@polderlabs/bizar 6.2.2 → 6.2.4

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,
@@ -180,7 +221,7 @@ describe("ClineRuntime.startSession — agent teams plumbing (v6.2.0)", () => {
     expect(cfg.enableAgentTeams).toBe(true);
   });
 
-  test("enableTools is true, enableSpawnAgent is false", async () => {
+  test("enableTools is true, enableSpawnAgent is true (subagents + task tool)", async () => {
     const runtime = new ClineRuntime({ logger: stubLogger() });
     (runtime as unknown as { core: unknown }).core = makeFakeCore();
     await runtime.startSession({
@@ -191,7 +232,8 @@ describe("ClineRuntime.startSession — agent teams plumbing (v6.2.0)", () => {
     });
     const cfg = capturedConfig[0]!.config;
     expect(cfg.enableTools).toBe(true);
-    expect(cfg.enableSpawnAgent).toBe(false);
+    expect(cfg.enableSpawnAgent).toBe(true,
+      "enableSpawnAgent must be true so Odin can use the `task` tool and `use_subagents`");
   });
 
   test("all three boolean flags survive even when caller passes no opts", async () => {
@@ -206,7 +248,27 @@ describe("ClineRuntime.startSession — agent teams plumbing (v6.2.0)", () => {
     const cfg = capturedConfig[0]!.config;
     expect(cfg.enableAgentTeams).toBe(true);
     expect(cfg.enableTools).toBe(true);
-    expect(cfg.enableSpawnAgent).toBe(false);
+    expect(cfg.enableSpawnAgent).toBe(true,
+      "v6.2.3 — subagents + task tool must be available even without caller opts");
+  });
+});
+
+describe("ClineRuntime.startSession — subagents plumbing (v6.2.3)", () => {
+  test("enableSpawnAgent regression: must NEVER be false (v6.2.3 fix)", async () => {
+    // v6.2.3 flipped enableSpawnAgent from false → true. Before this
+    // change, Odin could not use the `task` tool or `use_subagents`,
+    // which silently broke subagent delegation. This test pins the fix.
+    const runtime = new ClineRuntime({ logger: stubLogger() });
+    (runtime as unknown as { core: unknown }).core = makeFakeCore();
+    await runtime.startSession({
+      providerId: "anthropic",
+      modelId: "claude-sonnet-4-6",
+      workspaceRoot: "/tmp",
+      prompt: "go",
+    });
+    const cfg = capturedConfig[0]!.config;
+    expect(cfg.enableSpawnAgent).not.toBe(false);
+    expect(cfg.enableSpawnAgent).toBe(true);
   });
 });
 

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

@@ -125,7 +125,7 @@ if (!existsSync(PLUGIN_PATH)) {
 }
 record('plugin entry resolves', true, PLUGIN_PATH);
 
-// ── 1. Verify enableAgentTeams in source (the v6.2.0 fix) ──────
+// ── 1. Verify enableAgentTeams + enableSpawnAgent in source (v6.2.0 / v6.2.3) ───────
 try {
   const { readFileSync } = await import('node:fs');
   const srcPath = join(REPO_ROOT, 'plugins', 'bizar', 'src', 'clineruntime.ts');
@@ -133,10 +133,17 @@ try {
     record('clineruntime.ts source present', false, `${srcPath} missing`);
   } else {
     const text = readFileSync(srcPath, 'utf8');
-    if (/enableAgentTeams:\s*true/.test(text)) {
-      record('enableAgentTeams: true in clineruntime.ts', true, 'team-spawn tool will work');
+    const teamsOk = /enableAgentTeams:\s*true/.test(text);
+    const spawnOk = /enableSpawnAgent:\s*true/.test(text);
+    if (teamsOk && spawnOk) {
+      record('enableAgentTeams + enableSpawnAgent: true in clineruntime.ts', true,
+        '/team and /subagent (use_subagents + task tool) both work');
     } else {
-      record('enableAgentTeams: true in clineruntime.ts', false, 'REGRESSION: /team will not function');
+      const missing = [];
+      if (!teamsOk) missing.push('enableAgentTeams');
+      if (!spawnOk) missing.push('enableSpawnAgent');
+      record('enableAgentTeams + enableSpawnAgent: true in clineruntime.ts', false,
+        `REGRESSION: missing ${missing.join(', ')} — /team and subagents will not function`);
     }
   }
 } catch (err) {
@@ -336,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');
@@ -378,6 +407,52 @@ try {
   record('bizar validate command present', false, err.message);
 }
 
+// ── 12.6. Verify Cline CLI integration (v6.2.3) ─────────────────
+// v6.2.3 — pass-through wrappers for Cline CLI commands + sample.
+try {
+  const { existsSync } = await import('node:fs');
+  const clineCmd = join(REPO_ROOT, 'cli', 'commands', 'cline-cmd.mjs');
+  const rcaCmd = join(REPO_ROOT, 'cli', 'commands', 'rca.mjs');
+  const rcaTest = join(REPO_ROOT, 'cli', 'commands', 'rca.test.mjs');
+  const setupProviderCmd = join(REPO_ROOT, 'cli', 'commands', 'setup-provider.mjs');
+  const setupProviderTest = join(REPO_ROOT, 'cli', 'commands', 'setup-provider.test.mjs');
+  if (existsSync(clineCmd)) {
+    const text = (await import('node:fs')).readFileSync(clineCmd, 'utf8');
+    const hasConfig = /runClineConfig\b/.test(text);
+    const hasHistory = /runClineHistory\b/.test(text);
+    const hasHub = /runClineHub\b/.test(text);
+    const hasHook = /runClineHook\b/.test(text);
+    const hasTeam = /runClineTeam\b/.test(text);
+    const hasSubagent = /runClineSubagent\b/.test(text);
+    if (hasConfig && hasHistory && hasHub && hasHook && hasTeam && hasSubagent) {
+      record('bizar cline-cmd wrappers present', true, 'config, history, hub, hook, team, subagent');
+    } else {
+      const missing = [];
+      if (!hasConfig) missing.push('config');
+      if (!hasHistory) missing.push('history');
+      if (!hasHub) missing.push('hub');
+      if (!hasHook) missing.push('hook');
+      if (!hasTeam) missing.push('team');
+      if (!hasSubagent) missing.push('subagent');
+      record('bizar cline-cmd wrappers present', false, `missing: ${missing.join(', ')}`);
+    }
+  } else {
+    record('bizar cline-cmd wrappers present', false, 'cli/commands/cline-cmd.mjs missing');
+  }
+  if (existsSync(rcaCmd) && existsSync(rcaTest)) {
+    record('bizar rca (GitHub Issue RCA sample) present', true, 'cli/commands/rca.{mjs,test.mjs}');
+  } else {
+    record('bizar rca (GitHub Issue RCA sample) present', false, 'cli/commands/rca.* missing');
+  }
+  if (existsSync(setupProviderCmd) && existsSync(setupProviderTest)) {
+    record('bizar setup-provider + auto-migrate present', true, 'cli/commands/setup-provider.{mjs,test.mjs}');
+  } else {
+    record('bizar setup-provider + auto-migrate present', false, 'cli/commands/setup-provider.* missing');
+  }
+} catch (err) {
+  record('bizar cline-cmd integration present', false, err.message);
+}
+
 // ── 13. Verify package.json version is consistent ──────────────
 try {
   const { readFileSync } = await import('node:fs');

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`);