@skillkit/core 1.11.0 → 1.13.0

package/dist/index.js

@@ -10420,11 +10420,20 @@ import { parse as parseYaml7, stringify as stringifyYaml5 } from "yaml";
 import { randomUUID as randomUUID8 } from "crypto";
 var ObservationStore = class {
   filePath;
+  projectPath;
   data = null;
   sessionId;
-  constructor(projectPath, sessionId) {
+  compressionThreshold;
+  autoCompress;
+  onThresholdReached;
+  compressionInProgress = false;
+  constructor(projectPath, sessionId, options = {}) {
+    this.projectPath = projectPath;
     this.filePath = join21(projectPath, ".skillkit", "memory", "observations.yaml");
     this.sessionId = sessionId || randomUUID8();
+    this.compressionThreshold = options.compressionThreshold ?? 50;
+    this.autoCompress = options.autoCompress ?? true;
+    this.onThresholdReached = options.onThresholdReached;
   }
   ensureDir() {
     const dir = dirname4(this.filePath);
@@ -10475,8 +10484,66 @@ var ObservationStore = class {
     };
     data.observations.push(observation);
     this.save();
+    void this.checkAutoCompression().catch(() => {
+    });
     return observation;
   }
+  /**
+   * Check if auto-compression should trigger
+   */
+  async checkAutoCompression() {
+    if (!this.autoCompress || this.compressionInProgress) return;
+    if (!this.onThresholdReached) return;
+    const count = this.count();
+    if (count >= this.compressionThreshold) {
+      this.compressionInProgress = true;
+      try {
+        const observations = this.getAll();
+        await this.onThresholdReached(observations);
+      } finally {
+        this.compressionInProgress = false;
+      }
+    }
+  }
+  /**
+   * Set auto-compression callback
+   */
+  setAutoCompressCallback(callback) {
+    this.onThresholdReached = callback;
+  }
+  /**
+   * Enable/disable auto-compression
+   */
+  setAutoCompress(enabled) {
+    this.autoCompress = enabled;
+  }
+  /**
+   * Set compression threshold
+   */
+  setCompressionThreshold(threshold) {
+    if (threshold < 1 || !Number.isInteger(threshold)) {
+      throw new Error("Compression threshold must be a positive integer");
+    }
+    this.compressionThreshold = threshold;
+  }
+  /**
+   * Get compression threshold
+   */
+  getCompressionThreshold() {
+    return this.compressionThreshold;
+  }
+  /**
+   * Check if threshold is reached
+   */
+  isThresholdReached() {
+    return this.count() >= this.compressionThreshold;
+  }
+  /**
+   * Get project path
+   */
+  getProjectPath() {
+    return this.projectPath;
+  }
   getAll() {
     return this.load().observations;
   }
@@ -11364,7 +11431,6 @@ var MemoryObserver = class {
     }
     let score = 50;
     switch (event.type) {
-      // High relevance events
       case "error_encountered":
       case "task_failed":
         score = 85;
@@ -11384,7 +11450,6 @@ var MemoryObserver = class {
       case "verification_failed":
         score = 80;
         break;
-      // Medium relevance events
       case "file_modified":
         score = 60;
         if (event.files && event.files.length > 3) {
@@ -11398,7 +11463,6 @@ var MemoryObserver = class {
       case "verification_passed":
         score = 50;
         break;
-      // Lower relevance events
       case "task_start":
         score = 30;
         break;
@@ -12169,7 +12233,6 @@ Generate up to ${opts.maxLearnings} learnings. Only include learnings with impor
         return typeof item === "object" && typeof item.title === "string" && typeof item.content === "string" && Array.isArray(item.tags) && typeof item.importance === "number";
       }).map((item) => ({
         ...item,
-        // Validate source observation IDs
         sourceObservationIds: (item.sourceObservationIds || []).filter(
           (id) => observationIds.has(id)
         ),
@@ -12284,7 +12347,6 @@ var LearningConsolidator = class {
     const base = this.getBetterLearning(learning1, learning2);
     const other = base === learning1 ? learning2 : learning1;
     return {
-      // Preserve the source from the base learning instead of hard-coding 'session'
       source: base.source,
       sourceObservations: [
         ...base.sourceObservations || [],
@@ -12876,9 +12938,1429 @@ function createMemoryInjector(projectPath, projectName, projectContext) {
   return new MemoryInjector(projectPath, projectName, projectContext);
 }
 
+// src/memory/hooks/types.ts
+var DEFAULT_MEMORY_HOOK_CONFIG = {
+  enabled: true,
+  autoInjectOnSessionStart: true,
+  autoCaptureToolUse: true,
+  autoCompressOnSessionEnd: true,
+  minRelevanceForCapture: 30,
+  maxTokensForInjection: 2e3,
+  compressionThreshold: 50,
+  capturePatterns: ["*"],
+  excludeTools: ["Read", "Glob", "Grep"]
+};
+
+// src/memory/hooks/session-start.ts
+import { basename as basename9 } from "path";
+var SessionStartHook = class {
+  config;
+  projectPath;
+  agent;
+  constructor(projectPath, agent = "claude-code", config = {}) {
+    this.projectPath = projectPath;
+    this.agent = agent;
+    this.config = { ...DEFAULT_MEMORY_HOOK_CONFIG, ...config };
+  }
+  /**
+   * Execute the session start hook
+   */
+  async execute(context) {
+    if (!this.config.enabled || !this.config.autoInjectOnSessionStart) {
+      return {
+        injected: false,
+        learnings: [],
+        tokenCount: 0,
+        formattedContent: ""
+      };
+    }
+    const status = getMemoryStatus(this.projectPath);
+    if (!status.projectMemoryExists && !status.globalMemoryExists) {
+      return {
+        injected: false,
+        learnings: [],
+        tokenCount: 0,
+        formattedContent: ""
+      };
+    }
+    const projectName = context.project_path ? basename9(context.project_path.replace(/\/+$/, "")) || void 0 : void 0;
+    const injector = new MemoryInjector(this.projectPath, projectName);
+    const result = await injector.injectForAgent(this.agent, {
+      maxTokens: this.config.maxTokensForInjection,
+      minRelevance: this.config.minRelevanceForCapture,
+      maxLearnings: 10,
+      includeGlobal: true,
+      disclosureLevel: "preview"
+    });
+    const learnings = result.memories.map((m) => m.learning);
+    return {
+      injected: result.memories.length > 0,
+      learnings,
+      tokenCount: result.totalTokens,
+      formattedContent: result.formattedContent
+    };
+  }
+  /**
+   * Generate Claude Code hook output format
+   */
+  async generateHookOutput(context) {
+    const result = await this.execute(context);
+    return this.generateHookOutputFromResult(result);
+  }
+  /**
+   * Generate hook output from pre-computed result (avoids double execution)
+   */
+  generateHookOutputFromResult(result) {
+    if (!result.injected || result.learnings.length === 0) {
+      return { continue: true };
+    }
+    return {
+      continue: true,
+      inject: this.formatInjection(result)
+    };
+  }
+  /**
+   * Format learnings for injection into Claude Code context
+   */
+  formatInjection(result) {
+    if (result.learnings.length === 0) {
+      return "";
+    }
+    const lines = [
+      "<skillkit-memories>",
+      `<!-- ${result.learnings.length} relevant learnings from previous sessions (${result.tokenCount} tokens) -->`,
+      ""
+    ];
+    for (const learning of result.learnings) {
+      lines.push(`## ${learning.title}`);
+      lines.push(`Tags: ${learning.tags.join(", ")}`);
+      if (learning.frameworks && learning.frameworks.length > 0) {
+        lines.push(`Frameworks: ${learning.frameworks.join(", ")}`);
+      }
+      lines.push("");
+      const preview = learning.content.slice(0, 200);
+      lines.push(preview + (learning.content.length > 200 ? "..." : ""));
+      lines.push("");
+    }
+    lines.push("</skillkit-memories>");
+    return lines.join("\n");
+  }
+  /**
+   * Get configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update configuration
+   */
+  setConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+};
+function createSessionStartHook(projectPath, agent = "claude-code", config = {}) {
+  return new SessionStartHook(projectPath, agent, config);
+}
+async function executeSessionStartHook(projectPath, context, config = {}) {
+  const hook = new SessionStartHook(projectPath, context.agent || "claude-code", config);
+  return hook.execute(context);
+}
+
+// src/memory/hooks/post-tool-use.ts
+var TOOL_CATEGORIES = {
+  Read: "tool_use",
+  Write: "file_change",
+  Edit: "file_change",
+  Bash: "tool_use",
+  Glob: "tool_use",
+  Grep: "tool_use",
+  WebFetch: "tool_use",
+  WebSearch: "tool_use",
+  Task: "checkpoint",
+  AskUserQuestion: "decision"
+};
+var TOOL_RELEVANCE = {
+  Write: 70,
+  Edit: 70,
+  Bash: 60,
+  Task: 65,
+  AskUserQuestion: 75,
+  WebFetch: 50,
+  WebSearch: 50,
+  Read: 30,
+  Glob: 25,
+  Grep: 30
+};
+var PostToolUseHook = class {
+  config;
+  agent;
+  store;
+  pendingErrors = /* @__PURE__ */ new Map();
+  constructor(projectPath, agent = "claude-code", config = {}, sessionId) {
+    this.agent = agent;
+    this.config = { ...DEFAULT_MEMORY_HOOK_CONFIG, ...config };
+    this.store = new ObservationStore(projectPath, sessionId);
+  }
+  /**
+   * Execute the post tool use hook
+   */
+  async execute(event) {
+    this.clearOldPendingErrors();
+    if (!this.config.enabled || !this.config.autoCaptureToolUse) {
+      return { captured: false, reason: "Hook disabled" };
+    }
+    if (this.shouldExcludeTool(event.tool_name)) {
+      return { captured: false, reason: `Tool ${event.tool_name} is excluded` };
+    }
+    const relevance = this.calculateRelevance(event);
+    if (relevance < this.config.minRelevanceForCapture) {
+      return { captured: false, reason: `Relevance ${relevance} below threshold` };
+    }
+    const observationType = this.getObservationType(event);
+    const content = this.extractContent(event);
+    if (event.is_error) {
+      const errorId = this.generateErrorId(content.error || content.action);
+      this.pendingErrors.set(errorId, {
+        error: content.error || content.action,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    const matchingSolution = event.is_error ? void 0 : this.findMatchingSolution(content);
+    if (matchingSolution) {
+      content.solution = content.action;
+      content.context = `Solution for: ${matchingSolution.error}`;
+    }
+    const observation = this.store.add(
+      observationType,
+      content,
+      this.agent,
+      matchingSolution ? 95 : relevance
+    );
+    return { captured: true, observation };
+  }
+  /**
+   * Generate Claude Code hook output format
+   */
+  async generateHookOutput(event) {
+    const result = await this.execute(event);
+    return this.generateHookOutputFromResult(event, result);
+  }
+  /**
+   * Generate hook output from pre-computed result (avoids double execution)
+   */
+  generateHookOutputFromResult(event, result) {
+    return {
+      continue: true,
+      message: result.captured ? `Observation captured: ${event.tool_name}` : void 0
+    };
+  }
+  /**
+   * Get configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update configuration
+   */
+  setConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Record an error explicitly
+   */
+  recordError(error, context) {
+    const errorId = this.generateErrorId(error);
+    this.pendingErrors.set(errorId, {
+      error,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return this.store.add(
+      "error",
+      {
+        action: "Error encountered",
+        context,
+        error,
+        tags: ["error"]
+      },
+      this.agent,
+      80
+    );
+  }
+  /**
+   * Record a solution explicitly
+   */
+  recordSolution(solution, context, relatedError) {
+    let relevance = 70;
+    let solutionContext = context;
+    if (relatedError) {
+      const errorId = this.generateErrorId(relatedError);
+      if (this.pendingErrors.has(errorId)) {
+        this.pendingErrors.delete(errorId);
+        relevance = 95;
+        solutionContext = `Solution for: ${relatedError}`;
+      }
+    }
+    return this.store.add(
+      "solution",
+      {
+        action: solution,
+        context: solutionContext,
+        solution,
+        tags: ["solution"]
+      },
+      this.agent,
+      relevance
+    );
+  }
+  /**
+   * Record a decision explicitly
+   */
+  recordDecision(decision, options, context) {
+    return this.store.add(
+      "decision",
+      {
+        action: decision,
+        context: `Options: ${options.join(", ")}. Context: ${context}`,
+        tags: ["decision", "architecture"]
+      },
+      this.agent,
+      75
+    );
+  }
+  /**
+   * Record file modifications
+   */
+  recordFileChange(files, action, context) {
+    return this.store.add(
+      "file_change",
+      {
+        action,
+        context,
+        files,
+        tags: ["file-change"]
+      },
+      this.agent,
+      files.length > 3 ? 75 : 60
+    );
+  }
+  /**
+   * Get pending errors that haven't been resolved
+   */
+  getPendingErrors() {
+    return Array.from(this.pendingErrors.values());
+  }
+  /**
+   * Clear old pending errors (older than 30 minutes)
+   */
+  clearOldPendingErrors() {
+    const thirtyMinutesAgo = Date.now() - 30 * 60 * 1e3;
+    let cleared = 0;
+    for (const [id, { timestamp }] of this.pendingErrors) {
+      if (new Date(timestamp).getTime() < thirtyMinutesAgo) {
+        this.pendingErrors.delete(id);
+        cleared++;
+      }
+    }
+    return cleared;
+  }
+  /**
+   * Get observation store
+   */
+  getStore() {
+    return this.store;
+  }
+  /**
+   * Get observation count
+   */
+  getObservationCount() {
+    return this.store.count();
+  }
+  shouldExcludeTool(toolName) {
+    return this.config.excludeTools?.includes(toolName) ?? false;
+  }
+  calculateRelevance(event) {
+    let relevance = TOOL_RELEVANCE[event.tool_name] || 50;
+    if (event.is_error) {
+      relevance = Math.max(relevance, 80);
+    }
+    if (event.duration_ms && event.duration_ms > 1e4) {
+      relevance = Math.min(relevance + 10, 100);
+    }
+    const result = event.tool_result || "";
+    if (result.includes("error") || result.includes("Error") || result.includes("failed")) {
+      relevance = Math.max(relevance, 75);
+    }
+    if (result.includes("success") || result.includes("created") || result.includes("updated")) {
+      relevance = Math.min(relevance + 5, 100);
+    }
+    return relevance;
+  }
+  getObservationType(event) {
+    if (event.is_error) {
+      return "error";
+    }
+    return TOOL_CATEGORIES[event.tool_name] || "tool_use";
+  }
+  extractContent(event) {
+    const content = {
+      action: `${event.tool_name}: ${this.summarizeInput(event.tool_input)}`,
+      context: this.extractContext(event),
+      tags: [event.tool_name.toLowerCase()]
+    };
+    if (event.is_error && event.tool_result) {
+      content.error = event.tool_result.slice(0, 500);
+    }
+    if (event.tool_result && !event.is_error) {
+      content.result = event.tool_result.slice(0, 200);
+    }
+    const files = this.extractFiles(event);
+    if (files.length > 0) {
+      content.files = files;
+    }
+    return content;
+  }
+  summarizeInput(input) {
+    if (input.file_path) return String(input.file_path);
+    if (input.pattern) return String(input.pattern);
+    if (input.command) {
+      const cmd = String(input.command);
+      return cmd.length > 100 ? cmd.slice(0, 100) + "..." : cmd;
+    }
+    if (input.query) return String(input.query).slice(0, 100);
+    const keys = Object.keys(input);
+    if (keys.length === 0) return "(no input)";
+    return keys.slice(0, 3).join(", ");
+  }
+  extractContext(event) {
+    const parts = [];
+    if (event.duration_ms) {
+      parts.push(`Duration: ${event.duration_ms}ms`);
+    }
+    if (event.is_error) {
+      parts.push("Result: Error");
+    } else if (event.tool_result) {
+      const resultPreview = event.tool_result.slice(0, 100);
+      parts.push(`Result: ${resultPreview}${event.tool_result.length > 100 ? "..." : ""}`);
+    }
+    return parts.join(". ") || "No additional context";
+  }
+  extractFiles(event) {
+    const files = [];
+    if (event.tool_input.file_path) {
+      files.push(String(event.tool_input.file_path));
+    }
+    if (event.tool_input.path) {
+      files.push(String(event.tool_input.path));
+    }
+    return files;
+  }
+  generateErrorId(error) {
+    const normalized = error.toLowerCase().replace(/[0-9]+/g, "N").replace(/['"`]/g, "").replace(/\s+/g, " ").trim().slice(0, 100);
+    return normalized;
+  }
+  findMatchingSolution(content) {
+    const actionLower = content.action.toLowerCase();
+    const contextLower = content.context.toLowerCase();
+    for (const [errorId, errorData] of this.pendingErrors) {
+      const hasKeywordMatch = actionLower.includes("fix") || actionLower.includes("resolve") || actionLower.includes("solution") || contextLower.includes("fix") || contextLower.includes("resolve");
+      if (hasKeywordMatch) {
+        const errorWords = errorId.split(" ").filter((w) => w.length > 3);
+        const textWords = new Set((actionLower + " " + contextLower).split(/\s+/));
+        const matchCount = errorWords.filter((w) => textWords.has(w)).length;
+        if (matchCount >= 2 || matchCount >= 1 && hasKeywordMatch) {
+          this.pendingErrors.delete(errorId);
+          return errorData;
+        }
+      }
+    }
+    return void 0;
+  }
+};
+function createPostToolUseHook(projectPath, agent = "claude-code", config = {}, sessionId) {
+  return new PostToolUseHook(projectPath, agent, config, sessionId);
+}
+async function executePostToolUseHook(projectPath, event, config = {}, sessionId) {
+  const hook = new PostToolUseHook(projectPath, "claude-code", config, sessionId);
+  return hook.execute(event);
+}
+
+// src/memory/hooks/session-end.ts
+import { basename as basename10 } from "path";
+var SessionEndHook = class {
+  config;
+  projectPath;
+  agent;
+  constructor(projectPath, agent = "claude-code", config = {}) {
+    this.projectPath = projectPath;
+    this.agent = agent;
+    this.config = { ...DEFAULT_MEMORY_HOOK_CONFIG, ...config };
+  }
+  /**
+   * Execute the session end hook
+   */
+  async execute(context) {
+    if (!this.config.enabled || !this.config.autoCompressOnSessionEnd) {
+      return {
+        compressed: false,
+        observationCount: 0,
+        learningCount: 0,
+        learnings: []
+      };
+    }
+    const store = new ObservationStore(this.projectPath, context.session_id);
+    const observations = store.getAll();
+    if (observations.length < 3) {
+      return {
+        compressed: false,
+        observationCount: observations.length,
+        learningCount: 0,
+        learnings: []
+      };
+    }
+    const projectName = context.project_path ? basename10(context.project_path.replace(/\/+$/, "")) || void 0 : void 0;
+    const compressor = new MemoryCompressor(this.projectPath, {
+      scope: "project",
+      projectName
+    });
+    const { learnings, result } = await compressor.compressAndStore(observations, {
+      minObservations: 3,
+      maxLearnings: 10,
+      minImportance: 4,
+      includeLowRelevance: false,
+      additionalTags: ["session-end", this.agent]
+    });
+    if (result.processedObservationIds.length > 0) {
+      store.deleteMany(result.processedObservationIds);
+    }
+    return {
+      compressed: learnings.length > 0,
+      observationCount: observations.length,
+      learningCount: learnings.length,
+      learnings
+    };
+  }
+  /**
+   * Generate Claude Code hook output format
+   */
+  async generateHookOutput(context) {
+    const result = await this.execute(context);
+    return this.generateHookOutputFromResult(result);
+  }
+  /**
+   * Generate hook output from pre-computed result (avoids double execution)
+   */
+  generateHookOutputFromResult(result) {
+    let message;
+    if (result.compressed) {
+      message = `Session memory: ${result.observationCount} observations \u2192 ${result.learningCount} learnings`;
+    }
+    return {
+      continue: true,
+      message
+    };
+  }
+  /**
+   * Force compression regardless of settings
+   */
+  async forceCompress(sessionId) {
+    const store = new ObservationStore(this.projectPath, sessionId);
+    const observations = store.getAll();
+    if (observations.length === 0) {
+      return {
+        compressed: false,
+        observationCount: 0,
+        learningCount: 0,
+        learnings: []
+      };
+    }
+    const compressor = new MemoryCompressor(this.projectPath, {
+      scope: "project"
+    });
+    const { learnings, result } = await compressor.compressAndStore(observations, {
+      minObservations: 1,
+      maxLearnings: 20,
+      minImportance: 3,
+      includeLowRelevance: true
+    });
+    if (result.processedObservationIds.length > 0) {
+      store.deleteMany(result.processedObservationIds);
+    }
+    return {
+      compressed: learnings.length > 0,
+      observationCount: observations.length,
+      learningCount: learnings.length,
+      learnings
+    };
+  }
+  /**
+   * Preview what would be compressed (dry-run)
+   */
+  async preview(sessionId) {
+    const store = new ObservationStore(this.projectPath, sessionId);
+    const observations = store.getAll();
+    const types = {};
+    for (const obs of observations) {
+      types[obs.type] = (types[obs.type] || 0) + 1;
+    }
+    const compressor = new MemoryCompressor(this.projectPath, {
+      scope: "project"
+    });
+    const result = await compressor.compress(observations, {
+      minObservations: 3,
+      maxLearnings: 10,
+      minImportance: 4
+    });
+    return {
+      wouldCompress: result.learnings.length > 0,
+      observationCount: observations.length,
+      estimatedLearnings: result.learnings.length,
+      observationTypes: types
+    };
+  }
+  /**
+   * Get configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update configuration
+   */
+  setConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+};
+function createSessionEndHook(projectPath, agent = "claude-code", config = {}) {
+  return new SessionEndHook(projectPath, agent, config);
+}
+async function executeSessionEndHook(projectPath, context, config = {}) {
+  const hook = new SessionEndHook(projectPath, context.agent || "claude-code", config);
+  return hook.execute(context);
+}
+
+// src/memory/hooks/manager.ts
+import { randomUUID as randomUUID10 } from "crypto";
+var MemoryHookManager = class {
+  config;
+  projectPath;
+  agent;
+  sessionId;
+  startedAt;
+  sessionStartHook;
+  postToolUseHook;
+  sessionEndHook;
+  stats;
+  constructor(projectPath, agent = "claude-code", config = {}, sessionId) {
+    this.projectPath = projectPath;
+    this.agent = agent;
+    this.config = { ...DEFAULT_MEMORY_HOOK_CONFIG, ...config };
+    this.sessionId = sessionId || randomUUID10();
+    this.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.sessionStartHook = new SessionStartHook(projectPath, agent, this.config);
+    this.postToolUseHook = new PostToolUseHook(projectPath, agent, this.config, this.sessionId);
+    this.sessionEndHook = new SessionEndHook(projectPath, agent, this.config);
+    this.stats = {
+      sessionId: this.sessionId,
+      startedAt: this.startedAt,
+      observationsCaptured: 0,
+      learningsInjected: 0,
+      tokensUsed: 0,
+      toolCallsCaptured: 0,
+      errorsRecorded: 0,
+      solutionsRecorded: 0
+    };
+  }
+  /**
+   * Handle session start
+   */
+  async onSessionStart(workingDirectory) {
+    const context = {
+      session_id: this.sessionId,
+      project_path: this.projectPath,
+      agent: this.agent,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      working_directory: workingDirectory
+    };
+    const result = await this.sessionStartHook.execute(context);
+    this.stats.learningsInjected = result.learnings.length;
+    this.stats.tokensUsed = result.tokenCount;
+    return this.sessionStartHook.generateHookOutputFromResult(result);
+  }
+  /**
+   * Handle tool use
+   */
+  async onToolUse(event) {
+    const result = await this.postToolUseHook.execute(event);
+    if (result.captured) {
+      this.stats.observationsCaptured++;
+      this.stats.toolCallsCaptured++;
+      if (result.observation?.type === "error") {
+        this.stats.errorsRecorded++;
+      } else if (result.observation?.type === "solution") {
+        this.stats.solutionsRecorded++;
+      }
+    }
+    await this.checkAutoCompression();
+    return this.postToolUseHook.generateHookOutputFromResult(event, result);
+  }
+  /**
+   * Handle session end
+   */
+  async onSessionEnd(toolCallsCount) {
+    const context = {
+      session_id: this.sessionId,
+      project_path: this.projectPath,
+      agent: this.agent,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      duration_ms: Date.now() - new Date(this.startedAt).getTime(),
+      tool_calls_count: toolCallsCount
+    };
+    const result = await this.sessionEndHook.execute(context);
+    return this.sessionEndHook.generateHookOutputFromResult(result);
+  }
+  /**
+   * Record an error manually
+   */
+  recordError(error, context) {
+    const obs = this.postToolUseHook.recordError(error, context);
+    this.stats.observationsCaptured++;
+    this.stats.errorsRecorded++;
+    return obs;
+  }
+  /**
+   * Record a solution manually
+   */
+  recordSolution(solution, context, relatedError) {
+    const obs = this.postToolUseHook.recordSolution(solution, context, relatedError);
+    this.stats.observationsCaptured++;
+    this.stats.solutionsRecorded++;
+    return obs;
+  }
+  /**
+   * Record a decision manually
+   */
+  recordDecision(decision, options, context) {
+    const obs = this.postToolUseHook.recordDecision(decision, options, context);
+    this.stats.observationsCaptured++;
+    return obs;
+  }
+  /**
+   * Record file changes manually
+   */
+  recordFileChange(files, action, context) {
+    const obs = this.postToolUseHook.recordFileChange(files, action, context);
+    this.stats.observationsCaptured++;
+    return obs;
+  }
+  /**
+   * Force compression (regardless of threshold)
+   */
+  async forceCompress() {
+    const result = await this.sessionEndHook.forceCompress(this.sessionId);
+    return result.learnings;
+  }
+  /**
+   * Preview compression without executing
+   */
+  async previewCompression() {
+    return this.sessionEndHook.preview(this.sessionId);
+  }
+  /**
+   * Get current stats
+   */
+  getStats() {
+    return { ...this.stats };
+  }
+  /**
+   * Get session ID
+   */
+  getSessionId() {
+    return this.sessionId;
+  }
+  /**
+   * Get observation count
+   */
+  getObservationCount() {
+    return this.postToolUseHook.getObservationCount();
+  }
+  /**
+   * Get pending errors
+   */
+  getPendingErrors() {
+    return this.postToolUseHook.getPendingErrors();
+  }
+  /**
+   * Get configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update configuration
+   */
+  setConfig(config) {
+    this.config = { ...this.config, ...config };
+    this.sessionStartHook.setConfig(this.config);
+    this.postToolUseHook.setConfig(this.config);
+    this.sessionEndHook.setConfig(this.config);
+  }
+  /**
+   * Check if auto-compression should trigger
+   */
+  async checkAutoCompression() {
+    if (!this.config.enabled) return;
+    const count = this.postToolUseHook.getObservationCount();
+    if (count >= this.config.compressionThreshold) {
+      await this.sessionEndHook.forceCompress(this.sessionId);
+    }
+  }
+  /**
+   * Generate Claude Code hooks.json configuration
+   */
+  generateClaudeCodeHooksConfig() {
+    return {
+      hooks: [
+        {
+          matcher: ".*",
+          hooks: [
+            {
+              type: "command",
+              command: `npx skillkit memory hook session-start --project "${this.projectPath}"`,
+              event: "SessionStart"
+            },
+            {
+              type: "command",
+              command: `npx skillkit memory hook post-tool-use --project "${this.projectPath}"`,
+              event: "PostToolUse"
+            },
+            {
+              type: "command",
+              command: `npx skillkit memory hook session-end --project "${this.projectPath}"`,
+              event: "SessionEnd"
+            }
+          ]
+        }
+      ]
+    };
+  }
+};
+function createMemoryHookManager(projectPath, agent = "claude-code", config = {}, sessionId) {
+  return new MemoryHookManager(projectPath, agent, config, sessionId);
+}
+
+// src/memory/claude-md-updater.ts
+import { existsSync as existsSync26, readFileSync as readFileSync16, writeFileSync as writeFileSync14, mkdirSync as mkdirSync15 } from "fs";
+import { join as join25, dirname as dirname7, basename as basename11 } from "path";
+import { homedir as homedir12 } from "os";
+var SKILLKIT_MARKER = "<!-- Auto-populated by SkillKit -->";
+var DEFAULT_UPDATE_OPTIONS = {
+  minEffectiveness: 60,
+  maxLearnings: 20,
+  includeGlobal: false,
+  preserveManualEntries: true,
+  sectionTitle: "LEARNED",
+  addTimestamp: true
+};
+var ClaudeMdUpdater = class {
+  projectPath;
+  claudeMdPath;
+  constructor(projectPath, claudeMdPath) {
+    this.projectPath = projectPath;
+    this.claudeMdPath = claudeMdPath || join25(projectPath, "CLAUDE.md");
+  }
+  /**
+   * Parse CLAUDE.md to extract structure
+   */
+  parse() {
+    if (!existsSync26(this.claudeMdPath)) {
+      return {
+        content: "",
+        sections: /* @__PURE__ */ new Map(),
+        hasLearnedSection: false
+      };
+    }
+    const content = readFileSync16(this.claudeMdPath, "utf-8");
+    const sections = /* @__PURE__ */ new Map();
+    const lines = content.split("\n");
+    let currentSection = null;
+    let sectionStart = 0;
+    let sectionContent = [];
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const headerMatch = line.match(/^(#{1,3})\s+(.+)$/);
+      if (headerMatch) {
+        if (currentSection) {
+          sections.set(currentSection, {
+            start: sectionStart,
+            end: i - 1,
+            content: sectionContent.join("\n")
+          });
+        }
+        currentSection = headerMatch[2].trim();
+        sectionStart = i;
+        sectionContent = [line];
+      } else if (currentSection) {
+        sectionContent.push(line);
+      }
+    }
+    if (currentSection) {
+      sections.set(currentSection, {
+        start: sectionStart,
+        end: lines.length - 1,
+        content: sectionContent.join("\n")
+      });
+    }
+    const learnedSection = sections.get("LEARNED") || sections.get("Learned");
+    const hasLearnedSection = !!learnedSection;
+    return {
+      content,
+      sections,
+      hasLearnedSection,
+      learnedSectionContent: learnedSection?.content,
+      learnedSectionRange: learnedSection ? { start: learnedSection.start, end: learnedSection.end } : void 0
+    };
+  }
+  /**
+   * Get learnings to add to CLAUDE.md
+   */
+  getLearningsForClaudeMd(options = {}) {
+    const opts = { ...DEFAULT_UPDATE_OPTIONS, ...options };
+    const projectStore = new LearningStore("project", this.projectPath);
+    let learnings = projectStore.getAll();
+    if (opts.includeGlobal) {
+      const globalStore = new LearningStore("global");
+      learnings = [...learnings, ...globalStore.getAll()];
+    }
+    return learnings.filter((l) => (l.effectiveness ?? 0) >= opts.minEffectiveness || l.useCount >= 3).sort((a, b) => {
+      const scoreA = (a.effectiveness ?? 50) + a.useCount * 5;
+      const scoreB = (b.effectiveness ?? 50) + b.useCount * 5;
+      return scoreB - scoreA;
+    }).slice(0, opts.maxLearnings);
+  }
+  /**
+   * Format learnings as CLAUDE.md LEARNED section
+   */
+  formatLearnedSection(learnings, options = {}) {
+    const opts = { ...DEFAULT_UPDATE_OPTIONS, ...options };
+    const lines = [];
+    lines.push(`## ${opts.sectionTitle}`);
+    lines.push("");
+    lines.push(SKILLKIT_MARKER);
+    if (opts.addTimestamp) {
+      lines.push(`<!-- Last updated: ${(/* @__PURE__ */ new Date()).toISOString()} -->`);
+    }
+    lines.push("");
+    const byCategory = this.categorizeLearnings(learnings);
+    for (const [category, categoryLearnings] of byCategory) {
+      if (categoryLearnings.length > 0) {
+        lines.push(`### ${category}`);
+        for (const learning of categoryLearnings) {
+          const title = this.formatLearningTitle(learning);
+          const summary = this.extractSummary(learning.content);
+          lines.push(`${title}`);
+          lines.push(summary);
+          lines.push("");
+        }
+      }
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Update CLAUDE.md with learnings
+   */
+  update(options = {}) {
+    const opts = { ...DEFAULT_UPDATE_OPTIONS, ...options };
+    const learnings = this.getLearningsForClaudeMd(opts);
+    if (learnings.length === 0) {
+      return {
+        updated: false,
+        path: this.claudeMdPath,
+        learningsAdded: 0,
+        learningSummaries: [],
+        previousLearnings: 0
+      };
+    }
+    const parsed = this.parse();
+    const newSection = this.formatLearnedSection(learnings, opts);
+    let newContent;
+    let previousLearnings = 0;
+    if (parsed.hasLearnedSection && parsed.learnedSectionRange) {
+      if (opts.preserveManualEntries) {
+        const existingContent = parsed.learnedSectionContent || "";
+        const manualEntries = this.extractManualEntries(existingContent);
+        previousLearnings = this.countLearnings(existingContent);
+        const combinedSection = this.combineWithManualEntries(newSection, manualEntries);
+        const lines = parsed.content.split("\n");
+        const before = lines.slice(0, parsed.learnedSectionRange.start).join("\n");
+        const after = lines.slice(parsed.learnedSectionRange.end + 1).join("\n");
+        newContent = before + (before ? "\n" : "") + combinedSection + (after ? "\n" + after : "");
+      } else {
+        const lines = parsed.content.split("\n");
+        const before = lines.slice(0, parsed.learnedSectionRange.start).join("\n");
+        const after = lines.slice(parsed.learnedSectionRange.end + 1).join("\n");
+        newContent = before + (before ? "\n" : "") + newSection + (after ? "\n" + after : "");
+      }
+    } else if (parsed.content) {
+      newContent = parsed.content + "\n\n" + newSection;
+    } else {
+      newContent = this.createNewClaudeMd(newSection);
+    }
+    const dir = dirname7(this.claudeMdPath);
+    if (!existsSync26(dir)) {
+      mkdirSync15(dir, { recursive: true });
+    }
+    writeFileSync14(this.claudeMdPath, newContent, "utf-8");
+    return {
+      updated: true,
+      path: this.claudeMdPath,
+      learningsAdded: learnings.length,
+      learningSummaries: learnings.map((l) => l.title),
+      previousLearnings
+    };
+  }
+  /**
+   * Preview update without writing
+   */
+  preview(options = {}) {
+    const learnings = this.getLearningsForClaudeMd(options);
+    const formattedSection = this.formatLearnedSection(learnings, options);
+    return {
+      learnings,
+      formattedSection,
+      wouldUpdate: learnings.length > 0
+    };
+  }
+  /**
+   * Check if CLAUDE.md exists
+   */
+  exists() {
+    return existsSync26(this.claudeMdPath);
+  }
+  /**
+   * Get CLAUDE.md path
+   */
+  getPath() {
+    return this.claudeMdPath;
+  }
+  categorizeLearnings(learnings) {
+    const categories = /* @__PURE__ */ new Map();
+    for (const learning of learnings) {
+      let category = "General";
+      if (learning.patterns?.includes("error-handling")) {
+        category = "Error-Handling";
+      } else if (learning.patterns?.includes("debugging")) {
+        category = "Debugging";
+      } else if (learning.patterns?.includes("architecture")) {
+        category = "Architecture";
+      } else if (learning.patterns?.includes("workflow")) {
+        category = "Workflow";
+      } else if (learning.tags.some((t) => t.includes("react") || t.includes("typescript"))) {
+        category = "Code-Patterns";
+      }
+      const existing = categories.get(category) || [];
+      existing.push(learning);
+      categories.set(category, existing);
+    }
+    return categories;
+  }
+  formatLearningTitle(learning) {
+    const tags = learning.tags.slice(0, 3).join(", ");
+    return tags ? `**${tags}**: ${learning.title}` : `**${learning.title}**`;
+  }
+  extractSummary(content) {
+    const lines = content.split("\n").filter((l) => l.trim());
+    for (const line of lines) {
+      const cleaned = line.replace(/^#+\s*/, "").replace(/^\*\*.*?\*\*:?\s*/, "");
+      if (cleaned.length > 20 && !cleaned.startsWith("#")) {
+        return cleaned.slice(0, 200) + (cleaned.length > 200 ? "..." : "");
+      }
+    }
+    return content.slice(0, 200) + (content.length > 200 ? "..." : "");
+  }
+  extractManualEntries(sectionContent) {
+    const lines = sectionContent.split("\n");
+    const manualEntries = [];
+    let inManualEntry = false;
+    let currentEntry = [];
+    for (const line of lines) {
+      if (line.includes(SKILLKIT_MARKER)) {
+        inManualEntry = false;
+        continue;
+      }
+      if (line.startsWith("### ") && !line.includes("Auto-populated")) {
+        if (currentEntry.length > 0) {
+          manualEntries.push(currentEntry.join("\n"));
+        }
+        inManualEntry = true;
+        currentEntry = [line];
+      } else if (inManualEntry) {
+        currentEntry.push(line);
+      }
+    }
+    if (currentEntry.length > 0) {
+      manualEntries.push(currentEntry.join("\n"));
+    }
+    return manualEntries.filter((e) => e.trim().length > 0);
+  }
+  combineWithManualEntries(autoSection, manualEntries) {
+    if (manualEntries.length === 0) {
+      return autoSection;
+    }
+    const lines = autoSection.split("\n");
+    const combinedLines = [...lines];
+    combinedLines.push("");
+    combinedLines.push("### Manual Entries");
+    combinedLines.push("<!-- Preserved from previous edits -->");
+    combinedLines.push("");
+    for (const entry of manualEntries) {
+      combinedLines.push(entry);
+      combinedLines.push("");
+    }
+    return combinedLines.join("\n");
+  }
+  countLearnings(content) {
+    const matches = content.match(/^\*\*[^*]+\*\*/gm);
+    return matches ? matches.length : 0;
+  }
+  createNewClaudeMd(learnedSection) {
+    const projectName = basename11(this.projectPath) || "Project";
+    return `# ${projectName}
+
+${learnedSection}
+`;
+  }
+};
+function createClaudeMdUpdater(projectPath, claudeMdPath) {
+  return new ClaudeMdUpdater(projectPath, claudeMdPath);
+}
+function updateClaudeMd(projectPath, options = {}) {
+  const updater = new ClaudeMdUpdater(projectPath);
+  return updater.update(options);
+}
+function syncGlobalClaudeMd(options = {}) {
+  const globalClaudeMdPath = join25(homedir12(), ".claude", "CLAUDE.md");
+  const updater = new ClaudeMdUpdater(homedir12(), globalClaudeMdPath);
+  const globalOpts = {
+    ...options,
+    includeGlobal: true,
+    sectionTitle: "Global Learnings"
+  };
+  return updater.update(globalOpts);
+}
+
+// src/memory/progressive-disclosure.ts
+var TOKEN_ESTIMATES = {
+  index: 50,
+  timeline: 200,
+  details: 600
+};
+var ProgressiveDisclosureManager = class {
+  projectStore;
+  globalStore;
+  constructor(projectPath, projectName) {
+    this.projectStore = new LearningStore("project", projectPath, projectName);
+    this.globalStore = new LearningStore("global");
+  }
+  /**
+   * Layer 1: Get index of all learnings
+   * Minimal tokens (~50-100 per entry)
+   */
+  getIndex(options = {}) {
+    const projectLearnings = this.projectStore.getAll();
+    const globalLearnings = options.includeGlobal ? this.globalStore.getAll() : [];
+    const allLearnings = [...projectLearnings, ...globalLearnings];
+    return allLearnings.map((learning) => this.toIndexEntry(learning)).sort((a, b) => {
+      const scoreA = (a.effectiveness ?? 50) + a.useCount * 5;
+      const scoreB = (b.effectiveness ?? 50) + b.useCount * 5;
+      return scoreB - scoreA;
+    }).slice(0, options.maxResults ?? 50);
+  }
+  /**
+   * Layer 2: Get timeline entries for specific IDs
+   * Medium tokens (~200 per entry)
+   */
+  getTimeline(ids, options = {}) {
+    const entries = [];
+    for (const id of ids) {
+      let learning = this.projectStore.getById(id);
+      if (!learning && options.includeGlobal) {
+        learning = this.globalStore.getById(id);
+      }
+      if (learning) {
+        entries.push(this.toTimelineEntry(learning));
+      }
+    }
+    return entries.slice(0, options.maxResults ?? 20);
+  }
+  /**
+   * Layer 3: Get full details for specific IDs
+   * High tokens (~500-1000 per entry)
+   */
+  getDetails(ids, options = {}) {
+    const entries = [];
+    for (const id of ids) {
+      let learning = this.projectStore.getById(id);
+      let store = this.projectStore;
+      if (!learning && options.includeGlobal) {
+        learning = this.globalStore.getById(id);
+        store = this.globalStore;
+      }
+      if (learning) {
+        store.incrementUseCount(id);
+        entries.push(this.toDetailsEntry(learning));
+      }
+    }
+    return entries.slice(0, options.maxResults ?? 10);
+  }
+  /**
+   * Smart retrieval with automatic layer selection
+   * Uses minimum tokens needed to satisfy the query.
+   *
+   * Note: tokensUsed reflects cumulative cost of the retrieval operation
+   * (index lookup + any deeper layer fetches), not just the returned entries.
+   * This is intentional since progressive disclosure requires scanning
+   * the index first before fetching timeline/details.
+   */
+  smartRetrieve(query, tokenBudget = 2e3, options = {}) {
+    if (tokenBudget <= 0) {
+      return {
+        layer: 1,
+        entries: [],
+        tokensUsed: 0,
+        tokensRemaining: 0
+      };
+    }
+    const index = this.getIndex(options);
+    if (index.length === 0) {
+      return {
+        layer: 1,
+        entries: [],
+        tokensUsed: 0,
+        tokensRemaining: tokenBudget
+      };
+    }
+    const indexTokens = index.length * TOKEN_ESTIMATES.index;
+    if (tokenBudget < indexTokens) {
+      const maxEntries = Math.floor(tokenBudget / TOKEN_ESTIMATES.index);
+      const limitedIndex = index.slice(0, maxEntries);
+      return {
+        layer: 1,
+        entries: limitedIndex,
+        tokensUsed: limitedIndex.length * TOKEN_ESTIMATES.index,
+        tokensRemaining: tokenBudget - limitedIndex.length * TOKEN_ESTIMATES.index
+      };
+    }
+    const relevantIds = this.findRelevantIds(index, query, options.minRelevance ?? 0);
+    if (relevantIds.length === 0) {
+      return {
+        layer: 1,
+        entries: index,
+        tokensUsed: indexTokens,
+        tokensRemaining: tokenBudget - indexTokens
+      };
+    }
+    const remainingBudget = tokenBudget - indexTokens;
+    const maxTimelineEntries = Math.floor(remainingBudget / TOKEN_ESTIMATES.timeline);
+    if (maxTimelineEntries >= 1) {
+      const timelineIds = relevantIds.slice(0, Math.min(maxTimelineEntries, 10));
+      const timeline = this.getTimeline(timelineIds, options);
+      const timelineTokens = timeline.length * TOKEN_ESTIMATES.timeline;
+      const afterTimelineBudget = remainingBudget - timelineTokens;
+      const maxDetailsEntries = Math.floor(afterTimelineBudget / TOKEN_ESTIMATES.details);
+      if (maxDetailsEntries >= 1) {
+        const detailsIds = timelineIds.slice(0, Math.min(maxDetailsEntries, 5));
+        const details = this.getDetails(detailsIds, options);
+        const detailsTokens = details.length * TOKEN_ESTIMATES.details;
+        return {
+          layer: 3,
+          entries: details,
+          tokensUsed: indexTokens + timelineTokens + detailsTokens,
+          tokensRemaining: tokenBudget - (indexTokens + timelineTokens + detailsTokens)
+        };
+      }
+      return {
+        layer: 2,
+        entries: timeline,
+        tokensUsed: indexTokens + timelineTokens,
+        tokensRemaining: tokenBudget - (indexTokens + timelineTokens)
+      };
+    }
+    return {
+      layer: 1,
+      entries: index,
+      tokensUsed: indexTokens,
+      tokensRemaining: tokenBudget - indexTokens
+    };
+  }
+  /**
+   * Estimate tokens for a given layer and count
+   */
+  estimateTokens(layer, count) {
+    const estimate = {
+      1: TOKEN_ESTIMATES.index,
+      2: TOKEN_ESTIMATES.timeline,
+      3: TOKEN_ESTIMATES.details
+    };
+    return estimate[layer] * count;
+  }
+  /**
+   * Format entries for injection
+   */
+  formatForInjection(entries, layer) {
+    if (entries.length === 0) return "";
+    const lines = ["<skillkit-memories>"];
+    switch (layer) {
+      case 1:
+        lines.push("<!-- Memory Index (summaries only) -->");
+        for (const entry of entries) {
+          lines.push(`- [${entry.id.slice(0, 8)}] ${entry.title} (${entry.tags.join(", ")})`);
+        }
+        break;
+      case 2:
+        lines.push("<!-- Memory Timeline (with context) -->");
+        for (const entry of entries) {
+          lines.push(`## ${entry.title}`);
+          lines.push(`ID: ${entry.id.slice(0, 8)} | Tags: ${entry.tags.join(", ")}`);
+          if (entry.frameworks && entry.frameworks.length > 0) {
+            lines.push(`Frameworks: ${entry.frameworks.join(", ")}`);
+          }
+          lines.push("");
+          lines.push(entry.excerpt);
+          lines.push("");
+        }
+        break;
+      case 3:
+        lines.push("<!-- Memory Details (full content) -->");
+        for (const entry of entries) {
+          lines.push(`## ${entry.title}`);
+          lines.push(`ID: ${entry.id.slice(0, 8)} | Tags: ${entry.tags.join(", ")}`);
+          if (entry.frameworks && entry.frameworks.length > 0) {
+            lines.push(`Frameworks: ${entry.frameworks.join(", ")}`);
+          }
+          if (entry.patterns && entry.patterns.length > 0) {
+            lines.push(`Patterns: ${entry.patterns.join(", ")}`);
+          }
+          lines.push("");
+          lines.push(entry.content);
+          lines.push("");
+        }
+        break;
+    }
+    lines.push("</skillkit-memories>");
+    return lines.join("\n");
+  }
+  toIndexEntry(learning) {
+    return {
+      id: learning.id,
+      title: learning.title,
+      timestamp: learning.updatedAt,
+      tags: learning.tags,
+      scope: learning.scope,
+      effectiveness: learning.effectiveness,
+      useCount: learning.useCount
+    };
+  }
+  toTimelineEntry(learning) {
+    const timeline = this.buildActivityTimeline(learning);
+    return {
+      id: learning.id,
+      title: learning.title,
+      timestamp: learning.updatedAt,
+      tags: learning.tags,
+      scope: learning.scope,
+      effectiveness: learning.effectiveness,
+      useCount: learning.useCount,
+      excerpt: learning.content.slice(0, 200) + (learning.content.length > 200 ? "..." : ""),
+      frameworks: learning.frameworks,
+      patterns: learning.patterns,
+      sourceCount: learning.sourceObservations?.length ?? 0,
+      lastUsed: learning.lastUsed,
+      activityTimeline: timeline
+    };
+  }
+  toDetailsEntry(learning) {
+    const timeline = this.buildActivityTimeline(learning);
+    return {
+      id: learning.id,
+      title: learning.title,
+      timestamp: learning.updatedAt,
+      tags: learning.tags,
+      scope: learning.scope,
+      effectiveness: learning.effectiveness,
+      useCount: learning.useCount,
+      excerpt: learning.content.slice(0, 200) + (learning.content.length > 200 ? "..." : ""),
+      frameworks: learning.frameworks,
+      patterns: learning.patterns,
+      sourceCount: learning.sourceObservations?.length ?? 0,
+      lastUsed: learning.lastUsed,
+      activityTimeline: timeline,
+      content: learning.content,
+      sourceObservations: learning.sourceObservations
+    };
+  }
+  buildActivityTimeline(learning) {
+    const timeline = [];
+    timeline.push({
+      timestamp: learning.createdAt,
+      type: "created",
+      description: `Learning created from ${learning.source}`
+    });
+    if (learning.updatedAt !== learning.createdAt) {
+      timeline.push({
+        timestamp: learning.updatedAt,
+        type: "updated"
+      });
+    }
+    if (learning.lastUsed) {
+      timeline.push({
+        timestamp: learning.lastUsed,
+        type: "used",
+        description: `Used ${learning.useCount} times`
+      });
+    }
+    if (learning.effectiveness !== void 0) {
+      timeline.push({
+        timestamp: learning.updatedAt,
+        type: "rated",
+        description: `Effectiveness: ${learning.effectiveness}%`
+      });
+    }
+    return timeline.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+  }
+  findRelevantIds(index, query, minRelevance = 0) {
+    const queryWords = query.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+    const scored = [];
+    for (const entry of index) {
+      let score = 0;
+      const titleWords = entry.title.toLowerCase().split(/\s+/);
+      for (const qw of queryWords) {
+        if (titleWords.some((tw) => tw.includes(qw))) {
+          score += 10;
+        }
+      }
+      const tags = entry.tags.map((t) => t.toLowerCase());
+      for (const qw of queryWords) {
+        if (tags.includes(qw)) {
+          score += 20;
+        }
+      }
+      score += (entry.effectiveness ?? 50) / 10;
+      score += Math.min(entry.useCount * 2, 20);
+      if (score >= minRelevance) {
+        scored.push({ id: entry.id, score });
+      }
+    }
+    return scored.sort((a, b) => b.score - a.score).map((s) => s.id);
+  }
+};
+function createProgressiveDisclosureManager(projectPath, projectName) {
+  return new ProgressiveDisclosureManager(projectPath, projectName);
+}
+
 // src/team/manager.ts
-import { existsSync as existsSync26, readFileSync as readFileSync16, writeFileSync as writeFileSync14, mkdirSync as mkdirSync15 } from "fs";
-import { join as join25, dirname as dirname7 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync17, writeFileSync as writeFileSync15, mkdirSync as mkdirSync16 } from "fs";
+import { join as join26, dirname as dirname8 } from "path";
 import { execSync as execSync6 } from "child_process";
 import { parse as yamlParse, stringify as yamlStringify } from "yaml";
 var TEAM_CONFIG_FILE = "team.yaml";
@@ -12899,9 +14381,9 @@ var TeamManager = class {
       ...config,
       teamId
     };
-    const teamDir = join25(this.projectPath, TEAM_DIR);
-    if (!existsSync26(teamDir)) {
-      mkdirSync15(teamDir, { recursive: true });
+    const teamDir = join26(this.projectPath, TEAM_DIR);
+    if (!existsSync27(teamDir)) {
+      mkdirSync16(teamDir, { recursive: true });
     }
     this.saveConfig(fullConfig);
     this.config = fullConfig;
@@ -12921,12 +14403,12 @@ var TeamManager = class {
    * Load existing team configuration
    */
   load() {
-    const configPath = join25(this.projectPath, TEAM_DIR, TEAM_CONFIG_FILE);
-    if (!existsSync26(configPath)) {
+    const configPath = join26(this.projectPath, TEAM_DIR, TEAM_CONFIG_FILE);
+    if (!existsSync27(configPath)) {
       return null;
     }
     try {
-      const content = readFileSync16(configPath, "utf-8");
+      const content = readFileSync17(configPath, "utf-8");
       this.config = this.parseYaml(content);
       this.loadRegistry();
       return this.config;
@@ -12957,8 +14439,8 @@ var TeamManager = class {
     if (!skillPath) {
       throw new Error(`Skill "${options.skillName}" not found locally.`);
     }
-    const skillMdPath = join25(skillPath, "SKILL.md");
-    const skillContent = existsSync26(skillMdPath) ? readFileSync16(skillMdPath, "utf-8") : "";
+    const skillMdPath = join26(skillPath, "SKILL.md");
+    const skillContent = existsSync27(skillMdPath) ? readFileSync17(skillMdPath, "utf-8") : "";
     const metadata = this.extractFrontmatter(skillContent);
     const shared = {
       name: options.skillName,
@@ -13023,7 +14505,7 @@ var TeamManager = class {
     if (options.dryRun) {
       return {
         success: true,
-        path: join25(this.projectPath, ".skillkit", "skills", skillName)
+        path: join26(this.projectPath, ".skillkit", "skills", skillName)
       };
     }
     try {
@@ -13073,9 +14555,9 @@ var TeamManager = class {
       if (!fetchResult.success || !fetchResult.path) {
         throw new Error(fetchResult.error || "Failed to fetch remote registry");
       }
-      const remoteRegistryPath = join25(fetchResult.path, TEAM_DIR, "registry.yaml");
-      if (existsSync26(remoteRegistryPath)) {
-        const remoteContent = readFileSync16(remoteRegistryPath, "utf-8");
+      const remoteRegistryPath = join26(fetchResult.path, TEAM_DIR, "registry.yaml");
+      if (existsSync27(remoteRegistryPath)) {
+        const remoteContent = readFileSync17(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) {
@@ -13121,32 +14603,32 @@ var TeamManager = class {
     return `team-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
   }
   saveConfig(config) {
-    const configPath = join25(this.projectPath, TEAM_DIR, TEAM_CONFIG_FILE);
-    const dir = dirname7(configPath);
-    if (!existsSync26(dir)) {
-      mkdirSync15(dir, { recursive: true });
+    const configPath = join26(this.projectPath, TEAM_DIR, TEAM_CONFIG_FILE);
+    const dir = dirname8(configPath);
+    if (!existsSync27(dir)) {
+      mkdirSync16(dir, { recursive: true });
     }
-    writeFileSync14(configPath, this.toYaml(config), "utf-8");
+    writeFileSync15(configPath, this.toYaml(config), "utf-8");
   }
   loadRegistry() {
-    const registryPath = join25(this.projectPath, TEAM_DIR, "registry.yaml");
-    if (existsSync26(registryPath)) {
-      const content = readFileSync16(registryPath, "utf-8");
+    const registryPath = join26(this.projectPath, TEAM_DIR, "registry.yaml");
+    if (existsSync27(registryPath)) {
+      const content = readFileSync17(registryPath, "utf-8");
       this.registry = this.parseYaml(content);
     }
   }
   saveRegistry(registry) {
-    const registryPath = join25(this.projectPath, TEAM_DIR, "registry.yaml");
-    writeFileSync14(registryPath, this.toYaml(registry), "utf-8");
+    const registryPath = join26(this.projectPath, TEAM_DIR, "registry.yaml");
+    writeFileSync15(registryPath, this.toYaml(registry), "utf-8");
   }
   findLocalSkill(skillName) {
     const possiblePaths = [
-      join25(this.projectPath, ".skillkit", "skills", skillName),
-      join25(this.projectPath, "skills", skillName),
-      join25(this.projectPath, ".claude", "skills", skillName)
+      join26(this.projectPath, ".skillkit", "skills", skillName),
+      join26(this.projectPath, "skills", skillName),
+      join26(this.projectPath, ".claude", "skills", skillName)
     ];
     for (const p of possiblePaths) {
-      if (existsSync26(p)) {
+      if (existsSync27(p)) {
         return p;
       }
     }
@@ -13163,13 +14645,13 @@ var TeamManager = class {
   }
   detectCompatibleAgents(skillPath) {
     const agents = [];
-    if (existsSync26(join25(skillPath, "SKILL.md"))) {
+    if (existsSync27(join26(skillPath, "SKILL.md"))) {
       agents.push("claude-code", "codex", "gemini-cli", "universal");
     }
-    if (existsSync26(join25(skillPath, "skill.mdc"))) {
+    if (existsSync27(join26(skillPath, "skill.mdc"))) {
       agents.push("cursor");
     }
-    if (existsSync26(join25(skillPath, "rules.md"))) {
+    if (existsSync27(join26(skillPath, "rules.md"))) {
       agents.push("windsurf");
     }
     return agents.length > 0 ? agents : ["universal"];
@@ -13195,8 +14677,8 @@ function createTeamManager(projectPath) {
 }
 
 // src/team/bundle.ts
-import { existsSync as existsSync27, readFileSync as readFileSync17, writeFileSync as writeFileSync15, mkdirSync as mkdirSync16, readdirSync as readdirSync6, statSync as statSync3 } from "fs";
-import { join as join26, basename as basename9, resolve as resolve4, relative, dirname as dirname8, sep as sep3 } from "path";
+import { existsSync as existsSync28, readFileSync as readFileSync18, writeFileSync as writeFileSync16, mkdirSync as mkdirSync17, readdirSync as readdirSync6, statSync as statSync3 } from "fs";
+import { join as join27, basename as basename12, resolve as resolve4, relative, dirname as dirname9, sep as sep3 } from "path";
 import { createHash } from "crypto";
 var BUNDLE_VERSION = 1;
 var SkillBundle = class {
@@ -13218,7 +14700,7 @@ var SkillBundle = class {
    * Add a skill to the bundle
    */
   addSkill(skillPath, agents) {
-    const skillName = basename9(skillPath);
+    const skillName = basename12(skillPath);
     if (this.skills.has(skillName)) {
       throw new Error(`Skill "${skillName}" already exists in bundle`);
     }
@@ -13280,13 +14762,13 @@ var SkillBundle = class {
     const readDir = (dir, prefix = "") => {
       const entries = readdirSync6(dir);
       for (const entry of entries) {
-        const fullPath = join26(dir, entry);
+        const fullPath = join27(dir, entry);
         const relativePath = prefix ? `${prefix}/${entry}` : entry;
         const stat = statSync3(fullPath);
         if (stat.isDirectory()) {
           readDir(fullPath, relativePath);
         } else if (stat.isFile()) {
-          const content = readFileSync17(fullPath, "utf-8");
+          const content = readFileSync18(fullPath, "utf-8");
           contents.push(`--- ${relativePath} ---
 ${content}`);
         }
@@ -13295,14 +14777,14 @@ ${content}`);
     if (statSync3(skillPath).isDirectory()) {
       readDir(skillPath);
     } else {
-      contents.push(readFileSync17(skillPath, "utf-8"));
+      contents.push(readFileSync18(skillPath, "utf-8"));
     }
     return contents.join("\n\n");
   }
   detectAgents(skillPath) {
     const agents = [];
-    if (existsSync27(skillPath) && statSync3(skillPath).isFile()) {
-      const fileName = basename9(skillPath).toLowerCase();
+    if (existsSync28(skillPath) && statSync3(skillPath).isFile()) {
+      const fileName = basename12(skillPath).toLowerCase();
       if (fileName === "skill.md") {
         return ["claude-code", "codex", "gemini-cli", "universal"];
       }
@@ -13314,13 +14796,13 @@ ${content}`);
       }
       return ["universal"];
     }
-    if (existsSync27(join26(skillPath, "SKILL.md"))) {
+    if (existsSync28(join27(skillPath, "SKILL.md"))) {
       agents.push("claude-code", "codex", "gemini-cli", "universal");
     }
-    if (existsSync27(join26(skillPath, "skill.mdc"))) {
+    if (existsSync28(join27(skillPath, "skill.mdc"))) {
       agents.push("cursor");
     }
-    if (existsSync27(join26(skillPath, "rules.md"))) {
+    if (existsSync28(join27(skillPath, "rules.md"))) {
       agents.push("windsurf");
     }
     return agents.length > 0 ? agents : ["universal"];
@@ -13342,11 +14824,11 @@ function exportBundle(bundle, outputPath) {
         exportData.skills[skill.name] = content;
       }
     }
-    const dir = dirname8(outputPath);
-    if (dir && !existsSync27(dir)) {
-      mkdirSync16(dir, { recursive: true });
+    const dir = dirname9(outputPath);
+    if (dir && !existsSync28(dir)) {
+      mkdirSync17(dir, { recursive: true });
     }
-    writeFileSync15(outputPath, JSON.stringify(exportData, null, 2), "utf-8");
+    writeFileSync16(outputPath, JSON.stringify(exportData, null, 2), "utf-8");
     return { success: true, path: outputPath };
   } catch (err) {
     return {
@@ -13359,7 +14841,7 @@ function importBundle(bundlePath, targetDir, options = {}) {
   const imported = [];
   const errors = [];
   try {
-    const content = readFileSync17(bundlePath, "utf-8");
+    const content = readFileSync18(bundlePath, "utf-8");
     const data = JSON.parse(content);
     const absoluteTargetDir = resolve4(targetDir);
     for (const skill of data.manifest.skills) {
@@ -13372,19 +14854,19 @@ function importBundle(bundlePath, targetDir, options = {}) {
         errors.push(`Skill "${skill.name}" has no content in bundle`);
         continue;
       }
-      const skillDir = join26(absoluteTargetDir, skill.name);
+      const skillDir = join27(absoluteTargetDir, skill.name);
       const resolvedSkillDir = resolve4(skillDir);
       const relativeToTarget = relative(absoluteTargetDir, resolvedSkillDir);
       if (relativeToTarget.startsWith("..") || relativeToTarget.startsWith(sep3)) {
         errors.push(`Skill "${skill.name}" would escape target directory`);
         continue;
       }
-      if (existsSync27(skillDir) && !options.overwrite) {
+      if (existsSync28(skillDir) && !options.overwrite) {
         errors.push(`Skill "${skill.name}" already exists (use --overwrite)`);
         continue;
       }
-      if (!existsSync27(skillDir)) {
-        mkdirSync16(skillDir, { recursive: true });
+      if (!existsSync28(skillDir)) {
+        mkdirSync17(skillDir, { recursive: true });
       }
       const files = parseSkillContent2(skillContent);
       for (const [filePath, fileContent] of Object.entries(files)) {
@@ -13394,11 +14876,11 @@ function importBundle(bundlePath, targetDir, options = {}) {
           errors.push(`Skill "${skill.name}" contains invalid file path: ${filePath}`);
           continue;
         }
-        const fileDir = dirname8(fullPath);
-        if (!existsSync27(fileDir)) {
-          mkdirSync16(fileDir, { recursive: true });
+        const fileDir = dirname9(fullPath);
+        if (!existsSync28(fileDir)) {
+          mkdirSync17(fileDir, { recursive: true });
         }
-        writeFileSync15(fullPath, fileContent, "utf-8");
+        writeFileSync16(fullPath, fileContent, "utf-8");
       }
       imported.push(skill.name);
     }
@@ -13427,8 +14909,8 @@ function parseSkillContent2(content) {
 }
 
 // src/plugins/manager.ts
-import { existsSync as existsSync28, readFileSync as readFileSync18, writeFileSync as writeFileSync16, mkdirSync as mkdirSync17 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync19, writeFileSync as writeFileSync17, mkdirSync as mkdirSync18 } from "fs";
+import { join as join28 } from "path";
 var PLUGINS_DIR = ".skillkit/plugins";
 var PLUGINS_CONFIG_FILE = "plugins.json";
 var PluginManager = class {
@@ -13669,22 +15151,22 @@ var PluginManager = class {
   }
   // Private helpers
   loadState() {
-    const statePath = join27(this.projectPath, PLUGINS_DIR, PLUGINS_CONFIG_FILE);
-    if (existsSync28(statePath)) {
+    const statePath = join28(this.projectPath, PLUGINS_DIR, PLUGINS_CONFIG_FILE);
+    if (existsSync29(statePath)) {
       try {
-        return JSON.parse(readFileSync18(statePath, "utf-8"));
+        return JSON.parse(readFileSync19(statePath, "utf-8"));
       } catch {
       }
     }
     return { version: 1, plugins: {} };
   }
   saveState() {
-    const pluginsDir = join27(this.projectPath, PLUGINS_DIR);
-    if (!existsSync28(pluginsDir)) {
-      mkdirSync17(pluginsDir, { recursive: true });
+    const pluginsDir = join28(this.projectPath, PLUGINS_DIR);
+    if (!existsSync29(pluginsDir)) {
+      mkdirSync18(pluginsDir, { recursive: true });
     }
-    const statePath = join27(pluginsDir, PLUGINS_CONFIG_FILE);
-    writeFileSync16(statePath, JSON.stringify(this.state, null, 2), "utf-8");
+    const statePath = join28(pluginsDir, PLUGINS_CONFIG_FILE);
+    writeFileSync17(statePath, JSON.stringify(this.state, null, 2), "utf-8");
   }
   createContext() {
     return {
@@ -13709,15 +15191,15 @@ function createPluginManager(projectPath) {
 }
 
 // src/plugins/loader.ts
-import { existsSync as existsSync29, readFileSync as readFileSync19, readdirSync as readdirSync7, statSync as statSync4 } from "fs";
-import { join as join28, extname, basename as basename10, isAbsolute } from "path";
+import { existsSync as existsSync30, readFileSync as readFileSync20, readdirSync as readdirSync7, statSync as statSync4 } from "fs";
+import { join as join29, extname, basename as basename13, isAbsolute } from "path";
 import { pathToFileURL } from "url";
 var PluginLoader = class {
   /**
    * Load a plugin from a file path
    */
   async loadFromFile(filePath) {
-    if (!existsSync29(filePath)) {
+    if (!existsSync30(filePath)) {
       throw new Error(`Plugin file not found: ${filePath}`);
     }
     const ext = extname(filePath);
@@ -13759,11 +15241,11 @@ var PluginLoader = class {
    * Load a plugin from a JSON definition (for simple plugins)
    */
   loadFromJson(jsonPath) {
-    if (!existsSync29(jsonPath)) {
+    if (!existsSync30(jsonPath)) {
       throw new Error(`Plugin JSON not found: ${jsonPath}`);
     }
     try {
-      const content = readFileSync19(jsonPath, "utf-8");
+      const content = readFileSync20(jsonPath, "utf-8");
       const data = JSON.parse(content);
       if (!data.metadata) {
         throw new Error("Invalid plugin JSON: missing metadata");
@@ -13782,13 +15264,13 @@ var PluginLoader = class {
    * Scan a directory for plugins
    */
   async scanDirectory(dirPath) {
-    if (!existsSync29(dirPath)) {
+    if (!existsSync30(dirPath)) {
       return [];
     }
     const plugins = [];
     const entries = readdirSync7(dirPath);
     for (const entry of entries) {
-      const fullPath = join28(dirPath, entry);
+      const fullPath = join29(dirPath, entry);
       let stat;
       try {
         stat = statSync4(fullPath);
@@ -13796,11 +15278,11 @@ var PluginLoader = class {
         continue;
       }
       if (stat.isDirectory()) {
-        const pkgPath = join28(fullPath, "package.json");
-        const pluginPath = join28(fullPath, "plugin.json");
-        if (existsSync29(pkgPath)) {
+        const pkgPath = join29(fullPath, "package.json");
+        const pluginPath = join29(fullPath, "plugin.json");
+        if (existsSync30(pkgPath)) {
           try {
-            const pkg = JSON.parse(readFileSync19(pkgPath, "utf-8"));
+            const pkg = JSON.parse(readFileSync20(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,
@@ -13812,9 +15294,9 @@ var PluginLoader = class {
             }
           } catch {
           }
-        } else if (existsSync29(pluginPath)) {
+        } else if (existsSync30(pluginPath)) {
           try {
-            const data = JSON.parse(readFileSync19(pluginPath, "utf-8"));
+            const data = JSON.parse(readFileSync20(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);
             }
@@ -13824,7 +15306,7 @@ var PluginLoader = class {
       } else if (stat.isFile()) {
         const ext = extname(entry);
         if (ext === ".js" || ext === ".mjs") {
-          const name = basename10(entry, ext);
+          const name = basename13(entry, ext);
           if (name.includes("plugin") || name.startsWith("skillkit-")) {
             plugins.push({
               name,
@@ -13902,12 +15384,12 @@ async function loadPlugin(source) {
 async function loadPluginsFromDirectory(dirPath) {
   const loader = new PluginLoader();
   const plugins = [];
-  if (!existsSync29(dirPath)) {
+  if (!existsSync30(dirPath)) {
     return plugins;
   }
   const entries = readdirSync7(dirPath);
   for (const entry of entries) {
-    const fullPath = join28(dirPath, entry);
+    const fullPath = join29(dirPath, entry);
     let stat;
     try {
       stat = statSync4(fullPath);
@@ -13916,20 +15398,20 @@ async function loadPluginsFromDirectory(dirPath) {
     }
     try {
       if (stat.isDirectory()) {
-        const indexMjsPath = join28(fullPath, "index.mjs");
-        const indexPath = join28(fullPath, "index.js");
-        const mainMjsPath = join28(fullPath, "plugin.mjs");
-        const mainPath = join28(fullPath, "plugin.js");
-        const jsonPath = join28(fullPath, "plugin.json");
-        if (existsSync29(indexMjsPath)) {
+        const indexMjsPath = join29(fullPath, "index.mjs");
+        const indexPath = join29(fullPath, "index.js");
+        const mainMjsPath = join29(fullPath, "plugin.mjs");
+        const mainPath = join29(fullPath, "plugin.js");
+        const jsonPath = join29(fullPath, "plugin.json");
+        if (existsSync30(indexMjsPath)) {
           plugins.push(await loader.loadFromFile(indexMjsPath));
-        } else if (existsSync29(indexPath)) {
+        } else if (existsSync30(indexPath)) {
           plugins.push(await loader.loadFromFile(indexPath));
-        } else if (existsSync29(mainMjsPath)) {
+        } else if (existsSync30(mainMjsPath)) {
           plugins.push(await loader.loadFromFile(mainMjsPath));
-        } else if (existsSync29(mainPath)) {
+        } else if (existsSync30(mainPath)) {
           plugins.push(await loader.loadFromFile(mainPath));
-        } else if (existsSync29(jsonPath)) {
+        } else if (existsSync30(jsonPath)) {
           plugins.push(loader.loadFromJson(jsonPath));
         }
       } else if (stat.isFile()) {
@@ -13948,17 +15430,17 @@ async function loadPluginsFromDirectory(dirPath) {
 }
 
 // src/methodology/manager.ts
-import { existsSync as existsSync32, readFileSync as readFileSync22, writeFileSync as writeFileSync17, mkdirSync as mkdirSync18 } from "fs";
-import { join as join31, dirname as dirname10 } from "path";
+import { existsSync as existsSync33, readFileSync as readFileSync23, writeFileSync as writeFileSync18, mkdirSync as mkdirSync19 } from "fs";
+import { join as join32, dirname as dirname11 } from "path";
 
 // src/methodology/loader.ts
-import { existsSync as existsSync31, readFileSync as readFileSync21, readdirSync as readdirSync9, statSync as statSync6 } from "fs";
-import { join as join30, dirname as dirname9 } from "path";
+import { existsSync as existsSync32, readFileSync as readFileSync22, readdirSync as readdirSync9, statSync as statSync6 } from "fs";
+import { join as join31, dirname as dirname10 } from "path";
 import { fileURLToPath } from "url";
 
 // src/methodology/validator.ts
-import { existsSync as existsSync30, readFileSync as readFileSync20, readdirSync as readdirSync8, statSync as statSync5 } from "fs";
-import { join as join29 } from "path";
+import { existsSync as existsSync31, readFileSync as readFileSync21, readdirSync as readdirSync8, statSync as statSync5 } from "fs";
+import { join as join30 } from "path";
 function validatePackManifest(pack) {
   const errors = [];
   const warnings = [];
@@ -14108,15 +15590,15 @@ function validateSkillContent(content) {
 function validatePackDirectory(packPath) {
   const errors = [];
   const warnings = [];
-  if (!existsSync30(packPath)) {
+  if (!existsSync31(packPath)) {
     errors.push({
       code: "DIR_NOT_FOUND",
       message: `Pack directory not found: ${packPath}`
     });
     return { valid: false, errors, warnings };
   }
-  const manifestPath = join29(packPath, "pack.json");
-  if (!existsSync30(manifestPath)) {
+  const manifestPath = join30(packPath, "pack.json");
+  if (!existsSync31(manifestPath)) {
     errors.push({
       code: "MANIFEST_NOT_FOUND",
       message: "Pack must have a pack.json manifest",
@@ -14126,7 +15608,7 @@ function validatePackDirectory(packPath) {
   }
   let manifest;
   try {
-    const raw = readFileSync20(manifestPath, "utf-8");
+    const raw = readFileSync21(manifestPath, "utf-8");
     manifest = JSON.parse(raw);
     const manifestResult = validatePackManifest(manifest);
     errors.push(...manifestResult.errors);
@@ -14141,8 +15623,8 @@ function validatePackDirectory(packPath) {
   }
   if (manifest.skills) {
     for (const skillName of manifest.skills) {
-      const skillDir = join29(packPath, skillName);
-      if (!existsSync30(skillDir)) {
+      const skillDir = join30(packPath, skillName);
+      if (!existsSync31(skillDir)) {
         errors.push({
           code: "SKILL_DIR_NOT_FOUND",
           message: `Skill directory not found: ${skillName}`,
@@ -14158,8 +15640,8 @@ function validatePackDirectory(packPath) {
         });
         continue;
       }
-      const skillFile = join29(skillDir, "SKILL.md");
-      if (!existsSync30(skillFile)) {
+      const skillFile = join30(skillDir, "SKILL.md");
+      if (!existsSync31(skillFile)) {
         errors.push({
           code: "SKILL_FILE_NOT_FOUND",
           message: `Skill must have a SKILL.md file: ${skillName}`,
@@ -14167,7 +15649,7 @@ function validatePackDirectory(packPath) {
         });
         continue;
       }
-      const skillContent = readFileSync20(skillFile, "utf-8");
+      const skillContent = readFileSync21(skillFile, "utf-8");
       const skillResult = validateSkillContent(skillContent);
       for (const err of skillResult.errors) {
         errors.push({
@@ -14191,15 +15673,15 @@ function validatePackDirectory(packPath) {
 }
 function validateBuiltinPacks(packsDir) {
   const results = /* @__PURE__ */ new Map();
-  if (!existsSync30(packsDir)) {
+  if (!existsSync31(packsDir)) {
     return results;
   }
   const packDirs = readdirSync8(packsDir).filter((name) => {
-    const packPath = join29(packsDir, name);
+    const packPath = join30(packsDir, name);
     return statSync5(packPath).isDirectory();
   });
   for (const packName of packDirs) {
-    const packPath = join29(packsDir, packName);
+    const packPath = join30(packsDir, packName);
     results.set(packName, validatePackDirectory(packPath));
   }
   return results;
@@ -14257,8 +15739,8 @@ function extractSkillMetadata(content) {
 
 // src/methodology/loader.ts
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname9(__filename);
-var BUILTIN_PACKS_DIR = join30(__dirname, "packs");
+var __dirname = dirname10(__filename);
+var BUILTIN_PACKS_DIR = join31(__dirname, "packs");
 var MethodologyLoader = class {
   packsDir;
   loadedPacks = /* @__PURE__ */ new Map();
@@ -14271,11 +15753,11 @@ var MethodologyLoader = class {
    */
   async loadAllPacks() {
     const packs = [];
-    if (!existsSync31(this.packsDir)) {
+    if (!existsSync32(this.packsDir)) {
       return packs;
     }
     const packDirs = readdirSync9(this.packsDir).filter((name) => {
-      const packPath = join30(this.packsDir, name);
+      const packPath = join31(this.packsDir, name);
       return statSync6(packPath).isDirectory();
     });
     for (const packName of packDirs) {
@@ -14296,9 +15778,9 @@ var MethodologyLoader = class {
     if (this.loadedPacks.has(packName)) {
       return this.loadedPacks.get(packName);
     }
-    const packPath = join30(this.packsDir, packName);
-    const manifestPath = join30(packPath, "pack.json");
-    if (!existsSync31(manifestPath)) {
+    const packPath = join31(this.packsDir, packName);
+    const manifestPath = join31(packPath, "pack.json");
+    if (!existsSync32(manifestPath)) {
       return null;
     }
     const validation = validatePackDirectory(packPath);
@@ -14308,7 +15790,7 @@ var MethodologyLoader = class {
       );
     }
     const manifest = JSON.parse(
-      readFileSync21(manifestPath, "utf-8")
+      readFileSync22(manifestPath, "utf-8")
     );
     this.loadedPacks.set(packName, manifest);
     return manifest;
@@ -14338,11 +15820,11 @@ var MethodologyLoader = class {
     if (this.loadedSkills.has(skillId)) {
       return this.loadedSkills.get(skillId);
     }
-    const skillPath = join30(this.packsDir, packName, skillName, "SKILL.md");
-    if (!existsSync31(skillPath)) {
+    const skillPath = join31(this.packsDir, packName, skillName, "SKILL.md");
+    if (!existsSync32(skillPath)) {
       return null;
     }
-    const content = readFileSync21(skillPath, "utf-8");
+    const content = readFileSync22(skillPath, "utf-8");
     const rawMetadata = extractSkillMetadata(content);
     const metadata = {
       triggers: rawMetadata.triggers,
@@ -14421,9 +15903,9 @@ var MethodologyLoader = class {
    * Check if a pack exists
    */
   packExists(packName) {
-    const packPath = join30(this.packsDir, packName);
-    const manifestPath = join30(packPath, "pack.json");
-    return existsSync31(manifestPath);
+    const packPath = join31(this.packsDir, packName);
+    const manifestPath = join31(packPath, "pack.json");
+    return existsSync32(manifestPath);
   }
   /**
    * Clear cache
@@ -14789,10 +16271,10 @@ var MethodologyManager = class {
   }
   // Private helpers
   loadState() {
-    const statePath = join31(this.projectPath, METHODOLOGY_STATE_FILE);
-    if (existsSync32(statePath)) {
+    const statePath = join32(this.projectPath, METHODOLOGY_STATE_FILE);
+    if (existsSync33(statePath)) {
       try {
-        return JSON.parse(readFileSync22(statePath, "utf-8"));
+        return JSON.parse(readFileSync23(statePath, "utf-8"));
       } catch {
       }
     }
@@ -14803,21 +16285,21 @@ var MethodologyManager = class {
     };
   }
   saveState() {
-    const statePath = join31(this.projectPath, METHODOLOGY_STATE_FILE);
-    const dir = dirname10(statePath);
-    if (!existsSync32(dir)) {
-      mkdirSync18(dir, { recursive: true });
+    const statePath = join32(this.projectPath, METHODOLOGY_STATE_FILE);
+    const dir = dirname11(statePath);
+    if (!existsSync33(dir)) {
+      mkdirSync19(dir, { recursive: true });
     }
-    writeFileSync17(statePath, JSON.stringify(this.state, null, 2), "utf-8");
+    writeFileSync18(statePath, JSON.stringify(this.state, null, 2), "utf-8");
   }
   async installSkillLocally(skill) {
-    const skillsDir = join31(this.projectPath, ".skillkit", "methodology", "skills");
-    const skillDir = join31(skillsDir, skill.pack, skill.id.split("/")[1]);
-    if (!existsSync32(skillDir)) {
-      mkdirSync18(skillDir, { recursive: true });
+    const skillsDir = join32(this.projectPath, ".skillkit", "methodology", "skills");
+    const skillDir = join32(skillsDir, skill.pack, skill.id.split("/")[1]);
+    if (!existsSync33(skillDir)) {
+      mkdirSync19(skillDir, { recursive: true });
     }
-    const targetPath = join31(skillDir, "SKILL.md");
-    writeFileSync17(targetPath, skill.content, "utf-8");
+    const targetPath = join32(skillDir, "SKILL.md");
+    writeFileSync18(targetPath, skill.content, "utf-8");
   }
   async removeSkillLocally(_skillId) {
   }
@@ -14845,9 +16327,9 @@ var MethodologyManager = class {
     if (!agentDir) {
       throw new Error(`Unknown agent: ${agent}`);
     }
-    const skillsDir = join31(this.projectPath, agentDir);
-    if (!existsSync32(skillsDir)) {
-      mkdirSync18(skillsDir, { recursive: true });
+    const skillsDir = join32(this.projectPath, agentDir);
+    if (!existsSync33(skillsDir)) {
+      mkdirSync19(skillsDir, { recursive: true });
     }
     const skillName = skillId.split("/")[1];
     let filename;
@@ -14858,8 +16340,8 @@ var MethodologyManager = class {
     } else {
       filename = `${skillName}.md`;
     }
-    const targetPath = join31(skillsDir, filename);
-    writeFileSync17(targetPath, content, "utf-8");
+    const targetPath = join32(skillsDir, filename);
+    writeFileSync18(targetPath, content, "utf-8");
   }
   detectAgents() {
     const agents = [];
@@ -14882,7 +16364,7 @@ var MethodologyManager = class {
       ["windsurf", ".windsurf"]
     ];
     for (const [agent, dir] of agentDirs) {
-      if (existsSync32(join31(this.projectPath, dir))) {
+      if (existsSync33(join32(this.projectPath, dir))) {
         agents.push(agent);
       }
     }
@@ -14895,9 +16377,9 @@ function createMethodologyManager(options) {
 }
 
 // src/hooks/manager.ts
-import { existsSync as existsSync33, readFileSync as readFileSync23, writeFileSync as writeFileSync18, mkdirSync as mkdirSync19 } from "fs";
-import { join as join32, dirname as dirname11 } from "path";
-import { randomUUID as randomUUID10 } from "crypto";
+import { existsSync as existsSync34, readFileSync as readFileSync24, writeFileSync as writeFileSync19, mkdirSync as mkdirSync20 } from "fs";
+import { join as join33, dirname as dirname12 } from "path";
+import { randomUUID as randomUUID11 } from "crypto";
 import { minimatch } from "minimatch";
 var DEFAULT_CONFIG_PATH = ".skillkit/hooks.json";
 var HookManager = class {
@@ -14907,7 +16389,7 @@ var HookManager = class {
   constructor(options) {
     this.options = {
       projectPath: options.projectPath,
-      configPath: options.configPath || join32(options.projectPath, DEFAULT_CONFIG_PATH),
+      configPath: options.configPath || join33(options.projectPath, DEFAULT_CONFIG_PATH),
       autoLoad: options.autoLoad ?? true,
       defaultInjectionMode: options.defaultInjectionMode || "reference"
     };
@@ -14921,7 +16403,7 @@ var HookManager = class {
   registerHook(hook) {
     const fullHook = {
       ...hook,
-      id: hook.id || randomUUID10(),
+      id: hook.id || randomUUID11(),
       inject: hook.inject || this.options.defaultInjectionMode,
       enabled: hook.enabled ?? true,
       priority: hook.priority ?? 0
@@ -15047,11 +16529,11 @@ var HookManager = class {
    * Load hooks from config file
    */
   load() {
-    if (!existsSync33(this.options.configPath)) {
+    if (!existsSync34(this.options.configPath)) {
       return;
     }
     try {
-      const content = readFileSync23(this.options.configPath, "utf-8");
+      const content = readFileSync24(this.options.configPath, "utf-8");
       const config = JSON.parse(content);
       this.hooks.clear();
       for (const hook of config.hooks) {
@@ -15078,11 +16560,11 @@ var HookManager = class {
         enabled: true
       }
     };
-    const dir = dirname11(this.options.configPath);
-    if (!existsSync33(dir)) {
-      mkdirSync19(dir, { recursive: true });
+    const dir = dirname12(this.options.configPath);
+    if (!existsSync34(dir)) {
+      mkdirSync20(dir, { recursive: true });
     }
-    writeFileSync18(this.options.configPath, JSON.stringify(config, null, 2));
+    writeFileSync19(this.options.configPath, JSON.stringify(config, null, 2));
   }
   /**
    * Generate agent-specific hook configuration
@@ -15324,7 +16806,7 @@ function createHookManager(options) {
 
 // src/hooks/triggers.ts
 import { watch } from "fs";
-import { join as join33, relative as relative2 } from "path";
+import { join as join34, relative as relative2 } from "path";
 function debounce(fn, delay) {
   let timeoutId = null;
   return (...args) => {
@@ -15509,7 +16991,7 @@ var SkillTriggerEngine = class {
         { recursive: true },
         debounce((eventType, filename) => {
           if (!filename) return;
-          const relativePath = relative2(this.options.projectPath, join33(this.options.projectPath, filename));
+          const relativePath = relative2(this.options.projectPath, join34(this.options.projectPath, filename));
           if (this.shouldIgnore(relativePath)) return;
           if (eventType === "rename") {
             this.triggerFileCreate(relativePath);
@@ -15553,10 +17035,10 @@ function createTriggerEngine(hookManager, options) {
 }
 
 // src/orchestrator/team.ts
-import { randomUUID as randomUUID13 } from "crypto";
+import { randomUUID as randomUUID14 } from "crypto";
 
 // src/orchestrator/task.ts
-import { randomUUID as randomUUID11 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
 var TaskManager = class {
   tasks = /* @__PURE__ */ new Map();
   listeners = /* @__PURE__ */ new Set();
@@ -15566,7 +17048,7 @@ var TaskManager = class {
   createTask(name, description, spec, options) {
     const now = /* @__PURE__ */ new Date();
     const task = {
-      id: randomUUID11(),
+      id: randomUUID12(),
       name,
       description,
       spec,
@@ -15885,7 +17367,7 @@ function createTaskManager() {
 }
 
 // src/orchestrator/messages.ts
-import { randomUUID as randomUUID12 } from "crypto";
+import { randomUUID as randomUUID13 } from "crypto";
 var TeamMessageBus = class {
   messages = [];
   handlers = /* @__PURE__ */ new Map();
@@ -15899,7 +17381,7 @@ var TeamMessageBus = class {
    */
   async send(from, to, content, options) {
     const message = {
-      id: randomUUID12(),
+      id: randomUUID13(),
       type: options?.type || "direct",
       from,
       to,
@@ -15918,7 +17400,7 @@ var TeamMessageBus = class {
    */
   async broadcast(from, content, options) {
     const message = {
-      id: randomUUID12(),
+      id: randomUUID13(),
       type: "broadcast",
       from,
       content,
@@ -16178,10 +17660,10 @@ var TeamOrchestrator = class {
    * Spawn a new team
    */
   async spawnTeam(config) {
-    const teamId = randomUUID13();
+    const teamId = randomUUID14();
     const now = /* @__PURE__ */ new Date();
     const leader = {
-      id: randomUUID13(),
+      id: randomUUID14(),
       role: "leader",
       agentType: config.leaderAgent,
       status: "idle",
@@ -16223,7 +17705,7 @@ var TeamOrchestrator = class {
     if (!team) throw new Error(`Team not found: ${teamId}`);
     const now = /* @__PURE__ */ new Date();
     const teammate = {
-      id: randomUUID13(),
+      id: randomUUID14(),
       role: "teammate",
       agentType,
       status: "idle",
@@ -19610,8 +21092,8 @@ var CUSTOM_AGENT_FORMAT_MAP = {
 };
 
 // src/agents/parser.ts
-import { existsSync as existsSync34, readFileSync as readFileSync24, statSync as statSync7 } from "fs";
-import { join as join34, basename as basename11, extname as extname2 } from "path";
+import { existsSync as existsSync35, readFileSync as readFileSync25, statSync as statSync7 } from "fs";
+import { join as join35, basename as basename14, extname as extname2 } from "path";
 import { parse as parseYaml10 } from "yaml";
 function extractAgentFrontmatter(content) {
   const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
@@ -19629,18 +21111,18 @@ function extractAgentContent(content) {
   return withoutFrontmatter.trim();
 }
 function parseAgentFile(filePath, location = "project") {
-  if (!existsSync34(filePath)) {
+  if (!existsSync35(filePath)) {
     return null;
   }
   if (extname2(filePath) !== ".md") {
     return null;
   }
   try {
-    const content = readFileSync24(filePath, "utf-8");
+    const content = readFileSync25(filePath, "utf-8");
     const rawFrontmatter = extractAgentFrontmatter(content);
     const agentContent = extractAgentContent(content);
     if (!rawFrontmatter) {
-      const name = basename11(filePath, ".md");
+      const name = basename14(filePath, ".md");
       return {
         name,
         description: "No description available",
@@ -19656,7 +21138,7 @@ function parseAgentFile(filePath, location = "project") {
     }
     const parsed = AgentFrontmatter.safeParse(rawFrontmatter);
     if (!parsed.success) {
-      const name = rawFrontmatter.name || basename11(filePath, ".md");
+      const name = rawFrontmatter.name || basename14(filePath, ".md");
       return {
         name,
         description: rawFrontmatter.description || "No description available",
@@ -19688,16 +21170,16 @@ function parseAgentFile(filePath, location = "project") {
   }
 }
 function parseAgentDir(dirPath, location = "project") {
-  const agentMdPath = join34(dirPath, "AGENT.md");
-  if (existsSync34(agentMdPath)) {
+  const agentMdPath = join35(dirPath, "AGENT.md");
+  if (existsSync35(agentMdPath)) {
     const agent = parseAgentFile(agentMdPath, location);
     if (agent) {
       agent.path = dirPath;
     }
     return agent;
   }
-  const indexMdPath = join34(dirPath, "index.md");
-  if (existsSync34(indexMdPath)) {
+  const indexMdPath = join35(dirPath, "index.md");
+  if (existsSync35(indexMdPath)) {
     const agent = parseAgentFile(indexMdPath, location);
     if (agent) {
       agent.path = dirPath;
@@ -19707,11 +21189,11 @@ function parseAgentDir(dirPath, location = "project") {
   return null;
 }
 function loadAgentMetadata(metadataPath) {
-  if (!existsSync34(metadataPath)) {
+  if (!existsSync35(metadataPath)) {
     return null;
   }
   try {
-    const content = readFileSync24(metadataPath, "utf-8");
+    const content = readFileSync25(metadataPath, "utf-8");
     const data = JSON.parse(content);
     const parsed = AgentMetadata.safeParse(data);
     return parsed.success ? parsed.data : null;
@@ -19812,25 +21294,25 @@ function fromCanonicalAgent(canonical, _targetFormat = "claude-agent") {
   return lines.join("\n");
 }
 function readAgentContent(agentPath) {
-  if (existsSync34(agentPath) && extname2(agentPath) === ".md") {
+  if (existsSync35(agentPath) && extname2(agentPath) === ".md") {
     try {
-      return readFileSync24(agentPath, "utf-8");
+      return readFileSync25(agentPath, "utf-8");
     } catch {
       return null;
     }
   }
-  const agentMdPath = join34(agentPath, "AGENT.md");
-  if (existsSync34(agentMdPath)) {
+  const agentMdPath = join35(agentPath, "AGENT.md");
+  if (existsSync35(agentMdPath)) {
     try {
-      return readFileSync24(agentMdPath, "utf-8");
+      return readFileSync25(agentMdPath, "utf-8");
     } catch {
       return null;
     }
   }
-  const indexMdPath = join34(agentPath, "index.md");
-  if (existsSync34(indexMdPath)) {
+  const indexMdPath = join35(agentPath, "index.md");
+  if (existsSync35(indexMdPath)) {
     try {
-      return readFileSync24(indexMdPath, "utf-8");
+      return readFileSync25(indexMdPath, "utf-8");
     } catch {
       return null;
     }
@@ -19841,17 +21323,17 @@ function validateAgent(agentPath) {
   const errors = [];
   const warnings = [];
   let filePath = agentPath;
-  if (!existsSync34(agentPath)) {
+  if (!existsSync35(agentPath)) {
     errors.push(`Agent file not found: ${agentPath}`);
     return { valid: false, errors, warnings };
   }
   const stats = statSync7(agentPath);
   if (stats.isDirectory()) {
-    const agentMd = join34(agentPath, "AGENT.md");
-    const indexMd = join34(agentPath, "index.md");
-    if (existsSync34(agentMd)) {
+    const agentMd = join35(agentPath, "AGENT.md");
+    const indexMd = join35(agentPath, "index.md");
+    if (existsSync35(agentMd)) {
       filePath = agentMd;
-    } else if (existsSync34(indexMd)) {
+    } else if (existsSync35(indexMd)) {
       filePath = indexMd;
     } else {
       errors.push("Directory must contain AGENT.md or index.md");
@@ -19860,7 +21342,7 @@ function validateAgent(agentPath) {
   }
   let content;
   try {
-    content = readFileSync24(filePath, "utf-8");
+    content = readFileSync25(filePath, "utf-8");
   } catch {
     errors.push(`Cannot read file: ${filePath}`);
     return { valid: false, errors, warnings };
@@ -19878,7 +21360,7 @@ function validateAgent(agentPath) {
   }
   if (parsed.success) {
     const data = parsed.data;
-    const fileName = basename11(filePath, ".md");
+    const fileName = basename14(filePath, ".md");
     if (data.name !== fileName && fileName !== "AGENT" && fileName !== "index") {
       warnings.push(`name "${data.name}" does not match filename "${fileName}"`);
     }
@@ -19897,18 +21379,18 @@ function validateAgent(agentPath) {
 }
 
 // src/agents/discovery.ts
-import { existsSync as existsSync35, readdirSync as readdirSync10, statSync as statSync8 } from "fs";
-import { join as join35, extname as extname3 } from "path";
-import { homedir as homedir12 } from "os";
+import { existsSync as existsSync36, readdirSync as readdirSync10, statSync as statSync8 } from "fs";
+import { join as join36, extname as extname3 } from "path";
+import { homedir as homedir13 } from "os";
 function discoverAgentsInDir(dir, location) {
   const agents = [];
-  if (!existsSync35(dir)) {
+  if (!existsSync36(dir)) {
     return agents;
   }
   try {
     const entries = readdirSync10(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const entryPath = join35(dir, entry.name);
+      const entryPath = join36(dir, entry.name);
       if (entry.isFile() && extname3(entry.name) === ".md") {
         const agent = parseAgentFile(entryPath, location);
         if (agent) {
@@ -19929,8 +21411,8 @@ function discoverAgents(rootDir) {
   const agents = [];
   const seen = /* @__PURE__ */ new Set();
   for (const searchPath of ALL_AGENT_DISCOVERY_PATHS) {
-    const fullPath = join35(rootDir, searchPath);
-    if (existsSync35(fullPath)) {
+    const fullPath = join36(rootDir, searchPath);
+    if (existsSync36(fullPath)) {
       for (const agent of discoverAgentsInDir(fullPath, "project")) {
         if (!seen.has(agent.name)) {
           seen.add(agent.name);
@@ -19946,8 +21428,8 @@ function discoverAgentsForAgent(rootDir, agentType) {
   const seen = /* @__PURE__ */ new Set();
   const paths = AGENT_DISCOVERY_PATHS[agentType] || [];
   for (const searchPath of paths) {
-    const fullPath = join35(rootDir, searchPath);
-    if (existsSync35(fullPath)) {
+    const fullPath = join36(rootDir, searchPath);
+    if (existsSync36(fullPath)) {
       for (const agent of discoverAgentsInDir(fullPath, "project")) {
         if (!seen.has(agent.name)) {
           seen.add(agent.name);
@@ -19961,14 +21443,14 @@ function discoverAgentsForAgent(rootDir, agentType) {
 function discoverGlobalAgents() {
   const agents = [];
   const seen = /* @__PURE__ */ new Set();
-  const home = homedir12();
+  const home = homedir13();
   const globalPaths = [
-    join35(home, ".claude", "agents"),
-    join35(home, ".skillkit", "agents"),
-    join35(home, ".config", "skillkit", "agents")
+    join36(home, ".claude", "agents"),
+    join36(home, ".skillkit", "agents"),
+    join36(home, ".config", "skillkit", "agents")
   ];
   for (const searchPath of globalPaths) {
-    if (existsSync35(searchPath)) {
+    if (existsSync36(searchPath)) {
       for (const agent of discoverAgentsInDir(searchPath, "global")) {
         if (!seen.has(agent.name)) {
           seen.add(agent.name);
@@ -19983,7 +21465,7 @@ function findAllAgents(searchDirs) {
   const agents = [];
   const seen = /* @__PURE__ */ new Set();
   for (const dir of searchDirs) {
-    if (!existsSync35(dir)) continue;
+    if (!existsSync36(dir)) continue;
     const discovered = discoverAgents(dir);
     for (const agent of discovered) {
       if (!seen.has(agent.name)) {
@@ -20002,33 +21484,33 @@ function findAllAgents(searchDirs) {
 }
 function findAgent(name, searchDirs) {
   for (const dir of searchDirs) {
-    if (!existsSync35(dir)) continue;
+    if (!existsSync36(dir)) continue;
     for (const searchPath of ALL_AGENT_DISCOVERY_PATHS) {
-      const agentsDir = join35(dir, searchPath);
-      if (!existsSync35(agentsDir)) continue;
-      const agentFile = join35(agentsDir, `${name}.md`);
-      if (existsSync35(agentFile)) {
+      const agentsDir = join36(dir, searchPath);
+      if (!existsSync36(agentsDir)) continue;
+      const agentFile = join36(agentsDir, `${name}.md`);
+      if (existsSync36(agentFile)) {
         return parseAgentFile(agentFile, "project");
       }
-      const agentDir = join35(agentsDir, name);
-      if (existsSync35(agentDir) && statSync8(agentDir).isDirectory()) {
+      const agentDir = join36(agentsDir, name);
+      if (existsSync36(agentDir) && statSync8(agentDir).isDirectory()) {
         return parseAgentDir(agentDir, "project");
       }
     }
   }
-  const home = homedir12();
+  const home = homedir13();
   const globalPaths = [
-    join35(home, ".claude", "agents"),
-    join35(home, ".skillkit", "agents")
+    join36(home, ".claude", "agents"),
+    join36(home, ".skillkit", "agents")
   ];
   for (const agentsDir of globalPaths) {
-    if (!existsSync35(agentsDir)) continue;
-    const agentFile = join35(agentsDir, `${name}.md`);
-    if (existsSync35(agentFile)) {
+    if (!existsSync36(agentsDir)) continue;
+    const agentFile = join36(agentsDir, `${name}.md`);
+    if (existsSync36(agentFile)) {
       return parseAgentFile(agentFile, "global");
     }
-    const agentDir = join35(agentsDir, name);
-    if (existsSync35(agentDir) && statSync8(agentDir).isDirectory()) {
+    const agentDir = join36(agentsDir, name);
+    if (existsSync36(agentDir) && statSync8(agentDir).isDirectory()) {
       return parseAgentDir(agentDir, "global");
     }
   }
@@ -20037,9 +21519,9 @@ function findAgent(name, searchDirs) {
 function getAgentsDirectory(rootDir, agentType) {
   const paths = AGENT_DISCOVERY_PATHS[agentType];
   if (paths && paths.length > 0) {
-    return join35(rootDir, paths[0]);
+    return join36(rootDir, paths[0]);
   }
-  return join35(rootDir, "agents");
+  return join36(rootDir, "agents");
 }
 function agentExists(name, searchDirs) {
   return findAgent(name, searchDirs) !== null;
@@ -20057,14 +21539,14 @@ function getAgentStats(searchDirs) {
 function discoverAgentsRecursive(rootDir, location = "project") {
   const agents = [];
   const seen = /* @__PURE__ */ new Set();
-  if (!existsSync35(rootDir)) {
+  if (!existsSync36(rootDir)) {
     return agents;
   }
   function scanDirectory(dir) {
     try {
       const entries = readdirSync10(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const entryPath = join35(dir, entry.name);
+        const entryPath = join36(dir, entry.name);
         if (entry.isFile() && extname3(entry.name) === ".md") {
           const agent = parseAgentFile(entryPath, location);
           if (agent && !seen.has(agent.name)) {
@@ -20091,7 +21573,7 @@ function discoverAgentsRecursive(rootDir, location = "project") {
   return agents;
 }
 function discoverAgentsFromPath(sourcePath, recursive = false, location = "project") {
-  if (!existsSync35(sourcePath)) {
+  if (!existsSync36(sourcePath)) {
     return [];
   }
   const stats = statSync8(sourcePath);
@@ -20114,7 +21596,7 @@ function discoverAgentsFromPath(sourcePath, recursive = false, location = "proje
     try {
       const entries = readdirSync10(sourcePath, { withFileTypes: true });
       for (const entry of entries) {
-        const entryPath = join35(sourcePath, entry.name);
+        const entryPath = join36(sourcePath, entry.name);
         if (entry.isFile() && extname3(entry.name) === ".md") {
           const a = parseAgentFile(entryPath, location);
           if (a) agents.push(a);
@@ -20131,7 +21613,7 @@ function discoverAgentsFromPath(sourcePath, recursive = false, location = "proje
 }
 
 // src/agents/translator.ts
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 function translateAgent(agent, targetAgent, options) {
   const canonical = toCanonicalAgent(agent);
   return translateCanonicalAgent(canonical, targetAgent, options);
@@ -20352,9 +21834,9 @@ function getAgentFilename(agentName, targetAgent) {
 function getAgentTargetDirectory(rootDir, targetAgent) {
   const paths = AGENT_DISCOVERY_PATHS[targetAgent];
   if (paths && paths.length > 0) {
-    return join36(rootDir, paths[0]);
+    return join37(rootDir, paths[0]);
   }
-  return join36(rootDir, "agents");
+  return join37(rootDir, "agents");
 }
 function escapeYamlString(str) {
   if (/[:\{\}\[\],&*#?|\-<>=!%@`]/.test(str) || str.includes("\n")) {
@@ -20541,8 +22023,8 @@ function loadAndConvertSkill(skill, options) {
 }
 
 // src/skill-translator.ts
-import { readFileSync as readFileSync25, existsSync as existsSync36, writeFileSync as writeFileSync19, mkdirSync as mkdirSync20 } from "fs";
-import { join as join37, basename as basename12, dirname as dirname12, resolve as resolve5, relative as relative3, isAbsolute as isAbsolute2 } from "path";
+import { readFileSync as readFileSync26, existsSync as existsSync37, writeFileSync as writeFileSync20, mkdirSync as mkdirSync21 } from "fs";
+import { join as join38, basename as basename15, dirname as dirname13, resolve as resolve5, 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]) => [
@@ -20551,12 +22033,12 @@ var AGENT_SKILL_FORMATS = Object.fromEntries(
   ])
 );
 function parseSkillToCanonical(skillPath, sourceAgent) {
-  const skillMdPath = skillPath.endsWith("SKILL.md") ? skillPath : join37(skillPath, "SKILL.md");
-  if (!existsSync36(skillMdPath)) {
+  const skillMdPath = skillPath.endsWith("SKILL.md") ? skillPath : join38(skillPath, "SKILL.md");
+  if (!existsSync37(skillMdPath)) {
     return null;
   }
   try {
-    const content = readFileSync25(skillMdPath, "utf-8");
+    const content = readFileSync26(skillMdPath, "utf-8");
     return parseSkillContentToCanonical(content, skillPath, sourceAgent);
   } catch {
     return null;
@@ -20573,7 +22055,7 @@ function parseSkillContentToCanonical(content, sourcePath, sourceAgent) {
     } catch {
     }
   }
-  const name = frontmatter.name || basename12(sourcePath.endsWith(".md") ? dirname12(sourcePath) : sourcePath);
+  const name = frontmatter.name || basename15(sourcePath.endsWith(".md") ? dirname13(sourcePath) : sourcePath);
   const description = frontmatter.description || extractDescriptionFromContent(bodyContent);
   return {
     name,
@@ -20644,7 +22126,7 @@ function translateSkillToAgent(canonical, targetAgent, options) {
   }
   const content = generateSkillContent(canonical, targetAgent, format, options);
   const filename = options?.outputFilename || "SKILL.md";
-  const targetDir = options?.outputDir || join37(format.skillsDir, canonical.name);
+  const targetDir = options?.outputDir || join38(format.skillsDir, canonical.name);
   return {
     success: true,
     content,
@@ -20783,7 +22265,7 @@ function writeTranslatedSkill(result, rootDir, options) {
   try {
     const rootPath = resolve5(rootDir);
     const filePath = resolve5(rootDir, result.targetDir, result.filename);
-    const targetPath = dirname12(filePath);
+    const targetPath = dirname13(filePath);
     const relPath = relative3(rootPath, filePath);
     if (relPath.startsWith("..") || isAbsolute2(relPath)) {
       return {
@@ -20792,7 +22274,7 @@ function writeTranslatedSkill(result, rootDir, options) {
         error: "Resolved output path escapes rootDir"
       };
     }
-    if (existsSync36(filePath) && options?.overwrite === false) {
+    if (existsSync37(filePath) && options?.overwrite === false) {
       return {
         success: false,
         path: filePath,
@@ -20800,10 +22282,10 @@ function writeTranslatedSkill(result, rootDir, options) {
         skipped: true
       };
     }
-    if (!existsSync36(targetPath)) {
-      mkdirSync20(targetPath, { recursive: true });
+    if (!existsSync37(targetPath)) {
+      mkdirSync21(targetPath, { recursive: true });
     }
-    writeFileSync19(filePath, result.content, "utf-8");
+    writeFileSync20(filePath, result.content, "utf-8");
     return { success: true, path: filePath };
   } catch (error) {
     return {
@@ -20986,30 +22468,30 @@ var getAgentSkillsDir = getSkillsDir;
 var getAgentConfigFile = getConfigFile;
 
 // src/manifest/index.ts
-import { readFileSync as readFileSync26, writeFileSync as writeFileSync20, existsSync as existsSync37 } from "fs";
-import { join as join38, dirname as dirname13 } from "path";
+import { readFileSync as readFileSync27, writeFileSync as writeFileSync21, existsSync as existsSync38 } from "fs";
+import { join as join39, dirname as dirname14 } 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 !== dirname13(dir)) {
+  while (dir !== dirname14(dir)) {
     for (const filename of MANIFEST_FILENAMES) {
-      const manifestPath = join38(dir, filename);
-      if (existsSync37(manifestPath)) {
+      const manifestPath = join39(dir, filename);
+      if (existsSync38(manifestPath)) {
         return manifestPath;
       }
     }
-    dir = dirname13(dir);
+    dir = dirname14(dir);
   }
   return null;
 }
 function loadManifest(manifestPath) {
   const path4 = manifestPath || findManifestPath();
-  if (!path4 || !existsSync37(path4)) {
+  if (!path4 || !existsSync38(path4)) {
     return null;
   }
   try {
-    const content = readFileSync26(path4, "utf-8");
+    const content = readFileSync27(path4, "utf-8");
     const parsed = parseYaml12(content);
     if (!parsed || typeof parsed !== "object") {
       return null;
@@ -21051,7 +22533,7 @@ function normalizeSkills(skills) {
   }).filter((s) => s.source);
 }
 function saveManifest(manifest, manifestPath) {
-  const path4 = manifestPath || join38(process.cwd(), ".skills");
+  const path4 = manifestPath || join39(process.cwd(), ".skills");
   const content = stringifyYaml9({
     version: manifest.version || 1,
     skills: manifest.skills.map((s) => {
@@ -21064,7 +22546,7 @@ function saveManifest(manifest, manifestPath) {
     ...manifest.installMethod && { installMethod: manifest.installMethod },
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
-  writeFileSync20(path4, content, "utf-8");
+  writeFileSync21(path4, content, "utf-8");
 }
 function addToManifest(source, options, manifestPath) {
   const existing = loadManifest(manifestPath) || {
@@ -21141,8 +22623,8 @@ function generateManifestFromInstalled(installedSkills) {
 }
 
 // src/quality/index.ts
-import { readFileSync as readFileSync27, existsSync as existsSync38 } from "fs";
-import { join as join39, basename as basename13 } from "path";
+import { readFileSync as readFileSync28, existsSync as existsSync39 } from "fs";
+import { join as join40, basename as basename16 } from "path";
 
 // src/quality/benchmark.ts
 var CATEGORY_BENCHMARKS = {
@@ -21744,23 +23226,23 @@ function evaluateSkillContent(content) {
   };
 }
 function evaluateSkillFile(filePath) {
-  if (!existsSync38(filePath)) return null;
+  if (!existsSync39(filePath)) return null;
   try {
-    const content = readFileSync27(filePath, "utf-8");
+    const content = readFileSync28(filePath, "utf-8");
     return evaluateSkillContent(content);
   } catch {
     return null;
   }
 }
 function evaluateSkillDirectory(dirPath) {
-  const skillMdPath = join39(dirPath, "SKILL.md");
-  if (existsSync38(skillMdPath)) {
+  const skillMdPath = join40(dirPath, "SKILL.md");
+  if (existsSync39(skillMdPath)) {
     return evaluateSkillFile(skillMdPath);
   }
-  const mdcFiles = ["index.mdc", `${basename13(dirPath)}.mdc`];
+  const mdcFiles = ["index.mdc", `${basename16(dirPath)}.mdc`];
   for (const file of mdcFiles) {
-    const mdcPath = join39(dirPath, file);
-    if (existsSync38(mdcPath)) {
+    const mdcPath = join40(dirPath, file);
+    if (existsSync39(mdcPath)) {
       return evaluateSkillFile(mdcPath);
     }
   }
@@ -21930,8 +23412,8 @@ var AGENT_INSTRUCTION_TEMPLATES = {
 };
 
 // src/primer/analyzer.ts
-import { existsSync as existsSync39, readFileSync as readFileSync28, readdirSync as readdirSync11 } from "fs";
-import { join as join40, basename as basename14, relative as relative4, sep as sep4 } from "path";
+import { existsSync as existsSync40, readFileSync as readFileSync29, readdirSync as readdirSync11 } from "fs";
+import { join as join41, basename as basename17, relative as relative4, sep as sep4 } from "path";
 var PACKAGE_MANAGER_FILES = {
   "package-lock.json": "npm",
   "pnpm-lock.yaml": "pnpm",
@@ -22019,10 +23501,10 @@ var PrimerAnalyzer = class {
     return analysis;
   }
   loadPackageJson() {
-    const packageJsonPath = join40(this.projectPath, "package.json");
-    if (existsSync39(packageJsonPath)) {
+    const packageJsonPath = join41(this.projectPath, "package.json");
+    if (existsSync40(packageJsonPath)) {
       try {
-        const content = readFileSync28(packageJsonPath, "utf-8");
+        const content = readFileSync29(packageJsonPath, "utf-8");
         this.packageJson = JSON.parse(content);
       } catch {
         this.packageJson = null;
@@ -22035,7 +23517,7 @@ var PrimerAnalyzer = class {
       try {
         const entries = readdirSync11(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = join40(dir, entry.name);
+          const fullPath = join41(dir, entry.name);
           const relativePath = relative4(this.projectPath, fullPath);
           if (entry.name.startsWith(".") && entry.name !== ".github" && entry.name !== ".env.example") {
             if (!entry.isDirectory()) {
@@ -22058,7 +23540,7 @@ var PrimerAnalyzer = class {
   }
   getProjectInfo() {
     const info = {
-      name: basename14(this.projectPath)
+      name: basename17(this.projectPath)
     };
     if (this.packageJson) {
       if (typeof this.packageJson.name === "string") {
@@ -22080,10 +23562,10 @@ var PrimerAnalyzer = class {
         info.repository = String(repo.url);
       }
     }
-    const pyprojectPath = join40(this.projectPath, "pyproject.toml");
-    if (!this.packageJson && existsSync39(pyprojectPath)) {
+    const pyprojectPath = join41(this.projectPath, "pyproject.toml");
+    if (!this.packageJson && existsSync40(pyprojectPath)) {
       try {
-        const content = readFileSync28(pyprojectPath, "utf-8");
+        const content = readFileSync29(pyprojectPath, "utf-8");
         const nameMatch = content.match(/name\s*=\s*["']([^"']+)["']/);
         const versionMatch = content.match(/version\s*=\s*["']([^"']+)["']/);
         const descMatch = content.match(/description\s*=\s*["']([^"']+)["']/);
@@ -22093,10 +23575,10 @@ var PrimerAnalyzer = class {
       } catch {
       }
     }
-    const cargoPath = join40(this.projectPath, "Cargo.toml");
-    if (!this.packageJson && existsSync39(cargoPath)) {
+    const cargoPath = join41(this.projectPath, "Cargo.toml");
+    if (!this.packageJson && existsSync40(cargoPath)) {
       try {
-        const content = readFileSync28(cargoPath, "utf-8");
+        const content = readFileSync29(cargoPath, "utf-8");
         const nameMatch = content.match(/name\s*=\s*["']([^"']+)["']/);
         const versionMatch = content.match(/version\s*=\s*["']([^"']+)["']/);
         const descMatch = content.match(/description\s*=\s*["']([^"']+)["']/);
@@ -22276,8 +23758,8 @@ var PrimerAnalyzer = class {
     }
     if (this.hasFile("tsconfig.json")) {
       try {
-        const tsconfigPath = join40(this.projectPath, "tsconfig.json");
-        const content = readFileSync28(tsconfigPath, "utf-8");
+        const tsconfigPath = join41(this.projectPath, "tsconfig.json");
+        const content = readFileSync29(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("@"))) {
@@ -22306,7 +23788,7 @@ var PrimerAnalyzer = class {
       ci.provider = "github-actions";
       ci.configFile = ".github/workflows";
       try {
-        const workflowsDir = join40(this.projectPath, ".github/workflows");
+        const workflowsDir = join41(this.projectPath, ".github/workflows");
         const workflows = readdirSync11(workflowsDir);
         const deployWorkflows = workflows.filter(
           (f) => f.includes("deploy") || f.includes("release") || f.includes("publish")
@@ -22327,12 +23809,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 = join40(
+      const envExamplePath = join41(
         this.projectPath,
         this.hasFile(".env.example") ? ".env.example" : this.hasFile(".env.template") ? ".env.template" : ".env.sample"
       );
       try {
-        const content = readFileSync28(envExamplePath, "utf-8");
+        const content = readFileSync29(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 {
@@ -22349,8 +23831,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 = join40(this.projectPath, "Dockerfile");
-        const content = readFileSync28(dockerfilePath, "utf-8");
+        const dockerfilePath = join41(this.projectPath, "Dockerfile");
+        const content = readFileSync29(dockerfilePath, "utf-8");
         const fromMatch = content.match(/^FROM\s+(\S+)/m);
         if (fromMatch) {
           docker.baseImage = fromMatch[1];
@@ -22439,7 +23921,7 @@ var PrimerAnalyzer = class {
       }
       return false;
     }
-    return this.files.has(name) || existsSync39(join40(this.projectPath, name));
+    return this.files.has(name) || existsSync40(join41(this.projectPath, name));
   }
   getDepVersion(dep) {
     if (!this.packageJson) return void 0;
@@ -22461,10 +23943,10 @@ var PrimerAnalyzer = class {
   }
   readConfigFile(files) {
     for (const file of files) {
-      const filePath = join40(this.projectPath, file);
-      if (existsSync39(filePath)) {
+      const filePath = join41(this.projectPath, file);
+      if (existsSync40(filePath)) {
         try {
-          const content = readFileSync28(filePath, "utf-8");
+          const content = readFileSync29(filePath, "utf-8");
           if (file.endsWith(".json")) {
             return JSON.parse(content);
           }
@@ -22482,8 +23964,8 @@ function analyzePrimer(projectPath) {
 }
 
 // src/primer/generator.ts
-import { existsSync as existsSync40, mkdirSync as mkdirSync21, writeFileSync as writeFileSync21 } from "fs";
-import { join as join41, dirname as dirname14 } from "path";
+import { existsSync as existsSync41, mkdirSync as mkdirSync22, writeFileSync as writeFileSync22 } from "fs";
+import { join as join42, dirname as dirname15 } from "path";
 var ALL_AGENTS = Object.keys(AGENT_CONFIG);
 var markdownRenderer = {
   h1: (text) => `# ${text}`,
@@ -22647,14 +24129,14 @@ var PrimerGenerator = class {
   detectInstalledAgents() {
     const detected = [];
     for (const [agent, config] of Object.entries(AGENT_CONFIG)) {
-      const configPath = join41(this.projectPath, config.configFile);
-      const skillsPath = join41(this.projectPath, config.skillsDir);
-      if (existsSync40(configPath) || existsSync40(skillsPath)) {
+      const configPath = join42(this.projectPath, config.configFile);
+      const skillsPath = join42(this.projectPath, config.skillsDir);
+      if (existsSync41(configPath) || existsSync41(skillsPath)) {
         detected.push(agent);
       }
       if (config.altSkillsDirs) {
         for (const altDir of config.altSkillsDirs) {
-          if (existsSync40(join41(this.projectPath, altDir))) {
+          if (existsSync41(join42(this.projectPath, altDir))) {
             if (!detected.includes(agent)) {
               detected.push(agent);
             }
@@ -22674,7 +24156,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 = join41(outputDir, template.filename);
+    const filepath = join42(outputDir, template.filename);
     return {
       agent,
       filename: template.filename,
@@ -23046,11 +24528,11 @@ var PrimerGenerator = class {
     return lines.join("\n");
   }
   writeInstruction(instruction) {
-    const dir = dirname14(instruction.filepath);
-    if (!existsSync40(dir)) {
-      mkdirSync21(dir, { recursive: true });
+    const dir = dirname15(instruction.filepath);
+    if (!existsSync41(dir)) {
+      mkdirSync22(dir, { recursive: true });
     }
-    writeFileSync21(instruction.filepath, instruction.content, "utf-8");
+    writeFileSync22(instruction.filepath, instruction.content, "utf-8");
   }
   formatProjectType(type) {
     const typeMap = {
@@ -23092,23 +24574,23 @@ var DEFAULT_LEARNING_CONFIG = {
 };
 
 // src/learning/config.ts
-import { existsSync as existsSync41, readFileSync as readFileSync29, writeFileSync as writeFileSync22, mkdirSync as mkdirSync22 } from "fs";
-import { join as join42, dirname as dirname15 } from "path";
-import { homedir as homedir13 } from "os";
+import { existsSync as existsSync42, readFileSync as readFileSync30, writeFileSync as writeFileSync23, mkdirSync as mkdirSync23 } from "fs";
+import { join as join43, dirname as dirname16 } from "path";
+import { homedir as homedir14 } from "os";
 import yaml from "yaml";
 function getDefaultConfigPath() {
-  return join42(homedir13(), ".skillkit", "learning.yaml");
+  return join43(homedir14(), ".skillkit", "learning.yaml");
 }
 function getDefaultStorePath() {
-  return join42(homedir13(), ".skillkit", "learned", "patterns.json");
+  return join43(homedir14(), ".skillkit", "learned", "patterns.json");
 }
 function loadLearningConfig(configPath) {
   const path4 = configPath || getDefaultConfigPath();
-  if (!existsSync41(path4)) {
+  if (!existsSync42(path4)) {
     return DEFAULT_LEARNING_CONFIG;
   }
   try {
-    const content = readFileSync29(path4, "utf-8");
+    const content = readFileSync30(path4, "utf-8");
     const config = yaml.parse(content);
     return { ...DEFAULT_LEARNING_CONFIG, ...config };
   } catch {
@@ -23117,16 +24599,16 @@ function loadLearningConfig(configPath) {
 }
 function saveLearningConfig(config, configPath) {
   const path4 = configPath || getDefaultConfigPath();
-  const dir = dirname15(path4);
-  if (!existsSync41(dir)) {
-    mkdirSync22(dir, { recursive: true });
+  const dir = dirname16(path4);
+  if (!existsSync42(dir)) {
+    mkdirSync23(dir, { recursive: true });
   }
   const content = yaml.stringify(config);
-  writeFileSync22(path4, content);
+  writeFileSync23(path4, content);
 }
 function loadPatternStore(storePath) {
   const path4 = storePath || getDefaultStorePath();
-  if (!existsSync41(path4)) {
+  if (!existsSync42(path4)) {
     return {
       version: 1,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -23135,7 +24617,7 @@ function loadPatternStore(storePath) {
     };
   }
   try {
-    const content = readFileSync29(path4, "utf-8");
+    const content = readFileSync30(path4, "utf-8");
     return JSON.parse(content);
   } catch {
     return {
@@ -23148,13 +24630,13 @@ function loadPatternStore(storePath) {
 }
 function savePatternStore(store, storePath) {
   const path4 = storePath || getDefaultStorePath();
-  const dir = dirname15(path4);
-  if (!existsSync41(dir)) {
-    mkdirSync22(dir, { recursive: true });
+  const dir = dirname16(path4);
+  if (!existsSync42(dir)) {
+    mkdirSync23(dir, { recursive: true });
   }
   store.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const content = JSON.stringify(store, null, 2);
-  writeFileSync22(path4, content);
+  writeFileSync23(path4, content);
 }
 function addPattern(pattern, storePath) {
   const store = loadPatternStore(storePath);
@@ -23197,8 +24679,8 @@ function getApprovedPatterns(storePath) {
 
 // src/learning/git-analyzer.ts
 import { execSync as execSync7 } from "child_process";
-import { existsSync as existsSync42 } from "fs";
-import { join as join43 } from "path";
+import { existsSync as existsSync43 } from "fs";
+import { join as join44 } from "path";
 function runGitCommand(command, cwd) {
   try {
     return execSync7(command, { cwd, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 });
@@ -23207,7 +24689,7 @@ function runGitCommand(command, cwd) {
   }
 }
 function isGitRepository(path4) {
-  return existsSync42(join43(path4, ".git"));
+  return existsSync43(join44(path4, ".git"));
 }
 function getGitCommits(repoPath, options = {}) {
   if (!isGitRepository(repoPath)) {
@@ -23712,9 +25194,9 @@ function mergePatterns(existing, newPatterns) {
 }
 
 // src/learning/generator.ts
-import { writeFileSync as writeFileSync23, mkdirSync as mkdirSync23, existsSync as existsSync43 } from "fs";
-import { join as join44 } from "path";
-import { homedir as homedir14 } from "os";
+import { writeFileSync as writeFileSync24, mkdirSync as mkdirSync24, existsSync as existsSync44 } from "fs";
+import { join as join45 } from "path";
+import { homedir as homedir15 } from "os";
 function generateSkillFromPatterns(patterns, options = {}) {
   const minConfidence = options.minConfidence ?? 0.5;
   const minPatterns = options.minPatterns ?? 1;
@@ -23804,12 +25286,12 @@ function generateSkillContent2(name, patterns, category) {
   return lines.join("\n");
 }
 function saveGeneratedSkill(skill, outputDir) {
-  const dir = outputDir || join44(homedir14(), ".skillkit", "skills", "learned");
-  if (!existsSync43(dir)) {
-    mkdirSync23(dir, { recursive: true });
+  const dir = outputDir || join45(homedir15(), ".skillkit", "skills", "learned");
+  if (!existsSync44(dir)) {
+    mkdirSync24(dir, { recursive: true });
   }
-  const filepath = join44(dir, skill.filename);
-  writeFileSync23(filepath, skill.content);
+  const filepath = join45(dir, skill.filename);
+  writeFileSync24(filepath, skill.content);
   return filepath;
 }
 function generatePatternReport(patterns) {
@@ -24039,9 +25521,9 @@ var DEFAULT_PROFILE_CONFIG = {
 };
 
 // src/profiles/manager.ts
-import { existsSync as existsSync44, readFileSync as readFileSync30, writeFileSync as writeFileSync24, mkdirSync as mkdirSync24 } from "fs";
-import { join as join45, dirname as dirname16 } from "path";
-import { homedir as homedir15 } from "os";
+import { existsSync as existsSync45, readFileSync as readFileSync31, writeFileSync as writeFileSync25, mkdirSync as mkdirSync25 } from "fs";
+import { join as join46, dirname as dirname17 } from "path";
+import { homedir as homedir16 } from "os";
 import yaml2 from "yaml";
 var BUILTIN_PROFILES = [
   {
@@ -24121,15 +25603,15 @@ var BUILTIN_PROFILES = [
   }
 ];
 function getConfigPath() {
-  return join45(homedir15(), ".skillkit", "profiles.yaml");
+  return join46(homedir16(), ".skillkit", "profiles.yaml");
 }
 function loadProfileConfig() {
   const path4 = getConfigPath();
-  if (!existsSync44(path4)) {
+  if (!existsSync45(path4)) {
     return DEFAULT_PROFILE_CONFIG;
   }
   try {
-    const content = readFileSync30(path4, "utf-8");
+    const content = readFileSync31(path4, "utf-8");
     return { ...DEFAULT_PROFILE_CONFIG, ...yaml2.parse(content) };
   } catch {
     return DEFAULT_PROFILE_CONFIG;
@@ -24137,11 +25619,11 @@ function loadProfileConfig() {
 }
 function saveProfileConfig(config) {
   const path4 = getConfigPath();
-  const dir = dirname16(path4);
-  if (!existsSync44(dir)) {
-    mkdirSync24(dir, { recursive: true });
+  const dir = dirname17(path4);
+  if (!existsSync45(dir)) {
+    mkdirSync25(dir, { recursive: true });
   }
-  writeFileSync24(path4, yaml2.stringify(config));
+  writeFileSync25(path4, yaml2.stringify(config));
 }
 function getActiveProfile() {
   const config = loadProfileConfig();
@@ -24208,9 +25690,9 @@ var DEFAULT_GUIDELINE_CONFIG = {
 };
 
 // src/guidelines/manager.ts
-import { existsSync as existsSync45, readFileSync as readFileSync31, writeFileSync as writeFileSync25, mkdirSync as mkdirSync25 } from "fs";
-import { join as join46, dirname as dirname17 } from "path";
-import { homedir as homedir16 } from "os";
+import { existsSync as existsSync46, readFileSync as readFileSync32, writeFileSync as writeFileSync26, mkdirSync as mkdirSync26 } from "fs";
+import { join as join47, dirname as dirname18 } from "path";
+import { homedir as homedir17 } from "os";
 import yaml3 from "yaml";
 var BUILTIN_GUIDELINES = [
   {
@@ -24387,15 +25869,15 @@ Types: feat, fix, docs, style, refactor, test, chore`
   }
 ];
 function getConfigPath2() {
-  return join46(homedir16(), ".skillkit", "guidelines.yaml");
+  return join47(homedir17(), ".skillkit", "guidelines.yaml");
 }
 function loadGuidelineConfig() {
   const path4 = getConfigPath2();
-  if (!existsSync45(path4)) {
+  if (!existsSync46(path4)) {
     return DEFAULT_GUIDELINE_CONFIG;
   }
   try {
-    const content = readFileSync31(path4, "utf-8");
+    const content = readFileSync32(path4, "utf-8");
     return { ...DEFAULT_GUIDELINE_CONFIG, ...yaml3.parse(content) };
   } catch {
     return DEFAULT_GUIDELINE_CONFIG;
@@ -24403,11 +25885,11 @@ function loadGuidelineConfig() {
 }
 function saveGuidelineConfig(config) {
   const path4 = getConfigPath2();
-  const dir = dirname17(path4);
-  if (!existsSync45(dir)) {
-    mkdirSync25(dir, { recursive: true });
+  const dir = dirname18(path4);
+  if (!existsSync46(dir)) {
+    mkdirSync26(dir, { recursive: true });
   }
-  writeFileSync25(path4, yaml3.stringify(config));
+  writeFileSync26(path4, yaml3.stringify(config));
 }
 function getGuideline(id) {
   const builtin = BUILTIN_GUIDELINES.find((g) => g.id === id);
@@ -24489,8 +25971,8 @@ init_generator();
 
 // src/tree/serializer.ts
 init_types3();
-import { readFileSync as readFileSync32, writeFileSync as writeFileSync26, existsSync as existsSync46, mkdirSync as mkdirSync26 } from "fs";
-import { dirname as dirname18 } from "path";
+import { readFileSync as readFileSync33, writeFileSync as writeFileSync27, existsSync as existsSync47, mkdirSync as mkdirSync27 } from "fs";
+import { dirname as dirname19 } from "path";
 var TREE_FILE_NAME = "skill-tree.json";
 function serializeTree(tree) {
   return JSON.stringify(tree, null, 2);
@@ -24500,19 +25982,19 @@ function deserializeTree(json) {
   return SkillTreeSchema.parse(parsed);
 }
 function saveTree(tree, path4) {
-  const dir = dirname18(path4);
-  if (!existsSync46(dir)) {
-    mkdirSync26(dir, { recursive: true });
+  const dir = dirname19(path4);
+  if (!existsSync47(dir)) {
+    mkdirSync27(dir, { recursive: true });
   }
   const json = serializeTree(tree);
-  writeFileSync26(path4, json, "utf-8");
+  writeFileSync27(path4, json, "utf-8");
 }
 function loadTree(path4) {
-  if (!existsSync46(path4)) {
+  if (!existsSync47(path4)) {
     return null;
   }
   try {
-    const json = readFileSync32(path4, "utf-8");
+    const json = readFileSync33(path4, "utf-8");
     return deserializeTree(json);
   } catch {
     return null;
@@ -25229,7 +26711,7 @@ var ExecutionFlowSchema = z11.object({
 });
 
 // src/execution/manager.ts
-import { randomUUID as randomUUID14 } from "crypto";
+import { randomUUID as randomUUID15 } from "crypto";
 var DEFAULT_MAX_RETRIES = 3;
 var DEFAULT_RETRY_DELAY = 1e3;
 var DEFAULT_TIMEOUT2 = 3e4;
@@ -25249,7 +26731,7 @@ var ExecutionManager = class {
     };
   }
   createFlow(skillName, steps, options = {}) {
-    const flowId = randomUUID14();
+    const flowId = randomUUID15();
     const executionSteps = steps.map((step, index) => ({
       id: `${flowId}-step-${index}`,
       name: step.name,
@@ -25467,12 +26949,12 @@ function createExecutionManager(config) {
 }
 
 // src/execution/mode.ts
-import { existsSync as existsSync47, readFileSync as readFileSync33 } from "fs";
-import { join as join47 } from "path";
-import { homedir as homedir17 } from "os";
+import { existsSync as existsSync48, readFileSync as readFileSync34 } from "fs";
+import { join as join48 } from "path";
+import { homedir as homedir18 } from "os";
 var DEFAULT_MCP_CONFIG_PATHS = [
-  join47(homedir17(), ".mcp.json"),
-  join47(homedir17(), ".config", "claude", "mcp.json"),
+  join48(homedir18(), ".mcp.json"),
+  join48(homedir18(), ".config", "claude", "mcp.json"),
   ".mcp.json",
   "mcp.json"
 ];
@@ -25521,8 +27003,8 @@ function detectMcpServers(configPaths) {
   for (const configPath of configPaths) {
     try {
       const fullPath = configPath.startsWith("~") ? configPath.replace("~", process.env.HOME || "") : configPath;
-      if (existsSync47(fullPath)) {
-        const content = readFileSync33(fullPath, "utf-8");
+      if (existsSync48(fullPath)) {
+        const content = readFileSync34(fullPath, "utf-8");
         const config = JSON.parse(content);
         if (config.mcpServers) {
           servers.push(...Object.keys(config.mcpServers));
@@ -25659,6 +27141,80 @@ init_rrf();
 init_expansion();
 init_hybrid();
 
+// src/registry/community.ts
+import { readFileSync as readFileSync35, existsSync as existsSync49 } from "fs";
+import { join as join49, dirname as dirname20 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var CommunityRegistry = class {
+  constructor(skillsMdPath) {
+    this.skillsMdPath = skillsMdPath;
+  }
+  name = "community";
+  entries = [];
+  loaded = false;
+  load() {
+    if (this.loaded) return;
+    this.loaded = true;
+    const paths = this.skillsMdPath ? [this.skillsMdPath] : [
+      join49(process.cwd(), "registry", "SKILLS.md"),
+      join49(dirname20(fileURLToPath2(import.meta.url)), "..", "..", "..", "..", "registry", "SKILLS.md")
+    ];
+    for (const path4 of paths) {
+      if (!existsSync49(path4)) continue;
+      try {
+        const content = readFileSync35(path4, "utf-8");
+        this.entries = this.parse(content);
+        return;
+      } catch {
+        continue;
+      }
+    }
+  }
+  parse(content) {
+    const results = [];
+    let currentCategory = "";
+    for (const line of content.split("\n")) {
+      const headerMatch = line.match(/^##\s+(.+)/);
+      if (headerMatch) {
+        currentCategory = headerMatch[1].trim();
+        continue;
+      }
+      const entryMatch = line.match(/^-\s+\[([^\]]+)\]\(([^)]+)\)\s*-\s*(.+)/);
+      if (entryMatch) {
+        results.push({
+          name: entryMatch[1].trim(),
+          url: entryMatch[2].trim(),
+          description: entryMatch[3].trim(),
+          category: currentCategory
+        });
+      }
+    }
+    return results;
+  }
+  async search(query, options) {
+    this.load();
+    const limit = options?.limit ?? 20;
+    const q = query.toLowerCase();
+    const matched = this.entries.filter(
+      (e) => e.name.toLowerCase().includes(q) || e.description.toLowerCase().includes(q) || e.category.toLowerCase().includes(q)
+    );
+    return matched.slice(0, limit).map((e) => ({
+      name: e.name,
+      description: e.description,
+      source: e.url,
+      registry: this.name
+    }));
+  }
+  getAll() {
+    this.load();
+    return [...this.entries];
+  }
+  getCategories() {
+    this.load();
+    return [...new Set(this.entries.map((e) => e.category))];
+  }
+};
+
 // src/registry/index.ts
 var RateLimitError = class extends Error {
   constructor(registry) {
@@ -25765,6 +27321,296 @@ var FederatedSearch = class {
     };
   }
 };
+
+// src/cache/memory.ts
+var DEFAULT_MAX_SIZE = 1e3;
+var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
+var MemoryCache = class {
+  store = /* @__PURE__ */ new Map();
+  maxSize;
+  ttlMs;
+  hitCount = 0;
+  missCount = 0;
+  constructor(options) {
+    this.maxSize = options?.maxSize ?? DEFAULT_MAX_SIZE;
+    this.ttlMs = options?.ttlMs ?? DEFAULT_TTL_MS;
+  }
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry) {
+      this.missCount++;
+      return void 0;
+    }
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      this.missCount++;
+      return void 0;
+    }
+    entry.lastAccessed = Date.now();
+    this.hitCount++;
+    return entry.value;
+  }
+  set(key, value) {
+    if (this.store.size >= this.maxSize && !this.store.has(key)) {
+      this.evictLRU();
+    }
+    const now = Date.now();
+    this.store.set(key, {
+      value,
+      expiresAt: now + this.ttlMs,
+      lastAccessed: now
+    });
+  }
+  delete(key) {
+    return this.store.delete(key);
+  }
+  has(key) {
+    const entry = this.store.get(key);
+    if (!entry) return false;
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return false;
+    }
+    return true;
+  }
+  clear() {
+    this.store.clear();
+    this.hitCount = 0;
+    this.missCount = 0;
+  }
+  stats() {
+    const total = this.hitCount + this.missCount;
+    return {
+      hits: this.hitCount,
+      misses: this.missCount,
+      size: this.store.size,
+      maxSize: this.maxSize,
+      hitRate: total > 0 ? this.hitCount / total : 0
+    };
+  }
+  evictLRU() {
+    let oldestKey = null;
+    let oldestTime = Infinity;
+    for (const [key, entry] of this.store) {
+      if (entry.lastAccessed < oldestTime) {
+        oldestTime = entry.lastAccessed;
+        oldestKey = key;
+      }
+    }
+    if (oldestKey) {
+      this.store.delete(oldestKey);
+    }
+  }
+};
+
+// src/ranking/relevance.ts
+var WEIGHTS = {
+  contentAvailability: 40,
+  queryMatch: 30,
+  popularity: 15,
+  references: 15
+};
+var RelevanceRanker = class {
+  rank(skills, query) {
+    const results = skills.map((skill) => {
+      const breakdown = this.score(skill, query);
+      const score = breakdown.contentAvailability + breakdown.queryMatch + breakdown.popularity + breakdown.referenceScore;
+      return { skill, score, breakdown };
+    });
+    results.sort((a, b) => b.score - a.score);
+    return results;
+  }
+  score(skill, query) {
+    return {
+      contentAvailability: this.scoreContent(skill),
+      queryMatch: query ? this.scoreQuery(skill, query) : 0,
+      popularity: this.scorePopularity(skill),
+      referenceScore: this.scoreReferences(skill)
+    };
+  }
+  scoreContent(skill) {
+    let score = 0;
+    if (skill.description && skill.description.length > 0) score += 20;
+    if (skill.content && skill.content.length > 0) score += 20;
+    return score;
+  }
+  scoreQuery(skill, query) {
+    const q = query.toLowerCase();
+    const name = skill.name.toLowerCase();
+    if (name === q) return WEIGHTS.queryMatch;
+    if (name.includes(q) || q.includes(name)) {
+      return WEIGHTS.queryMatch * 0.7;
+    }
+    const desc = (skill.description || "").toLowerCase();
+    const content = (skill.content || "").toLowerCase();
+    const searchable = `${name} ${desc} ${content}`;
+    const words = q.split(/\s+/).filter(Boolean);
+    const matched = words.filter((w) => searchable.includes(w)).length;
+    if (words.length === 0) return 0;
+    return Math.round(WEIGHTS.queryMatch * (matched / words.length) * 0.6);
+  }
+  scorePopularity(skill) {
+    const count = (skill.stars ?? 0) + (skill.installs ?? 0);
+    if (count <= 0) return 0;
+    return Math.min(WEIGHTS.popularity, Math.round(Math.log10(count + 1) * 5));
+  }
+  scoreReferences(skill) {
+    if (!skill.references || skill.references.length === 0) return 0;
+    return Math.min(WEIGHTS.references, skill.references.length * 5);
+  }
+};
+
+// src/parser/references.ts
+import { readdirSync as readdirSync12, statSync as statSync9, existsSync as existsSync50 } from "fs";
+import { join as join50 } from "path";
+var REFERENCE_DIRS = ["references", "resources", "docs", "examples", "assets", "scripts"];
+var DIR_TYPE_MAP = {
+  references: "resource",
+  resources: "resource",
+  docs: "doc",
+  examples: "example",
+  assets: "asset",
+  scripts: "resource"
+};
+function discoverReferences(skillDir) {
+  const refs = [];
+  for (const dir of REFERENCE_DIRS) {
+    const fullPath = join50(skillDir, dir);
+    if (!existsSync50(fullPath)) continue;
+    try {
+      const stat = statSync9(fullPath);
+      if (!stat.isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    const type = DIR_TYPE_MAP[dir] || "resource";
+    try {
+      const entries = readdirSync12(fullPath);
+      for (const entry of entries) {
+        const entryPath = join50(fullPath, entry);
+        try {
+          const entryStat = statSync9(entryPath);
+          if (entryStat.isFile()) {
+            refs.push({
+              path: join50(dir, entry),
+              type,
+              name: entry
+            });
+          }
+        } catch {
+          continue;
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  return refs;
+}
+function stripFrontmatter(raw) {
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!match) {
+    const emptyMatch = raw.match(/^---\r?\n---\r?\n?([\s\S]*)$/);
+    if (emptyMatch) {
+      return { frontmatter: {}, body: emptyMatch[1] };
+    }
+    return { frontmatter: {}, body: raw };
+  }
+  const fmBlock = match[1];
+  const body = match[2];
+  const frontmatter = {};
+  for (const line of fmBlock.split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const value = line.slice(colonIdx + 1).trim();
+    if (key) {
+      frontmatter[key] = value;
+    }
+  }
+  return { frontmatter, body };
+}
+function parseSkillMd(raw, skillDir) {
+  const { frontmatter, body } = stripFrontmatter(raw);
+  const references = skillDir ? discoverReferences(skillDir) : [];
+  return {
+    frontmatter,
+    body,
+    references,
+    raw
+  };
+}
+
+// src/runtime/injector.ts
+function parseSource2(source) {
+  const parts = source.replace(/^https?:\/\/github\.com\//, "").split("/");
+  if (parts.length < 2) {
+    throw new Error(`Invalid source format: "${source}". Expected "owner/repo".`);
+  }
+  return { owner: parts[0], repo: parts[1] };
+}
+var SkillInjector = class {
+  cache;
+  constructor(cacheTtlMs) {
+    this.cache = new MemoryCache({
+      maxSize: 200,
+      ttlMs: cacheTtlMs ?? 24 * 60 * 60 * 1e3
+    });
+  }
+  async fetch(source, skillId) {
+    const cacheKey = `${source}:${skillId}`;
+    const cached = this.cache.get(cacheKey);
+    if (cached) return cached;
+    const { owner, repo } = parseSource2(source);
+    const raw = await this.fetchRawSkillMd(owner, repo, skillId);
+    const parsed = parseSkillMd(raw);
+    const result = {
+      source: { owner, repo },
+      skillId,
+      parsed,
+      fetchedAt: Date.now()
+    };
+    this.cache.set(cacheKey, result);
+    return result;
+  }
+  async inject(source, skillId) {
+    const fetched = await this.fetch(source, skillId);
+    return fetched.parsed.body;
+  }
+  async fetchRawSkillMd(owner, repo, skillId) {
+    const paths = [
+      `${skillId}/SKILL.md`,
+      `skills/${skillId}/SKILL.md`,
+      `SKILL.md`
+    ];
+    const headers = {
+      Accept: "application/vnd.github.v3.raw",
+      "User-Agent": "skillkit-runtime"
+    };
+    const token = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    }
+    for (const path4 of paths) {
+      const url = `https://api.github.com/repos/${owner}/${repo}/contents/${path4}`;
+      try {
+        const response = await fetch(url, { headers });
+        if (response.ok) {
+          return await response.text();
+        }
+      } catch {
+        continue;
+      }
+    }
+    throw new Error(`SKILL.md not found in ${owner}/${repo} for skill "${skillId}"`);
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+  cacheStats() {
+    return this.cache.stats();
+  }
+};
 export {
   AGENT_CLI_CONFIGS,
   AGENT_CONFIG,
@@ -25793,8 +27639,10 @@ export {
   CONTEXT_DIR,
   CONTEXT_FILE,
   CUSTOM_AGENT_FORMAT_MAP,
+  ClaudeMdUpdater,
   CommandGenerator,
   CommandRegistry,
+  CommunityRegistry,
   ConnectorCategorySchema,
   ConnectorConfigSchema,
   ConnectorMappingSchema,
@@ -25811,6 +27659,7 @@ export {
   DEFAULT_HYBRID_CONFIG,
   DEFAULT_LEARNING_CONFIG,
   DEFAULT_MEMORY_CONFIG,
+  DEFAULT_MEMORY_HOOK_CONFIG,
   DEFAULT_PROFILE_CONFIG,
   DEFAULT_REASONING_CONFIG,
   DEFAULT_SCORING_WEIGHTS,
@@ -25841,8 +27690,10 @@ export {
   MARKETPLACE_CACHE_FILE,
   MODEL_REGISTRY,
   MarketplaceAggregator,
+  MemoryCache,
   MemoryCompressor,
   MemoryEnabledEngine,
+  MemoryHookManager,
   MemoryIndexStore,
   MemoryInjector,
   MemoryObserver,
@@ -25859,8 +27710,10 @@ export {
   PlanValidator,
   PluginLoader,
   PluginManager,
+  PostToolUseHook,
   PrimerAnalyzer,
   PrimerGenerator,
+  ProgressiveDisclosureManager,
   ProjectDetector,
   QueryExpander,
   RateLimitError,
@@ -25868,18 +27721,22 @@ export {
   ReasoningProviderSchema,
   ReasoningRecommendationEngine,
   RecommendationEngine,
+  RelevanceRanker,
   RuleBasedCompressor,
   SEARCH_PLANNING_PROMPT,
   SESSION_FILE,
   SKILL_DISCOVERY_PATHS,
   SKILL_MATCH_PROMPT,
   STANDARD_PLACEHOLDERS,
+  SessionEndHook,
   SessionManager,
+  SessionStartHook,
   Skill,
   SkillBundle,
   SkillChunkSchema,
   SkillExecutionEngine,
   SkillFrontmatter,
+  SkillInjector,
   SkillLocation,
   SkillMdTranslator,
   SkillMetadata,
@@ -25932,6 +27789,7 @@ export {
   computeRRFScore,
   copilotTranslator,
   createAPIBasedCompressor,
+  createClaudeMdUpdater,
   createCommandGenerator,
   createCommandRegistry,
   createConnectorConfig,
@@ -25946,6 +27804,7 @@ export {
   createMarketplaceAggregator,
   createMemoryCompressor,
   createMemoryEnabledEngine,
+  createMemoryHookManager,
   createMemoryInjector,
   createMemoryObserver,
   createMessageBus,
@@ -25957,13 +27816,17 @@ export {
   createPlanParser,
   createPlanValidator,
   createPluginManager,
+  createPostToolUseHook,
+  createProgressiveDisclosureManager,
   createQueryExpander,
   createReasoningEngine,
   createReasoningRecommendationEngine,
   createRecommendationEngine,
   createRuleBasedCompressor,
+  createSessionEndHook,
   createSessionFile,
   createSessionManager,
+  createSessionStartHook,
   createSimulatedSkillExecutor,
   createSkillBundle,
   createSkillExecutor,
@@ -25989,6 +27852,7 @@ export {
   discoverAgentsFromPath,
   discoverAgentsRecursive,
   discoverGlobalAgents,
+  discoverReferences,
   discoverSkills,
   dryRunExecutor,
   enableGuideline,
@@ -25996,6 +27860,9 @@ export {
   evaluateSkillContent,
   evaluateSkillDirectory,
   evaluateSkillFile,
+  executePostToolUseHook,
+  executeSessionEndHook,
+  executeSessionStartHook,
   executeWithAgent,
   expandQuerySimple,
   exportBundle,
@@ -26155,6 +28022,7 @@ export {
   parseSkill,
   parseSkillContent,
   parseSkillContentToCanonical,
+  parseSkillMd,
   parseSkillToCanonical,
   parseSource,
   parseWorkflow,
@@ -26191,9 +28059,11 @@ export {
   shellExecutor,
   skillMdTranslator,
   skillToSubagent,
+  stripFrontmatter,
   suggestMappingsFromMcp,
   supportsAutoDiscovery,
   supportsSlashCommands,
+  syncGlobalClaudeMd,
   syncToAgent,
   syncToAllAgents,
   toCanonicalAgent,
@@ -26208,6 +28078,7 @@ export {
   translatorRegistry,
   treeToMarkdown,
   treeToText,
+  updateClaudeMd,
   updateSessionFile,
   validateAgent,
   validateBuiltinPacks,