@polderlabs/bizar 10.13.0 → 10.15.0

package/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "bizar-harness",
   "displayName": "Bizar Harness",
-  "version": "10.13.0",
+  "version": "10.15.0",
   "description": "Guarded multi-agent workflows for Claude Code with a single orchestrator, durable workflow state, and explicit human approval boundaries.",
   "author": {
     "name": "Polderlabs"
@@ -18,24 +18,24 @@
     "guarded-autonomy"
   ],
   "skills": "./config/skills/",
-  "commands": "./.claude/commands/",
+  "commands": "./config/claude/commands/",
   "agents": [
-    "./.claude/agents/brand-designer.md",
-    "./.claude/agents/debug-specialist.md",
-    "./.claude/agents/exec-assistant.md",
-    "./.claude/agents/help-desk.md",
-    "./.claude/agents/it-lead.md",
-    "./.claude/agents/knowledge-manager.md",
-    "./.claude/agents/office-coordinator.md",
-    "./.claude/agents/office-greeter.md",
-    "./.claude/agents/office-manager.md",
-    "./.claude/agents/planner.md",
-    "./.claude/agents/principal-engineer.md",
-    "./.claude/agents/qa-reviewer.md",
-    "./.claude/agents/research-analyst.md",
-    "./.claude/agents/senior-engineer.md",
-    "./.claude/agents/support-tech.md",
-    "./.claude/agents/ui-designer.md"
+    "./config/claude/agents/brand-designer.md",
+    "./config/claude/agents/debug-specialist.md",
+    "./config/claude/agents/exec-assistant.md",
+    "./config/claude/agents/help-desk.md",
+    "./config/claude/agents/it-lead.md",
+    "./config/claude/agents/knowledge-manager.md",
+    "./config/claude/agents/office-coordinator.md",
+    "./config/claude/agents/office-greeter.md",
+    "./config/claude/agents/office-manager.md",
+    "./config/claude/agents/planner.md",
+    "./config/claude/agents/principal-engineer.md",
+    "./config/claude/agents/qa-reviewer.md",
+    "./config/claude/agents/research-analyst.md",
+    "./config/claude/agents/senior-engineer.md",
+    "./config/claude/agents/support-tech.md",
+    "./config/claude/agents/ui-designer.md"
   ],
   "hooks": "./hooks/hooks.json"
 }

package/AGENTS.md

@@ -43,14 +43,20 @@ still deny prohibited actions and escalate externally visible or irreversible
 actions with `permissionDecision: "ask"`; that escalation list is the
 authoritative floor, not a starting point.
 
-Subagent dispatch through the Agent tool is the default for disjoint work.
-When two or more subtasks have non-overlapping file scopes and no data
-dependency on each other's intermediate output, the orchestrator MUST
-dispatch them in parallel in a single tool block rather than sequentially.
-Sequential dispatch is reserved for tasks that depend on a previous step's
-output (research → plan → implement, integration that requires a commit SHA,
-verification that consumes a build artifact). The `office-manager` skill
-enforces this; individual agents do not re-derive the rule.
+Subagent dispatch through the Agent tool is the default for focused disjoint
+work. Native dynamic workflows under `~/.claude/workflows/` are used when a
+large or repeatable task benefits from deterministic scripted fan-out. Native
+agent teams are used only when independent workers need direct communication or
+shared task state. When two or more subtasks have non-overlapping file scopes
+and no data dependency on each other's intermediate output, the orchestrator
+MUST dispatch them concurrently. Sequential dispatch is reserved for dependent
+phases and integration.
+
+Agent roles are model-agnostic. Mike selects the cheapest sufficient tier for
+each dispatch. It passes a concrete model only when live discovery proves a
+configured tier candidate; otherwise it omits `model` and inherits the active
+session. Bizar never retries a failed dispatch by cycling aliases, providers, or
+tiers.
 
 The authoritative hard approval list (cannot be auto-approved) is: commits, pushes, pull-request
 mutations, releases, package publication, deployments, production/shared-

package/cli/commands/hook.mjs

