@skillkit/cli 1.12.0 → 1.14.0

package/dist/index.js

@@ -1045,6 +1045,529 @@ This skill should NOT:
   }
 });
 
+// src/commands/generate.ts
+var generate_exports = {};
+__export(generate_exports, {
+  GenerateCommand: () => GenerateCommand
+});
+import { Command as Command35, Option as Option34 } from "clipanion";
+import { resolve as resolve16 } from "path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync8, writeFileSync as writeFileSync8 } from "fs";
+import {
+  SkillWizard,
+  detectProviders,
+  getProviderModels,
+  SkillComposer
+} from "@skillkit/core";
+function getTrustGradeColor(grade) {
+  switch (grade) {
+    case "trusted":
+      return colors.success;
+    case "review":
+      return colors.warning;
+    default:
+      return colors.error;
+  }
+}
+function getCompatGradeColor(grade) {
+  switch (grade) {
+    case "A":
+    case "B":
+      return colors.success;
+    case "C":
+      return colors.warning;
+    default:
+      return colors.error;
+  }
+}
+var GenerateCommand;
+var init_generate = __esm({
+  "src/commands/generate.ts"() {
+    "use strict";
+    init_prompts();
+    init_theme();
+    GenerateCommand = class extends Command35 {
+      static paths = [["generate"], ["gen"]];
+      static usage = Command35.Usage({
+        description: "Smart AI-powered skill generation wizard",
+        details: `
+      Generate skills using AI with multi-source context gathering:
+
+      - Documentation (Context7)
+      - Local codebase patterns
+      - Marketplace skills (15,000+)
+      - Memory observations and learnings
+
+      Supports multiple LLM providers: Claude, GPT-4, Gemini, Ollama, OpenRouter
+    `,
+        examples: [
+          ["Interactive wizard", "$0 generate"],
+          ["Use specific provider", "$0 generate --provider openai"],
+          ["Compose from existing skills", '$0 generate --compose "testing patterns for vitest"'],
+          ["Target specific agents", "$0 generate --agents claude-code,cursor"],
+          ["Skip memory context", "$0 generate --no-memory"]
+        ]
+      });
+      provider = Option34.String("--provider,-p", {
+        description: "LLM provider: anthropic, openai, google, ollama, openrouter"
+      });
+      model = Option34.String("--model,-m", {
+        description: "Specific model to use (e.g., gpt-4o, gemini-2.0-flash)"
+      });
+      compose = Option34.String("--compose,-c", {
+        description: "Natural language search to find skills to compose"
+      });
+      agents = Option34.String("--agents,-a", {
+        description: "Target agents (comma-separated)"
+      });
+      noMemory = Option34.Boolean("--no-memory", false, {
+        description: "Skip memory context"
+      });
+      contextSources = Option34.String("--context-sources", {
+        description: "Context sources (comma-separated): docs,codebase,skills,memory"
+      });
+      output = Option34.String("--output,-o", {
+        description: "Output directory for generated skill"
+      });
+      json = Option34.Boolean("--json,-j", false, {
+        description: "Output in JSON format"
+      });
+      async execute() {
+        if (this.json) {
+          return this.executeNonInteractive();
+        }
+        intro2("SkillKit Smart Generate");
+        const providerResult = await this.selectProvider();
+        if (isCancel2(providerResult)) {
+          cancel2("Operation cancelled");
+          return 1;
+        }
+        const wizard = new SkillWizard({
+          projectPath: process.cwd(),
+          options: {
+            provider: providerResult.name,
+            model: providerResult.model
+          },
+          events: {
+            onProgress: (message) => log2(colors.muted(message))
+          }
+        });
+        const expertiseResult = await this.stepExpertise(wizard);
+        if (!expertiseResult) return 1;
+        const sourcesResult = await this.stepContextSources(wizard);
+        if (!sourcesResult) return 1;
+        const compositionResult = await this.stepComposition(wizard);
+        if (!compositionResult) return 1;
+        const clarificationResult = await this.stepClarification(wizard);
+        if (!clarificationResult) return 1;
+        const reviewResult = await this.stepReview(wizard);
+        if (!reviewResult) return 1;
+        const installResult = await this.stepInstall(wizard);
+        if (!installResult) return 1;
+        outro2("Skill generated and installed successfully!");
+        return 0;
+      }
+      async executeNonInteractive() {
+        console.error("Non-interactive mode requires --expertise flag (not implemented yet)");
+        return 1;
+      }
+      async selectProvider() {
+        if (this.provider) {
+          return {
+            name: this.provider,
+            model: this.model || ""
+          };
+        }
+        const detected = detectProviders();
+        const configured = detected.filter((p) => p.configured && p.provider !== "mock");
+        if (configured.length === 0) {
+          warn("No LLM provider configured");
+          note2(
+            `Set one of these environment variables:
+  ANTHROPIC_API_KEY - Claude (Anthropic)
+  OPENAI_API_KEY - GPT-4 (OpenAI)
+  GOOGLE_AI_KEY - Gemini (Google)
+  OPENROUTER_API_KEY - OpenRouter (100+ models)
+
+Or use Ollama for local models (no API key needed)`,
+            "Provider Setup"
+          );
+        }
+        const options = configured.map((p) => ({
+          value: p.provider,
+          label: p.displayName,
+          hint: p.envVar ? `via ${p.envVar}` : void 0
+        }));
+        if (options.length === 0) {
+          options.push({
+            value: "ollama",
+            label: "Ollama (Local)",
+            hint: "No API key needed"
+          });
+        }
+        const selected = await select2({
+          message: "Select LLM provider",
+          options
+        });
+        if (isCancel2(selected)) {
+          return selected;
+        }
+        const models = getProviderModels(selected);
+        if (models.length > 1 && !this.model) {
+          const modelOptions = models.map((m) => ({
+            value: m,
+            label: m
+          }));
+          const selectedModel = await select2({
+            message: "Select model",
+            options: modelOptions,
+            initialValue: models[0]
+          });
+          if (isCancel2(selectedModel)) {
+            return selectedModel;
+          }
+          return { name: selected, model: selectedModel };
+        }
+        return { name: selected, model: this.model || models[0] || "" };
+      }
+      async stepExpertise(wizard) {
+        this.showStepHeader("expertise", "Describe Your Expertise");
+        const expertise = await text2({
+          message: "What should this skill help with?",
+          placeholder: "e.g., Write comprehensive unit tests using vitest",
+          validate: (value) => {
+            if (value.length < 10) {
+              return "Please provide more detail (at least 10 characters)";
+            }
+            return void 0;
+          }
+        });
+        if (isCancel2(expertise)) {
+          cancel2("Operation cancelled");
+          return false;
+        }
+        const result = await wizard.setExpertise(expertise);
+        if (!result.success) {
+          error(result.error || "Failed to set expertise");
+          return false;
+        }
+        return true;
+      }
+      async stepContextSources(wizard) {
+        this.showStepHeader("context-sources", "Context Sources");
+        if (this.contextSources) {
+          const sourceNames = this.contextSources.split(",").map((s) => s.trim());
+          const sources2 = [
+            { name: "docs", enabled: sourceNames.includes("docs"), weight: 1 },
+            { name: "codebase", enabled: sourceNames.includes("codebase"), weight: 0.9 },
+            { name: "skills", enabled: sourceNames.includes("skills"), weight: 0.8 },
+            { name: "memory", enabled: sourceNames.includes("memory") && !this.noMemory, weight: 0.7 }
+          ];
+          const result2 = await wizard.setContextSources(sources2);
+          if (!result2.success) {
+            error(result2.error || "Failed to gather context");
+            return false;
+          }
+          return true;
+        }
+        const sourceOptions = [
+          { value: "docs", label: "Documentation (Context7)", hint: "Library docs & guides" },
+          { value: "codebase", label: "Codebase (local)", hint: "Project patterns & configs" },
+          { value: "skills", label: "Marketplace Skills", hint: "15,000+ skills" },
+          { value: "memory", label: "Memory & Learnings", hint: "Your corrections & patterns" }
+        ];
+        const selectedSources = await groupMultiselect2({
+          message: "Select context sources",
+          options: {
+            "Context Sources": sourceOptions
+          },
+          required: true
+        });
+        if (isCancel2(selectedSources)) {
+          cancel2("Operation cancelled");
+          return false;
+        }
+        const sources = [
+          { name: "docs", enabled: selectedSources.includes("docs"), weight: 1 },
+          { name: "codebase", enabled: selectedSources.includes("codebase"), weight: 0.9 },
+          { name: "skills", enabled: selectedSources.includes("skills"), weight: 0.8 },
+          { name: "memory", enabled: selectedSources.includes("memory") && !this.noMemory, weight: 0.7 }
+        ];
+        const spinner3 = spinner2();
+        spinner3.start("Gathering context...");
+        const result = await wizard.setContextSources(sources);
+        if (!result.success) {
+          spinner3.stop("Context gathering failed");
+          error(result.error || "Failed to gather context");
+          return false;
+        }
+        const state = wizard.getState();
+        spinner3.stop(`Gathered ${state.gatheredContext.length} context chunks`);
+        const sourceSummary = sources.filter((s) => s.enabled).map((s) => {
+          const chunks = state.gatheredContext.filter((c) => c.source === s.name);
+          return `  ${colors.success(symbols.success)} ${s.name}: ${chunks.length} chunks`;
+        }).join("\n");
+        note2(sourceSummary, "Context Summary");
+        return true;
+      }
+      async stepComposition(wizard) {
+        this.showStepHeader("composition", "Compose from Skills (optional)");
+        const searchQuery = this.compose;
+        if (!searchQuery) {
+          const wantCompose = await confirm2({
+            message: "Search marketplace skills to compose from?",
+            initialValue: false
+          });
+          if (isCancel2(wantCompose)) {
+            cancel2("Operation cancelled");
+            return false;
+          }
+          if (!wantCompose) {
+            await wizard.selectSkillsForComposition([]);
+            return true;
+          }
+        }
+        const query = searchQuery || await text2({
+          message: "Search for skills to compose",
+          placeholder: "e.g., testing patterns for vitest"
+        });
+        if (isCancel2(query)) {
+          cancel2("Operation cancelled");
+          return false;
+        }
+        const spinner3 = spinner2();
+        spinner3.start("Searching marketplace...");
+        const composer = new SkillComposer();
+        const foundSkills = await composer.findComposable(query, 10);
+        spinner3.stop(`Found ${foundSkills.length} relevant skills`);
+        if (foundSkills.length === 0) {
+          warn("No matching skills found");
+          await wizard.selectSkillsForComposition([]);
+          return true;
+        }
+        const skillOptions = foundSkills.map((skill) => ({
+          name: skill.name,
+          description: skill.description,
+          score: Math.round(skill.trustScore * 10),
+          source: skill.source
+        }));
+        const selectedSkills = await skillMultiselect({
+          message: "Select skills to compose from",
+          skills: skillOptions,
+          required: false
+        });
+        if (isCancel2(selectedSkills)) {
+          cancel2("Operation cancelled");
+          return false;
+        }
+        const selected = foundSkills.filter((s) => selectedSkills.includes(s.name));
+        await wizard.selectSkillsForComposition(selected);
+        return true;
+      }
+      async stepClarification(wizard) {
+        this.showStepHeader("clarification", "Clarification Questions");
+        const result = await wizard.answerClarifications([]);
+        if (!result.success) {
+          error(result.error || "Failed to generate questions");
+          return false;
+        }
+        const state = wizard.getState();
+        const questions = state.generatedQuestions;
+        if (questions.length === 0) {
+          log2(colors.muted("No clarification questions needed"));
+          return true;
+        }
+        const answers = [];
+        for (const question of questions) {
+          let answer;
+          if (question.type === "select" && question.options) {
+            answer = await select2({
+              message: question.question,
+              options: question.options.map((opt) => ({
+                value: opt,
+                label: opt
+              }))
+            });
+          } else if (question.type === "multiselect" && question.options) {
+            answer = await groupMultiselect2({
+              message: question.question,
+              options: {
+                Options: question.options.map((opt) => ({
+                  value: opt,
+                  label: opt
+                }))
+              }
+            });
+          } else if (question.type === "confirm") {
+            answer = await confirm2({
+              message: question.question
+            });
+          } else {
+            answer = await text2({
+              message: question.question,
+              placeholder: question.context
+            });
+          }
+          if (isCancel2(answer)) {
+            cancel2("Operation cancelled");
+            return false;
+          }
+          answers.push({
+            questionId: question.id,
+            answer
+          });
+        }
+        const finalResult = await wizard.answerClarifications(answers);
+        return finalResult.success;
+      }
+      async stepReview(wizard) {
+        this.showStepHeader("review", "Review Generated Skill");
+        const spinner3 = spinner2();
+        spinner3.start("Generating skill...");
+        const result = await wizard.generateSkill();
+        if (!result.success) {
+          spinner3.stop("Generation failed");
+          error(result.error || "Failed to generate skill");
+          return false;
+        }
+        spinner3.stop("Skill generated");
+        const state = wizard.getState();
+        const skill = state.generatedSkill;
+        const trustScore = state.trustScore;
+        const compatibility = state.compatibilityMatrix;
+        note2(
+          `Name: ${colors.bold(skill.name)}
+Description: ${skill.description}
+Tags: ${skill.tags.join(", ")}
+Confidence: ${Math.round(skill.confidence * 100)}%
+Tokens: ~${skill.estimatedTokens}`,
+          "Generated Skill"
+        );
+        const trustBar = progressBar(trustScore.score, 10, 10);
+        const trustColor = getTrustGradeColor(trustScore.grade);
+        note2(
+          `Score: ${trustColor(`${trustScore.score.toFixed(1)}/10`)} ${colors.dim(trustBar)}
+Grade: ${trustColor(trustScore.grade.toUpperCase())}
+${trustScore.warnings.length > 0 ? `
+Warnings:
+${trustScore.warnings.map((w) => `  ${colors.warning(symbols.warning)} ${w}`).join("\n")}` : ""}`,
+          "Trust Score"
+        );
+        const topAgents = Object.entries(compatibility).sort(([, a], [, b]) => b.score - a.score).slice(0, 5);
+        const compatLines = topAgents.map(([agentId, score]) => {
+          const bar = progressBar(score.score, 10, 10);
+          const color = getCompatGradeColor(score.grade);
+          return `  ${formatAgent(agentId)}: ${color(`${score.score.toFixed(1)}/10`)} ${colors.dim(bar)}`;
+        });
+        note2(compatLines.join("\n"), "Agent Compatibility");
+        const action = await select2({
+          message: "What would you like to do?",
+          options: [
+            { value: "approve", label: "Approve and continue", hint: "Install to agents" },
+            { value: "view", label: "View full content" },
+            { value: "regenerate", label: "Regenerate", hint: "Try again with same inputs" }
+          ]
+        });
+        if (isCancel2(action)) {
+          cancel2("Operation cancelled");
+          return false;
+        }
+        if (action === "view") {
+          console.log("\n" + colors.dim("\u2500".repeat(60)));
+          console.log(skill.content);
+          console.log(colors.dim("\u2500".repeat(60)) + "\n");
+          const afterView = await select2({
+            message: "Continue?",
+            options: [
+              { value: "approve", label: "Approve and install" },
+              { value: "regenerate", label: "Regenerate" }
+            ]
+          });
+          if (isCancel2(afterView)) {
+            cancel2("Operation cancelled");
+            return false;
+          }
+          if (afterView === "regenerate") {
+            return this.stepReview(wizard);
+          }
+        }
+        if (action === "regenerate") {
+          return this.stepReview(wizard);
+        }
+        const approveResult = await wizard.approveSkill();
+        return approveResult.success;
+      }
+      async stepInstall(wizard) {
+        this.showStepHeader("install", "Install to Agents");
+        const state = wizard.getState();
+        let targetAgents;
+        if (this.agents) {
+          targetAgents = this.agents.split(",").map((a) => a.trim());
+        } else {
+          const agentOptions = [
+            "claude-code",
+            "cursor",
+            "codex",
+            "gemini-cli",
+            "opencode",
+            "github-copilot",
+            "windsurf",
+            "cline",
+            "roo",
+            "universal"
+          ];
+          const selected = await agentMultiselect({
+            message: "Select target agents",
+            agents: agentOptions,
+            initialValues: ["claude-code"],
+            required: true
+          });
+          if (isCancel2(selected)) {
+            cancel2("Operation cancelled");
+            return false;
+          }
+          targetAgents = selected;
+        }
+        const spinner3 = spinner2();
+        spinner3.start("Installing with agent-specific optimizations...");
+        const result = await wizard.installToAgents(targetAgents);
+        if (!result.success) {
+          spinner3.stop("Installation failed");
+          error(result.error || "Failed to install skill");
+          return false;
+        }
+        spinner3.stop("Installation complete");
+        const installState = wizard.getState();
+        const successCount = installState.installResults.filter((r) => r.success).length;
+        const resultLines = installState.installResults.map((r) => {
+          const icon = r.success ? colors.success(symbols.success) : colors.error(symbols.error);
+          const agent = formatAgent(r.agentId);
+          const changes = r.changes.length > 0 ? colors.dim(` (${r.changes.join(", ")})`) : "";
+          return `  ${icon} ${agent}${changes}`;
+        });
+        note2(resultLines.join("\n"), `Installed to ${successCount} agents`);
+        if (this.output) {
+          const outputDir = resolve16(this.output);
+          if (!existsSync17(outputDir)) {
+            mkdirSync8(outputDir, { recursive: true });
+          }
+          const skillPath = resolve16(outputDir, "SKILL.md");
+          writeFileSync8(skillPath, state.generatedSkill.content, "utf-8");
+          success(`Saved to: ${skillPath}`);
+        }
+        return true;
+      }
+      showStepHeader(step2, title) {
+        const stepOrder = ["expertise", "context-sources", "composition", "clarification", "review", "install"];
+        const current = stepOrder.indexOf(step2) + 1;
+        const total = stepOrder.length;
+        console.log();
+        log2(`${colors.dim(`Step ${current}/${total}:`)} ${colors.bold(title)}`);
+      }
+    };
+  }
+});
+
 // src/commands/list.ts
 init_helpers();
 init_onboarding();
