@stackmemoryai/stackmemory 0.2.8 → 0.3.0

package/dist/core/merge/resolution-engine.js

@@ -0,0 +1,565 @@
+import { v4 as uuidv4 } from "uuid";
+import { ConflictDetector } from "./conflict-detector.js";
+import { StackDiffVisualizer } from "./stack-diff.js";
+import { logger } from "../monitoring/logger.js";
+class ResolutionEngine {
+  conflictDetector;
+  diffVisualizer;
+  resolutionHistory = /* @__PURE__ */ new Map();
+  constructor() {
+    this.conflictDetector = new ConflictDetector();
+    this.diffVisualizer = new StackDiffVisualizer();
+  }
+  /**
+   * Resolve conflicts using the specified strategy
+   */
+  async resolveConflicts(stack1, stack2, strategy, context) {
+    const conflicts = this.conflictDetector.detectConflicts(stack1, stack2);
+    logger.info(
+      `Resolving ${conflicts.length} conflicts using ${strategy} strategy`,
+      {
+        userId: context.userId,
+        userRole: context.userRole
+      }
+    );
+    let resolution;
+    switch (strategy) {
+      case "keep_both":
+        resolution = await this.keepBothStrategy(
+          conflicts,
+          stack1,
+          stack2,
+          context
+        );
+        break;
+      case "team_vote":
+        resolution = await this.teamVoteStrategy(
+          conflicts,
+          stack1,
+          stack2,
+          context
+        );
+        break;
+      case "senior_override":
+        resolution = await this.seniorOverrideStrategy(
+          conflicts,
+          stack1,
+          stack2,
+          context
+        );
+        break;
+      case "ai_suggest":
+        resolution = await this.aiSuggestStrategy(
+          conflicts,
+          stack1,
+          stack2,
+          context
+        );
+        break;
+      case "hybrid":
+        resolution = await this.hybridStrategy(
+          conflicts,
+          stack1,
+          stack2,
+          context
+        );
+        break;
+      default:
+        throw new Error(`Unknown resolution strategy: ${strategy}`);
+    }
+    const mergeResult = await this.executeMerge(
+      stack1,
+      stack2,
+      conflicts,
+      resolution
+    );
+    this.storeResolution(mergeResult.mergedFrameId || "", resolution);
+    return mergeResult;
+  }
+  /**
+   * Strategy: Keep Both Solutions
+   * Creates a merged frame that includes both approaches
+   */
+  async keepBothStrategy(conflicts, stack1, stack2, context) {
+    logger.info("Applying keep_both strategy");
+    const strategy = {
+      type: "keep_both",
+      confidence: 0.8,
+      reasoning: "Preserving both solutions to maintain all work and allow future evaluation"
+    };
+    for (const conflict of conflicts) {
+      conflict.resolution = {
+        strategy,
+        resolvedBy: context.userId,
+        resolvedAt: Date.now(),
+        notes: "Both solutions preserved in merged frame"
+      };
+    }
+    return {
+      strategy,
+      resolvedBy: context.userId,
+      resolvedAt: Date.now(),
+      notes: `Kept all ${stack1.frames.length + stack2.frames.length} frames from both stacks`
+    };
+  }
+  /**
+   * Strategy: Team Vote
+   * Uses democratic voting to choose between options
+   */
+  async teamVoteStrategy(conflicts, stack1, stack2, context) {
+    logger.info("Applying team_vote strategy");
+    if (!context.teamVotes || context.teamVotes.length === 0) {
+      throw new Error("Team vote strategy requires votes from team members");
+    }
+    const voteResults = this.countVotes(context.teamVotes);
+    const strategy = {
+      type: "team_vote",
+      confidence: this.calculateVoteConfidence(voteResults),
+      reasoning: `Team consensus from ${context.teamVotes.length} votes`,
+      votes: context.teamVotes
+    };
+    for (const conflict of conflicts) {
+      const winner = this.determineVoteWinner(conflict, voteResults);
+      conflict.resolution = {
+        strategy,
+        resolvedBy: "team_consensus",
+        resolvedAt: Date.now(),
+        notes: `Resolved by ${voteResults.consensus}% consensus`
+      };
+    }
+    return {
+      strategy,
+      resolvedBy: "team_consensus",
+      resolvedAt: Date.now(),
+      notes: `Democratic resolution with ${voteResults.consensus}% agreement`
+    };
+  }
+  /**
+   * Strategy: Senior Override
+   * Senior developer's choice takes precedence
+   */
+  async seniorOverrideStrategy(conflicts, stack1, stack2, context) {
+    logger.info("Applying senior_override strategy");
+    if (context.userRole !== "senior" && context.userRole !== "lead") {
+      throw new Error("Senior override requires senior or lead role");
+    }
+    const preferredStack = this.determinePreferredStack(
+      stack1,
+      stack2,
+      context
+    );
+    const strategy = {
+      type: "senior_override",
+      confidence: 0.95,
+      reasoning: `Senior developer (${context.userId}) selected based on experience and architectural knowledge`
+    };
+    for (const conflict of conflicts) {
+      conflict.resolution = {
+        strategy,
+        resolvedBy: context.userId,
+        resolvedAt: Date.now(),
+        notes: `Overridden by ${context.userRole} authority`
+      };
+    }
+    return {
+      strategy,
+      resolvedBy: context.userId,
+      resolvedAt: Date.now(),
+      notes: `Senior override applied to all ${conflicts.length} conflicts`
+    };
+  }
+  /**
+   * Strategy: AI Suggest
+   * Uses AI analysis to recommend best resolution
+   */
+  async aiSuggestStrategy(conflicts, stack1, stack2, context) {
+    logger.info("Applying ai_suggest strategy");
+    const analysis = await this.analyzeFrameQuality(stack1, stack2);
+    const strategy = {
+      type: "ai_suggest",
+      confidence: context.aiConfidence || 0.85,
+      reasoning: this.generateAIReasoning(analysis)
+    };
+    for (const conflict of conflicts) {
+      const recommendation = this.getAIRecommendation(conflict, analysis);
+      conflict.resolution = {
+        strategy,
+        resolvedBy: "ai_system",
+        resolvedAt: Date.now(),
+        notes: recommendation
+      };
+    }
+    return {
+      strategy,
+      resolvedBy: "ai_system",
+      resolvedAt: Date.now(),
+      notes: `AI analysis with ${strategy.confidence * 100}% confidence`
+    };
+  }
+  /**
+   * Strategy: Hybrid
+   * Combines multiple strategies based on conflict type
+   */
+  async hybridStrategy(conflicts, stack1, stack2, context) {
+    logger.info("Applying hybrid strategy");
+    const strategy = {
+      type: "hybrid",
+      confidence: 0.9,
+      reasoning: "Using optimal strategy for each conflict type"
+    };
+    for (const conflict of conflicts) {
+      let subStrategy;
+      switch (conflict.type) {
+        case "parallel_solution":
+          subStrategy = "keep_both";
+          break;
+        case "conflicting_decision":
+          subStrategy = "ai_suggest";
+          break;
+        case "structural_divergence":
+          subStrategy = context.userRole === "senior" || context.userRole === "lead" ? "senior_override" : "team_vote";
+          break;
+        default:
+          subStrategy = "ai_suggest";
+      }
+      conflict.resolution = {
+        strategy: {
+          ...strategy,
+          reasoning: `${subStrategy} for ${conflict.type}`
+        },
+        resolvedBy: context.userId,
+        resolvedAt: Date.now(),
+        notes: `Hybrid resolution using ${subStrategy}`
+      };
+    }
+    return {
+      strategy,
+      resolvedBy: context.userId,
+      resolvedAt: Date.now(),
+      notes: `Hybrid strategy optimized for each conflict type`
+    };
+  }
+  /**
+   * Execute the merge based on resolution
+   */
+  async executeMerge(stack1, stack2, conflicts, resolution) {
+    const mergedFrameId = uuidv4();
+    const rollbackPoint = this.createRollbackPoint(stack1, stack2);
+    const notifications = [];
+    try {
+      const mergedFrames = this.mergeFrames(
+        stack1,
+        stack2,
+        conflicts,
+        resolution
+      );
+      const isValid = this.validateMerge(mergedFrames, conflicts);
+      if (!isValid) {
+        throw new Error("Merge validation failed");
+      }
+      const notifyResults = await this.sendNotifications(conflicts, resolution);
+      notifications.push(...notifyResults);
+      logger.info("Merge executed successfully", {
+        mergedFrameId,
+        frameCount: mergedFrames.length,
+        strategy: resolution.strategy.type
+      });
+      return {
+        success: true,
+        mergedFrameId,
+        conflicts,
+        resolution,
+        rollbackPoint,
+        notifications
+      };
+    } catch (error) {
+      logger.error("Merge execution failed", error);
+      return {
+        success: false,
+        conflicts,
+        resolution,
+        rollbackPoint,
+        notifications
+      };
+    }
+  }
+  /**
+   * Count votes from team members
+   */
+  countVotes(votes) {
+    const counts = {
+      frame1: 0,
+      frame2: 0,
+      both: 0,
+      neither: 0,
+      total: votes.length,
+      consensus: 0
+    };
+    for (const vote of votes) {
+      counts[vote.choice]++;
+    }
+    const maxVotes = Math.max(
+      counts.frame1,
+      counts.frame2,
+      counts.both,
+      counts.neither
+    );
+    counts.consensus = Math.round(maxVotes / counts.total * 100);
+    return counts;
+  }
+  /**
+   * Calculate confidence based on vote distribution
+   */
+  calculateVoteConfidence(voteResults) {
+    if (voteResults.consensus >= 80) return 0.95;
+    if (voteResults.consensus >= 60) return 0.75;
+    if (voteResults.consensus >= 40) return 0.5;
+    return 0.3;
+  }
+  /**
+   * Determine winner from vote results
+   */
+  determineVoteWinner(conflict, voteResults) {
+    if (voteResults.frame1 > voteResults.frame2) return conflict.frameId1;
+    if (voteResults.frame2 > voteResults.frame1) return conflict.frameId2;
+    if (voteResults.both > voteResults.neither) return "both";
+    return "neither";
+  }
+  /**
+   * Determine preferred stack for senior override
+   */
+  determinePreferredStack(stack1, stack2, context) {
+    if (stack1.owner === context.userId) return stack1;
+    if (stack2.owner === context.userId) return stack2;
+    if (stack1.lastModified > stack2.lastModified) return stack1;
+    if (stack2.frames.filter((f) => f.state === "closed").length > stack1.frames.filter((f) => f.state === "closed").length) {
+      return stack2;
+    }
+    return stack1;
+  }
+  /**
+   * Analyze frame quality for AI suggestions
+   */
+  async analyzeFrameQuality(stack1, stack2) {
+    const analysis = {
+      stack1: {
+        completeness: this.calculateCompleteness(stack1),
+        efficiency: this.calculateEfficiency(stack1),
+        quality: this.calculateQuality(stack1)
+      },
+      stack2: {
+        completeness: this.calculateCompleteness(stack2),
+        efficiency: this.calculateEfficiency(stack2),
+        quality: this.calculateQuality(stack2)
+      }
+    };
+    return analysis;
+  }
+  /**
+   * Calculate stack completeness
+   */
+  calculateCompleteness(stack) {
+    const closedFrames = stack.frames.filter(
+      (f) => f.state === "closed"
+    ).length;
+    return closedFrames / stack.frames.length;
+  }
+  /**
+   * Calculate stack efficiency
+   */
+  calculateEfficiency(stack) {
+    let totalDuration = 0;
+    let completedFrames = 0;
+    for (const frame of stack.frames) {
+      if (frame.closed_at && frame.created_at) {
+        totalDuration += frame.closed_at - frame.created_at;
+        completedFrames++;
+      }
+    }
+    if (completedFrames === 0) return 0;
+    const avgDuration = totalDuration / completedFrames;
+    return Math.max(0, Math.min(1, 3e5 / avgDuration));
+  }
+  /**
+   * Calculate stack quality
+   */
+  calculateQuality(stack) {
+    let qualityScore = 0;
+    for (const frame of stack.frames) {
+      if (frame.outputs && Object.keys(frame.outputs).length > 0)
+        qualityScore += 0.3;
+      if (frame.digest_text) qualityScore += 0.3;
+      if (frame.state === "closed") qualityScore += 0.4;
+    }
+    return Math.min(1, qualityScore / stack.frames.length);
+  }
+  /**
+   * Generate AI reasoning for resolution
+   */
+  generateAIReasoning(analysis) {
+    const stack1Score = analysis.stack1.completeness * 0.3 + analysis.stack1.efficiency * 0.3 + analysis.stack1.quality * 0.4;
+    const stack2Score = analysis.stack2.completeness * 0.3 + analysis.stack2.efficiency * 0.3 + analysis.stack2.quality * 0.4;
+    if (stack1Score > stack2Score) {
+      return `Stack 1 shows higher overall quality (${(stack1Score * 100).toFixed(1)}% vs ${(stack2Score * 100).toFixed(1)}%)`;
+    } else {
+      return `Stack 2 shows higher overall quality (${(stack2Score * 100).toFixed(1)}% vs ${(stack1Score * 100).toFixed(1)}%)`;
+    }
+  }
+  /**
+   * Get AI recommendation for specific conflict
+   */
+  getAIRecommendation(conflict, analysis) {
+    switch (conflict.type) {
+      case "parallel_solution":
+        return "Recommend keeping both solutions for A/B testing";
+      case "conflicting_decision":
+        return "Recommend the decision with higher quality score";
+      case "structural_divergence":
+        return "Recommend restructuring to accommodate both approaches";
+      default:
+        return "Recommend manual review for this conflict";
+    }
+  }
+  /**
+   * Create rollback point before merge
+   */
+  createRollbackPoint(stack1, stack2) {
+    const rollbackId = uuidv4();
+    const rollbackData = {
+      id: rollbackId,
+      timestamp: Date.now(),
+      stack1: JSON.parse(JSON.stringify(stack1)),
+      stack2: JSON.parse(JSON.stringify(stack2))
+    };
+    logger.info("Created rollback point", { rollbackId });
+    return rollbackId;
+  }
+  /**
+   * Merge frames based on resolution
+   */
+  mergeFrames(stack1, stack2, conflicts, resolution) {
+    const mergedFrames = [];
+    const processedIds = /* @__PURE__ */ new Set();
+    switch (resolution.strategy.type) {
+      case "keep_both":
+        mergedFrames.push(...stack1.frames, ...stack2.frames);
+        break;
+      case "team_vote":
+      case "senior_override":
+      case "ai_suggest":
+        for (const frame of stack1.frames) {
+          const conflict = conflicts.find((c) => c.frameId1 === frame.frame_id);
+          if (!conflict || conflict.resolution?.strategy.type === "keep_both") {
+            mergedFrames.push(frame);
+            processedIds.add(frame.frame_id);
+          }
+        }
+        for (const frame of stack2.frames) {
+          if (!processedIds.has(frame.frame_id)) {
+            const conflict = conflicts.find(
+              (c) => c.frameId2 === frame.frame_id
+            );
+            if (!conflict || conflict.resolution?.strategy.type === "keep_both") {
+              mergedFrames.push(frame);
+            }
+          }
+        }
+        break;
+      case "hybrid":
+        this.hybridMerge(stack1, stack2, conflicts, mergedFrames);
+        break;
+    }
+    return mergedFrames;
+  }
+  /**
+   * Hybrid merge implementation
+   */
+  hybridMerge(stack1, stack2, conflicts, mergedFrames) {
+    const conflictMap = /* @__PURE__ */ new Map();
+    for (const conflict of conflicts) {
+      conflictMap.set(conflict.frameId1, conflict);
+      conflictMap.set(conflict.frameId2, conflict);
+    }
+    for (const frame of [...stack1.frames, ...stack2.frames]) {
+      const conflict = conflictMap.get(frame.frame_id);
+      if (!conflict) {
+        if (!mergedFrames.find((f) => f.frame_id === frame.frame_id)) {
+          mergedFrames.push(frame);
+        }
+      } else if (conflict.type === "parallel_solution") {
+        if (!mergedFrames.find((f) => f.frame_id === frame.frame_id)) {
+          mergedFrames.push(frame);
+        }
+      }
+    }
+  }
+  /**
+   * Validate merge integrity
+   */
+  validateMerge(mergedFrames, conflicts) {
+    const ids = /* @__PURE__ */ new Set();
+    for (const frame of mergedFrames) {
+      if (ids.has(frame.frame_id)) {
+        logger.error("Duplicate frame ID in merge", {
+          frameId: frame.frame_id
+        });
+        return false;
+      }
+      ids.add(frame.frame_id);
+    }
+    for (const frame of mergedFrames) {
+      if (frame.parent_frame_id) {
+        const parent = mergedFrames.find(
+          (f) => f.frame_id === frame.parent_frame_id
+        );
+        if (!parent) {
+          logger.warn("Orphaned frame in merge", { frameId: frame.frame_id });
+        }
+      }
+    }
+    for (const conflict of conflicts) {
+      if (!conflict.resolution) {
+        logger.error("Unresolved conflict in merge", {
+          conflictId: conflict.id
+        });
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Send notifications about merge
+   */
+  async sendNotifications(conflicts, resolution) {
+    const notifications = [];
+    const notification = {
+      userId: resolution.resolvedBy || "team",
+      type: "in-app",
+      sent: true,
+      timestamp: Date.now()
+    };
+    notifications.push(notification);
+    logger.info("Notifications sent", { count: notifications.length });
+    return notifications;
+  }
+  /**
+   * Store resolution in history
+   */
+  storeResolution(mergeId, resolution) {
+    this.resolutionHistory.set(mergeId, resolution);
+    logger.info("Resolution stored in history", {
+      mergeId,
+      strategy: resolution.strategy.type
+    });
+  }
+  /**
+   * Get resolution history for analysis
+   */
+  getResolutionHistory() {
+    return this.resolutionHistory;
+  }
+}
+export {
+  ResolutionEngine
+};
+//# sourceMappingURL=resolution-engine.js.map

package/dist/core/merge/resolution-engine.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/core/merge/resolution-engine.ts"],
+  "sourcesContent": ["/**\n * Resolution Engine\n * Implements multiple strategies for resolving merge conflicts\n */\n\nimport { v4 as uuidv4 } from 'uuid';\nimport {\n  MergeConflict,\n  ConflictResolution,\n  ResolutionStrategy,\n  TeamVote,\n  FrameStack,\n  MergeResult,\n  NotificationResult,\n} from './types.js';\nimport { Frame } from '../context/frame-manager.js';\nimport { ConflictDetector } from './conflict-detector.js';\nimport { StackDiffVisualizer } from './stack-diff.js';\nimport { logger } from '../monitoring/logger.js';\n\nexport interface ResolutionContext {\n  userId: string;\n  userRole: 'junior' | 'mid' | 'senior' | 'lead';\n  teamVotes?: TeamVote[];\n  aiConfidence?: number;\n  timeConstraint?: number; // milliseconds\n}\n\nexport class ResolutionEngine {\n  private conflictDetector: ConflictDetector;\n  private diffVisualizer: StackDiffVisualizer;\n  private resolutionHistory: Map<string, ConflictResolution> = new Map();\n\n  constructor() {\n    this.conflictDetector = new ConflictDetector();\n    this.diffVisualizer = new StackDiffVisualizer();\n  }\n\n  /**\n   * Resolve conflicts using the specified strategy\n   */\n  async resolveConflicts(\n    stack1: FrameStack,\n    stack2: FrameStack,\n    strategy: ResolutionStrategy['type'],\n    context: ResolutionContext\n  ): Promise<MergeResult> {\n    const conflicts = this.conflictDetector.detectConflicts(stack1, stack2);\n\n    logger.info(\n      `Resolving ${conflicts.length} conflicts using ${strategy} strategy`,\n      {\n        userId: context.userId,\n        userRole: context.userRole,\n      }\n    );\n\n    let resolution: ConflictResolution;\n\n    switch (strategy) {\n      case 'keep_both':\n        resolution = await this.keepBothStrategy(\n          conflicts,\n          stack1,\n          stack2,\n          context\n        );\n        break;\n\n      case 'team_vote':\n        resolution = await this.teamVoteStrategy(\n          conflicts,\n          stack1,\n          stack2,\n          context\n        );\n        break;\n\n      case 'senior_override':\n        resolution = await this.seniorOverrideStrategy(\n          conflicts,\n          stack1,\n          stack2,\n          context\n        );\n        break;\n\n      case 'ai_suggest':\n        resolution = await this.aiSuggestStrategy(\n          conflicts,\n          stack1,\n          stack2,\n          context\n        );\n        break;\n\n      case 'hybrid':\n        resolution = await this.hybridStrategy(\n          conflicts,\n          stack1,\n          stack2,\n          context\n        );\n        break;\n\n      default:\n        throw new Error(`Unknown resolution strategy: ${strategy}`);\n    }\n\n    // Execute the merge based on resolution\n    const mergeResult = await this.executeMerge(\n      stack1,\n      stack2,\n      conflicts,\n      resolution\n    );\n\n    // Store resolution in history\n    this.storeResolution(mergeResult.mergedFrameId || '', resolution);\n\n    return mergeResult;\n  }\n\n  /**\n   * Strategy: Keep Both Solutions\n   * Creates a merged frame that includes both approaches\n   */\n  private async keepBothStrategy(\n    conflicts: MergeConflict[],\n    stack1: FrameStack,\n    stack2: FrameStack,\n    context: ResolutionContext\n  ): Promise<ConflictResolution> {\n    logger.info('Applying keep_both strategy');\n\n    const strategy: ResolutionStrategy = {\n      type: 'keep_both',\n      confidence: 0.8,\n      reasoning:\n        'Preserving both solutions to maintain all work and allow future evaluation',\n    };\n\n    // Mark all conflicts as resolved by keeping both\n    for (const conflict of conflicts) {\n      conflict.resolution = {\n        strategy,\n        resolvedBy: context.userId,\n        resolvedAt: Date.now(),\n        notes: 'Both solutions preserved in merged frame',\n      };\n    }\n\n    return {\n      strategy,\n      resolvedBy: context.userId,\n      resolvedAt: Date.now(),\n      notes: `Kept all ${stack1.frames.length + stack2.frames.length} frames from both stacks`,\n    };\n  }\n\n  /**\n   * Strategy: Team Vote\n   * Uses democratic voting to choose between options\n   */\n  private async teamVoteStrategy(\n    conflicts: MergeConflict[],\n    stack1: FrameStack,\n    stack2: FrameStack,\n    context: ResolutionContext\n  ): Promise<ConflictResolution> {\n    logger.info('Applying team_vote strategy');\n\n    if (!context.teamVotes || context.teamVotes.length === 0) {\n      throw new Error('Team vote strategy requires votes from team members');\n    }\n\n    // Count votes for each conflict\n    const voteResults = this.countVotes(context.teamVotes);\n\n    const strategy: ResolutionStrategy = {\n      type: 'team_vote',\n      confidence: this.calculateVoteConfidence(voteResults),\n      reasoning: `Team consensus from ${context.teamVotes.length} votes`,\n      votes: context.teamVotes,\n    };\n\n    // Apply vote results to conflicts\n    for (const conflict of conflicts) {\n      const winner = this.determineVoteWinner(conflict, voteResults);\n      conflict.resolution = {\n        strategy,\n        resolvedBy: 'team_consensus',\n        resolvedAt: Date.now(),\n        notes: `Resolved by ${voteResults.consensus}% consensus`,\n      };\n    }\n\n    return {\n      strategy,\n      resolvedBy: 'team_consensus',\n      resolvedAt: Date.now(),\n      notes: `Democratic resolution with ${voteResults.consensus}% agreement`,\n    };\n  }\n\n  /**\n   * Strategy: Senior Override\n   * Senior developer's choice takes precedence\n   */\n  private async seniorOverrideStrategy(\n    conflicts: MergeConflict[],\n    stack1: FrameStack,\n    stack2: FrameStack,\n    context: ResolutionContext\n  ): Promise<ConflictResolution> {\n    logger.info('Applying senior_override strategy');\n\n    if (context.userRole !== 'senior' && context.userRole !== 'lead') {\n      throw new Error('Senior override requires senior or lead role');\n    }\n\n    // Assume stack1 is the senior's preferred choice\n    const preferredStack = this.determinePreferredStack(\n      stack1,\n      stack2,\n      context\n    );\n\n    const strategy: ResolutionStrategy = {\n      type: 'senior_override',\n      confidence: 0.95,\n      reasoning: `Senior developer (${context.userId}) selected based on experience and architectural knowledge`,\n    };\n\n    for (const conflict of conflicts) {\n      conflict.resolution = {\n        strategy,\n        resolvedBy: context.userId,\n        resolvedAt: Date.now(),\n        notes: `Overridden by ${context.userRole} authority`,\n      };\n    }\n\n    return {\n      strategy,\n      resolvedBy: context.userId,\n      resolvedAt: Date.now(),\n      notes: `Senior override applied to all ${conflicts.length} conflicts`,\n    };\n  }\n\n  /**\n   * Strategy: AI Suggest\n   * Uses AI analysis to recommend best resolution\n   */\n  private async aiSuggestStrategy(\n    conflicts: MergeConflict[],\n    stack1: FrameStack,\n    stack2: FrameStack,\n    context: ResolutionContext\n  ): Promise<ConflictResolution> {\n    logger.info('Applying ai_suggest strategy');\n\n    // Analyze frames for quality and effectiveness\n    const analysis = await this.analyzeFrameQuality(stack1, stack2);\n\n    const strategy: ResolutionStrategy = {\n      type: 'ai_suggest',\n      confidence: context.aiConfidence || 0.85,\n      reasoning: this.generateAIReasoning(analysis),\n    };\n\n    // Apply AI recommendations to each conflict\n    for (const conflict of conflicts) {\n      const recommendation = this.getAIRecommendation(conflict, analysis);\n      conflict.resolution = {\n        strategy,\n        resolvedBy: 'ai_system',\n        resolvedAt: Date.now(),\n        notes: recommendation,\n      };\n    }\n\n    return {\n      strategy,\n      resolvedBy: 'ai_system',\n      resolvedAt: Date.now(),\n      notes: `AI analysis with ${strategy.confidence * 100}% confidence`,\n    };\n  }\n\n  /**\n   * Strategy: Hybrid\n   * Combines multiple strategies based on conflict type\n   */\n  private async hybridStrategy(\n    conflicts: MergeConflict[],\n    stack1: FrameStack,\n    stack2: FrameStack,\n    context: ResolutionContext\n  ): Promise<ConflictResolution> {\n    logger.info('Applying hybrid strategy');\n\n    const strategy: ResolutionStrategy = {\n      type: 'hybrid',\n      confidence: 0.9,\n      reasoning: 'Using optimal strategy for each conflict type',\n    };\n\n    // Apply different strategies based on conflict type\n    for (const conflict of conflicts) {\n      let subStrategy: ResolutionStrategy['type'];\n\n      switch (conflict.type) {\n        case 'parallel_solution':\n          // Keep both for parallel solutions\n          subStrategy = 'keep_both';\n          break;\n\n        case 'conflicting_decision':\n          // Use AI for decision conflicts\n          subStrategy = 'ai_suggest';\n          break;\n\n        case 'structural_divergence':\n          // Use senior override for structural issues\n          subStrategy =\n            context.userRole === 'senior' || context.userRole === 'lead'\n              ? 'senior_override'\n              : 'team_vote';\n          break;\n\n        default:\n          subStrategy = 'ai_suggest';\n      }\n\n      conflict.resolution = {\n        strategy: {\n          ...strategy,\n          reasoning: `${subStrategy} for ${conflict.type}`,\n        },\n        resolvedBy: context.userId,\n        resolvedAt: Date.now(),\n        notes: `Hybrid resolution using ${subStrategy}`,\n      };\n    }\n\n    return {\n      strategy,\n      resolvedBy: context.userId,\n      resolvedAt: Date.now(),\n      notes: `Hybrid strategy optimized for each conflict type`,\n    };\n  }\n\n  /**\n   * Execute the merge based on resolution\n   */\n  private async executeMerge(\n    stack1: FrameStack,\n    stack2: FrameStack,\n    conflicts: MergeConflict[],\n    resolution: ConflictResolution\n  ): Promise<MergeResult> {\n    const mergedFrameId = uuidv4();\n    const rollbackPoint = this.createRollbackPoint(stack1, stack2);\n    const notifications: NotificationResult[] = [];\n\n    try {\n      // Create merged frame stack\n      const mergedFrames = this.mergeFrames(\n        stack1,\n        stack2,\n        conflicts,\n        resolution\n      );\n\n      // Validate merge integrity\n      const isValid = this.validateMerge(mergedFrames, conflicts);\n\n      if (!isValid) {\n        throw new Error('Merge validation failed');\n      }\n\n      // Send notifications\n      const notifyResults = await this.sendNotifications(conflicts, resolution);\n      notifications.push(...notifyResults);\n\n      logger.info('Merge executed successfully', {\n        mergedFrameId,\n        frameCount: mergedFrames.length,\n        strategy: resolution.strategy.type,\n      });\n\n      return {\n        success: true,\n        mergedFrameId,\n        conflicts,\n        resolution,\n        rollbackPoint,\n        notifications,\n      };\n    } catch (error) {\n      logger.error('Merge execution failed', error as Error);\n\n      return {\n        success: false,\n        conflicts,\n        resolution,\n        rollbackPoint,\n        notifications,\n      };\n    }\n  }\n\n  /**\n   * Count votes from team members\n   */\n  private countVotes(votes: TeamVote[]): any {\n    const counts = {\n      frame1: 0,\n      frame2: 0,\n      both: 0,\n      neither: 0,\n      total: votes.length,\n      consensus: 0,\n    };\n\n    for (const vote of votes) {\n      counts[vote.choice]++;\n    }\n\n    // Calculate consensus percentage\n    const maxVotes = Math.max(\n      counts.frame1,\n      counts.frame2,\n      counts.both,\n      counts.neither\n    );\n    counts.consensus = Math.round((maxVotes / counts.total) * 100);\n\n    return counts;\n  }\n\n  /**\n   * Calculate confidence based on vote distribution\n   */\n  private calculateVoteConfidence(voteResults: any): number {\n    // High confidence if strong consensus\n    if (voteResults.consensus >= 80) return 0.95;\n    if (voteResults.consensus >= 60) return 0.75;\n    if (voteResults.consensus >= 40) return 0.5;\n    return 0.3;\n  }\n\n  /**\n   * Determine winner from vote results\n   */\n  private determineVoteWinner(\n    conflict: MergeConflict,\n    voteResults: any\n  ): string {\n    if (voteResults.frame1 > voteResults.frame2) return conflict.frameId1;\n    if (voteResults.frame2 > voteResults.frame1) return conflict.frameId2;\n    if (voteResults.both > voteResults.neither) return 'both';\n    return 'neither';\n  }\n\n  /**\n   * Determine preferred stack for senior override\n   */\n  private determinePreferredStack(\n    stack1: FrameStack,\n    stack2: FrameStack,\n    context: ResolutionContext\n  ): FrameStack {\n    // Check if senior owns one of the stacks\n    if (stack1.owner === context.userId) return stack1;\n    if (stack2.owner === context.userId) return stack2;\n\n    // Otherwise, prefer more recent/complete stack\n    if (stack1.lastModified > stack2.lastModified) return stack1;\n    if (\n      stack2.frames.filter((f) => f.state === 'closed').length >\n      stack1.frames.filter((f) => f.state === 'closed').length\n    ) {\n      return stack2;\n    }\n\n    return stack1;\n  }\n\n  /**\n   * Analyze frame quality for AI suggestions\n   */\n  private async analyzeFrameQuality(\n    stack1: FrameStack,\n    stack2: FrameStack\n  ): Promise<any> {\n    const analysis = {\n      stack1: {\n        completeness: this.calculateCompleteness(stack1),\n        efficiency: this.calculateEfficiency(stack1),\n        quality: this.calculateQuality(stack1),\n      },\n      stack2: {\n        completeness: this.calculateCompleteness(stack2),\n        efficiency: this.calculateEfficiency(stack2),\n        quality: this.calculateQuality(stack2),\n      },\n    };\n\n    return analysis;\n  }\n\n  /**\n   * Calculate stack completeness\n   */\n  private calculateCompleteness(stack: FrameStack): number {\n    const closedFrames = stack.frames.filter(\n      (f) => f.state === 'closed'\n    ).length;\n    return closedFrames / stack.frames.length;\n  }\n\n  /**\n   * Calculate stack efficiency\n   */\n  private calculateEfficiency(stack: FrameStack): number {\n    let totalDuration = 0;\n    let completedFrames = 0;\n\n    for (const frame of stack.frames) {\n      if (frame.closed_at && frame.created_at) {\n        totalDuration += frame.closed_at - frame.created_at;\n        completedFrames++;\n      }\n    }\n\n    if (completedFrames === 0) return 0;\n\n    const avgDuration = totalDuration / completedFrames;\n    // Normalize: 5 minutes = 1.0, longer = lower score\n    return Math.max(0, Math.min(1, 300000 / avgDuration));\n  }\n\n  /**\n   * Calculate stack quality\n   */\n  private calculateQuality(stack: FrameStack): number {\n    let qualityScore = 0;\n\n    for (const frame of stack.frames) {\n      if (frame.outputs && Object.keys(frame.outputs).length > 0)\n        qualityScore += 0.3;\n      if (frame.digest_text) qualityScore += 0.3;\n      if (frame.state === 'closed') qualityScore += 0.4;\n    }\n\n    return Math.min(1, qualityScore / stack.frames.length);\n  }\n\n  /**\n   * Generate AI reasoning for resolution\n   */\n  private generateAIReasoning(analysis: any): string {\n    const stack1Score =\n      analysis.stack1.completeness * 0.3 +\n      analysis.stack1.efficiency * 0.3 +\n      analysis.stack1.quality * 0.4;\n\n    const stack2Score =\n      analysis.stack2.completeness * 0.3 +\n      analysis.stack2.efficiency * 0.3 +\n      analysis.stack2.quality * 0.4;\n\n    if (stack1Score > stack2Score) {\n      return `Stack 1 shows higher overall quality (${(stack1Score * 100).toFixed(1)}% vs ${(stack2Score * 100).toFixed(1)}%)`;\n    } else {\n      return `Stack 2 shows higher overall quality (${(stack2Score * 100).toFixed(1)}% vs ${(stack1Score * 100).toFixed(1)}%)`;\n    }\n  }\n\n  /**\n   * Get AI recommendation for specific conflict\n   */\n  private getAIRecommendation(conflict: MergeConflict, analysis: any): string {\n    switch (conflict.type) {\n      case 'parallel_solution':\n        return 'Recommend keeping both solutions for A/B testing';\n\n      case 'conflicting_decision':\n        return 'Recommend the decision with higher quality score';\n\n      case 'structural_divergence':\n        return 'Recommend restructuring to accommodate both approaches';\n\n      default:\n        return 'Recommend manual review for this conflict';\n    }\n  }\n\n  /**\n   * Create rollback point before merge\n   */\n  private createRollbackPoint(stack1: FrameStack, stack2: FrameStack): string {\n    const rollbackId = uuidv4();\n\n    // Store current state for rollback\n    const rollbackData = {\n      id: rollbackId,\n      timestamp: Date.now(),\n      stack1: JSON.parse(JSON.stringify(stack1)),\n      stack2: JSON.parse(JSON.stringify(stack2)),\n    };\n\n    // In real implementation, persist this to database\n    logger.info('Created rollback point', { rollbackId });\n\n    return rollbackId;\n  }\n\n  /**\n   * Merge frames based on resolution\n   */\n  private mergeFrames(\n    stack1: FrameStack,\n    stack2: FrameStack,\n    conflicts: MergeConflict[],\n    resolution: ConflictResolution\n  ): Frame[] {\n    const mergedFrames: Frame[] = [];\n    const processedIds = new Set<string>();\n\n    // Process based on resolution strategy\n    switch (resolution.strategy.type) {\n      case 'keep_both':\n        // Add all frames from both stacks\n        mergedFrames.push(...stack1.frames, ...stack2.frames);\n        break;\n\n      case 'team_vote':\n      case 'senior_override':\n      case 'ai_suggest':\n        // Add frames based on resolution decisions\n        for (const frame of stack1.frames) {\n          const conflict = conflicts.find((c) => c.frameId1 === frame.frame_id);\n          if (!conflict || conflict.resolution?.strategy.type === 'keep_both') {\n            mergedFrames.push(frame);\n            processedIds.add(frame.frame_id);\n          }\n        }\n\n        for (const frame of stack2.frames) {\n          if (!processedIds.has(frame.frame_id)) {\n            const conflict = conflicts.find(\n              (c) => c.frameId2 === frame.frame_id\n            );\n            if (\n              !conflict ||\n              conflict.resolution?.strategy.type === 'keep_both'\n            ) {\n              mergedFrames.push(frame);\n            }\n          }\n        }\n        break;\n\n      case 'hybrid':\n        // Complex merging based on conflict types\n        this.hybridMerge(stack1, stack2, conflicts, mergedFrames);\n        break;\n    }\n\n    return mergedFrames;\n  }\n\n  /**\n   * Hybrid merge implementation\n   */\n  private hybridMerge(\n    stack1: FrameStack,\n    stack2: FrameStack,\n    conflicts: MergeConflict[],\n    mergedFrames: Frame[]\n  ): void {\n    const conflictMap = new Map<string, MergeConflict>();\n\n    for (const conflict of conflicts) {\n      conflictMap.set(conflict.frameId1, conflict);\n      conflictMap.set(conflict.frameId2, conflict);\n    }\n\n    // Process each frame based on its conflict type\n    for (const frame of [...stack1.frames, ...stack2.frames]) {\n      const conflict = conflictMap.get(frame.frame_id);\n\n      if (!conflict) {\n        // No conflict, add frame\n        if (!mergedFrames.find((f) => f.frame_id === frame.frame_id)) {\n          mergedFrames.push(frame);\n        }\n      } else if (conflict.type === 'parallel_solution') {\n        // Keep both for parallel solutions\n        if (!mergedFrames.find((f) => f.frame_id === frame.frame_id)) {\n          mergedFrames.push(frame);\n        }\n      }\n      // Other conflict types handled by resolution\n    }\n  }\n\n  /**\n   * Validate merge integrity\n   */\n  private validateMerge(\n    mergedFrames: Frame[],\n    conflicts: MergeConflict[]\n  ): boolean {\n    // Check for duplicate frame IDs\n    const ids = new Set<string>();\n    for (const frame of mergedFrames) {\n      if (ids.has(frame.frame_id)) {\n        logger.error('Duplicate frame ID in merge', {\n          frameId: frame.frame_id,\n        });\n        return false;\n      }\n      ids.add(frame.frame_id);\n    }\n\n    // Check parent-child relationships\n    for (const frame of mergedFrames) {\n      if (frame.parent_frame_id) {\n        const parent = mergedFrames.find(\n          (f) => f.frame_id === frame.parent_frame_id\n        );\n        if (!parent) {\n          logger.warn('Orphaned frame in merge', { frameId: frame.frame_id });\n        }\n      }\n    }\n\n    // Check all conflicts have resolutions\n    for (const conflict of conflicts) {\n      if (!conflict.resolution) {\n        logger.error('Unresolved conflict in merge', {\n          conflictId: conflict.id,\n        });\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Send notifications about merge\n   */\n  private async sendNotifications(\n    conflicts: MergeConflict[],\n    resolution: ConflictResolution\n  ): Promise<NotificationResult[]> {\n    const notifications: NotificationResult[] = [];\n\n    // In real implementation, send actual notifications\n    // For now, simulate notification sending\n    const notification: NotificationResult = {\n      userId: resolution.resolvedBy || 'team',\n      type: 'in-app',\n      sent: true,\n      timestamp: Date.now(),\n    };\n\n    notifications.push(notification);\n\n    logger.info('Notifications sent', { count: notifications.length });\n\n    return notifications;\n  }\n\n  /**\n   * Store resolution in history\n   */\n  private storeResolution(\n    mergeId: string,\n    resolution: ConflictResolution\n  ): void {\n    this.resolutionHistory.set(mergeId, resolution);\n\n    // In real implementation, persist to database\n    logger.info('Resolution stored in history', {\n      mergeId,\n      strategy: resolution.strategy.type,\n    });\n  }\n\n  /**\n   * Get resolution history for analysis\n   */\n  getResolutionHistory(): Map<string, ConflictResolution> {\n    return this.resolutionHistory;\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}