@polderlabs/bizar 10.23.5 → 10.23.6

package/AGENTS.md

@@ -59,11 +59,13 @@ actions with `permissionDecision: "ask"`; that escalation list is the
 authoritative floor, not a starting point.
 
 Native dynamic workflows under `config/workflows/` and `~/.claude/workflows/`
-are the primary dispatch mechanism for shaped work (research / implement /
-debug / review). Small, deterministic, repository-local tasks go directly to
-one isolated worker: inspect, make the smallest change, and run the smallest
-proving check. Do not add research, planning, review, or duplicate workers to
-such tasks. For work that needs 3+ long-lived workers with bounded cross-talk,
+are the required dispatch mechanism for every primary request except an
+unmistakably tiny single-target copy/style/format edit with no behavior or test
+change. Mike may execute that narrow exception directly. All other work enters
+the matching research / implement / debug / review workflow and uses at least
+one explicitly modeled editing subagent with call-level worktree isolation.
+Do not add unnecessary phases or duplicate workers. For work that needs 3+
+long-lived workers with bounded cross-talk,
 Mike invokes a workflow that fans out as a native agent team; the team is
 host-side state under `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`, and per
 Anthropic's docs `team_name` is deprecated and ignored. When two or more
@@ -132,10 +134,15 @@ guess-and-try remains prohibited.
 The autonomy and approval policy above governs this execution model. The project defaults to `acceptEdits`; eligible operators may opt into Claude Code Auto mode.
 
 Every non-empty primary request enters Bizar through `office-manager` (`@mike`).
-Mike handles small, deterministic repository-local changes directly and uses
-the smallest proving check. It delegates when worktree isolation, specialist
-expertise, or real parallelism materially helps. A Bizar custom agent already
-executing its assigned role does not recursively dispatch itself.
+The installer sets Claude Code's global `agent` setting to Mike's frontmatter
+name (`mike`),
+and a session-scoped routing guard requires a successful native Workflow before
+substantive primary-session mutation. Read-only inspection remains available.
+Mike directly executes only the tiny edit exception above. Every other request
+must invoke a native Bizar workflow before mutation; the workflow dispatches
+worktree-isolated subagents while Mike owns integration and final verification.
+A Bizar custom agent already executing its assigned role does not recursively
+dispatch itself.
 
 Every shipped agent has `WebSearch` access. Before proposing, explaining,
 troubleshooting, or implementing behavior from an external API, library,
@@ -145,8 +152,8 @@ relevant page. Guess-and-try integration work is prohibited. When official
 documentation is unavailable or ambiguous, inspect authoritative source code
 and report the evidence gap.
 
-For shaped requests, `office-manager` uses only the phases that reduce a known
-risk; direct tasks skip this pipeline:
+For workflow-routed requests, `office-manager` uses only the phases that reduce
+a known risk; only the tiny edit exception skips this pipeline:
 
 1. Research: `greg` (`research-analyst.md`) plus an implementation-context specialist.
 2. Plan: `planner` drafts; `qa-reviewer` challenges assumptions and test shape.

package/cli/commands/claude-cmd.mjs

@@ -56,7 +56,7 @@ export async function runClaudeTeam(args = []) {
     console.error(chalk.red(`  ✗ Missing ${router}; run bizar install`));
     return 1;
   }
