cogmem 3.7.0 → 3.7.2

package/dist/atlas/FacetQueryPlanner.js

@@ -1,3 +1,5 @@
+import { extractEntityCues } from '../utils/EntityCueExtractor.js';
+import { ACTION_KIND_RULES } from '../utils/ActionKindRegistry.js';
 const ISSUE_RULES = [
     {
         value: 'memory-context-blackbox',
@@ -29,7 +31,7 @@ const TOPIC_RULES = [
     {
         value: 'source-drilldown',
         label: '原文下钻',
-        test: (text) => /(sourcecontext|source context|原文下钻|原话|摘要.*原文)/i.test(text),
+        test: (text) => /(sourcecontext|source context|原文下钻|摘要.*原文)/i.test(text),
     },
     {
         value: 'context-injection',
@@ -41,7 +43,8 @@ export class FacetQueryPlanner {
     plan(query, options) {
         const normalized = query.trim();
         const facets = [];
-        const timeFacet = parseTimeFacet(normalized, options.now ?? Date.now());
+        const actionHistory = isActionHistoryQuery(normalized);
+        const timeFacet = parseTimeFacet(normalized, options);
         if (timeFacet)
             facets.push(withNodeId(timeFacet, options.projectId));
         const timeline = /(后来|继续|timeline|演化|发展|之后)/i.test(normalized);
@@ -60,15 +63,23 @@ export class FacetQueryPlanner {
         if (!timeline && isBroadMemoryBlackbox(normalized) && matchedIssueValues.size === 0) {
             facets.push(withNodeId({ type: 'issue', value: 'memory-context-blackbox', label: 'Memory Context 黑盒', relation: 'PART_OF_ISSUE' }, options.projectId));
         }
-        for (const entity of ['Cogmem', 'OpenClaw', 'Hermes']) {
-            if (new RegExp(entity, 'i').test(normalized)) {
-                facets.push({ type: 'entity', value: `facet:${entity.toLowerCase()}`, label: entity, nodeId: `entity:facet:${entity.toLowerCase()}`, relation: 'INVOLVES_ENTITY' });
+        for (const entity of extractEntityCues(normalized)) {
+            if (!actionHistory && isConceptFacetEntity(entity, facets))
+                continue;
+            facets.push({ type: 'entity', value: `facet:${entity.id}`, label: entity.label, nodeId: `entity:${options.projectId}:facet:${entity.id}`, relation: 'INVOLVES_ENTITY' });
+            if (actionHistory) {
+                facets.push(withNodeId({ type: 'topic', value: `PROJECT/${options.projectId}/${entity.id}`, label: entity.label, relation: 'ABOUT_TOPIC' }, options.projectId));
             }
         }
         for (const facet of parseKindFacets(normalized, options.projectId))
             facets.push(facet);
+        if (actionHistory && (!facets.some((facet) => facet.type === 'actionKind') || !hasSpecificActionCue(normalized))) {
+            for (const value of ['started', 'installed', 'configured', 'restarted', 'stopped', 'operated', 'implemented', 'debugged']) {
+                facets.push(withNodeId({ type: 'actionKind', value, label: value, relation: 'HAS_ACTION_KIND' }, options.projectId));
+            }
+        }
         return {
-            intent: /聊过|记得|还记得|讨论|原话|那次/i.test(normalized) ? 'historical_discussion' : 'graph_search',
+            intent: actionHistory ? 'action_history' : /聊过|记得|还记得|讨论|原话|那次/i.test(normalized) ? 'historical_discussion' : 'graph_search',
             operator: 'intersection',
             facets: dedupeFacets(facets),
             temporalIntent: timeline ? 'timeline' : undefined,
@@ -80,10 +91,26 @@ export class FacetQueryPlanner {
         };
     }
 }
+function isActionHistoryQuery(query) {
+    return /(让你.{0,20}(对|给|把)?.{0,20}(做过|做了|启动|安装|配置|修改|重启|停止|操作|处理|执行)|对.{0,30}(做过什么|做了什么|哪些操作)|what did (i ask you to do|you do) to|operations? on)/i.test(query);
+}
+function hasSpecificActionCue(query) {
+    return /(启动|start|started|launch|launched|boot|安装|install|installed|setup|配置|config|configured|设置|修改配置|重启|restart|停止|stop|修复|实现|implemented|review|审查|debug|排查|卡死|locked|zombie)/i.test(query);
+}
 function isBroadMemoryBlackbox(query) {
     return /(记忆黑盒|memory.*blackbox)/i.test(query) &&
         !/(memory graph|graph|database locked|sqlite|zombie|僵尸|卡死|atlas|图谱|节点|事件名称|自动注入|before_prompt_build|manual recall|手动.*recall)/i.test(query);
 }
+function isConceptFacetEntity(entity, facets) {
+    const label = entity.label.toLocaleLowerCase();
+    return facets.some((facet) => {
+        if (facet.type !== 'topic' && facet.type !== 'issue')
+            return false;
+        const facetLabel = facet.label.toLocaleLowerCase();
+        const facetSlug = facet.value.split('/').pop()?.toLocaleLowerCase();
+        return label === facetLabel || label.includes(facetLabel) || Boolean(facetSlug && entity.id === facetSlug);
+    });
+}
 function parseKindFacets(query, projectId) {
     const facets = [];
     const memoryKindRules = [
@@ -91,23 +118,18 @@ function parseKindFacets(query, projectId) {
         ['decision', /(decision|决定|方案|结论)/i],
         ['plan', /(计划|下一步|策略|plan)/i],
     ];
-    const actionKindRules = [
-        ['implemented', /(修复|实现|implemented|合并|发布|升级)/i],
-        ['reviewed', /(检查|审查|review)/i],
-        ['debugged', /(debug|排查|卡死|locked|zombie)/i],
-    ];
     for (const [value, test] of memoryKindRules) {
         if (test.test(query))
             facets.push(withNodeId({ type: 'memoryKind', value, label: value, relation: 'HAS_MEMORY_KIND' }, projectId));
     }
-    for (const [value, test] of actionKindRules) {
-        if (test.test(query))
-            facets.push(withNodeId({ type: 'actionKind', value, label: value, relation: 'HAS_ACTION_KIND' }, projectId));
+    for (const rule of ACTION_KIND_RULES) {
+        if (rule.pattern.test(query))
+            facets.push(withNodeId({ type: 'actionKind', value: rule.kind, label: rule.kind, relation: 'HAS_ACTION_KIND' }, projectId));
     }
     return facets;
 }
-function parseTimeFacet(query, now) {
-    const currentYear = new Date(now).getUTCFullYear();
+function parseTimeFacet(query, options) {
+    const currentYear = localYear(options);
     const isoDay = query.match(/(20\d{2})[-年\/.](\d{1,2})[-月\/.](\d{1,2})日?/);
     if (isoDay)
         return dayFacet(Number(isoDay[1]), Number(isoDay[2]), Number(isoDay[3]));
@@ -124,6 +146,25 @@ function parseTimeFacet(query, now) {
         return yearFacet(currentYear - 1);
     return undefined;
 }
+function localYear(options) {
+    const explicit = options.localDateNow?.match(/^(20\d{2})-\d{2}-\d{2}$/u)?.[1];
+    if (explicit)
+        return Number(explicit);
+    const now = options.now ?? Date.now();
+    try {
+        const parts = new Intl.DateTimeFormat('en-CA', {
+            timeZone: options.timeZone || 'Asia/Tokyo',
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+        }).formatToParts(new Date(now));
+        const year = parts.find((part) => part.type === 'year')?.value;
+        if (year)
+            return Number(year);
+    }
+    catch { /* fall back below */ }
+    return new Date(now).getUTCFullYear();
+}
 function dayFacet(year, month, day) {
     const label = `${year}-${pad(month)}-${pad(day)}`;
     return {

package/dist/atlas/GraphCurator.d.ts

@@ -14,6 +14,8 @@ export declare class GraphCurator {
     private readonly titleGenerator;
     constructor(db: Database, eventStore: EventStore, atlasStore: MemoryAtlasStore);
     rebuild(projectId: string, now?: number): GraphCuratorResult;
+    rebuildEpisodes(projectId: string, episodeIds: string[], now?: number): GraphCuratorResult;
+    private projectEpisode;
     private episodeEventIds;
     private facetTargetsFor;
     private upsertFacetNode;
@@ -22,6 +24,7 @@ export declare class GraphCurator {
     private upsertEpisodeRelation;
     private entityHintsFor;
     private deleteFacetEdges;
+    private deleteFacetEdgesForEpisodes;
     private upsertEdge;
 }
 //# sourceMappingURL=GraphCurator.d.ts.map

package/dist/atlas/GraphCurator.js

@@ -1,6 +1,8 @@
 import { createHash } from 'node:crypto';
 import { eventTextForMemory } from '../episode/CogmemBlockStripper.js';
 import { EpisodeTitleGenerator } from './EpisodeTitleGenerator.js';
+import { extractEntityCues, normalizeEntityCueId } from '../utils/EntityCueExtractor.js';
+import { inferActionKinds } from '../utils/ActionKindRegistry.js';
 const FACET_EDGE_RELATIONS = new Set([
     'OCCURRED_ON',
     'OCCURRED_IN',
@@ -37,6 +39,8 @@ export class GraphCurator {
         importance,summary,start_event_id,end_event_id,event_count,started_at,updated_at
       FROM memory_episodes
       WHERE project_id=?
+        AND COALESCE(event_count,0)>0
+        AND status NOT IN ('archived','rejected','merged','invalidated')
       ORDER BY started_at ASC, episode_id ASC
     `).all(projectId);
         const projections = [];
@@ -123,6 +127,99 @@ export class GraphCurator {
         facetEdgeCount += this.projectEpisodeRelations(projectId, projections, now);
         return { episodeCount: rows.length, facetNodeCount, facetEdgeCount, reviewNeeded };
     }
+    rebuildEpisodes(projectId, episodeIds, now = Date.now()) {
+        const bounded = Array.from(new Set(episodeIds.filter(Boolean))).slice(0, 100);
+        if (!bounded.length)
+            return { episodeCount: 0, facetNodeCount: 0, facetEdgeCount: 0, reviewNeeded: 0 };
+        this.deleteFacetEdgesForEpisodes(projectId, bounded);
+        const rows = this.db.prepare(`
+      SELECT episode_id,project_id,session_id,conversation_thread_id,topic_path,episode_type,status,
+        importance,summary,start_event_id,end_event_id,event_count,started_at,updated_at
+      FROM memory_episodes
+      WHERE project_id=? AND episode_id IN (${bounded.map(() => '?').join(',')})
+        AND COALESCE(event_count,0)>0
+        AND status NOT IN ('archived','rejected','merged','invalidated')
+      ORDER BY started_at ASC, episode_id ASC
+    `).all(projectId, ...bounded);
+        let facetNodeCount = 0;
+        let facetEdgeCount = 0;
+        let reviewNeeded = 0;
+        for (const row of rows) {
+            const projection = this.projectEpisode(row, projectId, now);
+            facetNodeCount += projection.facetNodeCount;
+            facetEdgeCount += projection.facetEdgeCount;
+            reviewNeeded += projection.reviewNeeded;
+        }
+        return { episodeCount: rows.length, facetNodeCount, facetEdgeCount, reviewNeeded };
+    }
+    projectEpisode(row, projectId, now) {
+        const eventIds = this.episodeEventIds(row.episode_id);
+        const events = eventIds.map((eventId) => this.eventStore.getEvent(eventId)).filter((event) => Boolean(event));
+        const title = this.titleGenerator.generate({
+            episodeId: row.episode_id,
+            summary: row.summary,
+            topicPath: row.topic_path,
+            episodeType: row.episode_type,
+            startedAt: row.started_at,
+            events,
+        });
+        const evidenceEventIds = Array.from(new Set([...title.sourceEventIds, ...eventIds])).slice(0, 30);
+        this.atlasStore.upsertDocument({
+            id: `episode:${row.episode_id}`,
+            projectId,
+            nodeType: 'episode',
+            sourceId: row.episode_id,
+            label: title.displayTitle,
+            summary: title.oneLineSummary,
+            topicPath: row.topic_path || undefined,
+            confidence: Math.max(0.01, Math.min(1, Number(row.importance || 0.5))),
+            supportCount: Math.max(1, Number(row.event_count || evidenceEventIds.length || 1)),
+            status: row.status,
+            occurredAt: row.started_at,
+            evidenceEventIds,
+            metadata: {
+                originalSummary: row.summary || undefined,
+                displayTitle: title.displayTitle,
+                titleConfidence: title.confidence,
+                topicHints: title.topicHints,
+                issueHints: title.issueHints,
+                eventKind: title.eventKind,
+                userIntent: title.userIntent,
+                localDate: title.localDate,
+                reviewNeeded: title.reviewNeeded,
+                generatorTrace: title.generatorTrace,
+                episodeType: row.episode_type,
+                sessionId: row.session_id || undefined,
+                threadId: row.conversation_thread_id || undefined,
+                canonicalId: `episode:${row.episode_id}`,
+            },
+            updatedAt: now,
+        });
+        for (const event of events.slice(0, 30))
+            this.upsertRawEventNode(projectId, event, now);
+        const projection = { row, eventIds, events, issueHints: title.issueHints, topicHints: title.topicHints, localDate: title.localDate };
+        let facetNodeCount = 0;
+        let facetEdgeCount = 0;
+        for (const target of this.facetTargetsFor(projection)) {
+            this.upsertFacetNode(projectId, target, projection, now);
+            facetNodeCount += 1;
+            this.upsertEdge({
+                projectId,
+                sourceType: 'episode',
+                sourceId: row.episode_id,
+                relationType: target.relation,
+                targetType: target.type,
+                targetId: target.id,
+                confidence: target.confidence,
+                evidenceEventIds,
+                status: 'active',
+                sourceAuthority: 'atlas_curator',
+                now,
+            });
+            facetEdgeCount += 1;
+        }
+        return { projection, facetNodeCount, facetEdgeCount, reviewNeeded: title.reviewNeeded ? 1 : 0 };
+    }
     episodeEventIds(episodeId) {
         const rows = this.db.prepare(`SELECT event_id FROM memory_episode_events WHERE episode_id=? ORDER BY position ASC`).all(episodeId);
         return rows.map((row) => row.event_id).filter(Boolean);
@@ -147,7 +244,10 @@ export class GraphCurator {
             targets.push({ type: 'issue', id: issueHint, nodeId: `issue:${projection.row.project_id}:${issueHint}`, label: issueLabel(issueHint), relation: 'PART_OF_ISSUE', confidence: 0.9 });
         }
         for (const entity of this.entityHintsFor(projection)) {
-            targets.push({ type: 'entity', id: `facet:${entity.toLowerCase()}`, nodeId: `entity:facet:${entity.toLowerCase()}`, label: entity, relation: 'INVOLVES_ENTITY', confidence: 0.78 });
+            const entityId = normalizeEntityCueId(entity);
+            if (!entityId)
+                continue;
+            targets.push({ type: 'entity', id: `facet:${entityId}`, nodeId: `entity:${projection.row.project_id}:facet:${entityId}`, label: entity, relation: 'INVOLVES_ENTITY', confidence: 0.78 });
         }
         if (projection.row.session_id) {
             targets.push({ type: 'session', id: projection.row.session_id, nodeId: `session:${projection.row.project_id}:${projection.row.session_id}`, label: `Session ${projection.row.session_id}`, relation: 'IN_SESSION', confidence: 1 });
@@ -157,9 +257,9 @@ export class GraphCurator {
         }
         const memoryKind = normalizeKind(projection.issueHints[0] ? issueKind(projection.issueHints[0]) : projection.row.episode_type || 'discussion');
         targets.push({ type: 'memoryKind', id: memoryKind, nodeId: `memoryKind:${projection.row.project_id}:${memoryKind}`, label: memoryKind, relation: 'HAS_MEMORY_KIND', confidence: 0.75 });
-        const actionKind = actionKindFor(projection);
-        if (actionKind)
+        for (const actionKind of actionKindsFor(projection)) {
             targets.push({ type: 'actionKind', id: actionKind, nodeId: `actionKind:${projection.row.project_id}:${actionKind}`, label: actionKind, relation: 'HAS_ACTION_KIND', confidence: 0.7 });
+        }
         for (const eventId of projection.eventIds.slice(0, 30)) {
             targets.push({ type: 'raw_event', id: eventId, nodeId: `raw_event:${eventId}`, label: eventId, relation: 'HAS_EVIDENCE', confidence: 1 });
         }
@@ -280,6 +380,18 @@ export class GraphCurator {
         const relations = Array.from(FACET_EDGE_RELATIONS);
         this.db.prepare(`DELETE FROM memory_edges WHERE project_id=? AND source_authority='atlas_curator' AND relation_type IN (${relations.map(() => '?').join(',')})`).run(projectId, ...relations);
     }
+    deleteFacetEdgesForEpisodes(projectId, episodeIds) {
+        const relations = Array.from(FACET_EDGE_RELATIONS);
+        this.db.prepare(`
+      DELETE FROM memory_edges
+      WHERE project_id=? AND source_authority='atlas_curator'
+        AND relation_type IN (${relations.map(() => '?').join(',')})
+        AND (
+          (source_type='episode' AND source_id IN (${episodeIds.map(() => '?').join(',')}))
+          OR (target_type='episode' AND target_id IN (${episodeIds.map(() => '?').join(',')}))
+        )
+    `).run(projectId, ...relations, ...episodeIds, ...episodeIds);
+    }
     upsertEdge(input) {
         const edgeId = createHash('sha256')
             .update([input.projectId, input.sourceType, input.sourceId, input.relationType, input.targetType, input.targetId].join('\0'))
@@ -339,21 +451,13 @@ function issueKind(value) {
         return 'plan';
     return 'diagnostic';
 }
-function actionKindFor(projection) {
+function actionKindsFor(projection) {
     const text = projection.events.map(eventTextForMemory).join('\n');
-    if (/修复|fixed|implemented|实现|提交|升级|upgrade/i.test(text))
-        return 'implemented';
-    if (/review|审查|检查/i.test(text))
-        return 'reviewed';
-    if (/决定|decided|方案|策略/i.test(text))
-        return 'decided';
-    if (/debug|排查|卡死|locked|zombie/i.test(text))
-        return 'debugged';
-    return undefined;
+    return inferActionKinds(text);
 }
 function entityHints(events) {
     const text = events.map(eventTextForMemory).join('\n');
-    return ['Cogmem', 'OpenClaw', 'Hermes'].filter((entity) => new RegExp(entity, 'i').test(text));
+    return extractEntityCues(text).map((entity) => entity.label);
 }
 function facetSummary(target) {
     if (target.type === 'topic')

package/dist/atlas/MemoryAtlasIndexer.d.ts

@@ -22,6 +22,18 @@ export declare class MemoryAtlasIndexer {
         curatedEpisodes?: number;
         refreshed: boolean;
     };
+    reindex(options: {
+        projectId: string;
+        eventId?: string;
+        episodeId?: string;
+    }): {
+        projectId: string;
+        episodeIds: string[];
+        refreshed: boolean;
+        curatedEpisodes: number;
+        facetEdges: number;
+        reviewNeeded: number;
+    };
     ensureAllFresh(): {
         documents: number;
         actions: number;

package/dist/atlas/MemoryAtlasIndexer.js

@@ -44,6 +44,7 @@ export class MemoryAtlasIndexer {
                     curatedEpisodes += result.episodeCount;
                     facetEdges += result.facetEdgeCount;
                     reviewNeeded += result.reviewNeeded;
+                    this.store.aggregateFacetNodeSupport(id);
                 }
                 if (projectId) {
                     this.store.markProjectionClean(projectId, { actions, curatedEpisodes, facetEdges, reviewNeeded });
@@ -66,6 +67,41 @@ export class MemoryAtlasIndexer {
         }
         return { ...this.rebuild(options), refreshed: true };
     }
+    reindex(options) {
+        const episodeIds = new Set();
+        if (options.episodeId)
+            episodeIds.add(options.episodeId);
+        if (options.eventId) {
+            const rows = this.db.prepare(`SELECT episode_id FROM memory_episode_events WHERE event_id=?`).all(options.eventId);
+            for (const row of rows)
+                if (row.episode_id)
+                    episodeIds.add(row.episode_id);
+        }
+        const ids = Array.from(episodeIds);
+        if (!ids.length)
+            throw new Error('graph_reindex_target_not_found');
+        let result = { episodeCount: 0, facetNodeCount: 0, facetEdgeCount: 0, reviewNeeded: 0 };
+        this.db.transaction(() => {
+            result = this.curator.rebuildEpisodes(options.projectId, ids);
+            this.store.markProjectionDirty(options.projectId, {
+                targetedReindex: true,
+                episodeIds: ids,
+                eventId: options.eventId,
+                curatedEpisodes: result.episodeCount,
+                facetEdges: result.facetEdgeCount,
+                reviewNeeded: result.reviewNeeded,
+                reason: 'targeted_reindex_requires_full_consistency_rebuild',
+            });
+        })();
+        return {
+            projectId: options.projectId,
+            episodeIds: ids,
+            refreshed: true,
+            curatedEpisodes: result.episodeCount,
+            facetEdges: result.facetEdgeCount,
+            reviewNeeded: result.reviewNeeded,
+        };
+    }
     ensureAllFresh() {
         let documents = 0;
         let actions = 0;

package/dist/atlas/MemoryAtlasQueryCompiler.js

@@ -1,5 +1,5 @@
 const STOP_WORDS = new Set(['我', '你', '让', '对', '的', '年', '做过', '什么', '去年', '今年', 'the', 'a', 'an', 'what', 'did', 'do', 'to', 'last', 'year']);
-const ACTION_MARKERS = /配置|连接|安装|修复|更新|升级|比较|操作|设置|调试|configure|connect|install|repair|fix|update|upgrade|compare|setup|debug/iu;
+const ACTION_MARKERS = /启动|重启|停止|执行|配置|连接|安装|修复|更新|升级|比较|操作|设置|调试|start|started|launch|launched|boot|restart|restarted|stop|stopped|run|ran|configure|connect|install|repair|fix|update|upgrade|compare|setup|debug/iu;
 const MEMORY_KIND_MARKERS = [
     [/决策|决定|decision/iu, 'decision'], [/修正|纠正|correction/iu, 'correction'],
     [/目标|goal/iu, 'goal'], [/偏好|preference/iu, 'preference'], [/计划|plan/iu, 'plan'],
@@ -45,11 +45,14 @@ export function actionMarkers(value) {
 }
 function frameTypeForAction(lower) {
     const frameType = /修复|fix|repair|调试|debug/u.test(lower) ? 'repair'
-        : /安装|install/u.test(lower) ? 'install'
-            : /连接|connect/u.test(lower) ? 'connect'
-                : /更新|升级|update|upgrade/u.test(lower) ? 'update'
-                    : /比较|compare/u.test(lower) ? 'compare'
-                        : /配置|设置|configure|setup/u.test(lower) ? 'configuration'
-                            : 'operation';
+        : /启动|start|launch|boot/u.test(lower) ? 'start'
+            : /重启|restart/u.test(lower) ? 'restart'
+                : /停止|stop/u.test(lower) ? 'stop'
+                    : /安装|install/u.test(lower) ? 'install'
+                        : /连接|connect/u.test(lower) ? 'connect'
+                            : /更新|升级|update|upgrade/u.test(lower) ? 'update'
+                                : /比较|compare/u.test(lower) ? 'compare'
+                                    : /配置|设置|configure|setup/u.test(lower) ? 'configuration'
+                                        : 'operation';
     return frameType;
 }

package/dist/atlas/MemoryAtlasService.d.ts

@@ -22,6 +22,7 @@ export declare class MemoryAtlasService {
     private attachCardEvidence;
     private evidence;
     private edgesFor;
+    private edgeProjection;
     private safeEdges;
     private adjacentEdges;
     private directEdgesToTarget;

package/dist/atlas/MemoryAtlasService.js

@@ -57,8 +57,8 @@ export class MemoryAtlasService {
             nodes = uniqueNodes([...actions.map((action) => this.store.getNode(action.id, projectId)).filter((node) => Boolean(node)), ...nodes]).slice(0, limit);
         }
         const nodesWithEvidence = this.attachEvidence(nodes, projectId, options);
-        const edges = this.edgesFor(nodesWithEvidence, projectId);
-        const result = slice(projectId, nodesWithEvidence, edges, query);
+        const edgeProjection = this.edgeProjection(nodesWithEvidence, projectId, exactMatchedNodeIds(cards, facetResult.plan));
+        const result = slice(projectId, nodesWithEvidence, edgeProjection.edges, query);
         result.facets = {
             ...facetsForPlan(facetResult.plan),
             legacy: { time: compiled.range, target: target.labels.join(', ') || compiled.target, memoryKinds: compiled.memoryKinds, keywords: compiled.keywords },
@@ -68,6 +68,10 @@ export class MemoryAtlasService {
             result.cards = this.attachCardEvidence(cards, projectId, options);
         if (facetResult.relaxationTrace.length)
             result.relaxationTrace = facetResult.relaxationTrace;
+        if (edgeProjection.truncation) {
+            result.edgeTruncation = edgeProjection.truncation;
+            result.warnings.push(`edges_truncated:${edgeProjection.truncation.omitted}_omitted`);
+        }
         const hasFacet = Boolean(compiled.range || compiled.target || compiled.memoryKinds.length || compiled.tokens.length);
         result.coldMemoryResurrected = hasFacet && nodes.some((node) => node.activation <= 0.1);
         return result;
@@ -88,7 +92,8 @@ export class MemoryAtlasService {
         if (!Number.isInteger(hops) || hops < 1 || hops > 2)
             throw new Error('hops must be between 1 and 2');
         const limit = boundedLimit(options.limit);
-        const seen = new Set([boundedId(nodeId)]);
+        const start = canonicalInputNodeId(this.store, boundedId(nodeId), projectId);
+        const seen = new Set([start]);
         let frontier = [...seen];
         const selectedEdges = [];
         for (let depth = 0; depth < hops; depth += 1) {
@@ -111,8 +116,8 @@ export class MemoryAtlasService {
     path(from, to, options) {
         const projectId = requiredProject(options.projectId);
         const maxHops = Math.max(1, Math.min(options.maxHops ?? 6, 6));
-        const start = boundedId(from);
-        const target = boundedId(to);
+        const start = canonicalInputNodeId(this.store, boundedId(from), projectId);
+        const target = canonicalInputNodeId(this.store, boundedId(to), projectId);
         const parents = new Map();
         const best = new Map([[start, 0]]);
         const queue = [{ id: start, cost: 0, hops: 0 }];
@@ -201,13 +206,13 @@ export class MemoryAtlasService {
         let plan = this.facetPlanner.plan(boundedQuery(query), { projectId, now: options.now });
         const relaxationTrace = [];
         let cards = plan.facets.length ? this.store.searchCanonicalEpisodeCards(projectId, plan, limit) : [];
-        if (!cards.length && plan.facets.length) {
+        for (let attempt = 0; !cards.length && plan.facets.length && attempt < 3; attempt += 1) {
             const relaxed = relaxFacetPlan(plan);
-            if (relaxed) {
-                plan = relaxed.plan;
-                cards = this.store.searchCanonicalEpisodeCards(projectId, relaxed.plan, limit);
-                relaxationTrace.push(...relaxed.trace);
-            }
+            if (!relaxed)
+                break;
+            plan = relaxed.plan;
+            cards = this.store.searchCanonicalEpisodeCards(projectId, plan, limit);
+            relaxationTrace.push(...relaxed.trace);
         }
         return { plan, cards, relaxationTrace };
     }
@@ -247,9 +252,23 @@ export class MemoryAtlasService {
         });
     }
     edgesFor(nodes, projectId) {
+        return this.edgeProjection(nodes, projectId).edges;
+    }
+    edgeProjection(nodes, projectId, priorityIds = new Set()) {
         const ids = new Set(nodes.map((node) => node.id));
-        return this.safeEdges(this.store.listEdgesForNodes(projectId, [...ids], 60)
-            .filter((edge) => ids.has(edge.source) && ids.has(edge.target)).slice(0, 60), projectId);
+        const limit = 60;
+        const candidates = this.safeEdges(this.store.listEdgesWithinNodes(projectId, [...ids], 4000)
+            .filter((edge) => ids.has(edge.source) && ids.has(edge.target)), projectId);
+        const sorted = uniqueEdges(candidates).sort((left, right) => edgePriority(right, priorityIds) - edgePriority(left, priorityIds)
+            || right.confidence - left.confidence
+            || edgeKey(left).localeCompare(edgeKey(right)));
+        const edges = sorted.slice(0, limit);
+        return {
+            edges,
+            truncation: sorted.length > edges.length
+                ? { limit, returned: edges.length, omitted: sorted.length - edges.length, candidateCount: sorted.length, prioritized: priorityIds.size > 0 }
+                : undefined,
+        };
     }
     safeEdges(edges, projectId) {
         return edges.map((edge) => ({ ...edge, evidenceEventIds: edge.evidenceEventIds.filter((eventId) => {
@@ -268,6 +287,17 @@ export class MemoryAtlasService {
             .flatMap((chunk) => this.store.findEdgesFromNodesToTarget(projectId, chunk, target)));
     }
 }
+function canonicalInputNodeId(store, id, projectId) {
+    if (id.startsWith(`entity:${projectId}:`))
+        return id;
+    if (!id.startsWith('entity:'))
+        return id;
+    const entityId = id.slice('entity:'.length);
+    if (!entityId.startsWith('facet:'))
+        return id;
+    const scoped = `entity:${projectId}:${entityId}`;
+    return store.getNode(scoped, projectId) ? scoped : id;
+}
 function requiredProject(value) { if (!value?.trim())
     throw new Error('projectId is required for Memory Atlas queries'); return value.trim(); }
 function boundedLimit(value) { if (value !== undefined && (!Number.isFinite(value) || value < 1))
@@ -282,6 +312,20 @@ function uniqueIds(ids) { return Array.from(new Set(ids)); }
 function uniqueEdges(edges) {
     return Array.from(new Map(edges.map((edge) => [`${edge.source}\0${edge.relation}\0${edge.target}`, edge])).values());
 }
+function edgeKey(edge) { return `${edge.source}\0${edge.relation}\0${edge.target}`; }
+function edgePriority(edge, priorityIds) {
+    return (priorityIds.has(edge.source) ? 1 : 0) + (priorityIds.has(edge.target) ? 1 : 0);
+}
+function exactMatchedNodeIds(cards, plan) {
+    return new Set([
+        ...cards.flatMap((card) => [
+            card.canonicalId,
+            ...card.matchedFacets.map((facet) => facet.nodeId),
+            ...card.matchedPaths.flatMap((path) => path.via),
+        ]),
+        ...plan.facets.map((facet) => facet.nodeId).filter((id) => Boolean(id)),
+    ]);
+}
 function edgeTraversalCost(edge) {
     const confidence = Math.max(0.01, Math.min(1, edge.confidence));
     const relationPenalty = /^(EVIDENCED_BY|DERIVED_FROM|TARGETS|OCCURRED_IN|SUPPORTS|ABOUT|MENTIONS)$/u.test(edge.relation)
@@ -330,23 +374,55 @@ function groupCardsByIssue(cards) {
 }
 function relaxFacetPlan(plan) {
     const dayFacet = plan.facets.find((facet) => facet.type === 'time' && facet.granularity === 'day');
-    if (!dayFacet)
-        return null;
-    const monthValue = dayFacet.value.slice(0, 7);
-    return {
-        plan: {
-            ...plan,
-            exactness: 'relaxed',
-            facets: plan.facets.map((facet) => facet === dayFacet ? {
-                ...facet,
+    if (dayFacet) {
+        const monthValue = dayFacet.value.slice(0, 7);
+        return {
+            plan: replaceFacet(plan, dayFacet, {
+                ...dayFacet,
                 value: monthValue,
                 label: monthValue,
-                nodeId: facet.nodeId?.replace(dayFacet.value, monthValue),
+                nodeId: dayFacet.nodeId?.replace(dayFacet.value, monthValue),
                 relation: 'OCCURRED_IN',
                 granularity: 'month',
-            } : facet),
-        },
-        trace: [{ from: dayFacet.value, to: monthValue, reason: 'exact day facet had no canonical episode match; relaxed to parent month' }],
+            }),
+            trace: [{ from: dayFacet.value, to: monthValue, reason: 'exact day facet had no canonical episode match; relaxed to parent month' }],
+        };
+    }
+    const monthFacet = plan.facets.find((facet) => facet.type === 'time' && facet.granularity === 'month');
+    if (monthFacet) {
+        const yearValue = monthFacet.value.slice(0, 4);
+        return {
+            plan: replaceFacet(plan, monthFacet, {
+                ...monthFacet,
+                value: yearValue,
+                label: yearValue,
+                nodeId: monthFacet.nodeId?.replace(monthFacet.value, yearValue),
+                relation: 'OCCURRED_IN',
+                granularity: 'year',
+            }),
+            trace: [{ from: monthFacet.value, to: yearValue, reason: 'exact month facet had no canonical episode match; relaxed to parent year' }],
+        };
+    }
+    const issueFacet = plan.facets.find((facet) => facet.type === 'issue');
+    const topicFacet = plan.facets.find((facet) => facet.type === 'topic');
+    if (issueFacet && topicFacet) {
+        return {
+            plan: {
+                ...plan,
+                exactness: 'relaxed',
+                requiresIntersection: plan.facets.length - 1 > 1,
+                facets: plan.facets.filter((facet) => facet !== issueFacet),
+            },
+            trace: [{ from: issueFacet.value, to: topicFacet.value, reason: 'issue facet had no canonical episode match; relaxed to parent topic' }],
+        };
+    }
+    return null;
+}
+function replaceFacet(plan, from, to) {
+    return {
+        ...plan,
+        exactness: 'relaxed',
+        facets: plan.facets.map((facet) => facet === from ? to : facet),
     };
 }
 function atlasSourceLocator(event, projectId) {

package/dist/atlas/MemoryAtlasTypes.d.ts

@@ -101,6 +101,13 @@ export interface MemoryAtlasSlice {
     edges: MemoryAtlasEdge[];
     nextActions: MemoryAtlasNextAction[];
     warnings: string[];
+    edgeTruncation?: {
+        limit: number;
+        returned: number;
+        omitted: number;
+        candidateCount: number;
+        prioritized: boolean;
+    };
     facets?: {
         planner?: {
             intent: string;