clamper-ai 1.1.6

package/skills/svg-draw/SKILL.md

@@ -0,0 +1,75 @@
+---
+name: svg-draw
+description: Create SVG images and convert them to PNG without external graphics libraries.
+---
+
+# SVG Draw
+
+Generate vector graphics using pure SVG code. No external libraries required.
+
+## Creating SVGs
+
+### Basic Structure
+```xml
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 400 400" width="400" height="400">
+  <rect width="400" height="400" fill="#1a1a2e"/>  <!-- background -->
+  <!-- your content here -->
+</svg>
+```
+
+**Always include:** `xmlns`, `viewBox`, background `<rect>`, `width`/`height`.
+
+### Common Elements
+```xml
+<!-- Shapes -->
+<rect x="10" y="10" width="80" height="60" rx="10" fill="#3498db"/>
+<circle cx="200" cy="200" r="50" fill="#e74c3c"/>
+<ellipse cx="200" cy="200" rx="80" ry="50" fill="#2ecc71"/>
+<polygon points="200,50 350,350 50,350" fill="#f39c12"/>
+
+<!-- Paths (for complex shapes) -->
+<path d="M10 80 C 40 10, 65 10, 95 80 S 150 150, 180 80" stroke="#333" fill="none" stroke-width="2"/>
+
+<!-- Text -->
+<text x="200" y="200" text-anchor="middle" font-family="Arial" font-size="24" fill="white">Hello</text>
+
+<!-- Groups with transforms -->
+<g transform="translate(100,100) rotate(45)">
+  <rect width="50" height="50" fill="blue"/>
+</g>
+```
+
+### Gradients & Effects
+```xml
+<defs>
+  <linearGradient id="sky" x1="0%" y1="0%" x2="0%" y2="100%">
+    <stop offset="0%" stop-color="#87CEEB"/>
+    <stop offset="100%" stop-color="#E0F7FA"/>
+  </linearGradient>
+  <filter id="shadow">
+    <feDropShadow dx="2" dy="2" stdDeviation="3" flood-opacity="0.3"/>
+  </filter>
+</defs>
+<rect width="400" height="400" fill="url(#sky)"/>
+<circle cx="200" cy="200" r="50" fill="gold" filter="url(#shadow)"/>
+```
+
+## Converting to PNG
+
+```bash
+# Using rsvg-convert (install: apt install librsvg2-bin)
+rsvg-convert -w 800 -h 800 input.svg -o output.png
+
+# Using ImageMagick
+convert -density 150 input.svg output.png
+
+# Using Inkscape CLI
+inkscape input.svg --export-type=png --export-filename=output.png --export-width=800
+```
+
+## Tips
+- Use `viewBox` for responsive scaling — set it once, resize via width/height
+- Layer elements back to front (SVG paints in document order)
+- Use `opacity` for transparency, `stroke-dasharray` for dashed lines
+- Emoji work in `<text>` elements on most renderers
+- Test complex SVGs in a browser before converting

package/skills/weather/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: weather
+description: Get current weather and forecasts using wttr.in (no API key required).
+---
+
+# Weather
+
+Get weather information for any location using the free wttr.in service.
+
+## Quick Commands
+
+```bash
+# Current weather for a city
+curl -s "wttr.in/Toronto?format=3"
+# Output: Toronto: ⛅️ +5°C
+
+# Detailed forecast (3 days)
+curl -s "wttr.in/Toronto"
+
+# One-line format with custom fields
+curl -s "wttr.in/Toronto?format=%l:+%c+%t+%h+%w"
+# Output: Toronto: ⛅️ +5°C 65% →15km/h
+
+# JSON format for parsing
+curl -s "wttr.in/Toronto?format=j1"
+
+# Specific day (0=today, 1=tomorrow, 2=day after)
+curl -s "wttr.in/Toronto?1"
+```
+
+## Format Codes
+
+| Code | Meaning |
+|------|---------|
+| `%c` | Weather condition icon |
+| `%C` | Weather condition text |
+| `%t` | Temperature |
+| `%f` | Feels like |
+| `%h` | Humidity |
+| `%w` | Wind |
+| `%p` | Precipitation (mm) |
+| `%P` | Pressure |
+| `%D` | Dawn |
+| `%S` | Sunrise |
+| `%s` | Sunset |
+| `%l` | Location |
+
+## Usage Patterns
+
+**Morning briefing:** `curl -s "wttr.in/{city}?format=%c+%t+feels+like+%f,+%C"`
+
+**Should I bring an umbrella?** Check precipitation:
+```bash
+curl -s "wttr.in/{city}?format=j1" | python3 -c "
+import json,sys; d=json.load(sys.stdin)
+rain=float(d['weather'][0]['hourly'][4].get('precipMM','0'))
+print('☔ Yes, rain expected' if rain>0.5 else '☀️ No rain expected')
+"
+```
+
+**Multi-city comparison:**
+```bash
+for city in Toronto NYC London; do
+  echo "$(curl -s "wttr.in/$city?format=3")"
+done
+```
+
+## Notes
+- No API key needed
+- Rate limited — don't hit it more than a few times per minute
+- Supports airports (ICAO codes), landmarks, IP-based geolocation
+- Add `?lang=fr` for other languages

