@polderlabs/bizar 2.3.0

package/cli/export.mjs

@@ -0,0 +1,87 @@
+import chalk from 'chalk';
+import { existsSync, readFileSync, readdirSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const HOME = process.env.HOME || '/home/drb0rk';
+const CONFIG_DIR = process.env.XDG_CONFIG_HOME
+  ? join(process.env.XDG_CONFIG_HOME, 'opencode')
+  : join(HOME, '.config/opencode');
+
+export async function runExport(target) {
+  const validTargets = ['claude', 'cursor', 'opencode'];
+  if (target && !validTargets.includes(target)) {
+    console.log(chalk.red(`  Unknown target "${target}". Valid: ${validTargets.join(', ')}`));
+    return;
+  }
+
+  const targets = target ? [target] : validTargets;
+
+  for (const t of targets) {
+    console.log(chalk.bold.hex('#6366f1')(`\n  Exporting to ${t}...\n`));
+    await exportTo(t);
+  }
+}
+
+async function exportTo(target) {
+  const agentFiles = readdirSync(join(CONFIG_DIR, 'agents')).filter(f => f.endsWith('.md'));
+
+  switch (target) {
+    case 'claude': {
+      const claudeDir = join(HOME, '.claude');
+      mkdirSync(claudeDir, { recursive: true });
+
+      // Copy agents to .claude/agents/
+      const claudeAgentDir = join(claudeDir, 'agents');
+      mkdirSync(claudeAgentDir, { recursive: true });
+      for (const file of agentFiles) {
+        const content = readFileSync(join(CONFIG_DIR, 'agents', file), 'utf-8');
+        writeFileSync(join(claudeAgentDir, file), content);
+      }
+      console.log(chalk.green(`  ✓ ${agentFiles.length} agents → ${claudeAgentDir}`));
+
+      // Copy rules
+      const rulesDir = join(CONFIG_DIR, 'rules');
+      if (existsSync(rulesDir)) {
+        const claudeRulesDir = join(claudeDir, 'rules');
+        mkdirSync(claudeRulesDir, { recursive: true });
+        const rules = readdirSync(rulesDir).filter(f => f.endsWith('.md'));
+        for (const file of rules) {
+          const content = readFileSync(join(rulesDir, file), 'utf-8');
+          writeFileSync(join(claudeRulesDir, file), content);
+        }
+        console.log(chalk.green(`  ✓ ${rules.length} rules → ${claudeRulesDir}`));
+      }
+
+      break;
+    }
+
+    case 'cursor': {
+      const cursorDir = join(HOME, '.cursor');
+
+      // Convert agents to .cursor/rules/ format
+      const cursorRulesDir = join(cursorDir, 'rules');
+      mkdirSync(cursorRulesDir, { recursive: true });
+
+      for (const file of agentFiles) {
+        const content = readFileSync(join(CONFIG_DIR, 'agents', file), 'utf-8');
+        // Cursor uses YAML frontmatter .mdc files
+        const name = file.replace('.md', '');
+        const cursorContent = `---
+description: ${name} agent from BizarHarness
+globs: **/*
+---
+${content}
+`;
+        writeFileSync(join(cursorRulesDir, `${name}.mdc`), cursorContent);
+      }
+      console.log(chalk.green(`  ✓ ${agentFiles.length} agents → ${cursorRulesDir} (as .mdc rules)`));
+
+      break;
+    }
+
+    case 'opencode': {
+      console.log(chalk.dim('  Already configured for opencode. Run `bizar` for interactive setup.'));
+      break;
+    }
+  }
+}

package/cli/init.mjs

@@ -0,0 +1,147 @@
+import chalk from 'chalk';
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+
+function detectStack(cwd) {
+  const stack = { language: null, framework: null, database: null, tools: [], build: null, test: null, runner: null };
+
+  // Language detection
+  if (existsSync(join(cwd, 'package.json'))) {
+    stack.language = 'JavaScript/TypeScript';
+    try {
+      const pkg = JSON.parse(readFileSync(join(cwd, 'package.json'), 'utf-8'));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (deps.next) stack.framework = 'Next.js';
+      else if (deps.react) stack.framework = 'React';
+      else if (deps.vue) stack.framework = 'Vue';
+      else if (deps.express) stack.framework = 'Express';
+      else if (deps.nest) stack.framework = 'NestJS';
+      if (deps.prisma) stack.database = 'PostgreSQL (Prisma)';
+      else if (deps['@prisma/client']) stack.database = 'PostgreSQL (Prisma)';
+      else if (deps.drizzle) stack.database = 'PostgreSQL (Drizzle)';
+      else if (deps.typeorm) stack.database = 'PostgreSQL (TypeORM)';
+      if (pkg.scripts) {
+        if (pkg.scripts.test) stack.test = pkg.scripts.test;
+        if (pkg.scripts.build) stack.build = pkg.scripts.build;
+        if (pkg.scripts.dev) stack.runner = pkg.scripts.dev;
+      }
+      if (existsSync(join(cwd, 'tsconfig.json'))) stack.language = 'TypeScript';
+    } catch { /* ignore parse errors */ }
+  }
+
+  if (existsSync(join(cwd, 'pyproject.toml'))) {
+    stack.language = 'Python';
+    const content = readFileSync(join(cwd, 'pyproject.toml'), 'utf-8');
+    if (content.includes('django')) stack.framework = 'Django';
+    else if (content.includes('fastapi') || content.includes('fastapi')) stack.framework = 'FastAPI';
+    else if (content.includes('flask')) stack.framework = 'Flask';
+  }
+
+  if (existsSync(join(cwd, 'Cargo.toml'))) {
+    stack.language = 'Rust';
+  }
+
+  if (existsSync(join(cwd, 'go.mod'))) {
+    stack.language = 'Go';
+  }
+
+  // Tool detection
+  if (existsSync(join(cwd, '.github/workflows'))) stack.tools.push('GitHub Actions');
+  if (existsSync(join(cwd, 'Dockerfile'))) stack.tools.push('Docker');
+  if (existsSync(join(cwd, 'docker-compose.yml')) || existsSync(join(cwd, 'docker-compose.yaml'))) stack.tools.push('Docker Compose');
+  if (existsSync(join(cwd, '.nvmrc'))) stack.tools.push('nvm');
+
+  return stack;
+}
+
+export async function runInit(cwd) {
+  console.log(chalk.bold.hex('#10b981')('\n  ᛗ BIZARHARNESS INIT ᛗ\n'));
+
+  const bizarDir = join(cwd, '.bizar');
+  mkdirSync(bizarDir, { recursive: true });
+
+  // Detect stack
+  console.log(chalk.dim('  Detecting project stack...'));
+  const stack = detectStack(cwd);
+  console.log(`  Language:  ${stack.language || chalk.yellow('unknown')}`);
+  console.log(`  Framework: ${stack.framework || chalk.yellow('none detected')}`);
+  console.log(`  Database:  ${stack.database || chalk.yellow('none detected')}`);
+  if (stack.tools.length > 0) console.log(`  Tools:     ${stack.tools.join(', ')}`);
+  console.log();
+
+  // Install relevant skills via Skills CLI
+  console.log(chalk.dim('  Installing relevant skills...'));
+  const skillRepos = [];
+  if (stack.language?.toLowerCase().includes('typescript') || stack.framework?.toLowerCase().includes('next') || stack.framework?.toLowerCase().includes('react')) {
+    skillRepos.push('skills add vercel-labs/agent-skills --all -y');
+    skillRepos.push('skills add shadcn/ui --all -y');
+  }
+  if (stack.framework?.toLowerCase().includes('django') || stack.framework?.toLowerCase().includes('fastapi') || stack.framework?.toLowerCase().includes('flask')) {
+    skillRepos.push('skills add supabase/agent-skills --all -y');
+  }
+  if (stack.language?.toLowerCase().includes('python')) {
+    skillRepos.push('skills add mattpocock/skills -y');
+  }
+  if (stack.language?.toLowerCase().includes('rust')) {
+    skillRepos.push('skills add supabase/agent-skills --all -y');
+  }
+
+  for (const cmd of skillRepos) {
+    try {
+      execSync(cmd, { stdio: 'pipe', timeout: 30000 });
+      console.log(chalk.green(`  ✓ ${cmd}`));
+    } catch {
+      console.log(chalk.dim(`  - ${cmd} (skipped)`));
+    }
+  }
+  console.log();
+
+  // Generate PROJECT.md
+  const projectName = cwd.split('/').pop() || 'my-project';
+  const projectMd = `# ${projectName}
+
+${stack.framework ? `${stack.framework} ` : ''}${stack.language || ''} project.
+
+## Stack
+- Language: ${stack.language || 'unknown'}
+${stack.framework ? `- Framework: ${stack.framework}` : ''}
+${stack.database ? `- Database: ${stack.database}` : ''}
+${stack.tools.length > 0 ? `- Tools: ${stack.tools.join(', ')}` : ''}
+${stack.build ? `- Build: \`${stack.build}\`` : ''}
+${stack.test ? `- Test: \`${stack.test}\`` : ''}
+${stack.runner ? `- Dev: \`${stack.runner}\`` : ''}
+
+## Conventions
+- Follow BizarHarness Always-On Rules (see \`rules/\`)
+- Use TDD for all new features
+- Conventional commits
+
+## Entry Points
+- \`${stack.runner || 'npm run dev'}\` — development
+- \`${stack.test || 'npm test'}\` — testing
+- \`${stack.build || 'npm run build'}\` — build
+`;
+
+  const projPath = join(bizarDir, 'PROJECT.md');
+  writeFileSync(projPath, projectMd);
+  console.log(chalk.green(`  ✓ Created ${projPath}`));
+
+  // Generate AGENTS_SELF_IMPROVEMENT.md if not exists
+  const siPath = join(bizarDir, 'AGENTS_SELF_IMPROVEMENT.md');
+  if (!existsSync(siPath)) {
+    writeFileSync(siPath, `# Agents Self-Improvement Log
+
+## Active Rules
+- Use BizarHarness Always-On Rules
+- Cost-aware routing: prefer cheapest capable agent
+- Always split implementation across 2+ parallel agents
+
+## Entries
+`);
+    console.log(chalk.green(`  ✓ Created ${siPath}`));
+  }
+
+  console.log(chalk.dim('\n  Project initialized. Run `@frigg` to ask questions about the codebase.\n'));
+  return true;
+}

package/cli/install.mjs

@@ -0,0 +1,390 @@
+import chalk from 'chalk';
+import boxen from 'boxen';
+import { existsSync } from 'node:fs';
+
+import { showBanner, showPantheon, sectionHeading } from './banner.mjs';
+import { promptComponents, promptInstallMode, promptAgents, promptSkillPacks, promptApiKeys, promptConfirmInstall, promptRestartOpenCode } from './prompts.mjs';
+import { detectOpenCode, detectRtk, detectSemble, detectSkillsCli, buildSummary, opencodeAgentsDir, opencodeConfigDir, repoPath } from './utils.mjs';
+import { installAgents, installAgentsMd, installSkill, installOpencodeJson, installBizarFolder, installPluginBizar, installRtk, installSemble, installSkillsCli, installCuratedSkills, installRules, installHooks, installCommands, mergeToolsIntoUserConfig } from './copy.mjs';
+
+const AGENT_FILES = [
+  'odin.md', 'vor.md', 'frigg.md', 'quick.md',
+  'mimir.md', 'heimdall.md', 'hermod.md', 'thor.md', 'baldr.md',
+  'tyr.md', 'vidarr.md', 'forseti.md',
+  'semble-search.md',
+];
+
+/**
+ * Install the Bizar opencode plugin from the separate global npm package
+ * `@polderlabs/bizar-plugin`. The main `@polderlabs/bizar` package
+ * no longer ships `plugins/bizar/` — the plugin lives in its own scoped package
+ * so it can be versioned and published independently.
+ *
+ * If the plugin package is globally installed, copies its contents into
+ * `~/.config/opencode/plugins/bizar/` (or the platform-equivalent path via
+ * `opencodeConfigDir()`). Otherwise, prints a hint directing the user to run
+ * `npm install -g @polderlabs/bizar-plugin`.
+ *
+ * Returns `true` if the plugin was installed, `false` otherwise. Never throws.
+ */
+export async function installPluginFromGlobal() {
+  const { execSync } = await import('node:child_process');
+  const { mkdir, readdir, copyFile } = await import('node:fs/promises');
+  const { join } = await import('node:path');
+
+  let globalRoot;
+  try {
+    globalRoot = execSync('npm root -g', { stdio: ['ignore', 'pipe', 'ignore'] })
+      .toString()
+      .trim();
+  } catch {
+    console.log(chalk.yellow('  ⚠ Could not determine npm global root — skipping plugin install'));
+    return false;
+  }
+
+  const pluginPath = join(globalRoot, '@polderlabs', 'bizar-plugin');
+  if (!existsSync(pluginPath)) {
+    console.log(chalk.dim('  ℹ Bizar plugin not installed globally. To install it:'));
+    console.log(chalk.dim('    npm install -g @polderlabs/bizar-plugin'));
+    return false;
+  }
+
+  const destDir = join(opencodeConfigDir(), 'plugins', 'bizar');
+  await mkdir(destDir, { recursive: true });
+
+  async function copyRecursive(srcDir, dstDir) {
+    const entries = await readdir(srcDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const src = join(srcDir, entry.name);
+      const dst = join(dstDir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === 'node_modules' || entry.name === 'dist') continue;
+        await mkdir(dst, { recursive: true });
+        await copyRecursive(src, dst);
+      } else {
+        if (entry.name === '.DS_Store' || entry.name.endsWith('.log')) continue;
+        await copyFile(src, dst);
+      }
+    }
+  }
+
+  try {
+    await copyRecursive(pluginPath, destDir);
+    console.log(chalk.green(`  ✓ Bizar plugin installed from global package`));
+    console.log(chalk.dim(`    ${pluginPath} → ${destDir}`));
+    return true;
+  } catch (err) {
+    console.log(chalk.yellow(`  ⚠ Failed to copy Bizar plugin: ${err.message}`));
+    return false;
+  }
+}
+
+export async function runInstaller() {
+  showBanner();
+
+  // ── Detect opencode ──
+  sectionHeading('Pre-flight');
+  const env = await detectOpenCode();
+
+  if (!env.exists) {
+    console.log(chalk.yellow('  ⚠ opencode config directory not found.'));
+    console.log(chalk.dim('  The installer will create it at:'));
+    console.log(chalk.dim(`  ${env.configDir}`));
+  } else {
+    console.log(chalk.green(`  ✓ opencode detected at ${env.configDir}`));
+    if (env.version) console.log(chalk.dim(`    version ${env.version}`));
+  }
+
+  const rtkInstalled = await detectRtk();
+  if (rtkInstalled) {
+    console.log(chalk.green('  ✓ RTK detected (token optimizer)'));
+  } else {
+    console.log(chalk.yellow('  ○ RTK not detected — will install'));
+  }
+
+  const sembleInstalled = await detectSemble();
+  if (sembleInstalled) {
+    console.log(chalk.green('  ✓ Semble detected (code search)'));
+  } else {
+    console.log(chalk.yellow('  ○ Semble not detected — will install'));
+  }
+
+  const skillsCliInstalled = await detectSkillsCli();
+  if (skillsCliInstalled) {
+    console.log(chalk.green('  ✓ Skills CLI detected (skill discovery)'));
+  } else {
+    console.log(chalk.yellow('  ○ Skills CLI not detected — will install'));
+  }
+  console.log();
+
+  // ── Step 1: Component selection ──
+  sectionHeading('Component Selection');
+  const components = await promptComponents();
+
+  // ── Step 2: Agent selection (if agents component chosen) ──
+  let selectedAgents = [];
+  if (components.includes('agents')) {
+    sectionHeading('Agent Selection');
+    selectedAgents = await promptAgents();
+  }
+
+  // ── Step 3: Install mode ──
+  sectionHeading('Installation Mode');
+  const mode = await promptInstallMode();
+
+  // ── Step 4: Skill packs (via skills.sh) ──
+  sectionHeading('Skills from skills.sh');
+  const skillPacks = await promptSkillPacks();
+
+  // ── Step 5: Build summary & confirm ──
+  const summary = buildSummary(components, selectedAgents, env.configDir, skillPacks);
+  showPantheon();
+  console.log();
+  console.log(chalk.dim('  Summary:'));
+  console.log(chalk.dim(`  Components : ${summary.components}`));
+  console.log(chalk.dim(`  Agents     : ${summary.agents}`));
+  console.log(chalk.dim(`  Target     : ${summary.target}`));
+  console.log(chalk.dim(`  Mode       : ${mode}`));
+  console.log();
+
+  const confirmed = await promptConfirmInstall(summary);
+  if (!confirmed) {
+    console.log(chalk.yellow('\n  Installation cancelled.\n'));
+    process.exit(0);
+  }
+
+  // ── Step 5: Install ──
+  console.log();
+  sectionHeading('Installing');
+
+  if (components.includes('agents') && selectedAgents.length > 0) {
+    await installAgents(selectedAgents, mode);
+  }
+
+  if (components.includes('agents-md')) {
+    await installAgentsMd(mode);
+  }
+
+  if (components.includes('skill-bizar')) {
+    await installSkill('bizar');
+  }
+
+  if (components.includes('skill-improve')) {
+    await installSkill('self-improvement');
+  }
+
+  if (components.includes('skill-cpp-std')) {
+    await installSkill('cpp-coding-standards');
+  }
+
+  if (components.includes('skill-cpp-test')) {
+    await installSkill('cpp-testing');
+  }
+
+  if (components.includes('skill-esp-idf')) {
+    await installSkill('embedded-esp-idf');
+  }
+
+  if (components.includes('opencode-json')) {
+    await installOpencodeJson(mode);
+  }
+
+  // Always attempt to merge the 7 BizarHarness tool keys idempotently.
+  // Safe to call even if opencode-json wasn't selected — skips silently.
+  {
+    const result = await mergeToolsIntoUserConfig();
+    if (result.merged) {
+      console.log(chalk.green(`  ✓ ${result.added.length} BizarHarness tool key(s) merged into opencode.json`));
+    }
+  }
+
+  if (components.includes('bizar')) {
+    await installBizarFolder();
+  }
+
+  if (components.includes('plugin-bizar')) {
+    const result = await installPluginBizar();
+    if (result.errors.length > 0) {
+      console.log(chalk.yellow(`  ⚠ Plugin install: ${result.errors.length} error(s)`));
+    }
+  }
+
+  // Also try to install the plugin from the separate global npm package
+  // `@polderlabs/bizar-plugin` (preferred path going forward).
+  await installPluginFromGlobal();
+
+  // ── Rules, hooks, commands (optional components) ──
+  if (components.includes('rules')) {
+    const n = await installRules();
+    console.log(chalk.green(`  ✓ ${n} rules installed`));
+  }
+  if (components.includes('hooks')) {
+    const n = await installHooks();
+    console.log(chalk.green(`  ✓ ${n} hooks installed`));
+  }
+  if (components.includes('commands')) {
+    const n = await installCommands();
+    console.log(chalk.green(`  ✓ ${n} commands installed`));
+  }
+
+  // ── RTK (always installed — token optimization required) ──
+  await installRtk();
+
+  // ── Semble (always installed — code search required) ──
+  await installSemble();
+
+  // ── Skills CLI (always installed — skill discovery required) ──
+  await installSkillsCli();
+
+  // ── Skill packs (via skills.sh ecosystem) ──
+  for (const pack of skillPacks) {
+    await installCuratedSkills([pack]);
+  }
+
+  // ── Step 6: API keys ──
+  sectionHeading('API Keys');
+  console.log(chalk.dim('  You can configure API keys now or later via /connect in opencode.'));
+  const keys = await promptApiKeys();
+
+  if (keys.opencodeZen || keys.minimax || keys.openai || keys.hindsight) {
+    console.log(chalk.dim('\n  Keys noted. Add them to your opencode.json or run /connect in opencode.\n'));
+  }
+
+  // ── Summary ──
+  console.log();
+  console.log(boxen(
+    chalk.bold.hex('#6366f1')('  ⚡ BIZARHARNESS INSTALLED ⚡\n') +
+    '\n' +
+    chalk.dim('  Norse Pantheon active.\n') +
+    '\n' +
+    chalk.green(`  ✓ ${selectedAgents.length} agents installed`) + '\n' +
+    chalk.green(`  ✓ ${summary.parts.length} components configured`) + '\n' +
+    '\n' +
+    chalk.green('  ✓ RTK ') + chalk.dim(`(${rtkInstalled ? 'already configured' : 'installed & configured'})`) + '\n' +
+    chalk.green('  ✓ Semble ') + chalk.dim(`(${sembleInstalled ? 'ready' : 'installed'})`) + '\n' +
+    chalk.green('  ✓ Skills CLI ') + chalk.dim(`(${skillsCliInstalled ? 'ready' : 'installed'})`) + '\n' +
+    (skillPacks.length > 0 ? chalk.green(`  ✓ Skill packs: ${skillPacks.join(', ')}`) + '\n' : '') + '\n' +
+    chalk.hex('#a855f7')('  Next steps:') + '\n' +
+    chalk.hex('#a855f7')('  1. Restart opencode') + '\n' +
+    chalk.hex('#a855f7')('  2. Run /connect to add API keys') + '\n' +
+    chalk.hex('#a855f7')('  3. Run /models to verify agents'),
+    {
+      padding: 1,
+      margin: 0,
+      borderStyle: 'round',
+      borderColor: '#6366f1',
+    },
+  ));
+  console.log();
+
+  // ── Restart prompt ──
+  const shouldRestart = await promptRestartOpenCode();
+  if (shouldRestart) {
+    console.log(chalk.dim('  Restarting opencode...'));
+    try {
+      const { execSync } = await import('node:child_process');
+      execSync('opencode', { stdio: 'inherit' });
+    } catch {
+      console.log(chalk.yellow('  Could not restart automatically. Restart opencode manually.'));
+    }
+  }
+
+  // ── Post-install ──
+  console.log(chalk.dim('\n  Odin watches. The Pantheon awaits. ᛟ\n'));
+}
+
+export async function runPostInstall() {
+  const { mkdirSync, copyFileSync, existsSync } = await import('node:fs');
+  const { join } = await import('node:path');
+  const { execSync } = await import('node:child_process');
+
+  const env = await detectOpenCode();
+  if (!env.exists) {
+    console.log('BizarHarness: opencode not detected — skipping auto-install.');
+    return;
+  }
+
+  mkdirSync(opencodeAgentsDir(), { recursive: true });
+
+  for (const file of AGENT_FILES) {
+    const src = repoPath('config', 'agents', file);
+    const dest = join(opencodeAgentsDir(), file);
+    if (!existsSync(dest)) {
+      copyFileSync(src, dest);
+    }
+  }
+  console.log('BizarHarness: agents installed.');
+
+  // Install RTK
+  const rtkPresent = await detectRtk();
+  if (!rtkPresent) {
+    console.log('BizarHarness: installing RTK (token optimizer)...');
+    try {
+      execSync(
+        'curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh',
+        { stdio: 'pipe', timeout: 60000 },
+      );
+      execSync('rtk init -g --opencode', { stdio: 'pipe' });
+      console.log('BizarHarness: RTK installed and configured.');
+    } catch {
+      console.log('BizarHarness: RTK install failed. Install manually from https://github.com/rtk-ai/rtk');
+    }
+  } else {
+    try {
+      execSync('rtk init -g --opencode', { stdio: 'pipe' });
+      console.log('BizarHarness: RTK configured for opencode.');
+    } catch {
+      console.log('BizarHarness: could not configure RTK. Run `rtk init -g --opencode` manually.');
+    }
+  }
+
+  // Install Semble
+  const semblePresent = await detectSemble();
+  if (!semblePresent) {
+    console.log('BizarHarness: installing Semble (code search)...');
+    try {
+      const hasUv = await detectUv();
+      if (!hasUv) {
+        execSync(
+          'curl -LsSf https://astral.sh/uv/install.sh | sh',
+          { stdio: 'pipe', timeout: 60000 },
+        );
+      }
+      execSync('uv tool install "semble[mcp]"', { stdio: 'pipe', timeout: 60000 });
+      console.log('BizarHarness: Semble installed.');
+    } catch {
+      console.log('BizarHarness: Semble install failed. Run `uv tool install "semble[mcp]"` manually.');
+    }
+  } else {
+    console.log('BizarHarness: Semble ready.');
+  }
+
+  // Install Skills CLI
+  const skillsPresent = await detectSkillsCli();
+  if (!skillsPresent) {
+    console.log('BizarHarness: installing Skills CLI...');
+    try {
+      execSync('npm install -g skills', { stdio: 'pipe', timeout: 30000 });
+      console.log('BizarHarness: Skills CLI installed.');
+    } catch {
+      console.log('BizarHarness: Skills CLI install failed. Run `npm install -g skills` manually.');
+    }
+  } else {
+    console.log('BizarHarness: Skills CLI ready.');
+  }
+
+  // Install core skill pack
+  console.log('BizarHarness: installing core skills (find-skills, skill-creator)...');
+  try {
+    execSync('skills add vercel-labs/skills --all -y', { stdio: 'pipe', timeout: 60000 });
+    console.log('BizarHarness: core skills installed.');
+  } catch {
+    console.log('BizarHarness: core skill install skipped — run `skills add vercel-labs/skills --all -y` manually.');
+  }
+
+  // Try to install the Bizar plugin from the separate global npm package.
+  // Non-fatal: prints a hint if the package isn't installed globally yet.
+  await installPluginFromGlobal();
+
+  console.log('Run `bizar` for interactive setup.');
+}