@skillkit/cli 1.3.1 → 1.5.0

package/dist/index.js

@@ -1771,15 +1771,19 @@ ${chalk12.bold("Agents:")}`);
 
 // src/commands/recommend.ts
 import { Command as Command14, Option as Option13 } from "clipanion";
-import { existsSync as existsSync9, readFileSync as readFileSync4, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5 } from "fs";
-import { resolve as resolve2, join as join6 } from "path";
+import { resolve as resolve2 } from "path";
 import chalk13 from "chalk";
+import ora3 from "ora";
 import {
   ContextManager as ContextManager2,
-  RecommendationEngine
+  RecommendationEngine,
+  buildSkillIndex,
+  saveIndex,
+  loadIndex as loadIndexFromCache,
+  isIndexStale,
+  INDEX_PATH,
+  KNOWN_SKILL_REPOS
 } from "@skillkit/core";
-var INDEX_PATH = join6(process.env.HOME || "~", ".skillkit", "index.json");
-var INDEX_CACHE_HOURS = 24;
 var RecommendCommand = class extends Command14 {
   static paths = [["recommend"], ["rec"]];
   static usage = Command14.Usage({
@@ -1803,7 +1807,8 @@ var RecommendCommand = class extends Command14 {
       ["Filter by category", "$0 recommend --category security"],
       ["Show detailed reasons", "$0 recommend --verbose"],
       ["Update skill index", "$0 recommend --update"],
-      ["Search for skills by task", '$0 recommend --search "authentication"']
+      ["Search for skills by task", '$0 recommend --task "authentication"'],
+      ["Search for skills (alias)", '$0 recommend --search "testing"']
     ]
   });
   // Limit number of results
@@ -1826,10 +1831,14 @@ var RecommendCommand = class extends Command14 {
   update = Option13.Boolean("--update,-u", false, {
     description: "Update skill index from sources"
   });
-  // Search mode
+  // Search mode (--search or --task)
   search = Option13.String("--search,-s", {
     description: "Search skills by task/query"
   });
+  // Task alias for search (GSD-style)
+  task = Option13.String("--task,-t", {
+    description: "Search skills by task (alias for --search)"
+  });
   // Include installed skills
   includeInstalled = Option13.Boolean("--include-installed", false, {
     description: "Include already installed skills"
@@ -1845,7 +1854,7 @@ var RecommendCommand = class extends Command14 {
   async execute() {
     const targetPath = resolve2(this.projectPath || process.cwd());
     if (this.update) {
-      return this.updateIndex();
+      return await this.updateIndex();
     }
     const profile = await this.getProjectProfile(targetPath);
     if (!profile) {
@@ -1862,8 +1871,9 @@ var RecommendCommand = class extends Command14 {
     }
     const engine = new RecommendationEngine();
     engine.loadIndex(index);
-    if (this.search) {
-      return this.handleSearch(engine, this.search);
+    const searchQuery = this.search || this.task;
+    if (searchQuery) {
+      return this.handleSearch(engine, searchQuery);
     }
     const result = engine.recommend(profile, {
       limit: this.limit ? parseInt(this.limit, 10) : 10,
@@ -2008,220 +2018,3225 @@ var RecommendCommand = class extends Command14 {
    * Load skill index from cache
    */
   loadIndex() {
-    if (!existsSync9(INDEX_PATH)) {
+    const index = loadIndexFromCache();
+    if (!index) {
       return null;
     }
-    try {
-      const content = readFileSync4(INDEX_PATH, "utf-8");
-      const index = JSON.parse(content);
+    if (isIndexStale(index) && !this.json) {
       const lastUpdated = new Date(index.lastUpdated);
       const hoursSinceUpdate = (Date.now() - lastUpdated.getTime()) / (1e3 * 60 * 60);
-      if (hoursSinceUpdate > INDEX_CACHE_HOURS && !this.json) {
-        console.log(
-          chalk13.dim(`Index is ${Math.round(hoursSinceUpdate)} hours old. Run --update to refresh.
+      console.log(
+        chalk13.dim(`Index is ${Math.round(hoursSinceUpdate)} hours old. Run --update to refresh.
 `)
-        );
-      }
-      return index;
-    } catch {
-      return null;
+      );
     }
+    return index;
   }
   /**
    * Update skill index from sources
    */
