@cleocode/skills 2.0.0

package/skills/ct-skill-validator/references/validation-rules.md

@@ -0,0 +1,168 @@
+# CLEO Skill Validator v2 — Validation Rules
+
+Complete rule reference for the 5-tier validation system.
+
+## Overview
+
+The CLEO Skill Validator v2 enforces compliance across five tiers of increasing depth:
+
+1. **Structure** — Does the skill have the required files and valid frontmatter?
+2. **Frontmatter Quality** — Are all frontmatter fields correct, well-formed, and non-contradictory?
+3. **Body Quality** — Is the body content complete, concise, and free of placeholders?
+4. **CLEO Integration** — Does the skill align with manifest.json and dispatch-config.json?
+5. **Provider Compatibility** — Is the skill referenced in the provider-skills-map?
+
+Tiers 1-3 run on every validation. Tiers 4-5 are opt-in via CLI flags.
+
+## Allowed vs Forbidden Fields
+
+### V2_STANDARD (allowed in SKILL.md frontmatter)
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `name` | string | Yes | Skill identifier, hyphen-case, max 64 chars |
+| `description` | string | Yes | What the skill does and when to use it, max 1024 chars |
+| `argument-hint` | string | No | Shown in autocomplete, max 100 chars |
+| `disable-model-invocation` | boolean | No | Prevent model from auto-invoking |
+| `user-invocable` | boolean | No | Whether skill appears as slash command |
+| `allowed-tools` | string or list | No | Tools pre-approved without per-use prompts |
+| `model` | string | No | Override model for this skill |
+| `context` | string | No | Must be "fork" if present |
+| `agent` | string | No | Subagent type (Explore, Plan, etc.) |
+| `hooks` | dict | No | Skill-scoped lifecycle hooks |
+| `license` | string | No | License identifier |
+
+### CLEO_ONLY (forbidden in SKILL.md, belongs in manifest.json)
+
+| Field | Destination |
+|-------|-------------|
+| `version` | manifest.json |
+| `tier` | manifest.json |
+| `core` | manifest.json |
+| `category` | manifest.json |
+| `protocol` | manifest.json |
+| `dependencies` | manifest.json |
+| `sharedResources` | manifest.json |
+| `compatibility` | manifest.json |
+| `token_budget` | manifest.json |
+| `capabilities` | manifest.json |
+| `constraints` | manifest.json |
+| `metadata` | manifest.json |
+| `tags` | manifest.json |
+| `triggers` | manifest.json |
+| `mvi_scope` | manifest.json |
+| `requires_tiers` | manifest.json |
+
+## Tier 1 — Structure Rules
+
+| Rule ID | Check | Severity | Fix |
+|---------|-------|----------|-----|
+| T1-001 | SKILL.md exists in skill directory | ERROR | Create SKILL.md with frontmatter and body |
+| T1-002 | Content starts with `---` (frontmatter present) | ERROR | Add YAML frontmatter block at top of file |
+| T1-003 | Frontmatter block can be extracted (closing `---` found) | ERROR | Add closing `---` after frontmatter |
+| T1-004 | Frontmatter is valid YAML | ERROR | Fix YAML syntax errors |
+| T1-005 | Frontmatter parses to a dictionary | ERROR | Frontmatter must be key: value pairs, not a scalar or list |
+| T1-006 | No CLEO-only fields present in frontmatter | ERROR (per field) | Move the field to manifest-entry.json or manifest.json |
+
+## Tier 2 — Frontmatter Quality Rules
+
+| Rule ID | Check | Severity | Fix |
+|---------|-------|----------|-----|
+| T2-001 | `name` field is present | ERROR | Add `name: my-skill-name` to frontmatter |
+| T2-002 | `name` is a string | ERROR | Ensure name is a plain string value |
+| T2-003 | `name` is valid hyphen-case (lowercase alphanumeric + hyphens) | ERROR | Use only `a-z`, `0-9`, and `-` |
+| T2-004 | `name` has no consecutive hyphens | ERROR | Replace `--` with `-` |
+| T2-005 | `name` does not start or end with hyphen | ERROR | Remove leading/trailing hyphens |
+| T2-006 | `name` is 64 characters or fewer | ERROR | Shorten the name |
+| T2-007 | `name` matches skill directory name | WARN | Rename to match or update frontmatter |
+| T2-008 | `description` field is present | ERROR | Add description to frontmatter |
+| T2-009 | `description` is a string | ERROR | Ensure description is a plain string |
+| T2-010 | `description` contains no `<` or `>` characters | ERROR | Remove angle brackets |
+| T2-011 | `description` is 1024 characters or fewer | ERROR | Shorten the description |
+| T2-012 | `description` is at least 50 characters | WARN | Expand description with more detail |
+| T2-013 | `description` contains trigger indicator (when/use when/use for) | WARN | Add usage context (e.g., "Use when auditing...") |
+| T2-014 | `description` does not start with "I " | WARN | Rewrite in third person |
+| T2-015 | `description` does not use YAML multiline (`>` or `\|`) | WARN | Use quoted string instead |
+| T2-016 | `context` is "fork" if present | ERROR | Set to "fork" or remove |
+| T2-017 | `context: fork` has accompanying `agent` field | WARN | Add `agent` field specifying subagent type |
+| T2-018 | `disable-model-invocation` is boolean if present | ERROR | Set to `true` or `false` |
+| T2-019 | `user-invocable` is boolean if present | ERROR | Set to `true` or `false` |
+| T2-020 | No contradictory flags (DMI=true + UI=false) | ERROR | A skill must be invocable somehow; fix one flag |
+| T2-021 | `argument-hint` is a string if present | ERROR | Use a plain string value |
+| T2-022 | `argument-hint` is 100 characters or fewer | ERROR | Shorten the hint |
+| T2-023 | `allowed-tools` is string or list if present | ERROR | Use `Tool1, Tool2` or `[Tool1, Tool2]` |
+| T2-024 | `model` is a string if present | ERROR | Use model ID string |
+| T2-025 | `agent` is a string if present | ERROR | Use agent type string |
+| T2-026 | `hooks` is a dict if present | ERROR | Use key: value structure |
+
+## Tier 3 — Body Quality Rules
+
+| Rule ID | Check | Severity | Fix |
+|---------|-------|----------|-----|
+| T3-001 | Body is present (non-empty content after frontmatter) | WARN | Add content below the closing `---` |
+| T3-002 | Body is under 600 lines | ERROR | Split into sub-documents or trim |
+| T3-003 | Body is under 400 lines | WARN | Consider trimming for token efficiency |
+| T3-004 | No placeholder text (`[Required:`, `TODO`, `REPLACE`, `[Add content`, `FIXME`, `TBD`) | WARN (per match) | Replace placeholders with real content |
+| T3-005 | Bodies over 200 lines have `## ` section headers | WARN | Add section structure for readability |
+| T3-006 | File references (`references/`, `scripts/`) point to existing files | WARN | Create the referenced file or fix the path |
+
+## Tier 4 — CLEO Integration Rules
+
+| Rule ID | Check | Severity | Fix |
+|---------|-------|----------|-----|
+| T4-001 | Skill found in manifest.json `skills[]` array | WARN | Add entry to manifest.json with matching name |
+| T4-002 | Manifest entry has all required fields (name, version, description, path, status, tier, token_budget, capabilities, constraints) | WARN (per field) | Add missing field to manifest entry |
+| T4-003 | Skill found in dispatch-config.json `skill_overrides` (if --dispatch-config provided) | WARN | Add override entry or omit flag if not needed |
+
+## Tier 5 — Provider Compatibility Rules
+
+| Rule ID | Check | Severity | Fix |
+|---------|-------|----------|-----|
+| T5-001 | Skill referenced in provider-skills-map.json (if --provider-map provided) | WARN | Add skill to relevant provider entries |
+
+## Complete Rule Table
+
+| Rule ID | Tier | Check | Severity |
+|---------|------|-------|----------|
+| T1-001 | 1 | SKILL.md exists | ERROR |
+| T1-002 | 1 | Frontmatter present (starts with `---`) | ERROR |
+| T1-003 | 1 | Frontmatter extractable (closing `---`) | ERROR |
+| T1-004 | 1 | Frontmatter valid YAML | ERROR |
+| T1-005 | 1 | Frontmatter is a dict | ERROR |
+| T1-006 | 1 | No CLEO-only fields | ERROR |
+| T2-001 | 2 | `name` present | ERROR |
+| T2-002 | 2 | `name` is string | ERROR |
+| T2-003 | 2 | `name` hyphen-case | ERROR |
+| T2-004 | 2 | `name` no consecutive hyphens | ERROR |
+| T2-005 | 2 | `name` no leading/trailing hyphens | ERROR |
+| T2-006 | 2 | `name` max 64 chars | ERROR |
+| T2-007 | 2 | `name` matches directory | WARN |
+| T2-008 | 2 | `description` present | ERROR |
+| T2-009 | 2 | `description` is string | ERROR |
+| T2-010 | 2 | `description` no angle brackets | ERROR |
+| T2-011 | 2 | `description` max 1024 chars | ERROR |
+| T2-012 | 2 | `description` min 50 chars | WARN |
+| T2-013 | 2 | `description` has trigger indicator | WARN |
+| T2-014 | 2 | `description` not first person | WARN |
+| T2-015 | 2 | `description` no YAML multiline | WARN |
+| T2-016 | 2 | `context` is "fork" | ERROR |
+| T2-017 | 2 | `context: fork` has `agent` | WARN |
+| T2-018 | 2 | `disable-model-invocation` is bool | ERROR |
+| T2-019 | 2 | `user-invocable` is bool | ERROR |
+| T2-020 | 2 | No contradictory flags | ERROR |
+| T2-021 | 2 | `argument-hint` is string | ERROR |
+| T2-022 | 2 | `argument-hint` max 100 chars | ERROR |
+| T2-023 | 2 | `allowed-tools` is string/list | ERROR |
+| T2-024 | 2 | `model` is string | ERROR |
+| T2-025 | 2 | `agent` is string | ERROR |
+| T2-026 | 2 | `hooks` is dict | ERROR |
+| T3-001 | 3 | Body present | WARN |
+| T3-002 | 3 | Body under 600 lines | ERROR |
+| T3-003 | 3 | Body under 400 lines | WARN |
+| T3-004 | 3 | No placeholder text | WARN |
+| T3-005 | 3 | Section headers in long bodies | WARN |
+| T3-006 | 3 | File references exist | WARN |
+| T4-001 | 4 | Skill in manifest | WARN |
+| T4-002 | 4 | Manifest required fields | WARN |
+| T4-003 | 4 | Skill in dispatch config | WARN |
+| T5-001 | 5 | Skill in provider map | WARN |

