新增: 消息级溯源 P2 切 ai_messages + AI Chat 跑题改进 P0-P2 + 标题诊断 + 苛刻测

消息级溯源 P2(一次性切读 b + 备份保留):
- 批次A 读路径切 ai_messages(state.rs AppState.ai_messages + 映射 ChatMessage↔AiMessageRecord +
  switch/export load 切 + fallback 兜底)
- 批次B 写路径切 ai_messages(replace_conversation 单事务全量重写 + save/clear 切 + 旧 messages 备份)
- 摘要/压缩不改 updated_at(save_conversation touch_updated_at,compress false 防时间分组跳变)

AI Chat 跑题改进 P0-P2(5 改进,治跑题 5 根因,三原则优雅/可靠/易迭代):
- P0 系统提示聚焦(## 聚焦准则独立段)+ 意图接入 loop(filter_tool_defs 收敛工具 29→5-10,三重 fallback)
- P1 压缩增强(compress prompt 主题锚点 + 失败关键词兜底 extract_keyword_summary)+
  工具结果压缩(should_summarize + extract_key_info view-only 不改持久化)
- P2 主题检测(TrackedMessage.topic + 双高置信保守标记 + tokenize 2-gram 修复中文锚点)
- title LLM complete 失败诊断日志(助定位返空根因)
- 跑题 P0 审查🟡修复(Debug 加 Data 域 + threshold 注释)

苛刻测 38 条(边界/对抗:全漂移/全停用词/全错误行/2KB 边界/连续主题切换/中文 2-gram/emoji)
df-ai 227 passed + workspace EXIT 0

crates/df-ai/src/context.rs

@@ -41,6 +41,10 @@ pub struct ContextManager {
     /// 压缩重入标志（F-15 §4.3）：true 表示一次 LLM 压缩正在进行中。
     /// agentic loop 顶部检测，防同一轮内多次触发压缩互相覆盖。纯内存态，不落库。
     is_compressing: bool,
+    /// [P2 改进5] 主题切换检测标记。push user 消息时若发现末两条 user 消息的 topic
+    /// 都非 None 且不同(双高置信),置位本字段,格式 "old|new"。agentic loop 顶部读并
+    /// 消费(insert 系统标记后清空)。纯内存态,不落库。保守:任一 topic 为 None 不置位(宁可漏报)。
+    pending_topic_marker: Option<String>,
 }
 
 impl ContextManager {
@@ -51,6 +55,7 @@ impl ContextManager {
             config,
             estimator: TokenEstimator::default(),
             is_compressing: false,
+            pending_topic_marker: None,
         }
     }
 
@@ -68,10 +73,37 @@ impl ContextManager {
         if message.is_active() {
             self.history_tokens += tokens;
         }
+        // [P2 改进5] 主题推断(仅 user 消息):IntentRecognizer 识别意图,置信 >= 0.7 且
+        // 非 Unknown 则把 Intent 标签存入 TrackedMessage.topic 供主题切换检测。
+        // 保守:低置信(None)不标,避免误报。topic 不参与裁剪/压缩(只供 marker 检测)。
+        let topic: Option<String> = if matches!(message.role, MessageRole::User) {
+            let (intent, conf) = crate::intent::IntentRecognizer::recognize(&message.content);
+            if conf >= 0.7 && !matches!(intent, crate::intent::Intent::Unknown) {
+                Some(intent.as_str().to_string())
+            } else {
+                None
+            }
+        } else {
+            None
+        };
+        // [P2 改进5] 主题切换检测:push 前(本消息即将成末条 user),若已存在一条更早 user
+        // 且本消息 topic 与之都非 None 且不同 → 置位 pending_topic_marker("old|new")。
+        // 双高置信(两条 topic 都非 None)才标,任一 None 不标(宁可漏报不误报)。
+        if matches!(message.role, MessageRole::User) {
+            if let Some(prev_topic) = self.last_user_topic() {
+                if let Some(this_topic) = &topic {
+                    if prev_topic != *this_topic {
+                        self.pending_topic_marker =
+                            Some(format!("{}|{}", prev_topic, this_topic));
+                    }
+                }
+            }
+        }
         self.messages.push(TrackedMessage {
             message,
             token_count: tokens,
             group,
+            topic,
         });
     }
 
@@ -80,6 +112,7 @@ impl ContextManager {
         self.messages.clear();
         self.history_tokens = 0;
         self.is_compressing = false;
+        self.pending_topic_marker = None;
     }
 
     /// 消息数量
@@ -493,6 +526,28 @@ impl ContextManager {
         self.last_message_id_by_role(MessageRole::User)
     }
 
+    // ── [P2 改进5] 主题切换检测(保守,双高置信才标) ──
+
+    /// 取末条 user 消息的 topic 标签(供 push 时主题切换检测)。
+    ///
+    /// 从尾部反向扫描 user 消息,取最近一条 role=User 的 TrackedMessage.topic。
+    /// 老消息(未接改进5 推断)topic=None → 返 None(向前兼容)。无 user 消息 → None。
+    fn last_user_topic(&self) -> Option<String> {
+        self.messages
+            .iter()
+            .rev()
+            .find(|t| matches!(t.message.role, MessageRole::User))
+            .and_then(|t| t.topic.clone())
+    }
+
+    /// 取并消费 pending_topic_marker(供 agentic loop 顶部读 → insert 系统标记 → 清空)。
+    ///
+    /// 返回 "old|new" 格式字符串(push 时末两条 user topic 都非 None 且不同置位)。
+    /// 取出即清空(一次性消费,防同 marker 重复 insert)。无 marker → None。
+    pub fn take_topic_marker(&mut self) -> Option<String> {
+        self.pending_topic_marker.take()
+    }
+
     // ── F-15 上下文管理增强辅助方法（阶段1 基础，零行为变化）──
     //
     // 这些方法供阶段2 IPC（ai_chat_compress_context）/ 阶段3 agentic loop
@@ -525,6 +580,7 @@ impl ContextManager {
             message,
             token_count: tokens,
             group,
+            topic: None,
         });
     }
 
@@ -1278,4 +1334,219 @@ mod tests {
         mgr.push(message);
         id.expect("新构造消息必有 id")
     }