@@ -5384,7 +5907,10 @@ import {
   initializeMemoryDirectory,
   getMemoryStatus,
   createMemoryCompressor,
-  createMemoryInjector
+  createMemoryInjector,
+  createClaudeMdUpdater,
+  syncGlobalClaudeMd,
+  createProgressiveDisclosureManager
 } from "@skillkit/core";
 var MemoryCommand = class extends Command26 {
   static paths = [["memory"], ["mem"]];
@@ -5395,17 +5921,19 @@ var MemoryCommand = class extends Command26 {
       captured from coding sessions across all AI agents.
 
       Subcommands:
-      - status:   Show current memory status
-      - search:   Search memories by query
-      - list:     List all learnings
-      - show:     Show a specific learning
-      - compress: Compress observations into learnings
-      - export:   Export a learning as a skill
-      - import:   Import memories from another project
-      - clear:    Clear session observations
-      - add:      Manually add a learning
-      - rate:     Rate a learning's effectiveness
-      - config:   Configure memory settings
+      - status:      Show current memory status
+      - search:      Search memories by query
+      - list:        List all learnings
+      - show:        Show a specific learning
+      - compress:    Compress observations into learnings
+      - export:      Export a learning as a skill
+      - import:      Import memories from another project
+      - clear:       Clear session observations
+      - add:         Manually add a learning
+      - rate:        Rate a learning's effectiveness
+      - sync-claude: Sync learnings to CLAUDE.md
+      - index:       Show memory index (progressive disclosure)
+      - config:      Configure memory settings
     `,
     examples: [
       ["Show memory status", "$0 memory status"],
@@ -5418,7 +5946,9 @@ var MemoryCommand = class extends Command26 {
       ["Export as skill", "$0 memory export <id> --name my-skill"],
       ["Clear session", "$0 memory clear"],
       ["Add manual learning", '$0 memory add --title "..." --content "..."'],
-      ["Rate effectiveness", "$0 memory rate <id> 85"]
+      ["Rate effectiveness", "$0 memory rate <id> 85"],
+      ["Sync to CLAUDE.md", "$0 memory sync-claude"],
+      ["Show memory index", "$0 memory index"]
     ]
   });
   // Subcommand (status, search, list, show, compress, export, import, clear, add, rate, config)
@@ -5500,9 +6030,13 @@ var MemoryCommand = class extends Command26 {
         return this.rateLearning();
       case "config":
         return this.showConfig();
+      case "sync-claude":
+        return this.syncClaudeMd();
+      case "index":
+        return this.showIndex();
       default:
         console.error(chalk18.red(`Unknown action: ${action}`));
-        console.log(chalk18.gray("Available actions: status, search, list, show, compress, export, import, clear, add, rate, config"));
+        console.log(chalk18.gray("Available actions: status, search, list, show, compress, export, import, clear, add, rate, sync-claude, index, config"));
         return 1;
     }
   }
@@ -5790,12 +6324,12 @@ ${learning.title}
     }
     const outputPath = this.output || `.skillkit/exports/${skillName}/SKILL.md`;
     const { dirname: dirname7 } = await import("path");
-    const { existsSync: existsSync23, mkdirSync: mkdirSync11, writeFileSync: writeFileSync12 } = await import("fs");
+    const { existsSync: existsSync24, mkdirSync: mkdirSync12, writeFileSync: writeFileSync13 } = await import("fs");
     const outputDir = dirname7(outputPath);
-    if (!existsSync23(outputDir)) {
-      mkdirSync11(outputDir, { recursive: true });
+    if (!existsSync24(outputDir)) {
+      mkdirSync12(outputDir, { recursive: true });
     }
-    writeFileSync12(outputPath, skillContent, "utf-8");
+    writeFileSync13(outputPath, skillContent, "utf-8");
     console.log(chalk18.green(`\u2713 Exported learning as skill: ${skillName}`));
     console.log(chalk18.gray(`  Path: ${outputPath}`));
     return 0;
@@ -5810,10 +6344,10 @@ ${learning.title}
       console.log(chalk18.gray("Usage: skillkit memory import --input <path>"));
       return 1;
     }
-    const { existsSync: existsSync23, readFileSync: readFileSync12 } = await import("fs");
-    const { resolve: resolve23 } = await import("path");
-    const fullPath = resolve23(inputPath);
-    if (!existsSync23(fullPath)) {
+    const { existsSync: existsSync24, readFileSync: readFileSync12 } = await import("fs");
+    const { resolve: resolve24 } = await import("path");
+    const fullPath = resolve24(inputPath);
+    if (!existsSync24(fullPath)) {
       console.error(chalk18.red(`File not found: ${fullPath}`));
       return 1;
     }
@@ -5981,6 +6515,117 @@ ${learning.title}
     console.log();
     return 0;
   }
+  /**
+   * Sync learnings to CLAUDE.md
+   */
+  async syncClaudeMd() {
+    const projectPath = process.cwd();
+    if (this.global) {
+      if (this.dryRun) {
+        console.log(chalk18.gray("(Dry run - previewing global CLAUDE.md sync)\n"));
+      }
+      const result2 = this.dryRun ? { updated: false, path: "~/.claude/CLAUDE.md", learningsAdded: 0, learningSummaries: [], previousLearnings: 0 } : syncGlobalClaudeMd({ minEffectiveness: 60 });
+      if (this.dryRun) {
+        const globalStore = new LearningStore("global");
+        const learnings = globalStore.getAll().filter((l) => (l.effectiveness ?? 0) >= 60 || l.useCount >= 3).slice(0, 20);
+        console.log(chalk18.cyan(`Would add ${learnings.length} learnings to global CLAUDE.md`));
+        for (const l of learnings.slice(0, 5)) {
+          console.log(`  ${chalk18.gray("\u25CF")} ${l.title}`);
+        }
+        if (learnings.length > 5) {
+          console.log(chalk18.gray(`  ... and ${learnings.length - 5} more`));
+        }
+        return 0;
+      }
+      if (result2.updated) {
+        console.log(chalk18.green(`\u2713 Updated global CLAUDE.md with ${result2.learningsAdded} learnings`));
+        console.log(chalk18.gray(`  Path: ${result2.path}`));
+      } else {
+        console.log(chalk18.yellow("No learnings to sync to global CLAUDE.md"));
+      }
+      return 0;
+    }
+    const updater = createClaudeMdUpdater(projectPath);
+    if (this.dryRun) {
+      const preview = updater.preview({ minEffectiveness: 60 });
+      console.log(chalk18.gray("(Dry run preview)\n"));
+      if (!preview.wouldUpdate) {
+        console.log(chalk18.yellow("No learnings to sync to CLAUDE.md"));
+        return 0;
+      }
+      console.log(chalk18.cyan(`Would add ${preview.learnings.length} learnings to CLAUDE.md
+`));
+      for (const learning of preview.learnings.slice(0, 5)) {
+        console.log(`  ${chalk18.gray("\u25CF")} ${learning.title}`);
+      }
+      if (preview.learnings.length > 5) {
+        console.log(chalk18.gray(`  ... and ${preview.learnings.length - 5} more`));
+      }
+      console.log(chalk18.bold("\nFormatted section preview:"));
+      console.log(chalk18.gray("\u2500".repeat(50)));
+      console.log(preview.formattedSection.slice(0, 500));
+      if (preview.formattedSection.length > 500) {
+        console.log(chalk18.gray("..."));
+      }
+      return 0;
+    }
+    const result = updater.update({ minEffectiveness: 60 });
+    if (result.updated) {
+      console.log(chalk18.green(`\u2713 Updated CLAUDE.md with ${result.learningsAdded} learnings`));
+      console.log(chalk18.gray(`  Path: ${result.path}`));
+      if (this.verbose && result.learningSummaries.length > 0) {
+        console.log(chalk18.cyan("\nLearnings added:"));
+        for (const title of result.learningSummaries.slice(0, 10)) {
+          console.log(`  ${chalk18.gray("\u25CF")} ${title}`);
+        }
+      }
+    } else {
+      console.log(chalk18.yellow("No learnings to sync to CLAUDE.md"));
+    }
+    return 0;
+  }
+  /**
+   * Show memory index (progressive disclosure Layer 1)
+   */
+  async showIndex() {
+    const projectPath = process.cwd();
+    const manager = createProgressiveDisclosureManager(projectPath);
+    let maxResults = 50;
+    if (this.limit) {
+      const parsed = parseInt(this.limit, 10);
+      if (isNaN(parsed) || parsed <= 0) {
+        console.log(chalk18.red("Invalid --limit value. Must be a positive number."));
+        return 1;
+      }
+      maxResults = parsed;
+    }
+    const index = manager.getIndex({ includeGlobal: this.global, maxResults });
+    if (this.json) {
+      console.log(JSON.stringify(index, null, 2));
+      return 0;
+    }
+    console.log(chalk18.bold(`
+Memory Index (${index.length} entries)
+`));
+    if (index.length === 0) {
+      console.log(chalk18.gray("No learnings found."));
+      return 0;
+    }
+    const displayLimit = this.limit ? parseInt(this.limit, 10) : 20;
+    const displayed = index.slice(0, displayLimit);
+    for (const entry of displayed) {
+      const effectiveness = entry.effectiveness !== void 0 ? ` [${this.formatScore(entry.effectiveness)}%]` : "";
+      const scope = entry.scope === "global" ? chalk18.magenta("[G]") : chalk18.blue("[P]");
+      console.log(`${scope} ${chalk18.gray(entry.id.slice(0, 8))} ${entry.title}${chalk18.green(effectiveness)}`);
+      console.log(`   Tags: ${entry.tags.join(", ")} | Uses: ${entry.useCount}`);
+    }
+    if (index.length > displayLimit) {
+      console.log(chalk18.gray(`
+... and ${index.length - displayLimit} more (use --limit to show more)`));
+    }
+    console.log(chalk18.gray('\nUse "skillkit memory show <id>" to view full details'));
+    return 0;
+  }
   /**
    * Format relevance/effectiveness score with color
    */
@@ -6892,14 +7537,14 @@ var TeamCommand = class extends Command29 {
     }
     const projectPath = process.cwd();
     const bundlePath = join12(projectPath, ".skillkit", "bundles", `${this.name}.json`);
-    const { existsSync: existsSync23, readFileSync: readFileSync12, writeFileSync: writeFileSync12 } = await import("fs");
-    if (!existsSync23(bundlePath)) {
+    const { existsSync: existsSync24, readFileSync: readFileSync12, writeFileSync: writeFileSync13 } = await import("fs");
+    if (!existsSync24(bundlePath)) {
       this.context.stderr.write(chalk21.red(`Bundle "${this.name}" not found. Create it first with bundle-create.
 `));
       return 1;
     }
     const content = readFileSync12(bundlePath, "utf-8");
-    writeFileSync12(this.output, content, "utf-8");
+    writeFileSync13(this.output, content, "utf-8");
     this.context.stdout.write(chalk21.green(`\u2713 Bundle exported to: ${this.output}
 `));
     return 0;
@@ -6909,8 +7554,8 @@ var TeamCommand = class extends Command29 {
       this.context.stderr.write(chalk21.red("--source <path> is required for bundle-import\n"));
       return 1;
     }
-    const { existsSync: existsSync23 } = await import("fs");
-    if (!existsSync23(this.source)) {
+    const { existsSync: existsSync24 } = await import("fs");
+    if (!existsSync24(this.source)) {
       this.context.stderr.write(chalk21.red(`Bundle file not found: ${this.source}
 `));
       return 1;
@@ -8874,18 +9519,20 @@ Saved to: ${configPath}
 };
 
 // src/commands/ai.ts
-import { Command as Command35, Option as Option34 } from "clipanion";
-import { resolve as resolve16 } from "path";
+import { Command as Command36, Option as Option35 } from "clipanion";
+import { resolve as resolve17 } from "path";
 import { promises as fs2 } from "fs";
 import chalk25 from "chalk";
 import ora4 from "ora";
 import {
   AIManager,
-  loadIndex as loadIndexFromCache2
+  loadIndex as loadIndexFromCache2,
+  detectProviders as detectProviders2,
+  getDefaultProvider
 } from "@skillkit/core";
-var AICommand = class extends Command35 {
+var AICommand = class extends Command36 {
   static paths = [["ai"]];
-  static usage = Command35.Usage({
+  static usage = Command36.Usage({
     description: "AI-powered skill search and generation",
     details: `
       The ai command provides AI-powered features for skills:
@@ -8905,37 +9552,37 @@ var AICommand = class extends Command35 {
     ]
   });
   // Subcommand