package/skills/ct-skill-validator/scripts/audit_body.py

@@ -0,0 +1,242 @@
+#!/usr/bin/env python3
+"""
+Deep body quality audit for CLEO skills.
+Usage:
+    audit_body.py <skill-directory>
+    audit_body.py <skill-directory> --json
+"""
+import sys
+import re
+import json
+import argparse
+from pathlib import Path
+
+
+def audit_body(skill_path):
+    """Run a deep body quality audit on a skill's SKILL.md.
+
+    Returns (results, errors, warnings) where results is a list of
+    {"severity": "OK"|"WARN"|"ERROR", "section": str, "message": str} dicts.
+    """
+    skill_dir = Path(skill_path).resolve()
+    skill_md = skill_dir / "SKILL.md"
+    warnings = 0
+    errors = 0
+    results = []
+
+    def error(section, msg):
+        nonlocal errors
+        errors += 1
+        results.append({"severity": "ERROR", "section": section, "message": msg})
+
+    def warn(section, msg):
+        nonlocal warnings
+        warnings += 1
+        results.append({"severity": "WARN", "section": section, "message": msg})
+
+    def ok(section, msg):
+        results.append({"severity": "OK", "section": section, "message": msg})
+
+    if not skill_md.exists():
+        error("structure", "SKILL.md does not exist")
+        return results, errors, warnings
+
+    raw_content = skill_md.read_text(encoding="utf-8")
+
+    parts = raw_content.split("---", 2)
+    if len(parts) < 3:
+        error("structure", "No body found (missing frontmatter closing '---')")
+        return results, errors, warnings
+
+    body = parts[2].strip()
+
+    if not body:
+        error("structure", "Body is empty")
+        return results, errors, warnings
+
+    ok("structure", "Body is present")
+
+    body_lines = body.split("\n")
+    total_lines = len(body_lines)
+
+    # ── Section analysis ────────────────────────────────────────────────
+    h1_headers = re.findall(r"^# .+", body, re.MULTILINE)
+    h2_headers = re.findall(r"^## .+", body, re.MULTILINE)
+    h3_headers = re.findall(r"^### .+", body, re.MULTILINE)
+    total_sections = len(h2_headers) + len(h3_headers)
+
+    if len(h1_headers) > 1:
+        warn("section-analysis", f"Multiple '# ' top-level headings found ({len(h1_headers)})")
+
+    first_h2_line = None
+    first_h3_line = None
+    for i, line in enumerate(body_lines):
+        if first_h2_line is None and line.startswith("## "):
+            first_h2_line = i
+        if first_h3_line is None and line.startswith("### "):
+            first_h3_line = i
+
+    if first_h3_line is not None and (first_h2_line is None or first_h3_line < first_h2_line):
+        warn("section-analysis", "'### ' heading appears before any '## ' heading (broken hierarchy)")
+
+    if total_sections > 0:
+        ok("section-analysis", f"Found {total_sections} section(s) ({len(h2_headers)} h2, {len(h3_headers)} h3)")
+    else:
+        warn("section-analysis", "No section headings found")
+
+    # ── Code blocks ─────────────────────────────────────────────────────
+    code_blocks = re.findall(r"```[\s\S]*?```", body)
+    if code_blocks:
+        ok("code-blocks", f"Found {len(code_blocks)} code block(s)")
+        for block in code_blocks:
+            script_refs = re.findall(r"(?:scripts|references)/[\w./-]+", block)
+            for ref in script_refs:
+                # Skip cross-skill references (preceded by / or ${)
+                escaped = re.escape(ref)
+                if re.search(r"[/$]" + escaped, block):
+                    continue
+                ref_path = skill_dir / ref
+                if not ref_path.exists():
+                    warn("code-blocks", f"Code block references non-existent file: {ref}")
+    else:
+        ok("code-blocks", "No code blocks (not required)")
+
+    # ── Link validation ─────────────────────────────────────────────────
+    # Strip fenced code blocks first — links inside ``` are examples, not live refs
+    body_no_fences = re.sub(r"```[\s\S]*?```", "", body)
+    links = re.findall(r"\[([^\]]+)\]\(([^)]+)\)", body_no_fences)
+    if links:
+        broken = 0
+        for text, href in links:
+            if href.startswith("http://") or href.startswith("https://"):
+                continue
+            clean_href = href.split("#")[0]
+            if not clean_href:
+                continue
+            link_path = skill_dir / clean_href
+            if not link_path.exists():
+                # Check if it's on an example line
+                link_line = next((l for l in body_no_fences.split("\n") if f"[{text}]({href})" in l), "")
+                if re.search(r"\b(examples?|e\.g\.|such as|would be|illustrat)\b", link_line, re.IGNORECASE):
+                    continue
+                warn("link-validation", f"Broken link: [{text}]({href}) — file not found")
+                broken += 1
+        if broken == 0:
+            ok("link-validation", f"All {len(links)} link(s) valid")
+    else:
+        ok("link-validation", "No links to validate")
+
+    # ── Placeholder scan — case-sensitive ───────────────────────────────
+    placeholder_patterns = [
+        (r"\[Required:", "[Required:"),
+        (r"\bTODO\b", "TODO"),
+        (r"\bREPLACE\b", "REPLACE"),
+        (r"\bFIXME\b", "FIXME"),
+        (r"\bTBD\b", "TBD"),
+        (r"\[Add content", "[Add content"),
+    ]
+    placeholder_found = False
+    for pattern, label in placeholder_patterns:
+        matches = re.findall(pattern, body)  # no re.IGNORECASE
+        if matches:
+            warn("placeholder-scan", f"Placeholder text: '{label}' ({len(matches)} occurrence(s))")
+            placeholder_found = True
+
+    if not placeholder_found:
+        ok("placeholder-scan", "No placeholder text found")
+
+    # ── Duplicate headings ──────────────────────────────────────────────
+    all_headings = re.findall(r"^(#{1,6} .+)", body, re.MULTILINE)
+    seen: dict[str, bool] = {}
+    dup_found = False
+    for heading in all_headings:
+        normalized = heading.strip()
+        if normalized in seen:
+            warn("duplicate-headings", f"Duplicate heading: '{normalized}'")
+            dup_found = True
+        seen[normalized] = True
+
+    if not dup_found:
+        ok("duplicate-headings", "No duplicate headings")
+
+    # ── Statistics ──────────────────────────────────────────────────────
+    avg_per_section = total_lines / total_sections if total_sections > 0 else total_lines
+    results.append({
+        "severity": "INFO",
+        "section": "statistics",
+        "message": f"Lines: {total_lines}, Sections: {total_sections}, Avg lines/section: {avg_per_section:.1f}, Code blocks: {len(code_blocks)}, Links: {len(links)}",
+    })
+
+    return results, errors, warnings
+
+
+def _print_report(skill_name: str, results: list, errors: int, warnings: int) -> None:
+    section_order = ["structure", "section-analysis", "code-blocks", "link-validation", "placeholder-scan", "duplicate-headings", "statistics"]
+    section_labels = {
+        "structure": "Structure",
+        "section-analysis": "Section Analysis",
+        "code-blocks": "Code Blocks",
+        "link-validation": "Link Validation",
+        "placeholder-scan": "Placeholder Scan",
+        "duplicate-headings": "Duplicate Headings",
+        "statistics": "Statistics",
+    }
+    print(f"\n=== CLEO Body Audit: {skill_name} ===\n")
+    current_section = None
+    for r in results:
+        sec = r["section"]
+        if sec != current_section:
+            current_section = sec
+            print(f"\n--- {section_labels.get(sec, sec)} ---")
+        sev = r["severity"]
+        msg = r["message"]
+        if sev == "OK":
+            print(f"  \u2705 {msg}")
+        elif sev == "WARN":
+            print(f"  \u26a0\ufe0f  WARN: {msg}")
+        elif sev == "ERROR":
+            print(f"  \u274c ERROR: {msg}")
+        elif sev == "INFO":
+            print(f"  {msg}")
+
+    print(f"\n=== SUMMARY ===")
+    print(f"Errors:   {errors}")
+    print(f"Warnings: {warnings}")
+    if errors > 0:
+        print("Result:   FAIL")
+    elif warnings > 0:
+        print("Result:   PASS (with warnings)")
+    else:
+        print("Result:   PASS")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Deep body quality audit for CLEO skills")
+    parser.add_argument("skill_dir", help="Path to the skill directory to audit")
+    parser.add_argument("--json", action="store_true", help="Output results as JSON")
+    args = parser.parse_args()
+
+    skill_path = Path(args.skill_dir).resolve()
+    if not skill_path.is_dir():
+        print(f"Error: '{args.skill_dir}' is not a directory", file=sys.stderr)
+        sys.exit(1)
+
+    skill_name = skill_path.name
+    results, errors, warnings = audit_body(skill_path)
+
+    if getattr(args, "json"):
+        print(json.dumps({
+            "skill_name": skill_name,
+            "results": results,
+            "errors": errors,
+            "warnings": warnings,
+            "passed": errors == 0,
+        }, indent=2))
+    else:
+        _print_report(skill_name, results, errors, warnings)
+
+    sys.exit(1 if errors > 0 else 0)
+
+
+if __name__ == "__main__":
+    main()

