cogmem 3.6.5 → 3.7.1

package/dist/store/MemoryAtlasStore.js

@@ -1,4 +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.2';
 export class MemoryAtlasStore {
     db;
     constructor(db) {
@@ -21,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) {
@@ -82,12 +85,83 @@ export class MemoryAtlasStore {
             return mapNode(row, matches + Number(row.activation || 0));
         }).sort((a, b) => b.score - a.score);
     }
+    searchCanonicalEpisodeCards(projectId, plan, limit) {
+        const plannedFacets = plan.facets;
+        if (!plannedFacets.length)
+            return [];
+        const facetMatches = plannedFacets.map((facet) => ({ facet, rows: this.episodeEdgesForFacet(projectId, facet) }));
+        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(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 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(card.relatedButNotSelected ?? [], this.relatedEpisodeCards(projectId, card.canonicalId, selectedIds, 4), this.topicRelatedCardsForPlan(projectId, plan, selectedIds, 4)).slice(0, 4);
+        }
+        return cards;
+    }
+    relatedEpisodeCards(projectId, canonicalId, selectedIds, limit) {
+        const parsed = parseNodeId(canonicalId, projectId);
+        if (!parsed || parsed.type !== 'episode')
+            return [];
+        const rows = this.db.prepare(`
+      SELECT e.relation_type, e.confidence, d.node_id, d.label, d.metadata_json
+      FROM memory_edges e
+      JOIN memory_atlas_documents d ON d.project_id=e.project_id AND d.node_id=CASE
+        WHEN e.source_type='episode' AND e.source_id=? THEN 'episode:' || e.target_id
+        ELSE 'episode:' || e.source_id
+      END
+      WHERE e.project_id=? AND e.status IN ('active','weak') AND e.relation_type IN ('SAME_ISSUE','FOLLOWS_UP','REFINES','CORRECTS','CONTRADICTS','SUPERSEDES','RELATED_TO')
+        AND ((e.source_type='episode' AND e.source_id=?) OR (e.target_type='episode' AND e.target_id=?))
+      ORDER BY CASE e.relation_type WHEN 'SAME_ISSUE' THEN 1 WHEN 'FOLLOWS_UP' THEN 2 WHEN 'REFINES' THEN 3 ELSE 4 END, e.confidence DESC
+      LIMIT ?
+    `).all(parsed.id, projectId, parsed.id, parsed.id, Math.max(1, Math.min(limit * 3, 30)));
+        const result = [];
+        for (const row of rows) {
+            if (selectedIds.has(row.node_id))
+                continue;
+            result.push({
+                canonicalId: row.node_id,
+                displayTitle: row.label,
+                reason: row.relation_type === 'RELATED_TO' ? 'related topic but different issue/date' : row.relation_type.toLowerCase(),
+            });
+            if (result.length >= limit)
+                break;
+        }
+        return result;
+    }
+    topicRelatedCardsForPlan(projectId, plan, selectedIds, limit) {
+        const topicFacets = plan.facets.filter((facet) => facet.type === 'topic');
+        if (!topicFacets.length)
+            return [];
+        const rows = topicFacets.flatMap((facet) => this.episodeEdgesForFacet(projectId, facet));
+        const candidateIds = Array.from(new Set(rows.map((row) => row.source_id))).filter((id) => !selectedIds.has(`episode:${id}`));
+        if (!candidateIds.length)
+            return [];
+        return this.episodeRows(projectId, candidateIds)
+            .map((row) => ({
+            canonicalId: row.node_id,
+            displayTitle: row.label,
+            reason: 'related topic but different issue/date',
+        }))
+            .slice(0, Math.max(1, Math.min(limit, 20)));
+    }
     resolveTargetNodeIds(projectId, query) {
         const normalizedQuery = normalizeLookup(query);
         const candidates = this.db.prepare(`
       SELECT node_id,node_type,source_id,label,topic_path,metadata_json,evidence_event_ids_json
       FROM memory_atlas_documents
-      WHERE project_id=? AND node_type IN ('entity','topic','project') AND status NOT IN ('rejected','archived')
+      WHERE project_id=? AND node_type IN ('entity','topic','issue','project') AND status NOT IN ('rejected','archived')
     `).all(projectId);
         const seeds = [];
         const labels = [];
@@ -375,12 +449,34 @@ export class MemoryAtlasStore {
     }
     projectionNeedsRefresh(projectId) {
         const row = this.db.prepare(`
+      SELECT status, metadata_json FROM memory_atlas_projection_state
+      WHERE project_id=? AND projection_name=?
+    `).get(projectId, MEMORY_ATLAS_PROJECTION_NAME);
+        if (!row || row.status !== 'clean')
+            return true;
+        const metadata = parseMetadata(row.metadata_json);
+        if (metadata.projectionSchemaVersion !== MEMORY_ATLAS_PROJECTION_SCHEMA_VERSION)
+            return true;
+        const legacyDirty = this.db.prepare(`
       SELECT status FROM memory_atlas_projection_state
-      WHERE project_id=? AND projection_name='memory_atlas.v1'
+      WHERE project_id=? AND projection_name='memory_atlas.v1' AND status<>'clean'
     `).get(projectId);
-        return !row || row.status !== 'clean';
+        return Boolean(legacyDirty);
     }
     markProjectionClean(projectId, metadata = {}, now = Date.now()) {
+        const enrichedMetadata = {
+            ...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(?, ?, ?, 'clean', ?, NULL, ?)
+      ON CONFLICT(project_id, projection_name) DO UPDATE SET
+        cursor_value=excluded.cursor_value, status='clean', last_rebuild_at=excluded.last_rebuild_at,
+        last_error=NULL, metadata_json=excluded.metadata_json
+    `).run(projectId, MEMORY_ATLAS_PROJECTION_NAME, String(now), now, JSON.stringify(enrichedMetadata));
         this.db.prepare(`
       INSERT INTO memory_atlas_projection_state(
         project_id, projection_name, cursor_value, status, last_rebuild_at, last_error, metadata_json
@@ -388,17 +484,61 @@ export class MemoryAtlasStore {
       ON CONFLICT(project_id, projection_name) DO UPDATE SET
         cursor_value=excluded.cursor_value, status='clean', last_rebuild_at=excluded.last_rebuild_at,
         last_error=NULL, metadata_json=excluded.metadata_json
-    `).run(projectId, String(now), now, JSON.stringify(metadata));
+    `).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)
-      VALUES(?,'memory_atlas.v1','error',?,?,'{}')
+      VALUES(?,?,'error',?,?,?)
       ON CONFLICT(project_id,projection_name) DO UPDATE SET status='error',last_rebuild_at=excluded.last_rebuild_at,last_error=excluded.last_error
-    `).run(projectId, now, error.slice(0, 2000));
+    `).run(projectId, MEMORY_ATLAS_PROJECTION_NAME, now, error.slice(0, 2000), JSON.stringify({
+            projectionName: MEMORY_ATLAS_PROJECTION_NAME,
+            projectionSchemaVersion: MEMORY_ATLAS_PROJECTION_SCHEMA_VERSION,
+        }));
     }
     getProjectionState(projectId) {
-        const row = this.db.prepare(`SELECT status,last_rebuild_at,last_error FROM memory_atlas_projection_state WHERE project_id=? AND projection_name='memory_atlas.v1'`).get(projectId);
+        const row = this.db.prepare(`SELECT status,last_rebuild_at,last_error FROM memory_atlas_projection_state WHERE project_id=? AND projection_name=?`).get(projectId, MEMORY_ATLAS_PROJECTION_NAME);
         return row ? { status: row.status, lastRebuildAt: row.last_rebuild_at ?? undefined, lastError: row.last_error || undefined } : null;
     }
     listKnownProjectIds() {
@@ -436,6 +576,67 @@ export class MemoryAtlasStore {
             target: nodeId('topic', row.target_path, projectId), confidence: Number(row.confidence),
             evidenceEventIds: parseStringArray(row.evidence_event_ids_json) }));
     }
