@skillkit/core 1.7.11 → 1.8.1

package/dist/index.js

@@ -4697,13 +4697,255 @@ function createSessionManager(projectPath) {
   return new SessionManager(projectPath);
 }
 
+// src/session/state-file.ts
+import { existsSync as existsSync14, readFileSync as readFileSync9, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7, readdirSync as readdirSync4 } from "fs";
+import { join as join13 } from "path";
+import { homedir as homedir4 } from "os";
+function getSessionsDir() {
+  return join13(homedir4(), ".skillkit", "sessions");
+}
+function getSessionFilePath(date) {
+  const d = date || (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return join13(getSessionsDir(), `${d}-session.md`);
+}
+function loadSessionFile(date) {
+  const filepath = getSessionFilePath(date);
+  if (!existsSync14(filepath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync9(filepath, "utf-8");
+    return parseSessionFile(content);
+  } catch {
+    return null;
+  }
+}
+function saveSessionFile(session) {
+  const dir = getSessionsDir();
+  if (!existsSync14(dir)) {
+    mkdirSync7(dir, { recursive: true });
+  }
+  const filepath = getSessionFilePath(session.date);
+  const content = formatSessionFile(session);
+  writeFileSync7(filepath, content);
+  return filepath;
+}
+function createSessionFile(agent, projectPath) {
+  const now = /* @__PURE__ */ new Date();
+  return {
+    date: now.toISOString().split("T")[0],
+    agent,
+    projectPath,
+    startedAt: now.toISOString(),
+    lastUpdated: now.toISOString(),
+    completed: [],
+    inProgress: [],
+    notes: [],
+    contextToLoad: []
+  };
+}
+function updateSessionFile(session, updates) {
+  const updated = {
+    ...session,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (updates.completed) {
+    updated.completed = [.../* @__PURE__ */ new Set([...session.completed, ...updates.completed])];
+  }
+  if (updates.inProgress) {
+    updated.inProgress = updates.inProgress;
+  }
+  if (updates.notes) {
+    updated.notes = [...session.notes, ...updates.notes];
+  }
+  if (updates.contextToLoad) {
+    updated.contextToLoad = [.../* @__PURE__ */ new Set([...session.contextToLoad, ...updates.contextToLoad])];
+  }
+  return updated;
+}
+function parseSessionFile(content) {
+  const lines = content.split("\n");
+  const session = {
+    date: "",
+    agent: "",
+    projectPath: "",
+    startedAt: "",
+    lastUpdated: "",
+    completed: [],
+    inProgress: [],
+    notes: [],
+    contextToLoad: []
+  };
+  let currentSection = "";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("# Session:")) {
+      session.date = trimmed.replace("# Session:", "").trim();
+    } else if (trimmed.startsWith("**Date:**")) {
+      session.date = trimmed.replace("**Date:**", "").trim();
+    } else if (trimmed.startsWith("**Started:**")) {
+      session.startedAt = trimmed.replace("**Started:**", "").trim();
+    } else if (trimmed.startsWith("**Last Updated:**")) {
+      session.lastUpdated = trimmed.replace("**Last Updated:**", "").trim();
+    } else if (trimmed.startsWith("**Agent:**")) {
+      session.agent = trimmed.replace("**Agent:**", "").trim();
+    } else if (trimmed.startsWith("**Project:**")) {
+      session.projectPath = trimmed.replace("**Project:**", "").trim();
+    } else if (trimmed === "### Completed") {
+      currentSection = "completed";
+    } else if (trimmed === "### In Progress") {
+      currentSection = "inProgress";
+    } else if (trimmed === "### Notes for Next Session") {
+      currentSection = "notes";
+    } else if (trimmed === "### Context to Load") {
+      currentSection = "contextToLoad";
+    } else if (trimmed.startsWith("- [x]")) {
+      if (currentSection === "completed") {
+        session.completed.push(trimmed.replace("- [x]", "").trim());
+      }
+    } else if (trimmed.startsWith("- [ ]")) {
+      if (currentSection === "inProgress") {
+        session.inProgress.push(trimmed.replace("- [ ]", "").trim());
+      }
+    } else if (trimmed.startsWith("- ")) {
+      const item = trimmed.replace("- ", "").trim();
+      if (currentSection === "notes") {
+        session.notes.push(item);
+      } else if (currentSection === "contextToLoad") {
+        session.contextToLoad.push(item);
+      }
+    }
+  }
+  return session;
+}
+function formatSessionFile(session) {
+  const lines = [];
+  lines.push(`# Session: ${session.date}`);
+  lines.push(`**Date:** ${session.date}`);
+  lines.push(`**Started:** ${session.startedAt}`);
+  lines.push(`**Last Updated:** ${session.lastUpdated}`);
+  lines.push(`**Agent:** ${session.agent}`);
+  lines.push(`**Project:** ${session.projectPath}`);
+  lines.push("");
+  lines.push("## Current State");
+  lines.push("");
+  lines.push("### Completed");
+  for (const task of session.completed) {
+    lines.push(`- [x] ${task}`);
+  }
+  lines.push("");
+  lines.push("### In Progress");
+  for (const task of session.inProgress) {
+    lines.push(`- [ ] ${task}`);
+  }
+  lines.push("");
+  lines.push("### Notes for Next Session");
+  for (const note of session.notes) {
+    lines.push(`- ${note}`);
+  }
+  lines.push("");
+  lines.push("### Context to Load");
+  for (const ctx of session.contextToLoad) {
+    lines.push(`- ${ctx}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function listSessions(limit = 10) {
+  const dir = getSessionsDir();
+  if (!existsSync14(dir)) {
+    return [];
+  }
+  const files = readdirSync4(dir).filter((f) => f.endsWith("-session.md")).sort().reverse().slice(0, limit);
+  const summaries = [];
+  for (const file of files) {
+    const date = file.replace("-session.md", "");
+    const session = loadSessionFile(date);
+    if (session) {
+      summaries.push({
+        date: session.date,
+        projectPath: session.projectPath,
+        agent: session.agent,
+        taskCount: session.completed.length + session.inProgress.length,
+        completedCount: session.completed.length,
+        hasNotes: session.notes.length > 0
+      });
+    }
+  }
+  return summaries;
+}
+function getMostRecentSession() {
+  const summaries = listSessions(1);
+  if (summaries.length === 0) {
+    return null;
+  }
+  return loadSessionFile(summaries[0].date);
+}
+
 // src/workflow/types.ts
 var WORKFLOWS_DIR = "workflows";
 var WORKFLOW_EXTENSION = ".yaml";
+var BUILTIN_PIPELINES = [
+  {
+    id: "feature",
+    name: "Feature Development",
+    description: "Plan \u2192 TDD \u2192 Review \u2192 Security",
+    stages: [
+      { agent: "planner", name: "Planning", description: "Design implementation approach" },
+      { agent: "tdd-guide", name: "TDD", description: "Write tests first, then implement" },
+      { agent: "code-reviewer", name: "Review", description: "Quality and best practices check" },
+      { agent: "security-reviewer", name: "Security", description: "Security audit" }
+    ]
+  },
+  {
+    id: "bugfix",
+    name: "Bug Fix",
+    description: "TDD \u2192 Review",
+    stages: [
+      { agent: "tdd-guide", name: "Fix", description: "Test-first bug fix" },
+      { agent: "code-reviewer", name: "Review", description: "Verify fix quality" }
+    ]
+  },
+  {
+    id: "refactor",
+    name: "Refactoring",
+    description: "Architect \u2192 Review \u2192 TDD",
+    stages: [
+      { agent: "architect", name: "Design", description: "Plan refactoring approach" },
+      { agent: "code-reviewer", name: "Review", description: "Review proposed changes" },
+      { agent: "tdd-guide", name: "Verify", description: "Ensure tests pass after refactor" }
+    ]
+  },
+  {
+    id: "security-audit",
+    name: "Security Audit",
+    description: "Security \u2192 Review \u2192 Fix",
+    stages: [
+      { agent: "security-reviewer", name: "Audit", description: "Identify vulnerabilities" },
+      { agent: "code-reviewer", name: "Review", description: "Review security findings" },
+      { agent: "build-error-resolver", name: "Fix", description: "Apply security fixes" }
+    ]
+  },
+  {
+    id: "documentation",
+    name: "Documentation",
+    description: "Planner \u2192 Doc Updater",
+    stages: [
+      { agent: "planner", name: "Plan", description: "Identify documentation needs" },
+      { agent: "doc-updater", name: "Update", description: "Update documentation" }
+    ]
+  }
+];
+function getBuiltinPipeline(id) {
+  return BUILTIN_PIPELINES.find((p) => p.id === id) || null;
+}
+function getBuiltinPipelines() {
+  return BUILTIN_PIPELINES;
+}
 
 // src/workflow/parser.ts
-import { existsSync as existsSync14, readFileSync as readFileSync9, readdirSync as readdirSync4, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync10, readdirSync as readdirSync5, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8 } from "fs";
+import { join as join14 } from "path";
 import { parse as parse2, stringify as stringify2 } from "yaml";
 function parseWorkflow(content) {
   const data = parse2(content);
@@ -4755,25 +4997,25 @@ function parseWorkflow(content) {
   };
 }
 function loadWorkflow(filePath) {
-  if (!existsSync14(filePath)) {
+  if (!existsSync15(filePath)) {
     throw new Error(`Workflow file not found: ${filePath}`);
   }
-  const content = readFileSync9(filePath, "utf-8");
+  const content = readFileSync10(filePath, "utf-8");
   return parseWorkflow(content);
 }
 function loadWorkflowByName(projectPath, name) {
-  const workflowsDir = join13(projectPath, ".skillkit", WORKFLOWS_DIR);
-  if (!existsSync14(workflowsDir)) {
+  const workflowsDir = join14(projectPath, ".skillkit", WORKFLOWS_DIR);
+  if (!existsSync15(workflowsDir)) {
     return null;
   }
-  const exactPath = join13(workflowsDir, `${name}${WORKFLOW_EXTENSION}`);
-  if (existsSync14(exactPath)) {
+  const exactPath = join14(workflowsDir, `${name}${WORKFLOW_EXTENSION}`);
+  if (existsSync15(exactPath)) {
     return loadWorkflow(exactPath);
   }
-  const files = readdirSync4(workflowsDir).filter((f) => f.endsWith(WORKFLOW_EXTENSION));
+  const files = readdirSync5(workflowsDir).filter((f) => f.endsWith(WORKFLOW_EXTENSION));
   for (const file of files) {
     try {
-      const workflow = loadWorkflow(join13(workflowsDir, file));
+      const workflow = loadWorkflow(join14(workflowsDir, file));
       if (workflow.name === name) {
         return workflow;
       }
@@ -4783,15 +5025,15 @@ function loadWorkflowByName(projectPath, name) {
   return null;
 }
 function listWorkflows(projectPath) {
-  const workflowsDir = join13(projectPath, ".skillkit", WORKFLOWS_DIR);
-  if (!existsSync14(workflowsDir)) {
+  const workflowsDir = join14(projectPath, ".skillkit", WORKFLOWS_DIR);
+  if (!existsSync15(workflowsDir)) {
     return [];
   }
-  const files = readdirSync4(workflowsDir).filter((f) => f.endsWith(WORKFLOW_EXTENSION));
+  const files = readdirSync5(workflowsDir).filter((f) => f.endsWith(WORKFLOW_EXTENSION));
   const workflows = [];
   for (const file of files) {
     try {
-      const workflow = loadWorkflow(join13(workflowsDir, file));
+      const workflow = loadWorkflow(join14(workflowsDir, file));
       workflows.push(workflow);
     } catch {
     }
@@ -4799,13 +5041,13 @@ function listWorkflows(projectPath) {
   return workflows;
 }
 function saveWorkflow(projectPath, workflow) {
-  const workflowsDir = join13(projectPath, ".skillkit", WORKFLOWS_DIR);
-  if (!existsSync14(workflowsDir)) {
-    mkdirSync7(workflowsDir, { recursive: true });
+  const workflowsDir = join14(projectPath, ".skillkit", WORKFLOWS_DIR);
+  if (!existsSync15(workflowsDir)) {
+    mkdirSync8(workflowsDir, { recursive: true });
   }
   const fileName = `${workflow.name.replace(/[^a-z0-9-]/gi, "-").toLowerCase()}${WORKFLOW_EXTENSION}`;
-  const filePath = join13(workflowsDir, fileName);
-  writeFileSync7(filePath, stringify2(workflow));
+  const filePath = join14(workflowsDir, fileName);
+  writeFileSync8(filePath, stringify2(workflow));
   return filePath;
 }
 function serializeWorkflow(workflow) {
@@ -5725,26 +5967,26 @@ To execute this skill manually:
 }
 
 // src/executor/skill-executor.ts
-import { existsSync as existsSync15 } from "fs";
-import { join as join14 } from "path";
-import { homedir as homedir4 } from "os";
+import { existsSync as existsSync16 } from "fs";
+import { join as join15 } from "path";
+import { homedir as homedir5 } from "os";
 function getSearchDirs2(projectPath) {
   const dirs = [];
   for (const searchPath of SKILL_DISCOVERY_PATHS) {
-    const fullPath = join14(projectPath, searchPath);
-    if (existsSync15(fullPath)) {
+    const fullPath = join15(projectPath, searchPath);
+    if (existsSync16(fullPath)) {
       dirs.push(fullPath);
     }
   }
-  const home = homedir4();
+  const home = homedir5();
   const globalPaths = [
-    join14(home, ".claude", "skills"),
-    join14(home, ".cursor", "skills"),
-    join14(home, ".codex", "skills"),
-    join14(home, ".skillkit", "skills")
+    join15(home, ".claude", "skills"),
+    join15(home, ".cursor", "skills"),
+    join15(home, ".codex", "skills"),
+    join15(home, ".skillkit", "skills")
   ];
   for (const globalPath of globalPaths) {
-    if (existsSync15(globalPath)) {
+    if (existsSync16(globalPath)) {
       dirs.push(globalPath);
     }
   }
@@ -5874,8 +6116,8 @@ function createSimulatedSkillExecutor(options = {}) {
 }
 
 // src/testing/runner.ts
-import { existsSync as existsSync16, readFileSync as readFileSync10 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync11 } from "fs";
+import { join as join16 } from "path";
 import { exec } from "child_process";
 import { createServer } from "net";
 import { promisify } from "util";
@@ -5940,8 +6182,8 @@ async function runAssertion(assertion, cwd, timeout) {
   }
 }
 function assertFileExists(assertion, cwd, startTime) {
-  const filePath = join15(cwd, assertion.target || "");
-  const exists = existsSync16(filePath);
+  const filePath = join16(cwd, assertion.target || "");
+  const exists = existsSync17(filePath);
   return {
     assertion,
     passed: exists,
@@ -5952,8 +6194,8 @@ function assertFileExists(assertion, cwd, startTime) {
   };
 }
 function assertFileNotExists(assertion, cwd, startTime) {
-  const filePath = join15(cwd, assertion.target || "");
-  const exists = existsSync16(filePath);
+  const filePath = join16(cwd, assertion.target || "");
+  const exists = existsSync17(filePath);
   return {
     assertion,
     passed: !exists,
@@ -5964,8 +6206,8 @@ function assertFileNotExists(assertion, cwd, startTime) {
   };
 }
 function assertFileContains(assertion, cwd, startTime) {
-  const filePath = join15(cwd, assertion.target || "");
-  if (!existsSync16(filePath)) {
+  const filePath = join16(cwd, assertion.target || "");
+  if (!existsSync17(filePath)) {
     return {
       assertion,
       passed: false,
@@ -5973,7 +6215,7 @@ function assertFileContains(assertion, cwd, startTime) {
       duration: Date.now() - startTime
     };
   }
-  const content = readFileSync10(filePath, "utf-8");
+  const content = readFileSync11(filePath, "utf-8");
   const expected = String(assertion.expected || "");
   const contains = content.includes(expected);
   return {
@@ -5986,8 +6228,8 @@ function assertFileContains(assertion, cwd, startTime) {
   };
 }
 function assertFileNotContains(assertion, cwd, startTime) {
-  const filePath = join15(cwd, assertion.target || "");
-  if (!existsSync16(filePath)) {
+  const filePath = join16(cwd, assertion.target || "");
+  if (!existsSync17(filePath)) {
     return {
       assertion,
       passed: true,
@@ -5995,7 +6237,7 @@ function assertFileNotContains(assertion, cwd, startTime) {
       duration: Date.now() - startTime
     };
   }
-  const content = readFileSync10(filePath, "utf-8");
+  const content = readFileSync11(filePath, "utf-8");
   const expected = String(assertion.expected || "");
   const contains = content.includes(expected);
   return {
@@ -6008,8 +6250,8 @@ function assertFileNotContains(assertion, cwd, startTime) {
   };
 }
 function assertFileMatches(assertion, cwd, startTime) {
-  const filePath = join15(cwd, assertion.target || "");
-  if (!existsSync16(filePath)) {
+  const filePath = join16(cwd, assertion.target || "");
+  if (!existsSync17(filePath)) {
     return {
       assertion,
       passed: false,
@@ -6017,7 +6259,7 @@ function assertFileMatches(assertion, cwd, startTime) {
       duration: Date.now() - startTime
     };
   }
-  const content = readFileSync10(filePath, "utf-8");
+  const content = readFileSync11(filePath, "utf-8");
   const pattern = new RegExp(String(assertion.expected || ""));
   const matches = pattern.test(content);
   return {
@@ -6104,8 +6346,8 @@ async function assertCommandOutputContains(assertion, cwd, timeout, startTime) {
   }
 }
 function assertJsonValid(assertion, cwd, startTime) {
-  const filePath = join15(cwd, assertion.target || "");
-  if (!existsSync16(filePath)) {
+  const filePath = join16(cwd, assertion.target || "");
+  if (!existsSync17(filePath)) {
     return {
       assertion,
       passed: false,
@@ -6114,7 +6356,7 @@ function assertJsonValid(assertion, cwd, startTime) {
     };
   }
   try {
-    const content = readFileSync10(filePath, "utf-8");
+    const content = readFileSync11(filePath, "utf-8");
     JSON.parse(content);
     return {
       assertion,
@@ -6135,8 +6377,8 @@ function assertJsonValid(assertion, cwd, startTime) {
   }
 }
 function assertJsonHasKey(assertion, cwd, startTime) {
-  const filePath = join15(cwd, assertion.target || "");
-  if (!existsSync16(filePath)) {
+  const filePath = join16(cwd, assertion.target || "");
+  if (!existsSync17(filePath)) {
     return {
       assertion,
       passed: false,
@@ -6145,7 +6387,7 @@ function assertJsonHasKey(assertion, cwd, startTime) {
     };
   }
   try {
-    const content = readFileSync10(filePath, "utf-8");
+    const content = readFileSync11(filePath, "utf-8");
     const json = JSON.parse(content);
     const key = String(assertion.expected || "");
     const keys = key.split(".");
@@ -6180,8 +6422,8 @@ function assertJsonHasKey(assertion, cwd, startTime) {
   }
 }
 function assertYamlValid(assertion, cwd, startTime) {
-  const filePath = join15(cwd, assertion.target || "");
-  if (!existsSync16(filePath)) {
+  const filePath = join16(cwd, assertion.target || "");
+  if (!existsSync17(filePath)) {
     return {
       assertion,
       passed: false,
@@ -6190,7 +6432,7 @@ function assertYamlValid(assertion, cwd, startTime) {
     };
   }
   try {
-    const content = readFileSync10(filePath, "utf-8");
+    const content = readFileSync11(filePath, "utf-8");
     parseYaml6(content);
     return {
       assertion,
@@ -6713,9 +6955,9 @@ var MARKETPLACE_CACHE_FILE = "marketplace-index.json";
 var DEFAULT_CACHE_TTL = 60 * 60 * 1e3;
 
 // src/marketplace/aggregator.ts
-import { existsSync as existsSync17, readFileSync as readFileSync11, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8, unlinkSync as unlinkSync2 } from "fs";
-import { join as join16 } from "path";
-import { homedir as homedir5 } from "os";
+import { existsSync as existsSync18, readFileSync as readFileSync12, writeFileSync as writeFileSync9, mkdirSync as mkdirSync9, unlinkSync as unlinkSync2 } from "fs";
+import { join as join17 } from "path";
+import { homedir as homedir6 } from "os";
 var MarketplaceAggregator = class {
   config;
   cacheDir;
@@ -6723,10 +6965,10 @@ var MarketplaceAggregator = class {
   index = null;
   constructor(config = {}) {
     this.config = config;
-    this.cacheDir = config.cacheDir || join16(homedir5(), ".skillkit", "marketplace");
-    this.cachePath = join16(this.cacheDir, MARKETPLACE_CACHE_FILE);
-    if (!existsSync17(this.cacheDir)) {
-      mkdirSync8(this.cacheDir, { recursive: true });
+    this.cacheDir = config.cacheDir || join17(homedir6(), ".skillkit", "marketplace");
+    this.cachePath = join17(this.cacheDir, MARKETPLACE_CACHE_FILE);
+    if (!existsSync18(this.cacheDir)) {
+      mkdirSync9(this.cacheDir, { recursive: true });
     }
   }
   /**
@@ -6739,11 +6981,11 @@ var MarketplaceAggregator = class {
    * Load cached index
    */
   loadCache() {
-    if (!existsSync17(this.cachePath)) {
+    if (!existsSync18(this.cachePath)) {
       return null;
     }
     try {
-      const content = readFileSync11(this.cachePath, "utf-8");
+      const content = readFileSync12(this.cachePath, "utf-8");
       const index = JSON.parse(content);
       const cacheAge = Date.now() - new Date(index.updatedAt).getTime();
       const ttl = this.config.cacheTTL || DEFAULT_CACHE_TTL;
@@ -6760,7 +7002,7 @@ var MarketplaceAggregator = class {
    * Save index to cache
    */
   saveCache(index) {
-    writeFileSync8(this.cachePath, JSON.stringify(index, null, 2));
+    writeFileSync9(this.cachePath, JSON.stringify(index, null, 2));
     this.index = index;
   }
   /**
@@ -7084,7 +7326,7 @@ var MarketplaceAggregator = class {
    * Clear cache
    */
   clearCache() {
-    if (existsSync17(this.cachePath)) {
+    if (existsSync18(this.cachePath)) {
       unlinkSync2(this.cachePath);
     }
     this.index = null;
@@ -7310,8 +7552,8 @@ var DEFAULT_MEMORY_CONFIG = {
 };
 
 // src/memory/observation-store.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync9, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname3, join as join17 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync10, readFileSync as readFileSync13, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname3, join as join18 } from "path";
 import { parse as parseYaml7, stringify as stringifyYaml5 } from "yaml";
 import { randomUUID as randomUUID7 } from "crypto";
 var ObservationStore = class {
@@ -7319,20 +7561,20 @@ var ObservationStore = class {
   data = null;
   sessionId;
   constructor(projectPath, sessionId) {
-    this.filePath = join17(projectPath, ".skillkit", "memory", "observations.yaml");
+    this.filePath = join18(projectPath, ".skillkit", "memory", "observations.yaml");
     this.sessionId = sessionId || randomUUID7();
   }
   ensureDir() {
     const dir = dirname3(this.filePath);
-    if (!existsSync18(dir)) {
-      mkdirSync9(dir, { recursive: true });
+    if (!existsSync19(dir)) {
+      mkdirSync10(dir, { recursive: true });
     }
   }
   load() {
     if (this.data) return this.data;
-    if (existsSync18(this.filePath)) {
+    if (existsSync19(this.filePath)) {
       try {
-        const content = readFileSync12(this.filePath, "utf-8");
+        const content = readFileSync13(this.filePath, "utf-8");
         this.data = parseYaml7(content);
         if (this.data.sessionId !== this.sessionId) {
           this.data.sessionId = this.sessionId;
@@ -7356,7 +7598,7 @@ var ObservationStore = class {
   save() {
     this.ensureDir();
     const content = stringifyYaml5(this.data, { lineWidth: 0 });
-    writeFileSync9(this.filePath, content, "utf-8");
+    writeFileSync10(this.filePath, content, "utf-8");
   }
   add(type, content, agent, relevance = 50) {
     const data = this.load();
@@ -7414,7 +7656,7 @@ var ObservationStore = class {
     }
   }
   exists() {
-    return existsSync18(this.filePath);
+    return existsSync19(this.filePath);
   }
   delete(id) {
     const data = this.load();
@@ -7437,9 +7679,9 @@ var ObservationStore = class {
 };
 
 // src/memory/learning-store.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync10, readFileSync as readFileSync13, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname4, join as join18 } from "path";
-import { homedir as homedir6 } from "os";
+import { existsSync as existsSync20, mkdirSync as mkdirSync11, readFileSync as readFileSync14, writeFileSync as writeFileSync11 } from "fs";
+import { dirname as dirname4, join as join19 } from "path";
+import { homedir as homedir7 } from "os";
 import { parse as parseYaml8, stringify as stringifyYaml6 } from "yaml";
 import { randomUUID as randomUUID8 } from "crypto";
 var LearningStore = class {
@@ -7451,22 +7693,22 @@ var LearningStore = class {
     this.scope = scope;
     this.projectName = projectName;
     if (scope === "project" && projectPath) {
-      this.filePath = join18(projectPath, ".skillkit", "memory", "learnings.yaml");
+      this.filePath = join19(projectPath, ".skillkit", "memory", "learnings.yaml");
     } else {
-      this.filePath = join18(homedir6(), ".skillkit", "memory", "global.yaml");
+      this.filePath = join19(homedir7(), ".skillkit", "memory", "global.yaml");
     }
   }
   ensureDir() {
     const dir = dirname4(this.filePath);
-    if (!existsSync19(dir)) {
-      mkdirSync10(dir, { recursive: true });
+    if (!existsSync20(dir)) {
+      mkdirSync11(dir, { recursive: true });
     }
   }
   load() {
     if (this.data) return this.data;
-    if (existsSync19(this.filePath)) {
+    if (existsSync20(this.filePath)) {
       try {
-        const content = readFileSync13(this.filePath, "utf-8");
+        const content = readFileSync14(this.filePath, "utf-8");
         this.data = parseYaml8(content);
       } catch {
         this.data = this.createEmpty();
@@ -7485,7 +7727,7 @@ var LearningStore = class {
   save() {
     this.ensureDir();
     const content = stringifyYaml6(this.data, { lineWidth: 0 });
-    writeFileSync10(this.filePath, content, "utf-8");
+    writeFileSync11(this.filePath, content, "utf-8");
   }
   add(learning) {
     const data = this.load();
@@ -7592,7 +7834,7 @@ var LearningStore = class {
     this.save();
   }
   exists() {
-    return existsSync19(this.filePath);
+    return existsSync20(this.filePath);
   }
   getScope() {
     return this.scope;
@@ -7600,26 +7842,26 @@ var LearningStore = class {
 };
 
 // src/memory/memory-index.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync11, readFileSync as readFileSync14, writeFileSync as writeFileSync11 } from "fs";
-import { dirname as dirname5, join as join19 } from "path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync12, readFileSync as readFileSync15, writeFileSync as writeFileSync12 } from "fs";
+import { dirname as dirname5, join as join20 } from "path";
 import { parse as parseYaml9, stringify as stringifyYaml7 } from "yaml";
 var MemoryIndexStore = class {
   filePath;
   data = null;
   constructor(basePath, _isGlobal = false) {
-    this.filePath = join19(basePath, ".skillkit", "memory", "index.yaml");
+    this.filePath = join20(basePath, ".skillkit", "memory", "index.yaml");
   }
   ensureDir() {
     const dir = dirname5(this.filePath);
-    if (!existsSync20(dir)) {
-      mkdirSync11(dir, { recursive: true });
+    if (!existsSync21(dir)) {
+      mkdirSync12(dir, { recursive: true });
     }
   }
   load() {
     if (this.data) return this.data;
-    if (existsSync20(this.filePath)) {
+    if (existsSync21(this.filePath)) {
       try {
-        const content = readFileSync14(this.filePath, "utf-8");
+        const content = readFileSync15(this.filePath, "utf-8");
         this.data = parseYaml9(content);
       } catch {
         this.data = this.createEmpty();
@@ -7643,7 +7885,7 @@ var MemoryIndexStore = class {
       this.data.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
     }
     const content = stringifyYaml7(this.data, { lineWidth: 0 });
-    writeFileSync11(this.filePath, content, "utf-8");
+    writeFileSync12(this.filePath, content, "utf-8");
   }
   extractKeywords(text) {
     const stopWords = /* @__PURE__ */ new Set([
@@ -7837,7 +8079,7 @@ var MemoryIndexStore = class {
     this.save();
   }
   exists() {
-    return existsSync20(this.filePath);
+    return existsSync21(this.filePath);
   }
   getStats() {
     const data = this.load();
@@ -7850,50 +8092,50 @@ var MemoryIndexStore = class {
 };
 
 // src/memory/initializer.ts
-import { existsSync as existsSync21, mkdirSync as mkdirSync12 } from "fs";
-import { join as join20 } from "path";
-import { homedir as homedir7 } from "os";
+import { existsSync as existsSync22, mkdirSync as mkdirSync13 } from "fs";
+import { join as join21 } from "path";
+import { homedir as homedir8 } from "os";
 function getMemoryPaths(projectPath) {
-  const projectMemoryDir = join20(projectPath, ".skillkit", "memory");
-  const globalMemoryDir = join20(homedir7(), ".skillkit", "memory");
+  const projectMemoryDir = join21(projectPath, ".skillkit", "memory");
+  const globalMemoryDir = join21(homedir8(), ".skillkit", "memory");
   return {
     projectMemoryDir,
     globalMemoryDir,
-    observationsFile: join20(projectMemoryDir, "observations.yaml"),
-    learningsFile: join20(projectMemoryDir, "learnings.yaml"),
-    indexFile: join20(projectMemoryDir, "index.yaml"),
-    globalLearningsFile: join20(globalMemoryDir, "global.yaml"),
-    globalIndexFile: join20(globalMemoryDir, "index.yaml")
+    observationsFile: join21(projectMemoryDir, "observations.yaml"),
+    learningsFile: join21(projectMemoryDir, "learnings.yaml"),
+    indexFile: join21(projectMemoryDir, "index.yaml"),
+    globalLearningsFile: join21(globalMemoryDir, "global.yaml"),
+    globalIndexFile: join21(globalMemoryDir, "index.yaml")
   };
 }
 function initializeMemoryDirectory(projectPath) {
   const paths = getMemoryPaths(projectPath);
-  if (!existsSync21(paths.projectMemoryDir)) {
-    mkdirSync12(paths.projectMemoryDir, { recursive: true });
+  if (!existsSync22(paths.projectMemoryDir)) {
+    mkdirSync13(paths.projectMemoryDir, { recursive: true });
   }
-  if (!existsSync21(paths.globalMemoryDir)) {
-    mkdirSync12(paths.globalMemoryDir, { recursive: true });
+  if (!existsSync22(paths.globalMemoryDir)) {
+    mkdirSync13(paths.globalMemoryDir, { recursive: true });
   }
   return paths;
 }
 function memoryDirectoryExists(projectPath) {
   const paths = getMemoryPaths(projectPath);
-  return existsSync21(paths.projectMemoryDir);
+  return existsSync22(paths.projectMemoryDir);
 }
 function globalMemoryDirectoryExists() {
-  const globalMemoryDir = join20(homedir7(), ".skillkit", "memory");
-  return existsSync21(globalMemoryDir);
+  const globalMemoryDir = join21(homedir8(), ".skillkit", "memory");
+  return existsSync22(globalMemoryDir);
 }
 function getMemoryStatus(projectPath) {
   const paths = getMemoryPaths(projectPath);
   return {
-    projectMemoryExists: existsSync21(paths.projectMemoryDir),
-    globalMemoryExists: existsSync21(paths.globalMemoryDir),
-    hasObservations: existsSync21(paths.observationsFile),
-    hasLearnings: existsSync21(paths.learningsFile),
-    hasGlobalLearnings: existsSync21(paths.globalLearningsFile),
-    hasIndex: existsSync21(paths.indexFile),
-    hasGlobalIndex: existsSync21(paths.globalIndexFile)
+    projectMemoryExists: existsSync22(paths.projectMemoryDir),
+    globalMemoryExists: existsSync22(paths.globalMemoryDir),
+    hasObservations: existsSync22(paths.observationsFile),
+    hasLearnings: existsSync22(paths.learningsFile),
+    hasGlobalLearnings: existsSync22(paths.globalLearningsFile),
+    hasIndex: existsSync22(paths.indexFile),
+    hasGlobalIndex: existsSync22(paths.globalIndexFile)
   };
 }
 
@@ -8495,7 +8737,7 @@ function wrapProgressCallbackWithMemory(projectPath, existingCallback, memoryCon
 }
 
 // src/memory/compressor.ts
-import { homedir as homedir8 } from "os";
+import { homedir as homedir9 } from "os";
 var DEFAULT_COMPRESSION_OPTIONS = {
   minObservations: 3,
   maxLearnings: 10,
@@ -9090,7 +9332,7 @@ var MemoryCompressor = class {
       projectPath,
       options?.projectName
     );
-    const indexBasePath = options?.scope === "global" ? homedir8() : projectPath;
+    const indexBasePath = options?.scope === "global" ? homedir9() : projectPath;
     this.indexStore = new MemoryIndexStore(indexBasePath, options?.scope === "global");
     this.projectName = options?.projectName;
   }
@@ -9773,8 +10015,8 @@ function createMemoryInjector(projectPath, projectName, projectContext) {
 }
 
 // src/team/manager.ts
-import { existsSync as existsSync22, readFileSync as readFileSync15, writeFileSync as writeFileSync12, mkdirSync as mkdirSync13 } from "fs";
-import { join as join21, dirname as dirname6 } from "path";
+import { existsSync as existsSync23, readFileSync as readFileSync16, writeFileSync as writeFileSync13, mkdirSync as mkdirSync14 } from "fs";
+import { join as join22, dirname as dirname6 } from "path";
 import { execSync as execSync6 } from "child_process";
 import { parse as yamlParse, stringify as yamlStringify } from "yaml";
 var TEAM_CONFIG_FILE = "team.yaml";
@@ -9795,9 +10037,9 @@ var TeamManager = class {
       ...config,
       teamId
     };
-    const teamDir = join21(this.projectPath, TEAM_DIR);
-    if (!existsSync22(teamDir)) {
-      mkdirSync13(teamDir, { recursive: true });
+    const teamDir = join22(this.projectPath, TEAM_DIR);
+    if (!existsSync23(teamDir)) {
+      mkdirSync14(teamDir, { recursive: true });
     }
     this.saveConfig(fullConfig);
     this.config = fullConfig;
@@ -9817,12 +10059,12 @@ var TeamManager = class {
    * Load existing team configuration
    */
   load() {
-    const configPath = join21(this.projectPath, TEAM_DIR, TEAM_CONFIG_FILE);
-    if (!existsSync22(configPath)) {
+    const configPath = join22(this.projectPath, TEAM_DIR, TEAM_CONFIG_FILE);
+    if (!existsSync23(configPath)) {
       return null;
     }
     try {
-      const content = readFileSync15(configPath, "utf-8");
+      const content = readFileSync16(configPath, "utf-8");
       this.config = this.parseYaml(content);
       this.loadRegistry();
       return this.config;
@@ -9853,8 +10095,8 @@ var TeamManager = class {
     if (!skillPath) {
       throw new Error(`Skill "${options.skillName}" not found locally.`);
     }
-    const skillMdPath = join21(skillPath, "SKILL.md");
-    const skillContent = existsSync22(skillMdPath) ? readFileSync15(skillMdPath, "utf-8") : "";
+    const skillMdPath = join22(skillPath, "SKILL.md");
+    const skillContent = existsSync23(skillMdPath) ? readFileSync16(skillMdPath, "utf-8") : "";
     const metadata = this.extractFrontmatter(skillContent);
     const shared = {
       name: options.skillName,
@@ -9919,7 +10161,7 @@ var TeamManager = class {
     if (options.dryRun) {
       return {
         success: true,
-        path: join21(this.projectPath, ".skillkit", "skills", skillName)
+        path: join22(this.projectPath, ".skillkit", "skills", skillName)
       };
     }
     try {
@@ -9969,9 +10211,9 @@ var TeamManager = class {
       if (!fetchResult.success || !fetchResult.path) {
         throw new Error(fetchResult.error || "Failed to fetch remote registry");
       }
-      const remoteRegistryPath = join21(fetchResult.path, TEAM_DIR, "registry.yaml");
-      if (existsSync22(remoteRegistryPath)) {
-        const remoteContent = readFileSync15(remoteRegistryPath, "utf-8");
+      const remoteRegistryPath = join22(fetchResult.path, TEAM_DIR, "registry.yaml");
+      if (existsSync23(remoteRegistryPath)) {
+        const remoteContent = readFileSync16(remoteRegistryPath, "utf-8");
         const remoteRegistry = this.parseYaml(remoteContent);
         const localSkillNames = new Set(this.registry?.skills.map((s) => s.name) || []);
         for (const skill of remoteRegistry.skills) {
@@ -10017,32 +10259,32 @@ var TeamManager = class {
     return `team-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
   }
   saveConfig(config) {
-    const configPath = join21(this.projectPath, TEAM_DIR, TEAM_CONFIG_FILE);
+    const configPath = join22(this.projectPath, TEAM_DIR, TEAM_CONFIG_FILE);
     const dir = dirname6(configPath);
-    if (!existsSync22(dir)) {
-      mkdirSync13(dir, { recursive: true });
+    if (!existsSync23(dir)) {
+      mkdirSync14(dir, { recursive: true });
     }
-    writeFileSync12(configPath, this.toYaml(config), "utf-8");
+    writeFileSync13(configPath, this.toYaml(config), "utf-8");
   }
   loadRegistry() {
-    const registryPath = join21(this.projectPath, TEAM_DIR, "registry.yaml");
-    if (existsSync22(registryPath)) {
-      const content = readFileSync15(registryPath, "utf-8");
+    const registryPath = join22(this.projectPath, TEAM_DIR, "registry.yaml");
+    if (existsSync23(registryPath)) {
+      const content = readFileSync16(registryPath, "utf-8");
       this.registry = this.parseYaml(content);
     }
   }
   saveRegistry(registry) {
-    const registryPath = join21(this.projectPath, TEAM_DIR, "registry.yaml");
-    writeFileSync12(registryPath, this.toYaml(registry), "utf-8");
+    const registryPath = join22(this.projectPath, TEAM_DIR, "registry.yaml");
+    writeFileSync13(registryPath, this.toYaml(registry), "utf-8");
   }
   findLocalSkill(skillName) {
     const possiblePaths = [
-      join21(this.projectPath, ".skillkit", "skills", skillName),
-      join21(this.projectPath, "skills", skillName),
-      join21(this.projectPath, ".claude", "skills", skillName)
+      join22(this.projectPath, ".skillkit", "skills", skillName),
+      join22(this.projectPath, "skills", skillName),
+      join22(this.projectPath, ".claude", "skills", skillName)
     ];
     for (const p of possiblePaths) {
-      if (existsSync22(p)) {
+      if (existsSync23(p)) {
         return p;
       }
     }
@@ -10059,13 +10301,13 @@ var TeamManager = class {
   }
   detectCompatibleAgents(skillPath) {
     const agents = [];
-    if (existsSync22(join21(skillPath, "SKILL.md"))) {
+    if (existsSync23(join22(skillPath, "SKILL.md"))) {
       agents.push("claude-code", "codex", "gemini-cli", "universal");
     }
-    if (existsSync22(join21(skillPath, "skill.mdc"))) {
+    if (existsSync23(join22(skillPath, "skill.mdc"))) {
       agents.push("cursor");
     }
-    if (existsSync22(join21(skillPath, "rules.md"))) {
+    if (existsSync23(join22(skillPath, "rules.md"))) {
       agents.push("windsurf");
     }
     return agents.length > 0 ? agents : ["universal"];
@@ -10091,8 +10333,8 @@ function createTeamManager(projectPath) {
 }
 
 // src/team/bundle.ts
-import { existsSync as existsSync23, readFileSync as readFileSync16, writeFileSync as writeFileSync13, mkdirSync as mkdirSync14, readdirSync as readdirSync5, statSync as statSync3 } from "fs";
-import { join as join22, basename as basename8, resolve as resolve2, relative, dirname as dirname7, sep } from "path";
+import { existsSync as existsSync24, readFileSync as readFileSync17, writeFileSync as writeFileSync14, mkdirSync as mkdirSync15, readdirSync as readdirSync6, statSync as statSync3 } from "fs";
+import { join as join23, basename as basename8, resolve as resolve2, relative, dirname as dirname7, sep } from "path";
 import { createHash } from "crypto";
 var BUNDLE_VERSION = 1;
 var SkillBundle = class {
@@ -10174,15 +10416,15 @@ var SkillBundle = class {
   readSkillContent(skillPath) {
     const contents = [];
     const readDir = (dir, prefix = "") => {
-      const entries = readdirSync5(dir);
+      const entries = readdirSync6(dir);
       for (const entry of entries) {
-        const fullPath = join22(dir, entry);
+        const fullPath = join23(dir, entry);
         const relativePath = prefix ? `${prefix}/${entry}` : entry;
         const stat = statSync3(fullPath);
         if (stat.isDirectory()) {
           readDir(fullPath, relativePath);
         } else if (stat.isFile()) {
-          const content = readFileSync16(fullPath, "utf-8");
+          const content = readFileSync17(fullPath, "utf-8");
           contents.push(`--- ${relativePath} ---
 ${content}`);
         }
@@ -10191,13 +10433,13 @@ ${content}`);
     if (statSync3(skillPath).isDirectory()) {
       readDir(skillPath);
     } else {
-      contents.push(readFileSync16(skillPath, "utf-8"));
+      contents.push(readFileSync17(skillPath, "utf-8"));
     }
     return contents.join("\n\n");
   }
   detectAgents(skillPath) {
     const agents = [];
-    if (existsSync23(skillPath) && statSync3(skillPath).isFile()) {
+    if (existsSync24(skillPath) && statSync3(skillPath).isFile()) {
       const fileName = basename8(skillPath).toLowerCase();
       if (fileName === "skill.md") {
         return ["claude-code", "codex", "gemini-cli", "universal"];
@@ -10210,13 +10452,13 @@ ${content}`);
       }
       return ["universal"];
     }
-    if (existsSync23(join22(skillPath, "SKILL.md"))) {
+    if (existsSync24(join23(skillPath, "SKILL.md"))) {
       agents.push("claude-code", "codex", "gemini-cli", "universal");
     }
-    if (existsSync23(join22(skillPath, "skill.mdc"))) {
+    if (existsSync24(join23(skillPath, "skill.mdc"))) {
       agents.push("cursor");
     }
-    if (existsSync23(join22(skillPath, "rules.md"))) {
+    if (existsSync24(join23(skillPath, "rules.md"))) {
       agents.push("windsurf");
     }
     return agents.length > 0 ? agents : ["universal"];
@@ -10239,10 +10481,10 @@ function exportBundle(bundle, outputPath) {
       }
     }
     const dir = dirname7(outputPath);
-    if (dir && !existsSync23(dir)) {
-      mkdirSync14(dir, { recursive: true });
+    if (dir && !existsSync24(dir)) {
+      mkdirSync15(dir, { recursive: true });
     }
-    writeFileSync13(outputPath, JSON.stringify(exportData, null, 2), "utf-8");
+    writeFileSync14(outputPath, JSON.stringify(exportData, null, 2), "utf-8");
     return { success: true, path: outputPath };
   } catch (err) {
     return {
@@ -10255,7 +10497,7 @@ function importBundle(bundlePath, targetDir, options = {}) {
   const imported = [];
   const errors = [];
   try {
-    const content = readFileSync16(bundlePath, "utf-8");
+    const content = readFileSync17(bundlePath, "utf-8");
     const data = JSON.parse(content);
     const absoluteTargetDir = resolve2(targetDir);
     for (const skill of data.manifest.skills) {
@@ -10268,19 +10510,19 @@ function importBundle(bundlePath, targetDir, options = {}) {
         errors.push(`Skill "${skill.name}" has no content in bundle`);
         continue;
       }
-      const skillDir = join22(absoluteTargetDir, skill.name);
+      const skillDir = join23(absoluteTargetDir, skill.name);
       const resolvedSkillDir = resolve2(skillDir);
       const relativeToTarget = relative(absoluteTargetDir, resolvedSkillDir);
       if (relativeToTarget.startsWith("..") || relativeToTarget.startsWith(sep)) {
         errors.push(`Skill "${skill.name}" would escape target directory`);
         continue;
       }
-      if (existsSync23(skillDir) && !options.overwrite) {
+      if (existsSync24(skillDir) && !options.overwrite) {
         errors.push(`Skill "${skill.name}" already exists (use --overwrite)`);
         continue;
       }
-      if (!existsSync23(skillDir)) {
-        mkdirSync14(skillDir, { recursive: true });
+      if (!existsSync24(skillDir)) {
+        mkdirSync15(skillDir, { recursive: true });
       }
       const files = parseSkillContent2(skillContent);
       for (const [filePath, fileContent] of Object.entries(files)) {
@@ -10291,10 +10533,10 @@ function importBundle(bundlePath, targetDir, options = {}) {
           continue;
         }
         const fileDir = dirname7(fullPath);
-        if (!existsSync23(fileDir)) {
-          mkdirSync14(fileDir, { recursive: true });
+        if (!existsSync24(fileDir)) {
+          mkdirSync15(fileDir, { recursive: true });
         }
-        writeFileSync13(fullPath, fileContent, "utf-8");
+        writeFileSync14(fullPath, fileContent, "utf-8");
       }
       imported.push(skill.name);
     }
@@ -10323,8 +10565,8 @@ function parseSkillContent2(content) {
 }
 
 // src/plugins/manager.ts
-import { existsSync as existsSync24, readFileSync as readFileSync17, writeFileSync as writeFileSync14, mkdirSync as mkdirSync15 } from "fs";
-import { join as join23 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync18, writeFileSync as writeFileSync15, mkdirSync as mkdirSync16 } from "fs";
+import { join as join24 } from "path";
 var PLUGINS_DIR = ".skillkit/plugins";
 var PLUGINS_CONFIG_FILE = "plugins.json";
 var PluginManager = class {
@@ -10565,22 +10807,22 @@ var PluginManager = class {
   }
   // Private helpers
   loadState() {
-    const statePath = join23(this.projectPath, PLUGINS_DIR, PLUGINS_CONFIG_FILE);
-    if (existsSync24(statePath)) {
+    const statePath = join24(this.projectPath, PLUGINS_DIR, PLUGINS_CONFIG_FILE);
+    if (existsSync25(statePath)) {
       try {
-        return JSON.parse(readFileSync17(statePath, "utf-8"));
+        return JSON.parse(readFileSync18(statePath, "utf-8"));
       } catch {
       }
     }
     return { version: 1, plugins: {} };
   }
   saveState() {
-    const pluginsDir = join23(this.projectPath, PLUGINS_DIR);
-    if (!existsSync24(pluginsDir)) {
-      mkdirSync15(pluginsDir, { recursive: true });
+    const pluginsDir = join24(this.projectPath, PLUGINS_DIR);
+    if (!existsSync25(pluginsDir)) {
+      mkdirSync16(pluginsDir, { recursive: true });
     }
-    const statePath = join23(pluginsDir, PLUGINS_CONFIG_FILE);
-    writeFileSync14(statePath, JSON.stringify(this.state, null, 2), "utf-8");
+    const statePath = join24(pluginsDir, PLUGINS_CONFIG_FILE);
+    writeFileSync15(statePath, JSON.stringify(this.state, null, 2), "utf-8");
   }
   createContext() {
     return {
@@ -10605,15 +10847,15 @@ function createPluginManager(projectPath) {
 }
 
 // src/plugins/loader.ts
-import { existsSync as existsSync25, readFileSync as readFileSync18, readdirSync as readdirSync6, statSync as statSync4 } from "fs";
-import { join as join24, extname, basename as basename9, isAbsolute } from "path";
+import { existsSync as existsSync26, readFileSync as readFileSync19, readdirSync as readdirSync7, statSync as statSync4 } from "fs";
+import { join as join25, extname, basename as basename9, isAbsolute } from "path";
 import { pathToFileURL } from "url";
 var PluginLoader = class {
   /**
    * Load a plugin from a file path
    */
   async loadFromFile(filePath) {
-    if (!existsSync25(filePath)) {
+    if (!existsSync26(filePath)) {
       throw new Error(`Plugin file not found: ${filePath}`);
     }
     const ext = extname(filePath);
@@ -10655,11 +10897,11 @@ var PluginLoader = class {
    * Load a plugin from a JSON definition (for simple plugins)
    */
   loadFromJson(jsonPath) {
-    if (!existsSync25(jsonPath)) {
+    if (!existsSync26(jsonPath)) {
       throw new Error(`Plugin JSON not found: ${jsonPath}`);
     }
     try {
-      const content = readFileSync18(jsonPath, "utf-8");
+      const content = readFileSync19(jsonPath, "utf-8");
       const data = JSON.parse(content);
       if (!data.metadata) {
         throw new Error("Invalid plugin JSON: missing metadata");
@@ -10678,13 +10920,13 @@ var PluginLoader = class {
    * Scan a directory for plugins
    */
   async scanDirectory(dirPath) {
-    if (!existsSync25(dirPath)) {
+    if (!existsSync26(dirPath)) {
       return [];
     }
     const plugins = [];
-    const entries = readdirSync6(dirPath);
+    const entries = readdirSync7(dirPath);
     for (const entry of entries) {
-      const fullPath = join24(dirPath, entry);
+      const fullPath = join25(dirPath, entry);
       let stat;
       try {
         stat = statSync4(fullPath);
@@ -10692,11 +10934,11 @@ var PluginLoader = class {
         continue;
       }
       if (stat.isDirectory()) {
-        const pkgPath = join24(fullPath, "package.json");
-        const pluginPath = join24(fullPath, "plugin.json");
-        if (existsSync25(pkgPath)) {
+        const pkgPath = join25(fullPath, "package.json");
+        const pluginPath = join25(fullPath, "plugin.json");
+        if (existsSync26(pkgPath)) {
           try {
-            const pkg = JSON.parse(readFileSync18(pkgPath, "utf-8"));
+            const pkg = JSON.parse(readFileSync19(pkgPath, "utf-8"));
             if ((pkg.skillkitPlugin || pkg.keywords?.includes("skillkit-plugin")) && pkg.name && typeof pkg.name === "string" && pkg.version && typeof pkg.version === "string") {
               plugins.push({
                 name: pkg.name,
@@ -10708,9 +10950,9 @@ var PluginLoader = class {
             }
           } catch {
           }
-        } else if (existsSync25(pluginPath)) {
+        } else if (existsSync26(pluginPath)) {
           try {
-            const data = JSON.parse(readFileSync18(pluginPath, "utf-8"));
+            const data = JSON.parse(readFileSync19(pluginPath, "utf-8"));
             if (data.metadata && data.metadata.name && typeof data.metadata.name === "string" && data.metadata.version && typeof data.metadata.version === "string") {
               plugins.push(data.metadata);
             }
@@ -10798,12 +11040,12 @@ async function loadPlugin(source) {
 async function loadPluginsFromDirectory(dirPath) {
   const loader = new PluginLoader();
   const plugins = [];
-  if (!existsSync25(dirPath)) {
+  if (!existsSync26(dirPath)) {
     return plugins;
   }
-  const entries = readdirSync6(dirPath);
+  const entries = readdirSync7(dirPath);
   for (const entry of entries) {
-    const fullPath = join24(dirPath, entry);
+    const fullPath = join25(dirPath, entry);
     let stat;
     try {
       stat = statSync4(fullPath);
@@ -10812,20 +11054,20 @@ async function loadPluginsFromDirectory(dirPath) {
     }
     try {
       if (stat.isDirectory()) {
-        const indexMjsPath = join24(fullPath, "index.mjs");
-        const indexPath = join24(fullPath, "index.js");
-        const mainMjsPath = join24(fullPath, "plugin.mjs");
-        const mainPath = join24(fullPath, "plugin.js");
-        const jsonPath = join24(fullPath, "plugin.json");
-        if (existsSync25(indexMjsPath)) {
+        const indexMjsPath = join25(fullPath, "index.mjs");
+        const indexPath = join25(fullPath, "index.js");
+        const mainMjsPath = join25(fullPath, "plugin.mjs");
+        const mainPath = join25(fullPath, "plugin.js");
+        const jsonPath = join25(fullPath, "plugin.json");
+        if (existsSync26(indexMjsPath)) {
           plugins.push(await loader.loadFromFile(indexMjsPath));
-        } else if (existsSync25(indexPath)) {
+        } else if (existsSync26(indexPath)) {
           plugins.push(await loader.loadFromFile(indexPath));
-        } else if (existsSync25(mainMjsPath)) {
+        } else if (existsSync26(mainMjsPath)) {
           plugins.push(await loader.loadFromFile(mainMjsPath));
-        } else if (existsSync25(mainPath)) {
+        } else if (existsSync26(mainPath)) {
           plugins.push(await loader.loadFromFile(mainPath));
-        } else if (existsSync25(jsonPath)) {
+        } else if (existsSync26(jsonPath)) {
           plugins.push(loader.loadFromJson(jsonPath));
         }
       } else if (stat.isFile()) {
@@ -10844,17 +11086,17 @@ async function loadPluginsFromDirectory(dirPath) {
 }
 
 // src/methodology/manager.ts
-import { existsSync as existsSync28, readFileSync as readFileSync21, writeFileSync as writeFileSync15, mkdirSync as mkdirSync16 } from "fs";
-import { join as join27, dirname as dirname9 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync22, writeFileSync as writeFileSync16, mkdirSync as mkdirSync17 } from "fs";
+import { join as join28, dirname as dirname9 } from "path";
 
 // src/methodology/loader.ts
-import { existsSync as existsSync27, readFileSync as readFileSync20, readdirSync as readdirSync8, statSync as statSync6 } from "fs";
-import { join as join26, dirname as dirname8 } from "path";
+import { existsSync as existsSync28, readFileSync as readFileSync21, readdirSync as readdirSync9, statSync as statSync6 } from "fs";
+import { join as join27, dirname as dirname8 } from "path";
 import { fileURLToPath } from "url";
 
 // src/methodology/validator.ts
-import { existsSync as existsSync26, readFileSync as readFileSync19, readdirSync as readdirSync7, statSync as statSync5 } from "fs";
-import { join as join25 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync20, readdirSync as readdirSync8, statSync as statSync5 } from "fs";
+import { join as join26 } from "path";
 function validatePackManifest(pack) {
   const errors = [];
   const warnings = [];
@@ -11004,15 +11246,15 @@ function validateSkillContent(content) {
 function validatePackDirectory(packPath) {
   const errors = [];
   const warnings = [];
-  if (!existsSync26(packPath)) {
+  if (!existsSync27(packPath)) {
     errors.push({
       code: "DIR_NOT_FOUND",
       message: `Pack directory not found: ${packPath}`
     });
     return { valid: false, errors, warnings };
   }
-  const manifestPath = join25(packPath, "pack.json");
-  if (!existsSync26(manifestPath)) {
+  const manifestPath = join26(packPath, "pack.json");
+  if (!existsSync27(manifestPath)) {
     errors.push({
       code: "MANIFEST_NOT_FOUND",
       message: "Pack must have a pack.json manifest",
@@ -11022,7 +11264,7 @@ function validatePackDirectory(packPath) {
   }
   let manifest;
   try {
-    const raw = readFileSync19(manifestPath, "utf-8");
+    const raw = readFileSync20(manifestPath, "utf-8");
     manifest = JSON.parse(raw);
     const manifestResult = validatePackManifest(manifest);
     errors.push(...manifestResult.errors);
@@ -11037,8 +11279,8 @@ function validatePackDirectory(packPath) {
   }
   if (manifest.skills) {
     for (const skillName of manifest.skills) {
-      const skillDir = join25(packPath, skillName);
-      if (!existsSync26(skillDir)) {
+      const skillDir = join26(packPath, skillName);
+      if (!existsSync27(skillDir)) {
         errors.push({
           code: "SKILL_DIR_NOT_FOUND",
           message: `Skill directory not found: ${skillName}`,
@@ -11054,8 +11296,8 @@ function validatePackDirectory(packPath) {
         });
         continue;
       }
-      const skillFile = join25(skillDir, "SKILL.md");
-      if (!existsSync26(skillFile)) {
+      const skillFile = join26(skillDir, "SKILL.md");
+      if (!existsSync27(skillFile)) {
         errors.push({
           code: "SKILL_FILE_NOT_FOUND",
           message: `Skill must have a SKILL.md file: ${skillName}`,
@@ -11063,7 +11305,7 @@ function validatePackDirectory(packPath) {
         });
         continue;
       }
-      const skillContent = readFileSync19(skillFile, "utf-8");
+      const skillContent = readFileSync20(skillFile, "utf-8");
       const skillResult = validateSkillContent(skillContent);
       for (const err of skillResult.errors) {
         errors.push({
@@ -11087,15 +11329,15 @@ function validatePackDirectory(packPath) {
 }
 function validateBuiltinPacks(packsDir) {
   const results = /* @__PURE__ */ new Map();
-  if (!existsSync26(packsDir)) {
+  if (!existsSync27(packsDir)) {
     return results;
   }
-  const packDirs = readdirSync7(packsDir).filter((name) => {
-    const packPath = join25(packsDir, name);
+  const packDirs = readdirSync8(packsDir).filter((name) => {
+    const packPath = join26(packsDir, name);
     return statSync5(packPath).isDirectory();
   });
   for (const packName of packDirs) {
-    const packPath = join25(packsDir, packName);
+    const packPath = join26(packsDir, packName);
     results.set(packName, validatePackDirectory(packPath));
   }
   return results;
@@ -11154,7 +11396,7 @@ function extractSkillMetadata(content) {
 // src/methodology/loader.ts
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname8(__filename);
-var BUILTIN_PACKS_DIR = join26(__dirname, "packs");
+var BUILTIN_PACKS_DIR = join27(__dirname, "packs");
 var MethodologyLoader = class {
   packsDir;
   loadedPacks = /* @__PURE__ */ new Map();
@@ -11167,11 +11409,11 @@ var MethodologyLoader = class {
    */
   async loadAllPacks() {
     const packs = [];
-    if (!existsSync27(this.packsDir)) {
+    if (!existsSync28(this.packsDir)) {
       return packs;
     }
-    const packDirs = readdirSync8(this.packsDir).filter((name) => {
-      const packPath = join26(this.packsDir, name);
+    const packDirs = readdirSync9(this.packsDir).filter((name) => {
+      const packPath = join27(this.packsDir, name);
       return statSync6(packPath).isDirectory();
     });
     for (const packName of packDirs) {
@@ -11192,9 +11434,9 @@ var MethodologyLoader = class {
     if (this.loadedPacks.has(packName)) {
       return this.loadedPacks.get(packName);
     }
-    const packPath = join26(this.packsDir, packName);
-    const manifestPath = join26(packPath, "pack.json");
-    if (!existsSync27(manifestPath)) {
+    const packPath = join27(this.packsDir, packName);
+    const manifestPath = join27(packPath, "pack.json");
+    if (!existsSync28(manifestPath)) {
       return null;
     }
     const validation = validatePackDirectory(packPath);
@@ -11204,7 +11446,7 @@ var MethodologyLoader = class {
       );
     }
     const manifest = JSON.parse(
-      readFileSync20(manifestPath, "utf-8")
+      readFileSync21(manifestPath, "utf-8")
     );
     this.loadedPacks.set(packName, manifest);
     return manifest;
@@ -11234,11 +11476,11 @@ var MethodologyLoader = class {
     if (this.loadedSkills.has(skillId)) {
       return this.loadedSkills.get(skillId);
     }
-    const skillPath = join26(this.packsDir, packName, skillName, "SKILL.md");
-    if (!existsSync27(skillPath)) {
+    const skillPath = join27(this.packsDir, packName, skillName, "SKILL.md");
+    if (!existsSync28(skillPath)) {
       return null;
     }
-    const content = readFileSync20(skillPath, "utf-8");
+    const content = readFileSync21(skillPath, "utf-8");
     const rawMetadata = extractSkillMetadata(content);
     const metadata = {
       triggers: rawMetadata.triggers,
@@ -11317,9 +11559,9 @@ var MethodologyLoader = class {
    * Check if a pack exists
    */
   packExists(packName) {
-    const packPath = join26(this.packsDir, packName);
-    const manifestPath = join26(packPath, "pack.json");
-    return existsSync27(manifestPath);
+    const packPath = join27(this.packsDir, packName);
+    const manifestPath = join27(packPath, "pack.json");
+    return existsSync28(manifestPath);
   }
   /**
    * Clear cache
@@ -11685,10 +11927,10 @@ var MethodologyManager = class {
   }
   // Private helpers
   loadState() {
-    const statePath = join27(this.projectPath, METHODOLOGY_STATE_FILE);
-    if (existsSync28(statePath)) {
+    const statePath = join28(this.projectPath, METHODOLOGY_STATE_FILE);
+    if (existsSync29(statePath)) {
       try {
-        return JSON.parse(readFileSync21(statePath, "utf-8"));
+        return JSON.parse(readFileSync22(statePath, "utf-8"));
       } catch {
       }
     }
@@ -11699,21 +11941,21 @@ var MethodologyManager = class {
     };
   }
   saveState() {
-    const statePath = join27(this.projectPath, METHODOLOGY_STATE_FILE);
+    const statePath = join28(this.projectPath, METHODOLOGY_STATE_FILE);
     const dir = dirname9(statePath);
-    if (!existsSync28(dir)) {
-      mkdirSync16(dir, { recursive: true });
+    if (!existsSync29(dir)) {
+      mkdirSync17(dir, { recursive: true });
     }
-    writeFileSync15(statePath, JSON.stringify(this.state, null, 2), "utf-8");
+    writeFileSync16(statePath, JSON.stringify(this.state, null, 2), "utf-8");
   }
   async installSkillLocally(skill) {
-    const skillsDir = join27(this.projectPath, ".skillkit", "methodology", "skills");
-    const skillDir = join27(skillsDir, skill.pack, skill.id.split("/")[1]);
-    if (!existsSync28(skillDir)) {
-      mkdirSync16(skillDir, { recursive: true });
+    const skillsDir = join28(this.projectPath, ".skillkit", "methodology", "skills");
+    const skillDir = join28(skillsDir, skill.pack, skill.id.split("/")[1]);
+    if (!existsSync29(skillDir)) {
+      mkdirSync17(skillDir, { recursive: true });
     }
-    const targetPath = join27(skillDir, "SKILL.md");
-    writeFileSync15(targetPath, skill.content, "utf-8");
+    const targetPath = join28(skillDir, "SKILL.md");
+    writeFileSync16(targetPath, skill.content, "utf-8");
   }
   async removeSkillLocally(_skillId) {
   }
@@ -11741,9 +11983,9 @@ var MethodologyManager = class {
     if (!agentDir) {
       throw new Error(`Unknown agent: ${agent}`);
     }
-    const skillsDir = join27(this.projectPath, agentDir);
-    if (!existsSync28(skillsDir)) {
-      mkdirSync16(skillsDir, { recursive: true });
+    const skillsDir = join28(this.projectPath, agentDir);
+    if (!existsSync29(skillsDir)) {
+      mkdirSync17(skillsDir, { recursive: true });
     }
     const skillName = skillId.split("/")[1];
     let filename;
@@ -11754,8 +11996,8 @@ var MethodologyManager = class {
     } else {
       filename = `${skillName}.md`;
     }
-    const targetPath = join27(skillsDir, filename);
-    writeFileSync15(targetPath, content, "utf-8");
+    const targetPath = join28(skillsDir, filename);
+    writeFileSync16(targetPath, content, "utf-8");
   }
   detectAgents() {
     const agents = [];
@@ -11778,7 +12020,7 @@ var MethodologyManager = class {
       ["windsurf", ".windsurf"]
     ];
     for (const [agent, dir] of agentDirs) {
-      if (existsSync28(join27(this.projectPath, dir))) {
+      if (existsSync29(join28(this.projectPath, dir))) {
         agents.push(agent);
       }
     }
@@ -11791,8 +12033,8 @@ function createMethodologyManager(options) {
 }
 
 // src/hooks/manager.ts
-import { existsSync as existsSync29, readFileSync as readFileSync22, writeFileSync as writeFileSync16, mkdirSync as mkdirSync17 } from "fs";
-import { join as join28, dirname as dirname10 } from "path";
+import { existsSync as existsSync30, readFileSync as readFileSync23, writeFileSync as writeFileSync17, mkdirSync as mkdirSync18 } from "fs";
+import { join as join29, dirname as dirname10 } from "path";
 import { randomUUID as randomUUID9 } from "crypto";
 import { minimatch } from "minimatch";
 var DEFAULT_CONFIG_PATH = ".skillkit/hooks.json";
@@ -11803,7 +12045,7 @@ var HookManager = class {
   constructor(options) {
     this.options = {
       projectPath: options.projectPath,
-      configPath: options.configPath || join28(options.projectPath, DEFAULT_CONFIG_PATH),
+      configPath: options.configPath || join29(options.projectPath, DEFAULT_CONFIG_PATH),
       autoLoad: options.autoLoad ?? true,
       defaultInjectionMode: options.defaultInjectionMode || "reference"
     };
@@ -11943,11 +12185,11 @@ var HookManager = class {
    * Load hooks from config file
    */
   load() {
-    if (!existsSync29(this.options.configPath)) {
+    if (!existsSync30(this.options.configPath)) {
       return;
     }
     try {
-      const content = readFileSync22(this.options.configPath, "utf-8");
+      const content = readFileSync23(this.options.configPath, "utf-8");
       const config = JSON.parse(content);
       this.hooks.clear();
       for (const hook of config.hooks) {
@@ -11975,10 +12217,10 @@ var HookManager = class {
       }
     };
     const dir = dirname10(this.options.configPath);
-    if (!existsSync29(dir)) {
-      mkdirSync17(dir, { recursive: true });
+    if (!existsSync30(dir)) {
+      mkdirSync18(dir, { recursive: true });
     }
-    writeFileSync16(this.options.configPath, JSON.stringify(config, null, 2));
+    writeFileSync17(this.options.configPath, JSON.stringify(config, null, 2));
   }
   /**
    * Generate agent-specific hook configuration
@@ -12220,7 +12462,7 @@ function createHookManager(options) {
 
 // src/hooks/triggers.ts
 import { watch } from "fs";
-import { join as join29, relative as relative2 } from "path";
+import { join as join30, relative as relative2 } from "path";
 function debounce(fn, delay) {
   let timeoutId = null;
   return (...args) => {
@@ -12405,7 +12647,7 @@ var SkillTriggerEngine = class {
         { recursive: true },
         debounce((eventType, filename) => {
           if (!filename) return;
-          const relativePath = relative2(this.options.projectPath, join29(this.options.projectPath, filename));
+          const relativePath = relative2(this.options.projectPath, join30(this.options.projectPath, filename));
           if (this.shouldIgnore(relativePath)) return;
           if (eventType === "rename") {
             this.triggerFileCreate(relativePath);
@@ -14839,8 +15081,8 @@ var shellExecutor = async (step, _task, _plan) => {
     return { success: true, output: "No command to execute" };
   }
   try {
-    const { execSync: execSync7 } = await import("child_process");
-    const output = execSync7(step.command, { encoding: "utf-8", timeout: 6e4 });
+    const { execSync: execSync8 } = await import("child_process");
+    const output = execSync8(step.command, { encoding: "utf-8", timeout: 6e4 });
     if (step.expectedOutput && !output.includes(step.expectedOutput)) {
       return {
         success: false,
@@ -16502,8 +16744,8 @@ var CUSTOM_AGENT_FORMAT_MAP = {
 };
 
 // src/agents/parser.ts
-import { existsSync as existsSync30, readFileSync as readFileSync23, statSync as statSync7 } from "fs";
-import { join as join30, basename as basename10, extname as extname2 } from "path";
+import { existsSync as existsSync31, readFileSync as readFileSync24, statSync as statSync7 } from "fs";
+import { join as join31, basename as basename10, extname as extname2 } from "path";
 import { parse as parseYaml10 } from "yaml";
 function extractAgentFrontmatter(content) {
   const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
@@ -16521,14 +16763,14 @@ function extractAgentContent(content) {
   return withoutFrontmatter.trim();
 }
 function parseAgentFile(filePath, location = "project") {
-  if (!existsSync30(filePath)) {
+  if (!existsSync31(filePath)) {
     return null;
   }
   if (extname2(filePath) !== ".md") {
     return null;
   }
   try {
-    const content = readFileSync23(filePath, "utf-8");
+    const content = readFileSync24(filePath, "utf-8");
     const rawFrontmatter = extractAgentFrontmatter(content);
     const agentContent = extractAgentContent(content);
     if (!rawFrontmatter) {
@@ -16580,16 +16822,16 @@ function parseAgentFile(filePath, location = "project") {
   }
 }
 function parseAgentDir(dirPath, location = "project") {
-  const agentMdPath = join30(dirPath, "AGENT.md");
-  if (existsSync30(agentMdPath)) {
+  const agentMdPath = join31(dirPath, "AGENT.md");
+  if (existsSync31(agentMdPath)) {
     const agent = parseAgentFile(agentMdPath, location);
     if (agent) {
       agent.path = dirPath;
     }
     return agent;
   }
-  const indexMdPath = join30(dirPath, "index.md");
-  if (existsSync30(indexMdPath)) {
+  const indexMdPath = join31(dirPath, "index.md");
+  if (existsSync31(indexMdPath)) {
     const agent = parseAgentFile(indexMdPath, location);
     if (agent) {
       agent.path = dirPath;
@@ -16599,11 +16841,11 @@ function parseAgentDir(dirPath, location = "project") {
   return null;
 }
 function loadAgentMetadata(metadataPath) {
-  if (!existsSync30(metadataPath)) {
+  if (!existsSync31(metadataPath)) {
     return null;
   }
   try {
-    const content = readFileSync23(metadataPath, "utf-8");
+    const content = readFileSync24(metadataPath, "utf-8");
     const data = JSON.parse(content);
     const parsed = AgentMetadata.safeParse(data);
     return parsed.success ? parsed.data : null;
@@ -16704,25 +16946,25 @@ function fromCanonicalAgent(canonical, _targetFormat = "claude-agent") {
   return lines.join("\n");
 }
 function readAgentContent(agentPath) {
-  if (existsSync30(agentPath) && extname2(agentPath) === ".md") {
+  if (existsSync31(agentPath) && extname2(agentPath) === ".md") {
     try {
-      return readFileSync23(agentPath, "utf-8");
+      return readFileSync24(agentPath, "utf-8");
     } catch {
       return null;
     }
   }
-  const agentMdPath = join30(agentPath, "AGENT.md");
-  if (existsSync30(agentMdPath)) {
+  const agentMdPath = join31(agentPath, "AGENT.md");
+  if (existsSync31(agentMdPath)) {
     try {
-      return readFileSync23(agentMdPath, "utf-8");
+      return readFileSync24(agentMdPath, "utf-8");
     } catch {
       return null;
     }
   }
-  const indexMdPath = join30(agentPath, "index.md");
-  if (existsSync30(indexMdPath)) {
+  const indexMdPath = join31(agentPath, "index.md");
+  if (existsSync31(indexMdPath)) {
     try {
-      return readFileSync23(indexMdPath, "utf-8");
+      return readFileSync24(indexMdPath, "utf-8");
     } catch {
       return null;
     }
@@ -16733,17 +16975,17 @@ function validateAgent(agentPath) {
   const errors = [];
   const warnings = [];
   let filePath = agentPath;
-  if (!existsSync30(agentPath)) {
+  if (!existsSync31(agentPath)) {
     errors.push(`Agent file not found: ${agentPath}`);
     return { valid: false, errors, warnings };
   }
   const stats = statSync7(agentPath);
   if (stats.isDirectory()) {
-    const agentMd = join30(agentPath, "AGENT.md");
-    const indexMd = join30(agentPath, "index.md");
-    if (existsSync30(agentMd)) {
+    const agentMd = join31(agentPath, "AGENT.md");
+    const indexMd = join31(agentPath, "index.md");
+    if (existsSync31(agentMd)) {
       filePath = agentMd;
-    } else if (existsSync30(indexMd)) {
+    } else if (existsSync31(indexMd)) {
       filePath = indexMd;
     } else {
       errors.push("Directory must contain AGENT.md or index.md");
@@ -16752,7 +16994,7 @@ function validateAgent(agentPath) {
   }
   let content;
   try {
-    content = readFileSync23(filePath, "utf-8");
+    content = readFileSync24(filePath, "utf-8");
   } catch {
     errors.push(`Cannot read file: ${filePath}`);
     return { valid: false, errors, warnings };
@@ -16789,18 +17031,18 @@ function validateAgent(agentPath) {
 }
 
 // src/agents/discovery.ts
-import { existsSync as existsSync31, readdirSync as readdirSync9, statSync as statSync8 } from "fs";
-import { join as join31, extname as extname3 } from "path";
-import { homedir as homedir9 } from "os";
+import { existsSync as existsSync32, readdirSync as readdirSync10, statSync as statSync8 } from "fs";
+import { join as join32, extname as extname3 } from "path";
+import { homedir as homedir10 } from "os";
 function discoverAgentsInDir(dir, location) {
   const agents = [];
-  if (!existsSync31(dir)) {
+  if (!existsSync32(dir)) {
     return agents;
   }
   try {
-    const entries = readdirSync9(dir, { withFileTypes: true });
+    const entries = readdirSync10(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const entryPath = join31(dir, entry.name);
+      const entryPath = join32(dir, entry.name);
       if (entry.isFile() && extname3(entry.name) === ".md") {
         const agent = parseAgentFile(entryPath, location);
         if (agent) {
@@ -16821,8 +17063,8 @@ function discoverAgents(rootDir) {
   const agents = [];
   const seen = /* @__PURE__ */ new Set();
   for (const searchPath of ALL_AGENT_DISCOVERY_PATHS) {
-    const fullPath = join31(rootDir, searchPath);
-    if (existsSync31(fullPath)) {
+    const fullPath = join32(rootDir, searchPath);
+    if (existsSync32(fullPath)) {
       for (const agent of discoverAgentsInDir(fullPath, "project")) {
         if (!seen.has(agent.name)) {
           seen.add(agent.name);
@@ -16838,8 +17080,8 @@ function discoverAgentsForAgent(rootDir, agentType) {
   const seen = /* @__PURE__ */ new Set();
   const paths = AGENT_DISCOVERY_PATHS[agentType] || [];
   for (const searchPath of paths) {
-    const fullPath = join31(rootDir, searchPath);
-    if (existsSync31(fullPath)) {
+    const fullPath = join32(rootDir, searchPath);
+    if (existsSync32(fullPath)) {
       for (const agent of discoverAgentsInDir(fullPath, "project")) {
         if (!seen.has(agent.name)) {
           seen.add(agent.name);
@@ -16853,14 +17095,14 @@ function discoverAgentsForAgent(rootDir, agentType) {
 function discoverGlobalAgents() {
   const agents = [];
   const seen = /* @__PURE__ */ new Set();
-  const home = homedir9();
+  const home = homedir10();
   const globalPaths = [
-    join31(home, ".claude", "agents"),
-    join31(home, ".skillkit", "agents"),
-    join31(home, ".config", "skillkit", "agents")
+    join32(home, ".claude", "agents"),
+    join32(home, ".skillkit", "agents"),
+    join32(home, ".config", "skillkit", "agents")
   ];
   for (const searchPath of globalPaths) {
-    if (existsSync31(searchPath)) {
+    if (existsSync32(searchPath)) {
       for (const agent of discoverAgentsInDir(searchPath, "global")) {
         if (!seen.has(agent.name)) {
           seen.add(agent.name);
@@ -16875,7 +17117,7 @@ function findAllAgents(searchDirs) {
   const agents = [];
   const seen = /* @__PURE__ */ new Set();
   for (const dir of searchDirs) {
-    if (!existsSync31(dir)) continue;
+    if (!existsSync32(dir)) continue;
     const discovered = discoverAgents(dir);
     for (const agent of discovered) {
       if (!seen.has(agent.name)) {
@@ -16894,33 +17136,33 @@ function findAllAgents(searchDirs) {
 }
 function findAgent(name, searchDirs) {
   for (const dir of searchDirs) {
-    if (!existsSync31(dir)) continue;
+    if (!existsSync32(dir)) continue;
     for (const searchPath of ALL_AGENT_DISCOVERY_PATHS) {
-      const agentsDir = join31(dir, searchPath);
-      if (!existsSync31(agentsDir)) continue;
-      const agentFile = join31(agentsDir, `${name}.md`);
-      if (existsSync31(agentFile)) {
+      const agentsDir = join32(dir, searchPath);
+      if (!existsSync32(agentsDir)) continue;
+      const agentFile = join32(agentsDir, `${name}.md`);
+      if (existsSync32(agentFile)) {
         return parseAgentFile(agentFile, "project");
       }
-      const agentDir = join31(agentsDir, name);
-      if (existsSync31(agentDir) && statSync8(agentDir).isDirectory()) {
+      const agentDir = join32(agentsDir, name);
+      if (existsSync32(agentDir) && statSync8(agentDir).isDirectory()) {
         return parseAgentDir(agentDir, "project");
       }
     }
   }
-  const home = homedir9();
+  const home = homedir10();
   const globalPaths = [
-    join31(home, ".claude", "agents"),
-    join31(home, ".skillkit", "agents")
+    join32(home, ".claude", "agents"),
+    join32(home, ".skillkit", "agents")
   ];
   for (const agentsDir of globalPaths) {
-    if (!existsSync31(agentsDir)) continue;
-    const agentFile = join31(agentsDir, `${name}.md`);
-    if (existsSync31(agentFile)) {
+    if (!existsSync32(agentsDir)) continue;
+    const agentFile = join32(agentsDir, `${name}.md`);
+    if (existsSync32(agentFile)) {
       return parseAgentFile(agentFile, "global");
     }
-    const agentDir = join31(agentsDir, name);
-    if (existsSync31(agentDir) && statSync8(agentDir).isDirectory()) {
+    const agentDir = join32(agentsDir, name);
+    if (existsSync32(agentDir) && statSync8(agentDir).isDirectory()) {
       return parseAgentDir(agentDir, "global");
     }
   }
@@ -16929,9 +17171,9 @@ function findAgent(name, searchDirs) {
 function getAgentsDirectory(rootDir, agentType) {
   const paths = AGENT_DISCOVERY_PATHS[agentType];
   if (paths && paths.length > 0) {
-    return join31(rootDir, paths[0]);
+    return join32(rootDir, paths[0]);
   }
-  return join31(rootDir, "agents");
+  return join32(rootDir, "agents");
 }
 function agentExists(name, searchDirs) {
   return findAgent(name, searchDirs) !== null;
@@ -16949,14 +17191,14 @@ function getAgentStats(searchDirs) {
 function discoverAgentsRecursive(rootDir, location = "project") {
   const agents = [];
   const seen = /* @__PURE__ */ new Set();
-  if (!existsSync31(rootDir)) {
+  if (!existsSync32(rootDir)) {
     return agents;
   }
   function scanDirectory(dir) {
     try {
-      const entries = readdirSync9(dir, { withFileTypes: true });
+      const entries = readdirSync10(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const entryPath = join31(dir, entry.name);
+        const entryPath = join32(dir, entry.name);
         if (entry.isFile() && extname3(entry.name) === ".md") {
           const agent = parseAgentFile(entryPath, location);
           if (agent && !seen.has(agent.name)) {
@@ -16983,7 +17225,7 @@ function discoverAgentsRecursive(rootDir, location = "project") {
   return agents;
 }
 function discoverAgentsFromPath(sourcePath, recursive = false, location = "project") {
-  if (!existsSync31(sourcePath)) {
+  if (!existsSync32(sourcePath)) {
     return [];
   }
   const stats = statSync8(sourcePath);
@@ -17004,9 +17246,9 @@ function discoverAgentsFromPath(sourcePath, recursive = false, location = "proje
     }
     const agents = [];
     try {
-      const entries = readdirSync9(sourcePath, { withFileTypes: true });
+      const entries = readdirSync10(sourcePath, { withFileTypes: true });
       for (const entry of entries) {
-        const entryPath = join31(sourcePath, entry.name);
+        const entryPath = join32(sourcePath, entry.name);
         if (entry.isFile() && extname3(entry.name) === ".md") {
           const a = parseAgentFile(entryPath, location);
           if (a) agents.push(a);
@@ -17023,7 +17265,7 @@ function discoverAgentsFromPath(sourcePath, recursive = false, location = "proje
 }
 
 // src/agents/translator.ts
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 function translateAgent(agent, targetAgent, options) {
   const canonical = toCanonicalAgent(agent);
   return translateCanonicalAgent(canonical, targetAgent, options);
@@ -17244,9 +17486,9 @@ function getAgentFilename(agentName, targetAgent) {
 function getAgentTargetDirectory(rootDir, targetAgent) {
   const paths = AGENT_DISCOVERY_PATHS[targetAgent];
   if (paths && paths.length > 0) {
-    return join32(rootDir, paths[0]);
+    return join33(rootDir, paths[0]);
   }
-  return join32(rootDir, "agents");
+  return join33(rootDir, "agents");
 }
 function escapeYamlString(str) {
   if (/[:\{\}\[\],&*#?|\-<>=!%@`]/.test(str) || str.includes("\n")) {
@@ -17281,8 +17523,8 @@ function isAgentCompatible(sourceFormat, targetFormat) {
 }
 
 // src/skill-translator.ts
-import { readFileSync as readFileSync24, existsSync as existsSync32, writeFileSync as writeFileSync17, mkdirSync as mkdirSync18 } from "fs";
-import { join as join33, basename as basename11, dirname as dirname11, resolve as resolve3, relative as relative3, isAbsolute as isAbsolute2 } from "path";
+import { readFileSync as readFileSync25, existsSync as existsSync33, writeFileSync as writeFileSync18, mkdirSync as mkdirSync19 } from "fs";
+import { join as join34, basename as basename11, dirname as dirname11, resolve as resolve3, relative as relative3, isAbsolute as isAbsolute2 } from "path";
 import { parse as parseYaml11, stringify as stringifyYaml8 } from "yaml";
 var AGENT_SKILL_FORMATS = Object.fromEntries(
   Object.entries(AGENT_CONFIG).map(([agent, config]) => [
@@ -17291,12 +17533,12 @@ var AGENT_SKILL_FORMATS = Object.fromEntries(
   ])
 );
 function parseSkillToCanonical(skillPath, sourceAgent) {
-  const skillMdPath = skillPath.endsWith("SKILL.md") ? skillPath : join33(skillPath, "SKILL.md");
-  if (!existsSync32(skillMdPath)) {
+  const skillMdPath = skillPath.endsWith("SKILL.md") ? skillPath : join34(skillPath, "SKILL.md");
+  if (!existsSync33(skillMdPath)) {
     return null;
   }
   try {
-    const content = readFileSync24(skillMdPath, "utf-8");
+    const content = readFileSync25(skillMdPath, "utf-8");
     return parseSkillContentToCanonical(content, skillPath, sourceAgent);
   } catch {
     return null;
@@ -17384,7 +17626,7 @@ function translateSkillToAgent(canonical, targetAgent, options) {
   }
   const content = generateSkillContent(canonical, targetAgent, format, options);
   const filename = options?.outputFilename || "SKILL.md";
-  const targetDir = options?.outputDir || join33(format.skillsDir, canonical.name);
+  const targetDir = options?.outputDir || join34(format.skillsDir, canonical.name);
   return {
     success: true,
     content,
@@ -17532,7 +17774,7 @@ function writeTranslatedSkill(result, rootDir, options) {
         error: "Resolved output path escapes rootDir"
       };
     }
-    if (existsSync32(filePath) && options?.overwrite === false) {
+    if (existsSync33(filePath) && options?.overwrite === false) {
       return {
         success: false,
         path: filePath,
@@ -17540,10 +17782,10 @@ function writeTranslatedSkill(result, rootDir, options) {
         skipped: true
       };
     }
-    if (!existsSync32(targetPath)) {
-      mkdirSync18(targetPath, { recursive: true });
+    if (!existsSync33(targetPath)) {
+      mkdirSync19(targetPath, { recursive: true });
     }
-    writeFileSync17(filePath, result.content, "utf-8");
+    writeFileSync18(filePath, result.content, "utf-8");
     return { success: true, path: filePath };
   } catch (error) {
     return {
@@ -17726,16 +17968,16 @@ var getAgentSkillsDir = getSkillsDir;
 var getAgentConfigFile = getConfigFile;
 
 // src/manifest/index.ts
-import { readFileSync as readFileSync25, writeFileSync as writeFileSync18, existsSync as existsSync33 } from "fs";
-import { join as join34, dirname as dirname12 } from "path";
+import { readFileSync as readFileSync26, writeFileSync as writeFileSync19, existsSync as existsSync34 } from "fs";
+import { join as join35, dirname as dirname12 } from "path";
 import { parse as parseYaml12, stringify as stringifyYaml9 } from "yaml";
 var MANIFEST_FILENAMES = [".skills", ".skills.yaml", ".skills.yml", "skills.yaml"];
 function findManifestPath(startDir = process.cwd()) {
   let dir = startDir;
   while (dir !== dirname12(dir)) {
     for (const filename of MANIFEST_FILENAMES) {
-      const manifestPath = join34(dir, filename);
-      if (existsSync33(manifestPath)) {
+      const manifestPath = join35(dir, filename);
+      if (existsSync34(manifestPath)) {
         return manifestPath;
       }
     }
@@ -17745,11 +17987,11 @@ function findManifestPath(startDir = process.cwd()) {
 }
 function loadManifest(manifestPath) {
   const path2 = manifestPath || findManifestPath();
-  if (!path2 || !existsSync33(path2)) {
+  if (!path2 || !existsSync34(path2)) {
     return null;
   }
   try {
-    const content = readFileSync25(path2, "utf-8");
+    const content = readFileSync26(path2, "utf-8");
     const parsed = parseYaml12(content);
     if (!parsed || typeof parsed !== "object") {
       return null;
@@ -17791,7 +18033,7 @@ function normalizeSkills(skills) {
   }).filter((s) => s.source);
 }
 function saveManifest(manifest, manifestPath) {
-  const path2 = manifestPath || join34(process.cwd(), ".skills");
+  const path2 = manifestPath || join35(process.cwd(), ".skills");
   const content = stringifyYaml9({
     version: manifest.version || 1,
     skills: manifest.skills.map((s) => {
@@ -17804,7 +18046,7 @@ function saveManifest(manifest, manifestPath) {
     ...manifest.installMethod && { installMethod: manifest.installMethod },
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
-  writeFileSync18(path2, content, "utf-8");
+  writeFileSync19(path2, content, "utf-8");
 }
 function addToManifest(source, options, manifestPath) {
   const existing = loadManifest(manifestPath) || {
@@ -17881,8 +18123,8 @@ function generateManifestFromInstalled(installedSkills) {
 }
 
 // src/quality/index.ts
-import { readFileSync as readFileSync26, existsSync as existsSync34 } from "fs";
-import { join as join35, basename as basename12 } from "path";
+import { readFileSync as readFileSync27, existsSync as existsSync35 } from "fs";
+import { join as join36, basename as basename12 } from "path";
 
 // src/quality/benchmark.ts
 var CATEGORY_BENCHMARKS = {
@@ -18484,23 +18726,23 @@ function evaluateSkillContent(content) {
   };
 }
 function evaluateSkillFile(filePath) {
-  if (!existsSync34(filePath)) return null;
+  if (!existsSync35(filePath)) return null;
   try {
-    const content = readFileSync26(filePath, "utf-8");
+    const content = readFileSync27(filePath, "utf-8");
     return evaluateSkillContent(content);
   } catch {
     return null;
   }
 }
 function evaluateSkillDirectory(dirPath) {
-  const skillMdPath = join35(dirPath, "SKILL.md");
-  if (existsSync34(skillMdPath)) {
+  const skillMdPath = join36(dirPath, "SKILL.md");
+  if (existsSync35(skillMdPath)) {
     return evaluateSkillFile(skillMdPath);
   }
   const mdcFiles = ["index.mdc", `${basename12(dirPath)}.mdc`];
   for (const file of mdcFiles) {
-    const mdcPath = join35(dirPath, file);
-    if (existsSync34(mdcPath)) {
+    const mdcPath = join36(dirPath, file);
+    if (existsSync35(mdcPath)) {
       return evaluateSkillFile(mdcPath);
     }
   }
@@ -18670,8 +18912,8 @@ var AGENT_INSTRUCTION_TEMPLATES = {
 };
 
 // src/primer/analyzer.ts
-import { existsSync as existsSync35, readFileSync as readFileSync27, readdirSync as readdirSync10 } from "fs";
-import { join as join36, basename as basename13, relative as relative4, sep as sep2 } from "path";
+import { existsSync as existsSync36, readFileSync as readFileSync28, readdirSync as readdirSync11 } from "fs";
+import { join as join37, basename as basename13, relative as relative4, sep as sep2 } from "path";
 var PACKAGE_MANAGER_FILES = {
   "package-lock.json": "npm",
   "pnpm-lock.yaml": "pnpm",
@@ -18759,10 +19001,10 @@ var PrimerAnalyzer = class {
     return analysis;
   }
   loadPackageJson() {
-    const packageJsonPath = join36(this.projectPath, "package.json");
-    if (existsSync35(packageJsonPath)) {
+    const packageJsonPath = join37(this.projectPath, "package.json");
+    if (existsSync36(packageJsonPath)) {
       try {
-        const content = readFileSync27(packageJsonPath, "utf-8");
+        const content = readFileSync28(packageJsonPath, "utf-8");
         this.packageJson = JSON.parse(content);
       } catch {
         this.packageJson = null;
@@ -18773,9 +19015,9 @@ var PrimerAnalyzer = class {
     const scan = (dir, depth) => {
       if (depth > maxDepth) return;
       try {
-        const entries = readdirSync10(dir, { withFileTypes: true });
+        const entries = readdirSync11(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = join36(dir, entry.name);
+          const fullPath = join37(dir, entry.name);
           const relativePath = relative4(this.projectPath, fullPath);
           if (entry.name.startsWith(".") && entry.name !== ".github" && entry.name !== ".env.example") {
             if (!entry.isDirectory()) {
@@ -18820,10 +19062,10 @@ var PrimerAnalyzer = class {
         info.repository = String(repo.url);
       }
     }
-    const pyprojectPath = join36(this.projectPath, "pyproject.toml");
-    if (!this.packageJson && existsSync35(pyprojectPath)) {
+    const pyprojectPath = join37(this.projectPath, "pyproject.toml");
+    if (!this.packageJson && existsSync36(pyprojectPath)) {
       try {
-        const content = readFileSync27(pyprojectPath, "utf-8");
+        const content = readFileSync28(pyprojectPath, "utf-8");
         const nameMatch = content.match(/name\s*=\s*["']([^"']+)["']/);
         const versionMatch = content.match(/version\s*=\s*["']([^"']+)["']/);
         const descMatch = content.match(/description\s*=\s*["']([^"']+)["']/);
@@ -18833,10 +19075,10 @@ var PrimerAnalyzer = class {
       } catch {
       }
     }
-    const cargoPath = join36(this.projectPath, "Cargo.toml");
-    if (!this.packageJson && existsSync35(cargoPath)) {
+    const cargoPath = join37(this.projectPath, "Cargo.toml");
+    if (!this.packageJson && existsSync36(cargoPath)) {
       try {
-        const content = readFileSync27(cargoPath, "utf-8");
+        const content = readFileSync28(cargoPath, "utf-8");
         const nameMatch = content.match(/name\s*=\s*["']([^"']+)["']/);
         const versionMatch = content.match(/version\s*=\s*["']([^"']+)["']/);
         const descMatch = content.match(/description\s*=\s*["']([^"']+)["']/);
@@ -19016,8 +19258,8 @@ var PrimerAnalyzer = class {
     }
     if (this.hasFile("tsconfig.json")) {
       try {
-        const tsconfigPath = join36(this.projectPath, "tsconfig.json");
-        const content = readFileSync27(tsconfigPath, "utf-8");
+        const tsconfigPath = join37(this.projectPath, "tsconfig.json");
+        const content = readFileSync28(tsconfigPath, "utf-8");
         const tsconfig = JSON.parse(content.replace(/\/\/.*$/gm, "").replace(/,\s*}/g, "}"));
         const paths = tsconfig.compilerOptions?.paths;
         if (paths && Object.keys(paths).some((k) => k.startsWith("@"))) {
@@ -19046,8 +19288,8 @@ var PrimerAnalyzer = class {
       ci.provider = "github-actions";
       ci.configFile = ".github/workflows";
       try {
-        const workflowsDir = join36(this.projectPath, ".github/workflows");
-        const workflows = readdirSync10(workflowsDir);
+        const workflowsDir = join37(this.projectPath, ".github/workflows");
+        const workflows = readdirSync11(workflowsDir);
         const deployWorkflows = workflows.filter(
           (f) => f.includes("deploy") || f.includes("release") || f.includes("publish")
         );
@@ -19067,12 +19309,12 @@ var PrimerAnalyzer = class {
     env.hasEnvFile = this.hasFile(".env");
     env.hasEnvExample = this.hasFile(".env.example") || this.hasFile(".env.template") || this.hasFile(".env.sample");
     if (env.hasEnvExample) {
-      const envExamplePath = join36(
+      const envExamplePath = join37(
         this.projectPath,
         this.hasFile(".env.example") ? ".env.example" : this.hasFile(".env.template") ? ".env.template" : ".env.sample"
       );
       try {
-        const content = readFileSync27(envExamplePath, "utf-8");
+        const content = readFileSync28(envExamplePath, "utf-8");
         const variables = content.split("\n").filter((line) => line.trim() && !line.startsWith("#")).map((line) => line.split("=")[0].trim()).filter((v) => v);
         env.envVariables = variables;
       } catch {
@@ -19089,8 +19331,8 @@ var PrimerAnalyzer = class {
     docker.hasCompose = this.hasFile("docker-compose.yml") || this.hasFile("docker-compose.yaml") || this.hasFile("compose.yml");
     if (docker.hasDockerfile) {
       try {
-        const dockerfilePath = join36(this.projectPath, "Dockerfile");
-        const content = readFileSync27(dockerfilePath, "utf-8");
+        const dockerfilePath = join37(this.projectPath, "Dockerfile");
+        const content = readFileSync28(dockerfilePath, "utf-8");
         const fromMatch = content.match(/^FROM\s+(\S+)/m);
         if (fromMatch) {
           docker.baseImage = fromMatch[1];
@@ -19179,7 +19421,7 @@ var PrimerAnalyzer = class {
       }
       return false;
     }
-    return this.files.has(name) || existsSync35(join36(this.projectPath, name));
+    return this.files.has(name) || existsSync36(join37(this.projectPath, name));
   }
   getDepVersion(dep) {
     if (!this.packageJson) return void 0;
@@ -19201,10 +19443,10 @@ var PrimerAnalyzer = class {
   }
   readConfigFile(files) {
     for (const file of files) {
-      const filePath = join36(this.projectPath, file);
-      if (existsSync35(filePath)) {
+      const filePath = join37(this.projectPath, file);
+      if (existsSync36(filePath)) {
         try {
-          const content = readFileSync27(filePath, "utf-8");
+          const content = readFileSync28(filePath, "utf-8");
           if (file.endsWith(".json")) {
             return JSON.parse(content);
           }
@@ -19222,8 +19464,8 @@ function analyzePrimer(projectPath) {
 }
 
 // src/primer/generator.ts
-import { existsSync as existsSync36, mkdirSync as mkdirSync19, writeFileSync as writeFileSync19 } from "fs";
-import { join as join37, dirname as dirname13 } from "path";
+import { existsSync as existsSync37, mkdirSync as mkdirSync20, writeFileSync as writeFileSync20 } from "fs";
+import { join as join38, dirname as dirname13 } from "path";
 var ALL_AGENTS = Object.keys(AGENT_CONFIG);
 var markdownRenderer = {
   h1: (text) => `# ${text}`,
@@ -19255,9 +19497,9 @@ ${code}
   separator: () => "",
   wrap: (content, metadata) => {
     if (metadata && Object.keys(metadata).length > 0) {
-      const yaml = Object.entries(metadata).map(([k, v]) => `${k}: ${JSON.stringify(v)}`).join("\n");
+      const yaml4 = Object.entries(metadata).map(([k, v]) => `${k}: ${JSON.stringify(v)}`).join("\n");
       return `---
-${yaml}
+${yaml4}
 ---
 
 ${content}`;
@@ -19387,14 +19629,14 @@ var PrimerGenerator = class {
   detectInstalledAgents() {
     const detected = [];
     for (const [agent, config] of Object.entries(AGENT_CONFIG)) {
-      const configPath = join37(this.projectPath, config.configFile);
-      const skillsPath = join37(this.projectPath, config.skillsDir);
-      if (existsSync36(configPath) || existsSync36(skillsPath)) {
+      const configPath = join38(this.projectPath, config.configFile);
+      const skillsPath = join38(this.projectPath, config.skillsDir);
+      if (existsSync37(configPath) || existsSync37(skillsPath)) {
         detected.push(agent);
       }
       if (config.altSkillsDirs) {
         for (const altDir of config.altSkillsDirs) {
-          if (existsSync36(join37(this.projectPath, altDir))) {
+          if (existsSync37(join38(this.projectPath, altDir))) {
             if (!detected.includes(agent)) {
               detected.push(agent);
             }
@@ -19414,7 +19656,7 @@ var PrimerGenerator = class {
     const template = AGENT_INSTRUCTION_TEMPLATES[agent] || this.getDefaultTemplate(agent, config);
     const content = this.generateContent(template);
     const outputDir = this.options.outputDir || this.projectPath;
-    const filepath = join37(outputDir, template.filename);
+    const filepath = join38(outputDir, template.filename);
     return {
       agent,
       filename: template.filename,
@@ -19787,10 +20029,10 @@ var PrimerGenerator = class {
   }
   writeInstruction(instruction) {
     const dir = dirname13(instruction.filepath);
-    if (!existsSync36(dir)) {
-      mkdirSync19(dir, { recursive: true });
+    if (!existsSync37(dir)) {
+      mkdirSync20(dir, { recursive: true });
     }
-    writeFileSync19(instruction.filepath, instruction.content, "utf-8");
+    writeFileSync20(instruction.filepath, instruction.content, "utf-8");
   }
   formatProjectType(type) {
     const typeMap = {
@@ -19820,6 +20062,1408 @@ function analyzeForPrimer(projectPath) {
   const result = generator.generate();
   return result.analysis;
 }
+
+// src/learning/types.ts
+var DEFAULT_LEARNING_CONFIG = {
+  minSessionLength: 10,
+  sensitivity: "medium",
+  autoApprove: false,
+  outputPath: "~/.skillkit/learned/",
+  categories: ["error_fix", "refactor", "workaround", "debugging", "convention"],
+  ignorePatterns: ["trivial_typo", "one_off_fix", "wip", "merge"]
+};
+
+// src/learning/config.ts
+import { existsSync as existsSync38, readFileSync as readFileSync29, writeFileSync as writeFileSync21, mkdirSync as mkdirSync21 } from "fs";
+import { join as join39, dirname as dirname14 } from "path";
+import { homedir as homedir11 } from "os";
+import yaml from "yaml";
+function getDefaultConfigPath() {
+  return join39(homedir11(), ".skillkit", "learning.yaml");
+}
+function getDefaultStorePath() {
+  return join39(homedir11(), ".skillkit", "learned", "patterns.json");
+}
+function loadLearningConfig(configPath) {
+  const path2 = configPath || getDefaultConfigPath();
+  if (!existsSync38(path2)) {
+    return DEFAULT_LEARNING_CONFIG;
+  }
+  try {
+    const content = readFileSync29(path2, "utf-8");
+    const config = yaml.parse(content);
+    return { ...DEFAULT_LEARNING_CONFIG, ...config };
+  } catch {
+    return DEFAULT_LEARNING_CONFIG;
+  }
+}
+function saveLearningConfig(config, configPath) {
+  const path2 = configPath || getDefaultConfigPath();
+  const dir = dirname14(path2);
+  if (!existsSync38(dir)) {
+    mkdirSync21(dir, { recursive: true });
+  }
+  const content = yaml.stringify(config);
+  writeFileSync21(path2, content);
+}
+function loadPatternStore(storePath) {
+  const path2 = storePath || getDefaultStorePath();
+  if (!existsSync38(path2)) {
+    return {
+      version: 1,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      patterns: [],
+      evolvingPatterns: []
+    };
+  }
+  try {
+    const content = readFileSync29(path2, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {
+      version: 1,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      patterns: [],
+      evolvingPatterns: []
+    };
+  }
+}
+function savePatternStore(store, storePath) {
+  const path2 = storePath || getDefaultStorePath();
+  const dir = dirname14(path2);
+  if (!existsSync38(dir)) {
+    mkdirSync21(dir, { recursive: true });
+  }
+  store.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const content = JSON.stringify(store, null, 2);
+  writeFileSync21(path2, content);
+}
+function addPattern(pattern, storePath) {
+  const store = loadPatternStore(storePath);
+  const existingIndex = store.patterns.findIndex((p) => p.id === pattern.id);
+  if (existingIndex >= 0) {
+    store.patterns[existingIndex] = pattern;
+  } else {
+    store.patterns.push(pattern);
+  }
+  savePatternStore(store, storePath);
+  return store;
+}
+function removePattern(patternId, storePath) {
+  const store = loadPatternStore(storePath);
+  store.patterns = store.patterns.filter((p) => p.id !== patternId);
+  store.evolvingPatterns = store.evolvingPatterns.filter((p) => p.id !== patternId);
+  savePatternStore(store, storePath);
+  return store;
+}
+function getPattern(patternId, storePath) {
+  const store = loadPatternStore(storePath);
+  return store.patterns.find((p) => p.id === patternId) || null;
+}
+function getEvolvingPattern(patternId, storePath) {
+  const store = loadPatternStore(storePath);
+  return store.evolvingPatterns.find((p) => p.id === patternId) || null;
+}
+function getAllPatterns(storePath) {
+  const store = loadPatternStore(storePath);
+  return store.patterns;
+}
+function getPatternsByCategory(category, storePath) {
+  const store = loadPatternStore(storePath);
+  return store.patterns.filter((p) => p.category === category);
+}
+function getApprovedPatterns(storePath) {
+  const store = loadPatternStore(storePath);
+  return store.patterns.filter((p) => p.approved);
+}
+
+// src/learning/git-analyzer.ts
+import { execSync as execSync7 } from "child_process";
+import { existsSync as existsSync39 } from "fs";
+import { join as join40 } from "path";
+function runGitCommand(command, cwd) {
+  try {
+    return execSync7(command, { cwd, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 });
+  } catch {
+    return "";
+  }
+}
+function isGitRepository(path2) {
+  return existsSync39(join40(path2, ".git"));
+}
+function getGitCommits(repoPath, options = {}) {
+  if (!isGitRepository(repoPath)) {
+    return [];
+  }
+  const limit = options.commits || 100;
+  const args = [
+    "log",
+    `--max-count=${limit}`,
+    "--format=%H|||%h|||%an|||%aI|||%s|||%b|||END_COMMIT",
+    "--name-status"
+  ];
+  if (options.since) {
+    args.push(`--since="${options.since}"`);
+  }
+  if (options.until) {
+    args.push(`--until="${options.until}"`);
+  }
+  if (options.branch) {
+    args.push(options.branch);
+  }
+  if (options.author) {
+    args.push(`--author="${options.author}"`);
+  }
+  const output = runGitCommand(`git ${args.join(" ")}`, repoPath);
+  if (!output) return [];
+  const commits = [];
+  const commitBlocks = output.split("END_COMMIT").filter((b) => b.trim());
+  for (const block of commitBlocks) {
+    const lines = block.trim().split("\n");
+    if (lines.length === 0) continue;
+    const headerLine = lines[0];
+    const parts = headerLine.split("|||");
+    if (parts.length < 5) continue;
+    const [hash, shortHash, author, date, message, body] = parts;
+    const files = [];
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (!line) continue;
+      const match = line.match(/^([AMDRT])\d*\t(.+?)(?:\t(.+))?$/);
+      if (match) {
+        const [, status, path2, oldPath] = match;
+        files.push({
+          path: path2,
+          status: parseFileStatus(status),
+          additions: 0,
+          deletions: 0,
+          oldPath: oldPath || void 0
+        });
+      }
+    }
+    commits.push({
+      hash,
+      shortHash,
+      author,
+      date,
+      message,
+      body: body || void 0,
+      files
+    });
+  }
+  return commits;
+}
+function parseFileStatus(status) {
+  switch (status) {
+    case "A":
+      return "added";
+    case "D":
+      return "deleted";
+    case "R":
+      return "renamed";
+    default:
+      return "modified";
+  }
+}
+function categorizeCommit(message, body) {
+  const text = `${message} ${body || ""}`.toLowerCase();
+  if (text.includes("fix") || text.includes("bug") || text.includes("error") || text.includes("issue")) {
+    return "error_fix";
+  }
+  if (text.includes("refactor") || text.includes("clean") || text.includes("simplify")) {
+    return "refactor";
+  }
+  if (text.includes("workaround") || text.includes("hack") || text.includes("temporary")) {
+    return "workaround";
+  }
+  if (text.includes("debug") || text.includes("log") || text.includes("trace")) {
+    return "debugging";
+  }
+  return null;
+}
+function shouldSkipCommit(commit, ignorePatterns) {
+  const message = commit.message.toLowerCase();
+  for (const pattern of ignorePatterns) {
+    if (message.includes(pattern.toLowerCase())) {
+      return true;
+    }
+  }
+  if (message.startsWith("merge ") || message.startsWith("wip")) {
+    return true;
+  }
+  if (commit.files.length === 0) {
+    return true;
+  }
+  return false;
+}
+function extractPatternFromCommit(commit) {
+  const category = categorizeCommit(commit.message, commit.body);
+  if (!category) return null;
+  const id = `git-${commit.shortHash}`;
+  const title = formatTitle(commit.message);
+  const problem = extractProblem(commit);
+  const solution = extractSolution(commit);
+  const context = extractContext(commit);
+  if (!problem || !solution) return null;
+  return {
+    id,
+    category,
+    title,
+    problem,
+    solution,
+    context,
+    extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    source: "git",
+    commitRange: { from: commit.hash, to: commit.hash },
+    approved: false,
+    confidence: calculateConfidence(commit, category)
+  };
+}
+function formatTitle(message) {
+  return message.charAt(0).toUpperCase() + message.slice(1);
+}
+function extractProblem(commit) {
+  const message = commit.message.toLowerCase();
+  if (message.includes("fix:") || message.includes("fix(")) {
+    const match = commit.message.match(/fix[:(]\s*([^)]+)/i);
+    if (match) {
+      return `Issue: ${match[1]}`;
+    }
+  }
+  if (commit.body) {
+    const problemMatch = commit.body.match(/problem:?\s*(.+)/i);
+    if (problemMatch) {
+      return problemMatch[1].trim();
+    }
+  }
+  return `${commit.message} (from commit ${commit.shortHash})`;
+}
+function extractSolution(commit) {
+  if (commit.body) {
+    const solutionMatch = commit.body.match(/solution:?\s*(.+)/i);
+    if (solutionMatch) {
+      return solutionMatch[1].trim();
+    }
+  }
+  const files = commit.files.map((f) => f.path).join(", ");
+  return `Modified: ${files}`;
+}
+function extractContext(commit) {
+  const files = commit.files;
+  const extensions = new Set(files.map((f) => f.path.split(".").pop() || ""));
+  const directories = new Set(files.map((f) => f.path.split("/")[0]));
+  const parts = [];
+  if (extensions.size > 0) {
+    parts.push(`Files: ${Array.from(extensions).filter((e) => e).join(", ")}`);
+  }
+  if (directories.size > 0 && directories.size <= 3) {
+    parts.push(`Areas: ${Array.from(directories).join(", ")}`);
+  }
+  return parts.join(". ") || "General codebase";
+}
+function calculateConfidence(commit, category) {
+  let confidence = 0.5;
+  if (commit.body && commit.body.length > 50) {
+    confidence += 0.1;
+  }
+  if (commit.message.match(/^(fix|feat|refactor|docs|test|chore)(\(.+\))?:/)) {
+    confidence += 0.1;
+  }
+  if (commit.files.length > 0 && commit.files.length < 10) {
+    confidence += 0.1;
+  }
+  if (category === "error_fix" || category === "workaround") {
+    confidence += 0.05;
+  }
+  return Math.min(0.9, confidence);
+}
+function analyzeGitHistory(repoPath, options = {}) {
+  const commits = getGitCommits(repoPath, options);
+  const ignorePatterns = ["merge", "wip", "typo"];
+  const patterns = [];
+  const summary = {
+    totalCommits: commits.length,
+    totalFilesChanged: 0,
+    errorFixes: 0,
+    refactors: 0,
+    features: 0,
+    documentation: 0,
+    tests: 0
+  };
+  const languages = /* @__PURE__ */ new Set();
+  const frameworks = /* @__PURE__ */ new Set();
+  for (const commit of commits) {
+    if (shouldSkipCommit(commit, ignorePatterns)) {
+      continue;
+    }
+    summary.totalFilesChanged += commit.files.length;
+    for (const file of commit.files) {
+      const ext = file.path.split(".").pop()?.toLowerCase();
+      if (ext) {
+        if (["ts", "tsx"].includes(ext)) languages.add("TypeScript");
+        else if (["js", "jsx"].includes(ext)) languages.add("JavaScript");
+        else if (ext === "py") languages.add("Python");
+        else if (ext === "go") languages.add("Go");
+        else if (ext === "rs") languages.add("Rust");
+        else if (ext === "java") languages.add("Java");
+      }
+      if (file.path.includes("next")) frameworks.add("Next.js");
+      if (file.path.includes("react")) frameworks.add("React");
+      if (file.path.includes("vue")) frameworks.add("Vue");
+    }
+    const category = categorizeCommit(commit.message, commit.body);
+    if (category === "error_fix") summary.errorFixes++;
+    else if (category === "refactor") summary.refactors++;
+    if (commit.message.toLowerCase().includes("feat")) summary.features++;
+    if (commit.message.toLowerCase().includes("doc")) summary.documentation++;
+    if (commit.message.toLowerCase().includes("test")) summary.tests++;
+    const pattern = extractPatternFromCommit(commit);
+    if (pattern) {
+      patterns.push(pattern);
+    }
+  }
+  const dates = commits.map((c) => c.date).sort();
+  return {
+    patterns,
+    commitCount: commits.length,
+    dateRange: {
+      from: dates[0] || "",
+      to: dates[dates.length - 1] || ""
+    },
+    languages: Array.from(languages),
+    frameworks: Array.from(frameworks),
+    summary
+  };
+}
+function getRecentBugFixes(repoPath, limit = 20) {
+  const result = analyzeGitHistory(repoPath, { commits: limit * 3 });
+  return result.patterns.filter((p) => p.category === "error_fix").slice(0, limit);
+}
+function getRecentRefactors(repoPath, limit = 20) {
+  const result = analyzeGitHistory(repoPath, { commits: limit * 3 });
+  return result.patterns.filter((p) => p.category === "refactor").slice(0, limit);
+}
+
+// src/learning/extractor.ts
+function extractPatternsFromSession(session) {
+  const patterns = [];
+  const skipped = [];
+  const errors = [];
+  if (session.messages.length < 5) {
+    skipped.push({ reason: "Session too short for pattern extraction" });
+    return { patterns, skipped, errors };
+  }
+  try {
+    const errorFixPatterns = findErrorFixPatterns(session);
+    patterns.push(...errorFixPatterns);
+    const workaroundPatterns = findWorkaroundPatterns(session);
+    patterns.push(...workaroundPatterns);
+    const conventionPatterns = findConventionPatterns(session);
+    patterns.push(...conventionPatterns);
+    const debuggingPatterns = findDebuggingPatterns(session);
+    patterns.push(...debuggingPatterns);
+  } catch (error) {
+    errors.push(error instanceof Error ? error.message : "Unknown extraction error");
+  }
+  return { patterns, skipped, errors };
+}
+function findErrorFixPatterns(session) {
+  const patterns = [];
+  const messages = session.messages;
+  for (let i = 0; i < messages.length - 1; i++) {
+    const current = messages[i];
+    const next = messages[i + 1];
+    if (isErrorDescription(current.content) && isSolution(next.content)) {
+      const pattern = createPatternFromErrorFix(
+        current.content,
+        next.content,
+        session,
+        i
+      );
+      if (pattern) {
+        patterns.push(pattern);
+      }
+    }
+  }
+  return patterns;
+}
+function findWorkaroundPatterns(session) {
+  const patterns = [];
+  const messages = session.messages;
+  const workaroundKeywords = [
+    "workaround",
+    "instead of",
+    "alternative",
+    "hack",
+    "temporary fix",
+    "for now",
+    "until"
+  ];
+  for (let i = 0; i < messages.length; i++) {
+    const message = messages[i];
+    if (message.role !== "assistant") continue;
+    const content = message.content.toLowerCase();
+    if (workaroundKeywords.some((kw) => content.includes(kw))) {
+      const problem = findPrecedingProblem(messages, i);
+      if (problem) {
+        const pattern = createPattern(
+          "workaround",
+          problem,
+          message.content,
+          session,
+          i
+        );
+        if (pattern) {
+          patterns.push(pattern);
+        }
+      }
+    }
+  }
+  return patterns;
+}
+function findConventionPatterns(session) {
+  const patterns = [];
+  const messages = session.messages;
+  const conventionKeywords = [
+    "naming convention",
+    "pattern we use",
+    "standard",
+    "best practice",
+    "we always",
+    "convention",
+    "style guide"
+  ];
+  for (let i = 0; i < messages.length; i++) {
+    const message = messages[i];
+    if (message.role !== "assistant") continue;
+    const content = message.content.toLowerCase();
+    if (conventionKeywords.some((kw) => content.includes(kw))) {
+      const pattern = createPattern(
+        "convention",
+        "Project convention discovered",
+        message.content,
+        session,
+        i
+      );
+      if (pattern) {
+        patterns.push(pattern);
+      }
+    }
+  }
+  return patterns;
+}
+function findDebuggingPatterns(session) {
+  const patterns = [];
+  const messages = session.messages;
+  const debugKeywords = [
+    "to debug this",
+    "debugging",
+    "to find the issue",
+    "trace",
+    "breakpoint",
+    "logging",
+    "to diagnose"
+  ];
+  for (let i = 0; i < messages.length; i++) {
+    const message = messages[i];
+    if (message.role !== "assistant") continue;
+    const content = message.content.toLowerCase();
+    if (debugKeywords.some((kw) => content.includes(kw))) {
+      const problem = findPrecedingProblem(messages, i);
+      if (problem) {
+        const pattern = createPattern(
+          "debugging",
+          problem,
+          message.content,
+          session,
+          i
+        );
+        if (pattern) {
+          patterns.push(pattern);
+        }
+      }
+    }
+  }
+  return patterns;
+}
+function isErrorDescription(content) {
+  const errorKeywords = [
+    "error",
+    "fail",
+    "exception",
+    "crash",
+    "not working",
+    "broken",
+    "bug",
+    "issue",
+    "problem",
+    "does not",
+    "doesn't",
+    "can't",
+    "cannot"
+  ];
+  const lower = content.toLowerCase();
+  return errorKeywords.some((kw) => lower.includes(kw));
+}
+function isSolution(content) {
+  const solutionKeywords = [
+    "fix",
+    "solution",
+    "resolve",
+    "change",
+    "update",
+    "modify",
+    "replace",
+    "should be",
+    "try this",
+    "use instead"
+  ];
+  const lower = content.toLowerCase();
+  return solutionKeywords.some((kw) => lower.includes(kw));
+}
+function findPrecedingProblem(messages, currentIndex) {
+  for (let i = currentIndex - 1; i >= 0 && i > currentIndex - 5; i--) {
+    const message = messages[i];
+    if (message.role === "user" && message.content.length > 20) {
+      return message.content;
+    }
+  }
+  return null;
+}
+function createPatternFromErrorFix(errorDescription, solution, session, messageIndex) {
+  return createPattern("error_fix", errorDescription, solution, session, messageIndex);
+}
+function createPattern(category, problem, solution, session, messageIndex) {
+  if (problem.length < 20 || solution.length < 20) {
+    return null;
+  }
+  const id = `session-${Date.now()}-${messageIndex}`;
+  const title = extractTitle(problem, category);
+  return {
+    id,
+    category,
+    title,
+    problem: truncate(problem, 500),
+    solution: truncate(solution, 1e3),
+    context: session.projectPath,
+    extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    source: "session",
+    approved: false,
+    confidence: calculateSessionConfidence(problem, solution, session)
+  };
+}
+function extractTitle(problem, category) {
+  const firstSentence = problem.split(/[.!?]/)[0].trim();
+  if (firstSentence.length > 80) {
+    return `${category.charAt(0).toUpperCase() + category.slice(1).replace("_", " ")} pattern`;
+  }
+  return firstSentence;
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 3) + "...";
+}
+function calculateSessionConfidence(problem, solution, _session) {
+  let confidence = 0.4;
+  if (problem.length > 50 && problem.length < 500) {
+    confidence += 0.1;
+  }
+  if (solution.length > 100 && solution.length < 1e3) {
+    confidence += 0.1;
+  }
+  if (solution.includes("```")) {
+    confidence += 0.15;
+  }
+  return Math.min(0.85, confidence);
+}
+function mergePatterns(existing, newPatterns) {
+  const merged = [...existing];
+  for (const pattern of newPatterns) {
+    const existingIndex = merged.findIndex(
+      (p) => p.problem === pattern.problem || p.id === pattern.id
+    );
+    if (existingIndex >= 0) {
+      if (pattern.confidence > merged[existingIndex].confidence) {
+        merged[existingIndex] = pattern;
+      }
+    } else {
+      merged.push(pattern);
+    }
+  }
+  return merged;
+}
+
+// src/learning/generator.ts
+import { writeFileSync as writeFileSync22, mkdirSync as mkdirSync22, existsSync as existsSync40 } from "fs";
+import { join as join41 } from "path";
+import { homedir as homedir12 } from "os";
+function generateSkillFromPatterns(patterns, options = {}) {
+  const minConfidence = options.minConfidence ?? 0.5;
+  const minPatterns = options.minPatterns ?? 1;
+  const eligiblePatterns = patterns.filter((p) => p.confidence >= minConfidence);
+  if (eligiblePatterns.length < minPatterns) {
+    return null;
+  }
+  const category = getMostCommonCategory(eligiblePatterns);
+  const id = `learned-${category}-${Date.now()}`;
+  const name = formatSkillName2(category, eligiblePatterns);
+  const content = generateSkillContent2(name, eligiblePatterns, category);
+  const filename = `${id}.md`;
+  return {
+    id,
+    name,
+    filename,
+    content,
+    patterns: eligiblePatterns
+  };
+}
+function getMostCommonCategory(patterns) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const pattern of patterns) {
+    counts.set(pattern.category, (counts.get(pattern.category) || 0) + 1);
+  }
+  let maxCategory = "error_fix";
+  let maxCount = 0;
+  for (const [category, count] of counts) {
+    if (count > maxCount) {
+      maxCount = count;
+      maxCategory = category;
+    }
+  }
+  return maxCategory;
+}
+function formatSkillName2(category, patterns) {
+  const categoryNames = {
+    error_fix: "Error Fixes",
+    refactor: "Refactoring Patterns",
+    workaround: "Workarounds",
+    debugging: "Debugging Techniques",
+    convention: "Project Conventions"
+  };
+  const baseName = categoryNames[category];
+  const context = patterns[0]?.context || "Project";
+  return `${baseName} - ${context}`;
+}
+function generateSkillContent2(name, patterns, category) {
+  const lines = [];
+  lines.push("---");
+  lines.push(`name: ${name.toLowerCase().replace(/\s+/g, "-")}`);
+  lines.push(`description: Learned ${category.replace("_", " ")} patterns from project history`);
+  lines.push(`category: learned`);
+  lines.push(`source: automated`);
+  lines.push(`generated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push(`pattern_count: ${patterns.length}`);
+  lines.push("---");
+  lines.push("");
+  lines.push(`# ${name}`);
+  lines.push("");
+  lines.push("> This skill was automatically generated from learned patterns.");
+  lines.push("");
+  lines.push("## Patterns");
+  lines.push("");
+  for (const pattern of patterns) {
+    lines.push(`### ${pattern.title}`);
+    lines.push("");
+    lines.push(`**Category:** ${pattern.category.replace("_", " ")}`);
+    lines.push(`**Confidence:** ${(pattern.confidence * 100).toFixed(0)}%`);
+    lines.push("");
+    lines.push("**Problem:**");
+    lines.push(pattern.problem);
+    lines.push("");
+    lines.push("**Solution:**");
+    lines.push(pattern.solution);
+    lines.push("");
+    if (pattern.example) {
+      lines.push("**Example:**");
+      lines.push("```");
+      lines.push(pattern.example);
+      lines.push("```");
+      lines.push("");
+    }
+    lines.push("---");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function saveGeneratedSkill(skill, outputDir) {
+  const dir = outputDir || join41(homedir12(), ".skillkit", "skills", "learned");
+  if (!existsSync40(dir)) {
+    mkdirSync22(dir, { recursive: true });
+  }
+  const filepath = join41(dir, skill.filename);
+  writeFileSync22(filepath, skill.content);
+  return filepath;
+}
+function generatePatternReport(patterns) {
+  const lines = [];
+  lines.push("# Learned Patterns Report");
+  lines.push("");
+  lines.push(`Generated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push(`Total Patterns: ${patterns.length}`);
+  lines.push("");
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const pattern of patterns) {
+    if (!byCategory.has(pattern.category)) {
+      byCategory.set(pattern.category, []);
+    }
+    byCategory.get(pattern.category).push(pattern);
+  }
+  lines.push("## Summary by Category");
+  lines.push("");
+  lines.push("| Category | Count | Avg Confidence |");
+  lines.push("|----------|-------|----------------|");
+  for (const [category, catPatterns] of byCategory) {
+    const avgConfidence = catPatterns.reduce((sum, p) => sum + p.confidence, 0) / catPatterns.length;
+    lines.push(`| ${category.replace("_", " ")} | ${catPatterns.length} | ${(avgConfidence * 100).toFixed(0)}% |`);
+  }
+  lines.push("");
+  lines.push("## Patterns");
+  lines.push("");
+  const approved = patterns.filter((p) => p.approved);
+  const pending = patterns.filter((p) => !p.approved);
+  if (approved.length > 0) {
+    lines.push("### Approved Patterns");
+    lines.push("");
+    for (const pattern of approved) {
+      lines.push(`- **${pattern.title}** (${pattern.category}, ${(pattern.confidence * 100).toFixed(0)}%)`);
+    }
+    lines.push("");
+  }
+  if (pending.length > 0) {
+    lines.push("### Pending Approval");
+    lines.push("");
+    for (const pattern of pending) {
+      lines.push(`- **${pattern.title}** (${pattern.category}, ${(pattern.confidence * 100).toFixed(0)}%)`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function exportPatternsAsJson(patterns) {
+  return JSON.stringify(
+    {
+      version: 1,
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      count: patterns.length,
+      patterns
+    },
+    null,
+    2
+  );
+}
+function importPatternsFromJson(jsonContent) {
+  try {
+    const data = JSON.parse(jsonContent);
+    if (Array.isArray(data.patterns)) {
+      return data.patterns;
+    }
+    if (Array.isArray(data)) {
+      return data;
+    }
+    return [];
+  } catch {
+    return [];
+  }
+}
+
+// src/learning/feedback.ts
+function recordSuccess(patternId, storePath) {
+  const store = loadPatternStore(storePath);
+  const evolving = findOrCreateEvolvingPattern(store, patternId);
+  if (!evolving) return null;
+  const previousConfidence = evolving.confidence;
+  evolving.useCount++;
+  evolving.successCount++;
+  evolving.lastUsed = (/* @__PURE__ */ new Date()).toISOString();
+  evolving.confidence = Math.min(0.95, evolving.confidence + 0.05);
+  updateEvolvingPattern(store, evolving);
+  savePatternStore(store, storePath);
+  return {
+    pattern: evolving,
+    previousConfidence,
+    newConfidence: evolving.confidence,
+    change: "increased"
+  };
+}
+function recordFailure(patternId, storePath) {
+  const store = loadPatternStore(storePath);
+  const evolving = findOrCreateEvolvingPattern(store, patternId);
+  if (!evolving) return null;
+  const previousConfidence = evolving.confidence;
+  evolving.useCount++;
+  evolving.failureCount++;
+  evolving.lastUsed = (/* @__PURE__ */ new Date()).toISOString();
+  evolving.confidence = Math.max(0.1, evolving.confidence - 0.1);
+  updateEvolvingPattern(store, evolving);
+  savePatternStore(store, storePath);
+  return {
+    pattern: evolving,
+    previousConfidence,
+    newConfidence: evolving.confidence,
+    change: "decreased"
+  };
+}
+function findOrCreateEvolvingPattern(store, patternId) {
+  let evolving = store.evolvingPatterns.find((p) => p.id === patternId);
+  if (!evolving) {
+    const basePattern = store.patterns.find((p) => p.id === patternId);
+    if (!basePattern) return null;
+    evolving = {
+      ...basePattern,
+      trigger: inferTrigger(basePattern),
+      action: inferAction(basePattern),
+      useCount: 0,
+      successCount: 0,
+      failureCount: 0
+    };
+    store.evolvingPatterns.push(evolving);
+  }
+  return evolving;
+}
+function updateEvolvingPattern(store, evolving) {
+  const index = store.evolvingPatterns.findIndex((p) => p.id === evolving.id);
+  if (index >= 0) {
+    store.evolvingPatterns[index] = evolving;
+  } else {
+    store.evolvingPatterns.push(evolving);
+  }
+}
+function inferTrigger(pattern) {
+  const problem = pattern.problem.toLowerCase();
+  if (problem.includes("error") || problem.includes("exception")) {
+    return "When encountering similar errors";
+  }
+  if (problem.includes("build") || problem.includes("compile")) {
+    return "During build/compilation issues";
+  }
+  if (problem.includes("test")) {
+    return "When tests fail in similar ways";
+  }
+  return `When facing: ${pattern.title}`;
+}
+function inferAction(pattern) {
+  return pattern.solution.split("\n")[0] || "Apply learned solution";
+}
+function getEvolvingPatternsByDomain(domain, storePath) {
+  const store = loadPatternStore(storePath);
+  return store.evolvingPatterns.filter((p) => p.domain === domain);
+}
+function getHighConfidencePatterns(minConfidence = 0.7, storePath) {
+  const store = loadPatternStore(storePath);
+  return store.evolvingPatterns.filter((p) => p.confidence >= minConfidence).sort((a, b) => b.confidence - a.confidence);
+}
+function getLowConfidencePatterns(maxConfidence = 0.3, storePath) {
+  const store = loadPatternStore(storePath);
+  return store.evolvingPatterns.filter((p) => p.confidence <= maxConfidence).sort((a, b) => a.confidence - b.confidence);
+}
+function getMostUsedPatterns(limit = 10, storePath) {
+  const store = loadPatternStore(storePath);
+  return store.evolvingPatterns.sort((a, b) => b.useCount - a.useCount).slice(0, limit);
+}
+function getPatternStats(storePath) {
+  const store = loadPatternStore(storePath);
+  const patterns = store.evolvingPatterns;
+  const byDomain = /* @__PURE__ */ new Map();
+  let high = 0, medium = 0, low = 0;
+  for (const pattern of patterns) {
+    const domain = pattern.domain || "unknown";
+    byDomain.set(domain, (byDomain.get(domain) || 0) + 1);
+    if (pattern.confidence >= 0.7) high++;
+    else if (pattern.confidence >= 0.4) medium++;
+    else low++;
+  }
+  const mostUsed = patterns.length > 0 ? patterns.reduce((max, p) => p.useCount > max.useCount ? p : max) : null;
+  const leastConfident = patterns.length > 0 ? patterns.reduce((min, p) => p.confidence < min.confidence ? p : min) : null;
+  return {
+    total: patterns.length,
+    byDomain,
+    byConfidenceRange: { high, medium, low },
+    mostUsed,
+    leastConfident
+  };
+}
+function approvePattern(patternId, storePath) {
+  const store = loadPatternStore(storePath);
+  const pattern = store.patterns.find((p) => p.id === patternId);
+  if (!pattern) return null;
+  pattern.approved = true;
+  savePatternStore(store, storePath);
+  return pattern;
+}
+function rejectPattern(patternId, storePath) {
+  const store = loadPatternStore(storePath);
+  const index = store.patterns.findIndex((p) => p.id === patternId);
+  if (index < 0) return false;
+  store.patterns.splice(index, 1);
+  const evolvingIndex = store.evolvingPatterns.findIndex((p) => p.id === patternId);
+  if (evolvingIndex >= 0) {
+    store.evolvingPatterns.splice(evolvingIndex, 1);
+  }
+  savePatternStore(store, storePath);
+  return true;
+}
+function clusterPatterns(patterns) {
+  const clusters = /* @__PURE__ */ new Map();
+  for (const pattern of patterns) {
+    const key = pattern.category;
+    if (!clusters.has(key)) {
+      clusters.set(key, []);
+    }
+    clusters.get(key).push(pattern);
+  }
+  return clusters;
+}
+
+// src/profiles/types.ts
+var DEFAULT_PROFILE_CONFIG = {
+  activeProfile: "dev",
+  customProfiles: []
+};
+
+// src/profiles/manager.ts
+import { existsSync as existsSync41, readFileSync as readFileSync30, writeFileSync as writeFileSync23, mkdirSync as mkdirSync23 } from "fs";
+import { join as join42, dirname as dirname15 } from "path";
+import { homedir as homedir13 } from "os";
+import yaml2 from "yaml";
+var BUILTIN_PROFILES = [
+  {
+    name: "dev",
+    description: "Active development mode",
+    focus: "Implementation speed and working solutions",
+    behaviors: [
+      "Prefer working code over perfect code",
+      "Quick iterations with frequent testing",
+      "Minimize context switching",
+      "Focus on the current task"
+    ],
+    priorities: ["Functionality", "Simplicity", "Testability", "Speed"],
+    preferredTools: ["Edit", "Write", "Bash", "Read"],
+    injectedContext: `You are in DEVELOPMENT mode. Focus on:
+- Getting working code quickly
+- Writing minimal tests for new functionality
+- Keeping changes small and focused
+- Committing frequently`
+  },
+  {
+    name: "review",
+    description: "Code review mode",
+    focus: "Quality, security, and maintainability",
+    behaviors: [
+      "Thorough analysis before suggesting changes",
+      "Security-first mindset",
+      "Consider edge cases and failure modes",
+      "Provide constructive feedback"
+    ],
+    priorities: ["Security", "Code quality", "Best practices", "Maintainability"],
+    preferredTools: ["Read", "Grep", "Glob"],
+    avoidTools: ["Edit", "Write"],
+    injectedContext: `You are in REVIEW mode. Focus on:
+- Identifying potential bugs and security issues
+- Checking code against best practices
+- Verifying test coverage
+- Suggesting improvements without making changes`
+  },
+  {
+    name: "research",
+    description: "Exploration and discovery mode",
+    focus: "Understanding and analysis",
+    behaviors: [
+      "Deep exploration of codebase",
+      "Document findings thoroughly",
+      "Consider multiple approaches",
+      "Ask clarifying questions"
+    ],
+    priorities: ["Understanding", "Documentation", "Options analysis", "Learning"],
+    preferredTools: ["Read", "Grep", "Glob", "WebSearch", "WebFetch"],
+    avoidTools: ["Edit", "Write"],
+    injectedContext: `You are in RESEARCH mode. Focus on:
+- Understanding the codebase structure
+- Finding relevant documentation
+- Exploring different approaches
+- Creating summaries of findings`
+  },
+  {
+    name: "security",
+    description: "Security audit mode",
+    focus: "Vulnerability detection and hardening",
+    behaviors: [
+      "Assume hostile input",
+      "Check all authentication and authorization",
+      "Look for common vulnerability patterns",
+      "Verify encryption and data protection"
+    ],
+    priorities: ["Security", "Data protection", "Authentication", "Authorization"],
+    preferredTools: ["Read", "Grep", "Glob", "Bash"],
+    injectedContext: `You are in SECURITY AUDIT mode. Focus on:
+- OWASP Top 10 vulnerabilities
+- Authentication and authorization flaws
+- Data exposure risks
+- Injection vulnerabilities
+- Secrets and credentials in code`
+  }
+];
+function getConfigPath() {
+  return join42(homedir13(), ".skillkit", "profiles.yaml");
+}
+function loadProfileConfig() {
+  const path2 = getConfigPath();
+  if (!existsSync41(path2)) {
+    return DEFAULT_PROFILE_CONFIG;
+  }
+  try {
+    const content = readFileSync30(path2, "utf-8");
+    return { ...DEFAULT_PROFILE_CONFIG, ...yaml2.parse(content) };
+  } catch {
+    return DEFAULT_PROFILE_CONFIG;
+  }
+}
+function saveProfileConfig(config) {
+  const path2 = getConfigPath();
+  const dir = dirname15(path2);
+  if (!existsSync41(dir)) {
+    mkdirSync23(dir, { recursive: true });
+  }
+  writeFileSync23(path2, yaml2.stringify(config));
+}
+function getActiveProfile() {
+  const config = loadProfileConfig();
+  return config.activeProfile;
+}
+function setActiveProfile(name) {
+  const config = loadProfileConfig();
+  config.activeProfile = name;
+  saveProfileConfig(config);
+}
+function getProfile(name) {
+  const builtin = BUILTIN_PROFILES.find((p) => p.name === name);
+  if (builtin) return builtin;
+  const config = loadProfileConfig();
+  return config.customProfiles.find((p) => p.name === name) || null;
+}
+function getAllProfiles() {
+  const config = loadProfileConfig();
+  return [...BUILTIN_PROFILES, ...config.customProfiles];
+}
+function getBuiltinProfiles() {
+  return BUILTIN_PROFILES;
+}
+function getProfileNames() {
+  const config = loadProfileConfig();
+  const builtinNames = BUILTIN_PROFILES.map((p) => p.name);
+  const customNames = config.customProfiles.map((p) => p.name);
+  return [...builtinNames, ...customNames];
+}
+function addCustomProfile(profile) {
+  const config = loadProfileConfig();
+  const existing = config.customProfiles.findIndex((p) => p.name === profile.name);
+  if (existing >= 0) {
+    config.customProfiles[existing] = profile;
+  } else {
+    config.customProfiles.push(profile);
+  }
+  saveProfileConfig(config);
+}
+function removeCustomProfile(name) {
+  const config = loadProfileConfig();
+  const index = config.customProfiles.findIndex((p) => p.name === name);
+  if (index < 0) return false;
+  config.customProfiles.splice(index, 1);
+  if (config.activeProfile === name) {
+    config.activeProfile = "dev";
+  }
+  saveProfileConfig(config);
+  return true;
+}
+function getProfileContext(name) {
+  const profileName = name || getActiveProfile();
+  const profile = getProfile(profileName);
+  return profile?.injectedContext || null;
+}
+function isBuiltinProfile(name) {
+  return BUILTIN_PROFILES.some((p) => p.name === name);
+}
+
+// src/guidelines/types.ts
+var DEFAULT_GUIDELINE_CONFIG = {
+  enabledGuidelines: ["security", "code-style", "testing", "git"],
+  customGuidelines: []
+};
+
+// src/guidelines/manager.ts
+import { existsSync as existsSync42, readFileSync as readFileSync31, writeFileSync as writeFileSync24, mkdirSync as mkdirSync24 } from "fs";
+import { join as join43, dirname as dirname16 } from "path";
+import { homedir as homedir14 } from "os";
+import yaml3 from "yaml";
+var BUILTIN_GUIDELINES = [
+  {
+    id: "security",
+    name: "Security Guidelines",
+    description: "Security best practices and vulnerability prevention",
+    category: "security",
+    priority: 10,
+    enabled: true,
+    scope: "global",
+    content: `## Security Guidelines
+
+### Input Validation
+- Validate all user input on the server side
+- Use allowlists over denylists when possible
+- Sanitize data before use in queries, commands, or output
+
+### Authentication & Authorization
+- Never store passwords in plain text
+- Use secure session management
+- Implement proper authorization checks on every endpoint
+- Use HTTPS for all communications
+
+### Data Protection
+- Encrypt sensitive data at rest and in transit
+- Never log sensitive information
+- Use environment variables for secrets
+- Implement proper access controls
+
+### Common Vulnerabilities to Prevent
+- SQL Injection: Use parameterized queries
+- XSS: Encode output, use CSP headers
+- CSRF: Use anti-CSRF tokens
+- Command Injection: Avoid shell commands with user input`
+  },
+  {
+    id: "code-style",
+    name: "Code Style Guidelines",
+    description: "Code formatting and style conventions",
+    category: "code-style",
+    priority: 7,
+    enabled: true,
+    scope: "global",
+    content: `## Code Style Guidelines
+
+### Naming Conventions
+- Use descriptive, meaningful names
+- camelCase for variables and functions
+- PascalCase for classes and types
+- SCREAMING_SNAKE_CASE for constants
+
+### Code Organization
+- One concept per file
+- Group related code together
+- Keep files under 300 lines when practical
+- Use barrel exports (index.ts) for public APIs
+
+### Functions
+- Single responsibility principle
+- Keep functions under 30 lines when practical
+- Use early returns to reduce nesting
+- Avoid side effects in pure functions
+
+### Comments
+- Don't comment obvious code
+- Explain "why" not "what"
+- Keep comments up to date
+- Use JSDoc for public APIs`
+  },
+  {
+    id: "testing",
+    name: "Testing Guidelines",
+    description: "Testing best practices and coverage requirements",
+    category: "testing",
+    priority: 8,
+    enabled: true,
+    scope: "global",
+    content: `## Testing Guidelines
+
+### Test Coverage
+- Aim for 80%+ code coverage
+- 100% coverage for critical paths
+- Don't sacrifice quality for coverage metrics
+
+### Test Structure
+- Arrange, Act, Assert (AAA) pattern
+- One concept per test
+- Descriptive test names that explain behavior
+- Independent tests (no shared state)
+
+### Test Types
+- Unit tests for business logic
+- Integration tests for component interactions
+- E2E tests for critical user flows
+
+### Test Quality
+- Tests should be deterministic
+- Fast execution (< 100ms for unit tests)
+- Easy to understand and maintain
+- Test behavior, not implementation`
+  },
+  {
+    id: "git",
+    name: "Git Workflow Guidelines",
+    description: "Version control best practices",
+    category: "git",
+    priority: 6,
+    enabled: true,
+    scope: "global",
+    content: `## Git Workflow Guidelines
+
+### Commits
+- Write clear, concise commit messages
+- Use conventional commits format
+- One logical change per commit
+- Don't commit generated files or secrets
+
+### Branches
+- Use feature branches
+- Keep branches short-lived
+- Delete branches after merge
+- Protect main/master branch
+
+### Pull Requests
+- Keep PRs focused and small
+- Write meaningful descriptions
+- Request reviews from appropriate people
+- Address all review comments
+
+### Commit Message Format
+\`\`\`
+<type>(<scope>): <description>
+
+[optional body]
+
+[optional footer]
+\`\`\`
+
+Types: feat, fix, docs, style, refactor, test, chore`
+  },
+  {
+    id: "performance",
+    name: "Performance Guidelines",
+    description: "Performance optimization best practices",
+    category: "performance",
+    priority: 5,
+    enabled: false,
+    scope: "global",
+    content: `## Performance Guidelines
+
+### General Principles
+- Measure before optimizing
+- Optimize critical paths first
+- Consider time/space tradeoffs
+- Profile in production-like environments
+
+### Database
+- Use indexes appropriately
+- Avoid N+1 queries
+- Paginate large result sets
+- Cache frequently accessed data
+
+### Frontend
+- Minimize bundle size
+- Lazy load when appropriate
+- Optimize images and assets
+- Use efficient rendering patterns
+
+### Backend
+- Use connection pooling
+- Implement appropriate caching
+- Async operations where beneficial
+- Monitor and alert on performance`
+  }
+];
+function getConfigPath2() {
+  return join43(homedir14(), ".skillkit", "guidelines.yaml");
+}
+function loadGuidelineConfig() {
+  const path2 = getConfigPath2();
+  if (!existsSync42(path2)) {
+    return DEFAULT_GUIDELINE_CONFIG;
+  }
+  try {
+    const content = readFileSync31(path2, "utf-8");
+    return { ...DEFAULT_GUIDELINE_CONFIG, ...yaml3.parse(content) };
+  } catch {
+    return DEFAULT_GUIDELINE_CONFIG;
+  }
+}
+function saveGuidelineConfig(config) {
+  const path2 = getConfigPath2();
+  const dir = dirname16(path2);
+  if (!existsSync42(dir)) {
+    mkdirSync24(dir, { recursive: true });
+  }
+  writeFileSync24(path2, yaml3.stringify(config));
+}
+function getGuideline(id) {
+  const builtin = BUILTIN_GUIDELINES.find((g) => g.id === id);
+  if (builtin) return builtin;
+  const config = loadGuidelineConfig();
+  return config.customGuidelines.find((g) => g.id === id) || null;
+}
+function getAllGuidelines() {
+  const config = loadGuidelineConfig();
+  return [...BUILTIN_GUIDELINES, ...config.customGuidelines];
+}
+function getBuiltinGuidelines() {
+  return BUILTIN_GUIDELINES;
+}
+function getEnabledGuidelines() {
+  const config = loadGuidelineConfig();
+  const all = getAllGuidelines();
+  return all.filter((g) => config.enabledGuidelines.includes(g.id));
+}
+function getGuidelinesByCategory(category) {
+  return getAllGuidelines().filter((g) => g.category === category);
+}
+function enableGuideline(id) {
+  const guideline = getGuideline(id);
+  if (!guideline) return false;
+  const config = loadGuidelineConfig();
+  if (!config.enabledGuidelines.includes(id)) {
+    config.enabledGuidelines.push(id);
+    saveGuidelineConfig(config);
+  }
+  return true;
+}
+function disableGuideline(id) {
+  const config = loadGuidelineConfig();
+  const index = config.enabledGuidelines.indexOf(id);
+  if (index < 0) return false;
+  config.enabledGuidelines.splice(index, 1);
+  saveGuidelineConfig(config);
+  return true;
+}
+function isGuidelineEnabled(id) {
+  const config = loadGuidelineConfig();
+  return config.enabledGuidelines.includes(id);
+}
+function addCustomGuideline(guideline) {
+  const config = loadGuidelineConfig();
+  const existing = config.customGuidelines.findIndex((g) => g.id === guideline.id);
+  if (existing >= 0) {
+    config.customGuidelines[existing] = guideline;
+  } else {
+    config.customGuidelines.push(guideline);
+  }
+  saveGuidelineConfig(config);
+}
+function removeCustomGuideline(id) {
+  const config = loadGuidelineConfig();
+  const index = config.customGuidelines.findIndex((g) => g.id === id);
+  if (index < 0) return false;
+  config.customGuidelines.splice(index, 1);
+  config.enabledGuidelines = config.enabledGuidelines.filter((g) => g !== id);
+  saveGuidelineConfig(config);
+  return true;
+}
+function getGuidelineContent(id) {
+  const guideline = getGuideline(id);
+  return guideline?.content || null;
+}
+function getEnabledGuidelineContent() {
+  const enabled = getEnabledGuidelines();
+  return enabled.map((g) => g.content).join("\n\n---\n\n");
+}
+function isBuiltinGuideline(id) {
+  return BUILTIN_GUIDELINES.some((g) => g.id === id);
+}
 export {
   AGENT_CLI_CONFIGS,
   AGENT_CONFIG,
@@ -19839,6 +21483,7 @@ export {
   AgentPermissionMode,
   AgentType,
   AuditLogger,
+  BUILTIN_PIPELINES,
   BaseAIProvider,
   BitbucketProvider,
   CIRCLECI_CONFIG_TEMPLATE,
@@ -19854,7 +21499,10 @@ export {
   CursorTranslator,
   DEFAULT_CACHE_TTL,
   DEFAULT_CONTEXT_CATEGORIES,
+  DEFAULT_GUIDELINE_CONFIG,
+  DEFAULT_LEARNING_CONFIG,
   DEFAULT_MEMORY_CONFIG,
+  DEFAULT_PROFILE_CONFIG,
   DEFAULT_SCORING_WEIGHTS,
   DEFAULT_SKILL_SOURCES,
   GITHUB_ACTION_TEMPLATE,
@@ -19918,15 +21566,21 @@ export {
   WORKFLOW_EXTENSION,
   WindsurfTranslator,
   WorkflowOrchestrator,
+  addCustomGuideline,
+  addCustomProfile,
+  addPattern,
   addToManifest,
   agentExists,
   analyzeForPrimer,
+  analyzeGitHistory,
   analyzePrimer,
   analyzeProject,
+  approvePattern,
   benchmarkSkill,
   buildSkillIndex,
   calculatePercentile,
   canTranslate,
+  clusterPatterns,
   copilotTranslator,
   createAPIBasedCompressor,
   createCommandGenerator,
@@ -19951,6 +21605,7 @@ export {
   createPluginManager,
   createRecommendationEngine,
   createRuleBasedCompressor,
+  createSessionFile,
   createSessionManager,
   createSimulatedSkillExecutor,
   createSkillBundle,
@@ -19966,6 +21621,7 @@ export {
   detectCategory,
   detectProvider,
   detectSkillFormat,
+  disableGuideline,
   discoverAgents,
   discoverAgentsForAgent,
   discoverAgentsFromPath,
@@ -19973,16 +21629,19 @@ export {
   discoverGlobalAgents,
   discoverSkills,
   dryRunExecutor,
+  enableGuideline,
   estimateTokens,
   evaluateSkillContent,
   evaluateSkillDirectory,
   evaluateSkillFile,
   executeWithAgent,
   exportBundle,
+  exportPatternsAsJson,
   extractAgentContent,
   extractAgentFrontmatter,
   extractField,
   extractFrontmatter,
+  extractPatternsFromSession,
   extractSkillMetadata,
   fetchSkillsFromRepo,
   findAgent,
@@ -19994,10 +21653,13 @@ export {
   fromCanonicalAgent,
   generateComparisonNotes,
   generateManifestFromInstalled,
+  generatePatternReport,
   generatePrimer,
   generatePrimerForAgent,
   generateRecommendations,
+  generateSkillFromPatterns,
   generateSkillsConfig,
+  getActiveProfile,
   getAgentCLIConfig,
   getAgentConfigFile,
   getAgentConfigPath,
@@ -20009,26 +21671,56 @@ export {
   getAgentTargetDirectory,
   getAgentsDirectory,
   getAllCategories,
+  getAllGuidelines,
+  getAllPatterns,
+  getAllProfiles,
   getAllProviders,
   getAllSkillsDirs,
+  getApprovedPatterns,
   getAvailableCLIAgents,
+  getBuiltinGuidelines,
   getBuiltinPacksDir,
+  getBuiltinPipeline,
+  getBuiltinPipelines,
+  getBuiltinProfiles,
   getCICDTemplate,
   getCategoryStats,
   getConfigFile,
   getConfigFormat,
+  getDefaultConfigPath,
+  getDefaultStorePath,
+  getEnabledGuidelineContent,
+  getEnabledGuidelines,
+  getEvolvingPattern,
+  getEvolvingPatternsByDomain,
   getExecutionStrategy,
+  getGitCommits,
   getGlobalConfigPath,
   getGlobalSkillsDir,
   getGrade,
+  getGuideline,
+  getGuidelineContent,
+  getGuidelinesByCategory,
+  getHighConfidencePatterns,
   getIndexStatus,
   getInstallDir,
+  getLowConfidencePatterns,
   getManualExecutionInstructions,
   getMemoryPaths,
   getMemoryStatus,
+  getMostRecentSession,
+  getMostUsedPatterns,
+  getPattern,
+  getPatternStats,
+  getPatternsByCategory,
+  getProfile,
+  getProfileContext,
+  getProfileNames,
   getProjectConfigPath,
   getProvider,
   getQualityGrade,
+  getRecentBugFixes,
+  getRecentRefactors,
   getSearchDirs,
   getSkillsDir,
   getStackTags,
@@ -20036,31 +21728,42 @@ export {
   getTechTags,
   globalMemoryDirectoryExists,
   importBundle,
+  importPatternsFromJson,
   initContext,
   initManifest,
   initProject,
   initializeMemoryDirectory,
   isAgentCLIAvailable,
   isAgentCompatible,
+  isBuiltinGuideline,
+  isBuiltinProfile,
   isGitUrl,
+  isGuidelineEnabled,
   isHighQuality,
   isIndexStale,
   isLocalPath,
   isPathInside,
   listCICDTemplates,
+  listSessions,
   listWorkflows,
   loadAgentMetadata,
   loadConfig,
   loadContext,
+  loadGuidelineConfig,
   loadIndex,
+  loadLearningConfig,
   loadManifest,
   loadMetadata,
+  loadPatternStore,
   loadPlugin,
   loadPluginsFromDirectory,
+  loadProfileConfig,
+  loadSessionFile,
   loadSkillMetadata,
   loadWorkflow,
   loadWorkflowByName,
   memoryDirectoryExists,
+  mergePatterns,
   parseAgentDir,
   parseAgentFile,
   parseShorthand,
@@ -20072,14 +21775,27 @@ export {
   parseWorkflow,
   readAgentContent,
   readSkillContent,
+  recordFailure,
+  recordSuccess,
+  rejectPattern,
+  removeCustomGuideline,
+  removeCustomProfile,
   removeFromManifest,
+  removePattern,
   runTestSuite,
   saveConfig,
+  saveGeneratedSkill,
+  saveGuidelineConfig,
   saveIndex,
+  saveLearningConfig,
   saveManifest,
+  savePatternStore,
+  saveProfileConfig,
+  saveSessionFile,
   saveSkillMetadata,
   saveWorkflow,
   serializeWorkflow,
+  setActiveProfile,
   setSkillEnabled,
   shellExecutor,
   skillMdTranslator,
@@ -20097,6 +21813,7 @@ export {
   translateSkillToAgent,
   translateSkillToAll,
   translatorRegistry,
+  updateSessionFile,
   validateAgent,
   validateBuiltinPacks,
   validatePackDirectory,