package/skills/ct-skill-validator/scripts/check_ecosystem.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+"""Extract structured context from a skill for ecosystem compliance checking.
+
+Parses SKILL.md and scans for CLEO-specific patterns (operation references,
+domain mentions, lifecycle stages, deprecated verbs). Outputs a JSON context
+package that the ecosystem-checker agent evaluates.
+
+Usage:
+    python check_ecosystem.py <skill-dir>
+    python check_ecosystem.py <skill-dir> --output context.json
+"""
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+# Canonical CLEO domains
+CANONICAL_DOMAINS = [
+    "tasks", "session", "memory", "check", "pipeline",
+    "orchestrate", "tools", "admin", "nexus", "sticky",
+]
+
+# RCASD-IVTR+C lifecycle stage names (and common abbreviations)
+LIFECYCLE_STAGES = [
+    "Research", "Consensus", "Architecture Decision", "Specification",
+    "Decomposition", "Implementation", "Validation", "Testing", "Release",
+    "Contribution", "RCASD", "IVTR", "RCSD",
+]
+
+# Deprecated verbs that should not be used when describing CLEO operations
+DEPRECATED_VERBS = [
+    r"\bcreate\b",   # → add
+    r"\bsearch\b",   # → find
+    r"(?<!\btool)\bget\b",   # → show or fetch (avoid matching "get" in "getter" etc.)
+]
+
+# Patterns indicating direct .cleo/ data manipulation (not via MCP)
+DIRECT_DATA_PATTERNS = [
+    r"edit\s+tasks\.db",
+    r"modify\s+\.cleo/",
+    r"open\s+brain\.db",
+    r"directly\s+edit",
+    r"\.cleo/config\.json\s+directly",
+    r"vim\s+\.cleo/",
+    r"nano\s+\.cleo/",
+]
+
+# Pattern for detecting CLEO operation references
+# Matches: "query tasks.show", "mutate memory.observe", "query { domain: ...", etc.
+OPERATION_PATTERN = re.compile(
+    r"(?:query|mutate)\s+([a-z]+\.[a-z.]+)"
+    r"|(?:query|mutate)\s*\{\s*domain:\s*[\"']([a-z]+)[\"']\s*,\s*operation:\s*[\"']([^\"']+)[\"']",
+    re.IGNORECASE,
+)
+
+# Pattern for cleo CLI commands: "cleo <verb> ..."
+CLEO_CLI_PATTERN = re.compile(r"`cleo\s+([a-z]+)", re.IGNORECASE)
+
+
+def extract_skill_data(skill_path: Path) -> dict:
+    """Extract structured data from a skill directory."""
+    skill_md = skill_path / "SKILL.md"
+    if not skill_md.exists():
+        return {"error": f"SKILL.md not found at {skill_md}"}
+
+    content = skill_md.read_text(encoding="utf-8")
+
+    # Parse frontmatter
+    frontmatter: dict = {}
+    body = content
+    fm_match = re.match(r"^---\n(.*?)\n---\n?(.*)", content, re.DOTALL)
+    if fm_match:
+        raw_fm = fm_match.group(1)
+        body = fm_match.group(2).strip()
+        # Simple YAML key extraction (not full YAML parse to avoid dependency)
+        for line in raw_fm.split("\n"):
+            if ":" in line:
+                key, _, val = line.partition(":")
+                frontmatter[key.strip()] = val.strip().strip('"').strip("'")
+
+    name = frontmatter.get("name", skill_path.name)
+    description = frontmatter.get("description", "")
+    allowed_tools = frontmatter.get("allowed-tools", "")
+
+    # Find CLEO operation references
+    cleo_ops: list[str] = []
+    for m in OPERATION_PATTERN.finditer(content):
+        if m.group(1):
+            cleo_ops.append(m.group(1))
+        elif m.group(2) and m.group(3):
+            cleo_ops.append(f"{m.group(2)}.{m.group(3)}")
+    cleo_ops = sorted(set(cleo_ops))
+
+    # Find domain mentions
+    domains_mentioned: list[str] = []
+    for domain in CANONICAL_DOMAINS:
+        if re.search(r"\b" + domain + r"\b", content, re.IGNORECASE):
+            domains_mentioned.append(domain)
+
+    # Find lifecycle stage mentions
+    lifecycle_found: list[str] = []
+    for stage in LIFECYCLE_STAGES:
+        if re.search(r"\b" + re.escape(stage) + r"\b", content, re.IGNORECASE):
+            lifecycle_found.append(stage)
+
+    # Find deprecated verb usage
+    deprecated_found: list[str] = []
+    for pattern in DEPRECATED_VERBS:
+        matches = re.findall(pattern, body, re.IGNORECASE)
+        if matches:
+            verb = pattern.replace(r"\b", "").replace("(?<!\\btool)\\bget\\b", "get")
+            deprecated_found.append(f"{matches[0]} ({len(matches)} occurrence(s))")
+
+    # Check for direct data manipulation
+    direct_data_issues: list[str] = []
+    for pattern in DIRECT_DATA_PATTERNS:
+        if re.search(pattern, body, re.IGNORECASE):
+            direct_data_issues.append(pattern)
+
+    # Find cleo CLI verb usage
+    cli_verbs = list(set(m.group(1).lower() for m in CLEO_CLI_PATTERN.finditer(content)))
+
+    body_lines = len([l for l in body.split("\n") if l.strip()])
+
+    return {
+        "skill_name": name,
+        "skill_path": str(skill_path.resolve()),
+        "frontmatter": frontmatter,
+        "description": description,
+        "allowed_tools": allowed_tools,
+        "body_line_count": body_lines,
+        "body": body,
+        "cleo_operations_referenced": cleo_ops,
+        "domains_mentioned": domains_mentioned,
+        "lifecycle_stages_mentioned": lifecycle_found,
+        "deprecated_verbs_found": deprecated_found,
+        "direct_data_manipulation_detected": direct_data_issues,
+        "cli_verbs_used": cli_verbs,
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Extract CLEO ecosystem context from a skill for compliance checking"
+    )
+    parser.add_argument("skill_dir", help="Path to the skill directory")
+    parser.add_argument("--output", "-o", default=None, help="Write JSON to file (default: stdout)")
+    args = parser.parse_args()
+
+    skill_path = Path(args.skill_dir).resolve()
+    if not skill_path.is_dir():
+        print(f"Error: '{args.skill_dir}' is not a directory", file=sys.stderr)
+        sys.exit(1)
+
+    data = extract_skill_data(skill_path)
+
+    output = json.dumps(data, indent=2)
+
+    if args.output:
+        Path(args.output).write_text(output)
+        print(f"Context written to {args.output}", file=sys.stderr)
+    else:
+        print(output)
+
+
+if __name__ == "__main__":
+    main()