-  updateIndex() {
-    console.log(chalk13.cyan("Updating skill index...\n"));
-    const sampleIndex = {
-      version: 1,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      skills: getSampleSkills(),
-      sources: [
-        {
-          name: "vercel-labs",
-          url: "https://github.com/vercel-labs/agent-skills",
-          lastFetched: (/* @__PURE__ */ new Date()).toISOString(),
-          skillCount: 5
-        },
-        {
-          name: "anthropics",
-          url: "https://github.com/anthropics/skills",
-          lastFetched: (/* @__PURE__ */ new Date()).toISOString(),
-          skillCount: 3
+  async updateIndex() {
+    console.log(chalk13.cyan("Updating skill index from GitHub repositories...\n"));
+    console.log(chalk13.dim(`Sources: ${KNOWN_SKILL_REPOS.map((r) => `${r.owner}/${r.repo}`).join(", ")}
+`));
+    const spinner = ora3("Fetching skills...").start();
+    try {
+      const { index, errors } = await buildSkillIndex(KNOWN_SKILL_REPOS, (message) => {
+        spinner.text = message;
+      });
+      spinner.stop();
+      if (errors.length > 0) {
+        console.log(chalk13.yellow("\nWarnings:"));
+        for (const error of errors) {
+          console.log(chalk13.dim(`  \u2022 ${error}`));
         }
-      ]
-    };
-    const indexDir = join6(process.env.HOME || "~", ".skillkit");
-    if (!existsSync9(indexDir)) {
-      mkdirSync5(indexDir, { recursive: true });
-    }
-    writeFileSync5(INDEX_PATH, JSON.stringify(sampleIndex, null, 2));
-    console.log(chalk13.green(`\u2713 Updated index with ${sampleIndex.skills.length} skills`));
-    console.log(chalk13.dim(`  Sources: ${sampleIndex.sources.map((s) => s.name).join(", ")}`));
-    console.log(chalk13.dim(`  Saved to: ${INDEX_PATH}
+        console.log();
+      }
+      saveIndex(index);
+      console.log(chalk13.green(`\u2713 Updated index with ${index.skills.length} skills`));
+      if (index.sources.length > 0) {
+        console.log(chalk13.dim(`  Sources: ${index.sources.map((s) => s.name).join(", ")}`));
+      }
+      console.log(chalk13.dim(`  Saved to: ${INDEX_PATH}
 `));
-    return 0;
+      return 0;
+    } catch (error) {
+      spinner.fail("Failed to update index");
+      console.error(chalk13.red(error instanceof Error ? error.message : String(error)));
+      return 1;
+    }
   }
 };
 function truncate2(str, maxLen) {
   if (str.length <= maxLen) return str;
   return str.slice(0, maxLen - 3) + "...";
 }
-function getSampleSkills() {
-  return [
-    {
-      name: "vercel-react-best-practices",
-      description: "Modern React patterns including Server Components, hooks best practices, and performance optimization",
-      source: "vercel-labs/agent-skills",
-      tags: ["react", "frontend", "typescript", "nextjs", "performance"],
-      compatibility: {
-        frameworks: ["react", "nextjs"],
-        languages: ["typescript", "javascript"],
-        libraries: []
-      },
-      popularity: 1500,
-      quality: 95,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      verified: true
-    },
-    {
-      name: "tailwind-v4-patterns",
-      description: "Tailwind CSS v4 utility patterns, responsive design, and component styling best practices",
-      source: "vercel-labs/agent-skills",
-      tags: ["tailwind", "css", "styling", "frontend", "responsive"],
-      compatibility: {
-        frameworks: [],
-        languages: ["typescript", "javascript"],
-        libraries: ["tailwindcss"]
-      },
-      popularity: 1200,
-      quality: 92,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      verified: true
-    },
-    {
-      name: "nextjs-app-router",
-      description: "Next.js App Router patterns including layouts, server actions, and data fetching",
-      source: "vercel-labs/agent-skills",
-      tags: ["nextjs", "react", "routing", "server-actions", "frontend"],
-      compatibility: {
-        frameworks: ["nextjs"],
-        languages: ["typescript", "javascript"],
-        libraries: []
-      },
-      popularity: 1100,
-      quality: 94,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      verified: true
-    },
-    {
-      name: "typescript-strict-patterns",
-      description: "TypeScript strict mode patterns, type safety, and advanced type utilities",
-      source: "anthropics/skills",
-      tags: ["typescript", "types", "safety", "patterns"],
-      compatibility: {
-        frameworks: [],
-        languages: ["typescript"],
-        libraries: []
-      },
-      popularity: 900,
-      quality: 90,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      verified: true
-    },
-    {
-      name: "supabase-best-practices",
-      description: "Supabase integration patterns including auth, database queries, and real-time subscriptions",
-      source: "anthropics/skills",
-      tags: ["supabase", "database", "auth", "backend", "postgresql"],
-      compatibility: {
-        frameworks: [],
-        languages: ["typescript", "javascript"],
-        libraries: ["@supabase/supabase-js"]
-      },
-      popularity: 800,
-      quality: 88,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      verified: true
-    },
-    {
-      name: "vitest-testing-patterns",
-      description: "Testing patterns with Vitest including mocking, assertions, and test organization",
-      source: "anthropics/skills",
-      tags: ["vitest", "testing", "typescript", "mocking", "tdd"],
-      compatibility: {
-        frameworks: [],
-        languages: ["typescript", "javascript"],
-        libraries: ["vitest"]
-      },
-      popularity: 700,
-      quality: 86,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      verified: false
-    },
-    {
-      name: "prisma-database-patterns",
-      description: "Prisma ORM patterns for schema design, migrations, and efficient queries",
-      source: "vercel-labs/agent-skills",
-      tags: ["prisma", "database", "orm", "postgresql", "backend"],
-      compatibility: {
-        frameworks: [],
-        languages: ["typescript"],
-        libraries: ["@prisma/client"]
-      },
-      popularity: 850,
-      quality: 89,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      verified: true
-    },
-    {
-      name: "security-best-practices",
-      description: "Security patterns for web applications including XSS prevention, CSRF, and secure headers",
-      source: "trailofbits/skills",
-      tags: ["security", "xss", "csrf", "headers", "owasp"],
-      compatibility: {
-        frameworks: [],
-        languages: ["typescript", "javascript", "python"],
-        libraries: []
-      },
-      popularity: 600,
-      quality: 95,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      verified: true
-    },
-    {
-      name: "python-fastapi-patterns",
-      description: "FastAPI best practices for building high-performance Python APIs",
-      source: "python-skills/fastapi",
-      tags: ["python", "fastapi", "backend", "api", "async"],
-      compatibility: {
-        frameworks: ["fastapi"],
-        languages: ["python"],
-        libraries: []
-      },
-      popularity: 550,
-      quality: 85,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      verified: false
-    },
-    {
-      name: "zustand-state-management",
-      description: "Zustand state management patterns for React applications",
-      source: "react-skills/state",
-      tags: ["zustand", "react", "state-management", "frontend"],
-      compatibility: {
-        frameworks: ["react"],
-        languages: ["typescript", "javascript"],
-        libraries: ["zustand"]
-      },
-      popularity: 650,
-      quality: 84,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      verified: false
+
+// src/commands/status.ts
+import { Command as Command15, Option as Option14 } from "clipanion";
+import { resolve as resolve3 } from "path";
+import chalk14 from "chalk";
+import { SessionManager } from "@skillkit/core";
+var StatusCommand = class extends Command15 {
+  static paths = [["status"], ["st"]];
+  static usage = Command15.Usage({
+    description: "Show current session state and execution progress",
+    details: `
+      The status command shows the current state of skill execution sessions,
+      including any paused executions and recent history.
+    `,
+    examples: [
+      ["Show session status", "$0 status"],
+      ["Show with history", "$0 status --history"],
+      ["Show JSON output", "$0 status --json"]
+    ]
+  });
+  // Show history
+  history = Option14.Boolean("--history,-h", false, {
+    description: "Show execution history"
+  });
+  // History limit
+  limit = Option14.String("--limit,-l", {
+    description: "Limit history entries (default: 10)"
+  });
+  // JSON output
+  json = Option14.Boolean("--json,-j", false, {
+    description: "Output in JSON format"
+  });
+  // Project path
+  projectPath = Option14.String("--path,-p", {
+    description: "Project path (default: current directory)"
+  });
+  async execute() {
+    const targetPath = resolve3(this.projectPath || process.cwd());
+    const manager = new SessionManager(targetPath);
+    const state = manager.get();
+    if (this.json) {
+      console.log(JSON.stringify(state || { message: "No session found" }, null, 2));
+      return 0;
     }
-  ];
-}
+    if (!state) {
+      console.log(chalk14.dim("No active session found."));
+      console.log(chalk14.dim('Run a skill with "skillkit run <skill>" to start a session.'));
+      return 0;
+    }
+    if (state.currentExecution) {
+      const exec = state.currentExecution;
+      const statusColor = exec.status === "paused" ? chalk14.yellow : chalk14.green;
+      console.log(chalk14.cyan("Current Execution:\n"));
+      console.log(`  Skill: ${chalk14.bold(exec.skillName)}`);
+      console.log(`  Source: ${chalk14.dim(exec.skillSource)}`);
+      console.log(`  Status: ${statusColor(exec.status)}`);
+      console.log(`  Progress: ${exec.currentStep}/${exec.totalSteps} tasks`);
+      console.log(`  Started: ${chalk14.dim(new Date(exec.startedAt).toLocaleString())}`);
+      if (exec.pausedAt) {
+        console.log(`  Paused: ${chalk14.dim(new Date(exec.pausedAt).toLocaleString())}`);
+      }
+      console.log(chalk14.cyan("\n  Tasks:"));
+      for (const task of exec.tasks) {
+        const statusIcon = this.getStatusIcon(task.status);
+        const statusText = this.getStatusColor(task.status)(task.status);
+        console.log(`    ${statusIcon} ${task.name} - ${statusText}`);
+        if (task.error) {
+          console.log(`      ${chalk14.red("Error:")} ${task.error}`);
+        }
+      }
+      if (exec.status === "paused") {
+        console.log(chalk14.yellow("\n  Resume with: skillkit resume"));
+      }
+    } else {
+      console.log(chalk14.dim("No active execution."));
+    }
+    if (this.history || !state.currentExecution && state.history.length > 0) {
+      const limit = this.limit ? parseInt(this.limit, 10) : 10;
+      const history = manager.getHistory(limit);
+      if (history.length > 0) {
+        console.log(chalk14.cyan("\nExecution History:\n"));
+        for (const entry of history) {
+          const statusColor = entry.status === "completed" ? chalk14.green : chalk14.red;
+          const duration = this.formatDuration(entry.durationMs);
+          console.log(`  ${statusColor("\u25CF")} ${chalk14.bold(entry.skillName)}`);
+          console.log(`    ${chalk14.dim(entry.skillSource)} \u2022 ${duration}`);
+          console.log(`    ${chalk14.dim(new Date(entry.completedAt).toLocaleString())}`);
+          if (entry.commits.length > 0) {
+            console.log(`    Commits: ${chalk14.dim(entry.commits.join(", "))}`);
+          }
+          if (entry.error) {
+            console.log(`    ${chalk14.red("Error:")} ${entry.error}`);
+          }
+          console.log();
+        }
+      }
+    }
+    if (state.decisions.length > 0) {
+      console.log(chalk14.cyan("Saved Decisions:\n"));
+      for (const decision of state.decisions.slice(0, 5)) {
+        console.log(`  ${chalk14.dim(decision.key)}: ${decision.value}`);
+      }
+      if (state.decisions.length > 5) {
+        console.log(chalk14.dim(`  ... and ${state.decisions.length - 5} more`));
+      }
+    }
+    return 0;
+  }
+  getStatusIcon(status) {
+    switch (status) {
+      case "completed":
+        return chalk14.green("\u2713");
+      case "failed":
+        return chalk14.red("\u2717");
+      case "in_progress":
+        return chalk14.blue("\u25CF");
+      case "paused":
+        return chalk14.yellow("\u23F8");
+      default:
+        return chalk14.dim("\u25CB");
+    }
+  }
+  getStatusColor(status) {
+    switch (status) {
+      case "completed":
+        return chalk14.green;
+      case "failed":
+        return chalk14.red;
+      case "in_progress":
+        return chalk14.blue;
+      case "paused":
+        return chalk14.yellow;
+      default:
+        return chalk14.dim;
+    }
+  }
+  formatDuration(ms) {
+    if (ms < 1e3) return `${ms}ms`;
+    if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+    const minutes = Math.floor(ms / 6e4);
+    const seconds = Math.floor(ms % 6e4 / 1e3);
+    return `${minutes}m ${seconds}s`;
+  }
+};
+
+// src/commands/pause.ts
+import { Command as Command16, Option as Option15 } from "clipanion";
+import { resolve as resolve4 } from "path";
+import chalk15 from "chalk";
+import { SessionManager as SessionManager2 } from "@skillkit/core";
+var PauseCommand = class extends Command16 {
+  static paths = [["pause"]];
+  static usage = Command16.Usage({
+    description: "Pause current skill execution for later resumption",
+    details: `
+      The pause command saves the current execution state so you can
+      continue later with "skillkit resume".
+
+      This is useful when you need to:
+      - Take a break from a long skill execution
+      - Handle an interruption
+      - Review progress before continuing
+    `,
+    examples: [
+      ["Pause current execution", "$0 pause"]
+    ]
+  });
+  // Project path
+  projectPath = Option15.String("--path,-p", {
+    description: "Project path (default: current directory)"
+  });
+  async execute() {
+    const targetPath = resolve4(this.projectPath || process.cwd());
+    const manager = new SessionManager2(targetPath);
+    const state = manager.get();
+    if (!state) {
+      console.log(chalk15.yellow("No active session found."));
+      return 1;
+    }
+    if (!state.currentExecution) {
+      console.log(chalk15.yellow("No skill execution in progress."));
+      return 1;
+    }
+    if (state.currentExecution.status === "paused") {
+      console.log(chalk15.yellow("Execution is already paused."));
+      console.log(chalk15.dim("Resume with: skillkit resume"));
+      return 0;
+    }
+    const success = manager.pause();
+    if (success) {
+      const exec = state.currentExecution;
+      console.log(chalk15.green("\u2713 Execution paused"));
+      console.log();
+      console.log(`  Skill: ${chalk15.bold(exec.skillName)}`);
+      console.log(`  Progress: ${exec.currentStep}/${exec.totalSteps} tasks completed`);
+      console.log();
+      console.log(chalk15.dim("Resume with: skillkit resume"));
+      console.log(chalk15.dim("View status: skillkit status"));
+      return 0;
+    } else {
+      console.log(chalk15.red("Failed to pause execution."));
+      return 1;
+    }
+  }
+};
+
+// src/commands/resume.ts
+import { Command as Command17, Option as Option16 } from "clipanion";
+import { resolve as resolve5 } from "path";
+import chalk16 from "chalk";
+import { SessionManager as SessionManager3 } from "@skillkit/core";
+var ResumeCommand = class extends Command17 {
+  static paths = [["resume"]];
+  static usage = Command17.Usage({
+    description: "Resume a paused skill execution",
+    details: `
+      The resume command continues a previously paused skill execution
+      from where it left off.
+
+      The execution state is preserved, including:
+      - Completed tasks
+      - User decisions
+      - Modified files
+    `,
+    examples: [
+      ["Resume paused execution", "$0 resume"]
+    ]
+  });
+  // Project path
+  projectPath = Option16.String("--path,-p", {
+    description: "Project path (default: current directory)"
+  });
+  async execute() {
+    const targetPath = resolve5(this.projectPath || process.cwd());
+    const manager = new SessionManager3(targetPath);
+    const state = manager.get();
+    if (!state) {
+      console.log(chalk16.yellow("No active session found."));
+      return 1;
+    }
+    if (!state.currentExecution) {
+      console.log(chalk16.yellow("No skill execution to resume."));
+      console.log(chalk16.dim("Start a new execution with: skillkit run <skill>"));
+      return 1;
+    }
+    if (state.currentExecution.status !== "paused") {
+      if (state.currentExecution.status === "running") {
+        console.log(chalk16.yellow("Execution is already running."));
+      } else {
+        console.log(chalk16.yellow(`Execution is ${state.currentExecution.status}.`));
+      }
+      return 1;
+    }
+    const success = manager.resume();
+    if (success) {
+      const exec = state.currentExecution;
+      console.log(chalk16.green("\u2713 Execution resumed"));
+      console.log();
+      console.log(`  Skill: ${chalk16.bold(exec.skillName)}`);
+      console.log(`  Progress: ${exec.currentStep}/${exec.totalSteps} tasks`);
+      console.log();
+      const nextTask = exec.tasks.find((t) => t.status === "pending" || t.status === "in_progress");
+      if (nextTask) {
+        console.log(`  Next task: ${chalk16.cyan(nextTask.name)}`);
+      }
+      console.log();
+      console.log(chalk16.dim("The execution will continue from where it left off."));
+      console.log(chalk16.dim("View status: skillkit status"));
+      return 0;
+    } else {
+      console.log(chalk16.red("Failed to resume execution."));
+      return 1;
+    }
+  }
+};
+
+// src/commands/workflow/run.ts
+import { Command as Command18, Option as Option17 } from "clipanion";
+import { resolve as resolve6 } from "path";
+import chalk17 from "chalk";
+import ora4 from "ora";
+import {
+  loadWorkflowByName,
+  loadWorkflow,
+  validateWorkflow,
+  createWorkflowOrchestrator,
+  createSkillExecutor,
+  createSimulatedSkillExecutor
+} from "@skillkit/core";
+var WorkflowRunCommand = class extends Command18 {
+  static paths = [["workflow", "run"], ["wf", "run"]];
+  static usage = Command18.Usage({
+    description: "Execute a skill workflow",
+    details: `
+      The workflow run command executes a workflow definition,
+      running skills in waves with parallel or sequential execution.
+
+      Workflows are defined in YAML files in .skillkit/workflows/
+    `,
+    examples: [
+      ["Run a workflow by name", "$0 workflow run setup-project"],
+      ["Run a workflow from file", "$0 workflow run --file my-workflow.yaml"],
+      ["Dry run (no execution)", "$0 workflow run setup-project --dry-run"]
+    ]
+  });
+  // Workflow name
+  workflowName = Option17.String({ required: false });
+  // Workflow file path
+  file = Option17.String("--file,-f", {
+    description: "Path to workflow YAML file"
+  });
+  // Dry run
+  dryRun = Option17.Boolean("--dry-run,-n", false, {
+    description: "Show what would be executed without running"
+  });
+  // Verbose output
+  verbose = Option17.Boolean("--verbose,-v", false, {
+    description: "Show detailed execution progress"
+  });
+  // Continue on error
+  continueOnError = Option17.Boolean("--continue-on-error", false, {
+    description: "Continue execution even if a skill fails"
+  });
+  // JSON output
+  json = Option17.Boolean("--json,-j", false, {
+    description: "Output in JSON format"
+  });
+  // Project path
+  projectPath = Option17.String("--path,-p", {
+    description: "Project path (default: current directory)"
+  });
+  // Agent to use for execution
+  agent = Option17.String("--agent,-a", {
+    description: "Agent to use for skill execution (e.g., claude-code, codex)"
+  });
+  // Simulate execution (for testing)
+  simulate = Option17.Boolean("--simulate", false, {
+    description: "Simulate execution without running skills (for testing)"
+  });
+  async execute() {
+    const targetPath = resolve6(this.projectPath || process.cwd());
+    let workflow;
+    try {
+      if (this.file) {
+        workflow = loadWorkflow(resolve6(this.file));
+      } else if (this.workflowName) {
+        workflow = loadWorkflowByName(targetPath, this.workflowName);
+        if (!workflow) {
+          console.error(chalk17.red(`Workflow "${this.workflowName}" not found`));
+          console.log(chalk17.dim("List available workflows: skillkit workflow list"));
+          return 1;
+        }
+      } else {
+        console.error(chalk17.red("Please specify a workflow name or --file"));
+        return 1;
+      }
+    } catch (error) {
+      console.error(chalk17.red(`Failed to load workflow: ${error}`));
+      return 1;
+    }
+    const validation = validateWorkflow(workflow);
+    if (!validation.valid) {
+      console.error(chalk17.red("Invalid workflow:"));
+      for (const error of validation.errors) {
+        console.error(chalk17.red(`  \u2022 ${error}`));
+      }
+      return 1;
+    }
+    if (this.dryRun) {
+      this.showDryRun(workflow);
+      return 0;
+    }
+    console.log(chalk17.cyan(`Executing workflow: ${chalk17.bold(workflow.name)}`));
+    if (workflow.description) {
+      console.log(chalk17.dim(workflow.description));
+    }
+    console.log();
+    const spinner = ora4();
+    let currentWave = -1;
+    const skillExecutor = this.simulate ? createSimulatedSkillExecutor({
+      delay: 500,
+      onExecute: (skillName) => {
+        if (this.verbose && !this.json) {
+          console.log(chalk17.dim(`  [Simulated] ${skillName}`));
+        }
+      }
+    }) : createSkillExecutor({
+      projectPath: targetPath,
+      preferredAgent: this.agent,
+      fallbackToAvailable: true,
+      onExecutionEvent: (event) => {
+        if (this.verbose && !this.json) {
+          switch (event.type) {
+            case "skill_found":
+              console.log(chalk17.dim(`  Found: ${event.message}`));
+              break;
+            case "skill_not_found":
+              console.log(chalk17.red(`  Not found: ${event.skillName}`));
+              break;
+            case "agent_selected":
+              console.log(chalk17.dim(`  Agent: ${event.agent}`));
+              break;
+            case "execution_complete":
+              if (!event.success) {
+                console.log(chalk17.red(`  Error: ${event.error}`));
+              }
+              break;
+          }
+        }
+      }
+    });
+    const orchestrator = createWorkflowOrchestrator(
+      skillExecutor,
+      (event) => {
+        if (this.json) return;
+        switch (event.type) {
+          case "wave_start":
+            currentWave = event.waveIndex || 0;
+            spinner.start(`Wave ${currentWave + 1}: ${event.waveName || "Executing..."}`);
+            break;
+          case "skill_start":
+            if (this.verbose) {
+              spinner.text = `Wave ${currentWave + 1}: Running ${event.skillName}...`;
+            }
+            break;
+          case "skill_complete":
+            if (this.verbose) {
+              const icon = event.status === "completed" ? chalk17.green("\u2713") : chalk17.red("\u2717");
+              console.log(`  ${icon} ${event.skillName}`);
+            }
+            break;
+          case "wave_complete":
+            const waveIcon = event.status === "completed" ? chalk17.green("\u2713") : chalk17.red("\u2717");
+            spinner.stopAndPersist({
+              symbol: waveIcon,
+              text: `Wave ${(event.waveIndex || 0) + 1}: ${event.waveName || "Complete"}`
+            });
+            break;
+          case "workflow_complete":
+            console.log();
+            if (event.status === "completed") {
+              console.log(chalk17.green("\u2713 Workflow completed successfully"));
+            } else {
+              console.log(chalk17.red(`\u2717 Workflow ${event.status}`));
+              if (event.error) {
+                console.log(chalk17.red(`  Error: ${event.error}`));
+              }
+            }
+            break;
+        }
+      }
+    );
+    const execution = await orchestrator.execute(workflow);
+    if (this.json) {
+      console.log(JSON.stringify(execution, null, 2));
+    }
+    return execution.status === "completed" ? 0 : 1;
+  }
+  showDryRun(workflow) {
+    console.log(chalk17.cyan("Dry Run - Workflow Execution Plan"));
+    console.log();
+    console.log(`Workflow: ${chalk17.bold(workflow.name)}`);
+    if (workflow.description) {
+      console.log(`Description: ${chalk17.dim(workflow.description)}`);
+    }
+    console.log();
+    for (let i = 0; i < workflow.waves.length; i++) {
+      const wave = workflow.waves[i];
+      const modeLabel = wave.parallel ? chalk17.blue("[parallel]") : chalk17.yellow("[sequential]");
+      console.log(`${chalk17.cyan(`Wave ${i + 1}`)}: ${wave.name || "Unnamed"} ${modeLabel}`);
+      for (const skill of wave.skills) {
+        const skillName = typeof skill === "string" ? skill : skill.skill;
+        console.log(`  \u2022 ${skillName}`);
+      }
+      console.log();
+    }
+    console.log(chalk17.dim("This is a dry run. No skills were executed."));
+    console.log(chalk17.dim("Remove --dry-run to execute the workflow."));
+  }
+};
+
+// src/commands/workflow/list.ts
+import { Command as Command19, Option as Option18 } from "clipanion";
+import { resolve as resolve7 } from "path";
+import chalk18 from "chalk";
+import { listWorkflows } from "@skillkit/core";
+var WorkflowListCommand = class extends Command19 {
+  static paths = [["workflow", "list"], ["wf", "list"], ["workflow", "ls"], ["wf", "ls"]];
+  static usage = Command19.Usage({
+    description: "List available workflows",
+    details: `
+      The workflow list command shows all available workflows
+      defined in .skillkit/workflows/
+    `,
+    examples: [
+      ["List all workflows", "$0 workflow list"],
+      ["List with details", "$0 workflow list --verbose"]
+    ]
+  });
+  // Verbose output
+  verbose = Option18.Boolean("--verbose,-v", false, {
+    description: "Show detailed workflow information"
+  });
+  // JSON output
+  json = Option18.Boolean("--json,-j", false, {
+    description: "Output in JSON format"
+  });
+  // Project path
+  projectPath = Option18.String("--path,-p", {
+    description: "Project path (default: current directory)"
+  });
+  async execute() {
+    const targetPath = resolve7(this.projectPath || process.cwd());
+    let workflows;
+    try {
+      workflows = listWorkflows(targetPath);
+    } catch (err) {
+      console.log(chalk18.red("Failed to list workflows."));
+      console.log(chalk18.dim(String(err)));
+      return 1;
+    }
+    if (this.json) {
+      console.log(JSON.stringify(workflows, null, 2));
+      return 0;
+    }
+    if (workflows.length === 0) {
+      console.log(chalk18.yellow("No workflows found."));
+      console.log(chalk18.dim("Create a workflow with: skillkit workflow create"));
+      console.log(chalk18.dim("Or add YAML files to .skillkit/workflows/"));
+      return 0;
+    }
+    console.log(chalk18.cyan(`Available Workflows (${workflows.length}):
+`));
+    for (const workflow of workflows) {
+      console.log(`  ${chalk18.bold(workflow.name)}`);
+      if (workflow.description) {
+        console.log(`    ${chalk18.dim(workflow.description)}`);
+      }
+      if (this.verbose) {
+        console.log(`    Version: ${chalk18.dim(workflow.version || "N/A")}`);
+        console.log(`    Waves: ${chalk18.dim(workflow.waves.length.toString())}`);
+        const totalSkills = workflow.waves.reduce(
+          (sum, wave) => sum + wave.skills.length,
+          0
+        );
+        console.log(`    Total Skills: ${chalk18.dim(totalSkills.toString())}`);
+        if (workflow.tags && workflow.tags.length > 0) {
+          console.log(`    Tags: ${chalk18.dim(workflow.tags.join(", "))}`);
+        }
+      }
+      console.log();
+    }
+    console.log(chalk18.dim("Run a workflow with: skillkit workflow run <name>"));
+    return 0;
+  }
+};
+
+// src/commands/workflow/create.ts
+import { Command as Command20, Option as Option19 } from "clipanion";
+import { resolve as resolve8 } from "path";
+import chalk19 from "chalk";
+import { createWorkflowTemplate, saveWorkflow, serializeWorkflow } from "@skillkit/core";
+var WorkflowCreateCommand = class extends Command20 {
+  static paths = [["workflow", "create"], ["wf", "create"], ["workflow", "new"], ["wf", "new"]];
+  static usage = Command20.Usage({
+    description: "Create a new workflow",
+    details: `
+      The workflow create command creates a new workflow template
+      that you can customize with your skill composition.
+    `,
+    examples: [
+      ["Create a new workflow", "$0 workflow create my-workflow"],
+      ["Create with description", '$0 workflow create setup-project --description "Project setup workflow"'],
+      ["Print to stdout", "$0 workflow create my-workflow --stdout"]
+    ]
+  });
+  // Workflow name
+  workflowName = Option19.String({ required: true });
+  // Description
+  description = Option19.String("--description,-d", {
+    description: "Workflow description"
+  });
+  // Print to stdout instead of saving
+  stdout = Option19.Boolean("--stdout", false, {
+    description: "Print workflow YAML to stdout instead of saving"
+  });
+  // Project path
+  projectPath = Option19.String("--path,-p", {
+    description: "Project path (default: current directory)"
+  });
+  async execute() {
+    const targetPath = resolve8(this.projectPath || process.cwd());
+    const workflow = createWorkflowTemplate(this.workflowName, this.description);
+    if (this.stdout) {
+      console.log(serializeWorkflow(workflow));
+      return 0;
+    }
+    const filePath = saveWorkflow(targetPath, workflow);
+    console.log(chalk19.green(`\u2713 Created workflow: ${chalk19.bold(this.workflowName)}`));
+    console.log(chalk19.dim(`  File: ${filePath}`));
+    console.log();
+    console.log(chalk19.dim("Edit the workflow file to add skills and configure waves."));
+    console.log(chalk19.dim("Run with: skillkit workflow run " + this.workflowName));
+    return 0;
+  }
+};
+
+// src/commands/run.ts
+import { Command as Command21, Option as Option20 } from "clipanion";
+import { resolve as resolve9, join as join6 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync4, statSync } from "fs";
+import chalk20 from "chalk";
+import ora5 from "ora";
+import {
+  createExecutionEngine,
+  discoverSkills,
+  extractFrontmatter
+} from "@skillkit/core";
+var RunCommand = class extends Command21 {
+  static paths = [["run"]];
+  static usage = Command21.Usage({
+    description: "Execute a skill with task-based orchestration",
+    details: `
+      The run command executes a skill, optionally breaking it down into
+      tasks with verification checkpoints.
+
+      Skills can be:
+      - Installed skills (by name)
+      - Local skill files (by path)
+      - Remote skills (owner/repo/path)
+    `,
+    examples: [
+      ["Run an installed skill", "$0 run typescript-strict-mode"],
+      ["Run a local skill file", "$0 run ./my-skill/SKILL.md"],
+      ["Dry run (show what would happen)", "$0 run typescript-strict-mode --dry-run"],
+      ["Run with verification", "$0 run setup-testing --verify"]
+    ]
+  });
+  // Skill name or path
+  skillRef = Option20.String({ required: true });
+  // Target agent
+  agent = Option20.String("--agent,-a", {
+    description: "Target agent (claude-code, cursor, etc.)"
+  });
+  // Dry run
+  dryRun = Option20.Boolean("--dry-run,-n", false, {
+    description: "Show what would be executed without running"
+  });
+  // Enable verification
+  verify = Option20.Boolean("--verify", false, {
+    description: "Run verification checks after each task"
+  });
+  // Auto-commit
+  autoCommit = Option20.Boolean("--auto-commit", false, {
+    description: "Create git commits after each task"
+  });
+  // Continue on error
+  continueOnError = Option20.Boolean("--continue-on-error", false, {
+    description: "Continue execution even if a task fails"
+  });
+  // Verbose output
+  verbose = Option20.Boolean("--verbose,-v", false, {
+    description: "Show detailed execution progress"
+  });
+  // JSON output
+  json = Option20.Boolean("--json,-j", false, {
+    description: "Output in JSON format"
+  });
+  // Project path
+  projectPath = Option20.String("--path,-p", {
+    description: "Project path (default: current directory)"
+  });
+  async execute() {
+    const targetPath = resolve9(this.projectPath || process.cwd());
+    const skill = await this.loadSkill(targetPath);
+    if (!skill) {
+      return 1;
+    }
+    if (!this.json) {
+      console.log(chalk20.cyan(`Executing skill: ${chalk20.bold(skill.name)}`));
+      if (skill.description) {
+        console.log(chalk20.dim(skill.description));
+      }
+      console.log();
+    }
+    if (this.dryRun) {
+      this.showDryRun(skill);
+      return 0;
+    }
+    const spinner = ora5();
+    let currentTask = "";
+    const engine = createExecutionEngine(targetPath, {
+      onProgress: (event) => {
+        if (this.json) return;
+        switch (event.type) {
+          case "task_start":
+            currentTask = event.taskName || "";
+            spinner.start(`Task ${(event.taskIndex || 0) + 1}/${event.totalTasks}: ${currentTask}`);
+            break;
+          case "task_complete":
+            const icon = event.status === "completed" ? chalk20.green("\u2713") : chalk20.red("\u2717");
+            spinner.stopAndPersist({
+              symbol: icon,
+              text: `Task ${(event.taskIndex || 0) + 1}/${event.totalTasks}: ${currentTask}`
+            });
+            if (event.error && this.verbose) {
+              console.log(chalk20.red(`    Error: ${event.error}`));
+            }
+            break;
+          case "checkpoint":
+            spinner.info(`Checkpoint: ${event.message}`);
+            break;
+          case "verification":
+            if (this.verbose) {
+              console.log(chalk20.dim(`    ${event.message}`));
+            }
+            break;
+          case "complete":
+            console.log();
+            if (event.status === "completed") {
+              console.log(chalk20.green("\u2713 Skill execution completed"));
+            } else {
+              console.log(chalk20.red(`\u2717 Skill execution ${event.status}`));
+              if (event.error) {
+                console.log(chalk20.red(`  Error: ${event.error}`));
+              }
+            }
+            break;
+        }
+      },
+      checkpointHandler: async (task, _context) => {
+        if (task.type === "checkpoint:decision" && task.options) {
+          return {
+            continue: true,
+            selectedOption: task.options[0]
+          };
+        }
+        return { continue: true };
+      }
+    });
+    const result = await engine.execute(skill, {
+      agent: this.agent,
+      autoCommit: this.autoCommit,
+      verify: this.verify,
+      continueOnError: this.continueOnError
+    });
+    if (this.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log();
+      console.log(chalk20.cyan("Summary:"));
+      console.log(`  Duration: ${chalk20.dim(this.formatDuration(result.durationMs || 0))}`);
+      console.log(`  Tasks: ${chalk20.dim(`${result.tasks.filter((t) => t.status === "completed").length}/${result.tasks.length} completed`)}`);
+      if (result.filesModified.length > 0) {
+        console.log(`  Files modified: ${chalk20.dim(result.filesModified.length.toString())}`);
+      }
+      if (result.commits.length > 0) {
+        console.log(`  Commits: ${chalk20.dim(result.commits.join(", "))}`);
+      }
+    }
+    return result.status === "completed" ? 0 : 1;
+  }
+  async loadSkill(projectPath) {
+    if (this.skillRef.endsWith(".md") || existsSync9(this.skillRef) && statSync(this.skillRef).isFile()) {
+      return this.loadSkillFromFile(resolve9(this.skillRef));
+    }
+    const skill = this.findInstalledSkill(projectPath, this.skillRef);
+    if (skill) {
+      return skill;
+    }
+    console.error(chalk20.red(`Skill "${this.skillRef}" not found`));
+    console.log(chalk20.dim("Install skills with: skillkit install <source>"));
+    return null;
+  }
+  loadSkillFromFile(filePath) {
+    if (!existsSync9(filePath)) {
+      console.error(chalk20.red(`File not found: ${filePath}`));
+      return null;
+    }
+    try {
+      const content = readFileSync4(filePath, "utf-8");
+      const frontmatter = extractFrontmatter(content);
+      const tasks = this.parseTasksFromFrontmatter(frontmatter);
+      return {
+        name: frontmatter?.name || this.skillRef,
+        description: frontmatter?.description,
+        version: frontmatter?.version,
+        source: filePath,
+        content,
+        tasks
+      };
+    } catch (error) {
+      console.error(chalk20.red(`Failed to load skill: ${error}`));
+      return null;
+    }
+  }
+  findInstalledSkill(projectPath, skillName) {
+    const skillDirs = [
+      join6(projectPath, ".claude", "skills"),
+      join6(projectPath, ".cursor", "skills"),
+      join6(projectPath, "skills"),
+      join6(projectPath, ".skillkit", "skills")
+    ];
+    for (const dir of skillDirs) {
+      if (!existsSync9(dir)) continue;
+      const skills = discoverSkills(dir);
+      const skill = skills.find((s) => s.name === skillName);
+      if (skill) {
+        const skillMdPath = join6(skill.path, "SKILL.md");
+        if (existsSync9(skillMdPath)) {
+          return this.loadSkillFromFile(skillMdPath);
+        }
+      }
+    }
+    return null;
+  }
+  parseTasksFromFrontmatter(frontmatter) {
+    if (!frontmatter?.tasks || !Array.isArray(frontmatter.tasks)) {
+      return void 0;
+    }
+    return frontmatter.tasks.map((task, index) => ({
+      id: task.id || `task-${index}`,
+      name: task.name || `Task ${index + 1}`,
+      type: task.type || "auto",
+      action: task.action || "",
+      files: task.files,
+      options: task.options,
+      verify: task.verify
+    }));
+  }
+  showDryRun(skill) {
+    console.log(chalk20.cyan("Dry Run - Execution Plan"));
+    console.log();
+    console.log(`Skill: ${chalk20.bold(skill.name)}`);
+    if (skill.description) {
+      console.log(`Description: ${chalk20.dim(skill.description)}`);
+    }
+    console.log(`Source: ${chalk20.dim(skill.source)}`);
+    console.log();
+    if (skill.tasks && skill.tasks.length > 0) {
+      console.log(chalk20.cyan("Tasks:"));
+      for (let i = 0; i < skill.tasks.length; i++) {
+        const task = skill.tasks[i];
+        const typeLabel = this.getTaskTypeLabel(task.type);
+        console.log(`  ${i + 1}. ${task.name} ${typeLabel}`);
+        if (task.action) {
+          console.log(`     ${chalk20.dim(task.action)}`);
+        }
+        if (task.files && task.files.length > 0) {
+          console.log(`     Files: ${chalk20.dim(task.files.join(", "))}`);
+        }
+      }
+    } else {
+      console.log(chalk20.dim("No structured tasks defined. Skill will be executed as a single unit."));
+    }
+    console.log();
+    console.log(chalk20.dim("This is a dry run. Remove --dry-run to execute."));
+  }
+  getTaskTypeLabel(type) {
+    switch (type) {
+      case "auto":
+        return chalk20.green("[auto]");
+      case "checkpoint:human-verify":
+        return chalk20.yellow("[verify]");
+      case "checkpoint:decision":
+        return chalk20.blue("[decision]");
+      case "checkpoint:human-action":
+        return chalk20.magenta("[manual]");
+      default:
+        return "";
+    }
+  }
+  formatDuration(ms) {
+    if (ms < 1e3) return `${ms}ms`;
+    if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+    const minutes = Math.floor(ms / 6e4);
+    const seconds = Math.floor(ms % 6e4 / 1e3);
+    return `${minutes}m ${seconds}s`;
+  }
+};
+
+// src/commands/test.ts
+import { Command as Command22, Option as Option21 } from "clipanion";
+import { resolve as resolve10, join as join7 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync5, readdirSync as readdirSync2 } from "fs";
+import chalk21 from "chalk";
+import {
+  runTestSuite,
+  createTestSuiteFromFrontmatter
+} from "@skillkit/core";
+import { parse as parseYaml } from "yaml";
+var TestCommand = class extends Command22 {
+  static paths = [["test"]];
+  static usage = Command22.Usage({
+    description: "Run skill tests",
+    details: `
+      The test command runs test cases defined in skill frontmatter.
+
+      Tests are defined in the skill's YAML frontmatter using the 'tests' key.
+
+      Example skill with tests:
+      \`\`\`yaml
+      ---
+      name: my-skill
+      tests:
+        - name: "Creates config file"
+          assertions:
+            - type: file_exists
+              target: config.json
+        - name: "Types check"
+          assertions:
+            - type: type_check
+      ---
+      \`\`\`
+    `,
+    examples: [
+      ["Run all skill tests", "$0 test"],
+      ["Run tests for a specific skill", "$0 test my-skill"],
+      ["Run with verbose output", "$0 test --verbose"],
+      ["Stop on first failure", "$0 test --bail"],
+      ["Run tests with specific tags", "$0 test --tags unit,integration"]
+    ]
+  });
+  skill = Option21.String({ required: false });
+  verbose = Option21.Boolean("--verbose,-v", false, {
+    description: "Verbose output"
+  });
+  bail = Option21.Boolean("--bail,-b", false, {
+    description: "Stop on first failure"
+  });
+  tags = Option21.String("--tags,-t", {
+    description: "Only run tests with these tags (comma-separated)"
+  });
+  skipTags = Option21.String("--skip-tags", {
+    description: "Skip tests with these tags (comma-separated)"
+  });
+  json = Option21.Boolean("--json,-j", false, {
+    description: "Output results as JSON"
+  });
+  projectPath = Option21.String("--path,-p", {
+    description: "Project path"
+  });
+  timeout = Option21.String("--timeout", {
+    description: "Test timeout in milliseconds"
+  });
+  async execute() {
+    const targetPath = resolve10(this.projectPath || process.cwd());
+    const skillFiles = this.findSkillFiles(targetPath);
+    if (skillFiles.length === 0) {
+      if (!this.json) {
+        console.log(chalk21.yellow("No skills found with tests."));
+        console.log(chalk21.dim("Add tests to your skills using YAML frontmatter."));
+      } else {
+        console.log(JSON.stringify({ results: [], passed: true, total: 0 }));
+      }
+      return 0;
+    }
+    const filesToTest = this.skill ? skillFiles.filter((f) => f.name.includes(this.skill)) : skillFiles;
+    if (filesToTest.length === 0) {
+      if (!this.json) {
+        console.log(chalk21.yellow(`No skills found matching "${this.skill}"`));
+      }
+      return 1;
+    }
+    if (!this.json) {
+      console.log(chalk21.bold("Running skill tests...\n"));
+    }
+    const tags = this.tags?.split(",").map((t) => t.trim());
+    const skipTags = this.skipTags?.split(",").map((t) => t.trim());
+    const timeout = this.timeout ? parseInt(this.timeout, 10) : void 0;
+    const results = [];
+    let allPassed = true;
+    for (const file of filesToTest) {
+      const suite = this.parseSkillTests(file.path, file.name);
+      if (!suite || suite.tests.length === 0) {
+        continue;
+      }
+      if (!this.json) {
+        console.log(chalk21.blue(`Testing: ${suite.skillName}`));
+      }
+      const result = await runTestSuite(suite, {
+        cwd: targetPath,
+        verbose: this.verbose,
+        bail: this.bail,
+        tags,
+        skipTags,
+        timeout,
+        onProgress: (event) => {
+          if (this.json || !this.verbose) return;
+          switch (event.type) {
+            case "test_start":
+              console.log(chalk21.dim(`  Running: ${event.testName}`));
+              break;
+            case "test_end":
+              if (event.passed) {
+                console.log(chalk21.green(`  \u2713 ${event.testName}`));
+              } else {
+                console.log(chalk21.red(`  \u2717 ${event.testName}`));
+                if (event.error) {
+                  console.log(chalk21.red(`    ${event.error}`));
+                }
+              }
+              break;
+            case "assertion_end":
+              if (this.verbose && !event.passed) {
+                console.log(chalk21.red(`    - ${event.assertionType}: ${event.error}`));
+              }
+              break;
+          }
+        }
+      });
+      results.push(result);
+      if (!result.passed) {
+        allPassed = false;
+      }
+      if (!this.json) {
+        const icon = result.passed ? chalk21.green("\u2713") : chalk21.red("\u2717");
+        const status = result.passed ? "PASSED" : "FAILED";
+        console.log(
+          `${icon} ${suite.skillName}: ${result.passedCount}/${result.tests.length} tests ${status} (${result.duration}ms)
+`
+        );
+      }
+      if (this.bail && !result.passed) {
+        break;
+      }
+    }
+    if (this.json) {
+      console.log(
+        JSON.stringify({
+          results: results.map((r) => ({
+            skill: r.skillName,
+            passed: r.passed,
+            tests: r.passedCount,
+            failed: r.failedCount,
+            skipped: r.skippedCount,
+            duration: r.duration
+          })),
+          passed: allPassed,
+          total: results.length
+        })
+      );
+    } else {
+      const totalTests = results.reduce((acc, r) => acc + r.tests.length, 0);
+      const passedTests = results.reduce((acc, r) => acc + r.passedCount, 0);
+      const failedTests = results.reduce((acc, r) => acc + r.failedCount, 0);
+      const skippedTests = results.reduce((acc, r) => acc + r.skippedCount, 0);
+      console.log(chalk21.bold("Summary:"));
+      console.log(`  Skills tested: ${results.length}`);
+      console.log(`  Total tests: ${totalTests}`);
+      console.log(chalk21.green(`  Passed: ${passedTests}`));
+      if (failedTests > 0) {
+        console.log(chalk21.red(`  Failed: ${failedTests}`));
+      }
+      if (skippedTests > 0) {
+        console.log(chalk21.yellow(`  Skipped: ${skippedTests}`));
+      }
+      if (allPassed) {
+        console.log(chalk21.green("\n\u2713 All tests passed!"));
+      } else {
+        console.log(chalk21.red("\n\u2717 Some tests failed."));
+      }
+    }
+    return allPassed ? 0 : 1;
+  }
+  /**
+   * Find skill files with tests
+   */
+  findSkillFiles(projectPath) {
+    const files = [];
+    const skillDirs = [
+      ".claude/skills",
+      ".cursor/skills",
+      ".skillkit/skills",
+      "skills"
+    ];
+    for (const dir of skillDirs) {
+      const fullDir = join7(projectPath, dir);
+      if (!existsSync10(fullDir)) continue;
+      try {
+        const entries = readdirSync2(fullDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".mdc"))) {
+            files.push({
+              name: entry.name.replace(/\.(md|mdc)$/, ""),
+              path: join7(fullDir, entry.name)
+            });
+          }
+        }
+      } catch {
+      }
+    }
+    return files;
+  }
+  /**
+   * Parse skill file for tests
+   */
+  parseSkillTests(filePath, skillName) {
+    try {
+      const content = readFileSync5(filePath, "utf-8");
+      const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+      if (!frontmatterMatch) {
+        return null;
+      }
+      const frontmatter = parseYaml(frontmatterMatch[1]);
+      if (!frontmatter.tests) {
+        return null;
+      }
+      return createTestSuiteFromFrontmatter(skillName, frontmatter);
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/commands/marketplace.ts
+import { Command as Command23, Option as Option22 } from "clipanion";
+import chalk22 from "chalk";
+import ora6 from "ora";
+import {
+  createMarketplaceAggregator
+} from "@skillkit/core";
+var MarketplaceCommand = class extends Command23 {
+  static paths = [["marketplace"], ["market"], ["mp"]];
+  static usage = Command23.Usage({
+    description: "Browse and install skills from the marketplace",
+    details: `
+      The marketplace command lets you discover and install skills
+      from curated repositories.
+
+      Skills are aggregated from multiple sources including:
+      - composioHQ/awesome-claude-code-skills
+      - anthropics/courses
+      - User-added custom sources
+    `,
+    examples: [
+      ["Browse marketplace", "$0 marketplace"],
+      ["Search for skills", "$0 marketplace search typescript"],
+      ["Refresh marketplace index", "$0 marketplace refresh"],
+      ["Show popular tags", "$0 marketplace tags"],
+      ["List sources", "$0 marketplace sources"]
+    ]
+  });
+  action = Option22.String({ required: false });
+  query = Option22.String({ required: false });
+  limit = Option22.String("--limit,-l", {
+    description: "Limit results"
+  });
+  tags = Option22.String("--tags,-t", {
+    description: "Filter by tags (comma-separated)"
+  });
+  source = Option22.String("--source,-s", {
+    description: "Filter by source"
+  });
+  json = Option22.Boolean("--json,-j", false, {
+    description: "Output as JSON"
+  });
+  async execute() {
+    const marketplace = createMarketplaceAggregator();
+    switch (this.action) {
+      case "search":
+        return this.searchSkills(marketplace);
+      case "refresh":
+        return this.refreshIndex(marketplace);
+      case "tags":
+        return this.showTags(marketplace);
+      case "sources":
+        return this.showSources(marketplace);
+      default:
+        if (this.query || this.action) {
+          return this.searchSkills(marketplace);
+        }
+        return this.browseMarketplace(marketplace);
+    }
+  }
+  async browseMarketplace(marketplace) {
+    const spinner = ora6("Loading marketplace...").start();
+    try {
+      const index = await marketplace.getIndex();
+      spinner.stop();
+      if (this.json) {
+        console.log(JSON.stringify({
+          totalSkills: index.totalCount,
+          sources: index.sources.length,
+          updatedAt: index.updatedAt
+        }));
+        return 0;
+      }
+      console.log(chalk22.bold("Skill Marketplace\n"));
+      console.log(`Total skills: ${chalk22.cyan(index.totalCount)}`);
+      console.log(`Sources: ${chalk22.cyan(index.sources.length)}`);
+      console.log(`Last updated: ${chalk22.dim(new Date(index.updatedAt).toLocaleString())}
+`);
+      console.log(chalk22.bold("Featured Skills:\n"));
+      const featured = index.skills.slice(0, 10);
+      for (const skill of featured) {
+        console.log(`  ${chalk22.cyan(skill.name)}`);
+        if (skill.description) {
+          console.log(`  ${chalk22.dim(skill.description.slice(0, 60))}${skill.description.length > 60 ? "..." : ""}`);
+        }
+        console.log(`  ${chalk22.dim(`Source: ${skill.source.name}`)}`);
+        console.log();
+      }
+      console.log(chalk22.dim('Use "skillkit marketplace search <query>" to search for skills.'));
+      console.log(chalk22.dim('Use "skillkit marketplace tags" to see popular tags.'));
+      return 0;
+    } catch (error) {
+      spinner.fail("Failed to load marketplace");
+      console.error(chalk22.red(error instanceof Error ? error.message : String(error)));
+      return 1;
+    }
+  }
+  async searchSkills(marketplace) {
+    const query = this.query || this.action;
+    let limit = 20;
+    if (this.limit) {
+      const parsed = parseInt(this.limit, 10);
+      if (isNaN(parsed) || parsed <= 0) {
+        console.error(chalk22.red("Invalid --limit value. Must be a positive number."));
+        return 1;
+      }
+      limit = parsed;
+    }
+    const tags = this.tags?.split(",").map((t) => t.trim()).filter((t) => t.length > 0);
+    const spinner = ora6(`Searching for "${query}"...`).start();
+    try {
+      const options = {
+        query: query || void 0,
+        limit,
+        tags: tags && tags.length > 0 ? tags : void 0,
+        source: this.source
+      };
+      const result = await marketplace.search(options);
+      spinner.stop();
+      if (this.json) {
+        console.log(JSON.stringify(result));
+        return 0;
+      }
+      if (result.skills.length === 0) {
+        console.log(chalk22.yellow(`No skills found${query ? ` matching "${query}"` : ""}.`));
+        return 0;
+      }
+      console.log(chalk22.bold(`Found ${result.total} skill(s):
+`));
+      for (const skill of result.skills) {
+        console.log(`${chalk22.cyan(skill.name)} ${chalk22.dim(`(${skill.source.name})`)}`);
+        if (skill.description) {
+          console.log(`  ${skill.description}`);
+        }
+        if (skill.tags.length > 0) {
+          console.log(`  Tags: ${chalk22.dim(skill.tags.join(", "))}`);
+        }
+        console.log();
+      }
+      if (result.total > result.skills.length) {
+        console.log(chalk22.dim(`Showing ${result.skills.length} of ${result.total} results. Use --limit to see more.`));
+      }
+      return 0;
+    } catch (error) {
+      spinner.fail("Search failed");
+      console.error(chalk22.red(error instanceof Error ? error.message : String(error)));
+      return 1;
+    }
+  }
+  async refreshIndex(marketplace) {
+    const spinner = ora6("Refreshing marketplace index...").start();
+    try {
+      const index = await marketplace.refresh();
+      spinner.succeed(`Marketplace refreshed: ${index.totalCount} skills from ${index.sources.length} sources`);
+      return 0;
+    } catch (error) {
+      spinner.fail("Refresh failed");
+      console.error(chalk22.red(error instanceof Error ? error.message : String(error)));
+      return 1;
+    }
+  }
+  async showTags(marketplace) {
+    const spinner = ora6("Loading tags...").start();
+    try {
+      const tags = await marketplace.getPopularTags(30);
+      spinner.stop();
+      if (this.json) {
+        console.log(JSON.stringify(tags));
+        return 0;
+      }
+      console.log(chalk22.bold("Popular Tags:\n"));
+      for (const { tag, count } of tags) {
+        const bar = "\u2588".repeat(Math.min(count, 20));
+        console.log(`  ${tag.padEnd(15)} ${chalk22.cyan(bar)} ${count}`);
+      }
+      return 0;
+    } catch (error) {
+      spinner.fail("Failed to load tags");
+      console.error(chalk22.red(error instanceof Error ? error.message : String(error)));
+      return 1;
+    }
+  }
+  async showSources(marketplace) {
+    const sources = marketplace.getSources();
+    if (this.json) {
+      console.log(JSON.stringify(sources));
+      return 0;
+    }
+    console.log(chalk22.bold("Skill Sources:\n"));
+    for (const source of sources) {
+      console.log(`${chalk22.cyan(source.name)} ${source.official ? chalk22.green("(official)") : ""}`);
+      console.log(`  ${chalk22.dim(`${source.owner}/${source.repo}`)}`);
+      if (source.description) {
+        console.log(`  ${source.description}`);
+      }
+      console.log();
+    }
+    return 0;
+  }
+};
+
+// src/commands/memory.ts
+import { Command as Command24, Option as Option23 } from "clipanion";
+import chalk23 from "chalk";
+import {
+  ObservationStore,
+  LearningStore,
+  getMemoryPaths,
+  initializeMemoryDirectory,
+  getMemoryStatus,
+  createMemoryCompressor,
+  createMemoryInjector
+} from "@skillkit/core";
+var MemoryCommand = class extends Command24 {
+  static paths = [["memory"], ["mem"]];
+  static usage = Command24.Usage({
+    description: "Manage session memory across AI coding agents",
+    details: `
+      The memory command helps you view, search, and manage learnings
+      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
+    `,
+    examples: [
+      ["Show memory status", "$0 memory status"],
+      ["Search memories", '$0 memory search "authentication"'],
+      ["Search global memories", '$0 memory search --global "react hooks"'],
+      ["List project learnings", "$0 memory list"],
+      ["List global learnings", "$0 memory list --global"],
+      ["Show a learning", "$0 memory show <id>"],
+      ["Compress observations", "$0 memory compress"],
+      ["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"]
+    ]
+  });
+  // Subcommand (status, search, list, show, compress, export, import, clear, add, rate, config)
+  action = Option23.String({ required: false });
+  // Second argument (query for search, id for show/export/rate)
+  arg = Option23.String({ required: false });
+  // Third argument (rating value for rate command)
+  ratingArg = Option23.String({ required: false });
+  // Global scope
+  global = Option23.Boolean("--global,-g", false, {
+    description: "Use global memories instead of project"
+  });
+  // Tags filter
+  tags = Option23.String("--tags,-t", {
+    description: "Filter by tags (comma-separated)"
+  });
+  // Limit results
+  limit = Option23.String("--limit,-l", {
+    description: "Maximum number of results"
+  });
+  // Title for add
+  title = Option23.String("--title", {
+    description: "Title for new learning"
+  });
+  // Content for add
+  content = Option23.String("--content,-c", {
+    description: "Content for new learning"
+  });
+  // Name for export
+  name = Option23.String("--name,-n", {
+    description: "Name for exported skill"
+  });
+  // Output file
+  output = Option23.String("--output,-o", {
+    description: "Output file path"
+  });
+  // Input file
+  input = Option23.String("--input,-i", {
+    description: "Input file path"
+  });
+  // Keep learnings when clearing
+  keepLearnings = Option23.Boolean("--keep-learnings", false, {
+    description: "Keep learnings when clearing"
+  });
+  // Dry run
+  dryRun = Option23.Boolean("--dry-run", false, {
+    description: "Preview without making changes"
+  });
+  // JSON output
+  json = Option23.Boolean("--json,-j", false, {
+    description: "Output in JSON format"
+  });
+  // Verbose output
+  verbose = Option23.Boolean("--verbose,-v", false, {
+    description: "Show detailed output"
+  });
+  async execute() {
+    const action = this.action || "status";
+    switch (action) {
+      case "status":
+        return this.showStatus();
+      case "search":
+        return this.searchMemories();
+      case "list":
+        return this.listLearnings();
+      case "show":
+        return this.showLearning();
+      case "compress":
+        return this.compressObservations();
+      case "export":
+        return this.exportLearning();
+      case "import":
+        return this.importMemories();
+      case "clear":
+        return this.clearMemory();
+      case "add":
+        return this.addLearning();
+      case "rate":
+        return this.rateLearning();
+      case "config":
+        return this.showConfig();
+      default:
+        console.error(chalk23.red(`Unknown action: ${action}`));
+        console.log(chalk23.gray("Available actions: status, search, list, show, compress, export, import, clear, add, rate, config"));
+        return 1;
+    }
+  }
+  /**
+   * Show memory status
+   */
+  async showStatus() {
+    const projectPath = process.cwd();
+    const status = getMemoryStatus(projectPath);
+    const paths = getMemoryPaths(projectPath);
+    const observationStore = new ObservationStore(projectPath);
+    const projectLearningStore = new LearningStore("project", projectPath);
+    const globalLearningStore = new LearningStore("global");
+    const sessionObservations = status.hasObservations ? observationStore.count() : 0;
+    const projectLearnings = status.hasLearnings ? projectLearningStore.count() : 0;
+    const globalLearnings = status.hasGlobalLearnings ? globalLearningStore.count() : 0;
+    const sessionId = status.hasObservations ? observationStore.getSessionId() : null;
+    if (this.json) {
+      console.log(JSON.stringify({
+        ...status,
+        sessionObservations,
+        projectLearnings,
+        globalLearnings,
+        sessionId,
+        paths
+      }, null, 2));
+      return 0;
+    }
+    console.log(chalk23.bold("\nMemory Status\n"));
+    console.log(chalk23.cyan("Session:"));
+    console.log(`  Observations: ${sessionObservations}`);
+    if (sessionId) {
+      console.log(`  Session ID: ${chalk23.gray(sessionId.slice(0, 8))}`);
+    }
+    console.log();
+    console.log(chalk23.cyan("Project:"));
+    console.log(`  Learnings: ${projectLearnings}`);
+    console.log(`  Path: ${chalk23.gray(status.projectMemoryExists ? paths.projectMemoryDir : "Not initialized")}`);
+    console.log();
+    console.log(chalk23.cyan("Global:"));
+    console.log(`  Learnings: ${globalLearnings}`);
+    console.log(`  Path: ${chalk23.gray(status.globalMemoryExists ? paths.globalMemoryDir : "Not initialized")}`);
+    console.log();
+    if (sessionObservations >= 50) {
+      console.log(chalk23.yellow("\u{1F4A1} You have many uncompressed observations. Consider running:"));
+      console.log(chalk23.gray("   skillkit memory compress"));
+    }
+    return 0;
+  }
+  /**
+   * Search memories
+   */
+  async searchMemories() {
+    const query = this.arg;
+    if (!query) {
+      console.error(chalk23.red("Error: Search query is required"));
+      console.log(chalk23.gray('Usage: skillkit memory search "your query"'));
+      return 1;
+    }
+    const projectPath = process.cwd();
+    const injector = createMemoryInjector(projectPath);
+    let maxLearnings = 10;
+    if (this.limit) {
+      const parsed = parseInt(this.limit, 10);
+      if (isNaN(parsed) || parsed <= 0) {
+        console.log(chalk23.red("Invalid --limit value. Must be a positive number."));
+        return 1;
+      }
+      maxLearnings = parsed;
+    }
+    const tags = this.tags?.split(",").map((t) => t.trim()).filter((t) => t.length > 0);
+    const results = injector.search(query, {
+      includeGlobal: this.global,
+      tags: tags && tags.length > 0 ? tags : void 0,
+      maxLearnings,
+      minRelevance: 0
+    });
+    if (this.json) {
+      console.log(JSON.stringify(results, null, 2));
+      return 0;
+    }
+    if (results.length === 0) {
+      console.log(chalk23.yellow(`No memories found for: "${query}"`));
+      return 0;
+    }
+    console.log(chalk23.bold(`
+Found ${results.length} memories:
+`));
+    for (const { learning, relevanceScore, matchedBy } of results) {
+      console.log(`${chalk23.cyan("\u25CF")} ${chalk23.bold(learning.title)}`);
+      console.log(`  ID: ${chalk23.gray(learning.id.slice(0, 8))}`);
+      console.log(`  Relevance: ${this.formatScore(relevanceScore)}%`);
+      console.log(`  Tags: ${learning.tags.join(", ")}`);
+      console.log(`  Scope: ${learning.scope}`);
+      if (this.verbose) {
+        console.log(`  Matched: ${this.formatMatchedBy(matchedBy)}`);
+        console.log(`  Created: ${new Date(learning.createdAt).toLocaleDateString()}`);
+        console.log(`  Uses: ${learning.useCount}`);
+      }
+      const excerpt = learning.content.slice(0, 100);
+      console.log(`  ${chalk23.gray(excerpt)}${learning.content.length > 100 ? "..." : ""}`);
+      console.log();
+    }
+    return 0;
+  }
+  /**
+   * List all learnings
+   */
+  async listLearnings() {
+    const projectPath = process.cwd();
+    const store = new LearningStore(
+      this.global ? "global" : "project",
+      this.global ? void 0 : projectPath
+    );
+    let learnings = store.getAll();
+    if (this.tags) {
+      const tagList = this.tags.split(",").map((t) => t.trim().toLowerCase());
+      learnings = learnings.filter(
+        (l) => l.tags.some((t) => tagList.includes(t.toLowerCase()))
+      );
+    }
+    const limit = this.limit ? parseInt(this.limit, 10) : learnings.length;
+    learnings = learnings.slice(0, limit);
+    if (this.json) {
+      console.log(JSON.stringify(learnings, null, 2));
+      return 0;
+    }
+    const scope = this.global ? "Global" : "Project";
+    console.log(chalk23.bold(`
+${scope} Learnings (${learnings.length}):
+`));
+    if (learnings.length === 0) {
+      console.log(chalk23.gray("No learnings found."));
+      console.log(chalk23.gray("\nCapture learnings by running skills or add manually:"));
+      console.log(chalk23.gray('  skillkit memory add --title "..." --content "..."'));
+      return 0;
+    }
+    for (const learning of learnings) {
+      const effectiveness = learning.effectiveness !== void 0 ? ` [${this.formatScore(learning.effectiveness)}%]` : "";
+      console.log(`${chalk23.cyan("\u25CF")} ${learning.title}${chalk23.green(effectiveness)}`);
+      console.log(`  ${chalk23.gray(learning.id.slice(0, 8))} | ${learning.tags.join(", ")} | ${learning.useCount} uses`);
+      if (this.verbose) {
+        const excerpt = learning.content.slice(0, 80);
+        console.log(`  ${chalk23.gray(excerpt)}${learning.content.length > 80 ? "..." : ""}`);
+      }
+    }
+    console.log();
+    return 0;
+  }
+  /**
+   * Show a specific learning
+   */
+  async showLearning() {
+    const id = this.arg;
+    if (!id) {
+      console.error(chalk23.red("Error: Learning ID is required"));
+      console.log(chalk23.gray("Usage: skillkit memory show <id>"));
+      return 1;
+    }
+    const projectPath = process.cwd();
+    let learning = new LearningStore("project", projectPath).getById(id);
+    if (!learning) {
+      learning = new LearningStore("global").getById(id);
+    }
+    if (!learning) {
+      const projectLearnings = new LearningStore("project", projectPath).getAll();
+      const globalLearnings = new LearningStore("global").getAll();
+      const all = [...projectLearnings, ...globalLearnings];
+      learning = all.find((l) => l.id.startsWith(id));
+    }
+    if (!learning) {
+      console.error(chalk23.red(`Learning not found: ${id}`));
+      return 1;
+    }
+    if (this.json) {
+      console.log(JSON.stringify(learning, null, 2));
+      return 0;
+    }
+    console.log(chalk23.bold(`
+${learning.title}
+`));
+    console.log(chalk23.gray(`ID: ${learning.id}`));
+    console.log(chalk23.gray(`Scope: ${learning.scope}`));
+    console.log(chalk23.gray(`Source: ${learning.source}`));
+    console.log(chalk23.gray(`Tags: ${learning.tags.join(", ")}`));
+    if (learning.frameworks?.length) {
+      console.log(chalk23.gray(`Frameworks: ${learning.frameworks.join(", ")}`));
+    }
+    if (learning.patterns?.length) {
+      console.log(chalk23.gray(`Patterns: ${learning.patterns.join(", ")}`));
+    }
+    console.log(chalk23.gray(`Created: ${new Date(learning.createdAt).toLocaleString()}`));
+    console.log(chalk23.gray(`Updated: ${new Date(learning.updatedAt).toLocaleString()}`));
+    console.log(chalk23.gray(`Uses: ${learning.useCount}`));
+    if (learning.effectiveness !== void 0) {
+      console.log(chalk23.gray(`Effectiveness: ${this.formatScore(learning.effectiveness)}%`));
+    }
+    console.log(chalk23.bold("\nContent:\n"));
+    console.log(learning.content);
+    console.log();
+    return 0;
+  }
+  /**
+   * Compress observations into learnings
+   */
+  async compressObservations() {
+    const projectPath = process.cwd();
+    initializeMemoryDirectory(projectPath);
+    const observationStore = new ObservationStore(projectPath);
+    const observations = observationStore.getAll();
+    if (observations.length === 0) {
+      console.log(chalk23.yellow("No observations to compress."));
+      return 0;
+    }
+    console.log(chalk23.cyan(`Found ${observations.length} observations to compress...
+`));
+    const compressor = createMemoryCompressor(projectPath);
+    const compressionOptions = {
+      minObservations: 2,
+      additionalTags: this.tags?.split(",").map((t) => t.trim())
+    };
+    if (this.dryRun) {
+      console.log(chalk23.gray("(Dry run - no changes will be made)\n"));
+      const result2 = await compressor.compress(observations, compressionOptions);
+      console.log(chalk23.green(`\u2713 Would compress ${result2.stats.inputCount} observations into ${result2.stats.outputCount} learnings
+`));
+      if (result2.learnings.length > 0) {
+        console.log(chalk23.bold("Learnings that would be created:"));
+        for (const learning of result2.learnings) {
+          console.log(`  ${chalk23.cyan("\u25CF")} ${learning.title}`);
+          console.log(`    Tags: ${learning.tags.join(", ")}`);
+        }
+        console.log();
+      }
+      return 0;
+    }
+    const { learnings, result } = await compressor.compressAndStore(observations, compressionOptions);
+    console.log(chalk23.green(`\u2713 Compressed ${result.stats.inputCount} observations into ${result.stats.outputCount} learnings
+`));
+    if (learnings.length > 0) {
+      console.log(chalk23.bold("New Learnings:"));
+      for (const learning of learnings) {
+        console.log(`  ${chalk23.cyan("\u25CF")} ${learning.title}`);
+        console.log(`    Tags: ${learning.tags.join(", ")}`);
+      }
+      console.log();
+    }
+    if (result.processedObservationIds.length > 0) {
+      const deleted = observationStore.deleteMany(result.processedObservationIds);
+      console.log(chalk23.gray(`Cleared ${deleted} processed observations.`));
+    }
+    return 0;
+  }
+  /**
+   * Export a learning as a skill
+   */
+  async exportLearning() {
+    const id = this.arg;
+    if (!id) {
+      console.error(chalk23.red("Error: Learning ID is required"));
+      console.log(chalk23.gray("Usage: skillkit memory export <id> --name my-skill"));
+      return 1;
+    }
+    const projectPath = process.cwd();
+    let learning = new LearningStore("project", projectPath).getById(id);
+    if (!learning) {
+      learning = new LearningStore("global").getById(id);
+    }
+    if (!learning) {
+      const projectLearnings = new LearningStore("project", projectPath).getAll();
+      const globalLearnings = new LearningStore("global").getAll();
+      const all = [...projectLearnings, ...globalLearnings];
+      learning = all.find((l) => l.id.startsWith(id));
+    }
+    if (!learning) {
+      console.error(chalk23.red(`Learning not found: ${id}`));
+      return 1;
+    }
+    const skillName = this.name || this.slugify(learning.title);
+    const skillContent = this.generateSkillContent(learning, skillName);
+    if (this.dryRun) {
+      console.log(chalk23.gray("(Dry run preview)\n"));
+      console.log(skillContent);
+      return 0;
+    }
+    const outputPath = this.output || `.skillkit/exports/${skillName}/SKILL.md`;
+    const { dirname: dirname3 } = await import("path");
+    const { existsSync: existsSync13, mkdirSync: mkdirSync7, writeFileSync: writeFileSync6 } = await import("fs");
+    const outputDir = dirname3(outputPath);
+    if (!existsSync13(outputDir)) {
+      mkdirSync7(outputDir, { recursive: true });
+    }
+    writeFileSync6(outputPath, skillContent, "utf-8");
+    console.log(chalk23.green(`\u2713 Exported learning as skill: ${skillName}`));
+    console.log(chalk23.gray(`  Path: ${outputPath}`));
+    return 0;
+  }
+  /**
+   * Import memories from another project
+   */
+  async importMemories() {
+    const inputPath = this.input || this.arg;
+    if (!inputPath) {
+      console.error(chalk23.red("Error: Input path is required"));
+      console.log(chalk23.gray("Usage: skillkit memory import --input <path>"));
+      return 1;
+    }
+    const { existsSync: existsSync13, readFileSync: readFileSync7 } = await import("fs");
+    const { resolve: resolve12 } = await import("path");
+    const fullPath = resolve12(inputPath);
+    if (!existsSync13(fullPath)) {
+      console.error(chalk23.red(`File not found: ${fullPath}`));
+      return 1;
+    }
+    const projectPath = process.cwd();
+    const store = new LearningStore(
+      this.global ? "global" : "project",
+      this.global ? void 0 : projectPath
+    );
+    try {
+      const content = readFileSync7(fullPath, "utf-8");
+      const { parse: parseYaml2 } = await import("yaml");
+      const data = parseYaml2(content);
+      if (!data.learnings || !Array.isArray(data.learnings)) {
+        console.error(chalk23.red("Invalid memory file format"));
+        return 1;
+      }
+      let imported = 0;
+      for (const learning of data.learnings) {
+        if (this.dryRun) {
+          console.log(chalk23.gray(`Would import: ${learning.title}`));
+        } else {
+          store.add({
+            source: "imported",
+            title: learning.title,
+            content: learning.content,
+            // Default to empty arrays if not present in imported YAML
+            tags: Array.isArray(learning.tags) ? learning.tags : [],
+            frameworks: Array.isArray(learning.frameworks) ? learning.frameworks : [],
+            patterns: Array.isArray(learning.patterns) ? learning.patterns : []
+          });
+          imported++;
+        }
+      }
+      if (this.dryRun) {
+        console.log(chalk23.gray(`
+(Dry run - ${data.learnings.length} learnings would be imported)`));
+      } else {
+        console.log(chalk23.green(`\u2713 Imported ${imported} learnings`));
+      }
+      return 0;
+    } catch (error) {
+      console.error(chalk23.red(`Import failed: ${error}`));
+      return 1;
+    }
+  }
+  /**
+   * Clear session observations
+   */
+  async clearMemory() {
+    const projectPath = process.cwd();
+    if (this.dryRun) {
+      const observationStore2 = new ObservationStore(projectPath);
+      const learningStore = new LearningStore("project", projectPath);
+      console.log(chalk23.gray("(Dry run preview)\n"));
+      console.log(`Would clear ${observationStore2.count()} observations`);
+      if (!this.keepLearnings) {
+        console.log(`Would clear ${learningStore.count()} learnings`);
+      }
+      return 0;
+    }
+    const observationStore = new ObservationStore(projectPath);
+    observationStore.clear();
+    console.log(chalk23.green("\u2713 Cleared session observations"));
+    if (!this.keepLearnings) {
+      const learningStore = new LearningStore("project", projectPath);
+      learningStore.clear();
+      console.log(chalk23.green("\u2713 Cleared project learnings"));
+    }
+    return 0;
+  }
+  /**
+   * Add a manual learning
+   */
+  async addLearning() {
+    if (!this.title) {
+      console.error(chalk23.red("Error: --title is required"));
+      console.log(chalk23.gray('Usage: skillkit memory add --title "..." --content "..."'));
+      return 1;
+    }
+    if (!this.content) {
+      console.error(chalk23.red("Error: --content is required"));
+      console.log(chalk23.gray('Usage: skillkit memory add --title "..." --content "..."'));
+      return 1;
+    }
+    const projectPath = process.cwd();
+    const store = new LearningStore(
+      this.global ? "global" : "project",
+      this.global ? void 0 : projectPath
+    );
+    const tags = this.tags?.split(",").map((t) => t.trim()) || [];
+    const learning = store.add({
+      source: "manual",
+      title: this.title,
+      content: this.content,
+      tags
+    });
+    console.log(chalk23.green(`\u2713 Added learning: ${learning.title}`));
+    console.log(chalk23.gray(`  ID: ${learning.id}`));
+    return 0;
+  }
+  /**
+   * Rate a learning's effectiveness
+   */
+  async rateLearning() {
+    const id = this.arg;
+    if (!id) {
+      console.error(chalk23.red("Error: Learning ID is required"));
+      console.log(chalk23.gray("Usage: skillkit memory rate <id> <rating>"));
+      return 1;
+    }
+    const rating = parseInt(this.ratingArg || "0", 10);
+    if (isNaN(rating) || rating < 0 || rating > 100) {
+      console.error(chalk23.red("Error: Rating must be 0-100"));
+      console.log(chalk23.gray("Usage: skillkit memory rate <id> <rating>"));
+      return 1;
+    }
+    const projectPath = process.cwd();
+    const projectStore = new LearningStore("project", projectPath);
+    let learning = projectStore.getById(id);
+    let store = projectStore;
+    if (!learning) {
+      const globalStore = new LearningStore("global");
+      learning = globalStore.getById(id);
+      store = globalStore;
+    }
+    if (!learning) {
+      const projectLearnings = projectStore.getAll();
+      const globalStore = new LearningStore("global");
+      const globalLearnings = globalStore.getAll();
+      learning = projectLearnings.find((l) => l.id.startsWith(id));
+      if (learning) {
+        store = projectStore;
+      } else {
+        learning = globalLearnings.find((l) => l.id.startsWith(id));
+        if (learning) {
+          store = globalStore;
+        }
+      }
+    }
+    if (!learning) {
+      console.error(chalk23.red(`Learning not found: ${id}`));
+      return 1;
+    }
+    store.setEffectiveness(learning.id, rating);
+    console.log(chalk23.green(`\u2713 Rated "${learning.title}" as ${rating}% effective`));
+    return 0;
+  }
+  /**
+   * Show memory configuration
+   */
+  async showConfig() {
+    const projectPath = process.cwd();
+    const paths = getMemoryPaths(projectPath);
+    if (this.json) {
+      console.log(JSON.stringify(paths, null, 2));
+      return 0;
+    }
+    console.log(chalk23.bold("\nMemory Configuration\n"));
+    console.log(chalk23.cyan("Paths:"));
+    console.log(`  Project observations: ${chalk23.gray(paths.observationsFile)}`);
+    console.log(`  Project learnings: ${chalk23.gray(paths.learningsFile)}`);
+    console.log(`  Project index: ${chalk23.gray(paths.indexFile)}`);
+    console.log(`  Global learnings: ${chalk23.gray(paths.globalLearningsFile)}`);
+    console.log(`  Global index: ${chalk23.gray(paths.globalIndexFile)}`);
+    console.log();
+    return 0;
+  }
+  /**
+   * Format relevance/effectiveness score with color
+   */
+  formatScore(score) {
+    if (score >= 80) return chalk23.green(score.toString());
+    if (score >= 50) return chalk23.yellow(score.toString());
+    return chalk23.red(score.toString());
+  }
+  /**
+   * Format matched by info
+   */
+  formatMatchedBy(matchedBy) {
+    const parts = [];
+    if (matchedBy.frameworks.length > 0) {
+      parts.push(`frameworks: ${matchedBy.frameworks.join(", ")}`);
+    }
+    if (matchedBy.tags.length > 0) {
+      parts.push(`tags: ${matchedBy.tags.join(", ")}`);
+    }
+    if (matchedBy.keywords.length > 0) {
+      parts.push(`keywords: ${matchedBy.keywords.slice(0, 3).join(", ")}`);
+    }
+    if (matchedBy.patterns.length > 0) {
+      parts.push(`patterns: ${matchedBy.patterns.join(", ")}`);
+    }
+    return parts.join(" | ") || "general";
+  }
+  /**
+   * Convert title to slug
+   */
+  slugify(text) {
+    return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 50);
+  }
+  /**
+   * Escape a YAML scalar value if it contains special characters
+   */
+  escapeYamlValue(value) {
+    if (/[:#\[\]{}|>&*!?,'"\\@`]/.test(value) || value.includes("\n")) {
+      return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+    }
+    return value;
+  }
+  /**
+   * Generate skill content from learning
+   */
+  generateSkillContent(learning, skillName) {
+    const escapedName = this.escapeYamlValue(skillName);
+    const escapedDesc = this.escapeYamlValue(learning.title);
+    const escapedTags = learning.tags.map((t) => this.escapeYamlValue(t));
+    const lines = [
+      "---",
+      `name: ${escapedName}`,
+      `description: ${escapedDesc}`,
+      `version: 1.0.0`,
+      `tags: [${escapedTags.join(", ")}]`,
+      `source: skillkit-memory`,
+      `sourceType: local`
+    ];
+    if (learning.frameworks?.length) {
+      const escapedFrameworks = learning.frameworks.map((f) => this.escapeYamlValue(f));
+      lines.push(`compatibility:`);
+      lines.push(`  frameworks: [${escapedFrameworks.join(", ")}]`);
+    }
+    lines.push("---", "", `# ${learning.title}`, "");
+    if (learning.patterns?.length) {
+      lines.push(`## Patterns`, "");
+      for (const pattern of learning.patterns) {
+        lines.push(`- ${pattern}`);
+      }
+      lines.push("");
+    }
+    lines.push(`## Content`, "", learning.content, "");
+    lines.push(
+      "---",
+      "",
+      "*Exported from SkillKit session memory*",
+      `*Created: ${new Date(learning.createdAt).toLocaleDateString()}*`,
+      `*Uses: ${learning.useCount}*`
+    );
+    if (learning.effectiveness !== void 0) {
+      lines.push(`*Effectiveness: ${learning.effectiveness}%*`);
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/commands/settings.ts
+import { Command as Command25, Option as Option24 } from "clipanion";
+import chalk24 from "chalk";
+import { loadConfig as loadConfig3, saveConfig } from "@skillkit/core";
+var VALID_AGENTS = [
+  "claude-code",
+  "cursor",
+  "codex",
+  "gemini-cli",
+  "opencode",
+  "antigravity",
+  "amp",
+  "clawdbot",
+  "droid",
+  "github-copilot",
+  "goose",
+  "kilo",
+  "kiro-cli",
+  "roo",
+  "trae",
+  "windsurf",
+  "universal"
+];
+var SettingsCommand = class extends Command25 {
+  static paths = [["settings"], ["config"]];
+  static usage = Command25.Usage({
+    description: "View and modify SkillKit settings",
+    details: `
+      View or modify SkillKit configuration. Settings are stored in skillkit.yaml.
+
+      Without arguments, shows all current settings.
+      With --set, modifies a specific setting.
+    `,
+    examples: [
+      ["Show all settings", "$0 settings"],
+      ["Set default agent", "$0 settings --set agent=claude-code"],
+      ["Enable auto-sync", "$0 settings --set autoSync=true"],
+      ["Set cache directory", "$0 settings --set cacheDir=~/.cache/skillkit"],
+      ["Show settings as JSON", "$0 settings --json"],
+      ["Save to global config", "$0 settings --set agent=cursor --global"]
+    ]
+  });
+  // Set a setting
+  set = Option24.String("--set,-s", {
+    description: "Set a config value (key=value)"
+  });
+  // Get a specific setting
+  get = Option24.String("--get,-g", {
+    description: "Get a specific setting value"
+  });
+  // JSON output
+  json = Option24.Boolean("--json,-j", false, {
+    description: "Output as JSON"
+  });
+  // Global config
+  global = Option24.Boolean("--global", false, {
+    description: "Use global config (~/.config/skillkit/)"
+  });
+  // Reset to defaults
+  reset = Option24.Boolean("--reset", false, {
+    description: "Reset all settings to defaults"
+  });
+  async execute() {
+    const config = loadConfig3(this.global);
+    if (this.reset) {
+      const defaultConfig = {
+        version: 1,
+        agent: "universal",
+        autoSync: true
+      };
+      saveConfig(defaultConfig, this.global);
+      console.log(chalk24.green("Settings reset to defaults"));
+      return 0;
+    }
+    if (this.get) {
+      const knownKeys = [
+        "agent",
+        "autoSync",
+        "cacheDir",
+        "skillsDir",
+        "enabledSkills",
+        "disabledSkills",
+        "marketplaceSources",
+        "defaultTimeout"
+      ];
+      if (!knownKeys.includes(this.get)) {
+        console.error(chalk24.red(`Unknown setting: ${this.get}`));
+        return 1;
+      }
+      const value = this.getConfigValue(config, this.get);
+      if (this.json) {
+        console.log(JSON.stringify({ [this.get]: value ?? null }));
+      } else {
+        console.log(value ?? "(not set)");
+      }
+      return 0;
+    }
+    if (this.set) {
+      const [key, ...valueParts] = this.set.split("=");
+      const value = valueParts.join("=");
+      if (!key || !this.set.includes("=")) {
+        console.error(chalk24.red("Invalid format. Use: --set key=value"));
+        return 1;
+      }
+      const result = this.setConfigValue(config, key, value);
+      if (!result.success) {
+        console.error(chalk24.red(result.error));
+        return 1;
+      }
+      saveConfig(config, this.global);
+      console.log(chalk24.green(`${key} = ${value}`));
+      return 0;
+    }
+    if (this.json) {
+      console.log(JSON.stringify(config, null, 2));
+    } else {
+      console.log(chalk24.cyan("SkillKit Settings"));
+      console.log(chalk24.dim("\u2500".repeat(40)));
+      console.log();
+      const settings = [
+        { key: "agent", label: "Default Agent", value: config.agent },
+        { key: "autoSync", label: "Auto Sync", value: config.autoSync ? "enabled" : "disabled" },
+        { key: "cacheDir", label: "Cache Dir", value: config.cacheDir || "~/.skillkit/cache" },
+        { key: "skillsDir", label: "Skills Dir", value: config.skillsDir || "(default)" },
+        { key: "defaultTimeout", label: "Timeout", value: config.defaultTimeout ? `${config.defaultTimeout}ms` : "(default)" }
+      ];
+      for (const setting of settings) {
+        console.log(`  ${chalk24.white(setting.label.padEnd(14))} ${chalk24.dim(setting.value)}`);
+      }
+      if (config.enabledSkills?.length) {
+        console.log();
+        console.log(`  ${chalk24.white("Enabled Skills".padEnd(14))} ${chalk24.dim(config.enabledSkills.join(", "))}`);
+      }
+      if (config.disabledSkills?.length) {
+        console.log(`  ${chalk24.white("Disabled Skills".padEnd(14))} ${chalk24.dim(config.disabledSkills.join(", "))}`);
+      }
+      if (config.marketplaceSources?.length) {
+        console.log(`  ${chalk24.white("Marketplaces".padEnd(14))} ${chalk24.dim(config.marketplaceSources.join(", "))}`);
+      }
+      console.log();
+      console.log(chalk24.dim("Use --set key=value to modify settings"));
+      console.log(chalk24.dim("Available keys: agent, autoSync, cacheDir, skillsDir, defaultTimeout"));
+    }
+    return 0;
+  }
+  getConfigValue(config, key) {
+    switch (key) {
+      case "agent":
+        return config.agent;
+      case "autoSync":
+        return config.autoSync;
+      case "cacheDir":
+        return config.cacheDir;
+      case "skillsDir":
+        return config.skillsDir;
+      case "enabledSkills":
+        return config.enabledSkills;
+      case "disabledSkills":
+        return config.disabledSkills;
+      case "marketplaceSources":
+        return config.marketplaceSources;
+      case "defaultTimeout":
+        return config.defaultTimeout;
+      default:
+        return void 0;
+    }
+  }
+  setConfigValue(config, key, value) {
+    switch (key) {
+      case "agent":
+        if (!VALID_AGENTS.includes(value)) {
+          return {
+            success: false,
+            error: `Invalid agent. Valid options: ${VALID_AGENTS.join(", ")}`
+          };
+        }
+        config.agent = value;
+        break;
+      case "autoSync":
+        if (!["true", "false", "enabled", "disabled"].includes(value.toLowerCase())) {
+          return { success: false, error: "autoSync must be true/false or enabled/disabled" };
+        }
+        config.autoSync = value.toLowerCase() === "true" || value.toLowerCase() === "enabled";
+        break;
+      case "cacheDir":
+        config.cacheDir = value || void 0;
+        break;
+      case "skillsDir":
+        config.skillsDir = value || void 0;
+        break;
+      case "defaultTimeout": {
+        const timeout = parseInt(value, 10);
+        if (isNaN(timeout) || timeout <= 0) {
+          return { success: false, error: "defaultTimeout must be a positive number (milliseconds)" };
+        }
+        config.defaultTimeout = timeout;
+        break;
+      }
+      default:
+        return { success: false, error: `Unknown setting: ${key}` };
+    }
+    return { success: true };
+  }
+};
+
+// src/commands/cicd.ts
+import { Command as Command26, Option as Option25 } from "clipanion";
+import chalk25 from "chalk";
+import { existsSync as existsSync11, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5, readFileSync as readFileSync6 } from "fs";
+import { join as join8 } from "path";
+var GITHUB_ACTIONS_WORKFLOW = `name: SkillKit CI
+
+on:
+  push:
+    branches: [main, master]
+    paths:
+      - '.skillkit/**'
+      - 'skills/**'
+      - '.claude/skills/**'
+      - '.cursor/skills/**'
+  pull_request:
+    branches: [main, master]
+    paths:
+      - '.skillkit/**'
+      - 'skills/**'
+      - '.claude/skills/**'
+      - '.cursor/skills/**'
+
+jobs:
+  validate:
+    name: Validate Skills
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install SkillKit
+        run: npm install -g skillkit
+
+      - name: Validate Skills
+        run: skillkit validate --all
+
+      - name: List Skills
+        run: skillkit list
+
+  test:
+    name: Test Skills
+    runs-on: ubuntu-latest
+    needs: validate
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install SkillKit
+        run: npm install -g skillkit
+
+      - name: Run Skill Tests
+        run: skillkit test --all
+        continue-on-error: true
+
+  sync:
+    name: Sync Skills
+    runs-on: ubuntu-latest
+    needs: validate
+    if: github.event_name == 'push'
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install SkillKit
+        run: npm install -g skillkit
+
+      - name: Sync Skills to All Agents
+        run: skillkit sync --yes
+`;
+var GITLAB_CI = `stages:
+  - validate
+  - test
+  - sync
+
+variables:
+  NODE_VERSION: "20"
+
+.skillkit-base:
+  image: node:\${NODE_VERSION}
+  before_script:
+    - npm install -g skillkit
+  rules:
+    - changes:
+        - .skillkit/**/*
+        - skills/**/*
+        - .claude/skills/**/*
+        - .cursor/skills/**/*
+
+validate:
+  extends: .skillkit-base
+  stage: validate
+  script:
+    - skillkit validate --all
+    - skillkit list
+
+test:
+  extends: .skillkit-base
+  stage: test
+  script:
+    - skillkit test --all
+  allow_failure: true
+  needs:
+    - validate
+
+sync:
+  extends: .skillkit-base
+  stage: sync
+  script:
+    - skillkit sync --yes
+  needs:
+    - validate
+  rules:
+    - if: $CI_COMMIT_BRANCH == "main" || $CI_COMMIT_BRANCH == "master"
+      changes:
+        - .skillkit/**/*
+        - skills/**/*
+        - .claude/skills/**/*
+        - .cursor/skills/**/*
+`;
+var CIRCLECI_CONFIG = `version: 2.1
+
+executors:
+  node:
+    docker:
+      - image: cimg/node:20.0
+
+jobs:
+  validate:
+    executor: node
+    steps:
+      - checkout
+      - run:
+          name: Install SkillKit
+          command: npm install -g skillkit
+      - run:
+          name: Validate Skills
+          command: skillkit validate --all
+      - run:
+          name: List Skills
+          command: skillkit list
+
+  test:
+    executor: node
+    steps:
+      - checkout
+      - run:
+          name: Install SkillKit
+          command: npm install -g skillkit
+      - run:
+          name: Run Skill Tests
+          command: skillkit test --all || true
+
+  sync:
+    executor: node
+    steps:
+      - checkout
+      - run:
+          name: Install SkillKit
+          command: npm install -g skillkit
+      - run:
+          name: Sync Skills
+          command: skillkit sync --yes
+
+workflows:
+  skillkit:
+    jobs:
+      - validate:
+          filters:
+            branches:
+              only:
+                - main
+                - master
+      - test:
+          requires:
+            - validate
+      - sync:
+          requires:
+            - validate
+          filters:
+            branches:
+              only:
+                - main
+                - master
+`;
+var CICDCommand = class extends Command26 {
+  static paths = [["cicd", "init"]];
+  static usage = Command26.Usage({
+    description: "Initialize CI/CD workflows for skill validation",
+    details: `
+      The cicd command sets up continuous integration workflows to automatically
+      validate and test skills on every push or pull request.
+
+      Supported providers: github, gitlab, circleci
+    `,
+    examples: [
+      ["Initialize GitHub Actions workflow", "$0 cicd init"],
+      ["Initialize GitLab CI", "$0 cicd init --provider gitlab"],
+      ["Initialize CircleCI", "$0 cicd init --provider circleci"],
+      ["Initialize all providers", "$0 cicd init --all"],
+      ["Force overwrite existing files", "$0 cicd init --force"]
+    ]
+  });
+  // Provider selection
+  provider = Option25.String("--provider,-p", "github", {
+    description: "CI/CD provider (github, gitlab, circleci)"
+  });
+  // Generate for all providers
+  all = Option25.Boolean("--all,-a", false, {
+    description: "Generate workflows for all supported providers"
+  });
+  // Force overwrite
+  force = Option25.Boolean("--force,-f", false, {
+    description: "Overwrite existing workflow files"
+  });
+  // Project path
+  targetPath = Option25.String("--path", {
+    description: "Project path (default: current directory)"
+  });
+  async execute() {
+    const projectPath = this.targetPath || process.cwd();
+    const providers = this.all ? ["github", "gitlab", "circleci"] : [this.provider];
+    console.log(chalk25.cyan("Initializing CI/CD workflows..."));
+    console.log();
+    let success = true;
+    let created = false;
+    for (const provider of providers) {
+      const result = this.createWorkflow(projectPath, provider);
+      if (result.skipped) {
+        console.log(chalk25.yellow(`  ${result.message}`));
+        continue;
+      }
+      if (!result.success) {
+        success = false;
+        console.error(chalk25.red(`  ${result.message}`));
+        continue;
+      }
+      created = true;
+      console.log(chalk25.green(`  \u2713 ${result.message}`));
+    }
+    if (success) {
+      console.log();
+      console.log(
+        created ? chalk25.green("CI/CD workflows initialized successfully!") : chalk25.yellow("CI/CD workflows already exist; nothing to do.")
+      );
+      console.log();
+      if (created) {
+        console.log(chalk25.dim("The workflows will run on push/PR to validate your skills."));
+        console.log(chalk25.dim("Commit the generated files to enable CI/CD."));
+      }
+    }
+    return success ? 0 : 1;
+  }
+  createWorkflow(projectPath, provider) {
+    switch (provider) {
+      case "github":
+        return this.createGitHubActions(projectPath);
+      case "gitlab":
+        return this.createGitLabCI(projectPath);
+      case "circleci":
+        return this.createCircleCI(projectPath);
+      default:
+        return { success: false, message: `Unknown provider: ${provider}` };
+    }
+  }
+  createGitHubActions(projectPath) {
+    const workflowDir = join8(projectPath, ".github", "workflows");
+    const workflowFile = join8(workflowDir, "skillkit.yml");
+    if (existsSync11(workflowFile) && !this.force) {
+      return {
+        success: true,
+        message: `GitHub Actions workflow already exists (use --force to overwrite)`,
+        skipped: true
+      };
+    }
+    try {
+      mkdirSync5(workflowDir, { recursive: true });
+      writeFileSync5(workflowFile, GITHUB_ACTIONS_WORKFLOW);
+      return { success: true, message: `Created ${workflowFile}` };
+    } catch (error) {
+      return { success: false, message: `Failed to create GitHub workflow: ${error}` };
+    }
+  }
+  createGitLabCI(projectPath) {
+    const ciFile = join8(projectPath, ".gitlab-ci.yml");
+    if (existsSync11(ciFile) && !this.force) {
+      try {
+        const content = readFileSync6(ciFile, "utf-8");
+        if (content.includes("skillkit")) {
+          return {
+            success: true,
+            message: `.gitlab-ci.yml already contains SkillKit config (use --force to overwrite)`,
+            skipped: true
+          };
+        }
+        return {
+          success: true,
+          message: `.gitlab-ci.yml already exists (use --force to overwrite)`,
+          skipped: true
+        };
+      } catch (error) {
+        return {
+          success: false,
+          message: `Failed to read .gitlab-ci.yml: ${error}`
+        };
+      }
+    }
+    try {
+      writeFileSync5(ciFile, GITLAB_CI);
+      return { success: true, message: `Created ${ciFile}` };
+    } catch (error) {
+      return { success: false, message: `Failed to create GitLab CI config: ${error}` };
+    }
+  }
+  createCircleCI(projectPath) {
+    const circleDir = join8(projectPath, ".circleci");
+    const configFile = join8(circleDir, "config.yml");
+    if (existsSync11(configFile) && !this.force) {
+      return {
+        success: true,
+        message: `CircleCI config already exists (use --force to overwrite)`,
+        skipped: true
+      };
+    }
+    try {
+      mkdirSync5(circleDir, { recursive: true });
+      writeFileSync5(configFile, CIRCLECI_CONFIG);
+      return { success: true, message: `Created ${configFile}` };
+    } catch (error) {
+      return { success: false, message: `Failed to create CircleCI config: ${error}` };
+    }
+  }
+};
+
+// src/commands/team.ts
+import { Command as Command27, Option as Option26 } from "clipanion";
+import chalk26 from "chalk";
+import { createTeamManager, createSkillBundle, exportBundle, importBundle } from "@skillkit/core";
+import { join as join9 } from "path";
+var TeamCommand = class extends Command27 {
+  static paths = [["team"]];
+  static usage = Command27.Usage({
+    description: "Manage team skill sharing and collaboration",
+    examples: [
+      ["Initialize team", '$0 team init --name "My Team" --registry https://github.com/myteam/skills'],
+      ["Share a skill", "$0 team share --name my-skill"],
+      ["Import a skill", "$0 team import --name shared-skill"],
+      ["List shared skills", "$0 team list"],
+      ["Sync with remote", "$0 team sync"],
+      ["Create a bundle", "$0 team bundle-create --name my-bundle --skills skill1,skill2"],
+      ["Export a bundle", "$0 team bundle-export --name my-bundle --output ./bundle.json"],
+      ["Import a bundle", "$0 team bundle-import --source ./bundle.json"]
+    ]
+  });
+  action = Option26.String({ required: true });
+  name = Option26.String("--name", { description: "Team name (for init), skill name, or bundle name" });
+  registry = Option26.String("--registry", { description: "Registry URL (for init)" });
+  description = Option26.String("--description,-d", { description: "Description (for share/bundle)" });
+  tags = Option26.String("--tags,-t", { description: "Comma-separated tags (for share)" });
+  skills = Option26.String("--skills", { description: "Comma-separated skill names (for bundle)" });
+  output = Option26.String("--output,-o", { description: "Output path (for bundle-export)" });
+  source = Option26.String("--source,-s", { description: "Source path (for bundle-import)" });
+  overwrite = Option26.Boolean("--overwrite", { description: "Overwrite existing (for import)" });
+  dryRun = Option26.Boolean("--dry-run", { description: "Preview without changes" });
+  async execute() {
+    const projectPath = process.cwd();
+    const teamManager = createTeamManager(projectPath);
+    try {
+      switch (this.action) {
+        case "init":
+          return await this.initTeam(teamManager);
+        case "share":
+          return await this.shareSkill(teamManager);
+        case "import":
+          return await this.importSkill(teamManager);
+        case "list":
+          return await this.listSkills(teamManager);
+        case "sync":
+          return await this.syncTeam(teamManager);
+        case "remove":
+          return await this.removeSkill(teamManager);
+        case "bundle-create":
+          return await this.createBundle(teamManager);
+        case "bundle-export":
+          return await this.exportSkillBundle(teamManager);
+        case "bundle-import":
+          return await this.importSkillBundle();
+        default:
+          this.context.stderr.write(chalk26.red(`Unknown action: ${this.action}
+`));
+          this.context.stderr.write("Available actions: init, share, import, list, sync, remove, bundle-create, bundle-export, bundle-import\n");
+          return 1;
+      }
+    } catch (err) {
+      this.context.stderr.write(chalk26.red(`\u2717 ${err instanceof Error ? err.message : "Unknown error"}
+`));
+      return 1;
+    }
+  }
+  async initTeam(teamManager) {
+    if (!this.name) {
+      this.context.stderr.write(chalk26.red("--name is required for init\n"));
+      return 1;
+    }
+    if (!this.registry) {
+      this.context.stderr.write(chalk26.red("--registry is required for init\n"));
+      return 1;
+    }
+    const config = await teamManager.init({
+      teamName: this.name,
+      registryUrl: this.registry
+    });
+    this.context.stdout.write(chalk26.green("\u2713 Team initialized!\n"));
+    this.context.stdout.write(`  Team ID: ${config.teamId}
+`);
+    this.context.stdout.write(`  Registry: ${config.registryUrl}
+`);
+    return 0;
+  }
+  async shareSkill(teamManager) {
+    const config = teamManager.load();
+    if (!config) {
+      this.context.stderr.write(chalk26.red("Team not initialized. Run `skillkit team init` first.\n"));
+      return 1;
+    }
+    if (!this.name) {
+      this.context.stderr.write(chalk26.red("--name <skill-name> is required for share\n"));
+      return 1;
+    }
+    const shared = await teamManager.shareSkill({
+      skillName: this.name,
+      description: this.description,
+      tags: this.tags?.split(",").map((t) => t.trim())
+    });
+    this.context.stdout.write(chalk26.green("\u2713 Skill shared!\n"));
+    this.context.stdout.write(`  Name: ${shared.name}
+`);
+    this.context.stdout.write(`  Version: ${shared.version}
+`);
+    this.context.stdout.write(`  Source: ${shared.source}
+`);
+    return 0;
+  }
+  async importSkill(teamManager) {
+    const config = teamManager.load();
+    if (!config) {
+      this.context.stderr.write(chalk26.red("Team not initialized. Run `skillkit team init` first.\n"));
+      return 1;
+    }
+    if (!this.name) {
+      this.context.stderr.write(chalk26.red("--name <skill-name> is required for import\n"));
+      return 1;
+    }
+    const result = await teamManager.importSkill(this.name, {
+      overwrite: this.overwrite,
+      dryRun: this.dryRun
+    });
+    if (!result.success) {
+      this.context.stderr.write(chalk26.red(`\u2717 ${result.error}
+`));
+      return 1;
+    }
+    if (this.dryRun) {
+      this.context.stdout.write(chalk26.cyan(`[dry-run] Would import to: ${result.path}
+`));
+    } else {
+      this.context.stdout.write(chalk26.green(`\u2713 Skill imported to: ${result.path}
+`));
+    }
+    return 0;
+  }
+  async listSkills(teamManager) {
+    const config = teamManager.load();
+    if (!config) {
+      this.context.stderr.write(chalk26.red("Team not initialized. Run `skillkit team init` first.\n"));
+      return 1;
+    }
+    const skills = teamManager.listSharedSkills();
+    this.context.stdout.write(chalk26.cyan(`Team: ${config.teamName}
+`));
+    this.context.stdout.write(chalk26.gray(`Registry: ${config.registryUrl}
+
+`));
+    if (skills.length === 0) {
+      this.context.stdout.write("No shared skills yet. Use `skillkit team share` to share a skill.\n");
+      return 0;
+    }
+    this.context.stdout.write(`Shared Skills (${skills.length}):
+`);
+    for (const skill of skills) {
+      this.context.stdout.write(chalk26.cyan(`  ${skill.name}`) + ` v${skill.version}
+`);
+      if (skill.description) {
+        this.context.stdout.write(chalk26.gray(`    ${skill.description}
+`));
+      }
+      this.context.stdout.write(`    by ${skill.author} | ${skill.downloads || 0} downloads
+`);
+    }
+    return 0;
+  }
+  async syncTeam(teamManager) {
+    const config = teamManager.load();
+    if (!config) {
+      this.context.stderr.write(chalk26.red("Team not initialized. Run `skillkit team init` first.\n"));
+      return 1;
+    }
+    this.context.stdout.write(`Syncing with ${config.registryUrl}...
+`);
+    const result = await teamManager.sync();
+    this.context.stdout.write(chalk26.green("\u2713 Sync complete!\n"));
+    if (result.added.length > 0) {
+      this.context.stdout.write(`  Added: ${result.added.join(", ")}
+`);
+    }
+    if (result.updated.length > 0) {
+      this.context.stdout.write(`  Updated: ${result.updated.join(", ")}
+`);
+    }
+    if (result.added.length === 0 && result.updated.length === 0) {
+      this.context.stdout.write("  Already up to date.\n");
+    }
+    return 0;
+  }
+  async removeSkill(teamManager) {
+    const config = teamManager.load();
+    if (!config) {
+      this.context.stderr.write(chalk26.red("Team not initialized. Run `skillkit team init` first.\n"));
+      return 1;
+    }
+    if (!this.name) {
+      this.context.stderr.write(chalk26.red("--name <skill-name> is required for remove\n"));
+      return 1;
+    }
+    const removed = teamManager.removeSkill(this.name);
+    if (!removed) {
+      this.context.stderr.write(chalk26.red(`Skill "${this.name}" not found in team registry.
+`));
+      return 1;
+    }
+    this.context.stdout.write(chalk26.green(`\u2713 Skill "${this.name}" removed from team registry.
+`));
+    return 0;
+  }
+  async createBundle(teamManager) {
+    const config = teamManager.load();
+    if (!config) {
+      this.context.stderr.write(chalk26.red("Team not initialized. Run `skillkit team init` first.\n"));
+      return 1;
+    }
+    if (!this.name) {
+      this.context.stderr.write(chalk26.red("--name <bundle-name> is required for bundle-create\n"));
+      return 1;
+    }
+    if (!this.skills) {
+      this.context.stderr.write(chalk26.red("--skills <skill1,skill2,...> is required for bundle-create\n"));
+      return 1;
+    }
+    const skillNames = this.skills.split(",").map((s) => s.trim());
+    const projectPath = process.cwd();
+    const skillsDir = join9(projectPath, "skills");
+    const bundle = createSkillBundle(this.name, config.teamName, this.description);
+    let addedCount = 0;
+    for (const skillName of skillNames) {
+      const skillPath = join9(skillsDir, skillName);
+      try {
+        bundle.addSkill(skillPath);
+        addedCount++;
+        this.context.stdout.write(chalk26.gray(`  + ${skillName}
+`));
+      } catch (err) {
+        this.context.stderr.write(chalk26.yellow(`  \u26A0 Skipping ${skillName}: ${err instanceof Error ? err.message : "Unknown error"}
+`));
+      }
+    }
+    if (addedCount === 0) {
+      this.context.stderr.write(chalk26.red("No skills were added to the bundle.\n"));
+      return 1;
+    }
+    const outputPath = this.output || join9(projectPath, ".skillkit", "bundles", `${this.name}.json`);
+    const result = exportBundle(bundle, outputPath);
+    if (!result.success) {
+      this.context.stderr.write(chalk26.red(`\u2717 ${result.error}
+`));
+      return 1;
+    }
+    this.context.stdout.write(chalk26.green(`
+\u2713 Bundle "${this.name}" created with ${addedCount} skills!
+`));
+    this.context.stdout.write(`  Checksum: ${bundle.getChecksum()}
+`);
+    this.context.stdout.write(`  Output: ${result.path}
+`);
+    return 0;
+  }
+  async exportSkillBundle(teamManager) {
+    const config = teamManager.load();
+    if (!config) {
+      this.context.stderr.write(chalk26.red("Team not initialized. Run `skillkit team init` first.\n"));
+      return 1;
+    }
+    if (!this.name) {
+      this.context.stderr.write(chalk26.red("--name <bundle-name> is required for bundle-export\n"));
+      return 1;
+    }
+    if (!this.output) {
+      this.context.stderr.write(chalk26.red("--output <path> is required for bundle-export\n"));
+      return 1;
+    }
+    const projectPath = process.cwd();
+    const bundlePath = join9(projectPath, ".skillkit", "bundles", `${this.name}.json`);
+    const { existsSync: existsSync13, readFileSync: readFileSync7, writeFileSync: writeFileSync6 } = await import("fs");
+    if (!existsSync13(bundlePath)) {
+      this.context.stderr.write(chalk26.red(`Bundle "${this.name}" not found. Create it first with bundle-create.
+`));
+      return 1;
+    }
+    const content = readFileSync7(bundlePath, "utf-8");
+    writeFileSync6(this.output, content, "utf-8");
+    this.context.stdout.write(chalk26.green(`\u2713 Bundle exported to: ${this.output}
+`));
+    return 0;
+  }
+  async importSkillBundle() {
+    if (!this.source) {
+      this.context.stderr.write(chalk26.red("--source <path> is required for bundle-import\n"));
+      return 1;
+    }
+    const { existsSync: existsSync13 } = await import("fs");
+    if (!existsSync13(this.source)) {
+      this.context.stderr.write(chalk26.red(`Bundle file not found: ${this.source}
+`));
+      return 1;
+    }
+    const projectPath = process.cwd();
+    const skillsDir = join9(projectPath, "skills");
+    if (this.dryRun) {
+      this.context.stdout.write(chalk26.cyan("[dry-run] Would import bundle to: " + skillsDir + "\n"));
+      return 0;
+    }
+    const result = importBundle(this.source, skillsDir, { overwrite: this.overwrite });
+    if (!result.success && result.imported.length === 0) {
+      this.context.stderr.write(chalk26.red("\u2717 Failed to import bundle:\n"));
+      for (const error of result.errors) {
+        this.context.stderr.write(chalk26.red(`  - ${error}
+`));
+      }
+      return 1;
+    }
+    this.context.stdout.write(chalk26.green(`\u2713 Imported ${result.imported.length} skills from bundle!
+`));
+    for (const name of result.imported) {
+      this.context.stdout.write(chalk26.gray(`  + ${name}
+`));
+    }
+    if (result.errors.length > 0) {
+      this.context.stdout.write(chalk26.yellow("\nWarnings:\n"));
+      for (const error of result.errors) {
+        this.context.stdout.write(chalk26.yellow(`  - ${error}
+`));
+      }
+    }
+    return 0;
+  }
+};
+
+// src/commands/plugin.ts
+import { Command as Command28, Option as Option27 } from "clipanion";
+import { join as join10, isAbsolute, resolve as resolve11, sep } from "path";
+import { homedir } from "os";
+import { existsSync as existsSync12, mkdirSync as mkdirSync6, copyFileSync, cpSync as cpSync3, rmSync as rmSync4 } from "fs";
+import chalk27 from "chalk";
+import { createPluginManager, loadPlugin, loadPluginsFromDirectory } from "@skillkit/core";
+var PluginCommand = class extends Command28 {
+  static paths = [["plugin"]];
+  static usage = Command28.Usage({
+    description: "Manage SkillKit plugins",
+    examples: [
+      ["List installed plugins", "$0 plugin list"],
+      ["Install a plugin", "$0 plugin install --source ./my-plugin"],
+      ["Install from npm", "$0 plugin install --source skillkit-plugin-gitlab"],
+      ["Uninstall a plugin", "$0 plugin uninstall --name my-plugin"],
+      ["Enable a plugin", "$0 plugin enable --name my-plugin"],
+      ["Disable a plugin", "$0 plugin disable --name my-plugin"]
+    ]
+  });
+  action = Option27.String({ required: true });
+  source = Option27.String("--source,-s", { description: "Plugin source (file path or npm package)" });
+  name = Option27.String("--name,-n", { description: "Plugin name" });
+  global = Option27.Boolean("--global,-g", { description: "Use global plugin directory" });
+  async execute() {
+    const projectPath = this.global ? join10(homedir(), ".skillkit") : process.cwd();
+    const pluginManager = createPluginManager(projectPath);
+    const pluginsDir = this.global ? join10(projectPath, "plugins") : join10(projectPath, ".skillkit", "plugins");
+    try {
+      const plugins = await loadPluginsFromDirectory(pluginsDir);
+      for (const plugin of plugins) {
+        if (pluginManager.isPluginEnabled(plugin.metadata.name)) {
+          await pluginManager.register(plugin);
+        }
+      }
+    } catch {
+    }
+    try {
+      switch (this.action) {
+        case "list":
+          return this.listPlugins(pluginManager);
+        case "install":
+          return await this.installPlugin(pluginManager);
+        case "uninstall":
+          return await this.uninstallPlugin(pluginManager);
+        case "enable":
+          return this.enablePlugin(pluginManager);
+        case "disable":
+          return this.disablePlugin(pluginManager);
+        case "info":
+          return this.pluginInfo(pluginManager);
+        default:
+          this.context.stderr.write(chalk27.red(`Unknown action: ${this.action}
+`));
+          this.context.stderr.write("Available actions: list, install, uninstall, enable, disable, info\n");
+          return 1;
+      }
+    } catch (err) {
+      this.context.stderr.write(chalk27.red(`\u2717 ${err instanceof Error ? err.message : "Unknown error"}
+`));
+      return 1;
+    }
+  }
+  listPlugins(pluginManager) {
+    const plugins = pluginManager.listPlugins();
+    if (plugins.length === 0) {
+      this.context.stdout.write("No plugins installed.\n");
+      this.context.stdout.write("Use `skillkit plugin install --source <source>` to install a plugin.\n");
+      return 0;
+    }
+    this.context.stdout.write(chalk27.cyan(`Installed Plugins (${plugins.length}):
+
+`));
+    for (const plugin of plugins) {
+      const enabled = pluginManager.isPluginEnabled(plugin.name);
+      const status = enabled ? chalk27.green("enabled") : chalk27.gray("disabled");
+      this.context.stdout.write(chalk27.cyan(`  ${plugin.name}`) + ` v${plugin.version} [${status}]
+`);
+      if (plugin.description) {
+        this.context.stdout.write(chalk27.gray(`    ${plugin.description}
+`));
+      }
+    }
+    const translators = pluginManager.getAllTranslators();
+    const providers = pluginManager.getAllProviders();
+    const commands = pluginManager.getAllCommands();
+    if (translators.size > 0 || providers.size > 0 || commands.length > 0) {
+      this.context.stdout.write(chalk27.cyan("\nRegistered Extensions:\n"));
+      if (translators.size > 0) {
+        this.context.stdout.write(`  Translators: ${Array.from(translators.keys()).join(", ")}
+`);
+      }
+      if (providers.size > 0) {
+        this.context.stdout.write(`  Providers: ${Array.from(providers.keys()).join(", ")}
+`);
+      }
+      if (commands.length > 0) {
+        this.context.stdout.write(`  Commands: ${commands.map((c) => c.name).join(", ")}
+`);
+      }
+    }
+    return 0;
+  }
+  /**
+   * Validate plugin name to prevent path traversal attacks
+   * Allows scoped npm names like @scope/name (mirrors loader.ts validation)
+   */
+  isValidPluginName(name) {
+    if (!name) return false;
+    if (name.includes("\\") || name.includes("..") || name === "." || name.startsWith(".")) {
+      return false;
+    }
+    return /^(?:@[a-z0-9-]+\/)?[a-z0-9-]+$/.test(name);
+  }
+  async installPlugin(pluginManager) {
+    if (!this.source) {
+      this.context.stderr.write(chalk27.red("--source is required for install\n"));
+      return 1;
+    }
+    const resolvedSource = this.source.startsWith("~") ? join10(homedir(), this.source.slice(1)) : this.source;
+    this.context.stdout.write(`Installing plugin from ${this.source}...
+`);
+    const plugin = await loadPlugin(resolvedSource);
+    const pluginName = plugin.metadata.name;
+    if (!this.isValidPluginName(pluginName)) {
+      this.context.stderr.write(chalk27.red(`Invalid plugin name: ${pluginName}
+`));
+      return 1;
+    }
+    const projectPath = this.global ? join10(homedir(), ".skillkit") : process.cwd();
+    const pluginsDir = this.global ? join10(projectPath, "plugins") : join10(projectPath, ".skillkit", "plugins");
+    const isLocalPath3 = this.source.startsWith("./") || this.source.startsWith("../") || this.source.startsWith("/") || this.source.startsWith("~") || this.source.includes("\\") || isAbsolute(this.source);
+    if (isLocalPath3 && existsSync12(resolvedSource)) {
+      const targetDir = join10(pluginsDir, pluginName);
+      const resolvedTarget = resolve11(targetDir);
+      const resolvedPluginsDir = resolve11(pluginsDir);
+      if (!resolvedTarget.startsWith(resolvedPluginsDir + sep)) {
+        this.context.stderr.write(chalk27.red("Invalid plugin name\n"));
+        return 1;
+      }
+      if (!existsSync12(pluginsDir)) {
+        mkdirSync6(pluginsDir, { recursive: true });
+      }
+      const { statSync: statSync2 } = await import("fs");
+      const sourceStat = statSync2(resolvedSource);
+      if (sourceStat.isDirectory()) {
+        cpSync3(resolvedSource, targetDir, { recursive: true });
+      } else {
+        if (!existsSync12(targetDir)) {
+          mkdirSync6(targetDir, { recursive: true });
+        }
+        let destFileName;
+        if (resolvedSource.endsWith(".json")) {
+          destFileName = "plugin.json";
+        } else if (resolvedSource.endsWith(".mjs")) {
+          destFileName = "index.mjs";
+        } else {
+          destFileName = "index.js";
+        }
+        copyFileSync(resolvedSource, join10(targetDir, destFileName));
+      }
+      this.context.stdout.write(chalk27.dim(`  Copied to ${targetDir}
+`));
+    }
+    await pluginManager.register(plugin);
+    this.context.stdout.write(chalk27.green(`\u2713 Plugin "${plugin.metadata.name}" installed!
+`));
+    this.context.stdout.write(`  Version: ${plugin.metadata.version}
+`);
+    if (plugin.metadata.description) {
+      this.context.stdout.write(`  ${plugin.metadata.description}
+`);
+    }
+    if (plugin.translators?.length) {
+      this.context.stdout.write(`  Translators: ${plugin.translators.map((t) => t.agentType).join(", ")}
+`);
+    }
+    if (plugin.providers?.length) {
+      this.context.stdout.write(`  Providers: ${plugin.providers.map((p) => p.providerName).join(", ")}
+`);
+    }
+    if (plugin.commands?.length) {
+      this.context.stdout.write(`  Commands: ${plugin.commands.map((c) => c.name).join(", ")}
+`);
+    }
+    return 0;
+  }
+  async uninstallPlugin(pluginManager) {
+    if (!this.name) {
+      this.context.stderr.write(chalk27.red("--name is required for uninstall\n"));
+      return 1;
+    }
+    if (!this.isValidPluginName(this.name)) {
+      this.context.stderr.write(chalk27.red("Invalid plugin name\n"));
+      return 1;
+    }
+    await pluginManager.unregister(this.name);
+    const projectPath = this.global ? join10(homedir(), ".skillkit") : process.cwd();
+    const pluginsDir = this.global ? join10(projectPath, "plugins") : join10(projectPath, ".skillkit", "plugins");
+    const pluginDir = join10(pluginsDir, this.name);
+    const resolvedPluginDir = resolve11(pluginDir);
+    const resolvedPluginsDir = resolve11(pluginsDir);
+    if (!resolvedPluginDir.startsWith(resolvedPluginsDir + sep)) {
+      this.context.stderr.write(chalk27.red("Invalid plugin name\n"));
+      return 1;
+    }
+    if (existsSync12(pluginDir)) {
+      rmSync4(pluginDir, { recursive: true, force: true });
+      this.context.stdout.write(chalk27.dim(`  Removed ${pluginDir}
+`));
+    }
+    this.context.stdout.write(chalk27.green(`\u2713 Plugin "${this.name}" uninstalled.
+`));
+    return 0;
+  }
+  enablePlugin(pluginManager) {
+    if (!this.name) {
+      this.context.stderr.write(chalk27.red("--name is required for enable\n"));
+      return 1;
+    }
+    pluginManager.enablePlugin(this.name);
+    this.context.stdout.write(chalk27.green(`\u2713 Plugin "${this.name}" enabled.
+`));
+    return 0;
+  }
+  disablePlugin(pluginManager) {
+    if (!this.name) {
+      this.context.stderr.write(chalk27.red("--name is required for disable\n"));
+      return 1;
+    }
+    pluginManager.disablePlugin(this.name);
+    this.context.stdout.write(chalk27.green(`\u2713 Plugin "${this.name}" disabled.
+`));
+    return 0;
+  }
+  pluginInfo(pluginManager) {
+    if (!this.name) {
+      this.context.stderr.write(chalk27.red("--name is required for info\n"));
+      return 1;
+    }
+    const plugin = pluginManager.getPlugin(this.name);
+    if (!plugin) {
+      this.context.stderr.write(chalk27.red(`Plugin "${this.name}" not found.
+`));
+      return 1;
+    }
+    const { metadata } = plugin;
+    const enabled = pluginManager.isPluginEnabled(this.name);
+    this.context.stdout.write(chalk27.cyan(`${metadata.name}`) + ` v${metadata.version}
+`);
+    this.context.stdout.write(`Status: ${enabled ? "enabled" : "disabled"}
+`);
+    if (metadata.description) {
+      this.context.stdout.write(`Description: ${metadata.description}
+`);
+    }
+    if (metadata.author) {
+      this.context.stdout.write(`Author: ${metadata.author}
+`);
+    }
+    if (metadata.homepage) {
+      this.context.stdout.write(`Homepage: ${metadata.homepage}
+`);
+    }
+    if (metadata.keywords?.length) {
+      this.context.stdout.write(`Keywords: ${metadata.keywords.join(", ")}
+`);
+    }
+    if (metadata.dependencies?.length) {
+      this.context.stdout.write(`Dependencies: ${metadata.dependencies.join(", ")}
+`);
+    }
+    return 0;
+  }
+};
 export {
+  CICDCommand,
   ContextCommand,
   CreateCommand,
   DisableCommand,
@@ -2229,14 +5244,27 @@ export {
   InitCommand,
   InstallCommand,
   ListCommand,
+  MarketplaceCommand,
+  MemoryCommand,
+  PauseCommand,
+  PluginCommand,
   ReadCommand,
   RecommendCommand,
   RemoveCommand,
+  ResumeCommand,
+  RunCommand,
+  SettingsCommand,
+  StatusCommand,
   SyncCommand,
+  TeamCommand,
+  TestCommand,
   TranslateCommand,
   UICommand,
   UpdateCommand,
   ValidateCommand,
+  WorkflowCreateCommand,
+  WorkflowListCommand,
+  WorkflowRunCommand,
   getAgentConfigPath,
   getInstallDir,
   getSearchDirs,