skill-tree 0.1.5 → 0.1.7

package/dist/chunk-K6NRCSAZ.mjs

@@ -1,4355 +0,0 @@
-// src/adapters/base.ts
-var BaseSessionAdapter = class {
-  /**
-   * Parse multiple sessions from a directory or concatenated file
-   */
-  async parseMany(input) {
-    const trajectory = await this.parse(input);
-    return [trajectory];
-  }
-  /**
-   * Generate a unique session ID if none provided
-   */
-  generateSessionId() {
-    return `session_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-  }
-  /**
-   * Safely parse JSON with error handling
-   */
-  safeJsonParse(input) {
-    try {
-      return JSON.parse(input);
-    } catch {
-      return null;
-    }
-  }
-};
-var AdapterRegistry = class {
-  constructor() {
-    this.adapters = /* @__PURE__ */ new Map();
-  }
-  register(adapter) {
-    this.adapters.set(adapter.name, adapter);
-  }
-  unregister(name) {
-    return this.adapters.delete(name);
-  }
-  get(name) {
-    return this.adapters.get(name);
-  }
-  /**
-   * Find an adapter that can handle the given input
-   */
-  findAdapter(input) {
-    for (const adapter of this.adapters.values()) {
-      if (adapter.canHandle(input)) {
-        return adapter;
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Find adapter by file extension
-   */
-  findByExtension(extension) {
-    const ext = extension.startsWith(".") ? extension : `.${extension}`;
-    for (const adapter of this.adapters.values()) {
-      if (adapter.supportedExtensions.includes(ext)) {
-        return adapter;
-      }
-    }
-    return void 0;
-  }
-  listAdapters() {
-    return Array.from(this.adapters.values());
-  }
-};
-var adapterRegistry = new AdapterRegistry();
-
-// src/adapters/claude-code.ts
-var ClaudeCodeAdapter = class extends BaseSessionAdapter {
-  constructor() {
-    super(...arguments);
-    this.name = "claude-code";
-    this.supportedExtensions = [".jsonl", ".json"];
-  }
-  canHandle(input) {
-    const str = typeof input === "string" ? input : input.toString("utf-8");
-    const firstLine = str.split("\n")[0]?.trim();
-    if (!firstLine) return false;
-    const parsed = this.safeJsonParse(firstLine);
-    if (!parsed) return false;
-    return parsed.type !== void 0 || parsed.message?.role !== void 0 || parsed.sessionId !== void 0;
-  }
-  async parse(input) {
-    const str = typeof input === "string" ? input : input.toString("utf-8");
-    const lines = str.split("\n").filter((line) => line.trim());
-    const messages = [];
-    for (const line of lines) {
-      const parsed = this.safeJsonParse(line);
-      if (parsed) {
-        messages.push(parsed);
-      }
-    }
-    return this.convertToTrajectory(messages);
-  }
-  async parseMany(input) {
-    const trajectory = await this.parse(input);
-    return [trajectory];
-  }
-  convertToTrajectory(messages) {
-    const turns = [];
-    let sessionId = this.generateSessionId();
-    let startedAt = /* @__PURE__ */ new Date();
-    let endedAt;
-    const metadata = {
-      agentType: "claude-code",
-      custom: {}
-    };
-    const pendingToolCalls = /* @__PURE__ */ new Map();
-    for (let i = 0; i < messages.length; i++) {
-      const msg = messages[i];
-      if (msg.sessionId) sessionId = msg.sessionId;
-      if (msg.timestamp) {
-        const ts = new Date(msg.timestamp);
-        if (i === 0) startedAt = ts;
-        endedAt = ts;
-      }
-      if (msg.cwd) metadata.workingDirectory = msg.cwd;
-      if (msg.model) metadata.model = msg.model;
-      if (msg.summary) continue;
-      if (msg.type === "result" && msg.toolUseId) {
-        const lastAssistantTurn = [...turns].reverse().find((t) => t.role === "assistant");
-        if (lastAssistantTurn) {
-          if (!lastAssistantTurn.toolResults) {
-            lastAssistantTurn.toolResults = [];
-          }
-          lastAssistantTurn.toolResults.push({
-            callId: msg.toolUseId,
-            name: msg.toolName || "unknown",
-            output: msg.result || "",
-            success: true
-            // Claude Code doesn't always indicate errors explicitly
-          });
-        }
-        continue;
-      }
-      if (msg.message) {
-        const turn = this.convertMessageToTurn(msg, turns.length, pendingToolCalls);
-        if (turn) {
-          turns.push(turn);
-        }
-      }
-    }
-    const outcome = this.inferOutcome(turns);
-    return {
-      sessionId,
-      startedAt,
-      endedAt,
-      turns,
-      metadata,
-      outcome
-    };
-  }
-  convertMessageToTurn(msg, index, pendingToolCalls) {
-    if (!msg.message) return null;
-    const { role, content } = msg.message;
-    const turn = {
-      index,
-      role,
-      content: "",
-      timestamp: msg.timestamp ? new Date(msg.timestamp) : void 0
-    };
-    if (typeof content === "string") {
-      turn.content = content;
-    } else if (Array.isArray(content)) {
-      const textParts = [];
-      const toolCalls = [];
-      const toolResults = [];
-      for (const block of content) {
-        if (block.type === "text" && block.text) {
-          textParts.push(block.text);
-        } else if (block.type === "tool_use" && block.name) {
-          const toolCall = {
-            name: block.name,
-            input: block.input || {},
-            callId: block.id
-          };
-          toolCalls.push(toolCall);
-          if (block.id) {
-            pendingToolCalls.set(block.id, toolCall);
-          }
-        } else if (block.type === "tool_result") {
-          const resultContent = this.extractToolResultContent(block.content);
-          toolResults.push({
-            callId: block.tool_use_id,
-            name: pendingToolCalls.get(block.tool_use_id || "")?.name || "unknown",
-            output: resultContent,
-            success: !block.is_error,
-            error: block.is_error ? resultContent : void 0
-          });
-        }
-      }
-      turn.content = textParts.join("\n");
-      if (toolCalls.length > 0) turn.toolCalls = toolCalls;
-      if (toolResults.length > 0) turn.toolResults = toolResults;
-    }
-    return turn;
-  }
-  extractToolResultContent(content) {
-    if (!content) return "";
-    if (typeof content === "string") return content;
-    if (Array.isArray(content)) {
-      return content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
-    }
-    return "";
-  }
-  inferOutcome(turns) {
-    const outcome = {
-      success: true,
-      // Default to success, look for failure signals
-      filesModified: [],
-      errors: []
-    };
-    for (const turn of turns) {
-      if (turn.content) {
-        const lowerContent = turn.content.toLowerCase();
-        if (lowerContent.includes("error") || lowerContent.includes("failed") || lowerContent.includes("couldn't") || lowerContent.includes("can't complete")) {
-          outcome.errors?.push(turn.content.substring(0, 200));
-        }
-      }
-      if (turn.toolResults) {
-        for (const result of turn.toolResults) {
-          if (!result.success && result.error) {
-            outcome.errors?.push(result.error.substring(0, 200));
-            outcome.success = false;
-          }
-        }
-      }
-      if (turn.toolCalls) {
-        for (const call of turn.toolCalls) {
-          if (["Write", "Edit", "MultiEdit"].includes(call.name)) {
-            const filePath = call.input.file_path || call.input.filePath;
-            if (typeof filePath === "string") {
-              outcome.filesModified?.push(filePath);
-            }
-          }
-        }
-      }
-    }
-    outcome.filesModified = [...new Set(outcome.filesModified)];
-    if (outcome.errors?.length === 0) {
-      outcome.success = true;
-    }
-    return outcome;
-  }
-};
-var claudeCodeAdapter = new ClaudeCodeAdapter();
-
-// src/extraction/quality-gates.ts
-var DEFAULT_QUALITY_GATES = [
-  {
-    name: "reusability",
-    type: "reusability",
-    description: "Skill should be applicable across multiple future tasks, not one-off",
-    required: true
-  },
-  {
-    name: "non-trivial",
-    type: "non-trivial",
-    description: "Skill should involve discovery beyond basic documentation lookup",
-    required: true
-  },
-  {
-    name: "specific-triggers",
-    type: "specific",
-    description: "Skill should have clear, specific trigger conditions",
-    required: true
-  },
-  {
-    name: "verified",
-    type: "verified",
-    description: "Skill solution should be verified to actually work",
-    required: false
-  }
-];
-var QualityGateEvaluator = class {
-  constructor(gates = DEFAULT_QUALITY_GATES) {
-    this.gates = gates;
-  }
-  /**
-   * Evaluate all quality gates for a skill candidate
-   */
-  async evaluate(skill, trajectory, turnRange) {
-    const results = [];
-    for (const gate of this.gates) {
-      const result = await this.evaluateGate(gate, skill, trajectory, turnRange);
-      results.push(result);
-    }
-    const passed = results.every((r) => {
-      const gate = this.gates.find((g) => g.name === r.gateName);
-      return !gate?.required || r.passed;
-    });
-    return { passed, results };
-  }
-  async evaluateGate(gate, skill, trajectory, turnRange) {
-    const turns = trajectory.turns.slice(turnRange[0], turnRange[1] + 1);
-    switch (gate.type) {
-      case "reusability":
-        return this.evaluateReusability(gate, skill, turns);
-      case "non-trivial":
-        return this.evaluateNonTrivial(gate, skill, turns);
-      case "specific":
-        return this.evaluateSpecificTriggers(gate, skill);
-      case "verified":
-        return this.evaluateVerified(gate, trajectory);
-      case "custom":
-        return this.evaluateCustom(gate, skill, trajectory, turns);
-      default:
-        return {
-          gateName: gate.name,
-          passed: true,
-          score: 1,
-          explanation: "Unknown gate type, passing by default"
-        };
-    }
-  }
-  evaluateReusability(gate, skill, turns) {
-    let score = 0;
-    const reasons = [];
-    const description = skill.description || "";
-    const problem = skill.problem || "";
-    const combined = `${description} ${problem}`.toLowerCase();
-    const reusabilitySignals = [
-      "error",
-      "bug",
-      "fix",
-      "pattern",
-      "when",
-      "if",
-      "always",
-      "common",
-      "typical",
-      "usually"
-    ];
-    const signalCount = reusabilitySignals.filter((s) => combined.includes(s)).length;
-    score += Math.min(signalCount * 0.15, 0.45);
-    const specificSignals = [
-      "this project",
-      "this repo",
-      "our codebase",
-      "specific to",
-      "only in"
-    ];
-    const specificCount = specificSignals.filter((s) => combined.includes(s)).length;
-    score -= specificCount * 0.2;
-    if (skill.triggerConditions && skill.triggerConditions.length > 0) {
-      const hasGenericTrigger = skill.triggerConditions.some(
-        (t) => t.type === "error" || t.type === "pattern"
-      );
-      if (hasGenericTrigger) {
-        score += 0.25;
-        reasons.push("Has generic trigger conditions");
-      }
-    }
-    const toolNames = /* @__PURE__ */ new Set();
-    for (const turn of turns) {
-      turn.toolCalls?.forEach((tc) => toolNames.add(tc.name));
-    }
-    if (toolNames.size > 2) {
-      score += 0.15;
-      reasons.push(`Uses ${toolNames.size} different tools`);
-    }
-    score = Math.max(0, Math.min(1, score + 0.3));
-    return {
-      gateName: gate.name,
-      passed: score >= 0.5,
-      score,
-      explanation: reasons.length > 0 ? reasons.join("; ") : score >= 0.5 ? "Skill appears reusable" : "Skill may be too project-specific"
-    };
-  }
-  evaluateNonTrivial(gate, skill, turns) {
-    let score = 0;
-    const reasons = [];
-    if (turns.length >= 5) {
-      score += 0.2;
-      reasons.push(`${turns.length} turns of investigation`);
-    } else if (turns.length >= 3) {
-      score += 0.1;
-    }
-    const hasErrors = turns.some(
-      (t) => t.toolResults?.some((r) => !r.success) || t.content?.toLowerCase().includes("error")
-    );
-    if (hasErrors) {
-      score += 0.25;
-      reasons.push("Involves error diagnosis/recovery");
-    }
-    const toolCallCounts = /* @__PURE__ */ new Map();
-    for (const turn of turns) {
-      turn.toolCalls?.forEach((tc) => {
-        toolCallCounts.set(tc.name, (toolCallCounts.get(tc.name) || 0) + 1);
-      });
-    }
-    const hasIteration = Array.from(toolCallCounts.values()).some((count) => count >= 3);
-    if (hasIteration) {
-      score += 0.2;
-      reasons.push("Shows iterative refinement");
-    }
-    const solutionLength = (skill.solution || "").length;
-    if (solutionLength > 500) {
-      score += 0.2;
-      reasons.push("Detailed solution");
-    } else if (solutionLength > 200) {
-      score += 0.1;
-    }
-    const nonObviousSignals = [
-      "workaround",
-      "trick",
-      "gotcha",
-      "subtle",
-      "hidden",
-      "unexpected",
-      "actually",
-      "turns out",
-      "discovered",
-      "realized"
-    ];
-    const content = `${skill.problem || ""} ${skill.solution || ""}`.toLowerCase();
-    const nonObviousCount = nonObviousSignals.filter((s) => content.includes(s)).length;
-    score += Math.min(nonObviousCount * 0.1, 0.25);
-    if (nonObviousCount > 0) {
-      reasons.push("Contains non-obvious discoveries");
-    }
-    score = Math.max(0, Math.min(1, score));
-    return {
-      gateName: gate.name,
-      passed: score >= 0.4,
-      score,
-      explanation: reasons.length > 0 ? reasons.join("; ") : score >= 0.4 ? "Skill involves non-trivial discovery" : "Skill may be too trivial (basic documentation lookup)"
-    };
-  }
-  evaluateSpecificTriggers(gate, skill) {
-    const triggers = skill.triggerConditions || [];
-    if (triggers.length === 0) {
-      return {
-        gateName: gate.name,
-        passed: false,
-        score: 0,
-        explanation: "No trigger conditions defined"
-      };
-    }
-    let score = 0;
-    const reasons = [];
-    for (const trigger of triggers) {
-      if (trigger.value && trigger.value.length > 10) {
-        score += 0.2;
-      }
-      if (trigger.description) {
-        score += 0.1;
-      }
-      if (trigger.type === "error" && trigger.value.length > 20) {
-        score += 0.15;
-        reasons.push("Has specific error trigger");
-      }
-      if (trigger.type === "pattern") {
-        score += 0.15;
-        reasons.push("Has pattern-based trigger");
-      }
-    }
-    score = Math.min(1, score);
-    return {
-      gateName: gate.name,
-      passed: score >= 0.4,
-      score,
-      explanation: reasons.length > 0 ? reasons.join("; ") : score >= 0.4 ? "Has specific trigger conditions" : "Trigger conditions need more specificity"
-    };
-  }
-  evaluateVerified(gate, trajectory) {
-    const success = trajectory.outcome?.success ?? false;
-    const hasVerification = trajectory.turns.some((t) => {
-      const content = t.content?.toLowerCase() || "";
-      return content.includes("works") || content.includes("fixed") || content.includes("solved") || content.includes("success");
-    });
-    const score = success ? 0.7 : hasVerification ? 0.5 : 0.2;
-    return {
-      gateName: gate.name,
-      passed: score >= 0.5,
-      score,
-      explanation: success ? "Session completed successfully" : hasVerification ? "Solution appears verified in conversation" : "Solution verification unclear"
-    };
-  }
-  evaluateCustom(gate, _skill, _trajectory, _turns) {
-    return {
-      gateName: gate.name,
-      passed: true,
-      score: 1,
-      explanation: "Custom gate - no implementation provided"
-    };
-  }
-  /**
-   * Add a custom quality gate
-   */
-  addGate(gate) {
-    this.gates.push(gate);
-  }
-  /**
-   * Remove a quality gate by name
-   */
-  removeGate(name) {
-    const index = this.gates.findIndex((g) => g.name === name);
-    if (index >= 0) {
-      this.gates.splice(index, 1);
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Get all configured gates
-   */
-  getGates() {
-    return [...this.gates];
-  }
-};
-
-// src/extraction/base.ts
-var BaseExtractor = class {
-  constructor(config) {
-    this.config = {
-      mode: config?.mode || "manual",
-      qualityGates: config?.qualityGates || DEFAULT_QUALITY_GATES,
-      minConfidence: config?.minConfidence ?? 0.6,
-      llmProvider: config?.llmProvider
-    };
-    this.gateEvaluator = new QualityGateEvaluator(this.config.qualityGates);
-  }
-  /**
-   * Create initial skill metrics
-   */
-  createInitialMetrics() {
-    return {
-      usageCount: 0,
-      successRate: 0,
-      feedbackScores: []
-    };
-  }
-  /**
-   * Create skill source info for extracted skills
-   */
-  createSource(trajectory, type) {
-    return {
-      type,
-      sessionId: trajectory.sessionId,
-      importedAt: /* @__PURE__ */ new Date()
-    };
-  }
-  /**
-   * Generate a skill ID from name
-   */
-  generateSkillId(name) {
-    return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-  }
-  /**
-   * Validate and run quality gates on extracted skill
-   */
-  async validateWithGates(skill, trajectory, turnRange) {
-    return this.gateEvaluator.evaluate(skill, trajectory, turnRange);
-  }
-  /**
-   * Add or update quality gates
-   */
-  setQualityGates(gates) {
-    this.config.qualityGates = gates;
-    this.gateEvaluator = new QualityGateEvaluator(gates);
-  }
-  /**
-   * Get current configuration
-   */
-  getConfig() {
-    return { ...this.config };
-  }
-};
-
-// src/extraction/manual.ts
-var ManualExtractor = class extends BaseExtractor {
-  constructor(config) {
-    super({ mode: "manual", qualityGates: config });
-  }
-  /**
-   * Extract a skill from a trajectory with manual guidance
-   */
-  async extract(trajectory, options) {
-    const turnRange = options?.turnRange || [
-      0,
-      trajectory.turns.length - 1
-    ];
-    const turns = trajectory.turns.slice(turnRange[0], turnRange[1] + 1);
-    const skill = this.buildSkillFromTurns(trajectory, turns, options);
-    if (!options?.skipValidation) {
-      const validation = await this.validateWithGates(skill, trajectory, turnRange);
-      if (!validation.passed) {
-        return [
-          {
-            success: false,
-            confidence: this.calculateConfidence(validation.results),
-            gateResults: validation.results,
-            failureReason: "Quality gates not passed",
-            sourceTrajectory: {
-              sessionId: trajectory.sessionId,
-              turnRange
-            }
-          }
-        ];
-      }
-      return [
-        {
-          success: true,
-          skill,
-          confidence: this.calculateConfidence(validation.results),
-          gateResults: validation.results,
-          sourceTrajectory: {
-            sessionId: trajectory.sessionId,
-            turnRange
-          }
-        }
-      ];
-    }
-    return [
-      {
-        success: true,
-        skill,
-        confidence: 0.8,
-        gateResults: [],
-        sourceTrajectory: {
-          sessionId: trajectory.sessionId,
-          turnRange
-        }
-      }
-    ];
-  }
-  /**
-   * Build a skill object from trajectory turns
-   */
-  buildSkillFromTurns(trajectory, turns, options) {
-    const firstUserTurn = turns.find((t) => t.role === "user");
-    const problem = firstUserTurn?.content || "Problem not specified";
-    const assistantTurns = turns.filter((t) => t.role === "assistant");
-    const solution = this.buildSolutionFromTurns(assistantTurns);
-    const triggerConditions = this.inferTriggerConditions(turns);
-    const example = this.buildExampleFromTurns(turns);
-    const name = options?.suggestedName || this.inferSkillName(problem, solution);
-    const id = this.generateSkillId(name);
-    const description = options?.description || this.generateDescription(problem, triggerConditions);
-    return {
-      id,
-      name,
-      version: "1.0.0",
-      description,
-      problem: this.truncate(problem, 1e3),
-      triggerConditions,
-      solution,
-      verification: this.inferVerification(trajectory),
-      examples: example ? [example] : [],
-      notes: this.extractNotes(turns),
-      author: "extracted",
-      tags: options?.tags || this.inferTags(problem, solution),
-      createdAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date(),
-      status: "draft",
-      metrics: this.createInitialMetrics(),
-      source: this.createSource(trajectory, "extracted")
-    };
-  }
-  /**
-   * Build solution text from assistant turns
-   */
-  buildSolutionFromTurns(assistantTurns) {
-    const steps = [];
-    for (let i = 0; i < assistantTurns.length; i++) {
-      const turn = assistantTurns[i];
-      if (turn.content && turn.content.trim()) {
-        steps.push(turn.content.trim());
-      }
-      if (turn.toolCalls) {
-        for (const call of turn.toolCalls) {
-          const toolStep = this.formatToolCallAsStep(call);
-          if (toolStep) {
-            steps.push(toolStep);
-          }
-        }
-      }
-    }
-    return steps.filter((s) => s.length > 10).slice(0, 10).map((step, i) => `${i + 1}. ${step}`).join("\n\n");
-  }
-  /**
-   * Format a tool call as a solution step
-   */
-  formatToolCallAsStep(call) {
-    const { name, input } = call;
-    switch (name) {
-      case "Read":
-        return `Read file: \`${input.file_path || input.path}\``;
-      case "Write":
-        return `Create/write file: \`${input.file_path || input.path}\``;
-      case "Edit":
-        return `Edit file: \`${input.file_path || input.path}\``;
-      case "Bash":
-        return `Run command: \`${this.truncate(String(input.command || ""), 100)}\``;
-      case "Grep":
-        return `Search for: \`${input.pattern}\``;
-      case "Glob":
-        return `Find files matching: \`${input.pattern}\``;
-      default:
-        return null;
-    }
-  }
-  /**
-   * Infer trigger conditions from turns
-   */
-  inferTriggerConditions(turns) {
-    const conditions = [];
-    for (const turn of turns) {
-      if (turn.toolResults) {
-        for (const result of turn.toolResults) {
-          if (!result.success && result.error) {
-            conditions.push({
-              type: "error",
-              value: this.extractErrorSignature(result.error),
-              description: `Error from ${result.name}`
-            });
-          }
-        }
-      }
-      const content = turn.content || "";
-      const errorMatch = content.match(/error[:\s]+([^\n]+)/i);
-      if (errorMatch) {
-        conditions.push({
-          type: "error",
-          value: errorMatch[1].trim()
-        });
-      }
-    }
-    const firstUserTurn = turns.find((t) => t.role === "user");
-    if (firstUserTurn?.content) {
-      const keywords = this.extractKeywords(firstUserTurn.content);
-      if (keywords.length > 0) {
-        conditions.push({
-          type: "keyword",
-          value: keywords.join(", "),
-          description: "Keywords from original problem"
-        });
-      }
-    }
-    return this.deduplicateTriggers(conditions);
-  }
-  /**
-   * Extract a representative error signature
-   */
-  extractErrorSignature(error) {
-    const lines = error.split("\n");
-    const errorLine = lines.find(
-      (l) => l.toLowerCase().includes("error") || l.toLowerCase().includes("exception") || l.toLowerCase().includes("failed")
-    );
-    return this.truncate(errorLine || lines[0] || error, 200);
-  }
-  /**
-   * Extract meaningful keywords from text
-   */
-  extractKeywords(text) {
-    const words = text.toLowerCase().split(/\W+/);
-    const stopWords = /* @__PURE__ */ new Set([
-      "the",
-      "a",
-      "an",
-      "is",
-      "are",
-      "was",
-      "were",
-      "be",
-      "been",
-      "being",
-      "have",
-      "has",
-      "had",
-      "do",
-      "does",
-      "did",
-      "will",
-      "would",
-      "could",
-      "should",
-      "may",
-      "might",
-      "can",
-      "this",
-      "that",
-      "these",
-      "those",
-      "i",
-      "you",
-      "he",
-      "she",
-      "it",
-      "we",
-      "they",
-      "what",
-      "which",
-      "who",
-      "when",
-      "where",
-      "how",
-      "to",
-      "from",
-      "in",
-      "on",
-      "at",
-      "by",
-      "for",
-      "with",
-      "about",
-      "into",
-      "through",
-      "during",
-      "before",
-      "after",
-      "above",
-      "below",
-      "and",
-      "or",
-      "but",
-      "if",
-      "then",
-      "else",
-      "so",
-      "because",
-      "as",
-      "until",
-      "while",
-      "of",
-      "not",
-      "no",
-      "just",
-      "only"
-    ]);
-    const keywords = words.filter((w) => w.length > 3 && !stopWords.has(w)).slice(0, 5);
-    return [...new Set(keywords)];
-  }
-  /**
-   * Deduplicate trigger conditions
-   */
-  deduplicateTriggers(triggers) {
-    const seen = /* @__PURE__ */ new Set();
-    return triggers.filter((t) => {
-      const key = `${t.type}:${t.value}`;
-      if (seen.has(key)) return false;
-      seen.add(key);
-      return true;
-    });
-  }
-  /**
-   * Build an example from the trajectory
-   */
-  buildExampleFromTurns(turns) {
-    const firstUserTurn = turns.find((t) => t.role === "user");
-    const lastAssistantTurn = [...turns].reverse().find((t) => t.role === "assistant");
-    if (!firstUserTurn || !lastAssistantTurn) return null;
-    return {
-      scenario: "Original extraction context",
-      before: this.truncate(firstUserTurn.content || "", 500),
-      after: this.truncate(lastAssistantTurn.content || "", 500)
-    };
-  }
-  /**
-   * Infer skill name from problem and solution
-   */
-  inferSkillName(problem, solution) {
-    const combined = `${problem} ${solution}`.toLowerCase();
-    const patterns = [
-      /fix(?:ing|ed)?\s+(\w+(?:\s+\w+)?)/i,
-      /solv(?:e|ing|ed)\s+(\w+(?:\s+\w+)?)/i,
-      /handl(?:e|ing|ed)\s+(\w+(?:\s+\w+)?)/i,
-      /(\w+)\s+error/i,
-      /(\w+)\s+issue/i,
-      /(\w+)\s+problem/i
-    ];
-    for (const pattern of patterns) {
-      const match = combined.match(pattern);
-      if (match && match[1]) {
-        return `${match[1].trim()}-fix`;
-      }
-    }
-    const words = problem.split(/\s+/).slice(0, 4).join("-");
-    return words.toLowerCase().replace(/[^a-z0-9-]/g, "") || "extracted-skill";
-  }
-  /**
-   * Generate a description optimized for semantic matching
-   */
-  generateDescription(problem, triggers) {
-    let desc = this.truncate(problem, 150);
-    const errorTriggers = triggers.filter((t) => t.type === "error");
-    if (errorTriggers.length > 0) {
-      desc += ` Triggered by: ${errorTriggers[0].value}`;
-    }
-    return desc;
-  }
-  /**
-   * Infer verification steps
-   */
-  inferVerification(trajectory) {
-    if (trajectory.outcome?.success) {
-      return "Verified: Session completed successfully.";
-    }
-    return "Verify by checking that the original error no longer occurs.";
-  }
-  /**
-   * Extract notes from turns (warnings, caveats, etc.)
-   */
-  extractNotes(turns) {
-    const notes = [];
-    for (const turn of turns) {
-      const content = turn.content || "";
-      if (content.toLowerCase().includes("note:") || content.toLowerCase().includes("warning:") || content.toLowerCase().includes("caveat:") || content.toLowerCase().includes("important:")) {
-        const match = content.match(/(note|warning|caveat|important):\s*([^\n]+)/i);
-        if (match) {
-          notes.push(match[0]);
-        }
-      }
-    }
-    return notes.length > 0 ? notes.join("\n") : void 0;
-  }
-  /**
-   * Infer tags from content
-   */
-  inferTags(problem, solution) {
-    const tags = [];
-    const content = `${problem} ${solution}`.toLowerCase();
-    const techPatterns = [
-      [/typescript|\.ts\b/i, "typescript"],
-      [/javascript|\.js\b/i, "javascript"],
-      [/python|\.py\b/i, "python"],
-      [/react/i, "react"],
-      [/node\.?js/i, "nodejs"],
-      [/docker/i, "docker"],
-      [/git\b/i, "git"],
-      [/npm|yarn|pnpm/i, "package-manager"],
-      [/test|jest|vitest|mocha/i, "testing"],
-      [/database|sql|postgres|mysql|mongo/i, "database"],
-      [/api|rest|graphql/i, "api"]
-    ];
-    for (const [pattern, tag] of techPatterns) {
-      if (pattern.test(content)) {
-        tags.push(tag);
-      }
-    }
-    if (content.includes("error") || content.includes("fix")) {
-      tags.push("debugging");
-    }
-    if (content.includes("performance") || content.includes("slow")) {
-      tags.push("performance");
-    }
-    if (content.includes("security") || content.includes("auth")) {
-      tags.push("security");
-    }
-    return [...new Set(tags)].slice(0, 5);
-  }
-  /**
-   * Calculate confidence from gate results
-   */
-  calculateConfidence(gateResults) {
-    if (gateResults.length === 0) return 0.5;
-    const avgScore = gateResults.reduce((sum, r) => sum + r.score, 0) / gateResults.length;
-    return Math.round(avgScore * 100) / 100;
-  }
-  /**
-   * Truncate text to max length
-   */
-  truncate(text, maxLength) {
-    if (text.length <= maxLength) return text;
-    return text.substring(0, maxLength - 3) + "...";
-  }
-};
-
-// src/extraction/automatic.ts
-var AutomaticExtractor = class extends BaseExtractor {
-  constructor(config) {
-    super({
-      mode: "automatic",
-      qualityGates: config?.qualityGates,
-      minConfidence: config?.minConfidence,
-      llmProvider: config?.llmProvider
-    });
-    this.llmProvider = config?.llmProvider || null;
-  }
-  /**
-   * Set the LLM provider for automatic extraction
-   */
-  setLLMProvider(provider) {
-    this.llmProvider = provider;
-    this.config.llmProvider = provider;
-  }
-  /**
-   * Extract skills automatically from a trajectory
-   */
-  async extract(trajectory, options) {
-    if (!this.llmProvider) {
-      return [
-        {
-          success: false,
-          confidence: 0,
-          gateResults: [],
-          failureReason: "No LLM provider configured for automatic extraction",
-          sourceTrajectory: {
-            sessionId: trajectory.sessionId,
-            turnRange: options?.turnRange || [0, trajectory.turns.length - 1]
-          }
-        }
-      ];
-    }
-    const candidates = await this.identifySkillCandidates(trajectory, options);
-    if (candidates.length === 0) {
-      return [
-        {
-          success: false,
-          confidence: 0,
-          gateResults: [],
-          failureReason: "No extractable skills identified in trajectory",
-          sourceTrajectory: {
-            sessionId: trajectory.sessionId,
-            turnRange: options?.turnRange || [0, trajectory.turns.length - 1]
-          }
-        }
-      ];
-    }
-    const results = [];
-    const minConfidence = options?.minConfidence ?? this.config.minConfidence ?? 0.6;
-    for (const candidate of candidates) {
-      if (candidate.confidence < minConfidence) {
-        results.push({
-          success: false,
-          confidence: candidate.confidence,
-          gateResults: [],
-          failureReason: `Confidence ${candidate.confidence} below threshold ${minConfidence}`,
-          sourceTrajectory: {
-            sessionId: trajectory.sessionId,
-            turnRange: candidate.turnRange
-          }
-        });
-        continue;
-      }
-      const skill = this.buildSkillFromCandidate(candidate, trajectory);
-      if (!options?.skipValidation) {
-        const validation = await this.validateWithGates(
-          skill,
-          trajectory,
-          candidate.turnRange
-        );
-        if (!validation.passed) {
-          results.push({
-            success: false,
-            skill,
-            confidence: candidate.confidence,
-            gateResults: validation.results,
-            failureReason: "Quality gates not passed",
-            sourceTrajectory: {
-              sessionId: trajectory.sessionId,
-              turnRange: candidate.turnRange
-            }
-          });
-          continue;
-        }
-        results.push({
-          success: true,
-          skill,
-          confidence: candidate.confidence,
-          gateResults: validation.results,
-          sourceTrajectory: {
-            sessionId: trajectory.sessionId,
-            turnRange: candidate.turnRange
-          }
-        });
-      } else {
-        results.push({
-          success: true,
-          skill,
-          confidence: candidate.confidence,
-          gateResults: [],
-          sourceTrajectory: {
-            sessionId: trajectory.sessionId,
-            turnRange: candidate.turnRange
-          }
-        });
-      }
-    }
-    return results;
-  }
-  /**
-   * Identify skill candidates using LLM analysis
-   */
-  async identifySkillCandidates(trajectory, options) {
-    const prompt = this.buildAnalysisPrompt(trajectory, options);
-    try {
-      const response = await this.llmProvider.completeStructured(prompt, SKILL_CANDIDATE_SCHEMA, { temperature: 0.3 });
-      return response.candidates || [];
-    } catch (error) {
-      try {
-        const textResponse = await this.llmProvider.complete(prompt, {
-          temperature: 0.3
-        });
-        return this.parseTextResponse(textResponse);
-      } catch {
-        return [];
-      }
-    }
-  }
-  /**
-   * Build the analysis prompt for skill identification
-   */
-  buildAnalysisPrompt(trajectory, options) {
-    const turns = options?.turnRange ? trajectory.turns.slice(options.turnRange[0], options.turnRange[1] + 1) : trajectory.turns;
-    const trajectoryText = this.formatTrajectoryForPrompt(turns);
-    return `Analyze the following agent conversation trajectory and identify any reusable skills that could be extracted.
-
-A skill is extractable if it meets these criteria:
-1. **Reusability**: The solution applies to multiple future tasks, not just this specific case
-2. **Non-trivial**: It involves discovery beyond basic documentation lookup
-3. **Specific triggers**: Has clear conditions for when to apply (error messages, patterns, contexts)
-4. **Verified**: The solution demonstrably worked in this trajectory
-
-For each skill you identify, provide:
-- name: A descriptive kebab-case name
-- description: 1-2 sentences optimized for semantic search/matching
-- problem: What problem does this skill solve?
-- solution: Step-by-step instructions to apply this skill
-- triggerConditions: Array of {type, value, description} for when to use this skill
-- verification: How to verify the skill worked
-- turnRange: [startTurn, endTurn] indices in the trajectory
-- confidence: 0-1 score for how extractable this skill is
-- reasoning: Why this is or isn't a good skill candidate
-
-If no skills are extractable, return an empty candidates array.
-
-TRAJECTORY:
-${trajectoryText}
-
-${options?.context ? `ADDITIONAL CONTEXT: ${options.context}` : ""}
-
-Respond with a JSON object containing a "candidates" array.`;
-  }
-  /**
-   * Format trajectory turns for the prompt
-   */
-  formatTrajectoryForPrompt(turns) {
-    return turns.map((turn, i) => {
-      let text = `[Turn ${i}] ${turn.role.toUpperCase()}:
-${turn.content || "(no content)"}`;
-      if (turn.toolCalls && turn.toolCalls.length > 0) {
-        text += "\nTool calls:";
-        for (const call of turn.toolCalls) {
-          text += `
-  - ${call.name}: ${JSON.stringify(call.input).substring(0, 200)}`;
-        }
-      }
-      if (turn.toolResults && turn.toolResults.length > 0) {
-        text += "\nTool results:";
-        for (const result of turn.toolResults) {
-          const status = result.success ? "SUCCESS" : "ERROR";
-          text += `
-  - ${result.name} [${status}]: ${result.output.substring(0, 200)}`;
-        }
-      }
-      return text;
-    }).join("\n\n---\n\n");
-  }
-  /**
-   * Parse text response into skill candidates (fallback)
-   */
-  parseTextResponse(response) {
-    try {
-      const jsonMatch = response.match(/\{[\s\S]*"candidates"[\s\S]*\}/);
-      if (jsonMatch) {
-        const parsed = JSON.parse(jsonMatch[0]);
-        return parsed.candidates || [];
-      }
-    } catch {
-    }
-    return [];
-  }
-  /**
-   * Build a Skill from a candidate
-   */
-  buildSkillFromCandidate(candidate, trajectory) {
-    const id = candidate.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-    const turns = trajectory.turns.slice(candidate.turnRange[0], candidate.turnRange[1] + 1);
-    const example = this.buildExample(turns);
-    return {
-      id,
-      name: candidate.name,
-      version: "1.0.0",
-      description: candidate.description,
-      problem: candidate.problem,
-      triggerConditions: candidate.triggerConditions,
-      solution: candidate.solution,
-      verification: candidate.verification,
-      examples: example ? [example] : [],
-      author: "auto-extracted",
-      tags: this.inferTags(candidate),
-      createdAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date(),
-      status: "draft",
-      metrics: this.createInitialMetrics(),
-      source: {
-        type: "extracted",
-        sessionId: trajectory.sessionId,
-        importedAt: /* @__PURE__ */ new Date()
-      }
-    };
-  }
-  /**
-   * Build an example from turns
-   */
-  buildExample(turns) {
-    const firstUser = turns.find((t) => t.role === "user");
-    const lastAssistant = [...turns].reverse().find((t) => t.role === "assistant");
-    if (!firstUser || !lastAssistant) return null;
-    return {
-      scenario: "Extracted from conversation",
-      before: (firstUser.content || "").substring(0, 500),
-      after: (lastAssistant.content || "").substring(0, 500)
-    };
-  }
-  /**
-   * Infer tags from candidate
-   */
-  inferTags(candidate) {
-    const tags = [];
-    const content = `${candidate.problem} ${candidate.solution}`.toLowerCase();
-    const techPatterns = [
-      [/typescript/i, "typescript"],
-      [/javascript/i, "javascript"],
-      [/python/i, "python"],
-      [/react/i, "react"],
-      [/node/i, "nodejs"],
-      [/docker/i, "docker"],
-      [/git\b/i, "git"],
-      [/test/i, "testing"],
-      [/error/i, "debugging"]
-    ];
-    for (const [pattern, tag] of techPatterns) {
-      if (pattern.test(content)) {
-        tags.push(tag);
-      }
-    }
-    return [...new Set(tags)];
-  }
-};
-var SKILL_CANDIDATE_SCHEMA = {
-  type: "object",
-  properties: {
-    candidates: {
-      type: "array",
-      items: {
-        type: "object",
-        properties: {
-          name: { type: "string" },
-          description: { type: "string" },
-          problem: { type: "string" },
-          solution: { type: "string" },
-          triggerConditions: {
-            type: "array",
-            items: {
-              type: "object",
-              properties: {
-                type: { type: "string", enum: ["error", "pattern", "context", "keyword", "custom"] },
-                value: { type: "string" },
-                description: { type: "string" }
-              },
-              required: ["type", "value"]
-            }
-          },
-          verification: { type: "string" },
-          turnRange: {
-            type: "array",
-            items: { type: "number" },
-            minItems: 2,
-            maxItems: 2
-          },
-          confidence: { type: "number", minimum: 0, maximum: 1 },
-          reasoning: { type: "string" }
-        },
-        required: ["name", "description", "problem", "solution", "turnRange", "confidence"]
-      }
-    }
-  },
-  required: ["candidates"]
-};
-
-// src/storage/base.ts
-var BaseStorageAdapter = class {
-  constructor() {
-    this.initialized = false;
-  }
-  /**
-   * Ensure storage is initialized before operations
-   */
-  ensureInitialized() {
-    if (!this.initialized) {
-      throw new Error("Storage not initialized. Call initialize() first.");
-    }
-  }
-  /**
-   * Apply filters to a list of skills
-   */
-  applyFilter(skills, filter) {
-    if (!filter) return skills;
-    return skills.filter((skill) => {
-      if (filter.status && filter.status.length > 0) {
-        if (!filter.status.includes(skill.status)) return false;
-      }
-      if (filter.tags && filter.tags.length > 0) {
-        const hasTag = filter.tags.some((tag) => skill.tags.includes(tag));
-        if (!hasTag) return false;
-      }
-      if (filter.author && skill.author !== filter.author) {
-        return false;
-      }
-      if (filter.minSuccessRate !== void 0 && skill.metrics.successRate < filter.minSuccessRate) {
-        return false;
-      }
-      if (filter.createdAfter && skill.createdAt < filter.createdAfter) {
-        return false;
-      }
-      if (filter.createdBefore && skill.createdAt > filter.createdBefore) {
-        return false;
-      }
-      return true;
-    });
-  }
-  /**
-   * Simple text search across skill fields
-   */
-  textSearch(skills, query) {
-    const lowerQuery = query.toLowerCase();
-    const terms = lowerQuery.split(/\s+/).filter((t) => t.length > 0);
-    return skills.filter((skill) => {
-      const searchText = [
-        skill.name,
-        skill.description,
-        skill.problem,
-        skill.solution,
-        ...skill.tags,
-        skill.triggerConditions.map((t) => t.value).join(" ")
-      ].join(" ").toLowerCase();
-      return terms.every((term) => searchText.includes(term));
-    });
-  }
-};
-var MemoryStorageAdapter = class extends BaseStorageAdapter {
-  constructor() {
-    super(...arguments);
-    this.skills = /* @__PURE__ */ new Map();
-    // skillId -> version -> skill
-    this.lineages = /* @__PURE__ */ new Map();
-  }
-  async initialize() {
-    this.initialized = true;
-  }
-  async saveSkill(skill) {
-    this.ensureInitialized();
-    if (!this.skills.has(skill.id)) {
-      this.skills.set(skill.id, /* @__PURE__ */ new Map());
-    }
-    const versionMap = this.skills.get(skill.id);
-    versionMap.set(skill.version, { ...skill });
-    this.updateLineage(skill);
-  }
-  async getSkill(id, version) {
-    this.ensureInitialized();
-    const versionMap = this.skills.get(id);
-    if (!versionMap) return null;
-    if (version) {
-      return versionMap.get(version) || null;
-    }
-    const versions = Array.from(versionMap.keys()).sort(this.compareVersions);
-    const latestVersion = versions[versions.length - 1];
-    return latestVersion ? versionMap.get(latestVersion) || null : null;
-  }
-  async listSkills(filter) {
-    this.ensureInitialized();
-    const skills = [];
-    for (const versionMap of this.skills.values()) {
-      const versions = Array.from(versionMap.keys()).sort(this.compareVersions);
-      const latestVersion = versions[versions.length - 1];
-      if (latestVersion) {
-        const skill = versionMap.get(latestVersion);
-        if (skill) skills.push(skill);
-      }
-    }
-    return this.applyFilter(skills, filter);
-  }
-  async deleteSkill(id, version) {
-    this.ensureInitialized();
-    if (version) {
-      const versionMap = this.skills.get(id);
-      if (!versionMap) return false;
-      return versionMap.delete(version);
-    }
-    const existed = this.skills.has(id);
-    this.skills.delete(id);
-    this.lineages.delete(id);
-    return existed;
-  }
-  async getVersionHistory(skillId) {
-    this.ensureInitialized();
-    const versionMap = this.skills.get(skillId);
-    if (!versionMap) return [];
-    const versions = [];
-    for (const [version, skill] of versionMap) {
-      versions.push({
-        skillId,
-        version,
-        skill,
-        changelog: "",
-        // Not tracked in memory
-        createdAt: skill.createdAt,
-        contentHash: this.hashSkill(skill)
-      });
-    }
-    return versions.sort((a, b) => this.compareVersions(a.version, b.version));
-  }
-  async getLineage(skillId) {
-    this.ensureInitialized();
-    return this.lineages.get(skillId) || null;
-  }
-  async searchSkills(query) {
-    this.ensureInitialized();
-    const allSkills = await this.listSkills();
-    return this.textSearch(allSkills, query);
-  }
-  updateLineage(skill) {
-    if (!this.lineages.has(skill.id)) {
-      this.lineages.set(skill.id, {
-        rootId: skill.id,
-        versions: [],
-        forks: []
-      });
-    }
-    const lineage = this.lineages.get(skill.id);
-    const existingIndex = lineage.versions.findIndex((v) => v.version === skill.version);
-    const versionEntry = {
-      skillId: skill.id,
-      version: skill.version,
-      skill,
-      changelog: "",
-      createdAt: skill.createdAt,
-      contentHash: this.hashSkill(skill)
-    };
-    if (existingIndex >= 0) {
-      lineage.versions[existingIndex] = versionEntry;
-    } else {
-      lineage.versions.push(versionEntry);
-      lineage.versions.sort((a, b) => this.compareVersions(a.version, b.version));
-    }
-  }
-  compareVersions(a, b) {
-    const partsA = a.split(".").map(Number);
-    const partsB = b.split(".").map(Number);
-    for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
-      const numA = partsA[i] || 0;
-      const numB = partsB[i] || 0;
-      if (numA !== numB) return numA - numB;
-    }
-    return 0;
-  }
-  hashSkill(skill) {
-    const content = JSON.stringify({
-      problem: skill.problem,
-      solution: skill.solution,
-      triggerConditions: skill.triggerConditions
-    });
-    let hash = 0;
-    for (let i = 0; i < content.length; i++) {
-      const char = content.charCodeAt(i);
-      hash = (hash << 5) - hash + char;
-      hash = hash & hash;
-    }
-    return Math.abs(hash).toString(16);
-  }
-  /**
-   * Clear all stored skills (for testing)
-   */
-  clear() {
-    this.skills.clear();
-    this.lineages.clear();
-  }
-};
-
-// src/storage/filesystem.ts
-import * as fs from "fs/promises";
-import * as path from "path";
-var FilesystemStorageAdapter = class extends BaseStorageAdapter {
-  constructor(config) {
-    super();
-    this.config = {
-      basePath: config.basePath,
-      openSkillsCompatible: config.openSkillsCompatible ?? true,
-      trackVersions: config.trackVersions ?? true
-    };
-    this.versionsDir = path.join(this.config.basePath, ".versions");
-  }
-  async initialize() {
-    await fs.mkdir(this.config.basePath, { recursive: true });
-    if (this.config.trackVersions) {
-      await fs.mkdir(this.versionsDir, { recursive: true });
-    }
-    this.initialized = true;
-  }
-  async saveSkill(skill) {
-    this.ensureInitialized();
-    const skillDir = path.join(this.config.basePath, skill.id);
-    await fs.mkdir(skillDir, { recursive: true });
-    const skillContent = this.serializeSkill(skill);
-    const skillFileName = this.config.openSkillsCompatible ? "SKILL.md" : "skill.md";
-    await fs.writeFile(path.join(skillDir, skillFileName), skillContent, "utf-8");
-    const metadata = this.createMetadata(skill);
-    await fs.writeFile(
-      path.join(skillDir, ".skilltree.json"),
-      JSON.stringify(metadata, null, 2),
-      "utf-8"
-    );
-    if (this.config.trackVersions) {
-      await this.saveVersionSnapshot(skill);
-    }
-  }
-  async getSkill(id, version) {
-    this.ensureInitialized();
-    if (version && this.config.trackVersions) {
-      return this.getVersionedSkill(id, version);
-    }
-    const skillDir = path.join(this.config.basePath, id);
-    const skillFileName = this.config.openSkillsCompatible ? "SKILL.md" : "skill.md";
-    const skillPath = path.join(skillDir, skillFileName);
-    try {
-      const content = await fs.readFile(skillPath, "utf-8");
-      const metadata = await this.loadMetadata(skillDir);
-      return this.parseSkill(id, content, metadata);
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        return null;
-      }
-      throw error;
-    }
-  }
-  async listSkills(filter) {
-    this.ensureInitialized();
-    const skills = [];
-    try {
-      const entries = await fs.readdir(this.config.basePath, { withFileTypes: true });
-      for (const entry of entries) {
-        if (!entry.isDirectory() || entry.name.startsWith(".")) {
-          continue;
-        }
-        const skill = await this.getSkill(entry.name);
-        if (skill) {
-          skills.push(skill);
-        }
-      }
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
-    }
-    return this.applyFilter(skills, filter);
-  }
-  async deleteSkill(id, version) {
-    this.ensureInitialized();
-    if (version && this.config.trackVersions) {
-      return this.deleteVersion(id, version);
-    }
-    const skillDir = path.join(this.config.basePath, id);
-    try {
-      await fs.rm(skillDir, { recursive: true });
-      if (this.config.trackVersions) {
-        const versionDir = path.join(this.versionsDir, id);
-        await fs.rm(versionDir, { recursive: true }).catch(() => {
-        });
-      }
-      return true;
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        return false;
-      }
-      throw error;
-    }
-  }
-  async getVersionHistory(skillId) {
-    this.ensureInitialized();
-    if (!this.config.trackVersions) {
-      const skill = await this.getSkill(skillId);
-      if (!skill) return [];
-      return [
-        {
-          skillId,
-          version: skill.version,
-          skill,
-          changelog: "",
-          createdAt: skill.createdAt,
-          contentHash: this.hashContent(skill)
-        }
-      ];
-    }
-    const versionDir = path.join(this.versionsDir, skillId);
-    const versions = [];
-    try {
-      const entries = await fs.readdir(versionDir);
-      for (const entry of entries) {
-        if (!entry.endsWith(".json")) continue;
-        const versionPath = path.join(versionDir, entry);
-        const content = await fs.readFile(versionPath, "utf-8");
-        const versionData = JSON.parse(content);
-        versionData.createdAt = new Date(versionData.createdAt);
-        if (versionData.skill) {
-          const skill = versionData.skill;
-          skill.createdAt = new Date(skill.createdAt);
-          skill.updatedAt = new Date(skill.updatedAt);
-        }
-        versions.push(versionData);
-      }
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
-    }
-    return versions.sort((a, b) => this.compareVersions(a.version, b.version));
-  }
-  async getLineage(skillId) {
-    this.ensureInitialized();
-    const versions = await this.getVersionHistory(skillId);
-    if (versions.length === 0) return null;
-    const skillDir = path.join(this.config.basePath, skillId);
-    const metadata = await this.loadMetadata(skillDir);
-    return {
-      rootId: metadata?.lineage?.rootId || skillId,
-      versions,
-      forks: metadata?.lineage?.forks || []
-    };
-  }
-  async searchSkills(query) {
-    this.ensureInitialized();
-    const allSkills = await this.listSkills();
-    return this.textSearch(allSkills, query);
-  }
-  // ==========================================================================
-  // Serialization
-  // ==========================================================================
-  /**
-   * Serialize skill to YAML frontmatter + Markdown format
-   */
-  serializeSkill(skill) {
-    const frontmatter = this.buildFrontmatter(skill);
-    const body = this.buildBody(skill);
-    return `---
-${frontmatter}---
-
-${body}`;
-  }
-  /**
-   * Build YAML frontmatter
-   */
-  buildFrontmatter(skill) {
-    const lines = [];
-    lines.push(`name: ${skill.name}`);
-    lines.push(`description: |`);
-    lines.push(`  ${skill.description}`);
-    lines.push(`version: ${skill.version}`);
-    lines.push(`author: ${skill.author}`);
-    lines.push(`status: ${skill.status}`);
-    lines.push(`date: ${skill.updatedAt.toISOString().split("T")[0]}`);
-    if (skill.tags.length > 0) {
-      lines.push(`tags:`);
-      for (const tag of skill.tags) {
-        lines.push(`  - ${tag}`);
-      }
-    }
-    if (skill.parentVersion) {
-      lines.push(`parentVersion: ${skill.parentVersion}`);
-    }
-    if (skill.derivedFrom && skill.derivedFrom.length > 0) {
-      lines.push(`derivedFrom:`);
-      for (const id of skill.derivedFrom) {
-        lines.push(`  - ${id}`);
-      }
-    }
-    return lines.join("\n") + "\n";
-  }
-  /**
-   * Build Markdown body (Claudeception-inspired structure)
-   */
-  buildBody(skill) {
-    const sections = [];
-    sections.push("## Problem\n");
-    sections.push(skill.problem);
-    sections.push("");
-    if (skill.triggerConditions.length > 0) {
-      sections.push("## Trigger Conditions\n");
-      for (const trigger of skill.triggerConditions) {
-        const desc = trigger.description ? ` - ${trigger.description}` : "";
-        sections.push(`- **${trigger.type}**: \`${trigger.value}\`${desc}`);
-      }
-      sections.push("");
-    }
-    sections.push("## Solution\n");
-    sections.push(skill.solution);
-    sections.push("");
-    sections.push("## Verification\n");
-    sections.push(skill.verification);
-    sections.push("");
-    if (skill.examples.length > 0) {
-      sections.push("## Examples\n");
-      for (const example of skill.examples) {
-        sections.push(`### ${example.scenario}
-`);
-        sections.push("**Before:**");
-        sections.push("```");
-        sections.push(example.before);
-        sections.push("```\n");
-        sections.push("**After:**");
-        sections.push("```");
-        sections.push(example.after);
-        sections.push("```");
-        sections.push("");
-      }
-    }
-    if (skill.notes) {
-      sections.push("## Notes\n");
-      sections.push(skill.notes);
-      sections.push("");
-    }
-    return sections.join("\n");
-  }
-  /**
-   * Parse skill from YAML frontmatter + Markdown content
-   */
-  parseSkill(id, content, metadata) {
-    const { frontmatter, body } = this.parseFrontmatterAndBody(content);
-    const sections = this.parseBodySections(body);
-    const name = this.extractYamlField(frontmatter, "name") || id;
-    const description = this.extractYamlMultiline(frontmatter, "description") || "";
-    const version = this.extractYamlField(frontmatter, "version") || "1.0.0";
-    const author = this.extractYamlField(frontmatter, "author") || "unknown";
-    const status = this.extractYamlField(frontmatter, "status") || "active";
-    const dateStr = this.extractYamlField(frontmatter, "date");
-    const tags = this.extractYamlList(frontmatter, "tags");
-    const parentVersion = this.extractYamlField(frontmatter, "parentVersion");
-    const derivedFrom = this.extractYamlList(frontmatter, "derivedFrom");
-    const problem = sections["problem"] || "";
-    const solution = sections["solution"] || "";
-    const verification = sections["verification"] || "";
-    const notes = sections["notes"];
-    const triggerConditions = this.parseTriggerConditions(sections["trigger conditions"] || "");
-    const examples = this.parseExamples(sections["examples"] || "");
-    const date = dateStr ? new Date(dateStr) : /* @__PURE__ */ new Date();
-    return {
-      id,
-      name,
-      version,
-      description,
-      problem,
-      triggerConditions,
-      solution,
-      verification,
-      examples,
-      notes,
-      author,
-      tags,
-      createdAt: date,
-      updatedAt: date,
-      status,
-      parentVersion: parentVersion || void 0,
-      derivedFrom: derivedFrom.length > 0 ? derivedFrom : void 0,
-      metrics: {
-        usageCount: 0,
-        successRate: 0,
-        feedbackScores: []
-      },
-      source: metadata?.source
-    };
-  }
-  /**
-   * Split content into frontmatter and body
-   */
-  parseFrontmatterAndBody(content) {
-    const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-    if (match) {
-      return { frontmatter: match[1], body: match[2] };
-    }
-    return { frontmatter: "", body: content };
-  }
-  /**
-   * Parse body into sections by ## headers
-   */
-  parseBodySections(body) {
-    const sections = {};
-    const parts = body.split(/^## /m);
-    for (const part of parts) {
-      if (!part.trim()) continue;
-      const lines = part.split("\n");
-      const header = lines[0]?.trim().toLowerCase();
-      const content = lines.slice(1).join("\n").trim();
-      if (header) {
-        sections[header] = content;
-      }
-    }
-    return sections;
-  }
-  /**
-   * Extract a single-line YAML field
-   */
-  extractYamlField(yaml, field) {
-    const match = yaml.match(new RegExp(`^${field}:\\s*(.+)$`, "m"));
-    return match ? match[1].trim() : null;
-  }
-  /**
-   * Extract a multiline YAML field (using |)
-   */
-  extractYamlMultiline(yaml, field) {
-    const match = yaml.match(new RegExp(`^${field}:\\s*\\|\\n((?:\\s{2}.+\\n?)+)`, "m"));
-    if (match) {
-      return match[1].split("\n").map((line) => line.replace(/^\s{2}/, "")).join("\n").trim();
-    }
-    return this.extractYamlField(yaml, field);
-  }
-  /**
-   * Extract a YAML list
-   */
-  extractYamlList(yaml, field) {
-    const match = yaml.match(new RegExp(`^${field}:\\n((?:\\s+-\\s+.+\\n?)+)`, "m"));
-    if (match) {
-      return match[1].split("\n").map((line) => line.replace(/^\s+-\s+/, "").trim()).filter((line) => line.length > 0);
-    }
-    return [];
-  }
-  /**
-   * Parse trigger conditions from markdown
-   */
-  parseTriggerConditions(content) {
-    const conditions = [];
-    const lines = content.split("\n");
-    for (const line of lines) {
-      const match = line.match(/^-\s+\*\*(\w+)\*\*:\s*`([^`]+)`(?:\s*-\s*(.+))?/);
-      if (match) {
-        conditions.push({
-          type: match[1],
-          value: match[2],
-          description: match[3]?.trim()
-        });
-      }
-    }
-    return conditions;
-  }
-  /**
-   * Parse examples from markdown
-   */
-  parseExamples(content) {
-    const examples = [];
-    const parts = content.split(/^### /m);
-    for (const part of parts) {
-      if (!part.trim()) continue;
-      const lines = part.split("\n");
-      const scenario = lines[0]?.trim() || "Example";
-      const rest = lines.slice(1).join("\n");
-      const beforeMatch = rest.match(/\*\*Before:\*\*\n```\n?([\s\S]*?)```/);
-      const afterMatch = rest.match(/\*\*After:\*\*\n```\n?([\s\S]*?)```/);
-      if (beforeMatch || afterMatch) {
-        examples.push({
-          scenario,
-          before: beforeMatch?.[1]?.trim() || "",
-          after: afterMatch?.[1]?.trim() || ""
-        });
-      }
-    }
-    return examples;
-  }
-  // ==========================================================================
-  // Version Management
-  // ==========================================================================
-  /**
-   * Save a version snapshot
-   */
-  async saveVersionSnapshot(skill) {
-    const versionDir = path.join(this.versionsDir, skill.id);
-    await fs.mkdir(versionDir, { recursive: true });
-    const versionFile = path.join(versionDir, `${skill.version}.json`);
-    const versionData = {
-      skillId: skill.id,
-      version: skill.version,
-      skill,
-      changelog: "",
-      // Could be enhanced to track changes
-      createdAt: /* @__PURE__ */ new Date(),
-      contentHash: this.hashContent(skill)
-    };
-    await fs.writeFile(versionFile, JSON.stringify(versionData, null, 2), "utf-8");
-  }
-  /**
-   * Get a specific version of a skill
-   */
-  async getVersionedSkill(id, version) {
-    const versionFile = path.join(this.versionsDir, id, `${version}.json`);
-    try {
-      const content = await fs.readFile(versionFile, "utf-8");
-      const versionData = JSON.parse(content);
-      const skill = versionData.skill;
-      skill.createdAt = new Date(skill.createdAt);
-      skill.updatedAt = new Date(skill.updatedAt);
-      return skill;
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        return null;
-      }
-      throw error;
-    }
-  }
-  /**
-   * Delete a specific version
-   */
-  async deleteVersion(id, version) {
-    const versionFile = path.join(this.versionsDir, id, `${version}.json`);
-    try {
-      await fs.unlink(versionFile);
-      return true;
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        return false;
-      }
-      throw error;
-    }
-  }
-  // ==========================================================================
-  // Metadata
-  // ==========================================================================
-  /**
-   * Create metadata for a skill
-   */
-  createMetadata(skill) {
-    return {
-      source: skill.source,
-      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      lineage: {
-        rootId: skill.id,
-        parentVersion: skill.parentVersion,
-        derivedFrom: skill.derivedFrom
-      }
-    };
-  }
-  /**
-   * Load metadata for a skill directory
-   */
-  async loadMetadata(skillDir) {
-    const metadataPath = path.join(skillDir, ".skilltree.json");
-    try {
-      const content = await fs.readFile(metadataPath, "utf-8");
-      return JSON.parse(content);
-    } catch {
-      return null;
-    }
-  }
-  // ==========================================================================
-  // Utilities
-  // ==========================================================================
-  /**
-   * Compare semantic versions
-   */
-  compareVersions(a, b) {
-    const partsA = a.split(".").map(Number);
-    const partsB = b.split(".").map(Number);
-    for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
-      const numA = partsA[i] || 0;
-      const numB = partsB[i] || 0;
-      if (numA !== numB) return numA - numB;
-    }
-    return 0;
-  }
-  /**
-   * Generate content hash
-   */
-  hashContent(skill) {
-    const content = JSON.stringify({
-      problem: skill.problem,
-      solution: skill.solution,
-      triggerConditions: skill.triggerConditions
-    });
-    let hash = 0;
-    for (let i = 0; i < content.length; i++) {
-      const char = content.charCodeAt(i);
-      hash = (hash << 5) - hash + char;
-      hash = hash & hash;
-    }
-    return Math.abs(hash).toString(16);
-  }
-};
-
-// src/versioning/semver.ts
-function parseVersion(version) {
-  const match = version.match(
-    /^(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9.-]+))?(?:\+([a-zA-Z0-9.-]+))?$/
-  );
-  if (!match) {
-    throw new Error(`Invalid version format: ${version}`);
-  }
-  return {
-    major: parseInt(match[1], 10),
-    minor: parseInt(match[2], 10),
-    patch: parseInt(match[3], 10),
-    prerelease: match[4],
-    build: match[5]
-  };
-}
-function formatVersion(parsed) {
-  let version = `${parsed.major}.${parsed.minor}.${parsed.patch}`;
-  if (parsed.prerelease) {
-    version += `-${parsed.prerelease}`;
-  }
-  if (parsed.build) {
-    version += `+${parsed.build}`;
-  }
-  return version;
-}
-function isValidVersion(version) {
-  try {
-    parseVersion(version);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function compareVersions(a, b) {
-  const parsedA = parseVersion(a);
-  const parsedB = parseVersion(b);
-  if (parsedA.major !== parsedB.major) {
-    return parsedA.major < parsedB.major ? -1 : 1;
-  }
-  if (parsedA.minor !== parsedB.minor) {
-    return parsedA.minor < parsedB.minor ? -1 : 1;
-  }
-  if (parsedA.patch !== parsedB.patch) {
-    return parsedA.patch < parsedB.patch ? -1 : 1;
-  }
-  if (!parsedA.prerelease && parsedB.prerelease) return 1;
-  if (parsedA.prerelease && !parsedB.prerelease) return -1;
-  if (parsedA.prerelease && parsedB.prerelease) {
-    return parsedA.prerelease < parsedB.prerelease ? -1 : parsedA.prerelease > parsedB.prerelease ? 1 : 0;
-  }
-  return 0;
-}
-function bumpVersion(version, type) {
-  const parsed = parseVersion(version);
-  switch (type) {
-    case "major":
-      return formatVersion({
-        major: parsed.major + 1,
-        minor: 0,
-        patch: 0
-      });
-    case "minor":
-      return formatVersion({
-        major: parsed.major,
-        minor: parsed.minor + 1,
-        patch: 0
-      });
-    case "patch":
-      return formatVersion({
-        major: parsed.major,
-        minor: parsed.minor,
-        patch: parsed.patch + 1
-      });
-    case "prerelease":
-      if (parsed.prerelease) {
-        const match = parsed.prerelease.match(/^(.+?)(\d+)$/);
-        if (match) {
-          return formatVersion({
-            ...parsed,
-            prerelease: `${match[1]}${parseInt(match[2], 10) + 1}`
-          });
-        }
-        return formatVersion({
-          ...parsed,
-          prerelease: `${parsed.prerelease}.1`
-        });
-      }
-      return formatVersion({
-        ...parsed,
-        prerelease: "alpha.1"
-      });
-    default:
-      throw new Error(`Unknown bump type: ${type}`);
-  }
-}
-function satisfiesRange(version, range) {
-  const parsed = parseVersion(version);
-  if (isValidVersion(range)) {
-    return compareVersions(version, range) === 0;
-  }
-  if (range.startsWith("^")) {
-    const rangeVersion = parseVersion(range.slice(1));
-    if (parsed.major !== rangeVersion.major) return false;
-    if (rangeVersion.major === 0) {
-      if (parsed.minor !== rangeVersion.minor) return false;
-      if (rangeVersion.minor === 0) {
-        return parsed.patch >= rangeVersion.patch;
-      }
-      return parsed.patch >= rangeVersion.patch;
-    }
-    return compareVersions(version, range.slice(1)) >= 0;
-  }
-  if (range.startsWith("~")) {
-    const rangeVersion = parseVersion(range.slice(1));
-    return parsed.major === rangeVersion.major && parsed.minor === rangeVersion.minor && parsed.patch >= rangeVersion.patch;
-  }
-  if (range.startsWith(">=")) {
-    return compareVersions(version, range.slice(2)) >= 0;
-  }
-  if (range.startsWith(">")) {
-    return compareVersions(version, range.slice(1)) > 0;
-  }
-  if (range.startsWith("<=")) {
-    return compareVersions(version, range.slice(2)) <= 0;
-  }
-  if (range.startsWith("<")) {
-    return compareVersions(version, range.slice(1)) < 0;
-  }
-  if (range.includes("x") || range.includes("*")) {
-    const parts = range.split(".");
-    if (parts[0] === "x" || parts[0] === "*") return true;
-    if (parsed.major !== parseInt(parts[0], 10)) return false;
-    if (parts[1] === "x" || parts[1] === "*" || parts.length === 1) return true;
-    if (parsed.minor !== parseInt(parts[1], 10)) return false;
-    if (parts[2] === "x" || parts[2] === "*" || parts.length === 2) return true;
-    return parsed.patch === parseInt(parts[2], 10);
-  }
-  return false;
-}
-function getLatestVersion(versions) {
-  if (versions.length === 0) return null;
-  return versions.reduce((latest, current) => {
-    return compareVersions(current, latest) > 0 ? current : latest;
-  });
-}
-function sortVersions(versions) {
-  return [...versions].sort((a, b) => compareVersions(a, b));
-}
-function inferBumpType(changes) {
-  if (changes.breakingChanges && changes.breakingChanges.length > 0) {
-    return "major";
-  }
-  if (changes.newFeatures && changes.newFeatures.length > 0) {
-    return "minor";
-  }
-  return "patch";
-}
-
-// src/versioning/lineage.ts
-var LineageTracker = class {
-  constructor(storage) {
-    this.storage = storage;
-  }
-  /**
-   * Create a new version of a skill
-   */
-  async createVersion(skillId, updates, options = {}) {
-    const currentSkill = await this.storage.getSkill(skillId);
-    if (!currentSkill) {
-      throw new Error(`Skill not found: ${skillId}`);
-    }
-    const bumpType = options.bumpType || inferBumpType(options.changes || {});
-    const newVersion = bumpVersion(currentSkill.version, bumpType);
-    const updatedSkill = {
-      ...currentSkill,
-      ...updates,
-      id: skillId,
-      version: newVersion,
-      parentVersion: currentSkill.version,
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    await this.storage.saveSkill(updatedSkill);
-    return updatedSkill;
-  }
-  /**
-   * Fork a skill to create a new, related skill
-   */
-  async forkSkill(skillId, options) {
-    const sourceSkill = await this.storage.getSkill(skillId, options.fromVersion);
-    if (!sourceSkill) {
-      throw new Error(`Skill not found: ${skillId}${options.fromVersion ? `@${options.fromVersion}` : ""}`);
-    }
-    const forkedSkill = {
-      ...sourceSkill,
-      id: options.newId,
-      name: options.newName || `${sourceSkill.name}-fork`,
-      version: "1.0.0",
-      parentVersion: void 0,
-      derivedFrom: [skillId],
-      createdAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date(),
-      status: "draft",
-      metrics: {
-        usageCount: 0,
-        successRate: 0,
-        feedbackScores: []
-      },
-      source: {
-        type: "composed",
-        importedAt: /* @__PURE__ */ new Date()
-      }
-    };
-    await this.storage.saveSkill(forkedSkill);
-    return forkedSkill;
-  }
-  /**
-   * Merge changes from one skill into another
-   */
-  async mergeSkill(targetId, sourceId, options = {}) {
-    const targetSkill = await this.storage.getSkill(targetId);
-    const sourceSkill = await this.storage.getSkill(sourceId);
-    if (!targetSkill) throw new Error(`Target skill not found: ${targetId}`);
-    if (!sourceSkill) throw new Error(`Source skill not found: ${sourceId}`);
-    const fields = options.fields || [
-      "solution",
-      "triggerConditions",
-      "examples",
-      "notes"
-    ];
-    const strategy = options.conflictStrategy || "combine";
-    const updates = {};
-    for (const field of fields) {
-      if (field === "triggerConditions") {
-        updates.triggerConditions = this.mergeTriggerConditions(
-          targetSkill.triggerConditions,
-          sourceSkill.triggerConditions
-        );
-      } else if (field === "examples") {
-        updates.examples = this.mergeExamples(
-          targetSkill.examples,
-          sourceSkill.examples
-        );
-      } else if (field === "tags") {
-        updates.tags = [.../* @__PURE__ */ new Set([...targetSkill.tags, ...sourceSkill.tags])];
-      } else if (field === "solution" || field === "notes") {
-        updates[field] = this.mergeText(
-          targetSkill[field] || "",
-          sourceSkill[field] || "",
-          strategy
-        );
-      }
-    }
-    updates.derivedFrom = [
-      ...targetSkill.derivedFrom || [],
-      sourceId
-    ].filter((id, i, arr) => arr.indexOf(id) === i);
-    return this.createVersion(targetId, updates, {
-      bumpType: "minor",
-      changelog: options.changelog || `Merged from ${sourceId}`,
-      changes: { newFeatures: [`Merged content from ${sourceId}`] }
-    });
-  }
-  /**
-   * Get the full lineage tree for a skill
-   */
-  async getLineageTree(skillId) {
-    const lineage = await this.storage.getLineage(skillId);
-    if (!lineage) return null;
-    const tree = {
-      skillId,
-      versions: lineage.versions,
-      forks: [],
-      ancestors: []
-    };
-    for (const fork of lineage.forks) {
-      const forkedSkill = await this.storage.getSkill(fork.forkedSkillId);
-      if (forkedSkill) {
-        tree.forks.push({
-          skill: forkedSkill,
-          fork
-        });
-      }
-    }
-    const currentSkill = await this.storage.getSkill(skillId);
-    if (currentSkill?.derivedFrom) {
-      for (const ancestorId of currentSkill.derivedFrom) {
-        const ancestor = await this.storage.getSkill(ancestorId);
-        if (ancestor) {
-          tree.ancestors.push(ancestor);
-        }
-      }
-    }
-    return tree;
-  }
-  /**
-   * Rollback a skill to a previous version
-   */
-  async rollback(skillId, toVersion) {
-    const targetSkill = await this.storage.getSkill(skillId, toVersion);
-    if (!targetSkill) {
-      throw new Error(`Version not found: ${skillId}@${toVersion}`);
-    }
-    const currentSkill = await this.storage.getSkill(skillId);
-    if (!currentSkill) {
-      throw new Error(`Skill not found: ${skillId}`);
-    }
-    const newVersion = bumpVersion(currentSkill.version, "patch");
-    const rolledBackSkill = {
-      ...targetSkill,
-      version: newVersion,
-      parentVersion: currentSkill.version,
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    await this.storage.saveSkill(rolledBackSkill);
-    return rolledBackSkill;
-  }
-  /**
-   * Compare two versions of a skill
-   */
-  async compareVersions(skillId, versionA, versionB) {
-    const skillA = await this.storage.getSkill(skillId, versionA);
-    const skillB = await this.storage.getSkill(skillId, versionB);
-    if (!skillA) throw new Error(`Version not found: ${skillId}@${versionA}`);
-    if (!skillB) throw new Error(`Version not found: ${skillId}@${versionB}`);
-    return {
-      versionA,
-      versionB,
-      changes: this.diffSkills(skillA, skillB)
-    };
-  }
-  /**
-   * Get suggested next version based on changes
-   */
-  async suggestNextVersion(skillId, changes) {
-    const skill = await this.storage.getSkill(skillId);
-    if (!skill) throw new Error(`Skill not found: ${skillId}`);
-    const bumpType = inferBumpType(changes);
-    return bumpVersion(skill.version, bumpType);
-  }
-  // ==========================================================================
-  // Private helpers
-  // ==========================================================================
-  mergeTriggerConditions(target, source) {
-    const seen = new Set(target.map((t) => `${t.type}:${t.value}`));
-    const merged = [...target];
-    for (const trigger of source) {
-      const key = `${trigger.type}:${trigger.value}`;
-      if (!seen.has(key)) {
-        merged.push(trigger);
-        seen.add(key);
-      }
-    }
-    return merged;
-  }
-  mergeExamples(target, source) {
-    const seen = new Set(target.map((e) => e.scenario));
-    const merged = [...target];
-    for (const example of source) {
-      if (!seen.has(example.scenario)) {
-        merged.push(example);
-        seen.add(example.scenario);
-      }
-    }
-    return merged;
-  }
-  mergeText(target, source, strategy) {
-    switch (strategy) {
-      case "source":
-        return source;
-      case "target":
-        return target;
-      case "combine":
-        if (!target) return source;
-        if (!source) return target;
-        return `${target}
-
----
-
-${source}`;
-    }
-  }
-  diffSkills(skillA, skillB) {
-    const changes = {
-      modified: [],
-      added: [],
-      removed: []
-    };
-    const textFields = [
-      "name",
-      "description",
-      "problem",
-      "solution",
-      "verification",
-      "notes"
-    ];
-    for (const field of textFields) {
-      const valueA = skillA[field];
-      const valueB = skillB[field];
-      if (valueA !== valueB) {
-        changes.modified.push({
-          field,
-          oldValue: valueA,
-          newValue: valueB
-        });
-      }
-    }
-    const triggersA = new Set(skillA.triggerConditions.map((t) => `${t.type}:${t.value}`));
-    const triggersB = new Set(skillB.triggerConditions.map((t) => `${t.type}:${t.value}`));
-    for (const trigger of triggersB) {
-      if (!triggersA.has(trigger)) {
-        changes.added.push({ type: "triggerCondition", value: trigger });
-      }
-    }
-    for (const trigger of triggersA) {
-      if (!triggersB.has(trigger)) {
-        changes.removed.push({ type: "triggerCondition", value: trigger });
-      }
-    }
-    const tagsA = new Set(skillA.tags);
-    const tagsB = new Set(skillB.tags);
-    for (const tag of tagsB) {
-      if (!tagsA.has(tag)) {
-        changes.added.push({ type: "tag", value: tag });
-      }
-    }
-    for (const tag of tagsA) {
-      if (!tagsB.has(tag)) {
-        changes.removed.push({ type: "tag", value: tag });
-      }
-    }
-    return changes;
-  }
-};
-
-// src/matching/embeddings.ts
-var SimpleHashEmbedding = class {
-  constructor() {
-    this.name = "simple-hash";
-    this.dimensions = 64;
-  }
-  async embed(text) {
-    return this.hashToVector(text);
-  }
-  async embedBatch(texts) {
-    return texts.map((text) => this.hashToVector(text));
-  }
-  hashToVector(text) {
-    const normalized = text.toLowerCase().trim();
-    const vector = new Array(this.dimensions).fill(0);
-    for (let i = 0; i < normalized.length; i++) {
-      const charCode = normalized.charCodeAt(i);
-      const idx = (charCode + i) % this.dimensions;
-      vector[idx] += Math.sin(charCode * (i + 1)) * 0.1;
-    }
-    const words = normalized.split(/\s+/);
-    for (let i = 0; i < words.length; i++) {
-      const word = words[i];
-      const hash = this.simpleHash(word);
-      const idx = hash % this.dimensions;
-      vector[idx] += 0.5;
-    }
-    return this.normalize(vector);
-  }
-  simpleHash(str) {
-    let hash = 0;
-    for (let i = 0; i < str.length; i++) {
-      const char = str.charCodeAt(i);
-      hash = (hash << 5) - hash + char;
-      hash = hash & hash;
-    }
-    return Math.abs(hash);
-  }
-  normalize(vector) {
-    const magnitude = Math.sqrt(vector.reduce((sum, v) => sum + v * v, 0));
-    if (magnitude === 0) return vector;
-    return vector.map((v) => v / magnitude);
-  }
-};
-var OpenAIEmbedding = class {
-  constructor(options) {
-    this.name = "openai";
-    this.dimensions = 1536;
-    if (!options.apiKey) {
-      throw new Error("OpenAI API key is required");
-    }
-    this.apiKey = options.apiKey;
-    this.model = options.model || "text-embedding-3-small";
-    this.baseUrl = options.baseUrl || "https://api.openai.com/v1";
-    if (this.model === "text-embedding-3-large") {
-      this.dimensions = 3072;
-    } else if (this.model === "text-embedding-ada-002") {
-      this.dimensions = 1536;
-    }
-  }
-  async embed(text) {
-    const embeddings = await this.embedBatch([text]);
-    return embeddings[0];
-  }
-  async embedBatch(texts) {
-    const response = await fetch(`${this.baseUrl}/embeddings`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify({
-        model: this.model,
-        input: texts
-      })
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`OpenAI API error: ${error}`);
-    }
-    const data = await response.json();
-    return data.data.sort((a, b) => a.index - b.index).map((item) => item.embedding);
-  }
-};
-var VoyageEmbedding = class {
-  constructor(options) {
-    this.name = "voyage";
-    this.dimensions = 1024;
-    if (!options.apiKey) {
-      throw new Error("Voyage API key is required");
-    }
-    this.apiKey = options.apiKey;
-    this.model = options.model || "voyage-2";
-  }
-  async embed(text) {
-    const embeddings = await this.embedBatch([text]);
-    return embeddings[0];
-  }
-  async embedBatch(texts) {
-    const response = await fetch("https://api.voyageai.com/v1/embeddings", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify({
-        model: this.model,
-        input: texts
-      })
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Voyage API error: ${error}`);
-    }
-    const data = await response.json();
-    return data.data.map((item) => item.embedding);
-  }
-};
-function cosineSimilarity(a, b) {
-  if (a.length !== b.length) {
-    throw new Error("Vectors must have the same length");
-  }
-  let dotProduct = 0;
-  let normA = 0;
-  let normB = 0;
-  for (let i = 0; i < a.length; i++) {
-    dotProduct += a[i] * b[i];
-    normA += a[i] * a[i];
-    normB += b[i] * b[i];
-  }
-  const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
-  if (magnitude === 0) return 0;
-  return dotProduct / magnitude;
-}
-function euclideanDistance(a, b) {
-  if (a.length !== b.length) {
-    throw new Error("Vectors must have the same length");
-  }
-  let sum = 0;
-  for (let i = 0; i < a.length; i++) {
-    const diff = a[i] - b[i];
-    sum += diff * diff;
-  }
-  return Math.sqrt(sum);
-}
-
-// src/matching/matcher.ts
-var SemanticMatcher = class {
-  constructor(config = {}) {
-    this.cache = /* @__PURE__ */ new Map();
-    this.provider = config.embeddingProvider || new SimpleHashEmbedding();
-    this.config = {
-      embeddingProvider: this.provider,
-      similarityThreshold: config.similarityThreshold ?? 0.5,
-      maxResults: config.maxResults ?? 10,
-      cacheEmbeddings: config.cacheEmbeddings ?? true,
-      embeddingFields: config.embeddingFields ?? [
-        "name",
-        "description",
-        "problem",
-        "triggerConditions",
-        "tags"
-      ]
-    };
-  }
-  /**
-   * Find skills matching a query string
-   */
-  async findMatches(query, skills, options) {
-    const threshold = options?.threshold ?? this.config.similarityThreshold;
-    const maxResults = options?.maxResults ?? this.config.maxResults;
-    const queryEmbedding = await this.provider.embed(query);
-    const results = [];
-    for (const skill of skills) {
-      const skillEmbedding = await this.getSkillEmbedding(skill);
-      const similarity = cosineSimilarity(queryEmbedding, skillEmbedding);
-      if (similarity >= threshold) {
-        results.push({
-          skill,
-          similarity,
-          matchedFields: this.identifyMatchedFields(query, skill)
-        });
-      }
-    }
-    return results.sort((a, b) => b.similarity - a.similarity).slice(0, maxResults);
-  }
-  /**
-   * Find skills matching a context (problem description, error message, etc.)
-   */
-  async findByContext(context, skills, options) {
-    const queryParts = [];
-    if (context.problemDescription) {
-      queryParts.push(context.problemDescription);
-    }
-    if (context.errorMessage) {
-      queryParts.push(`error: ${context.errorMessage}`);
-    }
-    if (context.keywords) {
-      queryParts.push(context.keywords.join(" "));
-    }
-    if (context.technologies) {
-      queryParts.push(context.technologies.join(" "));
-    }
-    if (context.codeSnippet) {
-      const identifiers = this.extractIdentifiers(context.codeSnippet);
-      queryParts.push(identifiers.join(" "));
-    }
-    const query = queryParts.join(" ");
-    return this.findMatches(query, skills, options);
-  }
-  /**
-   * Find skills similar to a given skill
-   */
-  async findSimilar(skill, allSkills, options) {
-    const skillText = this.skillToText(skill);
-    const excludeSelf = options?.excludeSelf ?? true;
-    const candidates = excludeSelf ? allSkills.filter((s) => s.id !== skill.id) : allSkills;
-    return this.findMatches(skillText, candidates, options);
-  }
-  /**
-   * Find skills that might apply to a trajectory
-   */
-  async findForTrajectory(trajectory, skills, options) {
-    const contextParts = [];
-    for (const turn of trajectory.turns) {
-      if (turn.content) {
-        const errorMatch = turn.content.match(/error[:\s]+([^\n]+)/i);
-        if (errorMatch) {
-          contextParts.push(errorMatch[1]);
-        }
-        if (turn.role === "user") {
-          contextParts.push(turn.content.substring(0, 500));
-        }
-      }
-    }
-    const query = contextParts.join(" ");
-    return this.findMatches(query, skills, options);
-  }
-  /**
-   * Pre-compute and cache embeddings for all skills
-   */
-  async indexSkills(skills) {
-    const texts = skills.map((s) => this.skillToText(s));
-    const embeddings = await this.provider.embedBatch(texts);
-    for (let i = 0; i < skills.length; i++) {
-      const skill = skills[i];
-      const cacheKey = this.getCacheKey(skill);
-      this.cache.set(cacheKey, {
-        skillId: skill.id,
-        version: skill.version,
-        embedding: embeddings[i],
-        updatedAt: /* @__PURE__ */ new Date()
-      });
-    }
-  }
-  /**
-   * Index skills from a storage adapter
-   */
-  async indexFromStorage(storage) {
-    const skills = await storage.listSkills();
-    await this.indexSkills(skills);
-    return skills.length;
-  }
-  /**
-   * Clear the embedding cache
-   */
-  clearCache() {
-    this.cache.clear();
-  }
-  /**
-   * Get cache statistics
-   */
-  getCacheStats() {
-    return {
-      size: this.cache.size,
-      skills: Array.from(this.cache.values()).map((e) => `${e.skillId}@${e.version}`)
-    };
-  }
-  /**
-   * Update configuration
-   */
-  setConfig(config) {
-    if (config.embeddingProvider) {
-      this.provider = config.embeddingProvider;
-      this.config.embeddingProvider = config.embeddingProvider;
-      this.clearCache();
-    }
-    if (config.similarityThreshold !== void 0) {
-      this.config.similarityThreshold = config.similarityThreshold;
-    }
-    if (config.maxResults !== void 0) {
-      this.config.maxResults = config.maxResults;
-    }
-    if (config.cacheEmbeddings !== void 0) {
-      this.config.cacheEmbeddings = config.cacheEmbeddings;
-    }
-    if (config.embeddingFields) {
-      this.config.embeddingFields = config.embeddingFields;
-      this.clearCache();
-    }
-  }
-  // ===========================================================================
-  // Private helpers
-  // ===========================================================================
-  /**
-   * Get or compute embedding for a skill
-   */
-  async getSkillEmbedding(skill) {
-    if (this.config.cacheEmbeddings) {
-      const cacheKey = this.getCacheKey(skill);
-      const cached = this.cache.get(cacheKey);
-      if (cached) {
-        return cached.embedding;
-      }
-      const embedding = await this.provider.embed(this.skillToText(skill));
-      this.cache.set(cacheKey, {
-        skillId: skill.id,
-        version: skill.version,
-        embedding,
-        updatedAt: /* @__PURE__ */ new Date()
-      });
-      return embedding;
-    }
-    return this.provider.embed(this.skillToText(skill));
-  }
-  /**
-   * Convert skill to text for embedding
-   */
-  skillToText(skill) {
-    const parts = [];
-    for (const field of this.config.embeddingFields) {
-      switch (field) {
-        case "name":
-          parts.push(skill.name);
-          break;
-        case "description":
-          parts.push(skill.description);
-          break;
-        case "problem":
-          parts.push(skill.problem);
-          break;
-        case "solution":
-          parts.push(skill.solution);
-          break;
-        case "triggerConditions":
-          parts.push(
-            skill.triggerConditions.map((t) => `${t.type}: ${t.value}`).join(" ")
-          );
-          break;
-        case "tags":
-          parts.push(skill.tags.join(" "));
-          break;
-      }
-    }
-    return parts.filter(Boolean).join(" ");
-  }
-  /**
-   * Get cache key for a skill
-   */
-  getCacheKey(skill) {
-    return `${skill.id}:${skill.version}`;
-  }
-  /**
-   * Identify which fields in the skill matched the query
-   */
-  identifyMatchedFields(query, skill) {
-    const queryTerms = query.toLowerCase().split(/\s+/);
-    const matchedFields = [];
-    const checkField = (fieldName, value) => {
-      const lowerValue = value.toLowerCase();
-      if (queryTerms.some((term) => lowerValue.includes(term))) {
-        matchedFields.push(fieldName);
-      }
-    };
-    checkField("name", skill.name);
-    checkField("description", skill.description);
-    checkField("problem", skill.problem);
-    checkField("solution", skill.solution);
-    checkField("tags", skill.tags.join(" "));
-    checkField(
-      "triggerConditions",
-      skill.triggerConditions.map((t) => t.value).join(" ")
-    );
-    return matchedFields;
-  }
-  /**
-   * Extract identifiers from code snippet
-   */
-  extractIdentifiers(code) {
-    const identifiers = code.match(/[a-zA-Z_][a-zA-Z0-9_]*/g) || [];
-    return [...new Set(identifiers)].filter((id) => id.length > 2);
-  }
-};
-
-// src/skill-bank.ts
-var SkillBank = class {
-  constructor(config = {}) {
-    this.eventHandlers = [];
-    this.initialized = false;
-    this.autoIndexOnInit = false;
-    if (config.storage?.type === "filesystem") {
-      this.storage = new FilesystemStorageAdapter({
-        basePath: config.storage.basePath,
-        openSkillsCompatible: config.storage.openSkillsCompatible ?? true
-      });
-    } else {
-      this.storage = new MemoryStorageAdapter();
-    }
-    this.adapterRegistry = new AdapterRegistry();
-    this.adapterRegistry.register(claudeCodeAdapter);
-    if (config.adapters) {
-      for (const adapter of config.adapters) {
-        this.adapterRegistry.register(adapter);
-      }
-    }
-    this.manualExtractor = new ManualExtractor();
-    this.automaticExtractor = new AutomaticExtractor({
-      llmProvider: config.llmProvider,
-      minConfidence: config.minExtractionConfidence
-    });
-    this.lineageTracker = new LineageTracker(this.storage);
-    this.semanticMatcher = new SemanticMatcher({
-      embeddingProvider: config.matching?.embeddingProvider,
-      similarityThreshold: config.matching?.similarityThreshold
-    });
-    this.autoIndexOnInit = config.matching?.autoIndex ?? false;
-  }
-  /**
-   * Initialize the skill bank (required before use)
-   */
-  async initialize() {
-    await this.storage.initialize();
-    this.initialized = true;
-    if (this.autoIndexOnInit) {
-      await this.indexSkills();
-    }
-  }
-  /**
-   * Ensure initialized before operations
-   */
-  ensureInitialized() {
-    if (!this.initialized) {
-      throw new Error("SkillBank not initialized. Call initialize() first.");
-    }
-  }
-  // ==========================================================================
-  // Session Parsing
-  // ==========================================================================
-  /**
-   * Parse a session from raw content
-   */
-  async parseSession(content, adapterName) {
-    let adapter;
-    if (adapterName) {
-      adapter = this.adapterRegistry.get(adapterName);
-      if (!adapter) {
-        throw new Error(`Adapter not found: ${adapterName}`);
-      }
-    } else {
-      adapter = this.adapterRegistry.findAdapter(content);
-      if (!adapter) {
-        throw new Error("No suitable adapter found for this content");
-      }
-    }
-    return adapter.parse(content);
-  }
-  /**
-   * Parse multiple sessions
-   */
-  async parseSessions(input, adapterName) {
-    let adapter;
-    if (adapterName) {
-      adapter = this.adapterRegistry.get(adapterName);
-    } else {
-      adapter = this.adapterRegistry.findAdapter(input);
-    }
-    if (!adapter) {
-      throw new Error("No suitable adapter found");
-    }
-    return adapter.parseMany(input);
-  }
-  /**
-   * Register a custom session adapter
-   */
-  registerAdapter(adapter) {
-    this.adapterRegistry.register(adapter);
-  }
-  // ==========================================================================
-  // Skill Extraction
-  // ==========================================================================
-  /**
-   * Extract a skill manually from a trajectory
-   */
-  async extractManual(trajectory, request) {
-    this.ensureInitialized();
-    this.emit({ type: "extraction:started", sessionId: trajectory.sessionId });
-    const results = await this.manualExtractor.extract(trajectory, {
-      turnRange: request?.turnRange,
-      suggestedName: request?.suggestedName,
-      skipValidation: request?.skipValidation
-    });
-    const result = results[0];
-    if (!result) {
-      const failedResult = {
-        success: false,
-        confidence: 0,
-        gateResults: [],
-        failureReason: "No extraction result",
-        sourceTrajectory: {
-          sessionId: trajectory.sessionId,
-          turnRange: request?.turnRange || [0, trajectory.turns.length - 1]
-        }
-      };
-      this.emit({ type: "extraction:failed", error: "No extraction result" });
-      return failedResult;
-    }
-    if (result.success && result.skill) {
-      await this.storage.saveSkill(result.skill);
-      this.emit({ type: "skill:created", skill: result.skill });
-    }
-    this.emit({ type: "extraction:completed", result });
-    return result;
-  }
-  /**
-   * Extract skills automatically from a trajectory
-   */
-  async extractAutomatic(trajectory, options) {
-    this.ensureInitialized();
-    this.emit({ type: "extraction:started", sessionId: trajectory.sessionId });
-    const results = await this.automaticExtractor.extract(trajectory, options);
-    for (const result of results) {
-      if (result.success && result.skill) {
-        await this.storage.saveSkill(result.skill);
-        this.emit({ type: "skill:created", skill: result.skill });
-      }
-      this.emit({ type: "extraction:completed", result });
-    }
-    return results;
-  }
-  /**
-   * Extract from raw session content (convenience method)
-   */
-  async extractFromSession(content, options) {
-    const trajectory = await this.parseSession(content, options?.adapterName);
-    if (options?.mode === "automatic") {
-      return this.extractAutomatic(trajectory, options);
-    } else {
-      const result = await this.extractManual(trajectory, options);
-      return [result];
-    }
-  }
-  /**
-   * Set LLM provider for automatic extraction
-   */
-  setLLMProvider(provider) {
-    this.automaticExtractor.setLLMProvider(provider);
-  }
-  // ==========================================================================
-  // Semantic Matching
-  // ==========================================================================
-  /**
-   * Find skills matching a query using semantic similarity
-   */
-  async findMatchingSkills(query, options) {
-    this.ensureInitialized();
-    const skills = await this.storage.listSkills({ status: ["active"] });
-    return this.semanticMatcher.findMatches(query, skills, options);
-  }
-  /**
-   * Find skills matching a context (problem, error, keywords)
-   */
-  async findSkillsByContext(context, options) {
-    this.ensureInitialized();
-    const skills = await this.storage.listSkills({ status: ["active"] });
-    return this.semanticMatcher.findByContext(context, skills, options);
-  }
-  /**
-   * Find skills similar to a given skill
-   */
-  async findSimilarSkills(skillId, options) {
-    this.ensureInitialized();
-    const skill = await this.storage.getSkill(skillId);
-    if (!skill) {
-      throw new Error(`Skill not found: ${skillId}`);
-    }
-    const allSkills = await this.storage.listSkills({ status: ["active"] });
-    return this.semanticMatcher.findSimilar(skill, allSkills, {
-      ...options,
-      excludeSelf: true
-    });
-  }
-  /**
-   * Find skills that might apply to a trajectory
-   */
-  async findSkillsForTrajectory(trajectory, options) {
-    this.ensureInitialized();
-    const skills = await this.storage.listSkills({ status: ["active"] });
-    return this.semanticMatcher.findForTrajectory(trajectory, skills, options);
-  }
-  /**
-   * Index all skills for faster semantic matching
-   */
-  async indexSkills() {
-    this.ensureInitialized();
-    return this.semanticMatcher.indexFromStorage(this.storage);
-  }
-  /**
-   * Set embedding provider for semantic matching
-   */
-  setEmbeddingProvider(provider) {
-    this.semanticMatcher.setConfig({ embeddingProvider: provider });
-  }
-  // ==========================================================================
-  // Skill CRUD Operations
-  // ==========================================================================
-  /**
-   * Get a skill by ID
-   */
-  async getSkill(id, version) {
-    this.ensureInitialized();
-    return this.storage.getSkill(id, version);
-  }
-  /**
-   * List all skills with optional filtering
-   */
-  async listSkills(filter) {
-    this.ensureInitialized();
-    return this.storage.listSkills(filter);
-  }
-  /**
-   * Search skills by query
-   */
-  async searchSkills(query) {
-    this.ensureInitialized();
-    return this.storage.searchSkills(query);
-  }
-  /**
-   * Save or update a skill
-   */
-  async saveSkill(skill) {
-    this.ensureInitialized();
-    const existing = await this.storage.getSkill(skill.id);
-    await this.storage.saveSkill(skill);
-    if (existing) {
-      this.emit({ type: "skill:updated", skill, previousVersion: existing.version });
-    } else {
-      this.emit({ type: "skill:created", skill });
-    }
-  }
-  /**
-   * Delete a skill
-   */
-  async deleteSkill(id, version) {
-    this.ensureInitialized();
-    const deleted = await this.storage.deleteSkill(id, version);
-    if (deleted) {
-      this.emit({ type: "skill:deleted", skillId: id });
-    }
-    return deleted;
-  }
-  /**
-   * Deprecate a skill
-   */
-  async deprecateSkill(id) {
-    this.ensureInitialized();
-    const skill = await this.storage.getSkill(id);
-    if (!skill) {
-      throw new Error(`Skill not found: ${id}`);
-    }
-    const deprecated = {
-      ...skill,
-      status: "deprecated",
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    await this.storage.saveSkill(deprecated);
-    this.emit({ type: "skill:deprecated", skillId: id });
-    return deprecated;
-  }
-  // ==========================================================================
-  // Version Management
-  // ==========================================================================
-  /**
-   * Create a new version of a skill
-   */
-  async createVersion(skillId, updates, options) {
-    this.ensureInitialized();
-    const newSkill = await this.lineageTracker.createVersion(skillId, updates, options);
-    this.emit({ type: "skill:updated", skill: newSkill, previousVersion: newSkill.parentVersion || "" });
-    return newSkill;
-  }
-  /**
-   * Fork a skill to create a new variant
-   */
-  async forkSkill(skillId, options) {
-    this.ensureInitialized();
-    const forked = await this.lineageTracker.forkSkill(skillId, options);
-    this.emit({ type: "skill:created", skill: forked });
-    return forked;
-  }
-  /**
-   * Get version history for a skill
-   */
-  async getVersionHistory(skillId) {
-    this.ensureInitialized();
-    return this.storage.getVersionHistory(skillId);
-  }
-  /**
-   * Get full lineage for a skill
-   */
-  async getLineage(skillId) {
-    this.ensureInitialized();
-    return this.storage.getLineage(skillId);
-  }
-  /**
-   * Rollback a skill to a previous version
-   */
-  async rollbackSkill(skillId, toVersion) {
-    this.ensureInitialized();
-    return this.lineageTracker.rollback(skillId, toVersion);
-  }
-  /**
-   * Compare two versions of a skill
-   */
-  async compareVersions(skillId, versionA, versionB) {
-    this.ensureInitialized();
-    return this.lineageTracker.compareVersions(skillId, versionA, versionB);
-  }
-  // ==========================================================================
-  // Events
-  // ==========================================================================
-  /**
-   * Subscribe to skill bank events
-   */
-  on(handler) {
-    this.eventHandlers.push(handler);
-    return () => {
-      const index = this.eventHandlers.indexOf(handler);
-      if (index >= 0) {
-        this.eventHandlers.splice(index, 1);
-      }
-    };
-  }
-  /**
-   * Emit an event to all handlers
-   */
-  emit(event) {
-    for (const handler of this.eventHandlers) {
-      try {
-        handler(event);
-      } catch (error) {
-        console.error("Event handler error:", error);
-      }
-    }
-  }
-  // ==========================================================================
-  // Utilities
-  // ==========================================================================
-  /**
-   * Get statistics about the skill bank
-   */
-  async getStats() {
-    this.ensureInitialized();
-    const skills = await this.storage.listSkills();
-    const stats = {
-      totalSkills: skills.length,
-      byStatus: {
-        draft: 0,
-        active: 0,
-        deprecated: 0,
-        experimental: 0
-      },
-      byTag: {},
-      avgSuccessRate: 0,
-      totalUsage: 0
-    };
-    let successRateSum = 0;
-    let successRateCount = 0;
-    for (const skill of skills) {
-      stats.byStatus[skill.status]++;
-      for (const tag of skill.tags) {
-        stats.byTag[tag] = (stats.byTag[tag] || 0) + 1;
-      }
-      stats.totalUsage += skill.metrics.usageCount;
-      if (skill.metrics.successRate > 0) {
-        successRateSum += skill.metrics.successRate;
-        successRateCount++;
-      }
-    }
-    stats.avgSuccessRate = successRateCount > 0 ? successRateSum / successRateCount : 0;
-    return stats;
-  }
-  /**
-   * Export all skills (for backup or migration)
-   */
-  async exportAll() {
-    this.ensureInitialized();
-    return this.storage.listSkills();
-  }
-  /**
-   * Import skills (for restore or migration)
-   */
-  async importSkills(skills) {
-    this.ensureInitialized();
-    let imported = 0;
-    let failed = 0;
-    for (const skill of skills) {
-      try {
-        await this.storage.saveSkill(skill);
-        this.emit({ type: "skill:created", skill });
-        imported++;
-      } catch {
-        failed++;
-      }
-    }
-    return { imported, failed };
-  }
-};
-function createSkillBank(config) {
-  return new SkillBank(config);
-}
-
-// src/batch/processor.ts
-var BatchProcessor = class {
-  constructor(config = {}) {
-    this.config = {
-      concurrency: config.concurrency ?? 5,
-      minConfidence: config.minConfidence ?? 0.6,
-      deduplication: config.deduplication ?? "semantic",
-      deduplicationThreshold: config.deduplicationThreshold ?? 0.85,
-      skipQualityGates: config.skipQualityGates ?? false,
-      extractionMode: config.extractionMode ?? "manual",
-      llmProvider: config.llmProvider,
-      embeddingProvider: config.embeddingProvider,
-      onProgress: config.onProgress
-    };
-    this.manualExtractor = new ManualExtractor();
-    this.automaticExtractor = new AutomaticExtractor({
-      minConfidence: this.config.minConfidence
-    });
-    if (this.config.llmProvider) {
-      this.automaticExtractor.setLLMProvider(this.config.llmProvider);
-    }
-    this.matcher = new SemanticMatcher({
-      embeddingProvider: this.config.embeddingProvider || new SimpleHashEmbedding(),
-      similarityThreshold: this.config.deduplicationThreshold
-    });
-  }
-  /**
-   * Process multiple sessions and extract skills
-   */
-  async process(sessions, parseSession) {
-    const startTime = Date.now();
-    const allExtractions = [];
-    const failedSessions = [];
-    const progress = {
-      total: sessions.length,
-      processed: 0,
-      skillsExtracted: 0,
-      duplicatesFound: 0,
-      phase: "parsing",
-      percentage: 0
-    };
-    this.reportProgress(progress);
-    const batches = this.createBatches(sessions, this.config.concurrency);
-    for (const batch of batches) {
-      progress.phase = "extracting";
-      const batchPromises = batch.map(async (session) => {
-        progress.currentSession = session.source;
-        this.reportProgress(progress);
-        try {
-          const trajectory = session.trajectory || await parseSession(session.content);
-          let results = [];
-          if (this.config.extractionMode === "automatic" && this.config.llmProvider) {
-            results = await this.automaticExtractor.extract(trajectory);
-          } else if (this.config.extractionMode === "manual") {
-            results = await this.manualExtractor.extract(trajectory, {
-              suggestedName: this.generateSkillName(trajectory, session.source),
-              skipValidation: this.config.skipQualityGates
-            });
-          } else if (this.config.extractionMode === "candidates-only") {
-            results = [this.createCandidateExtraction(trajectory, session.source)];
-          }
-          const successful = results.filter((r) => r.success && r.skill);
-          allExtractions.push(...successful);
-          progress.skillsExtracted += successful.length;
-        } catch (error) {
-          failedSessions.push({
-            source: session.source,
-            error: error instanceof Error ? error.message : String(error)
-          });
-        }
-        progress.processed++;
-        progress.percentage = Math.round(progress.processed / progress.total * 100);
-        this.reportProgress(progress);
-      });
-      await Promise.all(batchPromises);
-    }
-    progress.phase = "deduplicating";
-    this.reportProgress(progress);
-    const { unique, duplicates } = await this.deduplicate(allExtractions);
-    progress.duplicatesFound = duplicates.length;
-    progress.phase = "complete";
-    progress.percentage = 100;
-    this.reportProgress(progress);
-    const avgConfidence = unique.length > 0 ? unique.reduce((sum, e) => sum + e.confidence, 0) / unique.length : 0;
-    return {
-      skills: unique,
-      totalSessions: sessions.length,
-      failedSessions,
-      duplicates,
-      stats: {
-        totalExtractions: allExtractions.length,
-        uniqueSkills: unique.length,
-        duplicatesRemoved: duplicates.length,
-        averageConfidence: avgConfidence,
-        processingTimeMs: Date.now() - startTime
-      }
-    };
-  }
-  /**
-   * Process session files from file paths
-   */
-  async processFiles(filePaths, readFile2, parseSession) {
-    const sessions = [];
-    for (const path2 of filePaths) {
-      const content = await readFile2(path2);
-      sessions.push({
-        content,
-        source: path2
-      });
-    }
-    return this.process(sessions, parseSession);
-  }
-  /**
-   * Set LLM provider for automatic extraction
-   */
-  setLLMProvider(provider) {
-    this.config.llmProvider = provider;
-    this.automaticExtractor.setLLMProvider(provider);
-  }
-  /**
-   * Set embedding provider for semantic deduplication
-   */
-  setEmbeddingProvider(provider) {
-    this.config.embeddingProvider = provider;
-    this.matcher = new SemanticMatcher({
-      embeddingProvider: provider,
-      similarityThreshold: this.config.deduplicationThreshold
-    });
-  }
-  /**
-   * Update configuration
-   */
-  setConfig(config) {
-    if (config.concurrency !== void 0) {
-      this.config.concurrency = config.concurrency;
-    }
-    if (config.minConfidence !== void 0) {
-      this.config.minConfidence = config.minConfidence;
-      this.automaticExtractor = new AutomaticExtractor({
-        minConfidence: config.minConfidence
-      });
-      if (this.config.llmProvider) {
-        this.automaticExtractor.setLLMProvider(this.config.llmProvider);
-      }
-    }
-    if (config.deduplication !== void 0) {
-      this.config.deduplication = config.deduplication;
-    }
-    if (config.deduplicationThreshold !== void 0) {
-      this.config.deduplicationThreshold = config.deduplicationThreshold;
-      this.matcher.setConfig({ similarityThreshold: config.deduplicationThreshold });
-    }
-    if (config.skipQualityGates !== void 0) {
-      this.config.skipQualityGates = config.skipQualityGates;
-    }
-    if (config.extractionMode !== void 0) {
-      this.config.extractionMode = config.extractionMode;
-    }
-    if (config.onProgress !== void 0) {
-      this.config.onProgress = config.onProgress;
-    }
-    if (config.llmProvider !== void 0) {
-      this.setLLMProvider(config.llmProvider);
-    }
-    if (config.embeddingProvider !== void 0) {
-      this.setEmbeddingProvider(config.embeddingProvider);
-    }
-  }
-  // ===========================================================================
-  // Private helpers
-  // ===========================================================================
-  /**
-   * Create batches for parallel processing
-   */
-  createBatches(items, batchSize) {
-    const batches = [];
-    for (let i = 0; i < items.length; i += batchSize) {
-      batches.push(items.slice(i, i + batchSize));
-    }
-    return batches;
-  }
-  /**
-   * Deduplicate extracted skills
-   */
-  async deduplicate(extractions) {
-    if (this.config.deduplication === "none" || extractions.length === 0) {
-      return { unique: extractions, duplicates: [] };
-    }
-    const unique = [];
-    const duplicates = [];
-    for (const extraction of extractions) {
-      if (unique.length === 0) {
-        unique.push(extraction);
-        continue;
-      }
-      const isDuplicate = await this.checkDuplicate(extraction, unique);
-      if (isDuplicate) {
-        duplicates.push(isDuplicate);
-      } else {
-        unique.push(extraction);
-      }
-    }
-    return { unique, duplicates };
-  }
-  /**
-   * Check if an extraction is a duplicate of existing ones
-   */
-  async checkDuplicate(extraction, existing) {
-    const extractionSkill = extraction.skill;
-    if (!extractionSkill) return null;
-    if (this.config.deduplication === "exact") {
-      for (const e of existing) {
-        const existingSkill = e.skill;
-        if (!existingSkill) continue;
-        if (existingSkill.name === extractionSkill.name || existingSkill.problem === extractionSkill.problem) {
-          return {
-            skill: extraction,
-            duplicateOf: existingSkill.id
-          };
-        }
-      }
-    } else if (this.config.deduplication === "semantic") {
-      const existingSkills = existing.filter((e) => e.skill !== void 0).map((e) => e.skill);
-      const matches = await this.matcher.findMatches(
-        `${extractionSkill.name} ${extractionSkill.problem} ${extractionSkill.description}`,
-        existingSkills,
-        { threshold: this.config.deduplicationThreshold, maxResults: 1 }
-      );
-      if (matches.length > 0) {
-        return {
-          skill: extraction,
-          duplicateOf: matches[0].skill.id,
-          similarity: matches[0].similarity
-        };
-      }
-    }
-    return null;
-  }
-  /**
-   * Generate skill name from trajectory
-   */
-  generateSkillName(trajectory, source) {
-    const firstUserTurn = trajectory.turns.find((t) => t.role === "user");
-    if (firstUserTurn?.content) {
-      const firstLine = firstUserTurn.content.split(/[.\n]/)[0].trim();
-      if (firstLine.length > 0 && firstLine.length < 60) {
-        return this.slugify(firstLine);
-      }
-    }
-    if (source) {
-      const baseName = source.split("/").pop()?.replace(/\.[^.]+$/, "");
-      if (baseName) {
-        return `skill-from-${this.slugify(baseName)}`;
-      }
-    }
-    return `skill-${Date.now().toString(36)}`;
-  }
-  /**
-   * Convert string to slug
-   */
-  slugify(text) {
-    return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").substring(0, 50);
-  }
-  /**
-   * Create a candidate extraction without full processing
-   */
-  createCandidateExtraction(trajectory, source) {
-    const name = this.generateSkillName(trajectory, source);
-    const firstUserTurn = trajectory.turns.find((t) => t.role === "user");
-    return {
-      success: true,
-      skill: {
-        id: name,
-        name: name.replace(/-/g, " "),
-        description: "Candidate skill - needs review",
-        problem: firstUserTurn?.content?.substring(0, 500) || "Unknown problem",
-        solution: "Solution pending extraction",
-        verification: "Verification pending",
-        triggerConditions: [],
-        tags: [],
-        version: "0.1.0",
-        status: "draft",
-        examples: [],
-        author: "batch-processor",
-        metrics: {
-          usageCount: 0,
-          successRate: 0,
-          feedbackScores: []
-        },
-        source: {
-          type: "extracted",
-          sessionId: trajectory.sessionId,
-          importedAt: /* @__PURE__ */ new Date()
-        },
-        createdAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date()
-      },
-      confidence: 0.3,
-      gateResults: [],
-      sourceTrajectory: {
-        sessionId: trajectory.sessionId,
-        turnRange: [0, trajectory.turns.length - 1]
-      }
-    };
-  }
-  /**
-   * Report progress to callback
-   */
-  reportProgress(progress) {
-    if (this.config.onProgress) {
-      this.config.onProgress({ ...progress });
-    }
-  }
-};
-
-// src/composer/dependency-graph.ts
-var DependencyGraph = class {
-  constructor() {
-    this.nodes = /* @__PURE__ */ new Map();
-    this.edges = [];
-    this.adjacencyList = /* @__PURE__ */ new Map();
-    this.reverseAdjacencyList = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Add a skill to the graph
-   */
-  addSkill(skill) {
-    const key = this.getKey(skill.id, skill.version);
-    this.nodes.set(key, {
-      skillId: skill.id,
-      version: skill.version,
-      skill
-    });
-    if (!this.adjacencyList.has(key)) {
-      this.adjacencyList.set(key, /* @__PURE__ */ new Set());
-    }
-    if (!this.reverseAdjacencyList.has(key)) {
-      this.reverseAdjacencyList.set(key, /* @__PURE__ */ new Set());
-    }
-  }
-  /**
-   * Remove a skill from the graph
-   */
-  removeSkill(skillId, version) {
-    const keysToRemove = version ? [this.getKey(skillId, version)] : Array.from(this.nodes.keys()).filter((k) => k.startsWith(`${skillId}@`));
-    for (const key of keysToRemove) {
-      this.nodes.delete(key);
-      this.adjacencyList.delete(key);
-      this.reverseAdjacencyList.delete(key);
-      this.edges = this.edges.filter(
-        (e) => this.getKey(e.from) !== key && this.getKey(e.to) !== key
-      );
-      for (const adj of this.adjacencyList.values()) {
-        adj.delete(key);
-      }
-      for (const adj of this.reverseAdjacencyList.values()) {
-        adj.delete(key);
-      }
-    }
-  }
-  /**
-   * Add a dependency edge
-   */
-  addDependency(fromId, toId, type, options) {
-    const edge = {
-      from: fromId,
-      to: toId,
-      type,
-      required: options?.required ?? true,
-      description: options?.description
-    };
-    this.edges.push(edge);
-    const fromKey = options?.fromVersion ? this.getKey(fromId, options.fromVersion) : fromId;
-    const toKey = options?.toVersion ? this.getKey(toId, options.toVersion) : toId;
-    if (!this.adjacencyList.has(fromKey)) {
-      this.adjacencyList.set(fromKey, /* @__PURE__ */ new Set());
-    }
-    this.adjacencyList.get(fromKey).add(toKey);
-    if (!this.reverseAdjacencyList.has(toKey)) {
-      this.reverseAdjacencyList.set(toKey, /* @__PURE__ */ new Set());
-    }
-    this.reverseAdjacencyList.get(toKey).add(fromKey);
-  }
-  /**
-   * Remove a dependency edge
-   */
-  removeDependency(fromId, toId, type) {
-    this.edges = this.edges.filter(
-      (e) => !(e.from === fromId && e.to === toId && (type === void 0 || e.type === type))
-    );
-    const remainingEdges = this.edges.filter(
-      (e) => e.from === fromId && e.to === toId
-    );
-    if (remainingEdges.length === 0) {
-      this.adjacencyList.get(fromId)?.delete(toId);
-      this.reverseAdjacencyList.get(toId)?.delete(fromId);
-    }
-  }
-  /**
-   * Get all dependencies of a skill
-   */
-  getDependencies(skillId) {
-    return this.edges.filter((e) => e.from === skillId);
-  }
-  /**
-   * Get all skills that depend on this skill
-   */
-  getDependents(skillId) {
-    return this.edges.filter((e) => e.to === skillId);
-  }
-  /**
-   * Get conflicts for a skill
-   */
-  getConflicts(skillId) {
-    return this.edges.filter(
-      (e) => e.type === "conflicts" && (e.from === skillId || e.to === skillId)
-    );
-  }
-  /**
-   * Check if two skills conflict
-   */
-  hasConflict(skillId1, skillId2) {
-    return this.edges.some(
-      (e) => e.type === "conflicts" && (e.from === skillId1 && e.to === skillId2 || e.from === skillId2 && e.to === skillId1)
-    );
-  }
-  /**
-   * Get topological sort of skills (for execution order)
-   */
-  getTopologicalOrder(skillIds) {
-    const targetIds = skillIds || Array.from(new Set(this.edges.flatMap((e) => [e.from, e.to])));
-    const visited = /* @__PURE__ */ new Set();
-    const result = [];
-    const visit = (id) => {
-      if (visited.has(id)) return;
-      visited.add(id);
-      const deps = this.edges.filter(
-        (e) => e.from === id && (e.type === "requires" || e.type === "precedes" || e.type === "extends")
-      );
-      for (const dep of deps) {
-        visit(dep.to);
-      }
-      result.push(id);
-    };
-    for (const id of targetIds) {
-      visit(id);
-    }
-    return result;
-  }
-  /**
-   * Detect cycles in the graph
-   */
-  detectCycle() {
-    const visited = /* @__PURE__ */ new Set();
-    const recStack = /* @__PURE__ */ new Set();
-    const path2 = [];
-    const dfs = (node) => {
-      visited.add(node);
-      recStack.add(node);
-      path2.push(node);
-      const neighbors = this.adjacencyList.get(node) || /* @__PURE__ */ new Set();
-      for (const neighbor of neighbors) {
-        if (!visited.has(neighbor)) {
-          const cycle = dfs(neighbor);
-          if (cycle) return cycle;
-        } else if (recStack.has(neighbor)) {
-          const cycleStart = path2.indexOf(neighbor);
-          return path2.slice(cycleStart).concat(neighbor);
-        }
-      }
-      path2.pop();
-      recStack.delete(node);
-      return null;
-    };
-    const allNodes = /* @__PURE__ */ new Set([
-      ...this.adjacencyList.keys(),
-      ...this.reverseAdjacencyList.keys()
-    ]);
-    for (const node of allNodes) {
-      if (!visited.has(node)) {
-        const cycle = dfs(node);
-        if (cycle) {
-          return { hasCycle: true, cycle };
-        }
-      }
-    }
-    return { hasCycle: false };
-  }
-  /**
-   * Get all required dependencies (transitive)
-   */
-  getTransitiveDependencies(skillId) {
-    const result = /* @__PURE__ */ new Set();
-    const queue = [skillId];
-    while (queue.length > 0) {
-      const current = queue.shift();
-      const deps = this.edges.filter(
-        (e) => e.from === current && e.type === "requires" && e.required
-      );
-      for (const dep of deps) {
-        if (!result.has(dep.to)) {
-          result.add(dep.to);
-          queue.push(dep.to);
-        }
-      }
-    }
-    return Array.from(result);
-  }
-  /**
-   * Check if all required dependencies are satisfied
-   */
-  checkDependenciesSatisfied(skillIds) {
-    const available = new Set(skillIds);
-    const missing = [];
-    for (const id of skillIds) {
-      const requiredDeps = this.edges.filter(
-        (e) => e.from === id && e.type === "requires" && e.required
-      );
-      for (const dep of requiredDeps) {
-        if (!available.has(dep.to)) {
-          missing.push(dep.to);
-        }
-      }
-    }
-    return {
-      satisfied: missing.length === 0,
-      missing: [...new Set(missing)]
-    };
-  }
-  /**
-   * Get all skills in the graph
-   */
-  getSkills() {
-    return Array.from(this.nodes.values()).map((n) => n.skill);
-  }
-  /**
-   * Get all edges in the graph
-   */
-  getEdges() {
-    return [...this.edges];
-  }
-  /**
-   * Get graph statistics
-   */
-  getStats() {
-    const edgesByType = {
-      requires: 0,
-      extends: 0,
-      conflicts: 0,
-      enhances: 0,
-      precedes: 0,
-      follows: 0
-    };
-    for (const edge of this.edges) {
-      edgesByType[edge.type]++;
-    }
-    return {
-      nodeCount: this.nodes.size,
-      edgeCount: this.edges.length,
-      edgesByType
-    };
-  }
-  /**
-   * Clear the graph
-   */
-  clear() {
-    this.nodes.clear();
-    this.edges = [];
-    this.adjacencyList.clear();
-    this.reverseAdjacencyList.clear();
-  }
-  /**
-   * Export graph to JSON
-   */
-  toJSON() {
-    return {
-      nodes: Array.from(this.nodes.values()).map((n) => ({
-        skillId: n.skillId,
-        version: n.version
-      })),
-      edges: this.edges
-    };
-  }
-  /**
-   * Import graph from JSON (requires skills to be added separately)
-   */
-  fromJSON(data) {
-    for (const edge of data.edges) {
-      this.addDependency(edge.from, edge.to, edge.type, {
-        required: edge.required,
-        description: edge.description
-      });
-    }
-  }
-  // ===========================================================================
-  // Private helpers
-  // ===========================================================================
-  getKey(skillId, version) {
-    return version ? `${skillId}@${version}` : skillId;
-  }
-};
-
-// src/composer/composer.ts
-var SkillComposer = class {
-  constructor(config = {}) {
-    this.skillCache = /* @__PURE__ */ new Map();
-    this.config = {
-      storage: config.storage,
-      embeddingProvider: config.embeddingProvider || new SimpleHashEmbedding(),
-      suggestionThreshold: config.suggestionThreshold ?? 0.6,
-      maxDependencyDepth: config.maxDependencyDepth ?? 10
-    };
-    this.graph = new DependencyGraph();
-    this.matcher = new SemanticMatcher({
-      embeddingProvider: this.config.embeddingProvider,
-      similarityThreshold: this.config.suggestionThreshold
-    });
-  }
-  /**
-   * Compose multiple skills into a compound skill
-   */
-  async compose(skillIds, options) {
-    const conflicts = [];
-    const warnings = [];
-    const missingDependencies = [];
-    const skills = [];
-    for (const id of skillIds) {
-      const skill = await this.getSkill(id);
-      if (!skill) {
-        missingDependencies.push(id);
-        continue;
-      }
-      skills.push(skill);
-    }
-    if (missingDependencies.length > 0) {
-      return {
-        success: false,
-        conflicts,
-        warnings,
-        missingDependencies
-      };
-    }
-    const detectedConflicts = this.detectConflicts(skills);
-    conflicts.push(...detectedConflicts);
-    const blockingConflicts = conflicts.filter((c) => c.severity === "error");
-    if (blockingConflicts.length > 0) {
-      return {
-        success: false,
-        conflicts,
-        warnings,
-        missingDependencies
-      };
-    }
-    for (const conflict of conflicts.filter((c) => c.severity === "warning")) {
-      warnings.push(conflict.description);
-    }
-    const depCheck = this.graph.checkDependenciesSatisfied(skillIds);
-    if (!depCheck.satisfied) {
-      warnings.push(
-        `Missing optional dependencies: ${depCheck.missing.join(", ")}`
-      );
-    }
-    const orderedIds = options.mode === "sequential" ? this.getExecutionOrder(skillIds, options.executionOrder) : skillIds;
-    const components = orderedIds.map((id, index) => ({
-      skillId: id,
-      priority: index
-    }));
-    const compoundSkill = {
-      id: this.generateId(options.name),
-      name: options.name,
-      description: options.description || this.generateDescription(skills),
-      problem: this.mergeProblemStatements(skills),
-      triggerConditions: this.mergeTriggerConditions(skills),
-      solution: this.generateSolutionSteps(skills, options.mode || "sequential"),
-      verification: this.mergeVerifications(skills),
-      examples: [],
-      notes: `Composed from: ${skillIds.join(", ")}`,
-      author: "skill-composer",
-      tags: this.mergeTags(skills),
-      version: "1.0.0",
-      status: "draft",
-      metrics: {
-        usageCount: 0,
-        successRate: 0,
-        feedbackScores: []
-      },
-      source: {
-        type: "composed",
-        importedAt: /* @__PURE__ */ new Date()
-      },
-      createdAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date(),
-      derivedFrom: skillIds,
-      isCompound: true,
-      composition: {
-        mode: options.mode || "sequential",
-        executionOrder: options.executionOrder,
-        components,
-        stopOnFailure: options.stopOnFailure ?? true
-      }
-    };
-    return {
-      success: true,
-      skill: compoundSkill,
-      conflicts,
-      warnings,
-      missingDependencies
-    };
-  }
-  /**
-   * Decompose a compound skill into its components
-   */
-  async decompose(skill) {
-    const skills = [];
-    for (const component of skill.composition.components) {
-      const componentSkill = await this.getSkill(
-        component.skillId,
-        component.version
-      );
-      if (componentSkill) {
-        skills.push(componentSkill);
-      }
-    }
-    return skills;
-  }
-  /**
-   * Add a dependency relationship between skills
-   */
-  addDependency(fromId, toId, type, options) {
-    this.graph.addDependency(fromId, toId, type, options);
-  }
-  /**
-   * Remove a dependency relationship
-   */
-  removeDependency(fromId, toId, type) {
-    this.graph.removeDependency(fromId, toId, type);
-  }
-  /**
-   * Get dependencies for a skill
-   */
-  getDependencies(skillId) {
-    return this.graph.getDependencies(skillId);
-  }
-  /**
-   * Get skills that depend on this skill
-   */
-  getDependents(skillId) {
-    return this.graph.getDependents(skillId);
-  }
-  /**
-   * Detect conflicts between skills
-   */
-  detectConflicts(skills) {
-    const conflicts = [];
-    for (let i = 0; i < skills.length; i++) {
-      for (let j = i + 1; j < skills.length; j++) {
-        const skill1 = skills[i];
-        const skill2 = skills[j];
-        if (this.graph.hasConflict(skill1.id, skill2.id)) {
-          conflicts.push({
-            type: "direct",
-            skillId1: skill1.id,
-            skillId2: skill2.id,
-            description: `Skills "${skill1.name}" and "${skill2.name}" have declared conflicts`,
-            severity: "error"
-          });
-        }
-        const triggerOverlap = this.checkTriggerOverlap(skill1, skill2);
-        if (triggerOverlap) {
-          conflicts.push({
-            type: "trigger-overlap",
-            skillId1: skill1.id,
-            skillId2: skill2.id,
-            description: `Skills have overlapping trigger conditions: ${triggerOverlap}`,
-            severity: "warning"
-          });
-        }
-      }
-    }
-    return conflicts;
-  }
-  /**
-   * Validate a composition without creating it
-   */
-  async validateComposition(skillIds) {
-    const skills = [];
-    const missingDependencies = [];
-    const warnings = [];
-    for (const id of skillIds) {
-      const skill = await this.getSkill(id);
-      if (!skill) {
-        missingDependencies.push(id);
-      } else {
-        skills.push(skill);
-      }
-    }
-    const conflicts = this.detectConflicts(skills);
-    const blockingConflicts = conflicts.filter((c) => c.severity === "error");
-    const cycleResult = this.graph.detectCycle();
-    if (cycleResult.hasCycle) {
-      warnings.push(
-        `Circular dependency detected: ${cycleResult.cycle?.join(" -> ")}`
-      );
-    }
-    return {
-      valid: blockingConflicts.length === 0 && missingDependencies.length === 0,
-      conflicts,
-      missingDependencies,
-      warnings
-    };
-  }
-  /**
-   * Suggest skill compositions based on usage patterns and similarity
-   */
-  async suggestCompositions(skills, options) {
-    const suggestions = [];
-    const maxSuggestions = options?.maxSuggestions ?? 5;
-    const minConfidence = options?.minConfidence ?? this.config.suggestionThreshold;
-    for (let i = 0; i < skills.length; i++) {
-      const similar = await this.matcher.findSimilar(skills[i], skills, {
-        threshold: minConfidence,
-        maxResults: 3
-      });
-      for (const match of similar) {
-        if (match.skill.id === skills[i].id) continue;
-        const existing = suggestions.find(
-          (s) => s.skillIds.includes(skills[i].id) && s.skillIds.includes(match.skill.id)
-        );
-        if (existing) continue;
-        const mode = this.suggestCompositionMode(skills[i], match.skill);
-        suggestions.push({
-          skillIds: [skills[i].id, match.skill.id],
-          mode,
-          confidence: match.similarity,
-          reason: `Similar ${this.getSimilarityReason(skills[i], match.skill)}`,
-          benefit: this.estimateBenefit(skills[i], match.skill, mode)
-        });
-      }
-    }
-    const dependencyPairs = this.findCommonDependencyPairs(skills);
-    for (const pair of dependencyPairs) {
-      const existing = suggestions.find(
-        (s) => s.skillIds.includes(pair[0]) && s.skillIds.includes(pair[1])
-      );
-      if (!existing) {
-        suggestions.push({
-          skillIds: pair,
-          mode: "sequential",
-          confidence: 0.7,
-          reason: "Frequently used together based on dependency patterns",
-          benefit: "Streamlined workflow"
-        });
-      }
-    }
-    return suggestions.sort((a, b) => b.confidence - a.confidence).slice(0, maxSuggestions);
-  }
-  /**
-   * Index skills from storage for composition suggestions
-   */
-  async indexFromStorage(storage) {
-    const skills = await storage.listSkills();
-    for (const skill of skills) {
-      this.graph.addSkill(skill);
-      this.skillCache.set(skill.id, skill);
-      if (skill.derivedFrom) {
-        for (const parentId of skill.derivedFrom) {
-          this.graph.addDependency(skill.id, parentId, "extends");
-        }
-      }
-    }
-    await this.matcher.indexSkills(skills);
-    return skills.length;
-  }
-  /**
-   * Get dependency graph
-   */
-  getGraph() {
-    return this.graph;
-  }
-  /**
-   * Clear caches and graph
-   */
-  clear() {
-    this.graph.clear();
-    this.skillCache.clear();
-    this.matcher.clearCache();
-  }
-  // ===========================================================================
-  // Private helpers
-  // ===========================================================================
-  async getSkill(id, version) {
-    const cacheKey = version ? `${id}@${version}` : id;
-    if (this.skillCache.has(cacheKey)) {
-      return this.skillCache.get(cacheKey);
-    }
-    if (this.config.storage) {
-      const skill = await this.config.storage.getSkill(id, version);
-      if (skill) {
-        this.skillCache.set(cacheKey, skill);
-        return skill;
-      }
-    }
-    return null;
-  }
-  generateId(name) {
-    return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-  }
-  generateDescription(skills) {
-    return `Combines: ${skills.map((s) => s.name).join(", ")}`;
-  }
-  mergeProblemStatements(skills) {
-    const problems = skills.map((s) => `- ${s.problem}`);
-    return `This compound skill addresses:
-${problems.join("\n")}`;
-  }
-  mergeTriggerConditions(skills) {
-    const seen = /* @__PURE__ */ new Set();
-    const triggers = [];
-    for (const skill of skills) {
-      for (const trigger of skill.triggerConditions) {
-        const key = `${trigger.type}:${trigger.value}`;
-        if (!seen.has(key)) {
-          seen.add(key);
-          triggers.push(trigger);
-        }
-      }
-    }
-    return triggers;
-  }
-  generateSolutionSteps(skills, mode) {
-    const steps = [];
-    switch (mode) {
-      case "sequential":
-        steps.push("Execute the following skills in order:");
-        skills.forEach((s, i) => {
-          steps.push(`
-## Step ${i + 1}: ${s.name}
-${s.solution}`);
-        });
-        break;
-      case "parallel":
-        steps.push("Execute the following skills (can be done in parallel):");
-        skills.forEach((s) => {
-          steps.push(`
-## ${s.name}
-${s.solution}`);
-        });
-        break;
-      case "conditional":
-        steps.push("Execute skills based on conditions:");
-        skills.forEach((s) => {
-          const triggers = s.triggerConditions.map((t) => t.value).join(" OR ");
-          steps.push(`
-## If ${triggers}:
-${s.solution}`);
-        });
-        break;
-      case "fallback":
-        steps.push("Try skills in order until one succeeds:");
-        skills.forEach((s, i) => {
-          steps.push(`
-## Option ${i + 1}: ${s.name}
-${s.solution}`);
-        });
-        break;
-    }
-    return steps.join("\n");
-  }
-  mergeVerifications(skills) {
-    const verifications = skills.map(
-      (s) => `- ${s.name}: ${s.verification}`
-    );
-    return `Verify all components:
-${verifications.join("\n")}`;
-  }
-  mergeTags(skills) {
-    const tags = /* @__PURE__ */ new Set();
-    for (const skill of skills) {
-      for (const tag of skill.tags) {
-        tags.add(tag);
-      }
-    }
-    tags.add("compound");
-    return Array.from(tags);
-  }
-  getExecutionOrder(skillIds, order) {
-    switch (order) {
-      case "dependency":
-        return this.graph.getTopologicalOrder(skillIds);
-      case "priority":
-        return skillIds;
-      case "fixed":
-      default:
-        return skillIds;
-    }
-  }
-  checkTriggerOverlap(skill1, skill2) {
-    const triggers1 = skill1.triggerConditions.map((t) => t.value.toLowerCase());
-    const triggers2 = skill2.triggerConditions.map((t) => t.value.toLowerCase());
-    for (const t1 of triggers1) {
-      for (const t2 of triggers2) {
-        if (t1 === t2 || t1.includes(t2) || t2.includes(t1)) {
-          return t1;
-        }
-      }
-    }
-    return null;
-  }
-  suggestCompositionMode(skill1, skill2) {
-    if (skill1.solution.toLowerCase().includes(skill2.problem.toLowerCase().slice(0, 20)) || skill2.solution.toLowerCase().includes(skill1.problem.toLowerCase().slice(0, 20))) {
-      return "sequential";
-    }
-    const overlap = this.checkTriggerOverlap(skill1, skill2);
-    if (!overlap) {
-      return "conditional";
-    }
-    return "fallback";
-  }
-  getSimilarityReason(skill1, skill2) {
-    const reasons = [];
-    const problem1Words = new Set(skill1.problem.toLowerCase().split(/\s+/));
-    const problem2Words = new Set(skill2.problem.toLowerCase().split(/\s+/));
-    const problemOverlap = [...problem1Words].filter((w) => problem2Words.has(w));
-    if (problemOverlap.length > 3) {
-      reasons.push("problem statements");
-    }
-    const tagOverlap = skill1.tags.filter((t) => skill2.tags.includes(t));
-    if (tagOverlap.length > 0) {
-      reasons.push(`tags (${tagOverlap.join(", ")})`);
-    }
-    if (this.checkTriggerOverlap(skill1, skill2)) {
-      reasons.push("trigger conditions");
-    }
-    return reasons.length > 0 ? reasons.join(", ") : "content";
-  }
-  estimateBenefit(skill1, skill2, mode) {
-    switch (mode) {
-      case "sequential":
-        return "Combined workflow reduces manual steps";
-      case "parallel":
-        return "Parallel execution saves time";
-      case "conditional":
-        return "Smart routing to appropriate skill";
-      case "fallback":
-        return "Increased reliability with backup options";
-      default:
-        return "Unified skill management";
-    }
-  }
-  findCommonDependencyPairs(skills) {
-    const pairs = [];
-    const skillIds = new Set(skills.map((s) => s.id));
-    for (const skill of skills) {
-      const deps = this.graph.getDependencies(skill.id);
-      for (const dep of deps) {
-        if (skillIds.has(dep.to) && dep.type !== "conflicts") {
-          pairs.push([skill.id, dep.to]);
-        }
-      }
-    }
-    return pairs;
-  }
-};
-
-// src/composer/types.ts
-function isCompoundSkill(skill) {
-  return "isCompound" in skill && skill.isCompound === true;
-}
-
-// src/index.ts
-var VERSION = "0.1.0";
-
-export {
-  BaseSessionAdapter,
-  AdapterRegistry,
-  adapterRegistry,
-  ClaudeCodeAdapter,
-  claudeCodeAdapter,
-  DEFAULT_QUALITY_GATES,
-  QualityGateEvaluator,
-  BaseExtractor,
-  ManualExtractor,
-  AutomaticExtractor,
-  BaseStorageAdapter,
-  MemoryStorageAdapter,
-  FilesystemStorageAdapter,
-  parseVersion,
-  formatVersion,
-  isValidVersion,
-  compareVersions,
-  bumpVersion,
-  satisfiesRange,
-  getLatestVersion,
-  sortVersions,
-  inferBumpType,
-  LineageTracker,
-  SimpleHashEmbedding,
-  OpenAIEmbedding,
-  VoyageEmbedding,
-  cosineSimilarity,
-  euclideanDistance,
-  SemanticMatcher,
-  SkillBank,
-  createSkillBank,
-  BatchProcessor,
-  DependencyGraph,
-  SkillComposer,
-  isCompoundSkill,
-  VERSION
-};