@polderlabs/bizar 5.5.1 → 5.5.2

package/bizar-dash/tests/memory-store.test.mjs

@@ -53,11 +53,12 @@ describe('memory-store', () => {
         lightrag: { enabled: false, host: '127.0.0.1', port: 9621, workingDir: join(projectRoot, '.bizar', 'lightrag') },
         git: { autoPullOnSessionStart: false, autoCommitOnMemoryWrite: false, autoPushOnSessionEnd: false, commitAuthor: 'Bizar Memory <bizar-memory@local>', commitMessageTemplate: 'memory(my-proj): {summary}' },
       });
-      const { vaultRoot, mode } = TEST_MEMORY_STORE.resolveVault(projectRoot);
+      const { vaultRoot, projectVaultRoot, mode } = TEST_MEMORY_STORE.resolveVault(projectRoot);
       assert.strictEqual(mode, 'managed');
-      assert.ok(vaultRoot.includes('data/memory'));
-      assert.ok(vaultRoot.includes('projects'));
-      assert.ok(vaultRoot.includes('my-proj'));
+      assert.ok(vaultRoot.includes('data/memory'), 'vaultRoot should include data/memory');
+      assert.ok(projectVaultRoot.includes('projects'), 'projectVaultRoot should include projects');
+      assert.ok(projectVaultRoot.includes('my-proj'), 'projectVaultRoot should include my-proj');
+      assert.ok(projectVaultRoot.startsWith(vaultRoot), 'projectVaultRoot should be under vaultRoot');
     });
   });
 

package/bizar-dash/tests/memory-vault-config-endpoint.test.mjs

