/create-skill --url https://fastapi.tiangolo.com --name fastapi
/create-skill --url https://react.dev --name react --enhance

/create-skill --github facebook/react
/create-skill --github anthropics/anthropic-sdk-python --enhance

/create-skill --pdf /path/to/manual.pdf --name api-manual
/create-skill --pdf ~/Downloads/guide.pdf --name user-guide --enhance

# Use pre-configured framework from repository
/create-skill --config configs/fastapi.json
/create-skill --config configs/react.json
/create-skill --config configs/just.json

# Or use remote config URL
/create-skill --config https://raw.githubusercontent.com/.../config.json

# Validate required parameters
if [ -z "$URL" ] && [ -z "$GITHUB" ] && [ -z "$PDF" ] && [ -z "$CONFIG" ]; then
  echo "❌ Error: One of --url, --github, --pdf, or --config is required"
  exit 1
fi

# Validate source accessibility
if [ -n "$URL" ]; then
  curl -sI "$URL" | head -1 | grep -q "200" || {
    echo "❌ Error: URL not accessible: $URL"
    exit 1
  }
fi

# Validate PDF exists
if [ -n "$PDF" ]; then
  test -f "$PDF" || {
    echo "❌ Error: PDF file not found: $PDF"
    exit 1
  }
fi

# Validate config exists
if [ -n "$CONFIG" ]; then
  test -f "$CONFIG" || {
    echo "❌ Error: Config file not found: $CONFIG"
    echo "💡 Available configs: ls configs/"
    exit 1
  }
fi

# Ensure adequate space in INTEGRATION/incoming
AVAILABLE=$(df -h INTEGRATION/incoming | awk 'NR==2 {print $4}' | sed 's/G//')
if [ "$AVAILABLE" -lt 1 ]; then
  echo "⚠️  Warning: Low disk space (${AVAILABLE}GB available)"
  echo "Recommended: >1GB free in INTEGRATION/incoming"
fi

# Verify Python environment
python3 --version >/dev/null 2>&1 || {
  echo "❌ Error: Python 3.8+ required"
  exit 1
}

# Verify pip is available
pip --version >/dev/null 2>&1 || {
  echo "❌ Error: pip not found"
  exit 1
}

✅ Pre-execution validation passed
  • Input parameters: Valid
  • Source accessibility: Confirmed
  • Disk space: Adequate (XGB available)
  • Prerequisites: Python 3.x, pip installed

# Check if skill-seekers is installed
!which skill-seekers || python3 -m pip show skill-seekers

# Auto-install skill-seekers
!pip install skill-seekers

# Verify installation
!skill-seekers --version

🔧 Installing Skill Seekers...
✅ Skill Seekers v2.2.0 installed successfully

# Generate skill to default output/ directory
!skill-seekers scrape --url [URL] --name [NAME]

# Move to integration directory
!mv output/[NAME] INTEGRATION/incoming/[NAME]

# Extract repo name from owner/repo
REPO_NAME=$(echo [OWNER/REPO] | cut -d'/' -f2)

# Generate skill
!skill-seekers github --repo [OWNER/REPO]

# Move to integration directory
!mv output/$REPO_NAME INTEGRATION/incoming/$REPO_NAME

# Generate skill from PDF
!skill-seekers pdf --file [PDF_PATH] --name [NAME]

# Move to integration directory
!mv output/[NAME] INTEGRATION/incoming/[NAME]

# Generate from config file (local path or URL)
!skill-seekers scrape --config [CONFIG_PATH]

# Extract skill name from config JSON
SKILL_NAME=$(python3 -c "import json; print(json.load(open('[CONFIG_PATH]'))['name'])")

# Move to integration directory
!mv output/$SKILL_NAME INTEGRATION/incoming/$SKILL_NAME

🚀 Generating skill: [NAME]
📥 Source: [URL/GitHub/PDF]
📂 Default output: output/[NAME]
📂 Moving to: INTEGRATION/incoming/[NAME]

⏳ This may take 5-15 minutes depending on source size...

# Enhance in default location before moving
!skill-seekers enhance output/[NAME]

✨ Enhancing skill with AI refinement...
⏳ This may take 2-3 additional minutes...

# Move completed skill to integration directory
!mv output/[NAME] INTEGRATION/incoming/[NAME]

