@polderlabs/bizar 5.0.0 → 5.0.2

package/bizar-dash/tests/schedules-templates.test.mjs

@@ -0,0 +1,144 @@
+/**
+ * bizar-dash/tests/schedules-templates.test.mjs
+ *
+ * Verify schedule template loading and from-template endpoint.
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { readFileSync, existsSync, readdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+const PROJECT_ROOT = join(__dirname, '..', '..');
+const TEMPLATES_DIR = join(PROJECT_ROOT, 'templates', 'schedules');
+
+describe('Schedule templates', () => {
+  it('templates/schedules directory exists', () => {
+    assert.ok(existsSync(TEMPLATES_DIR), 'Missing templates/schedules directory');
+  });
+
+  it('at least 4 template files exist', () => {
+    const files = readdirSync(TEMPLATES_DIR).filter((f) => f.endsWith('.json'));
+    assert.ok(files.length >= 4, `Expected >=4 templates, found ${files.length}: ${files.join(', ')}`);
+  });
+
+  it('each template is valid JSON with required fields', () => {
+    const files = readdirSync(TEMPLATES_DIR).filter((f) => f.endsWith('.json'));
+    for (const file of files) {
+      const content = readFileSync(join(TEMPLATES_DIR, file), 'utf8');
+      const template = JSON.parse(content);
+      assert.ok(template.id, `${file}: missing id`);
+      assert.ok(template.name, `${file}: missing name`);
+      assert.ok(template.description, `${file}: missing description`);
+      assert.ok(template.type, `${file}: missing type`);
+      assert.ok(template.action, `${file}: missing action`);
+      assert.strictEqual(template.source, undefined, `${file}: should NOT have source field (added at load time)`);
+    }
+  });
+
+  it('daily-backup.json is a valid cron schedule template', () => {
+    const content = readFileSync(join(TEMPLATES_DIR, 'daily-backup.json'), 'utf8');
+    const t = JSON.parse(content);
+    assert.strictEqual(t.type, 'cron');
+    assert.strictEqual(t.schedule, '0 3 * * *');
+    assert.strictEqual(t.action.type, 'command');
+    assert.ok(t.action.target.includes('bizar backup'));
+  });
+
+  it('weekly-digest.json is a valid agent template', () => {
+    const content = readFileSync(join(TEMPLATES_DIR, 'weekly-digest.json'), 'utf8');
+    const t = JSON.parse(content);
+    assert.strictEqual(t.type, 'cron');
+    assert.strictEqual(t.action.type, 'agent');
+    assert.ok(t.action.prompt);
+  });
+
+  it('hourly-health-check.json is a valid interval template', () => {
+    const content = readFileSync(join(TEMPLATES_DIR, 'hourly-health-check.json'), 'utf8');
+    const t = JSON.parse(content);
+    assert.strictEqual(t.type, 'interval');
+    assert.strictEqual(t.action.type, 'command');
+  });
+
+  it('webhook-on-push.json has webhook action', () => {
+    const content = readFileSync(join(TEMPLATES_DIR, 'webhook-on-push.json'), 'utf8');
+    const t = JSON.parse(content);
+    assert.strictEqual(t.action.type, 'webhook');
+    assert.ok(t.action.target);
+  });
+});
+
+describe('loadTemplates (unit)', () => {
+  // Re-implement loadTemplates here to test in isolation
+  function loadTemplates() {
+    if (!existsSync(TEMPLATES_DIR)) return [];
+    return readdirSync(TEMPLATES_DIR)
+      .filter((f) => f.endsWith('.json'))
+      .map((f) => {
+        const content = JSON.parse(readFileSync(join(TEMPLATES_DIR, f), 'utf8'));
+        return { ...content, source: 'template', templateFile: f };
+      });
+  }
+
+  it('returns array with source=template and templateFile set', () => {
+    const templates = loadTemplates();
+    assert.ok(Array.isArray(templates));
+    assert.ok(templates.length > 0);
+    for (const t of templates) {
+      assert.strictEqual(t.source, 'template', 'each template should have source=template');
+      assert.ok(t.templateFile.endsWith('.json'), 'templateFile should be a .json file');
+    }
+  });
+
+  it('missing templates dir returns empty array', () => {
+    // Use a path that definitely doesn't exist
+    const fakeDir = join(TEMPLATES_DIR, '..', 'schedules-does-not-exist');
+    function loadFromFake() {
+      if (!existsSync(fakeDir)) return [];
+      return readdirSync(fakeDir).filter((f) => f.endsWith('.json'));
+    }
+    const result = loadFromFake();
+    assert.deepStrictEqual(result, []);
+  });
+});
+
+describe('from-template endpoint contract', () => {
+  it('template payload can be used to create a valid schedule payload', () => {
+    const content = readFileSync(join(TEMPLATES_DIR, 'daily-backup.json'), 'utf8');
+    const template = JSON.parse(content);
+
+    // Simulate what the route does
+    const schedulePayload = {
+      name: template.name,
+      type: template.type,
+      schedule: template.schedule,
+      timezone: template.timezone || 'UTC',
+      action: template.action,
+      enabled: true,
+    };
+
+    assert.ok(schedulePayload.name);
+    assert.ok(['cron', 'interval', 'once'].includes(schedulePayload.type));
+    assert.ok(schedulePayload.schedule);
+    assert.ok(schedulePayload.action);
+    assert.strictEqual(schedulePayload.enabled, true);
+  });
+
+  it('custom name can override template name', () => {
+    const content = readFileSync(join(TEMPLATES_DIR, 'daily-backup.json'), 'utf8');
+    const template = JSON.parse(content);
+    const customName = 'My Custom Backup';
+
+    const schedulePayload = {
+      name: customName || template.name,
+      type: template.type,
+      schedule: template.schedule,
+      timezone: template.timezone || 'UTC',
+      action: template.action,
+      enabled: true,
+    };
+
+    assert.strictEqual(schedulePayload.name, customName);
+  });
+});

package/bizar-dash/tests/settings-layout.test.tsx

@@ -0,0 +1,129 @@
+/**
+ * tests/settings-layout.test.tsx
+ *
+ * v4.9.0 — Integration tests for the settings sidebar layout mode.
+ * Verifies that when settingsMode is active, the sidebar shows SettingsNav
+ * and clicking sections updates the active section.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import React from 'react';
+import { Sidebar } from '../src/web/components/Sidebar';
+import type { TabDef } from '../src/web/components/Topbar';
+import { LayoutDashboard, MessageSquare, Sliders } from 'lucide-react';
+
+const TABS: TabDef[] = [
+  { id: 'overview', label: 'Overview', icon: LayoutDashboard },
+  { id: 'chat', label: 'Chat', icon: MessageSquare },
+  { id: 'settings', label: 'Settings', icon: Sliders },
+];
+
+describe('Sidebar — settingsMode', () => {
+  const onTabChange = vi.fn();
+  const onSettingsSectionChange = vi.fn();
+  const onExitSettings = vi.fn();
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('renders normal tab rail when settingsMode is false', () => {
+    render(
+      <Sidebar
+        tabs={TABS}
+        activeTab="overview"
+        onTabChange={onTabChange}
+        settingsMode={false}
+      />,
+    );
+    expect(screen.getByRole('tablist')).toBeInTheDocument();
+    expect(screen.getByRole('tab', { name: /overview/i })).toBeInTheDocument();
+    expect(screen.getByRole('tab', { name: /chat/i })).toBeInTheDocument();
+  });
+
+  it('renders SettingsNav instead of tab rail when settingsMode is true', () => {
+    render(
+      <Sidebar
+        tabs={TABS}
+        activeTab="settings"
+        onTabChange={onTabChange}
+        settingsMode={true}
+        settingsActiveSection={null}
+        onSettingsSectionChange={onSettingsSectionChange}
+        onExitSettings={onExitSettings}
+      />,
+    );
+    // Should NOT show the normal tab rail
+    expect(screen.queryByRole('tablist')).not.toBeInTheDocument();
+    // Should show the back button
+    expect(screen.getByRole('button', { name: /back/i })).toBeInTheDocument();
+    // Should show section groups (use selector to avoid duplicate text matches)
+    expect(screen.getByText('General', { selector: '.settings-nav-group-label' })).toBeInTheDocument();
+    expect(screen.getByText('Core', { selector: '.settings-nav-group-label' })).toBeInTheDocument();
+  });
+
+  it('shows Back button that calls onExitSettings', async () => {
+    const user = userEvent.setup();
+    render(
+      <Sidebar
+        tabs={TABS}
+        activeTab="settings"
+        onTabChange={onTabChange}
+        settingsMode={true}
+        settingsActiveSection={null}
+        onSettingsSectionChange={onSettingsSectionChange}
+        onExitSettings={onExitSettings}
+      />,
+    );
+    await user.click(screen.getByText('Back'));
+    expect(onExitSettings).toHaveBeenCalledTimes(1);
+  });
+
+  it('highlights the active section when settingsActiveSection is set', () => {
+    render(
+      <Sidebar
+        tabs={TABS}
+        activeTab="settings"
+        onTabChange={onTabChange}
+        settingsMode={true}
+        settingsActiveSection="theme"
+        onSettingsSectionChange={onSettingsSectionChange}
+        onExitSettings={onExitSettings}
+      />,
+    );
+    const themeBtn = screen.getByRole('button', { name: /theme/i });
+    expect(themeBtn).toHaveClass('settings-nav-item-active');
+  });
+
+  it('calls onSettingsSectionChange when a section is clicked', async () => {
+    const user = userEvent.setup();
+    render(
+      <Sidebar
+        tabs={TABS}
+        activeTab="settings"
+        onTabChange={onTabChange}
+        settingsMode={true}
+        settingsActiveSection={null}
+        onSettingsSectionChange={onSettingsSectionChange}
+        onExitSettings={onExitSettings}
+      />,
+    );
+    await user.click(screen.getByRole('button', { name: /memory/i }));
+    expect(onSettingsSectionChange).toHaveBeenCalledWith('memory');
+  });
+
+  it('calls onTabChange when a normal sidebar tab is clicked', async () => {
+    const user = userEvent.setup();
+    render(
+      <Sidebar
+        tabs={TABS}
+        activeTab="overview"
+        onTabChange={onTabChange}
+        settingsMode={false}
+      />,
+    );
+    await user.click(screen.getByRole('tab', { name: /chat/i }));
+    expect(onTabChange).toHaveBeenCalledWith('chat');
+  });
+});

package/bizar-dash/tests/settings-mode-wiring.test.tsx

@@ -0,0 +1,151 @@
+/**
+ * tests/settings-mode-wiring.test.tsx
+ *
+ * v4.9.0 — Wiring tests for settings mode.
+ * Verifies:
+ * 1. Topbar Settings tab calls onTabChange('settings') when clicked
+ * 2. Sidebar renders SettingsNav when settingsMode is true
+ * 3. Sidebar renders normal tab rail when settingsMode is false
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import React from 'react';
+import { Sidebar } from '../src/web/components/Sidebar';
+import { Topbar, TABS } from '../src/web/components/Topbar';
+import type { TabDef } from '../src/web/components/Topbar';
+
+// Minimal tabs for testing
+const TEST_TABS: TabDef[] = TABS.slice(0, 4);
+
+describe('Settings mode wiring', () => {
+  describe('Topbar', () => {
+    it('calls onTabChange with "settings" when the Settings tab is clicked', async () => {
+      const onTabChange = vi.fn();
+      const user = userEvent.setup();
+
+      render(
+        <Topbar
+          activeTab="overview"
+          onTabChange={onTabChange}
+          wsStatus="connected"
+          version="v4.9.0"
+          activeProject={null}
+          projects={[]}
+          onProjectChange={vi.fn()}
+          onProjectsRefresh={vi.fn()}
+          onOpenSearch={vi.fn()}
+        />,
+      );
+
+      // Find and click the Settings tab
+      const settingsTab = screen.getByRole('tab', { name: /settings/i });
+      await user.click(settingsTab);
+
+      expect(onTabChange).toHaveBeenCalledWith('settings');
+    });
+
+    it('calls onTabChange with "overview" when the Overview tab is clicked', async () => {
+      const onTabChange = vi.fn();
+      const user = userEvent.setup();
+
+      render(
+        <Topbar
+          activeTab="settings"
+          onTabChange={onTabChange}
+          wsStatus="connected"
+          version="v4.9.0"
+          activeProject={null}
+          projects={[]}
+          onProjectChange={vi.fn()}
+          onProjectsRefresh={vi.fn()}
+          onOpenSearch={vi.fn()}
+        />,
+      );
+
+      const overviewTab = screen.getByRole('tab', { name: /overview/i });
+      await user.click(overviewTab);
+
+      expect(onTabChange).toHaveBeenCalledWith('overview');
+    });
+  });
+
+  describe('Sidebar', () => {
+    const onTabChange = vi.fn();
+    const onSettingsSectionChange = vi.fn();
+    const onExitSettings = vi.fn();
+
+    beforeEach(() => {
+      vi.clearAllMocks();
+    });
+
+    it('renders SettingsNav when settingsMode is true', () => {
+      render(
+        <Sidebar
+          tabs={TEST_TABS}
+          activeTab="settings"
+          onTabChange={onTabChange}
+          settingsMode={true}
+          settingsActiveSection={null}
+          onSettingsSectionChange={onSettingsSectionChange}
+          onExitSettings={onExitSettings}
+        />,
+      );
+
+      // SettingsNav should be visible (renders the back button)
+      expect(screen.getByRole('button', { name: /exit settings/i })).toBeInTheDocument();
+      // Normal tab rail should NOT be visible
+      expect(screen.queryByRole('tablist')).not.toBeInTheDocument();
+    });
+
+    it('renders normal tab rail when settingsMode is false', () => {
+      render(
+        <Sidebar
+          tabs={TEST_TABS}
+          activeTab="overview"
+          onTabChange={onTabChange}
+          settingsMode={false}
+        />,
+      );
+
+      // Tab rail should be visible
+      expect(screen.getByRole('tablist')).toBeInTheDocument();
+      // SettingsNav should NOT be visible
+      expect(screen.queryByRole('button', { name: /back/i })).not.toBeInTheDocument();
+    });
+
+    it('exits settings mode when back button is clicked', async () => {
+      const user = userEvent.setup();
+      render(
+        <Sidebar
+          tabs={TEST_TABS}
+          activeTab="settings"
+          onTabChange={onTabChange}
+          settingsMode={true}
+          settingsActiveSection={null}
+          onSettingsSectionChange={onSettingsSectionChange}
+          onExitSettings={onExitSettings}
+        />,
+      );
+
+      await user.click(screen.getByRole('button', { name: /exit settings/i }));
+      expect(onExitSettings).toHaveBeenCalledTimes(1);
+    });
+
+    it('calls onTabChange when a tab is clicked while in settingsMode=false', async () => {
+      const user = userEvent.setup();
+      render(
+        <Sidebar
+          tabs={TEST_TABS}
+          activeTab="overview"
+          onTabChange={onTabChange}
+          settingsMode={false}
+        />,
+      );
+
+      // Click the Chat tab
+      await user.click(screen.getByRole('tab', { name: /chat/i }));
+      expect(onTabChange).toHaveBeenCalledWith('chat');
+    });
+  });
+});

package/bizar-dash/tests/settings-nav.test.tsx

@@ -0,0 +1,126 @@
+/**
+ * tests/settings-nav.test.tsx
+ *
+ * v4.9.0 — Component tests for SettingsNav sidebar component.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import React from 'react';
+import { SettingsNav } from '../src/web/components/SettingsNav';
+
+describe('SettingsNav', () => {
+  const onSectionChange = vi.fn();
+  const onExitSettings = vi.fn();
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('renders the back button', () => {
+    render(
+      <SettingsNav
+        activeSection={null}
+        onSectionChange={onSectionChange}
+        onExitSettings={onExitSettings}
+      />,
+    );
+    expect(screen.getByRole('button', { name: /back/i })).toBeInTheDocument();
+  });
+
+  it('calls onExitSettings when back button is clicked', async () => {
+    const user = userEvent.setup();
+    render(
+      <SettingsNav
+        activeSection={null}
+        onSectionChange={onSectionChange}
+        onExitSettings={onExitSettings}
+      />,
+    );
+    await user.click(screen.getByText('Back'));
+    expect(onExitSettings).toHaveBeenCalledTimes(1);
+  });
+
+  it('renders section groups with group-label class', () => {
+    render(
+      <SettingsNav
+        activeSection={null}
+        onSectionChange={onSectionChange}
+        onExitSettings={onExitSettings}
+      />,
+    );
+    expect(screen.getByText('General', { selector: '.settings-nav-group-label' })).toBeInTheDocument();
+    expect(screen.getByText('Core', { selector: '.settings-nav-group-label' })).toBeInTheDocument();
+    expect(screen.getByText('Experience', { selector: '.settings-nav-group-label' })).toBeInTheDocument();
+    expect(screen.getByText('Data', { selector: '.settings-nav-group-label' })).toBeInTheDocument();
+  });
+
+  it('renders section items within each group', () => {
+    render(
+      <SettingsNav
+        activeSection={null}
+        onSectionChange={onSectionChange}
+        onExitSettings={onExitSettings}
+      />,
+    );
+    expect(screen.getByRole('button', { name: /theme/i })).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /env vars/i })).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /memory/i })).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /system llm/i })).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /updates/i })).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /skills/i })).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /headroom/i })).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /backup/i })).toBeInTheDocument();
+  });
+
+  it('calls onSectionChange with correct id when a section is clicked', async () => {
+    const user = userEvent.setup();
+    render(
+      <SettingsNav
+        activeSection={null}
+        onSectionChange={onSectionChange}
+        onExitSettings={onExitSettings}
+      />,
+    );
+    await user.click(screen.getByRole('button', { name: /theme/i }));
+    expect(onSectionChange).toHaveBeenCalledWith('theme');
+  });
+
+  it('highlights the active section', () => {
+    render(
+      <SettingsNav
+        activeSection="theme"
+        onSectionChange={onSectionChange}
+        onExitSettings={onExitSettings}
+      />,
+    );
+    const themeBtn = screen.getByRole('button', { name: /theme/i });
+    expect(themeBtn).toHaveClass('settings-nav-item-active');
+  });
+
+  it('toggles off the active section when clicking it again', async () => {
+    const user = userEvent.setup();
+    render(
+      <SettingsNav
+        activeSection="theme"
+        onSectionChange={onSectionChange}
+        onExitSettings={onExitSettings}
+      />,
+    );
+    await user.click(screen.getByRole('button', { name: /theme/i }));
+    expect(onSectionChange).toHaveBeenCalledWith(null); // toggles off
+  });
+
+  it('renders chevron on the active section', () => {
+    render(
+      <SettingsNav
+        activeSection="theme"
+        onSectionChange={onSectionChange}
+        onExitSettings={onExitSettings}
+      />,
+    );
+    const themeBtn = screen.getByRole('button', { name: /theme/i });
+    // The chevron is inside the button as an SVG (aria-hidden), so we just verify the button exists
+    expect(themeBtn).toBeInTheDocument();
+  });
+});

package/cli/commands/dash.mjs

@@ -129,7 +129,11 @@ export async function runDash(dashArgs) {
   switch (sub) {
     case 'start':
       if (subOpts.bg) {
-        await dashModule.startInBackground(['start', ...(subOpts.subArgs || [])]);
+        // Pass --port, --host, --bind through to the child process
+        const bgArgs = ['start', ...(subOpts.subArgs || [])];
+        if (subOpts.port) bgArgs.push('--port', String(subOpts.port));
+        if (process.env.BIZAR_DASHBOARD_BIND) bgArgs.push('--bind', process.env.BIZAR_DASHBOARD_BIND);
+        await dashModule.startInBackground(bgArgs);
       } else {
         await dashModule.start(subOpts);
       }

package/cli/commands/minimax.mjs

@@ -148,8 +148,11 @@ async function runMinimaxCommand(minimaxArgs) {
     for (const m of data.models || []) {
       const five = m.current_interval_remaining_percent;
       const week = m.current_weekly_remaining_percent;
-      const fiveBar = '█'.repeat(Math.round(five / 5)) + '░'.repeat(20 - Math.round(five / 5));
-      const weekBar = '█'.repeat(Math.round(week / 5)) + '░'.repeat(20 - Math.round(week / 5));
+      // Bar shows CONSUMED as filled (inverted from remaining)
+      const fiveConsumed = 100 - five;
+      const weekConsumed = 100 - week;
+      const fiveBar = '█'.repeat(Math.round(fiveConsumed / 5)) + '░'.repeat(20 - Math.round(fiveConsumed / 5));
+      const weekBar = '█'.repeat(Math.round(weekConsumed / 5)) + '░'.repeat(20 - Math.round(weekConsumed / 5));
       const fiveColor = five >= 75 ? chalk.green : five >= 25 ? chalk.yellow : chalk.red;
       const weekColor = week >= 75 ? chalk.green : week >= 25 ? chalk.yellow : chalk.red;
       console.log(`    ${chalk.bold(m.model_name)}`);

package/cli/tests/minimax-cli.test.mjs

@@ -0,0 +1,79 @@
+/**
+ * cli/tests/minimax-cli.test.mjs
+ *
+ * Tests for MiniMax CLI bar rendering.
+ * Verifies bar shows CONSUMED quota as filled blocks (not remaining).
+ */
+
+import { test, describe } from 'node:test';
+import assert from 'node:assert';
+
+// ── Bar rendering helper (mirrors minimax.mjs logic) ──────────────────────────
+
+/**
+ * Render a quota bar string.
+ * @param {number} remainingPct - percentage of quota remaining (0-100)
+ * @returns {string} bar string like '██░░░░░░░░░░░░░░░░░' (20 chars total)
+ */
+function renderBar(remainingPct) {
+  const consumed = 100 - remainingPct;
+  const filled = Math.round(consumed / 5);
+  const empty = 20 - filled;
+  return '█'.repeat(filled) + '░'.repeat(empty);
+}
+
+// ── Tests ───────────────────────────────────────────────────────────────────
+
+describe('MiniMax CLI bar rendering', () => {
+
+  test('91% remaining → 9% consumed → 2 filled blocks (9/5 rounds to 2)', () => {
+    const bar = renderBar(91);
+    const filledCount = (bar.match(/█/g) || []).length;
+    assert.strictEqual(filledCount, 2, `Expected 2 filled blocks for 91% remaining, got ${filledCount}`);
+    assert.strictEqual(bar.length, 20, `Bar should be exactly 20 chars`);
+  });
+
+  test('100% remaining → 0% consumed → 0 filled blocks', () => {
+    const bar = renderBar(100);
+    const filledCount = (bar.match(/█/g) || []).length;
+    assert.strictEqual(filledCount, 0, `Expected 0 filled blocks for 100% remaining`);
+  });
+
+  test('0% remaining → 100% consumed → 20 filled blocks', () => {
+    const bar = renderBar(0);
+    const filledCount = (bar.match(/█/g) || []).length;
+    assert.strictEqual(filledCount, 20, `Expected 20 filled blocks for 0% remaining`);
+  });
+
+  test('75% remaining → 25% consumed → 5 filled blocks', () => {
+    const bar = renderBar(75);
+    const filledCount = (bar.match(/█/g) || []).length;
+    assert.strictEqual(filledCount, 5, `Expected 5 filled blocks for 75% remaining`);
+  });
+
+  test('25% remaining → 75% consumed → 15 filled blocks', () => {
+    const bar = renderBar(25);
+    const filledCount = (bar.match(/█/g) || []).length;
+    assert.strictEqual(filledCount, 15, `Expected 15 filled blocks for 25% remaining`);
+  });
+
+  test('bar is always exactly 20 characters', () => {
+    for (const remaining of [0, 10, 25, 50, 75, 90, 100]) {
+      const bar = renderBar(remaining);
+      assert.strictEqual(bar.length, 20, `Bar for ${remaining}% remaining should be 20 chars, got ${bar.length}`);
+    }
+  });
+
+  test('filled blocks increase as remaining decreases', () => {
+    const bars = [100, 91, 75, 50, 25, 10, 0].map(r => ({
+      remaining: r,
+      filled: (renderBar(r).match(/█/g) || []).length
+    }));
+    for (let i = 1; i < bars.length; i++) {
+      assert.ok(
+        bars[i].filled >= bars[i-1].filled,
+        `${bars[i].remaining}% remaining (${bars[i].filled} blocks) should have >= filled blocks than ${bars[i-1].remaining}% remaining (${bars[i-1].filled} blocks)`
+      );
+    }
+  });
+});

package/config/agents/frigg.md

@@ -1,7 +1,7 @@
 ---
 description: Frigg — Read-only codebase Q&A. Answers questions about the project with file references, never modifies anything. Routes to no one.
 mode: subagent
-model: opencode/deepseek-v4-flash-free
+model: minimax/MiniMax-M2.7
 color: "#f472b6"
 permission:
   read: allow

package/config/agents/heimdall.md

@@ -1,7 +1,7 @@
 ---
 description: Heimdall — Simple, routine, and deterministic tasks using DeepSeek. Quick edits, mechanical work, file operations. The ever-watchful guardian.
 mode: subagent
-model: opencode/deepseek-v4-flash-free
+model: minimax/MiniMax-M2.7
 color: "#10b981"
 permission:
   read: allow