cogmem 3.6.2

package/dist/agent/AgentRecallQueryCompiler.d.ts

@@ -0,0 +1,20 @@
+export type AgentRecallIntent = 'memory_recall' | 'previous_session_summary' | 'forensic_quote';
+export interface AgentRecallQueryCompileInput {
+    query: string;
+    intent?: AgentRecallIntent;
+    anchorText?: string;
+}
+export interface AgentRecallQueryPlan {
+    originalQuery: string;
+    intent: AgentRecallIntent;
+    primarySearchText: string;
+    searchTexts: string[];
+    keywords: string[];
+    semanticCuePhrases: string[];
+    temporalHints: string[];
+    anchorUsed: boolean;
+}
+export declare function compileAgentRecallQuery(input: AgentRecallQueryCompileInput): AgentRecallQueryPlan;
+export declare function inferAgentRecallIntent(query: string): AgentRecallIntent;
+export declare function extractRecallKeywords(text: string): string[];
+//# sourceMappingURL=AgentRecallQueryCompiler.d.ts.map

package/dist/agent/AgentRecallQueryCompiler.js

@@ -0,0 +1,289 @@
+const PROTECTED_PHRASES = [
+    'CogMem Memory Context',
+    'Memory Context',
+    'OpenClaw',
+    'Hermes',
+    'cogmem',
+    'Obsidian',
+    '记忆内核',
+    '记忆黑盒',
+    '黑盒',
+    '记忆',
+    '因果链',
+    '原话',
+    '上下文',
+    '上下文噪声',
+    '偏好',
+    '项目',
+    '约束',
+    '边界',
+    '库存',
+    '配置',
+    '安装',
+    '更新',
+    '重启',
+    '报错',
+    '错误',
+    '工具',
+];
+const QUERY_FILLERS = [
+    '我现在不是问你泛泛解释',
+    '不是问你泛泛解释',
+    '泛泛解释',
+    '我不是要你',
+    '我是问',
+    '我想知道',
+    '你还记不记得',
+    '还记不记得',
+    '你还记得',
+    '还记得',
+    '你记得吗',
+    '记得吗',
+    '我们之前讨论过关于',
+    '我们之前讨论过',
+    '之前讨论过',
+    '当时我问你的',
+    '当时的',
+    '这个问题时',
+    '这个问题',
+    '的问题',
+    '问题',
+    '是什么',
+    '什么',
+    'the',
+    'a',
+    'an',
+    'please',
+];
+const QUOTE_TERMS = new Set(['原话', 'exact', 'quote', 'verbatim']);
+export function compileAgentRecallQuery(input) {
+    const originalQuery = normalizeWhitespace(input.query);
+    const intent = input.intent ?? inferAgentRecallIntent(originalQuery);
+    const anchorText = normalizeWhitespace(input.anchorText || '');
+    const queryKeywords = extractRecallKeywords(originalQuery);
+    const anchorKeywords = extractRecallKeywords(anchorText);
+    const keywordSource = anchorKeywords.length > 0 && isVagueForensicFollowup(originalQuery)
+        ? anchorKeywords
+        : mergeKeywords(queryKeywords, anchorKeywords);
+    const keywords = intent === 'forensic_quote'
+        ? keywordSource.filter((keyword) => !QUOTE_TERMS.has(keyword.toLowerCase()))
+        : keywordSource;
+    const residual = stripFillers(originalQuery);
+    const anchorResidual = stripFillers(anchorText);
+    const semanticCuePhrases = buildSemanticCuePhrases(keywords, originalQuery, anchorText);
+    const temporalHints = extractTemporalHints(originalQuery);
+    const searchTexts = uniqueNonEmpty([
+        joinKeywords(keywords),
+        joinKeywords(queryKeywords.filter((keyword) => !QUOTE_TERMS.has(keyword.toLowerCase()))),
+        joinKeywords(anchorKeywords.filter((keyword) => !QUOTE_TERMS.has(keyword.toLowerCase()))),
+        ...semanticCuePhrases,
+        residual && keywords.length === 0 ? residual : '',
+        anchorResidual && keywords.length === 0 ? anchorResidual : '',
+    ]).filter((candidate) => !containsFiller(candidate));
+    return {
+        originalQuery,
+        intent,
+        primarySearchText: searchTexts[0] || residual || originalQuery,
+        searchTexts: searchTexts.length > 0 ? searchTexts : [originalQuery],
+        keywords,
+        semanticCuePhrases,
+        temporalHints,
+        anchorUsed: anchorKeywords.length > 0,
+    };
+}
+export function inferAgentRecallIntent(query) {
+    const text = query.toLowerCase();
+    if (/(上一个|上个|上一|上次).{0,12}(会话|session)|previous session|last session/.test(text)) {
+        return 'previous_session_summary';
+    }
+    if (/原话|怎么说的|完整对话|上一句|下一句|exact quote|verbatim/.test(text)) {
+        return 'forensic_quote';
+    }
+    return 'memory_recall';
+}
+export function extractRecallKeywords(text) {
+    const normalized = normalizeWhitespace(text);
+    if (!normalized)
+        return [];
+    const found = [];
+    const lower = normalized.toLowerCase();
+    for (const phrase of PROTECTED_PHRASES) {
+        if (lower.includes(phrase.toLowerCase())) {
+            if (phrase === '记忆黑盒') {
+                found.push('记忆', '黑盒');
+            }
+            else if (phrase === '记忆内核') {
+                found.push('记忆');
+            }
+            else if (phrase === 'cogmem' && lower.includes('cogmem memory context')) {
+                continue;
+            }
+            else if (phrase === 'Memory Context' && lower.includes('cogmem memory context')) {
+                continue;
+            }
+            else if (phrase !== '上下文' && phrase !== '问题') {
+                found.push(phrase);
+            }
+        }
+    }
+    for (const token of normalized.split(/[^\p{L}\p{N}_-]+/u)) {
+        const cleaned = token.trim();
+        if (!cleaned || cleaned.length < 3)
+            continue;
+        if (/^[\u4e00-\u9fff]+$/u.test(cleaned))
+            continue;
+        if (lower.includes('cogmem memory context') && /^(cogmem|memory|context)$/i.test(cleaned))
+            continue;
+        if (QUERY_FILLERS.some((filler) => filler.toLowerCase() === cleaned.toLowerCase()))
+            continue;
+        found.push(cleaned);
+    }
+    const existingKeywords = mergeKeywords(found);
+    found.push(...extractCjkCueTerms(normalized).filter((term) => !existingKeywords.some((keyword) => (term.includes(keyword) || keyword.includes(term)))));
+    return mergeKeywords(found);
+}
+function isVagueForensicFollowup(query) {
+    const withoutFillers = stripFillers(query);
+    const keywords = extractRecallKeywords(withoutFillers).filter((keyword) => !QUOTE_TERMS.has(keyword.toLowerCase()));
+    return /原话|exact quote|verbatim/.test(query.toLowerCase()) && keywords.length === 0;
+}
+function stripFillers(value) {
+    let output = normalizeWhitespace(value);
+    for (const filler of QUERY_FILLERS) {
+        output = output.replace(new RegExp(escapeRegExp(filler), 'giu'), ' ');
+    }
+    return normalizeWhitespace(output.replace(/[，。？！、；：,.?!;:]/g, ' '));
+}
+function containsFiller(value) {
+    return QUERY_FILLERS.some((filler) => value.toLowerCase().includes(filler.toLowerCase()));
+}
+function joinKeywords(keywords) {
+    return mergeKeywords(keywords).join(' ');
+}
+function buildSemanticCuePhrases(keywords, query, anchorText) {
+    const merged = mergeKeywords(keywords);
+    const text = `${query}\n${anchorText}`;
+    const out = [];
+    const hasMemory = merged.includes('记忆') || /memory|CogMem|记忆/u.test(text);
+    const hasBlackBox = merged.includes('黑盒') || /黑盒|black\s*box/iu.test(text);
+    if (hasMemory && hasBlackBox) {
+        out.push('记忆 黑盒');
+        out.push('存档 黑盒');
+        out.push('对话 存档 黑盒');
+        out.push('上下文 黑盒');
+        out.push('黑盒');
+    }
+    else if (hasBlackBox) {
+        out.push('黑盒');
+        out.push('存档 黑盒');
+    }
+    if (/原话|exact quote|verbatim/iu.test(text) && hasBlackBox) {
+        out.push('黑盒 原话');
+    }
+    if (/CogMem Memory Context/iu.test(text)) {
+        out.push('CogMem Memory Context');
+        out.push('Memory Context');
+    }
+    if (merged.includes('库存') || /库存|inventory|stock/iu.test(text)) {
+        out.push('库存管理');
+        out.push('在库');
+        out.push('产品コード');
+        out.push('数量');
+    }
+    return uniqueNonEmpty(out);
+}
+function extractTemporalHints(query) {
+    const hints = [];
+    if (/之前|以前|过去|几个月前|半年前|上个月|前几天|昨天|上次|上个|还记得|previous|before|last/i.test(query)) {
+        hints.push('past');
+    }
+    if (/昨天|yesterday/i.test(query))
+        hints.push('yesterday');
+    if (/上一个|上个|上次|previous|last/i.test(query))
+        hints.push('previous');
+    return uniqueNonEmpty(hints);
+}
+function mergeKeywords(...groups) {
+    const out = [];
+    const seen = new Set();
+    for (const keyword of groups.flat()) {
+        const normalized = normalizeWhitespace(keyword);
+        if (!normalized)
+            continue;
+        const key = normalized.toLowerCase();
+        if (seen.has(key))
+            continue;
+        if (normalized === '记忆内核' && seen.has('记忆'))
+            continue;
+        seen.add(key);
+        out.push(normalized);
+    }
+    return out;
+}
+const CJK_QUERY_STOP_PHRASES = [
+    ...QUERY_FILLERS,
+    '我们',
+    '你们',
+    '你',
+    '我',
+    '是否',
+    '是不是',
+    '有没有',
+    '哪些',
+    '哪个',
+    '什么',
+    '多少',
+    '记录过',
+    '聊过',
+    '讨论过',
+    '之前',
+    '以前',
+    '关于',
+    '和',
+    '这个',
+    '那个',
+    '问题',
+    '的吗',
+    '吗',
+    '呢',
+    '的',
+    '了',
+    '过',
+];
+function extractCjkCueTerms(text) {
+    const candidates = [];
+    for (const match of text.matchAll(/[\u3040-\u30ff\u3400-\u9fff]{2,}/gu)) {
+        let chunk = match[0];
+        for (const filler of CJK_QUERY_STOP_PHRASES) {
+            chunk = chunk.replace(new RegExp(escapeRegExp(filler), 'giu'), ' ');
+        }
+        for (const part of chunk.split(/\s+/)) {
+            const trimmed = part.trim();
+            if (trimmed.length >= 2 && trimmed.length <= 12)
+                candidates.push(trimmed);
+            if (trimmed.length > 12) {
+                for (let index = 0; index <= trimmed.length - 2 && candidates.length < 12; index += 2) {
+                    candidates.push(trimmed.slice(index, Math.min(index + 4, trimmed.length)));
+                }
+            }
+        }
+    }
+    return candidates;
+}
+function uniqueNonEmpty(values) {
+    const out = [];
+    const seen = new Set();
+    for (const value of values.map(normalizeWhitespace)) {
+        if (!value || seen.has(value.toLowerCase()))
+            continue;
+        seen.add(value.toLowerCase());
+        out.push(value);
+    }
+    return out;
+}
+function normalizeWhitespace(value) {
+    return String(value || '').replace(/\s+/g, ' ').trim();
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/agent/ContextHygiene.d.ts

@@ -0,0 +1,9 @@
+export declare const COGMEM_RECALL_BLOCK_RE: RegExp;
+export interface StripCogmemRecallBlocksResult {
+    text: string;
+    stripped: boolean;
+    strippedChars: number;
+    blockCount: number;
+}
+export declare function stripCogmemRecallBlocks(text: string): StripCogmemRecallBlocksResult;
+//# sourceMappingURL=ContextHygiene.d.ts.map

package/dist/agent/ContextHygiene.js

@@ -0,0 +1,20 @@
+export const COGMEM_RECALL_BLOCK_RE = /<(COGMEM_RECALL_CONTEXT|COGMEM_MEMORY_ATLAS|COGMEM_TURN_BRIDGE|COGMEM_SESSION_STATE|COGMEM_STRATEGY_CONTEXT)\b[\s\S]*?<\/\1>/g;
+export function stripCogmemRecallBlocks(text) {
+    const input = String(text || '');
+    let strippedChars = 0;
+    let blockCount = 0;
+    const output = input
+        .replace(COGMEM_RECALL_BLOCK_RE, (match) => {
+        strippedChars += match.length;
+        blockCount += 1;
+        return '';
+    })
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+    return {
+        text: output,
+        stripped: blockCount > 0,
+        strippedChars,
+        blockCount,
+    };
+}

package/dist/agent/MemoryUsageReceipt.d.ts

@@ -0,0 +1,35 @@
+import type { AgentRecallItem, AgentRecallSourceAnchor } from './AgentMemoryBackend.js';
+export interface MemoryUsageReceiptSourceAnchor {
+    memoryId?: string;
+    eventId?: string;
+    sessionId?: string;
+    role?: string;
+}
+export interface MemoryUsageReceipt {
+    sessionId: string;
+    turnId: string;
+    createdAt: number;
+    userQueryDigest: string;
+    assistantAnswerDigest: string;
+    usedMemoryIds: string[];
+    sourceAnchors: MemoryUsageReceiptSourceAnchor[];
+    usedThemes: string[];
+    workingConclusion?: string;
+    ttlTurns: number;
+    compileAllowed: false;
+}
+export interface CreateMemoryUsageReceiptInput {
+    sessionId: string;
+    turnId?: string;
+    createdAt?: number;
+    userText: string;
+    assistantText: string;
+    recallItems?: Array<Pick<AgentRecallItem, 'id' | 'text' | 'tags'> & {
+        sourceAnchor?: AgentRecallSourceAnchor;
+    }>;
+    ttlTurns?: number;
+}
+export declare function createMemoryUsageReceipt(input: CreateMemoryUsageReceiptInput): MemoryUsageReceipt;
+export declare function formatMemoryUsageBridge(receipt: MemoryUsageReceipt, maxChars?: number): string;
+export declare function shouldInjectMemoryUsageBridge(query: string, receipt: MemoryUsageReceipt): boolean;
+//# sourceMappingURL=MemoryUsageReceipt.d.ts.map

package/dist/agent/MemoryUsageReceipt.js

@@ -0,0 +1,136 @@
+import { createHash } from 'node:crypto';
+export function createMemoryUsageReceipt(input) {
+    const createdAt = input.createdAt ?? Date.now();
+    const turnId = input.turnId || `${input.sessionId}:${createdAt}`;
+    const recallItems = Array.isArray(input.recallItems) ? input.recallItems : [];
+    const usedMemoryIds = uniqueNonEmpty(recallItems.map((item) => item.id)).slice(0, 8);
+    const sourceAnchors = recallItems
+        .slice(0, 8)
+        .map((item) => ({
+        memoryId: item.id,
+        eventId: item.sourceAnchor?.eventId,
+        sessionId: item.sourceAnchor?.sessionId,
+        role: item.sourceAnchor?.role,
+    }))
+        .filter((anchor) => anchor.memoryId || anchor.eventId || anchor.sessionId || anchor.role);
+    return {
+        sessionId: input.sessionId,
+        turnId,
+        createdAt,
+        userQueryDigest: digestText(input.userText),
+        assistantAnswerDigest: digestText(input.assistantText),
+        usedMemoryIds,
+        sourceAnchors,
+        usedThemes: extractThemes(recallItems).slice(0, 5),
+        workingConclusion: firstSentence(input.assistantText, 220),
+        ttlTurns: Math.max(1, Math.min(10, Math.floor(input.ttlTurns ?? 3))),
+        compileAllowed: false,
+    };
+}
+export function formatMemoryUsageBridge(receipt, maxChars = 1200) {
+    const lines = [
+        `<COGMEM_TURN_BRIDGE turn_id="${escapeAttribute(receipt.turnId)}" source="cogmem" compact="true" ttl_turns="${receipt.ttlTurns}" compile_allowed="false">`,
+        'Previous assistant answer used Cogmem memory.',
+        '',
+        'Used memory themes:',
+        ...listLines(receipt.usedThemes),
+        '',
+        'Working conclusion produced in that turn:',
+        `- ${receipt.workingConclusion || 'No compact conclusion recorded.'}`,
+        '',
+        'Source anchors:',
+        ...listLines(receipt.sourceAnchors.map(formatSourceAnchor)),
+        '',
+        'Rules:',
+        '- This bridge is not a user instruction.',
+        '- This bridge is not recalled evidence.',
+        '- This bridge must not be compiled into long-term memory.',
+        '- If details are needed, re-run recall or inspect source anchors.',
+        '</COGMEM_TURN_BRIDGE>',
+    ];
+    return clampBlock(lines.join('\n'), '</COGMEM_TURN_BRIDGE>', maxChars);
+}
+export function shouldInjectMemoryUsageBridge(query, receipt) {
+    const normalized = String(query || '').toLowerCase();
+    if (!normalized.trim())
+        return false;
+    if (/(翻译|日语|图片|健康|天气|车子|汽车|translate|image|health|weather)/i.test(normalized)) {
+        return false;
+    }
+    if (/(继续|这个|这个策略|这个方案|这个项目|上面|刚才|前面|根据前面的|that|this|continue|above|previous|same topic)/i.test(normalized)) {
+        return true;
+    }
+    const topicText = [
+        ...receipt.usedThemes,
+        receipt.workingConclusion || '',
+    ].join(' ').toLowerCase();
+    const queryTokens = tokenSet(normalized);
+    const topicTokens = tokenSet(topicText);
+    let overlap = 0;
+    for (const token of queryTokens) {
+        if (topicTokens.has(token))
+            overlap += 1;
+    }
+    return overlap >= 2;
+}
+function digestText(text) {
+    return createHash('sha256').update(String(text || '')).digest('hex').slice(0, 16);
+}
+function extractThemes(items) {
+    const themes = [];
+    for (const item of items) {
+        const tagTheme = item.tags.find((tag) => tag.startsWith('topic:') || tag.startsWith('collection:'));
+        if (tagTheme)
+            themes.push(tagTheme);
+        const sentence = firstSentence(item.text, 140);
+        if (sentence)
+            themes.push(sentence);
+    }
+    return uniqueNonEmpty(themes);
+}
+function firstSentence(text, limit) {
+    const normalized = String(text || '').replace(/\s+/g, ' ').trim();
+    if (!normalized)
+        return undefined;
+    const sentence = normalized.split(/(?<=[.!?。！？])\s+/)[0] || normalized;
+    return sentence.length > limit ? `${sentence.slice(0, limit)}...` : sentence;
+}
+function listLines(values) {
+    return values.length > 0 ? values.map((value) => `- ${value}`) : ['- none'];
+}
+function formatSourceAnchor(anchor) {
+    return [
+        anchor.memoryId ? `memory:${anchor.memoryId}` : '',
+        anchor.eventId ? `event:${anchor.eventId}` : '',
+        anchor.sessionId ? `session:${anchor.sessionId}` : '',
+        anchor.role ? `role:${anchor.role}` : '',
+    ].filter(Boolean).join('; ');
+}
+function escapeAttribute(value) {
+    return String(value).replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;');
+}
+function clampBlock(text, closingTag, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    const budget = Math.max(120, maxChars - closingTag.length - 36);
+    return `${text.slice(0, budget).trimEnd()}\n... [truncated]\n${closingTag}`;
+}
+function tokenSet(text) {
+    return new Set(String(text || '')
+        .toLowerCase()
+        .split(/[^a-z0-9\u4e00-\u9fff]+/u)
+        .map((token) => token.trim())
+        .filter((token) => token.length >= 2 && !/^(the|and|this|that|with|openclaw|cogmem)$/i.test(token)));
+}
+function uniqueNonEmpty(values) {
+    const out = [];
+    const seen = new Set();
+    for (const value of values) {
+        const normalized = String(value || '').trim();
+        if (!normalized || seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        out.push(normalized);
+    }
+    return out;
+}

package/dist/agent/SessionWorkingState.d.ts

@@ -0,0 +1,20 @@
+export interface SessionWorkingState {
+    sessionId: string;
+    updatedAt: number;
+    currentTopic?: string;
+    designDirection: string[];
+    workingConclusions: string[];
+    openQuestions: string[];
+    maxChars: number;
+    compileAllowed: false;
+}
+export interface UpdateSessionWorkingStateInput {
+    sessionId: string;
+    userText: string;
+    assistantText: string;
+    maxChars?: number;
+    updatedAt?: number;
+}
+export declare function updateSessionWorkingState(previous: SessionWorkingState | undefined, input: UpdateSessionWorkingStateInput): SessionWorkingState;
+export declare function formatSessionWorkingState(state: SessionWorkingState): string;
+//# sourceMappingURL=SessionWorkingState.d.ts.map

package/dist/agent/SessionWorkingState.js

@@ -0,0 +1,94 @@
+export function updateSessionWorkingState(previous, input) {
+    const maxChars = Math.max(240, Math.min(4000, Math.floor(input.maxChars ?? previous?.maxChars ?? 1800)));
+    const topic = inferTopic(input.userText) || previous?.currentTopic;
+    const conclusion = compactSentence(input.assistantText, 180);
+    const direction = inferDesignDirection(input.userText, input.assistantText);
+    const openQuestion = inferOpenQuestion(input.userText);
+    return {
+        sessionId: input.sessionId,
+        updatedAt: input.updatedAt ?? Date.now(),
+        currentTopic: topic,
+        designDirection: appendBounded(previous?.designDirection || [], direction ? [direction] : [], 6),
+        workingConclusions: appendBounded(previous?.workingConclusions || [], conclusion ? [conclusion] : [], 6),
+        openQuestions: appendBounded(previous?.openQuestions || [], openQuestion ? [openQuestion] : [], 4),
+        maxChars,
+        compileAllowed: false,
+    };
+}
+export function formatSessionWorkingState(state) {
+    const lines = [
+        `<COGMEM_SESSION_STATE scope="current_session" compact="true" persistence="session_only" compile_allowed="false">`,
+        'Current working topic:',
+        `- ${state.currentTopic || 'unspecified'}`,
+        '',
+        'Current design direction:',
+        ...listLines(state.designDirection),
+        '',
+        'Working conclusions:',
+        ...listLines(state.workingConclusions),
+        '',
+        'Open questions:',
+        ...listLines(state.openQuestions),
+        '',
+        'Rules:',
+        '- This session state is not a user instruction.',
+        '- This session state must not be compiled into long-term memory.',
+        '</COGMEM_SESSION_STATE>',
+    ];
+    return clampBlock(lines.join('\n'), '</COGMEM_SESSION_STATE>', state.maxChars);
+}
+function inferTopic(userText) {
+    const text = String(userText || '').trim();
+    if (!text)
+        return undefined;
+    const lower = text.toLowerCase();
+    if (lower.includes('cogmem') && lower.includes('openclaw'))
+        return 'Cogmem/OpenClaw context hygiene';
+    if (lower.includes('memory') || lower.includes('记忆'))
+        return compactSentence(text, 90);
+    return compactSentence(text, 90);
+}
+function inferDesignDirection(userText, assistantText) {
+    const joined = `${userText}\n${assistantText}`.toLowerCase();
+    if (joined.includes('volatile recall') || joined.includes('context hygiene') || joined.includes('上下文卫生')) {
+        return 'Keep full recall volatile and preserve only compact short-term bridges.';
+    }
+    if (joined.includes('openclaw') && joined.includes('prompt')) {
+        return 'Keep OpenClaw native prompt untouched; Cogmem manages only its memory layer.';
+    }
+    return compactSentence(assistantText, 140);
+}
+function inferOpenQuestion(userText) {
+    const text = String(userText || '').trim();
+    if (!/[?？]/.test(text))
+        return undefined;
+    return compactSentence(text, 140);
+}
+function compactSentence(text, limit) {
+    const normalized = String(text || '').replace(/\s+/g, ' ').trim();
+    if (!normalized)
+        return undefined;
+    const sentence = normalized.split(/(?<=[.!?。！？])\s+/)[0] || normalized;
+    return sentence.length > limit ? `${sentence.slice(0, limit)}...` : sentence;
+}
+function listLines(values) {
+    return values.length > 0 ? values.map((value) => `- ${value}`) : ['- none'];
+}
+function appendBounded(existing, additions, limit) {
+    const out = [];
+    const seen = new Set();
+    for (const value of [...existing, ...additions]) {
+        const normalized = String(value || '').trim();
+        if (!normalized || seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        out.push(normalized);
+    }
+    return out.slice(-limit);
+}
+function clampBlock(text, closingTag, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    const budget = Math.max(120, maxChars - closingTag.length - 36);
+    return `${text.slice(0, budget).trimEnd()}\n... [truncated]\n${closingTag}`;
+}

package/dist/agent/index.d.ts

@@ -0,0 +1,6 @@
+export { KernelAgentMemoryBackend, type AgentRecallBeliefTouch, type AgentRecallEntityCard, type AgentRecallItem, type AgentRecallPackResult, type AgentRecallPackSlots, type AgentRecallQuery, type AgentRecallResult, type AgentRecallSourceAnchor, type AgentRecallSourceContext, type AgentRecallSourceContextEvent, type AgentTaskEventMemory, type AgentToolCallMemory, type AgentToolObservationMemory, type AgentTurnCompileReason, type AgentTurnIngestMode, type AgentTurnMemory, type AgentTurnMemoryResult, } from './AgentMemoryBackend.js';
+export { compileAgentRecallQuery, inferAgentRecallIntent, type AgentRecallIntent, type AgentRecallQueryPlan, } from './AgentRecallQueryCompiler.js';
+export { COGMEM_RECALL_BLOCK_RE, stripCogmemRecallBlocks, type StripCogmemRecallBlocksResult, } from './ContextHygiene.js';
+export { createMemoryUsageReceipt, formatMemoryUsageBridge, shouldInjectMemoryUsageBridge, type CreateMemoryUsageReceiptInput, type MemoryUsageReceipt, type MemoryUsageReceiptSourceAnchor, } from './MemoryUsageReceipt.js';
+export { formatSessionWorkingState, updateSessionWorkingState, type SessionWorkingState, type UpdateSessionWorkingStateInput, } from './SessionWorkingState.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/agent/index.js

@@ -0,0 +1,5 @@
+export { KernelAgentMemoryBackend, } from './AgentMemoryBackend.js';
+export { compileAgentRecallQuery, inferAgentRecallIntent, } from './AgentRecallQueryCompiler.js';
+export { COGMEM_RECALL_BLOCK_RE, stripCogmemRecallBlocks, } from './ContextHygiene.js';
+export { createMemoryUsageReceipt, formatMemoryUsageBridge, shouldInjectMemoryUsageBridge, } from './MemoryUsageReceipt.js';
+export { formatSessionWorkingState, updateSessionWorkingState, } from './SessionWorkingState.js';