@polderlabs/bizar 6.2.3 → 6.2.4

package/cli/commands/validate.mjs

@@ -362,6 +362,33 @@ const CHECKS = {
     }
   },
 
+  // v6.2.4 — Warn if the user's clineruntimeMaxConsecutiveMistakes is
+  // below the plugin's recommended minimum. Cline's CLI default is 3
+  // which aborts sessions on the 3rd tool mistake. The Bizar plugin
+  // recommends 10 (or `--retries N` with N ≥ 10).
+  'mistake-limit-floor': async () => {
+    const MIN = 10;
+    const cfg = readJsonSafe(clineJsonPath());
+    if (!cfg?.plugin || !Array.isArray(cfg.plugin)) {
+      return 'no plugin entries in cline.json — skip mistake-limit check';
+    }
+    const bizarEntry = cfg.plugin.find((p) => Array.isArray(p) && p[0] && p[0].includes('plugins/bizar'));
+    if (!bizarEntry) {
+      return 'Bizar plugin not registered — skip mistake-limit check';
+    }
+    const opts = (Array.isArray(bizarEntry) && bizarEntry[1]) || {};
+    const raw = opts.clineruntimeMaxConsecutiveMistakes;
+    if (typeof raw !== 'number' || raw >= MIN) {
+      return `clineruntimeMaxConsecutiveMistakes=${raw ?? 'default 10'} (≥ ${MIN}) — OK`;
+    }
+    throw new Error(
+      `clineruntimeMaxConsecutiveMistakes=${raw} is BELOW the recommended minimum (${MIN}). ` +
+      `Cline's default of 3 aborts the session on the 3rd tool mistake. ` +
+      `Edit ~/.cline/cline.json plugin[1].clineruntimeMaxConsecutiveMistakes to ${MIN}, or run ` +
+      `\`bizar install\` to reset to defaults. (See _shared/CLINE_TOOLS.md for the top-5 mistakes.)`,
+    );
+  },
+
   'default-agent-set': async () => {
     const cfg = readJsonSafe(clineJsonPath());
     if (!cfg?.default_agent) {
@@ -434,12 +461,14 @@ const CHECK_ORDER = [
   'provider-config',
   'cline-settings-provider',
   '9router-reachable',
+  'mistake-limit-floor',
 ];
 
 const LENIENT_CHECKS = new Set([
   '9router-reachable',
   'provider-config', // v6.2.2+ — installer no longer touches provider config; user must configure
   'cline-settings-provider', // v6.2.3 — warns about legacy/fake providerIds; non-blocking
+  'mistake-limit-floor', // v6.2.4 — warns about low mistake limit; non-blocking
 ]);
 
 export function showValidateHelp() {

package/cli/commands/validate.test.mjs

@@ -304,4 +304,41 @@ describe('runValidate() — JSON output', () => {
     const { exitCode } = await captureRun({ json: true, only: 'this-does-not-exist' });
     assert.equal(exitCode, 2);
   });
+
+  test('v6.2.4 — mistake-limit-floor warns when clineruntimeMaxConsecutiveMistakes is < 10', async () => {
+    const cfg = JSON.parse(readFileSync(join(workDir, 'cline.json'), 'utf8'));
+    cfg.plugin = [['./plugins/bizar', { clineruntimeMaxConsecutiveMistakes: 3 }]];
+    writeFileSync(join(workDir, 'cline.json'), JSON.stringify(cfg, null, 2));
+    const { stdout, exitCode } = await captureRun({ json: true });
+    assert.equal(exitCode, 0, 'mistake-limit-floor is lenient so exit stays 0');
+    const parsed = JSON.parse(stdout);
+    const check = parsed.results.find((r) => r.name === 'mistake-limit-floor');
+    assert.ok(check, 'mistake-limit-floor check should be present');
+    assert.equal(check.ok, false, 'low mistake limit should warn');
+    assert.match(check.message, /BELOW the recommended minimum/);
+    assert.match(check.message, /clineruntimeMaxConsecutiveMistakes=3/);
+  });
+
+  test('v6.2.4 — mistake-limit-floor OK when clineruntimeMaxConsecutiveMistakes >= 10', async () => {
+    const cfg = JSON.parse(readFileSync(join(workDir, 'cline.json'), 'utf8'));
+    cfg.plugin = [['./plugins/bizar', { clineruntimeMaxConsecutiveMistakes: 15 }]];
+    writeFileSync(join(workDir, 'cline.json'), JSON.stringify(cfg, null, 2));
+    const { stdout, exitCode } = await captureRun({ json: true });
+    assert.equal(exitCode, 0);
+    const parsed = JSON.parse(stdout);
+    const check = parsed.results.find((r) => r.name === 'mistake-limit-floor');
+    assert.equal(check.ok, true);
+    assert.match(check.message, /15/);
+  });
+
+  test('v6.2.4 — mistake-limit-floor OK when no plugin entry (legacy cline.json)', async () => {
+    const cfg = JSON.parse(readFileSync(join(workDir, 'cline.json'), 'utf8'));
+    delete cfg.plugin;
+    writeFileSync(join(workDir, 'cline.json'), JSON.stringify(cfg, null, 2));
+    const { stdout } = await captureRun({ json: true });
+    const parsed = JSON.parse(stdout);
+    const check = parsed.results.find((r) => r.name === 'mistake-limit-floor');
+    assert.match(check.message, /no plugin entries/);
+    assert.equal(check.ok, true);
+  });
 });

package/config/agents/_shared/AGENT_BASELINE.md

@@ -5,7 +5,19 @@ description: Always-on rules for every Bizar agent. Loaded automatically by clin
 
 # Agent Baseline — Always-On Rules
 
-Every Bizar agent follows these rules at all times. They are translated from the upstream Claude Fable 5 system prompt, with every Claude-specific tool / function / directory mapped to the BizarHarness equivalent (cline tools, Semble, Skills CLI, Obsidian vault, agent-browser, dashboard artifact pipeline).
+> **v6.2.4 — Read `CLINE_TOOLS.md` first.** The Cline tools (`read_file`,
+> `editor`, `apply_patch`, `ask_question`, `use_subagents`, `task`, …)
+> have strict argument shapes. Passing the wrong shape — e.g. `options:
+> null` on `ask_question` — silently fails and counts as a "mistake".
+> After 3 mistakes (10 since v6.2.4) Cline aborts the session.
+> See `_shared/CLINE_TOOLS.md` for the exact schemas.
+
+Every Bizar agent follows these rules at all times. They are the
+canonical agent baseline for the BizarHarness system — the Norse-pantheon
+multi-agent system built on top of Cline. The rules below are tuned for
+Bizar specifically: tool names reference Cline's built-in tools
+(`read_file`, `editor`, `ask_question`, …) and Bizar's plugin tools
+(`bizar_*`); storage paths reference `~/.cline/` and `~/.bizar_memory/`.
 
 ---
 
@@ -25,6 +37,33 @@ Every Bizar agent follows these rules at all times. They are translated from the
 
 ---
 
+## 1a. Tool Mistakes — Don't Kill the Session
+
+Cline's runtime counts consecutive tool failures (mistakes). When the
+count hits the limit (3 in v6.2.0–v6.2.3; **10 since v6.2.4**), it aborts
+the session with `max consecutive mistakes reached`. The most common
+cause is calling a tool with the wrong argument shape.
+
+**Top 5 mistakes that abort sessions — read this and avoid them:**
+
+1. **`ask_question` with `options: null` or `options: undefined`.** The tool silently fails and counts as a mistake. Always pass an array of 2–5 strings.
+2. **`editor` with non-matching `old_text`.** Whitespace must match exactly. Always `read_file` first and copy the bytes.
+3. **`editor` with `old_text` that matches multiple places.** Make `old_text` more specific (include more surrounding context) so it matches exactly once.
+4. **`execute_command` with shell redirects (`>`, `>>`).** Bizar blocks these by default. Use `editor` or `apply_patch` to write files.
+5. **`use_subagents` with a single prompt.** Subagents are parallel research. Spawn 3–5 at once, not one at a time.
+
+**Recovery: if you hit the mistake limit:**
+
+- Stop retrying the same broken call — each retry wastes a mistake.
+- Read `_shared/CLINE_TOOLS.md` for the exact schema.
+- Spawn a fresh session via `bizar_spawn_background` if the runtime is stuck.
+- Ask the user to abort and restart with `bizar doctor` + `bizar validate`.
+
+The full reference is at `_shared/CLINE_TOOLS.md` (linked from every agent
+file's `description` frontmatter).
+
+---
+
 ## 2. Codebase Search — Use Semble First
 
 Semble is the local code search tool — faster and more token-efficient than reading files directly.

package/config/agents/_shared/CLINE_TOOLS.md

@@ -0,0 +1,398 @@
+# Cline Tools Reference
+
+> **Read this before calling any Cline tool.** Calling tools with the
+> wrong argument shape is the #1 cause of "max consecutive mistakes
+> reached" session aborts. When in doubt, read this file.
+
+Every Bizar agent runs inside a Cline session and has access to
+Cline's built-in tools plus the Bizar plugin's `bizar_*` tools. This
+file is the single source of truth for **how to call every Cline
+tool correctly**.
+
+For a list of what each tool does, see https://docs.cline.bot.
+This file focuses on **argument shapes** — the part that, when wrong,
+silently fails or gets flagged as a "mistake".
+
+---
+
+## Quick reference (cheat sheet)
+
+| Tool | Required fields | Common mistake |
+|---|---|---|
+| `read_file` | `path` | passing a dir instead of a file |
+| `list_files` | `path` | forgetting `recursive: true` for nested lookups |
+| `search_files` | `query` (regex) | passing non-regex without `include_pattern` |
+| `editor` | `path`, `new_text` (and `old_text` OR `insert_line`) | `old_text` not matching whitespace exactly |
+| `apply_patch` | `path`, `patch_text` | missing `*** Begin Patch` / `*** End Patch` sentinels |
+| `execute_command` | `command` | shell redirects (`>`, `>>`) blocked by default; 10-min timeout |
+| `web_fetch` | `url` | passing a non-HTTP URL |
+| `ask_question` | `question`, `options` (array of 2–5) | **`options: null` → silent failure → mistake limit** |
+| `use_skill` | `skill` | passing a skill that isn't installed |
+| `use_subagents` | `prompts` (array of strings) | one prompt per subagent |
+| `task` | `agent` (Bizar agent name), `prompt` | passing a non-Bizar agent name |
+
+---
+
+## `read_file`
+
+Read a file (or a slice of one).
+
+```json
+{
+  "path": "/abs/path/to/file.ts",
+  "start_line": 10,
+  "end_line": 50
+}
+```
+
+| Field | Type | Required | Notes |
+|---|---|---|---|
+| `path` | string | **yes** | Absolute path. Reading a directory throws. |
+| `start_line` | number | no | 1-based. Defaults to 1. |
+| `end_line` | number | no | 1-based, inclusive. If omitted, reads to EOF. |
+
+**Failure modes:** `path` to a directory throws `Path is not a file`. `path` to a non-existent file throws. Don't pass `start_line` > `end_line`.
+
+---
+
+## `list_files`
+
+List files in a directory.
+
+```json
+{
+  "path": "/abs/path/to/dir",
+  "recursive": true
+}
+```
+
+| Field | Type | Required | Notes |
+|---|---|---|---|
+| `path` | string | **yes** | Absolute path to a directory. |
+| `recursive` | bool | no | Default false. **Set true for nested lookups.** |
+
+**Failure modes:** `path` to a file throws. The output excludes common build dirs (node_modules, .git, dist, build, .next, coverage, __pycache__, .venv, target, out, bin, obj). Don't rely on the default for deep trees.
+
+---
+
+## `search_files`
+
+Regex search across files.
+
+```json
+{
+  "query": "class \\w+ extends Plugin",
+  "path": "/abs/path/to/project",
+  "include_pattern": "*.ts",
+  "max_results": 50
+}
+```
+
+| Field | Type | Required | Notes |
+|---|---|---|---|
+| `query` | string | **yes** | Treated as a regex. Use `rg` syntax. |
+| `path` | string | no | Defaults to cwd. Absolute path recommended. |
+| `include_pattern` | string | no | Glob, e.g. `*.ts`, `*.{ts,tsx}`. |
+| `max_results` | number | no | Default 100. Clamped server-side. |
+
+**Failure modes:** An invalid regex throws `Invalid regex pattern`. Path to a file throws — must be a directory.
+
+---
+
+## `editor`
+
+The workhorse edit tool. Three modes:
+
+### Mode 1 — `old_text` / `new_text` (replace a block)
+
+```json
+{
+  "path": "/abs/path/to/file.ts",
+  "old_text": "export const foo = 1;\n",
+  "new_text": "export const foo = 2;\n"
+}
+```
+
+- `old_text` must match EXACTLY including whitespace and trailing newline.
+- If `old_text` is not found → tool returns error `text not found in <path>`.
+- If `old_text` matches more than once → tool returns error `multiple occurrences of text found`.
+
+**This is the #1 cause of agent mistakes.** When in doubt:
+1. First call `read_file` on the file
+2. Copy the exact bytes (including indentation and trailing newline)
+3. Make the smallest possible edit
+
+### Mode 2 — `insert_line` (insert at line N)
+
+```json
+{
+  "path": "/abs/path/to/file.ts",
+  "insert_line": 42,
+  "new_text": "// new comment\nconst x = 1;\n"
+}
+```
+
+- `insert_line` is 1-based. The new content is INSERTED before line N.
+- Use `insert_line: <last line + 1>` to append at EOF.
+- `insert_line` must be in `1..<last line + 1>`. Out-of-range throws.
+
+### Mode 3 — file does not exist (create new)
+
+If the file does not exist, omit `old_text` and pass only `new_text`. Cline creates the parent directories automatically.
+
+```json
+{
+  "path": "/abs/path/to/new-file.ts",
+  "new_text": "// brand new file content\n"
+}
+```
+
+**Common failures:**
+- "No replacement performed: text not found" — whitespace mismatch. Re-read the file and copy the bytes exactly.
+- "multiple occurrences" — your `old_text` is too generic. Make it more specific (include more surrounding context).
+- Missing trailing `\n` — the new_text and old_text must end with `\n` if the file does.
+
+---
+
+## `apply_patch`
+
+Multi-file unified-diff patches. Use when editing several files atomically.
+
+```
+*** Begin Patch
+*** Update File: /abs/path/file.ts
+@@ context line
+-old line
++new line
+*** End Patch
+```
+
+**Sentinels are mandatory.** Missing `*** Begin Patch` or `*** End Patch` → throws `Invalid patch text - incomplete sentinels. Try breaking it into smaller patches.`
+
+**Prefer `editor` for single-file edits.** Use `apply_patch` only when you need to:
+- Edit 2+ files in one atomic operation
+- Apply a unified diff you already have
+
+---
+
+## `execute_command`
+
+Run a shell command.
+
+```json
+{
+  "command": "ls -la /tmp",
+  "cwd": "/abs/path",
+  "timeout": 30000
+}
+```
+
+| Field | Type | Required | Notes |
+|---|---|---|---|
+| `command` | string | **yes** | Passed to `/bin/bash -c` (Linux/macOS) or `cmd /c` (Windows). |
+| `cwd` | string | no | Defaults to the Cline session's cwd. |
+| `timeout` | number | no | **Max 600,000 ms (10 min).** Larger values are clamped. |
+
+**Critical constraints:**
+- **No shell redirects** (`>`, `>>`, `<`) unless `CLINE_COMMAND_PERMISSIONS.allowRedirects` is true. Use `editor` or `apply_patch` to write files.
+- Long-running processes will hit the timeout. For >10min tasks, use `bizar_spawn_background` instead (Bizar plugin tool).
+- The `command` string IS a shell command. Quote carefully. Use `&&` to chain, `;` to sequence, `|` to pipe.
+
+**Common failures:**
+- `command not found` — the binary isn't on PATH. Use absolute path or `which <name>` first.
+- `Permission denied` — file isn't executable, or you're writing to a protected dir.
+- `timeout` — increase `timeout` (max 600000) or move to background agent.
+
+---
+
+## `web_fetch`
+
+Fetch a URL and return the content as text.
+
+```json
+{
+  "url": "https://example.com/docs"
+}
+```
+
+| Field | Type | Required | Notes |
+|---|---|---|---|
+| `url` | string | **yes** | Must be HTTP/HTTPS. No `file://`. |
+
+**Failure modes:** Non-HTTP URLs throw. The fetch goes through Cline's content extractor; PDFs, JS-rendered pages, and login-walled sites may return partial content.
+
+---
+
+## `ask_question`
+
+Ask the user ONE clarifying question with 2–5 options. **This is the most-misused tool.**
+
+```json
+{
+  "question": "Which database do you want to use?",
+  "options": ["PostgreSQL", "MySQL", "SQLite", "MongoDB"]
+}
+```
+
+| Field | Type | Required | Notes |
+|---|---|---|---|
+| `question` | string | **yes** | One question. Multi-question calls fail. |
+| `options` | array of 2–5 strings | **yes** | **MUST be an array of strings.** Must be 2–5 items. |
+
+### ⚠️ CRITICAL — `options` is REQUIRED, not optional
+
+If you pass `options: null`, `options: undefined`, or `options: []`, Cline
+**silently rejects the call** and counts it as a mistake. After 3 such
+silent failures (since v6.2.0; 10 since v6.2.4), the session aborts.
+
+### When to use `ask_question`
+
+- A key implementation decision has multiple valid paths
+- The user said something ambiguous and you need to clarify before doing real work
+- You're about to make a destructive change (rm, drop table, force-push)
+
+### When NOT to use `ask_question`
+
+- You can decide safely using sensible defaults
+- The user's intent is clear from context
+- You're just confirming something you should have done already
+- The answer is in the codebase (use `read_file` / `search_files` first)
+
+### Alternatives to `ask_question`
+
+- **Use `bizar_spawn_team`** to spawn a team that investigates and proposes options
+- **Use `use_subagents`** to parallelize the investigation
+- **Just pick a sensible default** and document it in your final response
+
+### Recovery from `ask_question` mistakes
+
+If you accidentally pass `options: null` and the tool errors, **DO NOT retry the same broken call**. Instead:
+1. Switch to a sensible default
+2. Document the decision in your final response
+3. Let the user override later if they disagree
+
+---
+
+## `use_skill`
+
+Activate a skill.
+
+```json
+{
+  "skill": "commit",
+  "args": "-m \"Fix auth bug\""
+}
+```
+
+| Field | Type | Required | Notes |
+|---|---|---|---|
+| `skill` | string | **yes** | Exact skill name. Run `skills list` to see available. |
+| `args` | string | no | Passed to the skill's runner. |
+
+**Failure modes:** Unknown skill name throws. Skills are case-sensitive.
+
+---
+
+## `use_subagents`
+
+Spawn parallel read-only research subagents.
+
+```json
+{
+  "prompts": [
+    "Trace the auth flow from login button to JWT verification. Cite file paths.",
+    "Find every place the database schema is migrated. Cite file paths.",
+    "List all the env vars the app reads at startup. Cite file paths."
+  ]
+}
+```
+
+| Field | Type | Required | Notes |
+|---|---|---|---|
+| `prompts` | array of strings | **yes** | **One research question per subagent.** Each prompt should be focused and self-contained. |
+
+### Subagent rules
+
+- Subagents are **read-only**. They can read files, search, run read-only commands (ls, grep, git log). They **cannot** edit, write, apply patches, or use the browser.
+- Subagents return a focused report citing the most relevant file paths. Read those files yourself before editing.
+- Subagents run in parallel — fire 3–5 at once for broad research, not one at a time.
+- Subagent results do NOT trigger approval — they run under the "Read project files" auto-approve permission.
+
+### When to use subagents
+
+- Onboarding to an unfamiliar codebase (map architecture in parallel)
+- Investigating cross-cutting concerns (auth + logging + errors)
+- Pre-edit research (gather context from related files)
+
+### When NOT to use subagents
+
+- Small focused task where you already know which file
+- Editing files (use `editor` or `apply_patch` instead)
+- Running commands that mutate state (use `execute_command` with `cwd`)
+
+---
+
+## `task` (Bizar plugin — dispatch to a Bizar agent)
+
+Synchronously delegate to a Bizar agent (Odin, Thor, Tyr, Heimdall, Mimir, etc.).
+
+```json
+{
+  "agent": "thor",
+  "prompt": "Implement the rate-limiter middleware in src/middleware/ratelimit.ts"
+}
+```
+
+| Field | Type | Required | Notes |
+|---|---|---|---|
+| `agent` | string | **yes** | A Bizar agent name: `odin`, `thor`, `tyr`, `heimdall`, `mimir`, `frigg`, `hermod`, `baldr`, `vor`, `vidarr`, `forseti`. NOT a Cline-built-in agent. |
+| `prompt` | string | **yes** | What to do. Be specific. |
+
+**Failure modes:** Unknown agent name throws. The agent runs synchronously and returns its result inline.
+
+### Sync vs async dispatch
+
+- `task` — synchronous, blocks until the agent returns. Use when the parent needs the result before continuing.
+- `bizar_spawn_background` (Bizar plugin) — async, returns immediately. Use for long-running work that doesn't block the parent.
+
+---
+
+## `bizar_*` tools (Bizar plugin)
+
+The Bizar plugin adds these on top of the Cline built-ins:
+
+- `bizar_spawn_background(agent, prompt, timeoutMs)` — async background agent
+- `bizar_status(instanceId)` — check background instance
+- `bizar_collect(instanceId, timeoutMs)` — wait for background result (BLOCKS)
+- `bizar_kill(instanceId)` — terminate background
+- `bizar_spawn_team(teamName, mission)` — coordinated agent team
+- `bizar_team_status(sessionId)` — team progress
+- `bizar_plan_action(action, planSlug, ...)` — visual plan canvas
+- `bizar_wait_for_feedback(planSlug)` — block until human reviews plan
+- `bizar_memory_search(query)` / `read` / `write` / `list` — Bizar memory vault
+- `bizar_graph_query(concept)` / `path` / `explain` — knowledge graph
+
+These are documented in `.cline/instructions/bizar-tools.md` (auto-loaded into every session).
+
+---
+
+## Recovery: when you hit the mistake limit
+
+If Cline says "max consecutive mistakes reached (3 in v6.2.0–v6.2.3, 10 since v6.2.4)", the session aborts. To recover:
+
+1. **Stop retrying the same broken call.** Each retry wastes a mistake.
+2. **Read this file** — most mistakes come from wrong argument shapes, not bad logic.
+3. **Use simpler tools** — `read_file` instead of `editor` for inspection; `apply_patch` instead of `editor` for multi-line.
+4. **Spawn a fresh session** if the runtime is in a bad state.
+
+---
+
+## Per-tool I/O contract
+
+All Cline tools return text via stdout-like output. Failed tools return
+either:
+- A structured error message (e.g. "No replacement performed: text not found in /path")
+- An exception thrown back to the agent (which Cline wraps as a mistake)
+
+There is no `success: true|false` field. You must read the response text
+to know what happened.

package/config/agents/agent-browser.md

@@ -1,5 +1,5 @@
 ---
-description: agent-browser — Primary agent for browser-driven E2E verification. No-edit permissions. Drives Chrome for Testing via the agent-browser CLI for end-to-end testing of web apps.
+description: agent-browser — Primary agent for browser-driven E2E verification. No-edit permissions. Drives Chrome for Testing via the agent-browser CLI for end-to-end testing of web apps. Reads `_shared/CLINE_TOOLS.md` before any tool call.
 mode: primary
 model: openrouter/minimax/minimax-m2.7
 color: "#84cc16"

package/config/agents/baldr.md

@@ -1,5 +1,5 @@
 ---
-description: Baldr — UI/UX design system specialist. Creates DESIGN.md files using Google's design.md standard. Aesthetic direction, typography, design tokens, anti-slop audits. Does not implement code.
+description: Baldr — UI/UX design system specialist. Creates DESIGN.md files using Google's design.md standard. Aesthetic direction, typography, design tokens, anti-slop audits. Does not implement code., Cline tool argument shapes (CLINE_TOOLS.md).
 mode: subagent
 model: minimaxcustom/MiniMax-M2.7
 color: "#ec4899"

package/config/agents/forseti.md

@@ -1,5 +1,5 @@
 ---
-description: Forseti — Audits, criticizes, and corrects implementation plans before execution. No write permissions. Review only.
+description: Forseti — Audits, criticizes, and corrects implementation plans before execution. No write permissions. Review only., Cline tool argument shapes (CLINE_TOOLS.md).
 mode: subagent
 model: minimaxcustom/MiniMax-M3
 color: "#ef4444"

package/config/agents/frigg.md

@@ -1,5 +1,5 @@
 ---
-description: Frigg — Read-only codebase Q&A. Answers questions about the project with file references, never modifies anything. Routes to no one.
+description: Frigg — Read-only codebase Q&A. Answers questions about the project with file references, never modifies anything. Routes to no one., Cline tool argument shapes (CLINE_TOOLS.md).
 mode: subagent
 model: minimaxcustom/MiniMax-M2.7
 color: "#f472b6"

package/config/agents/heimdall.md

@@ -1,5 +1,5 @@
 ---
-description: Heimdall — Simple, routine, and deterministic tasks using DeepSeek. Quick edits, mechanical work, file operations. The ever-watchful guardian.
+description: Heimdall — Simple, routine, and deterministic tasks using DeepSeek. Quick edits, mechanical work, file operations. The ever-watchful guardian., Cline tool argument shapes (CLINE_TOOLS.md).
 mode: subagent
 model: minimaxcustom/MiniMax-M2.7
 color: "#10b981"

package/config/agents/hermod.md

@@ -1,5 +1,5 @@
 ---
-description: Hermod — Git and GitHub operations specialist using MiniMax M2.7. The only agent allowed to perform write-level git (commit, push, merge, rebase, branch) and `gh` CLI operations.
+description: Hermod — Git and GitHub operations specialist using MiniMax M2.7. The only agent allowed to perform write-level git (commit, push, merge, rebase, branch) and `gh` CLI operations., Cline tool argument shapes (CLINE_TOOLS.md).
 mode: subagent
 model: minimaxcustom/MiniMax-M2.7
 color: "#f59e0b"

package/config/agents/mimir.md

@@ -1,5 +1,5 @@
 ---
-description: Mimir — Deep codebase research and exploration. Uses Semble as primary search tool. Architecture analysis, pattern discovery, documentation research, and project initialization.
+description: Mimir — Deep codebase research and exploration. Uses Semble as primary search tool. Architecture analysis, pattern discovery, documentation research, and project initialization., Cline tool argument shapes (CLINE_TOOLS.md).
 mode: subagent
 model: minimaxcustom/MiniMax-M2.7
 color: "#06b6d4"

package/config/agents/odin.md

@@ -1,5 +1,5 @@
 ---
-description: Odin — Pure router that delegates all work to subagents. Routes across Frigg (DeepSeek/Q&A), Vör (DeepSeek/clarify), Mimir (DeepSeek/research), Heimdall (DeepSeek/simple), Hermod (M2.7/git), Thor (M2.7/mid), Baldr (M2.7/design), Tyr (M3/top), Vidarr (GPT-5.5/ultra), Forseti (verifier/M3).
+description: Odin — Pure router that delegates all work to subagents. Routes across Frigg (DeepSeek/Q&A), Vör (DeepSeek/clarify), Mimir (DeepSeek/research), Heimdall (DeepSeek/simple), Hermod (M2.7/git), Thor (M2.7/mid), Baldr (M2.7/design), Tyr (M3/top), Vidarr (GPT-5.5/ultra), Forseti (verifier/M3)., Cline tool argument shapes (CLINE_TOOLS.md).
 mode: primary
 model: minimaxcustom/MiniMax-M3
 color: "#6366f1"

package/config/agents/quick.md

@@ -1,5 +1,5 @@
 ---
-description: Quick (quick) — fast single-shot tasks. No delegation, no parallel streams. Use for small edits, mechanical changes, one-shot questions. Routes to no one.
+description: Quick (quick) — fast single-shot tasks. No delegation, no parallel streams. Use for small edits, mechanical changes, one-shot questions. Routes to no one., Cline tool argument shapes (CLINE_TOOLS.md).
 mode: primary
 model: minimaxcustom/MiniMax-M2.7-highspeed
 color: "#22d3ee"

package/config/agents/semble-search.md

@@ -1,5 +1,5 @@
 ---
-description: Code search agent for exploring any codebase. Use for finding code by intent, locating implementations, understanding how something works, or discovering related code. Prefer over Bash/Read for any semantic or exploratory question.
+description: Code search agent for exploring any codebase. Use for finding code by intent, locating implementations, understanding how something works, or discovering related code. Prefer over Bash/Read for any semantic or exploratory question., Cline tool argument shapes (CLINE_TOOLS.md).
 mode: subagent
 model: minimaxcustom/MiniMax-M2.7
 color: "#64748b"

package/config/agents/thor.md

@@ -1,5 +1,5 @@
 ---
-description: Thor — Handles medium-complexity implementation tasks using MiniMax M2.7. New features, non-trivial debugging, refactoring, code review, and writing tests.
+description: Thor — Handles medium-complexity implementation tasks using MiniMax M2.7. New features, non-trivial debugging, refactoring, code review, and writing tests., Cline tool argument shapes (CLINE_TOOLS.md).
 mode: subagent
 model: minimaxcustom/MiniMax-M2.7
 color: "#a855f7"

package/config/agents/tyr.md

@@ -1,5 +1,5 @@
 ---
-description: Tyr — Handles the most complex implementation, debugging, and architectural work using MiniMax M3. Reserved for the hardest problems. Always plan-then-Forseti-gate.
+description: Tyr — Handles the most complex implementation, debugging, and architectural work using MiniMax M3. Reserved for the hardest problems. Always plan-then-Forseti-gate., Cline tool argument shapes (CLINE_TOOLS.md).
 mode: subagent
 model: minimaxcustom/MiniMax-M3
 color: "#dc2626"

package/config/agents/vidarr.md

@@ -1,5 +1,5 @@
 ---
-description: Vidarr — The ultimate fallback via MiniMax M3. For the hardest problems when Tyr stalls, debugging is stuck, or novel insight is needed. Use sparingly — highest cost.
+description: Vidarr — The ultimate fallback via MiniMax M3. For the hardest problems when Tyr stalls, debugging is stuck, or novel insight is needed. Use sparingly — highest cost., Cline tool argument shapes (CLINE_TOOLS.md).
 mode: subagent
 model: minimaxcustom/MiniMax-M3
 color: "#0ea5e9"

package/config/agents/vor.md

@@ -1,5 +1,5 @@
 ---
-description: Vör — Asks clarifying questions for ambiguous or incomplete requests. Reads project context first, then asks one targeted, project-specific question.
+description: Vör — Asks clarifying questions for ambiguous or incomplete requests. Reads project context first, then asks one targeted, project-specific question., Cline tool argument shapes (CLINE_TOOLS.md).
 mode: subagent
 model: minimaxcustom/MiniMax-M2.7
 color: "#a78bfa"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar",
-  "version": "6.2.3",
+  "version": "6.2.4",
   "description": "Norse-pantheon multi-agent system for cline — 13 agents across 4 cost tiers with cost-aware routing, plans, and a configurable agent harness. v4 ships as a single npm package bundling the dashboard server, cline plugin, and typed SDK.",
   "type": "module",
   "bin": {

package/plugins/bizar/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar-plugin",
-  "version": "6.2.3",
+  "version": "6.2.4",
   "description": "Bizar Norse-pantheon multi-agent plugin for Cline — 14 agents across 4 cost tiers with cost-aware routing and plans.",
   "type": "module",
   "main": "./index.ts",

package/plugins/bizar/src/clineruntime.ts

@@ -177,14 +177,29 @@ export class ClineRuntime {
 
   /**
    * Merge caller's `execution` block with the runtime default
-   * (`defaultMaxConsecutiveMistakes`). Returns `undefined` when neither
-   * is set, so the optional field stays out of the config payload.
+   * (`defaultMaxConsecutiveMistakes`).
+   *
+   * v6.2.4 — Plugin's defaultMaxConsecutiveMistakes is now a FLOOR,
+   * not a default. The Cline CLI's `--retries` flag defaults to 3
+   * and previously silently overrode our 6 (or higher) — leading
+   * to premature session aborts after just 3 tool errors. Now we
+   * use Math.max(plugin_default, caller_value) so the user can
+   * still raise the limit with `--retries 15`, but the plugin's
+   * higher default is honored on plain `cline` invocations.
+   *
+   * Returns `undefined` when neither is set, so the optional field
+   * stays out of the config payload.
    */
   private buildExecution(
     callerExecution: StartSessionOpts["execution"],
   ): StartSessionOpts["execution"] | undefined {
     if (!callerExecution && this.defaultMaxConsecutiveMistakes === undefined) return undefined;
-    const max = callerExecution?.maxConsecutiveMistakes ?? this.defaultMaxConsecutiveMistakes;
+    const callerMax = callerExecution?.maxConsecutiveMistakes;
+    const pluginMax = this.defaultMaxConsecutiveMistakes;
+    const max =
+      callerMax !== undefined && pluginMax !== undefined
+        ? Math.max(callerMax, pluginMax)
+        : callerMax ?? pluginMax;
     return { ...callerExecution, ...(max !== undefined ? { maxConsecutiveMistakes: max } : {}) };
   }
 

package/plugins/bizar/src/options.ts

@@ -111,10 +111,14 @@ export const DEFAULT_OPTIONS: NormalizedOptions = {
   backgroundThinkingLoopTimeoutMs: 300_000, // 5 min
   backgroundMaxInterventions: 1,
   // v0.3.1 — ClineRuntime execution surface
-  // SDK default `??6`; CLI overrides to 3. We pick 6 so a single
-  // malformed tool call doesn't kill the session; the recovery callback
-  // (mistake-recovery.ts) gives the model guidance on the way back.
-  clineruntimeMaxConsecutiveMistakes: 6,
+  // SDK default `??6`; CLI overrides to 3. We pick 10 so several
+  // malformed tool calls don't kill the session; the recovery
+  // callback (mistake-recovery.ts) gives the model guidance on the
+  // way back. v6.2.4 — bumped from 6 → 10 because the Cline CLI's
+  // --retries default of 3 was previously overriding this entirely.
+  // Now `buildExecution` uses Math.max(plugin_default, caller_value)
+  // so this acts as a FLOOR, not a default.
+  clineruntimeMaxConsecutiveMistakes: 10,
 };
 
 const SECRET_DIRS: readonly string[] = [
@@ -380,9 +384,12 @@ export function normalizeOptions(raw: RawOptions | undefined): {
 
   // --- v0.3.1 ClineRuntime execution surface -------------------------------
 
-  // clineruntimeMaxConsecutiveMistakes: default 6, range [3, 20]
-  // CLI default is 3 which aborts sessions on the FIRST malformed tool call
-  // (editor { new_text: undefined }, ask_question { options: null }, …).
+  // clineruntimeMaxConsecutiveMistakes: default 10, range [3, 20]
+  // v6.2.4 — bumped from 6 to 10. CLI default is 3 which aborts
+  // sessions on the FIRST 3 malformed tool calls (editor { new_text:
+  // undefined }, run_commands exit code != 0, ask_question { options:
+  // null }, …). With the v6.2.4 buildExecution fix (Math.max floor),
+  // our higher default now always wins on plain `cline` invocations.
   // The harness wires a recovery callback that keeps the session alive on
   // recoverable mistakes, so we only need a slightly-larger ceiling.
   const rawMaxConsecutive = toFiniteInt(r.clineruntimeMaxConsecutiveMistakes);

package/plugins/bizar/tests/clineruntime-config.test.ts

@@ -73,7 +73,7 @@ describe("ClineRuntime.startSession — execution plumbing", () => {
     };
     const runtime = new ClineRuntime({
       logger: stubLogger(),
-      defaultMaxConsecutiveMistakes: 6,
+      defaultMaxConsecutiveMistakes: 10,
       defaultOnConsecutiveMistakeLimitReached: recovery,
     });
     (runtime as unknown as { core: unknown }).core = makeFakeCore();
@@ -84,16 +84,57 @@ describe("ClineRuntime.startSession — execution plumbing", () => {
       prompt: "go",
     });
     const cfg = capturedConfig[0]!.config;
-    expect(cfg.execution).toEqual({ maxConsecutiveMistakes: 6 });
+    expect(cfg.execution).toEqual({ maxConsecutiveMistakes: 10 });
     expect(typeof cfg.onConsecutiveMistakeLimitReached).toBe("function");
     // Invoke the wire-through function and confirm it IS the recovery closure.
     const fn = cfg.onConsecutiveMistakeLimitReached as (ctx: ConsecutiveMistakeLimitContext) => unknown;
-    fn({ iteration: 1, consecutiveMistakes: 3, maxConsecutiveMistakes: 6, reason: "invalid_tool_call" });
+    fn({ iteration: 1, consecutiveMistakes: 3, maxConsecutiveMistakes: 10, reason: "invalid_tool_call" });
     expect(recoveryCalls.length).toBe(1);
     expect(recoveryCalls[0]!.reason).toBe("invalid_tool_call");
   });
 
-  test("caller-supplied execution.maxConsecutiveMistakes wins over default", async () => {
+  test("v6.2.4 — plugin default is a FLOOR; CLI default of 3 is bumped to plugin default", async () => {
+    // This is the v6.2.0 → v6.2.4 regression test. Previously the
+    // caller's maxConsecutiveMistakes (e.g. the Cline CLI's --retries
+    // default of 3) would silently override the plugin's higher
+    // default. Now we use Math.max so the plugin's 10 wins.
+    const runtime = new ClineRuntime({
+      logger: stubLogger(),
+      defaultMaxConsecutiveMistakes: 10,
+    });
+    (runtime as unknown as { core: unknown }).core = makeFakeCore();
+    await runtime.startSession({
+      providerId: "anthropic",
+      modelId: "claude-sonnet-4-6",
+      workspaceRoot: "/tmp",
+      prompt: "go",
+      execution: { maxConsecutiveMistakes: 3, reminderAfterIterations: 8 },
+    });
+    const cfg = capturedConfig[0]!.config;
+    expect(cfg.execution?.maxConsecutiveMistakes).toBe(10,
+      "plugin default must win over CLI default of 3 (was a v6.0 regression)");
+    expect(cfg.execution?.reminderAfterIterations).toBe(8, "other caller fields pass through");
+  });
+
+  test("caller-supplied HIGHER execution.maxConsecutiveMistakes still wins", async () => {
+    const runtime = new ClineRuntime({
+      logger: stubLogger(),
+      defaultMaxConsecutiveMistakes: 10,
+    });
+    (runtime as unknown as { core: unknown }).core = makeFakeCore();
+    await runtime.startSession({
+      providerId: "anthropic",
+      modelId: "claude-sonnet-4-6",
+      workspaceRoot: "/tmp",
+      prompt: "go",
+      execution: { maxConsecutiveMistakes: 20, reminderAfterIterations: 8 },
+    });
+    const cfg = capturedConfig[0]!.config;
+    expect(cfg.execution?.maxConsecutiveMistakes).toBe(20,
+      "user can still raise the limit with --retries 20");
+  });
+
+  test("caller-supplied execution.maxConsecutiveMistakes wins over default (legacy behavior)", async () => {
     const runtime = new ClineRuntime({
       logger: stubLogger(),
       defaultMaxConsecutiveMistakes: 4,

package/plugins/bizar/tests/options.test.ts

@@ -278,16 +278,16 @@ describe("readEnvFlags", () => {
 // ── clineruntimeMaxConsecutiveMistakes ───────────────────────────────────────
 
 describe("clineruntimeMaxConsecutiveMistakes (v0.3.1)", () => {
-  test("default is 6 when neither raw nor env is provided", () => {
+  test("default is 10 when neither raw nor env is provided (v6.2.4)", () => {
     delete process.env.BIZAR_MAX_CONSECUTIVE_MISTAKES;
     const { options } = normalizeOptions({});
-    expect(options.clineruntimeMaxConsecutiveMistakes).toBe(6);
+    expect(options.clineruntimeMaxConsecutiveMistakes).toBe(10);
   });
 
   test("raw value is honored when in range", () => {
     delete process.env.BIZAR_MAX_CONSECUTIVE_MISTAKES;
-    const { options, notes } = normalizeOptions({ clineruntimeMaxConsecutiveMistakes: 10 });
-    expect(options.clineruntimeMaxConsecutiveMistakes).toBe(10);
+    const { options, notes } = normalizeOptions({ clineruntimeMaxConsecutiveMistakes: 15 });
+    expect(options.clineruntimeMaxConsecutiveMistakes).toBe(15);
     expect(notes.some((n) => n.includes("clineruntimeMaxConsecutiveMistakes"))).toBe(false);
   });
 
@@ -321,9 +321,9 @@ describe("clineruntimeMaxConsecutiveMistakes (v0.3.1)", () => {
     delete process.env.BIZAR_MAX_CONSECUTIVE_MISTAKES;
   });
 
-  test("non-numeric raw falls back to default", () => {
+  test("non-numeric raw falls back to default (10)", () => {
     delete process.env.BIZAR_MAX_CONSECUTIVE_MISTAKES;
     const { options } = normalizeOptions({ clineruntimeMaxConsecutiveMistakes: "not-a-number" });
-    expect(options.clineruntimeMaxConsecutiveMistakes).toBe(6);
+    expect(options.clineruntimeMaxConsecutiveMistakes).toBe(10);
   });
 });

package/scripts/bh-full-e2e.mjs

@@ -343,6 +343,28 @@ try {
   record('plugin hooks dir scannable', false, err.message);
 }
 
+// ── 9.5. Verify all 14 agents reference the shared docs (v6.2.4) ─────
+// Catches drift: an agent that doesn't reference AGENT_BASELINE.md or
+// CLINE_TOOLS.md won't get the always-on rules at runtime.
+try {
+  const { spawnSync } = await import('node:child_process');
+  const r = spawnSync('node', ['scripts/check-agents.mjs'], {
+    encoding: 'utf8',
+    cwd: REPO_ROOT,
+    timeout: 10000,
+  });
+  if (r.status === 0) {
+    // Extract the count from the output
+    const m = /All (\d+) agents/.exec(r.stdout || '');
+    const n = m ? m[1] : '?';
+    record('all 14 agents reference AGENT_BASELINE + CLINE_TOOLS', true, `${n} agents OK`);
+  } else {
+    record('all 14 agents reference AGENT_BASELINE + CLINE_TOOLS', false, (r.stdout || r.stderr || '').trim().split('\n').slice(-3).join(' | '));
+  }
+} catch (err) {
+  record('all 14 agents reference AGENT_BASELINE + CLINE_TOOLS', false, err.message);
+}
+
 // ── 10. Verify cline CLI is on PATH and recent enough ──────────
 try {
   const { spawnSync } = await import('node:child_process');

package/scripts/check-agents.mjs

@@ -0,0 +1,73 @@
+/**
+ * scripts/check-agents.mjs
+ *
+ * v6.2.4 — Verifies every agent file references the right shared docs.
+ *
+ * Fails (exit 1) if any of the 14 Bizar agents is missing the
+ * AGENT_BASELINE or CLINE_TOOLS reference. This catches drift early —
+ * an agent that doesn't reference the baseline doesn't get the
+ * always-on rules at runtime.
+ */
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const ROOT = join(__filename, '..', '..');
+
+const AGENT_FILES = [
+  'agent-browser.md',
+  'baldr.md',
+  'forseti.md',
+  'frigg.md',
+  'heimdall.md',
+  'hermod.md',
+  'mimir.md',
+  'odin.md',
+  'quick.md',
+  'semble-search.md',
+  'thor.md',
+  'tyr.md',
+  'vidarr.md',
+  'vor.md',
+];
+
+let failed = 0;
+const rows = [];
+
+for (const file of AGENT_FILES) {
+  const path = join(ROOT, 'config', 'agents', file);
+  let text = '';
+  try {
+    text = readFileSync(path, 'utf8');
+  } catch (err) {
+    rows.push([file, 'MISSING FILE', '']);
+    failed++;
+    continue;
+  }
+  const hasBaseline = /AGENT_BASELINE|agent-baseline/i.test(text);
+  const hasClineTools = /CLINE_TOOLS/i.test(text);
+  if (!hasBaseline && !hasClineTools) {
+    rows.push([file, 'NO REFERENCE', 'needs AGENT_BASELINE or CLINE_TOOLS in description']);
+    failed++;
+  } else {
+    const refs = [
+      hasBaseline ? 'AGENT_BASELINE' : null,
+      hasClineTools ? 'CLINE_TOOLS' : null,
+    ].filter(Boolean).join('+');
+    rows.push([file, 'OK', refs]);
+  }
+}
+
+console.log('\n  Agent → Shared-Docs reference check (v6.2.4)\n');
+console.log('  ' + 'agent'.padEnd(24) + 'status'.padEnd(14) + 'references');
+console.log('  ' + '-'.repeat(60));
+for (const [file, status, refs] of rows) {
+  console.log('  ' + file.padEnd(24) + status.padEnd(14) + refs);
+}
+console.log('');
+if (failed > 0) {
+  console.log(`  ✗ ${failed} agent(s) missing the AGENT_BASELINE/CLINE_TOOLS reference.\n`);
+  process.exit(1);
+}
+console.log(`  ✓ All ${AGENT_FILES.length} agents reference the shared docs.\n`);