@polderlabs/bizar 5.4.0 → 5.5.0

package/bizar-dash/src/server/memory-lightrag.mjs

@@ -217,6 +217,69 @@ function redactLightRAG(cfg) {
   };
 }
 
+/**
+ * v5.x — Detect which LLM provider is available for LightRAG.
+ *
+ * Decision order:
+ *   1. If `llmBinding === 'ollama'`, do a quick async probe of
+ *      localhost:11434 (or the configured `llmBindingHost`).
+ *      If reachable → ollama available. If unreachable but an API key
+ *      is configured for OpenAI / Anthropic / MiniMax → use that instead.
+ *   2. For cloud bindings (openai / anthropic / minimax / etc.),
+ *      check whether the corresponding env var is set. If yes → available.
+ *   3. If no provider is detectable, return null and the caller logs
+ *      a warning and skips reindex.
+ *
+ * Returns { provider, available, detail } or null.
+ */
+export async function detectAvailableLLM(config) {
+  const binding = config.llmBinding || 'ollama';
+
+  if (binding === 'ollama') {
+    const ollamaHost = config.llmBindingHost || 'http://localhost:11434';
+    // Quick async probe — give it 1.5s to connect.
+    try {
+      const controller = new AbortController();
+      const t = setTimeout(() => controller.abort(), 1500);
+      const res = await fetch(`${ollamaHost}/`, {
+        method: 'HEAD',
+        signal: controller.signal,
+      });
+      clearTimeout(t);
+      if (res.ok || res.status < 500) {
+        return { provider: 'ollama', available: true, detail: ollamaHost };
+      }
+    } catch {
+      // Fall through — ollama not reachable.
+    }
+    // ollama not reachable; check for cloud API keys as fallback.
+    const hasOpenAI = !!(process.env.OPENAI_API_KEY || process.env.OPENAI_API_KEY_2);
+    const hasAnthropic = !!(process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY_2);
+    const hasMinimax = !!(process.env.MINIMAX_API_KEY || process.env.MINIMAX_API_KEY_2);
+    if (hasOpenAI || hasAnthropic || hasMinimax) {
+      const provider = hasOpenAI ? 'openai' : hasAnthropic ? 'anthropic' : 'minimax';
+      return { provider, available: true, detail: `${provider} (ollama unreachable, using API key)` };
+    }
+    return null; // no ollama, no API key
+  }
+
+  // Cloud bindings — available if API key is set.
+  const apiKeyEnvVars = {
+    openai: ['OPENAI_API_KEY', 'OPENAI_API_KEY_2'],
+    anthropic: ['ANTHROPIC_API_KEY', 'ANTHROPIC_API_KEY_2'],
+    minimax: ['MINIMAX_API_KEY', 'MINIMAX_API_KEY_2'],
+    azure_openai: ['AZURE_OPENAI_API_KEY'],
+    gemini: ['GEMINI_API_KEY'],
+  };
+  const relevantKeys = apiKeyEnvVars[binding] || [];
+  const hasKey = relevantKeys.some((k) => process.env[k]);
+  if (hasKey) {
+    return { provider: binding, available: true, detail: binding };
+  }
+
+  return null; // configured binding but no key detected
+}
+
 /**
  * Resolve the LightRAG config for a project.
  * Pulls from `.bizar/memory.json` (lightrag block) and applies defaults.
@@ -539,6 +602,11 @@ export async function stopServer(config, { logger } = {}) {
 /**
  * Idempotent: returns immediately if the server is healthy. Otherwise
  * starts it. Returns { ok, started, pid?, error? }.
+ *
+ * v5.x — Before starting, calls `detectAvailableLLM` to check whether
+ * the configured LLM provider is reachable. If no provider is detected
+ * (ollama unreachable + no API key), returns { ok: false } with a
+ * descriptive error rather than starting LightRAG in a broken state.
  */
 export async function ensureRunning(config, opts) {
   if (!config.enabled) {
@@ -547,10 +615,116 @@ export async function ensureRunning(config, opts) {
   if (await isRunning(config)) {
     return { ok: true, started: false };
   }
+  // v5.x — probe LLM availability before attempting to start.
+  const llm = await detectAvailableLLM(config);
+  if (!llm) {
+    const binding = config.llmBinding || 'ollama';
+    return {
+      ok: false,
+      started: false,
+      error: `lightrag cannot start: ${binding} is not reachable and no API key is configured. `
+        + `Set an API key env var (OPENAI_API_KEY, ANTHROPIC_API_KEY, or MINIMAX_API_KEY) `
+        + `or ensure ollama is running, then try again.`,
+    };
+  }
   const r = await startServer(config, opts);
   return { ok: r.ok, started: r.ok, pid: r.pid, error: r.error };
 }
 
+/**
+ * v5.x — LightRAG startup hook (issue #6).
+ *
+ * Called by server.mjs on dashboard boot (and exposed via
+ * `bizar lightrag autostart`). Reads the active project from
+ * `state.projectRoot` (or whatever is passed in), resolves the
+ * LightRAG config, and starts the server if the user's settings
+ * allow it.
+ *
+ * Decision flow:
+ *   1. Resolve config from .bizar/memory.json — if `lightrag.enabled`
+ *      is `false`, skip silently (return ok=true, started=false,
+ *      reason='disabled').
+ *   2. Read the env override `BIZAR_LIGHTRAG_AUTOSTART` — if set to
+ *      '0' / 'false' / 'no', skip.
+ *   3. Check if the server is already running — if so, return
+ *      ok=true, started=false, reason='already-running'.
+ *   4. Otherwise call `startServer(config)` and return its result.
+ *
+ * Errors are caught and logged as warnings — startup must not fail
+ * the dashboard just because LightRAG couldn't be started (the user
+ * may not have the binary installed, may be running the dashboard
+ * in an environment where LightRAG isn't needed, etc.).
+ *
+ * @param {string} projectRoot — path to the active project root
+ *   (where `.bizar/memory.json` lives). When omitted, the hook
+ *   returns ok=false with reason='no-project' (the caller didn't
+ *   tell us where to look).
+ * @param {{ logger?: { info?: Function, warn?: Function } }} [opts]
+ * @returns {Promise<{ ok: boolean, started: boolean, pid?: number|null, reason?: string, error?: string }>}
+ */
+export async function lightragStartupHook(projectRoot, opts = {}) {
+  const log = (...a) => opts?.logger?.info?.('[lightrag]', ...a) || console.log('[lightrag]', ...a);
+  const warn = (...a) => opts?.logger?.warn?.('[lightrag]', ...a) || console.warn('[lightrag]', ...a);
+
+  // 1. No project → can't resolve config.
+  if (!projectRoot || typeof projectRoot !== 'string') {
+    return { ok: false, started: false, reason: 'no-project' };
+  }
+
+  // 2. Resolve config (from .bizar/memory.json).
+  let config;
+  try {
+    config = resolveLightRAGConfig(projectRoot);
+  } catch (err) {
+    warn('startup hook: failed to resolve config:', err?.message || err);
+    return { ok: false, started: false, error: err?.message || String(err) };
+  }
+
+  // 3. Check lightrag.enabled flag.
+  if (config.enabled === false) {
+    log('startup hook: lightrag disabled in .bizar/memory.json, skipping');
+    return { ok: true, started: false, reason: 'disabled' };
+  }
+
+  // 4. Check env-var override.
+  const envAuto = process.env.BIZAR_LIGHTRAG_AUTOSTART;
+  if (typeof envAuto === 'string' && /^(0|false|no|off)$/i.test(envAuto.trim())) {
+    log(`startup hook: BIZAR_LIGHTRAG_AUTOSTART=${envAuto}, skipping`);
+    return { ok: true, started: false, reason: 'env-disabled' };
+  }
+
+  // 5. Already running? Nothing to do.
+  try {
+    if (await isRunning(config)) {
+      log('startup hook: lightrag already running');
+      return { ok: true, started: false, reason: 'already-running' };
+    }
+  } catch (err) {
+    warn('startup hook: isRunning probe failed:', err?.message || err);
+  }
+
+  // 6. Try to start.
+  try {
+    const r = await startServer(config, opts);
+    if (r.ok) {
+      if (r.alreadyRunning) {
+        log(`startup hook: lightrag already running (pid=${r.pid})`);
+        return { ok: true, started: false, reason: 'already-running', pid: r.pid };
+      }
+      log(`startup hook: lightrag started (pid=${r.pid})`);
+      return { ok: true, started: true, pid: r.pid };
+    }
+    warn(`startup hook: start failed: ${r.error || 'unknown'}`);
+    return { ok: false, started: false, error: r.error || 'start failed' };
+  } catch (err) {
+    // Catch-all: dashboard boot must not fail because LightRAG couldn't
+    // start. Common causes: binary missing (lightrag-server not on PATH),
+    // port already in use, working-dir not writable.
+    warn('startup hook: caught error:', err?.message || err);
+    return { ok: false, started: false, error: err?.message || String(err) };
+  }
+}
+
 // ── Document insertion ────────────────────────────────────────────────────
 
 /**
@@ -784,6 +958,74 @@ export async function reindexVault(projectRoot, opts = {}) {
   };
 }
 
+/**
+ * v5.x — Re-index a single note into LightRAG.
+ *
+ * Use this for incremental updates (e.g. after a note is written or
+ * updated via the REST API). Unlike `reindexVault` which walks the entire
+ * vault, this only inserts one document.
+ *
+ * Returns { ok, inserted, failed, error? }.
+ */
+export async function reindexSingleNote(projectRoot, relPath, opts = {}) {
+  const config = resolveLightRAGConfig(projectRoot);
+  if (!config.enabled) {
+    return { ok: false, error: 'lightrag disabled' };
+  }
+
+  // Resolve vault path (same logic as reindexVault).
+  const memPath = join(projectRoot, '.bizar', 'memory.json');
+  if (!existsSync(memPath)) {
+    return { ok: false, error: 'memory not initialized' };
+  }
+  const mem = JSON.parse(readFileSync(memPath, 'utf8'));
+  const mode = mem.memoryRepo?.mode || 'local-only';
+  let vaultRoot;
+  const projectId = mem.projectId || basename(projectRoot);
+  if (mode === 'local-only') {
+    vaultRoot = join(projectRoot, '.obsidian');
+  } else {
+    const rawPath = mem.memoryRepo?.path || '';
+    let expanded;
+    if (!rawPath) {
+      expanded = join(projectRoot, '.bizar', 'memory');
+    } else if (rawPath.startsWith('~')) {
+      expanded = join(homedir(), rawPath.slice(1));
+    } else if (rawPath.startsWith('/')) {
+      expanded = rawPath;
+    } else {
+      expanded = join(projectRoot, rawPath);
+    }
+    vaultRoot = join(expanded, 'projects', projectId);
+  }
+
+  const fullPath = join(vaultRoot, relPath);
+  if (!fullPath.startsWith(vaultRoot)) {
+    return { ok: false, error: 'path traversal attempt blocked' };
+  }
+  if (!existsSync(fullPath)) {
+    return { ok: false, error: `note not found: ${relPath}` };
+  }
+
+  // Ensure server is running (uses the same LLM-detection logic as reindexVault).
+  const runResult = await ensureRunning(config, opts);
+  if (!runResult.ok) {
+    return { ok: false, error: runResult.error || 'lightrag server unavailable' };
+  }
+
+  const raw = readFileSync(fullPath, 'utf8');
+  const { frontmatter, body } = parseFrontmatter(raw);
+  const note = { relPath, frontmatter, body };
+  const r = await insertNote(config, projectId, note);
+
+  return {
+    ok: r.ok,
+    inserted: r.ok ? 1 : 0,
+    failed: r.ok ? 0 : 1,
+    error: r.error,
+  };
+}
+
 /**
  * Query LightRAG. Returns { ok, mode, response, error? }.
  *

package/bizar-dash/src/server/memory-store.mjs

@@ -4,11 +4,17 @@
  * MarkdownMemoryStore — reads/writes Obsidian-compatible `.md` notes with YAML
  * frontmatter for the Bizar Memory Service. Supports three modes:
  *   local-only  — vault at <projectRoot>/.obsidian/
- *   managed    — vault at ~/.local/share/bizar/memory/<repoName>/projects/<projectId>/
+ *   managed    — vault at ~/.bizar_memory/<repoName>/projects/<projectId>/
  *   linked     — alias for managed
  *
  * The project namespace directory is created LAZY on first writeNote, not at
  * initVault time (F7 invariant).
+ *
+ * v5.x — Default vault root relocated from `~/.local/share/bizar/memory` to
+ * `~/.bizar_memory` per issue #5. The old path still works if `BIZAR_MEMORY_VAULT`
+ * is set; on first run, `ensureVaultExists()` emits a one-time notice when the
+ * old path exists and the new one doesn't, but does NOT auto-migrate (too
+ * risky to move user data without consent).
  */
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, lstatSync, unlinkSync } from 'node:fs';
@@ -27,15 +33,26 @@ const HOME = homedir();
 /**
  * Default vault root — auto-created on first use.
  * Override with BIZAR_MEMORY_VAULT env var.
+ *
+ * v5.x — moved from `~/.local/share/bizar/memory` to `~/.bizar_memory` so the
+ * vault lives at a memorable, top-level location in the user's home.
  */
-export const DEFAULT_MEMORY_VAULT = join(HOME, '.local', 'share', 'bizar', 'memory');
+export const DEFAULT_MEMORY_VAULT = join(HOME, '.bizar_memory');
+
+/**
+ * v5.x — Legacy vault path kept for migration detection only. The old
+ * `~/.local/share/bizar/memory` location is no longer the default; if a
+ * user still has notes there, `ensureVaultExists()` logs a one-time
+ * notice pointing them at the migration command.
+ */
+export const LEGACY_MEMORY_VAULT = join(HOME, '.local', 'share', 'bizar', 'memory');
 
 /**
  * Default git remote — set via BIZAR_MEMORY_GIT_REMOTE to enable sync.
  */
 export const DEFAULT_GIT_REMOTE = process.env.BIZAR_MEMORY_GIT_REMOTE || null;
 
-const BIZAR_MEMORY_ROOT = join(HOME, '.local', 'share', 'bizar', 'memory');
+const BIZAR_MEMORY_ROOT = join(HOME, '.bizar_memory');
 
 /**
  * Return the effective vault root for the default memory vault.
@@ -51,11 +68,34 @@ export function currentVault() {
  * Ensure the default memory vault directory exists and is git-initialised.
  * Idempotent — calling multiple times is safe.
  *
+ * v5.x — On first call with a fresh default vault, if the legacy
+ * `~/.local/share/bizar/memory` path exists and the new
+ * `~/.bizar_memory` doesn't, log a one-time migration notice. We do
+ * NOT auto-migrate: the user owns the data and may have already moved
+ * it, or may want to keep the old path via `BIZAR_MEMORY_VAULT`.
+ *
  * @returns {string} the vault path that was ensured
  */
 export function ensureVaultExists() {
   const vault = currentVault();
   if (!existsSync(vault)) {
+    // v5.x — Migration notice: legacy path exists, new default does not.
+    // Only emit when the user is using the default (no env override) and
+    // the new path doesn't exist yet.
+    if (
+      !process.env.BIZAR_MEMORY_VAULT &&
+      vault === DEFAULT_MEMORY_VAULT &&
+      existsSync(LEGACY_MEMORY_VAULT)
+    ) {
+      console.warn(
+        `[memory-store] Detected a legacy memory vault at ${LEGACY_MEMORY_VAULT}.\n` +
+          `[memory-store] The default location has moved to ${DEFAULT_MEMORY_VAULT}.\n` +
+          `[memory-store] To keep using the old vault, set BIZAR_MEMORY_VAULT=${LEGACY_MEMORY_VAULT}.\n` +
+          `[memory-store] To migrate, move the contents manually: ` +
+          `mv ${LEGACY_MEMORY_VAULT}/* ${DEFAULT_MEMORY_VAULT}/\n` +
+          `[memory-store] (not auto-migrated — please review before moving user data).`,
+      );
+    }
     mkdirSync(vault, { recursive: true, mode: 0o700 });
     if (!existsSync(join(vault, '.git'))) {
       try {

package/bizar-dash/src/server/routes/background.mjs

@@ -2,10 +2,15 @@
  * src/server/routes/background.mjs
  *
  * /api/background                          — list
+ * /api/background (POST)                   — spawn from UI (v5.x)
  * /api/background/:id                      — single instance
  * /api/background/:id/output               — tail captured output
+ * /api/background/:id/tool-calls (GET)     — tool call history (v5.x)
  * /api/background/:id/tmux                 — tmux attach metadata
  * /api/background/:id/message (POST)       — send a follow-up message
+ * /api/background/:id/pause (POST)         — pause subprocess (v5.x)
+ * /api/background/:id/resume (POST)        — resume subprocess (v5.x)
+ * /api/background/:id/steer (POST)         — kill+respawn with new prompt (v5.x)
  * /api/background/:id/retry (POST)         — manual unstick (v3.11.0)
  * /api/background/:id (DELETE)             — kill
  *
@@ -23,12 +28,68 @@ import { wrap } from './_shared.mjs';
 export function createBackgroundRouter({ broadcast }) {
   const router = Router();
 
+  // Wire bg-spawner's broadcast so spawned agents broadcast on the
+  // existing WS bus (mirroring the way `bg-poller.mjs` does it).
+  import('../bg-spawner.mjs').then((m) => {
+    if (m && typeof m.configureSpawner === 'function') {
+      m.configureSpawner({ broadcast });
+    }
+  }).catch(() => { /* ignore — spawner optional */ });
+
   router.get('/background', wrap(async (_req, res) => {
     const { backgroundStore } = await import('../background-store.mjs');
     const instances = await backgroundStore.list();
     res.json({ instances, status: backgroundStore.status() });
   }));
 
+  // v5.x — Spawn from UI. Body: { agent, prompt, model?, persistent?, maxRestarts?, tags?, timeoutMs?, worktree? }
+  router.post('/background', wrap(async (req, res) => {
+    const body = req.body || {};
+    const agent = String(body.agent || '').trim();
+    const prompt = String(body.prompt || '').trim();
+    const worktree = body.worktree ? String(body.worktree) : process.cwd();
+    if (!agent || !prompt) {
+      res.status(400).json({ error: 'bad_request', message: 'agent and prompt are required' });
+      return;
+    }
+    let model;
+    if (body.model && typeof body.model === 'string') {
+      const idx = body.model.indexOf('/');
+      if (idx > 0) {
+        model = {
+          providerID: body.model.slice(0, idx).trim(),
+          modelID: body.model.slice(idx + 1).trim(),
+        };
+      }
+    }
+    const tags = Array.isArray(body.tags)
+      ? body.tags.filter((t) => typeof t === 'string').slice(0, 10)
+      : undefined;
+    const { spawnBgAgent } = await import('../bg-spawner.mjs');
+    const result = await spawnBgAgent({
+      agent,
+      prompt,
+      worktree,
+      model,
+      timeoutMs: Number(body.timeoutMs) || 300_000,
+      persistent: Boolean(body.persistent),
+      maxRestarts: Number(body.maxRestarts) || 3,
+      tags,
+    });
+    if (result.error) {
+      res.status(500).json({ error: 'spawn_failed', message: result.error, instanceId: result.instanceId });
+      return;
+    }
+    res.status(201).json({
+      instanceId: result.instanceId,
+      sessionId: result.sessionId ?? null,
+      processId: result.processId ?? null,
+      status: 'pending',
+      agent,
+      worktree,
+    });
+  }));
+
   router.get('/background/:id', wrap(async (req, res) => {
     const { backgroundStore } = await import('../background-store.mjs');
     const inst = backgroundStore.get(req.params.id);
@@ -46,6 +107,73 @@ export function createBackgroundRouter({ broadcast }) {
     res.json(result);
   }));
 
+  // v5.x — Tool-call history. The state file carries a `toolCalls`
+  // array populated by the plugin's InstanceManager as it observes
+  // opencode events. This endpoint is read-only; the plugin owns the
+  // shape.
+  router.get('/background/:id/tool-calls', wrap(async (req, res) => {
+    const { backgroundStore } = await import('../background-store.mjs');
+    const inst = backgroundStore.get(req.params.id);
+    if (!inst) {
+      res.status(404).json({ error: 'not_found' });
+      return;
+    }
+    const calls = Array.isArray(inst.toolCalls) ? inst.toolCalls : [];
+    res.json({ instanceId: req.params.id, toolCalls: calls, count: calls.length });
+  }));
+
+  // v5.x — Pause. SIGSTOP the subprocess.
+  router.post('/background/:id/pause', wrap(async (req, res) => {
+    const { pauseBgAgent } = await import('../bg-spawner.mjs');
+    const result = pauseBgAgent(req.params.id);
+    if (!result.ok) {
+      res.status(result.error === 'unsupported_on_win32' ? 501 : 400).json({ ok: false, error: result.error });
+      return;
+    }
+    broadcast({ type: 'background:change', id: req.params.id, status: 'paused' });
+    res.json({ ok: true, status: 'paused' });
+  }));
+
+  // v5.x — Resume. SIGCONT the subprocess.
+  router.post('/background/:id/resume', wrap(async (req, res) => {
+    const { resumeBgAgent } = await import('../bg-spawner.mjs');
+    const result = resumeBgAgent(req.params.id);
+    if (!result.ok) {
+      res.status(result.error === 'unsupported_on_win32' ? 501 : 400).json({ ok: false, error: result.error });
+      return;
+    }
+    broadcast({ type: 'background:change', id: req.params.id, status: 'running' });
+    res.json({ ok: true, status: 'running' });
+  }));
+
+  // v5.x — Steer (kill+restart with appended prompt). Body: { message }.
+  router.post('/background/:id/steer', wrap(async (req, res) => {
+    const message = String((req.body && req.body.message) || '').trim();
+    if (!message) {
+      res.status(400).json({ ok: false, error: 'message_empty' });
+      return;
+    }
+    const { steerBgAgent } = await import('../bg-spawner.mjs');
+    const result = await steerBgAgent(req.params.id, message);
+    if (!result.ok) {
+      res.status(400).json({ ok: false, error: result.error });
+      return;
+    }
+    broadcast({
+      type: 'background:change',
+      id: req.params.id,
+      status: 'steered',
+      newInstanceId: result.newInstanceId,
+    });
+    broadcast({
+      type: 'background:change',
+      id: result.newInstanceId,
+      status: 'pending',
+      parentInstanceId: req.params.id,
+    });
+    res.json({ ok: true, status: 'steered', newInstanceId: result.newInstanceId, processId: result.processId });
+  }));
+
   // v3.5.5 — Tmux session metadata. The UI uses this to render an
   // "Attach" button next to a running bg instance. Returns the
   // computed session name, the local attach command, and whether
@@ -126,6 +254,21 @@ export function createBackgroundRouter({ broadcast }) {
   }));
 
   router.delete('/background/:id', wrap(async (req, res) => {
+    // v5.x — Prefer the dashboard-side spawner's kill for instances
+    // that we own (spawned via POST /background). Falls back to the
+    // plugin's tmux/abort path for instances spawned by the plugin.
+    try {
+      const { isAlive: spawnerAlive, killBgAgent } = await import('../bg-spawner.mjs');
+      if (spawnerAlive(req.params.id)) {
+        const r = await killBgAgent(req.params.id, { signal: 'SIGTERM' });
+        if (r.ok) {
+          broadcast({ type: 'background:change', action: 'kill', id: req.params.id, source: 'dashboard' });
+          res.json({ ok: true, instanceId: req.params.id, source: 'dashboard' });
+          return;
+        }
+      }
+    } catch { /* ignore — fall through to legacy */ }
+
     const { backgroundStore } = await import('../background-store.mjs');
     // v3.5.4 (bug #3) — `kill()` is now async (it awaits the abortSession
     // HTTP call to opencode serve, then deletes the state file, then

package/bizar-dash/src/server/routes/lightrag.mjs

@@ -155,5 +155,15 @@ export function createLightragRouter({ projectRoot }) {
     });
   }));
 
+  // POST /api/lightrag/autostart — v5.x — issue #6.
+  // Runs lightragStartupHook() against the dashboard's projectRoot.
+  // Used by `bizar lightrag autostart` (CLI) and by `install.sh` to
+  // ensure the LightRAG server is up after install/update.
+  router.post('/lightrag/autostart', wrap(async (_req, res) => {
+    const { lightragStartupHook } = await import('../memory-lightrag.mjs');
+    const r = await lightragStartupHook(projectRoot);
+    res.status(r.ok ? 200 : 503).json(r);
+  }));
+
   return router;
 }

package/bizar-dash/src/server/routes/memory.mjs

@@ -198,6 +198,10 @@ export function createMemoryRouter({ projectRoot }) {
     try {
       const note = writeNote(projectRoot, relPath, { frontmatter: frontmatter || {}, body: body || '' });
       res.status(201).json(note);
+      // v5.x — auto-reindex the written note in the background (fire-and-forget).
+      getMemoryLightrag().then((m) => {
+        void m.reindexSingleNote(projectRoot, relPath).catch(() => {});
+      });
     } catch (err) {
       if (err.code === 'SCHEMA_VALIDATION_FAILED' || err.code === 'SECRET_DETECTED') {
         res.status(400).json({ error: err.code, message: err.message, findings: err.findings });
@@ -1276,6 +1280,10 @@ export function createMemoryRouter({ projectRoot }) {
     try {
       const note = writeNote(projectRoot, relPath, { frontmatter: frontmatter || {}, body: body || '' });
       res.json(note);
+      // v5.x — auto-reindex the updated note in the background (fire-and-forget).
+      getMemoryLightrag().then((m) => {
+        void m.reindexSingleNote(projectRoot, relPath).catch(() => {});
+      });
     } catch (err) {
       if (err.code === 'SCHEMA_VALIDATION_FAILED' || err.code === 'SECRET_DETECTED') {
         res.status(400).json({ error: err.code, message: err.message, findings: err.findings });

package/bizar-dash/src/server/server.mjs

@@ -473,6 +473,28 @@ export async function createServer({
     console.warn('[bizar-dash] headroom startup hook skipped:', err?.message || err);
   }
 
+  // v5.x — LightRAG startup hook (issue #6). Mirrors the headroom hook:
+  // reads config from .bizar/memory.json + env vars, then calls
+  // lightragStartupHook() which respects `lightrag.enabled` and the
+  // BIZAR_LIGHTRAG_AUTOSTART env override. All errors are caught — the
+  // dashboard must boot even when LightRAG can't start.
+  try {
+    const { lightragStartupHook } = await import('./memory-lightrag.mjs');
+    lightragStartupHook(projectRoot).then((r) => {
+      if (!r.ok) {
+        console.warn('[bizar-dash] lightragStartupHook:', r.error || r.reason || 'not started');
+      } else if (r.started) {
+        console.log(`[bizar-dash] lightrag auto-started (pid=${r.pid})`);
+      } else {
+        console.log(`[bizar-dash] lightrag: ${r.reason || 'not started'}`);
+      }
+    }).catch((err) => {
+      console.warn('[bizar-dash] lightragStartupHook error:', err?.message || err);
+    });
+  } catch (err) {
+    console.warn('[bizar-dash] lightrag startup hook skipped:', err?.message || err);
+  }
+
   // v5.2 — Background transcription worker for voice notes. Uploads
   // save audio immediately and enqueue the noteId here; the worker
   // drains the queue, calls Whisper (or BIZAR_WHISPER_ENDPOINT), and

package/bizar-dash/src/web/App.tsx

@@ -30,6 +30,7 @@ import { Tasks } from './views/Tasks';
 import { Activity } from './views/Activity';
 import { Config } from './views/Config';
 import { SettingsView } from './views/Settings';
+import { Marketplace } from './views/Marketplace';
 import { Mods } from './views/Mods';
 import { Plugins } from './views/Plugins';
 import { ModView, type ModView as ModViewType } from './views/ModView';
@@ -47,6 +48,7 @@ import { Spinner } from './components/Spinner';
 import { Button } from './components/Button';
 import { AlertTriangle, Globe, LayoutTemplate, X } from 'lucide-react';
 import './styles/main.css';
+import './styles/settings.css';
 
 type ViewProps = {
   snapshot: Snapshot;
@@ -90,6 +92,7 @@ const VIEW_MAP: Record<string, (p: ViewProps) => React.ReactNode> = {
   background: BackgroundAgents,
   config: Config,
   settings: SettingsView,
+  marketplace: Marketplace,
   mods: Mods,
   schedules: Schedules,
   skills: Skills,

package/bizar-dash/src/web/MobileApp.tsx

@@ -13,7 +13,6 @@ import type { Notification, Settings, Snapshot, WsMessage } from './lib/types';
 import { applyTheme, applyThemeTokens } from './lib/types';
 import { Ws } from './lib/ws';
 import { MobileBottomNav, type MobileTab } from './mobile/MobileBottomNav';
-import { MobileTopbar } from './mobile/MobileTopbar';
 import { MobileLayout, type DrawerTab } from './components/MobileLayout';
 import { MobileActivity } from './mobile/views/MobileActivity';
 import { MobileAgents } from './mobile/views/MobileAgents';
@@ -401,20 +400,12 @@ export function MobileApp() {
         onExitSettings={() => goToTab('activity')}
         onSearch={() => setSearchOpen(true)}
       >
-        <MobileTopbar
-          activeTab={currentView.id}
-          snapshot={snapshot}
-          onSearch={() => setSearchOpen(true)}
-          onNavigate={handleNavigate}
-        />
-
-        <main className="mobile-content">{renderView()}</main>
-
         {stack.length > 0 && (
           <button type="button" className="mobile-back-btn" onClick={popView} aria-label="Go back">
             ← Back
           </button>
         )}
+        {renderView()}
       </MobileLayout>
 
       <MobileSearchModal open={searchOpen} onClose={() => setSearchOpen(false)} onNavigate={handleNavigate} />

package/bizar-dash/src/web/components/InstallConfirmDialog.tsx

@@ -27,7 +27,7 @@ export function InstallConfirmDialog({ plugin, onConfirm, onCancel, installing }
 
     modal.open({
       title: `Install ${plugin.name}?`,
-      width: 480,
+      width: 560,
       onClose: () => {
         openedForRef.current = null;
         onCancel();