cogmem 3.7.0 → 3.7.2

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);
@@ -298,6 +301,54 @@ export class MemoryAtlasStore {
             edges.push(...this.topicRelationEdges(projectId, topicPaths, Math.max(1, Math.min(limit, 2000))));
         return Array.from(new Map(edges.map((edge) => [`${edge.source}\0${edge.relation}\0${edge.target}`, edge])).values()).slice(0, Math.max(1, Math.min(limit, 4000)));
     }
+    listEdgesWithinNodes(projectId, nodeIds, limit = 4000) {
+        const selectedIds = new Set(Array.from(new Set(nodeIds)));
+        const parsed = Array.from(selectedIds).map((id) => parseNodeId(id, projectId)).filter((item) => Boolean(item));
+        if (!parsed.length)
+            return [];
+        const edges = [];
+        const cap = Math.max(1, Math.min(limit, 4000));
+        for (const sourceChunk of chunked(parsed, 120)) {
+            for (const targetChunk of chunked(parsed, 120)) {
+                const sourceClause = sourceChunk.map(() => '(source_type=? AND source_id=?)').join(' OR ');
+                const targetClause = targetChunk.map(() => '(target_type=? AND target_id=?)').join(' OR ');
+                const rows = this.db.prepare(`
+          SELECT * FROM memory_edges
+          WHERE project_id=? AND status IN ('active','weak')
+            AND (${sourceClause}) AND (${targetClause})
+          ORDER BY confidence DESC LIMIT ?
+        `).all(projectId, ...sourceChunk.flatMap((item) => [item.type, item.id]), ...targetChunk.flatMap((item) => [item.type, item.id]), cap);
+                for (const row of rows)
+                    edges.push({
+                        source: nodeId(String(row.source_type), String(row.source_id), projectId), relation: String(row.relation_type),
+                        target: nodeId(String(row.target_type), String(row.target_id), projectId), confidence: Number(row.confidence),
+                        evidenceEventIds: parseStringArray(String(row.evidence_event_ids_json || '[]')),
+                    });
+            }
+        }
+        const actionIds = parsed.filter((item) => item.type === 'action').map((item) => item.id);
+        if (actionIds.length) {
+            for (const chunk of chunked(actionIds, 400)) {
+                const actions = this.db.prepare(`SELECT action_id,target_entity_id,occurred_at,confidence FROM memory_action_frames
+          WHERE project_id=? AND action_id IN (${chunk.map(() => '?').join(',')})`).all(projectId, ...chunk);
+                for (const action of actions) {
+                    const evidenceEventIds = this.actionEvidenceIds(action.action_id, projectId);
+                    if (action.target_entity_id && selectedIds.has(`entity:${action.target_entity_id}`)) {
+                        edges.push({ source: `action:${action.action_id}`, relation: 'TARGETS', target: `entity:${action.target_entity_id}`, confidence: action.confidence, evidenceEventIds });
+                    }
+                    const timeId = timeNodeId(projectId, action.occurred_at);
+                    if (selectedIds.has(timeId))
+                        edges.push({ source: `action:${action.action_id}`, relation: 'OCCURRED_IN', target: timeId, confidence: 1, evidenceEventIds });
+                }
+            }
+        }
+        const topicPaths = parsed.filter((item) => item.type === 'topic').map((item) => item.id);
+        if (topicPaths.length) {
+            edges.push(...this.topicRelationEdges(projectId, topicPaths, cap)
+                .filter((edge) => selectedIds.has(edge.source) && selectedIds.has(edge.target)));
+        }
+        return Array.from(new Map(edges.map((edge) => [`${edge.source}\0${edge.relation}\0${edge.target}`, edge])).values());
+    }
     findEdgesBetween(projectId, leftNodeId, rightNodeId) {
         const left = parseNodeId(leftNodeId, projectId);
         const right = parseNodeId(rightNodeId, projectId);
@@ -483,6 +534,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 +639,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 +666,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 +674,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 +728,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 +737,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) };
@@ -662,6 +773,12 @@ function stringArray(value) {
 function optionalMetadataString(value) {
     return typeof value === 'string' && value ? value : undefined;
 }
+function chunked(values, size) {
+    const chunks = [];
+    for (let index = 0; index < values.length; index += size)
+        chunks.push(values.slice(index, index + size));
+    return chunks;
+}
 function facetFromEdge(edge, projectId) {
     return {
         type: edge.target_type,
@@ -686,6 +803,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 +837,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();

package/dist/utils/ActionKindRegistry.d.ts

@@ -0,0 +1,10 @@
+export interface ActionKindRule {
+    kind: string;
+    label: string;
+    verb: string;
+    pattern: RegExp;
+}
+export declare const ACTION_KIND_RULES: ActionKindRule[];
+export declare function inferActionKinds(text: string): string[];
+export declare function inferFirstActionKind(text: string): ActionKindRule | undefined;
+//# sourceMappingURL=ActionKindRegistry.d.ts.map

package/dist/utils/ActionKindRegistry.js

@@ -0,0 +1,18 @@
+export const ACTION_KIND_RULES = [
+    { kind: 'started', label: '启动', verb: '启动', pattern: /启动|start|started|launch|launched|boot/i },
+    { kind: 'installed', label: '安装', verb: '安装', pattern: /安装|install|installed|setup/i },
+    { kind: 'configured', label: '配置', verb: '配置', pattern: /配置|config|configured|设置|修改配置|修改/i },
+    { kind: 'restarted', label: '重启', verb: '重启', pattern: /重启|restart|restarted/i },
+    { kind: 'stopped', label: '停止', verb: '停止', pattern: /停止|stop|stopped/i },
+    { kind: 'operated', label: '操作', verb: '操作', pattern: /操作|处理|执行|运行|run|ran/i },
+    { kind: 'implemented', label: '实现', verb: '实现', pattern: /修复|fixed|implemented|实现|提交|升级|upgrade|合并|发布/i },
+    { kind: 'reviewed', label: '审查', verb: '审查', pattern: /review|审查|检查/i },
+    { kind: 'decided', label: '决定', verb: '决定', pattern: /决定|decided|方案|策略|结论/i },
+    { kind: 'debugged', label: '排查', verb: '排查', pattern: /debug|排查|卡死|locked|zombie|报错|错误/i },
+];
+export function inferActionKinds(text) {
+    return ACTION_KIND_RULES.filter((rule) => rule.pattern.test(text)).map((rule) => rule.kind);
+}
+export function inferFirstActionKind(text) {
+    return ACTION_KIND_RULES.find((rule) => rule.pattern.test(text));
+}

package/dist/utils/EntityCueExtractor.d.ts

@@ -0,0 +1,13 @@
+export interface EntityCue {
+    label: string;
+    id: string;
+}
+export interface OperationalActionCue {
+    kind: string;
+    label: string;
+    verb: string;
+}
+export declare function extractEntityCues(text: string, limit?: number): EntityCue[];
+export declare function inferOperationalActionCue(text: string): OperationalActionCue | undefined;
+export declare function normalizeEntityCueId(label: string): string;
+//# sourceMappingURL=EntityCueExtractor.d.ts.map

package/dist/utils/EntityCueExtractor.js

@@ -0,0 +1,81 @@
+import { inferFirstActionKind } from './ActionKindRegistry.js';
+const ENTITY_STOP_WORDS = new Set([
+    'a',
+    'an',
+    'and',
+    'are',
+    'before',
+    'bug',
+    'context',
+    'database',
+    'debug',
+    'exact',
+    'graph',
+    'install',
+    'installed',
+    'launch',
+    'launched',
+    'memory',
+    'operation',
+    'operations',
+    'quote',
+    'recall',
+    'sourcecontext',
+    'start',
+    'started',
+    'the',
+    'what',
+    'you',
+]);
+export function extractEntityCues(text, limit = 8) {
+    const normalized = String(text || '').replace(/\s+/g, ' ').trim();
+    const labels = [];
+    collectEntityMatches(normalized, /(?:对|给|把|关于|有关|围绕)\s*([\p{L}][\p{L}\p{N}_-]{1,48})\s*(?:做过|做了|做|启动|安装|配置|修改|重启|停止|操作|处理|执行|有关|的|什么|哪些|吗)?/giu, labels);
+    collectEntityMatches(normalized, /(?:聊过|讨论过|记得|还记得|提到过)\s*([\p{L}][\p{L}\p{N}_-]{1,48})\s*(?:什么|哪些|吗|的)?/giu, labels);
+    collectEntityMatches(normalized, /(?:启动|安装|配置|修改|重启|停止|执行|运行|start|started|launch|launched|boot|install|installed|setup|configure|configured|restart|stop|run|ran)\s*(?:本机安装的|本地的|the\s+)?([\p{L}][\p{L}\p{N}_-]{1,48})/giu, labels);
+    collectEntityMatches(normalized, /\b([A-Z][A-Za-z0-9_-]{1,48})\b/g, labels);
+    const seen = new Set();
+    const cues = [];
+    for (const label of labels.map(cleanEntityLabel).filter(Boolean)) {
+        const id = normalizeEntityCueId(label);
+        if (!id || ENTITY_STOP_WORDS.has(id) || isLikelyConceptLabel(label) || seen.has(id))
+            continue;
+        seen.add(id);
+        cues.push({ label, id });
+        if (cues.length >= limit)
+            break;
+    }
+    return cues;
+}
+export function inferOperationalActionCue(text) {
+    const rule = inferFirstActionKind(text);
+    return rule ? { kind: rule.kind, label: rule.label, verb: rule.verb } : undefined;
+}
+export function normalizeEntityCueId(label) {
+    return String(label || '')
+        .trim()
+        .toLocaleLowerCase()
+        .replace(/['"“”‘’`]/g, '')
+        .replace(/[^\p{L}\p{N}]+/gu, '-')
+        .replace(/^-|-$/g, '');
+}
+function collectEntityMatches(text, regex, out) {
+    for (const match of text.matchAll(regex)) {
+        if (match[1])
+            out.push(match[1]);
+    }
+}
+function cleanEntityLabel(label) {
+    return String(label || '')
+        .replace(/^(我|你|我们)?(?:之前)?让你(?:对|给|把)?/u, '')
+        .replace(/^(我们|你|我)?(?:之前)?聊过的?/u, '')
+        .replace(/(聊过|讨论过|记得|还记得|提到过).*$/u, '')
+        .replace(/^(本机安装的|本地的|the\s+)/i, '')
+        .replace(/(做过|做了|启动|安装|配置|修改|重启|停止|操作|处理|执行)(什么|哪些|吗|么|的)?$/u, '')
+        .replace(/(什么|哪些|吗|么|的)$/u, '')
+        .replace(/[，。？！、；：,.?!;:()[\]{}<>]/g, '')
+        .trim();
+}
+function isLikelyConceptLabel(label) {
+    return /(黑盒|问题|方案|策略|计划|原话|上下文|记忆)$/u.test(label);
+}

package/examples/hermes-backend/AGENTS.md

@@ -227,7 +227,7 @@ Hermes has no automatic observation path in this integration. Use `cogmem_episod
 
 Use `cogmem_topic_operate` with actor `user_explicit` only for explicit user naming/organization instructions. Model suggestions use `model_candidate` and remain reviewable; alias collisions fail closed. Use `cogmem_episode_repair` for split/merge/move/reclassify/requeue work so receipts, stale candidates, cross-references, Dream jobs, and audit records stay synchronized. Do not hand-edit the database.
 
-Use `cogmem memory map --project hermes --json` or MCP `cogmem_memory_map` to inspect Memory Binding and Graph Recall counters. Bindings attach high-value user raw events to stable topic/entity paths, fuse same-claim evidence into claim-key clusters, and create graph anchors for source drill-down only; they are not verified facts, user preferences, or instructions. Correction bindings expose review flags and correction edges. If `cogmem memory tick --project hermes --json` suggests `bind_raw_events`, run `cogmem memory bind --project hermes --json`; it scans the historical ledger by cursor and can resume with `--since <globalSeq>`. For old-discussion questions, use `cogmem memory recall --intent historical_discussion ...` or `cogmem_graph_explore`; in 3.7.0 cards carry `canonicalId`, `matchedFacets`, `matchedPaths`, `relatedButNotSelected`, and `sourceLocator`. Answer from the selected canonical card, not from a side card. Re-run `cogmem connect hermes --workspace . --auto --force --json` after upgrades to patch existing MCP allow-lists with new Cogmem tools. Follow only `nextCommands` for unattended agent work; operator/host actions are in `nextSteps` with `safeForAutomation=false`.
+Use `cogmem memory map --project hermes --json` or MCP `cogmem_memory_map` to inspect Memory Binding and Graph Recall counters. Bindings attach high-value user raw events to stable topic/entity paths, fuse same-claim evidence into claim-key clusters, and create graph anchors for source drill-down only; they are not verified facts, user preferences, or instructions. Correction bindings expose review flags and correction edges. If `cogmem memory tick --project hermes --json` suggests `bind_raw_events`, run `cogmem memory bind --project hermes --json`; it scans the historical ledger by cursor and can resume with `--since <globalSeq>`. For old-discussion questions, use `cogmem memory recall --intent historical_discussion ...` or `cogmem_graph_explore`; in 3.7.2 cards carry `canonicalId`, `matchedFacets`, `matchedPaths`, `relatedButNotSelected`, and `sourceLocator`. Answer from the selected canonical card, not from a side card. Re-run `cogmem connect hermes --workspace . --auto --force --json` after upgrades to patch existing MCP allow-lists with new Cogmem tools. Follow only `nextCommands` for unattended agent work; operator/host actions are in `nextSteps` with `safeForAutomation=false`.
 
 Dream correction records require explicit user clarification; assistant self-correction and questions containing `是不是` are not user-owned contradictions. Invalid provider output is a rejected diagnostic. Maintenance ticks supersede `needs_confirmation` entries older than the default 30-day TTL and retain their evidence rows.
 

package/examples/hermes-backend/README.md

@@ -109,7 +109,7 @@ Dream stores explicit user clarification as organizational correction evidence r
 
 After upgrades, reload MCP. Rerun `cogmem connect hermes --workspace . --auto --force --json` when MCP wiring, allow-listed tools, or the installed skill bundle changed. Follow only JSON `nextCommands` for unattended agent work; operator/host actions are in `nextSteps` with `safeForAutomation=false`.
 
-Cogmem 3.7.0 exposes read-only/idempotent Memory Atlas query tools plus explicit `cogmem_graph_touch`, installs from npm by default, prevents empty imported episodes from blocking Dream, and adds an agent-safe operations protocol. Use `memory plan` for the next safe command, grouped `memory candidates --json` for queue state, `historical_discussion` recall for old-discussion questions, and returned `sourceLocator` commands for exact evidence. Only run `dream_tick` when it appears in `memory plan.nextActions`; `raw_dream_ledger_lag` in `nonBlocking` has `resolvableByDreamTick:false` and is not fixed by looping `dream tick`. Use explore for broad memory inventory/history, search and node for a known concept, path/neighbors for relations, timeline for ordered reconstruction, and normal recall for a direct fact. Query facets combine the user's actual project, day/month/year, topic, issue, entity/target, session/thread, memory-kind, action-kind, and keyword conditions like table filters, so cold memory can be revived without requiring an entity-time-action tuple. Prefer returned `cards[]` for historical discussion: `canonicalId` dedupes the episode, `matchedFacets` explains why it matched, `relatedButNotSelected` is only side context, and `sourceLocator` opens raw evidence. Touch only nodes actually used, and follow returned event IDs or `sourceLocator` commands before quoting exact wording.
+Cogmem 3.7.2 exposes read-only/idempotent Memory Atlas query tools plus explicit `cogmem_graph_touch`, installs from npm by default, prevents empty imported episodes from blocking Dream, and adds an agent-safe operations protocol. Use `memory plan` for the next safe command, grouped `memory candidates --json` for queue state, `historical_discussion` recall for old-discussion questions, and returned `sourceLocator` commands for exact evidence. Only run `dream_tick` when it appears in `memory plan.nextActions`; `raw_dream_ledger_lag` in `nonBlocking` has `resolvableByDreamTick:false` and is not fixed by looping `dream tick`. Use explore for broad memory inventory/history, search and node for a known concept, path/neighbors for relations, timeline for ordered reconstruction, and normal recall for a direct fact. Query facets combine the user's actual project, day/month/year, topic, issue, entity/target, session/thread, memory-kind, action-kind, and keyword conditions like table filters, so cold memory can be revived without requiring an entity-time-action tuple. Unicode entity cues are supported, but alias merges still require governed evidence. Prefer returned `cards[]` for historical discussion: `canonicalId` dedupes the episode, `matchedFacets` explains why it matched, `relatedButNotSelected` is only side context, `relaxationTrace` marks day/month/year or issue/topic fallback, and `sourceLocator` opens raw evidence. Touch only nodes actually used, and follow returned event IDs or `sourceLocator` commands before quoting exact wording.
 
 ## Runtime
 

package/examples/hermes-backend/SKILL.md

@@ -114,7 +114,7 @@ timeout_ms = 60000
 
 ## Migrate Existing Hermes Memory
 
-Upgrade a 3.5.2 database, an existing 3.6.x database, or a pre-release schema-25 test database to the current 3.7.0 schema/projection set in one backed-up command:
+Upgrade a 3.5.2 database, an existing 3.6.x database, or a pre-release schema-25 test database to the current 3.7.2 schema/projection set in one backed-up command:
 
 ```bash
 cogmem migrate --yes --backup --json
@@ -214,9 +214,9 @@ Choose the graph tool from the question shape:
 - Direct factual question: `cogmem_recall`.
 - Exact wording: follow an event ID with `cogmem memory show`.
 
-Atlas combines whatever conditions the user supplies like table filters. Do not require entity + time + action. Project, day/month/year, topic, issue, entity/target, session/thread, memory kind, action kind, and ordinary cues may revive cold nodes together. Activation is visibility, not truth. Atlas summaries are hints and never replace raw evidence.
+Atlas combines whatever conditions the user supplies like table filters. Do not require entity + time + action. Project, day/month/year, topic, issue, entity/target, session/thread, memory kind, action kind, and ordinary cues may revive cold nodes together. Entity cue extraction accepts Unicode letter/number names, but it is not full NER and must not be treated as proof that two aliases are the same person/tool. Activation is visibility, not truth. Atlas summaries are hints and never replace raw evidence.
 
-In 3.7.0, `cogmem_graph_search`, `cogmem_graph_explore`, and historical recall can return canonical `cards[]`. Prefer cards over raw node labels for past-discussion questions. A card's `canonicalId` is the single episode identity; `matchedFacets` explains time/topic/issue/entity matches; `matchedPaths` explains how the card was reached; `relatedButNotSelected` is context only and must not replace the selected answer; `sourceLocator.command` is the command to inspect exact original text. If `relaxationTrace` exists, say the answer is a relaxed nearby match, not an exact hit.
+In 3.7.2, `cogmem_graph_search`, `cogmem_graph_explore`, and historical recall can return canonical `cards[]`. Prefer cards over raw node labels for past-discussion questions. A card's `canonicalId` is the single episode identity; `matchedFacets` explains time/topic/issue/entity matches; `matchedPaths` explains how the card was reached; `relatedButNotSelected` is context only and must not replace the selected answer; `sourceLocator.command` is the command to inspect exact original text. If `relaxationTrace` exists, say the answer is a relaxed match, not an exact hit; supported relaxations include day → month → year and issue → parent topic.
 
 When the prompt does not contain enough injected Cogmem context, do not search legacy memory files first. Ask Cogmem directly:
 
@@ -245,6 +245,13 @@ For “did we discuss this before?”, “几个月前是不是聊过…”, “
 cogmem memory recall --query "<past discussion question>" --intent historical_discussion --project hermes --agent hermes --json
 ```
 
+For action-history questions such as “what did I ask you to do to <entity>?”, “启动 <tool>”, or “对 <entity> 做过什么操作”, use `action_history` or Atlas timeline. The entity is whatever project/tool/person/service the user mentions in memory; it is not limited to Hermes itself:
+
+```bash
+cogmem memory recall --query "我之前让你对 <实体或工具名> 做过什么" --intent action_history --project hermes --agent hermes --json
+cogmem memory graph-timeline --project hermes --query "对 <实体或工具名> 做过什么操作" --include-evidence --json
+```
+
 If the answer depends on exact wording or nearby context, run the returned `sourceLocator` or use a Raw Ledger cursor:
 
 ```bash

package/examples/hermes-backend/references/operations.md

@@ -1,4 +1,4 @@
-# Cogmem 3.7.0 Operations Reference for Hermes
+# Cogmem 3.7.2 Operations Reference for Hermes
 
 Read this file when installing, upgrading, importing, repairing, or operating Cogmem. `SKILL.md` contains the decision rules; this file records the operational commands.
 
@@ -76,7 +76,7 @@ cogmem doctor
 cogmem connect hermes --workspace . --auto --force --json
 ```
 
-The backed-up command upgrades 3.5.2 schema 24, an existing 3.6.x database, or a pre-release schema-25 test database to the current 3.7.0 schema/projection state in one run and preserves Raw Ledger evidence. `--dry-run` is read-only and does not create `_schema_migrations`. Reload MCP after reconnecting.
+The backed-up command upgrades 3.5.2 schema 24, an existing 3.6.x database, or a pre-release schema-25 test database to the current 3.7.2 schema/projection state in one run and preserves Raw Ledger evidence. `--dry-run` is read-only and does not create `_schema_migrations`. Reload MCP after reconnecting.
 
 ## Import Hermes memory
 
@@ -149,22 +149,23 @@ cogmem memory list --project hermes --since <globalSeq> --order asc --json
 
 JSON uses `cogmem.cli.v1`: object fields are top-level, arrays use `items`, and queue counters remain top-level. `vectors: 0` is not a recall failure; inspect `vectorState`.
 
-Use `historical_discussion` for “did we discuss this before?”, “几个月前是不是聊过…”, “记忆黑盒”, and missing MCP memory cases. Raw list rows include `sourceLocator`; run the locator before quoting exact words or saying the event cannot be found. Read-only plan/status/candidates use a lightweight SQLite path and should not require stopping the MCP server.
+Use `historical_discussion` for “did we discuss this before?”, “几个月前是不是聊过…”, “记忆黑盒”, and missing MCP memory cases. Use `action_history` for “what did I ask you to do to <entity>?”, “启动 <tool>”, or “对 <entity> 做过什么操作”; the entity is the project/tool/person/service named in memory, not necessarily Hermes. Raw list rows include `sourceLocator`; run the locator before quoting exact words or saying the event cannot be found. Read-only plan/status/candidates use a lightweight SQLite path and should not require stopping the MCP server.
 
 ## Memory Atlas as composable filters
 
-Atlas uses any available project, day/month/year, topic, issue, entity/target, session/thread, memory-kind, action-kind, and text facets together. It does not require an entity + time + operation tuple. A canonical episode appears once even if it is reached through several facets.
+Atlas uses any available project, day/month/year, topic, issue, entity/target, session/thread, memory-kind, action-kind, and text facets together. Unicode letter/number entity cues are supported, but Atlas does not automatically prove aliases or merge identities. It does not require an entity + time + operation tuple. A canonical episode appears once even if it is reached through several facets.
 
 ```bash
 cogmem memory graph --project hermes --json
-cogmem memory graph-search --project hermes --query "Hermes" --json
-cogmem memory graph-explore --project hermes --query "2025 年 Hermes 的决策" --now 1782057600000 --evidence-limit 2 --json
+cogmem memory graph-search --project hermes --query "<实体或工具名>" --json
+cogmem memory graph-explore --project hermes --query "2025 年 <实体或工具名> 的决策" --now 1782057600000 --evidence-limit 2 --json
 cogmem memory graph-explore --project hermes --query "6月6号关于记忆黑盒聊过什么" --json
 cogmem memory graph-explore --project hermes --query "记忆黑盒后来有没有继续讨论" --json
 cogmem memory graph-node --project hermes --id <node-id> --include-evidence --evidence-limit 4 --json
 cogmem memory graph-neighbors --project hermes --id <node-id> --hops 2 --json
 cogmem memory graph-path --project hermes --from <node-id> --to <node-id> --json
-cogmem memory graph-timeline --project hermes --query "去年与 Hermes 有关的修复" --now 1782057600000 --evidence-limit 4 --json
+cogmem memory graph-timeline --project hermes --query "去年与 <实体或工具名> 有关的修复" --now 1782057600000 --evidence-limit 4 --json
+cogmem memory graph-timeline --project hermes --query "对 <实体或工具名> 做过什么操作" --include-evidence --json
 ```
 
 Use MCP by question shape:
@@ -176,7 +177,7 @@ Use MCP by question shape:
 - Direct fact: `cogmem_recall`.
 - Exact source: follow `evidenceEventIds` with `memory show`.
 
-Graph reads are pure and declared read-only/idempotent. Call `cogmem_graph_touch` only after using selected nodes. Overview display alone must not change future ranking. Search/explore may return `cards[]` for canonical episodes. Use `cards[].displayTitle` for UI/readability, `oneLineSummary` as a hint, `matchedFacets` and `matchedPaths` to explain why it matched, and `canonicalId` to dedupe. `relatedButNotSelected` is context only; do not substitute it as the answer. If `relaxationTrace` exists, say the match was relaxed. `evidenceTotal` is all known evidence; `evidenceReturned` is the bounded payload. Search/explore evidence includes `sourceLocator.command` and `sourceLocator.contextCommand`; use those locators before treating an Atlas summary as evidence.
+Graph reads are pure and declared read-only/idempotent. Call `cogmem_graph_touch` only after using selected nodes. Overview display alone must not change future ranking. Search/explore may return `cards[]` for canonical episodes. Use `cards[].displayTitle` for UI/readability, `oneLineSummary` as a hint, `matchedFacets` and `matchedPaths` to explain why it matched, and `canonicalId` to dedupe. `relatedButNotSelected` is context only; do not substitute it as the answer. If `relaxationTrace` exists, say the match was relaxed; supported relaxations are day → month → year and issue → parent topic. `evidenceTotal` is all known evidence; `evidenceReturned` is the bounded payload. Search/explore evidence includes `sourceLocator.command` and `sourceLocator.contextCommand`; use those locators before treating an Atlas summary as evidence.
 
 ## Candidate governance and review
 

package/examples/openclaw-backend/AGENTS.md

@@ -185,7 +185,7 @@ Recall behavior:
 - If `cogmem memory tick --project openclaw --json` suggests `bind_raw_events`, run `cogmem memory bind --project openclaw --json` to backfill imported or adapter-written raw user events into the binding graph.
 - For “did we discuss this before?”, “几个月前是不是聊过…”, “记忆黑盒”, or missing injection cases, run `cogmem memory recall --query "<past discussion question>" --intent historical_discussion --project openclaw --agent openclaw --json` before claiming no memory.
 - For ledger audits or resumable checks, use `cogmem memory list --project openclaw --since <globalSeq> --order asc --json`; list rows and Atlas search/explore evidence include `sourceLocator` commands.
-- For old-discussion or "do you remember" questions, prefer `cogmem memory recall --intent historical_discussion ...` or `cogmem memory graph-explore ... --json`. In 3.7.0, cards carry `canonicalId`, `matchedFacets`, `matchedPaths`, `relatedButNotSelected`, and `sourceLocator`; answer from the selected canonical card, not from a related-but-not-selected side card.
+- For old-discussion or "do you remember" questions, prefer `cogmem memory recall --intent historical_discussion ...` or `cogmem memory graph-explore ... --json`. In 3.7.2, cards carry `canonicalId`, `matchedFacets`, `matchedPaths`, `relatedButNotSelected`, and `sourceLocator`; answer from the selected canonical card, not from a related-but-not-selected side card.
 
 Installing the workspace skill makes the kernel procedure discoverable to OpenClaw agents. Installing the local auto wrapper makes future turns call the memory kernel automatically:
 

package/examples/openclaw-backend/README.md

@@ -84,7 +84,7 @@ cogmem memory tick --project openclaw --json
 cogmem memory bind --project openclaw --json
 ```
 
-Cogmem 3.7.0 keeps npm as the default install/update channel and upgrades Memory Atlas into a multi-dimensional navigation graph. Use `memory plan` for the next safe command, grouped `memory candidates --json` for queue state, `historical_discussion` recall for old-discussion questions, and returned `sourceLocator` commands for exact evidence. Only run `dream_tick` when it appears in `memory plan.nextActions`; `raw_dream_ledger_lag` in `nonBlocking` has `resolvableByDreamTick:false` and is not fixed by looping `dream tick`. The auto plugin uses one shared bridge/kernel lifecycle for graph exploration, evidence-bearing node/timeline drill-down, and recall, so OpenClaw does not need MCP for broad inventory/history questions. Atlas combines the query's actual project, day/month/year, topic, issue, entity/target, session/thread, memory-kind, action-kind, and keyword conditions like table filters; no fixed entity-time-action tuple is required. Prefer returned `cards[]` for historical discussion: `canonicalId` dedupes the episode, `matchedFacets` explains why it matched, `relatedButNotSelected` is only side context, and `sourceLocator` opens the raw evidence.
+Cogmem 3.7.2 keeps npm as the default install/update channel and upgrades Memory Atlas into a multi-dimensional navigation graph. Use `memory plan` for the next safe command, grouped `memory candidates --json` for queue state, `historical_discussion` recall for old-discussion questions, and returned `sourceLocator` commands for exact evidence. Only run `dream_tick` when it appears in `memory plan.nextActions`; `raw_dream_ledger_lag` in `nonBlocking` has `resolvableByDreamTick:false` and is not fixed by looping `dream tick`. The auto plugin uses one shared bridge/kernel lifecycle for graph exploration, evidence-bearing node/timeline drill-down, and recall, so OpenClaw does not need MCP for broad inventory/history questions. Atlas combines the query's actual project, day/month/year, topic, issue, entity/target, session/thread, memory-kind, action-kind, and keyword conditions like table filters; no fixed entity-time-action tuple is required. Unicode entity cues are supported, but alias merges still require governed evidence. Prefer returned `cards[]` for historical discussion: `canonicalId` dedupes the episode, `matchedFacets` explains why it matched, `relatedButNotSelected` is only side context, `relaxationTrace` marks day/month/year or issue/topic fallback, and `sourceLocator` opens the raw evidence.
 
 ```bash
 cogmem memory plan --project openclaw --json
@@ -230,7 +230,7 @@ To make future OpenClaw turns automatically recall and record memory, run:
 cogmem connect openclaw --workspace . --auto --force
 ```
 
-`--auto` installs `<workspace>/extensions/cogmem-auto-memory/`, patches OpenClaw `plugins.load.paths`, and enables a local plugin wrapper with `before_prompt_build` and `agent_end` hooks. The wrapper calls `KernelAgentMemoryBackend` through the public `cogmem` API via a Bun bridge; core still does not import OpenClaw. Plugin 0.7.0 uses singleton queue/spawn locks, stale-lock and stale-processing recovery, and bounded remember batches so queued `agent_end` recording does not hold SQLite open longer than necessary.
+`--auto` installs `<workspace>/extensions/cogmem-auto-memory/`, patches OpenClaw `plugins.load.paths`, and enables a local plugin wrapper with `before_prompt_build` and `agent_end` hooks. The wrapper calls `KernelAgentMemoryBackend` through the public `cogmem` API via a Bun bridge; core still does not import OpenClaw. Plugin 0.7.1 uses singleton queue/spawn locks, stale-lock and stale-processing recovery, bounded remember batches, and untrusted-memory serialization so queued `agent_end` recording does not hold SQLite open longer than necessary and recalled history cannot create `COGMEM_*` prompt blocks.
 
 The wrapper does not rewrite OpenClaw's native prompt, tool instructions, skills, or conversation order. It only prepends Cogmem-owned blocks: