@polderlabs/bizar 10.7.2 → 10.10.0

package/cli/agent-browser-update.mjs

@@ -1,322 +1,135 @@
 /**
- * cli/kevin-update.mjs
+ * Install, update, and inspect the official `agent-browser` CLI.
  *
- * v6.0.0 — Install / update / verify the `kevin` CLI.
- *
- * `kevin` is a native Rust CLI from vercel-labs (~38K★) that
- * gives Bizar agents a complete browser-automation surface:
- *   - 100+ typed CLI commands (open, snapshot, click, fill, screenshot, ...)
- *   - Native MCP stdio server (`kevin mcp`)
- *   - Self-healing snapshot-based element refs (`@e2`)
- *   - Plugin system (vault, recorder, ...)
- *   - Vercel AI SDK + AI Gateway integration
- *
- * This module is the single source of truth for installing and
- * updating `kevin`. It is used by:
- *   - cli/install.mjs (during `bizar install`)
- *   - cli/provision.mjs (during `bizar update`)
- *   - cli/kevin-up.sh (the bash idempotent starter; on first
- *     run it shells to `npm install -g kevin` if the binary
- *     is missing — this module is the rich equivalent)
- *
- * Public API:
- *   detectState()       probe what's installed without modifying
- *   install(opts)       install + download Chrome for Testing
- *   update(opts)        upgrade to the latest version
- *   ensureRunning()     bring the daemon up if it's down
- *   printStatus()       one-line status for the user
- *
- * All functions are idempotent and safe to re-run.
+ * The browser daemon is managed by agent-browser itself. Bizar does not
+ * start, stop, or persist a separate browser process.
  */
 
