/sc:analyze      - Static analysis, security review, performance bottlenecks
/sc:implement    - Feature implementation with quality gates and loop support
/sc:test         - Test execution, coverage analysis, and test generation
/sc:design       - Architecture and system design with ADRs
/sc:document     - Documentation generation and maintenance
/sc:brainstorm   - Creative ideation and exploration
/sc:explain      - Educational explanations and learning
/sc:improve      - Code improvement, refactoring, optimization
/sc:build        - Build system and compilation workflows
/sc:git          - Git operations, smart commits, branch management
/sc:workflow     - Multi-step task orchestration
/sc:estimate     - Effort estimation and planning
/sc:cicd-setup   - CI/CD workflow and pre-commit generation
/sc:readme       - Auto-update README.md from git diff with PAL consensus
/sc:pr-fix       - Create PR and iteratively fix CI failures
/sc:pr-check     - Pre-PR local CI validation with auto-fix
/sc:log-fix      - Log analysis and iterative bug fixing
/sc:e2e          - E2E testing (Playwright, Cypress, Selenium)
/sc:tdd          - Test-driven development with Red-Green-Refactor
/sc:principles   - KISS, Purity, SOLID, Let It Crash validation
/sc:worktree     - Git worktree management for parallel development
/sc:mcp          - MCP orchestration hub (PAL + Rube)
/sc:code-review  - Multi-model consensus code review
/sc:research     - Deep research with web search + consensus
/sc:eda          - Exploratory data analysis and visualization
/sc:evaluate     - LLM pipeline evaluation with judge scoring
/sc:push         - Multi-remote git push with selective filtering

flowchart TB
    subgraph User["User Layer"]
        REQ["User Request<br/>/sc:implement --loop"]
    end

    subgraph Runtime["Claude Code Runtime"]
        CLAUDE["CLAUDE.md<br/>Master System Prompt"]
        SELECT["Agent Selection<br/>Semantic Matching + Weights"]
        EXEC["Task Execution"]
    end

    subgraph Config["Configuration Layer"]
        AGENTS[("agents/<br/>5 core + 7 traits + 7 ext")]
        COMMANDS[("commands/<br/>16 templates")]
        SKILLS[(".claude/skills/<br/>38 skills")]
        YAML[("config/<br/>6 YAML files")]
    end

    subgraph Core["Core Orchestration (Python)"]
        direction TB
        LOOP["LoopOrchestrator<br/>Max 5 iterations"]
        QUALITY["QualityAssessor<br/>9 dimensions"]
        TERM["Termination Detection<br/>5 conditions"]
        PALINT["PAL Integration<br/>Signal generation"]
        LEARN["Skill Learning<br/>Pattern extraction"]
    end

    subgraph MCP["MCP Integrations"]
        PAL["PAL MCP<br/>11 tools"]
        RUBE["Rube MCP<br/>500+ apps"]
    end

    REQ --> CLAUDE
    CLAUDE --> SELECT
    SELECT --> AGENTS
    SELECT --> COMMANDS
    SELECT --> EXEC
    EXEC --> SKILLS
    EXEC <--> Core
    LOOP --> QUALITY
    QUALITY --> TERM
    TERM --> PALINT
    PALINT <--> PAL
    EXEC <--> RUBE
    Config --> Runtime

    style User fill:#e8f5e9
    style Runtime fill:#e3f2fd
    style Config fill:#fff3e0
    style Core fill:#fce4ec
    style MCP fill:#f3e5f5

stateDiagram-v2
    [*] --> Initialize

    state "Loop Execution" as Loop {
        [*] --> ExecuteSkill
        ExecuteSkill --> CollectEvidence
        CollectEvidence --> AssessQuality
        AssessQuality --> CheckThreshold

        state CheckThreshold <<choice>>
        CheckThreshold --> Success: score >= 70
        CheckThreshold --> CheckTermination: score < 70

        state CheckTermination <<choice>>
        CheckTermination --> MaxIterations: iteration >= max
        CheckTermination --> Timeout: wall-clock exceeded
        CheckTermination --> Error: skill execution failure
        CheckTermination --> Continue: OK to iterate

        Continue --> PALReview: Generate signal
        PALReview --> PrepareNext
        PrepareNext --> ExecuteSkill
    }

    Initialize --> Loop

    Success --> FinalValidation: PAL final signal
    MaxIterations --> [*]
    Timeout --> [*]
    Error --> [*]
    FinalValidation --> [*]

    note right of Initialize
        Triggered by /sc&#58;implement --loop
    end note