📦 Moving skill to integration directory...
✅ Skill moved to: INTEGRATION/incoming/[NAME]

# Check skill structure
!ls -la INTEGRATION/incoming/[NAME]/

# Verify SKILL.md exists
!test -f INTEGRATION/incoming/[NAME]/SKILL.md && echo "✅ SKILL.md found"

INTEGRATION/incoming/[NAME]/
├── SKILL.md               # Main skill file (required)
├── knowledge/             # Extracted documentation
│   ├── section1.md
│   └── section2.md
├── examples/              # Code samples
│   └── usage.py
└── references/            # Source materials
    └── sources.txt

# Verify required components
SKILL_DIR="INTEGRATION/incoming/[NAME]"

# Check SKILL.md exists and has minimum content
if [ -f "$SKILL_DIR/SKILL.md" ]; then
  LINES=$(wc -l < "$SKILL_DIR/SKILL.md")
  if [ "$LINES" -lt 50 ]; then
    echo "⚠️  Quality Warning: SKILL.md only $LINES lines (expected >50)"
  else
    echo "✅ SKILL.md: $LINES lines"
  fi
else
  echo "❌ CRITICAL: SKILL.md not found"
  exit 1
fi

# Check for required sections
grep -q "## Description" "$SKILL_DIR/SKILL.md" || echo "⚠️  Missing: Description section"
grep -q "## When to Use" "$SKILL_DIR/SKILL.md" || echo "⚠️  Missing: Activation triggers"
grep -q "## Example" "$SKILL_DIR/SKILL.md" || echo "⚠️  Missing: Examples"

# Count examples (should have 2-5)
EXAMPLES=$(grep -c "^### Example" "$SKILL_DIR/SKILL.md")
if [ "$EXAMPLES" -lt 2 ]; then
  echo "⚠️  Quality Warning: Only $EXAMPLES example(s), recommend 2-5"
elif [ "$EXAMPLES" -ge 2 ]; then
  echo "✅ Examples: $EXAMPLES provided"
fi

# Check knowledge directory size
if [ -d "$SKILL_DIR/knowledge" ]; then
  KNOWLEDGE_COUNT=$(find "$SKILL_DIR/knowledge" -type f | wc -l)
  echo "✅ Knowledge files: $KNOWLEDGE_COUNT extracted"
else
  echo "⚠️  Warning: No knowledge directory created"
fi

# Validate trigger clarity (Python snippet)
import re

with open(f'{SKILL_DIR}/SKILL.md', 'r') as f:
    content = f.read()

# Check for action-oriented triggers
triggers = re.findall(r'- When.*?(create|generate|analyze|review|build)', content, re.IGNORECASE)
if len(triggers) >= 3:
    print("✅ Activation triggers: Clear and action-oriented")
else:
    print("⚠️  Weak triggers: Add explicit action verbs (create, generate, analyze)")

╔═══════════════════════════════════════════════════╗
║          QUALITY ASSESSMENT RESULTS               ║
╚═══════════════════════════════════════════════════╝

STRUCTURE:     ✅ 5/5 (All sections present)
EXAMPLES:      ✅ 4/5 (3 examples provided)
TRIGGERS:      ⚠️  3/5 (Triggers need action verbs)
KNOWLEDGE:     ✅ 5/5 (42 files extracted)
DOCUMENTATION: ✅ 5/5 (Complete workflow)

TOTAL SCORE:   22/25 (88%) ✅ PASSED

RECOMMENDATIONS:
  • Strengthen activation triggers with explicit verbs
  • Consider adding 1-2 edge case examples

DEPLOYMENT STATUS: Ready for production ✅

# Invoke integration-scan command
@.claude/commands/integration-scan.md

🔍 Auto-scanning new skill for integration...