package/skills/workspace-manager/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: workspace-manager
+description: Workspace setup and organization assistant.
+---
+
+# Workspace Manager
+
+Help users create and maintain well-organized workspaces.
+
+## Workspace Structure Templates
+
+### Engineering
+```
+infrastructure/    # Cloud & infra docs
+devops/            # CI/CD, pipelines
+architecture/      # ADRs, system designs
+security/          # Audits, compliance
+team/              # Processes, hiring
+daily-notes/       # Daily logs
+```
+
+### Business
+```
+clients/           # Per-client folders
+projects/          # Active projects
+meetings/          # Notes & agendas
+strategy/          # Plans, OKRs
+templates/         # Reusable docs
+archive/           # Completed work
+```
+
+### Personal Knowledge
+```
+areas/             # Life areas (health, finance, career)
+projects/          # Active projects
+resources/         # Reference material
+archive/           # Done projects
+inbox/             # Unsorted notes
+```
+
+## File Naming Conventions
+- Dates: `YYYY-MM-DD` prefix for time-sensitive files
+- Projects: `project-name-description.md`
+- No spaces: use hyphens (`my-document.md`)
+- Lowercase everything
+
+## Organization Principles
+1. **Flat over deep** — Max 3 levels of nesting
+2. **Action-oriented** — Name folders by what you DO, not what things ARE
+3. **Archive aggressively** — Done projects → archive/
+4. **One inbox** — Single capture point, sort regularly
+5. **README in every folder** — What's this folder for? What goes here?
+
+## Maintenance Tasks
+- Weekly: Process inbox, archive completed projects
+- Monthly: Review folder structure, clean unused files
+- Quarterly: Major reorganization if needed
+
+## Quick Commands
+```bash
+# Find large files
+find . -type f -size +10M | head -20
+
+# Find recently modified
+find . -type f -mtime -7 -name "*.md" | head -20
+
+# Count files per directory
+find . -maxdepth 2 -type f | cut -d/ -f2 | sort | uniq -c | sort -rn
+```

package/src/cron.mjs

@@ -0,0 +1,30 @@
+import { execSync } from 'child_process';
+import { log, cmdExists } from './utils.mjs';
+
+export function registerCron(workspace) {
+  if (process.platform === 'win32') {
+    log.warn('Cron not available on Windows — set up nightly consolidation manually');
+    return false;
+  }
+
+  const scriptPath = `${workspace}/scripts/nightly-consolidation.sh`;
+  const cronLine = `0 2 * * * CLAMPER_WORKSPACE="${workspace}" bash "${scriptPath}" >> "${workspace}/scripts/consolidation.log" 2>&1`;
+
+  try {
+    let existing = '';
+    try { existing = execSync('crontab -l 2>/dev/null', { encoding: 'utf8' }); } catch { /* empty crontab */ }
+
+    if (existing.includes('nightly-consolidation.sh')) {
+      log.info('Nightly consolidation cron already registered');
+      return true;
+    }
+
+    const updated = existing.trimEnd() + '\n' + cronLine + '\n';
+    execSync(`echo "${updated.replace(/"/g, '\\"')}" | crontab -`, { encoding: 'utf8' });
+    log.ok('Registered nightly consolidation cron (2 AM daily)');
+    return true;
+  } catch (e) {
+    log.warn('Could not register cron job — set up nightly consolidation manually');
+    return false;
+  }
+}

package/src/dashboard.mjs