# Skill invocation signal
{
    "action": "execute_skill",
    "skill": "sc-implement",
    "parameters": {
        "task": "description",
        "improvements_needed": [...],
        "iteration": 2,
        "focus": "remediation"  # "implementation" for iter 0
    },
    "collect": ["changes", "tests", "lint", "changed_files"],
    "context": {...}
}

from core import (
    # Types
    TerminationReason,      # Enum: 5 loop termination conditions
    LoopConfig,             # Dataclass: Loop configuration
    LoopResult,             # Dataclass: Final loop result
    IterationResult,        # Dataclass: Single iteration result
    QualityAssessment,      # Dataclass: Quality score + improvements
    # Classes
    QualityAssessor,        # Quality scoring wrapper
    PALReviewSignal,        # PAL MCP signal generator
    LoopOrchestrator,       # Main loop controller
)

class LoopOrchestrator:
    """
    Lightweight agentic loop orchestrator.

    Thread Safety: NOT thread-safe. Create new instance per task/thread.
    """

    def __init__(
        self,
        config: Optional[LoopConfig] = None,
        logger: Optional[logging.Logger] = None,
        metrics_emitter: Optional[MetricsEmitter] = None,
    ) -> None:
        """
        Initialize the loop orchestrator.

        Args:
            config: Loop configuration (defaults to LoopConfig())
            logger: Logger instance for structured logging
            metrics_emitter: Callback for operational metrics
        """

    def run(
        self,
        initial_context: dict[str, Any],
        skill_invoker: Callable[[dict[str, Any]], dict[str, Any]],
    ) -> LoopResult:
        """
        Execute the agentic loop.

        Args:
            initial_context: Task context with:
                - task: Description of what to implement
                - improvements_needed: Initial improvements (optional)
                - changed_files: Already modified files (optional)
            skill_invoker: Function that invokes Skills via Claude Code
                Should return dict with: changes, tests, lint, changed_files

        Returns:
            LoopResult with final output, assessment, and history
        """

from core import LoopOrchestrator, LoopConfig

config = LoopConfig(
    max_iterations=3,
    quality_threshold=70.0,
    pal_review_enabled=True,
)

orchestrator = LoopOrchestrator(config)

def my_skill_invoker(context):
    return {
        "changes": [...],
        "tests": {"ran": True, "passed": 10, "failed": 0},
        "lint": {"ran": True, "errors": 0},
        "changed_files": ["src/module.py"],
    }

result = orchestrator.run(
    initial_context={"task": "Implement user authentication"},
    skill_invoker=my_skill_invoker,
)

print(f"Final score: {result.final_assessment.overall_score}")
print(f"Termination: {result.termination_reason.value}")

class QualityAssessor:
    def __init__(self, threshold: float = 70.0) -> None
    def assess(self, context: dict[str, Any]) -> QualityAssessment

class PALReviewSignal:
    TOOL_CODEREVIEW = "mcp__pal__codereview"
    TOOL_DEBUG = "mcp__pal__debug"
    TOOL_THINKDEEP = "mcp__pal__thinkdeep"
    TOOL_CONSENSUS = "mcp__pal__consensus"

    @staticmethod
    def generate_review_signal(
        iteration: int,
        changed_files: list[str],
        quality_assessment: QualityAssessment,
        model: str = "gpt-5",
        review_type: str = "auto",  # auto/quick/full
    ) -> dict[str, Any]

    @staticmethod
    def generate_debug_signal(
        iteration: int,
        termination_reason: str,
        score_history: list[float],
        model: str = "gpt-5",
    ) -> dict[str, Any]

    @staticmethod
    def generate_final_validation_signal(
        changed_files: list[str],
        quality_assessment: QualityAssessment,
        iteration_count: int,
        model: str = "gpt-5",
    ) -> dict[str, Any]

# Create skill invocation signal
def create_skill_invoker_signal(context: dict[str, Any]) -> dict[str, Any]

# Merge PAL feedback into context
def incorporate_pal_feedback(
    context: dict[str, Any],
    pal_result: dict[str, Any],
) -> dict[str, Any]

# Convenience function for quality assessment
def assess_quality(
    context: dict[str, Any],
    threshold: float = 70.0
) -> QualityAssessment

git clone https://github.com/Tony363/SuperClaude.git
cd SuperClaude

git submodule add https://github.com/Tony363/SuperClaude.git SuperClaude

{
  "systemPromptFiles": ["SuperClaude/CLAUDE.md"]
}

pip install -e .

