chill-agent 0.0.0-stage → 1.0.0

package/src/cli.js

@@ -0,0 +1,250 @@
+// src/cli.js - ChillAgent CLI Command Router
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseArgs } from 'node:util';
+import { banner, c, select, multiselect, confirm } from './prompts.js';
+import { detectAgents } from './detector.js';
+import { AVAILABLE_SKILLS, copySkillsToProject, generatePointerBlock, injectPointerIntoFile } from './installer.js';
+import { scanDirectory, printAuditReport } from './auditor.js';
+import { DESIGN_PRESETS } from './presets.js';
+
+export async function runCli() {
+  const rawArgs = process.argv.slice(2);
+  const command = rawArgs[0] || 'wizard';
+
+  if (command === 'help' || command === '--help' || command === '-h') {
+    banner();
+    console.log(`
+${c.bold}USAGE:${c.reset}
+  npx chill-agent                          Launch interactive setup wizard
+  npx chill-agent install [--all] [--agent <name>]   Install anti-slop skills non-interactively
+  npx chill-agent audit [dir] [--json]     Scan code & copy for AI slop cliches
+  npx chill-agent init-design [preset]     Generate a high-craft DESIGN.md specification
+  npx chill-agent doctor                   Inspect detected coding agents and rule health
+  npx chill-agent rewind [subcommand]      Run deterministic time-travel debugger & proxy
+
+${c.bold}PRESETS FOR init-design:${c.reset}
+  linear-carbon    Precision carbon monochrome, 1px hairlines (Default)
+  swiss-brutal     Stark black/white contrast, zero border radius
+  technical-spec   Industrial data-first layout, telemetry density
+  editorial-paper  Warm ivory paper, literary serif headings
+  micro-density    Cyberpunk HUD, compact phosphor-green telemetry
+`);
+    return;
+  }
+
+  if (command === 'doctor') {
+    banner();
+    console.log(`${c.bold}ChillAgent Environment Diagnostics${c.reset}\n`);
+    const agents = detectAgents();
+    agents.forEach((ag) => {
+      const statusIcon = ag.isDetected ? `${c.emerald}✔ DETECTED${c.reset}` : `${c.gray}○ NOT FOUND${c.reset}`;
+      console.log(`  ${ag.icon} ${c.bold}${ag.name.padEnd(30)}${c.reset} ${statusIcon} ${c.dim}(${ag.matchType})${c.reset}`);
+    });
+    console.log();
+    return;
+  }
+
+  if (command === 'audit' || command === 'lint' || command === 'scan') {
+    const isFix = rawArgs.includes('--fix');
+    const targetDir = rawArgs[1] && !rawArgs[1].startsWith('--')
+      ? path.resolve(process.cwd(), rawArgs[1])
+      : process.cwd();
+
+    if (isFix) {
+      const { autoFixFile } = await import('./auditor.js');
+      let fixCount = 0;
+      function walkFix(dir) {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const e of entries) {
+          if (e.isDirectory() && !['node_modules', '.git', '.chillrewind', 'dist'].includes(e.name)) {
+            walkFix(path.join(dir, e.name));
+          } else if (e.isFile() && ['.js', '.jsx', '.ts', '.tsx', '.html', '.css', '.md'].some(ext => e.name.endsWith(ext))) {
+            if (autoFixFile(path.join(dir, e.name))) fixCount++;
+          }
+        }
+      }
+      walkFix(targetDir);
+      console.log(`\n${c.emerald}✔ Anti-Slop Auto-Fix Completed:${c.reset} Remedied slop patterns in ${c.bold}${fixCount}${c.reset} files.`);
+    }
+
+    const findings = scanDirectory(targetDir);
+    if (rawArgs.includes('--json')) {
+      console.log(JSON.stringify(findings, null, 2));
+    } else {
+      printAuditReport(findings, targetDir);
+    }
+    return;
+  }
+
+  if (command === 'init-design') {
+    const presetId = rawArgs[1];
+    let selectedPreset = DESIGN_PRESETS.find((p) => p.id === presetId);
+
+    if (!selectedPreset) {
+      banner();
+      const choice = await select({
+        message: 'Select a High-Craft Aesthetic Preset for DESIGN.md:',
+        choices: DESIGN_PRESETS.map((p) => ({
+          label: p.name,
+          value: p.id,
+          description: p.description
+        }))
+      });
+      selectedPreset = DESIGN_PRESETS.find((p) => p.id === choice);
+    }
+
+    if (selectedPreset) {
+      const destPath = path.join(process.cwd(), 'DESIGN.md');
+      fs.writeFileSync(destPath, selectedPreset.content, 'utf8');
+      console.log(`\n${c.emerald}✔ Generated DESIGN.md${c.reset} using '${c.bold}${selectedPreset.name}${c.reset}' preset.`);
+    }
+    return;
+  }
+
+  if (command === 'install') {
+    const { values } = parseArgs({
+      args: rawArgs.slice(1),
+      options: {
+        all: { type: 'boolean', default: false },
+        agent: { type: 'string', short: 'a' }
+      },
+      strict: false
+    });
+
+    const skillsToInstall = values.all
+      ? AVAILABLE_SKILLS.map((s) => s.id)
+      : ['chill-slop', 'chill-slop-ui', 'chill-slop-copywriting', 'chill-slop-code'];
+
+    copySkillsToProject(skillsToInstall);
+
+    const agents = detectAgents();
+    let targetAgents = agents.filter((ag) => ag.isDetected);
+    if (values.agent) {
+      targetAgents = agents.filter((ag) => ag.id === values.agent);
+    }
+    if (targetAgents.length === 0) {
+      targetAgents = [agents.find((ag) => ag.id === 'antigravity') || agents[0]];
+    }
+
+    const pointer = generatePointerBlock(skillsToInstall);
+    for (const ag of targetAgents) {
+      const targetFilePath = path.join(process.cwd(), ag.targetFile);
+      injectPointerIntoFile(targetFilePath, pointer);
+      console.log(`${c.emerald}✔ Injected Anti-Slop into ${ag.name}:${c.reset} ${ag.targetFile}`);
+    }
+    return;
+  }
+
+  if (command === 'rewind') {
+    const rewindCliPath = path.resolve(__dirname, '..', 'chillrewind', 'src', 'cli.ts');
+    if (!fs.existsSync(rewindCliPath)) {
+      console.error(`${c.coral}ChillRewind engine not found at ${rewindCliPath}${c.reset}`);
+      return;
+    }
+    const { spawn } = await import('node:child_process');
+    spawn('node', ['--experimental-strip-types', '--no-warnings', rewindCliPath, ...rawArgs.slice(1)], {
+      stdio: 'inherit'
+    });
+    return;
+  }
+
+  // Interactive Wizard (Default)
+  banner();
+  console.log(`${c.dim}Setting up ChillAgent Anti-Slop 2.0 in ${process.cwd()}${c.reset}\n`);
+
+  // Step 1: Detect Agents
+  const agents = detectAgents();
+  const detectedList = agents.filter((a) => a.isDetected);
+
+  let selectedAgents = [];
+  if (detectedList.length > 0) {
+    console.log(`${c.bold}Detected Agent Environments in Workspace:${c.reset}`);
+    detectedList.forEach((ag) => console.log(`  ${ag.icon} ${c.cyan}${ag.name}${c.reset} ${c.dim}(${ag.matchType})${c.reset}`));
+    console.log();
+
+    selectedAgents = await multiselect({
+      message: 'Select target coding agents to configure:',
+      choices: agents.map((ag) => ({
+        label: `${ag.icon} ${ag.name}`,
+        value: ag.id,
+        description: ag.isDetected ? 'Detected' : 'Standard'
+      })),
+      defaultSelected: detectedList.map((ag) => ag.id)
+    });
+  } else {
+    selectedAgents = await multiselect({
+      message: 'Select target coding agents to configure:',
+      choices: agents.map((ag) => ({
+        label: `${ag.icon} ${ag.name}`,
+        value: ag.id
+      })),
+      defaultSelected: ['antigravity', 'claude']
+    });
+  }
+
+  if (selectedAgents.length === 0) {
+    console.log(`${c.yellow}No agents selected. Exiting.${c.reset}`);
+    return;
+  }
+
+  // Step 2: Choose Skills
+  console.log();
+  const selectedSkills = await multiselect({
+    message: 'Select Anti-Slop skills to install into this project:',
+    choices: AVAILABLE_SKILLS.map((s) => ({
+      label: s.label,
+      value: s.id,
+      description: s.description
+    })),
+    defaultSelected: AVAILABLE_SKILLS.map((s) => s.id) // All by default
+  });
+
+  // Step 3: Design Direction
+  console.log();
+  const needDesignMd = !fs.existsSync(path.join(process.cwd(), 'DESIGN.md'));
+  if (needDesignMd) {
+    const wantDesign = await confirm({
+      message: 'No DESIGN.md found. Initialize a High-Craft aesthetic spec to avoid sterile AI defaults?'
+    });
+    if (wantDesign) {
+      const presetId = await select({
+        message: 'Pick an aesthetic foundation for DESIGN.md:',
+        choices: DESIGN_PRESETS.map((p) => ({
+          label: p.name,
+          value: p.id,
+          description: p.description
+        }))
+      });
+      const chosen = DESIGN_PRESETS.find((p) => p.id === presetId);
+      if (chosen) {
+        fs.writeFileSync(path.join(process.cwd(), 'DESIGN.md'), chosen.content, 'utf8');
+        console.log(`${c.emerald}✔ Generated DESIGN.md${c.reset} (${chosen.name})`);
+      }
+    }
+  }
+
+  // Step 4: Perform Installation
+  console.log(`\n${c.bold}Installing selected skills & injecting agent hooks...${c.reset}`);
+  const copied = copySkillsToProject(selectedSkills);
+  console.log(`${c.emerald}✔ Copied ${copied.length} skills into:${c.reset} ./skills/`);
+
+  const pointer = generatePointerBlock(selectedSkills);
+  for (const agentId of selectedAgents) {
+    const ag = agents.find((a) => a.id === agentId);
+    if (ag) {
+      const targetFilePath = path.join(process.cwd(), ag.targetFile);
+      injectPointerIntoFile(targetFilePath, pointer);
+      console.log(`${c.emerald}✔ Configured ${ag.name}:${c.reset} ${ag.targetFile}`);
+    }
+  }
+
+  console.log(`
+${c.green}${c.bold}✔ ChillAgent Anti-Slop 2.0 Successfully Activated!${c.reset}
+${c.dim}------------------------------------------------------------${c.reset}
+${c.bold}Next Steps:${c.reset}
+  • Run ${c.cyan}npx chill-agent audit${c.reset} to scan existing files for AI slop cliches.
+  • Run ${c.cyan}npx chill-agent rewind ui${c.reset} to inspect agent time-travel timelines.
+  • Start coding in your agent; all anti-slop rules are now strictly enforced!
+`);
+}

