@polderlabs/bizar 10.12.0 → 10.12.2

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

@@ -10,7 +10,6 @@ import { spawnSync } from 'node:child_process';
 import { findGitCommand } from './git-command-parser.mjs';
 
 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;
 const GH_GLOBAL_OPTION = String.raw`(?:(?:-R|--repo|--hostname)\s+(?:"[^"]*"|'[^']*'|\S+)|--(?:help|version))`;
 
 function commandPattern(program, globalOption, subcommand) {
@@ -82,19 +81,24 @@ process.stdin.on('end', () => {
     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) && (commit || hasGhCommand(command, 'pr', '\\w+'))) {
-    output('deny', 'Remove AI-attribution trailers or generated-by links from the commit or pull-request text.');
-    return;
-  }
-
   if (commit) {
     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;
+    // F-145 loosening: subject-shape check is a soft warning attached to
+    // the same hook response as the `ask` decision (the dispatcher
+    // expects one JSON line per leaf).
+    const conventional = subject && !new RegExp(`^(?:${ALLOWED_COMMIT_TYPES.join('|')})(\\([^)]+\\))?:\\s+\\S`, 'i').test(subject);
+    const payload = {
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'ask',
+        permissionDecisionReason: `Create this local commit${subject ? `: ${subject}` : ''}?`,
+      },
+    };
+    if (conventional) {
+      payload.hookSpecificOutput.additionalContext = `Conventional commit hint: prefer "type: subject" (types: ${ALLOWED_COMMIT_TYPES.join(', ')}).`;
     }
-    output('ask', `Create this local commit${subject ? `: ${subject}` : ''}?`);
+    process.stdout.write(`${JSON.stringify(payload)}\n`);
     return;
   }
 

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

@@ -1,6 +1,11 @@
 #!/usr/bin/env node
 // PreToolUse — deny edits outside the current task scope or inside a path
 // leased by a sibling worktree.
+//
+// F-145 loosening: removed the per-edit `git worktree list --porcelain`
+// fork and the `requireTask` gate. The hook is now a single in-memory
+// ledger lookup. Edits inside the project are allowed by default; only
+// an active lease held by another agent on the same path denies.
 
 import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