@@ -0,0 +1,69 @@
+import { createServer } from 'http';
+import { readFileSync, existsSync } from 'fs';
+import { join, extname } from 'path';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import { c, log } from './utils.mjs';
+
+const MIME = {
+  '.html': 'text/html',
+  '.css': 'text/css',
+  '.js': 'application/javascript',
+  '.json': 'application/json',
+  '.png': 'image/png',
+  '.svg': 'image/svg+xml',
+};
+
+export function runDashboard(flags) {
+  const port = parseInt(flags.port) || 8080;
+  const thisDir = fileURLToPath(new URL('.', import.meta.url));
+  const dashDir = join(thisDir, '..', 'dashboard');
+
+  if (!existsSync(join(dashDir, 'index.html'))) {
+    log.err('Dashboard files not found. Reinstall Clamper.');
+    process.exit(1);
+  }
+
+  const server = createServer((req, res) => {
+    let filePath = req.url === '/' ? '/index.html' : req.url;
+    filePath = filePath.split('?')[0]; // strip query
+    const full = join(dashDir, filePath);
+
+    if (!existsSync(full)) {
+      res.writeHead(404, { 'Content-Type': 'text/plain' });
+      res.end('Not found');
+      return;
+    }
+
+    const ext = extname(full);
+    const mime = MIME[ext] || 'application/octet-stream';
+    try {
+      const data = readFileSync(full);
+      res.writeHead(200, { 'Content-Type': mime });
+      res.end(data);
+    } catch {
+      res.writeHead(500);
+      res.end('Error');
+    }
+  });
+
+  server.listen(port, '0.0.0.0', () => {
+    const url = `http://localhost:${port}`;
+    console.log(`\n  ${c.green}⚡${c.reset} Dashboard running at ${c.cyan}${url}${c.reset}\n`);
+    console.log(`  ${c.dim}Press Ctrl+C to stop${c.reset}\n`);
+
+    // Open browser (non-blocking — execSync blocks the event loop!)
+    try {
+      const { exec: execNB } = require !== undefined ? require('child_process') : {};
+      const platform = process.platform;
+      const cmd = platform === 'darwin' ? `open ${url}` : platform === 'win32' ? `start ${url}` : `xdg-open ${url} 2>/dev/null || true`;
+      import('child_process').then(cp => cp.exec(cmd));
+    } catch {}
+  });
+
+  process.on('SIGINT', () => {
+    console.log(`\n  ${c.dim}Shutting down...${c.reset}`);
+    server.close();
+    process.exit(0);
+  });
+}

package/src/doctor.mjs

@@ -0,0 +1,69 @@
+import { existsSync, readFileSync, readdirSync, accessSync, constants } from 'fs';
+import { join } from 'path';
+import { c, log, detectWorkspace, cmdExists } from './utils.mjs';
+
+export function runDoctor() {
+  const checks = [];
+  const pass = (name) => checks.push({ name, ok: true });
+  const fail = (name, hint) => checks.push({ name, ok: false, hint });
+
+  // 1. OpenClaw installed
+  cmdExists('openclaw') ? pass('OpenClaw CLI installed') : fail('OpenClaw CLI installed', 'Install: npm i -g openclaw');
+
+  // 2. Workspace
+  const workspace = detectWorkspace();
+  if (workspace && existsSync(workspace)) {
+    pass('Workspace directory exists');
+  } else {
+    fail('Workspace directory exists', 'Set CLAMPER_WORKSPACE env var');
+  }
+
+  if (workspace) {
+    // 3. AGENTS.md
+    existsSync(join(workspace, 'AGENTS.md')) ? pass('AGENTS.md present') : fail('AGENTS.md present', 'Run: clamper init');
+
+    // 4. Config
+    const cfgPath = join(workspace, 'skills', '.clamper', 'config.json');
+    if (existsSync(cfgPath)) {
+      try { JSON.parse(readFileSync(cfgPath, 'utf8')); pass('Config valid'); }
+      catch { fail('Config valid', 'config.json is corrupt — re-run clamper init'); }
+    } else {
+      fail('Config valid', 'Run: clamper init');
+    }
+
+    // 5. Skills
+    const sd = join(workspace, 'skills');
+    if (existsSync(sd)) {
+      const cnt = readdirSync(sd, { withFileTypes: true }).filter(d => d.isDirectory() && !d.name.startsWith('.')).length;
+      cnt > 0 ? pass(`Skills installed (${cnt})`) : fail('Skills installed', 'Run: clamper init');
+    } else {
+      fail('Skills installed', 'Run: clamper init');
+    }
+
+    // 6. Consolidation script
+    const cs = join(workspace, 'scripts/nightly-consolidation.sh');
+    if (existsSync(cs)) {
+      try { accessSync(cs, constants.X_OK); pass('Consolidation script executable'); }
+      catch { fail('Consolidation script executable', `Run: chmod +x ${cs}`); }
+    } else {
+      fail('Consolidation script present', 'Run: clamper init');
+    }
+
+    // 7. Memory dirs
+    existsSync(join(workspace, 'memory/daily')) && existsSync(join(workspace, 'memory/knowledge'))
+      ? pass('Memory directories') : fail('Memory directories', 'Run: clamper init');
+  }
+
+  // 5. API key
+  process.env.CLAMPER_API_KEY ? pass('API key set') : fail('API key set', 'Set CLAMPER_API_KEY env var');
+
+  console.log(`\n${c.bold}${c.cyan}🩺 Clamper Doctor${c.reset}\n`);
+  for (const ch of checks) {
+    const icon = ch.ok ? `${c.green}✔${c.reset}` : `${c.red}✖${c.reset}`;
+    console.log(`  ${icon} ${ch.name}`);
+    if (!ch.ok && ch.hint) console.log(`    ${c.dim}→ ${ch.hint}${c.reset}`);
+  }
+
+  const passed = checks.filter(c => c.ok).length;
+  console.log(`\n  ${passed}/${checks.length} checks passed\n`);
+}

