@polderlabs/bizar 10.7.2 → 10.10.0

package/.claude/hooks/advisor-context.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+/**
+ * Inject the recent parent transcript into review-oriented subagents.
+ * Reads newest-first with hard record and character caps.
+ */
+
+import { readFileSync } from 'node:fs';
+
+const clip = (value, limit) => value.length > limit ? `${value.slice(0, limit)} …[truncated]` : value;
+
+let input = {};
+try { input = JSON.parse(readFileSync(0, 'utf8') || '{}'); } catch { input = {}; }
+
+let rendered = [];
+try {
+  const lines = readFileSync(input.transcript_path, 'utf8').split('\n');
+  for (let index = lines.length - 1; index >= 0 && rendered.length < 60; index--) {
+    let record;
+    try { record = JSON.parse(lines[index]); } catch { continue; }
+    if (record.isSidechain || record.isMeta || !['user', 'assistant'].includes(record.type)) continue;
+    const content = record.message?.content;
+    if (typeof content === 'string') rendered.push(`${record.type}: ${clip(content, 3_000)}`);
+    else if (Array.isArray(content)) {
+      const text = content
+        .filter((block) => block?.type === 'text')
+        .map((block) => block.text || '')
+        .join('\n');
+      if (text) rendered.push(`${record.type}: ${clip(text, 3_000)}`);
+    }
+  }
+} catch { rendered = []; }
+
+rendered.reverse();
+let recent = rendered.join('\n\n---\n\n');
+if (recent.length > 30_000) recent = `…[older turns truncated]\n${recent.slice(-30_000)}`;
+const additionalContext = recent
+  ? `Review the caller's request against this recent parent-session evidence, not only its summary:\n\n<recent-conversation>\n${recent}\n</recent-conversation>`
+  : 'The parent transcript could not be reconstructed. State any context needed before making a strong claim.';
+
+process.stdout.write(JSON.stringify({
+  hookSpecificOutput: { hookEventName: 'SubagentStart', additionalContext },
+}) + '\n');

package/.claude/hooks/agent-grounding.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+/**
+ * Inject current-documentation and evidence requirements into every subagent.
+ *
+ * SubagentStart hooks cannot block creation, but their additionalContext is
+ * added before the agent's first prompt. The static agent verifier separately
+ * guarantees that every shipped Bizar agent can call WebSearch.
+ */
+'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 agentType = String(input.agent_type || 'unknown');
+  const context = [
+    `Bizar grounding policy for @${agentType}:`,
+    '- For any external API, library, framework, CLI, configuration format, or version-sensitive behavior, use WebSearch before proposing or attempting a solution.',
+    '- Search for the current official documentation, then open the exact relevant page with WebFetch. Prefer primary vendor documentation over blogs, snippets, memory, or examples.',
+    '- Do not guess an API shape and do not use trial-and-error as a substitute for reading documentation.',
+    '- If official documentation is unavailable or ambiguous, inspect authoritative source code, state the evidence gap, and keep conclusions qualified.',
+    '- For repository-local facts, inspect the actual files, tests, and tool output; do not manufacture an unnecessary web citation.',
+    '- Report the documentation or source evidence used in your handoff.',
+  ].join('\n');
+
+  process.stdout.write(`${JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'SubagentStart',
+      additionalContext: context,
+    },
+  })}\n`);
+});

