@polderlabs/bizar 10.23.9 → 10.23.11

package/cli/commands/models.mjs

@@ -716,9 +716,8 @@ export function classifyKind(modelId) {
 // in-code hardcoded list — adding or removing a blocked provider is a
 // single JSON edit.
 //
-// Dual-path read: the Bizar path (`~/.config/bizar/config/claude/model-router.json`)
-// WINS when both exist, including an explicit `[]` (operators may pin
-// "no providers disabled" without deleting the legacy mirror). Whitespace
+// Global-only read: the Bizar path (`~/.config/bizar/config/claude/model-router.json`)
+// is the sole operator policy source. Whitespace
 // trim + lowercase normalization happens at read time so operators may
 // write `"  Anthropic  "` in JSON and still match `anthropic/...` model
 // ids. The comparison itself is a case-sensitive prefix filter against
@@ -758,44 +757,28 @@ function extractDisabledProviders(router) {
 
 /**
  * Read the operator's `disabledProviders` list from the model-router
- * config. Dual-path: the Bizar path wins when present (even with an
- * explicit empty array); the legacy `~/.claude/model-router.json` mirror
- * is the fallback. Both paths are normalized (trim + lowercase) at read.
+ * config. The Bizar global path is the only source. It is normalized (trim +
+ * lowercase) at read.
  *
  * Pure function over the filesystem; returns an empty array when neither
- * file exists, when both files lack the key, or when both reads fail.
+ * file exists, lacks the key, or cannot be read.
  *
- * @param {{ routerPath?: string, legacyPath?: string }} [opts]
+ * @param {{ routerPath?: string }} [opts]
  *   - `routerPath` defaults to the Bizar home path
  *     (`~/.config/bizar/config/claude/model-router.json`).
- *   - `legacyPath` defaults to the Claude Code mirror
- *     (`~/.claude/model-router.json`).
  * @returns {string[]} normalized disabled-provider prefixes
  */
-export function readDisabledProviders({ routerPath, legacyPath } = {}) {
+export function readDisabledProviders({ routerPath } = {}) {
   const bizarPath = routerPath || resolveGlobalModelRouter();
-  const fallPath = legacyPath || join(resolveClaudeConfigDir(), 'model-router.json');
   if (existsSync(bizarPath)) {
     try {
       const parsed = JSON.parse(readFileSync(bizarPath, 'utf8'));
       const extracted = extractDisabledProviders(parsed);
-      // Bizar path exists — its `disabledProviders` is authoritative even
-      // when explicitly `[]` (operators may pin "no providers disabled"
-      // without deleting the legacy mirror). Missing key still falls back.
+      // An explicit empty list is a valid global opt-out policy.
       if (Array.isArray(parsed && typeof parsed === 'object' ? parsed.disabledProviders : undefined)) {
         return extracted;
       }
-    } catch {
-      // Corrupt Bizar file — fall through to the legacy mirror.
-    }
-  }
-  if (existsSync(fallPath)) {
-    try {
-      const parsed = JSON.parse(readFileSync(fallPath, 'utf8'));
-      return extractDisabledProviders(parsed);
-    } catch {
-      return [];
-    }
+    } catch { return []; }
   }
   return [];
 }

package/cli/commands/tier.mjs

@@ -5,7 +5,7 @@
  * `bizar tier` — automatic task-based model selection.
  *
  * Replays the same tier resolution the @mike orchestrator uses:
- *  1. Read the role default from ~/.claude/model-router.json.
+ *  1. Read the role default from the global Bizar model router.
  *  2. Adjust the tier from current task risk and complexity.
  *  3. Print ordered candidates; dispatch uses a candidate only when live
  *     discovery proves it, otherwise Agent omits model and inherits the session.

package/cli/commands/upgrade-defaults.mjs

@@ -42,13 +42,11 @@ 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.
-// Dual-path read matches `cli/commands/models.mjs#readDisabledProviders`:
-// the Bizar path wins when present; the Claude Code mirror is fallback.
+// The Bizar global router is the sole model-policy source.
 const BIZAR_ROUTER_PATH = resolveGlobalModelRouter();
-const LEGACY_ROUTER_PATH = join(CLAUDE_DIR, 'model-router.json');
 
 function readConfiguredModels() {
-  for (const path of [BIZAR_ROUTER_PATH, LEGACY_ROUTER_PATH]) {
+  for (const path of [BIZAR_ROUTER_PATH]) {
     if (!existsSync(path)) continue;
     try {
       const parsed = JSON.parse(readFileSync(path, 'utf8'));
@@ -58,8 +56,7 @@ function readConfiguredModels() {
       if (list.length > 0) return list;
       const fallback = configuredFallbackModels(parsed);
       if (fallback.length > 0) return fallback;
-      // Bizar path exists with an explicit empty `userSelected.models` —
-      // honour that intent (do NOT fall through to the legacy mirror).
+      // An explicit empty selection is an intentional global policy.
       if (path === BIZAR_ROUTER_PATH && parsed && typeof parsed === 'object'
           && Array.isArray(parsed.userSelected?.models)) {
         return [];

package/cli/provision.mjs

@@ -31,7 +31,7 @@ import {
 import { homedir } from 'node:os';
 import { dirname, join, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { resolveBizarHome } from './config-paths.mjs';
+import { resolveBizarHome, resolveGlobalModelRouter } from './config-paths.mjs';
 import {
   buildClaudeModelOverrides,
   configuredEnabledModels,
@@ -465,9 +465,20 @@ export async function syncAgentFiles({ dryRun = false, force = false } = {}) {
   return { ok: true, message: `${copied} agent(s) synced (${skipped} kept)${sharedCopied ? `, ${sharedCopied} _shared/*.md` : ''}${tail}`, copied, skipped, pruned };
 }
 
-// The dynamic model router lives at config/claude/model-router.json and is
-// copied to user-level `$CLAUDE_CONFIG_DIR/model-router.json` so Mike and the
-// SDK can select tiers without a repository cwd dependency.
+// The dynamic model router is operator-owned state. It is created only under
+// Bizar's global config root; a repository can never supply a runtime model.
+
+export const EMPTY_GLOBAL_MODEL_ROUTER = {
+  $schema: 'https://bizar.dev/schema/model-router.v3.json',
+  version: '13.0.0',
+  endpoint: null,
+  disabledProviders: ['anthropic'],
+  userSelected: { models: [], lastUpdated: null, source: 'default-empty', tierHints: {} },
+  gateway: { required: false, endpoint: null, availabilityProbe: '/models', discoveryTimeoutMs: 3000, unavailableBehavior: 'configured-tier-fallback' },
+  tiers: Object.fromEntries(['premium', 'high', 'mid-design', 'default', 'mid', 'budget'].map((name) => [name, { models: [] }])),
+  roleDefaults: { mike: 'premium', paul: 'premium', carl: 'premium', karen: 'high', linda: 'high', ria: 'mid-design', greg: 'default', steve: 'default', oscar: 'mid', todd: 'mid', susan: 'mid', pam: 'budget', brenda: 'budget', janet: 'budget', kevin: 'budget', brad: 'mid-design' },
+  policies: { mainOrchestrator: 'mike', selectionOwner: 'orchestrator', dispatchModelOverride: 'required-configured-candidate', unknownAgent: 'configured-tier-fallback', discoveryFailure: 'configured-tier-fallback', unavailableModel: 'configured-tier-fallback', silentProviderSubstitution: false, retryModelAliases: false, snapshotDecisions: true, maxDispatchModelAttempts: 1 },
+};
 
 export function isBizarManagedModelRouter(value) {
   return Boolean(
@@ -479,16 +490,14 @@ export function isBizarManagedModelRouter(value) {
 }
 
 export async function syncModelRouter({ dryRun = false, force = false } = {}) {
-  const src = join(REPO_ROOT, 'config', 'claude', 'model-router.json');
-  const dest = join(CLAUDE_DIR, 'model-router.json');
-  if (!existsSync(src)) return { ok: true, message: `no model-router at ${src}` };
-  if (existsSync(dest) && !force && !isBizarManagedModelRouter(readJsonSafe(dest, null))) {
-    return { ok: true, message: `${dest} is user-managed — pass --force to overwrite`, preserved: true };
+  const dest = resolveGlobalModelRouter();
+  if (existsSync(dest)) {
+    return { ok: true, message: `${dest} is operator-managed — preserved`, preserved: true };
   }
-  if (dryRun) return { ok: true, message: `[dry-run] would copy ${src} → ${dest}` };
-  ensureDir(CLAUDE_DIR);
-  copyFileSync(src, dest);
-  return { ok: true, message: `model-router.json → ${dest}`, path: dest };
+  if (dryRun) return { ok: true, message: `[dry-run] would create global model router at ${dest}` };
+  ensureDir(dirname(dest));
+  writeFileSync(dest, `${JSON.stringify(EMPTY_GLOBAL_MODEL_ROUTER, null, 2)}\n`);
+  return { ok: true, message: `global model-router.json → ${dest}`, path: dest };
 }
 
 export async function syncSkillFiles({ dryRun = false, force = false } = {}) {
@@ -949,16 +958,12 @@ export function writeClaudeSettings({ dryRun = false, force = false } = {}) {
   // wins; otherwise the first enabled configured tier candidate is used.
   // This prevents Claude Code from falling through to an unconfigured
   // provider default when `userSelected.models` is intentionally empty.
-  // Dual-path read matches
-  // `cli/commands/models.mjs#readDisabledProviders` and
-  // `cli/commands/upgrade-defaults.mjs#readUserSelectedModels`.
-  const bizarRouterPath = process.env.BIZAR_MODEL_ROUTER_CONFIG?.trim()
-    || join(BIZAR_HOME(), 'config', 'claude', 'model-router.json');
-  const legacyRouterPath = join(CLAUDE_DIR, 'model-router.json');
+  // The Bizar global router is the sole source of model policy and picks.
+  const bizarRouterPath = resolveGlobalModelRouter();
   let installModel;
   let installContextTokens;
   let installModels = [];
-  for (const p of [bizarRouterPath, legacyRouterPath]) {
+  for (const p of [bizarRouterPath]) {
     if (!existsSync(p)) continue;
     const parsed = readJsonSafe(p, null);
     if (!parsed || typeof parsed !== 'object') continue;
@@ -966,8 +971,6 @@ export function writeClaudeSettings({ dryRun = false, force = false } = {}) {
     installModels = configuredEnabledModels(parsed);
     installContextTokens = installModel ? configuredModelContextTokens(parsed, installModel) : undefined;
     if (installModel) break;
-    // The Bizar path is authoritative even when it has no enabled candidates.
-    if (p === bizarRouterPath) break;
   }
   if (installModel) {
     bizarSettings.model = installModel;
@@ -1177,16 +1180,16 @@ export async function runProvision(opts = {}) {
   await runStep('Installing git hooks', () => installGitHooks({ dryRun }));
   await runStep('Building SDK',       () => buildSdk({ dryRun }));
 
+  section('Ensuring global model-router.json');
+  const routerStep = await syncModelRouter({ dryRun, force });
+  if (routerStep.ok) logOk(routerStep.message); else logErr(routerStep.message);
+  stepResults.push({ label: 'model-router', ...routerStep });
+
   section('Writing settings.json');
   const settingsStep = writeClaudeSettings({ dryRun, force });
   if (settingsStep.ok) logOk(settingsStep.message); else logErr(settingsStep.message);
   stepResults.push({ label: 'settings.json', ...settingsStep });
 
-  section('Syncing model-router.json');
-  const routerStep = await syncModelRouter({ dryRun, force });
-  if (routerStep.ok) logOk(routerStep.message); else logErr(routerStep.message);
-  stepResults.push({ label: 'model-router', ...routerStep });
-
   section('MCP server (bizar)');
   const mcpStep = setupMcpServer({ dryRun });
   if (mcpStep.ok) logOk(mcpStep.message); else logWarn(mcpStep.message);
@@ -1221,7 +1224,7 @@ export async function runProvision(opts = {}) {
   // back to a clear hint to run `bizar models`.
   let premiumPick = null;
   try {
-    const routerPath = join(BIZAR_HOME(), 'config', 'claude', 'model-router.json');
+    const routerPath = resolveGlobalModelRouter();
     const router = JSON.parse(readFileSync(routerPath, 'utf8'));
     const picks = Array.isArray(router?.userSelected?.tierHints?.premium)
       ? router.userSelected.tierHints.premium.filter((id) => typeof id === 'string' && id)

package/config/agents/model-assignment.mjs

@@ -8,11 +8,12 @@
  */
 import { createHash } from 'node:crypto';
 import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { resolveGlobalModelRouter } from '../../cli/config-paths.mjs';
 
-const ROOT = resolve(fileURLToPath(new URL('../..', import.meta.url)));
-export const DEFAULT_MODEL_ROUTER_PATH = resolve(ROOT, 'config', 'claude', 'model-router.json');
+/** Resolve the single operator-owned router at call time, never from a repo. */
+export function defaultModelRouterPath() {
+  return resolveGlobalModelRouter();
+}
 
 function fail(code, message) {
   const error = new Error(message);
@@ -39,9 +40,6 @@ function assertDynamicRegistry(registry) {
   if (!registry.tiers || typeof registry.tiers !== 'object' || Object.keys(registry.tiers).length === 0) {
     fail('MODEL_REGISTRY_INVALID', 'The model router must define at least one dynamic tier.');
   }
-  for (const [name, tier] of Object.entries(registry.tiers)) {
-    if (normalizeModelIds(tier?.models).length === 0) fail('MODEL_REGISTRY_INVALID', `Tier ${name} has no candidate models.`);
-  }
   const policies = registry.policies || {};
   if (policies.selectionOwner !== 'orchestrator') fail('MODEL_POLICY_INVALID', 'The orchestrator must own model selection.');
   if (!['configured-tier-fallback', 'inherit-session'].includes(policies.discoveryFailure)
@@ -54,7 +52,7 @@ function assertDynamicRegistry(registry) {
   return registry;
 }
 
-export function loadModelRouter(path = DEFAULT_MODEL_ROUTER_PATH) {
+export function loadModelRouter(path = defaultModelRouterPath()) {
   try {
     return assertDynamicRegistry(JSON.parse(readFileSync(path, 'utf8')));
   } catch (error) {
@@ -73,7 +71,16 @@ export function resolveDispatchModel({
   const definition = registry.tiers?.[chosenTier];
   if (!definition) fail('UNKNOWN_TIER', `Unknown model tier ${chosenTier}.`);
   const disabled = new Set(normalizeModelIds(registry.disabledProviders).map((prefix) => prefix.toLowerCase()));
-  const candidates = normalizeModelIds(definition.models)
+  const selected = normalizeModelIds(registry.userSelected?.models)
+    .filter((candidate) => ![...disabled].some((prefix) => candidate.toLowerCase().startsWith(prefix)));
+  const hints = registry.userSelected?.tierHints && typeof registry.userSelected.tierHints === 'object'
+    ? registry.userSelected.tierHints
+    : {};
+  // The operator's picker is authoritative. A matching tier hint narrows the
+  // pool; otherwise all enabled picks remain eligible rather than silently
+  // falling back to repository-supplied candidates.
+  const hinted = selected.filter((candidate) => hints[candidate] === chosenTier);
+  const candidates = (hinted.length > 0 ? hinted : selected.length > 0 ? selected : normalizeModelIds(definition.models))
     .filter((candidate) => ![...disabled].some((prefix) => candidate.toLowerCase().startsWith(prefix)));
   if (candidates.length === 0) fail('NO_ENABLED_TIER_MODEL', `Tier ${chosenTier} has no enabled candidate models.`);
   const available = availableModelIds == null ? null : new Set(normalizeModelIds(availableModelIds));

package/config/claude/agents/planner.md

@@ -43,7 +43,8 @@ Every plan you produce MUST follow this shape. The user (or Mike, or any downstr
 
 ## Subagent Model Selection
 
-When you delegate implementation, you recommend the model tier. Read `.claude/model-router.json` to confirm.
+When you delegate implementation, you recommend the model tier. Read the
+operator-global Bizar router (`$BIZAR_HOME/config/claude/model-router.json`) to confirm.
 
 | Task shape | Route to | Tier |
 |---|---|---|

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

@@ -44,9 +44,11 @@
  */
 
 import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 
 import { loadModelRouter } from '../../../config/agents/model-assignment.mjs';
+import { resolveClaudeConfigDir } from '../../../cli/config-paths.mjs';
 
 function deny(reason) {
   return {
@@ -152,6 +154,17 @@ function readFailoverBlock(toolInput) {
   };
 }
 
+function readConfiguredParentModel(options = {}) {
+  if (typeof options.parentModel === 'string') return options.parentModel.trim();
+  const settingsPath = options.settingsPath || join(resolveClaudeConfigDir(), 'settings.json');
+  try {
+    const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    return typeof settings?.model === 'string' ? settings.model.trim() : '';
+  } catch {
+    return '';
+  }
+}
+
 export async function guardAgentModel(input, options = {}) {
   if (!input || typeof input !== 'object') return {};
   if (input.hook_event_name !== 'PreToolUse' || input.tool_name !== 'Agent') return {};
@@ -160,10 +173,6 @@ export async function guardAgentModel(input, options = {}) {
   const failoverBlock = readFailoverBlock(toolInput);
   const hasFailoverContract = Boolean(failoverBlock.routingDecisionId) && Boolean(failoverBlock.fallback);
 
-  if (!requested || requested === 'inherit') {
-    return deny('Bizar Agent dispatch blocked: every Agent call requires an explicit enabled model from `bizar models`; session/provider inheritance is prohibited.');
-  }
-
   let registry;
   try {
     registry = options.registry || loadModelRouter(options.routerPath);
@@ -181,6 +190,20 @@ export async function guardAgentModel(input, options = {}) {
   const allowed = configuredModels(registry);
   const userPicks = userSelectedModels(registry);
 
+  // The native Agent tool rejects arbitrary gateway IDs in its `model` enum.
+  // 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 configured = typeof toolInput.additionalContext?.bizarConfiguredModel === 'string'
+      ? toolInput.additionalContext.bizarConfiguredModel.trim()
+      : '';
+    const parent = readConfiguredParentModel(options);
+    if (!configured || configured !== parent || !userPicks.has(configured)) {
+      return deny('Bizar Agent dispatch blocked: native Agent inheritance requires the global Claude parent model to exactly match an enabled Bizar user selection. Run `bizar models` and restart Claude Code.');
+    }
+    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

@@ -61,16 +61,12 @@ function readRouterPath() {
 
 /**
  * 10.22.0 / Phase 4: read the operator's `disabledProviders: string[]`
- * list with the same dual-path contract as `cli/commands/models.mjs`.
- * The Bizar path (`~/.config/bizar/config/claude/model-router.json`) wins
- * when both exist (even with explicit `[]`); the legacy
- * `~/.claude/model-router.json` mirror is the fallback. Whitespace +
- * lowercase normalization happens here. Returns `[]` on any failure —
+ * list from the sole global Bizar router. Whitespace + lowercase
+ * normalization happens here. Returns `[]` on any failure —
  * the hook is advisory and must NEVER block session start.
  */
 function readDisabledProviders() {
   const bizarPath = readRouterPath();
-  const legacyPath = join(resolveClaudeConfigDir(), 'model-router.json');
   const extract = (parsed) => {
     if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return null;
     if (!Array.isArray(parsed.disabledProviders)) return null;
@@ -85,18 +81,12 @@ function readDisabledProviders() {
   };
   if (existsSync(bizarPath)) {
     const parsed = readJsonIfObject(bizarPath);
-    // Bizar path exists — its `disabledProviders` is authoritative even
-    // when explicit `[]`. Missing key still falls back to the legacy.
+    // An explicit empty global list is a valid operator policy.
     if (parsed && Array.isArray(parsed.disabledProviders)) {
       const extracted = extract(parsed);
       if (extracted !== null) return extracted;
     }
   }
-  const legacy = readJsonIfObject(legacyPath);
-  if (legacy && Array.isArray(legacy.disabledProviders)) {
-    const extracted = extract(legacy);
-    if (extracted !== null) return extracted;
-  }
   return [];
 }
 
@@ -193,8 +183,7 @@ function syncOnce() {
     : {};
   // 10.22.0 / Phase 4: filter the operator's disabled-provider ids out
   // of the SessionStart re-apply so Claude Code's `/model` picker never
-  // surfaces e.g. `anthropic/*` after a session restart. Dual-path read
-  // matches `cli/commands/models.mjs#readDisabledProviders`.
+  // surfaces e.g. `anthropic/*` after a session restart.
   const disabled = readDisabledProviders();
   const selectedIds = filterDisabled(
     models.filter((id) => typeof id === 'string' && id.trim()),

package/config/workflows/lib/dispatch.js

@@ -793,15 +793,17 @@ export function classifyDispatchOutcome(result, error, startMs) {
 }
 
 /**
- * Build the augmented agent-call payload. Adds `model`,
- * `routingDecisionId`, `tier`, and `selectorReason` so the Agent
- * tool can route correctly and the audit trail can prove which
- * selector step fired.
+ * Build the augmented agent-call payload. The native Agent model field cannot
+ * carry arbitrary gateway IDs, so the selected Bizar ID is audit context and
+ * the guard permits inheritance only from an identical configured parent.
  */
 export function augmentPayload(opts, decision, agentName) {
   return {
     ...opts,
-    model: decision.modelId ?? undefined,
+    additionalContext: {
+      ...(opts.additionalContext && typeof opts.additionalContext === 'object' ? opts.additionalContext : {}),
+      bizarConfiguredModel: decision.modelId ?? null,
+    },
     routingDecisionId: decision.routingDecisionId,
     tier: decision.tier,
     selectorReason: decision.reason,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar",
-  "version": "10.23.9",
+  "version": "10.23.11",
   "description": "Autonomous, human-in-the-loop multi-agent harness for Claude Code with guarded workflows, typed SDK primitives, and MCP tools.",
   "type": "module",
   "bin": {
@@ -25,7 +25,6 @@
     "config/claude/hooks/*.mjs",
     "config/claude/hooks/*.sh",
     "config/claude/hooks/README.md",
-    "config/claude/model-router.json",
     "config/claude/settings.json",
     "scripts/git-hooks/commit-msg",
     "scripts/git-hooks/pre-commit",

package/packages/sdk/dist/mcp/server.js

@@ -385,7 +385,7 @@ const bizarAuditTool = defineTool("bizar_audit", "Wrapper around `bizar audit --
     }
 }, { readOnlyHint: true });
 // `bizar model list --json` — gateway model inventory.
-const bizarModelListTool = defineTool("bizar_model_list", "Wrapper around `bizar models --json`. Returns ONLY the models the user has explicitly enabled via `bizar models` (the `userSelected` block of `config/claude/model-router.json`). Live discovery is filtered out by default to avoid surfacing dozens of unrelated models. Empty list = orchestrator inherits the active session model.", {}, async () => {
+const bizarModelListTool = defineTool("bizar_model_list", "Wrapper around `bizar models --json`. Returns ONLY the models the user has explicitly enabled via `bizar models` in the global Bizar router (`$BIZAR_HOME/config/claude/model-router.json#userSelected`). Live discovery is filtered out by default to avoid surfacing dozens of unrelated models. An empty list means no agent dispatch is permitted until the operator configures models.", {}, async () => {
     try {
         // Prefer the new `bizar models` surface; fall back to the legacy
         // `bizar model list` alias for older installs. The CLI is responsible

package/packages/sdk/dist/router/agent-model-registry.d.ts

@@ -225,8 +225,13 @@ export declare function rankUserSelectedForRole(registry: ModelRegistry, role: s
 };
 /**
  * Pure sorter extracted for testability. Mutates and returns the input
- * array. Sort key: `(eligible desc, capabilityScore desc, hasProfile desc,
- * originalIndex asc)`.
+ * array. Sort key: `(eligible desc, originalIndex asc, capabilityScore desc,
+ * hasProfile desc)`. The `originalIndex` primary sort key honours the
+ * operator's `userSelected.models` ordering as the authoritative pick
+ * sequence — the same contract as the CLI's `resolveDispatchModel`. The
+ * capability score is a secondary tiebreaker for entries that share the
+ * same `originalIndex` position (i.e., when a profile lookup changes
+ * eligibility status without reordering).
  */
 export declare function compareRankedEntries(a: RankedUserSelectedEntry, b: RankedUserSelectedEntry): number;
 /**

package/packages/sdk/dist/router/agent-model-registry.js

@@ -85,8 +85,6 @@ export function loadModelRegistry(src = {}) {
         if (!isRecord(value))
             registryError("CONFIG_INVALID", `Tier ${name} is invalid.`);
         const ids = modelIds(value.models);
-        if (ids.length === 0)
-            registryError("CONFIG_INVALID", `Tier ${name} has no candidate models.`);
         tiers.set(name, { tier: name, modelIds: ids, purpose: String(value.purpose || ""), effort: typeof value.effort === "string" ? value.effort : null });
     }
     const roleDefaults = new Map();
@@ -98,6 +96,25 @@ export function loadModelRegistry(src = {}) {
     const configuredEndpoint = typeof raw.endpoint === "string" ? raw.endpoint : typeof gateway.endpoint === "string" ? gateway.endpoint : null;
     const endpoint = process.env.BIZAR_MODEL_ROUTER_URL ?? process.env.ANTHROPIC_BASE_URL ?? configuredEndpoint;
     const userSelected = parseUserSelected(raw.userSelected);
+    // Empty tier lists are tolerated when the operator's `userSelected`
+    // pool is non-empty: the runtime resolver (resolveTierModel) prefers
+    // the operator's authoritative picks and only falls through to a
+    // tier's static model list when no user pick matches. The CLI mirror
+    // (config/agents/model-assignment.mjs#resolveDispatchModel) applies
+    // the same rule; this keeps SDK and CLI symmetric on the canonical
+    // template, which ships empty tier lists by design (F-201 follow-up:
+    // remove every shipped provider/model default). When `userSelected`
+    // is also empty, every tier must still carry at least one candidate
+    // so the resolver never dispatches with no model at all.
+    if (!(userSelected && userSelected.models.length > 0)) {
+        for (const [name, value] of Object.entries(raw.tiers)) {
+            if (!isRecord(value))
+                registryError("CONFIG_INVALID", `Tier ${name} is invalid.`);
+            const ids = modelIds(value.models);
+            if (ids.length === 0)
+                registryError("CONFIG_INVALID", `Tier ${name} has no candidate models.`);
+        }
+    }
     return { version: String(raw.version || "unknown"), endpoint, configuredEndpoint, gateway, policies: raw.policies, tiers, roleDefaults, ...(userSelected ? { userSelected } : {}) };
 }
 function parseUserSelected(raw) {
@@ -298,24 +315,35 @@ export function rankUserSelectedForRole(registry, role, requirements = {}) {
         return entry;
     });
     ranked.sort(compareRankedEntries);
-    const eligible = ranked.filter((entry) => entry.eligible);
-    // role is consumed only for future per-role filtering / logging hooks.
-    void role;
+    // Tier-aware filtering (parity with the CLI's
+    // resolveDispatchModel#hinted): when the caller asks for a specific
+    // tier (the common dispatch path passes the agent's role-default
+    // tier), narrow `eligible` to entries whose tier hint matches. When
+    // no entry matches the requested tier, fall back to the full eligible
+    // ranking so a stale tierHints map never strands a dispatch with no
+    // candidates at all — same fail-open shape as the CLI.
+    const tierMatched = role ? ranked.filter((entry) => entry.eligible && entry.tier === role) : ranked.filter((entry) => entry.eligible);
+    const eligible = tierMatched.length > 0 ? tierMatched : ranked.filter((entry) => entry.eligible);
     return { ranked, eligible };
 }
 /**
  * Pure sorter extracted for testability. Mutates and returns the input
- * array. Sort key: `(eligible desc, capabilityScore desc, hasProfile desc,
- * originalIndex asc)`.
+ * array. Sort key: `(eligible desc, originalIndex asc, capabilityScore desc,
+ * hasProfile desc)`. The `originalIndex` primary sort key honours the
+ * operator's `userSelected.models` ordering as the authoritative pick
+ * sequence — the same contract as the CLI's `resolveDispatchModel`. The
+ * capability score is a secondary tiebreaker for entries that share the
+ * same `originalIndex` position (i.e., when a profile lookup changes
+ * eligibility status without reordering).
  */
 export function compareRankedEntries(a, b) {
     if (a.eligible !== b.eligible)
         return a.eligible ? -1 : 1;
+    if (a.originalIndex !== b.originalIndex)
+        return a.originalIndex - b.originalIndex;
     if (a.capabilityScore !== b.capabilityScore)
         return b.capabilityScore - a.capabilityScore;
-    if (a.hasProfile !== b.hasProfile)
-        return a.hasProfile ? -1 : 1;
-    return a.originalIndex - b.originalIndex;
+    return a.hasProfile !== b.hasProfile ? (a.hasProfile ? -1 : 1) : 0;
 }
 /**
  * Weighted capability score: reasoning=0.3, toolCall=0.25,

package/packages/sdk/dist/router/failover-mirror.mjs

@@ -175,13 +175,17 @@ export function rankUserSelectedForRole(registry, role, requirements = {}) {
     });
   ranked.sort((a, b) => {
     if (a.eligible !== b.eligible) return a.eligible ? -1 : 1;
+    if (a.originalIndex !== b.originalIndex) return a.originalIndex - b.originalIndex;
     if (a.capabilityScore !== b.capabilityScore) return b.capabilityScore - a.capabilityScore;
-    if (a.hasProfile !== b.hasProfile) return a.hasProfile ? -1 : 1;
-    return a.originalIndex - b.originalIndex;
+    return a.hasProfile !== b.hasProfile ? (a.hasProfile ? -1 : 1) : 0;
   });
-  const eligible = ranked.filter((entry) => entry.eligible);
-  // role is consumed only for future per-role filtering / logging hooks.
-  void role;
+  // Tier-aware filtering (parity with the CLI's
+  // resolveDispatchModel#hinted): narrow `eligible` to entries whose
+  // tier hint matches the requested tier; fall back to the full eligible
+  // ranking when no tier-matched candidate exists so a stale tierHints
+  // map never strands a dispatch with no candidates at all.
+  const tierMatched = role ? ranked.filter((entry) => entry.eligible && entry.tier === role) : ranked.filter((entry) => entry.eligible);
+  const eligible = tierMatched.length > 0 ? tierMatched : ranked.filter((entry) => entry.eligible);
   return { ranked, eligible };
 }
 

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.9";
+export declare const SDK_VERSION: "10.23.11";
 //# 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.9";
+export const SDK_VERSION = "10.23.11";
 //# sourceMappingURL=version.js.map

package/packages/sdk/package.json

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

package/config/claude/model-router.json

@@ -1,110 +0,0 @@
-{
-  "$schema": "https://bizar.dev/schema/model-router.v3.json",
-  "version": "13.0.0",
-  "endpoint": null,
-  "disabledProviders": ["anthropic"],
-  "comment": "Mike selects the cheapest sufficient enabled operator-configured model per dispatch. Explicit user-selected models take precedence; empty shipped tiers ensure a fresh install never silently chooses a vendor or model. The orchestrator always supplies an Agent model and fails closed when no enabled configured candidate exists, so Claude Code cannot select an unconfigured provider default. The gateway endpoint is intentionally null in the shipped config — operators MUST configure it via the `ANTHROPIC_BASE_URL` or `BIZAR_MODEL_ROUTER_URL` environment variable. Bizar is provider-agnostic and ships no default model. `disabledProviders` (top-level, optional) is a case-insensitive-at-write, case-sensitive-at-filter list of provider prefixes whose model ids are stripped from every read site (CLI sync, picker, settings.json sync, SessionStart hook, Agent model guard). Anthropic is opted out by default; operators may remove that entry or opt out of additional providers.",
-  "userSelected": {
-    "models": [],
-    "lastUpdated": null,
-    "source": "default-empty",
-    "tierHints": {}
-  },
-  "gateway": {
-    "required": false,
-    "endpoint": null,
-    "availabilityProbe": "/models",
-    "discoveryTimeoutMs": 3000,
-    "unavailableBehavior": "configured-tier-fallback",
-    "documentation": "https://code.claude.com/docs/en/llm-gateway"
-  },
-  "tiers": {
-    "premium": {
-      "models": [],
-      "purpose": "Architecture, high-risk planning, adversarial verification, and last-resort debugging where mistakes are expensive.",
-      "effort": "high"
-    },
-    "high": {
-      "models": [],
-      "purpose": "Complex implementation, security review, and cross-cutting reasoning.",
-      "effort": "high"
-    },
-    "mid-design": {
-      "models": [],
-      "purpose": "UI/UX design and product-quality implementation where visual judgment matters.",
-      "effort": "medium"
-    },
-    "default": {
-      "models": [],
-      "purpose": "Broad research, git operations, and ordinary engineering work.",
-      "effort": "medium"
-    },
-    "mid": {
-      "models": [],
-      "purpose": "Bounded technical analysis, code search, and moderate implementation.",
-      "effort": "medium"
-    },
-    "budget": {
-      "models": [],
-      "purpose": "Routine deterministic edits, targeted clarification, and scripted verification.",
-      "effort": "low"
-    }
-  },
-  "roleDefaults": {
-    "mike": "premium",
-    "paul": "premium",
-    "carl": "premium",
-    "karen": "high",
-    "linda": "high",
-    "ria": "mid-design",
-    "greg": "default",
-    "steve": "default",
-    "oscar": "mid",
-    "todd": "mid",
-    "susan": "mid",
-    "pam": "budget",
-    "brenda": "budget",
-    "janet": "budget",
-    "kevin": "budget",
-    "brad": "mid-design"
-  },
-  "complexityRules": [
-    {
-      "when": "irreversible, security-sensitive, architectural, or previously failed twice",
-      "tier": "premium"
-    },
-    {
-      "when": "cross-cutting implementation or adversarial review",
-      "tier": "high"
-    },
-    {
-      "when": "UI or product design judgment dominates",
-      "tier": "mid-design"
-    },
-    {
-      "when": "bounded implementation or codebase research",
-      "tier": "mid"
-    },
-    {
-      "when": "deterministic, mechanical, or clarification-only",
-      "tier": "budget"
-    }
-  ],
-  "policies": {
-    "mainOrchestrator": "mike",
-    "selectionOwner": "orchestrator",
-    "dispatchModelOverride": "required-configured-candidate",
-    "unknownAgent": "configured-tier-fallback",
-    "discoveryFailure": "configured-tier-fallback",
-    "unavailableModel": "configured-tier-fallback",
-    "silentProviderSubstitution": false,
-    "retryModelAliases": false,
-    "snapshotDecisions": true,
-    "maxDispatchModelAttempts": 1
-  },
-  "costControls": {
-    "maxConcurrentAgents": 10,
-    "maxPremiumAgentsPerWorkflow": 3,
-    "preferInheritanceWhenDiscoveryUnavailable": false
-  }
-}