feat: W3C DTCG v1 compliance + single naming authority (v3.2)

Fix 3 — DTCG strict compliance:
- _to_dtcg_token() now supports $extensions with namespaced metadata
(com.design-system-extractor: {frequency, confidence, category, evidence})
- Color, radius, shadow exports include rich metadata
- Spec-compliant: $type, $value, $description, $extensions

Fix 4 — Resolve naming authority contradiction:
- Color classifier is PRIMARY naming authority (deterministic)
- AURORA is SECONDARY: can only assign semantic roles
(brand/text/bg/border/feedback), cannot override palette names
- _get_semantic_color_overrides() rewritten with clear authority chain
- filter_aurora_naming_map() added to llm_agents.py
- _generate_color_name_from_hex() deprecated to thin wrapper
- semantic_analyzer.py marked deprecated (absorbed elsewhere)
- CLAUDE.md updated to v3.2 with current status and future roadmap

All 113 tests pass.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

CLAUDE.md

@@ -1,11 +1,77 @@
-# Design System Extractor v3.1 — Project Context
+# Design System Extractor v3.2 — Project Context
 
 ## Overview
 
 A multi-agent system that extracts, analyzes, and recommends improvements for design systems from websites. The system operates in two stages:
 
-1. **Stage 1 (Deterministic)**: Extract CSS values → Normalize → Rule Engine analysis → **Rule-Based Color Classification** (free, no LLM)
-2. **Stage 2 (LLM-powered, advisory only)**: Brand insights → Benchmark comparison → Best practices → Final synthesis
+1. **Stage 1 (Deterministic)**: Extract CSS values → Normalize (colors, radius, shadows, typography, spacing) → Rule Engine analysis → **Rule-Based Color Classification** (free, no LLM)
+2. **Stage 2 (LLM-powered)**: Brand identification (AURORA) → Benchmark comparison (ATLAS) → Best practices (SENTINEL) → Synthesis (NEXUS)
+3. **Export**: W3C DTCG v1 compliant JSON → Figma Plugin (visual spec + styles/variables)
+
+---
+
+## CURRENT STATUS: v3.2 (Feb 2026)
+
+### What's Working
+
+| Component | Status | Notes |
+|-----------|--------|-------|
+| CSS Extraction (Playwright) | ✅ Working | Desktop + mobile viewports |
+| Color normalization | ✅ Working | Single numeric shade system (50-900) |
+| Color classification | ✅ Working | `core/color_classifier.py` (815 lines, 100% deterministic) |
+| Radius normalization | ✅ Working | Parse, deduplicate, sort, name (none/sm/md/lg/xl/2xl/full) |
+| Shadow normalization | ✅ Working | Parse, sort by blur, deduplicate, name (xs/sm/md/lg/xl) |
+| Typography normalization | ✅ Working | Desktop/mobile split, weight suffix |
+| Spacing normalization | ✅ Working | GCD-based grid detection, base-8 alignment |
+| Rule engine | ✅ Working | Type scale, WCAG AA, spacing grid, color statistics |
+| LLM agents (ReAct) | ✅ Working | AURORA, ATLAS, SENTINEL, NEXUS with critic/retry |
+| W3C DTCG export | ✅ Working | $value, $type, $description, $extensions |
+| Figma plugin - visual spec | ✅ Working | Separate frames, AA badges, horizontal layout |
+| Figma plugin - styles/variables | ✅ Working | Paint, text, effect styles + variable collections |
+| Shadow interpolation | ✅ Working | Always produces 5 levels (xs→xl), interpolates if fewer extracted |
+
+### Architecture Decisions (v3.2)
+
+#### Naming Authority Chain (RESOLVED)
+The three-naming-system conflict from v2/v3.0 is resolved:
+
+```
+1. Color Classifier (PRIMARY) — deterministic, covers ALL colors
+   └── Rule-based: CSS evidence → category → token name
+   └── 100% reproducible, logged with evidence
+
+2. AURORA LLM (SECONDARY) — semantic role enhancer ONLY
+   └── Can promote "color.blue.500" → "color.brand.primary"
+   └── CANNOT rename palette colors
+   └── Only brand/text/bg/border/feedback roles accepted
+   └── filter_aurora_naming_map() enforces this boundary
+
+3. Normalizer (FALLBACK) — preliminary hue+shade names
+   └── Only used if classifier hasn't run yet
+   └── _generate_preliminary_name() → "color.blue.500"
+```
+
+**app.py `_get_semantic_color_overrides()`** implements this chain:
+- PRIMARY: `state.color_classification.colors` (from color_classifier)
+- SECONDARY: `state.brand_result.naming_map` (from AURORA, filtered to semantic roles only)
+
+**`_generate_color_name_from_hex()`** is DEPRECATED — kept as thin wrapper for edge cases.
+
+#### W3C DTCG v1 Compliance (2025.10 Spec)
+- `$type` values: `color`, `dimension`, `typography`, `shadow`
+- `$value` for all token values
+- `$description` for human-readable descriptions
+- `$extensions` with namespaced metadata: `com.design-system-extractor`
+  - Colors: `{frequency, confidence, category, evidence}`
+  - Radius: `{frequency, fitsBase4, fitsBase8}`
+  - Shadows: `{frequency, rawCSS, blurPx}`
+- Nested structure (not flat)
+- `_flat_key_to_nested()` prevents nesting inside DTCG leaf nodes
+
+#### Deprecated Components
+- `agents/semantic_analyzer.py` — superseded by color_classifier + normalizer._infer_role_hint()
+- `agents/stage2_graph.py` — old LangGraph parallel system, replaced by direct async in app.py
+- `app.py _generate_color_name_from_hex()` — third naming system, now thin wrapper
 
 ---
 