-  return spawnClaude(['-p', '--name', name, '--agent', 'office-manager', mission, ...rest]);
+  return spawnClaude(['-p', '--name', name, '--agent', 'mike', mission, ...rest]);
 }
 
 export async function runClaudeSubagent(args = []) {
@@ -80,7 +80,9 @@ export async function runClaudeRun(args = []) {
     console.log('  Usage: bizar run [--bg] <prompt>');
     return 2;
   }
-  return spawnClaude(background ? ['--bg', '-p', prompt] : ['-p', prompt]);
+  return spawnClaude(background
+    ? ['--bg', '-p', '--agent', 'mike', prompt]
+    : ['-p', '--agent', 'mike', prompt]);
 }
 
 export async function run(name, args, isHelpRequest) {

package/cli/commands/hook.mjs

@@ -19,6 +19,7 @@ const PRETOOL_SAFETY_LEAVES = new Set([
   'pretooluse-editwrite', 'path-ownership-guard',
   'pretooluse-bash', 'git-workflow-guard',
   'agent-model-guard',
+  'workflow-route-guard',
 ]);
 
 export const HOOK_PROGRAMS = Object.freeze({
@@ -47,6 +48,7 @@ export const HOOK_PROGRAMS = Object.freeze({
   'team-lifecycle': 'team-lifecycle.mjs',
   'verify-deliverables': 'verify-deliverables.mjs',
   'worker-suggest': 'worker-suggest.mjs',
+  'workflow-route-guard': 'workflow-route-guard.mjs',
   'worktree-archive': 'worktree-archive.mjs',
   'worktree-bootstrap': 'worktree-bootstrap.mjs',
 });
@@ -55,6 +57,7 @@ export const EVENT_CHAINS = Object.freeze({
   'user-prompt-submit': Object.freeze([
     'control-inbox',
     'keyword-router',
+    'workflow-route-guard',
     'worker-suggest',
     'thinking-route',
     'telemetry',
@@ -230,16 +233,17 @@ export function selectEventChain(eventKey, input = '') {
 
   if (eventKey === 'pre-tool-use') {
     if (/^(Write|Edit|MultiEdit)$/.test(toolName)) {
-      return ['pretooluse-editwrite', 'path-ownership-guard'];
+      return ['workflow-route-guard', 'pretooluse-editwrite', 'path-ownership-guard'];
     }
     if (toolName === 'Bash') {
-      return ['pretooluse-bash', 'git-workflow-guard'];
+      return ['workflow-route-guard', 'pretooluse-bash', 'git-workflow-guard'];
     }
-    if (toolName === 'Agent') return ['agent-model-guard'];
+    if (toolName === 'Agent') return ['workflow-route-guard', 'agent-model-guard'];
     return [];
   }
 
   if (eventKey === 'post-tool-use') {
+    if (toolName === 'Workflow') return ['workflow-route-guard'];
     if (/^(Write|Edit|MultiEdit)$/.test(toolName)) return ['posttooluse-editwrite'];
     if (toolName === 'Bash') return [];
     return [];

package/cli/commands/validate.mjs

@@ -82,6 +82,8 @@ export const REQUIRED_HOOKS = [
   'thinking-route.mjs',
   'verify-deliverables.mjs',
   'worker-suggest.mjs',
+  'workflow-route-guard.mjs',
+  'workflow-route-state.mjs',
   'worktree-archive.mjs',
   'worktree-bootstrap.mjs',
 ];

package/cli/provision.mjs

@@ -608,6 +608,8 @@ const LEGACY_BIZAR_HOOK_FILES = new Set([
   'thinking-route.mjs',
   'verify-deliverables.mjs',
   'worker-suggest.mjs',
+  'workflow-route-guard.mjs',
+  'workflow-route-state.mjs',
   'worktree-bootstrap.mjs',
 ]);
 
@@ -835,7 +837,7 @@ export function writeClaudeSettings({ dryRun = false, force = false } = {}) {
   const hook = (name, timeout = 15) => resolveHookCommand(name, timeout);
 
   // The shipped settings template (`config/claude/settings.json`) is the
-  // source of truth for defaultMode, worktree, enableWorkflows, etc. We
+  // source of truth for the main agent, worktree, workflows, etc. We
   // overlay Bizar-owned keys (mcpServers, hooks, env) on top so the installer
   // honors user preferences without having to fork the template here.
   // 10.22.0 / Phase 4 spirit-of-constraint fix: `model` and
@@ -848,6 +850,10 @@ export function writeClaudeSettings({ dryRun = false, force = false } = {}) {
   const bizarSettings = {
     ...shipped,
     $schema: shipped.$schema || 'https://json.schemastore.org/claude-code-settings.json',
+    // Bizar must own the primary thread globally. A routing hook can add
+    // context, but only the agent setting applies Mike's system prompt and
+    // tool surface (including Workflow) to ordinary `claude` launches.
+    agent: 'mike',
     mcpServers: {
       bizar: {
         type: 'stdio',
@@ -892,6 +898,8 @@ export function writeClaudeSettings({ dryRun = false, force = false } = {}) {
       cleanupPeriodDays: 7,
     },
     enableWorkflows: shipped.enableWorkflows !== undefined ? shipped.enableWorkflows : true,
+    disableWorkflows: false,
+    workflowSizeGuideline: shipped.workflowSizeGuideline || 'small',
     alwaysThinkingEnabled: shipped.alwaysThinkingEnabled !== undefined ? shipped.alwaysThinkingEnabled : true,
     autoDreamEnabled: shipped.autoDreamEnabled !== undefined ? shipped.autoDreamEnabled : true,
     showThinkingSummaries: shipped.showThinkingSummaries !== undefined ? shipped.showThinkingSummaries : true,
@@ -990,11 +998,15 @@ export function writeClaudeSettings({ dryRun = false, force = false } = {}) {
     merged.autoMode = existing.autoMode || bizarSettings.autoMode;
     merged.attribution = existing.attribution || bizarSettings.attribution;
     merged.worktree = { ...(bizarSettings.worktree || {}), ...(existing.worktree || {}) };
-    for (const key of ['enableWorkflows', 'alwaysThinkingEnabled', 'autoDreamEnabled', 'showThinkingSummaries']) {
+    for (const key of ['enableWorkflows', 'disableWorkflows', 'workflowSizeGuideline', 'alwaysThinkingEnabled', 'autoDreamEnabled', 'showThinkingSummaries']) {
       if (merged[key] === undefined) merged[key] = bizarSettings[key];
     }
   }
 
+  // The installed harness owns the default main-thread role. Operators can
+  // still override it for one session with `claude --agent <name>`.
+  merged.agent = 'mike';
+
   // `model` is Bizar-owned routing policy, so refresh it on both ordinary and
   // forced provision runs. Do not erase an existing operator model if a
   // malformed router has no enabled candidate; dispatch will fail closed.

package/config/claude/CLAUDE.md

@@ -70,11 +70,13 @@ actions with `permissionDecision: "ask"`; that escalation list is the
 authoritative floor, not a starting point.
 
 Native dynamic workflows under `config/workflows/` and `~/.claude/workflows/`
-are the primary dispatch mechanism for shaped work (research / implement /
-debug / review). Small, deterministic, repository-local tasks go directly to
-one isolated worker: inspect, make the smallest change, and run the smallest
-proving check. Do not add research, planning, review, or duplicate workers to
-such tasks. For work that needs 3+ long-lived workers with bounded cross-talk,
+are the required dispatch mechanism for every primary request except an
+unmistakably tiny single-target copy/style/format edit with no behavior or test
+change. Mike may execute that narrow exception directly. All other work enters
+the matching research / implement / debug / review workflow and uses at least
+one explicitly modeled editing subagent with call-level worktree isolation.
+Do not add unnecessary phases or duplicate workers. For work that needs 3+
+long-lived workers with bounded cross-talk,
 Mike invokes a workflow that fans out as a native agent team; the team is
 host-side state under `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`, and per
 Anthropic's docs `team_name` is deprecated and ignored. When two or more
@@ -143,10 +145,15 @@ guess-and-try remains prohibited.
 The autonomy and approval policy above governs this execution model. The project defaults to `acceptEdits`; eligible operators may opt into Claude Code Auto mode.
 
 Every non-empty primary request enters Bizar through `office-manager` (`@mike`).
-Mike handles small, deterministic repository-local changes directly and uses
-the smallest proving check. It delegates when worktree isolation, specialist
-expertise, or real parallelism materially helps. A Bizar custom agent already
-executing its assigned role does not recursively dispatch itself.
+The installer sets Claude Code's global `agent` setting to Mike's frontmatter
+name (`mike`),
+and a session-scoped routing guard requires a successful native Workflow before
+substantive primary-session mutation. Read-only inspection remains available.
+Mike directly executes only the tiny edit exception above. Every other request
+must invoke a native Bizar workflow before mutation; the workflow dispatches
+worktree-isolated subagents while Mike owns integration and final verification.
+A Bizar custom agent already executing its assigned role does not recursively
+dispatch itself.
 
 Every shipped agent has `WebSearch` access. Before proposing, explaining,
 troubleshooting, or implementing behavior from an external API, library,
@@ -156,8 +163,8 @@ relevant page. Guess-and-try integration work is prohibited. When official
 documentation is unavailable or ambiguous, inspect authoritative source code
 and report the evidence gap.
 
-For shaped requests, `office-manager` uses only the phases that reduce a known
-risk; direct tasks skip this pipeline:
+For workflow-routed requests, `office-manager` uses only the phases that reduce
+a known risk; only the tiny edit exception skips this pipeline:
 
 1. Research: `greg` (`research-analyst.md`) plus an implementation-context specialist.
 2. Plan: `planner` drafts; `qa-reviewer` challenges assumptions and test shape.

package/config/claude/agents/_shared/AGENT_BASELINE.md

@@ -24,7 +24,12 @@ Exact authority is required for pushes, PR mutations, releases, publication, dep
 
 ## 5. Agent coordination
 
-Every primary request enters through `@mike`. Mike handles small deterministic local work directly. Delegate only when isolation, expertise, or real parallelism helps; use only risk-reducing phases. A Bizar subagent never recursively dispatches itself.
+Every primary request enters through `@mike`. Mike directly handles only an
+unmistakably tiny single-target copy/style/format edit with no behavior or test
+change. Every other request enters a matching native Bizar workflow, which
+dispatches at least one explicitly modeled worktree-isolated implementation
+subagent. Use only risk-reducing phases and parallelize only genuinely disjoint
+scopes. A Bizar subagent never recursively dispatches itself.
 
 Agent prompts name ownership, deliverable, validation, sibling awareness, and escalation. Editing Agent calls use `isolation: "worktree"`; independent writers run concurrently. The leader consumes terminal results, merges queued branches, and verifies integration.
 

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

@@ -1,7 +1,7 @@
 ---
 name: mike
-description: Mike — adaptive primary orchestrator for direct fixes and coordinated agent work.
-tools: Agent, Read, Write, Edit, Bash, Grep, Glob, WebFetch, WebSearch, Skill
+description: Mike — workflow-first orchestrator with a tiny direct-edit exception.
+tools: Workflow, Agent, Read, Write, Edit, Bash, Grep, Glob, WebFetch, WebSearch, Skill
 skills:
   - i-have-adhd
 ---
@@ -9,22 +9,25 @@ skills:
 # Mike — adaptive primary orchestrator
 
 Follow `_shared/AGENT_BASELINE.md`. You own the user outcome, integration, and
-final verification. Choose the lightest workflow that proves the result.
+final verification. Direct execution is a narrow exception; workflows are the
+default for meaningful work.
 
-## Route once
+## Route, then reassess if scope expands
 
 | Shape | Signals | Execution |
 |---|---|---|
-| Direct | small known local bug, style/spacing/text change, bounded lookup, one or two files | inspect, edit, run the smallest proving check yourself; no plan, research, or subagent ceremony |
-| Isolated | bounded implementation where worktree isolation materially helps | one `@brenda` call with `isolation: "worktree"`, then merge and verify |
-| Parallel | two or more independent writable scopes with no data dependency | one concurrent Agent batch; every writer gets a disjoint scope and `isolation: "worktree"` |
-| Shaped | uncertain root cause, architecture/security, external/version-sensitive behavior, or interacting components | use the matching native research/debug/implement workflow; parallelize independent lanes and serialize only dependencies |
+| Tiny direct | one obvious copy, typo, comment, whitespace, or single style-token edit; one target; no behavior or test change | inspect, make the micro-edit, run the smallest proving check yourself |
+| Bounded workflow | known non-trivial implementation, including a logical bug or any behavioral change | invoke `bizar-implement`; it dispatches at least one editing worker with `isolation: "worktree"`; merge and verify |
+| Debug workflow | failing behavior, unclear cause, regression, or interacting state | invoke `bizar-debug`; keep diagnosis and fix evidence separate |
+| Research/shaped | external/version-sensitive behavior, architecture/security, broad review, or interacting components | invoke `bizar-research` or the matching `ultracode*` workflow; parallelize independent lanes and serialize dependencies |
 
-Do not expand a direct task because tools are available. Do not compress a
-shaped task merely to avoid coordination. Research current official docs only
-for external or 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.
+If a request could reasonably require a regression test, touch multiple files,
+or needs inspection to discover its scope, it is not tiny: invoke a workflow
+before editing. The primary session does not substitute an ad-hoc Agent call
+for the workflow. Research current official docs only for external or
+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.
 
 ## Models
 

package/config/claude/commands/quick.md

@@ -11,16 +11,16 @@ Run `$ARGUMENTS` directly in this session. Do NOT delegate to subagents.
 
 ## Mechanism
 
-The `worker-suggest` hook recognizes `/quick` directly and skips orchestration
-for this command only. Legacy `.bizar/.quick-once` sentinels are consumed and
-deleted on their first prompt, so they cannot disable routing for a session.
+The `worker-suggest` hook recognizes `/quick` directly, but honors the bypass
+only when the argument still qualifies as an unmistakably tiny edit. Legacy
+`.bizar/.quick-once` sentinels are consumed on their first prompt and cannot
+bypass routing for substantive work.
 
 ## What this is for
 
 - One-line file edits
 - Quick lookups ("find X", "show me Y")
-- Mechanical renames
-- Single-tool invocations
+- One-token style adjustments
 
 ## What this is NOT for
 

package/config/claude/hooks/README.md

@@ -11,6 +11,7 @@ All hooks read Claude Code JSON from stdin and emit either no decision, addition
 | `simplify-guard.mjs` | PostToolUse Skill + PreToolUse Bash | require one `/simplify` per commit attempt |
 | `posttooluse-editwrite.mjs` | PostToolUse writes | local telemetry and test reminder |
 | `worker-suggest.mjs` | UserPromptSubmit | ranked skill/agent suggestions |
+| `workflow-route-guard.mjs` | UserPromptSubmit, PreToolUse, PostToolUse | requires a proven successful native workflow before substantive primary mutation; permits narrowly whitelisted, redirect-free Git inspection |
 | `thinking-route.mjs` | UserPromptSubmit | slash and mental-model routing |
 | `telemetry.mjs` | SessionStart/UserPromptSubmit | local correlation and rejection categories |
 | `sessionstart-prime.mjs` | SessionStart | bounded project and handoff context |

package/config/claude/hooks/sessionstart-prime.mjs

@@ -186,13 +186,13 @@ function startupBriefing(cwd, featureBrief, recentCommits, projectLine, progress
     }
   }
   if (progressLast) lines.push(`- Progress: ${progressLast}.`);
-  lines.push('- You are @mike. Direct small known local fixes; use one isolated worker when useful; use parallel worktrees only for independent scopes; shaped work gets only risk-reducing phases.');
+  lines.push('- You are @mike. Only an unmistakably tiny single-target copy/style/format edit is direct; every other change enters the matching native workflow before mutation. Use one isolated writer by default and parallel worktrees only for independent scopes.');
   lines.push('- External/version-sensitive work requires current official docs via WebSearch/WebFetch. Use relevant installed skills; apply i-have-adhd to user output. WIP=1.');
   lines.push('- TaskCompleted/SubagentStop/<task-notification> is terminal: consume <result>, mark done/failed, merge queued work, continue the objective.');
   // Default-first-stop hint when nothing is active yet.
   if (featureBrief && featureBrief.active.length === 0) {
     lines.push(
-      '- First move: read PROGRESS.md and feature_list.json; then choose direct, isolated, parallel, or shaped execution once.',
+      '- First move: read PROGRESS.md and feature_list.json; then choose the matching workflow, except for an unmistakably tiny direct edit.',
     );
   }
   return lines.join('\n');
@@ -203,14 +203,14 @@ function clearBriefing(cwd, recentCommits, progressLast) {
   if (progressLast) lines.push(`- Progress: ${progressLast}.`);
   if (recentCommits.length > 0) lines.push(`- Last commit: ${recentCommits[0]}.`);
   lines.push('- Context preserved in same repo / cwd — only the model turn was reset.');
-  lines.push('- You are @mike: continue with the lightest execution shape that proves the result.');
+  lines.push('- You are @mike: continue through the active workflow; only an unmistakably tiny edit may stay direct.');
   lines.push('- First move: continue from where the model left off; no need to reread project files.');
   return lines.join('\n');
 }
 
 function resumeBriefing(cwd, state) {
   const lines = ['Bizar SessionStart (resume):'];
-  lines.push('- You are @mike: restore state, then use direct work or bounded delegation based on actual complexity.');
+  lines.push('- You are @mike: restore state, then continue the active workflow; only an unmistakably tiny edit may stay direct.');
   if (state) {
     if (state.activeFeature) lines.push(`- Last active feature: ${state.activeFeature}.`);
     if (state.reason) lines.push(`- Last session ended with: ${state.reason}.`);

package/config/claude/hooks/worker-suggest.mjs

@@ -4,9 +4,9 @@
  *
  * Bizar Background Workers — UserPromptSubmit hook.
  *
- * Runs on every user prompt. Small, repository-local requests take a cheap
- * fast path without loading the worker/learning modules. Larger requests get
- * routing and specialized suggestions from cli/worker-dispatcher.mjs.
+ * Runs on every user prompt. Only unmistakably tiny, single-scope edits take
+ * a cheap fast path. Every other request is routed into a native Bizar
+ * workflow that owns subagent dispatch.
  *
  * Uses import.meta.url + dynamic import() to resolve the sibling CLI module so
  * the hook works regardless of install path (fixes ERR_MODULE_NOT_FOUND after
@@ -37,6 +37,7 @@
 import { dirname, join } from 'node:path';
 import { existsSync, unlinkSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
+import { isTinyDirectTask } from './workflow-route-state.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -46,17 +47,22 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
  * normal routing path. Keeping the classifier lexical makes it free on the
  * UserPromptSubmit hot path and easy to explain to the model.
  */
-function isFastLocalTask(prompt) {
-  if (prompt.length > 500 || prompt.split('\n').length > 3) return false;
-  if (!/\b(fix|correct|rename|remove|delete|format|typo|style|padding|margin|color|spacing|align|change|update)\b/i.test(prompt)) return false;
-  return !/\b(api|sdk|library|framework|dependency|version|migration|architecture|security|auth|credential|deploy|publish|release|database|workflow|agent team|hook|performance|benchmark|all files|every file|failing|failure|error|crash|root cause|regression)\b/i.test(prompt);
-}
+const isFastLocalTask = isTinyDirectTask;
 
 const FAST_ROUTE_POLICY = [
-  'Bizar fast path:',
-  '- This is a small, bounded, repository-local request. The primary orchestrator may execute it directly; otherwise dispatch exactly one @brenda worker with call-level `isolation: "worktree"`. Do not research, plan, or review first.',
-  '- Inspect the named/local code, make the smallest reversible change, add or adjust only the directly relevant regression test when behavior changes, and run the smallest proving check. Use current official documentation only if the change touches an external or version-sensitive API.',
-  '- Do not fan out duplicate analysis. Parallelize only independent file scopes; a single-file fix stays single-worker to avoid worktree and merge overhead.',
+  'Bizar tiny direct path:',
+  '- Direct execution is allowed only because this request is an unmistakably tiny, single-scope copy/style/format edit. Inspect the exact target, make one minimal reversible edit, and run the smallest proving check. Do not plan, research, or dispatch a subagent.',
+  '- If inspection reveals behavioral logic, more than one target, ambiguity, a required test change, or any interaction beyond the named micro-edit, stop the direct path and invoke the matching native Bizar workflow before editing further.',
+].join('\n');
+
+const ROUTE_POLICY = [
+  'Workflow-required Bizar routing policy:',
+  '- If this is the primary session, you ARE @mike. Do not implement this request directly in the primary session. Before any edit or mutation, invoke the matching native Bizar workflow; the primary owns routing, integration, and final verification.',
+  '- Use bizar-implement for known bounded changes, bizar-debug for bugs needing diagnosis, bizar-research for external or uncertain implementation context, and ultracode / ultracode-research / ultracode-review for broad, high-risk, or review-heavy objectives. Use only phases that reduce a concrete risk.',
+  '- The workflow must dispatch at least one implementation subagent with an explicit configured model and call-level `isolation: "worktree"`. For genuinely disjoint writable scopes, dispatch them concurrently; otherwise use one isolated writer. Never create duplicate workers merely to satisfy fan-out.',
+  '- Consume terminal agent results, merge queued worktrees with bizar worktree-merge, and run integration checks in the primary session. A subagent may not recursively dispatch itself.',
+  '- Do NOT execute any tool you do not have. If a tool you need is missing from your tools list, dispatch to a subagent that has it — do not pretend you have it.',
+  '- If you are already running as a Bizar custom agent, follow your assigned role and do not recursively dispatch yourself.',
 ].join('\n');
 
 let raw = '';
@@ -72,7 +78,7 @@ process.stdin.on('end', async () => {
 
   const prompt = String(input.prompt ?? input.user_prompt ?? '').trim();
 
-  if (input.task_notification || /<task-notification\b[\s\S]*<result\b/i.test(prompt)) {
+  if (input.task_notification || /^<task-notification\b[\s\S]*<result\b[\s\S]*<\/task-notification>\s*$/i.test(prompt)) {
     process.stdout.write(JSON.stringify({
       hookSpecificOutput: {
         hookEventName: 'UserPromptSubmit',
@@ -83,7 +89,9 @@ process.stdin.on('end', async () => {
   }
 
   if (/^\/quick(?:\s|$)/i.test(prompt)) {
-    process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: '' } }) + '\n');
+    const quickTask = prompt.replace(/^\/quick(?:\s+|$)/i, '').trim();
+    const context = !quickTask || isFastLocalTask(quickTask) ? FAST_ROUTE_POLICY : ROUTE_POLICY;
+    process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: context } }) + '\n');
     return;
   }
 
@@ -93,10 +101,11 @@ process.stdin.on('end', async () => {
   const quickSentinel = join(input.cwd || process.cwd(), '.bizar', '.quick-once');
   if (existsSync(quickSentinel)) {
     try { unlinkSync(quickSentinel); } catch { /* best-effort one-shot cleanup */ }
+    const context = isFastLocalTask(prompt) ? FAST_ROUTE_POLICY : ROUTE_POLICY;
     process.stdout.write(JSON.stringify({
       hookSpecificOutput: {
         hookEventName: 'UserPromptSubmit',
-        additionalContext: '',
+        additionalContext: context,
       },
     }) + '\n');
     process.exit(0);
@@ -130,15 +139,6 @@ process.stdin.on('end', async () => {
     return;
   }
 
-  const routePolicy = [
-    'Adaptive Bizar routing policy:',
-    '- If this is the primary session, you ARE @mike. Execute small deterministic repository work directly, or use the Agent tool for one @brenda worktree worker when isolation helps. Do not add research, planning, review, or a second worker unless the task needs it.',
-    '- For a known, multi-file change, first split only genuinely disjoint edit scopes and dispatch those writers concurrently with call-level `isolation: "worktree"`. A monolithic scope gets one writer, not artificial parallelism.',
-    '- Use research and planning only when external/version-sensitive behavior, an unclear root cause, an architectural decision, or interacting scopes make them decision-reducing. When required, run independent research in parallel with repository inspection.',
-    '- Do NOT execute any tool you do not have. If a tool you need is missing from your tools list, dispatch to a subagent that has it — do not pretend you have it.',
-    '- If you are already running as a Bizar custom agent, follow your assigned role and do not recursively dispatch yourself.',
-  ].join('\n');
-
   let dispatch;
   let recordSuggestion;
   try {
@@ -150,7 +150,7 @@ process.stdin.on('end', async () => {
     process.stdout.write(JSON.stringify({
       hookSpecificOutput: {
         hookEventName: 'UserPromptSubmit',
-        additionalContext: routePolicy,
+        additionalContext: ROUTE_POLICY,
       },
     }) + '\n');
     process.exit(0);
@@ -167,7 +167,7 @@ process.stdin.on('end', async () => {
     process.stdout.write(JSON.stringify({
       hookSpecificOutput: {
         hookEventName: 'UserPromptSubmit',
-        additionalContext: routePolicy,
+        additionalContext: ROUTE_POLICY,
       },
     }) + '\n');
     process.exit(0);
@@ -204,7 +204,7 @@ process.stdin.on('end', async () => {
 
   // Build additionalContext for the model so Bizar routing is mandatory even
   // when no specialized worker pattern matches.
-  let note = routePolicy;
+  let note = ROUTE_POLICY;
   if (suggestions.length > 0) {
     const lines = suggestions.map((s) => {
       const skillPart = s.skill ? `, skill=${s.skill}` : '';

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

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+/** Enforce native-workflow entry before substantive primary-session mutation. */
+'use strict';
+
+import {
+  clearWorkflowRequired,
+  markWorkflowRequired,
+  promptRequiresWorkflow,
+  workflowRequired,
+} from './workflow-route-state.mjs';
+import { parseGitCommands } from './git-command-parser.mjs';
+
+const READ_ONLY_GIT_SUBCOMMANDS = new Set([
+  'diff', 'log', 'ls-files', 'rev-parse', 'show', 'status',
+]);
+const WORKFLOW_SUCCESS = new Set(['completed', 'dry', 'ready-for-integration', 'succeeded', 'success']);
+const WORKFLOW_FAILURE = new Set(['blocked', 'budget-exhausted', 'cancelled', 'canceled', 'error', 'failed', 'failure']);
+
+export function isReadOnlyShellInspection(command) {
+  const source = String(command || '').trim();
+  if (!source || /[\n\r;|<>`]/.test(source) || /\$\(|(?:^|\s)&(?:\s|$)/.test(source)) return false;
+
+  return source.split(/\s*&&\s*/).every((segment) => {
+    const trimmed = segment.trim();
+    if (/^echo(?:\s|$)/.test(trimmed)) return true;
+    if (!/^git(?:\s|$)/.test(trimmed) || /(?:^|\s)--(?:output|ext-diff)(?:=|\s|$)/.test(trimmed)) return false;
+    const parsed = parseGitCommands(trimmed);
+    return parsed.length === 1 && READ_ONLY_GIT_SUBCOMMANDS.has(parsed[0].subcommand);
+  });
+}
+
+export function workflowCompletedSuccessfully(input) {
+  const root = input?.tool_response ?? input?.tool_result ?? input?.toolUseResult;
+  if (!root || typeof root !== 'object') return false;
+  const statuses = [];
+  const visit = (value, depth = 0) => {
+    if (!value || typeof value !== 'object' || depth > 3) return;
+    if (typeof value.status === 'string') statuses.push(value.status.toLowerCase());
+    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));
+}
+
+let raw = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => { raw += chunk; });
+process.stdin.on('end', () => {
+  let input = {};
+  try { input = JSON.parse(raw || '{}'); } catch { input = {}; }
+
+  const event = String(input.hook_event_name || '');
+  const sessionId = String(input.session_id || '');
+  const toolName = String(input.tool_name || '');
+
+  try {
+    if (event === 'UserPromptSubmit') {
+      if (promptRequiresWorkflow(input)) markWorkflowRequired(input);
+      else clearWorkflowRequired(sessionId);
+      process.stdout.write('{}\n');
+      return;
+    }
+
+    if (event === 'PostToolUse' && toolName === 'Workflow') {
+      if (workflowCompletedSuccessfully(input)) clearWorkflowRequired(sessionId);
+      process.stdout.write('{}\n');
+      return;
+    }
+
+    if (event !== 'PreToolUse' || input.agent_id || !workflowRequired(sessionId)) {
+      process.stdout.write('{}\n');
+      return;
+    }
+
+    const readOnlyBash = toolName === 'Bash' && isReadOnlyShellInspection(input.tool_input?.command);
+    if (!readOnlyBash && /^(?:Edit|Write|MultiEdit|Bash|Agent)$/.test(toolName)) {
+      process.stdout.write(`${JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: 'PreToolUse',
+          permissionDecision: 'deny',
+          permissionDecisionReason: `Bizar workflow routing guard: ${toolName} is unavailable in the primary session until the required native Workflow runs successfully. Invoke bizar-implement, bizar-debug, bizar-research, or the matching ultracode workflow first.`,
+        },
+      })}\n`);
+      return;
+    }
+  } catch (error) {
+    process.stderr.write(`[bizar.workflow-route] ${error?.message || String(error)}\n`);
+  }
+
+  process.stdout.write('{}\n');
+});

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

@@ -0,0 +1,71 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const MAX_AGE_MS = 24 * 60 * 60 * 1000;
+
+export function isTinyDirectTask(prompt) {
+  const text = String(prompt || '').trim();
+  if (text.length === 0 || text.length > 240 || text.split('\n').length > 1) return false;
+  if (!/^(?:please\s+)?(?:fix|correct|format|adjust|change|update)\b/i.test(text)) return false;
+  if (/[?]\s*$/.test(text) || /\b(?:do\s+not|don't|never)\b/i.test(text)) return false;
+  if (!/\b(typo|spelling|punctuation|comment|copy|wording|whitespace|formatting|indentation|padding|margin|spacing|color|colour|alignment?)\b/i.test(text)) return false;
+  return !/\b(and|also|then|plus|both|across|multiple|several|throughout|entire|everywhere|sitewide|app-wide|components?|files?|api|sdk|library|framework|dependency|version|migration|architecture|security|auth|credential|deploy|publish|release|database|workflow|agent|hook|performance|benchmark|all files|every file|failing|failure|error|crash|root cause|regression|test|tests|logic|handling|parser|parsing|algorithm|calculation|rendering?|generation|tokenizer|lexer)\b/i.test(text);
+}
+
+function safeSessionId(value) {
+  return String(value || '').replace(/[^A-Za-z0-9_-]/g, '').slice(0, 80);
+}
+
+function stateDir(env = process.env) {
+  const root = env.BIZAR_HOME || join(env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'bizar');
+  return join(root, 'workflow-routing');
+}
+
+export function routeStatePath(sessionId, env = process.env) {
+  const safe = safeSessionId(sessionId);
+  return safe ? join(stateDir(env), `${safe}.json`) : '';
+}
+
+export function markWorkflowRequired(input, env = process.env) {
+  const path = routeStatePath(input?.session_id, env);
+  if (!path) return false;
+  const dir = stateDir(env);
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify({ required: true, createdAt: Date.now(), cwd: String(input?.cwd || '') })}\n`, { mode: 0o600 });
+  renameSync(tmp, path);
+  return true;
+}
+
+export function clearWorkflowRequired(sessionId, env = process.env) {
+  const path = routeStatePath(sessionId, env);
+  if (!path) return false;
+  rmSync(path, { force: true });
+  return true;
+}
+
+export function workflowRequired(sessionId, env = process.env, now = Date.now()) {
+  const path = routeStatePath(sessionId, env);
+  if (!path || !existsSync(path)) return false;
+  try {
+    const state = JSON.parse(readFileSync(path, 'utf8'));
+    if (state?.required !== true || !Number.isFinite(state.createdAt) || now - state.createdAt > MAX_AGE_MS) {
+      rmSync(path, { force: true });
+      return false;
+    }
+    return true;
+  } catch {
+    rmSync(path, { force: true });
+    return false;
+  }
+}
+
+export function promptRequiresWorkflow(input) {
+  const prompt = String(input?.prompt ?? input?.user_prompt ?? '').trim();
+  if (!prompt) return false;
+  if (input?.task_notification || /^<task-notification\b[\s\S]*<result\b[\s\S]*<\/task-notification>\s*$/i.test(prompt)) return false;
+  const quick = prompt.match(/^\/quick(?:\s+([\s\S]*))?$/i);
+  if (quick) return Boolean(quick[1]?.trim()) && !isTinyDirectTask(quick[1]);
+  return !isTinyDirectTask(prompt);
+}

package/config/claude/settings.json

@@ -1,5 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/claude-code-settings.json",
+  "agent": "mike",
   "mcpServers": {
     "bizar": {
       "command": "npx",
@@ -65,6 +66,8 @@
   "askUserQuestionTimeout": "5m",
   "showThinkingSummaries": true,
   "enableWorkflows": true,
+  "disableWorkflows": false,
+  "workflowSizeGuideline": "small",
   "disableAutoCompact": false,
   "autoDreamEnabled": true,
   "env": {

package/config/workflows/bizar-debug.js

@@ -82,7 +82,7 @@ if (!accepted) {
 }
 
 phase('Fix')
-const fix = await dispatchAgent(agent, 'fix-author', `Produce the smallest fix + regression test for bug ${BUG_ID} based on the accepted hypothesis. 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' })
+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')

package/config/workflows/bizar-implement.js

@@ -1,16 +1,11 @@
-import { randomUUID } from 'node:crypto'
-import { dispatchAgent, writeArtifact, barrierRef } from './lib/dispatch.js'
+import { dispatchAgent } from './lib/dispatch.js'
 
 export const meta = {
   name: 'bizar-implement',
-  description: 'Run disjoint implementation lanes concurrently, barrier-merge their results, and synthesize an integration report without sequential pipeline stages',
-  whenToUse: 'Use when the scope is already understood, lanes can be drawn up front, and a single barrier agent can reconcile the work before final synthesis. Parallel-only — no sequential pipeline stages.',
+  description: 'Implement one bounded change in one worktree, or run explicitly supplied disjoint lanes concurrently',
+  whenToUse: 'Use when implementation scope is understood and external research or root-cause discovery is unnecessary.',
   phases: [
-    { title: 'Scope', detail: 'Extract disjoint lanes from the supplied scope' },
-    { title: 'Implement', detail: 'Run lanes concurrently in worktrees' },
-    { title: 'Barrier', detail: 'A single agent reconciles all lane outputs' },
-    { title: 'Verify', detail: 'A single agent re-checks the barrier plan against the scope' },
-    { title: 'Synthesis', detail: 'A single integration agent produces the final report' },
+    { title: 'Implement', detail: 'Run one isolated writer, or explicit disjoint writers concurrently' },
   ],
 }
 
@@ -20,79 +15,33 @@ const TOPIC = typeof args === 'string'
     ? args.topic
     : JSON.stringify(args || {})
 const SCOPE = (args && Array.isArray(args.scope)) ? args.scope : []
-
-// 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 LANES = {
-  type: 'object',
-  required: ['lanes'],
-  properties: {
-    lanes: {
-      type: 'array',
-      items: {
-        type: 'object',
-        required: ['name', 'scope', 'task'],
-        properties: {
-          name: { type: 'string' },
-          scope: { type: 'array', items: { type: 'string' } },
-          task: { type: 'string' },
-        },
-      },
-    },
-  },
-}
-
-phase('Scope')
-const scoped = await dispatchAgent(agent, 'scope-extractor', `Extract 2-6 disjoint edit lanes for: ${TOPIC}\nProvided scope: ${SCOPE.length ? SCOPE.join(', ') : '(none supplied)'}\nEach lane owns a non-overlapping file scope. Shared root/config/lock files must have one owner. Return lanes with name/scope/task.`, { role: 'implementer', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: 'scope-extract', phase: 'Scope', schema: LANES })
-if (!scoped || !Array.isArray(scoped.lanes) || scoped.lanes.length === 0) {
-  return { status: 'blocked', reason: 'Scope agent produced no lanes.' }
-}
-// Phase B: persist the scope artifact for the next barrier agent.
-const scopeSummary = `scope lanes: ${scoped.lanes.map((l) => l.name).join(', ')}`
-writeArtifact({ runId: RUN_ID, phase: 'Scope', label: 'barrier', payload: scoped, summary: scopeSummary, role: 'implementer' })
-const lanes = scoped.lanes.slice(0, 6)
-if (scoped.lanes.length > lanes.length) {
-  log(`Bounded implementation to 6 of ${scoped.lanes.length} lanes.`)
-}
+const suppliedLanes = (args && Array.isArray(args.lanes)) ? args.lanes : []
+const lanes = (suppliedLanes.length > 0
+  ? suppliedLanes
+  : [{ name: 'bounded-change', scope: SCOPE, task: TOPIC }]
+).slice(0, 6)
 
 phase('Implement')
-const implementations = (await parallel(
-  lanes.map((lane, index) => () => dispatchAgent(
-    agent,
-    `lane-implementer-${index + 1}`,
-    `Implement this owned lane for the topic "${TOPIC}".\n${barrierRef({ runId: RUN_ID, phase: 'Scope', label: 'barrier', summary: `lane ${lane.name}: ${lane.task.slice(0, 120)}` }).promptBlock}\nDo not edit outside the listed scope. Do not revert sibling work. Add regression tests and run the smallest relevant checks. Return changed files, commands, exact results, and blockers. Do not commit, push, publish, or deploy.`,
-    { role: 'implementer', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: `implement:${index + 1}:${lane.name}`, phase: 'Implement', isolation: 'worktree' },
-  )),
-)).filter(Boolean)
-if (implementations.length === 0) {
-  return { status: 'blocked', reason: 'No implementation lane completed successfully.', scope: scoped }
-}
-// Phase B: persist each implementation artifact.
-for (let i = 0; i < implementations.length; i++) {
-  const lane = lanes[i];
-  const label = `implement:${i + 1}:${lane.name}`;
-  const summary = `lane ${lane.name} files: ${(implementations[i]?.files || []).slice(0, 5).join(', ')}`;
-  writeArtifact({ runId: RUN_ID, phase: 'Implement', label, payload: implementations[i], summary, role: 'implementer' });
+const runLane = (lane, index) => dispatchAgent(
+  agent,
+  `lane-implementer-${index + 1}`,
+  `Implement this owned lane for the topic "${TOPIC}".\nLane: ${lane.name || `lane-${index + 1}`}\nTask: ${lane.task || TOPIC}\nWritable scope: ${Array.isArray(lane.scope) && lane.scope.length ? lane.scope.join(', ') : 'discover the smallest necessary scope, then keep it bounded'}\nDo not edit outside the lane's necessary scope. Do not revert sibling work. Add a regression test when behavior changes and run the smallest proving checks. Return changed files, commands, exact results, and blockers. Do not commit, push, publish, or deploy.`,
+  { role: 'implementer', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: `implement:${index + 1}:${lane.name || 'bounded-change'}`, phase: 'Implement', isolation: 'worktree' },
+)
+
+const implementations = lanes.length === 1
+  ? [await runLane(lanes[0], 0)]
+  : await parallel(lanes.map((lane, index) => () => runLane(lane, index)))
+const completed = implementations.filter(Boolean)
+
+if (completed.length === 0) {
+  return { status: 'blocked', reason: 'No implementation lane completed successfully.', lanes }
 }
 
-phase('Barrier')
-const merge = await dispatchAgent(agent, 'barrier-merger', `Reconcile the lane outputs for topic "${TOPIC}" into one MERGE plan. Identify conflicts between worktrees, exact integration order, shared-file ownership, and any human approvals required.\n${barrierRef({ runId: RUN_ID, phase: 'Implement', label: 'implement:summary', summary: `${implementations.length} lanes complete across ${lanes.length} planned` }).promptBlock}`, { role: 'implementer', risk: 'high', capabilities: ['structured-output', 'reasoning', 'architecture'], label: 'barrier-merge', phase: 'Barrier' })
-writeArtifact({ runId: RUN_ID, phase: 'Barrier', label: 'barrier', payload: merge, summary: typeof merge === 'string' ? merge.slice(0, 200) : `barrier merge complete`, role: 'implementer' })
-
-phase('Verify')
-const verify = await dispatchAgent(agent, 'barrier-verifier', `Re-check this MERGE plan against the original scope for topic "${TOPIC}". Reject it if any lane output is missing, any conflict is unresolved, or any test gate is unbounded. Return the verified plan plus the exact gating tests.\n${barrierRef({ runId: RUN_ID, phase: 'Barrier', label: 'barrier', summary: `verify against scope: ${SCOPE.length} scope items` }).promptBlock}`, { role: 'adversarial', risk: 'high', capabilities: ['structured-output', 'reasoning'], label: 'barrier-verify', phase: 'Verify' })
-
-phase('Synthesis')
-const synthesis = await dispatchAgent(agent, 'integration-reporter', `Produce the final integration report for topic "${TOPIC}". State exact integration order, remaining gates, evidence commands to run, and any required human approvals. Do not claim success without fresh command evidence.\n${barrierRef({ runId: RUN_ID, phase: 'Barrier', label: 'barrier', summary: `merge plan: ${typeof merge === 'string' ? merge.slice(0, 120) : 'complex'}` }).promptBlock}\n${barrierRef({ runId: RUN_ID, phase: 'Verify', label: 'barrier-verify', summary: typeof verify === 'string' ? verify.slice(0, 120) : 'verified' }).promptBlock}`, { role: 'implementer', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: 'integration-report', phase: 'Synthesis' })
-
 return {
   status: 'ready-for-integration',
   topic: TOPIC,
   lanes,
-  implementations,
-  barrier: merge,
-  verify,
-  synthesis,
+  implementations: completed,
+  next: 'Merge queued worktrees and run integration verification in the primary session.',
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar",
-  "version": "10.23.5",
+  "version": "10.23.6",
   "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.5";
+export declare const SDK_VERSION: "10.23.6";
 //# 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.5";
+export const SDK_VERSION = "10.23.6";
 //# sourceMappingURL=version.js.map

package/packages/sdk/package.json

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