total-recall-brain 3.45.0 → 3.46.1

package/src/core/workspace-compositions.mjs

@@ -0,0 +1,151 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { executePluginState, listPluginStates, PluginStateStore } from './plugin-state-store.mjs';
+import { getUiChunk, UiChunkInputError } from './ui-chunks.mjs';
+import { getPluginById } from './plugin-loader.mjs';
+import { pluginActivation } from './plugin-state.mjs';
+
+const OWNER = 'workspace-ui';
+const SAVED_PAGES = 'workspace-pages';
+const ID = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+const VERSION = /^[a-f0-9]{64}$/;
+const MAX_PAGE_BLOCKS = 24;
+
+function stateFile(brainDir, plugin) {
+  if (typeof plugin !== 'string' || plugin.length > 64 || !ID.test(plugin)) throw new UiChunkInputError('Invalid plugin ID.');
+  return path.join(brainDir, 'config', 'workspace-compositions', plugin + '.json');
+}
+
+function readCompositionState(brainDir, plugin, projectRoot) {
+  const store = new PluginStateStore(stateFile(brainDir, plugin), OWNER);
+  const owner = getPluginById(plugin, projectRoot);
+  if (!owner?.valid || !pluginActivation(owner, { projectRoot }).enabled) {
+    throw new UiChunkInputError('The destination plugin must be installed and enabled.');
+  }
+  const state = store.read({ keys: [] });
+  return { keys: state.keys, version: store.version };
+}
+
+function readPageBlocks(brainDir, keys, projectRoot) {
+  return keys.flatMap(key => {
+    const chunk = readPageBlock(brainDir, key, projectRoot);
+    if (!chunk) return [];
+    const { html: _html, ...metadata } = chunk;
+    return [metadata];
+  });
+}
+
+export function readWorkspaceComposition(brainDir, plugin, projectRoot = process.cwd()) {
+  const { keys, version } = readCompositionState(brainDir, plugin, projectRoot);
+  return { chunks: readPageBlocks(brainDir, keys, projectRoot), version };
+}
+
+function readPageBlock(brainDir, key, projectRoot) {
+  if (typeof key !== 'string') return null;
+  const [owner, id, ...rest] = key.split(':');
+  return ID.test(owner) && typeof id === 'string' && ID.test(id) && !rest.length
+    ? getUiChunk(owner, id, { surface: 'page', brainDir, projectRoot }) : null;
+}
+
+export async function publishWorkspaceComposition(brainDir, plugin, keys, version, projectRoot = process.cwd()) {
+  const file = stateFile(brainDir, plugin);
+  const owner = getPluginById(plugin, projectRoot);
+  if (!owner?.valid || !pluginActivation(owner, { projectRoot }).enabled ||
+      !keys.length || keys.length > 3 || keys.some(key => !readPageBlock(brainDir, key, projectRoot))) {
+    throw new UiChunkInputError('The selected page blocks changed. Compose the view again.');
+  }
+  return executePluginState({ file, plugin: OWNER, action: 'write', value: { keys }, expectedVersion: version });
+}
+
+function pageDirectory(brainDir) {
+  const config = path.join(brainDir, 'config');
+  const directory = path.join(config, SAVED_PAGES);
+  for (const candidate of [config, directory]) {
+    const stat = fs.lstatSync(candidate, { throwIfNoEntry: false });
+    if (stat && !stat.isDirectory()) throw new Error('Unsafe saved page directory');
+  }
+  return directory;
+}
+
+function savedPageFile(brainDir, id) {
+  if (typeof id !== 'string' || id.length > 64 || !ID.test(id)) throw new UiChunkInputError('Invalid saved page ID.');
+  return path.join(pageDirectory(brainDir), id + '.json');
+}
+
+function pageConflict(message) {
+  return Object.assign(new Error(message), { status: 409 });
+}
+
+export function listWorkspacePages(brainDir) {
+  return listPluginStates(pageDirectory(brainDir), SAVED_PAGES)
+    .map(({ value: { id, title }, version }) => ({ id, title, version }))
+    .sort((a, b) => a.title.localeCompare(b.title) || a.id.localeCompare(b.id));
+}
+
+export function readWorkspacePage(brainDir, id, projectRoot = process.cwd()) {
+  const store = new PluginStateStore(savedPageFile(brainDir, id), SAVED_PAGES);
+  const page = store.read(null);
+  if (!page) return null;
+  return { id, title: page.title, version: store.version, chunks: readPageBlocks(brainDir, page.keys, projectRoot) };
+}
+
+export function prepareWorkspacePage(brainDir, id, title) {
+  const file = savedPageFile(brainDir, id);
+  const name = typeof title === 'string' ? title.trim() : '';
+  if (!name || name.length > 120 || /[\u0000-\u001f\u007f-\u009f]/u.test(title)) {
+    throw new UiChunkInputError('Enter a saved page title of up to 120 characters.');
+  }
+  const store = new PluginStateStore(file, SAVED_PAGES);
+  if (store.read(null)) throw pageConflict('That saved page ID already exists.');
+  return { title: name, file };
+}
+
+function verifyPageBlocks(brainDir, keys, projectRoot) {
+  if (!Array.isArray(keys) || !keys.length || keys.length > MAX_PAGE_BLOCKS || new Set(keys).size !== keys.length) {
+    throw new UiChunkInputError(`Choose one to ${MAX_PAGE_BLOCKS} distinct page blocks.`);
+  }
+  const chunks = readPageBlocks(brainDir, keys, projectRoot);
+  if (chunks.length !== keys.length) throw pageConflict('The selected page blocks are no longer available.');
+  return chunks;
+}
+
+export async function createWorkspacePage(brainDir, { id, title, keys }, projectRoot = process.cwd()) {
+  const page = prepareWorkspacePage(brainDir, id, title);
+  const chunks = verifyPageBlocks(brainDir, keys, projectRoot);
+  try {
+    const { version } = await executePluginState({
+      file: page.file, plugin: SAVED_PAGES, action: 'write',
+      value: { id, title: page.title, keys }, expectedVersion: null,
+    });
+    return { id, title: page.title, version, chunks };
+  } catch (error) {
+    if (error.message.startsWith('Plugin state version conflict')) throw pageConflict('That saved page ID already exists.');
+    throw error;
+  }
+}
+
+export async function updateWorkspacePage(brainDir, { id, keys, revision }, projectRoot = process.cwd()) {
+  if (typeof revision !== 'string' || !VERSION.test(revision)) {
+    throw new UiChunkInputError('Supply the current saved page revision.');
+  }
+  const file = savedPageFile(brainDir, id);
+  const store = new PluginStateStore(file, SAVED_PAGES);
+  const page = store.read(null);
+  if (!page) throw Object.assign(new Error('Saved page unavailable'), { status: 404 });
+  if (store.version !== revision) throw pageConflict('The saved page changed. Read its current revision before editing.');
+  const chunks = verifyPageBlocks(brainDir, keys, projectRoot);
+  const { version } = await executePluginState({
+    file, plugin: SAVED_PAGES, action: 'write',
+    value: { id, title: page.title, keys }, expectedVersion: revision,
+  });
+  return { id, title: page.title, version, chunks };
+}
+
+export async function saveWorkspaceCompositionPage(brainDir, { id, title, sourcePlugin, sourceVersion }, projectRoot = process.cwd()) {
+  if (typeof sourceVersion !== 'string' || !VERSION.test(sourceVersion)) {
+    throw new UiChunkInputError('Supply the published Home revision to save.');
+  }
+  const { keys, version } = readCompositionState(brainDir, sourcePlugin, projectRoot);
+  if (version !== sourceVersion) throw pageConflict('The plugin Home changed. Read its current revision before saving.');
+  return createWorkspacePage(brainDir, { id, title, keys }, projectRoot);
+}

