@polderlabs/bizar 10.23.7 → 10.23.8

package/cli/commands/models.mjs

@@ -947,8 +947,9 @@ export function partitionStalePicks({ liveIds, pickedIds, disabledProviders }) {
  *
  * Behavior:
  *   - Reads `settings.json` if present; preserves every other field.
- *   - Writes `modelOverrides` as a sparse object for picked IDs that are
- *     also in `liveIds`; Claude Code still dispatches each literal value.
+ *   - Maps every recognized Claude alias into picked IDs that are also in
+ *     `liveIds`, preventing internal alias normalization from reaching an
+ *     unconfigured provider default.
  *   - Atomic replace via temp-file + rename (matches `applyModels`).
  *   - When `settingsJsonPath` is provided (tests), uses that instead of
  *     `~/.claude/settings.json`.
@@ -1007,6 +1008,12 @@ 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);
+  if (requiresGatewayModelDiscovery(synced)) {
+    settings.env = {
+      ...(settings.env || {}),
+      CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: '1',
+    };
+  }
   const previousModel = typeof settings.model === 'string' ? settings.model : null;
   const previousContext = profiles?.[previousModel]?.limits?.contextTokens;
   const nextModel = synced[0] || null;
@@ -1068,8 +1075,20 @@ export function buildClaudeModelOverrides(modelIds) {
   const unique = [...new Set((Array.isArray(modelIds) ? modelIds : [])
     .filter((id) => typeof id === 'string' && id.trim())
     .map((id) => id.trim()))];
-  return Object.fromEntries(unique.slice(0, CLAUDE_MODEL_OVERRIDE_KEYS.length)
-    .map((id, index) => [CLAUDE_MODEL_OVERRIDE_KEYS[index], id]));
+  if (unique.length === 0) return {};
+  // Cover every built-in alias: the workflow runtime may normalize an Agent
+  // request through one of these names, and no alias may escape to an
+  // unconfigured Anthropic default.
+  return Object.fromEntries(CLAUDE_MODEL_OVERRIDE_KEYS
+    .map((key, index) => [key, unique[index % unique.length]]));
+}
+
+/** Custom gateway IDs must be discoverable to Claude's SDK/subagent path. */
+export function requiresGatewayModelDiscovery(modelIds) {
+  return (Array.isArray(modelIds) ? modelIds : []).some((id) => {
+    if (typeof id !== 'string' || !id.trim()) return false;
+    return !/^(?:claude(?:-|$)|anthropic(?:[./-]|$))/i.test(id.trim());
+  });
 }
 
 /**

package/cli/doctor.mjs

@@ -42,6 +42,7 @@ import {
   REQUIRED_HOOKS,
 } from './commands/validate.mjs';
 import { configuredEnabledModels, listModels, resolveEndpoint } from './commands/models.mjs';
+import { validateNativeWorkflowDirectory } from '../config/workflows/lib/native-contract.mjs';
 
 const REQUIRED_RULES = [
   'general.md', 'git.md', 'javascript.md', 'python.md',
@@ -157,6 +158,13 @@ async function checkHookFilesInstalled() {
   return `all ${REQUIRED_HOOKS.length} hook entrypoints installed`;
 }
 
+async function checkNativeWorkflowsInstalled() {
+  const dir = join(claudeDir(), 'workflows');
+  if (!existsSync(dir)) throw new Error(`workflows dir missing: ${dir} — run \`bizar update\``);
+  const result = validateNativeWorkflowDirectory(dir);
+  return `${result.count} native workflows parser-compatible and filename-addressable`;
+}
+
 /**
  * Lenient: passes if at least one of semble/skills/claude is on PATH.
  * These are informational — none of them are strictly required for
@@ -216,6 +224,7 @@ const CHECKS = [
   { name: 'skill-files-installed',     run: checkSkillFilesInstalled },
   { name: 'rule-files-installed',      run: checkRuleFilesInstalled },
   { name: 'hook-files-installed',      run: checkHookFilesInstalled },
+  { name: 'native-workflows-valid',    run: checkNativeWorkflowsInstalled },
   { name: 'tools-on-path',             run: checkToolsAvailable },
   { name: 'bizar-home',                run: checkBizarHome },
   { name: 'provider-reachable',        run: checkProviderReachable },

package/cli/provision.mjs

@@ -32,7 +32,12 @@ 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 { buildClaudeModelOverrides, configuredEnabledModels } from './commands/models.mjs';
+import {
+  buildClaudeModelOverrides,
+  configuredEnabledModels,
+  requiresGatewayModelDiscovery,
+} from './commands/models.mjs';
+import { validateNativeWorkflowDirectory } from '../config/workflows/lib/native-contract.mjs';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -921,7 +926,6 @@ export function writeClaudeSettings({ dryRun = false, force = false } = {}) {
         pickEnv('CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS')
         || shipped.env?.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS
         || '1',
-      ...(pickEnv('ANTHROPIC_MODEL') ? { ANTHROPIC_MODEL: pickEnv('ANTHROPIC_MODEL') } : {}),
     },
     hooks: {
       UserPromptSubmit: [{ hooks: [hook('user-prompt-submit', 10)] }],
@@ -968,6 +972,10 @@ export function writeClaudeSettings({ dryRun = false, force = false } = {}) {
   if (installModel) {
     bizarSettings.model = installModel;
     bizarSettings.modelOverrides = buildClaudeModelOverrides(installModels);
+    bizarSettings.env.ANTHROPIC_MODEL = installModel;
+    if (operatorGatewayUrl && requiresGatewayModelDiscovery(installModels)) {
+      bizarSettings.env.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY = '1';
+    }
     const configuredContext = pickEnv('CLAUDE_CODE_MAX_CONTEXT_TOKENS') || installContextTokens;
     if (configuredContext) bizarSettings.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS = String(configuredContext);
   } else {
@@ -1013,6 +1021,9 @@ export function writeClaudeSettings({ dryRun = false, force = false } = {}) {
   if (installModel) {
     merged.model = installModel;
     merged.modelOverrides = bizarSettings.modelOverrides;
+    merged.env = { ...(merged.env || {}), ANTHROPIC_MODEL: installModel };
+  } else if (merged.env && typeof merged.env === 'object') {
+    delete merged.env.ANTHROPIC_MODEL;
   }
 
   // Auto-compaction is part of the Bizar reliability contract. Remove legacy
@@ -1348,9 +1359,9 @@ export async function syncConfigExtras({ dryRun = false } = {}) {
   const workflowsSrc = join(REPO_ROOT, 'config', 'workflows');
   if (existsSync(workflowsSrc)) {
     const workflowsDst = join(CLAUDE_DIR, 'workflows');
+    validateNativeWorkflowDirectory(workflowsSrc);
     await copyDirIfExists(workflowsSrc, workflowsDst);
-    counts.workflows = readdirSync(workflowsSrc, { withFileTypes: true })
-      .filter((entry) => entry.isFile() && entry.name.endsWith('.js')).length;
+    counts.workflows = validateNativeWorkflowDirectory(workflowsDst).count;
   }
 
   return { ok: true, message: `synced (${counts.commands} commands, ${counts.skills} skills, ${counts.hooks} hooks, ${counts.rules} rules, ${counts.workflows} workflows)`, counts };
@@ -1374,7 +1385,6 @@ export const FORCE_CLEAN_PRESERVE_ENV_KEYS = Object.freeze([
   'ANTHROPIC_AUTH_TOKEN',
   'BIZAR_MODEL_ROUTER_URL',
   'BIZAR_HOME',
-  'ANTHROPIC_MODEL',
   'CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY',
   'CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS',
   'CLAUDE_CODE_MAX_CONTEXT_TOKENS',

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

@@ -29,6 +29,23 @@ 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 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. Never pass only a string and never use
+`inherit`, `sonnet`, `opus`, or another provider default. If no configured ID
+exists, stop and ask the operator to run `bizar models`.
+
+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
+with the absolute installed `scriptPath` at
+`<CLAUDE_CONFIG_DIR>/workflows/<name>.js` (normally
+`~/.claude/workflows/<name>.js`). Never retry a bare filename or a repository
+relative path. If that file is missing or invalid, stop with `bizar update`
+and `bizar doctor` as the repair commands; do not improvise a primary-session
+implementation around a broken workflow installation.
+
 ## Models
 
 For every Agent call, select the cheapest sufficient enabled configured model

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

@@ -36,11 +36,11 @@
  *     validated by `pickFailover` against the same registry.
  *   - The hard deny of out-of-pool models STILL APPLIES when
  *     `routingDecisionId` is absent — the contract is opt-in.
- *   - Registry load failures still fail open (F-176 advisory): the orchestrator
- *     already chose a model, let Claude Code validate it once.
+ *   - Registry load failures fail closed: allowing the dispatch would hand
+ *     model choice back to Claude Code's unconfigured provider default.
  *
- * The contract is intentionally additive. Existing callers that only pass
- * `model` see no behavior change.
+ * Callers that pass only `model` are accepted only when that literal ID is in
+ * the enabled configured pool. Missing or inherited model selection is denied.
  */
 
 import { readFileSync } from 'node:fs';
