Skip to content

World's first open-source enterprise world model.

36.2 KB
Raw Blame
//! 图谱答出来的回答点得开原句(#935)。
//!
//! 四个图谱工具(entity_facts、neighbors、timeline、paths_between)在对话里给每条显示出来
//! 的事实印上它第一条有效证据的 `[n]`,证据块登进这一轮的来源清单,与检索结果共用一套号。
//! 这里钉住:
//!
//! - 每个工具的号都指向那条事实的证据块;几条证据时取最早那篇文档的
//! - 同一块在一轮里只有一个号,换一个工具再印还是它
//! - 证据只在已删文档里的事实不带号;`as_of` 回到删除之前,它又带上号
//! - 派生事实那一行不带号,它的前提各带各的
//! - MCP 的文字一字不改,来源清单是空的(号码对没有清单的调用方没有意义)
//! - 整条对话:工具印的号随 `sources` 帧发出去、跟着回答落库,模型读到的事实行带着号
//! - 号打开的是那句话(#968 的后续):条目带着块里说出这条事实的引文,一块被引几句就记
//!   几句;块被新版本取代后换成仍有效的那一块,`as_of` 回到取代之前又是原来那块
//! - 检索和图谱工具在一轮里共用一个号:图谱引到检索登过的块,号不变、补上那句话;只补了
//!   引文、条数没变,来源帧也再发一次
//! - 原句里没有的日期在行上说出来(#970):时间线推出来的终点写出关上它的那一行、带那一行
//!   的号(那一行没有有效证据时不带号,清单里也不多一条),人改过的区间写出修正备注、不带号;
//!   本行的号照旧。对话与 MCP 一样(MCP 不带号),规则 4 说推出的终点引关它的那一行,两种
//!   日期都不归到本行的原句
//!
//! 没有 `UTOPIA_DATABASE_URL` 时跳过而不是失败。自建自拆,绝不碰已有的库。
use super::*;
use crate::api::tools::{dispatch, ToolCtx, ToolSink};

struct Seed {
    /// 张三 leads Aurora 的两条证据:早的那篇(charter)与晚的那篇(recap)
    charter: Uuid,
    recap: Uuid,
    /// 李四 leads Aurora 的证据
    handover: Uuid,
    /// 王五 advises Aurora 的唯一证据,在一篇删掉的文档里
    deleted: Uuid,
}

