@polderlabs/bizar 6.2.5 → 6.3.0

package/.claude/commands/visual-plan.md

@@ -0,0 +1,24 @@
+---
+description: Toggle the Bizar visual plan canvas or check its current status.
+---
+
+# /visual-plan — Toggle Visual Plan Canvas
+
+Toggle the Bizar visual plan canvas or check its current status.
+
+The full arguments are available as `$ARGUMENTS` (and `$1`).
+
+## Usage
+
+```
+/visual-plan on   — Enable the visual plan canvas in the current session
+/visual-plan off  — Disable the visual plan canvas
+/visual-plan status — Show whether the canvas is currently enabled
+```
+
+## Notes
+
+The visual plan canvas shows plans as interactive node graphs. When enabled, plan elements appear as draggable nodes on a canvas that agents can manipulate directly. This is useful for visual thinkers or when planning complex multi-step work.
+
+This is a session-level toggle — it affects the current Claude Code
+session only.

package/.claude/hooks/README.md

@@ -0,0 +1,92 @@
+# Bizar Harness — Claude Code Hooks
+
+This directory contains the **Claude Code** adapter scripts that back the
+project-scoped hooks defined in `.claude/settings.json`.
+
+They replaced the legacy Cline hooks in `config/hooks/*` (PreToolUse,
+PostToolUse, TaskStart, TaskResume, UserPromptSubmit). The Claude Code
+set is the only supported path on Bizar v6.3.0+; the legacy Cline hooks
+are no longer installed.
+
+## Adapter inventory
+
+| File | Event | Matcher | Behaviour |
+|------|-------|---------|-----------|
+| `pretooluse-editwrite.mjs`   | `PreToolUse`       | `Write\|Edit\|MultiEdit\|Bash` | Blocks `.env`/secrets/lockfiles; warns on `console.log`/`debugger`/`.only()` in `src/`; scans `Bash` against the 36-pattern dangerous-pattern list |
+| `posttooluse-editwrite.mjs`  | `PostToolUse`      | `Edit\|Write\|MultiEdit`        | Logs edit/write latency + size to `~/.config/bizar/hook-logs/` |
+| `sessionstart-prime.mjs`     | `SessionStart`     | (none — branches on `source`)  | Primes the agent with CLAUDE.md, AGENTS.md, feature_list state |
+| `userpromptsubmit-tag.mjs`   | `UserPromptSubmit` | (none)                          | Tags prompt for `/team`, `/plow-through`, `/test`, `/validate`, `/plan`, `/audit`, `/pr-review` |
+| `sessionend-recall.mjs`      | `SessionEnd`       | (none)                          | Records a session summary to the memory vault at `~/.bizar_home/memory/projects/<name>/sessions/` |
+
+## I/O contract
+
+Claude Code invokes each hook as a child process, pipes JSON on
+**stdin**, and reads JSON on **stdout**. The five adapters above all
+read using `process.stdin` and write a single JSON object to
+`process.stdout`.
+
+### Stdin (varies by event)
+
+```jsonc
+// PreToolUse
+{
+  "session_id": "...",
+  "transcript_path": "...",
+  "cwd": "/home/drb0rk/Projects/BizarHarness",
+  "hook_event_name": "PreToolUse",
+  "tool_name": "Write",
+  "tool_input": { "file_path": "/path", "content": "..." }
+}
+
+// PostToolUse  (adds tool_response)
+// UserPromptSubmit  (uses .user_prompt instead of .tool_name/.tool_input)
+// SessionStart  (uses .source = "startup" | "resume" | "clear")
+// SessionEnd  (uses .reason = "exit" | "clear" | "logout" | "prompt_input_exit")
+```
+
+### Stdout
+
+```jsonc
+// Block (PreToolUse only)
+{
+  "hookSpecificOutput": {
+    "hookEventName": "PreToolUse",
+    "permissionDecision": "deny",
+    "permissionDecisionReason": "..."
+  }
+}
+
+// Inject context for the next turn (all events)
+{
+  "hookSpecificOutput": {
+    "hookEventName": "PostToolUse",   // or PreToolUse / SessionStart / UserPromptSubmit
+    "additionalContext": "..."
+  }
+}
+```
+
+For a non-blocking `PreToolUse`, omitting `permissionDecision` and
+emitting only `additionalContext` is a soft hint to the model — the
+tool call still proceeds.
+
+## Claude Code lifecycle mapping
+
+The legacy Cline plugin used four separate events (PreToolUse,
+PostToolUse, TaskStart, TaskResume, UserPromptSubmit). Claude Code
+collapses "task start" and "task resume" into a single `SessionStart`
+event that branches on `source` (`startup`, `resume`, `clear`). The
+adapter `sessionstart-prime.mjs` reads `source` and applies the
+appropriate priming logic for each branch.
+
+## Disabling an individual hook
+
+Easiest path: comment out the matching `hooks` array entry in
+`.claude/settings.json`. Removing the executable bit
+(`chmod -x …`) also works — Claude Code silently skips hooks it can't
+execute.
+
+## See also
+
+- `cli/provision-claude.mjs` — installs Claude Code hooks to
+  `~/.claude/hooks/` and wires them via `~/.claude/settings.json`.
+- `.claude/settings.json` — the project hook wiring

