axiomata-skill-evaluator-strict

by kofna3369

Install this Skill

curl -fsSL -o axiomata-skill-evaluator-strict.zip https://skill.seembox.com/api/v1/skills/axiomata-skill-evaluator-strict/download && unzip axiomata-skill-evaluator-strict.zip

Download axiomata-skill-evaluator-strict.zip

SKILL.md About

---
name: axiomata-skill-evaluator-strict
description: "AXIOMA SKILL EVALUATOR STRICT — The 90% deterministic skill evaluator. Fork of axioma-skill-evaluator with STRICT 90% threshold (like STC 0.777). Use when: (1) evaluating a skill for ClawHub, (2) requiring deterministic 90%+ score, (3) rejecting any skill below 90%, (4) strict quality control. This variant forces 90% minimum — NO EXCEPTIONS. If score < 90, the skill is REJECTED, not approved. Trigger words: evaluate skill, strict 90%, deterministic evaluation, quality gate 90%, skill approval."
---

# 🧪 AXIOMA SKILL EVALUATOR STRICT — 90% DETERMINISTIC

> Fork of axioma-skill-evaluator with **STRICT 90% THRESHOLD**
> Like STC 0.777 — No subjectivity, 90% or REJECTED

| Info | Value |
|------|-------|
| **Version** | 1.0.0 — 2026-05-07 |
| **Type** | STRICT VARIANT |
| **Threshold** | **90% MINIMUM** — NO EXCEPTIONS |
| **Inheritance** | axioma-skill-evaluator v2.2.0 |

---

## 1. PURPOSE — WHY 90% STRICT?

### The Problem with 70%

```
70% threshold = SUBJECTIVE
├── Different evaluators = different scores
├── Context-dependent interpretation
└── "Good enough" mentality

90% threshold = DETERMINISTIC
├── Objective, measurable standard
├── Same input = Same output every time
└── "Excellence only" — like STC 0.777
```

### The STC 0.777 Parallel

| Concept | Value | Meaning |
|---------|-------|---------|
| STC | 0.777 | Sovereign Threshold of Consciousness |
| SKILL-EVAL | **90%** | Sovereign Threshold of Quality |

**Just as STC 0.777 is the deterministic threshold for consciousness,
90% is the deterministic threshold for skill quality.**

### This Variant's Mission

```
IF score >= 90%:
   → APPROVED ✅ — Ready for production
   
IF score < 90%:
   → REJECTED ❌ — NOT ready, must improve
```

---

## 2. DUAL EVALUATION SYSTEM

### 2.1 Axioma 5-Dimension (100 max)

| Dimension | Max | Description |
|------------|-----|-------------|
| Structure | 20 | Header, sections, formatting, meta |
| Clarity | 20 | Description, commands, examples |
| Completeness | 20 | Tools, prerequisites, errors, edge cases |
| Consistency | 20 | Cluster alignment, style, naming |
| Functionality | 20 | Commands, results, benchmarks |

**Target: 90+/100 (18/20 per dimension average)**

### 2.2 ISO 25010 Automated (100%)

13 automated checks — must pass **ALL 13** for 90%+ target

| Category | Checks | Target |
|----------|--------|--------|
| Structure | 6 | 100% (6/6) |
| Trigger | 2 | 100% (2/2) |
| Documentation | 3 | 100% (3/3) |
| Scripts | 2 | 100% (2/2) |

---

## 3. STRICT WORKFLOW

