openclaw-cortex-memory 0.1.0-Alpha.30 → 0.1.0-Alpha.32

package/dist/src/graph/ontology.js

@@ -34,9 +34,13 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeEntityName = normalizeEntityName;
+exports.getEntityMatchKeys = getEntityMatchKeys;
 exports.loadGraphSchema = loadGraphSchema;
 exports.normalizeEventType = normalizeEventType;
 exports.normalizeRelationType = normalizeRelationType;
+exports.isCanonicalRelationType = isCanonicalRelationType;
+exports.getDefaultGraphSchema = getDefaultGraphSchema;
+exports.buildRelationPromptHint = buildRelationPromptHint;
 exports.buildCanonicalId = buildCanonicalId;
 exports.validateRelations = validateRelations;
 exports.normalizeEntityType = normalizeEntityType;
@@ -113,20 +117,40 @@ const DEFAULT_SCHEMA = {
         "Concept",
         "Resource",
         "Document",
+        "ConfigFile",
+        "Preference",
+        "Case",
+        "Pattern",
+        "Date",
     ],
     entityAliases: {
         "OpenClaw": ["openclaw", "插件", "该项目", "本项目"],
         "FamilyMember": ["家人", "家庭成员", "亲人"],
         "Friend": ["朋友", "好友"],
+        "Team": ["团队", "小组", "组", "班组"],
         "Location": ["地点", "位置", "住址", "地址"],
         "Event": ["活动", "事情", "事项"],
         "Schedule": ["日程", "安排", "计划表"],
         "Habit": ["习惯", "作息"],
         "HealthItem": ["健康", "体检", "药物", "锻炼"],
         "FinanceItem": ["账单", "支出", "收入", "预算"],
-        "Person": ["我", "自己", "本人", "同事", "客户", "用户"],
-        "Project": ["项目", "工程"],
-        "Task": ["任务", "待办", "todo"],
+        "Plan": ["计划", "方案", "路线图"],
+        "Preference": ["偏好", "习惯选择"],
+        "Document": ["文档", "说明文档", "手册", "wiki", "README", "PRD", "方案文档"],
+        "Resource": ["资源", "物品", "物件", "设备", "工具", "素材", "资产"],
+        "ConfigFile": ["配置文件", "config", "配置"],
+        "Decision": ["决策", "决定", "拍板"],
+        "Action": ["动作", "操作", "执行"],
+        "Risk": ["风险", "隐患"],
+        "Blocker": ["阻塞", "卡点", "障碍"],
+        "Assumption": ["假设", "前提"],
+        "Concept": ["概念", "术语"],
+        "Case": ["案例", "case"],
+        "Pattern": ["模式", "pattern"],
+        "Date": ["日期", "时间", "时间点"],
+        "Person": ["我", "自己", "本人", "同事", "客户", "用户", "姓名", "名字", "人名", "成员", "联系人"],
+        "Project": ["项目", "工程", "项目线"],
+        "Task": ["任务", "待办", "todo", "工单", "事项"],
         "Milestone": ["里程碑", "节点"],
         "Issue": ["问题", "故障", "报错"],
         "Fix": ["修复", "解决方案"],
@@ -134,43 +158,100 @@ const DEFAULT_SCHEMA = {
     relationTypes: [
         "depends_on",
         "blocks",
-        "related_to",
+        "unblocks",
         "causes",
+        "impacts",
         "resolves",
+        "encountered_bug",
+        "solved_with",
+        "uses_tech",
+        "integrates_with",
+        "migrates_to",
+        "replaced_by",
+        "has_subtask",
+        "belongs_to",
+        "owned_by",
+        "implements",
+        "requires",
         "plans_to",
+        "planned_for",
         "scheduled_for",
+        "references",
+        "documents",
+        "defined_in",
+        "configured_in",
+        "supports",
+        "conflicts_with",
+        "duplicates",
+        "supersedes",
+        "assigned_to",
+        "reviewed_by",
+        "approved_by",
+        "rejected_by",
+        "reported_by",
         "lives_in",
         "cares_for",
         "pays_for",
-        "supports",
-        "conflicts_with",
-        "belongs_to",
-        "owned_by",
-        "references",
         "prefers",
-        "implements",
-        "requires",
+        "has_spouse",
+        "has_child",
+        "birthday_on",
+        "anniversary_on",
     ],
     relationTypeAliases: {
         dependency: "depends_on",
         blocked_by: "blocks",
-        linked_to: "related_to",
+        unblock: "unblocks",
+        impact: "impacts",
         plan_to: "plans_to",
+        plan_for: "planned_for",
         schedule_for: "scheduled_for",
         located_in: "lives_in",
         care_for: "cares_for",
         pay_for: "pays_for",
         support: "supports",
         conflict_with: "conflicts_with",
+        use_tech: "uses_tech",
+        tech_stack: "uses_tech",
+        integrate_with: "integrates_with",
+        migrate_to: "migrates_to",
+        replace_by: "replaced_by",
+        replace_with: "replaced_by",
+        bug: "encountered_bug",
+        bug_on: "encountered_bug",
+        fix_with: "solved_with",
+        solve_with: "solved_with",
+        solved_by: "solved_with",
+        subtask_of: "has_subtask",
+        child_task: "has_subtask",
+        documented_by: "documents",
+        defined_by: "defined_in",
+        config_in: "configured_in",
+        duplicate_of: "duplicates",
+        superseded_by: "supersedes",
+        assign_to: "assigned_to",
+        review_by: "reviewed_by",
+        approve_by: "approved_by",
+        reject_by: "rejected_by",
+        report_by: "reported_by",
         "依赖于": "depends_on",
         "依赖": "depends_on",
         "取决于": "depends_on",
         "阻塞": "blocks",
         "卡住": "blocks",
+        "解除阻塞": "unblocks",
         "导致": "causes",
         "引起": "causes",
+        "影响": "impacts",
         "解决": "resolves",
         "修复": "resolves",
+        "遇到报错": "encountered_bug",
+        "通过": "solved_with",
+        "使用技术": "uses_tech",
+        "集成": "integrates_with",
+        "迁移到": "migrates_to",
+        "被替代": "replaced_by",
+        "子任务": "has_subtask",
         "属于": "belongs_to",
         "归属": "belongs_to",
         "负责": "owned_by",
@@ -183,6 +264,7 @@ const DEFAULT_SCHEMA = {
         "需要": "requires",
         "计划做": "plans_to",
         "打算": "plans_to",
+        "计划于": "planned_for",
         "安排在": "scheduled_for",
         "约在": "scheduled_for",
         "住在": "lives_in",
@@ -194,14 +276,33 @@ const DEFAULT_SCHEMA = {
         "支持": "supports",
         "冲突": "conflicts_with",
         "矛盾": "conflicts_with",
-        "相关": "related_to",
-        "有关": "related_to",
+        "记录": "documents",
+        "定义于": "defined_in",
+        "配置于": "configured_in",
+        "重复": "duplicates",
+        "取代": "supersedes",
+        "分配给": "assigned_to",
+        "评审": "reviewed_by",
+        "批准": "approved_by",
+        "拒绝": "rejected_by",
+        "报告": "reported_by",
         belongs: "belongs_to",
         owner_of: "owned_by",
         refer_to: "references",
         preference_for: "prefers",
         implement: "implements",
         need: "requires",
+        technology: "uses_tech",
+        encountered_issue: "encountered_bug",
+        spouse: "has_spouse",
+        wife_of: "has_spouse",
+        husband_of: "has_spouse",
+        child_of: "has_child",
+        parent_of: "has_child",
+        birthday: "birthday_on",
+        born_on: "birthday_on",
+        anniversary: "anniversary_on",
+        married_on: "anniversary_on",
     },
     relationRules: [
         { type: "depends_on", fromTypes: ["Task", "Plan", "Milestone"], toTypes: ["Task", "Plan", "Milestone"], allowSelfLoop: false },
@@ -210,10 +311,35 @@ const DEFAULT_SCHEMA = {
         { type: "resolves", fromTypes: ["Fix", "Decision", "Action"], toTypes: ["Issue", "Blocker"], allowSelfLoop: false },
         { type: "belongs_to", fromTypes: ["Task", "Issue", "Fix", "Decision"], toTypes: ["Project", "Plan", "Milestone"], allowSelfLoop: false },
         { type: "owned_by", fromTypes: ["Task", "Plan", "Project", "Issue"], toTypes: ["Person", "Team"], allowSelfLoop: false },
+        { type: "uses_tech", fromTypes: ["Project", "Task", "Fix", "Action"], toTypes: ["Resource", "Document", "Concept", "Project"], allowSelfLoop: false },
+        { type: "encountered_bug", fromTypes: ["Project", "Task", "Action"], toTypes: ["Issue", "Blocker"], allowSelfLoop: false },
+        { type: "solved_with", fromTypes: ["Issue", "Blocker"], toTypes: ["Fix", "Action", "Decision", "Resource"], allowSelfLoop: false },
+        { type: "has_subtask", fromTypes: ["Project", "Plan", "Milestone", "Task"], toTypes: ["Task"], allowSelfLoop: false },
+        { type: "planned_for", fromTypes: ["Task", "Plan", "Milestone"], toTypes: ["Date", "Schedule", "Milestone"], allowSelfLoop: false },
     ],
-    highValueRelationTypes: ["depends_on", "blocks", "resolves", "owned_by"],
-    relatedToMaxRatio: 0.35,
-    relatedToMaxAbsolute: 2,
+    highValueRelationTypes: [
+        "depends_on",
+        "blocks",
+        "unblocks",
+        "causes",
+        "impacts",
+        "resolves",
+        "encountered_bug",
+        "solved_with",
+        "uses_tech",
+        "integrates_with",
+        "migrates_to",
+        "replaced_by",
+        "has_subtask",
+        "belongs_to",
+        "owned_by",
+        "implements",
+        "requires",
+        "planned_for",
+        "scheduled_for",
+    ],
+    relatedToMaxRatio: 0,
+    relatedToMaxAbsolute: 0,
     minRelationConfidence: 0.35,
     evidenceSpanRequired: true,
     endpointMentionRequired: true,
@@ -258,28 +384,127 @@ function sanitizeEntityAliases(input) {
     }
     return Object.keys(output).length > 0 ? output : DEFAULT_SCHEMA.entityAliases;
 }
+function normalizeAliasKey(value) {
+    return value
+        .normalize("NFKC")
+        .toLowerCase()
+        .replace(/[`"'“”‘’]/g, "")
+        .replace(/[【】[\]{}()<>]/g, " ")
+        .replace(/[_\-\/\\|]+/g, " ")
+        .replace(/[,:;!?]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function buildEntityLookupKeys(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return [];
+    }
+    const normalized = normalizeAliasKey(trimmed);
+    const compact = normalized.replace(/\s+/g, "");
+    const keys = new Set();
+    keys.add(trimmed.toLowerCase());
+    if (normalized) {
+        keys.add(normalized);
+    }
+    if (compact) {
+        keys.add(compact);
+    }
+    return [...keys];
+}
+function chooseCanonicalAlias(leftRaw, rightRaw) {
+    const left = leftRaw.trim();
+    const right = rightRaw.trim();
+    if (!left)
+        return right;
+    if (!right)
+        return left;
+    const leftAscii = /[A-Za-z]/.test(left);
+    const rightAscii = /[A-Za-z]/.test(right);
+    if (leftAscii && !rightAscii)
+        return left;
+    if (!leftAscii && rightAscii)
+        return right;
+    return left.length >= right.length ? left : right;
+}
+function buildRuntimeAliasLookup(sourceText) {
+    const lookup = new Map();
+    const text = (sourceText || "").trim();
+    if (!text) {
+        return lookup;
+    }
+    const pairPattern = /([^()\n（）]{1,80})\s*[（(]\s*([^()\n（）]{1,80})\s*[)）]/g;
+    let matched = pairPattern.exec(text);
+    while (matched) {
+        const left = (matched[1] || "").trim();
+        const right = (matched[2] || "").trim();
+        if (left && right && left !== right) {
+            const canonical = chooseCanonicalAlias(left, right);
+            const alias = canonical === left ? right : left;
+            for (const key of buildEntityLookupKeys(alias)) {
+                lookup.set(key, canonical);
+            }
+            for (const key of buildEntityLookupKeys(canonical)) {
+                lookup.set(key, canonical);
+            }
+        }
+        matched = pairPattern.exec(text);
+    }
+    return lookup;
+}
 function buildAliasLookup(schema) {
     const lookup = new Map();
     for (const [canonical, aliases] of Object.entries(schema.entityAliases || {})) {
         const normalizedCanonical = canonical.trim();
         if (!normalizedCanonical)
             continue;
-        lookup.set(normalizedCanonical.toLowerCase(), normalizedCanonical);
+        for (const key of buildEntityLookupKeys(normalizedCanonical)) {
+            lookup.set(key, normalizedCanonical);
+        }
         for (const alias of aliases || []) {
-            const normalizedAlias = alias.trim().toLowerCase();
-            if (!normalizedAlias)
-                continue;
-            lookup.set(normalizedAlias, normalizedCanonical);
+            for (const key of buildEntityLookupKeys(alias)) {
+                lookup.set(key, normalizedCanonical);
+            }
         }
     }
     return lookup;
 }
-function normalizeEntityName(raw, schema) {
+function normalizeEntityName(raw, schema, runtimeAliasLookup) {
     const value = raw.trim();
     if (!value)
         return "";
     const lookup = buildAliasLookup(schema);
-    return lookup.get(value.toLowerCase()) || value;
+    for (const key of buildEntityLookupKeys(value)) {
+        const runtimeMapped = runtimeAliasLookup?.get(key);
+        if (runtimeMapped) {
+            return runtimeMapped;
+        }
+        const schemaMapped = lookup.get(key);
+        if (schemaMapped) {
+            return schemaMapped;
+        }
+    }
+    return value;
+}
+function getEntityMatchKeys(raw, schema) {
+    const value = raw.trim();
+    if (!value) {
+        return [];
+    }
+    const canonical = normalizeEntityName(value, schema);
+    const keys = new Set();
+    for (const key of buildEntityLookupKeys(value)) {
+        keys.add(key);
+    }
+    for (const key of buildEntityLookupKeys(canonical)) {
+        keys.add(key);
+    }
+    for (const alias of schema.entityAliases[canonical] || []) {
+        for (const key of buildEntityLookupKeys(alias)) {
+            keys.add(key);
+        }
+    }
+    return [...keys];
 }
 function tokenizeForMatch(value) {
     return value.toLowerCase().replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim();
@@ -288,11 +513,12 @@ function entityMentionedInText(entity, sourceText, schema) {
     const text = tokenizeForMatch(sourceText || "");
     if (!text)
         return false;
-    const target = tokenizeForMatch(entity);
+    const canonical = normalizeEntityName(entity, schema);
+    const target = tokenizeForMatch(canonical || entity);
     if (target && text.includes(target)) {
         return true;
     }
-    const aliases = schema.entityAliases[entity] || [];
+    const aliases = schema.entityAliases[canonical] || [];
     for (const alias of aliases) {
         const normalized = tokenizeForMatch(alias);
         if (normalized && text.includes(normalized)) {
@@ -352,6 +578,9 @@ function normalizeEventType(raw, schema) {
 }
 function normalizeRelationType(raw, schema) {
     const value = raw.trim().toLowerCase();
+    if (!value) {
+        return "";
+    }
     const relationTypes = new Set(schema.relationTypes.map(item => item.toLowerCase()));
     const aliases = toLowerMap(schema.relationTypeAliases);
     if (relationTypes.has(value)) {
@@ -361,7 +590,346 @@ function normalizeRelationType(raw, schema) {
     if (mapped) {
         return mapped;
     }
-    return "related_to";
+    const snakeCase = value.replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+    if (/^[a-z][a-z0-9_]*$/.test(snakeCase)) {
+        return snakeCase;
+    }
+    return "";
+}
+function isCanonicalRelationType(type, schema) {
+    const value = type.trim().toLowerCase();
+    if (!value) {
+        return false;
+    }
+    const relationTypes = new Set(schema.relationTypes.map(item => item.toLowerCase()));
+    return relationTypes.has(value);
+}
+function getDefaultGraphSchema() {
+    return DEFAULT_SCHEMA;
+}
+function buildRelationPromptHint(schema) {
+    return [
+        `Allowed canonical relation types: ${schema.relationTypes.join(", ")}.`,
+        "Never use related_to.",
+        "If no canonical relation fits, create a snake_case custom relation, set relation_origin=llm_custom, and include relation_definition.",
+    ].join(" ");
+}
+const GENERIC_ENTITY_BLOCKLIST = new Set([
+    "用户",
+    "我",
+    "我们",
+    "你",
+    "你们",
+    "他",
+    "她",
+    "他们",
+    "问题",
+    "方案",
+    "实体",
+    "系统",
+    "task",
+    "issue",
+    "solution",
+    "system",
+    "person",
+    "user",
+    "thing",
+]);
+function isGenericEntityName(raw) {
+    const value = normalizeAliasKey(String(raw || ""));
+    return value ? GENERIC_ENTITY_BLOCKLIST.has(value) : false;
+}
+function collectEntitiesFromRelations(relations, schema, runtimeAliasLookup) {
+    const output = new Set();
+    for (const relation of relations) {
+        const source = normalizeEntityName(relation.source || "", schema, runtimeAliasLookup);
+        const target = normalizeEntityName(relation.target || "", schema, runtimeAliasLookup);
+        if (source)
+            output.add(source);
+        if (target)
+            output.add(target);
+    }
+    return [...output];
+}
+function extractResourceReferences(sourceText) {
+    const text = (sourceText || "").trim();
+    if (!text) {
+        return [];
+    }
+    const output = new Set();
+    const urlMatches = text.match(/https?:\/\/[^\s)>"'`]+|www\.[^\s)>"'`]+/gi) || [];
+    const normalizedUrls = urlMatches.map(item => item.trim()).filter(Boolean);
+    for (const item of urlMatches) {
+        output.add(item.trim());
+    }
+    const pathMatches = text.match(/[A-Za-z]:\\[^\s"']+|(?:\.{0,2}\/)?(?:[\w.-]+\/)+[\w.-]+\.[A-Za-z0-9]{1,12}/g) || [];
+    for (const item of pathMatches) {
+        const value = item.trim();
+        const compact = value.replace(/^\.\/+/, "").replace(/^\/+/, "");
+        const coveredByUrl = normalizedUrls.some(url => url.includes(value) || (compact && url.includes(compact)));
+        if (coveredByUrl) {
+            continue;
+        }
+        if (value.length >= 4) {
+            output.add(value);
+        }
+    }
+    return [...output].slice(0, 12);
+}
+function inferEntityTypeFromName(entity, schema) {
+    const valid = new Set(schema.entityTypes);
+    const value = entity.trim();
+    if (!value) {
+        return schema.defaultEntityType;
+    }
+    if (valid.has("Date") && /(?:\d{4}-\d{2}-\d{2}|\d{1,2}月\d{1,2}日|\d{1,2}[/-]\d{1,2})/.test(value)) {
+        return "Date";
+    }
+    if (valid.has("Resource") && /^(https?:\/\/|www\.)/i.test(value)) {
+        return "Resource";
+    }
+    if (valid.has("Document")
+        && (/([/\\].+\.[A-Za-z0-9]{1,12})$/.test(value) || /\.(md|txt|pdf|docx?|pptx?|xlsx?|json|yaml|yml|xml|html?)$/i.test(value))) {
+        return "Document";
+    }
+    if (valid.has("Team") && /(team|org|organization|团队|组织|公司)/i.test(value)) {
+        return "Team";
+    }
+    if (valid.has("Project") && /(project|repo|仓库|项目|工程)/i.test(value)) {
+        return "Project";
+    }
+    return schema.defaultEntityType;
+}
+function inferEvidenceSpanFromSource(sourceText, candidates) {
+    const text = (sourceText || "").trim();
+    if (!text) {
+        return undefined;
+    }
+    const normalizedText = tokenizeForMatch(text);
+    const uniqueCandidates = [...new Set(candidates.map(item => item.trim()).filter(Boolean))]
+        .sort((a, b) => b.length - a.length);
+    for (const candidate of uniqueCandidates) {
+        const normalized = tokenizeForMatch(candidate);
+        if (normalized && normalizedText.includes(normalized)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function inferContextChunkFromSource(sourceText, anchors) {
+    const text = (sourceText || "").trim().replace(/\s+/g, " ");
+    if (!text)
+        return undefined;
+    const normalizedAnchors = anchors.map(item => String(item || "").trim()).filter(Boolean);
+    let hitIndex = -1;
+    let hitAnchor = "";
+    for (const anchor of normalizedAnchors) {
+        const idx = text.indexOf(anchor);
+        if (idx >= 0) {
+            hitIndex = idx;
+            hitAnchor = anchor;
+            break;
+        }
+    }
+    if (hitIndex < 0) {
+        const fallback = text.slice(0, Math.min(text.length, 100)).trim();
+        return fallback || undefined;
+    }
+    const targetLength = 80;
+    const minLength = 50;
+    const maxLength = 120;
+    let start = Math.max(0, hitIndex - Math.floor((targetLength - hitAnchor.length) / 2));
+    let end = Math.min(text.length, start + targetLength);
+    if ((end - start) < minLength) {
+        end = Math.min(text.length, start + minLength);
+    }
+    if ((end - start) > maxLength) {
+        end = start + maxLength;
+    }
+    if (end >= text.length && (end - start) < minLength) {
+        start = Math.max(0, end - minLength);
+    }
+    const chunk = text.slice(start, end).trim();
+    return chunk || undefined;
+}
+function summaryMentionsEntity(summary, entity, schema, runtimeAliasLookup) {
+    const normalizedSummary = tokenizeForMatch(summary || "");
+    if (!normalizedSummary) {
+        return false;
+    }
+    const canonical = normalizeEntityName(entity, schema, runtimeAliasLookup);
+    const candidates = new Set([
+        entity,
+        canonical,
+        ...(schema.entityAliases[canonical] || []),
+    ]);
+    for (const candidateRaw of candidates) {
+        const candidate = tokenizeForMatch(candidateRaw || "");
+        if (candidate && normalizedSummary.includes(candidate)) {
+            return true;
+        }
+    }
+    return false;
+}
+function missingEntitiesInSummary(args) {
+    const missing = [];
+    for (const entity of args.entities) {
+        if (!summaryMentionsEntity(args.summary, entity, args.schema, args.runtimeAliasLookup)) {
+            missing.push(entity);
+        }
+    }
+    return missing;
+}
+function normalizeSourceTextNav(args) {
+    const nav = args.sourceTextNav || {};
+    const layerRaw = typeof nav.layer === "string" ? nav.layer.trim() : "";
+    const layer = layerRaw === "archive_event" || layerRaw === "active_only"
+        ? layerRaw
+        : args.sourceLayer;
+    const sourceEventId = (typeof nav.source_event_id === "string" ? nav.source_event_id : "").trim()
+        || args.sourceEventId.trim()
+        || (typeof args.archiveEventId === "string" ? args.archiveEventId.trim() : "");
+    const sourceMemoryId = (typeof nav.source_memory_id === "string" ? nav.source_memory_id : "").trim()
+        || sourceEventId;
+    const sessionId = (typeof nav.session_id === "string" ? nav.session_id : "").trim()
+        || args.sessionId.trim();
+    const sourceFile = (typeof nav.source_file === "string" ? nav.source_file : "").trim()
+        || (typeof args.sourceFile === "string" ? args.sourceFile.trim() : "");
+    const fulltextAnchor = typeof nav.fulltext_anchor === "string" ? nav.fulltext_anchor.trim() : "";
+    if (!layer || !sessionId || !sourceFile || !sourceEventId || !sourceMemoryId) {
+        return null;
+    }
+    return {
+        layer,
+        session_id: sessionId,
+        source_file: sourceFile,
+        source_memory_id: sourceMemoryId,
+        source_event_id: sourceEventId,
+        fulltext_anchor: fulltextAnchor || undefined,
+    };
+}
+function shouldRetryWithFallbackRelations(rejectedReasons) {
+    const hardStopReasons = new Set([
+        "missing_relation_confidence",
+        "missing_evidence_span",
+        "low_relation_confidence",
+        "empty_edge",
+    ]);
+    for (const reason of rejectedReasons) {
+        if (hardStopReasons.has(reason)) {
+            return false;
+        }
+    }
+    return true;
+}
+function buildFallbackRelations(args) {
+    const output = [];
+    const dedupe = new Set();
+    const entitySet = new Set(args.entities);
+    const sourceText = (args.sourceText || "").trim();
+    const fallbackConfidence = Math.max(args.schema.minRelationConfidence + 0.05, 0.55);
+    const pushRelation = (relation) => {
+        const source = normalizeEntityName(relation.source || "", args.schema, args.runtimeAliasLookup);
+        const target = normalizeEntityName(relation.target || "", args.schema, args.runtimeAliasLookup);
+        const type = normalizeRelationType(relation.type || "", args.schema);
+        const isCanonical = isCanonicalRelationType(type, args.schema);
+        const relationOrigin = relation.relation_origin || (isCanonical ? "canonical" : "llm_custom");
+        const relationDefinition = typeof relation.relation_definition === "string" ? relation.relation_definition.trim() : "";
+        const evidenceSpan = typeof relation.evidence_span === "string" ? relation.evidence_span.trim() : "";
+        const contextChunkRaw = typeof relation.context_chunk === "string" ? relation.context_chunk.trim() : "";
+        const contextChunk = contextChunkRaw || inferContextChunkFromSource(sourceText, [evidenceSpan, source, target].filter(Boolean));
+        const confidence = typeof relation.confidence === "number"
+            ? Math.max(0, Math.min(1, relation.confidence))
+            : fallbackConfidence;
+        if (!source || !target || source === target)
+            return;
+        if (!entitySet.has(source) || !entitySet.has(target))
+            return;
+        if (!type || type === "related_to")
+            return;
+        if (relationOrigin === "llm_custom" && !relationDefinition)
+            return;
+        if (!evidenceSpan)
+            return;
+        const key = `${source}|${type}|${target}`;
+        if (dedupe.has(key))
+            return;
+        dedupe.add(key);
+        output.push({
+            source,
+            target,
+            type,
+            relation_origin: relationOrigin,
+            relation_definition: relationDefinition || undefined,
+            mapping_hint: typeof relation.mapping_hint === "string" ? relation.mapping_hint.trim() || undefined : undefined,
+            evidence_span: evidenceSpan,
+            context_chunk: contextChunk,
+            confidence,
+        });
+    };
+    for (const relation of args.relations) {
+        const sourceRaw = (relation.source || "").trim();
+        const targetRaw = (relation.target || "").trim();
+        const evidence = (typeof relation.evidence_span === "string" && relation.evidence_span.trim())
+            || inferEvidenceSpanFromSource(sourceText, [sourceRaw, targetRaw])
+            || "";
+        pushRelation({
+            source: sourceRaw,
+            target: targetRaw,
+            type: relation.type || "",
+            relation_origin: relation.relation_origin,
+            relation_definition: relation.relation_definition,
+            mapping_hint: relation.mapping_hint,
+            evidence_span: evidence,
+            context_chunk: inferContextChunkFromSource(sourceText, [evidence, sourceRaw, targetRaw].filter(Boolean)),
+            confidence: typeof relation.confidence === "number" ? relation.confidence : fallbackConfidence,
+        });
+    }
+    if (output.length === 0) {
+        const resources = args.entities.filter(entity => {
+            const type = (args.entityTypes[entity] || "").trim();
+            return type === "Resource" || type === "Document";
+        });
+        const anchors = args.entities.filter(entity => !resources.includes(entity) && (args.entityTypes[entity] || "").trim() !== "Date");
+        const anchor = anchors[0];
+        if (anchor) {
+            for (const resource of resources.slice(0, 3)) {
+                const evidence = inferEvidenceSpanFromSource(sourceText, [resource, anchor]) || "";
+                pushRelation({
+                    source: anchor,
+                    target: resource,
+                    type: "references",
+                    evidence_span: evidence,
+                    context_chunk: inferContextChunkFromSource(sourceText, [evidence, anchor, resource].filter(Boolean)),
+                    confidence: fallbackConfidence,
+                });
+            }
+        }
+    }
+    if (output.length === 0) {
+        const nonDateEntities = args.entities.filter(entity => (args.entityTypes[entity] || "").trim() !== "Date");
+        if (nonDateEntities.length >= 2) {
+            const source = nonDateEntities[0];
+            for (const target of nonDateEntities.slice(1)) {
+                const evidence = inferEvidenceSpanFromSource(sourceText, [source, target]) || "";
+                pushRelation({
+                    source,
+                    target,
+                    type: "co_occurs_with",
+                    relation_origin: "llm_custom",
+                    relation_definition: "Source and target are explicitly co-mentioned within the same source chunk.",
+                    mapping_hint: "references",
+                    evidence_span: evidence,
+                    context_chunk: inferContextChunkFromSource(sourceText, [evidence, source, target].filter(Boolean)),
+                    confidence: fallbackConfidence,
+                });
+                if (output.length > 0) {
+                    break;
+                }
+            }
+        }
+    }
+    return output;
 }
 function buildCanonicalId(args) {
     const entities = (args.entities || []).map(item => item.trim().toLowerCase()).filter(Boolean).sort();
@@ -382,32 +950,78 @@ function validateRelations(args) {
     const accepted = [];
     const rejected = [];
     const warnings = [];
-    const entitySet = new Set(args.entities.map(item => item.trim()).filter(Boolean));
+    const runtimeAliasLookup = args.runtimeAliasLookup || new Map();
+    const normalizedSourceText = (args.sourceText || "").trim().replace(/\s+/g, " ");
+    const entitySet = new Set(args.entities
+        .map(item => normalizeEntityName(item, args.schema, runtimeAliasLookup))
+        .filter(Boolean));
     const rules = toKeyedRules(args.schema.relationRules);
     const typeMap = {};
     for (const [name, type] of Object.entries(args.entityTypes || {})) {
         if (typeof name === "string" && typeof type === "string" && name.trim() && type.trim()) {
-            typeMap[name.trim()] = type.trim();
+            const normalizedName = normalizeEntityName(name, args.schema, runtimeAliasLookup);
+            if (normalizedName) {
+                typeMap[normalizedName] = type.trim();
+            }
         }
     }
     for (const relation of args.relations) {
-        const source = normalizeEntityName(relation.source || "", args.schema);
-        const target = normalizeEntityName(relation.target || "", args.schema);
+        const source = normalizeEntityName(relation.source || "", args.schema, runtimeAliasLookup);
+        const target = normalizeEntityName(relation.target || "", args.schema, runtimeAliasLookup);
         const type = normalizeRelationType(relation.type, args.schema);
+        const typeIsCanonical = isCanonicalRelationType(type, args.schema);
+        const relationOriginRaw = typeof relation.relation_origin === "string" ? relation.relation_origin.trim() : "";
+        const relationOrigin = relationOriginRaw === "canonical" || relationOriginRaw === "llm_custom"
+            ? relationOriginRaw
+            : (typeIsCanonical ? "canonical" : "llm_custom");
+        const relationDefinition = typeof relation.relation_definition === "string" ? relation.relation_definition.trim() : "";
+        const mappingHint = typeof relation.mapping_hint === "string" ? relation.mapping_hint.trim() : "";
         const confidence = typeof relation.confidence === "number"
             ? Math.max(0, Math.min(1, relation.confidence))
             : undefined;
         const evidenceSpan = typeof relation.evidence_span === "string" ? relation.evidence_span.trim() : "";
-        const normalized = { source, target, type, confidence, evidence_span: evidenceSpan || undefined };
+        const contextChunkRaw = typeof relation.context_chunk === "string" ? relation.context_chunk.trim() : "";
+        const contextChunk = contextChunkRaw || inferContextChunkFromSource(normalizedSourceText, [evidenceSpan, source, target].filter(Boolean));
+        const normalized = {
+            source,
+            target,
+            type,
+            relation_origin: relationOrigin,
+            relation_definition: relationDefinition || undefined,
+            mapping_hint: mappingHint || undefined,
+            confidence,
+            evidence_span: evidenceSpan || undefined,
+            context_chunk: contextChunk || undefined,
+        };
         if (!source || !target) {
             rejected.push({ reason: "empty_edge", relation: normalized });
             continue;
         }
+        if (!type) {
+            rejected.push({ reason: "invalid_relation_type", relation: normalized });
+            continue;
+        }
+        if (type === "related_to") {
+            rejected.push({ reason: "related_to_detected", relation: normalized });
+            continue;
+        }
+        if (relationOrigin === "canonical" && !typeIsCanonical) {
+            rejected.push({ reason: "relation_origin_mismatch", relation: normalized });
+            continue;
+        }
+        if (relationOrigin === "llm_custom" && typeIsCanonical) {
+            rejected.push({ reason: "relation_origin_mismatch", relation: normalized });
+            continue;
+        }
+        if (relationOrigin === "llm_custom" && !relationDefinition) {
+            rejected.push({ reason: "llm_custom_missing_definition", relation: normalized });
+            continue;
+        }
         if (!entitySet.has(source) || !entitySet.has(target)) {
             rejected.push({ reason: "edge_entity_missing", relation: normalized });
             continue;
         }
-        const rule = rules.get(type);
+        const rule = typeIsCanonical ? rules.get(type) : undefined;
         if (source === target && !(rule?.allowSelfLoop ?? false)) {
             rejected.push({ reason: "self_loop_blocked", relation: normalized });
             continue;
@@ -430,15 +1044,16 @@ function validateRelations(args) {
             rejected.push({ reason: "low_relation_confidence", relation: normalized });
             continue;
         }
+        if (typeof confidence !== "number") {
+            rejected.push({ reason: "missing_relation_confidence", relation: normalized });
+            continue;
+        }
+        if (args.schema.evidenceSpanRequired && !evidenceSpan) {
+            rejected.push({ reason: "missing_evidence_span", relation: normalized });
+            continue;
+        }
         if (mode !== "off" && args.schema.evidenceSpanRequired && args.sourceText) {
-            if (!evidenceSpan) {
-                if (mode === "strict") {
-                    rejected.push({ reason: "missing_evidence_span", relation: normalized });
-                    continue;
-                }
-                warnings.push({ reason: "missing_evidence_span", relation: normalized });
-            }
-            else if (!tokenizeForMatch(args.sourceText).includes(tokenizeForMatch(evidenceSpan))) {
+            if (evidenceSpan && !tokenizeForMatch(args.sourceText).includes(tokenizeForMatch(evidenceSpan))) {
                 if (mode === "strict") {
                     rejected.push({ reason: "evidence_span_not_in_source", relation: normalized });
                     continue;
@@ -446,6 +1061,20 @@ function validateRelations(args) {
                 warnings.push({ reason: "evidence_span_not_in_source", relation: normalized });
             }
         }
+        if (mode !== "off") {
+            if (!contextChunk) {
+                warnings.push({ reason: "missing_context_chunk", relation: normalized });
+            }
+            else {
+                const length = contextChunk.length;
+                if (length < 50 || length > 120) {
+                    warnings.push({ reason: "context_chunk_length_out_of_range", relation: normalized });
+                }
+                if (normalizedSourceText && !normalizedSourceText.includes(contextChunk)) {
+                    warnings.push({ reason: "context_chunk_not_in_source", relation: normalized });
+                }
+            }
+        }
         if (mode !== "off" && args.schema.endpointMentionRequired && args.sourceText) {
             const sourceHit = entityMentionedInText(source, args.sourceText, args.schema);
             const targetHit = entityMentionedInText(target, args.sourceText, args.schema);
@@ -459,27 +1088,6 @@ function validateRelations(args) {
         }
         accepted.push(normalized);
     }
-    if (accepted.length > 0) {
-        const highValueSet = new Set((args.schema.highValueRelationTypes || []).map(item => item.toLowerCase()));
-        const relatedTo = accepted.filter(item => item.type === "related_to");
-        const highValueCount = accepted.filter(item => highValueSet.has(item.type)).length;
-        const maxByRatio = Math.max(1, Math.ceil(Math.max(1, highValueCount) * args.schema.relatedToMaxRatio));
-        const maxAllowed = Math.max(0, Math.min(args.schema.relatedToMaxAbsolute, maxByRatio));
-        if (relatedTo.length > maxAllowed) {
-            const sorted = [...relatedTo].sort((a, b) => (b.confidence || 0.5) - (a.confidence || 0.5));
-            const keepSet = new Set(sorted.slice(0, maxAllowed).map(item => `${item.source}|${item.type}|${item.target}`));
-            const filtered = accepted.filter(item => item.type !== "related_to" || keepSet.has(`${item.source}|${item.type}|${item.target}`));
-            if (filtered.length !== accepted.length) {
-                for (const item of accepted) {
-                    if (item.type === "related_to" && !keepSet.has(`${item.source}|${item.type}|${item.target}`)) {
-                        rejected.push({ reason: "related_to_throttled", relation: item });
-                    }
-                }
-            }
-            accepted.length = 0;
-            accepted.push(...filtered);
-        }
-    }
     return { accepted, rejected, warnings };
 }
 function normalizeEntityType(raw, schema) {
@@ -495,20 +1103,50 @@ function validateGraphPayload(args) {
     if (!sourceEventId) {
         return { valid: false, reason: "source_event_id_empty" };
     }
-    const entities = Array.isArray(args.entities)
-        ? [...new Set(args.entities.map(item => normalizeEntityName(typeof item === "string" ? item : "", args.schema)).filter(Boolean))]
+    const summary = typeof args.summary === "string" ? args.summary.trim() : "";
+    if (!summary) {
+        return { valid: false, reason: "missing_summary" };
+    }
+    const sourceTextNav = normalizeSourceTextNav({
+        sourceTextNav: args.source_text_nav,
+        sourceLayer: args.sourceLayer,
+        sourceEventId,
+        archiveEventId: args.archiveEventId,
+        sessionId: args.sessionId,
+        sourceFile: args.sourceFile,
+    });
+    if (!sourceTextNav) {
+        return { valid: false, reason: "fulltext_navigation_missing" };
+    }
+    const baseWarnings = [];
+    const runtimeAliasLookup = buildRuntimeAliasLookup(args.sourceText);
+    const normalizedInputEntities = Array.isArray(args.entities)
+        ? args.entities
+            .map(item => normalizeEntityName(typeof item === "string" ? item : "", args.schema, runtimeAliasLookup))
+            .filter(Boolean)
         : [];
+    const relationEndpoints = collectEntitiesFromRelations(Array.isArray(args.relations) ? args.relations : [], args.schema, runtimeAliasLookup);
+    const resourceEntities = extractResourceReferences(args.sourceText)
+        .map(item => normalizeEntityName(item, args.schema, runtimeAliasLookup))
+        .filter(Boolean);
+    const dedupedEntities = [...new Set([...normalizedInputEntities, ...relationEndpoints, ...resourceEntities])];
+    const entities = dedupedEntities.filter(entity => !isGenericEntityName(entity));
+    if (entities.length !== dedupedEntities.length) {
+        baseWarnings.push("generic_entity_rejected");
+    }
     if (entities.length === 0) {
         return { valid: false, reason: "entities_empty" };
     }
+    if (missingEntitiesInSummary({ summary, entities, schema: args.schema, runtimeAliasLookup }).length > 0) {
+        return { valid: false, reason: "summary_missing_entities" };
+    }
     const entityTypes = args.entity_types || {};
     const validEntityTypes = new Set(args.schema.entityTypes);
     const normalizedEntityTypes = {};
-    const aliasLookup = buildAliasLookup(args.schema);
     for (const [nameRaw, typeRaw] of Object.entries(entityTypes)) {
         if (typeof typeRaw !== "string")
             continue;
-        const normalizedName = aliasLookup.get(nameRaw.trim().toLowerCase()) || nameRaw.trim();
+        const normalizedName = normalizeEntityName(nameRaw.trim(), args.schema, runtimeAliasLookup);
         if (!normalizedName)
             continue;
         normalizedEntityTypes[normalizedName] = typeRaw.trim();
@@ -519,7 +1157,7 @@ function validateGraphPayload(args) {
             normalizedEntityTypes[entity] = providedType;
         }
         else {
-            return { valid: false, reason: `entity_type_missing_or_invalid:${entity}` };
+            normalizedEntityTypes[entity] = inferEntityTypeFromName(entity, args.schema);
         }
     }
     const relationValidation = validateRelations({
@@ -529,16 +1167,51 @@ function validateGraphPayload(args) {
         schema: args.schema,
         sourceText: args.sourceText,
         qualityMode: args.qualityMode,
+        runtimeAliasLookup,
     });
-    if (relationValidation.accepted.length === 0) {
+    let acceptedRelations = relationValidation.accepted;
+    const warnings = [...baseWarnings, ...relationValidation.warnings.map(item => item.reason)];
+    if (acceptedRelations.length === 0) {
+        const rejectedReasons = new Set(relationValidation.rejected.map(item => item.reason));
+        if (!shouldRetryWithFallbackRelations(rejectedReasons)) {
+            return { valid: false, reason: "relations_empty_or_invalid" };
+        }
+        const fallbackRelations = buildFallbackRelations({
+            entities,
+            entityTypes: normalizedEntityTypes,
+            relations: Array.isArray(args.relations) ? args.relations : [],
+            sourceText: args.sourceText,
+            schema: args.schema,
+            runtimeAliasLookup,
+        });
+        if (fallbackRelations.length > 0) {
+            const fallbackValidation = validateRelations({
+                relations: fallbackRelations,
+                entities,
+                entityTypes: normalizedEntityTypes,
+                schema: args.schema,
+                sourceText: args.sourceText,
+                qualityMode: args.qualityMode,
+                runtimeAliasLookup,
+            });
+            if (fallbackValidation.accepted.length > 0) {
+                acceptedRelations = fallbackValidation.accepted;
+                warnings.push("fallback_relations_applied");
+                warnings.push(...fallbackValidation.warnings.map(item => item.reason));
+            }
+        }
+    }
+    if (acceptedRelations.length === 0) {
         return { valid: false, reason: "relations_empty_or_invalid" };
     }
     const id = `gph_${Date.now().toString(36)}_${crypto.randomBytes(4).toString("hex")}`;
     return {
         valid: true,
-        warnings: relationValidation.warnings.map(item => item.reason),
+        warnings: [...new Set(warnings)],
         normalized: {
             id,
+            summary,
+            source_text_nav: sourceTextNav,
             source_event_id: args.sourceEventId.trim(),
             source_layer: args.sourceLayer,
             archive_event_id: typeof args.archiveEventId === "string" && args.archiveEventId.trim()
@@ -551,7 +1224,7 @@ function validateGraphPayload(args) {
             timestamp: new Date().toISOString(),
             entities,
             entity_types: normalizedEntityTypes,
-            relations: relationValidation.accepted,
+            relations: acceptedRelations,
             gate_source: args.gateSource,
             event_type: typeof args.eventType === "string" && args.eventType.trim()
                 ? normalizeEventType(args.eventType, args.schema)