@polderlabs/bizar 6.1.0 → 6.2.1

package/config/commands/team.md

@@ -0,0 +1,124 @@
+---
+description: Spawn a Cline agent team — coordinate Thor (M2.7), Tyr (M3), Mimir (research), and Hermod (git) to complete a complex mission end-to-end.
+agent: odin
+---
+# Team — Spawn a Cline Agent Team
+
+The `/team` command spawns a **coordinated agent team** for a complex,
+multi-step mission. The lead agent coordinates teammates; each teammate
+owns a disjoint scope; results are synthesized and committed.
+
+## When to Use `/team`
+
+Use `/team` for any non-trivial mission that benefits from **parallel
+work + explicit coordination**. Examples:
+
+- **Refactor** — split a module across Thor (M2.7) and Tyr (M3) in parallel.
+- **Multi-feature build** — new feature A (Thor) + new feature B (Tyr) + tests (Heimdall).
+- **Research + implementation** — Mimir researches, Thor implements, Forseti audits.
+- **Migration / upgrade** — Hermod handles the git/PR lifecycle while Thor/Tyr write code.
+- **Bug hunt** — Mimir traces the data flow while Tyr writes the fix and tests.
+
+Do NOT use `/team` for trivial single-file edits or single-question
+clarifications. Use `@heimdall` directly for those.
+
+## Default Team Composition
+
+If the user does not specify a team composition, spawn this default:
+
+| Role          | Agent   | Model             | Job                                   |
+|---------------|---------|-------------------|---------------------------------------|
+| Lead          | @odin   | minimax/MiniMax-M3   | Coordinate, synthesize, gate quality  |
+| Implementer 1 | @thor   | minimax/MiniMax-M2.7 | Moderate-complexity implementation   |
+| Implementer 2 | @tyr    | minimax/MiniMax-M3   | Complex / cross-cutting work         |
+| Researcher    | @mimir  | 9router/kr/auto  | Codebase research, pattern discovery  |
+| Git ops       | @hermod | minimax/MiniMax-M2.7 | Branch, commit, push, PR             |
+| Reviewer      | @forseti| minimax/MiniMax-M3   | Audit plan + final output            |
+
+You can swap or remove any of these — but always keep at least one
+implementer and a reviewer.
+
+## Protocol (How Odin Runs a `/team` Invocation)
+
+1. **Read `.bizar/PROJECT.md`** if it exists. Factor the project
+   description into the team mission.
+2. **Read `bizar memory status`**. If the vault is reachable, run
+   `bizar memory search "<topic>"` for prior context on the mission.
+3. **Decompose** the mission into disjoint work items. Each item
+   names:
+   - The agent that owns it
+   - The file scope (paths/globs)
+   - The deliverable (a function, a test, a commit, a doc)
+   - The exit signal ("done when X is committed")
+4. **Launch in parallel** — use `bizar_spawn_team` with the mission
+   string. Or, if you prefer synchronous control, launch 2+ `task`
+   calls in a **single message** to drive Thor and Tyr directly.
+5. **Monitor** — while the team runs, return control to the user.
+   The team runs asynchronously. Use `bizar_status` to check progress
+   only when the user asks.
+6. **Synthesize** — when teammates report back, gate through @forseti
+   (audit) and @hermod (commit/push). Then report the final outcome
+   to the user with file:line references.
+
+## Pre-Dispatch Checklist (MANDATORY)
+
+- [ ] Each teammate has a **disjoint file scope** — no two agents
+       edit the same file or directory
+- [ ] Lockfiles, `package.json`, root configs, `tsconfig.json`,
+       `vite.config.*`, `Dockerfile`, CI configs are assigned to ONE
+       agent or marked READ-ONLY for everyone else
+- [ ] No subagent has both `bash: allow` AND a write-level git task
+       in the same batch — Hermod is the only git writer
+- [ ] Each teammate's scope is named in plain English
+- [ ] You have prepended the **Sibling-Awareness Block** to every
+       prompt — see Odin baseline, "Parallel Dispatch Coordination"
+- [ ] You have called `bizar memory status` and confirmed the vault
+       is reachable
+
+## Example Mission Strings
+
+**Refactor a module:**
+```
+Refactor src/api/auth.ts into a clean module: extract JWT validation
+into src/auth/jwt.ts, rate-limiting into src/auth/rate-limit.ts, and
+keep the public surface stable. Add tests for each new module. Update
+docs/architecture.md with the new module map. Do not change the HTTP
+route handlers.
+```
+
+**Multi-feature build:**
+```
+Add a kanban board: (1) Thor — backend API at /api/tasks with CRUD
+endpoints and SQLite persistence. (2) Tyr — frontend React component
+in src/components/Kanban.tsx with 5 columns. (3) Heimdall — write
+the OpenAPI spec at docs/api/tasks.yaml. (4) Hermod — open a PR
+named feat/kanban-board.
+```
+
+**Bug hunt:**
+```
+Mimir — trace the data flow from POST /api/checkout through to the
+Stripe webhook handler; find any place where the order status is
+written before the payment is confirmed. Tyr — write a regression
+test that reproduces the race. Thor — fix the bug. Forseti —
+audit the fix for completeness. Hermod — commit + push.
+```
+
+## Tool Reference
+
+- `bizar_spawn_team` — spawn a full team in one call (lead + mission)
+- `bizar_spawn_background` — spawn a single background agent
+- `bizar_status` — list all running background instances
+- `bizar_collect` — block until an instance completes (use sparingly)
+- `bizar_kill` — terminate an instance
+
+## Failure Modes
+
+- **Two agents write the same file** — STOP, revert one branch, reassign.
+- **One agent stalls** — call `bizar_kill`, route the remaining scope
+  to another agent.
+- **Tests fail after team work** — dispatch @thor to investigate; do
+  not paper over the failure.
+- **Git conflict** — route to @hermod for `git rebase` / merge resolution.
+- **A teammate goes silent** — call `bizar_status` for a status report;
+  if dead, kill and re-spawn with a fresh prompt.

