aiox-core 5.0.1 → 5.0.3

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

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+/**
+ * Frequency Filter + Atomic Classification — Component Curation Pipeline
+ *
+ * Algorithm (from DS-CURATION-PIPELINE-PROPOSAL.md §4.6):
+ *   1. Filter by frequency of use (>= 3 instances)
+ *   2. Classify by atomic level (atom/molecule/organism)
+ *   3. Prioritize by impact (P0/P1/P2)
+ *   4. Map tokens and variants
+ */
+
+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-components.json');
+
+// ── Classification Rules ───────────────────────────────────────────────────
+
+const ATOM_PATTERNS = /\b(button|btn|input|label|badge|avatar|icon|tag|chip|switch|toggle|checkbox|radio|divider|spinner|loader|skeleton)\b/i;
+const MOLECULE_PATTERNS = /\b(form[-_]?field|card|alert|tooltip|toast|dropdown|select|menu[-_]?item|tab|breadcrumb|pagination|search|popover|dialog|modal[-_]?header|accordion)\b/i;
+const ORGANISM_PATTERNS = /\b(form|modal|sidebar|navbar|header|footer|table|data[-_]?table|calendar|carousel|wizard|stepper|layout|page|section|panel|drawer)\b/i;
+
+function classifyAtomic(name) {
+  const n = name.toLowerCase();
+  if (ATOM_PATTERNS.test(n)) return 'atom';
+  if (MOLECULE_PATTERNS.test(n)) return 'molecule';
+  if (ORGANISM_PATTERNS.test(n)) return 'organism';
+  return 'unknown';
+}
+
+// Size-based heuristic for classification when name doesn't match
+function classifyBySize(sizes) {
+  if (!sizes || sizes.length === 0) return 'unknown';
+  const avgArea = sizes.reduce((sum, s) => {
+    const [w, h] = s.split('x').map(Number);
+    return sum + (w || 0) * (h || 0);
+  }, 0) / sizes.length;
+
+  if (avgArea < 2000) return 'atom';       // < ~45x45
+  if (avgArea < 20000) return 'molecule';   // < ~140x140
+  return 'organism';
+}
+
+// ── Priority ───────────────────────────────────────────────────────────────
+
+const P0_PATTERNS = /\b(button|btn|input|card)\b/i;
+const P1_PATTERNS = /\b(badge|avatar|form|modal|alert|select|dropdown|toast|dialog)\b/i;
+
+function classifyPriority(name, usagePercent) {
+  const n = name.toLowerCase();
+  if (P0_PATTERNS.test(n) || usagePercent > 50) return 'P0';
+  if (P1_PATTERNS.test(n) || usagePercent > 20) return 'P1';
+  return 'P2';
+}
+
+// ── Variant Detection ──────────────────────────────────────────────────────
+
+const VARIANT_PATTERNS = {
+  state: /\b(default|hover|active|focus|disabled|pressed|loading|error|success|selected)\b/i,
+  size: /\b(xs|sm|md|lg|xl|2xl|small|medium|large|mini|compact)\b/i,
+  variant: /\b(primary|secondary|tertiary|ghost|outline|link|destructive|warning|info)\b/i,
+};
+
+function detectVariants(name, contexts) {
+  const allText = [name, ...(contexts || [])].join(' ');
+  const detected = {};
+
+  for (const [category, pattern] of Object.entries(VARIANT_PATTERNS)) {
+    const matches = new Set();
+    let match;
+    const regex = new RegExp(pattern.source, 'gi');
+    while ((match = regex.exec(allText)) !== null) {
+      matches.add(match[0].toLowerCase());
+    }
+    if (matches.size > 0) {
+      detected[category] = [...matches];
+    }
+  }
+
+  return detected;
+}
+
+// ── Main ───────────────────────────────────────────────────────────────────
+
+function main() {
+  console.log('=== COMPONENT CURATION PIPELINE ===\n');
+
+  const merged = JSON.parse(fs.readFileSync(MERGED_PATH, 'utf8'));
+  const rawComponents = merged.components || [];
+
+  console.log(`Input: ${rawComponents.length} unique components from ${merged.meta.pagesIncluded} pages`);
+
+  const totalUsage = rawComponents.reduce((sum, c) => sum + (c.count || 0), 0);
+
+  // Filter by frequency (>= 3 instances)
+  const MIN_INSTANCES = 3;
+  const filtered = rawComponents.filter((c) => (c.count || 0) >= MIN_INSTANCES);
+  console.log(`  After frequency filter (>= ${MIN_INSTANCES}): ${filtered.length}`);
+
+  // Classify and enrich — now using real component names
+  const curated = filtered.map((comp) => {
+    const usagePercent = ((comp.count || 0) / totalUsage) * 100;
+    const nameForClassification = comp.name || (comp.sizes ? comp.sizes.join(' ') : '');
+
+    let atomicLevel = classifyAtomic(nameForClassification);
+    if (atomicLevel === 'unknown') {
+      // Heuristic: components with componentProperties (variant props) are likely molecules/organisms
+      const propCount = comp.componentProperties ? Object.keys(comp.componentProperties).length : 0;
+      if (propCount >= 3) {
+        atomicLevel = 'organism';
+      } else if (propCount >= 1) {
+        atomicLevel = 'molecule';
+      } else {
+        atomicLevel = classifyBySize(comp.sizes);
+      }
+    }
+
+    const variants = detectVariants(
+      nameForClassification,
+      comp.contexts || []
+    );
+
+    return {
+      name: comp.name || null,
+      figmaName: comp.name || null,
+      componentId: comp.componentId || null,
+      sizes: comp.sizes || [],
+      type: comp.type,
+      count: comp.count || 0,
+      usagePercent: Math.round(usagePercent * 100) / 100,
+      atomicLevel,
+      priority: classifyPriority(nameForClassification, usagePercent),
+      variants,
+      hasComponentProperties: comp.componentProperties ? Object.keys(comp.componentProperties).length > 0 : false,
+      pages: comp.pages || [],
+    };
+  });
+
+  // Sort by count descending
+  curated.sort((a, b) => b.count - a.count);
+
+  // Group by atomic level
+  const atoms = curated.filter((c) => c.atomicLevel === 'atom');
+  const molecules = curated.filter((c) => c.atomicLevel === 'molecule');
+  const organisms = curated.filter((c) => c.atomicLevel === 'organism');
+  const unknown = curated.filter((c) => c.atomicLevel === 'unknown');
+
+  // Priority grouping
+  const p0 = curated.filter((c) => c.priority === 'P0');
+  const p1 = curated.filter((c) => c.priority === 'P1');
+  const p2 = curated.filter((c) => c.priority === 'P2');
+
+  // Stats
+  const scores = {
+    before: rawComponents.length,
+    after: curated.length,
+    reduction: `${Math.round(((rawComponents.length - curated.length) / rawComponents.length) * 1000) / 10}%`,
+    atomic: {
+      atoms: atoms.length,
+      molecules: molecules.length,
+      organisms: organisms.length,
+      unknown: unknown.length,
+    },
+    priority: {
+      P0: p0.length,
+      P1: p1.length,
+      P2: p2.length,
+    },
+  };
+
+  const output = {
+    meta: {
+      source: 'all-pages-merged.json',
+      pagesIncluded: merged.meta.pagesIncluded,
+      curatedAt: new Date().toISOString(),
+      algorithm: 'Frequency filter + atomic classification',
+      minInstances: MIN_INSTANCES,
+    },
+    scores,
+    components: curated,
+    topP0: p0.slice(0, 10).map((c) => ({
+      name: c.name,
+      sizes: c.sizes,
+      count: c.count,
+      atomicLevel: c.atomicLevel,
+    })),
+    topP1: p1.slice(0, 10).map((c) => ({
+      name: c.name,
+      sizes: c.sizes,
+      count: c.count,
+      atomicLevel: c.atomicLevel,
+    })),
+  };
+
+  fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+  fs.writeFileSync(OUTPUT_PATH, JSON.stringify(output, null, 2));
+
+  console.log(`\n--- RESULTS ---`);
+  console.log(`  Before: ${scores.before} components`);
+  console.log(`  After:  ${scores.after} components`);
+  console.log(`  Reduction: ${scores.reduction}`);
+  console.log(`  Atomic: ${atoms.length} atoms, ${molecules.length} molecules, ${organisms.length} organisms, ${unknown.length} unknown`);
+  console.log(`  Priority: ${p0.length} P0, ${p1.length} P1, ${p2.length} P2`);
+  console.log(`\n  Top 5 most-used:`);
+  for (const c of curated.slice(0, 5)) {
+    console.log(`    ${c.name || '(unnamed)'} [${(c.sizes || []).join(', ')}] — ${c.count}x (${c.atomicLevel}, ${c.priority})`);
+  }
+  console.log(`\nOutput: ${OUTPUT_PATH}`);
+  console.log('=== DONE ===');
+}
+
+main();

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

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+/**
+ * Harmonic Scale Mapping — Border Radius Curation Pipeline
+ *
+ * Algorithm (from DS-CURATION-PIPELINE-PROPOSAL.md §4.5):
+ *   1. Normalize to px
+ *   2. Bucket by size ranges (none → full)
+ *   3. Select most-used value per bucket as canonical
+ *   4. Detect brand signature radius preferences
+ */
+
+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-radius.json');
+
+// ── Radius Buckets (Tailwind-compatible) ───────────────────────────────────
+
+const RADIUS_BUCKETS = [
+  { name: 'none', min: 0, max: 0, rem: '0' },
+  { name: 'sm', min: 1, max: 4, rem: '0.125rem' },
+  { name: 'md', min: 5, max: 8, rem: '0.375rem' },
+  { name: 'lg', min: 9, max: 12, rem: '0.5rem' },
+  { name: 'xl', min: 13, max: 16, rem: '0.75rem' },
+  { name: '2xl', min: 17, max: 24, rem: '1rem' },
+  { name: '3xl', min: 25, max: 40, rem: '1.5rem' },
+  { name: 'full', min: 41, max: Infinity, rem: '9999px' },
+];
+
+function findBucket(px) {
+  for (const bucket of RADIUS_BUCKETS) {
+    if (px >= bucket.min && px <= bucket.max) {
+      return bucket;
+    }
+  }
+  return RADIUS_BUCKETS[RADIUS_BUCKETS.length - 1];
+}
+
+// ── Main ───────────────────────────────────────────────────────────────────
+
+function main() {
+  console.log('=== BORDER RADIUS CURATION PIPELINE ===\n');
+
+  const merged = JSON.parse(fs.readFileSync(MERGED_PATH, 'utf8'));
+  const rawRadii = merged.radii || [];
+
+  console.log(`Input: ${rawRadii.length} unique radius values from ${merged.meta.pagesIncluded} pages`);
+
+  // Build unique values
+  const valueMap = new Map(); // px → count
+  for (const r of rawRadii) {
+    const px = Math.round(r.value || 0);
+    valueMap.set(px, (valueMap.get(px) || 0) + (r.count || 0));
+  }
+
+  const uniqueValues = [...valueMap.entries()]
+    .sort((a, b) => a[0] - b[0])
+    .map(([px, count]) => ({ px, count }));
+
+  console.log(`  Unique pixel values: ${uniqueValues.length}`);
+
+  // Bucket all values
+  const bucketedRadii = new Map();
+  const totalUsage = uniqueValues.reduce((sum, v) => sum + v.count, 0);
+
+  for (const val of uniqueValues) {
+    const bucket = findBucket(val.px);
+    if (!bucketedRadii.has(bucket.name)) {
+      bucketedRadii.set(bucket.name, []);
+    }
+    bucketedRadii.get(bucket.name).push(val);
+  }
+
+  // Select canonical value per bucket
+  const decisions = [];
+  const curatedRadii = [];
+
+  for (const bucket of RADIUS_BUCKETS) {
+    const values = bucketedRadii.get(bucket.name) || [];
+    if (values.length === 0 && bucket.name !== 'none') continue;
+
+    // Special case for 'none' — always include
+    if (bucket.name === 'none' && values.length === 0) {
+      curatedRadii.push({
+        name: `radius-${bucket.name}`,
+        cssVar: `--radius-${bucket.name}`,
+        px: 0,
+        rem: bucket.rem,
+        bucket: bucket.name,
+        count: 0,
+        candidatesInBucket: 0,
+      });
+      continue;
+    }
+
+    // Sort by count descending
+    values.sort((a, b) => b.count - a.count);
+    const canonical = values[0];
+
+    // For 'full', always use 9999px
+    const finalPx = bucket.name === 'full' ? 9999 : canonical.px;
+    const finalRem = bucket.name === 'full' ? '9999px' : `${Math.round((finalPx / 16) * 1000) / 1000}rem`;
+
+    curatedRadii.push({
+      name: `radius-${bucket.name}`,
+      cssVar: `--radius-${bucket.name}`,
+      px: finalPx,
+      rem: finalRem,
+      bucket: bucket.name,
+      count: values.reduce((sum, v) => sum + v.count, 0),
+      canonicalSource: canonical.px,
+      candidatesInBucket: values.length,
+    });
+
+    if (values.length > 1) {
+      decisions.push({
+        category: 'radius',
+        action: 'SELECT',
+        items: values.map((v) => `${v.px}px (${v.count}x)`),
+        result: `${finalPx}px`,
+        reason: `Most used in ${bucket.name} bucket (${canonical.count} instances)`,
+        authority: 'DS-CURATION-PIPELINE-PROPOSAL §4.5 — harmonic scale',
+      });
+    }
+  }
+
+  // Brand signature analysis: which buckets are most used?
+  const brandSignature = curatedRadii
+    .filter((r) => r.count > 0)
+    .sort((a, b) => b.count - a.count)
+    .slice(0, 3)
+    .map((r) => ({
+      bucket: r.bucket,
+      px: r.px,
+      count: r.count,
+      percentage: `${Math.round((r.count / totalUsage) * 1000) / 10}%`,
+    }));
+
+  // Stats
+  const reduction = ((uniqueValues.length - curatedRadii.length) / uniqueValues.length) * 100;
+  const mappedUsage = curatedRadii.reduce((sum, r) => sum + r.count, 0);
+  const coverage = totalUsage > 0 ? (mappedUsage / totalUsage) * 100 : 100;
+
+  const scores = {
+    before: uniqueValues.length,
+    after: curatedRadii.length,
+    reduction: `${Math.round(reduction * 10) / 10}%`,
+    target: '60%',
+    status: reduction >= 60 ? 'PASS' : reduction >= 40 ? 'CONDITIONAL' : 'FAIL',
+    coverage: `${Math.round(coverage * 10) / 10}%`,
+  };
+
+  const output = {
+    meta: {
+      source: 'all-pages-merged.json',
+      pagesIncluded: merged.meta.pagesIncluded,
+      curatedAt: new Date().toISOString(),
+      algorithm: 'Harmonic scale bucketing + frequency selection',
+    },
+    scores,
+    scale: curatedRadii,
+    brandSignature,
+    decisions,
+    distribution: RADIUS_BUCKETS.map((b) => ({
+      bucket: b.name,
+      range: `${b.min}-${b.max === Infinity ? '∞' : b.max}px`,
+      values: (bucketedRadii.get(b.name) || []).length,
+      totalUsage: (bucketedRadii.get(b.name) || []).reduce((sum, v) => sum + v.count, 0),
+    })),
+  };
+
+  fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+  fs.writeFileSync(OUTPUT_PATH, JSON.stringify(output, null, 2));
+
+  console.log(`\n--- RESULTS ---`);
+  console.log(`  Before: ${scores.before} values`);
+  console.log(`  After:  ${scores.after} tokens`);
+  console.log(`  Reduction: ${scores.reduction} (target: ${scores.target}) → ${scores.status}`);
+  console.log(`  Coverage: ${scores.coverage}`);
+  console.log(`  Brand signature: ${brandSignature.map((b) => `${b.bucket}=${b.px}px(${b.percentage})`).join(', ')}`);
+  console.log(`  Decisions logged: ${decisions.length}`);
+  console.log(`\nOutput: ${OUTPUT_PATH}`);
+  console.log('=== DONE ===');
+}
+
+main();

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

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+/**
+ * Depth Level Consolidation — Shadow Curation Pipeline
+ *
+ * Algorithm (from DS-CURATION-PIPELINE-PROPOSAL.md §4.4):
+ *   1. Calculate "depth score" for each shadow
+ *   2. Bucket by depth levels (xs/sm/md/lg/xl)
+ *   3. Select most-used shadow per bucket
+ *   4. Replace hardcoded colors with token references
+ */
+
+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-shadows.json');
+
+// ── Depth Buckets ──────────────────────────────────────────────────────────
+
+const DEPTH_BUCKETS = [
+  { name: 'xs', min: 0, max: 3, description: 'hover states, subtle elevation' },
+  { name: 'sm', min: 4, max: 8, description: 'cards resting' },
+  { name: 'md', min: 9, max: 15, description: 'cards elevated, dropdowns' },
+  { name: 'lg', min: 16, max: 25, description: 'dialogs, popovers' },
+  { name: 'xl', min: 26, max: 50, description: 'modals, overlays' },
+  { name: '2xl', min: 51, max: Infinity, description: 'maximum elevation' },
+];
+
+function calculateDepthScore(shadow) {
+  return Math.abs(shadow.offsetX || 0) + Math.abs(shadow.offsetY || 0) + (shadow.blurRadius || 0);
+}
+
+function findBucket(depthScore) {
+  for (const bucket of DEPTH_BUCKETS) {
+    if (depthScore >= bucket.min && depthScore <= bucket.max) {
+      return bucket;
+    }
+  }
+  return DEPTH_BUCKETS[DEPTH_BUCKETS.length - 1];
+}
+
+// ── Shadow to CSS ──────────────────────────────────────────────────────────
+
+function shadowToCSS(shadow) {
+  const inset = shadow.type === 'INNER_SHADOW' ? 'inset ' : '';
+  const ox = shadow.offsetX || 0;
+  const oy = shadow.offsetY || 0;
+  const blur = shadow.blurRadius || 0;
+  const spread = shadow.spread || 0;
+  const color = shadow.color || 'rgba(0,0,0,0.1)';
+
+  return `${inset}${ox}px ${oy}px ${blur}px ${spread}px ${color}`;
+}
+
+// ── Main ───────────────────────────────────────────────────────────────────
+
+function main() {
+  console.log('=== SHADOW CURATION PIPELINE ===\n');
+
+  const merged = JSON.parse(fs.readFileSync(MERGED_PATH, 'utf8'));
+  const rawShadows = merged.shadows || [];
+
+  console.log(`Input: ${rawShadows.length} unique shadows from ${merged.meta.pagesIncluded} pages`);
+
+  // Separate drop shadows vs inner shadows
+  const dropShadows = rawShadows.filter((s) => s.type === 'DROP_SHADOW');
+  const innerShadows = rawShadows.filter((s) => s.type === 'INNER_SHADOW');
+
+  console.log(`  Drop shadows: ${dropShadows.length}`);
+  console.log(`  Inner shadows: ${innerShadows.length}`);
+
+  // Calculate depth scores and bucket
+  const bucketedShadows = new Map(); // bucket name → shadows[]
+
+  for (const shadow of dropShadows) {
+    const depth = calculateDepthScore(shadow);
+    const bucket = findBucket(depth);
+
+    if (!bucketedShadows.has(bucket.name)) {
+      bucketedShadows.set(bucket.name, []);
+    }
+    bucketedShadows.get(bucket.name).push({
+      ...shadow,
+      depthScore: depth,
+      bucket: bucket.name,
+    });
+  }
+
+  // Select most-used shadow per bucket
+  const decisions = [];
+  const curatedShadows = [];
+
+  for (const bucket of DEPTH_BUCKETS) {
+    const shadows = bucketedShadows.get(bucket.name) || [];
+    if (shadows.length === 0) continue;
+
+    // Sort by count descending
+    shadows.sort((a, b) => (b.count || 0) - (a.count || 0));
+    const selected = shadows[0];
+
+    curatedShadows.push({
+      name: `shadow-${bucket.name}`,
+      cssVar: `--shadow-${bucket.name}`,
+      bucket: bucket.name,
+      description: bucket.description,
+      value: {
+        type: selected.type,
+        offsetX: selected.offsetX,
+        offsetY: selected.offsetY,
+        blurRadius: selected.blurRadius,
+        spread: selected.spread,
+        color: selected.color,
+      },
+      css: shadowToCSS(selected),
+      tokenizedCSS: shadowToCSS({
+        ...selected,
+        color: 'var(--color-shadow)',
+      }),
+      depthScore: selected.depthScore,
+      count: selected.count,
+      candidatesInBucket: shadows.length,
+    });
+
+    if (shadows.length > 1) {
+      decisions.push({
+        category: 'shadow',
+        action: 'SELECT',
+        items: shadows.map((s) => shadowToCSS(s)),
+        result: shadowToCSS(selected),
+        reason: `Most used in ${bucket.name} bucket (${selected.count} instances, ${shadows.length} candidates)`,
+        authority: 'DS-CURATION-PIPELINE-PROPOSAL §4.4 — depth bucketing',
+      });
+    }
+  }
+
+  // Handle inner shadows separately
+  const curatedInnerShadows = [];
+  if (innerShadows.length > 0) {
+    innerShadows.sort((a, b) => (b.count || 0) - (a.count || 0));
+    const topInner = innerShadows[0];
+    curatedInnerShadows.push({
+      name: 'shadow-inner',
+      cssVar: '--shadow-inner',
+      description: 'inner shadow (inset)',
+      value: {
+        type: topInner.type,
+        offsetX: topInner.offsetX,
+        offsetY: topInner.offsetY,
+        blurRadius: topInner.blurRadius,
+        spread: topInner.spread,
+        color: topInner.color,
+      },
+      css: shadowToCSS(topInner),
+      count: topInner.count,
+    });
+  }
+
+  // Stats
+  const totalAfter = curatedShadows.length + curatedInnerShadows.length;
+  const reduction = ((rawShadows.length - totalAfter) / rawShadows.length) * 100;
+
+  const scores = {
+    before: rawShadows.length,
+    after: totalAfter,
+    reduction: `${Math.round(reduction * 10) / 10}%`,
+    target: '70%',
+    status: reduction >= 70 ? 'PASS' : reduction >= 50 ? 'CONDITIONAL' : 'FAIL',
+    buckets_used: curatedShadows.length,
+    inner_shadows: curatedInnerShadows.length,
+  };
+
+  const output = {
+    meta: {
+      source: 'all-pages-merged.json',
+      pagesIncluded: merged.meta.pagesIncluded,
+      curatedAt: new Date().toISOString(),
+      algorithm: 'Depth-level bucketing + frequency selection',
+    },
+    scores,
+    shadows: curatedShadows,
+    innerShadows: curatedInnerShadows,
+    decisions,
+    depthDistribution: DEPTH_BUCKETS.map((b) => ({
+      bucket: b.name,
+      range: `${b.min}-${b.max === Infinity ? '∞' : b.max}`,
+      count: (bucketedShadows.get(b.name) || []).length,
+    })),
+  };
+
+  fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+  fs.writeFileSync(OUTPUT_PATH, JSON.stringify(output, null, 2));
+
+  console.log(`\n--- RESULTS ---`);
+  console.log(`  Before: ${scores.before} shadows`);
+  console.log(`  After:  ${scores.after} tokens (${scores.buckets_used} drop + ${scores.inner_shadows} inner)`);
+  console.log(`  Reduction: ${scores.reduction} (target: ${scores.target}) → ${scores.status}`);
+  for (const s of curatedShadows) {
+    console.log(`    ${s.name}: depth=${s.depthScore}, used=${s.count}x, candidates=${s.candidatesInBucket}`);
+  }
+  console.log(`  Decisions logged: ${decisions.length}`);
+  console.log(`\nOutput: ${OUTPUT_PATH}`);
+  console.log('=== DONE ===');
+}
+
+main();