package/src/core/workspace-drawers.mjs

@@ -0,0 +1,79 @@
+/** Private dashboard chrome settings, shared by the HTTP and CLI adapters. */
+import path from 'node:path';
+import { executePluginState, PluginStateStore } from './plugin-state-store.mjs';
+
+const OWNER = 'workspace-ui';
+const ID = /^[a-z][a-z0-9-]{0,63}$/;
+const EMPTY = { html: '', chunks: [], panels: [], shortcuts: [] };
+export const MAX_DRAWER_HTML_BYTES = 64 * 1024;
+
+export class DrawerInputError extends Error {}
+
+function stateFile(brainDir, edge) {
+  if (edge !== 'right' && edge !== 'bottom') throw new DrawerInputError('Choose the right or bottom drawer.');
+  return path.join(brainDir, 'config', `workspace-drawer-${edge}.json`);
+}
+
+function list(value, name, limit) {
+  if (!Array.isArray(value) || value.length > limit) throw new DrawerInputError(`${name} must contain at most ${limit} items.`);
+  return value;
+}
+
+function shortcutHref(value) {
+  if (typeof value !== 'string' || value.length > 1024 || /[\u0000-\u0020\u007f\\]/.test(value)) {
+    throw new DrawerInputError('Use a dashboard path or an HTTPS address for each shortcut.');
+  }
+  const base = 'https://workspace.invalid';
+  let url;
+  try { url = new URL(value, base); } catch { throw new DrawerInputError('Invalid shortcut address.'); }
+  if (value.startsWith('/') && !value.startsWith('//') && url.origin === base && !url.pathname.startsWith('//') &&
+      !/%(?:2f|5c)/i.test(url.pathname)) {
+    return url.pathname + url.search + url.hash;
+  }
+  if (value.startsWith('https://') && !url.username && !url.password) return url.href;
+  throw new DrawerInputError('Use a dashboard path or an HTTPS address for each shortcut.');
+}
+
+export function validateDrawerConfig(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value) || Object.keys(value).some(key => !Object.hasOwn(EMPTY, key))) {
+    throw new DrawerInputError('Invalid drawer configuration.');
+  }
+  const { html = '', chunks = [], panels = [], shortcuts = [] } = value;
+  if (typeof html !== 'string' || Buffer.byteLength(html, 'utf8') > MAX_DRAWER_HTML_BYTES) {
+    throw new DrawerInputError('Drawer HTML must be at most 64 KiB.');
+  }
+  const chunkIds = list(chunks, 'Chunks', 8).map(key => {
+    if (typeof key !== 'string' || key.split(':').length !== 2 || key.split(':').some(id => !ID.test(id))) {
+      throw new DrawerInputError('Each chunk needs a plugin ID and a chunk ID.');
+    }
+    return key;
+  });
+  const references = list(panels, 'Panels', 6).map(panel => {
+    if (typeof panel?.plugin !== 'string' || typeof panel?.element !== 'string' ||
+        !ID.test(panel.plugin) || !ID.test(panel.element)) throw new DrawerInputError('Invalid plugin panel reference.');
+    return { plugin: panel.plugin, element: panel.element };
+  });
+  const links = list(shortcuts, 'Shortcuts', 16).map(shortcut => {
+    const label = typeof shortcut?.label === 'string' ? shortcut.label.trim() : '';
+    if (!label || label.length > 80 || /[\u0000-\u001f\u007f]/.test(label)) throw new DrawerInputError('Give each shortcut a name of 1–80 characters.');
+    return { label, href: shortcutHref(shortcut.href) };
+  });
+  return { html, chunks: [...new Set(chunkIds)], panels: references, shortcuts: links };
+}
+
+export function readDrawerConfig(brainDir, edge) {
+  const store = new PluginStateStore(stateFile(brainDir, edge), OWNER);
+  const config = validateDrawerConfig(store.read(EMPTY));
+  return { config, version: store.version };
+}
+
+export async function writeDrawerConfig(brainDir, edge, config, version) {
+  if (version !== null && (typeof version !== 'string' || !/^[0-9a-f]{64}$/.test(version))) {
+    throw new DrawerInputError('Reload the drawer before saving.');
+  }
+  const value = validateDrawerConfig(config);
+  const result = await executePluginState({
+    file: stateFile(brainDir, edge), plugin: OWNER, action: 'write', value, expectedVersion: version,
+  });
+  return { config: value, version: result.version };
+}

