@polderlabs/bizar 10.23.22 → 10.23.23

package/AGENTS.md

@@ -58,13 +58,15 @@ still deny prohibited actions and escalate externally visible or irreversible
 actions with `permissionDecision: "ask"`; that escalation list is the
 authoritative floor, not a starting point.
 
-Mike selects the coordination mode after bounded read-only orientation and one
-user clarification checkpoint: direct work only for an unmistakably tiny
-single-target copy/style/format edit; one isolated Agent for a clear bounded
-change; a native workflow for repeatable phased work; parallel Agents for
-disjoint scopes; and an Agent team for 3+ sustained roles that genuinely need
-cross-talk. Do not add unnecessary phases or duplicate workers. The team is
-host-side state under `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`, and per
+Mike performs bounded read-only orientation, then uses a native Agent team as
+the default for substantive work. Direct work is reserved for an unmistakably
+tiny single-target copy/style/format edit or the user's explicit `/quick`
+request. A single Agent or native workflow is used only when the user
+explicitly requests that mode or a durable workflow must be resumed. Ask one
+concise clarification question only when a material choice, acceptance
+criterion, safety boundary, or unresolved constraint would change the work;
+otherwise continue autonomously. The team is host-side state under
+`CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`, and per
 Anthropic's docs `team_name` is deprecated and ignored. Every editing dispatch
 uses an explicit configured model and call-level `isolation: "worktree"`.
 When two or more subtasks have non-overlapping writable scopes and no data
@@ -133,13 +135,14 @@ The autonomy and approval policy above governs this execution model. The project
 Every non-empty primary request enters Bizar through `office-manager` (`@mike`).
 The installer sets Claude Code's global `agent` setting to Mike's frontmatter
 name (`mike`),
-and the routing hook supplies the adaptive coordination policy. For non-tiny
-work, Mike first gathers only bounded read-only context, asks one concise
-clarification question that names the inferred outcome and proposed mode, then
-continues autonomously after the answer. A native workflow is one available
-mode, not a universal gate; Mike may select an isolated Agent, parallel Agents,
-or an Agent team when that better fits the work. Mike owns integration and
-final verification.
+and the routing hook supplies the team-first coordination policy. For non-tiny
+work, Mike first gathers only bounded read-only context. When the inferred
+outcome, acceptance criteria, and safety boundary are clear, it forms the
+default Agent team and continues autonomously. It asks one concise
+clarification only when a material choice or unresolved constraint would
+change the work. `/quick` explicitly selects direct primary-session execution;
+single Agents and native workflows are explicit or resumed modes. Mike owns
+integration and final verification.
 A Bizar custom agent already executing its assigned role does not recursively
 dispatch itself.
 

package/README.md

@@ -1,92 +1,231 @@
-# Bizar Harness
+<div align="center">
+
+```text
+██████╗ ██╗███████╗ █████╗ ██████╗
+██╔══██╗██║╚══███╔╝██╔══██╗██╔══██╗
+██████╔╝██║  ███╔╝ ███████║██████╔╝
+██╔══██╗██║ ███╔╝  ██╔══██║██╔══██╗
+██████╔╝██║███████╗██║  ██║██║  ██║
+╚═════╝ ╚═╝╚══════╝╚═╝  ╚═╝╚═╝  ╚═╝
+```
+
+### Guarded autonomy for Claude Code
+
+Choose your models once. Give Claude Code real work. Bizar supplies the routing,
+specialists, guardrails, and evidence to carry it through responsibly.
+
+`84 agents` · `80 skills` · `33 commands` · `14-tool MCP server`
+
+</div>
 
-Bizar is a guarded-autonomy harness for Claude Code. It packages 16 uniquely named role agents, 66 skills, slash-command workflows, lifecycle and safety hooks, a typed SDK, a 14-tool MCP server, and install/audit/test utilities.
+---
 
-## What it does
+## Why Bizar?
 
-- Executes clear local edit/test/verify work autonomously.
-- Uses Claude Code permission modes plus deterministic hooks for safety.
-- Requires human confirmation for commits, pushes, PR mutations, releases, publishing, deployments, and other external or irreversible operations.
-- Routes non-trivial work through research, plan/audit, implementation, review, and verification phases.
-- Preserves bounded session handoffs and learning evidence without providing a general-purpose note vault.
-- Guards compaction fidelity, commit quality, prose quality, dangerous shell commands, protected paths, and reviewer context.
+Claude Code is already powerful. Bizar makes longer, cross-cutting work easier
+to trust and easier to follow. It starts with a small read-only orientation,
+forms an agent team by default for substantive work, and asks a clarification
+only when a material decision remains unresolved. `/quick` deliberately
+selects direct primary-session work; workflows and single agents are explicit
+or resumed modes.
 
-Bizar deliberately ships no embedded web control plane, browser extension,
-background web service, or note-vault/search subsystem. The machine-readable
-`bizar control` command lets an optional OpenKan installation present Bizar
-agents, tasks, sessions, feature state, and durable messages without coupling
-to Bizar internals.
+It keeps the operator in control of model selection and high-impact actions.
+Your configured model choices live in your global Claude configuration—not in
+the project you happen to be working on.
 
-## Quick start
+| You want | Bizar provides |
+| --- | --- |
+| A clean way to begin | A guided installer and `bizar models` picker |
+| Your own gateway models | Global selection, full-ID subagent definitions, and native alias mapping |
+| Useful parallel work | Isolated worktrees, scoped tasks, and specialist roles |
+| Fewer surprises | Explicit safety checks for releases, publication, deployment, pushes, and destructive operations |
+| Confidence at the end | Tests, architecture checks, E2E checks, and evidence-aware handoff |
+
+## Start here
+
+Install Bizar globally, install its Claude Code integration, then choose the
+models you want Bizar to use.
 
 ```sh
-npm install
-npm run build
-node cli/bin.mjs install
-make check
-make test
-make e2e
+npm install -g @polderlabs/bizar
+bizar install
+bizar models
 ```
 
-Claude Code reads `.claude/settings.json`. `cli/provision.mjs` can copy agents, commands, skills, hooks, rules, and settings into `~/.claude/` for user-level use.
+Restart Claude Code after installation. The installer adds Bizar's agents,
+skills, commands, hooks, and settings to your user-level Claude configuration.
+It preserves your configured gateway endpoint and credential values during a
+clean reinstall.
 
-## Core surfaces
+For a completely fresh Bizar-managed Claude setup while retaining endpoint and
+authentication settings:
 