-  subcommand = Option34.String({ required: true });
+  subcommand = Option35.String({ required: true });
   // Search options
-  query = Option34.String("--query,-q", {
+  query = Option35.String("--query,-q", {
     description: "Search query for natural language search"
   });
   // Generation options
-  description = Option34.String("--description,-d", {
+  description = Option35.String("--description,-d", {
     description: "Description of the skill to generate"
   });
-  fromCode = Option34.String("--from-code", {
+  fromCode = Option35.String("--from-code", {
     description: "Generate skill from code example file"
   });
-  additionalContext = Option34.String("--context", {
+  additionalContext = Option35.String("--context", {
     description: "Additional context for generation"
   });
-  targetAgent = Option34.String("--agent,-a", {
+  targetAgent = Option35.String("--agent,-a", {
     description: "Target agent for generated skill"
   });
   // Similar skills option
-  skillName = Option34.String({ required: false });
+  skillName = Option35.String({ required: false });
   // Common options
-  limit = Option34.String("--limit,-l", {
+  limit = Option35.String("--limit,-l", {
     description: "Maximum number of results"
   });
-  minRelevance = Option34.String("--min-relevance", {
+  minRelevance = Option35.String("--min-relevance", {
     description: "Minimum relevance score (0-1)"
   });
-  json = Option34.Boolean("--json,-j", false, {
+  json = Option35.Boolean("--json,-j", false, {
     description: "Output in JSON format"
   });
-  output = Option34.String("--output,-o", {
+  output = Option35.String("--output,-o", {
     description: "Output file for generated skill"
   });
   async execute() {
@@ -8959,12 +9606,16 @@ var AICommand = class extends Command35 {
         return await this.handleGenerate(manager);
       case "similar":
         return await this.handleSimilar(manager);
+      case "wizard":
+        return await this.handleWizard();
+      case "providers":
+        return this.handleProviders();
       default:
         console.error(
           chalk25.red(`Unknown subcommand: ${this.subcommand}
 `)
         );
-        console.log("Valid subcommands: search, generate, similar");
+        console.log("Valid subcommands: search, generate, similar, wizard, providers");
         return 1;
     }
   }
@@ -9031,7 +9682,7 @@ AI Search Results (${results.length} found):
     }
     let codeExamples = [];
     if (this.fromCode) {
-      const codePath = resolve16(this.fromCode);
+      const codePath = resolve17(this.fromCode);
       try {
         const code = await fs2.readFile(codePath, "utf-8");
         codeExamples = [code];
@@ -9083,7 +9734,7 @@ AI Search Results (${results.length} found):
       console.log(generated.content);
       console.log(chalk25.dim("\u2500".repeat(60)));
       if (this.output) {
-        const outputPath = resolve16(this.output);
+        const outputPath = resolve17(this.output);
         await fs2.writeFile(outputPath, generated.content, "utf-8");
         console.log(chalk25.green(`
 \u2713 Saved to: ${outputPath}`));
@@ -9180,28 +9831,63 @@ Skills similar to "${skillName}" (${results.length} found):
       source: s.source
     }));
   }
+  async handleWizard() {
+    console.log(chalk25.cyan("\nLaunching Smart Generate Wizard...\n"));
+    console.log(chalk25.dim("For the full wizard experience, use: skillkit generate\n"));
+    const { GenerateCommand: GenerateCommand2 } = await Promise.resolve().then(() => (init_generate(), generate_exports));
+    const generateCmd = new GenerateCommand2();
+    return generateCmd.execute();
+  }
+  handleProviders() {
+    const detected = detectProviders2();
+    const defaultProvider = getDefaultProvider();
+    console.log(chalk25.cyan("\nAvailable LLM Providers:\n"));
+    for (const provider of detected) {
+      const isDefault = provider.provider === defaultProvider;
+      const status = provider.configured ? chalk25.green("\u2713 Configured") : chalk25.dim("\u25CB Not configured");
+      const defaultBadge = isDefault ? chalk25.yellow(" (default)") : "";
+      console.log(`  ${provider.displayName}${defaultBadge}`);
+      console.log(`    ${status}`);
+      if (provider.envVar) {
+        console.log(`    ${chalk25.dim(`Set ${provider.envVar} to configure`)}`);
+      }
+      console.log();
+    }
+    if (defaultProvider === "mock") {
+      console.log(`  Mock Provider${chalk25.yellow(" (default)")}`);
+      console.log(`    ${chalk25.green("\u2713 Always available")}`);
+      console.log(`    ${chalk25.dim("Basic functionality without API keys")}`);
+      console.log();
+    }
+    console.log(chalk25.dim('Use "skillkit generate --provider <name>" to use a specific provider\n'));
+    return 0;
+  }
   getAIConfig() {
-    const apiKey = process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY;
+    const provider = process.env.ANTHROPIC_API_KEY ? "anthropic" : process.env.OPENAI_API_KEY ? "openai" : process.env.GOOGLE_AI_KEY || process.env.GEMINI_API_KEY ? "google" : process.env.OPENROUTER_API_KEY ? "openrouter" : process.env.OLLAMA_HOST ? "ollama" : "none";
+    const apiKey = provider === "anthropic" ? process.env.ANTHROPIC_API_KEY : provider === "openai" ? process.env.OPENAI_API_KEY : provider === "google" ? process.env.GOOGLE_AI_KEY || process.env.GEMINI_API_KEY : provider === "openrouter" ? process.env.OPENROUTER_API_KEY : void 0;
     return {
-      provider: process.env.ANTHROPIC_API_KEY ? "anthropic" : process.env.OPENAI_API_KEY ? "openai" : "none",
+      provider,
       apiKey,
-      model: process.env.ANTHROPIC_API_KEY ? "claude-3-sonnet-20240229" : void 0,
+      model: provider === "anthropic" ? "claude-sonnet-4-20250514" : void 0,
       maxTokens: 4096,
       temperature: 0.7
     };
   }
 };
 
+// src/commands/index.ts
+init_generate();
+
 // src/commands/audit.ts
-import { Command as Command36, Option as Option35 } from "clipanion";
-import { resolve as resolve17 } from "path";
+import { Command as Command37, Option as Option36 } from "clipanion";
+import { resolve as resolve18 } from "path";
 import { promises as fs3 } from "fs";
 import path2 from "path";
 import chalk26 from "chalk";
 import { AuditLogger } from "@skillkit/core";
-var AuditCommand = class extends Command36 {
+var AuditCommand = class extends Command37 {
   static paths = [["audit"]];
-  static usage = Command36.Usage({
+  static usage = Command37.Usage({
     description: "View and manage audit logs",
     details: `
       The audit command provides access to the audit log system.
@@ -9221,52 +9907,52 @@ var AuditCommand = class extends Command36 {
       ["Clear logs older than 30 days", "$0 audit clear --days 30"]
     ]
   });
-  subcommand = Option35.String({ required: true });
+  subcommand = Option36.String({ required: true });
   // Query options
-  type = Option35.Array("--type,-t", {
+  type = Option36.Array("--type,-t", {
     description: "Filter by event type"
   });
-  user = Option35.String("--user,-u", {
+  user = Option36.String("--user,-u", {
     description: "Filter by user"
   });
-  resource = Option35.String("--resource,-r", {
+  resource = Option36.String("--resource,-r", {
     description: "Filter by resource"
   });
-  success = Option35.Boolean("--success", {
+  success = Option36.Boolean("--success", {
     description: "Show only successful operations"
   });
-  failed = Option35.Boolean("--failed", {
+  failed = Option36.Boolean("--failed", {
     description: "Show only failed operations"
   });
-  since = Option35.String("--since", {
+  since = Option36.String("--since", {
     description: "Show events since date (ISO 8601)"
   });
-  until = Option35.String("--until", {
+  until = Option36.String("--until", {
     description: "Show events until date (ISO 8601)"
   });
-  limit = Option35.String("--limit,-l", {
+  limit = Option36.String("--limit,-l", {
     description: "Maximum number of entries"
   });
   // Export options
-  format = Option35.String("--format,-f", {
+  format = Option36.String("--format,-f", {
     description: "Export format (json, csv, text)"
   });
-  output = Option35.String("--output,-o", {
+  output = Option36.String("--output,-o", {
     description: "Output file path"
   });
   // Clear options
-  days = Option35.String("--days", {
+  days = Option36.String("--days", {
     description: "Clear entries older than N days"
   });
   // Common options
-  json = Option35.Boolean("--json,-j", false, {
+  json = Option36.Boolean("--json,-j", false, {
     description: "Output in JSON format"
   });
-  projectPath = Option35.String("--path,-p", {
+  projectPath = Option36.String("--path,-p", {
     description: "Project path (default: current directory)"
   });
   async execute() {
-    const targetPath = resolve17(this.projectPath || process.cwd());
+    const targetPath = resolve18(this.projectPath || process.cwd());
     const logDir = path2.join(targetPath, ".skillkit");
     const logger = new AuditLogger(logDir);
     try {
@@ -9334,7 +10020,7 @@ Audit Log (${events.length} entries):
     const query = this.buildQuery();
     const content = await logger.export({ format, query });
     if (this.output) {
-      const outputPath = resolve17(this.output);
+      const outputPath = resolve18(this.output);
       await fs3.writeFile(outputPath, content, "utf-8");
       console.log(chalk26.green(`\u2713 Exported audit log to: ${outputPath}`));
     } else {
@@ -9432,10 +10118,10 @@ Recent Errors (${stats.recentErrors.length}):`));
 };
 
 // src/commands/publish.ts
-import { existsSync as existsSync17, readFileSync as readFileSync9, mkdirSync as mkdirSync8, writeFileSync as writeFileSync8, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
-import { join as join16, basename as basename4, dirname as dirname6, resolve as resolve18 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync9, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import { join as join16, basename as basename4, dirname as dirname6, resolve as resolve19 } from "path";
 import chalk27 from "chalk";
-import { Command as Command37, Option as Option36 } from "clipanion";
+import { Command as Command38, Option as Option37 } from "clipanion";
 import { generateWellKnownIndex } from "@skillkit/core";
 function sanitizeSkillName(name) {
   if (!name || typeof name !== "string") return null;
@@ -9448,9 +10134,9 @@ function sanitizeSkillName(name) {
   }
   return name;
 }
-var PublishCommand = class extends Command37 {
+var PublishCommand = class extends Command38 {
   static paths = [["publish"]];
-  static usage = Command37.Usage({
+  static usage = Command38.Usage({
     description: "Generate well-known skills structure for hosting",
     details: `
       This command generates the RFC 8615 well-known URI structure for hosting skills.
@@ -9468,11 +10154,11 @@ var PublishCommand = class extends Command37 {
       ["Preview without writing", "$0 publish --dry-run"]
     ]
   });
-  skillPath = Option36.String({ required: false, name: "path" });
-  output = Option36.String("--output,-o", {
+  skillPath = Option37.String({ required: false, name: "path" });
+  output = Option37.String("--output,-o", {
     description: "Output directory for well-known structure (default: current directory)"
   });
-  dryRun = Option36.Boolean("--dry-run,-n", false, {
+  dryRun = Option37.Boolean("--dry-run,-n", false, {
     description: "Show what would be generated without writing files"
   });
   async execute() {
@@ -9526,27 +10212,27 @@ var PublishCommand = class extends Command37 {
       return 0;
     }
     const wellKnownDir = join16(outputDir, ".well-known", "skills");
-    mkdirSync8(wellKnownDir, { recursive: true });
+    mkdirSync9(wellKnownDir, { recursive: true });
     for (const skill of validSkills) {
       const skillDir = join16(wellKnownDir, skill.safeName);
-      const resolvedSkillDir = resolve18(skillDir);
-      const resolvedWellKnownDir = resolve18(wellKnownDir);
+      const resolvedSkillDir = resolve19(skillDir);
+      const resolvedWellKnownDir = resolve19(wellKnownDir);
       if (!resolvedSkillDir.startsWith(resolvedWellKnownDir)) {
         console.log(chalk27.yellow(`  Skipping "${skill.name}" (path traversal detected)`));
         continue;
       }
-      mkdirSync8(skillDir, { recursive: true });
+      mkdirSync9(skillDir, { recursive: true });
       const files = this.getSkillFiles(skill.path);
       for (const file of files) {
         const safeFile = basename4(file);
         const sourcePath = join16(skill.path, file);
         const destPath = join16(skillDir, safeFile);
         const content = readFileSync9(sourcePath, "utf-8");
-        writeFileSync8(destPath, content);
+        writeFileSync9(destPath, content);
       }
     }
     const index = generateWellKnownIndex(wellKnownSkills);
-    writeFileSync8(join16(wellKnownDir, "index.json"), JSON.stringify(index, null, 2));
+    writeFileSync9(join16(wellKnownDir, "index.json"), JSON.stringify(index, null, 2));
     console.log(chalk27.green("Generated well-known structure:\n"));
     console.log(chalk27.dim(`  ${wellKnownDir}/index.json`));
     for (const skill of wellKnownSkills) {
@@ -9562,7 +10248,7 @@ var PublishCommand = class extends Command37 {
   discoverSkills(basePath) {
     const skills = [];
     const skillMdPath = join16(basePath, "SKILL.md");
-    if (existsSync17(skillMdPath)) {
+    if (existsSync18(skillMdPath)) {
       const content = readFileSync9(skillMdPath, "utf-8");
       const frontmatter = this.parseFrontmatter(content);
       skills.push({
@@ -9578,13 +10264,13 @@ var PublishCommand = class extends Command37 {
       join16(basePath, ".claude", "skills")
     ];
     for (const searchDir of searchDirs) {
-      if (!existsSync17(searchDir)) continue;
+      if (!existsSync18(searchDir)) continue;
       const entries = readdirSync3(searchDir);
       for (const entry of entries) {
         const entryPath = join16(searchDir, entry);
         if (!statSync3(entryPath).isDirectory()) continue;
         const entrySkillMd = join16(entryPath, "SKILL.md");
-        if (existsSync17(entrySkillMd)) {
+        if (existsSync18(entrySkillMd)) {
           const content = readFileSync9(entrySkillMd, "utf-8");
           const frontmatter = this.parseFrontmatter(content);
           skills.push({
@@ -9656,20 +10342,20 @@ var PublishCommand = class extends Command37 {
     return frontmatter;
   }
 };
-var PublishSubmitCommand = class extends Command37 {
+var PublishSubmitCommand = class extends Command38 {
   static paths = [["publish", "submit"]];
-  static usage = Command37.Usage({
+  static usage = Command38.Usage({
     description: "Submit skill to SkillKit marketplace (requires review)",
     examples: [
       ["Submit skill from current directory", "$0 publish submit"],
       ["Submit with custom name", "$0 publish submit --name my-skill"]
     ]
   });
-  skillPath = Option36.String({ required: false, name: "path" });
-  name = Option36.String("--name,-n", {
+  skillPath = Option37.String({ required: false, name: "path" });
+  name = Option37.String("--name,-n", {
     description: "Custom skill name"
   });
-  dryRun = Option36.Boolean("--dry-run", false, {
+  dryRun = Option37.Boolean("--dry-run", false, {
     description: "Show what would be submitted"
   });
   async execute() {
@@ -9734,11 +10420,11 @@ var PublishSubmitCommand = class extends Command37 {
     return 0;
   }
   findSkillMd(basePath) {
-    if (basePath.endsWith("SKILL.md") && existsSync17(basePath)) {
+    if (basePath.endsWith("SKILL.md") && existsSync18(basePath)) {
       return basePath;
     }
     const direct = join16(basePath, "SKILL.md");
-    if (existsSync17(direct)) {
+    if (existsSync18(direct)) {
       return direct;
     }
     const locations = [
@@ -9746,7 +10432,7 @@ var PublishSubmitCommand = class extends Command37 {
       join16(basePath, ".claude", "skills", "SKILL.md")
     ];
     for (const loc of locations) {
-      if (existsSync17(loc)) {
+      if (existsSync18(loc)) {
         return loc;
       }
     }
@@ -9831,8 +10517,8 @@ Submitted via \`skillkit publish submit\``;
 
 // src/commands/agent.ts
 import chalk28 from "chalk";
-import { Command as Command38, Option as Option37 } from "clipanion";
-import { existsSync as existsSync18, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
+import { Command as Command39, Option as Option38 } from "clipanion";
+import { existsSync as existsSync19, mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
 import { join as join17, basename as basename5 } from "path";
 import { homedir as homedir3 } from "os";
 import {
@@ -9854,9 +10540,9 @@ import {
   installBundledAgent,
   isAgentInstalled
 } from "@skillkit/resources";
-var AgentCommand = class extends Command38 {
+var AgentCommand = class extends Command39 {
   static paths = [["agent"]];
-  static usage = Command38.Usage({
+  static usage = Command39.Usage({
     description: "Manage custom AI sub-agents",
     details: `
       This command manages custom AI sub-agents that can be used with
@@ -9897,9 +10583,9 @@ var AgentCommand = class extends Command38 {
     return 0;
   }
 };
-var AgentListCommand = class extends Command38 {
+var AgentListCommand = class extends Command39 {
   static paths = [["agent", "list"], ["agent", "ls"]];
-  static usage = Command38.Usage({
+  static usage = Command39.Usage({
     description: "List all installed agents",
     examples: [
       ["List all agents", "$0 agent list"],
@@ -9907,13 +10593,13 @@ var AgentListCommand = class extends Command38 {
       ["Show only project agents", "$0 agent list --project"]
     ]
   });
-  json = Option37.Boolean("--json,-j", false, {
+  json = Option38.Boolean("--json,-j", false, {
     description: "Output as JSON"
   });
-  project = Option37.Boolean("--project,-p", false, {
+  project = Option38.Boolean("--project,-p", false, {
     description: "Show only project agents"
   });
-  global = Option37.Boolean("--global,-g", false, {
+  global = Option38.Boolean("--global,-g", false, {
     description: "Show only global agents"
   });
   async execute() {
@@ -9971,15 +10657,15 @@ var AgentListCommand = class extends Command38 {
     return 0;
   }
 };
-var AgentShowCommand = class extends Command38 {
+var AgentShowCommand = class extends Command39 {
   static paths = [["agent", "show"], ["agent", "info"]];
-  static usage = Command38.Usage({
+  static usage = Command39.Usage({
     description: "Show details for a specific agent",
     examples: [
       ["Show agent details", "$0 agent show architect"]
     ]
   });
-  name = Option37.String({ required: true });
+  name = Option38.String({ required: true });
   async execute() {
     const searchDirs = [process.cwd()];
     const agent = findAgent(this.name, searchDirs);
@@ -10028,9 +10714,9 @@ var AgentShowCommand = class extends Command38 {
     return 0;
   }
 };
-var AgentCreateCommand = class extends Command38 {
+var AgentCreateCommand = class extends Command39 {
   static paths = [["agent", "create"], ["agent", "new"]];
-  static usage = Command38.Usage({
+  static usage = Command39.Usage({
     description: "Create a new agent",
     examples: [
       ["Create an agent", "$0 agent create security-reviewer"],
@@ -10038,14 +10724,14 @@ var AgentCreateCommand = class extends Command38 {
       ["Create globally", "$0 agent create my-agent --global"]
     ]
   });
-  name = Option37.String({ required: true });
-  model = Option37.String("--model,-m", {
+  name = Option38.String({ required: true });
+  model = Option38.String("--model,-m", {
     description: "Model to use (opus, sonnet, haiku)"
   });
-  description = Option37.String("--description,-d", {
+  description = Option38.String("--description,-d", {
     description: "Agent description"
   });
-  global = Option37.Boolean("--global,-g", false, {
+  global = Option38.Boolean("--global,-g", false, {
     description: "Create in global agents directory"
   });
   async execute() {
@@ -10061,17 +10747,17 @@ var AgentCreateCommand = class extends Command38 {
     } else {
       targetDir = join17(process.cwd(), ".claude", "agents");
     }
-    if (!existsSync18(targetDir)) {
-      mkdirSync9(targetDir, { recursive: true });
+    if (!existsSync19(targetDir)) {
+      mkdirSync10(targetDir, { recursive: true });
     }
     const agentPath = join17(targetDir, `${this.name}.md`);
-    if (existsSync18(agentPath)) {
+    if (existsSync19(agentPath)) {
       console.log(chalk28.red(`Agent already exists: ${agentPath}`));
       return 1;
     }
     const description = this.description || `${this.name} agent`;
     const content = generateAgentTemplate(this.name, description, this.model);
-    writeFileSync9(agentPath, content);
+    writeFileSync10(agentPath, content);
     console.log(chalk28.green(`Created agent: ${agentPath}`));
     console.log();
     console.log(chalk28.dim("Edit the file to customize the agent system prompt."));
@@ -10079,9 +10765,9 @@ var AgentCreateCommand = class extends Command38 {
     return 0;
   }
 };
-var AgentTranslateCommand = class extends Command38 {
+var AgentTranslateCommand = class extends Command39 {
   static paths = [["agent", "translate"]];
-  static usage = Command38.Usage({
+  static usage = Command39.Usage({
     description: "Translate agents between AI coding agent formats",
     details: `
       Translates agent definitions between different AI coding agent formats.
@@ -10098,24 +10784,24 @@ var AgentTranslateCommand = class extends Command38 {
       ["Dry run", "$0 agent translate --to cursor --dry-run"]
     ]
   });
-  name = Option37.String({ required: false });
-  to = Option37.String("--to,-t", {
+  name = Option38.String({ required: false });
+  to = Option38.String("--to,-t", {
     description: "Target AI agent (claude-code, cursor, codex, etc.)",
     required: true
   });
-  source = Option37.String("--source,-s", {
+  source = Option38.String("--source,-s", {
     description: "Source directory or file to translate from"
   });
-  output = Option37.String("--output,-o", {
+  output = Option38.String("--output,-o", {
     description: "Output directory"
   });
-  dryRun = Option37.Boolean("--dry-run,-n", false, {
+  dryRun = Option38.Boolean("--dry-run,-n", false, {
     description: "Show what would be done without writing files"
   });
-  all = Option37.Boolean("--all,-a", false, {
+  all = Option38.Boolean("--all,-a", false, {
     description: "Translate all agents"
   });
-  recursive = Option37.Boolean("--recursive,-r", false, {
+  recursive = Option38.Boolean("--recursive,-r", false, {
     description: "Recursively scan directories for agents"
   });
   async execute() {
@@ -10124,7 +10810,7 @@ var AgentTranslateCommand = class extends Command38 {
     let agents;
     if (this.source) {
       const sourcePath = this.source.startsWith("/") ? this.source : join17(process.cwd(), this.source);
-      if (!existsSync18(sourcePath)) {
+      if (!existsSync19(sourcePath)) {
         console.log(chalk28.red(`Source path not found: ${sourcePath}`));
         return 1;
       }
@@ -10179,10 +10865,10 @@ var AgentTranslateCommand = class extends Command38 {
             }
           }
         } else {
-          if (!existsSync18(outputDir)) {
-            mkdirSync9(outputDir, { recursive: true });
+          if (!existsSync19(outputDir)) {
+            mkdirSync10(outputDir, { recursive: true });
           }
-          writeFileSync9(outputPath, result.content);
+          writeFileSync10(outputPath, result.content);
           console.log(chalk28.green(`\u2713 ${agent.name} \u2192 ${outputPath}`));
         }
         successCount++;
@@ -10200,16 +10886,16 @@ var AgentTranslateCommand = class extends Command38 {
     return errorCount > 0 ? 1 : 0;
   }
 };
-var AgentSyncCommand = class extends Command38 {
+var AgentSyncCommand = class extends Command39 {
   static paths = [["agent", "sync"]];
-  static usage = Command38.Usage({
+  static usage = Command39.Usage({
     description: "Sync agents to target AI coding agent",
     examples: [
       ["Sync to Claude Code", "$0 agent sync --agent claude-code"],
       ["Sync to multiple agents", "$0 agent sync --agent claude-code,cursor"]
     ]
   });
-  agent = Option37.String("--agent,-a", {
+  agent = Option38.String("--agent,-a", {
     description: "Target AI agent(s) (comma-separated)"
   });
   async execute() {
@@ -10225,14 +10911,14 @@ var AgentSyncCommand = class extends Command38 {
     for (const targetAgent of targetAgents) {
       const outputDir = getAgentTargetDirectory(process.cwd(), targetAgent);
       console.log(chalk28.blue(`\u2192 ${targetAgent} (${outputDir})`));
-      if (!existsSync18(outputDir)) {
-        mkdirSync9(outputDir, { recursive: true });
+      if (!existsSync19(outputDir)) {
+        mkdirSync10(outputDir, { recursive: true });
       }
       for (const agent of agents) {
         const result = translateAgent(agent, targetAgent);
         if (result.success) {
           const outputPath = join17(outputDir, result.filename);
-          writeFileSync9(outputPath, result.content);
+          writeFileSync10(outputPath, result.content);
           console.log(chalk28.green(`  \u2713 ${agent.name}`));
         } else {
           console.log(chalk28.red(`  \u2717 ${agent.name}`));
@@ -10244,17 +10930,17 @@ var AgentSyncCommand = class extends Command38 {
     return 0;
   }
 };
-var AgentValidateCommand = class extends Command38 {
+var AgentValidateCommand = class extends Command39 {
   static paths = [["agent", "validate"]];
-  static usage = Command38.Usage({
+  static usage = Command39.Usage({
     description: "Validate agent definitions",
     examples: [
       ["Validate specific agent", "$0 agent validate ./my-agent.md"],
       ["Validate all agents", "$0 agent validate --all"]
     ]
   });
-  agentPath = Option37.String({ required: false });
-  all = Option37.Boolean("--all,-a", false, {
+  agentPath = Option38.String({ required: false });
+  all = Option38.Boolean("--all,-a", false, {
     description: "Validate all discovered agents"
   });
   async execute() {
@@ -10347,9 +11033,9 @@ function generateAgentTemplate(name, description, model) {
 function formatAgentName(name) {
   return name.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
 }
-var AgentInstallCommand = class extends Command38 {
+var AgentInstallCommand = class extends Command39 {
   static paths = [["agent", "install"]];
-  static usage = Command38.Usage({
+  static usage = Command39.Usage({
     description: "Install a bundled agent template",
     details: `
       Installs a bundled agent template from @skillkit/resources.
@@ -10364,14 +11050,14 @@ var AgentInstallCommand = class extends Command38 {
       ["Install all bundled agents", "$0 agent install --all"]
     ]
   });
-  name = Option37.String({ required: false });
-  global = Option37.Boolean("--global,-g", false, {
+  name = Option38.String({ required: false });
+  global = Option38.Boolean("--global,-g", false, {
     description: "Install to global agents directory"
   });
-  force = Option37.Boolean("--force,-f", false, {
+  force = Option38.Boolean("--force,-f", false, {
     description: "Overwrite if agent already exists"
   });
-  all = Option37.Boolean("--all,-a", false, {
+  all = Option38.Boolean("--all,-a", false, {
     description: "Install all bundled agents"
   });
   async execute() {
@@ -10435,9 +11121,9 @@ var AgentInstallCommand = class extends Command38 {
     return errorCount > 0 ? 1 : 0;
   }
 };
-var AgentAvailableCommand = class extends Command38 {
+var AgentAvailableCommand = class extends Command39 {
   static paths = [["agent", "available"], ["agent", "bundled"]];
-  static usage = Command38.Usage({
+  static usage = Command39.Usage({
     description: "List bundled agents available for installation",
     examples: [
       ["List available agents", "$0 agent available"],
@@ -10445,13 +11131,13 @@ var AgentAvailableCommand = class extends Command38 {
       ["Filter by category", "$0 agent available --category testing"]
     ]
   });
-  json = Option37.Boolean("--json,-j", false, {
+  json = Option38.Boolean("--json,-j", false, {
     description: "Output as JSON"
   });
-  category = Option37.String("--category,-c", {
+  category = Option38.String("--category,-c", {
     description: "Filter by category (planning, development, testing, review, documentation, security, refactoring)"
   });
-  installed = Option37.Boolean("--installed,-i", false, {
+  installed = Option38.Boolean("--installed,-i", false, {
     description: "Show only installed bundled agents"
   });
   async execute() {
@@ -10506,9 +11192,9 @@ var AgentAvailableCommand = class extends Command38 {
     return 0;
   }
 };
-var AgentFromSkillCommand = class extends Command38 {
+var AgentFromSkillCommand = class extends Command39 {
   static paths = [["agent", "from-skill"]];
-  static usage = Command38.Usage({
+  static usage = Command39.Usage({
     description: "Convert a skill into a Claude Code subagent",
     details: `
       Converts a SkillKit skill into a Claude Code native subagent format.
@@ -10525,23 +11211,23 @@ var AgentFromSkillCommand = class extends Command38 {
       ["Preview without writing", "$0 agent from-skill code-simplifier --dry-run"]
     ]
   });
-  skillName = Option37.String({ required: true });
-  inline = Option37.Boolean("--inline,-i", false, {
+  skillName = Option38.String({ required: true });
+  inline = Option38.Boolean("--inline,-i", false, {
     description: "Embed full skill content in system prompt"
   });
-  model = Option37.String("--model,-m", {
+  model = Option38.String("--model,-m", {
     description: "Model to use (sonnet, opus, haiku, inherit)"
   });
-  permission = Option37.String("--permission,-p", {
+  permission = Option38.String("--permission,-p", {
     description: "Permission mode (default, plan, auto-edit, full-auto, bypassPermissions)"
   });
-  global = Option37.Boolean("--global,-g", false, {
+  global = Option38.Boolean("--global,-g", false, {
     description: "Create in ~/.claude/agents/ instead of .claude/agents/"
   });
-  output = Option37.String("--output,-o", {
+  output = Option38.String("--output,-o", {
     description: "Custom output filename (without .md)"
   });
-  dryRun = Option37.Boolean("--dry-run,-n", false, {
+  dryRun = Option38.Boolean("--dry-run,-n", false, {
     description: "Preview without writing files"
   });
   async execute() {
@@ -10613,13 +11299,13 @@ var AgentFromSkillCommand = class extends Command38 {
       console.log(chalk28.dim("\u2500".repeat(50)));
       return 0;
     }
-    if (!existsSync18(targetDir)) {
-      mkdirSync9(targetDir, { recursive: true });
+    if (!existsSync19(targetDir)) {
+      mkdirSync10(targetDir, { recursive: true });
     }
-    if (existsSync18(outputPath)) {
+    if (existsSync19(outputPath)) {
       console.log(chalk28.yellow(`Overwriting existing file: ${outputPath}`));
     }
-    writeFileSync9(outputPath, content);
+    writeFileSync10(outputPath, content);
     console.log(chalk28.green(`Created subagent: ${outputPath}`));
     console.log();
     console.log(chalk28.dim(`Invoke with: @${skill.name}`));
@@ -10652,13 +11338,13 @@ function sanitizeFilename(input) {
 // src/commands/check.ts
 init_helpers();
 init_onboarding();
-import { existsSync as existsSync19 } from "fs";
+import { existsSync as existsSync20 } from "fs";
 import { join as join18 } from "path";
-import { Command as Command39, Option as Option38 } from "clipanion";
+import { Command as Command40, Option as Option39 } from "clipanion";
 import { findAllSkills as findAllSkills7, findSkill as findSkill5, detectProvider as detectProvider3, isLocalPath as isLocalPath3 } from "@skillkit/core";
-var CheckCommand = class extends Command39 {
+var CheckCommand = class extends Command40 {
   static paths = [["check"]];
-  static usage = Command39.Usage({
+  static usage = Command40.Usage({
     description: "Check for available skill updates (dry-run)",
     details: `
       Checks if installed skills have updates available from their sources.
@@ -10670,11 +11356,11 @@ var CheckCommand = class extends Command39 {
       ["Show detailed output", "$0 check --verbose"]
     ]
   });
-  skills = Option38.Rest();
-  verbose = Option38.Boolean("--verbose,-v", false, {
+  skills = Option39.Rest();
+  verbose = Option39.Boolean("--verbose,-v", false, {
     description: "Show detailed information"
   });
-  quiet = Option38.Boolean("--quiet,-q", false, {
+  quiet = Option39.Boolean("--quiet,-q", false, {
     description: "Minimal output"
   });
   async execute() {
@@ -10723,7 +11409,7 @@ var CheckCommand = class extends Command39 {
       try {
         if (isLocalPath3(metadata.source)) {
           const localPath = metadata.subpath ? join18(metadata.source, metadata.subpath) : metadata.source;
-          if (!existsSync19(localPath)) {
+          if (!existsSync20(localPath)) {
             results.push({
               name: skill.name,
               hasUpdate: false,
@@ -10734,7 +11420,7 @@ var CheckCommand = class extends Command39 {
           }
           const sourceSkillMd = join18(localPath, "SKILL.md");
           const installedSkillMd = join18(skill.path, "SKILL.md");
-          if (existsSync19(sourceSkillMd) && existsSync19(installedSkillMd)) {
+          if (existsSync20(sourceSkillMd) && existsSync20(installedSkillMd)) {
             const { statSync: statSync4 } = await import("fs");
             const sourceTime = statSync4(sourceSkillMd).mtime;
             const installedTime = statSync4(installedSkillMd).mtime;
@@ -10814,7 +11500,7 @@ var CheckCommand = class extends Command39 {
 
 // src/commands/find.ts
 init_onboarding();
-import { Command as Command40, Option as Option39 } from "clipanion";
+import { Command as Command41, Option as Option40 } from "clipanion";
 import { FederatedSearch, GitHubSkillRegistry, RateLimitError } from "@skillkit/core";
 
 // ../../marketplace/skills.json
@@ -136466,9 +137152,9 @@ var sources_default = {
 };
 
 // src/commands/find.ts
-var FindCommand = class extends Command40 {
+var FindCommand = class extends Command41 {
   static paths = [["find"], ["search"]];
-  static usage = Command40.Usage({
+  static usage = Command41.Usage({
     description: "Search for skills in the marketplace",
     details: `
       Quickly find and install skills from the marketplace.
@@ -136481,20 +137167,20 @@ var FindCommand = class extends Command40 {
       ["List top skills", "$0 find --top"]
     ]
   });
-  query = Option39.String({ required: false });
-  top = Option39.Boolean("--top,-t", false, {
+  query = Option40.String({ required: false });
+  top = Option40.Boolean("--top,-t", false, {
     description: "Show top/featured skills"
   });
-  limit = Option39.String("--limit,-l", "10", {
+  limit = Option40.String("--limit,-l", "10", {
     description: "Maximum results to show"
   });
-  install = Option39.Boolean("--install,-i", false, {
+  install = Option40.Boolean("--install,-i", false, {
     description: "Prompt to install after finding"
   });
-  quiet = Option39.Boolean("--quiet,-q", false, {
+  quiet = Option40.Boolean("--quiet,-q", false, {
     description: "Minimal output (just list skills)"
   });
-  federated = Option39.Boolean("--federated,-f", false, {
+  federated = Option40.Boolean("--federated,-f", false, {
     description: "Search external registries (GitHub SKILL.md files)"
   });
   async execute() {
@@ -136623,7 +137309,7 @@ var FindCommand = class extends Command40 {
 // src/commands/manifest.ts
 init_helpers();
 init_onboarding();
-import { Command as Command41, Option as Option40 } from "clipanion";
+import { Command as Command42, Option as Option41 } from "clipanion";
 import {
   loadManifest,
   saveManifest,
@@ -136634,9 +137320,9 @@ import {
   generateManifestFromInstalled,
   findAllSkills as findAllSkills8
 } from "@skillkit/core";
-var ManifestCommand = class extends Command41 {
+var ManifestCommand = class extends Command42 {
   static paths = [["manifest"]];
-  static usage = Command41.Usage({
+  static usage = Command42.Usage({
     description: "Manage .skills manifest file",
     details: `
       The .skills manifest file allows declarative skill management.
@@ -136701,12 +137387,12 @@ var ManifestCommand = class extends Command41 {
     return 0;
   }
 };
-var ManifestInitCommand = class extends Command41 {
+var ManifestInitCommand = class extends Command42 {
   static paths = [["manifest", "init"]];
-  static usage = Command41.Usage({
+  static usage = Command42.Usage({
     description: "Initialize a new .skills manifest"
   });
-  force = Option40.Boolean("--force,-f", false, {
+  force = Option41.Boolean("--force,-f", false, {
     description: "Overwrite existing manifest"
   });
   async execute() {
@@ -136724,16 +137410,16 @@ var ManifestInitCommand = class extends Command41 {
     return 0;
   }
 };
-var ManifestAddCommand = class extends Command41 {
+var ManifestAddCommand = class extends Command42 {
   static paths = [["manifest", "add"]];
-  static usage = Command41.Usage({
+  static usage = Command42.Usage({
     description: "Add a skill source to the manifest"
   });
-  source = Option40.String({ required: true });
-  skills = Option40.String("--skills,-s", {
+  source = Option41.String({ required: true });
+  skills = Option41.String("--skills,-s", {
     description: "Specific skills to include (comma-separated)"
   });
-  agents = Option40.String("--agents,-a", {
+  agents = Option41.String("--agents,-a", {
     description: "Target agents (comma-separated)"
   });
   async execute() {
@@ -136749,12 +137435,12 @@ var ManifestAddCommand = class extends Command41 {
     return 0;
   }
 };
-var ManifestRemoveCommand = class extends Command41 {
+var ManifestRemoveCommand = class extends Command42 {
   static paths = [["manifest", "remove"]];
-  static usage = Command41.Usage({
+  static usage = Command42.Usage({
     description: "Remove a skill source from the manifest"
   });
-  source = Option40.String({ required: true });
+  source = Option41.String({ required: true });
   async execute() {
     const result = removeFromManifest(this.source);
     if (!result) {
@@ -136765,12 +137451,12 @@ var ManifestRemoveCommand = class extends Command41 {
     return 0;
   }
 };
-var ManifestInstallCommand = class extends Command41 {
+var ManifestInstallCommand = class extends Command42 {
   static paths = [["manifest", "install"]];
-  static usage = Command41.Usage({
+  static usage = Command42.Usage({
     description: "Install all skills defined in the manifest"
   });
-  yes = Option40.Boolean("--yes,-y", false, {
+  yes = Option41.Boolean("--yes,-y", false, {
     description: "Skip confirmation"
   });
   async execute() {
@@ -136832,12 +137518,12 @@ var ManifestInstallCommand = class extends Command41 {
     return 0;
   }
 };
-var ManifestGenerateCommand = class extends Command41 {
+var ManifestGenerateCommand = class extends Command42 {
   static paths = [["manifest", "generate"]];
-  static usage = Command41.Usage({
+  static usage = Command42.Usage({
     description: "Generate manifest from currently installed skills"
   });
-  output = Option40.String("--output,-o", {
+  output = Option41.String("--output,-o", {
     description: "Output file path (default: .skills)"
   });
   async execute() {
@@ -136866,8 +137552,8 @@ var ManifestGenerateCommand = class extends Command41 {
 };
 
 // src/commands/primer.ts
-import { Command as Command42, Option as Option41 } from "clipanion";
-import { resolve as resolve19 } from "path";
+import { Command as Command43, Option as Option42 } from "clipanion";
+import { resolve as resolve20 } from "path";
 import chalk29 from "chalk";
 import {
   AgentType as AgentTypeSchema,
@@ -136877,9 +137563,9 @@ import {
   addPattern,
   AGENT_CONFIG
 } from "@skillkit/core";
-var PrimerCommand = class extends Command42 {
+var PrimerCommand = class extends Command43 {
   static paths = [["primer"]];
-  static usage = Command42.Usage({
+  static usage = Command43.Usage({
     description: "Analyze codebase and generate AI instruction files for agents",
     details: `
       The primer command analyzes your codebase to detect languages, frameworks,
@@ -136901,41 +137587,41 @@ var PrimerCommand = class extends Command42 {
       ["Verbose output", "$0 primer --verbose"]
     ]
   });
-  agent = Option41.String("--agent,-a", {
+  agent = Option42.String("--agent,-a", {
     description: "Comma-separated list of agents to generate for"
   });
-  allAgents = Option41.Boolean("--all-agents,-A", false, {
+  allAgents = Option42.Boolean("--all-agents,-A", false, {
     description: "Generate for all 32 supported agents"
   });
-  output = Option41.String("--output,-o", {
+  output = Option42.String("--output,-o", {
     description: "Output directory for generated files"
   });
-  dryRun = Option41.Boolean("--dry-run,-n", false, {
+  dryRun = Option42.Boolean("--dry-run,-n", false, {
     description: "Preview what would be generated without writing files"
   });
-  analyzeOnly = Option41.Boolean("--analyze-only", false, {
+  analyzeOnly = Option42.Boolean("--analyze-only", false, {
     description: "Only show codebase analysis, do not generate files"
   });
-  verbose = Option41.Boolean("--verbose,-v", false, {
+  verbose = Option42.Boolean("--verbose,-v", false, {
     description: "Show detailed output"
   });
-  includeExamples = Option41.Boolean("--examples", false, {
+  includeExamples = Option42.Boolean("--examples", false, {
     description: "Include code examples in generated instructions"
   });
-  json = Option41.Boolean("--json,-j", false, {
+  json = Option42.Boolean("--json,-j", false, {
     description: "Output analysis in JSON format"
   });
-  directory = Option41.String("--dir,-d", {
+  directory = Option42.String("--dir,-d", {
     description: "Project directory to analyze (default: current directory)"
   });
-  learn = Option41.Boolean("--learn,-l", false, {
+  learn = Option42.Boolean("--learn,-l", false, {
     description: "Extract learnable patterns from git history"
   });
-  commits = Option41.String("--commits", {
+  commits = Option42.String("--commits", {
     description: "Number of commits to analyze for learning (default: 100)"
   });
   async execute() {
-    const projectPath = resolve19(this.directory || process.cwd());
+    const projectPath = resolve20(this.directory || process.cwd());
     if (this.analyzeOnly) {
       return this.runAnalysis(projectPath);
     }
@@ -137004,7 +137690,7 @@ var PrimerCommand = class extends Command42 {
       const result = generatePrimer(projectPath, {
         agents,
         allAgents: this.allAgents,
-        outputDir: this.output ? resolve19(this.output) : void 0,
+        outputDir: this.output ? resolve20(this.output) : void 0,
         dryRun: this.dryRun,
         verbose: this.verbose,
         includeExamples: this.includeExamples
@@ -137224,11 +137910,11 @@ var PrimerCommand = class extends Command42 {
 };
 
 // src/commands/mesh.ts
-import { Command as Command43, Option as Option42 } from "clipanion";
+import { Command as Command44, Option as Option43 } from "clipanion";
 import chalk30 from "chalk";
-var MeshCommand = class extends Command43 {
+var MeshCommand = class extends Command44 {
   static paths = [["mesh"]];
-  static usage = Command43.Usage({
+  static usage = Command44.Usage({
     description: "Manage peer mesh network for multi-machine agent distribution",
     details: `
       The mesh command helps you manage a peer-to-peer network of hosts
@@ -137260,17 +137946,17 @@ var MeshCommand = class extends Command43 {
       ["List trusted peers", "$0 mesh peer list --trusted"]
     ]
   });
-  action = Option42.String({ required: false });
-  arg = Option42.String({ required: false });
-  subArg = Option42.String({ required: false });
-  name = Option42.String("--name,-n", { description: "Name for the host" });
-  port = Option42.String("--port,-p", { description: "Port number" });
-  tailscale = Option42.Boolean("--tailscale,-t", false, { description: "Include Tailscale peers" });
-  timeout = Option42.String("--timeout", { description: "Timeout in milliseconds" });
-  json = Option42.Boolean("--json,-j", false, { description: "Output in JSON format" });
-  verbose = Option42.Boolean("--verbose,-v", false, { description: "Show detailed output" });
-  trusted = Option42.Boolean("--trusted", false, { description: "Show only trusted peers" });
-  securityLevel = Option42.String("--security", { description: "Security level: development, signed, secure, strict" });
+  action = Option43.String({ required: false });
+  arg = Option43.String({ required: false });
+  subArg = Option43.String({ required: false });
+  name = Option43.String("--name,-n", { description: "Name for the host" });
+  port = Option43.String("--port,-p", { description: "Port number" });
+  tailscale = Option43.Boolean("--tailscale,-t", false, { description: "Include Tailscale peers" });
+  timeout = Option43.String("--timeout", { description: "Timeout in milliseconds" });
+  json = Option43.Boolean("--json,-j", false, { description: "Output in JSON format" });
+  verbose = Option43.Boolean("--verbose,-v", false, { description: "Show detailed output" });
+  trusted = Option43.Boolean("--trusted", false, { description: "Show only trusted peers" });
+  securityLevel = Option43.String("--security", { description: "Security level: development, signed, secure, strict" });
   async execute() {
     const action = this.action || "status";
     switch (action) {
@@ -137773,11 +138459,11 @@ Total: ${trustedPeers.length} trusted, ${revokedFingerprints.length} revoked`));
 };
 
 // src/commands/message.ts
-import { Command as Command44, Option as Option43 } from "clipanion";
+import { Command as Command45, Option as Option44 } from "clipanion";
 import chalk31 from "chalk";
-var MessageCommand = class extends Command44 {
+var MessageCommand = class extends Command45 {
   static paths = [["message"], ["msg"]];
-  static usage = Command44.Usage({
+  static usage = Command45.Usage({
     description: "Inter-agent messaging system",
     details: `
       The message command enables communication between AI agents
@@ -137804,18 +138490,18 @@ var MessageCommand = class extends Command44 {
       ["Forward a message", "$0 message forward <id> other-agent"]
     ]
   });
-  action = Option43.String({ required: false });
-  arg = Option43.String({ required: false });
-  arg2 = Option43.String({ required: false });
-  body = Option43.String("--body,-b", { description: "Message body" });
-  subject = Option43.String("--subject,-s", { description: "Message subject" });
-  priority = Option43.String("--priority,-p", { description: "Priority: low, normal, high, urgent" });
-  type = Option43.String("--type,-t", { description: "Type: request, response, notification, update" });
-  unread = Option43.Boolean("--unread,-u", false, { description: "Show only unread messages" });
-  limit = Option43.String("--limit,-l", { description: "Maximum number of results" });
-  agent = Option43.String("--agent,-a", { description: "Agent ID (defaults to current agent)" });
-  json = Option43.Boolean("--json,-j", false, { description: "Output in JSON format" });
-  verbose = Option43.Boolean("--verbose,-v", false, { description: "Show detailed output" });
+  action = Option44.String({ required: false });
+  arg = Option44.String({ required: false });
+  arg2 = Option44.String({ required: false });
+  body = Option44.String("--body,-b", { description: "Message body" });
+  subject = Option44.String("--subject,-s", { description: "Message subject" });
+  priority = Option44.String("--priority,-p", { description: "Priority: low, normal, high, urgent" });
+  type = Option44.String("--type,-t", { description: "Type: request, response, notification, update" });
+  unread = Option44.Boolean("--unread,-u", false, { description: "Show only unread messages" });
+  limit = Option44.String("--limit,-l", { description: "Maximum number of results" });
+  agent = Option44.String("--agent,-a", { description: "Agent ID (defaults to current agent)" });
+  json = Option44.Boolean("--json,-j", false, { description: "Output in JSON format" });
+  verbose = Option44.Boolean("--verbose,-v", false, { description: "Show detailed output" });
   async execute() {
     const action = this.action || "inbox";
     switch (action) {
@@ -138214,8 +138900,8 @@ Sent Messages (${messages.length})
 };
 
 // src/commands/learn.ts
-import { Command as Command45, Option as Option44 } from "clipanion";
-import { resolve as resolve20 } from "path";
+import { Command as Command46, Option as Option45 } from "clipanion";
+import { resolve as resolve21 } from "path";
 import chalk32 from "chalk";
 import {
   analyzeGitHistory as analyzeGitHistory2,
@@ -138235,10 +138921,10 @@ import {
   getPatternStats,
   clusterPatterns
 } from "@skillkit/core";
-import { writeFileSync as writeFileSync10, readFileSync as readFileSync10, existsSync as existsSync20 } from "fs";
-var LearnCommand = class extends Command45 {
+import { writeFileSync as writeFileSync11, readFileSync as readFileSync10, existsSync as existsSync21 } from "fs";
+var LearnCommand = class extends Command46 {
   static paths = [["learn"]];
-  static usage = Command45.Usage({
+  static usage = Command46.Usage({
     description: "Extract learnable patterns from git history or sessions",
     details: `
       Analyzes git commit history to extract reusable patterns for error fixes,
@@ -138253,26 +138939,26 @@ var LearnCommand = class extends Command45 {
       ["Show extracted patterns", "$0 learn --show"]
     ]
   });
-  commits = Option44.String("--commits,-c", {
+  commits = Option45.String("--commits,-c", {
     description: "Number of commits to analyze (default: 100)"
   });
-  since = Option44.String("--since,-s", {
+  since = Option45.String("--since,-s", {
     description: 'Analyze commits since date (e.g., "2 weeks ago")'
   });
-  approve = Option44.Boolean("--approve,-a", false, {
+  approve = Option45.Boolean("--approve,-a", false, {
     description: "Auto-approve extracted patterns"
   });
-  show = Option44.Boolean("--show", false, {
+  show = Option45.Boolean("--show", false, {
     description: "Show existing patterns without analyzing"
   });
-  json = Option44.Boolean("--json,-j", false, {
+  json = Option45.Boolean("--json,-j", false, {
     description: "Output as JSON"
   });
-  directory = Option44.String("--dir,-d", {
+  directory = Option45.String("--dir,-d", {
     description: "Project directory to analyze (default: current directory)"
   });
   async execute() {
-    const projectPath = resolve20(this.directory || process.cwd());
+    const projectPath = resolve21(this.directory || process.cwd());
     if (this.show) {
       return this.showPatterns();
     }
@@ -138377,19 +139063,19 @@ var LearnCommand = class extends Command45 {
     console.log(chalk32.dim(`    ${truncate5(pattern.problem, 60)}`));
   }
 };
-var PatternStatusCommand = class extends Command45 {
+var PatternStatusCommand = class extends Command46 {
   static paths = [["pattern", "status"], ["pattern", "list"]];
-  static usage = Command45.Usage({
+  static usage = Command46.Usage({
     description: "Show status of learned patterns",
     examples: [
       ["Show all patterns", "$0 pattern status"],
       ["Show by category", "$0 pattern status --category error_fix"]
     ]
   });
-  category = Option44.String("--category,-c", {
+  category = Option45.String("--category,-c", {
     description: "Filter by category (error_fix, refactor, workaround, debugging, convention)"
   });
-  json = Option44.Boolean("--json,-j", false, {
+  json = Option45.Boolean("--json,-j", false, {
     description: "Output as JSON"
   });
   async execute() {
@@ -138420,20 +139106,20 @@ var PatternStatusCommand = class extends Command45 {
     return 0;
   }
 };
-var PatternFeedbackCommand = class extends Command45 {
+var PatternFeedbackCommand = class extends Command46 {
   static paths = [["pattern", "feedback"]];
-  static usage = Command45.Usage({
+  static usage = Command46.Usage({
     description: "Provide feedback on a pattern to evolve its confidence",
     examples: [
       ["Mark pattern as successful", "$0 pattern feedback <id> --success"],
       ["Mark pattern as failed", "$0 pattern feedback <id> --failure"]
     ]
   });
-  id = Option44.String({ required: true });
-  success = Option44.Boolean("--success,-s", false, {
+  id = Option45.String({ required: true });
+  success = Option45.Boolean("--success,-s", false, {
     description: "Pattern was helpful"
   });
-  failure = Option44.Boolean("--failure,-f", false, {
+  failure = Option45.Boolean("--failure,-f", false, {
     description: "Pattern was not helpful"
   });
   async execute() {
@@ -138453,13 +139139,13 @@ var PatternFeedbackCommand = class extends Command45 {
     return 0;
   }
 };
-var PatternApproveCommand = class extends Command45 {
+var PatternApproveCommand = class extends Command46 {
   static paths = [["pattern", "approve"]];
-  static usage = Command45.Usage({
+  static usage = Command46.Usage({
     description: "Approve a pending pattern",
     examples: [["Approve pattern", "$0 pattern approve <id>"]]
   });
-  id = Option44.String({ required: true });
+  id = Option45.String({ required: true });
   async execute() {
     const pattern = approvePattern(this.id);
     if (!pattern) {
@@ -138470,13 +139156,13 @@ var PatternApproveCommand = class extends Command45 {
     return 0;
   }
 };
-var PatternRejectCommand = class extends Command45 {
+var PatternRejectCommand = class extends Command46 {
   static paths = [["pattern", "reject"]];
-  static usage = Command45.Usage({
+  static usage = Command46.Usage({
     description: "Reject and remove a pattern",
     examples: [["Reject pattern", "$0 pattern reject <id>"]]
   });
-  id = Option44.String({ required: true });
+  id = Option45.String({ required: true });
   async execute() {
     const removed = rejectPattern(this.id);
     if (!removed) {
@@ -138487,22 +139173,22 @@ var PatternRejectCommand = class extends Command45 {
     return 0;
   }
 };
-var PatternExportCommand = class extends Command45 {
+var PatternExportCommand = class extends Command46 {
   static paths = [["pattern", "export"]];
-  static usage = Command45.Usage({
+  static usage = Command46.Usage({
     description: "Export patterns to a file",
     examples: [
       ["Export as JSON", "$0 pattern export --output patterns.json"],
       ["Export as markdown report", "$0 pattern export --format report"]
     ]
   });
-  output = Option44.String("--output,-o", {
+  output = Option45.String("--output,-o", {
     description: "Output file path"
   });
-  format = Option44.String("--format,-f", {
+  format = Option45.String("--format,-f", {
     description: "Format: json or report (default: json)"
   });
-  approvedOnly = Option44.Boolean("--approved", false, {
+  approvedOnly = Option45.Boolean("--approved", false, {
     description: "Export only approved patterns"
   });
   async execute() {
@@ -138519,7 +139205,7 @@ var PatternExportCommand = class extends Command45 {
       content = exportPatternsAsJson(patterns);
     }
     if (this.output) {
-      writeFileSync10(this.output, content);
+      writeFileSync11(this.output, content);
       console.log(chalk32.green(`\u2713 Exported ${patterns.length} patterns to ${this.output}`));
     } else {
       console.log(content);
@@ -138527,15 +139213,15 @@ var PatternExportCommand = class extends Command45 {
     return 0;
   }
 };
-var PatternImportCommand = class extends Command45 {
+var PatternImportCommand = class extends Command46 {
   static paths = [["pattern", "import"]];
-  static usage = Command45.Usage({
+  static usage = Command46.Usage({
     description: "Import patterns from a file",
     examples: [["Import patterns", "$0 pattern import patterns.json"]]
   });
-  file = Option44.String({ required: true });
+  file = Option45.String({ required: true });
   async execute() {
-    if (!existsSync20(this.file)) {
+    if (!existsSync21(this.file)) {
       console.log(chalk32.red(`File not found: ${this.file}`));
       return 1;
     }
@@ -138552,19 +139238,19 @@ var PatternImportCommand = class extends Command45 {
     return 0;
   }
 };
-var PatternClusterCommand = class extends Command45 {
+var PatternClusterCommand = class extends Command46 {
   static paths = [["pattern", "cluster"]];
-  static usage = Command45.Usage({
+  static usage = Command46.Usage({
     description: "Cluster similar patterns and generate skills",
     examples: [
       ["Cluster patterns", "$0 pattern cluster"],
       ["Cluster and generate skills", "$0 pattern cluster --generate"]
     ]
   });
-  generate = Option44.Boolean("--generate,-g", false, {
+  generate = Option45.Boolean("--generate,-g", false, {
     description: "Generate skills from clusters"
   });
-  minConfidence = Option44.String("--min-confidence", {
+  minConfidence = Option45.String("--min-confidence", {
     description: "Minimum confidence for clustering (default: 0.5)"
   });
   async execute() {
@@ -138603,7 +139289,7 @@ function truncate5(str, maxLen) {
 }
 
 // src/commands/session.ts
-import { Command as Command46, Option as Option45 } from "clipanion";
+import { Command as Command47, Option as Option46 } from "clipanion";
 import chalk33 from "chalk";
 import {
   loadSessionFile,
@@ -138613,9 +139299,9 @@ import {
   listSessions,
   getMostRecentSession
 } from "@skillkit/core";
-var SessionCommand = class extends Command46 {
+var SessionCommand = class extends Command47 {
   static paths = [["session"]];
-  static usage = Command46.Usage({
+  static usage = Command47.Usage({
     description: "Manage session state for context preservation",
     details: `
       Sessions track context across coding sessions, allowing you to
@@ -138639,13 +139325,13 @@ var SessionCommand = class extends Command46 {
     return 0;
   }
 };
-var SessionStatusCommand = class extends Command46 {
+var SessionStatusCommand = class extends Command47 {
   static paths = [["session", "status"]];
-  static usage = Command46.Usage({
+  static usage = Command47.Usage({
     description: "Show current session state",
     examples: [["Show status", "$0 session status"]]
   });
-  json = Option45.Boolean("--json,-j", false, {
+  json = Option46.Boolean("--json,-j", false, {
     description: "Output as JSON"
   });
   async execute() {
@@ -138699,16 +139385,16 @@ var SessionStatusCommand = class extends Command46 {
     }
   }
 };
-var SessionStartCommand = class extends Command46 {
+var SessionStartCommand = class extends Command47 {
   static paths = [["session", "start"]];
-  static usage = Command46.Usage({
+  static usage = Command47.Usage({
     description: "Start a new session",
     examples: [
       ["Start session", "$0 session start"],
       ["Start with agent", "$0 session start --agent claude-code"]
     ]
   });
-  agent = Option45.String("--agent,-a", {
+  agent = Option46.String("--agent,-a", {
     description: "AI agent being used"
   });
   async execute() {
@@ -138721,13 +139407,13 @@ var SessionStartCommand = class extends Command46 {
     return 0;
   }
 };
-var SessionLoadCommand = class extends Command46 {
+var SessionLoadCommand = class extends Command47 {
   static paths = [["session", "load"]];
-  static usage = Command46.Usage({
+  static usage = Command47.Usage({
     description: "Load session from specific date",
     examples: [["Load session", "$0 session load 2026-01-30"]]
   });
-  date = Option45.String({ required: false });
+  date = Option46.String({ required: false });
   async execute() {
     const session = this.date ? loadSessionFile(this.date) : getMostRecentSession();
     if (!session) {
@@ -138759,16 +139445,16 @@ var SessionLoadCommand = class extends Command46 {
     return 0;
   }
 };
-var SessionListCommand = class extends Command46 {
+var SessionListCommand = class extends Command47 {
   static paths = [["session", "list"], ["session", "ls"]];
-  static usage = Command46.Usage({
+  static usage = Command47.Usage({
     description: "List recent sessions",
     examples: [["List sessions", "$0 session list"]]
   });
-  limit = Option45.String("--limit,-l", {
+  limit = Option46.String("--limit,-l", {
     description: "Number of sessions to show (default: 10)"
   });
-  json = Option45.Boolean("--json,-j", false, {
+  json = Option46.Boolean("--json,-j", false, {
     description: "Output as JSON"
   });
   async execute() {
@@ -138795,13 +139481,13 @@ var SessionListCommand = class extends Command46 {
     return 0;
   }
 };
-var SessionNoteCommand = class extends Command46 {
+var SessionNoteCommand = class extends Command47 {
   static paths = [["session", "note"]];
-  static usage = Command46.Usage({
+  static usage = Command47.Usage({
     description: "Add note to current session",
     examples: [["Add note", '$0 session note "Remember to test edge cases"']]
   });
-  note = Option45.String({ required: true });
+  note = Option46.String({ required: true });
   async execute() {
     let session = getMostRecentSession();
     if (!session) {
@@ -138815,13 +139501,13 @@ var SessionNoteCommand = class extends Command46 {
     return 0;
   }
 };
-var SessionCompleteCommand = class extends Command46 {
+var SessionCompleteCommand = class extends Command47 {
   static paths = [["session", "complete"]];
-  static usage = Command46.Usage({
+  static usage = Command47.Usage({
     description: "Mark task as completed",
     examples: [["Mark completed", '$0 session complete "Implemented user auth"']]
   });
-  task = Option45.String({ required: true });
+  task = Option46.String({ required: true });
   async execute() {
     let session = getMostRecentSession();
     if (!session) {
@@ -138838,13 +139524,13 @@ var SessionCompleteCommand = class extends Command46 {
     return 0;
   }
 };
-var SessionInProgressCommand = class extends Command46 {
+var SessionInProgressCommand = class extends Command47 {
   static paths = [["session", "wip"], ["session", "progress"]];
-  static usage = Command46.Usage({
+  static usage = Command47.Usage({
     description: "Mark task as in progress",
     examples: [["Mark in progress", '$0 session wip "Working on auth flow"']]
   });
-  task = Option45.String({ required: true });
+  task = Option46.String({ required: true });
   async execute() {
     let session = getMostRecentSession();
     if (!session) {
@@ -138860,7 +139546,7 @@ var SessionInProgressCommand = class extends Command46 {
 };
 
 // src/commands/profile.ts
-import { Command as Command47, Option as Option46 } from "clipanion";
+import { Command as Command48, Option as Option47 } from "clipanion";
 import chalk34 from "chalk";
 import {
   getActiveProfile,
@@ -138871,9 +139557,9 @@ import {
   removeCustomProfile,
   isBuiltinProfile
 } from "@skillkit/core";
-var ProfileCommand = class extends Command47 {
+var ProfileCommand = class extends Command48 {
   static paths = [["profile"]];
-  static usage = Command47.Usage({
+  static usage = Command48.Usage({
     description: "Manage operational profiles (dev, review, research modes)",
     details: `
       Profiles adjust agent behavior for different tasks.
@@ -138885,7 +139571,7 @@ var ProfileCommand = class extends Command47 {
       ["List all profiles", "$0 profile list"]
     ]
   });
-  name = Option46.String({ required: false });
+  name = Option47.String({ required: false });
   async execute() {
     if (this.name) {
       const profile2 = getProfile(this.name);
@@ -138929,13 +139615,13 @@ var ProfileCommand = class extends Command47 {
     return 0;
   }
 };
-var ProfileListCommand = class extends Command47 {
+var ProfileListCommand = class extends Command48 {
   static paths = [["profile", "list"], ["profile", "ls"]];
-  static usage = Command47.Usage({
+  static usage = Command48.Usage({
     description: "List available profiles",
     examples: [["List profiles", "$0 profile list"]]
   });
-  json = Option46.Boolean("--json,-j", false, {
+  json = Option47.Boolean("--json,-j", false, {
     description: "Output as JSON"
   });
   async execute() {
@@ -138960,23 +139646,23 @@ var ProfileListCommand = class extends Command47 {
     return 0;
   }
 };
-var ProfileCreateCommand = class extends Command47 {
+var ProfileCreateCommand = class extends Command48 {
   static paths = [["profile", "create"]];
-  static usage = Command47.Usage({
+  static usage = Command48.Usage({
     description: "Create a custom profile",
     examples: [
       ["Create profile", '$0 profile create --name my-profile --description "My custom profile"']
     ]
   });
-  name = Option46.String("--name,-n", {
+  name = Option47.String("--name,-n", {
     description: "Profile name",
     required: true
   });
-  description = Option46.String("--description,-d", {
+  description = Option47.String("--description,-d", {
     description: "Profile description",
     required: true
   });
-  focus = Option46.String("--focus,-f", {
+  focus = Option47.String("--focus,-f", {
     description: "Profile focus"
   });
   async execute() {
@@ -138997,13 +139683,13 @@ var ProfileCreateCommand = class extends Command47 {
     return 0;
   }
 };
-var ProfileRemoveCommand = class extends Command47 {
+var ProfileRemoveCommand = class extends Command48 {
   static paths = [["profile", "remove"], ["profile", "rm"]];
-  static usage = Command47.Usage({
+  static usage = Command48.Usage({
     description: "Remove a custom profile",
     examples: [["Remove profile", "$0 profile remove my-profile"]]
   });
-  name = Option46.String({ required: true });
+  name = Option47.String({ required: true });
   async execute() {
     if (isBuiltinProfile(this.name)) {
       console.log(chalk34.red(`Cannot remove built-in profile: ${this.name}`));
@@ -139020,7 +139706,7 @@ var ProfileRemoveCommand = class extends Command47 {
 };
 
 // src/commands/guideline.ts
-import { Command as Command48, Option as Option47 } from "clipanion";
+import { Command as Command49, Option as Option48 } from "clipanion";
 import chalk35 from "chalk";
 import {
   getAllGuidelines,
@@ -139033,9 +139719,9 @@ import {
   addCustomGuideline,
   removeCustomGuideline
 } from "@skillkit/core";
-var GuidelineCommand = class extends Command48 {
+var GuidelineCommand = class extends Command49 {
   static paths = [["guideline"], ["guide"]];
-  static usage = Command48.Usage({
+  static usage = Command49.Usage({
     description: "Manage coding guidelines (always-on rules)",
     details: `
       Guidelines are always-on coding standards that guide agent behavior.
@@ -139058,19 +139744,19 @@ var GuidelineCommand = class extends Command48 {
     return 0;
   }
 };
-var GuidelineListCommand = class extends Command48 {
+var GuidelineListCommand = class extends Command49 {
   static paths = [["guideline", "list"], ["guideline", "ls"]];
-  static usage = Command48.Usage({
+  static usage = Command49.Usage({
     description: "List all guidelines",
     examples: [
       ["List all", "$0 guideline list"],
       ["Show only enabled", "$0 guideline list --enabled"]
     ]
   });
-  enabled = Option47.Boolean("--enabled,-e", false, {
+  enabled = Option48.Boolean("--enabled,-e", false, {
     description: "Show only enabled guidelines"
   });
-  json = Option47.Boolean("--json,-j", false, {
+  json = Option48.Boolean("--json,-j", false, {
     description: "Output as JSON"
   });
   async execute() {
@@ -139106,13 +139792,13 @@ var GuidelineListCommand = class extends Command48 {
     return 0;
   }
 };
-var GuidelineShowCommand = class extends Command48 {
+var GuidelineShowCommand = class extends Command49 {
   static paths = [["guideline", "show"]];
-  static usage = Command48.Usage({
+  static usage = Command49.Usage({
     description: "Show guideline content",
     examples: [["Show guideline", "$0 guideline show security"]]
   });
-  id = Option47.String({ required: true });
+  id = Option48.String({ required: true });
   async execute() {
     const guideline = getGuideline(this.id);
     if (!guideline) {
@@ -139133,13 +139819,13 @@ var GuidelineShowCommand = class extends Command48 {
     return 0;
   }
 };
-var GuidelineEnableCommand = class extends Command48 {
+var GuidelineEnableCommand = class extends Command49 {
   static paths = [["guideline", "enable"]];
-  static usage = Command48.Usage({
+  static usage = Command49.Usage({
     description: "Enable a guideline",
     examples: [["Enable security", "$0 guideline enable security"]]
   });
-  id = Option47.String({ required: true });
+  id = Option48.String({ required: true });
   async execute() {
     const success2 = enableGuideline(this.id);
     if (!success2) {
@@ -139150,13 +139836,13 @@ var GuidelineEnableCommand = class extends Command48 {
     return 0;
   }
 };
-var GuidelineDisableCommand = class extends Command48 {
+var GuidelineDisableCommand = class extends Command49 {
   static paths = [["guideline", "disable"]];
-  static usage = Command48.Usage({
+  static usage = Command49.Usage({
     description: "Disable a guideline",
     examples: [["Disable performance", "$0 guideline disable performance"]]
   });
-  id = Option47.String({ required: true });
+  id = Option48.String({ required: true });
   async execute() {
     const success2 = disableGuideline(this.id);
     if (!success2) {
@@ -139167,29 +139853,29 @@ var GuidelineDisableCommand = class extends Command48 {
     return 0;
   }
 };
-var GuidelineCreateCommand = class extends Command48 {
+var GuidelineCreateCommand = class extends Command49 {
   static paths = [["guideline", "create"]];
-  static usage = Command48.Usage({
+  static usage = Command49.Usage({
     description: "Create a custom guideline",
     examples: [
       ["Create guideline", '$0 guideline create --id my-rules --name "My Rules" --category custom']
     ]
   });
-  id = Option47.String("--id", {
+  id = Option48.String("--id", {
     description: "Guideline ID",
     required: true
   });
-  name = Option47.String("--name,-n", {
+  name = Option48.String("--name,-n", {
     description: "Guideline name",
     required: true
   });
-  description = Option47.String("--description,-d", {
+  description = Option48.String("--description,-d", {
     description: "Guideline description"
   });
-  category = Option47.String("--category,-c", {
+  category = Option48.String("--category,-c", {
     description: "Category (security, code-style, testing, git, performance, custom)"
   });
-  priority = Option47.String("--priority,-p", {
+  priority = Option48.String("--priority,-p", {
     description: "Priority (1-10, higher = more important)"
   });
   async execute() {
@@ -139216,13 +139902,13 @@ Add your guidelines here.`
     return 0;
   }
 };
-var GuidelineRemoveCommand = class extends Command48 {
+var GuidelineRemoveCommand = class extends Command49 {
   static paths = [["guideline", "remove"], ["guideline", "rm"]];
-  static usage = Command48.Usage({
+  static usage = Command49.Usage({
     description: "Remove a custom guideline",
     examples: [["Remove guideline", "$0 guideline remove my-rules"]]
   });
-  id = Option47.String({ required: true });
+  id = Option48.String({ required: true });
   async execute() {
     if (isBuiltinGuideline(this.id)) {
       console.log(chalk35.red(`Cannot remove built-in guideline: ${this.id}`));
@@ -139243,7 +139929,7 @@ function formatCategoryName2(category) {
 
 // src/commands/tree.ts
 init_onboarding();
-import { Command as Command49, Option as Option48 } from "clipanion";
+import { Command as Command50, Option as Option49 } from "clipanion";
 import { join as join19 } from "path";
 import { homedir as homedir4 } from "os";
 import {
@@ -139253,9 +139939,9 @@ import {
   loadTree
 } from "@skillkit/core";
 var TREE_PATH = join19(homedir4(), ".skillkit", "skill-tree.json");
-var TreeCommand = class extends Command49 {
+var TreeCommand = class extends Command50 {
   static paths = [["tree"]];
-  static usage = Command49.Usage({
+  static usage = Command50.Usage({
     description: "Browse skills in a hierarchical tree structure",
     details: `
       The tree command displays skills organized in a hierarchical taxonomy.
@@ -139277,23 +139963,23 @@ var TreeCommand = class extends Command49 {
       ["Show tree stats", "$0 tree --stats"]
     ]
   });
-  treePath = Option48.String({ required: false });
-  depth = Option48.String("--depth,-d", {
+  treePath = Option49.String({ required: false });
+  depth = Option49.String("--depth,-d", {
     description: "Maximum depth to display"
   });
-  generate = Option48.Boolean("--generate,-g", false, {
+  generate = Option49.Boolean("--generate,-g", false, {
     description: "Generate/update tree from skill index"
   });
-  markdown = Option48.Boolean("--markdown,-m", false, {
+  markdown = Option49.Boolean("--markdown,-m", false, {
     description: "Output in markdown format"
   });
-  stats = Option48.Boolean("--stats,-s", false, {
+  stats = Option49.Boolean("--stats,-s", false, {
     description: "Show tree statistics"
   });
-  json = Option48.Boolean("--json,-j", false, {
+  json = Option49.Boolean("--json,-j", false, {
     description: "Output in JSON format"
   });
-  quiet = Option48.Boolean("--quiet,-q", false, {
+  quiet = Option49.Boolean("--quiet,-q", false, {
     description: "Minimal output"
   });
   async execute() {
@@ -139446,11 +140132,11 @@ var TreeCommand = class extends Command49 {
 // src/commands/quick.ts
 init_helpers();
 init_onboarding();
-import { existsSync as existsSync21, mkdirSync as mkdirSync10, cpSync as cpSync4, rmSync as rmSync5, symlinkSync as symlinkSync2 } from "fs";
-import { join as join20, resolve as resolve21, normalize } from "path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync11, cpSync as cpSync4, rmSync as rmSync5, symlinkSync as symlinkSync2 } from "fs";
+import { join as join20, resolve as resolve22, normalize } from "path";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { Command as Command50 } from "clipanion";
+import { Command as Command51 } from "clipanion";
 import {
   ContextManager as ContextManager3,
   RecommendationEngine as RecommendationEngine2,
@@ -139469,9 +140155,9 @@ function truncate6(str, maxLen) {
   if (str.length <= maxLen) return str;
   return str.slice(0, maxLen - 3) + "...";
 }
-var QuickCommand = class extends Command50 {
+var QuickCommand = class extends Command51 {
   static paths = [["quick"]];
-  static usage = Command50.Usage({
+  static usage = Command51.Usage({
     description: "Zero-friction skill setup: detect agents, analyze project, recommend and install",
     examples: [
       ["Quick setup", "$0 quick"]
@@ -139490,7 +140176,7 @@ var QuickCommand = class extends Command50 {
         try {
           const installDir = getInstallDir(false, adapter.type);
           const globalDir = getInstallDir(true, adapter.type);
-          if (existsSync21(installDir) || existsSync21(globalDir) || existsSync21(adapter.configFile)) {
+          if (existsSync22(installDir) || existsSync22(globalDir) || existsSync22(adapter.configFile)) {
             detectedAgents.push(adapter.type);
           }
         } catch {
@@ -139502,7 +140188,7 @@ var QuickCommand = class extends Command50 {
       }
       s.stop(`Detected ${detectedAgents.length} agent${detectedAgents.length !== 1 ? "s" : ""}: ${detectedAgents.map(formatAgent).join(", ")}`);
       s.start("Analyzing project...");
-      const targetPath = resolve21(process.cwd());
+      const targetPath = resolve22(process.cwd());
       const manager = new ContextManager3(targetPath);
       let context = manager.get();
       if (!context) {
@@ -139637,8 +140323,8 @@ var QuickCommand = class extends Command50 {
       for (const agentType of detectedAgents) {
         const adapter = getAdapter6(agentType);
         const installDir = getInstallDir(false, agentType);
-        if (!existsSync21(installDir)) {
-          mkdirSync10(installDir, { recursive: true });
+        if (!existsSync22(installDir)) {
+          mkdirSync11(installDir, { recursive: true });
         }
         const sanitizedName = matchedSkill.name.split(/[/\\]/).pop() || matchedSkill.name;
         const targetInstallPath = normalize(join20(installDir, sanitizedName));
@@ -139654,7 +140340,7 @@ var QuickCommand = class extends Command50 {
         const useSymlink = detectedAgents.length > 1 && primaryPath !== null;
         s.start(`Installing to ${adapter.name}${useSymlink ? " (symlink)" : ""}...`);
         try {
-          if (existsSync21(targetInstallPath)) {
+          if (existsSync22(targetInstallPath)) {
             rmSync5(targetInstallPath, { recursive: true, force: true });
           }
           if (useSymlink && primaryPath) {
@@ -139665,7 +140351,7 @@ var QuickCommand = class extends Command50 {
               primaryPath = targetInstallPath;
             }
             const packageJsonPath = join20(targetInstallPath, "package.json");
-            if (existsSync21(packageJsonPath)) {
+            if (existsSync22(packageJsonPath)) {
               s.stop(`Installed to ${adapter.name}`);
               s.start("Installing npm dependencies...");
               try {
@@ -139696,7 +140382,7 @@ var QuickCommand = class extends Command50 {
         }
       }
       const cleanupPath = cloneResult.tempRoot || cloneResult.path;
-      if (!isLocalPath4(selectedSkill.skill.source) && cleanupPath && existsSync21(cleanupPath)) {
+      if (!isLocalPath4(selectedSkill.skill.source) && cleanupPath && existsSync22(cleanupPath)) {
         rmSync5(cleanupPath, { recursive: true, force: true });
       }
       if (installedAgents.length > 0) {
@@ -139730,9 +140416,9 @@ var QuickCommand = class extends Command50 {
 
 // src/commands/skillmd.ts
 init_onboarding();
-import { existsSync as existsSync22, readFileSync as readFileSync11, writeFileSync as writeFileSync11, readdirSync as readdirSync4 } from "fs";
-import { join as join21, resolve as resolve22, basename as basename6, relative } from "path";
-import { Command as Command51, Option as Option49 } from "clipanion";
+import { existsSync as existsSync23, readFileSync as readFileSync11, writeFileSync as writeFileSync12, readdirSync as readdirSync4 } from "fs";
+import { join as join21, resolve as resolve23, basename as basename6, relative } from "path";
+import { Command as Command52, Option as Option50 } from "clipanion";
 function validateSkillMd(filePath) {
   const result = {
     path: filePath,
@@ -139746,7 +140432,7 @@ function validateSkillMd(filePath) {
     score: 0,
     issues: []
   };
-  if (!existsSync22(filePath)) {
+  if (!existsSync23(filePath)) {
     result.issues.push("File does not exist");
     return result;
   }
@@ -139847,25 +140533,25 @@ function printValidation(validation, verbose = false) {
     }
   }
 }
-var SkillMdValidateCommand = class extends Command51 {
+var SkillMdValidateCommand = class extends Command52 {
   static paths = [["skillmd", "validate"], ["skill-md", "validate"]];
-  static usage = Command51.Usage({
+  static usage = Command52.Usage({
     description: "Validate a SKILL.md file against the standard",
     examples: [
       ["Validate SKILL.md in current directory", "$0 skillmd validate"],
       ["Validate specific file", "$0 skillmd validate ./path/to/SKILL.md"]
     ]
   });
-  targetPath = Option49.String({ required: false, name: "path" });
-  verbose = Option49.Boolean("--verbose,-v", false, {
+  targetPath = Option50.String({ required: false, name: "path" });
+  verbose = Option50.Boolean("--verbose,-v", false, {
     description: "Show detailed validation results"
   });
-  json = Option49.Boolean("--json", false, {
+  json = Option50.Boolean("--json", false, {
     description: "Output as JSON"
   });
   async execute() {
     const targetPath = this.targetPath || join21(process.cwd(), "SKILL.md");
-    const resolvedPath = resolve22(targetPath);
+    const resolvedPath = resolve23(targetPath);
     const filePath = resolvedPath.endsWith("SKILL.md") ? resolvedPath : join21(resolvedPath, "SKILL.md");
     if (!this.json) {
       header("SKILL.md Validation");
@@ -139890,24 +140576,24 @@ var SkillMdValidateCommand = class extends Command51 {
     return validation.score >= 60 ? 0 : 1;
   }
 };
-var SkillMdInitCommand = class extends Command51 {
+var SkillMdInitCommand = class extends Command52 {
   static paths = [["skillmd", "init"], ["skill-md", "init"]];
-  static usage = Command51.Usage({
+  static usage = Command52.Usage({
     description: "Create a template SKILL.md in the current directory",
     examples: [
       ["Create SKILL.md template", "$0 skillmd init"],
       ["Create with custom name", "$0 skillmd init --name my-skill"]
     ]
   });
-  name = Option49.String("--name,-n", {
+  name = Option50.String("--name,-n", {
     description: "Skill name"
   });
-  force = Option49.Boolean("--force,-f", false, {
+  force = Option50.Boolean("--force,-f", false, {
     description: "Overwrite existing SKILL.md"
   });
   async execute() {
     const outputPath = join21(process.cwd(), "SKILL.md");
-    if (existsSync22(outputPath) && !this.force) {
+    if (existsSync23(outputPath) && !this.force) {
       warn("SKILL.md already exists");
       console.log(colors.muted("Use --force to overwrite"));
       return 1;
@@ -139952,7 +140638,7 @@ var SkillMdInitCommand = class extends Command51 {
       "```",
       ""
     ].join("\n");
-    writeFileSync11(outputPath, template);
+    writeFileSync12(outputPath, template);
     success(`Created SKILL.md for "${skillName}"`);
     console.log("");
     console.log(colors.muted("Next steps:"));
@@ -139962,21 +140648,21 @@ var SkillMdInitCommand = class extends Command51 {
     return 0;
   }
 };
-var SkillMdCheckCommand = class extends Command51 {
+var SkillMdCheckCommand = class extends Command52 {
   static paths = [["skillmd", "check"], ["skill-md", "check"]];
-  static usage = Command51.Usage({
+  static usage = Command52.Usage({
     description: "Check all SKILL.md files in the project for compliance",
     examples: [
       ["Check current directory", "$0 skillmd check"],
       ["Check specific directory", "$0 skillmd check ./skills"]
     ]
   });
-  targetPath = Option49.String({ required: false, name: "path" });
-  verbose = Option49.Boolean("--verbose,-v", false, {
+  targetPath = Option50.String({ required: false, name: "path" });
+  verbose = Option50.Boolean("--verbose,-v", false, {
     description: "Show detailed validation results"
   });
   async execute() {
-    const targetPath = resolve22(this.targetPath || process.cwd());
+    const targetPath = resolve23(this.targetPath || process.cwd());
     header("SKILL.md Compliance Check");
     const s = spinner2();
     s.start("Scanning for SKILL.md files...");
@@ -140024,7 +140710,7 @@ var SkillMdCheckCommand = class extends Command51 {
   findSkillMdFiles(dir) {
     const results = [];
     const directFile = join21(dir, "SKILL.md");
-    if (existsSync22(directFile)) results.push(directFile);
+    if (existsSync23(directFile)) results.push(directFile);
     const searchDirs = [
       join21(dir, "skills"),
       join21(dir, ".claude", "skills"),
@@ -140033,7 +140719,7 @@ var SkillMdCheckCommand = class extends Command51 {
       join21(dir, ".github", "skills")
     ];
     for (const searchDir of searchDirs) {
-      if (!existsSync22(searchDir)) continue;
+      if (!existsSync23(searchDir)) continue;
       this.scanDir(searchDir, results, 0);
     }
     try {
@@ -140042,7 +140728,7 @@ var SkillMdCheckCommand = class extends Command51 {
         if (!entry.isDirectory()) continue;
         if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
         const entrySkillMd = join21(dir, entry.name, "SKILL.md");
-        if (existsSync22(entrySkillMd) && !results.includes(entrySkillMd)) {
+        if (existsSync23(entrySkillMd) && !results.includes(entrySkillMd)) {
           results.push(entrySkillMd);
         }
       }
@@ -140070,10 +140756,10 @@ var SkillMdCheckCommand = class extends Command51 {
 
 // src/commands/serve.ts
 init_onboarding();
-import { Command as Command52, Option as Option50 } from "clipanion";
-var ServeCommand = class extends Command52 {
+import { Command as Command53, Option as Option51 } from "clipanion";
+var ServeCommand = class extends Command53 {
   static paths = [["serve"], ["server"]];
-  static usage = Command52.Usage({
+  static usage = Command53.Usage({
     description: "Start the SkillKit REST API server for skill discovery",
     details: `
       Launches a local HTTP server that exposes the SkillKit skill catalog
@@ -140086,16 +140772,16 @@ var ServeCommand = class extends Command52 {
       ["Start with custom CORS", '$0 serve --cors "http://localhost:3000"']
     ]
   });
-  port = Option50.String("--port,-p", "3737", {
+  port = Option51.String("--port,-p", "3737", {
     description: "Port to listen on"
   });
-  host = Option50.String("--host,-H", "0.0.0.0", {
+  host = Option51.String("--host,-H", "0.0.0.0", {
     description: "Host to bind to"
   });
-  corsOrigin = Option50.String("--cors", "*", {
+  corsOrigin = Option51.String("--cors", "*", {
     description: "CORS allowed origin"
   });
-  cacheTtl = Option50.String("--cache-ttl", "86400000", {
+  cacheTtl = Option51.String("--cache-ttl", "86400000", {
     description: "Cache TTL in milliseconds"
   });
   async execute() {
@@ -140130,6 +140816,8 @@ var ServeCommand = class extends Command52 {
       console.log(colors.muted(`  GET  /trending        - Top skills`));
       console.log(colors.muted(`  GET  /categories      - Skill categories`));
       console.log(colors.muted(`  GET  /cache/stats     - Cache statistics`));
+      console.log(colors.muted(`  GET  /docs            - Interactive API docs`));
+      console.log(colors.muted(`  GET  /openapi.json    - OpenAPI specification`));
       console.log("");
       console.log(colors.muted("Press Ctrl+C to stop"));
       await new Promise(() => {
@@ -140169,6 +140857,7 @@ export {
   EnableCommand,
   FindCommand,
   FixCommand,
+  GenerateCommand,
   GuidelineCommand,
   GuidelineCreateCommand,
   GuidelineDisableCommand,