skill-tree 0.1.2 → 0.1.3

package/dist/cli/index.js

@@ -712,11 +712,76 @@ var LoadoutCompiler = class {
 // src/serving/project-detector.ts
 var import_fs = require("fs");
 var import_path = require("path");
-var _ProjectDetector = class _ProjectDetector {
+var ProjectDetector = class _ProjectDetector {
   constructor() {
     /** Cache for project context */
     this.cache = /* @__PURE__ */ new Map();
   }
+  static {
+    /** Project type patterns */
+    this.PROJECT_TYPES = [
+      { manifestFile: "package.json", type: "nodejs", tags: ["nodejs", "javascript"], packageManager: "npm" },
+      { manifestFile: "pyproject.toml", type: "python", tags: ["python"], packageManager: "pip" },
+      { manifestFile: "requirements.txt", type: "python", tags: ["python"], packageManager: "pip" },
+      { manifestFile: "Cargo.toml", type: "rust", tags: ["rust"], packageManager: "cargo" },
+      { manifestFile: "go.mod", type: "go", tags: ["go", "golang"] },
+      { manifestFile: "pom.xml", type: "java", tags: ["java", "maven"], packageManager: "maven" },
+      { manifestFile: "build.gradle", type: "java", tags: ["java", "gradle"], packageManager: "gradle" },
+      { manifestFile: "build.gradle.kts", type: "kotlin", tags: ["kotlin", "gradle"], packageManager: "gradle" }
+    ];
+  }
+  static {
+    /** TypeScript detection */
+    this.TYPESCRIPT_FILES = ["tsconfig.json", "tsconfig.base.json"];
+  }
+  static {
+    /** Node.js framework patterns */
+    this.NODE_FRAMEWORKS = [
+      { name: "react", packageName: "react", tags: ["react", "frontend"] },
+      { name: "next", packageName: "next", tags: ["nextjs", "react", "fullstack"] },
+      { name: "vue", packageName: "vue", tags: ["vue", "frontend"] },
+      { name: "nuxt", packageName: "nuxt", tags: ["nuxt", "vue", "fullstack"] },
+      { name: "angular", packageName: "@angular/core", tags: ["angular", "frontend"] },
+      { name: "svelte", packageName: "svelte", tags: ["svelte", "frontend"] },
+      { name: "express", packageName: "express", tags: ["express", "backend", "api"] },
+      { name: "fastify", packageName: "fastify", tags: ["fastify", "backend", "api"] },
+      { name: "nestjs", packageName: "@nestjs/core", tags: ["nestjs", "backend", "api"] },
+      { name: "hono", packageName: "hono", tags: ["hono", "backend", "api"] },
+      { name: "prisma", packageName: "@prisma/client", tags: ["prisma", "database", "orm"] },
+      { name: "drizzle", packageName: "drizzle-orm", tags: ["drizzle", "database", "orm"] },
+      { name: "typeorm", packageName: "typeorm", tags: ["typeorm", "database", "orm"] },
+      { name: "jest", packageName: "jest", tags: ["testing", "jest"] },
+      { name: "vitest", packageName: "vitest", tags: ["testing", "vitest"] },
+      { name: "playwright", packageName: "@playwright/test", tags: ["testing", "e2e", "playwright"] },
+      { name: "cypress", packageName: "cypress", tags: ["testing", "e2e", "cypress"] }
+    ];
+  }
+  static {
+    /** Python framework patterns (from pyproject.toml or requirements.txt) */
+    this.PYTHON_FRAMEWORKS = [
+      { name: "fastapi", packageName: "fastapi", tags: ["fastapi", "backend", "api"] },
+      { name: "django", packageName: "django", tags: ["django", "backend", "fullstack"] },
+      { name: "flask", packageName: "flask", tags: ["flask", "backend", "api"] },
+      { name: "sqlalchemy", packageName: "sqlalchemy", tags: ["sqlalchemy", "database", "orm"] },
+      { name: "pytest", packageName: "pytest", tags: ["testing", "pytest"] },
+      { name: "pydantic", packageName: "pydantic", tags: ["pydantic", "validation"] }
+    ];
+  }
+  static {
+    /** Directory patterns */
+    this.DIRECTORY_PATTERNS = [
+      { pattern: ".github/workflows", feature: "github-actions", tags: ["ci", "github-actions"] },
+      { pattern: ".gitlab-ci.yml", feature: "gitlab-ci", tags: ["ci", "gitlab"] },
+      { pattern: "Dockerfile", feature: "docker", tags: ["docker", "containers"] },
+      { pattern: "docker-compose.yml", feature: "docker-compose", tags: ["docker", "containers"] },
+      { pattern: "docker-compose.yaml", feature: "docker-compose", tags: ["docker", "containers"] },
+      { pattern: "terraform", feature: "terraform", tags: ["terraform", "infrastructure"] },
+      { pattern: "kubernetes", feature: "kubernetes", tags: ["kubernetes", "infrastructure"] },
+      { pattern: "k8s", feature: "kubernetes", tags: ["kubernetes", "infrastructure"] },
+      { pattern: ".env.example", feature: "env-config", tags: ["configuration"] },
+      { pattern: "prisma/schema.prisma", feature: "prisma", tags: ["prisma", "database"] }
+    ];
+  }
   /**
    * Detect project context from a directory
    */
@@ -878,62 +943,6 @@ var _ProjectDetector = class _ProjectDetector {
     }
   }
 };
-/** Project type patterns */
-_ProjectDetector.PROJECT_TYPES = [
-  { manifestFile: "package.json", type: "nodejs", tags: ["nodejs", "javascript"], packageManager: "npm" },
-  { manifestFile: "pyproject.toml", type: "python", tags: ["python"], packageManager: "pip" },
-  { manifestFile: "requirements.txt", type: "python", tags: ["python"], packageManager: "pip" },
-  { manifestFile: "Cargo.toml", type: "rust", tags: ["rust"], packageManager: "cargo" },
-  { manifestFile: "go.mod", type: "go", tags: ["go", "golang"] },
-  { manifestFile: "pom.xml", type: "java", tags: ["java", "maven"], packageManager: "maven" },
-  { manifestFile: "build.gradle", type: "java", tags: ["java", "gradle"], packageManager: "gradle" },
-  { manifestFile: "build.gradle.kts", type: "kotlin", tags: ["kotlin", "gradle"], packageManager: "gradle" }
-];
-/** TypeScript detection */
-_ProjectDetector.TYPESCRIPT_FILES = ["tsconfig.json", "tsconfig.base.json"];
-/** Node.js framework patterns */
-_ProjectDetector.NODE_FRAMEWORKS = [
-  { name: "react", packageName: "react", tags: ["react", "frontend"] },
-  { name: "next", packageName: "next", tags: ["nextjs", "react", "fullstack"] },
-  { name: "vue", packageName: "vue", tags: ["vue", "frontend"] },
-  { name: "nuxt", packageName: "nuxt", tags: ["nuxt", "vue", "fullstack"] },
-  { name: "angular", packageName: "@angular/core", tags: ["angular", "frontend"] },
-  { name: "svelte", packageName: "svelte", tags: ["svelte", "frontend"] },
-  { name: "express", packageName: "express", tags: ["express", "backend", "api"] },
-  { name: "fastify", packageName: "fastify", tags: ["fastify", "backend", "api"] },
-  { name: "nestjs", packageName: "@nestjs/core", tags: ["nestjs", "backend", "api"] },
-  { name: "hono", packageName: "hono", tags: ["hono", "backend", "api"] },
-  { name: "prisma", packageName: "@prisma/client", tags: ["prisma", "database", "orm"] },
-  { name: "drizzle", packageName: "drizzle-orm", tags: ["drizzle", "database", "orm"] },
-  { name: "typeorm", packageName: "typeorm", tags: ["typeorm", "database", "orm"] },
-  { name: "jest", packageName: "jest", tags: ["testing", "jest"] },
-  { name: "vitest", packageName: "vitest", tags: ["testing", "vitest"] },
-  { name: "playwright", packageName: "@playwright/test", tags: ["testing", "e2e", "playwright"] },
-  { name: "cypress", packageName: "cypress", tags: ["testing", "e2e", "cypress"] }
-];
-/** Python framework patterns (from pyproject.toml or requirements.txt) */
-_ProjectDetector.PYTHON_FRAMEWORKS = [
-  { name: "fastapi", packageName: "fastapi", tags: ["fastapi", "backend", "api"] },
-  { name: "django", packageName: "django", tags: ["django", "backend", "fullstack"] },
-  { name: "flask", packageName: "flask", tags: ["flask", "backend", "api"] },
-  { name: "sqlalchemy", packageName: "sqlalchemy", tags: ["sqlalchemy", "database", "orm"] },
-  { name: "pytest", packageName: "pytest", tags: ["testing", "pytest"] },
-  { name: "pydantic", packageName: "pydantic", tags: ["pydantic", "validation"] }
-];
-/** Directory patterns */
-_ProjectDetector.DIRECTORY_PATTERNS = [
-  { pattern: ".github/workflows", feature: "github-actions", tags: ["ci", "github-actions"] },
-  { pattern: ".gitlab-ci.yml", feature: "gitlab-ci", tags: ["ci", "gitlab"] },
-  { pattern: "Dockerfile", feature: "docker", tags: ["docker", "containers"] },
-  { pattern: "docker-compose.yml", feature: "docker-compose", tags: ["docker", "containers"] },
-  { pattern: "docker-compose.yaml", feature: "docker-compose", tags: ["docker", "containers"] },
-  { pattern: "terraform", feature: "terraform", tags: ["terraform", "infrastructure"] },
-  { pattern: "kubernetes", feature: "kubernetes", tags: ["kubernetes", "infrastructure"] },
-  { pattern: "k8s", feature: "kubernetes", tags: ["kubernetes", "infrastructure"] },
-  { pattern: ".env.example", feature: "env-config", tags: ["configuration"] },
-  { pattern: "prisma/schema.prisma", feature: "prisma", tags: ["prisma", "database"] }
-];
-var ProjectDetector = _ProjectDetector;
 
 // src/serving/view-renderer.ts
 var DEFAULT_CONFIG2 = {
@@ -6227,10 +6236,7 @@ var MemoryStorageAdapter = class extends BaseStorageAdapter {
     this.skills = /* @__PURE__ */ new Map();
     // skillId -> version -> skill
     this.lineages = /* @__PURE__ */ new Map();
-    this.candidates = /* @__PURE__ */ new Map();
-    this.antiPatterns = /* @__PURE__ */ new Map();
   }
-  // skillId -> patterns
   async initialize() {
     this.initialized = true;
   }
@@ -6361,78 +6367,6 @@ var MemoryStorageAdapter = class extends BaseStorageAdapter {
   clear() {
     this.skills.clear();
     this.lineages.clear();
-    this.candidates.clear();
-    this.antiPatterns.clear();
-  }
-  // ==========================================================================
-  // Learning Candidate Operations
-  // ==========================================================================
-  async saveCandidate(candidate) {
-    this.ensureInitialized();
-    this.candidates.set(candidate.id, { ...candidate });
-  }
-  async getCandidate(id) {
-    this.ensureInitialized();
-    return this.candidates.get(id) || null;
-  }
-  async listCandidates(filter) {
-    this.ensureInitialized();
-    let results = Array.from(this.candidates.values());
-    if (filter) {
-      if (filter.kind && filter.kind.length > 0) {
-        results = results.filter((c) => filter.kind.includes(c.kind));
-      }
-      if (filter.status && filter.status.length > 0) {
-        results = results.filter((c) => filter.status.includes(c.status));
-      }
-      if (filter.minConfidence !== void 0) {
-        results = results.filter((c) => c.confidence >= filter.minConfidence);
-      }
-      if (filter.createdAfter) {
-        results = results.filter((c) => c.createdAt >= filter.createdAfter);
-      }
-      if (filter.createdBefore) {
-        results = results.filter((c) => c.createdAt <= filter.createdBefore);
-      }
-    }
-    return results;
-  }
-  async updateCandidateStatus(id, status, details) {
-    this.ensureInitialized();
-    const candidate = this.candidates.get(id);
-    if (!candidate) return false;
-    candidate.status = status;
-    candidate.updatedAt = /* @__PURE__ */ new Date();
-    if (details?.promotedToSkillId) {
-      candidate.promotedToSkillId = details.promotedToSkillId;
-    }
-    if (details?.rejectionReason) {
-      candidate.rejectionReason = details.rejectionReason;
-    }
-    return true;
-  }
-  async deleteCandidate(id) {
-    this.ensureInitialized();
-    return this.candidates.delete(id);
-  }
-  // ==========================================================================
-  // Anti-Pattern Operations
-  // ==========================================================================
-  async saveAntiPatterns(skillId, patterns) {
-    this.ensureInitialized();
-    this.antiPatterns.set(skillId, [...patterns]);
-  }
-  async getAntiPatterns(skillId) {
-    this.ensureInitialized();
-    return this.antiPatterns.get(skillId) || [];
-  }
-  async listAntiPatterns() {
-    this.ensureInitialized();
-    const results = [];
-    for (const [skillId, patterns] of this.antiPatterns) {
-      results.push({ skillId, patterns });
-    }
-    return results;
   }
   // ==========================================================================
   // Fork Tracking
@@ -6983,152 +6917,6 @@ ${body}`;
     return Math.abs(hash).toString(16);
   }
   // ==========================================================================
-  // Learning Candidate Operations
-  // ==========================================================================
-  get candidatesDir() {
-    return path4.join(this.skilltreeDir, "candidates");
-  }
-  get antiPatternsDir() {
-    return path4.join(this.skilltreeDir, "anti-patterns");
-  }
-  async saveCandidate(candidate) {
-    this.ensureInitialized();
-    await fs4.mkdir(this.candidatesDir, { recursive: true });
-    const candidatePath = path4.join(this.candidatesDir, `${candidate.id}.json`);
-    await fs4.writeFile(candidatePath, JSON.stringify(candidate, null, 2), "utf-8");
-  }
-  async getCandidate(id) {
-    this.ensureInitialized();
-    const candidatePath = path4.join(this.candidatesDir, `${id}.json`);
-    try {
-      const content = await fs4.readFile(candidatePath, "utf-8");
-      const candidate = JSON.parse(content);
-      candidate.createdAt = new Date(candidate.createdAt);
-      candidate.updatedAt = new Date(candidate.updatedAt);
-      candidate.source.extractedAt = new Date(candidate.source.extractedAt);
-      return candidate;
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        return null;
-      }
-      throw error;
-    }
-  }
-  async listCandidates(filter) {
-    this.ensureInitialized();
-    try {
-      const files = await fs4.readdir(this.candidatesDir);
-      const candidates = [];
-      for (const file of files) {
-        if (!file.endsWith(".json")) continue;
-        const id = file.replace(".json", "");
-        const candidate = await this.getCandidate(id);
-        if (candidate) {
-          candidates.push(candidate);
-        }
-      }
-      let results = candidates;
-      if (filter) {
-        if (filter.kind && filter.kind.length > 0) {
-          results = results.filter((c) => filter.kind.includes(c.kind));
-        }
-        if (filter.status && filter.status.length > 0) {
-          results = results.filter((c) => filter.status.includes(c.status));
-        }
-        if (filter.minConfidence !== void 0) {
-          results = results.filter((c) => c.confidence >= filter.minConfidence);
-        }
-        if (filter.createdAfter) {
-          results = results.filter((c) => c.createdAt >= filter.createdAfter);
-        }
-        if (filter.createdBefore) {
-          results = results.filter((c) => c.createdAt <= filter.createdBefore);
-        }
-      }
-      return results;
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        return [];
-      }
-      throw error;
-    }
-  }
-  async updateCandidateStatus(id, status, details) {
-    this.ensureInitialized();
-    const candidate = await this.getCandidate(id);
-    if (!candidate) return false;
-    candidate.status = status;
-    candidate.updatedAt = /* @__PURE__ */ new Date();
-    if (details?.promotedToSkillId) {
-      candidate.promotedToSkillId = details.promotedToSkillId;
-    }
-    if (details?.rejectionReason) {
-      candidate.rejectionReason = details.rejectionReason;
-    }
-    await this.saveCandidate(candidate);
-    return true;
-  }
-  async deleteCandidate(id) {
-    this.ensureInitialized();
-    const candidatePath = path4.join(this.candidatesDir, `${id}.json`);
-    try {
-      await fs4.unlink(candidatePath);
-      return true;
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        return false;
-      }
-      throw error;
-    }
-  }
-  // ==========================================================================
-  // Anti-Pattern Operations
-  // ==========================================================================
-  async saveAntiPatterns(skillId, patterns) {
-    this.ensureInitialized();
-    await fs4.mkdir(this.antiPatternsDir, { recursive: true });
-    const patternPath = path4.join(this.antiPatternsDir, `${skillId}.json`);
-    await fs4.writeFile(patternPath, JSON.stringify(patterns, null, 2), "utf-8");
-  }
-  async getAntiPatterns(skillId) {
-    this.ensureInitialized();
-    const patternPath = path4.join(this.antiPatternsDir, `${skillId}.json`);
-    try {
-      const content = await fs4.readFile(patternPath, "utf-8");
-      const patterns = JSON.parse(content);
-      for (const pattern of patterns) {
-        pattern.learnedAt = new Date(pattern.learnedAt);
-      }
-      return patterns;
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        return [];
-      }
-      throw error;
-    }
-  }
-  async listAntiPatterns() {
-    this.ensureInitialized();
-    try {
-      const files = await fs4.readdir(this.antiPatternsDir);
-      const results = [];
-      for (const file of files) {
-        if (!file.endsWith(".json")) continue;
-        const skillId = file.replace(".json", "");
-        const patterns = await this.getAntiPatterns(skillId);
-        if (patterns.length > 0) {
-          results.push({ skillId, patterns });
-        }
-      }
-      return results;
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        return [];
-      }
-      throw error;
-    }
-  }
-  // ==========================================================================
   // Fork Tracking
   // ==========================================================================
   async recordFork(sourceSkillId, fork) {
@@ -7455,310 +7243,6 @@ ${source}`;
   }
 };
 
-// src/learning/providers/naive.ts
-var NaiveLearningProvider = class {
-  constructor(config2) {
-    this.name = "naive";
-    this.description = "Built-in extraction using heuristics and optional LLM analysis";
-    this.capabilities = {
-      accumulating: false,
-      feedbackEnabled: false,
-      persistent: false,
-      supportedKinds: ["skill", "strategy", "pattern", "error-fix"]
-    };
-    this.config = {
-      llmProvider: config2?.llmProvider ?? null,
-      minConfidence: config2?.minConfidence ?? 0.6,
-      runQualityGates: config2?.runQualityGates ?? true,
-      creditStrategy: config2?.creditStrategy ?? "simple"
-    };
-    this.manualExtractor = new ManualExtractor();
-    this.automaticExtractor = new AutomaticExtractor({
-      llmProvider: this.config.llmProvider || void 0,
-      minConfidence: this.config.minConfidence
-    });
-  }
-  /**
-   * Set or update the LLM provider
-   */
-  setLLMProvider(provider) {
-    this.config.llmProvider = provider;
-    this.automaticExtractor.setLLMProvider(provider);
-  }
-  /**
-   * Analyze a trajectory and extract learning candidates
-   */
-  async analyze(trajectory, options) {
-    const startTime = Date.now();
-    const candidates = [];
-    const kinds = options?.kinds ?? ["skill"];
-    const useAutomatic = this.config.llmProvider != null;
-    let results;
-    if (useAutomatic) {
-      results = await this.automaticExtractor.extract(trajectory, {
-        turnRange: options?.turnRange,
-        minConfidence: options?.minConfidence ?? this.config.minConfidence,
-        skipValidation: options?.skipValidation ?? !this.config.runQualityGates,
-        context: options?.context
-      });
-    } else {
-      results = await this.manualExtractor.extract(trajectory, {
-        turnRange: options?.turnRange,
-        skipValidation: options?.skipValidation ?? !this.config.runQualityGates,
-        context: options?.context
-      });
-    }
-    for (const result of results) {
-      if (!result.success || !result.skill) continue;
-      const kind = this.inferKind(result.skill);
-      if (!kinds.includes(kind)) continue;
-      const candidate = this.extractionResultToCandidate(result, trajectory);
-      candidates.push(candidate);
-    }
-    return {
-      candidates,
-      // Naive provider doesn't produce updates, demotions, or anti-patterns
-      metadata: {
-        trajectoriesAnalyzed: 1,
-        durationMs: Date.now() - startTime
-      }
-    };
-  }
-  /**
-   * Batch analysis - runs individual analysis on each trajectory.
-   * A more sophisticated provider could do cross-trajectory pattern detection.
-   */
-  async analyzeBatch(trajectories, options) {
-    const startTime = Date.now();
-    const allCandidates = [];
-    for (const trajectory of trajectories) {
-      const result = await this.analyze(trajectory, options);
-      allCandidates.push(...result.candidates);
-    }
-    const deduplicated = this.deduplicateCandidates(allCandidates);
-    return {
-      candidates: deduplicated,
-      metadata: {
-        trajectoriesAnalyzed: trajectories.length,
-        durationMs: Date.now() - startTime
-      }
-    };
-  }
-  /**
-   * Check if a candidate is a duplicate based on name/content similarity
-   */
-  isDuplicate(candidate, existing) {
-    if (existing.some((e) => e.id === candidate.id)) {
-      return true;
-    }
-    const normalizedName = this.normalizeName(candidate.name);
-    for (const e of existing) {
-      if (this.normalizeName(e.name) === normalizedName) {
-        return true;
-      }
-    }
-    return false;
-  }
-  /**
-   * Compute similarity between two candidates (basic implementation)
-   */
-  computeSimilarity(a, b) {
-    if (a.kind !== b.kind) return 0.1;
-    const nameA = this.normalizeName(a.name);
-    const nameB = this.normalizeName(b.name);
-    const nameSimilarity = this.jaccardSimilarity(
-      nameA.split("-"),
-      nameB.split("-")
-    );
-    let contentSimilarity = 0;
-    if (a.content.kind === "skill" && b.content.kind === "skill") {
-      const aWords = this.tokenize(a.content.problem + " " + a.content.solution);
-      const bWords = this.tokenize(b.content.problem + " " + b.content.solution);
-      contentSimilarity = this.jaccardSimilarity(aWords, bWords);
-    }
-    return nameSimilarity * 0.3 + contentSimilarity * 0.7;
-  }
-  // ==========================================================================
-  // Private Methods
-  // ==========================================================================
-  /**
-   * Convert an ExtractionResult to a LearningCandidate
-   */
-  extractionResultToCandidate(result, trajectory) {
-    const skill = result.skill;
-    const turnRange = result.sourceTrajectory.turnRange;
-    return {
-      kind: this.inferKind(skill),
-      id: skill.id,
-      name: skill.name,
-      content: this.skillToContent(skill),
-      confidence: result.confidence,
-      attribution: this.computeAttribution(trajectory, turnRange),
-      source: {
-        provider: this.name,
-        trajectoryId: trajectory.sessionId,
-        turnRange,
-        extractedAt: /* @__PURE__ */ new Date(),
-        metadata: {
-          gateResults: result.gateResults,
-          extractionMode: this.config.llmProvider ? "automatic" : "manual"
-        }
-      },
-      tags: skill.tags,
-      reasoning: result.failureReason
-    };
-  }
-  /**
-   * Convert a Skill to LearningContent
-   */
-  skillToContent(skill) {
-    return {
-      kind: "skill",
-      problem: skill.problem,
-      solution: skill.solution,
-      verification: skill.verification,
-      triggers: skill.triggerConditions.map(
-        (t) => ({
-          type: t.type,
-          value: t.value,
-          description: t.description
-        })
-      ),
-      examples: skill.examples.map(
-        (e) => ({
-          scenario: e.scenario,
-          before: e.before,
-          after: e.after
-        })
-      )
-    };
-  }
-  /**
-   * Infer the kind of learning from a skill
-   */
-  inferKind(skill) {
-    const hasErrorTriggers = skill.triggerConditions.some(
-      (t) => t.type === "error"
-    );
-    if (hasErrorTriggers && skill.problem.toLowerCase().includes("error")) {
-      return "error-fix";
-    }
-    if (skill.solution.toLowerCase().includes("approach") || skill.solution.toLowerCase().includes("strategy") || skill.solution.toLowerCase().includes("when you see")) {
-      return "strategy";
-    }
-    return "skill";
-  }
-  /**
-   * Compute step attribution using the configured strategy
-   */
-  computeAttribution(trajectory, turnRange) {
-    const [start, end] = turnRange;
-    const turns = trajectory.turns.slice(start, end + 1);
-    switch (this.config.creditStrategy) {
-      case "simple":
-        return this.simpleCredit(turns, start);
-      case "uniform":
-        return this.uniformCredit(turns, start);
-      case "llm":
-        return this.simpleCredit(turns, start);
-      default:
-        return this.simpleCredit(turns, start);
-    }
-  }
-  /**
-   * Simple credit assignment: exponential decay from end.
-   * Last step gets most credit, earlier steps get less.
-   */
-  simpleCredit(turns, startOffset) {
-    const attributions = [];
-    const n = turns.length;
-    for (let i = 0; i < n; i++) {
-      const turn = turns[i];
-      if (turn.role === "system") continue;
-      const distanceFromEnd = n - 1 - i;
-      const score = Math.pow(0.7, distanceFromEnd);
-      const hasToolCalls = turn.toolCalls && turn.toolCalls.length > 0;
-      const boostedScore = hasToolCalls ? Math.min(1, score * 1.3) : score;
-      attributions.push({
-        turnIndex: startOffset + i,
-        score: Math.round(boostedScore * 100) / 100,
-        reasoning: this.getAttributionReasoning(turn, boostedScore)
-      });
-    }
-    return attributions;
-  }
-  /**
-   * Uniform credit assignment: all steps get equal credit.
-   */
-  uniformCredit(turns, startOffset) {
-    const nonSystemTurns = turns.filter((t) => t.role !== "system");
-    const score = 1 / nonSystemTurns.length;
-    return turns.map((turn, i) => {
-      if (turn.role === "system") return null;
-      return {
-        turnIndex: startOffset + i,
-        score: Math.round(score * 100) / 100
-      };
-    }).filter((a) => a !== null);
-  }
-  /**
-   * Generate reasoning for attribution
-   */
-  getAttributionReasoning(turn, score) {
-    const reasons = [];
-    if (score >= 0.8) {
-      reasons.push("High impact (near end of solution)");
-    } else if (score >= 0.5) {
-      reasons.push("Medium impact");
-    } else {
-      reasons.push("Lower impact (early in trajectory)");
-    }
-    if (turn.toolCalls && turn.toolCalls.length > 0) {
-      const toolNames = turn.toolCalls.map((t) => t.name).join(", ");
-      reasons.push(`Used tools: ${toolNames}`);
-    }
-    if (turn.toolResults?.some((r) => !r.success)) {
-      reasons.push("Encountered and handled errors");
-    }
-    return reasons.join(". ");
-  }
-  /**
-   * Deduplicate candidates by ID
-   */
-  deduplicateCandidates(candidates) {
-    const seen = /* @__PURE__ */ new Map();
-    for (const candidate of candidates) {
-      const existing = seen.get(candidate.id);
-      if (!existing || candidate.confidence > existing.confidence) {
-        seen.set(candidate.id, candidate);
-      }
-    }
-    return Array.from(seen.values());
-  }
-  /**
-   * Normalize a name for comparison
-   */
-  normalizeName(name) {
-    return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-  }
-  /**
-   * Tokenize text into words
-   */
-  tokenize(text) {
-    return text.toLowerCase().split(/\W+/).filter((w) => w.length > 2);
-  }
-  /**
-   * Compute Jaccard similarity between two arrays
-   */
-  jaccardSimilarity(a, b) {
-    const setA = new Set(a);
-    const setB = new Set(b);
-    const intersection = new Set([...setA].filter((x) => setB.has(x)));
-    const union = /* @__PURE__ */ new Set([...setA, ...setB]);
-    return union.size === 0 ? 0 : intersection.size / union.size;
-  }
-};
-
 // src/hooks/registry.ts
 var import_crypto = require("crypto");
 var PRIORITY_ORDER = {
@@ -8228,10 +7712,6 @@ var SkillBank = class {
     this.eventHandlers = [];
     this.initialized = false;
     this.autoIndexOnInit = false;
-    /** Learning providers for meta-learning integration */
-    this.learningProviders = /* @__PURE__ */ new Map();
-    /** Anti-patterns stored separately as metadata */
-    this.antiPatterns = /* @__PURE__ */ new Map();
     /** Validation mode: advisory (non-blocking) or blocking */
     this.validationMode = "advisory";
     /** Whether validation is enabled */
@@ -8269,11 +7749,6 @@ var SkillBank = class {
       similarityThreshold: config2.matching?.similarityThreshold
     });
     this.autoIndexOnInit = config2.matching?.autoIndex ?? false;
-    const naiveProvider = new NaiveLearningProvider({
-      llmProvider: config2.llmProvider,
-      minConfidence: config2.minExtractionConfidence
-    });
-    this.learningProviders.set(naiveProvider.name, naiveProvider);
     if (config2.namespace) {
       this.namespaceConfig = {
         agentId: config2.namespace.agentId,
@@ -8301,11 +7776,6 @@ var SkillBank = class {
    */
   async initialize() {
     await this.storage.initialize();
-    for (const provider of this.learningProviders.values()) {
-      if (provider.initialize) {
-        await provider.initialize();
-      }
-    }
     if (this.validator) {
       this.validator.setStorage(this.storage);
     }
@@ -8318,11 +7788,6 @@ var SkillBank = class {
    * Shutdown the skill bank cleanly
    */
   async shutdown() {
-    for (const provider of this.learningProviders.values()) {
-      if (provider.shutdown) {
-        await provider.shutdown();
-      }
-    }
   }
   /**
    * Ensure initialized before operations
@@ -8480,569 +7945,6 @@ var SkillBank = class {
    */
   setLLMProvider(provider) {
     this.automaticExtractor.setLLMProvider(provider);
-    const naiveProvider = this.learningProviders.get("naive");
-    if (naiveProvider && "setLLMProvider" in naiveProvider) {
-      naiveProvider.setLLMProvider(provider);
-    }
-  }
-  // ==========================================================================
-  // Learning Providers (Meta-learning Integration)
-  // ==========================================================================
-  /**
-   * Register a learning provider.
-   * Learning providers analyze trajectories and produce learning candidates.
-   * Use this to integrate external learning engines like cognitive-core.
-   */
-  async registerLearningProvider(provider) {
-    if (provider.initialize) {
-      await provider.initialize();
-    }
-    this.learningProviders.set(provider.name, provider);
-  }
-  /**
-   * Get a registered learning provider by name
-   */
-  getLearningProvider(name) {
-    return this.learningProviders.get(name);
-  }
-  /**
-   * List all registered learning providers
-   */
-  listLearningProviders() {
-    return Array.from(this.learningProviders.values());
-  }
-  /**
-   * Learn from a trajectory using a learning provider.
-   * This is the primary integration point for meta-learning engines.
-   *
-   * For accumulating providers, this may not return immediate results.
-   * Use flushProviders() to force extraction from accumulated trajectories.
-   */
-  async learnFrom(trajectory, options) {
-    this.ensureInitialized();
-    const providerName = options?.provider ?? "naive";
-    const provider = this.learningProviders.get(providerName);
-    if (!provider) {
-      throw new Error(
-        `Learning provider not found: ${providerName}. Available: ${Array.from(this.learningProviders.keys()).join(", ")}`
-      );
-    }
-    const result = await provider.analyze(trajectory, options);
-    return this.processAnalyzeResult(result);
-  }
-  /**
-   * Learn from multiple trajectories.
-   * Providers that support batch analysis can find cross-trajectory patterns.
-   */
-  async learnFromBatch(trajectories, options) {
-    this.ensureInitialized();
-    const providerName = options?.provider ?? "naive";
-    const provider = this.learningProviders.get(providerName);
-    if (!provider) {
-      throw new Error(`Learning provider not found: ${providerName}`);
-    }
-    let result;
-    if (provider.analyzeBatch) {
-      result = await provider.analyzeBatch(trajectories, options);
-    } else {
-      const candidates = [];
-      const updates = [];
-      const demotions = [];
-      const antiPatterns = [];
-      let totalDuration = 0;
-      for (const trajectory of trajectories) {
-        const r = await provider.analyze(trajectory, options);
-        candidates.push(...r.candidates);
-        if (r.updates) updates.push(...r.updates);
-        if (r.demotions) demotions.push(...r.demotions);
-        if (r.antiPatterns) antiPatterns.push(...r.antiPatterns);
-        totalDuration += r.metadata.durationMs;
-      }
-      result = {
-        candidates,
-        updates: updates.length > 0 ? updates : void 0,
-        demotions: demotions.length > 0 ? demotions : void 0,
-        antiPatterns: antiPatterns.length > 0 ? antiPatterns : void 0,
-        metadata: {
-          trajectoriesAnalyzed: trajectories.length,
-          durationMs: totalDuration
-        }
-      };
-    }
-    return this.processAnalyzeResult(result);
-  }
-  /**
-   * Force extraction from all accumulating providers.
-   */
-  async flushProviders() {
-    this.ensureInitialized();
-    const mergedResult = {
-      skillsCreated: 0,
-      skillsUpdated: 0,
-      skillsDemoted: 0,
-      antiPatternsAdded: 0,
-      createdSkillIds: [],
-      updatedSkillIds: []
-    };
-    for (const provider of this.learningProviders.values()) {
-      if (provider.capabilities.accumulating && provider.flush) {
-        const result = await provider.flush();
-        const processed = await this.processAnalyzeResult(result);
-        mergedResult.skillsCreated += processed.skillsCreated;
-        mergedResult.skillsUpdated += processed.skillsUpdated;
-        mergedResult.skillsDemoted += processed.skillsDemoted;
-        mergedResult.antiPatternsAdded += processed.antiPatternsAdded;
-        mergedResult.createdSkillIds.push(...processed.createdSkillIds);
-        mergedResult.updatedSkillIds.push(...processed.updatedSkillIds);
-      }
-    }
-    return mergedResult;
-  }
-  /**
-   * Record outcome when a skill is applied.
-   * Provider updates internal state and returns updates for SkillBank.
-   */
-  async recordOutcome(feedback, providerName) {
-    this.ensureInitialized();
-    const skill = await this.storage.getSkill(feedback.candidateId);
-    if (skill) {
-      skill.metrics.usageCount++;
-      if (feedback.success) {
-        const totalUses = skill.metrics.usageCount;
-        const currentSuccesses = skill.metrics.successRate * (totalUses - 1);
-        skill.metrics.successRate = (currentSuccesses + 1) / totalUses;
-      } else {
-        const totalUses = skill.metrics.usageCount;
-        const currentSuccesses = skill.metrics.successRate * (totalUses - 1);
-        skill.metrics.successRate = currentSuccesses / totalUses;
-      }
-      skill.metrics.lastUsed = /* @__PURE__ */ new Date();
-      await this.storage.saveSkill(skill);
-    }
-    const providersToNotify = providerName ? [this.learningProviders.get(providerName)].filter(Boolean) : Array.from(this.learningProviders.values());
-    for (const provider of providersToNotify) {
-      if (provider.capabilities.feedbackEnabled && provider.recordOutcome) {
-        const result = await provider.recordOutcome(feedback);
-        if (result.updates) {
-          for (const update of result.updates) {
-            await this.applyUpdate(update);
-          }
-        }
-        if (result.antiPatterns) {
-          for (const ap of result.antiPatterns) {
-            await this.addAntiPattern(ap);
-          }
-        }
-      }
-    }
-  }
-  /**
-   * Process an AnalyzeResult: store candidates, apply updates, etc.
-   */
-  async processAnalyzeResult(result) {
-    const learnResult = {
-      skillsCreated: 0,
-      skillsUpdated: 0,
-      skillsDemoted: 0,
-      antiPatternsAdded: 0,
-      providerState: result.providerState,
-      createdSkillIds: [],
-      updatedSkillIds: []
-    };
-    for (const candidate of result.candidates) {
-      if (candidate.content.kind === "skill") {
-        const skill = await this.promoteToSkill(candidate);
-        learnResult.skillsCreated++;
-        learnResult.createdSkillIds.push(skill.id);
-      } else {
-        await this.storeCandidateForReview(candidate);
-      }
-    }
-    if (result.updates) {
-      for (const update of result.updates) {
-        const updated = await this.applyUpdate(update);
-        if (updated) {
-          learnResult.skillsUpdated++;
-          learnResult.updatedSkillIds.push(update.candidateId);
-        }
-      }
-    }
-    if (result.demotions) {
-      for (const demotion of result.demotions) {
-        await this.applyDemotion(demotion);
-        learnResult.skillsDemoted++;
-      }
-    }
-    if (result.antiPatterns) {
-      for (const ap of result.antiPatterns) {
-        await this.addAntiPattern(ap);
-        learnResult.antiPatternsAdded++;
-      }
-    }
-    return learnResult;
-  }
-  /**
-   * Store a non-skill candidate for later review
-   */
-  async storeCandidateForReview(candidate) {
-    if (!this.storage.saveCandidate) {
-      return;
-    }
-    const record = {
-      id: candidate.id,
-      kind: candidate.kind,
-      name: candidate.name,
-      content: candidate.content,
-      confidence: candidate.confidence,
-      source: {
-        trajectoryId: candidate.source.trajectoryId,
-        provider: candidate.source.provider,
-        extractedAt: candidate.source.extractedAt,
-        turnRange: candidate.source.turnRange
-      },
-      tags: candidate.tags,
-      reasoning: candidate.reasoning,
-      createdAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date(),
-      status: "pending"
-    };
-    await this.storage.saveCandidate(record);
-  }
-  /**
-   * Apply an update to an existing skill
-   */
-  async applyUpdate(update) {
-    const skill = await this.storage.getSkill(update.candidateId);
-    if (!skill) return false;
-    let modified = false;
-    if (update.addTrigger) {
-      const exists = skill.triggerConditions.some(
-        (t) => t.type === update.addTrigger.type && t.value === update.addTrigger.value
-      );
-      if (!exists) {
-        skill.triggerConditions.push({
-          type: update.addTrigger.type,
-          value: update.addTrigger.value,
-          description: update.addTrigger.description
-        });
-        modified = true;
-      }
-    }
-    if (update.refinement) {
-      const refinementNote = `[${update.refinement.source}] ${update.refinement.context}: ${update.refinement.addition}`;
-      skill.notes = skill.notes ? `${skill.notes}
-${refinementNote}` : refinementNote;
-      modified = true;
-    }
-    if (update.confidenceAdjustment) {
-      skill.metrics.successRate = Math.max(
-        0,
-        Math.min(1, skill.metrics.successRate + update.confidenceAdjustment)
-      );
-      modified = true;
-    }
-    if (update.incrementSuccess || update.incrementFailure) {
-      skill.metrics.usageCount++;
-      if (update.incrementSuccess) {
-        const total = skill.metrics.usageCount;
-        const currentSuccesses = skill.metrics.successRate * (total - 1);
-        skill.metrics.successRate = (currentSuccesses + 1) / total;
-      }
-      modified = true;
-    }
-    if (modified) {
-      skill.updatedAt = /* @__PURE__ */ new Date();
-      await this.storage.saveSkill(skill);
-      this.emit({ type: "skill:updated", skill, previousVersion: skill.version });
-    }
-    return modified;
-  }
-  /**
-   * Apply a demotion to an existing skill
-   */
-  async applyDemotion(demotion) {
-    const skill = await this.storage.getSkill(demotion.candidateId);
-    if (!skill) return;
-    skill.metrics.successRate = demotion.newConfidence;
-    if (demotion.deprecate) {
-      skill.status = "deprecated";
-      this.emit({ type: "skill:deprecated", skillId: skill.id });
-    }
-    skill.notes = skill.notes ? `${skill.notes}
-[demotion] ${demotion.reason}` : `[demotion] ${demotion.reason}`;
-    skill.updatedAt = /* @__PURE__ */ new Date();
-    await this.storage.saveSkill(skill);
-  }
-  // ==========================================================================
-  // Anti-Pattern Management
-  // ==========================================================================
-  /**
-   * Get anti-patterns for a skill
-   */
-  async getAntiPatterns(skillId) {
-    return this.antiPatterns.get(skillId) ?? [];
-  }
-  /**
-   * Add an anti-pattern
-   */
-  async addAntiPattern(antiPattern) {
-    const existing = this.antiPatterns.get(antiPattern.candidateId) ?? [];
-    existing.push(antiPattern);
-    this.antiPatterns.set(antiPattern.candidateId, existing);
-    if (this.storage.saveAntiPatterns) {
-      const records = existing.map((ap) => ({
-        id: ap.id,
-        pattern: ap.pattern,
-        description: ap.reason,
-        context: ap.discoveredFrom,
-        severity: "warning",
-        learnedAt: ap.createdAt,
-        occurrences: 1
-      }));
-      await this.storage.saveAntiPatterns(antiPattern.candidateId, records);
-    }
-  }
-  /**
-   * Remove an anti-pattern by ID
-   */
-  async removeAntiPattern(antiPatternId) {
-    for (const [skillId, patterns] of this.antiPatterns.entries()) {
-      const index = patterns.findIndex((p) => p.id === antiPatternId);
-      if (index >= 0) {
-        patterns.splice(index, 1);
-        if (patterns.length === 0) {
-          this.antiPatterns.delete(skillId);
-        }
-        return true;
-      }
-    }
-    return false;
-  }
-  // ==========================================================================
-  // Candidate Lifecycle Management
-  // ==========================================================================
-  /**
-   * List pending learning candidates for review
-   */
-  async listCandidates(filter) {
-    this.ensureInitialized();
-    if (!this.storage.listCandidates) {
-      return [];
-    }
-    return this.storage.listCandidates(filter);
-  }
-  /**
-   * Get a specific candidate by ID
-   */
-  async getCandidate(id) {
-    this.ensureInitialized();
-    if (!this.storage.getCandidate) {
-      return null;
-    }
-    return this.storage.getCandidate(id);
-  }
-  /**
-   * Promote a candidate to a skill
-   * Works for strategy, pattern, and error-fix candidates that were stored for review
-   */
-  async promoteCandidate(candidateId) {
-    this.ensureInitialized();
-    if (!this.storage.getCandidate || !this.storage.updateCandidateStatus) {
-      throw new Error("Storage does not support candidate operations");
-    }
-    const record = await this.storage.getCandidate(candidateId);
-    if (!record) return null;
-    if (record.status !== "pending") {
-      throw new Error(`Cannot promote candidate with status: ${record.status}`);
-    }
-    const candidate = {
-      id: record.id,
-      kind: record.kind,
-      name: record.name,
-      content: record.content,
-      confidence: record.confidence,
-      source: {
-        provider: record.source.provider,
-        trajectoryId: record.source.trajectoryId,
-        extractedAt: record.source.extractedAt,
-        turnRange: record.source.turnRange ?? [0, 0]
-      },
-      tags: record.tags,
-      reasoning: record.reasoning
-    };
-    const skill = await this.promoteToSkill(candidate);
-    await this.storage.updateCandidateStatus(candidateId, "promoted", {
-      promotedToSkillId: skill.id
-    });
-    return skill;
-  }
-  /**
-   * Reject a candidate with a reason
-   */
-  async rejectCandidate(candidateId, reason) {
-    this.ensureInitialized();
-    if (!this.storage.updateCandidateStatus) {
-      throw new Error("Storage does not support candidate operations");
-    }
-    return this.storage.updateCandidateStatus(candidateId, "rejected", {
-      rejectionReason: reason
-    });
-  }
-  /**
-   * Delete a candidate
-   */
-  async deleteCandidate(candidateId) {
-    this.ensureInitialized();
-    if (!this.storage.deleteCandidate) {
-      return false;
-    }
-    return this.storage.deleteCandidate(candidateId);
-  }
-  /**
-   * Find skills with anti-pattern awareness
-   */
-  async findSkillsWithAntiPatterns(query, options) {
-    this.ensureInitialized();
-    const skills = await this.storage.listSkills({ status: ["active"] });
-    const matches = await this.semanticMatcher.findMatches(query, skills, {
-      threshold: options?.minSimilarity,
-      maxResults: options?.maxResults
-    });
-    const results = [];
-    for (const match of matches) {
-      const skillAntiPatterns = await this.getAntiPatterns(match.skill.id);
-      const warnings = [];
-      let relevantAntiPatterns;
-      if (options?.context && skillAntiPatterns.length > 0) {
-        relevantAntiPatterns = skillAntiPatterns.filter(
-          (ap) => options.context.toLowerCase().includes(ap.pattern.toLowerCase())
-        );
-        if (relevantAntiPatterns.length > 0) {
-          warnings.push(
-            `This skill has failed in similar contexts: ${relevantAntiPatterns.map((ap) => ap.reason).join("; ")}`
-          );
-        }
-      }
-      if (options?.excludeAntiPatternMatches && relevantAntiPatterns && relevantAntiPatterns.length > 0) {
-        continue;
-      }
-      if (match.skill.metrics.successRate < 0.5 && match.skill.metrics.usageCount > 2) {
-        warnings.push(`Low success rate: ${Math.round(match.skill.metrics.successRate * 100)}%`);
-      }
-      results.push({
-        ...match,
-        relevantAntiPatterns: relevantAntiPatterns && relevantAntiPatterns.length > 0 ? relevantAntiPatterns : void 0,
-        warnings: warnings.length > 0 ? warnings : void 0
-      });
-    }
-    return results;
-  }
-  // ==========================================================================
-  // Legacy Learning Methods (backwards compatibility)
-  // ==========================================================================
-  /**
-   * Extract learning candidates from a trajectory using a learning provider.
-   * @deprecated Use learnFrom() instead
-   */
-  async extractLearnings(trajectory, options) {
-    this.ensureInitialized();
-    const providerName = options?.provider ?? "naive";
-    const provider = this.learningProviders.get(providerName);
-    if (!provider) {
-      throw new Error(
-        `Learning provider not found: ${providerName}. Available: ${Array.from(this.learningProviders.keys()).join(", ")}`
-      );
-    }
-    const result = await provider.analyze(trajectory, options);
-    return result.candidates;
-  }
-  /**
-   * Extract learning candidates from multiple trajectories.
-   * @deprecated Use learnFromBatch() instead
-   */
-  async extractLearningsBatch(trajectories, options) {
-    this.ensureInitialized();
-    const providerName = options?.provider ?? "naive";
-    const provider = this.learningProviders.get(providerName);
-    if (!provider) {
-      throw new Error(`Learning provider not found: ${providerName}`);
-    }
-    if (provider.analyzeBatch) {
-      const result = await provider.analyzeBatch(trajectories, options);
-      return result.candidates;
-    }
-    const allCandidates = [];
-    for (const trajectory of trajectories) {
-      const result = await provider.analyze(trajectory, options);
-      allCandidates.push(...result.candidates);
-    }
-    return allCandidates;
-  }
-  /**
-   * Promote a learning candidate to a versioned skill.
-   * This converts the raw learning into a curated, versioned skill.
-   */
-  async promoteToSkill(candidate, options) {
-    this.ensureInitialized();
-    if (candidate.content.kind !== "skill") {
-      throw new Error(
-        `Cannot promote ${candidate.content.kind} to skill directly. Only 'skill' kind is supported.`
-      );
-    }
-    const agentId = this.activationManager.getCurrentAgentId();
-    const agentMetadata = this.activationManager.getAgentMetadata();
-    const agentName = agentMetadata?.agentName;
-    const content = candidate.content;
-    const skill = {
-      id: candidate.id,
-      name: candidate.name,
-      version: "1.0.0",
-      description: content.problem.substring(0, 150),
-      problem: content.problem,
-      triggerConditions: (content.triggers ?? []).map((t) => ({
-        type: t.type,
-        value: t.value,
-        description: t.description
-      })),
-      solution: content.solution,
-      verification: content.verification,
-      examples: (content.examples ?? []).map((e) => ({
-        scenario: e.scenario,
-        before: e.before,
-        after: e.after
-      })),
-      author: options?.author ?? agentName ?? candidate.source.provider,
-      tags: options?.tags ?? candidate.tags ?? [],
-      createdAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date(),
-      status: options?.status ?? "draft",
-      metrics: {
-        usageCount: 0,
-        successRate: candidate.confidence,
-        feedbackScores: []
-      },
-      source: {
-        type: "extracted",
-        sessionId: candidate.source.trajectoryId,
-        importedAt: candidate.source.extractedAt,
-        agentId,
-        agentName
-      }
-    };
-    skill.serving = computeServingMetadata(skill);
-    await this.storage.saveSkill(skill);
-    this.emit({ type: "skill:created", skill });
-    if (this.validationEnabled && this.validator) {
-      this.runValidationAsync(skill).catch((err) => {
-        console.error("Validation error:", err);
-      });
-    }
-    if (this.compositionEnabled && this.composer) {
-      this.runCompositionSuggestionsAsync(skill).catch((err) => {
-        console.error("Composition suggestion error:", err);
-      });
-    }
-    return skill;
   }
   /**
    * Validate a skill and store the result
@@ -9501,7 +8403,6 @@ ${refinementNote}` : refinementNote;
     const deleted = await this.storage.deleteSkill(id, version);
     if (deleted) {
       this.emit({ type: "skill:deleted", skillId: id });
-      this.antiPatterns.delete(id);
     }
     return deleted;
   }
@@ -9975,8 +8876,7 @@ ${refinementNote}` : refinementNote;
       },
       byTag: {},
       avgSuccessRate: 0,
-      totalUsage: 0,
-      totalAntiPatterns: 0
+      totalUsage: 0
     };
     if (this.namespaceConfig) {
       stats.byScope = { personal: 0, team: 0, global: 0 };
@@ -9994,10 +8894,6 @@ ${refinementNote}` : refinementNote;
         successRateSum += skill.metrics.successRate;
         successRateCount++;
       }
-      const ap = this.antiPatterns.get(skill.id);
-      if (ap) {
-        stats.totalAntiPatterns += ap.length;
-      }
       if (stats.byScope && stats.byVisibility) {
         const scope = skill.namespace?.scope || "personal";
         const visibility = skill.namespace?.visibility || "private";
@@ -15283,3 +14179,4 @@ program.addCommand(configCommand);
 program.addCommand(syncCommand2);
 program.addCommand(mcpCommand);
 program.parse();
+//# sourceMappingURL=index.js.map