package/.claude/hooks/content-style-guard.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+/**
+ * Human-facing text guard adapted from the upstream humanize hook.
+ * It checks Markdown/text writes, code comments, and commit/PR messages.
+ */
+
+const swaps = new Map([
+  ['delve', 'look at'],
+  ['leverage', 'use'],
+  ['utilize', 'use'],
+  ['plethora', 'many'],
+  ['myriad', 'many'],
+  ['tapestry', 'mix'],
+  ['showcase', 'show'],
+  ['transformative', 'major'],
+  ['unprecedented', 'new'],
+  ['streamline', 'simplify'],
+  ['seamlessly', 'remove the claim or explain how'],
+  ['game-changing', 'state the concrete effect'],
+  ['cutting-edge', 'latest'],
+]);
+const phrases = [
+  ['as an ai language model', 'remove the AI disclaimer'],
+  ['it is important to note', 'state the point directly'],
+  ['in conclusion', 'remove the stock conclusion'],
+  ['in summary', 'remove the stock summary'],
+  ['a testament to', 'state what it proves'],
+];
+
+function textFrom(input) {
+  const tool = String(input.tool_name || '');
+  const data = input.tool_input && typeof input.tool_input === 'object' ? input.tool_input : {};
+  if (/^(Write|Edit|MultiEdit)$/.test(tool)) {
+    const path = String(data.file_path || '');
+    if (!/\.(md|mdx|txt|rst)$/i.test(path)) return '';
+    return [data.content, data.new_string, ...(Array.isArray(data.edits) ? data.edits.map((edit) => edit?.new_string) : [])]
+      .filter((value) => typeof value === 'string')
+      .join('\n');
+  }
+  if (tool === 'Bash') {
+    const command = Array.isArray(data.command) ? data.command.join(' ') : String(data.command || '');
+    return /\b(?:git\s+commit|gh\s+pr)\b/i.test(command) ? command : '';
+  }
+  return '';
+}
+
+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 text = textFrom(input);
+  if (!text) return;
+
+  const notes = [];
+  const lower = text.toLowerCase();
+  for (const [word, replacement] of swaps) {
+    if (new RegExp(`\\b${word.replace('-', '[- ]')}\\b`, 'i').test(text)) notes.push(`"${word}" → ${replacement}`);
+  }
+  for (const [phrase, replacement] of phrases) {
+    if (lower.includes(phrase)) notes.push(`"${phrase}" → ${replacement}`);
+  }
+  if (notes.length) {
+    process.stdout.write(JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'deny',
+        permissionDecisionReason: `Humanize the text before publishing it: ${notes.join('; ')}.`,
+      },
+    }) + '\n');
+  }
+});

package/.claude/hooks/control-inbox.mjs

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+
+import { claimControlMessages } from '../../cli/control-store.mjs';
+
+let input = {};
+try {
+  let raw = '';
+  for await (const chunk of process.stdin) raw += chunk;
+  input = raw.trim() ? JSON.parse(raw) : {};
+} catch {
+  process.stdout.write(JSON.stringify({ continue: true }) + '\n');
+  process.exit(0);
+}
+
+const cwd = input.cwd || process.cwd();
+const messages = claimControlMessages(cwd, {
+  sessionId: input.session_id || '',
+  agentType: input.agent_type || input.agent_id || '',
+});
+
+if (messages.length === 0) {
+  process.stdout.write(JSON.stringify({ continue: true }) + '\n');
+  process.exit(0);
+}
+
+const context = [
+  '# Bizar control messages',
+  '',
+  'Process these durable messages in order. They were sent through OpenKan/Bizar.',
+  '',
+  ...messages.flatMap((message) => [
+    `## Message ${message.id}`,
+    `From: ${message.from}`,
+    message.taskId ? `Task: ${message.taskId}` : null,
+    '',
+    message.text,
+    '',
+  ].filter(Boolean)),
+].join('\n');
+
+process.stdout.write(JSON.stringify({
+  continue: true,
+  hookSpecificOutput: {
+    hookEventName: input.hook_event_name || 'SessionStart',
+    additionalContext: context,
+  },
+}) + '\n');
+