package/src/init.mjs

@@ -0,0 +1,145 @@
+import { createInterface } from 'readline';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { c, log, detectWorkspace, detectTimezone, today } from './utils.mjs';
+import { readApiKey, parseTier, validateKey } from './validate.mjs';
+import { scaffoldWorkspace, backupWorkspace } from './scaffold.mjs';
+import { installSkills } from './skills.mjs';
+
+function ask(rl, question, defaultVal) {
+  return new Promise((resolve) => {
+    rl.question(`${c.cyan}?${c.reset} ${question} ${c.dim}(${defaultVal})${c.reset} `, (answer) => {
+      resolve(answer.trim() || defaultVal);
+    });
+  });
+}
+
+export async function runInit(flags) {
+  const yes = flags.yes || flags.y;
+  const force = flags.force;
+
+  console.log(`\n${c.bold}${c.magenta}🧰 Clamper Init${c.reset}\n`);
+
+  // Step 1: Detect workspace
+  log.step(1, 'Detecting workspace...');
+  let workspace = detectWorkspace();
+
+  const rl = !yes ? createInterface({ input: process.stdin, output: process.stdout }) : null;
+
+  if (!workspace && !yes) {
+    workspace = await ask(rl, 'Workspace path:', join(process.env.HOME || '~', '.openclaw', 'workspace'));
+  }
+  if (!workspace) {
+    workspace = join(process.env.HOME || '/tmp', '.openclaw', 'workspace');
+  }
+  mkdirSync(workspace, { recursive: true });
+  log.ok(`Workspace: ${workspace}`);
+
+  // Step 2: Check existing
+  log.step(2, 'Checking existing files...');
+  if (existsSync(join(workspace, 'AGENTS.md'))) {
+    if (!yes && !force) {
+      const overwrite = await ask(rl, 'Existing workspace detected. Backup & overwrite? (y/n):', 'y');
+      if (overwrite.toLowerCase() !== 'y') {
+        log.info('Aborted.');
+        rl?.close();
+        return;
+      }
+    }
+    const bk = backupWorkspace(workspace);
+    log.ok(`Backed up to ${bk}`);
+  } else {
+    log.ok('Clean workspace');
+  }
+
+  // Step 3: Read API key
+  log.step(3, 'Reading API key...');
+  let apiKey = readApiKey();
+  if (!apiKey) {
+    console.log(`\n  ${c.yellow}An API key is required to use Clamper.${c.reset}`);
+    console.log(`  ${c.dim}Get your free key at: ${c.cyan}https://clamper.tech/get-started${c.reset}\n`);
+    if (!yes) {
+      apiKey = await ask(rl, 'Paste your Clamper API key:', '');
+    }
+    if (!apiKey) {
+      console.log(`\n  ${c.yellow}No API key provided. Continuing with limited free tier.${c.reset}`);
+      console.log(`  ${c.dim}Run ${c.cyan}clamper upgrade --key YOUR_KEY${c.reset}${c.dim} later to activate.${c.reset}\n`);
+    }
+  }
+  const tier = parseTier(apiKey);
+  if (apiKey) {
+    log.ok(`API key found (tier: ${tier})`);
+  } else {
+    log.warn('No API key — limited free tier');
+  }
+
+  // Step 4: Validate
+  log.step(4, 'Validating...');
+  const validation = await validateKey(apiKey);
+  if (!validation.valid && !validation.offline) {
+    log.err(`Validation failed: ${validation.error}`);
+    log.info('Continuing with free tier...');
+  } else if (validation.offline) {
+    log.warn('Offline mode — continuing with key prefix tier');
+  } else {
+    log.ok('API key validated');
+  }
+
+  const effectiveTier = validation.tier || tier;
+
+  // Step 5: Prompts
+  log.step(5, 'Configuration...');
+  const agentName = yes ? 'Atlas' : await ask(rl, 'What should your agent be called?', 'Atlas');
+  const userName = yes ? 'Human' : await ask(rl, "What's your name?", 'Human');
+  const timezone = yes ? detectTimezone() : await ask(rl, 'Your timezone?', detectTimezone());
+
+  rl?.close();
+
+  const vars = { agentName, userName, timezone, tier: effectiveTier, date: today() };
+
+  // Step 6: Scaffold
+  log.step(6, 'Scaffolding workspace...');
+  scaffoldWorkspace(workspace, vars);
+  log.ok('Template files written');
+
+  // Step 7: Skills
+  log.step(7, 'Installing skills...');
+  const skillCount = installSkills(workspace, effectiveTier);
+
+  // Step 8: Config
+  log.step(8, 'Writing config...');
+  const configDir = join(workspace, 'skills', '.clamper');
+  mkdirSync(configDir, { recursive: true });
+  const config = {
+    version: '1.0.0',
+    tier: effectiveTier,
+    apiKey: apiKey || '',
+    installedAt: new Date().toISOString(),
+    agentName,
+    userName,
+    timezone,
+    features: validation.features || {},
+  };
+  writeFileSync(join(configDir, 'config.json'), JSON.stringify(config, null, 2), 'utf8');
+  log.ok('Config saved');
+
+  // Step 9: Success
+  console.log(`
+${c.green}╔══════════════════════════════════════════════╗
+║  🧰 Clamper initialized successfully!       ║
+╠══════════════════════════════════════════════╣
+║                                              ║
+║  Agent: ${(agentName + '                    ').slice(0, 36)}║
+║  Tier: ${(effectiveTier + '                     ').slice(0, 37)}║
+║  Skills: ${(skillCount + ' installed              ').slice(0, 35)}║
+║  Memory: 3-layer system active               ║
+║                                              ║
+║  Next steps:                                 ║
+║  1. openclaw gateway restart                 ║
+║  2. Start chatting — your agent is ready!    ║
+║                                              ║
+║  Run clamper status to check health          ║
+║  Run clamper upgrade to go Pro               ║
+╚══════════════════════════════════════════════╝${c.reset}
+`);
+}