/// 一个项目、三个人、四篇文档(一篇已删),外加一条对称规则推出来的事实
async fn seed(pool: &sqlx::PgPool, kb: Uuid) -> anyhow::Result<Seed> {
    let id = Uuid::now_v7;
    let (person, project, leads, advises, works_with, rule) = (id(), id(), id(), id(), id(), id());
    let (zhang, li, wang, aurora) = (id(), id(), id(), id());
    let (d_charter, d_recap, d_handover, d_deleted) = (id(), id(), id(), id());
    let (charter, recap, handover, deleted) = (id(), id(), id(), id());
    let (f_zhang, f_li, f_wang, f_pair, derived) = (id(), id(), id(), id(), id());
    // 插进去的只有本地生成的 UUID 和写死的日期
    sqlx::raw_sql(&format!(
        r#"
        INSERT INTO entity_types(id,kb_id,key,label) VALUES
            ('{person}','{kb}','person','Person'), ('{project}','{kb}','project','Project');
        INSERT INTO relation_types(id,kb_id,key,label,temporal) VALUES
            ('{leads}','{kb}','leads','leads','state'),
            ('{advises}','{kb}','advises','advises','state'),
            ('{works_with}','{kb}','works_with','works with','state');
        INSERT INTO entities(id,kb_id,type_id,canonical_name,created_at) VALUES
            ('{zhang}','{kb}','{person}','Zhang San','2026-01-01'),
            ('{li}','{kb}','{person}','Li Si','2026-01-01'),
            ('{wang}','{kb}','{person}','Wang Wu','2026-01-01'),
            ('{aurora}','{kb}','{project}','Project Aurora','2026-01-01');
        INSERT INTO documents(id,kb_id,filename,sha256,created_at,doc_time,deleted_at) VALUES
            ('{d_charter}','{kb}','charter.md',repeat('1',64),'2026-01-01','2023-01-05',NULL),
            ('{d_recap}','{kb}','recap.md',repeat('2',64),'2025-12-01','2025-01-01',NULL),
            ('{d_handover}','{kb}','handover.md',repeat('3',64),'2026-01-01','2024-07-05',NULL),
            ('{d_deleted}','{kb}','advisor-note.md',repeat('4',64),'2026-01-01','2023-03-02','2026-06-01');
        INSERT INTO chunks(id,kb_id,document_id,seq,text,created_at) VALUES
            ('{charter}','{kb}','{d_charter}',0,'Zhang San leads Project Aurora from 2023-01-10.','2026-01-01'),
            ('{recap}','{kb}','{d_recap}',0,'Zhang San led Project Aurora until the handover.','2026-01-01'),
            ('{handover}','{kb}','{d_handover}',0,'Li Si leads Project Aurora from 2024-07-05.','2026-01-01'),
            ('{deleted}','{kb}','{d_deleted}',0,'Wang Wu advises Project Aurora.','2026-01-01');
        INSERT INTO facts(id,kb_id,subject_id,predicate_id,object_id,valid_from,valid_from_precision,
                          valid_to,valid_to_precision,recorded_at,confidence) VALUES
            ('{f_zhang}','{kb}','{zhang}','{leads}','{aurora}','2023-01-10','day','2024-07-05','day','2026-01-01',0.9),
            ('{f_li}','{kb}','{li}','{leads}','{aurora}','2024-07-05','day',NULL,NULL,'2026-01-01',0.9),
            ('{f_wang}','{kb}','{wang}','{advises}','{aurora}','2023-03-02','day',NULL,NULL,'2026-01-01',0.9),
            ('{f_pair}','{kb}','{zhang}','{works_with}','{li}','2023-01-10','day',NULL,NULL,'2026-01-01',0.9);
        -- 晚的那篇先插、也先入库:取哪条证据按文档自己的日期,不按插入或入库的先后
        INSERT INTO fact_evidence(fact_id,chunk_id,document_id,doc_version,quote) VALUES
            ('{f_zhang}','{recap}','{d_recap}',1,'Zhang San led Project Aurora until the handover.'),
            ('{f_zhang}','{charter}','{d_charter}',1,'Zhang San leads Project Aurora from 2023-01-10.'),
            ('{f_li}','{handover}','{d_handover}',1,'Li Si leads Project Aurora from 2024-07-05.'),
            ('{f_wang}','{deleted}','{d_deleted}',1,'Wang Wu advises Project Aurora.'),
            ('{f_pair}','{charter}','{d_charter}',1,'Zhang San leads Project Aurora from 2023-01-10.');
        INSERT INTO rules(id,kb_id,predicate_id,kind) VALUES ('{rule}','{kb}','{works_with}','symmetric');
        INSERT INTO derived_facts(id,kb_id,subject_id,predicate_id,object_id,rule_id,derived_at,
                                  valid_from,valid_from_precision) VALUES
            ('{derived}','{kb}','{li}','{works_with}','{zhang}','{rule}','2026-01-01','2023-01-10','day');
        INSERT INTO fact_derivations(derived_fact_id,premise_fact_id,seq) VALUES ('{derived}','{f_pair}',0);
        "#
    ))
    .execute(pool)
    .await?;
    Ok(Seed {
        charter,
        recap,
        handover,
        deleted,
    })
}

fn ctx(f: &Fx, via_token: Option<Uuid>) -> ToolCtx<'_> {
    ToolCtx {
        state: &f.state,
        kb_id: f.kb,
        workspace_id: Uuid::nil(),
        mounted_sources: &[],
        can_write: false,
        actor: Some(f.user.id),
        via_token,
        question: None,
    }
}

/// 一段文字里的引用号:`[3]` 算,置信度 `[90%]` 和 `[rule: …]` 不算
fn marks(text: &str) -> Vec<usize> {
    text.match_indices('[')
        .filter_map(|(at, _)| {
            let rest = &text[at + 1..];
            let end = rest.find(']')?;
            rest[..end].parse().ok()
        })
        .collect()
}

/// 含 `needle` 的那一行。neighbors 把一组的几项写在同一行、用 ` · ` 隔开,取的是那一项
fn line<'t>(text: &'t str, needle: &str) -> &'t str {
    text.lines()
        .flat_map(|l| l.split(" · "))
        .find(|item| item.contains(needle))
        .unwrap_or_else(|| panic!("no line with {needle:?} in:\n{text}"))
}

/// 号 `n` 在清单里登的是哪一块
fn chunk_of(sink: &ToolSink, n: usize) -> Uuid {
    sink.sources[n - 1]["chunk_id"]
        .as_str()
        .and_then(|s| s.parse().ok())
        .unwrap_or_else(|| panic!("no source {n} in {:?}", sink.sources))
}

