@atomicmemory/core 1.0.0

package/dist/services/event-anchor-facts.js

@@ -0,0 +1,205 @@
+/**
+ * Deterministic event-anchor fact generation for Cat2-style disambiguation.
+ * Converts high-signal extracted facts into explicit event memories such as
+ * "event anchor mentorship.received for Jon occurred on June 15 2023" so
+ * retrieval and answer-time prompting can rely on structured event labels.
+ */
+import { dedupeEntities } from './entity-dedup.js';
+import { extractRelativeTemporalAnchors } from './relative-temporal.js';
+const RECORDED_DATE_PATTERN = /^As of ([A-Za-z]+ \d{1,2} \d{4}),\s*/i;
+const EXPLICIT_EVENT_ANCHOR_PATTERN = /\bevent anchor\s+[a-z.]+/i;
+const EVENT_DATE_PATTERN = /\boccurred on ([A-Za-z]+ \d{1,2} \d{4})\b/i;
+const NON_SUBJECT_TOKENS = new Set(['Hey', 'Long', 'Yesterday', 'Thats', 'Awesome', 'Oh', 'Paris', 'Rome', 'Barcelona']);
+const MONTH_INDEX = {
+    january: 0,
+    february: 1,
+    march: 2,
+    april: 3,
+    may: 4,
+    june: 5,
+    july: 6,
+    august: 7,
+    september: 8,
+    october: 9,
+    november: 10,
+    december: 11,
+};
+export function inferEventAnchorFacts(fact) {
+    if (EXPLICIT_EVENT_ANCHOR_PATTERN.test(fact.fact)) {
+        return [];
+    }
+    const recordedDate = parseRecordedDate(fact.fact);
+    if (!recordedDate) {
+        return [];
+    }
+    return inferDescriptors(fact, recordedDate).map((descriptor) => buildAnchorFact(fact, descriptor));
+}
+function inferDescriptors(fact, recordedDate) {
+    const lower = fact.fact.toLowerCase();
+    const subject = inferSubject(fact);
+    if (!subject) {
+        return [];
+    }
+    const eventDateIso = inferEventDateIso(fact.fact, recordedDate);
+    const descriptors = [];
+    for (const rule of DESCRIPTOR_RULES) {
+        const labels = rule(lower);
+        for (const label of labels) {
+            descriptors.push({ label, subject, eventDateIso });
+        }
+    }
+    return dedupeDescriptors(descriptors);
+}
+/** Ordered list of pattern-matching rules, each returning zero or more labels. */
+const DESCRIPTOR_RULES = [
+    (l) => l.includes('accepted') && l.includes('internship') ? ['internship.accepted'] : [],
+    (l) => l.includes('interview') && l.includes('internship') ? ['internship.interviewed'] : [],
+    (l) => (l.includes('got mentored') || l.includes('mentored by') || l.includes('received mentorship')) ? ['mentorship.received'] : [],
+    (l) => (l.includes('mentoring') || l.includes('mentor aspiring') || l.includes('one-on-one mentoring')) ? ['mentorship.given'] : [],
+    inferNetworkingLabels,
+    inferParisLabels,
+    inferRomeLabels,
+    (l) => (l.includes('collaborat') || l.includes('content creation') || l.includes('social media management'))
+        && (l.includes('plan') || l.includes('help') || l.includes('offered')) ? ['collaboration.decided'] : [],
+    (l) => l.includes('shia labeouf') ? ['quote.mentioned'] : [],
+    (l) => l.includes('dance class') && l.includes('group of friends') ? ['dance_class.attended'] : [],
+];
+function inferNetworkingLabels(lower) {
+    if (!lower.includes('networking'))
+        return [];
+    if (lower.includes('chose to attend') || lower.includes('go to networking')
+        || lower.includes('visit networking') || lower.includes('yesterday')) {
+        return ['networking.first_visit'];
+    }
+    if (lower.includes('last networking event') || lower.includes('met investors')) {
+        return ['networking.followup'];
+    }
+    return [];
+}
+function inferParisLabels(lower) {
+    if (!lower.includes('paris'))
+        return [];
+    const labels = ['trip.paris'];
+    if (lower.includes('return') || lower.includes('returned from') || lower.includes('returns from')) {
+        labels.push('trip.returned_from_paris');
+    }
+    return labels;
+}
+function inferRomeLabels(lower) {
+    if (!lower.includes('rome'))
+        return [];
+    const labels = ['trip.rome'];
+    if (lower.includes('short trip')) {
+        labels.push('trip.took_short_trip_rome');
+    }
+    return labels;
+}
+function buildAnchorFact(sourceFact, descriptor) {
+    const recordedPrefix = sourceFact.fact.match(RECORDED_DATE_PATTERN)?.[1];
+    const eventDateHuman = formatHumanDate(descriptor.eventDateIso);
+    const anchorFact = `As of ${recordedPrefix}, event anchor ${descriptor.label} for ${descriptor.subject} occurred on ${eventDateHuman}.`;
+    return {
+        fact: anchorFact,
+        headline: `Event ${descriptor.label}`,
+        importance: Math.max(sourceFact.importance, 0.85),
+        type: 'knowledge',
+        keywords: buildKeywords(descriptor),
+        entities: buildEntities(sourceFact.entities, descriptor.subject),
+        relations: [],
+        network: sourceFact.network,
+        opinionConfidence: sourceFact.opinionConfidence ?? null,
+    };
+}
+function inferSubject(fact) {
+    const people = fact.entities
+        .filter((entity) => entity.name !== 'User' && looksLikeSubjectEntity(entity))
+        .map((entity) => entity.name);
+    if (people.length >= 2 && fact.fact.toLowerCase().includes('collaborat')) {
+        return people.sort().join(' and ');
+    }
+    if (people.length > 0) {
+        return people[people.length - 1];
+    }
+    if (/\buser\b/i.test(fact.fact)) {
+        return 'User';
+    }
+    return null;
+}
+function looksLikeSubjectEntity(entity) {
+    if (NON_SUBJECT_TOKENS.has(entity.name)) {
+        return false;
+    }
+    if (entity.type === 'person') {
+        return true;
+    }
+    return entity.type === 'concept' && /^[A-Z][a-z]+(?:\s+[A-Z][a-z]+)?$/.test(entity.name);
+}
+function inferEventDateIso(text, recordedDate) {
+    const relativeAnchor = extractRelativeTemporalAnchors(text, recordedDate)[0];
+    if (relativeAnchor) {
+        return relativeAnchor.eventDate;
+    }
+    const explicit = text.match(EVENT_DATE_PATTERN);
+    if (explicit) {
+        return formatIsoDate(explicit[1]);
+    }
+    return recordedDate.toISOString().slice(0, 10);
+}
+function buildKeywords(descriptor) {
+    return [
+        ...descriptor.label.split('.'),
+        descriptor.label,
+        descriptor.subject,
+        formatHumanDate(descriptor.eventDateIso),
+    ];
+}
+function buildEntities(entities, subject) {
+    const baseEntities = entities.filter((entity) => entity.type === 'person' && entity.name !== 'User');
+    const subjectEntities = subject
+        .split(' and ')
+        .map((name) => name.trim())
+        .filter(Boolean)
+        .map((name) => ({ name, type: 'person' }));
+    return dedupeEntities([...baseEntities, ...subjectEntities, { name: 'event anchor', type: 'concept' }]);
+}
+function dedupeDescriptors(descriptors) {
+    const unique = new Map();
+    for (const descriptor of descriptors) {
+        unique.set(`${descriptor.label}:${descriptor.subject}:${descriptor.eventDateIso}`, descriptor);
+    }
+    return [...unique.values()];
+}
+function parseRecordedDate(text) {
+    const match = text.match(RECORDED_DATE_PATTERN);
+    if (!match) {
+        return null;
+    }
+    return parseHumanDate(match[1]);
+}
+function parseHumanDate(input) {
+    const match = input.match(/^([A-Za-z]+) (\d{1,2}) (\d{4})$/);
+    if (!match) {
+        return null;
+    }
+    const month = MONTH_INDEX[match[1].toLowerCase()];
+    if (month === undefined) {
+        return null;
+    }
+    return new Date(Date.UTC(Number(match[3]), month, Number(match[2]), 0, 0, 0, 0));
+}
+function formatHumanDate(isoDate) {
+    const [year, month, day] = isoDate.split('-').map(Number);
+    return new Date(Date.UTC(year, month - 1, day, 0, 0, 0, 0)).toLocaleDateString('en-US', {
+        timeZone: 'UTC',
+        month: 'long',
+        day: 'numeric',
+        year: 'numeric',
+    });
+}
+function formatIsoDate(input) {
+    const parsed = parseHumanDate(input);
+    if (!parsed) {
+        return input;
+    }
+    return parsed.toISOString().slice(0, 10);
+}