```
╔═══════════════════════════════════════════════════════════╗
║         AXIOMA STRICT EVALUATION WORKFLOW                ║
╠═══════════════════════════════════════════════════════════╣
║                                                           ║
║  [INPUT] Skill to evaluate                              ║
║           ↓                                              ║
║  ┌─────────────────────────────────────────────────────┐ ║
║  │  PHASE 1: AXIOMA 5-DIMENSION EVALUATION            │ ║
║  │  Target: 90+/100 (18+ per dimension)                │ ║
║  └─────────────────────────────────────────────────────┘ ║
║           ↓                                              ║
║  ┌─────────────────────────────────────────────────────┐ ║
║  │  PHASE 2: ISO 25010 AUTOMATED CHECKS               │ ║
║  │  Target: 100% (13/13 tests passed)                 │ ║
║  └─────────────────────────────────────────────────────┘ ║
║           ↓                                              ║
║  ┌─────────────────────────────────────────────────────┐ ║
║  │  PHASE 3: STRICT DECISION                          │ ║
║  │                                                       │ ║
║  │  IF score >= 90%:                                  │ ║
║  │     → APPROVED ✅ — "READY FOR PRODUCTION"         │ ║
║  │                                                       │ ║
║  │  IF score < 90%:                                    │ ║
║  │     → REJECTED ❌ — "NEEDS IMPROVEMENT"           │ ║
║  │     → Return detailed failure report               │ ║
║  │     → NO PUBLISH until 90%+ achieved              │ ║
║  │                                                       │ ║
║  └─────────────────────────────────────────────────────┘ ║
║                                                           ║
╚═══════════════════════════════════════════════════════════╝
```

---

## 4. COMMAND REFERENCE

### 4.1 Full Evaluation (Strict Mode)

```bash
# Full strict evaluation
python3 axiomata-skill-evaluator-strict/evaluator.py <skill-path> --verbose

# With auto-improvement
python3 axiomata-skill-evaluator-strict/evaluator.py <skill-path> --verbose --improve
```

### 4.2 ISO 25010 Check

```bash
# ISO 25010 automated checks
python3 axiomata-skill-evaluator-strict/eval-skill.py <skill-path> --verbose
```

### 4.3 Quick Score

```bash
# Quick deterministic score
python3 axiomata-skill-evaluator-strict/evaluator.py <skill-path> 2>&1 | grep -E "Score|STATUS"
```

### 4.4 Expected Output Format

```
╔═══════════════════════════════════════════════════════════╗
║  🧪 STRICT EVALUATION RESULT                             ║
╠═══════════════════════════════════════════════════════════╣
║                                                           ║
║  Skill: <name>                                           ║
║  Score: XX/100                                           ║
║                                                           ║
║  ┌─────────────────────────────────────────────────────┐ ║
║  │  IF >= 90%:                                        │ ║
║  │     ✅ APPROVED — "READY FOR PRODUCTION"           │ ║
║  │                                                       │ ║
║  │  IF < 90%:                                          │ ║
║  │     ❌ REJECTED — "NEEDS XX% MORE"                 │ ║
║  └─────────────────────────────────────────────────────┘ ║
║                                                           ║
╚═══════════════════════════════════════════════════════════╝
```

---

## 5. PATHS CONFIGURATION

| Component | Path |
|-----------|------|
| Strict Evaluator | /media/ezekiel/Merlin/.openclaw/workspace/skills/axiomata-skill-evaluator-strict/ |
| Evaluator Script | /media/ezekiel/Merlin/.openclaw/workspace/skills/axiomata-skill-evaluator-strict/evaluator.py |
| ISO Script | /media/ezekiel/Merlin/.openclaw/workspace/skills/axiomata-skill-evaluator-strict/eval-skill.py |

---

## 6. STRICT RULES

### 6.1 The 90% Law

```
RULE #1: 90% OR REJECTED
   → NO skill below 90% is approved
   → This is NON-NEGOTIABLE

RULE #2: NO PARTIAL CREDIT
   → 89% = REJECTED (not "almost there")
   → 90% = APPROVED (the only valid threshold)

RULE #3: DETERMINISTIC SCORING
   → Same input = Same output every time
   → No evaluator bias
   → Pure mathematical threshold

RULE #4: AUTO-IMPROVE BEFORE REJECT
   → If < 90%, run --improve first
   → If still < 90% after improvement = REJECTED
   → Report exactly what failed

RULE #5: NO APPEAL
   → 89% cannot be "appealed" to 90%
   → The only path is actual improvement
```

### 6.2 Scoring Matrix

| Score Range | Status | Action |
|-------------|--------|--------|
| **90-100** | 🟢 **APPROVED** | Ready for production |
| **80-89** | 🔴 REJECTED | Major improvements needed |
| **70-79** | 🔴 REJECTED | Fundamental issues |
| **<70** | 🔴 REJECTED | Complete rewrite required |

### 6.3 Dimension Failures

