total-recall-brain 3.44.0 → 3.46.0

package/src/server/route-manifest.json

@@ -19,10 +19,6 @@
     "method": "GET",
     "path": "/api/brains/:id/nodes"
   },
-  {
-    "method": "POST",
-    "path": "/api/brains/sync"
-  },
   {
     "method": "POST",
     "path": "/api/capture/:source"
@@ -92,20 +88,16 @@
     "path": "/api/context"
   },
   {
-    "method": "GET",
-    "path": "/api/context/flash/health"
+    "method": "POST",
+    "path": "/api/daemon/restart"
   },
   {
     "method": "GET",
-    "path": "/api/context/preview"
+    "path": "/api/dashboard/drawers/:edge"
   },
   {
-    "method": "POST",
-    "path": "/api/context/stream"
-  },
-  {
-    "method": "POST",
-    "path": "/api/daemon/restart"
+    "method": "PUT",
+    "path": "/api/dashboard/drawers/:edge"
   },
   {
     "method": "GET",
@@ -483,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"
@@ -807,14 +795,6 @@
     "method": "GET",
     "path": "/api/ssss"
   },
-  {
-    "method": "GET",
-    "path": "/api/ssss"
-  },
-  {
-    "method": "GET",
-    "path": "/api/ssss/instructions"
-  },
   {
     "method": "GET",
     "path": "/api/ssss/instructions"
@@ -823,14 +803,6 @@
     "method": "GET",
     "path": "/api/ssss/references"
   },
-  {
-    "method": "GET",
-    "path": "/api/ssss/references"
-  },
-  {
-    "method": "GET",
-    "path": "/api/ssss/references/:name"
-  },
   {
     "method": "GET",
     "path": "/api/ssss/references/:name"
@@ -839,14 +811,6 @@
     "method": "GET",
     "path": "/api/ssss/skill/ssss"
   },
-  {
-    "method": "GET",
-    "path": "/api/ssss/skill/ssss"
-  },
-  {
-    "method": "GET",
-    "path": "/api/ssss/spec"
-  },
   {
     "method": "GET",
     "path": "/api/ssss/spec"
@@ -876,20 +840,40 @@
     "path": "/api/tasks/:id/retry"
   },
   {
-    "method": "DELETE",
-    "path": "/api/tasks/cleanup"
+    "method": "POST",
+    "path": "/api/tts"
   },
   {
     "method": "GET",
-    "path": "/api/tasks/failed"
+    "path": "/api/tts/status"
   },
   {
-    "method": "POST",
-    "path": "/api/tts"
+    "method": "GET",
+    "path": "/api/ui-chunks"
   },
   {
     "method": "GET",
-    "path": "/api/tts/status"
+    "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",
@@ -911,18 +895,10 @@
     "method": "POST",
     "path": "/api/v1/ssss"
   },
-  {
-    "method": "POST",
-    "path": "/api/vault/compact"
-  },
   {
     "method": "POST",
     "path": "/api/vault/compile"
   },
