cogmem 3.6.2

package/dist/lexicon/coreMemoryLexicon.js

@@ -0,0 +1,525 @@
+import { EN_ENTITY_TYPE_TERMS, EN_ISSUE_KEYWORDS, EN_ISSUE_QUALIFIERS, EN_LONG_TERM_SIGNAL_TERMS, EN_PENDING_PATTERNS, EN_REFERENCE_SIGNALS, EN_RELATION_PHRASES, EN_SHORT_REPLY_BINDING } from './language-packs/en.js';
+import { ZH_ENTITY_TYPE_TERMS, ZH_ISSUE_KEYWORDS, ZH_ISSUE_QUALIFIERS, ZH_LONG_TERM_SIGNAL_TERMS, ZH_PENDING_PATTERNS, ZH_REFERENCE_SIGNALS, ZH_RELATION_PHRASES, ZH_SHORT_REPLY_BINDING } from './language-packs/zh.js';
+export const ENTITY_TYPE_LEXICON = {
+    device: [...ZH_ENTITY_TYPE_TERMS.device, ...EN_ENTITY_TYPE_TERMS.device],
+    project: [...ZH_ENTITY_TYPE_TERMS.project, ...EN_ENTITY_TYPE_TERMS.project],
+    person: [...ZH_ENTITY_TYPE_TERMS.person, ...EN_ENTITY_TYPE_TERMS.person],
+    brand: [...ZH_ENTITY_TYPE_TERMS.brand, ...EN_ENTITY_TYPE_TERMS.brand],
+    issue: [...ZH_ENTITY_TYPE_TERMS.issue, ...EN_ENTITY_TYPE_TERMS.issue]
+};
+export const RELATION_PHRASE_MAP = {
+    owns: [...ZH_RELATION_PHRASES.owns, ...EN_RELATION_PHRASES.owns],
+    purchased: [...ZH_RELATION_PHRASES.purchased, ...EN_RELATION_PHRASES.purchased],
+    has_issue: [...ZH_RELATION_PHRASES.has_issue, ...EN_RELATION_PHRASES.has_issue],
+    worked_on: [...ZH_RELATION_PHRASES.worked_on, ...EN_RELATION_PHRASES.worked_on],
+    likes: [...ZH_RELATION_PHRASES.likes, ...EN_RELATION_PHRASES.likes],
+    dislikes: [...ZH_RELATION_PHRASES.dislikes, ...EN_RELATION_PHRASES.dislikes],
+    approved: ['user approved'],
+    rejected: ['user rejected']
+};
+export const REFERENCE_SIGNAL_LEXICON = {
+    new_instance_signal: [...ZH_REFERENCE_SIGNALS.newInstance, ...EN_REFERENCE_SIGNALS.newInstance],
+    update_instance_signal: [...ZH_REFERENCE_SIGNALS.updateInstance, ...EN_REFERENCE_SIGNALS.updateInstance],
+    ambiguous_reference_signal: [...ZH_REFERENCE_SIGNALS.ambiguous, ...EN_REFERENCE_SIGNALS.ambiguous]
+};
+export const REFERENCE_SYNONYMS = {
+    latest: [...ZH_REFERENCE_SIGNALS.latest, ...EN_REFERENCE_SIGNALS.latest],
+    previous: [...ZH_REFERENCE_SIGNALS.previous, ...EN_REFERENCE_SIGNALS.previous]
+};
+export const ENTITY_INSTANCE_SIGNAL_LEXICON = {
+    strongNew: REFERENCE_SIGNAL_LEXICON.new_instance_signal,
+    strongUpdate: REFERENCE_SIGNAL_LEXICON.update_instance_signal
+};
+export const INTERACTION_EVENT_PREFIX = {
+    approved: 'user approved',
+    rejected: 'user rejected',
+    entitySelection: 'user selected'
+};
+export const SHORT_REPLY_BINDING_LEXICON = {
+    approved: [...ZH_SHORT_REPLY_BINDING.approved, ...EN_SHORT_REPLY_BINDING.approved],
+    rejected: [...ZH_SHORT_REPLY_BINDING.rejected, ...EN_SHORT_REPLY_BINDING.rejected],
+    entitySelection: [
+        ...REFERENCE_SYNONYMS.latest,
+        ...REFERENCE_SYNONYMS.previous,
+        ...ZH_SHORT_REPLY_BINDING.entitySelection,
+        ...EN_SHORT_REPLY_BINDING.entitySelection
+    ]
+};
+export const PENDING_BINDING_PROMPT_PATTERNS = {
+    action: [
+        ...ZH_PENDING_PATTERNS.action,
+        ...EN_PENDING_PATTERNS.action
+    ],
+    entity: [
+        ...ZH_PENDING_PATTERNS.entity,
+        ...EN_PENDING_PATTERNS.entity
+    ]
+};
+export const LONG_TERM_MEMORY_SIGNAL_TERMS = [
+    ...ZH_LONG_TERM_SIGNAL_TERMS,
+    ...EN_LONG_TERM_SIGNAL_TERMS
+];
+export const ISSUE_FAMILY_LEXICON = {
+    connectivity_issue: {
+        keywords: [...ZH_ISSUE_KEYWORDS.connectivity, ...EN_ISSUE_KEYWORDS.connectivity]
+    },
+    sound_issue: {
+        keywords: [...ZH_ISSUE_KEYWORDS.sound, ...EN_ISSUE_KEYWORDS.sound]
+    },
+    performance_issue: {
+        keywords: [...ZH_ISSUE_KEYWORDS.performance, ...EN_ISSUE_KEYWORDS.performance]
+    },
+    generic_issue: {
+        keywords: ['有问题', '什么问题', 'issue', '故障', '异常', '坏了']
+    }
+};
+export const ISSUE_QUALIFIER_LEXICON = {
+    left: [...ZH_ISSUE_QUALIFIERS.left, ...EN_ISSUE_QUALIFIERS.left],
+    right: [...ZH_ISSUE_QUALIFIERS.right, ...EN_ISSUE_QUALIFIERS.right]
+};
+const DEVICE_SURFACE_PATTERN = /([A-Za-z0-9._+-]+(?:\s+[A-Za-z0-9._+-]+){0,4}\s+(?:headset|monitor|keyboard|mouse|earbuds?|earphones?)|bluetooth\s+(?:earbuds?|earphones?)|[A-Za-z0-9._+-]+(?:耳机|键盘|鼠标|显示器)|[\u4e00-\u9fa5A-Za-z0-9._+-]+(?:耳机|键盘|鼠标|显示器)|耳机|键盘|鼠标|显示器|headset|monitor|keyboard|mouse|earbuds?|earphones?)/gi;
+const PROJECT_SURFACE_PATTERN = /([A-Za-z0-9._-]+(?:\s+[A-Za-z0-9._-]+){0,5}\s+(?:project|sdk|library|platform|api|repository|repo)|[\u4e00-\u9fa5A-Za-z0-9._-]+项目)/gi;
+function collapseSurfaceWhitespace(value) {
+    return value.trim().replace(/\s+/g, ' ');
+}
+function stripRepeatedPrefixes(value, patterns) {
+    let current = collapseSurfaceWhitespace(value);
+    for (let index = 0; index < 6; index += 1) {
+        let changed = false;
+        for (const pattern of patterns) {
+            const next = current.replace(pattern, '').trim();
+            if (next !== current) {
+                current = collapseSurfaceWhitespace(next);
+                changed = true;
+            }
+        }
+        if (!changed)
+            break;
+    }
+    return current;
+}
+function escapeLexiconRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function cleanDeviceSurfaceCandidate(candidate, fullText) {
+    const raw = collapseSurfaceWhitespace(candidate);
+    const stripped = stripRepeatedPrefixes(candidate, [
+        /^(?:my|our|the|an?|another)\s+/i,
+        /^(?:一个|一副|一台|一部|个|副|台|部)\s*/i,
+        /^(?:i\s+own(?:\s+(?:a|an))?|i\s+bought(?:\s+(?:a|an|another))?(?:\s+new)?|i\s+have(?:\s+(?:a|an))?|i\s+had(?:\s+(?:a|an))?|i\s+got(?:\s+(?:a|an))?(?:\s+new)?|i\s+used)\s+/i,
+        /^(?:我(?:又)?买了(?:一个|一副)?|我有一个|我有个|我的|用了)\s*/i,
+        /^(?:the\s+previous|previous|the\s+new|new|the\s+old|old|this|that)\s+/i,
+        /^(?:前一个|之前那个|上一个|新的那个|新买的|旧的那个|旧的|旧|这个|那个)\s*/i
+    ]);
+    if (!stripped)
+        return undefined;
+    if (/\bproject\b|项目/i.test(stripped))
+        return undefined;
+    if (/^(?:耳机|键盘|鼠标|显示器|bluetooth\s+(?:earbuds?|earphones?)|earbuds?|earphones?|keyboard|mouse|monitor|device|headset)$/i.test(stripped)) {
+        if (fullText) {
+            const hasOwnershipLead = /(?:i\s+own|i\s+bought|i\s+have|i\s+had|i\s+got|my\b|我(?:又)?买了|我有一个|我有个|我的)/i.test(fullText);
+            if (hasOwnershipLead)
+                return stripped;
+            const escaped = escapeLexiconRegex(stripped);
+            if (new RegExp(`(?:the\\s+previous|previous|the\\s+new|new|the\\s+old|old|this|that)\\s+${escaped}\\b`, 'i').test(fullText)
+                || new RegExp(`(?:前一个|之前那个|上一个|新的那个|新买的|旧的那个|旧的|旧|这个|那个)\\s*${escaped}`, 'i').test(fullText)) {
+                return undefined;
+            }
+        }
+        const hadRelativeLead = /^(?:the previous|previous|the new|new|the old|old|this|that|前一个|之前那个|上一个|新的那个|新买的|旧的那个|旧的|旧|这个|那个)\b/i.test(raw);
+        return hadRelativeLead ? undefined : stripped;
+    }
+    return stripped;
+}
+function cleanProjectSurfaceCandidate(candidate) {
+    const stripped = stripRepeatedPrefixes(candidate, [
+        /^(?:are\s+building(?:\s+(?:a|an|the))?)\s+/i,
+        /^(?:the|an?|this|that)\s+/i,
+        /^(?:for|in|during|on)\s+/i,
+        /^(?:we\s+are\s+building|we're\s+building|worked on|working on|doing|building|developing|maintaining|shipping)\s+/i,
+        /^(?:而且)?(?:还)?(?:做过|参与过|负责过|在做|在开发|开发|维护|跟进)\s*/i,
+        /^(?:the\s+previous|previous|the\s+new|new|old)\s+/i,
+        /^(?:前一个|上一个|新的|旧的|这个|那个)\s*/i
+    ]);
+    if (!stripped)
+        return undefined;
+    if (/^(?:项目|project|sdk|library|platform|api|repository|repo)$/i.test(stripped))
+        return undefined;
+    return stripped;
+}
+export function normalizeLexiconText(text) {
+    return text
+        .trim()
+        .replace(/蓝芽/g, '蓝牙')
+        .replace(/藍牙/g, '蓝牙')
+        .replace(/耳機/g, '耳机')
+        .replace(/断联/g, '断连')
+        .replace(/斷連/g, '断连')
+        .replace(/雜音/g, '杂音')
+        .replace(/\bleft\s+disconnect\b/gi, 'left ear disconnect')
+        .replace(/\bright\s+disconnect\b/gi, 'right ear disconnect')
+        .replace(/\bleft ear\b/gi, '左耳')
+        .replace(/\bright ear\b/gi, '右耳')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+export function includesLexiconTerm(text, terms) {
+    return terms.some((term) => text.toLowerCase().includes(term.toLowerCase()));
+}
+function normalizeShortReplyText(text) {
+    return normalizeLexiconText(text)
+        .toLowerCase()
+        .replace(/[，,]/g, ' ')
+        .replace(/[。.!！？?]/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+export function inferEntityTypeFromText(text) {
+    const lowered = text.toLowerCase();
+    const orderedTypes = ['device', 'project', 'brand', 'issue', 'person'];
+    return orderedTypes.find((type) => includesLexiconTerm(lowered, ENTITY_TYPE_LEXICON[type]));
+}
+export function extractRelativeReferences(text) {
+    const lexiconRefs = [
+        ...REFERENCE_SYNONYMS.latest,
+        ...REFERENCE_SYNONYMS.previous,
+        ...REFERENCE_SIGNAL_LEXICON.ambiguous_reference_signal
+    ].filter((ref) => text.toLowerCase().includes(ref.toLowerCase()));
+    const patternRefs = Array.from(normalizeLexiconText(text).matchAll(/((?:之前那个|前一个|上一个|新的那个|新的项目|新买的|新项目|旧的那个|旧的|那个|这个|它)(?:[\u4e00-\u9fa5A-Za-z0-9._ -]{0,6}(?:耳机|键盘|鼠标|显示器|项目|device|project)|(?:耳机|键盘|鼠标|显示器|项目|device|project))?)/gi)).map((match) => match[1].trim());
+    const englishPatternRefs = Array.from(normalizeLexiconText(text).matchAll(/((?:the new one|new one|this one|the current one|the previous one|previous one|the old one|old one|that one|this project|that project|the new project|new project|the previous project|previous project|old project|the previous headset|previous headset|the new headset|new headset|the previous monitor|previous monitor|the new monitor|new monitor|the previous keyboard|previous keyboard|the new keyboard|new keyboard|the previous mouse|previous mouse|the new mouse|new mouse)(?:\s+(?:bluetooth|wireless|current|new|old))?(?:\s+(?:headset|monitor|keyboard|mouse|device|project|earbuds))?)/gi)).map((match) => match[1].trim());
+    return Array.from(new Set([...lexiconRefs, ...patternRefs, ...englishPatternRefs]));
+}
+export function classifyIssueFamilies(text) {
+    const lowered = text.toLowerCase();
+    const families = Object.entries(ISSUE_FAMILY_LEXICON)
+        .filter(([, descriptor]) => includesLexiconTerm(lowered, descriptor.keywords))
+        .map(([family]) => family);
+    return families.length > 0 ? families : [];
+}
+export function detectIssueQualifier(text) {
+    const lowered = text.toLowerCase();
+    if (includesLexiconTerm(lowered, ISSUE_QUALIFIER_LEXICON.left))
+        return 'left';
+    if (includesLexiconTerm(lowered, ISSUE_QUALIFIER_LEXICON.right))
+        return 'right';
+    return 'generic';
+}
+export function inferIssueValue(text) {
+    const families = classifyIssueFamilies(text);
+    if (families.includes('connectivity_issue'))
+        return '断连';
+    if (families.includes('sound_issue'))
+        return '杂音';
+    if (families.includes('performance_issue'))
+        return '卡顿';
+    return '问题';
+}
+export function hasIssueSignal(text) {
+    return classifyIssueFamilies(text).length > 0;
+}
+export function isStrongNewInstanceSignal(text) {
+    return includesLexiconTerm(normalizeLexiconText(text), ENTITY_INSTANCE_SIGNAL_LEXICON.strongNew);
+}
+export function isStrongUpdateInstanceSignal(text) {
+    return includesLexiconTerm(normalizeLexiconText(text), ENTITY_INSTANCE_SIGNAL_LEXICON.strongUpdate);
+}
+export function matchBindingReplyIntent(text) {
+    const raw = normalizeLexiconText(text);
+    if (/[？?]/.test(raw) || raw.length > 24) {
+        return null;
+    }
+    const normalized = normalizeShortReplyText(text);
+    const selectedReference = SHORT_REPLY_BINDING_LEXICON.entitySelection.find((term) => normalized.includes(term.toLowerCase()));
+    if (selectedReference) {
+        return { kind: 'entity_selection', reference: selectedReference };
+    }
+    const rejected = SHORT_REPLY_BINDING_LEXICON.rejected.find((term) => normalized.includes(term.toLowerCase()));
+    if (rejected) {
+        return { kind: 'rejected' };
+    }
+    const approved = SHORT_REPLY_BINDING_LEXICON.approved.find((term) => normalized === term.toLowerCase());
+    if (approved) {
+        return { kind: 'approved' };
+    }
+    return null;
+}
+export function isBindFirstShortReply(text) {
+    return matchBindingReplyIntent(text) !== null;
+}
+export function detectPendingBindingPromptType(text) {
+    const normalized = normalizeLexiconText(text);
+    if (PENDING_BINDING_PROMPT_PATTERNS.action.some((pattern) => pattern.test(normalized)))
+        return 'action';
+    const hasRelativeReferences = extractRelativeReferences(normalized).length > 0;
+    const hasEntityPromptPattern = PENDING_BINDING_PROMPT_PATTERNS.entity.some((pattern) => pattern.test(normalized));
+    if (hasEntityPromptPattern && hasRelativeReferences)
+        return 'entity';
+    if (/\?$|？$/.test(normalized))
+        return 'question';
+    return null;
+}
+export function hasLongTermMemorySignal(text) {
+    const normalized = normalizeLexiconText(text);
+    return Boolean(inferEntityTypeFromText(normalized)
+        || hasIssueSignal(normalized)
+        || isOwnershipSignal(normalized)
+        || isPurchaseSignal(normalized)
+        || isWorkedOnSignal(normalized)
+        || extractPreference(normalized)
+        || includesLexiconTerm(normalized, LONG_TERM_MEMORY_SIGNAL_TERMS));
+}
+export function extractIssueHints(text) {
+    const normalized = normalizeLexiconText(text);
+    const segments = normalized
+        .split(/[，。,.!?！？]/)
+        .map((segment) => segment.trim())
+        .filter(Boolean);
+    const hints = segments.filter((segment) => hasIssueSignal(segment));
+    return hints.length > 0 ? hints : (hasIssueSignal(normalized) ? [normalized] : []);
+}
+export function extractLatestIssueReference(text) {
+    const normalized = normalizeLexiconText(text);
+    const segments = normalized
+        .split(/[，。,.!?！？]/)
+        .map((segment) => segment.trim())
+        .filter(Boolean)
+        .filter((segment) => hasIssueSignal(segment));
+    const target = segments[segments.length - 1];
+    if (!target)
+        return null;
+    const qualifier = detectIssueQualifier(target);
+    const explicitDevice = extractDeviceCandidate(target);
+    const explicitProject = extractProjectCandidate(target);
+    const reference = qualifier === 'left'
+        ? '左耳'
+        : qualifier === 'right'
+            ? '右耳'
+            : explicitDevice
+                || explicitProject
+                || extractRelativeReferences(target)[0]
+                || 'device';
+    return {
+        reference,
+        issue: inferIssueValue(target)
+    };
+}
+export function extractIssueRankingTokensFromText(text) {
+    const normalized = normalizeLexiconText(text);
+    const tokens = [];
+    const qualifier = detectIssueQualifier(normalized);
+    if (qualifier === 'left')
+        tokens.push('left-ear');
+    if (qualifier === 'right')
+        tokens.push('right-ear');
+    for (const family of classifyIssueFamilies(normalized)) {
+        if (family === 'connectivity_issue')
+            tokens.push('disconnect');
+        if (family === 'sound_issue')
+            tokens.push('noise');
+        if (family === 'performance_issue')
+            tokens.push('performance');
+    }
+    return Array.from(new Set(tokens));
+}
+export function extractDeviceCandidate(text) {
+    const normalized = normalizeLexiconText(text);
+    const targetedPatterns = [
+        /(?:i\s+own|i\s+have|i\s+got|i\s+bought(?:\s+(?:a|an|another))?(?:\s+new)?|my)\s+(?:an?\s+|the\s+)?([A-Za-z0-9._+-]+(?:\s+[A-Za-z0-9._+-]+){0,4}\s+(?:earphones?|earbuds?|headset|monitor|keyboard|mouse|device))\b/i,
+        /(?:我(?:有|买了)|我的)\s*([\u4e00-\u9fa5A-Za-z0-9._+-]+(?:耳机|键盘|鼠标|显示器))/i,
+        /\b([A-Za-z0-9._+-]+(?:\s+[A-Za-z0-9._+-]+){0,3}\s+(?:earphones?|earbuds?|headset|monitor|keyboard|mouse))\b/i
+    ];
+    for (const pattern of targetedPatterns) {
+        const matched = normalized.match(pattern)?.[1];
+        const candidate = matched ? cleanDeviceSurfaceCandidate(matched, normalized) : undefined;
+        if (candidate)
+            return candidate;
+    }
+    const matches = Array.from(normalized.matchAll(DEVICE_SURFACE_PATTERN));
+    for (const match of matches) {
+        const candidate = cleanDeviceSurfaceCandidate(match[1] || '', normalized);
+        if (candidate)
+            return candidate;
+    }
+    return undefined;
+}
+export function extractDeviceAliasCandidates(text) {
+    const normalized = normalizeLexiconText(text);
+    const candidate = extractDeviceCandidate(normalized);
+    if (!candidate)
+        return [];
+    const aliases = new Set();
+    const loweredCandidate = candidate.toLowerCase();
+    const nounMatch = loweredCandidate.match(/\b(earphones?|earbuds?|headset|monitor|keyboard|mouse|device)\b/);
+    if (nounMatch?.[1])
+        aliases.add(nounMatch[1].replace(/s$/i, ''));
+    if (/\bbluetooth\b/i.test(candidate))
+        aliases.add('bluetooth');
+    if (/\bwireless\b/i.test(candidate))
+        aliases.add('wireless');
+    return Array.from(aliases);
+}
+export function isOwnershipSignal(text) {
+    return includesLexiconTerm(text, RELATION_PHRASE_MAP.owns);
+}
+export function extractOwnershipSignals(text) {
+    const normalized = normalizeLexiconText(text);
+    const matches = normalized.match(/(我有一个[^，。,.!?]+|我有个[^，。,.!?]+|my\s+[^,.!?]+|i own (?:a|an)?\s*[^,.!?]+|i have (?:a|an)?\s*[^,.!?]+)/gi) || [];
+    return Array.from(new Set(matches.map((match) => match.trim()).filter(Boolean)));
+}
+export function isPurchaseSignal(text) {
+    return includesLexiconTerm(text, RELATION_PHRASE_MAP.purchased);
+}
+export function isWorkedOnSignal(text) {
+    return includesLexiconTerm(text, RELATION_PHRASE_MAP.worked_on);
+}
+export function extractProjectCandidate(text) {
+    const normalized = normalizeLexiconText(text);
+    const targetedPatterns = [
+        /(?:we\s+are\s+building|we're\s+building|building|developing|working on|maintaining|shipping)\s+(?:an?\s+|the\s+)?([A-Za-z0-9._-]+(?:\s+[A-Za-z0-9._-]+){0,5}\s+(?:sdk|library|platform|api|project|repository|repo))\b/i,
+        /(?:for|in|during|on)\s+(?:the\s+)?([A-Za-z0-9._-]+(?:\s+[A-Za-z0-9._-]+){0,3}\s+project)\b/i,
+        /(?:worked on|working on|doing|building|maintaining|shipping)\s+([A-Za-z0-9._-]+(?:\s+[A-Za-z0-9._-]+){0,3}\s+project)\b/i,
+        /([A-Za-z0-9._-]+(?:\s+[A-Za-z0-9._-]+){0,5}\s+(?:sdk|library|platform|api))\b/i,
+        /([A-Za-z0-9._-]+(?:\s+[A-Za-z0-9._-]+){0,3}\s+project)\b/i,
+        /([\u4e00-\u9fa5A-Za-z0-9._-]+项目)/i
+    ];
+    for (const pattern of targetedPatterns) {
+        const matched = normalized.match(pattern)?.[1];
+        const candidate = matched ? cleanProjectSurfaceCandidate(matched) : undefined;
+        if (candidate)
+            return candidate;
+    }
+    const matches = Array.from(normalized.matchAll(PROJECT_SURFACE_PATTERN));
+    for (const match of matches) {
+        const candidate = cleanProjectSurfaceCandidate(match[1] || '');
+        if (candidate && !/(?:headset|monitor|keyboard|mouse|earbuds?|耳机|键盘|鼠标|显示器)/i.test(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+export function extractProjectLinks(text) {
+    const normalized = normalizeLexiconText(text);
+    const matches = normalized.match(/[\u4e00-\u9fa5A-Za-z0-9._-]+项目|[A-Za-z0-9._-]+(?:\s+[A-Za-z0-9._-]+){0,5}\s+(?:project|sdk|library|platform|api)/gi) || [];
+    return Array.from(new Set(matches
+        .map((match) => cleanProjectSurfaceCandidate(match))
+        .filter((match) => Boolean(match))));
+}
+export function extractProjectAliasCandidates(text) {
+    const normalized = normalizeLexiconText(text);
+    const aliases = new Set();
+    const projectCandidate = extractProjectCandidate(normalized);
+    const patterns = [
+        /([\u4e00-\u9fa5A-Za-z0-9._-]+项目|[A-Za-z0-9._-]+\s+project).{0,16}(?:也叫|又叫|别名是|alias|aka|also called|called)\s*([A-Za-z0-9._-]+(?:\s+project)?)/gi,
+        /([A-Za-z0-9._-]+(?:\s+project)?).{0,16}(?:就是|is|means)\s*([\u4e00-\u9fa5A-Za-z0-9._-]+项目|[A-Za-z0-9._-]+\s+project)/gi
+    ];
+    for (const pattern of patterns) {
+        for (const match of normalized.matchAll(pattern)) {
+            if (match[1])
+                aliases.add(match[1].trim());
+            if (match[2])
+                aliases.add(match[2].trim());
+        }
+    }
+    for (const link of extractProjectLinks(normalized)) {
+        aliases.add(link);
+        if (link.includes('-'))
+            aliases.add(link.replace(/-/g, ' '));
+        if (/\s+project$/i.test(link))
+            aliases.add(link.replace(/\s+project$/i, ''));
+        if (/\s+sdk$/i.test(link) && /\bbluetooth\b/i.test(link))
+            aliases.add('bluetooth sdk');
+    }
+    if (projectCandidate && /\bsdk\b/i.test(projectCandidate)) {
+        if (/\bbluetooth\b/i.test(projectCandidate))
+            aliases.add('bluetooth sdk');
+        if (/\bbluetooth low energy\b/i.test(projectCandidate))
+            aliases.add('ble sdk');
+        if (/\biot\b/i.test(normalized))
+            aliases.add('iot sdk');
+    }
+    for (const reference of extractRelativeReferences(normalized)) {
+        if (/project|项目/i.test(reference))
+            aliases.add(reference);
+    }
+    return Array.from(aliases).filter(Boolean);
+}
+export function extractConditionHints(text) {
+    const normalized = normalizeLexiconText(text);
+    const matches = normalized.match(/如果[^，。,.!?]+|if\s+[^,.!?]+/gi) || [];
+    return Array.from(new Set(matches.map((match) => match.trim()).filter(Boolean)));
+}
+export function extractTemporalHints(text) {
+    const normalized = normalizeLexiconText(text);
+    const hints = [];
+    if (/(今天|today)/i.test(normalized))
+        hints.push('today');
+    if (/(本周|this week)/i.test(normalized))
+        hints.push('this_week');
+    if (/(这个月|this month)/i.test(normalized))
+        hints.push('this_month');
+    if (/(近一年|past year|last year)/i.test(normalized))
+        hints.push('past_year');
+    if (/(半年|half year|six months)/i.test(normalized))
+        hints.push('around_half_year_ago');
+    return Array.from(new Set(hints));
+}
+export function extractPreference(text) {
+    const matches = Array.from(text.matchAll(/(?<verb>喜欢|I like|讨厌|不喜欢|I dislike)\s*(?<target>[\u4e00-\u9fa5A-Za-z0-9._-]+(?:\s+[\u4e00-\u9fa5A-Za-z0-9._-]+){0,2})/gi));
+    const last = matches[matches.length - 1];
+    if (!last?.groups?.verb || !last.groups.target)
+        return null;
+    return {
+        kind: /^(讨厌|不喜欢|I dislike)$/i.test(last.groups.verb) ? 'dislike' : 'like',
+        target: last.groups.target.trim().replace(/\s+/g, ' ')
+    };
+}
+export function extractNegativePreferenceCue(text) {
+    const normalized = normalizeLexiconText(text);
+    const negative = normalized.match(/(?:一闻到|一看到|看到|听到)?\s*([\u4e00-\u9fa5A-Za-z0-9._-]+(?:\s+[\u4e00-\u9fa5A-Za-z0-9._-]+){0,2})\s*(?:就烦|就讨厌|就难受|就不想碰)/i);
+    if (!negative?.[1])
+        return null;
+    return {
+        kind: 'dislike',
+        target: negative[1]
+            .trim()
+            .replace(/^(现在|如今|最近)\s*/i, '')
+            .replace(/^(一闻到|一看到|看到|听到)\s*/i, '')
+            .replace(/\s+/g, ' ')
+    };
+}
+export function extractExplicitNamedEntityCandidate(text) {
+    const normalized = normalizeLexiconText(text);
+    const explicitNamedDevice = normalized.match(/(?:i\s+bought(?:\s+(?:a|an|another))?(?:\s+new)?|i\s+have(?:\s+(?:a|an))?|i\s+had(?:\s+(?:a|an))?|i\s+got(?:\s+(?:a|an))?(?:\s+new)?|my|买了(?:一个|一副)?|我买了|我有一个|我有个|我的)\s+([A-Za-z][A-Za-z0-9._-]*(?:\s+[A-Za-z0-9._-]+){0,3})(?=\s+(?:for|in|during|on|yesterday|today|earlier|later|project|headset|monitor|keyboard|mouse|earbuds?)\b|[,.!?，。！？]|$)/i);
+    const candidate = explicitNamedDevice?.[1]
+        ?.trim()
+        .replace(/\s+(?:yesterday|today|earlier|later)\.?$/i, '')
+        .trim();
+    if (!candidate)
+        return null;
+    if (/^(i like|i dislike)$/i.test(candidate))
+        return null;
+    return collapseSurfaceWhitespace(candidate);
+}
+export function extractApprovedArchiveProject(text) {
+    const normalized = normalizeLexiconText(text);
+    const archiveProject = normalized.match(/(?:([\u4e00-\u9fa5A-Za-z0-9._-]+项目|[A-Za-z0-9._-]+\s+project).*(归档|archive))|((归档|archive).{0,12}([\u4e00-\u9fa5A-Za-z0-9._-]+项目|[A-Za-z0-9._-]+\s+project))/i);
+    return archiveProject?.[1] || archiveProject?.[5] || null;
+}
+export function inferReferenceType(reference, query) {
+    const candidate = `${reference} ${query}`.toLowerCase();
+    if (includesLexiconTerm(candidate, ENTITY_TYPE_LEXICON.device))
+        return 'device';
+    if (includesLexiconTerm(candidate, ENTITY_TYPE_LEXICON.project))
+        return 'project';
+    return undefined;
+}
+export function isLatestReference(reference) {
+    const normalized = reference.toLowerCase();
+    return REFERENCE_SYNONYMS.latest.some((item) => item.toLowerCase() === normalized)
+        || /\b(the\s+)?new\s+(headset|monitor|keyboard|mouse|project)\b/i.test(reference);
+}
+export function isPreviousReference(reference) {
+    const normalized = reference.toLowerCase();
+    return REFERENCE_SYNONYMS.previous.some((item) => item.toLowerCase() === normalized)
+        || /\b(the\s+)?previous\s+(headset|monitor|keyboard|mouse|project)\b/i.test(reference);
+}

package/dist/lexicon/language-packs/en.d.ts

@@ -0,0 +1,42 @@
+export declare const EN_ENTITY_TYPE_TERMS: {
+    readonly device: readonly ["keyboard", "mouse", "monitor", "device", "earbuds", "bluetooth earbuds", "headset", "earphone", "earphones"];
+    readonly project: readonly ["project", "repo", "repository", "sdk", "library", "platform", "api"];
+    readonly person: readonly ["they", "user"];
+    readonly brand: readonly ["apple", "sony", "logitech", "razer", "dell", "brand", "framework", "library"];
+    readonly issue: readonly ["issue", "bug"];
+};
+export declare const EN_RELATION_PHRASES: {
+    readonly owns: readonly ["i own", "i have", "i got", "my"];
+    readonly purchased: readonly ["i bought", "i bought another", "i bought a new", "i got a new"];
+    readonly has_issue: readonly ["issue", "disconnect", "noise", "lag", "slow", "connection lost", "flicker"];
+    readonly worked_on: readonly ["worked on", "working on", "building", "we are building", "we're building", "developing", "maintaining", "shipping"];
+    readonly likes: readonly ["i like"];
+    readonly dislikes: readonly ["i dislike"];
+};
+export declare const EN_REFERENCE_SIGNALS: {
+    readonly newInstance: readonly ["i bought another", "i got a new"];
+    readonly updateInstance: readonly ["that one", "the old one", "the new one", "the previous one", "previous one", "new one", "this project", "the new project", "the previous project"];
+    readonly ambiguous: readonly ["it", "this one", "that thing", "this project", "that project"];
+    readonly latest: readonly ["the new one", "new one", "this one", "the current one", "this project", "the new project", "new project", "that project"];
+    readonly previous: readonly ["the previous one", "previous one", "the old one", "old one", "the previous project", "previous project", "old project"];
+};
+export declare const EN_SHORT_REPLY_BINDING: {
+    readonly approved: readonly ["yes", "ok", "okay", "sounds good", "continue", "go on"];
+    readonly rejected: readonly ["no", "don't", "don't do that", "never mind", "forget it"];
+    readonly entitySelection: readonly ["that one", "this one", "the new one", "new one", "the previous one", "previous one", "the old one", "old one"];
+};
+export declare const EN_PENDING_PATTERNS: {
+    readonly action: readonly [RegExp, RegExp, RegExp];
+    readonly entity: readonly [RegExp, RegExp];
+};
+export declare const EN_LONG_TERM_SIGNAL_TERMS: readonly ["workflow", "api", "database", "project", "issue", "prefer", "like", "dislike", "decide", "using", "fixed", "gave away"];
+export declare const EN_ISSUE_KEYWORDS: {
+    readonly connectivity: readonly ["disconnect", "connection lost"];
+    readonly sound: readonly ["noise"];
+    readonly performance: readonly ["lag", "slow", "flicker"];
+};
+export declare const EN_ISSUE_QUALIFIERS: {
+    readonly left: readonly ["left ear"];
+    readonly right: readonly ["right ear"];
+};
+//# sourceMappingURL=en.d.ts.map

package/dist/lexicon/language-packs/en.js

@@ -0,0 +1,41 @@
+export const EN_ENTITY_TYPE_TERMS = {
+    device: ['keyboard', 'mouse', 'monitor', 'device', 'earbuds', 'bluetooth earbuds', 'headset', 'earphone', 'earphones'],
+    project: ['project', 'repo', 'repository', 'sdk', 'library', 'platform', 'api'],
+    person: ['they', 'user'],
+    brand: ['apple', 'sony', 'logitech', 'razer', 'dell', 'brand', 'framework', 'library'],
+    issue: ['issue', 'bug']
+};
+export const EN_RELATION_PHRASES = {
+    owns: ['i own', 'i have', 'i got', 'my'],
+    purchased: ['i bought', 'i bought another', 'i bought a new', 'i got a new'],
+    has_issue: ['issue', 'disconnect', 'noise', 'lag', 'slow', 'connection lost', 'flicker'],
+    worked_on: ['worked on', 'working on', 'building', 'we are building', "we're building", 'developing', 'maintaining', 'shipping'],
+    likes: ['i like'],
+    dislikes: ['i dislike']
+};
+export const EN_REFERENCE_SIGNALS = {
+    newInstance: ['i bought another', 'i got a new'],
+    updateInstance: ['that one', 'the old one', 'the new one', 'the previous one', 'previous one', 'new one', 'this project', 'the new project', 'the previous project'],
+    ambiguous: ['it', 'this one', 'that thing', 'this project', 'that project'],
+    latest: ['the new one', 'new one', 'this one', 'the current one', 'this project', 'the new project', 'new project', 'that project'],
+    previous: ['the previous one', 'previous one', 'the old one', 'old one', 'the previous project', 'previous project', 'old project']
+};
+export const EN_SHORT_REPLY_BINDING = {
+    approved: ['yes', 'ok', 'okay', 'sounds good', 'continue', 'go on'],
+    rejected: ['no', "don't", "don't do that", 'never mind', 'forget it'],
+    entitySelection: ['that one', 'this one', 'the new one', 'new one', 'the previous one', 'previous one', 'the old one', 'old one']
+};
+export const EN_PENDING_PATTERNS = {
+    action: [/\bshould\b/i, /\bdo you want\b/i, /\bwant me to\b/i],
+    entity: [/\bwhich\b/i, /\bor\b/i]
+};
+export const EN_LONG_TERM_SIGNAL_TERMS = ['workflow', 'api', 'database', 'project', 'issue', 'prefer', 'like', 'dislike', 'decide', 'using', 'fixed', 'gave away'];
+export const EN_ISSUE_KEYWORDS = {
+    connectivity: ['disconnect', 'connection lost'],
+    sound: ['noise'],
+    performance: ['lag', 'slow', 'flicker']
+};
+export const EN_ISSUE_QUALIFIERS = {
+    left: ['left ear'],
+    right: ['right ear']
+};

package/dist/lexicon/language-packs/zh.d.ts

@@ -0,0 +1,42 @@
+export declare const ZH_ENTITY_TYPE_TERMS: {
+    readonly device: readonly ["耳机", "键盘", "鼠标", "显示器"];
+    readonly project: readonly ["项目"];
+    readonly person: readonly ["我", "用户", "他", "她"];
+    readonly brand: readonly ["品牌", "框架", "库"];
+    readonly issue: readonly ["问题", "故障", "异常"];
+};
+export declare const ZH_RELATION_PHRASES: {
+    readonly owns: readonly ["我有一个", "我有个"];
+    readonly purchased: readonly ["买了一个", "又买了一个", "新买的", "重新买了", "第二个"];
+    readonly has_issue: readonly ["有问题", "什么问题", "故障", "异常", "坏了", "断连", "杂音", "卡顿", "延迟", "闪屏"];
+    readonly worked_on: readonly ["做过", "负责过", "参与过"];
+    readonly likes: readonly ["喜欢"];
+    readonly dislikes: readonly ["讨厌", "不喜欢"];
+};
+export declare const ZH_REFERENCE_SIGNALS: {
+    readonly newInstance: readonly ["新买的", "新的那个", "第二个", "刚入手一个", "又买了一个"];
+    readonly updateInstance: readonly ["那个耳机", "那个设备", "那个项目", "前一个", "之前那个", "它后来", "旧的"];
+    readonly ambiguous: readonly ["它", "这个", "那个东西", "那个设备"];
+    readonly latest: readonly ["新的那个", "新的设备", "新买的设备", "这个设备", "那个设备", "这个项目", "那个项目", "新项目", "新的项目", "它", "新买的耳机", "这个耳机", "那个耳机"];
+    readonly previous: readonly ["之前那个", "前一个", "前一个设备", "旧设备", "前一个项目", "旧项目", "上一个项目", "前一个耳机", "旧耳机"];
+};
+export declare const ZH_SHORT_REPLY_BINDING: {
+    readonly approved: readonly ["好的", "好", "行", "可以", "继续"];
+    readonly rejected: readonly ["不要", "不行", "算了", "先别这个", "先别"];
+    readonly entitySelection: readonly ["旧的那个", "就这个", "还是它"];
+};
+export declare const ZH_PENDING_PATTERNS: {
+    readonly action: readonly [RegExp, RegExp, RegExp, RegExp];
+    readonly entity: readonly [RegExp, RegExp, RegExp];
+};
+export declare const ZH_LONG_TERM_SIGNAL_TERMS: readonly ["项目", "喜欢", "讨厌", "决定", "必须", "不能", "买了", "修好了", "送人了", "在用"];
+export declare const ZH_ISSUE_KEYWORDS: {
+    readonly connectivity: readonly ["断连", "掉线", "配对失败"];
+    readonly sound: readonly ["杂音", "爆音", "无声", "收音发闷", "电流声"];
+    readonly performance: readonly ["卡顿", "延迟", "慢", "不稳定", "闪屏"];
+};
+export declare const ZH_ISSUE_QUALIFIERS: {
+    readonly left: readonly ["左耳"];
+    readonly right: readonly ["右耳"];
+};
+//# sourceMappingURL=zh.d.ts.map