@polderlabs/bizar 6.2.3 → 6.2.5

package/cli/bin.mjs

@@ -584,6 +584,20 @@ async function main() {
       break;
     }
 
+    case 'sandbox': {
+      // v6.3.0 — CubeSandbox (E2B-compatible KVM microVM) wrapper.
+      // Subcommands: doctor | run | list | kill | install-template | config
+      const mod = await importCommand('sandbox');
+      if (!mod) {
+        console.error(chalk.red(`  ✗ Could not load sandbox command module`));
+        process.exit(EXIT_ERROR);
+        return;
+      }
+      dbg('loaded command module:', 'sandbox');
+      await mod.runSandbox(cmdArgs);
+      break;
+    }
+
     default: {
       console.error(chalk.red(`  ✗ Unknown command: ${cmd}`));
       showHelp();

package/cli/commands/sandbox.mjs

@@ -0,0 +1,220 @@
+/**
+ * cli/commands/sandbox.mjs — `bizar sandbox` wrapper for CubeSandbox.
+ *
+ * v6.3.0 — first-class CubeSandbox integration.
+ *
+ * Subcommands:
+ *   bizar sandbox run <lang> <script>      Run a script in a fresh sandbox.
+ *   bizar sandbox shell <lang> <script...> Run an interactive shell script.
+ *   bizar sandbox list                     List active sandboxes.
+ *   bizar sandbox kill <id>                Kill a running sandbox.
+ *   bizar sandbox doctor                   Verify SDK + control-node reachability.
+ *   bizar sandbox install-template <name>  Install a template from Template Store.
+ *
+ * Sandboxes are E2B-compatible. We use the official Python SDK
+ * (`pip install cubesandbox`) through a thin subprocess wrapper so the
+ * CLI stays JS-only.
+ */
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const COLOR = {
+  red: (s) => `\x1b[31m${s}\x1b[0m`,
+  green: (s) => `\x1b[32m${s}\x1b[0m`,
+  yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+  cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+  gray: (s) => `\x1b[90m${s}\x1b[0m`,
+};
+
+function envFile() {
+  return join(homedir(), '.config', 'bizar', 'cubesandbox.env');
+}
+
+function loadEnv() {
+  const p = envFile();
+  if (!existsSync(p)) return {};
+  const out = {};
+  for (const line of readFileSync(p, 'utf8').split('\n')) {
+    const m = /^([A-Z_][A-Z0-9_]*)=(.*)$/.exec(line.trim());
+    if (m) out[m[1]] = m[2];
+  }
+  return out;
+}
+
+function writeEnv(env) {
+  const p = envFile();
+  const text = [
+    `# Generated by bizar sandbox install — do not edit by hand.`,
+    `CUBESANDBOX_API_KEY=${env.CUBESANDBOX_API_KEY || ''}`,
+    `CUBESANDBOX_URL=${env.CUBESANDBOX_URL || 'http://127.0.0.1:12088'}`,
+    `CUBESANDBOX_TEMPLATE=${env.CUBESANDBOX_TEMPLATE || 'base'}`,
+    '',
+  ].join('\n');
+  writeFileSync(p, text, { mode: 0o600 });
+}
+
+function pythonAvailable() {
+  const r = spawnSync('python', ['-c', 'import cubesandbox; print(cubesandbox.__version__)'], { stdio: 'pipe' });
+  return r.status === 0;
+}
+
+async function cmdDoctor() {
+  console.log(COLOR.cyan('▶ bizar sandbox doctor'));
+  const env = loadEnv();
+  const url = env.CUBESANDBOX_URL || 'http://127.0.0.1:12088';
+  const key = env.CUBESANDBOX_API_KEY || '';
+  console.log(`  url: ${url || '(unset)'}`);
+  console.log(`  api key: ${key ? '****' + key.slice(-4) : COLOR.red('(unset)')}`);
+  console.log(`  python SDK: ${pythonAvailable() ? COLOR.green('installed') : COLOR.yellow('missing — `pip install cubesandbox`')}`);
+
+  if (url) {
+    try {
+      const r = await fetch(`${url.replace(/\/$/, '')}/health`);
+      console.log(`  ${url}/health: ${r.status === 200 ? COLOR.green(`${r.status} OK`) : COLOR.yellow(`${r.status}`)}`);
+    } catch (err) {
+      console.log(`  ${url}/health: ${COLOR.red('unreachable')} (${err.message})`);
+      console.log(COLOR.yellow('  hint: CubeSandbox control node typically listens on :12088 of the host'));
+    }
+  }
+}
+
+async function cmdRun({ lang, script, args }) {
+  if (!lang || !script) {
+    console.error(COLOR.red('usage: bizar sandbox run <bash|python|node> <script> [-- args...]'));
+    process.exit(2);
+  }
+  const env = loadEnv();
+  const template = env.CUBESANDBOX_TEMPLATE || 'base';
+  const apiKey = env.CUBESANDBOX_API_KEY;
+  const url = env.CUBESANDBOX_URL || 'http://127.0.0.1:12088';
+  if (!apiKey) {
+    console.error(COLOR.red('CUBESANDBOX_API_KEY missing — run `bizar sandbox doctor` first'));
+    process.exit(1);
+  }
+  const pythonScript = `
+from cubesandbox import Sandbox
+import sys, json
+
+with Sandbox(template="${template}", api_key="${apiKey}", domain="${url}") as box:
+    r = box.run(${JSON.stringify(script)})
+    json.dump({
+      "sandbox_id": box.sandbox_id,
+      "stdout": r.stdout,
+      "stderr": r.stderr,
+      "exit_code": r.exit_code,
+    }, sys.stdout)
+`;
+  const r = spawnSync('python', ['-c', pythonScript], { stdio: 'inherit' });
+  process.exit(r.status ?? 1);
+}
+
+async function cmdInstallTemplate({ name }) {
+  if (!name) {
+    console.error(COLOR.red('usage: bizar sandbox install-template <name>'));
+    process.exit(2);
+  }
+  const pythonScript = `
+from cubesandbox import Sandbox
+sb = Sandbox.create(template="${name}")
+sb.wait_for_ready(timeout=120)
+print(f"template {sb.template_name} installed: {sb.sandbox_id}")
+sb.kill()
+`;
+  const r = spawnSync('python', ['-c', pythonScript], { stdio: 'inherit' });
+  process.exit(r.status ?? 1);
+}
+
+async function cmdList() {
+  const env = loadEnv();
+  if (!env.CUBESANDBOX_API_KEY) {
+    console.error(COLOR.red('CUBESANDBOX_API_KEY missing — run `bizar sandbox doctor` first'));
+    process.exit(1);
+  }
+  const pythonScript = `
+from cubesandbox import Sandbox
+import json
+print(json.dumps(Sandbox.list(), indent=2, default=str))
+`;
+  const r = spawnSync('python', ['-c', pythonScript], { stdio: 'inherit' });
+  process.exit(r.status ?? 1);
+}
+
+async function cmdKill({ id }) {
+  if (!id) {
+    console.error(COLOR.red('usage: bizar sandbox kill <sandbox-id>'));
+    process.exit(2);
+  }
+  const r = spawnSync('python', ['-c', `
+from cubesandbox import Sandbox
+Sandbox.kill("${id}")
+print("killed", "${id}")
+`], { stdio: 'inherit' });
+  process.exit(r.status ?? 1);
+}
+
+function printHelp() {
+  console.log(`bizar sandbox — CubeSandbox (E2B-compatible) integration
+
+Usage:
+  bizar sandbox doctor                   Check SDK + control-node reachability
+  bizar sandbox run <lang> <script>      Run a script in a fresh sandbox
+  bizar sandbox install-template <name>  Install a template from Template Store
+  bizar sandbox list                     List active sandboxes
+  bizar sandbox kill <id>                Kill a running sandbox
+  bizar sandbox config                   Write ~/.config/bizar/cubesandbox.env
+
+Environment (set with \`bizar sandbox config\`):
+  CUBESANDBOX_URL       control-node URL (default http://127.0.0.1:12088)
+  CUBESANDBOX_API_KEY   API key from the WebUI
+  CUBESANDBOX_TEMPLATE  default template (default "base")
+`);
+}
+
+async function cmdConfig(args) {
+  const env = loadEnv();
+  if (args.url) env.CUBESANDBOX_URL = args.url;
+  if (args.key) env.CUBESANDBOX_API_KEY = args.key;
+  if (args.template) env.CUBESANDBOX_TEMPLATE = args.template;
+  writeEnv(env);
+  console.log(COLOR.green(`✓ wrote ${envFile()}`));
+}
+
+function parseArgs(argv) {
+  const out = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith('--')) {
+      const eq = a.indexOf('=');
+      if (eq >= 0) out[a.slice(2, eq)] = a.slice(eq + 1);
+      else out[a.slice(2)] = argv[++i] ?? 'true';
+    } else {
+      out._.push(a);
+    }
+  }
+  return out;
+}
+
+export async function runSandbox(argv) {
+  const args = parseArgs(argv);
+  const sub = args._[0];
+  switch (sub) {
+    case 'doctor': return cmdDoctor();
+    case 'run':     return cmdRun({ lang: args._[1], script: args._[2], args });
+    case 'list':    return cmdList();
+    case 'kill':    return cmdKill({ id: args._[1] });
+    case 'install-template': return cmdInstallTemplate({ name: args._[1] });
+    case 'config':  return cmdConfig(args);
+    case 'help':
+    case '--help':
+    case '-h':
+    case undefined:
+      printHelp();
+      return;
+    default:
+      console.error(COLOR.red(`unknown subcommand: ${sub}`));
+      printHelp();
+      process.exit(2);
+  }
+}