@@ -0,0 +1,173 @@
+/**
+ * tests/memory-vault-config-endpoint.test.mjs
+ *
+ * v6.x — Tests for POST /memory/config/vault endpoint which updates the
+ * vault root path persistently in ~/.config/bizar/memory-config.json
+ * and sets process.env.BIZAR_MEMORY_VAULT.
+ */
+
+import { test, describe, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { tmpdir, homedir } from 'node:os';
+import { join } from 'node:path';
+import { rmSync, existsSync, readFileSync, mkdirSync } from 'node:fs';
+import http from 'node:http';
+
+const httpPost = (port, path, body) =>
+  new Promise((resolve) => {
+    const data = JSON.stringify(body);
+    const req = http.request(
+      { hostname: 'localhost', port, path, method: 'POST', headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) } },
+      (res) => {
+        let respBody = '';
+        res.on('data', (c) => (respBody += c));
+        res.on('end', () => resolve({ status: res.statusCode, body: JSON.parse(respBody || '{}') }));
+      },
+    );
+    req.write(data);
+    req.end();
+  });
+
+async function buildApp(projectRoot) {
+  const { createMemoryRouter } = await import('../src/server/routes/memory.mjs');
+  const express = (await import('express')).default;
+  const app = express();
+  app.use(express.json());
+  app.use('/api', createMemoryRouter({ projectRoot }));
+  return app;
+}
+
+async function withApp(projectRoot, fn) {
+  const app = await buildApp(projectRoot);
+  const server = app.listen(0);
+  const port = server.address().port;
+  try {
+    return await fn(port);
+  } finally {
+    server.close();
+  }
+}
+
+function makeTmp() {
+  const root = join(tmpdir(), `bizar-vault-cfg-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(root, { recursive: true });
+  mkdirSync(join(root, '.bizar'), { recursive: true });
+  return root;
+}
+
+describe('POST /api/memory/config/vault', () => {
+  let root;
+  const capturedEnv = [];
+
+  beforeEach(() => {
+    root = makeTmp();
+    // Capture process.env changes so we can restore them
+    capturedEnv.push(process.env.BIZAR_MEMORY_VAULT);
+  });
+
+  afterEach(() => {
+    // Restore env
+    if (capturedEnv.length > 0) {
+      const prev = capturedEnv.pop();
+      if (prev === undefined) delete process.env.BIZAR_MEMORY_VAULT;
+      else process.env.BIZAR_MEMORY_VAULT = prev;
+    }
+    try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  test('returns 400 when vaultRoot is missing', async () => {
+    await withApp(root, async (port) => {
+      const res = await httpPost(port, '/api/memory/config/vault', {});
+      assert.strictEqual(res.status, 400);
+      assert.strictEqual(res.body.error, 'vaultRoot required');
+    });
+  });
+
+  test('returns 400 when vaultRoot is not a string', async () => {
+    await withApp(root, async (port) => {
+      const res = await httpPost(port, '/api/memory/config/vault', { vaultRoot: 123 });
+      assert.strictEqual(res.status, 400);
+      assert.strictEqual(res.body.error, 'vaultRoot required');
+    });
+  });
+
+  test('returns 400 when vaultRoot is an empty string', async () => {
+    await withApp(root, async (port) => {
+      const res = await httpPost(port, '/api/memory/config/vault', { vaultRoot: '  ' });
+      assert.strictEqual(res.status, 400);
+      assert.strictEqual(res.body.error, 'vaultRoot required');
+    });
+  });
+
+  test('creates the vault directory if it does not exist', async () => {
+    const targetVault = join(tmpdir(), `bizar-vault-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    assert.strictEqual(existsSync(targetVault), false);
+
+    await withApp(root, async (port) => {
+      const res = await httpPost(port, '/api/memory/config/vault', { vaultRoot: targetVault });
+      assert.strictEqual(res.status, 200);
+      assert.strictEqual(res.body.ok, true);
+      assert.strictEqual(res.body.vaultRoot, targetVault);
+    });
+
+    assert.strictEqual(existsSync(targetVault), true);
+    rmSync(targetVault, { recursive: true, force: true });
+  });
+
+  test('persists the vault root to ~/.config/bizar/memory-config.json', async () => {
+    const targetVault = join(tmpdir(), `bizar-vault-persist-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    const configPath = join(homedir(), '.config', 'bizar', 'memory-config.json');
+
+    await withApp(root, async (port) => {
+      const res = await httpPost(port, '/api/memory/config/vault', { vaultRoot: targetVault });
+      assert.strictEqual(res.status, 200);
+      assert.strictEqual(res.body.ok, true);
+    });
+
+    // Verify config was written
+    assert.strictEqual(existsSync(configPath), true);
+    const cfg = JSON.parse(readFileSync(configPath, 'utf8'));
+    assert.strictEqual(cfg.git?.repoPath, targetVault);
+
+    rmSync(targetVault, { recursive: true, force: true });
+  });
+
+  test('sets process.env.BIZAR_MEMORY_VAULT', async () => {
+    const targetVault = join(tmpdir(), `bizar-vault-env-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    assert.strictEqual(process.env.BIZAR_MEMORY_VAULT, capturedEnv[capturedEnv.length - 1] || undefined);
+
+    await withApp(root, async (port) => {
+      const res = await httpPost(port, '/api/memory/config/vault', { vaultRoot: targetVault });
+      assert.strictEqual(res.status, 200);
+    });
+
+    assert.strictEqual(process.env.BIZAR_MEMORY_VAULT, targetVault);
+    rmSync(targetVault, { recursive: true, force: true });
+  });
+
+  test('expands ~ to home directory', async () => {
+    const targetVault = `~/bizar-test-vault-${Date.now()}`;
+    const expectedVault = join(homedir(), `bizar-test-vault-${Date.now()}`);
+
+    await withApp(root, async (port) => {
+      const res = await httpPost(port, '/api/memory/config/vault', { vaultRoot: targetVault });
+      assert.strictEqual(res.status, 200);
+      assert.strictEqual(res.body.vaultRoot, expectedVault);
+    });
+
+    rmSync(expectedVault, { recursive: true, force: true });
+  });
+
+  test('returns the resolved vault root in the response', async () => {
+    const targetVault = join(tmpdir(), `bizar-vault-resolved-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+
+    await withApp(root, async (port) => {
+      const res = await httpPost(port, '/api/memory/config/vault', { vaultRoot: targetVault });
+      assert.strictEqual(res.status, 200);
+      assert.strictEqual(res.body.ok, true);
+      assert.strictEqual(res.body.vaultRoot, targetVault);
+    });
+
+    rmSync(targetVault, { recursive: true, force: true });
+  });
+});

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: /exit settings/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: /env vars/i }));
+    expect(onSettingsSectionChange).toHaveBeenCalledWith('env-vars');
+  });
+
+  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 (first 4 tabs from TABS)
+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,127 @@
+/**
+ * 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: /exit settings/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();
+  });
+
+  it('renders section items within each group', () => {
+    render(
+      <SettingsNav
+        activeSection={null}
+        onSectionChange={onSectionChange}
+        onExitSettings={onExitSettings}
+      />,
+    );
+    // General group
+    expect(screen.getByRole('button', { name: /theme/i })).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /layout/i })).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /general/i })).toBeInTheDocument();
+    // Core group
+    expect(screen.getByRole('button', { name: /env vars/i })).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /system llm/i })).toBeInTheDocument();
+    // Experience group
+    expect(screen.getByRole('button', { name: /updates/i })).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /headroom/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/bizar-dash/tests/views/Memory.test.tsx

@@ -6,6 +6,9 @@
  * path to '' and rendered "(loading…)" forever. After the fix, they fetch
  * /api/memory/status and render the actual path or a "not initialised"
  * placeholder, plus an Initialise button.
+ *
+ * v6.x also adds tests for the Save Path button calling
+ * POST /memory/config/vault (instead of just showing a message).
  */
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { render, screen, waitFor } from '@testing-library/react';
@@ -56,6 +59,7 @@ describe('MemoryOverview vault path', () => {
         initialized: true,
         mode: 'local-only',
         vaultRoot: '/Users/test/.bizar_memory',
+        projectVaultRoot: '/Users/test/.bizar_memory',
         noteCount: 5,
         gitClean: true,
         branch: 'main',
@@ -88,7 +92,7 @@ describe('MemoryOverview vault path', () => {
   it('shows "not initialised" when status reports initialized=false', async () => {
     (api.get as ReturnType<typeof vi.fn>).mockImplementation((url: string) => {
       if (url === '/memory/status') return Promise.resolve({
-        initialized: false, mode: null, projectId: null, vaultRoot: null,
+        initialized: false, mode: null, projectId: null, vaultRoot: null, projectVaultRoot: null,
       });
       if (url === '/memory/health') return Promise.resolve({
         score: 0, status: 'unconfigured', checks: [], message: 'not initialised',
@@ -185,6 +189,41 @@ describe('ConfigPanel vault path', () => {
     await user.click(screen.getByTestId('memory-init-vault'));
     expect(post).toHaveBeenCalledWith('/memory/init', expect.anything());
   });
+
+  // v6.x — Save Path now calls POST /memory/config/vault
+  it('calls POST /memory/config/vault when Save path is clicked (already initialised)', async () => {
+    const post = vi.fn().mockResolvedValue({ ok: true, vaultRoot: '/new/path/.bizar_memory' });
+    (api.get as ReturnType<typeof vi.fn>).mockImplementation((url: string) => {
+      if (url === '/memory/config/global') return Promise.resolve({ config: { git: { remoteUrl: '' } } });
+      if (url === '/memory/status') return Promise.resolve({
+        initialized: true, vaultRoot: '/old/path/.bizar_memory', mode: 'managed',
+      });
+      if (url === '/memory/git/status') return Promise.resolve({ ok: true, clean: true, branch: 'main' });
+      return Promise.resolve(null);
+    });
+    (api.post as ReturnType<typeof vi.fn>) = post;
+
+    const user = userEvent.setup();
+    render(
+      <Harness>
+        <ConfigPanel refreshKey={0} />
+      </Harness>,
+    );
+
+    await waitFor(() => {
+      expect(screen.getByTestId('memory-save-vault-path')).toBeInTheDocument();
+    });
+
+    // Change the vault path input
+    const input = screen.getByTestId('memory-vault-path-input');
+    await user.clear(input);
+    await user.type(input, '/new/path/.bizar_memory');
+
+    await user.click(screen.getByTestId('memory-save-vault-path'));
+
+    // v6.x: should call /memory/config/vault (not just show a message)
+    expect(post).toHaveBeenCalledWith('/memory/config/vault', { vaultRoot: '/new/path/.bizar_memory' });
+  });
 });
 
 describe('MemorySection (settings) vault path', () => {