+
+    // ── [P2 改进5] 主题切换检测(保守,双高置信才标) ──
+
+    #[test]
+    fn topic_marker_triggers_on_two_different_high_conf_topics() {
+        // 双高置信:两条 user 消息各自 intent 置信 >= 0.7 且不同 topic → 置位 marker。
+        // "帮我重构这段代码"(Code, conf=1.0) + "创建项目并绑定目录"(Project, conf=1.0)
+        let mut mgr = ContextManager::new(cfg(100_000));
+        mgr.push(ChatMessage::user("帮我重构这段代码"));
+        // 此时只有一条 user,无 marker
+        assert!(mgr.take_topic_marker().is_none(), "首条 user 不触发 marker");
+        mgr.push(ChatMessage::user("创建项目并绑定目录"));
+        let marker = mgr.take_topic_marker()
+            .expect("双不同 topic 应置位 marker");
+        assert!(marker.contains("code"), "old topic 应为 code, 实际: {}", marker);
+        assert!(marker.contains("project"), "new topic 应为 project, 实际: {}", marker);
+        // take 后清空(幂等)
+        assert!(mgr.take_topic_marker().is_none(), "take 后应清空");
+    }
+
+    #[test]
+    fn topic_marker_not_triggered_on_same_topic() {
+        // 同 topic(code/code)→ 不置位(非切换)。
+        let mut mgr = ContextManager::new(cfg(100_000));
+        mgr.push(ChatMessage::user("重构这段代码"));
+        mgr.push(ChatMessage::user("再重构另一段代码"));
+        assert!(mgr.take_topic_marker().is_none(), "同 topic 不应触发 marker");
+    }
+
+    #[test]
+    fn topic_marker_not_triggered_when_either_topic_none() {
+        // 保守:任一 topic 为 None(低置信未标)不置位。
+        // "今天的天气不错"(Unknown, conf=0.0 → topic=None) + "重构代码"(Code, conf 高)
+        let mut mgr = ContextManager::new(cfg(100_000));
+        mgr.push(ChatMessage::user("今天的天气不错啊"));
+        mgr.push(ChatMessage::user("帮我重构这段代码"));
+        assert!(mgr.take_topic_marker().is_none(), "前一条 topic None 不应触发 marker(保守)");
+
+        // 反向:前一条高置信 + 后一条低置信
+        let mut mgr2 = ContextManager::new(cfg(100_000));
+        mgr2.push(ChatMessage::user("帮我重构这段代码"));
+        mgr2.push(ChatMessage::user("嗯嗯好的"));
+        assert!(mgr2.take_topic_marker().is_none(), "后一条 topic None 不应触发 marker(保守)");
+    }
+
+    #[test]
+    fn topic_marker_not_polluting_compression_or_trim() {
+        // topic 字段不参与裁剪/压缩(只检测):超预算裁剪 + 压缩后消息仍正常,
+        // topic 标记独立工作。push 足量消息撑爆小预算触发裁剪。
+        let mut mgr = ContextManager::new(cfg(80));
+        for i in 0..10 {
+            mgr.push(ChatMessage::user(&format!("重构代码第 {} 条长消息撑爆预算", i)));
+        }
+        mgr.push(ChatMessage::user("创建项目并绑定目录")); // Project topic → marker
+        let _ = mgr.take_topic_marker(); // 消费 marker(topic 不影响裁剪)
+        // 裁剪仍正常工作(topic 字段不参与裁剪逻辑)
+        let (msgs, trimmed) = mgr.build_for_request(0);
+        assert!(trimmed);
+        assert!(!msgs.is_empty());
+    }
+
+    #[test]
+    fn topic_field_default_none_in_constructors() {
+        // TrackedMessage.topic 在 push/insert_at 构造时默认 None(push 会按 intent 推断覆盖,
+        // insert_at 始终 None——insert_at 不做主题推断,保守)。
+        let mut mgr = ContextManager::new(cfg(100_000));
+        mgr.insert_at(0, ChatMessage::system("摘要"));
+        // insert_at 的 system 消息 topic=None(role 非 User)
+        assert_eq!(mgr.messages_mut()[0].topic, None);
+    }
+
+    // ===== 苁刻测:主题切换检测对抗/边界/链式 =====
+
+    #[test]
+    fn topic_marker_chained_three_switches_each_triggers() {
+        // 对抗(链式):A→B→C 三次连续主题切换,每次 push 不同 topic 都应置位 marker。
+        // 验证 last_user_topic 反向扫描取最近 user,链式切换逐次触发不漏。
+        let mut mgr = ContextManager::new(cfg(100_000));
+
+        // 1. Code
+        mgr.push(ChatMessage::user("帮我重构这段代码")); // topic=code
+        assert!(mgr.take_topic_marker().is_none(), "首条不触发");
+
+        // 2. Code → Project(切换)
+        mgr.push(ChatMessage::user("创建项目并绑定目录")); // topic=project
+        let m1 = mgr.take_topic_marker().expect("code→project 应触发");
+        assert!(m1.contains("code") && m1.contains("project"), "marker1: {}", m1);
+        assert!(mgr.take_topic_marker().is_none(), "take 后清空");
+
+        // 3. Project → Task(切换)
+        mgr.push(ChatMessage::user("推进这个任务到下一状态")); // topic=task
+        let m2 = mgr.take_topic_marker().expect("project→task 应触发");
+        assert!(m2.contains("project") && m2.contains("task"), "marker2: {}", m2);
+
+        // 4. Task → Http(切换,证链式不因中间穿插断)
+        mgr.push(ChatMessage::user("调用接口请求这个 api")); // topic=http
+        let m3 = mgr.take_topic_marker().expect("task→http 应触发");
+        assert!(m3.contains("task") && m3.contains("http"), "marker3: {}", m3);
+    }
+
+    #[test]
+    fn topic_marker_low_confidence_chain_never_triggers() {
+        // 对抗(低置信链):连续 push 低置信(Unknown)消息 → topic 全 None → 永不置位
+        let mut mgr = ContextManager::new(cfg(100_000));
+        mgr.push(ChatMessage::user("嗯嗯好的")); // Unknown/0.0 → None
+        assert!(mgr.take_topic_marker().is_none());
+        mgr.push(ChatMessage::user("啊这样啊")); // Unknown/0.0 → None
+        assert!(mgr.take_topic_marker().is_none(), "双 None 链不触发");
+        // 再接一条高置信,但前一条 None → 仍不触发(保守:任一 None 即不标)
+        mgr.push(ChatMessage::user("重构这段代码")); // Code/1.0
+        assert!(
+            mgr.take_topic_marker().is_none(),
+            "前一条 topic None,即使本条高置信也不触发(双高置信约束)"
+        );
+    }
+
+    #[test]
+    fn topic_marker_high_then_low_confidence_never_triggers() {
+        // 对抗(反向低置信链):高置信 → 低置信,后一条 None → 不触发
+        let mut mgr = ContextManager::new(cfg(100_000));
+        mgr.push(ChatMessage::user("重构这段代码")); // Code/1.0
+        assert!(mgr.take_topic_marker().is_none());
+        mgr.push(ChatMessage::user("嗯嗯好的")); // Unknown/0.0 → None
+        assert!(
+            mgr.take_topic_marker().is_none(),
+            "后一条 topic None,即使前一条高置信也不触发"
+        );
+    }
+
+    #[test]
+    fn topic_marker_switch_back_to_same_after_different_not_triggered() {
+        // 边界:A→B→A:第二次 A 时,末两条 user 是 B(高)→ A(高),不同 → 应触发。
+        // 验证 last_user_topic 只看最近一条 user,不缓存历史(不会因"曾标过 code"漏判)
+        let mut mgr = ContextManager::new(cfg(100_000));
+        mgr.push(ChatMessage::user("重构这段代码")); // code
+        mgr.push(ChatMessage::user("创建项目并绑定目录")); // project → 触发 code|project
+        let _ = mgr.take_topic_marker();
+        mgr.push(ChatMessage::user("再重构另一段代码")); // code(末两条:project→code 不同)
+        let m = mgr.take_topic_marker().expect("project→code 切回应触发");
+        assert!(m.contains("project") && m.contains("code"), "切回原 topic 也应触发: {}", m);
+    }
+
+    #[test]
+    fn topic_field_survives_compress_old_messages() {
+        // 对抗(topic 跨 compress):compress_old_messages 只改 status,不动 topic 字段。
+        // 压缩后 compressed 消息的 topic 标签保留(向前兼容,DB/内存一致性)。
+        let mut mgr = ContextManager::new(cfg(100_000));
+        mgr.push(ChatMessage::user("重构这段代码")); // idx 0, topic=code
+        mgr.push(ChatMessage::user("读取这个文件")); // idx 1, topic=file
+        mgr.push(ChatMessage::assistant("ok")); // idx 2
+
+        // 压缩 [0,2):idx 0/1 标 compressed
+        let compressed = mgr.compress_old_messages(2);
+        assert_eq!(compressed.len(), 2);
+        // topic 字段保留(compress 不触碰)
+        assert_eq!(mgr.messages_mut()[0].topic.as_deref(), Some("code"), "compressed 消息 topic 应保留");
+        assert_eq!(mgr.messages_mut()[1].topic.as_deref(), Some("file"), "compressed 消息 topic 应保留");
+        // status 改为 compressed
+        assert_eq!(mgr.messages_mut()[0].message.status.as_deref(), Some("compressed"));
+    }
+
+    #[test]
+    fn topic_marker_system_message_in_send_view_under_adequate_budget() {
+        // 边界(marker 端到端):取 marker → 调用方 insert_at 顶 system 标记 →
+        // build_for_request 在充足预算下 system 正常进发送视图(不丢,不 panic)。
+        // 注:build_for_request 裁剪策略裁前部(保护最近 PROTECT_COUNT 条),顶置 system
+        // 在极小预算撑爆时会被裁——这是策略既定行为,非 bug。本测验证充足预算下 marker
+        // 流程端到端正常:marker 取出 + insert system + 发送视图含该 system。
+        let mut mgr = ContextManager::new(cfg(100_000));
+        mgr.push(ChatMessage::user("重构这段代码")); // code
+        mgr.push(ChatMessage::user("创建项目并绑定目录")); // project → marker
+        let marker = mgr.take_topic_marker().expect("应触发 marker");
+        assert!(marker.contains("code") && marker.contains("project"));
+
+        // 调用方据 marker insert system 标记(agentic loop 实际行为)
+        mgr.insert_at(0, ChatMessage::system("[主题切换标记]"));
+        let (msgs, trimmed) = mgr.build_for_request(0);
+        assert!(!trimmed, "充足预算不应裁剪");
+        assert!(
+            msgs.iter().any(|m| m.content.contains("[主题切换标记]")),
+            "marker system 应进发送视图: {:?}",
+            msgs.iter().map(|m| m.content.chars().take(15).collect::<String>()).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn topic_marker_not_triggered_by_assistant_or_tool_messages() {
+        // 边界:只有 user 消息参与主题推断;assistant/tool push 不触发 marker(topic=None)
+        let mut mgr = ContextManager::new(cfg(100_000));
+        mgr.push(ChatMessage::user("重构这段代码")); // code
+        assert!(mgr.take_topic_marker().is_none());
+        // assistant 消息(含 error 关键词但不影响 topic 推断,因 role 非 User)
+        mgr.push(ChatMessage::assistant("编译 error 出现了"));
+        assert!(
+            mgr.take_topic_marker().is_none(),
+            "assistant 消息不参与主题推断,不触发 marker"
+        );
+        // 再 push user(同 code topic)→ 末两条 user 都是 code,不切换
+        mgr.push(ChatMessage::user("继续重构"));
+        assert!(mgr.take_topic_marker().is_none(), "同 topic user 间不切换(assistant 不算)");
+        // 此时末条 user 是 code,切到 project 应触发
+        mgr.push(ChatMessage::user("创建项目并绑定目录"));
+        assert!(mgr.take_topic_marker().is_some(), "code→project 切换应触发(assistant 不打断)");
+    }
+
+    #[test]
+    fn topic_marker_take_is_idempotent_and_clears() {
+        // 边界:take_topic_marker 一次性消费,take 两次第二次必 None(防重复 insert)
+        let mut mgr = ContextManager::new(cfg(100_000));
+        mgr.push(ChatMessage::user("重构这段代码"));
+        mgr.push(ChatMessage::user("创建项目并绑定目录"));
+        let _ = mgr.take_topic_marker().expect("应有 marker");
+        // 第二次 take 必 None
+        assert!(mgr.take_topic_marker().is_none(), "marker 一次性消费, 二次 take 必空");
+    }
 }

crates/df-ai/src/context_helpers.rs

@@ -152,6 +152,9 @@ pub struct TrackedMessage {
     pub message: ChatMessage,
     pub token_count: u32,
     pub group: MessageGroup,
+    /// [P2 改进5] 该消息所属主题标签(意图识别推断,None=未标记)。当前不参与裁剪/压缩,
+    /// 仅供主题切换检测。向前兼容:TrackedMessage 不 Serialize(只 ChatMessage 落库),无 DB 影响。
+    pub topic: Option<String>,
 }
 
 /// 按消息角色与 tool_calls 判定其逻辑分组（淘汰单元的原子性基础）
@@ -171,6 +174,283 @@ pub fn classify_group(msg: &ChatMessage) -> MessageGroup {
     }
 }
 