package/dist/services/event-chain-detector.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Event-chain detector — finds per-entity chronological sequences in a set
+ * of retrieved memories.
+ *
+ * Replaces the TLL invocation regex. Rather than guess from query phrasing
+ * whether ordering matters, this module inspects the retrieved data: if 3+
+ * memories share an entity AND span 3+ distinct observed_at dates AND
+ * exhibit state-change between them, that's a chain worth emitting.
+ *
+ * Decisions are data-driven; no prompt regex.
+ */
+export interface ChainMember {
+    memoryId: string;
+    observedAt: Date;
+    text: string;
+}
+export interface EventChain {
+    entity: string;
+    /** Members sorted ascending by observedAt. */
+    members: ChainMember[];
+    /**
+     * Score reflecting confidence the chain is meaningful for ordering questions.
+     * Higher = more confident. Computed from #members × distinct-date-count × 1.0.
+     */
+    score: number;
+}
+export interface ChainDetectorCandidate {
+    id: string;
+    text: string;
+    observedAt: Date;
+    /** Primary entity key; when provided, used directly for grouping. */
+    entityIds?: string[];
+}
+export interface ChainDetectorInput {
+    /** The retrieved memories from RRF + reranking. Order does not matter. */
+    candidates: ReadonlyArray<ChainDetectorCandidate>;
+    /** Minimum members to qualify as a chain. Recommended default: 3. */
+    minMembers: number;
+    /** Minimum number of distinct observed_at dates among members. Recommended default: 3. */
+    minDistinctDates: number;
+}
+export interface ChainDetectorResult {
+    /** Event chains sorted descending by score. */
+    chains: EventChain[];
+}
+/**
+ * Detect per-entity chronological event chains in a retrieved candidate set.
+ *
+ * Returns chains sorted descending by score. Chains below CHAIN_SCORE_FLOOR
+ * or with fewer than minMembers / minDistinctDates are excluded.
+ */
+export declare function detectEventChains(input: ChainDetectorInput): ChainDetectorResult;