package/src/detector.js

@@ -0,0 +1,102 @@
+// src/detector.js - Coding Agent Environment & Configuration Detector
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+export function getHomeDir() {
+  return os.homedir();
+}
+
+export function detectAgents(projectRoot = process.cwd()) {
+  const home = getHomeDir();
+  const detected = [];
+
+  const candidates = [
+    {
+      id: 'antigravity',
+      name: 'Antigravity (Google / AGY)',
+      icon: '🌌',
+      projectFiles: ['GEMINI.md', 'AGENTS.md'],
+      globalPaths: [
+        path.join(home, '.gemini', 'antigravity'),
+        path.join(home, '.gemini', 'config', 'skills')
+      ],
+      targetFile: 'GEMINI.md'
+    },
+    {
+      id: 'claude',
+      name: 'Claude Code (Anthropic)',
+      icon: '🤖',
+      projectFiles: ['CLAUDE.md', '.claude-plugin'],
+      globalPaths: [path.join(home, '.claude')],
+      targetFile: 'CLAUDE.md'
+    },
+    {
+      id: 'cursor',
+      name: 'Cursor IDE',
+      icon: '⚡',
+      projectFiles: ['.cursorrules', '.cursor/rules'],
+      globalPaths: [path.join(home, '.cursor')],
+      targetFile: fs.existsSync(path.join(projectRoot, '.cursor', 'rules'))
+        ? path.join('.cursor', 'rules', 'chill-agent.mdc')
+        : '.cursorrules'
+    },
+    {
+      id: 'windsurf',
+      name: 'Windsurf (Codeium)',
+      icon: '🏄',
+      projectFiles: ['.windsurfrules', '.windsurf'],
+      globalPaths: [],
+      targetFile: '.windsurfrules'
+    },
+    {
+      id: 'codex',
+      name: 'OpenAI Codex / OpenCode',
+      icon: '🧠',
+      projectFiles: ['AGENTS.md', '.codex-plugin'],
+      globalPaths: [path.join(home, '.codex')],
+      targetFile: 'AGENTS.md'
+    },
+    {
+      id: 'copilot',
+      name: 'GitHub Copilot Workspace',
+      icon: '🐙',
+      projectFiles: ['.github/copilot-instructions.md'],
+      globalPaths: [],
+      targetFile: path.join('.github', 'copilot-instructions.md')
+    }
+  ];
+
+  for (const agent of candidates) {
+    let found = false;
+    let matchType = 'none';
+
+    // Check project-level existence
+    for (const rel of agent.projectFiles) {
+      if (fs.existsSync(path.join(projectRoot, rel))) {
+        found = true;
+        matchType = `project (${rel})`;
+        break;
+      }
+    }
+
+    // Check global installation
+    if (!found) {
+      for (const gPath of agent.globalPaths) {
+        if (fs.existsSync(gPath)) {
+          found = true;
+          matchType = 'global';
+          break;
+        }
+      }
+    }
+
+    detected.push({
+      ...agent,
+      isDetected: found,
+      matchType
+    });
+  }
+
+  return detected;
+}

