@polderlabs/bizar 10.2.0 → 10.3.0

package/bizar-dash/src/web/v8/__tests__/new-views.test.tsx

@@ -8,7 +8,6 @@ import { UsageView } from '../views/Usage/UsageView.js';
 import { BackupView } from '../views/Backup/BackupView.js';
 import { NotificationsView } from '../views/Notifications/NotificationsView.js';
 import { DiagnosticsView } from '../views/Diagnostics/DiagnosticsView.js';
-import { HeadroomView } from '../views/Headroom/HeadroomView.js';
 import { EvalView } from '../views/Eval/EvalView.js';
 
 /**
@@ -140,22 +139,6 @@ describe('DiagnosticsView (S35)', () => {
   });
 });
 
-describe('HeadroomView (S35)', () => {
-  it('shows status + controls + stats', async () => {
-    installFetchMock([
-      { match: (u) => u.endsWith('/api/headroom/status'), run: () => ({ status: 'not-installed' }) },
-      { match: (u) => u.includes('/api/headroom/stats'), run: () => ({ hours: 24, requests: 142, tokensSaved: 1234, cacheHits: 12, cacheMisses: 4 }) },
-      { match: (u) => u.endsWith('/api/headroom/install'), run: () => ({ ok: true }) },
-      { match: () => true, run: () => ({}) },
-    ]);
-    render(<Providers><HeadroomView /></Providers>);
-    expect(await screen.findByText('not-installed')).toBeTruthy();
-    expect(screen.getByText('142')).toBeTruthy();
-    expect(screen.getByText('1234')).toBeTruthy();
-    expect(screen.getByTestId('headroom-install')).toBeTruthy();
-  });
-});
-
 describe('EvalView (S35)', () => {
   it('lists runs + launches a suite via POST /api/eval/run', async () => {
     const { calls } = installFetchMock([

package/bizar-dash/src/web/v8/shell/Sidebar.tsx

@@ -167,7 +167,6 @@ const DEFAULT_SECTIONS: SidebarSection[] = [
       { id: 'backup', label: 'Backups', icon: Archive },
       { id: 'notifications', label: 'Notifications', icon: Bell },
       { id: 'diagnostics', label: 'Diagnostics', icon: Terminal },
-      { id: 'headroom', label: 'Headroom', icon: Network },
       { id: 'eval', label: 'Eval', icon: FlaskConical },
       { id: 'settings', label: 'Settings', icon: SettingsIcon },
     ],

package/bizar-dash/src/web/v8/views/Router.tsx

@@ -57,9 +57,6 @@ const NotificationsView = lazy(() =>
 const DiagnosticsView = lazy(() =>
   import('./Diagnostics/DiagnosticsView.js').then((m) => ({ default: m.DiagnosticsView })),
 );
-const HeadroomView = lazy(() =>
-  import('./Headroom/HeadroomView.js').then((m) => ({ default: m.HeadroomView })),
-);
 const EvalView = lazy(() =>
   import('./Eval/EvalView.js').then((m) => ({ default: m.EvalView })),
 );
@@ -160,8 +157,6 @@ export function useViewForId(id: string): JSX.Element {
         return <NotificationsView />;
       case 'diagnostics':
         return <DiagnosticsView />;
-      case 'headroom':
-        return <HeadroomView />;
       case 'eval':
         return <EvalView />;
       case 'chat':

package/bizar-dash/tests/_update-test-helpers.mjs

@@ -0,0 +1,13 @@
+/**
+ * _update-test-helpers.mjs — shared test helpers for update route tests.
+ *
+ * Exports a pre-loaded module instance so all test files share the same
+ * module state (important for ESM module caching in Node.js).
+ */
+import { resolve } from 'node:path';
+
+const REPO = resolve(import.meta.dirname, '..', '..');
+
+export const { createUpdateRouter, resetUpdateCache, resetConcurrencyGuard } = await import(
+  `${REPO}/bizar-dash/src/server/routes/update.mjs`
+);

package/bizar-dash/tests/update-check.test.mjs