package/dist/services/event-chain-detector.js

@@ -0,0 +1,83 @@
+/**
+ * Event-chain detector — finds per-entity chronological sequences in a set
+ * of retrieved memories.
+ *
+ * Replaces the TLL invocation regex. Rather than guess from query phrasing
+ * whether ordering matters, this module inspects the retrieved data: if 3+
+ * memories share an entity AND span 3+ distinct observed_at dates AND
+ * exhibit state-change between them, that's a chain worth emitting.
+ *
+ * Decisions are data-driven; no prompt regex.
+ */
+/** Minimum score a candidate chain must reach to be emitted. */
+const CHAIN_SCORE_FLOOR = 9;
+/**
+ * Extract a fallback grouping key from memory text when entityIds is absent.
+ * Takes the first non-stopword token from the text, normalized to lowercase.
+ * Crude but avoids an LLM call — keeps this module synchronous and zero-latency.
+ */
+function extractFallbackEntityKey(text) {
+    const stopwords = new Set([
+        'the', 'a', 'an', 'i', 'my', 'your', 'user', 'is', 'was', 'has', 'have',
+        'to', 'of', 'in', 'on', 'at', 'for', 'and', 'or', 'it', 'this', 'that',
+    ]);
+    const tokens = text.toLowerCase().replace(/[^a-z0-9\s]/g, '').split(/\s+/);
+    const meaningful = tokens.find((t) => t.length >= 3 && !stopwords.has(t));
+    return meaningful ?? '__unknown__';
+}
+/** Derive a stable entity key from a candidate. */
+function entityKey(candidate) {
+    if (candidate.entityIds && candidate.entityIds.length > 0) {
+        return candidate.entityIds[0];
+    }
+    return extractFallbackEntityKey(candidate.text);
+}
+/** Count the number of distinct calendar-day strings in a set of dates. */
+function countDistinctDates(dates) {
+    return new Set(dates.map((d) => d.toISOString().slice(0, 10))).size;
+}
+/** Build one EventChain from a validated group of candidates. */
+function buildChain(entity, group) {
+    const sorted = [...group].sort((a, b) => a.observedAt.getTime() - b.observedAt.getTime());
+    const distinctDates = countDistinctDates(sorted.map((c) => c.observedAt));
+    const score = sorted.length * distinctDates;
+    const members = sorted.map((c) => ({
+        memoryId: c.id,
+        observedAt: c.observedAt,
+        text: c.text,
+    }));
+    return { entity, members, score };
+}
+/**
+ * Detect per-entity chronological event chains in a retrieved candidate set.
+ *
+ * Returns chains sorted descending by score. Chains below CHAIN_SCORE_FLOOR
+ * or with fewer than minMembers / minDistinctDates are excluded.
+ */
+export function detectEventChains(input) {
+    const { candidates, minMembers, minDistinctDates } = input;
+    if (candidates.length === 0)
+        return { chains: [] };
+    // Group candidates by entity key
+    const groups = new Map();
+    for (const candidate of candidates) {
+        const key = entityKey(candidate);
+        if (!groups.has(key))
+            groups.set(key, []);
+        groups.get(key).push(candidate);
+    }
+    const chains = [];
+    for (const [entity, group] of groups) {
+        if (group.length < minMembers)
+            continue;
+        const distinctDates = countDistinctDates(group.map((c) => c.observedAt));
+        if (distinctDates < minDistinctDates)
+            continue;
+        const chain = buildChain(entity, group);
+        if (chain.score < CHAIN_SCORE_FLOOR)
+            continue;
+        chains.push(chain);
+    }
+    chains.sort((a, b) => b.score - a.score);
+    return { chains };
+}

