World's first open-source enterprise world model.
Rust agent-memorybitemporalgraphragknowledge-baseknowledge-graphllmontologypgvectorpostgresqlragrustself-hostedsemantic-searchtemporal-knowledge-graphworld-model
An amount outlives adoption (#602)
WaylandYang367e95c4846f
diff --git a/crates/utopia-extract/src/lib.rs b/crates/utopia-extract/src/lib.rsindex f596f7de..337666ad 100644--- a/crates/utopia-extract/src/lib.rs+++ b/crates/utopia-extract/src/lib.rs@@ -309,7 +309,7 @@ pub fn build_messages(units and all. **A stated figure left out is the loss that costs most**: the reader \came for those numbers, and no later step can recover one that was never written \down.\n\- 8c. A listed relation followed by {{…}} can carry those **qualifiers on the edge**: when the same sentence gives both the other entity and a figure for it — an amount, a stake, a price, a share count — write the relation with its \"object\" and put the figure in \"qualifiers\" keyed exactly as listed, **as written in the text, currency and all** (\"€30 million\", \"15亿元人民币\", never a bare number): {{\"subject\":\"Vega Capital\",\"predicate\":\"invested_in\",\"object\":\"Northwind\", \"qualifiers\":{{\"amount\":\"$5 billion\"}},…}}. Never invent a key that is not listed for that relation, and never drop the figure to keep the edge — a relation without its amount is half the sentence.+ 8c. A listed relation followed by {{…}} can carry those **qualifiers on the edge**: when the same sentence gives both the other entity and a figure for it — an amount, a stake, a price, a share count — write the relation with its \"object\" and put the figure in \"qualifiers\" keyed exactly as listed, **as written in the text, currency and all** (\"€30 million\", \"15亿元人民币\", never a bare number): {{\"subject\":\"Vega Capital\",\"predicate\":\"invested_in\",\"object\":\"Northwind\", \"qualifiers\":{{\"amount\":\"$5 billion\"}},…}}. Never invent a key that is not listed for that relation, and never drop the figure to keep the edge — a relation without its amount is half the sentence. A relation you name after the text (rule 8) carries its figure the same way — keyed by the listed attribute that fits it, or by the plainest word for it (\"amount\", \"stake\", \"price\") when none does.8b. A **listed** relation also takes \"value\" when what the text gives is a \string rather than another entity — a job title, a designation, a ticker, a \model number. Never invent an entity for a string. And when the text introduces \diff --git a/crates/utopia-server/src/extraction.rs b/crates/utopia-server/src/extraction.rsindex d6bcba60..2244e177 100644--- a/crates/utopia-server/src/extraction.rs+++ b/crates/utopia-server/src/extraction.rs@@ -1492,8 +1492,10 @@ async fn run(state: &AppState, document_id: Uuid, proposer: Proposer) -> anyhow:continue;};let mut object_value = serde_json::json!({ "value": normalized });- if let Some(u) = attr.unit.as_deref().filter(|u| !u.is_empty()) {- // 单位随事实落笔:类型上的单位以后改了,旧值仍按记录时的单位读+ // 单位随事实落笔:类型上的单位以后改了,旧值仍按记录时的单位读。+ // 记哪个单位照 `unit_for`——从前这里无条件盖上声明的单位,实测+ //「提供 500 兆瓦的风电」被模型记成金额,再盖上 ¥ 就成了 500 块钱+ if let Some(u) = unit_for(&raw, datatype, None, attr.unit.as_deref()) {object_value["unit"] = serde_json::json!(u);}if await_nod {@@ -2304,10 +2306,16 @@ async fn run(state: &AppState, document_id: Uuid, proposer: Proposer) -> anyhow:同一条边再听到一次带了金额的,是同一条边补上金额。值照 datatype 换算,单位另记一格(与 object_value 同形);key 不在声明里、换不动、与已记的不一致——三种都进丢弃表,不静默 */- if let (Some(pid), Some(quals)) = (predicate_id, f.qualifiers.as_ref()) {+ /* 谓词未知(0010,说法在证据上)时属性照写:值落在事实上,声明等+ 关系被采纳时在 `adopt` 里补。不写的话,`invested_in` 在 schema.org+ 库里是未知说法,一句话里的 $1.5 billion 就没有地方放——召回台上+ `oh-invest` 那一条正是这么丢的 */+ if let Some(quals) = f.qualifiers.as_ref() {+ let pid = predicate_id;// 克隆出这一组引用:下面撞上已有属性时要往 qualifier_defs 里追加声明- let defs: Vec<&utopia_core::models::RelationType> =- qualifier_defs.get(&pid).cloned().unwrap_or_default();+ let defs: Vec<&utopia_core::models::RelationType> = pid+ .and_then(|p| qualifier_defs.get(&p).cloned())+ .unwrap_or_default();/* 模型常把币种单独写成一个键(`"amount": "1500000000", "currency": "CNY"`),而不是写进数额里。那不是一个属性,是数额的单位——先把它拿出来,数值属性解不出单位时用它,别让它作为未知 key 进丢弃表 */@@ -2343,9 +2351,16 @@ async fn run(state: &AppState, document_id: Uuid, proposer: Proposer) -> anyhow:所以跟自动扩本体走同一个开关 */let adopted = match declared {Some(d) => Some(d),+ /* 谓词还未知(0010,说法在证据上):没有关系可声明,值绑到库里+ 已有的属性定义、先落在事实上,采纳时 `adopt` 再补声明。这一步+ 不动本体,所以不看自动扩本体的开关 */+ None if pid.is_none() => {+ attr_by_key.get(&key.trim().to_lowercase()).copied()+ }None if kb.auto_extend_ontology => {match attr_by_key.get(&key.trim().to_lowercase()).copied() {Some(attr) => {+ let pid = pid.expect("checked above");match utopia_store::ontology::add_relation_qualifier(&state.pool,doc.kb_id,@@ -2377,15 +2392,50 @@ async fn run(state: &AppState, document_id: Uuid, proposer: Proposer) -> anyhow:}};let Some(def) = adopted else {- drop_signal(- state,+ /* **绑不上属性定义的数也不丢。** 库里没有这个属性(schema.org 里+ `amount` 是关系不是属性)、或本体冻着不让扩——从前这里进丢弃表,+ 数就只剩丢弃表里的一个样例。现在照 8a 的样子落成主语上的一条+ 字面值事实:值按原文、单位另记一格、原词 `关系.键` 进证据的+ proposed_predicate,缺的定义记进 ontology_misses(0010 的样子),+ 采纳时人来决定它归哪儿。图里有它、有证据、能查到 */+ let wording = format!("{}.{}", f.predicate.trim(), key.trim());+ let unit = raw+ .as_str()+ .and_then(utopia_extract::parse_leading_quantity)+ .and_then(|(_, u)| u)+ .or_else(|| sibling_currency.map(str::to_string));+ let mut literal = serde_json::json!({ "value": raw });+ if let Some(u) = unit {+ literal["unit"] = serde_json::Value::String(u);+ }+ let _ = utopia_store::ontology::record_miss(+ &state.pool,doc.kb_id,- document_id,- utopia_store::extraction_drops::reason::QUALIFIER_UNKNOWN,- &format!("{}.{}", f.predicate, key),- Some(&raw.to_string()),+ "attribute_type",+ &wording,+ Some(&format!("{} → {raw}", f.subject.trim())),).await;+ let (literal_id, _) = utopia_store::graph::insert_value_fact(+ &state.pool,+ doc.kb_id,+ subject_id,+ None,+ &literal,+ validity,+ confidence,+ )+ .await?;+ touched_facts.push(literal_id);+ utopia_store::graph::add_evidence(+ &state.pool,+ literal_id,+ chunk.id,+ f.quote.as_deref(),+ Some(wording.as_str()),+ )+ .await?;+ tracing::debug!(kb_id = %doc.kb_id, wording = %wording, "边上的属性绑不上定义,落成主语上的字面值");continue;};let dt = def.datatype.as_deref().unwrap_or("text");@@ -2402,28 +2452,7 @@ async fn run(state: &AppState, document_id: Uuid, proposer: Proposer) -> anyhow:continue;};let mut value = serde_json::json!({ "value": normalized });- /* 单位:原文里认得出的用原文的(€、¥、%),原文里**没有任何单位记号**- 才落回属性声明的缺省。原文带着一个认不出的单位("francs")时- **不能**拿缺省顶上——实测 `EUR 30 million` 被存成了 `$`,- `15亿元人民币` 也是;币种写错比不写更糟 */- let parsed = raw- .as_str()- .and_then(utopia_extract::parse_leading_quantity);- let raw_has_unit_token = raw.as_str().is_some_and(|t| {- t.chars().any(|c| {- c.is_alphabetic()- || matches!(c, '$' | '€' | '£' | '¥' | '₩' | '₹' | '%')- })- });- let unit = match parsed.and_then(|(_, u)| u) {- Some(u) => Some(u),- None => match sibling_currency {- Some(c) if dt == "number" => Some(c.to_string()),- _ if raw_has_unit_token => None,- _ => def.unit.clone().filter(|u| !u.is_empty()),- },- };- if let Some(u) = unit {+ if let Some(u) = unit_for(raw, dt, sibling_currency, def.unit.as_deref()) {value["unit"] = serde_json::Value::String(u);}let write = utopia_store::graph::upsert_fact_qualifier(@@ -2938,6 +2967,129 @@ async fn chunk_lists()))}+/// 一条值该记什么单位(#600「单位是读出来的,不是猜的」,实体上的属性与边上的属性同一条规矩)。+///+/// 原文里认得出的用原文的(€、¥、%、"EUR 30 million" 的 €);模型把币种单独写成+/// 一个键时用那个;原文里写着声明的那个单位("4300 人" 对 "人")也算读出来的。+/// 原文带着一个认不出的单位记号("500 兆瓦"、"francs")时**不能**拿声明的缺省顶上——+/// 实测 `EUR 30 million` 被存成了 `$`,`500 兆瓦` 被存成了 500 块钱;单位写错比不写更糟。+/// 只有原文完全没有单位记号(一个光秃秃的数)才落回声明的缺省。+fn unit_for(+ raw: &serde_json::Value,+ datatype: &str,+ sibling_currency: Option<&str>,+ declared: Option<&str>,+) -> Option<String> {+ let declared = declared.map(str::trim).filter(|u| !u.is_empty());+ let text = raw.as_str();+ if let Some(u) = text+ .and_then(utopia_extract::parse_leading_quantity)+ .and_then(|(_, u)| u)+ {+ return Some(u);+ }+ if let (Some(c), "number") = (sibling_currency, datatype) {+ return Some(c.to_string());+ }+ if let (Some(t), Some(d)) = (text, declared) {+ if t.contains(d) {+ return Some(d.to_string());+ }+ }+ let has_unit_token = text.is_some_and(|t| {+ t.chars()+ .any(|c| c.is_alphabetic() || matches!(c, '$' | '€' | '£' | '¥' | '₩' | '₹' | '%'))+ });+ if has_unit_token {+ None+ } else {+ declared.map(str::to_string)+ }+}++#[cfg(test)]+mod unit_for_tests {+ use super::unit_for;+ use serde_json::{json, Value};++ fn s(t: &str) -> Value {+ Value::String(t.to_string())+ }++ #[test]+ fn a_unit_is_read_from_the_text_before_anything_else() {+ assert_eq!(+ unit_for(&s("EUR 30 million"), "number", None, Some("$")).as_deref(),+ Some("€")+ );+ assert_eq!(+ unit_for(&s("8.6亿元"), "number", None, Some("$")).as_deref(),+ Some("¥")+ );+ assert_eq!(+ unit_for(&s("12%"), "number", None, Some("¥")).as_deref(),+ Some("%")+ );+ assert_eq!(+ unit_for(&s("$5 billion"), "number", None, None).as_deref(),+ Some("$")+ );+ }++ #[test]+ fn a_sibling_currency_is_the_unit_of_a_bare_number() {+ assert_eq!(+ unit_for(&s("1500000000"), "number", Some("CNY"), Some("$")).as_deref(),+ Some("CNY")+ );+ // 文本型属性没有币种可言+ assert_eq!(unit_for(&s("B 轮"), "text", Some("CNY"), None), None);+ }++ #[test]+ fn the_declared_unit_written_in_the_text_counts_as_read() {+ assert_eq!(+ unit_for(&s("4300 人"), "number", None, Some("人")).as_deref(),+ Some("人")+ );+ assert_eq!(+ unit_for(&s("三年"), "text", None, Some("年")).as_deref(),+ Some("年")+ );+ }++ #[test]+ fn an_unknown_unit_token_is_never_overwritten_by_the_default() {+ // 宽松扫描把尾巴上的记号当单位读出来:记的是原文的单位,不是声明的 ¥+ assert_eq!(+ unit_for(&s("500 兆瓦"), "number", None, Some("¥")).as_deref(),+ Some("兆瓦")+ );+ assert_eq!(+ unit_for(&s("30 million francs"), "number", None, Some("$")).as_deref(),+ Some("francs")+ );+ // 扫描读不出、原文却明明带着字:也不拿缺省顶上+ assert_eq!(+ unit_for(&s("about five hundred"), "number", None, Some("$")),+ None+ );+ }++ #[test]+ fn a_bare_figure_takes_the_declared_default() {+ assert_eq!(+ unit_for(&s("4300"), "number", None, Some("人")).as_deref(),+ Some("人")+ );+ assert_eq!(+ unit_for(&json!(4300), "number", None, Some("人")).as_deref(),+ Some("人")+ );+ assert_eq!(unit_for(&s("4300"), "number", None, Some("")), None);+ }+}+#[cfg(test)]mod name_tests {use super::{clause_suspect, is_entity_name};diff --git a/crates/utopia-store/src/graph.rs b/crates/utopia-store/src/graph.rsindex 266f381a..3561cc76 100644--- a/crates/utopia-store/src/graph.rs+++ b/crates/utopia-store/src/graph.rs@@ -1994,6 +1994,32 @@ async fn adopt(.bind(old_id).execute(&mut *tx).await?;+ /* **边上的属性跟着搬**(0037)。谓词还没被采纳时金额就已经落在旧行上——+ 一句「NVIDIA invested $1.5 billion in SB Energy」在 schema.org 库里+ `invested_in` 是未知说法,钱不能等到采纳那天才有地方放。旧行作废、+ 新行接上,属性照证据的样子整体复制;顺手在关系上补声明——+ 这些属性定义本来就在库里,缺的只是关系上的一条声明 */+ sqlx::query(+ "INSERT INTO fact_qualifiers (fact_id, qualifier_type_id, value, entity_id)+ SELECT $1, qualifier_type_id, value, entity_id+ FROM fact_qualifiers WHERE fact_id = $2+ ON CONFLICT DO NOTHING",+ )+ .bind(new_id)+ .bind(old_id)+ .execute(&mut *tx)+ .await?;+ sqlx::query(+ "INSERT INTO relation_type_qualifiers (relation_type_id, qualifier_type_id)+ SELECT $1, q.qualifier_type_id+ FROM fact_qualifiers q JOIN relation_types r ON r.id = q.qualifier_type_id+ WHERE q.fact_id = $2 AND r.kind = 'attribute' AND r.id <> $1+ ON CONFLICT DO NOTHING",+ )+ .bind(predicate_id)+ .bind(new_id)+ .execute(&mut *tx)+ .await?;sqlx::query("UPDATE facts SET invalidated_at = now() WHERE id = $1").bind(old_id).execute(&mut *tx)diff --git a/crates/utopia-store/tests/an_amount_outlives_adoption.rs b/crates/utopia-store/tests/an_amount_outlives_adoption.rsnew file mode 100644index 00000000..4a2f976d--- /dev/null+++ b/crates/utopia-store/tests/an_amount_outlives_adoption.rs@@ -0,0 +1,166 @@+//! 谓词还没被采纳时,金额已经落在事实上;采纳把属性搬到新行、并在关系上补声明(0037)。+//!+//! 一句「NVIDIA invested $1.5 billion in SB Energy」在 schema.org 库里 `invested_in`+//! 是未知说法,钱不能等到采纳那天才有地方放。++use sqlx::PgPool;+use uuid::Uuid;++#[tokio::test]+async fn a_qualifier_written_before_adoption_survives_it() -> anyhow::Result<()> {+ let Some(url) = utopia_store::test_db::url() else {+ return Ok(());+ };+ let pool = PgPool::connect(&url).await?;+ let tag = Uuid::now_v7();+ let (org, ws, kb) = (Uuid::now_v7(), Uuid::now_v7(), Uuid::now_v7());+ sqlx::query("INSERT INTO organizations (id, name) VALUES ($1, $2)")+ .bind(org)+ .bind(format!("outlive-{tag}"))+ .execute(&pool)+ .await?;+ sqlx::query("INSERT INTO workspaces (id, org_id, name) VALUES ($1, $2, $3)")+ .bind(ws)+ .bind(org)+ .bind(format!("outlive-{tag}"))+ .execute(&pool)+ .await?;+ sqlx::query("INSERT INTO knowledge_bases (id, workspace_id, name) VALUES ($1, $2, $3)")+ .bind(kb)+ .bind(ws)+ .bind(format!("outlive-{tag}"))+ .execute(&pool)+ .await?;+ let class = Uuid::now_v7();+ sqlx::query("INSERT INTO entity_types (id, kb_id, key, label) VALUES ($1, $2, 'org', 'Org')")+ .bind(class)+ .bind(kb)+ .execute(&pool)+ .await?;+ let amount = utopia_store::ontology::create_relation_type(+ &pool,+ kb,+ "amount",+ "amount",+ "state",+ Default::default(),+ "",+ "attribute",+ &[class],+ &[],+ Some("number"),+ Some("$"),+ )+ .await?;+ // 关系此刻还不存在于本体里——先建好但不声明任何属性,模拟"采纳"那一刻+ let invested = utopia_store::ontology::create_relation_type(+ &pool,+ kb,+ "invested_in",+ "invested in",+ "event",+ Default::default(),+ "",+ "relation",+ &[],+ &[],+ None,+ None,+ )+ .await?;+ let (a, b) = (Uuid::now_v7(), Uuid::now_v7());+ for (id, name) in [(a, "NVIDIA"), (b, "SB Energy")] {+ sqlx::query(+ "INSERT INTO entities (id, kb_id, type_id, canonical_name) VALUES ($1, $2, $3, $4)",+ )+ .bind(id)+ .bind(kb)+ .bind(class)+ .bind(format!("{name}-{tag}"))+ .execute(&pool)+ .await?;+ }+ let (doc, chunk, fact) = (Uuid::now_v7(), Uuid::now_v7(), Uuid::now_v7());+ sqlx::query("INSERT INTO documents (id, kb_id, filename, sha256) VALUES ($1, $2, $3, $4)")+ .bind(doc)+ .bind(kb)+ .bind(format!("{tag}.txt"))+ .bind(tag.to_string())+ .execute(&pool)+ .await?;+ sqlx::query(+ "INSERT INTO chunks (id, kb_id, document_id, seq, text) VALUES ($1, $2, $3, 0, 'x')",+ )+ .bind(chunk)+ .bind(kb)+ .bind(doc)+ .execute(&pool)+ .await?;+ // 谓词为空的事实 + 说法在证据上 + 金额已经在边上+ sqlx::query(+ "INSERT INTO facts (id, kb_id, subject_id, predicate_id, object_id, confidence)+ VALUES ($1, $2, $3, NULL, $4, 0.9)",+ )+ .bind(fact)+ .bind(kb)+ .bind(a)+ .bind(b)+ .execute(&pool)+ .await?;+ sqlx::query(+ "INSERT INTO fact_evidence (fact_id, chunk_id, document_id, proposed_predicate)+ VALUES ($1, $2, $3, 'invested_in')",+ )+ .bind(fact)+ .bind(chunk)+ .bind(doc)+ .execute(&pool)+ .await?;+ let value = serde_json::json!({ "value": 1500000000.0, "unit": "$" });+ utopia_store::graph::upsert_fact_qualifier(&pool, fact, amount, &value).await?;++ // 采纳:旧行作废、新行接上谓词+ let adopted = utopia_store::graph::adopt_proposed_predicates(+ &pool,+ kb,+ invested,+ &["invested_in".to_string()],+ false,+ )+ .await?;+ assert_eq!(adopted.moved, 1);++ // 活着的那一行带着金额+ let live: Vec<(Uuid,)> = sqlx::query_as(+ "SELECT id FROM facts WHERE kb_id = $1 AND predicate_id = $2 AND invalidated_at IS NULL",+ )+ .bind(kb)+ .bind(invested)+ .fetch_all(&pool)+ .await?;+ assert_eq!(live.len(), 1, "采纳后正好一条活着的边");+ let quals = utopia_store::graph::fact_qualifiers_for(&pool, &[live[0].0]).await?;+ let q = &quals[&live[0].0];+ assert_eq!(q.len(), 1);+ assert_eq!(q[0].key, "amount");+ assert_eq!(q[0].value, Some(value), "金额跟着搬到了新行");++ // 关系上补了声明+ let declared = utopia_store::graph::relation_types(&pool, kb)+ .await?+ .into_iter()+ .find(|r| r.id == invested)+ .map(|r| r.qualifiers)+ .unwrap_or_default();+ assert_eq!(declared, vec![amount], "采纳时按边上已有的属性补了声明");++ sqlx::query("DELETE FROM knowledge_bases WHERE id = $1")+ .bind(kb)+ .execute(&pool)+ .await?;+ sqlx::query("DELETE FROM organizations WHERE id = $1")+ .bind(org)+ .execute(&pool)+ .await?;+ Ok(())+}diff --git a/docs/decisions/0037-a-relation-carries-its-own-attributes.md b/docs/decisions/0037-a-relation-carries-its-own-attributes.mdindex 90232ed6..a27bf89b 100644--- a/docs/decisions/0037-a-relation-carries-its-own-attributes.md+++ b/docs/decisions/0037-a-relation-carries-its-own-attributes.md@@ -114,7 +114,9 @@ rules corpus declared and undeclared, a Chinese corpus declared and undeclared):writes the currency as a sibling key (`"currency": "CNY"`). The prompt now asks for thefigure as written, the scanner reads ISO codes, currency words and CJK magnitudes (万, 亿),a sibling `currency` key becomes the unit, and the attribute's default unit is used only- when the text carries no unit token at all — a wrong currency is worse than none.+ when the text carries no unit token at all — a wrong currency is worse than none. The same+ rule (`unit_for`) now governs an attribute written on an entity, which used to stamp the+ declared unit unconditionally: `500 兆瓦` filed under 金额 came out as ¥500.- **Two mentions of one edge in parallel can both insert.** The dedup in `insert_fact_inner`is a read-then-write with no unique index behind it; two documents describing the same`(subject, predicate, object, moment)` extracted at the same time produced two rows with@@ -126,10 +128,13 @@ rules corpus declared and undeclared, a Chinese corpus declared and undeclared):## Open questions-- Where does the amount go when the relation is not adopted yet (`predicate_id` is null,- wording on the evidence)? This cut drops it with a reason. Keeping it keyed by wording- until adoption would preserve the figure; the bootstrap would then have to propose the- qualifier along with the relation.+- ~~Where does the amount go when the relation is not adopted yet?~~ Answered: a qualifier+ on a fact whose predicate is unknown binds to an attribute the base already defines (no+ ontology change, so no switch), and adoption (`adopt`) carries the qualifiers onto the new+ row and declares them on the relation. A qualifier that binds to nothing — the base has no+ such attribute, or the ontology is frozen — is written as a literal fact on the subject,+ worded `relation.key` on its evidence and recorded in `ontology_misses`, the shape rule 8a+ gives an unlisted figure. Nothing about an edge is dropped for want of a definition.- The canvas. An edge label with the amount is a rendering change and belongs with theparallel-edge work; the timeline reading an event as a point is[0031](0031-an-event-holds-at-the-moment-it-names.md)'s UI cut.diff --git a/scripts/bench/recall.mjs b/scripts/bench/recall.mjsindex c7c32817..7cffe2a8 100644--- a/scripts/bench/recall.mjs+++ b/scripts/bench/recall.mjs@@ -86,7 +86,10 @@ function score() {coalesce(s.canonical_name,''),coalesce(rt.key, coalesce(fe.proposed_predicate,'')),coalesce(o.canonical_name, f.object_value #>> '{}', f.object_value::text, ''),- coalesce(to_char(f.valid_from,'YYYY-MM-DD'),''))+ coalesce(to_char(f.valid_from,'YYYY-MM-DD'),''),+ coalesce((SELECT string_agg(q.key || '=' || coalesce(fq.value #>> '{value}', '') || ' ' || coalesce(fq.value #>> '{unit}', ''), ' ')+ FROM fact_qualifiers fq JOIN relation_types q ON q.id = fq.qualifier_type_id+ WHERE fq.fact_id = f.id), ''))FROM facts fJOIN fact_evidence fe ON fe.fact_id = f.idJOIN documents d ON d.id = fe.document_id@@ -97,8 +100,9 @@ function score() {.split("\n").filter(Boolean).map((l) => {- const [file, subj, pred, obj, from] = l.split("");- return { file, subj, pred, obj, from };+ // 边上的属性(0037)也在这一行里:金额挂在边上时,值不在 object 那一格+ const [file, subj, pred, obj, from, quals] = l.split("");+ return { file, subj, pred, obj, from, quals };});const byDoc = new Map();@@ -122,7 +126,7 @@ function score() {let ok = false;if (t.kind === "value") {ok = facts.some((f) => {- const raw = `${f.subj} | ${f.pred} | ${f.obj} | ${f.from}`;+ const raw = `${f.subj} | ${f.pred} | ${f.obj} | ${f.from} | ${f.quals}`;return t.value_any.some((v) => norm(raw).includes(norm(v)) || squash(raw).includes(squash(v)));});} else if (t.kind === "edge") {