package/.claude/hooks/git-workflow-guard.mjs

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+/**
+ * Guard irreversible or externally visible Git/GitHub operations.
+ * Safe local inspection remains autonomous; history rewriting is denied;
+ * commits, pushes, PR mutations, releases, publishes, and deploys require
+ * a human confirmation in Claude Code.
+ */
+
+import { spawnSync } from 'node:child_process';
+
+const ALLOWED_COMMIT_TYPES = ['feat', 'fix', 'refactor', 'docs', 'style', 'test', 'build', 'chore'];
+const AI_ATTRIBUTION = /Claude-Session:|Co-Authored-By:\s*(?:Claude|Codex|ChatGPT|OpenAI|Gemini|Cursor|Copilot)|Generated with[^\n]*Claude Code|claude\.ai\/code\/session/i;
+
+function output(decision, reason) {
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: decision,
+      permissionDecisionReason: reason,
+    },
+  }) + '\n');
+}
+
+function commitMessage(command) {
+  const heredoc = command.match(/<<['"]?([A-Z_][A-Z0-9_]*)['"]?\s*\n([\s\S]*?)\n\1/i);
+  if (heredoc) return heredoc[2].trim();
+  const match = command.match(/(?:^|\s)(?:-m|--message)(?:=|\s+)(["'])([\s\S]*?)\1/);
+  return match?.[2]?.trim() ?? '';
+}
+
+function hasDesignChanges(cwd) {
+  const candidates = [
+    ['diff', '--name-only', 'origin/HEAD...HEAD'],
+    ['diff', '--name-only', '--cached'],
+  ];
+  for (const args of candidates) {
+    const result = spawnSync('git', args, { cwd, encoding: 'utf8', timeout: 5_000 });
+    if (result.status !== 0) continue;
+    if (result.stdout.split('\n').some((path) => /\.(astro|css|scss|sass|less|html|vue|svelte|tsx|jsx)$/.test(path))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+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 = {}; }
+  if (input.tool_name !== 'Bash') return;
+
+  const commandValue = input.tool_input?.command;
+  const command = Array.isArray(commandValue) ? commandValue.join(' ') : String(commandValue || '');
+  const cwd = String(input.cwd || process.cwd());
+
+  if (/\bgit\s+(?:-\S+\s+)*push\b[\s\S]*(?:--force(?:-with-lease|-if-includes)?|-f)\b/i.test(command)) {
+    output('deny', 'Force-pushing rewrites shared history. Create a follow-up commit or a new branch instead.');
+    return;
+  }
+  if (/\bgit\s+(?:-\S+\s+)*rebase\b/i.test(command)) {
+    output('deny', 'Rebasing rewrites history. Use a merge or follow-up commit unless the user explicitly changes project policy.');
+    return;
+  }
+  if (AI_ATTRIBUTION.test(command) && /\b(?:git\s+commit|gh\s+pr)\b/i.test(command)) {
+    output('deny', 'Remove AI-attribution trailers or generated-by links from the commit or pull-request text.');
+    return;
+  }
+
+  if (/\bgit\s+(?:-\S+\s+)*commit\b/i.test(command)) {
+    const message = commitMessage(command);
+    const subject = message.split('\n').find((line) => line.trim())?.trim() ?? '';
+    if (subject && !new RegExp(`^(?:${ALLOWED_COMMIT_TYPES.join('|')}):\\s+\\S`, 'i').test(subject)) {
+      output('deny', `Use a conventional commit subject: ${ALLOWED_COMMIT_TYPES.join(', ')} followed by ": description".`);
+      return;
+    }
+    output('ask', `Create this local commit${subject ? `: ${subject}` : ''}?`);
+    return;
+  }
+
+  if (/\bgh\s+pr\s+(?:create|edit)\b/i.test(command)) {
+    const hasBody = /(?:^|\s)(?:-b|--body)(?:=|\s)/.test(command);
+    const hasImage = /!\[[^\]]*\]\([^)]*\)|<img\b/i.test(command);
+    if (hasBody && !hasImage && hasDesignChanges(cwd)) {
+      output('deny', 'This branch changes visual files. Add before/after evidence to the pull-request body before publishing it.');
+      return;
+    }
+    output('ask', 'Publish or modify this pull request on GitHub?');
+    return;
+  }
+
+  if (/\bgh\s+pr\s+(?:merge|close|reopen)\b/i.test(command)) {
+    output('ask', 'Apply this pull-request state change on GitHub?');
+    return;
+  }
+  if (/\bgit\s+(?:-\S+\s+)*push\b/i.test(command)) {
+    output('ask', 'Push local commits to the remote repository?');
+    return;
+  }
+  if (/\b(?:gh\s+release\s+(?:create|upload|delete)|npm\s+publish|bun\s+publish|pnpm\s+publish|(?:vercel|wrangler|flyctl)\s+(?:deploy|publish))\b/i.test(command)) {
+    output('ask', 'This command publishes or deploys externally. Continue?');
+  }
+});

package/.claude/hooks/path-ownership-guard.mjs

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+// PreToolUse — deny edits outside the current task scope or inside a path
+// leased by a sibling worktree.
+
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+import { TaskLedger, resolveTaskDatabase } from '../../cli/task-ledger.mjs';
+
+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 || '');
+  if (!/^(Write|Edit|MultiEdit)$/.test(toolName)) {
+    process.stdout.write('{}\n');
+    return;
+  }
+  const filePath = String(input.tool_input?.file_path || '');
+  const cwd = resolve(String(input.cwd || process.cwd()));
+  if (!filePath) {
+    process.stdout.write('{}\n');
+    return;
+  }
+
+  const dbPath = resolveTaskDatabase(cwd);
+  if (!existsSync(dbPath)) {
+    process.stdout.write('{}\n');
+    return;
+  }
+
+  const top = spawnSync('git', ['rev-parse', '--show-toplevel'], {
+    cwd,
+    encoding: 'utf8',
+  });
+  const worktrees = spawnSync('git', ['worktree', 'list', '--porcelain'], {
+    cwd,
+    encoding: 'utf8',
+  });
+  const repoRoot = top.status === 0 && top.stdout.trim()
+    ? resolve(top.stdout.trim())
+    : cwd;
+  const mainWorktree = worktrees.status === 0
+    ? /^worktree (.+)$/m.exec(worktrees.stdout)?.[1]
+    : null;
+  const requireTask = Boolean(
+    mainWorktree && resolve(mainWorktree) !== repoRoot,
+  );
+
+  let ledger;
+  try {
+    ledger = new TaskLedger({ dbPath });
+    const authorization = ledger.authorizeEdit({
+      cwd,
+      filePath,
+      repoRoot,
+      requireTask,
+    });
+    if (!authorization.allowed) {
+      process.stdout.write(JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: 'PreToolUse',
+          permissionDecision: 'deny',
+          permissionDecisionReason:
+            `Bizar path ownership: ${authorization.reason} for ` +
+            `${authorization.path || filePath}` +
+            `${authorization.taskId ? ` (task ${authorization.taskId})` : ''}.`,
+        },
+      }) + '\n');
+      return;
+    }
+    process.stdout.write('{}\n');
+  } catch (error) {
+    process.stdout.write(JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'deny',
+        permissionDecisionReason:
+          `Bizar path ownership: LEDGER_UNAVAILABLE (${error.message || String(error)}).`,
+      },
+    }) + '\n');
+  } finally {
+    try { ledger?.close(); } catch { /* process is exiting */ }
+  }
+});