@@ -14,7 +14,7 @@ import { dirname, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
 const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
-const HOOK_ROOT = resolve(PACKAGE_ROOT, '.claude', 'hooks');
+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',
@@ -44,6 +44,7 @@ export const HOOK_PROGRAMS = Object.freeze({
   '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',
   'worktree-bootstrap': 'worktree-bootstrap.mjs',
@@ -81,6 +82,9 @@ export const EVENT_CHAINS = Object.freeze({
     'worktree-bootstrap',
   ]),
   'subagent-stop': Object.freeze(['verify-deliverables']),
+  'task-created': Object.freeze(['team-lifecycle']),
+  'task-completed': Object.freeze(['team-lifecycle']),
+  'teammate-idle': Object.freeze(['team-lifecycle']),
   'pre-compact': Object.freeze(['persistent-mode', 'precompact-priorities']),
   stop: Object.freeze(['persistent-mode']),
   'session-end': Object.freeze(['sessionend-recall', 'learning-extract']),
@@ -95,6 +99,9 @@ const EVENT_NAMES = Object.freeze({
   'post-tool-use-failure': 'PostToolUseFailure',
   'subagent-start': 'SubagentStart',
   'subagent-stop': 'SubagentStop',
+  'task-created': 'TaskCreated',
+  'task-completed': 'TaskCompleted',
+  'teammate-idle': 'TeammateIdle',
   'pre-compact': 'PreCompact',
   stop: 'Stop',
   'session-end': 'SessionEnd',

package/cli/commands/model.mjs

@@ -16,7 +16,7 @@ const BIZAR_MODEL_ROUTER_URL = process.env.BIZAR_MODEL_ROUTER_URL
 const ANTHROPIC_AUTH_TOKEN = process.env.ANTHROPIC_AUTH_TOKEN || 'sk_9router';
 
 const PROVIDER_GROUPS = [
-  'cx/', 'bizar/', 'oc/', 'claude/', 'anthropic/',
+  'cx/', 'claude-minimax/', 'claude-qwen/', 'oc/', 'claude/', 'anthropic/',
 ];
 
 function showHelp() {
@@ -31,7 +31,7 @@ function showHelp() {
     Fetches GET ${BIZAR_MODEL_ROUTER_URL}/models?limit=1000
     and prints a table of provider | id | display_name.
     The /model picker inside Claude Code shows only "claude"/"anthropic" prefixed
-    IDs. This command exposes the full set (cx/, bizar/, oc/, etc.).
+    IDs. This command exposes the full set (cx/, claude-minimax/, claude-qwen/, oc/, etc.).
 
   Flags:
     --json   Emit { providers: { "cx/": [...], ... }, total: N }

package/cli/commands/tier.mjs

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+/**
+ * cli/commands/tier.mjs
+ *
+ * `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.
+ *  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.
+ *
+ * A failed dispatch is never retried by cycling aliases or providers.
+ */
+
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const HOME = homedir();
+const ROUTER_PATHS = [
+  process.env.BIZAR_MODEL_ROUTER_PATH,
+  join(HOME, '.claude', 'model-router.json'),
+  process.env.CLAUDE_CONFIG_DIR && join(process.env.CLAUDE_CONFIG_DIR, 'model-router.json'),
+].filter(Boolean);
+
+function loadRouter() {
+  for (const path of ROUTER_PATHS) {
+    if (existsSync(path)) {
+      try {
+        return { path, config: JSON.parse(readFileSync(path, 'utf8')) };
+      } catch (err) {
+        throw new Error(`failed to parse ${path}: ${err.message}`);
+      }
+    }
+  }
+  throw new Error('no model-router.json found — run `bizar install` first');
+}
+
+const ESCALATE_KEYWORDS = [
+  'design', 'review', 'audit', 'plan', 'spec', 'architecture',
+  'security', 'refactor', 'trade-off', 'tradeoff', 'reason',
+  'verify', 'compare', 'analyze', 'analyse', 'explain why',
+];
+const DEMOTE_KEYWORDS = [
+  'rename', 'format', 'lint', 'chmod', 'reformat', 'stub',
+  'comment', 'docstring', 'wording', 'spell', 'typo',
+];
+
+function adjustTier(baseTier, task) {
+  const lower = task.toLowerCase();
+  const wantEscalate = ESCALATE_KEYWORDS.some((kw) => lower.includes(kw));
+  const wantDemote = DEMOTE_KEYWORDS.some((kw) => lower.includes(kw));
+  if (wantEscalate && wantDemote) return { tier: baseTier, reason: 'mixed signals — default tier wins' };
+  if (wantEscalate) return { tier: 'high', reason: 'task requires reasoning / review' };
+  if (wantDemote) return { tier: 'budget', reason: 'task is a deterministic mechanical edit' };
+  return { tier: baseTier, reason: 'task matches default tier' };
+}
+
+const TIER_ORDER = ['budget', 'mid', 'default', 'mid-design', 'high', 'premium'];
+
+function liftTier(tier) {
+  const i = TIER_ORDER.indexOf(tier);
+  if (i === -1 || i === TIER_ORDER.length - 1) return tier;
+  return TIER_ORDER[i + 1];
+}
+
+export async function runTier(cmdArgs) {
+  if (cmdArgs.includes('--help') || cmdArgs.includes('-h')) {
+    console.log(`
+  bizar tier — automatic task-based model selection
+
+  Usage:
+    bizar tier [--agent <name>] [--list] [--json] <task-description>
+    bizar tier --list        List every shipped agent and its default tier.
+
+  Returns the dynamic tier and ordered model candidates for the named role
+  (defaults to "mike"). Mike uses a concrete candidate only after live
+  discovery; otherwise Claude Code inherits the active session model.
+`);
+    return;
+  }
+
+  const { path, config } = loadRouter();
+  const agentName = (() => {
+    const idx = cmdArgs.indexOf('--agent');
+    return idx !== -1 ? cmdArgs[idx + 1] : 'mike';
+  })();
+  const taskParts = [];
+  for (let i = 0; i < cmdArgs.length; i++) {
+    if (cmdArgs[i] === '--agent') { i += 1; continue; }
+    if (cmdArgs[i].startsWith('--')) continue;
+    taskParts.push(cmdArgs[i]);
+  }
+  const task = taskParts.join(' ').trim();
+
+  if (cmdArgs.includes('--list')) {
+    const roles = Object.entries(config.roleDefaults || {}).sort(([a], [b]) => a.localeCompare(b));
+    for (const [name, tier] of roles) {
+      console.log(`  ${name.padEnd(20)} ${String(tier).padEnd(12)} ${(config.tiers?.[tier]?.models || []).join(', ')}`);
+    }
+    return;
+  }
+
+  const defaultTier = config.roleDefaults?.[agentName] || 'default';
+
+  if (!task) {
+    console.error(chalk.red('  ✗ task description required (or pass --list)'));
+    process.exit(2);
+  }
+
+  const adjusted = adjustTier(defaultTier, task);
+  const chosenTier = adjusted.tier === 'high' && defaultTier === 'premium'
+    ? 'premium'
+    : adjusted.tier;
+  const candidates = config.tiers?.[chosenTier]?.models || [];
+  const endpoint = process.env.BIZAR_MODEL_ROUTER_URL
+    || process.env.ANTHROPIC_BASE_URL
+    || config.endpoint;
+
+  if (cmdArgs.includes('--json')) {
+    console.log(JSON.stringify({
+      agent: agentName,
+      defaultTier,
+      chosenTier,
+      candidates,
+      selection: 'first-live-candidate-or-inherit-session',
+      endpoint,
+      source: path,
+      reason: adjusted.reason,
+      task,
+    }, null, 2));
+    return;
+  }
+
+  console.log(chalk.bold(`  task       ${task}`));
+  console.log(`  role       ${agentName} (default tier: ${defaultTier})`);
+  console.log(`  tier       ${chosenTier} — ${adjusted.reason}`);
+  console.log(`  candidates ${candidates.join(', ') || '(none; inherit session)'}`);
+  console.log('  selection  first live candidate, otherwise inherit active session');
+  console.log(`  endpoint   ${endpoint}`);
+  console.log(`  source     ${path}`);
+}
+
+if (process.argv[1] && import.meta.url === new URL(`file://${process.argv[1]}`).href) {
+  runTier(process.argv.slice(2)).catch((error) => {
+    console.error(chalk.red(`  ✗ ${error?.message || error}`));
+    process.exitCode = 1;
+  });
+}

package/cli/commands/tools.mjs

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+/**
+ * cli/commands/tools.mjs
+ *
+ * `bizar tools` — inventory every Bizar surface installed at user level.
+ *
+ * Walks ~/.claude/{agents,skills,commands,hooks}/ plus the Bizar runtime
+ * state under ~/.config/bizar/, then queries the SDK for the live MCP
+ * tool set and prints everything grouped by surface. Also lists every
+ * wired `bizar <cmd>` subcommand from this bin.mjs dispatcher.
+ */
+
+import chalk from 'chalk';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const HOME = homedir();
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = resolve(__filename, '..', '..');
+const CLAUDE_DIR = process.env.CLAUDE_CONFIG_DIR?.trim() || join(HOME, '.claude');
+
+function listDir(dir, ext) {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir).filter((name) => !ext || name.endsWith(ext)).sort();
+}
+
+function listEvents(hooksDir) {
+  if (!existsSync(hooksDir)) return [];
+  return listDir(hooksDir, '.mjs').concat(listDir(hooksDir, '.sh')).sort();
+}
+
+function listWiredCommands() {
+  // Mirror bin.mjs dispatch — single source of truth lives in bin.mjs.
+  // We parse the switch cases to avoid duplicating the list here.
+  const binPath = resolve(__dirname, 'bin.mjs');
+  const text = readFileSync(binPath, 'utf8');
+  const match = text.match(/case '([a-z][a-z0-9-]*)':/g) || [];
+  const names = match
+    .map((line) => line.match(/case '([^']+)'/)?.[1])
+    .filter(Boolean);
+  return [...new Set(names)].sort();
+}
+
+async function listMcpTools() {
+  try {
+    const sdkPath = resolve(__dirname, '..', 'packages/sdk/dist/mcp/server.js');
+    if (!existsSync(sdkPath)) return [];
+    const mod = await import(sdkPath);
+    const list = mod.BIZAR_TOOLS || mod.default?.BIZAR_TOOLS || [];
+    return list.map((tool) => tool.name).sort();
+  } catch {
+    return [];
+  }
+}
+
+export async function runTools(cmdArgs) {
+  if (cmdArgs.includes('--help') || cmdArgs.includes('-h')) {
+    console.log(`
+  bizar tools — list every installed Bizar surface.
+
+  Usage:
+    bizar tools [--json] [--user-level]
+
+  Flags:
+    --json        Emit machine-readable JSON.
+    --user-level  Restrict enumeration to user-level (~/.claude/).
+`);
+    return;
+  }
+
+  const asJson = cmdArgs.includes('--json');
+
+  const agents = listDir(join(CLAUDE_DIR, 'agents'), '.md');
+  const commands = listDir(join(CLAUDE_DIR, 'commands'), '.md');
+  const skills = listDir(join(CLAUDE_DIR, 'skills'));
+  const hooks = listEvents(join(CLAUDE_DIR, 'hooks'));
+  const wiredCommands = listWiredCommands();
+  const mcpTools = await listMcpTools();
+
+  const settingsPath = join(CLAUDE_DIR, 'settings.json');
+  const hasSettings = existsSync(settingsPath);
+  const modelRouterPath = join(CLAUDE_DIR, 'model-router.json');
+  const hasModelRouter = existsSync(modelRouterPath);
+
+  const summary = {
+    userLevel: CLAUDE_DIR,
+    agents,
+    commands,
+    skills,
+    hooks,
+    wiredCommands,
+    mcpTools,
+    settings: { path: settingsPath, present: hasSettings },
+    modelRouter: { path: modelRouterPath, present: hasModelRouter },
+  };
+
+  if (asJson) {
+    console.log(JSON.stringify(summary, null, 2));
+    return;
+  }
+
+  const section = (label, items) => {
+    console.log(chalk.bold(`\n  ${label}`));
+    if (!items.length) {
+      console.log(chalk.dim('    (none)'));
+      return;
+    }
+    for (const item of items) console.log(`    ${item}`);
+  };
+
+  console.log(chalk.bold.cyan(`\n  Bizar tools — installed at ${CLAUDE_DIR}`));
+  section(`agents (${agents.length})`, agents.map((n) => n.replace(/\.md$/, '')));
+  section(`commands (${commands.length})`, commands.map((n) => '/' + n.replace(/\.md$/, '')));
+  section(`skills (${skills.length})`, skills);
+  section(`hooks (${hooks.length})`, hooks);
+  section(`mcp tools (${mcpTools.length})`, mcpTools);
+  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}`);
+}

package/cli/commands/upgrade-defaults.mjs

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+/**
+ * cli/commands/upgrade-defaults.mjs
+ *
+ * `bizar upgrade-defaults` — re-apply the user-favored defaults to
+ * ~/.claude/settings.json (or $CLAUDE_CONFIG_DIR/settings.json).
+ *
+ * What this does:
+ *   1. Reads the existing settings.json without overwriting user-set
+ *      values that are already in place.
+ *   2. Sets the permissive defaults the Bizar user typically wants:
+ *        - permissions.defaultMode  → "bypassPermissions"
+ *        - worktree.bgIsolation     → "worktree"
+ *        - model                    → "claude/minimax/MiniMax-M3"
+ *        - alwaysThinkingEnabled    → true
+ *        - effortLevel              → "high"
+ *        - skipDangerousModePermissionPrompt → true
+ *        - showThinkingSummaries    → true
+ *        - askUserQuestionTimeout   → "5m"
+ *   3. Refuses to downgrade any value the user has explicitly set to
+ *      a more restrictive mode (e.g. a user who set
+ *      defaultMode="default" gets to keep it).
+ *   4. Preserves every unrelated key (mcpServers, hooks, env, etc.).
+ *
+ * Why this exists: the canonical config/claude/settings.json ships with
+ * these defaults and `cli/provision.mjs` (F-163 scope-owned) is the
+ * runtime installer. Until F-163 releases the file or its scope is
+ * extended, this command lets the user apply the new defaults in one
+ * call rather than editing the merged file by hand.
+ */
+
+import chalk from 'chalk';
+import { existsSync, readFileSync, writeFileSync, copyFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const HOME = homedir();
+const CLAUDE_DIR = process.env.CLAUDE_CONFIG_DIR?.trim() || join(HOME, '.claude');
+const SETTINGS_PATH = join(CLAUDE_DIR, 'settings.json');
+
+const FAVORED = {
+  permissions: { defaultMode: 'bypassPermissions' },
+  worktree: { bgIsolation: 'worktree' },
+  model: 'claude/minimax/MiniMax-M3',
+  alwaysThinkingEnabled: true,
+  effortLevel: 'high',
+  skipDangerousModePermissionPrompt: true,
+  showThinkingSummaries: true,
+  askUserQuestionTimeout: '5m',
+};
+
+function isAtLeastAsPermissive(existing, desired) {
+  // Don't downgrade: if the user picked a stricter mode, keep theirs.
+  const order = { default: 0, acceptEdits: 1, bypassPermissions: 2 };
+  const e = order[existing];
+  const d = order[desired];
+  if (e === undefined || d === undefined) return existing === desired;
+  return e >= d;
+}
+
+function deepAssign(target, source) {
+  for (const [k, v] of Object.entries(source)) {
+    if (
+      v !== null
+      && typeof v === 'object'
+      && !Array.isArray(v)
+      && target[k] !== null
+      && typeof target[k] === 'object'
+      && !Array.isArray(target[k])
+    ) {
+      deepAssign(target[k], v);
+    } else if (target[k] === undefined) {
+      target[k] = v;
+    }
+  }
+}
+
+function load() {
+  if (!existsSync(SETTINGS_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync(SETTINGS_PATH, 'utf8'));
+  } catch (err) {
+    throw new Error(`failed to parse ${SETTINGS_PATH}: ${err.message}`);
+  }
+}
+
+function diff(existing) {
+  const proposed = JSON.parse(JSON.stringify(existing));
+  deepAssign(proposed, FAVORED);
+  // Permission-mode guard.
+  const existingMode = existing?.permissions?.defaultMode;
+  if (existingMode && !isAtLeastAsPermissive(existingMode, FAVORED.permissions.defaultMode)) {
+    proposed.permissions.defaultMode = existingMode;
+  }
+  return proposed;
+}
+
+export async function runUpgradeDefaults(cmdArgs) {
+  if (cmdArgs.includes('--help') || cmdArgs.includes('-h')) {
+    console.log(`
+  bizar upgrade-defaults — re-apply the user-favored defaults to ~/.claude/settings.json.
+
+  Usage:
+    bizar upgrade-defaults [--dry-run] [--no-backup]
+
+  Flags:
+    --dry-run   Print the proposed diff without writing.
+    --no-backup Skip the timestamped backup file.
+`);
+    return;
+  }
+
+  const dryRun = cmdArgs.includes('--dry-run');
+  const noBackup = cmdArgs.includes('--no-backup');
+
+  if (!existsSync(SETTINGS_PATH)) {
+    console.error(chalk.red(`  ✗ ${SETTINGS_PATH} not found — run \`bizar install\` first`));
+    process.exit(2);
+  }
+
+  const before = load();
+  const after = diff(before);
+
+  if (!noBackup && !dryRun) {
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backup = `${SETTINGS_PATH}.bak-${stamp}`;
+    copyFileSync(SETTINGS_PATH, backup);
+    console.log(chalk.dim(`  backup: ${backup}`));
+  }
+
+  if (dryRun) {
+    console.log(JSON.stringify({ before, after }, null, 2));
+    return;
+  }
+
+  writeFileSync(SETTINGS_PATH, JSON.stringify(after, null, 2) + '\n');
+  console.log(chalk.green('  ✓ updated'));
+  console.log(chalk.dim(`  ${SETTINGS_PATH}`));
+}

package/cli/commands/workflow.mjs

@@ -217,8 +217,15 @@ export async function run(name, args, isHelpRequest) {
         );
       }
       const registry = loadModelRouter(flags.router || process.env.BIZAR_MODEL_ROUTER_PATH);
-      requireEffectiveInferenceEndpoint(registry);
-      const availableModelIds = await probeAvailableModels({ registry });
+      let availableModelIds;
+      try {
+        requireEffectiveInferenceEndpoint(registry);
+        availableModelIds = await probeAvailableModels({ registry });
+      } catch {
+        // Dynamic routing deliberately fails open to session-model inheritance.
+        // Do not retry provider aliases or block workflow startup on discovery.
+        availableModelIds = undefined;
+      }
       state = startWorkflow({
         ...ctx,
         profile: flags.profile || flags.workflow || 'default',

package/cli/core/workflow-state.mjs

@@ -318,31 +318,36 @@ export function validateWorkflowState(state, context) {
   assert(state.assignmentSnapshot.runId === state.runId, 'ASSIGNMENT_RUN_MISMATCH', 'model assignment snapshot belongs to a different run');
   assert(verifyRunAssignmentSnapshot(state.assignmentSnapshot), 'ASSIGNMENT_INTEGRITY_ERROR', 'model assignment snapshot fingerprint is invalid');
   assert(
-    typeof state.assignmentSnapshot.gatewayEndpoint === 'string' &&
+    state.assignmentSnapshot.gatewayEndpoint === null || (
+      typeof state.assignmentSnapshot.gatewayEndpoint === 'string' &&
       state.assignmentSnapshot.gatewayEndpoint.length > 0 &&
-      state.assignmentSnapshot.gatewayEndpoint.trim() === state.assignmentSnapshot.gatewayEndpoint,
+      state.assignmentSnapshot.gatewayEndpoint.trim() === state.assignmentSnapshot.gatewayEndpoint
+    ),
     'INVALID_STATE',
-    'model assignment snapshot gateway endpoint is invalid',
+    'routing snapshot gateway endpoint is invalid',
   );
   assert(
-    typeof state.assignmentSnapshot.availabilityProbe === 'string' &&
+    state.assignmentSnapshot.availabilityProbe === null || (
+      typeof state.assignmentSnapshot.availabilityProbe === 'string' &&
       state.assignmentSnapshot.availabilityProbe.length > 0 &&
-      state.assignmentSnapshot.availabilityProbe.trim() === state.assignmentSnapshot.availabilityProbe,
+      state.assignmentSnapshot.availabilityProbe.trim() === state.assignmentSnapshot.availabilityProbe
+    ),
     'INVALID_STATE',
-    'model assignment snapshot availability probe is invalid',
+    'routing snapshot availability probe is invalid',
   );
   assert(
-    state.assignmentSnapshot.assignments &&
-      typeof state.assignmentSnapshot.assignments === 'object' &&
-      !Array.isArray(state.assignmentSnapshot.assignments) &&
-      Object.keys(state.assignmentSnapshot.assignments).length > 0,
+    state.assignmentSnapshot.decisions &&
+      typeof state.assignmentSnapshot.decisions === 'object' &&
+      !Array.isArray(state.assignmentSnapshot.decisions),
     'INVALID_STATE',
-    'model assignment snapshot has no required agents',
+    'routing decision snapshot is invalid',
   );
-  for (const [agent, assignment] of Object.entries(state.assignmentSnapshot.assignments)) {
-    assert(typeof agent === 'string' && agent.length > 0, 'INVALID_STATE', 'model assignment agent is invalid');
-    assert(typeof assignment?.model === 'string' && assignment.model.length > 0, 'INVALID_STATE', `model assignment for ${agent} is invalid`);
-    assert(typeof assignment?.tier === 'string' && assignment.tier.length > 0, 'INVALID_STATE', `model tier for ${agent} is invalid`);
+  for (const [agent, decision] of Object.entries(state.assignmentSnapshot.decisions)) {
+    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(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`);
   }
   deepFreeze(state.assignmentSnapshot);
   assert(state.attempts && typeof state.attempts === 'object', 'INVALID_STATE', 'workflow attempt counters are missing');