package/config/commands/test.md

@@ -0,0 +1,60 @@
+---
+description: Run the project's test suite via the Bizar test gate. Auto-detects jest/vitest/bun/pytest/cargo/go. Exits non-zero on failure.
+agent: thor
+---
+# /test — Run the Project's Test Suite
+
+The `/test` command is a thin wrapper around `bizar test-gate`. It
+auto-detects the project's test runner and runs the full suite.
+
+## What It Does
+
+1. Detects the project stack (one of: npm, pytest, cargo, go).
+2. Runs the matching test command:
+   - `package.json` present → `npm test`
+   - `pyproject.toml` present → `pytest`
+   - `Cargo.toml` present → `cargo test`
+   - `go.mod` present → `go test ./...`
+3. Streams the test output to the user.
+4. Exits non-zero on test failures.
+
+## Exit Codes
+
+| Code | Meaning                          |
+|------|----------------------------------|
+| 0    | All tests passed                 |
+| 1    | Tests failed                     |
+| 2    | No test runner detected          |
+
+## How to Use
+
+Invoke `/test` (no arguments) from the project root. The test gate
+inspects the current directory and picks the right runner.
+
+To run a specific Bizar test scope instead, you can pass arguments
+to `/test`. The arguments are forwarded to the underlying runner:
+
+- `/test plugins/bizar` — run only the Bizar plugin tests (bun)
+- `/test --testPathPattern=auth` — pass a flag to the runner
+
+## When to Use
+
+- After any non-trivial code change
+- Before committing (`@hermod` should always run `/test` first)
+- As the final step of a `/team` mission — gate quality with tests
+
+## Common Patterns
+
+- **Post-implementation gate** — after Thor and Tyr finish their
+  parallel work, dispatch `@thor` to run `/test`. If failures, fix
+  and re-run.
+- **PR check** — run `/test` in CI before merging.
+- **Debug a flaky test** — run `/test` twice; if the second run
+  passes, the test is order-dependent (fix or quarantine).
+
+## Related
+
+- `bizar test-gate` — the underlying CLI command
+- `bizar doctor` — checks the Bizar install itself (not project tests)
+- `make check` — typecheck + tests (full pipeline, dev only)
+- `make e2e` — Bizar plugin end-to-end (dev only)

package/config/commands/validate.md

@@ -0,0 +1,66 @@
+---
+description: Validate the Bizar install end-to-end — cline.json parses, plugin entry resolves, all 14 agent files are installed, all skills/rules/hooks/commands are in place, provider config is sane, and the 9router gateway is reachable.
+agent: heimdall
+---
+# /validate — Validate the Bizar Install
+
+The `/validate` command runs `bizar doctor` with the full check
+battery. It is the fastest way to confirm the install is healthy
+and Cline will see every Bizar component on the next session start.
+
+## What It Checks
+
+1. **cline-reachable** — `cline --version` exits 0.
+2. **cline-config-valid** — `~/.cline/cline.json` parses as JSON.
+3. **plugin-entry-present** — `cline.json` has a Bizar plugin entry.
+4. **plugin-path-resolves** — the plugin path on disk actually exists.
+5. **agent-files-installed** — all 14 agent files in `~/.cline/agents/`
+   (odin, vor, frigg, quick, mimir, heimdall, hermod, thor, baldr,
+   tyr, vidarr, forseti, semble-search, agent-browser).
+6. **tools-available** — at least one of `headroom`, `semble`, `skills`
+   is on PATH.
+7. **provider-config-sanity** — `provider.9router` (preferred) or
+   `provider.minimax` (legacy) has at least one sane model entry.
+8. **9router-reachable** — 9Router gateway responds at
+   `http://localhost:20128/api/health` (lenient — warn, don't fail).
+9. **slash-commands-installed** — all Bizar slash commands
+   (`/audit`, `/explain`, `/init`, `/learn`, `/plan`, `/plow-through`,
+   `/pr-review`, `/tailscale-serve`, `/visual-plan`, `/bizar`,
+   `/team`, `/test`, `/validate`) are present in `~/.cline/commands/`.
+10. **skills-installed** — every subdir of `config/skills/` is
+    mirrored to `~/.cline/skills/`.
+11. **rules-installed** — every `.md` in `config/rules/` is mirrored
+    to `~/.cline/rules/`.
+12. **hooks-installed** — `config/hooks/` is mirrored to
+    `~/.cline/hooks/`.
+
+## How to Use
+
+Invoke `/validate` (no arguments) from anywhere. It is read-only and
+never modifies the system.
+
+If any check fails, the user should run `bizar update` to refresh the
+install, or `bizar repair` to fix common issues.
+
+## Output
+
+Each check prints ✓ or ✗ with a one-line message. The summary line
+shows the total pass/fail count. Exits non-zero if any check fails.
+
+For machine-readable output, the user can run `bizar doctor --json`
+directly.
+
+## When to Use
+
+- After a manual config edit — confirm nothing broke.
+- Before a `/team` mission — confirm the install is healthy so the
+  team has all the tools it needs.
+- After `bizar install` or `bizar update` — the install already
+  calls doctor, but a manual re-run is cheap.
+- When a user asks "why is cline misbehaving?" — start here.
+
+## Related
+
+- `bizar doctor` — the underlying CLI command
+- `bizar update` — refreshes the install (re-runs syncConfigExtras)
+- `bizar repair` — fixes common issues (stale symlinks, version drift)

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');
+});