package/src/log-activity.mjs

@@ -0,0 +1,26 @@
+import { existsSync, appendFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { detectWorkspace } from './utils.mjs';
+
+export function logActivity(message) {
+  const workspace = detectWorkspace();
+  if (!workspace) return;
+
+  const logPath = join(workspace, 'logs', 'activity.jsonl');
+  const logDir = dirname(logPath);
+  if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true });
+
+  const entry = JSON.stringify({ ts: new Date().toISOString(), msg: message }) + '\n';
+  appendFileSync(logPath, entry);
+}
+
+// CLI usage: clamper log "Did something"
+export function runLog(flags) {
+  const msg = flags._ || process.argv.slice(3).join(' ');
+  if (!msg) {
+    console.log('Usage: clamper log "Your activity message"');
+    process.exit(1);
+  }
+  logActivity(msg);
+  console.log(`  ✔ Logged: ${msg}`);
+}

package/src/scaffold.mjs

@@ -0,0 +1,57 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, cpSync, chmodSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = join(__dirname, '..');
+
+export function replaceVars(text, vars) {
+  return text
+    .replace(/\{\{AGENT_NAME\}\}/g, vars.agentName || 'Atlas')
+    .replace(/\{\{USER_NAME\}\}/g, vars.userName || 'Human')
+    .replace(/\{\{TIMEZONE\}\}/g, vars.timezone || 'UTC')
+    .replace(/\{\{TIER\}\}/g, vars.tier || 'free')
+    .replace(/\{\{DATE\}\}/g, vars.date || new Date().toISOString().slice(0, 10));
+}
+
+const TEMPLATE_FILES = [
+  'AGENTS.md', 'SOUL.md', 'IDENTITY.md', 'USER.md', 'TOOLS.md', 'HEARTBEAT.md',
+  'MEMORY.md', 'LEARNINGS.md', 'PROTOCOL_COST_EFFICIENCY.md', 'SKILLS-INDEX.md',
+  'memory/knowledge/about-me.md', 'tasks/QUEUE.md', 'scripts/nightly-consolidation.sh',
+];
+
+export function scaffoldWorkspace(workspace, vars) {
+  for (const d of ['memory/daily', 'memory/knowledge', 'memory/para', 'tasks', 'scripts', 'skills']) {
+    mkdirSync(join(workspace, d), { recursive: true });
+  }
+
+  for (const f of TEMPLATE_FILES) {
+    const src = join(PKG_ROOT, 'templates', f);
+    const dest = join(workspace, f);
+    mkdirSync(dirname(dest), { recursive: true });
+    const content = readFileSync(src, 'utf8');
+    writeFileSync(dest, replaceVars(content, vars), 'utf8');
+  }
+
+  // Make consolidation script executable
+  const scriptPath = join(workspace, 'scripts/nightly-consolidation.sh');
+  if (existsSync(scriptPath)) {
+    chmodSync(scriptPath, 0o755);
+  }
+}
+
+export function backupWorkspace(workspace) {
+  const backupDir = join(workspace, '.clamper-backup');
+  const ts = new Date().toISOString().replace(/[:.]/g, '-');
+  const dest = join(backupDir, ts);
+  mkdirSync(dest, { recursive: true });
+  for (const f of TEMPLATE_FILES) {
+    const src = join(workspace, f);
+    if (existsSync(src)) {
+      const d = join(dest, f);
+      mkdirSync(dirname(d), { recursive: true });
+      cpSync(src, d);
+    }
+  }
+  return dest;
+}

