All your AI agent sessions in one place — browse, search, resume. Rust + GPUI.
Rust
fix: keep the index compact, honour put-back, fold Claude Code branches
Corey Chiud008ecde7796
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex d4095ea..13846bc 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -1,5 +1,14 @@# Changelog+## [Unreleased]++- Fix: Search results show the text around each match, with every search term highlighted, instead of a dozen characters+- Fix: A session you delete in Wake shows up again when you put its file back from the Trash; sessions that live in an agent's own database are now hidden from Wake instead of claiming to go to the Trash+- Fix: A failed search, star or pin change, or a list that stops loading now says so instead of failing silently+- Fix: Claude Code sessions branched from an earlier conversation no longer repeat that conversation: the copied part is folded away, the branch is listed under the session it came from, and its title, token count and start time come from what was said after the branch. When the original is deleted, in Wake or by Claude Code's own cleanup, its branches stay and show the whole conversation. Existing indexes are re-read once after upgrading+- Fix: The notices Claude Code adds when a background task or sub-agent finishes are no longer shown or counted as prompts you typed+- Update: Wake's search index stays compact: a refresh no longer rewrites conversations that haven't changed, and the index is compacted after refreshes, so searches are faster and it takes far less disk space (one index went from 661 MB to about 160 MB)+## [0.8.8] — 2026-10-09- Fix: Grok Build sessions closed before the first message no longer show up as empty Untitled sessions (#55, thanks @yangmingyuan380)diff --git a/crates/wake-core/src/adapters/claude.rs b/crates/wake-core/src/adapters/claude.rsindex b8a44b4..a79a7cf 100644--- a/crates/wake-core/src/adapters/claude.rs+++ b/crates/wake-core/src/adapters/claude.rs@@ -1,12 +1,14 @@use super::parse_utils::*;use super::AgentAdapter;use crate::models::*;-use anyhow::Result;+use anyhow::{Context as _, Result};+use serde::Deserialize;use serde_json::Value;-use std::collections::HashMap;+use std::collections::{HashMap, HashSet};use std::fs;use std::io::BufReader;use std::path::{Path, PathBuf};+use std::sync::{Arc, Mutex};/// Claude JSONL 已知的非消息行类型,静默跳过(不计 unknown)const KNOWN_SKIP_TYPES: &[&str] = &[@@ -31,26 +33,330 @@ pub struct ClaudeAdapter {/// 镜像没有 home——不越界摸父目录(不变量 8⑨)home: Option<PathBuf>,/// 默认根(本机自己的 ~/.claude):项目目录名才能在本机文件系统上反推——目录名- /// 指的是写下会话的那台机器上的路径,自定义根(别处拷来的、远程镜像)反推不得+ /// 指的是写下会话的那台机器上的路径,自定义根(别处拷来的、远程镜像)反推不得;+ /// 文件的创建时间也只在这里可信(分支识别)local: bool,/// auto-memory 文档,按目录指纹缓存(每轮扫描都会列,指纹没变不重读)memories: super::MemoryCache,/// 目录名 → 反推出的项目路径,进程内记住(含反推失败):反推要从 `/` 逐层/// read_dir + stat,答案又几乎不变,每轮扫描重走一遍是白费;目录后来才出现的/// 极少数情况重启即可- decoded: std::sync::Mutex<HashMap<String, Option<String>>>,+ decoded: Mutex<HashMap<String, Option<String>>>,+ /// 分支识别的缓存(见 `BranchCache`)+ branches: Mutex<BranchCache>,+}++// ---------------- 分支(续接)识别 ----------------+//+// Claude Code 从一段已有对话分出新会话(桌面端的分支、`--fork-session`)时,会新建一份+// 会话文件、把原对话到分叉点为止的行**原样复制**进去:uuid、message.id、时间戳都不变,+// 只改写 sessionId。原样入库就是同一段对话列两遍、搜一次命中两次、Insights 的 prompt 与+// token 多算(本机 159 份里 24 份带着复制来的历史,多算约 5%)。做法照 Craft 分支与 Codex+// fork 的先例:同一项目目录里,第一条带 uuid 的行相同的文件是同一棵对话树;树里写下得+// 更晚的那份是分支,它开头连续落在更早那些文件 uuid 集合里的行折成一条 Meta,分支挂到+// 最早那份(原件)下面。++/// 一份会话文件开头的身份,写下后就不变(Claude 只往后追加)。`root` 是第一条带 uuid 的+/// 行(整棵对话树的根,复制时原样带过来);`first_ts` 是文件里第一个时间戳——原件是会话+/// 开始,分支是复制发生的时刻(它头几行的 queue-operation 写在复制之前),所以分支恒不早于+/// 原件;`born` 是文件的创建时间,两份的第一个时间戳一样时(分支没有那几行头)才拿来比+#[derive(Clone)]+struct Head {+ root: Option<String>,+ first_ts: i64,+ born: Option<i64>,+}++/// 一份分支:同根组里比它早写下的文件,以及其中最早的那份(原件)+#[derive(Clone)]+struct Branch {+ earlier: Vec<PathBuf>,+ original: PathBuf,+}++/// 整份文件的 uuid 集合与最后一条自定义标题。只给分支之前的那几份读(绝大多数会话没有+/// 分支,一份都不用读)+#[derive(Clone)]+struct Lineage {+ uuids: Arc<HashSet<String>>,+ custom_title: Option<String>,+}++/// 一个项目目录的分支分组,按目录 mtime 校验:文件进出、改名都会改它;文件追加不会,也+/// 不影响分组(头写下就不变)。根那一行还没写的文件(刚建、头不全)让这份分组不作数,+/// 下次重算;已经读全的头留着复用,目录变了也只读新来的文件+struct DirBranches {+ mtime: i64,+ complete: bool,+ heads: HashMap<PathBuf, Head>,+ branches: Arc<HashMap<PathBuf, Branch>>,+}++#[derive(Default)]+struct BranchCache {+ dirs: HashMap<PathBuf, DirBranches>,+ /// 文件 → ((mtime, size), uuid 集合)+ lineages: HashMap<PathBuf, ((i64, i64), Lineage)>,+}++/// 一份分支会话的继承段:比它早写下的同根文件里出现过的 uuid。文件开头连续落在这些集合+/// 里的行是从原件复制来的+struct Inherited {+ earlier: Vec<Lineage>,+ /// 原件最后一条自定义标题:分支的自定义标题跟它一样(分支时照抄过来)就不当标题用,+ /// 改用分支自己的第一句话——否则父子两行标题一模一样,看不出分支在问什么+ parent_title: Option<String>,+}++impl Inherited {+ fn contains(&self, uuid: &str) -> bool {+ self.earlier.iter().any(|l| l.uuids.contains(uuid))+ }+}++/// `a` 是否严格早于 `b` 写下:先比文件里第一个时间戳;一样时只在 `trust_born`(默认根,+/// 本机自己写下的文件)上再比创建时间——远程镜像与拷贝来的目录里,创建时间是同步 / 拷贝+/// 的时刻,宁可不判也不瞎判。没有时间戳的文件不参与排序+fn written_before(a: &Head, b: &Head, trust_born: bool) -> bool {+ if a.first_ts <= 0 || b.first_ts <= 0 {+ return false;+ }+ if a.first_ts != b.first_ts {+ return a.first_ts < b.first_ts;+ }+ trust_born && matches!((a.born, b.born), (Some(x), Some(y)) if x < y)+}++/// 按根分组,算出每份分支之前有哪些同根文件、最早的是哪份(并列时取路径字典序小的,+/// 保证稳定)。没有更早文件的(原件、和原件分不出先后的)不在结果里+fn group_branches(heads: &HashMap<PathBuf, Head>, trust_born: bool) -> HashMap<PathBuf, Branch> {+ let mut trees: HashMap<&str, Vec<(&PathBuf, &Head)>> = HashMap::new();+ for (path, head) in heads {+ if let Some(root) = &head.root {+ trees.entry(root).or_default().push((path, head));+ }+ }+ let mut out = HashMap::new();+ for tree in trees.values().filter(|tree| tree.len() > 1) {+ for &(path, head) in tree {+ let earlier: Vec<(&PathBuf, &Head)> = tree+ .iter()+ .copied()+ .filter(|&(other, h)| other != path && written_before(h, head, trust_born))+ .collect();+ let original = earlier+ .iter()+ .filter(|(_, h)| {+ !earlier+ .iter()+ .any(|(_, o)| written_before(o, h, trust_born))+ })+ .map(|(p, _)| *p)+ .min();+ if let Some(original) = original {+ out.insert(+ path.clone(),+ Branch {+ earlier: earlier.iter().map(|(p, _)| (*p).clone()).collect(),+ original: original.clone(),+ },+ );+ }+ }+ }+ out+}++/// 读文件头:第一个时间戳与第一条带 uuid 的行。头几行都是很短的元数据行,找到根就停+fn read_head(path: &Path, born: Option<i64>) -> Head {+ #[derive(Deserialize)]+ struct Row {+ uuid: Option<String>,+ timestamp: Option<Value>,+ }+ let mut head = Head {+ root: None,+ first_ts: 0,+ born,+ };+ let Ok(file) = fs::File::open(path) else {+ return head;+ };+ for row in jsonl_rows::<Row, _>(BufReader::new(file)).take(200) {+ let Ok(row) = row else { break };+ let Some(row) = row else { continue };+ if head.first_ts == 0 {+ head.first_ts = row.timestamp.as_ref().map(to_epoch_ms).unwrap_or(0);+ }+ if let Some(uuid) = row.uuid.filter(|u| !u.is_empty()) {+ head.root = Some(uuid);+ break;+ }+ }+ head+}++/// 读整份文件的 uuid 集合与最后一条自定义标题。逐行只反序列化这三个字段;坏行跳过,+/// 读错误整份失败(读不全就宁可不折)+fn read_lineage(path: &Path) -> Result<Lineage> {+ #[derive(Deserialize)]+ struct Row {+ uuid: Option<String>,+ #[serde(rename = "type")]+ typ: Option<String>,+ #[serde(rename = "customTitle")]+ custom_title: Option<Value>,+ }+ let mut uuids = HashSet::new();+ let mut title = None;+ for row in jsonl_rows::<Row, _>(BufReader::with_capacity(1 << 20, fs::File::open(path)?)) {+ let Some(row) = row? else { continue };+ if let Some(uuid) = row.uuid.filter(|u| !u.is_empty()) {+ uuids.insert(uuid);+ }+ // 与解析同一个取法(optional_string),分支标题与原件标题才比得上+ if row.typ.as_deref() == Some("custom-title") {+ title = optional_string(row.custom_title.as_ref()).or(title);+ }+ }+ Ok(Lineage {+ uuids: Arc::new(uuids),+ custom_title: title,+ })}impl ClaudeAdapter {pub fn new() -> Self {let home = super::home_dir().unwrap_or_default().join(".claude");+ Self::at(home.join("projects"), Some(home), true)+ }++ fn at(root: PathBuf, home: Option<PathBuf>, local: bool) -> Self {Self {- root: home.join("projects"),- home: Some(home),- local: true,+ root,+ home,+ local,memories: super::MemoryCache::new(),- decoded: std::sync::Mutex::new(HashMap::new()),+ decoded: Mutex::new(HashMap::new()),+ branches: Mutex::new(BranchCache::default()),+ }+ }++ /// 一个项目目录里的分支(见 `DirBranches`)。目录没变就直接用上次的分组,一次 stat;+ /// 变了只读新来文件的头。文件 I/O 不持锁——扫描、watcher、GUI 打开详情、导出可能同时问+ fn branches_in(&self, dir: &Path) -> Arc<HashMap<PathBuf, Branch>> {+ let mtime = fs::metadata(dir).map(|m| mtime_ms(&m)).unwrap_or(0);+ let known = {+ let cache = self.branches.lock().unwrap();+ match cache.dirs.get(dir) {+ Some(memo) if memo.mtime == mtime && memo.complete => return memo.branches.clone(),+ Some(memo) => memo.heads.clone(),+ None => HashMap::new(),+ }+ };+ let Ok(entries) = fs::read_dir(dir) else {+ return Arc::default();+ };+ let mut heads = HashMap::new();+ // 建好了、还没写下第一行的会话文件(零字节)不进分组,但让这次分组不作数:之后的写入+ // 不改目录 mtime,当成完整缓存起来就再也看不见它,连 ⌘R 都救不回+ let mut unwritten = false;+ for entry in entries.flatten() {+ let path = entry.path();+ let head = match known.get(&path) {+ Some(head) => head.clone(),+ None => {+ if default_file_ref(AgentId::ClaudeCode, &path).is_none() {+ unwritten |= path.extension().is_some_and(|ext| ext == "jsonl")+ && fs::metadata(&path).is_ok_and(|m| m.is_file() && m.len() == 0);+ continue;+ }+ let born = entry.metadata().ok().and_then(|m| created_ms(&m));+ read_head(&path, born)+ }+ };+ heads.insert(path, head);+ }+ let complete = !unwritten && heads.values().all(|head| head.root.is_some());+ let branches = Arc::new(group_branches(&heads, self.local));+ heads.retain(|_, head| head.root.is_some());+ self.branches.lock().unwrap().dirs.insert(+ dir.to_path_buf(),+ DirBranches {+ mtime,+ complete,+ heads,+ branches: branches.clone(),+ },+ );+ branches+ }++ /// 会话引用:`default_file_ref` 再把"之前有几份同根文件"加进 size。原件被删(Claude 的+ /// cleanupPeriodDays 清掉了它)或冒出更早的同根文件时,分支的引用随之变化、下一轮扫描+ /// 重解析——折叠只在原件还在时才成立,原件没了分支就该露出完整历史(file_ref 的 trait+ /// 约定:引用的戳要盖住解析读到的每个文件)。列表与 file_ref 共用+ fn session_ref(+ &self,+ path: &Path,+ branches: &HashMap<PathBuf, Branch>,+ ) -> Option<SessionFileRef> {+ let mut r = default_file_ref(AgentId::ClaudeCode, path)?;+ r.size += branches.get(path).map_or(0, |b| b.earlier.len() as i64);+ Some(r)+ }++ /// 一份文件的 uuid 集合(按 mtime + size 缓存;读文件不持锁)+ fn lineage(&self, path: &Path) -> Result<Lineage> {+ let meta = fs::metadata(path)?;+ let stamp = (mtime_ms(&meta), meta.len() as i64);+ if let Some((cached, lineage)) = self.branches.lock().unwrap().lineages.get(path) {+ if *cached == stamp {+ return Ok(lineage.clone());+ }}+ let lineage = read_lineage(path)?;+ self.branches+ .lock()+ .unwrap()+ .lineages+ .insert(path.to_path_buf(), (stamp, lineage.clone()));+ Ok(lineage)+ }++ /// `file` 是分支的话,它的继承段与原件的标题;不是分支给 None。更早的文件读不出来就报错,+ /// 不能当成"不是分支"照常入库:等它读得出来,分支的引用没变、扫描不会重来,索引停在没+ /// 折叠的那份,现场解析却折叠了,两边的 seq 对不上(不变量 1)。解析失败时库里的旧行+ /// 留着,下一轮再试+ fn inherited_for(&self, file: &Path) -> Result<Option<Inherited>> {+ let Some(dir) = file.parent() else {+ return Ok(None);+ };+ let branches = self.branches_in(dir);+ let Some(branch) = branches.get(file) else {+ return Ok(None);+ };+ let earlier = branch+ .earlier+ .iter()+ .map(|path| {+ self.lineage(path).with_context(|| {+ format!("reading the session it branched from: {}", path.display())+ })+ })+ .collect::<Result<Vec<_>>>()?;+ let parent_title = self.lineage(&branch.original)?.custom_title;+ Ok(Some(Inherited {+ earlier,+ parent_title,+ }))+ }++ /// 主会话的解析(parse_session 与 parse_transcript 共用):分支先拿继承段+ fn parse_main(&self, r: &SessionFileRef, decode_images: bool) -> Result<ParseResult> {+ let path = Path::new(&r.file_path);+ let inherited = self.inherited_for(path)?;+ parse_claude_jsonl(path, false, decode_images, inherited.as_ref())}/// auto-memory 树 `projects/<dir>/memory/*.md` 展开成读取单元:每个项目目录的记忆@@ -149,6 +455,16 @@ struct PendingAssistant {model: Option<String>,}+/// 这一行是不是 pending 那条助手消息的续写:同一个 message.id,或者这一行 / pending 没有+/// id(逐块落盘的中间行)。助手消息的合并与分支边界的判断共用这一条规则+fn continues_pending(pending: &Option<PendingAssistant>, msg_id: Option<&str>) -> bool {+ match (pending, msg_id) {+ (None, _) => false,+ (Some(p), Some(mid)) => p.msg_id.as_deref().is_none_or(|pid| pid == mid),+ (Some(_), None) => true,+ }+}+fn flush_assistant(pending: &mut Option<PendingAssistant>,messages: &mut Vec<TranscriptMessage>,@@ -186,10 +502,14 @@ fn flush_assistant(});}+/// `inherited`:这份是分支时它从原件复制来的 uuid(见 `ClaudeAdapter::inherited_for`)。+/// 文件开头连续落在集合里的行折成一条 Meta(`collapse_inherited`),token、创建时间与+/// 兜底标题只算分支自己的行。parse_session 与 parse_transcript 都经这里,seq 两边一致fn parse_claude_jsonl(path: &Path,include_sidechain: bool,decode_images: bool,+ inherited: Option<&Inherited>,) -> Result<ParseResult> {let _image_budget = transcript_image_decode_budget(decode_images);let file = fs::File::open(path)?;@@ -208,6 +528,10 @@ fn parse_claude_jsonl(let mut updated_at: i64 = 0;let mut unknown_lines: u32 = 0;let mut pending: Option<PendingAssistant> = None;+ // 分支:继承段在第几条消息处结束(None = 还在继承段里,或者不是分支);分支自己的+ // 第一个时间戳+ let mut cut: Option<usize> = None;+ let mut own_created_at: i64 = 0;for row in jsonl_values(reader) {let Some(row) = row? else {@@ -216,11 +540,27 @@ fn parse_claude_jsonl(};let typ = row.get("type").and_then(|v| v.as_str()).unwrap_or("");- if typ == "custom-title" {- if let Some(t) = row.get("customTitle").and_then(|v| v.as_str()) {- if !t.trim().is_empty() {- custom_title = t.trim().to_string();+ // 继承段的边界:第一条 uuid 不在更早文件里的行(attachment 这类跳过的行也带 uuid,+ // 必须在类型过滤之前判)。边界行若是 pending 那条助手消息的续写,那条消息算分支+ // 自己的;否则先把继承段里还没落下的助手消息落下,再记边界+ if let Some(inh) = inherited.filter(|_| cut.is_none()) {+ let uuid = row.get("uuid").and_then(|v| v.as_str());+ if uuid.is_some_and(|uuid| !inh.contains(uuid)) {+ let msg_id = row.pointer("/message/id").and_then(|v| v.as_str());+ if !(typ == "assistant" && continues_pending(&pending, msg_id)) {+ flush_assistant(&mut pending, &mut messages, &mut tool_index);}+ cut = Some(messages.len());+ }+ }+ let in_prefix = inherited.is_some() && cut.is_none();+ if !in_prefix && own_created_at == 0 {+ own_created_at = row.get("timestamp").map(to_epoch_ms).unwrap_or(0);+ }++ if typ == "custom-title" {+ if let Some(t) = optional_string(row.get("customTitle")) {+ custom_title = t;}continue;}@@ -348,7 +688,8 @@ fn parse_claude_jsonl(} else {MessageKind::Text};- if kind == MessageKind::Text && fallback_title.is_empty() {+ // 分支的兜底标题取它自己的第一句,不拿原件开头那句+ if kind == MessageKind::Text && fallback_title.is_empty() && !in_prefix {fallback_title = clean_title_candidate(&text);}let (clipped, truncated) = clip(&text, MAX_MSG_TEXT);@@ -370,12 +711,7 @@ fn parse_claude_jsonl(// ---- assistant ----let Some(message) = message else { continue };let msg_id = message.get("id").and_then(|v| v.as_str()).map(String::from);- let need_new = match (&pending, &msg_id) {- (None, _) => true,- (Some(p), Some(mid)) => p.msg_id.as_deref().is_some_and(|pid| pid != mid),- (Some(_), None) => false,- };- if need_new {+ if !continues_pending(&pending, msg_id.as_deref()) {flush_assistant(&mut pending, &mut messages, &mut tool_index);pending = Some(PendingAssistant {msg_id: msg_id.clone(),@@ -394,7 +730,8 @@ fn parse_claude_jsonl(model = Some(m.to_string());}}- if let Some(usage) = message.get("usage") {+ // 复制来的助手消息带着原件那次调用的 usage,算进分支就重复计了+ if let Some(usage) = message.get("usage").filter(|_| !in_prefix) {tokens_used += usage.get("input_tokens").and_then(|v| v.as_i64())@@ -450,6 +787,17 @@ fn parse_claude_jsonl(}}flush_assistant(&mut pending, &mut messages, &mut tool_index);+ if let Some(inh) = inherited {+ // 整份都是复制来的(分出来还没说话就关了)也折,只剩那条 Meta+ let cut = cut.unwrap_or(messages.len());+ collapse_inherited(&mut messages, cut, "session");+ if own_created_at > 0 {+ created_at = own_created_at;+ }+ if inh.parent_title.as_deref() == Some(custom_title.as_str()) {+ custom_title.clear();+ }+ }assign_seq(&mut messages);Ok(ParseResult {@@ -611,33 +959,23 @@ impl AgentAdapter for ClaudeAdapter {return Ok(refs);};for project in projects.flatten() {- let Ok(entries) = fs::read_dir(project.path()) else {+ // 引用要现 stat(mtime / size 是扫描的变更判据);分支分组每个目录取一次+ let dir = project.path();+ let branches = self.branches_in(&dir);+ let Ok(entries) = fs::read_dir(&dir) else {continue;};- for entry in entries.flatten() {- let path = entry.path();- let name = entry.file_name().to_string_lossy().to_string();- if !name.ends_with(".jsonl") {- continue;- }- let Ok(meta) = entry.metadata() else { continue };- if !meta.is_file() || meta.len() == 0 {- continue;- }- refs.push(SessionFileRef {- agent: AgentId::ClaudeCode,- native_id: name.trim_end_matches(".jsonl").to_string(),- file_path: path.to_string_lossy().to_string(),- mtime_ms: mtime_ms(&meta),- size: meta.len() as i64,- });- }+ refs.extend(+ entries+ .flatten()+ .filter_map(|entry| self.session_ref(&entry.path(), &branches)),+ );}Ok(refs)}fn parse_session(&self, r: &SessionFileRef) -> Result<ParsedSession> {- let parsed = parse_claude_jsonl(Path::new(&r.file_path), false, false)?;+ let parsed = self.parse_main(r, false)?;let meta = build_meta(r, &parsed);Ok(ParsedSession::derive(meta,@@ -647,7 +985,7 @@ impl AgentAdapter for ClaudeAdapter {}fn parse_transcript(&self, r: &SessionFileRef) -> Result<ParsedTranscript> {- let parsed = parse_claude_jsonl(Path::new(&r.file_path), false, true)?;+ let parsed = self.parse_main(r, true)?;let sidechains = list_sidechains(r);let mut mainline = parsed.messages.clone();// 把 sidechain 挂到主线对应 Task tool call@@ -679,19 +1017,84 @@ impl AgentAdapter for ClaudeAdapter {if !file.is_file() {return Ok(Vec::new());}- let parsed = parse_claude_jsonl(&file, true, true)?;+ let parsed = parse_claude_jsonl(&file, true, true, None)?;Ok(parsed.messages)}+ /// 项目目录里的会话文件进出(原件被删、被放回)会改变同目录分支的引用(`session_ref`+ /// 数着更早的同根文件):交出同目录的其余会话文件,watcher 按引用重比、变了的重解析+ fn ref_dependents(&self, path: &Path) -> Vec<PathBuf> {+ let Some(dir) = path+ .parent()+ .filter(|dir| dir.parent() == Some(self.root.as_path()))+ else {+ return Vec::new();+ };+ let jsonl = |p: &Path| p.extension().is_some_and(|ext| ext == "jsonl");+ if !jsonl(path) {+ return Vec::new();+ }+ let Ok(entries) = fs::read_dir(dir) else {+ return Vec::new();+ };+ entries+ .flatten()+ .map(|entry| entry.path())+ .filter(|sibling| sibling != path && jsonl(sibling))+ .collect()+ }+fn file_ref(&self, path: &Path) -> Option<SessionFileRef> {// subagents 转录与 memory 边车不是主会话。按所在目录的名字判:按路径分段,Windows 的// 反斜杠路径一样认(原先拿带 `/` 的字符串去比,watcher 报来的路径一条都对不上);只看// 直接所在的目录,数据根上层恰好有叫 memory / subagents 的目录也不误伤- let parent = path.parent()?.file_name()?;+ let dir = path.parent()?;+ let parent = dir.file_name()?;if parent == "subagents" || parent == "memory" {return None;}- default_file_ref(self.agent(), path)+ self.session_ref(path, &self.branches_in(dir))+ }++ /// 分支挂到原件下面(见本文件「分支识别」)。关系由分支自己的文件头与同目录里更早的+ /// 同根文件推出,所以算"写在子会话里"(多 location 下按子会话的胜出副本认边)+ fn manages_parent_links(&self) -> bool {+ true+ }++ fn parent_links_in_child(&self) -> bool {+ true+ }++ /// 分支是自己完整的一段对话:删原件不带上它们,原件没了它们变回顶层会话、露出完整历史+ /// (重解析由 watcher 经 `ref_dependents` 触发)+ fn children_outlive_parent(&self) -> bool {+ true+ }++ /// 全量快照只用文件头(不读 uuid 集合):每个分支 → 它所在同根组里最早的那份。分支+ /// 的分支也直接挂到原件上——scanner 本来就把链压平到根。目录没变的,分组直接复用+ /// (每批 watcher 事件都会问一遍,每个目录一次 stat)。projects 目录不在 = 确定没有+ /// 关系;在却列不出来是"不知道",交 None 让 scanner 保留库里的关系+ fn parent_links(&self) -> Option<Vec<(String, String)>> {+ let projects = match fs::read_dir(&self.root) {+ Ok(projects) => projects,+ Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Some(Vec::new()),+ Err(_) => return None,+ };+ let key = |path: &Path| {+ path.file_stem()+ .map(|s| session_key(AgentId::ClaudeCode, "", &s.to_string_lossy()))+ };+ let mut links = Vec::new();+ for project in projects.flatten() {+ for (path, branch) in self.branches_in(&project.path()).iter() {+ if let (Some(child), Some(parent)) = (key(path), key(&branch.original)) {+ links.push((child, parent));+ }+ }+ }+ Some(links)}fn session_paths(&self, meta: &SessionMeta) -> Vec<String> {@@ -750,13 +1153,7 @@ impl AgentAdapter for ClaudeAdapter {} else {(dir, None)};- Box::new(Self {- root,- home,- local: false,- memories: super::MemoryCache::new(),- decoded: std::sync::Mutex::new(HashMap::new()),- })+ Box::new(Self::at(root, home, false))}fn data_roots(&self) -> Vec<PathBuf> {@@ -768,6 +1165,136 @@ impl AgentAdapter for ClaudeAdapter {mod tests {use super::*;+ fn head(root: &str, first_ts: i64, born: Option<i64>) -> Head {+ Head {+ root: Some(root.to_string()),+ first_ts,+ born,+ }+ }++ /// 谁先写下:先比文件里第一个时间戳;一样(分支没有那几行头)时只在可信的默认根上+ /// 比创建时间;没有时间戳的不参与排序+ #[test]+ fn branch_order_uses_the_first_timestamp_then_trusted_creation_time() {+ let original = head("r", 100, Some(5_000));+ let with_header = head("r", 200, Some(1_000));+ assert!(written_before(&original, &with_header, false));+ assert!(!written_before(&with_header, &original, false));++ let no_header = head("r", 100, Some(9_000));+ assert!(+ !written_before(&original, &no_header, false),+ "镜像 / 拷贝目录里不信创建时间"+ );+ assert!(written_before(&original, &no_header, true));+ assert!(!written_before(&no_header, &original, true));++ let untimed = head("r", 0, Some(1));+ assert!(!written_before(&untimed, &original, true));+ assert!(!written_before(&original, &untimed, true));+ }++ /// 同根组里每份分支都挂到最早那份上(分支的分支也是);别的根、分不出先后的不算+ #[test]+ fn every_branch_points_at_the_earliest_file_of_its_tree() {+ let heads: HashMap<PathBuf, Head> = [+ ("/p/a.jsonl", head("r", 100, None)),+ ("/p/b.jsonl", head("r", 200, None)),+ ("/p/c.jsonl", head("r", 300, None)),+ ("/p/x.jsonl", head("other", 50, None)),+ ("/p/tie.jsonl", head("r", 100, None)),+ ]+ .into_iter()+ .map(|(path, head)| (PathBuf::from(path), head))+ .collect();+ let branches = group_branches(&heads, false);+ let of = |name: &str| {+ branches+ .get(Path::new(name))+ .map(|b| (b.earlier.len(), b.original.clone()))+ };+ assert_eq!(of("/p/a.jsonl"), None);+ assert_eq!(of("/p/tie.jsonl"), None, "和原件分不出先后就不判");+ assert_eq!(of("/p/x.jsonl"), None);+ assert_eq!(of("/p/b.jsonl"), Some((2, PathBuf::from("/p/a.jsonl"))));+ assert_eq!(of("/p/c.jsonl"), Some((3, PathBuf::from("/p/a.jsonl"))));+ }++ /// 项目目录里的一份会话:一行 queue-operation 定下"什么时候写下",一条共有的提问(根+ /// uuid 相同),分支再加一条自己的。返回 (目录, 原件, 分支)+ fn stage_branch(root: &Path) -> (PathBuf, PathBuf, PathBuf) {+ let dir = root.join("-w");+ fs::create_dir_all(&dir).unwrap();+ let session = |id: &str, opened: &str, own: Option<&str>| {+ let mut lines = vec![+ format!(+ r#"{{"type":"queue-operation","timestamp":"{opened}","sessionId":"{id}"}}"#+ ),+ format!(+ r#"{{"type":"user","uuid":"u1","timestamp":"2026-09-01T08:00:01.000Z","sessionId":"{id}","message":{{"role":"user","content":"why does login time out"}}}}"#+ ),+ ];+ if let Some(own) = own {+ lines.push(format!(+ r#"{{"type":"user","uuid":"b2","timestamp":"2026-09-02T09:00:10.000Z","sessionId":"{id}","message":{{"role":"user","content":"{own}"}}}}"#+ ));+ }+ lines.join("\n") + "\n"+ };+ let (original, branch) = (dir.join("a.jsonl"), dir.join("b.jsonl"));+ fs::write(&original, session("a", "2026-09-01T08:00:00.000Z", None)).unwrap();+ fs::write(+ &branch,+ session("b", "2026-09-02T09:00:00.000Z", Some("use a queue")),+ )+ .unwrap();+ (dir, original, branch)+ }++ /// 建好了、还没写下第一行的会话文件(零字节)不进分组,分组却不能记成完整:之后的写入+ /// 不改目录 mtime,缓存成完整就再也认不出它是分支+ #[test]+ fn an_unwritten_session_file_keeps_the_grouping_open() {+ let tmp = tempfile::tempdir().unwrap();+ let (dir, _, branch) = stage_branch(tmp.path());+ let content = fs::read(&branch).unwrap();+ fs::write(&branch, "").unwrap();+ let adapter = ClaudeAdapter::at(tmp.path().to_path_buf(), None, false);+ assert!(adapter.branches_in(&dir).is_empty());+ fs::write(&branch, content).unwrap();+ assert!(+ adapter.branches_in(&dir).contains_key(&branch),+ "写下第一行以后要认出分支"+ );+ }++ /// 已经认出是分支、原件却读不出来(权限、I/O 错误):这次解析失败,不能当成"不是分支"+ /// 交出完整历史——那样入了库,读得出来以后引用不变、不会重来,索引与现场解析的 seq+ /// 就一直对不上。读得出来就照常折叠+ #[cfg(unix)]+ #[test]+ fn a_branch_whose_original_cannot_be_read_fails_to_parse() {+ use std::os::unix::fs::PermissionsExt;+ let tmp = tempfile::tempdir().unwrap();+ let (dir, original, branch) = stage_branch(tmp.path());+ let adapter = ClaudeAdapter::at(tmp.path().to_path_buf(), None, false);+ assert!(adapter.branches_in(&dir).contains_key(&branch));+ let r = default_file_ref(AgentId::ClaudeCode, &branch).unwrap();+ fs::set_permissions(&original, fs::Permissions::from_mode(0o000)).unwrap();+ if fs::File::open(&original).is_ok() {+ return; // root 读得动任何文件,这条测不了+ }+ assert!(adapter.parse_main(&r, false).is_err());+ fs::set_permissions(&original, fs::Permissions::from_mode(0o644)).unwrap();+ let parsed = adapter.parse_main(&r, false).unwrap();+ assert_eq!(+ parsed.messages[0].kind,+ MessageKind::Meta,+ "复制来的那一轮折叠掉"+ );+ }+/// 目录名反推项目路径:`.`、`_`、空格都被编成 `-`,同一层多个候选按最长优先,/// 磁盘上不存在的认不出。只在 unix 跑:Windows 的临时目录编码出来是 `C--Users-…`/// 形态,函数对它直接给 None(文档里写明不做),测试里 `starts_with('-')` 必红diff --git a/crates/wake-core/src/adapters/mod.rs b/crates/wake-core/src/adapters/mod.rsindex 8420878..c8a82df 100644--- a/crates/wake-core/src/adapters/mod.rs+++ b/crates/wake-core/src/adapters/mod.rs@@ -64,6 +64,14 @@ pub trait AgentAdapter: Send + Sync {fn file_ref(&self, path: &Path) -> Option<SessionFileRef> {parse_utils::default_file_ref(self.agent(), path)}+ /// 这份会话文件出现或消失时,还有哪些文件的引用(`file_ref` 的 mtime / size)跟着变——那些+ /// 文件没动,watcher 收不到它们的事件。默认没有;Claude 分支的引用数着同目录更早的同根+ /// 文件,原件被删、被放回,同目录的分支要重解析(展开 / 折叠复制来的历史)。watcher 对新+ /// 出现与消失的路径各问一次,只把引用真变了的交给增量收编;全量扫描本来就逐个重比引用,+ /// 用不着它。远程装饰器必须转发+ fn ref_dependents(&self, _path: &Path) -> Vec<std::path::PathBuf> {+ Vec::new()+ }/// 快路径:不解析文件直接给出 meta(Codex 走 state DB)。None = 无快路径fn quick_meta(&self,@@ -232,6 +240,13 @@ pub trait AgentAdapter: Send + Sync {fn parent_links_in_child(&self) -> bool {false}+ /// 本家的子会话是不是**分支**——从父会话分出去、自己完整的一段对话(Claude Code 的+ /// fork),而不是父会话的一部分(子代理、子任务)。是的话删父会话不带上它们:详情页+ /// 删除只删父会话本身,Clean Up 里分支自成一棵清理树;父会话没了,分支变回顶层会话、+ /// 露出完整历史。默认 false(随父会话一起删)。远程装饰器必须转发+ fn children_outlive_parent(&self) -> bool {+ false+ }/// 本家会话在**别家**目录里的替身。外壳产品(Craft Agents)跑的是别家的引擎,/// 引擎自己也往自家目录落了一份转录(Claude Agent SDK → `~/.claude/projects`),/// 同一段对话就会以两家身份各列一次。返回那些替身的 `(别家, 别家 native id)`:@@ -570,6 +585,13 @@ pub fn adapter_for<'a>(adapter_ix_for(adapters, agent, file_path).map(|ix| adapters[ix].as_ref())}+/// 这条会话所在的家,子会话是不是各自完整的对话(`AgentAdapter::children_outlive_parent`):+/// 是的话删除与 Clean Up 都不带上它们。详情页删除问根会话、Clean Up 载入索引时问每条子+/// 会话——关系只连同家会话,两种问法是同一个答案+pub fn children_outlive_parent(adapters: &[Box<dyn AgentAdapter>], meta: &SessionMeta) -> bool {+ adapter_for(adapters, meta.agent, &meta.file_path).is_some_and(|a| a.children_outlive_parent())+}+/// 从解析后的消息派生 FTS 单元(text + tool 名称/输入摘要)。agent 对 Wake 自己的/// 查询(MCP 的 wake_* 工具、shell 里的 wake-cli / wake-mcp)不进索引:否则搜任何/// 词,第一条命中都是"上次搜这个词的那次调用",越用越吵(自指回声)。只跳过工具diff --git a/crates/wake-core/src/adapters/parse_utils.rs b/crates/wake-core/src/adapters/parse_utils.rsindex 1e471d2..9469e00 100644--- a/crates/wake-core/src/adapters/parse_utils.rs+++ b/crates/wake-core/src/adapters/parse_utils.rs@@ -64,6 +64,14 @@ fn consume_image_decode_budget(bytes: usize) -> bool {pub fn jsonl_values<R: std::io::BufRead>(reader: R,) -> impl Iterator<Item = std::io::Result<Option<Value>>> {+ jsonl_rows(reader)+}++/// `jsonl_values` 的窄版:每行只反序列化成 `T`(用不到的字段直接跳过,不建整棵 Value 树),+/// 读错误规则相同;读不出、不是 JSON、对不上形状的行交 `Ok(None)`+pub fn jsonl_rows<T: serde::de::DeserializeOwned, R: std::io::BufRead>(+ reader: R,+) -> impl Iterator<Item = std::io::Result<Option<T>>> {jsonl_lines(reader).filter_map(|line| match line {Ok(Some(line)) if line.trim().is_empty() => None,Ok(line) => Some(Ok(line.and_then(|line| serde_json::from_str(&line).ok()))),@@ -104,11 +112,18 @@ impl<R: std::io::BufRead> Iterator for JsonlLines<R> {/// 文件 mtime → epoch ms(各家 adapter 与 watcher 共用)pub fn mtime_ms(meta: &std::fs::Metadata) -> i64 {- meta.modified()+ meta.modified().ok().and_then(system_time_ms).unwrap_or(0)+}++/// 文件创建时间 → epoch ms;平台或文件系统不记的给 None+pub fn created_ms(meta: &std::fs::Metadata) -> Option<i64> {+ meta.created().ok().and_then(system_time_ms)+}++fn system_time_ms(t: std::time::SystemTime) -> Option<i64> {+ t.duration_since(std::time::UNIX_EPOCH).ok()- .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok()).map(|d| d.as_millis() as i64)- .unwrap_or(0)}/// cwd → 项目显示名(路径末段;空/异常 = "Unknown project")@@ -1148,6 +1163,9 @@ pub fn is_injected_user_content(text: &str) -> bool {"## Referenced ChatGPT conversation",// Codex 把 AGENTS.md 作为 user 消息注入"# AGENTS.md instructions",+ // Claude Code 的后台任务(子代理、后台命令)结束时以 user 行注入的通知,不是人打的字;+ // 不认它的话它会当成提问进 Insights、给分支会话起出 "b69tgbuwc toolu_…" 这种标题+ "<task-notification",// Codex 的 subagent / 分支线程:父会话的整段 transcript 被打包成// 一条 role=user 消息喂进来,里面含父会话的 assistant 输出。不认它// 的话,父会话里 AI 说的话会显示成这个会话里用户发的@@ -1211,6 +1229,17 @@ pub fn make_preview(input: &Value) -> String {mod tests {use super::*;+ /// Claude Code 后台任务结束的通知是注入内容,不是提问;正文里提到这个词的照算人话+ #[test]+ fn task_notifications_are_injected_content() {+ assert!(is_injected_user_content(+ "<task-notification>\n<task-id>b69tgbuwc</task-id>\n<status>completed</status>"+ ));+ assert!(!is_injected_user_content(+ "为什么 <task-notification> 会被当成提问?"+ ));+ }+#[test]fn jsonl_lines_stop_on_a_persistent_read_error() {// 一直读不出来(EIO、断开的网络盘):交一次 Err 就结束,不打转diff --git a/crates/wake-core/src/adapters/remote.rs b/crates/wake-core/src/adapters/remote.rsindex 37699d8..30980ac 100644--- a/crates/wake-core/src/adapters/remote.rs+++ b/crates/wake-core/src/adapters/remote.rs@@ -93,6 +93,10 @@ impl AgentAdapter for RemoteAdapter {self.inner.file_ref(path)}+ fn ref_dependents(&self, path: &Path) -> Vec<std::path::PathBuf> {+ self.inner.ref_dependents(path)+ }+fn quick_meta(&self,refs: &[SessionFileRef],@@ -226,6 +230,10 @@ impl AgentAdapter for RemoteAdapter {self.inner.parent_links_in_child()}+ fn children_outlive_parent(&self) -> bool {+ self.inner.children_outlive_parent()+ }+fn manages_claims(&self) -> bool {self.inner.manages_claims()}diff --git a/crates/wake-core/src/cleanup.rs b/crates/wake-core/src/cleanup.rsindex f97a184..32f8428 100644--- a/crates/wake-core/src/cleanup.rs+++ b/crates/wake-core/src/cleanup.rs@@ -1,8 +1,8 @@//! Local session cleanup: immutable review plans, conservative ownership checks,//! per-target Trash results and a durable journal. No source database writes.use crate::{- adapters::{adapter_for, AgentAdapter},- db::Store,+ adapters::{adapter_for, children_outlive_parent, AgentAdapter},+ db::{put_back_fingerprint, Store},models::*,services::terminal,};@@ -423,6 +423,19 @@ struct CleanupPlan {targets: Vec<CleanupTarget>,}+/// 清理用的会话索引。分支——所在的家声明子会话是自己完整的对话(`children_outlive_parent`,+/// Claude Code 的 fork)——在这里就摘掉父会话:它自成一棵清理树,单独列、单独清,也不随父+/// 会话一起清;子代理、子任务照旧是父会话树的一部分+fn cleanup_index(store: &Store, adapters: &[Box<dyn AgentAdapter>]) -> Result<Vec<IndexedSession>> {+ let mut index = store.cleanup_index()?;+ for s in &mut index {+ if !s.parent.is_empty() && children_outlive_parent(adapters, &s.meta) {+ s.parent.clear();+ }+ }+ Ok(index)+}+fn build_plan(root: &IndexedSession,index: &[IndexedSession],@@ -545,7 +558,7 @@ fn inventory_candidate(}pub fn inventory(store: &Store, adapters: &[Box<dyn AgentAdapter>]) -> Result<CleanupInventory> {- let index = store.cleanup_index()?;+ let index = cleanup_index(store, adapters)?;let prompt_counts = store.cleanup_prompt_counts()?;let ownership = ownership(&index, adapters);let mut result = CleanupInventory::default();@@ -655,7 +668,7 @@ pub fn revalidate(adapters: &[Box<dyn AgentAdapter>],old: &CleanupCandidate,) -> Result<()> {- let index = store.cleanup_index()?;+ let index = cleanup_index(store, adapters)?;let root = index.iter().find(|s| s.meta.key == old.root.key)@@ -695,7 +708,7 @@ pub fn revalidate(for old in &new.targets {ensure!(target(&old.path)? == *old, "Source changed while checking");}- let index = store.cleanup_index()?;+ let index = cleanup_index(store, adapters)?;let root = index.iter().find(|s| s.meta.key == old.root.key)@@ -807,6 +820,23 @@ pub fn retry_index_updates(store: &Store, batch: &mut CleanupBatch) -> Result<us}Ok(count)}+/// 详情页的删除:移动**之前**先给每份会话文件记放回指纹(`put_back_fingerprint`),再把磁盘+/// 目标移进废纸篓、出库并记墓碑(`Store::remove_trashed_sessions`)——用户从废纸篓放回原处,+/// 扫描认出同一份文件就撤掉墓碑。返回 true = 一个文件都没移:会话只在别家自己的库里(虚拟+/// 路径),Wake 只是不再列出它+pub fn trash_sessions(store: &Store, sessions: &[SessionMeta], targets: &[String]) -> Result<bool> {+ let prints: HashMap<String, (i64, i64)> = sessions+ .iter()+ .filter_map(|s| {+ put_back_fingerprint(Path::new(&s.file_path)).map(|print| (s.file_path.clone(), print))+ })+ .collect();+ let moved = terminal::trash_paths(targets)?;+ let keys: Vec<String> = sessions.iter().map(|s| s.key.clone()).collect();+ store.remove_trashed_sessions(&keys, &prints)?;+ Ok(moved.is_empty())+}+pub fn execute(store: &Store,adapters: &[Box<dyn AgentAdapter>],@@ -815,7 +845,7 @@ pub fn execute(progress: impl Fn(usize),) -> Result<()> {execute_with(store, adapters, batch, cancel, progress, |path| {- terminal::trash_paths(&[path.to_string_lossy().into_owned()])+ terminal::trash_paths(&[path.to_string_lossy().into_owned()]).map(drop)})}fn execute_with(@@ -1051,6 +1081,8 @@ mod tests {struct FilesAdapter {root: PathBuf,supported: bool,+ /// 子会话是不是分支(`children_outlive_parent`)+ branches: bool,}impl AgentAdapter for FilesAdapter {fn agent(&self) -> AgentId {@@ -1063,6 +1095,7 @@ mod tests {Box::new(Self {root,supported: self.supported,+ branches: self.branches,})}fn list_session_files(&self) -> Result<Vec<SessionFileRef>> {@@ -1097,6 +1130,9 @@ mod tests {fn cleanup_paths(&self, m: &SessionMeta) -> Option<Vec<String>> {self.supported.then(|| self.session_paths(m))}+ fn children_outlive_parent(&self) -> bool {+ self.branches+ }}fn now() -> i64 {chrono::Utc::now().timestamp_millis()@@ -1161,6 +1197,7 @@ mod tests {let adapters: Vec<Box<dyn AgentAdapter>> = vec![Box::new(FilesAdapter {root: root.clone(),supported: true,+ branches: false,})];(temp, store, adapters, root)}@@ -1183,6 +1220,43 @@ mod tests {.unwrap();m}+ /// 分支(所在的家声明子会话是自己完整的对话)自成一棵清理树:原件的清理计划不带上它,+ /// 它自己也是一个候选、过得了复核;默认(子代理一类)照旧随父会话+ #[test]+ fn branches_are_their_own_cleanup_trees() {+ let (_temp, store, adapters, root) = setup();+ let original = insert(&store, &root, "original", 100);+ let branch = insert(&store, &root, "branch", 100);+ store+ .replace_parent_links(+ AgentId::ClaudeCode,+ &[(branch.key.clone(), original.key.clone())],+ )+ .unwrap();+ let trees = |adapters: &[Box<dyn AgentAdapter>]| {+ let mut trees: Vec<(String, usize)> = inventory(&store, adapters)+ .unwrap()+ .candidates+ .iter()+ .map(|c| (c.root.key.clone(), c.sessions.len()))+ .collect();+ trees.sort();+ trees+ };+ assert_eq!(trees(&adapters), vec![(original.key.clone(), 2)]);+ let branching: Vec<Box<dyn AgentAdapter>> = vec![Box::new(FilesAdapter {+ root: root.clone(),+ supported: true,+ branches: true,+ })];+ assert_eq!(+ trees(&branching),+ vec![(branch.key.clone(), 1), (original.key.clone(), 1)]+ );+ for c in inventory(&store, &branching).unwrap().candidates {+ revalidate(&store, &branching, &c).unwrap();+ }+ }#[test]fn unavailable_entries_follow_date_source_and_tree_flag_filters() {let (_temp, store, adapters, root) = setup();@@ -1712,7 +1786,7 @@ mod tests {let original = child.file_path.clone();child.file_path = root.join("a/child.jsonl").to_string_lossy().into_owned();fs::rename(original, &child.file_path).unwrap();- store.remove_session(&child.key, false).unwrap();+ store.remove_session(&child.key).unwrap();store.write_session(&child, child.updated_at, &[]).unwrap();age(&root.join("a"));assert!(inventory(&store, &adapters)@@ -1814,6 +1888,7 @@ mod tests {let unsupported: Vec<Box<dyn AgentAdapter>> = vec![Box::new(FilesAdapter {root: root.clone(),supported: false,+ branches: false,})];assert!(inventory(&store, &unsupported).unwrap()@@ -1945,6 +2020,7 @@ mod tests {let adapters: Vec<Box<dyn AgentAdapter>> = vec![Box::new(FilesAdapter {root: root.clone(),supported: true,+ branches: false,})];insert(&store, &root, "ordinary-path", 100);let inv = inventory(&store, &adapters).unwrap();@@ -2037,6 +2113,7 @@ mod tests {inner: FilesAdapter {root,supported: true,+ branches: false,},store: store.clone(),owner,@@ -2104,14 +2181,14 @@ mod tests {|_| {},|p| {fs::rename(p, &dest)?;- store.remove_session(&m.key, false)?;+ store.remove_session(&m.key)?;Ok(())},).unwrap();assert!(batch.records[0].indexed);assert!(store.is_key_tombstoned(&m.key));- assert!(store.is_tombstoned(&m.file_path));+ assert!(store.is_tombstoned(&m.file_path).unwrap());assert!(restore(&store, &adapters, &mut batch).is_err());fs::rename(dest, &m.file_path).unwrap();store@@ -2175,7 +2252,7 @@ mod tests {fs::rename(dest, &m.file_path).unwrap();assert_eq!(restore(&store, &adapters, &mut batch).unwrap(), 1);assert!(!store.is_key_tombstoned(&m.key));- assert!(!store.is_tombstoned(&m.file_path));+ assert!(!store.is_tombstoned(&m.file_path).unwrap());assert!(history(&store).unwrap()[0].records[0].restored);}diff --git a/crates/wake-core/src/db.rs b/crates/wake-core/src/db.rsindex 8c35558..d1072fa 100644--- a/crates/wake-core/src/db.rs+++ b/crates/wake-core/src/db.rs@@ -78,7 +78,12 @@ CREATE TABLE IF NOT EXISTS user_data (CREATE TABLE IF NOT EXISTS tombstones (file_path TEXT PRIMARY KEY,key TEXT,- deleted_at INTEGER+ deleted_at INTEGER,+ -- 单条删除把文件移进废纸篓之前记下的文件指纹(`put_back_fingerprint`):同一路径再+ -- 出现、指纹对得上,就是用户从废纸篓放回来了(`Store::release_put_back`)。没被移走的、+ -- 批量清理与老版本写的墓碑留 NULL,永远对不上+ file_size INTEGER,+ file_mtime INTEGER);CREATE TABLE IF NOT EXISTS custom_roots (@@ -215,8 +220,19 @@ CREATE TABLE IF NOT EXISTS claimed_sessions (/// Windows 上 `C:/…` 形态的工作目录换成反斜杠(PR #61),老行靠这轮重解析回填;/// "11" = Kimi Code CLI 的助手回复(context.append_loop_event 的 text / think / 工具调用与结果)、/// 系统产生的输入记 Meta、分叉复制来的历史折成一条、迁移来的 `ses_` 会话;pi / dsh / Hermes-/// 的回复合并改走同一个封顶合并(恰好停在上限上的回复也补截断标记),老行靠这轮重解析回填。-pub const FTS_FORMAT: &str = "11";+/// 的回复合并改走同一个封顶合并(恰好停在上限上的回复也补截断标记),老行靠这轮重解析回填;+/// "12" = Claude Code 的分支会话(开头原样复制了原对话的那种)折掉复制来的一段、挂到原件下,+/// token / 标题 / 创建时间只算分支自己的行;后台任务结束时注入的 `<task-notification>`+/// user 行归注入内容(Meta),老行靠这轮重解析回填。+pub const FTS_FORMAT: &str = "12";++/// FTS 压缩的节奏(见 `Store::compact_fts`):距上次压缩满一天、或从没压过才压。没有记录+/// 就算到期——老库升级后、新建库首轮扫描收尾各压一次;`FTS_FORMAT` 换代时 open_conn 把+/// 记录清掉,换代的全量重写收尾也一定压+const FTS_COMPACT_EVERY_MS: i64 = 24 * 3600 * 1000;+/// 分块合并的块大小(FTS5 页):本机 561 MB 的 messages_fts 段实测 88 次合并、共 8 秒,+/// 每次持写锁不超过 120 ms(1000 页一块时最慢一次 550 ms,收藏切换会被它卡住)+const FTS_MERGE_PAGES: i64 = 250;fn open_conn(path: &Path) -> Result<Connection> {if let Some(dir) = path.parent() {@@ -236,6 +252,16 @@ fn open_conn(path: &Path) -> Result<Connection> {// tombstones.key 迁移(2026-08-24 加列,老库无此列;重复加列报错即忽略):// 墓碑按逻辑会话(key)+物理路径双轨屏蔽,多 location 副本不得复活已删会话let _ = conn.execute("ALTER TABLE tombstones ADD COLUMN key TEXT", []);+ // 放回识别的指纹列(2026-10-09):老墓碑的指纹是 NULL,永远不会被当成放回。逐列判:+ // 半途中断留下的半套列不得让下次开库报 duplicate column(那会被当成坏库重建)+ for column in ["file_size", "file_mtime"] {+ if !table_has_column(&conn, "tombstones", column)? {+ conn.execute(+ &format!("ALTER TABLE tombstones ADD COLUMN {column} INTEGER"),+ [],+ )?;+ }+ }if !table_has_column(&conn, "sessions", "parent_key")? {let tx = conn.transaction()?;tx.execute(@@ -272,6 +298,9 @@ fn open_conn(path: &Path) -> Result<Connection> {"INSERT OR REPLACE INTO schema_meta(key, value) VALUES ('fts_reindex', '1')",[],)?;+ // 全量重写会给每一行留一份删除标记加一份新段,收尾必须压一次:清掉上次压缩的+ // 记录,让它到期+ conn.execute("DELETE FROM schema_meta WHERE key = 'fts_compacted_at'", [])?;}conn.execute("INSERT OR REPLACE INTO schema_meta(key, value) VALUES ('fts_format', ?1)",@@ -851,17 +880,21 @@ impl Store {Ok(changed)}- /// schema_meta 里的一次性旗子(升级后要补做的事),做完由 scanner 清掉- fn has_meta_flag(&self, key: &str) -> bool {+ /// schema_meta 里的一个值;没有、或读不出都给 None+ fn meta_value(&self, key: &str) -> Option<String> {let conn = self.read.lock().unwrap();conn.query_row(- "SELECT 1 FROM schema_meta WHERE key = ?1",+ "SELECT value FROM schema_meta WHERE key = ?1",params![key],- |_| Ok(()),+ |r| r.get(0),).optional()- .map(|value| value.is_some())- .unwrap_or(false)+ .unwrap_or(None)+ }++ /// schema_meta 里的一次性旗子(升级后要补做的事),做完由 scanner 清掉+ fn has_meta_flag(&self, key: &str) -> bool {+ self.meta_value(key).is_some()}fn clear_meta_flag(&self, key: &str) -> Result<()> {@@ -890,6 +923,65 @@ impl Store {self.clear_meta_flag("fts_reindex")}+ /// 该不该做一次 FTS 压缩(节奏见 `FTS_COMPACT_EVERY_MS`)。读不出记录按到期算——+ /// 多压一次只费几秒+ pub fn fts_compaction_due(&self, now: i64) -> bool {+ self.meta_value("fts_compacted_at")+ .and_then(|v| v.parse::<i64>().ok())+ .is_none_or(|at| now.saturating_sub(at) >= FTS_COMPACT_EVERY_MS)+ }++ /// 把三张 FTS 表各自的段合并成一棵 b-tree,顺带丢掉删除标记。会话每重写一次+ /// (watcher 的增量、`FTS_FORMAT` 换代的全量重解析)都只追加新段与删除标记,automerge+ /// 收不回大段里的旧版本:本机实测 661 MB 的库里 557 MB 是 messages_fts 的段,压完+ /// 87 MB,多词查询从 10–20 ms 降到 0.4–2 ms。+ ///+ /// 按 FTS5 文档的分块做法:第一次 merge 传负数(所有段归到同一层、开局),之后传正数+ /// 续跑,`total_changes` 的增量小于 2 就是做完了。每块之间放开写锁,watcher 写入与+ /// 收藏切换照常插队;插进来的新段由正数续跑接着并,不会让合并重新开局+ pub fn compact_fts(&self, now: i64) -> Result<()> {+ // 防御上限:持续有写入时合并也终会收敛,这里只防万一卡在循环里(250 页一块,+ // 一万块远超任何真实索引)+ const MAX_CHUNKS: usize = 10_000;+ for table in ["messages_fts", "titles_fts", "memories_fts"] {+ let sql = format!("INSERT INTO {table}({table}, rank) VALUES ('merge', ?1)");+ let mut pages = -FTS_MERGE_PAGES;+ for _ in 0..MAX_CHUNKS {+ let conn = self.write.lock().unwrap();+ let before = conn.total_changes();+ conn.execute(&sql, params![pages])?;+ let done = conn.total_changes() - before < 2;+ drop(conn);+ if done {+ break;+ }+ pages = FTS_MERGE_PAGES;+ }+ }+ self.write.lock().unwrap().execute(+ "INSERT OR REPLACE INTO schema_meta(key, value) VALUES ('fts_compacted_at', ?1)",+ params![now.to_string()],+ )?;+ Ok(())+ }++ /// 压缩后空闲页占到三成、且至少 64 MiB 才 VACUUM,把文件真正缩回去(Settings → Data+ /// 显示的占用随之下降)。VACUUM 持写锁重写整个文件(本机 161 MB 约 1 秒),所以只在+ /// 确有大块空闲时做;做完把 WAL 截断,否则 WAL 文件会停在整库那么大+ pub fn reclaim_free_pages(&self) -> Result<()> {+ let conn = self.write.lock().unwrap();+ let pages: i64 = conn.query_row("PRAGMA page_count", [], |r| r.get(0))?;+ let free: i64 = conn.query_row("PRAGMA freelist_count", [], |r| r.get(0))?;+ let page_size: i64 = conn.query_row("PRAGMA page_size", [], |r| r.get(0))?;+ if free * 10 < pages * 3 || free * page_size < 64 << 20 {+ return Ok(());+ }+ conn.execute_batch("VACUUM")?;+ // 有读者(MCP / CLI 进程)占着快照时截不了,下次检查点再缩;不算失败+ let _ = conn.query_row("PRAGMA wal_checkpoint(TRUNCATE)", [], |_| Ok(()));+ Ok(())+ }+/// 当前胜出副本的 `(key, file_path)`,scanner 用 file_path 把同一 agent/// 的多 location 会话交回真正拥有它的 adapter 快照。pub fn session_sources_for_agent(&self, agent: AgentId) -> Result<Vec<(String, String)>> {@@ -920,6 +1012,11 @@ impl Store {/// 用某家 adapter 的全量快照原子替换父子关系。只接受库内存在、同 agent、/// 非自指的父子键;陈旧关系会被清空。返回是否真的改变了任何行。pub fn replace_parent_links(&self, agent: AgentId, links: &[(String, String)]) -> Result<bool> {+ // Claude 的分支关系每批 watcher 事件都会对账一遍,绝大多数时候什么都没变:在读连接+ // 上比一眼即回,不开写事务(replace_claims 同款早退)+ if self.parent_links_settled(agent, links)? {+ return Ok(false);+ }let mut conn = self.write.lock().unwrap();let tx = conn.transaction()?;let before: Vec<(String, String)> = {@@ -972,21 +1069,84 @@ impl Store {Ok(before != after)}- pub fn remove_session(&self, key: &str, tombstone: bool) -> Result<()> {- self.remove_sessions(&[key.to_string()], tombstone)+ /// `replace_parent_links` 写下去会不会什么都不变:每个子会话挂的父会话与写入路径算的+ /// 一致(每个子会话取第一条边;父会话不在库里、或就是自己的不挂),而且挂着的子会话+ /// 已经是父会话的项目(写入路径会把父会话的项目再铺一遍——子会话重解析后自己的项目+ /// 会盖回来,这时必须写)+ fn parent_links_settled(&self, agent: AgentId, links: &[(String, String)]) -> Result<bool> {+ let conn = self.read.lock().unwrap();+ let mut stmt = conn.prepare_cached(+ "SELECT key, parent_key, project_path, project_name FROM sessions WHERE agent_id = ?1",+ )?;+ let rows: HashMap<String, (String, String, String)> = stmt+ .query_map(params![agent.as_str()], |r| {+ Ok((r.get(0)?, (r.get(1)?, r.get(2)?, r.get(3)?)))+ })?+ .collect::<rusqlite::Result<_>>()?;+ let mut first: HashMap<&str, &str> = HashMap::new();+ for (child, parent) in links {+ first.entry(child.as_str()).or_insert(parent.as_str());+ }+ Ok(rows.iter().all(|(key, (parent_key, path, name))| {+ let wanted = first+ .get(key.as_str())+ .filter(|parent| **parent != key.as_str())+ .and_then(|parent| rows.get(*parent).map(|row| (*parent, row)));+ match wanted {+ None => parent_key.is_empty(),+ Some((parent, (_, parent_path, parent_name))) => {+ parent_key == parent+ && (parent_path.is_empty() || path == parent_path)+ && (parent_name.is_empty() || name == parent_name)+ }+ }+ }))}- /// 一棵会话树在索引侧原子删除。磁盘路径由调用方先整体移入废纸篓;若- /// 任一索引步骤失败,所有 session/message/FTS/tombstone 改动一起回滚。- pub fn remove_sessions(&self, keys: &[String], tombstone: bool) -> Result<()> {- self.remove_sessions_recorded(keys, tombstone, &[], now_ms())+ /// 出库、不记墓碑:扫描与 watcher 发现文件已经不在了。用户删除走+ /// `remove_trashed_sessions`,批量清理走 `complete_cleanup`+ pub fn remove_session(&self, key: &str) -> Result<()> {+ self.remove_sessions_recorded(&[key.to_string()], false, &[], now_ms(), &HashMap::new())+ }++ /// 单条删除:文件已经进了废纸篓。`fingerprint` 给出被移走的会话文件在移动**之前**的+ /// 指纹(`put_back_fingerprint`;SQLite 型会话的虚拟路径、移动前就不在的文件给 None),+ /// 记进墓碑。用户从废纸篓放回原处后,扫描看到同一路径、同一指纹的文件就撤掉墓碑+ /// (`release_put_back`)——确认框说"放回原处就会重新出现"靠的是这个。批量清理不走+ /// 这里:它有自己的清理记录与 Check 校验(内容哈希)+ pub fn remove_trashed_sessions(+ &self,+ keys: &[String],+ prints: &HashMap<String, (i64, i64)>,+ ) -> Result<()> {+ self.remove_sessions_recorded(keys, true, &[], now_ms(), prints)}/// Keep the reviewed paths even if the watcher already removed a missing/// source row. File moves and watcher delivery cannot share a transaction.pub fn complete_cleanup(&self, sessions: &[SessionMeta], stamp: i64) -> Result<()> {let keys = sessions.iter().map(|s| s.key.clone()).collect::<Vec<_>>();- self.remove_sessions_recorded(&keys, true, sessions, stamp)+ self.remove_sessions_recorded(&keys, true, sessions, stamp, &HashMap::new())+ }++ /// 这条路径压在墓碑下吗。扫描对每份候选文件都会问;读不出交 Err,扫描当它压着+ pub fn is_tombstoned(&self, file_path: &str) -> Result<bool> {+ let conn = self.read.lock().unwrap();+ let mut stmt = conn.prepare_cached("SELECT 1 FROM tombstones WHERE file_path = ?1")?;+ Ok(stmt.exists(params![file_path])?)+ }++ /// 放回识别:磁盘上这份文件的指纹(`put_back_fingerprint`)与删除前记下的一致——用户+ /// 把它从废纸篓放回原处了,撤掉墓碑(路径与 key 是同一行)。返回撤没撤。比较只在这条+ /// DELETE 的 WHERE 里:没记指纹的墓碑(批量清理、老墓碑、库存型会话)永远对不上,agent+ /// 在同一路径重新写出的文件也对不上,删除照旧生效+ pub fn release_put_back(&self, file_path: &str, print: (i64, i64)) -> Result<bool> {+ let conn = self.write.lock().unwrap();+ let released = conn.execute(+ "DELETE FROM tombstones WHERE file_path = ?1 AND file_size = ?2 AND file_mtime = ?3",+ params![file_path, print.0, print.1],+ )?;+ Ok(released > 0)}fn remove_sessions_recorded(@@ -995,6 +1155,7 @@ impl Store {tombstone: bool,recorded: &[SessionMeta],stamp: i64,+ prints: &HashMap<String, (i64, i64)>,) -> Result<()> {let mut conn = self.write.lock().unwrap();let tx = conn.transaction()?;@@ -1028,9 +1189,12 @@ impl Store {.find(|s| s.key == *key).map(|s| s.file_path.clone())}) {+ let (size, mtime) = prints.get(&fp).copied().unzip();tx.execute(- "INSERT OR REPLACE INTO tombstones(file_path, key, deleted_at) VALUES (?1, ?2, ?3)",- params![fp, key, stamp],+ "INSERT OR REPLACE INTO tombstones+ (file_path, key, deleted_at, file_size, file_mtime)+ VALUES (?1, ?2, ?3, ?4, ?5)",+ params![fp, key, stamp, size, mtime],)?;}}@@ -1039,6 +1203,17 @@ impl Store {Ok(())}+ /// 索引里这条路径的变更戳 (file_mtime, file_size),没入库给 None。watcher 拿它与+ /// `file_ref` 现算的引用比:没入库 = 新出现的文件,对不上 = 引用变了(`ref_dependents`)+ pub fn file_stamp(&self, file_path: &str) -> Result<Option<(i64, i64)>> {+ let conn = self.read.lock().unwrap();+ let mut stmt =+ conn.prepare_cached("SELECT file_mtime, file_size FROM sessions WHERE file_path = ?1")?;+ Ok(stmt+ .query_row(params![file_path], |r| Ok((r.get(0)?, r.get(1)?)))+ .optional()?)+ }+/// 路径 → 现行 key(watcher 增量的易主清理用)pub fn key_for_path(&self, file_path: &str) -> Result<Option<String>> {let conn = self.read.lock().unwrap();@@ -1064,7 +1239,7 @@ impl Store {.optional()?};if let Some(k) = &key {- self.remove_session(k, false)?;+ self.remove_session(k)?;}Ok(key)}@@ -1540,18 +1715,6 @@ impl Store {.unwrap_or(false)}- pub fn is_tombstoned(&self, file_path: &str) -> bool {- let conn = self.read.lock().unwrap();- conn.query_row(- "SELECT 1 FROM tombstones WHERE file_path = ?1",- params![file_path],- |_| Ok(()),- )- .optional()- .map(|o| o.is_some())- .unwrap_or(false)- }-/// 被外壳产品认领的全部会话 key(见 claimed_sessions 表)。scanner 在枚举时一次/// 取齐,跳过这些文件的解析;写入闸门另在事务里逐条查pub fn claimed_keys(&self) -> Result<std::collections::HashSet<String>> {@@ -2223,58 +2386,46 @@ impl Store {}let limit = if f.limit > 0 { f.limit } else { 20 };let (filter_sql, filter_args) = memory_filter(f);+ // FTS 与 LIKE 降级只差 SQL 与前导参数。片段取自正文、在 make_snippet 里开窗(FTS5 的+ // snippet() 在 trigram 下只露十几个字);只在标题里命中的,正文里找不到词,给正文开头+ let (sql, mut all_args): (String, Vec<Box<dyn rusqlite::ToSql>>) =+ if !needs_like_fallback(&segs) {+ (+ format!(+ "SELECT {MEMORY_COLS}+ FROM memories_fts JOIN memories m ON m.id = memories_fts.rowid+ {MEMORY_SESSION_JOIN}+ WHERE memories_fts MATCH ?{filter_sql}+ ORDER BY bm25(memories_fts) LIMIT ?"+ ),+ vec![Box::new(fts_match_expr(&segs))],+ )+ } else {+ (+ format!(+ "SELECT {MEMORY_COLS} FROM memories m {MEMORY_SESSION_JOIN}+ WHERE {}{filter_sql}+ ORDER BY m.updated_at DESC LIMIT ?",+ like_where(&["m.title", "m.body"], segs.len())+ ),+ like_args(&segs, 2),+ )+ };+ all_args.extend(filter_args);+ all_args.push(Box::new(limit));let conn = self.read.lock().unwrap();- let mut out = Vec::new();- if !needs_like_fallback(&segs) {- let mut stmt = conn.prepare_cached(&format!(- "SELECT {MEMORY_COLS}, snippet(memories_fts, 1, ?, ?, '…', 16)- FROM memories_fts JOIN memories m ON m.id = memories_fts.rowid- {MEMORY_SESSION_JOIN}- WHERE memories_fts MATCH ?{filter_sql}- ORDER BY bm25(memories_fts) LIMIT ?"- ))?;- let mut all_args: Vec<Box<dyn rusqlite::ToSql>> = vec![- Box::new(HL_OPEN.to_string()),- Box::new(HL_CLOSE.to_string()),- Box::new(fts_match_expr(&segs)),- ];- all_args.extend(filter_args);- all_args.push(Box::new(limit));- let rows = stmt.query_map(+ let hits = conn+ .prepare_cached(&sql)?+ .query_map(rusqlite::params_from_iter(all_args.iter().map(|b| b.as_ref())),|r| {- Ok(MemoryHit {- doc: row_to_memory(r)?,- // snippet 是 SELECT 里跟在 memory_cols! 后面的最后一列,按列数取——写死下标加列时- // 顶错过一次(2026-09-21)- snippet: r.get(r.as_ref().column_count() - 1)?,- })+ let doc = row_to_memory(r)?;+ let snippet = make_snippet(&doc.body, &segs);+ Ok(MemoryHit { doc, snippet })},- )?;- for r in rows {- out.push(r?);- }- } else {- let like_where = like_where(&["m.title", "m.body"], segs.len());- let mut stmt = conn.prepare_cached(&format!(- "SELECT {MEMORY_COLS} FROM memories m {MEMORY_SESSION_JOIN}- WHERE {like_where}{filter_sql}- ORDER BY m.updated_at DESC LIMIT ?"- ))?;- let mut all_args = like_args(&segs, 2);- all_args.extend(filter_args);- all_args.push(Box::new(limit));- let rows = stmt.query_map(- rusqlite::params_from_iter(all_args.iter().map(|b| b.as_ref())),- row_to_memory,- )?;- for r in rows {- let doc = r?;- let snippet = make_like_snippet(&doc.body, segs[0]);- out.push(MemoryHit { doc, snippet });- }- }- Ok(out)+ )?+ .collect::<rusqlite::Result<_>>()?;+ Ok(hits)}pub fn agent_counts(&self) -> Result<HashMap<String, i64>> {@@ -2621,80 +2772,55 @@ impl Store {let match_expr = fts_match_expr(&segs);let conn = self.read.lock().unwrap();- let mut raw: Vec<(String, i64, Option<String>, String, Option<i64>, String)> = Vec::new();+ // 正文命中:FTS 与 LIKE 降级只差 SQL 与前导参数;片段都取原文在 make_snippet 里开窗+ // (FTS5 的 snippet() 在 trigram 下只露十几个字)+ let (sql, mut all_args): (String, Vec<Box<dyn rusqlite::ToSql>>) = if !degraded {+ (+ format!(+ "SELECT m.session_key, m.seq, m.sidechain_id, m.role, m.ts, m.text+ FROM messages_fts+ JOIN messages m ON m.id = messages_fts.rowid+ JOIN sessions s ON s.key = m.session_key+ WHERE messages_fts MATCH ?{filter_sql}+ ORDER BY bm25(messages_fts) * {RECENCY_BOOST} LIMIT ?"+ ),+ vec![Box::new(match_expr.clone())],+ )+ } else {+ (+ format!(+ "SELECT m.session_key, m.seq, m.sidechain_id, m.role, m.ts, m.text+ FROM messages m JOIN sessions s ON s.key = m.session_key+ WHERE {}{filter_sql}+ ORDER BY m.ts DESC LIMIT ?",+ like_where(&["m.text"], segs.len())+ ),+ like_args(&segs, 1),+ )+ };+ all_args.extend(filter_args(f));if !degraded {- let sql = format!(- "SELECT m.session_key, m.seq, m.sidechain_id, m.role, m.ts,- snippet(messages_fts, 0, ?, ?, '…', 16)- FROM messages_fts- JOIN messages m ON m.id = messages_fts.rowid- JOIN sessions s ON s.key = m.session_key- WHERE messages_fts MATCH ?{filter_sql}- ORDER BY bm25(messages_fts) * {RECENCY_BOOST} LIMIT ?"- );- let mut stmt = conn.prepare_cached(&sql)?;- let mut all_args: Vec<Box<dyn rusqlite::ToSql>> = vec![- Box::new(HL_OPEN.to_string()),- Box::new(HL_CLOSE.to_string()),- Box::new(match_expr.clone()),- ];- all_args.extend(filter_args(f));all_args.push(Box::new(now));- all_args.push(Box::new(limit));- let rows = stmt.query_map(- rusqlite::params_from_iter(all_args.iter().map(|b| b.as_ref())),- |r| {- Ok((- r.get(0)?,- r.get(1)?,- r.get(2)?,- r.get(3)?,- r.get(4)?,- r.get(5)?,- ))- },- )?;- for r in rows {- raw.push(r?);- }- } else {- let like_where = like_where(&["m.text"], segs.len());- let sql = format!(- "SELECT m.session_key, m.seq, m.sidechain_id, m.role, m.ts, m.text- FROM messages m JOIN sessions s ON s.key = m.session_key- WHERE {like_where}{filter_sql}- ORDER BY m.ts DESC LIMIT ?"- );- let mut stmt = conn.prepare_cached(&sql)?;- let mut all_args = like_args(&segs, 1);- all_args.extend(filter_args(f));- all_args.push(Box::new(limit));- let rows = stmt.query_map(+ }+ all_args.push(Box::new(limit));+ let raw: Vec<(String, i64, Option<String>, String, Option<i64>, String)> = conn+ .prepare_cached(&sql)?+ .query_map(rusqlite::params_from_iter(all_args.iter().map(|b| b.as_ref())),|r| {+ let text: String = r.get(5)?;Ok((r.get(0)?,r.get(1)?,r.get(2)?,r.get(3)?,r.get(4)?,- r.get(5)?,+ make_snippet(&text, &segs),))},- )?;- for r in rows {- let (k, seq, sc, role, ts, text): (- String,- i64,- Option<String>,- String,- Option<i64>,- String,- ) = r?;- raw.push((k, seq, sc, role, ts, make_like_snippet(&text, segs[0])));- }- }+ )?+ .collect::<rusqlite::Result<_>>()?;// 标题命中:独立的 titles_fts。排在正文命中之前——词出现在标题里是最强的// 相关性信号;role 记 "title"、seq 记 0,跳转落到会话开头(标题没有对应的@@ -2740,7 +2866,7 @@ impl Store {)?;for r in rows {let (key, title) = r?;- title_raw.push((key, make_like_snippet(&title, segs[0])));+ title_raw.push((key, make_snippet(&title, &segs)));}}@@ -3117,26 +3243,84 @@ fn tally_wake_lookups(conn: &Connection, since_ms: i64) -> Result<Vec<LookupTallOk(rows)}-/// 清掉一条会话在库里的全部派生行:messages 及其 FTS 影子、wake_lookups。写入前-/// (write_session_tx)与删除时(remove_sessions_recorded)共用;titles_fts 不在这里,-/// 它随 upsert_session 走(quick 路径也要改标题)。再加一张派生表只改这里和写入侧+/// 清掉一条会话在库里的全部派生行:messages 及其 FTS 影子、wake_lookups。删除时+/// (remove_sessions_recorded / delete_session_row)用;写入侧走同一对原语+/// (`replace_units` + 重写 wake_lookups)。titles_fts 不在这里,它随 upsert_session 走+/// (quick 路径也要改标题)。再加一张派生表只改这里和写入侧fn clear_session_rows(tx: &rusqlite::Transaction<'_>, key: &str) -> Result<()> {- // FTS external content 需要显式 delete 旧行- let rows: Vec<(i64, String)> = tx- .prepare_cached("SELECT id, text FROM messages WHERE session_key = ?1")?- .query_map(params![key], |r| Ok((r.get(0)?, r.get(1)?)))?+ replace_units(tx, key, &[])?;+ tx.prepare_cached("DELETE FROM wake_lookups WHERE session_key = ?1")?+ .execute(params![key])?;+ Ok(())+}++/// 把一条会话的消息行换成 `units`,只动变了的尾部。活跃会话每追加一行、⌘R 的全量重扫、+/// `FTS_FORMAT` 换代都会把整条会话重解析一遍;原先一律整段删了重插,每次都给 FTS 留下+/// 一整份删除标记加新段(本机 661 MB 的库里 557 MB 是这些段)。现在按 id 顺序取出现有行,+/// 与新单元逐条比,最长的相同前缀原样留着,其后的旧行删掉(FTS 是外部内容表,要拿原文+/// 显式 delete)、新单元插入:没变的会话零写入,追加只写新行。新行的 id 比留下的都大,+/// 按 id 排的顺序仍是单元顺序+fn replace_units(tx: &rusqlite::Transaction<'_>, key: &str, units: &[IndexUnit]) -> Result<()> {+ type Row = (+ i64,+ Option<String>,+ i64,+ Option<String>,+ Option<i64>,+ String,+ );+ let existing: Vec<Row> = tx+ .prepare_cached(+ "SELECT id, sidechain_id, seq, role, ts, text FROM messages+ WHERE session_key = ?1 ORDER BY id",+ )?+ .query_map(params![key], |r| {+ Ok((+ r.get(0)?,+ r.get(1)?,+ r.get(2)?,+ r.get(3)?,+ r.get(4)?,+ r.get(5)?,+ ))+ })?.collect::<rusqlite::Result<_>>()?;- let mut fts_del = tx.prepare_cached(- "INSERT INTO messages_fts(messages_fts, rowid, text) VALUES ('delete', ?1, ?2)",+ let keep = existing+ .iter()+ .zip(units)+ .take_while(|((_, sidechain, seq, role, ts, text), u)| {+ *sidechain == u.sidechain_id+ && *seq == u.seq+ && role.as_deref() == Some(u.role.as_str())+ && *ts == u.timestamp+ && *text == u.text+ })+ .count();+ if let Some((first_stale, ..)) = existing.get(keep) {+ let mut fts_del = tx.prepare_cached(+ "INSERT INTO messages_fts(messages_fts, rowid, text) VALUES ('delete', ?1, ?2)",+ )?;+ for (id, .., text) in &existing[keep..] {+ fts_del.execute(params![id, text])?;+ }+ tx.prepare_cached("DELETE FROM messages WHERE session_key = ?1 AND id >= ?2")?+ .execute(params![key, first_stale])?;+ }+ let mut ins_msg = tx.prepare_cached(+ "INSERT INTO messages(session_key, sidechain_id, seq, role, ts, text) VALUES (?1,?2,?3,?4,?5,?6)",)?;- for (id, text) in rows {- fts_del.execute(params![id, text])?;+ let mut ins_fts = tx.prepare_cached("INSERT INTO messages_fts(rowid, text) VALUES (?1, ?2)")?;+ for u in &units[keep..] {+ ins_msg.execute(params![+ key,+ u.sidechain_id,+ u.seq,+ u.role.as_str(),+ u.timestamp,+ u.text+ ])?;+ ins_fts.execute(params![tx.last_insert_rowid(), u.text])?;}- drop(fts_del);- tx.prepare_cached("DELETE FROM messages WHERE session_key = ?1")?- .execute(params![key])?;- tx.prepare_cached("DELETE FROM wake_lookups WHERE session_key = ?1")?- .execute(params![key])?;Ok(())}@@ -3167,27 +3351,13 @@ fn write_session_tx(units: &[IndexUnit],lookups: &[WakeLookup],) -> Result<()> {- clear_session_rows(tx, &meta.key)?;upsert_session(tx, meta, file_mtime)?;-- let mut ins_msg = tx.prepare_cached(- "INSERT INTO messages(session_key, sidechain_id, seq, role, ts, text) VALUES (?1,?2,?3,?4,?5,?6)",- )?;- let mut ins_fts = tx.prepare_cached("INSERT INTO messages_fts(rowid, text) VALUES (?1, ?2)")?;- for u in units {- ins_msg.execute(params![- meta.key,- u.sidechain_id,- u.seq,- u.role.as_str(),- u.timestamp,- u.text- ])?;- let rowid = tx.last_insert_rowid();- ins_fts.execute(params![rowid, u.text])?;- }- // Wake 调用记录与 messages 同事务、同 key 删插;quick 路径(write_meta_only)- // 不经这里,所以不会把记录冲掉。绝大多数会话一次都没有,别为它白取一次语句+ replace_units(tx, &meta.key, units)?;+ // Wake 调用记录与 messages 同事务、同 key 删插(行数很少,整份重写);quick 路径+ // (write_meta_only)不经这里,所以不会把记录冲掉。绝大多数会话一次都没有,别为它+ // 白取一次插入语句+ tx.prepare_cached("DELETE FROM wake_lookups WHERE session_key = ?1")?+ .execute(params![meta.key])?;if !lookups.is_empty() {let mut ins_lookup = tx.prepare_cached("INSERT INTO wake_lookups(session_key, seq, ts, channel, tool) VALUES (?1,?2,?3,?4,?5)",@@ -3307,45 +3477,79 @@ fn like_args(segs: &[&str], cols: usize) -> Vec<Box<dyn rusqlite::ToSql>> {.collect()}-/// LIKE 降级路径的 snippet:不区分大小写找首个词项,前 40 / 后 80 字符开窗并高亮。+/// 命中片段:以最早出现的检索词为锚,前 40 / 后 80 字符开窗,窗口里每个检索词的每次+/// 出现都高亮(相邻、重叠的并成一段)。会话正文与记忆的 FTS / LIKE 两条路径、标题的 LIKE+/// 路径共用这一个(标题的 FTS 路径用 highlight() 给整个标题,标题短,不用开窗):FTS5 的+/// snippet() 按词元数开窗,trigram 分词下一个词元是三个字符的滑窗,16 个词元只露出十几个+/// 字,看不出命中在说什么。+////// 全程按**字符**下标走:逐字符小写并记下每个小写字符来自原文第几个字符——小写/// 不保长(Ω→ω、İ→i̇、K→k 字节数与字符数都会变),拿小写串里的字节偏移去切原文正是/// 2026-09-21 review 复现的 panic(⌘K 逐字键入 CJK 查询必经此路,后台线程 panic/// 直接 abort 整个 app)-fn make_like_snippet(text: &str, first_seg: &str) -> String {+fn make_snippet(text: &str, segs: &[&str]) -> String {+ const BEFORE: usize = 40;+ const AFTER: usize = 80;+ // 大小写按字符折叠,正文与词项同一个取法、对齐 FTS 的 trigram:它把 ΟΣΟΣ / οσος / οσοσ+ // 当成同一个词。整串 to_lowercase 会把词尾的 Σ 变成 ς(希腊文词尾 sigma 规则),逐字符的+ // 正文那边是 σ,两边就对不上;ς 也并成 σ+ let fold = |c: char| c.to_lowercase().map(|c| if c == 'ς' { 'σ' } else { c });let chars: Vec<char> = text.chars().collect();- let needle: Vec<char> = first_seg.to_lowercase().chars().collect();let mut lower: Vec<char> = Vec::with_capacity(chars.len());let mut origin: Vec<usize> = Vec::with_capacity(chars.len());- for (i, c) in chars.iter().enumerate() {- for lc in c.to_lowercase() {+ for (i, &c) in chars.iter().enumerate() {+ for lc in fold(c) {lower.push(lc);origin.push(i);}}- let hit = (!needle.is_empty())- .then(|| {- lower- .windows(needle.len())- .position(|w| w == needle.as_slice())- })- .flatten();- let Some(pos) = hit else {- return chars.iter().take(120).collect();+ // 每个词项的每次出现,换算成原文的字符区间 [start, end)+ let mut spans: Vec<(usize, usize)> = Vec::new();+ for seg in segs {+ let needle: Vec<char> = seg.chars().flat_map(fold).collect();+ if needle.is_empty() {+ continue;+ }+ let mut i = 0;+ while i + needle.len() <= lower.len() {+ if lower[i..i + needle.len()] == needle[..] {+ spans.push((origin[i], origin[i + needle.len() - 1] + 1));+ i += needle.len();+ } else {+ i += 1;+ }+ }+ }+ spans.sort_unstable();+ let Some(&(anchor_start, anchor_end)) = spans.first() else {+ return chars.iter().take(BEFORE + AFTER).collect();};- let char_idx = origin[pos];- let match_end = origin[pos + needle.len() - 1] + 1;- let start = char_idx.saturating_sub(40);- let end = (match_end + 80).min(chars.len());+ let start = anchor_start.saturating_sub(BEFORE);+ let end = (anchor_end + AFTER).min(chars.len());+ let mut marks: Vec<(usize, usize)> = Vec::new();+ for &(s, e) in &spans {+ if s >= end {+ break;+ }+ let e = e.min(end);+ match marks.last_mut() {+ Some(last) if s <= last.1 => last.1 = last.1.max(e),+ _ => marks.push((s, e)),+ }+ }let mut out = String::new();if start > 0 {out.push('…');}- out.extend(&chars[start..char_idx]);- out.push(HL_OPEN);- out.extend(&chars[char_idx..match_end]);- out.push(HL_CLOSE);- out.extend(&chars[match_end..end]);+ let mut cursor = start;+ for (s, e) in marks {+ out.extend(&chars[cursor..s]);+ out.push(HL_OPEN);+ out.extend(&chars[s..e]);+ out.push(HL_CLOSE);+ cursor = e;+ }+ out.extend(&chars[cursor..end]);if end < chars.len() {out.push('…');}@@ -3378,6 +3582,19 @@ pub fn now_ms() -> i64 {chrono::Utc::now().timestamp_millis()}+/// 放回识别里"同一份文件"的唯一定义:文件本身的大小与修改时间(废纸篓的移入与放回都是+/// 改名,两样都不变)。删除前(`cleanup::trash_sessions`)与重新出现时(scanner+/// `path_tombstoned`)都用它——+/// 不拿索引里的 file_size / file_mtime:那是 adapter 的变更戳,有的把边车、同根文件数+/// 算了进去,文件没动它也会变。不是普通文件给 None+pub fn put_back_fingerprint(path: &Path) -> Option<(i64, i64)> {+ let meta = std::fs::metadata(path).ok().filter(|m| m.is_file())?;+ Some((+ meta.len() as i64,+ crate::adapters::parse_utils::mtime_ms(&meta),+ ))+}+/// `--db` 给了就用它,否则取 GUI 那份。调用点一律**惰性**求值:/// `default_db_path` 首次调用会把旧 vibex 库拷过来,`--help` 不该触发它pub fn path_or_default(db: Option<&Path>) -> PathBuf {@@ -3414,3 +3631,66 @@ pub fn default_db_path() -> std::path::PathBuf {}db}++#[cfg(test)]+mod tests {+ use super::*;++ /// 把哨兵换成方括号,断言好写好读+ fn shown(s: &str) -> String {+ s.replace(HL_OPEN, "[").replace(HL_CLOSE, "]")+ }++ #[test]+ fn snippet_windows_around_the_first_hit_and_marks_every_term() {+ let text = format!(+ "{}先说二维码,再说 useEffect( 的挂载,最后又提到二维码。{}",+ "前文".repeat(40),+ "后文".repeat(80)+ );+ let s = shown(&make_snippet(&text, &["二维码", "useeffect("]));+ assert!(+ s.starts_with('…') && s.ends_with('…'),+ "长文两头都要省略:{s}"+ );+ assert!(+ s.contains("先说[二维码],再说 [useEffect(] 的挂载,最后又提到[二维码]"),+ "窗口里每个词的每次出现都标上,大小写按原文:{s}"+ );+ // 前 40 后 80 字符的窗口,再加两个省略号+ assert!(s.chars().count() <= 40 + 80 + "二维码".chars().count() + 2 + 6);+ }++ #[test]+ fn snippet_merges_overlapping_terms_and_falls_back_to_the_start() {+ assert_eq!(shown(&make_snippet("xabcdx", &["abc", "bcd"])), "x[abcd]x");+ let plain = "没有命中的长文本".repeat(30);+ let s = make_snippet(&plain, &["二维码"]);+ assert_eq!(s.chars().count(), 120, "找不到词就给开头 120 字");+ assert!(!s.contains(HL_OPEN));+ }++ #[test]+ fn snippet_survives_case_mappings_that_change_length() {+ // Ω/İ/K 小写后字符数或字节数会变,按原文字符下标切才不会 panic 或错位+ let s = shown(&make_snippet(+ "İstanbul Ωmega KELVIN 二维码",+ &["ωmega", "kelvin"],+ ));+ assert_eq!(s, "İstanbul [Ωmega] [KELVIN] 二维码");+ let s = shown(&make_snippet("İİİ二维码", &["二维码"]));+ assert_eq!(s, "İİİ[二维码]");+ }++ /// 希腊文词尾的 sigma:FTS 的 trigram 把 ΟΣΟΣ / οσος / οσοσ 当成同一个词,片段也得认得出——+ /// 整串小写会把查询词尾的 Σ 变成 ς,逐字符小写的正文那边却是 σ+ #[test]+ fn snippet_folds_greek_final_sigma_like_the_index() {+ let text = format!("{} ΟΣΟΣ τέλος", "α".repeat(200));+ for query in ["ΟΣΟΣ", "οσος", "οσοσ"] {+ let s = shown(&make_snippet(&text, &[query]));+ assert!(s.contains("[ΟΣΟΣ]"), "{query}: {s}");+ }+ assert!(shown(&make_snippet("τέλος οσος", &["ΟΣΟΣ"])).contains("[οσος]"));+ }+}diff --git a/crates/wake-core/src/mcp/tools.rs b/crates/wake-core/src/mcp/tools.rsindex 523c81f..2627fbd 100644--- a/crates/wake-core/src/mcp/tools.rs+++ b/crates/wake-core/src/mcp/tools.rs@@ -47,19 +47,24 @@ impl TranscriptCache {meta: &SessionMeta,) -> anyhow::Result<Arc<ParsedTranscript>> {let r = SessionFileRef::from_meta(meta);- // SQLite 型会话的 `<db>#<id>` 虚拟路径 stat 不到,from_meta 退回索引里的- // 时间——源库变了、Wake 没重扫时键不会变。改用库文件与 -wal 的 mtime- // 作戳(sqlite_ro 行缓存同款判据),源库一写就失效- let stamp = if std::path::Path::new(&r.file_path).exists() {- r.mtime_ms- } else {- let db = crate::adapters::sqlite_ro::strip_virtual_path(&r.file_path);- crate::adapters::sqlite_ro::db_cache_stamp(std::path::Path::new(db))+ let path = std::path::Path::new(&r.file_path);+ // 戳与扫描的脏判据同一把尺子:adapter 的引用(`file_ref`)把边车与同根文件数都算了+ // 进去——Claude 分支的原件被删 / 放回,分支文件不动,转录却要展开 / 折叠,只看文件+ // 本身会一直交旧转录、seq 与搜索对不上。SQLite 型会话的 `<db>#<id>` 虚拟路径 stat+ // 不到、也没有引用,改用库文件与 -wal 的 mtime(sqlite_ro 行缓存同款),源库一写就失效+ let (stamp, size) = match adapter.file_ref(path) {+ Some(current) => (current.mtime_ms, current.size),+ None if path.exists() => (r.mtime_ms, r.size),+ None => {+ let db = crate::adapters::sqlite_ro::strip_virtual_path(&r.file_path);+ let stamp = crate::adapters::sqlite_ro::db_cache_stamp(std::path::Path::new(db));+ (stamp, r.size)+ }};if let Some(cached) = self.0.lock().unwrap().as_ref() {if cached.path == r.file_path&& cached.mtime == stamp- && cached.size == r.size+ && cached.size == size&& cached.indexed_project == meta.project_path&& cached.indexed_model == meta.model{@@ -70,7 +75,7 @@ impl TranscriptCache {*self.0.lock().unwrap() = Some(CachedTranscript {path: r.file_path,mtime: stamp,- size: r.size,+ size,indexed_project: meta.project_path.clone(),indexed_model: meta.model.clone(),transcript: t.clone(),diff --git a/crates/wake-core/src/scanner.rs b/crates/wake-core/src/scanner.rsindex 3bf6ae2..4c33e06 100644--- a/crates/wake-core/src/scanner.rs+++ b/crates/wake-core/src/scanner.rs@@ -268,7 +268,7 @@ pub fn run_scan(events: &dyn ScanEvents,full: bool,) -> Result<()> {- let _gate = SCAN_GATE+ let gate = SCAN_GATE.lock().unwrap_or_else(std::sync::PoisonError::into_inner);let mut fin = ScanFinale {@@ -287,9 +287,60 @@ pub fn run_scan(fin.progress.error = Some(e.to_string());}fin.graceful = true;+ // 终态先发、扫描门先放:索引维护是后台杂务,不该让刷新的转圈多转几秒,也不该让+ // 维护期间按下的 ⌘R / 记忆刷新干等(合并分块进行,与写入照常交错)+ drop(fin);+ drop(gate);+ if result.is_ok() {+ maintain_index(store);+ }result}+/// 这条路径还压在墓碑下吗。用户从废纸篓放回的文件(磁盘上这份的指纹与删除前记下的对得上,+/// 比较在 `Store::release_put_back` 里)当场撤掉墓碑放行,放回去的会话在下一轮扫描或 watcher+/// 收到放回事件时就重新入库。压着墓碑的路径才去 stat。全量枚举与增量两处共用+fn path_tombstoned(store: &Store, r: &SessionFileRef) -> bool {+ match store.is_tombstoned(&r.file_path) {+ Ok(false) => false,+ Ok(true) => {+ !crate::db::put_back_fingerprint(Path::new(&r.file_path)).is_some_and(|print| {+ store+ .release_put_back(&r.file_path, print)+ .unwrap_or_else(|e| {+ eprintln!("[scanner] put-back release failed {}: {e:#}", r.file_path);+ false+ })+ })+ }+ Err(e) => {+ eprintln!("[scanner] tombstone check failed {}: {e:#}", r.file_path);+ true+ }+ }+}++/// 扫描收尾的索引维护:到期才压缩 FTS(见 `Store::compact_fts`),压完有大块空闲再+/// VACUUM。在扫描门外跑,自己一把门:前一次维护还没完就跳过,下一轮扫描照样到期再来。+/// 失败只记日志——维护做不成不影响这一轮扫描的结果+fn maintain_index(store: &Store) {+ static MAINTENANCE: std::sync::Mutex<()> = std::sync::Mutex::new(());+ let Ok(_maintaining) = MAINTENANCE.try_lock() else {+ return;+ };+ let now = crate::db::now_ms();+ if !store.fts_compaction_due(now) {+ return;+ }+ if let Err(e) = store.compact_fts(now) {+ eprintln!("wake: compacting the search index failed: {e:#}");+ return;+ }+ if let Err(e) = store.reclaim_free_pages() {+ eprintln!("wake: reclaiming index space failed: {e:#}");+ }+}+/// 只同步记忆、不碰会话:Memory 页的 Refresh 与 Settings → Memory locations 变更的/// 收尾(用户 2026-09-22 定"memory 的只刷 memory、session 的只刷 session,不然设置里/// 分开的 locations 就没意义")。读的是当下的 Memory locations 配置(停用 / 自定义 /@@ -391,9 +442,7 @@ fn run_scan_inner(// 删除只 trash 了胜者文件,别的 location 里的副本不得复活它//(2026-08-24 Codex review P1)。key 按实例 host 构造(远程三段)// ——阶段 1 远程禁删故无远程墓碑,但格式先写对,放开时不欠债- .filter(|r| {- !store.is_tombstoned(&r.file_path) && !store.is_key_tombstoned(&key_of(ix, r))- })+ .filter(|r| !path_tombstoned(store, r) && !store.is_key_tombstoned(&key_of(ix, r)))// 被外壳产品认领的替身(Craft 的 Claude 后端在 ~/.claude 落的那份)不索引:// 不在 seen_paths 里,库里若还有它的行,下面的删除检测一并清掉.filter(|r| !claimed.contains(&key_of(ix, r)))@@ -447,7 +496,7 @@ fn run_scan_inner(for r in refs {if let Some((_, _, key)) = known.get(&r.file_path) {if key.split(':').next() != Some(r.agent.as_str()) {- let _ = store.remove_session(key, false);+ let _ = store.remove_session(key);owner_changed.insert(r.file_path.clone());}}@@ -526,7 +575,7 @@ fn run_scan_inner(let mut pruned = false;for (path, (_, _, key)) in &known {if !seen_paths.contains(path) && !owner_of(path).is_some_and(|ix| frozen.contains(&ix)) {- let _ = store.remove_session(key, false);+ let _ = store.remove_session(key);pruned = true;}}@@ -1115,7 +1164,7 @@ pub fn scan_files(let mut by_adapter: std::collections::HashMap<usize, Vec<SessionFileRef>> =std::collections::HashMap::new();for r in refs {- if store.is_tombstoned(&r.file_path) {+ if path_tombstoned(store, &r) {continue;}let Some(ix) = crate::adapters::adapter_ix_for(adapters, r.agent, &r.file_path) else {@@ -1147,7 +1196,7 @@ pub fn scan_files(// 写入撞 file_path UNIQUE,会话永远停在旧家(Codex review P1)if let Ok(Some(old_key)) = store.key_for_path(&r.file_path) {if old_key.split(':').next() != Some(meta.agent.as_str()) {- let _ = store.remove_session(&old_key, false);+ let _ = store.remove_session(&old_key);}}// 副本裁决在写事务内(write_session_guarded):先查后写与diff --git a/crates/wake-core/src/services/terminal/mod.rs b/crates/wake-core/src/services/terminal/mod.rsindex 6fa8f82..b24df6d 100644--- a/crates/wake-core/src/services/terminal/mod.rs+++ b/crates/wake-core/src/services/terminal/mod.rs@@ -459,9 +459,10 @@ pub(crate) fn validate_trash_path(path: &Path) -> anyhow::Result<()> {/// 删除会话文件到系统回收站(可恢复)。虚拟路径 `<db>#<id>` 与已消失的/// 文件在此过滤(不变量 3:SQLite 型只 tombstone),平台原语只收真实路径。+/// 返回真被移进回收站的那些路径(一个都没有 = 全是库存型会话,只是从 Wake 隐藏)。/// 部分失败语义:平台实现可能删到一半报错(macOS 逐文件、Linux/Windows/// 批量),调用方按"整批可疑"处理即可——已进回收站的文件可恢复,无害。-pub fn trash_paths(paths: &[String]) -> anyhow::Result<()> {+pub fn trash_paths(paths: &[String]) -> anyhow::Result<Vec<String>> {let existing: Vec<&str> = paths.iter().map(|s| s.as_str())@@ -472,10 +473,10 @@ pub fn trash_paths(paths: &[String]) -> anyhow::Result<()> {for path in &existing {validate_trash_path(Path::new(path))?;}- if existing.is_empty() {- return Ok(());+ if !existing.is_empty() {+ platform::trash_existing(&existing)?;}- platform::trash_existing(&existing)+ Ok(existing.into_iter().map(String::from).collect())}/// Open the system trash for the user to inspect the reviewed batch. Neverdiff --git a/crates/wake-core/src/watcher.rs b/crates/wake-core/src/watcher.rsindex 386e2b4..e67cf95 100644--- a/crates/wake-core/src/watcher.rs+++ b/crates/wake-core/src/watcher.rs@@ -161,6 +161,33 @@ pub(crate) fn process_batch(}}+ // 新出现(还没入库)与消失的会话文件可能改变同实例别的文件的引用(`ref_dependents`:+ // Claude 的分支数着同目录更早的同根文件)。那些文件没动、没有事件,这里按引用与索引+ // 重比,变了的跟本批一起收编——Wake 里删原件、从废纸篓放回、Claude 自己清理旧会话,+ // 留下的分支都当场展开 / 折叠,不用等下一次全量扫描+ let appeared = present+ .iter()+ .filter(|(path, _)| matches!(store.file_stamp(&path.to_string_lossy()), Ok(None)))+ .map(|(path, ix)| (path, *ix));+ let vanished = gone+ .iter()+ .filter_map(|path| resolve_watch_agent(roots, path).map(|ix| (path, ix)));+ let dependents: Vec<SessionFileRef> = appeared+ .chain(vanished)+ .flat_map(|(path, ix)| {+ let adapter = &adapters[ix];+ adapter+ .ref_dependents(path)+ .into_iter()+ .filter_map(|dependent| adapter.file_ref(&dependent))+ })+ .filter(|r| {+ store+ .file_stamp(&r.file_path)+ .is_ok_and(|stamp| stamp.is_some_and(|stamp| stamp != (r.mtime_ms, r.size)))+ })+ .collect();+let removed_keys: Vec<String> = gone.iter().filter_map(|path| store.remove_by_path(&path.to_string_lossy()).ok().flatten())@@ -185,6 +212,7 @@ pub(crate) fn process_batch(let refs: Vec<SessionFileRef> = present.into_iter().filter_map(|(path, ix)| adapters.get(ix).and_then(|a| a.file_ref(&path)))+ .chain(dependents).filter(|r| seen.insert(r.file_path.clone())).collect();let scanned_agents: HashSet<AgentId> = refs.iter().map(|reference| reference.agent).collect();@@ -373,6 +401,94 @@ mod tests {assert!(!claimed.contains("claude-code:sdk-1"), "{claimed:?}");}+ /// Claude Code 的分支 B 开头原样复制了原件 A 的第一轮。A 在 Wake 之外消失(Claude 按+ /// cleanupPeriodDays 清掉、在 Finder 里删掉)或者被放回时,B 的文件没动、没有它的事件——+ /// watcher 经 `ref_dependents` 把它补进同一批:A 没了,B 展开完整历史、变回顶层;+ /// A 回来,B 重新折叠、挂回 A 下面+ #[test]+ fn claude_branches_follow_their_original_coming_and_going() {+ use crate::adapters::claude::ClaudeAdapter;+ let tmp = tempfile::tempdir().unwrap();+ let root = tmp.path().join("projects");+ let dir = root.join("-w");+ std::fs::create_dir_all(&dir).unwrap();+ let (id_a, id_b) = (+ "c1a0de00-0000-4000-8000-0000000000a1",+ "c1a0de00-0000-4000-8000-0000000000b2",+ );+ let row = |session: &str, uuid: &str, ts: &str, message: serde_json::Value| {+ serde_json::json!({+ "parentUuid": null, "isSidechain": false, "cwd": "/w", "sessionId": session,+ "type": message["role"], "message": message, "uuid": uuid, "timestamp": ts,+ })+ .to_string()+ };+ let user = |text: &str| serde_json::json!({ "role": "user", "content": text });+ let file = |session: &str, opened: &str, own: &str| {+ let queued = serde_json::json!({+ "type": "queue-operation", "operation": "enqueue",+ "timestamp": opened, "sessionId": session,+ });+ let reply = serde_json::json!({+ "id": "msg_shared", "role": "assistant", "model": "claude-opus-5-5",+ "content": [{ "type": "text", "text": "The connection pool is exhausted." }],+ });+ [+ queued.to_string(),+ row(+ session,+ "u1",+ "2026-09-01T08:00:01.000Z",+ user("Why does login time out?"),+ ),+ row(session, "u2", "2026-09-01T08:00:05.000Z", reply),+ row(session, own, "2026-09-02T09:00:10.000Z", user(own)),+ ]+ .join("\n")+ };+ let a = dir.join(format!("{id_a}.jsonl"));+ let b = dir.join(format!("{id_b}.jsonl"));+ let original = file(id_a, "2026-09-01T08:00:00.000Z", "add exponential backoff");+ std::fs::write(&a, &original).unwrap();+ std::fs::write(+ &b,+ file(id_b, "2026-09-02T09:00:00.000Z", "move login to a queue"),+ )+ .unwrap();++ let store = Arc::new(Store::open(&tmp.path().join("wake.db")).unwrap());+ let adapters: Vec<Box<dyn AgentAdapter>> =+ vec![ClaudeAdapter::new().with_custom_root(root.clone())];+ let roots = vec![(root, 0)];+ crate::scanner::run_scan(&adapters, &store, &NullEvents, true).unwrap();+ let (key_a, key_b) = (format!("claude-code:{id_a}"), format!("claude-code:{id_b}"));+ let shared_turn = || -> Vec<String> {+ let (hits, _) = store.search("connection pool", &[], None, 10).unwrap();+ hits.into_iter().map(|h| h.session.key).collect()+ };+ let parent_of_b = || store.parent_key_of(&key_b).unwrap();+ let event = |kind: EventKind| {+ let batch = vec![Ok(notify::Event::new(kind).add_path(a.clone()))];+ process_batch(&adapters, &store, &NullEvents, &roots, batch);+ };+ assert_eq!(shared_turn(), vec![key_a.clone()]);+ assert_eq!(parent_of_b(), Some(key_a.clone()));++ std::fs::remove_file(&a).unwrap();+ event(EventKind::Remove(RemoveKind::File));+ assert_eq!(+ shared_turn(),+ vec![key_b.clone()],+ "共有的那一轮回到分支名下"+ );+ assert_eq!(parent_of_b(), None);++ std::fs::write(&a, &original).unwrap();+ event(EventKind::Create(CreateKind::File));+ assert_eq!(shared_turn(), vec![key_a.clone()]);+ assert_eq!(parent_of_b(), Some(key_a));+ }+#[test]fn dropping_watcher_joins_worker_and_releases_its_state() {let fx = Fixture::new();diff --git a/crates/wake-core/tests/adapter_contracts.rs b/crates/wake-core/tests/adapter_contracts.rsindex 65a3449..ed6d8b2 100644--- a/crates/wake-core/tests/adapter_contracts.rs+++ b/crates/wake-core/tests/adapter_contracts.rs@@ -510,6 +510,83 @@ fn claude_parse_contract() {assert_eq!(s2.meta.message_count, 1);}+/// Claude Code 的分支会话(开头原样复制了原对话的一段):复制来的一段折成一条 Meta、分支+/// 挂到原件下;标题、token、创建时间只算分支自己的行;自定义标题照抄原件的不当标题用。+/// 列表与 file_ref 的引用都把"更早的同根文件有几份"计进 size,原件没了引用随之变化、+/// 分支重解析后露出完整历史。在私有临时目录里搭(共用的假 HOME 只读)+#[test]+fn claude_branches_fold_the_copied_history_and_nest_under_the_original() {+ let tmp = tempfile::tempdir().unwrap();+ let projects = tmp.path().join("projects");+ let (dir, a, b) = common::stage_claude_branch(&projects);+ let adapter = ClaudeAdapter::new().with_custom_root(projects.clone());+ let path_a = dir.join(format!("{a}.jsonl"));+ let path_b = dir.join(format!("{b}.jsonl"));+ let size = |p: &Path| fs::metadata(p).unwrap().len() as i64;++ let listed = adapter.list_session_files().unwrap();+ let listed_ref = |id: &str| listed.iter().find(|r| r.native_id == id).unwrap().clone();+ let (ref_a, ref_b) = (listed_ref(&a), listed_ref(&b));+ assert_eq!(ref_a.size, size(&path_a), "原件之前没有同根文件");+ assert_eq!(ref_b.size, size(&path_b) + 1, "分支之前有一份同根文件");+ let watched = adapter.file_ref(&path_b).unwrap();+ assert_eq!(+ (watched.mtime_ms, watched.size),+ (ref_b.mtime_ms, ref_b.size),+ "watcher 的引用要与列表一致"+ );++ // 原件不受影响+ let sa = adapter.parse_session(&ref_a).unwrap();+ assert_eq!(sa.meta.title, "修复登录超时");+ assert_eq!(sa.meta.message_count, 4);+ assert_eq!(sa.meta.tokens_used, Some(350));++ // 分支:复制来的两条折成一条 Meta,自己的一问一答从 seq 1 起+ let sb = adapter.parse_session(&ref_b).unwrap();+ let tb = adapter.parse_transcript(&ref_b).unwrap();+ assert_eq!(+ roles_kinds(&tb.mainline),+ vec![+ (Role::System, MessageKind::Meta),+ (Role::User, MessageKind::Text),+ (Role::Assistant, MessageKind::Text),+ ]+ );+ assert!(tb.mainline[0]+ .text+ .contains("2 messages inherited from the parent session"));+ assert_eq!(tb.mainline[1].text, "换个思路:登录改成异步队列");+ assert_eq!(+ sb.units.iter().map(|u| u.seq).collect::<Vec<_>>(),+ vec![1, 2],+ "索引的 seq 与详情页一致,复制来的那段不进索引"+ );+ assert_eq!(sb.meta.message_count, 2);+ assert_eq!(sb.meta.title, "换个思路:登录改成异步队列", "照抄的标题不用");+ assert_eq!(sb.meta.tokens_used, Some(340), "复制来的那次调用不重复计");+ assert_eq!(sb.meta.created_at, ms("2026-09-02T09:00:10Z"));++ assert_eq!(+ adapter.parent_links(),+ Some(vec![(+ format!("claude-code:{b}"),+ format!("claude-code:{a}")+ )])+ );++ // 原件被删(Claude 的 cleanupPeriodDays):引用变了,分支露出完整历史、自己也不再是子会话+ fs::remove_file(&path_a).unwrap();+ let listed = adapter.list_session_files().unwrap();+ let ref_b = listed.iter().find(|r| r.native_id == b).unwrap().clone();+ assert_eq!(ref_b.size, size(&path_b));+ let sb = adapter.parse_session(&ref_b).unwrap();+ assert_eq!(sb.meta.message_count, 4);+ assert_eq!(sb.meta.title, "修复登录超时");+ assert_eq!(sb.meta.tokens_used, Some(460));+ assert_eq!(adapter.parent_links(), Some(Vec::new()));+}+#[test]fn codex_parse_contract() {setup();diff --git a/crates/wake-core/tests/cli.rs b/crates/wake-core/tests/cli.rsindex 503812b..2c7967c 100644--- a/crates/wake-core/tests/cli.rs+++ b/crates/wake-core/tests/cli.rs@@ -584,7 +584,7 @@ fn refresh_brings_an_existing_index_up_to_date() {let path = db.to_str().unwrap();Store::open(&db).unwrap()- .remove_session(CLAUDE_KEY, false)+ .remove_session(CLAUDE_KEY).unwrap();let (_, _, code) = cli_raw(&["--db", path, "show", CLAUDE_KEY, "--messages", "1"]);assert_eq!(code, Some(1), "抠掉的会话按 key 该是读不出来的");diff --git a/crates/wake-core/tests/common/mod.rs b/crates/wake-core/tests/common/mod.rsindex 97821b8..55f4851 100644--- a/crates/wake-core/tests/common/mod.rs+++ b/crates/wake-core/tests/common/mod.rs@@ -1259,3 +1259,119 @@ pub fn lock_as(db: &Path, kind: &str) -> IndexLock {}}}++/// Claude Code 的分支会话:原件 A 问了两轮;B 是从 A 第一轮之后分出来的——Claude 把 A 到+/// 分叉点为止的行**原样**复制进 B 的开头(uuid、message.id、时间戳都不变,只改 sessionId),+/// 头几行(custom-title 照抄 A 的标题、queue-operation)是复制那一刻写的,时间晚于 A 的开头。+/// 之后 B 问了自己的一轮。返回 (项目目录, A 的 id, B 的 id)。adapter_contracts 与+/// scanner_finale 共用+pub fn stage_claude_branch(projects: &Path) -> (PathBuf, String, String) {+ let dir = projects.join("-Users-tester-Github-branchfx");+ fs::create_dir_all(&dir).unwrap();+ let a = "c1a0de00-0000-4000-8000-0000000000a1".to_string();+ let b = "c1a0de00-0000-4000-8000-0000000000b2".to_string();+ let row = |session: &str,+ typ: &str,+ uuid: &str,+ parent: Option<&str>,+ ts: &str,+ message: serde_json::Value| {+ serde_json::json!({+ "parentUuid": parent,+ "isSidechain": false,+ "cwd": "/Users/tester/Github/branchfx",+ "sessionId": session,+ "type": typ,+ "message": message,+ "uuid": uuid,+ "timestamp": ts,+ })+ };+ let user = |text: &str| serde_json::json!({ "role": "user", "content": text });+ let reply = |id: &str, text: &str, input: i64, output: i64| {+ serde_json::json!({+ "id": id,+ "role": "assistant",+ "model": "claude-opus-5-5",+ "content": [{ "type": "text", "text": text }],+ "usage": { "input_tokens": input, "output_tokens": output },+ })+ };+ let header = |session: &str, ts: &str| {+ vec![+ serde_json::json!({ "type": "custom-title", "customTitle": "修复登录超时", "sessionId": session }),+ serde_json::json!({ "type": "queue-operation", "operation": "enqueue", "timestamp": ts, "sessionId": session }),+ ]+ };+ // 两份共有的第一轮:B 里的是原样复制(只有 sessionId 不同)+ let shared = |session: &str| {+ vec![+ row(+ session,+ "user",+ "c1a0de00-1111-4000-8000-000000000001",+ None,+ "2026-09-01T08:00:01.000Z",+ user("登录接口偶发超时,先看看日志"),+ ),+ row(+ session,+ "assistant",+ "c1a0de00-1111-4000-8000-000000000002",+ Some("c1a0de00-1111-4000-8000-000000000001"),+ "2026-09-01T08:00:05.000Z",+ reply(+ "msg_shared_01",+ "日志里连接池耗尽了,把上限从 10 调到 50。",+ 100,+ 20,+ ),+ ),+ ]+ };+ let mut lines_a = header(&a, "2026-09-01T08:00:00.000Z");+ lines_a.extend(shared(&a));+ lines_a.push(row(+ &a,+ "user",+ "c1a0de00-1111-4000-8000-000000000003",+ Some("c1a0de00-1111-4000-8000-000000000002"),+ "2026-09-01T08:10:00.000Z",+ user("调了,还是超时"),+ ));+ lines_a.push(row(+ &a,+ "assistant",+ "c1a0de00-1111-4000-8000-000000000004",+ Some("c1a0de00-1111-4000-8000-000000000003"),+ "2026-09-01T08:10:05.000Z",+ reply("msg_a_02", "那再加个指数退避的重试。", 200, 30),+ ));++ let mut lines_b = header(&b, "2026-09-02T09:00:00.000Z");+ lines_b.extend(shared(&b));+ lines_b.push(row(+ &b,+ "user",+ "c1a0de00-2222-4000-8000-000000000003",+ Some("c1a0de00-1111-4000-8000-000000000002"),+ "2026-09-02T09:00:10.000Z",+ user("换个思路:登录改成异步队列"),+ ));+ lines_b.push(row(+ &b,+ "assistant",+ "c1a0de00-2222-4000-8000-000000000004",+ Some("c1a0de00-2222-4000-8000-000000000003"),+ "2026-09-02T09:00:15.000Z",+ reply("msg_b_02", "好,登录请求进后台队列,前端轮询结果。", 300, 40),+ ));++ let write = |id: &str, lines: &[serde_json::Value]| {+ let text: String = lines.iter().map(|l| format!("{l}\n")).collect();+ fs::write(dir.join(format!("{id}.jsonl")), text).unwrap();+ };+ write(&a, &lines_a);+ write(&b, &lines_b);+ (dir, a, b)+}diff --git a/crates/wake-core/tests/db_roundtrip.rs b/crates/wake-core/tests/db_roundtrip.rsindex 3f8b67d..a80f92e 100644--- a/crates/wake-core/tests/db_roundtrip.rs+++ b/crates/wake-core/tests/db_roundtrip.rs@@ -1,6 +1,7 @@//! Store 写入/搜索/删除语义的往返测试(临时库,不碰真实索引)。//! 覆盖 CLAUDE.md 不变量 3:tombstone 防复活、user_data 独立表重建不丢。+use std::collections::HashMap;use std::time::{Duration, Instant};use wake_core::db::{self, IndexLock, Ownership, Store, Wait};@@ -76,6 +77,215 @@ fn search_roundtrip_hits_correct_seq() {assert_eq!(hits.len(), 1);}+/// messages_fts 的段数据行数:FTS 每写一次都长新段,原样重写与压缩看的都是它+fn fts_data_rows(raw: &rusqlite::Connection) -> i64 {+ raw.query_row("SELECT count(*) FROM messages_fts_data", [], |r| r.get(0))+ .unwrap()+}++/// FTS 压缩:会话反复整段重写攒下的段与删除标记被合并掉,搜索结果一字不变;压过之后+/// 一天内不再到期;`FTS_FORMAT` 换代重开库会让它重新到期(换代的全量重写收尾必须压)+#[test]+fn fts_compaction_drops_rewrite_garbage_and_keeps_results() {+ let (dir, store) = temp_store();+ let path = dir.path().join("test.db");+ let m = meta("claude-code:compact", "压缩测试");+ // 每轮每条都改(轮次写进正文):尾部比对从第一条起就不同、整段换新,FTS 攒下旧段与删除标记+ for round in 0..40 {+ let units: Vec<IndexUnit> = (0..30)+ .map(|i| {+ let role = if i % 2 == 0 {+ Role::User+ } else {+ Role::Assistant+ };+ unit(+ i,+ role,+ &format!("第 {round} 轮第 {i} 条:二维码扫描 useEffect( 挂载"),+ )+ })+ .collect();+ store+ .write_session(&m, m.updated_at + round, &units)+ .unwrap();+ }+ let raw = rusqlite::Connection::open(&path).unwrap();+ let fts_rows = || fts_data_rows(&raw);+ let hits = |q: &str| -> Vec<(String, i64, String)> {+ let (hits, _) = store.search(q, &[], None, 100).unwrap();+ hits.into_iter()+ .map(|h| (h.session.key, h.seq, h.snippet))+ .collect()+ };+ let before = (hits("二维码"), hits("useEffect("), hits("第 39 轮第 7 条"));+ let rows_before = fts_rows();++ let now = db::now_ms();+ assert!(store.fts_compaction_due(now), "从没压过就算到期");+ store.compact_fts(now).unwrap();+ assert!(+ fts_rows() < rows_before / 2,+ "合并后段数据应大幅减少:{rows_before} → {}",+ fts_rows()+ );+ assert_eq!(+ (hits("二维码"), hits("useEffect("), hits("第 39 轮第 7 条")),+ before,+ "压缩不得改变任何搜索结果"+ );+ assert!(+ !store.fts_compaction_due(now + 3_600_000),+ "一小时后还不到期"+ );+ assert!(store.fts_compaction_due(now + 25 * 3_600_000), "一天后到期");++ // 换代:库里记的派生版本对不上 → 重开时挂 fts_reindex,压缩记录一并清掉+ raw.execute(+ "UPDATE schema_meta SET value = '0' WHERE key = 'fts_format'",+ [],+ )+ .unwrap();+ drop(store);+ let reopened = Store::open(&path).unwrap();+ assert!(reopened.needs_fts_reindex());+ assert!(+ reopened.fts_compaction_due(now + 60_000),+ "换代的全量重写收尾必须再压一次"+ );+}++/// 关系没变就不写(每批 watcher 事件都会对账一遍);子会话重解析后自己的项目盖回来了,+/// 关系虽然没变也要再写一遍,把父会话的项目铺回去+#[test]+fn unchanged_parent_links_skip_the_write_but_inherited_projects_are_restored() {+ let (_dir, store) = temp_store();+ let parent = meta("claude-code:orig", "原件");+ let mut child = meta("claude-code:branch", "分支");+ child.project_path = "/tmp/elsewhere".into();+ child.project_name = "elsewhere".into();+ child.file_path = "/tmp/fixtures/branch.jsonl".into();+ store+ .write_meta_only(&[(parent.clone(), 1), (child.clone(), 1)])+ .unwrap();+ let links = [(child.key.clone(), parent.key.clone())];+ assert!(store+ .replace_parent_links(AgentId::ClaudeCode, &links)+ .unwrap());+ assert_eq!(+ store.get_session(&child.key).unwrap().unwrap().project_path,+ parent.project_path,+ "挂上去就继承父会话的项目"+ );+ assert!(+ !store+ .replace_parent_links(AgentId::ClaudeCode, &links)+ .unwrap(),+ "什么都没变"+ );++ // 子会话重解析:upsert 把它自己的项目写回来,关系列不动+ store.write_meta_only(&[(child.clone(), 2)]).unwrap();+ assert_eq!(+ store.get_session(&child.key).unwrap().unwrap().project_path,+ "/tmp/elsewhere"+ );+ store+ .replace_parent_links(AgentId::ClaudeCode, &links)+ .unwrap();+ assert_eq!(+ store.get_session(&child.key).unwrap().unwrap().project_path,+ parent.project_path,+ "关系没变也要把父会话的项目铺回去"+ );+ assert_eq!(+ store.parent_key_of(&child.key).unwrap().as_deref(),+ Some(parent.key.as_str())+ );+}++/// 会话重写只动变了的尾部:原样重写不碰任何行(id 不变、FTS 不长新段),追加只插新行,+/// 中间改了从那条起换掉,变短了删掉多出的——搜索结果始终与最后一次写入一致+#[test]+fn rewriting_a_session_only_touches_the_changed_tail() {+ let (dir, store) = temp_store();+ let m = meta("claude-code:tail", "尾部重写");+ let raw = rusqlite::Connection::open(dir.path().join("test.db")).unwrap();+ let ids = || -> Vec<i64> {+ raw.prepare("SELECT id FROM messages WHERE session_key = 'claude-code:tail' ORDER BY id")+ .unwrap()+ .query_map([], |r| r.get(0))+ .unwrap()+ .collect::<rusqlite::Result<_>>()+ .unwrap()+ };+ let fts_rows = || fts_data_rows(&raw);+ let found = |q: &str| -> Vec<i64> {+ let (hits, _) = store.search(q, &[], None, 10).unwrap();+ hits.into_iter().map(|h| h.seq).collect()+ };+ let a = unit(0, Role::User, "第一问:二维码扫描怎么做");+ let b = unit(1, Role::Assistant, "第一答:用 useEffect( 挂载");+ let c = unit(2, Role::User, "第二问:相机权限被拒");++ store+ .write_session(&m, 1, &[a.clone(), b.clone(), c.clone()])+ .unwrap();+ let first = ids();+ let segments = fts_rows();++ store+ .write_session(&m, 2, &[a.clone(), b.clone(), c.clone()])+ .unwrap();+ assert_eq!(ids(), first, "原样重写不换行");+ assert_eq!(fts_rows(), segments, "原样重写不给 FTS 添任何东西");++ let d = unit(3, Role::Assistant, "第二答:引导去系统设置开权限");+ store+ .write_session(&m, 3, &[a.clone(), b.clone(), c.clone(), d.clone()])+ .unwrap();+ let appended = ids();+ assert_eq!(appended[..3], first[..], "追加不动已有的行");+ assert!(appended[3] > first[2]);+ assert_eq!(found("系统设置"), vec![3]);++ let b2 = unit(1, Role::Assistant, "第一答:改用 zxing 库解码");+ store+ .write_session(&m, 4, &[a.clone(), b2, c.clone(), d.clone()])+ .unwrap();+ assert_eq!(ids()[0], first[0], "改动之前的行留着");+ assert!(found("useEffect(").is_empty(), "被换掉的旧文本搜不到");+ assert_eq!(found("zxing"), vec![1]);+ assert_eq!(found("系统设置"), vec![3], "改动之后的行换成新行,内容照旧");++ store.write_session(&m, 5, &[a]).unwrap();+ assert_eq!(ids(), vec![first[0]], "变短了删掉多出的");+ assert!(found("相机权限").is_empty());+}++/// 老库的墓碑表没有指纹列:开库时补上,已有的墓碑指纹是 NULL、永远不会被当成放回+#[test]+fn old_tombstones_are_never_mistaken_for_a_put_back() {+ let dir = tempfile::tempdir().unwrap();+ let path = dir.path().join("old.db");+ {+ let conn = create_legacy_db(&path);+ conn.execute_batch(+ "CREATE TABLE tombstones (file_path TEXT PRIMARY KEY, key TEXT, deleted_at INTEGER);+ INSERT INTO tombstones VALUES ('/tmp/old.jsonl', 'claude-code:old', 1);",+ )+ .unwrap();+ }+ let store = Store::open(&path).unwrap();+ assert!(store.is_tombstoned("/tmp/old.jsonl").unwrap());+ assert!(!store.release_put_back("/tmp/old.jsonl", (0, 0)).unwrap());+ assert!(store.is_tombstoned("/tmp/old.jsonl").unwrap());+ drop(store);+ // 再开一次:列已在,不得重复 ALTER(重复加列会让开库失败、被当坏库重建)+ let store = Store::open(&path).unwrap();+ assert!(store.is_key_tombstoned("claude-code:old"));+}+#[test]fn tombstone_primitives() {let (_dir, store) = temp_store();@@ -83,13 +293,15 @@ fn tombstone_primitives() {store.write_session(&m, m.updated_at, &[]).unwrap();assert!(store.get_session("codex:s2").unwrap().is_some());- // remove_session(tombstone=true) 后按 file_path 记墓碑。+ // remove_trashed_sessions 后按 file_path 记墓碑。// 注意分层:write_meta_only 是纯写入原语、不查墓碑——防复活由// scanner 两条路径先过 is_tombstoned 保证(端到端见 scanner_finale.rs)- store.remove_session("codex:s2", true).unwrap();+ store+ .remove_trashed_sessions(&["codex:s2".to_string()], &HashMap::new())+ .unwrap();assert!(store.get_session("codex:s2").unwrap().is_none());- assert!(store.is_tombstoned(&m.file_path));- assert!(!store.is_tombstoned("/tmp/other.jsonl"));+ assert!(store.is_tombstoned(&m.file_path).unwrap());+ assert!(!store.is_tombstoned("/tmp/other.jsonl").unwrap());}#[test]@@ -105,7 +317,9 @@ fn user_data_survives_rebuild() {store.write_session(&removed, removed.updated_at, &[]).unwrap();- store.remove_session("claude-code:removed", true).unwrap();+ store+ .remove_trashed_sessions(&["claude-code:removed".to_string()], &HashMap::new())+ .unwrap();store.add_custom_root("codex", "/tmp/codex-copy").unwrap();store.add_removed_default("gemini").unwrap();store@@ -406,14 +620,14 @@ fn removing_a_session_tree_writes_every_tombstone_atomically() {assert_eq!(store.all_descendants(&parent.key).unwrap().len(), 1);store- .remove_sessions(&[parent.key.clone(), child.key.clone()], true)+ .remove_trashed_sessions(&[parent.key.clone(), child.key.clone()], &HashMap::new()).unwrap();assert!(store.get_session(&parent.key).unwrap().is_none());assert!(store.get_session(&child.key).unwrap().is_none());assert!(store.is_key_tombstoned(&parent.key));assert!(store.is_key_tombstoned(&child.key));- assert!(store.is_tombstoned(&parent.file_path));- assert!(store.is_tombstoned(&child.file_path));+ assert!(store.is_tombstoned(&parent.file_path).unwrap());+ assert!(store.is_tombstoned(&child.file_path).unwrap());}/// 最老的 sessions schema(无 parent_key、无 host):迁移类测试共用,@@ -724,9 +938,7 @@ fn wake_lookups_follow_the_session_and_reach_insights() {tally("claude-code", 0, 1),"重解析整体替换旧记录");- store- .remove_sessions(&["claude-code:a".to_string()], false)- .unwrap();+ store.remove_session("claude-code:a").unwrap();assert_eq!(tallies(), vec![tally("codex", 0, 1)], "删会话一并删记录");}@@ -1156,7 +1368,7 @@ fn titles_are_searchable_and_tracked_with_the_session() {);// 删除与重建都带走标题索引- store.remove_session(&m.key, false).unwrap();+ store.remove_session(&m.key).unwrap();assert!(store.search("数据库迁移", &[], None, 10).unwrap()diff --git a/crates/wake-core/tests/scanner_finale.rs b/crates/wake-core/tests/scanner_finale.rsindex 2223d15..113a0f3 100644--- a/crates/wake-core/tests/scanner_finale.rs+++ b/crates/wake-core/tests/scanner_finale.rs@@ -4,11 +4,13 @@mod common;+use std::collections::HashMap;use std::path::Path;use std::sync::{Arc, Mutex};use anyhow::{bail, Result};use serde_json::json;+use wake_core::adapters::claude::ClaudeAdapter;use wake_core::adapters::codex::CodexAdapter;use wake_core::adapters::AgentAdapter;use wake_core::db::Store;@@ -141,6 +143,77 @@ fn codex_spawned_subagents_nest_under_their_parent() {);}+/// Claude Code 分支端到端:全量扫描后分支挂在原件下、顶层只列原件;两份共有的那一轮只在+/// 原件里搜得到,分支自己的话在分支里;原件删掉后分支变回顶层、拿回完整历史+#[test]+fn claude_branches_nest_under_their_original_and_outlive_it() {+ let home = tempfile::tempdir().unwrap();+ let projects = home.path().join("projects");+ let (project, a, b) = common::stage_claude_branch(&projects);+ let dir = tempfile::tempdir().unwrap();+ let store = temp_store(dir.path());+ let adapters: Vec<Box<dyn AgentAdapter>> =+ vec![ClaudeAdapter::new().with_custom_root(projects)];+ run_scan(&adapters, &store, &Recorder::new(), true).unwrap();++ let (key_a, key_b) = (format!("claude-code:{a}"), format!("claude-code:{b}"));+ assert_eq!(+ store.parent_key_of(&key_b).unwrap().as_deref(),+ Some(key_a.as_str())+ );+ let filter = SessionFilter {+ roots_only: true,+ limit: 10,+ ..Default::default()+ };+ let (roots, total) = store.list_sessions(&filter).unwrap();+ assert_eq!(total, 1, "分支不进顶层列表");+ assert_eq!(roots[0].key, key_a);++ let keys = |q: &str| -> std::collections::BTreeSet<String> {+ let (hits, _) = store.search(q, &[], None, 10).unwrap();+ hits.into_iter().map(|h| h.session.key).collect()+ };+ assert_eq!(+ keys("连接池耗尽"),+ [key_a.clone()].into(),+ "共有的一轮只命中一次"+ );+ assert_eq!(keys("前端轮询结果"), [key_b.clone()].into());+ // 长驻的 wake-mcp 一直拿着同一份转录缓存:分支文件没动,原件一没就得换成完整历史+ let cache = TranscriptCache::default();+ let read_b = || {+ tools::invoke(+ store.as_ref(),+ &adapters,+ &cache,+ tools::GET_SESSION,+ &json!({ "key": key_b }),+ )+ .unwrap()+ };+ assert!(+ !read_b().contains("连接池耗尽"),+ "原件在时复制来的那一轮折叠掉"+ );++ // 在 Wake 里删掉原件(文件移走 + 墓碑),分支不跟着删:增量扫描后它变回顶层会话,+ // 复制来的那一轮也回到它自己名下+ std::fs::remove_file(project.join(format!("{a}.jsonl"))).unwrap();+ store+ .remove_trashed_sessions(&[key_a], &HashMap::new())+ .unwrap();+ assert!(+ read_b().contains("连接池耗尽"),+ "转录缓存还在交折叠过的旧版本"+ );+ run_scan(&adapters, &store, &Recorder::new(), false).unwrap();+ assert_eq!(store.parent_key_of(&key_b).unwrap(), None);+ let (roots, total) = store.list_sessions(&filter).unwrap();+ assert_eq!((total, roots[0].key.as_str()), (1, key_b.as_str()));+ assert_eq!(keys("连接池耗尽"), [key_b.clone()].into());+}+#[test]fn finale_fires_on_empty_scan() {let dir = tempfile::tempdir().unwrap();@@ -1195,7 +1268,9 @@ fn tombstoned_session_does_not_resurrect_on_rescan() {"首扫应写入");- store.remove_session("codex:ghost", true).unwrap();+ store+ .remove_trashed_sessions(&["codex:ghost".to_string()], &HashMap::new())+ .unwrap();run_scan(&adapters, &store, &rec, true).unwrap();assert!(store.get_session("codex:ghost").unwrap().is_none(),@@ -1203,6 +1278,78 @@ fn tombstoned_session_does_not_resurrect_on_rescan() {);}+/// 单条删除把文件移进废纸篓后:文件不在、或同一路径冒出另一份内容(agent 重新写出)→+/// 照旧压着;用户原样放回(文件本身的大小与修改时间对得上,`put_back_fingerprint`)→+/// 全量与增量两条路都撤掉墓碑、会话回来——确认框说"放回原处就会重新出现"靠的就是这个。+/// 只在 Wake 里隐藏的库存型会话(没记指纹)永远不会被当成放回。比的是文件本身而不是+/// 索引里的变更戳:seed 的引用戳与磁盘上的文件毫无关系,照样认得出+#[test]+fn put_back_from_trash_brings_a_deleted_session_back() {+ let dir = tempfile::tempdir().unwrap();+ let store = temp_store(dir.path());+ let rec = Recorder::new();+ let file = dir.path().join("a.jsonl");+ let trash = dir.path().join("trashed-a.jsonl");+ std::fs::write(&file, "{\"the original\": 1}\n").unwrap();+ let path = file.to_string_lossy().to_string();+ let roster = || -> Vec<Box<dyn AgentAdapter>> {+ vec![Box::new(seed(+ AgentId::Codex,+ &dir.path().to_string_lossy(),+ &path,+ "a",+ 10,+ ))]+ };+ let present = |store: &Store| store.get_session("codex:a").unwrap().is_some();+ // 删除:先记指纹,再"移进废纸篓"(改名走开,与真废纸篓一样保留修改时间)+ let delete = |store: &Store| {+ let print = wake_core::db::put_back_fingerprint(&file).expect("fingerprint");+ std::fs::rename(&file, &trash).unwrap();+ store+ .remove_trashed_sessions(+ &["codex:a".to_string()],+ &HashMap::from([(path.clone(), print)]),+ )+ .unwrap();+ };+ let put_back = || std::fs::rename(&trash, &file).unwrap();++ run_scan(&roster(), &store, &rec, true).unwrap();+ assert!(present(&store));++ // 全量路径+ delete(&store);+ run_scan(&roster(), &store, &rec, true).unwrap();+ assert!(!present(&store), "文件还在废纸篓里");+ std::fs::write(&file, "{\"rewritten by the agent\": 2}\n").unwrap();+ run_scan(&roster(), &store, &rec, true).unwrap();+ assert!(!present(&store), "同一路径的另一份文件不得解开删除");+ std::fs::remove_file(&file).unwrap();+ put_back();+ run_scan(&roster(), &store, &rec, true).unwrap();+ assert!(present(&store), "原样放回的文件要重新入库");++ // 增量路径(watcher 收到放回事件)+ delete(&store);+ put_back();+ scan_files(&roster(), &store, &rec, vec![roster_ref(&roster())]);+ assert!(present(&store), "watcher 收到放回事件也要认出来");++ // 只隐藏:没记指纹,文件原样在也不放行+ store+ .remove_trashed_sessions(&["codex:a".to_string()], &HashMap::new())+ .unwrap();+ run_scan(&roster(), &store, &rec, true).unwrap();+ scan_files(&roster(), &store, &rec, vec![roster_ref(&roster())]);+ assert!(!present(&store), "只在 Wake 里隐藏的会话不得自己回来");+}++/// 单实例 seed roster 枚举出的那条引用(watcher 增量直接拿它喂 scan_files)+fn roster_ref(roster: &[Box<dyn AgentAdapter>]) -> SessionFileRef {+ roster[0].list_session_files().unwrap().remove(0)+}+/// 同 agent 双根下的同 ID 会话:mtime 新者胜且跨轮稳定。旧行为是"后写者胜",/// 两个副本每轮轮流改写同一行、file_path 随扫描摇摆(2026-08-24 Codex review)/// ——故意把旧副本排在 roster 后面,旧代码在此必败@@ -2032,7 +2179,9 @@ fn tombstone_blocks_all_copies() {assert!(store.get_session("codex:dup").unwrap().is_some());// UI 删除:trash 胜者文件 + 墓碑(key 一并入墓)- store.remove_session("codex:dup", true).unwrap();+ store+ .remove_trashed_sessions(&["codex:dup".to_string()], &HashMap::new())+ .unwrap();run_scan(&adapters, &store, &rec, true).unwrap();assert!(store.get_session("codex:dup").unwrap().is_none(),@@ -2062,7 +2211,9 @@ fn quick_meta_respects_key_tombstone() {"quick 改名 key 应入库");- store.remove_session("codex:thread-1", true).unwrap();+ store+ .remove_trashed_sessions(&["codex:thread-1".to_string()], &HashMap::new())+ .unwrap();run_scan(&adapters, &store, &rec, true).unwrap();assert!(store.get_session("codex:thread-1").unwrap().is_none(),diff --git a/crates/wake/locales/zh-Hans.json b/crates/wake/locales/zh-Hans.jsonindex 216464a..f3ece81 100644--- a/crates/wake/locales/zh-Hans.json+++ b/crates/wake/locales/zh-Hans.json@@ -85,12 +85,15 @@"Couldn't add remote host: {}": "无法添加远程主机:{}","Couldn't check for updates. Check your connection and try again.": "检查更新失败。请检查网络后重试。","Couldn't load this session": "无法载入此会话",+ "Couldn't load more sessions. Refresh to try again: {}": "加载更多会话失败,刷新后再试:{}","Couldn't remove remote host: {}": "无法移除远程主机:{}","Couldn't save appearance: {}": "无法保存外观设置:{}","Couldn't save language: {}": "无法保存语言设置:{}","Couldn't save the image": "无法存储图片","Couldn't update location": "无法更新位置","Couldn't update remote host": "无法更新远程主机",+ "Couldn't update the pin: {}": "无法更新置顶:{}",+ "Couldn't update the star: {}": "无法更新收藏:{}","Created {}": "创建于 {}","Customize how Wake looks and reads.": "自定义 Wake 的外观与语言。","Cut": "剪切",@@ -131,6 +134,8 @@"Hide": "隐藏","Hide Others": "隐藏其他","Hide Wake": "隐藏 Wake",+ "Hide this session tree?": "从 Wake 隐藏这个会话树?",+ "Hide this session?": "从 Wake 隐藏这个会话?","Host": "主机","Host must be an SSH alias or user@host (letters, digits, . _ - @)": "主机必须是 SSH 别名或 user@host(字母、数字、. _ - @)","Image copied": "图片已拷贝",@@ -252,6 +257,7 @@"Saved": "已存储","Scope: all sessions": "范围:全部会话","Search everything — prose or code": "搜索全部内容 —— 文字或代码",+ "Search failed": "搜索失败","Search full conversation text": "搜索完整对话文本","Search sessions": "搜索会话","See where Wake stores local data. Sessions refresh automatically.": "查看 Wake 的本地数据位置。会话会自动刷新。",@@ -259,6 +265,7 @@"Session locations": "会话位置","Session moved to Recycle Bin": "会话已移到回收站","Session moved to Trash": "会话已移到废纸篓",+ "Session hidden": "会话已隐藏","Sessions": "会话","Sessions refreshed": "会话已刷新","Settings": "设置",@@ -287,13 +294,16 @@"Syncing…": "正在同步…","System": "跟随系统","The linked path is unavailable on this Mac.": "此链接的路径在这台 Mac 上不存在或无法访问。",- "The session file will be moved to Trash. You can restore it anytime:": "会话文件将被移到废纸篓,随时可以还原:",- "The session file will be moved to the Recycle Bin. You can restore it anytime:": "会话文件将被移到回收站,随时可以还原:",+ "This file will be moved to Trash. Put it back from Trash and the session shows up again.": "这个文件会被移到废纸篓。把它从废纸篓放回原处,会话就会重新出现。",+ "This file will be moved to the Recycle Bin. Put it back from the Recycle Bin and the session shows up again.": "这个文件会被移到回收站。从回收站还原后,会话就会重新出现。","Thinking": "思考","This folder is already in Wake's session locations": "该文件夹已在 Wake 的会话位置中","This path is already in Wake's memory locations": "这个路径已经在 Wake 的记忆位置里了",- "This session and {} nested session will be moved to {}. You can restore them anytime:": "此会话及其 {0} 个子会话将被移到{1},随时可以还原:",- "This session and {} nested sessions will be moved to {}. You can restore them anytime:": "此会话及其 {0} 个子会话将被移到{1},随时可以还原:",+ "This session and {} nested session will be moved to {1}. Put them back from {1} and they show up again.": "此会话及其 {0} 个子会话将被移到{1}。从{1}放回原处后,它们会重新出现。",+ "This session and {} nested sessions will be moved to {1}. Put them back from {1} and they show up again.": "此会话及其 {0} 个子会话将被移到{1}。从{1}放回原处后,它们会重新出现。",+ "This session and {} nested session are stored in {1}'s own database, which Wake never changes, so no files are moved. Wake just stops listing them.": "此会话及其 {0} 个子会话存放在 {1} 自己的数据库里,Wake 从不改动它,所以不会移动任何文件,只是不再列出它们。",+ "This session and {} nested sessions are stored in {1}'s own database, which Wake never changes, so no files are moved. Wake just stops listing them.": "此会话及其 {0} 个子会话存放在 {1} 自己的数据库里,Wake 从不改动它,所以不会移动任何文件,只是不再列出它们。",+ "This session is stored in {}'s own database, which Wake never changes, so no files are moved. Wake just stops listing it.": "这个会话存放在 {} 自己的数据库里,Wake 从不改动它,所以不会移动任何文件,只是不再列出它。","Thu": "周四","Thursdays": "周四","Today": "今天",@@ -356,6 +366,7 @@"{} sessions": "{} 个会话","{} sessions moved to Recycle Bin": "{} 个会话已移到回收站","{} sessions moved to Trash": "{} 个会话已移到废纸篓",+ "{} sessions hidden": "已隐藏 {} 个会话","{} to {}": "{} 到 {}","{} tokens": "{} Token","{} tool calls": "{} 次工具调用",@@ -479,5 +490,7 @@"Make text and controls larger or smaller.": "放大或缩小文字与控件。","Couldn't save zoom: {}": "无法保存缩放设置:{}","Choose the language Wake uses.": "选择 Wake 的界面语言。",- "Theme": "主题"+ "Theme": "主题",+ "Its branch stays and shows the whole conversation.": "它的分支会留下,显示完整的对话。",+ "Its {} branches stay and show the whole conversation.": "它的 {} 个分支会留下,显示完整的对话。"}diff --git a/crates/wake/src/i18n.rs b/crates/wake/src/i18n.rsindex 6e2ba0a..4c775f4 100644--- a/crates/wake/src/i18n.rs+++ b/crates/wake/src/i18n.rs@@ -662,7 +662,7 @@ mod tests {"Move to ","Session moved to ","{} sessions moved to ",- "The session file will be moved to ",+ "This file will be moved to ","You can restore files from ","Show in ","Reveal in ",diff --git a/crates/wake/src/ui.rs b/crates/wake/src/ui.rsindex 5c880b0..7af04e5 100644--- a/crates/wake/src/ui.rs+++ b/crates/wake/src/ui.rs@@ -205,12 +205,15 @@ macro_rules! trash_copy {". Space is freed after emptying it."))}- /// 删除确认框正文首句+ /// 删除确认框正文(下面接着是文件路径)。找回的方式要说准:从废纸篓放回原处,+ /// 扫描认出原样回来的文件就重新列出(`Store::release_put_back`)pub fn trash_confirm_body() -> &'static str {crate::i18n::t(concat!(- "The session file will be moved to ",+ "This file will be moved to ",$body,- ". You can restore it anytime:"+ ". Put it back from ",+ $body,+ " and the session shows up again."))}};diff --git a/crates/wake/src/workbench.rs b/crates/wake/src/workbench.rsindex 2f9254a..a50a50d 100644--- a/crates/wake/src/workbench.rs+++ b/crates/wake/src/workbench.rs@@ -47,8 +47,8 @@ use gpui_component::{};use wake_core::adapters::{- adapter_for, create_adapter_roster_for, path_owns, session_source_path, AdapterLocation,- AgentAdapter,+ adapter_for, children_outlive_parent, create_adapter_roster_for, path_owns,+ session_source_path, AdapterLocation, AgentAdapter,};use wake_core::db::Store;use wake_core::models::Role as MessageRole;@@ -940,7 +940,7 @@ impl ListDelegate for SessionsDelegate {let query = cx.background_spawn(async move { store.list_sessions(&filter) });cx.spawn_in(window, async move |this, cx| {let result = query.await;- this.update(cx, |state, cx| {+ this.update_in(cx, |state, window, cx| {let delegate = state.delegate_mut();let Some(current) = delegate.pagination.as_mut() else {return;@@ -965,7 +965,18 @@ impl ListDelegate for SessionsDelegate {current.next_offset.max(next_offset).min(current.total);delegate.append_sessions(sessions);}- Err(_) => current.failed = true,+ // 停住等用户刷新(防触底重试风暴),但要说出来——否则列表只是+ // 无声地到底了,看起来像会话就这么多+ Err(e) => {+ current.failed = true;+ window.push_notification(+ Notification::error(crate::tf!(+ "Couldn't load more sessions. Refresh to try again: {}",+ e+ )),+ cx,+ );+ }}cx.notify();})@@ -1393,6 +1404,9 @@ mod session_group_tests {pub struct SearchDelegate {pub hits: Vec<SearchHit>,pub degraded: bool,+ /// 查询本身失败(库读不出、FTS 表达式报错)。与"没有结果"分开显示,+ /// 否则用户会以为真的没讨论过+ error: Option<String>,store: Arc<Store>,last_query: String,}@@ -1495,19 +1509,19 @@ impl ListDelegate for SearchDelegate {let store = self.store.clone();let bg = cx.background_spawn(async move {if q.trim().is_empty() {- (Vec::new(), false)+ Ok((Vec::new(), false))} else {store.search(&q, &[], None, 60)- .unwrap_or((Vec::new(), false))+ .map_err(|e| format!("{e:#}"))}});cx.spawn_in(window, async move |this, cx| {- let (hits, degraded) = bg.await;+ let result = bg.await;this.update(cx, |state, cx| {let d = state.delegate_mut();- d.hits = hits;- d.degraded = degraded;+ d.error = result.as_ref().err().cloned();+ (d.hits, d.degraded) = result.unwrap_or_default();cx.notify();}).ok();@@ -1522,19 +1536,24 @@ impl ListDelegate for SearchDelegate {cx: &mut Context<ListState<Self>>,) -> impl IntoElement {let theme = cx.theme();- if self.last_query.trim().is_empty() {+ // 还没输入给提示,查询失败说失败(与"没有结果"分开,否则用户以为真的没讨论过)+ let card = if self.last_query.trim().is_empty() {+ Some((+ "icons/search.svg",+ t("Search full conversation text"),+ SharedString::from(t("Matches natural language and code, like \"useEffect(\".")),+ ))+ } else {+ self.error+ .as_ref()+ .map(|error| ("icons/info.svg", t("Search failed"), error.clone().into()))+ };+ if let Some((glyph, title, caption)) = card {return v_flex().h(zpx(250.)).w_full().justify_center()- .child(empty_state(- "icons/search.svg",- zpx(48.),- zpx(22.),- t("Search full conversation text"),- t("Matches natural language and code, like \"useEffect(\"."),- cx,- ));+ .child(empty_state(glyph, zpx(48.), zpx(22.), title, caption, cx));}v_flex().h(zpx(250.))@@ -2539,6 +2558,7 @@ impl Workbench {SearchDelegate {hits: Vec::new(),degraded: false,+ error: None,store: store.clone(),last_query: String::new(),},@@ -5284,28 +5304,37 @@ impl Workbench {});}- fn toggle_favorite(&mut self, window: &mut Window, cx: &mut Context<Self>) {- if let Some(detail) = &mut self.detail {- let key = detail.meta.key.clone();- let v = !detail.meta.favorite;- let _ = self.store.set_user_data(&detail.meta.key, Some(v), None);- detail.meta.favorite = v;- self.refresh(cx);- self.select_list_key(&key, false, window, cx);- self.refresh_cleanup_flags(&key, window, cx);- }- }-- fn toggle_pinned(&mut self, window: &mut Window, cx: &mut Context<Self>) {- if let Some(detail) = &mut self.detail {- let key = detail.meta.key.clone();- let v = !detail.meta.pinned;- let _ = self.store.set_user_data(&detail.meta.key, None, Some(v));- detail.meta.pinned = v;- self.refresh(cx);- self.select_list_key(&key, true, window, cx);- self.refresh_cleanup_flags(&key, window, cx);+ /// 收藏(`pin` = false)/ 置顶(`pin` = true)切换。写库失败就不翻界面上的状态:先前+ /// 吞掉错误照样翻,重启后收藏 / 置顶悄悄没了+ fn toggle_flag(&mut self, pin: bool, window: &mut Window, cx: &mut Context<Self>) {+ let Some(detail) = &mut self.detail else {+ return;+ };+ let key = detail.meta.key.clone();+ let flag = if pin {+ &mut detail.meta.pinned+ } else {+ &mut detail.meta.favorite+ };+ let value = !*flag;+ let (favorite, pinned) = if pin {+ (None, Some(value))+ } else {+ (Some(value), None)+ };+ if let Err(e) = self.store.set_user_data(&key, favorite, pinned) {+ let message = if pin {+ crate::tf!("Couldn't update the pin: {}", e)+ } else {+ crate::tf!("Couldn't update the star: {}", e)+ };+ window.push_notification(Notification::error(message), cx);+ return;}+ *flag = value;+ self.refresh(cx);+ self.select_list_key(&key, pin, window, cx);+ self.refresh_cleanup_flags(&key, window, cx);}/// 导出:系统"另存为"选路径(issue #25,此前直接写进 Downloads),后台解析写文件;@@ -5337,24 +5366,23 @@ impl Workbench {/// 否则界面在授权框弹出的整段时间里完全冻结。fn do_delete(&mut self,- keys: Vec<String>,+ sessions: Vec<SessionMeta>,targets: Vec<String>,window: &mut Window,cx: &mut Context<Self>,) {let store = self.store.clone();- let trash_keys = keys.clone();+ let keys: Vec<String> = sessions.iter().map(|session| session.key.clone()).collect();let count = keys.len();let lock = self.index_lock.clone();let task = cx.background_spawn(async move {let _lock = lock;- terminal::trash_paths(&targets)?;- store.remove_sessions(&trash_keys, true)+ wake_core::cleanup::trash_sessions(&store, &sessions, &targets)});cx.spawn_in(window, async move |this, cx| {let result = task.await;this.update_in(cx, |this, window, cx| match result {- Ok(()) => {+ Ok(hidden) => {// 等待期间用户可能已翻到别的会话,只在仍停在被删子树时清空。if this.detail@@ -5363,12 +5391,16 @@ impl Workbench {{this.detail = None;}- let message = crate::i18n::tp(- crate::ui::session_trashed_key(),- crate::ui::sessions_trashed_key(),- count as i64,- &[&count],- );+ let message = if hidden {+ crate::tp!("Session hidden", "{} sessions hidden", count)+ } else {+ crate::i18n::tp(+ crate::ui::session_trashed_key(),+ crate::ui::sessions_trashed_key(),+ count as i64,+ &[&count],+ )+ };window.push_notification(Notification::success(message), cx);// 立刻把它从列表摘掉,不等 watcher 那 800ms 去抖this.refresh(cx);@@ -5395,10 +5427,25 @@ impl Workbench {return;}let meta = detail.meta.clone();+ // 子会话查不出来就别删:只删根会把子代理一类留成孤儿+ let descendants = match self.store.all_descendants(&meta.key) {+ Ok(descendants) => descendants,+ Err(e) => {+ window+ .push_notification(Notification::error(crate::tf!("Delete failed: {}", e)), cx);+ return;+ }+ };+ // 分支(Claude Code 的 fork)是自己完整的对话,不随原件一起删:原件没了它们变回顶层+ // 会话,watcher 随即把它们重解析出完整历史(`ref_dependents`)let mut sessions = vec![meta.clone()];- sessions.extend(self.store.all_descendants(&meta.key).unwrap_or_default());+ let kept_branches = if children_outlive_parent(&self.adapters, &meta) {+ descendants.len()+ } else {+ sessions.extend(descendants);+ 0+ };let nested_count = sessions.len().saturating_sub(1);- let keys: Vec<String> = sessions.iter().map(|session| session.key.clone()).collect();// 每个子会话按自己的胜出 file_path 找 adapter;多 location 下不能沿用// 根会话所属实例。磁盘目标保持稳定顺序并去重。let mut seen_targets = HashSet::new();@@ -5413,23 +5460,58 @@ impl Workbench {}}}+ // 没有一个目标真在磁盘上 = 会话只活在 agent 自己的库里(OpenCode、Copilot、+ // Cursor IDE…的虚拟路径 `<db>#<id>`):Wake 不改别家的库,能做的只是不再列出它。+ // 先前这里照样说"移到废纸篓、随时可还原",两句都不成立+ let hide_only = !targets+ .iter()+ .any(|path| std::path::Path::new(path).exists());let entity = cx.entity();open_alert(window, cx, 440., move |dialog, _, cx| {let meta = meta.clone();- let keys = keys.clone();+ let sessions = sessions.clone();let targets = targets.clone();let entity = entity.clone();let theme = cx.theme();+ // 文件型:说清怎么找回——从废纸篓放回原处,扫描认出它就重新列出+ // (`Store::release_put_back`);库存型:不动任何文件,只是不再列出+ let (title, body) = match (hide_only, nested_count > 0) {+ (true, true) => (+ t("Hide this session tree?"),+ crate::tp!(+ "This session and {} nested session are stored in {1}'s own database, which Wake never changes, so no files are moved. Wake just stops listing them.",+ "This session and {} nested sessions are stored in {1}'s own database, which Wake never changes, so no files are moved. Wake just stops listing them.",+ nested_count,+ meta.agent.display_name()+ ),+ ),+ (true, false) => (+ t("Hide this session?"),+ crate::tf!(+ "This session is stored in {}'s own database, which Wake never changes, so no files are moved. Wake just stops listing it.",+ meta.agent.display_name()+ ),+ ),+ (false, true) => (+ t("Delete this session tree?"),+ crate::tp!(+ "This session and {} nested session will be moved to {1}. Put them back from {1} and they show up again.",+ "This session and {} nested sessions will be moved to {1}. Put them back from {1} and they show up again.",+ nested_count,+ crate::ui::trash_body()+ ),+ ),+ (false, false) => (+ t("Delete this session?"),+ trash_confirm_body().to_string(),+ ),+ };dialog.title(div().text_size(FONT_HEADING).font_semibold()- .child(if nested_count > 0 {- t("Delete this session tree?")- } else {- t("Delete this session?")- }),+ .child(title),)// 破坏性确认:主按钮点名动作并用 danger 形态,不留裸 "OK"。// .confirm() 必须显式调用——Dialog 只在设了 footer 时才渲染@@ -5437,36 +5519,30 @@ impl Workbench {.confirm().button_props(gpui_component::dialog::DialogButtonProps::default()- .ok_text(move_to_trash())+ .ok_text(if hide_only { t("Hide") } else { move_to_trash() }).ok_variant(gpui_component::button::ButtonVariant::Danger),).child(v_flex().gap(SPACE_SM).text_size(FONT_BODY)- .child(if nested_count > 0 {- crate::tp!(- "This session and {} nested session will be moved to {}. You can restore them anytime:",- "This session and {} nested sessions will be moved to {}. You can restore them anytime:",- nested_count,- crate::ui::trash_body()+ .child(body)+ // 库存型的 file_path 是虚拟路径,没有可移动的文件,不展示+ .when(!hide_only, |this| {+ this.child(+ div()+ .px(SPACE_SM)+ .py(SPACE_XS)+ .rounded(theme.radius)+ .bg(theme.muted)+ .text_size(FONT_CAPTION)+ // 等宽走主题 token(Menlo 只有 macOS 有;+ // Windows 上找不到会静默回落到比例字体的+ // 系统 UI 字体,与其他路径 chip 不一致)+ .font_family(theme.mono_font_family.clone())+ .child(meta.file_path.clone()),)- } else {- trash_confirm_body().to_string()})- .child(- div()- .px(SPACE_SM)- .py(SPACE_XS)- .rounded(theme.radius)- .bg(theme.muted)- .text_size(FONT_CAPTION)- // 等宽走主题 token(Menlo 只有 macOS 有;- // Windows 上找不到会静默回落到比例字体的- // 系统 UI 字体,与其他路径 chip 不一致)- .font_family(theme.mono_font_family.clone())- .child(meta.file_path.clone()),- ).when(meta.agent == AgentId::Codex, |this| {this.child(div()@@ -5474,11 +5550,23 @@ impl Workbench {.text_color(theme.muted_foreground).child(t("Only the local file is removed — Codex's own records stay intact.")),)+ })+ .when(kept_branches > 0, |this| {+ this.child(+ div()+ .text_size(FONT_CAPTION)+ .text_color(theme.muted_foreground)+ .child(crate::tp!(+ "Its branch stays and shows the whole conversation.",+ "Its {} branches stay and show the whole conversation.",+ kept_branches+ )),+ )}),).on_ok(move |_, window, cx| {entity.update(cx, |this, cx| {- this.do_delete(keys.clone(), targets.clone(), window, cx);+ this.do_delete(sessions.clone(), targets.clone(), window, cx);});true})@@ -7365,7 +7453,7 @@ impl Workbench {t("Star")},meta.favorite,- cx.listener(|this, _, window, cx| this.toggle_favorite(window, cx)),+ cx.listener(|this, _, window, cx| this.toggle_flag(false, window, cx)),).into_any_element(),tool_btn(@@ -7375,7 +7463,7 @@ impl Workbench {theme.primary,if meta.pinned { t("Unpin") } else { t("Pin") },meta.pinned,- cx.listener(|this, _, window, cx| this.toggle_pinned(window, cx)),+ cx.listener(|this, _, window, cx| this.toggle_flag(true, window, cx)),).into_any_element(),copy_path.into_any_element(),