-  {
-    "method": "GET",
-    "path": "/api/vault/hash"
-  },
   {
     "method": "GET",
     "path": "/api/vault/status"
@@ -995,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)) {

package/src/server/routes/brains.mjs

@@ -12,14 +12,10 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import { requireAuth, requireScope } from '../auth.mjs';
+import { dashboardBrainDir, readRegisteredProjects } from '../../core/brain-registry.mjs';
 import { getNodes } from '../../core/vault-cache.mjs';
 import { logger } from '../../core/logger.mjs';
-import {
-  BRAIN_DIR,
-  VAULT_DIR,
-  DERIVED_DIR,
-  serverError,
-} from './_shared.mjs';
+import { serverError } from './_shared.mjs';
 
 const router = Router();
 
@@ -49,8 +45,9 @@ function countMd(dir) {
  * List all known brains (global + registered projects + optional tenant) with state metadata.
  */
 router.get('/api/brains', requireAuth, requireScope('ssss:read'), async (req, res) => {
+  res.set('Cache-Control', 'private, no-store');
   try {
-    const globalBrainDir = path.join(os.homedir(), '.agent', 'skills', 'total-recall');
+    const globalBrainDir = dashboardBrainDir();
     const brains = [];
 
     // Global brain
@@ -75,35 +72,27 @@ router.get('/api/brains', requireAuth, requireScope('ssss:read'), async (req, re
     });
 
     // Project brains from registry
-    const registryPath = path.join(globalBrainDir, 'config', 'project-registry.json');
-    if (fs.existsSync(registryPath)) {
-      try {
-        const registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
-        for (const project of registry) {
-          const projectVaultDir = path.join(project.brainDir, 'memory-vault');
-          let nodeCount = 0;
-          const exists = fs.existsSync(project.path);
-          if (!exists) continue; // Hide non-existent projects automatically
-
-          if (fs.existsSync(projectVaultDir)) {
-            nodeCount = countMd(projectVaultDir);
-          }
-
-          brains.push({
-            id: `project:${project.name}`,
-            name: project.name,
-            layer: 'project',
-            path: project.brainDir,
-            project_root: project.path,
-            exists: true,
-            node_count: nodeCount,
-            registered_at: project.registered_at,
-            last_compiled: project.last_compiled || getLastModified(path.join(project.brainDir, 'memory-derived', 'graph-index.jsonl')),
-          });
-        }
-      } catch (err) {
-        logger.error('server', 'Failed to read project registry', { error: err.message });
+    try {
+      const registry = readRegisteredProjects(globalBrainDir);
+      for (const project of registry) {
+        if (!project.name || !project.path || !project.brainDir || !fs.existsSync(project.path)) continue;
+        const duplicateName = registry.some(other => other !== project && other.name === project.name);
+        if (duplicateName && !project.project_id) continue;
+        brains.push({
+          id: `project:${duplicateName ? project.project_id : project.name}`,
+          name: project.name,
+          layer: 'project',
+          path: project.brainDir,
+          project_root: project.path,
+          exists: true,
+          node_count: countMd(path.join(project.brainDir, 'memory-vault')),
+          registered_at: project.registered_at,
+          last_compiled: project.last_compiled || getLastModified(path.join(project.brainDir, 'memory-derived', 'graph-index.jsonl')),
+        });
       }
+    } catch (err) {
+      logger.error('server', 'Failed to read project registry', { error: err.message });
+      return res.status(503).json({ error: 'Brain registry metadata is unavailable' });
     }
 
     // Optional remote/tenant vault from config
@@ -145,22 +134,18 @@ router.get('/api/brains', requireAuth, requireScope('ssss:read'), async (req, re
  * List all memory nodes for a specific brain.
  */
 router.get('/api/brains/:id/nodes', requireAuth, requireScope('ssss:read', 'memory:read'), async (req, res) => {
+  res.set('Cache-Control', 'private, no-store');
   try {
     const brainId = req.params.id;
     let vaultDir;
 
     if (brainId === 'global') {
-      const brainDir = path.join(os.homedir(), '.agent', 'skills', 'total-recall');
-      vaultDir = path.join(brainDir, 'memory-vault');
+      vaultDir = path.join(dashboardBrainDir(), 'memory-vault');
     } else 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)) {
-        return res.status(404).json({ error: 'Project registry not found' });
-      }
-      const registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
-      const project = registry.find(p => p.name === projectName);
+      const registry = readRegisteredProjects(dashboardBrainDir());
+      const matching = registry.filter(p => p.name === projectName || p.project_id === projectName);
+      const project = matching.length === 1 ? matching[0] : null;
       if (!project) {
         return res.status(404).json({ error: `Project "${projectName}" not found in registry` });
       }
@@ -210,22 +195,4 @@ router.get('/api/brains/:id/nodes', requireAuth, requireScope('ssss:read', 'memo
   } catch (err) { serverError(res, err); }
 });
 
-/**
- * POST /api/brains/sync
- * Trigger a repo-sync across all registered repos.
- * Returns sync results per repo.
- */
-router.post('/api/brains/sync', requireAuth, requireScope('memory:write'), async (req, res) => {
-  try {
-    const { syncAllRepos } = await import('../../core/repo-sync.mjs');
-    const result = await syncAllRepos();
-    res.json({
-      ok: true,
-      totalIngested: result.totalIngested,
-      totalSkipped: result.totalSkipped,
-      repos: result.repos,
-    });
-  } catch (err) { serverError(res, err); }
-});
-
 export default router;

package/src/server/routes/context.mjs

@@ -49,45 +49,4 @@ router.post('/api/context', requireAuth, requireScope('memory:read'), async (req
   }
 });
 
-router.get('/api/context/preview', requireAuth, requireScope('memory:read'), async (req, res) => {
-  try {
-    const { previewContext } = await import('../../core/context-compiler.mjs');
-    const vaultDir = resolveVaultFromQuery(req, { strict: true });
-    const result = previewContext({ vaultDir });
-    res.json(result);
-  } catch (err) {
-    serverError(res, err);
-  }
-});
-
-router.post('/api/context/stream', requireAuth, requireScope('memory:read'), async (req, res) => {
-  try {
-    const { streamParallelContext } = await import('../../core/parallel-context.mjs');
-    const { query, budget_tokens, batch_size, concurrency, min_score } = req.body || {};
-    if (!query) return badRequest(res, 'query is required');
-    const vaultDir = resolveVaultFromQuery(req, { strict: true });
-    const result = await streamParallelContext({
-      query,
-      vaultDir,
-      budgetTokens: budget_tokens,
-      batchSize: batch_size,
-      concurrency,
-      minScore: min_score,
-    });
-    res.json(result);
-  } catch (err) {
-    serverError(res, err);
-  }
-});
-
-router.get('/api/context/flash/health', requireAuth, requireScope('memory:read'), async (req, res) => {
-  try {
-    const { checkFlashHealth } = await import('../../core/parallel-context.mjs');
-    const result = await checkFlashHealth();
-    res.json(result);
-  } catch (err) {
-    serverError(res, err);
-  }
-});
-
 export default router;

package/src/server/routes/dashboard.mjs

@@ -4,8 +4,10 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { requireAuth, requireScope } from '../auth.mjs';
 import { getNodes } from '../../core/vault-cache.mjs';
+import { DrawerInputError, readDrawerConfig, writeDrawerConfig } from '../../core/workspace-drawers.mjs';
 import {
   VAULT_DIR,
+  BRAIN_DIR,
   INSTRUCTIONS,
   ROOT as SHARED_ROOT,
   resolveVaultFromQuery,
@@ -17,6 +19,30 @@ const router = Router();
 // (breaks on Windows and on paths with encoded characters).
 const ROOT = process.env.TR_ROOT || SHARED_ROOT || path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..', '..');
 
+router.get('/api/dashboard/drawers/:edge', requireAuth, requireScope('config:read'), (req, res) => {
+  res.set('Cache-Control', 'no-store');
+  try {
+    return res.json(readDrawerConfig(BRAIN_DIR, req.params.edge));
+  } catch (error) {
+    if (error instanceof DrawerInputError) return res.status(400).json({ error: error.message });
+    return res.status(500).json({ error: 'Could not read the saved drawer.' });
+  }
+});
+
+router.put('/api/dashboard/drawers/:edge', requireAuth, requireScope('config:write'), async (req, res) => {
+  res.set('Cache-Control', 'no-store');
+  if (!req.is('application/json')) return res.status(415).json({ error: 'Use JSON to save the drawer.' });
+  try {
+    return res.json(await writeDrawerConfig(BRAIN_DIR, req.params.edge, req.body?.config, req.body?.version));
+  } catch (error) {
+    if (error instanceof DrawerInputError) return res.status(400).json({ error: error.message });
+    if (error.message.startsWith('Plugin state version conflict')) {
+      return res.status(409).json({ error: 'The drawer changed elsewhere. Reload it before saving.' });
+    }
+    return res.status(500).json({ error: 'Could not save the drawer.' });
+  }
+});
+
 router.get('/api/dashboard/instructions', requireAuth, requireScope('instructions:read'), (req, res) => {
   const vaultDir = resolveVaultFromQuery(req);
   const paths = pathsForVault(vaultDir);

package/src/server/routes/invoke.mjs

@@ -16,6 +16,7 @@ import { invokeAuthority, authorizeInvoke, operationAllowed } from '../invoke-po
 import { restrictedBrainTargets } from '../invoke-targets.mjs';
 import { INVOKE_LIMITS, InvokeError, executeInvokeChild, requireSuccessfulRun, invokeEnvironment, absoluteTarget } from '../invoke-execution.mjs';
 import { syncChangedFiles } from '../invoke-durability.mjs';
+import { CORE_OPERATIONS, validateCoreParams } from '../invoke-core-operations.mjs';
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../..');
 // Share across router instances in this server; do not race projection refreshes.
@@ -29,6 +30,7 @@ export const OPERATIONS = Object.freeze(Object.fromEntries(Object.entries({
   'composable.run': { scope: 'sandbox:run', family: 'composable' },
   'decision.run': { scope: 'memory:read', family: 'decision' },
   'decision.predict': { scope: 'memory:read', family: 'decision' },
+  ...CORE_OPERATIONS,
 }).map(([name, def]) => [name, Object.freeze(def)])));
 
 const fail = (res, status, operation, code, message, extra = {}) => res.status(status).json({
@@ -106,13 +108,14 @@ export function createInvokeRouter({ auth = requireAuth, store = { loadKeys, key
       };
       revalidate();
       timer = setInterval(revalidate, 250); timer.unref?.();
-      const context = { authority, target, serverBrain, selectedBrain, signal: controller.signal, limits, commandScopes,
+      const context = { authority, target, serverBrain, registryBrain, selectedBrain, signal: controller.signal, limits, commandScopes,
         run: options => {
           revalidate();
           return execute({ ...options, signal: controller.signal, limits });
         } };
       let result;
       if (operation === 'capabilities') result = capabilitiesFor(authority, limits, targetNames);
+      else if (Object.hasOwn(CORE_OPERATIONS, operation)) result = await runCoreOperation(operation, params, context);
       else result = await HANDLERS[operation](params, context);
       if (operation === 'ssss.write' && authority.mode === 'restricted') mutationResult = result;
       revalidate();
@@ -143,6 +146,28 @@ export function createInvokeRouter({ auth = requireAuth, store = { loadKeys, key
 
 export const invokeRouter = createInvokeRouter();
 
+async function runCoreOperation(operation, params, context) {
+  validateCoreParams(operation, params);
+  const run = await context.run({ entry: path.join(root, 'src/server/invoke-core-child.mjs'),
+    cwd: context.target, env: invokeEnvironment(true), timeoutMs: params.timeoutMs,
+    input: JSON.stringify({ operation, params, brain: context.serverBrain, registryBrain: context.registryBrain }) });
+  if (run.termination_reason || run.truncated) {
+    const code = run.termination_reason || 'output-limit';
+    throw new InvokeError(code === 'timeout' ? 504 : code === 'authority-ended' ? 403 : 422,
+      code, 'Owner execution did not complete; a mutation may already have committed.');
+  }
+  let response;
+  try { response = JSON.parse(run.stdout); } catch { /* reject below */ }
+  if (response?.ok === false) {
+    const code = ['brain-unavailable', 'sync-failed'].includes(response.error) ? response.error : 'operation-failed';
+    throw new InvokeError(code === 'brain-unavailable' ? 404 : 502, code, 'Owner operation failed.');
+  }
+  if (run.exit_code !== 0 || response?.ok !== true || !response.result || typeof response.result !== 'object' || Array.isArray(response.result)) {
+    throw new InvokeError(502, 'invalid-owner-output', 'Owner returned invalid output.');
+  }
+  return response.result;
+}
+
 /** The categories `total-recall remember` documents. Singular, and closed. */
 const MEMORY_CATEGORIES = new Set(['invariant', 'preference', 'correction', 'fact', 'concept', 'pattern', 'anti-pattern', 'decision', 'lore']);