aiox-core 5.0.4 → 5.0.5

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

@@ -1,217 +0,0 @@
-#!/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

@@ -1,190 +0,0 @@
-#!/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

@@ -1,208 +0,0 @@
-#!/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();