aw-ecc 1.4.32 → 1.4.47

package/skills/aw-adk/scripts/aggregate-benchmark.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+"""
+aggregate-benchmark.py — Aggregates ADK eval results into benchmark.json
+
+Usage:
+    python skills/aw-adk/scripts/aggregate-benchmark.py <workspace>/iteration-N --artifact-name <name>
+
+Reads grading.json and timing.json from each eval directory,
+produces benchmark.json and benchmark.md with aggregate statistics.
+
+Adapted from skill-creator's aggregate_benchmark.py for CASRE context.
+"""
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+from statistics import mean, stdev
+
+
+def load_json(path: str) -> dict:
+    """Load a JSON file, returning empty dict if not found."""
+    try:
+        with open(path, "r") as f:
+            return json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError):
+        return {}
+
+
+def collect_runs(iteration_dir: str) -> list[dict]:
+    """Collect all grading results from an iteration directory."""
+    runs = []
+    iteration_path = Path(iteration_dir)
+
+    for eval_dir in sorted(iteration_path.iterdir()):
+        if not eval_dir.is_dir():
+            continue
+
+        for config_dir in sorted(eval_dir.iterdir()):
+            if not config_dir.is_dir():
+                continue
+
+            grading_path = config_dir / "grading.json"
+            timing_path = config_dir / "timing.json"
+            metadata_path = eval_dir / "eval_metadata.json"
+
+            grading = load_json(str(grading_path))
+            timing = load_json(str(timing_path))
+            metadata = load_json(str(metadata_path))
+
+            if not grading:
+                continue
+
+            summary = grading.get("summary", {})
+            run = {
+                "eval_id": metadata.get("eval_id", eval_dir.name),
+                "eval_name": metadata.get("eval_name", eval_dir.name),
+                "configuration": config_dir.name,
+                "run_number": 1,
+                "result": {
+                    "pass_rate": summary.get("pass_rate", 0),
+                    "passed": summary.get("passed", 0),
+                    "failed": summary.get("failed", 0),
+                    "total": summary.get("total", 0),
+                    "time_seconds": timing.get("total_duration_seconds", 0),
+                    "tokens": timing.get("total_tokens", 0),
+                    "errors": grading.get("execution_metrics", {}).get("errors_encountered", 0),
+                },
+                "expectations": grading.get("expectations", []),
+            }
+            runs.append(run)
+
+    return runs
+
+
+def compute_summary(runs: list[dict]) -> dict:
+    """Compute aggregate statistics per configuration."""
+    configs: dict[str, list[dict]] = {}
+    for run in runs:
+        config = run["configuration"]
+        configs.setdefault(config, []).append(run)
+
+    summary = {}
+    for config, config_runs in configs.items():
+        pass_rates = [r["result"]["pass_rate"] for r in config_runs]
+        times = [r["result"]["time_seconds"] for r in config_runs if r["result"]["time_seconds"] > 0]
+        tokens = [r["result"]["tokens"] for r in config_runs if r["result"]["tokens"] > 0]
+
+        summary[config] = {
+            "pass_rate": {
+                "mean": round(mean(pass_rates), 3) if pass_rates else 0,
+                "stddev": round(stdev(pass_rates), 3) if len(pass_rates) > 1 else 0,
+                "min": round(min(pass_rates), 3) if pass_rates else 0,
+                "max": round(max(pass_rates), 3) if pass_rates else 0,
+            },
+            "time_seconds": {
+                "mean": round(mean(times), 1) if times else 0,
+                "stddev": round(stdev(times), 1) if len(times) > 1 else 0,
+            },
+            "tokens": {
+                "mean": round(mean(tokens)) if tokens else 0,
+                "stddev": round(stdev(tokens)) if len(tokens) > 1 else 0,
+            },
+        }
+
+    # Compute delta between with_artifact and without_artifact (or with_skill/without_skill)
+    with_key = next((k for k in summary if "with" in k), None)
+    without_key = next((k for k in summary if "without" in k or "old" in k), None)
+
+    if with_key and without_key:
+        summary["delta"] = {
+            "pass_rate": f"+{summary[with_key]['pass_rate']['mean'] - summary[without_key]['pass_rate']['mean']:.3f}",
+            "time_seconds": f"+{summary[with_key]['time_seconds']['mean'] - summary[without_key]['time_seconds']['mean']:.1f}",
+            "tokens": f"+{summary[with_key]['tokens']['mean'] - summary[without_key]['tokens']['mean']:.0f}",
+        }
+
+    return summary
+
+
+def generate_markdown(benchmark: dict) -> str:
+    """Generate a human-readable benchmark.md summary."""
+    lines = [f"# Benchmark: {benchmark['metadata']['artifact_name']}", ""]
+
+    summary = benchmark.get("run_summary", {})
+    for config, stats in summary.items():
+        if config == "delta":
+            continue
+        lines.append(f"## {config}")
+        pr = stats.get("pass_rate", {})
+        lines.append(f"- Pass rate: {pr.get('mean', 0):.1%} ± {pr.get('stddev', 0):.1%}")
+        ts = stats.get("time_seconds", {})
+        lines.append(f"- Time: {ts.get('mean', 0):.1f}s ± {ts.get('stddev', 0):.1f}s")
+        tk = stats.get("tokens", {})
+        lines.append(f"- Tokens: {tk.get('mean', 0):.0f} ± {tk.get('stddev', 0):.0f}")
+        lines.append("")
+
+    if "delta" in summary:
+        d = summary["delta"]
+        lines.append("## Delta")
+        lines.append(f"- Pass rate: {d['pass_rate']}")
+        lines.append(f"- Time: {d['time_seconds']}s")
+        lines.append(f"- Tokens: {d['tokens']}")
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Aggregate ADK eval results into benchmark")
+    parser.add_argument("iteration_dir", help="Path to iteration directory")
+    parser.add_argument("--artifact-name", required=True, help="Name of the artifact being benchmarked")
+    args = parser.parse_args()
+
+    if not os.path.isdir(args.iteration_dir):
+        print(f"Error: {args.iteration_dir} is not a directory", file=sys.stderr)
+        sys.exit(1)
+
+    runs = collect_runs(args.iteration_dir)
+
+    if not runs:
+        print(f"Warning: No grading results found in {args.iteration_dir}", file=sys.stderr)
+
+    benchmark = {
+        "metadata": {
+            "artifact_name": args.artifact_name,
+            "iteration_dir": args.iteration_dir,
+            "evals_run": list({r["eval_name"] for r in runs}),
+            "total_runs": len(runs),
+        },
+        "runs": runs,
+        "run_summary": compute_summary(runs),
+        "notes": [],
+    }
+
+    # Write benchmark.json
+    output_path = os.path.join(args.iteration_dir, "benchmark.json")
+    with open(output_path, "w") as f:
+        json.dump(benchmark, f, indent=2)
+    print(f"Wrote {output_path}")
+
+    # Write benchmark.md
+    md_path = os.path.join(args.iteration_dir, "benchmark.md")
+    with open(md_path, "w") as f:
+        f.write(generate_markdown(benchmark))
+    print(f"Wrote {md_path}")
+
+
+if __name__ == "__main__":
+    main()

