aiox-core 5.0.2 → 5.0.3

package/pro/squads/design/scripts/design-system/curate_spacing.cjs

@@ -0,0 +1,243 @@
+#!/usr/bin/env node
+/**
+ * GCD Base Unit + Harmonic Scale — Spacing Curation Pipeline
+ *
+ * Algorithm (from DS-CURATION-PIPELINE-PROPOSAL.md §4.2):
+ *   1. Normalize units (rem → px)
+ *   2. Calculate GCD of all values
+ *   3. Default to 4px grid if GCD is anomalous
+ *   4. Generate harmonic scale (0-96px, 13 steps)
+ *   5. Map each value to nearest scale step
+ *   6. Document unmapped values as overrides
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = process.cwd();
+const EXTRACTION_DIR = path.join(ROOT, 'workspace', 'domains', 'design-system', 'extraction');
+const MERGED_PATH = path.join(EXTRACTION_DIR, 'all-pages-merged.json');
+const OUTPUT_DIR = path.join(EXTRACTION_DIR, 'curated');
+const OUTPUT_PATH = path.join(OUTPUT_DIR, 'curated-spacing.json');
+
+// ── Math helpers ───────────────────────────────────────────────────────────
+
+function gcd(a, b) {
+  a = Math.abs(Math.round(a));
+  b = Math.abs(Math.round(b));
+  while (b) {
+    [a, b] = [b, a % b];
+  }
+  return a;
+}
+
+function gcdArray(arr) {
+  return arr.reduce((acc, val) => gcd(acc, val), arr[0]);
+}
+
+// ── Harmonic Scale ─────────────────────────────────────────────────────────
+
+// Standard 4px grid scale (Tailwind-compatible)
+const SCALE = [
+  { name: '0', px: 0 },
+  { name: '0.5', px: 2 },
+  { name: '1', px: 4 },
+  { name: '1.5', px: 6 },
+  { name: '2', px: 8 },
+  { name: '2.5', px: 10 },
+  { name: '3', px: 12 },
+  { name: '3.5', px: 14 },
+  { name: '4', px: 16 },
+  { name: '5', px: 20 },
+  { name: '6', px: 24 },
+  { name: '7', px: 28 },
+  { name: '8', px: 32 },
+  { name: '9', px: 36 },
+  { name: '10', px: 40 },
+  { name: '11', px: 44 },
+  { name: '12', px: 48 },
+  { name: '14', px: 56 },
+  { name: '16', px: 64 },
+  { name: '20', px: 80 },
+  { name: '24', px: 96 },
+  { name: '28', px: 112 },
+  { name: '32', px: 128 },
+  { name: '36', px: 144 },
+  { name: '40', px: 160 },
+  { name: '44', px: 176 },
+  { name: '48', px: 192 },
+  { name: '52', px: 208 },
+  { name: '56', px: 224 },
+  { name: '60', px: 240 },
+  { name: '64', px: 256 },
+  { name: '72', px: 288 },
+  { name: '80', px: 320 },
+  { name: '96', px: 384 },
+];
+
+function findNearestStep(px) {
+  let best = SCALE[0];
+  let bestDist = Math.abs(px - best.px);
+
+  for (const step of SCALE) {
+    const dist = Math.abs(px - step.px);
+    if (dist < bestDist) {
+      bestDist = dist;
+      best = step;
+    }
+  }
+
+  return { step: best, distance: bestDist };
+}
+
+// ── Main ───────────────────────────────────────────────────────────────────
+
+function main() {
+  console.log('=== SPACING CURATION PIPELINE ===\n');
+
+  const merged = JSON.parse(fs.readFileSync(MERGED_PATH, 'utf8'));
+  const rawSpacings = merged.spacings || [];
+
+  console.log(`Input: ${rawSpacings.length} unique spacing values from ${merged.meta.pagesIncluded} pages`);
+
+  // Extract unique px values with usage counts
+  const valueMap = new Map(); // px → { count, types[], contexts[] }
+  for (const sp of rawSpacings) {
+    const px = Math.round(sp.value);
+    if (px < 0) continue; // Skip negative values
+    const entry = valueMap.get(px) || { px, count: 0, types: new Set(), contexts: new Set() };
+    entry.count += sp.count || 0;
+    entry.types.add(sp.type || 'unknown');
+    if (sp.contexts) sp.contexts.forEach((c) => entry.contexts.add(c));
+    valueMap.set(px, entry);
+  }
+
+  const uniqueValues = [...valueMap.values()].sort((a, b) => a.px - b.px);
+  console.log(`  Unique pixel values: ${uniqueValues.length}`);
+
+  // Calculate GCD
+  const positiveValues = uniqueValues.filter((v) => v.px > 0).map((v) => v.px);
+  let detectedGcd = positiveValues.length > 0 ? gcdArray(positiveValues) : 4;
+
+  // Validate GCD
+  let baseUnit = detectedGcd;
+  let gcdStatus = 'auto';
+  if (detectedGcd !== 4 && detectedGcd !== 8 && detectedGcd !== 2) {
+    baseUnit = 4; // Default to 4px (Workshop rule)
+    gcdStatus = 'override';
+    console.log(`  GCD detected: ${detectedGcd}px → Overriding to 4px (market standard)`);
+  } else {
+    console.log(`  GCD detected: ${detectedGcd}px → Using as base unit`);
+  }
+
+  // Map each value to nearest scale step
+  const MAX_DISTANCE = 2; // Values > 2px from scale step → override
+  const decisions = [];
+  const mapped = [];
+  const overrides = [];
+  const usedSteps = new Map(); // step name → accumulated count
+
+  const totalUsage = uniqueValues.reduce((sum, v) => sum + v.count, 0);
+  let mappedUsage = 0;
+
+  for (const val of uniqueValues) {
+    const { step, distance } = findNearestStep(val.px);
+
+    if (distance <= MAX_DISTANCE) {
+      mapped.push({
+        originalPx: val.px,
+        mappedTo: step.name,
+        mappedPx: step.px,
+        distance,
+        count: val.count,
+        types: [...val.types],
+      });
+      mappedUsage += val.count;
+
+      const acc = usedSteps.get(step.name) || { step: step.name, px: step.px, count: 0 };
+      acc.count += val.count;
+      usedSteps.set(step.name, acc);
+
+      if (distance > 0) {
+        decisions.push({
+          category: 'spacing',
+          action: 'MAP',
+          items: [`${val.px}px`],
+          result: `${step.px}px (step ${step.name})`,
+          reason: `Distance ${distance}px <= ${MAX_DISTANCE}px threshold, mapped to nearest scale step`,
+          authority: 'Workshop 2026-02-16 — 4px grid market standard',
+        });
+      }
+    } else {
+      overrides.push({
+        originalPx: val.px,
+        nearestStep: step.name,
+        nearestPx: step.px,
+        distance,
+        count: val.count,
+        types: [...val.types],
+        contexts: [...val.contexts].slice(0, 3),
+      });
+    }
+  }
+
+  // Build final scale (only steps that are actually used + essential ones)
+  const essentialSteps = ['0', '1', '2', '3', '4', '6', '8', '10', '12', '16', '20', '24'];
+  const finalScale = SCALE.filter(
+    (s) => usedSteps.has(s.name) || essentialSteps.includes(s.name)
+  ).map((s) => ({
+    name: s.name,
+    px: s.px,
+    rem: Math.round((s.px / 16) * 10000) / 10000,
+    cssVar: `--spacing-${s.name.replace('.', '_')}`,
+    usage: usedSteps.get(s.name)?.count || 0,
+  }));
+
+  // Stats
+  const coverage = (mappedUsage / totalUsage) * 100;
+  const reduction = ((uniqueValues.length - finalScale.length) / uniqueValues.length) * 100;
+
+  const scores = {
+    before: uniqueValues.length,
+    after: finalScale.length,
+    reduction: `${Math.round(reduction * 10) / 10}%`,
+    target: '60%',
+    status: reduction >= 60 ? 'PASS' : reduction >= 40 ? 'CONDITIONAL' : 'FAIL',
+    base_unit: `${baseUnit}px`,
+    base_unit_status: gcdStatus === 'auto' ? 'PASS' : 'CONDITIONAL',
+    coverage: `${Math.round(coverage * 10) / 10}%`,
+    coverage_status: coverage >= 95 ? 'PASS' : coverage >= 85 ? 'CONDITIONAL' : 'FAIL',
+    overrides_count: overrides.length,
+  };
+
+  const output = {
+    meta: {
+      source: 'all-pages-merged.json',
+      pagesIncluded: merged.meta.pagesIncluded,
+      curatedAt: new Date().toISOString(),
+      algorithm: 'GCD base unit + harmonic scale mapping',
+      baseUnit: baseUnit,
+      detectedGcd: detectedGcd,
+    },
+    scores,
+    scale: finalScale,
+    overrides: overrides.sort((a, b) => b.count - a.count),
+    decisions,
+  };
+
+  fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+  fs.writeFileSync(OUTPUT_PATH, JSON.stringify(output, null, 2));
+
+  console.log(`\n--- RESULTS ---`);
+  console.log(`  Before: ${scores.before} unique values`);
+  console.log(`  After:  ${scores.after} scale steps`);
+  console.log(`  Reduction: ${scores.reduction} (target: ${scores.target}) → ${scores.status}`);
+  console.log(`  Base unit: ${scores.base_unit} (${scores.base_unit_status})`);
+  console.log(`  Coverage: ${scores.coverage} → ${scores.coverage_status}`);
+  console.log(`  Overrides: ${scores.overrides_count}`);
+  console.log(`  Decisions logged: ${decisions.length}`);
+  console.log(`\nOutput: ${OUTPUT_PATH}`);
+  console.log('=== DONE ===');
+}
+
+main();

package/pro/squads/design/scripts/design-system/curate_typography.cjs

@@ -0,0 +1,404 @@
+#!/usr/bin/env node
+/**
+ * Modular Scale + Font Consolidation — Typography Curation Pipeline
+ *
+ * Algorithm (from DS-CURATION-PIPELINE-PROPOSAL.md §4.3):
+ *   1. Count frequency of each font family → pick top 2 + 1 mono
+ *   2. Detect modular scale multiplier, generate size scale
+ *   3. Consolidate weights (max 5)
+ *   4. Calculate ideal line-height ratios
+ *   5. Consolidate letter-spacing
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = process.cwd();
+const EXTRACTION_DIR = path.join(ROOT, 'workspace', 'domains', 'design-system', 'extraction');
+const MERGED_PATH = path.join(EXTRACTION_DIR, 'all-pages-merged.json');
+const STYLES_PATH = path.join(EXTRACTION_DIR, 'figma-styles.json');
+const OUTPUT_DIR = path.join(EXTRACTION_DIR, 'curated');
+const OUTPUT_PATH = path.join(OUTPUT_DIR, 'curated-typography.json');
+
+// ── Size Scale (Tailwind-compatible) ───────────────────────────────────────
+
+const SIZE_SCALE = [
+  { name: 'xs', px: 12 },
+  { name: 'sm', px: 14 },
+  { name: 'base', px: 16 },
+  { name: 'lg', px: 18 },
+  { name: 'xl', px: 20 },
+  { name: '2xl', px: 24 },
+  { name: '3xl', px: 30 },
+  { name: '4xl', px: 36 },
+  { name: '5xl', px: 48 },
+  { name: '6xl', px: 60 },
+  { name: '7xl', px: 72 },
+  { name: '8xl', px: 96 },
+  { name: '9xl', px: 128 },
+];
+
+// ── Weight consolidation ───────────────────────────────────────────────────
+
+const CANONICAL_WEIGHTS = [
+  { name: 'light', value: 300 },
+  { name: 'normal', value: 400 },
+  { name: 'medium', value: 500 },
+  { name: 'semibold', value: 600 },
+  { name: 'bold', value: 700 },
+];
+
+function findNearestWeight(w) {
+  let best = CANONICAL_WEIGHTS[0];
+  let bestDist = Math.abs(w - best.value);
+  for (const cw of CANONICAL_WEIGHTS) {
+    const dist = Math.abs(w - cw.value);
+    if (dist < bestDist) {
+      bestDist = dist;
+      best = cw;
+    }
+  }
+  return { canonical: best, distance: bestDist };
+}
+
+// ── Line-height ratios ────────────────────────────────────────────────────
+
+const LH_RATIOS = [
+  { name: 'none', value: 1.0 },
+  { name: 'tight', value: 1.25 },
+  { name: 'snug', value: 1.375 },
+  { name: 'normal', value: 1.5 },
+  { name: 'relaxed', value: 1.625 },
+  { name: 'loose', value: 2.0 },
+];
+
+function findNearestLineHeight(ratio) {
+  let best = LH_RATIOS[0];
+  let bestDist = Math.abs(ratio - best.value);
+  for (const lh of LH_RATIOS) {
+    const dist = Math.abs(ratio - lh.value);
+    if (dist < bestDist) {
+      bestDist = dist;
+      best = lh;
+    }
+  }
+  return best;
+}
+
+// ── Letter-spacing ─────────────────────────────────────────────────────────
+
+const LS_SCALE = [
+  { name: 'tighter', em: -0.05 },
+  { name: 'tight', em: -0.025 },
+  { name: 'normal', em: 0 },
+  { name: 'wide', em: 0.025 },
+  { name: 'wider', em: 0.05 },
+  { name: 'widest', em: 0.1 },
+];
+
+// ── Mono font detection ───────────────────────────────────────────────────
+
+const MONO_PATTERNS = /mono|code|console|courier|fira\s*code|jet\s*brains|source\s*code|menlo|hack|inconsolata/i;
+
+// ── Main ───────────────────────────────────────────────────────────────────
+
+function main() {
+  console.log('=== TYPOGRAPHY CURATION PIPELINE ===\n');
+
+  const merged = JSON.parse(fs.readFileSync(MERGED_PATH, 'utf8'));
+  const rawFonts = merged.fonts || [];
+  const rawTextStyles = merged.textStyles || [];
+
+  // Load Figma styles for enrichment
+  let figmaStyles = [];
+  try { figmaStyles = JSON.parse(fs.readFileSync(STYLES_PATH, 'utf8')); } catch (_) { /* optional */ }
+  const textFigmaStyles = figmaStyles.filter((s) => s.style_type === 'TEXT');
+  console.log(`  Figma text styles: ${textFigmaStyles.length}`);
+
+  // Analyze text decoration and text case usage from enriched textStyles
+  const decorationMap = new Map();
+  const textCaseMap = new Map();
+  for (const ts of rawTextStyles) {
+    const dec = ts.textDecoration || 'NONE';
+    decorationMap.set(dec, (decorationMap.get(dec) || 0) + (ts.count || 0));
+    const tc = ts.textCase || 'ORIGINAL';
+    textCaseMap.set(tc, (textCaseMap.get(tc) || 0) + (ts.count || 0));
+  }
+
+  console.log(`Input: ${rawFonts.length} font entries, ${rawTextStyles.length} text styles`);
+
+  // 1. Font families — count frequency
+  const familyMap = new Map(); // family → total count
+  for (const font of rawFonts) {
+    const family = (font.family || '').trim();
+    if (!family) continue;
+    familyMap.set(family, (familyMap.get(family) || 0) + (font.count || 0));
+  }
+
+  const sortedFamilies = [...familyMap.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .map(([name, count]) => ({ name, count, isMono: MONO_PATTERNS.test(name) }));
+
+  console.log(`  Unique families: ${sortedFamilies.length}`);
+
+  // Select top 2 display/body + 1 mono
+  const monoFamilies = sortedFamilies.filter((f) => f.isMono);
+  const nonMonoFamilies = sortedFamilies.filter((f) => !f.isMono);
+
+  const selectedFamilies = [];
+  if (nonMonoFamilies.length >= 1) selectedFamilies.push({ ...nonMonoFamilies[0], role: 'primary' });
+  if (nonMonoFamilies.length >= 2) selectedFamilies.push({ ...nonMonoFamilies[1], role: 'secondary' });
+  if (monoFamilies.length >= 1) selectedFamilies.push({ ...monoFamilies[0], role: 'mono' });
+
+  // Rejected families (< 5% usage)
+  const totalFontUsage = sortedFamilies.reduce((sum, f) => sum + f.count, 0);
+  const rejectedFamilies = sortedFamilies
+    .filter((f) => !selectedFamilies.some((s) => s.name === f.name))
+    .filter((f) => (f.count / totalFontUsage) < 0.05)
+    .map((f) => ({
+      name: f.name,
+      count: f.count,
+      percentage: `${Math.round((f.count / totalFontUsage) * 1000) / 10}%`,
+    }));
+
+  console.log(`  Selected families: ${selectedFamilies.map((f) => f.name).join(', ')}`);
+  console.log(`  Rejected families: ${rejectedFamilies.length}`);
+
+  // 2. Font sizes — map to scale
+  const sizeMap = new Map(); // px → count
+  for (const ts of rawTextStyles) {
+    const size = Math.round(ts.fontSize || 0);
+    if (size <= 0) continue;
+    sizeMap.set(size, (sizeMap.get(size) || 0) + (ts.count || 0));
+  }
+
+  const uniqueSizes = [...sizeMap.entries()]
+    .sort((a, b) => a[0] - b[0])
+    .map(([px, count]) => ({ px, count }));
+
+  console.log(`  Unique sizes: ${uniqueSizes.length}`);
+
+  // Map each size to nearest scale step
+  const sizeMappings = [];
+  const usedSizeSteps = new Map();
+
+  for (const { px, count } of uniqueSizes) {
+    let bestStep = SIZE_SCALE[0];
+    let bestDist = Math.abs(px - bestStep.px);
+
+    for (const step of SIZE_SCALE) {
+      const dist = Math.abs(px - step.px);
+      if (dist < bestDist) {
+        bestDist = dist;
+        bestStep = step;
+      }
+    }
+
+    sizeMappings.push({
+      originalPx: px,
+      mappedTo: bestStep.name,
+      mappedPx: bestStep.px,
+      distance: bestDist,
+      count,
+    });
+
+    const acc = usedSizeSteps.get(bestStep.name) || { ...bestStep, count: 0, rem: bestStep.px / 16 };
+    acc.count += count;
+    usedSizeSteps.set(bestStep.name, acc);
+  }
+
+  // Final size scale (used + essential)
+  const essentialSizes = ['xs', 'sm', 'base', 'lg', 'xl', '2xl', '3xl', '4xl', '5xl'];
+  const finalSizeScale = SIZE_SCALE
+    .filter((s) => usedSizeSteps.has(s.name) || essentialSizes.includes(s.name))
+    .map((s) => ({
+      name: s.name,
+      px: s.px,
+      rem: s.px / 16,
+      cssVar: `--font-size-${s.name}`,
+      usage: usedSizeSteps.get(s.name)?.count || 0,
+    }));
+
+  // 3. Weights — consolidate
+  const weightMap = new Map();
+  for (const ts of rawTextStyles) {
+    const w = ts.fontWeight || 400;
+    weightMap.set(w, (weightMap.get(w) || 0) + (ts.count || 0));
+  }
+
+  const decisions = [];
+  const weightMappings = [];
+  const usedWeights = new Map();
+
+  for (const [w, count] of weightMap) {
+    const { canonical, distance } = findNearestWeight(w);
+    weightMappings.push({
+      original: w,
+      mappedTo: canonical.name,
+      mappedValue: canonical.value,
+      distance,
+      count,
+    });
+
+    const acc = usedWeights.get(canonical.name) || { ...canonical, count: 0 };
+    acc.count += count;
+    usedWeights.set(canonical.name, acc);
+
+    if (distance > 0) {
+      decisions.push({
+        category: 'typography',
+        action: 'MAP_WEIGHT',
+        items: [`weight ${w}`],
+        result: `${canonical.name} (${canonical.value})`,
+        reason: `Distance ${distance} < 50 threshold`,
+        authority: 'DS-CURATION-PIPELINE-PROPOSAL §4.3',
+      });
+    }
+  }
+
+  const finalWeights = CANONICAL_WEIGHTS
+    .filter((w) => usedWeights.has(w.name))
+    .map((w) => ({
+      name: w.name,
+      value: w.value,
+      cssVar: `--font-weight-${w.name}`,
+      usage: usedWeights.get(w.name)?.count || 0,
+    }));
+
+  // 4. Line heights
+  const lhMap = new Map();
+  for (const ts of rawTextStyles) {
+    if (!ts.fontSize || !ts.lineHeight) continue;
+    const ratio = Math.round((ts.lineHeight / ts.fontSize) * 100) / 100;
+    lhMap.set(ratio, (lhMap.get(ratio) || 0) + (ts.count || 0));
+  }
+
+  const usedLineHeights = new Map();
+  for (const [ratio, count] of lhMap) {
+    const nearest = findNearestLineHeight(ratio);
+    const acc = usedLineHeights.get(nearest.name) || { ...nearest, count: 0 };
+    acc.count += count;
+    usedLineHeights.set(nearest.name, acc);
+  }
+
+  const finalLineHeights = LH_RATIOS
+    .filter((lh) => usedLineHeights.has(lh.name))
+    .map((lh) => ({
+      name: lh.name,
+      value: lh.value,
+      cssVar: `--line-height-${lh.name}`,
+      usage: usedLineHeights.get(lh.name)?.count || 0,
+    }));
+
+  // 5. Letter spacing
+  const lsMap = new Map();
+  for (const ts of rawTextStyles) {
+    const ls = ts.letterSpacing || 0;
+    const em = ts.fontSize ? Math.round((ls / ts.fontSize) * 1000) / 1000 : 0;
+    const key = Math.round(em * 100) / 100;
+    lsMap.set(key, (lsMap.get(key) || 0) + (ts.count || 0));
+  }
+
+  const finalLetterSpacing = LS_SCALE.map((ls) => ({
+    name: ls.name,
+    em: ls.em,
+    cssVar: `--letter-spacing-${ls.name}`,
+  }));
+
+  // Stats
+  const totalBefore = {
+    families: sortedFamilies.length,
+    sizes: uniqueSizes.length,
+    weights: weightMap.size,
+  };
+  const totalAfter = {
+    families: selectedFamilies.length,
+    sizes: finalSizeScale.length,
+    weights: finalWeights.length,
+  };
+
+  const reductionPct =
+    (1 -
+      (totalAfter.families + totalAfter.sizes + totalAfter.weights) /
+        (totalBefore.families + totalBefore.sizes + totalBefore.weights)) *
+    100;
+
+  const scores = {
+    before: totalBefore,
+    after: totalAfter,
+    reduction: `${Math.round(reductionPct * 10) / 10}%`,
+    target: '50%',
+    status: reductionPct >= 50 ? 'PASS' : reductionPct >= 35 ? 'CONDITIONAL' : 'FAIL',
+    families_status: totalAfter.families <= 3 ? 'PASS' : totalAfter.families === 4 ? 'CONDITIONAL' : 'FAIL',
+    weights_status: totalAfter.weights <= 5 ? 'PASS' : totalAfter.weights === 6 ? 'CONDITIONAL' : 'FAIL',
+  };
+
+  // Text decoration analysis
+  const textDecorations = [...decorationMap.entries()]
+    .filter(([k]) => k !== 'NONE')
+    .map(([name, count]) => ({ name, count }))
+    .sort((a, b) => b.count - a.count);
+
+  // Text case analysis
+  const textCases = [...textCaseMap.entries()]
+    .filter(([k]) => k !== 'ORIGINAL')
+    .map(([name, count]) => ({ name, count }))
+    .sort((a, b) => b.count - a.count);
+
+  // Paragraph spacing analysis
+  const paragraphSpacingMap = new Map();
+  for (const ts of rawTextStyles) {
+    const ps = ts.paragraphSpacing || 0;
+    if (ps > 0) {
+      paragraphSpacingMap.set(ps, (paragraphSpacingMap.get(ps) || 0) + (ts.count || 0));
+    }
+  }
+  const paragraphSpacings = [...paragraphSpacingMap.entries()]
+    .map(([value, count]) => ({ value, count }))
+    .sort((a, b) => b.count - a.count);
+
+  const output = {
+    meta: {
+      source: 'all-pages-merged.json',
+      pagesIncluded: merged.meta.pagesIncluded,
+      curatedAt: new Date().toISOString(),
+      algorithm: 'Modular scale + font consolidation',
+      figmaTextStylesCount: textFigmaStyles.length,
+    },
+    scores,
+    families: selectedFamilies.map((f) => ({
+      name: f.name,
+      role: f.role,
+      count: f.count,
+      percentage: `${Math.round((f.count / totalFontUsage) * 1000) / 10}%`,
+      cssVar: `--font-family-${f.role}`,
+    })),
+    rejectedFamilies,
+    sizeScale: finalSizeScale,
+    weights: finalWeights,
+    lineHeights: finalLineHeights,
+    letterSpacing: finalLetterSpacing,
+    textDecorations,
+    textCases,
+    paragraphSpacings,
+    decisions,
+  };
+
+  fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+  fs.writeFileSync(OUTPUT_PATH, JSON.stringify(output, null, 2));
+
+  console.log(`\n--- RESULTS ---`);
+  console.log(`  Families: ${totalBefore.families} → ${totalAfter.families} (${scores.families_status})`);
+  console.log(`  Sizes: ${totalBefore.sizes} → ${totalAfter.sizes}`);
+  console.log(`  Weights: ${totalBefore.weights} → ${totalAfter.weights} (${scores.weights_status})`);
+  console.log(`  Line heights: ${lhMap.size} → ${finalLineHeights.length}`);
+  console.log(`  Text decorations: ${textDecorations.length} non-default`);
+  console.log(`  Text cases: ${textCases.length} non-default`);
+  console.log(`  Paragraph spacings: ${paragraphSpacings.length} distinct values`);
+  console.log(`  Overall reduction: ${scores.reduction} (target: ${scores.target}) → ${scores.status}`);
+  console.log(`  Decisions logged: ${decisions.length}`);
+  console.log(`\nOutput: ${OUTPUT_PATH}`);
+  console.log('=== DONE ===');
+}
+
+main();