-import { execSync, spawnSync } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { execFileSync, spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
+import { join } from 'node:path';
 import chalk from 'chalk';
 
-const DEFAULT_DAEMON_PORT = 9223;
-const DEFAULT_PROFILE_DIR = join(homedir(), '.kevin', 'profile');
-
-// ── detection ──────────────────────────────────────────────────────────
-
-/**
- * Probe the current kevin install without modifying anything.
- *
- * Returns a structured state object:
- *   {
- *     installed: boolean,
- *     version: string | null,
- *     chromeReady: boolean,
- *     daemonRunning: boolean,
- *     profileDir: string,
- *     daemonPort: number,
- *   }
- */
-export function detectState() {
-  const state = {
-    installed: false,
-    version: null,
-    chromeReady: false,
-    daemonRunning: false,
-    profileDir: DEFAULT_PROFILE_DIR,
-    daemonPort: DEFAULT_DAEMON_PORT,
-    bin: null,
-  };
-
-  // 1. Find the binary
-  const bin = findAgentBrowserBin();
-  state.bin = bin;
-  if (!bin) return state;
-
-  // 2. Get the version
-  try {
-    const out = execSync(`"${bin}" --version`, { encoding: 'utf8', timeout: 5_000 }).trim();
-    state.version = out;
-    state.installed = true;
-  } catch {
-    return state;
-  }
-
-  // 3. Check Chrome for Testing
-  const chromeDir = join(homedir(), '.cache', 'kevin', 'chrome');
-  if (existsSync(chromeDir)) state.chromeReady = true;
-
-  // 4. Check daemon (read env on every call so tests can override)
-  const port = parseInt(process.env.AGENT_BROWSER_PORT ?? String(DEFAULT_DAEMON_PORT), 10);
-  state.daemonPort = port;
-  state.daemonRunning = isDaemonUp(port);
-
-  return state;
-}
-
 function findAgentBrowserBin() {
-  // 1. Explicit override
-  if (process.env.AGENT_BROWSER_BIN && existsSync(process.env.AGENT_BROWSER_BIN)) {
-    return process.env.AGENT_BROWSER_BIN;
-  }
-  // 2. Well-known npm-global locations
+  const override = process.env.AGENT_BROWSER_BIN;
+  if (override && existsSync(override)) return override;
+
   const candidates = [
-    '/usr/local/bin/kevin',
-    '/opt/homebrew/bin/kevin',
-    join(homedir(), '.local', 'bin', 'kevin'),
-    join(homedir(), '.npm', 'bin', 'kevin'),
+    '/usr/local/bin/agent-browser',
+    '/opt/homebrew/bin/agent-browser',
+    join(homedir(), '.local', 'bin', 'agent-browser'),
+    join(homedir(), '.npm', 'bin', 'agent-browser'),
   ];
-  for (const c of candidates) {
-    if (existsSync(c)) return c;
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
   }
-  // 3. PATH lookup
+
   try {
-    const r = execSync('command -v kevin', { encoding: 'utf8', timeout: 2_000 }).trim();
-    if (r && existsSync(r)) return r;
+    const bin = execFileSync('which', ['agent-browser'], {
+      encoding: 'utf8',
+      timeout: 2_000,
+    }).trim();
+    return bin && existsSync(bin) ? bin : null;
   } catch {
-    // fall through
+    return null;
   }
-  return null;
 }
 
-function isDaemonUp(port) {
+export function detectState() {
+  const bin = findAgentBrowserBin();
+  if (!bin) return { installed: false, version: null, bin: null };
+
   try {
-    execSync(
-      `curl -fsS --max-time 1 "http://127.0.0.1:${port}/json/version" >/dev/null 2>&1`,
-      { shell: '/bin/bash', timeout: 2_000 },
-    );
-    return true;
+    const result = spawnSync(bin, ['--version'], {
+      encoding: 'utf8',
+      timeout: 5_000,
+    });
+    if (result.status !== 0) {
+      return { installed: false, version: null, bin };
+    }
+    const version = `${result.stdout || result.stderr}`.trim() || 'unknown';
+    return { installed: true, version, bin };
   } catch {
-    return false;
+    return { installed: false, version: null, bin };
   }
 }
 
-// ── install / update ───────────────────────────────────────────────────
-
-/**
- * Install kevin. Idempotent: skips steps that are already
- * complete. Returns the updated state.
- *
- * @param {object} opts
- * @param {boolean} [opts.silent=false]   suppress info output (for CI)
- * @param {boolean} [opts.dryRun=false]   print actions, make no changes
- * @param {string}  [opts.channel='latest']  npm dist-tag (e.g. 'beta')
- * @param {boolean} [opts.startDaemon=true]   start the daemon after install
- */
-export function install(opts = {}) {
-  const { silent = false, dryRun = false, channel = 'latest', startDaemon = true } = opts;
-  const log = silent ? () => {} : (msg) => console.log(chalk.cyan('  → ') + msg);
+function runChecked(command, args, { silent, timeout }) {
+  const result = spawnSync(command, args, {
+    stdio: silent ? 'ignore' : 'inherit',
+    timeout,
+  });
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    throw new Error(`${command} ${args.join(' ')} failed (exit ${result.status})`);
+  }
+}
 
+export function install({ silent = false, dryRun = false, channel = 'latest' } = {}) {
+  const log = silent ? () => {} : (message) => console.log(chalk.cyan('  → ') + message);
   const before = detectState();
   if (before.installed) {
-    log(`kevin ${before.version} already installed at ${before.bin}`);
-    if (startDaemon && !before.daemonRunning) {
-      log('daemon is down — bringing it up');
-      ensureRunning({ silent, dryRun });
-    }
-    return detectState();
+    log(`agent-browser ${before.version} already installed at ${before.bin}`);
+    return before;
   }
 
-  log(`Installing kevin from npm (channel: ${channel})...`);
+  const packageSpec = channel === 'latest' ? 'agent-browser' : `agent-browser@${channel}`;
   if (dryRun) {
-    log(`[DRY RUN] would run: npm install -g kevin@${channel}`);
-    // In dry-run, the binary may not be on PATH. Just return the
-    // current state (which includes installed=false) without checking
-    // for the after-install state.
-    return detectState();
-  } else {
-    const r = spawnSync('npm', ['install', '-g', `kevin@${channel}`], {
-      stdio: silent ? 'ignore' : 'inherit',
-      timeout: 180_000,
-    });
-    if (r.status !== 0) {
-      throw new Error(`npm install -g kevin@${channel} failed (exit ${r.status})`);
-    }
+    log(`[DRY RUN] would run: npm install -g ${packageSpec}`);
+    log('[DRY RUN] would run: agent-browser install');
+    return before;
   }
 
-  const after = detectState();
-  if (!after.installed) {
-    throw new Error('kevin still not on PATH after install');
-  }
-  log(`kevin ${after.version} installed`);
-
-  log('Downloading Chrome for Testing...');
-  if (!dryRun) {
-    const r = spawnSync(after.bin, ['install'], {
-      stdio: silent ? 'ignore' : 'inherit',
-      timeout: 300_000,
-    });
-    if (r.status !== 0) {
-      log(chalk.yellow('Chrome download failed — you can retry with `kevin install`'));
-    }
-  }
-
-  if (startDaemon) {
-    ensureRunning({ silent, dryRun });
+  log(`Installing ${packageSpec}...`);
+  runChecked('npm', ['install', '-g', packageSpec], { silent, timeout: 180_000 });
+  const afterInstall = detectState();
+  if (!afterInstall.installed) {
+    throw new Error('agent-browser is not on PATH after npm installation');
   }
+  runChecked(afterInstall.bin, ['install'], { silent, timeout: 300_000 });
   return detectState();
 }
 
-/**
- * Update kevin to the latest version. Idempotent.
- *
- * Same shape as install() but uses `kevin upgrade` after the
- * first install (which knows how to detect the install method and run
- * the right update command).
- */
-export function update(opts = {}) {
-  const { silent = false, dryRun = false, channel = 'latest', startDaemon = true } = opts;
-  const log = silent ? () => {} : (msg) => console.log(chalk.cyan('  → ') + msg);
-
+export function update({ silent = false, dryRun = false } = {}) {
+  const log = silent ? () => {} : (message) => console.log(chalk.cyan('  → ') + message);
   const before = detectState();
-  if (!before.installed) {
-    log('kevin not installed — calling install()');
-    return install(opts);
-  }
+  if (!before.installed) return install({ silent, dryRun });
 
-  log(`kevin ${before.version} is installed. Upgrading to ${channel}...`);
   if (dryRun) {
-    log(`[DRY RUN] would run: kevin upgrade`);
-    return detectState();
-  } else {
-    // First, try `kevin upgrade` (the self-updater). If it
-    // doesn't exist (older version), fall back to `npm update -g`.
-    const r = spawnSync(before.bin, ['upgrade'], {
-      stdio: silent ? 'ignore' : 'inherit',
-      timeout: 180_000,
-    });
-    if (r.status !== 0) {
-      log('`kevin upgrade` failed — falling back to `npm update -g`');
-      const r2 = spawnSync('npm', ['update', '-g', `kevin@${channel}`], {
-        stdio: silent ? 'ignore' : 'inherit',
-        timeout: 180_000,
-      });
-      if (r2.status !== 0) {
-        throw new Error(`npm update -g kevin@${channel} failed (exit ${r2.status})`);
-      }
-    }
-  }
-
-  const after = detectState();
-  if (after.version === before.version) {
-    log(`kevin already at latest (${after.version})`);
-  } else {
-    log(`kevin updated: ${before.version} → ${after.version}`);
+    log('[DRY RUN] would run: agent-browser upgrade');
+    return before;
   }
 
-  if (startDaemon && !after.daemonRunning) {
-    ensureRunning({ silent, dryRun });
-  }
-  return after;
+  log(`Upgrading agent-browser ${before.version}...`);
+  runChecked(before.bin, ['upgrade'], { silent, timeout: 180_000 });
+  return detectState();
 }
 
-// ── daemon management ──────────────────────────────────────────────────
-
-/**
- * Bring the kevin daemon up if it's down. Idempotent.
- *
- * On macOS, Linux, and Windows, the daemon is started as a background
- * process using `kevin serve`. On success, the daemon listens
- * on `http://127.0.0.1:<port>` and is reachable via the typed CLI
- * and the MCP stdio server.
- */
-export function ensureRunning(opts = {}) {
-  const { silent = false, dryRun = false } = opts;
-  const log = silent ? () => {} : (msg) => console.log(chalk.cyan('  → ') + msg);
-
+export function doctor({ silent = false } = {}) {
   const state = detectState();
   if (!state.installed) {
-    log('kevin is not installed — call install() first');
-    return state;
-  }
-  if (state.daemonRunning) {
-    log(`daemon is up (port ${state.daemonPort})`);
-    return state;
-  }
-
-  log(`starting daemon on port ${state.daemonPort}...`);
-  if (dryRun) {
-    log(`[DRY RUN] would run: ${state.bin} serve --port ${state.daemonPort} --headless`);
-  } else {
-    const r = spawnSync('nohup', [
-      state.bin, 'serve',
-      '--port', `${state.daemonPort}`,
-      '--profile', state.profileDir,
-      '--headless',
-    ], {
-      detached: true,
-      stdio: 'ignore',
-      timeout: 5_000,
-    });
-    if (r.error) {
-      log(chalk.yellow(`daemon spawn failed: ${r.error.message}`));
-    }
-  }
-
-  // Wait up to 5s for the daemon to bind
-  for (let i = 0; i < 50; i++) {
-    if (isDaemonUp(state.daemonPort)) {
-      log(`daemon is up (port ${state.daemonPort})`);
-      return detectState();
-    }
-    spawnSync('sleep', ['0.1']);
-  }
-  log(chalk.yellow('daemon did not bind within 5s — check `kevin doctor`'));
-  return detectState();
+    return { ok: false, state, message: 'agent-browser is not installed' };
+  }
+  const result = spawnSync(state.bin, ['doctor'], {
+    encoding: silent ? 'utf8' : undefined,
+    stdio: silent ? ['ignore', 'pipe', 'pipe'] : 'inherit',
+    timeout: 120_000,
+  });
+  return {
+    ok: result.status === 0,
+    state,
+    message: result.status === 0 ? 'agent-browser doctor passed' : 'agent-browser doctor failed',
+  };
 }
 
-// ── status ─────────────────────────────────────────────────────────────
-
-/**
- * One-line status for the user. Returns the state object.
- */
 export function printStatus() {
-  const s = detectState();
-  if (!s.installed) {
-    console.log(chalk.yellow('  kevin: NOT INSTALLED'));
-    console.log(chalk.dim('    Install with: npm install -g kevin && kevin install'));
+  const state = detectState();
+  if (!state.installed) {
+    console.log(chalk.yellow('  agent-browser: NOT INSTALLED'));
+    console.log(chalk.dim('    Install with: npm install -g agent-browser && agent-browser install'));
   } else {
-    const daemonTxt = s.daemonRunning
-      ? chalk.green('running')
-      : chalk.yellow('stopped');
-    const chromeTxt = s.chromeReady ? chalk.green('ready') : chalk.yellow('not installed');
-    console.log(`  kevin ${chalk.cyan(s.version)}  ·  daemon: ${daemonTxt} (port ${s.daemonPort})  ·  chrome: ${chromeTxt}`);
+    console.log(`  agent-browser ${chalk.cyan(state.version)} · ${state.bin}`);
   }
-  return s;
+  return state;
 }

package/cli/atomic.mjs

@@ -1,7 +1,7 @@
 /**
  * src/server/atomic.mjs
  *
- * Atomic file I/O utilities for the Bizar Memory Service. Uses the
+ * Atomic file I/O utilities for Bizar runtime state. Uses the
  * proven tmp+rename pattern to ensure files are either fully written or
  * not written at all (no partial writes on crash).
  *

package/cli/audit.mjs

@@ -1,141 +1,51 @@
 import chalk from 'chalk';
-import { readFileSync, existsSync, readdirSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
-import { clineConfigDir } from './utils.mjs';
+import { claudeConfigDir } from './utils.mjs';
 
-const CONFIG_DIR = clineConfigDir();
+const CONFIG_DIR = claudeConfigDir();
 
-export async function runAudit() {
-  console.log(chalk.bold.hex('#ef4444')('\n  ⚔  BIZARHARNESS AUDIT ⚔\n'));
-  console.log(chalk.dim('  Scanning agent configuration for security and correctness issues...\n'));
+function frontmatter(text) {
+  const match = /^---\n([\s\S]*?)\n---/.exec(text);
+  return match?.[1] || '';
+}
 
+export async function runAudit() {
+  console.log(chalk.bold.cyan('\n  BIZARHARNESS AGENT AUDIT\n'));
   const agentsDir = join(CONFIG_DIR, 'agents');
   if (!existsSync(agentsDir)) {
-    console.log(chalk.yellow('  ✗ No agents directory found at', agentsDir));
-    return;
+    const result = { issues: [{ path: agentsDir, severity: 'HIGH', msg: 'agents directory missing' }], warnings: [], score: 0 };
+    console.log(chalk.red(`  ✗ No agents directory found at ${agentsDir}`));
+    return result;
   }
 
-  const files = readdirSync(agentsDir).filter(f => f.endsWith('.md'));
-  let totalIssues = 0;
-  let totalWarnings = 0;
-
   const issues = [];
   const warnings = [];
-
+  const files = readdirSync(agentsDir).filter((file) => file.endsWith('.md'));
   for (const file of files) {
-    const content = readFileSync(join(agentsDir, file), 'utf-8');
-    const path = `agents/${file}`;
-    const lines = content.split('\n');
-
-    // Check 1: Dangerous bash permissions on review-only agents
-    if (file.includes('linda') || file.includes('oscar')) {
-      if (content.includes('bash: allow')) {
-        issues.push({ path, severity: 'HIGH', msg: 'Review-only agent has bash permission' });
-      }
-      if (content.includes('edit: allow')) {
-        issues.push({ path, severity: 'HIGH', msg: 'Review-only agent has edit permission — should be edit: deny' });
-      }
+    const path = join(agentsDir, file);
+    const text = readFileSync(path, 'utf8');
+    const meta = frontmatter(text);
+    if (!meta) issues.push({ path, severity: 'HIGH', msg: 'missing YAML frontmatter' });
+    for (const field of ['name:', 'description:', 'tools:', 'model:']) {
+      if (!meta.includes(field)) warnings.push({ path, severity: 'WARN', msg: `missing ${field.slice(0, -1)} field` });
     }
-
-    // Check 2: Frigg should never have edit/write
-    if (file.includes('susan')) {
-      if (content.includes('edit: allow')) {
-        issues.push({ path, severity: 'HIGH', msg: 'Read-only Q&A agent (Frigg) has edit permission' });
-      }
-      if (content.includes('write: allow')) {
-        issues.push({ path, severity: 'HIGH', msg: 'Read-only Q&A agent (Frigg) has write permission' });
-      }
+    if (/(?:sk-[A-Za-z0-9_-]{20,}|api[-_]?key\s*[:=]\s*["'][^"']{12,})/i.test(text)) {
+      issues.push({ path, severity: 'CRITICAL', msg: 'possible embedded credential' });
     }
 
-    // Check 3: Odin should have minimal permissions
-    if (file.includes('mike')) {
-      const dangerousForOdin = ['bash', 'edit', 'write', 'glob', 'grep', 'question'];
-      for (const tool of dangerousForOdin) {
-        if (content.includes(`${tool}: allow`)) {
-          issues.push({ path, severity: 'HIGH', msg: `Odin has ${tool} permission but should be pure router` });
-        }
-      }
+    const tools = meta.match(/^tools:\s*(.+)$/m)?.[1] || '';
+    if (file === 'office-manager.md' && /\b(?:Bash|Edit|Write)\b/.test(tools)) {
+      issues.push({ path, severity: 'HIGH', msg: 'primary router has execution tools' });
     }
-
-    // Check 4: API keys in agent descriptions or content
-    const apiKeyPatterns = [
-      /sk-[a-zA-Z0-9]{20,}/g,
-      /api[-_]?key['":]?\s*['"][a-zA-Z0-9_\-]{16,}/gi,
-      /AIza[0-9A-Za-z\-_]{35}/g,
-    ];
-    for (let i = 0; i < lines.length; i++) {
-      for (const pattern of apiKeyPatterns) {
-        const matches = lines[i].match(pattern);
-        if (matches) {
-          issues.push({ path, severity: 'CRITICAL', line: i + 1, msg: 'Possible API key exposed in agent content' });
-        }
-      }
-    }
-
-    // Check 5: Model validation
-    const modelMatch = content.match(/^model:\s*(.+)$/m);
-    if (modelMatch) {
-      const model = modelMatch[1].trim();
-      const validModels = [
-        'cline/deepseek-v4-flash-free',
-        'minimax/MiniMax-M2.7',
-        'minimax/MiniMax-M3',
-      ];
-      if (!validModels.includes(model)) {
-        warnings.push({ path, severity: 'WARN', msg: `Unknown model: ${model}` });
-      }
+    if (['qa-reviewer.md', 'research-analyst.md'].includes(file) && /\b(?:Edit|Write)\b/.test(tools)) {
+      issues.push({ path, severity: 'HIGH', msg: 'read-only reviewer has mutation tools' });
     }
-
-    // Check 6: Missing model field
-    if (!content.includes('model:')) {
-      warnings.push({ path, severity: 'WARN', msg: 'Missing model field' });
-    }
-
-    // Check 7: Missing description
-    if (!content.includes('description:')) {
-      warnings.push({ path, severity: 'WARN', msg: 'Missing description field' });
-    }
-  }
-
-  // Check 8: AGENTS.md exists
-  const agentsMd = join(CONFIG_DIR, 'AGENTS.md');
-  if (!existsSync(agentsMd)) {
-    issues.push({ path: 'AGENTS.md', severity: 'HIGH', msg: 'AGENTS.md routing table not found' });
-  }
-
-  // Check 9: Rules directory
-  const rulesDir = join(CONFIG_DIR, 'rules');
-  if (!existsSync(rulesDir)) {
-    warnings.push({ path: 'rules/', severity: 'WARN', msg: 'Rules directory not found' });
-  }
-
-  // Print results
-  for (const item of issues) {
-    totalIssues++;
-    const icon = item.severity === 'CRITICAL' ? '🔥' : '⚠';
-    const color = item.severity === 'CRITICAL' ? chalk.red : item.severity === 'HIGH' ? chalk.hex('#f59e0b') : chalk.yellow;
-    console.log(`  ${icon} ${color(item.severity.padEnd(8))} ${chalk.dim(item.path)}${item.line ? chalk.dim(`:${item.line}`) : ''}`);
-    console.log(chalk.dim(`     ${item.msg}`));
-  }
-
-  for (const item of warnings) {
-    totalWarnings++;
-    console.log(`  ⓘ  ${chalk.cyan('INFO'.padEnd(8))} ${chalk.dim(item.path)}`);
-    console.log(chalk.dim(`     ${item.msg}`));
   }
 
-  console.log();
-  if (totalIssues === 0 && totalWarnings === 0) {
-    console.log(chalk.green('  ✓ No issues found. Configuration looks clean.\n'));
-  } else {
-    console.log(chalk[totalIssues > 0 ? 'red' : 'yellow'](
-      `  Found ${totalIssues} issue(s) and ${totalWarnings} warning(s).\n`
-    ));
-  }
-
-  const score = Math.max(0, Math.round(100 - (totalIssues * 15 + totalWarnings * 5)));
-  const scoreColor = score >= 90 ? chalk.green : score >= 70 ? chalk.hex('#f59e0b') : chalk.red;
-  console.log(chalk.bold(`  Security Score: ${scoreColor(`${score}/100`)}\n`));
-
-  return { issues, warnings, score, totalIssues, totalWarnings };
+  for (const item of issues) console.log(chalk.red(`  ✗ ${item.severity} ${item.path}: ${item.msg}`));
+  for (const item of warnings) console.log(chalk.yellow(`  ⚠ ${item.path}: ${item.msg}`));
+  const score = Math.max(0, 100 - issues.length * 15 - warnings.length * 3);
+  console.log(`\n  Security score: ${score}/100 (${files.length} agents)\n`);
+  return { issues, warnings, score, totalIssues: issues.length, totalWarnings: warnings.length };
 }

package/cli/banner.mjs

@@ -9,28 +9,17 @@ const RUNE_HELM = `
     ╚═════╝ ╚═╝     ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝
 `;
 
-const PANTHEON = `
-
-    ╔══════════════════════════════════════════╗
-    ║                                          ║
-    ║    ᛟ Odin     ᛗ Mimir    ᚹ Heimdall     ║
-    ║    ᚱ Hermod   ᚦ Thor     ᛏ Tyr          ║
-    ║    ᛉ Vidarr   ᚨ Forseti  ᛒ Baldr        ║
-    ║                                          ║
-    ╚══════════════════════════════════════════╝
-`;
-
 export function showBanner() {
   console.clear();
   console.log(chalk.hex('#6366f1').bold(RUNE_HELM));
-  console.log(chalk.hex('#a855f7')('    Norse Pantheon Agent System for cline'));
+  console.log(chalk.hex('#a855f7')('    Guarded autonomous agent system for Claude Code'));
   console.log();
-  console.log(chalk.dim('    13 agents · 4 cost tiers · Obsidian vault long-term memory · Semble · Skills CLI · Mods'));
+  console.log(chalk.dim('    16 agents · guarded autonomy · human approval gates · MCP · Skills CLI'));
   console.log();
 }
 
 export function showPantheon() {
-  console.log(chalk.hex('#312e81')(PANTHEON));
+  console.log(chalk.hex('#312e81')('    Claude Code agents · guarded workflows · explicit approval gates'));
 }
 
 export function sectionHeading(text) {