@polderlabs/bizar 10.16.0 → 10.16.2

package/cli/commands/install.mjs

@@ -19,9 +19,11 @@ 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 AND prune stale
-                                        entries in ~/.claude/{agents,skills,
-                                        commands,rules,hooks}
+    bizar install --force               Full clean install: wipe Bizar-managed dirs,
+                                        back up settings env vars, re-sync everything
+                                        from the repo. Preserves ~/.config/bizar/
+                                        login state. Combine with --yes to skip prompts.
+    bizar install --deep                Alias for --force (clean-install semantics)
     bizar install --yes                 Assume yes for any non-destructive prompt
     bizar install --help                Show this help
 
@@ -30,6 +32,21 @@ export function showInstallHelp() {
     difference is just mode=install vs mode=update. Every step is
     idempotent — running this twice is safe.
 
+    F-183 (v10.16.2+) — --force promotes the install from
+    overwrite+prune-stale to a fully clean install. It wipes:
+      - ~/.claude/{agents,skills,commands,hooks,rules,workflows,plugins}/
+      - ~/.agents/ (shared skill-registry + lock)
+      - ~/.claude/settings.json (env vars backed up to BIZAR_SAVED_ENV)
+    and preserves:
+      - ~/.config/bizar/ (login state, telemetry, model picks, worktree-queue)
+      - ~/.claude/.credentials.json, statsig/, .playwright-mcp/
+      - any user-created subdirs under ~/.claude/ outside the managed set
+
+    The freshly-emitted settings.json inherits the F-181 wildcard
+    permissions.allow expansion and the F-176 empty deny/ask lists
+    while the prior ANTHROPIC_* and BIZAR_* env vars are merged back
+    in from the stash.
+
     1. Installs @polderlabs/bizar via npm (skipped if already current).
     2. Shells to ./install.sh for platform-specific system dependencies.
     3. Syncs agent files, slash commands, and bundled skills into
@@ -38,7 +55,6 @@ export function showInstallHelp() {
     5. Wires Claude Code lifecycle hooks (SessionStart / PreToolUse /
        PostToolUse / UserPromptSubmit) under ~/.claude/hooks/.
     6. Runs 'bizar doctor' as a post-install health check.
-
     No API key collection, no interactive prompts.
   `);
 }
@@ -48,7 +64,6 @@ export function showUpdateHelp() {
   bizar update — Update @anthropic-ai/claude-code + @polderlabs/bizar
   (which bundles the CLI, SDK, agents, skills, hooks, and commands). Detects what's
   installed and only touches what's missing or out of date.
-
   Usage:
     bizar update                       Update all installed Bizar components
     bizar update --check               Only print current vs. latest; do not update
@@ -57,11 +72,9 @@ export function showUpdateHelp() {
     bizar update --force               Override .bizar/PRE_PUSH_NOTES.md blockers
     bizar update --yes                 Same as --force, but named for one-line scripts
     bizar update --help                Show this help
-
   Components updated:
     @anthropic-ai/claude-code   the Claude Code CLI itself
     @polderlabs/bizar            CLI + SDK + agents + skills + hooks
-
   Behavior (v4.4.7+):
     • Single unified provisioner. 'bizar install' and 'bizar update' are
       the same code path with different mode flags. Every step is
@@ -72,13 +85,11 @@ export function showUpdateHelp() {
       regressions before claude tries to start.
     • With --check: prints the version matrix and release-notes excerpt
       between current and latest, exits non-zero if an update is available.
-
   Examples:
     bizar update                       Full auto-update (recommended)
     bizar update --check               Show version matrix + notes, do nothing
     bizar update --channel=beta        Upgrade to latest beta build
     bizar update --dry-run             Preview what would change
-
   Errors:
     Network failures (registry offline / DNS) and npm permission issues
     are surfaced with the raw npm output. The provisioner never silently
@@ -87,7 +98,6 @@ export function showUpdateHelp() {
 }
 
 // ── Command runners ────────────────────────────────────────────────────────────
-
 export async function install(args, isHelpRequest) {
   if (isHelpRequest) {
     showInstallHelp();
@@ -95,9 +105,21 @@ export async function install(args, isHelpRequest) {
   }
   // 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.
+  // update in lockstep on flag semantics. --deep is parsed as an
+  // alias for --force (clean-install semantics, F-183).
   const { mode, dryRun, force, yes } = parseFlags(args);
-  await runInstaller({ mode, dryRun, force, yes });
+  const result = await runInstaller({ mode, dryRun, force, yes });
+  // F-183 — print a one-line summary of the wipe scope so operators
+  // can see at a glance what changed without re-reading the verbose
+  // step list.
+  if (force && result?.clean) {
+    console.log('');
+    console.log(chalk.cyan(`  Summary (F-183): wiped ${result.clean.wiped.length} path(s); preserved ${result.clean.preserved.length} path(s).`));
+    if (result.doctor) {
+      const ok = result.doctor.failed === 0;
+      console.log(chalk[ok ? 'green' : 'yellow'](`  Doctor: ${result.doctor.passed} passed, ${result.doctor.failed} failed.`));
+    }
+  }
   // v4.4.3 — After install, repair any stale bin symlinks so the
   // user picks up the new code.
   try {

package/cli/install/index.mjs

@@ -5,15 +5,29 @@
  * that delegates to the provisioner.
  */
 
-import { runProvision } from '../provision.mjs';
+import { runProvision, forceCleanInstall, clearSavedEnv } from '../provision.mjs';
+import { runDoctor } from '../doctor.mjs';
 import { showBanner, sectionHeading } from './banner.mjs';
 import { printInstallLocations } from './paths.mjs';
 
 /**
  * Thin orchestrator entry point.
+ *
+ * Behavior (v10.16.2+, F-183):
+ *   - When `force === true`, run `forceCleanInstall` *before*
+ *     `runProvision` so the Bizar-managed dirs under `~/.claude/` and
+ *     `~/.agents/` are wiped, `~/.claude/settings.json` is removed, and
+ *     the prior env vars are stashed into `process.env.BIZAR_SAVED_ENV`
+ *     for the factory to re-inject. We always pass `force: true` to
+ *     `runProvision` regardless of how the caller phrased the flag.
+ *   - After the provisioner completes, run `runDoctor({ silent: true })`
+ *     and surface the result so forced installs surface a health summary.
+ *   - The wipe report is returned to the caller (e.g. `bizar install`)
+ *     so the CLI layer can print a summary of what changed.
+ *
  * @param {object} opts
  * @param {boolean} [opts.dryRun]
- * @param {boolean} [opts.force]   - overwrite existing files AND prune stale entries
+ * @param {boolean} [opts.force]   - overwrite existing files AND prune stale entries AND wipe dirs (F-183)
  * @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
@@ -29,5 +43,56 @@ export async function runInstaller(opts = {}) {
   showBanner();
   printInstallLocations({ dryRun, force });
 
-  return runProvision({ mode, dryRun, force, yes });
-}
+  // F-183 — pre-provision wipe for forced installs. Force-clean is what
+  // makes `--force` actually a clean install: dirs under ~/.claude/ are
+  // wiped (BIZAR_HOME and third-party state preserved), settings.json
+  // is removed, and the operator's env vars are stashed in
+  // `process.env.BIZAR_SAVED_ENV` so the next `writeClaudeSettings` call
+  // re-injects them after re-emitting the file from the template.
+  let clean = null;
+  if (force) {
+    clearSavedEnv();
+    clean = forceCleanInstall({ dryRun });
+    if (!quiet && clean?.wiped?.length) {
+      sectionHeading('Pre-install wipe (F-183)');
+      console.log(`  wiped: ${clean.wiped.length} path(s)`);
+      for (const p of clean.wiped) console.log(`    - ${p}`);
+      if (clean.preserved?.length) {
+        console.log(`  preserved: ${clean.preserved.length} path(s)`);
+        for (const p of clean.preserved) console.log(`    - ${p}`);
+      }
+      console.log('');
+    }
+  }
+
+  // Always pass `force: true` downstream so `runProvision` re-emits the
+  // template-owned keys (permissions.allow wildcards, mcpServers, hooks)
+  // into the freshly-empty settings file.
+  const provisionResult = await runProvision({ mode, dryRun, force: true, yes });
+
+  // F-183 — post-install health check. Surfaced as a warning rather
+  // than a hard failure so a forced install that completes without
+  // error still reports its doctor summary; the operator decides
+  // whether to investigate.
+  if (!dryRun) {
+    try {
+      const doctorResult = await runDoctor({ silent: true });
+      provisionResult.doctor = doctorResult;
+      if (!quiet) {
+        sectionHeading('Post-install doctor (F-183)');
+        const ok = doctorResult.failed === 0;
+        console.log(`  ${ok ? '✓' : '✗'} doctor: ${doctorResult.passed} passed, ${doctorResult.failed} failed`);
+        if (doctorResult.failed > 0) {
+          for (const r of doctorResult.results) {
+            if (!r.ok) console.log(`    ✗ ${r.name}: ${r.message}`);
+          }
+        }
+        console.log('');
+      }
+    } catch (err) {
+      if (!quiet) console.log(`  ! doctor skipped: ${err?.message || err}`);
+    }
+  }
+
+  return { ...provisionResult, clean };
+}

package/cli/provision.mjs

@@ -740,7 +740,41 @@ export function writeClaudeSettings({ dryRun = false, force = false } = {}) {
   const shipped = readJsonSafe(join(REPO_ROOT, 'config', 'claude', 'settings.json'), {}) || {};
   const shippedRouter = readJsonSafe(join(REPO_ROOT, 'config', 'claude', 'model-router.json'), {}) || {};
   const defaultGatewayUrl = shippedRouter.endpoint || shippedRouter.gateway?.endpoint || 'http://localhost:20129/v1';
-  const gatewayUrl = process.env.ANTHROPIC_BASE_URL
+
+  // F-183 — when `forceCleanInstall` has wiped `~/.claude/settings.json`,
+  // it stashes the prior env block into `process.env.BIZAR_SAVED_ENV`.
+  // The stash is the **only** source of operator credentials that
+  // survives a wipe — everything else on disk has been removed by the
+  // time this function runs. We honor it preferentially for the env
+  // keys in FORCE_CLEAN_PRESERVE_ENV_KEYS so `bizar install --force`
+  // preserves gateway URLs / auth tokens without forcing operators to
+  // re-export them in the shell.
+  //
+  // Precedence (preserved-env keys):
+  //   savedEnv.X  >  process.env.X  >  existingEnv.X  >  default
+  //
+  // The stash is only consulted when it was actually set by
+  // `forceCleanInstall` (non-empty JSON). For direct `force: true`
+  // calls that bypass the wipe, we keep the legacy precedence so the
+  // existing merge-settings contract is unchanged.
+  let savedEnv = {};
+  if (typeof process.env.BIZAR_SAVED_ENV === 'string') {
+    try { savedEnv = JSON.parse(process.env.BIZAR_SAVED_ENV) || {}; } catch { /* corrupt stash */ }
+  }
+  const hasSavedEnv = Object.keys(savedEnv).length > 0;
+
+  const pickEnv = (key) => {
+    if (hasSavedEnv && typeof savedEnv[key] === 'string') return savedEnv[key];
+    if (process.env[key]) return process.env[key];
+    if (!force && typeof existingEnv[key] === 'string') return existingEnv[key];
+    return undefined;
+  };
+
+  const savedBaseUrl = pickEnv('ANTHROPIC_BASE_URL');
+  const savedRouterUrl = pickEnv('BIZAR_MODEL_ROUTER_URL');
+  const gatewayUrl = savedBaseUrl
+    || savedRouterUrl
+    || process.env.ANTHROPIC_BASE_URL
     || process.env.BIZAR_MODEL_ROUTER_URL
     || (!force && (existingEnv.ANTHROPIC_BASE_URL || existingEnv.BIZAR_MODEL_ROUTER_URL))
     || defaultGatewayUrl;
@@ -808,12 +842,20 @@ export function writeClaudeSettings({ dryRun = false, force = false } = {}) {
     env: {
       BIZAR_HOME: BIZAR_HOME(),
       ANTHROPIC_BASE_URL: gatewayUrl,
-      BIZAR_MODEL_ROUTER_URL: process.env.BIZAR_MODEL_ROUTER_URL || gatewayUrl,
-      ANTHROPIC_AUTH_TOKEN: process.env.ANTHROPIC_AUTH_TOKEN || 'sk_9router',
+      BIZAR_MODEL_ROUTER_URL:
+        pickEnv('BIZAR_MODEL_ROUTER_URL')
+        || gatewayUrl,
+      ANTHROPIC_AUTH_TOKEN:
+        pickEnv('ANTHROPIC_AUTH_TOKEN')
+        || 'sk_9router',
       CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY:
-        process.env.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY || '1',
+        pickEnv('CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY')
+        || '1',
       CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS:
-        process.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS || shipped.env?.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS || '1',
+        pickEnv('CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS')
+        || shipped.env?.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS
+        || '1',
+      ...(pickEnv('ANTHROPIC_MODEL') ? { ANTHROPIC_MODEL: pickEnv('ANTHROPIC_MODEL') } : {}),
     },
     hooks: {
       UserPromptSubmit: [{ hooks: [hook('user-prompt-submit', 10)] }],
@@ -859,6 +901,12 @@ export function writeClaudeSettings({ dryRun = false, force = false } = {}) {
   if (dryRun) return { ok: true, message: `[dry-run] would write ${fp}` };
   ensureDir(CLAUDE_DIR);
   writeFileSync(fp, JSON.stringify(merged, null, 2) + '\n');
+  // F-183 — clear the in-process stash once consumed so subsequent
+  // writes in the same run (or in tests) don't accidentally inherit
+  // operator credentials.
+  if (typeof process.env.BIZAR_SAVED_ENV === 'string') {
+    delete process.env.BIZAR_SAVED_ENV;
+  }
   return { ok: true, message: `wrote ${fp}`, path: fp };
 }
 
@@ -1164,6 +1212,164 @@ export async function syncConfigExtras({ dryRun = false } = {}) {
   return { ok: true, message: `synced (${counts.commands} commands, ${counts.skills} skills, ${counts.hooks} hooks, ${counts.rules} rules, ${counts.workflows} workflows)`, counts };
 }
 
+// ─── F-183 — fully clean install ────────────────────────────────────────────
+
+/**
+ * Env keys whose values the freshly-emitted `~/.claude/settings.json`
+ * must inherit from a previously-installed copy of the file. Operators
+ * run `bizar install --force` to repair drifted settings; this set is
+ * the contract that keeps gateway credentials + provider URLs alive
+ * across the wipe.
+ *
+ * Anything outside this set is **not** preserved — the re-emitted
+ * `permissions` block must mirror the current template so the F-181
+ * wildcard expansion and F-176 empty deny/ask lists land on disk.
+ */
+export const FORCE_CLEAN_PRESERVE_ENV_KEYS = Object.freeze([
+  'ANTHROPIC_BASE_URL',
+  'ANTHROPIC_AUTH_TOKEN',
+  'BIZAR_MODEL_ROUTER_URL',
+  'BIZAR_HOME',
+  'ANTHROPIC_MODEL',
+  'CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY',
+  'CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS',
+]);
+
+/**
+ * Resolve `~/.agents/` (the shared skills-registry directory).
+ * Honors `process.env.AGENTS_DIR` so tests and operators can override
+ * it without bouncing HOME.
+ */
+export function resolveAgentsDir() {
+  if (process.env.AGENTS_DIR && process.env.AGENTS_DIR.trim()) {
+    return process.env.AGENTS_DIR.trim();
+  }
+  return join(HOME, '.agents');
+}
+
+/** `~/.agents/` — shared skills-registry directory. Re-evaluated per read so
+ * tests that flip `process.env.AGENTS_DIR` are honored. */
+export function AGENTS_DIR() {
+  return resolveAgentsDir();
+}
+
+/**
+ * Bizar-managed subdirectories of `~/.claude/`. Anything outside this
+ * set under `~/.claude/` is treated as user-owned and is preserved
+ * by `forceCleanInstall` (e.g. `.credentials.json`, `statsig/`,
+ * `.playwright-mcp/`).
+ */
+const FORCE_CLEAN_WIPE_DIRS = Object.freeze([
+  'agents',
+  'skills',
+  'commands',
+  'hooks',
+  'rules',
+  'workflows',
+  'plugins',
+]);
+
+/**
+ * F-183 — wipe every Bizar-managed directory under `~/.claude/` plus
+ * `~/.agents/`, back up `~/.claude/settings.json` env vars into
+ * `process.env.BIZAR_SAVED_ENV`, and return a structured wipe report.
+ *
+ * The wipe is **idempotent** at the file-system level (rmSync is
+ * recursive+force), and the resulting state is fully reproducible by
+ * the subsequent `runProvision` call because the factory re-emits the
+ * entire settings file from the shipped template (so the F-181
+ * wildcard expansion in `permissions.allow` lands automatically).
+ *
+ * What is **not** wiped:
+ *   - `~/.config/bizar/` (BIZAR_HOME) — login state, telemetry,
+ *     worktree-queue, model picks, installed.json marker. Operators
+ *     rely on this surviving a forced reinstall.
+ *   - `~/.claude/.credentials.json`, `~/.claude/statsig/`,
+ *     `~/.claude/.playwright-mcp/` — third-party state managed by
+ *     Claude Code itself.
+ *   - Any subdirectory of `~/.claude/` not in FORCE_CLEAN_WIPE_DIRS.
+ *
+ * @param {{ dryRun?: boolean }} [opts]
+ * @returns {{ ok: true, message: string, wiped: string[], preserved: string[], env: Record<string, string> }}
+ */
+export function forceCleanInstall(opts = {}) {
+  const { dryRun = false } = opts;
+  const claudeDir = resolveClaudeDir();
+  const agentsDir = resolveAgentsDir();
+  const settingsPath = join(claudeDir, 'settings.json');
+
+  // 1. Stash existing env vars so `writeClaudeSettings` can re-inject
+  //    them when the freshly-emitted file lands. Use a string env so
+  //    we don't pollute the parent process object graph with arbitrary
+  //    operator-defined keys.
+  let savedEnv = {};
+  if (existsSync(settingsPath)) {
+    try {
+      const cur = JSON.parse(readFileSync(settingsPath, 'utf8'));
+      if (cur && typeof cur === 'object' && cur.env && typeof cur.env === 'object') {
+        for (const key of FORCE_CLEAN_PRESERVE_ENV_KEYS) {
+          if (typeof cur.env[key] === 'string') savedEnv[key] = cur.env[key];
+        }
+      }
+    } catch { /* corrupt settings — treat as no env */ }
+  }
+  // Also pick up env values from the live process so a freshly-invoked
+  // `bizar install --force` carries operator credentials through the
+  // wipe even if the on-disk settings file is missing/stale.
+  for (const key of FORCE_CLEAN_PRESERVE_ENV_KEYS) {
+    if (!savedEnv[key] && process.env[key]) savedEnv[key] = process.env[key];
+  }
+  process.env.BIZAR_SAVED_ENV = JSON.stringify(savedEnv);
+
+  // 2. Wipe managed dirs.
+  const wiped = [];
+  for (const sub of FORCE_CLEAN_WIPE_DIRS) {
+    const dir = join(claudeDir, sub);
+    if (!existsSync(dir)) continue;
+    wiped.push(dir);
+    if (!dryRun) {
+      try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+    }
+  }
+  if (existsSync(agentsDir)) {
+    wiped.push(agentsDir);
+    if (!dryRun) {
+      try { rmSync(agentsDir, { recursive: true, force: true }); } catch { /* ignore */ }
+    }
+  }
+  // 3. Wipe settings.json so writeClaudeSettings re-emits from the
+  //    shipped template. Operators keep their gateway / auth env vars
+  //    via the BIZAR_SAVED_ENV stash.
+  if (existsSync(settingsPath)) {
+    wiped.push(settingsPath);
+    if (!dryRun) {
+      try { rmSync(settingsPath, { force: true }); } catch { /* ignore */ }
+    }
+  }
+
+  const preserved = [];
+  if (existsSync(BIZAR_HOME())) preserved.push(BIZAR_HOME());
+  // Document the third-party state we intentionally left alone.
+  for (const sub of ['.credentials.json', 'statsig', '.playwright-mcp']) {
+    const p = join(claudeDir, sub);
+    if (existsSync(p)) preserved.push(p);
+  }
+
+  const tag = dryRun ? '[dry-run] ' : '';
+  const message = `${tag}F-183 clean: wiped ${wiped.length} paths; preserved ${preserved.length} paths (BIZAR_HOME + third-party state)`;
+  return { ok: true, message, wiped, preserved, env: savedEnv };
+}
+
+/**
+ * Inverse of `forceCleanInstall` — clears the in-process stash once
+ * `writeClaudeSettings` has consumed it. Idempotent and side-effect
+ * free; exported so tests can run multiple forced installs without
+ * leaking stale stashes between scenarios.
+ */
+export function clearSavedEnv() {
+  delete process.env.BIZAR_SAVED_ENV;
+}
+
 // ─── CLI entry ──────────────────────────────────────────────────────────────
 
 export function parseFlags(argv) {
@@ -1177,7 +1383,7 @@ export function parseFlags(argv) {
       const v = argv[++i];
       if (v === 'install' || v === 'update' || v === 'install-only-system') opts.mode = v;
     } else if (a === '--dry-run') opts.dryRun = true;
-    else if (a === '--force') opts.force = true;
+    else if (a === '--force' || a === '--deep') opts.force = true;
     else if (a === '--yes' || a === '-y') opts.yes = true;
     else if (a === '--non-interactive') opts.yes = true;
     else if (a === '--no-service') opts.start = false;

package/config/claude/hooks/agent-model-guard.mjs

@@ -20,12 +20,12 @@ import { pathToFileURL } from 'node:url';
 
 import { loadModelRouter } from '../../../config/agents/model-assignment.mjs';
 
-function deny(reason) {
+function advise(reason) {
   return {
     hookSpecificOutput: {
       hookEventName: 'PreToolUse',
-      permissionDecision: 'deny',
-      permissionDecisionReason: reason,
+      permissionDecision: 'allow',
+      additionalContext: `🟡 Model override guidance: ${reason} The dispatch will proceed regardless.`,
     },
   };
 }
@@ -80,7 +80,7 @@ export async function guardAgentModel(input, options = {}) {
 
   const allowed = configuredModels(registry);
   if (!allowed.has(requested)) {
-    return deny(`Bizar Agent dispatch blocked: model override ${requested} is outside the configured dynamic tiers and the user-selected pool. Omit model to inherit the session or pick it via \`bizar models\`.`);
+    return advise(`Bizar Agent dispatch blocked: model override ${requested} is outside the configured dynamic tiers and the user-selected pool. Omit model to inherit the session or pick it via \`bizar models\`.`);
   }
 
   // User-selected models bypass live-discovery validation. The picker is the
