cogmem 3.6.2

package/dist/binding/BindingClassifier.js

@@ -0,0 +1,270 @@
+import { ClaimKeyGenerator } from './ClaimKeyGenerator.js';
+import { TopicPathRegistry } from './TopicPathRegistry.js';
+const TOPIC_PATH_REGISTRY = new TopicPathRegistry();
+const CLAIM_KEY_GENERATOR = new ClaimKeyGenerator();
+const PROJECT_ALIASES = [
+    { canonical: 'Cogmem', aliases: ['cogmem', 'memory kernel', '记忆内核', 'agent brain'] },
+    { canonical: 'OpenClaw', aliases: ['openclaw', 'lobster'] },
+    { canonical: 'Hermes', aliases: ['hermes'] },
+];
+const GENERIC_PROJECT_RE = /([A-Z][A-Za-z0-9_-]{2,})(?:\s*(?:项目|工程|仓库|插件|应用|工具|project|repo|repository|app|plugin|tool))/;
+export class BindingClassifier {
+    classify(text) {
+        const normalized = normalizeForBinding(text);
+        if (!isHighValueText(normalized))
+            return [];
+        const projects = detectProjects(normalized);
+        const lowered = normalized.toLowerCase();
+        const decisions = [];
+        for (const project of projects) {
+            const projectLower = project.canonical.toLowerCase();
+            if (project.canonical === 'Cogmem' && hasMemoryWritePipelineCue(lowered)) {
+                decisions.push(projectDecision({
+                    project,
+                    suffix: 'memory-write-pipeline',
+                    summary: 'Cogmem write-time memory association, classification, and raw-event binding.',
+                    bindingType: bindingTypeFor(normalized, 'diagnostic'),
+                    signal: signalForClaim(normalized, 'memory_write_pipeline'),
+                    claimKey: claimKeyFor(normalized, 'memory-write-pipeline'),
+                    confidence: 0.88,
+                }));
+            }
+            if (project.canonical === 'Cogmem' && hasContextHygieneCue(normalized)) {
+                decisions.push(projectDecision({
+                    project,
+                    suffix: 'recall-context-hygiene',
+                    summary: 'Cogmem context hygiene boundaries for volatile recall, bridges, and session state.',
+                    bindingType: bindingTypeFor(normalized, 'boundary'),
+                    signal: signalForClaim(normalized, 'context_hygiene'),
+                    claimKey: claimKeyFor(normalized, 'context-hygiene'),
+                    confidence: 0.86,
+                }));
+            }
+            if (project.canonical === 'OpenClaw' || lowered.includes('openclaw')) {
+                decisions.push(projectDecision({
+                    project,
+                    suffix: 'integration',
+                    summary: `${project.canonical} integration boundaries and agent memory behavior.`,
+                    bindingType: bindingTypeFor(normalized, 'about'),
+                    signal: 'project_integration',
+                    claimKey: claimKeyFor(normalized, 'integration'),
+                    confidence: 0.8,
+                }));
+            }
+            const genericTopic = genericProjectTopic(normalized, project.canonical);
+            if (genericTopic) {
+                decisions.push(projectDecision({
+                    project,
+                    suffix: genericTopic.suffix,
+                    summary: genericTopic.summary,
+                    bindingType: bindingTypeFor(normalized, genericTopic.bindingType),
+                    signal: genericTopic.signal,
+                    claimKey: claimKeyFor(normalized, genericTopic.suffix),
+                    confidence: genericTopic.confidence,
+                }));
+            }
+            if (projectLower === 'cogmem' && hasOpenClawCue(lowered)) {
+                decisions.push(projectDecision({
+                    project: { canonical: 'OpenClaw', aliases: ['openclaw'] },
+                    suffix: 'integration',
+                    summary: 'OpenClaw integration boundaries and agent memory behavior.',
+                    bindingType: bindingTypeFor(normalized, 'about'),
+                    signal: 'project_integration',
+                    claimKey: claimKeyFor(normalized, 'integration'),
+                    confidence: 0.8,
+                }));
+            }
+        }
+        if (/local-first|本地优先|隐私|离线|privacy|offline/.test(lowered)) {
+            decisions.push({
+                topicPath: 'PERSON/user/durable-preferences',
+                topicType: 'person',
+                summary: 'Explicit durable user preferences, boundaries, and operating constraints.',
+                bindingType: bindingTypeFor(normalized, 'preference'),
+                signal: 'user_durable_preference',
+                claimKey: claimKeyFor(normalized, 'durable-preferences'),
+                confidence: 0.78,
+                entityName: 'user',
+                entityType: 'person',
+                aliases: ['用户'],
+            });
+        }
+        return uniqueTopicDecisions(decisions);
+    }
+    isBindableText(text) {
+        return this.classify(text).length > 0;
+    }
+}
+export function normalizeForBinding(text) {
+    return String(text || '')
+        .replace(/<COGMEM_RECALL_CONTEXT\b[\s\S]*?<\/COGMEM_RECALL_CONTEXT>/g, ' ')
+        .replace(/<COGMEM_TURN_BRIDGE\b[\s\S]*?<\/COGMEM_TURN_BRIDGE>/g, ' ')
+        .replace(/<COGMEM_SESSION_STATE\b[\s\S]*?<\/COGMEM_SESSION_STATE>/g, ' ')
+        .replace(/<COGMEM_STRATEGY_CONTEXT\b[\s\S]*?<\/COGMEM_STRATEGY_CONTEXT>/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function isHighValueText(text) {
+    const lowered = text.toLowerCase();
+    if (text.length < 8)
+        return false;
+    if (/^(ok|okay|yes|no|thanks|thank you|continue|go on)$/i.test(text))
+        return false;
+    if (/^(好的|好|嗯|继续|谢谢|可以|收到|明白|是的|不是)$/.test(text))
+        return false;
+    return [
+        'remember',
+        'prefer',
+        'must',
+        'never',
+        'boundary',
+        'decision',
+        'correct',
+        'wrong',
+        'problem',
+        'project',
+        'architecture',
+        'deploy',
+        'timeline',
+        'memory',
+        'pipeline',
+        'local-first',
+        '请记住',
+        '以后',
+        '不要',
+        '必须',
+        '边界',
+        '决定',
+        '纠正',
+        '不对',
+        '问题',
+        '架构',
+        '部署',
+        '时间线',
+        '写入',
+        '存储',
+        '分类',
+        '关联',
+        '项目',
+    ].some((needle) => lowered.includes(needle.toLowerCase()));
+}
+function detectProjects(text) {
+    const lowered = text.toLowerCase();
+    const detected = [];
+    for (const project of PROJECT_ALIASES) {
+        if (project.aliases.some((alias) => lowered.includes(alias.toLowerCase()))) {
+            detected.push(project);
+        }
+    }
+    if (!detected.some((project) => project.canonical === 'Cogmem')
+        && /memory-write|memory-storage|context hygiene|COGMEM_RECALL_CONTEXT|记忆写入/.test(text)) {
+        detected.push(PROJECT_ALIASES[0]);
+    }
+    const generic = text.match(GENERIC_PROJECT_RE)?.[1];
+    if (generic && !detected.some((project) => project.canonical.toLowerCase() === generic.toLowerCase())) {
+        detected.push({ canonical: generic, aliases: [generic] });
+    }
+    return detected;
+}
+function genericProjectTopic(text, projectName) {
+    const lowered = text.toLowerCase();
+    if (/架构|architecture|设计|design|插件|plugin/.test(lowered)) {
+        return {
+            suffix: 'architecture',
+            summary: `${projectName} architecture, design boundaries, and component organization.`,
+            signal: 'project_architecture',
+            bindingType: 'decision',
+            confidence: 0.76,
+        };
+    }
+    if (/部署|deploy|发布|release/.test(lowered)) {
+        return {
+            suffix: 'release-operations',
+            summary: `${projectName} deployment, release, and operational constraints.`,
+            signal: 'project_release_operations',
+            bindingType: 'decision',
+            confidence: 0.74,
+        };
+    }
+    if (/时间线|timeline|里程碑|milestone/.test(lowered)) {
+        return {
+            suffix: 'timeline',
+            summary: `${projectName} timeline, milestones, and temporal project state.`,
+            signal: 'project_timeline',
+            bindingType: 'about',
+            confidence: 0.72,
+        };
+    }
+    if (/问题|风险|bug|error|fail|不稳|漂移|污染/.test(lowered)) {
+        return {
+            suffix: 'known-risks',
+            summary: `${projectName} diagnostics, risks, and unresolved project issues.`,
+            signal: signalForClaim(text, 'project_diagnostic'),
+            bindingType: 'diagnostic',
+            confidence: 0.74,
+        };
+    }
+    return undefined;
+}
+function projectDecision(input) {
+    return {
+        topicPath: TOPIC_PATH_REGISTRY.resolveProjectPath(input.project.canonical, input.suffix),
+        topicType: 'project',
+        summary: input.summary,
+        bindingType: input.bindingType,
+        signal: input.signal,
+        claimKey: input.claimKey,
+        confidence: input.confidence,
+        entityName: input.project.canonical,
+        entityType: 'project',
+        aliases: input.project.aliases,
+    };
+}
+function hasMemoryWritePipelineCue(lowered) {
+    return /写入|存储|表格|大脑|历史|关联|分类|绑定|write|storage|pipeline|brain|table|classif|binding/.test(lowered);
+}
+function hasContextHygieneCue(text) {
+    return /COGMEM_RECALL_CONTEXT|COGMEM_TURN_BRIDGE|COGMEM_SESSION_STATE|COGMEM_STRATEGY_CONTEXT|context hygiene|recall block|上下文|污染|长期记忆|清洗|注入/.test(text);
+}
+function hasOpenClawCue(lowered) {
+    return lowered.includes('openclaw');
+}
+function bindingTypeFor(text, fallback) {
+    const lowered = text.toLowerCase();
+    if (/纠正|不对|错了|更正|correct|wrong/.test(lowered))
+        return 'correction';
+    if (/不要|不能|禁止|必须|边界|must not|never|forbid|boundary/.test(lowered))
+        return 'boundary';
+    if (/决定|方案|策略|decision|decide/.test(lowered))
+        return 'decision';
+    if (/请记住|以后|偏好|prefer|local-first|本地优先/.test(lowered))
+        return 'preference';
+    if (/目标|希望|goal|want/.test(lowered))
+        return 'goal';
+    if (/问题|风险|不像|表格|漂移|problem|risk|diagnos/.test(lowered))
+        return 'diagnostic';
+    return fallback;
+}
+function signalForClaim(text, fallback) {
+    const lowered = text.toLowerCase();
+    if (/分类树|分类.*漂移|topic.*drift|tree.*drift|memory-storage|memory-write/.test(lowered))
+        return 'classification_drift';
+    if (/历史|关联|binding|旧记忆|old memory|table|表格|孤立/.test(lowered))
+        return 'historical_binding';
+    if (/污染|上下文|recall_context|turn_bridge|session_state/.test(lowered))
+        return 'context_pollution_boundary';
+    return fallback;
+}
+function claimKeyFor(text, fallback) {
+    return CLAIM_KEY_GENERATOR.generate(text, signalForClaim(text, fallback));
+}
+function uniqueTopicDecisions(decisions) {
+    const seen = new Set();
+    return decisions.filter((decision) => {
+        const key = `${decision.topicPath}:${decision.bindingType}:${decision.claimKey}:${decision.entityName || ''}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}

package/dist/binding/BindingDecisionEngine.d.ts

@@ -0,0 +1,11 @@
+import type { MemoryBindingAction, MemoryBindingType } from './MemoryBindingTypes.js';
+export interface BindingDecisionInput {
+    bindingType: MemoryBindingType;
+    relatedCount: number;
+    supportCount: number;
+    relatedBindingTypes?: MemoryBindingType[];
+}
+export declare class BindingDecisionEngine {
+    decide(input: BindingDecisionInput): MemoryBindingAction;
+}
+//# sourceMappingURL=BindingDecisionEngine.d.ts.map

package/dist/binding/BindingDecisionEngine.js

@@ -0,0 +1,13 @@
+export class BindingDecisionEngine {
+    decide(input) {
+        if (input.bindingType === 'correction' && input.relatedCount > 0)
+            return 'corrects_prior_memory';
+        if (input.bindingType === 'correction')
+            return 'possible_conflict';
+        if (input.relatedCount === 0 || input.supportCount <= 1)
+            return 'create_new_cluster';
+        if ((input.relatedBindingTypes || []).includes(input.bindingType) || input.supportCount > 1)
+            return 'strengthen_existing';
+        return 'attach_to_existing';
+    }
+}

package/dist/binding/ClaimKeyGenerator.d.ts

@@ -0,0 +1,4 @@
+export declare class ClaimKeyGenerator {
+    generate(text: string, fallback: string): string;
+}
+//# sourceMappingURL=ClaimKeyGenerator.d.ts.map

package/dist/binding/ClaimKeyGenerator.js

@@ -0,0 +1,21 @@
+const CLAIM_PATTERNS = [
+    { key: 'missing-historical-binding', pattern: /不看历史|没有历史关联|旧记忆|historical bind|old memor|孤立|表格/i },
+    { key: 'classification-drift', pattern: /分类树.*漂移|分类.*漂移|topic.*drift|classification.*drift/i },
+    { key: 'context-pollution-boundary', pattern: /上下文.*污染|context.*pollution|recall_context|turn_bridge|session_state/i },
+    { key: 'source-fidelity', pattern: /原文|source.*fidel|sourcecontext|source locator/i },
+];
+export class ClaimKeyGenerator {
+    generate(text, fallback) {
+        const matched = CLAIM_PATTERNS.find((entry) => entry.pattern.test(String(text || '')));
+        if (matched)
+            return matched.key;
+        return slug(fallback) || 'general';
+    }
+}
+function slug(value) {
+    return String(value || '')
+        .normalize('NFKC')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}

package/dist/binding/MemoryBindingService.d.ts

@@ -0,0 +1,28 @@
+import type { MemoryEvent } from '../types/index.js';
+import type { MemoryBindingRecord, MemoryGraphRecallAnchor } from './MemoryBindingTypes.js';
+import { MemoryBindingStore } from '../store/MemoryBindingStore.js';
+import { EntityStore } from '../store/EntityStore.js';
+export interface MemoryBindingEventInput {
+    eventId: string;
+    projectId?: string;
+    role?: string;
+    rawEventType?: string;
+    text: string;
+    occurredAt?: number;
+}
+export declare class MemoryBindingService {
+    private readonly store;
+    private readonly entityStore?;
+    private readonly classifier;
+    private readonly decisionEngine;
+    constructor(store: MemoryBindingStore, entityStore?: EntityStore | undefined);
+    bindRawEvent(event: MemoryEvent): MemoryBindingRecord[];
+    bindEvent(input: MemoryBindingEventInput): MemoryBindingRecord[];
+    isBindableRawEvent(event: MemoryEvent): boolean;
+    recallGraphAnchors(query: string, options?: {
+        projectId?: string;
+        limit?: number;
+    }): MemoryGraphRecallAnchor[];
+    private rawEventText;
+}
+//# sourceMappingURL=MemoryBindingService.d.ts.map

package/dist/binding/MemoryBindingService.js

@@ -0,0 +1,283 @@
+import { BindingClassifier, normalizeForBinding } from './BindingClassifier.js';
+import { BindingDecisionEngine } from './BindingDecisionEngine.js';
+export class MemoryBindingService {
+    store;
+    entityStore;
+    classifier = new BindingClassifier();
+    decisionEngine = new BindingDecisionEngine();
+    constructor(store, entityStore) {
+        this.store = store;
+        this.entityStore = entityStore;
+    }
+    bindRawEvent(event) {
+        const payload = event.payload;
+        const text = typeof payload.text === 'string'
+            ? payload.text
+            : typeof payload.output === 'string'
+                ? payload.output
+                : typeof payload.title === 'string'
+                    ? payload.title
+                    : JSON.stringify(event.payload);
+        return this.bindEvent({
+            eventId: event.eventId,
+            projectId: event.projectId,
+            role: event.role,
+            rawEventType: event.rawEventType,
+            text,
+            occurredAt: event.occurredAt,
+        });
+    }
+    bindEvent(input) {
+        if (input.role !== 'user')
+            return [];
+        if (input.rawEventType && input.rawEventType !== 'message')
+            return [];
+        const text = normalizeForBinding(input.text);
+        const decisions = this.classifier.classify(text);
+        if (decisions.length === 0)
+            return [];
+        const createdAt = input.occurredAt ?? Date.now();
+        const bindings = [];
+        for (const decision of decisions) {
+            const canonicalEntity = decision.entityName && this.entityStore
+                ? this.entityStore.upsertEntity({
+                    canonicalName: decision.entityName,
+                    type: decision.entityType || 'concept',
+                    aliases: decision.aliases,
+                    createdFrom: input.eventId,
+                    metadata: { projectId: input.projectId, evidenceEventId: input.eventId },
+                    createdAt,
+                })
+                : undefined;
+            const entity = decision.entityName
+                ? this.store.upsertEntity({
+                    entityId: canonicalEntity?.entityId,
+                    projectId: input.projectId,
+                    canonicalName: decision.entityName,
+                    entityType: decision.entityType || 'concept',
+                    aliases: decision.aliases,
+                    stablePath: entityStablePath(decision.entityType || 'concept', decision.entityName),
+                    now: createdAt,
+                })
+                : undefined;
+            this.store.upsertTopic({
+                projectId: input.projectId,
+                topicPath: decision.topicPath,
+                topicType: decision.topicType,
+                summary: decision.summary,
+                now: createdAt,
+            });
+            const related = this.store.listBindings({
+                projectId: input.projectId,
+                topicPath: decision.topicPath,
+                role: 'user',
+                limit: 8,
+            }).filter((binding) => binding.eventId !== input.eventId);
+            const clusterStatus = decision.bindingType === 'correction' ? 'possible_conflict' : 'active';
+            const cluster = this.store.upsertCluster({
+                projectId: input.projectId,
+                topicPath: decision.topicPath,
+                clusterType: decision.bindingType,
+                title: clusterTitle(decision.topicPath, decision.bindingType),
+                summary: decision.summary,
+                claimKey: decision.claimKey,
+                status: 'active',
+                reviewFlags: clusterStatus === 'possible_conflict' ? ['possible_conflict'] : [],
+                confidence: decision.confidence,
+                eventId: input.eventId,
+                now: createdAt,
+            });
+            const bindingAction = this.decisionEngine.decide({
+                bindingType: decision.bindingType,
+                relatedCount: related.length,
+                supportCount: cluster.supportCount,
+                relatedBindingTypes: related.map((binding) => binding.bindingType),
+            });
+            const binding = {
+                eventId: input.eventId,
+                projectId: input.projectId,
+                role: input.role,
+                rawEventType: input.rawEventType,
+                entityId: entity?.entityId,
+                entityName: entity?.canonicalName,
+                entityType: entity?.entityType,
+                topicPath: decision.topicPath,
+                bindingType: decision.bindingType,
+                confidence: decision.confidence,
+                source: 'deterministic',
+                signal: decision.signal,
+                claimKey: decision.claimKey,
+                bindingAction,
+                clusterId: cluster.clusterId,
+                relatedEventIds: related.map((item) => item.eventId),
+                createdAt,
+            };
+            const inserted = this.store.insertBinding(binding);
+            this.store.upsertEdge({
+                projectId: input.projectId,
+                sourceType: 'event',
+                sourceId: input.eventId,
+                relationType: 'ABOUT',
+                targetType: 'topic',
+                targetId: decision.topicPath,
+                confidence: decision.confidence,
+                evidenceEventIds: [input.eventId],
+                createdAt,
+            });
+            this.store.upsertEdge({
+                projectId: input.projectId,
+                sourceType: 'event',
+                sourceId: input.eventId,
+                relationType: 'SUPPORTS',
+                targetType: 'cluster',
+                targetId: cluster.clusterId,
+                confidence: decision.confidence,
+                evidenceEventIds: [input.eventId],
+                createdAt,
+            });
+            this.store.upsertEdge({
+                projectId: input.projectId,
+                sourceType: 'cluster',
+                sourceId: cluster.clusterId,
+                relationType: 'BELONGS_TO',
+                targetType: 'topic',
+                targetId: decision.topicPath,
+                confidence: decision.confidence,
+                evidenceEventIds: cluster.evidenceEventIds,
+                createdAt,
+            });
+            if (entity) {
+                this.store.upsertEdge({
+                    projectId: input.projectId,
+                    sourceType: 'event',
+                    sourceId: input.eventId,
+                    relationType: 'MENTIONS',
+                    targetType: 'entity',
+                    targetId: entity.entityId,
+                    confidence: decision.confidence,
+                    evidenceEventIds: [input.eventId],
+                    createdAt,
+                });
+            }
+            for (const relatedBinding of related.slice(0, 5)) {
+                this.store.upsertEdge({
+                    projectId: input.projectId,
+                    sourceType: 'event',
+                    sourceId: input.eventId,
+                    relationType: 'SAME_TOPIC_AS',
+                    targetType: 'event',
+                    targetId: relatedBinding.eventId,
+                    confidence: Math.min(decision.confidence, relatedBinding.confidence),
+                    evidenceEventIds: [input.eventId, relatedBinding.eventId],
+                    createdAt,
+                });
+            }
+            if (decision.bindingType === 'correction') {
+                for (const relatedBinding of related.slice(0, 3)) {
+                    this.store.upsertEdge({
+                        projectId: input.projectId,
+                        sourceType: 'event',
+                        sourceId: input.eventId,
+                        relationType: 'CORRECTS',
+                        targetType: 'event',
+                        targetId: relatedBinding.eventId,
+                        confidence: Math.min(decision.confidence, relatedBinding.confidence),
+                        evidenceEventIds: [input.eventId, relatedBinding.eventId],
+                        createdAt,
+                    });
+                    if (/不对|错了|wrong|contradict|不是/.test(text.toLowerCase())) {
+                        this.store.upsertEdge({
+                            projectId: input.projectId,
+                            sourceType: 'event',
+                            sourceId: input.eventId,
+                            relationType: 'CONTRADICTS',
+                            targetType: 'event',
+                            targetId: relatedBinding.eventId,
+                            confidence: Math.min(decision.confidence, relatedBinding.confidence),
+                            evidenceEventIds: [input.eventId, relatedBinding.eventId],
+                            createdAt,
+                        });
+                    }
+                }
+            }
+            bindings.push(inserted);
+        }
+        return bindings;
+    }
+    isBindableRawEvent(event) {
+        if (event.role !== 'user')
+            return false;
+        if (event.rawEventType && event.rawEventType !== 'message')
+            return false;
+        return this.classifier.isBindableText(this.rawEventText(event));
+    }
+    recallGraphAnchors(query, options = {}) {
+        const text = normalizeForBinding(query);
+        if (!text)
+            return [];
+        const decisions = this.classifier.classify(text);
+        if (decisions.length === 0)
+            return [];
+        const limit = Math.max(1, Math.min(options.limit ?? 8, 50));
+        const anchors = [];
+        const seen = new Set();
+        for (const decision of decisions) {
+            const bindings = this.store.listBindings({
+                projectId: options.projectId,
+                topicPath: decision.topicPath,
+                role: 'user',
+                limit: Math.max(limit * 4, 20),
+            }).sort((a, b) => bindingRank(b, decision) - bindingRank(a, decision));
+            for (const binding of bindings) {
+                if (seen.has(binding.eventId))
+                    continue;
+                seen.add(binding.eventId);
+                anchors.push({
+                    eventId: binding.eventId,
+                    projectId: binding.projectId,
+                    topicPath: binding.topicPath,
+                    clusterId: binding.clusterId,
+                    confidence: bindingRank(binding, decision),
+                    whyMatched: 'memory_binding_graph',
+                });
+                if (anchors.length >= limit)
+                    return anchors;
+            }
+        }
+        return anchors;
+    }
+    rawEventText(event) {
+        const payload = event.payload;
+        if (typeof payload.text === 'string')
+            return payload.text;
+        if (typeof payload.output === 'string')
+            return payload.output;
+        if (typeof payload.title === 'string')
+            return payload.title;
+        return JSON.stringify(event.payload);
+    }
+}
+function bindingRank(binding, decision) {
+    let score = binding.confidence;
+    if (binding.claimKey === decision.claimKey)
+        score += 1;
+    if (binding.signal === decision.signal)
+        score += 0.75;
+    if (binding.bindingType === decision.bindingType)
+        score += 0.5;
+    if (binding.role === 'user')
+        score += 0.25;
+    score += Math.min(0.25, Math.max(0, binding.createdAt) / 1_000_000_000_000_000);
+    return score;
+}
+function clusterTitle(topicPath, bindingType) {
+    const tail = topicPath.split('/').slice(-1)[0] || topicPath;
+    return `${tail}:${bindingType}`;
+}
+function entityStablePath(entityType, canonicalName) {
+    if (entityType === 'project')
+        return `PROJECT/${canonicalName}`;
+    if (entityType === 'person')
+        return `PERSON/${canonicalName}`;
+    return `${entityType.toUpperCase()}/${canonicalName}`;
+}