package/src/server/api.mjs

@@ -15,10 +15,10 @@ import { runInSandbox } from '../core/sandbox.mjs';
 import { resolveAgentDir } from '../cli/agent-dir.mjs';
 import { removeSessionEmbeddingFromIndex } from '../core/embeddings.mjs';
 import path from 'path';
-import os from 'os';
 import fs from 'fs';
 import matter from '../core/frontmatter.mjs';
 import { agentDir, brainDir, surfaceDir, instructionsFilePath } from '../core/config.mjs';
+import { resolveVaultFromQuery } from './routes/_shared.mjs';
 
 const AGENT_DIR = process.env.AGENT_DIR || agentDir;
 const BRAIN_DIR = process.env.TR_BRAIN || path.join(AGENT_DIR, 'skills', 'total-recall');
@@ -43,32 +43,9 @@ const MODEL_CATALOG_DIR = path.join(ROOT, 'models', 'catalog', 'total-recall');
  * @returns {string} Absolute path to the memory-vault directory
  */
 function resolveVaultDir(brainId) {
-  if (!brainId || brainId === 'global') {
-    return VAULT_DIR;
-  }
-
-  if (brainId.startsWith('project:')) {
-    const projectName = brainId.slice('project:'.length);
-    const globalBrainDir = path.join(os.homedir(), '.agent', 'skills', 'total-recall');
-    const registryPath = path.join(globalBrainDir, 'config', 'project-registry.json');
-
-    if (fs.existsSync(registryPath)) {
-      try {
-        const registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
-        const project = registry.find(p => p.name === projectName);
-        if (project) {
-          const projectVaultDir = path.join(project.brainDir, 'memory-vault');
-          if (fs.existsSync(projectVaultDir)) {
-            return projectVaultDir;
-          }
-        }
-      } catch {
-        // Registry parse error — fall through to default
-      }
-    }
-  }
-
-  return VAULT_DIR;
+  return typeof brainId === 'string' && (brainId === 'global' || brainId.startsWith('project:'))
+    ? resolveVaultFromQuery({ query: { brain: brainId } })
+    : VAULT_DIR;
 }
 
 function sha256(content) {

package/src/server/index.mjs

@@ -352,6 +352,8 @@ app.get('/health', requireAuthOrLocal, async (req, res) => {
     cloudflare: cloudflareStatus,
     emergency_alerts: emergencyAlerts || null,
     fetch_gate,
+    // Whether the served dashboard is as new as this checkout's frontend sources.
+    dashboard: dashboardBundle.state(),
     vfs: {
       exists: vaultExists,
       skill_exists: skillExists,
@@ -444,24 +446,30 @@ try {
 
 const frontendDist = path.join(ROOT, 'frontend', 'dist');
 
-// Auto-build frontend if dist/ doesn't exist
-if (!fs.existsSync(path.join(frontendDist, 'index.html'))) {
-  const frontendDir = path.join(ROOT, 'frontend');
-  if (fs.existsSync(path.join(frontendDir, 'package.json'))) {
-    logger.info('server', 'Frontend not built. Building automatically...');
-    try {
-      const { execSync } = await import('node:child_process');
-      execSync('npm install --no-audit --no-fund 2>/dev/null && npm run build', {
-        cwd: frontendDir,
-        stdio: 'pipe',
-        timeout: 120_000,
-      });
-      logger.info('server', 'Frontend build complete.');
-    } catch (err) {
-      logger.warn('server', `Frontend auto-build failed: ${err.message?.split('\\n')[0] || 'unknown error'}. Dashboard will show API info instead.`);
+// Live refresh for the memory page on this port (the /stream monitor listens on 127.0.0.1 only).
+const { memoryEventsHandler } = await import('./memory-events.mjs');
+app.get('/api/memory-events', requireAuth, memoryEventsHandler(logEvents));
+
+// Keep the served dashboard as new as its sources. A missing or stale bundle is
+// rebuilt in the background while the current one keeps serving; express.static
+// resolves files per request, so the swapped-in build serves without a restart.
+// Building only when index.html was missing left every later frontend commit unserved.
+const { watchDashboardBundle } = await import('../core/dashboard-bundle.mjs');
+const dashboardBundle = watchDashboardBundle({
+  root: ROOT,
+  report: (state) => {
+    if (state.status === 'current' && state.rebuilt) {
+      logger.info('server', `Dashboard bundle rebuilt from newer sources (${Math.round(state.durationMs / 1000)} s); serving it now.`);
+    } else if (state.status === 'current') {
+      logger.info('server', 'Dashboard bundle is current.');
+    } else if (state.retryInMs) {
+      logger.info('server', `Dashboard bundle is ${state.status}; rebuilding once the sources stop changing.`);
+    } else {
+      logger.error('server', `Dashboard bundle is ${state.status} and was not rebuilt: ${state.reason}.${state.build?.output ? ` Build output: ${state.build.output.slice(-1500)}` : ''}`);
     }
-  }
-}
+  },
+});
+dashboardBundle.check();
 
 app.use(express.static(frontendDist));
 
@@ -803,8 +811,7 @@ app.get('/chat', (req, res) => {
 
 // SPA fallback — serve index.html for all unmatched routes
 app.get(/^(.*)$/, (req, res) => {
-  const indexPath = path.join(frontendDist, 'index.html');
-  res.sendFile(indexPath, (err) => {
+  res.sendFile('index.html', { root: frontendDist }, (err) => {
     if (err) {
       // Frontend not built yet — return a helpful message
       res.status(200).json({
@@ -814,7 +821,7 @@ app.get(/^(.*)$/, (req, res) => {
           memory: 'GET /api/memory',
           sandbox: 'POST /api/sandbox',
           health: 'GET /health',
-          dashboard: 'Build frontend first: cd frontend && npm run build'
+          dashboard: `Dashboard bundle is ${dashboardBundle.state().status}${dashboardBundle.state().reason ? `: ${dashboardBundle.state().reason}` : ''}. The server rebuilds it from frontend/ in the background.`
         }
       });
     }
@@ -874,7 +881,7 @@ const server = app.listen(PORT, HOST, () => {
 
   // Only meaningful once the socket is up: asking before the callback fires
   // reads an empty set, which is "unknown", so the watch never armed.
-  if (isReachableFromOtherDevices() === false) {
+  if (bindResolution.usedLoopbackFallback && isReachableFromOtherDevices() === false) {
     logger.warn(
       'server',
       `Bound to loopback only — no other device can reach this brain at :${PORT}. `

package/src/server/memory-events.mjs

@@ -0,0 +1,31 @@
+/**
+ * Live refresh for the memory page, on the dashboard's own port.
+ *
+ * The page listened to `/stream` on the dashboard origin, but the server
+ * serves `/stream` only on the 127.0.0.1 monitor port, so the dashboard got
+ * its HTML fallback and the live refresh never connected. This stream is
+ * authenticated like the rest of the dashboard API and carries only the
+ * subsystem name of the events that change what the page shows, never log
+ * contents.
+ */
+export const MEMORY_EVENT_SUBSYSTEMS = new Set(['conflict-detector', 'rebuild', 'session-watcher']);
+const HEARTBEAT_MS = 25000;
+
+/** @param {import('node:events').EventEmitter} events Emits 'log' entries ({ subsystem, ... }). */
+export function memoryEventsHandler(events, { heartbeatMs = HEARTBEAT_MS } = {}) {
+  return (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', Connection: 'keep-alive' });
+    res.write(': connected\n\n');
+    const onLog = (entry) => {
+      if (MEMORY_EVENT_SUBSYSTEMS.has(entry?.subsystem)) res.write(`data: ${JSON.stringify({ subsystem: entry.subsystem })}\n\n`);
+    };
+    events.on('log', onLog);
+    // Comment lines keep proxies from closing an idle stream.
+    const heartbeat = setInterval(() => res.write(': ping\n\n'), heartbeatMs);
+    heartbeat.unref?.();
+    req.on('close', () => {
+      events.off('log', onLog);
+      clearInterval(heartbeat);
+    });
+  };
+}

package/src/server/plugin-brain-targets.mjs

@@ -0,0 +1,89 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { dashboardBrainDir, globalBrainDirFor, readBrainToggles, readRegisteredProjects } from '../core/brain-registry.mjs';
+import { projectPluginsDir } from '../core/plugin-loader.mjs';
+import { readProjectId } from '../core/project-id.mjs';
+import { keyHasScope } from './keys.mjs';
+
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+const PROJECT_SELECTOR = /^project:[^/\\:,\x00-\x1f\x7f]{1,160}$/u;
+
+const targetError = (status, message) => Object.assign(new Error(message), { status });
+
+function optionalDirectoriesAreLocal(brainDir) {
+  for (const name of ['plugins', 'memory-vault', 'memory-derived']) {
+    try {
+      if (!fs.lstatSync(path.join(brainDir, name)).isDirectory()) return false;
+    } catch (error) {
+      if (error.code !== 'ENOENT') return false;
+    }
+  }
+  return true;
+}
+
+function resolveProject(row, sharedBrain, toggles) {
+  try {
+    if (typeof row.path !== 'string' || !path.isAbsolute(row.path) ||
+        typeof row.brainDir !== 'string' || !path.isAbsolute(row.brainDir)) return null;
+    const projectRoot = fs.realpathSync(row.path);
+    const brainDir = path.dirname(projectPluginsDir(projectRoot));
+    const identity = path.join(brainDir, 'config', 'brain.json');
+    if (brainDir === sharedBrain || fs.realpathSync(row.brainDir) !== brainDir ||
+        fs.realpathSync(brainDir) !== brainDir || fs.realpathSync(identity) !== identity ||
+        !fs.lstatSync(identity).isFile() || readProjectId(brainDir) !== row.project_id ||
+        toggles[path.resolve(row.brainDir)] === false || toggles[brainDir] === false ||
+        !optionalDirectoriesAreLocal(brainDir)) return null;
+    return { brainDir, projectRoot };
+  } catch {
+    return null;
+  }
+}
+
+function authorize(auth, scope) {
+  if (auth?.type === 'dashboard_session') return;
+  if (auth?.type !== 'pat' || !keyHasScope(auth, scope)) {
+    throw targetError(403, 'The token does not grant access to a selected brain.');
+  }
+}
+
+/** Resolve selected IDs against server-owned registrations before plugin I/O. */
+export function resolvePluginBrainTargets(ids, auth, { registryBrain = globalBrainDirFor() } = {}) {
+  if (!Array.isArray(ids) || !ids.length || ids.length > 64 ||
+      ids.some(id => typeof id !== 'string' || (id !== 'global' && !PROJECT_SELECTOR.test(id)))) {
+    throw targetError(400, 'Select up to 64 global or registered project brain IDs.');
+  }
+  let sharedBrain, rows, toggles, globalToggles;
+  try {
+    const projectRegistryBrain = dashboardBrainDir(process.env, registryBrain);
+    sharedBrain = fs.realpathSync(registryBrain);
+    globalToggles = ids.includes('global') ? readBrainToggles(registryBrain, { strict: true }) : {};
+    const needsProjects = ids.some(id => id !== 'global');
+    toggles = needsProjects ? readBrainToggles(projectRegistryBrain, { strict: true }) : {};
+    rows = needsProjects ? readRegisteredProjects(projectRegistryBrain) : [];
+  } catch {
+    throw targetError(503, 'Brain registry metadata is unavailable.');
+  }
+  const resolved = new Set();
+  return [...new Set(ids)].map(brainId => {
+    if (brainId === 'global') {
+      authorize(auth, 'brain:global');
+      if (globalToggles[path.resolve(registryBrain)] === false || globalToggles[sharedBrain] === false) {
+        throw targetError(404, 'The selected global brain is unavailable.');
+      }
+      return { brainId, name: 'Global Brain', brainDir: sharedBrain, projectRoot: null };
+    }
+    const selector = brainId.slice('project:'.length);
+    const matches = rows.filter(row => row.name === selector || row.project_id === selector);
+    if (matches.length > 1) throw targetError(409, 'A selected project brain ID is ambiguous.');
+    const row = matches[0];
+    if (typeof row?.project_id !== 'string' || !UUID.test(row.project_id) || rows.filter(candidate => candidate.project_id === row.project_id).length !== 1) {
+      throw targetError(404, 'A selected project brain is unavailable.');
+    }
+    authorize(auth, 'brain:project-' + row.project_id);
+    const target = resolveProject(row, sharedBrain, toggles);
+    if (!target) throw targetError(404, 'A selected project brain is unavailable.');
+    if (resolved.has(target.brainDir)) throw targetError(400, 'Select each project brain once.');
+    resolved.add(target.brainDir);
+    return { brainId, name: row.name || selector, ...target };
+  });
+}

package/src/server/rest.mjs

@@ -121,6 +121,7 @@ import updateRouter       from './routes/update.mjs';
 import { rulesRouter }    from './routes/rules.mjs';
 import notificationsRouter from './routes/notifications.mjs';
 import pluginsRouter      from './routes/plugins.mjs';
+import uiChunksRouter     from './routes/ui-chunks.mjs';
 // ollamaUrl removed — CLI agents replace Ollama
 import {
   AGENT_DIR,
@@ -235,6 +236,7 @@ router.use(ssssRouter);
 router.use(rulesRouter);
 router.use(notificationsRouter);
 router.use(pluginsRouter);
+router.use(uiChunksRouter);
 for (const pluginRouter of await (await import('../core/plugin-runtime.mjs')).loadPluginRouters()) router.use(pluginRouter);
 
 export { router as restRouter };

package/src/server/route-inventory.mjs

@@ -29,13 +29,14 @@ export function extractRoutes(router) {
 
     for (const layer of stack) {
       if (layer.route) {
-        const pathStr = layer.route.path;
+        // Express keeps aliases and regular expressions in Route.path.
+        const paths = [layer.route.path].flat(Infinity).map(String);
         const methods = Object.keys(layer.route.methods)
           .filter((method) => layer.route.methods[method])
           .map((method) => method.toUpperCase());
 
         for (const method of methods) {
-          routes.push({ method, path: pathStr });
+          for (const path of paths) routes.push({ method, path });
         }
       } else if (layer.name === 'router' && layer.handle && layer.handle.stack) {
         // Sub-router mounted via router.use()

package/src/server/route-manifest.json

@@ -91,6 +91,14 @@
     "method": "POST",
     "path": "/api/daemon/restart"
   },
+  {
+    "method": "GET",
+    "path": "/api/dashboard/drawers/:edge"
+  },
+  {
+    "method": "PUT",
+    "path": "/api/dashboard/drawers/:edge"
+  },
   {
     "method": "GET",
     "path": "/api/dashboard/instructions"
@@ -467,10 +475,6 @@
     "method": "POST",
     "path": "/api/plugins/:id/branding"
   },
-  {
-    "method": "PATCH",
-    "path": "/api/plugins/:id/card-face"
-  },
   {
     "method": "GET",
     "path": "/api/plugins/:id/configuration"
@@ -843,6 +847,34 @@
     "method": "GET",
     "path": "/api/tts/status"
   },
+  {
+    "method": "GET",
+    "path": "/api/ui-chunks"
+  },
+  {
+    "method": "GET",
+    "path": "/api/ui-chunks/:plugin/:id"
+  },
+  {
+    "method": "GET",
+    "path": "/api/ui-chunks/:plugin/composition/current"
+  },
+  {
+    "method": "GET",
+    "path": "/api/ui-chunks/:plugin/design/revision"
+  },
+  {
+    "method": "POST",
+    "path": "/api/ui-chunks/compose"
+  },
+  {
+    "method": "POST",
+    "path": "/api/ui-chunks/pool"
+  },
+  {
+    "method": "POST",
+    "path": "/api/ui-chunks/suggest"
+  },
   {
     "method": "GET",
     "path": "/api/update/check"
@@ -939,6 +971,22 @@
     "method": "POST",
     "path": "/api/webhooks/test/:provider"
   },
+  {
+    "method": "GET",
+    "path": "/api/workspace/pages"
+  },
+  {
+    "method": "POST",
+    "path": "/api/workspace/pages"
+  },
+  {
+    "method": "GET",
+    "path": "/api/workspace/pages/:id"
+  },
+  {
+    "method": "PUT",
+    "path": "/api/workspace/pages/:id"
+  },
   {
     "method": "POST",
     "path": "/auth/change-password"

package/src/server/routes/_shared.mjs

@@ -13,6 +13,7 @@ import { fileURLToPath } from 'node:url';
 import { agentDir, brainDir, globalBrainDir } from '../../core/config.mjs';
 import { resolveSurfaceDir } from '../../cli/agent-dir.mjs';
 import { logger } from '../../core/logger.mjs';
+import { dashboardBrainDir, readRegisteredProjects } from '../../core/brain-registry.mjs';
 
 export { globalBrainDir };
 export const AGENT_DIR    = process.env.AGENT_DIR || agentDir;
@@ -33,7 +34,7 @@ export const MODEL_CATALOG_DIR = path.join(ROOT, 'models', 'catalog', 'total-rec
  * Resolve a brain-specific vault directory from the request.
  *
  * Reads `req.query.brain` (query param) or `req.body?.brainId` (body field).
- * - If the value is `'global'` or missing, returns the default VAULT_DIR.
+ * - Missing selection uses the default server vault. Explicit global selection follows the dashboard.
  * - If it starts with `'project:'`, looks up the project brain in the
  *   project-registry.json (same resolution logic as GET /api/brains/:id/nodes).
  * - Falls back to VAULT_DIR if the resolved path doesn't exist.
@@ -52,23 +53,15 @@ export function resolveVaultFromQuery(req, { strict = false } = {}) {
     }
   }
 
-  // No brain specified or explicitly global → default vault
-  if (!brainId || brainId === 'global') {
-    return VAULT_DIR;
-  }
+  if (!brainId) return VAULT_DIR;
+  if (brainId === 'global') return path.join(dashboardBrainDir(process.env, BRAIN_DIR), 'memory-vault');
 
   if (brainId.startsWith('project:')) {
     const projectName = brainId.slice('project:'.length);
-    const registryPath = path.join(globalBrainDir, 'config', 'project-registry.json');
-
-    if (!fs.existsSync(registryPath)) {
-      if (strict) throw Object.assign(new Error('Selected brain is unavailable'), { status: 404 });
-      return VAULT_DIR;
-    }
-
     try {
-      const registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
-      const project = registry.find(p => p.name === projectName);
+      const registry = readRegisteredProjects(dashboardBrainDir(process.env, globalBrainDir));
+      const matching = registry.filter(p => p.name === projectName || p.project_id === projectName);
+      const project = matching.length === 1 ? matching[0] : null;
       if (project) {
         const projectVaultDir = path.join(project.brainDir, 'memory-vault');
         if (fs.existsSync(projectVaultDir)) {