cogmem 3.6.4 → 3.7.0

package/dist/agent/AgentRecallQueryCompiler.js

@@ -99,6 +99,9 @@ export function inferAgentRecallIntent(query) {
     if (/原话|怎么说的|完整对话|上一句|下一句|exact quote|verbatim/.test(text)) {
         return 'forensic_quote';
     }
+    if (/记得.{0,12}(聊过|讨论过|说过)|还记得|之前.{0,12}(聊过|讨论过|说过)|以前.{0,12}(聊过|讨论过|说过)|(过去|几个月前|半年前|上个月|前几天|昨天|上次|上个).{0,20}(聊过|讨论过|说过)|当时.{0,12}(聊|说|问)|那次.{0,12}(聊|说|问)|有没有.{0,12}(记录|聊过|讨论过)|have we discussed|did we talk about|previously discussed/.test(text)) {
+        return 'historical_discussion';
+    }
     return 'memory_recall';
 }
 export function extractRecallKeywords(text) {
@@ -168,10 +171,19 @@ function buildSemanticCuePhrases(keywords, query, anchorText) {
     const hasBlackBox = merged.includes('黑盒') || /黑盒|black\s*box/iu.test(text);
     if (hasMemory && hasBlackBox) {
         out.push('记忆 黑盒');
+        out.push('记忆黑盒');
+        out.push('CogMem Memory Context');
+        out.push('Memory Context');
+        out.push('上下文注入');
+        out.push('sourceContext 原文下钻');
         out.push('存档 黑盒');
         out.push('对话 存档 黑盒');
         out.push('上下文 黑盒');
         out.push('黑盒');
+        if (/graph|图|卡死|database locked|zombie|锁/iu.test(text)) {
+            out.push('memory graph 黑盒');
+            out.push('database locked zombie');
+        }
     }
     else if (hasBlackBox) {
         out.push('黑盒');

package/dist/atlas/EpisodeTitleGenerator.d.ts

@@ -0,0 +1,31 @@
+import type { MemoryEvent } from '../types/index.js';
+export interface EpisodeTitleInput {
+    episodeId: string;
+    summary?: string | null;
+    topicPath?: string | null;
+    episodeType?: string | null;
+    startedAt?: number | null;
+    events: MemoryEvent[];
+}
+export interface EpisodeTitleResult {
+    displayTitle: string;
+    oneLineSummary: string;
+    topicHints: string[];
+    issueHints: string[];
+    eventKind: string;
+    userIntent?: string;
+    localDate?: string;
+    confidence: number;
+    reviewNeeded: boolean;
+    sourceEventIds: string[];
+    generatorTrace: {
+        usedUserText: boolean;
+        usedAssistantText: boolean;
+        fallback: boolean;
+        matchedRules: string[];
+    };
+}
+export declare class EpisodeTitleGenerator {
+    generate(input: EpisodeTitleInput): EpisodeTitleResult;
+}
+//# sourceMappingURL=EpisodeTitleGenerator.d.ts.map

package/dist/atlas/EpisodeTitleGenerator.js

@@ -0,0 +1,152 @@
+import { eventTextForMemory } from '../episode/CogmemBlockStripper.js';
+const TITLE_RULES = [
+    {
+        id: 'memory_context_blackbox',
+        test: (text) => /(cogmem memory context|memory context|sourcecontext|source context|原文下钻|上下文.*黑盒|记忆上下文|摘要.*原话|记忆黑盒)/i.test(text) &&
+            !/(database locked|zombie|卡死|atlas|节点|事件名称|manual recall.*before_prompt_build|手动.*recall.*自动注入)/i.test(text),
+        displayTitle: 'CogMem Memory Context 黑盒与原文下钻',
+        oneLineSummary: '用户指出注入的 CogMem Memory Context 像黑盒，需要能从摘要下钻到原始对话。',
+        topicHints: ['memory-blackbox', 'source-drilldown', 'context-injection'],
+        issueHints: ['memory-context-blackbox'],
+        eventKind: 'diagnostic',
+        userIntent: 'inspect_original_context',
+        confidence: 0.92,
+    },
+    {
+        id: 'graph_runtime_blackbox',
+        test: (text) => /(memory graph|graph.*卡死|卡死|database locked|sqlite.*lock|zombie|僵尸进程|锁冲突)/i.test(text),
+        displayTitle: 'memory graph 卡死与数据库锁',
+        oneLineSummary: '用户遇到 memory graph 卡死、SQLite 锁冲突或残留进程，导致图谱与召回命令不稳定。',
+        topicHints: ['memory-blackbox', 'graph-runtime', 'sqlite-locks'],
+        issueHints: ['graph-runtime-blackbox'],
+        eventKind: 'bug',
+        userIntent: 'debug_graph_runtime',
+        confidence: 0.9,
+    },
+    {
+        id: 'atlas_readability_blackbox',
+        test: (text) => /(atlas|图谱|节点|事件名称|父主题|多维|facet|canonical|可读性|label|标题)/i.test(text),
+        displayTitle: 'Atlas 节点命名与多维导航',
+        oneLineSummary: '用户要求 Atlas 节点拥有清晰事件标题，并通过时间、主题、issue、实体等 facet 导航到同一份 canonical episode。',
+        topicHints: ['memory-blackbox', 'atlas-readability', 'facet-navigation'],
+        issueHints: ['atlas-readability'],
+        eventKind: 'plan',
+        userIntent: 'improve_atlas_navigation',
+        confidence: 0.88,
+    },
+    {
+        id: 'auto_injection_mismatch',
+        test: (text) => /((manual recall|手动.*recall|CLI).*(自动注入|before_prompt_build|OpenClaw)|(自动注入|before_prompt_build|OpenClaw).*(manual recall|手动.*recall|CLI)|注入.*不一致|selected.*different|选择.*不同)/i.test(text),
+        displayTitle: '自动注入与手动 recall 不一致',
+        oneLineSummary: '用户发现 OpenClaw 自动注入与手动 recall 的记忆选择不一致，需要暴露选择依据和匹配 facet。',
+        topicHints: ['context-injection', 'memory-blackbox', 'openclaw'],
+        issueHints: ['auto-injection-mismatch'],
+        eventKind: 'diagnostic',
+        userIntent: 'align_auto_injection',
+        confidence: 0.89,
+    },
+];
+export class EpisodeTitleGenerator {
+    generate(input) {
+        const userEvents = input.events.filter((event) => event.role === 'user');
+        const assistantEvents = input.events.filter((event) => event.role === 'assistant' || event.role === 'agent');
+        const userText = normalizeText(userEvents.map(eventTextForMemory).join('\n'));
+        const assistantText = normalizeText(assistantEvents.map(eventTextForMemory).join('\n'));
+        const summaryText = normalizeText([input.summary, input.topicPath, input.episodeType].filter(Boolean).join('\n'));
+        const preferredText = [userText, summaryText, assistantText].filter(Boolean).join('\n');
+        const matchedRule = TITLE_RULES.find((rule) => rule.test(preferredText));
+        const localDate = inferLocalDate(input.events, input.startedAt);
+        const sourceEventIds = sourceIdsFor(userEvents.length > 0 ? userEvents : input.events);
+        if (matchedRule) {
+            return {
+                displayTitle: boundTitle(matchedRule.displayTitle),
+                oneLineSummary: matchedRule.oneLineSummary,
+                topicHints: matchedRule.topicHints,
+                issueHints: matchedRule.issueHints,
+                eventKind: matchedRule.eventKind,
+                userIntent: matchedRule.userIntent,
+                localDate,
+                confidence: matchedRule.confidence,
+                reviewNeeded: matchedRule.confidence < 0.65,
+                sourceEventIds,
+                generatorTrace: {
+                    usedUserText: userText.length > 0,
+                    usedAssistantText: userText.length === 0 && assistantText.length > 0,
+                    fallback: false,
+                    matchedRules: [matchedRule.id],
+                },
+            };
+        }
+        const fallbackTitle = fallbackDisplayTitle({ userText, summaryText, topicPath: input.topicPath, episodeType: input.episodeType });
+        return {
+            displayTitle: fallbackTitle,
+            oneLineSummary: fallbackSummary({ userText, summaryText, topicPath: input.topicPath }),
+            topicHints: inferTopicHints(preferredText),
+            issueHints: [],
+            eventKind: normalizeKind(input.episodeType) ?? 'explanation',
+            localDate,
+            confidence: 0.55,
+            reviewNeeded: true,
+            sourceEventIds,
+            generatorTrace: {
+                usedUserText: userText.length > 0,
+                usedAssistantText: userText.length === 0 && assistantText.length > 0,
+                fallback: true,
+                matchedRules: [],
+            },
+        };
+    }
+}
+function normalizeText(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+function sourceIdsFor(events) {
+    return events.map((event) => event.eventId).filter(Boolean).slice(0, 20);
+}
+function inferLocalDate(events, startedAt) {
+    for (const event of events) {
+        const candidate = event.localDate;
+        if (candidate && /^\d{4}-\d{2}-\d{2}$/.test(candidate))
+            return candidate;
+    }
+    const timestamp = events.find((event) => Number.isFinite(event.occurredAt))?.occurredAt ?? startedAt;
+    if (!timestamp || !Number.isFinite(timestamp))
+        return undefined;
+    return new Date(timestamp).toISOString().slice(0, 10);
+}
+function boundTitle(title) {
+    const clean = normalizeText(title).replace(/[0-9a-f]{8}-[0-9a-f-]{12,}/gi, '').trim();
+    if (/[^\x00-\x7F]/.test(clean))
+        return clean.length > 32 ? `${clean.slice(0, 31)}…` : clean;
+    const words = clean.split(/\s+/);
+    return words.length > 12 ? words.slice(0, 12).join(' ') : clean;
+}
+function fallbackDisplayTitle(input) {
+    const source = input.userText || input.summaryText || input.topicPath || input.episodeType || 'Untitled episode';
+    const firstSentence = source.split(/[。.!?\n]/).find(Boolean) ?? source;
+    const title = boundTitle(firstSentence);
+    if (!title || /^episode[:\s-]*[0-9a-f-]+$/i.test(title))
+        return '未命名记忆事件';
+    return title;
+}
+function fallbackSummary(input) {
+    const source = input.summaryText || input.userText || input.topicPath || '该 episode 缺少可读摘要，需要人工复核。';
+    const sentence = source.split(/[。.!?\n]/).find(Boolean) ?? source;
+    return normalizeText(sentence).slice(0, 140);
+}
+function inferTopicHints(text) {
+    const hints = new Set();
+    if (/cogmem|记忆|memory/i.test(text))
+        hints.add('memory');
+    if (/openclaw/i.test(text))
+        hints.add('openclaw');
+    if (/hermes/i.test(text))
+        hints.add('hermes');
+    return Array.from(hints);
+}
+function normalizeKind(kind) {
+    if (!kind)
+        return undefined;
+    const normalized = kind.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+    return normalized || undefined;
+}

package/dist/atlas/FacetQueryPlanner.d.ts

@@ -0,0 +1,31 @@
+export type FacetType = 'time' | 'topic' | 'issue' | 'entity' | 'session' | 'thread' | 'memoryKind' | 'actionKind';
+export type FacetOperator = 'intersection' | 'union';
+export interface PlannedFacet {
+    type: FacetType;
+    value: string;
+    label: string;
+    nodeId?: string;
+    relation?: string;
+    granularity?: 'year' | 'month' | 'day';
+    from?: number;
+    to?: number;
+}
+export interface FacetQueryPlan {
+    intent: string;
+    operator: FacetOperator;
+    facets: PlannedFacet[];
+    temporalIntent?: 'timeline';
+    groupBy?: 'topic' | 'time' | 'issue';
+    exactness: 'strict' | 'relaxed';
+    requiresIntersection: boolean;
+    keywords: string[];
+    query: string;
+}
+export interface FacetQueryPlannerOptions {
+    projectId: string;
+    now?: number;
+}
+export declare class FacetQueryPlanner {
+    plan(query: string, options: FacetQueryPlannerOptions): FacetQueryPlan;
+}
+//# sourceMappingURL=FacetQueryPlanner.d.ts.map

package/dist/atlas/FacetQueryPlanner.js

@@ -0,0 +1,188 @@
+const ISSUE_RULES = [
+    {
+        value: 'memory-context-blackbox',
+        label: 'Memory Context 黑盒',
+        test: (text) => /(memory context|sourcecontext|source context|上下文.*黑盒|记忆上下文|原文下钻|摘要.*原话)/i.test(text),
+    },
+    {
+        value: 'graph-runtime-blackbox',
+        label: 'Graph Runtime 黑盒',
+        test: (text) => /(memory graph|graph.*卡死|database locked|sqlite.*lock|zombie|僵尸进程|锁冲突|卡死)/i.test(text),
+    },
+    {
+        value: 'atlas-readability',
+        label: 'Atlas 可读性黑盒',
+        test: (text) => /(atlas|图谱|节点|事件名称|父主题|多维|facet|canonical|可读性|标题)/i.test(text),
+    },
+    {
+        value: 'auto-injection-mismatch',
+        label: '自动注入不一致',
+        test: (text) => /(自动注入|before_prompt_build|manual recall|手动.*recall|注入.*不一致|COGMEM_RECALL_CONTEXT)/i.test(text),
+    },
+];
+const TOPIC_RULES = [
+    {
+        value: 'memory-blackbox',
+        label: '记忆黑盒',
+        test: (text) => /(记忆黑盒|memory.*blackbox|memory context|sourcecontext|graph.*卡死|atlas|自动注入|上下文.*黑盒)/i.test(text),
+    },
+    {
+        value: 'source-drilldown',
+        label: '原文下钻',
+        test: (text) => /(sourcecontext|source context|原文下钻|原话|摘要.*原文)/i.test(text),
+    },
+    {
+        value: 'context-injection',
+        label: '上下文注入',
+        test: (text) => /(自动注入|context injection|before_prompt_build|COGMEM_RECALL_CONTEXT|注入)/i.test(text),
+    },
+];
+export class FacetQueryPlanner {
+    plan(query, options) {
+        const normalized = query.trim();
+        const facets = [];
+        const timeFacet = parseTimeFacet(normalized, options.now ?? Date.now());
+        if (timeFacet)
+            facets.push(withNodeId(timeFacet, options.projectId));
+        const timeline = /(后来|继续|timeline|演化|发展|之后)/i.test(normalized);
+        const matchedIssueValues = new Set();
+        for (const rule of TOPIC_RULES) {
+            if (rule.test(normalized)) {
+                facets.push(withNodeId({ type: 'topic', value: `PROJECT/${options.projectId}/${rule.value}`, label: rule.label, relation: 'ABOUT_TOPIC' }, options.projectId));
+            }
+        }
+        for (const rule of ISSUE_RULES) {
+            if (rule.test(normalized)) {
+                facets.push(withNodeId({ type: 'issue', value: rule.value, label: rule.label, relation: 'PART_OF_ISSUE' }, options.projectId));
+                matchedIssueValues.add(rule.value);
+            }
+        }
+        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 facet of parseKindFacets(normalized, options.projectId))
+            facets.push(facet);
+        return {
+            intent: /聊过|记得|还记得|讨论|原话|那次/i.test(normalized) ? 'historical_discussion' : 'graph_search',
+            operator: 'intersection',
+            facets: dedupeFacets(facets),
+            temporalIntent: timeline ? 'timeline' : undefined,
+            groupBy: timeline ? 'time' : timeFacet && facets.length === 1 ? 'topic' : facets.some((facet) => facet.type === 'issue') ? 'issue' : undefined,
+            exactness: 'strict',
+            requiresIntersection: facets.length > 1,
+            keywords: extractKeywords(normalized),
+            query: normalized,
+        };
+    }
+}
+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 parseKindFacets(query, projectId) {
+    const facets = [];
+    const memoryKindRules = [
+        ['bug', /(bug|问题|卡死|failure|故障|错误|报错)/i],
+        ['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));
+    }
+    return facets;
+}
+function parseTimeFacet(query, now) {
+    const currentYear = new Date(now).getUTCFullYear();
+    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]));
+    const cnDay = query.match(/(?:(20\d{2})年)?(\d{1,2})月(\d{1,2})(?:号|日)?/);
+    if (cnDay)
+        return dayFacet(cnDay[1] ? Number(cnDay[1]) : currentYear, Number(cnDay[2]), Number(cnDay[3]));
+    const isoMonth = query.match(/(20\d{2})[-年\/.](\d{1,2})月?/);
+    if (isoMonth)
+        return monthFacet(Number(isoMonth[1]), Number(isoMonth[2]));
+    const year = query.match(/\b(20\d{2})\b|((20\d{2})年)/);
+    if (year)
+        return yearFacet(Number(year[1] ?? year[3]));
+    if (/去年/.test(query))
+        return yearFacet(currentYear - 1);
+    return undefined;
+}
+function dayFacet(year, month, day) {
+    const label = `${year}-${pad(month)}-${pad(day)}`;
+    return {
+        type: 'time',
+        value: label,
+        label,
+        relation: 'OCCURRED_ON',
+        granularity: 'day',
+        from: Date.UTC(year, month - 1, day),
+        to: Date.UTC(year, month - 1, day + 1),
+    };
+}
+function monthFacet(year, month) {
+    const label = `${year}-${pad(month)}`;
+    return {
+        type: 'time',
+        value: label,
+        label,
+        relation: 'OCCURRED_IN',
+        granularity: 'month',
+        from: Date.UTC(year, month - 1, 1),
+        to: Date.UTC(year, month, 1),
+    };
+}
+function yearFacet(year) {
+    const label = String(year);
+    return {
+        type: 'time',
+        value: label,
+        label,
+        relation: 'OCCURRED_IN',
+        granularity: 'year',
+        from: Date.UTC(year, 0, 1),
+        to: Date.UTC(year + 1, 0, 1),
+    };
+}
+function withNodeId(facet, projectId) {
+    return {
+        ...facet,
+        nodeId: `${facet.type}:${projectId}:${facet.value}`,
+    };
+}
+function dedupeFacets(facets) {
+    const seen = new Set();
+    return facets.filter((facet) => {
+        const key = `${facet.type}:${facet.value}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function extractKeywords(query) {
+    return query
+        .split(/[^\p{L}\p{N}_-]+/u)
+        .map((token) => token.trim())
+        .filter((token) => token.length >= 2)
+        .slice(0, 8);
+}
+function pad(value) {
+    return String(value).padStart(2, '0');
+}

package/dist/atlas/GraphCurator.d.ts

@@ -0,0 +1,27 @@
+import type Database from 'bun:sqlite';
+import type { EventStore } from '../store/EventStore.js';
+import { MemoryAtlasStore } from '../store/MemoryAtlasStore.js';
+export interface GraphCuratorResult {
+    episodeCount: number;
+    facetNodeCount: number;
+    facetEdgeCount: number;
+    reviewNeeded: number;
+}
+export declare class GraphCurator {
+    private readonly db;
+    private readonly eventStore;
+    private readonly atlasStore;
+    private readonly titleGenerator;
+    constructor(db: Database, eventStore: EventStore, atlasStore: MemoryAtlasStore);
+    rebuild(projectId: string, now?: number): GraphCuratorResult;
+    private episodeEventIds;
+    private facetTargetsFor;
+    private upsertFacetNode;
+    private upsertRawEventNode;
+    private projectEpisodeRelations;
+    private upsertEpisodeRelation;
+    private entityHintsFor;
+    private deleteFacetEdges;
+    private upsertEdge;
+}
+//# sourceMappingURL=GraphCurator.d.ts.map