package/pro/squads/design/scripts/design-system/design-system-metadata.test.js

@@ -0,0 +1,49 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+
+describe('design system metadata pipeline', () => {
+  test('generates metadata/components.json', () => {
+    const result = spawnSync('node', ['squads/design/scripts/design-system/generate_components_metadata.cjs'], {
+      encoding: 'utf8'
+    });
+
+    expect(result.status).toBe(0);
+    expect(existsSync('workspace/domains/design-system/metadata/components.json')).toBe(true);
+  });
+
+  test('validates metadata/components.json', () => {
+    const result = spawnSync('node', ['squads/design/scripts/design-system/validate_components_metadata.cjs'], {
+      encoding: 'utf8'
+    });
+
+    expect(result.status).toBe(0);
+    expect(result.stdout).toContain('PASS: validated');
+  });
+
+  test('validates MCP skeleton', () => {
+    const result = spawnSync('node', ['squads/design/scripts/design-system/validate_mcp_skeleton.cjs'], {
+      encoding: 'utf8'
+    });
+
+    expect(result.status).toBe(0);
+    expect(result.stdout).toContain('PASS: MCP skeleton');
+  });
+
+  test('syncs design manifest from squad.yaml', () => {
+    const result = spawnSync('node', ['squads/design/scripts/design-system/sync_design_manifest.cjs'], {
+      encoding: 'utf8'
+    });
+
+    expect(result.status).toBe(0);
+    expect(result.stdout).toContain('PASS: synced');
+  });
+
+  test('validates design manifest drift', () => {
+    const result = spawnSync('node', ['squads/design/scripts/design-system/validate_design_manifest_drift.cjs'], {
+      encoding: 'utf8'
+    });
+
+    expect(result.status).toBe(0);
+    expect(result.stdout).toContain('PASS: design manifest is synchronized');
+  });
+});