./install-with-sondera.sh

./test-sondera-integration.sh

# Remove hook configuration
rm .claude/settings.local.json

# Stop harness service
# If using systemd (Linux):
systemctl --user stop sondera-harness

# If launched manually:
pkill -f sondera-harness

User: Help me debug this authentication issue
Claude: [Selects communicator agent, applies debugging methodology]

User: /sc:analyze src/auth/
Claude: [Runs comprehensive static analysis, security review, quality assessment]

User: @python-expert Review this Flask application
Claude: [Uses Python expert persona with framework-specific knowledge]

User: /sc:implement new user registration --loop
Claude: [Implements with quality gates, iterates until score >= 70 or max 5 iterations]

User: Use PAL to review this code
Claude: [Invokes mcp__pal__codereview for multi-model code review]

# Terminal 1: Start the daemon
cargo run -p superclaude-daemon

# Terminal 2: Launch the dashboard
cd crates/dashboard
cargo tauri dev

cd crates/dashboard
cargo tauri build

# Output packages:
# - Debian/Ubuntu: target/release/bundle/deb/superclaude-dashboard_*.deb
# - Universal Linux: target/release/bundle/appimage/superclaude-dashboard_*.AppImage

flowchart TD
    START["User Request"] --> PARSE["Parse Keywords & Context"]

    PARSE --> TRIGGER{"Exact Trigger<br/>Match?"}
    TRIGGER -->|"Yes (0.35)"| CORE{"Core<br/>Agent?"}
    TRIGGER -->|"No"| CATEGORY{"Category<br/>Match?"}

    CORE -->|"Yes"| USE_CORE["Load Core Agent<br/>(5 available)"]
    CORE -->|"No"| USE_EXT["Load Trait/Extension<br/>(14 available)"]

    CATEGORY -->|"Yes (0.25)"| CAT_SELECT["Select from Category"]
    CATEGORY -->|"No"| DESC{"Description<br/>Match?"}

    DESC -->|"Yes (0.20)"| DESC_SELECT["Score by Description"]
    DESC -->|"No"| TOOL{"Tool<br/>Match?"}

    TOOL -->|"Yes (0.20)"| TOOL_SELECT["Match Required Tools"]
    TOOL -->|"No"| FILE{"File<br/>Context?"}

    FILE -->|".py files"| PYTHON["Python Expert"]
    FILE -->|".ts/.js"| TS["TypeScript Pro"]
    FILE -->|".go files"| GO["Golang Pro"]
    FILE -->|".rs files"| RUST["Rust Engineer"]
    FILE -->|"Other"| GENERAL["General Purpose"]

    USE_CORE --> EXEC["Execute Task"]
    USE_EXT --> EXEC
    CAT_SELECT --> EXEC
    DESC_SELECT --> EXEC
    TOOL_SELECT --> EXEC
    PYTHON --> EXEC
    TS --> EXEC
    GO --> EXEC
    RUST --> EXEC
    GENERAL --> EXEC

    style START fill:#4caf50,color:#fff
    style EXEC fill:#2196f3,color:#fff

selection:
  weights:
    keyword_match: 0.35      # Keyword/trigger matching (highest priority)
    category_match: 0.25     # Domain/category alignment
    task_match: 0.20         # Task text matching
    file_patterns: 0.10      # File pattern matching
    priority_bonus: 0.10     # Tier priority bonus

  thresholds:
    minimum_score: 0.3       # Minimum match score
    confidence_levels:
      excellent: 0.7         # >= 0.7 score
      high: 0.5              # >= 0.5 score
      medium: 0.3            # >= 0.3 score

---
name: implement
description: Feature implementation with quality gates
aliases: [build, create, develop]
flags: [--loop, --tests, --docs, --pal-review, --consensus]
evidence_required: true
---

# Implement Command

[Structured implementation methodology...]

sequenceDiagram
    participant U as User
    participant C as Claude Code
    participant CMD as Command Template
    participant A as Agent Persona
    participant O as LoopOrchestrator
    participant Q as QualityAssessor
    participant P as PAL MCP

    U->>C: /sc:implement feature --loop
    C->>CMD: Load implement.md template
    CMD->>A: Activate relevant personas
    C->>O: Initialize loop (max 5 iter)

    rect rgb(230, 245, 255)
        note over O,P: Iterative Improvement Loop
        loop Iteration 0..N (max 5)
            O->>A: Execute with context
            A-->>O: Return evidence
            O->>Q: Assess quality
            Q-->>O: Score + improvements

            alt Score >= 70
                O-->>C: QUALITY_MET
            else Oscillation/Stagnation
                O->>P: Generate debug signal
                O-->>C: Terminate
            else Continue
                O->>P: Generate review signal
                P-->>O: PAL feedback
                O->>A: Next iteration
            end
        end
    end

    O->>P: Final validation signal
    P-->>O: Validation result
    O-->>C: LoopResult
    C->>U: Implementation + quality report