{
  "status": "success",
  "skill": {
    "name": "[NAME]",
    "source": {
      "type": "documentation|github|pdf|config",
      "url": "[SOURCE_URL]",
      "config": "[CONFIG_PATH]"
    },
    "output": {
      "directory": "INTEGRATION/incoming/[NAME]",
      "size_mb": 5.2,
      "files": {
        "skill_md": true,
        "knowledge_count": 42,
        "examples_count": 3,
        "references_count": 1
      }
    },
    "quality": {
      "score": 22,
      "max_score": 25,
      "percentage": 88,
      "status": "passed",
      "breakdown": {
        "structure": {"score": 5, "weight": 0.25},
        "examples": {"score": 4, "weight": 0.25},
        "triggers": {"score": 3, "weight": 0.20},
        "knowledge": {"score": 5, "weight": 0.15},
        "documentation": {"score": 5, "weight": 0.15}
      },
      "recommendations": [
        "Strengthen activation triggers with explicit verbs",
        "Consider adding 1-2 edge case examples"
      ]
    },
    "execution": {
      "duration_minutes": 12,
      "enhanced": true,
      "timestamp": "2026-01-23T06:30:00Z"
    },
    "integration": {
      "scanned": true,
      "scan_report": "/INTEGRATION/logs/scan-report-20260123-063000.md"
    }
  },
  "next_steps": [
    "Review skill: INTEGRATION/incoming/[NAME]/SKILL.md",
    "Run '/integration-process' to finalize integration",
    "Test skill: 'Use [NAME] skill to...'"
  ]
}

╔═══════════════════════════════════════════════════╗
║          SKILL CREATION COMPLETED                  ║
╚═══════════════════════════════════════════════════╝

SKILL: [NAME]
SOURCE: [URL/GitHub/PDF]
OUTPUT: INTEGRATION/incoming/[NAME]
ENHANCED: [Yes/No]

FILES CREATED:
  • SKILL.md ✓
  • knowledge/ ([X] files) ✓
  • examples/ ([X] files) ✓
  • references/ ([X] files) ✓

QUALITY ASSESSMENT:
  Score: 22/25 (88%) ✅ PASSED
  • Structure: 5/5 ✓
  • Examples: 4/5 ⚠️
  • Triggers: 3/5 ⚠️
  • Knowledge: 5/5 ✓
  • Documentation: 5/5 ✓

INTEGRATION STATUS:
  ✅ Scanned and categorized by /integration-scan
  📋 Report: /INTEGRATION/logs/scan-report-[timestamp].md
  📊 JSON output: /INTEGRATION/logs/creation-result-[timestamp].json

NEXT STEPS:
  1. Review skill: INTEGRATION/incoming/[NAME]/SKILL.md
  2. Address recommendations (strengthen triggers)
  3. Run '/integration-process' to finalize integration
  4. Test skill: "Use [NAME] skill to..."

Time: [X] minutes | Size: [X] MB | Quality: ✅ Ready for Production

❌ Failed to install skill-seekers
Reason: [error message]

Please install manually:
  pip install skill-seekers

Then retry: /create-skill [your-parameters]

❌ Skill generation failed
Source: [URL/GitHub/PDF]
Error: [detailed error message]

Common fixes:
  • Check URL is accessible
  • Verify GitHub repo exists (public access)
  • Ensure PDF file path is correct
  • Try without --enhance flag first

Retry with debug: skill-seekers [command] --verbose

⚠️ Skill generated but SKILL.md not found
Location: INTEGRATION/incoming/[NAME]

This may indicate:
  • Incomplete generation
  • Unexpected directory structure

Suggested actions:
  1. Check manually: ls -la INTEGRATION/incoming/[NAME]
  2. Review logs: skill-seekers --help
  3. Re-run with fresh output directory

⚠️ Skill created but auto-scan failed
Skill location: INTEGRATION/incoming/[NAME]

You can manually run integration scan:
  /integration-scan

/create-skill → INTEGRATION/incoming/ → /integration-scan (auto)
    ↓
Review scan report
    ↓
/integration-process → Move to skills-templates/
    ↓
/integration-validate → Quality checks
    ↓
/integration-update-docs → Update README
    ↓
Production-ready skill ✅

# Best approach: Use pre-configured config file from repository
/create-skill --config configs/fastapi.json

# Basic approach: Only captures 1 page (12 KB)
/create-skill --url https://fastapi.tiangolo.com --name fastapi

/create-skill --github facebook/react

/create-skill --config configs/just.json

/create-skill --pdf ~/Documents/api-reference-v3.pdf --name company-api --enhance

