@polderlabs/bizar 10.2.0 → 10.4.0

package/cli/install/banner.mjs

@@ -0,0 +1,67 @@
+/**
+ * cli/install/banner.mjs
+ *
+ * Banner, pantheon card, and section heading for the install flow.
+ */
+
+import chalk from 'chalk';
+
+const RUNE_HELM = `
+    ██████╗ ██╗██╗  ██╗ █████╗ ██████╗
+    ██╔══██╗██║██║  ██║██╔══██╗██╔══██╗
+    ██████╔╝██║███████║███████║██████╔╝
+    ██╔══██╗██║╚════██║██╔══██║██╔══██╗
+    ██████╔╝██║     ██║██║  ██║██║  ██║
+    ╚═════╝ ╚═╝     ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝
+`;
+
+const PANTHEON = `
+    ╔══════════════════════════════════════════╗
+    ║                                          ║
+    ║    ᛟ Odin     ᛗ Mimir    ᚹ Heimdall     ║
+    ║    ᚱ Hermod   ᚦ Thor     ᛏ Tyr          ║
+    ║    ᛉ Vidarr   ᚨ Forseti  ᛒ Baldr        ║
+    ║                                          ║
+    ╚══════════════════════════════════════════╝
+`;
+
+const TAGLINE = '14 agents · 6 cost tiers · dashboard · Obsidian vault long-term memory · Mods · Skills CLI';
+
+export const palette = {
+  primary: chalk.hex('#6366f1'),
+  success: chalk.green,
+  warn:    chalk.yellow,
+  error:   chalk.red,
+  dim:     chalk.dim,
+};
+
+/**
+ * Print the Bizar mark + tagline.
+ * @param {string} [version] - Optional version string to prepend.
+ */
+export function showBanner(version) {
+  if (version) {
+    console.log(chalk.bold.hex('#6366f1')(`\n  ⚡ BizarHarness v${version}\n`));
+  } else {
+    console.log(chalk.bold.hex('#6366f1')(RUNE_HELM));
+    console.log(chalk.hex('#a855f7')('    Norse Pantheon Agent System for Claude Code'));
+  }
+  console.log();
+  console.log(chalk.dim(`    ${TAGLINE}`));
+  console.log();
+}
+
+/** Print the Norse pantheon card. */
+export function showPantheon() {
+  console.log(chalk.hex('#312e81')(PANTHEON));
+}
+
+/**
+ * Print a section header divider.
+ * @param {string} text - Section title.
+ */
+export function sectionHeading(text) {
+  console.log();
+  console.log(chalk.bold.hex('#6366f1')(` ── ${text} ──`));
+  console.log();
+}

package/cli/install/banner.test.mjs

@@ -0,0 +1,39 @@
+/**
+ * cli/install/banner.test.mjs
+ *
+ * Tests for cli/install/banner.mjs
+ */
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { showBanner, showPantheon, sectionHeading, palette } from './banner.mjs';
+
+describe('showBanner()', () => {
+  test('does not throw', () => {
+    assert.doesNotThrow(() => showBanner());
+  });
+
+  test('does not throw with version', () => {
+    assert.doesNotThrow(() => showBanner('10.0.0'));
+  });
+});
+
+describe('palette', () => {
+  test('has all 5 required keys', () => {
+    const required = ['primary', 'success', 'warn', 'error', 'dim'];
+    for (const key of required) {
+      assert.ok(key in palette, `missing palette key: ${key}`);
+      assert.ok(typeof palette[key] === 'function', `${key} should be a function`);
+    }
+  });
+});
+
+describe('sectionHeading()', () => {
+  let output;
+  const orig = console.log;
+
+  test('does not throw', () => {
+    assert.doesNotThrow(() => sectionHeading('Test Section'));
+  });
+});
+
+console.log('  banner.test.mjs loaded — run with: node --test cli/install/banner.test.mjs');

package/cli/install/index.mjs