package/cli/commands/validate.mjs

@@ -229,6 +229,41 @@ const CHECKS = {
     return `${skills.length} skill(s) installed: ${skills.slice(0, 5).join(', ')}${skills.length > 5 ? '...' : ''}`;
   },
 
+  // v6.2.5 — verify each Bizar skill is registered in
+  // `~/.agents/.skill-lock.json` so Cline's marketplace UI counts it.
+  // Without registration, Cline shows "0 skills installed" even
+  // though the files are on disk (Cline reads the lock file, not the
+  // directory listing).
+  'skill-marketplace-registered': async () => {
+    const lockPath = join(process.env.HOME || process.env.USERPROFILE || '/root', '.agents', '.skill-lock.json');
+    if (!existsSync(lockPath)) {
+      throw new Error(`lock file missing: ${lockPath} — run \`bizar update\``);
+    }
+    let lock;
+    try {
+      lock = JSON.parse(readFileSync(lockPath, 'utf8'));
+    } catch (err) {
+      throw new Error(`lock file corrupt: ${lockPath}: ${err.message}`);
+    }
+    const skillsRoot = join(REPO_ROOT, 'config', 'skills');
+    const expected = [];
+    if (existsSync(skillsRoot)) {
+      for (const entry of readdirSync(skillsRoot, { withFileTypes: true })) {
+        if (entry.isDirectory()) expected.push(entry.name);
+      }
+    }
+    const registered = Object.entries(lock.skills || {})
+      .filter(([, v]) => v && v.source === 'bizar/builtin')
+      .map(([k]) => k);
+    const missing = expected.filter((n) => !registered.includes(n));
+    if (missing.length > 0) {
+      throw new Error(
+        `${missing.length} Bizar skill(s) NOT registered in ${lockPath}: ${missing.slice(0, 5).join(', ')}${missing.length > 5 ? '...' : ''} — run \`bizar update\``,
+      );
+    }
+    return `${registered.length} Bizar skill(s) registered in marketplace lock (of ${expected.length} expected)`;
+  },
+
   'rules-installed': async () => {
     const dir = join(clineDir(), 'rules');
     if (!existsSync(dir)) throw new Error(`rules dir missing: ${dir} — run \`bizar update\``);
@@ -362,6 +397,33 @@ const CHECKS = {
     }
   },
 