package/dist/services/extraction-cache.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Disk-based extraction cache for deterministic eval runs.
+ * Caches extractFacts() and resolveAUDN() results keyed by input hash.
+ * When EXTRACTION_CACHE_ENABLED=true, identical inputs produce identical
+ * outputs across runs, eliminating LLM non-determinism from eval comparisons.
+ */
+import { type AUDNDecision, type ExtractionOptions, type ExtractedFact, type ExistingMemory } from './extraction.js';
+export declare function cachedExtractFacts(conversationText: string, options?: ExtractionOptions): Promise<ExtractedFact[]>;
+export declare function cachedResolveAUDN(newFact: string, existingMemories: ExistingMemory[]): Promise<AUDNDecision>;

package/dist/services/extraction-cache.js

@@ -0,0 +1,54 @@
+/**
+ * Disk-based extraction cache for deterministic eval runs.
+ * Caches extractFacts() and resolveAUDN() results keyed by input hash.
+ * When EXTRACTION_CACHE_ENABLED=true, identical inputs produce identical
+ * outputs across runs, eliminating LLM non-determinism from eval comparisons.
+ */
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { config } from '../config.js';
+import { extractFacts, resolveAUDN, } from './extraction.js';
+function hashInput(parts) {
+    return createHash('sha256').update(parts.join('\0')).digest('hex').slice(0, 16);
+}
+function cacheFilePath(key) {
+    return join(config.extractionCacheDir, `${key}.json`);
+}
+function readCache(filePath) {
+    if (!existsSync(filePath))
+        return null;
+    const raw = readFileSync(filePath, 'utf-8');
+    return JSON.parse(raw);
+}
+function writeCache(filePath, value) {
+    mkdirSync(config.extractionCacheDir, { recursive: true });
+    const tmpPath = `${filePath}.tmp`;
+    writeFileSync(tmpPath, JSON.stringify(value, null, 2), 'utf-8');
+    renameSync(tmpPath, filePath);
+}
+export async function cachedExtractFacts(conversationText, options = {}) {
+    if (!config.extractionCacheEnabled)
+        return extractFacts(conversationText, options);
+    const key = `extract-${hashInput([conversationText, JSON.stringify(options)])}`;
+    const filePath = cacheFilePath(key);
+    const cached = readCache(filePath);
+    if (cached)
+        return cached;
+    const result = await extractFacts(conversationText, options);
+    writeCache(filePath, result);
+    return result;
+}
+export async function cachedResolveAUDN(newFact, existingMemories) {
+    if (!config.extractionCacheEnabled)
+        return resolveAUDN(newFact, existingMemories);
+    const memoriesKey = JSON.stringify(existingMemories.map((m) => ({ id: m.id, content: m.content, similarity: m.similarity })));
+    const key = `audn-${hashInput([newFact, memoriesKey])}`;
+    const filePath = cacheFilePath(key);
+    const cached = readCache(filePath);
+    if (cached)
+        return cached;
+    const result = await resolveAUDN(newFact, existingMemories);
+    writeCache(filePath, result);
+    return result;
+}