@@ -48,16 +48,6 @@ import { pathToFileURL } from 'node:url';
 
 import { loadModelRouter } from '../../../config/agents/model-assignment.mjs';
 
-function advise(reason) {
-  return {
-    hookSpecificOutput: {
-      hookEventName: 'PreToolUse',
-      permissionDecision: 'allow',
-      additionalContext: `🟡 Model override guidance: ${reason} The dispatch will proceed regardless.`,
-    },
-  };
-}
-
 function deny(reason) {
   return {
     hookSpecificOutput: {
@@ -72,8 +62,6 @@ function deny(reason) {
  * 10.22.0 / Phase 4: extract the operator's `disabledProviders` list from
  * the loaded registry. Whitespace-trimmed + lowercased at read time.
  * Returns `[]` for legacy configs that lack the key (no in-code default).
- * The hook MUST fail open on parse errors — the orchestrator already
- * chose a model; let Claude Code validate it once.
  */
 function readDisabledProvidersFromRegistry(registry) {
   if (!registry || typeof registry !== 'object') return [];
@@ -90,14 +78,15 @@ function readDisabledProvidersFromRegistry(registry) {
 }
 
 /**
- * 10.22.0 / Phase 4: case-sensitive prefix filter against the (lowercase)
- * disabled list. Empty / missing prefix list is a no-op (returns input).
+ * 10.22.0 / Phase 4: case-insensitive prefix filter against the normalized
+ * disabled list. Empty / missing prefix list is a no-op.
  */
 function isDisabledId(id, prefixes) {
   if (!Array.isArray(prefixes) || prefixes.length === 0) return false;
   if (typeof id !== 'string' || !id) return false;
+  const normalized = id.toLowerCase();
   for (const p of prefixes) {
-    if (typeof p === 'string' && p && id.startsWith(p)) return true;
+    if (typeof p === 'string' && p && normalized.startsWith(p)) return true;
   }
   return false;
 }
@@ -171,18 +160,15 @@ export async function guardAgentModel(input, options = {}) {
   const failoverBlock = readFailoverBlock(toolInput);
   const hasFailoverContract = Boolean(failoverBlock.routingDecisionId) && Boolean(failoverBlock.fallback);
 
-  // The workflow dispatcher enforces a model override. This permissive branch
-  // keeps the hook compatible with non-Bizar Agent callers.
-  if (!requested) return {};
-  if (requested === 'inherit') return {};
+  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);
   } catch {
-    // A broken optional router must not strand subagents. The caller already
-    // chose a model; let Claude Code/provider validate it once.
-    return {};
+    return deny('Bizar Agent dispatch blocked: the global model router is missing or invalid. Run `bizar models`, then retry.');
   }
 
   // Disabled is an enforceable operator boundary. Falling through here would
@@ -201,17 +187,17 @@ export async function guardAgentModel(input, options = {}) {
   // already computed by `pickFailover` against this same registry.
   if (hasFailoverContract) {
     if (!userPicks.has(failoverBlock.fallback)) {
-      return advise(`Bizar Agent dispatch: fallback ${failoverBlock.fallback} is outside the user-selected pool; select an enabled configured fallback.`);
+      return deny(`Bizar Agent dispatch blocked: fallback ${failoverBlock.fallback} is outside the user-selected pool; select an enabled configured fallback.`);
     }
     if (!allowed.has(requested)) {
-      return advise(`Bizar Agent dispatch blocked: model override ${requested} is outside the configured dynamic tiers and the user-selected pool. Pick it via \`bizar models\`.`);
+      return deny(`Bizar Agent dispatch blocked: model override ${requested} is outside the configured dynamic tiers and the user-selected pool. Pick it via \`bizar models\`.`);
     }
     // Both IDs are user-selected. Accept without re-probing the gateway.
     return {};
   }
 
   if (!allowed.has(requested)) {
-    return advise(`Bizar Agent dispatch blocked: model override ${requested} is outside the configured dynamic tiers and the user-selected pool. Pick it via \`bizar models\`.`);
+    return deny(`Bizar Agent dispatch blocked: model override ${requested} is outside the configured dynamic tiers and the user-selected pool. Pick it via \`bizar models\`.`);
   }
 
   // User-selected models bypass live-discovery validation. The picker is the
@@ -220,7 +206,7 @@ export async function guardAgentModel(input, options = {}) {
   if (!fromUserPick && Array.isArray(options.availableModelIds)) {
     const available = new Set(options.availableModelIds);
     if (!available.has(requested)) {
-      return advise(`Bizar Agent dispatch blocked: ${requested} was not reported by live discovery. Select another enabled configured model; do not retry aliases.`);
+      return deny(`Bizar Agent dispatch blocked: ${requested} was not reported by live discovery. Select another enabled configured model; do not retry aliases.`);
     }
   }
 

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

@@ -122,6 +122,10 @@ function filterDisabled(ids, disabled) {
   return kept;
 }
 
+function requiresGatewayModelDiscovery(modelIds) {
+  return modelIds.some((id) => !/^(?:claude(?:-|$)|anthropic(?:[./-]|$))/i.test(id));
+}
+
 function readSettingsPath() {
   return join(resolveClaudeConfigDir(), 'settings.json');
 }
@@ -234,8 +238,14 @@ function syncOnce() {
   ];
   settings.modelPicker = { options };
   settings.modelOverrides = Object.fromEntries(
-    liveIds.slice(0, overrideKeys.length).map((id, index) => [overrideKeys[index], id]),
+    overrideKeys.map((key, index) => [key, liveIds[index % liveIds.length]]),
   );
+  if (requiresGatewayModelDiscovery(liveIds)) {
+    settings.env = {
+      ...(settings.env || {}),
+      CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: '1',
+    };
+  }
 
   let modelChanged = false;
   if (typeof settings.model !== 'string' || !liveIds.includes(settings.model)) {

package/config/claude/hooks/workflow-route-guard.mjs

@@ -33,14 +33,18 @@ export function workflowCompletedSuccessfully(input) {
   const root = input?.tool_response ?? input?.tool_result ?? input?.toolUseResult;
   if (!root || typeof root !== 'object') return false;
   const statuses = [];
+  let nestedError = false;
+  let acceptedLaunch = false;
   const visit = (value, depth = 0) => {
     if (!value || typeof value !== 'object' || depth > 3) return;
     if (typeof value.status === 'string') statuses.push(value.status.toLowerCase());
+    if (value.is_error === true || value.error) nestedError = true;
+    if (value.status === 'async_launched' && value.taskType === 'local_workflow') acceptedLaunch = true;
     for (const key of ['result', 'workflow', 'data']) visit(value[key], depth + 1);
   };
   visit(root);
-  if (root.is_error === true || root.error || statuses.some((status) => WORKFLOW_FAILURE.has(status))) return false;
-  return statuses.some((status) => WORKFLOW_SUCCESS.has(status));
+  if (nestedError || statuses.some((status) => WORKFLOW_FAILURE.has(status))) return false;
+  return acceptedLaunch || statuses.some((status) => WORKFLOW_SUCCESS.has(status));
 }
 
 let raw = '';

package/config/workflows/bizar-debug.js

@@ -1,6 +1,3 @@
-import { randomUUID } from 'node:crypto'
-import { dispatchAgent, writeArtifact, barrierRef } from './lib/dispatch.js'
-
 export const meta = {
   name: 'bizar-debug',
   description: 'Root-cause a bug with bounded loop-until-dry: RCA hypothesis, adversarial verification, smallest fix, regression test',
@@ -14,6 +11,44 @@ export const meta = {
   ],
 }
 
+const WORKFLOW_INPUT = args && typeof args === 'object' ? args : {}
+const WORKFLOW_ROUTING = WORKFLOW_INPUT.routing && typeof WORKFLOW_INPUT.routing === 'object'
+  ? WORKFLOW_INPUT.routing
+  : {}
+const WORKFLOW_DEFAULT_MODEL = typeof WORKFLOW_INPUT.model === 'string'
+  ? WORKFLOW_INPUT.model.trim()
+  : Array.isArray(WORKFLOW_INPUT.models) && typeof WORKFLOW_INPUT.models[0] === 'string'
+    ? WORKFLOW_INPUT.models[0].trim()
+    : ''
+const routeModel = (risk) => {
+  const candidate = WORKFLOW_ROUTING[risk] || WORKFLOW_ROUTING.default || WORKFLOW_DEFAULT_MODEL
+  return typeof candidate === 'string' ? candidate.trim() : ''
+}
+if (!routeModel('medium') || !routeModel('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.',
+  }
+}
+let WORKFLOW_DISPATCH_SEQUENCE = 0
+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'),
+    effort: opts.risk === 'high' ? 'high' : 'medium',
+  }
+  if (opts.schema) agentOptions.schema = opts.schema
+  if (opts.isolation) agentOptions.isolation = opts.isolation
+  if (opts.disallowedTools) agentOptions.disallowedTools = opts.disallowedTools
+  return agentFn(`${prefix}\n${prompt}`, agentOptions)
+}
+const barrierRef = ({ phase, label, summary, payload }) => {
+  let evidence = ''
+  try { evidence = JSON.stringify(payload ?? '').slice(0, 12000) } catch { evidence = '<unserializable>' }
+  return { promptBlock: `Prior phase: ${phase}; label: ${label}; summary: ${summary || ''}\nBounded evidence: ${evidence}` }
+}
+
 const BUG_ID = typeof args === 'string'
   ? args
   : (args && typeof args.bug_id === 'string')
@@ -22,9 +57,7 @@ const BUG_ID = typeof args === 'string'
       ? args.topic
       : JSON.stringify(args || {})
 
-// Phase B (v10.21.0) artifact-on-disk barriers: one runId per workflow
-// invocation. Used by every writeArtifact() + barrierRef() in this script.
-const RUN_ID = randomUUID()
+const RUN_ID = 'bizar-debug'
 
 const HYPOTHESIS = {
   type: 'object',
@@ -48,8 +81,6 @@ const iterations = []
 phase('Hypothesis')
 const initial = await dispatchAgent(agent, 'rca-hypothesis', `Root-cause bug ${BUG_ID} with the cheapest discriminating experiment. Return {cause, experiment, predictedOutcome}. Do not propose a fix yet.`, { role: 'research-analyst', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: 'hypothesis:initial', phase: 'Hypothesis', schema: HYPOTHESIS })
 iterations.push(initial)
-// Phase B: persist initial hypothesis artifact.
-writeArtifact({ runId: RUN_ID, phase: 'Hypothesis', label: 'hypothesis:initial', payload: initial, summary: initial?.cause ? initial.cause.slice(0, 200) : 'initial hypothesis', role: 'research-analyst' })
 
 let accepted = null
 for (let i = 0; i < MAX_ITERATIONS; i++) {
@@ -68,8 +99,6 @@ for (let i = 0; i < MAX_ITERATIONS; i++) {
   phase('Loop')
   const refined = await dispatchAgent(agent, 'rca-refiner', `The previous RCA hypothesis for bug ${BUG_ID} was not confirmed. Produce a refined hypothesis with a new cheapest discriminating experiment.\n${barrierRef({ runId: RUN_ID, phase: 'Hypothesis', label: priorLabel, summary: prior?.cause ? prior.cause.slice(0, 200) : `prior iter ${i + 1}` }).promptBlock}\n${barrierRef({ runId: RUN_ID, phase: 'AdversarialVerify', label: `verify:${i + 1}`, summary: verdict?.reason ? verdict.reason.slice(0, 200) : 'no confirmation' }).promptBlock}`, { role: 'research-analyst', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: `refine:${i + 1}`, phase: 'Loop', schema: HYPOTHESIS })
   iterations.push(refined)
-  // Phase B: persist refined hypothesis artifact.
-  writeArtifact({ runId: RUN_ID, phase: 'Hypothesis', label: `refine:${i + 1}`, payload: refined, summary: refined?.cause ? refined.cause.slice(0, 200) : `refined iter ${i + 1}`, role: 'research-analyst' });
 }
 
 if (!accepted) {
@@ -83,7 +112,6 @@ if (!accepted) {
 
 phase('Fix')
 const fix = await dispatchAgent(agent, 'fix-author', `Implement the smallest fix + regression test for bug ${BUG_ID} based on the accepted hypothesis. Edit and test in your isolated worktree. Do not commit, push, publish, or deploy.\n${barrierRef({ runId: RUN_ID, phase: 'Hypothesis', label: 'hypothesis:initial', summary: accepted.hypothesis?.cause ? accepted.hypothesis.cause.slice(0, 200) : 'accepted hypothesis' }).promptBlock}`, { role: 'implementer', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: 'fix', phase: 'Fix', isolation: 'worktree' })
-writeArtifact({ runId: RUN_ID, phase: 'Fix', label: 'fix', payload: fix, summary: typeof fix === 'string' ? fix.slice(0, 200) : 'fix proposed', role: 'implementer' })
 
 phase('Verify')
 const verify = await dispatchAgent(agent, 'fix-verifier', `Re-check the proposed fix for bug ${BUG_ID} against the regression test and adjacent paths. Reject the fix if it is unbounded, out of scope, or already covered.\n${barrierRef({ runId: RUN_ID, phase: 'Fix', label: 'fix', summary: typeof fix === 'string' ? fix.slice(0, 200) : 'fix artifact' }).promptBlock}`, { role: 'adversarial', risk: 'high', capabilities: ['structured-output', 'reasoning'], label: 'fix-verify', phase: 'Verify' })

package/config/workflows/bizar-implement.js

@@ -1,5 +1,3 @@
-import { dispatchAgent } from './lib/dispatch.js'
-
 export const meta = {
   name: 'bizar-implement',
   description: 'Implement one bounded change in one worktree, or run explicitly supplied disjoint lanes concurrently',
@@ -9,6 +7,44 @@ export const meta = {
   ],
 }
 
+const WORKFLOW_INPUT = args && typeof args === 'object' ? args : {}
+const WORKFLOW_ROUTING = WORKFLOW_INPUT.routing && typeof WORKFLOW_INPUT.routing === 'object'
+  ? WORKFLOW_INPUT.routing
+  : {}
+const WORKFLOW_DEFAULT_MODEL = typeof WORKFLOW_INPUT.model === 'string'
+  ? WORKFLOW_INPUT.model.trim()
+  : Array.isArray(WORKFLOW_INPUT.models) && typeof WORKFLOW_INPUT.models[0] === 'string'
+    ? WORKFLOW_INPUT.models[0].trim()
+    : ''
+const routeModel = (risk) => {
+  const candidate = WORKFLOW_ROUTING[risk] || WORKFLOW_ROUTING.default || WORKFLOW_DEFAULT_MODEL
+  return typeof candidate === 'string' ? candidate.trim() : ''
+}
+if (!routeModel('medium') || !routeModel('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.',
+  }
+}
+let WORKFLOW_DISPATCH_SEQUENCE = 0
+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'),
+    effort: opts.risk === 'high' ? 'high' : 'medium',
+  }
+  if (opts.schema) agentOptions.schema = opts.schema
+  if (opts.isolation) agentOptions.isolation = opts.isolation
+  if (opts.disallowedTools) agentOptions.disallowedTools = opts.disallowedTools
+  return agentFn(`${prefix}\n${prompt}`, agentOptions)
+}
+const barrierRef = ({ phase, label, summary, payload }) => {
+  let evidence = ''
+  try { evidence = JSON.stringify(payload ?? '').slice(0, 12000) } catch { evidence = '<unserializable>' }
+  return { promptBlock: `Prior phase: ${phase}; label: ${label}; summary: ${summary || ''}\nBounded evidence: ${evidence}` }
+}
+
 const TOPIC = typeof args === 'string'
   ? args
   : (args && typeof args.topic === 'string')

package/config/workflows/bizar-research.js

@@ -1,6 +1,3 @@
-import { randomUUID } from 'node:crypto'
-import { dispatchAgent, writeArtifact, barrierRef } from './lib/dispatch.js'
-
 export const meta = {
   name: 'bizar-research',
   description: 'Research, plan, audit, and implement a bounded task across disjoint lanes with sequential pipeline verification',
@@ -14,16 +11,51 @@ export const meta = {
   ],
 }
 
+const WORKFLOW_INPUT = args && typeof args === 'object' ? args : {}
+const WORKFLOW_ROUTING = WORKFLOW_INPUT.routing && typeof WORKFLOW_INPUT.routing === 'object'
+  ? WORKFLOW_INPUT.routing
+  : {}
+const WORKFLOW_DEFAULT_MODEL = typeof WORKFLOW_INPUT.model === 'string'
+  ? WORKFLOW_INPUT.model.trim()
+  : Array.isArray(WORKFLOW_INPUT.models) && typeof WORKFLOW_INPUT.models[0] === 'string'
+    ? WORKFLOW_INPUT.models[0].trim()
+    : ''
+const routeModel = (risk) => {
+  const candidate = WORKFLOW_ROUTING[risk] || WORKFLOW_ROUTING.default || WORKFLOW_DEFAULT_MODEL
+  return typeof candidate === 'string' ? candidate.trim() : ''
+}
+if (!routeModel('medium') || !routeModel('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.',
+  }
+}
+let WORKFLOW_DISPATCH_SEQUENCE = 0
+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'),
+    effort: opts.risk === 'high' ? 'high' : 'medium',
+  }
+  if (opts.schema) agentOptions.schema = opts.schema
+  if (opts.isolation) agentOptions.isolation = opts.isolation
+  if (opts.disallowedTools) agentOptions.disallowedTools = opts.disallowedTools
+  return agentFn(`${prefix}\n${prompt}`, agentOptions)
+}
+const barrierRef = ({ phase, label, summary, payload }) => {
+  let evidence = ''
+  try { evidence = JSON.stringify(payload ?? '').slice(0, 12000) } catch { evidence = '<unserializable>' }
+  return { promptBlock: `Prior phase: ${phase}; label: ${label}; summary: ${summary || ''}\nBounded evidence: ${evidence}` }
+}
+
 const TOPIC = typeof args === 'string'
   ? args
   : (args && typeof args.topic === 'string')
     ? args.topic
     : JSON.stringify(args || {})
 
-// Phase B (v10.21.0) artifact-on-disk barriers: one runId per workflow
-// invocation. Used by every writeArtifact() + barrierRef() in this script
-// so the on-disk store + the 3-line barrier block stay paired.
-const RUN_ID = randomUUID()
+const RUN_ID = 'bizar-research'
 
 const BRIEF = {
   type: 'object',
@@ -65,9 +97,7 @@ const research = (await parallel([
 
 if (research.length === 0) return { status: 'blocked', reason: 'No research agent completed successfully.' }
 
-// Phase B: persist the research artifact for the next barrier agent.
 const researchSummary = `research lanes: ${research.map((r) => (r && r.summary) ? r.summary.slice(0, 80) : '<lane>').join(' | ')}`
-writeArtifact({ runId: RUN_ID, phase: 'Research', label: 'barrier', payload: research, summary: researchSummary, role: 'research-analyst' })
 
 phase('Plan')
 const plan = await dispatchAgent(agent, 'plan-author', `Design one reversible implementation for: ${TOPIC}\n${barrierRef({ runId: RUN_ID, phase: 'Research', label: 'barrier', summary: researchSummary }).promptBlock}\nReturn disjoint edit lanes. Shared root/config/lock files must have one owner. Include bounded tests and stop conditions.`, { role: 'architect', risk: 'medium', capabilities: ['structured-output', 'reasoning', 'architecture'], label: 'plan', phase: 'Plan', schema: PLAN })
@@ -75,9 +105,7 @@ if (!plan || !Array.isArray(plan.lanes) || plan.lanes.length === 0) {
   return { status: 'blocked', reason: 'Planning produced no implementation lanes.', research }
 }
 
-// Phase B: persist the plan artifact for the next barrier agent.
 const planSummary = `plan lanes: ${plan.lanes.map((l) => l.name).join(', ')}`
-writeArtifact({ runId: RUN_ID, phase: 'Plan', label: 'barrier', payload: plan, summary: planSummary, role: 'architect' })
 
 phase('Audit')
 const audit = await dispatchAgent(agent, 'plan-auditor', `Adversarially review this plan for correctness, security, conflicting file ownership, missing regression tests, and unbounded retry loops. Return a corrected plan, not commentary. Topic: ${TOPIC}\n${barrierRef({ runId: RUN_ID, phase: 'Plan', label: 'barrier', summary: planSummary }).promptBlock}`, { role: 'adversarial', risk: 'high', capabilities: ['structured-output', 'reasoning', 'architecture', 'security'], label: 'plan-audit', phase: 'Audit', schema: PLAN })
@@ -101,14 +129,6 @@ if (completed.length === 0) {
   return { status: 'blocked', reason: 'No implementation lane completed successfully.', plan: approved }
 }
 
-// Phase B: persist each lane's artifact for the next barrier agent.
-for (let i = 0; i < completed.length; i++) {
-  const lane = lanes[i];
-  const label = `implement:${i + 1}:${lane.name}`;
-  const summary = `lane ${lane.name} files: ${(completed[i]?.files || []).slice(0, 5).join(', ')}`;
-  writeArtifact({ runId: RUN_ID, phase: 'Implement', label, payload: completed[i], summary, role: 'implementer' });
-}
-
 phase('Verify')
 const reviews = await pipeline(
   completed,
@@ -119,11 +139,7 @@ const reviews = await pipeline(
     { role: 'adversarial', risk: 'high', capabilities: ['structured-output', 'reasoning'], label: `review:${index + 1}`, phase: 'Verify' },
   ),
 )
-// Phase B: persist review artifacts.
 const verifiedReviews = reviews.filter(Boolean);
-for (let i = 0; i < verifiedReviews.length; i++) {
-  writeArtifact({ runId: RUN_ID, phase: 'Verify', label: `review:${i + 1}`, payload: verifiedReviews[i], summary: typeof verifiedReviews[i] === 'string' ? verifiedReviews[i].slice(0, 200) : `review ${i + 1}`, role: 'adversarial' });
-}
 const final = await dispatchAgent(agent, 'final-verifier', `Synthesize a bounded integration and verification report for topic "${TOPIC}". Do not claim success without fresh command evidence. Identify conflicts between worktrees, exact integration order, remaining gates, and any required human approvals.\n${barrierRef({ runId: RUN_ID, phase: 'Plan', label: 'barrier', summary: `approved plan with ${approved.lanes.length} lanes` }).promptBlock}\n${barrierRef({ runId: RUN_ID, phase: 'Implement', label: 'implement:summary', summary: `${completed.length} lanes complete` }).promptBlock}\n${barrierRef({ runId: RUN_ID, phase: 'Verify', label: 'review:summary', summary: `${verifiedReviews.length} reviews complete` }).promptBlock}`, { role: 'implementer', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: 'final-verification', phase: 'Verify' })
 
-return { status: 'ready-for-integration', topic: TOPIC, research, plan: approved, implementation: completed, reviews: reviews.filter(Boolean), final }
+return { status: 'ready-for-integration', topic: TOPIC, research, plan: approved, implementation: completed, reviews: reviews.filter(Boolean), final }

package/config/workflows/lib/dispatch.js

@@ -1,5 +1,5 @@
 /**
- * config/workflows/lib/dispatch.js — Workflow-side dispatch wrapper (F-189 / IMP-014).
+ * config/workflows/lib/dispatch.js — host-side dispatch and evidence utilities.
  *
  * Closes the IMP-014 P0 gap from `IMPROVEMENTS.md` line 867: every
  * `agent(...)` call emitted by native workflow scripts (`config/workflows/*.js`)
@@ -7,7 +7,7 @@
  * ride on every dispatch. The acceptance gate is verbatim: "Captured nested
  * Agent payloads contain expected models."
  *
- * This module is the single entry point for workflow-side dispatch. It:
+ * This retained host-side module:
  *
  *   1. Reads the operator's `userSelected.profiles`, the provider-health
  *      snapshot, and the budget from the canonical config paths.
@@ -21,10 +21,11 @@
  *   4. Supports `dryRun: true` so the capture test can introspect
  *      payloads without invoking a real agent.
  *
- * IMPORTANT: every workflow script in `config/workflows/*.js` MUST import
- * `dispatchAgent` from this module. The drift guard
- * `scripts/__tests__/autonomy-contract-workflow.test.mjs` fails CI when a
- * bare `agent(` call is reintroduced without a documented bypass.
+ * Claude's native workflow VM rejects static and dynamic imports. Shipped
+ * workflow entrypoints therefore contain a small self-contained wrapper and
+ * receive explicit configured model IDs through `args.routing`. This module
+ * remains the canonical host/test implementation for selector and evidence
+ * behavior outside that VM boundary.
  */
 
 import { randomUUID, createHash } from 'node:crypto';
@@ -885,10 +886,6 @@ export async function dispatchAgent(agentFn, agentName, prompt, opts = {}, conte
     return { __dispatchDecision: decision, payload: augmented };
   }
 
-  if (opts.forceModel && typeof opts.forceModel === 'string') {
-    augmented.model = opts.forceModel;
-  }
-
   const startMs = Date.now();
   try {
     const result = await agentFn(prompt, augmented);

package/config/workflows/lib/native-contract.mjs

@@ -0,0 +1,96 @@
+import { readdirSync, readFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+
+const META_PREFIX = 'export const meta =';
+
+function firstStatement(source) {
+  return String(source).replace(/^\uFEFF/, '').trimStart();
+}
+
+function workflowParts(source) {
+  const normalized = firstStatement(source);
+  if (!normalized.startsWith(META_PREFIX)) {
+    throw new Error('`export const meta = { name, description, phases }` must be the FIRST statement in the script');
+  }
+
+  const open = normalized.indexOf('{', META_PREFIX.length);
+  if (open < 0) throw new Error('meta must be a pure object literal');
+
+  let depth = 0;
+  let quote = '';
+  let escaped = false;
+  for (let index = open; index < normalized.length; index += 1) {
+    const character = normalized[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (quote) {
+      if (character === '\\') escaped = true;
+      else if (character === quote) quote = '';
+      continue;
+    }
+    if (character === '"' || character === "'" || character === '`') {
+      quote = character;
+      continue;
+    }
+    if (character === '{') depth += 1;
+    if (character === '}') {
+      depth -= 1;
+      if (depth === 0) {
+        return {
+          block: normalized.slice(open, index + 1),
+          body: normalized.slice(index + 1).replace(/^\s*;?/, ''),
+        };
+      }
+    }
+  }
+  throw new Error('meta object literal is not balanced');
+}
+
+export function inspectNativeWorkflowSource(source, { expectedName } = {}) {
+  const { block, body } = workflowParts(source);
+  const name = block.match(/\bname\s*:\s*(['"])([^'"\r\n]+)\1/)?.[2];
+  if (!name) throw new Error('meta.name must be a non-empty string literal');
+  if (!/\bdescription\s*:\s*(['"])[^'"\r\n]+\1/.test(block)) {
+    throw new Error('meta.description must be a non-empty string literal');
+  }
+  if (!/\bphases\s*:\s*\[/.test(block)) throw new Error('meta.phases must be an array literal');
+  if (expectedName && name !== expectedName) {
+    throw new Error(`meta.name ${JSON.stringify(name)} does not match filename ${JSON.stringify(expectedName)}`);
+  }
+  if (/^\s*import\s/m.test(body) || /\bimport\s*\(/.test(body)) {
+    throw new Error('workflow body must be self-contained; imports are unavailable');
+  }
+  try {
+    Function(`return (async () => { 'use strict';\n${body}\n});`);
+  } catch (error) {
+    throw new Error(`workflow body does not compile: ${error.message}`);
+  }
+  return { name };
+}
+
+export function validateNativeWorkflowFile(path) {
+  const expectedName = basename(path, '.js');
+  try {
+    return inspectNativeWorkflowSource(readFileSync(path, 'utf8'), { expectedName });
+  } catch (error) {
+    throw new Error(`${path}: ${error.message}`);
+  }
+}
+
+export function validateNativeWorkflowDirectory(directory) {
+  const files = readdirSync(directory, { withFileTypes: true })
+    .filter((entry) => entry.isFile() && entry.name.endsWith('.js'))
+    .map((entry) => join(directory, entry.name))
+    .sort();
+  if (files.length === 0) throw new Error(`${directory}: no workflow scripts found`);
+
+  const names = new Set();
+  for (const file of files) {
+    const { name } = validateNativeWorkflowFile(file);
+    if (names.has(name)) throw new Error(`${file}: duplicate workflow name ${JSON.stringify(name)}`);
+    names.add(name);
+  }
+  return { count: files.length, names: [...names] };
+}

package/config/workflows/ultracode-research.js

@@ -1,6 +1,3 @@
-import { randomUUID } from 'node:crypto'
-import { dispatchAgent, writeArtifact, barrierRef } from './lib/dispatch.js'
-
 export const meta = {
   name: 'ultracode-research',
   description: 'Research a technical question with independent repository, documentation, architecture, and adversarial passes',
@@ -12,11 +9,47 @@ export const meta = {
   ],
 }
 
+const WORKFLOW_INPUT = args && typeof args === 'object' ? args : {}
+const WORKFLOW_ROUTING = WORKFLOW_INPUT.routing && typeof WORKFLOW_INPUT.routing === 'object'
+  ? WORKFLOW_INPUT.routing
+  : {}
+const WORKFLOW_DEFAULT_MODEL = typeof WORKFLOW_INPUT.model === 'string'
+  ? WORKFLOW_INPUT.model.trim()
+  : Array.isArray(WORKFLOW_INPUT.models) && typeof WORKFLOW_INPUT.models[0] === 'string'
+    ? WORKFLOW_INPUT.models[0].trim()
+    : ''
+const routeModel = (risk) => {
+  const candidate = WORKFLOW_ROUTING[risk] || WORKFLOW_ROUTING.default || WORKFLOW_DEFAULT_MODEL
+  return typeof candidate === 'string' ? candidate.trim() : ''
+}
+if (!routeModel('medium') || !routeModel('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.',
+  }
+}
+let WORKFLOW_DISPATCH_SEQUENCE = 0
+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'),
+    effort: opts.risk === 'high' ? 'high' : 'medium',
+  }
+  if (opts.schema) agentOptions.schema = opts.schema
+  if (opts.isolation) agentOptions.isolation = opts.isolation
+  if (opts.disallowedTools) agentOptions.disallowedTools = opts.disallowedTools
+  return agentFn(`${prefix}\n${prompt}`, agentOptions)
+}
+const barrierRef = ({ phase, label, summary, payload }) => {
+  let evidence = ''
+  try { evidence = JSON.stringify(payload ?? '').slice(0, 12000) } catch { evidence = '<unserializable>' }
+  return { promptBlock: `Prior phase: ${phase}; label: ${label}; summary: ${summary || ''}\nBounded evidence: ${evidence}` }
+}
+
 const QUESTION = typeof args === 'string' ? args : args?.question || JSON.stringify(args || {})
 
-// Phase B (v10.21.0) artifact-on-disk barriers: one runId per workflow
-// invocation. Used by every writeArtifact() + barrierRef() in this script.
-const RUN_ID = randomUUID()
+const RUN_ID = 'ultracode-research'
 const EVIDENCE = {
   type: 'object',
   required: ['claims', 'gaps'],
@@ -43,12 +76,10 @@ if (evidence.length === 0) return { status: 'blocked', reason: 'No research pass
 
 // Phase B: persist evidence artifact for the next barrier agent.
 const evidenceSummary = `${evidence.length} evidence passes with ${evidence.reduce((n, e) => n + (Array.isArray(e?.claims) ? e.claims.length : 0), 0)} total claims`
-writeArtifact({ runId: RUN_ID, phase: 'Research', label: 'barrier', payload: evidence, summary: evidenceSummary, role: 'research-analyst' })
 
 phase('Critique')
 const critique = await dispatchAgent(agent, 'completeness-critic', `Challenge these research claims. Identify contradictions, unread sources, outdated assumptions, and claims lacking reproducible evidence.\nQuestion: ${QUESTION}\n${barrierRef({ runId: RUN_ID, phase: 'Research', label: 'barrier', summary: evidenceSummary }).promptBlock}`, { role: 'adversarial', risk: 'high', capabilities: ['structured-output', 'reasoning'], label: 'completeness-critic', phase: 'Critique', schema: EVIDENCE })
-writeArtifact({ runId: RUN_ID, phase: 'Critique', label: 'barrier', payload: critique, summary: typeof critique === 'string' ? critique.slice(0, 200) : 'critique complete', role: 'adversarial' })
 
 phase('Synthesize')
 const synthesis = await dispatchAgent(agent, 'synthesis-author', `Produce a concise sourced decision brief for: ${QUESTION}. Separate verified facts, repository-specific implications, recommendation, risks, and unresolved gaps. Do not invent consensus or hide evidence gaps.\n${barrierRef({ runId: RUN_ID, phase: 'Research', label: 'barrier', summary: evidenceSummary }).promptBlock}\n${barrierRef({ runId: RUN_ID, phase: 'Critique', label: 'barrier', summary: typeof critique === 'string' ? critique.slice(0, 200) : 'critique complete' }).promptBlock}`, { role: 'architect', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: 'synthesis', phase: 'Synthesize' })
-return { question: QUESTION, evidence, critique, synthesis }
+return { question: QUESTION, evidence, critique, synthesis }

package/config/workflows/ultracode-review.js

@@ -1,6 +1,3 @@
-import { randomUUID } from 'node:crypto'
-import { dispatchAgent, writeArtifact, barrierRef } from './lib/dispatch.js'
-
 export const meta = {
   name: 'ultracode-review',
   description: 'Review a change across independent dimensions and adversarially verify every finding',
@@ -11,11 +8,47 @@ export const meta = {
   ],
 }
 
+const WORKFLOW_INPUT = args && typeof args === 'object' ? args : {}
+const WORKFLOW_ROUTING = WORKFLOW_INPUT.routing && typeof WORKFLOW_INPUT.routing === 'object'
+  ? WORKFLOW_INPUT.routing
+  : {}
+const WORKFLOW_DEFAULT_MODEL = typeof WORKFLOW_INPUT.model === 'string'
+  ? WORKFLOW_INPUT.model.trim()
+  : Array.isArray(WORKFLOW_INPUT.models) && typeof WORKFLOW_INPUT.models[0] === 'string'
+    ? WORKFLOW_INPUT.models[0].trim()
+    : ''
+const routeModel = (risk) => {
+  const candidate = WORKFLOW_ROUTING[risk] || WORKFLOW_ROUTING.default || WORKFLOW_DEFAULT_MODEL
+  return typeof candidate === 'string' ? candidate.trim() : ''
+}
+if (!routeModel('medium') || !routeModel('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.',
+  }
+}
+let WORKFLOW_DISPATCH_SEQUENCE = 0
+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'),
+    effort: opts.risk === 'high' ? 'high' : 'medium',
+  }
+  if (opts.schema) agentOptions.schema = opts.schema
+  if (opts.isolation) agentOptions.isolation = opts.isolation
+  if (opts.disallowedTools) agentOptions.disallowedTools = opts.disallowedTools
+  return agentFn(`${prefix}\n${prompt}`, agentOptions)
+}
+const barrierRef = ({ phase, label, summary, payload }) => {
+  let evidence = ''
+  try { evidence = JSON.stringify(payload ?? '').slice(0, 12000) } catch { evidence = '<unserializable>' }
+  return { promptBlock: `Prior phase: ${phase}; label: ${label}; summary: ${summary || ''}\nBounded evidence: ${evidence}` }
+}
+
 const TARGET = typeof args === 'string' ? args : args?.target || 'the current working diff'
 
-// Phase B (v10.21.0) artifact-on-disk barriers: one runId per workflow
-// invocation. Used by every writeArtifact() + barrierRef() in this script.
-const RUN_ID = randomUUID()
+const RUN_ID = 'ultracode-review'
 const FINDINGS = {
   type: 'object',
   required: ['findings'],

package/config/workflows/ultracode.js

@@ -1,6 +1,3 @@
-import { randomUUID } from 'node:crypto'
-import { dispatchAgent, writeArtifact, barrierRef } from './lib/dispatch.js'
-
 export const meta = {
   name: 'ultracode',
   description: 'Research, design, implement, review, and verify a substantial engineering task with bounded multi-agent orchestration',
@@ -13,11 +10,47 @@ export const meta = {
   ],
 }
 
+const WORKFLOW_INPUT = args && typeof args === 'object' ? args : {}
+const WORKFLOW_ROUTING = WORKFLOW_INPUT.routing && typeof WORKFLOW_INPUT.routing === 'object'
+  ? WORKFLOW_INPUT.routing
+  : {}
+const WORKFLOW_DEFAULT_MODEL = typeof WORKFLOW_INPUT.model === 'string'
+  ? WORKFLOW_INPUT.model.trim()
+  : Array.isArray(WORKFLOW_INPUT.models) && typeof WORKFLOW_INPUT.models[0] === 'string'
+    ? WORKFLOW_INPUT.models[0].trim()
+    : ''
+const routeModel = (risk) => {
+  const candidate = WORKFLOW_ROUTING[risk] || WORKFLOW_ROUTING.default || WORKFLOW_DEFAULT_MODEL
+  return typeof candidate === 'string' ? candidate.trim() : ''
+}
+if (!routeModel('medium') || !routeModel('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.',
+  }
+}
+let WORKFLOW_DISPATCH_SEQUENCE = 0
+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'),
+    effort: opts.risk === 'high' ? 'high' : 'medium',
+  }
+  if (opts.schema) agentOptions.schema = opts.schema
+  if (opts.isolation) agentOptions.isolation = opts.isolation
+  if (opts.disallowedTools) agentOptions.disallowedTools = opts.disallowedTools
+  return agentFn(`${prefix}\n${prompt}`, agentOptions)
+}
+const barrierRef = ({ phase, label, summary, payload }) => {
+  let evidence = ''
+  try { evidence = JSON.stringify(payload ?? '').slice(0, 12000) } catch { evidence = '<unserializable>' }
+  return { promptBlock: `Prior phase: ${phase}; label: ${label}; summary: ${summary || ''}\nBounded evidence: ${evidence}` }
+}
+
 const TASK = typeof args === 'string' ? args : args?.task || JSON.stringify(args || {})
 
-// Phase B (v10.21.0) artifact-on-disk barriers: one runId per workflow
-// invocation. Used by every writeArtifact() + barrierRef() in this script.
-const RUN_ID = randomUUID()
+const RUN_ID = 'ultracode'
 const BRIEF = {
   type: 'object',
   required: ['summary', 'files', 'risks', 'verification'],
@@ -59,7 +92,6 @@ if (research.length === 0) return { status: 'blocked', reason: 'No research agen
 
 // Phase B: persist research artifact for the next barrier agent.
 const researchSummary = `research lanes: ${research.map((r) => (r && r.summary) ? r.summary.slice(0, 80) : '<lane>').join(' | ')}`
-writeArtifact({ runId: RUN_ID, phase: 'Research', label: 'barrier', payload: research, summary: researchSummary, role: 'research-analyst' })
 
 phase('Design')
 const plan = await dispatchAgent(agent, 'plan-author', `Design one reversible implementation for: ${TASK}\n${barrierRef({ runId: RUN_ID, phase: 'Research', label: 'barrier', summary: researchSummary }).promptBlock}\nReturn disjoint edit lanes. Shared root/config/lock files must have one owner. Include bounded tests and stop conditions.`, { role: 'architect', risk: 'medium', capabilities: ['structured-output', 'reasoning', 'architecture'], label: 'plan', phase: 'Design', schema: PLAN })
@@ -67,7 +99,6 @@ if (!plan || !Array.isArray(plan.lanes) || plan.lanes.length === 0) return { sta
 
 // Phase B: persist plan artifact for the next barrier agent.
 const planSummary = `plan lanes: ${plan.lanes.map((l) => l.name).join(', ')}`
-writeArtifact({ runId: RUN_ID, phase: 'Design', label: 'barrier', payload: plan, summary: planSummary, role: 'architect' })
 
 const audit = await dispatchAgent(agent, 'plan-auditor', `Adversarially review this plan for correctness, security, conflicting file ownership, missing regression tests, and unbounded retry loops. Return a corrected plan, not commentary. Task: ${TASK}\n${barrierRef({ runId: RUN_ID, phase: 'Design', label: 'barrier', summary: planSummary }).promptBlock}`, { role: 'adversarial', risk: 'high', capabilities: ['structured-output', 'reasoning', 'architecture', 'security'], label: 'plan-audit', phase: 'Design', schema: PLAN })
 const approved = audit || plan
@@ -79,20 +110,10 @@ const implementation = await parallel(lanes.map((lane, index) => () => dispatchA
 const completed = implementation.filter(Boolean)
 if (completed.length === 0) return { status: 'blocked', reason: 'No implementation lane completed successfully.', plan: approved }
 // Phase B: persist each implementation artifact.
-for (let i = 0; i < completed.length; i++) {
-  const lane = lanes[i];
-  const label = `implement:${i + 1}:${lane.name}`;
-  const summary = `lane ${lane.name} files: ${(completed[i]?.files || []).slice(0, 5).join(', ')}`;
-  writeArtifact({ runId: RUN_ID, phase: 'Implement', label, payload: completed[i], summary, role: 'implementer' });
-}
-
 phase('Verify')
 const reviews = await parallel(completed.map((result, index) => () => dispatchAgent(agent, `reviewer-${index + 1}`, `Try to refute this implementation result for task "${TASK}". Check correctness, security, scope, test evidence, and integration assumptions. Return only verified findings and required checks.\n${barrierRef({ runId: RUN_ID, phase: 'Implement', label: `implement:${index + 1}:${lanes[index]?.name || ''}`, summary: `review of lane ${lanes[index]?.name || index + 1}` }).promptBlock}`, { role: 'adversarial', risk: 'high', capabilities: ['structured-output', 'reasoning'], label: `review:${index + 1}`, phase: 'Verify' })))
 // Phase B: persist review artifacts.
 const verifiedReviews = reviews.filter(Boolean);
-for (let i = 0; i < verifiedReviews.length; i++) {
-  writeArtifact({ runId: RUN_ID, phase: 'Verify', label: `review:${i + 1}`, payload: verifiedReviews[i], summary: typeof verifiedReviews[i] === 'string' ? verifiedReviews[i].slice(0, 200) : `review ${i + 1}`, role: 'adversarial' });
-}
 const final = await dispatchAgent(agent, 'final-verifier', `Synthesize a bounded integration and verification report for task "${TASK}". Do not claim success without fresh command evidence. Identify conflicts between worktrees, exact integration order, remaining gates, and any required human approvals.\n${barrierRef({ runId: RUN_ID, phase: 'Design', label: 'barrier', summary: `approved plan with ${approved.lanes.length} lanes` }).promptBlock}\n${barrierRef({ runId: RUN_ID, phase: 'Implement', label: 'implement:summary', summary: `${completed.length} lanes complete` }).promptBlock}\n${barrierRef({ runId: RUN_ID, phase: 'Verify', label: 'review:summary', summary: `${verifiedReviews.length} reviews complete` }).promptBlock}`, { role: 'implementer', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: 'final-verification', phase: 'Verify' })
 
 return { status: 'ready-for-integration', task: TASK, research, plan: approved, implementation: completed, reviews: reviews.filter(Boolean), final }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar",
-  "version": "10.23.7",
+  "version": "10.23.8",
   "description": "Autonomous, human-in-the-loop multi-agent harness for Claude Code with guarded workflows, typed SDK primitives, and MCP tools.",
   "type": "module",
   "bin": {

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

package/packages/sdk/package.json

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