{
  "name": "framework-name",
  "description": "Short description",
  "base_url": "https://docs.example.com/",
  "start_urls": ["https://docs.example.com/tutorial/"],
  "url_patterns": {
    "include": ["/tutorial/", "/api/"],
    "exclude": ["/blog/", "/external/"]
  },
  "categories": {
    "getting_started": ["intro", "tutorial"],
    "api": ["api", "reference"]
  },
  "rate_limit": 0.5,
  "max_pages": 250
}

{
  "name": "just",
  "description": "Just command runner for project task automation",
  "base_url": "https://just.systems/",
  "start_urls": ["https://just.systems/man/en/"],
  "url_patterns": {
    "include": ["/man/en/"],
    "exclude": ["/blog/", "/changelog/"]
  },
  "categories": {
    "getting_started": ["introduction", "quick-start"],
    "recipes": ["recipes", "syntax"],
    "features": ["features", "patterns"]
  },
  "rate_limit": 0.5,
  "max_pages": 50
}

# Verify Python environment
python3 --version

# Install manually
pip install skill-seekers

# Verify
skill-seekers --version

# Wrong Python environment - check pip location
which pip
which python3

# Reinstall with correct pip
python3 -m pip install skill-seekers

# Use Skill Seekers directly with custom timeout
skill-seekers pdf --file huge.pdf --name huge-manual --timeout 3600

# Set OpenAI API key (if not already set)
export OPENAI_API_KEY="sk-..."

# Or skip enhancement for now
/create-skill --url https://example.com --name example

#!/bin/bash
# Auto-validate generated skills after creation

INPUT=$(cat)
TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name')

# Only run for Bash commands that moved files to INTEGRATION/incoming
if [ "$TOOL_NAME" = "Bash" ]; then
  COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command')

  if echo "$COMMAND" | grep -q "mv.*INTEGRATION/incoming"; then
    # Extract skill name from move command
    SKILL_NAME=$(echo "$COMMAND" | grep -oP 'INTEGRATION/incoming/\K[^/]+')
    SKILL_PATH="INTEGRATION/incoming/$SKILL_NAME"

    if [ -d "$SKILL_PATH" ]; then
      # Run validation
      if [ ! -f "$SKILL_PATH/SKILL.md" ]; then
        echo "❌ Quality gate failed: SKILL.md not found in $SKILL_NAME" >&2
        exit 2  # Blocking error
      fi

      # Check minimum line count
      LINES=$(wc -l < "$SKILL_PATH/SKILL.md")
      if [ "$LINES" -lt 50 ]; then
        echo "⚠️  Quality warning: SKILL.md only $LINES lines (expected >50)" >&2
      fi

      echo "✅ Quality gate passed: $SKILL_NAME validated"
    fi
  fi
fi

exit 0

{
  "hooks": {
    "PostToolUse": [{
      "matcher": "Bash",
      "hooks": [{
        "type": "command",
        "command": ".claude/hooks/posttooluse_skill_quality.sh",
        "timeout": 10
      }]
    }]
  }
}

name: Auto-Generate Skills

on:
  schedule:
    - cron: '0 2 * * 1'  # Weekly Monday 2 AM
  workflow_dispatch:
    inputs:
      framework:
        description: 'Framework config to generate'
        required: true
        type: choice
        options:
          - fastapi
          - react
          - django
          - just

jobs:
  generate-skill:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

      - name: Install Skill Seekers
        run: pip install skill-seekers

      - name: Generate Skill
        uses: anthropic/claude-code-action@v1
        with:
          api-key: ${{ secrets.ANTHROPIC_API_KEY }}
          command: /create-skill
          args: --config configs/${{ inputs.framework }}.json --enhance
          output-format: json

      - name: Parse Quality Results
        id: quality
        run: |
          SCORE=$(jq -r '.skill.quality.score' creation-result.json)
          MAX=$(jq -r '.skill.quality.max_score' creation-result.json)
          PERCENT=$(jq -r '.skill.quality.percentage' creation-result.json)

          echo "score=$SCORE" >> $GITHUB_OUTPUT
          echo "percentage=$PERCENT" >> $GITHUB_OUTPUT

          # Fail if quality below threshold
          if [ "$PERCENT" -lt 80 ]; then
            echo "❌ Quality check failed: $PERCENT% (minimum 80%)"
            exit 1
          fi

      - name: Create Pull Request
        if: steps.quality.outputs.percentage >= 80
        uses: peter-evans/create-pull-request@v5
        with:
          title: "feat(skills): add ${{ inputs.framework }} skill (quality: ${{ steps.quality.outputs.percentage }}%)"
          body: |
            ## Auto-Generated Skill

            **Framework**: ${{ inputs.framework }}
            **Quality Score**: ${{ steps.quality.outputs.score }}/25 (${{ steps.quality.outputs.percentage }}%)

            ### Quality Breakdown
            ${{ toJSON(steps.quality.outputs) }}

            ### Next Steps
            - [ ] Review SKILL.md content
            - [ ] Test skill activation
            - [ ] Verify examples work
            - [ ] Merge when satisfied
          branch: auto-skill/${{ inputs.framework }}
          labels: auto-generated, skills

