@lov3kaizen/agentsea-debugger 0.5.1

package/dist/analysis/index.js

@@ -0,0 +1,1840 @@
+import { EventEmitter } from 'eventemitter3';
+import { nanoid } from 'nanoid';
+
+// src/analysis/WhatIfEngine.ts
+function generateId(prefix = "") {
+  const id = nanoid(12);
+  return prefix ? `${prefix}_${id}` : id;
+}
+function now() {
+  return Date.now();
+}
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item));
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  if (obj instanceof Map) {
+    const clonedMap = /* @__PURE__ */ new Map();
+    obj.forEach((value, key) => {
+      clonedMap.set(deepClone(key), deepClone(value));
+    });
+    return clonedMap;
+  }
+  if (obj instanceof Set) {
+    const clonedSet = /* @__PURE__ */ new Set();
+    obj.forEach((value) => {
+      clonedSet.add(deepClone(value));
+    });
+    return clonedSet;
+  }
+  const clonedObj = {};
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      clonedObj[key] = deepClone(
+        obj[key]
+      );
+    }
+  }
+  return clonedObj;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/utils/diff.ts
+function diff(lhs, rhs, path = []) {
+  const differences = [];
+  if (lhs === rhs) {
+    return differences;
+  }
+  if (lhs === null || lhs === void 0) {
+    if (rhs !== null && rhs !== void 0) {
+      differences.push({ path, kind: "N", rhs });
+    }
+    return differences;
+  }
+  if (rhs === null || rhs === void 0) {
+    differences.push({ path, kind: "D", lhs });
+    return differences;
+  }
+  const lhsType = typeof lhs;
+  const rhsType = typeof rhs;
+  if (lhsType !== rhsType) {
+    differences.push({ path, kind: "E", lhs, rhs });
+    return differences;
+  }
+  if (lhsType !== "object") {
+    if (lhs !== rhs) {
+      differences.push({ path, kind: "E", lhs, rhs });
+    }
+    return differences;
+  }
+  if (Array.isArray(lhs) && Array.isArray(rhs)) {
+    const maxLen = Math.max(lhs.length, rhs.length);
+    for (let i = 0; i < maxLen; i++) {
+      if (i >= lhs.length) {
+        differences.push({
+          path,
+          kind: "A",
+          index: i,
+          item: { path: [...path, String(i)], kind: "N", rhs: rhs[i] }
+        });
+      } else if (i >= rhs.length) {
+        differences.push({
+          path,
+          kind: "A",
+          index: i,
+          item: { path: [...path, String(i)], kind: "D", lhs: lhs[i] }
+        });
+      } else {
+        const itemDiffs = diff(lhs[i], rhs[i], [...path, String(i)]);
+        differences.push(...itemDiffs);
+      }
+    }
+    return differences;
+  }
+  if (typeof lhs === "object" && typeof rhs === "object") {
+    const lhsObj = lhs;
+    const rhsObj = rhs;
+    const allKeys = /* @__PURE__ */ new Set([...Object.keys(lhsObj), ...Object.keys(rhsObj)]);
+    for (const key of allKeys) {
+      const keyPath = [...path, key];
+      if (!(key in lhsObj)) {
+        differences.push({ path: keyPath, kind: "N", rhs: rhsObj[key] });
+      } else if (!(key in rhsObj)) {
+        differences.push({ path: keyPath, kind: "D", lhs: lhsObj[key] });
+      } else {
+        const propDiffs = diff(lhsObj[key], rhsObj[key], keyPath);
+        differences.push(...propDiffs);
+      }
+    }
+  }
+  return differences;
+}
+function toReplayDifferences(diffs, stepIndex) {
+  return diffs.map((d) => ({
+    stepIndex,
+    path: d.path.join("."),
+    original: d.lhs,
+    replayed: d.rhs,
+    type: d.kind === "N" ? "added" : d.kind === "D" ? "removed" : "changed"
+  }));
+}
+function applyPatches(target, patches) {
+  let result = target;
+  for (const patch of patches) {
+    result = applyPatch(result, patch);
+  }
+  return result;
+}
+function applyPatch(target, patch) {
+  const result = JSON.parse(JSON.stringify(target));
+  if (patch.path.length === 0) {
+    return patch.rhs;
+  }
+  let current = result;
+  for (let i = 0; i < patch.path.length - 1; i++) {
+    const key = patch.path[i];
+    if (!(key in current)) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  const lastKey = patch.path[patch.path.length - 1];
+  switch (patch.kind) {
+    case "N":
+    case "E":
+      current[lastKey] = patch.rhs;
+      break;
+    case "D":
+      delete current[lastKey];
+      break;
+    case "A":
+      if (Array.isArray(current[lastKey]) && patch.item) {
+        const arr = current[lastKey];
+        if (patch.item.kind === "N") {
+          arr.splice(patch.index, 0, patch.item.rhs);
+        } else if (patch.item.kind === "D") {
+          arr.splice(patch.index, 1);
+        } else if (patch.item.kind === "E") {
+          arr[patch.index] = patch.item.rhs;
+        }
+      }
+      break;
+  }
+  return result;
+}
+
+// src/replay/StateRestorer.ts
+var DEFAULT_OPTIONS = {
+  includeMemory: true,
+  includeContext: true,
+  includeMessages: true,
+  includeTools: true
+};
+var StateRestorer = class {
+  options;
+  stateCache = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.options = {
+      ...DEFAULT_OPTIONS,
+      ...options
+    };
+  }
+  /**
+   * Restore state at a specific step
+   */
+  restore(recording, stepIndex) {
+    const cacheKey = recording.id;
+    const recordingCache = this.stateCache.get(cacheKey);
+    if (recordingCache?.has(stepIndex)) {
+      return deepClone(recordingCache.get(stepIndex));
+    }
+    if (stepIndex < 0) {
+      const state2 = deepClone(recording.initialState);
+      if (!recordingCache) {
+        this.stateCache.set(cacheKey, /* @__PURE__ */ new Map());
+      }
+      this.stateCache.get(cacheKey).set(stepIndex, deepClone(state2));
+      return state2;
+    }
+    let state;
+    let startStep;
+    const checkpoint = this.findClosestCheckpoint(recording, stepIndex);
+    if (checkpoint) {
+      if (checkpoint.stepIndex === stepIndex) {
+        state = deepClone(recording.initialState);
+        startStep = 0;
+      } else {
+        state = deepClone(recording.initialState);
+        startStep = 0;
+      }
+    } else {
+      state = deepClone(recording.initialState);
+      startStep = 0;
+    }
+    for (let i = startStep; i <= stepIndex && i < recording.steps.length; i++) {
+      state = this.applyStep(state, recording.steps[i]);
+    }
+    if (!recordingCache) {
+      this.stateCache.set(cacheKey, /* @__PURE__ */ new Map());
+    }
+    this.stateCache.get(cacheKey).set(stepIndex, deepClone(state));
+    return state;
+  }
+  /**
+   * Restore state from a checkpoint
+   */
+  restoreFromCheckpoint(checkpoint) {
+    return deepClone(checkpoint.state);
+  }
+  /**
+   * Apply a step to state
+   */
+  applyStep(state, step) {
+    const newState = deepClone(state);
+    switch (step.type) {
+      case "input":
+        if (this.options.includeMessages) {
+          newState.messages.push({
+            role: "user",
+            content: String(step.input)
+          });
+        }
+        break;
+      case "prompt":
+        break;
+      case "response":
+        if (this.options.includeMessages) {
+          newState.messages.push({
+            role: "assistant",
+            content: String(step.output)
+          });
+        }
+        break;
+      case "tool-call":
+        if (this.options.includeMessages && step.toolCall) {
+          newState.messages.push({
+            role: "assistant",
+            content: `[Calling tool: ${step.toolCall.name}]`,
+            toolCalls: [
+              {
+                id: step.toolCall.id,
+                name: step.toolCall.name,
+                arguments: step.toolCall.arguments
+              }
+            ]
+          });
+        }
+        break;
+      case "tool-result":
+        if (this.options.includeMessages && step.toolCall) {
+          newState.messages.push({
+            role: "tool",
+            content: String(step.toolCall.result ?? ""),
+            toolCallId: step.toolCall.id
+          });
+        }
+        break;
+      case "memory-write":
+        if (this.options.includeMemory && step.output) {
+          this.applyMemoryChange(
+            newState,
+            step.output
+          );
+        }
+        break;
+      case "memory-read":
+        break;
+      case "decision":
+        if (this.options.includeContext && step.decision) {
+          newState.context["lastDecision"] = {
+            options: step.decision.options.map((o) => o.description),
+            chosen: step.decision.chosen.description,
+            confidence: step.decision.confidence
+          };
+        }
+        break;
+      case "handoff":
+      case "delegation":
+        if (this.options.includeContext && step.output) {
+          const output = step.output;
+          newState.context["delegatedTo"] = output.agentId ?? output.agentName;
+        }
+        break;
+      case "error":
+        newState.context["lastError"] = step.error;
+        break;
+    }
+    return newState;
+  }
+  /**
+   * Apply memory changes to state
+   */
+  applyMemoryChange(state, changes) {
+    for (const [key, value] of Object.entries(changes)) {
+      if (key === "working") {
+        state.memory.working = {
+          ...state.memory.working,
+          ...value
+        };
+      } else if (key === "shortTerm" && Array.isArray(value)) {
+        state.memory.shortTerm = [...state.memory.shortTerm ?? [], ...value];
+      } else if (key === "longTermSummary" && typeof value === "string") {
+        state.memory.longTermSummary = value;
+      } else if (key === "size" && typeof value === "number") {
+        state.memory.size = value;
+      }
+    }
+  }
+  /**
+   * Find closest checkpoint before or at step
+   */
+  findClosestCheckpoint(recording, stepIndex) {
+    let closest;
+    for (const checkpoint of recording.checkpoints) {
+      if (checkpoint.stepIndex <= stepIndex) {
+        if (!closest || checkpoint.stepIndex > closest.stepIndex) {
+          closest = checkpoint;
+        }
+      }
+    }
+    return closest;
+  }
+  /**
+   * Apply a diff patch to state
+   */
+  applyPatch(state, differences) {
+    return applyPatches(state, differences);
+  }
+  /**
+   * Validate restored state
+   */
+  validate(state) {
+    const errors = [];
+    const warnings = [];
+    if (!state.agentId) {
+      errors.push("Missing agentId");
+    }
+    if (!state.agentName) {
+      warnings.push("Missing agentName");
+    }
+    if (!state.model) {
+      warnings.push("Missing model");
+    }
+    if (!state.memory) {
+      errors.push("Missing memory object");
+    } else {
+      if (typeof state.memory.size !== "number") {
+        warnings.push("Memory size should be a number");
+      }
+    }
+    if (!Array.isArray(state.messages)) {
+      errors.push("Messages should be an array");
+    } else {
+      for (let i = 0; i < state.messages.length; i++) {
+        const msg = state.messages[i];
+        if (!msg.role) {
+          errors.push(`Message ${i} missing role`);
+        }
+        if (msg.content === void 0 && !msg.toolCalls) {
+          warnings.push(`Message ${i} has no content or tool calls`);
+        }
+        if (typeof msg.content === "string" && msg.content.trim() === "") {
+          warnings.push(`Message ${i} has empty content`);
+        }
+      }
+    }
+    if (!state.context || typeof state.context !== "object") {
+      warnings.push("Context should be an object");
+    }
+    if (!Array.isArray(state.tools)) {
+      warnings.push("Tools should be an array");
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  /**
+   * Merge two states
+   */
+  merge(base, overlay) {
+    const merged = deepClone(base);
+    if (overlay.agentId) {
+      merged.agentId = overlay.agentId;
+    }
+    if (overlay.agentName) {
+      merged.agentName = overlay.agentName;
+    }
+    if (overlay.model) {
+      merged.model = overlay.model;
+    }
+    if (overlay.memory) {
+      merged.memory = {
+        ...merged.memory,
+        ...overlay.memory
+      };
+    }
+    if (overlay.context) {
+      merged.context = {
+        ...merged.context,
+        ...overlay.context
+      };
+    }
+    if (overlay.tools) {
+      merged.tools = [...overlay.tools];
+    }
+    if (overlay.messages) {
+      merged.messages = [...overlay.messages];
+    }
+    return merged;
+  }
+  /**
+   * Create a minimal state
+   */
+  createMinimalState(agentId, agentName, model) {
+    return {
+      agentId,
+      agentName,
+      model,
+      memory: {
+        size: 0
+      },
+      context: {},
+      tools: [],
+      messages: []
+    };
+  }
+  /**
+   * Clear state cache
+   */
+  clearCache() {
+    this.stateCache.clear();
+  }
+  /**
+   * Clear cache for specific recording
+   */
+  clearRecordingCache(recordingId) {
+    this.stateCache.delete(recordingId);
+  }
+  /**
+   * Get cache size
+   */
+  getCacheSize() {
+    let size = 0;
+    for (const cache of this.stateCache.values()) {
+      size += cache.size;
+    }
+    return size;
+  }
+};
+var ReplayController = class extends EventEmitter {
+  recording;
+  session;
+  config;
+  playbackState;
+  stateHistory = /* @__PURE__ */ new Map();
+  checkpointMap = /* @__PURE__ */ new Map();
+  constructor(recording, session, config) {
+    super();
+    this.recording = recording;
+    this.session = session;
+    this.config = config;
+    this.playbackState = {
+      currentStep: session.currentStep,
+      state: deepClone(recording.initialState),
+      isPaused: false
+    };
+    this.stateHistory.set(-1, deepClone(recording.initialState));
+    for (const checkpoint of recording.checkpoints) {
+      this.checkpointMap.set(checkpoint.id, checkpoint);
+    }
+  }
+  /**
+   * Step forward one step
+   */
+  stepForward() {
+    const nextStep = this.playbackState.currentStep + 1;
+    if (nextStep >= this.recording.steps.length) {
+      return void 0;
+    }
+    const step = this.recording.steps[nextStep];
+    const newState = this.applyStep(this.playbackState.state, step);
+    this.stateHistory.set(nextStep, deepClone(newState));
+    this.playbackState.currentStep = nextStep;
+    this.playbackState.state = newState;
+    this.session.currentStep = nextStep;
+    this.emit("step:replayed", step, newState);
+    this.checkPauseConditions(step);
+    return step;
+  }
+  /**
+   * Step backward one step
+   */
+  stepBackward() {
+    if (this.playbackState.currentStep < 0) {
+      return void 0;
+    }
+    const prevStep = this.playbackState.currentStep - 1;
+    let state = this.stateHistory.get(prevStep);
+    if (!state) {
+      state = this.rebuildStateAt(prevStep);
+      this.stateHistory.set(prevStep, deepClone(state));
+    }
+    this.playbackState.currentStep = prevStep;
+    this.playbackState.state = deepClone(state);
+    this.session.currentStep = Math.max(0, prevStep);
+    const stepIndex = prevStep - 1;
+    if (stepIndex >= 0 && stepIndex < this.recording.steps.length) {
+      const step = this.recording.steps[stepIndex];
+      this.emit("step:replayed", step, this.playbackState.state);
+      return step;
+    }
+    return void 0;
+  }
+  /**
+   * Jump to a specific step
+   */
+  jumpToStep(stepIndex) {
+    if (stepIndex < -1 || stepIndex >= this.recording.steps.length) {
+      return void 0;
+    }
+    let state = this.stateHistory.get(stepIndex);
+    if (!state) {
+      state = this.rebuildStateAt(stepIndex);
+      this.stateHistory.set(stepIndex, deepClone(state));
+    }
+    this.playbackState.currentStep = stepIndex;
+    this.playbackState.state = deepClone(state);
+    this.session.currentStep = Math.max(0, stepIndex);
+    if (stepIndex >= 0) {
+      const step = this.recording.steps[stepIndex];
+      this.emit("step:replayed", step, this.playbackState.state);
+      return step;
+    }
+    return void 0;
+  }
+  /**
+   * Jump to a checkpoint
+   */
+  jumpToCheckpoint(checkpointId) {
+    const checkpoint = this.checkpointMap.get(checkpointId);
+    if (!checkpoint) {
+      return false;
+    }
+    this.playbackState.currentStep = checkpoint.stepIndex;
+    this.playbackState.state = deepClone(checkpoint.state);
+    this.session.currentStep = checkpoint.stepIndex;
+    this.stateHistory.set(checkpoint.stepIndex, deepClone(checkpoint.state));
+    this.emit("checkpoint:reached", checkpoint);
+    if (checkpoint.stepIndex >= 0 && checkpoint.stepIndex < this.recording.steps.length) {
+      const step = this.recording.steps[checkpoint.stepIndex];
+      this.emit("step:replayed", step, this.playbackState.state);
+    }
+    return true;
+  }
+  /**
+   * Get next checkpoint
+   */
+  getNextCheckpoint() {
+    const currentStep = this.playbackState.currentStep;
+    for (const checkpoint of this.recording.checkpoints) {
+      if (checkpoint.stepIndex > currentStep) {
+        return checkpoint;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Get previous checkpoint
+   */
+  getPreviousCheckpoint() {
+    const currentStep = this.playbackState.currentStep;
+    let lastCheckpoint;
+    for (const checkpoint of this.recording.checkpoints) {
+      if (checkpoint.stepIndex < currentStep) {
+        lastCheckpoint = checkpoint;
+      } else {
+        break;
+      }
+    }
+    return lastCheckpoint;
+  }
+  /**
+   * Pause playback
+   */
+  pause(reason) {
+    this.playbackState.isPaused = true;
+    this.playbackState.pauseReason = reason;
+    this.emit("paused", reason ?? "Manual pause");
+  }
+  /**
+   * Resume playback
+   */
+  resume() {
+    this.playbackState.isPaused = false;
+    this.playbackState.pauseReason = void 0;
+    this.emit("resumed");
+  }
+  /**
+   * Get current step
+   */
+  getCurrentStep() {
+    const index = this.playbackState.currentStep;
+    if (index >= 0 && index < this.recording.steps.length) {
+      return this.recording.steps[index];
+    }
+    return void 0;
+  }
+  /**
+   * Get current state
+   */
+  getCurrentState() {
+    return deepClone(this.playbackState.state);
+  }
+  /**
+   * Get playback state
+   */
+  getPlaybackState() {
+    return { ...this.playbackState };
+  }
+  /**
+   * Check if at beginning
+   */
+  isAtBeginning() {
+    return this.playbackState.currentStep <= 0;
+  }
+  /**
+   * Check if at end
+   */
+  isAtEnd() {
+    return this.playbackState.currentStep >= this.recording.steps.length - 1;
+  }
+  /**
+   * Get progress percentage
+   */
+  getProgress() {
+    if (this.recording.steps.length === 0) {
+      return 100;
+    }
+    return (this.playbackState.currentStep + 1) / this.recording.steps.length * 100;
+  }
+  /**
+   * Apply a step to state
+   */
+  applyStep(state, step) {
+    const newState = deepClone(state);
+    switch (step.type) {
+      case "input":
+        newState.messages.push({
+          role: "user",
+          content: String(step.input)
+        });
+        break;
+      case "response":
+        newState.messages.push({
+          role: "assistant",
+          content: String(step.output)
+        });
+        break;
+      case "tool-call":
+        if (step.toolCall) {
+          newState.messages.push({
+            role: "assistant",
+            content: `[Tool Call: ${step.toolCall.name}]`
+          });
+        }
+        break;
+      case "tool-result":
+        if (step.toolCall) {
+          newState.messages.push({
+            role: "tool",
+            content: String(step.toolCall.result)
+          });
+        }
+        break;
+      case "memory-write":
+        if (step.output && typeof step.output === "object") {
+          Object.assign(newState.memory, step.output);
+        }
+        break;
+    }
+    return newState;
+  }
+  /**
+   * Rebuild state at a specific step
+   */
+  rebuildStateAt(targetStep) {
+    let startStep = -1;
+    let state = deepClone(this.recording.initialState);
+    for (let i = targetStep; i >= -1; i--) {
+      const cached = this.stateHistory.get(i);
+      if (cached) {
+        startStep = i;
+        state = deepClone(cached);
+        break;
+      }
+    }
+    for (const checkpoint of this.recording.checkpoints) {
+      if (checkpoint.stepIndex > startStep && checkpoint.stepIndex <= targetStep) {
+        startStep = checkpoint.stepIndex;
+        state = deepClone(checkpoint.state);
+      }
+    }
+    for (let i = startStep + 1; i <= targetStep; i++) {
+      if (i >= 0 && i < this.recording.steps.length) {
+        state = this.applyStep(state, this.recording.steps[i]);
+      }
+    }
+    return state;
+  }
+  /**
+   * Check pause conditions
+   */
+  checkPauseConditions(step) {
+    if (this.config.pauseOnDecisions && step.type === "decision") {
+      this.pause("Decision point");
+    }
+    if (this.config.pauseOnErrors && step.error) {
+      this.pause("Error occurred");
+    }
+    if (this.config.pauseOnToolCalls && step.type === "tool-call") {
+      this.pause("Tool call");
+    }
+  }
+  /**
+   * Get all checkpoints
+   */
+  getCheckpoints() {
+    return this.recording.checkpoints;
+  }
+  /**
+   * Get steps count
+   */
+  get stepsCount() {
+    return this.recording.steps.length;
+  }
+};
+
+// src/replay/ReplayEngine.ts
+var DEFAULT_CONFIG = {
+  speedMultiplier: 1,
+  pauseOnDecisions: false,
+  pauseOnErrors: true,
+  pauseOnToolCalls: false,
+  executeTools: false,
+  executeLLM: false,
+  compareResults: true,
+  trackDifferences: true
+};
+var ReplayEngine = class extends EventEmitter {
+  config;
+  sessions = /* @__PURE__ */ new Map();
+  currentSession;
+  stateRestorer;
+  controller;
+  isRunning = false;
+  constructor(config) {
+    super();
+    this.config = {
+      ...DEFAULT_CONFIG,
+      ...config
+    };
+    this.stateRestorer = new StateRestorer();
+  }
+  /**
+   * Start a replay session
+   */
+  start(recording, options) {
+    const session = {
+      id: generateId("replay"),
+      recordingId: recording.id,
+      state: "idle",
+      currentStep: options?.startStep ?? 0,
+      totalSteps: recording.steps.length,
+      speed: options?.speed ?? "normal",
+      startedAt: now(),
+      modifications: options?.modifications ?? [],
+      differences: []
+    };
+    this.sessions.set(session.id, session);
+    this.currentSession = session;
+    this.controller = new ReplayController(recording, session, {
+      ...this.config,
+      speedMultiplier: this.getSpeedMultiplier(session.speed)
+    });
+    this.controller.on("step:replayed", (step, state) => {
+      this.emit("step:replayed", step, state);
+    });
+    this.controller.on("paused", () => {
+      session.state = "paused";
+      this.emit("replay:paused", session);
+    });
+    this.controller.on("error", (error) => {
+      this.emit("error", error);
+    });
+    this.emit("replay:started", session);
+    this.runReplay(recording, session, options).catch((error) => {
+      this.emit("error", error);
+    });
+    return session;
+  }
+  /**
+   * Run the replay loop
+   */
+  async runReplay(recording, session, options) {
+    this.isRunning = true;
+    const startStep = options?.startStep ?? 0;
+    const endStep = options?.endStep ?? recording.steps.length - 1;
+    let currentState = this.stateRestorer.restore(
+      recording,
+      startStep > 0 ? startStep - 1 : 0
+    );
+    const replayedSteps = [];
+    const differences = [];
+    for (let i = startStep; i <= endStep && this.isRunning; i++) {
+      while (session.state === "paused" && this.isRunning) {
+        await sleep(100);
+      }
+      if (!this.isRunning) {
+        break;
+      }
+      const originalStep = recording.steps[i];
+      let step = deepClone(originalStep);
+      const modification = options?.modifications?.find(
+        (m) => m.stepIndex === i
+      );
+      if (modification) {
+        step = this.applyModification(step, modification);
+        this.emit("step:modified", originalStep, step);
+      }
+      const result2 = await this.executeStep(step, currentState, options);
+      if (this.config.trackDifferences && result2.executed) {
+        const stepDiffs = this.compareResults(originalStep, result2.step);
+        if (stepDiffs.length > 0) {
+          differences.push(...stepDiffs);
+          session.differences = differences;
+          this.emit("divergence:detected", stepDiffs);
+        }
+      }
+      replayedSteps.push(result2.step);
+      currentState = result2.state;
+      session.currentStep = i;
+      const delay = this.getStepDelay(step, session.speed);
+      if (delay > 0) {
+        await sleep(delay);
+      }
+      this.emit("step:replayed", result2.step, currentState);
+      if (this.shouldPause(step)) {
+        session.state = "paused";
+        this.emit("replay:paused", session);
+      }
+    }
+    const result = {
+      sessionId: session.id,
+      recordingId: recording.id,
+      success: this.isRunning,
+      stepsReplayed: replayedSteps.length,
+      differences,
+      finalState: currentState,
+      startedAt: session.startedAt,
+      completedAt: now(),
+      durationMs: now() - session.startedAt
+    };
+    session.state = "completed";
+    session.completedAt = result.completedAt;
+    this.isRunning = false;
+    this.emit("replay:completed", result);
+  }
+  /**
+   * Execute a step during replay
+   */
+  async executeStep(step, state, options) {
+    const newStep = deepClone(step);
+    let newState = deepClone(state);
+    let executed = false;
+    if (step.type === "tool-call" && options?.executeTools && options?.onToolCall) {
+      try {
+        const result = await options.onToolCall(step);
+        newStep.toolCall = {
+          ...newStep.toolCall,
+          result,
+          success: true
+        };
+        executed = true;
+      } catch (error) {
+        newStep.toolCall = {
+          ...newStep.toolCall,
+          result: error.message,
+          success: false
+        };
+        executed = true;
+      }
+    }
+    if (step.type === "response" && options?.executeLLM && options?.onLLMCall) {
+      try {
+        const response = await options.onLLMCall(step);
+        newStep.output = response;
+        executed = true;
+      } catch (error) {
+        newStep.error = {
+          name: "LLMError",
+          message: error.message
+        };
+        executed = true;
+      }
+    }
+    newState = this.updateState(newState, newStep);
+    return { step: newStep, state: newState, executed };
+  }
+  /**
+   * Update state based on step
+   */
+  updateState(state, step) {
+    const newState = deepClone(state);
+    if (step.type === "input") {
+      newState.messages.push({
+        role: "user",
+        content: String(step.input)
+      });
+    } else if (step.type === "response") {
+      newState.messages.push({
+        role: "assistant",
+        content: String(step.output)
+      });
+    }
+    return newState;
+  }
+  /**
+   * Apply a modification to a step
+   */
+  applyModification(step, modification) {
+    const modified = deepClone(step);
+    switch (modification.type) {
+      case "skip":
+        modified.metadata = {
+          ...modified.metadata,
+          skipped: true
+        };
+        break;
+      case "modify":
+        if (modification.data) {
+          Object.assign(modified, modification.data);
+        }
+        break;
+      case "insert":
+        break;
+      case "replace":
+        if (modification.data) {
+          return {
+            ...modified,
+            ...modification.data
+          };
+        }
+        break;
+    }
+    return modified;
+  }
+  /**
+   * Compare original and replayed results
+   */
+  compareResults(original, replayed) {
+    const differences = diff(original, replayed);
+    return toReplayDifferences(differences, original.index);
+  }
+  /**
+   * Check if should pause on this step
+   */
+  shouldPause(step) {
+    if (this.config.pauseOnDecisions && step.type === "decision") {
+      return true;
+    }
+    if (this.config.pauseOnErrors && step.error) {
+      return true;
+    }
+    if (this.config.pauseOnToolCalls && step.type === "tool-call") {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get speed multiplier
+   */
+  getSpeedMultiplier(speed) {
+    switch (speed) {
+      case "slow":
+        return 0.5;
+      case "normal":
+        return 1;
+      case "fast":
+        return 2;
+      case "instant":
+        return 0;
+      default:
+        return 1;
+    }
+  }
+  /**
+   * Get delay for step based on speed
+   */
+  getStepDelay(step, speed) {
+    if (speed === "instant") {
+      return 0;
+    }
+    const baseDelay = step.durationMs ?? 100;
+    const multiplier = this.getSpeedMultiplier(speed);
+    return baseDelay / multiplier;
+  }
+  /**
+   * Pause current replay
+   */
+  pause() {
+    if (this.currentSession && this.currentSession.state !== "paused" && this.currentSession.state !== "stopped") {
+      this.currentSession.state = "paused";
+      this.emit("replay:paused", this.currentSession);
+    }
+  }
+  /**
+   * Resume current replay
+   */
+  resume() {
+    if (this.currentSession && this.currentSession.state === "paused") {
+      this.currentSession.state = "playing";
+      this.emit("replay:resumed", this.currentSession);
+    }
+  }
+  /**
+   * Stop current replay
+   */
+  stop() {
+    this.isRunning = false;
+    if (this.currentSession) {
+      this.currentSession.state = "stopped";
+      this.emit("replay:stopped", this.currentSession);
+    }
+  }
+  /**
+   * Set replay speed
+   */
+  setSpeed(speed) {
+    if (this.currentSession) {
+      this.currentSession.speed = speed;
+    }
+  }
+  /**
+   * Jump to step
+   */
+  jumpToStep(stepIndex) {
+    if (!this.currentSession) {
+      return;
+    }
+    this.currentSession.currentStep = stepIndex;
+  }
+  /**
+   * Get current session
+   */
+  getSession() {
+    return this.currentSession;
+  }
+  /**
+   * Get session by ID
+   */
+  getSessionById(id) {
+    return this.sessions.get(id);
+  }
+  /**
+   * Get all sessions
+   */
+  getSessions() {
+    return Array.from(this.sessions.values());
+  }
+};
+
+// src/analysis/WhatIfEngine.ts
+var WhatIfEngine = class extends EventEmitter {
+  scenarios = /* @__PURE__ */ new Map();
+  results = /* @__PURE__ */ new Map();
+  replayEngine;
+  stateRestorer;
+  constructor() {
+    super();
+    this.replayEngine = new ReplayEngine();
+    this.stateRestorer = new StateRestorer();
+  }
+  /**
+   * Create a what-if scenario
+   */
+  createScenario(options) {
+    const scenario = {
+      id: generateId("whatif"),
+      name: options.name,
+      description: options.description,
+      baseRecordingId: options.recordingId,
+      modifications: options.modifications,
+      createdAt: now(),
+      status: "pending"
+    };
+    this.scenarios.set(scenario.id, scenario);
+    this.emit("scenario:created", scenario);
+    return scenario;
+  }
+  /**
+   * Run a scenario
+   */
+  async runScenario(scenarioId, recording, options) {
+    const scenario = this.scenarios.get(scenarioId);
+    if (!scenario) {
+      throw new Error(`Scenario not found: ${scenarioId}`);
+    }
+    scenario.status = "running";
+    this.emit("scenario:started", scenarioId);
+    try {
+      this.replayEngine.start(recording, {
+        modifications: scenario.modifications,
+        executeTools: options?.executeTools,
+        executeLLM: options?.executeLLM,
+        onToolCall: options?.onToolCall,
+        onLLMCall: options?.onLLMCall
+      });
+      await this.waitForReplayCompletion();
+      const replaySession = this.replayEngine.getSession();
+      const differences = replaySession?.differences ?? [];
+      const result = {
+        scenarioId,
+        success: true,
+        originalRecordingId: recording.id,
+        modifiedSteps: scenario.modifications.length,
+        differences,
+        divergencePoint: differences.length > 0 ? differences[0].stepIndex : void 0,
+        finalState: replaySession ? deepClone(recording.finalState ?? recording.initialState) : recording.finalState ?? recording.initialState,
+        executedAt: now(),
+        durationMs: now() - scenario.createdAt
+      };
+      scenario.status = "completed";
+      this.results.set(scenarioId, result);
+      this.emit("scenario:completed", result);
+      return result;
+    } catch (error) {
+      scenario.status = "failed";
+      this.emit("scenario:failed", scenarioId, error);
+      throw error;
+    }
+  }
+  /**
+   * Wait for replay to complete
+   */
+  waitForReplayCompletion() {
+    return new Promise((resolve) => {
+      const handler = () => {
+        this.replayEngine.off("replay:completed", handler);
+        this.replayEngine.off("replay:stopped", handler);
+        resolve();
+      };
+      this.replayEngine.on("replay:completed", handler);
+      this.replayEngine.on("replay:stopped", handler);
+    });
+  }
+  /**
+   * Run multiple scenarios in batch
+   */
+  async runBatch(options, recording) {
+    const scenarios = options.variations.map(
+      (v) => this.createScenario({
+        name: v.name,
+        recordingId: options.recordingId,
+        modifications: v.modifications
+      })
+    );
+    if (options.parallel) {
+      return Promise.all(
+        scenarios.map((s) => this.runScenario(s.id, recording))
+      );
+    } else {
+      const results = [];
+      for (const scenario of scenarios) {
+        const result = await this.runScenario(scenario.id, recording);
+        results.push(result);
+      }
+      return results;
+    }
+  }
+  /**
+   * Compare original recording with scenario result
+   */
+  compare(original, result) {
+    const scenario = this.scenarios.get(result.scenarioId);
+    const outcomeChanged = original.status !== (result.success ? "completed" : "failed");
+    const totalSteps = original.steps.length;
+    const divergenceStep = result.divergencePoint ?? totalSteps;
+    const divergencePercentage = (totalSteps - divergenceStep) / totalSteps * 100;
+    return {
+      scenarioId: result.scenarioId,
+      scenarioName: scenario?.name ?? "Unknown",
+      originalRecordingId: original.id,
+      outcomeChanged,
+      divergencePoint: result.divergencePoint,
+      divergencePercentage,
+      differences: result.differences,
+      summary: this.generateComparisonSummary(original, result)
+    };
+  }
+  /**
+   * Generate a summary of the comparison
+   */
+  generateComparisonSummary(original, result) {
+    const lines = [];
+    if (result.divergencePoint !== void 0) {
+      lines.push(`Diverged at step ${result.divergencePoint}`);
+    } else {
+      lines.push("No divergence detected");
+    }
+    lines.push(`${result.modifiedSteps} step(s) modified`);
+    lines.push(`${result.differences.length} difference(s) detected`);
+    return lines.join(". ");
+  }
+  /**
+   * Create scenario from a decision point
+   */
+  createFromDecision(recording, stepIndex, alternativeChoice) {
+    const step = recording.steps[stepIndex];
+    if (step.type !== "decision" || !step.decision) {
+      throw new Error("Step is not a decision point");
+    }
+    const alternative = step.decision.options.find(
+      (o) => o.id === alternativeChoice || o.description === alternativeChoice
+    );
+    if (!alternative) {
+      throw new Error("Alternative choice not found in decision options");
+    }
+    return this.createScenario({
+      name: `What if: ${alternative.description}`,
+      description: `Explore alternative decision at step ${stepIndex}`,
+      recordingId: recording.id,
+      modifications: [
+        {
+          stepIndex,
+          type: "modify",
+          data: {
+            decision: {
+              ...step.decision,
+              chosen: alternative
+            }
+          }
+        }
+      ]
+    });
+  }
+  /**
+   * Create scenario from a tool result change
+   */
+  createFromToolResult(recording, stepIndex, alternativeResult) {
+    const step = recording.steps[stepIndex];
+    if (step.type !== "tool-result" || !step.toolCall) {
+      throw new Error("Step is not a tool result");
+    }
+    return this.createScenario({
+      name: `What if: ${step.toolCall.name} returned different result`,
+      description: `Explore alternative tool result at step ${stepIndex}`,
+      recordingId: recording.id,
+      modifications: [
+        {
+          stepIndex,
+          type: "modify",
+          data: {
+            toolCall: {
+              ...step.toolCall,
+              result: alternativeResult
+            }
+          }
+        }
+      ]
+    });
+  }
+  /**
+   * Create scenario from skipping steps
+   */
+  createFromSkip(recording, stepIndices, name) {
+    return this.createScenario({
+      name: name ?? `What if: Skip steps ${stepIndices.join(", ")}`,
+      description: `Skip specific steps in the execution`,
+      recordingId: recording.id,
+      modifications: stepIndices.map((stepIndex) => ({
+        stepIndex,
+        type: "skip"
+      }))
+    });
+  }
+  /**
+   * Get a scenario by ID
+   */
+  getScenario(id) {
+    return this.scenarios.get(id);
+  }
+  /**
+   * Get all scenarios
+   */
+  getScenarios() {
+    return Array.from(this.scenarios.values());
+  }
+  /**
+   * Get scenarios for a recording
+   */
+  getScenariosForRecording(recordingId) {
+    return this.getScenarios().filter((s) => s.baseRecordingId === recordingId);
+  }
+  /**
+   * Get a result by scenario ID
+   */
+  getResult(scenarioId) {
+    return this.results.get(scenarioId);
+  }
+  /**
+   * Get all results
+   */
+  getResults() {
+    return Array.from(this.results.values());
+  }
+  /**
+   * Delete a scenario
+   */
+  deleteScenario(id) {
+    this.results.delete(id);
+    return this.scenarios.delete(id);
+  }
+  /**
+   * Clear all scenarios
+   */
+  clear() {
+    this.scenarios.clear();
+    this.results.clear();
+  }
+};
+function createWhatIfEngine() {
+  return new WhatIfEngine();
+}
+
+// src/analysis/FailureAnalyzer.ts
+var DEFAULT_PATTERNS = [
+  {
+    id: "repeated_tool_failure",
+    name: "Repeated Tool Failures",
+    description: "The same tool failed multiple times in succession",
+    matcher: (recording, steps) => {
+      const toolFailures = steps.filter(
+        (s) => s.type === "tool-result" && s.toolCall && !s.toolCall.success
+      );
+      if (toolFailures.length < 2) return false;
+      for (let i = 0; i < toolFailures.length - 1; i++) {
+        if (toolFailures[i].toolCall?.name === toolFailures[i + 1].toolCall?.name) {
+          return true;
+        }
+      }
+      return false;
+    },
+    severity: "high",
+    recommendations: [
+      "Add retry logic with exponential backoff",
+      "Implement fallback tools",
+      "Add input validation before tool calls"
+    ]
+  },
+  {
+    id: "low_confidence_decision",
+    name: "Low Confidence Decision",
+    description: "A critical decision was made with low confidence",
+    matcher: (recording, steps) => {
+      return steps.some(
+        (s) => s.type === "decision" && s.decision && s.decision.confidence < 0.5
+      );
+    },
+    severity: "medium",
+    recommendations: [
+      "Gather more context before making decisions",
+      "Request clarification from user for ambiguous cases",
+      "Add confidence thresholds that trigger fallback behavior"
+    ]
+  },
+  {
+    id: "infinite_loop",
+    name: "Potential Infinite Loop",
+    description: "Similar steps repeated many times without progress",
+    matcher: (recording, steps) => {
+      const stepTypes = steps.map((s) => s.type);
+      const windowSize = 3;
+      const minRepetitions = 4;
+      for (let i = 0; i <= stepTypes.length - windowSize * minRepetitions; i++) {
+        const window1 = stepTypes.slice(i, i + windowSize).join(",");
+        let repetitions = 1;
+        for (let j = i + windowSize; j <= stepTypes.length - windowSize; j += windowSize) {
+          const nextWindow = stepTypes.slice(j, j + windowSize).join(",");
+          if (nextWindow === window1) {
+            repetitions++;
+          } else {
+            break;
+          }
+        }
+        if (repetitions >= minRepetitions) {
+          return true;
+        }
+      }
+      return false;
+    },
+    severity: "critical",
+    recommendations: [
+      "Add loop detection and break conditions",
+      "Track state changes to detect lack of progress",
+      "Implement maximum iteration limits"
+    ]
+  },
+  {
+    id: "missing_context",
+    name: "Missing Context",
+    description: "Tool or decision made without required context",
+    matcher: (recording, steps) => {
+      for (let i = 0; i < steps.length - 1; i++) {
+        if (steps[i].type === "input" && steps[i + 1].type === "tool-call") {
+          return true;
+        }
+      }
+      return false;
+    },
+    severity: "low",
+    recommendations: [
+      "Add context gathering step before tool calls",
+      "Use memory retrieval to provide relevant context",
+      "Implement input analysis before action"
+    ]
+  },
+  {
+    id: "memory_overflow",
+    name: "Memory Issues",
+    description: "Memory size grew excessively during execution",
+    matcher: (recording) => {
+      const initialSize = recording.initialState.memory.size;
+      const finalSize = recording.finalState?.memory?.size ?? 0;
+      return finalSize > initialSize * 10 && finalSize > 1024 * 1024;
+    },
+    severity: "medium",
+    recommendations: [
+      "Implement memory compaction",
+      "Add memory limits and eviction policies",
+      "Summarize long conversations"
+    ]
+  },
+  {
+    id: "timeout_likely",
+    name: "Slow Execution",
+    description: "Execution took excessively long, possibly due to timeouts",
+    matcher: (recording) => {
+      const avgDuration = recording.durationMs / recording.steps.length;
+      return avgDuration > 1e4;
+    },
+    severity: "medium",
+    recommendations: [
+      "Add timeout handling for external calls",
+      "Implement caching for repeated operations",
+      "Optimize tool implementations"
+    ]
+  }
+];
+var FailureAnalyzer = class {
+  patterns;
+  options;
+  constructor(options) {
+    this.options = {
+      includeDetailedSteps: options?.includeDetailedSteps ?? true,
+      includeMemoryAnalysis: options?.includeMemoryAnalysis ?? true,
+      includeTimingAnalysis: options?.includeTimingAnalysis ?? true,
+      customPatterns: options?.customPatterns ?? []
+    };
+    this.patterns = [...DEFAULT_PATTERNS, ...this.options.customPatterns];
+  }
+  /**
+   * Analyze a failed recording
+   */
+  analyze(recording) {
+    const contributingFactors = this.findContributingFactors(recording);
+    const rootCause = this.determineRootCause(recording, contributingFactors);
+    const recommendations = this.generateRecommendations(contributingFactors);
+    const errorStepIndex = this.findErrorStep(recording);
+    return {
+      id: generateId("analysis"),
+      recordingId: recording.id,
+      analyzedAt: now(),
+      rootCause,
+      contributingFactors,
+      recommendations,
+      errorStepIndex,
+      errorMessage: this.getErrorMessage(recording, errorStepIndex),
+      stackTrace: this.getStackTrace(recording, errorStepIndex),
+      severity: this.calculateOverallSeverity(contributingFactors),
+      confidence: this.calculateConfidence(contributingFactors)
+    };
+  }
+  /**
+   * Find contributing factors
+   */
+  findContributingFactors(recording) {
+    const factors = [];
+    for (const pattern of this.patterns) {
+      if (pattern.matcher(recording, recording.steps)) {
+        factors.push({
+          id: generateId("factor"),
+          type: pattern.id,
+          description: pattern.description,
+          severity: pattern.severity,
+          stepIndices: this.findPatternSteps(recording, pattern),
+          evidence: this.gatherEvidence(recording, pattern)
+        });
+      }
+    }
+    const errorSteps = recording.steps.filter((s) => s.error);
+    for (const step of errorSteps) {
+      factors.push({
+        id: generateId("factor"),
+        type: "explicit_error",
+        description: step.error?.message ?? "Unknown error",
+        severity: "high",
+        stepIndices: [step.index],
+        evidence: {
+          errorName: step.error?.name,
+          errorMessage: step.error?.message,
+          errorStack: step.error?.stack
+        }
+      });
+    }
+    const severityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+    factors.sort(
+      (a, b) => severityOrder[a.severity] - severityOrder[b.severity]
+    );
+    return factors;
+  }
+  /**
+   * Find steps related to a pattern
+   */
+  findPatternSteps(recording, pattern) {
+    const indices = [];
+    switch (pattern.id) {
+      case "repeated_tool_failure":
+        for (const step of recording.steps) {
+          if (step.type === "tool-result" && step.toolCall && !step.toolCall.success) {
+            indices.push(step.index);
+          }
+        }
+        break;
+      case "low_confidence_decision":
+        for (const step of recording.steps) {
+          if (step.type === "decision" && step.decision && step.decision.confidence < 0.5) {
+            indices.push(step.index);
+          }
+        }
+        break;
+      default:
+        for (const step of recording.steps) {
+          if (step.error) {
+            indices.push(step.index);
+          }
+        }
+    }
+    return indices;
+  }
+  /**
+   * Gather evidence for a pattern
+   */
+  gatherEvidence(recording, pattern) {
+    const evidence = {
+      patternId: pattern.id,
+      patternName: pattern.name
+    };
+    switch (pattern.id) {
+      case "repeated_tool_failure": {
+        const failures = recording.steps.filter(
+          (s) => s.type === "tool-result" && s.toolCall && !s.toolCall.success
+        );
+        evidence.failedTools = failures.map((s) => s.toolCall?.name);
+        evidence.failureCount = failures.length;
+        break;
+      }
+      case "low_confidence_decision": {
+        const lowConfidence = recording.steps.filter(
+          (s) => s.type === "decision" && s.decision && s.decision.confidence < 0.5
+        );
+        evidence.decisions = lowConfidence.map((s) => ({
+          step: s.index,
+          confidence: s.decision?.confidence,
+          reason: s.decision?.reason
+        }));
+        break;
+      }
+      case "timeout_likely":
+        evidence.totalDuration = recording.durationMs;
+        evidence.avgStepDuration = recording.durationMs / recording.steps.length;
+        break;
+      case "memory_overflow":
+        evidence.initialMemorySize = recording.initialState.memory.size;
+        evidence.finalMemorySize = recording.finalState?.memory?.size ?? 0;
+        evidence.growth = (recording.finalState?.memory?.size ?? 0) / recording.initialState.memory.size;
+        break;
+    }
+    return evidence;
+  }
+  /**
+   * Determine the root cause
+   */
+  determineRootCause(recording, factors) {
+    const explicitError = factors.find((f) => f.type === "explicit_error");
+    if (explicitError) {
+      return explicitError.description;
+    }
+    if (factors.length > 0) {
+      return factors[0].description;
+    }
+    if (recording.status === "failed") {
+      return "Execution failed without clear error indication";
+    }
+    return "No failure detected";
+  }
+  /**
+   * Generate recommendations
+   */
+  generateRecommendations(factors) {
+    const recommendations = [];
+    const seenRecommendations = /* @__PURE__ */ new Set();
+    for (const factor of factors) {
+      const pattern = this.patterns.find((p) => p.id === factor.type);
+      if (pattern) {
+        for (const rec of pattern.recommendations) {
+          if (!seenRecommendations.has(rec)) {
+            seenRecommendations.add(rec);
+            recommendations.push({
+              id: generateId("rec"),
+              priority: this.getPriorityFromSeverity(factor.severity),
+              title: rec,
+              description: `Based on pattern: ${pattern.name}`,
+              relatedFactors: [factor.id]
+            });
+          }
+        }
+      } else if (factor.type === "explicit_error") {
+        const defaultRecs = [
+          "Review the error message and stack trace",
+          "Add error handling and recovery logic",
+          "Validate inputs before operations"
+        ];
+        for (const rec of defaultRecs) {
+          if (!seenRecommendations.has(rec)) {
+            seenRecommendations.add(rec);
+            recommendations.push({
+              id: generateId("rec"),
+              priority: this.getPriorityFromSeverity(factor.severity),
+              title: rec,
+              description: `Based on explicit error: ${factor.description}`,
+              relatedFactors: [factor.id]
+            });
+          }
+        }
+      }
+    }
+    recommendations.sort((a, b) => a.priority - b.priority);
+    return recommendations;
+  }
+  /**
+   * Get priority from severity
+   */
+  getPriorityFromSeverity(severity) {
+    switch (severity) {
+      case "critical":
+        return 1;
+      case "high":
+        return 2;
+      case "medium":
+        return 3;
+      case "low":
+        return 4;
+      default:
+        return 5;
+    }
+  }
+  /**
+   * Find the error step
+   */
+  findErrorStep(recording) {
+    for (const step of recording.steps) {
+      if (step.error) {
+        return step.index;
+      }
+    }
+    for (let i = recording.steps.length - 1; i >= 0; i--) {
+      const step = recording.steps[i];
+      if (step.type === "tool-result" && step.toolCall && !step.toolCall.success) {
+        return step.index;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Get error message
+   */
+  getErrorMessage(recording, stepIndex) {
+    if (stepIndex === void 0) {
+      return void 0;
+    }
+    const step = recording.steps[stepIndex];
+    return step?.error?.message ?? step?.toolCall?.result;
+  }
+  /**
+   * Get stack trace
+   */
+  getStackTrace(recording, stepIndex) {
+    if (stepIndex === void 0) {
+      return void 0;
+    }
+    const step = recording.steps[stepIndex];
+    return step?.error?.stack;
+  }
+  /**
+   * Calculate overall severity
+   */
+  calculateOverallSeverity(factors) {
+    if (factors.length === 0) {
+      return "low";
+    }
+    const severities = factors.map((f) => f.severity);
+    if (severities.includes("critical")) return "critical";
+    if (severities.includes("high")) return "high";
+    if (severities.includes("medium")) return "medium";
+    return "low";
+  }
+  /**
+   * Calculate analysis confidence
+   */
+  calculateConfidence(factors) {
+    if (factors.length === 0) {
+      return 0.3;
+    }
+    let confidenceSum = 0;
+    for (const factor of factors) {
+      let factorConfidence = 0.5;
+      if (factor.type === "explicit_error") {
+        factorConfidence = 0.95;
+      } else if (Object.keys(factor.evidence ?? {}).length > 2) {
+        factorConfidence = 0.8;
+      }
+      confidenceSum += factorConfidence;
+    }
+    return Math.min(confidenceSum / factors.length, 0.99);
+  }
+  /**
+   * Analyze individual steps
+   */
+  analyzeSteps(steps) {
+    const analyses = [];
+    for (const step of steps) {
+      const analysis = {
+        stepIndex: step.index,
+        type: step.type,
+        suspicious: false,
+        reasons: [],
+        relatedSteps: []
+      };
+      if (step.error) {
+        analysis.suspicious = true;
+        analysis.reasons.push(`Error: ${step.error.message}`);
+      }
+      if (step.type === "tool-result" && step.toolCall && !step.toolCall.success) {
+        analysis.suspicious = true;
+        analysis.reasons.push(`Tool ${step.toolCall.name} failed`);
+      }
+      if (step.type === "decision" && step.decision && step.decision.confidence < 0.5) {
+        analysis.suspicious = true;
+        analysis.reasons.push(
+          `Low confidence decision (${step.decision.confidence})`
+        );
+      }
+      if (step.durationMs && step.durationMs > 3e4) {
+        analysis.suspicious = true;
+        analysis.reasons.push(`Long duration (${step.durationMs}ms)`);
+      }
+      analyses.push(analysis);
+    }
+    return analyses;
+  }
+  /**
+   * Add a custom pattern
+   */
+  addPattern(pattern) {
+    this.patterns.push(pattern);
+  }
+  /**
+   * Remove a pattern
+   */
+  removePattern(patternId) {
+    const index = this.patterns.findIndex((p) => p.id === patternId);
+    if (index >= 0) {
+      this.patterns.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get all patterns
+   */
+  getPatterns() {
+    return [...this.patterns];
+  }
+};
+function createFailureAnalyzer(options) {
+  return new FailureAnalyzer(options);
+}
+
+export { FailureAnalyzer, WhatIfEngine, createFailureAnalyzer, createWhatIfEngine };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map