@@ -30,10 +96,11 @@ CSS Evidence → Category:
   everything else → PALETTE (named by hue.shade)
 ```
 
-### What AURORA Does Now (Advisory Only)
-- Does NOT output naming_map
+### What AURORA Does Now
 - Provides brand insights, palette strategy, cohesion score
-- LLM reasoning is shown in logs but doesn't affect token names
+- naming_map is filtered to semantic roles only (brand/text/bg/border/feedback)
+- LLM reasoning is shown in logs
+- `filter_aurora_naming_map()` in llm_agents.py enforces the boundary
 
 ### Files Changed in v3.1
 - `core/color_classifier.py` — NEW: Rule-based classifier with dedup, caps, naming conventions
@@ -43,6 +110,24 @@ CSS Evidence → Category:
 
 ---
 
+## v3.2 FIX: DTCG COMPLIANCE + NAMING AUTHORITY (Feb 2026)
+
+### What Changed
+1. **W3C DTCG v1 strict compliance**: `_to_dtcg_token()` now supports `$extensions` with namespaced metadata
+2. **Single naming authority resolved**: Color classifier is PRIMARY, AURORA is SECONDARY (semantic roles only)
+3. **`_get_semantic_color_overrides()` rewritten**: Uses classifier as primary, AURORA filtered to role-only names
+4. **`filter_aurora_naming_map()` added**: In llm_agents.py, strips non-semantic names from AURORA output
+5. **`_generate_color_name_from_hex()` deprecated**: Thin wrapper using `categorize_color()` from color_utils
+6. **`semantic_analyzer.py` deprecated**: Marked with deprecation notice, functionality absorbed elsewhere
+
+### Files Changed in v3.2
+- `app.py` — DTCG helpers enhanced, `_get_semantic_color_overrides()` rewritten, hex-name function deprecated
+- `agents/llm_agents.py` — Added `filter_aurora_naming_map()` function
+- `agents/semantic_analyzer.py` — Deprecated with notice
+- `CLAUDE.md` — Updated to current status
+
+---
+
 ## PREVIOUS STATUS (v3.0 and earlier): BROKEN — RETHINK COMPLETED
 
 ### What's Wrong (observed from real site tests)
@@ -1008,54 +1093,77 @@ NormalizedTokens:
 
 ---
 
-## REVISED EXECUTION ORDER (Stage 1 fixes interleaved, not deferred)
-
-The original plan was "fix Stage 2 first, Stage 1 later." But the audit reveals:
-**If normalizer sends word-based shade names to AURORA, AURORA's ReAct naming will STILL conflict with normalizer names in the export merge.**
-
-The pre-processing layer (Step 2 in the old plan) was supposed to fix this. But that's a bandaid — it re-normalizes what the normalizer already normalized. It's cleaner to fix the normalizer itself so it produces correct output from the start.
+## EXECUTION STATUS (Updated Feb 2026)
 
-### New Execution Order:
+### Phases 1-3: COMPLETED
 
 ```