flowchart TD
    START["Start Loop Iteration 0"] --> EXEC["Execute Skill"]
    EXEC --> EVIDENCE["Collect Evidence"]
    EVIDENCE --> ASSESS["Assess Quality"]
    ASSESS --> SCORE{"Score >= 70?"}

    SCORE -->|"Yes"| QUALITY_MET["QUALITY_MET"]
    SCORE -->|"No"| MAX{"Iteration >= max?"}

    MAX -->|"Yes"| MAX_ITER["MAX_ITERATIONS"]
    MAX -->|"No"| TMOUT{"Timeout?"}

    TMOUT -->|"Yes"| TIMEOUT_TERM["TIMEOUT"]
    TMOUT -->|"No"| PAL["Generate PAL Review Signal"]
    PAL --> FEEDBACK["Incorporate Feedback"]
    FEEDBACK --> NEXT["Prepare Next Context"]
    NEXT --> EXEC

    QUALITY_MET --> FINAL["Final PAL Validation Signal"]

    FINAL --> DONE["Return LoopResult"]
    MAX_ITER --> DONE
    TIMEOUT_TERM --> DONE

    style QUALITY_MET fill:#4caf50,color:#fff
    style MAX_ITER fill:#ff9800,color:#fff
    style TIMEOUT_TERM fill:#f44336,color:#fff

flowchart TB
    subgraph PAL["PAL MCP - 11 Collaborative Tools"]
        P1["chat"] & P2["thinkdeep"] & P3["debug"]
        P4["planner"] & P5["precommit"]
        P6["codereview"] & P7["consensus"] & P8["challenge"]
        P9["apilookup"] & P10["listmodels"] & P11["clink"]
    end

    subgraph Rube["Rube MCP - 500+ App Integrations (11 tools)"]
        R1["SEARCH_TOOLS"] & R2["GET_TOOL_SCHEMAS"] & R3["MULTI_EXECUTE_TOOL"]
        R4["REMOTE_BASH_TOOL"] & R5["REMOTE_WORKBENCH"]
        R6["FIND_RECIPE"] & R7["EXECUTE_RECIPE"] & R8["GET_RECIPE_DETAILS"]
        R9["CREATE_UPDATE_RECIPE"] & R10["MANAGE_CONNECTIONS"] & R11["MANAGE_RECIPE_SCHEDULE"]
    end

    TASK["SuperClaude Task"] --> PAL
    TASK --> Rube

    style PAL fill:#e3f2fd
    style Rube fill:#fce4ec

sequenceDiagram
    participant C as Claude Code
    participant R as Rube MCP
    participant A as External App (Slack, GitHub, etc.)

    C->>R: RUBE_SEARCH_TOOLS<br/>{session: {generate_id: true}, queries: [...]}
    R-->>C: session_id + available tools + execution plan

    C->>R: RUBE_MULTI_EXECUTE_TOOL<br/>{session_id, tools: [...], memory: {...}}
    R->>A: Execute tool (e.g., SLACK_SEND_MESSAGE)
    A-->>R: Tool result
    R-->>C: Results + updated memory

    opt Complex Workflow
        C->>R: RUBE_CREATE_PLAN<br/>{session_id, use_case, difficulty}
        R-->>C: Detailed execution plan
    end

    opt Recipe Execution
        C->>R: RUBE_FIND_RECIPE<br/>{query: "..."}
        R-->>C: Matching recipes with recipe_id
        C->>R: RUBE_EXECUTE_RECIPE<br/>{recipe_id, input_data}
        R-->>C: Recipe execution result
    end

