@polderlabs/bizar 10.12.0 → 10.12.1

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.1",
   "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/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.1",
   "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.1";
 //# 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.1";
 //# sourceMappingURL=version.js.map

package/packages/sdk/package.json

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