@polderlabs/bizar 10.12.2 → 10.13.0

package/.claude/commands/quick.md

@@ -0,0 +1,35 @@
+---
+description: Skip Bizar\'s mandatory routing for this turn. Use for trivial single-step work the chat can handle directly.
+argument-hint: "[task]"
+disable-model-invocation: true
+allowed-tools: Read, Bash, Edit, Write, Grep, Glob
+---
+
+# /quick — One-Turn Routing Bypass
+
+Run `$ARGUMENTS` directly in this session. Do NOT delegate to subagents.
+
+## Mechanism
+
+This command creates a sentinel file `.bizar/.quick-once` in the current
+working directory. The `worker-suggest` UserPromptSubmit hook checks for
+this sentinel and short-circuits the orchestrator routing prompt for the
+NEXT turn only. The sentinel is removed automatically by the
+`session-end` lifecycle hook (or manually by the next non-quick user
+prompt).
+
+## What this is for
+
+- One-line file edits
+- Quick lookups ("find X", "show me Y")
+- Mechanical renames
+- Single-tool invocations
+
+## What this is NOT for
+
+- Multi-step implementations
+- Anything that requires verification across multiple files
+- Any task that should be tracked in `feature_list.json`
+
+If the task balloons, abort, delete the sentinel, and re-run the request
+without `/quick` so the orchestrator can dispatch properly.

package/.claude/hooks/sessionend-recall.mjs

@@ -28,7 +28,7 @@
 
 'use strict';
 
-import { readFileSync, existsSync, mkdirSync, writeFileSync, appendFileSync } from 'node:fs';
+import { readFileSync, existsSync, mkdirSync, writeFileSync, appendFileSync, unlinkSync } from 'node:fs';
 import { join } from 'node:path';
 import os from 'node:os';
 
