@polderlabs/bizar 10.25.2 → 10.26.0

package/README.md

@@ -35,21 +35,22 @@ the project you happen to be working on.
 
 | 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 |
+| A clean way to begin | A guided installer and a static four-alias dispatch surface |
+| Your own gateway models | Four native aliases (`haiku`/`sonnet`/`opus`/`fable`) with OmniRoute handling ordered failover between configured full IDs |
 | 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.
+Install Bizar globally and its Claude Code integration. Bizar dispatches
+through four static native aliases — `haiku`, `sonnet`, `opus`, `fable` —
+and OmniRoute handles ordered failover between configured full IDs for the
+chosen alias, so there is no model picker step.
 
 ```sh
 npm install -g @polderlabs/bizar
 bizar install
-bizar models
 ```
 
 Restart Claude Code after installation. The installer adds Bizar's agents, skills, commands, hooks, settings, and the
@@ -59,19 +60,18 @@ for Bizar and OpenKan, not for the Claude Code CLI.
 It preserves your configured gateway endpoint and credential values during a
 clean reinstall.
 
-On a new interactive install, Bizar also asks for an optional default model,
-whether Claude Code agent teams should be enabled, the OpenKan install
-directory, and whether the current project should receive a `.ok/` workspace.
-OpenKan is installed from npm as `@polderlabs/openkan@latest`; its package-owned
-agent and skill are installed into the same Claude configuration. Use
-`bizar install --yes` for CI or a prompt-free refresh.
+On a new interactive install, Bizar also asks whether Claude Code agent teams
+should be enabled, the OpenKan install directory, and whether the current
+project should receive a `.ok/` workspace. OpenKan is installed from npm as
+`@polderlabs/openkan@latest`; its package-owned agent and skill are
+installed into the same Claude configuration. Use `bizar install --yes` for
+CI or a prompt-free refresh.
 
 For a completely fresh Bizar-managed Claude setup while retaining endpoint and
 authentication settings:
 
 ```sh
 bizar install --force
-bizar models
 ```
 
 Then open any repository in Claude Code and describe the outcome you want.
@@ -107,40 +107,36 @@ foregrounded.
 
 ## Your models, everywhere Bizar dispatches
 