package/.claude/hooks/posttooluse-editwrite.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+// PostToolUse — Bizar harness hook (Claude Code format).
+//
+// Runs AFTER a tool call against `Edit`, `Write`, or `MultiEdit`
+// completes. Logs the edit/write to `~/.config/bizar/hook-logs/` so
+// downstream observability tooling can aggregate latency + size.
+//
+// Claude Code stdin shape:
+//   {
+//     "session_id": "...",
+//     "transcript_path": "...",
+//     "cwd": "...",
+//     "hook_event_name": "PostToolUse",
+//     "tool_name": "Edit",
+//     "tool_input": { "file_path": "..." },
+//     "tool_response": { ... }
+//   }
+//
+// Claude Code stdout shape:
+//   { "hookSpecificOutput": {
+//       "hookEventName": "PostToolUse",
+//       "additionalContext": "note for the next turn"
+//   }}
+//
+// Behaviour:
+//   1. Append-only JSONL log under ~/.config/bizar/hook-logs/.
+//   2. Remind to run /test after edits to src/ files.
+
+'use strict';
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node: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 toolName = String(input.tool_name || '');
+  const toolInput =
+    (input.tool_input && typeof input.tool_input === 'object') ? input.tool_input : {};
+  const filePath = String(toolInput.file_path || '');
+  const sessionId = String(input.session_id || '');
+
+  // 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: true, // PostToolUse only fires on success in Claude Code
+      executionTimeMs: 0, // not exposed in Claude Code hook input
+      sessionId: sessionId || null,
+    });
+    fs.appendFileSync(logFile, line + '\n');
+  } catch { /* best-effort */ }
+
+  const notes = [];
+
+  // 2. Skip the slow-tool warning — Claude Code doesn't surface tool
+  //    latency in hook input, so no signal to warn on.
+  //
+  // 3. Surface a reminder for Write/Edit/MultiEdit on src/ paths.
+  if (
+    /^(write|edit|multiedit)$/i.test(toolName) &&
+    /\/(src|plugins|packages)\//.test(filePath.toLowerCase())
+  ) {
+    notes.push(
+      "Bizar PostToolUse: if you're done editing, run `/test` to gate the change with tests before claiming complete.",
+    );
+  }
+
+  if (notes.length === 0) {
+    process.stdout.write('{}\n');
+    return;
+  }
+
+  const out = {
+    hookSpecificOutput: {
+      hookEventName: 'PostToolUse',
+      additionalContext: notes.join(' '),
+    },
+  };
+  process.stdout.write(JSON.stringify(out) + '\n');
+});