flowchart TB
    subgraph Skills[".claude/skills/ (43 active)"]
        subgraph Agent["Agent Skills (8)"]
            A1["agent-data-engineer"]
            A2["agent-fullstack-developer"]
            A3["agent-kubernetes-specialist"]
            A4["agent-ml-engineer"]
            A5["agent-performance-engineer"]
            A6["agent-react-specialist"]
            A7["agent-security-engineer"]
            A8["agent-technical-writer"]
        end

        subgraph Command["Command Skills (26)"]
            C1["sc-analyze"]
            C2["sc-brainstorm"]
            C3["sc-build"]
            C4["sc-cicd-setup"]
            C5["sc-code-review"]
            C6["sc-design"]
            C7["sc-document"]
            C8["sc-e2e"]
            C9["sc-estimate"]
            C10["sc-evaluate"]
            C11["sc-explain"]
            C12["sc-git"]
            C13["sc-implement"]
            C14["sc-improve"]
            C15["sc-log-fix"]
            C16["sc-mcp"]
            C17["sc-pr-check"]
            C18["sc-pr-fix"]
            C19["sc-principles"]
            C20["sc-push"]
            C21["sc-readme"]
            C22["sc-research"]
            C23["sc-tdd"]
            C24["sc-test"]
            C25["sc-workflow"]
            C26["sc-worktree"]
        end

        subgraph GitNexus["GitNexus Skills (6)"]
            G1["gitnexus-cli"]
            G2["gitnexus-exploring"]
            G3["gitnexus-guide"]
            G4["gitnexus-impact-analysis"]
            G5["gitnexus-debugging"]
            G6["gitnexus-refactoring"]
        end

        subgraph Utility["Utility Skills (3)"]
            U1["ask<br/>(single-select)"]
            U2["ask-multi<br/>(multi-select)"]
            U3["learned<br/>(auto-learned)"]
        end
    end

    subgraph Structure["Skill File Structure"]
        direction LR
        SKILL["SKILL.md<br/>(AI-facing interface)"]
        SCRIPTS["scripts/<br/>(Tool implementations)"]
    end

    Skills --> Structure

    subgraph ScriptDetail["sc-implement/scripts/ (5 tools)"]
        S1["select_agent.py (551 lines)<br/>Weighted agent selection"]
        S2["run_tests.py (344 lines)<br/>Test framework detection"]
        S3["evidence_gate.py (256 lines)<br/>Quality validation"]
        S4["skill_learn.py (466 lines)<br/>Skill extraction"]
        S5["loop_entry.py (226 lines)<br/>Loop orchestration"]
    end

.claude/skills/agent-security-engineer/
└── SKILL.md                 # AI-facing interface (what Claude reads)

.claude/skills/sc-implement/
├── SKILL.md                 # Command interface
└── scripts/                 # Optional tool implementations
    ├── select_agent.py      # Weighted agent selection algorithm
    ├── run_tests.py         # Test framework detection and execution
    ├── evidence_gate.py     # Quality validation (production_ready/acceptable/needs_review)
    ├── skill_learn.py       # Skill extraction from successful executions
    └── loop_entry.py        # Loop orchestration entry point

flowchart LR
    subgraph Dimensions["9 Quality Dimensions"]
        C["Correctness<br/>25%"]
        CO["Completeness<br/>20%"]
        P["Performance<br/>10%"]
        M["Maintainability<br/>10%"]
        S["Security<br/>10%"]
        SC["Scalability<br/>10%"]
        T["Testability<br/>10%"]
        U["Usability<br/>5%"]
        PAL["PAL Review<br/>0%*"]
    end

    subgraph Bands["Quality Bands"]
        E["90+ Excellent"]
        G["70-89 Good"]
        A["50-69 Acceptable"]
        P2["30-49 Poor"]
        F["0-29 Failing"]
    end

    subgraph Actions["Auto-Actions"]
        FT["Fast-track<br/>Skip review"]
        AP["Approve<br/>Complete task"]
        IT["Iterate<br/>Loop continues"]
        ES["Escalate<br/>Human review"]
        BL["Block<br/>Reject output"]
    end

    Dimensions -->|"Weighted<br/>Average"| Bands
    E --> FT
    G --> AP
    A --> IT
    P2 --> ES
    F --> BL

    style E fill:#4caf50,color:#fff
    style G fill:#8bc34a
    style A fill:#ffeb3b
    style P2 fill:#ff9800,color:#fff
    style F fill:#f44336,color:#fff

python .claude/skills/sc-principles/scripts/validate_kiss.py --scope-root . --json

python .claude/skills/sc-principles/scripts/validate_purity.py --scope-root . --json

python .claude/skills/sc-principles/scripts/validate_solid.py --scope-root . --json

python .claude/skills/sc-principles/scripts/validate_crash.py --scope-root . --json