-`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:
+Bizar dispatches through four static native aliases — `haiku`, `sonnet`,
+`opus`, `fable`. Claude Code's native per-call `model` field accepts one of
+these aliases. OmniRoute handles ordered failover between the configured full
+gateway IDs for the chosen alias, so the operator never picks a picker-style
+gateway ID per agent at this layer. There is no `bizar models` picker, no
+`model-router.json`, no `userSelected` block, and no Agent-model-guard hook.
 
-```text
-~/.claude/model-router.json
-```
+The four aliases are the entire dispatch surface:
 
-The router is never stored in a project directory. Bizar uses the selected
-models for direct subagents, workflows, and agent-team teammates.
+- `haiku` — trivial / cheap micro-edits
+- `sonnet` — ordinary implementation, research, planning lanes
+- `opus` — hard / architectural / adversarial / debug / high-risk review lanes
+- `fable` — explicit Anthropic OpenAI-compat surfaces
+
+Workflow scripts (`config/workflows/*.js`) inline a tiny `dispatchAgent`
+wrapper that picks the alias from a static policy; agent definitions stay
+model-agnostic so the harness, not the agent, owns alias selection.
 
 ```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"]
+    Policy["Static alias policy\n(office-manager.md + workflow routeModel)"] --> Aliases["haiku · sonnet · opus · fable"]
+    Aliases --> OmniRoute["OmniRoute ordered failover\nper configured full ID"]
+    OmniRoute --> Agent["Subagents"]
+    OmniRoute --> Workflow["Workflow workers"]
+    OmniRoute --> 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 models --list
-bizar models --agent-types --json
-bizar models explain todd
 bizar doctor
 ```
 
@@ -153,9 +149,7 @@ 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.
+risk. It does not create parallel workers merely to look busy.
 
 ```text
 Core coordination                 Specialist coverage
@@ -195,7 +189,7 @@ point where an external or difficult-to-reverse decision belongs to you.
 ├── 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
+└── agents/          Bizar agent definitions (alias-agnostic)
 
 ~/.config/bizar/
 ├── installed.json   install record
@@ -217,7 +211,6 @@ plane, background daemon, or general-purpose note vault.
 | `bizar install` | Install or refresh Bizar, OpenKan, and the global Claude configuration |
 | `bizar openkan install` | Refresh the managed `@polderlabs/openkan` npm runtime and its agent/skill |
 | `bizar openkan init` | Initialise `.ok/` planning state in the current project |
-| `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 |
 | `ok task` | Inspect or coordinate scoped worktree tasks (OpenKan-native) |

package/cli/bin.mjs

@@ -108,7 +108,6 @@ function showHelp() {
     artifact               Toggle global browser completion artifacts
     learn                  Manage bounded global preferences and project lessons
     tools                  Inventory installed agents, skills, hooks, commands, and MCP tools
-    tier                   Explain the explicit configured model tier for a task
     upgrade-defaults       Reapply safe Bizar-owned Claude defaults
     backup                 Create / list / verify / delete backups of BizarHarness state
     restore                Restore BizarHarness from a backup
@@ -136,12 +135,10 @@ function showHelp() {
     hook <name>            Run a portable Claude Code hook
     worktree-merge <branch>  Merge a feature branch with archive tag (no work lost)
     worker <subcommand>      Run an exact-model Claude process worker in a worktree
-    models                 Configure the global model picker and Models.dev metadata
     evidence <subcommand>  Inspect model-routing evidence
     improve <subcommand>   Propose and verify bounded self-edits
     sandbox <subcommand>   Manage local execution sandboxes
     explain-run <id>       Explain a recorded run
-    model                  Deprecated alias for models
 
   Examples:
     bizar install
@@ -452,22 +449,6 @@ async function main() {
       break;
     }
 
-    case 'models': {
-      const mod = await importCommand('models');
-      if (!mod) {
-        console.error(chalk.red(`  ✗ Could not load models command module`));
-        process.exit(EXIT_ERROR);
-        return;
-      }
-      dbg('loaded command module:', 'models');
-      const found = await mod.run(cmd, cmdArgs, isHelpRequest);
-      if (found === false) {
-        console.error(chalk.red(`  ✗ Usage: bizar models [--list|--set|--clear|--json] — run 'bizar models --help'`));
-        process.exit(EXIT_USAGE);
-      }
-      break;
-    }
-
     case 'artifact': {
       const mod = await importCommand('artifact');
       if (!mod) { process.exit(EXIT_ERROR); return; }
@@ -483,7 +464,6 @@ async function main() {
     }
 
     case 'tools':
-    case 'tier':
     case 'upgrade-defaults': {
       const mod = await importCommand(cmd);
       if (!mod) { process.exit(EXIT_ERROR); return; }
@@ -615,29 +595,6 @@ async function main() {
       break;
     }
 
-    case 'model': {
-      // Deprecated alias. Routes to the original `model.mjs` so the
-      // legacy JSON shape (`{ providers: { ... }, total: N }`) and table
-      // output keep working for existing scripts and tests. New code
-      // should use `bizar models` (see `case 'models'`).
-      const mod = await importCommand('model');
-      if (!mod) {
-        console.error(chalk.red(`  ✗ Could not load model command module`));
-        process.exit(EXIT_ERROR);
-        return;
-      }
-      dbg('loaded command module (deprecated alias):', 'model');
-      if (!isHelpRequest) {
-        console.error(chalk.yellow('  ! `bizar model` is deprecated; use `bizar models` for the new picker surface.'));
-      }
-      const found = await mod.run(cmd, cmdArgs, isHelpRequest);
-      if (found === false) {
-        console.error(chalk.red(`  ✗ Usage: bizar model <subcommand> — run 'bizar model --help'`));
-        process.exit(EXIT_USAGE);
-      }
-      break;
-    }
-
     case 'workflow': {
       const mod = await importCommand('workflow');
       if (!mod) {

package/cli/commands/hook.mjs

@@ -18,14 +18,12 @@ const HOOK_ROOT = resolve(PACKAGE_ROOT, 'config', 'claude', 'hooks');
 const PRETOOL_SAFETY_LEAVES = new Set([
   'pretooluse-editwrite', 'path-ownership-guard',
   'pretooluse-bash', 'git-workflow-guard',
-  'agent-model-guard',
   'workflow-route-guard',
 ]);
 
 export const HOOK_PROGRAMS = Object.freeze({
   'advisor-context': 'advisor-context.mjs',
   'agent-grounding': 'agent-grounding.mjs',
-  'agent-model-guard': 'agent-model-guard.mjs',
   'content-style-guard': 'content-style-guard.mjs',
   'completion-artifact': 'completion-artifact.mjs',
   'control-inbox': 'control-inbox.mjs',
@@ -40,11 +38,9 @@ export const HOOK_PROGRAMS = Object.freeze({
   'pretooluse-bash': 'pretooluse-bash.mjs',
   'pretooluse-editwrite': 'pretooluse-editwrite.mjs',
   'sessionend-recall': 'sessionend-recall.mjs',
-  'sessionstart-model-sync': 'sessionstart-model-sync.mjs',
   'sessionstart-prime': 'sessionstart-prime.mjs',
   'simplify-guard': 'simplify-guard.mjs',
   telemetry: 'telemetry.mjs',
-  'thinking-route': 'thinking-route.mjs',
   'team-lifecycle': 'team-lifecycle.mjs',
   'verify-deliverables': 'verify-deliverables.mjs',
   'worker-suggest': 'worker-suggest.mjs',
@@ -59,12 +55,10 @@ export const EVENT_CHAINS = Object.freeze({
     'keyword-router',
     'workflow-route-guard',
     'worker-suggest',
-    'thinking-route',
     'telemetry',
   ]),
   'session-start': Object.freeze([
     'control-inbox',
-    'sessionstart-model-sync',
     'sessionstart-prime',
     'persistent-mode',
     'telemetry',
@@ -238,7 +232,6 @@ export function selectEventChain(eventKey, input = '') {
     if (toolName === 'Bash') {
       return ['workflow-route-guard', 'pretooluse-bash', 'git-workflow-guard'];
     }
-    if (toolName === 'Agent') return ['workflow-route-guard', 'agent-model-guard'];
     return [];
   }
 

package/cli/commands/setup-provider.mjs

@@ -43,7 +43,9 @@ export function updateProviderSettings(current, options) {
   const next = { ...current, env: { ...(current.env || {}) } };
   if (options.gateway !== undefined) {
     next.env.ANTHROPIC_BASE_URL = options.gateway;
-    next.env.BIZAR_MODEL_ROUTER_URL = options.gateway;
+    // Legacy compatibility: drop any pre-existing router-URL mirror so the
+    // install surface converges on a single provider URL.
+    delete next.env.BIZAR_MODEL_ROUTER_URL;
   }
   if (options.key !== undefined) next.env.ANTHROPIC_AUTH_TOKEN = options.key;
   if (options.model !== undefined) next.env.ANTHROPIC_MODEL = options.model;
@@ -87,7 +89,7 @@ export async function runSetupProvider(args = []) {
 
   if (options.list) {
     console.log(`  Settings: ${path}`);
-    console.log(`  Gateway: ${current.env?.ANTHROPIC_BASE_URL || current.env?.BIZAR_MODEL_ROUTER_URL || '(Anthropic default)'}`);
+    console.log(`  Gateway: ${current.env?.ANTHROPIC_BASE_URL || '(Anthropic default)'}`);
     console.log(`  Model:   ${current.env?.ANTHROPIC_MODEL || '(Claude Code default)'}`);
     console.log(`  API key: ${redact(current.env?.ANTHROPIC_AUTH_TOKEN || current.env?.ANTHROPIC_API_KEY)}`);
     return { ok: true, path, settings: current };

package/cli/commands/tools.mjs

@@ -15,7 +15,7 @@ import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-import { resolveClaudeConfigDir, resolveGlobalModelRouter } from '../config-paths.mjs';
+import { resolveClaudeConfigDir } from '../config-paths.mjs';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = resolve(__filename, '..', '..');
 const CLAUDE_DIR = resolveClaudeConfigDir();
@@ -80,8 +80,6 @@ export async function runTools(cmdArgs) {
 
   const settingsPath = join(CLAUDE_DIR, 'settings.json');
   const hasSettings = existsSync(settingsPath);
-  const modelRouterPath = resolveGlobalModelRouter();
-  const hasModelRouter = existsSync(modelRouterPath);
 
   const summary = {
     userLevel: CLAUDE_DIR,
@@ -92,7 +90,6 @@ export async function runTools(cmdArgs) {
     wiredCommands,
     mcpTools,
     settings: { path: settingsPath, present: hasSettings },
-    modelRouter: { path: modelRouterPath, present: hasModelRouter },
   };
 
   if (asJson) {
@@ -118,8 +115,24 @@ export async function runTools(cmdArgs) {
   section(`wired bizar commands (${wiredCommands.length})`, wiredCommands.map((c) => 'bizar ' + c));
   console.log(chalk.bold('\n  settings'));
   console.log(`    ${hasSettings ? '✓' : '✗'} ${settingsPath}`);
-  console.log(chalk.bold('  model-router'));
-  console.log(`    ${hasModelRouter ? '✓' : '✗'} ${modelRouterPath}`);
+  if (hasSettings) {
+    try {
+      const parsed = JSON.parse(readFileSync(settingsPath, 'utf8'));
+      const env = (parsed && parsed.env) || {};
+      const aliases = {
+        sonnet: env.ANTHROPIC_DEFAULT_SONNET_MODEL,
+        haiku: env.ANTHROPIC_DEFAULT_HAIKU_MODEL,
+        opus: env.ANTHROPIC_DEFAULT_OPUS_MODEL,
+        fable: env.ANTHROPIC_DEFAULT_FABLE_MODEL,
+      };
+      console.log(chalk.bold('  alias map'));
+      for (const [key, value] of Object.entries(aliases)) {
+        console.log(`    ${key.padEnd(8)} → ${value || '(unset)'}`);
+      }
+      const model = parsed?.model;
+      if (model) console.log(chalk.dim(`    default model: ${model}`));
+    } catch { /* ignore malformed settings */ }
+  }
 }
 
 export async function run(name, args, isHelpRequest) {

package/cli/commands/upgrade-defaults.mjs

@@ -35,42 +35,18 @@
 import chalk from 'chalk';
 import { existsSync, readFileSync, writeFileSync, copyFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { resolveClaudeConfigDir, resolveGlobalModelRouter } from '../config-paths.mjs';
-import { configuredFallbackModels } from './models.mjs';
+import { resolveClaudeConfigDir } from '../config-paths.mjs';
 
 const CLAUDE_DIR = resolveClaudeConfigDir();
 const SETTINGS_PATH = join(CLAUDE_DIR, 'settings.json');
-// 10.22.0 / Phase 4 spirit-of-constraint: the install model id comes
-// from the operator's `userSelected.models[0]`, not a hardcoded literal.
-// The Bizar global router is the sole model-policy source.
-const BIZAR_ROUTER_PATH = resolveGlobalModelRouter();
-
-function readConfiguredModels() {
-  for (const path of [BIZAR_ROUTER_PATH]) {
-    if (!existsSync(path)) continue;
-    try {
-      const parsed = JSON.parse(readFileSync(path, 'utf8'));
-      const list = Array.isArray(parsed?.userSelected?.models)
-        ? parsed.userSelected.models.filter((id) => typeof id === 'string' && id.trim())
-        : [];
-      if (list.length > 0) return list;
-      const fallback = configuredFallbackModels(parsed);
-      if (fallback.length > 0) return fallback;
-      // An explicit empty selection is an intentional global policy.
-      if (path === BIZAR_ROUTER_PATH && parsed && typeof parsed === 'object'
-          && Array.isArray(parsed.userSelected?.models)) {
-        return [];
-      }
-    } catch { /* keep falling through */ }
-  }
-  return [];
-}
 
 const STATIC_FAVORED = {
   permissions: { defaultMode: 'bypassPermissions' },
   worktree: { bgIsolation: 'worktree' },
-  // `model` is intentionally absent — `buildFavored()` derives it from
-  // userSelected.models[0] (or omits it when empty).
+  // `model` is intentionally absent — settings.json ships the alias
+  // binding (model + modelOverrides + the four ANTHROPIC_DEFAULT_*_MODEL
+  // env vars) as the canonical source. `upgrade-defaults` only re-applies
+  // the safe Bizar-owned UX defaults, not model policy.
   alwaysThinkingEnabled: true,
   effortLevel: 'high',
   skipDangerousModePermissionPrompt: true,
@@ -79,10 +55,7 @@ const STATIC_FAVORED = {
 };
 
 function buildFavored() {
-  const out = { ...STATIC_FAVORED };
-  const picks = readConfiguredModels();
-  if (picks[0]) out.model = picks[0];
-  return out;
+  return { ...STATIC_FAVORED };
 }
 
 export async function run(name, args, isHelpRequest) {

package/cli/commands/util.mjs

@@ -82,7 +82,7 @@ export function showDoctorHelp() {
       • hook wiring
       • installed agents and skills
       • required local tools
-      • model-router reachability
+      • alias map (ANTHROPIC_DEFAULT_*_MODEL)
 
     Prints ✓/✗ for each check and a final summary. Exits non-zero
     if any check fails. Use \`bizar doctor\` after installation or

package/cli/commands/validate.mjs

@@ -26,8 +26,7 @@ import chalk from 'chalk';
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { spawnSync } from 'node:child_process';
-import { resolveBizarHome, resolveClaudeConfigDir, resolveGlobalModelRouter } from '../config-paths.mjs';
-import { configuredEnabledModels, listModels, resolveEndpoint } from './models.mjs';
+import { resolveBizarHome, resolveClaudeConfigDir } from '../config-paths.mjs';
 
 function claudeDir() { return resolveClaudeConfigDir(); }
 function bizarHome() { return resolveBizarHome(); }
@@ -54,9 +53,13 @@ export const REQUIRED_COMMANDS = [
 ];
 
 // v6.3.0 — Claude Code hook adapter scripts (executable, .mjs extension).
+// OmniRoute alias-routing overhaul (10.25.x): `agent-model-guard.mjs` and
+// `sessionstart-model-sync.mjs` are removed from active registration AND
+// from required-hook validation. Settings.json's model + modelOverrides
+// is the sole alias binding; native Claude Code validates the alias/model
+// setting on its own.
 export const REQUIRED_HOOKS = [
   'agent-grounding.mjs',
-  'agent-model-guard.mjs',
   'advisor-context.mjs',
   'bizar-hook-wrapper.sh',
   'completion-artifact.mjs',
@@ -73,12 +76,10 @@ export const REQUIRED_HOOKS = [
   'pretooluse-bash.mjs',
   'pretooluse-editwrite.mjs',
   'sessionend-recall.mjs',
-  'sessionstart-model-sync.mjs',
   'sessionstart-prime.mjs',
   'simplify-guard.mjs',
   'team-lifecycle.mjs',
   'telemetry.mjs',
-  'thinking-route.mjs',
   'verify-deliverables.mjs',
   'worker-suggest.mjs',
   'workflow-route-guard.mjs',
@@ -350,22 +351,27 @@ const CHECKS = {
   },
 
   'provider-reachable': async () => {
-    const { endpoint, authToken } = resolveEndpoint();
-    if (!endpoint) {
-      const path = resolveGlobalModelRouter();
-      const router = readJsonSafe(path);
-      const fallback = router ? configuredEnabledModels(router) : [];
-      if (fallback.length === 0) {
-        throw new Error(`no gateway URL or enabled configured model in ${path}; implicit defaults are prohibited`);
-      }
-      return `no gateway URL; explicit configured fallback is ${fallback[0]}`;
-    }
-    try {
-      const models = await listModels({ endpoint, authToken, timeoutMs: 4000 });
-      return `provider reachable at ${endpoint} (${models.length} models)`;
-    } catch (err) {
-      throw new Error(`provider at ${endpoint} unreachable: ${err.message ?? err}`);
+    // The picker/router is gone. Provider reachability is the operator's
+    // concern — Claude Code (or any HTTP client) probes its own gateway.
+    // We only confirm an operator-configured gateway URL is present and
+    // that the four alias env vars map to the four OmniRoute combos.
+    const path = settingsJsonPath();
+    const settings = readJsonSafe(path);
+    const env = (settings && typeof settings === 'object' && settings.env) || {};
+    const aliasMap = {
+      sonnet: env.ANTHROPIC_DEFAULT_SONNET_MODEL,
+      haiku: env.ANTHROPIC_DEFAULT_HAIKU_MODEL,
+      opus: env.ANTHROPIC_DEFAULT_OPUS_MODEL,
+      fable: env.ANTHROPIC_DEFAULT_FABLE_MODEL,
+    };
+    const missing = Object.entries(aliasMap).filter(([, v]) => typeof v !== 'string' || !v.trim()).map(([k]) => k);
+    if (missing.length > 0) {
+      throw new Error(`alias env map missing entries in ${path}: ${missing.join(', ')}`);
     }
+    const endpoint = env.ANTHROPIC_BASE_URL;
+    return endpoint
+      ? `provider gateway configured at ${endpoint}; aliases: sonnet→${aliasMap.sonnet}, haiku→${aliasMap.haiku}, opus→${aliasMap.opus}, fable→${aliasMap.fable}`
+      : `no gateway URL configured; default provider is Anthropic; aliases: sonnet→${aliasMap.sonnet}, haiku→${aliasMap.haiku}, opus→${aliasMap.opus}, fable→${aliasMap.fable}`;
   },
 
   'claude-md-mirrored': async () => {

package/cli/commands/worker.mjs

@@ -1,16 +1,21 @@
 /**
- * Exact-model process workers.
+ * Process workers spawned with a native Claude alias.
  *
  * This command is the separately launched alternative: it creates an isolated
- * worktree and starts a top-level Claude process with the literal gateway ID
- * selected through `bizar models`. No global settings are rewritten per
- * worker, so parallel workers cannot race each other's model selection.
+ * worktree and starts a top-level Claude process with a native alias
+ * (default `sonnet`). No global settings are rewritten per worker, so
+ * parallel workers cannot race each other's model selection. The alias is
+ * passed through to `claude --model <alias>`; native Claude Code is the
+ * sole authority on alias-to-combo resolution.
  */
 import { spawn, spawnSync } from 'node:child_process';
 import { createWriteStream, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import { basename, dirname, join } from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { resolveBizarHome, resolveClaudeConfigDir, resolveGlobalModelRouter } from '../config-paths.mjs';
+import { resolveBizarHome, resolveClaudeConfigDir } from '../config-paths.mjs';
+
+const NATIVE_ALIASES = Object.freeze(new Set(['sonnet', 'haiku', 'opus', 'fable']));
+const DEFAULT_ALIAS = 'sonnet';
 
 function runGit(args, cwd) {
   const result = spawnSync('git', args, { cwd, encoding: 'utf8' });
@@ -18,14 +23,18 @@ function runGit(args, cwd) {
   return result.stdout.trim();
 }
 
-function readRouter() {
-  const path = resolveGlobalModelRouter();
-  try { return JSON.parse(readFileSync(path, 'utf8')); } catch { throw new Error('Global Bizar model router is missing or invalid; run `bizar models`.'); }
+function normalizeAlias(value) {
+  const alias = typeof value === 'string' && value.trim() ? value.trim().toLowerCase() : DEFAULT_ALIAS;
+  if (!NATIVE_ALIASES.has(alias)) {
+    throw new Error(`worker start requires a native alias (sonnet | haiku | opus | fable); got "${alias}"`);
+  }
+  return alias;
 }
 
-export function enabledModels(router) {
-  const disabled = new Set((router.disabledProviders || []).filter((id) => typeof id === 'string').map((id) => id.trim().toLowerCase()));
-  return (router.userSelected?.models || []).filter((id) => typeof id === 'string' && id.trim() && ![...disabled].some((prefix) => id.toLowerCase().startsWith(prefix)));
+export function enabledModels() {
+  // Retained for backwards compatibility with `cli/commands/worker.test.mjs`.
+  // The picker is gone; native aliases are the only legal `model` values.
+  return [...NATIVE_ALIASES];
 }
 
 function workerRoot() { return join(resolveBizarHome(), 'workers'); }
@@ -36,23 +45,21 @@ function writeState(state) {
 }
 
 export function buildWorkerPlan({ repoRoot = process.cwd(), model, task, agent = 'todd' } = {}) {
-  if (!model || typeof model !== 'string') throw new Error('worker start requires --model <selected gateway model id>.');
   if (!task || typeof task !== 'string') throw new Error('worker start requires --task <bounded task>.');
-  const router = readRouter();
-  if (!enabledModels(router).includes(model)) throw new Error(`Model ${model} is not an enabled global bizar models selection.`);
+  const normalized = normalizeAlias(model);
   const root = runGit(['rev-parse', '--show-toplevel'], repoRoot);
   const id = `worker-${randomUUID().slice(0, 8)}`;
   const branch = `wt/${id}`;
   const worktree = join(dirname(root), `${basename(root)}-${id}`);
   const logPath = join(workerRoot(), `${id}.log`);
-  return { id, root, branch, worktree, model, task: task.trim(), agent, logPath };
+  return { id, root, branch, worktree, model: normalized, task: task.trim(), agent, logPath };
 }
 
 export function workerClaudeArgs(plan) {
   return [
     '--print', '--name', `bizar-${plan.id}`, '--model', plan.model,
     '--permission-mode', 'acceptEdits', '--agent', plan.agent,
-    `${plan.task}\n\nYou are an exact-model Bizar process worker in ${plan.worktree}. Work only in this worktree. Do not spawn subagents. Implement and test the bounded task, commit one logical change locally, never push, then report the commit and verification.`,
+    `${plan.task}\n\nYou are an isolated Bizar process worker in ${plan.worktree}, running with the native "${plan.model}" alias. Work only in this worktree. Do not spawn subagents. Implement and test the bounded task, commit one logical change locally, never push, then report the commit and verification.`,
   ];
 }
 
@@ -75,12 +82,14 @@ function listWorkers() {
 
 function usage() {
   console.log(`
-  bizar worker start --model <selected-id> --task <task> [--agent todd] [--background]
+  bizar worker start --model <sonnet|haiku|opus|fable> --task <task> [--agent todd] [--background]
   bizar worker list [--json]
 
-  Starts an isolated top-level Claude Code process in a wt/ worktree with the
-  exact selected gateway model. Use this when a separately launched worktree
-  process is useful. Merge completed branches with bizar worktree-merge <branch>.
+  Starts an isolated top-level Claude Code process in a wt/ worktree with a
+  native alias. Default alias is "sonnet". Native Claude Code maps the
+  alias to an OmniRoute combo via the four ANTHROPIC_DEFAULT_*_MODEL
+  env vars in config/claude/settings.json. Merge completed branches with
+  bizar worktree-merge <branch>.
 `);
 }
 
@@ -108,7 +117,7 @@ export async function run(name, args, isHelpRequest) {
   });
   child.once('error', (error) => {
     writeState({ ...state, status: 'failed', exitedAt: new Date().toISOString(), error: error.message });
-    console.error(`Unable to start exact-model worker: ${error.message}`);
+    console.error(`Unable to start isolated worker: ${error.message}`);
   });
   state.pid = child.pid || null;
   writeState(state);