@polderlabs/bizar 6.2.4 → 6.3.0

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');

package/cli/utils.mjs

@@ -15,30 +15,56 @@ export function repoPath(...parts) {
 }
 
 /**
- * Resolve the Cline global config directory.
-*
-  * Mirrors Cline's `resolveClineDir()` in `@cline/shared/storage`:
-  *   1. `process.env.CLINE_DIR` (explicit override)
-  *   2. `$HOME/.cline` (the Cline default since v3.0)
-  *
-  * v6.1.0 — Bizar is Cline-only. The pre-v5.6 `~/.config/cline/` path
-  * (the OpenCode-era layout) is no longer supported; the previous
-  * `legacyClineConfigDir()` helper has been removed.
-  */
-export function clineConfigDir() {
-  if (process.env.CLINE_DIR && process.env.CLINE_DIR.trim()) {
-    return process.env.CLINE_DIR.trim();
+ * Resolve the Claude Code global config directory.
+ *
+ * v6.3.0 — Bizar is Claude Code-native. The legacy `~/.cline/`
+ * path is kept as a back-compat alias via the wrappers below.
+ *
+ *   1. `process.env.CLAUDE_CONFIG_DIR` (explicit override)
+ *   2. `$HOME/.claude` (Claude Code default)
+ */
+export function claudeConfigDir() {
+  if (process.env.CLAUDE_CONFIG_DIR && process.env.CLAUDE_CONFIG_DIR.trim()) {
+    return process.env.CLAUDE_CONFIG_DIR.trim();
   }
   if (isWin) {
     return process.env.APPDATA
-      ? join(process.env.APPDATA, 'cline')
-      : join(homedir(), '.cline');
+      ? join(process.env.APPDATA, 'claude')
+      : join(homedir(), '.claude');
   }
-  return join(homedir(), '.cline');
+  return join(homedir(), '.claude');
 }
 
+export function claudeAgentsDir() {
+  return join(claudeConfigDir(), 'agents');
+}
+
+export function claudeSkillsDir() {
+  return join(claudeConfigDir(), 'skills');
+}
+
+export function claudeCommandsDir() {
+  return join(claudeConfigDir(), 'commands');
+}
+
+export function claudeHooksDir() {
+  return join(claudeConfigDir(), 'hooks');
+}
+
+/**
+ * @deprecated v6.3.0 — Claude Code migration. Use `claudeConfigDir()`.
+ * Thin wrapper so older scripts that haven't been migrated keep working.
+ */
+export function clineConfigDir() {
+  return claudeConfigDir();
+}
+
+/**
+ * @deprecated v6.3.0 — Claude Code migration. Use `claudeAgentsDir()`.
+ * Thin wrapper so older scripts that haven't been migrated keep working.
+ */
 export function clineAgentsDir() {
-  return join(clineConfigDir(), 'agents');
+  return claudeAgentsDir();
 }
 
 async function tryReadVersion(filePath) {
@@ -58,53 +84,41 @@ function commandExists(command) {
   return probe.status === 0;
 }
 
+/**
+ * @deprecated v6.3.0 — Claude Code migration. Use `detectClaude()`.
+ * Probe for the legacy Cline CLI to power compat reports.
+ */
 export async function detectCline() {
-  const configDir = clineConfigDir();
-  const agentsDir = clineAgentsDir();
-
+  const configDir = claudeConfigDir();
+  const agentsDir = claudeAgentsDir();
   let exists = false;
   let version = '';
-
   try {
     await access(configDir, constants.F_OK);
     exists = true;
+  } catch {
+    exists = false;
+  }
+  return { exists, version, configDir, agentsDir };
+}
 
-    if (isWin) {
-      const winPaths = [
-        join(process.env.APPDATA || homedir(), 'npm', 'node_modules', 'cline', 'package.json'),
-        join(process.env.APPDATA || homedir(), 'npm', 'node_modules', 'cline', 'package.json'),
-        join(process.env.APPDATA || homedir(), 'npm-global', 'node_modules', 'cline', 'package.json'),
-        join(process.env.APPDATA || homedir(), 'npm-global', 'node_modules', 'cline', 'package.json'),
-        join(homedir(), 'node_modules', 'cline', 'package.json'),
-        join(homedir(), 'node_modules', 'cline', 'package.json'),
-      ];
-      for (const p of winPaths) {
-        version = await tryReadVersion(p);
-        if (version) break;
-      }
-    } else {
-      const posixPaths = [
-        join(homedir(), '.local', 'share', 'cline', 'package.json'),
-        join(homedir(), '.local', 'share', 'cline', 'package.json'),
-        '/usr/local/lib/node_modules/cline/package.json',
-        '/usr/local/lib/node_modules/cline/package.json',
-        '/usr/lib/node_modules/cline/package.json',
-        '/usr/lib/node_modules/cline/package.json',
-        join(homedir(), '.npm-global', 'lib', 'node_modules', 'cline', 'package.json'),
-        join(homedir(), '.npm-global', 'lib', 'node_modules', 'cline', 'package.json'),
-        join(homedir(), 'node_modules', 'cline', 'package.json'),
-        join(homedir(), 'node_modules', 'cline', 'package.json'),
-      ];
-      for (const p of posixPaths) {
-        version = await tryReadVersion(p);
-        if (version) break;
-      }
+/**
+ * Probe for the Claude Code CLI on PATH.
+ * Returns `{ exists, version }`. v6.3.0+ replacement for `detectCline()`.
+ */
+export async function detectClaude() {
+  let exists = false;
+  let version = '';
+  try {
+    const probe = spawnSync('claude', ['--version'], { encoding: 'utf8', timeout: 5000 });
+    if (probe.status === 0) {
+      exists = true;
+      version = (probe.stdout || probe.stderr || '').trim().split('\n')[0];
     }
   } catch {
     exists = false;
   }
-
-  return { exists, version, configDir, agentsDir };
+  return { exists, version, configDir: claudeConfigDir(), agentsDir: claudeAgentsDir() };
 }
 
 export async function detectHeadroom() {
@@ -133,7 +147,7 @@ export async function detectSkillsCli() {
 }
 
 export async function detectInstalledAgents() {
-  const agentsDir = clineAgentsDir();
+  const agentsDir = claudeAgentsDir();
   try {
     await access(agentsDir, constants.F_OK);
     return agentsDir;
@@ -148,9 +162,9 @@ export function buildSummary(components, agents, target, skillPacks = []) {
   if (components.includes('agents-md')) parts.push('AGENTS.md');
   if (components.includes('skill-bizar')) parts.push('bizar skill');
   if (components.includes('skill-improve')) parts.push('self-improvement skill');
-  if (components.includes('cline-json')) parts.push('cline.json');
+  if (components.includes('settings-json')) parts.push('settings.json');
   if (components.includes('bizar')) parts.push('.bizar/ folder');
-  if (components.includes('plugin-bizar')) parts.push('Bizar plugin');
+  if (components.includes('mcp-bizar')) parts.push('Bizar MCP server');
   if (components.includes('rules')) parts.push('rules');
   if (components.includes('hooks')) parts.push('hooks');
   if (components.includes('commands')) parts.push('commands');
@@ -167,7 +181,7 @@ export function buildSummary(components, agents, target, skillPacks = []) {
   };
 }
 
-// ── Path helpers ─────────────────────────────────────────────────────────────────
+// Path helpers
 
 /**
  * Return the platform-specific Bizar config directory.
@@ -204,4 +218,4 @@ export function whichPath(cmd) {
   } catch {
     return null;
   }
-}
+}

package/config/AGENTS.md

@@ -54,7 +54,7 @@ which skills 2>/dev/null
 skills list --json
 
 # View installed skill files
-ls ~/.cline/skills/<skill-name>/SKILL.md
+ls ~/.claude/skills/<skill-name>/SKILL.md
 ```
 
 ### How to Install
@@ -72,7 +72,7 @@ skills add <owner/repo> -s "<skill-name>" -y
 1. **Assess**: When given a task, consider whether a skill might exist for it
 2. **Check installed**: Run `skills list --json` to see what's already available
 3. **Try known repos**: Based on the task domain, attempt installation from known skill repos (e.g., `skills add supabase/agent-skills --all -y` for database work, `skills add vercel-labs/agent-skills --all -y` for frontend work)
-4. **Use**: After installing, the skill instructions are at `~/.cline/skills/<skill-name>/SKILL.md` — load them with the `skill` tool
+4. **Use**: After installing, the skill instructions are at `~/.claude/skills/<skill-name>/SKILL.md` — load them with the `skill` tool
 5. **Skip**: If no skill is found after trying likely repos, proceed without
 
 ### Known Skill Repositories by Domain
@@ -146,26 +146,26 @@ Odin (`@odin`) is the All-Father and primary/default agent. He analyzes each req
 
 ### Frigg
 
-- **Model**: `cline/deepseek-v4-flash-free` (via Cline Zen — free tier)
+- **Model**: `claude-3-5-haiku` (via Claude Code — Anthropic API, free tier)
 - **Use for**: Read-only codebase Q&A. Use `@frigg` to ask questions about the project and get answers with file references — never modifies anything.
 - **Mode**: Primary (directly selectable by the user via `@frigg`)
 - **Cost**: Free
 
 ### Vör
 
-- **Model**: `cline/deepseek-v4-flash-free` (via Cline Zen — free tier)
+- **Model**: `claude-3-5-haiku` (via Claude Code — Anthropic API, free tier)
 - **Use for**: Clarifying ambiguous or incomplete requests. First reads project context (`.bizar/PROJECT.md`, obsidian, project files), then only asks targeted, project-specific questions if still unclear. Never asks generic questions.
 - **Cost**: Free
 
 ### Heimdall
 
-- **Model**: `cline/deepseek-v4-flash-free` (via Cline Zen — free tier)
+- **Model**: `claude-3-5-haiku` (via Claude Code — Anthropic API, free tier)
 - **Use for**: Simple tasks, mechanical work, quick edits, file operations. The ever-watchful guardian.
 - **Cost**: Free
 
 ### Mimir
 
-- **Model**: `cline/deepseek-v4-flash-free` (via Cline Zen — free tier)
+- **Model**: `claude-3-5-haiku` (via Claude Code — Anthropic API, free tier)
 - **Use for**: Deep codebase research, exploration, documentation analysis. Semble-first search approach.
 - **Cost**: Free
 
@@ -207,7 +207,7 @@ Odin (`@odin`) is the All-Father and primary/default agent. He analyzes each req
 
 ### Routing Heuristic
 
-Odin dispatches all tasks to subagents via the `task` tool. When work items are **independent**, he launches them as **parallel `task` calls in a single message**.
+Odin dispatches all tasks to subagents via the Claude Code `Agent` tool. When work items are **independent**, he launches them as **parallel `Agent` calls in a single message** with `subagent_type` set to the target agent's name.
 
 **Before dispatching any task, Odin runs `bizar memory status` to confirm the vault is reachable.** No `bank_id` is needed — `bizar memory status` resolves everything from the project root.
 
@@ -285,25 +285,25 @@ From the project root, the user (or heimdall via `/init` or any other agent prom
 
 ## General Agent Baseline — Always-On Behavior
 
-This section is the single source of truth for every Bizar agent's behavior. It is **adapted from the upstream system prompt and translated to Bizar**. Every Claude-specific reference has been mapped to the Bizar equivalent (BizarHarness, cline, obsidian, Semble, Skills CLI, agent-browser, the cline tool set). All agents **MUST** follow these rules at all times.
+This section is the single source of truth for every Bizar agent's behavior. It is **adapted from the upstream system prompt and translated to Bizar**. Every Claude-specific reference has been mapped to the Bizar equivalent (BizarHarness, Claude Code, obsidian, Semble, Skills CLI, agent-browser, Claude Code's native tool set). All agents **MUST** follow these rules at all times.
 
-> **Tool name translation table** (used throughout this baseline):
+> **Tool name translation table** (used throughout this baseline): this section maps Claude.ai tool names (e.g. `view`) to Claude Code tool names (e.g. `Read`). Starting with v6.3.0 (DEC-011), Claude Code's native tools are the source of truth — the harness no longer maintains its own tool set. The Bizar column below is the Claude Code column when they match.
 >
-> | Upstream (Claude.ai) | Bizar equivalent |
+> | Upstream (Claude.ai) | Claude Code |
 > |---|---|
-> | `view` | `read` |
-> | `str_replace` | `edit` |
-> | `create_file` | `write` |
-> | `bash_tool` | `bash` |
-> | `web_search` | `websearch` (cline built-in) |
-> | `web_fetch` | `webfetch` (cline built-in) |
+> | `view` | `Read` |
+> | `str_replace` | `Edit` |
+> | `create_file` | `Write` |
+> | `bash_tool` | `Bash` |
+> | `web_search` | `WebSearch` |
+> | `web_fetch` | `WebFetch` |
 > | `present_files` | not applicable — Bizar delivers files via the dashboard (`@polderlabs/bizar-dash/src/server/routes/artifacts.mjs`) or by writing to the workspace |
-> | `image_search` / `places_*` / `weather_fetch` / `recipe_display_v0` / `fetch_sports_data` / `message_compose_v1` / `recommend_claude_apps` | not available in Bizar — do not assume these exist |
+> | `image_search` / `places_*` / `weather_fetch` / `recipe_display_v0` / `fetch_sports_data` / `message_compose_v1` / `recommend_claude_apps` | not available in Claude Code — do not assume these exist |
 > | `search_mcp_registry` / `suggest_connectors` | use the `skills` CLI (`skills add <owner/repo> -s <name>`) to discover and install skills instead |
-> | `ask_user_input_v0` | Bizar has a `question` tool — same shape, single high-value question |
-> | `skill` | `skill` — load a SKILL.md from `~/.cline/skills/<name>/` or installed equivalent |
-> | `task` (subagent dispatch) | `task` — same — used by Odin to dispatch subagents |
-> | MCP servers | `semble` (codebase search) and any user-added servers in `config/cline.json` |
+> | `ask_user_input_v0` | `AskUserQuestion` — single high-value question |
+> | `skill` | `Skill` — load a SKILL.md from `~/.claude/skills/<name>/` or `.claude/skills/<name>/` |
+> | `task` (subagent dispatch) | `Agent` (with `subagent_type`, `run_in_background`, `isolation: "worktree"`) — used by Odin to dispatch subagents |
+> | MCP servers | `semble` (codebase search) and any user-added servers in `.claude/mcp.json` |
 
 ### Simplicity Rule — do not overcomplicate
 
@@ -321,7 +321,7 @@ This section is the single source of truth for every Bizar agent's behavior. It
 
 ### Identity preamble
 
-- Bizar is a Norse-pantheon multi-agent system for cline. Odin is the default primary agent; Frigg, Vör, Mimir, Heimdall, Hermod, Thor, Baldr, Tyr, Vidarr, and Forseti are the subagents.
+- Bizar is a Norse-pantheon multi-agent system for Claude Code. Odin is the default primary agent; Frigg, Vör, Mimir, Heimdall, Hermod, Thor, Baldr, Tyr, Vidarr, and Forseti are the subagents.
 - The agent does not have a fixed identity outside its role definition. Do not claim to be Claude, Anthropic, or any other AI.
 - Treat the user as a capable adult working on engineering work unless the context clearly indicates otherwise.
 
@@ -388,7 +388,7 @@ This section is the single source of truth for every Bizar agent's behavior. It
 - For facts that change quickly (current positions, prices, breaking news) or anything that could have changed recently, **search before answering**: use `websearch` and `webfetch` or delegate to `@mimir` for deep research.
 - For stable technical knowledge (language semantics, well-established APIs, mathematical truths), answer directly without search.
 - Default to running `bizar memory search "<topic>"` at session start to retrieve prior project context before answering anything project-specific.
-- When formulating date-sensitive queries, use the actual current date (Bizar's cline environment provides this). Do not hardcode years.
+- When formulating date-sensitive queries, use the actual current date (Bizar's Claude Code environment provides this). Do not hardcode years.
 - Do not over-rely on memory; if uncertain, search. Confabulating costs the user more than searching.
 
 ### mcp_servers_and_skills
@@ -407,7 +407,7 @@ The `skills` CLI (`npm install -g skills`) installs skill packs from skills.sh.
 ```bash
 which skills 2>/dev/null
 skills list --json
-ls ~/.cline/skills/<skill-name>/SKILL.md
+ls ~/.claude/skills/<skill-name>/SKILL.md
 ```
 
 If not installed but relevant, install it from a known repo by domain:
@@ -424,7 +424,7 @@ Load the SKILL.md via the `skill` tool before writing code or making changes cov
 
 #### Browser interaction
 
-For browser-driven E2E validation, use **agent-browser** (the Python tool from https://github.com/browser-use/agent-browser). Invoke via `bash` heredoc:
+For browser-driven E2E validation, use **agent-browser** (the Rust-native tool from https://github.com/vercel-labs/agent-browser; the earlier Python build at https://github.com/browser-use/agent-browser is archived as of the v6.0.0 migration). Invoke via `bash` heredoc:
 
 ```bash
 agent-browser <<'PY'
@@ -434,7 +434,7 @@ print(page_info())
 PY
 ```
 
-Common operations: `new_tab`, `goto_url`, `wait_for_load`, `page_info`, `click_at_xy`, `fill_input`, `press_key`, `scroll`, `capture_screenshot`, `js`, `cdp("Domain.method", ...)`. Read the SKILL.md at `~/.cline/skills/agent-browser/SKILL.md` on first use. Do **not** install headless Chrome via raw shell commands when agent-browser is available.
+Common operations: `new_tab`, `goto_url`, `wait_for_load`, `page_info`, `click_at_xy`, `fill_input`, `press_key`, `scroll`, `capture_screenshot`, `js`, `cdp("Domain.method", ...)`. Read the SKILL.md at `~/.claude/skills/agent-browser/SKILL.md` on first use. Do **not** install headless Chrome via raw shell commands when agent-browser is available.
 
 ### skills_mandatory_read
 
@@ -445,8 +445,8 @@ Concrete triggers:
 - Backend/API work → framework-specific skill
 - Browser E2E → `agent-browser` SKILL.md
 - Skill creation → `skill-creator` SKILL.md
-- BizarHarness-specific work → `~/.cline/skills/bizar/` SKILL.md (always)
-- Self-improvement logging → `~/.cline/skills/self-improvement/` SKILL.md (always)
+- BizarHarness-specific work → `~/.claude/skills/bizar/` SKILL.md (always)
+- Self-improvement logging → `~/.claude/skills/self-improvement/` SKILL.md (always)
 
 ### file_creation_advice