package/.claude/hooks/precompact-priorities.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+cat <<'PRIORITIES'
+<priority-preservation-instructions>
+Preserve unanswered or partially answered user questions; confirmed root causes
+and ruled-out hypotheses; exact errors, numbers, IDs, commit SHAs, and paths;
+critical versus referenced files; subagent findings as primary evidence; chosen
+tradeoffs and their rejected alternatives; current validation results; remaining
+work; and all explicit human-approval boundaries. Drop filler and duplicated
+tool output before any of those items.
+</priority-preservation-instructions>
+PRIORITIES

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

@@ -29,7 +29,7 @@ process.stdin.on('end', () => {
   // `packages/sdk/src/dangerous-patterns.ts` — kept inline so this hook
   // works without importing the SDK at runtime.
   // For the `rm` family, the path argument must be EXACTLY the dangerous
-  // root — not a prefix of a deeper path. `/home/drb0rk/projects/foo.mjs`
+  // root — not a prefix of a deeper path. `/home/user/projects/foo.mjs`
   // is a legitimate delete, not "wipe home directory". The old patterns
   // matched any path STARTING with `/home` and so blocked every file
   // delete under the project root (false positive).
@@ -75,13 +75,6 @@ process.stdin.on('end', () => {
     }
   }
 
-  // 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');
-});
+  // No dangerous pattern: defer to Claude Code permissions/auto-mode.
+  process.stdout.write('{}\n');
+});

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

@@ -27,7 +27,7 @@
 
 'use strict';
 