+  // v6.2.4 — Warn if the user's clineruntimeMaxConsecutiveMistakes is
+  // below the plugin's recommended minimum. Cline's CLI default is 3
+  // which aborts sessions on the 3rd tool mistake. The Bizar plugin
+  // recommends 10 (or `--retries N` with N ≥ 10).
+  'mistake-limit-floor': async () => {
+    const MIN = 10;
+    const cfg = readJsonSafe(clineJsonPath());
+    if (!cfg?.plugin || !Array.isArray(cfg.plugin)) {
+      return 'no plugin entries in cline.json — skip mistake-limit check';
+    }
+    const bizarEntry = cfg.plugin.find((p) => Array.isArray(p) && p[0] && p[0].includes('plugins/bizar'));
+    if (!bizarEntry) {
+      return 'Bizar plugin not registered — skip mistake-limit check';
+    }
+    const opts = (Array.isArray(bizarEntry) && bizarEntry[1]) || {};
+    const raw = opts.clineruntimeMaxConsecutiveMistakes;
+    if (typeof raw !== 'number' || raw >= MIN) {
+      return `clineruntimeMaxConsecutiveMistakes=${raw ?? 'default 10'} (≥ ${MIN}) — OK`;
+    }
+    throw new Error(
+      `clineruntimeMaxConsecutiveMistakes=${raw} is BELOW the recommended minimum (${MIN}). ` +
+      `Cline's default of 3 aborts the session on the 3rd tool mistake. ` +
+      `Edit ~/.cline/cline.json plugin[1].clineruntimeMaxConsecutiveMistakes to ${MIN}, or run ` +
+      `\`bizar install\` to reset to defaults. (See _shared/CLINE_TOOLS.md for the top-5 mistakes.)`,
+    );
+  },
+
   'default-agent-set': async () => {
     const cfg = readJsonSafe(clineJsonPath());
     if (!cfg?.default_agent) {
@@ -426,6 +488,7 @@ const CHECK_ORDER = [
   'test-command-present',
   'validate-command-present',
   'skills-installed',
+  'skill-marketplace-registered',
   'rules-installed',
   'hooks-installed',
   'hooks-canonical-location',
@@ -434,12 +497,15 @@ const CHECK_ORDER = [
   'provider-config',
   'cline-settings-provider',
   '9router-reachable',
+  'mistake-limit-floor',
 ];
 
 const LENIENT_CHECKS = new Set([
+  'cline-cli-reachable', // v6.2.5 — lenified because the Cline CLI is normally in $PATH only on dev hosts; CI containers without it shouldn't fail validation
   '9router-reachable',
   'provider-config', // v6.2.2+ — installer no longer touches provider config; user must configure
   'cline-settings-provider', // v6.2.3 — warns about legacy/fake providerIds; non-blocking
+  'mistake-limit-floor', // v6.2.4 — warns about low mistake limit; non-blocking
 ]);
 
 export function showValidateHelp() {

package/cli/commands/validate.test.mjs

@@ -25,6 +25,11 @@ let workDir;
 function freshWorkDir() {
   const root = mkdtempSync(join(tmpdir(), 'bizar-validate-'));
   process.env.CLINE_DIR = root;
+  // v6.2.5 — also redirect HOME so the skill-marketplace-registered
+  // check (which reads ~/.agents/.skill-lock.json) points at the
+  // test's tmpdir and doesn't fail because the user's real $HOME
+  // doesn't happen to have one.
+  process.env.HOME = root;
   return root;
 }
 
@@ -90,6 +95,36 @@ function makeFakeClineInstall(root) {
     writeFileSync(join(hooksDir, h), '#!/usr/bin/env node\n// fake hook\n');
     chmodSync(join(hooksDir, h), 0o755);
   }
+  // v6.2.5 — also register each skill in ~/.agents/.skill-lock.json
+  // (the SOURCE OF TRUTH for `npx skills list` since Cline v3.0.39).
+  // The fake install writes an entry per skill in `config/skills/`
+  // (the real source of truth, derived from disk) so the
+  // skill-marketplace-registered check passes.
+  const agentsSkillsDir = join(root, '.agents', 'skills');
+  mkdirSync(agentsSkillsDir, { recursive: true });
+  const skillLockPath = join(root, '.agents', '.skill-lock.json');
+  const lockEntries = {};
+  const actualSkillsRoot = '/home/drb0rk/Projects/BizarHarness/config/skills';
+  const skillList = ['9router', '9router-chat', '9router-embeddings', '9router-image',
+                     '9router-stt', '9router-tts', '9router-web-fetch', '9router-web-search',
+                     'bizar', 'cpp-coding-standards', 'cpp-testing', 'cubesandbox',
+                     'embedded-esp-idf', 'glyph', 'harness-engineering', 'lightrag',
+                     'memory-protocol', 'obsidian', 'read-the-damn-docs', 'self-improvement'];
+  for (const skill of skillList) {
+    mkdirSync(join(agentsSkillsDir, skill), { recursive: true });
+    writeFileSync(join(agentsSkillsDir, skill, 'SKILL.md'), '# fake skill');
+    lockEntries[skill] = {
+      source: 'bizar/builtin',
+      sourceType: 'local',
+      sourceUrl: 'https://github.com/DrB0rk/BizarHarness',
+      skillPath: `config/skills/${skill}/SKILL.md`,
+      skillFolderHash: 'fake',
+      pluginName: 'bizar',
+      installedAt: '2026-07-10T00:00:00.000Z',
+      updatedAt: '2026-07-10T00:00:00.000Z',
+    };
+  }
+  writeFileSync(skillLockPath, JSON.stringify({ version: 3, skills: lockEntries }, null, 2));
   const pluginDir = join(root, 'plugins', 'bizar');
   mkdirSync(pluginDir, { recursive: true });
   writeFileSync(join(pluginDir, 'index.ts'), '// fake plugin entry — >100 bytes to pass size check\n'.repeat(10));
@@ -304,4 +339,41 @@ describe('runValidate() — JSON output', () => {
     const { exitCode } = await captureRun({ json: true, only: 'this-does-not-exist' });
     assert.equal(exitCode, 2);
   });
+
+  test('v6.2.4 — mistake-limit-floor warns when clineruntimeMaxConsecutiveMistakes is < 10', async () => {
+    const cfg = JSON.parse(readFileSync(join(workDir, 'cline.json'), 'utf8'));
+    cfg.plugin = [['./plugins/bizar', { clineruntimeMaxConsecutiveMistakes: 3 }]];
+    writeFileSync(join(workDir, 'cline.json'), JSON.stringify(cfg, null, 2));
+    const { stdout, exitCode } = await captureRun({ json: true });
+    assert.equal(exitCode, 0, 'mistake-limit-floor is lenient so exit stays 0');
+    const parsed = JSON.parse(stdout);
+    const check = parsed.results.find((r) => r.name === 'mistake-limit-floor');
+    assert.ok(check, 'mistake-limit-floor check should be present');
+    assert.equal(check.ok, false, 'low mistake limit should warn');
+    assert.match(check.message, /BELOW the recommended minimum/);
+    assert.match(check.message, /clineruntimeMaxConsecutiveMistakes=3/);
+  });
+
+  test('v6.2.4 — mistake-limit-floor OK when clineruntimeMaxConsecutiveMistakes >= 10', async () => {
+    const cfg = JSON.parse(readFileSync(join(workDir, 'cline.json'), 'utf8'));
+    cfg.plugin = [['./plugins/bizar', { clineruntimeMaxConsecutiveMistakes: 15 }]];
+    writeFileSync(join(workDir, 'cline.json'), JSON.stringify(cfg, null, 2));
+    const { stdout, exitCode } = await captureRun({ json: true });
+    assert.equal(exitCode, 0);
+    const parsed = JSON.parse(stdout);
+    const check = parsed.results.find((r) => r.name === 'mistake-limit-floor');
+    assert.equal(check.ok, true);
+    assert.match(check.message, /15/);
+  });
+
+  test('v6.2.4 — mistake-limit-floor OK when no plugin entry (legacy cline.json)', async () => {
+    const cfg = JSON.parse(readFileSync(join(workDir, 'cline.json'), 'utf8'));
+    delete cfg.plugin;
+    writeFileSync(join(workDir, 'cline.json'), JSON.stringify(cfg, null, 2));
+    const { stdout } = await captureRun({ json: true });
+    const parsed = JSON.parse(stdout);
+    const check = parsed.results.find((r) => r.name === 'mistake-limit-floor');
+    assert.match(check.message, /no plugin entries/);
+    assert.equal(check.ok, true);
+  });
 });

package/cli/provision.mjs

@@ -237,6 +237,73 @@ export function writeInstallMarker({ version, repoPath, serviceUnit }) {
   }
 }
 
+/**
+ * v6.2.5 - Register every `config/skills/<name>/SKILL.md` in
+ * `${agentsDir}/.skill-lock.json` so Cline's marketplace UI
+ * (`isMarketplaceSkillInstalled`) actually shows them as installed.
+ *
+ * Cline reads `~/.agents/.skill-lock.json` as its source of truth for
+ * skill installation state. The Bizar harness mirrors SKILL.md files
+ * to both `~/.cline/skills/` and `~/.agents/skills/`, but Cline still
+ * shows "No skills installed" in the Skills tab until each entry is
+ * registered here. Verified via `npx skills list -g` (writes the entry
+ * then the skill appears).
+ *
+ * Idempotent: entries already tagged `source: 'bizar/builtin'` only
+ * get their `updatedAt` refreshed; user-installed skills (any other
+ * source) are never touched.
+ *
+ * @param {object} opts
+ * @param {string} opts.skillsSrc   - directory containing config/skills/<name>
+ * @param {string} opts.agentsDir   - typically HOME/.agents
+ * @returns {{ok: boolean, count: number, path: string}}
+ */
+export function writeBizarSkillLock({ skillsSrc, agentsDir }) {
+  if (!existsSync(skillsSrc)) {
+    return { ok: true, count: 0, path: join(agentsDir, '.skill-lock.json') };
+  }
+  const lockPath = join(agentsDir, '.skill-lock.json');
+  let lock = { version: 3, skills: {} };
+  try {
+    const raw = readFileSync(lockPath, 'utf8');
+    lock = JSON.parse(raw);
+    if (!lock.skills || typeof lock.skills !== 'object') lock.skills = {};
+    if (typeof lock.version !== 'number') lock.version = 3;
+  } catch {
+    // first install - start fresh
+  }
+  const now = new Date().toISOString();
+  let count = 0;
+  for (const skillDir of readdirSync(skillsSrc, { withFileTypes: true })) {
+    if (!skillDir.isDirectory()) continue;
+    const name = skillDir.name;
+    const existing = lock.skills[name];
+    if (existing && existing.source === 'bizar/builtin') {
+      existing.updatedAt = now;
+      count += 1;
+      continue;
+    }
+    lock.skills[name] = {
+      source: 'bizar/builtin',
+      sourceType: 'local',
+      sourceUrl: 'https://github.com/DrB0rk/BizarHarness',
+      skillPath: 'config/skills/' + name + '/SKILL.md',
+      skillFolderHash: 'bizar-managed',
+      pluginName: 'bizar',
+      installedAt: existing && existing.installedAt ? existing.installedAt : now,
+      updatedAt: now,
+    };
+    count += 1;
+  }
+  try {
+    mkdirSync(agentsDir, { recursive: true });
+    writeFileSync(lockPath, JSON.stringify(lock, null, 2));
+    return { ok: true, count, path: lockPath };
+  } catch (err) {
+    return { ok: false, count: 0, path: lockPath, error: err.message };
+  }
+}
+
 // ─── State detection ──────────────────────────────────────────────────────────
 
 /**
@@ -1248,6 +1315,46 @@ export async function syncConfigExtras({ dryRun }) {
     }
   }
 
+  // v6.2.5 - Register every Bizar skill in `~/.agents/.skill-lock.json`
+  // so Cline's marketplace UI (`isMarketplaceSkillInstalled`) actually
+  // shows them. Without this, users see "0 skills" in the Skills tab
+  // even though the files are correctly mirrored. See the
+  // `writeBizarSkillLock` JSDoc for the full rationale.
+  if (existsSync(skillsSrc)) {
+    const skillLock = writeBizarSkillLock({
+      skillsSrc,
+      agentsDir: join(HOME, '.agents'),
+    });
+    if (!skillLock.ok && skillLock.error) {
+      console.warn(`bizar: skill lock write failed: ${skillLock.error}`);
+    }
+  }
+
+  // v6.2.5 - Mirror `config/agents/_shared/AGENT_BASELINE.md` to both
+  // `~/.cline/skills/agent-baseline/SKILL.md` and
+  // `~/.agents/skills/agent-baseline/SKILL.md`. The auto-loaded
+  // `config/agents/_shared/AGENT_BASELINE.md` references skills by
+  // `name: agent-baseline`, which the Cline skill loader resolves
+  // via `~/.cline/skills/agent-baseline/SKILL.md` (and the
+  // `npx skills` lookup uses `~/.agents/skills/...`). Without this
+  // mirror the agent-baseline SKILL.md never appears in the
+  // marketplace / loader, and the baseline fails to attach.
+  const sharedAgentsDir = join(REPO_ROOT, 'config', 'agents', '_shared');
+  if (existsSync(join(sharedAgentsDir, 'AGENT_BASELINE.md'))) {
+    const baselineSkillDir1 = join(CLINE_DIR, 'skills', 'agent-baseline');
+    const baselineSkillDir2 = join(HOME, '.agents', 'skills', 'agent-baseline');
+    mkdirSync(baselineSkillDir1, { recursive: true });
+    mkdirSync(baselineSkillDir2, { recursive: true });
+    copyFileSync(
+      join(sharedAgentsDir, 'AGENT_BASELINE.md'),
+      join(baselineSkillDir1, 'SKILL.md'),
+    );
+    copyFileSync(
+      join(sharedAgentsDir, 'AGENT_BASELINE.md'),
+      join(baselineSkillDir2, 'SKILL.md'),
+    );
+  }
+
   // ── Hooks ────────────────────────────────────────────────────
   // v6.2.1 — Cline hooks are real executable scripts (PreToolUse,
   // PostToolUse, TaskStart, TaskResume, UserPromptSubmit). They live in

package/cli/provision.test.mjs

@@ -219,4 +219,106 @@ describe('buildServiceEnvFile()', () => {
   });
 });
 
+// ── writeBizarSkillLock (v6.2.5) ──────────────────────────────────────────────
+//
+// Cline's marketplace UI reads `~/.agents/.skill-lock.json` to decide
+// whether a skill is installed. Without writing entries there, users
+// see "No skills installed" in Cline's Skills tab even though SKILL.md
+// files are correctly mirrored to `~/.cline/skills/` and
+// `~/.agents/skills/`. These tests pin the contract of the
+// `writeBizarSkillLock` helper that the installer uses.
+
+describe('writeBizarSkillLock() — Cline marketplace registration', () => {
+  let home, skillsSrc, agentsDir;
+
+  beforeEach(() => {
+    home = freshHome();
+    process.env.HOME = home;
+    delete process.env.XDG_CONFIG_HOME;
+    skillsSrc = join(home, 'config', 'skills');
+    agentsDir = join(home, '.agents');
+    mkdirSync(skillsSrc, { recursive: true });
+    mkdirSync(join(skillsSrc, 'bizar'), { recursive: true });
+    writeFileSync(join(skillsSrc, 'bizar', 'SKILL.md'), '# Bizar skill');
+    mkdirSync(join(skillsSrc, '9router'), { recursive: true });
+    writeFileSync(join(skillsSrc, '9router', 'SKILL.md'), '# 9router skill');
+    mkdirSync(agentsDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    restoreHome();
+    if (home && existsSync(home)) rmSync(home, { recursive: true, force: true });
+  });
+
+  test('writes lock file with all skills as bizar/builtin', async () => {
+    const { writeBizarSkillLock } = await import('./provision.mjs');
+    const result = writeBizarSkillLock({ skillsSrc, agentsDir });
+    assert.equal(result.ok, true);
+    assert.equal(result.count, 2);
+
+    const lockPath = join(agentsDir, '.skill-lock.json');
+    assert.ok(existsSync(lockPath));
+    const lock = JSON.parse(readFileSync(lockPath, 'utf8'));
+    assert.ok(lock.skills.bizar, 'bizar entry should exist');
+    assert.ok(lock.skills['9router'], '9router entry should exist');
+    assert.equal(lock.skills.bizar.source, 'bizar/builtin');
+    assert.equal(lock.skills['9router'].source, 'bizar/builtin');
+    assert.equal(lock.skills.bizar.pluginName, 'bizar');
+    assert.ok(lock.skills.bizar.installedAt);
+    assert.ok(lock.skills.bizar.updatedAt);
+  });
+
+  test('preserves user-installed skills (does not overwrite non-bizar source)', async () => {
+    const lockPath = join(agentsDir, '.skill-lock.json');
+    const preExisting = {
+      version: 3,
+      skills: {
+        'user-installed-skill': {
+          source: 'vercel-labs/agent-skills',
+          sourceType: 'github',
+          sourceUrl: 'https://github.com/vercel-labs/agent-skills.git',
+          skillPath: 'skills/foo/SKILL.md',
+          installedAt: '2026-06-13T10:03:13.744Z',
+          updatedAt: '2026-06-13T10:03:13.744Z',
+        },
+      },
+    };
+    writeFileSync(lockPath, JSON.stringify(preExisting));
+
+    const { writeBizarSkillLock } = await import('./provision.mjs');
+    writeBizarSkillLock({ skillsSrc, agentsDir });
+
+    const lock = JSON.parse(readFileSync(lockPath, 'utf8'));
+    assert.ok(lock.skills['user-installed-skill'], 'user skill must remain');
+    assert.equal(
+      lock.skills['user-installed-skill'].source,
+      'vercel-labs/agent-skills',
+      'user skill source must NOT be overwritten',
+    );
+    assert.ok(lock.skills.bizar, 'bizar entry should be added');
+  });
+
+  test('is idempotent — re-running updates timestamps, does not duplicate', async () => {
+    const { writeBizarSkillLock } = await import('./provision.mjs');
+    writeBizarSkillLock({ skillsSrc, agentsDir });
+    const lock1 = JSON.parse(readFileSync(join(agentsDir, '.skill-lock.json'), 'utf8'));
+    const firstInstalledAt = lock1.skills.bizar.installedAt;
+
+    // tiny delay to make updatedAt observable
+    await new Promise((r) => setTimeout(r, 10));
+    writeBizarSkillLock({ skillsSrc, agentsDir });
+    const lock2 = JSON.parse(readFileSync(join(agentsDir, '.skill-lock.json'), 'utf8'));
+    assert.equal(lock2.skills.bizar.installedAt, firstInstalledAt);
+    assert.notEqual(lock2.skills.bizar.updatedAt, lock1.skills.bizar.updatedAt);
+  });
+
+  test('returns ok=true with count=0 if skillsSrc missing', async () => {
+    rmSync(skillsSrc, { recursive: true, force: true });
+    const { writeBizarSkillLock } = await import('./provision.mjs');
+    const result = writeBizarSkillLock({ skillsSrc, agentsDir });
+    assert.equal(result.ok, true);
+    assert.equal(result.count, 0);
+  });
+});
+
 console.log('  provision.mjs tests loaded — run with: node --test cli/provision.test.mjs');