@@ -0,0 +1,32 @@
+/**
+ * cli/install/index.mjs
+ *
+ * Clean orchestrator: runInstaller() — rewritten as a thin coordinator
+ * that delegates to the provisioner.
+ */
+
+import { runProvision } from '../provision.mjs';
+import { showBanner, sectionHeading } from './banner.mjs';
+import { printInstallLocations } from './paths.mjs';
+
+/**
+ * Thin orchestrator entry point.
+ * @param {object} opts
+ * @param {boolean} [opts.dryRun]
+ * @param {boolean} [opts.force]
+ * @param {boolean} [opts.quiet] - Only print the location card
+ * @param {string}  [opts.mode]  - 'install' | 'update'
+ */
+export async function runInstaller(opts = {}) {
+  const { dryRun = false, force = false, quiet = false, mode = 'install' } = opts;
+
+  if (quiet) {
+    printInstallLocations({ dryRun, force });
+    return { ok: true };
+  }
+
+  showBanner();
+  printInstallLocations({ dryRun, force });
+
+  return runProvision({ mode, dryRun, force });
+}

package/cli/install/index.test.mjs

@@ -0,0 +1,61 @@
+/**
+ * cli/install/index.test.mjs
+ *
+ * Tests for cli/install/index.mjs — runInstaller orchestrator.
+ */
+import { test, describe, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, existsSync, writeFileSync, mkdirSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const ORIG_HOME = process.env.HOME;
+
+function freshHome() {
+  const home = mkdtempSync(join(tmpdir(), 'bizar-install-index-'));
+  process.env.HOME = home;
+  delete process.env.CLAUDE_CONFIG_DIR;
+  delete process.env.XDG_CONFIG_HOME;
+  return home;
+}
+
+function restoreHome() {
+  if (ORIG_HOME === undefined) delete process.env.HOME;
+  else process.env.HOME = ORIG_HOME;
+}
+
+describe('runInstaller()', () => {
+  let home;
+
+  beforeEach(() => { home = freshHome(); });
+  afterEach(() => {
+    restoreHome();
+    if (home) try { rmSync(home, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  test('runInstaller({ dryRun: true }) does not write files', async () => {
+    const { runInstaller } = await import('./index.mjs');
+    const result = await runInstaller({ dryRun: true });
+    assert.equal(result.ok, true);
+  });
+
+  test('runInstaller({ quiet: true }) only prints location card', async () => {
+    const { runInstaller } = await import('./index.mjs');
+    const result = await runInstaller({ quiet: true });
+    assert.equal(result.ok, true);
+  });
+
+  test('runInstaller({ force: true }) runs without error', async () => {
+    const { runInstaller } = await import('./index.mjs');
+    const result = await runInstaller({ force: true, dryRun: true });
+    assert.equal(result.ok, true);
+  });
+
+  test('runInstaller({ mode: "update" }) runs without error', async () => {
+    const { runInstaller } = await import('./index.mjs');
+    const result = await runInstaller({ mode: 'update', dryRun: true });
+    assert.equal(result.ok, true);
+  });
+});
+
+console.log('  index.test.mjs loaded — run with: node --test cli/install/index.test.mjs');

package/cli/install/paths.mjs

@@ -0,0 +1,80 @@
+/**
+ * cli/install/paths.mjs
+ *
+ * Single source of truth for all install paths. Replaces hard-coded
+ * path literals scattered throughout the install flow.
+ */
+
+import chalk from 'chalk';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+/** Resolve the Claude Code config directory.
+ *   1. `process.env.CLAUDE_CONFIG_DIR`
+ *   2. `$HOME/.claude`
+ */
+export function resolveClaudeDir() {
+  const HOME = homedir();
+  if (process.env.CLAUDE_CONFIG_DIR && process.env.CLAUDE_CONFIG_DIR.trim()) {
+    return process.env.CLAUDE_CONFIG_DIR.trim();
+  }
+  if (process.platform === 'win32') {
+    return process.env.APPDATA
+      ? join(process.env.APPDATA, 'Claude')
+      : join(HOME, '.claude');
+  }
+  return join(HOME, '.claude');
+}
+
+const HOME = homedir();
+const CLAUDE_DIR = resolveClaudeDir();
+const BIZAR_HOME = process.env.BIZAR_HOME
+  || join(process.env.XDG_CONFIG_HOME || join(HOME, '.config'), 'bizar');
+
+/** The Bizar runtime state directory (not under ~/.claude/). */
+export { BIZAR_HOME };
+
+/** Standard Claude Code subdirectories under CLAUDE_DIR. */
+export const PATHS = {
+  claudeDir:     CLAUDE_DIR,
+  agentsDir:     join(CLAUDE_DIR, 'agents'),
+  skillsDir:     join(CLAUDE_DIR, 'skills'),
+  commandsDir:   join(CLAUDE_DIR, 'commands'),
+  hooksDir:      join(CLAUDE_DIR, 'hooks'),
+  pluginsDir:    join(CLAUDE_DIR, 'plugins'),
+  settingsFile:  join(CLAUDE_DIR, 'settings.json'),
+  bizarHome:     BIZAR_HOME,
+  servicePid:    join(BIZAR_HOME, 'service.pid'),
+  dashboardPid:   join(BIZAR_HOME, 'dashboard.pid'),
+  dashboardPort: join(BIZAR_HOME, 'dashboard.port'),
+  installMarker: join(BIZAR_HOME, 'installed.json'),
+};
+
+/**
+ * Render the install-location card to the console.
+ * @param {{ dryRun?: boolean, force?: boolean }} [_opts]
+ */
+export function printInstallLocations(_opts = {}) {
+  const G = chalk.green;
+  const dim = chalk.dim;
+
+  console.log();
+  console.log(chalk.bold('┌─ BizarHarness will install to ─────────────────────────────────────┐'));
+  console.log(chalk.bold('│') + ' '.repeat(68) + chalk.bold('│'));
+  console.log(chalk.bold('│') + `  Claude Code config     ${PATHS.claudeDir}`.padEnd(69) + chalk.bold('│'));
+  console.log(chalk.bold('│') + `    ├─ agents/          bundled agents`.padEnd(69) + chalk.bold('│'));
+  console.log(chalk.bold('│') + `    ├─ skills/          bundled skill packs`.padEnd(69) + chalk.bold('│'));
+  console.log(chalk.bold('│') + `    ├─ commands/        slash commands`.padEnd(69) + chalk.bold('│'));
+  console.log(chalk.bold('│') + `    ├─ hooks/           PreToolUse, PostToolUse, …`.padEnd(69) + chalk.bold('│'));
+  console.log(chalk.bold('│') + `    ├─ plugins/bizar/   the MCP server`.padEnd(69) + chalk.bold('│'));
+  console.log(chalk.bold('│') + `    └─ settings.json    scoped permissions + hooks`.padEnd(69) + chalk.bold('│'));
+  console.log(chalk.bold('│') + ' '.repeat(68) + chalk.bold('│'));
+  console.log(chalk.bold('│') + `  Bizar runtime state   ${PATHS.bizarHome}`.padEnd(69) + chalk.bold('│'));
+  console.log(chalk.bold('│') + `    ├─ service.pid      background daemon PID`.padEnd(69) + chalk.bold('│'));
+  console.log(chalk.bold('│') + `    ├─ dashboard.pid    dashboard server PID`.padEnd(69) + chalk.bold('│'));
+  console.log(chalk.bold('│') + `    └─ installed.json   install manifest (version, hash)`.padEnd(69) + chalk.bold('│'));
+  console.log(chalk.bold('│') + ' '.repeat(68) + chalk.bold('│'));
+  console.log(chalk.bold('│') + `  Override with: ${dim('CLAUDE_CONFIG_DIR=/path/to/dir')}`.padEnd(69) + chalk.bold('│'));
+  console.log(chalk.bold('└──────────────────────────────────────────────────────────────────────┘'));
+  console.log();
+}

package/cli/install/paths.test.mjs

@@ -0,0 +1,77 @@
+/**
+ * cli/install/paths.test.mjs
+ *
+ * Tests for cli/install/paths.mjs
+ */
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { PATHS, printInstallLocations, resolveClaudeDir } from './paths.mjs';
+
+describe('PATHS', () => {
+  test('has all required keys', () => {
+    const required = [
+      'claudeDir', 'agentsDir', 'skillsDir', 'commandsDir',
+      'hooksDir', 'pluginsDir', 'settingsFile', 'bizarHome',
+      'servicePid', 'dashboardPid', 'dashboardPort', 'installMarker',
+    ];
+    for (const key of required) {
+      assert.ok(key in PATHS, `missing key: ${key}`);
+    }
+  });
+
+  test('PATHS values are non-empty strings', () => {
+    for (const [key, val] of Object.entries(PATHS)) {
+      assert.ok(typeof val === 'string' && val.length > 0, `${key} should be non-empty string, got: ${val}`);
+    }
+  });
+});
+
+describe('printInstallLocations()', () => {
+  test('does not throw', () => {
+    assert.doesNotThrow(() => printInstallLocations({ dryRun: false }));
+  });
+
+  test('output contains ~/.claude', () => {
+    let output = '';
+    const orig = console.log;
+    console.log = (...args) => { output += args.join(' ') + '\n'; };
+    try { printInstallLocations({}); } finally { console.log = orig; }
+    // Output mentions the Claude config dir — exact form depends on resolved HOME
+    assert.ok(output.includes('.claude') || output.includes('/.claude'), 'should mention .claude path');
+  });
+});
+
+describe('resolveClaudeDir()', () => {
+  test('uses CLAUDE_CONFIG_DIR env override', () => {
+    const orig = process.env.CLAUDE_CONFIG_DIR;
+    process.env.CLAUDE_CONFIG_DIR = '/tmp/my-claude-dir';
+    try {
+      const dir = resolveClaudeDir();
+      assert.equal(dir, '/tmp/my-claude-dir');
+    } finally {
+      if (orig === undefined) delete process.env.CLAUDE_CONFIG_DIR;
+      else process.env.CLAUDE_CONFIG_DIR = orig;
+    }
+  });
+});
+
+describe('idempotency', () => {
+  test('two consecutive calls produce same output', () => {
+    let out1 = '', out2 = '';
+    const orig = console.log;
+    const capture = () => { let s = ''; console.log = (...a) => { s += a.join(' ') + '\n'; }; return s; };
+    const restore = (s) => { console.log = orig; return s; };
+
+    const c1 = capture();
+    printInstallLocations({});
+    out1 = restore(c1);
+
+    const c2 = capture();
+    printInstallLocations({});
+    out2 = restore(c2);
+
+    assert.equal(out1, out2, 'consecutive calls should produce identical output');
+  });
+});
+
+console.log('  paths.test.mjs loaded — run with: node --test cli/install/paths.test.mjs');

package/cli/install/plugin.mjs

@@ -0,0 +1,161 @@
+/**
+ * cli/install/plugin.mjs
+ *
+ * installPluginFromGlobal() — copied from cli/install.mjs (original ~220 lines).
+ * Installs the Bizar plugin from the global npm package into ~/.claude/plugins/bizar/.
+ */
+
+import chalk from 'chalk';
+import { existsSync, lstatSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { resolveClaudeDir } from './paths.mjs';
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+
+/**
+ * Install the Bizar MCP server from this package's own `plugins/bizar/`
+ * directory into `~/.claude/plugins/bizar/`.
+ *
+ * Symlink guard (v3.12.2): if the dest is a symlink (e.g. created by
+ * `bizar dev-link`), do NOT overwrite it. Pass `{ force: true }` to override.
+ *
+ * node_modules copy: the plugin imports `@polderlabs/bizar-sdk`. After copying
+ * the plugin files, this function also copies the source `node_modules/` to the
+ * deployed `node_modules/` so Bun can resolve the import.
+ *
+ * Returns `true` if the plugin was installed (or already in place),
+ * `false` otherwise. Never throws.
+ */
+export async function installPluginFromGlobal(opts = {}) {
+  const { mkdir, readdir, copyFile } = await import('node:fs/promises');
+
+  const destDir = join(resolveClaudeDir(), 'plugins', 'bizar');
+  let destIsSymlink = false;
+  try {
+    destIsSymlink = lstatSync(destDir).isSymbolicLink();
+  } catch {
+    // doesn't exist yet — fine
+  }
+
+  if (destIsSymlink) {
+    if (opts.silent) return true;
+    console.log(chalk.yellow('  ⚠ ~/.claude/plugins/bizar is a dev symlink — skipping copy.'));
+    console.log(chalk.dim('    Run `bizar dev-unlink` to restore the deployed copy, or pass --force to overwrite.'));
+    if (!opts.force) return false;
+    rmSync(destDir, { force: true });
+  }
+
+  let pluginPath;
+  if (opts.sourceDir) {
+    pluginPath = opts.sourceDir;
+  } else {
+    pluginPath = join(__dirname, '..', '..', 'plugins', 'bizar');
+  }
+  if (!existsSync(pluginPath)) {
+    console.log(chalk.red(`  ✗ Plugin source not found at ${pluginPath}`));
+    console.log(chalk.dim('    This package appears to be missing plugins/bizar/. Reinstall:'));
+    console.log(chalk.dim('      npm install -g @polderlabs/bizar --force'));
+    return false;
+  }
+
+  const distEntry = join(pluginPath, 'dist', 'index.js');
+  if (!existsSync(distEntry)) {
+    try {
+      const { buildPlugin } = await import('../provision.mjs');
+      const buildRes = await buildPlugin();
+      if (buildRes.ok && !buildRes.skipped) {
+        console.log(chalk.dim(`    auto-built plugin (${buildRes.message})`));
+      } else if (!buildRes.ok) {
+        console.log(chalk.yellow(`  ⚠ Plugin auto-build failed: ${buildRes.message}`));
+        console.log(chalk.dim('    Run `bizar install` from a checkout, or:'));
+        console.log(chalk.dim('      npx tsc -p plugins/bizar/tsconfig.json'));
+        return false;
+      }
+    } catch (err) {
+      console.log(chalk.yellow(`  ⚠ Plugin auto-build threw: ${err.message}`));
+      return false;
+    }
+  }
+
+  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}`));
+  } catch (err) {
+    console.log(chalk.yellow(`  ⚠ Failed to copy Bizar plugin: ${err.message}`));
+    return false;
+  }
+
+  // node_modules copy — the plugin imports `@polderlabs/bizar-sdk`
+  try {
+    const srcNmDir = join(pluginPath, 'node_modules');
+    if (existsSync(srcNmDir)) {
+      const dstNmDir = join(destDir, 'node_modules');
+      let dstNmIsSymlink = false;
+      try {
+        dstNmIsSymlink = lstatSync(dstNmDir).isSymbolicLink();
+      } catch { /* doesn't exist — fine */ }
+      if (dstNmIsSymlink) {
+        console.log(chalk.yellow(`  ⚠ ${dstNmDir} is a symlink — refusing to copy node_modules (remove manually).`));
+      } else {
+        const srcEntries = await readdir(srcNmDir, { withFileTypes: true });
+        await mkdir(dstNmDir, { recursive: true });
+        async function copyNodeModules(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()) {
+              await mkdir(dst, { recursive: true });
+              await copyNodeModules(src, dst);
+            } else {
+              await copyFile(src, dst);
+            }
+          }
+        }
+        await copyNodeModules(srcNmDir, dstNmDir);
+        console.log(chalk.green(`  ✓ copied node_modules (${srcEntries.length} packages) to deployed plugin`));
+      }
+    }
+
+    // Wire runtime deps (zod, @anthropic-ai/claude-agent-sdk)
+    let pluginMain = null;
+    try {
+      const pkgPath = join(destDir, 'package.json');
+      const pkg = JSON.parse(await import('node:fs/promises').then(fs => fs.readFile(pkgPath, 'utf8')));
+      pluginMain = pkg.main;
+    } catch { /* missing or unreadable */ }
+    const needsWiring = typeof pluginMain === 'string' && pluginMain.endsWith('.ts');
+    if (needsWiring) {
+      try {
+        const { wirePluginRuntimeDeps } = await import('../plugin-runtime-deps.mjs');
+        await wirePluginRuntimeDeps(destDir);
+      } catch (err) {
+        console.log(chalk.dim(`  ℹ Could not auto-wire runtime deps: ${err.message} (run \`bizar doctor\` to diagnose)`));
+      }
+    }
+  } catch (err) {
+    console.log(chalk.yellow(`  ⚠ Failed to copy node_modules: ${err.message}`));
+  }
+
+  return true;
+}

package/cli/install/postinstall.mjs

@@ -0,0 +1,111 @@
+/**
+ * cli/install/postinstall.mjs
+ *
+ * runPostInstall() — moved verbatim from cli/install.mjs (original ~95 lines).
+ */
+
+import chalk from 'chalk';
+import { existsSync, mkdirSync, copyFileSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import { join } from 'node:path';
+import { resolveClaudeDir, PATHS } from './paths.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',
+];
+
+/**
+ * Post-install bootstrap: settings.json template, agents, Semble, Skills CLI.
+ * Called by the npm postinstall hook.
+ */
+export async function runPostInstall() {
+  const dest = join(resolveClaudeDir(), 'settings.json');
+  const templateSrc = join(PATHS.bizarHome, '..', 'config', 'settings.json');
+
+  // Copy settings.json template if not exists
+  if (!existsSync(dest)) {
+    if (existsSync(templateSrc)) {
+      mkdirSync(resolveClaudeDir(), { recursive: true });
+      copyFileSync(templateSrc, dest);
+      console.log('  ✓ settings.json bootstrapped from package template');
+    }
+  }
+
+  // Ensure Claude config dir exists
+  const env = { exists: existsSync(resolveClaudeDir()) };
+  if (!env.exists) {
+    mkdirSync(resolveClaudeDir(), { recursive: true });
+    console.log(`BizarHarness: created ${resolveClaudeDir()}/`);
+  }
+
+  mkdirSync(PATHS.agentsDir, { recursive: true });
+
+  for (const file of AGENT_FILES) {
+    const src = join(PATHS.bizarHome, '..', 'config', 'agents', file);
+    const dst = join(PATHS.agentsDir, file);
+    if (!existsSync(dst)) {
+      copyFileSync(src, dst);
+    }
+  }
+  console.log('BizarHarness: agents installed.');
+
+  // Install Semble
+  const seemeCmd = (cmd) => {
+    try {
+      execSync(`command -v ${cmd}`, { stdio: ['ignore', 'pipe', 'ignore'] });
+      return true;
+    } catch { return false; }
+  };
+  const semblePresent = seemeCmd('semble');
+  if (!semblePresent) {
+    console.log('BizarHarness: installing Semble (code search)...');
+    try {
+      const hasUv = seemeCmd('uv');
+      if (!hasUv) {
+        if (process.platform === 'win32') {
+          execSync('powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"', { stdio: 'pipe', timeout: 60000 });
+        } else {
+          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 = seemeCmd('skills');
+  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...');
+  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.');
+  }
+
+  // Install Bizar plugin
+  const { installPluginFromGlobal } = await import('./plugin.mjs');
+  await installPluginFromGlobal();
+
+  console.log('Run `bizar` for interactive setup.');
+}