package/src/index.js

@@ -0,0 +1,6 @@
+// src/index.js - ChillAgent main export
+export * from './auditor.js';
+export * from './detector.js';
+export * from './installer.js';
+export * from './presets.js';
+export * from './prompts.js';

package/src/installer.js

@@ -0,0 +1,81 @@
+// src/installer.js - Multi-Agent Skill Injector & Config Manager
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { c } from './prompts.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT_DIR = path.resolve(__dirname, '..');
+
+export const AVAILABLE_SKILLS = [
+  { id: 'chill-slop', label: 'ChillSlop Master Filter (Core)', description: 'Hard gates, purpose tests, craftsmanship standard' },
+  { id: 'chill-slop-ui', label: 'ChillSlop UI & Layout', description: 'Monochrome surfaces, typography, non-generic cards' },
+  { id: 'chill-slop-copywriting', label: 'ChillSlop Copywriting', description: 'Strip AI buzzwords, vague hype, fake testimonials' },
+  { id: 'chill-slop-code', label: 'ChillSlop Clean Code', description: 'Technical docstrings, zero emoji clutter, no obvious comments' },
+  { id: 'chill-slop-human', label: 'ChillSlop Ergonomics & A11y', description: 'WCAG contrast, focus rings, 44px tap targets' },
+  { id: 'chill-slop-mobile', label: 'ChillSlop Mobile & Fluid', description: 'Clamp scaling, thumb reach zones, zero overflow' }
+];
+
+export function generatePointerBlock(selectedSkills = ['chill-slop']) {
+  const lines = [
+    '<!-- chill-agent:start -->',
+    '## ChillAgent Anti-Slop 2.0 Engine & Craftsmanship Standard',
+    'Before generating or editing any code, interface, copy, or architecture in this workspace, follow these active skills:',
+    ...selectedSkills.map((s) => `- \`skills/${s}/SKILL.md\``),
+    '',
+    '### Core Operating Rules:',
+    '1. **Purpose Test:** Every visual decision, color accent, layout structure, and copy phrase must name a specific domain purpose. AI defaults (purple gradients, rounded-3xl cards, generic cards) are forbidden.',
+    '2. **Liveliness Bar:** Avoid sterile defaults by reading `DESIGN.md`. If `DESIGN.md` is missing, adhere strictly to Linear/Geist carbon monochromatic standards.',
+    '3. **Context Hygiene:** Strip conversational fluff, emojis in code comments, and redundant obvious docstrings.',
+    '4. **Time-Travel Debugging:** When debugging stochastic agent loops, route upstream LLM calls through `chillrewind run` (deterministic SQLite WAL replay + SlopSieve circuit breaker).',
+    '<!-- chill-agent:end -->'
+  ];
+  return lines.join('\n');
+}
+
+export function copySkillsToProject(selectedSkills, targetDir = process.cwd()) {
+  const destSkillsDir = path.join(targetDir, 'skills');
+  if (!fs.existsSync(destSkillsDir)) fs.mkdirSync(destSkillsDir, { recursive: true });
+
+  const copied = [];
+  for (const skillId of selectedSkills) {
+    const srcDir = path.join(ROOT_DIR, 'skills', skillId);
+    const destDir = path.join(destSkillsDir, skillId);
+
+    if (fs.existsSync(srcDir)) {
+      if (!fs.existsSync(destDir)) fs.mkdirSync(destDir, { recursive: true });
+      const srcSkillMd = path.join(srcDir, 'SKILL.md');
+      const destSkillMd = path.join(destDir, 'SKILL.md');
+      if (fs.existsSync(srcSkillMd)) {
+        fs.copyFileSync(srcSkillMd, destSkillMd);
+        copied.push(skillId);
+      }
+    }
+  }
+  return copied;
+}
+
+export function injectPointerIntoFile(targetFilePath, pointerBlock) {
+  let existingContent = '';
+  if (fs.existsSync(targetFilePath)) {
+    existingContent = fs.readFileSync(targetFilePath, 'utf8');
+  } else {
+    const parentDir = path.dirname(targetFilePath);
+    if (!fs.existsSync(parentDir)) fs.mkdirSync(parentDir, { recursive: true });
+  }
+
+  const startMarker = '<!-- chill-agent:start -->';
+  const endMarker = '<!-- chill-agent:end -->';
+
+  let newContent = '';
+  if (existingContent.includes(startMarker) && existingContent.includes(endMarker)) {
+    const before = existingContent.substring(0, existingContent.indexOf(startMarker));
+    const after = existingContent.substring(existingContent.indexOf(endMarker) + endMarker.length);
+    newContent = `${before.trimEnd()}\n\n${pointerBlock}\n${after.trimStart()}`.trim() + '\n';
+  } else {
+    newContent = existingContent.trim() ? `${existingContent.trim()}\n\n${pointerBlock}\n` : `${pointerBlock}\n`;
+  }
+
+  fs.writeFileSync(targetFilePath, newContent, 'utf8');
+  return true;
+}