@@ -16,7 +16,7 @@ import { resolve } from 'node:path';
 const REPO = resolve(import.meta.dirname, '..', '..');
 
 const { createUpdateRouter, resetUpdateCache } = await import(
-  `${REPO}/bizar-dash/src/server/routes/update.mjs`
+  './_update-test-helpers.mjs'
 );
 
 let app;
@@ -64,34 +64,39 @@ describe('update.mjs — /api/updates/status', () => {
   it('returns the installed package map', async () => {
     const res = await request(app, 'GET', '/api/updates/status');
     assert.equal(res.status, 200);
-    assert.ok(res.body.current, 'response should have current field');
-    assert.equal(typeof res.body.current, 'object');
-    for (const id of ['bizar', 'bizar-dash', 'bizar-plugin']) {
-      assert.ok(id in res.body.current, `current.${id} should be a key`);
+    assert.ok(res.body.installed, 'response should have installed field');
+    assert.equal(typeof res.body.installed, 'object');
+    for (const id of ['bizar', 'bizar-sdk', 'claude-agent', 'claude-code']) {
+      assert.ok(id in res.body.installed, `installed.${id} should be a key`);
       assert.ok(
-        res.body.current[id] === null || typeof res.body.current[id] === 'string',
-        `current.${id} should be string or null`,
+        res.body.installed[id] === null || typeof res.body.installed[id] === 'string',
+        `installed.${id} should be string or null`,
       );
     }
   });
 
-  it('does not include latest/hasUpdates fields', async () => {
+  it('does not include latest/hasUpdates/available fields', async () => {
     const res = await request(app, 'GET', '/api/updates/status');
     assert.equal(res.status, 200);
     assert.equal(res.body.latest, undefined, 'status should not include latest');
     assert.equal(res.body.hasUpdates, undefined, 'status should not include hasUpdates');
+    assert.equal(res.body.available, undefined, 'status should not include available');
   });
 });
 
 describe('update.mjs — /api/updates/check', () => {
-  it('returns shape { current, latest, hasUpdates }', async () => {
+  it('returns shape { installed, available, hasUpdates, channel }', async () => {
     const res = await request(app, 'GET', '/api/updates/check');
     assert.equal(res.status, 200);
-    assert.ok(res.body.current, 'should have current');
-    assert.ok(res.body.latest, 'should have latest');
+    assert.ok(res.body.installed, 'should have installed');
+    assert.ok(res.body.available, 'should have available');
+    assert.equal(typeof res.body.available, 'object');
+    assert.ok('stable' in res.body.available, 'available should have stable key');
+    assert.ok('beta' in res.body.available, 'available should have beta key');
     assert.equal(typeof res.body.hasUpdates, 'boolean');
-    for (const id of ['bizar', 'bizar-dash', 'bizar-plugin']) {
-      assert.ok(id in res.body.latest, `latest.${id} should be a key`);
+    assert.equal(res.body.channel, 'stable');
+    for (const id of ['bizar', 'bizar-sdk', 'claude-agent', 'claude-code']) {
+      assert.ok(id in res.body.installed, `installed.${id} should be a key`);
     }
   });
 

package/bizar-dash/tests/update-packages.test.mjs

@@ -0,0 +1,154 @@
+/**
+ * update-packages.test.mjs — tests for the v10.3.0 package list and channel selection.
+ *
+ * Run with: node --test bizar-dash/tests/update-packages.test.mjs
+ *
+ * Strategy: test HTTP response shapes + response fields without needing to
+ * patch spawn. The channel selection is encoded in the POST response body
+ * (channel field) and the concurrency guard (runningSince) is checked from
+ * the 409 response. The actual npm spawn behavior is tested in
+ * update-run.test.mjs which has the proper spawn interception setup.
+ */
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import express from 'express';
+import { resolve } from 'node:path';
+
+const REPO = resolve(import.meta.dirname, '..', '..');
+
+const { createUpdateRouter, resetUpdateCache, resetConcurrencyGuard } = await import(
+  `${REPO}/bizar-dash/src/server/routes/update.mjs`
+);
+
+// ─── HTTP helper ─────────────────────────────────────────────────────────────
+
+async function request(app, method, path, body) {
+  const http = await import('node:http');
+  return new Promise((resolveP, reject) => {
+    const server = app.listen(0, '127.0.0.1', () => {
+      const { port } = server.address();
+      const bodyStr = body ? JSON.stringify(body) : '';
+      const req = http.request({
+        hostname: '127.0.0.1',
+        port,
+        path,
+        method,
+        headers: bodyStr
+          ? { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(bodyStr) }
+          : {},
+      }, (res) => {
+        let data = '';
+        res.on('data', (c) => { data += c; });
+        res.on('end', () => {
+          server.close();
+          try {
+            resolveP({ status: res.statusCode, body: JSON.parse(data) });
+          } catch {
+            resolveP({ status: res.statusCode, body: data });
+          }
+        });
+      });
+      req.on('error', (err) => { server.close(); reject(err); });
+      if (bodyStr) req.write(bodyStr);
+      req.end();
+    });
+  });
+}
+
+// ─── Tests ─────────────────────────────────────────────────────────────────
+
+describe('update.mjs — v10.3.0 package list', () => {
+  it('returns exactly 4 packages (bizar, bizar-sdk, claude-agent, claude-code)', async () => {
+    resetUpdateCache();
+    const app = express();
+    app.use(express.json());
+    app.use('/api', createUpdateRouter({ broadcast: () => {} }));
+
+    const res = await request(app, 'GET', '/api/updates/status');
+    assert.equal(res.status, 200);
+    assert.ok(res.body.installed, 'should have installed field');
+
+    const ids = Object.keys(res.body.installed).sort();
+    assert.deepEqual(ids.sort(), ['bizar', 'bizar-sdk', 'claude-agent', 'claude-code'].sort());
+    assert.ok(!ids.includes('bizar-dash'), 'bizar-dash should not be present');
+    assert.ok(!ids.includes('bizar-plugin'), 'bizar-plugin should not be present');
+  });
+});
+
+describe('update.mjs — channel selection', () => {
+  let app;
+
+  beforeEach(() => {
+    resetUpdateCache();
+    resetConcurrencyGuard();
+    const localApp = express();
+    localApp.use(express.json());
+    localApp.use('/api', createUpdateRouter({ broadcast: () => {} }));
+    app = localApp;
+  });
+
+  it('POST with channel=beta returns 202 and reflects channel=beta in body', async () => {
+    const res = await request(app, 'POST', '/api/updates/apply', {
+      packages: ['bizar'],
+      channel: 'beta',
+    });
+    // Returns 202 (npm may not be on PATH in test env, so accept 500 too)
+    assert.ok([202, 500].includes(res.status), `unexpected status ${res.status}`);
+    if (res.status === 202) {
+      assert.equal(res.body.channel, 'beta', 'response should reflect channel=beta');
+    }
+  });
+
+  it('POST without channel returns 202 and reflects channel=stable in body', async () => {
+    const res = await request(app, 'POST', '/api/updates/apply', {
+      packages: ['bizar'],
+    });
+    assert.ok([202, 500].includes(res.status), `unexpected status ${res.status}`);
+    if (res.status === 202) {
+      assert.equal(res.body.channel, 'stable', 'default channel should be stable');
+    }
+  });
+});
+
+describe('update.mjs — concurrency guard returns runningSince', () => {
+  it('second concurrent POST returns 409 with runningSince ISO8601 timestamp', async () => {
+    resetUpdateCache();
+    resetConcurrencyGuard();
+    const localApp = express();
+    localApp.use(express.json());
+    localApp.use('/api', createUpdateRouter({ broadcast: () => {} }));
+
+    // First request may succeed or fail depending on npm availability
+    const first = await request(localApp, 'POST', '/api/updates/apply', { packages: ['bizar'] });
+    assert.ok([202, 500].includes(first.status), `first status unexpected: ${first.status}`);
+
+    // Second concurrent request should always hit the guard (regardless of npm availability)
+    const second = await request(localApp, 'POST', '/api/updates/apply', { packages: ['bizar'] });
+    assert.equal(second.status, 409, 'second request should get 409');
+    assert.equal(second.body.error, 'already_running');
+    assert.ok('runningSince' in second.body, 'response should include runningSince');
+    assert.ok(second.body.runningSince !== null, 'runningSince should not be null');
+    assert.match(
+      second.body.runningSince,
+      /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/,
+      'runningSince should be ISO8601',
+    );
+  });
+});
+
+describe('update.mjs — /check returns stable and beta in available', () => {
+  it('GET /api/updates/check includes available.stable and available.beta', async () => {
+    resetUpdateCache();
+    const app = express();
+    app.use(express.json());
+    app.use('/api', createUpdateRouter({ broadcast: () => {} }));
+
+    const res = await request(app, 'GET', '/api/updates/check');
+    assert.equal(res.status, 200);
+    assert.ok(res.body.available, 'should have available field');
+    assert.ok('stable' in res.body.available, 'available should have stable key');
+    assert.ok('beta' in res.body.available, 'available should have beta key');
+    // Both may be null if npm registry is unreachable, but keys must be present
+    assert.equal(typeof res.body.available.stable, 'string');
+  });
+});

package/bizar-dash/tests/update-run.test.mjs

@@ -8,7 +8,7 @@
  * exit code. Capture the broadcast channel's emitted messages and
  * assert they fire in the documented order.
  */
-import { describe, it, beforeEach } from 'node:test';
+import { describe, it, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert/strict';
 import express from 'express';
 import { EventEmitter } from 'node:events';
@@ -17,10 +17,14 @@ import { resolve } from 'node:path';
 
 const REPO = resolve(import.meta.dirname, '..', '..');
 
-// ─── Spawn fake ────────────────────────────────────────────────────────────
-// We monkey-patch the module loader's view of `node:child_process` so
-// that update.mjs's `import { spawn } from 'node:child_process'` resolves
-// to our fake.
+// ─── Dynamic import to get fresh module (bypasses ESM static-capture) ─────────
+
+async function importUpdateModuleFresh() {
+  const url = `${REPO}/bizar-dash/src/server/routes/update.mjs?fresh=${Date.now()}-${Math.random()}`;
+  return import(url);
+}
+
+// ─── Spawn fake ─────────────────────────────────────────────────────────────
 
 class FakeChildProcess extends EventEmitter {
   constructor() {
@@ -28,7 +32,6 @@ class FakeChildProcess extends EventEmitter {
     this.stdout = new Readable({ read() {} });
     this.stderr = new Readable({ read() {} });
   }
-  // Helpers for tests
   emitStdout(line) { this.stdout.push(line + '\n'); }
   emitStderr(line) { this.stderr.push(line + '\n'); }
   finish(code = 0) {
@@ -36,9 +39,7 @@ class FakeChildProcess extends EventEmitter {
     this.stderr.push(null);
     this.emit('close', code);
   }
-  failWith(err) {
-    this.emit('error', err);
-  }
+  failWith(err) { this.emit('error', err); }
 }
 
 let fakeProc = null;
@@ -49,37 +50,9 @@ function makeFakeSpawn() {
   };
 }
 
-// Install the fake by intercepting `node:child_process`. We do this by
-// rewriting `Module._resolveFilename` for one test at a time.
 import { createRequire } from 'node:module';
 const require = createRequire(import.meta.url);
 
-let originalLoad;
-let patched = false;
-function installFakeSpawn() {
-  if (patched) return;
-  // Override via global require cache: pre-populate the require cache
-  // for `node:child_process` with a stub module.
-  const realChild = require('node:child_process');
-  const stub = { ...realChild, spawn: makeFakeSpawn() };
-  require.cache[require.resolve('node:child_process')] = {
-    id: 'node:child_process',
-    filename: 'node:child_process',
-    loaded: true,
-    exports: stub,
-  };
-  patched = true;
-}
-
-// Load update.mjs once after we've patched child_process. We do this
-// dynamically so the import picks up the stubbed `spawn` from the
-// require cache that ESM bridges through.
-//
-// NOTE: ESM `import` does NOT use the require cache, so the patch above
-// only works for CommonJS callers of `child_process`. The route imports
-// `spawn` from `node:child_process` directly via ESM. To make this test
-// work, we patch the actual child_process module's `spawn` property at
-// runtime instead.
 function patchSpawnDirectly() {
   const cp = require('node:child_process');
   cp.__originalSpawn = cp.__originalSpawn || cp.spawn;
@@ -94,25 +67,6 @@ function unpatchSpawn() {
   fakeProc = null;
 }
 
-// Now we need the route to use the patched spawn. update.mjs does:
-//   import { spawn, execFileSync } from 'node:child_process';
-// In Node.js, ESM imports for built-in modules go through the loader,
-// which uses a private internal cache separate from the CommonJS
-// require cache. So patching require.cache alone won't redirect ESM.
-//
-// The reliable approach is to use a loader hook. For simplicity in
-// this test, we instead use module-aliasing via a wrapper: we use a
-// small middleware-only test that monkey-patches spawn on the imported
-// module instance directly. Since the same module instance is shared
-// across imports within a process, this works after first import.
-
-async function importUpdateModuleFresh() {
-  // Use a query string to force re-import. ESM treats query strings as
-  // distinct specifiers, so this gives us a fresh module instance.
-  const url = `${REPO}/bizar-dash/src/server/routes/update.mjs?case=${Date.now()}-${Math.random()}`;
-  return import(url);
-}
-
 // ─── App setup ─────────────────────────────────────────────────────────────
 
 function setupApp(broadcast) {
@@ -163,14 +117,8 @@ function waitFor(predicate, { timeoutMs = 4000, intervalMs = 10 } = {}) {
   return new Promise((resolveP, reject) => {
     const start = Date.now();
     const tick = () => {
-      if (predicate()) {
-        resolveP();
-        return;
-      }
-      if (Date.now() - start > timeoutMs) {
-        reject(new Error(`waitFor timed out after ${timeoutMs}ms`));
-        return;
-      }
+      if (predicate()) { resolveP(); return; }
+      if (Date.now() - start > timeoutMs) { reject(new Error(`waitFor timed out after ${timeoutMs}ms`)); return; }
       setTimeout(tick, intervalMs);
     };
     tick();
@@ -186,40 +134,37 @@ describe('update.mjs — apply run broadcasts events in order', () => {
     broadcast = [];
   });
 
+  afterEach(() => {
+    unpatchSpawn();
+  });
+
   it('emits starting → log → done → complete for a successful install', async () => {
     const { app } = await setupApp((msg) => broadcast.push(msg));
     const res = await request(app, 'POST', '/api/updates/apply', { packages: ['bizar'] });
     assert.equal(res.status, 202);
     assert.deepEqual(res.body.started, ['bizar']);
 
-    // The first event should be a `starting` progress for `bizar`
     await waitFor(() => broadcast.length >= 1);
     assert.equal(broadcast[0].type, 'update:progress');
     assert.equal(broadcast[0].pkg, 'bizar');
     assert.equal(broadcast[0].status, 'starting');
 
-    // Now drive the fake spawn to emit log lines + finish
     assert.ok(fakeProc, 'fakeProc should exist after request');
     fakeProc.emitStdout('npm WARN deprecated foo');
     fakeProc.emitStdout('added 1 package in 2s');
     fakeProc.finish(0);
 
-    // Wait for the complete event
     await waitFor(() => broadcast.some((m) => m.type === 'update:complete'), { timeoutMs: 5000 });
 
-    // Verify ordering and types
     const types = broadcast.map((m) => `${m.type}${m.pkg ? `:${m.pkg}` : ''}:${m.status ?? ''}`);
     assert.ok(types.includes('update:progress:bizar:starting'), 'should have starting progress');
     assert.ok(types.includes('update:log:bizar:'), 'should have at least one log');
     assert.ok(types.includes('update:progress:bizar:done'), 'should have done progress');
     assert.ok(types.at(-1) === 'update:complete:', 'last event should be update:complete');
 
-    // Done event should carry newVersion
     const doneEvent = broadcast.find((m) => m.type === 'update:progress' && m.status === 'done');
     assert.ok(doneEvent, 'done event should exist');
     assert.ok('newVersion' in doneEvent, 'done event should carry newVersion field');
-
-    unpatchSpawn();
   });
 
   it('emits error progress + complete when npm exits non-zero', async () => {
@@ -241,26 +186,18 @@ describe('update.mjs — apply run broadcasts events in order', () => {
 
     const lastEvent = broadcast.at(-1);
     assert.equal(lastEvent.type, 'update:complete');
-
-    unpatchSpawn();
   });
 
   it('returns 409 when an apply is already running', async () => {
     const { app } = await setupApp(() => {});
-    // First call — kicks off the run but the fake proc never closes,
-    // so the run is "active" for the duration of the test.
     const first = await request(app, 'POST', '/api/updates/apply', { packages: ['bizar'] });
     assert.equal(first.status, 202);
 
-    // Second call — should hit the concurrency guard
     const second = await request(app, 'POST', '/api/updates/apply', { packages: ['bizar'] });
     assert.equal(second.status, 409);
     assert.equal(second.body.error, 'already_running');
 
-    // Cleanup: close the fake proc so the run's finally clears the guard
     if (fakeProc) fakeProc.finish(0);
-    // Give the async run a moment to clear
     await new Promise((r) => setTimeout(r, 50));
-    unpatchSpawn();
   });
-});
+});

package/cli/banner.mjs

@@ -25,7 +25,7 @@ export function showBanner() {
   console.log(chalk.hex('#6366f1').bold(RUNE_HELM));
   console.log(chalk.hex('#a855f7')('    Norse Pantheon Agent System for cline'));
   console.log();
-  console.log(chalk.dim('    13 agents · 4 cost tiers · Obsidian vault long-term memory · Headroom · Semble · Skills CLI · Mods'));
+  console.log(chalk.dim('    13 agents · 4 cost tiers · Obsidian vault long-term memory · Semble · Skills CLI · Mods'));
   console.log();
 }
 

package/cli/bin.mjs

@@ -90,7 +90,7 @@ if (
   !process.env.BIZAR_SKIP_BUILD
 ) {
   try {
-    const { buildSdk, buildPlugin } = await import('./provision-claude.mjs');
+    const { buildSdk, buildPlugin } = await import('./provision.mjs');
     const sdkRes = await buildSdk();
     if (sdkRes.ok && !sdkRes.skipped) {
       console.error(chalk.dim(`  → ${sdkRes.message}`));
@@ -124,6 +124,7 @@ function showHelp() {
 
   Commands:
     install             Run the interactive installer
+    migrate             Migrate legacy ~/.config/cline/ or ~/.config/bizar/ to ~/.claude/
     audit               Run security audit on agent configuration
     init                Initialize .bizar/ in current project
     export [target]     Export agents/rules to another harness
@@ -293,6 +294,12 @@ async function main() {
       break;
     }
 
+    case 'migrate': {
+      const { runMigrate } = await import('./migrate.mjs');
+      await runMigrate(cmdArgs);
+      break;
+    }
+
     case 'service': {
       const mod = await importCommand('service');
       if (!mod) {

package/cli/bootstrap.mjs

@@ -49,7 +49,7 @@ export function checkSetupStatus() {
  */
 function printSetupBanner() {
   // Use console.log directly to avoid chalk formatting issues in non-TTY
-  console.log('\n  ⚡ First-time setup — Bizar needs to install agents, plugin, Headroom, Semble, Skills CLI...\n');
+  console.log('\n  ⚡ First-time setup — Bizar needs to install agents, plugin, Semble, Skills CLI...\n');
 }
 
 /**

package/cli/commands/claude-cmd.mjs

@@ -49,7 +49,7 @@ const CLAUDE_BIN = process.env.CLAUDE_BIN || 'claude';
  *
  * Mirrors Claude Code's own resolver. Used so all subcommands
  * delegate to the same `~/.claude/` directory that the rest of the
- * Bizar harness writes to via `cli/provision-claude.mjs`.
+ * Bizar harness writes to via `cli/provision.mjs`.
  */
 export function resolveClaudeDir() {
   if (process.env.CLAUDE_CONFIG_DIR && process.env.CLAUDE_CONFIG_DIR.trim()) {

package/cli/commands/deploy/docker.mjs

@@ -74,9 +74,6 @@ function generateComposeScaffold(outDir, opts) {
     '# Tailscale (optional)',
     '# TAILSCALE_AUTHKEY=tskey-auth-xxxxxxxxxxxxxxxxxxxx',
     '',
-    '# Headroom context compression (optional)',
-    '# HEADROOM_ENABLED=1',
-    '',
   ].join('\n');
   writeFileSync(join(scaffoldRoot, '.env.template'), envTemplate);
 

package/cli/install/banner.mjs

@@ -0,0 +1,67 @@
+/**
+ * cli/install/banner.mjs
+ *
+ * Banner, pantheon card, and section heading for the install flow.
+ */
+
+import chalk from 'chalk';
+
+const RUNE_HELM = `
+    ██████╗ ██╗██╗  ██╗ █████╗ ██████╗
+    ██╔══██╗██║██║  ██║██╔══██╗██╔══██╗
+    ██████╔╝██║███████║███████║██████╔╝
+    ██╔══██╗██║╚════██║██╔══██║██╔══██╗
+    ██████╔╝██║     ██║██║  ██║██║  ██║
+    ╚═════╝ ╚═╝     ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝
+`;
+
+const PANTHEON = `
+    ╔══════════════════════════════════════════╗
+    ║                                          ║
+    ║    ᛟ Odin     ᛗ Mimir    ᚹ Heimdall     ║
+    ║    ᚱ Hermod   ᚦ Thor     ᛏ Tyr          ║
+    ║    ᛉ Vidarr   ᚨ Forseti  ᛒ Baldr        ║
+    ║                                          ║
+    ╚══════════════════════════════════════════╝
+`;
+
+const TAGLINE = '14 agents · 6 cost tiers · dashboard · Obsidian vault long-term memory · Mods · Skills CLI';
+
+export const palette = {
+  primary: chalk.hex('#6366f1'),
+  success: chalk.green,
+  warn:    chalk.yellow,
+  error:   chalk.red,
+  dim:     chalk.dim,
+};
+
+/**
+ * Print the Bizar mark + tagline.
+ * @param {string} [version] - Optional version string to prepend.
+ */
+export function showBanner(version) {
+  if (version) {
+    console.log(chalk.bold.hex('#6366f1')(`\n  ⚡ BizarHarness v${version}\n`));
+  } else {
+    console.log(chalk.bold.hex('#6366f1')(RUNE_HELM));
+    console.log(chalk.hex('#a855f7')('    Norse Pantheon Agent System for Claude Code'));
+  }
+  console.log();
+  console.log(chalk.dim(`    ${TAGLINE}`));
+  console.log();
+}
+
+/** Print the Norse pantheon card. */
+export function showPantheon() {
+  console.log(chalk.hex('#312e81')(PANTHEON));
+}
+
+/**
+ * Print a section header divider.
+ * @param {string} text - Section title.
+ */
+export function sectionHeading(text) {
+  console.log();
+  console.log(chalk.bold.hex('#6366f1')(` ── ${text} ──`));
+  console.log();
+}

package/cli/install/banner.test.mjs

@@ -0,0 +1,39 @@
+/**
+ * cli/install/banner.test.mjs
+ *
+ * Tests for cli/install/banner.mjs
+ */
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { showBanner, showPantheon, sectionHeading, palette } from './banner.mjs';
+
+describe('showBanner()', () => {
+  test('does not throw', () => {
+    assert.doesNotThrow(() => showBanner());
+  });
+
+  test('does not throw with version', () => {
+    assert.doesNotThrow(() => showBanner('10.0.0'));
+  });
+});
+
+describe('palette', () => {
+  test('has all 5 required keys', () => {
+    const required = ['primary', 'success', 'warn', 'error', 'dim'];
+    for (const key of required) {
+      assert.ok(key in palette, `missing palette key: ${key}`);
+      assert.ok(typeof palette[key] === 'function', `${key} should be a function`);
+    }
+  });
+});
+
+describe('sectionHeading()', () => {
+  let output;
+  const orig = console.log;
+
+  test('does not throw', () => {
+    assert.doesNotThrow(() => sectionHeading('Test Section'));
+  });
+});
+
+console.log('  banner.test.mjs loaded — run with: node --test cli/install/banner.test.mjs');