package/src/skills.mjs

@@ -0,0 +1,52 @@
+import { readdirSync, readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+import { log, cmdExists } from './utils.mjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = join(__dirname, '..');
+const BUNDLED_DIR = join(PKG_ROOT, 'skills');
+
+const PRO_SKILLS = [
+  'reminder', 'data-analyst', 'automation-workflows', 'sales',
+  'security-monitor', 'nano-pdf', 'pdf-to-structured',
+];
+
+export function installSkills(workspace, tier) {
+  const skillsDir = join(workspace, 'skills');
+  mkdirSync(skillsDir, { recursive: true });
+
+  // Install bundled free skills
+  let count = 0;
+  const entries = readdirSync(BUNDLED_DIR, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const srcSkill = join(BUNDLED_DIR, entry.name, 'SKILL.md');
+    if (!existsSync(srcSkill)) continue;
+    const destDir = join(skillsDir, entry.name);
+    mkdirSync(destDir, { recursive: true });
+    const content = readFileSync(srcSkill, 'utf8');
+    writeFileSync(join(destDir, 'SKILL.md'), content, 'utf8');
+    count++;
+  }
+  log.ok(`Installed ${count} free-tier skills`);
+
+  // Pro skills via clawhub
+  if (tier === 'pro') {
+    if (cmdExists('clawhub')) {
+      for (const slug of PRO_SKILLS) {
+        try {
+          execSync(`clawhub install ${slug} --force`, { cwd: workspace, stdio: 'ignore', timeout: 30000 });
+          log.ok(`Installed pro skill: ${slug}`);
+        } catch {
+          log.warn(`Could not install pro skill: ${slug}`);
+        }
+      }
+    } else {
+      log.warn('clawhub CLI not found — skipping pro skill installation. Run: npm i -g clawhub');
+    }
+  }
+
+  return count;
+}