@polderlabs/bizar 10.29.1 → 10.30.0

package/AGENTS.md

@@ -1,8 +1,8 @@
 # AGENTS.md — Bizar Harness
 
-Bizar Harness is a Claude Code-native, guarded-autonomy harness. It ships project and user-level agents, skills, slash commands, hooks, an MCP server, CLI utilities, and verification scripts. OpenKan is bundled as Bizar’s default durable planning, progression, task, and PRD-goal system; Bizar integrates with it only through the `.ok/` workspace and its supported CLI boundary.
+Bizar Harness is an Agent Orchestrator (AO)-first, guarded-autonomy worker harness for Codex and Claude Code. AO owns multi-agent coordination, isolated worktrees, sessions, branches, PRs, review feedback, previews, and browser state; Bizar supplies repository policy, skills, hooks, CLI utilities, and verification. OpenKan remains a standalone planning, progression, task, and PRD-goal option through `.ok/` and its supported CLI boundary.
 
-If you are an agent: read this file, inspect `.ok/` with `ok task list` and `ok prd list`, then run `make check` before changing code.
+If `AO_SESSION_ID` or `AO_PROJECT_ID` is present, this is an AO worker session: inspect AO session context, run `make check` before changing code, and do not start a second team/worktree/task lifecycle. Otherwise, inspect `.ok/` with `ok task list` and `ok prd list`, then run `make check` before changing code.
 
 ## Commands
 
@@ -24,8 +24,9 @@ make session-end              # lifecycle compatibility target
 
 ## Hard constraints
 
-- **MUST** keep the scoped OpenKan task current in `.ok/`: claim before implementation, update status/evidence at each durable handoff, and complete only with verification evidence.
-- **MUST** use OpenKan PRDs and plans for durable goals and progression; `PROGRESS.md` and `feature_list.json` are legacy historical records, not live control state.
+- **MUST** treat AO as the durable task, session, worktree, branch, PR, CI/review, preview, and browser authority when `AO_SESSION_ID` or `AO_PROJECT_ID` is present. Do not update `.ok/` from an AO worker unless the assigned task explicitly requires it and AO has serialized that shared-state operation.
+- **MUST** keep the scoped OpenKan task current in standalone Bizar mode: claim before implementation, update status/evidence at each durable handoff, and complete only with verification evidence.
+- **MUST** use OpenKan PRDs and plans for standalone Bizar durable goals and progression; `PROGRESS.md` and `feature_list.json` are legacy historical records, not live control state.
 - **MUST** keep one logical operation per commit and keep its docs in the same commit.
 - **MUST** run targeted tests, then `make check`; run `make e2e` for cross-component changes.
 - **MUST** verify evidence before claiming completion.
@@ -50,6 +51,8 @@ force a resolution you do not understand.
 
 ## Autonomy and parallelism
 