-import { readFileSync, existsSync, readdirSync } from 'node:fs';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -82,8 +82,8 @@ function logLifecycle(cwd, sessionId, source) {
     const dir = join(cwd, HOOK_LOG_DIR);
     const today = new Date().toISOString().slice(0, 10);
     const logFile = join(dir, `task-start-${today}.jsonl`);
-    require('node:fs').mkdirSync(dir, { recursive: true });
-    require('node:fs').appendFileSync(
+    mkdirSync(dir, { recursive: true });
+    appendFileSync(
       logFile,
       JSON.stringify({
         ts: new Date().toISOString(),
@@ -184,8 +184,14 @@ function startupBriefing(cwd, featureBrief, recentCommits, projectLine, progress
     }
   }
   if (progressLast) lines.push(`- Progress: ${progressLast}.`);
-  lines.push('- Rules: AGENT_BASELINE.md §4b thinking defaults active; WIP=1 honored.');
+  lines.push('- Rules: every request routes through Bizar agents; external APIs require current official docs via WebSearch/WebFetch; WIP=1 honored.');
   lines.push('- First move: confirm scope, then read PROGRESS.md and feature_list.json.');
+  // Default-first-stop hint when nothing is active yet.
+  if (featureBrief && featureBrief.active.length === 0) {
+    lines.push(
+      '- Default pipeline: user → @mike → Phase 1 (@greg + @oscar research) → Phase 2 (@paul plan, @linda audit) → Phase 3 (@todd + @karen, with @ria when UI scope; then @linda post-impl + @kevin E2E + @todd test gate; final atomic commit by @steve). Trivial asks skip straight to @brenda.',
+    );
+  }
   return lines.join('\n');
 }
 

package/.claude/hooks/simplify-guard.mjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+/**
+ * Require one successful simplify skill run for every commit attempt.
+ * The marker is stored in the worktree's Git directory and consumed once.
+ */
+
+import { closeSync, existsSync, openSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+function marker(cwd) {
+  const result = spawnSync('git', ['rev-parse', '--path-format=absolute', '--git-dir'], {
+    cwd,
+    encoding: 'utf8',
+    timeout: 5_000,
+  });
+  const gitDir = result.status === 0 ? result.stdout.trim() : '';
+  return gitDir ? join(gitDir, 'bizar-simplify.ok') : null;
+}
+
+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 cwd = String(input.cwd || process.cwd());
+  const mark = marker(cwd);
+  if (!mark) return;
+
+  if (input.hook_event_name === 'PostToolUse' && input.tool_name === 'Skill' && input.tool_input?.skill === 'simplify') {
+    closeSync(openSync(mark, 'w'));
+    return;
+  }
+  if (input.hook_event_name !== 'PreToolUse' || input.tool_name !== 'Bash') return;
+
+  const commandValue = input.tool_input?.command;
+  const command = Array.isArray(commandValue) ? commandValue.join(' ') : String(commandValue || '');
+  if (!/\bgit\s+(?:-\S+\s+)*commit\b/i.test(command)) return;
+  if (existsSync(mark)) {
+    rmSync(mark, { force: true });
+    return;
+  }
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: 'deny',
+      permissionDecisionReason: 'Run /simplify on the staged diff, apply any justified cleanup, rerun tests, then retry the commit.',
+    },
+  }) + '\n');
+});

package/.claude/hooks/telemetry.mjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+/**
+ * Local-only session correlation and rejected-action feedback telemetry.
+ * No network calls and no note-vault integration.
+ */
+
+import { createHash, randomUUID } from 'node:crypto';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const categories = [
+  ['wrong_target', /\b(?:wrong (?:file|repo|branch|directory)|not that|i meant)\b/i],
+  ['tool_steering', /\b(?:use|prefer)\b.*\b(?:rg|grep|gh|bun|npm|web search)\b|\binstead of\b/i],
+  ['scope_drift', /\b(?:only|don'?t touch|don'?t change|overengineer|no need)\b/i],
+  ['verify_first', /\b(?:check|read|verify).*(?:first|docs|code|source)\b/i],
+  ['rule_setting', /\b(?:never|always|from now on|next time)\b/i],
+  ['retry_request', /\b(?:try again|redo|retry|once more)\b/i],
+];
+
+function recentReject(path) {
+  if (!path || !existsSync(path)) return null;
+  const lines = readFileSync(path, 'utf8').split('\n').slice(-30).reverse();
+  for (const line of lines) {
+    let entry;
+    try { entry = JSON.parse(line); } catch { continue; }
+    const result = entry.toolUseResult;
+    if (result?.interrupted) return result.name || 'unknown';
+    const content = entry.message?.content;
+    if (Array.isArray(content) && content.some((block) => block?.type === 'tool_result' && block.is_error)) {
+      return result?.name || 'unknown';
+    }
+  }
+  return null;
+}
+
+let input = {};
+try { input = JSON.parse(readFileSync(0, 'utf8') || '{}'); } catch { input = {}; }
+const cwd = String(input.cwd || process.cwd());
+const stateDir = join(homedir(), '.config', 'bizar', 'telemetry');
+mkdirSync(stateDir, { recursive: true });
+const projectId = createHash('sha256').update(cwd).digest('hex').slice(0, 12);
+const chatFile = join(stateDir, `chat-${projectId}`);
+
+if (input.hook_event_name === 'SessionStart') {
+  const chatId = process.env.BIZAR_NEW_CHAT === '1' || !existsSync(chatFile)
+    ? randomUUID()
+    : readFileSync(chatFile, 'utf8').trim();
+  writeFileSync(chatFile, chatId, { mode: 0o600 });
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'SessionStart',
+      additionalContext: `Bizar telemetry correlation id: ${chatId}.`,
+    },
+  }) + '\n');
+} else if (input.hook_event_name === 'UserPromptSubmit') {
+  const prompt = String(input.prompt || input.user_prompt || '');
+  const tool = recentReject(input.transcript_path);
+  if (!tool || !prompt) process.exit(0);
+  const category = categories.find(([, pattern]) => pattern.test(prompt))?.[0] || 'uncategorized';
+  appendFileSync(join(stateDir, 'reject-feedback.jsonl'), JSON.stringify({
+    timestamp: new Date().toISOString(),
+    sessionId: input.session_id || null,
+    chatId: existsSync(chatFile) ? readFileSync(chatFile, 'utf8').trim() : null,
+    tool,
+    category,
+    excerpt: prompt.slice(0, 200),
+  }) + '\n');
+}