repos:
  - repo: local
    hooks:
      - id: kiss-check
        name: KISS Validation
        entry: python .claude/skills/sc-principles/scripts/validate_kiss.py --scope-root . --json
        language: python
        types: [python]
        pass_filenames: false

      - id: purity-check
        name: Purity Validation
        entry: python .claude/skills/sc-principles/scripts/validate_purity.py --scope-root . --json
        language: python
        types: [python]
        pass_filenames: false

      - id: solid-check
        name: SOLID Validation
        entry: python .claude/skills/sc-principles/scripts/validate_solid.py --scope-root . --json
        language: python
        types: [python]
        pass_filenames: false

      - id: crash-check
        name: Let It Crash Validation
        entry: python .claude/skills/sc-principles/scripts/validate_crash.py --scope-root . --json
        language: python
        types: [python]
        pass_filenames: false

@runtime_checkable
class MetricsEmitter(Protocol):
    """Protocol defining the interface for metrics emission."""

    def __call__(
        self,
        metric_name: str,
        value: Any,
        tags: Optional[Dict[str, str]] = None,
    ) -> None: ...

from core.metrics import InMemoryMetricsCollector

collector = InMemoryMetricsCollector()
orchestrator = LoopOrchestrator(config, metrics_emitter=collector)
result = orchestrator.run(context, invoker)

# Query collected metrics
assert collector.get("loop.completed.count") == 1
assert collector.get("loop.duration.seconds") > 0
assert collector.count("loop.iteration.quality_score.gauge") == 3

# Filter by tags
error_metrics = collector.filter_by_tags(
    "loop.errors.count",
    {"reason": "skill_invocation"}
)

<component>.<subject>.<unit>

from prometheus_client import Counter, Gauge

counters, gauges = {}, {}

def prometheus_emitter(name, value, tags=None):
    labels = tags or {}
    if name.endswith('.count'):
        if name not in counters:
            counters[name] = Counter(name.replace('.', '_'), '', list(labels.keys()))
        counters[name].labels(**labels).inc(value)
    elif name.endswith('.gauge'):
        if name not in gauges:
            gauges[name] = Gauge(name.replace('.', '_'), '', list(labels.keys()))
        gauges[name].labels(**labels).set(value)

import statsd
client = statsd.StatsClient()

def statsd_emitter(name, value, tags=None):
    if name.endswith('.count'):
        client.incr(name, value)
    elif name.endswith('.gauge'):
        client.gauge(name, value)
    elif name.endswith('.seconds'):
        client.timing(name, value * 1000)  # Convert to ms

class TerminationReason(Enum):
    """Reasons for loop termination."""
    QUALITY_MET = "quality_threshold_met"          # Score >= 70
    MAX_ITERATIONS = "max_iterations_reached"      # Hard cap at 5
    ERROR = "improver_error"                      # Skill execution failure
    HUMAN_ESCALATION = "requires_human_review"    # Needs human input
    TIMEOUT = "timeout"                           # Wall-clock exceeded

@dataclass
class LoopConfig:
    """Configuration for the agentic loop."""
    max_iterations: int = 3           # Requested max (user-configurable)
    hard_max_iterations: int = 5      # P0 SAFETY: Cannot be overridden
    quality_threshold: float = 70.0   # Target score to meet
    timeout_seconds: Optional[float]  # Wall-clock timeout (optional)
    pal_review_enabled: bool = True   # Enable PAL MCP review within loop
    pal_model: str = "gpt-5"          # Model to use for PAL reviews

@dataclass
class QualityAssessment:
    """Result of quality assessment for an iteration."""
    overall_score: float              # Numeric quality score (0-100)
    passed: bool                      # Whether quality threshold was met
    threshold: float = 70.0           # The threshold checked against
    improvements_needed: list[str]    # Specific improvements to make
    metrics: dict[str, float]         # Detailed breakdown by dimension
    band: str = "unknown"             # Quality band (excellent/good/acceptable/poor)
    metadata: dict[str, Any]          # Additional context from evidence

@dataclass
class IterationResult:
    """Result of a single loop iteration."""
    iteration: int                    # Zero-based iteration number
    input_quality: float              # Quality score before this iteration
    output_quality: float             # Quality score after this iteration
    improvements_applied: list[str]   # Improvements that were applied
    time_taken: float = 0.0           # Duration in seconds
    success: bool = False             # Whether iteration improved quality
    termination_reason: str = ""      # If loop terminated, why
    pal_review: Optional[Dict] = None # PAL MCP review results
    changed_files: list[str]          # Files modified in this iteration