@@ -36,20 +41,11 @@ process.stdin.on('end', () => {
   const top = spawnSync('git', ['rev-parse', '--show-toplevel'], {
     cwd,
     encoding: 'utf8',
-  });
-  const worktrees = spawnSync('git', ['worktree', 'list', '--porcelain'], {
-    cwd,
-    encoding: 'utf8',
+    timeout: 3_000,
   });
   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 {
@@ -58,7 +54,7 @@ process.stdin.on('end', () => {
       cwd,
       filePath,
       repoRoot,
-      requireTask,
+      requireTask: false,
     });
     if (!authorization.allowed) {
       process.stdout.write(JSON.stringify({

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

@@ -27,12 +27,13 @@
 //   }}
 //
 // Behaviour:
-//   1. Block writes to .env, .envrc, secrets/, credentials/, node_modules/.
-//      .env.example/.sample/.template are explicitly allowed (docs, not
-//      secrets). Lockfiles are allowed — they're package-manager output.
-//   2. Always return a small context line for the next AI decision.
-//      (console.log / debugger / .only() are enforced by `make clean-check`
-//      at commit time — duplicate-warning here adds noise without safety.)
+//   Block writes to .env, .envrc, secrets/, credentials/, node_modules/.
+//   .env.example/.sample/.template are explicitly allowed (docs, not
+//   secrets). Lockfiles are allowed — they're package-manager output.
+//
+//   F-145: removed the always-on `additionalContext` line. Every Write/
+//   Edit was emitting a tool/path note into the model's context — pure
+//   noise. The model already knows what tool and path it called.
 
 'use strict';
 
@@ -47,25 +48,21 @@ process.stdin.on('end', () => {
   const toolInput =
     (input.tool_input && typeof input.tool_input === 'object') ? input.tool_input : {};
 
-  // Extract the "file_path" mapped onto Claude Code's Write/Edit/MultiEdit
-  // shapes. Content scanning was removed (debug artifacts are enforced at
-  // commit time via `make clean-check`, not write time).
   let filePath = '';
-  if (toolName === 'Write') {
-    filePath = String(toolInput.file_path || '');
-  } else if (toolName === 'Edit') {
-    filePath = String(toolInput.file_path || '');
-  } else if (toolName === 'MultiEdit') {
+  if (/^(Write|Edit|MultiEdit)$/.test(toolName)) {
     filePath = String(toolInput.file_path || '');
   } else {
     process.stdout.write('{}\n');
     return;
   }
 
+  if (!filePath) {
+    process.stdout.write('{}\n');
+    return;
+  }
+
   const lowerPath = filePath.toLowerCase();
 
-  // 1. Hard block — secrets + protected paths. .env.example/.sample/.template
-  //    and all lockfiles are explicitly allowed (docs / package-manager output).
   const allowed = [
     /\/\.env\.(example|sample|template|dist)$/i,
     /\/(package-lock|yarn|pnpm-lock|bun)\.lock\w*$/i,
@@ -80,38 +77,19 @@ process.stdin.on('end', () => {
     /\/node_modules\//,
   ];
 
-  const isAllowed = filePath && allowed.some((re) => re.test(lowerPath));
-  let blockReason = '';
-  if (filePath && !isAllowed && blocked.some((re) => re.test(lowerPath))) {
-    blockReason = filePath;
-  }
-
-  if (blockReason) {
+  const isAllowed = allowed.some((re) => re.test(lowerPath));
+  if (!isAllowed && blocked.some((re) => re.test(lowerPath))) {
     const out = {
       hookSpecificOutput: {
         hookEventName: 'PreToolUse',
         permissionDecision: 'deny',
         permissionDecisionReason:
-          `Bizar PreToolUse: refusing to write to protected path '${blockReason}' (Bizar harness policy).`,
+          `Bizar PreToolUse: refusing to write to protected path '${filePath}' (Bizar harness policy).`,
       },
     };
     process.stdout.write(JSON.stringify(out) + '\n');
     return;
   }
 
-  // 2. Always add a small context line for the AI's next decision.
-  //    Debug-artifact warnings (console.log / debugger / .only()) live in
-  //    `make clean-check` — duplicating them here would add noise without
-  //    adding safety (they're caught at commit time, not write time).
-  const notes = [
-    `Bizar PreToolUse: tool=${toolName || 'unknown'} path=${filePath || '(no path)'}`,
-  ];
-
-  const out = {
-    hookSpecificOutput: {
-      hookEventName: 'PreToolUse',
-      additionalContext: notes.join(' '),
-    },
-  };
-  process.stdout.write(JSON.stringify(out) + '\n');
+  process.stdout.write('{}\n');
 });

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

@@ -17,7 +17,8 @@ import { join } from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { findGitCommand } from './git-command-parser.mjs';
 
-const FRESHNESS_WINDOW_MS = 30 * 60 * 1000;
+const FRESHNESS_WINDOW_MS = 4 * 60 * 60 * 1000;
+const TRIVIAL_PATH = /^(?:CHANGELOG\.md|package(-lock)?\.json|.*\/package(-lock)?\.json|\.claude-plugin\/plugin\.json|packages\/[^/]+\/src\/version\.ts)$/;
 
 function marker(cwd) {
   const result = spawnSync('git', ['rev-parse', '--path-format=absolute', '--git-dir'], {
@@ -50,6 +51,18 @@ function readMarker(path) {
   }
 }
 
+function isTrivialDiff(cwd) {
+  const result = spawnSync('git', ['diff', '--cached', '--name-only'], {
+    cwd,
+    encoding: 'utf8',
+    timeout: 5_000,
+  });
+  if (result.status !== 0) return false;
+  const paths = result.stdout.split('\n').map((p) => p.trim()).filter(Boolean);
+  if (paths.length === 0) return false;
+  return paths.every((p) => TRIVIAL_PATH.test(p));
+}
+
 let raw = '';
 process.stdin.setEncoding('utf8');
 process.stdin.on('data', (chunk) => { raw += chunk; });
@@ -70,6 +83,9 @@ process.stdin.on('end', () => {
   const commandValue = input.tool_input?.command;
   const command = Array.isArray(commandValue) ? commandValue.join(' ') : String(commandValue || '');
   if (!findGitCommand(command, 'commit')) return;
+
+  if (isTrivialDiff(cwd)) return;
+
   const approval = readMarker(mark);
   const age = approval ? Date.now() - approval.timestamp : Infinity;
   const fingerprint = stagedFingerprint(cwd);

package/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "bizar-harness",
   "displayName": "Bizar Harness",
-  "version": "10.12.0",
+  "version": "10.12.2",
   "description": "Guarded multi-agent workflows for Claude Code with a single orchestrator, durable workflow state, and explicit human approval boundaries.",
   "author": {
     "name": "Polderlabs"

package/cli/commands/hook.mjs

@@ -16,8 +16,9 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
 const HOOK_ROOT = resolve(PACKAGE_ROOT, '.claude', 'hooks');
 const PRETOOL_SAFETY_LEAVES = new Set([
-  'pretooluse-editwrite', 'path-ownership-guard', 'content-style-guard',
-  'pretooluse-bash', 'git-workflow-guard', 'simplify-guard', 'agent-model-guard',
+  'pretooluse-editwrite', 'path-ownership-guard',
+  'pretooluse-bash', 'git-workflow-guard',
+  'agent-model-guard',
 ]);
 
 export const HOOK_PROGRAMS = Object.freeze({
@@ -65,16 +66,13 @@ export const EVENT_CHAINS = Object.freeze({
   'pre-tool-use': Object.freeze([
     'pretooluse-editwrite',
     'path-ownership-guard',
-    'content-style-guard',
     'pretooluse-bash',
     'git-workflow-guard',
-    'simplify-guard',
   ]),
   'permission-request': Object.freeze(['permission-request-policy']),
   'post-tool-use': Object.freeze([
     'posttooluse-editwrite',
     'auto-instinct',
-    'simplify-guard',
   ]),
   'post-tool-use-failure': Object.freeze(['post-tool-use-failure-policy']),
   'subagent-start': Object.freeze([
@@ -224,10 +222,10 @@ export function selectEventChain(eventKey, input = '') {
 
   if (eventKey === 'pre-tool-use') {
     if (/^(Write|Edit|MultiEdit)$/.test(toolName)) {
-      return ['pretooluse-editwrite', 'path-ownership-guard', 'content-style-guard'];
+      return ['pretooluse-editwrite', 'path-ownership-guard'];
     }
     if (toolName === 'Bash') {
-      return ['pretooluse-bash', 'git-workflow-guard', 'content-style-guard', 'simplify-guard'];
+      return ['pretooluse-bash', 'git-workflow-guard'];
     }
     if (toolName === 'Agent') return ['agent-model-guard'];
     return [];
@@ -236,7 +234,6 @@ export function selectEventChain(eventKey, input = '') {
   if (eventKey === 'post-tool-use') {
     if (/^(Write|Edit|MultiEdit)$/.test(toolName)) return ['posttooluse-editwrite'];
     if (toolName === 'Bash') return ['auto-instinct'];
-    if (toolName === 'Skill') return ['simplify-guard'];
     return [];
   }
 

package/cli/commands/install.mjs

@@ -8,6 +8,7 @@ import chalk from 'chalk';
 import { runInstaller } from '../install.mjs';
 import { runUpdate } from '../update.mjs';
 import { runRepair } from '../repair.mjs';
+import { parseFlags } from '../provision.mjs';
 
 // ── Help texts ──────────────────────────────────────────────────────────────────
 
@@ -18,7 +19,10 @@ export function showInstallHelp() {
   Usage:
     bizar install                       Install (or refresh) every component
     bizar install --dry-run             Print what would happen, change nothing
-    bizar install --force               Overwrite existing files
+    bizar install --force               Overwrite existing files AND prune stale
+                                        entries in ~/.claude/{agents,skills,
+                                        commands,rules,hooks}
+    bizar install --yes                 Assume yes for any non-destructive prompt
     bizar install --help                Show this help
 
   Description:
@@ -89,7 +93,11 @@ export async function install(args, isHelpRequest) {
     showInstallHelp();
     return;
   }
-  await runInstaller({});
+  // parseFlags lives in cli/provision.mjs and is the canonical argv
+  // parser for the installer family. Reusing it keeps install and
+  // update in lockstep on flag semantics.
+  const { mode, dryRun, force, yes } = parseFlags(args);
+  await runInstaller({ mode, dryRun, force, yes });
   // v4.4.3 — After install, repair any stale bin symlinks so the
   // user picks up the new code.
   try {

package/cli/install/index.mjs

@@ -13,12 +13,13 @@ import { printInstallLocations } from './paths.mjs';
  * Thin orchestrator entry point.
  * @param {object} opts
  * @param {boolean} [opts.dryRun]
- * @param {boolean} [opts.force]
- * @param {boolean} [opts.quiet] - Only print the location card
- * @param {string}  [opts.mode]  - 'install' | 'update'
+ * @param {boolean} [opts.force]   - overwrite existing files AND prune stale entries
+ * @param {boolean} [opts.quiet]   - Only print the location card
+ * @param {string}  [opts.mode]    - 'install' | 'update'
+ * @param {boolean} [opts.yes]     - assume yes for any non-destructive prompts
  */
 export async function runInstaller(opts = {}) {
-  const { dryRun = false, force = false, quiet = false, mode = 'install' } = opts;
+  const { dryRun = false, force = false, quiet = false, mode = 'install', yes = false } = opts;
 
   if (quiet) {
     printInstallLocations({ dryRun, force });
@@ -28,5 +29,5 @@ export async function runInstaller(opts = {}) {
   showBanner();
   printInstallLocations({ dryRun, force });
 
-  return runProvision({ mode, dryRun, force });
+  return runProvision({ mode, dryRun, force, yes });
 }

package/cli/provision.mjs

@@ -352,6 +352,69 @@ function syncDir(srcDir, destDir, opts = {}) {
   return { copied, skipped };
 }
 
+/**
+ * Remove entries in destDir that are not present in srcDir.
+ * Honors the same recursive shape and filter as syncDir().
+ * Used by --force installs to clear stale files left over from
+ * previous versions (e.g. agents renamed by F-112).
+ *
+ * Policy: `bizar install --force` treats the global state under
+ * `~/.claude/{agents,skills,commands,rules,hooks}` as fully Bizar-
+ * managed. Anything in dest that does not appear in src is removed.
+ * This is intentionally aggressive; users who keep hand-edited
+ * entries under those paths should run without `--force` to leave
+ * them alone. See PROGRESS.md F-141 for the trade-off.
+ *
+ * Returns { removed, kept } counts.
+ */
+export function pruneStale(srcDir, destDir, opts = {}) {
+  if (!existsSync(destDir)) return { removed: 0, kept: 0 };
+  if (!existsSync(srcDir)) return { removed: 0, kept: 0 };
+  let removed = 0, kept = 0;
+  for (const name of readdirSync(destDir)) {
+    if (name.startsWith('.')) continue;
+    const dp = join(destDir, name);
+    const sp = join(srcDir, name);
+    let dstStat;
+    try { dstStat = statSync(dp); } catch { continue; }
+    const srcExists = existsSync(sp);
+    if (dstStat.isDirectory()) {
+      if (!srcExists) {
+        rmSync(dp, { recursive: true, force: true });
+        removed++;
+        continue;
+      }
+      const r = pruneStale(sp, dp, opts);
+      removed += r.removed;
+      kept += r.kept;
+      // Drop now-empty directories.
+      try {
+        if (readdirSync(dp).length === 0) rmSync(dp, { recursive: true, force: true });
+      } catch { /* ignore */ }
+      continue;
+    }
+    if (!srcExists) {
+      if (opts.filter && !opts.filter(name, dp)) { kept++; continue; }
+      rmSync(dp, { force: true });
+      removed++;
+    } else {
+      kept++;
+    }
+  }
+  return { removed, kept };
+}
+
+/**
+ * Run the prune pass under the same conditions used by every sync*
+ * helper and return a `{ pruned, tail }` pair the caller appends
+ * to its result message. No-op when `force` is false.
+ */
+function pruneReport(srcDir, destDir, filter, force) {
+  if (!force) return { pruned: 0, tail: '' };
+  const pruned = pruneStale(srcDir, destDir, { filter }).removed;
+  return { pruned, tail: pruned ? `, pruned ${pruned} stale` : '' };
+}
+
 // F-107: syncAgentFiles removed. Agent definitions live at
 // .claude/agents/ (Claude Code canonical) — they were never sourced
 // from config/agents/ in Claude Code era, and the legacy source dir
@@ -366,10 +429,11 @@ export async function syncAgentFiles({ dryRun = false, force = false } = {}) {
   const src = join(REPO_ROOT, '.claude', 'agents');
   const dest = CLAUDE_AGENTS_DIR;
   if (!existsSync(src)) return { ok: true, message: `no agents source at ${src}`, copied: 0, skipped: 0 };
-  if (dryRun) return { ok: true, message: `[dry-run] would sync ${src} → ${dest}` };
+  if (dryRun) return { ok: true, message: `[dry-run] would sync ${src} → ${dest}${force ? ' (prune stale)' : ''}` };
   ensureDir(dest);
   const { copied, skipped } = syncDir(src, dest, { filter: n => n.endsWith('.md') });
-  return { ok: true, message: `${copied} agent(s) synced (${skipped} kept)`, copied, skipped };
+  const { pruned, tail } = pruneReport(src, dest, n => n.endsWith('.md'), force);
+  return { ok: true, message: `${copied} agent(s) synced (${skipped} kept)${tail}`, copied, skipped, pruned };
 }
 
 // F-113: syncModelRouter added. The model-router.json file lives in
@@ -399,11 +463,11 @@ export async function syncModelRouter({ dryRun = false, force = false } = {}) {
   return { ok: true, message: `model-router.json → ${dest}`, path: dest };
 }
 
-export async function syncSkillFiles({ dryRun = false } = {}) {
+export async function syncSkillFiles({ dryRun = false, force = false } = {}) {
   const src = join(REPO_ROOT, 'config', 'skills');
   const dest = CLAUDE_SKILLS_DIR;
   if (!existsSync(src)) return { ok: true, message: `no skills source at ${src}`, copied: 0, skipped: 0 };
-  if (dryRun) return { ok: true, message: `[dry-run] would sync ${src} → ${dest}` };
+  if (dryRun) return { ok: true, message: `[dry-run] would sync ${src} → ${dest}${force ? ' (prune stale)' : ''}` };
   ensureDir(dest); copyDirContents(src, dest);
   const sharedBaseline = join(REPO_ROOT, 'config', 'agents', '_shared', 'AGENT_BASELINE.md');
   if (existsSync(sharedBaseline)) {
@@ -411,39 +475,50 @@ export async function syncSkillFiles({ dryRun = false } = {}) {
     ensureDir(baselineDir);
     copyFileSync(sharedBaseline, join(baselineDir, 'SKILL.md'));
   }
+  // Skill packs are directories containing SKILL.md; a stray non-SKILL.md
+  // file in dest is almost certainly user-owned. Restrict the prune pass
+  // to .md files only.
+  const { pruned, tail } = pruneReport(src, dest, n => n.endsWith('.md'), force);
   const count = readdirSync(dest).filter(n => { try { return statSync(join(dest, n)).isDirectory(); } catch { return false; } }).length;
-  return { ok: true, message: `${count} skill(s) synced`, copied: count, skipped: 0 };
+  return { ok: true, message: `${count} skill(s) synced${tail}`, copied: count, skipped: 0, pruned };
 }
 
-export async function syncCommandFiles({ dryRun = false } = {}) {
+export async function syncCommandFiles({ dryRun = false, force = false } = {}) {
   const candidates = [join(REPO_ROOT, '.claude', 'commands'), join(REPO_ROOT, 'config', 'commands')];
   let src = null;
   for (const c of candidates) if (existsSync(c)) { src = c; break; }
   if (!src) return { ok: true, message: 'no commands source found', copied: 0, skipped: 0 };
   const dest = CLAUDE_COMMANDS_DIR;
-  if (dryRun) return { ok: true, message: `[dry-run] would sync ${src} → ${dest}` };
+  if (dryRun) return { ok: true, message: `[dry-run] would sync ${src} → ${dest}${force ? ' (prune stale)' : ''}` };
   ensureDir(dest);
   const { copied, skipped } = syncDir(src, dest, { filter: n => n.endsWith('.md') });
-  return { ok: true, message: `${copied} command(s) synced (${skipped} kept)`, copied, skipped };
+  const { pruned, tail } = pruneReport(src, dest, n => n.endsWith('.md'), force);
+  return { ok: true, message: `${copied} command(s) synced (${skipped} kept)${tail}`, copied, skipped, pruned };
 }
 
-export async function syncRulesFiles({ dryRun = false } = {}) {
+export async function syncRulesFiles({ dryRun = false, force = false } = {}) {
   const src = join(REPO_ROOT, 'config', 'rules');
   const dest = CLAUDE_RULES_DIR;
   if (!existsSync(src)) return { ok: true, message: `no rules source at ${src}`, copied: 0, skipped: 0 };
-  if (dryRun) return { ok: true, message: `[dry-run] would sync ${src} → ${dest}` };
+  if (dryRun) return { ok: true, message: `[dry-run] would sync ${src} → ${dest}${force ? ' (prune stale)' : ''}` };
   ensureDir(dest);
-  const { copied, skipped } = syncDir(src, dest, { filter: n => n.endsWith('.md') || n.endsWith('.txt') });
-  return { ok: true, message: `${copied} rule(s) synced (${skipped} kept)`, copied, skipped };
+  const ruleFilter = n => n.endsWith('.md') || n.endsWith('.txt');
+  const { copied, skipped } = syncDir(src, dest, { filter: ruleFilter });
+  const { pruned, tail } = pruneReport(src, dest, ruleFilter, force);
+  return { ok: true, message: `${copied} rule(s) synced (${skipped} kept)${tail}`, copied, skipped, pruned };
 }
 
-export async function syncHookFiles({ dryRun = false } = {}) {
+export async function syncHookFiles({ dryRun = false, force = false } = {}) {
   const src = join(REPO_ROOT, '.claude', 'hooks');
   const dest = CLAUDE_HOOKS_DIR;
   ensureDir(dest);
   if (!existsSync(src)) return { ok: true, message: `no hooks source at ${src}`, copied: 0, skipped: 0 };
-  if (dryRun) return { ok: true, message: `[dry-run] would sync ${src} → ${dest}` };
+  if (dryRun) return { ok: true, message: `[dry-run] would sync ${src} → ${dest}${force ? ' (prune stale)' : ''}` };
   copyDirContents(src, dest);
+  // Hooks are .mjs / .sh scripts. Restrict prune to those extensions so
+  // any user-owned file (READMEs, fixtures, etc.) is not removed.
+  const hookFilter = n => n.endsWith('.mjs') || n.endsWith('.sh');
+  const { pruned, tail } = pruneReport(src, dest, hookFilter, force);
   for (const name of readdirSync(dest)) {
     const fp = join(dest, name);
     try {
@@ -451,7 +526,7 @@ export async function syncHookFiles({ dryRun = false } = {}) {
       if (st.isFile() && (name.endsWith('.sh') || name.endsWith('.mjs'))) chmodSync(fp, 0o755);
     } catch { /* ignore */ }
   }
-  return { ok: true, message: 'hook scripts installed', copied: readdirSync(dest).length, skipped: 0 };
+  return { ok: true, message: `hook scripts installed${tail}`, copied: readdirSync(dest).length, skipped: 0, pruned };
 }
 
 // ─── git hooks ──────────────────────────────────────────────────────────────
@@ -992,7 +1067,7 @@ export async function syncConfigExtras({ dryRun = false } = {}) {
 
 // ─── CLI entry ──────────────────────────────────────────────────────────────
 
-function parseFlags(argv) {
+export function parseFlags(argv) {
   const opts = { mode: 'install', dryRun: false, force: false, yes: false, start: true, update: false };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar",
-  "version": "10.12.0",
+  "version": "10.12.2",
   "description": "Autonomous, human-in-the-loop multi-agent harness for Claude Code with guarded workflows, typed SDK primitives, and MCP tools.",
   "type": "module",
   "bin": {

package/packages/sdk/dist/version.d.ts

@@ -1,5 +1,5 @@
 /**
  * SDK version constant. Keep synchronized with the workspace package versions.
  */
-export declare const SDK_VERSION: "10.12.0";
+export declare const SDK_VERSION: "10.12.2";
 //# sourceMappingURL=version.d.ts.map

package/packages/sdk/dist/version.js

@@ -1,5 +1,5 @@
 /**
  * SDK version constant. Keep synchronized with the workspace package versions.
  */
-export const SDK_VERSION = "10.12.0";
+export const SDK_VERSION = "10.12.2";
 //# sourceMappingURL=version.js.map

package/packages/sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar-sdk",
-  "version": "10.12.0",
+  "version": "10.12.2",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",