@polderlabs/bizar 6.2.4 → 6.3.0

package/cli/dev-link.test.mjs

@@ -4,12 +4,12 @@
  * Tests for the `bizar dev-link` / `bizar dev-unlink` subcommands.
  * Uses Node's built-in node:test (no external test framework).
  *
- * Strategy: mock HOME (and XDG_CONFIG_HOME) so clineConfigDir() in
+ * Strategy: mock HOME (and XDG_CONFIG_HOME) so claudeConfigDir() in
  * cli/utils.mjs returns a path inside a tmpdir, and exercise the
  * create/remove symlink behavior against a controlled filesystem.
  *
  * Note: We mock HOME *before* importing dev-link.mjs because the module
- * imports clineConfigDir transitively from utils.mjs. The path is
+ * imports claudeConfigDir transitively from utils.mjs. The path is
  * resolved at call time, though, so the mock just needs to be in place
  * when the functions run.
  */
@@ -40,28 +40,28 @@ const ORIG_HOME = process.env.HOME;
 const ORIG_XDG = process.env.XDG_CONFIG_HOME;
 
 /**
- * Point HOME at a fresh tmpdir so the module's clineConfigDir()
- * resolves inside it (via the fallback `<HOME>/.cline`).
+ * Point HOME at a fresh tmpdir so the module's claudeConfigDir()
+ * resolves inside it (via the fallback `<HOME>/.claude`).
  * Returns the tmpdir path.
  *
  * Note: we deliberately do NOT set XDG_CONFIG_HOME here. The
- * clineConfigDir() helper treats a set XDG_CONFIG_HOME as the
- * direct parent (so `XDG_CONFIG_HOME=~/.config` → `~/.cline`,
+ * claudeConfigDir() helper treats a set XDG_CONFIG_HOME as the
+ * direct parent (so `XDG_CONFIG_HOME=~/.config` → `~/.claude`,
  * matching the standard layout). Setting it to a raw tmpdir would
- * produce `<tmpdir>/cline` instead of the expected
- * `<tmpdir>/.cline` and break path alignment with the test.
+ * produce `<tmpdir>/claude` instead of the expected
+ * `<tmpdir>/.claude` and break path alignment with the test.
  */
 function freshHome() {
   const home = mkdtempSync(join(tmpdir(), 'bizar-devlink-'));
   process.env.HOME = home;
-  delete process.env.CLINE_DIR;
-    delete process.env.BIZAR_LEGACY_CLINE_DIR;
+  delete process.env.CLAUDE_CONFIG_DIR;
+    delete process.env.BIZAR_LEGACY_CLAUDE_DIR;
   return home;
 }
 
 /** Path to the deployed plugin dir under the mocked HOME. */
 function pluginDest(home) {
-  return join(home, '.cline', 'plugins', 'bizar');
+  return join(home, '.claude', 'plugins', 'bizar');
 }
 
 after(() => {

package/cli/doctor.mjs

@@ -1,86 +1,53 @@
 /**
  * cli/doctor.mjs
  *
- * v3.12.2 — `bizar doctor` subcommand.
+ * v6.3.0 — `bizar doctor` subcommand (Claude Code-native).
  *
- * Runs a battery of health checks against the local Bizar / cline
+ * Runs a battery of health checks against the local Bizar / Claude Code
  * install and reports pass/fail for each. Returns a structured summary
  * suitable for callers (e.g. `bizar update`) that want to act on the
  * result without re-printing the per-check output.
  *
- * The checks are intentionally tolerant: missing optional tools
- * (headroom/semble/skills) don't fail the run, and the dashboard check
- * is skipped silently if no port file exists. The goal is "is your
- * install healthy?" not "is every conceivable thing present?".
+ * Checks (9 total):
+ *   claude-cli-reachable:    claude --version exits 0
+ *   settings-valid:          ~/.claude/settings.json parses
+ *   mcp-server-registered:   settings.json has mcpServers.bizar
+ *   hooks-wired:             settings.json has PreToolUse/PostToolUse/etc
+ *   agent-files-installed:   agent .md files deployed
+ *   skill-files-installed:   SKILL.md files deployed
+ *   tools-on-path:           at least one of headroom/semble/skills/claude
+ *   memory-vault:            BIZAR_HOME exists (memory subdir lazy)
+ *   9router-reachable:       provider gateway responds
  *
  * Usage:
- *   import { runDoctor } from './doctor.mjs';
- *   const r = await runDoctor();                    // prints everything
- *   const r = await runDoctor({ silent: true });    // returns summary only
+ *   import { runDoctor } from "./doctor.mjs";
+ *   const r = await runDoctor();
+ *   const r = await runDoctor({ silent: true });
  */
 import chalk from 'chalk';
 import { spawnSync } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, statSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
-import { clineConfigDir, clineAgentsDir, which, bizarConfigDir } from './utils.mjs';
+import { homedir } from 'node:os';
 
-// v3.20.11: list every agent the install script is expected to deploy.
-// Adding a new agent to `config/agents/` without adding it here causes
-// doctor to silently under-count ("all 4 core agents present" when there
-// are actually 14). The list mirrors cli/install.mjs AGENT_FILES plus
-// `agent-browser.md` (added in v3.20.7) and `_shared/AGENT_BASELINE.md`
-// is intentionally excluded (it's a skill, not an agent).
-const REQUIRED_AGENTS = [
-  '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',
-  'agent-browser.md',
-];
-
-// ── helpers ─────────────────────────────────────────────────────────────────
-
-/**
- * Run a check function and capture its result. The check either
- * returns a string message (pass) or throws an Error (fail).
- */
-async function runCheck(name, fn) {
-  try {
-    const message = await fn();
-    return { name, ok: true, message: message || 'ok' };
-  } catch (err) {
-    return {
-      name,
-      ok: false,
-      message: err && err.message ? err.message : String(err),
-    };
-  }
-}
+const CLAUDE_DIR = process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
+const BIZAR_HOME = process.env.BIZAR_HOME || join(homedir(), '.bizar_home');
 
 // ── individual checks ───────────────────────────────────────────────────────
 
-async function checkClineReachable() {
-  const r = spawnSync('cline', ['--version'], {
+async function checkClaudeReachable() {
+  const r = spawnSync('claude', ['--version'], {
     encoding: 'utf8',
     timeout: 5000,
   });
   if (r.status !== 0) {
-    throw new Error(`cline --version exited ${r.status}`);
+    throw new Error(`claude --version exited ${r.status}`);
   }
-  return (r.stdout || r.stderr || '').trim().split('\n')[0] || 'cline available';
+  return (r.stdout || r.stderr || '').trim().split('\n')[0] || 'claude available';
 }
 
-async function checkConfigValid() {
-  const cfgPath = join(clineConfigDir(), 'cline.json');
+async function checkSettingsValid() {
+  const cfgPath = join(CLAUDE_DIR, 'settings.json');
   if (!existsSync(cfgPath)) {
     throw new Error(`not found at ${cfgPath}`);
   }
@@ -89,73 +56,56 @@ async function checkConfigValid() {
   } catch (err) {
     throw new Error(`invalid JSON: ${err.message}`);
   }
-  return 'cline.json parses';
+  return 'settings.json parses';
 }
 
-async function checkPluginEntryPresent() {
-  const cfgPath = join(clineConfigDir(), 'cline.json');
+async function checkMcpServerRegistered() {
+  const cfgPath = join(CLAUDE_DIR, 'settings.json');
   const cfg = JSON.parse(readFileSync(cfgPath, 'utf8'));
-  const plugins = Array.isArray(cfg.plugin) ? cfg.plugin : [];
-  if (plugins.length === 0) {
-    throw new Error('no plugin entries in cline.json');
+  const servers = cfg.mcpServers || {};
+  if (!servers.bizar) {
+    throw new Error('mcpServers.bizar missing from settings.json');
   }
-  const hasBizar = plugins.some((p) => {
-    if (typeof p === 'string') return p.includes('bizar');
-    if (Array.isArray(p)) {
-      const [path] = p;
-      return typeof path === 'string' && path.includes('bizar');
-    }
-    if (p && typeof p === 'object') {
-      return (
-        (p.name || '').includes('bizar') ||
-        (p.path || '').includes('bizar')
-      );
-    }
-    return false;
-  });
-  if (!hasBizar) {
-    throw new Error('bizar not found in plugin[]');
-  }
-  return 'bizar present in plugin[]';
+  return `bizar MCP server registered (${servers.bizar.command ?? '?'})`;
 }
 
-async function checkPluginPathResolves() {
-  const cfgPath = join(clineConfigDir(), 'cline.json');
+async function checkHooksWired() {
+  const cfgPath = join(CLAUDE_DIR, 'settings.json');
   const cfg = JSON.parse(readFileSync(cfgPath, 'utf8'));
-  const plugins = Array.isArray(cfg.plugin) ? cfg.plugin : [];
-  let lastChecked = null;
-  for (const p of plugins) {
-    let entryPath = null;
-    if (Array.isArray(p)) {
-      const [path] = p;
-      if (typeof path === 'string') entryPath = path;
-    } else if (p && typeof p === 'object' && p.path) {
-      entryPath = p.path;
-    }
-    if (!entryPath) continue;
-    const isAbs = entryPath.startsWith('/') || /^[a-z]:[\\/]/i.test(entryPath);
-    const resolved = isAbs ? entryPath : join(clineConfigDir(), entryPath);
-    lastChecked = resolved;
-    if (!existsSync(resolved)) {
-      throw new Error(`plugin path does not exist: ${resolved}`);
-    }
-  }
-  if (lastChecked === null) {
-    return 'no plugin path to check';
+  const hooks = cfg.hooks || {};
+  const required = ['PreToolUse', 'PostToolUse', 'SessionStart', 'UserPromptSubmit'];
+  const missing = required.filter((e) => !Array.isArray(hooks[e]) || hooks[e].length === 0);
+  if (missing.length > 0) {
+    throw new Error(`missing hook events: ${missing.join(', ')}`);
   }
-  return `plugin path resolves: ${lastChecked}`;
+  return `hooks wired: ${required.join(', ')}`;
 }
 
 async function checkAgentFilesInstalled() {
-  const dir = clineAgentsDir();
+  const dir = join(CLAUDE_DIR, 'agents');
   if (!existsSync(dir)) {
     throw new Error(`agents dir missing: ${dir}`);
   }
-  const missing = REQUIRED_AGENTS.filter((f) => !existsSync(join(dir, f)));
-  if (missing.length > 0) {
-    throw new Error(`missing: ${missing.join(', ')}`);
+  const have = readdirSync(dir).filter((f) => f.endsWith('.md'));
+  if (have.length === 0) {
+    throw new Error('no agent .md files installed');
+  }
+  return `${have.length} agents installed: ${have.slice(0, 4).join(', ')}${have.length > 4 ? '…' : ''}`;
+}
+
+async function checkSkillFilesInstalled() {
+  const dir = join(CLAUDE_DIR, 'skills');
+  if (!existsSync(dir)) {
+    throw new Error(`skills dir missing: ${dir}`);
+  }
+  const skills = readdirSync(dir).filter((d) => {
+    const fp = join(dir, d, 'SKILL.md');
+    return existsSync(fp);
+  });
+  if (skills.length === 0) {
+    throw new Error('no SKILL.md files found');
   }
-  return `all ${REQUIRED_AGENTS.length} core agents present`;
+  return `${skills.length} skills installed`;
 }
 
 /**
@@ -165,7 +115,7 @@ async function checkAgentFilesInstalled() {
  * overall health report.
  */
 async function checkToolsAvailable() {
-  const tools = ['headroom', 'semble', 'skills'];
+  const tools = ['headroom', 'semble', 'skills', 'claude'];
   const found = tools.filter(which);
   if (found.length === 0) {
     throw new Error(`none of ${tools.join('/')} on PATH`);
@@ -173,127 +123,95 @@ async function checkToolsAvailable() {
   return `available: ${found.join(', ')}`;
 }
 
-async function checkProviderConfigSanity() {
-  const cfgPath = join(clineConfigDir(), 'cline.json');
-  if (!existsSync(cfgPath)) {
-    throw new Error('cline.json missing');
+async function checkMemoryVault() {
+  if (!existsSync(BIZAR_HOME)) {
+    throw new Error(`BIZAR_HOME missing: ${BIZAR_HOME}`);
   }
-  const cfg = JSON.parse(readFileSync(cfgPath, 'utf8'));
-
-  // v6.0.1 — 9router is the primary gateway. All Bizar agents
-  // route through it via `9router/<model>` prefixed model IDs.
-  const nine = cfg.provider && cfg.provider['9router'];
-  if (nine && nine.baseUrl) {
-    const models = nine.models || {};
-    const sane = Object.keys(models).filter((id) => typeof id === 'string' && id.length > 0);
-    if (sane.length === 0) {
-      throw new Error(
-        'provider.9router block has no models (run `bizar update` to re-sync)',
-      );
-    }
-    return `provider.9router baseUrl=${nine.baseUrl} sane (${sane.length} models)`;
+  const memDir = process.env.BIZAR_MEMORY_VAULT || join(BIZAR_HOME, 'memory');
+  if (!existsSync(memDir)) {
+    // Not fatal — the vault is created lazily on first write.
+    return `BIZAR_HOME present; memory vault will be created on demand`;
   }
-
-  // Fallback: legacy `minimax` provider only. Kept for back-compat with
-  // older pre-v6.0.1 cline.json installs.
-  const minimax = cfg.provider && cfg.provider.minimax;
-  if (!minimax) {
-    return 'warn: no provider.9router AND no provider.minimax — run `bizar update`';
-  }
-  const models = minimax.models || {};
-  const saneNames = Object.entries(models).filter(([, m]) => {
-    return (
-      m &&
-      typeof m === 'object' &&
-      'interleaved' in m &&
-      'reasoning' in m
-    );
-  });
-  if (saneNames.length === 0) {
-    throw new Error(
-      'no MiniMax-style model with interleaved + reasoning flags',
-    );
-  }
-  return `provider.minimax + ${saneNames.length} model(s) sane (legacy; consider migrating to provider.9router)`;
+  const st = statSync(memDir);
+  return `memory vault at ${memDir} (${st.isDirectory() ? 'dir' : '?'})`;
 }
 
-/**
- * v6.0.1 — Check 9Router reachability. 9Router is the Bizar gateway;
- * if it's down, agents can't reach any upstream. Lenient (warn) by
- * design — the user might be intentionally working offline — but a
- * loud warning keeps the issue from being silent.
- */
-async function check9routerReachable() {
-  const url = process.env.NINEROUTER_URL || 'http://localhost:20128';
-  const ac = new AbortController();
-  const timer = setTimeout(() => ac.abort(), 4000);
+async function check9RouterReachable() {
+  const url = process.env.NINEROUTER_URL || 'http://127.0.0.1:8787';
+  let res;
   try {
-    const res = await fetch(`${url}/api/health`, { signal: ac.signal });
-    if (!res.ok) {
-      return `warn: 9router at ${url} returned HTTP ${res.status}`;
-    }
-    const body = await res.text().catch(() => '');
-    if (!body.includes('"ok":true')) {
-      return `warn: 9router at ${url} responded but body did not include ok:true (got: ${body.slice(0, 60)})`;
-    }
-    return `9router healthy at ${url}`;
+    res = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3000) });
   } catch (err) {
-    const reason = err.name === 'AbortError' ? 'timeout after 4s' : (err.message || 'unreachable');
-    return `warn: 9router unreachable at ${url} — ${reason}`;
-  } finally {
-    clearTimeout(timer);
+    throw new Error(`9router at ${url} unreachable: ${err.message ?? err}`);
+  }
+  if (!res.ok) {
+    throw new Error(`9router at ${url} responded HTTP ${res.status}`);
   }
+  return `9router at ${url} ok`;
 }
 
+// ── runner ──────────────────────────────────────────────────────────────────
+
 const CHECKS = [
-  ['cline-reachable', checkClineReachable],
-  ['cline-config-valid', checkConfigValid],
-  ['plugin-entry-present', checkPluginEntryPresent],
-  ['plugin-path-resolves', checkPluginPathResolves],
-  ['agent-files-installed', checkAgentFilesInstalled],
-  ['tools-available', checkToolsAvailable],
-  ['provider-config-sanity', checkProviderConfigSanity],
-  ['9router-reachable', check9routerReachable],
+  { name: 'claude-cli-reachable',       run: checkClaudeReachable },
+  { name: 'settings-valid',            run: checkSettingsValid },
+  { name: 'mcp-server-registered',     run: checkMcpServerRegistered },
+  { name: 'hooks-wired',               run: checkHooksWired },
+  { name: 'agent-files-installed',     run: checkAgentFilesInstalled },
+  { name: 'skill-files-installed',     run: checkSkillFilesInstalled },
+  { name: 'tools-on-path',             run: checkToolsAvailable },
+  { name: 'memory-vault',              run: checkMemoryVault },
+  { name: '9router-reachable',         run: check9RouterReachable },
 ];
 
-// ── public API ──────────────────────────────────────────────────────────────
-
-/**
- * Run all health checks. Prints per-check output unless `opts.silent`.
- * Prints a final summary line unless `opts.json` is true.
- * Returns `{ passed, failed, results }`.
- */
 export async function runDoctor(opts = {}) {
   const silent = !!opts.silent;
-  const jsonMode = !!opts.json;
   const results = [];
-  for (const [name, fn] of CHECKS) {
-    const r = await runCheck(name, fn);
-    results.push(r);
+  let passed = 0;
+  let failed = 0;
+
+  for (const check of CHECKS) {
+    let result;
+    try {
+      const message = await check.run();
+      result = { name: check.name, ok: true, message: message ?? 'ok' };
+    } catch (err) {
+      result = { name: check.name, ok: false, message: err?.message ?? String(err) };
+    }
+    results.push(result);
+    if (result.ok) passed += 1;
+    else failed += 1;
+
     if (!silent) {
-      const marker = r.ok ? chalk.green('✓') : chalk.red('✗');
-      const label = name.padEnd(28);
-      const msg = r.ok ? chalk.dim(`  ${r.message}`) : chalk.red(`  ${r.message}`);
-      console.log(`  ${marker} ${label}${msg}`);
+      const tag = result.ok ? chalk.green('  ✔ ') : chalk.red('  ✖ ');
+      process.stdout.write(`${tag}${check.name}${result.ok ? '' : ` — ${result.message}`}\n`);
     }
   }
 
-  const passed = results.filter((r) => r.ok).length;
-  const failed = results.length - passed;
-
-  // Print summary line only when not in JSON mode
-  if (!jsonMode && (failed > 0 || !silent)) {
-    console.log('');
-    if (failed === 0) {
-      console.log(
-        chalk.green(`  ✓ ${passed} checks passed, ${failed} failed`),
-      );
-    } else {
-      console.log(
-        chalk.yellow(`  ⚠ ${passed} checks passed, ${failed} failed`),
-      );
-    }
+  if (!silent) {
+    const summary = chalk.bold(
+      failed > 0
+        ? chalk.red(`${failed} checks failed, ${passed} passed`)
+        : chalk.green(`${passed} checks passed`),
+    );
+    process.stdout.write(`\n${summary}\n`);
   }
 
   return { passed, failed, results };
-}
+}
+
+// ── helper ──────────────────────────────────────────────────────────────────
+
+function which(cmd) {
+  const r = spawnSync('which', [cmd], { encoding: 'utf8' });
+  return r.status === 0 && !!r.stdout?.trim();
+}
+
+// Stand-alone CLI invocation (so `bizar doctor` still works when imported
+// without the bin dispatcher).
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const silent = process.argv.includes('--silent');
+  runDoctor({ silent }).then(({ failed }) => {
+    process.exit(failed === 0 ? 0 : 1);
+  });
+}

package/cli/install.mjs

@@ -16,7 +16,7 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 
 import { showBanner, showPantheon, sectionHeading } from './banner.mjs';
 import { promptComponents, promptInstallMode, promptAgents, promptSkillPacks, promptApiKeys, promptConfirmInstall, promptRestartCline } from './prompts.mjs';
-import { detectCline, detectHeadroom, detectSemble, detectSkillsCli, detectUv, buildSummary, clineAgentsDir, clineConfigDir, repoPath } from './utils.mjs';
+import { detectClaude, detectHeadroom, detectSemble, detectSkillsCli, detectUv, buildSummary, claudeAgentsDir, claudeConfigDir, repoPath } from './utils.mjs';
 import { installAgents, installAgentsMd, installSkill, installClineJson, installBizarFolder, installPluginBizar, installHeadroom, installSemble, installSkillsCli, installCuratedSkills, installRules, installHooks, installCommands, installCommandsBizar, mergeToolsIntoUserConfig } from './copy.mjs';
 
 const AGENT_FILES = [
@@ -27,8 +27,12 @@ const AGENT_FILES = [
 ];
 
 /**
- * Install the Bizar cline plugin from this package's own
- * `plugins/bizar/` directory into `~/.config/cline/plugins/bizar/`.
+ * Install the Bizar MCP server from this package's own `plugins/bizar/`
+ * directory into `~/.claude/plugins/bizar/`.
+ *
+ * v6.3.0 — Bizar is Claude Code-native. The plugin entry-point still
+ * ships at `plugins/bizar/` as a back-compat shim that re-exports the
+ * SDK; the actual MCP server lives in `packages/sdk/src/mcp/bin.ts`.
  *
  * v4.0.0 consolidated everything into one npm package, so the plugin
  * source ships with `@polderlabs/bizar` itself — no separate
@@ -44,8 +48,8 @@ const AGENT_FILES = [
  * workspace-internal package not on the public registry. After copying
  * the plugin files, this function ALSO copies the source's `node_modules/`
  * to the deployed `node_modules/` so Bun can resolve the import when the
- * plugin is loaded from `~/.config/cline/plugins/bizar/`. Without
- * this, the plugin silently fails to load.
+ * plugin is loaded from `~/.claude/plugins/bizar/`. Without this, the
+ * plugin silently fails to load.
  *
  * Pass `{ silent: true }` to suppress the warning prints; the function
  * still returns `true` if the dest is already in the desired state.
@@ -65,7 +69,7 @@ export async function installPluginFromGlobal(opts = {}) {
   // A plain copy would dereference the symlink and silently break the
   // dev workflow. Print a hint unless silent, or honour an explicit
   // --force from the caller.
-  const destDir = join(clineConfigDir(), 'plugins', 'bizar');
+  const destDir = join(claudeConfigDir(), 'plugins', 'bizar');
   let destIsSymlink = false;
   try {
     destIsSymlink = lstatSync(destDir).isSymbolicLink();
@@ -81,7 +85,7 @@ export async function installPluginFromGlobal(opts = {}) {
     }
     console.log(
       chalk.yellow(
-        '  ⚠ ~/.config/cline/plugins/bizar is a dev symlink — skipping copy.',
+        '  ⚠ ~/.claude/plugins/bizar is a dev symlink — skipping copy.',
       ),
     );
     console.log(
@@ -197,11 +201,11 @@ export async function installPluginFromGlobal(opts = {}) {
       }
     }
 
-    // Wire runtime deps (`zod` plus `@cline/sdk`, `@cline/core`,
-    // `@cline/shared`) into the deployed plugin's `node_modules/`.
+    // Wire runtime deps (`zod` plus `@anthropic-ai/claude-agent-sdk`)
+    // into the deployed plugin's `node_modules/`.
     // Bun's module resolver walks up from the plugin entry point
     // looking for `node_modules/`, and without entries there the
-    // plugin throws `Cannot find module 'zod' (+2 more)` at startup.
+    // plugin throws `Cannot find module 'zod'` at startup.
     //
     // The resolution logic lives in `cli/plugin-runtime-deps.mjs` and
     // is shared with the modern provisioner (`cli/provision.mjs`). It
@@ -479,46 +483,38 @@ async function promptGraphifyInstall() {
 }
 
 export async function runPostInstall() {
-  // v6.1.0 — Bizar is Cline-only. The legacy opencode-era
-  // `promptAndInstallOptional()` (plugin/dashboard presence probes)
-  // has been removed; `cli/provision.mjs:runProvision` covers the same
-  // surface via `runProvision({ mode: 'install' })`, which is the path
+  // v6.3.0 — Bizar is Claude Code-native. `cli/provision-claude.mjs:runProvision`
+  // covers the install/update/validate surface and is the primary path
   // used by `bizar install` and `bizar update`. This `runPostInstall`
-  // is now a thin Cline-only bootstrap that:
-  //   - copies `config/cline.json` template on first install
-  //   - runs `installCommandsBizar()` for the legacy `commands-bizar/` dir
-  //   - installs agents into `~/.cline/agents/`
+  // is a thin Claude Code-native bootstrap that:
+  //   - copies `config/settings.json` template on first install
+  //   - installs agents into `~/.claude/agents/`
   //   - probes for headroom / semble / skills-cli
   //   - installs Headroom via pip or npm
-  // The old OpenCode-era probes (`Plugin source present`,
-  // `Dashboard source present`) moved to `cli/doctor.mjs` as live checks.
   const { mkdirSync, copyFileSync, existsSync } = await import('node:fs');
   const { execSync } = await import('node:child_process');
 
-  const dest = join(clineConfigDir(), 'cline.json');
-  const templateSrc = repoPath('config', 'cline.json');
+  const dest = join(claudeConfigDir(), 'settings.json');
+  const templateSrc = repoPath('config', 'settings.json');
   if (!existsSync(dest)) {
     if (existsSync(templateSrc)) {
-      mkdirSync(clineConfigDir(), { recursive: true });
+      mkdirSync(claudeConfigDir(), { recursive: true });
       copyFileSync(templateSrc, dest);
-      console.log('  ✓ cline.json bootstrapped from package template');
+      console.log('  ✓ settings.json bootstrapped from package template');
     }
   }
 
-  // Install Bizar commands to commands-bizar/ (separate from ECC's commands symlink)
-  await installCommandsBizar();
-
-  const env = await detectCline();
+  const env = await detectClaude();
   if (!env.exists) {
-    mkdirSync(clineConfigDir(), { recursive: true });
-    console.log(`BizarHarness: created ${clineConfigDir()}/`);
+    mkdirSync(claudeConfigDir(), { recursive: true });
+    console.log(`BizarHarness: created ${claudeConfigDir()}/`);
   }
 
-  mkdirSync(clineAgentsDir(), { recursive: true });
+  mkdirSync(claudeAgentsDir(), { recursive: true });
 
   for (const file of AGENT_FILES) {
     const src = repoPath('config', 'agents', file);
-    const dest = join(clineAgentsDir(), file);
+    const dest = join(claudeAgentsDir(), file);
     if (!existsSync(dest)) {
       copyFileSync(src, dest);
     }
@@ -537,14 +533,14 @@ export async function runPostInstall() {
           'pip install --user "headroom-ai[all]"',
           { stdio: 'pipe', timeout: 60000 },
         );
-        execSync('headroom wrap cline', { stdio: 'pipe' });
+        execSync('headroom wrap claude', { stdio: 'pipe' });
         console.log('BizarHarness: Headroom installed and configured.');
       }
     } catch {
       // Fall back to npm
       try {
         execSync('npm install -g headroom-ai', { stdio: 'pipe', timeout: 60000 });
-        execSync('headroom wrap cline', { stdio: 'pipe' });
+        execSync('headroom wrap claude', { stdio: 'pipe' });
         console.log('BizarHarness: Headroom installed (npm) and configured.');
       } catch {
         console.log('BizarHarness: Headroom install failed. Install manually: pip install "headroom-ai[all]" or npm install -g headroom-ai');
@@ -552,10 +548,10 @@ export async function runPostInstall() {
     }
   } else {
     try {
-      execSync('headroom wrap cline', { stdio: 'pipe' });
-      console.log('BizarHarness: Headroom configured for cline.');
+      execSync('headroom wrap claude', { stdio: 'pipe' });
+      console.log('BizarHarness: Headroom configured for claude.');
     } catch {
-      console.log('BizarHarness: could not configure Headroom. Run `headroom wrap cline` manually.');
+      console.log('BizarHarness: could not configure Headroom. Run `headroom wrap claude` manually.');
     }
   }