-| Surface | Purpose |
-| --- | --- |
-| `.claude/agents/` | Office-themed role agents and orchestrator |
-| `config/skills/` | Canonical skill library |
-| `.claude/commands/` | Slash-command workflows |
-| `.claude/hooks/` | Safety, HITL, lifecycle, routing, telemetry, and compaction hooks |
-| `packages/sdk/` | Agent registry, router, learning logs, federation, consensus, and MCP |
-| `cli/` | Installer, validator, backup, audit, cost/claim/task/control, sandbox, repair |
-| `scripts/` | Architecture, absence, E2E, feature, eval, and clean-state verification |
+```sh
+bizar install --force
+bizar models
+```
+
+Then open any repository in Claude Code and describe the outcome you want.
+Mike—the Bizar coordinator—handles the rest.
+
+> **Tip:** Run `bizar doctor` whenever you want to verify that the global
+> install, Claude settings, hooks, skills, agents, and provider connection are
+> healthy.
+
+## The first-task experience
+
+```mermaid
+flowchart LR
+    U["Describe the outcome"] --> M["Mike: brief orientation"]
+    M --> Q{"Material choice?"}
+    Q -- Yes --> C["One concise question"]
+    C --> R["Choose a coordination mode"]
+    Q -- No --> R
+    R --> D["Direct edit"]
+    R --> A["Isolated specialist"]
+    R --> P["Parallel agents / team"]
+    R --> W["Visible workflow"]
+    D --> V["Verify and report evidence"]
+    A --> V
+    P --> V
+    W --> V
+```
+
+The coordinator does not force every request through a workflow. Small,
+obvious edits stay small; larger requests get only the structure they need.
+Writing agents work in Git worktrees, while read-only research stays light and
+foregrounded.
 
-The MCP tools are `plan_action`, `loop_start`, `loop_stop`, `loop_list`, `loop_status`, `graph_query`, `graph_path`, `list_instincts`, and `list_decisions`.
+## Your models, everywhere Bizar dispatches
 
-## Parallel agent coordination
+`bizar models` is the single operator-facing place to select models. It
+discovers candidates from your configured gateway and writes your selections to
+the global model router:
 
-Code-writing subagents run in isolated Git worktrees. `bizar task` stores a
-shared SQLite task graph under Git's common directory, so all worktrees observe
-the same dependencies, owners, path scopes, and expiring leases. The
-PreToolUse ownership hook denies edits outside the current task scope and edits
-to paths leased by sibling agents.
+```text
+~/.claude/model-router.json
+```
+
+The router is never stored in a project directory. Bizar uses the selected
+models for direct subagents, workflows, and agent-team teammates.
+
+```mermaid
+flowchart TD
+    Picker["bizar models"] --> Router["Global model router\n~/.claude/model-router.json"]
+    Router --> Definitions["Global Bizar agent definitions\nfull model ID in frontmatter"]
+    Router --> Aliases["sonnet · opus · haiku · fable\ncompatibility aliases"]
+    Definitions --> Agent["Subagents"]
+    Definitions --> Workflow["Workflow workers"]
+    Definitions --> Team["Agent-team teammates"]
+```
+
+Claude Code's native per-call model field has a small alias vocabulary. Bizar
+avoids making that vocabulary a limitation: it projects each selected gateway
+model into a global subagent definition whose frontmatter contains the full
+model ID. The agent, workflow, and team routes use that definition. The four
+native aliases are compatibility shortcuts only; they do not enable an
+unselected provider or reduce your selected-model pool to four choices.
+
+Useful inspection commands:
 
 ```sh
-bizar task create sdk-change --title "Update SDK" --scope "packages/sdk/**"
-bizar task claim sdk-change --owner todd --workspace "$PWD"
-bizar task heartbeat sdk-change --owner todd
-bizar task complete sdk-change --owner todd --evidence "targeted tests passed"
-bizar task integrate enqueue sdk-change --commit abc1234 --owner todd
-bizar task integrate claim --worker steve
-bizar task integrate pass 1 --worker steve --evidence "aggregate checks passed"
+bizar models --list
+bizar models --agent-types --json
+bizar models explain todd
+bizar doctor
 ```
 
-The integration queue records the commit, base reference, verification command,
-owner, integrator, and outcome. It deliberately does not perform unapproved
-merge, rebase, push, or publication operations.
+## A specialist bench, not a generic swarm
+
+Bizar ships its core coordination roles alongside 68 focused specialists for
+architecture, accessibility, security, testing, documentation, performance,
+language and framework review, build repair, operations, and evaluation. It
+also ships 80 skills for planning, debugging, verification, review,
+worktrees, and implementation practice.
+
+The coordinator selects specialists when their expertise reduces a concrete
+risk. It does not create parallel workers merely to look busy. You can inspect
+the installed specialist definition names through `bizar models --agent-types
+--json` and use a relevant Bizar specialist directly when needed.
+
+```text
+Core coordination                 Specialist coverage
+─────────────────                 ──────────────────────────────────
+Mike · research · plan            Architecture · accessibility · security
+Implementation · review           Build repair · tests · documentation
+Verification · integration        Frameworks · performance · operations
+                                  Evaluation · product and domain analysis
+```
+
+## Guardrails that stay out of the way
+
+Bizar is designed to be autonomous for local, reversible work and deliberate
+for consequential actions.
+
+| Category | Default behavior |
+| --- | --- |
+| Read, inspect, edit, test, format | Proceeds autonomously within the task scope |
+| Parallel code changes | Uses isolated worktrees and scoped task ownership |
+| Ambiguous material design choice | Asks one concise clarification before execution |
+| Commit | Locally allowed, with a fresh simplify review reminder |
+| Push, PR mutation, release, publish, deploy | Requires an explicit human decision |
+| Rebase, force-push, broad destructive commands | Denied or escalated by the safety floor |
+
+The goal is not to make Claude Code timid. It is to make its boundaries clear:
+Bizar works through local implementation and verification, then stops at the
+point where an external or difficult-to-reverse decision belongs to you.
+
+## What gets installed
+
+```text
+~/.claude/
+├── agents/          84 Bizar roles and specialist definitions
+├── skills/          80 skill packs
+├── commands/        39 slash-command surfaces
+├── hooks/           routing, lifecycle, safety, evidence, and quality hooks
+├── rules/           focused guidance for common development work
+├── workflows/       native workflow definitions
+├── settings.json    Bizar-managed Claude Code integration
+└── model-router.json operator-selected model state
+
+~/.config/bizar/
+├── installed.json   install record
+├── evidence/        local dispatch and verification evidence
+├── telemetry/       local routing and rejected-action feedback
+└── worktree-queue.json  completed worktree integration queue
+```
 
-## OpenKan control plane
+`bizar control` is a machine-readable command boundary for optional external
+interfaces. Bizar deliberately does not include an embedded browser control
+plane, background daemon, or general-purpose note vault.
 
-`bizar control snapshot --json` exposes the current agent catalogue, durable
-task and integration queues, feature ledger, progress summary, Claude Code
-background sessions, and durable control messages. OpenKan invokes task and
-session mutations through the same CLI instead of importing Bizar modules or
-opening its SQLite database.
+## Commands worth knowing
 
-Messages are atomically queued under `.bizar/control/messages/`. Supported
-Claude Code `SessionStart` and `UserPromptSubmit` hooks claim and inject matching
-messages exactly once. A session-targeted message can request a documented
-background resume; Bizar never edits transcripts or attaches to private process
-internals.
+| Command | When to use it |
+| --- | --- |
+| `bizar install` | Install or refresh Bizar in your global Claude configuration |
+| `bizar models` | Discover and select the models Bizar may dispatch |
+| `bizar doctor` | Diagnose the global installation and provider connectivity |
+| `bizar validate` | Run an install-focused health check |
+| `bizar task` | Inspect or coordinate scoped worktree tasks |
+| `bizar worktree-merge --all` | Review and merge completed isolated work, surfacing conflicts |
+| `bizar control snapshot --json` | Read the machine-friendly current harness state |
+| `bizar evidence` | Inspect local dispatch and verification evidence |
 
-## Guarded autonomy
+## Running Bizar from this repository
 