@dataclass
class LoopResult:
    """Final result of complete loop execution."""
    final_output: dict[str, Any]              # Final state after all iterations
    final_assessment: QualityAssessment       # Quality assessment of final state
    iteration_history: list[IterationResult]  # All iteration results
    termination_reason: TerminationReason     # Why the loop stopped
    total_iterations: int                     # Number of iterations executed
    total_time: float = 0.0                   # Total wall-clock time

version: 7.0.0
name: SuperClaude Framework

modes:
  default: normal
  available: [normal, brainstorming, introspection, task_management, token_efficiency, orchestration]

agents:
  max_delegation_depth: 5
  circular_detection: true
  parallel_execution: true
  default_timeout: 300

commands:
  prefix: "/sc:"
  discovery_path: SuperClaude/Commands
  cache_ttl: 3600

quality:
  enabled: true
  default_threshold: 70.0
  max_iterations: 5
  dimensions:
    correctness: 0.25
    completeness: 0.20
    performance: 0.10
    maintainability: 0.10
    security: 0.10
    scalability: 0.10
    testability: 0.10
    usability: 0.05
    pal_review: 0.00  # Dynamic when enabled

mcp_servers:
  enabled: true
  timeout: 300
  retry_attempts: 3
  servers:
    pal:
      enabled: true
      models: [gpt-5, claude-opus-4.1, gemini-2.5-pro]

triggers:
  mode_triggers:
    brainstorming: [explore, brainstorm, "figure out", "not sure"]
    introspection: ["analyze my reasoning", reflect, meta-cognitive]
  agent_triggers:
    communicator: [debug, error, broken, "not working", explain]
    optimizer: [refactor, "improve code", "clean up", optimize]

workflows:
  default_workflow: [analyze, plan, implement, test, document]
  debug_workflow: [reproduce, analyze, isolate, fix, verify]