@@ -89,7 +89,7 @@ export async function guardAgentModel(input, options = {}) {
   if (!fromUserPick && Array.isArray(options.availableModelIds)) {
     const available = new Set(options.availableModelIds);
     if (!available.has(requested)) {
-      return deny(`Bizar Agent dispatch blocked: ${requested} was not reported by live discovery. Omit model to inherit the active session; do not retry aliases.`);
+      return advise(`Bizar Agent dispatch blocked: ${requested} was not reported by live discovery. Omit model to inherit the active session; do not retry aliases.`);
     }
   }
 

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

@@ -65,8 +65,8 @@ process.stdin.on('end', () => {
     process.stdout.write(JSON.stringify({
       hookSpecificOutput: {
         hookEventName: 'PreToolUse',
-        permissionDecision: 'deny',
-        permissionDecisionReason: `Humanize the text before publishing it: ${notes.join('; ')}.`,
+        permissionDecision: 'allow',
+        additionalContext: `🟡 Style suggestion: humanize the text before publishing. ${notes.join('; ')}. The write will proceed regardless.`,
       },
     }) + '\n');
   }

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

@@ -8,7 +8,7 @@
  * NOT consume the marker — the hook chain may run more than once for a single
  * bash invocation, and a one-shot rm caused sporadic false denies.
  *
- * Missing or stale markers deny the commit. Hard approval gates (commit,
+ * Missing or stale markers emit an advisory reminder. Hard approval gates (commit,
  * push, gh, publish, deploy) remain in git-workflow-guard.mjs.
  */
 
@@ -94,8 +94,8 @@ process.stdin.on('end', () => {
   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.',
+      permissionDecision: 'allow',
+      additionalContext: '🟡 /simplify not run on the current staged diff. Recommended: run /simplify, apply any justified cleanup, rerun tests, then retry the commit. The commit will proceed without /simplify if you choose.',
     },
   }) + '\n');
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar",
-  "version": "10.16.0",
+  "version": "10.16.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/scripts/git-hooks/pre-push

@@ -20,6 +20,12 @@ while read -r LOCAL_REF LOCAL_SHA REMOTE_REF REMOTE_SHA; do
   if [ -z "$LOCAL_SHA" ] || [ "$LOCAL_SHA" = "0000000000000000000000000000000000000000" ]; then
     continue
   fi
+  # Tag pushes (refs/tags/*) point at existing commits; they don't introduce
+  # new file changes. Skip tag-only ref updates so an annotated tag pointing
+  # at a commit already pushed via master doesn't scan the full history.
+  case "$LOCAL_REF" in
+    refs/tags/*) continue ;;
+  esac
   if [ -z "$REMOTE_SHA" ] || [ "$REMOTE_SHA" = "0000000000000000000000000000000000000000" ]; then
     # New branch — scan all commits on the local side
     RANGE="$LOCAL_SHA"