fix: Gemini thinking token budget, Qdrant indexes, NER quality, entity cleanup

- Fix brain_reflect/consolidation 502: Gemini 2.5 Flash thinking tokens
  consumed maxOutputTokens:4096 budget — bumped to 65536 with 8192
  thinking cap, added finishReason check and non-thinking part selection
- Fix Qdrant payload index creation: 'Keyword' → 'keyword' (4 places)
- Tighten NER extraction: reject verb phrases, digits, 4+ word phrases,
  sentence starters in both isJunkPhrase and isJunkQuotedName
- Add /reconcile endpoint for Qdrant/Postgres/keyword data layer sync
- Add DELETE /entities/:name and POST /entities/:name/merge endpoints
- Fix query limit: listEvents/listFacts/listStatuses accept limit param
  (was hardcoded at 50, now configurable up to 500)
- Add query param auth fallback (req.query.key) for dashboard SSE/graph
- Add 'general' catch-all category to client briefing endpoint
- Add temporal validity post-filter for keyword/graph search results
- Rebrand dashboard to Zengram, fix entity/graph auth in dashboard HTML
- Bump MCP server version to 2.5.1

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Skiipy11

api/src/index.js

@@ -15,6 +15,7 @@ import { reflectRouter } from './routes/reflect.js';
 import { subscribeRouter } from './routes/subscribe.js';
 import { dashboardRouter } from './routes/dashboard.js';
 import { collectionsRouter } from './routes/collections.js';
+import { reconcileRouter } from './routes/reconcile.js';
 import { initQdrant, ensureEntityIndex } from './services/qdrant.js';
 import { initEmbeddings } from './services/embedders/interface.js';
 import { initStore, isEntityStoreAvailable, loadAllAliases, _getStoreInstance, getBackendType } from './services/stores/interface.js';
@@ -72,6 +73,7 @@ app.use('/graph', graphRouter);
 app.use('/reflect', reflectRouter);
 app.use('/subscribe', subscribeRouter);
 app.use('/collections', collectionsRouter);