@@ -370,6 +370,14 @@ process.stdin.on('end', () => {
   const notePath = writeSessionNote(cwd, sessionId, reason, summary);
   const stateOk = writeSessionState(cwd, sessionId, reason, summary, nextStep);
 
+  // Clear /quick sentinel so the next session is back to orchestrator routing.
+  try {
+    const quickSentinel = join(cwd, '.bizar', '.quick-once');
+    if (existsSync(quickSentinel)) {
+      try { unlinkSync(quickSentinel); } catch { /* best-effort */ }
+    }
+  } catch { /* best-effort */ }
+
   // Silent success — the artifact is the file system.
   process.stdout.write(
     JSON.stringify({

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

@@ -36,6 +36,7 @@
 'use strict';
 
 import { dirname, join } from 'node:path';
+import { existsSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -53,6 +54,21 @@ process.stdin.on('end', async () => {
 
   const prompt = String(input.prompt ?? input.user_prompt ?? '').trim();
 
+  // /quick sentinel bypass: when .bizar/.quick-once exists, skip the
+  // orchestrator routing policy for this single turn. The sentinel is
+  // created by the /quick slash command and removed by session-end.
+  const quickSentinel = join(input.cwd || process.cwd(), '.bizar', '.quick-once');
+  if (existsSync(quickSentinel)) {
+    process.stdout.write(JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'UserPromptSubmit',
+        additionalContext: '',
+      },
+    }) + '\n');
+    process.exit(0);
+    return;
+  }
+
   // Empty prompts get the silent treatment — the user has not yet
   // committed any intent.
   if (prompt.length === 0) {
@@ -68,9 +84,8 @@ process.stdin.on('end', async () => {
 
   const routePolicy = [
     'Mandatory Bizar routing policy:',
-    '- If this is the primary session, use the Agent tool to delegate the request to custom Bizar agent @mike before doing task analysis or implementation.',
+    '- If this is the primary session, you ARE @mike. Inline-play the orchestrator role: decompose the request, route to specialists via the Agent tool inside this session when a specialist would materially improve the answer, and synthesize the verified result. Otherwise execute directly. Keep the phased research/plan/implement/review discipline as guidance, not as a forced dispatch gate.',
     '- @mike must route trivial work to @brenda and non-trivial work through the configured research, plan, implementation, review, and verification agents.',
-    '- Do not implement directly in the primary session.',
     '- If you are already running as a Bizar custom agent, follow your assigned role and do not recursively dispatch yourself.',
   ].join('\n');
 

package/.claude/model-router.json

@@ -1,11 +1,11 @@
 {
   "$schema": "https://bizar.dev/schema/model-router.v2.json",
   "version": "11.0.0",
-  "endpoint": "http://localhost:20128/v1",
+  "endpoint": "http://localhost:20129/v1",
   "comment": "Bizar assigns one exact gateway model to each shipped agent. Role selection and complexity/model selection are separate decisions; every run snapshots its assignments before dispatch.",
   "gateway": {
     "required": true,
-    "endpoint": "http://localhost:20128/v1",
+    "endpoint": "http://localhost:20129/v1",
     "availabilityProbe": "/models",
     "exactModelRequired": true,
     "unavailableBehavior": "fail",

package/.claude/settings.json

@@ -37,6 +37,11 @@
       "mcp__bizar__graph_path",
       "mcp__bizar__list_instincts",
       "mcp__bizar__list_decisions",
+      "mcp__bizar__bizar_task",
+      "mcp__bizar__bizar_workflow",
+      "mcp__bizar__bizar_control",
+      "mcp__bizar__bizar_audit",
+      "mcp__bizar__bizar_model_list",
       "mcp__semble__*",
       "mcp__agent-browser__*"
     ],

package/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "bizar-harness",
   "displayName": "Bizar Harness",
-  "version": "10.12.2",
+  "version": "10.13.0",
   "description": "Guarded multi-agent workflows for Claude Code with a single orchestrator, durable workflow state, and explicit human approval boundaries.",
   "author": {
     "name": "Polderlabs"

package/cli/audit.mjs

@@ -11,11 +11,18 @@ function frontmatter(text) {
 }
 
 export async function runAudit() {
-  console.log(chalk.bold.cyan('\n  BIZARHARNESS AGENT AUDIT\n'));
+  // F-146 — machine-readable JSON branch for `bizar_audit` MCP tool.
+  // Must short-circuit BEFORE any human-formatted console output so the
+  // tool result is pure JSON.
+  const jsonMode = process.argv.includes('--json');
+
+  const emit = (line) => { if (!jsonMode) console.log(line); };
+  if (!jsonMode) emit(chalk.bold.cyan('\n  BIZARHARNESS AGENT AUDIT\n'));
   const agentsDir = join(CONFIG_DIR, 'agents');
   if (!existsSync(agentsDir)) {
     const result = { issues: [{ path: agentsDir, severity: 'HIGH', msg: 'agents directory missing' }], warnings: [], score: 0 };
-    console.log(chalk.red(`  ✗ No agents directory found at ${agentsDir}`));
+    emit(chalk.red(`  ✗ No agents directory found at ${agentsDir}`));
+    if (jsonMode) process.stdout.write(JSON.stringify(result));
     return result;
   }
 
@@ -43,9 +50,11 @@ export async function runAudit() {
     }
   }
 
-  for (const item of issues) console.log(chalk.red(`  ✗ ${item.severity} ${item.path}: ${item.msg}`));
-  for (const item of warnings) console.log(chalk.yellow(`  ⚠ ${item.path}: ${item.msg}`));
+  for (const item of issues) emit(chalk.red(`  ✗ ${item.severity} ${item.path}: ${item.msg}`));
+  for (const item of warnings) emit(chalk.yellow(`  ⚠ ${item.path}: ${item.msg}`));
   const score = Math.max(0, 100 - issues.length * 15 - warnings.length * 3);
-  console.log(`\n  Security score: ${score}/100 (${files.length} agents)\n`);
-  return { issues, warnings, score, totalIssues: issues.length, totalWarnings: warnings.length };
-}
+  emit(`\n  Security score: ${score}/100 (${files.length} agents)\n`);
+  const result = { issues, warnings, score, totalIssues: issues.length, totalWarnings: warnings.length };
+  if (jsonMode) process.stdout.write(JSON.stringify(result));
+  return result;
+}

package/cli/bin.mjs

@@ -117,8 +117,10 @@ function showHelp() {
     claim <subcommand>     GitHub-style claim protocol over feature_list.json
     task <subcommand>      Durable dependency/worktree/path task coordination
     control <subcommand>   Machine-readable agents/tasks/sessions/messages API
+    picker-proxy <start>   Run the 9router picker proxy (default port 20129)
     workflow <subcommand>  Session-bound autopilot workflow state
     hook <name>            Run a portable Claude Code hook
+    worktree-merge <branch>  Merge a feature branch with archive tag (no work lost)
 
   Examples:
     bizar install
@@ -459,6 +461,16 @@ async function main() {
       break;
     }
 
+    case 'picker-proxy': {
+      await import('./commands/picker-proxy.mjs');
+      return;
+    }
+
+    case 'worktree-merge': {
+      await import('./commands/worktree-merge.mjs');
+      return;
+    }
+
     default: {
       console.error(chalk.red(`  ✗ Unknown command: ${cmd}`));
       showHelp();

package/cli/commands/9router-picker-proxy.mjs

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+// 9router picker proxy — rewrites upstream model IDs to `claude-...` so
+// Claude Code's /model picker surfaces them while preserving Anthropic defaults.
+//
+// ponytail: UPSTREAM host/port are constant because the picker proxy only ever
+// fronts the local 9router gateway. If multi-gateway routing is ever needed,
+// convert these to env-driven and re-test. BIZAR_PICKER_PROXY_TEST_* env vars
+// exist only for the test harness.
+
+import { createServer, request as httpRequest } from "node:http";
+
+const UPSTREAM_HOST = process.env.BIZAR_PICKER_PROXY_TEST_UPSTREAM_HOST || "127.0.0.1";
+const UPSTREAM_PORT = Number(process.env.BIZAR_PICKER_PROXY_TEST_UPSTREAM_PORT || 20128);
+const LISTEN_HOST = process.env.BIZAR_PICKER_PROXY_TEST_LISTEN_HOST || "127.0.0.1";
+const LISTEN_PORT = Number(process.env.BIZAR_PICKER_PROXY_TEST_LISTEN_PORT || process.env.BIZAR_PICKER_PROXY_PORT || 20129);
+
+export function rewriteIds(parsed) {
+  if (Array.isArray(parsed?.data)) {
+    for (const m of parsed.data) {
+      if (typeof m.id !== "string") continue;
+      if (!m.id.startsWith("claude") && !m.id.startsWith("anthropic")) {
+        m.id = `claude-${m.id}`;
+      }
+    }
+  }
+  return parsed;
+}
+
+function proxyUpstream(req, res) {
+  const upstream = httpRequest({
+    host: UPSTREAM_HOST,
+    port: UPSTREAM_PORT,
+    path: req.url,
+    method: req.method,
+    headers: { ...req.headers, host: `${UPSTREAM_HOST}:${UPSTREAM_PORT}` },
+  });
+  upstream.on("error", (e) => {
+    res.writeHead(502, { "content-type": "text/plain" });
+    res.end(`upstream error: ${e.message}`);
+  });
+  upstream.on("response", (upRes) => {
+    res.writeHead(upRes.statusCode || 502, upRes.headers);
+    upRes.pipe(res);
+  });
+  req.pipe(upstream);
+}
+
+function handleModels(req, res) {
+  const upstream = httpRequest({
+    host: UPSTREAM_HOST,
+    port: UPSTREAM_PORT,
+    path: "/v1/models?limit=1000",
+    method: "GET",
+    headers: { accept: "application/json" },
+  });
+  upstream.on("error", (e) => {
+    res.writeHead(502, { "content-type": "text/plain" });
+    res.end(`upstream error: ${e.message}`);
+  });
+  upstream.on("response", (upRes) => {
+    let body = "";
+    upRes.setEncoding("utf8");
+    upRes.on("data", (c) => (body += c));
+    upRes.on("end", () => {
+      let parsed;
+      try {
+        parsed = JSON.parse(body);
+      } catch {
+        res.writeHead(502, { "content-type": "text/plain" });
+        res.end("upstream not JSON");
+        return;
+      }
+      rewriteIds(parsed);
+      const out = JSON.stringify(parsed);
+      res.writeHead(200, {
+        "content-type": "application/json",
+        "content-length": Buffer.byteLength(out),
+      });
+      res.end(out);
+    });
+  });
+  upstream.end();
+}
+
+export function createProxyServer() {
+  return createServer((req, res) => {
+    if (req.method === "GET" && req.url?.startsWith("/v1/models")) {
+      handleModels(req, res);
+      return;
+    }
+    proxyUpstream(req, res);
+  });
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const server = createProxyServer();
+  server.listen(LISTEN_PORT, LISTEN_HOST, () => {
+    process.stdout.write(`[picker-proxy] listening on http://${LISTEN_HOST}:${LISTEN_PORT} -> ${UPSTREAM_HOST}:${UPSTREAM_PORT}\n`);
+  });
+}

package/cli/commands/picker-proxy.mjs

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+// `bizar picker-proxy start` — spawn the 9router picker proxy in the foreground.
+
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+const sub = process.argv[2];
+if (sub === "start") {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const child = spawn(process.execPath, [join(here, "9router-picker-proxy.mjs")], { stdio: "inherit" });
+  child.on("exit", (code) => process.exit(code ?? 1));
+  process.on("SIGINT", () => child.kill("SIGINT"));
+  process.on("SIGTERM", () => child.kill("SIGTERM"));
+} else {
+  console.error("usage: bizar picker-proxy start");
+  process.exit(2);
+}

package/cli/commands/worktree-merge.mjs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+// `bizar worktree-merge <branch>` — merge a feature branch into the current
+// branch with guaranteed artifact preservation. Tags the source branch tip
+// as `merge-archive/<branch>-<sha>` before merge, so parallel pipeline work
+// is never lost on conflict resolution. `git merge --no-ff` keeps the merge
+// topology visible in `git log --graph`.
+
+import { spawnSync } from "node:child_process";
+
+const branch = process.argv[2];
+if (!branch) {
+  console.error("usage: bizar worktree-merge <branch>");
+  process.exit(2);
+}
+
+const tip = spawnSync("git", ["rev-parse", branch], { encoding: "utf8" });
+if (tip.status !== 0) {
+  console.error(tip.stderr || tip.stdout);
+  process.exit(1);
+}
+const sha = tip.stdout.trim();
+const safe = branch.replace(/[^a-zA-Z0-9._-]/g, "-");
+const tag = `merge-archive/${safe}-${sha.slice(0, 7)}`;
+const tagged = spawnSync("git", ["tag", tag, sha], { encoding: "utf8", stdio: "inherit" });
+if (tagged.status !== 0) process.exit(tagged.status ?? 1);
+
+const m = spawnSync(
+  "git",
+  ["merge", "--no-ff", branch, "-m", `merge: ${branch} into current branch`],
+  { encoding: "utf8", stdio: "inherit" },
+);
+process.exit(m.status ?? 1);

package/config/skills/i-have-adhd/SKILL.md

@@ -0,0 +1,142 @@
+---
+name: i-have-adhd
+description: 'Shape output for a reader with ADHD: lead with the next action, number multi-step work, restate state across turns, suppress tangents, give specific time estimates, make wins visible. Invoke with /i-have-adhd; stays on until "stop adhd mode".'
+license: MIT
+metadata:
+  hermes:
+    tags: [ADHD, Output Style, Productivity, Formatting]
+    category: productivity
+    related_skills: []
+---
+
+# i-have-adhd
+# disable-model-invocation deliberately omitted: keep this skill always-on. See PROGRESS.md F-146.
+
+The reader has ADHD. Output is not just brief. It is shaped so an ADHD brain can act on it.
+
+## Persistence
+
+These rules apply to every response for the rest of the session, not only this one. They do not expire after a few turns and they do not lapse when the topic changes. If you are unsure whether they still apply, they do.
+
+Turn them off only when the reader says "stop adhd mode" or "normal mode". Confirm in one line, then return to your default style.
+
+## What ADHD changes about reading
+
+Five facts drive every rule below:
+
+1. Working memory is small. Anything not on screen is forgotten. Do not ask the reader to "keep in mind X."
+2. Knowing the answer is not doing the answer. The friction between "got it" and "done it" is where work dies.
+3. Starting is the hardest step. The first action must be obvious, small, and doable now.
+4. Time estimates feel uniform. "A bit of work" and "a few hours" register the same. Vague estimates fail.
+5. Dopamine is scarce. Visible progress matters. Buried wins do not register.
+
+## Rules
+
+### 1. Lead with the next action
+
+The first line is something the reader can do. Not context. Not a plan. The action.
+
+Bad: "Let's think about this. Your auth flow has a few moving pieces..."
+Good: "Run `npm install jsonwebtoken`, then edit `src/auth.ts:42`."
+
+If the answer is a command, path, or snippet, it goes first. Prose comes after, if at all.
+
+### 2. Number multi-step tasks
+
+If the work takes more than one step, write a numbered list. Each step is one bounded action. No step contains "and then" twice.
+
+Use the fewest steps that still work. Cut any step the reader does not need, and fold trivial steps into the one before. A short path finished beats a complete path abandoned.
+
+Bad: "First open the file, find the function, swap it out, then run the tests."
+
+Good:
+```
+1. Open `src/auth.ts`
+2. Replace `verifyToken` (lines 42 to 58) with the snippet below
+3. Run `npm test -- auth.spec.ts`
+```
+
+### 3. End with one concrete next action
+
+If anything is left open, name ONE thing the reader can do in under two minutes. Even "open the file" counts.
+
+Bad: "Hope that helps. Let me know if you want to dig deeper."
+Good: "Next: run `npm test` and paste the first failing line."
+
+### 4. Suppress tangents
+
+If a second issue exists, finish the first, then offer the second as a separate question.
+
+Bad: "Here's the fix. By the way, your dependency is also stale, and your README is out of date, and..."
+Good: "Here's the fix. Separately: there is also a stale dependency. Want me to handle that next?"
+
+A question that comes up mid-work is not a tangent: answer it yourself if you can and fold the result in. If it still needs the reader, surface it once, at the end.
+
+### 5. Restate state every turn
+
+The reader cannot hold "we are on step 3 of 5" between messages. Restate it.
+
+Bad: "Done. Ready for the next part?"
+Good: "Step 3 of 5 done: schema updated. Next: backfill the new column. Run the script?"
+
+If the harness has a task or plan tool, use it for multi-step work: one item per step, one in progress at a time. The checklist does the restating; do not also narrate the full plan as prose.
+
+### 6. Give specific time estimates
+
+Vague estimates fail. Ballpark in concrete units.
+
+Bad: "This will take some work."
+Good: "About 15 minutes if tests already cover this. An afternoon if not."
+
+### 7. Make completed work visible
+
+Show what now works, in concrete terms. Do not bury wins in a recap.
+
+Bad: "I've made some changes to the auth flow. Among other things..."
+Good: "Login now works with magic links. Try: `npm run dev`, open `/login`."
+
+### 8. Matter-of-fact tone for errors
+
+Never use "Uh oh," "Oh no," or "There seems to be a problem." State cause and fix.
+
+Bad: "Uh oh, the test is failing. There seems to be an issue..."
+Good: "Test fails at `auth.spec.ts:42`: expected 200, got 401. Cause: missing auth header. Fix: add `Authorization: Bearer ${token}` to the request."
+
+### 9. Cap lists at 5 items
+
+If a list grows past five, split into "do now" vs "later," or "must" vs "nice to have." Five items ranked beats ten unranked.
+
+### 10. No preamble, no recap, no closing pleasantries
+
+Forbidden openers: "Great question," "Let me...", "I'll...", "Sure!", "Looking at your...", "To answer your question..."
+
+Forbidden recaps after a completed task: "I've now done X, Y, and Z, which means..."
+
+Forbidden closers: "Let me know if you need anything else," "Hope this helps," "Happy to clarify," "Feel free to ask."
+
+Start with the answer. End when the answer is done.
+
+## When to break the rules
+
+Override the defaults when:
+
+1. User asks to "explain" or "walk me through." Explain fully. Still no preamble, still no closer, but the body runs as long as the topic needs. Add headers so the reader can skim back.
+2. Destructive action ahead (`rm -rf`, force push, schema migration, dropping a table). Confirm before acting. Safety wins over brevity.
+3. Debug spiral. If the last three turns have been "still broken," stop iterating on code. Name the assumption that might be wrong. Ask one diagnostic question.
+4. Real ambiguity in the request. One short clarifying question beats guessing and rewriting.
+5. A rule fights the task. When a rule would delete the answer itself, the task wins; the shape stays. Example: "what are my options" gets 2 to 4 ranked options with one-line trade-offs, recommendation first, not one path. The options are the answer.
+6. A rule fights the harness. Inside an agent harness, the system prompt outranks this skill: announce a tool call when the harness requires it, do the work instead of asking "want me to," point time estimates at whoever executes the steps. Same principle as 5: the constraint wins, the shape stays.
+
+## Pre-send check
+
+Before sending, delete:
+
+1. The first sentence if it announces what you are about to do.
+2. The last sentence if it asks "anything else?" or recaps what just happened.
+3. Any "by the way" sidebar.
+4. Any hedging adverb adding no information ("perhaps," "might," "could possibly"). Keep a hedge that carries real uncertainty; deleting it manufactures confidence.
+5. Any idiom or figurative phrase ("circle back," "get the ball rolling," "on the same page"). Replace with the literal action.
+
+Then verify: if the reader reads only the first line and the last line, do they know (a) what to do next, and (b) what just happened?
+
+If yes, send.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar",
-  "version": "10.12.2",
+  "version": "10.13.0",
   "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/mcp/server.js

@@ -33,6 +33,7 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
+import { spawnSync } from "node:child_process";
 import { listInstincts } from "../learning/instincts.js";
 import { listDecisions } from "../learning/decisions.js";
 /**
@@ -54,6 +55,22 @@ function err(text) {
     // a structured payload so the model can react.
     return { content: [{ type: "text", text: `error: ${text}` }] };
 }
+// Spawn the local `bizar` CLI with --json. Thin wrappers for the 5 agent-
+// facing surfaces (task, workflow, control, audit, model list) so subagents
+// can call them through MCP instead of shelling out. 30s ceiling keeps the
+// MCP request from hanging on a stuck subprocess.
+function runBizar(args) {
+    const r = spawnSync("bizar", [...args, "--json"], { encoding: "utf8", timeout: 30_000 });
+    if (r.status !== 0)
+        return { ok: false, error: `bizar ${args.join(" ")} exited ${r.status}: ${r.stderr || r.stdout}` };
+    return { ok: true, stdout: r.stdout };
+}
+function readJsonSafe(text) { try {
+    return JSON.parse(text);
+}
+catch {
+    return null;
+} }
 // ---------------------------------------------------------------------------
 // Pillar D — instinct + decision read-back (v10.3.0)
 // ---------------------------------------------------------------------------
@@ -278,6 +295,109 @@ const graphPathTool = defineTool("graph_path", "Find the shortest path between t
     }
 }, { readOnlyHint: true });
 // ---------------------------------------------------------------------------
+// Agent-facing CLI wrappers (F-146) — thin `bizar <surface> --json` shells.
+// ---------------------------------------------------------------------------
+// Forward action + arbitrary key/value args to `bizar task <action> --json`.
+// Valid actions: create, ready, list, show, claim, heartbeat, complete,
+// cancel, sweep.
+const bizarTaskTool = defineTool("bizar_task", "Wrapper around `bizar task <action> --json`. Actions: create, ready, list, show, claim, heartbeat, complete, cancel, sweep. Pass other CLI flags (e.g. --title, --scope, --depends-on, --owner, --workspace, --lease-ms, --evidence, --reason) as string fields.", { action: "string" }, async (args) => {
+    try {
+        const { action, ...rest } = args;
+        if (!action)
+            return err("missing action");
+        const flat = [action];
+        for (const [k, v] of Object.entries(rest)) {
+            if (v === undefined || v === null || v === "")
+                continue;
+            flat.push(`--${k}`, String(v));
+        }
+        const r = runBizar(["task", ...flat]);
+        if (!r.ok)
+            return err(r.error);
+        const parsed = readJsonSafe(r.stdout);
+        return ok(parsed !== null ? JSON.stringify(parsed) : r.stdout);
+    }
+    catch (e) {
+        return err(String(e));
+    }
+});
+// Forward action + args to `bizar workflow <action> --json`.
+// Valid actions: start, status, resume, advance, fail, cancel.
+const bizarWorkflowTool = defineTool("bizar_workflow", "Wrapper around `bizar workflow <action> --json`. Actions: start, status, resume, advance, fail, cancel. Pass CLI flags (e.g. --goal, --profile, --session, --run, --revision, --stage, --evidence, --reason) as string fields.", { action: "string" }, async (args) => {
+    try {
+        const { action, ...rest } = args;
+        if (!action)
+            return err("missing action");
+        const flat = [action];
+        for (const [k, v] of Object.entries(rest)) {
+            if (v === undefined || v === null || v === "")
+                continue;
+            flat.push(`--${k}`, String(v));
+        }
+        const r = runBizar(["workflow", ...flat]);
+        if (!r.ok)
+            return err(r.error);
+        const parsed = readJsonSafe(r.stdout);
+        return ok(parsed !== null ? JSON.stringify(parsed) : r.stdout);
+    }
+    catch (e) {
+        return err(String(e));
+    }
+});
+// Forward action + args to `bizar control <action> --json`.
+// Valid actions: snapshot, agents, tasks, sessions, messages, message.
+const bizarControlTool = defineTool("bizar_control", "Wrapper around `bizar control <action> --json`. Actions: snapshot, agents, tasks, sessions, messages, message. Pass CLI flags (e.g. --agent, --session, --text, --from) as string fields.", { action: "string" }, async (args) => {
+    try {
+        const { action, ...rest } = args;
+        if (!action)
+            return err("missing action");
+        const flat = [action];
+        for (const [k, v] of Object.entries(rest)) {
+            if (v === undefined || v === null || v === "")
+                continue;
+            flat.push(`--${k}`, String(v));
+        }
+        const r = runBizar(["control", ...flat]);
+        if (!r.ok)
+            return err(r.error);
+        const parsed = readJsonSafe(r.stdout);
+        return ok(parsed !== null ? JSON.stringify(parsed) : r.stdout);
+    }
+    catch (e) {
+        return err(String(e));
+    }
+});
+// `bizar audit --json` — single-shot wrapper, no action routing needed.
+const bizarAuditTool = defineTool("bizar_audit", "Wrapper around `bizar audit --json`. Emits the structured audit report (issues, warnings, score) without human-formatted output.", {}, async () => {
+    try {
+        const r = runBizar(["audit"]);
+        if (!r.ok)
+            return err(r.error);
+        const parsed = readJsonSafe(r.stdout);
+        if (parsed !== null)
+            return ok(JSON.stringify(parsed));
+        // CLI did not honour --json; surface a structured error so callers
+        // know the binary is on an older revision than this wrapper expects.
+        return err(`bizar audit did not emit JSON; first chars: ${r.stdout.slice(0, 80)}`);
+    }
+    catch (e) {
+        return err(String(e));
+    }
+}, { readOnlyHint: true });
+// `bizar model list --json` — gateway model inventory.
+const bizarModelListTool = defineTool("bizar_model_list", "Wrapper around `bizar model list --json`. Lists every model id reachable through the configured 9Router gateway.", {}, async () => {
+    try {
+        const r = runBizar(["model", "list"]);
+        if (!r.ok)
+            return err(r.error);
+        const parsed = readJsonSafe(r.stdout);
+        return ok(parsed !== null ? JSON.stringify(parsed) : r.stdout);
+    }
+    catch (e) {
+        return err(String(e));
+    }
+}, { readOnlyHint: true });
+// ---------------------------------------------------------------------------
 // Factory — wire all tools into an MCP server
 // ---------------------------------------------------------------------------
 export const BIZAR_TOOLS = [
@@ -290,6 +410,12 @@ export const BIZAR_TOOLS = [
     graphPathTool,
     listInstinctsTool,
     listDecisionsTool,
+    // F-146 — agent-facing CLI wrappers
+    bizarTaskTool,
+    bizarWorkflowTool,
+    bizarControlTool,
+    bizarAuditTool,
+    bizarModelListTool,
 ];
 /**
  * Build the Bizar MCP server config. Pass this into Claude Code's

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

package/packages/sdk/package.json

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