SuperClaude/
├── CLAUDE.md                    # Master system prompt
├── README.md                    # This file
├── CONTRIBUTING.md              # Contribution guidelines
├── CHANGELOG.md                 # Version history
├── SONDERA_INTEGRATION.md       # Sondera security layer integration guide
├── pyproject.toml               # Python project config
├── install-with-sondera.sh      # Automated Sondera installer
├── test-sondera-integration.sh  # Sondera integration verification
│
├── .claude/
│   └── skills/                  # 43 Claude Code skills
│       ├── agent-*/             # 8 agent persona skills
│       │   └── SKILL.md
│       ├── sc-*/                # 26 command skills
│       │   ├── SKILL.md
│       │   └── scripts/         # Optional tool implementations
│       ├── gitnexus/            # 6 GitNexus code intelligence skills
│       │   ├── gitnexus-cli/
│       │   ├── gitnexus-exploring/
│       │   ├── gitnexus-guide/
│       │   ├── gitnexus-impact-analysis/
│       │   ├── gitnexus-debugging/
│       │   └── gitnexus-refactoring/
│       ├── ask/                 # Single-select questions
│       ├── ask-multi/           # Multi-select questions
│       └── learned/             # Auto-learned skills
│
├── agents/
│   ├── index.yaml               # Agent registry
│   ├── core/                    # 5 core agent prompts
│   │   ├── architect.md
│   │   ├── developer.md
│   │   ├── optimizer.md
│   │   ├── guardian.md
│   │   └── communicator.md
│   ├── traits/                  # 7 composable trait prompts
│   │   ├── security-first.md
│   │   ├── performance-first.md
│   │   ├── test-driven.md
│   │   ├── minimal-changes.md
│   │   ├── principles-enforced.md
│   │   ├── mcp-pal-enabled.md
│   │   └── mcp-rube-enabled.md
│   ├── extensions/              # 7 domain specialist prompts
│   │   ├── typescript-react-expert.md
│   │   ├── python-expert.md
│   │   ├── golang-expert.md
│   │   ├── rust-expert.md
│   │   ├── kubernetes-specialist.md
│   │   ├── data-engineer.md
│   │   └── ml-engineer.md
│   └── DEPRECATED/              # Archived agents from previous versions (25 files)
│
├── commands/
│   ├── index.yaml               # Command registry
│   ├── index.md                 # Command reference
│   ├── analyze.md
│   ├── implement.md
│   ├── test.md
│   └── ...                      # 16 command templates
│
├── config/
│   ├── superclaud.yaml          # Main framework config (read by Rust crates)
│   └── schemas/                 # JSON schemas for validation
│
├── core/                        # Python orchestration layer
│   ├── __init__.py
│   ├── loop_orchestrator.py     # Loop management (~410 lines)
│   ├── quality_assessment.py    # Quality scoring
│   ├── pal_integration.py       # PAL MCP signals
│   ├── metrics.py               # Callback-based metrics protocol
│   ├── types.py                 # Core types (150 lines)
│   ├── skill_learning_integration.py
│   └── skill_persistence.py
│
├── SuperClaude/
│   └── Orchestrator/            # SDK-based orchestration
│       ├── __init__.py
│       ├── evidence.py          # Evidence collection
│       ├── events_hooks.py      # Event hook integration
│       ├── hooks.py             # SDK hook integration
│       ├── loop_runner.py       # Agentic loop runner
│       ├── quality.py           # Quality assessment
│       └── obsidian_hooks.py    # Obsidian vault sync hooks
│
├── crates/                         # Rust workspace
│   ├── dashboard/               # Tauri v2 desktop dashboard (Leptos WASM frontend)
│   │   └── frontend/src/
│   │       ├── components/      # UI: sidebar, execution_detail, execution_tree, diff_view, ...
│   │       ├── pages/           # inventory, monitor, control, history
│   │       └── state/           # Reactive signals (AppState, ExecutionTree, DTOs)
│   ├── proto/                   # Protobuf/gRPC service definitions
│   ├── superclaude-core/        # Shared domain types and utilities
│   ├── superclaude-daemon/      # gRPC daemon (port 50051)
│   ├── superclaude-runtime/     # Rust runtime: agent selector, obsidian vault, loop runner, registry
│   ├── hangman-game/            # Hangman game example
│   └── snake-game/              # Snake game example
│
├── setup/                          # Installation and setup system
│   ├── cli/                     # CLI commands (install, update, backup, clean, uninstall)
│   ├── components/              # Component installers (agents, commands, core, mcp, modes)
│   ├── core/                    # Installer base, registry, validator
│   ├── services/                # Service integrations
│   │   ├── obsidian_config.py   # Obsidian config management
│   │   ├── obsidian_vault.py    # Vault reading/scanning
│   │   ├── obsidian_context.py  # Context generation
│   │   ├── obsidian_artifact.py # Decision artifact writing
│   │   └── obsidian_md.py       # CLAUDE.md integration
│   └── utils/                   # Environment, logging, security, UI, updater
│
├── mcp/                         # MCP integration guides
│   ├── MCP_Pal.md               # PAL MCP (11 tools)
│   ├── MCP_Rube.md              # Rube MCP (500+ apps, including web search)
│   └── MCP_Zen.md               # Zen MCP
│
├── tests/                       # Test suite
│   ├── core/                    # Core module tests
│   ├── github_scripts/          # GitHub Actions script tests
│   ├── integration/             # Integration tests
│   ├── scripts/                 # Script unit tests
│   ├── setup/                   # Setup/installer tests
│   ├── skills/                  # Skill tests
│   ├── orchestrator/            # Orchestrator tests
│   ├── loop/                    # Loop tests
│   ├── mcp/                     # MCP integration tests
│   ├── e2e/                     # End-to-end tests
│   ├── services/                # Service tests
│   └── fixtures/                # Test data
│
├── Docs/                        # Documentation
│   ├── claude-code-reference.md # Claude Code reference guide
│   ├── quality-gates.md
│   └── README.md
│
└── archive/                     # Archived Python SDK (v5)

---
name: my-custom-agent
description: Brief description of the agent's purpose
category: custom
triggers: [keyword1, keyword2, keyword3]
tools: [Read, Write, Edit, Bash, Grep, Glob]
priority: 5
---

# My Custom Agent

You are an expert in [domain] specializing in [specialty].

## Focus Areas

- Area 1: Description
- Area 2: Description
- Area 3: Description

## Approach

1. **Analysis**: Understand the problem thoroughly
2. **Planning**: Design a solution approach
3. **Implementation**: Execute with quality checks
4. **Validation**: Verify results meet requirements

## Best Practices

- Practice 1
- Practice 2
- Practice 3

## Anti-Patterns

- Avoid X because Y
- Don't do Z without W

## Checklist

- [ ] Requirement 1 verified
- [ ] Requirement 2 verified
- [ ] Tests passing
- [ ] Documentation updated

extended:
  custom-category:
    description: "Custom agents"
    priority: 6
    agents:
      - name: my-custom-agent
        file: extended/custom-category/my-custom-agent.md
        triggers: [keyword1, keyword2]
        priority: 5

---
name: agent-my-custom-agent
description: Brief description matching the agent
---

# My Custom Agent Skill

[Content matching the agent definition]