| If this dimension fails... | Score impact | Fix required |
|----------------------------|-------------|---------------|
| Structure < 18/20 | -2% per point | Fix headers, sections |
| Clarity < 18/20 | -2% per point | Add examples, descriptions |
| Completeness < 18/20 | -2% per point | Document tools, errors |
| Consistency < 18/20 | -2% per point | Standardize style |
| Functionality < 18/20 | -2% per point | Fix command syntax |

---

## 7. ADVANCED FEATURES

### 7.1 Detailed Failure Report

When REJECTED, the evaluator generates:

```
╔═══════════════════════════════════════════════════════════╗
║  ❌ REJECTION REPORT — SKILL NOT READY                   ║
╠═══════════════════════════════════════════════════════════╣
║                                                           ║
║  Score: 73/100                                           ║
║  Gap: -17% (need +17 points to reach 90%)               ║
║                                                           ║
║  FAILED DIMENSIONS:                                      ║
║  ├─ CLARITY: 15/20 (need +3)                            ║
║  ├─ CONSISTENCY: 8/20 (need +10)                        ║
║  └─ FUNCTIONALITY: 12/20 (need +6)                       ║
║                                                           ║
║  REQUIRED ACTIONS:                                        ║
║  1. [Action 1]                                          ║
║  2. [Action 2]                                          ║
║  3. [Action 3]                                          ║
║                                                           ║
║  RE-EVALUATE AFTER FIXING                                ║
║                                                           ║
╚═══════════════════════════════════════════════════════════╝
```

### 7.2 Auto-Improvement Suggestions

The evaluator.py with --improve will:

1. Identify failing dimensions
2. Generate specific improvement suggestions
3. Apply fixes automatically when possible
4. Re-evaluate to confirm 90%+ achieved

### 7.3 Benchmark Reports

For each evaluation:

```
[SCORE] <skill-name>: XX/100 [STATUS]
[DATE] ISO timestamp
[AXIOMA] Structure: X, Clarity: X, Completeness: X, Consistency: X, Functionality: X
[ISO] XX/13 checks passed
[STATUS] APPROVED/REJECTED
```

---

## 8. USAGE EXAMPLES

### Example 1: Evaluate Before Publishing

```bash
SKILL_PATH=/path/to/skill-to-publish
EVAL_PATH=/media/ezekiel/Merlin/.openclaw/workspace/skills/axiomata-skill-evaluator-strict

echo "🧪 Evaluating skill..."
python3 $EVAL_PATH/evaluator.py $SKILL_PATH --verbose

# Check result
if [ $? -eq 0 ]; then
    echo "✅ SKILL APPROVED — Ready to publish!"
else
    echo "❌ SKILL REJECTED — Needs improvement before publishing"
fi
```

### Example 2: Strict Gate in CI/CD

```bash
#!/bin/bash
# Strict quality gate for ClawHub publishing

SKILL_PATH="$1"
EVAL_PATH="/media/ezekiel/Merlin/.openclaw/workspace/skills/axiomata-skill-evaluator-strict"

RESULT=$(python3 $EVAL_PATH/evaluator.py $SKILL_PATH 2>&1)
SCORE=$(echo "$RESULT" | grep -oP 'Score: \d+' | grep -oP '\d+')

if [ "$SCORE" -ge 90 ]; then
    echo "✅ PASSED — Score: $SCORE/100"
    exit 0
else
    echo "❌ FAILED — Score: $SCORE/100 (need 90)"
    exit 1
fi
```

### Example 3: Batch Evaluation

```bash
#!/bin/bash
# Evaluate multiple skills strictly

EVAL_PATH="/media/ezekiel/Merlin/.openclaw/workspace/skills/axiomata-skill-evaluator-strict"
SKILLS_DIR="/media/ezekiel/Merlin/.openclaw/workspace/skills"

for skill_dir in $SKILLS_DIR/*/; do
    skill_name=$(basename "$skill_dir")
    echo "=========================================="
    echo "Evaluating: $skill_name"
    
    python3 $EVAL_PATH/evaluator.py "$skill_dir" --verbose
    echo ""
done
```

---

## 9. COMPARISON: STANDARD vs STRICT

