ultracode 5.3.0 → 5.5.0

package/dist/chunks/merge-agent-LSUBDJB2.js

@@ -0,0 +1,2481 @@
+import { getGlobalContainer, getOrCreateAgent } from './chunk-RMZXFGQZ.js';
+import { BaseAgent } from './chunk-IGUCJL3R.js';
+import { cosineSimilarity } from './chunk-QN237S7C.js';
+import { init_fast_hash, hashText } from './chunk-HEMJHRHZ.js';
+import './chunk-GMVGCSNU.js';
+import { init_file_ops, readBytes } from './chunk-F7CKCMXI.js';
+import './chunk-BMHPPH2B.js';
+import { init_logging, log } from './chunk-VCCBEJQ5.js';
+import { __export, __esm, __toCommonJS } from './chunk-NAQKA54E.js';
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+// src/merge/indexing/content-normalizer.ts
+var content_normalizer_exports = {};
+__export(content_normalizer_exports, {
+  ContentNormalizer: () => ContentNormalizer
+});
+var ContentNormalizer;
+var init_content_normalizer = __esm({
+  "src/merge/indexing/content-normalizer.ts"() {
+    init_fast_hash();
+    init_file_ops();
+    ContentNormalizer = class {
+      /**
+       * Normalize a file.
+       *
+       * @param filePath - Absolute path to file
+       * @returns Normalized content with metadata
+       */
+      async normalize(filePath) {
+        const rawBytes = Buffer.from(await readBytes(filePath));
+        const { encoding, hasBom } = this.detectEncoding(rawBytes);
+        let content = rawBytes.toString(encoding);
+        if (hasBom && content.charCodeAt(0) === 65279) {
+          content = content.slice(1);
+        }
+        content = this.normalizeLineEndings(content);
+        content = this.trimTrailingWhitespace(content);
+        content = content.replace(/\n+$/, "\n");
+        return {
+          content,
+          originalEncoding: encoding,
+          hadBom: hasBom
+        };
+      }
+      /**
+       * Compute SHA256 hash of content.
+       *
+       * Used for Fast Path Level 1 matching (exact content match).
+       *
+       * @param content - Normalized content string
+       * @returns Hex-encoded SHA256 hash
+       */
+      computeContentHash(content) {
+        return hashText(content);
+      }
+      /**
+       * Detect encoding via BOM detection.
+       *
+       * @param bytes - Raw file bytes
+       * @returns Detected encoding and BOM presence
+       */
+      detectEncoding(bytes) {
+        if (bytes.length >= 3 && bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191) {
+          return { encoding: "utf8", hasBom: true };
+        }
+        if (bytes.length >= 2 && bytes[0] === 255 && bytes[1] === 254) {
+          return { encoding: "utf16le", hasBom: true };
+        }
+        if (bytes.length >= 2 && bytes[0] === 254 && bytes[1] === 255) {
+          return { encoding: "utf16le", hasBom: true };
+        }
+        return { encoding: "utf8", hasBom: false };
+      }
+      /**
+       * Normalize line endings (CRLF/CR → LF).
+       *
+       * @param content - Content with potentially mixed line endings
+       * @returns Content with Unix-style LF line endings
+       */
+      normalizeLineEndings(content) {
+        content = content.replace(/\r\n/g, "\n");
+        content = content.replace(/\r/g, "\n");
+        return content;
+      }
+      /**
+       * Remove trailing whitespace on each line.
+       *
+       * @param content - Content to trim
+       * @returns Content with trimmed lines
+       */
+      trimTrailingWhitespace(content) {
+        return content.split("\n").map((line) => line.replace(/[ \t]+$/, "")).join("\n");
+      }
+    };
+  }
+});
+
+// src/merge/models/code-unit.ts
+var code_unit_exports = {};
+__export(code_unit_exports, {
+  CodeUnitType: () => CodeUnitType
+});
+var CodeUnitType;
+var init_code_unit = __esm({
+  "src/merge/models/code-unit.ts"() {
+    CodeUnitType = /* @__PURE__ */ ((CodeUnitType2) => {
+      CodeUnitType2["File"] = "file";
+      CodeUnitType2["Module"] = "module";
+      CodeUnitType2["Class"] = "class";
+      CodeUnitType2["Interface"] = "interface";
+      CodeUnitType2["Function"] = "function";
+      CodeUnitType2["Method"] = "method";
+      CodeUnitType2["Property"] = "property";
+      CodeUnitType2["Block"] = "block";
+      CodeUnitType2["Statement"] = "statement";
+      return CodeUnitType2;
+    })(CodeUnitType || {});
+  }
+});
+
+// src/agents/merge-agent.ts
+init_logging();
+
+// src/merge/engine/ai-conflict-resolver.ts
+init_logging();
+
+// src/merge/models/semantic-conflict.ts
+function createOverlappingConflict(baseUnit, branchAUnit, branchBUnit) {
+  const id = `conflict-${branchAUnit.id}-${branchBUnit.id}-${Date.now()}`;
+  return {
+    id,
+    type: "OverlappingChanges" /* OverlappingChanges */,
+    severity: "Medium" /* Medium */,
+    baseUnit,
+    branchAUnit,
+    branchBUnit,
+    description: `Both branches modified ${branchAUnit.fullyQualifiedName}`,
+    conflictingRegions: [],
+    autoResolvable: false
+  };
+}
+function createIncompatibleIntentsConflict(baseUnit, branchAUnit, branchBUnit, branchAIntent, branchBIntent) {
+  const id = `conflict-${branchAUnit.id}-${branchBUnit.id}-${Date.now()}`;
+  return {
+    id,
+    type: "IncompatibleIntents" /* IncompatibleIntents */,
+    severity: "High" /* High */,
+    baseUnit,
+    branchAUnit,
+    branchBUnit,
+    branchAIntent,
+    branchBIntent,
+    description: `Incompatible intents: ${branchAIntent.type} vs ${branchBIntent.type}`,
+    conflictingRegions: [],
+    autoResolvable: false
+  };
+}
+function createAPIBreakingConflict(baseUnit, branchAUnit, branchBUnit) {
+  const id = `conflict-${branchAUnit.id}-${branchBUnit.id}-${Date.now()}`;
+  return {
+    id,
+    type: "APIBreakingChange" /* APIBreakingChange */,
+    severity: "Critical" /* Critical */,
+    baseUnit,
+    branchAUnit,
+    branchBUnit,
+    description: `API breaking change in ${branchAUnit.fullyQualifiedName}`,
+    conflictingRegions: [],
+    autoResolvable: false
+  };
+}
+
+// src/merge/engine/ai-conflict-resolver.ts
+var AIConflictResolver = class {
+  config;
+  embeddingCache = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Analyze a conflict using AI
+   *
+   * @param conflict - Conflict to analyze
+   * @returns AI analysis result
+   */
+  async analyzeConflict(conflict) {
+    const { baseUnit, branchAUnit, branchBUnit } = conflict;
+    const [baseEmbedding, branchAEmbedding, branchBEmbedding] = await Promise.all([
+      this.getEmbedding(baseUnit),
+      this.getEmbedding(branchAUnit),
+      this.getEmbedding(branchBUnit)
+    ]);
+    const similarity = this.cosineSimilarity(branchAEmbedding, branchBEmbedding);
+    const branchADistance = baseEmbedding && branchAEmbedding ? this.cosineDistance(baseEmbedding, branchAEmbedding) : 0;
+    const branchBDistance = baseEmbedding && branchBEmbedding ? this.cosineDistance(baseEmbedding, branchBEmbedding) : 0;
+    const { strategy, confidence, explanation, mergedCode } = this.determineStrategy(
+      conflict,
+      similarity,
+      branchADistance,
+      branchBDistance
+    );
+    return {
+      similarity,
+      branchADistance,
+      branchBDistance,
+      suggestedStrategy: strategy,
+      confidence,
+      explanation,
+      mergedCode
+    };
+  }
+  /**
+   * Get or generate embedding for a code unit
+   */
+  async getEmbedding(unit) {
+    if (!unit) return null;
+    const cacheKey = this.getCacheKey(unit);
+    if (this.embeddingCache.has(cacheKey)) {
+      return this.embeddingCache.get(cacheKey);
+    }
+    if (unit.embedding) {
+      this.embeddingCache.set(cacheKey, unit.embedding);
+      return unit.embedding;
+    }
+    try {
+      const text = this.prepareTextForEmbedding(unit);
+      const embedding = await this.config.embeddingGenerator.generateEmbedding(text);
+      this.embeddingCache.set(cacheKey, embedding);
+      return embedding;
+    } catch (error) {
+      log.w("AICONFLICT", "embedding_fail", { id: unit.id, err: String(error) });
+      return null;
+    }
+  }
+  /**
+   * Prepare text for embedding
+   */
+  prepareTextForEmbedding(unit) {
+    const parts = [];
+    if (unit.fullyQualifiedName) {
+      parts.push(`Name: ${unit.fullyQualifiedName}`);
+    }
+    if (unit.signature) {
+      parts.push(`Signature: ${unit.signature}`);
+    }
+    if (unit.content) {
+      const normalized = unit.content.trim().replace(/\s+/g, " ");
+      parts.push(`Code: ${normalized}`);
+    }
+    return parts.join("\n");
+  }
+  /**
+   * Determine resolution strategy based on similarity analysis
+   */
+  determineStrategy(conflict, similarity, branchADistance, branchBDistance) {
+    const { branchAUnit, branchBUnit } = conflict;
+    if (similarity >= this.config.highSimilarityThreshold) {
+      const preferA = branchADistance <= branchBDistance;
+      return {
+        strategy: preferA ? "TakeBranchA" /* TakeBranchA */ : "TakeBranchB" /* TakeBranchB */,
+        confidence: 0.95,
+        explanation: `Both branches made semantically similar changes (similarity: ${similarity.toFixed(2)}). Choosing ${preferA ? "branchA" : "branchB"} as it's closer to base.`,
+        mergedCode: preferA ? branchAUnit.content : branchBUnit.content
+      };
+    }
+    if (similarity >= this.config.mediumSimilarityThreshold) {
+      const mergedCode = this.attemptIntelligentMerge(conflict, similarity);
+      if (mergedCode) {
+        return {
+          strategy: "MergeBoth" /* MergeBoth */,
+          confidence: 0.7 + similarity * 0.2,
+          // 0.7-0.9 range
+          explanation: `Changes are semantically compatible (similarity: ${similarity.toFixed(2)}). AI-generated merge proposed.`,
+          mergedCode
+        };
+      }
+      return {
+        strategy: "ManualReview" /* ManualReview */,
+        confidence: 0.6,
+        explanation: `Changes are moderately similar (${similarity.toFixed(2)}) but automatic merge is uncertain. Manual review recommended.`
+      };
+    }
+    if (similarity >= this.config.lowSimilarityThreshold) {
+      return {
+        strategy: "ManualReview" /* ManualReview */,
+        confidence: 0.4,
+        explanation: `Changes are semantically different (similarity: ${similarity.toFixed(2)}). Manual review required.`
+      };
+    }
+    return {
+      strategy: "ManualReview" /* ManualReview */,
+      confidence: 0.2,
+      explanation: `Changes are semantically divergent (similarity: ${similarity.toFixed(2)}). Careful manual review strongly recommended.`
+    };
+  }
+  /**
+   * Attempt intelligent merge based on semantic analysis
+   *
+   * Heuristic: if changes are semantically close, try to combine them
+   */
+  attemptIntelligentMerge(conflict, similarity) {
+    const { baseUnit, branchAUnit, branchBUnit } = conflict;
+    const baseLength = baseUnit?.content.length || 0;
+    const branchALength = branchAUnit.content.length;
+    const branchBLength = branchBUnit.content.length;
+    const branchAAdded = branchALength > baseLength;
+    const branchBAdded = branchBLength > baseLength;
+    if (branchAAdded && branchBAdded && similarity >= 0.7) {
+      return branchALength > branchBLength ? branchAUnit.content : branchBUnit.content;
+    }
+    const maxChange = Math.max(Math.abs(branchALength - baseLength), Math.abs(branchBLength - baseLength));
+    if (maxChange < 100 && similarity >= 0.8) {
+      return branchAUnit.content;
+    }
+    return null;
+  }
+  /**
+   * Cosine similarity between two vectors (0-1, where 1 = identical)
+   */
+  cosineSimilarity(a, b) {
+    if (!a || !b || a.length !== b.length) return 0;
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+      const aVal = a[i] ?? 0;
+      const bVal = b[i] ?? 0;
+      dotProduct += aVal * bVal;
+      normA += aVal * aVal;
+      normB += bVal * bVal;
+    }
+    const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+    if (denominator === 0) return 0;
+    return dotProduct / denominator;
+  }
+  /**
+   * Cosine distance (1 - similarity)
+   */
+  cosineDistance(a, b) {
+    const similarity = this.cosineSimilarity(a, b);
+    return 1 - similarity;
+  }
+  /**
+   * Cache key for embedding
+   */
+  getCacheKey(unit) {
+    return `${unit.id}-${unit.contentHash}`;
+  }
+  /**
+   * Create Resolution based on AI analysis
+   */
+  createResolution(aiAnalysis) {
+    return {
+      strategy: aiAnalysis.suggestedStrategy,
+      confidence: aiAnalysis.confidence,
+      mergedCode: aiAnalysis.mergedCode || "",
+      explanation: aiAnalysis.explanation
+    };
+  }
+  /**
+   * Clear cache
+   */
+  clearCache() {
+    this.embeddingCache.clear();
+  }
+  /**
+   * Get cache statistics
+   */
+  getCacheStats() {
+    return {
+      size: this.embeddingCache.size,
+      maxSize: 1e3
+      // Can be made configurable
+    };
+  }
+};
+
+// src/merge/engine/three-way-merger.ts
+init_logging();
+
+// src/merge/models/change-intent.ts
+function createBugFixIntent(evidence) {
+  return {
+    type: "BugFix" /* BugFix */,
+    confidence: evidence.length > 0 ? Math.min(0.7 + evidence.length * 0.1, 1) : 0.5,
+    evidence,
+    description: "Code change appears to fix a bug"
+  };
+}
+function createRefactoringIntent(evidence) {
+  return {
+    type: "Refactoring" /* Refactoring */,
+    confidence: evidence.length > 0 ? Math.min(0.7 + evidence.length * 0.1, 1) : 0.5,
+    evidence,
+    description: "Code change is refactoring without logic changes"
+  };
+}
+function createFeatureAdditionIntent(evidence) {
+  return {
+    type: "FeatureAddition" /* FeatureAddition */,
+    confidence: evidence.length > 0 ? Math.min(0.7 + evidence.length * 0.1, 1) : 0.5,
+    evidence,
+    description: "Code change adds new functionality"
+  };
+}
+function createAPIChangeIntent(evidence) {
+  return {
+    type: "APIChange" /* APIChange */,
+    confidence: evidence.length > 0 ? Math.min(0.7 + evidence.length * 0.1, 1) : 0.5,
+    evidence,
+    description: "Code change modifies API signatures"
+  };
+}
+function createUnknownIntent() {
+  return {
+    type: "Unknown" /* Unknown */,
+    confidence: 0,
+    evidence: [],
+    description: "Unable to classify change intent"
+  };
+}
+
+// src/merge/analysis/conflict-detector.ts
+var ConflictDetector = class {
+  /**
+   * Determine whether there is a conflict between two changes
+   *
+   * @param baseUnit - Unit in base (may be null)
+   * @param branchAUnit - Unit in branchA
+   * @param branchBUnit - Unit in branchB
+   * @param branchAIntent - Change intent in branchA (optional)
+   * @param branchBIntent - Change intent in branchB (optional)
+   * @returns SemanticConflict if there is a conflict, null if not
+   */
+  detectConflict(baseUnit, branchAUnit, branchBUnit, branchAIntent, branchBIntent) {
+    if (branchAUnit.contentHash === branchBUnit.contentHash) {
+      return null;
+    }
+    const apiConflict = this.detectAPIConflict(baseUnit, branchAUnit, branchBUnit);
+    if (apiConflict) {
+      return apiConflict;
+    }
+    if (branchAIntent && branchBIntent) {
+      const intentConflict = this.detectIntentConflict(
+        baseUnit,
+        branchAUnit,
+        branchBUnit,
+        branchAIntent,
+        branchBIntent
+      );
+      if (intentConflict) {
+        return intentConflict;
+      }
+    }
+    const conflict = createOverlappingConflict(baseUnit, branchAUnit, branchBUnit);
+    conflict.severity = this.classifySeverity(baseUnit, branchAUnit, branchBUnit);
+    conflict.autoResolvable = this.isAutoResolvable(conflict, branchAIntent, branchBIntent);
+    return conflict;
+  }
+  /**
+   * Detect API breaking changes
+   */
+  detectAPIConflict(baseUnit, branchAUnit, branchBUnit) {
+    if (!baseUnit) return null;
+    const branchASignatureChanged = baseUnit.signature !== branchAUnit.signature;
+    const branchBSignatureChanged = baseUnit.signature !== branchBUnit.signature;
+    if (branchASignatureChanged && branchBSignatureChanged) {
+      return createAPIBreakingConflict(baseUnit, branchAUnit, branchBUnit);
+    }
+    const branchAFQNChanged = baseUnit.fullyQualifiedName !== branchAUnit.fullyQualifiedName;
+    const branchBFQNChanged = baseUnit.fullyQualifiedName !== branchBUnit.fullyQualifiedName;
+    if (branchAFQNChanged && branchBFQNChanged) {
+      return createAPIBreakingConflict(baseUnit, branchAUnit, branchBUnit);
+    }
+    return null;
+  }
+  /**
+   * Detect intent conflict
+   */
+  detectIntentConflict(baseUnit, branchAUnit, branchBUnit, branchAIntent, branchBIntent) {
+    const compatible = this.areIntentsCompatible(branchAIntent.type, branchBIntent.type);
+    if (!compatible) {
+      return createIncompatibleIntentsConflict(baseUnit, branchAUnit, branchBUnit, branchAIntent, branchBIntent);
+    }
+    return null;
+  }
+  /**
+   * Check intent compatibility
+   */
+  areIntentsCompatible(intentA, intentB) {
+    const compatibilityMatrix = {
+      ["BugFix" /* BugFix */]: /* @__PURE__ */ new Set([
+        "BugFix" /* BugFix */,
+        // Two bug fixes are usually compatible
+        "Refactoring" /* Refactoring */
+        // BugFix + Refactoring = OK
+      ]),
+      ["Refactoring" /* Refactoring */]: /* @__PURE__ */ new Set(["BugFix" /* BugFix */, "Refactoring" /* Refactoring */]),
+      ["FeatureAddition" /* FeatureAddition */]: /* @__PURE__ */ new Set([
+        "FeatureAddition" /* FeatureAddition */
+        // Two feature additions can be compatible
+      ]),
+      ["APIChange" /* APIChange */]: /* @__PURE__ */ new Set([
+        // API changes are usually incompatible with other changes
+      ]),
+      ["Unknown" /* Unknown */]: /* @__PURE__ */ new Set(["Unknown" /* Unknown */])
+    };
+    const compatibleWith = compatibilityMatrix[intentA];
+    return compatibleWith ? compatibleWith.has(intentB) : false;
+  }
+  /**
+   * Classify conflict severity
+   */
+  classifySeverity(baseUnit, branchAUnit, branchBUnit) {
+    if (!baseUnit) {
+      return "Medium" /* Medium */;
+    }
+    const branchADiff = this.computeDifference(baseUnit.content, branchAUnit.content);
+    const branchBDiff = this.computeDifference(baseUnit.content, branchBUnit.content);
+    if (branchADiff > 0.5 && branchBDiff > 0.5) {
+      return "High" /* High */;
+    }
+    if (branchADiff > 0.3 || branchBDiff > 0.3) {
+      return "Medium" /* Medium */;
+    }
+    return "Low" /* Low */;
+  }
+  /**
+   * Compute difference between two code versions (0.0-1.0)
+   */
+  computeDifference(baseContent, changedContent) {
+    const maxLength = Math.max(baseContent.length, changedContent.length);
+    if (maxLength === 0) return 0;
+    const lengthDiff = Math.abs(baseContent.length - changedContent.length);
+    return Math.min(lengthDiff / maxLength, 1);
+  }
+  /**
+   * Check whether the conflict can be automatically resolved
+   */
+  isAutoResolvable(conflict, branchAIntent, branchBIntent) {
+    if (conflict.severity === "Critical" /* Critical */) {
+      return false;
+    }
+    if (conflict.type === "APIBreakingChange" /* APIBreakingChange */) {
+      return false;
+    }
+    if (branchAIntent && branchBIntent && this.areIntentsCompatible(branchAIntent.type, branchBIntent.type) && conflict.severity === "Low" /* Low */) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Batch detection for multiple unit pairs
+   */
+  detectConflicts(matches) {
+    const conflicts = [];
+    for (const match of matches) {
+      const conflict = this.detectConflict(
+        match.baseUnit,
+        match.branchAUnit,
+        match.branchBUnit,
+        match.branchAIntent,
+        match.branchBIntent
+      );
+      if (conflict) {
+        conflicts.push(conflict);
+      }
+    }
+    return conflicts;
+  }
+};
+
+// src/merge/analysis/intent-classifier.ts
+var IntentClassifier = class {
+  /**
+   * Classify the change intent
+   *
+   * @param baseUnit - Unit before the change (may be null for new units)
+   * @param changedUnit - Unit after the change
+   * @returns ChangeIntent with type and confidence
+   */
+  classifyIntent(baseUnit, changedUnit) {
+    if (!baseUnit) {
+      return this.classifyNewUnit(changedUnit);
+    }
+    const bugFixEvidence = this.collectBugFixEvidence(baseUnit, changedUnit);
+    const refactoringEvidence = this.collectRefactoringEvidence(baseUnit, changedUnit);
+    const featureEvidence = this.collectFeatureAdditionEvidence(baseUnit, changedUnit);
+    const apiChangeEvidence = this.collectAPIChangeEvidence(baseUnit, changedUnit);
+    const evidenceCounts = [
+      { type: "BugFix" /* BugFix */, evidence: bugFixEvidence, count: bugFixEvidence.length },
+      {
+        type: "Refactoring" /* Refactoring */,
+        evidence: refactoringEvidence,
+        count: refactoringEvidence.length
+      },
+      {
+        type: "FeatureAddition" /* FeatureAddition */,
+        evidence: featureEvidence,
+        count: featureEvidence.length
+      },
+      {
+        type: "APIChange" /* APIChange */,
+        evidence: apiChangeEvidence,
+        count: apiChangeEvidence.length
+      }
+    ];
+    evidenceCounts.sort((a, b) => b.count - a.count);
+    const winner = evidenceCounts[0];
+    if (!winner || winner.count === 0) {
+      return createUnknownIntent();
+    }
+    switch (winner.type) {
+      case "BugFix" /* BugFix */:
+        return createBugFixIntent(bugFixEvidence);
+      case "Refactoring" /* Refactoring */:
+        return createRefactoringIntent(refactoringEvidence);
+      case "FeatureAddition" /* FeatureAddition */:
+        return createFeatureAdditionIntent(featureEvidence);
+      case "APIChange" /* APIChange */:
+        return createAPIChangeIntent(apiChangeEvidence);
+      default:
+        return createUnknownIntent();
+    }
+  }
+  /**
+   * Classify a new unit (baseUnit === null)
+   */
+  classifyNewUnit(changedUnit) {
+    const evidence = [];
+    if (changedUnit.type === "class") {
+      evidence.push({
+        type: "NewClass" /* NewClass */,
+        description: `Added new class: ${changedUnit.name}`,
+        location: `${changedUnit.filePath}:${changedUnit.startLine}`
+      });
+    } else if (changedUnit.type === "function" || changedUnit.type === "method") {
+      evidence.push({
+        type: "NewMethod" /* NewMethod */,
+        description: `Added new method: ${changedUnit.name}`,
+        location: `${changedUnit.filePath}:${changedUnit.startLine}`
+      });
+    } else if (changedUnit.type === "property") {
+      evidence.push({
+        type: "NewProperty" /* NewProperty */,
+        description: `Added new property: ${changedUnit.name}`,
+        location: `${changedUnit.filePath}:${changedUnit.startLine}`
+      });
+    }
+    return createFeatureAdditionIntent(evidence);
+  }
+  /**
+   * Collect BugFix evidence
+   */
+  collectBugFixEvidence(baseUnit, changedUnit) {
+    const evidence = [];
+    const baseContent = baseUnit.content.toLowerCase();
+    const changedContent = changedUnit.content.toLowerCase();
+    if (!baseContent.includes("try") && changedContent.includes("try")) {
+      evidence.push({
+        type: "AddedTryCatch" /* AddedTryCatch */,
+        description: "Added try-catch block for error handling",
+        location: `${changedUnit.filePath}:${changedUnit.startLine}`
+      });
+    }
+    const baseIfCount = (baseContent.match(/\bif\s*\(/g) || []).length;
+    const changedIfCount = (changedContent.match(/\bif\s*\(/g) || []).length;
+    if (changedIfCount > baseIfCount) {
+      evidence.push({
+        type: "AddedValidation" /* AddedValidation */,
+        description: `Added validation checks (+${changedIfCount - baseIfCount} if statements)`,
+        location: `${changedUnit.filePath}:${changedUnit.startLine}`
+      });
+    }
+    const hasNullCheck = changedContent.includes("!= null") || changedContent.includes("!== null") || changedContent.includes("== null") || changedContent.includes("=== null");
+    if (hasNullCheck && !baseContent.includes("null")) {
+      evidence.push({
+        type: "AddedNullCheck" /* AddedNullCheck */,
+        description: "Added null/undefined check",
+        location: `${changedUnit.filePath}:${changedUnit.startLine}`
+      });
+    }
+    return evidence;
+  }
+  /**
+   * Collect Refactoring evidence
+   */
+  collectRefactoringEvidence(baseUnit, changedUnit) {
+    const evidence = [];
+    if (baseUnit.name !== changedUnit.name && baseUnit.structuralHash === changedUnit.structuralHash) {
+      evidence.push({
+        type: "RenamedVariable" /* RenamedVariable */,
+        description: `Renamed ${baseUnit.name} to ${changedUnit.name}`,
+        location: `${changedUnit.filePath}:${changedUnit.startLine}`
+      });
+    }
+    if (baseUnit.structuralHash === changedUnit.structuralHash && baseUnit.contentHash !== changedUnit.contentHash) {
+      evidence.push({
+        type: "CFGPreserved" /* CFGPreserved */,
+        description: "Code structure preserved (likely refactoring)",
+        location: `${changedUnit.filePath}:${changedUnit.startLine}`
+      });
+    }
+    return evidence;
+  }
+  /**
+   * Collect FeatureAddition evidence
+   */
+  collectFeatureAdditionEvidence(baseUnit, changedUnit) {
+    const evidence = [];
+    const newChildren = changedUnit.childIds.length - baseUnit.childIds.length;
+    if (newChildren > 0) {
+      evidence.push({
+        type: "NewMethod" /* NewMethod */,
+        description: `Added ${newChildren} new methods/properties`,
+        location: `${changedUnit.filePath}:${changedUnit.startLine}`
+      });
+    }
+    const sizeIncrease = (changedUnit.content.length - baseUnit.content.length) / baseUnit.content.length;
+    if (sizeIncrease > 0.3) {
+      evidence.push({
+        type: "NewMethod" /* NewMethod */,
+        description: `Code size increased by ${Math.round(sizeIncrease * 100)}%`,
+        location: `${changedUnit.filePath}:${changedUnit.startLine}`
+      });
+    }
+    return evidence;
+  }
+  /**
+   * Collect APIChange evidence
+   */
+  collectAPIChangeEvidence(baseUnit, changedUnit) {
+    const evidence = [];
+    if (baseUnit.signature && changedUnit.signature && baseUnit.signature !== changedUnit.signature) {
+      evidence.push({
+        type: "SignatureChanged" /* SignatureChanged */,
+        description: `Signature changed: ${baseUnit.signature} \u2192 ${changedUnit.signature}`,
+        location: `${changedUnit.filePath}:${changedUnit.startLine}`
+      });
+    }
+    if (baseUnit.fullyQualifiedName !== changedUnit.fullyQualifiedName) {
+      evidence.push({
+        type: "SignatureChanged" /* SignatureChanged */,
+        description: `Fully qualified name changed: ${baseUnit.fullyQualifiedName} \u2192 ${changedUnit.fullyQualifiedName}`,
+        location: `${changedUnit.filePath}:${changedUnit.startLine}`
+      });
+    }
+    return evidence;
+  }
+};
+
+// src/merge/indexing/lazy-embedding-cache.ts
+var LazyEmbeddingCache = class {
+  embeddingGenerator;
+  cache = /* @__PURE__ */ new Map();
+  // In-memory cache
+  batchSize;
+  constructor(embeddingGenerator, options = {}) {
+    this.embeddingGenerator = embeddingGenerator;
+    this.batchSize = options.batchSize ?? 32;
+  }
+  /**
+   * Generate embeddings for units in the index.
+   *
+   * Only for units without embeddings (lazy generation).
+   *
+   * @param index - Versioned index
+   * @param unitsNeedingEmbeddings - Units that need embeddings
+   * @returns Promise that resolves when done
+   */
+  async generateEmbeddings(index, unitsNeedingEmbeddings) {
+    const unitsToProcess = unitsNeedingEmbeddings.filter((unit) => !unit.embedding);
+    if (unitsToProcess.length === 0) {
+      return;
+    }
+    for (let i = 0; i < unitsToProcess.length; i += this.batchSize) {
+      const batch = unitsToProcess.slice(i, i + this.batchSize);
+      await Promise.all(
+        batch.map(async (unit) => {
+          const embedding = await this.getOrGenerateEmbedding(unit);
+          unit.embedding = embedding;
+          index.units.set(unit.id, unit);
+        })
+      );
+    }
+  }
+  /**
+   * Get embedding from cache or generate a new one.
+   */
+  async getOrGenerateEmbedding(unit) {
+    const cacheKey = this.computeCacheKey(unit);
+    const cached = this.cache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    const embedding = await this.embeddingGenerator(unit.content);
+    this.cache.set(cacheKey, embedding);
+    return embedding;
+  }
+  /**
+   * Compute cache key for a unit.
+   *
+   * Based on contentHash (same content = same embedding).
+   */
+  computeCacheKey(unit) {
+    return unit.contentHash;
+  }
+  /**
+   * Clear in-memory cache.
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+  /**
+   * Get cache statistics.
+   */
+  getCacheStats() {
+    return {
+      size: this.cache.size,
+      memoryUsage: this.estimateMemoryUsage()
+    };
+  }
+  /**
+   * Estimate cache memory usage (bytes).
+   */
+  estimateMemoryUsage() {
+    const bytesPerEmbedding = 384 * 4 + 100;
+    return this.cache.size * bytesPerEmbedding;
+  }
+};
+
+// src/merge/indexing/multi-version-indexer.ts
+init_logging();
+var MultiVersionIndexer = class {
+  branchManager;
+  gitIntegration;
+  conductor;
+  constructor(branchManager, gitIntegration, conductor) {
+    this.branchManager = branchManager;
+    this.gitIntegration = gitIntegration;
+    this.conductor = conductor;
+  }
+  /**
+   * Index 3 branches for merge: base, branchA, branchB
+   *
+   * This is the main entry point for Phase 4.
+   */
+  async indexThreeBranches(branchA, branchB, options = {}) {
+    const startTime = Date.now();
+    let cacheHits = 0;
+    log.i("MULTIVIDX", `[MultiVersionIndexer] Starting 3-way indexing: ${branchA} + ${branchB}`);
+    try {
+      const mergeBase = this.gitIntegration.getMergeBase(branchA, branchB);
+      if (!mergeBase) {
+        throw new Error(`No merge base found between ${branchA} and ${branchB}`);
+      }
+      log.i("MULTIVIDX", `[MultiVersionIndexer] Merge base: ${mergeBase.slice(0, 8)}`);
+      const baseIndex = await this.indexBranch(mergeBase, "base", options);
+      if (this.wasCacheHit(baseIndex)) cacheHits++;
+      const branchAIndex = await this.indexBranch(branchA, branchA, options);
+      if (this.wasCacheHit(branchAIndex)) cacheHits++;
+      const branchBIndex = await this.indexBranch(branchB, branchB, options);
+      if (this.wasCacheHit(branchBIndex)) cacheHits++;
+      await this.gitIntegration.restoreOriginalBranch();
+      const totalUnits = baseIndex.stats.totalUnits + branchAIndex.stats.totalUnits + branchBIndex.stats.totalUnits;
+      const totalFiles = (baseIndex.stats.byFile?.size || 0) + (branchAIndex.stats.byFile?.size || 0) + (branchBIndex.stats.byFile?.size || 0);
+      const indexingTimeMs = Date.now() - startTime;
+      log.i("MULTIVIDX", `[MultiVersionIndexer] Completed in ${indexingTimeMs}ms`);
+      log.i("MULTIVIDX", `[MultiVersionIndexer] Total units: ${totalUnits}, Cache hits: ${cacheHits}/3`);
+      return {
+        base: baseIndex,
+        branchA: branchAIndex,
+        branchB: branchBIndex,
+        mergeBase,
+        stats: {
+          totalUnits,
+          totalFiles,
+          indexingTimeMs,
+          cacheHits
+        }
+      };
+    } catch (error) {
+      await this.gitIntegration.cleanup();
+      throw error;
+    }
+  }
+  /**
+   * Index a single branch
+   *
+   * Strategy:
+   * 1. Check if branch DB exists and is up-to-date
+   * 2. If yes → load from cache
+   * 3. If no → checkout branch, run full index, save to cache
+   */
+  async indexBranch(branch, label, options) {
+    log.i("MULTIVIDX", `[MultiVersionIndexer] Indexing ${label}...`);
+    if (!options.fullScan && !options.reset) {
+      const cachedIndex = await this.loadCachedIndex(branch);
+      if (cachedIndex) {
+        log.i("MULTIVIDX", `[MultiVersionIndexer] Loaded ${label} from cache`);
+        return cachedIndex;
+      }
+    }
+    const startTime = Date.now();
+    await this.gitIntegration.checkoutBranch(branch);
+    if (!this.conductor) {
+      throw new Error("ConductorOrchestrator is required for fresh indexing");
+    }
+    const container = getGlobalContainer();
+    const devAgent = await getOrCreateAgent(container, this.conductor, "dev" /* DEV */);
+    const index = await this.runIndexing(devAgent, branch, options);
+    await this.saveCachedIndex(branch, index);
+    const elapsed = Date.now() - startTime;
+    log.i("MULTIVIDX", `[MultiVersionIndexer] Indexed ${label} in ${elapsed}ms (${index.stats.totalUnits} units)`);
+    return index;
+  }
+  /**
+   * Run actual indexing using DevAgent
+   */
+  async runIndexing(devAgent, branch, options) {
+    const repoPath = this.gitIntegration.repoPath;
+    const result = await devAgent.execute?.({
+      task: "index_codebase",
+      params: {
+        directory: repoPath,
+        incremental: options.incremental ?? true,
+        fullScan: options.fullScan ?? false,
+        excludePatterns: options.excludePatterns || [],
+        reset: options.reset ?? false
+      }
+    });
+    const index = {
+      branch,
+      indexedAt: /* @__PURE__ */ new Date(),
+      units: /* @__PURE__ */ new Map(),
+      contentHashIndex: /* @__PURE__ */ new Map(),
+      structuralHashIndex: /* @__PURE__ */ new Map(),
+      signatureIndex: /* @__PURE__ */ new Map(),
+      filePathIndex: /* @__PURE__ */ new Map(),
+      stats: {
+        totalUnits: 0,
+        byType: /* @__PURE__ */ new Map(),
+        byLanguage: /* @__PURE__ */ new Map(),
+        byFile: /* @__PURE__ */ new Map()
+      }
+    };
+    if (result?.entities) {
+      for (const entity of result.entities) {
+        const codeUnit = this.entityToCodeUnit(entity);
+        this.addUnitToIndex(index, codeUnit);
+      }
+    } else {
+      await this.populateIndexFromStorage(index);
+    }
+    return index;
+  }
+  /**
+   * Convert entity from DevAgent to CodeUnit
+   */
+  entityToCodeUnit(entity) {
+    const { ContentNormalizer: ContentNormalizer2 } = (init_content_normalizer(), __toCommonJS(content_normalizer_exports));
+    const normalizer = new ContentNormalizer2();
+    const content = entity.content || "";
+    const contentHash = normalizer.computeContentHash(content);
+    return {
+      id: entity.id,
+      type: this.mapEntityType(entity.type),
+      filePath: entity.filePath || "",
+      name: entity.name || "",
+      fullyQualifiedName: entity.fullyQualifiedName || entity.name || "",
+      startLine: entity.startLine || 1,
+      endLine: entity.endLine || 1,
+      content,
+      contentHash,
+      structuralHash: entity.structuralHash || contentHash,
+      signature: entity.signature,
+      language: entity.language || "unknown",
+      parentId: entity.parentId,
+      childIds: entity.childIds || [],
+      metadata: entity.metadata || {}
+    };
+  }
+  /**
+   * Map entity type string to CodeUnitType
+   */
+  mapEntityType(type) {
+    const { CodeUnitType: CodeUnitType2 } = (init_code_unit(), __toCommonJS(code_unit_exports));
+    const typeMap = {
+      file: CodeUnitType2.File,
+      module: CodeUnitType2.Module,
+      class: CodeUnitType2.Class,
+      interface: CodeUnitType2.Interface,
+      function: CodeUnitType2.Function,
+      method: CodeUnitType2.Method,
+      property: CodeUnitType2.Property
+    };
+    return typeMap[type?.toLowerCase()] || CodeUnitType2.Block;
+  }
+  /**
+   * Add a CodeUnit to the index with all hash indexes
+   */
+  addUnitToIndex(index, unit) {
+    index.units.set(unit.id, unit);
+    if (!index.contentHashIndex.has(unit.contentHash)) {
+      index.contentHashIndex.set(unit.contentHash, []);
+    }
+    index.contentHashIndex.get(unit.contentHash).push(unit.id);
+    if (!index.structuralHashIndex.has(unit.structuralHash)) {
+      index.structuralHashIndex.set(unit.structuralHash, []);
+    }
+    index.structuralHashIndex.get(unit.structuralHash).push(unit.id);
+    if (unit.signature) {
+      if (!index.signatureIndex.has(unit.signature)) {
+        index.signatureIndex.set(unit.signature, []);
+      }
+      index.signatureIndex.get(unit.signature).push(unit.id);
+    }
+    if (!index.filePathIndex.has(unit.filePath)) {
+      index.filePathIndex.set(unit.filePath, []);
+    }
+    index.filePathIndex.get(unit.filePath).push(unit.id);
+    index.stats.totalUnits++;
+    index.stats.byType.set(unit.type, (index.stats.byType.get(unit.type) || 0) + 1);
+    index.stats.byLanguage.set(unit.language, (index.stats.byLanguage.get(unit.language) || 0) + 1);
+    index.stats.byFile.set(unit.filePath, (index.stats.byFile.get(unit.filePath) || 0) + 1);
+  }
+  /**
+   * Populate index from GraphStorage (fallback when DevAgent result is unavailable)
+   */
+  async populateIndexFromStorage(index) {
+    try {
+      const storage = this.conductor.getGraphStorage?.();
+      if (!storage) {
+        log.w("MULTIVIDX", "[MultiVersionIndexer] GraphStorage not available for fallback");
+        return;
+      }
+      const entities = await storage.getAllEntities?.();
+      if (!entities || entities.length === 0) {
+        log.w("MULTIVIDX", "[MultiVersionIndexer] No entities found in GraphStorage");
+        return;
+      }
+      for (const entity of entities) {
+        const codeUnit = this.entityToCodeUnit(entity);
+        this.addUnitToIndex(index, codeUnit);
+      }
+      log.i("MULTIVIDX", "storage_loaded", { units: index.stats.totalUnits });
+    } catch (error) {
+      log.e("MULTIVIDX", "storage_populate_fail", { err: String(error) });
+    }
+  }
+  /**
+   * Load cached index for a branch
+   */
+  async loadCachedIndex(branch) {
+    try {
+      if (!this.branchManager.hasBranchDatabase(branch)) {
+        return null;
+      }
+      const metadata = this.branchManager.getBranchMetadata(branch);
+      if (!metadata) {
+        return null;
+      }
+      const currentCommit = this.gitIntegration.getCommitHash(branch);
+      if (metadata.lastCommitHash !== currentCommit) {
+        log.i(
+          "MULTIVIDX",
+          `[MultiVersionIndexer] Cache outdated for ${branch} (${metadata.lastCommitHash?.slice(0, 8)} vs ${currentCommit.slice(0, 8)})`
+        );
+        return null;
+      }
+      const index = {
+        branch,
+        indexedAt: new Date(metadata.lastIndexedAt),
+        units: /* @__PURE__ */ new Map(),
+        contentHashIndex: /* @__PURE__ */ new Map(),
+        structuralHashIndex: /* @__PURE__ */ new Map(),
+        signatureIndex: /* @__PURE__ */ new Map(),
+        filePathIndex: /* @__PURE__ */ new Map(),
+        stats: {
+          totalUnits: 0,
+          byType: /* @__PURE__ */ new Map(),
+          byLanguage: /* @__PURE__ */ new Map(),
+          byFile: /* @__PURE__ */ new Map()
+        }
+      };
+      index.stats.totalUnits = metadata.entityCount;
+      index._fromCache = true;
+      return index;
+    } catch (error) {
+      log.e("MULTIVIDX", "cache_load_fail", { branch, err: String(error) });
+      return null;
+    }
+  }
+  /**
+   * Save index to branch cache
+   */
+  async saveCachedIndex(branch, index) {
+    try {
+      const repoPath = this.gitIntegration.repoPath;
+      const commitHash = this.gitIntegration.getCommitHash(branch);
+      const repoHash = this.branchManager.getRepositoryHash(repoPath);
+      this.branchManager.updateBranchMetadata({
+        branch,
+        repositoryPath: repoPath,
+        repositoryHash: repoHash,
+        lastCommitHash: commitHash,
+        lastIndexedAt: Date.now(),
+        fileCount: index.stats.byFile?.size || 0,
+        entityCount: index.stats.totalUnits,
+        relationshipCount: 0,
+        // TODO: Track relationships
+        indexVersion: "1.0.0",
+        accessedAt: Date.now()
+      });
+      log.i("MULTIVIDX", "cache_saved", { branch, commit: commitHash.slice(0, 8) });
+    } catch (error) {
+      log.e("MULTIVIDX", "cache_save_fail", { branch, err: String(error) });
+    }
+  }
+  /**
+   * Check if index was loaded from cache
+   */
+  wasCacheHit(index) {
+    return index._fromCache === true;
+  }
+};
+
+// src/merge/matching/fast-path-matcher.ts
+var FastPathMatcher = class {
+  /**
+   * Perform bulk matching between two indices.
+   *
+   * @param baseIndex - Base version index
+   * @param targetIndex - Target version index (branchA or branchB)
+   * @returns Map of targetUnitId → Match result
+   */
+  bulkMatch(baseIndex, targetIndex) {
+    const results = /* @__PURE__ */ new Map();
+    for (const [targetId, targetUnit] of targetIndex.units) {
+      const match = this.findMatch(targetUnit, baseIndex);
+      if (match) {
+        results.set(targetId, match);
+      }
+    }
+    return results;
+  }
+  /**
+   * Find match for a single unit in the base index.
+   *
+   * Tries levels in order: Exact → Structural → Signature → ID
+   */
+  findMatch(targetUnit, baseIndex) {
+    const exactMatch = this.tryExactMatch(targetUnit, baseIndex);
+    if (exactMatch) {
+      return {
+        baseUnitId: exactMatch.id,
+        baseUnit: exactMatch,
+        level: "exact_content" /* ExactContent */,
+        confidence: 1
+      };
+    }
+    const structuralMatch = this.tryStructuralMatch(targetUnit, baseIndex);
+    if (structuralMatch) {
+      return {
+        baseUnitId: structuralMatch.id,
+        baseUnit: structuralMatch,
+        level: "structural" /* Structural */,
+        confidence: 0.95
+      };
+    }
+    if (targetUnit.signature) {
+      const signatureMatch = this.trySignatureMatch(targetUnit, baseIndex);
+      if (signatureMatch) {
+        return {
+          baseUnitId: signatureMatch.id,
+          baseUnit: signatureMatch,
+          level: "signature" /* Signature */,
+          confidence: 0.85
+        };
+      }
+    }
+    const idMatch = this.tryIdMatch(targetUnit, baseIndex);
+    if (idMatch) {
+      return {
+        baseUnitId: idMatch.id,
+        baseUnit: idMatch,
+        level: "id" /* Id */,
+        confidence: 0.7
+      };
+    }
+    return void 0;
+  }
+  /**
+   * Level 1: Exact Content Match.
+   *
+   * Matches if contentHash is identical (byte-for-byte same code).
+   */
+  tryExactMatch(targetUnit, baseIndex) {
+    const candidates = baseIndex.contentHashIndex.get(targetUnit.contentHash);
+    if (!candidates || candidates.length === 0) {
+      return void 0;
+    }
+    if (candidates.length === 1) {
+      const firstId2 = candidates[0];
+      return firstId2 ? baseIndex.units.get(firstId2) : void 0;
+    }
+    const sameFileCandidate = candidates.find((id) => {
+      const unit = baseIndex.units.get(id);
+      return unit?.filePath === targetUnit.filePath;
+    });
+    if (sameFileCandidate) {
+      return baseIndex.units.get(sameFileCandidate);
+    }
+    const firstId = candidates[0];
+    return firstId ? baseIndex.units.get(firstId) : void 0;
+  }
+  /**
+   * Level 2: Structural Match.
+   *
+   * Matches if structuralHash is identical (same AST structure).
+   * Ignores whitespace, comments, formatting.
+   */
+  tryStructuralMatch(targetUnit, baseIndex) {
+    const candidates = baseIndex.structuralHashIndex.get(targetUnit.structuralHash);
+    if (!candidates || candidates.length === 0) {
+      return void 0;
+    }
+    const typedCandidates = candidates.filter((id) => {
+      const unit = baseIndex.units.get(id);
+      return unit?.type === targetUnit.type;
+    });
+    if (typedCandidates.length === 0) {
+      return void 0;
+    }
+    const bestCandidate = typedCandidates.find((id) => {
+      const unit = baseIndex.units.get(id);
+      return unit?.filePath === targetUnit.filePath && unit?.name === targetUnit.name;
+    });
+    if (bestCandidate) {
+      return baseIndex.units.get(bestCandidate);
+    }
+    const firstId = typedCandidates[0];
+    return firstId ? baseIndex.units.get(firstId) : void 0;
+  }
+  /**
+   * Level 3: Signature Match.
+   *
+   * Matches if signature is identical (FQN + params for functions).
+   * Useful for renamed/moved code with same signature.
+   */
+  trySignatureMatch(targetUnit, baseIndex) {
+    if (!targetUnit.signature) {
+      return void 0;
+    }
+    const candidates = baseIndex.signatureIndex.get(targetUnit.signature);
+    if (!candidates || candidates.length === 0) {
+      return void 0;
+    }
+    const typedCandidates = candidates.filter((id) => {
+      const unit = baseIndex.units.get(id);
+      return unit?.type === targetUnit.type;
+    });
+    if (typedCandidates.length === 0) {
+      return void 0;
+    }
+    const firstCandidate = typedCandidates[0];
+    if (!firstCandidate) {
+      return void 0;
+    }
+    return baseIndex.units.get(firstCandidate);
+  }
+  /**
+   * Level 4: ID Match.
+   *
+   * Matches by stable ID (based on FQN).
+   * Only used as last resort - code may have changed significantly.
+   */
+  tryIdMatch(targetUnit, baseIndex) {
+    const candidate = baseIndex.units.get(targetUnit.id);
+    if (candidate && candidate.fullyQualifiedName === targetUnit.fullyQualifiedName) {
+      return candidate;
+    }
+    return void 0;
+  }
+  /**
+   * Compute Fast Path coverage statistics.
+   */
+  computeStatistics(matchResults, totalUnits) {
+    const byLevel = /* @__PURE__ */ new Map();
+    for (const result of matchResults.values()) {
+      byLevel.set(result.level, (byLevel.get(result.level) || 0) + 1);
+    }
+    const totalMatched = matchResults.size;
+    const coverage = totalUnits > 0 ? totalMatched / totalUnits : 0;
+    return {
+      totalUnits,
+      totalMatched,
+      coverage,
+      exactContentMatches: byLevel.get("exact_content" /* ExactContent */) || 0,
+      structuralMatches: byLevel.get("structural" /* Structural */) || 0,
+      signatureMatches: byLevel.get("signature" /* Signature */) || 0,
+      idMatches: byLevel.get("id" /* Id */) || 0
+    };
+  }
+};
+
+// src/merge/matching/semantic-matcher.ts
+var SemanticMatcher = class {
+  /**
+   * Find semantic match for a unit in the base index.
+   *
+   * @param targetUnit - Target unit to match (must have embedding)
+   * @param baseIndex - Base version index (units must have embeddings)
+   * @param threshold - Minimum similarity threshold (0.0-1.0), default 0.7
+   * @returns Match result or undefined if no match above threshold
+   */
+  findMatch(targetUnit, baseIndex, threshold = 0.7) {
+    if (!targetUnit.embedding) {
+      throw new Error(`Target unit ${targetUnit.id} missing embedding. Use LazyEmbeddingCache to generate.`);
+    }
+    const candidates = this.findCandidates(targetUnit, baseIndex);
+    if (candidates.length === 0) {
+      return void 0;
+    }
+    const similarities = candidates.map((candidate) => {
+      const vectorSim = this.computeVectorSimilarity(targetUnit.embedding, candidate.embedding);
+      const structuralSim = this.computeStructuralSimilarity(targetUnit, candidate);
+      const combinedScore = vectorSim * 0.7 + structuralSim * 0.3;
+      return {
+        candidate,
+        vectorSimilarity: vectorSim,
+        structuralSimilarity: structuralSim,
+        combinedScore
+      };
+    });
+    similarities.sort((a, b) => b.combinedScore - a.combinedScore);
+    const best = similarities[0];
+    if (!best || best.combinedScore < threshold) {
+      return void 0;
+    }
+    return {
+      baseUnitId: best.candidate.id,
+      baseUnit: best.candidate,
+      vectorSimilarity: best.vectorSimilarity,
+      structuralSimilarity: best.structuralSimilarity,
+      combinedScore: best.combinedScore,
+      confidence: this.scoreToConfidence(best.combinedScore)
+    };
+  }
+  /**
+   * Bulk semantic matching for multiple units.
+   *
+   * @param targetUnits - Units to match (with embeddings)
+   * @param baseIndex - Base index (units with embeddings)
+   * @param threshold - Minimum similarity threshold
+   * @returns Map of targetUnitId → Match result
+   */
+  bulkMatch(targetUnits, baseIndex, threshold = 0.7) {
+    const results = /* @__PURE__ */ new Map();
+    for (const targetUnit of targetUnits) {
+      if (!targetUnit.embedding) {
+        continue;
+      }
+      const match = this.findMatch(targetUnit, baseIndex, threshold);
+      if (match) {
+        results.set(targetUnit.id, match);
+      }
+    }
+    return results;
+  }
+  /**
+   * Find candidates in the base index (units with embeddings of the same type).
+   */
+  findCandidates(targetUnit, baseIndex) {
+    const candidates = [];
+    for (const [, baseUnit] of baseIndex.units) {
+      if (baseUnit.type === targetUnit.type && baseUnit.embedding) {
+        candidates.push(baseUnit);
+      }
+    }
+    return candidates;
+  }
+  /**
+   * Compute vector similarity with GPU acceleration.
+   *
+   * Uses SIMD/WASM cosine similarity.
+   */
+  computeVectorSimilarity(embedding1, embedding2) {
+    return cosineSimilarity(embedding1, embedding2);
+  }
+  /**
+   * Compute structural similarity (based on hashes).
+   *
+   * Simple metric: matching structuralHash = 1.0, otherwise 0.0
+   * (can be improved using edit distance)
+   */
+  computeStructuralSimilarity(unit1, unit2) {
+    if (unit1.structuralHash === unit2.structuralHash) {
+      return 1;
+    }
+    return 0;
+  }
+  /**
+   * Convert combined score to confidence (0.0-1.0).
+   *
+   * Mapping:
+   * - 0.9-1.0 → 0.9-1.0 (very high confidence)
+   * - 0.8-0.9 → 0.75-0.9 (high confidence)
+   * - 0.7-0.8 → 0.6-0.75 (medium confidence)
+   */
+  scoreToConfidence(score) {
+    if (score >= 0.9) {
+      return score;
+    }
+    if (score >= 0.8) {
+      return 0.75 + (score - 0.8) * 1.5;
+    }
+    return 0.6 + (score - 0.7) * 1.5;
+  }
+  /**
+   * Compute Semantic Path statistics.
+   */
+  computeStatistics(matchResults, totalUnits) {
+    const totalMatched = matchResults.size;
+    const coverage = totalUnits > 0 ? totalMatched / totalUnits : 0;
+    let sumVector = 0;
+    let sumStructural = 0;
+    let sumCombined = 0;
+    for (const result of matchResults.values()) {
+      sumVector += result.vectorSimilarity;
+      sumStructural += result.structuralSimilarity;
+      sumCombined += result.combinedScore;
+    }
+    const count = totalMatched || 1;
+    return {
+      totalUnits,
+      totalMatched,
+      coverage,
+      avgVectorSimilarity: sumVector / count,
+      avgStructuralSimilarity: sumStructural / count,
+      avgCombinedScore: sumCombined / count
+    };
+  }
+};
+
+// src/merge/engine/three-way-merger.ts
+var ThreeWayMerger = class {
+  branchManager;
+  gitIntegration;
+  conductor;
+  config;
+  // Components
+  multiVersionIndexer;
+  fastPathMatcher;
+  semanticMatcher;
+  intentClassifier;
+  conflictDetector;
+  constructor(_branchManager, _gitIntegration, _conductor, config = {}) {
+    this.branchManager = _branchManager;
+    this.gitIntegration = _gitIntegration;
+    this.conductor = _conductor;
+    this.config = {
+      fastPathEnabled: true,
+      semanticMatchingEnabled: true,
+      semanticThreshold: 0.7,
+      classifyIntents: true,
+      detectConflicts: true,
+      autoResolveConflicts: false,
+      ...config
+    };
+    this.multiVersionIndexer = new MultiVersionIndexer(this.branchManager, this.gitIntegration, this.conductor);
+    this.fastPathMatcher = new FastPathMatcher();
+    this.semanticMatcher = new SemanticMatcher();
+    this.intentClassifier = new IntentClassifier();
+    this.conflictDetector = new ConflictDetector();
+  }
+  /**
+   * Perform 3-way merge
+   *
+   * @param branchA - Name of the first branch to merge
+   * @param branchB - Name of the second branch to merge
+   * @returns MergeResult with matched units, conflicts, and merge actions
+   */
+  async performMerge(branchA, branchB) {
+    log.i("3WAYMERGE", `[ThreeWayMerger] Starting 3-way merge: ${branchA} + ${branchB}`);
+    const startTime = Date.now();
+    log.i("3WAYMERGE", "[ThreeWayMerger] Phase 1: Indexing 3 branches...");
+    const indexResult = await this.multiVersionIndexer.indexThreeBranches(branchA, branchB);
+    const { base, branchA: indexA, branchB: indexB, mergeBase } = indexResult;
+    log.i(
+      "3WAYMERGE",
+      `[ThreeWayMerger] Indexed: base=${base.stats.totalUnits}, A=${indexA.stats.totalUnits}, B=${indexB.stats.totalUnits}`
+    );
+    log.i("3WAYMERGE", "[ThreeWayMerger] Phase 1.5: Detecting file changes from git...");
+    const changesA = await this.gitIntegration.getChangedFilesBetween(mergeBase, branchA);
+    const changesB = await this.gitIntegration.getChangedFilesBetween(mergeBase, branchB);
+    const renamedInA = changesA.filter((c) => c.status === "renamed");
+    const renamedInB = changesB.filter((c) => c.status === "renamed");
+    log.i(
+      "3WAYMERGE",
+      `[ThreeWayMerger] Git changes: A=${changesA.length} (${renamedInA.length} renamed), B=${changesB.length} (${renamedInB.length} renamed)`
+    );
+    log.i("3WAYMERGE", "[ThreeWayMerger] Phase 2: Fast Path matching...");
+    const { matchedUnits, unmatchedA, unmatchedB } = await this.fastPathMatch(base, indexA, indexB);
+    log.i(
+      "3WAYMERGE",
+      `[ThreeWayMerger] Fast Path: ${matchedUnits.length} matched, ${unmatchedA.length} unmapped in A, ${unmatchedB.length} unmapped in B`
+    );
+    log.i("3WAYMERGE", "[ThreeWayMerger] Phase 2.5: Detecting added/deleted units...");
+    const { addedInA, addedInB, deletedUnits, renamedUnits } = this.detectAddedDeletedRenamed(
+      base,
+      indexA,
+      indexB,
+      unmatchedA,
+      unmatchedB,
+      renamedInA,
+      renamedInB
+    );
+    log.i(
+      "3WAYMERGE",
+      `[ThreeWayMerger] Added: A=${addedInA.length}, B=${addedInB.length}, Deleted=${deletedUnits.length}, Renamed=${renamedUnits.length}`
+    );
+    const addedIds = /* @__PURE__ */ new Set([...addedInA.map((u) => u.id), ...addedInB.map((u) => u.id)]);
+    const renamedIds = new Set(renamedUnits.map((r) => r.unit.id));
+    const remainingUnmatchedA = unmatchedA.filter((u) => !addedIds.has(u.id) && !renamedIds.has(u.id));
+    const remainingUnmatchedB = unmatchedB.filter((u) => !addedIds.has(u.id) && !renamedIds.has(u.id));
+    let semanticMatches = [];
+    if (this.config.semanticMatchingEnabled && (remainingUnmatchedA.length > 0 || remainingUnmatchedB.length > 0)) {
+      log.i("3WAYMERGE", "[ThreeWayMerger] Phase 3: Semantic matching...");
+      semanticMatches = await this.semanticMatch(base, remainingUnmatchedA, remainingUnmatchedB);
+      log.i("3WAYMERGE", `[ThreeWayMerger] Semantic: ${semanticMatches.length} matched`);
+    }
+    const allMatches = [...matchedUnits, ...semanticMatches];
+    let intents = /* @__PURE__ */ new Map();
+    if (this.config.classifyIntents) {
+      log.i("3WAYMERGE", "[ThreeWayMerger] Phase 4: Classifying intents...");
+      intents = this.classifyIntents(allMatches);
+      log.i("3WAYMERGE", `[ThreeWayMerger] Classified intents for ${intents.size} unit pairs`);
+    }
+    let conflicts = [];
+    if (this.config.detectConflicts) {
+      log.i("3WAYMERGE", "[ThreeWayMerger] Phase 5: Detecting conflicts...");
+      conflicts = this.detectConflicts(allMatches, intents);
+      const deleteModifyConflicts = this.detectDeleteModifyConflicts(deletedUnits);
+      conflicts = [...conflicts, ...deleteModifyConflicts];
+      log.i("3WAYMERGE", `[ThreeWayMerger] Detected ${conflicts.length} conflicts`);
+    }
+    const mergeActions = this.generateMergeActions(
+      allMatches,
+      conflicts,
+      addedInA,
+      addedInB,
+      deletedUnits,
+      renamedUnits
+    );
+    const stats = {
+      totalUnitsInBase: base.stats.totalUnits,
+      totalUnitsInA: indexA.stats.totalUnits,
+      totalUnitsInB: indexB.stats.totalUnits,
+      matchedCount: allMatches.length,
+      conflictCount: conflicts.length,
+      autoMergedCount: mergeActions.filter((a) => a.type === "auto-merge").length,
+      manualReviewCount: mergeActions.filter((a) => a.type === "manual-review").length,
+      addedFromACount: addedInA.length,
+      addedFromBCount: addedInB.length,
+      deletedCount: deletedUnits.length,
+      renamedCount: renamedUnits.length,
+      mergeTimeMs: Date.now() - startTime
+    };
+    const result = {
+      branchA,
+      branchB,
+      mergeBase,
+      baseIndex: base,
+      branchAIndex: indexA,
+      branchBIndex: indexB,
+      matchedUnits: allMatches,
+      addedInA,
+      addedInB,
+      deletedUnits,
+      renamedUnits,
+      conflicts,
+      mergeActions,
+      stats
+    };
+    log.i(
+      "3WAYMERGE",
+      `[ThreeWayMerger] Merge completed in ${stats.mergeTimeMs}ms: ${stats.autoMergedCount} auto-merged, ${stats.conflictCount} conflicts, ${stats.addedFromACount + stats.addedFromBCount} added, ${stats.deletedCount} deleted, ${stats.renamedCount} renamed`
+    );
+    return result;
+  }
+  /**
+   * Phase 2: Fast Path Matching
+   */
+  async fastPathMatch(base, indexA, indexB) {
+    const matchedUnits = [];
+    const unmatchedA = [];
+    const unmatchedB = [];
+    const unitsA = Array.from(indexA.units.values());
+    const unitsB = Array.from(indexB.units.values());
+    for (const unitA of unitsA) {
+      const matchResult = this.fastPathMatcher.findMatch(unitA, indexB);
+      if (matchResult) {
+        const baseUnit = base.units.get(unitA.id) || null;
+        matchedUnits.push({
+          baseUnit,
+          branchAUnit: unitA,
+          branchBUnit: matchResult.baseUnit
+        });
+      } else {
+        unmatchedA.push(unitA);
+      }
+    }
+    const matchedBIds = new Set(matchedUnits.map((m) => m.branchBUnit.id));
+    for (const unitB of unitsB) {
+      if (!matchedBIds.has(unitB.id)) {
+        unmatchedB.push(unitB);
+      }
+    }
+    return { matchedUnits, unmatchedA, unmatchedB };
+  }
+  /**
+   * Phase 3: Semantic Matching
+   */
+  async semanticMatch(base, unmatchedA, unmatchedB) {
+    if (this.config.embeddingGenerator) {
+      const cache = new LazyEmbeddingCache(this.config.embeddingGenerator);
+      await cache.generateEmbeddings(base, unmatchedA);
+      await cache.generateEmbeddings(base, unmatchedB);
+    }
+    const matches = [];
+    const tempIndexB = {
+      ...base,
+      units: new Map(unmatchedB.map((u) => [u.id, u]))
+    };
+    for (const unitA of unmatchedA) {
+      const matchResult = this.semanticMatcher.findMatch(unitA, tempIndexB, this.config.semanticThreshold);
+      if (matchResult) {
+        const baseUnit = base.units.get(unitA.id) || null;
+        matches.push({
+          baseUnit,
+          branchAUnit: unitA,
+          branchBUnit: matchResult.baseUnit
+        });
+      }
+    }
+    return matches;
+  }
+  /**
+   * Phase 4: Intent Classification
+   */
+  classifyIntents(matches) {
+    const intents = /* @__PURE__ */ new Map();
+    for (const match of matches) {
+      const branchAIntent = this.intentClassifier.classifyIntent(match.baseUnit, match.branchAUnit);
+      const branchBIntent = this.intentClassifier.classifyIntent(match.baseUnit, match.branchBUnit);
+      intents.set(match.branchAUnit.id, { branchAIntent, branchBIntent });
+    }
+    return intents;
+  }
+  /**
+   * Phase 5: Conflict Detection
+   */
+  detectConflicts(matches, intents) {
+    const conflictsToDetect = matches.map((match) => {
+      const intentPair = intents.get(match.branchAUnit.id);
+      return {
+        ...match,
+        branchAIntent: intentPair?.branchAIntent,
+        branchBIntent: intentPair?.branchBIntent
+      };
+    });
+    return this.conflictDetector.detectConflicts(conflictsToDetect);
+  }
+  /**
+   * Phase 2.5: Detect added, deleted, and renamed units
+   */
+  detectAddedDeletedRenamed(base, indexA, indexB, unmatchedA, unmatchedB, renamedInA, renamedInB) {
+    const addedInA = [];
+    const addedInB = [];
+    const deletedUnits = [];
+    const renamedUnits = [];
+    const renameMapA = new Map(renamedInA.map((r) => [r.oldPath, r.path]));
+    const renameMapB = new Map(renamedInB.map((r) => [r.oldPath, r.path]));
+    const renameNewPathsA = new Set(renamedInA.map((r) => r.path));
+    const renameNewPathsB = new Set(renamedInB.map((r) => r.path));
+    for (const unit of unmatchedA) {
+      const existsInBase = base.units.has(unit.id) || unit.filePath && this.findUnitByPath(base, unit.filePath);
+      if (!existsInBase) {
+        const isRenameDestination = unit.filePath && renameNewPathsA.has(unit.filePath);
+        if (isRenameDestination) {
+          for (const [oldPath, newPath] of renameMapA) {
+            if (newPath === unit.filePath && oldPath) {
+              renamedUnits.push({ oldPath, newPath, unit, branch: "branchA" });
+              break;
+            }
+          }
+        } else {
+          addedInA.push(unit);
+        }
+      }
+    }
+    for (const unit of unmatchedB) {
+      const existsInBase = base.units.has(unit.id) || unit.filePath && this.findUnitByPath(base, unit.filePath);
+      if (!existsInBase) {
+        const isRenameDestination = unit.filePath && renameNewPathsB.has(unit.filePath);
+        if (isRenameDestination) {
+          for (const [oldPath, newPath] of renameMapB) {
+            if (newPath === unit.filePath && oldPath) {
+              renamedUnits.push({ oldPath, newPath, unit, branch: "branchB" });
+              break;
+            }
+          }
+        } else {
+          addedInB.push(unit);
+        }
+      }
+    }
+    for (const [unitId, baseUnit] of base.units) {
+      const existsInA = indexA.units.has(unitId) || this.findUnitByPath(indexA, baseUnit.filePath);
+      const existsInB = indexB.units.has(unitId) || this.findUnitByPath(indexB, baseUnit.filePath);
+      const isRenamedInA = renameMapA.has(baseUnit.filePath);
+      const isRenamedInB = renameMapB.has(baseUnit.filePath);
+      if (!existsInA && !isRenamedInA && existsInB) {
+        const unitInB = indexB.units.get(unitId) || this.findUnitByPath(indexB, baseUnit.filePath);
+        const modifiedInB = unitInB && unitInB.contentHash !== baseUnit.contentHash;
+        deletedUnits.push({
+          baseUnit,
+          deletedIn: "branchA",
+          modifiedIn: modifiedInB ? "branchB" : void 0
+        });
+      } else if (!existsInB && !isRenamedInB && existsInA) {
+        const unitInA = indexA.units.get(unitId) || this.findUnitByPath(indexA, baseUnit.filePath);
+        const modifiedInA = unitInA && unitInA.contentHash !== baseUnit.contentHash;
+        deletedUnits.push({
+          baseUnit,
+          deletedIn: "branchB",
+          modifiedIn: modifiedInA ? "branchA" : void 0
+        });
+      }
+    }
+    return { addedInA, addedInB, deletedUnits, renamedUnits };
+  }
+  /**
+   * Find unit by file path in an index
+   */
+  findUnitByPath(index, filePath) {
+    if (!filePath) return void 0;
+    const unitIds = index.filePathIndex.get(filePath);
+    if (unitIds && unitIds.length > 0 && unitIds[0]) {
+      return index.units.get(unitIds[0]);
+    }
+    return void 0;
+  }
+  /**
+   * Detect delete-modify conflicts
+   */
+  detectDeleteModifyConflicts(deletedUnits) {
+    const conflicts = [];
+    for (const deleted of deletedUnits) {
+      if (deleted.modifiedIn) {
+        conflicts.push({
+          id: `conflict-delete-modify-${deleted.baseUnit.id}`,
+          type: "DeleteModify" /* DeleteModify */,
+          severity: "High" /* High */,
+          description: `File deleted in ${deleted.deletedIn} but modified in ${deleted.modifiedIn}`,
+          baseUnit: deleted.baseUnit,
+          branchAUnit: deleted.baseUnit,
+          // Use base as placeholder
+          branchBUnit: deleted.baseUnit,
+          conflictingRegions: [],
+          autoResolvable: false
+        });
+      }
+    }
+    return conflicts;
+  }
+  /**
+   * Generate Merge Actions
+   */
+  generateMergeActions(matches, conflicts, addedInA, addedInB, deletedUnits, renamedUnits) {
+    const actions = [];
+    const conflictIds = new Set(conflicts.map((c) => c.branchAUnit.id));
+    for (const match of matches) {
+      if (conflictIds.has(match.branchAUnit.id)) {
+        const conflict = conflicts.find((c) => c.branchAUnit.id === match.branchAUnit.id);
+        actions.push({
+          type: "manual-review",
+          unitId: match.branchAUnit.id,
+          description: `Conflict detected: ${conflict?.description}`,
+          conflict
+        });
+        continue;
+      }
+      if (match.branchAUnit.contentHash === match.branchBUnit.contentHash) {
+        actions.push({
+          type: "auto-merge",
+          unitId: match.branchAUnit.id,
+          description: "Identical changes in both branches",
+          mergedUnit: match.branchAUnit
+          // Use either (they're identical)
+        });
+        continue;
+      }
+      actions.push({
+        type: "manual-review",
+        unitId: match.branchAUnit.id,
+        description: "Different changes in both branches"
+      });
+    }
+    for (const unit of addedInA) {
+      actions.push({
+        type: "add-from-branchA",
+        unitId: unit.id,
+        description: `New file added in branchA: ${unit.filePath}`,
+        mergedUnit: unit,
+        sourceBranch: "branchA"
+      });
+    }
+    for (const unit of addedInB) {
+      actions.push({
+        type: "add-from-branchB",
+        unitId: unit.id,
+        description: `New file added in branchB: ${unit.filePath}`,
+        mergedUnit: unit,
+        sourceBranch: "branchB"
+      });
+    }
+    for (const deleted of deletedUnits) {
+      if (deleted.modifiedIn) {
+        actions.push({
+          type: "conflict-delete-modify",
+          unitId: deleted.baseUnit.id,
+          description: `Conflict: deleted in ${deleted.deletedIn}, modified in ${deleted.modifiedIn}`
+        });
+      } else {
+        actions.push({
+          type: deleted.deletedIn === "branchA" ? "delete-from-branchA" : "delete-from-branchB",
+          unitId: deleted.baseUnit.id,
+          description: `File deleted in ${deleted.deletedIn}: ${deleted.baseUnit.filePath}`
+        });
+      }
+    }
+    for (const renamed of renamedUnits) {
+      actions.push({
+        type: "rename",
+        unitId: renamed.unit.id,
+        description: `File renamed in ${renamed.branch}: ${renamed.oldPath} -> ${renamed.newPath}`,
+        mergedUnit: renamed.unit,
+        renameInfo: {
+          oldPath: renamed.oldPath,
+          newPath: renamed.newPath,
+          sourceBranch: renamed.branch
+        }
+      });
+    }
+    return actions;
+  }
+};
+
+// src/merge/integration/git-integration.ts
+init_logging();
+var GitIntegration = class {
+  config;
+  originalBranch = null;
+  constructor(config) {
+    this.config = {
+      allowDetachedHead: false,
+      restoreOnError: true,
+      ...config
+    };
+    if (!this.isGitRepository()) {
+      throw new Error(`Not a git repository: ${this.config.repoPath}`);
+    }
+  }
+  /**
+   * Get repository path
+   * Public getter to avoid intersection type issues with private config field
+   */
+  get repoPath() {
+    return this.config.repoPath;
+  }
+  /**
+   * Check if path is a git repository
+   */
+  isGitRepository() {
+    const gitDir = join(this.config.repoPath, ".git");
+    return existsSync(gitDir);
+  }
+  /**
+   * Get current branch info
+   */
+  getCurrentBranch() {
+    try {
+      const branch = execSync("git symbolic-ref --short HEAD", {
+        cwd: this.config.repoPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "ignore"],
+        windowsHide: true
+      }).trim();
+      const commitHash = this.getCommitHash("HEAD");
+      return {
+        name: branch,
+        commitHash,
+        shortHash: commitHash.slice(0, 8),
+        isDetached: false
+      };
+    } catch {
+      const commitHash = this.getCommitHash("HEAD");
+      return {
+        name: `detached-${commitHash.slice(0, 8)}`,
+        commitHash,
+        shortHash: commitHash.slice(0, 8),
+        isDetached: true
+      };
+    }
+  }
+  /**
+   * Get commit hash for a reference (branch, tag, commit)
+   */
+  getCommitHash(ref) {
+    try {
+      const hash = execSync(`git rev-parse ${ref}`, {
+        cwd: this.config.repoPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "ignore"],
+        windowsHide: true
+      }).trim();
+      return hash;
+    } catch (error) {
+      throw new Error(`Failed to get commit hash for ${ref}`, { cause: error });
+    }
+  }
+  /**
+   * Check if a branch exists
+   */
+  branchExists(branch) {
+    try {
+      execSync(`git rev-parse --verify ${branch}`, {
+        cwd: this.config.repoPath,
+        stdio: ["pipe", "pipe", "ignore"],
+        windowsHide: true
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Safely checkout a branch
+   *
+   * Saves current branch, checks out target, handles errors.
+   */
+  async checkoutBranch(branch) {
+    if (!this.originalBranch) {
+      this.originalBranch = this.getCurrentBranch().name;
+    }
+    if (!this.branchExists(branch)) {
+      throw new Error(`Branch does not exist: ${branch}`);
+    }
+    if (this.hasUncommittedChanges()) {
+      throw new Error("Cannot checkout branch: uncommitted changes detected. Please commit or stash changes first.");
+    }
+    try {
+      execSync(`git checkout ${branch}`, {
+        cwd: this.config.repoPath,
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true
+      });
+      log.i("GITINTEGR", `[GitIntegration] Checked out branch: ${branch}`);
+    } catch (error) {
+      if (this.config.restoreOnError && this.originalBranch) {
+        await this.restoreOriginalBranch();
+      }
+      throw new Error(`Failed to checkout branch ${branch}: ${error}`);
+    }
+  }
+  /**
+   * Restore original branch (before merge operations)
+   */
+  async restoreOriginalBranch() {
+    if (!this.originalBranch) {
+      log.w("GITINTEGR", "[GitIntegration] No original branch to restore");
+      return;
+    }
+    try {
+      execSync(`git checkout ${this.originalBranch}`, {
+        cwd: this.config.repoPath,
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true
+      });
+      log.i("GITINTEGR", `[GitIntegration] Restored original branch: ${this.originalBranch}`);
+      this.originalBranch = null;
+    } catch (error) {
+      log.i("GITINTEGR", `[GitIntegration] Failed to restore branch: ${error}`);
+      throw error;
+    }
+  }
+  /**
+   * Check if there are uncommitted changes
+   */
+  hasUncommittedChanges() {
+    try {
+      const output = execSync("git status --porcelain", {
+        cwd: this.config.repoPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "ignore"],
+        windowsHide: true
+      });
+      return output.trim().length > 0;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get changed files between two branches/commits
+   */
+  async getChangedFilesBetween(base, target) {
+    try {
+      const output = execSync(`git diff --name-status ${base}...${target}`, {
+        cwd: this.config.repoPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "ignore"],
+        windowsHide: true
+      });
+      const changes = [];
+      const lines = output.trim().split("\n");
+      for (const line of lines) {
+        if (!line) continue;
+        const parts = line.split("	");
+        const status = parts[0];
+        if (!status) continue;
+        let change;
+        switch (status[0]) {
+          case "A":
+            change = { path: parts[1], status: "added" };
+            break;
+          case "M":
+            change = { path: parts[1], status: "modified" };
+            break;
+          case "D":
+            change = { path: parts[1], status: "deleted" };
+            break;
+          case "R":
+            change = {
+              path: parts[2],
+              status: "renamed",
+              oldPath: parts[1]
+            };
+            break;
+          default:
+            change = { path: parts[1], status: "modified" };
+        }
+        changes.push(change);
+      }
+      return changes;
+    } catch (error) {
+      log.i("GITINTEGR", `[GitIntegration] Failed to get changed files: ${error}`);
+      return [];
+    }
+  }
+  /**
+   * Get detailed diff statistics between branches
+   */
+  async getDiffStats(base, target) {
+    try {
+      const files = await this.getChangedFilesBetween(base, target);
+      const output = execSync(`git diff --shortstat ${base}...${target}`, {
+        cwd: this.config.repoPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "ignore"],
+        windowsHide: true
+      });
+      const match = output.match(/(\d+) files? changed(?:, (\d+) insertions?\(\+\))?(?:, (\d+) deletions?\(-\))?/);
+      const filesChanged = match?.[1] ? Number.parseInt(match[1], 10) : 0;
+      const insertions = match?.[2] ? Number.parseInt(match[2], 10) : 0;
+      const deletions = match?.[3] ? Number.parseInt(match[3], 10) : 0;
+      return {
+        files,
+        filesChanged,
+        insertions,
+        deletions
+      };
+    } catch (error) {
+      log.i("GITINTEGR", `[GitIntegration] Failed to get diff stats: ${error}`);
+      return {
+        files: [],
+        filesChanged: 0,
+        insertions: 0,
+        deletions: 0
+      };
+    }
+  }
+  /**
+   * Get merge base between two branches
+   *
+   * The merge base is the common ancestor commit.
+   */
+  getMergeBase(branchA, branchB) {
+    try {
+      const base = execSync(`git merge-base ${branchA} ${branchB}`, {
+        cwd: this.config.repoPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "ignore"],
+        windowsHide: true
+      }).trim();
+      return base;
+    } catch (error) {
+      log.i("GITINTEGR", `[GitIntegration] Failed to get merge base: ${error}`);
+      return null;
+    }
+  }
+  /**
+   * Get file content at specific revision
+   *
+   * @param path - File path relative to repository root
+   * @param ref - Git reference (branch, tag, commit hash)
+   * @returns File content as string, or null if file doesn't exist at ref
+   */
+  getFileContent(path, ref) {
+    try {
+      const content = execSync(`git show ${ref}:${path}`, {
+        cwd: this.config.repoPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "ignore"],
+        windowsHide: true
+      });
+      return content;
+    } catch (_error) {
+      return null;
+    }
+  }
+  /**
+   * Get list of changed file paths between two references
+   *
+   * Simplified version of getChangedFilesBetween that returns only paths.
+   * Useful for quick file enumeration.
+   *
+   * @param fromRef - Starting reference (branch, tag, commit)
+   * @param toRef - Target reference
+   * @returns Array of file paths (without status information)
+   */
+  async getChangedFiles(fromRef, toRef) {
+    try {
+      const output = execSync(`git diff --name-only ${fromRef}...${toRef}`, {
+        cwd: this.config.repoPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "ignore"],
+        windowsHide: true
+      });
+      return output.trim().split("\n").filter((path) => path.length > 0);
+    } catch (error) {
+      log.i("GITINTEGR", `[GitIntegration] Failed to get changed files: ${error}`);
+      return [];
+    }
+  }
+  /**
+   * Get list of all branches
+   */
+  getAllBranches() {
+    try {
+      const output = execSync("git branch --format='%(refname:short)'", {
+        cwd: this.config.repoPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "ignore"],
+        windowsHide: true
+      });
+      return output.trim().split("\n").map((b) => b.trim()).filter((b) => b.length > 0);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Clean up - restore original branch if not already done
+   */
+  async cleanup() {
+    if (this.originalBranch) {
+      await this.restoreOriginalBranch();
+    }
+  }
+};
+
+// src/agents/merge-agent.ts
+var MergeAgent = class extends BaseAgent {
+  config;
+  gitIntegration = null;
+  threeWayMerger = null;
+  aiResolver = null;
+  branchManager = null;
+  // Merge-specific metrics
+  mergeMetrics = {
+    mergesPerformed: 0,
+    conflictsDetected: 0,
+    conflictsAutoResolved: 0,
+    totalMergeTimeMs: 0,
+    lastMergeAt: 0
+  };
+  constructor(config) {
+    super("merge" /* MERGE */, {
+      maxConcurrency: config.maxConcurrency ?? 1,
+      memoryLimit: 512,
+      // MB
+      priority: 5
+    });
+    this.config = {
+      fastPathEnabled: true,
+      semanticMatchingEnabled: true,
+      semanticThreshold: 0.7,
+      autoResolveConflicts: false,
+      maxConcurrency: 1,
+      ...config
+    };
+  }
+  // =============================================================================
+  // ABSTRACT METHOD IMPLEMENTATIONS
+  // =============================================================================
+  canProcessTask(task) {
+    return task.type === "merge" || task.type === "merge:analyze" || task.type === "merge:perform" || task.type === "merge:suggestions";
+  }
+  async processTask(task) {
+    log.d("MERGEAGENT", "proc_task", { id: task.id, type: task.type });
+    const payload = task.payload;
+    switch (task.type) {
+      case "merge":
+      case "merge:perform":
+        return await this.performSemanticMerge({
+          branchA: payload["branchA"],
+          branchB: payload["branchB"],
+          dryRun: payload["dryRun"],
+          autoResolve: payload["autoResolve"],
+          includeAISuggestions: payload["includeAISuggestions"]
+        });
+      case "merge:analyze":
+        return await this.analyzeConflicts(payload["branchA"], payload["branchB"]);
+      case "merge:suggestions":
+        return await this.getSuggestions(payload["conflict"]);
+      default:
+        throw new Error(`Unknown task type: ${task.type}`);
+    }
+  }
+  async handleMessage(message) {
+    log.d("MERGEAGENT", "recv_msg", { from: message.from, type: message.type });
+  }
+  // =============================================================================
+  // LIFECYCLE
+  // =============================================================================
+  async onInitialize() {
+    log.i("MERGEAGENT", "init_start");
+    this.gitIntegration = this.config.gitIntegration ?? new GitIntegration({
+      repoPath: this.config.repoPath,
+      allowDetachedHead: true,
+      restoreOnError: true
+    });
+    this.branchManager = this.config.branchManager ?? null;
+    const mergerConfig = {
+      fastPathEnabled: this.config.fastPathEnabled,
+      semanticMatchingEnabled: this.config.semanticMatchingEnabled,
+      semanticThreshold: this.config.semanticThreshold,
+      autoResolveConflicts: this.config.autoResolveConflicts
+    };
+    if (this.branchManager && this.gitIntegration) {
+      this.threeWayMerger = new ThreeWayMerger(
+        this.branchManager,
+        this.gitIntegration,
+        null,
+        // conductor - not needed for basic merge operations
+        mergerConfig
+      );
+    }
+    this.aiResolver = null;
+    log.i("MERGEAGENT", "init_done");
+  }
+  async onShutdown() {
+    log.i("MERGEAGENT", "shutdown_start");
+    if (this.gitIntegration) {
+      await this.gitIntegration.cleanup();
+    }
+    this.threeWayMerger = null;
+    this.gitIntegration = null;
+    this.aiResolver = null;
+    log.i("MERGEAGENT", "shutdown_done");
+  }
+  // =============================================================================
+  // PUBLIC API
+  // =============================================================================
+  /**
+   * Set dependencies after construction (for DI)
+   */
+  setDependencies(branchManager, gitIntegration) {
+    this.branchManager = branchManager;
+    if (gitIntegration) {
+      this.gitIntegration = gitIntegration;
+    }
+  }
+  /**
+   * Set AI resolver with embedding generator
+   */
+  setAIResolver(config) {
+    this.aiResolver = new AIConflictResolver(config);
+  }
+  /**
+   * Perform semantic merge between two branches
+   */
+  async performSemanticMerge(options) {
+    const startTime = Date.now();
+    if (!this.threeWayMerger) {
+      return {
+        success: false,
+        error: "MergeAgent not properly initialized - missing ThreeWayMerger",
+        stats: this.createEmptyStats(0)
+      };
+    }
+    try {
+      log.i("MERGEAGENT", "merge_start", { from: options.branchA, to: options.branchB });
+      const mergeResult = await this.threeWayMerger.performMerge(options.branchA, options.branchB);
+      if (options.includeAISuggestions && mergeResult.conflicts.length > 0 && this.aiResolver) {
+        await this.generateAISuggestions(mergeResult.conflicts);
+      }
+      let autoResolved = 0;
+      if (options.autoResolve) {
+        autoResolved = await this.autoResolveConflicts(mergeResult);
+      }
+      let appliedActions = [];
+      if (!options.dryRun) {
+        appliedActions = await this.applyMergeActions(mergeResult);
+      }
+      const mergeTimeMs = Date.now() - startTime;
+      this.updateMergeMetrics(mergeResult, autoResolved, mergeTimeMs);
+      return {
+        success: true,
+        mergeResult,
+        appliedActions,
+        stats: {
+          totalUnitsAnalyzed: mergeResult.stats.totalUnitsInA + mergeResult.stats.totalUnitsInB,
+          matchedUnits: mergeResult.stats.matchedCount,
+          conflictsDetected: mergeResult.stats.conflictCount,
+          autoResolved,
+          manualReviewRequired: mergeResult.stats.manualReviewCount - autoResolved,
+          mergeTimeMs
+        }
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      log.e("MERGEAGENT", "merge_fail", { err: errorMsg });
+      return {
+        success: false,
+        error: errorMsg,
+        stats: this.createEmptyStats(Date.now() - startTime)
+      };
+    }
+  }
+  /**
+   * Analyze merge conflicts without performing merge
+   */
+  async analyzeConflicts(branchA, branchB) {
+    const result = await this.performSemanticMerge({
+      branchA,
+      branchB,
+      dryRun: true,
+      autoResolve: false
+    });
+    if (!result.mergeResult) {
+      return {
+        conflicts: [],
+        stats: { totalConflicts: 0, bySeverity: {}, byType: {} }
+      };
+    }
+    const conflicts = result.mergeResult.conflicts;
+    const bySeverity = {};
+    const byType = {};
+    for (const conflict of conflicts) {
+      bySeverity[conflict.severity] = (bySeverity[conflict.severity] || 0) + 1;
+      byType[conflict.type] = (byType[conflict.type] || 0) + 1;
+    }
+    return {
+      conflicts,
+      stats: {
+        totalConflicts: conflicts.length,
+        bySeverity,
+        byType
+      }
+    };
+  }
+  /**
+   * Get AI-generated suggestions for a specific conflict
+   */
+  async getSuggestions(conflict) {
+    if (!this.aiResolver) {
+      return ["AI resolver not available - configure embedding generator first"];
+    }
+    try {
+      const aiAnalysis = await this.aiResolver.analyzeConflict(conflict);
+      const resolution = this.aiResolver.createResolution(aiAnalysis);
+      return [
+        `Strategy: ${resolution.strategy}`,
+        `Confidence: ${(resolution.confidence * 100).toFixed(1)}%`,
+        `Explanation: ${resolution.explanation}`,
+        ...resolution.mergedCode ? [`Suggested code:
+${resolution.mergedCode}`] : []
+      ];
+    } catch (error) {
+      log.e("MERGEAGENT", "ai_suggest_fail", { err: String(error) });
+      return [];
+    }
+  }
+  /**
+   * Get merge-specific metrics
+   */
+  getMergeMetrics() {
+    return { ...this.mergeMetrics };
+  }
+  // =============================================================================
+  // PRIVATE METHODS
+  // =============================================================================
+  async generateAISuggestions(conflicts) {
+    if (!this.aiResolver) return;
+    log.d("MERGEAGENT", "gen_ai_suggest", { cnt: conflicts.length });
+    for (const conflict of conflicts) {
+      try {
+        const aiAnalysis = await this.aiResolver.analyzeConflict(conflict);
+        const resolution = this.aiResolver.createResolution(aiAnalysis);
+        conflict.aiSuggestions = [resolution.explanation];
+        conflict.aiConfidence = resolution.confidence;
+      } catch (error) {
+        log.w("MERGEAGENT", "ai_conflict_fail", { err: String(error) });
+      }
+    }
+  }
+  async autoResolveConflicts(mergeResult) {
+    let resolved = 0;
+    for (const action of mergeResult.mergeActions) {
+      if (action.type === "manual-review" && action.conflict) {
+        if (this.aiResolver) {
+          try {
+            const aiAnalysis = await this.aiResolver.analyzeConflict(action.conflict);
+            if (aiAnalysis.confidence >= 0.9 && aiAnalysis.mergedCode) {
+              action.type = "auto-merge";
+              action.description = `Auto-resolved: ${aiAnalysis.explanation}`;
+              resolved++;
+            }
+          } catch {
+          }
+        }
+      }
+    }
+    return resolved;
+  }
+  async applyMergeActions(mergeResult) {
+    const applied = [];
+    for (const action of mergeResult.mergeActions) {
+      if (action.type === "auto-merge" && action.mergedUnit) {
+        applied.push(action);
+      }
+    }
+    log.i("MERGEAGENT", "actions_applied", { cnt: applied.length });
+    return applied;
+  }
+  updateMergeMetrics(mergeResult, autoResolved, mergeTimeMs) {
+    this.mergeMetrics.mergesPerformed++;
+    this.mergeMetrics.conflictsDetected += mergeResult.conflicts.length;
+    this.mergeMetrics.conflictsAutoResolved += autoResolved;
+    this.mergeMetrics.totalMergeTimeMs += mergeTimeMs;
+    this.mergeMetrics.lastMergeAt = Date.now();
+  }
+  createEmptyStats(mergeTimeMs) {
+    return {
+      totalUnitsAnalyzed: 0,
+      matchedUnits: 0,
+      conflictsDetected: 0,
+      autoResolved: 0,
+      manualReviewRequired: 0,
+      mergeTimeMs
+    };
+  }
+};
+
+export { MergeAgent };
+//# sourceMappingURL=merge-agent-LSUBDJB2.js.map
+//# sourceMappingURL=merge-agent-LSUBDJB2.js.map