#[tokio::test]
async fn each_graph_tool_cites_the_first_live_evidence_of_each_fact() -> anyhow::Result<()> {
    let Some(f) = fixture(Scripted::new(vec![])).await? else {
        return Ok(());
    };
    let run = async {
        let s = seed(&f.pool, f.kb).await?;
        let chat = ctx(&f, None);
        let mut sink = ToolSink::default();

        let facts = dispatch(
            &chat,
            &mut sink,
            "entity_facts",
            &json!({"entity": "Project Aurora"}),
        )
        .await;
        let text = &facts.text;
        let zhang = marks(line(text, "Zhang San"));
        let li = marks(line(text, "Li Si"));
        assert_eq!(zhang.len(), 1, "{text}");
        assert_eq!(
            chunk_of(&sink, zhang[0]),
            s.charter,
            "the earliest document's chunk, not the recap"
        );
        assert_eq!(li.len(), 1, "{text}");
        assert_eq!(chunk_of(&sink, li[0]), s.handover);
        assert!(
            marks(line(text, "Wang Wu")).is_empty(),
            "evidence only in a deleted document: {text}"
        );
        assert_eq!(sink.sources.len(), 2, "{:?}", sink.sources);
        assert_eq!(sink.sources[zhang[0] - 1]["filename"], "charter.md");
        assert!(
            sink.sources
                .iter()
                .all(|x| x["chunk_id"] != s.recap.to_string()),
            "one number per fact: the later evidence is not listed"
        );

        // 同一块同一个号:换一个工具再印,清单不长
        let near = dispatch(
            &chat,
            &mut sink,
            "neighbors",
            &json!({"entity": "Project Aurora"}),
        )
        .await;
        assert_eq!(marks(line(&near.text, "Zhang San")), zhang, "{}", near.text);
        assert_eq!(marks(line(&near.text, "Li Si")), li, "{}", near.text);
        let dated = dispatch(
            &chat,
            &mut sink,
            "timeline",
            &json!({"entity": "Project Aurora"}),
        )
        .await;
        assert_eq!(
            marks(line(&dated.text, "Zhang San")),
            zhang,
            "{}",
            dated.text
        );
        assert_eq!(marks(line(&dated.text, "Li Si")), li, "{}", dated.text);
        assert!(
            marks(line(&dated.text, "Wang Wu")).is_empty(),
            "{}",
            dated.text
        );
        // 路径的每一跳是一条事实,各带各的号:王五那一跳的证据在删掉的文档里,不带
        let path = dispatch(
            &chat,
            &mut sink,
            "paths_between",
            &json!({"from": "Wang Wu", "to": "Li Si"}),
        )
        .await;
        let hops = line(&path.text, "—advises→");
        assert_eq!(marks(hops), [li[0]], "{}", path.text);
        assert_eq!(
            sink.sources.len(),
            2,
            "no chunk was numbered twice: {:?}",
            sink.sources
        );

        // 派生那一行不带号;它的前提(张三 works with 李四)带着自己的号
        let li_facts = dispatch(
            &chat,
            &mut sink,
            "entity_facts",
            &json!({"entity": "Li Si"}),
        )
        .await;
        let derived = line(&li_facts.text, "[rule:");
        assert!(marks(derived).is_empty(), "{}", li_facts.text);
        let premise = marks(line(&li_facts.text, "Zhang San"));
        assert_eq!(premise.len(), 1, "{}", li_facts.text);
        assert_eq!(chunk_of(&sink, premise[0]), s.charter);

        // 回到删除之前:那篇文档当时还在,王五的事实带上号
        let mut before = ToolSink::default();
        let then = dispatch(
            &chat,
            &mut before,
            "entity_facts",
            &json!({"entity": "Project Aurora", "as_of": "2026-03-01"}),
        )
        .await;
        let wang = marks(line(&then.text, "Wang Wu"));
        assert_eq!(wang.len(), 1, "{}", then.text);
        assert_eq!(chunk_of(&before, wang[0]), s.deleted);

        // MCP:文字与对话里去掉号之后一字不差,清单是空的
        let mcp = ctx(&f, Some(Uuid::now_v7()));
        for (tool, args) in [
            ("entity_facts", json!({"entity": "Project Aurora"})),
            ("neighbors", json!({"entity": "Project Aurora"})),
            ("timeline", json!({"entity": "Project Aurora"})),
            ("paths_between", json!({"from": "Wang Wu", "to": "Li Si"})),
        ] {
            let mut empty = ToolSink::default();
            let plain = dispatch(&mcp, &mut empty, tool, &args).await.text;
            let numbered = dispatch(&chat, &mut ToolSink::default(), tool, &args)
                .await
                .text;
            let mut stripped = numbered.clone();
            for n in 1..=2 {
                stripped = stripped.replace(&format!(" [{n}]"), "");
            }
            assert_eq!(plain, stripped, "{tool} over MCP keeps its text");
            assert!(marks(&plain).is_empty(), "{tool}: {plain}");
            assert!(empty.sources.is_empty(), "{tool}: {:?}", empty.sources);
        }
        anyhow::Ok(())
    }
    .await;
    f.cleanup().await?;
    run
}

