chill-agent 0.0.0-stage → 1.1.0

package/src/auditor.js

@@ -0,0 +1,229 @@
+// src/auditor.js - Automated Anti-Slop & Over-Engineering Scanner
+import fs from 'node:fs';
+import path from 'node:path';
+import { c } from './prompts.js';
+
+const SLOP_PATTERNS = [
+  // 1. Visual Slop (Anti-Slop UI)
+  {
+    id: 'VISUAL-01',
+    category: 'Visual Slop',
+    severity: 'HIGH',
+    regex: /from-purple-[0-9]{3}\s+to-indigo-[0-9]{3}|from-violet-[0-9]{3}\s+to-cyan-[0-9]{3}|from-indigo-[0-9]{3}\s+to-pink-[0-9]{3}/i,
+    name: 'Generic AI Purple/Cyan Gradient',
+    fix: 'Replace with precision monochromatic carbon `#09090B` or a branded domain color palette.'
+  },
+  {
+    id: 'VISUAL-02',
+    category: 'Visual Slop',
+    severity: 'MEDIUM',
+    regex: /rounded-3xl|rounded-full\s+.*shadow-2xl/i,
+    name: 'Pill-Shaped Floating Bubble',
+    fix: 'Use crisp geometric radius (4px to 8px) with hairline 1px borders instead of rounded-3xl with heavy shadow.'
+  },
+  {
+    id: 'VISUAL-03',
+    category: 'Visual Slop',
+    severity: 'LOW',
+    regex: /backdrop-blur-(md|lg|xl|2xl)/i,
+    name: 'Excessive Glassmorphic Blur',
+    fix: 'Ensure backdrop-blur is not stacked across cards, modals, and navbars simultaneously.'
+  },
+
+  // 2. Over-Engineering & Bloat (Ponytail Minimalism)
+  {
+    id: 'BLOAT-01',
+    category: 'Over-Engineering',
+    severity: 'HIGH',
+    regex: /class\s+[A-Za-z0-9]+Factory|class\s+[A-Za-z0-9]+AbstractBuilder|class\s+[A-Za-z0-9]+ProviderManager/i,
+    name: 'Premature Factory / Builder Abstraction',
+    fix: 'Ponytail YAGNI rule: replace speculative multi-class factory wrappers with a direct 1-line function or object literal.'
+  },
+  {
+    id: 'BLOAT-02',
+    category: 'Over-Engineering',
+    severity: 'MEDIUM',
+    regex: /import\s+.*lodash\/(cloneDeep|isEqual|merge)|import\s+is-number\s+from/i,
+    name: 'Unnecessary Micro-Dependency',
+    fix: 'Use native JavaScript standard library (`structuredClone`, `Object.assign`, or standard operators) instead of external micro-packages.'
+  },
+
+  // 3. Copywriting Slop
+  {
+    id: 'COPY-01',
+    category: 'Copywriting Slop',
+    severity: 'HIGH',
+    regex: /\b(unleash\s+the\s+power\s+of|supercharge\s+your|seamlessly\s+integrate|next-generation|game-changer|delve\s+into|dive\s+deep\s+into)\b/i,
+    name: 'Generic AI Hype Filler',
+    fix: 'Replace vague hype words with concrete specifications or direct functional instructions.'
+  },
+  {
+    id: 'COPY-02',
+    category: 'Copywriting Slop',
+    severity: 'MEDIUM',
+    regex: /[✨🚀🎉💡🔥]/u,
+    name: 'AI Sparkle / Rocket Emoji Cliché',
+    fix: 'Strip emojis from marketing headlines, documentation, and interface button labels.'
+  },
+  {
+    id: 'COPY-03',
+    category: 'Copywriting Slop',
+    severity: 'HIGH',
+    regex: /\b(trusted\s+by\s+[0-9,]+\s+happy\s+customers|99\.9%\s+customer\s+satisfaction)\b/i,
+    name: 'Hallucinated Social Proof',
+    fix: 'Cite verified customer metrics or remove synthetic testimonials entirely.'
+  },
+
+  // 4. Code Hygiene Slop
+  {
+    id: 'CODE-01',
+    category: 'Code Hygiene',
+    severity: 'MEDIUM',
+    regex: /\/\/\s*(this\s+function\s+calculates|this\s+is\s+the\s+render\s+method|define\s+variables?|initialize\s+state)/i,
+    name: 'Redundant Obvious AI Code Comment',
+    fix: 'Remove comments that merely restate what the code visibly does. Document the "WHY", not the "WHAT".'
+  },
+  {
+    id: 'CODE-02',
+    category: 'Code Hygiene',
+    severity: 'LOW',
+    regex: /\/\/\s*TODO:\s*(implement\s+this|add\s+logic\s+later|finish\s+this)/i,
+    name: 'Unimplemented Lazy AI Stub',
+    fix: 'Provide full working implementation or throw explicit NotImplementedError with actionable message.'
+  },
+
+  // 5. Human Factors & Accessibility
+  {
+    id: 'A11Y-01',
+    category: 'Human Factors',
+    severity: 'HIGH',
+    regex: /<button[^>]*>[^<]*<svg[^>]*>[\s\S]*?<\/svg>[^<]*<\/button>/i,
+    name: 'Icon Button Missing Accessible Label',
+    fix: 'Add aria-label="..." to the button element so screen readers can identify the control action.'
+  }
+];
+
+const SCAN_EXTENSIONS = new Set([
+  '.js', '.jsx', '.ts', '.tsx', '.vue', '.svelte', '.html', '.css', '.md', '.mdx'
+]);
+
+const IGNORE_DIRS = new Set([
+  'node_modules', '.git', '.chillrewind', 'dist', 'build', '.next', '.cache', 'coverage'
+]);
+
+export function scanFile(filePath) {
+  const findings = [];
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split('\n');
+
+    lines.forEach((line, lineIdx) => {
+      for (const pattern of SLOP_PATTERNS) {
+        if (pattern.regex.test(line)) {
+          findings.push({
+            file: filePath,
+            line: lineIdx + 1,
+            snippet: line.trim().slice(0, 80),
+            ...pattern
+          });
+        }
+      }
+    });
+  } catch {}
+  return findings;
+}
+
+export function autoFixFile(filePath) {
+  let modified = false;
+  try {
+    let content = fs.readFileSync(filePath, 'utf8');
+
+    // 1. Strip marketing emojis
+    const strippedEmoji = content.replace(/[✨🚀🎉💡🔥]/gu, '');
+    if (strippedEmoji !== content) {
+      content = strippedEmoji;
+      modified = true;
+    }
+
+    // 2. Fix redundant obvious comments
+    const strippedComments = content.replace(/\/\/\s*(this\s+function\s+calculates|this\s+is\s+the\s+render\s+method|define\s+variables?|initialize\s+state).*\n/gi, '');
+    if (strippedComments !== content) {
+      content = strippedComments;
+      modified = true;
+    }
+
+    // 3. Fix rounded-3xl cards
+    const fixedRadius = content.replace(/\brounded-3xl\b/g, 'rounded-lg');
+    if (fixedRadius !== content) {
+      content = fixedRadius;
+      modified = true;
+    }
+
+    if (modified) {
+      fs.writeFileSync(filePath, content, 'utf8');
+    }
+  } catch {}
+  return modified;
+}
+
+export function scanDirectory(dirPath) {
+  const allFindings = [];
+
+  function walk(current) {
+    let entries = [];
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (!IGNORE_DIRS.has(entry.name)) {
+          walk(path.join(current, entry.name));
+        }
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name);
+        if (SCAN_EXTENSIONS.has(ext)) {
+          const res = scanFile(path.join(current, entry.name));
+          allFindings.push(...res);
+        }
+      }
+    }
+  }
+
+  walk(dirPath);
+  return allFindings;
+}
+
+export function printAuditReport(findings, targetDir = process.cwd()) {
+  console.log(`\n${c.bold}ChillAgent Anti-Slop & Over-Engineering Audit${c.reset}`);
+  console.log(`${c.dim}Scanned directory: ${targetDir}${c.reset}\n`);
+
+  if (findings.length === 0) {
+    console.log(`${c.green}${c.bold}✔ Clean Codebase!${c.reset} No AI slop patterns or premature over-engineering found.`);
+    return;
+  }
+
+  const highCount = findings.filter((f) => f.severity === 'HIGH').length;
+  const medCount = findings.filter((f) => f.severity === 'MEDIUM').length;
+  const lowCount = findings.filter((f) => f.severity === 'LOW').length;
+
+  console.log(
+    `Found ${c.bold}${findings.length} infractions${c.reset} ` +
+      `(${c.coral}${highCount} High${c.reset}, ${c.amber}${medCount} Medium${c.reset}, ${c.gray}${lowCount} Low${c.reset}):\n`
+  );
+
+  findings.forEach((f, idx) => {
+    const sevColor = f.severity === 'HIGH' ? c.coral : f.severity === 'MEDIUM' ? c.amber : c.gray;
+    const relFile = path.relative(targetDir, f.file);
+
+    console.log(
+      `${c.bold}#${idx + 1}${c.reset} [${sevColor}${f.severity}${c.reset}] ` +
+        `${c.cyan}${f.category}${c.reset} — ${c.bold}${f.name}${c.reset}`
+    );
+    console.log(`  ${c.dim}Location:${c.reset} ${relFile}:${c.line}`);
+    console.log(`  ${c.dim}Snippet:${c.reset}  ${c.italic}"${f.snippet}"${c.reset}`);
+    console.log(`  ${c.emerald}Fix:${c.reset}      ${f.fix}\n`);
+  });
+}

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,84 @@
+// 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 (Anti-Slop + Ponytail Core)', description: 'Hard gates, YAGNI ladder, craftsmanship standard' },
+  { id: 'chill-slop-code', label: 'ChillSlop Pragmatic Code', description: 'Smallest complete change, native APIs, zero over-engineering' },
+  { id: 'chill-slop-ui', label: 'ChillSlop UI & Layout', description: 'Monochrome surfaces, 1px hairlines, non-generic cards' },
+  { id: 'chill-slop-copywriting', label: 'ChillSlop Copywriting', description: 'Strip AI buzzwords, vague hype, fake testimonials' },
+  { id: 'chill-slop-human', label: 'ChillSlop Ergonomics & A11y', description: 'WCAG 4.5:1 contrast, visible 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'], intensity = 'full') {
+  const lines = [
+    '<!-- chill-agent:start -->',
+    '## ChillAgent Anti-Slop 2.0 & Pragmatic Senior Dev Standard (Ponytail + Anti-Slop)',
+    `Active Mode: \`${intensity}\` (Options: lite | full | ultra). Switch anytime with \`/chill <mode>\`.`,
+    '',
+    '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. **The Smallest Complete Change (Ponytail):** Take the shortest path that solves the whole task: standard library > existing codebase helper > installed dependency > minimum new code. No premature abstractions or wrapper factories.',
+    '2. **Purpose Test (Anti-Slop):** 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.',
+    '3. **Liveliness Bar:** Avoid sterile defaults by reading `DESIGN.md`. If `DESIGN.md` is missing, adhere strictly to Linear/Geist carbon monochromatic standards.',
+    '4. **Context Hygiene & Time-Travel:** Strip conversational fluff and emojis. When debugging stochastic agent loops, route upstream LLM calls through `chillrewind run` (deterministic SQLite WAL replay + SlopSieve circuit breaker).',
+    '5. **Delivery Disclosure:** End non-trivial deliveries with a 1-line disclosure: what was skipped and known limits/trade-offs.',
+    '<!-- 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;
+}