skill-tree 0.1.2 → 0.1.3

package/dist/index.js

@@ -42,7 +42,6 @@ __export(index_exports, {
   BaseStorageAdapter: () => BaseStorageAdapter,
   BatchProcessor: () => BatchProcessor,
   ClaudeCodeAdapter: () => ClaudeCodeAdapter,
-  CognitiveCoreProvider: () => CognitiveCoreProvider,
   ConflictStore: () => ConflictStore,
   DEFAULT_ACTIVATION_CONFIG: () => DEFAULT_ACTIVATION_CONFIG,
   DEFAULT_AGENTS_CONFIG: () => DEFAULT_AGENTS_CONFIG,
@@ -61,7 +60,6 @@ __export(index_exports, {
   MemoryMetricsStorage: () => MemoryMetricsStorage,
   MemoryStorageAdapter: () => MemoryStorageAdapter,
   MetricsTracker: () => MetricsTracker,
-  NaiveLearningProvider: () => NaiveLearningProvider,
   OpenAIAdapter: () => OpenAIAdapter,
   OpenAIEmbedding: () => OpenAIEmbedding,
   ProjectDetector: () => ProjectDetector,
@@ -94,9 +92,7 @@ __export(index_exports, {
   createAgentsParser: () => createAgentsParser,
   createAgentsSync: () => createAgentsSync,
   createBackupHook: () => createBackupHook,
-  createCognitiveCoreProvider: () => createCognitiveCoreProvider,
   createConflictStore: () => createConflictStore,
-  createDefaultCognitiveCoreFactory: () => createDefaultCognitiveCoreFactory,
   createDefaultSyncConfig: () => createDefaultSyncConfig,
   createExtractionEnrichmentHook: () => createExtractionEnrichmentHook,
   createExtractionValidationHook: () => createExtractionValidationHook,
@@ -106,7 +102,6 @@ __export(index_exports, {
   createMcpServer: () => createMcpServer,
   createMetricsHook: () => createMetricsHook,
   createMetricsTracker: () => createMetricsTracker,
-  createNaiveProvider: () => createNaiveProvider,
   createQualityBypassHook: () => createQualityBypassHook,
   createQualityLoggingHook: () => createQualityLoggingHook,
   createSaveValidationHook: () => createSaveValidationHook,
@@ -116,6 +111,7 @@ __export(index_exports, {
   createToolHandlers: () => createToolHandlers,
   debuggingProfile: () => debuggingProfile,
   devopsProfile: () => devopsProfile,
+  discoverSkills: () => discoverSkills,
   documentationProfile: () => documentationProfile,
   euclideanDistance: () => euclideanDistance,
   executeToolCall: () => executeToolCall,
@@ -126,6 +122,7 @@ __export(index_exports, {
   getLatestVersion: () => getLatestVersion,
   getToolDefinition: () => getToolDefinition,
   getToolNames: () => getToolNames,
+  hasSkilltreeDir: () => hasSkilltreeDir,
   hookRegistry: () => hookRegistry,
   implementationProfile: () => implementationProfile,
   importFromAgentsMd: () => importFromAgentsMd,
@@ -846,11 +843,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
    */
@@ -1012,62 +1074,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 = {
@@ -6522,10 +6528,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;
   }
@@ -6656,78 +6659,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
@@ -7278,152 +7209,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) {
@@ -8226,8 +8011,6 @@ async function migrateStorage(source, target, options = {}) {
   const opts = {
     skills: options.skills ?? true,
     lineage: options.lineage ?? true,
-    candidates: options.candidates ?? true,
-    antiPatterns: options.antiPatterns ?? true,
     onProgress: options.onProgress ?? (() => {
     }),
     overwrite: options.overwrite ?? false
@@ -8239,9 +8022,7 @@ async function migrateStorage(source, target, options = {}) {
     errors: 0,
     details: {
       skills: { migrated: 0, skipped: 0, errors: 0 },
-      lineages: { migrated: 0, skipped: 0, errors: 0 },
-      candidates: { migrated: 0, skipped: 0, errors: 0 },
-      antiPatterns: { migrated: 0, skipped: 0, errors: 0 }
+      lineages: { migrated: 0, skipped: 0, errors: 0 }
     }
   };
   if (opts.skills) {
@@ -8250,12 +8031,6 @@ async function migrateStorage(source, target, options = {}) {
   if (opts.lineage) {
     await migrateLineages(source, target, opts, result);
   }
-  if (opts.candidates) {
-    await migrateCandidates(source, target, opts, result);
-  }
-  if (opts.antiPatterns) {
-    await migrateAntiPatterns(source, target, opts, result);
-  }
   return result;
 }
 async function migrateSkills(source, target, opts, result) {
@@ -8321,65 +8096,6 @@ async function migrateLineages(source, target, opts, result) {
     }
   }
 }
-async function migrateCandidates(source, target, opts, result) {
-  if (!source.listCandidates || !target.saveCandidate) {
-    return;
-  }
-  const candidates = await source.listCandidates();
-  for (const candidate of candidates) {
-    result.totalProcessed++;
-    try {
-      if (!opts.overwrite && target.getCandidate) {
-        const existing = await target.getCandidate(candidate.id);
-        if (existing) {
-          result.skipped++;
-          result.details.candidates.skipped++;
-          opts.onProgress({ type: "candidate", id: candidate.id, status: "skipped" });
-          continue;
-        }
-      }
-      await target.saveCandidate(candidate);
-      result.migrated++;
-      result.details.candidates.migrated++;
-      opts.onProgress({ type: "candidate", id: candidate.id, status: "migrated" });
-    } catch (error) {
-      result.errors++;
-      result.details.candidates.errors++;
-      opts.onProgress({
-        type: "candidate",
-        id: candidate.id,
-        status: "error",
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-}
-async function migrateAntiPatterns(source, target, opts, result) {
-  if (!source.getAntiPatterns || !target.saveAntiPatterns) {
-    return;
-  }
-  const skills = await source.listSkills();
-  for (const skill of skills) {
-    try {
-      const patterns = await source.getAntiPatterns(skill.id);
-      if (!patterns || patterns.length === 0) continue;
-      result.totalProcessed++;
-      await target.saveAntiPatterns(skill.id, patterns);
-      result.migrated++;
-      result.details.antiPatterns.migrated++;
-      opts.onProgress({ type: "anti-pattern", id: skill.id, status: "migrated" });
-    } catch (error) {
-      result.errors++;
-      result.details.antiPatterns.errors++;
-      opts.onProgress({
-        type: "anti-pattern",
-        id: skill.id,
-        status: "error",
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-}
 
 // src/versioning/lineage.ts
 var LineageTracker = class {
@@ -9152,387 +8868,80 @@ function createSkillMerger(storage, config) {
   return new SkillMerger(storage, config);
 }
 
-// src/learning/providers/naive.ts
-var NaiveLearningProvider = class {
-  constructor(config) {
-    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: config?.llmProvider ?? null,
-      minConfidence: config?.minConfidence ?? 0.6,
-      runQualityGates: config?.runQualityGates ?? true,
-      creditStrategy: config?.creditStrategy ?? "simple"
-    };
-    this.manualExtractor = new ManualExtractor();
-    this.automaticExtractor = new AutomaticExtractor({
-      llmProvider: this.config.llmProvider || void 0,
-      minConfidence: this.config.minConfidence
-    });
+// src/hooks/registry.ts
+var import_crypto = require("crypto");
+var PRIORITY_ORDER = {
+  high: 0,
+  normal: 1,
+  low: 2
+};
+var HookRegistry = class {
+  constructor() {
+    this.hooks = /* @__PURE__ */ new Map();
+    this.eventIndex = /* @__PURE__ */ new Map();
   }
   /**
-   * Set or update the LLM provider
+   * Register a new hook
    */
-  setLLMProvider(provider) {
-    this.config.llmProvider = provider;
-    this.automaticExtractor.setLLMProvider(provider);
+  register(options) {
+    const id = (0, import_crypto.randomUUID)();
+    const events = Array.isArray(options.events) ? options.events : [options.events];
+    const hook = {
+      id,
+      name: options.name,
+      events,
+      handler: options.handler,
+      priority: options.priority || "normal",
+      enabled: options.enabled !== false,
+      filter: options.filter
+    };
+    this.hooks.set(id, hook);
+    for (const event of events) {
+      if (!this.eventIndex.has(event)) {
+        this.eventIndex.set(event, /* @__PURE__ */ new Set());
+      }
+      this.eventIndex.get(event).add(id);
+    }
+    return id;
   }
   /**
-   * Analyze a trajectory and extract learning candidates
+   * Unregister a hook
    */
-  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);
+  unregister(hookId) {
+    const hook = this.hooks.get(hookId);
+    if (!hook) return false;
+    for (const event of hook.events) {
+      this.eventIndex.get(event)?.delete(hookId);
     }
-    return {
-      candidates,
-      // Naive provider doesn't produce updates, demotions, or anti-patterns
-      metadata: {
-        trajectoriesAnalyzed: 1,
-        durationMs: Date.now() - startTime
-      }
-    };
+    this.hooks.delete(hookId);
+    return true;
   }
   /**
-   * Batch analysis - runs individual analysis on each trajectory.
-   * A more sophisticated provider could do cross-trajectory pattern detection.
+   * Enable a hook
    */
-  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
-      }
-    };
+  enable(hookId) {
+    const hook = this.hooks.get(hookId);
+    if (!hook) return false;
+    hook.enabled = true;
+    return true;
   }
   /**
-   * Check if a candidate is a duplicate based on name/content similarity
+   * Disable a hook
    */
-  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;
+  disable(hookId) {
+    const hook = this.hooks.get(hookId);
+    if (!hook) return false;
+    hook.enabled = false;
+    return true;
   }
   /**
-   * Compute similarity between two candidates (basic implementation)
+   * Get a hook by ID
    */
-  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;
+  get(hookId) {
+    return this.hooks.get(hookId);
   }
-  // ==========================================================================
-  // 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;
-  }
-};
-function createNaiveProvider(config) {
-  return new NaiveLearningProvider(config);
-}
-
-// src/hooks/registry.ts
-var import_crypto = require("crypto");
-var PRIORITY_ORDER = {
-  high: 0,
-  normal: 1,
-  low: 2
-};
-var HookRegistry = class {
-  constructor() {
-    this.hooks = /* @__PURE__ */ new Map();
-    this.eventIndex = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Register a new hook
-   */
-  register(options) {
-    const id = (0, import_crypto.randomUUID)();
-    const events = Array.isArray(options.events) ? options.events : [options.events];
-    const hook = {
-      id,
-      name: options.name,
-      events,
-      handler: options.handler,
-      priority: options.priority || "normal",
-      enabled: options.enabled !== false,
-      filter: options.filter
-    };
-    this.hooks.set(id, hook);
-    for (const event of events) {
-      if (!this.eventIndex.has(event)) {
-        this.eventIndex.set(event, /* @__PURE__ */ new Set());
-      }
-      this.eventIndex.get(event).add(id);
-    }
-    return id;
-  }
-  /**
-   * Unregister a hook
-   */
-  unregister(hookId) {
-    const hook = this.hooks.get(hookId);
-    if (!hook) return false;
-    for (const event of hook.events) {
-      this.eventIndex.get(event)?.delete(hookId);
-    }
-    this.hooks.delete(hookId);
-    return true;
-  }
-  /**
-   * Enable a hook
-   */
-  enable(hookId) {
-    const hook = this.hooks.get(hookId);
-    if (!hook) return false;
-    hook.enabled = true;
-    return true;
-  }
-  /**
-   * Disable a hook
-   */
-  disable(hookId) {
-    const hook = this.hooks.get(hookId);
-    if (!hook) return false;
-    hook.enabled = false;
-    return true;
-  }
-  /**
-   * Get a hook by ID
-   */
-  get(hookId) {
-    return this.hooks.get(hookId);
-  }
-  /**
-   * List all registered hooks
+   * List all registered hooks
    */
   list() {
     return Array.from(this.hooks.values());
@@ -9931,10 +9340,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 */
@@ -9972,11 +9377,6 @@ var SkillBank = class {
       similarityThreshold: config.matching?.similarityThreshold
     });
     this.autoIndexOnInit = config.matching?.autoIndex ?? false;
-    const naiveProvider = new NaiveLearningProvider({
-      llmProvider: config.llmProvider,
-      minConfidence: config.minExtractionConfidence
-    });
-    this.learningProviders.set(naiveProvider.name, naiveProvider);
     if (config.namespace) {
       this.namespaceConfig = {
         agentId: config.namespace.agentId,
@@ -10004,11 +9404,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);
     }
@@ -10021,11 +9416,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
@@ -10127,625 +9517,62 @@ var SkillBank = class {
     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) {
-        const duplicate = await this.findSemanticDuplicate(result.skill);
-        if (duplicate) {
-          result.success = false;
-          result.failureReason = `Duplicate of existing skill: ${duplicate.skill.id} (similarity: ${duplicate.similarity.toFixed(2)})`;
-        } else {
-          await this.storage.saveSkill(result.skill);
-          this.emit({ type: "skill:created", skill: result.skill });
-        }
-      }
-      this.emit({ type: "extraction:completed", result });
-    }
-    return results;
-  }
-  /**
-   * Unified extraction entry point.
-   *
-   * Supports both manual (targeted) and automatic (LLM-driven) extraction
-   * from a Trajectory. Use this instead of calling extractManual/extractAutomatic
-   * directly.
-   *
-   * @example
-   * ```typescript
-   * // Manual extraction with defaults
-   * const results = await bank.extract(trajectory);
-   *
-   * // Automatic extraction
-   * const results = await bank.extract(trajectory, { mode: 'automatic' });
-   *
-   * // Manual with specific turn range
-   * const results = await bank.extract(trajectory, {
-   *   mode: 'manual',
-   *   turnRange: [0, 5],
-   *   suggestedName: 'fix-auth-error',
-   * });
-   * ```
-   */
-  async extract(trajectory, options) {
-    if (options?.mode === "automatic") {
-      return this.extractAutomatic(trajectory, options);
-    }
-    const result = await this.extractManual(trajectory, options);
-    return [result];
-  }
-  /**
-   * Extract from raw session content (convenience method)
-   */
-  async extractFromSession(content, options) {
-    const trajectory = await this.parseSession(content, options?.adapterName);
-    return this.extract(trajectory, options);
-  }
-  /**
-   * Set LLM provider for automatic extraction
-   */
-  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 (result.success && result.skill) {
+        const duplicate = await this.findSemanticDuplicate(result.skill);
+        if (duplicate) {
+          result.success = false;
+          result.failureReason = `Duplicate of existing skill: ${duplicate.skill.id} (similarity: ${duplicate.similarity.toFixed(2)})`;
+        } else {
+          await this.storage.saveSkill(result.skill);
+          this.emit({ type: "skill:created", skill: result.skill });
         }
       }
-      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
-      });
+      this.emit({ type: "extraction:completed", result });
     }
     return results;
   }
-  // ==========================================================================
-  // Legacy Learning Methods (backwards compatibility)
-  // ==========================================================================
   /**
-   * Extract learning candidates from a trajectory using a learning provider.
-   * @deprecated Use learnFrom() instead
+   * Unified extraction entry point.
+   *
+   * Supports both manual (targeted) and automatic (LLM-driven) extraction
+   * from a Trajectory. Use this instead of calling extractManual/extractAutomatic
+   * directly.
+   *
+   * @example
+   * ```typescript
+   * // Manual extraction with defaults
+   * const results = await bank.extract(trajectory);
+   *
+   * // Automatic extraction
+   * const results = await bank.extract(trajectory, { mode: 'automatic' });
+   *
+   * // Manual with specific turn range
+   * const results = await bank.extract(trajectory, {
+   *   mode: 'manual',
+   *   turnRange: [0, 5],
+   *   suggestedName: 'fix-auth-error',
+   * });
+   * ```
    */
-  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(", ")}`
-      );
+  async extract(trajectory, options) {
+    if (options?.mode === "automatic") {
+      return this.extractAutomatic(trajectory, options);
     }
-    const result = await provider.analyze(trajectory, options);
-    return result.candidates;
+    const result = await this.extractManual(trajectory, options);
+    return [result];
   }
   /**
-   * Extract learning candidates from multiple trajectories.
-   * @deprecated Use learnFromBatch() instead
+   * Extract from raw session content (convenience method)
    */
-  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;
+  async extractFromSession(content, options) {
+    const trajectory = await this.parseSession(content, options?.adapterName);
+    return this.extract(trajectory, options);
   }
   /**
-   * Promote a learning candidate to a versioned skill.
-   * This converts the raw learning into a curated, versioned skill.
+   * Set LLM provider for automatic extraction
    */
-  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;
+  setLLMProvider(provider) {
+    this.automaticExtractor.setLLMProvider(provider);
   }
   /**
    * Validate a skill and store the result
@@ -11204,7 +10031,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;
   }
@@ -11678,8 +10504,7 @@ ${refinementNote}` : refinementNote;
       },
       byTag: {},
       avgSuccessRate: 0,
-      totalUsage: 0,
-      totalAntiPatterns: 0
+      totalUsage: 0
     };
     if (this.namespaceConfig) {
       stats.byScope = { personal: 0, team: 0, global: 0 };
@@ -11697,10 +10522,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";
@@ -13910,509 +12731,6 @@ function conditionalHook(filter, handler) {
   };
 }
 
-// src/learning/providers/cognitive-core.ts
-var CognitiveCoreProvider = class {
-  constructor(options) {
-    this.name = "cognitive-core";
-    this.description = "Advanced learning using cognitive-core with batch extraction and feedback";
-    this.capabilities = {
-      accumulating: true,
-      feedbackEnabled: true,
-      persistent: true,
-      minTrajectories: 5,
-      supportedKinds: ["skill", "strategy", "pattern", "error-fix"]
-    };
-    this.initialized = false;
-    // ID mapping: playbook.id <-> candidate.id
-    // For cognitive-core, we use playbook.id as the candidate.id directly
-    this.playbookIdCache = /* @__PURE__ */ new Map();
-    this.factory = options.factory;
-    this.config = {
-      storagePath: options.storagePath ?? "./.cognitive-core",
-      minTrajectories: options.minTrajectories ?? 5,
-      deduplicationThreshold: options.deduplicationThreshold ?? 0.85,
-      creditStrategy: options.creditStrategy ?? "simple",
-      convertToReAct: options.convertToReAct ?? true
-    };
-    this.memory = this.factory.createMemorySystem(this.config.storagePath);
-    this.pipeline = this.factory.createLearningPipeline(this.memory, {
-      creditStrategy: this.config.creditStrategy,
-      minTrajectories: this.config.minTrajectories,
-      deduplicationThreshold: this.config.deduplicationThreshold
-    });
-  }
-  /**
-   * Initialize the provider (load persisted state)
-   */
-  async initialize() {
-    if (this.initialized) return;
-    await this.memory.init();
-    this.initialized = true;
-  }
-  /**
-   * Shutdown cleanly (persist state, release resources)
-   */
-  async shutdown() {
-    await this.memory.close();
-    this.initialized = false;
-  }
-  /**
-   * Analyze a trajectory and accumulate for batch learning.
-   * Returns empty candidates until flush() or batch threshold.
-   */
-  async analyze(trajectory, options) {
-    await this.initialize();
-    const startTime = Date.now();
-    const ccTrajectory = this.convertTrajectory(trajectory, options);
-    await this.pipeline.processTrajectory(ccTrajectory);
-    let candidates = [];
-    let updates = [];
-    let demotions = [];
-    let antiPatterns = [];
-    if (options?.forceImmediate || this.pipeline.shouldRunBatch()) {
-      const batchResult = await this.runBatchExtraction(options);
-      candidates = batchResult.candidates;
-      updates = batchResult.updates ?? [];
-      demotions = batchResult.demotions ?? [];
-      antiPatterns = batchResult.antiPatterns ?? [];
-    }
-    return {
-      candidates,
-      updates: updates.length > 0 ? updates : void 0,
-      demotions: demotions.length > 0 ? demotions : void 0,
-      antiPatterns: antiPatterns.length > 0 ? antiPatterns : void 0,
-      providerState: {
-        pendingCount: this.pipeline.getAccumulatedCount(),
-        readyForFlush: this.pipeline.shouldRunBatch()
-      },
-      metadata: {
-        trajectoriesAnalyzed: 1,
-        durationMs: Date.now() - startTime
-      }
-    };
-  }
-  /**
-   * Analyze multiple trajectories together.
-   * Enables better cross-trajectory pattern detection.
-   */
-  async analyzeBatch(trajectories, options) {
-    await this.initialize();
-    const startTime = Date.now();
-    for (const trajectory of trajectories) {
-      const ccTrajectory = this.convertTrajectory(trajectory, options);
-      await this.pipeline.processTrajectory(ccTrajectory);
-    }
-    const batchResult = await this.runBatchExtraction(options);
-    return {
-      candidates: batchResult.candidates,
-      updates: batchResult.updates,
-      demotions: batchResult.demotions,
-      antiPatterns: batchResult.antiPatterns,
-      providerState: {
-        pendingCount: this.pipeline.getAccumulatedCount(),
-        readyForFlush: this.pipeline.shouldRunBatch()
-      },
-      metadata: {
-        trajectoriesAnalyzed: trajectories.length,
-        durationMs: Date.now() - startTime
-      }
-    };
-  }
-  /**
-   * Force extraction from accumulated trajectories.
-   */
-  async flush(options) {
-    await this.initialize();
-    const startTime = Date.now();
-    const pendingCount = this.pipeline.getAccumulatedCount();
-    const batchResult = await this.runBatchExtraction(options);
-    return {
-      ...batchResult,
-      metadata: {
-        trajectoriesAnalyzed: pendingCount,
-        durationMs: Date.now() - startTime
-      }
-    };
-  }
-  /**
-   * Record outcome when a candidate/playbook is applied.
-   * Updates playbook confidence and may generate refinements.
-   */
-  async recordOutcome(feedback) {
-    await this.initialize();
-    const playbookId = feedback.candidateId;
-    const playbook = await this.memory.playbooks.get(playbookId);
-    if (!playbook) {
-      return { recorded: false };
-    }
-    await this.memory.recordPlaybookUsage(
-      playbookId,
-      feedback.trajectoryId,
-      feedback.success,
-      feedback.context,
-      feedback.failureMode
-    );
-    const updates = [];
-    const antiPatterns = [];
-    if (feedback.success) {
-      updates.push({
-        candidateId: playbookId,
-        incrementSuccess: true,
-        confidenceAdjustment: 0.05
-        // Slight boost on success
-      });
-    } else {
-      updates.push({
-        candidateId: playbookId,
-        incrementFailure: true,
-        confidenceAdjustment: -0.1
-        // Decrease confidence on failure
-      });
-      if (feedback.context || feedback.failureMode) {
-        antiPatterns.push({
-          id: `anti-${playbookId}-${Date.now()}`,
-          candidateId: playbookId,
-          pattern: feedback.context ?? "Unknown context",
-          reason: feedback.failureMode ?? "Unknown failure mode",
-          discoveredFrom: feedback.trajectoryId,
-          createdAt: /* @__PURE__ */ new Date()
-        });
-      }
-    }
-    return {
-      recorded: true,
-      updates: updates.length > 0 ? updates : void 0,
-      antiPatterns: antiPatterns.length > 0 ? antiPatterns : void 0
-    };
-  }
-  /**
-   * Check if a candidate is a duplicate based on playbook similarity
-   */
-  isDuplicate(candidate, existing) {
-    if (existing.some((e) => e.id === candidate.id)) {
-      return true;
-    }
-    for (const e of existing) {
-      const similarity = this.computeSimilarity(candidate, e);
-      if (similarity > this.config.deduplicationThreshold) {
-        return true;
-      }
-    }
-    return false;
-  }
-  /**
-   * Compute similarity between two candidates
-   */
-  computeSimilarity(a, b) {
-    if (a.kind !== b.kind) return 0.1;
-    const nameA = this.tokenize(a.name);
-    const nameB = this.tokenize(b.name);
-    const nameSimilarity = this.jaccardSimilarity(nameA, nameB);
-    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
-  // ==========================================================================
-  /**
-   * Run batch extraction and convert results to LearningCandidates
-   */
-  async runBatchExtraction(options) {
-    await this.pipeline.runBatchLearning();
-    const allPlaybooks = await this.memory.playbooks.getAll();
-    const candidates = [];
-    const updates = [];
-    const demotions = [];
-    const antiPatterns = [];
-    const minConfidence = options?.minConfidence ?? 0;
-    const requestedKinds = options?.kinds;
-    for (const playbook of allPlaybooks) {
-      if (!this.playbookIdCache.has(playbook.id)) {
-        const candidate = this.playbookToCandidate(playbook);
-        if (candidate.confidence < minConfidence) {
-          continue;
-        }
-        if (requestedKinds && !requestedKinds.includes(candidate.kind)) {
-          continue;
-        }
-        candidates.push(candidate);
-        this.playbookIdCache.set(playbook.id, true);
-      }
-      const successRate = playbook.evolution.successCount + playbook.evolution.failureCount > 0 ? playbook.evolution.successCount / (playbook.evolution.successCount + playbook.evolution.failureCount) : 1;
-      if (successRate < 0.3 && playbook.evolution.successCount + playbook.evolution.failureCount >= 3) {
-        demotions.push({
-          candidateId: playbook.id,
-          reason: `Low success rate: ${Math.round(successRate * 100)}%`,
-          newConfidence: successRate,
-          deprecate: successRate < 0.1
-        });
-      }
-      for (const antiPattern of playbook.applicability.antiPatterns) {
-        antiPatterns.push({
-          id: `anti-${playbook.id}-${antiPattern.slice(0, 10)}`,
-          candidateId: playbook.id,
-          pattern: antiPattern,
-          reason: "Learned from playbook applicability",
-          discoveredFrom: playbook.evolution.createdFrom[0] ?? "unknown",
-          createdAt: playbook.createdAt
-        });
-      }
-    }
-    return {
-      candidates,
-      updates: updates.length > 0 ? updates : void 0,
-      demotions: demotions.length > 0 ? demotions : void 0,
-      antiPatterns: antiPatterns.length > 0 ? antiPatterns : void 0,
-      providerState: {
-        pendingCount: this.pipeline.getAccumulatedCount(),
-        readyForFlush: this.pipeline.shouldRunBatch()
-      }
-    };
-  }
-  /**
-   * Convert a skill-tree Trajectory to cognitive-core Trajectory format
-   */
-  convertTrajectory(trajectory, options) {
-    const firstUserTurn = trajectory.turns.find((t) => t.role === "user");
-    let taskDescription = firstUserTurn?.content ?? "Unknown task";
-    if (options?.context) {
-      taskDescription = `${taskDescription}
-
-Context: ${options.context}`;
-    }
-    const task = this.factory.createTask({
-      id: trajectory.sessionId,
-      domain: trajectory.metadata.projectName ?? "general",
-      description: taskDescription,
-      context: trajectory.metadata.custom ?? {}
-    });
-    const [startTurn, endTurn] = options?.turnRange ?? [0, trajectory.turns.length - 1];
-    const turnsToProcess = trajectory.turns.slice(startTurn, endTurn + 1);
-    const steps = [];
-    if (this.config.convertToReAct) {
-      for (let i = 0; i < turnsToProcess.length; i++) {
-        const turn = turnsToProcess[i];
-        if (turn.role === "assistant") {
-          const step = this.turnToStep(turn, turnsToProcess, i);
-          if (step) {
-            steps.push(step);
-          }
-        }
-      }
-    }
-    const outcome = {
-      success: trajectory.outcome?.success ?? false,
-      partialScore: trajectory.outcome?.success ? 1 : 0,
-      solution: trajectory.outcome?.summary ?? "",
-      errorInfo: trajectory.outcome?.errors?.join("; ")
-    };
-    return this.factory.createTrajectory({
-      id: trajectory.sessionId,
-      task,
-      steps,
-      outcome,
-      agentId: trajectory.metadata.agentType ?? "skill-tree",
-      metadata: trajectory.metadata.custom ?? {}
-    });
-  }
-  /**
-   * Convert an assistant turn to a cognitive-core Step
-   */
-  turnToStep(turn, allTurns, turnIndex) {
-    let observation = "";
-    const nextTurn = allTurns[turnIndex + 1];
-    if (nextTurn?.role === "tool" && nextTurn.toolResults?.length) {
-      observation = nextTurn.toolResults.map((r) => r.output).join("\n");
-    } else if (nextTurn?.role === "user") {
-      observation = nextTurn.content.slice(0, 500);
-    }
-    let action = "";
-    if (turn.toolCalls?.length) {
-      action = turn.toolCalls.map((tc) => `${tc.name}(${JSON.stringify(tc.input).slice(0, 200)})`).join("; ");
-    } else {
-      action = turn.content.slice(0, 300);
-    }
-    const thought = turn.toolCalls?.length ? turn.content.slice(0, 500) : void 0;
-    return this.factory.createStep({
-      thought,
-      action,
-      observation
-    });
-  }
-  /**
-   * Convert a cognitive-core Playbook to a LearningCandidate
-   */
-  playbookToCandidate(playbook) {
-    const kind = this.inferKind(playbook);
-    const content = this.createContentForKind(kind, playbook);
-    const attribution = playbook.evolution.createdFrom.map(
-      (trajectoryId, i) => ({
-        turnIndex: i,
-        score: 1 / Math.max(1, playbook.evolution.createdFrom.length),
-        reasoning: `Derived from trajectory ${trajectoryId}`
-      })
-    );
-    return {
-      kind,
-      id: playbook.id,
-      name: playbook.name,
-      content,
-      confidence: playbook.confidence,
-      attribution,
-      source: {
-        provider: this.name,
-        trajectoryId: playbook.evolution.createdFrom[0] ?? "unknown",
-        turnRange: [0, 0],
-        // Playbooks don't track specific turn ranges
-        extractedAt: playbook.createdAt,
-        metadata: {
-          version: playbook.evolution.version,
-          successCount: playbook.evolution.successCount,
-          failureCount: playbook.evolution.failureCount,
-          complexity: playbook.complexity
-        }
-      },
-      embedding: playbook.embedding,
-      // Pass through embedding if present
-      tags: playbook.applicability.domains,
-      reasoning: playbook.guidance.strategy
-    };
-  }
-  /**
-   * Create appropriate content type for the inferred kind
-   */
-  createContentForKind(kind, playbook) {
-    switch (kind) {
-      case "strategy":
-        return {
-          kind: "strategy",
-          situation: playbook.applicability.situations.join(". "),
-          suggestion: playbook.guidance.strategy,
-          parameters: playbook.guidance.codeExample ? { example: playbook.guidance.codeExample } : void 0
-        };
-      case "pattern":
-        return {
-          kind: "pattern",
-          pattern: playbook.applicability.triggers[0] ?? playbook.name,
-          description: playbook.guidance.strategy,
-          examples: playbook.applicability.situations
-        };
-      case "error-fix":
-        return {
-          kind: "error-fix",
-          errorPattern: playbook.applicability.triggers.join(" | "),
-          fix: playbook.guidance.strategy + (playbook.guidance.steps?.length ? "\n\nSteps:\n" + playbook.guidance.steps.map((s, i) => `${i + 1}. ${s}`).join("\n") : ""),
-          frequency: playbook.evolution.successCount + playbook.evolution.failureCount,
-          errorExamples: playbook.applicability.triggers
-        };
-      case "skill":
-      default:
-        return {
-          kind: "skill",
-          problem: playbook.applicability.situations.join(". "),
-          solution: playbook.guidance.strategy + (playbook.guidance.steps?.length ? "\n\nSteps:\n" + playbook.guidance.steps.map((s, i) => `${i + 1}. ${s}`).join("\n") : ""),
-          verification: playbook.verification.successIndicators.join(". "),
-          triggers: this.extractTriggers(playbook),
-          examples: []
-          // Playbooks don't have direct examples
-        };
-    }
-  }
-  /**
-   * Infer the kind of learning from a playbook
-   */
-  inferKind(playbook) {
-    const hasErrorTriggers = playbook.applicability.triggers.some(
-      (t) => t.toLowerCase().includes("error") || /^[A-Z]{2,}\d+/.test(t)
-    );
-    if (hasErrorTriggers) {
-      return "error-fix";
-    }
-    const strategy = playbook.guidance.strategy.toLowerCase();
-    if (strategy.includes("approach") || strategy.includes("strategy") || strategy.includes("when you see")) {
-      return "strategy";
-    }
-    if (playbook.applicability.situations.some((s) => s.includes("pattern"))) {
-      return "pattern";
-    }
-    return "skill";
-  }
-  /**
-   * Extract triggers from playbook applicability
-   */
-  extractTriggers(playbook) {
-    const triggers = [];
-    for (const situation of playbook.applicability.situations) {
-      triggers.push({
-        type: "context",
-        value: situation,
-        description: "Situation trigger"
-      });
-    }
-    for (const trigger of playbook.applicability.triggers) {
-      let type = "keyword";
-      if (trigger.toLowerCase().includes("error") || /^[A-Z]{2,}\d+/.test(trigger)) {
-        type = "error";
-      } else if (trigger.startsWith("/") || trigger.includes("*")) {
-        type = "pattern";
-      }
-      triggers.push({
-        type,
-        value: trigger,
-        description: "Explicit trigger"
-      });
-    }
-    return triggers;
-  }
-  /**
-   * 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;
-  }
-};
-function createCognitiveCoreProvider(options) {
-  return new CognitiveCoreProvider(options);
-}
-async function createDefaultCognitiveCoreFactory() {
-  const cc = await import("cognitive-core");
-  return {
-    createMemorySystem(storagePath) {
-      return cc.createMemorySystem(storagePath);
-    },
-    createLearningPipeline(memory, config) {
-      return cc.createLearningPipeline(
-        memory,
-        config
-      );
-    },
-    createTrajectory(params) {
-      return cc.createTrajectory(params);
-    },
-    createTask(params) {
-      return cc.createTask(params);
-    },
-    createStep(params) {
-      return cc.createStep(params);
-    }
-  };
-}
-
 // src/sync/git-sync-adapter.ts
 var fs8 = __toESM(require("fs"));
 var path8 = __toESM(require("path"));
@@ -15942,7 +14260,6 @@ var VERSION = "0.1.0";
   BaseStorageAdapter,
   BatchProcessor,
   ClaudeCodeAdapter,
-  CognitiveCoreProvider,
   ConflictStore,
   DEFAULT_ACTIVATION_CONFIG,
   DEFAULT_AGENTS_CONFIG,
@@ -15961,7 +14278,6 @@ var VERSION = "0.1.0";
   MemoryMetricsStorage,
   MemoryStorageAdapter,
   MetricsTracker,
-  NaiveLearningProvider,
   OpenAIAdapter,
   OpenAIEmbedding,
   ProjectDetector,
@@ -15994,9 +14310,7 @@ var VERSION = "0.1.0";
   createAgentsParser,
   createAgentsSync,
   createBackupHook,
-  createCognitiveCoreProvider,
   createConflictStore,
-  createDefaultCognitiveCoreFactory,
   createDefaultSyncConfig,
   createExtractionEnrichmentHook,
   createExtractionValidationHook,
@@ -16006,7 +14320,6 @@ var VERSION = "0.1.0";
   createMcpServer,
   createMetricsHook,
   createMetricsTracker,
-  createNaiveProvider,
   createQualityBypassHook,
   createQualityLoggingHook,
   createSaveValidationHook,
@@ -16016,6 +14329,7 @@ var VERSION = "0.1.0";
   createToolHandlers,
   debuggingProfile,
   devopsProfile,
+  discoverSkills,
   documentationProfile,
   euclideanDistance,
   executeToolCall,
@@ -16026,6 +14340,7 @@ var VERSION = "0.1.0";
   getLatestVersion,
   getToolDefinition,
   getToolNames,
+  hasSkilltreeDir,
   hookRegistry,
   implementationProfile,
   importFromAgentsMd,
@@ -16055,3 +14370,4 @@ var VERSION = "0.1.0";
   testingProfile,
   writeAgentsMd
 });
+//# sourceMappingURL=index.js.map