+app.use('/reconcile', reconcileRouter);
 
 async function start() {
   try {

api/src/middleware/auth.js

@@ -59,7 +59,7 @@ export function authMiddleware(req, res, next) {
     return res.status(429).json({ error: 'Too many failed attempts. Try again later.' });
   }
 
-  const key = req.headers['x-api-key'];
+  const key = req.headers['x-api-key'] || req.query.key;
   if (!key) {
     recordFailure(ip);
     return res.status(401).json({ error: 'Missing API key' });

api/src/routes/client.js

@@ -90,16 +90,25 @@ clientRouter.get('/:clientId', async (req, res) => {
     // --- Briefing mode ---
     const knowledge = {};
 
-    const categoryResults = await Promise.all(KNOWLEDGE_CATEGORIES.map(cat => {
+    // Query each named category + a "general" catch-all for uncategorized memories
+    const allCategories = [...KNOWLEDGE_CATEGORIES, 'general'];
+    const categoryResults = await Promise.all(allCategories.map(cat => {
       const scrollFilter = {
         client_id: effectiveClientId,
         active: true,
-        knowledge_category: cat,
       };
-      return scrollPoints(scrollFilter, SCROLL_LIMIT).then(r => ({ cat, points: r.points || [] }));
+      if (cat !== 'general') {
+        scrollFilter.knowledge_category = cat;
+      }
+      // For 'general': no knowledge_category filter — gets all memories for this client
+      return scrollPoints(scrollFilter, cat === 'general' ? 50 : SCROLL_LIMIT).then(r => ({ cat, points: r.points || [] }));
     }));
 
+    // Collect IDs from categorized results to exclude from general
+    const categorizedIds = new Set();
+
     for (const { cat, points } of categoryResults) {
+      if (cat === 'general') continue; // process general last
       // Sort by created_at descending (Qdrant scroll doesn't sort by payload)
       points.sort((a, b) => {
         const dateA = a.payload?.created_at || '';
@@ -111,6 +120,7 @@ clientRouter.get('/:clientId', async (req, res) => {
       const topPoints = points.slice(0, BRIEFING_PER_CATEGORY);
 
       knowledge[cat] = topPoints.map(p => {
+        categorizedIds.add(p.id);
         const payload = p.payload;
         const text = payload.text || '';
         if (isCompact) {
@@ -135,6 +145,37 @@ clientRouter.get('/:clientId', async (req, res) => {
       });
     }
 
+    // Process "general" — uncategorized memories not already in a named category
+    const generalResult = categoryResults.find(r => r.cat === 'general');
+    if (generalResult) {
+      const uncategorized = generalResult.points.filter(p => !categorizedIds.has(p.id));
+      uncategorized.sort((a, b) => (b.payload?.created_at || '').localeCompare(a.payload?.created_at || ''));
+      const topGeneral = uncategorized.slice(0, SCROLL_LIMIT);
+
+      knowledge.general = topGeneral.map(p => {
+        const payload = p.payload;
+        const text = payload.text || '';
+        if (isCompact) {
+          return {
+            id: p.id,
+            type: payload.type,
+            content: text.length > COMPACT_MAX ? text.slice(0, COMPACT_MAX) + '...' : text,
+            source_agent: payload.source_agent,
+            created_at: payload.created_at,
+          };
+        }
+        return {
+          id: p.id,
+          type: payload.type,
+          content: text,
+          source_agent: payload.source_agent,
+          importance: payload.importance,
+          created_at: payload.created_at,
+          metadata: payload.metadata || null,
+        };
+      });
+    }
+
     res.json({
       client_id: effectiveClientId,
       mode: 'briefing',

api/src/routes/entities.js

@@ -216,6 +216,126 @@ entitiesRouter.get('/:name', async (req, res) => {
   }
 });
 
+// DELETE /entities/:name — Delete an entity and its links
+entitiesRouter.delete('/:name', async (req, res) => {
+  try {
+    if (!isEntityStoreAvailable()) {
+      return res.status(400).json({ error: 'Entity queries require sqlite or postgres backend.' });
+    }
+
+    const entity = await findEntity(req.params.name);
+    if (!entity) {
+      return res.status(404).json({ error: 'Entity not found' });
+    }
+
+    const store = _getStoreInstance();
+    if (!store?.pool && !store?.db) {
+      return res.status(500).json({ error: 'No writable store available' });
+    }
+
+    // CASCADE handles entity_memory_links and entity_aliases
+    if (store.pool) {
+      await store.pool.query('DELETE FROM entities WHERE id = $1', [entity.id]);
+    } else if (store.db) {
+      store.db.prepare('DELETE FROM entities WHERE id = @id').run({ id: entity.id });
+    }
+
+    console.log(`[entities:delete] Entity "${entity.canonical_name}" (${entity.entity_type}) deleted`);
+
+    res.json({
+      deleted: true,
+      name: entity.canonical_name,
+      type: entity.entity_type,
+      id: entity.id,
+    });
+  } catch (err) {
+    console.error('[entities:delete]', err.message);
+    res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+// POST /entities/:name/merge — Merge another entity into this one
+entitiesRouter.post('/:name/merge', async (req, res) => {
+  try {
+    if (!isEntityStoreAvailable()) {
+      return res.status(400).json({ error: 'Entity queries require sqlite or postgres backend.' });
+    }
+
+    const { merge_from } = req.body;
+    if (!merge_from) {
+      return res.status(400).json({ error: 'merge_from is required (entity name to merge into this one)' });
+    }
+
+    const primary = await findEntity(req.params.name);
+    if (!primary) {
+      return res.status(404).json({ error: `Primary entity "${req.params.name}" not found` });
+    }
+
+    const secondary = await findEntity(merge_from);
+    if (!secondary) {
+      return res.status(404).json({ error: `Source entity "${merge_from}" not found` });
+    }
+
+    const store = _getStoreInstance();
+    if (!store?.pool) {
+      return res.status(500).json({ error: 'Merge requires postgres backend' });
+    }
+
+    // Move memory links from secondary to primary (skip conflicts)
+    const moveResult = await store.pool.query(`
+      UPDATE entity_memory_links SET entity_id = $1
+      WHERE entity_id = $2
+      AND NOT EXISTS (
+        SELECT 1 FROM entity_memory_links existing
+        WHERE existing.entity_id = $1
+        AND existing.memory_id = entity_memory_links.memory_id
+        AND existing.role = entity_memory_links.role
+      )
+    `, [primary.id, secondary.id]);
+    const movedLinks = moveResult.rowCount || 0;
+
+    // Move relationships from secondary to primary
+    await store.pool.query(`
+      UPDATE entity_relationships SET source_entity_id = $1
+      WHERE source_entity_id = $2
+      AND target_entity_id != $1
+    `, [primary.id, secondary.id]).catch(() => {});
+    await store.pool.query(`
+      UPDATE entity_relationships SET target_entity_id = $1
+      WHERE target_entity_id = $2
+      AND source_entity_id != $1
+    `, [primary.id, secondary.id]).catch(() => {});
+
+    // Create alias from secondary name
+    await store.pool.query(
+      `INSERT INTO entity_aliases (entity_id, alias, created_at) VALUES ($1, $2, NOW()) ON CONFLICT DO NOTHING`,
+      [primary.id, secondary.canonical_name]
+    );
+
+    // Update mention count on primary
+    await store.pool.query(
+      'UPDATE entities SET mention_count = mention_count + $1 WHERE id = $2',
+      [secondary.mention_count || 0, primary.id]
+    );
+
+    // Delete secondary (CASCADE removes remaining links/aliases)
+    await store.pool.query('DELETE FROM entities WHERE id = $1', [secondary.id]);
+
+    console.log(`[entities:merge] Merged "${secondary.canonical_name}" → "${primary.canonical_name}" (${movedLinks} links moved)`);
+
+    res.json({
+      merged: true,
+      primary: primary.canonical_name,
+      absorbed: secondary.canonical_name,
+      links_moved: movedLinks,
+      alias_created: secondary.canonical_name,
+    });
+  } catch (err) {
+    console.error('[entities:merge]', err.message);
+    res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
 // GET /entities/:name/memories — All memories linked to an entity
 entitiesRouter.get('/:name/memories', async (req, res) => {
   try {

api/src/routes/memory.js

@@ -454,6 +454,17 @@ memoryRouter.get('/search', async (req, res) => {
       finalResults = vectorResults.slice(0, maxResults);
     }
 
+    // Post-filter for temporal validity (at_time) — applies to ALL search paths
+    // Vector search already filters via Qdrant range query, but keyword/graph results bypass it
+    if (at_time) {
+      finalResults = finalResults.filter(r => {
+        const p = r.payload;
+        if (p.valid_from && p.valid_from > at_time) return false; // not yet valid
+        if (p.valid_to && p.valid_to <= at_time) return false;    // already expired
+        return true;
+      });
+    }
+
     // Apply confidence decay + access-weighted ranking + temporal boost
     const COMPACT_MAX = 200;
     const refDateForBoost = reference_date || at_time || null;
@@ -665,10 +676,10 @@ memoryRouter.get('/query', async (req, res) => {
       });
     }
 
-    const { type, source_agent, category, client_id, since, key, subject } = req.query;
+    const { type, source_agent, category, client_id, since, key, subject, limit } = req.query;
 
     let results;
-    const filters = { source_agent, category, client_id };
+    const filters = { source_agent, category, client_id, limit };
 
     if (type === 'fact' || type === 'facts') {
       if (key) filters.key = key;