total-recall-brain 3.43.3 → 3.45.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"
@@ -91,18 +87,6 @@
     "method": "POST",
     "path": "/api/context"
   },
-  {
-    "method": "GET",
-    "path": "/api/context/flash/health"
-  },
-  {
-    "method": "GET",
-    "path": "/api/context/preview"
-  },
-  {
-    "method": "POST",
-    "path": "/api/context/stream"
-  },
   {
     "method": "POST",
     "path": "/api/daemon/restart"
@@ -807,14 +791,6 @@
     "method": "GET",
     "path": "/api/ssss"
   },
-  {
-    "method": "GET",
-    "path": "/api/ssss"
-  },
-  {
-    "method": "GET",
-    "path": "/api/ssss/instructions"
-  },
   {
     "method": "GET",
     "path": "/api/ssss/instructions"
@@ -823,22 +799,10 @@
     "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"
-  },
-  {
-    "method": "GET",
-    "path": "/api/ssss/skill/ssss"
-  },
   {
     "method": "GET",
     "path": "/api/ssss/skill/ssss"
@@ -847,10 +811,6 @@
     "method": "GET",
     "path": "/api/ssss/spec"
   },
-  {
-    "method": "GET",
-    "path": "/api/ssss/spec"
-  },
   {
     "method": "POST",
     "path": "/api/sync/remote-vault/proposals/:id/decision"
@@ -875,14 +835,6 @@
     "method": "POST",
     "path": "/api/tasks/:id/retry"
   },
