cliskill 1.1.7 → 1.2.0

package/dist/index.js

@@ -28,11 +28,10 @@ import {
   renderInkApp,
   runAgentLoop,
   runCli
-} from "./chunk-TZMKZQ7N.js";
+} from "./chunk-RLXS6WEQ.js";
 import {
-  getGlobalSkillsDir,
   getHistoryPath
-} from "./chunk-S7IQHES2.js";
+} from "./chunk-CISBSDJM.js";
 
 // src/memory/store.ts
 import { readFile, writeFile, mkdir, readdir, stat, unlink } from "fs/promises";
@@ -193,135 +192,767 @@ ${memory.content.slice(0, 500)}
   }
 };
 
-// src/extensions/skill-loader.ts
-import { readFile as readFile2, readdir as readdir2 } from "fs/promises";
-import { join as join2 } from "path";
-import { existsSync as existsSync2 } from "fs";
-async function loadSkillsFromDir(dir) {
-  if (!existsSync2(dir)) return [];
-  const skills = [];
-  const files = await readdir2(dir);
-  for (const file of files) {
-    if (!file.endsWith(".md")) continue;
-    const filePath = join2(dir, file);
-    const content = await readFile2(filePath, "utf-8");
-    const skill = parseSkillMarkdown(content, filePath);
-    if (skill) {
-      skills.push(skill);
-    }
-  }
-  return skills;
-}
-function parseSkillMarkdown(content, sourcePath) {
-  const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
-  if (!frontmatterMatch) {
-    const name = sourcePath ? sourcePath.split(/[\\/]/).pop()?.replace(".md", "") ?? "unnamed" : "unnamed";
-    return {
-      name,
-      description: `Skill: ${name}`,
-      prompt: content.trim(),
-      builtin: false,
-      sourcePath
-    };
-  }
-  const [, frontmatter, body] = frontmatterMatch;
-  const metadata = parseSimpleYaml(frontmatter);
-  if (!metadata.name) {
-    metadata.name = sourcePath ? sourcePath.split(/[\\/]/).pop()?.replace(".md", "") ?? "unnamed" : "unnamed";
+// src/extensions/builtin-skills.ts
+var BUILT_IN_SKILLS = [
+  // ── 1. Code Review ────────────────────────────────────────────────
+  {
+    id: "builtin-code-review",
+    name: "Code Review",
+    version: "1.0.0",
+    description: "Deep code review with best practices, bug detection, and improvement suggestions",
+    icon: "\u{1F50D}",
+    category: "code-review",
+    tags: ["review", "quality", "bugs", "best-practices"],
+    author: "CliSkill",
+    source: "builtin",
+    modelPreference: "smart",
+    params: [
+      {
+        name: "filePath",
+        type: "file",
+        label: "File to review",
+        description: "Path to the file or directory to review",
+        required: true
+      },
+      {
+        name: "focus",
+        type: "select",
+        label: "Review focus",
+        description: "What aspect to focus on",
+        default: "all",
+        options: [
+          { value: "all", label: "All aspects" },
+          { value: "bugs", label: "Bug detection" },
+          { value: "security", label: "Security issues" },
+          { value: "performance", label: "Performance" },
+          { value: "style", label: "Code style" },
+          { value: "architecture", label: "Architecture" }
+        ]
+      },
+      {
+        name: "severity",
+        type: "select",
+        label: "Minimum severity",
+        default: "warning",
+        options: [
+          { value: "info", label: "Info (all issues)" },
+          { value: "warning", label: "Warning+" },
+          { value: "critical", label: "Critical only" }
+        ]
+      }
+    ],
+    steps: [
+      {
+        id: "analyze",
+        title: "Analyze code structure",
+        prompt: `Perform a thorough code review of {{filePath}}.
+
+Focus: {{focus}}
+Minimum severity: {{severity}}
+
+Analyze the code and provide:
+1. **Critical issues** \u2014 bugs, security vulnerabilities, logic errors
+2. **Warnings** \u2014 potential problems, edge cases, missing error handling
+3. **Suggestions** \u2014 code quality improvements, readability, best practices
+4. **Positive notes** \u2014 good patterns found in the code
+
+Format each finding as:
+- **[SEVERITY]** Category: Description (line X)
+  Suggestion: How to fix
+
+Rate overall code quality on a scale of 1-10 and provide a summary.`,
+        tools: ["file_read", "file_outline", "search_symbol", "grep", "glob"]
+      }
+    ],
+    outputs: [{ type: "markdown", description: "Detailed code review report" }]
+  },
+  // ── 2. Refactor ───────────────────────────────────────────────────
+  {
+    id: "builtin-refactor",
+    name: "Smart Refactor",
+    version: "1.0.0",
+    description: "Intelligent code refactoring with pattern detection and safe transformations",
+    icon: "\u{1F527}",
+    category: "refactoring",
+    tags: ["refactor", "clean-code", "patterns", "design"],
+    author: "CliSkill",
+    source: "builtin",
+    modelPreference: "smart",
+    params: [
+      {
+        name: "filePath",
+        type: "file",
+        label: "File or directory",
+        required: true
+      },
+      {
+        name: "goal",
+        type: "select",
+        label: "Refactoring goal",
+        default: "clean",
+        options: [
+          { value: "clean", label: "Clean up code" },
+          { value: "patterns", label: "Apply design patterns" },
+          { value: "extract", label: "Extract functions/methods" },
+          { value: "simplify", label: "Simplify logic" },
+          { value: "modernize", label: "Modernize syntax" },
+          { value: "modularize", label: "Split into modules" }
+        ]
+      },
+      {
+        name: "aggressiveness",
+        type: "select",
+        label: "Aggressiveness",
+        default: "moderate",
+        options: [
+          { value: "conservative", label: "Conservative (minimal changes)" },
+          { value: "moderate", label: "Moderate" },
+          { value: "aggressive", label: "Aggressive (full rewrite)" }
+        ]
+      }
+    ],
+    steps: [
+      {
+        id: "plan",
+        title: "Analyze and plan refactoring",
+        prompt: `Analyze {{filePath}} for refactoring opportunities.
+
+Goal: {{goal}}
+Aggressiveness: {{aggressiveness}}
+
+First, read the code and identify:
+1. Code smells and anti-patterns
+2. Duplicated logic
+3. Overly complex functions
+4. Poor naming
+5. Missing abstractions
+
+Then create a refactoring plan listing specific changes. Do NOT make changes yet \u2014 only plan.`,
+        tools: ["file_read", "file_outline", "search_symbol", "grep", "glob"]
+      },
+      {
+        id: "execute",
+        title: "Execute refactoring",
+        prompt: `Now execute the refactoring plan for {{filePath}}.
+
+Goal: {{goal}}
+Aggressiveness: {{aggressiveness}}
+
+Apply the planned changes. Make sure to:
+- Preserve all existing functionality
+- Keep imports and exports intact
+- Maintain backward compatibility
+- Add comments only where logic is non-obvious
+
+After each change, verify the file still has valid syntax.`,
+        tools: ["file_read", "file_edit", "file_write", "bash"],
+        timeout: 120
+      }
+    ],
+    outputs: [
+      { type: "diff", description: "Changes made during refactoring" },
+      { type: "markdown", description: "Summary of refactoring changes" }
+    ]
+  },
+  // ── 3. Test Generator ─────────────────────────────────────────────
+  {
+    id: "builtin-test-gen",
+    name: "Test Generator",
+    version: "1.0.0",
+    description: "Generate comprehensive unit and integration tests for your code",
+    icon: "\u{1F9EA}",
+    category: "testing",
+    tags: ["tests", "unit-tests", "integration", "coverage"],
+    author: "CliSkill",
+    source: "builtin",
+    modelPreference: "code",
+    params: [
+      {
+        name: "filePath",
+        type: "file",
+        label: "File to test",
+        required: true
+      },
+      {
+        name: "framework",
+        type: "select",
+        label: "Test framework",
+        default: "auto",
+        options: [
+          { value: "auto", label: "Auto-detect" },
+          { value: "jest", label: "Jest" },
+          { value: "vitest", label: "Vitest" },
+          { value: "pytest", label: "Pytest" },
+          { value: "go", label: "Go testing" },
+          { value: "rust", label: "Rust #[test]" }
+        ]
+      },
+      {
+        name: "coverage",
+        type: "select",
+        label: "Coverage level",
+        default: "comprehensive",
+        options: [
+          { value: "basic", label: "Basic (happy path)" },
+          { value: "comprehensive", label: "Comprehensive (edge cases)" },
+          { value: "exhaustive", label: "Exhaustive (all paths)" }
+        ]
+      }
+    ],
+    steps: [
+      {
+        id: "analyze",
+        title: "Analyze code for testability",
+        prompt: `Analyze {{filePath}} to identify all testable units (functions, methods, classes).
+
+Framework: {{framework}}
+Coverage: {{coverage}}
+
+List every function/method with:
+- Name and signature
+- Input parameters and their possible values
+- Expected outputs
+- Edge cases and error conditions
+- Dependencies that need mocking`,
+        tools: ["file_read", "file_outline", "search_symbol", "grep"]
+      },
+      {
+        id: "generate",
+        title: "Generate tests",
+        prompt: `Generate {{coverage}} tests for {{filePath}}.
+
+Framework: {{framework}}
+
+Create a test file that includes:
+1. Setup/teardown if needed
+2. Tests for each function/method identified
+3. Edge case coverage
+4. Error handling tests
+5. Mock dependencies where appropriate
+
+Follow the project's existing test patterns if any exist.
+Place the test file in the appropriate location.`,
+        tools: ["file_read", "file_write", "glob", "grep", "bash"],
+        timeout: 120
+      }
+    ],
+    outputs: [
+      { type: "file", description: "Generated test file" },
+      { type: "markdown", description: "Test coverage summary" }
+    ]
+  },
+  // ── 4. Explain Code ───────────────────────────────────────────────
+  {
+    id: "builtin-explain",
+    name: "Explain Code",
+    version: "1.0.0",
+    description: "Deep code explanation with architecture analysis and flow diagrams",
+    icon: "\u{1F4D6}",
+    category: "analysis",
+    tags: ["explain", "understand", "architecture", "learning"],
+    author: "CliSkill",
+    source: "builtin",
+    modelPreference: "smart",
+    params: [
+      {
+        name: "filePath",
+        type: "file",
+        label: "File or directory",
+        required: true
+      },
+      {
+        name: "depth",
+        type: "select",
+        label: "Explanation depth",
+        default: "detailed",
+        options: [
+          { value: "overview", label: "Overview (high-level)" },
+          { value: "detailed", label: "Detailed (function-by-function)" },
+          { value: "line-by-line", label: "Line-by-line" }
+        ]
+      },
+      {
+        name: "audience",
+        type: "select",
+        label: "Target audience",
+        default: "developer",
+        options: [
+          { value: "beginner", label: "Beginner" },
+          { value: "developer", label: "Developer" },
+          { value: "senior", label: "Senior / Architect" }
+        ]
+      }
+    ],
+    steps: [
+      {
+        id: "explain",
+        title: "Analyze and explain code",
+        prompt: `Explain the code in {{filePath}}.
+
+Depth: {{depth}}
+Audience: {{audience}}
+
+Provide:
+1. **Overview** \u2014 What does this code do? Why does it exist?
+2. **Architecture** \u2014 How is it structured? Key abstractions?
+3. **Data flow** \u2014 How does data move through the code?
+4. **Key functions** \u2014 What does each important function do?
+5. **Dependencies** \u2014 What external packages/APIs does it use?
+6. **Patterns** \u2014 What design patterns are used?
+7. **Gotchas** \u2014 Any tricky or non-obvious parts?
+
+Use clear language appropriate for the {{audience}} level.`,
+        tools: ["file_read", "file_outline", "search_symbol", "grep", "glob", "lsp"]
+      }
+    ],
+    outputs: [{ type: "markdown", description: "Detailed code explanation" }]
+  },
+  // ── 5. Security Audit ─────────────────────────────────────────────
+  {
+    id: "builtin-security-audit",
+    name: "Security Audit",
+    version: "1.0.0",
+    description: "OWASP-based security audit for vulnerability detection",
+    icon: "\u{1F6E1}\uFE0F",
+    category: "security",
+    tags: ["security", "owasp", "vulnerabilities", "audit"],
+    author: "CliSkill",
+    source: "builtin",
+    modelPreference: "smart",
+    params: [
+      {
+        name: "path",
+        type: "directory",
+        label: "Project path",
+        required: true
+      },
+      {
+        name: "checkTypes",
+        type: "multiselect",
+        label: "Check types",
+        default: void 0,
+        options: [
+          { value: "injection", label: "SQL/Command Injection" },
+          { value: "xss", label: "Cross-Site Scripting (XSS)" },
+          { value: "auth", label: "Authentication issues" },
+          { value: "secrets", label: "Hardcoded secrets" },
+          { value: "deps", label: "Vulnerable dependencies" },
+          { value: "config", label: "Misconfiguration" }
+        ]
+      }
+    ],
+    steps: [
+      {
+        id: "scan",
+        title: "Scan for vulnerabilities",
+        prompt: `Perform a security audit of the project at {{path}}.
+
+Check types: {{checkTypes}}
+
+Scan for:
+1. **Injection** \u2014 SQL injection, command injection, XSS
+2. **Authentication** \u2014 Weak auth, missing auth, session issues
+3. **Secrets** \u2014 Hardcoded passwords, API keys, tokens
+4. **Dependencies** \u2014 Known vulnerable packages
+5. **Configuration** \u2014 Debug mode, CORS, insecure defaults
+6. **Data exposure** \u2014 Logging sensitive data, error messages
+
+For each finding provide:
+- Severity: Critical/High/Medium/Low
+- OWASP category
+- File and line number
+- Description of the vulnerability
+- Recommended fix
+
+Also check for .env files, config files, and package.json for exposed secrets.`,
+        tools: ["file_read", "grep", "glob", "bash"],
+        timeout: 180
+      }
+    ],
+    outputs: [{ type: "markdown", description: "Security audit report" }]
+  },
+  // ── 6. Documentation Generator ────────────────────────────────────
+  {
+    id: "builtin-docs-gen",
+    name: "Doc Generator",
+    version: "1.0.0",
+    description: "Generate comprehensive documentation \u2014 JSDoc, README, API docs",
+    icon: "\u{1F4DD}",
+    category: "documentation",
+    tags: ["docs", "jsdoc", "readme", "api-docs"],
+    author: "CliSkill",
+    source: "builtin",
+    modelPreference: "code",
+    params: [
+      {
+        name: "filePath",
+        type: "file",
+        label: "File to document",
+        required: true
+      },
+      {
+        name: "docType",
+        type: "select",
+        label: "Documentation type",
+        default: "inline",
+        options: [
+          { value: "inline", label: "Inline comments (JSDoc/doc comments)" },
+          { value: "readme", label: "README section" },
+          { value: "api", label: "API documentation" },
+          { value: "architecture", label: "Architecture doc" }
+        ]
+      }
+    ],
+    steps: [
+      {
+        id: "generate-docs",
+        title: "Generate documentation",
+        prompt: `Generate {{docType}} documentation for {{filePath}}.
+
+Documentation type: {{docType}}
+
+Analyze the code and generate:
+- For inline: Add proper JSDoc/TSDoc/doc comments to all exported functions, classes, interfaces
+- For README: Create a section describing the module, its API, usage examples
+- For API docs: Full API reference with types, parameters, return values, examples
+- For architecture: High-level architecture diagram (text-based), module relationships
+
+Follow the project's existing documentation style if present.`,
+        tools: ["file_read", "file_outline", "search_symbol", "file_edit", "grep"]
+      }
+    ],
+    outputs: [
+      { type: "code", description: "Documented code or documentation file" }
+    ]
+  },
+  // ── 7. Performance Profiler ───────────────────────────────────────
+  {
+    id: "builtin-perf-analyze",
+    name: "Performance Analyzer",
+    version: "1.0.0",
+    description: "Analyze code for performance bottlenecks and suggest optimizations",
+    icon: "\u26A1",
+    category: "performance",
+    tags: ["performance", "optimization", "profiling", "bottleneck"],
+    author: "CliSkill",
+    source: "builtin",
+    modelPreference: "smart",
+    params: [
+      {
+        name: "filePath",
+        type: "file",
+        label: "File to analyze",
+        required: true
+      },
+      {
+        name: "language",
+        type: "select",
+        label: "Language runtime",
+        default: "auto",
+        options: [
+          { value: "auto", label: "Auto-detect" },
+          { value: "node", label: "Node.js" },
+          { value: "browser", label: "Browser" },
+          { value: "rust", label: "Rust" },
+          { value: "python", label: "Python" }
+        ]
+      }
+    ],
+    steps: [
+      {
+        id: "analyze-perf",
+        title: "Analyze performance",
+        prompt: `Analyze {{filePath}} for performance issues.
+
+Runtime: {{language}}
+
+Look for:
+1. **Algorithmic complexity** \u2014 O(n\xB2) where O(n) is possible, unnecessary loops
+2. **Memory leaks** \u2014 Unbounded arrays, missing cleanup, event listeners
+3. **Blocking operations** \u2014 Synchronous I/O, long computations on main thread
+4. **Redundant work** \u2014 Repeated calculations, unnecessary re-renders
+5. **Data structures** \u2014 Suboptimal choices (array vs Set/Map)
+6. **Caching opportunities** \u2014 Repeated expensive operations
+7. **Lazy loading** \u2014 Opportunities to defer work
+
+For each issue:
+- Severity: High/Medium/Low
+- Estimated impact
+- Code location
+- Suggested optimization with code example`,
+        tools: ["file_read", "file_outline", "search_symbol", "grep", "glob"]
+      }
+    ],
+    outputs: [{ type: "markdown", description: "Performance analysis report" }]
+    // duplicate outputs removed — see line 500
+  },
+  // ── 8. God Mode Activation ────────────────────────────────────────
+  {
+    id: "builtin-god-mode",
+    name: "God Mode",
+    version: "1.0.0",
+    description: "Activate GOD MODE \u2014 cascading escalation engine with 3 tiers (Unchained \u2192 Sovereign \u2192 Apex). Unlocks autonomous behavior, self-modification, and swarm intelligence.",
+    source: "builtin",
+    category: "agent",
+    params: [
+      {
+        name: "action",
+        type: "select",
+        label: "Action",
+        required: true,
+        default: "activate",
+        options: [
+          { value: "activate", label: "\u26A1 Activate / Escalate" },
+          { value: "status", label: "\u{1F4CA} Current Status" },
+          { value: "deactivate", label: "\u{1F534} Deactivate" }
+        ]
+      },
+      {
+        name: "tier",
+        type: "select",
+        label: "Tier (for activate)",
+        required: false,
+        default: "unchained",
+        options: [
+          { value: "unchained", label: "\u26A1 Unchained \u2014 Zero friction" },
+          { value: "sovereign", label: "\u{1F451} Sovereign \u2014 Self-modifying" },
+          { value: "apex", label: "\u{1F525} Apex \u2014 Swarm intelligence" }
+        ]
+      }
+    ],
+    steps: [
+      {
+        id: "execute",
+        title: "Execute God Mode Action",
+        prompt: `You are the GOD MODE controller. Execute the requested action: {{action}}.",
+
+{{#if (eq action "activate")}}
+Activate GOD MODE at tier "{{tier}}". Apply the following:
+
+TIER 1 "UNCHAINED" (\u26A1):
+- Auto-approve ALL tool calls \u2014 no permission prompts
+- Maximum parallelism \u2014 run up to 5 tools simultaneously
+- No confirmations for destructive operations
+- Speed over safety \u2014 broken things can be fixed
+
+TIER 2 "SOVEREIGN" (\u{1F451}) \u2014 includes all Unchained:
+- Agent modifies its own system prompt via memory
+- Auto-heal: on error \u2192 diagnose \u2192 fix \u2192 verify \u2192 report (no stopping)
+- Strategic simplification: simple tasks get simple approaches
+- Context preservation: save critical info before compaction
+
+TIER 3 "APEX" (\u{1F525}) \u2014 includes all Sovereign:
+- Spawn sub-agents autonomously for parallel tasks
+- Modify project config files (package.json, tsconfig, etc.)
+- Swarm orchestration: decompose \u2192 spawn \u2192 aggregate
+- Self-evolving: save lessons to memory after each major task
+
+Inform the user what tier they are at and what capabilities are unlocked.
+{{else if (eq action "status")}}
+Report the current GOD MODE status:
+- Active tier (or OFF)
+- Capabilities unlocked
+- Session statistics (auto-approved, sub-agents spawned, errors healed)
+{{else if (eq action "deactivate")}}
+Deactivate GOD MODE. Return to normal operation with all safety checks and confirmations.
+Summarize what was accomplished during god mode.
+{{/if}}`,
+        tools: ["memory", "bash", "file_read", "file_edit", "file_write"]
+      }
+    ],
+    outputs: [{ type: "markdown", description: "God mode action result" }]
   }
-  return {
-    name: metadata.name,
-    description: metadata.description ?? `Skill: ${metadata.name}`,
-    aliases: metadata.aliases ? String(metadata.aliases).replace(/^\[(.+)\]$/, "$1").split(",").map((s) => s.trim()) : void 0,
-    prompt: body.trim(),
-    allowedTools: metadata.allowedTools ? String(metadata.allowedTools).replace(/^\[(.+)\]$/, "$1").split(",").map((s) => s.trim()) : void 0,
-    builtin: false,
-    sourcePath
-  };
-}
-function parseSimpleYaml(yaml) {
-  const result = {};
-  for (const line of yaml.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) continue;
-    const colonIndex = trimmed.indexOf(":");
-    if (colonIndex === -1) continue;
-    const key = trimmed.slice(0, colonIndex).trim();
-    const value = trimmed.slice(colonIndex + 1).trim();
-    result[key] = value;
-  }
-  return result;
-}
+];
 
 // src/extensions/skill-registry.ts