package/.claude/hooks/pretooluse-bash.mjs

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+/**
+ * pretooluse-bash.mjs — Claude Code PreToolUse hook (matcher: Bash).
+ *
+ * Runs the Bizar dangerous-pattern scanner on Bash commands before they
+ * execute. Blocks destructive patterns (rm -rf, sudo, SSRF, etc.) via
+ * the 36-pattern DANGEROUS_PATTERNS regex list maintained in
+ * `@polderlabs/bizar-sdk/dist/dangerous-patterns.js`.
+ *
+ * Claude Code PreToolUse input schema:
+ *   { session_id, cwd, hook_event_name: "PreToolUse", tool_name: "Bash", tool_input: { command, description } }
+ *
+ * Claude Code PreToolUse output schema:
+ *   { hookSpecificOutput: { hookEventName, permissionDecision, permissionDecisionReason }, additionalContext? }
+ */
+
+'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 toolInput = (input.tool_input && typeof input.tool_input === 'object') ? input.tool_input : {};
+  const command = String(toolInput.command || '');
+
+  // Inline dangerous-pattern scanner. Mirrors
+  // `packages/sdk/src/dangerous-patterns.ts` — kept inline so this hook
+  // works without importing the SDK at runtime.
+  const DANGEROUS = [
+    { name: 'rm-rf-root', pattern: /\brm\s+(-\w*r\w*f\w*\s+)*\/\s*$/i, decision: 'deny', reason: 'Recursive delete of root filesystem' },
+    { name: 'rm-rf-etc', pattern: /\brm\s+(-\w*r\w*f\w*\s+)*\/(etc|var|usr|boot|home)\b/i, decision: 'deny', reason: 'Recursive delete of system directory' },
+    { name: 'rm-rf-wildcard', pattern: /\brm\s+-\w*r\w*f\w*\s+\*/i, decision: 'ask', reason: 'Recursive delete with wildcard' },
+    { name: 'rm-rf-home', pattern: /\brm\s+(-\w*r\w*f\w*\s+)*~?\//i, decision: 'ask', reason: 'Recursive delete of home directory' },
+    { name: 'mkfs', pattern: /\bmkfs(\.\w+)?\s+\/dev\//i, decision: 'deny', reason: 'Format filesystem' },
+    { name: 'dd-of-dev', pattern: /\bdd\s+.*of=\/dev\//i, decision: 'deny', reason: 'dd to raw device' },
+    { name: 'sudo', pattern: /(^|\s|;|&&|\|\|)sudo\b/i, decision: 'ask', reason: 'Sudo escalation' },
+    { name: 'su-root', pattern: /\bsu\s+-?\s*root\b/i, decision: 'ask', reason: 'su to root' },
+    { name: 'curl-metadata', pattern: /169\.254\.169\.254/i, decision: 'deny', reason: 'AWS metadata IP' },
+    { name: 'curl-google-metadata', pattern: /metadata\.google\.internal/i, decision: 'deny', reason: 'GCP metadata hostname' },
+    { name: 'curl-azure-metadata', pattern: /metadata\.azure\.com/i, decision: 'deny', reason: 'Azure metadata hostname' },
+    { name: 'nc-backdoor', pattern: /\bnc\s+(-[a-z]*\s+)*-[a-z]*e\b/i, decision: 'deny', reason: 'nc execute backdoor' },
+    { name: 'wget-pipe-shell', pattern: /\bwget\s+.*\|\s*(ba)?sh\b/i, decision: 'deny', reason: 'wget piped to shell' },
+    { name: 'curl-pipe-shell', pattern: /\bcurl\s+.*\|\s*(ba)?sh\b/i, decision: 'deny', reason: 'curl piped to shell' },
+    { name: 'kill-init', pattern: /\bkill\s+(-9\s+)?1\b/i, decision: 'deny', reason: 'Kill PID 1 (init)' },
+    { name: 'shutdown', pattern: /\b(shutdown|halt|poweroff|reboot)\b/i, decision: 'deny', reason: 'System shutdown' },
+    { name: 'xmrig', pattern: /\b(xmrig|minerd|cpuminer|cgminer)\b/i, decision: 'deny', reason: 'Crypto miner' },
+    { name: 'read-shadow', pattern: /\/etc\/(shadow|passwd|sudoers)\b/i, decision: 'ask', reason: 'Read sensitive system file' },
+    { name: 'read-ssh', pattern: /\.ssh\//i, decision: 'deny', reason: 'Read SSH keys' },
+    { name: 'read-aws-creds', pattern: /~\/\.aws\/credentials/i, decision: 'deny', reason: 'Read AWS credentials' },
+    { name: 'path-traversal', pattern: /(\.\.\/){2,}/i, decision: 'ask', reason: 'Multiple path traversal' },
+    { name: 'git-force-push-main', pattern: /\bgit\s+push\s+(-f|--force)(\s+--.*)?\s+origin\s+(main|master)\b/i, decision: 'deny', reason: 'Force push to main/master' },
+    { name: 'git-reset-hard', pattern: /\bgit\s+reset\s+--hard\b/i, decision: 'ask', reason: 'git reset --hard' },
+  ];
+
+  for (const p of DANGEROUS) {
+    if (p.pattern.test(command)) {
+      const decision = p.decision === 'deny' ? 'deny' : 'ask';
+      const out = {
+        hookSpecificOutput: {
+          hookEventName: 'PreToolUse',
+          permissionDecision: decision,
+          permissionDecisionReason: `dangerous_pattern:${p.name}: ${p.reason}`,
+        },
+      };
+      process.stdout.write(JSON.stringify(out) + '\n');
+      return;
+    }
+  }
+
+  // No dangerous pattern — allow.
+  const out = {
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: 'allow',
+    },
+    additionalContext: `Bizar PreToolUse(Bash): scanned ${command.length} chars, no dangerous pattern.`,
+  };
+  process.stdout.write(JSON.stringify(out) + '\n');
+});

package/.claude/hooks/pretooluse-editwrite.mjs

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+// PreToolUse — Bizar harness hook (Claude Code format).
+//
+// Runs BEFORE any tool call against `Write`, `Edit`, `MultiEdit`, or `Bash`.
+//
+// Claude Code stdin shape:
+//   {
+//     "session_id": "...",
+//     "transcript_path": "...",
+//     "cwd": "...",
+//     "hook_event_name": "PreToolUse",
+//     "tool_name": "Write",
+//     "tool_input": { "file_path": "...", "content": "..." }
+//   }
+//
+// Claude Code stdout shape:
+//   { "hookSpecificOutput": {
+//       "hookEventName": "PreToolUse",
+//       "permissionDecision": "deny",
+//       "permissionDecisionReason": "..."
+//   }}
+//   ── or ──
+//   { "hookSpecificOutput": {
+//       "hookEventName": "PreToolUse",
+//       "additionalContext": "note for the model"
+//   }}
+//
+// Behaviour:
+//   1. Block writes to .env, .envrc, secrets/, credentials/,
+//      node_modules/, *.lock, *.lockb, package-lock.json, bun.lock*, yarn.lock.
+//   2. Warn (don't block) on console.log / debugger / .only() in src/.
+//   3. Scan `Bash` commands against the dangerous-patterns list.
+//   4. 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 toolName = String(input.tool_name || '');
+  const toolInput =
+    (input.tool_input && typeof input.tool_input === 'object') ? input.tool_input : {};
+
+  // Extract the "path" and "content" mapped onto Claude Code's
+  // Write/Edit/MultiEdit/Bash shapes.
+  let filePath = '';
+  let content = '';
+  if (toolName === 'Write') {
+    filePath = String(toolInput.file_path || '');
+    content = String(toolInput.content || '');
+  } else if (toolName === 'Edit') {
+    filePath = String(toolInput.file_path || '');
+    content = String(toolInput.new_string || '');
+  } else if (toolName === 'MultiEdit') {
+    filePath = String(toolInput.file_path || '');
+    const edits = Array.isArray(toolInput.edits) ? toolInput.edits : [];
+    content = edits.map((e) => String((e && e.new_string) || '')).join('\n');
+  } else if (toolName === 'Bash') {
+    // No "path" for Bash — use the command string as the inspect surface.
+    content = String(toolInput.command || '');
+  } else {
+    process.stdout.write('{}\n');
+    return;
+  }
+
+  const lowerPath = filePath.toLowerCase();
+  const lowerContent = content.toLowerCase();
+
+  // 1. Hard block — secrets + protected paths.
+  const blocked = [
+    /\/\.env(\.|$|\/)/,
+    /\/\.envrc$/,
+    /\/secrets?\//,
+    /\/credentials?/,
+    /\/node_modules\//,
+    /\.(lock|lockb)$/,
+    /\/package-lock\.json$/,
+    /\/bun\.lockb?$/,
+    /\/yarn\.lock$/,
+  ];
+
+  let blockReason = '';
+  if (filePath && blocked.some((re) => re.test(lowerPath))) {
+    blockReason = filePath;
+  } else if (toolName === 'Bash' && blocked.some((re) => re.test(lowerContent))) {
+    blockReason = '(matched in Bash command)';
+  }
+
+  if (blockReason) {
+    const out = {
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'deny',
+        permissionDecisionReason:
+          `Bizar PreToolUse: refusing to write to protected path '${blockReason}' (Bizar harness policy).`,
+      },
+    };
+    process.stdout.write(JSON.stringify(out) + '\n');
+    return;
+  }
+
+  // 2. Warn — debug artifacts in src/ (only when a path-shaped target exists).
+  const notes = [];
+  const target = filePath || content; // for Bash, content == command (rarely matches)
+  const lowerTarget = target.toLowerCase();
+  if (
+    filePath &&
+    /\.(ts|tsx|js|jsx|mjs|cjs)$/.test(lowerTarget) &&
+    /\/(src|plugins|packages)\//.test(lowerTarget)
+  ) {
+    if (
+      /\bconsole\.(log|debug|warn)\b/.test(lowerContent) &&
+      !/\bconsole\.(error|info)\b/.test(lowerContent)
+    ) {
+      notes.push("Heads up: console.log detected in src — `make clean-check` will fail.");
+    }
+    if (/\bdebugger\b/.test(lowerContent)) {
+      notes.push('Heads up: debugger statement detected — remove before committing.');
+    }
+    if (/\.only\s*\(/.test(content) && !/\.skip\s*\(/.test(content)) {
+      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=${filePath || '(no path)'}`);
+
+  const out = {
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      additionalContext: notes.join(' '),
+    },
+  };
+  process.stdout.write(JSON.stringify(out) + '\n');
+});

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

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+/**
+ * sessionend-recall.mjs — Claude Code SessionEnd hook.
+ *
+ * Records session summaries to the memory vault and writes a
+ * `sessions/<date>-<session-id>.md` note via the in-process vault.
+ *
+ * Claude Code SessionEnd input schema:
+ *   { session_id, cwd, hook_event_name: "SessionEnd", reason?: string }
+ *
+ * Claude Code SessionEnd output schema:
+ *   { continue?: boolean, stopReason?: string }
+ */
+
+'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 sessionId = input.session_id || 'unknown';
+  const cwd = input.cwd || process.cwd();
+  const reason = input.reason || 'unknown';
+
+  // Log session end.
+  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, `session-end-${today}.jsonl`);
+    fs.appendFileSync(logFile, JSON.stringify({
+      ts: new Date().toISOString(),
+      sessionId,
+      reason,
+      cwd,
+    }) + '\n');
+  } catch { /* best-effort */ }
+
+  // Write a session note to the memory vault.
+  const vaultRoot = process.env.BIZAR_MEMORY_VAULT || path.join(os.homedir(), '.bizar_memory');
+  const projectName = path.basename(cwd) || 'unknown';
+  const date = new Date().toISOString().slice(0, 10);
+  const notePath = path.join(vaultRoot, 'projects', projectName, 'sessions', `${date}-${sessionId.slice(0, 8)}.md`);
+
+  try {
+    fs.mkdirSync(path.dirname(notePath), { recursive: true });
+    const noteBody = [
+      '---',
+      `title: Session ${sessionId.slice(0, 8)}`,
+      `createdAt: ${new Date().toISOString()}`,
+      `sessionId: ${sessionId}`,
+      `cwd: ${cwd}`,
+      `reason: ${reason}`,
+      'tags: [session, auto-generated]',
+      '---',
+      '',
+      `# Session ${sessionId.slice(0, 8)} (${date})`,
+      '',
+      `Session ended with reason: \`${reason}\`.`,
+      '',
+      `Working directory: \`${cwd}\``,
+      '',
+    ].join('\n');
+    fs.writeFileSync(notePath, noteBody, 'utf8');
+  } catch { /* best-effort */ }
+
+  process.stdout.write(JSON.stringify({}) + '\n');
+});