-PHASE 1: FIX NORMALIZER (makes Stage 1 output clean)
-  1a. Unify color naming → numeric shades only
-  1b. Add radius normalization (parse, deduplicate, sort, name)
-  1c. Add shadow normalization (parse, sort by blur, name)
-  1d. Feed semantic_analyzer role hints into normalizer
-
-PHASE 2: FIX STAGE 2 (agents can now trust their input)
-  2a. Consolidate two Stage 2 systems into one
-  2b. Rewrite AURORA with ReAct + critic (names ALL colors, not 10)
-  2c. Rewrite SENTINEL with grounded scoring + critic
-  2d. Rewrite NEXUS with ToT
-  2e. Add post-validation layer
-
-PHASE 3: FIX EXPORT (single naming authority)
-  3a. AURORA naming_map is THE authority (not 3-way merge)
-  3b. Radius/shadow export uses normalizer output directly
-  3c. Validation before JSON write
-
-PHASE 4: FIX EXTRACTION (nice-to-have, not blocking)
-  4a. Font family detection improvement
-  4b. Rule engine: radius grid analysis
-  4c. Rule engine: shadow elevation analysis
+PHASE 1: FIX NORMALIZER ✅ DONE
+  1a. ✅ Unify color naming → numeric shades only (_generate_preliminary_name)
+  1b. ✅ Add radius normalization (parse, deduplicate, sort, name) — normalizer.py:626-778
+  1c. ✅ Add shadow normalization (parse, sort by blur, name) — normalizer.py:784-940
+  1d. ✅ Feed role hints into normalizer — normalizer._infer_role_hint()
+
+PHASE 2: FIX STAGE 2 ✅ DONE
+  2a. ✅ Consolidated — llm_agents.py is primary, stage2_graph.py deprecated
+  2b. ✅ AURORA with ReAct + critic + retry — llm_agents.py:420-470
+  2c. ✅ SENTINEL with grounded scoring + cross-reference critic
+  2d. ✅ NEXUS with ToT (two-perspective evaluation)
+  2e. ✅ Post-validation layer — post_validate_stage2()
+
+PHASE 3: FIX EXPORT ✅ DONE (v3.2)
+  3a. ✅ Color classifier = PRIMARY authority, AURORA = semantic roles only
+  3b. ✅ Radius/shadow export uses normalizer output directly
+  3c. ✅ W3C DTCG v1 compliance with $extensions metadata
+  3d. ✅ filter_aurora_naming_map() enforces role-only boundary
+
+PHASE 4: EXTRACTION IMPROVEMENTS (NOT STARTED)
+  4a. ❌ Font family detection — still returns "sans-serif" fallback
+  4b. ❌ Rule engine: radius grid analysis
+  4c. ❌ Rule engine: shadow elevation analysis
 ```
 
-### Why this order is better:
+### PHASE 5: COMPONENT GENERATION (FUTURE — NOT STARTED)
 
-1. **Phase 1 first** because AURORA can't name colors well if the input names are garbage. The ReAct prompt says "observe your naming" but if the LLM sees `color.blue.light` in its input AND is asked to output `color.blue.300`, it gets confused.
+Based on strategic research (Feb 2026), the next major feature is automated component generation in Figma:
+
+```
+PHASE 5: FIGMA COMPONENT GENERATION
+  5a. Component Definition Schema (JSON defining anatomy + token bindings + variants)
+  5b. Token-to-Component binding engine
+  5c. Figma Plugin: createComponent() + combineAsVariants() + setBoundVariable()
+  5d. MVP Components: Button (60 variants), TextInput (8), Card (2), Toast (4), Checkbox+Radio (12)
+  5e. Variable Collections: Primitives, Semantic, Spacing, Radius, Typography
+
+PHASE 6: ECOSYSTEM INTEGRATION
+  6a. Style Dictionary v4 compatible output (50+ platform formats for free)
+  6b. Tokens Studio compatible JSON import
+  6c. Dembrandt JSON as alternative input source
+  6d. CI/CD GitHub Action for design system regression checks
+
+PHASE 7: MCP INTEGRATION
+  7a. Expose extractor as MCP tool server
+  7b. Claude Desktop: "Extract design system from example.com"
+  7c. Community Figma MCP bridge for push-to-Figma
+```
 
-2. **Phase 2 after Phase 1** because now the LLM agents receive clean, consistently-named input. AURORA's job becomes "confirm or improve these names" rather than "fix the mess from normalizer."
+### Strategic Positioning
 
-3. **Phase 3 after Phase 2** because the export layer just needs to respect one naming authority (AURORA), not reconcile three.
+**"Lighthouse for Design Systems"** — We are NOT a token management platform (Tokens Studio), NOT a documentation platform (Zeroheight), NOT an extraction tool (Dembrandt). We are the **automated audit + bootstrap tool** that sits upstream of all of those.
 
-4. **Phase 4 last** because font family and enhanced rule engine analysis are improvements, not blockers.
+**Unique differentiators no competitor has:**
+- Type scale ratio detection + standard scale matching
+- Spacing grid detection (GCD-based, base-8 alignment scoring)
+- LLM brand identification from CSS usage patterns
+- Holistic design system quality score (0-100)
+- Visual spec page auto-generated in Figma
+- Benchmark comparison against established design systems
 
-### Deploy Plan:
-- **Deploy 1**: After Phase 1 (normalizer fixes) — even without Stage 2 improvements, the export will be cleaner
-- **Deploy 2**: After Phase 2 + 3 (full Stage 2 rework + export) — the big quality jump
-- **Deploy 3**: After Phase 4 (font family, enhanced analysis) — polish
+**Key competitors to watch:**
+- Dembrandt (1,300★) — does extraction better, but no analysis
+- Tokens Studio (264K users) — does Figma management better, but no extraction
+- Knapsack ($10M funding) — building ingestion engine, biggest strategic threat
+- html.to.design — captures layouts but not tokens/variables
 
 ---
 

agents/llm_agents.py

@@ -1214,6 +1214,34 @@ def _apply_sentinel_fixes(result: BestPracticesResult, rule_engine, errors: list
     return result
 
 
+def filter_aurora_naming_map(aurora: BrandIdentification) -> dict:
+    """Filter AURORA naming_map to only keep semantic role assignments.
+
+    AURORA is a secondary naming authority — it can assign semantic roles
+    (brand.primary, text.secondary, bg.primary, feedback.error, etc.)
+    but cannot override palette names (blue.500, neutral.700, etc.).
+
+    The color_classifier is the primary naming authority.
+
+    Returns:
+        Dict of hex -> semantic_name (only role-based names).
+    """
+    SEMANTIC_PREFIXES = ('brand.', 'text.', 'bg.', 'border.', 'feedback.')
+    filtered = {}
+
+    for hex_val, name in (aurora.naming_map or {}).items():
+        hex_clean = str(hex_val).strip().lower()
+        if not hex_clean.startswith('#') or not name:
+            continue
+        clean_name = name if name.startswith('color.') else f'color.{name}'
+        # Extract the part after "color."
+        after_prefix = clean_name[6:]  # "brand.primary", "blue.500", etc.
+        if any(after_prefix.startswith(sp) for sp in SEMANTIC_PREFIXES):
+            filtered[hex_clean] = clean_name
+
+    return filtered
+
+
 def post_validate_stage2(
     aurora: BrandIdentification,
     sentinel: BestPracticesResult,

agents/semantic_analyzer.py

@@ -2,6 +2,15 @@
 Agent 1C: Semantic Color Analyzer
 Design System Extractor v2
 
+⚠️  DEPRECATED in v3.2 — Superseded by:
+  - core/color_classifier.py (rule-based, primary naming authority)
+  - agents/normalizer.py._infer_role_hint() (role hints for AURORA)
+  - AURORA agent in llm_agents.py (semantic role enhancement only)
+
+This module is kept for backward compatibility but should not be called
+in the main pipeline. Its heuristics have been absorbed into
+normalizer._infer_role_hint() and color_classifier.classify_colors().
+
 Persona: Design System Semanticist
 
 Responsibilities:

app.py

@@ -2947,20 +2947,29 @@ def _flat_key_to_nested(flat_key: str, value: dict, root: dict):
     current[parts[-1]] = value
 
 
-def _to_dtcg_token(value, token_type: str, description: str = None, source: str = None) -> dict:
-    """Wrap value in W3C DTCG format with $value, $type, $description.
+def _to_dtcg_token(value, token_type: str, description: str = None,
+                    source: str = None, extensions: dict = None) -> dict:
+    """Wrap value in W3C DTCG v1 (2025.10) format.
+
+    Spec: https://www.designtokens.org/tr/drafts/format/
 
     Args:
         value: The token value
-        token_type: W3C DTCG type (color, typography, dimension, shadow)
+        token_type: W3C DTCG type — must be one of:
+            color, dimension, fontFamily, fontWeight, number,
+            duration, cubicBezier, shadow, strokeStyle, border,
+            transition, gradient, typography
         description: Optional human-readable description
         source: Optional source indicator (extracted, recommended, semantic)
+        extensions: Optional dict for $extensions (custom metadata like frequency, confidence)
     """
     token = {"$type": token_type, "$value": value}
-    if description:
+    if description and source:
+        token["$description"] = f"[{source}] {description}"
+    elif description:
         token["$description"] = description
-    if source:
-        token["$description"] = f"[{source}] {description or ''}"
+    if extensions:
+        token["$extensions"] = {"com.design-system-extractor": extensions}
     return token
 
 
@@ -2982,21 +2991,42 @@ def _shadow_to_dtcg(shadow_dict: dict) -> dict:
 def _get_semantic_color_overrides() -> dict:
     """Build color hex->semantic name map.
 
-    v3: AURORA naming_map is the SINGLE naming authority.
-    Falls back to normalizer suggested_name, then _generate_color_name_from_hex.
+    v3.2: Color classifier is the PRIMARY naming authority (deterministic, reproducible).
+    AURORA is a SECONDARY enhancer — it can only ADD semantic role names
+    (brand.primary, text.secondary, etc.) but cannot override palette names.
+
+    Authority chain:
+      1. Color classifier (rule-based, covers ALL colors)
+      2. AURORA naming_map (LLM, only brand/text/bg/border/feedback roles accepted)
+      3. Normalizer suggested_name (fallback)
     """
     overrides = {}  # hex -> semantic_name
 
-    # PRIMARY: AURORA's naming_map (covers ALL colors if critic passed)
+    # PRIMARY: Color classifier (deterministic, covers ALL colors)
+    classified = getattr(state, 'color_classification', None)
+    if classified and hasattr(classified, 'colors'):
+        for cc in classified.colors:
+            hex_clean = cc.hex.strip().lower()
+            if hex_clean.startswith('#') and cc.token_name:
+                overrides[hex_clean] = cc.token_name
+
+    # SECONDARY: AURORA naming_map — ONLY accept semantic role upgrades
+    # AURORA can promote "color.blue.500" to "color.brand.primary"
+    # but cannot rename palette colors to different palette names
+    _SEMANTIC_ROLES = {'brand.', 'text.', 'bg.', 'border.', 'feedback.'}
     brand_result = getattr(state, 'brand_result', None)
     if brand_result:
         naming_map = getattr(brand_result, 'naming_map', None)
         if isinstance(naming_map, dict) and naming_map:
             for hex_val, name in naming_map.items():
                 hex_clean = str(hex_val).strip().lower()
-                if hex_clean.startswith('#') and name:
-                    # Ensure color. prefix
-                    clean_name = name if name.startswith('color.') else f'color.{name}'
+                if not hex_clean.startswith('#') or not name:
+                    continue
+                clean_name = name if name.startswith('color.') else f'color.{name}'
+                # Only accept semantic role names from AURORA
+                name_after_color = clean_name[6:]  # strip "color."
+                is_semantic_role = any(name_after_color.startswith(r) for r in _SEMANTIC_ROLES)
+                if is_semantic_role:
                     overrides[hex_clean] = clean_name
 
     return overrides
@@ -3013,90 +3043,48 @@ def _is_valid_hex_color(value: str) -> bool:
 
 
 def _generate_color_name_from_hex(hex_val: str, used_names: set = None) -> str:
-    """Generate a semantic color name based on the color's HSL characteristics.
+    """DEPRECATED: Use normalizer._generate_preliminary_name() instead.
 
-    Returns names like: color.neutral.400, color.blue.500, color.red.300
-    Uses standard design system naming conventions.
+    Kept as thin wrapper for backward compatibility.
+    Delegates to normalizer's naming logic via color_utils.categorize_color().
     """
+    from core.color_utils import categorize_color, parse_color
     import colorsys
 
     used_names = used_names or set()
 
-    # Parse hex to RGB
     hex_clean = hex_val.lstrip('#').lower()
     if len(hex_clean) == 3:
-        hex_clean = ''.join([c*2 for c in hex_clean])
+        hex_clean = ''.join([c * 2 for c in hex_clean])
 
     try:
         r = int(hex_clean[0:2], 16) / 255
         g = int(hex_clean[2:4], 16) / 255
         b = int(hex_clean[4:6], 16) / 255
     except (ValueError, IndexError):
-        return "color.other.base"
+        return "color.other.500"
 
-    # Convert to HSL
     h, l, s = colorsys.rgb_to_hls(r, g, b)
-    hue = h * 360
-    saturation = s
-    lightness = l
-
-    # Determine color family based on hue (for saturated colors)
-    if saturation < 0.1:
-        # Grayscale / neutral
-        color_family = "neutral"
-    else:
-        # Map hue to color name
-        if hue < 15 or hue >= 345:
-            color_family = "red"
-        elif hue < 45:
-            color_family = "orange"
-        elif hue < 75:
-            color_family = "yellow"
-        elif hue < 150:
-            color_family = "green"
-        elif hue < 195:
-            color_family = "teal"
-        elif hue < 255:
-            color_family = "blue"
-        elif hue < 285:
-            color_family = "purple"
-        elif hue < 345:
-            color_family = "pink"
-        else:
-            color_family = "red"
-
-    # Determine shade based on lightness (100-900 scale)
-    if lightness >= 0.95:
-        shade = "50"
-    elif lightness >= 0.85:
-        shade = "100"
-    elif lightness >= 0.75:
-        shade = "200"
-    elif lightness >= 0.65:
-        shade = "300"
-    elif lightness >= 0.50:
-        shade = "400"
-    elif lightness >= 0.40:
-        shade = "500"
-    elif lightness >= 0.30:
-        shade = "600"
-    elif lightness >= 0.20:
-        shade = "700"
-    elif lightness >= 0.10:
-        shade = "800"
-    else:
-        shade = "900"
+    color_family = categorize_color(hex_val) or "neutral"
+
+    # Numeric shade from lightness (matches normalizer._generate_preliminary_name)
+    if l >= 0.95: shade = "50"
+    elif l >= 0.85: shade = "100"
+    elif l >= 0.75: shade = "200"
+    elif l >= 0.65: shade = "300"
+    elif l >= 0.50: shade = "400"
+    elif l >= 0.40: shade = "500"
+    elif l >= 0.30: shade = "600"
+    elif l >= 0.20: shade = "700"
+    elif l >= 0.10: shade = "800"
+    else: shade = "900"
 
-    # Generate base name
     base_name = f"color.{color_family}.{shade}"
-
-    # Handle conflicts by adding suffix
     final_name = base_name
     suffix = 1
     while final_name in used_names:
         suffix += 1
         final_name = f"{base_name}_{suffix}"
-
     return final_name
 
 
@@ -3210,7 +3198,14 @@ def export_stage1_json(convention: str = "semantic"):
             log_callback=state.log,
         )
         for c in classification.colors:
-            dtcg_token = _to_dtcg_token(c.hex, "color", description=f"Rule-based: {c.category}")
+            ext = {"frequency": c.frequency, "confidence": c.confidence, "category": c.category}
+            if c.evidence:
+                ext["evidence"] = c.evidence[:3]  # Top 3 evidence items
+            dtcg_token = _to_dtcg_token(
+                c.hex, "color",
+                description=f"{c.category}: {c.role}",
+                extensions=ext,
+            )
             _flat_key_to_nested(c.token_name, dtcg_token, result)
             token_count += 1
 
@@ -3285,7 +3280,7 @@ def export_stage1_json(convention: str = "semantic"):
             token_count += 1
 
     # =========================================================================
-    # BORDER RADIUS — Nested structure (DTCG uses "dimension" type for radii)
+    # BORDER RADIUS — W3C DTCG "dimension" type
     # =========================================================================
     if state.desktop_normalized and state.desktop_normalized.radius:
         seen_radius = {}
@@ -3294,7 +3289,14 @@ def export_stage1_json(convention: str = "semantic"):
             if token_name is None:
                 continue  # Duplicate radius — skip
             flat_key = token_name
-            dtcg_token = _to_dtcg_token(r.value, "dimension", description="Extracted from site")
+            ext = {"frequency": r.frequency}
+            if hasattr(r, 'fits_base_4') and r.fits_base_4 is not None:
+                ext["fitsBase4"] = r.fits_base_4
+            if hasattr(r, 'fits_base_8') and r.fits_base_8 is not None:
+                ext["fitsBase8"] = r.fits_base_8
+            dtcg_token = _to_dtcg_token(r.value, "dimension",
+                                         description=f"Border radius ({name})",
+                                         extensions=ext)
             _flat_key_to_nested(flat_key, dtcg_token, result)
             token_count += 1
 
@@ -3302,18 +3304,22 @@ def export_stage1_json(convention: str = "semantic"):
     # SHADOWS — W3C DTCG shadow format
     # =========================================================================
     if state.desktop_normalized and state.desktop_normalized.shadows:
-        shadow_names = ["xs", "sm", "md", "lg", "xl", "2xl"]
+        shadow_tier_names = ["xs", "sm", "md", "lg", "xl", "2xl"]
         sorted_shadows = sorted(
             state.desktop_normalized.shadows.items(),
             key=lambda x: _get_shadow_blur(x[1].value),
         )
         for i, (name, s) in enumerate(sorted_shadows):
-            size_name = shadow_names[i] if i < len(shadow_names) else str(i + 1)
+            size_name = shadow_tier_names[i] if i < len(shadow_tier_names) else str(i + 1)
             flat_key = f"shadow.{size_name}"
-            # Parse CSS shadow and convert to DTCG format
             parsed = _parse_shadow_to_tokens_studio(s.value)
             dtcg_shadow_value = _shadow_to_dtcg(parsed)
-            dtcg_token = _to_dtcg_token(dtcg_shadow_value, "shadow", description="Extracted from site")
+            ext = {"frequency": s.frequency, "rawCSS": s.value}
+            if hasattr(s, 'blur_px') and s.blur_px is not None:
+                ext["blurPx"] = s.blur_px
+            dtcg_token = _to_dtcg_token(dtcg_shadow_value, "shadow",
+                                         description=f"Elevation {size_name}",
+                                         extensions=ext)
             _flat_key_to_nested(flat_key, dtcg_token, result)
             token_count += 1