package/src/presets.js

@@ -0,0 +1,126 @@
+// src/presets.js - 5 High-Craft Design System Presets for DESIGN.md
+export const DESIGN_PRESETS = [
+  {
+    id: 'linear-carbon',
+    name: 'Linear Carbon Geist (Recommended)',
+    description: 'Precision carbon monochrome, 1px hairlines, JetBrains Mono, emerald accents.',
+    content: `# DESIGN.md — Linear Carbon Geist Spec
+
+## Identity & Philosophy
+- **Vibe:** Precision engineering, ultra-clean desktop utility, focused zero-distraction dark canvas.
+- **Aesthetic Benchmark:** Linear, Vercel Geist, Raycast.
+
+## Palette
+- **Canvas Base:** \`#09090B\`
+- **Surface Layer 1 (Panel):** \`#101014\`
+- **Surface Layer 2 (Interactive):** \`#16161C\`
+- **Surface Hover:** \`#1E1E26\`
+- **Hairline Border:** \`1px solid #26262E\`
+- **Border Focus / Hover:** \`1px solid #3F3F4E\`
+- **Text Primary:** \`#F4F4F6\`
+- **Text Secondary:** \`#A1A1AA\`
+- **Text Muted:** \`#63636E\`
+- **Semantic Accents:**
+  - Emerald (Replay / Success): \`#10B981\` (Badge: \`rgba(16, 185, 129, 0.12)\`)
+  - Amber (Sieve / Pruned): \`#F59E0B\` (Badge: \`rgba(245, 158, 11, 0.12)\`)
+  - Rose (Circuit Breaker): \`#F43F5E\` (Badge: \`rgba(244, 63, 94, 0.12)\`)
+  - Indigo (Fork / Branch): \`#818CF8\` (Badge: \`rgba(129, 140, 248, 0.14)\`)
+
+## Typography
+- **Display & Body:** Inter, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif
+- **Code & Tabular Numbers:** 'JetBrains Mono', 'Fira Code', 'SF Mono', Consolas, ui-monospace
+- **Letter Spacing:** Headers \`-0.025em\`, Uppercase Tags \`+0.05em\`
+
+## Radius & Elevation
+- **Controls & Badges:** \`4px\` to \`6px\`
+- **Cards & Modals:** \`8px\`
+- **Shadows:** None or tight micro-ambient \`0 1px 2px rgba(0,0,0,0.5)\`. Rely on hairline borders.
+`
+  },
+  {
+    id: 'swiss-brutal',
+    name: 'Swiss Neo-Brutal',
+    description: 'Stark black-and-white contrast, zero rounded corners, heavy grotesque type.',
+    content: `# DESIGN.md — Swiss Neo-Brutal Spec
+
+## Identity & Philosophy
+- **Vibe:** Uncompromising graphic clarity, International Typographic Style, pure structure.
+- **Aesthetic Benchmark:** Neue Haas Grotesk, Bauhaus posters, modernist archives.
+
+## Palette
+- **Canvas Base:** \`#FFFFFF\` (or Inverted Dark: \`#0A0A0A\`)
+- **Ink Primary:** \`#000000\`
+- **Divider Hairline:** \`2px solid #000000\`
+- **Accent Red:** \`#FF2200\` (Used sparingly for primary anchor)
+
+## Typography
+- **Primary:** 'Space Grotesk', 'Helvetica Neue', Arial, sans-serif
+- **Headers:** Tight line-height (\`0.95\`), uppercase leading sections, zero kerning slop.
+
+## Geometry
+- **Border Radius:** \`0px\` strictly everywhere.
+- **Grids:** Strict visible grid lines, bold high-contrast dividers, asymmetric block layouts.
+`
+  },
+  {
+    id: 'technical-spec',
+    name: 'Industrial Technical Dossier',
+    description: 'Data-first layout, slate/steel tone, dense tabular views, blueprint annotations.',
+    content: `# DESIGN.md — Industrial Technical Dossier Spec
+
+## Identity & Philosophy
+- **Vibe:** Mission control telemetry, NASA flight documentation, Bloomberg terminal density.
+- **Aesthetic Benchmark:** Grafana, Datadog Enterprise, Flight Radar.
+
+## Palette
+- **Canvas Base:** \`#0B0F19\`
+- **Panel Surface:** \`#111827\`
+- **Border Grid:** \`1px solid #1F2937\`
+- **Cyan Signal:** \`#38BDF8\`
+- **Amber Warning:** \`#FBBF24\`
+
+## Typography
+- Monospace-first layout for all data cells, timestamps, and parameters.
+- Micro-labels at \`10px\` with uppercase \`+0.08em\` letter-spacing.
+`
+  },
+  {
+    id: 'editorial-paper',
+    name: 'Warm Analog Editorial',
+    description: 'Warm ivory paper, charcoal ink, literary serif headings, tactile book feel.',
+    content: `# DESIGN.md — Warm Analog Editorial Spec
+
+## Identity & Philosophy
+- **Vibe:** Handcrafted print journalism, literary publication, analog warmth.
+- **Aesthetic Benchmark:** The Atlantic, Kinfolk, Stripe Press.
+
+## Palette
+- **Paper Canvas:** \`#FBFBF9\`
+- **Charcoal Ink:** \`#1A1A1A\`
+- **Secondary Ink:** \`#575757\`
+- **Warm Border:** \`1px solid #E6E6DF\`
+- **Terracotta Accent:** \`#C85A32\`
+
+## Typography
+- **Display & Headings:** 'Newsreader', 'Playfair Display', Georgia, serif
+- **Body & Microcopy:** 'Inter', -apple-system, sans-serif
+`
+  },
+  {
+    id: 'micro-density',
+    name: 'Cyberpunk Micro-Density',
+    description: 'High-density HUD panels, emerald phosphor text, compact technical toggles.',
+    content: `# DESIGN.md — Cyberpunk Micro-Density Spec
+
+## Identity & Philosophy
+- **Vibe:** Embedded systems monitor, sub-millisecond network analyzer.
+- **Aesthetic Benchmark:** Rizin, IDA Pro, Bloomberg CLI.
+
+## Palette
+- **Phosphor Green:** \`#22C55E\`
+- **Deep Obsidian:** \`#050505\`
+- **Surface Elevation:** \`#0D0D0D\`
+- **Grid Trace:** \`1px solid #1A1A1A\`
+`
+  }
+];