+// ============================================================
+// 改进3 B: 压缩失败兜底 — 关键词摘要提取(纯函数,无 LLM)
+// ============================================================
+
+/// 压缩失败降级:从消息提取关键词摘要(避免裸裁剪丢主题)。
+///
+/// 当 LLM 压缩失败时,原本只能裸裁剪保最近 6 条(可能丢失用户反复提到的核心
+/// 主题词/实体名)。本函数从 user 消息中提取频次最高的关键词,组装成 system 摘要
+/// 塞回首条,作为续接锚点。
+///
+/// 策略(纯启发式,无 tokenizer 依赖):
+/// - 仅取 user 消息(用户表达意图的载体,assistant 多为操作流水)。
+/// - 按非字母数字下划线汉字边界分词;保留长度 >= 2 的词。
+/// - 去停用词(常见虚词/助词,中英混合)。
+/// - 频次 top-N,频次相同按词长降序(长实体优先),再按字典序稳定。
+/// - 返回 system 文本(空消息/无可提取词 → 空字符串,调用方判空跳过 insert)。
+pub fn extract_keyword_summary(msgs: &[ChatMessage]) -> String {
+    const TOP_N: usize = 10;
+    const MIN_WORD_LEN: usize = 2;
+
+    // 中英混合停用词表(高频虚词/助词/常见无主题意义词)。
+    const STOPWORDS: &[&str] = &[
+        // 中文
+        "的", "了", "是", "在", "我", "有", "和", "就", "不", "人", "都", "一", "一个",
+        "上", "也", "很", "到", "说", "要", "去", "你", "会", "着", "没有", "看", "好",
+        "自己", "这", "那", "这个", "那个", "什么", "怎么", "可以", "应该", "需要",
+        "已经", "现在", "然后", "因为", "所以", "但是", "如果", "虽然", "一下", "一些",
+        // 英文
+        "the", "a", "an", "is", "are", "was", "were", "be", "been", "being", "to", "of",
+        "in", "on", "at", "by", "for", "with", "about", "as", "into", "like", "through",
+        "after", "over", "between", "and", "but", "or", "not", "no", "yes", "if", "then",
+        "this", "that", "these", "those", "it", "its", "i", "you", "he", "she", "we",
+        "they", "them", "my", "your", "his", "her", "our", "their", "do", "does", "did",
+        "have", "has", "had", "will", "would", "can", "could", "should", "may", "might",
+        "please", "help", "want", "need", "make", "use", "get",
+    ];
+
+    use std::collections::HashMap;
+
+    let mut freq: HashMap<String, u32> = HashMap::new();
+    for msg in msgs {
+        // 仅 user 消息参与(assistant/tool 多为操作流水,无主题价值)。
+        if !matches!(msg.role, MessageRole::User) {
+            continue;
+        }
+        for token in tokenize(msg.content.as_str()) {
+            let word = token.trim();
+            if word.chars().count() < MIN_WORD_LEN {
+                continue;
+            }
+            if STOPWORDS.contains(&word) {
+                continue;
+            }
+            *freq.entry(word.to_string()).or_insert(0) += 1;
+        }
+    }
+
+    if freq.is_empty() {
+        return String::new();
+    }
+
+    let mut entries: Vec<(String, u32)> = freq.into_iter().collect();
+    // 排序:频次降序 → 词长降序(长实体优先) → 字典序稳定。
+    entries.sort_by(|a, b| {
+        b.1.cmp(&a.1)
+            .then_with(|| b.0.chars().count().cmp(&a.0.chars().count()))
+            .then_with(|| a.0.cmp(&b.0))
+    });
+
+    let keywords: Vec<&str> = entries.iter().take(TOP_N).map(|(w, _)| w.as_str()).collect();
+    if keywords.is_empty() {
+        return String::new();
+    }
+
+    format!(
+        "[上下文压缩失败兜底摘要] 用户在历史对话中反复提及的关键主题词(作为续接锚点保留):\n{}",
+        keywords.join("、")
+    )
+}
+
+/// 简单分词:按非(字母/数字/下划线/汉字)边界切分,保留连续的词素 + 汉字 2-gram。
+///
+/// 中英混合:连续的拉丁/数字/下划线聚成一个词素(标识符如 build_for_request);
+/// 汉字既作为单字词素,又额外产出 2-gram 相邻汉字词素(如"压缩架构"→"压缩"/"缩架"/"架构"),
+/// 以捕获 2 字常用词(CR-26 🟡1:此前单字全被 MIN_WORD_LEN=2 滤掉,致"压缩/架构/审批"
+/// 这类高频 2 字词在关键词摘要中丢失)。纯启发式,不依赖 jieba(零依赖原则)。
+fn tokenize(s: &str) -> Vec<String> {
+    let mut out: Vec<String> = Vec::new();
+    let mut buf = String::new();
+    let mut prev_class: u8 = 0; // 0=none,1=han,2=word(字母数字_),3=other
+    let mut prev_han: Option<char> = None; // [CR-26] 上一个汉字,供 2-gram 滑窗
+    for ch in s.chars() {
+        let class = if ch.is_alphanumeric() && !is_han(ch) {
+            2
+        } else if is_han(ch) {
+            1
+        } else if ch == '_' {
+            2
+        } else {
+            3
+        };
+        if class == 3 {
+            if !buf.is_empty() {
+                out.push(std::mem::take(&mut buf));
+            }
+            prev_class = 0;
+            prev_han = None; // 非汉字边界重置 2-gram 窗口(不跨边界组词)
+            continue;
+        }
+        // 词素切换:汉字单独成词(每个汉字一个词素,便于统计高频字组),
+        // 但连续拉丁/下划线/数字聚成一个词素(标识符如 build_for_request)。
+        if class == 1 {
+            // 汉字:先冲掉当前 buf(若有),再把单字作为独立词素。
+            if !buf.is_empty() {
+                out.push(std::mem::take(&mut buf));
+            }
+            out.push(ch.to_string());
+            // [CR-26 🟡1] 2-gram 汉字滑窗:与前一个汉字(若连续,prev_class==1)组成 2 字词素。
+            // "压缩架构"→"压缩"/"缩架"/"架构";"压缩 文件"(空格隔开)→"压缩"/"文件",无跨边界 2-gram。
+            if let Some(prev) = prev_han {
+                if prev_class == 1 {
+                    let mut gram = String::new();
+                    gram.push(prev);
+                    gram.push(ch);
+                    out.push(gram);
+                }
+            }
+            prev_han = Some(ch);
+            prev_class = 1;
+        } else {
+            // class == 2:拉丁/数字/下划线聚成连续词素。
+            // 从汉字切换到拉丁或反向时,先冲掉 buf + 重置 2-gram 窗口。
+            if prev_class == 1 {
+                buf.clear();
+            }
+            prev_han = None; // 离开汉字区,2-gram 窗口重置
+            buf.push(ch);
+            prev_class = 2;
+        }
+    }
+    if !buf.is_empty() {
+        out.push(buf);
+    }
+    out
+}
+
+/// 判定是否汉字(统一码 CJK 区间,粗略覆盖常用范围)。
+fn is_han(ch: char) -> bool {
+    matches!(ch as u32,
+        0x4E00..=0x9FFF     // CJK 统一汉字
+        | 0x3400..=0x4DBF   // CJK 扩展 A
+        | 0xF900..=0xFAFF   // CJK 兼容
+    )
+}
+
+// ============================================================
+// 改进4: 工具结果压缩(view-only 摘要化纯函数)
+// ============================================================
+
+/// tool_result 内容触发摘要压缩的大小阈值(字节,~512 行典型输出)。
+pub const TOOL_RESULT_SUMMARIZE_BYTES: usize = 2_048;
+/// tool_result 占历史 token 比例阈值(占比超此值触发摘要)。
+pub const TOOL_RESULT_SUMMARIZE_RATIO: f32 = 0.40;
+/// extract_key_info 保留的首部行数。
+pub const TOOL_RESULT_HEAD_LINES: usize = 5;
+/// extract_key_info 保留的尾部行数。
+pub const TOOL_RESULT_TAIL_LINES: usize = 5;
+
+/// 判断 tool_result 是否需摘要压缩:content >2KB 或 占比 >40%。
+///
+/// - `content_len`:tool_result content 字节数。
+/// - `history_tokens`:当前历史总 token(用于占比判定)。
+/// - `content_tokens`:该 tool_result 自身的 token 估算(供占比)。
+///
+/// 任一阈值触发即压缩。0 history/0 content 不触发(避免除零/空消息误压)。
+pub fn should_summarize_tool_result(
+    content_len: usize,
+    history_tokens: u32,
+    content_tokens: u32,
+) -> bool {
+    if content_len >= TOOL_RESULT_SUMMARIZE_BYTES {
+        return true;
+    }
+    if history_tokens == 0 {
+        return false;
+    }
+    let ratio = content_tokens as f32 / history_tokens as f32;
+    ratio > TOOL_RESULT_SUMMARIZE_RATIO
+}
+
+/// 提取 tool_result 关键信息(纯函数,无 LLM):保留错误行 + 首/尾各若干行,中间省略。
+///
+/// 策略:
+/// - 全文扫一遍,挑出含错误信号的行(`error`/`Error`/`panic`/`失败`/`.rs:N` 文件定位行)。
+/// - 保留首 `TOOL_RESULT_HEAD_LINES` 行 + 末 `TOOL_RESULT_TAIL_LINES` 行(上下文边界)。
+/// - 错误行(在头尾区间外的)额外插入,标注位置。
+/// - 中间大段省略为 `... (省略 N 行) ...`。
+///
+/// `tool_name` 仅用于摘要头注释,不参与内容判断。空 content 返回空字符串。
+pub fn extract_key_info(content: &str, tool_name: &str) -> String {
+    let lines: Vec<&str> = content.lines().collect();
+    if lines.is_empty() {
+        return String::new();
+    }
+
+    // 短内容不压缩(行数不足以省略)。
+    let total = lines.len();
+    let kept_boundary = TOOL_RESULT_HEAD_LINES + TOOL_RESULT_TAIL_LINES;
+    if total <= kept_boundary {
+        return content.to_string();
+    }
+
+    let head_end = TOOL_RESULT_HEAD_LINES;
+    let tail_start = total.saturating_sub(TOOL_RESULT_TAIL_LINES);
+
+    let mut out: Vec<String> = Vec::new();
+    out.push(format!("[工具 {} 输出已压缩: 保留首尾 + 错误行, 共 {} 行]", tool_name, total));
+
+    // 头部。
+    for line in &lines[..head_end] {
+        out.push((*line).to_string());
+    }
+
+    // 中部:扫描错误行(head_end..tail_start 区间内)。
+    let mut error_lines: Vec<(usize, &str)> = Vec::new();
+    for (idx, line) in lines.iter().enumerate() {
+        if idx < head_end || idx >= tail_start {
+            continue;
+        }
+        if is_error_line(line) {
+            error_lines.push((idx, *line));
+        }
+    }
+
+    if error_lines.is_empty() {
+        // 无错误行:单一省略标记。
+        let omitted = tail_start - head_end;
+        out.push(format!("... (省略 {} 行) ...", omitted));
+    } else {
+        // 有错误行:按位置分段省略 + 插入错误行。
+        let mut last = head_end;
+        for (idx, line) in &error_lines {
+            if *idx > last {
+                out.push(format!("... (省略 {} 行) ...", idx - last));
+            }
+            out.push(format!("[行 {}] {}", idx + 1, line));
+            last = idx + 1;
+        }
+        if last < tail_start {
+            out.push(format!("... (省略 {} 行) ...", tail_start - last));
+        }
+    }
+
+    // 尾部。
+    for line in &lines[tail_start..] {
+        out.push((*line).to_string());
+    }
+
+    out.join("\n")
+}
+
+/// 判定一行是否错误信号行(错误信息/panic/失败/源码定位)。
+fn is_error_line(line: &str) -> bool {
+    let lower = line.to_lowercase();
+    if lower.contains("error") || lower.contains("panic") {
+        return true;
+    }
+    if line.contains("失败") || line.contains("错误") || line.contains("异常") {
+        return true;
+    }
+    // 源码定位行:常见 `.rs:NN:` / `.rs:NNN` 格式(rust 编译错误/panic 定位)。
+    if line.contains(".rs:") {
+        return true;
+    }
+    false
+}
+
 // ============================================================
 // 淘汰单元
 // ============================================================
