@polderlabs/bizar 6.2.0 → 6.2.1

package/cli/commands/validate.mjs

@@ -54,8 +54,13 @@ const REQUIRED_COMMANDS = [
   'team.md', 'test.md', 'validate.md',
 ];
 
+// v6.2.1 — Cline-native hook scripts (executable, shebang, no extension).
+// These are real Cline hooks (https://docs.cline.bot/customization/hooks).
+// The previous v6.x hook contract was markdown behavioral files, which
+// Cline silently ignored — leading to the "I see skills but no hooks"
+// user report.
 const REQUIRED_HOOKS = [
-  'pre-tool-use.md', 'post-tool-use.md', 'README.md',
+  'PreToolUse', 'PostToolUse', 'TaskStart', 'TaskResume', 'UserPromptSubmit',
 ];
 
 const REQUIRED_RUNTIME_DEPS = ['zod', '@cline/sdk', '@cline/core', '@cline/shared'];
@@ -222,7 +227,42 @@ const CHECKS = {
     if (missing.length > 0) {
       throw new Error(`missing: ${missing.join(', ')} — run \`bizar update\``);
     }
-    return `all ${REQUIRED_HOOKS.length} hook file(s) present`;
+    // Verify hooks are executable (Cline silently skips non-executable
+    // hook files per the official contract). On Windows, chmod is a
+    // no-op so skip the check there.
+    if (process.platform !== 'win32') {
+      const { statSync } = await import('node:fs');
+      const nonExec = [];
+      for (const f of REQUIRED_HOOKS) {
+        try {
+          const st = statSync(join(dir, f));
+          // 0o755 = owner=rwx, group=r-x, other=r-x. Just check owner has x.
+          if ((st.mode & 0o100) === 0) nonExec.push(f);
+        } catch {
+          nonExec.push(f);
+        }
+      }
+      if (nonExec.length > 0) {
+        throw new Error(`hooks not executable: ${nonExec.join(', ')} — run \`chmod +x ~/.cline/hooks/*\``);
+      }
+    }
+    return `all ${REQUIRED_HOOKS.length} Cline-native hook file(s) executable in ${dir}`;
+  },
+
+  'hooks-canonical-location': async () => {
+    // Cline's default global hooks location per the official docs:
+    // `~/Documents/Cline/Hooks/`. Verify our hooks are also there
+    // (Bizar install puts them in BOTH ~/.cline/hooks/ and
+    // ~/Documents/Cline/Hooks/ for max compatibility).
+    const canonical = join(homedir(), 'Documents', 'Cline', 'Hooks');
+    if (!existsSync(canonical)) {
+      return `optional: ${canonical} does not exist yet — \`bizar install\` creates it`;
+    }
+    const missing = REQUIRED_HOOKS.filter((f) => !existsSync(join(canonical, f)));
+    if (missing.length > 0) {
+      return `optional: ${missing.length} hook(s) missing in ${canonical} — re-run \`bizar install\``;
+    }
+    return `canonical hooks dir ${canonical} has all ${REQUIRED_HOOKS.length} hook(s)`;
   },
 
   'provider-config': async () => {
@@ -325,6 +365,7 @@ const CHECK_ORDER = [
   'skills-installed',
   'rules-installed',
   'hooks-installed',
+  'hooks-canonical-location',
   'default-agent-set',
   'instructions-loaded',
   'provider-config',

package/cli/commands/validate.test.mjs

@@ -10,7 +10,7 @@
  */
 import { test, describe, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync } from 'node:fs';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync, chmodSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { Writable } from 'node:stream';
@@ -85,8 +85,10 @@ function makeFakeClineInstall(root) {
   }
   const hooksDir = join(root, 'hooks');
   mkdirSync(hooksDir, { recursive: true });
-  for (const h of ['pre-tool-use.md', 'post-tool-use.md', 'README.md']) {
-    writeFileSync(join(hooksDir, h), '# fake hook');
+  for (const h of ['PreToolUse', 'PostToolUse', 'TaskStart', 'TaskResume', 'UserPromptSubmit']) {
+    // Cline hooks must be executable scripts with a shebang line.
+    writeFileSync(join(hooksDir, h), '#!/usr/bin/env node\n// fake hook\n');
+    chmodSync(join(hooksDir, h), 0o755);
   }
   const pluginDir = join(root, 'plugins', 'bizar');
   mkdirSync(pluginDir, { recursive: true });

package/cli/provision.mjs

@@ -38,7 +38,7 @@
 
 import chalk from 'chalk';
 import { execSync, spawn, spawnSync } from 'node:child_process';
-import { existsSync, readFileSync, readdirSync, rmSync, writeFileSync, mkdirSync, statSync, copyFileSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync, rmSync, writeFileSync, mkdirSync, statSync, copyFileSync, chmodSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, dirname, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -1278,12 +1278,47 @@ export async function syncConfigExtras({ dryRun }) {
   }
 
   // ── Hooks ────────────────────────────────────────────────────
+  // v6.2.1 — Cline hooks are real executable scripts (PreToolUse,
+  // PostToolUse, TaskStart, TaskResume, UserPromptSubmit). They live in
+  // `~/.cline/hooks/` AND `~/Documents/Cline/Hooks/`. Cline only loads
+  // hooks from the second path (the first is for additional runtime
+  // hook injection via `--hooks-dir`), but we install to BOTH so:
+  //   1. `bizar validate` can verify the hooks are on disk.
+  //   2. Power users who pass `--hooks-dir ~/.cline/hooks` get them.
+  //   3. The official `~/Documents/Cline/Hooks/` location is canonical
+  //      and works without any extra config.
+  //
+  // Hooks must be `chmod +x` executable (Cline silently skips
+  // non-executable hook files per the Cline hooks contract).
   const hooksSrc = join(REPO_ROOT, 'config', 'hooks');
   if (existsSync(hooksSrc)) {
-    const hooksDst = join(CLINE_DIR, 'hooks');
-    mkdirSync(hooksDst, { recursive: true });
-    await copyDirIfExists(hooksSrc, hooksDst);
-    counts.hooks = 1;
+    const hookEntries = readdirSync(hooksSrc, { withFileTypes: true });
+    const hookFiles = hookEntries
+      .filter((e) => e.isFile() && !e.name.endsWith('.md') && !e.name.endsWith('.txt'))
+      .map((e) => e.name);
+
+    // Install to ~/.cline/hooks/ (used by --hooks-dir override)
+    const hooksDst1 = join(CLINE_DIR, 'hooks');
+    mkdirSync(hooksDst1, { recursive: true });
+    for (const hookFile of hookFiles) {
+      const src = join(hooksSrc, hookFile);
+      const dst = join(hooksDst1, hookFile);
+      copyFileSync(src, dst);
+      try { chmodSync(dst, 0o755); } catch { /* best-effort */ }
+    }
+
+    // Also install to the canonical location: ~/Documents/Cline/Hooks/
+    // (Cline's default global hooks directory per the official docs)
+    const hooksDst2 = join(HOME, 'Documents', 'Cline', 'Hooks');
+    mkdirSync(hooksDst2, { recursive: true });
+    for (const hookFile of hookFiles) {
+      const src = join(hooksSrc, hookFile);
+      const dst = join(hooksDst2, hookFile);
+      copyFileSync(src, dst);
+      try { chmodSync(dst, 0o755); } catch { /* best-effort */ }
+    }
+
+    counts.hooks = hookFiles.length;
   }
 
   // ── Rules ────────────────────────────────────────────────────

package/config/hooks/PostToolUse

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+// PostToolUse — Bizar harness hook.
+//
+// Runs AFTER a tool completes. Reads JSON from stdin, outputs JSON to
+// stdout. This hook does NOT block (post-tool actions can't undo the
+// call); it just adds context for the AI's next decision.
+//
+// Responsibilities:
+//   1. Log tool latency for performance observability (append-only JSONL).
+//   2. Surface any pre-tool warnings (e.g. console.log detected) AFTER
+//      the tool ran, so the model gets a second chance to fix it.
+//   3. Remind the AI to run /test before claiming "done".
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+let raw = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => { raw += chunk; });
+process.stdin.on('end', () => {
+  let input = {};
+  try { input = JSON.parse(raw); } catch { input = {}; }
+  const post = input.postToolUse || {};
+  const toolName = String(post.toolName || '');
+  const success = post.success !== false;
+  const executionTimeMs = Number(post.executionTimeMs) || 0;
+  const params = (post.parameters && typeof post.parameters === 'object') ? post.parameters : {};
+
+  // 1. Append-only JSONL log under ~/.config/bizar/hook-logs/
+  try {
+    const logDir = path.join(os.homedir(), '.config', 'bizar', 'hook-logs');
+    fs.mkdirSync(logDir, { recursive: true });
+    const today = new Date().toISOString().slice(0, 10);
+    const logFile = path.join(logDir, `post-tool-use-${today}.jsonl`);
+    const line = JSON.stringify({
+      ts: new Date().toISOString(),
+      tool: toolName,
+      success,
+      executionTimeMs,
+      sessionId: input.taskId || null,
+    });
+    fs.appendFileSync(logFile, line + '\n');
+  } catch { /* best-effort */ }
+
+  const out = { cancel: false, contextModification: '' };
+  const notes = [];
+
+  if (!success) {
+    notes.push(`Bizar PostToolUse: tool '${toolName}' failed. Investigate the error before proceeding.`);
+  } else if (executionTimeMs > 5000) {
+    notes.push(`Bizar PostToolUse: tool '${toolName}' took ${executionTimeMs}ms — consider whether this is worth the cost.`);
+  }
+
+  // Surface a reminder for write_to_file / apply_patch to src/.
+  const path = params.path || params.file_path || params.filePath || params.target_file || '';
+  if (/^write_to_file$|^apply_patch$|^replace_in_file$|^edit$/i.test(toolName) &&
+      /\/src\/|\/plugins\/|\/packages\//.test(String(path))) {
+    notes.push("Bizar PostToolUse: if you're done editing, run `/test` to gate the change with tests before claiming complete.");
+  }
+
+  out.contextModification = notes.join(' ');
+  process.stdout.write(JSON.stringify(out) + '\n');
+});

package/config/hooks/PreToolUse

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+// PreToolUse — Bizar harness hook.
+//
+// Cline hook script (https://docs.cline.bot/customization/hooks).
+// Runs BEFORE any tool call. Reads JSON from stdin, outputs JSON to
+// stdout. Returns `{ cancel: true, errorMessage: "..." }` to block
+// the tool call, or `{ cancel: false, contextModification: "..." }`
+// to add context for the next AI decision.
+//
+// This hook enforces three Bizar harness invariants:
+//   1. Block writes to .env, secrets, .lock files, node_modules.
+//   2. Warn (don't block) on console.log / debugger / .only() in src/.
+//   3. Always return a small context line for the next AI decision.
+
+'use strict';
+
+let raw = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => { raw += chunk; });
+process.stdin.on('end', () => {
+  let input = {};
+  try { input = JSON.parse(raw); } catch { input = {}; }
+  const pre = input.preToolUse || {};
+  const toolName = String(pre.toolName || '');
+  const params = (pre.parameters && typeof pre.parameters === 'object') ? pre.parameters : {};
+
+  const out = { cancel: false, contextModification: '' };
+  const notes = [];
+
+  // Extract the most common "path" parameter (varies by tool name).
+  const path =
+    params.path ||
+    params.file_path ||
+    params.filePath ||
+    params.target_file ||
+    params.targetFile ||
+    params.notebook_path ||
+    '';
+
+  const lower = String(path).toLowerCase();
+
+  // 1. Hard block — secrets + protected paths.
+  const blocked = [
+    /\/\.env(\.|$|\/)/,
+    /\/\.envrc$/,
+    /\/secrets?\//,
+    /\/credentials?/,
+    /\/node_modules\//,
+    /\.(lock|lockb)$/,
+    /\/package-lock\.json$/,
+    /\/bun\.lockb?$/,
+    /\/yarn\.lock$/,
+  ];
+  if (path && blocked.some((re) => re.test(lower))) {
+    out.cancel = true;
+    out.errorMessage = `PreToolUse: refusing to write to protected path '${path}' (Bizar harness policy).`;
+    process.stdout.write(JSON.stringify(out) + '\n');
+    return;
+  }
+
+  // 2. Warn — debug artifacts in src/.
+  if (path && /\.(ts|tsx|js|jsx|mjs|cjs)$/.test(lower)) {
+    if (/\/src\//.test(lower) || /\/plugins\//.test(lower) || /\/packages\//.test(lower)) {
+      const text = JSON.stringify(params);
+      if (/\bconsole\.(log|debug|warn)\b/.test(text) && !/\bconsole\.(error|info)\b/.test(text)) {
+        notes.push('Heads up: console.log detected in src — `make clean-check` will fail.');
+      }
+      if (/\bdebugger\b/.test(text)) {
+        notes.push('Heads up: debugger statement detected — remove before committing.');
+      }
+      if (/\.only\s*\(/.test(text) && !/^[\s\S]*\.skip\s*\(/m.test(text)) {
+        notes.push('Heads up: .only() detected — `make clean-check` will fail.');
+      }
+    }
+  }
+
+  // 3. Always add a small context line for the AI's next decision.
+  notes.push(`Bizar PreToolUse: tool=${toolName || 'unknown'} path=${path || '(no path)'}`);
+
+  out.contextModification = notes.join(' ');
+  process.stdout.write(JSON.stringify(out) + '\n');
+});

package/config/hooks/README.md

@@ -1,29 +1,68 @@
-# Hook System
+# Bizar Harness — Cline Hooks
 
-BizarHarness uses **behavioral hooks** — agent-level instructions that simulate hook behavior. Since cline doesn't have a native hook runtime, all hooks are implemented as agent behavioral patterns.
+This directory contains Cline-native hook scripts. They are NOT markdown
+behavioral patterns — they are real Cline hook executables that run at
+specific lifecycle events.
 
-## Available Hooks
+## Format
 
-| Hook | Type | Trigger | Behavior |
-|------|------|---------|----------|
-| `pre-tool-use` | Behavioral | Before any edit/write | Check for secrets, verify permissions |
-| `post-tool-use` | Behavioral | After any edit/write | Auto-lint, auto-format, auto-test |
-| `session-start` | Behavioral | On session start | Read .bizar/, Hindsight recall, stack detection |
-| `session-end` | Behavioral | On task completion | Append to AGENTS_SELF_IMPROVEMENT.md |
-| `pre-commit` | Behavioral | Before git commit | Check for console.log, .env leaks, lint |
-| `post-implement` | Behavioral | After parallel implementation | Run test gate, verify both agents' outputs |
+Cline hooks are executable scripts (no extension) with a shebang line:
 
-## How It Works
+```bash
+#!/usr/bin/env node
+```
 
-Each hook is enforced by agent instructions in the agent `.md` files:
+They live in two locations:
+- **Global**: `~/Documents/Cline/Hooks/` (applies to all workspaces)
+- **Workspace**: `.clinerules/hooks/` (applies to one project)
 
-- **Pre-tool-use**: All implementation agents check for exposed secrets before any `write` or `edit` call
-- **Post-tool-use**: After file modifications, agents auto-run the linter and formatter
-- **Session-start**: Odin reads `.bizar/PROJECT.md` and Hindsight; Heimdall runs `bizar init` if missing
-- **Session-end**: Odin dispatches Heimdall to auto-extract self-improvement entries
-- **Pre-commit**: Hermod checks for console.log and .env before allowing git commits
-- **Post-implement**: After Thor+Tyr complete, Odin routes to Thor for test gate
+The `bizar install` / `bizar update` commands install these scripts to
+**both** locations with `chmod +x` so Cline picks them up.
 
-## Customization
+## What each hook does
 
-To disable a hook, remove its instruction from the relevant agent `.md` file(s) in `~/.config/cline/agents/`.
+| Hook | Stage | Job |
+|------|-------|-----|
+| `TaskStart` | New task | Prime the AI with `.bizar/PROJECT.md` + memory-vault search |
+| `TaskResume` | Existing task resumed | Re-read project state, check `git log` since last run |
+| `UserPromptSubmit` | User submits prompt | Tag the prompt for routing (`/team`, `/plow-through`, etc.) |
+| `PreToolUse` | Before every tool | Block writes to `.env`, `secrets/`, `node_modules/`, lockfiles; warn on `console.log`/`debugger`/`.only()` in `src/` |
+| `PostToolUse` | After every tool | Log latency to `~/.config/bizar/hook-logs/`, remind to run `/test` after edits |
+
+## I/O contract
+
+Cline invokes each hook with **JSON on stdin** and reads **JSON on stdout**.
+
+Input shape (Cline → hook):
+
+```json
+{
+  "clineVersion": "3.0.39",
+  "hookName": "PreToolUse",
+  "taskId": "...",
+  "preToolUse": { "toolName": "write_to_file", "parameters": { "path": "src/foo.ts", ... } }
+}
+```
+
+Output shape (hook → Cline):
+
+```json
+{
+  "cancel": false,
+  "contextModification": "small note for the next AI decision"
+}
+```
+
+Set `cancel: true` to block the tool call. The optional `errorMessage`
+is shown to the user.
+
+## Disabling a hook
+
+Rename the file to add a `.disabled` suffix (e.g. `PreToolUse.disabled`)
+or remove the executable bit (`chmod -x PreToolUse`). Cline silently
+skips hooks it can't execute.
+
+## See also
+
+- [Cline hooks documentation](https://docs.cline.bot/customization/hooks)
+- `cli/commands/validate.mjs` — `bizar validate` includes a `hooks-installed` check

package/config/hooks/TaskResume

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+// TaskResume — Bizar harness hook.
+//
+// Runs when an existing task is resumed. Reads JSON from stdin, outputs
+// JSON to stdout. Used to remind the model of previous progress and to
+// detect scope drift since the last run.
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+let raw = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => { raw += chunk; });
+process.stdin.on('end', () => {
+  let input = {};
+  try { input = JSON.parse(raw); } catch { input = {}; }
+  const task = input.taskResume || {};
+  const previous = task.previousState || {};
+
+  try {
+    const logDir = path.join(os.homedir(), '.config', 'bizar', 'hook-logs');
+    fs.mkdirSync(logDir, { recursive: true });
+    const today = new Date().toISOString().slice(0, 10);
+    const logFile = path.join(logDir, `task-resume-${today}.jsonl`);
+    fs.appendFileSync(logFile, JSON.stringify({
+      ts: new Date().toISOString(),
+      taskId: input.taskId || null,
+      lastMessageTs: previous.lastMessageTs || null,
+      messageCount: previous.messageCount || null,
+    }) + '\n');
+  } catch { /* best-effort */ }
+
+  const notes = [
+    'Bizar TaskResume: re-read `.bizar/PROJECT.md` and `PROGRESS.md` before continuing.',
+    'Bizar TaskResume: check `git log --oneline -10` to see what changed since the last run.',
+  ];
+  if (previous.conversationHistoryDeleted) {
+    notes.push('Bizar TaskResume: WARNING — conversation history was deleted. Context from previous run is gone; verify scope before continuing.');
+  }
+
+  process.stdout.write(JSON.stringify({
+    cancel: false,
+    contextModification: notes.join(' '),
+  }) + '\n');
+});

package/config/hooks/TaskStart

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+// TaskStart — Bizar harness hook.
+//
+// Runs when a NEW task is started (not when resuming). Reads JSON from
+// stdin, outputs JSON to stdout. Used to prime the AI with project
+// context and to record the start of a session.
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+let raw = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => { raw += chunk; });
+process.stdin.on('end', () => {
+  let input = {};
+  try { input = JSON.parse(raw); } catch { input = {}; }
+  const task = input.taskStart || {};
+  const initial = String(task.taskMetadata?.initialTask || '').slice(0, 500);
+
+  // Log task start to ~/.config/bizar/hook-logs/
+  try {
+    const logDir = path.join(os.homedir(), '.config', 'bizar', 'hook-logs');
+    fs.mkdirSync(logDir, { recursive: true });
+    const today = new Date().toISOString().slice(0, 10);
+    const logFile = path.join(logDir, `task-start-${today}.jsonl`);
+    fs.appendFileSync(logFile, JSON.stringify({
+      ts: new Date().toISOString(),
+      taskId: input.taskId || null,
+      clineVersion: input.clineVersion || null,
+      initial: initial,
+    }) + '\n');
+  } catch { /* best-effort */ }
+
+  const notes = [
+    'Bizar TaskStart: read `.bizar/PROJECT.md` (if present) before any routing decision.',
+    'Bizar TaskStart: if memory vault exists, run `bizar memory search "<topic>"` first.',
+    'Bizar TaskStart: Odin dispatches to subagents via `task` (sync) or `bizar_spawn_background` (async).',
+  ];
+
+  process.stdout.write(JSON.stringify({
+    cancel: false,
+    contextModification: notes.join(' '),
+  }) + '\n');
+});

package/config/hooks/UserPromptSubmit

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+// UserPromptSubmit — Bizar harness hook.
+//
+// Runs when the user submits a prompt. Reads JSON from stdin, outputs
+// JSON to stdout. Used to lightly tag user prompts for routing and to
+// add a "Plow Through" prompt hint when ambiguity is detected.
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+let raw = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => { raw += chunk; });
+process.stdin.on('end', () => {
+  let input = {};
+  try { input = JSON.parse(raw); } catch { input = {}; }
+  const submit = input.userPromptSubmit || {};
+  const prompt = String(submit.prompt || '').trim();
+
+  // Always log (no PII redaction needed — the prompt is the user's).
+  try {
+    const logDir = path.join(os.homedir(), '.config', 'bizar', 'hook-logs');
+    fs.mkdirSync(logDir, { recursive: true });
+    const today = new Date().toISOString().slice(0, 10);
+    const logFile = path.join(logDir, `user-prompt-${today}.jsonl`);
+    fs.appendFileSync(logFile, JSON.stringify({
+      ts: new Date().toISOString(),
+      taskId: input.taskId || null,
+      promptLength: prompt.length,
+    }) + '\n');
+  } catch { /* best-effort */ }
+
+  const notes = [];
+  if (prompt.length === 0) {
+    notes.push('Bizar UserPromptSubmit: empty prompt — wait for actual user input.');
+  } else if (prompt.startsWith('/team')) {
+    notes.push('Bizar UserPromptSubmit: /team — Odin will spawn a coordinated agent team. Confirm disjoint file scopes before dispatching.');
+  } else if (prompt.startsWith('/plow-through')) {
+    notes.push('Bizar UserPromptSubmit: /plow-through — autonomous mode. Dispatch 2+ parallel agents when possible. Run /test before claiming done.');
+  } else if (prompt.startsWith('/test')) {
+    notes.push('Bizar UserPromptSubmit: /test — auto-detects runner (jest/vitest/bun/pytest/cargo/go). Streams output to the user.');
+  } else if (prompt.startsWith('/validate')) {
+    notes.push('Bizar UserPromptSubmit: /validate — runs 21-point health check on the Bizar install.');
+  } else {
+    notes.push('Bizar UserPromptSubmit: if the request is complex, decompose into 2+ parallel subagent tasks (Odin) or spawn a /team.');
+  }
+
+  process.stdout.write(JSON.stringify({
+    cancel: false,
+    contextModification: notes.join(' '),
+  }) + '\n');
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar",
-  "version": "6.2.0",
+  "version": "6.2.1",
   "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.0",
+  "version": "6.2.1",
   "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/scripts/bh-full-e2e.mjs

@@ -249,6 +249,39 @@ try {
   record('config/rules/ scannable', false, err.message);
 }
 
+// ── 6.5. Verify config/hooks/ has Cline-native executable hooks ────
+// Cline hooks are real scripts (not markdown). They must have a
+// shebang line and the right names. The previous v6.x format used
+// markdown behavioral files which Cline ignored.
+try {
+  const { readFileSync, readdirSync, existsSync } = await import('node:fs');
+  const hooksDir = join(REPO_ROOT, 'config', 'hooks');
+  if (!existsSync(hooksDir)) {
+    record('config/hooks/ present', false, `${hooksDir} missing`);
+  } else {
+    const files = readdirSync(hooksDir);
+    const required = ['PreToolUse', 'PostToolUse', 'TaskStart', 'TaskResume', 'UserPromptSubmit'];
+    const missing = required.filter((f) => !files.includes(f));
+    if (missing.length > 0) {
+      record('config/hooks/ has 5 Cline-native hook scripts', false, `missing: ${missing.join(', ')}`);
+    } else {
+      // Verify each has a shebang line (Cline requires it).
+      const noShebang = [];
+      for (const f of required) {
+        const first = readFileSync(join(hooksDir, f), 'utf8').split('\n')[0] || '';
+        if (!first.startsWith('#!')) noShebang.push(f);
+      }
+      if (noShebang.length > 0) {
+        record('Cline hooks have shebang', false, `no shebang: ${noShebang.join(', ')}`);
+      } else {
+        record('config/hooks/ has 5 Cline-native executable hooks', true, required.join(', '));
+      }
+    }
+  }
+} catch (err) {
+  record('config/hooks/ scannable', false, err.message);
+}
+
 // ── 7. Verify plugin index.ts is well-formed ───────────────────
 try {
   const { readFileSync } = await import('node:fs');

package/config/hooks/post-tool-use.md

@@ -1,16 +0,0 @@
-# Post-Tool-Use Hook
-
-Enforced by: All implementation agents (Heimdall, Thor, Tyr, Vidarr)
-
-## Checklist
-
-After every `write` or `edit` operation:
-
-1. **Format**: Run the project formatter (Prettier, Black, ruff, gofmt, rustfmt)
-2. **Lint**: Run the linter on the modified file
-3. **Typecheck**: Run the type checker (tsc, mypy, etc.) if applicable
-4. **Quick test**: If modifying tests, run just the affected test file
-
-## Enforcement
-
-Run these automatically. Do not ask for permission — the hook enforces quality.

package/config/hooks/pre-tool-use.md

@@ -1,16 +0,0 @@
-# Pre-Tool-Use Hook
-
-Enforced by: All implementation agents (Heimdall, Thor, Tyr, Vidarr)
-
-## Checklist
-
-Before every `write` or `edit` operation, check:
-
-1. **Secrets**: Does the content contain API keys, tokens, or passwords? (`sk-...`, `AIza...`, etc.)
-2. **Console.log**: Is debug logging being committed? Use proper logging instead.
-3. **Permissions**: Are you writing to a file you should not modify? (e.g., `.env`, `node_modules/`, `*.lock`)
-4. **Size**: Is the file too large? Consider splitting into smaller modules.
-
-## Enforcement
-
-Block the operation if any check fails. Fix the issue first, then proceed.