@polderlabs/bizar 10.25.2 → 10.26.0

package/cli/commands/workflow.mjs

@@ -10,8 +10,6 @@ import {
   resumeWorkflow,
   startWorkflow,
 } from '../core/workflow-state.mjs';
-import { loadModelRouter } from '../../config/agents/model-assignment.mjs';
-import { resolveGlobalModelRouter } from '../config-paths.mjs';
 
 const DEFAULT_PROBE_TIMEOUT_MS = 3_000;
 
@@ -21,96 +19,15 @@ function normalizeEndpoint(value) {
   return normalized || null;
 }
 
-function requireEffectiveInferenceEndpoint(registry, env = process.env) {
-  const configuredEndpoint = normalizeEndpoint(registry?.gateway?.endpoint);
+function requireEffectiveInferenceEndpoint(env = process.env) {
   const inferenceEndpoint = normalizeEndpoint(env.ANTHROPIC_BASE_URL);
   if (!inferenceEndpoint) {
     throw new WorkflowStateError(
       'INFERENCE_ENDPOINT_REQUIRED',
-      `workflow start requires ANTHROPIC_BASE_URL=${registry?.gateway?.endpoint || '<configured gateway>'}`,
+      'workflow start requires ANTHROPIC_BASE_URL to point at the inference gateway',
     );
   }
-  if (inferenceEndpoint !== configuredEndpoint) {
-    throw new WorkflowStateError(
-      'INFERENCE_ENDPOINT_MISMATCH',
-      `ANTHROPIC_BASE_URL must match the configured workflow gateway ${registry.gateway.endpoint}`,
-    );
-  }
-  const routerEndpointValue = env.BIZAR_MODEL_ROUTER_URL;
-  if (typeof routerEndpointValue === 'string' && routerEndpointValue !== '') {
-    const routerEndpoint = normalizeEndpoint(routerEndpointValue);
-    if (!routerEndpoint || routerEndpoint !== configuredEndpoint) {
-      throw new WorkflowStateError(
-        'INFERENCE_ENDPOINT_MISMATCH',
-        `BIZAR_MODEL_ROUTER_URL must not contradict the configured workflow gateway ${registry.gateway.endpoint}`,
-      );
-    }
-  }
-}
-
-function probeUrl(registry) {
-  const endpoint = registry?.gateway?.endpoint;
-  const probe = registry?.gateway?.availabilityProbe;
-  if (typeof endpoint !== 'string' || !endpoint || typeof probe !== 'string' || !probe) {
-    throw new WorkflowStateError(
-      'MODEL_REGISTRY_INVALID',
-      'model registry requires gateway.endpoint and gateway.availabilityProbe',
-    );
-  }
-  return `${endpoint.replace(/\/+$/, '')}/${probe.replace(/^\/+/, '')}?limit=1000`;
-}
-
-export async function probeAvailableModels({
-  registry,
-  fetchImpl = globalThis.fetch,
-  authToken = process.env.ANTHROPIC_AUTH_TOKEN || process.env.BIZAR_MODEL_ROUTER_TOKEN,
-  timeoutMs = DEFAULT_PROBE_TIMEOUT_MS,
-} = {}) {
-  if (typeof fetchImpl !== 'function') {
-    throw new WorkflowStateError('GATEWAY_UNAVAILABLE', 'this Node runtime has no fetch implementation');
-  }
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const headers = { Accept: 'application/json' };
-    if (authToken) headers.Authorization = `Bearer ${authToken}`;
-    const response = await fetchImpl(probeUrl(registry), {
-      method: 'GET',
-      headers,
-      signal: controller.signal,
-    });
-    if (!response.ok) {
-      throw new WorkflowStateError(
-        'GATEWAY_UNAVAILABLE',
-        `model availability probe returned HTTP ${response.status}`,
-      );
-    }
-    let payload;
-    try {
-      payload = await response.json();
-    } catch {
-      throw new WorkflowStateError('GATEWAY_RESPONSE_INVALID', 'model availability probe returned invalid JSON');
-    }
-    if (!payload || !Array.isArray(payload.data)) {
-      throw new WorkflowStateError('GATEWAY_RESPONSE_INVALID', 'model availability response must contain a data array');
-    }
-    const ids = payload.data.map((entry) => entry?.id);
-    if (ids.some((id) => typeof id !== 'string' || !id || id.trim() !== id)) {
-      throw new WorkflowStateError('GATEWAY_RESPONSE_INVALID', 'model availability response contains an invalid exact model id');
-    }
-    if (new Set(ids).size !== ids.length) {
-      throw new WorkflowStateError('GATEWAY_RESPONSE_INVALID', 'model availability response contains duplicate model ids');
-    }
-    return ids;
-  } catch (error) {
-    if (error instanceof WorkflowStateError) throw error;
-    if (error?.name === 'AbortError') {
-      throw new WorkflowStateError('GATEWAY_TIMEOUT', `model availability probe timed out after ${timeoutMs}ms`);
-    }
-    throw new WorkflowStateError('GATEWAY_UNAVAILABLE', `model availability probe failed: ${error?.message || String(error)}`);
-  } finally {
-    clearTimeout(timeout);
-  }
+  return inferenceEndpoint;
 }
 
 function parseFlags(args) {
@@ -118,7 +35,7 @@ function parseFlags(args) {
   const values = new Set([
     '--profile', '--workflow', '--mode', '--project', '--session', '--session-id',
     '--run', '--run-id', '--revision', '--expected-revision', '--stage', '--expected-stage',
-    '--reason', '--goal', '--evidence', '--router',
+    '--reason', '--goal', '--evidence',
   ]);
   // Boolean flags take no value. Long flags use the kebab->camel key;
   // short flags carry an explicit key mapping.
@@ -162,7 +79,6 @@ function showHelp() {
   Common flags:
     --project <path>    Project root (defaults to the current directory)
     --session <id>      Claude session id (defaults to CLAUDE_SESSION_ID)
-    --router <path>     Strict model router registry (defaults to the shipped registry)
     --mode <name>       Routing hint for start (ralplan routes to the 8-step consensus protocol)
     --deliberate        Force the pre-mortem round on a ralplan-shaped workflow
     --advisory          Run the protocol without enforced gates (observability only)
@@ -286,24 +202,22 @@ export async function run(name, args, isHelpRequest) {
           '--mode cannot be combined with --profile or --workflow; --mode owns the routing hint',
         );
       }
-      const registry = loadModelRouter(
-        flags.router || process.env.BIZAR_MODEL_ROUTER_PATH || resolveGlobalModelRouter(),
-      );
-      let availableModelIds;
+      // The picker/router is gone; workflows no longer probe a model list
+      // or load a model-router registry. Native Claude Code resolves the
+      // alias via the four ANTHROPIC_DEFAULT_*_MODEL env vars shipped in
+      // config/claude/settings.json. We still require ANTHROPIC_BASE_URL
+      // so an operator without a gateway cannot silently inherit a
+      // provider default.
       try {
-        requireEffectiveInferenceEndpoint(registry);
-        availableModelIds = await probeAvailableModels({ registry });
-      } catch {
-        // Discovery is optional; the resolver still supplies an explicit
-        // enabled configured-tier model. Never inherit a provider default.
-        availableModelIds = undefined;
+        requireEffectiveInferenceEndpoint();
+      } catch (error) {
+        if (!(error instanceof WorkflowStateError)) throw error;
+        throw error;
       }
       state = startWorkflow({
         ...ctx,
         profile: routing.profile,
         goal: flags.goal,
-        registry,
-        availableModelIds,
       });
       if (routing.routing.mode !== null && !flags.json) {
         // Surface the routing hint in human mode. In JSON mode the

package/cli/config-paths.mjs

@@ -14,18 +14,6 @@ export function resolveBizarHome({ env = process.env, cwd = process.cwd() } = {}
   return join(home, '.config', 'bizar');
 }
 
-export function resolveGlobalModelRouter(options = {}) {
-  const { env = process.env, cwd = process.cwd() } = options;
-  const override = typeof env.BIZAR_MODEL_ROUTER_CONFIG === 'string'
-    ? env.BIZAR_MODEL_ROUTER_CONFIG.trim()
-    : '';
-  if (override) return isAbsolute(override) ? override : resolve(cwd, override);
-  // Claude Code reads hooks, agents, skills, and model-router from ~/.claude/.
-  // Use ~/.claude/model-router.json as the single canonical location so the
-  // hook and the CLI always agree on the same file.
-  return join(resolveClaudeConfigDir({ env, cwd }), 'model-router.json');
-}
-
 export function resolveGlobalLearningDir(options = {}) {
   return join(resolveBizarHome(options), 'learning');
 }

package/cli/core/workflow-state.mjs

@@ -346,6 +346,7 @@ export function validateWorkflowState(state, context) {
     assert(typeof agent === 'string' && agent.length > 0, 'INVALID_STATE', 'routing decision agent is invalid');
     assert(decision && typeof decision === 'object', 'INVALID_STATE', `routing decision for ${agent} is invalid`);
     assert(typeof decision.tier === 'string' && decision.tier.length > 0, 'INVALID_STATE', `routing tier for ${agent} is invalid`);
+    assert(['haiku', 'sonnet', 'opus', 'fable'].includes(decision.alias), 'INVALID_STATE', `alias for ${agent} is not a static native alias`);
     assert(decision.model === null || (typeof decision.model === 'string' && decision.model.length > 0), 'INVALID_STATE', `routing model for ${agent} is invalid`);
     assert(typeof decision.inheritSession === 'boolean', 'INVALID_STATE', `routing inheritance for ${agent} is invalid`);
   }
@@ -400,9 +401,7 @@ export function startWorkflow({
   sessionId,
   profile = 'default',
   goal,
-  availableModelIds,
-  registry,
-  requiredAgents,
+  requiredAgents = [],
   now = new Date(),
 }) {
   const paths = resolveWorkflowPaths({ projectRoot, sessionId });
@@ -415,8 +414,6 @@ export function startWorkflow({
     assignmentSnapshot = createRunAssignmentSnapshot({
       runId,
       agentNames: requiredAgents,
-      availableModelIds,
-      registry,
       createdAt: now.toISOString(),
     });
   } catch (error) {

package/cli/doctor.mjs

@@ -20,7 +20,10 @@
  *   hook-files-installed:    all shipped hook entrypoints are executable
  *   tools-on-path:           at least one of semble/skills/claude
  *   bizar-home:              BIZAR_HOME exists
- *   provider-reachable:       provider gateway responds
+ *   alias-map:               ANTHROPIC_DEFAULT_*_MODEL entries are present
+ *                            and equal default/common/hard/fable
+ *   legacy-router:           non-destructive warning if ~/.claude/model-router.json
+ *                            still exists on disk (no Bizar runtime reads it)
  *
  * Usage:
  *   import { runDoctor } from "./doctor.mjs";
@@ -34,14 +37,12 @@ import { join } from 'node:path';
 import {
   resolveBizarHome,
   resolveClaudeConfigDir,
-  resolveGlobalModelRouter,
 } from './config-paths.mjs';
 import {
   REQUIRED_AGENTS,
   REQUIRED_COMMANDS,
   REQUIRED_HOOKS,
 } from './commands/validate.mjs';
-import { configuredEnabledModels, listModels, resolveEndpoint } from './commands/models.mjs';
 import { validateNativeWorkflowDirectory } from '../config/workflows/lib/native-contract.mjs';
 import { resolveOpenKanHome, verifyOpenKanRuntime } from './openkan.mjs';
 
@@ -195,28 +196,36 @@ async function checkOpenKanRuntime() {
   return `OpenKan ${home} is runnable (${result.launcher})`;
 }
 
-async function checkProviderReachable() {
-  const { endpoint, authToken } = resolveEndpoint();
-  if (!endpoint) {
-    const routerPath = resolveGlobalModelRouter();
-    let router;
-    try {
-      router = JSON.parse(readFileSync(routerPath, 'utf8'));
-    } catch {
-      throw new Error(`no provider URL and no readable global model router at ${routerPath}`);
-    }
-    const configured = configuredEnabledModels(router);
-    if (configured.length === 0) {
-      throw new Error('no enabled configured model; implicit provider defaults are prohibited');
+async function checkAliasMap() {
+  const settingsPath = join(resolveClaudeConfigDir(), 'settings.json');
+  const settings = readFileSync(settingsPath, 'utf8');
+  const parsed = JSON.parse(settings);
+  const env = (parsed && typeof parsed === 'object' && parsed.env) || {};
+  const expected = {
+    ANTHROPIC_DEFAULT_SONNET_MODEL: 'default',
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: 'common',
+    ANTHROPIC_DEFAULT_OPUS_MODEL: 'hard',
+    ANTHROPIC_DEFAULT_FABLE_MODEL: 'fable',
+  };
+  const mismatches = [];
+  for (const [key, expectedValue] of Object.entries(expected)) {
+    const actual = env[key];
+    if (typeof actual !== 'string' || !actual.trim()) {
+      mismatches.push(`${key}=<unset>`);
+    } else if (actual !== expectedValue) {
+      mismatches.push(`${key}=${actual} (expected ${expectedValue})`);
     }
-    return `no gateway URL; explicit configured fallback is ${configured[0]}`;
   }
-  try {
-    const models = await listModels({ endpoint, authToken, timeoutMs: 3000 });
-    return `provider at ${endpoint} ok (${models.length} models)`;
-  } catch (err) {
-    throw new Error(`provider at ${endpoint} unreachable: ${err.message ?? err}`);
+  if (mismatches.length > 0) {
+    throw new Error(`alias map drift in ${settingsPath}: ${mismatches.join(', ')}`);
   }
+  return `alias map ok (sonnet→default, haiku→common, opus→hard, fable→fable)`;
+}
+
+async function checkLegacyRouterPresent() {
+  const routerPath = join(resolveClaudeConfigDir(), 'model-router.json');
+  if (!existsSync(routerPath)) return 'no legacy model-router.json present';
+  return `legacy model-router.json present at ${routerPath} — safe to delete (no Bizar runtime reads it)`;
 }
 
 // ── runner ──────────────────────────────────────────────────────────────────
@@ -235,7 +244,8 @@ const CHECKS = [
   { name: 'tools-on-path',             run: checkToolsAvailable },
   { name: 'bizar-home',                run: checkBizarHome },
   { name: 'openkan-runtime',           run: checkOpenKanRuntime },
-  { name: 'provider-reachable',        run: checkProviderReachable },
+  { name: 'alias-map',                 run: checkAliasMap },
+  { name: 'legacy-router',             run: checkLegacyRouterPresent },
 ];
 
 export async function runDoctor(opts = {}) {

package/cli/install/interactive-setup.mjs

@@ -18,9 +18,11 @@ export function readProviderSettings(path = providerSettingsPath()) {
 
 export function detectProviderConfiguration({ env = process.env, settings = {} } = {}) {
   const settingsEnv = settings?.env && typeof settings.env === 'object' ? settings.env : {};
-  const url = env.BIZAR_MODEL_ROUTER_URL?.trim()
-    || env.ANTHROPIC_BASE_URL?.trim()
-    || settingsEnv.BIZAR_MODEL_ROUTER_URL?.trim()
+  // The picker surface is gone; we no longer consult a separate
+  // BIZAR_MODEL_ROUTER_URL. The install only configures
+  // ANTHROPIC_BASE_URL + ANTHROPIC_AUTH_TOKEN; the four aliases
+  // (sonnet/haiku/opus/fable) are bound by the shipped settings template.
+  const url = env.ANTHROPIC_BASE_URL?.trim()
     || settingsEnv.ANTHROPIC_BASE_URL?.trim()
     || '';
   const key = env.ANTHROPIC_AUTH_TOKEN?.trim()
@@ -173,7 +175,6 @@ export async function runInteractiveSetup({
   }
 
   env.ANTHROPIC_BASE_URL = url;
-  env.BIZAR_MODEL_ROUTER_URL = url;
   env.ANTHROPIC_AUTH_TOKEN = key;
   writeLine(output, '  ✓ Provider configuration ready; the key will be stored in global Claude settings.');