#[tokio::test]
async fn a_graph_answer_publishes_and_stores_its_sources() -> anyhow::Result<()> {
    let Some(f) = fixture(Scripted::new(vec![
        Reply::Tool("entity_facts", r#"{"entity_id":"Project Aurora"}"#),
        Reply::Text("Li Si leads Project Aurora."),
    ]))
    .await?
    else {
        return Ok(());
    };
    let run = async {
        let s = seed(&f.pool, f.kb).await?;
        let sse = f.ask("Who leads Project Aurora?").await?;
        assert!(sse.contains("event: done"), "{sse}");

        // `sources` 帧:两块证据,按印出来的顺序编号
        let published: Vec<serde_json::Value> = sse
            .split("\n\n")
            .filter(|frame| frame.lines().any(|l| l == "event: sources"))
            .filter_map(|frame| frame.lines().find_map(|l| l.strip_prefix("data: ")))
            .filter_map(|data| serde_json::from_str(data).ok())
            .collect();
        let last = published.last().expect("a sources frame");
        let chunks: Vec<&str> = last
            .as_array()
            .unwrap()
            .iter()
            .filter_map(|s| s["chunk_id"].as_str())
            .collect();
        assert_eq!(chunks.len(), 2, "{last}");
        assert!(chunks.contains(&s.charter.to_string().as_str()), "{last}");
        assert!(chunks.contains(&s.handover.to_string().as_str()), "{last}");

        // 落库的回答带着同一张清单,重开会话时号码照样点得开
        let stored: serde_json::Value = sqlx::query_scalar(
            "SELECT m.sources FROM conversation_messages m
               JOIN conversations c ON c.id = m.conversation_id
              WHERE c.kb_id = $1 AND m.role = 'assistant'",
        )
        .bind(f.kb)
        .fetch_one(&f.pool)
        .await?;
        assert_eq!(&stored, last);

        // 模型读到的事实行带着号:置信度后面跟着它
        let requests = f.requests();
        let sent = requests[1]["messages"].to_string();
        assert!(sent.contains("Li Si") && sent.contains("%] ["), "{sent}");
        anyhow::Ok(())
    }
    .await;
    f.cleanup().await?;
    run
}

/// 号 `n` 那一条带着的引文
fn quotes_of(sink: &ToolSink, n: usize) -> Vec<String> {
    sink.sources[n - 1]["quotes"]
        .as_array()
        .map(|q| {
            q.iter()
                .filter_map(|x| x.as_str().map(str::to_string))
                .collect()
        })
        .unwrap_or_default()
}

/// 种子里还在的几篇文档进全文索引:检索要找得到它们
async fn index_seed(f: &Fx) -> anyhow::Result<()> {
    let rows: Vec<(Uuid, Uuid, String)> = sqlx::query_as(
        "SELECT c.document_id, c.id, c.text FROM chunks c JOIN documents d ON d.id = c.document_id
          WHERE c.kb_id = $1 AND d.deleted_at IS NULL ORDER BY c.document_id, c.seq",
    )
    .bind(f.kb)
    .fetch_all(&f.pool)
    .await?;
    let mut by_doc: std::collections::BTreeMap<Uuid, Vec<(String, String)>> = Default::default();
    for (doc, chunk, text) in rows {
        by_doc
            .entry(doc)
            .or_default()
            .push((chunk.to_string(), text));
    }
    for (doc, chunks) in by_doc {
        f.state
            .search
            .reindex_document(&f.kb.to_string(), &doc.to_string(), &chunks)?;
    }
    Ok(())
}

/// 号打开的是说出这条事实的那一句:条目带着引文,同一块两条事实两句都在;块被取代后
/// 换成仍有效的那一块和它那一句,`as_of` 回到取代之前又是原来的
#[tokio::test]
async fn a_graph_number_opens_the_sentence_it_was_read_from() -> anyhow::Result<()> {
    let Some(f) = fixture(Scripted::new(vec![])).await? else {
        return Ok(());
    };
    let run = async {
        let s = seed(&f.pool, f.kb).await?;
        let pair: Uuid = sqlx::query_scalar(
            "SELECT f.id FROM facts f JOIN relation_types r ON r.id = f.predicate_id
              WHERE f.kb_id = $1 AND r.key = 'works_with'",
        )
        .bind(f.kb)
        .fetch_one(&f.pool)
        .await?;
        // 章程那一块说了两句,张三的两条事实各从一句读出来
        sqlx::query("UPDATE chunks SET text = $2 WHERE id = $1")
            .bind(s.charter)
            .bind("Zhang San leads Project Aurora from 2023-01-10. Zhang San works with Li Si.")
            .execute(&f.pool)
            .await?;
        sqlx::query(
            "UPDATE fact_evidence SET quote = 'Zhang San works with Li Si.' WHERE fact_id = $1",
        )
        .bind(pair)
        .execute(&f.pool)
        .await?;
        let chat = ctx(&f, None);
        let mut sink = ToolSink::default();
        let text = dispatch(
            &chat,
            &mut sink,
            "entity_facts",
            &json!({"entity": "Zhang San"}),
        )
        .await
        .text;
        // 张三 works with 李四有两行:断言的那行带号,规则推出来的那行(`[rule:`)不带
        let works_line = text
            .lines()
            .flat_map(|l| l.split(" · "))
            .find(|l| l.contains("Li Si") && !l.contains("[rule:"))
            .unwrap_or_else(|| panic!("no stated works-with line in:\n{text}"));
        let (leads, works) = (marks(line(&text, "Project Aurora")), marks(works_line));
        assert_eq!(leads, works, "one chunk, one number: {text}");
        assert_eq!(chunk_of(&sink, leads[0]), s.charter);
        let mut quotes = quotes_of(&sink, leads[0]);
        quotes.sort();
        assert_eq!(
            quotes,
            [
                "Zhang San leads Project Aurora from 2023-01-10.",
                "Zhang San works with Li Si."
            ],
            "both sentences the chunk was cited for"
        );

        // 章程那一块被新版本取代:张三领 Aurora 那一条换成仍有效的回顾那一块、那一句
        sqlx::query("UPDATE chunks SET superseded_at = now() WHERE id = $1")
            .bind(s.charter)
            .execute(&f.pool)
            .await?;
        let mut now = ToolSink::default();
        let text = dispatch(
            &chat,
            &mut now,
            "entity_facts",
            &json!({"entity": "Project Aurora"}),
        )
        .await
        .text;
        let zhang = marks(line(&text, "Zhang San"));
        assert_eq!(chunk_of(&now, zhang[0]), s.recap, "{text}");
        assert_eq!(
            quotes_of(&now, zhang[0]),
            ["Zhang San led Project Aurora until the handover."]
        );
        // 回到取代之前:那时章程那一块还是现行的
        let mut then = ToolSink::default();
        let text = dispatch(
            &chat,
            &mut then,
            "entity_facts",
            &json!({"entity": "Project Aurora", "as_of": "2026-03-01"}),
        )
        .await
        .text;
        let zhang = marks(line(&text, "Zhang San"));
        assert_eq!(chunk_of(&then, zhang[0]), s.charter, "{text}");
        assert_eq!(
            quotes_of(&then, zhang[0]),
            ["Zhang San leads Project Aurora from 2023-01-10."]
        );
        // MCP 没有来源清单,也就没有引文
        let mut empty = ToolSink::default();
        dispatch(
            &ctx(&f, Some(Uuid::now_v7())),
            &mut empty,
            "entity_facts",
            &json!({"entity": "Project Aurora"}),
        )
        .await;
        assert!(empty.sources.is_empty());
        anyhow::Ok(())
    }
    .await;
    f.cleanup().await?;
    run
}

/// 一轮里检索和图谱工具共用一个号:检索先登了交接备忘录那一块,图谱引到它时号不变,
/// 条目补上李四那句话;反过来也一样,检索不另起一个号,引文留着
#[tokio::test]
async fn a_search_and_a_graph_tool_share_one_number() -> anyhow::Result<()> {
    let Some(f) = fixture(Scripted::new(vec![])).await? else {
        return Ok(());
    };
    let run = async {
        let s = seed(&f.pool, f.kb).await?;
        index_seed(&f).await?;
        let chat = ctx(&f, None);
        let number_of = |sink: &ToolSink, chunk: Uuid| {
            sink.sources
                .iter()
                .position(|x| x["chunk_id"] == chunk.to_string())
                .map(|i| i + 1)
        };
        let li_says = "Li Si leads Project Aurora from 2024-07-05.";

        let mut sink = ToolSink::default();
        let found = dispatch(
            &chat,
            &mut sink,
            "search_chunks",
            &json!({"query": "Li Si leads Project Aurora"}),
        )
        .await
        .text;
        let n = number_of(&sink, s.handover).unwrap_or_else(|| panic!("the handover hit: {found}"));
        assert!(
            quotes_of(&sink, n).is_empty(),
            "a search hit carries no quote"
        );
        let listed = sink.sources.len();
        let text = dispatch(
            &chat,
            &mut sink,
            "entity_facts",
            &json!({"entity": "Project Aurora"}),
        )
        .await
        .text;
        assert_eq!(
            marks(line(&text, "Li Si")),
            [n],
            "the search's number: {text}"
        );
        assert_eq!(
            quotes_of(&sink, n),
            [li_says],
            "the entry gains the sentence"
        );
        assert_eq!(
            number_of(&sink, s.handover),
            Some(n),
            "still one entry for the chunk"
        );
        assert!(sink.sources.len() >= listed);

        let mut reverse = ToolSink::default();
        let text = dispatch(
            &chat,
            &mut reverse,
            "entity_facts",
            &json!({"entity": "Project Aurora"}),
        )
        .await
        .text;
        let m = marks(line(&text, "Li Si"))[0];
        let listed = reverse.sources.len();
        dispatch(
            &chat,
            &mut reverse,
            "search_chunks",
            &json!({"query": "Li Si leads Project Aurora"}),
        )
        .await;
        assert_eq!(
            number_of(&reverse, s.handover),
            Some(m),
            "the graph's number"
        );
        assert_eq!(quotes_of(&reverse, m), [li_says], "the quote stays");
        assert!(reverse.sources.len() >= listed);
        anyhow::Ok(())
    }
    .await;
    f.cleanup().await?;
    run
}

/// 整条对话:检索登了三块,图谱再引其中两块,只补了引文、条数没变——来源帧照样再发
/// 一次,存下的与最后一帧一致
#[tokio::test]
async fn a_quote_added_to_a_search_hit_is_published() -> anyhow::Result<()> {
    let Some(f) = fixture(Scripted::new(vec![
        Reply::Tool("search_chunks", r#"{"query":"Project Aurora"}"#),
        Reply::Tool("entity_facts", r#"{"entity_id":"Li Si"}"#),
        Reply::Text("Li Si leads Project Aurora."),
    ]))
    .await?
    else {
        return Ok(());
    };
    let run = async {
        seed(&f.pool, f.kb).await?;
        index_seed(&f).await?;
        let sse = f.ask("Who leads Project Aurora?").await?;
        assert!(sse.contains("event: done"), "{sse}");
        let published: Vec<serde_json::Value> = sse
            .split("\n\n")
            .filter(|frame| frame.lines().any(|l| l == "event: sources"))
            .filter_map(|frame| frame.lines().find_map(|l| l.strip_prefix("data: ")))
            .filter_map(|data| serde_json::from_str(data).ok())
            .collect();
        assert!(published.len() >= 2, "{published:?}");
        let (first, last) = (&published[0], published.last().unwrap());
        assert_eq!(
            first.as_array().map(Vec::len),
            last.as_array().map(Vec::len),
            "the graph step added no entry, only quotes: {published:?}"
        );
        assert!(
            last.as_array()
                .unwrap()
                .iter()
                .any(|x| x["quotes"].as_array().is_some_and(|q| !q.is_empty())),
            "{last}"
        );
        let stored: serde_json::Value = sqlx::query_scalar(
            "SELECT m.sources FROM conversation_messages m
               JOIN conversations c ON c.id = m.conversation_id
              WHERE c.kb_id = $1 AND m.role = 'assistant'",
        )
        .bind(f.kb)
        .fetch_one(&f.pool)
        .await?;
        assert_eq!(&stored, last);
        anyhow::Ok(())
    }
    .await;
    f.cleanup().await?;
    run
}

/// #970 的两处:周七 2025-09-01 接手,时间线把李四那一段关在那天;人把张三的起点从章程的
/// 2023-01-10 改成 2023-02-01。两行的号仍打开它们读出来的原句,而原句里没有这两个日期,
/// 所以行上说出日期从哪来。周七那篇删掉以后,关上李四那段的那一行没有有效证据:行上照旧
/// 写出是他接手,不带号
#[tokio::test]
async fn a_fact_line_says_when_a_date_is_not_the_passages() -> anyhow::Result<()> {
    let Some(f) = fixture(Scripted::new(vec![])).await? else {
        return Ok(());
    };
    let run = async {
        let s = seed(&f.pool, f.kb).await?;
        let (leads, person, aurora): (Uuid, Uuid, Uuid) = sqlx::query_as(
            "SELECT r.id, t.id, e.id FROM relation_types r, entity_types t, entities e
              WHERE r.kb_id = $1 AND r.key = 'leads' AND t.kb_id = $1 AND t.key = 'person'
                AND e.kb_id = $1 AND e.canonical_name = 'Project Aurora'",
        )
        .bind(f.kb)
        .fetch_one(&f.pool)
        .await?;
        let row_of = |name: &'static str| {
            let pool = f.pool.clone();
            let kb = f.kb;
            async move {
                sqlx::query_scalar::<_, Uuid>(
                    "SELECT f.id FROM facts f JOIN entities e ON e.id = f.subject_id
                      WHERE f.kb_id = $1 AND e.canonical_name = $2 AND f.predicate_id = $3
                        AND f.invalidated_at IS NULL",
                )
                .bind(kb)
                .bind(name)
                .bind(leads)
                .fetch_one(&pool)
                .await
            }
        };
        let (zhang, li) = (row_of("Zhang San").await?, row_of("Li Si").await?);
        let (zhou, d_update, update, zhou_fact) =
            (Uuid::now_v7(), Uuid::now_v7(), Uuid::now_v7(), Uuid::now_v7());
        // 插进去的只有本地生成的 UUID 和写死的日期
        sqlx::raw_sql(&format!(
            r#"
            INSERT INTO entities(id,kb_id,type_id,canonical_name,created_at) VALUES
                ('{zhou}','{kb}','{person}','Zhou Qi','2026-01-01');
            INSERT INTO documents(id,kb_id,filename,sha256,created_at,doc_time) VALUES
                ('{d_update}','{kb}','leadership-update.md',repeat('5',64),'2026-01-01','2025-09-01');
            INSERT INTO chunks(id,kb_id,document_id,seq,text,created_at) VALUES
                ('{update}','{kb}','{d_update}',0,'Zhou Qi leads Project Aurora from 2025-09-01.','2026-01-01');
            INSERT INTO facts(id,kb_id,subject_id,predicate_id,object_id,valid_from,valid_from_precision,
                              recorded_at,confidence) VALUES
                ('{zhou_fact}','{kb}','{zhou}','{leads}','{aurora}','2025-09-01','day','2026-01-01',0.9);
            INSERT INTO fact_evidence(fact_id,chunk_id,document_id,doc_version,quote) VALUES
                ('{zhou_fact}','{update}','{d_update}',1,'Zhou Qi leads Project Aurora from 2025-09-01.');
            UPDATE relation_types SET inverse_functional = TRUE WHERE id = '{leads}';
            "#,
            kb = f.kb
        ))
        .execute(&f.pool)
        .await?;
        // 一个项目同时只有一个 lead:对账把李四那一段关在周七接手那天
        utopia_store::temporal::reconcile_moved_facts(&f.pool, f.kb, &[li, zhou_fact]).await?;
        // 人改张三的起点,终点照旧;审计记在被改的那一行上(PATCH /facts/{id} 同一条路)
        let day = |s: &str| s.parse::<chrono::DateTime<chrono::Utc>>().unwrap();
        utopia_store::temporal::correct_interval(
            &f.pool,
            zhang,
            utopia_store::graph::Validity {
                from: Some(day("2023-02-01T00:00:00Z")),
                from_precision: Some("day"),
                to: Some(day("2024-07-05T00:00:00Z")),
                to_precision: Some("day"),
                attested_at: None,
                from_grade: None,
                end_after_period: false,
            },
        )
        .await?
        .expect("the row was live");
        utopia_store::audit::record(
            &f.pool,
            Some(f.kb),
            f.user.id,
            "fact.time_corrected",
            "fact",
            Some(zhang),
            json!({ "note": "The charter date was the approval date" }),
        )
        .await?;

        let chat = ctx(&f, None);
        let mut sink = ToolSink::default();
        for tool in ["entity_facts", "neighbors", "timeline"] {
            let text = dispatch(&chat, &mut sink, tool, &json!({"entity": "Project Aurora"}))
                .await
                .text;
            let zhang_line = line(&text, "Zhang San");
            assert!(
                zhang_line.contains(
                    "2023-02-01 → 2024-07-05, start corrected: The charter date was the approval date)"
                ),
                "{tool}: {text}"
            );
            let li_line = line(&text, "Li Si");
            assert!(
                li_line.contains("2024-07-05 → 2025-09-01, superseded by Zhou Qi ["),
                "{tool}: {text}"
            );
            // 李四那一行也写着周七(关它的是他),所以按周七那一行自己的区间找
            let zhou_line = line(&text, "2025-09-01 → now)");
            assert!(zhou_line.contains("Zhou Qi"), "{tool}: {text}");
            // 本行的号照旧:打开的仍是那条事实读出来的原句。关上李四那段的号打开周七接手的
            // 那一块,那里写着 2025-09-01;周七自己那一行也是它,同一块只有一个号。备注不进清单
            let (z, l, q) = (marks(zhang_line), marks(li_line), marks(zhou_line));
            assert_eq!((z.len(), l.len(), q.len()), (1, 2, 1), "{tool}: {text}");
            assert_eq!(chunk_of(&sink, z[0]), s.charter, "{tool}");
            assert_eq!(chunk_of(&sink, l[0]), update, "{tool}: the closing fact's passage");
            // 那一条带着周七那句原话(#968 的后续):号打开的就是写着 2025-09-01 的那句
            assert_eq!(
                quotes_of(&sink, l[0]),
                ["Zhou Qi leads Project Aurora from 2025-09-01."],
                "{tool}: the closer's entry carries the sentence that states the date"
            );
            assert_eq!(chunk_of(&sink, l[1]), s.handover, "{tool}: the line's own passage");
            assert_eq!(q[0], l[0], "{tool}: one number for one chunk");
            assert!(
                sink.sources
                    .iter()
                    .all(|x| !x.to_string().contains("approval date")),
                "the note is not a source"
            );
        }
        let path = dispatch(
            &chat,
            &mut sink,
            "paths_between",
            &json!({"from": "Wang Wu", "to": "Li Si"}),
        )
        .await
        .text;
        assert!(
            path.contains("2024-07-05 → 2025-09-01, superseded by Zhou Qi ["),
            "{path}"
        );
        // 路径上被人改过的那条边(#976 的评审):同样只说被改的那一端
        let path = dispatch(
            &chat,
            &mut sink,
            "paths_between",
            &json!({"from": "Wang Wu", "to": "Zhang San"}),
        )
        .await
        .text;
        assert!(
            path.contains(
                "2023-02-01 → 2024-07-05, start corrected: The charter date was the approval date"
            ),
            "{path}"
        );

        // MCP 的文字带着同样的标记:它们是这一行的事实,不是引用
        let mcp = ctx(&f, Some(Uuid::now_v7()));
        let plain = dispatch(
            &mcp,
            &mut ToolSink::default(),
            "entity_facts",
            &json!({"entity": "Project Aurora"}),
        )
        .await
        .text;
        assert!(
            plain.contains(", start corrected: The charter date was the approval date)")
                && plain.contains(", superseded by Zhou Qi)"),
            "{plain}"
        );
        assert!(marks(&plain).is_empty(), "{plain}");

        // 规则 4:推出的终点引关它的那一行;推出的与人改的日期都不归到本行的原句,没标记的
        // 那个日期仍是
        assert!(
            SYSTEM_PROMPT.contains("An end written `superseded by X [m]`")
                && SYSTEM_PROMPT.contains("cite [m] for that end, never the line's own [n]")
                && SYSTEM_PROMPT.contains("A line marked `start corrected` or `end corrected`")
                && SYSTEM_PROMPT.contains("a date the line does not mark still is"),
            "{SYSTEM_PROMPT}"
        );

        // 张三再改一次,这回改终点(#976 的评审):两端都是人改的,备注取最近那一次
        let zhang_now = row_of("Zhang San").await?;
        utopia_store::temporal::correct_interval(
            &f.pool,
            zhang_now,
            utopia_store::graph::Validity {
                from: Some(day("2023-02-01T00:00:00Z")),
                from_precision: Some("day"),
                to: Some(day("2024-07-01T00:00:00Z")),
                to_precision: Some("day"),
                attested_at: None,
                from_grade: None,
                end_after_period: false,
            },
        )
        .await?
        .expect("the row was live");
        utopia_store::audit::record(
            &f.pool,
            Some(f.kb),
            f.user.id,
            "fact.time_corrected",
            "fact",
            Some(zhang_now),
            json!({ "note": "The handover was on 1 July" }),
        )
        .await?;
        let text = dispatch(
            &chat,
            &mut ToolSink::default(),
            "entity_facts",
            &json!({"entity": "Project Aurora"}),
        )
        .await
        .text;
        assert!(
            line(&text, "Zhang San")
                .contains("2023-02-01 → 2024-07-01, corrected: The handover was on 1 July)"),
            "{text}"
        );

        // 关上李四那段的那一行没有有效证据了(周七那篇删了,#986 的评审):行上照旧写出是
        // 谁接手,只是不带号,清单里也不多一条;本行的号照旧打开交接那篇
        sqlx::query("UPDATE documents SET deleted_at = now() WHERE id = $1")
            .bind(d_update)
            .execute(&f.pool)
            .await?;
        let mut sink = ToolSink::default();
        for tool in ["entity_facts", "neighbors", "timeline"] {
            let text = dispatch(&chat, &mut sink, tool, &json!({"entity": "Project Aurora"}))
                .await
                .text;
            let li_line = line(&text, "Li Si");
            assert!(
                li_line.contains("2024-07-05 → 2025-09-01, superseded by Zhou Qi)"),
                "{tool}: {text}"
            );
            let l = marks(li_line);
            assert_eq!(l.len(), 1, "{tool}: {text}");
            assert_eq!(chunk_of(&sink, l[0]), s.handover, "{tool}: the line's own passage");
        }
        let path = dispatch(
            &chat,
            &mut sink,
            "paths_between",
            &json!({"from": "Wang Wu", "to": "Li Si"}),
        )
        .await
        .text;
        assert!(
            path.contains("2024-07-05 → 2025-09-01, superseded by Zhou Qi)"),
            "{path}"
        );
        assert!(
            !sink.source_ids.contains(&update.to_string()),
            "a closer without live evidence adds no entry: {:?}",
            sink.sources
        );
        anyhow::Ok(())
    }
    .await;
    f.cleanup().await?;
    run
}