-  {
-    "method": "DELETE",
-    "path": "/api/tasks/cleanup"
-  },
-  {
-    "method": "GET",
-    "path": "/api/tasks/failed"
-  },
   {
     "method": "POST",
     "path": "/api/tts"
@@ -911,18 +863,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"

package/src/server/routes/brains.mjs

@@ -210,22 +210,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/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']);
 

package/src/server/routes/ssss.mjs

@@ -3,184 +3,15 @@
  * Extracted from rest.mjs
  */
 import { Router } from 'express';
-import fs from 'node:fs';
-import path from 'node:path';
-import crypto from 'node:crypto';
 import { requireAuth, requireScope } from '../auth.mjs';
 import { processOperationAsync } from '../../core/operation-validator.mjs';
 import { invalidate } from '../../core/vault-cache.mjs';
 import {
-  ROOT,
-  INSTRUCTIONS,
-  SKILLS_DIR,
   resolveVaultFromQuery,
 } from './_shared.mjs';
 
 const router = Router();
 
-// ─── SSSS Resources (sync and integration consumers) ─────────────────────────
-
-function sha256(content) {
-  return crypto.createHash('sha256').update(content).digest('hex');
-}
-
-function readTextResource(filePath, name) {
-  if (!fs.existsSync(filePath)) return null;
-  const content = fs.readFileSync(filePath, 'utf8');
-  const stat = fs.statSync(filePath);
-  return {
-    name,
-    content,
-    sha256: sha256(content),
-    bytes: stat.size,
-    modified: stat.mtime.toISOString()
-  };
-}
-
-function sendTextResource(res, filePath, name) {
-  const resource = readTextResource(filePath, name);
-  if (!resource) {
-    return res.status(404).json({ error: `${name} is not available` });
-  }
-  return res.json(resource);
-}
-
-function baseUrl(req) {
-  return `${req.protocol}://${req.get('host')}`;
-}
-
-function absoluteUrl(req, routePath) {
-  return new URL(routePath, baseUrl(req)).toString();
-}
-
-function ssssReferenceDir() {
-  // Prefer compact TR references; fall back to legacy nested module paths.
-  const candidates = [
-    path.join(SKILLS_DIR, 'total-recall', 'references'),
-    path.join(SKILLS_DIR, 'total-recall', 'modules', 'ssss', 'references'),
-    path.join(SKILLS_DIR, 'okf', 'references'),
-  ];
-  return candidates.find((p) => fs.existsSync(p)) || candidates[0];
-}
-
-function ssssSkillDocPath() {
-  const candidates = [
-    path.join(SKILLS_DIR, 'total-recall', 'references', 'ssss-reference.md'),
-    path.join(SKILLS_DIR, 'total-recall', 'SKILL.md'),
-    path.join(SKILLS_DIR, 'total-recall', 'modules', 'ssss', 'MODULE.md'),
-    path.join(SKILLS_DIR, 'okf', 'SKILL.md'),
-  ];
-  return candidates.find((p) => fs.existsSync(p)) || candidates[0];
-}
-
-function listSsssReferences(req) {
-  const refsDir = ssssReferenceDir();
-  if (!fs.existsSync(refsDir)) return [];
-  return fs.readdirSync(refsDir)
-    .filter(file => file.endsWith('.md'))
-    .sort()
-    .map((file) => {
-      const name = file.replace(/\.md$/, '');
-      const resource = readTextResource(path.join(refsDir, file), name);
-      return {
-        name,
-        url: absoluteUrl(req, `/api/ssss/references/${name}`),
-        sha256: resource?.sha256 || null,
-        bytes: resource?.bytes || 0,
-        modified: resource?.modified || null
-      };
-    });
-}
-
-function safeReferencePath(name) {
-  if (!/^[a-zA-Z0-9_-]+$/.test(String(name || ''))) return null;
-  return path.join(ssssReferenceDir(), `${name}.md`);
-}
-
-router.get('/api/ssss', requireAuth, requireScope('ssss:read'), (req, res) => {
-  const resources = {
-    instructions: {
-      name: 'instructions',
-      url: absoluteUrl(req, '/api/ssss/instructions'),
-      ...(() => {
-        const r = readTextResource(INSTRUCTIONS, 'instructions');
-        return r ? { sha256: r.sha256, bytes: r.bytes, modified: r.modified } : { sha256: null, bytes: 0, modified: null };
-      })()
-    },
-    skill: {
-      name: 'ssss-skill',
-      url: absoluteUrl(req, '/api/ssss/skill/ssss'),
-      ...(() => {
-        const r = readTextResource(ssssSkillDocPath(), 'ssss-skill');
-        return r ? { sha256: r.sha256, bytes: r.bytes, modified: r.modified } : { sha256: null, bytes: 0, modified: null };
-      })()
-    },
-    spec: {
-      name: 'ssss-spec',
-      url: absoluteUrl(req, '/api/ssss/spec'),
-      ...(() => {
-        const refs = ssssReferenceDir();
-        const specPath = ['ssss-reference.md', 'ssss-spec.md']
-          .map((n) => path.join(refs, n))
-          .find((p) => fs.existsSync(p));
-        const r = specPath ? readTextResource(specPath, 'ssss-spec') : null;
-        return r ? { sha256: r.sha256, bytes: r.bytes, modified: r.modified } : { sha256: null, bytes: 0, modified: null };
-      })()
-    },
-    references: listSsssReferences(req)
-  };
-
-  res.json({
-    name: 'ssss',
-    schema_version: 2,
-    resources
-  });
-});
-
-router.get('/api/ssss/instructions', requireAuth, requireScope('ssss:read', 'instructions:read'), (req, res) => {
-  const surface = req.query.surface;
-  // Prefer live INSTRUCTIONS constant (agent brain), then package ROOT fallback
-  const instructionsPath = fs.existsSync(INSTRUCTIONS)
-    ? INSTRUCTIONS
-    : path.join(ROOT, 'INSTRUCTIONS.md');
-  if (surface) {
-    if (surface === 'INSTRUCTIONS.md') {
-      return sendTextResource(res, instructionsPath, 'instructions');
-    }
-    const safeSurface = path.basename(surface);
-    const candidates = [
-      path.join(path.dirname(instructionsPath), safeSurface),
-      path.join(ROOT, safeSurface),
-    ];
-    const surfacePath = candidates.find(p => fs.existsSync(p)) || candidates[0];
-    return sendTextResource(res, surfacePath, safeSurface);
-  }
-  return sendTextResource(res, instructionsPath, 'instructions');
-});
-
-router.get('/api/ssss/skill/ssss', requireAuth, requireScope('ssss:read'), (_req, res) => {
-  return sendTextResource(res, ssssSkillDocPath(), 'ssss-skill');
-});
-
-router.get('/api/ssss/spec', requireAuth, requireScope('ssss:read'), (_req, res) => {
-  const refs = ssssReferenceDir();
-  const specPath = ['ssss-reference.md', 'ssss-spec.md']
-    .map((n) => path.join(refs, n))
-    .find((p) => fs.existsSync(p));
-  return sendTextResource(res, specPath || path.join(refs, 'ssss-reference.md'), 'ssss-spec');
-});
-
-router.get('/api/ssss/references', requireAuth, requireScope('ssss:read'), (req, res) => {
-  res.json({ references: listSsssReferences(req) });
-});
-
-router.get('/api/ssss/references/:name', requireAuth, requireScope('ssss:read'), (req, res) => {
-  const filePath = safeReferencePath(req.params.name);
-  if (!filePath) return res.status(400).json({ error: 'Invalid reference name' });
-  return sendTextResource(res, filePath, req.params.name);
-});
-
-
 export const ssssOperationHandler = async (req, res) => {
   try {
     const vaultRoot = resolveVaultFromQuery(req);

package/src/server/routes/system.mjs

@@ -4,7 +4,6 @@
  * GET  /api/logs/:type           — Read last 200 lines of server or daemon log
  * POST /api/diagnostics/agents   — Run upgrade --agents diagnostics
  * GET  /api/pairing              — Reachable URLs for the mobile pairing QR
- * GET  /api/tasks/failed         — List failed tasks from the DLQ
  * POST /api/tasks/:id/retry      — Re-queue a failed task
  * GET  /api/usage                — Usage ledger + cost summary
  * GET  /api/usage/providers      — Spend as the providers report it
@@ -144,20 +143,6 @@ router.get('/api/pairing', requireAuth, requireScope('config:read'), async (_req
   }
 });
 
-/**
- * GET /api/tasks/failed
- * List failed tasks from the scheduler DLQ.
- */
-router.get('/api/tasks/failed', requireAuth, async (req, res) => {
-  try {
-    const { listTasks } = await import('../../core/task-envelope.mjs');
-    const failed = listTasks(QUEUE_DIR, { status: 'failed' });
-    res.json({ total: failed.length, tasks: failed });
-  } catch (err) {
-    serverError(res, err);
-  }
-});
-
 /**
  * POST /api/tasks/:id/retry
  * Re-queue a failed task.

package/src/server/routes/tasks.mjs

@@ -38,32 +38,6 @@ router.get('/api/tasks', requireAuth, requireScope('tasks:read'), (req, res) =>
   } catch (err) { serverError(res, err); }
 });
 
-router.delete('/api/tasks/cleanup', requireAuth, requireScope('tasks:write'), (req, res) => {
-  try {
-    if (!fs.existsSync(TASKS_DIR)) {
-      return res.json({ deleted: 0 });
-    }
-    let deleted = 0;
-    const files = fs.readdirSync(TASKS_DIR);
-    for (const file of files) {
-      if (!file.endsWith('.md')) continue;
-      const filePath = path.join(TASKS_DIR, file);
-      try {
-        const raw = fs.readFileSync(filePath, 'utf8');
-        const { data } = matter(raw);
-        if (data.status === 'completed') {
-          fs.unlinkSync(filePath);
-          deleted++;
-        }
-      } catch (e) {
-        // skip
-      }
-    }
-    res.json({ deleted });
-    
-  } catch (err) { serverError(res, err); }
-});
-
 router.post('/api/tasks', requireAuth, requireScope('tasks:write'), (req, res) => {
   try {
     const { category, target, body, priority = 5 } = req.body || {};

package/src/server/routes/vault.mjs

@@ -1,6 +1,5 @@
 import { Router } from 'express';
 import fs from 'node:fs';
-import path from 'node:path';
 import { requireAuth, requireScope } from '../auth.mjs';
 import {
   serverError,
@@ -16,6 +15,7 @@ import { compileSurface } from '../../core/surface.mjs';
 import { getNodes, invalidate } from '../../core/vault-cache.mjs';
 import { loadEmbeddingsIndex, loadSessionEmbeddingsIndex } from '../../core/embeddings.mjs';
 import { logger } from '../../core/logger.mjs';
+import { ruleLengthStats } from '../../core/rule-length.mjs';
 
 const router = Router();
 
@@ -63,28 +63,6 @@ router.post('/api/vault/compile', requireAuth, requireScope('memory:recompile'),
   }
 });
 
-router.post('/api/vault/compact', requireAuth, requireScope('memory:write'), async (req, res) => {
-  try {
-    const { compactAppendLogs } = await import('../../core/append-log.mjs');
-    const result = compactAppendLogs();
-    res.json({ compacted: true, ...result });
-  } catch (err) {
-    serverError(res, err);
-  }
-});
-
-router.get('/api/vault/hash', requireAuth, requireScope('memory:read'), (req, res) => {
-  try {
-    const vaultDir = resolveVaultFromQuery(req);
-    const { derivedDir } = pathsForVault(vaultDir);
-    const hashFile = path.join(derivedDir, 'vault-hash.txt');
-    const hash = fs.existsSync(hashFile) ? fs.readFileSync(hashFile, 'utf8').trim() : null;
-    res.json({ vault_hash: hash, vault_dir: vaultDir });
-  } catch (err) {
-    serverError(res, err);
-  }
-});
-
 router.get('/api/vault/status', requireAuth, requireScope('memory:read'), async (req, res) => {
   try {
     const vaultDir = resolveVaultFromQuery(req);
@@ -116,6 +94,7 @@ router.get('/api/vault/status', requireAuth, requireScope('memory:read'), async
 
     res.json({
       vault_dir:     vaultDir,
+      rule_length:   ruleLengthStats(),
       node_count:    nodeCount,
       skill_count:   skillCount,
       derived_files: derivedFiles,