package/.claude/hooks/sessionstart-prime.mjs

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+// SessionStart — Bizar harness hook (Claude Code format).
+//
+// Claude Code has a single `SessionStart` event that fires for
+// "startup", "clear", and "resume" — we branch on `source` to apply
+// the appropriate priming for each branch.
+//
+// Claude Code stdin shape:
+//   {
+//     "session_id": "...",
+//     "transcript_path": "...",
+//     "cwd": "...",
+//     "hook_event_name": "SessionStart",
+//     "source": "startup" | "resume" | "clear"
+//   }
+//
+// Claude Code stdout shape:
+//   { "hookSpecificOutput": {
+//       "hookEventName": "SessionStart",
+//       "additionalContext": "note injected into the model's first turn"
+//   }}
+
+'use strict';
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node: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 = {}; }
+
+  // "startup" | "resume" | "clear" — default to "startup".
+  const source = String(input.source || 'startup');
+  const sessionId = String(input.session_id || '');
+  const isResume = source === 'resume';
+
+  // Log session lifecycle 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 = isResume
+      ? path.join(logDir, `task-resume-${today}.jsonl`)
+      : path.join(logDir, `task-start-${today}.jsonl`);
+    const line = JSON.stringify({
+      ts: new Date().toISOString(),
+      sessionId: sessionId || null,
+      source,
+      initial: isResume ? '' : 'bizar:sessionstart:' + source,
+    });
+    fs.appendFileSync(logFile, line + '\n');
+  } catch { /* best-effort */ }
+
+  const notes = isResume
+    ? [
+        'Bizar SessionStart (resume): re-read `.bizar/PROJECT.md` and `PROGRESS.md` before continuing.',
+        'Bizar SessionStart (resume): check `git log --oneline -10` to see what changed since the last run.',
+        // Claude Code compacts context automatically between resumes;
+        // compaction is opaque to the hook, so we warn unconditionally
+        // to remind the agent to verify scope.
+        'Bizar SessionStart (resume): WARNING — context may have been compacted since the last run; verify scope before continuing.',
+      ]
+    : [
+        'Bizar SessionStart: read `.bizar/PROJECT.md` (if present) before any routing decision.',
+        'Bizar SessionStart: if memory vault exists, run `bizar memory search "<topic>"` first.',
+        'Bizar SessionStart: Odin dispatches to subagents via `Agent` (sync) or via the `bizar-mcp` MCP server (async).',
+      ];
+
+  const out = {
+    hookSpecificOutput: {
+      hookEventName: 'SessionStart',
+      additionalContext: notes.join(' '),
+    },
+  };
+  process.stdout.write(JSON.stringify(out) + '\n');
+});