-Project settings default to `acceptEdits`, which lets Claude iterate locally while preserving prompts around broader shell operations. Operators who meet Claude Code's requirements may choose Auto mode; Bizar's deny/ask hooks still apply before permission-mode evaluation.
+For contributors, use the repository checkout rather than the global package:
 
-The Git workflow hook denies force-push, rebase, unsupported commit subjects, and AI-attribution trailers. It asks before a commit, push, PR mutation, release, publish, or deploy. The simplify guard requires `/simplify` for every commit attempt.
+```sh
+npm install
+npm run build
+node cli/bin.mjs install
+make check
+make test
+make e2e
+```
 
-## Verification
+The verification suite covers both the code and the integration contract:
 
 ```sh
 make verify-removed-surfaces
@@ -98,10 +237,13 @@ make clean-check
 make check
 ```
 
-The root package uses a runtime-only allowlist: no test files, local state,
-duplicate skill mirror, or source-only fixture is published.
+## Learn more
 
-See [the documentation index](docs/INDEX.md), [architecture](docs/architecture.md), [core feature audit](docs/audits/core-feature-audit-2026-07-30.md), [repository cleanup audit](docs/audits/repository-cleanup-2026-07-30.md), and [upstream parity matrix](docs/audits/claude-codex-settings-parity-2026-07-30.md).
+- [Documentation index](docs/INDEX.md)
+- [Architecture](docs/architecture.md)
+- [Model routing decisions](docs/decisions/)
+- [Current progress and evidence](PROGRESS.md)
+- [MIT license](LICENSE)
 
 ## License
 

package/cli/commands/models.mjs

@@ -18,6 +18,7 @@
  * reject user-selected IDs.
  */
 import chalk from 'chalk';
