@polderlabs/bizar 3.14.1 → 3.15.1

package/cli/bin.mjs

@@ -84,7 +84,7 @@ function showHelp() {
     plan <subcommand>  Manage visual plans
     graph               Per-project knowledge graph (powered by graphify)
     test-gate           Detect & run the project's test suite
-    update              Update opencode, bizar, and/or bizar-plugin
+    update              Auto-update everything (opencode + bizar + dash + plugin)
     service             Manage the background service daemon
     bg <subcommand>     Manage background agents (list/view/kill/logs)
     dash <subcommand>   Manage the dashboard (start/stop/status/tui)
@@ -182,13 +182,12 @@ function showInstallHelp() {
 
 function showUpdateHelp() {
   console.log(`
-  bizar update — Update opencode, bizar, and/or bizar-plugin
+  bizar update — Update opencode, bizar, bizar-dash, and/or bizar-plugin
 
   Usage:
-    bizar update                       Interactive prompt for components
-    bizar update --all                 Update every component
+    bizar update                       Update EVERYTHING (default; auto-kills + restarts)
+    bizar update --pick                Interactive picker (legacy per-component UI)
     bizar update opencode bizar dash    Update specific components
-    bizar update --all --yes           Update everything + auto-kill running instances
     bizar update --no-restart          Don't auto-restart the dashboard after update
     bizar update --dry-run             Print what would happen, change nothing
     bizar update --help                Show this help
@@ -199,13 +198,15 @@ function showUpdateHelp() {
     dash       @polderlabs/bizar-dash (web dashboard + TUI)
     plugin     @polderlabs/bizar-plugin (opencode plugin)
 
-  Behavior:
+  Behavior (v3.15.0+):
+    • Default = automatic. Updates all 4 components without prompting.
+      Any missing package is auto-installed so a broken install gets
+      repaired in one shot.
     • Detects running Bizar instances (background service daemon, web
       dashboard) by reading ~/.config/bizar/{service,dashboard}.pid and
-      cleaning up any stale or empty PID files.
-    • Warns the user explicitly before killing each instance. Pass
-      --yes / -y / --force to skip the confirmation (required for
-      non-interactive shells).
+      cleans up any stale or empty PID files.
+    • Auto-kills running instances with a brief notice (use --pick to
+      be prompted first instead).
     • Sends SIGTERM, waits up to 5s, escalates to SIGKILL if needed.
     • Re-runs the install script so the deployed plugin source matches
       the just-upgraded npm version (avoids the version-skew trap).
@@ -214,15 +215,12 @@ function showUpdateHelp() {
       (skipped with --no-restart).
     • Runs \`bizar doctor\` after a successful update to catch config
       regressions before opencode tries to start.
-    • If ~/.config/opencode/plugins/bizar is a dev symlink (created
-      by \`bizar dev-link\`), the copy step is skipped to preserve the
-      link. Use \`bizar dev-unlink\` first, or pass --force.
 
   Examples:
-    bizar update --all --yes           Headless full update + restart
-    bizar update dash                  Update only the dashboard
+    bizar update                       Full auto-update (recommended)
+    bizar update --dry-run             Preview what would change
+    bizar update --pick                Pick specific components
     bizar update plugin --no-restart   Plugin-only, leave dashboard alone
-    bizar update --all --dry-run       See what would change without doing it
   `);
 }
 

package/cli/graph-build-from-cache.mjs

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+/**
+ * cli/graph-build-from-cache.mjs
+ *
+ * One-off script for environments where graphify's semantic-extraction
+ * step fails (e.g. no LLM API key + remaining non-code docs that the
+ * `.graphifyignore` can't filter) but the AST cache is intact.
+ *
+ * graphify's pipeline has two stages:
+ *   1. AST extraction (local, tree-sitter) — writes per-file JSON to
+ *      `.bizar/graph/cache/ast/v0.8.46/<hash>.json` regardless of LLM status.
+ *   2. Semantic extraction (LLM, optional) — merges per-file nodes into a
+ *      project-wide graph.
+ *
+ * If stage 2 aborts, `graph.json` is never written and the dashboard has
+ * nothing to render. This script reconstructs `graph.json` directly from
+ * the per-file AST cache, then calls `graphify cluster-only` to generate
+ * `graph.html` + `GRAPH_REPORT.md`.
+ *
+ * Usage:
+ *   node cli/graph-build-from-cache.mjs                 # use .bizar/graph/
+ *   node cli/graph-build-from-cache.mjs /tmp/other/graph # custom dir
+ */
+
+import { readFileSync, writeFileSync, existsSync, readdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+
+const graphDirArg = process.argv[2] || '.bizar/graph';
+const graphDir = resolve(graphDirArg);
+
+// The cache version directory inside graphify's cache layout. Bumping the
+// graphify version moves the cache; we discover the actual subdir at
+// runtime so we don't hardcode "v0.8.46".
+const cacheAstRoot = join(graphDir, 'cache', 'ast');
+
+function findCacheDir() {
+  if (!existsSync(cacheAstRoot)) {
+    throw new Error(`No AST cache found at ${cacheAstRoot}. Run \`bizar graph build\` first to populate it.`);
+  }
+  const entries = readdirSync(cacheAstRoot);
+  if (entries.length === 0) {
+    throw new Error(`AST cache directory ${cacheAstRoot} is empty.`);
+  }
+  // graphify uses one version directory like v0.8.46. Pick the first.
+  return join(cacheAstRoot, entries[0]);
+}
+
+function buildGraphFromCache(cacheDir) {
+  const files = readdirSync(cacheDir).filter((f) => f.endsWith('.json'));
+  console.log(`  Reading ${files.length} AST cache files from ${cacheDir}...`);
+
+  const nodesById = new Map();
+  const edges = [];
+  const rawCalls = [];
+
+  let fileIdx = 0;
+  for (const f of files) {
+    fileIdx++;
+    const raw = JSON.parse(readFileSync(join(cacheDir, f), 'utf8'));
+    for (const n of raw.nodes || []) {
+      // Later files win on duplicate id (consistent with graphify's
+      // dedup behavior — first write keeps the canonical location).
+      if (!nodesById.has(n.id)) nodesById.set(n.id, n);
+    }
+    for (const e of raw.edges || []) edges.push(e);
+    for (const rc of raw.raw_calls || []) rawCalls.push(rc);
+    if (fileIdx % 50 === 0) {
+      console.log(`    merged ${fileIdx}/${files.length} files`);
+    }
+  }
+
+  // Re-key node.community so it matches the dashboard's expected schema.
+  // The AST cache uses `community` as a numeric cluster id; we keep it as-is.
+  const nodes = Array.from(nodesById.values());
+
+  const graph = {
+    directed: false,
+    multigraph: false,
+    graph: {},
+    nodes,
+    links: edges,
+  };
+
+  console.log(`  Built graph: ${nodes.length} nodes, ${edges.length} edges (raw_calls=${rawCalls.length})`);
+  return { graph, rawCalls };
+}
+
+function writeOutputs(graphDir, graph) {
+  // graph.json — NetworkX node-link format
+  const graphJsonPath = join(graphDir, 'graph.json');
+  writeFileSync(graphJsonPath, JSON.stringify(graph, null, 2), 'utf8');
+  console.log(`  ✓ Wrote ${graphJsonPath}`);
+
+  // .graphify_analysis.json — graphify's secondary output. cluster-only
+  // doesn't strictly require this, but writing it keeps the directory
+  // shape consistent with what `graphify .` would have produced.
+  const analysis = {
+    schema_version: 1,
+    generated_at: new Date().toISOString(),
+    clusters: [],
+  };
+  const analysisPath = join(graphDir, '.graphify_analysis.json');
+  writeFileSync(analysisPath, JSON.stringify(analysis, null, 2), 'utf8');
+  console.log(`  ✓ Wrote ${analysisPath}`);
+}
+
+function main() {
+  console.log(`  Graph dir: ${graphDir}`);
+  if (!existsSync(graphDir)) {
+    throw new Error(`Graph dir does not exist: ${graphDir}`);
+  }
+  const cacheDir = findCacheDir();
+  const { graph } = buildGraphFromCache(cacheDir);
+  writeOutputs(graphDir, graph);
+  console.log('');
+  console.log('  Next step: run `bizar graph cluster-only` to generate graph.html.');
+}
+
+try {
+  main();
+} catch (err) {
+  console.error(`\n  Error: ${err.message}\n`);
+  process.exit(1);
+}

package/cli/graph.mjs

@@ -7,7 +7,7 @@
 
 import chalk from 'chalk';
 import { spawnSync } from 'node:child_process';
-import { existsSync, readFileSync, mkdirSync, writeFileSync, statSync } from 'node:fs';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, statSync, copyFileSync } from 'node:fs';
 import { join } from 'node:path';
 
 // ── Constants ─────────────────────────────────────────────────────────────────
@@ -15,6 +15,82 @@ import { join } from 'node:path';
 export const GRAPH_DIR = '.bizar/graph';
 export const GRAPHIFY_OUT_ENV = 'GRAPHIFY_OUT';
 
+/**
+ * Env vars graphify recognises for semantic extraction of docs/papers/images.
+ * If NONE of these are set, graphify refuses to run on a corpus that contains
+ * any non-code file ("A code-only corpus needs no key."). We auto-detect this
+ * and write a comprehensive .graphifyignore so a fresh checkout can build
+ * the graph offline with no LLM key.
+ */
+const GRAPHIFY_LLM_KEY_ENVS = [
+  'GEMINI_API_KEY', 'GOOGLE_API_KEY',
+  'MOONSHOT_API_KEY',
+  'ANTHROPIC_API_KEY',
+  'OPENAI_API_KEY',
+  'DEEPSEEK_API_KEY',
+  'AZURE_OPENAI_API_KEY',
+];
+
+/**
+ * Minimal .graphifyignore that restricts graphify to code-only extraction.
+ * Written automatically by `bizar graph build` when no LLM key is set.
+ * The user can override this file with their own .graphifyignore — we
+ * never overwrite a pre-existing one.
+ */
+const CODE_ONLY_GRAPHIFYIGNORE = [
+  '# Auto-generated by `bizar graph build` — code-only mode.',
+  '# Bizar detected no LLM key, so docs/papers/images cannot be semantically',
+  '# extracted. We restrict extraction to code files (processed locally via',
+  "# tree-sitter — no API key needed). Delete this file and re-run once you've",
+  '# set one of: GEMINI_API_KEY, GOOGLE_API_KEY, MOONSHOT_API_KEY,',
+  '# ANTHROPIC_API_KEY, OPENAI_API_KEY, DEEPSEEK_API_KEY, AZURE_OPENAI_API_KEY.',
+  '',
+  '# Heavy / vendored dirs to skip entirely',
+  'node_modules/',
+  '.git/',
+  '.bizar/',
+  '.agents/',
+  'dist/',
+  'build/',
+  'coverage/',
+  '',
+  '# Agent system prompts — they\'re Markdown but contain YAML frontmatter',
+  '# + system instructions, not project documentation. They\'re noise for',
+  '# a structural graph and would balloon the doc count to ~1100.',
+  'config/agents/',
+  '',
+  '# Non-code file types — graphify would need an LLM for these',
+  '*.md',
+  '*.mdx',
+  '*.qmd',
+  '*.html',
+  '*.txt',
+  '*.rst',
+  '*.pdf',
+  '*.png',
+  '*.jpg',
+  '*.jpeg',
+  '*.webp',
+  '*.gif',
+  '*.mp4',
+  '*.mov',
+  '*.mp3',
+  '*.wav',
+  '',
+].join('\n');
+
+/**
+ * Detect whether any graphify-recognised LLM API key is set in the
+ * current process env. Used by `cmdBuild` to decide whether to write
+ * the code-only .graphifyignore.
+ */
+function hasLlmKey(env = process.env) {
+  return GRAPHIFY_LLM_KEY_ENVS.some((k) => {
+    const v = env[k];
+    return typeof v === 'string' && v.trim().length > 0;
+  });
+}
+
 // ── Python detection ───────────────────────────────────────────────────────────
 
 /**
@@ -190,15 +266,176 @@ function runGraphify(python, subArgs, extraEnv = {}) {
 // ── Subcommand handlers ────────────────────────────────────────────────────────
 
 async function cmdBuild(python) {
+  // If no LLM key is set, fall back to a code-only build by writing a
+  // comprehensive .graphifyignore. We never overwrite a user-provided
+  // .graphifyignore — only create the file when it doesn't exist.
+  let llmKeyPresent = hasLlmKey();
+  if (!llmKeyPresent) {
+    const ignorePath = '.graphifyignore';
+    if (!existsSync(ignorePath)) {
+      writeFileSync(ignorePath, CODE_ONLY_GRAPHIFYIGNORE, 'utf8');
+      console.log(chalk.dim('  No LLM API key detected — switching to code-only build.'));
+      console.log(chalk.dim(`  Wrote ${ignorePath} restricting extraction to code files.`));
+      console.log(chalk.dim('  Set GEMINI_API_KEY / OPENAI_API_KEY / etc. and re-run for full docs extraction.\n'));
+    } else {
+      console.log(chalk.dim('  No LLM API key detected — using existing .graphifyignore for code-only build.\n'));
+    }
+  }
+
   console.log(chalk.dim('  Running full graphify pipeline...'));
-  const code = runGraphify(python, ['.']);
+  let code = runGraphify(python, ['.']);
+
+  // Offline code-only fallback — when no LLM key is set, graphify's
+  // pre-flight check rejects the build before it can write any output.
+  // Even with a dummy key set, the semantic step fails for any non-code
+  // docs that escaped the .graphifyignore filter, and graphify refuses
+  // to write graph.json. To unblock this case we:
+  //   1. Run graphify with a dummy ANTHROPIC_API_KEY so the AST cache
+  //      gets populated (semantic extraction will fail, that's fine).
+  //   2. Reconstruct graph.json from the per-file AST cache.
+  //   3. Run cluster-only to generate graph.html + GRAPH_REPORT.md.
+  if (code !== 0 && !llmKeyPresent) {
+    const cacheAstRoot = join(GRAPH_DIR, 'cache', 'ast');
+    const cacheIsPopulated = existsSync(cacheAstRoot) && (
+      // graphify creates a versioned subdir on first extract.
+      // Check if any version dir contains JSON files.
+      (await import('node:fs/promises'))
+        .readdir(cacheAstRoot, { withFileTypes: true })
+        .then((entries) =>
+          entries.some(async (e) => {
+            if (!e.isDirectory()) return false;
+            const files = await (await import('node:fs/promises')).readdir(join(cacheAstRoot, e.name));
+            return files.some((f) => f.endsWith('.json'));
+          }),
+        )
+        .catch(() => false)
+    );
+
+    if (!cacheIsPopulated) {
+      console.log(chalk.yellow('  ⚠ No AST cache yet. Running graphify with a dummy key to populate the cache (semantic extraction will fail; that\'s OK)...'));
+      // Set a dummy key so graphify gets past its pre-flight check and
+      // populates the AST cache. We invoke the graphify binary directly
+      // (the user's python3 -m graphify may not have graphify installed;
+      // uv-tool installs put a shim at ~/.local/bin/graphify).
+      const dummyRes = spawnSync('graphify', ['.'], {
+        stdio: 'inherit',
+        env: { ...process.env, ANTHROPIC_API_KEY: 'sk-bizar-graph-dummy', GRAPHIFY_OUT: GRAPH_DIR },
+        timeout: 0,
+      });
+      void dummyRes; // exit code doesn't matter — we want the cache, not the merge
+    }
+
+    const cacheStillEmpty = !(await (async () => {
+      try {
+        const e = await (await import('node:fs/promises')).readdir(cacheAstRoot, { withFileTypes: true });
+        for (const d of e) {
+          if (!d.isDirectory()) continue;
+          const f = await (await import('node:fs/promises')).readdir(join(cacheAstRoot, d.name));
+          if (f.some((x) => x.endsWith('.json'))) return true;
+        }
+        return false;
+      } catch {
+        return false;
+      }
+    })());
+
+    if (!cacheStillEmpty) {
+      console.log(chalk.yellow('  ⚠ graphify exited non-zero. Falling back to AST-cache build...'));
+      const fb = runCacheFallbackBuild();
+      if (fb === 0) code = 0;
+    }
+  }
+
   if (code === 0) {
     ensureGitignore(GRAPH_DIR);
+    // After extract, run cluster-only to write graph.html + GRAPH_REPORT.md
+    // (extract only writes graph.json; cluster-only adds viz + report).
+    const graphJson = join(GRAPH_DIR, 'graph.json');
+    if (existsSync(graphJson)) {
+      console.log(chalk.dim('  Generating graph.html + GRAPH_REPORT.md via cluster-only...'));
+      // Pass "." as the cluster-only path so it writes graph.html +
+      // GRAPH_REPORT.md to the current directory's graphify-out/.
+      // (Passing `.bizar/graph` directly nests the output as
+      // `.bizar/graph/.bizar/graph/...` which is wrong.) The explicit
+      // --graph overrides the auto-discovery to find graph.json.
+      const clusterArgs = ['cluster-only', '.', '--graph', graphJson];
+      const clusterCode = runGraphify(python, clusterArgs);
+      if (clusterCode !== 0) {
+        console.log(chalk.yellow(`  ⚠ cluster-only returned ${clusterCode} — graph.json was built but graph.html may be stale.`));
+      } else {
+        // cluster-only writes to ./graphify-out/ (relative to CWD).
+        // Promote the artifacts up to .bizar/graph/ paths the dashboard
+        // serves directly.
+        const out = join(GRAPH_DIR, 'graphify-out');
+        if (!existsSync(out)) {
+          // Fallback: graphify may have written to ./graphify-out/ at CWD.
+          const cwdOut = join(process.cwd(), 'graphify-out');
+          if (existsSync(cwdOut)) {
+            promoteFromDir(cwdOut, GRAPH_DIR);
+          }
+        } else {
+          promoteClusterOutputs(GRAPH_DIR);
+        }
+      }
+    }
     console.log(chalk.green(`\n  ✓ Graph built → ${GRAPH_DIR}/\n`));
   }
   return code;
 }
 
+/**
+ * Reconstruct graph.json from graphify's per-file AST cache and run
+ * cluster-only to produce graph.html + GRAPH_REPORT.md. Used when the
+ * full graphify pipeline fails because some docs need an LLM that we
+ * don't have, but the AST cache for code-only files was successfully
+ * extracted.
+ *
+ * Returns the exit code of the overall sequence (0 on success).
+ */
+function runCacheFallbackBuild() {
+  // Step 1: merge the per-file AST cache into a single graph.json.
+  const scriptPath = new URL(import.meta.url).pathname;
+  // cli/graph.mjs sits next to cli/graph-build-from-cache.mjs.
+  const cacheScript = scriptPath.replace(/graph\.mjs$/, 'graph-build-from-cache.mjs');
+  if (!existsSync(cacheScript)) {
+    console.log(chalk.red(`  ✗ Cache fallback script not found at ${cacheScript}`));
+    return 1;
+  }
+  const buildRes = spawnSync(process.execPath, [cacheScript, GRAPH_DIR], {
+    stdio: 'inherit',
+  });
+  if (buildRes.status !== 0) {
+    return buildRes.status ?? 1;
+  }
+  // Step 2: cluster-only regenerates graph.html from the merged graph.json.
+  return 0;
+}
+
+/**
+ * Copy the named files from `srcDir` up to `dstDir`. Used to hoist
+ * cluster-only's graph.html / GRAPH_REPORT.md / graph.json up to the
+ * canonical .bizar/graph/ paths the dashboard serves.
+ */
+function promoteFromDir(srcDir, dstDir) {
+  for (const name of ['graph.html', 'GRAPH_REPORT.md', 'graph.json']) {
+    const src = join(srcDir, name);
+    const dst = join(dstDir, name);
+    if (existsSync(src)) {
+      copyFileSync(src, dst);
+    }
+  }
+}
+
+/**
+ * cluster-only writes its outputs to a nested graphify-out/ directory
+ * by default. This hoists them up to the standard paths the dashboard
+ * serves (.bizar/graph/graph.html + .bizar/graph/GRAPH_REPORT.md).
+ */
+function promoteClusterOutputs(graphDir) {
+  const out = join(graphDir, 'graphify-out');
+  if (existsSync(out)) promoteFromDir(out, graphDir);
+}
+
 async function cmdUpdate(python) {
   console.log(chalk.dim('  Running incremental graph update...'));
   return runGraphify(python, ['.', '--update']);

package/cli/update.mjs

@@ -475,6 +475,22 @@ async function promptForUpdates(forceAll) {
 // Main entry point
 // ---------------------------------------------------------------------------
 
+/**
+ * Default behavior policy for `bizar update`:
+ *   - Update EVERYTHING (opencode + bizar + dash + plugin) automatically.
+ *   - Auto-install any missing component without asking.
+ *   - Kill running instances without confirmation (with a brief notice).
+ *   - Re-run the install script to refresh the on-disk plugin.
+ *   - Restart the dashboard if it was running.
+ *
+ * The `--pick` / `-p` flag opts into the legacy per-component picker
+ * (checkbox UI) for users who want to update only some components.
+ *
+ * The `--dry-run` flag previews what would happen without touching
+ * anything.
+ *
+ * The `--no-restart` flag skips the dashboard restart step.
+ */
 export async function runUpdate(subargs = []) {
   console.log(chalk.bold.hex('#a855f7')('\n  ᚦ BIZAR UPDATE ᚦ\n'));
 
@@ -483,6 +499,11 @@ export async function runUpdate(subargs = []) {
   const restartAfter = !subargs.includes('--no-restart');
   const forceAll = subargs.includes('--all');
   const dryRun = subargs.includes('--dry-run');
+  // Opt-in interactive picker. Without `--pick`, we update everything
+  // automatically. This matches what the user actually wants 95% of
+  // the time ("update my install") and removes a prompt that
+  // interrupted the flow.
+  const interactivePick = subargs.includes('--pick') || subargs.includes('-p');
 
   if (dryRun) {
     console.log(
@@ -503,13 +524,16 @@ export async function runUpdate(subargs = []) {
         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...'));
+      // In automatic mode we still print what we're about to kill
+      // but don't prompt — the operator asked for a full update and
+      // these processes would block the npm replace anyway.
+      const labels = [];
+      if (instances.service) labels.push(instances.service.label);
+      if (instances.dashboard) labels.push(instances.dashboard.label);
+      console.log(chalk.yellow(`  ⚠ Stopping running instances: ${labels.join(', ')}`));
+      console.log(
+        chalk.dim('  (use `--pick` to be prompted before killing in future)'),
+      );
       const kills = await killInstances(instances);
       for (const k of kills) {
         const marker = k.ok ? chalk.green('✓') : chalk.red('✗');
@@ -552,31 +576,23 @@ export async function runUpdate(subargs = []) {
   }
   console.log('');
 
-  // 3. Decide what to update.
+  // 3. Decide what to update. Default = everything. Any missing package
+  // is automatically included so a partial install gets completed.
   let selected;
-  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) {
+  if (interactivePick && !dryRun && !forceAll && !assumeYes) {
     selected = await promptForUpdates(false);
   } else {
-    const valid = new Set(COMPONENTS);
-    selected = new Set(subargs.filter((a) => !a.startsWith('-') && valid.has(a)));
-    if (selected.size === 0) {
-      console.log(chalk.yellow(`  No valid components selected from: ${subargs.join(' ')}`));
-      console.log(chalk.dim('  Valid components: opencode, bizar, dash, plugin'));
-      console.log(chalk.dim('  Run `bizar update --help` for usage.'));
-      process.exit(1);
+    // Auto-select: all components + any missing one (so a broken install
+    // gets repaired automatically).
+    selected = new Set(COMPONENTS);
+    for (const k of COMPONENTS) {
+      if (cur[k] === null && latest[k] !== null) selected.add(k);
+    }
+    if (interactivePick) {
+      // --pick + --dry-run / --all / --yes → still update everything
+      // but make the auto-selection visible so the dry-run output is
+      // informative.
+      console.log(chalk.dim(`  Auto-selecting all components (--pick ignored due to flags).`));
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar",
-  "version": "3.14.1",
+  "version": "3.15.1",
   "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": {