# skill_metrics.py - Log creation metrics
import json
from datetime import datetime

def log_skill_creation(skill_name, quality_score, duration_min, source_type):
    """Log skill creation for trend analysis"""
    log_entry = {
        "timestamp": datetime.utcnow().isoformat(),
        "skill": skill_name,
        "quality_score": quality_score,
        "duration_minutes": duration_min,
        "source_type": source_type,
        "success": quality_score >= 20  # 80% threshold
    }

    with open("INTEGRATION/logs/skill-creation-metrics.jsonl", "a") as f:
        f.write(json.dumps(log_entry) + "\n")

# Monthly analysis
def analyze_monthly_trends():
    """Generate monthly skill creation report"""
    # Parse logs, calculate averages, identify patterns
    # Output: Markdown report for review

# /skill-generate - Generate skill (no validation)
!skill-seekers scrape --config $1 && mv output/* INTEGRATION/incoming/

# /skill-validate - Run quality checks only
!python3 validate_skill.py INTEGRATION/incoming/$1

# /skill-enhance - AI enhancement only
!skill-seekers enhance INTEGRATION/incoming/$1

# /create-skill-comprehensive - Full pipeline
1. Pre-validate source: /skill-validate-source $1
2. Generate: /skill-generate $1
3. Enhance: /skill-enhance $1
4. Quality check: /skill-validate $1
5. Integrate: /integration-scan
6. Report: Output JSON summary

allowed-tools:
  - "Bash(pip:install,show)"        # Only pip install and show
  - "Bash(skill-seekers:*)"          # All skill-seekers commands
  - "Bash(python3:-c,-m)"            # Only -c and -m flags
  - "Bash(which:*)"                   # Binary location checks
  - "Bash(ls:-la)"                    # List with details only
  - "Bash(mkdir:-p)"                  # Create directories only
  - "Bash(mv:*)"                      # Move operations
  - "Bash(test:-f)"                   # File existence checks only
  - "Read"                            # Read files
  - "Write"                           # Write logs

# Sanitize skill name input (prevent path traversal)
SKILL_NAME=$(echo "$INPUT_NAME" | sed 's/[^a-zA-Z0-9_-]//g')

# Validate config file path (prevent directory traversal)
if echo "$CONFIG_PATH" | grep -q '\.\./'; then
  echo "❌ Security: Path traversal detected in config path"
  exit 1
fi

# Sanitize URLs (prevent malicious redirects)
if ! echo "$URL" | grep -qE '^https?://[a-zA-Z0-9.-]+'; then
  echo "❌ Security: Invalid URL format"
  exit 1
fi

{
  "timestamp": "2026-01-23T06:30:00Z",
  "user": "${USER}",
  "command": "/create-skill",
  "parameters": {
    "config": "configs/fastapi.json",
    "enhance": true
  },
  "output": {
    "skill_name": "fastapi",
    "quality_score": 22,
    "status": "success"
  },
  "security_events": []
}

# tests/test_create_skill_command.py
import subprocess
import json
import pytest

def test_input_validation():
    """Verify input validation catches invalid parameters"""
    result = subprocess.run(
        ["claude", "code", "/create-skill"],  # No parameters
        capture_output=True,
        text=True
    )
    assert result.returncode == 1
    assert "Error: One of --url, --github, --pdf, or --config is required" in result.stderr

def test_source_accessibility():
    """Verify source accessibility check"""
    result = subprocess.run(
        ["claude", "code", "/create-skill", "--url", "https://invalid-domain-12345.com", "--name", "test"],
        capture_output=True,
        text=True
    )
    assert result.returncode == 1
    assert "URL not accessible" in result.stderr

def test_quality_scoring():
    """Verify quality scoring rubric"""
    # Generate test skill
    result = subprocess.run(
        ["claude", "code", "/create-skill", "--config", "tests/fixtures/minimal.json"],
        capture_output=True,
        text=True
    )

    # Parse JSON output
    output = json.loads(result.stdout)

    # Validate quality structure
    assert "quality" in output["skill"]
    assert output["skill"]["quality"]["score"] >= 0
    assert output["skill"]["quality"]["score"] <= 25
    assert output["skill"]["quality"]["percentage"] >= 0
    assert output["skill"]["quality"]["percentage"] <= 100

@pytest.mark.slow
def test_fastapi_config_generation():
    """Integration test: Full FastAPI skill generation"""
    result = subprocess.run(
        ["claude", "code", "/create-skill", "--config", "configs/fastapi.json"],
        capture_output=True,
        text=True,
        timeout=900  # 15 minutes
    )

    assert result.returncode == 0
    output = json.loads(result.stdout)

    # Validate output
    assert output["status"] == "success"
    assert output["skill"]["quality"]["percentage"] >= 80
    assert output["skill"]["output"]["files"]["skill_md"] == True

    # Verify file exists
    import os
    assert os.path.exists("INTEGRATION/incoming/fastapi/SKILL.md")

# .github/workflows/test-create-skill.yml
name: Test Create Skill Command

on:
  pull_request:
    paths:
      - '.claude/commands/create-skill.md'
      - 'configs/**'

jobs:
  test-command:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

      - name: Install Dependencies
        run: |
          pip install skill-seekers pytest

      - name: Run Unit Tests
        run: pytest tests/test_create_skill_command.py -v

      - name: Test Config Validation
        run: |
          # Verify all configs are valid JSON
          for config in configs/*.json; do
            jq empty "$config" || exit 1
          done

      - name: Integration Test (Fast Config)
        run: |
          # Test with small, fast config
          claude code /create-skill --config tests/fixtures/minimal.json

          # Verify output
          test -f INTEGRATION/incoming/minimal/SKILL.md

# BAD: Generate blindly
skill-seekers scrape --url $URL --name $NAME

# GOOD: Check source first
curl -sI "$URL" | grep -q "200" && skill-seekers scrape --url $URL --name $NAME

# BAD: Move to integration regardless of quality
mv output/$NAME INTEGRATION/incoming/

# GOOD: Check quality threshold
SCORE=$(calculate_quality_score)
if [ "$SCORE" -ge 20 ]; then
  mv output/$NAME INTEGRATION/incoming/
else
  echo "❌ Quality gate failed: Score $SCORE/25 (need ≥20)"
  exit 1
fi

# BAD: Assumes specific directory structure
mv output/fastapi ~/my-skills/fastapi

# GOOD: Respects configuration
INTEGRATION_DIR="${INTEGRATION_DIR:-INTEGRATION/incoming}"
mv output/$NAME "$INTEGRATION_DIR/$NAME"

# BAD: Unrestricted access
allowed-tools: ["Bash"]

# GOOD: Specific operations only
allowed-tools: ["Bash(skill-seekers:*)", "Bash(mv:*)", "Read", "Write"]

Skill generation failed?
│
├─> ❌ "Command not found"
│   └─> Check: Python installed? pip available?
│       Fix: python3 --version && pip --version
│
├─> ❌ "URL not accessible"
│   └─> Check: URL loads in browser? Behind auth?
│       Fix: Use --pdf for downloaded docs OR create config with auth headers
│
├─> ❌ "Quality score < 20"
│   ├─> Missing examples?
│   │   Fix: Run with --enhance flag
│   ├─> Weak activation triggers?
│   │   Fix: Manually edit SKILL.md to add action verbs
│   └─> Insufficient knowledge extracted?
│       Fix: Use config file instead of basic --url
│
├─> ❌ "SKILL.md not found"
│   └─> Check: skill-seekers version up to date?
│       Fix: pip install --upgrade skill-seekers
│
└─> ❌ "Out of disk space"
    └─> Check: df -h INTEGRATION/incoming
        Fix: Clean up old skills OR increase disk space