@polderlabs/bizar 3.12.1 → 3.12.3

package/cli/install.mjs

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 import boxen from 'boxen';
-import { existsSync } from 'node:fs';
+import { existsSync, lstatSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 
 import { showBanner, showPantheon, sectionHeading } from './banner.mjs';
@@ -26,31 +26,93 @@ const AGENT_FILES = [
  * `opencodeConfigDir()`). Otherwise, prints a hint directing the user to run
  * `npm install -g @polderlabs/bizar-plugin`.
  *
- * Returns `true` if the plugin was installed, `false` otherwise. Never throws.
+ * Symlink guard (v3.12.2): if the dest is a symlink (e.g. created by
+ * `bizar dev-link`), do NOT overwrite it. The copy below would otherwise
+ * dereference the symlink and silently turn it back into a real directory,
+ * breaking the dev workflow. Pass `{ force: true }` to override (after
+ * confirming the user really wants the deployed copy back).
+ *
+ * node_modules copy: the plugin imports `@polderlabs/bizar-sdk`, a
+ * workspace-internal package not on the public registry. The npm source
+ * bundles the SDK into its own `node_modules/`. After copying the plugin
+ * files, this function ALSO copies the source's `node_modules/` to the
+ * deployed `node_modules/` so Bun can resolve the import when the plugin
+ * is loaded from `~/.config/opencode/plugins/bizar/`. Without this, the
+ * plugin silently fails to load.
+ *
+ * Pass `{ silent: true }` to suppress the warning prints; the function
+ * still returns `true` if the dest is already in the desired state.
+ *
+ * Pass `{ sourceDir: '/path/to/fake' }` (test seam) to bypass the
+ * `npm root -g` lookup and use a caller-supplied source path. Used by
+ * cli/install.test.mjs to drive the function against a controlled
+ * filesystem without touching the real global npm root.
+ *
+ * Returns `true` if the plugin was installed (or already in place),
+ * `false` otherwise. Never throws.
  */
-export async function installPluginFromGlobal() {
+export async function installPluginFromGlobal(opts = {}) {
   const { execSync } = await import('node:child_process');
   const { mkdir, readdir, copyFile } = await import('node:fs/promises');
   const { join } = await import('node:path');
 
-  let globalRoot;
+  // ── Symlink guard ───────────────────────────────────────────────────────────
+  // If dest is a symlink (created by `bizar dev-link`), don't overwrite it.
+  // A plain copy would dereference the symlink and silently break the
+  // dev workflow. Print a hint unless silent, or honour an explicit
+  // --force from the caller.
+  const destDir = join(opencodeConfigDir(), 'plugins', 'bizar');
+  let destIsSymlink = false;
   try {
-    globalRoot = execSync('npm root -g', { stdio: ['ignore', 'pipe', 'ignore'] })
-      .toString()
-      .trim();
+    destIsSymlink = lstatSync(destDir).isSymbolicLink();
   } catch {
-    console.log(chalk.yellow('  ⚠ Could not determine npm global root — skipping plugin install'));
-    return false;
+    // doesn't exist yet — fine
   }
 
-  const pluginPath = join(globalRoot, '@polderlabs', 'bizar-plugin');
+  if (destIsSymlink) {
+    if (opts.silent) {
+      // Called from dev-unlink, which has already removed the symlink.
+      // If we somehow still see one here, treat as "already restored".
+      return true;
+    }
+    console.log(
+      chalk.yellow(
+        '  ⚠ ~/.config/opencode/plugins/bizar is a dev symlink — skipping npm copy.',
+      ),
+    );
+    console.log(
+      chalk.dim(
+        '    Run `bizar dev-unlink` to restore the deployed copy, or pass --force to overwrite.',
+      ),
+    );
+    if (!opts.force) return false;
+    rmSync(destDir, { force: true });
+  }
+
+  // ── Resolve source path ─────────────────────────────────────────────────────
+  // Production: `npm root -g` + `@polderlabs/bizar-plugin`. Tests can pass
+  // `opts.sourceDir` to bypass the lookup entirely.
+  let pluginPath;
+  if (opts.sourceDir) {
+    pluginPath = opts.sourceDir;
+  } else {
+    let globalRoot;
+    try {
+      globalRoot = execSync('npm root -g', { stdio: ['ignore', 'pipe', 'ignore'] })
+        .toString()
+        .trim();
+    } catch {
+      console.log(chalk.yellow('  ⚠ Could not determine npm global root — skipping plugin install'));
+      return false;
+    }
+    pluginPath = join(globalRoot, '@polderlabs', 'bizar-plugin');
+  }
   if (!existsSync(pluginPath)) {
     console.log(chalk.dim('  ℹ Bizar plugin not installed globally. To install it:'));
     console.log(chalk.dim('    npm install -g @polderlabs/bizar-plugin'));
     return false;
   }
 
-  const destDir = join(opencodeConfigDir(), 'plugins', 'bizar');
   await mkdir(destDir, { recursive: true });
 
   async function copyRecursive(srcDir, dstDir) {
@@ -73,11 +135,75 @@ export async function installPluginFromGlobal() {
     await copyRecursive(pluginPath, destDir);
     console.log(chalk.green(`  ✓ Bizar plugin installed from global package`));
     console.log(chalk.dim(`    ${pluginPath} → ${destDir}`));
-    return true;
   } catch (err) {
     console.log(chalk.yellow(`  ⚠ Failed to copy Bizar plugin: ${err.message}`));
     return false;
   }
+
+  // ── node_modules copy ───────────────────────────────────────────────────────
+  // The plugin imports `@polderlabs/bizar-sdk`, a workspace-internal package
+  // not on the public registry. The npm source bundles the SDK into its
+  // own `node_modules/`, so loading from `$(npm root -g)/...` resolves
+  // correctly. The deployed copy at `~/.config/opencode/plugins/bizar/`
+  // has no `node_modules`, so Bun can't resolve the import — without this
+  // copy the plugin silently fails to load. This used to be papered over
+  // by a manual `cp -r $(npm root -g)/.../node_modules ~/.config/...` step
+  // that got wiped every time `bizar update` re-ran the outer copy. Doing
+  // it here makes the fix durable across updates.
+  //
+  // Semantics: mirror `cp -r` — merge into dest if it exists as a real
+  // directory (overwrite same-named files, don't delete extras), error
+  // if dest is a symlink (don't dereference through it). Idempotent —
+  // running twice never breaks; files whose contents already match are
+  // rewritten byte-identically.
+  try {
+    const srcNmDir = join(pluginPath, 'node_modules');
+    if (existsSync(srcNmDir)) {
+      const dstNmDir = join(destDir, 'node_modules');
+      let dstIsSymlink = false;
+      try {
+        dstIsSymlink = lstatSync(dstNmDir).isSymbolicLink();
+      } catch {
+        // doesn't exist — fine, we'll create it below
+      }
+      if (dstIsSymlink) {
+        console.log(
+          chalk.yellow(
+            `  ⚠ ${dstNmDir} is a symlink — refusing to copy node_modules (remove manually).`,
+          ),
+        );
+      } else {
+        // Top-level entry count (matches `npm ls --depth=0`) — gives the
+        // user a sense of what was bundled. e.g. "copied node_modules
+        // (25 packages) to deployed plugin".
+        const srcEntries = await readdir(srcNmDir, { withFileTypes: true });
+        await mkdir(dstNmDir, { recursive: true });
+        async function copyNodeModules(srcDir, dstDir) {
+          const entries = await readdir(srcDir, { withFileTypes: true });
+          for (const entry of entries) {
+            const src = join(srcDir, entry.name);
+            const dst = join(dstDir, entry.name);
+            if (entry.isDirectory()) {
+              await mkdir(dst, { recursive: true });
+              await copyNodeModules(src, dst);
+            } else {
+              await copyFile(src, dst);
+            }
+          }
+        }
+        await copyNodeModules(srcNmDir, dstNmDir);
+        console.log(
+          chalk.green(
+            `  ✓ copied node_modules (${srcEntries.length} packages) to deployed plugin`,
+          ),
+        );
+      }
+    }
+  } catch (err) {
+    console.log(chalk.yellow(`  ⚠ Failed to copy node_modules: ${err.message}`));
+  }
+
+  return true;
 }
 
 export async function runInstaller() {

package/cli/install.test.mjs

@@ -0,0 +1,246 @@
+/**
+ * cli/install.test.mjs
+ *
+ * Tests for `installPluginFromGlobal()` in cli/install.mjs — specifically
+ * the node_modules copy step added in the "make the plugin-install fix
+ * durable" change.
+ *
+ * Strategy: mock HOME so opencodeConfigDir() resolves inside a tmpdir,
+ * and pass `opts.sourceDir` to bypass the `npm root -g` lookup with a
+ * caller-supplied fake plugin source.
+ *
+ * Mirrors the HOME-mocking pattern used by cli/dev-link.test.mjs.
+ */
+import { test, describe, beforeEach, afterEach, after } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  mkdtempSync,
+  mkdirSync,
+  writeFileSync,
+  rmSync,
+  existsSync,
+  lstatSync,
+  symlinkSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const { installPluginFromGlobal } = await import('./install.mjs');
+
+const ORIG_HOME = process.env.HOME;
+const ORIG_XDG = process.env.XDG_CONFIG_HOME;
+
+/**
+ * Point HOME at a fresh tmpdir so the module's opencodeConfigDir()
+ * resolves inside it (via the fallback `<HOME>/.config/opencode`).
+ * Returns the tmpdir path.
+ *
+ * We deliberately do NOT set XDG_CONFIG_HOME. opencodeConfigDir() treats
+ * a set XDG_CONFIG_HOME as the direct parent (so `~/.config` →
+ * `~/.config/opencode`); setting it to a raw tmpdir would produce
+ * `<tmpdir>/opencode` instead of `<tmpdir>/.config/opencode` and break
+ * path alignment with the rest of the test.
+ */
+function freshHome() {
+  const home = mkdtempSync(join(tmpdir(), 'bizar-install-'));
+  process.env.HOME = home;
+  delete process.env.XDG_CONFIG_HOME;
+  return home;
+}
+
+/** Path to the deployed plugin dir under the mocked HOME. */
+function pluginDest(home) {
+  return join(home, '.config', 'opencode', 'plugins', 'bizar');
+}
+
+/**
+ * Build a fake plugin source tree, optionally including a `node_modules/`
+ * directory with a couple of packages. Used to drive the function under
+ * test without touching the real global npm install.
+ */
+function makeFakeSource({ withNodeModules = true } = {}) {
+  const src = mkdtempSync(join(tmpdir(), 'fake-plugin-src-'));
+  writeFileSync(
+    join(src, 'package.json'),
+    JSON.stringify({
+      name: '@polderlabs/bizar-plugin',
+      version: '0.0.0-test',
+    }),
+  );
+  writeFileSync(join(src, 'index.ts'), '// fake plugin');
+  if (withNodeModules) {
+    // Mimics the real npm install layout:
+    //   node_modules/
+    //     @polderlabs/bizar-sdk/package.json   <-- the workspace-internal import
+    //     some-dep/package.json               <-- a transitive dep
+    //     some-dep/lib/index.js               <-- nested file
+    mkdirSync(join(src, 'node_modules'));
+    mkdirSync(join(src, 'node_modules', '@polderlabs'));
+    mkdirSync(join(src, 'node_modules', '@polderlabs', 'bizar-sdk'));
+    writeFileSync(
+      join(src, 'node_modules', '@polderlabs', 'bizar-sdk', 'package.json'),
+      JSON.stringify({ name: '@polderlabs/bizar-sdk', version: '1.0.0' }),
+    );
+    mkdirSync(join(src, 'node_modules', 'some-dep'));
+    writeFileSync(
+      join(src, 'node_modules', 'some-dep', 'package.json'),
+      JSON.stringify({ name: 'some-dep', version: '2.0.0' }),
+    );
+    mkdirSync(join(src, 'node_modules', 'some-dep', 'lib'));
+    writeFileSync(
+      join(src, 'node_modules', 'some-dep', 'lib', 'index.js'),
+      'module.exports = 1;',
+    );
+  }
+  return src;
+}
+
+/** Restore env at the very end (individual tests restore in afterEach). */
+after(() => {
+  if (ORIG_HOME === undefined) delete process.env.HOME;
+  else process.env.HOME = ORIG_HOME;
+  if (ORIG_XDG === undefined) delete process.env.XDG_CONFIG_HOME;
+  else process.env.XDG_CONFIG_HOME = ORIG_XDG;
+});
+
+// ── installPluginFromGlobal — node_modules copy ───────────────────────────────
+
+describe('installPluginFromGlobal() — node_modules copy', () => {
+  let home;
+  let sourceDir;
+
+  beforeEach(() => {
+    home = freshHome();
+  });
+
+  afterEach(() => {
+    if (home && existsSync(home)) rmSync(home, { recursive: true, force: true });
+    if (sourceDir && existsSync(sourceDir)) rmSync(sourceDir, { recursive: true, force: true });
+    if (ORIG_HOME === undefined) delete process.env.HOME;
+    else process.env.HOME = ORIG_HOME;
+    if (ORIG_XDG === undefined) delete process.env.XDG_CONFIG_HOME;
+    else process.env.XDG_CONFIG_HOME = ORIG_XDG;
+  });
+
+  test('copies node_modules from source when present', async () => {
+    sourceDir = makeFakeSource({ withNodeModules: true });
+    const dest = pluginDest(home);
+
+    const ok = await installPluginFromGlobal({ sourceDir });
+    assert.equal(ok, true);
+
+    // Plugin file copied.
+    assert.equal(existsSync(join(dest, 'index.ts')), true);
+    assert.equal(existsSync(join(dest, 'package.json')), true);
+
+    // node_modules copied (the actual fix).
+    const destNm = join(dest, 'node_modules');
+    assert.equal(existsSync(destNm), true);
+    assert.equal(
+      existsSync(join(destNm, 'some-dep', 'package.json')),
+      true,
+      'top-level dep copied',
+    );
+    assert.equal(
+      existsSync(join(destNm, 'some-dep', 'lib', 'index.js')),
+      true,
+      'nested file inside top-level dep copied',
+    );
+    assert.equal(
+      existsSync(join(destNm, '@polderlabs', 'bizar-sdk', 'package.json')),
+      true,
+      'scoped @polderlabs/bizar-sdk copied (the actual bug fix)',
+    );
+  });
+
+  test('no-op for node_modules when source has none', async () => {
+    sourceDir = makeFakeSource({ withNodeModules: false });
+    const dest = pluginDest(home);
+
+    const ok = await installPluginFromGlobal({ sourceDir });
+    assert.equal(ok, true);
+
+    // Plugin file copied.
+    assert.equal(existsSync(join(dest, 'index.ts')), true);
+
+    // node_modules should NOT exist — we don't create empty dirs.
+    const destNm = join(dest, 'node_modules');
+    assert.equal(existsSync(destNm), false);
+  });
+
+  test('idempotent: running twice does not error and preserves extras', async () => {
+    sourceDir = makeFakeSource({ withNodeModules: true });
+    const dest = pluginDest(home);
+
+    const ok1 = await installPluginFromGlobal({ sourceDir });
+    assert.equal(ok1, true);
+
+    // Drop a marker that simulates a user adding their own package.
+    // After a second run, this marker must STILL be present (cp -r
+    // semantics — don't delete, just overwrite/add).
+    const destNm = join(dest, 'node_modules');
+    mkdirSync(join(destNm, 'user-added'), { recursive: true });
+    writeFileSync(join(destNm, 'user-added', 'marker.json'), '{}');
+
+    const ok2 = await installPluginFromGlobal({ sourceDir });
+    assert.equal(ok2, true, 'second call should still return true');
+
+    // User's marker is still there.
+    assert.equal(
+      existsSync(join(destNm, 'user-added', 'marker.json')),
+      true,
+      'user-added extras preserved across re-runs',
+    );
+
+    // And the npm-bundled contents are still there.
+    assert.equal(
+      existsSync(join(destNm, '@polderlabs', 'bizar-sdk', 'package.json')),
+      true,
+      '@polderlabs/bizar-sdk still present after second run',
+    );
+    assert.equal(
+      existsSync(join(destNm, 'some-dep', 'lib', 'index.js')),
+      true,
+      'nested file still present after second run',
+    );
+  });
+
+  test('refuses to overwrite a symlinked node_modules', async () => {
+    sourceDir = makeFakeSource({ withNodeModules: true });
+    const dest = pluginDest(home);
+
+    // Pre-create dest as a real dir (the outer copy needs a real dest)
+    // AND pre-create dest/node_modules as a symlink to some unrelated
+    // location. The fix must NOT dereference through the symlink and
+    // must leave it intact.
+    mkdirSync(dest, { recursive: true });
+    const linkTarget = mkdtempSync(join(tmpdir(), 'nm-link-target-'));
+    const destNm = join(dest, 'node_modules');
+    symlinkSync(linkTarget, destNm);
+
+    try {
+      const ok = await installPluginFromGlobal({ sourceDir });
+      // Outer install succeeds (the file copy still works — it doesn't
+      // touch node_modules at the dest).
+      assert.equal(ok, true);
+
+      // The symlink must still be a symlink — we refused to dereference.
+      assert.equal(
+        lstatSync(destNm).isSymbolicLink(),
+        true,
+        'node_modules symlink preserved (not dereferenced)',
+      );
+
+      // SDK NOT copied into the link target (we skipped the copy).
+      assert.equal(
+        existsSync(join(linkTarget, '@polderlabs')),
+        false,
+        'refused copy did not leak into link target',
+      );
+    } finally {
+      rmSync(linkTarget, { recursive: true, force: true });
+    }
+  });
+});
+
+console.log('  install.mjs tests loaded — run with: node --test cli/install.test.mjs');

package/cli/update.mjs

@@ -233,9 +233,18 @@ function latestVersion(pkg) {
 /**
  * Update opencode. Tries `opencode upgrade` first (the upstream installer's
  * own command); falls back to `npm install -g opencode-ai@latest`.
+ * Pass `{ dryRun: true }` to print what would run without executing.
  * Returns `{ ok: boolean, message: string }`.
  */
-function updateOpencode() {
+function updateOpencode({ dryRun = false } = {}) {
+  if (dryRun) {
+    console.log(
+      chalk.dim(
+        '  [dry-run] would run: opencode upgrade (fallback: npm install -g opencode-ai@latest)',
+      ),
+    );
+    return { ok: true, message: '[dry-run] opencode' };
+  }
   const r1 = spawnSync('opencode', ['upgrade'], { stdio: 'inherit' });
   if (r1.status === 0) {
     return { ok: true, message: 'opencode updated via `opencode upgrade`' };
@@ -248,7 +257,13 @@ function updateOpencode() {
   return { ok: false, message: 'opencode update failed — try `opencode upgrade` manually' };
 }
 
-function updatePackage(pkg) {
+function updatePackage(pkg, { dryRun = false } = {}) {
+  if (dryRun) {
+    console.log(
+      chalk.dim(`  [dry-run] would run: npm install -g ${pkg}@latest`),
+    );
+    return { ok: true, message: `[dry-run] ${pkg}` };
+  }
   const r = spawnSync('npm', ['install', '-g', `${pkg}@latest`], { stdio: 'inherit' });
   if (r.status !== 0) {
     return { ok: false, message: `${pkg} update failed` };
@@ -467,27 +482,43 @@ export async function runUpdate(subargs = []) {
   const assumeYes = subargs.includes('--yes') || subargs.includes('-y') || subargs.includes('--force');
   const restartAfter = !subargs.includes('--no-restart');
   const forceAll = subargs.includes('--all');
+  const dryRun = subargs.includes('--dry-run');
+
+  if (dryRun) {
+    console.log(
+      chalk.dim('  --dry-run set: no installs, kills, or restarts will be performed.\n'),
+    );
+  }
 
   // 1. Detect running instances BEFORE doing anything else.
   const instances = detectInstances();
   const runningCount = (instances.service ? 1 : 0) + (instances.dashboard ? 1 : 0);
 
   if (runningCount > 0) {
-    const ok = await confirmKill(instances, { assumeYes });
-    if (!ok) {
-      console.log(chalk.yellow('\n  Update cancelled — instances still running.'));
-      console.log(chalk.dim('  Stop them with `bizar service stop` and `bizar dashboard stop`, then retry.'));
-      process.exit(1);
-    }
-    console.log(chalk.cyan('\n  Stopping running instances...'));
-    const kills = await killInstances(instances);
-    for (const k of kills) {
-      const marker = k.ok ? chalk.green('✓') : chalk.red('✗');
-      console.log(`    ${marker} ${k.name} stopped`);
+    if (dryRun) {
+      const labels = [];
+      if (instances.service) labels.push(instances.service.label);
+      if (instances.dashboard) labels.push(instances.dashboard.label);
+      console.log(
+        chalk.dim(`  [dry-run] would stop running instances: ${labels.join(', ')}`),
+      );
+    } else {
+      const ok = await confirmKill(instances, { assumeYes });
+      if (!ok) {
+        console.log(chalk.yellow('\n  Update cancelled — instances still running.'));
+        console.log(chalk.dim('  Stop them with `bizar service stop` and `bizar dashboard stop`, then retry.'));
+        process.exit(1);
+      }
+      console.log(chalk.cyan('\n  Stopping running instances...'));
+      const kills = await killInstances(instances);
+      for (const k of kills) {
+        const marker = k.ok ? chalk.green('✓') : chalk.red('✗');
+        console.log(`    ${marker} ${k.name} stopped`);
+      }
+      // Give the kernel a moment to release any open file handles on the
+      // npm-global directory before npm tries to replace files.
+      await new Promise((resolve) => setTimeout(resolve, 500));
     }
-    // Give the kernel a moment to release any open file handles on the
-    // npm-global directory before npm tries to replace files.
-    await new Promise((resolve) => setTimeout(resolve, 500));
   } else {
     console.log(chalk.dim('  No running Bizar instances detected.'));
   }
@@ -523,8 +554,19 @@ export async function runUpdate(subargs = []) {
 
   // 3. Decide what to update.
   let selected;
-  if (forceAll || assumeYes) {
+  if (forceAll || assumeYes || dryRun) {
+    // dryRun defaults to showing everything (the whole point is to see
+    // what *would* change across the board). Pass a positional list to
+    // narrow the preview.
     selected = new Set(COMPONENTS);
+    // If the user passed positional component names alongside --dry-run,
+    // narrow the selection to those.
+    const positional = subargs.filter((a) => !a.startsWith('-'));
+    if (positional.length > 0) {
+      const valid = new Set(COMPONENTS);
+      const narrowed = positional.filter((a) => valid.has(a));
+      if (narrowed.length > 0) selected = new Set(narrowed);
+    }
   } else if (subargs.length === 0) {
     selected = await promptForUpdates(false);
   } else {
@@ -548,44 +590,57 @@ export async function runUpdate(subargs = []) {
   const results = [];
   if (selected.has('opencode')) {
     console.log(chalk.bold('  → opencode'));
-    results.push(['opencode', updateOpencode()]);
+    results.push(['opencode', updateOpencode({ dryRun })]);
   }
   if (selected.has('bizar')) {
     console.log(chalk.bold(`  → ${PKG_MAIN}`));
-    results.push(['bizar', updatePackage(PKG_MAIN)]);
+    results.push(['bizar', updatePackage(PKG_MAIN, { dryRun })]);
   }
   if (selected.has('dash')) {
     console.log(chalk.bold(`  → ${PKG_DASH}`));
-    results.push(['dash', updatePackage(PKG_DASH)]);
+    results.push(['dash', updatePackage(PKG_DASH, { dryRun })]);
   }
   if (selected.has('plugin')) {
     console.log(chalk.bold(`  → ${PKG_PLUGIN}`));
-    results.push(['plugin', updatePackage(PKG_PLUGIN)]);
+    results.push(['plugin', updatePackage(PKG_PLUGIN, { dryRun })]);
   }
 
   // 4. Re-run the install script if anything relevant changed.
   const anySuccess = results.some(([, r]) => r.ok);
   if (anySuccess && (selected.has('bizar') || selected.has('plugin'))) {
     console.log('');
-    const rerun = rerunInstallScript();
-    if (rerun.ok) {
-      console.log(chalk.green(`\n  ✓ ${rerun.message}`));
+    if (dryRun) {
+      console.log(
+        chalk.dim(
+          '  [dry-run] would re-run install script (bin.mjs --setup or install.sh)',
+        ),
+      );
     } else {
-      console.log(chalk.yellow(`\n  ⚠ ${rerun.message}`));
-      console.log(chalk.dim('    Run `bash install.sh` from the Bizar repo manually.'));
+      const rerun = rerunInstallScript();
+      if (rerun.ok) {
+        console.log(chalk.green(`\n  ✓ ${rerun.message}`));
+      } else {
+        console.log(chalk.yellow(`\n  ⚠ ${rerun.message}`));
+        console.log(chalk.dim('    Run `bash install.sh` from the Bizar repo manually.'));
+      }
     }
   }
 
   // 5. Restart the dashboard if it was running before the update.
   if (restartAfter && instances.dashboard && (selected.has('bizar') || selected.has('dash'))) {
-    console.log('');
-    console.log(chalk.cyan('  Restarting dashboard with the new code...'));
-    const res = spawnFreshDashboard({ port: instances.dashboard.port || undefined });
-    if (res.ok) {
-      console.log(chalk.green(`  ✓ ${res.message}`));
+    if (dryRun) {
+      console.log('');
+      console.log(chalk.dim('  [dry-run] would restart dashboard with the new code'));
     } else {
-      console.log(chalk.yellow(`  ⚠ ${res.message}`));
-      console.log(chalk.dim('    Start it manually with `bizar dash start --bg`.'));
+      console.log('');
+      console.log(chalk.cyan('  Restarting dashboard with the new code...'));
+      const res = spawnFreshDashboard({ port: instances.dashboard.port || undefined });
+      if (res.ok) {
+        console.log(chalk.green(`  ✓ ${res.message}`));
+      } else {
+        console.log(chalk.yellow(`  ⚠ ${res.message}`));
+        console.log(chalk.dim('    Start it manually with `bizar dash start --bg`.'));
+      }
     }
   }
 
@@ -602,5 +657,40 @@ export async function runUpdate(subargs = []) {
     console.log(chalk.yellow('\n  Some updates failed. See messages above.'));
     process.exit(1);
   }
+  if (dryRun) {
+    console.log(
+      chalk.green('\n  ✓ Dry-run complete (no installs, kills, or restarts performed)\n'),
+    );
+    return;
+  }
   console.log(chalk.green('\n  ✓ Update complete\n'));
+
+  // 7. Post-update health check (v3.12.2). Catches a bad config merge or
+  // missing files before the user discovers it via a broken opencode session.
+  try {
+    const { runDoctor } = await import('./doctor.mjs');
+    const result = await runDoctor({ silent: true });
+    if (result.failed > 0) {
+      console.log('');
+      console.log(
+        chalk.yellow('  ⚠ Post-update health check found issues:'),
+      );
+      for (const r of result.results) {
+        if (!r.ok) {
+          console.log(chalk.red(`    ✗ ${r.name}: ${r.message}`));
+        }
+      }
+      console.log(chalk.dim('  Run `bizar doctor` for details.'));
+      process.exit(1);
+    }
+  } catch (err) {
+    // Doctor import or runtime failure shouldn't crash the update —
+    // log a hint and let the user run `bizar doctor` themselves.
+    console.log(
+      chalk.yellow(
+        `  ⚠ Post-update health check could not run: ${err.message}`,
+      ),
+    );
+    console.log(chalk.dim('  Run `bizar doctor` manually to verify the install.'));
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar",
-  "version": "3.12.1",
+  "version": "3.12.3",
   "description": "Norse-pantheon multi-agent system for opencode — 13 agents across 4 cost tiers with cost-aware routing, plans, and a configurable agent harness.",
   "type": "module",
   "bin": {