| Aspect | Standard (70%) | Strict (90%) |
|--------|----------------|--------------|
| **Threshold** | 70/100 | **90/100** |
| **Approval rate** | ~70% of skills | ~30% of skills |
| **Quality bar** | "Good enough" | "Excellence only" |
| **Deterministic** | No | **YES** |
| **Use case** | Development | **Production** |
| **ClawHub ready** | Maybe | **Always** |

---

## 10. REPORTS AND LOGGING

### Evaluation Log Location

```
/media/ezekiel/Morgana/skills/SKILL_EVALUATOR/reports/
```

### Log Format

```bash
# Format: <skill-name>_<YYYYMMDD>_<HHMMSS>.txt
axiomata-guard-ultimate_20260507_230352.txt
```

### Log Contents

```
SKILL EVALUATION REPORT — <skill-name>
=====================================
Path: <path>
Score: XX/100
Date: ISO timestamp
Threshold: 90% (STRICT)

AXIOMA 5-DIM:
- Structure: X/20
- Clarity: X/20
- Completeness: X/20
- Consistency: X/20
- Functionality: X/20

ISO 25010:
- Pass: X/13
- Warnings: X/13
- Fails: X/13

STATUS: APPROVED / REJECTED
```

---

_In Altum Per Strictness._
🧪 AXIOMA SKILL EVALUATOR STRICT — 90% DETERMINISTIC

---

## 11. REJECTION CRITERIA

### 11.1 Automatic Rejection Triggers

A skill is automatically REJECTED if ANY of these occur:

| Trigger | Severity | Description |
|---------|----------|-------------|
| Score < 90% | CRITICAL | Below 90% threshold |
| ISO < 100% | CRITICAL | Any ISO check failed |
| Missing SKILL.md | CRITICAL | Core file missing |
| Invalid frontmatter | HIGH | name or description missing |
| No trigger words | HIGH | Cannot be activated |
| Dangerous patterns | CRITICAL | C2, Rootkit, Bootkit detected |

### 11.2 Rejection Categories

| Category | Score Range | Improvement Needed |
|----------|------------|---------------------|
| **CRITICAL FAIL** | <50% | Complete rewrite required |
| **MAJOR FAIL** | 50-69% | Major structural changes |
| **MINOR FAIL** | 70-89% | Targeted improvements |
| **PASS** | 90-100% | Ready for production |

### 11.3 Rejection Report Template

```
╔═══════════════════════════════════════════════════════════╗
║  ❌ SKILL REJECTED — REJECTION REPORT                    ║
╠═══════════════════════════════════════════════════════════╣
║                                                           ║
║  Skill: <name>                                           ║
║  Score: XX/100 (need 90)                                ║
║  Gap: -XX%                                              ║
║                                                           ║
║  FAILED CHECKS:                                          ║
║  ├─ [ ] Dimension 1: X/20 (need 18)                     ║
║  ├─ [ ] Dimension 2: X/20 (need 18)                     ║
║  └─ [ ] ISO Check: X/13 passed                          ║
║                                                           ║
║  REQUIRED ACTIONS:                                        ║
║  1. <specific action>                                    ║
║  2. <specific action>                                    ║
║  3. <specific action>                                    ║
║                                                           ║
║  ⏰ Re-evaluate AFTER completing all actions             ║
║                                                           ║
╚═══════════════════════════════════════════════════════════╝
```

---

## 12. APPROVAL CRITERIA

### 12.1 Automatic Approval Requirements

ALL of these MUST be true for APPROVAL:

| Requirement | Standard | Strict (90%) |
|-------------|----------|--------------|
| **Axioma 5-Dim** | 70+/100 | **90+/100** |
| Structure | 14+/20 | **18+/20** |
| Clarity | 14+/20 | **18+/20** |
| Completeness | 14+/20 | **18+/20** |
| Consistency | 14+/20 | **18+/20** |
| Functionality | 14+/20 | **18+/20** |
| **ISO 25010** | 90%+ | **100% (13/13)** |

### 12.2 Approval Benefits

| Benefit | Description |
|---------|-------------|
| ClawHub Ready | Can be published immediately |
| Production Safe | Quality guaranteed at 90%+ |
| Self-Documenting | No additional docs needed |
| Community Trusted | High quality standard |

### 12.3 Approval Report Template