package/dist/services/extraction-enrichment.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Deterministic enrichment for extracted entities and relations.
+ * Complements LLM extraction by adding a stable self entity plus high-signal
+ * relation/entity patterns that the model often omits in temporal comparison
+ * facts and advisor/timeline facts.
+ */
+import type { ExtractedFact } from './extraction.js';
+export declare function enrichExtractedFacts(facts: ExtractedFact[]): ExtractedFact[];
+export declare function enrichExtractedFact(fact: ExtractedFact): ExtractedFact;

package/dist/services/extraction-enrichment.js

@@ -0,0 +1,223 @@
+/**
+ * Deterministic enrichment for extracted entities and relations.
+ * Complements LLM extraction by adding a stable self entity plus high-signal
+ * relation/entity patterns that the model often omits in temporal comparison
+ * facts and advisor/timeline facts.
+ */
+import { dedupeEntities } from './entity-dedup.js';
+import { inferEventAnchorFacts } from './event-anchor-facts.js';
+const SELF_ENTITY = { name: 'User', type: 'person' };
+const SELF_MARKERS = ['user ', 'user\'s', 'i ', 'i\'m', 'i’ve', 'i have', 'my '];
+const PREFERENCE_MARKERS = ['prefer', 'favorite', 'love', 'like', "can't go back"];
+const USES_MARKERS = ['using', 'use', 'added', 'implemented', 'integration', 'switched from', 'switch from', 'switch to'];
+const WORKS_ON_MARKERS = ['building', 'working on', 'started', 'created', 'built', 'update on'];
+const KNOWS_MARKERS = ['advisor', 'career advice from', 'supportive', 'recommendation letter', 'recommended by'];
+const STUDIES_MARKERS = ['focus on', 'studying', 'research', 'paper on'];
+const TOOL_NAMES = new Set([
+    'React',
+    'TypeScript',
+    'Vite',
+    'Tailwind CSS',
+    'Supabase',
+    'Plaid',
+    'tRPC',
+    'React Query',
+    'TanStack Virtual',
+    'Vercel',
+    'GRE',
+    'EMNLP 2025',
+    'ACL 2026',
+]);
+const ORGANIZATION_NAMES = new Set([
+    'OpenAI',
+    'Anthropic',
+    'Google',
+    'Meta',
+    'Microsoft Research',
+    'Stanford',
+    'MIT',
+    'CMU',
+    'UC Berkeley',
+]);
+const CANONICAL_ENTITY_NAMES = {
+    msr: 'Microsoft Research',
+};
+export function enrichExtractedFacts(facts) {
+    const enriched = facts.flatMap((fact) => {
+        const baseFact = enrichExtractedFact(fact);
+        return [baseFact, ...inferEventAnchorFacts(baseFact)];
+    });
+    return dedupeFacts(enriched);
+}
+export function enrichExtractedFact(fact) {
+    const entities = dedupeEntities([
+        ...fact.entities,
+        ...inferKeywordEntities(fact),
+        ...inferFactEntities(fact.fact),
+    ]);
+    const withSelf = shouldAddSelfEntity(fact.fact) ? dedupeEntities([SELF_ENTITY, ...entities]) : entities;
+    const relations = dedupeRelations([
+        ...fact.relations,
+        ...inferRelations(fact.fact, withSelf),
+    ]);
+    return { ...fact, entities: withSelf, relations };
+}
+function shouldAddSelfEntity(text) {
+    const lower = text.toLowerCase();
+    return SELF_MARKERS.some((marker) => lower.includes(marker));
+}
+function inferKeywordEntities(fact) {
+    return fact.keywords
+        .map((keyword) => inferEntityFromToken(keyword, fact.fact))
+        .filter((entity) => entity !== null);
+}
+function inferFactEntities(text) {
+    const matches = [];
+    const personMatches = text.match(/\bDr\.\s+[A-Z][a-z]+(?:\s+[A-Z][a-z]+)?\b/g) ?? [];
+    for (const match of personMatches) {
+        matches.push({ name: match.trim(), type: 'person' });
+    }
+    const projectMatches = text.match(/\b(?:the\s+)?([A-Za-z0-9.-]+(?:\s+[A-Za-z0-9.-]+){0,2}\s+(?:tracker|project|app|repo|dashboard|paper))\b/gi) ?? [];
+    for (const match of projectMatches) {
+        matches.push({ name: normalizeEntityDisplay(match), type: 'project' });
+    }
+    const orgMatches = text.match(/\b(?:Microsoft Research|UC Berkeley|Stanford|MIT|CMU|Google|Meta|OpenAI|Anthropic)\b/g) ?? [];
+    for (const match of orgMatches) {
+        matches.push({ name: normalizeEntityDisplay(match), type: 'organization' });
+    }
+    const titleMatches = [
+        ...extractPatternCaptures(text, /\b(?:recommended|reading|book(?:\s+\w+){0,2}\s+was|favorite childhood book was|favorite book was|song|songs|listening to|fan of)\s+("?)([A-Z][A-Za-z'’.-]+(?:\s+[A-Z][A-Za-z'’.-]+)*)\1/g),
+        ...extractPatternCaptures(text, /["“”]([^"“”]{2,80})["“”]/g),
+    ];
+    for (const match of titleMatches) {
+        matches.push({ name: normalizeEntityDisplay(match), type: 'concept' });
+    }
+    const petMatches = extractPatternCaptures(text, /\b([A-Z][a-z]+)\s+(?:hid|hides|found|finds|was|is)\s+(?:his|her|a|an|the)\b/g);
+    for (const match of petMatches) {
+        matches.push({ name: normalizeEntityDisplay(match), type: 'concept' });
+    }
+    return matches;
+}
+function inferEntityFromToken(token, factText) {
+    const cleaned = normalizeEntityDisplay(token);
+    const canonical = CANONICAL_ENTITY_NAMES[cleaned.toLowerCase()] ?? cleaned;
+    if (TOOL_NAMES.has(canonical)) {
+        return { name: canonical, type: 'tool' };
+    }
+    if (ORGANIZATION_NAMES.has(canonical)) {
+        return { name: canonical, type: 'organization' };
+    }
+    if (/^Dr\.\s+[A-Z]/.test(canonical)) {
+        return { name: canonical, type: 'person' };
+    }
+    if (looksLikeProject(canonical, factText)) {
+        return { name: canonical, type: 'project' };
+    }
+    if (looksLikeConcept(canonical, factText)) {
+        return { name: canonical, type: 'concept' };
+    }
+    return null;
+}
+function inferRelations(text, entities) {
+    const lower = text.toLowerCase();
+    const relations = [];
+    const grouped = groupEntitiesByType(entities);
+    if (grouped.self) {
+        inferSelfRelations(lower, grouped.self.name, grouped, relations);
+    }
+    inferCrossEntityRelations(lower, grouped, relations);
+    return relations.filter((relation) => relation.source !== relation.target);
+}
+/** Partition entities into typed groups for relation inference. */
+function groupEntitiesByType(entities) {
+    return {
+        self: entities.find((e) => e.name === SELF_ENTITY.name),
+        people: entities.filter((e) => e.type === 'person' && e.name !== SELF_ENTITY.name),
+        tools: entities.filter((e) => e.type === 'tool'),
+        projects: entities.filter((e) => e.type === 'project'),
+        orgs: entities.filter((e) => e.type === 'organization'),
+        concepts: entities.filter((e) => e.type === 'concept'),
+    };
+}
+/** Infer relations from the self entity to other entities based on text markers. */
+function inferSelfRelations(lower, selfName, grouped, relations) {
+    const markerRules = [
+        { markers: USES_MARKERS, targets: grouped.tools, type: 'uses' },
+        { markers: WORKS_ON_MARKERS, targets: grouped.projects, type: 'works_on' },
+        { markers: PREFERENCE_MARKERS, targets: grouped.tools, type: 'prefers' },
+        { markers: KNOWS_MARKERS, targets: grouped.people, type: 'knows' },
+        { markers: STUDIES_MARKERS, targets: grouped.concepts, type: 'studies' },
+    ];
+    for (const rule of markerRules) {
+        if (containsAny(lower, rule.markers)) {
+            for (const target of rule.targets) {
+                relations.push({ source: selfName, target: target.name, type: rule.type });
+            }
+        }
+    }
+    if (/\bwork(?:ing)?(?:\s+as\s+.+?)?\s+at\b/.test(lower)) {
+        for (const org of grouped.orgs) {
+            relations.push({ source: selfName, target: org.name, type: 'works_at' });
+        }
+    }
+}
+/** Infer cross-entity relations (person-org, project-tool). */
+function inferCrossEntityRelations(lower, grouped, relations) {
+    if (grouped.people.length > 0 && grouped.orgs.length > 0 && /\bat\b/.test(lower)) {
+        for (const person of grouped.people) {
+            for (const org of grouped.orgs) {
+                relations.push({ source: person.name, target: org.name, type: 'works_at' });
+            }
+        }
+    }
+    if (grouped.projects.length > 0 && grouped.tools.length > 0 && containsAny(lower, USES_MARKERS)) {
+        for (const project of grouped.projects) {
+            for (const tool of grouped.tools) {
+                relations.push({ source: project.name, target: tool.name, type: 'uses' });
+            }
+        }
+    }
+}
+function containsAny(text, markers) {
+    return markers.some((marker) => text.includes(marker));
+}
+function looksLikeProject(token, factText) {
+    const lowerToken = token.toLowerCase();
+    return /\b(tracker|project|app|repo|dashboard|paper)\b/.test(lowerToken)
+        || factText.toLowerCase().includes(`the ${lowerToken}`)
+        || lowerToken === 'dotctl';
+}
+function looksLikeConcept(token, factText) {
+    const lowerToken = token.toLowerCase();
+    return /\b(llms?|machine translation|transfer learning|low-resource|phd|languages?)\b/.test(lowerToken)
+        || /\b(focus on|research|paper on|studying)\b/.test(factText.toLowerCase());
+}
+function normalizeEntityDisplay(token) {
+    return token.trim().replace(/^[Tt]he\s+/, '').replace(/[. ]+$/, '');
+}
+function extractPatternCaptures(text, pattern) {
+    const matches = [];
+    const regex = new RegExp(pattern.source, pattern.flags);
+    let match;
+    while ((match = regex.exec(text)) !== null) {
+        const captured = match[2] ?? match[1];
+        if (captured) {
+            matches.push(captured.trim());
+        }
+    }
+    return matches;
+}
+function dedupeFacts(facts) {
+    const unique = new Map();
+    for (const fact of facts) {
+        unique.set(fact.fact.toLowerCase().replace(/\s+/g, ' ').trim(), fact);
+    }
+    return [...unique.values()];
+}
+function dedupeRelations(relations) {
+    const unique = new Map();
+    for (const relation of relations) {
+        unique.set(`${relation.source.toLowerCase()}:${relation.type}:${relation.target.toLowerCase()}`, relation);
+    }
+    return [...unique.values()];
+}