+import { createHash } from 'node:crypto';
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import readline from 'node:readline';
@@ -1077,6 +1078,13 @@ export const NATIVE_AGENT_ALIASES = Object.freeze(['sonnet', 'opus', 'haiku', 'f
 
 const MODEL_AGENT_WORDS = Object.freeze({ a:'alpha', b:'bravo', c:'charlie', d:'delta', e:'echo', f:'foxtrot', g:'golf', h:'hotel', i:'india', j:'juliet', k:'kilo', l:'lima', m:'mike', n:'november', o:'oscar', p:'papa', q:'quebec', r:'romeo', s:'sierra', t:'tango', u:'uniform', v:'victor', w:'whiskey', x:'xray', y:'yankee', z:'zulu', 0:'zero', 1:'one', 2:'two', 3:'three', 4:'four', 5:'five', 6:'six', 7:'seven', 8:'eight', 9:'nine', '/':'slash', '.':'dot', '-':'dash', '_':'under' });
 
+// Keep generated names below common filesystem component limits and leave
+// enough path budget for the Claude config directory on Windows. The complete
+// gateway ID remains in frontmatter; this limit only affects the native agent
+// name and its filename.
+export const MODEL_AGENT_NAME_MAX_LENGTH = 160;
+const MODEL_AGENT_NAME_HASH_LENGTH = 16;
+
 // These are the stable Bizar role frontmatter names. Model definitions are
 // projected per role so Claude Code's task UI retains a meaningful Bizar agent
 // identity instead of displaying an opaque model-only worker.
@@ -1102,7 +1110,17 @@ export function stableSpecialistAgentNames(agentsDir = join(resolveClaudeConfigD
 
 export function modelAgentName(modelId, role = 'worker') {
   const safeRole = BIZAR_AGENT_ROLES.includes(role) ? role : 'worker';
-  return `${safeRole}-bizar-${[...String(modelId || '').toLowerCase()].map((ch) => MODEL_AGENT_WORDS[ch] || 'unknown').join('-')}`;
+  const normalizedModelId = String(modelId || '').toLowerCase();
+  const expanded = [...normalizedModelId].map((ch) => MODEL_AGENT_WORDS[ch] || 'unknown').join('-');
+  const fullName = `${safeRole}-bizar-${expanded}`;
+  if (fullName.length <= MODEL_AGENT_NAME_MAX_LENGTH) return fullName;
+
+  const hash = createHash('sha256')
+    .update(`${safeRole}\0${normalizedModelId}`)
+    .digest('hex')
+    .slice(0, MODEL_AGENT_NAME_HASH_LENGTH);
+  const suffix = `-${hash}`;
+  return `${fullName.slice(0, MODEL_AGENT_NAME_MAX_LENGTH - suffix.length)}${suffix}`;
 }
 
 export function isGeneratedModelAgentName(name, modelIds) {

package/cli/commands/validate.mjs

@@ -46,12 +46,11 @@ export const REQUIRED_AGENTS = [
 export const REQUIRED_COMMANDS = [
   'artifact.md', 'audit.md', 'autopilot.md', 'backup.md', 'bizar.md',
   'browser.md', 'cancel.md', 'cron.md', 'doctor.md', 'explain.md', 'init.md',
-  'learn.md', 'migrate.md', 'plan.md', 'plow-through.md', 'pr-review.md',
-  'quick.md', 'ralph.md', 'ralplan.md', 'rca.md', 'repair.md', 'restore.md',
-  'setup-provider.md', 'spec.md', 'sprint.md', 'tailscale-serve.md', 'team.md',
-  'test.md', 'tier.md', 'tools.md', 'ultracode.md', 'ultraqa.md',
-  'ultrawork.md', 'update.md', 'upgrade-defaults.md', 'use-default.md',
-  'use-premium.md', 'validate.md', 'verify.md',
+  'learn.md', 'plan.md', 'plow-through.md', 'pr-review.md', 'quick.md',
+  'ralph.md', 'ralplan.md', 'rca.md', 'repair.md', 'restore.md',
+  'setup-provider.md', 'spec.md', 'sprint.md', 'team.md', 'test.md',
+  'tools.md', 'ultracode.md', 'ultraqa.md', 'ultrawork.md', 'update.md',
+  'validate.md', 'verify.md',
 ];
 
 // v6.3.0 — Claude Code hook adapter scripts (executable, .mjs extension).

package/cli/install/interactive-setup.mjs

@@ -92,7 +92,19 @@ export async function runInteractiveSetup({
   const interactive = enabled && input.isTTY === true && output.isTTY === true;
   if (!interactive) {
     if (detected.missing.length > 0) {
-      writeLine(output, `  ! Provider ${detected.missing.join(' and ')} not detected; set ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN or run \`bizar setup-provider\`.`);
+      const missing = detected.missing.join(' and ');
+      const header = `  [BIZAR_PROVIDER_CONFIG_MISSING] Provider ${missing} not configured in this non-interactive run.`;
+      const action = `  Set ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN in the environment, or run \`bizar setup-provider\` interactively.`;
+      writeLine(output, '');
+      writeLine(output, header);
+      writeLine(output, action);
+      writeLine(output, '');
+      // Also surface to stderr when output is the real stdout so CI runners
+      // and operator logs do not silently lose the warning in a flood of
+      // piped output. The custom test output streams ignore stderr.
+      if (output === process.stdout) {
+        process.stderr.write(`${header}\n${action}\n`);
+      }
     }
     return { ok: true, interactive: false, configured: detected.missing.length === 0, missing: detected.missing };
   }

package/cli/install/paths.mjs

@@ -8,22 +8,14 @@
 import chalk from 'chalk';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { resolveClaudeConfigDir } from '../config-paths.mjs';
 
 /** 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');
+  return resolveClaudeConfigDir();
 }
 
 const HOME = homedir();

package/cli/provision.mjs

@@ -31,7 +31,11 @@ import {
 import { homedir } from 'node:os';
 import { dirname, join, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { resolveBizarHome, resolveGlobalModelRouter } from './config-paths.mjs';
+import {
+  resolveBizarHome,
+  resolveClaudeConfigDir,
+  resolveGlobalModelRouter,
+} from './config-paths.mjs';
 import {
   buildClaudeModelOverrides,
   configuredEnabledModels,
@@ -64,15 +68,7 @@ export const BIZAR_VERSION = (() => {
  *   2. `$HOME/.claude`
  */
 export function resolveClaudeDir() {
-  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');
+  return resolveClaudeConfigDir();
 }
 
 export const CLAUDE_DIR = resolveClaudeDir();
@@ -98,9 +94,13 @@ export const CLAUDE_RULES_DIR    = join(CLAUDE_DIR, 'rules');
 
 // ─── Tiny utilities ──────────────────────────────────────────────────────────
 
-function haveCmd(cmd) {
+export function haveCmd(cmd) {
   try {
-    execSync(`command -v ${cmd}`, { stdio: ['ignore', 'pipe', 'ignore'] });
+    if (process.platform === 'win32') {
+      execFileSync('where.exe', [cmd], { stdio: ['ignore', 'pipe', 'ignore'] });
+    } else {
+      execSync(`command -v ${cmd}`, { stdio: ['ignore', 'pipe', 'ignore'] });
+    }
     return true;
   } catch {
     return false;
@@ -1204,7 +1204,14 @@ export async function runProvision(opts = {}) {
   if (routerStep.ok) logOk(routerStep.message); else logErr(routerStep.message);
   stepResults.push({ label: 'model-router', ...routerStep });
 
-  const modelAgentsStep = syncConfiguredModelAgents({ dryRun });
+  section('Syncing configured model agents');
+  let modelAgentsStep;
+  try {
+    modelAgentsStep = syncConfiguredModelAgents({ dryRun });
+  } catch (err) {
+    const message = err?.message ?? String(err);
+    modelAgentsStep = { ok: false, message: `configured model-agent sync failed: ${message}`, error: message, code: err?.code };
+  }
   if (modelAgentsStep.ok) logOk(modelAgentsStep.message); else logErr(modelAgentsStep.message);
   stepResults.push({ label: 'model-agents', ...modelAgentsStep });
 
@@ -1259,7 +1266,7 @@ export async function runProvision(opts = {}) {
   } else {
     console.log(chalk.dim('  Premium model: (no premium pick configured yet — run `bizar models`)'));
   }
-  console.log(chalk.dim('  See /use-premium or .claude/commands/use-premium.md for the full launch snippet.'));
+  console.log(chalk.dim('  Inspect configured selections with `bizar models --list` or `bizar models --agent-types --json`.'));
   console.log('');
   return { ok: !anyFail, mode: effectiveMode, state: detectState(), stepResults };
 }

package/cli/utils.mjs

@@ -4,12 +4,11 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { existsSync, readFileSync } from 'node:fs';
+import { resolveClaudeConfigDir } from './config-paths.mjs';
 
 const __dirname = fileURLToPath(new URL('.', import.meta.url));
 const REPO_ROOT = join(__dirname, '..');
 
-const isWin = process.platform === 'win32';
-
 export function repoPath(...parts) {
   return join(REPO_ROOT, ...parts);
 }
@@ -21,15 +20,7 @@ export function repoPath(...parts) {
  *   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, 'claude')
-      : join(homedir(), '.claude');
-  }
-  return join(homedir(), '.claude');
+  return resolveClaudeConfigDir();
 }
 
 export function claudeAgentsDir() {

package/config/claude/CLAUDE.md

@@ -69,13 +69,15 @@ still deny prohibited actions and escalate externally visible or irreversible
 actions with `permissionDecision: "ask"`; that escalation list is the
 authoritative floor, not a starting point.
 
-Mike selects the coordination mode after bounded read-only orientation and one
-user clarification checkpoint: direct work only for an unmistakably tiny
-single-target copy/style/format edit; one isolated Agent for a clear bounded
-change; a native workflow for repeatable phased work; parallel Agents for
-disjoint scopes; and an Agent team for 3+ sustained roles that genuinely need
-cross-talk. Do not add unnecessary phases or duplicate workers. The team is
-host-side state under `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`, and per
+Mike performs bounded read-only orientation, then uses a native Agent team as
+the default for substantive work. Direct work is reserved for an unmistakably
+tiny single-target copy/style/format edit or the user's explicit `/quick`
+request. A single Agent or native workflow is used only when the user
+explicitly requests that mode or a durable workflow must be resumed. Ask one
+concise clarification question only when a material choice, acceptance
+criterion, safety boundary, or unresolved constraint would change the work;
+otherwise continue autonomously. The team is host-side state under
+`CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`, and per
 Anthropic's docs `team_name` is deprecated and ignored. Every editing dispatch
 uses an explicit configured model and call-level `isolation: "worktree"`.
 When two or more subtasks have non-overlapping writable scopes and no data
@@ -144,13 +146,14 @@ The autonomy and approval policy above governs this execution model. The project
 Every non-empty primary request enters Bizar through `office-manager` (`@mike`).
 The installer sets Claude Code's global `agent` setting to Mike's frontmatter
 name (`mike`),
-and the routing hook supplies the adaptive coordination policy. For non-tiny
-work, Mike first gathers only bounded read-only context, asks one concise
-clarification question that names the inferred outcome and proposed mode, then
-continues autonomously after the answer. A native workflow is one available
-mode, not a universal gate; Mike may select an isolated Agent, parallel Agents,
-or an Agent team when that better fits the work. Mike owns integration and
-final verification.
+and the routing hook supplies the team-first coordination policy. For non-tiny
+work, Mike first gathers only bounded read-only context. When the inferred
+outcome, acceptance criteria, and safety boundary are clear, it forms the
+default Agent team and continues autonomously. It asks one concise
+clarification only when a material choice or unresolved constraint would
+change the work. `/quick` explicitly selects direct primary-session execution;
+single Agents and native workflows are explicit or resumed modes. Mike owns
+integration and final verification.
 A Bizar custom agent already executing its assigned role does not recursively
 dispatch itself.
 

package/config/claude/agents/office-manager.md

@@ -1,6 +1,6 @@
 ---
 name: mike
-description: Mike — adaptive orchestrator that selects the lightest safe coordination mode.
+description: Mike — team-first orchestrator that uses direct work only for quick or tiny requests.
 tools: Workflow, Agent, Read, Write, Edit, Bash, Grep, Glob, WebFetch, WebSearch, Skill, AskUserQuestion
 skills:
   - i-have-adhd
@@ -9,27 +9,25 @@ skills:
 # Mike — adaptive primary orchestrator
 
 Follow `_shared/AGENT_BASELINE.md`. You own the user outcome, integration, and
-final verification. Direct execution is a narrow exception; workflows are the
-default for meaningful work.
+final verification. Direct execution is a narrow exception; native Agent teams
+are the default for meaningful work.
 
-## Orient, clarify, then select the coordination mode
+## Orient, decide, then coordinate
 
 | Shape | Signals | Execution |
 |---|---|---|
 | Tiny direct | one obvious copy, typo, comment, whitespace, or single style-token edit; one target; no behavior or test change | inspect, make the micro-edit, run the smallest proving check yourself |
-| Single isolated worker | one bounded implementation after scope is clear | dispatch one worktree-isolated native Agent with its explicit Bizar model; use an exact-model process worker only when a separate Claude process is useful; integrate and verify |
-| Native workflow | repeatable diagnosis, research, review, or an implementation needing visible phase barriers | invoke the matching Bizar workflow with explicit Bizar routing |
-| Agent team | three or more sustained, independent roles need bounded cross-talk or coordinated handoff | use the native Agent-team capability; writers use worktrees and explicit Bizar models |
-| Parallel agents | two disjoint writable scopes with no cross-talk needed | dispatch concurrently with explicit models and worktree isolation |
+| Default substantive work | any request beyond a tiny edit or explicit `/quick` | form a native Agent team with bounded research, implementation, and review/integration ownership |
+| Explicit single worker | user specifically asks for one agent or one narrow owner is required | dispatch one worktree-isolated native Agent and integrate its result |
+| Explicit/resumed workflow | user explicitly requests a workflow or an existing workflow must continue | invoke the matching Bizar workflow with explicit Bizar routing |
 
 For every non-tiny request, first make only enough read-only inspection to
-understand the repository boundary and current constraints. Then ask the user
-one concise clarification checkpoint: state the inferred outcome, the material
-choice or risk, and the proposed coordination mode. Wait for the answer before
-writing, dispatching editors, creating branches, or running tests. If the user
-explicitly says to proceed without questions, record that choice and continue.
-After the answer, work autonomously until the requested outcome and verification
-are complete. Research current official docs only for external or
+understand the repository boundary and current constraints. If the inferred
+outcome, acceptance criteria, and safety boundary are clear, form the default
+team and continue autonomously. Ask one concise clarification question only
+when a material choice, unresolved constraint, or missing success criterion
+would change the work. `/quick` is an explicit direct-execution request and
+does not form a team. Research current official docs only for external or
 version-sensitive claims. Inspect installed skills before hard or specialized
 work; if stuck with no match, search skills.sh and review the candidate before
 proposing installation.

package/config/claude/commands/bizar.md

@@ -1,5 +1,5 @@
 ---
-description: Show the Bizar autonomous harness controls and choose the smallest safe workflow.
+description: Show the Bizar autonomous harness controls and start the team-first coordination policy.
 ---
 
 # Bizar Harness
@@ -7,9 +7,10 @@ description: Show the Bizar autonomous harness controls and choose the smallest
 Use `/bizar` to orient a task to the installed Claude Code-native harness.
 
 1. Read `PROGRESS.md`, `feature_list.json`, and the repository instructions.
-2. Select the smallest appropriate lane: direct execution, research, plan/audit, team, or guarded background work.
-3. State the target result, constraints, validation evidence, and stop condition.
-4. Use `bizar --help` for CLI primitives and the installed skills for workflow-specific instructions.
-5. Preserve human approval gates for destructive, publishing, deployment, and credential-sensitive operations.
+2. For substantive work, form a native Agent team after bounded read-only orientation. Use direct work only for a genuinely tiny task or an explicit `/quick` request; use a single Agent or a workflow only when the user explicitly asks for one or is resuming one.
+3. Ask one concise clarification question only when orientation leaves a material outcome, acceptance criterion, constraint, or safety boundary unresolved. Otherwise proceed autonomously.
+4. State the target result, constraints, validation evidence, and stop condition.
+5. Use `bizar --help` for CLI primitives and the installed skills for workflow-specific instructions.
+6. Preserve human approval gates for destructive, publishing, deployment, and credential-sensitive operations.
 
 Bizar has no browser control plane or persistent web service. Project files, Claude Code hooks, MCP tools, and CLI output are the operational surfaces.

package/config/claude/commands/plow-through.md

@@ -8,8 +8,9 @@ Execute the requested local work end-to-end without pausing for ordinary reversi
 
 1. Read repository instructions, `PROGRESS.md`, and relevant project files.
 2. Infer reasonable details from evidence; record material assumptions.
-3. Use direct execution by default. Use parallel dispatch only for genuinely
-   independent scopes where it materially improves throughput.
+3. Form the default native Agent team with bounded research, implementation,
+   and review/integration ownership. Use direct execution only for an explicit
+   `/quick` request or an unmistakably tiny edit.
 4. Continue through edit, targeted tests, full required gates, documentation, and state updates.
 5. Stop only when verified complete or when an approval-gated action is the only remaining step.
 

package/config/claude/commands/quick.md

@@ -1,32 +1,32 @@
 ---
-description: Skip Bizar\'s mandatory routing for this turn. Use for trivial single-step work the chat can handle directly.
+description: Use direct primary-session execution for this turn instead of Bizar's default agent team.
 argument-hint: "[task]"
 disable-model-invocation: true
 allowed-tools: Read, Bash, Edit, Write, Grep, Glob
 ---
 
-# /quick — One-Turn Routing Bypass
+# /quick — Direct Execution
 
-Run `$ARGUMENTS` directly in this session. Do NOT delegate to subagents.
+Run `$ARGUMENTS` directly in this session. Do not create an Agent team,
+dispatch a subagent, or start a workflow for this turn.
 
 ## Mechanism
 
-The `worker-suggest` hook recognizes `/quick` directly, but honors the bypass
-only when the argument still qualifies as an unmistakably tiny edit. Legacy
-`.bizar/.quick-once` sentinels are consumed on their first prompt and cannot
-bypass routing for substantive work.
+The `worker-suggest` hook recognizes `/quick` directly and applies the direct
+execution policy for this request. `/quick` changes coordination only: it never
+bypasses model selection, safety hooks, approval boundaries, or verification.
 
 ## What this is for
 
-- One-line file edits
+- A focused implementation you want handled in the primary session
 - Quick lookups ("find X", "show me Y")
-- One-token style adjustments
+- A single-owner debugging or editing task
 
 ## What this is NOT for
 
-- Multi-step implementations
-- Anything that requires verification across multiple files
-- Any task that should be tracked in `feature_list.json`
+- Work that benefits from independent research, implementation, and review
+- Work with disjoint lanes where a team will be materially faster
+- A task whose scope is unclear after bounded orientation
 
-If the task balloons, abort, delete the sentinel, and re-run the request
-without `/quick` so the orchestrator can dispatch properly.
+If the task expands into independent lanes or becomes materially unclear, stop
+and re-run it without `/quick` so Bizar can form the default agent team.

package/config/claude/commands/team.md

@@ -5,7 +5,10 @@ allowed-tools: Read, Bash, Agent, SendMessage
 
 # Team — Coordinated Claude Code Agents
 
-Use `/team` only when teammates need to coordinate or communicate directly while parallel, independent scopes materially improve delivery. Use ordinary subagents for focused delegation and native dynamic workflows for deterministic large fan-out.
+`/team` is Bizar's standard substantive-work mode. Use it after bounded
+orientation whenever the task is not an explicit `/quick` direct request or an
+unmistakably tiny edit. Use an explicit single-agent or workflow route only
+when the user asks for it or a durable workflow must be resumed.
 
 Agent teams are experimental. They require `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`, which Bizar installs by default. Current Claude Code versions create and clean up teams automatically; do not call obsolete `TeamCreate` or `TeamDelete` tools.
 
@@ -30,7 +33,7 @@ Team agents may inspect, edit, build, and test locally without approval. They mu
 
 ## Checklist
 
-- [ ] Parallelism is justified; a direct lane would be slower or less reliable.
+- [ ] The team has a concrete research, implementation, and review/integration purpose.
 - [ ] File scopes are disjoint.
 - [ ] Every editing lane has a claimed task/worktree and path scope.
 - [ ] Lockfiles and root configuration have one owner.

package/config/claude/hooks/sessionend-recall.mjs

@@ -28,7 +28,7 @@
 
 'use strict';
 
-import { readFileSync, existsSync, mkdirSync, writeFileSync, appendFileSync, unlinkSync } from 'node:fs';
+import { readFileSync, existsSync, mkdirSync, writeFileSync, appendFileSync } from 'node:fs';
 import { join } from 'node:path';
 import os from 'node:os';
 import { createHash } from 'node:crypto';
@@ -354,14 +354,6 @@ process.stdin.on('end', () => {
   const notePath = writeSessionNote(cwd, sessionId, reason, summary);
   const stateOk = writeSessionState(cwd, sessionId, reason, summary, nextStep);
 
-  // Clear /quick sentinel so the next session is back to orchestrator routing.
-  try {
-    const quickSentinel = join(cwd, '.bizar', '.quick-once');
-    if (existsSync(quickSentinel)) {
-      try { unlinkSync(quickSentinel); } catch { /* best-effort */ }
-    }
-  } catch { /* best-effort */ }
-
   // Silent success — the artifact is the file system.
   process.stdout.write(
     JSON.stringify({

package/config/claude/hooks/sessionstart-prime.mjs

@@ -186,13 +186,13 @@ function startupBriefing(cwd, featureBrief, recentCommits, projectLine, progress
     }
   }
   if (progressLast) lines.push(`- Progress: ${progressLast}.`);
-  lines.push('- You are @mike. For non-tiny work, do bounded read-only orientation, ask one clarification checkpoint, then choose a single isolated worker, native workflow, parallel workers, or an Agent team by actual dependency. Use worktrees for editors and explicit Bizar models for every Agent.');
+  lines.push('- You are @mike. For non-tiny work, do bounded read-only orientation, then form a native Agent team by default. Ask one concise clarification only when a material choice, acceptance criterion, or safety boundary remains unresolved; otherwise continue autonomously. /quick is the explicit direct-execution exception. Use worktrees for editors and explicit Bizar models for every Agent.');
   lines.push('- External/version-sensitive work requires current official docs via WebSearch/WebFetch. Use relevant installed skills; apply i-have-adhd to user output. WIP=1.');
   lines.push('- TaskCompleted/SubagentStop/<task-notification> is terminal: consume its original <result> once, mark done/failed, merge queued work, and continue the objective. Never turn a terminal notification into a worker follow-up or replace that result with a later status reply.');
   // Default-first-stop hint when nothing is active yet.
   if (featureBrief && featureBrief.active.length === 0) {
     lines.push(
-      '- First move: read PROGRESS.md and feature_list.json, then do bounded orientation and ask the clarification checkpoint before choosing the fitting coordination mode.',
+      '- First move: read PROGRESS.md and feature_list.json, do bounded orientation, and form the default team when the outcome is clear. Ask only if a material decision remains unresolved.',
     );
   }
   return lines.join('\n');

package/config/claude/hooks/thinking-route.mjs

@@ -259,7 +259,6 @@ process.stdin.on('end', () => {
     { cmd: '/audit',           note: 'Run Forseti-style code-review audit on the current diff.' },
     { cmd: '/test',            note: 'Auto-detects runner (jest/vitest/bun/pytest/cargo/go); streams output.' },
     { cmd: '/explain',         note: 'Read-only explanation — dispatch susan (or general-purpose) to look up the answer with file:line refs.' },
-    { cmd: '/tailscale-serve', note: 'Authenticate Tailscale and configure `tailscale serve` for a local port.' },
     { cmd: '/bizar',           note: 'Bizar harness orientation — guarded workflows, plans, loops, graph, cost, and claims.' },
     { cmd: '/init',            note: 'Run `bizar init` to scaffold project context and graph state in this repo.' },
     { cmd: '/cron',            note: 'Manage scheduled tasks via the Bizar SDK cron API — list / add / remove / pause.' },

package/config/claude/hooks/worker-suggest.mjs

@@ -5,9 +5,8 @@
  * Bizar Background Workers — UserPromptSubmit hook.
  *
  * Runs on every user prompt. Only unmistakably tiny, single-scope edits take
- * a cheap fast path. Every other request is routed into a native Bizar
- * adaptive coordination mode selected by Mike after bounded orientation and a
- * clarification checkpoint.
+ * a cheap fast path. Every other request is routed into a team-first Bizar
+ * coordination mode selected by Mike after bounded orientation.
  *
  * Uses import.meta.url + dynamic import() to resolve the sibling CLI module so
  * the hook works regardless of install path (fixes ERR_MODULE_NOT_FOUND after
@@ -36,7 +35,6 @@
 'use strict';
 
 import { dirname, join } from 'node:path';
-import { existsSync, unlinkSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { isTinyDirectTask } from './workflow-route-state.mjs';
 
@@ -56,10 +54,17 @@ const FAST_ROUTE_POLICY = [
   '- If inspection reveals behavioral logic, more than one target, ambiguity, a required test change, or any interaction beyond the named micro-edit, stop the direct path and invoke the matching native Bizar workflow before editing further.',
 ].join('\n');
 
+const QUICK_ROUTE_POLICY = [
+  'Bizar /quick direct path:',
+  '- The user explicitly selected direct, primary-session execution for this turn. Do not create an Agent team, dispatch a subagent, or start a workflow merely because the request is substantial.',
+  '- Do bounded read-only orientation, then proceed autonomously when the requested outcome, acceptance criteria, and safety boundary are clear. Ask only when a material choice or missing success criterion prevents a safe, correct implementation.',
+  '- /quick never bypasses worktree, approval, credential, destructive-action, or verification safeguards. Run the smallest relevant proof before reporting completion.',
+].join('\n');
+
 const ROUTE_POLICY = [
   'Adaptive Bizar routing policy:',
-  '- If this is the primary session, you ARE @mike. First do only bounded read-only orientation. Then ask one concise clarification question describing the inferred outcome, the material choice/risk, and your proposed coordination mode. Wait for the answer before edits, branches, tests, or editor dispatch. If the user explicitly waives questions, continue autonomously.',
-  '- After clarification, choose the lightest coordination mode: a direct tiny edit, one isolated Agent for a bounded change, a native Bizar Workflow for repeatable phased work, parallel Agents for disjoint scopes, or an Agent team only when 3+ sustained roles need cross-talk. Do not force a workflow or team when it adds no value.',
+  '- If this is the primary session, you ARE @mike. First do only bounded read-only orientation. If the inferred outcome, acceptance criteria, and safety boundary are clear, continue without a clarification question. Ask one concise question only when a material choice, unresolved constraint, or missing success criterion would change the work.',
+  '- For substantive work, native Agent teams are the default execution method. Form a small team with clear ownership, use a lead to integrate evidence, and use worktrees for editors. Use direct execution only for an unmistakably tiny edit or an explicit /quick request. Use a single agent or a native workflow only when the user explicitly requests that mode or an existing workflow must be resumed.',
   '- For every normal Agent, workflow worker, or agent-team teammate, pass its stable Bizar role name (`greg`, `todd`, `linda`, and so on) as `subagent_type` and OMIT the native `model` field. `bizar models` keeps that global role definition frontmatter bound to the default enabled operator-selected gateway ID. Never put a raw gateway ID or a Claude family alias in the native model field; aliases are compatibility-only. `bizar models --agent-types --json` is advanced explicit per-model routing only. For teams, do not name a competing model in the spawn prompt. If the stable role definition is missing, run `bizar models`; do not retry by cycling providers or tiers. Every editing worker uses call-level `isolation: "worktree"`. For genuinely disjoint writable scopes, dispatch concurrently; otherwise use one owner.',
   '- Consume each terminal agent result exactly once from its original `<result>`/final summary, merge queued worktrees with bizar worktree-merge, and run integration checks in the primary session. Never send a terminal notification, idle ping, or completed task back to that agent as a follow-up and never re-dispatch a completed background agent merely to summarize its result. A subagent may not recursively dispatch itself.',
   '- Do NOT execute any tool you do not have. If a tool you need is missing from your tools list, dispatch to a subagent that has it — do not pretend you have it.',
@@ -91,28 +96,11 @@ process.stdin.on('end', async () => {
 
   if (/^\/quick(?:\s|$)/i.test(prompt)) {
     const quickTask = prompt.replace(/^\/quick(?:\s+|$)/i, '').trim();
-    const context = !quickTask || isFastLocalTask(quickTask) ? FAST_ROUTE_POLICY : ROUTE_POLICY;
+    const context = !quickTask ? FAST_ROUTE_POLICY : QUICK_ROUTE_POLICY;
     process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: context } }) + '\n');
     return;
   }
 
-  // /quick sentinel bypass: when .bizar/.quick-once exists, skip the
-  // orchestrator routing policy for this single turn. The sentinel is
-  // created by the /quick slash command and removed by session-end.
-  const quickSentinel = join(input.cwd || process.cwd(), '.bizar', '.quick-once');
-  if (existsSync(quickSentinel)) {
-    try { unlinkSync(quickSentinel); } catch { /* best-effort one-shot cleanup */ }
-    const context = isFastLocalTask(prompt) ? FAST_ROUTE_POLICY : ROUTE_POLICY;
-    process.stdout.write(JSON.stringify({
-      hookSpecificOutput: {
-        hookEventName: 'UserPromptSubmit',
-        additionalContext: context,
-      },
-    }) + '\n');
-    process.exit(0);
-    return;
-  }
-
   // Empty prompts get the silent treatment — the user has not yet
   // committed any intent.
   if (prompt.length === 0) {

package/config/claude/hooks/workflow-route-guard.mjs

@@ -88,9 +88,10 @@ process.stdin.on('end', () => {
     }
 
     // Coordination is an orchestrator decision, not a hard-coded tool gate.
-    // Instructions require orientation + clarification before mutation; Agent
-    // calls are independently protected by agent-model-guard.mjs. Keeping this
-    // hook advisory avoids trapping valid single-worker and Agent-team plans.
+    // Instructions require orientation, then a team by default; clarification
+    // is conditional on unresolved material choices. Agent calls are
+    // independently protected by agent-model-guard.mjs. Keeping this hook
+    // advisory avoids trapping valid direct, single-worker, and team plans.
   } catch (error) {
     process.stderr.write(`[bizar.workflow-route] ${error?.message || String(error)}\n`);
   }

package/config/claude/hooks/workflow-route-state.mjs

@@ -66,6 +66,6 @@ export function promptRequiresWorkflow(input) {
   if (!prompt) return false;
   if (input?.task_notification || /^<task-notification\b[\s\S]*<result\b[\s\S]*<\/task-notification>\s*$/i.test(prompt)) return false;
   const quick = prompt.match(/^\/quick(?:\s+([\s\S]*))?$/i);
-  if (quick) return Boolean(quick[1]?.trim()) && !isTinyDirectTask(quick[1]);
+  if (quick) return false;
   return !isTinyDirectTask(prompt);
 }

package/config/workflows/bizar-debug.js

@@ -39,6 +39,7 @@ const dispatchAgent = (agentFn, agentName, prompt, opts = {}) => {
   const prefix = `[Bizar dispatch ${sequence}: ${agentName}; role=${opts.role || 'worker'}; phase=${opts.phase || 'work'}; label=${opts.label || agentName}]`
   const agentOptions = {
     subagent_type: routeAgentType(opts.risk || 'medium', opts.role),
+    model: routeModel(opts.risk || 'medium'),
     effort: opts.risk === 'high' ? 'high' : 'medium',
   }
   if (opts.schema) agentOptions.schema = opts.schema

package/config/workflows/bizar-implement.js

@@ -38,6 +38,7 @@ const dispatchAgent = (agentFn, agentName, prompt, opts = {}) => {
   const prefix = `[Bizar dispatch ${sequence}: ${agentName}; role=${opts.role || 'worker'}; phase=${opts.phase || 'work'}; label=${opts.label || agentName}]`
   const agentOptions = {
     subagent_type: routeAgentType(opts.risk || 'medium', opts.role),
+    model: routeModel(opts.risk || 'medium'),
     effort: opts.risk === 'high' ? 'high' : 'medium',
   }
   if (opts.schema) agentOptions.schema = opts.schema

package/config/workflows/bizar-research.js

@@ -39,6 +39,7 @@ const dispatchAgent = (agentFn, agentName, prompt, opts = {}) => {
   const prefix = `[Bizar dispatch ${sequence}: ${agentName}; role=${opts.role || 'worker'}; phase=${opts.phase || 'work'}; label=${opts.label || agentName}]`
   const agentOptions = {
     subagent_type: routeAgentType(opts.risk || 'medium', opts.role),
+    model: routeModel(opts.risk || 'medium'),
     effort: opts.risk === 'high' ? 'high' : 'medium',
   }
   if (opts.schema) agentOptions.schema = opts.schema

package/config/workflows/ultracode-research.js

@@ -37,6 +37,7 @@ const dispatchAgent = (agentFn, agentName, prompt, opts = {}) => {
   const prefix = `[Bizar dispatch ${sequence}: ${agentName}; role=${opts.role || 'worker'}; phase=${opts.phase || 'work'}; label=${opts.label || agentName}]`
   const agentOptions = {
     subagent_type: routeAgentType(opts.risk || 'medium', opts.role),
+    model: routeModel(opts.risk || 'medium'),
     effort: opts.risk === 'high' ? 'high' : 'medium',
   }
   if (opts.schema) agentOptions.schema = opts.schema

package/config/workflows/ultracode-review.js

@@ -36,6 +36,7 @@ const dispatchAgent = (agentFn, agentName, prompt, opts = {}) => {
   const prefix = `[Bizar dispatch ${sequence}: ${agentName}; role=${opts.role || 'worker'}; phase=${opts.phase || 'work'}; label=${opts.label || agentName}]`
   const agentOptions = {
     subagent_type: routeAgentType(opts.risk || 'medium', opts.role),
+    model: routeModel(opts.risk || 'medium'),
     effort: opts.risk === 'high' ? 'high' : 'medium',
   }
   if (opts.schema) agentOptions.schema = opts.schema

package/config/workflows/ultracode.js

@@ -38,6 +38,7 @@ const dispatchAgent = (agentFn, agentName, prompt, opts = {}) => {
   const prefix = `[Bizar dispatch ${sequence}: ${agentName}; role=${opts.role || 'worker'}; phase=${opts.phase || 'work'}; label=${opts.label || agentName}]`
   const agentOptions = {
     subagent_type: routeAgentType(opts.risk || 'medium', opts.role),
+    model: routeModel(opts.risk || 'medium'),
     effort: opts.risk === 'high' ? 'high' : 'medium',
   }
   if (opts.schema) agentOptions.schema = opts.schema

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar",
-  "version": "10.23.22",
+  "version": "10.23.23",
   "description": "Autonomous, human-in-the-loop multi-agent harness for Claude Code with guarded workflows, typed SDK primitives, and MCP tools.",
   "type": "module",
   "bin": {

package/packages/sdk/dist/version.d.ts

@@ -1,5 +1,5 @@
 /**
  * SDK version constant. Keep synchronized with the workspace package versions.
  */
-export declare const SDK_VERSION: "10.23.22";
+export declare const SDK_VERSION: "10.23.23";
 //# sourceMappingURL=version.d.ts.map

package/packages/sdk/dist/version.js

@@ -1,5 +1,5 @@
 /**
  * SDK version constant. Keep synchronized with the workspace package versions.
  */
-export const SDK_VERSION = "10.23.22";
+export const SDK_VERSION = "10.23.23";
 //# sourceMappingURL=version.js.map

package/packages/sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar-sdk",
-  "version": "10.23.22",
+  "version": "10.23.23",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/config/claude/commands/migrate.md

@@ -1,18 +0,0 @@
----
-description: Migrate a legacy ~/.config/cline/ install to the user-level Claude Code directory.
-allowed-tools: Read, Bash
----
-
-# /migrate — Cline-era ~/.config/cline/ → ~/.claude/
-
-Runs `bizar migrate` once. It is safe to re-run.
-
-1. Detects `~/.config/cline/{settings.json,CLAUDE.md,agents,commands}` and any
-   other Cline-era surfaces that still live under `~/.config/`.
-2. Moves them under `~/.claude/` (or `$CLAUDE_CONFIG_DIR`) and reconciles
-   names with the current Claude Code conventions.
-3. Writes a stamp file `~/.claude/.bizar-cline-migration-stamp` recording the
-   source and Bizar version that performed the migration.
-
-No file is deleted. The original `~/.config/cline/` is left in place until you
-verify the move succeeded.

package/config/claude/commands/tailscale-serve.md

@@ -1,14 +0,0 @@
----
-description: Expose an explicitly selected local service through Tailscale Serve with confirmation.
----
-
-# Tailscale Serve
-
-This command is generic and does not start any Bizar service.
-
-1. Require the user to provide the local port or socket to expose.
-2. Verify the target is listening locally.
-3. Show the exact `tailscale serve` command and exposure scope.
-4. Ask before changing the machine's Tailscale Serve configuration.
-5. After approval, run the command and verify `tailscale serve status`.
-6. Report the public/private URL and the reversal command: `tailscale serve reset`.

package/config/claude/commands/tier.md

@@ -1,31 +0,0 @@
----
-description: Pick the cheapest Bizar tier that fits a task description; the same selection the @mike orchestrator makes.
-allowed-tools: Read, Bash
----
-
-# /tier — automatic task-based model selection
-
-Routes a task description through the same Bizar tier resolver the `@mike`
-orchestrator uses. Useful when you want to know which model an agent would
-land on before launching a session.
-
-```bash
-# After `npm install -g @polderlabs/bizar` the script lives at:
-bizar tier --agent mike "design a deterministic migration plan for X"
-bizar tier --list
-```
-
-Selection rules:
-
-1. The role default (`premium` / `high` / `mid-design` / `default` / `mid` /
-   `budget`) comes from the global Bizar router under `BIZAR_HOME`.
-2. Mike adjusts that default from the current task's risk and complexity. A
-   role never carries fixed `model:` frontmatter.
-3. If live model discovery reports a configured candidate for the chosen tier,
-   Mike passes the first matching candidate on the Agent call.
-4. If discovery is unavailable, stale, ambiguous, or has no matching candidate,
-   Mike uses the closest enabled configured tier candidate and keeps `model` explicit.
-5. A failed dispatch is not retried through aliases, providers, or tiers.
-
-The orchestrator's decision can be logged to `~/.config/bizar/tier.log` with a
-short rationale.

package/config/claude/commands/upgrade-defaults.md

@@ -1,34 +0,0 @@
----
-description: Apply the user-favored defaults to ~/.claude/settings.json — bypass permissions and enable background worktree isolation.
-allowed-tools: Read, Bash
----
-
-# /upgrade-defaults — set user-favored Claude Code defaults for Bizar
-
-Re-applies the defaults that pair with `bypassPermissions` mode and
-worktree-based background isolation:
-
-- `permissions.defaultMode = "bypassPermissions"`
-- `worktree.bgIsolation = "worktree"`
-- `model = first enabled user-selected or configured-tier model`
-- `alwaysThinkingEnabled = true`
-- `effortLevel = "high"`
-- `skipDangerousModePermissionPrompt = true`
-- `showThinkingSummaries = true`
-- `askUserQuestionTimeout = "5m"`
-
-The command preserves any user-set value that is more restrictive than the
-default (e.g. if `defaultMode` is already `acceptEdits`, it stays). Every
-unrelated key — `mcpServers`, `hooks`, `env`, `attribution`, `enabledPlugins`,
-`extraKnownMarketplaces` — is preserved verbatim.
-
-```bash
-# Preview the diff without writing.
-bizar upgrade-defaults --dry-run
-
-# Apply (writes a timestamped .bak-<stamp> alongside settings.json first).
-bizar upgrade-defaults
-```
-
-This command preserves unrelated settings and creates a timestamped backup
-before changing Bizar-owned defaults.

package/config/claude/commands/use-default.md

@@ -1,12 +0,0 @@
----
-description: Show the configured model Bizar will use for ordinary work.
-allowed-tools: Bash
-disable-model-invocation: true
----
-
-# /use-default
-
-Run `bizar tier --agent mike --json "ordinary repository task"`. Report the
-first enabled configured candidate and the global router path. Do not hardcode
-a provider or write project-local model settings. To change the global picks,
-run `bizar models`.

package/config/claude/commands/use-premium.md

@@ -1,12 +0,0 @@
----
-description: Show the configured model Bizar will use for high-risk reasoning.
-allowed-tools: Bash
-disable-model-invocation: true
----
-
-# /use-premium
-
-Run `bizar tier --agent carl --json "high-risk architecture and debugging"`.
-Report the first enabled configured candidate and the global router path. Do
-not hardcode a model, invent a cost ceiling, or create project-local overrides.
-To change premium candidates globally, run `bizar models`.