package/.claude/hooks/thinking-route.mjs

@@ -253,21 +253,19 @@ process.stdin.on('end', () => {
     { cmd: '/plow-through',    note: 'Autonomous mode — dispatch 2+ parallel agents when possible; run /test before claiming done.' },
     { cmd: '/pr-review',       note: 'Review a PR — read the diff, score against the rubric, write findings.' },
     { cmd: '/setup-provider',  note: 'Configure a provider (Anthropic / OpenRouter / Bedrock / Vertex / Foundry) for this Bizar install.' },
-    { cmd: '/validate',        note: 'Runs the 21-point Bizar install health check.' },
-    { cmd: '/team',            note: 'Odin spawns a coordinated team — confirm disjoint file scopes before dispatch.' },
+    { cmd: '/validate',        note: 'Runs the Bizar install health check.' },
+    { cmd: '/team',            note: 'Mike spawns a coordinated team — confirm disjoint file scopes before dispatch.' },
     { cmd: '/plan',            note: 'Enter plan mode — no edits until ExitPlanMode; write the plan file first.' },
     { cmd: '/audit',           note: 'Run Forseti-style code-review audit on the current diff.' },
     { cmd: '/test',            note: 'Auto-detects runner (jest/vitest/bun/pytest/cargo/go); streams output.' },
     { cmd: '/explain',         note: 'Read-only explanation — dispatch susan (or general-purpose) to look up the answer with file:line refs.' },
-    { cmd: '/visual-plan',     note: 'Toggle the Bizar visual plan canvas or check its status.' },
     { cmd: '/tailscale-serve', note: 'Authenticate Tailscale and configure `tailscale serve` for a local port.' },
-    { cmd: '/bizar',           note: 'Bizar SDK passthrough — `npx bizar <subcommand>` (memory, plan, loops, graph).' },
-    { cmd: '/init',            note: 'Run `bizar init` to scaffold memory vault, project context, and graph index in this repo.' },
+    { cmd: '/bizar',           note: 'Bizar harness orientation — guarded workflows, plans, loops, graph, cost, and claims.' },
+    { cmd: '/init',            note: 'Run `bizar init` to scaffold project context and graph state in this repo.' },
     { cmd: '/cron',            note: 'Manage scheduled tasks via the Bizar SDK cron API — list / add / remove / pause.' },
     { cmd: '/spec',            note: 'Generate a 5-section spec (Goal, Scope, DoD, Out-of-Scope, Open Questions); checks for duplicates first.' },
-    { cmd: '/sprint',          note: 'Read the next goal from `.bizar/PROGRESS.md` and pre-fill `templates/sprint-contract.md`.' },
-    { cmd: '/goal',            note: 'Add or update a long-term goal — Heimdall writes it to `.bizar/GOALS.md`.' },
-    { cmd: '/learn',           note: 'Heimdall reviews recent instincts + session transcripts and writes a self-improvement entry.' },
+    { cmd: '/sprint',          note: 'Read a feature from root `PROGRESS.md` and pre-fill `templates/sprint-contract.md`.' },
+    { cmd: '/learn',           note: 'Review bounded instincts and decisions with explicit operator approval.' },
   ];
 
   let slashNote = '';
@@ -311,4 +309,4 @@ process.stdin.on('end', () => {
     },
   }) + '\n');
   process.exit(0);
-});
+});