skill-tree 0.1.0 → 0.1.2

package/dist/chunk-7LMOQW5H.mjs

@@ -0,0 +1,4893 @@
+// 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/adapters/openai.ts
+var OpenAIAdapter = class extends BaseSessionAdapter {
+  constructor() {
+    super(...arguments);
+    this.name = "openai";
+    this.supportedExtensions = [".json", ".jsonl"];
+  }
+  canHandle(input) {
+    const str = typeof input === "string" ? input : input.toString("utf-8");
+    try {
+      const parsed = JSON.parse(str);
+      if (parsed.messages && Array.isArray(parsed.messages)) {
+        return this.looksLikeOpenAIMessages(parsed.messages);
+      }
+      if (Array.isArray(parsed)) {
+        return this.looksLikeOpenAIMessages(parsed);
+      }
+      return false;
+    } catch {
+      const firstLine = str.split("\n")[0]?.trim();
+      if (!firstLine) return false;
+      try {
+        const parsed = JSON.parse(firstLine);
+        return parsed.role !== void 0 && ["system", "user", "assistant", "tool"].includes(parsed.role);
+      } catch {
+        return false;
+      }
+    }
+  }
+  async parse(input) {
+    const str = typeof input === "string" ? input : input.toString("utf-8");
+    let conversation;
+    try {
+      const parsed = JSON.parse(str);
+      if (parsed.messages && Array.isArray(parsed.messages)) {
+        conversation = parsed;
+      } else if (Array.isArray(parsed)) {
+        conversation = { messages: parsed };
+      } else {
+        throw new Error("Invalid OpenAI format");
+      }
+    } catch {
+      const lines = str.split("\n").filter((l) => l.trim());
+      const messages = [];
+      for (const line of lines) {
+        try {
+          messages.push(JSON.parse(line));
+        } catch {
+        }
+      }
+      conversation = { messages };
+    }
+    return this.convertToTrajectory(conversation);
+  }
+  async parseMany(input) {
+    const sections = input.split(/\n\n+/);
+    const trajectories = [];
+    for (const section of sections) {
+      if (section.trim()) {
+        try {
+          trajectories.push(await this.parse(section));
+        } catch {
+        }
+      }
+    }
+    return trajectories.length > 0 ? trajectories : [await this.parse(input)];
+  }
+  looksLikeOpenAIMessages(messages) {
+    if (messages.length === 0) return false;
+    const first = messages[0];
+    return first.role !== void 0 && ["system", "user", "assistant", "tool"].includes(first.role);
+  }
+  convertToTrajectory(conversation) {
+    const turns = [];
+    const pendingToolCalls = /* @__PURE__ */ new Map();
+    const metadata = {
+      agentType: "openai",
+      model: conversation.model,
+      custom: conversation.metadata
+    };
+    for (let i = 0; i < conversation.messages.length; i++) {
+      const msg = conversation.messages[i];
+      if (msg.role === "tool" && msg.tool_call_id) {
+        const lastAssistantTurn = [...turns].reverse().find((t) => t.role === "assistant");
+        if (lastAssistantTurn) {
+          if (!lastAssistantTurn.toolResults) {
+            lastAssistantTurn.toolResults = [];
+          }
+          const pendingCall = pendingToolCalls.get(msg.tool_call_id);
+          lastAssistantTurn.toolResults.push({
+            callId: msg.tool_call_id,
+            name: pendingCall?.name || msg.name || "unknown",
+            output: msg.content || "",
+            success: true
+          });
+        }
+        continue;
+      }
+      const turn = {
+        index: turns.length,
+        role: msg.role,
+        content: msg.content || ""
+      };
+      if (msg.role === "assistant" && msg.tool_calls) {
+        turn.toolCalls = msg.tool_calls.map((tc) => {
+          let parsedArgs = {};
+          try {
+            parsedArgs = JSON.parse(tc.function.arguments);
+          } catch {
+            parsedArgs = { raw: tc.function.arguments };
+          }
+          const toolCall = {
+            callId: tc.id,
+            name: tc.function.name,
+            input: parsedArgs
+          };
+          pendingToolCalls.set(tc.id, toolCall);
+          return toolCall;
+        });
+      }
+      turns.push(turn);
+    }
+    return {
+      sessionId: conversation.id || this.generateSessionId(),
+      startedAt: conversation.created ? new Date(conversation.created * 1e3) : /* @__PURE__ */ new Date(),
+      turns,
+      metadata
+    };
+  }
+};
+var openAIAdapter = new OpenAIAdapter();
+
+// src/adapters/anthropic.ts
+var AnthropicAdapter = class extends BaseSessionAdapter {
+  constructor() {
+    super(...arguments);
+    this.name = "anthropic";
+    this.supportedExtensions = [".json", ".jsonl"];
+  }
+  canHandle(input) {
+    const str = typeof input === "string" ? input : input.toString("utf-8");
+    try {
+      const parsed = JSON.parse(str);
+      if (parsed.messages && Array.isArray(parsed.messages)) {
+        return this.looksLikeAnthropicMessages(parsed.messages);
+      }
+      if (Array.isArray(parsed)) {
+        return this.looksLikeAnthropicMessages(parsed);
+      }
+      return false;
+    } catch {
+      const firstLine = str.split("\n")[0]?.trim();
+      if (!firstLine) return false;
+      try {
+        const parsed = JSON.parse(firstLine);
+        return parsed.role !== void 0 && ["user", "assistant"].includes(parsed.role) && (typeof parsed.content === "string" || Array.isArray(parsed.content));
+      } catch {
+        return false;
+      }
+    }
+  }
+  async parse(input) {
+    const str = typeof input === "string" ? input : input.toString("utf-8");
+    let conversation;
+    try {
+      const parsed = JSON.parse(str);
+      if (parsed.messages && Array.isArray(parsed.messages)) {
+        conversation = parsed;
+      } else if (Array.isArray(parsed)) {
+        conversation = { messages: parsed };
+      } else {
+        throw new Error("Invalid Anthropic format");
+      }
+    } catch {
+      const lines = str.split("\n").filter((l) => l.trim());
+      const messages = [];
+      for (const line of lines) {
+        try {
+          messages.push(JSON.parse(line));
+        } catch {
+        }
+      }
+      conversation = { messages };
+    }
+    return this.convertToTrajectory(conversation);
+  }
+  async parseMany(input) {
+    const sections = input.split(/\n\n+/);
+    const trajectories = [];
+    for (const section of sections) {
+      if (section.trim()) {
+        try {
+          trajectories.push(await this.parse(section));
+        } catch {
+        }
+      }
+    }
+    return trajectories.length > 0 ? trajectories : [await this.parse(input)];
+  }
+  looksLikeAnthropicMessages(messages) {
+    if (messages.length === 0) return false;
+    const first = messages[0];
+    return first.role !== void 0 && ["user", "assistant"].includes(first.role) && first.content !== void 0 && (typeof first.content === "string" || Array.isArray(first.content));
+  }
+  convertToTrajectory(conversation) {
+    const turns = [];
+    const pendingToolCalls = /* @__PURE__ */ new Map();
+    const metadata = {
+      agentType: "anthropic",
+      model: conversation.model,
+      custom: conversation.metadata
+    };
+    if (conversation.system) {
+      const systemContent = typeof conversation.system === "string" ? conversation.system : this.extractTextContent(conversation.system);
+      turns.push({
+        index: 0,
+        role: "system",
+        content: systemContent
+      });
+    }
+    for (const msg of conversation.messages) {
+      const turn = {
+        index: turns.length,
+        role: msg.role,
+        content: ""
+      };
+      if (typeof msg.content === "string") {
+        turn.content = msg.content;
+      } else if (Array.isArray(msg.content)) {
+        const textParts = [];
+        const toolCalls = [];
+        const toolResults = [];
+        for (const block of msg.content) {
+          switch (block.type) {
+            case "text":
+              textParts.push(block.text);
+              break;
+            case "tool_use": {
+              const toolCall = {
+                callId: block.id,
+                name: block.name,
+                input: block.input
+              };
+              toolCalls.push(toolCall);
+              pendingToolCalls.set(block.id, toolCall);
+              break;
+            }
+            case "tool_result": {
+              const pendingCall = pendingToolCalls.get(block.tool_use_id);
+              const resultContent = typeof block.content === "string" ? block.content : this.extractTextContent(block.content);
+              toolResults.push({
+                callId: block.tool_use_id,
+                name: pendingCall?.name || "unknown",
+                output: resultContent,
+                success: !block.is_error,
+                error: block.is_error ? resultContent : void 0
+              });
+              break;
+            }
+          }
+        }
+        turn.content = textParts.join("\n");
+        if (toolCalls.length > 0) {
+          turn.toolCalls = toolCalls;
+        }
+        if (toolResults.length > 0) {
+          turn.toolResults = toolResults;
+        }
+      }
+      turns.push(turn);
+    }
+    return {
+      sessionId: conversation.id || this.generateSessionId(),
+      startedAt: /* @__PURE__ */ new Date(),
+      turns,
+      metadata
+    };
+  }
+  extractTextContent(blocks) {
+    return blocks.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+  }
+};
+var anthropicAdapter = new AnthropicAdapter();
+
+// src/adapters/generic.ts
+var DEFAULT_CONFIG = {
+  messagesPath: "messages",
+  roleField: "role",
+  contentField: "content",
+  roleMapping: {
+    user: "user",
+    assistant: "assistant",
+    system: "system",
+    tool: "tool",
+    human: "user",
+    ai: "assistant",
+    bot: "assistant"
+  },
+  timestampField: "timestamp",
+  sessionIdField: "id",
+  toolCallsPath: "tool_calls",
+  toolCallFields: {
+    name: "name",
+    input: "arguments",
+    id: "id"
+  },
+  metadataPath: "metadata"
+};
+var GenericAdapter = class extends BaseSessionAdapter {
+  constructor(config = {}) {
+    super();
+    this.name = "generic";
+    this.supportedExtensions = [".json", ".jsonl"];
+    this.config = {
+      ...DEFAULT_CONFIG,
+      ...config,
+      roleMapping: { ...DEFAULT_CONFIG.roleMapping, ...config.roleMapping },
+      toolCallFields: { ...DEFAULT_CONFIG.toolCallFields, ...config.toolCallFields }
+    };
+  }
+  /**
+   * Update configuration
+   */
+  setConfig(config) {
+    this.config = {
+      ...this.config,
+      ...config,
+      roleMapping: { ...this.config.roleMapping, ...config.roleMapping },
+      toolCallFields: { ...this.config.toolCallFields, ...config.toolCallFields }
+    };
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  canHandle(input) {
+    const str = typeof input === "string" ? input : input.toString("utf-8");
+    try {
+      const parsed = JSON.parse(str);
+      return this.canExtractMessages(parsed);
+    } catch {
+      const firstLine = str.split("\n")[0]?.trim();
+      if (!firstLine) return false;
+      try {
+        const parsed = JSON.parse(firstLine);
+        return this.looksLikeMessage(parsed);
+      } catch {
+        return false;
+      }
+    }
+  }
+  async parse(input) {
+    const str = typeof input === "string" ? input : input.toString("utf-8");
+    try {
+      const parsed = JSON.parse(str);
+      return this.convertToTrajectory(parsed);
+    } catch {
+      const lines = str.split("\n").filter((l) => l.trim());
+      const messages = [];
+      for (const line of lines) {
+        try {
+          messages.push(JSON.parse(line));
+        } catch {
+        }
+      }
+      return this.convertToTrajectory({ messages });
+    }
+  }
+  async parseMany(input) {
+    const sections = input.split(/\n\n+/);
+    const trajectories = [];
+    for (const section of sections) {
+      if (section.trim()) {
+        try {
+          trajectories.push(await this.parse(section));
+        } catch {
+        }
+      }
+    }
+    return trajectories.length > 0 ? trajectories : [await this.parse(input)];
+  }
+  canExtractMessages(obj) {
+    if (!obj || typeof obj !== "object") return false;
+    const messages = this.getNestedValue(obj, this.config.messagesPath);
+    if (Array.isArray(messages) && messages.length > 0) {
+      return this.looksLikeMessage(messages[0]);
+    }
+    if (Array.isArray(obj) && obj.length > 0) {
+      return this.looksLikeMessage(obj[0]);
+    }
+    return false;
+  }
+  looksLikeMessage(obj) {
+    if (!obj || typeof obj !== "object") return false;
+    const record = obj;
+    const role = record[this.config.roleField];
+    if (role === void 0) return false;
+    const content = record[this.config.contentField];
+    if (content === void 0) return false;
+    return true;
+  }
+  convertToTrajectory(data) {
+    const obj = data;
+    let messages;
+    const messagesFromPath = this.getNestedValue(obj, this.config.messagesPath);
+    if (Array.isArray(messagesFromPath)) {
+      messages = messagesFromPath;
+    } else if (Array.isArray(data)) {
+      messages = data;
+    } else {
+      throw new Error("Could not find messages array");
+    }
+    const sessionId = this.getNestedValue(obj, this.config.sessionIdField) || this.generateSessionId();
+    const customMetadata = this.getNestedValue(obj, this.config.metadataPath);
+    const metadata = {
+      agentType: "generic",
+      custom: customMetadata
+    };
+    const turns = [];
+    for (const msg of messages) {
+      const turn = this.convertMessageToTurn(msg, turns.length);
+      if (turn) {
+        turns.push(turn);
+      }
+    }
+    return {
+      sessionId,
+      startedAt: this.extractTimestamp(messages[0]) || /* @__PURE__ */ new Date(),
+      endedAt: this.extractTimestamp(messages[messages.length - 1]),
+      turns,
+      metadata
+    };
+  }
+  convertMessageToTurn(msg, index) {
+    const rawRole = msg[this.config.roleField];
+    if (rawRole === void 0) return null;
+    const role = this.mapRole(String(rawRole));
+    let content = "";
+    const rawContent = msg[this.config.contentField];
+    if (typeof rawContent === "string") {
+      content = rawContent;
+    } else if (rawContent !== null && rawContent !== void 0) {
+      content = JSON.stringify(rawContent);
+    }
+    const turn = {
+      index,
+      role,
+      content,
+      timestamp: this.extractTimestamp(msg)
+    };
+    const toolCallsData = this.getNestedValue(msg, this.config.toolCallsPath);
+    if (Array.isArray(toolCallsData) && toolCallsData.length > 0) {
+      turn.toolCalls = toolCallsData.map(
+        (tc) => this.convertToolCall(tc)
+      );
+    }
+    if (this.config.customExtractors) {
+      for (const [key, extractor] of Object.entries(this.config.customExtractors)) {
+        try {
+          const value = extractor(msg);
+          if (value !== void 0) {
+            turn[key] = value;
+          }
+        } catch {
+        }
+      }
+    }
+    return turn;
+  }
+  convertToolCall(tc) {
+    const fields = this.config.toolCallFields;
+    let input = {};
+    const rawInput = tc[fields.input || "arguments"];
+    if (typeof rawInput === "string") {
+      try {
+        input = JSON.parse(rawInput);
+      } catch {
+        input = { raw: rawInput };
+      }
+    } else if (rawInput && typeof rawInput === "object") {
+      input = rawInput;
+    }
+    return {
+      callId: tc[fields.id || "id"],
+      name: tc[fields.name || "name"] || "unknown",
+      input
+    };
+  }
+  mapRole(rawRole) {
+    const normalized = rawRole.toLowerCase();
+    return this.config.roleMapping[normalized] || "user";
+  }
+  extractTimestamp(msg) {
+    if (!msg || typeof msg !== "object") return void 0;
+    const record = msg;
+    const tsValue = record[this.config.timestampField];
+    if (!tsValue) return void 0;
+    if (typeof tsValue === "number") {
+      return new Date(tsValue > 1e12 ? tsValue : tsValue * 1e3);
+    }
+    if (typeof tsValue === "string") {
+      const parsed = new Date(tsValue);
+      return isNaN(parsed.getTime()) ? void 0 : parsed;
+    }
+    return void 0;
+  }
+  getNestedValue(obj, path2) {
+    if (!obj || typeof obj !== "object") return void 0;
+    const parts = path2.split(".");
+    let current = obj;
+    for (const part of parts) {
+      if (current === null || current === void 0) return void 0;
+      if (typeof current !== "object") return void 0;
+      current = current[part];
+    }
+    return current;
+  }
+};
+function createGenericAdapter(config) {
+  return new GenericAdapter(config);
+}
+var genericAdapter = new GenericAdapter();
+
+// src/adapters/index.ts
+adapterRegistry.register(claudeCodeAdapter);
+adapterRegistry.register(openAIAdapter);
+adapterRegistry.register(anthropicAdapter);
+adapterRegistry.register(genericAdapter);
+
+// 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,
+  OpenAIAdapter,
+  openAIAdapter,
+  AnthropicAdapter,
+  anthropicAdapter,
+  GenericAdapter,
+  createGenericAdapter,
+  genericAdapter,
+  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
+};