package/skills/aw-adk/scripts/lint-artifact.sh

@@ -0,0 +1,211 @@
+#!/usr/bin/env bash
+# lint-artifact.sh — Validates CASRE artifact structure
+# Usage: bash skills/aw-adk/scripts/lint-artifact.sh <path> <type>
+# Types: command | agent | skill | rule | eval
+# Returns JSON with pass/fail per check
+
+set -euo pipefail
+
+ARTIFACT_PATH="${1:-}"
+ARTIFACT_TYPE="${2:-}"
+ERRORS=()
+WARNINGS=()
+
+if [[ -z "$ARTIFACT_PATH" || -z "$ARTIFACT_TYPE" ]]; then
+  echo '{"error": "Usage: lint-artifact.sh <path> <type>"}' >&2
+  exit 1
+fi
+
+if [[ ! -f "$ARTIFACT_PATH" ]]; then
+  echo "{\"error\": \"File not found: $ARTIFACT_PATH\"}" >&2
+  exit 1
+fi
+
+# Read file content
+CONTENT=$(cat "$ARTIFACT_PATH")
+
+# Check 1: YAML frontmatter exists
+if ! echo "$CONTENT" | head -1 | grep -q '^---$'; then
+  ERRORS+=("frontmatter_missing: No YAML frontmatter (must start with ---)")
+fi
+
+# Check 2: Frontmatter has 'name' field
+if ! echo "$CONTENT" | grep -q '^name:'; then
+  ERRORS+=("name_missing: No 'name' field in frontmatter")
+fi
+
+# Check 3: Frontmatter has 'description' field
+if ! echo "$CONTENT" | grep -q '^description:'; then
+  ERRORS+=("description_missing: No 'description' field in frontmatter")
+fi
+
+# Type-specific checks
+case "$ARTIFACT_TYPE" in
+  command)
+    # Commands need phases
+    if ! echo "$CONTENT" | grep -qi 'phase'; then
+      WARNINGS+=("no_phases: Command has no phase structure")
+    fi
+    # Commands need agent roster
+    if ! echo "$CONTENT" | grep -qi 'agent.*roster\|## Agent'; then
+      WARNINGS+=("no_agent_roster: Command has no agent roster section")
+    fi
+    ;;
+  agent)
+    # Agents need identity section
+    if ! echo "$CONTENT" | grep -qi '## Identity\|## Core Mission'; then
+      WARNINGS+=("no_identity: Agent has no Identity or Core Mission section")
+    fi
+    # Agents need tools in frontmatter
+    if ! echo "$CONTENT" | grep -q '^tools:'; then
+      WARNINGS+=("no_tools: Agent has no 'tools' field in frontmatter")
+    fi
+    ;;
+  skill)
+    # Skills: SKILL.md must be the filename
+    BASENAME=$(basename "$ARTIFACT_PATH")
+    if [[ "$BASENAME" != "SKILL.md" ]]; then
+      ERRORS+=("wrong_filename: Skill must be named SKILL.md, got $BASENAME")
+    fi
+    # Skills need When to Use
+    if ! echo "$CONTENT" | grep -qi '## When to Use'; then
+      WARNINGS+=("no_when_to_use: Skill has no 'When to Use' section")
+    fi
+    # Check word count (should be < 5000)
+    WORD_COUNT=$(echo "$CONTENT" | wc -w | tr -d ' ')
+    if [[ "$WORD_COUNT" -gt 5000 ]]; then
+      WARNINGS+=("too_long: Skill is $WORD_COUNT words (recommended < 5000)")
+    fi
+    ;;
+  rule)
+    # Rules need WRONG/RIGHT or Always/Never examples
+    if ! echo "$CONTENT" | grep -qi 'WRONG\|Never\|Always'; then
+      WARNINGS+=("no_examples: Rule has no WRONG/RIGHT or Always/Never examples")
+    fi
+    ;;
+  eval)
+    # Evals need pass/fail criteria
+    if ! echo "$CONTENT" | grep -qi 'pass\|fail\|expect'; then
+      WARNINGS+=("no_criteria: Eval has no pass/fail criteria")
+    fi
+    ;;
+  *)
+    echo "{\"error\": \"Unknown type: $ARTIFACT_TYPE. Must be: command|agent|skill|rule|eval\"}" >&2
+    exit 1
+    ;;
+esac
+
+# ─── Dependency resolution checks ───
+# Find the .aw/.aw_registry/ root by walking up from the artifact path
+REGISTRY_ROOT=""
+SEARCH_DIR=$(dirname "$ARTIFACT_PATH")
+for _ in $(seq 1 10); do
+  if [[ -d "$SEARCH_DIR/.aw_registry" ]]; then
+    # We're inside .aw/ already
+    REGISTRY_ROOT="$SEARCH_DIR"
+    break
+  elif [[ -d "$SEARCH_DIR/.aw/.aw_registry" ]]; then
+    REGISTRY_ROOT="$SEARCH_DIR/.aw"
+    break
+  fi
+  SEARCH_DIR=$(dirname "$SEARCH_DIR")
+done
+
+if [[ -n "$REGISTRY_ROOT" ]]; then
+  case "$ARTIFACT_TYPE" in
+    agent)
+      # Check skills: frontmatter — each skill must exist in the registry
+      SKILLS_LINE=$(echo "$CONTENT" | grep -E '^skills:' | head -1)
+      if [[ -n "$SKILLS_LINE" ]]; then
+        # Extract skill names from YAML: skills: [skill-1, skill-2] or skills: skill-1, skill-2
+        SKILL_NAMES=$(echo "$SKILLS_LINE" | sed 's/^skills:[[:space:]]*//;s/\[//g;s/\]//g;s/,/ /g;s/"//g;s/'"'"'//g' | tr -s ' ')
+        for SKILL_NAME in $SKILL_NAMES; do
+          SKILL_NAME=$(echo "$SKILL_NAME" | xargs) # trim whitespace
+          [[ -z "$SKILL_NAME" || "$SKILL_NAME" == "[]" || "$SKILL_NAME" == "-" ]] && continue
+          # Search for the skill in the registry
+          FOUND=$(find "$REGISTRY_ROOT/.aw_registry" -path "*/skills/$SKILL_NAME/SKILL.md" 2>/dev/null | head -1)
+          if [[ -z "$FOUND" ]]; then
+            ERRORS+=("phantom_skill: Agent references skill '$SKILL_NAME' but no skills/$SKILL_NAME/SKILL.md found in registry")
+          fi
+        done
+      fi
+      ;;
+    command)
+      # Check agent roster — only extract from the "Agent Roster" section, not Skill Loading Gate
+      # Extract lines between "## Agent Roster" and the next "##" heading
+      ROSTER_SECTION=$(echo "$CONTENT" | sed -n '/^## Agent Roster/,/^## [^A]/p' | sed '$d')
+      if [[ -n "$ROSTER_SECTION" ]]; then
+        AGENT_NAMES=$(echo "$ROSTER_SECTION" | grep -E '^\| *`[a-zA-Z]' | sed 's/.*`\([a-zA-Z0-9_-]*\)`.*/\1/' 2>/dev/null || true)
+        # Known built-in subagent types (Claude Code native agents, not registry artifacts)
+        BUILTIN_AGENTS="general-purpose|planner|code-reviewer|security-reviewer|build-error-resolver|typescript-reviewer|python-reviewer|go-reviewer|rust-reviewer|java-reviewer|kotlin-reviewer|cpp-reviewer|flutter-reviewer|e2e-runner|refactor-cleaner|doc-updater|tdd-guide|architect|harness-optimizer|docs-lookup|database-reviewer|loop-operator"
+        for AGENT_NAME in $AGENT_NAMES; do
+          [[ -z "$AGENT_NAME" ]] && continue
+          # Skip built-in subagent types
+          if echo "$AGENT_NAME" | grep -qE "^($BUILTIN_AGENTS)$"; then
+            continue
+          fi
+          # Try exact name first, then progressively strip namespace prefixes
+          # e.g. platform-review-security-reviewer → review-security-reviewer → security-reviewer
+          FOUND=""
+          SEARCH_NAME="$AGENT_NAME"
+          while [[ -z "$FOUND" && -n "$SEARCH_NAME" ]]; do
+            FOUND=$(find "$REGISTRY_ROOT/.aw_registry" -path "*/agents/$SEARCH_NAME.md" 2>/dev/null | head -1)
+            if [[ -z "$FOUND" ]]; then
+              # Strip first segment (up to and including first hyphen)
+              NEW_NAME="${SEARCH_NAME#*-}"
+              # If stripping didn't change anything, stop
+              [[ "$NEW_NAME" == "$SEARCH_NAME" ]] && break
+              SEARCH_NAME="$NEW_NAME"
+            fi
+          done
+          if [[ -z "$FOUND" ]]; then
+            ERRORS+=("phantom_agent: Command references agent '$AGENT_NAME' but no agents/$AGENT_NAME.md found in registry")
+          fi
+        done
+      fi
+      ;;
+  esac
+fi
+
+# Check: file has minimum content (not just frontmatter)
+LINE_COUNT=$(echo "$CONTENT" | wc -l | tr -d ' ')
+if [[ "$LINE_COUNT" -lt 20 ]]; then
+  WARNINGS+=("too_short: Artifact is only $LINE_COUNT lines (minimum recommended: 20)")
+fi
+
+# Check: has at least one markdown heading
+if ! echo "$CONTENT" | grep -q '^#'; then
+  ERRORS+=("no_heading: No markdown heading found")
+fi
+
+# Build JSON output
+ERROR_COUNT=${#ERRORS[@]}
+WARNING_COUNT=${#WARNINGS[@]}
+PASS=$([[ $ERROR_COUNT -eq 0 ]] && echo "true" || echo "false")
+
+{
+  echo "{"
+  echo "  \"path\": \"$ARTIFACT_PATH\","
+  echo "  \"type\": \"$ARTIFACT_TYPE\","
+  echo "  \"pass\": $PASS,"
+  echo "  \"error_count\": $ERROR_COUNT,"
+  echo "  \"warning_count\": $WARNING_COUNT,"
+
+  # Errors array
+  echo "  \"errors\": ["
+  for i in "${!ERRORS[@]}"; do
+    COMMA=$([[ $i -lt $((ERROR_COUNT - 1)) ]] && echo "," || echo "")
+    echo "    \"${ERRORS[$i]}\"$COMMA"
+  done
+  echo "  ],"
+
+  # Warnings array
+  echo "  \"warnings\": ["
+  for i in "${!WARNINGS[@]}"; do
+    COMMA=$([[ $i -lt $((WARNING_COUNT - 1)) ]] && echo "," || echo "")
+    echo "    \"${WARNINGS[$i]}\"$COMMA"
+  done
+  echo "  ]"
+
+  echo "}"
+}

package/skills/aw-adk/scripts/score-artifact.sh

@@ -0,0 +1,179 @@
+#!/usr/bin/env bash
+# score-artifact.sh — Applies quality rubric to a CASRE artifact
+# Usage: bash skills/aw-adk/scripts/score-artifact.sh <path> <type>
+# Types: command | agent | skill | rule | eval
+#
+# This script performs structural scoring (presence/absence of sections).
+# For deeper qualitative scoring, use the ADK skill's score mode which
+# applies the full rubric with LLM judgment.
+#
+# Returns JSON with per-dimension scores and tier assignment.
+
+set -euo pipefail
+
+ARTIFACT_PATH="${1:-}"
+ARTIFACT_TYPE="${2:-}"
+
+if [[ -z "$ARTIFACT_PATH" || -z "$ARTIFACT_TYPE" ]]; then
+  echo '{"error": "Usage: score-artifact.sh <path> <type>"}' >&2
+  exit 1
+fi
+
+if [[ ! -f "$ARTIFACT_PATH" ]]; then
+  echo "{\"error\": \"File not found: $ARTIFACT_PATH\"}" >&2
+  exit 1
+fi
+
+CONTENT=$(cat "$ARTIFACT_PATH")
+
+# Helper: check if content matches pattern (case-insensitive), return 1 if found
+has_pattern() {
+  if echo "$CONTENT" | grep -qi "$1" 2>/dev/null; then
+    echo 1
+  else
+    echo 0
+  fi
+}
+
+# Helper: count occurrences of pattern
+count_pattern() {
+  local count
+  count=$(echo "$CONTENT" | grep -ci "$1" 2>/dev/null) || true
+  echo "${count:-0}"
+}
+
+# Scoring function: returns 0-10 based on presence/quality signals
+score_dimension() {
+  local name="$1"
+  local score=0
+
+  case "$name" in
+    frontmatter)
+      [[ $(has_pattern '^---$') -eq 1 ]] && score=$((score + 3))
+      [[ $(has_pattern '^name:') -eq 1 ]] && score=$((score + 3))
+      [[ $(has_pattern '^description:') -eq 1 ]] && score=$((score + 2))
+      [[ $(has_pattern '^trigger:') -eq 1 ]] && score=$((score + 2))
+      ;;
+    sections)
+      HEADING_COUNT=$(count_pattern '^##')
+      if [[ $HEADING_COUNT -ge 8 ]]; then score=10
+      elif [[ $HEADING_COUNT -ge 5 ]]; then score=7
+      elif [[ $HEADING_COUNT -ge 3 ]]; then score=5
+      elif [[ $HEADING_COUNT -ge 1 ]]; then score=3
+      fi
+      ;;
+    code_examples)
+      CODE_BLOCKS=$(echo "$CONTENT" | grep -c '```' 2>/dev/null) || true
+      CODE_BLOCKS=${CODE_BLOCKS:-0}
+      CODE_BLOCKS=$((CODE_BLOCKS / 2))  # pairs of ```
+      if [[ $CODE_BLOCKS -ge 3 ]]; then score=10
+      elif [[ $CODE_BLOCKS -ge 2 ]]; then score=7
+      elif [[ $CODE_BLOCKS -ge 1 ]]; then score=5
+      fi
+      ;;
+    length)
+      WORD_COUNT=$(echo "$CONTENT" | wc -w | tr -d ' ')
+      if [[ $WORD_COUNT -ge 200 && $WORD_COUNT -le 5000 ]]; then score=10
+      elif [[ $WORD_COUNT -ge 100 ]]; then score=7
+      elif [[ $WORD_COUNT -ge 50 ]]; then score=5
+      elif [[ $WORD_COUNT -ge 20 ]]; then score=3
+      fi
+      ;;
+    checklists)
+      CHECKLIST_ITEMS=$(count_pattern '^\- \[')
+      TABLE_ROWS=$(count_pattern '^\|')
+      TOTAL=$((CHECKLIST_ITEMS + TABLE_ROWS))
+      if [[ $TOTAL -ge 10 ]]; then score=10
+      elif [[ $TOTAL -ge 5 ]]; then score=7
+      elif [[ $TOTAL -ge 2 ]]; then score=5
+      elif [[ $TOTAL -ge 1 ]]; then score=3
+      fi
+      ;;
+  esac
+
+  echo $score
+}
+
+# Score universal dimensions
+D_FRONTMATTER=$(score_dimension "frontmatter")
+D_SECTIONS=$(score_dimension "sections")
+D_CODE=$(score_dimension "code_examples")
+D_LENGTH=$(score_dimension "length")
+D_CHECKLISTS=$(score_dimension "checklists")
+
+# Type-specific dimensions (structural check only)
+D_TYPE_1=0
+D_TYPE_2=0
+D_TYPE_3=0
+D_TYPE_4=0
+D_TYPE_5=0
+
+case "$ARTIFACT_TYPE" in
+  command)
+    [[ $(has_pattern 'protocol\|AW-PROTOCOL') -eq 1 ]] && D_TYPE_1=7 || D_TYPE_1=0
+    [[ $(has_pattern 'agent.*roster\|## Agent') -eq 1 ]] && D_TYPE_2=7 || D_TYPE_2=0
+    [[ $(has_pattern 'skill.*load\|loading gate') -eq 1 ]] && D_TYPE_3=7 || D_TYPE_3=0
+    [[ $(has_pattern 'phase') -eq 1 ]] && D_TYPE_4=7 || D_TYPE_4=0
+    [[ $(has_pattern 'checkpoint\|human') -eq 1 ]] && D_TYPE_5=7 || D_TYPE_5=0
+    ;;
+  agent)
+    [[ $(has_pattern 'identity\|personality') -eq 1 ]] && D_TYPE_1=7 || D_TYPE_1=0
+    [[ $(has_pattern 'core mission\|## Mission') -eq 1 ]] && D_TYPE_2=7 || D_TYPE_2=0
+    [[ $(has_pattern 'critical rules\|## Rules') -eq 1 ]] && D_TYPE_3=7 || D_TYPE_3=0
+    [[ $(has_pattern 'deliverable') -eq 1 ]] && D_TYPE_4=7 || D_TYPE_4=0
+    [[ $(has_pattern 'communication\|voice') -eq 1 ]] && D_TYPE_5=7 || D_TYPE_5=0
+    ;;
+  skill)
+    [[ $(has_pattern 'when to use') -eq 1 ]] && D_TYPE_1=7 || D_TYPE_1=0
+    [[ $(has_pattern 'quick start\|## Instructions') -eq 1 ]] && D_TYPE_2=7 || D_TYPE_2=0
+    [[ $(has_pattern 'reference') -eq 1 ]] && D_TYPE_3=7 || D_TYPE_3=0
+    [[ $(has_pattern 'output format\|## Output') -eq 1 ]] && D_TYPE_4=7 || D_TYPE_4=0
+    [[ $(has_pattern 'progressive\|disclosure') -eq 1 ]] && D_TYPE_5=5 || D_TYPE_5=0
+    ;;
+  rule)
+    [[ $(has_pattern 'WRONG\|wrong') -eq 1 ]] && D_TYPE_1=7 || D_TYPE_1=0
+    [[ $(has_pattern 'RIGHT\|right\|correct') -eq 1 ]] && D_TYPE_2=7 || D_TYPE_2=0
+    [[ $(has_pattern 'MUST\|SHOULD\|severity') -eq 1 ]] && D_TYPE_3=7 || D_TYPE_3=0
+    [[ $(has_pattern 'automat\|enforce\|lint') -eq 1 ]] && D_TYPE_4=7 || D_TYPE_4=0
+    [[ $(has_pattern 'manifest\|coverage') -eq 1 ]] && D_TYPE_5=5 || D_TYPE_5=0
+    ;;
+  eval)
+    [[ $(has_pattern 'scenario') -eq 1 ]] && D_TYPE_1=7 || D_TYPE_1=0
+    [[ $(has_pattern 'grader\|assert') -eq 1 ]] && D_TYPE_2=7 || D_TYPE_2=0
+    [[ $(has_pattern 'pass.*criter\|expected') -eq 1 ]] && D_TYPE_3=7 || D_TYPE_3=0
+    [[ $(has_pattern 'fail\|edge.*case') -eq 1 ]] && D_TYPE_4=7 || D_TYPE_4=0
+    [[ $(has_pattern 'baseline\|reproduc') -eq 1 ]] && D_TYPE_5=5 || D_TYPE_5=0
+    ;;
+esac
+
+TOTAL=$((D_FRONTMATTER + D_SECTIONS + D_CODE + D_LENGTH + D_CHECKLISTS + D_TYPE_1 + D_TYPE_2 + D_TYPE_3 + D_TYPE_4 + D_TYPE_5))
+
+# Assign tier
+if [[ $TOTAL -ge 90 ]]; then TIER="S"
+elif [[ $TOTAL -ge 75 ]]; then TIER="A"
+elif [[ $TOTAL -ge 60 ]]; then TIER="B"
+elif [[ $TOTAL -ge 40 ]]; then TIER="C"
+else TIER="D"
+fi
+
+cat <<EOF
+{
+  "path": "$ARTIFACT_PATH",
+  "type": "$ARTIFACT_TYPE",
+  "total": $TOTAL,
+  "tier": "$TIER",
+  "dimensions": {
+    "frontmatter": $D_FRONTMATTER,
+    "sections": $D_SECTIONS,
+    "code_examples": $D_CODE,
+    "length": $D_LENGTH,
+    "checklists": $D_CHECKLISTS,
+    "type_specific_1": $D_TYPE_1,
+    "type_specific_2": $D_TYPE_2,
+    "type_specific_3": $D_TYPE_3,
+    "type_specific_4": $D_TYPE_4,
+    "type_specific_5": $D_TYPE_5
+  },
+  "note": "Structural scoring only. For qualitative rubric scoring, use the ADK skill score mode."
+}
+EOF