@polderlabs/bizar 3.21.0 → 3.22.0

package/cli/bin.mjs

@@ -25,6 +25,7 @@ import { runInit } from './init.mjs';
 import { runExport } from './export.mjs';
 import runArtifact from './artifact.mjs';
 import { runUpdate } from './update.mjs';
+import { runHeadsUp } from './heads-up.mjs';
 import { ensureSetup, checkSetupStatus } from './bootstrap.mjs';
 
 const args = process.argv.slice(2);
@@ -90,6 +91,7 @@ function showHelp() {
     dev-link [src]      Symlink the local plugin source into opencode's plugin dir
     dev-unlink          Remove the dev symlink and restore the deployed copy
     doctor              Check the BizarHarness install for health issues
+    heads-up <subcommand>  Manage pre-push / pre-release heads-ups (list/check/archive)
     mod <subcommand>    Manage mods (install/upgrade/list via the dashboard API)
 
   Examples:
@@ -660,6 +662,9 @@ async function main() {
       const result = await runDoctor();
       if (result.failed > 0) process.exit(1);
     }
+  } else if (args[0] === 'heads-up') {
+    // v3.21.0 — Pre-push / pre-release heads-ups
+    await runHeadsUp(args[1], args.slice(2));
   } else if (args[0] === 'plan') {
     await runArtifact(args.slice(1), {});
   } else if (args[0] === 'install') {

package/cli/heads-up.mjs

@@ -0,0 +1,295 @@
+/**
+ * heads-up.mjs — `bizar heads-up` subcommand.
+ *
+ * Reads and manages .bizar/PRE_PUSH_NOTES.md — a per-project file for
+ * tracking gotchas, risks, and things-to-verify before pushing/publishing.
+ *
+ * Subcommands:
+ *   list         Print active heads-up entries
+ *   check        Exit code 0 (no blockers) or 1 (blockers found); batches
+ *                with warnings printed to stderr
+ *   archive      Move all active entries to the Resolved section
+ */
+
+import chalk from 'chalk';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+// ---------------------------------------------------------------------------
+// Entry parsing
+// ---------------------------------------------------------------------------
+
+/**
+ * Parse entries from the "Active heads-ups" section of a PRE_PUSH_NOTES.md.
+ * Returns an array of { title, severity, area, affected, description,
+ * mitigation, verified, lines } objects.
+ */
+function parseActiveEntries(content) {
+  const entries = [];
+
+  // Find the Active heads-ups section. We stop at the next h2 that starts
+  // with an uppercase letter (section header like "## Resolved") but NOT
+  // at entry titles that start with a date bracket "## [YYYY-MM-DD]".
+  const activeMatch = content.match(/## Active heads-ups\n([\s\S]*?)(?=\n## [A-Z]|$)/);
+  if (!activeMatch) return entries;
+
+  const section = activeMatch[1];
+
+  // Each entry starts with "## [YYYY-MM-DD] ..."
+  const entryBlocks = section.split(/(?=^## \[)/m);
+  for (const block of entryBlocks) {
+    const trimmed = block.trim();
+    if (!trimmed || trimmed.startsWith('<!--')) continue;
+
+    const titleMatch = trimmed.match(/^##\s+(\[.+?\]\s*.+)$/m);
+    if (!titleMatch) continue;
+
+    const severityMatch = trimmed.match(/^Severity:\s*(\S+)/m);
+    const areaMatch = trimmed.match(/^Area:\s*(.+)$/m);
+    const affectedMatch = trimmed.match(/^Affected versions:\s*(.+)$/m);
+    const descMatch = trimmed.match(/^Description:\s*(.+)$/m);
+    const mitigMatch = trimmed.match(/^Mitigation:\s*(.+)$/m);
+    const verifiedMatch = trimmed.match(/^Verified:\s*(.+)$/m);
+
+    entries.push({
+      title: titleMatch[1].trim(),
+      severity: severityMatch ? severityMatch[1].trim().toLowerCase() : 'info',
+      area: areaMatch ? areaMatch[1].trim() : null,
+      affected: affectedMatch ? affectedMatch[1].trim() : null,
+      description: descMatch ? descMatch[1].trim() : null,
+      mitigation: mitigMatch ? mitigMatch[1].trim() : null,
+      verified: verifiedMatch ? verifiedMatch[1].trim() : '☐',
+      lines: trimmed,
+    });
+  }
+
+  return entries;
+}
+
+// ---------------------------------------------------------------------------
+// File helpers
+// ---------------------------------------------------------------------------
+
+function readPrePushNotes(bizarDir) {
+  const file = join(bizarDir, 'PRE_PUSH_NOTES.md');
+  if (!existsSync(file)) return null;
+  return readFileSync(file, 'utf8');
+}
+
+function findBizarDir(cwd) {
+  // Walk up from cwd looking for .bizar/
+  let dir = cwd;
+  for (let i = 0; i < 10; i++) {
+    const candidate = join(dir, '.bizar');
+    if (existsSync(candidate)) return candidate;
+    const parent = join(dir, '..');
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Severity label helpers
+// ---------------------------------------------------------------------------
+
+function severityLabel(severity) {
+  switch (severity) {
+    case 'blocker': return chalk.bold.red('blocker');
+    case 'warning': return chalk.bold.yellow('warning');
+    case 'info':    return chalk.bold.blue('info');
+    default:        return severity;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Subcommands
+// ---------------------------------------------------------------------------
+
+/**
+ * `bizar heads-up list` — print active entries.
+ */
+async function listHeadsUps(bizarDir) {
+  const content = readPrePushNotes(bizarDir);
+  if (!content) {
+    console.log(chalk.yellow('  No .bizar/PRE_PUSH_NOTES.md found. Run `bizar init` first.'));
+    return;
+  }
+
+  const entries = parseActiveEntries(content);
+  if (entries.length === 0) {
+    console.log(chalk.green('  ✓ No active heads-ups.'));
+    return;
+  }
+
+  console.log(chalk.bold('\n  ⚠  Active heads-ups:\n'));
+  for (const entry of entries) {
+    console.log(`  ${chalk.bold(entry.title)}  ${severityLabel(entry.severity)}`);
+    if (entry.area)      console.log(`    Area:       ${entry.area}`);
+    if (entry.affected)  console.log(`    Affects:    ${entry.affected}`);
+    if (entry.description) console.log(`    ${chalk.dim(entry.description)}`);
+    if (entry.mitigation)  console.log(`    Mitigation: ${chalk.cyan(entry.mitigation)}`);
+    console.log(`    Verified:   ${entry.verified === '☑' ? chalk.green('☑') : chalk.dim('☐')}`);
+    console.log('');
+  }
+}
+
+/**
+ * `bizar heads-up check` — exit 0 if clear, 1 if blockers.
+ * Used by update/publish flows as a pre-flight gate.
+ */
+async function checkHeadsUps(bizarDir) {
+  const content = readPrePushNotes(bizarDir);
+  if (!content) {
+    // No file = no pre-push notes = clear
+    return { ok: true, blockerCount: 0, warningCount: 0, entries: [] };
+  }
+
+  const entries = parseActiveEntries(content);
+  const blockers = entries.filter((e) => e.severity === 'blocker');
+  const warnings = entries.filter((e) => e.severity === 'warning');
+
+  if (blockers.length > 0) {
+    console.error(chalk.bold.red(`\n  ✗ ${blockers.length} blocker(s) in active heads-ups:\n`));
+    for (const b of blockers) {
+      console.error(chalk.red(`    • ${b.title}`));
+      if (b.description) console.error(chalk.dim(`      ${b.description}`));
+      if (b.mitigation)  console.error(chalk.cyan(`      Fix: ${b.mitigation}`));
+      console.error('');
+    }
+  }
+  if (warnings.length > 0) {
+    console.error(chalk.yellow(`\n  ⚠ ${warnings.length} warning(s) in active heads-ups:\n`));
+    for (const w of warnings) {
+      console.error(chalk.yellow(`    • ${w.title}`));
+      if (w.description) console.error(chalk.dim(`      ${w.description}`));
+      console.error('');
+    }
+  }
+
+  return {
+    ok: blockers.length === 0,
+    blockerCount: blockers.length,
+    warningCount: warnings.length,
+    entries,
+  };
+}
+
+/**
+ * `bizar heads-up archive` — move all active entries to the Resolved section.
+ */
+async function archiveHeadsUps(bizarDir) {
+  const file = join(bizarDir, 'PRE_PUSH_NOTES.md');
+  const content = readPrePushNotes(bizarDir);
+  if (!content) {
+    console.log(chalk.yellow('  No .bizar/PRE_PUSH_NOTES.md found. Nothing to archive.'));
+    return;
+  }
+
+  const entries = parseActiveEntries(content);
+  if (entries.length === 0) {
+    console.log(chalk.dim('  No active entries to archive.'));
+    return;
+  }
+
+  // Build resolved entries block (with indented detail lines for readability)
+  const today = new Date().toISOString().slice(0, 10);
+  const newResolvedEntries = entries
+    .map((e) => {
+      const lines = e.lines.split('\n');
+      const header = lines[0];
+      const body = lines.slice(1).map((l) => `  ${l}`).join('\n');
+      return `${header}\n${body}`;
+    })
+    .join('\n\n');
+
+  // Clean the Active section — strip entries, keep header + comment
+  const cleanActive = '## Active heads-ups\n\n<!--\n  Entries archived. See "Resolved" below.\n-->\n';
+
+  let newContent;
+
+  // Check if a "## Resolved" section already exists
+  const resolvedMatch = content.match(/## Resolved[\s\S]*$/);
+  if (resolvedMatch) {
+    // Remove active entries from the Active section
+    newContent = content.replace(/## Active heads-ups[\s\S]*?(?=\n## Resolved|$)/, cleanActive);
+
+    // Prepend new resolved entries into the existing Resolved section,
+    // right after the header (first line "## Resolved").
+    const oldResolved = resolvedMatch[0];
+    const firstNewlineAfterHeader = oldResolved.indexOf('\n');
+    const prefix = oldResolved.slice(0, firstNewlineAfterHeader + 1); // "## Resolved\n"
+    const suffix = oldResolved.slice(firstNewlineAfterHeader + 1);    // everything after
+
+    const updatedResolved = `${prefix}<!-- Resolved on ${today} -->\n\n${newResolvedEntries}\n\n${suffix.trimStart()}\n`;
+
+    newContent = newContent.replace(resolvedMatch[0], updatedResolved);
+  } else {
+    // No existing Resolved section — replace Active section and append Resolved
+    newContent = content.replace(/## Active heads-ups[\s\S]*?(?=\n## |$)/, cleanActive);
+    const resolvedSection = `## Resolved\n\n<!-- Resolved on ${today} -->\n\n${newResolvedEntries}\n`;
+    newContent = `${newContent.trim()}\n\n${resolvedSection}\n`;
+  }
+
+  writeFileSync(file, newContent);
+  console.log(chalk.green(`  ✓ Archived ${entries.length} heads-up(s) to Resolved section.`));
+}
+
+// ---------------------------------------------------------------------------
+// Help
+// ---------------------------------------------------------------------------
+
+function showHeadsUpHelp() {
+  console.log(`
+  bizar heads-up — Manage pre-push / pre-release heads-ups
+
+  Usage:
+    bizar heads-up list       Show active heads-up entries
+    bizar heads-up check      Exit 0 if no blockers, 1 if blockers exist
+    bizar heads-up archive    Move all active entries to Resolved
+
+  Description:
+    Reads .bizar/PRE_PUSH_NOTES.md in the current (or nearest parent)
+    project. The file is created automatically by \`bizar init\`.
+
+    Add entries as agent-discovered gotchas before pushing or publishing.
+    The \`check\` subcommand is invoked automatically by \`bizar update\`
+    to gate pushes when unresolved blockers exist.
+  `);
+}
+
+// ---------------------------------------------------------------------------
+// Main entry point
+// ---------------------------------------------------------------------------
+
+export async function runHeadsUp(sub, args = []) {
+  const bizarDir = findBizarDir(process.cwd());
+
+  if (!sub || sub === '--help' || sub === '-h') {
+    showHeadsUpHelp();
+    return;
+  }
+
+  if (!bizarDir) {
+    console.log(chalk.yellow('  No .bizar/ directory found in this project.'));
+    console.log(chalk.dim('  Run `bizar init` to create one.'));
+    process.exit(1);
+  }
+
+  if (sub === 'list') {
+    await listHeadsUps(bizarDir);
+  } else if (sub === 'check') {
+    const result = await checkHeadsUps(bizarDir);
+    if (!result.ok) process.exit(1);
+    console.log(chalk.green('  ✓ No active blocker heads-ups.'));
+  } else if (sub === 'archive') {
+    await archiveHeadsUps(bizarDir);
+  } else {
+    console.error(chalk.red(`  ✗ Unknown heads-up subcommand: ${sub}`));
+    showHeadsUpHelp();
+    process.exit(1);
+  }
+}
+
+// Also export utilities so update.mjs and other commands can import them
+export { checkHeadsUps, parseActiveEntries, findBizarDir, readPrePushNotes };

package/cli/init.mjs

@@ -56,6 +56,37 @@ function detectStack(cwd) {
   return stack;
 }
 
+/**
+ * Write the .bizar/PRE_PUSH_NOTES.md template file.
+ * Created during `bizar init` with empty active/resolved sections.
+ */
+export function writePrePushNotesFile(bizarDir) {
+  const ppnPath = join(bizarDir, 'PRE_PUSH_NOTES.md');
+  const template = `# Pre-push / Pre-release Heads-up
+
+> File for tracking gotchas, risks, and things-to-verify before pushing or publishing.
+> Each entry is archived (moved to \`_archive/\`) after the push that resolves it.
+
+## Active heads-ups
+
+<!--
+  ## [YYYY-MM-DD] Short title
+  Severity: blocker | warning | info
+  Area: cli | dash | plugin | npm | docs | build
+  Affected versions: v3.20.0–v3.21.0
+  Description: What could go wrong. Be specific.
+  Mitigation: What to do before pushing.
+  Verified: ☐
+-->
+
+## Resolved
+
+<!-- Entries moved here after the push that resolved them. Keep last 5. -->
+`;
+  writeFileSync(ppnPath, template);
+  console.log(chalk.green(`  ✓ Created ${ppnPath}`));
+}
+
 export async function runInit(cwd) {
   console.log(chalk.bold.hex('#10b981')('\n  ᛗ BIZARHARNESS INIT ᛗ\n'));
 
@@ -150,6 +181,9 @@ ${stack.runner ? `- Dev: \`${stack.runner}\`` : ''}
     console.log(chalk.green(`  ✓ Created ${siPath}`));
   }
 
+  // Generate PRE_PUSH_NOTES.md
+  writePrePushNotesFile(bizarDir);
+
   // Build per-project knowledge graph (graphify -> .bizar/graph/)
   // Soft step: never fails init. If graphify is missing or build errors,
   // the user can retry manually with `bizar graph build`.

package/cli/update.mjs

@@ -37,12 +37,15 @@
 import chalk from 'chalk';
 import { execSync, spawn, spawnSync } from 'node:child_process';
 import { existsSync, readFileSync, rmSync, writeFileSync, mkdirSync } from 'node:fs';
+import { cp } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { checkHeadsUps, findBizarDir } from './heads-up.mjs';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
+const REPO_ROOT = join(__dirname, '..');
 
 const PKG_MAIN = '@polderlabs/bizar';
 const PKG_DASH = '@polderlabs/bizar-dash';
@@ -454,6 +457,111 @@ function spawnFreshDashboard({ port } = {}) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Repo-level update helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Pull the latest changes from the git origin. Exits the process if the
+ * pull fails (merge conflict etc.), matching the task flow — an update
+ * should not proceed when the working tree is dirty.
+ */
+function runGitPull({ dryRun = false } = {}) {
+  if (dryRun) {
+    console.log(chalk.dim('  [dry-run] would run: git pull --rebase'));
+    return { ok: true, message: '[dry-run] git pull --rebase' };
+  }
+  try {
+    execSync('git pull --rebase', { stdio: 'inherit', cwd: REPO_ROOT, timeout: 60000 });
+    return { ok: true, message: 'git pull --rebase succeeded' };
+  } catch {
+    return { ok: false, message: 'git pull --rebase failed — resolve conflicts manually' };
+  }
+}
+
+/**
+ * Copy bundled skills from config/skills/ to the user's .opencode/skills/
+ * directory. Currently installs: obsidian, glyph, read-the-damn-docs.
+ */
+async function installSkills({ dryRun = false } = {}) {
+  const skills = ['obsidian', 'glyph', 'read-the-damn-docs'];
+  const results = [];
+  for (const skill of skills) {
+    const src = join(REPO_ROOT, 'config', 'skills', skill);
+    const dst = join(homedir(), '.opencode', 'skills', skill);
+    if (dryRun) {
+      if (existsSync(src)) {
+        console.log(chalk.dim(`  [dry-run] would install skill: ${skill}`));
+      }
+    } else if (existsSync(src)) {
+      try {
+        await cp(src, dst, { recursive: true });
+        console.log(chalk.green(`  ✓ Installed skill: ${skill}`));
+        results.push({ skill, ok: true });
+      } catch (err) {
+        console.log(chalk.yellow(`  ⚠ Failed to install skill: ${skill} — ${err.message}`));
+        results.push({ skill, ok: false });
+      }
+    } else {
+      console.log(chalk.dim(`  — Source not found: config/skills/${skill} (skipping)`));
+    }
+  }
+  return results;
+}
+
+/**
+ * Rebuild the bizar-dash frontend with Vite.
+ */
+function rebuildDashboard({ dryRun = false } = {}) {
+  const dashDir = join(REPO_ROOT, 'bizar-dash');
+  const pkgJson = join(dashDir, 'package.json');
+  if (!existsSync(pkgJson)) {
+    return { ok: false, message: 'bizar-dash/package.json not found — is the dashboard cloned?' };
+  }
+  if (dryRun) {
+    console.log(chalk.dim('  [dry-run] would run: npx vite build (in bizar-dash/)'));
+    return { ok: true, message: '[dry-run] dashboard rebuild' };
+  }
+  console.log(chalk.dim('\n  Rebuilding dashboard...'));
+  const r = spawnSync('npx', ['vite', 'build'], {
+    stdio: 'inherit', cwd: dashDir, timeout: 120000,
+  });
+  if (r.status === 0) {
+    return { ok: true, message: 'dashboard rebuilt' };
+  }
+  return { ok: false, message: 'dashboard rebuild failed (try: cd bizar-dash && npx vite build)' };
+}
+
+/**
+ * Detect and run the project's test suite. Checks for common test runners
+ * (npm test, pytest, cargo test, go test) and runs the first one found.
+ */
+function runTestGate({ dryRun = false } = {}) {
+  if (dryRun) {
+    console.log(chalk.dim('  [dry-run] would detect and run local test suite'));
+    return { ok: true, message: '[dry-run] test gate' };
+  }
+  const cwd = process.cwd();
+  const suites = [
+    { cmd: 'npm test',           check: 'package.json' },
+    { cmd: 'pytest',             check: 'pyproject.toml' },
+    { cmd: 'cargo test',         check: 'Cargo.toml' },
+    { cmd: 'go test ./...',      check: 'go.mod' },
+  ];
+  for (const suite of suites) {
+    try {
+      if (existsSync(join(cwd, suite.check))) {
+        console.log(chalk.dim(`\n  Running test suite: ${suite.cmd}...`));
+        execSync(suite.cmd, { stdio: 'inherit', timeout: 120000, cwd });
+        return { ok: true, message: `test gate passed (${suite.cmd})` };
+      }
+    } catch {
+      return { ok: false, message: `test gate failed (${suite.cmd})` };
+    }
+  }
+  return { ok: true, message: 'no test suite detected (skipped)' };
+}
+
 // ---------------------------------------------------------------------------
 // Prompt helpers
 // ---------------------------------------------------------------------------
@@ -553,6 +661,22 @@ export async function runUpdate(subargs = []) {
     console.log(chalk.dim('  No running Bizar instances detected.'));
   }
 
+  // ── Git pull ──────────────────────────────────────────────────────────
+  if (dryRun) {
+    console.log(chalk.dim('\n  [dry-run] would pull latest from origin (git pull --rebase)'));
+  } else {
+    console.log(chalk.dim('\n  Pulling latest from origin...'));
+    const pull = runGitPull();
+    if (pull.ok) {
+      console.log(chalk.green(`  ✓ ${pull.message}`));
+    } else {
+      console.log(chalk.red(`  ✗ ${pull.message}`));
+      console.log(chalk.yellow('  Update aborted — resolve git conflicts and retry.'));
+      process.exit(1);
+    }
+  }
+  console.log('');
+
   // 2. Show installed vs. latest versions.
   const cur = {
     opencode: currentVersion('opencode-ai'),
@@ -582,6 +706,52 @@ export async function runUpdate(subargs = []) {
   }
   console.log('');
 
+  // ── Heads-up gate ───────────────────────────────────────────────────────
+  // Check .bizar/PRE_PUSH_NOTES.md for active blockers or warnings before
+  // allowing the update to proceed. Blocker entries require --force.
+  const bizarDir = findBizarDir(process.cwd());
+  if (bizarDir) {
+    const headsUp = await checkHeadsUps(bizarDir);
+    if (!headsUp.ok) {
+      if (dryRun) {
+        console.log(chalk.yellow('  Dry-run: found active blocker(s) — update would be blocked.'));
+      } else if (assumeYes || subargs.includes('--force')) {
+        console.log(chalk.yellow('  ⚠ Active blocker(s) present — proceeding due to --force.'));
+      } else {
+        console.error(chalk.red('  ✗ Active blocker(s) found in .bizar/PRE_PUSH_NOTES.md.'));
+        console.error(chalk.dim('    Archive them with `bizar heads-up archive` or'));
+        console.error(chalk.dim('    override with `--force`.'));
+        process.exit(1);
+      }
+    } else if (headsUp.warningCount > 0) {
+      console.log(chalk.yellow(`  ⚠ ${headsUp.warningCount} warning(s) in active heads-ups.`));
+      // In automatic mode, print the warning count and continue.
+      // In interactive mode, ask for confirmation.
+      if (!assumeYes && !forceAll && process.stdin.isTTY) {
+        try {
+          const inquirer = await import('inquirer');
+          const { proceed } = await inquirer.default.prompt([
+            {
+              type: 'confirm',
+              name: 'proceed',
+              message: 'Heads-up warnings exist. Continue with update?',
+              default: true,
+            },
+          ]);
+          if (!proceed) {
+            console.log(chalk.yellow('  Update cancelled by user.'));
+            process.exit(0);
+          }
+        } catch {
+          // inquirer unavailable — continue anyway
+        }
+      }
+    } else {
+      console.log(chalk.green('  ✓ Heads-ups: clear'));
+    }
+  }
+  console.log('');
+
   // 3. Decide what to update. Default = everything. Any missing package
   // is automatically included so a partial install gets completed.
   let selected;
@@ -648,15 +818,39 @@ export async function runUpdate(subargs = []) {
     }
   }
 
-  // 5. Restart the dashboard if it was running before the update.
-  if (restartAfter && instances.dashboard && (selected.has('bizar') || selected.has('dash'))) {
+  // ── Install bundled skills ──────────────────────────────────────────
+  console.log(chalk.bold('\n  → Installing bundled skills...'));
+  const skillResults = await installSkills({ dryRun });
+  const skillOk = skillResults.length === 0 || skillResults.every((r) => r.ok);
+
+  // ── Rebuild dashboard ───────────────────────────────────────────────
+  console.log(chalk.bold('\n  → Rebuilding dashboard...'));
+  const dashRebuild = rebuildDashboard({ dryRun });
+  if (dashRebuild.ok) {
+    console.log(chalk.green(`  ✓ ${dashRebuild.message}`));
+  } else {
+    console.log(chalk.yellow(`  ⚠ ${dashRebuild.message}`));
+  }
+
+  // ── Test gate ───────────────────────────────────────────────────────
+  console.log(chalk.bold('\n  → Running test gate...'));
+  const testResult = runTestGate({ dryRun });
+  if (testResult.ok) {
+    console.log(chalk.green(`  ✓ ${testResult.message}`));
+  } else {
+    console.log(chalk.red(`  ✗ ${testResult.message}`));
+  }
+
+  // ── Restart dashboard ─────────────────────────────────────────────
+  // Restart if it was running before, or if the dashboard was just rebuilt.
+  if (restartAfter && (instances.dashboard || dashRebuild.ok)) {
     if (dryRun) {
       console.log('');
       console.log(chalk.dim('  [dry-run] would restart dashboard with the new code'));
     } else {
       console.log('');
       console.log(chalk.cyan('  Restarting dashboard with the new code...'));
-      const res = spawnFreshDashboard({ port: instances.dashboard.port || undefined });
+      const res = spawnFreshDashboard({ port: instances.dashboard?.port || undefined });
       if (res.ok) {
         console.log(chalk.green(`  ✓ ${res.message}`));
       } else {
@@ -673,11 +867,29 @@ export async function runUpdate(subargs = []) {
     const marker = r.ok ? chalk.green('✓') : chalk.red('✗');
     console.log(`    ${marker} ${name.padEnd(10)} ${r.message}`);
   }
+  // Skills
+  for (const sr of skillResults) {
+    const marker = sr.ok ? chalk.green('✓') : chalk.red('✗');
+    console.log(`    ${marker} ${'skill/skills'.padEnd(10)} ${sr.ok ? 'installed' : `failed: ${sr.skill}`}`);
+  }
+  if (!dashRebuild.ok) {
+    console.log(`    ${chalk.yellow('⚠')} ${'dash'.padEnd(10)} ${dashRebuild.message}`);
+  }
+  const testMarker = testResult.ok ? chalk.green('✓') : chalk.red('✗');
+  console.log(`    ${testMarker} ${'test-gate'.padEnd(10)} ${testResult.message}`);
 
-  const anyFail = results.some(([, r]) => !r.ok);
+  const allResults = [
+    ...results.map(([, r]) => r),
+    ...skillResults,
+    dashRebuild,
+    testResult,
+  ];
+  const anyFail = allResults.some((r) => !r.ok);
   if (anyFail) {
-    console.log(chalk.yellow('\n  Some updates failed. See messages above.'));
-    process.exit(1);
+    console.log(chalk.yellow('\n  Some steps had issues. See messages above.'));
+    if (allResults.filter((r) => !r.ok).some((r) => r.message && r.message.includes('failed'))) {
+      process.exit(1);
+    }
   }
   if (dryRun) {
     console.log(

package/config/agents/_shared/AGENT_BASELINE.md

@@ -616,3 +616,38 @@ Rules:
 - Keep it concise — 20-40 lines max.
 - Don't duplicate what's in `AGENTS_SELF_IMPROVEMENT.md`.
 - First creation is done by `@mimir` at Odin's request (explores codebase and writes it).
+
+---
+
+## 12. Obsidian Vault — Project Knowledge Is Your First Stop
+
+**Project knowledge lives in `.obsidian/`. Read it before you start, write to it when you learn.**
+
+Every Bizar project has a vault at `.obsidian/` with index files (`index/`), agent-specific memory (`agents/`), bug postmortems (`bugs/`), design decisions, and ongoing work notes. The user has been working on this project — their notes contain the real context, the gotchas, the failed approaches, the preferred patterns. **Read the relevant vault entries before making any non-trivial decision.**
+
+**When to read:**
+- At the start of every session (skim the index)
+- Before any non-trivial implementation decision
+- When you're about to suggest something the user has already tried
+- When the codebase feels like it's working around something you don't understand
+
+**When to write:**
+- After completing a meaningful piece of work
+- On discovering a bug or postmortem
+- When you find a pattern that should be reused
+- When the user corrects you
+- When you make a design decision that should be remembered
+
+**What to write:**
+- Date-stamped entry under the appropriate category (`index/`, `bugs/`, `agents/<name>/`, etc.)
+- The context: what was happening
+- The lesson: what you learned
+- The pattern: what to do next time
+- Link to related entries with `[[wikilinks]]`
+
+**What NOT to write:**
+- Secrets, API keys, tokens (use auth.json)
+- Temporary scratch
+- Anything already obvious from reading the code
+
+**The O in Odin stands for "oblige the system": Odin ALWAYS updates the vault after significant work, regardless of who did the work. The other agents read; Odin writes.**