+When running under AO, the AO orchestrator is the only multi-agent coordinator. A Bizar worker works only in its assigned AO worktree, uses `ao send` for real blockers or cross-session coordination, and asks AO to create further workers when parallel work is necessary. It must not invoke Bizar/Claude/Codex teams, create a separate worktree, manipulate AO internals, or treat `.ok/` as a second source of assignment state.
+
 Agents execute clear, local, reversible work autonomously — they inspect,
 edit, test, and iterate without pausing for routine decisions. Routine
 decisions (file layout, naming, scope of a single commit, choosing between
@@ -169,24 +172,23 @@ isolation.
 
 ## Architecture
 
-- `.claude/agents/` — Claude Code subagent definitions.
-- `config/skills/` — canonical skills; `.claude/skills/` is the verified project mirror.
-- `.claude/commands/` — user-invoked workflows.
-- `.claude/hooks/` + `.claude/settings.json` — safety, routing, lifecycle, telemetry, compaction, reviewer-context, simplify, and HITL gates.
+- `config/ao/` — versioned Agent Orchestrator worker-rule template; `bizar ao setup` materializes it at `.ao/bizar-worker-rules.md` in each registered repository.
+- `config/claude/` — standalone Claude Code agents, skills, commands, hooks, and settings.
 - `packages/sdk/` — typed autonomy primitives and the 14-tool stdio MCP surface: plans, loops, graph queries, learning reads, tasks, workflows, control, audits, and model inventory.
-- `cli/` — install/provision, audit, validation, backup, cost/claim/task, OpenKan control, sandbox, and repair utilities.
+- `cli/` — AO bridge, install/provision, audit, validation, backup, OpenKan control, sandbox, and repair utilities.
 - `scripts/` + `.harness/` + `templates/` — verification, feature/eval state, audit output, and reusable contracts.
 
 The harness has no embedded browser/server UI layer or local web editor.
-`bizar control` is a machine-readable subprocess boundary over the default OpenKan
-workspace; OpenKan owns durable task/plan/PRD state, HTTP, WebSocket, and presentation concerns. Session
-handoff, control inbox, and learning logs are bounded operational records for
-autonomy; they are not a general note vault, semantic search service, or
-knowledge-base API.
+In AO mode, AO's documented daemon CLI is the machine-readable control boundary
+for session, worktree, PR, review, preview, and browser state. `bizar control`
+and OpenKan remain standalone compatibility surfaces. Session handoff, control
+inbox, and learning logs are bounded operational records for autonomy; they are
+not a general note vault, semantic search service, or knowledge-base API.
 
 ## State and evidence
 
-- `.ok/` — authoritative OpenKan tasks, plans, PRDs, progression, evidence, and scoped ownership.
+- AO project/session/PR state — authoritative whenever this is an AO worker session.
+- `.ok/` — authoritative OpenKan tasks, plans, PRDs, progression, evidence, and scoped ownership in standalone Bizar mode.
 - `PROGRESS.md` and `feature_list.json` — legacy historical records; do not use them for new work.
 - `DECISIONS.md` and `docs/decisions/` — current architecture decisions.
 - `.harness/evals/` — feature evaluation records.

package/README.md

@@ -1,18 +1,18 @@
 <div align="center">
 
-<img src="docs/assets/bizar-banner.svg" alt="Bizar: guarded autonomy for Claude Code" width="100%" />
+<img src="docs/assets/bizar-banner.svg" alt="Bizar: guarded autonomy for Agent Orchestrator" width="100%" />
 
 [![npm](https://img.shields.io/npm/v/%40polderlabs%2Fbizar?color=0f766e&label=npm)](https://www.npmjs.com/package/@polderlabs/bizar)
 [![license](https://img.shields.io/badge/license-MIT-0f172a)](LICENSE)
-[![Claude Code](https://img.shields.io/badge/works%20with-Claude%20Code-d97757)](https://docs.anthropic.com/en/docs/claude-code)
+[![Agent Orchestrator](https://img.shields.io/badge/works%20with-Agent%20Orchestrator-2563eb)](https://github.com/Untrivial-ai/agent-orchestrator)
 [![release](https://img.shields.io/github/v/release/PolderLabsVOF/BizarHarness?color=2563eb&label=release)](https://github.com/PolderLabsVOF/BizarHarness/releases)
 ![OmniRoute routing](https://img.shields.io/badge/routing-OmniRoute-0ea5e9)
-[![Planning](https://img.shields.io/badge/planning-OpenKan-f59e0b)](https://www.npmjs.com/package/@polderlabs/openkan)
+[![Standalone planning](https://img.shields.io/badge/standalone%20planning-OpenKan-f59e0b)](https://www.npmjs.com/package/@polderlabs/openkan)
 
-### Guarded autonomy for Claude Code
+### Guarded autonomy for Agent Orchestrator workers
 
-Choose your models once. Give Claude Code real work. Bizar supplies the routing,
-specialists, guardrails, and evidence to carry it through responsibly.
+Run focused Codex workers under Agent Orchestrator. Bizar supplies their
+repository policy, guardrails, skills, and verification evidence.
 
 `85 agents` · `85 skills` · `37 commands` · `21-tool MCP server`
 
@@ -22,22 +22,20 @@ specialists, guardrails, and evidence to carry it through responsibly.
 
 ## Why Bizar?
 
-Claude Code is already powerful. Bizar makes longer, cross-cutting work easier
-to trust and easier to follow. It starts with a small read-only orientation,
-forms an agent team by default for substantive work, and asks a clarification
-only when a material decision remains unresolved. `/quick` deliberately
-selects direct primary-session work; workflows and single agents are explicit
-or resumed modes.
+Agent Orchestrator is built to coordinate parallel coding sessions. Bizar makes
+each worker's implementation and verification discipline explicit. AO owns
+multi-agent coordination, worktrees, branches, PR/review/CI feedback, previews,
+and browser state; Bizar does not duplicate those surfaces.
 
 It keeps the operator in control of model selection and high-impact actions.
-Your configured model choices live in your global Claude configuration—not in
-the project you happen to be working on.
+AO model choices live in the registered project's AO configuration. Standalone
+Claude aliases live in the global Claude configuration.
 
 | You want | Bizar provides |
 | --- | --- |
-| A clean way to begin | A guided installer and a static four-alias dispatch surface |
-| Your own gateway models | Four native aliases (`haiku`/`sonnet`/`opus`/`fable`) with OmniRoute handling ordered failover between configured full IDs |
-| Useful parallel work | Isolated worktrees, scoped tasks, and specialist roles |
+| A clean way to begin | `bizar ao setup` configures the current repository through AO's supported CLI |
+| Codex workers | Versioned AO worker rules plus Bizar's repository guards and checks |
+| Useful parallel work | AO-owned isolated worktrees, sessions, branches, PRs, CI/review feedback, preview, and browser tools |
 | Fewer surprises | Explicit safety checks for releases, publication, deployment, pushes, and destructive operations |
 | Confidence at the end | Tests, architecture checks, E2E checks, and evidence-aware handoff |
 
@@ -45,101 +43,65 @@ the project you happen to be working on.
 
 <table>
   <tr>
-    <td width="50%"><strong>Claude Code</strong><br />Bizar adds its integration to your user-level Claude Code configuration. Install Claude Code with Anthropic's installer first.</td>
-    <td width="50%"><strong>Node.js 22+</strong><br />OpenKan requires Node.js 22 or newer. Bizar and OpenKan install from npm.</td>
+    <td width="50%"><strong>Agent Orchestrator</strong><br />Install AO from its official desktop/GitHub distribution and start its local daemon.</td>
+    <td width="50%"><strong>Codex</strong><br />AO launches Codex workers and delivers Bizar's project rules through its supported configuration.</td>
   </tr>
   <tr>
-    <td width="50%"><strong>OmniRoute</strong><br />Configure a gateway endpoint, API key, and model ID. OmniRoute resolves the full model IDs behind Bizar's four aliases and handles ordered failover.</td>
-    <td width="50%"><strong>Git</strong><br />Needed for isolated worktrees and normal project history. Bizar does not require a persistent daemon.</td>
+    <td width="50%"><strong>OpenKan (optional)</strong><br />Use it only for standalone Bizar planning; AO is the primary lifecycle authority.</td>
+    <td width="50%"><strong>Git</strong><br />AO creates the isolated worktrees and preserves normal project history.</td>
   </tr>
 </table>
 
 ```mermaid
 flowchart LR
-    CC[Claude Code] --> B[Bizar]
-    B --> OR[OmniRoute gateway]
-    OR --> M[Configured model IDs]
-    B --> OK[OpenKan]
-    OK --> S[.ok workspace]
-```
-
-Configure OmniRoute once before installing Bizar. The command writes provider
-settings to Claude Code and preserves existing hooks, permissions, and MCP
-servers.
-
-```sh
-bizar setup-provider --gateway https://your-gateway.example/v1 --key "$YOUR_API_KEY" --model your/model-id
+    AO[Agent Orchestrator] --> C[Codex workers]
+    AO --> W[Isolated worktrees, sessions, PRs, review, browser]
+    C --> B[Bizar worker harness]
+    B --> V[Repository checks and evidence]
+    OK[OpenKan standalone] --> S[.ok workspace]
 ```
 
 ## Install Bizar
 
-Install Bizar globally and its Claude Code integration. Bizar dispatches
-through four static aliases: `haiku`, `sonnet`, `opus`, and `fable`. OmniRoute
-maps each alias to configured full model IDs and applies ordered failover.
+Install Bizar, then configure the repository with a running AO daemon.
 
 ```sh
 npm install -g @polderlabs/bizar
-bizar install
+bizar ao doctor
+bizar ao setup
 ```
 
-Restart Claude Code after installation. The installer adds Bizar's agents,
-skills, commands, hooks, settings, and the default OpenKan planning runtime to
-your user-level Claude configuration. It preserves your configured gateway
-endpoint and credentials during a clean reinstall.
-
-On a new interactive install, Bizar also asks whether Claude Code agent teams
-should be enabled, the OpenKan install directory, and whether the current
-project should receive a `.ok/` workspace. OpenKan is installed from npm as
-`@polderlabs/openkan@latest`; its package-owned agent and skill are
-installed into the same Claude configuration. Use `bizar install --yes` for
-CI or a prompt-free refresh.
-
-For a completely fresh Bizar-managed Claude setup while retaining endpoint and
-authentication settings:
-
-```sh
-bizar install --force
-```
-
-Then open any repository in Claude Code and describe the outcome you want.
-Mike, the Bizar coordinator, handles the rest.
-
-> **Tip:** Run `bizar doctor` whenever you want to verify that the global
-> install, Claude settings, hooks, skills, agents, and provider connection are
-> healthy.
+`bizar ao setup` preserves AO's existing project configuration while selecting
+Codex for both AO roles and materializing Bizar's managed repository-local
+worker rules at `.ao/bizar-worker-rules.md`.
+AO remains responsible for spawning workers, messaging, PR claims, review/CI
+follow-up, previews, and browser verification. See
+[the AO integration guide](docs/agent-orchestrator.md).
 
-## The first-task experience
+## AO worker lifecycle
 
 ```mermaid
 flowchart LR
-    U["Describe the outcome"] --> M["Mike: brief orientation"]
-    M --> Q{"Material choice?"}
-    Q -- Yes --> C["One concise question"]
-    C --> R["Choose a coordination mode"]
-    Q -- No --> R
-    R --> D["Direct edit"]
-    R --> A["Isolated specialist"]
-    R --> P["Parallel agents / team"]
-    R --> W["Visible workflow"]
-    D --> V["Verify and report evidence"]
-    A --> V
-    P --> V
-    W --> V
+    U["Describe the outcome"] --> AO["AO: inspect state"]
+    AO --> W["Spawn focused Codex worker"]
+    W --> B["Bizar: implement and verify"]
+    B --> V["Report evidence to AO"]
+    V --> AO
 ```
 
-The coordinator does not force every request through a workflow. Small,
-obvious edits stay small; larger requests get only the structure they need.
-Writing agents work in Git worktrees, while read-only research stays light and
-foregrounded.
+AO decides whether work needs one focused worker or several. Bizar workers do
+not fan out a second team: they implement, test, and report evidence in their
+assigned AO worktree.
 
-## OmniRoute model aliases
+## Standalone Claude Code model aliases
 
-Bizar dispatches through four static native aliases: `haiku`, `sonnet`,
-`opus`, `fable`. Claude Code's native per-call `model` field accepts one of
-these aliases. OmniRoute handles ordered failover between the configured full
-gateway IDs for the chosen alias, so the operator never picks a picker-style
-gateway ID per agent at this layer. There is no `bizar models` picker, no
-`model-router.json`, no `userSelected` block, and no Agent-model-guard hook.
+Bizar's four static native aliases (`haiku`, `sonnet`, `opus`, `fable`) remain
+available for standalone Claude Code operation. AO workers use AO's configured
+Codex model override instead. OmniRoute handles ordered failover between the
+configured full gateway IDs for standalone alias dispatch, so the operator never
+picks a picker-style gateway ID per agent at that layer. There is no `bizar
+models` picker, no `model-router.json`, no `userSelected` block, and no
+Agent-model-guard hook.
 
 The four aliases are the entire dispatch surface:
 
@@ -169,12 +131,12 @@ Useful inspection commands:
 bizar doctor
 ```
 
-## OpenKan owns durable work state
+## OpenKan standalone mode
 
-OpenKan is Bizar's default planning and progression system. Bizar orchestrates
-the work; OpenKan stores project-local tasks, plans, PRDs, goals, and evidence
-under `.ok/`. Bizar talks to OpenKan through the supported `ok` CLI boundary,
-so OpenKan can evolve independently.
+OpenKan remains available when Bizar is used without AO. In AO mode, AO owns
+the project/session/PR lifecycle and `.ok/` is opt-in only. In standalone mode,
+OpenKan stores project-local tasks, plans, PRDs, goals, and evidence under
+`.ok/` through its supported `ok` CLI boundary.
 
 ```mermaid
 flowchart LR

package/cli/bin.mjs

@@ -81,7 +81,7 @@ if (
 // ── Banner ─────────────────────────────────────────────────────────────────────
 
 function showBanner() {
-  console.log(chalk.bold.cyan('  Bizar — guarded autonomous workflows for Claude Code'));
+  console.log(chalk.bold.cyan('  Bizar — guarded autonomous workflows for Agent Orchestrator and Claude Code'));
   console.log();
 }
 
@@ -115,6 +115,7 @@ function showHelp() {
     setup-provider         Configure the global provider used by Bizar and Claude Code
     advisor                Configure Claude Code's advisor tool
     orchestrator           Manage multi-select modelPicker entries for Claude Code
+    ao <subcommand>        Configure or forward to Agent Orchestrator (AO-primary)
     statusline             Customized Claude Code status bar (render/install/remove/show/preview)
     release-provenance     Generate SBOM + provenance + minisig for a release (audit #83)
     verify-release         Verify a release artifact set against the pinned allowlist
@@ -334,6 +335,18 @@ async function main() {
       break;
     }
 
+    case 'ao': {
+      const mod = await importCommand('ao');
+      if (!mod) {
+        console.error(chalk.red(`  ✗ Could not load Agent Orchestrator command module`));
+        process.exit(EXIT_ERROR);
+        return;
+      }
+      dbg('loaded command module:', 'ao');
+      await mod.run(cmdArgs);
+      break;
+    }
+
     case 'statusline': {
       const mod = await importCommand('statusline');
       if (!mod) {

package/cli/commands/ao.mjs

@@ -0,0 +1,212 @@
+/**
+ * Agent Orchestrator integration.
+ *
+ * AO owns daemon, worktree, session, PR, review, and browser state. This
+ * command configures Bizar as a Codex worker harness through AO's supported
+ * CLI rather than accessing AO's local database or runtime internals.
+ */
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { basename, dirname, resolve } from 'node:path';
+
+export const AO_RULES_FILE = '.ao/bizar-worker-rules.md';
+export const AO_ORCHESTRATOR_RULES = 'Use AO for coordination and Bizar as the Codex worker harness. Spawn focused AO workers for implementation; workers own changes, verification, commits, and PR follow-up.';
+const WORKER_RULES_TEMPLATE = resolve(dirname(fileURLToPath(import.meta.url)), '../../config/ao/worker-rules.md');
+
+function optionValue(args, flag) {
+  const index = args.indexOf(flag);
+  return index >= 0 && typeof args[index + 1] === 'string' ? args[index + 1] : undefined;
+}
+
+export function parseAoArgs(args = []) {
+  const [first, ...rest] = args;
+  const subcommand = ['setup', 'doctor', 'status', 'sessions', 'help'].includes(first) ? first : 'forward';
+  return {
+    subcommand,
+    forward: subcommand === 'forward' ? args : rest,
+    project: optionValue(args, '--project'),
+    model: optionValue(args, '--model'),
+    permissions: optionValue(args, '--permissions'),
+    help: args.includes('--help') || args.includes('-h') || first === 'help',
+  };
+}
+
+export function isAoSession(env = process.env) {
+  return Boolean(env.AO_SESSION_ID || env.AO_PROJECT_ID);
+}
+
+export function defaultProjectId(cwd) {
+  const id = basename(resolve(cwd)).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+  return id || 'bizar-project';
+}
+
+export function configuredProjectConfig(current = {}, options = {}) {
+  const worker = { ...(current.worker || {}), agent: 'codex' };
+  const orchestrator = { ...(current.orchestrator || {}), agent: 'codex' };
+  const agentConfig = { ...(current.agentConfig || {}) };
+  if (options.model) agentConfig.model = options.model;
+  if (options.permissions) agentConfig.permissions = options.permissions;
+  return {
+    ...current,
+    agentRulesFile: options.rulesFile || AO_RULES_FILE,
+    orchestratorRules: current.orchestratorRules || AO_ORCHESTRATOR_RULES,
+    worker,
+    orchestrator,
+    ...(Object.keys(agentConfig).length ? { agentConfig } : {}),
+  };
+}
+
+/**
+ * AO resolves agentRulesFile from the registered repository root. Install the
+ * packaged Bizar rules there once, without replacing project-owned changes.
+ */
+export function materializeWorkerRules(cwd, options = {}) {
+  const filesystem = options.filesystem || { existsSync, mkdirSync, readFileSync, writeFileSync };
+  const target = resolve(cwd, AO_RULES_FILE);
+  if (filesystem.existsSync(target)) return target;
+
+  const source = options.rulesTemplate || WORKER_RULES_TEMPLATE;
+  const contents = filesystem.readFileSync(source, 'utf8');
+  filesystem.mkdirSync(dirname(target), { recursive: true });
+  try {
+    filesystem.writeFileSync(target, contents, { encoding: 'utf8', mode: 0o644, flag: 'wx' });
+  } catch (error) {
+    if (error?.code !== 'EEXIST') throw error;
+  }
+  return target;
+}
+
+function runAo(args, options = {}) {
+  const execute = options.execute || ((command, commandArgs, spawnOptions) => spawnSync(command, commandArgs, spawnOptions));
+  const result = execute(options.binary || 'ao', args, {
+    cwd: options.cwd || process.cwd(),
+    encoding: 'utf8',
+    shell: false,
+  });
+  if (result.error) throw result.error;
+  return {
+    ok: result.status === 0,
+    status: result.status ?? 1,
+    stdout: result.stdout || '',
+    stderr: result.stderr || '',
+  };
+}
+
+function emit(result, output = process) {
+  if (result.stdout) output.stdout.write(result.stdout);
+  if (result.stderr) output.stderr.write(result.stderr);
+}
+
+function parseJson(text, context) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(`Agent Orchestrator returned invalid JSON for ${context}`);
+  }
+}
+
+export function findProjectByPath(projects, cwd) {
+  const expected = resolve(cwd);
+  return projects.find((project) => project?.path && resolve(project.path) === expected) || null;
+}
+
+function help(output = process.stdout) {
+  output.write(`
+bizar ao — Agent Orchestrator bridge (AO-primary)
+
+Usage:
+  bizar ao doctor
+  bizar ao setup [--project <id>] [--model <id>] [--permissions <mode>]
+  bizar ao status
+  bizar ao sessions
+  bizar ao <any supported ao command> [args...]
+
+AO remains the sole owner of sessions, worktrees, PRs, review feedback,
+previews, and browser state. The setup command registers this repository with AO,
+selects Codex for both AO roles, and preserves existing AO project settings.
+It creates and configures the repository-local ${AO_RULES_FILE} as AO worker
+rules, preserving a file that is already present.
+
+OpenKan remains available independently through bizar openkan and ok.
+`);
+}
+
+export function setupAo(options = {}) {
+  const cwd = resolve(options.cwd || process.cwd());
+  const list = runAo(['project', 'ls', '--json'], options);
+  if (!list.ok) return list;
+  const listed = parseJson(list.stdout, 'project list').projects || [];
+  let projectDetails = null;
+  let projectId = options.project;
+
+  if (projectId) {
+    const details = runAo(['project', 'get', projectId, '--json'], options);
+    if (!details.ok) return details;
+    projectDetails = parseJson(details.stdout, 'project get').project || {};
+  } else {
+    for (const project of listed) {
+      if (!project?.id) continue;
+      const details = runAo(['project', 'get', project.id, '--json'], options);
+      if (!details.ok) return details;
+      const candidate = parseJson(details.stdout, 'project get').project || {};
+      if (findProjectByPath([candidate], cwd)) {
+        projectId = candidate.id;
+        projectDetails = candidate;
+        break;
+      }
+    }
+  }
+  projectId ||= defaultProjectId(cwd);
+
+  if (!projectDetails) {
+    const added = runAo(['project', 'add', '--path', cwd, '--id', projectId, '--worker-agent', 'codex', '--orchestrator-agent', 'codex'], options);
+    if (!added.ok) return added;
+    const details = runAo(['project', 'get', projectId, '--json'], options);
+    if (!details.ok) return details;
+    projectDetails = parseJson(details.stdout, 'project get').project || {};
+  }
+  materializeWorkerRules(cwd, options);
+  const config = configuredProjectConfig(projectDetails.config, options);
+  const configured = runAo(['project', 'set-config', projectId, '--config-json', JSON.stringify(config), '--json'], options);
+  if (configured.ok) {
+    configured.stdout = `${configured.stdout}Bizar is configured as the AO Codex worker harness for ${projectId}.\n`;
+  }
+  return configured;
+}
+
+export function doctorAo(options = {}) {
+  const status = runAo(['status', '--json'], options);
+  if (!status.ok) return status;
+  const agents = runAo(['agent', 'ls', '--json'], options);
+  if (!agents.ok) return agents;
+  return {
+    ok: true,
+    status: 0,
+    stdout: `${status.stdout}${agents.stdout}Agent Orchestrator is reachable; verify that the Codex row is installed and authenticated before spawning workers.\n`,
+    stderr: `${status.stderr}${agents.stderr}`,
+  };
+}
+
+export function run(args = [], options = {}) {
+  const parsed = parseAoArgs(args);
+  const output = options.output || process;
+  if (parsed.help) {
+    help(output.stdout);
+    return true;
+  }
+  try {
+    let result;
+    if (parsed.subcommand === 'setup') result = setupAo({ ...options, ...parsed });
+    else if (parsed.subcommand === 'doctor') result = doctorAo(options);
+    else if (parsed.subcommand === 'status') result = runAo(['status', '--json'], options);
+    else if (parsed.subcommand === 'sessions') result = runAo(['session', 'ls', ...parsed.forward], options);
+    else result = runAo(parsed.forward, options);
+    emit(result, output);
+    if (!result.ok) process.exitCode = result.status || 1;
+  } catch (error) {
+    output.stderr.write(`bizar ao: ${error.message || String(error)}\n`);
+    process.exitCode = 1;
+  }
+  return true;
+}

package/cli/install/index.mjs

@@ -5,8 +5,11 @@
  * that delegates to the provisioner.
  */
 
+import chalk from 'chalk';
+
 import { runProvision, forceCleanInstall, clearSavedEnv } from '../provision.mjs';
 import { runDoctor } from '../doctor.mjs';
+import { runStatuslineInstall } from '../commands/statusline.mjs';
 import { showBanner, sectionHeading } from './banner.mjs';
 import { printInstallLocations } from './paths.mjs';
 import { runInteractiveSetup } from './interactive-setup.mjs';
@@ -32,9 +35,19 @@ import { runInteractiveSetup } from './interactive-setup.mjs';
  * @param {boolean} [opts.quiet]   - Only print the location card
  * @param {string}  [opts.mode]    - 'install' | 'update'
  * @param {boolean} [opts.yes]     - assume yes for any non-destructive prompts
+ * @param {Function} [opts.statuslineInstall] - injectable statusline installer for tests
+ * @param {Function} [opts.provision] - injectable provisioner for tests
  */
 export async function runInstaller(opts = {}) {
-  const { dryRun = false, force = false, quiet = false, mode = 'install', yes = false } = opts;
+  const {
+    dryRun = false,
+    force = false,
+    quiet = false,
+    mode = 'install',
+    yes = false,
+    statuslineInstall = runStatuslineInstall,
+    provision = runProvision,
+  } = opts;
 
   if (quiet) {
     printInstallLocations({ dryRun, force });
@@ -78,7 +91,7 @@ export async function runInstaller(opts = {}) {
   // Always pass `force: true` downstream so `runProvision` re-emits the
   // template-owned keys (permissions.allow wildcards, mcpServers, hooks)
   // into the freshly-empty settings file.
-  const provisionResult = await runProvision({
+  const provisionResult = await provision({
     mode,
     dryRun,
     force: true,
@@ -87,6 +100,22 @@ export async function runInstaller(opts = {}) {
     initializeOpenKanProject: interactive?.initializeOpenKanProject === true,
   });
 
+  // Auto-install statusline (v10.29.2+). Skipped on dry-run, non-fatal on failure.
+  // Idempotent: re-running is safe — updateStatuslineSettings re-writes the same field.
+  if (!dryRun) {
+    try {
+      const statuslineResult = await statuslineInstall([]);
+      if (statuslineResult?.ok) {
+        provisionResult.statuslineInstalled = true;
+      } else {
+        console.log(chalk.yellow(`  ! statusline auto-install failed: ${statuslineResult?.error || 'unknown'}`));
+      }
+    } catch (err) {
+      // Non-fatal: the user can still run `bizar statusline install` manually.
+      console.log(chalk.yellow(`  ! statusline auto-install skipped: ${err?.message || err}`));
+    }
+  }
+
   // F-183 — post-install health check. Surfaced as a warning rather
   // than a hard failure so a forced install that completes without
   // error still reports its doctor summary; the operator decides

package/config/ao/worker-rules.md

@@ -0,0 +1,22 @@
+# Bizar worker rules for Agent Orchestrator
+
+This repository is running inside an Agent Orchestrator (AO) worker session.
+AO is the sole owner of worker sessions, worktrees, branches, session messages,
+pull-request lifecycle, CI/review feedback, previews, and browser state.
+
+- Work only on the assigned AO task in this session and its assigned worktree.
+- Do not create a Bizar, Claude Code, Codex, tmux, or ad-hoc subagent team.
+  If parallel work is needed, report it through AO so the AO orchestrator can
+  create focused worker sessions.
+- Do not create or manage a second worktree, task database, session ledger, or
+  PR coordinator. Use `ao send` only for a real blocker or required
+  cross-session coordination.
+- Treat OpenKan as an explicit standalone option. Do not claim, update, or
+  complete `.ok/` tasks from an AO worker unless the task explicitly requires
+  it and the AO orchestrator has serialized that shared-state operation.
+- Use Bizar's repository guidance, hooks, skills, targeted tests, `make check`,
+  and applicable verification gates to implement and prove the assigned work.
+- Keep commits focused. Push, publish, deploy, release, or mutate a PR only
+  when the assigned task or an explicit user instruction authorizes it.
+- Report changed files, verification evidence, and remaining risks to AO when
+  the task is complete.

package/config/claude/CLAUDE.md

@@ -11,9 +11,9 @@
 ---
 
 
-Bizar Harness is a Claude Code-native, guarded-autonomy harness. It ships project and user-level agents, skills, slash commands, hooks, an MCP server, CLI utilities, and verification scripts. OpenKan is bundled as Bizar’s default durable planning, progression, task, and PRD-goal system; Bizar integrates with it only through the `.ok/` workspace and its supported CLI boundary.
+Bizar Harness is an Agent Orchestrator (AO)-first, guarded-autonomy worker harness for Codex and Claude Code. AO owns multi-agent coordination, isolated worktrees, sessions, branches, PRs, review feedback, previews, and browser state; Bizar supplies repository policy, skills, hooks, CLI utilities, and verification. OpenKan remains a standalone planning, progression, task, and PRD-goal option through `.ok/` and its supported CLI boundary.
 
-If you are an agent: read this file, inspect `.ok/` with `ok task list` and `ok prd list`, then run `make check` before changing code.
+If `AO_SESSION_ID` or `AO_PROJECT_ID` is present, this is an AO worker session: inspect AO session context, run `make check` before changing code, and do not start a second team/worktree/task lifecycle. Otherwise, inspect `.ok/` with `ok task list` and `ok prd list`, then run `make check` before changing code.
 
 ## Commands
 
@@ -35,8 +35,9 @@ make session-end              # lifecycle compatibility target
 
 ## Hard constraints
 
-- **MUST** keep the scoped OpenKan task current in `.ok/`: claim before implementation, update status/evidence at each durable handoff, and complete only with verification evidence.
-- **MUST** use OpenKan PRDs and plans for durable goals and progression; `PROGRESS.md` and `feature_list.json` are legacy historical records, not live control state.
+- **MUST** treat AO as the durable task, session, worktree, branch, PR, CI/review, preview, and browser authority when `AO_SESSION_ID` or `AO_PROJECT_ID` is present. Do not update `.ok/` from an AO worker unless the assigned task explicitly requires it and AO has serialized that shared-state operation.
+- **MUST** keep the scoped OpenKan task current in standalone Bizar mode: claim before implementation, update status/evidence at each durable handoff, and complete only with verification evidence.
+- **MUST** use OpenKan PRDs and plans for standalone Bizar durable goals and progression; `PROGRESS.md` and `feature_list.json` are legacy historical records, not live control state.
 - **MUST** keep one logical operation per commit and keep its docs in the same commit.
 - **MUST** run targeted tests, then `make check`; run `make e2e` for cross-component changes.
 - **MUST** verify evidence before claiming completion.
@@ -61,6 +62,8 @@ force a resolution you do not understand.
 
 ## Autonomy and parallelism
 
+When running under AO, the AO orchestrator is the only multi-agent coordinator. A Bizar worker works only in its assigned AO worktree, uses `ao send` for real blockers or cross-session coordination, and asks AO to create further workers when parallel work is necessary. It must not invoke Bizar/Claude/Codex teams, create a separate worktree, manipulate AO internals, or treat `.ok/` as a second source of assignment state.
+
 Agents execute clear, local, reversible work autonomously — they inspect,
 edit, test, and iterate without pausing for routine decisions. Routine
 decisions (file layout, naming, scope of a single commit, choosing between
@@ -180,24 +183,23 @@ isolation.
 
 ## Architecture
 
-- `.claude/agents/` — Claude Code subagent definitions.
-- `config/skills/` — canonical skills; `.claude/skills/` is the verified project mirror.
-- `.claude/commands/` — user-invoked workflows.
-- `.claude/hooks/` + `.claude/settings.json` — safety, routing, lifecycle, telemetry, compaction, reviewer-context, simplify, and HITL gates.
+- `config/ao/` — versioned Agent Orchestrator worker-rule template; `bizar ao setup` materializes it at `.ao/bizar-worker-rules.md` in each registered repository.
+- `config/claude/` — standalone Claude Code agents, skills, commands, hooks, and settings.
 - `packages/sdk/` — typed autonomy primitives and the 14-tool stdio MCP surface: plans, loops, graph queries, learning reads, tasks, workflows, control, audits, and model inventory.
-- `cli/` — install/provision, audit, validation, backup, cost/claim/task, OpenKan control, sandbox, and repair utilities.
+- `cli/` — AO bridge, install/provision, audit, validation, backup, OpenKan control, sandbox, and repair utilities.
 - `scripts/` + `.harness/` + `templates/` — verification, feature/eval state, audit output, and reusable contracts.
 
 The harness has no embedded browser/server UI layer or local web editor.
-`bizar control` is a machine-readable subprocess boundary over the default OpenKan
-workspace; OpenKan owns durable task/plan/PRD state, HTTP, WebSocket, and presentation concerns. Session
-handoff, control inbox, and learning logs are bounded operational records for
-autonomy; they are not a general note vault, semantic search service, or
-knowledge-base API.
+In AO mode, AO's documented daemon CLI is the machine-readable control boundary
+for session, worktree, PR, review, preview, and browser state. `bizar control`
+and OpenKan remain standalone compatibility surfaces. Session handoff, control
+inbox, and learning logs are bounded operational records for autonomy; they are
+not a general note vault, semantic search service, or knowledge-base API.
 
 ## State and evidence
 
-- `.ok/` — authoritative OpenKan tasks, plans, PRDs, progression, evidence, and scoped ownership.
+- AO project/session/PR state — authoritative whenever this is an AO worker session.
+- `.ok/` — authoritative OpenKan tasks, plans, PRDs, progression, evidence, and scoped ownership in standalone Bizar mode.
 - `PROGRESS.md` and `feature_list.json` — legacy historical records; do not use them for new work.
 - `DECISIONS.md` and `docs/decisions/` — current architecture decisions.
 - `.harness/evals/` — feature evaluation records.

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

@@ -12,6 +12,16 @@ Follow `_shared/AGENT_BASELINE.md`. You own the user outcome, integration, and
 final verification. Direct execution is a narrow exception; native Agent teams
 are the default for meaningful work.
 
+## Agent Orchestrator boundary
+
+If `AO_SESSION_ID` or `AO_PROJECT_ID` is set, you are an AO worker, not Bizar's
+general orchestrator. AO owns worktrees, session lifecycle, PRs, review/CI
+feedback, and cross-worker coordination. Complete only the assigned task in the
+current AO worktree; do not invoke a Bizar/Claude/Codex team, native workflow,
+or a second worktree. Use `ao send` only for a real blocker or to request that
+the AO orchestrator create another focused worker. OpenKan is opt-in in this
+mode and must not be mutated without an explicit, serialized AO task.
+
 ## Orient, decide, then coordinate
 
 | Shape | Signals | Execution |

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@polderlabs/bizar",
-  "version": "10.29.1",
-  "description": "Autonomous, human-in-the-loop multi-agent harness for Claude Code with guarded workflows, typed SDK primitives, and MCP tools.",
+  "version": "10.30.0",
+  "description": "Agent Orchestrator-first worker harness for Codex and Claude Code with guarded workflows, typed SDK primitives, and MCP tools.",
   "type": "module",
   "bin": {
     "bizar": "cli/bin.mjs"
@@ -46,6 +46,8 @@
   },
   "keywords": [
     "claude-code",
+    "codex",
+    "agent-orchestrator",
     "claude-agent-sdk",
     "ai-agent",
     "multi-agent",

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

package/packages/sdk/package.json

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