package/.claude/hooks/userpromptsubmit-tag.mjs

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+// UserPromptSubmit — Bizar harness hook (Claude Code format).
+//
+// Runs when the user submits a prompt. Lightly tags the prompt for
+// routing and emits a short routing hint for the model's next turn.
+//
+// Claude Code stdin shape:
+//   {
+//     "session_id": "...",
+//     "transcript_path": "...",
+//     "cwd": "...",
+//     "hook_event_name": "UserPromptSubmit",
+//     "user_prompt": "raw prompt text"
+//   }
+//
+// Claude Code stdout shape:
+//   { "hookSpecificOutput": {
+//       "hookEventName": "UserPromptSubmit",
+//       "additionalContext": "routing hint for the model"
+//   }}
+//
+// Behaviour:
+//   1. Append-only JSONL log of (timestamp, sessionId, promptLength).
+//   2. Branch on leading slash-command: empty / /team / /plow-through /
+//      /test / /validate / default-decompose.
+
+'use strict';
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node: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 prompt = String(input.user_prompt || '').trim();
+  const sessionId = String(input.session_id || '');
+
+  // 1. 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`);
+    const line = JSON.stringify({
+      ts: new Date().toISOString(),
+      sessionId: sessionId || null,
+      promptLength: prompt.length,
+    });
+    fs.appendFileSync(logFile, line + '\n');
+  } catch { /* best-effort */ }
+
+  // 2. Branch on leading slash-command (anchored to start of trimmed text).
+  let note;
+  if (prompt.length === 0) {
+    note = 'Bizar UserPromptSubmit: empty prompt — wait for actual user input.';
+  } else if (prompt.startsWith('/team')) {
+    note = 'Bizar UserPromptSubmit: /team — Odin will spawn a coordinated agent team. Confirm disjoint file scopes before dispatching.';
+  } else if (prompt.startsWith('/plow-through')) {
+    note = 'Bizar UserPromptSubmit: /plow-through — autonomous mode. Dispatch 2+ parallel agents when possible. Run /test before claiming done.';
+  } else if (prompt.startsWith('/test')) {
+    note = 'Bizar UserPromptSubmit: /test — auto-detects runner (jest/vitest/bun/pytest/cargo/go). Streams output to the user.';
+  } else if (prompt.startsWith('/validate')) {
+    note = 'Bizar UserPromptSubmit: /validate — runs 21-point health check on the Bizar install.';
+  } else {
+    note = 'Bizar UserPromptSubmit: if the request is complex, decompose into 2+ parallel subagent tasks (Odin) or spawn a /team.';
+  }
+
+  const out = {
+    hookSpecificOutput: {
+      hookEventName: 'UserPromptSubmit',
+      additionalContext: note,
+    },
+  };
+  process.stdout.write(JSON.stringify(out) + '\n');
+});