+    episodeEdgesForFacet(projectId, facet) {
+        const relationFilter = facet.relation ? 'AND relation_type=?' : '';
+        const params = facet.relation
+            ? [projectId, facet.type, facet.value, facet.relation]
+            : [projectId, facet.type, facet.value];
+        return this.db.prepare(`
+      SELECT source_id, relation_type, target_type, target_id, confidence, evidence_event_ids_json
+      FROM memory_edges
+      WHERE project_id=? AND source_type='episode' AND target_type=? AND target_id=? ${relationFilter}
+        AND status IN ('active','weak')
+      ORDER BY confidence DESC
+      LIMIT 5000
+    `).all(...params);
+    }
+    episodeRows(projectId, episodeIds) {
+        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);
+        const evidenceEventIds = parseStringArray(row.evidence_event_ids_json);
+        const matchedFacets = edges.map((edge) => facetFromEdge(edge, projectId));
+        const matchedPaths = edges.map((edge) => {
+            const facet = facetFromEdge(edge, projectId);
+            return { facet, via: [facet.nodeId, row.node_id], relation: edge.relation_type, confidence: Number(edge.confidence || 0) };
+        });
+        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',
+            displayTitle: row.label,
+            oneLineSummary: row.summary || undefined,
+            matchedFacets,
+            matchedPaths,
+            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),
+            whyMatched: matchedFacets.length ? `matched ${matchedFacets.map((facet) => `${facet.type}:${facet.value}`).join(', ')}` : 'matched canonical episode',
+            relatedButNotSelected: [],
+            evidenceEventIds,
+            evidenceTotal: evidenceEventIds.length,
+            evidenceReturned: 0,
+        };
+    }
 }
 function mapNode(row, score) {
     return { id: row.node_id, projectId: row.project_id, nodeType: row.node_type, sourceId: row.source_id,
@@ -479,22 +680,159 @@ catch {
 } }
 function escapeLike(value) { return value.replace(/[\\%_]/g, '\\$&'); }
 function nodeId(type, id, projectId) {
-    if (type === 'topic' || type === 'time')
+    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}`;
 }
 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) {
-    const topicPrefix = `topic:${projectId}:`;
-    if (value.startsWith(topicPrefix))
-        return { type: 'topic', id: value.slice(topicPrefix.length) };
-    const timePrefix = `time:${projectId}:`;
-    if (value.startsWith(timePrefix))
-        return { type: 'time', id: value.slice(timePrefix.length) };
+    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) };
+    }
     const separator = value.indexOf(':');
     if (separator <= 0 || separator === value.length - 1)
         return null;
     return { type: value.slice(0, separator), id: value.slice(separator + 1) };
 }
+function parseMetadata(value) {
+    try {
+        const parsed = JSON.parse(value || '{}');
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string' && item.length > 0) : [];
+}
+function optionalMetadataString(value) {
+    return typeof value === 'string' && value ? value : undefined;
+}
+function facetFromEdge(edge, projectId) {
+    return {
+        type: edge.target_type,
+        value: edge.target_id,
+        label: facetLabel(edge.target_type, edge.target_id),
+        nodeId: nodeId(edge.target_type, edge.target_id, projectId),
+        relation: edge.relation_type,
+    };
+}
+function facetLabel(type, value) {
+    if (type === 'topic')
+        return value.split('/').pop() || value;
+    if (type === 'issue') {
+        if (value === 'memory-context-blackbox')
+            return 'Memory Context 黑盒';
+        if (value === 'graph-runtime-blackbox')
+            return 'Graph Runtime 黑盒';
+        if (value === 'atlas-readability')
+            return 'Atlas 可读性黑盒';
+        if (value === 'auto-injection-mismatch')
+            return '自动注入不一致';
+    }
+    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();
+    const [first, ...rest] = sets;
+    const result = new Set();
+    for (const value of first ?? []) {
+        if (rest.every((set) => set.has(value)))
+            result.add(value);
+    }
+    return result;
+}
+function cardRank(card) {
+    return scoreCard(card) + Math.min(card.evidenceTotal || 0, 10) * 0.01;
+}
+function scoreCard(card) {
+    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();
+    for (const group of groups)
+        for (const card of group)
+            if (!merged.has(card.canonicalId))
+                merged.set(card.canonicalId, card);
+    return Array.from(merged.values());
+}

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

@@ -122,7 +122,7 @@ cogmem normalize-transcript --input ./hermes-sessions.jsonl --output ./hermes.no
 cogmem import-hermes --workspace . --project hermes --session ./hermes.normalized.md
 ```
 
-Cogmem 3.6.4 and later skip import batch sealing for empty episode boundaries and skip legacy empty Dream jobs so one bad imported episode cannot block the queue.
+Cogmem skips import batch sealing for empty episode boundaries and skips legacy empty Dream jobs so one bad imported episode cannot block the queue.
 
 After import, use this order:
 
@@ -162,7 +162,7 @@ cogmem memory list --project hermes --since <globalSeq> --order asc --json
 
 `vectors: 0` does not mean Cogmem has no memory. It means the dense vector index has no hot vectors yet. `memory recall` still falls back to governed raw ledger search and returns `sourceContext` locators. Broad inventory questions are expanded into structured cues such as `库存管理`, `在库`, `产品コード`, and `数量`; if compiled-memory candidates miss those cues, raw ledger evidence is preferred.
 
-`sourceContext` and `memory show --json` now share the same replay contract: each event has a `label`, optional `charRange` / `sourceRange`, and `sourceContext.window` / `window` metadata with requested counts, actual counts, `excludesAnchor`, `ordering`, `roleFilter`, and `overlapHandling`. Use those fields before quoting exact wording or explaining what happened before/after a recalled point. In 3.6.5, Raw Ledger list rows and Atlas search/explore evidence include `sourceLocator.command` and `sourceLocator.contextCommand`; run those commands before saying the source event is unavailable.
+`sourceContext` and `memory show --json` share the same replay contract: each event has a `label`, optional `charRange` / `sourceRange`, and `sourceContext.window` / `window` metadata with requested counts, actual counts, `excludesAnchor`, `ordering`, `roleFilter`, and `overlapHandling`. Use those fields before quoting exact wording or explaining what happened before/after a recalled point. Raw Ledger list rows and Atlas search/explore evidence include `sourceLocator.command` and `sourceLocator.contextCommand`; run those commands before saying the source event is unavailable.
 
 Check status with:
 
@@ -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`; in 3.6.5 it scans the historical ledger by cursor and can resume with `--since <globalSeq>`. 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.1 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.6.5 exposes seven 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, time, topic, entity/target, memory-kind, action, and keyword conditions like table filters, so cold memory can be revived without requiring an entity-time-action tuple. Touch only nodes actually used, and follow returned event IDs or `sourceLocator` commands to raw evidence before quoting exact wording.
+Cogmem 3.7.1 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