@skillkit/cli 1.3.1 → 1.4.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,219 +2018,2028 @@ 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"]
+
+// 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
+} 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)"
+  });
+  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 orchestrator = createWorkflowOrchestrator(
+      async (_skillName, _config) => {
+        await new Promise((resolve11) => setTimeout(resolve11, 500));
+        return { success: true };
       },
-      popularity: 650,
-      quality: 84,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      verified: false
+      (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: existsSync11, mkdirSync: mkdirSync5, writeFileSync: writeFileSync5 } = await import("fs");
+    const outputDir = dirname3(outputPath);
+    if (!existsSync11(outputDir)) {
+      mkdirSync5(outputDir, { recursive: true });
+    }
+    writeFileSync5(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: existsSync11, readFileSync: readFileSync6 } = await import("fs");
+    const { resolve: resolve11 } = await import("path");
+    const fullPath = resolve11(inputPath);
+    if (!existsSync11(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 = readFileSync6(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");
+  }
+};
 export {
   ContextCommand,
   CreateCommand,
@@ -2229,14 +4048,24 @@ export {
   InitCommand,
   InstallCommand,
   ListCommand,
+  MarketplaceCommand,
+  MemoryCommand,
+  PauseCommand,
   ReadCommand,
   RecommendCommand,
   RemoveCommand,
+  ResumeCommand,
+  RunCommand,
+  StatusCommand,
   SyncCommand,
+  TestCommand,
   TranslateCommand,
   UICommand,
   UpdateCommand,
   ValidateCommand,
+  WorkflowCreateCommand,
+  WorkflowListCommand,
+  WorkflowRunCommand,
   getAgentConfigPath,
   getInstallDir,
   getSearchDirs,