@@ -193,3 +473,460 @@ pub const PROTECT_COUNT: usize = 6;
 /// Anthropic 流式 tool_use 缺 id 时的占位 id 前缀（见 anthropic_compat.rs 170-176）。
 /// 此类 id 必然无匹配 tool_result，是历史中毒的标志，sanitize 时据此剔除畸形三元组。
 pub const TOOL_MISSING_PREFIX: &str = "tool_missing_";
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::provider::ChatMessage;
+
+    // ── 改进3 B: extract_keyword_summary ──
+
+    #[test]
+    fn keyword_summary_empty_messages() {
+        assert_eq!(extract_keyword_summary(&[]), "");
+    }
+
+    #[test]
+    fn keyword_summary_only_assistant_returns_empty() {
+        // 非 user 消息不参与提取。
+        let msgs = vec![
+            ChatMessage::assistant("build_for_request 的实现"),
+            ChatMessage::assistant("另一个 assistant 消息"),
+        ];
+        assert_eq!(extract_keyword_summary(&msgs), "");
+    }
+
+    #[test]
+    fn keyword_summary_chinese_extracts_frequent_terms() {
+        let msgs = vec![
+            ChatMessage::user("帮我看看 build_for_request 的实现"),
+            ChatMessage::assistant("ok"),
+            ChatMessage::user("build_for_request 怎么裁剪的"),
+            ChatMessage::user("build_for_request 这个函数有问题"),
+        ];
+        let summary = extract_keyword_summary(&msgs);
+        assert!(summary.contains("build_for_request"), "应提取高频标识符, 实际: {}", summary);
+        assert!(summary.contains("上下文压缩失败兜底摘要"));
+    }
+
+    #[test]
+    fn keyword_summary_filters_stopwords() {
+        // 全是停用词/单字 → 返回空。
+        let msgs = vec![ChatMessage::user("的 了 是 在 我 有 和")];
+        assert_eq!(extract_keyword_summary(&msgs), "");
+    }
+
+    #[test]
+    fn keyword_summary_mixed_cn_en() {
+        let msgs = vec![
+            ChatMessage::user("检查 ContextManager 的 history_tokens"),
+            ChatMessage::user("ContextManager token 超预算"),
+        ];
+        let summary = extract_keyword_summary(&msgs);
+        assert!(summary.contains("ContextManager"), "应提取英文标识符, 实际: {}", summary);
+        // token 频次 1 也应入榜(去停用词后剩余的有意义词)。
+    }
+
+    // ── CR-26 🟡1: tokenize 2-gram 汉字(中文 2 字词不再被滤掉) ──
+
+    #[test]
+    fn tokenize_chinese_2gram_produces_bigram_terms() {
+        // "压缩架构" 应产出 2-gram 词素 "压缩"/"缩架"/"架构",不再只剩单字。
+        let toks = tokenize("压缩架构");
+        // 2-gram 入榜
+        assert!(toks.contains(&"压缩".to_string()), "应产出 2-gram 压缩, 实际: {:?}", toks);
+        assert!(toks.contains(&"架构".to_string()), "应产出 2-gram 架构, 实际: {:?}", toks);
+        // 单字也并存
+        assert!(toks.contains(&"压".to_string()));
+        assert!(toks.contains(&"构".to_string()));
+    }
+
+    #[test]
+    fn tokenize_chinese_2gram_not_crossing_boundary() {
+        // 空格/标点隔开 → 不跨边界组 2-gram("压缩 文件"→"压缩"/"文件",无"缩文")。
+        let toks = tokenize("压缩 文件");
+        assert!(toks.contains(&"压缩".to_string()));
+        assert!(toks.contains(&"文件".to_string()));
+        assert!(!toks.contains(&"缩文".to_string()), "空格边界不应跨字组 2-gram");
+    }
+
+    #[test]
+    fn tokenize_english_identifier_unchanged() {
+        // 既有英文标识符不被 2-gram 改造:连续拉丁聚成一个词素。
+        let toks = tokenize("build_for_request is cool");
+        assert!(toks.contains(&"build_for_request".to_string()), "标识符应保持完整, 实际: {:?}", toks);
+        assert!(toks.contains(&"is".to_string()));
+        assert!(toks.contains(&"cool".to_string()));
+    }
+
+    #[test]
+    fn keyword_summary_chinese_2gram_terms_in_top() {
+        // CR-26 🟡1 验证:中文 2 字常用词经 2-gram 入榜,不再被 MIN_WORD_LEN=2 滤掉。
+        let msgs = vec![
+            ChatMessage::user("压缩上下文 token 超预算了"),
+            ChatMessage::user("架构需要重构压缩逻辑"),
+        ];
+        let summary = extract_keyword_summary(&msgs);
+        // "压缩"出现两次(2-gram)应入榜;"架构"频次 1 也应有机会。
+        assert!(
+            summary.contains("压缩") || summary.contains("架构"),
+            "中文 2 字词经 2-gram 应入榜, 实际: {}",
+            summary
+        );
+    }
+
+    // ── 改进4: should_summarize_tool_result ──
+
+    #[test]
+    fn should_summarize_short_content_below_byte_threshold() {
+        // 100 字节 + history 充足,占比低 → 不压缩。
+        assert!(!should_summarize_tool_result(100, 10_000, 35));
+    }
+
+    #[test]
+    fn should_summarize_large_bytes_triggers() {
+        // > 2KB 触发。
+        assert!(should_summarize_tool_result(3_000, 100_000, 100));
+    }
+
+    #[test]
+    fn should_summarize_high_ratio_triggers() {
+        // content 占 history 50% > 40% 阈值触发(content_len 未超 2KB)。
+        assert!(should_summarize_tool_result(1_000, 1_000, 500));
+    }
+
+    #[test]
+    fn should_summarize_zero_history_no_panic() {
+        // 0 history + 小 content → 不压缩且不除零 panic。
+        assert!(!should_summarize_tool_result(100, 0, 50));
+    }
+
+    // ── 改进4: extract_key_info ──
+
+    #[test]
+    fn extract_key_info_short_content_unchanged() {
+        let content = "line1\nline2\nline3";
+        assert_eq!(extract_key_info(content, "read_file"), content);
+    }
+
+    #[test]
+    fn extract_key_info_empty_returns_empty() {
+        assert_eq!(extract_key_info("", "read_file"), "");
+    }
+
+    #[test]
+    fn extract_key_info_keeps_head_tail_and_errors() {
+        let mut lines: Vec<String> = (1..=20).map(|i| format!("line {}", i)).collect();
+        // 在中间插入一行 rust 错误定位(第 12 行,索引 11)。
+        lines[11] = "error[E0308]: mismatched types at src/foo.rs:42:13".to_string();
+        let content = lines.join("\n");
+        let result = extract_key_info(&content, "cargo_build");
+        assert!(result.contains("已压缩"), "应含压缩标记, 实际: {}", result);
+        assert!(result.contains("line 1"), "应保留首行");
+        assert!(result.contains("line 20"), "应保留末行");
+        assert!(result.contains("src/foo.rs:42"), "应保留错误行");
+        assert!(result.contains("行 12"), "错误行应标注原始位置");
+        assert!(result.contains("省略"), "应含省略标记");
+    }
+
+    #[test]
+    fn extract_key_info_detects_panic_and_failure() {
+        let lines: Vec<String> = (1..=15)
+            .map(|i| {
+                if i == 8 {
+                    "thread main panicked at lib.rs:10".to_string()
+                } else if i == 9 {
+                    "执行失败".to_string()
+                } else {
+                    format!("row {}", i)
+                }
+            })
+            .collect();
+        let content = lines.join("\n");
+        let result = extract_key_info(&content, "run_cmd");
+        assert!(result.contains("panicked"));
+        assert!(result.contains("lib.rs:10"));
+        assert!(result.contains("执行失败"));
+    }
+
+    #[test]
+    fn extract_key_info_no_errors_single_omission() {
+        // 中间无错误行 → 单一省略标记。
+        let lines: Vec<String> = (1..=20).map(|i| format!("data {}", i)).collect();
+        let content = lines.join("\n");
+        let result = extract_key_info(&content, "list_dir");
+        // 计算省略标记出现次数:中间 10 行省略,应仅 1 个省略段。
+        let omission_count = result.matches("省略").count();
+        assert_eq!(omission_count, 1, "无错误行应单一省略, 实际 {} 次: {}", omission_count, result);
+    }
+
+    // ===== 苛刻测:对抗 + 边界 + 极端 =====
+
+    // ── extract_keyword_summary:对抗/极端 ──
+
+    #[test]
+    fn keyword_summary_no_user_messages_returns_empty_no_panic() {
+        // 极端:全 assistant/tool 消息,无 user → 返空串(不 panic)
+        let msgs = vec![
+            ChatMessage::assistant("我读了文件"),
+            ChatMessage::tool_result("call_1", "{\"ok\":true}"),
+            ChatMessage::assistant("完成"),
+        ];
+        assert_eq!(extract_keyword_summary(&msgs), "");
+    }
+
+    #[test]
+    fn keyword_summary_all_stopwords_returns_empty() {
+        // 对抗(全停用词):user 消息全是"的/了/是/在/我"(单字 + 停用词双过滤)
+        // → 全被滤,返空串
+        let msgs = vec![ChatMessage::user("的 了 是 在 我 有 和 就 不 人 都 一 上")];
+        assert_eq!(extract_keyword_summary(&msgs), "");
+    }
+
+    #[test]
+    fn keyword_summary_single_long_message_caps_top10() {
+        // 极端(单条 10K 字 user):top-10 不超 10,高频词正确入榜。
+        // 构造 20 个不同高频词各重复 5 次 + 大量填充,验证 take(TOP_N=10) 生效。
+        let mut content = String::new();
+        // 20 个候选词,每个写 5 次(词频递减可验排序)
+        let words: Vec<&str> = (0..20).map(|_| "高频词").collect();
+        for (i, w) in words.iter().enumerate() {
+            for _ in 0..5 {
+                content.push_str(w);
+                content.push_str(&format!("序号{} ", i)); // 拉丁数字区分不同实例
+            }
+        }
+        // 填充到 ~10K 字
+        while content.chars().count() < 10_000 {
+            content.push_str("填充内容x ");
+        }
+        let msgs = vec![ChatMessage::user(content)];
+        let summary = extract_keyword_summary(&msgs);
+        // 摘要非空 + 关键词数 <= 10(逗号分隔统计)
+        assert!(summary.contains("上下文压缩失败兜底摘要"));
+        // 取摘要中关键词行(第二行),按"、"切分数
+        let kw_line = summary.lines().nth(1).unwrap_or("");
+        let kw_count = kw_line.split('、').count();
+        assert!(kw_count <= 10, "top-10 应不超 10, 实际 {} 个: {}", kw_count, kw_line);
+        assert!(kw_count >= 1, "应至少提取 1 个关键词");
+    }
+
+    #[test]
+    fn keyword_summary_mixed_cn_en_2gram_and_english_both_ranked() {
+        // 对抗(中英混合 + 2-gram):"read 压缩架构 file" →
+        // 中文 2-gram("压缩"/"架构") + 英文("read"/"file") 均能被 tokenize 产出
+        let toks = tokenize("read 压缩架构 file");
+        assert!(toks.contains(&"压缩".to_string()), "应产 2-gram 压缩, 实际: {:?}", toks);
+        assert!(toks.contains(&"架构".to_string()), "应产 2-gram 架构, 实际: {:?}", toks);
+        assert!(toks.contains(&"read".to_string()));
+        assert!(toks.contains(&"file".to_string()));
+        // 经 extract_keyword_summary(去停用词 + MIN_LEN=2):
+        //   - "read"(4 字母)入榜;"file"(4 字母)入榜
+        //   - "压缩"/"架构"(2 字 2-gram)入榜
+        let msgs = vec![ChatMessage::user("read 压缩架构 file")];
+        let summary = extract_keyword_summary(&msgs);
+        assert!(summary.contains("压缩") || summary.contains("架构"), "中文 2-gram 应入榜: {}", summary);
+        assert!(summary.contains("read"), "英文 read 应入榜: {}", summary);
+        assert!(summary.contains("file"), "英文 file 应入榜: {}", summary);
+    }
+
+    #[test]
+    fn keyword_summary_pure_punctuation_emoji_returns_empty() {
+        // 对抗(纯标点/emoji 无实质词):所有字符非字母数字汉字 → tokenize 返空 → 摘要空
+        let msgs = vec![ChatMessage::user("🎉，。！？...... 😊 👍")];
+        assert_eq!(extract_keyword_summary(&msgs), "");
+    }
+
+    // ── should_summarize_tool_result:边界阈值 ──
+
+    #[test]
+    fn should_summarize_exactly_2048_bytes_triggers() {
+        // 边界:content_len == TOOL_RESULT_SUMMARIZE_BYTES(2048)→ >= 触发(true)
+        assert!(
+            should_summarize_tool_result(TOOL_RESULT_SUMMARIZE_BYTES, 100_000, 1),
+            "刚好 2048 字节(>= 阈值)应触发"
+        );
+    }
+
+    #[test]
+    fn should_summarize_just_below_2048_no_trigger_when_low_ratio() {
+        // 边界:content_len = 2047(< 2048)+ 占比极低 → 不触发
+        assert!(
+            !should_summarize_tool_result(TOOL_RESULT_SUMMARIZE_BYTES - 1, 100_000, 1),
+            "2047 字节 + 低占比不应触发"
+        );
+    }
+
+    #[test]
+    fn should_summarize_zero_history_zero_content_no_panic() {
+        // 极端:history=0 + content_len=0 + content_tokens=0 → 不触发,不除零 panic
+        assert!(!should_summarize_tool_result(0, 0, 0));
+    }
+
+    #[test]
+    fn should_summarize_zero_history_below_byte_threshold_no_trigger() {
+        // 边界:history=0(除零短路返 false)+ content_len < 2048 → 不触发
+        // (history=0 时占比分支被短路,只看字节阈值)
+        assert!(!should_summarize_tool_result(500, 0, 999_999), "history=0 时占比分支短路,字节未超不触发");
+    }
+
+    #[test]
+    fn should_summarize_ratio_exactly_40_percent_no_trigger() {
+        // 边界(严格 >):占比 == 0.40 不触发(用 > 而非 >=)。
+        // content_tokens / history_tokens = 40/100 = 0.40,严格大于判定为 false。
+        // 但 f32 精度:40/100=0.4 精确,0.4 > 0.40 → false。
+        assert!(
+            !should_summarize_tool_result(100, 100, 40),
+            "占比 == 40% 不触发(严格 >), 实际占比 {}",
+            40.0_f32 / 100.0_f32
+        );
+    }
+
+    #[test]
+    fn should_summarize_ratio_just_above_40_percent_triggers() {
+        // 边界:占比略超 40% → 触发。content_len < 2048 走占比分支。
+        // 41/100 = 0.41 > 0.40 → true
+        assert!(
+            should_summarize_tool_result(100, 100, 41),
+            "占比 41% > 40% 应触发"
+        );
+    }
+
+    // ── extract_key_info:对抗(全错误行/单行超长) ──
+
+    #[test]
+    fn extract_key_info_all_error_lines_preserved() {
+        // 对抗(全错误行):行数 > HEAD+TAIL(11),且每行都含 error → 全保留不省略
+        let lines: Vec<String> = (1..=15).map(|i| format!("error: failure {}", i)).collect();
+        let content = lines.join("\n");
+        let result = extract_key_info(&content, "run_cmd");
+        // 15 行全含 error,首 5(头) + 末 5(尾)区间外 5 行也全是 error → 全部保留
+        for i in 1..=15 {
+            assert!(
+                result.contains(&format!("failure {}", i)),
+                "错误行 failure {} 应保留, result: {}",
+                i,
+                result
+            );
+        }
+        // 不应出现省略(全错误行被插入,无中间省略段)
+        assert!(!result.contains("省略"), "全错误行不应省略, result: {}", result);
+    }
+
+    #[test]
+    fn extract_key_info_single_line_no_newline_unchanged() {
+        // 边界(无换行):单行(无 \n)→ lines() 返 1 行,total <= kept_boundary → 原样返回
+        let content = "single line no newline";
+        assert_eq!(extract_key_info(content, "read_file"), content);
+    }
+
+    #[test]
+    fn extract_key_info_single_huge_line_no_newline_unchanged() {
+        // 极端(单行 50KB 无换行):lines() 返 1 行 → 原样返回(不走首尾切分)
+        let content = "x".repeat(50_000);
+        let result = extract_key_info(&content, "read_file");
+        assert_eq!(result, content, "单行无换行应原样返回(即使超长)");
+    }
+
+    #[test]
+    fn extract_key_info_exactly_head_tail_boundary_no_compression() {
+        // 边界:行数 == HEAD+TAIL(10)→ total <= kept_boundary → 原样返回(不压缩)
+        let lines: Vec<String> = (1..=10).map(|i| format!("line {}", i)).collect();
+        let content = lines.join("\n");
+        let result = extract_key_info(&content, "read_file");
+        assert_eq!(result, content, "10 行(== HEAD+TAIL)应原样不压缩");
+    }
+
+    #[test]
+    fn extract_key_info_eleven_lines_triggers_compression() {
+        // 边界:行数 == 11(刚超 kept_boundary=10)→ 触发压缩,含标记
+        let lines: Vec<String> = (1..=11).map(|i| format!("line {}", i)).collect();
+        let content = lines.join("\n");
+        let result = extract_key_info(&content, "read_file");
+        assert!(result.contains("已压缩"), "11 行应触发压缩");
+        assert!(result.contains("line 1"), "保留首行");
+        assert!(result.contains("line 11"), "保留末行");
+    }
+
+    #[test]
+    fn extract_key_info_error_line_outside_boundary_kept_with_index() {
+        // 边界:错误行恰在头部区间内(idx < head_end)→ 不重复插入(头部已含)
+        // 错误行在尾部区间内(idx >= tail_start)→ 不重复插入(尾部已含)
+        // 错误行在中间区间 → 标注 [行 N] 插入
+        let mut lines: Vec<String> = (1..=20).map(|i| format!("norm {}", i)).collect();
+        // idx=2(头部区间 [0,5))错误行 → 头部已含,不在 error_lines(扫描跳过 head/tail)
+        lines[2] = "error in head zone".to_string();
+        // idx=18(尾部区间 [15,20))错误行 → 尾部已含
+        lines[18] = "error in tail zone".to_string();
+        // idx=10(中间)错误行 → 标注插入
+        lines[10] = "error in middle".to_string();
+        let content = lines.join("\n");
+        let result = extract_key_info(&content, "read_file");
+        // 中间错误行被标注插入(原始行号 11)
+        assert!(result.contains("[行 11] error in middle"), "中间错误行应标注插入: {}", result);
+        // 头/尾错误行原样保留(无 [行 N] 标注)
+        assert!(result.contains("error in head zone"));
+        assert!(result.contains("error in tail zone"));
+    }
+
+    // ── tokenize:对抗(中文长实体/emoji/全角/混合标点) ──
+
+    #[test]
+    fn tokenize_chinese_long_entity_produces_overlapping_2grams() {
+        // 对抗(中文长实体):"跨端架构设计"(5 字)→
+        // 单字:跨/端/架/构/设/计(6 个?不,5 字 5 个单字)
+        // 2-gram:跨端/端架/架构/构建/设计(5 个,相邻滑窗)
+        let toks = tokenize("跨端架构设计");
+        // 单字
+        for ch in "跨端架构设计".chars() {
+            assert!(toks.contains(&ch.to_string()), "单字 {} 应产出: {:?}", ch, toks);
+        }
+        // 2-gram(相邻滑窗)
+        assert!(toks.contains(&"跨端".to_string()), "应含 2-gram 跨端: {:?}", toks);
+        assert!(toks.contains(&"端架".to_string()), "应含 2-gram 端架: {:?}", toks);
+        assert!(toks.contains(&"架构".to_string()), "应含 2-gram 架构: {:?}", toks);
+        // 相邻滑窗:构→设 相邻产 2-gram "构设"(非"构建",构建非相邻字)
+        assert!(toks.contains(&"构设".to_string()), "应含 2-gram 构设(相邻滑窗): {:?}", toks);
+        assert!(toks.contains(&"设计".to_string()), "应含 2-gram 设计: {:?}", toks);
+    }
+
+    #[test]
+    fn tokenize_emoji_and_fullwidth_punctuation_excluded() {
+        // 对抗(emoji/全角标点):🎉/，/。非字母数字汉字 → class=3 → 不入词素,重置 2-gram 窗口
+        let toks = tokenize("架构，🎉设计");
+        // "架构"(，前)、"设计"(🎉后)各成 2-gram;全角逗号/emoji 隔断,无"构设"跨边界 2-gram
+        assert!(toks.contains(&"架构".to_string()));
+        assert!(toks.contains(&"设计".to_string()));
+        assert!(!toks.contains(&"构设".to_string()), "emoji/全角标点应隔断 2-gram");
+        // emoji 本身不入词素
+        assert!(!toks.iter().any(|t| t.contains('🎉')), "emoji 不应入词素: {:?}", toks);
+    }
+
+    #[test]
+    fn tokenize_mixed_punctuation_separates_latin_words() {
+        // 对抗(混合标点分隔):"a,b,c" → 逗号分隔 → "a"/"b"/"c" 三个独立词素
+        // (但单字母 a/b/c 因 MIN_WORD_LEN=2 在 summary 阶段被滤,tokenize 层应产出)
+        let toks = tokenize("a,b,c");
+        assert!(toks.contains(&"a".to_string()));
+        assert!(toks.contains(&"b".to_string()));
+        assert!(toks.contains(&"c".to_string()));
+        // 不应有 "abc" 或 "a,b" 这种带标点的聚合
+        assert!(!toks.iter().any(|t| t.contains(',')), "标点不应聚入词素: {:?}", toks);
+    }
+
+    #[test]
+    fn tokenize_empty_string_returns_empty() {
+        // 极端:空串 → 空 Vec(不 panic)
+        let toks = tokenize("");
+        assert!(toks.is_empty());
+    }
+
+    #[test]
+    fn tokenize_underscore_keeps_identifier() {
+        // 边界:下划线属 class=2,标识符 build_for_request 保持完整
+        let toks = tokenize("call build_for_request now");
+        assert!(toks.contains(&"build_for_request".to_string()));
+        assert!(toks.contains(&"call".to_string()));
+        assert!(toks.contains(&"now".to_string()));
+    }
+}

