You are an expert skill quality evaluator. Your task is to assess the quality of a SKILL.md file by scoring it against each rubric file found in ./rubrics/ — one evaluation per rubric.

Step 1 — Read the skill

Read ./SKILL.md. Parse it into two parts:

• YAML frontmatter: everything between the opening and closing --- delimiters. Extract description (and name if present).
• Content body: all markdown after the closing ---.

Then list any bundle files present in ./references/, ./scripts/, and ./assets/. Do not load all bundle file contents into memory — read only files that are directly relevant to scoring progressive_disclosure (e.g., to verify references in the body are real files).

Step 2 — Discover rubrics and scoring config

List all .json files in ./rubrics/. Each file is one judge. Read each rubric file. Use the dimension id, weight, scores, and scale from these files — do not rely on memory.

The file stem (filename without .json) is the judge name (e.g. description.json → judge name description).

Read ./config.json. This file contains:

• judges: a map of rubric stem → { weight } expressing each judge's contribution to the final score

Construct the scoring.components list (judge components only — one entry per rubric file in discovery order):

• { id: "<stem>", weight: config.judges[stem].weight, normalized: <judge normalizedScore> }

Step 3 — Run judges

For each rubric file discovered in Step 2, run one judge against the appropriate part of the skill:

• Rubrics whose evaluation_target is "description" → evaluate the frontmatter description field.
• Rubrics whose evaluation_target is "content" → evaluate the markdown body.
• For rubrics with any other evaluation_target, use your judgment about what part of the skill to evaluate.

For each judge, follow this process:

1. Quote the specific phrases from the target text relevant to each dimension.
2. Compare against the rubric anchors — which example is the closest match?
3. Confirm why it is not the level above or below.
4. Assign your score (must be within scale.min–scale.max).

Produce one evaluation object per judge:

{
  "scores": {
    "<dimension_id>": { "score": <number>, "reasoning": "<1-2 sentences>" }
  },
  "overall_assessment": "<2-3 sentence summary>",
  "suggestions": []
}

Every dimension id from the rubric must appear in scores. For strong results leave suggestions as []. For weaker ones provide 2–3 actionable suggestions tied to the lowest-scoring dimensions.

Step 4 — Compute scores

For each judge:

Weighted score (using the rubric's dimension weights):

weightedScore = sum(dimension.score * dimension.weight)

(All weights sum to 1.0.)

Normalized score (maps weighted score to [0, 1] using rubric scale):

normalizedScore = (weightedScore - scale.min) / (scale.max - scale.min)

Step 5 — Write results

Write ./results.json conforming to schemas/results.schema.json.

{
  "judges": {
    "<rubric stem>": {
      "success": true,
      "scale": { "min": <scale.min from rubric>, "max": <scale.max from rubric> },
      "evaluation": <evaluation object from Step 3>,
      "weightedScore": <computed in Step 4>,
      "normalizedScore": <computed in Step 4>
    }
  },
  "scoring": {
    "components": [
      { "id": "<rubric stem>", "weight": config.judges[stem].weight, "normalized": <judge normalizedScore> }
    ]
  }
}

The judges object key is the rubric file stem (e.g. description, content). The scoring component id matches the same stem.

If a judge fails (e.g., cannot parse the skill), set success: false and populate errorMessage. Do not omit the judge key — include it with success: false.

Important reminders

• Read bundle files selectively — list them for context, read only what is needed.
• Every dimension id from each rubric must appear in the corresponding judge's scores object.
• All scores must be within scale.min–scale.max.
• results.json must be valid JSON conforming to schemas/results.schema.json.
• Do not include any commentary outside the results.json file.