@polderlabs/bizar 10.23.14 → 10.23.16

package/cli/bin.mjs

@@ -129,6 +129,7 @@ function showHelp() {
     workflow <subcommand>  Session-bound autopilot workflow state
     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
@@ -613,6 +614,14 @@ async function main() {
       return;
     }
 
+    case 'worker': {
+      const mod = await importCommand('worker');
+      if (!mod) { process.exit(EXIT_ERROR); return; }
+      const found = await mod.run(cmd, cmdArgs, isHelpRequest);
+      if (found === false) process.exit(EXIT_USAGE);
+      break;
+    }
+
     case 'explain-run': {
       const mod = await importCommand('explain-run');
       if (!mod) {

package/cli/commands/models.mjs

@@ -18,7 +18,7 @@
  * reject user-selected IDs.
  */
 import chalk from 'chalk';
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import readline from 'node:readline';
 
@@ -991,6 +991,10 @@ export function applyModelOverrides({ settingsJsonPath, pickedIds, liveIds = [],
   // must be keys; configured gateway aliases are values. This also suppresses
   // print-mode `[claude-code:unrecognized_model]` diagnostics for Agent SDK calls.
   settings.modelOverrides = buildClaudeModelOverrides(synced);
+  const nativeAgentAliases = applyNativeAgentAliasTargets(settings, synced);
+  const generatedAgents = syncGeneratedModelAgents(synced, {
+    agentsDir: settingsJsonPath === undefined ? undefined : join(dirname(path), 'agents', 'bizar-models'),
+  });
   if (requiresGatewayModelDiscovery(synced)) {
     settings.env = {
       ...(settings.env || {}),
@@ -1020,6 +1024,8 @@ export function applyModelOverrides({ settingsJsonPath, pickedIds, liveIds = [],
     syncedIds: synced,
     skippedStale: skipped,
     skippedDisabled,
+    nativeAgentAliases,
+    generatedAgents,
     settingsPath: path,
   };
 }
@@ -1042,9 +1048,8 @@ export function configuredEnabledModels(router) {
 }
 
 export const CLAUDE_MODEL_OVERRIDE_KEYS = Object.freeze([
-  'claude-fable-5',
-  'claude-opus-5',
   'claude-sonnet-5',
+  'claude-opus-5',
   'claude-haiku-4-5-20251001',
   'claude-opus-4-8',
   'claude-opus-4-7',
@@ -1060,13 +1065,78 @@ export const CLAUDE_MODEL_OVERRIDE_KEYS = Object.freeze([
   'claude-3-5-sonnet-20241022',
 ]);
 
+// Claude Code's native Agent tool accepts these transport labels in the
+// installed runtime. They are labels only: Bizar binds them to the operator's
+// gateway IDs below; they never select an Anthropic provider by themselves.
+export const NATIVE_AGENT_ALIASES = Object.freeze(['sonnet', 'opus', 'haiku', 'fable']);
+
+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' });
+
+export function modelAgentName(modelId) {
+  return `bizar-model-${[...String(modelId || '').toLowerCase()].map((ch) => MODEL_AGENT_WORDS[ch] || 'unknown').join('-')}`;
+}
+
+export function syncGeneratedModelAgents(modelIds, opts = {}) {
+  const agentsDir = opts.agentsDir || join(resolveClaudeConfigDir(), 'agents', 'bizar-models');
+  const ids = [...new Set((Array.isArray(modelIds) ? modelIds : []).filter((id) => typeof id === 'string' && id.trim()).map((id) => id.trim()))];
+  if (existsSync(agentsDir)) rmSync(agentsDir, { recursive: true, force: true });
+  if (!ids.length) return { agentsDir, names: [] };
+  mkdirSync(agentsDir, { recursive: true, mode: 0o700 });
+  const names = ids.map((id) => modelAgentName(id));
+  ids.forEach((id, index) => writeFileSync(join(agentsDir, `${names[index]}.md`), `---\nname: ${names[index]}\ndescription: Bizar configured gateway model worker.\nmodel: ${id}\n---\n\nFollow the assigned Bizar role and task. Report concise evidence to the coordinator.\n`, { mode: 0o600 }));
+  return { agentsDir, names };
+}
+
+const NATIVE_AGENT_OVERRIDE_KEYS = Object.freeze({
+  sonnet: 'claude-sonnet-5',
+  opus: 'claude-opus-5',
+  haiku: 'claude-haiku-4-5-20251001',
+  fable: 'claude-fable-5',
+});
+
+export function buildNativeAgentAliasTargets(modelIds) {
+  const unique = [...new Set((Array.isArray(modelIds) ? modelIds : [])
+    .filter((id) => typeof id === 'string' && id.trim())
+    .map((id) => id.trim()))];
+  if (unique.length === 0) return {};
+  return Object.fromEntries(NATIVE_AGENT_ALIASES.map((alias, index) => [
+    alias,
+    unique[index] || unique[0],
+  ]));
+}
+
+export function applyNativeAgentAliasTargets(settings, modelIds) {
+  const targets = buildNativeAgentAliasTargets(modelIds);
+  const env = { ...(settings.env || {}) };
+  const envKeys = {
+    sonnet: 'ANTHROPIC_DEFAULT_SONNET_MODEL',
+    opus: 'ANTHROPIC_DEFAULT_OPUS_MODEL',
+    haiku: 'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+    fable: 'ANTHROPIC_DEFAULT_FABLE_MODEL',
+  };
+  for (const alias of NATIVE_AGENT_ALIASES) {
+    const envKey = envKeys[alias];
+    if (targets[alias]) env[envKey] = targets[alias];
+    else delete env[envKey];
+  }
+  settings.env = env;
+  return targets;
+}
+
 export function buildClaudeModelOverrides(modelIds) {
   const unique = [...new Set((Array.isArray(modelIds) ? modelIds : [])
     .filter((id) => typeof id === 'string' && id.trim())
     .map((id) => id.trim()))];
   if (unique.length === 0) return {};
-  return Object.fromEntries(CLAUDE_MODEL_OVERRIDE_KEYS
-    .map((key, index) => [key, unique[index % unique.length]]));
+  const targets = buildNativeAgentAliasTargets(unique);
+  const nativeEntries = NATIVE_AGENT_ALIASES.map((alias) => [
+    NATIVE_AGENT_OVERRIDE_KEYS[alias],
+    targets[alias],
+  ]);
+  const remaining = CLAUDE_MODEL_OVERRIDE_KEYS
+    .filter((key) => !Object.values(NATIVE_AGENT_OVERRIDE_KEYS).includes(key))
+    .map((key, index) => [key, unique[index % unique.length]]);
+  return Object.fromEntries([...nativeEntries, ...remaining]);
 }
 
 /** Custom gateway IDs must be discoverable to Claude's SDK/subagent path. */

package/cli/commands/worker.mjs

@@ -0,0 +1,125 @@
+/**
+ * Exact-model process workers.
+ *
+ * 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.
+ */
+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';
+
+function runGit(args, cwd) {
+  const result = spawnSync('git', args, { cwd, encoding: 'utf8' });
+  if (result.status !== 0) throw new Error((result.stderr || result.stdout || `git ${args.join(' ')} failed`).trim());
+  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`.'); }
+}
+
+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)));
+}
+
+function workerRoot() { return join(resolveBizarHome(), 'workers'); }
+function statePath(id) { return join(workerRoot(), `${id}.json`); }
+function writeState(state) {
+  mkdirSync(workerRoot(), { recursive: true, mode: 0o700 });
+  writeFileSync(statePath(state.id), JSON.stringify(state, null, 2) + '\n', { mode: 0o600 });
+}
+
+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 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 };
+}
+
+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.`,
+  ];
+}
+
+function parseStart(args) {
+  const value = (name) => {
+    const eq = args.find((arg) => arg.startsWith(`${name}=`));
+    if (eq) return eq.slice(name.length + 1);
+    const index = args.indexOf(name);
+    return index >= 0 ? args[index + 1] : null;
+  };
+  return { model: value('--model'), task: value('--task'), agent: value('--agent') || 'todd', background: args.includes('--background') };
+}
+
+function listWorkers() {
+  if (!existsSync(workerRoot())) return [];
+  return readdirSync(workerRoot()).filter((name) => name.endsWith('.json')).flatMap((name) => {
+    try { return [JSON.parse(readFileSync(join(workerRoot(), name), 'utf8'))]; } catch { return []; }
+  }).sort((a, b) => String(b.startedAt || '').localeCompare(String(a.startedAt || '')));
+}
+
+function usage() {
+  console.log(`
+  bizar worker start --model <selected-id> --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>.
+`);
+}
+
+export async function run(name, args, isHelpRequest) {
+  if (name !== 'worker') return false;
+  if (isHelpRequest || args.length === 0) { usage(); return true; }
+  const [subcommand] = args;
+  if (subcommand === 'list') {
+    const rows = listWorkers();
+    if (args.includes('--json')) process.stdout.write(JSON.stringify(rows, null, 2) + '\n');
+    else for (const row of rows) console.log(`${row.id}\t${row.status}\t${row.model}\t${row.branch}`);
+    return true;
+  }
+  if (subcommand !== 'start') { usage(); return false; }
+  const parsed = parseStart(args.slice(1));
+  const plan = buildWorkerPlan({ repoRoot: process.cwd(), ...parsed });
+  mkdirSync(workerRoot(), { recursive: true, mode: 0o700 });
+  runGit(['worktree', 'add', '-b', plan.branch, plan.worktree, 'HEAD'], plan.root);
+  const state = { ...plan, status: 'running', startedAt: new Date().toISOString(), pid: null };
+  const child = spawn(process.env.CLAUDE_BIN || 'claude', workerClaudeArgs(plan), {
+    cwd: plan.worktree,
+    env: { ...process.env, CLAUDE_CONFIG_DIR: resolveClaudeConfigDir() },
+    detached: parsed.background,
+    stdio: parsed.background ? ['ignore', 'pipe', 'pipe'] : 'inherit',
+  });
+  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}`);
+  });
+  state.pid = child.pid || null;
+  writeState(state);
+  child.once('exit', (code) => writeState({ ...state, status: code === 0 ? 'completed' : 'failed', exitedAt: new Date().toISOString(), exitCode: code ?? 1 }));
+  if (parsed.background) {
+    const log = createWriteStream(plan.logPath, { flags: 'a', mode: 0o600 });
+    child.stdout?.pipe(log); child.stderr?.pipe(log); child.unref();
+    console.log(JSON.stringify({ id: plan.id, status: 'running', model: plan.model, branch: plan.branch, worktree: plan.worktree }));
+    return true;
+  }
+  const code = await new Promise((done) => child.once('exit', (value) => done(value ?? 1)));
+  process.exitCode = code;
+  return true;
+}

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

@@ -17,7 +17,7 @@ default for meaningful work.
 | 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 Agent with an explicit Bizar model; integrate and verify |
+| 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 |
@@ -34,15 +34,18 @@ 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.
 
-Before every Workflow, Agent, or Agent-team call, read the global Bizar model router and construct a
-small `args.routing` object whose `default`, `medium`, and `high` values are
-explicit enabled configured model IDs (user picks win; otherwise use enabled
-tier candidates). Include the user's task in the same args object under the
-workflow's documented task field. Pass the exact enabled raw gateway ID chosen
-from `bizar models` as `model`; never substitute a Claude family alias. You may
-include that selection in `additionalContext.bizarConfiguredModel` for audit
-telemetry. If no configured model exists, stop and ask the operator to run
-`bizar models`; never retry by omitting `model` or using `inherit`.
+Before every Workflow, Agent, or Agent-team call, read the global Bizar model
+router and construct a small `args.routing` object whose `default`, `medium`,
+and `high` values are explicit enabled configured gateway IDs. Include the
+user's task in the same args object under the workflow's documented task field.
+Use the generated `bizar-models` user agent matching the chosen full gateway
+ID as `subagent_type`, and omit the native Agent `model` parameter entirely.
+That definition's frontmatter owns the full-ID selection for ordinary agents,
+workflows, and teams. Include the raw ID in `additionalContext.bizarConfiguredModel`
+for audit telemetry. Never use `inherit` or an unconfigured provider default.
+`sonnet`, `opus`, `haiku`, and `fable` are compatibility aliases only. If no
+generated configured definition exists, stop and ask the operator to run
+`bizar models`; never omit the generated agent type or cycle providers.
 
 Invoke the selected workflow by `name` first. If Claude reports that the Bizar
 name is unavailable, resolve the active Claude config directory and retry once
@@ -55,14 +58,16 @@ implementation around a broken workflow installation.
 
 ## Models
 
-For every Agent call, select the cheapest sufficient enabled configured model
+For every dispatch, select the cheapest sufficient enabled configured model
 from the global Bizar router. User-selected models take precedence over tier
-candidates; `disabledProviders` excludes both. Pass that raw selected custom
-ID directly; the guard verifies it is in the enabled selected pool. If no
-enabled configured candidate exists, stop with the configuration error. Never
-let Claude choose an unconfigured default, inherit the session model, or retry
-by cycling models, providers, or tiers. A single configured transport failover
-is allowed only when the router explicitly supplies it.
+candidates; `disabledProviders` excludes both. Native aliases are transport
+labels bound by `bizar models`, not Anthropic selections. Use the full selected
+model ID directly for native Agents and teams; every enabled selection is
+eligible. Use `bizar worker` only when a separately launched process worktree
+is useful. If no enabled configured candidate exists, stop with the
+configuration error. Never let Claude choose an unconfigured default, inherit
+the session model, use an unmapped alias,
+or retry by cycling models, providers, or tiers.
 
 ## Worktree Discipline and integration
 

package/config/claude/hooks/agent-model-guard.mjs

@@ -49,6 +49,7 @@ import { pathToFileURL } from 'node:url';
 
 import { loadModelRouter } from '../../../config/agents/model-assignment.mjs';
 import { resolveClaudeConfigDir } from '../../../cli/config-paths.mjs';
+import { modelAgentName } from '../../../cli/commands/models.mjs';
 
 function deny(reason) {
   return {
@@ -169,21 +170,32 @@ const NATIVE_AGENT_TRANSPORT_KEYS = Object.freeze({
   sonnet: 'claude-sonnet-5',
   opus: 'claude-opus-5',
   haiku: 'claude-haiku-4-5-20251001',
+  fable: 'claude-fable-5',
+});
+
+const NATIVE_AGENT_TRANSPORT_ENV_KEYS = Object.freeze({
+  sonnet: 'ANTHROPIC_DEFAULT_SONNET_MODEL',
+  opus: 'ANTHROPIC_DEFAULT_OPUS_MODEL',
+  haiku: 'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+  fable: 'ANTHROPIC_DEFAULT_FABLE_MODEL',
 });
 
 function readTransportTarget(alias, options = {}) {
   const key = NATIVE_AGENT_TRANSPORT_KEYS[alias];
   if (!key) return '';
-  const overrides = options.modelOverrides || (() => {
+  const settings = options.settings || (options.modelOverrides ? null : (() => {
     const settingsPath = options.settingsPath || join(resolveClaudeConfigDir(), 'settings.json');
-    try { return JSON.parse(readFileSync(settingsPath, 'utf8'))?.modelOverrides; } catch { return null; }
-  })();
+    try { return JSON.parse(readFileSync(settingsPath, 'utf8')); } catch { return null; }
+  })());
+  const envTarget = settings?.env?.[NATIVE_AGENT_TRANSPORT_ENV_KEYS[alias]];
+  if (typeof envTarget === 'string' && envTarget.trim()) return envTarget.trim();
+  const overrides = options.modelOverrides || settings?.modelOverrides;
   return typeof overrides?.[key] === 'string' ? overrides[key].trim() : '';
 }
 
 export async function guardAgentModel(input, options = {}) {
   if (!input || typeof input !== 'object') return {};
-  if (input.hook_event_name !== 'PreToolUse' || input.tool_name !== 'Agent') return {};
+  if (input.hook_event_name !== 'PreToolUse' || !['Agent', 'Task'].includes(input.tool_name)) return {};
   const toolInput = input.tool_input && typeof input.tool_input === 'object' ? input.tool_input : {};
   const requested = typeof toolInput.model === 'string' ? toolInput.model.trim() : '';
   const failoverBlock = readFailoverBlock(toolInput);
@@ -214,6 +226,8 @@ export async function guardAgentModel(input, options = {}) {
   // Inheritance is safe only when the auditable Bizar selection equals the
   // actual global Claude parent model and is a selected, enabled user pick.
   if (!requested || requested === 'inherit') {
+    const generated = typeof toolInput.subagent_type === 'string' && [...userPicks].some((id) => toolInput.subagent_type === modelAgentName(id));
+    if (generated && !requested) return {};
     const configured = configuredContext;
     const parent = readConfiguredParentModel(options);
     if (!configured || configured !== parent || !userPicks.has(configured)) {
@@ -234,6 +248,13 @@ export async function guardAgentModel(input, options = {}) {
     return {};
   }
 
+  // Claude Code accepts full model IDs for native Agent calls. A model picked
+  // through `bizar models` is therefore valid directly; do not collapse every
+  // user selection into the four family aliases.
+  if (userPicks.has(requested) && !hasFailoverContract) {
+    return {};
+  }
+
   // F-185 contract: when the orchestrator passes both `routingDecisionId`
   // and `fallback`, validate the fallback against the userSelected pool
   // but skip the live-discovery re-probe. The fallback's eligibility was

package/config/claude/hooks/sessionstart-model-sync.mjs

@@ -116,6 +116,28 @@ function requiresGatewayModelDiscovery(modelIds) {
   return modelIds.some((id) => !/^(?:claude(?:-|$)|anthropic(?:[./-]|$))/i.test(id));
 }
 
+// Bind Claude Code's four family aliases to the operator's selected gateway
+// IDs for compatibility. They never imply an Anthropic provider selection and
+// do not constrain full-ID native Agent dispatch.
+const NATIVE_AGENT_ALIASES = ['sonnet', 'opus', 'haiku', 'fable'];
+const NATIVE_AGENT_OVERRIDE_KEYS = {
+  sonnet: 'claude-sonnet-5',
+  opus: 'claude-opus-5',
+  haiku: 'claude-haiku-4-5-20251001',
+  fable: 'claude-fable-5',
+};
+const NATIVE_AGENT_ENV_KEYS = {
+  sonnet: 'ANTHROPIC_DEFAULT_SONNET_MODEL',
+  opus: 'ANTHROPIC_DEFAULT_OPUS_MODEL',
+  haiku: 'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+  fable: 'ANTHROPIC_DEFAULT_FABLE_MODEL',
+};
+
+function nativeAgentAliasTargets(modelIds) {
+  if (modelIds.length === 0) return {};
+  return Object.fromEntries(NATIVE_AGENT_ALIASES.map((alias, index) => [alias, modelIds[index] || modelIds[0]]));
+}
+
 function readSettingsPath() {
   return join(resolveClaudeConfigDir(), 'settings.json');
 }
@@ -217,18 +239,24 @@ function syncOnce() {
   });
 
   const overrideKeys = [
-    'claude-fable-5', 'claude-opus-5', 'claude-sonnet-5',
-    'claude-haiku-4-5-20251001', 'claude-opus-4-8', 'claude-opus-4-7',
+    'claude-sonnet-5', 'claude-opus-5', 'claude-haiku-4-5-20251001', 'claude-fable-5',
+    'claude-opus-4-8', 'claude-opus-4-7',
     'claude-opus-4-6', 'claude-sonnet-4-6', 'claude-opus-4-5-20251101',
     'claude-sonnet-4-5-20250929', 'claude-opus-4-1-20250805',
     'claude-opus-4-20250514', 'claude-sonnet-4-20250514',
     'claude-3-7-sonnet-20250219', 'claude-3-5-haiku-20241022',
     'claude-3-5-sonnet-20241022',
   ];
+  const aliasTargets = nativeAgentAliasTargets(liveIds);
   settings.modelPicker = { options };
   settings.modelOverrides = Object.fromEntries(
-    overrideKeys.map((key, index) => [key, liveIds[index % liveIds.length]]),
+    overrideKeys.map((key, index) => {
+      const alias = NATIVE_AGENT_ALIASES.find((candidate) => NATIVE_AGENT_OVERRIDE_KEYS[candidate] === key);
+      return [key, alias ? aliasTargets[alias] : liveIds[index % liveIds.length]];
+    }),
   );
+  settings.env = { ...(settings.env || {}) };
+  for (const alias of NATIVE_AGENT_ALIASES) settings.env[NATIVE_AGENT_ENV_KEYS[alias]] = aliasTargets[alias];
   if (requiresGatewayModelDiscovery(liveIds)) {
     settings.env = {
       ...(settings.env || {}),

package/config/workflows/bizar-debug.js

@@ -22,12 +22,15 @@ const WORKFLOW_DEFAULT_MODEL = typeof WORKFLOW_INPUT.model === 'string'
     : ''
 const routeModel = (risk) => {
   const candidate = WORKFLOW_ROUTING[risk] || WORKFLOW_ROUTING.default || WORKFLOW_DEFAULT_MODEL
-  return typeof candidate === 'string' ? candidate.trim() : ''
+  if (typeof candidate !== 'string') return ''
+  const selected = candidate.trim()
+  return selected
 }
-if (!routeModel('medium') || !routeModel('high')) {
+const routeAgentType = (risk) => WORKFLOW_ROUTING.agentTypes?.[routeModel(risk)] || ''
+if (!routeModel('medium') || !routeModel('high') || !routeAgentType('medium') || !routeAgentType('high')) {
   return {
     status: 'blocked',
-    reason: 'No explicit configured Bizar model routing was supplied. Read the global Bizar model router and retry with args.routing; provider defaults are prohibited.',
+    reason: 'No generated Bizar model-agent mapping was supplied for workflow routing. Run bizar models and retry; provider defaults are prohibited.',
   }
 }
 let WORKFLOW_DISPATCH_SEQUENCE = 0
@@ -35,7 +38,7 @@ const dispatchAgent = (agentFn, agentName, prompt, opts = {}) => {
   const sequence = ++WORKFLOW_DISPATCH_SEQUENCE
   const prefix = `[Bizar dispatch ${sequence}: ${agentName}; role=${opts.role || 'worker'}; phase=${opts.phase || 'work'}; label=${opts.label || agentName}]`
   const agentOptions = {
-    model: routeModel(opts.risk || 'medium'),
+    subagent_type: routeAgentType(opts.risk || 'medium'),
     effort: opts.risk === 'high' ? 'high' : 'medium',
   }
   if (opts.schema) agentOptions.schema = opts.schema

package/config/workflows/bizar-implement.js

@@ -21,12 +21,15 @@ const WORKFLOW_DEFAULT_MODEL = typeof WORKFLOW_INPUT.model === 'string'
     : ''
 const routeModel = (risk) => {
   const candidate = WORKFLOW_ROUTING[risk] || WORKFLOW_ROUTING.default || WORKFLOW_DEFAULT_MODEL
-  return typeof candidate === 'string' ? candidate.trim() : ''
+  if (typeof candidate !== 'string') return ''
+  const selected = candidate.trim()
+  return selected
 }
-if (!routeModel('medium') || !routeModel('high')) {
+const routeAgentType = (risk) => WORKFLOW_ROUTING.agentTypes?.[routeModel(risk)] || ''
+if (!routeModel('medium') || !routeModel('high') || !routeAgentType('medium') || !routeAgentType('high')) {
   return {
     status: 'blocked',
-    reason: 'No explicit configured Bizar model routing was supplied. Read the global Bizar model router and retry with args.routing; provider defaults are prohibited.',
+    reason: 'No generated Bizar model-agent mapping was supplied for workflow routing. Run bizar models and retry; provider defaults are prohibited.',
   }
 }
 let WORKFLOW_DISPATCH_SEQUENCE = 0
@@ -34,7 +37,7 @@ const dispatchAgent = (agentFn, agentName, prompt, opts = {}) => {
   const sequence = ++WORKFLOW_DISPATCH_SEQUENCE
   const prefix = `[Bizar dispatch ${sequence}: ${agentName}; role=${opts.role || 'worker'}; phase=${opts.phase || 'work'}; label=${opts.label || agentName}]`
   const agentOptions = {
-    model: routeModel(opts.risk || 'medium'),
+    subagent_type: routeAgentType(opts.risk || 'medium'),
     effort: opts.risk === 'high' ? 'high' : 'medium',
   }
   if (opts.schema) agentOptions.schema = opts.schema

package/config/workflows/bizar-research.js

@@ -22,12 +22,15 @@ const WORKFLOW_DEFAULT_MODEL = typeof WORKFLOW_INPUT.model === 'string'
     : ''
 const routeModel = (risk) => {
   const candidate = WORKFLOW_ROUTING[risk] || WORKFLOW_ROUTING.default || WORKFLOW_DEFAULT_MODEL
-  return typeof candidate === 'string' ? candidate.trim() : ''
+  if (typeof candidate !== 'string') return ''
+  const selected = candidate.trim()
+  return selected
 }
-if (!routeModel('medium') || !routeModel('high')) {
+const routeAgentType = (risk) => WORKFLOW_ROUTING.agentTypes?.[routeModel(risk)] || ''
+if (!routeModel('medium') || !routeModel('high') || !routeAgentType('medium') || !routeAgentType('high')) {
   return {
     status: 'blocked',
-    reason: 'No explicit configured Bizar model routing was supplied. Read the global Bizar model router and retry with args.routing; provider defaults are prohibited.',
+    reason: 'No generated Bizar model-agent mapping was supplied for workflow routing. Run bizar models and retry; provider defaults are prohibited.',
   }
 }
 let WORKFLOW_DISPATCH_SEQUENCE = 0
@@ -35,7 +38,7 @@ const dispatchAgent = (agentFn, agentName, prompt, opts = {}) => {
   const sequence = ++WORKFLOW_DISPATCH_SEQUENCE
   const prefix = `[Bizar dispatch ${sequence}: ${agentName}; role=${opts.role || 'worker'}; phase=${opts.phase || 'work'}; label=${opts.label || agentName}]`
   const agentOptions = {
-    model: routeModel(opts.risk || 'medium'),
+    subagent_type: routeAgentType(opts.risk || 'medium'),
     effort: opts.risk === 'high' ? 'high' : 'medium',
   }
   if (opts.schema) agentOptions.schema = opts.schema

package/config/workflows/lib/dispatch.js

@@ -33,6 +33,9 @@ import { existsSync, readFileSync, appendFileSync, mkdirSync, writeFileSync, ren
 import { homedir } from 'node:os';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
 
+const MODEL_AGENT_WORDS = { 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' };
+function modelAgentName(modelId) { return `bizar-model-${[...String(modelId || '').toLowerCase()].map((ch) => MODEL_AGENT_WORDS[ch] || 'unknown').join('-')}`; }
+
 const { O_APPEND, O_CREAT, O_WRONLY } = fsConstants;
 
 /* ────────────────────────────────────────────────────────────────────────── */
@@ -796,14 +799,12 @@ export function classifyDispatchOutcome(result, error, startMs) {
 }
 
 /**
- * Build the augmented agent-call payload. The native Agent model field cannot
- * carry selected gateway IDs directly. The guard validates that the raw ID is
- * an enabled Bizar selection before the native Agent tool sees it.
+ * Build an Agent payload that selects a generated full-ID model definition.
  */
-export function augmentPayload(opts, decision, agentName) {
+export function augmentPayload(opts, decision, agentName, context = {}) {
   return {
     ...opts,
-    model: decision.modelId,
+    subagent_type: modelAgentName(decision.modelId),
     additionalContext: {
       ...(opts.additionalContext && typeof opts.additionalContext === 'object' ? opts.additionalContext : {}),
       bizarConfiguredModel: decision.modelId ?? null,
@@ -858,13 +859,14 @@ export async function dispatchAgent(agentFn, agentName, prompt, opts = {}, conte
   if (!agentName || typeof agentName !== 'string') {
     throw new TypeError('dispatchAgent requires a non-empty agentName');
   }
-  const decision = computeDecision(agentName, prompt, opts, context);
+  const ctx = context ?? loadDispatchContext();
+  const decision = computeDecision(agentName, prompt, opts, ctx);
   if (!decision.modelId) {
     throw new ModelRoutingError(
       'No enabled configured model is available for this Agent dispatch. Configure a model tier or user selection with `bizar models`; refusing to inherit an unconfigured provider default.',
     );
   }
-  const augmented = augmentPayload(opts, decision, agentName);
+  const augmented = augmentPayload(opts, decision, agentName, ctx);
 
   // F-191 / IMP-018 audit trail — persist the decision before invoking
   // the agent. Best-effort: telemetry failures MUST NOT abort the

package/config/workflows/ultracode-research.js

@@ -20,12 +20,15 @@ const WORKFLOW_DEFAULT_MODEL = typeof WORKFLOW_INPUT.model === 'string'
     : ''
 const routeModel = (risk) => {
   const candidate = WORKFLOW_ROUTING[risk] || WORKFLOW_ROUTING.default || WORKFLOW_DEFAULT_MODEL
-  return typeof candidate === 'string' ? candidate.trim() : ''
+  if (typeof candidate !== 'string') return ''
+  const selected = candidate.trim()
+  return selected
 }
-if (!routeModel('medium') || !routeModel('high')) {
+const routeAgentType = (risk) => WORKFLOW_ROUTING.agentTypes?.[routeModel(risk)] || ''
+if (!routeModel('medium') || !routeModel('high') || !routeAgentType('medium') || !routeAgentType('high')) {
   return {
     status: 'blocked',
-    reason: 'No explicit configured Bizar model routing was supplied. Read the global Bizar model router and retry with args.routing; provider defaults are prohibited.',
+    reason: 'No generated Bizar model-agent mapping was supplied for workflow routing. Run bizar models and retry; provider defaults are prohibited.',
   }
 }
 let WORKFLOW_DISPATCH_SEQUENCE = 0
@@ -33,7 +36,7 @@ const dispatchAgent = (agentFn, agentName, prompt, opts = {}) => {
   const sequence = ++WORKFLOW_DISPATCH_SEQUENCE
   const prefix = `[Bizar dispatch ${sequence}: ${agentName}; role=${opts.role || 'worker'}; phase=${opts.phase || 'work'}; label=${opts.label || agentName}]`
   const agentOptions = {
-    model: routeModel(opts.risk || 'medium'),
+    subagent_type: routeAgentType(opts.risk || 'medium'),
     effort: opts.risk === 'high' ? 'high' : 'medium',
   }
   if (opts.schema) agentOptions.schema = opts.schema

package/config/workflows/ultracode-review.js

@@ -19,12 +19,15 @@ const WORKFLOW_DEFAULT_MODEL = typeof WORKFLOW_INPUT.model === 'string'
     : ''
 const routeModel = (risk) => {
   const candidate = WORKFLOW_ROUTING[risk] || WORKFLOW_ROUTING.default || WORKFLOW_DEFAULT_MODEL
-  return typeof candidate === 'string' ? candidate.trim() : ''
+  if (typeof candidate !== 'string') return ''
+  const selected = candidate.trim()
+  return selected
 }
-if (!routeModel('medium') || !routeModel('high')) {
+const routeAgentType = (risk) => WORKFLOW_ROUTING.agentTypes?.[routeModel(risk)] || ''
+if (!routeModel('medium') || !routeModel('high') || !routeAgentType('medium') || !routeAgentType('high')) {
   return {
     status: 'blocked',
-    reason: 'No explicit configured Bizar model routing was supplied. Read the global Bizar model router and retry with args.routing; provider defaults are prohibited.',
+    reason: 'No generated Bizar model-agent mapping was supplied for workflow routing. Run bizar models and retry; provider defaults are prohibited.',
   }
 }
 let WORKFLOW_DISPATCH_SEQUENCE = 0
@@ -32,7 +35,7 @@ const dispatchAgent = (agentFn, agentName, prompt, opts = {}) => {
   const sequence = ++WORKFLOW_DISPATCH_SEQUENCE
   const prefix = `[Bizar dispatch ${sequence}: ${agentName}; role=${opts.role || 'worker'}; phase=${opts.phase || 'work'}; label=${opts.label || agentName}]`
   const agentOptions = {
-    model: routeModel(opts.risk || 'medium'),
+    subagent_type: routeAgentType(opts.risk || 'medium'),
     effort: opts.risk === 'high' ? 'high' : 'medium',
   }
   if (opts.schema) agentOptions.schema = opts.schema

package/config/workflows/ultracode.js

@@ -21,12 +21,15 @@ const WORKFLOW_DEFAULT_MODEL = typeof WORKFLOW_INPUT.model === 'string'
     : ''
 const routeModel = (risk) => {
   const candidate = WORKFLOW_ROUTING[risk] || WORKFLOW_ROUTING.default || WORKFLOW_DEFAULT_MODEL
-  return typeof candidate === 'string' ? candidate.trim() : ''
+  if (typeof candidate !== 'string') return ''
+  const selected = candidate.trim()
+  return selected
 }
-if (!routeModel('medium') || !routeModel('high')) {
+const routeAgentType = (risk) => WORKFLOW_ROUTING.agentTypes?.[routeModel(risk)] || ''
+if (!routeModel('medium') || !routeModel('high') || !routeAgentType('medium') || !routeAgentType('high')) {
   return {
     status: 'blocked',
-    reason: 'No explicit configured Bizar model routing was supplied. Read the global Bizar model router and retry with args.routing; provider defaults are prohibited.',
+    reason: 'No generated Bizar model-agent mapping was supplied for workflow routing. Run bizar models and retry; provider defaults are prohibited.',
   }
 }
 let WORKFLOW_DISPATCH_SEQUENCE = 0
@@ -34,7 +37,7 @@ const dispatchAgent = (agentFn, agentName, prompt, opts = {}) => {
   const sequence = ++WORKFLOW_DISPATCH_SEQUENCE
   const prefix = `[Bizar dispatch ${sequence}: ${agentName}; role=${opts.role || 'worker'}; phase=${opts.phase || 'work'}; label=${opts.label || agentName}]`
   const agentOptions = {
-    model: routeModel(opts.risk || 'medium'),
+    subagent_type: routeAgentType(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.14",
+  "version": "10.23.16",
   "description": "Autonomous, human-in-the-loop multi-agent harness for Claude Code with guarded workflows, typed SDK primitives, and MCP tools.",
   "type": "module",
   "bin": {