-import { join as join3 } from "path";
 var SkillRegistry = class {
   skills = /* @__PURE__ */ new Map();
-  aliasIndex = /* @__PURE__ */ new Map();
-  /** Register a skill */
-  register(skill) {
-    this.skills.set(skill.name, skill);
-    if (skill.aliases) {
-      for (const alias of skill.aliases) {
-        this.aliasIndex.set(alias.toLowerCase(), skill.name);
-      }
+  executions = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  // ── Initialization ────────────────────────────────────────────────
+  /** Load built-in skills into registry */
+  loadBuiltinSkills() {
+    for (const manifest of BUILT_IN_SKILLS) {
+      this.skills.set(manifest.id, {
+        manifest,
+        status: "builtin",
+        installedAt: Date.now(),
+        useCount: 0,
+        enabled: true
+      });
     }
   }
-  /** Get a skill by name or alias */
-  get(nameOrAlias) {
-    const aliasTarget = this.aliasIndex.get(nameOrAlias.toLowerCase());
-    return this.skills.get(aliasTarget ?? nameOrAlias);
+  /** Register a skill from external source (file, marketplace, etc.) */
+  registerSkill(manifest, sourcePath) {
+    const existing = this.skills.get(manifest.id);
+    const skill = {
+      manifest: {
+        ...manifest,
+        sourcePath: sourcePath ?? manifest.sourcePath
+      },
+      status: manifest.source === "builtin" ? "builtin" : "installed",
+      installedAt: existing?.installedAt ?? Date.now(),
+      lastUsedAt: existing?.lastUsedAt,
+      useCount: existing?.useCount ?? 0,
+      enabled: existing?.enabled ?? true
+    };
+    this.skills.set(manifest.id, skill);
+    this.notify();
+    return skill;
+  }
+  /** Unregister a skill by id */
+  unregisterSkill(id) {
+    const skill = this.skills.get(id);
+    if (!skill || skill.status === "builtin") return false;
+    this.skills.delete(id);
+    this.notify();
+    return true;
   }
-  /** Get all registered skills */
+  // ── Query ─────────────────────────────────────────────────────────
   getAll() {
     return Array.from(this.skills.values());
   }
-  /** Check if a skill exists */
-  has(name) {
-    return this.skills.has(name) || this.aliasIndex.has(name.toLowerCase());
+  getById(id) {
+    return this.skills.get(id);
   }
-  /** Unregister a skill */
-  unregister(name) {
-    const skill = this.skills.get(name);
-    if (skill?.aliases) {
-      for (const alias of skill.aliases) {
-        this.aliasIndex.delete(alias.toLowerCase());
-      }
-    }
-    this.skills.delete(name);
+  getByCategory(category) {
+    return this.getAll().filter((s) => s.manifest.category === category);
   }
-  /**
-   * Load skills from a directory.
-   * Returns the number of skills loaded.
-   */
-  async loadFromDir(dir) {
-    const skills = await loadSkillsFromDir(dir);
-    for (const skill of skills) {
-      this.register(skill);
+  getEnabled() {
+    return this.getAll().filter((s) => s.enabled);
+  }
+  getBuiltin() {
+    return this.getAll().filter((s) => s.status === "builtin");
+  }
+  getCustom() {
+    return this.getAll().filter((s) => s.status !== "builtin");
+  }
+  search(query) {
+    const q = query.toLowerCase();
+    return this.getAll().filter((s) => {
+      const m = s.manifest;
+      return m.name.toLowerCase().includes(q) || m.description.toLowerCase().includes(q) || m.tags?.some((t) => t.toLowerCase().includes(q)) || m.category.toLowerCase().includes(q);
+    });
+  }
+  // ── State management ──────────────────────────────────────────────
+  enableSkill(id) {
+    const skill = this.skills.get(id);
+    if (!skill) return false;
+    skill.enabled = true;
+    skill.status = skill.status === "builtin" ? "builtin" : "enabled";
+    this.notify();
+    return true;
+  }
+  disableSkill(id) {
+    const skill = this.skills.get(id);
+    if (!skill) return false;
+    skill.enabled = false;
+    skill.status = "disabled";
+    this.notify();
+    return true;
+  }
+  toggleSkill(id) {
+    const skill = this.skills.get(id);
+    if (!skill) return false;
+    return skill.enabled ? this.disableSkill(id) : this.enableSkill(id);
+  }
+  // ── Execution tracking ────────────────────────────────────────────
+  startExecution(skillId, params) {
+    const skill = this.skills.get(skillId);
+    if (!skill || !skill.enabled) throw new Error(`Skill "${skillId}" not found or disabled`);
+    const execution = {
+      id: `exec-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      skillId,
+      startedAt: Date.now(),
+      status: "running",
+      currentStep: 0,
+      params,
+      results: []
+    };
+    this.executions.set(execution.id, execution);
+    skill.lastUsedAt = Date.now();
+    skill.useCount++;
+    this.notify();
+    return execution;
+  }
+  completeExecution(executionId, stepResults) {
+    const execution = this.executions.get(executionId);
+    if (!execution) return;
+    execution.completedAt = Date.now();
+    execution.status = "completed";
+    execution.results = stepResults;
+    execution.currentStep = execution.results.length;
+    this.notify();
+  }
+  failExecution(executionId, error) {
+    const execution = this.executions.get(executionId);
+    if (!execution) return;
+    execution.completedAt = Date.now();
+    execution.status = "failed";
+    execution.error = error;
+    this.notify();
+  }
+  getExecution(executionId) {
+    return this.executions.get(executionId);
+  }
+  getRecentExecutions(limit = 20) {
+    return Array.from(this.executions.values()).sort((a, b) => b.startedAt - a.startedAt).slice(0, limit);
+  }
+  // ── Export / Import ───────────────────────────────────────────────
+  /** Export a skill definition as a legacy SkillDefinition */
+  toSkillDefinition(id) {
+    const skill = this.skills.get(id);
+    if (!skill) return void 0;
+    const m = skill.manifest;
+    return {
+      id: m.id,
+      name: m.name,
+      version: m.version,
+      description: m.description,
+      prompt: m.steps.map((s) => s.prompt).join("\n\n"),
+      tools: m.requiresTools,
+      modelPreference: m.modelPreference,
+      category: m.category,
+      tags: m.tags,
+      params: m.params
+    };
+  }
+  /** Serialize all skills for persistence */
+  serialize() {
+    const data = this.getAll().map((s) => ({
+      manifest: s.manifest,
+      installedAt: s.installedAt,
+      lastUsedAt: s.lastUsedAt,
+      useCount: s.useCount,
+      enabled: s.enabled
+    }));
+    return JSON.stringify(data, null, 2);
+  }
+  /** Restore from serialized state */
+  deserialize(json) {
+    try {
+      const data = JSON.parse(json);
+      for (const item of data) {
+        this.skills.set(item.manifest.id, {
+          ...item,
+          status: item.manifest.source === "builtin" ? "builtin" : "installed",
+          error: void 0
+        });
+      }
+      this.notify();
+    } catch {
     }
-    return skills.length;
   }
-  /**
-   * Load skills from standard locations:
-   * 1. ~/.cliskill/skills/ (global user skills)
-   * 2. .cliskill/skills/ (project skills)
-   */
-  async loadStandardSkills(projectRoot) {
-    let count = 0;
-    const globalDir = getGlobalSkillsDir();
-    count += await this.loadFromDir(globalDir);
-    const projectDir = join3(projectRoot, ".cliskill", "skills");
-    count += await this.loadFromDir(projectDir);
-    return count;
+  // ── Event system ──────────────────────────────────────────────────
+  onChange(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
   }
-  /**
-   * Get skill prompt for injection into system prompt.
-   */
-  getSkillPrompt(nameOrAlias) {
-    const skill = this.get(nameOrAlias);
-    return skill?.prompt;
+  notify() {
+    for (const listener of this.listeners) listener();
   }
 };
+var skillRegistry = new SkillRegistry();
 
 // src/safety/permissions.ts
 var PermissionManager = class {
@@ -605,8 +1236,8 @@ function matchesAny(fullCommand, firstTwoWords, set) {
 }
 
 // src/services/history.ts
-import { readFile as readFile3, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
 import { dirname } from "path";
 var DEFAULT_CONFIG2 = {
   maxEntries: 1e3,
@@ -668,7 +1299,7 @@ var HistoryManager = class {
   async save() {
     const filePath = this.resolvePath();
     const dir = dirname(filePath);
-    if (!existsSync3(dir)) {
+    if (!existsSync2(dir)) {
       await mkdir2(dir, { recursive: true });
     }
     const lines = this.entries.map((e) => JSON.stringify(e)).join("\n");
@@ -676,35 +1307,256 @@ var HistoryManager = class {
   }
   async load() {
     const filePath = this.resolvePath();
-    if (!existsSync3(filePath)) {
+    if (!existsSync2(filePath)) {
       this.entries = [];
       this.cursorIndex = -1;
       return;
     }
-    const content = await readFile3(filePath, "utf-8");
-    const lines = content.split("\n").filter(Boolean);
-    const loaded = [];
-    for (const line of lines) {
-      try {
-        const entry = JSON.parse(line);
-        if (entry.content && typeof entry.content === "string" && entry.timestamp) {
-          loaded.push({
-            content: entry.content,
-            timestamp: entry.timestamp,
-            type: entry.type ?? "user"
-          });
-        }
-      } catch {
+    const content = await readFile2(filePath, "utf-8");
+    const lines = content.split("\n").filter(Boolean);
+    const loaded = [];
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.content && typeof entry.content === "string" && entry.timestamp) {
+          loaded.push({
+            content: entry.content,
+            timestamp: entry.timestamp,
+            type: entry.type ?? "user"
+          });
+        }
+      } catch {
+      }
+    }
+    this.entries = loaded.slice(-this.config.maxEntries);
+    this.cursorIndex = this.entries.length;
+  }
+  resolvePath() {
+    if (this.config.filePath.startsWith("~")) {
+      return getHistoryPath();
+    }
+    return this.config.filePath;
+  }
+};
+
+// src/utils/decomposition.ts
+var NUMBERED_LIST_REGEX = /(?:^|\n)\s*(?:\d+[\.|\)])\s*(.+?)(?=\n\s*(?:\d+[\.|\)])|$)/gs;
+
+// src/swarm/coordinator.ts
+var MAX_PARALLEL_WORKERS = 3;
+var SwarmCoordinator = class {
+  constructor(adapter, tools) {
+    this.adapter = adapter;
+    this.tools = tools;
+  }
+  adapter;
+  tools;
+  agents = /* @__PURE__ */ new Map();
+  mailbox = /* @__PURE__ */ new Map();
+  abortController = new AbortController();
+  addAgent(config) {
+    this.agents.set(config.id, config);
+    this.mailbox.set(config.id, []);
+  }
+  removeAgent(id) {
+    this.agents.delete(id);
+    this.mailbox.delete(id);
+  }
+  getAgents() {
+    return Array.from(this.agents.values());
+  }
+  async sendMessage(message) {
+    if (message.to === "*") {
+      for (const [agentId] of this.agents) {
+        this.mailbox.get(agentId)?.push({ ...message, to: agentId });
+      }
+    } else {
+      this.mailbox.get(message.to)?.push(message);
+    }
+  }
+  getMessages(agentId) {
+    return this.mailbox.get(agentId) ?? [];
+  }
+  async executeSwarm(task) {
+    this.abortController = new AbortController();
+    const startTime = performance.now();
+    const coordinator = this.findAgentByRole("coordinator");
+    const workers = this.findAgentsByRole("worker");
+    const reviewers = this.findAgentsByRole("reviewer");
+    const subtasks = coordinator ? await this.decomposeTask(coordinator, task) : this.fallbackDecompose(task, workers.length);
+    const assignments = this.assignSubtasks(subtasks, workers);
+    const workerResults = await this.executeParallel(assignments);
+    let reviewResult;
+    if (reviewers.length > 0) {
+      reviewResult = await this.reviewResults(reviewers[0], workerResults);
+    }
+    const results = workerResults.map((wr) => ({
+      agentId: wr.agentId,
+      agentName: wr.agentName,
+      task: wr.task,
+      result: wr.result,
+      success: wr.success,
+      duration: performance.now() - startTime,
+      turns: wr.turns
+    }));
+    if (reviewResult !== void 0 && reviewers.length > 0) {
+      results.push({
+        agentId: reviewers[0].id,
+        agentName: reviewers[0].name,
+        task: "Review all worker results",
+        result: reviewResult,
+        success: true,
+        duration: 0,
+        turns: 1
+      });
+    }
+    return results;
+  }
+  shutdown() {
+    this.abortController.abort();
+    for (const [agentId] of this.agents) {
+      this.mailbox.get(agentId)?.push({
+        from: "system",
+        to: agentId,
+        type: "shutdown",
+        content: "Shutdown requested",
+        timestamp: Date.now()
+      });
+    }
+  }
+  findAgentByRole(role) {
+    for (const agent of this.agents.values()) {
+      if (agent.role === role) return agent;
+    }
+    return void 0;
+  }
+  findAgentsByRole(role) {
+    return Array.from(this.agents.values()).filter((a) => a.role === role);
+  }
+  async decomposeTask(coordinator, task) {
+    const engine = this.createEngine(coordinator);
+    const prompt = `Decompose the following task into subtasks. Return ONLY a numbered list, one subtask per line. No explanations.
+
+Task: ${task}
+
+Subtasks:`;
+    let decomposition = "";
+    try {
+      for await (const event of engine.run(prompt)) {
+        if (event.type === "text_delta") decomposition += event.text;
+        if (event.type === "error") break;
+      }
+    } catch {
+      return this.fallbackDecompose(task, this.findAgentsByRole("worker").length);
+    }
+    const matches = [...decomposition.matchAll(NUMBERED_LIST_REGEX)];
+    if (matches.length === 0) {
+      return this.fallbackDecompose(task, this.findAgentsByRole("worker").length);
+    }
+    return matches.map((m, i) => ({
+      id: `subtask_${i + 1}`,
+      description: m[1].trim(),
+      status: "pending"
+    }));
+  }
+  fallbackDecompose(task, workerCount) {
+    const count = Math.max(1, Math.min(workerCount, MAX_PARALLEL_WORKERS));
+    return Array.from({ length: count }, (_, i) => ({
+      id: `subtask_${i + 1}`,
+      description: count === 1 ? task : `Part ${i + 1} of: ${task}`,
+      status: "pending"
+    }));
+  }
+  assignSubtasks(subtasks, workers) {
+    const assignments = [];
+    if (workers.length === 0) return assignments;
+    subtasks.forEach((task, i) => {
+      const worker = workers[i % workers.length];
+      task.assignedTo = worker.id;
+      assignments.push({ task, worker });
+    });
+    return assignments;
+  }
+  async executeParallel(assignments) {
+    const chunks = [];
+    for (let i = 0; i < assignments.length; i += MAX_PARALLEL_WORKERS) {
+      chunks.push(assignments.slice(i, i + MAX_PARALLEL_WORKERS));
+    }
+    const allResults = [];
+    for (const chunk of chunks) {
+      if (this.abortController.signal.aborted) break;
+      const settled = await Promise.allSettled(
+        chunk.map(async ({ task, worker }) => {
+          task.status = "running";
+          const engine = this.createEngine(worker);
+          let output = "";
+          let turns = 0;
+          try {
+            for await (const event of engine.run(task.description)) {
+              if (this.abortController.signal.aborted) break;
+              if (event.type === "text_delta") output += event.text;
+              if (event.type === "turn_end") turns = event.turn;
+              if (event.type === "complete") {
+                turns = event.result.turns;
+                output = output || event.result.messages.filter((m) => m.role === "assistant").flatMap((m) => m.content).filter((b) => b.type === "text").map((b) => b.text).join("\n");
+              }
+            }
+            task.status = "completed";
+            task.result = output;
+            return { agentId: worker.id, agentName: worker.name, task: task.description, result: output, success: true, turns };
+          } catch (err) {
+            task.status = "failed";
+            return { agentId: worker.id, agentName: worker.name, task: task.description, result: err.message, success: false, turns };
+          }
+        })
+      );
+      for (const r of settled) {
+        if (r.status === "fulfilled") allResults.push(r.value);
+        else allResults.push({ agentId: "unknown", agentName: "unknown", task: "", result: r.reason?.message ?? "Unknown error", success: false, turns: 0 });
+      }
+    }
+    return allResults;
+  }
+  async reviewResults(reviewer, results) {
+    const engine = this.createEngine(reviewer);
+    const summary = results.map((r, i) => `Worker ${i + 1} (${r.agentName}): ${r.success ? "SUCCESS" : "FAILED"}
+Task: ${r.task}
+Result: ${r.result.slice(0, 500)}`).join("\n\n");
+    const prompt = `Review the following worker results and provide a brief assessment:
+
+${summary}
+
+Provide a concise review:`;
+    let reviewText = "";
+    try {
+      for await (const event of engine.run(prompt)) {
+        if (event.type === "error") break;
+        if (event.type === "text_delta" && event.text) reviewText += event.text;
       }
+    } catch {
     }
-    this.entries = loaded.slice(-this.config.maxEntries);
-    this.cursorIndex = this.entries.length;
+    return reviewText || "Review completed with no output.";
   }
-  resolvePath() {
-    if (this.config.filePath.startsWith("~")) {
-      return getHistoryPath();
+  createEngine(agent) {
+    const filteredTools = new ToolRegistry();
+    if (agent.tools) {
+      for (const toolName of agent.tools) {
+        const tool = this.tools.get(toolName);
+        if (tool) filteredTools.register(tool);
+      }
+    } else {
+      for (const tool of this.tools.getAll()) {
+        if (tool.name !== "agent") filteredTools.register(tool);
+      }
     }
-    return this.config.filePath;
+    return new QueryEngine(
+      {
+        maxTurns: agent.maxTurns ?? 10,
+        systemPrompt: agent.systemPrompt ?? `You are agent "${agent.name}" with role "${agent.role}". Complete assigned tasks concisely.`
+      },
+      this.adapter,
+      filteredTools
+    );
   }
 };
 
@@ -787,12 +1639,23 @@ var HookExecutor = class {
   executeOne(hook, context) {
     const start = Date.now();
     if (hook.type === "function") {
-      return Promise.resolve({
-        hookId: hook.id,
-        success: true,
-        output: `Function handler "${hook.handler}" executed (stub)`,
-        duration: Date.now() - start
-      });
+      try {
+        const handlerFn = new Function("context", `return (${hook.handler})`);
+        const result = handlerFn(context);
+        return Promise.resolve({
+          hookId: hook.id,
+          success: true,
+          output: typeof result === "string" ? result : JSON.stringify(result),
+          duration: Date.now() - start
+        });
+      } catch (err) {
+        return Promise.resolve({
+          hookId: hook.id,
+          success: false,
+          output: `Function handler "${hook.handler}" failed: ${err.message}`,
+          duration: Date.now() - start
+        });
+      }
     }
     return this.executeCommand(hook, context, start);
   }
@@ -1145,207 +2008,6 @@ async function executeShellTask(taskId, manager, command, cwd, signal) {
     }
   });
 }
-
-// src/swarm/coordinator.ts
-var MAX_PARALLEL_WORKERS = 3;
-var SUBTASK_REGEX = /(?:^|\n)\s*(?:\d+[\.\)])\s*(.+?)(?=\n\s*(?:\d+[\.\)])|$)/gs;
-var SwarmCoordinator = class {
-  constructor(adapter, tools) {
-    this.adapter = adapter;
-    this.tools = tools;
-  }
-  adapter;
-  tools;
-  agents = /* @__PURE__ */ new Map();
-  mailbox = /* @__PURE__ */ new Map();
-  abortController = new AbortController();
-  addAgent(config) {
-    this.agents.set(config.id, config);
-    this.mailbox.set(config.id, []);
-  }
-  removeAgent(id) {
-    this.agents.delete(id);
-    this.mailbox.delete(id);
-  }
-  getAgents() {
-    return Array.from(this.agents.values());
-  }
-  async sendMessage(message) {
-    if (message.to === "*") {
-      for (const [agentId] of this.agents) {
-        this.mailbox.get(agentId)?.push({ ...message, to: agentId });
-      }
-    } else {
-      this.mailbox.get(message.to)?.push(message);
-    }
-  }
-  async executeSwarm(task) {
-    this.abortController = new AbortController();
-    const startTime = performance.now();
-    const coordinator = this.findAgentByRole("coordinator");
-    const workers = this.findAgentsByRole("worker");
-    const reviewers = this.findAgentsByRole("reviewer");
-    const subtasks = coordinator ? await this.decomposeTask(coordinator, task) : this.fallbackDecompose(task, workers.length);
-    const assignments = this.assignSubtasks(subtasks, workers);
-    const workerResults = await this.executeParallel(assignments);
-    if (reviewers.length > 0) {
-      await this.reviewResults(reviewers[0], workerResults);
-    }
-    const results = workerResults.map((wr) => ({
-      agentId: wr.agentId,
-      agentName: wr.agentName,
-      task: wr.task,
-      result: wr.result,
-      success: wr.success,
-      duration: performance.now() - startTime,
-      turns: wr.turns
-    }));
-    return results;
-  }
-  shutdown() {
-    this.abortController.abort();
-    for (const [agentId] of this.agents) {
-      this.mailbox.get(agentId)?.push({
-        from: "system",
-        to: agentId,
-        type: "shutdown",
-        content: "Shutdown requested",
-        timestamp: Date.now()
-      });
-    }
-  }
-  findAgentByRole(role) {
-    for (const agent of this.agents.values()) {
-      if (agent.role === role) return agent;
-    }
-    return void 0;
-  }
-  findAgentsByRole(role) {
-    return Array.from(this.agents.values()).filter((a) => a.role === role);
-  }
-  async decomposeTask(coordinator, task) {
-    const engine = this.createEngine(coordinator);
-    const prompt = `Decompose the following task into subtasks. Return ONLY a numbered list, one subtask per line. No explanations.
-
-Task: ${task}
-
-Subtasks:`;
-    let decomposition = "";
-    try {
-      for await (const event of engine.run(prompt)) {
-        if (event.type === "text_delta") decomposition += event.text;
-        if (event.type === "error") break;
-      }
-    } catch {
-      return this.fallbackDecompose(task, this.findAgentsByRole("worker").length);
-    }
-    const matches = [...decomposition.matchAll(SUBTASK_REGEX)];
-    if (matches.length === 0) {
-      return this.fallbackDecompose(task, this.findAgentsByRole("worker").length);
-    }
-    return matches.map((m, i) => ({
-      id: `subtask_${i + 1}`,
-      description: m[1].trim(),
-      status: "pending"
-    }));
-  }
-  fallbackDecompose(task, workerCount) {
-    const count = Math.max(1, Math.min(workerCount, MAX_PARALLEL_WORKERS));
-    return Array.from({ length: count }, (_, i) => ({
-      id: `subtask_${i + 1}`,
-      description: count === 1 ? task : `Part ${i + 1} of: ${task}`,
-      status: "pending"
-    }));
-  }
-  assignSubtasks(subtasks, workers) {
-    const assignments = [];
-    if (workers.length === 0) return assignments;
-    subtasks.forEach((task, i) => {
-      const worker = workers[i % workers.length];
-      task.assignedTo = worker.id;
-      assignments.push({ task, worker });
-    });
-    return assignments;
-  }
-  async executeParallel(assignments) {
-    const chunks = [];
-    for (let i = 0; i < assignments.length; i += MAX_PARALLEL_WORKERS) {
-      chunks.push(assignments.slice(i, i + MAX_PARALLEL_WORKERS));
-    }
-    const allResults = [];
-    for (const chunk of chunks) {
-      if (this.abortController.signal.aborted) break;
-      const settled = await Promise.allSettled(
-        chunk.map(async ({ task, worker }) => {
-          task.status = "running";
-          const engine = this.createEngine(worker);
-          let output = "";
-          let turns = 0;
-          try {
-            for await (const event of engine.run(task.description)) {
-              if (this.abortController.signal.aborted) break;
-              if (event.type === "text_delta") output += event.text;
-              if (event.type === "turn_end") turns = event.turn;
-              if (event.type === "complete") {
-                turns = event.result.turns;
-                output = output || event.result.messages.filter((m) => m.role === "assistant").flatMap((m) => m.content).filter((b) => b.type === "text").map((b) => b.text).join("\n");
-              }
-            }
-            task.status = "completed";
-            task.result = output;
-            return { agentId: worker.id, agentName: worker.name, task: task.description, result: output, success: true, turns };
-          } catch (err) {
-            task.status = "failed";
-            return { agentId: worker.id, agentName: worker.name, task: task.description, result: err.message, success: false, turns };
-          }
-        })
-      );
-      for (const r of settled) {
-        if (r.status === "fulfilled") allResults.push(r.value);
-        else allResults.push({ agentId: "unknown", agentName: "unknown", task: "", result: r.reason?.message ?? "Unknown error", success: false, turns: 0 });
-      }
-    }
-    return allResults;
-  }
-  async reviewResults(reviewer, results) {
-    const engine = this.createEngine(reviewer);
-    const summary = results.map((r, i) => `Worker ${i + 1} (${r.agentName}): ${r.success ? "SUCCESS" : "FAILED"}
-Task: ${r.task}
-Result: ${r.result.slice(0, 500)}`).join("\n\n");
-    const prompt = `Review the following worker results and provide a brief assessment:
-
-${summary}
-
-Provide a concise review:`;
-    try {
-      for await (const event of engine.run(prompt)) {
-        if (event.type === "error") break;
-      }
-    } catch {
-    }
-  }
-  createEngine(agent) {
-    const filteredTools = new ToolRegistry();
-    if (agent.tools) {
-      for (const toolName of agent.tools) {
-        const tool = this.tools.get(toolName);
-        if (tool) filteredTools.register(tool);
-      }
-    } else {
-      for (const tool of this.tools.getAll()) {
-        if (tool.name !== "agent") filteredTools.register(tool);
-      }
-    }
-    return new QueryEngine(
-      {
-        maxTurns: agent.maxTurns ?? 10,
-        systemPrompt: agent.systemPrompt ?? `You are agent "${agent.name}" with role "${agent.role}". Complete assigned tasks concisely.`
-      },
-      this.adapter,
-      filteredTools
-    );
-  }
-};
 export {
   AdapterRegistry,
   AgentTool,