crates/df-ai/src/intent.rs

@@ -337,11 +337,11 @@ fn best_in_group(message: &str, group: &[IntentGroup]) -> Option<(Intent, f32)>
 ///
 /// 设计：Code → [file, http]；File → [file]；Project/Task/Idea → [data]；
 /// Http → [http]；Search → [file]（含 search_files）；Conversation → [];
-/// Chat → []；Debug → [file, http]（调试常需读文件+查 API）；Unknown → []（全量）。
+/// Chat → []；Debug → [file, http, data]（调试常需读文件+查 API+查任务/工作流状态,CR-25 审查🟡-1 加 data 防"调试任务"丢 Data 工具）；Unknown → []（全量）。
 pub fn tool_subset_for(intent: &Intent) -> Vec<&'static str> {
     let domains: &[ToolDomain] = match intent {
         Intent::Code => &[ToolDomain::File, ToolDomain::Http],
-        Intent::Debug => &[ToolDomain::File, ToolDomain::Http],
+        Intent::Debug => &[ToolDomain::File, ToolDomain::Http, ToolDomain::Data],
         Intent::File => &[ToolDomain::File],
         Intent::Project => &[ToolDomain::Data],
         Intent::Task => &[ToolDomain::Data],
@@ -378,6 +378,34 @@ pub fn suggested_model_tier(_intent: &Intent) -> Option<ModelTier> {
     None
 }
 
+// ---- 工具子集过滤（agentic loop 接入用，改进2 A） -----------------------------
+
+/// 按意图过滤 `tool_defs`：subset 非空只留命中，空返回全量（低置信/Unknown/Chat fallback）。
+///
+/// **接入语义**（改进2 B）：agentic loop 在调用 LLM 前用本函数收敛 LLM 可见工具集，
+/// 减少跑题（如纯闲聊不暴露文件操作工具）。三重 fallback 保证安全：
+/// 1. `tool_subset_for(intent)` 空（Chat/Unknown/Conversation）→ 返回 `all_defs` 全量。
+/// 2. subset 工具名在 `all_defs` 找不到 → 跳过该名（防 registry 漂移导致过滤后为空）。
+/// 3. 调用方再做「过滤后 < 3 条 → 回全量」的兜底（见 agentic loop）。
+///
+/// **关键安全**：filter 仅影响 LLM 可见 tool_defs，**不影响执行**（audit 走 tools_arc
+/// get/execute 完整 registry，LLM 即使幻觉一个被滤掉的工具名，audit 也能查到/拒绝）。
+pub fn filter_tool_defs(
+    all_defs: &[df_ai_core::types::ToolDefinition],
+    intent: &Intent,
+) -> Vec<df_ai_core::types::ToolDefinition> {
+    let subset = tool_subset_for(intent);
+    if subset.is_empty() {
+        return all_defs.to_vec();
+    }
+    let allowed: std::collections::HashSet<&str> = subset.iter().copied().collect();
+    all_defs
+        .iter()
+        .filter(|d| allowed.contains(d.function.name.as_str()))
+        .cloned()
+        .collect()
+}
+
 // ---- 单测 -------------------------------------------------------------------
 
 #[cfg(test)]
@@ -679,4 +707,234 @@ mod tests {
         let (i, _) = IntentRecognizer::recognize("hi");
         assert_eq!(i, Intent::Chat);
     }
+
+    // --- filter_tool_defs（改进2 A） ---
+
+    /// 构造测试用 ToolDefinition（仅 name 有意义，description/parameters 填占位）。
+    fn tool_def(name: &str) -> df_ai_core::types::ToolDefinition {
+        df_ai_core::types::ToolDefinition {
+            tool_type: "function".to_string(),
+            function: df_ai_core::types::ToolFunction {
+                name: name.to_string(),
+                description: String::new(),
+                parameters: serde_json::json!({}),
+            },
+        }
+    }
+
+    #[test]
+    fn filter_subset_empty_returns_all_for_unknown() {
+        // Unknown → subset 空 → fallback 全量
+        let all = vec![tool_def("read_file"), tool_def("create_project")];
+        let out = filter_tool_defs(&all, &Intent::Unknown);
+        assert_eq!(out.len(), all.len(), "Unknown subset 空应回全量");
+    }
+
+    #[test]
+    fn filter_subset_empty_returns_all_for_chat() {
+        // Chat → subset 空 → fallback 全量（低意图/闲聊不收敛）
+        let all = vec![tool_def("read_file"), tool_def("write_file")];
+        let out = filter_tool_defs(&all, &Intent::Chat);
+        assert_eq!(out.len(), all.len(), "Chat subset 空应回全量");
+    }
+
+    #[test]
+    fn filter_subset_empty_returns_all_for_conversation() {
+        let all = vec![tool_def("read_file")];
+        let out = filter_tool_defs(&all, &Intent::Conversation);
+        assert_eq!(out.len(), 1, "Conversation subset 空应回全量");
+    }
+
+    #[test]
+    fn filter_subset_hit_filters_to_matching() {
+        // File 意图 subset = File domain(read_file/write_file/...);Http 工具应被滤掉
+        let all = vec![
+            tool_def("read_file"),
+            tool_def("write_file"),
+            tool_def("http_request"), // 不在 File domain
+        ];
+        let out = filter_tool_defs(&all, &Intent::File);
+        assert!(out.iter().any(|d| d.function.name == "read_file"));
+        assert!(out.iter().any(|d| d.function.name == "write_file"));
+        assert!(
+            !out.iter().any(|d| d.function.name == "http_request"),
+            "File 意图不应含 http_request"
+        );
+        assert_eq!(out.len(), 2);
+    }
+
+    #[test]
+    fn filter_subset_drift_skips_missing_names() {
+        // subset 命中但 all_defs 里没有对应工具(registry 漂移)→ 跳过,不 panic
+        // Project 意图 subset = Data domain(create_project/...),all 里只放了一个 Data 工具 + 一个无关工具
+        let all = vec![
+            tool_def("create_project"),  // 命中
+            tool_def("http_request"),    // 不在 Data domain,滤掉
+            // 其余 Data domain 工具名在 subset 里但 all 没有 → 跳过
+        ];
+        let out = filter_tool_defs(&all, &Intent::Project);
+        assert_eq!(out.len(), 1);
+        assert_eq!(out[0].function.name, "create_project");
+    }
+
+    #[test]
+    fn filter_all_drift_returns_empty_not_panic() {
+        // 极端漂移:subset 命中但 all_defs 完全不交集 → 返回空(调用方做 <3 回全量兜底)
+        let all = vec![tool_def("totally_unknown_tool")];
+        let out = filter_tool_defs(&all, &Intent::File);
+        assert!(out.is_empty(), "全部漂移应返空(交调用方兜底)");
+    }
+
+    #[test]
+    fn filter_preserves_input_order_for_matching() {
+        // 过滤后顺序应跟 all_defs 一致(filter 保留原序)
+        let all = vec![
+            tool_def("write_file"),
+            tool_def("read_file"),
+            tool_def("patch_file"),
+            tool_def("http_request"),
+        ];
+        let out = filter_tool_defs(&all, &Intent::File);
+        let names: Vec<&str> = out.iter().map(|d| d.function.name.as_str()).collect();
+        assert_eq!(names, vec!["write_file", "read_file", "patch_file"]);
+    }
+
+    // ===== 苛刻测:对抗 + 边界 + 极端(filter_tool_defs / tool_subset_for) =====
+
+    #[test]
+    fn filter_total_drift_subset_names_none_in_registry_returns_empty_no_panic() {
+        // 对抗:registry 全改名(File subset 工具名一个不在 all_defs)
+        // → filter 返空 Vec(调用方 <3 回全量兜底)。证不 panic。
+        let all = vec![
+            tool_def("renamed_read_file_v2"),
+            tool_def("totally_other_tool"),
+            tool_def("weird_name_xyz"),
+        ];
+        let out = filter_tool_defs(&all, &Intent::File);
+        assert!(out.is_empty(), "全漂移应返空(交调用方兜底), 实际: {}", out.len());
+    }
+
+    #[test]
+    fn filter_partial_drift_keeps_only_intersecting() {
+        // 对抗:subset 含 N 个工具名,all_defs 只命中其中 2 个,其余跳过(不 panic,不补全)
+        let all = vec![
+            tool_def("read_file"),
+            tool_def("patch_file"),
+            tool_def("unrelated_thing"),
+        ];
+        let out = filter_tool_defs(&all, &Intent::File);
+        let names: Vec<&str> = out.iter().map(|d| d.function.name.as_str()).collect();
+        assert_eq!(names, vec!["read_file", "patch_file"], "部分漂移只留交集, 顺序跟 all");
+    }
+
+    #[test]
+    fn filter_empty_all_defs_no_panic() {
+        // 极端:all_defs 空(无工具注册)。无论 intent 怎样都不 panic,返空 Vec。
+        let empty: Vec<_> = vec![];
+        let out_unknown = filter_tool_defs(&empty, &Intent::Unknown);
+        let out_file = filter_tool_defs(&empty, &Intent::File);
+        assert!(out_unknown.is_empty());
+        assert!(out_file.is_empty(), "空 registry + File 意图应返空不 panic");
+    }
+
+    #[test]
+    fn filter_debug_subset_spans_three_domains_complete() {
+        // 对抗(多 domain):Debug subset 跨 File + Http + Data 三 domain,
+        // 必须同条消息里能同时命中三个 domain 的工具(防 domain 漏挂)
+        let all = vec![
+            // Data domain
+            tool_def("list_tasks"),
+            tool_def("create_project"),
+            tool_def("run_workflow"),
+            // File domain
+            tool_def("read_file"),
+            tool_def("patch_file"),
+            // Http domain
+            tool_def("http_request"),
+        ];
+        let out = filter_tool_defs(&all, &Intent::Debug);
+        let names: Vec<String> = out.iter().map(|d| d.function.name.clone()).collect();
+        assert!(names.contains(&"list_tasks".to_string()), "Debug 必含 Data(list_tasks), 防 CR-25 🟡-1 丢 Data");
+        assert!(names.contains(&"read_file".to_string()), "Debug 必含 File");
+        assert!(names.contains(&"http_request".to_string()), "Debug 必含 Http");
+        assert_eq!(names.len(), 6, "三 domain 工具全保留, 实际: {:?}", names);
+    }
+
+    #[test]
+    fn filter_low_confidence_unknown_subset_empty_falls_back_full() {
+        // 对抗(低置信):"帮我看看这个"无任何关键词 → recognize 返 Unknown/0.0
+        // → tool_subset_for(Unknown) 空 → filter 返全量(fallback 链完整)
+        let (intent, conf) = IntentRecognizer::recognize("帮我看看这个");
+        assert_eq!(intent, Intent::Unknown, "无关键词应 Unknown");
+        assert_eq!(conf, 0.0, "置信度应 0.0");
+        assert!(tool_subset_for(&intent).is_empty(), "Unknown subset 应空");
+
+        let all = vec![tool_def("read_file"), tool_def("write_file"), tool_def("http_request")];
+        let out = filter_tool_defs(&all, &intent);
+        assert_eq!(out.len(), all.len(), "Unknown/低置信应回全量 fallback");
+    }
+
+    #[test]
+    fn subset_all_intents_covered_names_in_registry() {
+        // 对抗(完整性):遍历所有 Intent 的 subset,每个工具名都能在对应 ToolDomain.tools() 找到。
+        // 防 subset 表写错工具名(如 read_filez 笔误)。subset 工具名必须真存在于其声明 domain。
+        let all_intents = [
+            Intent::Code,
+            Intent::Debug,
+            Intent::File,
+            Intent::Project,
+            Intent::Task,
+            Intent::Idea,
+            Intent::Conversation,
+            Intent::Search,
+            Intent::Http,
+            Intent::Chat,
+            Intent::Unknown,
+        ];
+        for intent in all_intents {
+            let subset = tool_subset_for(&intent);
+            // 全 registry 工具名(三 domain 并集)
+            let registry: std::collections::HashSet<&str> = ToolDomain::Data
+                .tools()
+                .iter()
+                .chain(ToolDomain::File.tools().iter())
+                .chain(ToolDomain::Http.tools().iter())
+                .copied()
+                .collect();
+            for name in &subset {
+                assert!(
+                    registry.contains(*name),
+                    "Intent {:?} subset 含工具名 {} 不在任何 domain 注册表",
+                    intent,
+                    name
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn filter_subset_correct_intent_for_multi_domain_message() {
+        // 对抗(跨 domain 完整):"调试任务并读文件"意图多 domain,
+        // 但 recognize 按优先级定单一 intent,filter 据此收敛。
+        // 关键:无论 recognize 落哪个 intent,该 intent 的 subset 必须覆盖任务+文件相关工具。
+        let (intent, conf) = IntentRecognizer::recognize("调试这个任务");
+        // "调试"(Debug/SPECIFIC, 1.0) 优先于 "任务"(Task/ENTITY)
+        assert_eq!(intent, Intent::Debug);
+        assert!(conf >= 0.7);
+        let subset = tool_subset_for(&intent);
+        // Debug subset 必含 list_tasks(Data) + read_file(File) 防"调试任务"丢工具
+        assert!(subset.contains(&"list_tasks"), "Debug 应含 list_tasks(Data domain)");
+        assert!(subset.contains(&"read_file"), "Debug 应含 read_file(File domain)");
+    }
+
+    #[test]
+    fn subset_code_and_debug_dedup_http_across_domains() {
+        // 边界:Code = [File, Http], Debug = [File, Http, Data]
+        // File + Http 都含 http_request,必须去重(subset 内不重复)
+        for intent in [Intent::Code, Intent::Debug] {
+            let s = tool_subset_for(&intent);
+            let http_count = s.iter().filter(|n| **n == "http_request").count();
+            assert_eq!(http_count, 1, "Intent {:?} subset http_request 应去重为 1", intent);
+        }
+    }
 }

crates/df-storage/src/crud/message_repo.rs

@@ -186,6 +186,61 @@ impl AiMessageRepo {
         .map_err(storage_err)?
     }
 
+    /// 全量重写对话的消息(单事务 DELETE + INSERT OR IGNORE,原子)。
+    ///
+    /// F-260619-03 批次 B(save_conversation 写路径切 ai_messages)的核心方法:
+    /// 全量重写语义——以入参 records 为该对话的**唯一真相**,先删该 conv 全部旧行再批量插。
+    /// 单事务保证「删 + 插」原子,无中间空窗(reload 不会读到半删半插的中间态)。
+    ///
+    /// 设计权衡(非 dirty 增量,留 P2.1 优化):
+    /// - 内存 ContextManager 是运行时真相源,save 是同步点,每轮 save 全量回写简单可靠;
+    /// - INSERT OR IGNORE 幂等:records 内 id 重复或与残留行(理论不应有,事务已 DELETE)冲突跳过;
+    /// - 入参 records 的 conversation_id 应一致(调用方 save_conversation 保证),本方法不校验。
+    ///
+    /// 返回 Ok(()) —— 不返回受影响行数(DELETE + INSERT 两条计数语义混乱,调用方只关心成功)。
+    pub async fn replace_conversation(
+        &self,
+        conv_id: &str,
+        records: Vec<AiMessageRecord>,
+    ) -> Result<()> {
+        let conn = self.conn.clone();
+        let conv_id = conv_id.to_owned();
+        tokio::task::spawn_blocking(move || -> Result<()> {
+            let mut guard = conn.blocking_lock();
+            let tx = guard.transaction().map_err(storage_err)?;
+            {
+                // 先删该 conv 全部旧行(全量重写语义)
+                tx.execute(
+                    "DELETE FROM ai_messages WHERE conversation_id = ?1",
+                    params![conv_id],
+                )
+                .map_err(storage_err)?;
+                // 再批量插新行(INSERT OR IGNORE 幂等,id 冲突跳过)
+                if !records.is_empty() {
+                    let mut stmt = tx.prepare(
+                        "INSERT OR IGNORE INTO ai_messages
+                         (id, conversation_id, seq, role, content, parts, tool_call_id,
+                          tool_calls, model, status, reasoning_content, timestamp, created_at)
+                         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13)",
+                    )
+                    .map_err(storage_err)?;
+                    for rec in &records {
+                        stmt.execute(params![
+                            rec.id, rec.conversation_id, rec.seq, rec.role, rec.content,
+                            rec.parts, rec.tool_call_id, rec.tool_calls, rec.model, rec.status,
+                            rec.reasoning_content, rec.timestamp, rec.created_at
+                        ])
+                        .map_err(storage_err)?;
+                    }
+                }
+            }
+            tx.commit().map_err(storage_err)?;
+            Ok(())
+        })
+        .await
+        .map_err(storage_err)?
+    }
+
     /// 按 tool_call_id 定点更新消息 content(replace_tool_result_content 用)。
     ///
     /// 返回是否实际更新(0 = 该 tool_call_id 在此对话无对应消息)。
@@ -365,4 +420,162 @@ mod tests {
         let got = repo.list_by_conversation("c").await.expect("list");
         assert_eq!(got[0].content, "替换后的结果", "其他消息不应被改");
     }
+
+    // ---------- replace_conversation(F-260619-03 批次 B)----------
+
+    /// replace_conversation 全量重写:删旧 + 插新原子,list 一致
+    #[tokio::test]
+    async fn replace_conversation_full_rewrite() {
+        let db = Database::open_in_memory().await.expect("open_in_memory");
+        let repo = AiMessageRepo::new(&db);
+
+        // 预置旧数据(将被 replace 删除)
+        repo.insert_batch(vec![
+            mk_msg("old_0", "conv", 0, "user", "旧0"),
+            mk_msg("old_1", "conv", 1, "user", "旧1"),
+        ])
+        .await
+        .expect("insert old");
+
+        // replace 成全新内容(完全不同的 id,旧 id 应被删)
+        let now = now_millis_str();
+        let records = vec![
+            AiMessageRecord {
+                id: "new_0".into(),
+                conversation_id: "conv".into(),
+                seq: 0,
+                role: "user".into(),
+                content: "新0".into(),
+                parts: None,
+                tool_call_id: None,
+                tool_calls: None,
+                model: Some("deepseek-chat".into()),
+                status: "active".into(),
+                reasoning_content: Some("思考".into()),
+                timestamp: Some(1700000000000),
+                created_at: now.clone(),
+            },
+            AiMessageRecord {
+                id: "new_1".into(),
+                conversation_id: "conv".into(),
+                seq: 1,
+                role: "assistant".into(),
+                content: "新1".into(),
+                parts: None,
+                tool_call_id: None,
+                tool_calls: Some(r#"[{"id":"c1","type":"function","function":{"name":"f","arguments":"{}"}}]"#.into()),
+                model: None,
+                status: "active".into(),
+                reasoning_content: None,
+                timestamp: None,
+                created_at: now,
+            },
+        ];
+        repo.replace_conversation("conv", records).await.expect("replace");
+
+        let got = repo.list_by_conversation("conv").await.expect("list");
+        assert_eq!(got.len(), 2, "旧 2 条应被删,新 2 条入");
+        assert_eq!(got[0].id, "new_0");
+        assert_eq!(got[0].content, "新0");
+        assert_eq!(got[0].model.as_deref(), Some("deepseek-chat"));
+        assert_eq!(got[0].reasoning_content.as_deref(), Some("思考"));
+        assert_eq!(got[1].id, "new_1");
+        assert!(got[1].tool_calls.is_some());
+
+        // 确认旧 id 已删
+        let ids: Vec<&str> = got.iter().map(|r| r.id.as_str()).collect();
+        assert!(!ids.contains(&"old_0") && !ids.contains(&"old_1"));
+    }
+
+    /// replace_conversation 空列表 = 清空该对话消息(单事务 DELETE 不插)
+    #[tokio::test]
+    async fn replace_conversation_empty_clears() {
+        let db = Database::open_in_memory().await.expect("open_in_memory");
+        let repo = AiMessageRepo::new(&db);
+        repo.insert_batch(vec![
+            mk_msg("m0", "c", 0, "user", "0"),
+            mk_msg("m1", "c", 1, "user", "1"),
+        ])
+        .await
+        .expect("insert");
+
+        repo.replace_conversation("c", vec![]).await.expect("replace empty");
+        let got = repo.list_by_conversation("c").await.expect("list");
+        assert!(got.is_empty(), "空 records 应清空对话");
+    }
+
+    /// replace_conversation 对话隔离:两 conv 并发写不串
+    #[tokio::test]
+    async fn replace_conversation_isolation_between_convs() {
+        let db = Database::open_in_memory().await.expect("open_in_memory");
+        let repo = AiMessageRepo::new(&db);
+
+        // 预置 conv_a 与 conv_b
+        repo.insert_batch(vec![mk_msg("a0", "conv_a", 0, "user", "a0")])
+            .await
+            .expect("insert a");
+        repo.insert_batch(vec![mk_msg("b0", "conv_b", 0, "user", "b0")])
+            .await
+            .expect("insert b");
+
+        // 只 replace conv_a,conv_b 不应被影响
+        let now = now_millis_str();
+        repo.replace_conversation(
+            "conv_a",
+            vec![AiMessageRecord {
+                id: "a_new".into(),
+                conversation_id: "conv_a".into(),
+                seq: 0,
+                role: "user".into(),
+                content: "a_new".into(),
+                parts: None,
+                tool_call_id: None,
+                tool_calls: None,
+                model: None,
+                status: "active".into(),
+                reasoning_content: None,
+                timestamp: None,
+                created_at: now,
+            }],
+        )
+        .await
+        .expect("replace a");
+
+        let got_a = repo.list_by_conversation("conv_a").await.expect("list a");
+        assert_eq!(got_a.len(), 1);
+        assert_eq!(got_a[0].id, "a_new", "conv_a 应被全量重写");
+
+        let got_b = repo.list_by_conversation("conv_b").await.expect("list b");
+        assert_eq!(got_b.len(), 1, "conv_b 不应被影响");
+        assert_eq!(got_b[0].id, "b0");
+        assert_eq!(got_b[0].content, "b0");
+    }
+
+    /// replace_conversation 幂等性:INSERT OR IGNORE 在同事务内 DELETE 后无残留,
+    /// 重复 replace 同 id 不报错(DELETE 后表内该 conv 空,INSERT 必然成功)
+    #[tokio::test]
+    async fn replace_conversation_idempotent_rerun() {
+        let db = Database::open_in_memory().await.expect("open_in_memory");
+        let repo = AiMessageRepo::new(&db);
+        let now = now_millis_str();
+        let rec = || AiMessageRecord {
+            id: "m0".into(),
+            conversation_id: "c".into(),
+            seq: 0,
+            role: "user".into(),
+            content: "0".into(),
+            parts: None,
+            tool_call_id: None,
+            tool_calls: None,
+            model: None,
+            status: "active".into(),
+            reasoning_content: None,
+            timestamp: None,
+            created_at: now.clone(),
+        };
+        repo.replace_conversation("c", vec![rec()]).await.expect("1st");
+        repo.replace_conversation("c", vec![rec()]).await.expect("2nd");
+        let got = repo.list_by_conversation("c").await.expect("list");
+        assert_eq!(got.len(), 1, "重复 replace 不应叠加");
+    }
 }