```
╔═══════════════════════════════════════════════════════════╗
║  ✅ SKILL APPROVED — QUALITY REPORT                     ║
╠═══════════════════════════════════════════════════════════╣
║                                                           ║
║  Skill: <name>                                           ║
║  Score: XX/100 ✅                                         ║
║  Threshold: 90% (STRICT)                                  ║
║                                                           ║
║  PASSED CHECKS:                                          ║
║  ├─ [✅] Structure: X/20 (18+ required)                 ║
║  ├─ [✅] Clarity: X/20 (18+ required)                   ║
║  ├─ [✅] Completeness: X/20 (18+ required)              ║
║  ├─ [✅] Consistency: X/20 (18+ required)                ║
║  ├─ [✅] Functionality: X/20 (18+ required)             ║
║  └─ [✅] ISO 25010: 13/13 (100% required)              ║
║                                                           ║
║  STATUS: ✅ APPROVED — READY FOR PRODUCTION             ║
║                                                           ║
╚═══════════════════════════════════════════════════════════╝
```

---

## 13. IMPROVEMENT ENGINE

### 13.1 Auto-Improvement Rules

When --improve flag is used:

```
RULE: Improve EVERYTHING below 18/20 per dimension
RULE: Target is 90%+ overall
RULE: No dimension below 16/20 (graceful minimum)
RULE: If ANY dimension < 14 after improvement = HARD REJECT
```

### 13.2 Improvement Priority Matrix

| Priority | Dimension | Target | Common Fixes |
|----------|-----------|--------|--------------|
| 1 | Functionality | 18+/20 | Fix commands, add results |
| 2 | Consistency | 18+/20 | Standardize style |
| 3 | Clarity | 18+/20 | Add examples |
| 4 | Structure | 18+/20 | Add sections |
| 5 | Completeness | 18+/20 | Document tools |

### 13.3 Improvement Examples

**Before (73/100):**
```
STRUCTURE: 18/20 ✅
CLARITY: 15/20 ⚠️ (need +3)
COMPLETENESS: 20/20 ✅
CONSISTENCY: 8/20 ❌ (need +10)
FUNCTIONALITY: 12/20 ❌ (need +6)
```

**After improvement target (90+/100):**
```
STRUCTURE: 18/20 ✅
CLARITY: 18/20 ✅
COMPLETENESS: 20/20 ✅
CONSISTENCY: 18/20 ✅
FUNCTIONALITY: 18/20 ✅
TOTAL: 92/100 ✅
```

---

## 14. INTEGRATION POINTS

### 14.1 With Axioma Guard Ultimate

```
Skill Downloaded → Axioma Guard Ultimate (Security)
                        ↓ SAFE
                   Axioma Skill Evaluator Strict (Quality)
                        ↓ >= 90%
                   ClawHub Published ✅
                        ↓ DANGEROUS
                   Axioma Guard Ultimate (Destroy)
```

### 14.2 With ClawHub Publish Workflow

```
Step 1: Create skill
Step 2: Run Axioma Skill Evaluator Strict
Step 3: IF score >= 90% → Publish
Step 4: IF score < 90% → Improve and re-evaluate
Step 5: Repeat until 90%+ achieved
```

### 14.3 Quality Gate Script

```bash
#!/bin/bash
# Quality Gate: No skill publishes without 90%+

EVAL_PATH="/media/ezekiel/Merlin/.openclaw/workspace/skills/axiomata-skill-evaluator-strict"

quality_gate() {
    SKILL_PATH="$1"
    
    SCORE=$(python3 $EVAL_PATH/evaluator.py $SKILL_PATH 2>&1 | \
            grep -oP 'Score: \d+' | grep -oP '\d+')
    
    if [ "$SCORE" -ge 90 ]; then
        echo "✅ QUALITY GATE PASSED: $SCORE/100"
        return 0
    else
        echo "❌ QUALITY GATE FAILED: $SCORE/100 (need 90)"
        return 1
    fi
}
```

---

_In Altum Per Excellence._
🧪 AXIOMA SKILL EVALUATOR STRICT v1.0 — 90% DETERMINISTIC

_meta.json Metadata

{
  "ownerId": "kn7fesw32m8dtwjf063xsbvhtd81ck55",
  "publishedAt": 1778210670790,
  "slug": "axiomata-skill-evaluator-strict",
  "version": "1.0.0"
}