cogmem 3.7.0 → 3.7.1

package/dist/factory.js

@@ -83,7 +83,7 @@ import { SqliteVecStore } from './store/SqliteVecStore.js';
 import { VectorStore } from './store/VectorStore.js';
 import { config } from './utils/Config.js';
 import { KernelRunningError, SnapshotExporter, SnapshotImporter, } from './snapshot/index.js';
-const CORE_VERSION = '3.7.0';
+const CORE_VERSION = '3.7.1';
 const LATEST_SCHEMA_VERSION = 27;
 export class MemoryKernel {
     options;
@@ -1056,6 +1056,7 @@ export class MemoryKernel {
         const affected = new Set();
         const before = {};
         const previousStatuses = new Map();
+        let requeuedDream = input.operation === 'requeue-dream' || input.operation === 'invalidate-dream-run';
         if (input.operation === 'move-event') {
             const link = this.episodeStore.getEventLink(input.eventId);
             const source = link ? this.episodeStore.getEpisode(link.episodeId) : undefined;
@@ -1169,11 +1170,30 @@ export class MemoryKernel {
             const episode = this.episodeStore.getEpisode(episodeId);
             if (episode?.eventCount && episode.status === 'sealed') {
                 this.episodeStore.requeueDreamForRepair(episodeId, input.operation === 'invalidate-dream-run' ? input.mode || 'normal' : 'normal', now);
+                requeuedDream = true;
             }
         }
         const after = Object.fromEntries([...affected].map((episodeId) => [episodeId, this.episodeStore.getEpisode(episodeId)]));
         const repairId = this.episodeStore.recordRepairAudit({ projectId: input.projectId, operation: input.operation, payload: input, before, after, now });
-        return { repairId, operation: input.operation, affectedEpisodeIds: [...affected], staleCandidateIds };
+        const affectedEpisodeIds = [...affected];
+        const nextCommands = affectedEpisodeIds.length
+            ? affectedEpisodeIds.map((episodeId) => `cogmem memory graph-reindex --project ${input.projectId} --episode ${episodeId} --json`)
+            : [];
+        return {
+            repairId,
+            applied: true,
+            operation: input.operation,
+            affectedEpisodeIds,
+            changedFields: changedFieldsForRepair(input),
+            staleCandidateIds,
+            requeuedDream,
+            graphRefreshNeeded: affectedEpisodeIds.length > 0,
+            nextCommands: [
+                ...nextCommands,
+                `cogmem memory graph-explore --project ${input.projectId} --query "<query>" --json`,
+            ],
+            note: 'repairId is an audit id, not a dream candidate id; do not run memory dream --promote just because repairId exists.',
+        };
     }
     listDreamCandidates(options = {}) {
         return this.deepWriteCandidateStore.listCandidates(options);
@@ -1265,6 +1285,9 @@ export class MemoryKernel {
     rebuildMemoryAtlas(options = {}) {
         return this.memoryAtlasIndexer.rebuild(options);
     }
+    reindexMemoryAtlas(options) {
+        return this.memoryAtlasIndexer.reindex(options);
+    }
     ensureMemoryAtlas(options) {
         return this.memoryAtlasIndexer.ensureFresh(options);
     }
@@ -2002,6 +2025,22 @@ export function createMemoryKernelFromConfig(input = {}) {
     const { configPath: _configPath, cwd: _cwd, env: _env, ...explicitOptions } = options;
     return createMemoryKernel({ ...loaded.options, ...explicitOptions });
 }
+function changedFieldsForRepair(input) {
+    if (input.operation === 'reclassify') {
+        return [
+            input.episodeType ? 'episodeType' : '',
+            input.topicPath ? 'topicPath' : '',
+            input.importance !== undefined ? 'importance' : '',
+        ].filter(Boolean);
+    }
+    if (input.operation === 'move-event')
+        return ['episodeEvents'];
+    if (input.operation === 'split' || input.operation === 'merge')
+        return ['episodeEvents', 'crossRefs'];
+    if (input.operation === 'requeue-dream' || input.operation === 'invalidate-dream-run')
+        return ['dreamQueue'];
+    return [];
+}
 function requiredGovernancePayloadString(payload, field) {
     const value = payload[field];
     if (typeof value !== 'string' || value.trim() === '')

package/dist/host/openclaw/AutoMemoryPluginInstaller.js

@@ -5,7 +5,7 @@ import { basename, dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { resolveCogmemConfigPath } from '../../config/CogmemConfig.js';
 const PLUGIN_ID = 'cogmem-auto-memory';
-const PLUGIN_VERSION = '0.7.0';
+const PLUGIN_VERSION = '0.7.1';
 function defaultPublicEntrypoint() {
     return join(resolve(dirname(fileURLToPath(import.meta.url)), '../..'), 'public.js');
 }
@@ -516,15 +516,29 @@ function createMemoryUsageReceipt(input) {
 
 function formatSourceAnchor(anchor) {
   return [
-    anchor.memoryId ? 'memory:' + anchor.memoryId : '',
-    anchor.eventId ? 'event:' + anchor.eventId : '',
-    anchor.sessionId ? 'session:' + anchor.sessionId : '',
-    anchor.role ? 'role:' + anchor.role : '',
+    anchor.memoryId ? 'memory:' + serializeUntrustedMemory(anchor.memoryId, 160) : '',
+    anchor.eventId ? 'event:' + serializeUntrustedMemory(anchor.eventId, 160) : '',
+    anchor.sessionId ? 'session:' + serializeUntrustedMemory(anchor.sessionId, 160) : '',
+    anchor.role ? 'role:' + serializeUntrustedMemory(anchor.role, 80) : '',
   ].filter(Boolean).join('; ');
 }
 
 function listLines(values) {
-  return values.length ? values.map((value) => '- ' + value) : ['- none'];
+  return values.length ? values.map((value) => '- ' + serializeUntrustedMemory(value, 260)) : ['- none'];
+}
+
+function serializeUntrustedMemory(input, limit) {
+  const clean = stripCogmemRecallBlocks(String(input || '')).text
+    .replace(new RegExp('</?COGMEM_[A-Z0-9_:-]+[^>]*>', 'gi'), '')
+    .replace(new RegExp('[\\\\u0000-\\\\u0008\\\\u000b\\\\u000c\\\\u000e-\\\\u001f\\\\u007f]', 'g'), ' ')
+    .replace(new RegExp('\\\\s+', 'g'), ' ')
+    .trim()
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+  return clean.slice(0, Math.max(0, Number(limit || 500)));
 }
 
 function clampBlock(text, closingTag, maxChars) {
@@ -535,14 +549,14 @@ function clampBlock(text, closingTag, maxChars) {
 
 function formatMemoryUsageBridge(receipt, maxChars) {
   const lines = [
-    '<COGMEM_TURN_BRIDGE turn_id="' + String(receipt.turnId).replace(/"/g, '&quot;') + '" source="cogmem" compact="true" ttl_turns="' + receipt.ttlTurns + '" compile_allowed="false">',
+    '<COGMEM_TURN_BRIDGE turn_id="' + serializeUntrustedMemory(receipt.turnId, 180) + '" source="cogmem" compact="true" ttl_turns="' + receipt.ttlTurns + '" compile_allowed="false">',
     'Previous assistant answer used Cogmem memory.',
     '',
     'Used memory themes:',
     ...listLines(receipt.usedThemes || []),
     '',
     'Working conclusion produced in that turn:',
-    '- ' + (receipt.workingConclusion || 'No compact conclusion recorded.'),
+    '- ' + serializeUntrustedMemory(receipt.workingConclusion || 'No compact conclusion recorded.', 260),
     '',
     'Source anchors:',
     ...listLines((receipt.sourceAnchors || []).map(formatSourceAnchor)),
@@ -608,7 +622,7 @@ function formatSessionWorkingState(state, maxChars) {
   const lines = [
     '<COGMEM_SESSION_STATE scope="current_session" compact="true" persistence="session_only" compile_allowed="false">',
     'Current working topic:',
-    '- ' + (state.currentTopic || 'unspecified'),
+    '- ' + serializeUntrustedMemory(state.currentTopic || 'unspecified', 180),
     '',
     'Current design direction:',
     ...listLines(state.designDirection || []),
@@ -663,6 +677,9 @@ function classifyRecallIntent(query) {
   if (/原话|怎么说的|完整对话|上一句|下一句|exact quote|verbatim/.test(text)) {
     return 'forensic_quote';
   }
+  if (/(让你.{0,20}(对|给|把)?.{0,20}(做过|做了|启动|安装|配置|修改|重启|停止|操作|处理|执行)|对.{0,30}(做过什么|做了什么|哪些操作)|what did (i ask you to do|you do) to|operations? on)/i.test(text)) {
+    return 'action_history';
+  }
   if (/记得.{0,12}(聊过|讨论过|说过)|还记得|之前.{0,12}(聊过|讨论过|说过)|以前.{0,12}(聊过|讨论过|说过)|(过去|几个月前|半年前|上个月|前几天|昨天|上次|上个).{0,20}(聊过|讨论过|说过)|当时.{0,12}(聊|说|问)|那次.{0,12}(聊|说|问)|有没有.{0,12}(记录|聊过|讨论过)|have we discussed|did we talk about|previously discussed/.test(text)) {
     return 'historical_discussion';
   }
@@ -1314,7 +1331,7 @@ async function recallPayload(input, config, kernel, memory, formatStrategyContex
   let result = await memory.recall({
     agentId: config.agentId || 'openclaw', projectId: config.projectId || 'openclaw',
     query: input.query || '', sessionId: input.sessionId, threadId: input.threadId,
-    excludeSessionId: input.excludeSessionId, intent: input.intent || 'memory_recall',
+    excludeSessionId: input.excludeSessionId, intent: input.intent || undefined,
     anchorEventId: input.anchorEventId, anchorText: input.anchorText,
     limit: Number(config.limit || 3), retrievalPolicy: strategyCapsule && strategyCapsule.retrievalPolicy,
   });
@@ -1327,7 +1344,7 @@ async function recallPayload(input, config, kernel, memory, formatStrategyContex
     result = await memory.recall({
       agentId: config.agentId || 'openclaw', projectId: config.projectId || 'openclaw',
       query: input.query || '', sessionId: input.sessionId, threadId: input.threadId,
-      excludeSessionId: input.excludeSessionId, intent: input.intent || 'memory_recall',
+      excludeSessionId: input.excludeSessionId, intent: input.intent || undefined,
       anchorEventId: input.anchorEventId, anchorText: input.anchorText,
       limit: Number(config.limit || 3), retrievalPolicy: strategyCapsule && strategyCapsule.retrievalPolicy,
     });
@@ -1368,7 +1385,7 @@ async function recallPayload(input, config, kernel, memory, formatStrategyContex
   return {
     context: recallContext ? (strategyCapsule ? formatStrategyContext(strategyCapsule) + '\n\n' : '') + recallContext : '',
     items: compactRecallItems(plannedResult.items, config), itemCount: plannedResult.items.length,
-    recallMode: result.recallMode, fallbackUsed: result.fallbackUsed, intent: input.intent || 'memory_recall',
+    recallMode: result.recallMode, fallbackUsed: result.fallbackUsed, intent: (result.queryPlan && result.queryPlan.intent) || input.intent || 'memory_recall',
     anchorEventId: anchorItem && anchorItem.sourceAnchor && anchorItem.sourceAnchor.eventId,
     anchorText: anchorItem && anchorItem.text, queryPlan: result.queryPlan, decisionTrace: result.decisionTrace,
     atlasCards: result.atlasCards, selectedEpisodeCards,
@@ -1470,10 +1487,20 @@ function formatAtlasContext(result, maxChars) {
 }
 
 function safeAtlasText(input, limit) {
+  return serializeUntrustedMemory(input, limit);
+}
+
+function serializeUntrustedMemory(input, limit) {
   const clean = stripCogmemRecallBlocks(String(input || '')).text
-    .replace(/[<>]/g, (value) => value === '<' ? '\\u003c' : '\\u003e')
+    .replace(/<\/?COGMEM_[A-Z0-9_:-]+[^>]*>/gi, '')
+    .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, ' ')
     .replace(/\s+/g, ' ')
-    .trim();
+    .trim()
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
   return clean.slice(0, Math.max(0, Number(limit || 500)));
 }
 
@@ -1773,43 +1800,43 @@ function formatRecallContext(result, config) {
     lines.push('selectedMemoryCards=' + result.atlasCards.slice(0, Number(config.memoryContextMaxItems || config.limit || 3)).map(formatAtlasCard).join(' | '));
   }
   if (Array.isArray(result.relaxationTrace) && result.relaxationTrace.length) {
-    lines.push('relaxationTrace=' + result.relaxationTrace.map((step) => step.from + ' -> ' + step.to + ' (' + step.reason + ')').join(' | '));
+    lines.push('relaxationTrace=' + result.relaxationTrace.map((step) => serializeUntrustedMemory(step.from, 80) + ' -> ' + serializeUntrustedMemory(step.to, 80) + ' (' + serializeUntrustedMemory(step.reason, 160) + ')').join(' | '));
   }
   if (Array.isArray(result.relatedButNotSelected) && result.relatedButNotSelected.length) {
-    lines.push('relatedButNotSelected=' + result.relatedButNotSelected.slice(0, 4).map((item) => item.displayTitle + ' [' + item.reason + ']').join(' | '));
+    lines.push('relatedButNotSelected=' + result.relatedButNotSelected.slice(0, 4).map((item) => serializeUntrustedMemory(item.displayTitle, 160) + ' [' + serializeUntrustedMemory(item.reason, 160) + ']').join(' | '));
   }
   lines.push('');
   if (result.narrative && result.narrative.summary) {
-    lines.push(result.narrative.summary);
+    lines.push(serializeUntrustedMemory(result.narrative.summary, 800));
   }
   const maxItems = Number(config.memoryContextMaxItems || config.limit || 3);
   const sourceWindowMaxChars = Number(config.sourceWindowMaxChars || 1200);
   const includeSourceWindow = config.includeSourceWindowByDefault === true;
   for (const item of result.items.slice(0, maxItems)) {
-    const source = item.source ? ' [' + item.source + ']' : '';
-    lines.push('- ' + item.text + source);
+    const source = item.source ? ' [' + serializeUntrustedMemory(item.source, 220) + ']' : '';
+    lines.push('- ' + serializeUntrustedMemory(item.text, 500) + source);
     const sourceType = item.sourceType || 'compiled_memory';
     const quote = item.canAnswerExactQuote === true ? 'true' : 'false';
     const confidence = Number.isFinite(item.confidence) ? String(item.confidence) : 'unknown';
-    const anchor = item.sourceAnchor ? '; anchorEvent=' + (item.sourceAnchor.eventId || 'unknown')
-      + (item.sourceAnchor.sessionId ? '; session=' + item.sourceAnchor.sessionId : '')
-      + (item.sourceAnchor.role ? '; role=' + item.sourceAnchor.role : '') : '';
-    const why = item.whyMatched ? '; whyMatched=' + item.whyMatched : '';
-    const canonical = item.canonicalId ? '; canonicalId=' + item.canonicalId : '';
+    const anchor = item.sourceAnchor ? '; anchorEvent=' + serializeUntrustedMemory(item.sourceAnchor.eventId || 'unknown', 160)
+      + (item.sourceAnchor.sessionId ? '; session=' + serializeUntrustedMemory(item.sourceAnchor.sessionId, 160) : '')
+      + (item.sourceAnchor.role ? '; role=' + serializeUntrustedMemory(item.sourceAnchor.role, 80) : '') : '';
+    const why = item.whyMatched ? '; whyMatched=' + serializeUntrustedMemory(item.whyMatched, 180) : '';
+    const canonical = item.canonicalId ? '; canonicalId=' + serializeUntrustedMemory(item.canonicalId, 180) : '';
     const matchedFacets = Array.isArray(item.matchedFacets) && item.matchedFacets.length
-      ? '; matchedFacets=' + item.matchedFacets.map((facet) => facet.type + ':' + facet.value).join(',')
+      ? '; matchedFacets=' + item.matchedFacets.map((facet) => serializeUntrustedMemory(facet.type, 80) + ':' + serializeUntrustedMemory(facet.value, 160)).join(',')
       : '';
-    lines.push('  sourceType=' + sourceType + '; confidence=' + confidence + '; canAnswerExactQuote=' + quote + canonical + matchedFacets + anchor + why);
+    lines.push('  sourceType=' + serializeUntrustedMemory(sourceType, 120) + '; confidence=' + confidence + '; canAnswerExactQuote=' + quote + canonical + matchedFacets + anchor + why);
     if (item.sourceContext && item.sourceContext.event) {
       const anchorEvent = item.sourceContext.event;
       const anchorFormatted = formatContextEvent(anchorEvent, Math.min(220, sourceWindowMaxChars));
       lines.push('  sourceContext=' + anchorFormatted.line);
       lines.push('  sourceWindow=' + formatSourceWindow(item.sourceContext.window, item.sourceContext));
       if (item.sourceContext.locator && item.sourceContext.locator.command) {
-        lines.push('  sourceLocator=' + item.sourceContext.locator.command);
+        lines.push('  sourceLocator=' + serializeUntrustedMemory(item.sourceContext.locator.command, 500));
       } else if (item.sourceContext.event.eventId) {
         const project = item.sourceContext.event.projectId ? ' --project ' + item.sourceContext.event.projectId : '';
-        lines.push('  sourceLocator=cogmem memory show --event ' + item.sourceContext.event.eventId + project + ' --before 2 --after 2 --json');
+        lines.push('  sourceLocator=' + serializeUntrustedMemory('cogmem memory show --event ' + item.sourceContext.event.eventId + project + ' --before 2 --after 2 --json', 500));
       }
       const seenEventIds = new Set([anchorEvent.eventId].filter(Boolean));
       const before = uniqueWindowEvents(Array.isArray(item.sourceContext.before) ? item.sourceContext.before : [], seenEventIds).slice(-2);
@@ -1854,16 +1881,16 @@ function formatRecallDecision(trace) {
 
 function formatAtlasCard(card) {
   const facets = Array.isArray(card && card.matchedFacets)
-    ? card.matchedFacets.map((facet) => facet.type + ':' + facet.value).join(',')
+    ? card.matchedFacets.map((facet) => serializeUntrustedMemory(facet.type, 80) + ':' + serializeUntrustedMemory(facet.value, 160)).join(',')
     : '';
   const paths = Array.isArray(card && card.matchedPaths)
-    ? card.matchedPaths.map((path) => path.relation + '@' + (path.facet && path.facet.nodeId || 'facet')).slice(0, 6).join(',')
+    ? card.matchedPaths.map((path) => serializeUntrustedMemory(path.relation, 80) + '@' + serializeUntrustedMemory(path.facet && path.facet.nodeId || 'facet', 180)).slice(0, 6).join(',')
     : '';
-  const locator = card && card.sourceLocator && card.sourceLocator.command ? '; sourceLocator=' + card.sourceLocator.command : '';
-  const why = card && card.whyMatched ? '; whyMatched=' + truncateLineWithMeta(card.whyMatched, 180).text : '';
-  return (card && card.canonicalId || 'episode:unknown')
-    + '; title=' + truncateLineWithMeta(card && card.displayTitle, 120).text
-    + '; summary=' + truncateLineWithMeta(card && card.oneLineSummary, 180).text
+  const locator = card && card.sourceLocator && card.sourceLocator.command ? '; sourceLocator=' + serializeUntrustedMemory(card.sourceLocator.command, 500) : '';
+  const why = card && card.whyMatched ? '; whyMatched=' + serializeUntrustedMemory(card.whyMatched, 180) : '';
+  return serializeUntrustedMemory(card && card.canonicalId || 'episode:unknown', 180)
+    + '; title=' + serializeUntrustedMemory(card && card.displayTitle, 120)
+    + '; summary=' + serializeUntrustedMemory(card && card.oneLineSummary, 180)
     + (facets ? '; matchedFacets=' + facets : '')
     + (paths ? '; matchedPaths=' + paths : '')
     + why
@@ -1878,10 +1905,10 @@ function clampRecallContext(text, maxChars) {
 }
 
 function formatContextEvent(event, limit) {
-  const truncation = truncateLineWithMeta(event && event.text, limit);
-  const label = contextEventLabel(event);
-  const role = event && event.role ? event.role : 'unknown';
-  const eventId = event && event.eventId ? event.eventId : 'unknown';
+  const truncation = truncateLineWithMeta(serializeUntrustedMemory(event && event.text, limit), limit);
+  const label = serializeUntrustedMemory(contextEventLabel(event), 120);
+  const role = serializeUntrustedMemory(event && event.role ? event.role : 'unknown', 80);
+  const eventId = serializeUntrustedMemory(event && event.eventId ? event.eventId : 'unknown', 160);
   const charRange = event && event.charRange ? '; charRange=' + event.charRange.start + '-' + event.charRange.end : '';
   const sourceRange = formatSourceRange(event && event.sourceRange);
   const textLength = Number.isFinite(event && event.textLength) ? event.textLength : truncation.originalChars;
@@ -1903,17 +1930,17 @@ function formatSourceWindow(window, context) {
   const dropped = Array.isArray(window && window.droppedOverlapEventIds) ? window.droppedOverlapEventIds : [];
   return 'before=' + formatWindowSide(before)
     + '; after=' + formatWindowSide(after)
-    + '; overlap=' + (overlapEventIds.length ? overlapEventIds.join(',') : 'none')
-    + '; droppedOverlap=' + (dropped.length ? dropped.join(',') : 'none')
-    + '; overlapHandling=' + ((window && window.overlapHandling) || 'drop_from_after');
+    + '; overlap=' + (overlapEventIds.length ? overlapEventIds.map((id) => serializeUntrustedMemory(id, 120)).join(',') : 'none')
+    + '; droppedOverlap=' + (dropped.length ? dropped.map((id) => serializeUntrustedMemory(id, 120)).join(',') : 'none')
+    + '; overlapHandling=' + serializeUntrustedMemory((window && window.overlapHandling) || 'drop_from_after', 120);
 }
 
 function formatWindowSide(side) {
   return 'requestedCount=' + Number(side.requestedCount || 0)
     + ', count=' + Number(side.count || 0)
     + ', excludesAnchor=' + (side.excludesAnchor !== false)
-    + ', ordering=' + (side.ordering || 'chronological')
-    + ', roleFilter=' + (side.roleFilter || 'all');
+    + ', ordering=' + serializeUntrustedMemory(side.ordering || 'chronological', 80)
+    + ', roleFilter=' + serializeUntrustedMemory(side.roleFilter || 'all', 80);
 }
 
 function uniqueWindowEvents(events, seenEventIds) {

package/dist/mcp/server.js

@@ -5,7 +5,7 @@ import { callCogmemMcpTool, listCogmemMcpTools, } from './CoreMcpTools.js';
 export function createCogmemMcpServer(runtime = {}) {
     const server = new Server({
         name: 'cogmem-core',
-        version: '3.7.0',
+        version: '3.7.1',
     }, {
         capabilities: {
             tools: {},

package/dist/recall/RecallExplanation.d.ts

@@ -44,7 +44,7 @@ export interface RecallExplanation {
     projectId?: string;
     agentId?: string;
     collection?: string;
-    recallMode: MemoryKernelNavigationResult['recallMode'] | 'raw_ledger_fallback';
+    recallMode: MemoryKernelNavigationResult['recallMode'] | 'raw_ledger_fallback' | 'atlas_facet_recall' | 'atlas_raw_grounded_recall';
     fallbackUsed: boolean;
     narrative?: NonNullable<MemoryKernelNavigationResult['navigation']>['narrative'];
     pulseTrace?: NonNullable<MemoryKernelNavigationResult['navigation']>['pulse']['trace'];

package/dist/store/MemoryAtlasStore.d.ts

@@ -2,7 +2,7 @@ import type Database from 'bun:sqlite';
 import type { FacetQueryPlan } from '../atlas/FacetQueryPlanner.js';
 import type { MemoryAtlasAction, MemoryAtlasCard, MemoryAtlasEdge, MemoryAtlasNode, MemoryAtlasRelatedCard } from '../atlas/MemoryAtlasTypes.js';
 export declare const MEMORY_ATLAS_PROJECTION_NAME = "memory_atlas.v2";
-export declare const MEMORY_ATLAS_PROJECTION_SCHEMA_VERSION = "3.7.0";
+export declare const MEMORY_ATLAS_PROJECTION_SCHEMA_VERSION = "3.7.2";
 export declare class MemoryAtlasStore {
     readonly db: Database;
     constructor(db: Database);
@@ -52,6 +52,8 @@ export declare class MemoryAtlasStore {
     decay(projectId?: string, factor?: number, now?: number): number;
     projectionNeedsRefresh(projectId: string): boolean;
     markProjectionClean(projectId: string, metadata?: Record<string, unknown>, now?: number): void;
+    markProjectionDirty(projectId: string, metadata?: Record<string, unknown>, now?: number): void;
+    aggregateFacetNodeSupport(projectId: string, now?: number): void;
     markProjectionFailed(projectId: string, error: string, now?: number): void;
     getProjectionState(projectId: string): {
         status: string;

package/dist/store/MemoryAtlasStore.js

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from 'node:crypto';
 export const MEMORY_ATLAS_PROJECTION_NAME = 'memory_atlas.v2';
-export const MEMORY_ATLAS_PROJECTION_SCHEMA_VERSION = '3.7.0';
+export const MEMORY_ATLAS_PROJECTION_SCHEMA_VERSION = '3.7.2';
 export class MemoryAtlasStore {
     db;
     constructor(db) {
@@ -23,12 +23,13 @@ export class MemoryAtlasStore {
         this.refreshFtsNode(input.id);
     }
     getNode(nodeId, projectId) {
+        const scopedNodeId = scopedEntityNodeId(this.db, nodeId, projectId);
         const row = this.db.prepare(`
       SELECT d.*, COALESCE(a.activation, 0) AS activation
       FROM memory_atlas_documents d LEFT JOIN memory_atlas_activation a
         ON a.project_id=d.project_id AND a.node_id=d.node_id
       WHERE d.node_id=? AND d.project_id=?
-    `).get(nodeId, projectId);
+    `).get(scopedNodeId, projectId);
         return row ? mapNode(row, 0) : null;
     }
     listNodes(projectId, limit) {
@@ -89,23 +90,25 @@ export class MemoryAtlasStore {
         if (!plannedFacets.length)
             return [];
         const facetMatches = plannedFacets.map((facet) => ({ facet, rows: this.episodeEdgesForFacet(projectId, facet) }));
-        if (plan.operator === 'intersection' && facetMatches.some((match) => match.rows.length === 0))
+        const facetGroups = groupFacetMatches(facetMatches);
+        if (plan.operator === 'intersection' && facetGroups.some((group) => group.every((match) => match.rows.length === 0)))
             return [];
         const candidateIds = plan.operator === 'intersection'
-            ? intersectSets(facetMatches.map((match) => new Set(match.rows.map((row) => row.source_id))))
+            ? intersectSets(facetGroups.map((group) => new Set(group.flatMap((match) => match.rows.map((row) => row.source_id)))))
             : new Set(facetMatches.flatMap((match) => match.rows.map((row) => row.source_id)));
         if (!candidateIds.size)
             return [];
         const rows = this.episodeRows(projectId, Array.from(candidateIds));
-        const cards = rows.map((row) => {
+        const rankedCards = rows.map((row) => {
             const candidateEdges = facetMatches.flatMap((match) => match.rows.filter((edge) => edge.source_id === row.source_id));
             return this.cardFromEpisodeRow(row, candidateEdges, projectId);
-        });
+        }).sort((left, right) => cardRank(right) - cardRank(left) || left.canonicalId.localeCompare(right.canonicalId));
+        const cards = dedupeCardsByEvidence(rankedCards).slice(0, Math.max(1, Math.min(limit, 100)));
         const selectedIds = new Set(cards.map((card) => card.canonicalId));
         for (const card of cards) {
-            card.relatedButNotSelected = mergeRelatedCards(this.relatedEpisodeCards(projectId, card.canonicalId, selectedIds, 4), this.topicRelatedCardsForPlan(projectId, plan, selectedIds, 4)).slice(0, 4);
+            card.relatedButNotSelected = mergeRelatedCards(card.relatedButNotSelected ?? [], this.relatedEpisodeCards(projectId, card.canonicalId, selectedIds, 4), this.topicRelatedCardsForPlan(projectId, plan, selectedIds, 4)).slice(0, 4);
         }
-        return cards.sort((left, right) => scoreCard(right) - scoreCard(left)).slice(0, Math.max(1, Math.min(limit, 100)));
+        return cards;
     }
     relatedEpisodeCards(projectId, canonicalId, selectedIds, limit) {
         const parsed = parseNodeId(canonicalId, projectId);
@@ -483,6 +486,47 @@ export class MemoryAtlasStore {
         last_error=NULL, metadata_json=excluded.metadata_json
     `).run(projectId, String(now), now, JSON.stringify({ compatibilityAliasFor: MEMORY_ATLAS_PROJECTION_NAME }));
     }
+    markProjectionDirty(projectId, metadata = {}, now = Date.now()) {
+        this.db.prepare(`
+      INSERT INTO memory_atlas_projection_state(project_id,projection_name,cursor_value,status,last_rebuild_at,last_error,metadata_json)
+      VALUES(?, ?, NULL, 'dirty', ?, NULL, ?)
+      ON CONFLICT(project_id,projection_name) DO UPDATE SET
+        status='dirty', cursor_value=NULL, last_error=NULL, metadata_json=excluded.metadata_json
+    `).run(projectId, MEMORY_ATLAS_PROJECTION_NAME, now, JSON.stringify({
+            ...metadata,
+            projectionName: MEMORY_ATLAS_PROJECTION_NAME,
+            projectionSchemaVersion: MEMORY_ATLAS_PROJECTION_SCHEMA_VERSION,
+        }));
+        this.db.prepare(`
+      INSERT INTO memory_atlas_projection_state(project_id,projection_name,cursor_value,status,last_rebuild_at,last_error,metadata_json)
+      VALUES(?, 'memory_atlas.v1', NULL, 'dirty', ?, NULL, ?)
+      ON CONFLICT(project_id,projection_name) DO UPDATE SET status='dirty', cursor_value=NULL, last_error=NULL, metadata_json=excluded.metadata_json
+    `).run(projectId, now, JSON.stringify({ compatibilityAliasFor: MEMORY_ATLAS_PROJECTION_NAME, dirtyBecause: 'atlas_v2_targeted_reindex' }));
+    }
+    aggregateFacetNodeSupport(projectId, now = Date.now()) {
+        const rows = this.db.prepare(`
+      SELECT target_type,target_id,evidence_event_ids_json
+      FROM memory_edges
+      WHERE project_id=? AND source_type='episode'
+        AND target_type IN ('topic','time','issue','entity','session','thread','memoryKind','actionKind')
+        AND status IN ('active','weak')
+      ORDER BY target_type,target_id
+    `).all(projectId);
+        const buckets = new Map();
+        for (const row of rows) {
+            const id = nodeId(row.target_type, row.target_id, projectId);
+            const bucket = buckets.get(id) ?? { count: 0, evidence: new Set() };
+            bucket.count += 1;
+            for (const eventId of parseStringArray(row.evidence_event_ids_json).slice(0, 5))
+                bucket.evidence.add(eventId);
+            buckets.set(id, bucket);
+        }
+        const update = this.db.prepare(`UPDATE memory_atlas_documents SET support_count=?, evidence_event_ids_json=?, updated_at=? WHERE project_id=? AND node_id=?`);
+        for (const [nodeIdValue, bucket] of buckets) {
+            update.run(bucket.count, JSON.stringify(Array.from(bucket.evidence).slice(0, 100)), now, projectId, nodeIdValue);
+            this.refreshFtsNode(nodeIdValue);
+        }
+    }
     markProjectionFailed(projectId, error, now = Date.now()) {
         this.db.prepare(`
       INSERT INTO memory_atlas_projection_state(project_id,projection_name,status,last_rebuild_at,last_error,metadata_json)
@@ -547,16 +591,22 @@ export class MemoryAtlasStore {
     `).all(...params);
     }
     episodeRows(projectId, episodeIds) {
-        const bounded = Array.from(new Set(episodeIds)).slice(0, 500);
-        if (!bounded.length)
-            return [];
-        return this.db.prepare(`
-      SELECT d.*, COALESCE(a.activation, 0) AS activation
-      FROM memory_atlas_documents d LEFT JOIN memory_atlas_activation a
-        ON a.project_id=d.project_id AND a.node_id=d.node_id
-      WHERE d.project_id=? AND d.node_id IN (${bounded.map(() => '?').join(',')})
-        AND d.node_type='episode' AND d.status NOT IN ('rejected','archived')
-    `).all(projectId, ...bounded.map((id) => `episode:${id}`));
+        const ids = Array.from(new Set(episodeIds));
+        const rows = [];
+        for (let index = 0; index < ids.length; index += 400) {
+            const chunk = ids.slice(index, index + 400);
+            if (!chunk.length)
+                continue;
+            rows.push(...this.db.prepare(`
+        SELECT d.*, COALESCE(a.activation, 0) AS activation
+        FROM memory_atlas_documents d LEFT JOIN memory_atlas_activation a
+          ON a.project_id=d.project_id AND a.node_id=d.node_id
+        WHERE d.project_id=? AND d.node_id IN (${chunk.map(() => '?').join(',')})
+          AND d.node_type='episode' AND d.status NOT IN ('rejected','archived')
+        ORDER BY d.occurred_at DESC, d.support_count DESC, d.node_id ASC
+      `).all(projectId, ...chunk.map((id) => `episode:${id}`)));
+        }
+        return rows;
     }
     cardFromEpisodeRow(row, edges, projectId) {
         const metadata = parseMetadata(row.metadata_json);
@@ -568,6 +618,7 @@ export class MemoryAtlasStore {
         });
         const issueHints = stringArray(metadata.issueHints);
         const topicHints = stringArray(metadata.topicHints);
+        const matchedTopicPaths = matchedFacets.filter((facet) => facet.type === 'topic').map((facet) => facet.value);
         return {
             canonicalId: row.node_id,
             nodeType: 'episode',
@@ -575,7 +626,7 @@ export class MemoryAtlasStore {
             oneLineSummary: row.summary || undefined,
             matchedFacets,
             matchedPaths,
-            parentTopics: topicHints.length ? topicHints : row.topic_path ? [row.topic_path] : [],
+            parentTopics: matchedTopicPaths.length ? matchedTopicPaths : topicHints.length ? topicHints : row.topic_path ? [row.topic_path] : [],
             issueType: issueHints[0],
             eventKind: optionalMetadataString(metadata.eventKind),
             localDate: optionalMetadataString(metadata.localDate) ?? (row.occurred_at ? new Date(row.occurred_at).toISOString().slice(0, 10) : undefined),
@@ -629,6 +680,8 @@ catch {
 } }
 function escapeLike(value) { return value.replace(/[\\%_]/g, '\\$&'); }
 function nodeId(type, id, projectId) {
+    if (type === 'entity')
+        return id.startsWith('facet:') ? `entity:${projectId}:${id}` : `entity:${id}`;
     if (['topic', 'time', 'issue', 'session', 'thread', 'memoryKind', 'actionKind'].includes(type))
         return `${type}:${projectId}:${id}`;
     return `${type}:${id}`;
@@ -636,8 +689,18 @@ function nodeId(type, id, projectId) {
 function timeNodeId(projectId, occurredAt) {
     return `time:${projectId}:${new Date(occurredAt).getUTCFullYear()}`;
 }
+function scopedEntityNodeId(db, value, projectId) {
+    if (!value.startsWith('entity:') || value.startsWith(`entity:${projectId}:`))
+        return value;
+    const id = value.slice('entity:'.length);
+    if (!id.startsWith('facet:'))
+        return value;
+    const scoped = `entity:${projectId}:${id}`;
+    const row = db.prepare(`SELECT 1 FROM memory_atlas_documents WHERE project_id=? AND node_id=?`).get(projectId, scoped);
+    return row ? scoped : value;
+}
 function parseNodeId(value, projectId) {
-    for (const type of ['topic', 'time', 'issue', 'session', 'thread', 'memoryKind', 'actionKind']) {
+    for (const type of ['topic', 'time', 'issue', 'entity', 'session', 'thread', 'memoryKind', 'actionKind']) {
         const prefix = `${type}:${projectId}:`;
         if (value.startsWith(prefix))
             return { type, id: value.slice(prefix.length) };
@@ -686,6 +749,29 @@ function facetLabel(type, value) {
     }
     return value;
 }
+function groupFacetMatches(matches) {
+    const groups = new Map();
+    for (const match of matches) {
+        const targetSlug = equivalentTargetSlug(match.facet);
+        const key = targetSlug
+            ? `target:${targetSlug}`
+            : match.facet.type === 'actionKind' || match.facet.type === 'memoryKind'
+                ? `${match.facet.type}:${match.facet.relation || ''}`
+                : `${match.facet.type}:${match.facet.value}:${match.facet.relation || ''}`;
+        const group = groups.get(key) ?? [];
+        group.push(match);
+        groups.set(key, group);
+    }
+    return Array.from(groups.values());
+}
+function equivalentTargetSlug(facet) {
+    if (facet.type === 'entity' && facet.value.startsWith('facet:'))
+        return facet.value.slice('facet:'.length);
+    if (facet.type !== 'topic')
+        return undefined;
+    const match = facet.value.match(/^PROJECT\/[^/]+\/([^/]+)$/u);
+    return match?.[1];
+}
 function intersectSets(sets) {
     if (!sets.length)
         return new Set();
@@ -697,12 +783,50 @@ function intersectSets(sets) {
     }
     return result;
 }
+function cardRank(card) {
+    return scoreCard(card) + Math.min(card.evidenceTotal || 0, 10) * 0.01;
+}
 function scoreCard(card) {
-    const issuePriority = card.issueType === 'memory-context-blackbox' ? 4
-        : card.issueType === 'graph-runtime-blackbox' ? 2
-            : card.issueType === 'atlas-readability' ? 1
-                : 0;
-    return card.matchedFacets.length * 10 + issuePriority + card.matchedPaths.reduce((sum, path) => sum + path.confidence, 0) + (card.localDate ? 0.1 : 0);
+    return card.matchedFacets.length * 10 + card.matchedPaths.reduce((sum, path) => sum + path.confidence, 0) + (card.localDate ? 0.1 : 0);
+}
+function dedupeCardsByEvidence(cards) {
+    const bySignature = new Map();
+    const out = [];
+    for (const card of cards) {
+        const signature = evidenceSignature(card);
+        if (!signature) {
+            out.push(card);
+            continue;
+        }
+        const kept = bySignature.get(signature);
+        if (!kept) {
+            bySignature.set(signature, card);
+            out.push(card);
+            continue;
+        }
+        kept.relatedButNotSelected = mergeRelatedCards(kept.relatedButNotSelected ?? [], [{
+                canonicalId: card.canonicalId,
+                displayTitle: card.displayTitle,
+                reason: 'same primary raw evidence',
+            }]);
+    }
+    return out;
+}
+function evidenceSignature(card) {
+    const primary = card.sourceLocator?.eventId || card.evidenceEventIds[0];
+    if (!primary)
+        return undefined;
+    const facets = (type) => card.matchedFacets
+        .filter((facet) => facet.type === type)
+        .map((facet) => facet.value)
+        .sort()
+        .join(',');
+    return [
+        primary,
+        card.localDate || '',
+        facets('entity'),
+        facets('actionKind'),
+    ].join('|');
 }
 function mergeRelatedCards(...groups) {
     const merged = new Map();