All your AI agent sessions in one place — browse, search, resume. Rust + GPUI.
Rust
Make Session locations a full path manager; multi-copy hardening
Corey Chiua777f18fa6c1
diff --git a/DESIGN.md b/DESIGN.mdindex be732c1..5164451 100644--- a/DESIGN.md+++ b/DESIGN.md@@ -95,7 +95,7 @@ Wake 的目标不是展示技术感,而是让用户在几秒内重新找到并**颜色三级制**:`foreground`(主文字)/`muted_foreground`(全部辅助文字)/`primary`(强调与激活)。不引入第四种文字灰;不在 muted 色上叠 opacity。-**间距刻度(4px 网格)**:`SPACE_XS/SM/MD/LG/XL/XXL` = 4/8/12/16/20/24,定义在 `ui.rs`。新代码引用常量或显式 `px()`;**对齐敏感处禁用 rem 间距类**——`p_2p5` 实为 8.75px、`p_3` 实为 10.5px(rem=14 折算),均不在网格上,是对齐失真的来源。存量 rem 类逐步迁移。+**间距刻度(4px 网格)**:`SPACE_XS/SM/MD/LG/XL/XXL` = 4/8/12/16/20/24,定义在 `ui.rs`。新代码引用常量或显式 `px()`;**对齐敏感处禁用 rem 间距类**——`p_2p5` 实为 8.75px、`p_3` 实为 10.5px(rem=14 折算),均不在网格上,是对齐失真的来源。存量 rem 类已于 2026-08-24 全量迁移完毕,代码中不再允许出现 rem 间距类(`p_0` 例外,零无幽灵值)。**侧栏中轴(x = 26.75)**:traffic lights 定位 (20,11),红灯实测直径 13.5px,中心即 **26.75**。侧栏所有行首元素的**视觉中心**压在这条竖线上,而非左缘对齐:@@ -133,7 +133,7 @@ UI 语言英文;会话正文保持原语言。元信息分隔符固定为前后- 线条图标比实心品牌图视觉轻,同档里给小一号:分组项 Lucide 14 / 品牌图 18,主导航 Lucide 15。- 行内容 = 行首元素 + 标题 + 计数;计数一律 Label 档 muted。- 组头 "Agents"/"Projects" 用 Body 档常规字重 + muted 色(与主导航同字号同字重,仅靠颜色和"无行首图标"区分——加粗会让组头压过它统辖的行),带 13px chevron 可折叠。-- 底部工具条常驻,顶部 hairline 分隔,按钮靠右排列(次要操作区:透明底、hover 才出色,不与导航行选中态抢注意力)——左为 "Session locations"(硬盘图标,开面板列出每家 agent 的数据路径、会话数,点击行在 Finder 打开),右为 refresh。+- 底部工具条常驻,顶部 hairline 分隔,按钮靠右排列(次要操作区:透明底、hover 才出色,不与导航行选中态抢注意力)——左为 "Session locations"(硬盘图标,开面板列出每家 agent 的数据路径、会话数,点击行在 Finder 打开;行按 AgentId 声明序稳定成组(自定义根紧随该家默认根之后);**行点击即编辑**,预设与自定义同权、均可改可删(2026-08-24 定稿)。添加/编辑共用一个表单弹窗(480px,agent 下拉 + 路径输入框可手输 ~ 展开 + 目录选择钮,Add|Save / Cancel)**压栈**在面板之上,esc/取消原生弹回面板;**纯路径管理无内容校验**(同日定稿),保存后先出通知、待补扫终态(增量,常亚秒)再重开面板——此刻计数才是真值,立即重开会让新根恒显 0(2026-08-24 Codex review)。行尾仅计数 badge(悬停工具图标试过、否决,同日——Show in Finder 与 Remove 收进编辑表单的动作行——破坏性靠左惯例:Remove(danger 红字 ghost)压内容左缘,Show in Finder 靠右);底部 hairline 下左 "Add location" 右 "Restore defaults"(仅存在偏离时出现,双清自定义与被移除预设;hover 胶囊只包按钮本体——整行 hover 否决,同日)),右为 refresh。- 工具条内的**状态行"常态沉默"**:仅刷新中或监听不可用时出现在按钮行上方;文案须可 truncate,窄侧栏放不下长句(故为 "Live updates off" 而非带操作建议的整句)。- 不把项目包装成卡片,不堆叠分支、时间或重复图标。项目行不加彩色标识——同一图标重复十几次不传递信息。@@ -157,6 +157,10 @@ UI 语言英文;会话正文保持原语言。元信息分隔符固定为前后“在终端继续”是唯一主按钮。收藏、置顶保留为独立图标按钮;导出、Finder 和删除进入“更多”菜单。按钮圆角固定 6px,危险操作在菜单中用分组隔开并继续走确认框。+头部元信息(路径/属性/时间/文件)四行收成 4px 紧组,与标题区之间保持 8px——组内紧、组间松,四行等距摊开会读成四个并列区块(2026-08-24 polish)。++对话框标题一律 Heading 16 semibold:组件内建 `.title()` 不设字号(实渲窗口默认 14px),必须显式补 `text_size(FONT_HEADING)`。破坏性确认的主按钮点名动作并用 danger 形态("Move to Trash",不留裸 "OK");表单弹窗内控件同档取齐(输入框与下拉/浏览钮同高,次级动作行才允许 small)。+### 阅读卡正文位于 `popover` 材质的 12px 圆角阅读卡中,外层使用 `background`。正文 15px,可选择、可滚动,代码继续使用 tree-sitter 高亮。diff --git a/crates/wake-core/src/adapters/antigravity.rs b/crates/wake-core/src/adapters/antigravity.rsindex 73c6291..36bf631 100644--- a/crates/wake-core/src/adapters/antigravity.rs+++ b/crates/wake-core/src/adapters/antigravity.rs@@ -205,6 +205,23 @@ impl AgentAdapter for AntigravityAdapter {})}+ fn with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {+ // 选中 `~/.gemini` 形态(含 antigravity-cli/)、库所在目录,或直接+ // 给到库文件路径都认(Codex review)+ let nested = dir.join("antigravity-cli").join("conversation_summaries.db");+ let db = if dir.is_file() {+ dir+ } else if nested.is_file() {+ nested+ } else {+ dir.join("conversation_summaries.db")+ };+ Box::new(Self {+ db,+ rows_cache: MtimeCache::new(),+ })+ }+fn data_roots(&self) -> Vec<PathBuf> {vec![self.db.clone()]}diff --git a/crates/wake-core/src/adapters/claude.rs b/crates/wake-core/src/adapters/claude.rsindex 249bd07..80d2cf0 100644--- a/crates/wake-core/src/adapters/claude.rs+++ b/crates/wake-core/src/adapters/claude.rs@@ -562,6 +562,12 @@ impl AgentAdapter for ClaudeAdapter {v}+ fn with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {+ // 选中 `~/.claude` 形态(含 projects/)或直接选中 projects 目录都认+ let root = if dir.join("projects").is_dir() { dir.join("projects") } else { dir };+ Box::new(Self { root })+ }+fn data_roots(&self) -> Vec<PathBuf> {vec![self.root.clone()]}diff --git a/crates/wake-core/src/adapters/codex.rs b/crates/wake-core/src/adapters/codex.rsindex 139cd61..ec346a4 100644--- a/crates/wake-core/src/adapters/codex.rs+++ b/crates/wake-core/src/adapters/codex.rs@@ -32,6 +32,53 @@ impl CodexAdapter {}}+/// rollout 存储本体(用户选中的是数据目录而非 codex home):自身不含+/// sessions/archived 子目录,且顶层有 YYYY 日期目录(sessions 树)**或**+/// 平铺的 rollout-*.jsonl(archived_sessions 的真实布局,实测平铺)。+/// with_custom_root 与 normalize_custom_root 共用同一判据+fn is_rollout_store(dir: &Path) -> bool {+ !dir.join("sessions").is_dir()+ && !dir.join("archived_sessions").is_dir()+ && std::fs::read_dir(dir)+ .map(|rd| {+ rd.flatten().any(|e| {+ let name = e.file_name();+ let Some(n) = name.to_str() else { return false };+ (e.path().is_dir() && n.len() == 4 && n.bytes().all(|b| b.is_ascii_digit()))+ || (n.starts_with("rollout-") && n.ends_with(".jsonl"))+ })+ })+ .unwrap_or(false)+}++/// 各家归一化的 codex 实现(mod.rs 静态分派,**不依赖 roster 在场**):+/// 直选数据目录且父目录呈 home 形态 → 存父目录,state DB 与两个数据根全部+/// 找回。"数据目录"认两种证据:内容形态(rollout 存储),或目录名本身就是+/// sessions/archived_sessions——空目录没有内容证据,但表单允许空路径,真实+/// 的空 sessions 目录同样该上提(2026-08-24 Codex review 两轮)+pub(crate) fn normalize_custom_root(dir: PathBuf) -> PathBuf {+ let name = dir.file_name().and_then(|n| n.to_str());+ let looks_data_dir =+ is_rollout_store(&dir) || matches!(name, Some("sessions") | Some("archived_sessions"));+ if looks_data_dir {+ if let Some(parent) = dir.parent() {+ // home 证据必须独立于被选目录自身:目录名恰为 sessions 时,+ // parent/sessions 就是它自己,不能算证据+ let sibling = match name {+ Some("sessions") => parent.join("archived_sessions").is_dir(),+ Some("archived_sessions") => parent.join("sessions").is_dir(),+ _ => {+ parent.join("sessions").is_dir() || parent.join("archived_sessions").is_dir()+ }+ };+ if parent.join("state_5.sqlite").is_file() || sibling {+ return parent.to_path_buf();+ }+ }+ }+ dir+}+#[derive(Debug)]struct ThreadRow {id: String,@@ -547,6 +594,27 @@ impl AgentAdapter for CodexAdapter {})}+ fn with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {+ // dir 视作 CODEX_HOME 形态;归一化未上提的孤立数据目录按**目录名**+ // 保留角色:空的独立 sessions 目录日后落盘的 rollout 要能被发现,+ // 独立 archived 拷贝的会话必须保住 archived 标记(build_meta 按+ // archived_dir 前缀判);无名可依的裸 rollout 拷贝当活跃 sessions。+ // 侧档一并相对 dir 派生,绝不越界摸父目录——"父目录有 home 证据"的+ // 场景由 normalize_custom_root 在入库前上提(2026-08-24 Codex review)+ let name = dir.file_name().and_then(|n| n.to_str());+ let (sessions_dir, archived_dir) = match name {+ Some("archived_sessions") => (dir.join("sessions"), dir.clone()),+ Some("sessions") => (dir.clone(), dir.join("archived_sessions")),+ _ if is_rollout_store(&dir) => (dir.clone(), dir.join("archived_sessions")),+ _ => (dir.join("sessions"), dir.join("archived_sessions")),+ };+ Box::new(Self {+ sessions_dir,+ archived_dir,+ state_db: dir.join("state_5.sqlite"),+ })+ }+fn data_roots(&self) -> Vec<PathBuf> {vec![self.sessions_dir.clone(), self.archived_dir.clone()]}diff --git a/crates/wake-core/src/adapters/copilot.rs b/crates/wake-core/src/adapters/copilot.rsindex eb207f1..26462c0 100644--- a/crates/wake-core/src/adapters/copilot.rs+++ b/crates/wake-core/src/adapters/copilot.rs@@ -227,6 +227,15 @@ impl AgentAdapter for CopilotAdapter {})}+ fn with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {+ // 手输/预填的就是库文件路径时直接认,不再往下拼(Codex review)+ let db = if dir.is_file() { dir } else { dir.join("session-store.db") };+ Box::new(Self {+ db,+ rows_cache: Mutex::new(None),+ })+ }+fn data_roots(&self) -> Vec<PathBuf> {vec![self.db.clone()]}diff --git a/crates/wake-core/src/adapters/cursor.rs b/crates/wake-core/src/adapters/cursor.rsindex dda9ec6..88f9b8f 100644--- a/crates/wake-core/src/adapters/cursor.rs+++ b/crates/wake-core/src/adapters/cursor.rs@@ -368,6 +368,12 @@ impl AgentAdapter for CursorAdapter {Ok(parse_cursor_jsonl(&file)?.messages)}+ fn with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {+ // 选中 `~/.cursor` 形态(含 projects/)或直接选中 projects 目录都认+ let root = if dir.join("projects").is_dir() { dir.join("projects") } else { dir };+ Box::new(Self { root })+ }+fn data_roots(&self) -> Vec<PathBuf> {vec![self.root.clone()]}diff --git a/crates/wake-core/src/adapters/dsh.rs b/crates/wake-core/src/adapters/dsh.rsindex 18837bf..f25e299 100644--- a/crates/wake-core/src/adapters/dsh.rs+++ b/crates/wake-core/src/adapters/dsh.rs@@ -464,6 +464,11 @@ impl AgentAdapter for DshAdapter {}}+ fn with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {+ let root = if dir.join("sessions").is_dir() { dir.join("sessions") } else { dir };+ Box::new(Self { root })+ }+fn data_roots(&self) -> Vec<PathBuf> {vec![self.root.clone()]}diff --git a/crates/wake-core/src/adapters/gemini.rs b/crates/wake-core/src/adapters/gemini.rsindex caa4d2d..65dd3bf 100644--- a/crates/wake-core/src/adapters/gemini.rs+++ b/crates/wake-core/src/adapters/gemini.rs@@ -268,6 +268,25 @@ impl AgentAdapter for GeminiAdapter {})}+ fn with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {+ // `~/.gemini` 形态(含 tmp/)则 projects.json 在其顶层;直接选中 tmp+ // 形态则上一层找。侧档必须相对 dir 派生,落回默认家就会拿错 cwd 映射+ let (root, projects_json) = if dir.join("tmp").is_dir() {+ (dir.join("tmp"), dir.join("projects.json"))+ } else {+ let pj = dir+ .parent()+ .map(|p| p.join("projects.json"))+ .unwrap_or_else(|| dir.join("projects.json"));+ (dir, pj)+ };+ Box::new(Self {+ root,+ projects_json,+ slug_cache: std::sync::Mutex::new(None),+ })+ }+fn data_roots(&self) -> Vec<PathBuf> {vec![self.root.clone()]}diff --git a/crates/wake-core/src/adapters/grok.rs b/crates/wake-core/src/adapters/grok.rsindex 2732030..136c58f 100644--- a/crates/wake-core/src/adapters/grok.rs+++ b/crates/wake-core/src/adapters/grok.rs@@ -347,6 +347,11 @@ impl AgentAdapter for GrokAdapter {})}+ fn with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {+ let root = if dir.join("sessions").is_dir() { dir.join("sessions") } else { dir };+ Box::new(Self { root })+ }+fn data_roots(&self) -> Vec<PathBuf> {vec![self.root.clone()]}diff --git a/crates/wake-core/src/adapters/kimi.rs b/crates/wake-core/src/adapters/kimi.rsindex e2ae365..8b759a9 100644--- a/crates/wake-core/src/adapters/kimi.rs+++ b/crates/wake-core/src/adapters/kimi.rs@@ -284,6 +284,25 @@ impl AgentAdapter for KimiAdapter {})}+ fn with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {+ // `~/.kimi-code` 形态(含 sessions/)则 index 在其顶层;直接选中+ // sessions 则上一层找。index 相对 dir 派生,落回默认家会拿错 cwd 映射+ let (root, index_path) = if dir.join("sessions").is_dir() {+ (dir.join("sessions"), dir.join("session_index.jsonl"))+ } else {+ let idx = dir+ .parent()+ .map(|p| p.join("session_index.jsonl"))+ .unwrap_or_else(|| dir.join("session_index.jsonl"));+ (dir, idx)+ };+ Box::new(Self {+ root,+ index_path,+ cwd_cache: MtimeCache::new(),+ })+ }+fn data_roots(&self) -> Vec<PathBuf> {vec![self.root.clone()]}diff --git a/crates/wake-core/src/adapters/kiro.rs b/crates/wake-core/src/adapters/kiro.rsindex c2c50ae..a2a98ab 100644--- a/crates/wake-core/src/adapters/kiro.rs+++ b/crates/wake-core/src/adapters/kiro.rs@@ -188,6 +188,18 @@ impl AgentAdapter for KiroAdapter {})}+ fn with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {+ // `~/.kiro`/`~/.kiro/sessions`/`~/.kiro/sessions/cli` 三层都认+ let root = if dir.join("sessions").join("cli").is_dir() {+ dir.join("sessions").join("cli")+ } else if dir.join("cli").is_dir() {+ dir.join("cli")+ } else {+ dir+ };+ Box::new(Self { root })+ }+fn data_roots(&self) -> Vec<PathBuf> {vec![self.root.clone()]}diff --git a/crates/wake-core/src/adapters/mod.rs b/crates/wake-core/src/adapters/mod.rsindex 6a0138d..fe73c4e 100644--- a/crates/wake-core/src/adapters/mod.rs+++ b/crates/wake-core/src/adapters/mod.rs@@ -83,6 +83,26 @@ pub trait AgentAdapter: Send + Sync {fn watch_paths(&self) -> Vec<std::path::PathBuf> {self.data_roots().into_iter().filter(|p| p.is_dir()).collect()}+ /// 以自定义数据根构造本家的第二实例("Session locations" 的 Add location)。+ /// `dir` 是用户在系统目录选择器里选中的目录;各家把它整形成自己默认根的形态+ /// (允许选"家目录"或数据目录任一层,SQLite 型在其中找库文件),整形判据只看+ /// `dir` 内的现有结构,与默认实例的 env 探测同一快照语义。+ /// 唯一消费方是 create_adapters_with(常驻 roster 的自定义实例);+ /// 侧档(gemini projects.json / kimi session_index / codex state DB)必须+ /// 全部相对 `dir` 派生,落回默认家目录就会拿错树。新增 adapter 必须实现。+ fn with_custom_root(&self, dir: std::path::PathBuf) -> Box<dyn AgentAdapter>;+}++/// 入库前的自定义根归一化:把用户选中的目录整形成本家"该存哪一层"的形态。+/// **按 agent 静态分派、不依赖 roster**——该家默认实例被用户移除且无自定义+/// 实例时,归一化仍必须生效(2026-08-24 Codex review);各家实现放各家文件,+/// 这里只做路由。归一化在构造之外做,是为维持"with_custom_root 派生根都在+/// 落库目录之下"的契约(构造器越界摸父目录会破坏契约测试与面板行标记)+pub fn normalize_custom_root(agent: AgentId, dir: std::path::PathBuf) -> std::path::PathBuf {+ match agent {+ AgentId::Codex => codex::normalize_custom_root(dir),+ _ => dir,+ }}/// 环境变量指定的数据根。**只能读进程环境**:从 Dock 启动的 GUI 不继承用户@@ -123,6 +143,98 @@ pub fn create_adapters() -> Vec<Box<dyn AgentAdapter>> {]}++/// 用户 location 配置下的完整 roster:默认实例在前(被用户移除的家除外),+/// 自定义实例按存储顺序追加在后。顺序是契约的一部分——"按 agent 找第一个"+/// 的兜底路径(watcher file_ref、adapter_ix_for 的 fallback)落在该家现存的+/// 首个实例上。自定义实例始终从默认模板构造(即便该家默认被移除,模板仍是+/// with_custom_root 的 ctor 来源)。构造点与 create_adapters 同属唯一化范围:+/// 换代必须整体换(见不变量 8)+pub fn create_adapters_with(+ custom_roots: &[(AgentId, std::path::PathBuf)],+ removed_defaults: &[AgentId],+) -> Vec<Box<dyn AgentAdapter>> {+ let base = create_adapters();+ let customs: Vec<Box<dyn AgentAdapter>> = custom_roots+ .iter()+ .filter_map(|(agent, root)| {+ base.iter()+ .find(|a| a.agent() == *agent)+ .map(|a| a.with_custom_root(root.clone()))+ })+ .collect();+ let mut v: Vec<Box<dyn AgentAdapter>> = base+ .into_iter()+ .filter(|a| !removed_defaults.contains(&a.agent()))+ .collect();+ v.extend(customs);+ v+}++/// 按索引库里的 location 配置构造 roster——**所有打开真实索引库的入口**+/// (GUI 与 scan CLI)都必须走这里:用默认 roster 对配置过的库跑 run_scan,+/// 删除检测会把自定义根的会话当"磁盘已删"整批清掉,再把被压制的默认根加回+/// (2026-08-24 Codex review 抓到 scan bin 正是这么毁数据的)+pub fn create_adapters_for(store: &crate::db::Store) -> Vec<Box<dyn AgentAdapter>> {+ let (customs, removed) = store.location_overrides();+ create_adapters_with(&customs, &removed)+}++/// 数据根是否拥有该会话文件路径。边界必须落在 '/'(目录型)或 '#'(SQLite+/// 虚拟路径 `<db>#<id>`)上,与 db 侧 counts_by_path_prefix 同判据——裸前缀+/// 会把 `…/sessions-old` 记到 `…/sessions` 头上+pub fn path_owns(root: &str, path: &str) -> bool {+ // 文件系统根:strip_prefix("/") 剥掉的正是分隔符本身,通用分支会把一切+ // 后代判为界外(2026-08-24 Codex review)+ if root == "/" {+ return path.starts_with('/');+ }+ match path.strip_prefix(root) {+ Some("") => true,+ Some(rest) => rest.starts_with('/') || rest.starts_with('#'),+ None => false,+ }+}++/// 会话文件应由哪个实例服务:同 agent 中数据根最长前缀匹配者,匹配不到根时+/// 回退该 agent 的首个(默认)实例。自定义 location 让同 agent 出现多实例后,+/// "按 agent 找第一个"不再充分——gemini/kimi 的 cwd 反查、codex 的 state DB+/// 都是实例相对的侧档,拿默认实例解析自定义根下的文件会读错树+pub fn adapter_ix_for(+ adapters: &[Box<dyn AgentAdapter>],+ agent: AgentId,+ file_path: &str,+) -> Option<usize> {+ let first = adapters.iter().position(|a| a.agent() == agent)?;+ // 常态(该家只有默认一实例,零自定义 location)零分配直返;+ // data_roots() 每次调用都克隆整组 PathBuf,只该在真多实例时才付+ if !adapters[first + 1..].iter().any(|a| a.agent() == agent) {+ return Some(first);+ }+ let mut best: Option<(usize, usize)> = None; // (root 长度, 下标)+ for (ix, a) in adapters.iter().enumerate().skip(first) {+ if a.agent() != agent {+ continue;+ }+ for r in a.data_roots() {+ let rs = r.to_string_lossy();+ if path_owns(&rs, file_path) && best.is_none_or(|(len, _)| rs.len() > len) {+ best = Some((rs.len(), ix));+ }+ }+ }+ Some(best.map(|(_, ix)| ix).unwrap_or(first))+}++/// adapter_ix_for 的引用形态,详情/导出/删除等单会话路径用+pub fn adapter_for<'a>(+ adapters: &'a [Box<dyn AgentAdapter>],+ agent: AgentId,+ file_path: &str,+) -> Option<&'a dyn AgentAdapter> {+ adapter_ix_for(adapters, agent, file_path).map(|ix| adapters[ix].as_ref())+}+/// 从解析后的消息派生 FTS 单元(text + tool 名称/输入摘要)pub(crate) fn units_from_messages(messages: &[TranscriptMessage]) -> Vec<IndexUnit> {messagesdiff --git a/crates/wake-core/src/adapters/opencode.rs b/crates/wake-core/src/adapters/opencode.rsindex e5cd948..7b181a3 100644--- a/crates/wake-core/src/adapters/opencode.rs+++ b/crates/wake-core/src/adapters/opencode.rs@@ -461,6 +461,23 @@ impl AgentAdapter for OpencodeAdapter {})}+ fn with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {+ // 选中 XDG 数据根(含 opencode/)、opencode 目录本身,或直接给到+ // 库文件路径都认(Codex review:预设行编辑值曾把文件当目录拼)+ let nested = dir.join("opencode").join("opencode.db");+ let db = if dir.is_file() {+ dir+ } else if nested.is_file() {+ nested+ } else {+ dir.join("opencode.db")+ };+ Box::new(Self {+ db,+ rows_cache: MtimeCache::new(),+ })+ }+fn data_roots(&self) -> Vec<PathBuf> {vec![self.db.clone()]}diff --git a/crates/wake-core/src/adapters/pi.rs b/crates/wake-core/src/adapters/pi.rsindex ecc230f..6a9ad33 100644--- a/crates/wake-core/src/adapters/pi.rs+++ b/crates/wake-core/src/adapters/pi.rs@@ -261,6 +261,18 @@ impl AgentAdapter for PiAdapter {})}+ fn with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {+ // 选中 `~/.pi`/`~/.omp` 家目录形态或 sessions 目录本身都认。+ // pi 与 omp 布局全同:实例保持自己的 agent,探测时两家都会命中同一目录,+ // 取舍交 UI(用户知道自己装的是哪个 CLI)+ let nested = dir.join("agent").join("sessions");+ let root = if nested.is_dir() { nested } else { dir };+ Box::new(Self {+ agent: self.agent,+ root,+ })+ }+fn data_roots(&self) -> Vec<PathBuf> {vec![self.root.clone()]}diff --git a/crates/wake-core/src/bin/scan.rs b/crates/wake-core/src/bin/scan.rsindex 975cc82..22ff88b 100644--- a/crates/wake-core/src/bin/scan.rs+++ b/crates/wake-core/src/bin/scan.rs@@ -2,7 +2,7 @@//! 与 Electron 版基准(claude 97 / codex 168 / messages 31871±)对照。use anyhow::Result;use std::sync::Arc;-use wake_core::adapters::create_adapters;+use wake_core::adapters::create_adapters_for;use wake_core::db::Store;use wake_core::models::SessionFilter;use wake_core::scanner::{run_scan, NullEvents, ScanEvents, ScanProgress};@@ -28,7 +28,8 @@ fn main() -> Result<()> {eprintln!("DB: {}", db_path.display());let store = Arc::new(Store::open(&db_path)?);- let adapters = create_adapters();+ // 必须带上库里的 location 配置:默认 roster 会把自定义根会话当已删清掉+ let adapters = create_adapters_for(&store);eprintln!("adapters: {:?}",adapters.iter().map(|a| a.agent().as_str()).collect::<Vec<_>>()diff --git a/crates/wake-core/src/db.rs b/crates/wake-core/src/db.rsindex c05ee15..9371d7a 100644--- a/crates/wake-core/src/db.rs+++ b/crates/wake-core/src/db.rs@@ -57,8 +57,21 @@ CREATE TABLE IF NOT EXISTS user_data (CREATE TABLE IF NOT EXISTS tombstones (file_path TEXT PRIMARY KEY,+ key TEXT,deleted_at INTEGER);++CREATE TABLE IF NOT EXISTS custom_roots (+ agent TEXT NOT NULL,+ path TEXT NOT NULL,+ added_at INTEGER,+ PRIMARY KEY (agent, path)+);++CREATE TABLE IF NOT EXISTS removed_defaults (+ agent TEXT PRIMARY KEY,+ removed_at INTEGER+);"#;fn open_conn(path: &Path) -> Result<Connection> {@@ -71,12 +84,16 @@ fn open_conn(path: &Path) -> Result<Connection> {conn.busy_timeout(std::time::Duration::from_millis(3000))?;conn.execute_batch(DDL).context("failed to initialize SQLite schema")?;+ // tombstones.key 迁移(2026-08-24 加列,老库无此列;重复加列报错即忽略):+ // 墓碑按逻辑会话(key)+物理路径双轨屏蔽,多 location 副本不得复活已删会话+ let _ = conn.execute("ALTER TABLE tombstones ADD COLUMN key TEXT", []);Ok(conn)}/// 打开索引库;打不开就把它连同 WAL/SHM 一起挪到 `.corrupt` 旁路再建一个空的。-/// 索引本来就能从磁盘全量重扫恢复,重建的真实损失只有 user_data(收藏/置顶)——-/// 而它远好过 GUI 无提示秒退。返回的 `Some(_)` 是给用户看的说明文案。+/// 索引本来就能从磁盘全量重扫恢复,重建的真实损失只有 user_data(收藏/置顶)+/// 与 custom_roots(自定义 location)——而它远好过 GUI 无提示秒退。+/// 返回的 `Some(_)` 是给用户看的说明文案。pub fn open_or_rebuild(path: &Path) -> Result<(Store, Option<String>)> {let first = match Store::open(path) {Ok(store) => return Ok((store, None)),@@ -94,8 +111,8 @@ pub fn open_or_rebuild(path: &Path) -> Result<(Store, Option<String>)> {Ok((store,Some(format!(- "Index was damaged and has been rebuilt — stars and pins are gone. \- The old file is kept at {}",+ "Index was damaged and has been rebuilt — stars, pins and custom \+ locations are gone. The old file is kept at {}",backup.display())),))@@ -120,41 +137,40 @@ impl Store {pub fn write_session(&self, meta: &SessionMeta, file_mtime: i64, units: &[IndexUnit]) -> Result<()> {let mut conn = self.write.lock().unwrap();let tx = conn.transaction()?;- {- // FTS external content 需要显式 delete 旧行- let mut sel = tx.prepare_cached("SELECT id, text FROM messages WHERE session_key = ?1")?;- let rows: Vec<(i64, String)> = sel- .query_map(params![meta.key], |r| Ok((r.get(0)?, r.get(1)?)))?- .collect::<rusqlite::Result<_>>()?;- let mut fts_del =- tx.prepare_cached("INSERT INTO messages_fts(messages_fts, rowid, text) VALUES ('delete', ?1, ?2)")?;- for (id, text) in rows {- fts_del.execute(params![id, text])?;- }- tx.execute("DELETE FROM messages WHERE session_key = ?1", params![meta.key])?;-- upsert_session(&tx, meta, file_mtime)?;+ write_session_tx(&tx, meta, file_mtime, units)?;+ tx.commit()?;+ Ok(())+ }- 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])?;+ /// 增量写入的并发安全版:胜者比较与写入**同一事务**——先查后写分开时,+ /// 败方副本的事件能与全量扫描交错、后发落库,让 file_path 违背 mtime 裁决+ /// (2026-08-24 Codex review)。返回 false = 本次是败方副本,一字未写+ pub fn write_session_guarded(+ &self,+ meta: &SessionMeta,+ file_mtime: i64,+ units: &[IndexUnit],+ ) -> Result<bool> {+ let mut conn = self.write.lock().unwrap();+ let tx = conn.transaction()?;+ let cur: Option<(String, i64)> = tx+ .query_row(+ "SELECT file_path, file_mtime FROM sessions WHERE key = ?1",+ params![meta.key],+ |r| Ok((r.get(0)?, r.get(1)?)),+ )+ .optional()?;+ if let Some((cur_path, cur_mtime)) = cur {+ let loses = cur_path != meta.file_path+ && (cur_mtime > file_mtime+ || (cur_mtime == file_mtime && cur_path.as_str() < meta.file_path.as_str()));+ if loses {+ return Ok(false); // 事务未提交即弃}}+ write_session_tx(&tx, meta, file_mtime, units)?;tx.commit()?;- Ok(())+ Ok(true)}pub fn write_meta_only(&self, metas: &[(SessionMeta, i64)]) -> Result<()> {@@ -188,8 +204,8 @@ impl Store {if tombstone {if let Some(fp) = file_path {tx.execute(- "INSERT OR REPLACE INTO tombstones(file_path, deleted_at) VALUES (?1, ?2)",- params![fp, now_ms()],+ "INSERT OR REPLACE INTO tombstones(file_path, key, deleted_at) VALUES (?1, ?2, ?3)",+ params![fp, key, now_ms()],)?;}}@@ -198,7 +214,21 @@ impl Store {Ok(())}- pub fn remove_by_path(&self, file_path: &str) -> Result<()> {+ /// 路径 → 现行 key(watcher 增量的易主清理用)+ pub fn key_for_path(&self, file_path: &str) -> Result<Option<String>> {+ let conn = self.read.lock().unwrap();+ Ok(conn+ .query_row(+ "SELECT key FROM sessions WHERE file_path = ?1",+ params![file_path],+ |r| r.get(0),+ )+ .optional()?)+ }++ /// 按路径删行,返回被删会话的 key——watcher 用它触发幸存副本上位+ ///(同 key 的另一 location 副本接管,Codex review P2)+ pub fn remove_by_path(&self, file_path: &str) -> Result<Option<String>> {let key: Option<String> = {let conn = self.read.lock().unwrap();conn.query_row(@@ -208,10 +238,10 @@ impl Store {).optional()?};- if let Some(k) = key {- self.remove_session(&k, false)?;+ if let Some(k) = &key {+ self.remove_session(k, false)?;}- Ok(())+ Ok(key)}pub fn set_user_data(&self, key: &str, favorite: Option<bool>, pinned: Option<bool>) -> Result<()> {@@ -228,6 +258,113 @@ impl Store {Ok(())}+ // ---------- 自定义 location(Session locations 面板的 Add location) ----------++ /// 与收藏/置顶同层级的用户数据:索引重扫不动它,只有索引文件本体损坏+ /// 重建才丢(open_or_rebuild 的提示文案已列入)+ pub fn list_custom_roots(&self) -> Result<Vec<(String, String)>> {+ let conn = self.read.lock().unwrap();+ let mut stmt =+ conn.prepare_cached("SELECT agent, path FROM custom_roots ORDER BY added_at, path")?;+ let rows = stmt.query_map([], |r| Ok((r.get(0)?, r.get(1)?)))?;+ Ok(rows.flatten().collect())+ }++ pub fn add_custom_root(&self, agent: &str, path: &str) -> Result<()> {+ let conn = self.write.lock().unwrap();+ conn.execute(+ "INSERT OR IGNORE INTO custom_roots(agent, path, added_at) VALUES (?1, ?2, ?3)",+ params![agent, path, now_ms()],+ )?;+ Ok(())+ }++ /// location 配置一次取齐(自定义根 + 被移除预设),解析成模型层类型;+ /// 未识别的 agent 名(库被降级版本写过)静默跳过。GUI 与 scan CLI 共用+ pub fn location_overrides(&self) -> (Vec<(AgentId, std::path::PathBuf)>, Vec<AgentId>) {+ let customs = self+ .list_custom_roots()+ .unwrap_or_default()+ .into_iter()+ .filter_map(|(a, p)| AgentId::from_str(&a).map(|a| (a, std::path::PathBuf::from(p))))+ .collect();+ let removed = self+ .list_removed_defaults()+ .unwrap_or_default()+ .into_iter()+ .filter_map(|a| AgentId::from_str(&a))+ .collect();+ (customs, removed)+ }++ /// 编辑 location 的全形态原子写入(2026-08-24 Codex review:分开自动提交+ /// 时第二步失败会把配置改成半生效)。旧单元:自定义 = 删记录,预设 =+ /// 压默认;新单元一律记自定义——含换 agent 的编辑,全在一个事务里+ pub fn replace_location(+ &self,+ old_agent: &str,+ old_custom_path: Option<&str>,+ new_agent: &str,+ new_path: &str,+ ) -> Result<()> {+ let mut conn = self.write.lock().unwrap();+ let tx = conn.transaction()?;+ match old_custom_path {+ Some(p) => {+ tx.execute(+ "DELETE FROM custom_roots WHERE agent = ?1 AND path = ?2",+ params![old_agent, p],+ )?;+ }+ None => {+ tx.execute(+ "INSERT OR IGNORE INTO removed_defaults(agent, removed_at) VALUES (?1, ?2)",+ params![old_agent, now_ms()],+ )?;+ }+ }+ tx.execute(+ "INSERT OR IGNORE INTO custom_roots(agent, path, added_at) VALUES (?1, ?2, ?3)",+ params![new_agent, new_path, now_ms()],+ )?;+ tx.commit()?;+ Ok(())+ }++ /// 恢复初始:清空全部 location 偏离(自定义 + 被移除的预设)+ pub fn clear_location_overrides(&self) -> Result<()> {+ let conn = self.write.lock().unwrap();+ conn.execute_batch("DELETE FROM custom_roots; DELETE FROM removed_defaults;")?;+ Ok(())+ }++ /// 预设 location 的移除是"压制该家默认实例"而非删路径——默认根随+ /// env(CODEX_HOME 等)在构造时活解析,不能物化落库,故只记偏离+ pub fn list_removed_defaults(&self) -> Result<Vec<String>> {+ let conn = self.read.lock().unwrap();+ let mut stmt = conn.prepare_cached("SELECT agent FROM removed_defaults ORDER BY agent")?;+ let rows = stmt.query_map([], |r| r.get(0))?;+ Ok(rows.flatten().collect())+ }++ pub fn add_removed_default(&self, agent: &str) -> Result<()> {+ let conn = self.write.lock().unwrap();+ conn.execute(+ "INSERT OR IGNORE INTO removed_defaults(agent, removed_at) VALUES (?1, ?2)",+ params![agent, now_ms()],+ )?;+ Ok(())+ }++ pub fn remove_custom_root(&self, agent: &str, path: &str) -> Result<()> {+ let conn = self.write.lock().unwrap();+ conn.execute(+ "DELETE FROM custom_roots WHERE agent = ?1 AND path = ?2",+ params![agent, path],+ )?;+ Ok(())+ }+pub fn rebuild_all(&self) -> Result<()> {let conn = self.write.lock().unwrap();conn.execute_batch(@@ -252,6 +389,20 @@ impl Store {Ok(map)}+ /// 逻辑会话级墓碑:同 key 的任何副本(别的 location 里的拷贝)都不得+ /// 让已删会话复活(2026-08-24 Codex review P1,不变量 3 的多副本延伸)+ pub fn is_key_tombstoned(&self, key: &str) -> bool {+ let conn = self.read.lock().unwrap();+ conn.query_row(+ "SELECT 1 FROM tombstones WHERE key = ?1",+ params![key],+ |_| Ok(()),+ )+ .optional()+ .map(|o| o.is_some())+ .unwrap_or(false)+ }+pub fn is_tombstoned(&self, file_path: &str) -> bool {let conn = self.read.lock().unwrap();conn.query_row(@@ -389,7 +540,7 @@ impl Store {/// **(agent, 数据根)** 归属,免去每个目录一次往返。**不过滤 archived**/// ——归档目录本就该显示自己的量,那正是 agent_counts(WHERE archived = 0)/// 看不见的那部分。- /// 必须连 agent 一起比,且边界走 path_under:CODEX_HOME / XDG_DATA_HOME+ /// 必须连 agent 一起比,且边界走 adapters::path_owns:CODEX_HOME / XDG_DATA_HOME/// 允许把一家的数据根搬进另一家的树下,只认裸路径前缀会把整批会话静默/// 记到别家行上pub fn counts_by_path_prefix(&self, sources: &[(String, String)]) -> Result<Vec<i64>> {@@ -401,7 +552,7 @@ impl Store {let (agent, path) = row?;if let Some(i) = sources.iter()- .position(|(a, root)| *a == agent && path_under(&path, root))+ .position(|(a, root)| *a == agent && crate::adapters::path_owns(root, &path)){counts[i] += 1;}@@ -566,6 +717,49 @@ fn row_to_meta(r: &rusqlite::Row<'_>) -> rusqlite::Result<SessionMeta> {})}+/// write_session / write_session_guarded 共用的事务内核+fn write_session_tx(+ tx: &rusqlite::Transaction<'_>,+ meta: &SessionMeta,+ file_mtime: i64,+ units: &[IndexUnit],+) -> Result<()> {+ // FTS external content 需要显式 delete 旧行+ let mut sel = tx.prepare_cached("SELECT id, text FROM messages WHERE session_key = ?1")?;+ let rows: Vec<(i64, String)> = sel+ .query_map(params![meta.key], |r| Ok((r.get(0)?, r.get(1)?)))?+ .collect::<rusqlite::Result<_>>()?;+ drop(sel);+ let mut fts_del = tx.prepare_cached(+ "INSERT INTO messages_fts(messages_fts, rowid, text) VALUES ('delete', ?1, ?2)",+ )?;+ for (id, text) in rows {+ fts_del.execute(params![id, text])?;+ }+ drop(fts_del);+ tx.execute("DELETE FROM messages WHERE session_key = ?1", params![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])?;+ }+ Ok(())+}+fn upsert_session(tx: &rusqlite::Transaction<'_>, m: &SessionMeta, file_mtime: i64) -> Result<()> {tx.execute("INSERT INTO sessions(key, agent_id, native_id, title, project_path, project_name,@@ -659,13 +853,4 @@ pub fn default_db_path() -> std::path::PathBuf {db}-/// 会话文件是否落在这个数据根下。边界必须落在分隔符上,否则 `…/sessions`-/// 会把兄弟目录 `…/sessions-old` 一并吞掉;SQLite 型的数据根就是库文件本身,-/// 其会话是 `<db>#<id>` 虚拟路径,故 '#' 同样算边界-fn path_under(path: &str, root: &str) -> bool {- match path.strip_prefix(root) {- Some("") => true,- Some(rest) => rest.starts_with('/') || rest.starts_with('#'),- None => false,- }-}+diff --git a/crates/wake-core/src/models.rs b/crates/wake-core/src/models.rsindex a460d3b..7da81ff 100644--- a/crates/wake-core/src/models.rs+++ b/crates/wake-core/src/models.rs@@ -21,6 +21,25 @@ pub enum AgentId {}impl AgentId {+ /// 全部十三家,**枚举声明序**(= Ord = 用户钉的侧栏展示序;面板成组、+ /// 表单下拉共用同一顺序)。曾误抄 create_adapters 的构造序,下拉与侧栏+ /// 排序当场对不上——契约测试现在卡它与 Ord 一致+ pub const ALL: [AgentId; 13] = [+ AgentId::ClaudeCode,+ AgentId::Codex,+ AgentId::Grok,+ AgentId::Dsh,+ AgentId::Cursor,+ AgentId::Opencode,+ AgentId::Pi,+ AgentId::Omp,+ AgentId::Kiro,+ AgentId::Kimi,+ AgentId::Gemini,+ AgentId::Copilot,+ AgentId::Antigravity,+ ];+pub fn as_str(&self) -> &'static str {match self {AgentId::ClaudeCode => "claude-code",diff --git a/crates/wake-core/src/scanner.rs b/crates/wake-core/src/scanner.rsindex 88d5272..368bc93 100644--- a/crates/wake-core/src/scanner.rs+++ b/crates/wake-core/src/scanner.rs@@ -85,15 +85,94 @@ fn run_scan_inner(adapter: &'a dyn AgentAdapter,r: SessionFileRef,quick: Option<SessionMeta>,+ /// 同 key 的落选副本(裁决顺位),胜者解析失败时依次回退+ fallbacks: Vec<(usize, SessionFileRef)>,}let mut queue: Vec<WorkItem> = Vec::new();- for adapter in adapters {+ // 归属表:(根, 实例下标)。跨家/跨实例的重叠根下(自定义 location 可以+ // 落进别家树,pi/kiro 的递归枚举会吞下界内一切 .jsonl),一个文件只属于+ // **最长根**的那个实例——别家枚举到也丢弃,与 watcher 的最长根分派同一+ // 语义。不做这道过滤,两家会对同一 file_path 轮流写库(UNIQUE 冲突 ++ // 错误归属,2026-08-24 Codex review)+ let mut roots: Vec<(String, usize)> = Vec::new();+ for (ix, a) in adapters.iter().enumerate() {+ for r in a.data_roots() {+ roots.push((r.to_string_lossy().to_string(), ix));+ }+ }+ let owner_of = |path: &str| -> Option<usize> {+ roots+ .iter()+ .filter(|(root, _)| crate::adapters::path_owns(root, path))+ .max_by_key(|(root, _)| root.len())+ .map(|(_, ix)| *ix)+ };+ // 第一遍:全量枚举 + 归属过滤+ let mut per_adapter: Vec<Vec<SessionFileRef>> = Vec::with_capacity(adapters.len());+ for (ix, adapter) in adapters.iter().enumerate() {let refs: Vec<SessionFileRef> = adapter.list_session_files()?.into_iter()- .filter(|r| !store.is_tombstoned(&r.file_path))+ // 墓碑双轨:物理路径之外还按逻辑会话(key)屏蔽——多 location 下+ // 删除只 trash 了胜者文件,别的 location 里的副本不得复活它+ //(2026-08-24 Codex review P1)+ .filter(|r| {+ !store.is_tombstoned(&r.file_path)+ && !store+ .is_key_tombstoned(&format!("{}:{}", r.agent.as_str(), r.native_id))+ })+ // 无任何根认领的引用(越界枚举或合成测试)保守放行给枚举者;+ // 过滤只裁决"确有更深的根拥有它"的情形+ .filter(|r| owner_of(&r.file_path).is_none_or(|o| o == ix)).collect();+ per_adapter.push(refs);+ }+ // 同家同 ID 去重:同一会话在默认根与自定义根各有一份副本时,两个文件会+ // 每轮轮流改写同一行(key 相同,file_path 摇摆)。候选按 (mtime 新者,+ // 平局路径字典序小者) 排序,首位入队,其余留作**解析失败的回退顺位**+ // ——胜者副本截断/损坏时,不能让整个会话从索引消失(Codex review P2)+ let mut candidates: std::collections::HashMap<(AgentId, String), Vec<(usize, SessionFileRef)>> =+ std::collections::HashMap::new();+ for (ix, refs) in per_adapter.iter().enumerate() {+ for r in refs {+ candidates+ .entry((r.agent, r.native_id.clone()))+ .or_default()+ .push((ix, r.clone()));+ }+ }+ for v in candidates.values_mut() {+ v.sort_by(|(_, a), (_, b)| {+ b.mtime_ms+ .cmp(&a.mtime_ms)+ .then_with(|| a.file_path.cmp(&b.file_path))+ });+ }+ for refs in &mut per_adapter {+ refs.retain(|r| {+ candidates+ .get(&(r.agent, r.native_id.clone()))+ .is_none_or(|v| v[0].1.file_path == r.file_path)+ });+ }++ // 路径易主清理(location 编辑改了 agent / 更深的他家根接管既有文件):+ // 旧 agent 的行不先删,新 key 写入会撞 file_path UNIQUE;且文件 mtime/size+ // 未变会跳过解析——旧行先删、该路径强制入队(2026-08-24 Codex review P1)+ let mut owner_changed: std::collections::HashSet<String> = std::collections::HashSet::new();+ for refs in &per_adapter {+ 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);+ owner_changed.insert(r.file_path.clone());+ }+ }+ }+ }++ for (adapter, refs) in adapters.iter().zip(per_adapter) {for r in &refs {seen_paths.insert(r.file_path.clone());}@@ -105,11 +184,16 @@ fn run_scan_inner(.iter().filter_map(|r| {let meta = map.get(&r.file_path)?;- let changed = match known.get(&r.file_path) {- None => true,- Some((mtime, size, _)) => *mtime != r.mtime_ms || *size != r.size,- };- if changed || full {+ let changed = owner_changed.contains(&r.file_path)+ || match known.get(&r.file_path) {+ None => true,+ Some((mtime, size, _)) => *mtime != r.mtime_ms || *size != r.size,+ };+ // quick 的 key 可能已被合并策略改写(codex thread-id),+ // 墓碑要按**这个最终 key** 再卡——write_meta_only 是第三条+ // 写库路径,漏了它,已删会话会以空正文卡片复活+ //(2026-08-24 Codex review P1)+ if (changed || full) && !store.is_key_tombstoned(&meta.key) {// fileMtime=0 → 后续全量解析仍会执行Some((meta.clone(), 0))} else {@@ -124,27 +208,41 @@ fn run_scan_inner(}for r in refs {- let changed = match known.get(&r.file_path) {- None => true,- Some((mtime, size, _)) => *mtime != r.mtime_ms || *size != r.size,- };+ let changed = owner_changed.contains(&r.file_path)+ || match known.get(&r.file_path) {+ None => true,+ Some((mtime, size, _)) => *mtime != r.mtime_ms || *size != r.size,+ };if full || changed {let quick = quick_map.as_ref().and_then(|m| m.get(&r.file_path).cloned());+ let fallbacks = candidates+ .get(&(r.agent, r.native_id.clone()))+ .filter(|v| v.len() > 1)+ .map(|v| v[1..].to_vec())+ .unwrap_or_default();queue.push(WorkItem {adapter: adapter.as_ref(),r,quick,+ fallbacks,});}}}// 删除检测:库里有但磁盘没了+ let mut pruned = false;for (path, (_, _, key)) in &known {if !seen_paths.contains(path) {let _ = store.remove_session(key, false);+ pruned = true;}}+ // 纯删除轮(location 移除后的补扫常是)也要让 UI 刷新:解析队列为空时+ // 下方循环一次不跑,不发这个事件,列表会一直挂着已删会话(Codex review P1)+ if pruned {+ events.on_sessions_changed();+ }// 最近的会话优先queue.sort_by(|a, b| b.r.mtime_ms.cmp(&a.r.mtime_ms));@@ -161,11 +259,51 @@ fn run_scan_inner(Some(q) => item.adapter.merge_quick_meta(parsed.meta, q),None => parsed.meta,};- if let Err(e) = store.write_session(&meta, item.r.mtime_ms, &parsed.units) {+ // 合并可能改写 key(codex 的 state thread-id):改名后的 key+ // 也要受墓碑约束,否则改名副本绕过上面的枚举过滤+ if store.is_key_tombstoned(&meta.key) {+ progress.done += 1;+ continue;+ }+ // 全量写入也走事务内副本裁决:扫描快照里的旧副本不得覆盖+ // watcher 并发间隙写入的更新副本(启动扫描与手动刷新期间+ // watcher 都活着,2026-08-24 Codex review P1)+ if let Err(e) = store.write_session_guarded(&meta, item.r.mtime_ms, &parsed.units)+ {eprintln!("[scanner] write failed {}: {e}", item.r.file_path);}}- Err(e) => eprintln!("[scanner] parse failed {}: {e}", item.r.file_path),+ Err(e) => {+ eprintln!("[scanner] parse failed {}: {e}", item.r.file_path);+ // 胜者副本坏了不等于会话消失:按裁决顺位回退到下一份有效副本。+ // 回退实例自己的 quick 合并不能省——codex 的 state key(thread id)+ // 可与文件 native id 不同,绕过 merge 会丢手工标题、还可能留下+ // 双 key 两行(2026-08-24 Codex review)+ for (fb_ix, fb) in &item.fallbacks {+ let fb_adapter = &adapters[*fb_ix];+ match fb_adapter.parse_session(fb) {+ Ok(parsed) => {+ let quick = fb_adapter.quick_meta(std::slice::from_ref(fb));+ let meta = match quick.as_ref().and_then(|m| m.get(&fb.file_path)) {+ Some(q) => fb_adapter.merge_quick_meta(parsed.meta, q),+ None => parsed.meta,+ };+ if store.is_key_tombstoned(&meta.key) {+ break;+ }+ if let Err(e) =+ store.write_session_guarded(&meta, fb.mtime_ms, &parsed.units)+ {+ eprintln!("[scanner] fallback write failed {}: {e}", fb.file_path);+ }+ break;+ }+ Err(e2) => {+ eprintln!("[scanner] fallback parse failed {}: {e2}", fb.file_path)+ }+ }+ }+ }}progress.done += 1;if last_notify.elapsed().as_millis() > 800 || progress.done == progress.total {@@ -187,22 +325,26 @@ pub fn scan_files(events: &dyn ScanEvents,refs: Vec<SessionFileRef>,) {- // 按 agent 分组:quick_meta 是整库查询(Codex 要开 state DB 读整张 threads),- // 每组只查一次,不能逐文件调- let mut by_agent: std::collections::HashMap<AgentId, Vec<SessionFileRef>> =+ // 按**实例**分组,不是按 agent:自定义 location 让同 agent 有多实例,+ // 文件必须交给拥有其根的那个(gemini/kimi 的 cwd 反查、codex 的 state DB+ // 都是实例相对侧档);quick_meta 是整库查询,每组只查一次,不能逐文件调+ 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 store.is_tombstoned(&r.file_path)+ || store.is_key_tombstoned(&format!("{}:{}", r.agent.as_str(), r.native_id))+ {continue;}- by_agent.entry(r.agent).or_default().push(r);+ let Some(ix) = crate::adapters::adapter_ix_for(adapters, r.agent, &r.file_path) else {+ continue;+ };+ by_adapter.entry(ix).or_default().push(r);}let mut changed = false;- for (agent, group) in by_agent {- let Some(adapter) = adapters.iter().find(|a| a.agent() == agent) else {- continue;- };+ for (ix, group) in by_adapter {+ let adapter = &adapters[ix];let quick = adapter.quick_meta(&group);for r in &group {match adapter.parse_session(r) {@@ -211,7 +353,24 @@ pub fn scan_files(Some(q) => adapter.merge_quick_meta(parsed.meta, q),None => parsed.meta,};- if store.write_session(&meta, r.mtime_ms, &parsed.units).is_ok() {+ // 合并后 key 改名(codex thread-id)也受墓碑约束+ if store.is_key_tombstoned(&meta.key) {+ continue;+ }+ // 路径易主(location 编辑改了 agent):旧 key 行不清,新 key+ // 写入撞 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);+ }+ }+ // 副本裁决在写事务内(write_session_guarded):先查后写与+ // 全量扫描并发交错时,败方能后发落库违背 mtime 裁决+ //(rsync 刷备份目录带旧 mtime 的事件串,2026-08-24 Codex review)+ if store+ .write_session_guarded(&meta, r.mtime_ms, &parsed.units)+ .unwrap_or(false)+ {changed = true;}}diff --git a/crates/wake-core/src/watcher.rs b/crates/wake-core/src/watcher.rsindex 61aa5ae..8506cd5 100644--- a/crates/wake-core/src/watcher.rs+++ b/crates/wake-core/src/watcher.rs@@ -10,10 +10,22 @@ use std::sync::Arc;use std::time::Duration;/// 监听 adapter 数据目录,800ms 去抖后做单文件增量。-/// 返回的 handle drop 时停止监听。+/// drop 即停:先撤事件源(通道关闭、线程退出循环),再 **join 等线程真正+/// 退出**——roster 换代时旧线程可能正持旧 roster/Store 在写库,不等它收尾,+/// 已移除根的会话会在新 roster 补扫之后被写回、复活到下次手动刷新+/// (2026-08-24 Codex review P1)。在批处理粒度上等待,通常毫秒级pub struct SessionWatcher {- _watcher: notify::RecommendedWatcher,- _thread: std::thread::JoinHandle<()>,+ watcher: Option<notify::RecommendedWatcher>,+ thread: Option<std::thread::JoinHandle<()>>,+}++impl Drop for SessionWatcher {+ fn drop(&mut self) {+ self.watcher.take();+ if let Some(t) = self.thread.take() {+ let _ = t.join();+ }+ }}/// 事件路径 → 归属 agent:取**最长匹配根**,不是第一个命中。env 自定义根@@ -22,12 +34,68 @@ pub struct SessionWatcher {/// 很宽松,会以错误的 agent 入库(错 key + 同 file_path 还会触发 UNIQUE 冲突)。/// 更深的根必然是更具体的归属;Path::starts_with 按组件比较,同名前缀兄弟/// 目录不会误匹配-pub fn resolve_watch_agent(roots: &[(PathBuf, AgentId)], path: &Path) -> Option<AgentId> {+pub fn resolve_watch_agent<T: Copy>(roots: &[(PathBuf, T)], path: &Path) -> Option<T> {roots.iter().filter(|(root, _)| path.starts_with(root)).max_by_key(|(root, _)| root.components().count())- .map(|(_, agent)| *agent)+ .map(|(_, tag)| *tag)+}++/// 胜者副本被删后的幸存者上位:按被删 key 反查同家实例枚举里的同 native_id+/// 引用,交常规增量收编(该 key 已无既有行,scan_files 的副本裁决自然放行)。+/// codex 经 state DB 改写过的 key(thread-id ≠ 文件 native_id)反查不到,由+/// 下一次全量扫描兜底;删除事件罕见,逐家枚举(纯 stat)代价可忽略+pub fn promote_survivors(+ adapters: &[Box<dyn AgentAdapter>],+ store: &Arc<Store>,+ events: &dyn ScanEvents,+ removed_keys: &[String],+) {+ let mut seen = std::collections::HashSet::new();+ let mut survivors: Vec<SessionFileRef> = Vec::new();+ for key in removed_keys {+ if !seen.insert(key.as_str()) {+ continue;+ }+ let Some((agent_str, native_id)) = key.split_once(':') else { continue };+ let Some(agent) = AgentId::from_str(agent_str) else { continue };+ let mut agent_refs: Vec<SessionFileRef> = Vec::new();+ for a in adapters.iter().filter(|a| a.agent() == agent) {+ if let Ok(refs) = a.list_session_files() {+ agent_refs.extend(refs);+ }+ }+ let by_name: Vec<SessionFileRef> = agent_refs+ .iter()+ .filter(|r| r.native_id == native_id)+ .cloned()+ .collect();+ if !by_name.is_empty() {+ survivors.extend(by_name);+ continue;+ }+ // key 后缀是**内容 id** 的家(gemini 的 sessionId、pi/dsh 的首行 id)+ // 文件名对不上——退而解析比对,规模封顶防重罚(超限交下次全量扫描)+ if agent_refs.len() <= 32 {+ for r in agent_refs {+ let Some(owner) = crate::adapters::adapter_for(adapters, r.agent, &r.file_path)+ else {+ continue;+ };+ if owner+ .parse_session(&r)+ .is_ok_and(|p| p.meta.key.as_str() == key.as_str())+ {+ survivors.push(r);+ break;+ }+ }+ }+ }+ if !survivors.is_empty() {+ scan_files(adapters, store, events, survivors);+ }}pub fn start_watcher(@@ -35,10 +103,13 @@ pub fn start_watcher(store: Arc<Store>,events: Arc<dyn ScanEvents>,) -> Option<SessionWatcher> {- let mut roots: Vec<(PathBuf, AgentId)> = Vec::new();- for a in adapters.iter() {+ // 根携带实例下标而非 AgentId:同 agent 多实例(自定义 location)时,+ // file_ref 也必须由拥有该根的实例执行——dsh 的 file_ref 要读文件首行,+ // 实例相对的判据按 agent 找第一个会拿默认实例跑偏+ let mut roots: Vec<(PathBuf, usize)> = Vec::new();+ for (ix, a) in adapters.iter().enumerate() {for p in a.watch_paths() {- roots.push((p, a.agent()));+ roots.push((p, ix));}}if roots.is_empty() {@@ -52,9 +123,9 @@ pub fn start_watcher(}let thread = std::thread::spawn(move || {- let resolve_agent = |path: &Path| resolve_watch_agent(&roots, path);+ let resolve_ix = |path: &Path| resolve_watch_agent(&roots, path);- let mut pending: HashMap<PathBuf, AgentId> = HashMap::new();+ let mut pending: HashMap<PathBuf, usize> = HashMap::new();let mut removed: Vec<PathBuf> = Vec::new();loop {// 等首个事件(阻塞),然后 800ms 窗口收敛@@ -76,26 +147,26 @@ pub fn start_watcher(if matches!(ev.kind, notify::EventKind::Remove(_)) {pending.remove(&path);removed.push(path.clone());- } else if let Some(agent) = resolve_agent(&path) {- pending.insert(path.clone(), agent);+ } else if let Some(ix) = resolve_ix(&path) {+ pending.insert(path.clone(), ix);}}}+ let mut removed_keys: Vec<String> = Vec::new();for path in removed.drain(..) {- let _ = store.remove_by_path(&path.to_string_lossy());+ if let Ok(Some(key)) = store.remove_by_path(&path.to_string_lossy()) {+ removed_keys.push(key);+ }events.on_sessions_changed();}+ promote_survivors(&adapters, &store, events.as_ref(), &removed_keys);- // 路径是否本 agent 的会话文件、native_id 怎么取,统一问 adapter+ // 路径是否本 agent 的会话文件、native_id 怎么取,统一问**拥有+ // 该根的实例**(下标即 roots 表登记的归属)let refs: Vec<SessionFileRef> = pending.drain()- .filter_map(|(path, agent)| {- adapters- .iter()- .find(|a| a.agent() == agent)- .and_then(|a| a.file_ref(&path))- })+ .filter_map(|(path, ix)| adapters.get(ix).and_then(|a| a.file_ref(&path))).collect();if !refs.is_empty() {scan_files(&adapters, &store, events.as_ref(), refs);@@ -104,7 +175,7 @@ pub fn start_watcher(});Some(SessionWatcher {- _watcher: watcher,- _thread: thread,+ watcher: Some(watcher),+ thread: Some(thread),})}diff --git a/crates/wake-core/tests/adapter_contracts.rs b/crates/wake-core/tests/adapter_contracts.rsindex f178ffe..6d74bd6 100644--- a/crates/wake-core/tests/adapter_contracts.rs+++ b/crates/wake-core/tests/adapter_contracts.rs@@ -1128,3 +1128,247 @@ fn merge_quick_meta_default_vs_codex_override() {let merged = codex.merge_quick_meta(parsed, &quick);assert_eq!(merged.title, "首条消息推导标题");}++// ---------------------------------------------------------------- 自定义 location++/// with_custom_root 契约(不变量 8 配套):agent 不变、数据根全部落在自定义+/// 目录之下(侧档也必须相对它派生,但侧档不在 data_roots,无法在此直接断言)、+/// 缺根照旧降级为 Ok(空)+#[test]+fn with_custom_root_contract() {+ setup();+ let dir = tempfile::tempdir().unwrap();+ let custom = dir.path().join("somewhere-else");+ for base in wake_core::adapters::create_adapters() {+ let inst = base.with_custom_root(custom.clone());+ assert_eq!(inst.agent(), base.agent(), "{:?}: 自定义实例换了 agent", base.agent());+ let roots = inst.data_roots();+ assert!(!roots.is_empty(), "{:?}: 自定义实例无数据根", base.agent());+ for r in &roots {+ assert!(+ r.starts_with(&custom),+ "{:?}: 数据根 {} 溢出自定义目录 {}",+ base.agent(),+ r.display(),+ custom.display()+ );+ }+ let refs = inst+ .list_session_files()+ .unwrap_or_else(|e| panic!("{:?}: 缺根必须 Ok(空) 降级,却 Err: {e}", base.agent()));+ assert!(refs.is_empty(), "{:?}: 空目录读出了会话", base.agent());+ }++ // codex 的"直接选中 rollout 日期树"分支:顶层有 YYYY 目录时,dir 本身+ // 即 sessions 根(用户常会选中 sessions 目录本体)+ let tree = dir.path().join("codex-sessions-copy");+ fs::create_dir_all(tree.join("2026")).unwrap();+ let inst = CodexAdapter::new().with_custom_root(tree.clone());+ assert!(+ inst.data_roots().contains(&tree),+ "codex 未把 rollout 树本体当 sessions 根: {:?}",+ inst.data_roots()+ );+}++/// AgentId::ALL 是侧栏/面板/表单下拉共用的顺序事实源:必须与枚举声明序+/// (= Ord,用户 2026-08-20 钉的展示序)严格一致,且与 roster 的 agent 集合+/// 等同——第十四家漏进任何一份名单,在这里爆而不是静默从下拉里消失+#[test]+fn agent_id_all_matches_ord_and_roster() {+ setup();+ assert!(+ AgentId::ALL.windows(2).all(|w| w[0] < w[1]),+ "ALL 未按声明序(Ord)排列"+ );+ let mut roster: Vec<AgentId> = wake_core::adapters::create_adapters()+ .iter()+ .map(|a| a.agent())+ .collect();+ roster.sort();+ let mut all = AgentId::ALL.to_vec();+ all.sort();+ assert_eq!(all, roster, "ALL 与 roster 的 agent 集合不一致");+}++/// 预设 location 的移除 = 压制该家默认实例;该家的自定义实例仍从默认模板+/// 构造、照常在场(编辑预设 = 压默认 + 记自定义,正是这个组合)+#[test]+fn removed_defaults_suppress_instances() {+ setup();+ let roster = wake_core::adapters::create_adapters_with(&[], &[AgentId::ClaudeCode]);+ assert_eq!(roster.len(), 12);+ assert!(roster.iter().all(|a| a.agent() != AgentId::ClaudeCode));++ let dir = tempfile::tempdir().unwrap();+ let roster = wake_core::adapters::create_adapters_with(+ &[(AgentId::ClaudeCode, dir.path().to_path_buf())],+ &[AgentId::ClaudeCode],+ );+ let claude: Vec<_> = roster.iter().filter(|a| a.agent() == AgentId::ClaudeCode).collect();+ assert_eq!(claude.len(), 1, "默认被压制后应只剩自定义实例");+ assert!(claude[0].data_roots().iter().all(|r| r.starts_with(dir.path())));+}++/// normalize_custom_root(静态分派,不依赖 roster——该家默认被移除时也要+/// 生效):codex 直选 sessions 树或**平铺 archived** 且父目录呈 home 形态时+/// 上提一层(侧档/归档找回,2026-08-24 Codex review);裸拷贝与其他家恒等+#[test]+fn codex_normalize_lifts_sessions_dir_to_home() {+ use wake_core::adapters::normalize_custom_root;+ setup();+ let tmp = tempfile::tempdir().unwrap();+ let home = tmp.path().join("codex-home");+ fs::create_dir_all(home.join("sessions").join("2026")).unwrap();+ fs::create_dir_all(home.join("archived_sessions")).unwrap();+ fs::write(home.join("archived_sessions").join("rollout-x.jsonl"), b"{}").unwrap();+ fs::write(home.join("state_5.sqlite"), b"x").unwrap();+ assert_eq!(normalize_custom_root(AgentId::Codex, home.join("sessions")), home);+ assert_eq!(+ normalize_custom_root(AgentId::Codex, home.join("archived_sessions")),+ home,+ "平铺 archived 目录也应上提到 home"+ );++ let bare = tmp.path().join("codex-copy");+ fs::create_dir_all(bare.join("2026")).unwrap();+ assert_eq!(+ normalize_custom_root(AgentId::Codex, bare.clone()),+ bare,+ "裸树不上提"+ );++ // 空的真实 sessions 目录(表单允许空路径):凭目录名 + 父级独立证据上提+ let home2 = tmp.path().join("codex-home-2");+ fs::create_dir_all(home2.join("sessions")).unwrap();+ fs::write(home2.join("state_5.sqlite"), b"x").unwrap();+ assert_eq!(+ normalize_custom_root(AgentId::Codex, home2.join("sessions")),+ home2,+ "空 sessions 目录也应上提"+ );+ // 孤立的空 sessions 目录(父级无任何 home 证据)保持原样+ let lone = tmp.path().join("lone");+ fs::create_dir_all(lone.join("sessions")).unwrap();+ assert_eq!(+ normalize_custom_root(AgentId::Codex, lone.join("sessions")),+ lone.join("sessions")+ );++ let d = tmp.path().join("whatever");+ assert_eq!(+ normalize_custom_root(AgentId::ClaudeCode, d.clone()),+ d,+ "无覆写的家恒等"+ );+}++/// create_adapters_for:roster 必须吃索引库里的 location 配置——scan CLI 曾用+/// 默认 roster 对配置过的库跑扫描,把自定义根会话当"已删"整批清掉+/// (2026-08-24 Codex review)+#[test]+fn create_adapters_for_honors_store_config() {+ setup();+ let dir = tempfile::tempdir().unwrap();+ let store = wake_core::db::Store::open(&dir.path().join("t.db")).unwrap();+ store.add_custom_root("claude-code", "/tmp/claude-backup").unwrap();+ store.add_removed_default("codex").unwrap();+ let roster = wake_core::adapters::create_adapters_for(&store);+ assert!(+ roster.iter().all(|a| a.agent() != AgentId::Codex),+ "被移除的预设仍在 roster"+ );+ assert_eq!(+ roster.iter().filter(|a| a.agent() == AgentId::ClaudeCode).count(),+ 2,+ "自定义 location 未生效"+ );+}++/// path_owns 的边界字典:分隔符边界(sessions-old 不属 sessions)、SQLite+/// 虚拟路径的 '#'、文件系统根 "/"(strip_prefix 剥掉的正是分隔符,通用分支+/// 会全判界外——2026-08-24 Codex review)+#[test]+fn path_owns_boundaries() {+ use wake_core::adapters::path_owns;+ assert!(path_owns("/a/sessions", "/a/sessions"));+ assert!(path_owns("/a/sessions", "/a/sessions/x.jsonl"));+ assert!(!path_owns("/a/sessions", "/a/sessions-old/x.jsonl"));+ assert!(path_owns("/a/store.db", "/a/store.db#42"));+ assert!(path_owns("/", "/anything/below"));+ assert!(!path_owns("/b", "/a/x"));+}++/// 裸 Codex 数据目录按目录名保角色(2026-08-24 Codex review):独立 archived+/// 拷贝的会话保住 archived 标记;空的独立 sessions 目录以自身为数据根,+/// 日后落盘的 rollout 能被发现+#[test]+fn codex_bare_data_dir_keeps_role() {+ setup();+ let tmp = tempfile::tempdir().unwrap();+ let arch = tmp.path().join("archived_sessions");+ fs::create_dir_all(&arch).unwrap();+ fs::copy(+ fixture("codex/sessions/2026/08/02/rollout-2026-08-02T09-15-00-22222222-aaaa-bbbb-cccc-000000000002.jsonl"),+ arch.join("rollout-2026-08-02T09-15-00-22222222-aaaa-bbbb-cccc-000000000002.jsonl"),+ )+ .unwrap();+ let inst = CodexAdapter::new().with_custom_root(arch.clone());+ let refs = inst.list_session_files().unwrap();+ assert_eq!(refs.len(), 1, "独立 archived 目录应以自身为数据根");+ let parsed = inst.parse_session(&refs[0]).unwrap();+ assert!(parsed.meta.archived, "archived 角色丢失,归档会话被标成活跃");++ let empty_sessions = tmp.path().join("sessions");+ fs::create_dir_all(&empty_sessions).unwrap();+ let inst = CodexAdapter::new().with_custom_root(empty_sessions.clone());+ assert!(+ inst.data_roots().contains(&empty_sessions),+ "空的独立 sessions 目录应以自身为数据根"+ );+}++/// SQLite 型构造器直接给到库文件路径也认(预设行编辑值即库文件,当目录拼+/// 会得到 <db>/<db> 死路径——2026-08-24 Codex review)+#[test]+fn sqlite_custom_root_accepts_db_file() {+ let env = setup();+ let inst = CopilotAdapter::new().with_custom_root(env.copilot_db.clone());+ assert_eq!(inst.data_roots(), vec![env.copilot_db.clone()]);+ let inst = OpencodeAdapter::new().with_custom_root(env.opencode_db.clone());+ assert_eq!(inst.data_roots(), vec![env.opencode_db.clone()]);+ let inst = AntigravityAdapter::new().with_custom_root(env.antigravity_db.clone());+ assert_eq!(inst.data_roots(), vec![env.antigravity_db.clone()]);+}++/// 实例路由(不变量 8 配套):同 agent 多实例时,文件按"拥有其根的实例"+/// 分派(最长前缀 + 分隔符边界),匹配不到根回退默认实例+#[test]+fn adapter_ix_for_routes_to_owning_instance() {+ setup();+ let dir = tempfile::tempdir().unwrap();+ let custom = dir.path().to_path_buf();+ let roster =+ wake_core::adapters::create_adapters_with(&[(AgentId::ClaudeCode, custom.clone())], &[]);+ assert_eq!(roster.len(), 14, "13 默认 + 1 自定义");+ assert_eq!(roster[13].agent(), AgentId::ClaudeCode);++ let under = format!("{}/projects/p/x.jsonl", custom.display());+ assert_eq!(+ wake_core::adapters::adapter_ix_for(&roster, AgentId::ClaudeCode, &under),+ Some(13),+ "自定义根下的文件应路由到自定义实例"+ );+ // 兄弟目录(裸前缀)不得吸入+ let sibling = format!("{}-old/x.jsonl", custom.display());+ assert_eq!(+ wake_core::adapters::adapter_ix_for(&roster, AgentId::ClaudeCode, &sibling),+ Some(0),+ "边界外路径应回退默认实例"+ );+ assert_eq!(+ wake_core::adapters::adapter_ix_for(&roster, AgentId::Codex, "/nowhere/x.jsonl"),+ Some(1),+ "无根命中回退该 agent 首个实例"+ );+}diff --git a/crates/wake-core/tests/db_roundtrip.rs b/crates/wake-core/tests/db_roundtrip.rsindex 3aea6b5..9d3416d 100644--- a/crates/wake-core/tests/db_roundtrip.rs+++ b/crates/wake-core/tests/db_roundtrip.rs@@ -164,3 +164,74 @@ fn path_counts_respect_agent_and_boundary() {assert_eq!(counts[0], 1, "codex 的会话不该被记到 claude 行");assert_eq!(counts[1], 1, "sessions-old 不该算进 sessions");}++/// 自定义 location 的持久化:与收藏/置顶同层级的用户数据,重复添加幂等+#[test]+fn custom_roots_roundtrip() {+ let (_dir, store) = temp_store();+ store.add_custom_root("codex", "/tmp/a").unwrap();+ store.add_custom_root("codex", "/tmp/a").unwrap(); // 幂等+ store.add_custom_root("claude-code", "/tmp/b").unwrap();++ let mut roots = store.list_custom_roots().unwrap();+ roots.sort();+ assert_eq!(+ roots,+ vec![+ ("claude-code".to_string(), "/tmp/b".to_string()),+ ("codex".to_string(), "/tmp/a".to_string()),+ ]+ );++ store.remove_custom_root("codex", "/tmp/a").unwrap();+ assert_eq!(+ store.list_custom_roots().unwrap(),+ vec![("claude-code".to_string(), "/tmp/b".to_string())]+ );++ // 预设移除是按 agent 压制,幂等+ store.add_removed_default("codex").unwrap();+ store.add_removed_default("codex").unwrap();+ assert_eq!(store.list_removed_defaults().unwrap(), vec!["codex".to_string()]);++ // 编辑的原子替换:自定义换路径 / 预设改自定义 / 换 agent,全走单事务+ store.add_custom_root("grok", "/tmp/g1").unwrap();+ store.replace_location("grok", Some("/tmp/g1"), "grok", "/tmp/g2").unwrap();+ assert_eq!(+ store.list_custom_roots().unwrap(),+ vec![+ ("claude-code".to_string(), "/tmp/b".to_string()),+ ("grok".to_string(), "/tmp/g2".to_string()),+ ]+ );+ store.replace_location("kiro", None, "kiro", "/tmp/k").unwrap();+ assert!(store.list_removed_defaults().unwrap().contains(&"kiro".to_string()));+ store.replace_location("grok", Some("/tmp/g2"), "cursor", "/tmp/cur").unwrap();+ let roots = store.list_custom_roots().unwrap();+ assert!(roots.iter().any(|(a, p)| a == "cursor" && p == "/tmp/cur"));+ assert!(!roots.iter().any(|(a, _)| a == "grok"));++ // Restore defaults 语义:自定义与预设移除一把双清+ store.add_custom_root("grok", "/tmp/c").unwrap();+ store.clear_location_overrides().unwrap();+ assert!(store.list_custom_roots().unwrap().is_empty());+ assert!(store.list_removed_defaults().unwrap().is_empty());+}++/// 增量写入的胜者裁决在写事务内:败方副本(旧 mtime、异路径)一字不写,+/// 反超后按规则接管(2026-08-24 Codex review)+#[test]+fn guarded_write_respects_winner() {+ let (_dir, store) = temp_store();+ let mut winner = meta("codex:g", "胜者");+ winner.file_path = "/live/g.jsonl".into();+ store.write_session(&winner, 9, &[]).unwrap();++ let mut loser = meta("codex:g", "败方");+ loser.file_path = "/backup/g.jsonl".into();+ assert!(!store.write_session_guarded(&loser, 5, &[]).unwrap(), "败方不该写入");+ assert_eq!(store.get_session("codex:g").unwrap().unwrap().file_path, "/live/g.jsonl");++ assert!(store.write_session_guarded(&loser, 12, &[]).unwrap(), "反超应接管");+ assert_eq!(store.get_session("codex:g").unwrap().unwrap().file_path, "/backup/g.jsonl");+}diff --git a/crates/wake-core/tests/scanner_finale.rs b/crates/wake-core/tests/scanner_finale.rsindex 1b6f29d..dce6de1 100644--- a/crates/wake-core/tests/scanner_finale.rs+++ b/crates/wake-core/tests/scanner_finale.rs@@ -11,14 +11,25 @@ use wake_core::db::Store;use wake_core::models::*;use wake_core::scanner::{run_scan, ScanEvents, ScanProgress};-/// 收集全部进度事件,供断言终态-struct Recorder(Mutex<Vec<ScanProgress>>);+/// 收集全部进度事件与变更通知计数,供断言终态/刷新契约+struct Recorder(Mutex<Vec<ScanProgress>>, Mutex<usize>);++impl Recorder {+ fn new() -> Self {+ Recorder(Mutex::new(Vec::new()), Mutex::new(0))+ }+ fn changed(&self) -> usize {+ *self.1.lock().unwrap()+ }+}impl ScanEvents for Recorder {fn on_progress(&self, p: &ScanProgress) {self.0.lock().unwrap().push(p.clone());}- fn on_sessions_changed(&self) {}+ fn on_sessions_changed(&self) {+ *self.1.lock().unwrap() += 1;+ }}/// 枚举文件即失败的 adapter,模拟数据源不可读@@ -40,6 +51,9 @@ impl AgentAdapter for FailingAdapter {fn data_roots(&self) -> Vec<std::path::PathBuf> {vec![std::path::PathBuf::from("/nonexistent/test-adapter")]}+ fn with_custom_root(&self, _: std::path::PathBuf) -> Box<dyn AgentAdapter> {+ Box::new(FailingAdapter)+ }}fn assert_terminal_event(events: &[ScanProgress], ctx: &str) {@@ -59,7 +73,7 @@ fn finale_fires_on_empty_scan() {let dir = tempfile::tempdir().unwrap();let store = temp_store(dir.path());let adapters: Vec<Box<dyn AgentAdapter>> = Vec::new();- let rec = Recorder(Mutex::new(Vec::new()));+ let rec = Recorder::new();let _ = run_scan(&adapters, &store, &rec, false);assert_terminal_event(&rec.0.lock().unwrap(), "空 adapter 列表");@@ -70,23 +84,30 @@ fn finale_fires_when_adapter_fails() {let dir = tempfile::tempdir().unwrap();let store = temp_store(dir.path());let adapters: Vec<Box<dyn AgentAdapter>> = vec![Box::new(FailingAdapter)];- let rec = Recorder(Mutex::new(Vec::new()));+ let rec = Recorder::new();// list_session_files 报错的路径:无论 run_scan 返回 Ok/Err,终态事件必须送达let _ = run_scan(&adapters, &store, &rec, false);assert_terminal_event(&rec.0.lock().unwrap(), "adapter 枚举失败");}-/// 固定提供一个会话(含 quickMeta 快路径)的 adapter,-/// 模拟 Codex state DB 中删除后仍残留的行+/// 固定提供一个会话(含 quickMeta 快路径)的 adapter。agent/root 可参数化:+/// 防复活、跨根去重、重叠根归属三组测试共用struct SeedAdapter {+ agent: AgentId,+ root: std::path::PathBuf,r: SessionFileRef,meta: SessionMeta,+ /// 模拟截断/损坏副本:解析一律报错(副本回退测试用)+ fail_parse: bool,+ /// 模拟 codex 的 state 改名:quick 给出的 key 与文件 native key 不同,+ /// merge 时 quick key 压过 parsed(codex 同款优先级)+ quick_key: Option<String>,}impl AgentAdapter for SeedAdapter {fn agent(&self) -> AgentId {- AgentId::Codex+ self.agent}fn list_session_files(&self) -> Result<Vec<SessionFileRef>> {Ok(vec![self.r.clone()])@@ -95,11 +116,24 @@ impl AgentAdapter for SeedAdapter {&self,_refs: &[SessionFileRef],) -> Option<std::collections::HashMap<String, SessionMeta>> {+ let mut meta = self.meta.clone();+ if let Some(k) = &self.quick_key {+ meta.key = k.clone();+ }let mut m = std::collections::HashMap::new();- m.insert(self.r.file_path.clone(), self.meta.clone());+ m.insert(self.r.file_path.clone(), meta);Some(m)}+ fn merge_quick_meta(&self, mut parsed: SessionMeta, quick: &SessionMeta) -> SessionMeta {+ if self.quick_key.is_some() {+ parsed.key = quick.key.clone();+ }+ parsed+ }fn parse_session(&self, _: &SessionFileRef) -> Result<ParsedSession> {+ if self.fail_parse {+ bail!("simulated corrupt copy")+ }Ok(ParsedSession {meta: self.meta.clone(),units: Vec::new(),@@ -110,7 +144,54 @@ impl AgentAdapter for SeedAdapter {bail!("transcript not needed in scan")}fn data_roots(&self) -> Vec<std::path::PathBuf> {- vec![std::path::PathBuf::from("/nonexistent/test-adapter")]+ vec![self.root.clone()]+ }+ fn with_custom_root(&self, _: std::path::PathBuf) -> Box<dyn AgentAdapter> {+ Box::new(SeedAdapter {+ agent: self.agent,+ root: self.root.clone(),+ r: self.r.clone(),+ meta: self.meta.clone(),+ fail_parse: self.fail_parse,+ quick_key: self.quick_key.clone(),+ })+ }+}++/// SeedAdapter 三件套:根/路径/mtime 齐配的最小会话+fn seed(agent: AgentId, root: &str, path: &str, native_id: &str, mtime: i64) -> SeedAdapter {+ SeedAdapter {+ agent,+ root: std::path::PathBuf::from(root),+ r: SessionFileRef {+ agent,+ native_id: native_id.into(),+ file_path: path.into(),+ mtime_ms: mtime,+ size: 1,+ },+ meta: SessionMeta {+ key: format!("{}:{native_id}", agent.as_str()),+ id: native_id.into(),+ agent,+ title: "seed".into(),+ project_path: "/tmp/p".into(),+ project_name: "p".into(),+ file_path: path.into(),+ created_at: 1,+ updated_at: mtime,+ message_count: 0,+ size_bytes: 1,+ git_branch: None,+ model: None,+ tokens_used: None,+ archived: false,+ source: None,+ favorite: false,+ pinned: false,+ },+ fail_parse: false,+ quick_key: None,}}@@ -147,9 +228,15 @@ fn tombstoned_session_does_not_resurrect_on_rescan() {mtime_ms: 2,size: 1,};- let adapters: Vec<Box<dyn AgentAdapter>> =- vec![Box::new(SeedAdapter { r, meta: meta.clone() })];- let rec = Recorder(Mutex::new(Vec::new()));+ let adapters: Vec<Box<dyn AgentAdapter>> = vec![Box::new(SeedAdapter {+ agent: AgentId::Codex,+ root: std::path::PathBuf::from("/tmp/fixtures"),+ r,+ meta: meta.clone(),+ fail_parse: false,+ quick_key: None,+ })];+ let rec = Recorder::new();run_scan(&adapters, &store, &rec, true).unwrap();assert!(store.get_session("codex:ghost").unwrap().is_some(), "首扫应写入");@@ -161,3 +248,245 @@ fn tombstoned_session_does_not_resurrect_on_rescan() {"tombstoned 会话重扫后复活 = 不变量 3 破坏");}++/// 同 agent 双根下的同 ID 会话:mtime 新者胜且跨轮稳定。旧行为是"后写者胜",+/// 两个副本每轮轮流改写同一行、file_path 随扫描摇摆(2026-08-24 Codex review)+/// ——故意把旧副本排在 roster 后面,旧代码在此必败+#[test]+fn duplicate_session_across_roots_resolves_to_newest() {+ let dir = tempfile::tempdir().unwrap();+ let store = temp_store(dir.path());+ let adapters: Vec<Box<dyn AgentAdapter>> = vec![+ Box::new(seed(AgentId::Codex, "/live", "/live/dup.jsonl", "dup", 9)),+ Box::new(seed(AgentId::Codex, "/backup", "/backup/dup.jsonl", "dup", 5)),+ ];+ let rec = Recorder::new();+ for round in 0..2 {+ run_scan(&adapters, &store, &rec, true).unwrap();+ let s = store.get_session("codex:dup").unwrap().expect("会话应在库");+ assert_eq!(+ s.file_path, "/live/dup.jsonl",+ "第 {round} 轮后 file_path 未稳定在 mtime 新者上"+ );+ }+}++/// 跨 agent 重叠根:文件只归**最长根**的实例(与 watcher 分派同一语义)。+/// 旧行为两家轮流认领——先写的一家留下错误归属,后写的撞 file_path UNIQUE+#[test]+fn overlapping_roots_assign_file_to_deepest_instance() {+ let dir = tempfile::tempdir().unwrap();+ let store = temp_store(dir.path());+ let adapters: Vec<Box<dyn AgentAdapter>> = vec![+ Box::new(seed(AgentId::ClaudeCode, "/x", "/x/inner/f.jsonl", "f", 7)),+ Box::new(seed(AgentId::Codex, "/x/inner", "/x/inner/f.jsonl", "f", 7)),+ ];+ let rec = Recorder::new();+ run_scan(&adapters, &store, &rec, true).unwrap();+ assert!(+ store.get_session("codex:f").unwrap().is_some(),+ "最长根(/x/inner)的实例应拥有该文件"+ );+ assert!(+ store.get_session("claude-code:f").unwrap().is_none(),+ "外层根实例不得认领别家树内的文件"+ );+}++/// watcher 增量同样受副本裁决约束:败方副本(旧 mtime)的文件事件不得覆盖+/// 已选中的胜者行——rsync 刷新备份目录会带旧 mtime 触发一串事件+/// (2026-08-24 Codex review P1)+#[test]+fn incremental_write_respects_duplicate_winner() {+ let dir = tempfile::tempdir().unwrap();+ let store = temp_store(dir.path());+ let live = seed(AgentId::Codex, "/live", "/live/dup.jsonl", "dup", 9);+ let backup = seed(AgentId::Codex, "/backup", "/backup/dup.jsonl", "dup", 5);+ let backup_ref = backup.r.clone();+ let newer_ref = SessionFileRef { mtime_ms: 12, ..backup.r.clone() };+ let mut newer_backup = seed(AgentId::Codex, "/backup", "/backup/dup.jsonl", "dup", 12);+ newer_backup.r = newer_ref.clone();+ let adapters: Vec<Box<dyn AgentAdapter>> = vec![Box::new(live), Box::new(backup)];+ let rec = Recorder::new();+ run_scan(&adapters, &store, &rec, true).unwrap();+ assert_eq!(store.get_session("codex:dup").unwrap().unwrap().file_path, "/live/dup.jsonl");++ // 旧副本来了个文件事件:必须被裁决挡下+ wake_core::scanner::scan_files(&adapters, &store, &rec, vec![backup_ref]);+ assert_eq!(+ store.get_session("codex:dup").unwrap().unwrap().file_path,+ "/live/dup.jsonl",+ "败方副本的增量事件覆盖了胜者行"+ );++ // 备份真被更新(mtime 反超):按同款规则易主+ let adapters2: Vec<Box<dyn AgentAdapter>> = vec![Box::new(newer_backup)];+ wake_core::scanner::scan_files(&adapters2, &store, &rec, vec![newer_ref]);+ assert_eq!(+ store.get_session("codex:dup").unwrap().unwrap().file_path,+ "/backup/dup.jsonl",+ "mtime 反超的副本应按规则接管"+ );+}++/// 纯删除轮也要发变更通知:location 移除后的补扫常常解析队列为空,只有+/// 删除检测在干活——不通知,列表会一直挂着已删会话(2026-08-24 Codex review P1)+#[test]+fn pure_deletion_scan_notifies_sessions_changed() {+ let dir = tempfile::tempdir().unwrap();+ let store = temp_store(dir.path());+ let adapters: Vec<Box<dyn AgentAdapter>> =+ vec![Box::new(seed(AgentId::Codex, "/live", "/live/one.jsonl", "one", 5))];+ run_scan(&adapters, &store, &Recorder::new(), true).unwrap();+ assert!(store.get_session("codex:one").unwrap().is_some());++ // roster 里这家没了(location 被移除)→ 补扫是纯删除轮+ let rec = Recorder::new();+ let empty: Vec<Box<dyn AgentAdapter>> = Vec::new();+ run_scan(&empty, &store, &rec, false).unwrap();+ assert!(store.get_session("codex:one").unwrap().is_none(), "行应被出清");+ assert!(rec.changed() > 0, "纯删除轮未发 on_sessions_changed,UI 不会刷新");+}++/// 胜者副本损坏时按裁决顺位回退:会话不得从索引消失(2026-08-24 Codex review P2)+#[test]+fn corrupt_winner_falls_back_to_valid_copy() {+ let dir = tempfile::tempdir().unwrap();+ let store = temp_store(dir.path());+ let mut broken_live = seed(AgentId::Codex, "/live", "/live/dup.jsonl", "dup", 9);+ broken_live.fail_parse = true;+ let adapters: Vec<Box<dyn AgentAdapter>> = vec![+ Box::new(broken_live),+ Box::new(seed(AgentId::Codex, "/backup", "/backup/dup.jsonl", "dup", 5)),+ ];+ run_scan(&adapters, &store, &Recorder::new(), true).unwrap();+ let s = store+ .get_session("codex:dup")+ .unwrap()+ .expect("胜者损坏后会话不该消失");+ assert_eq!(s.file_path, "/backup/dup.jsonl", "应回退到有效副本");+}++/// 胜者文件被删后,幸存副本经 promote_survivors 上位,不必等下一次全量扫描+/// (2026-08-24 Codex review P2)+#[test]+fn survivor_copy_promoted_after_winner_deleted() {+ let dir = tempfile::tempdir().unwrap();+ let store = temp_store(dir.path());+ let adapters: Vec<Box<dyn AgentAdapter>> = vec![+ Box::new(seed(AgentId::Codex, "/live", "/live/dup.jsonl", "dup", 9)),+ Box::new(seed(AgentId::Codex, "/backup", "/backup/dup.jsonl", "dup", 5)),+ ];+ let rec = Recorder::new();+ run_scan(&adapters, &store, &rec, true).unwrap();+ assert_eq!(store.get_session("codex:dup").unwrap().unwrap().file_path, "/live/dup.jsonl");++ let key = store.remove_by_path("/live/dup.jsonl").unwrap().expect("应返回被删 key");+ assert!(store.get_session("codex:dup").unwrap().is_none());+ // 真实世界里被删文件不会再被枚举;SeedAdapter 是静态的,用"删除后"的+ // roster(只剩 backup 实例)喂给上位逻辑+ let after: Vec<Box<dyn AgentAdapter>> =+ vec![Box::new(seed(AgentId::Codex, "/backup", "/backup/dup.jsonl", "dup", 5))];+ wake_core::watcher::promote_survivors(&after, &store, &rec, &[key]);+ assert_eq!(+ store.get_session("codex:dup").unwrap().expect("幸存副本应上位").file_path,+ "/backup/dup.jsonl"+ );+}++/// location 易主(如把同一目录从 Pi 改成 Omp):文件 mtime/size 未变也要+/// 重新入库,旧 agent 行先删——否则旧行永留、新 key 撞 file_path UNIQUE,+/// 连全量刷新都救不回(2026-08-24 Codex review P1)+#[test]+fn owner_change_migrates_existing_rows() {+ let dir = tempfile::tempdir().unwrap();+ let store = temp_store(dir.path());+ let as_pi: Vec<Box<dyn AgentAdapter>> =+ vec![Box::new(seed(AgentId::Pi, "/d", "/d/s.jsonl", "s", 7))];+ run_scan(&as_pi, &store, &Recorder::new(), true).unwrap();+ assert!(store.get_session("pi:s").unwrap().is_some());++ // 同一文件、同 mtime/size,agent 换成 Omp;增量(full=false)也必须迁移+ let as_omp: Vec<Box<dyn AgentAdapter>> =+ vec![Box::new(seed(AgentId::Omp, "/d", "/d/s.jsonl", "s", 7))];+ run_scan(&as_omp, &store, &Recorder::new(), false).unwrap();+ assert!(store.get_session("pi:s").unwrap().is_none(), "旧 agent 行应被清理");+ assert!(store.get_session("omp:s").unwrap().is_some(), "新 agent 行应入库");+}++/// 墓碑双轨(不变量 3 的多副本延伸):删除只 trash 了胜者文件,另一 location+/// 的副本不得让会话复活——全量与 watcher 增量都要挡(2026-08-24 Codex review P1)+#[test]+fn tombstone_blocks_all_copies() {+ let dir = tempfile::tempdir().unwrap();+ let store = temp_store(dir.path());+ let backup_ref = SessionFileRef {+ agent: AgentId::Codex,+ native_id: "dup".into(),+ file_path: "/backup/dup.jsonl".into(),+ mtime_ms: 5,+ size: 1,+ };+ let adapters: Vec<Box<dyn AgentAdapter>> = vec![+ Box::new(seed(AgentId::Codex, "/live", "/live/dup.jsonl", "dup", 9)),+ Box::new(seed(AgentId::Codex, "/backup", "/backup/dup.jsonl", "dup", 5)),+ ];+ let rec = Recorder::new();+ run_scan(&adapters, &store, &rec, true).unwrap();+ assert!(store.get_session("codex:dup").unwrap().is_some());++ // UI 删除:trash 胜者文件 + 墓碑(key 一并入墓)+ store.remove_session("codex:dup", true).unwrap();+ run_scan(&adapters, &store, &rec, true).unwrap();+ assert!(+ store.get_session("codex:dup").unwrap().is_none(),+ "备份副本在全量扫描中复活了已删会话"+ );+ wake_core::scanner::scan_files(&adapters, &store, &rec, vec![backup_ref]);+ assert!(+ store.get_session("codex:dup").unwrap().is_none(),+ "备份副本在增量事件中复活了已删会话"+ );+}++/// 第三条写库路径(quick 的 write_meta_only)同样受 key 墓碑约束:codex 式+/// 改名 key 已入墓时,别的副本不得经 quick 快路径以空正文卡片复活已删会话+/// (2026-08-24 Codex review P1)+#[test]+fn quick_meta_respects_key_tombstone() {+ let dir = tempfile::tempdir().unwrap();+ let store = temp_store(dir.path());+ let mut a = seed(AgentId::Codex, "/live", "/live/dup.jsonl", "dup", 9);+ a.quick_key = Some("codex:thread-1".to_string());+ let adapters: Vec<Box<dyn AgentAdapter>> = vec![Box::new(a)];+ let rec = Recorder::new();+ run_scan(&adapters, &store, &rec, true).unwrap();+ assert!(store.get_session("codex:thread-1").unwrap().is_some(), "quick 改名 key 应入库");++ store.remove_session("codex:thread-1", true).unwrap();+ run_scan(&adapters, &store, &rec, true).unwrap();+ assert!(+ store.get_session("codex:thread-1").unwrap().is_none(),+ "quick 快路径复活了已删会话"+ );+ assert!(store.get_session("codex:dup").unwrap().is_none(), "native key 也不得复活");+}++/// key 后缀是内容 id 的家(gemini/pi/dsh):上位反查文件名对不上时,+/// 解析比对回退仍能找到幸存副本(2026-08-24 Codex review P2)+#[test]+fn survivor_promotion_matches_content_keys() {+ let dir = tempfile::tempdir().unwrap();+ let store = temp_store(dir.path());+ // meta.key 的后缀(LOGICAL)与文件名 native_id(session-123)不同+ let mut backup = seed(AgentId::Gemini, "/backup", "/backup/session-123.jsonl", "session-123", 5);+ backup.meta.key = "gemini:LOGICAL".to_string();+ backup.meta.id = "LOGICAL".to_string();+ let after: Vec<Box<dyn AgentAdapter>> = vec![Box::new(backup)];+ let rec = Recorder::new();+ wake_core::watcher::promote_survivors(&after, &store, &rec, &["gemini:LOGICAL".to_string()]);+ assert!(+ store.get_session("gemini:LOGICAL").unwrap().is_some(),+ "内容 key 的幸存副本未被上位"+ );+}diff --git a/crates/wake/assets/icons/plus.svg b/crates/wake/assets/icons/plus.svgnew file mode 100644index 0000000..a69f590--- /dev/null+++ b/crates/wake/assets/icons/plus.svg@@ -0,0 +1,16 @@+<!-- @license lucide-static v0.462.0 - ISC -->+<svg+ class="lucide lucide-plus"+ xmlns="http://www.w3.org/2000/svg"+ width="24"+ height="24"+ viewBox="0 0 24 24"+ fill="none"+ stroke="currentColor"+ stroke-width="2"+ stroke-linecap="round"+ stroke-linejoin="round"+>+ <path d="M5 12h14" />+ <path d="M12 5v14" />+</svg>diff --git a/crates/wake/src/assets.rs b/crates/wake/src/assets.rsindex 1a11e4b..ceb0e09 100644--- a/crates/wake/src/assets.rs+++ b/crates/wake/src/assets.rs@@ -83,6 +83,7 @@ icons!("file-text","more-horizontal","hard-drive",+ "plus",);impl AssetSource for Assets {diff --git a/crates/wake/src/format.rs b/crates/wake/src/format.rsindex 834bac7..cb93281 100644--- a/crates/wake/src/format.rs+++ b/crates/wake/src/format.rs@@ -46,22 +46,26 @@ pub fn fmt_tokens(n: Option<i64>) -> String {}}-/// 绝对路径 → `~/…` 形式,**不折叠中段**。数据源面板要如实给出完整路径-/// (display_file_path 那种 `~/a/…/file` 的折叠在那里会把信息吃掉)-pub fn tilde_path(p: &str) -> String {- // HOME 进程内不变,缓存住:display_file_path 经由本函数落在详情页- // header 上,那是每帧都跑的路径+/// 进程内不变的 HOME,缓存住:折叠(tilde_path 经 display_file_path 落在+/// 详情页 header,每帧都跑)与手输展开(expand_tilde)共用同一份+fn cached_home() -> Option<&'static str> {static HOME: std::sync::OnceLock<Option<String>> = std::sync::OnceLock::new();- let home = HOME.get_or_init(|| {+ HOME.get_or_init(|| {dirs::home_dir().map(|h| h.to_string_lossy().to_string()).filter(|h| !h.is_empty())- });+ })+ .as_deref()+}++/// 绝对路径 → `~/…` 形式,**不折叠中段**。数据源面板要如实给出完整路径+/// (display_file_path 那种 `~/a/…/file` 的折叠在那里会把信息吃掉)+pub fn tilde_path(p: &str) -> String {// 边界必须落在分隔符上:裸 starts_with 会把 HOME 的同名前缀兄弟目录// 也折叠掉(HOME=/Users/al 时 /Users/al-data → "~-data",一个并不存在// 的 HOME 相对路径)。自定义 CODEX_HOME / XDG_DATA_HOME 让这种根变得可能- match home {- Some(h) => match p.strip_prefix(h.as_str()) {+ match cached_home() {+ Some(h) => match p.strip_prefix(h) {Some(rest) if rest.is_empty() || rest.starts_with('/') => format!("~{rest}"),_ => p.to_string(),},@@ -69,6 +73,17 @@ pub fn tilde_path(p: &str) -> String {}}+/// 手输路径的 `~` 前缀展开(tilde_path 的逆;仅前缀,边界同样落在分隔符上)+pub fn expand_tilde(p: &str) -> String {+ match p.strip_prefix('~') {+ Some(rest) if rest.is_empty() || rest.starts_with('/') => match cached_home() {+ Some(h) => format!("{h}{rest}"),+ None => p.to_string(),+ },+ _ => p.to_string(),+ }+}+/// 会话文件路径的展示形态(详情页路径行):SQLite 虚拟路径剥 `#<id>`、/// HOME 缩成 `~`、深路径折叠中段(根目录 + … + 文件名)。/// 仅用于展示——Reveal in Finder 仍传原始完整路径。diff --git a/crates/wake/src/ui.rs b/crates/wake/src/ui.rsindex 13b8580..5661754 100644--- a/crates/wake/src/ui.rs+++ b/crates/wake/src/ui.rs@@ -81,6 +81,14 @@ pub const RADIUS_KBD: Pixels = px(5.);/// 小胶囊 badge(项目名 / model / source / 各处计数共用)pub const RADIUS_BADGE: Pixels = px(4.);+// ---------------- 组件度量派生 ----------------++/// gpui-component `Size::Small` 按钮的水平内边距(px_3 @ rem14 = 10.5)。+/// location 表单的"内容轴"对齐从它派生——组件升级或 rem 基准变更先核此值+pub const BUTTON_SM_PX: Pixels = px(10.5);+/// gpui-component `Size::Small` 按钮高度(h_6 = 24),手排胶囊钮取齐用+pub const BUTTON_SM_H: Pixels = px(24.);+// ---------------- 交互态文字 ----------------/// gpui 陷阱兜底:`.hover()`/`.active()` 闭包的 text 样式对 base 是**整体替换**diff --git a/crates/wake/src/workbench.rs b/crates/wake/src/workbench.rsindex 29b4a25..810c694 100644--- a/crates/wake/src/workbench.rs+++ b/crates/wake/src/workbench.rs@@ -37,7 +37,7 @@ use gpui_component::{StyledExt as _, TitleBar, WindowExt as _,};-use wake_core::adapters::{create_adapters, AgentAdapter};+use wake_core::adapters::{adapter_for, create_adapters_for, path_owns, AgentAdapter};use wake_core::db::Store;use wake_core::models::*;use wake_core::scanner::{run_scan, ScanEvents, ScanProgress};@@ -45,7 +45,9 @@ use wake_core::services::{exporter, terminal};use wake_core::watcher::{start_watcher, SessionWatcher};use crate::ui::*;-use crate::format::{abs_date, display_file_path, fmt_tokens, one_line, relative_time, tilde_path};+use crate::format::{+ abs_date, display_file_path, expand_tilde, fmt_tokens, one_line, relative_time, tilde_path,+};actions!(wake, [ToggleSearch, RefreshSessions, PaletteUp, PaletteDown]);@@ -54,6 +56,8 @@ pub const KEY_CONTEXT: &str = "Workbench";pub const PALETTE_CONTEXT: &str = "WakePalette";/// ⌘K 面板内容总高(输入行 + 结果列表 + footer);列表 flex_1 吃剩余空间const PALETTE_HEIGHT: Pixels = px(492.);+/// location 表单标签列宽(Agent/Folder 两行共用)+const FORM_LABEL_W: Pixels = px(52.);fn icon(path: &'static str) -> Icon {Icon::empty().path(path)@@ -121,7 +125,7 @@ impl ListDelegate for SessionsDelegate {.gap(SPACE_XS).child(h_flex()- .gap_1p5()+ .gap(px(6.)).child(div().flex_1()@@ -149,7 +153,7 @@ impl ListDelegate for SessionsDelegate {).child(h_flex()- .gap_1p5()+ .gap(px(6.)).text_size(FONT_LABEL).text_color(theme.muted_foreground).child(img(s.agent.brand_icon(theme.mode.is_dark())).size(px(15.)).flex_shrink_0())@@ -206,12 +210,12 @@ impl ListDelegate for SearchDelegate {ListItem::new(ix.row).rounded(theme.radius).child(v_flex().w_full()- .px_2()- .py_2p5()- .gap_1p5()+ .px(SPACE_SM)+ .py(SPACE_SM)+ .gap(px(6.)).child(h_flex()- .gap_2()+ .gap(SPACE_SM).text_size(FONT_CAPTION).child(img(h.session.agent.brand_icon(theme.mode.is_dark())).size(px(15.)).flex_shrink_0()).child(@@ -309,7 +313,7 @@ impl ListDelegate for SearchDelegate {.w_full().items_center().justify_center()- .gap_3()+ .gap(SPACE_MD).text_color(theme.muted_foreground).child(icon("icons/inbox.svg").with_size(px(24.))).child(@@ -336,8 +340,8 @@ impl ListDelegate for SearchDelegate {}Some(div()- .px_2()- .pb_1()+ .px(SPACE_SM)+ .pb(SPACE_XS).text_size(FONT_LABEL).text_color(cx.theme().muted_foreground).child("Short query — using fallback search. Longer keywords are faster."),@@ -386,6 +390,14 @@ pub struct Workbench {/// 用户主动重扫中(模态进度弹窗开着,阻断其他操作)。与 scan.scanning 正交:/// 那是"扫没扫",这是"要不要弹模态"refreshing: bool,+ /// location 变更撞上进行中的扫描时置位:那轮扫描持旧 roster,不补扫的话+ /// 新根不收录、被移根不出清,要等手动 ⌘R(2026-08-24 Codex review)。+ /// 终态事件到达后由 on_bg_event 消费,用新 roster 补一轮增量+ pending_rescan: bool,+ /// location 变更成功后置位:面板等**补扫终态**再重开——立即重开抓到的是+ /// 扫描前的计数快照,新根会一直显示 0(2026-08-24 Codex review)。补扫+ /// 是增量,通常亚秒;期间成功通知先行反馈。用户若已开了别的弹窗则放弃重开+ reopen_locations_after_scan: bool,/// 全量解析进度 (done, total);None = 仍在枚举文件。/// 用 Rc<Cell> 而非 entity 字段:进度弹窗 builder 在本 entity 的/// render 期间执行,entity.read(cx) 会 double-lease panic。@@ -422,6 +434,22 @@ struct DataSourceRow {tally: SharedString,/// 路径当前存在(行是否可点)exists: bool,+ /// Some(落库路径) = 自定义行(路径可能是本行根的上层目录);None = 预设行+ custom: Option<SharedString>,+}++/// location 表单的语义目标。预设行的"编辑/删除"落库为**压制默认 + 记自定义**:+/// 默认根随 env(CODEX_HOME 等)在构造时活解析,不能物化成一行路径+#[derive(Clone)]+enum FormTarget {+ Add,+ /// 编辑既有一行。custom=true:path 是落库的自定义路径(编辑单位);+ /// custom=false:path 是被点预设行的展示路径(无改动判定与 Finder 用)+ Edit {+ agent: AgentId,+ path: SharedString,+ custom: bool,+ },}impl Workbench {@@ -441,7 +469,7 @@ impl Workbench {}};let store = Arc::new(store);- let adapters: Arc<Vec<Box<dyn AgentAdapter>>> = Arc::new(create_adapters());+ let adapters = Self::build_roster(&store);let list_state = cx.new(|cx| {ListState::new(@@ -516,6 +544,8 @@ impl Workbench {..Default::default()},refreshing: false,+ pending_rescan: false,+ reopen_locations_after_scan: false,refresh_progress: Rc::new(Cell::new(None)),total_sessions: 0,list_state,@@ -638,7 +668,7 @@ impl Workbench {.gap(SPACE_LG).child(h_flex()- .gap_2()+ .gap(SPACE_SM).child(Spinner::new().small()).child(div()@@ -660,9 +690,10 @@ impl Workbench {}/// "Wake 读哪些路径"面板(侧栏底部数据源钮)。列全十三家含本机没装的,- /// 呼应"只读你的目录、零网络"的产品承诺。数据在打开前一次算好 move 进- /// 闭包——dialog builder 在宿主 render 期间执行,闭包内 read 宿主 entity- /// 必 double-lease panic+ /// 呼应"只读你的目录、零网络"的产品承诺;行点击即编辑,底部 Add location+ /// 打开增改删共用的表单。数据在打开前一次算好+ /// move 进闭包——dialog builder 在宿主 render 期间执行,闭包内 read 宿主+ /// entity 必 double-lease panicfn show_data_sources(&mut self, window: &mut Window, cx: &mut Context<Self>) {// 数据源**必须**读 self.adapters——与 scanner/watcher/refresh 同一份// 实例。根路径是构造时刻对 env(CODEX_HOME/XDG_DATA_HOME)与文件系统@@ -673,7 +704,7 @@ impl Workbench {// 独立 flat_map 再按位置 zip 计数,靠的是遍历顺序一致这条隐形契约。// 文本一律预先算成 SharedString:dialog builder 存的是 Rc<dyn Fn>,// 面板开着时每帧重跑,留 format!/String::clone 在里面就是每帧堆分配- let flat: Vec<(AgentId, PathBuf)> = self+ let mut flat: Vec<(AgentId, PathBuf)> = self.adapters.iter().flat_map(|a| {@@ -681,6 +712,10 @@ impl Workbench {a.data_roots().into_iter().map(move |r| (agent, r))}).collect();+ // 按 AgentId 声明序稳定排序:自定义根紧随该家默认根之后成组展示+ // (roster 里 customs 追加在尾部,不排会飘到列表底部与所属家分离);+ // 稳定排序保证同家内默认在前、codex 的 sessions/archived 相邻不散+ flat.sort_by_key(|(a, _)| *a);// 带上 agent:计数按 (agent, 根) 归属,不然一家的根被 env 搬进另一家// 树下时,会话会整批记到别家行上let prefixes: Vec<(String, String)> = flat@@ -691,6 +726,12 @@ impl Workbench {.store.counts_by_path_prefix(&prefixes).unwrap_or_else(|_| vec![0; prefixes.len()]);+ // 直接查库,不设镜像字段:面板打开是点击路径,微秒级查询无需缓存+ let (customs, removed) = self.store.location_overrides();+ let customs: Vec<(AgentId, SharedString)> = customs+ .into_iter()+ .map(|(a, p)| (a, SharedString::from(p.to_string_lossy().to_string())))+ .collect();let rows: Vec<DataSourceRow> = flat.iter().zip(prefixes)@@ -698,15 +739,23 @@ impl Workbench {.map(|(((agent, root), (_, raw)), n)| {// 存在性逐路径判断:某家的归档目录可能还没建,不该按整家一刀切let exists = root.exists();+ // 本行根落在同家某个自定义 location 之下 → 可移除行。+ // 携带**落库路径**而非本行根:codex 一个自定义家目录派生+ // sessions/archived 两行,删除按落库那条删+ let custom = custom_owner(&customs, *agent, &raw).cloned();DataSourceRow {agent: *agent,display: tilde_path(&raw).into(),raw: raw.into(),tally: if exists { n.to_string().into() } else { "Not found".into() },exists,+ custom,}}).collect();+ // 有任何偏离(自定义或被移除的预设)才给 Restore defaults 出场+ let diverged = !customs.is_empty() || !removed.is_empty();+ let entity = cx.entity();window.open_dialog(cx, move |dialog, _window, cx| {let theme = cx.theme();// 左右内边距从默认 24 收到 14,让出的 10px 由标题与各行自己的@@ -732,7 +781,27 @@ impl Workbench {.max_h(px(400.)).overflow_y_scroll().children(rows.iter().enumerate().map(|(ix, row)| {- let raw = row.raw.clone();+ // 点击行 = 编辑(2026-08-24 定稿)+ // 表单与 with_custom_root 的契约是**目录**;SQLite+ // 型预设行的 raw 是库文件,预填其父目录——照文件+ // 路径保存会拼出 <db>/<db> 的死路径(Codex review)+ let edit_path = row.custom.clone().unwrap_or_else(|| {+ let raw = row.raw.as_ref();+ if std::path::Path::new(raw).is_file() {+ std::path::Path::new(raw)+ .parent()+ .map(|p| SharedString::from(p.to_string_lossy().to_string()))+ .unwrap_or_else(|| row.raw.clone())+ } else {+ row.raw.clone()+ }+ });+ let edit_target = FormTarget::Edit {+ agent: row.agent,+ custom: row.custom.is_some(),+ path: edit_path,+ };+ let edit_entity = entity.clone();h_flex().id(("data-source-row", ix)).h(ROW_HEIGHT_SUB)@@ -743,12 +812,13 @@ impl Workbench {.rounded(theme.radius).gap(SPACE_SM).items_center()- .when(row.exists, |el| {- el.cursor_pointer()- .hover(|s| s.bg(theme.secondary_hover))- .on_click(move |_, _, _| {- terminal::open_in_finder(&raw)- })+ .cursor_pointer()+ .hover(|s| s.bg(theme.secondary_hover))+ .on_click(move |_, window, cx| {+ let t = edit_target.clone();+ edit_entity.update(cx, |this, cx| {+ this.open_location_form(t, window, cx)+ });}).child(img(row.agent.brand_icon(theme.mode.is_dark()))@@ -774,16 +844,14 @@ impl Workbench {.child(row.display.clone()),).child(+ // 尾列纯计数 badge:悬停工具试过、用户否决+ // (2026-08-24,Finder/移除挪进编辑表单)h_flex().w(px(88.)).flex_shrink_0().justify_end().text_size(FONT_LABEL).child({- // 有目录取中性灰(同项目名 badge);目录不在- // 取 warning 淡底 tint——这是"本机没这家"的- // 陈述而非报错,不用实心告警色。文字实色,- // 只有底叠 opacity// 有目录取中性灰(同项目名 badge);目录不在// 取 warning 淡底 tint——这是"本机没这家"的// 陈述而非报错,不用实心告警色。文字实色,@@ -797,11 +865,581 @@ impl Workbench {}),)})),+ )+ .child(div().h(px(1.)).bg(theme.border).mx(px(10.)))+ .child(+ h_flex()+ .items_center()+ .justify_between()+ .child(+ // 底部添加按钮:加号与行图标同列对齐(px10 内边+ // 同构),hover 胶囊只包按钮本体——整行 hover+ // 否决(2026-08-24);上方 hairline 与侧栏+ // footer 同语言,分开数据区与动作区+ h_flex()+ .id("add-location")+ .h(ROW_HEIGHT_SUB)+ .px(px(10.))+ .rounded(theme.radius)+ .gap(SPACE_SM)+ .items_center()+ .cursor_pointer()+ .text_color(theme.muted_foreground)+ .hover(|s| s.bg(theme.secondary_hover))+ .on_click({+ let entity = entity.clone();+ move |_, window, cx| {+ // 面板不关:dialog 是栈,表单压在其上,+ // esc/取消原生弹回面板+ entity.update(cx, |this, cx| {+ this.open_location_form(FormTarget::Add, window, cx)+ });+ }+ })+ .child(icon("icons/plus.svg").with_size(px(14.)).flex_shrink_0())+ .child(div().text_size(FONT_CAPTION).child("Add location")),+ )+ .when(diverged, |el| {+ el.child(+ // 恢复初始:清空全部偏离,回到内置默认路径+ h_flex()+ .id("restore-defaults")+ .h(ROW_HEIGHT_SUB)+ .px(px(10.))+ .rounded(theme.radius)+ .items_center()+ .cursor_pointer()+ .text_color(theme.muted_foreground)+ .hover(|s| s.bg(theme.secondary_hover))+ .on_click({+ let entity = entity.clone();+ move |_, window, cx| {+ window.close_dialog(cx);+ entity.update(cx, |this, cx| {+ this.restore_default_locations(window, cx)+ });+ }+ })+ .child(div().text_size(FONT_CAPTION).child("Restore defaults")),+ )+ }),),)});}+ /// store 的 location 配置 → roster。new 与 rebuild_roster 共用;解析与+ /// 组装都在 wake-core(create_adapters_for),与 scan CLI 同一条路+ fn build_roster(store: &Arc<Store>) -> Arc<Vec<Box<dyn AgentAdapter>>> {+ Arc::new(create_adapters_for(store))+ }++ /// location 配置变更后的唯一 roster 换代点:同一处换 Arc + 重启 watcher,+ /// 新旧两份实例不共存(不变量 8 的运行时补充:"单实例"指任一时刻只有一份+ /// 在服务,换代必须整体换、所有消费方跟随新 Arc)+ fn rebuild_roster(&mut self, cx: &mut Context<Self>) {+ // 先撤旧 watcher 并等它退出(SessionWatcher::Drop 内 join):旧线程持+ // 旧 roster,不等收尾,已移除根的会话可能在补扫后被写回复活+ self.watcher = None;+ self.adapters = Self::build_roster(&self.store);+ self.watcher = start_watcher(self.adapters.clone(), self.store.clone(), self.scan_events.clone());+ cx.notify();+ }++ /// location 表单(添加/编辑共用一套 UI,2026-08-24 定稿):agent 下拉 ++ /// 路径输入框(可手输,~ 展开)+ 目录选择按钮;Cancel/Save 只在有改动时+ /// 出现。压栈在面板之上,esc/取消原生弹回+ fn open_location_form(&mut self, target: FormTarget, window: &mut Window, cx: &mut Context<Self>) {+ let (title, ok_label, init_agent, init_path): (+ &'static str,+ &'static str,+ AgentId,+ SharedString,+ ) = match &target {+ FormTarget::Add => ("Add location", "Add", AgentId::ClaudeCode, "".into()),+ FormTarget::Edit { agent, path, .. } => ("Edit location", "Save", *agent, path.clone()),+ };+ let path_input = cx.new(|cx| InputState::new(window, cx).placeholder("/absolute/folder/path"));+ if !init_path.is_empty() {+ let v = init_path.clone();+ path_input.update(cx, |st, cx| st.set_value(v, window, cx));+ }+ // 编辑态动作行的 Finder 只挂真实存在的路径——目录或 SQLite 库文件都算+ // (open_in_finder 对文件走 reveal 选中;用 is_dir 会把三家库文件行的+ // Finder 恒隐藏,2026-08-24 Codex review)。fs 探测一次,不进每帧 builder+ let edit_exists = match &target {+ FormTarget::Add => None,+ FormTarget::Edit { path, .. } => Some(std::path::Path::new(path.as_ref()).exists()),+ };+ // 表单状态放 Rc<Cell>/entity 而非宿主字段:builder 每帧重跑,闭包内+ // read 宿主 entity 必 double-lease panic(与 refresh 进度弹窗同一约束)+ let selected: Rc<Cell<AgentId>> = Rc::new(Cell::new(init_agent));+ let dirty_init_agent = init_agent;+ let dirty_init_path = init_path;+ let entity = cx.entity();+ let title: SharedString = title.into();+ let ok_label: SharedString = ok_label.into();+ window.open_dialog(cx, move |dialog, _window, cx| {+ let theme = cx.theme();+ let dark = theme.mode.is_dark();+ // 内容轴缩进 = small 按钮的水平内边距:字段行/标题/footer 以它为轴,+ // 动作行的胶囊钮**不缩进**——可见内容(内边距之后)恰好落轴,hover+ // 胶囊完整留在内容盒内。负 margin 会溢出被裁(locations 面板同一教训)+ let field_inset = BUTTON_SM_PX;+ let sel = selected.get();+ // 脏状态:与初始 (agent, path) 有差且路径非空才亮出 Cancel/Save+ // ——没改动时无可保存,收手走 esc/关闭即可(2026-08-24 用户定稿)。+ // Rope 直接与 &str 比较 + chars 扫描:builder 每帧跑,禁 to_string+ let dirty = {+ let text = path_input.read(cx).text();+ (sel != dirty_init_agent || *text != dirty_init_path.as_ref())+ && text.chars().any(|c| !c.is_whitespace())+ };+ let sel_cell = selected.clone();+ let browse_entity = entity.clone();+ let browse_input = path_input.clone();+ let ok_entity = entity.clone();+ let ok_input = path_input.clone();+ let ok_sel = selected.clone();+ let ok_target = target.clone();+ let action_target = target.clone();+ let dialog = dialog+ .title(+ div()+ .pl(field_inset)+ .text_size(FONT_HEADING)+ .font_semibold()+ .child(title.clone()),+ )+ .w(px(500.))+ .button_props(+ gpui_component::dialog::DialogButtonProps::default().ok_text(ok_label.clone()),+ )+ .child(+ v_flex()+ .gap(SPACE_MD)+ .child(+ h_flex()+ .px(field_inset)+ .gap(SPACE_SM)+ .items_center()+ .child(+ div()+ .w(FORM_LABEL_W)+ .flex_shrink_0()+ .text_size(FONT_CAPTION)+ .text_color(theme.muted_foreground)+ .child("Agent"),+ )+ .child(+ // Button 走 ParentElement 自组内容:品牌图标是+ // PNG(img),进不了 .icon()(那只收单色 SVG),+ // 图标+名字+箭头必须同住按钮内(2026-08-24 反馈)+ Button::new("loc-agent")+ .outline()+ .rounded(RADIUS_BUTTON)+ .child(+ h_flex()+ .gap(SPACE_SM)+ .items_center()+ .child(+ img(sel.brand_icon(dark))+ .size(px(14.))+ .flex_shrink_0(),+ )+ .child(+ div()+ .text_size(FONT_CAPTION)+ .child(sel.display_name()),+ )+ .child(+ icon("icons/chevron-down.svg")+ .with_size(px(12.))+ .text_color(theme.muted_foreground),+ ),+ )+ .dropdown_menu(move |menu, _, _| {+ let mut menu = menu.min_w(px(200.));+ for a in AgentId::ALL {+ let cell = sel_cell.clone();+ // element 变体:菜单项带品牌 PNG+ //(纯文本项的 icon 只收单色 SVG)+ menu = menu.item(+ PopupMenuItem::element(move |_, _| {+ h_flex()+ .gap(SPACE_SM)+ .items_center()+ .child(+ img(a.brand_icon(dark))+ .size(px(14.))+ .flex_shrink_0(),+ )+ .child(a.display_name())+ })+ .checked(sel == a)+ .on_click(move |_, window, _| {+ cell.set(a);+ window.refresh();+ }),+ );+ }+ menu+ }),+ ),+ )+ .child(+ h_flex()+ .px(field_inset)+ .gap(SPACE_SM)+ .items_center()+ .child(+ div()+ .w(FORM_LABEL_W)+ .flex_shrink_0()+ .text_size(FONT_CAPTION)+ .text_color(theme.muted_foreground)+ .child("Folder"),+ )+ .child(div().flex_1().min_w_0().child(Input::new(&browse_input)))+ .child(+ Button::new("loc-browse")+ .outline()+ .rounded(RADIUS_BUTTON)+ .icon(icon("icons/folder.svg").with_size(px(13.)))+ .tooltip("Choose a folder")+ .on_click({+ let entity = browse_entity.clone();+ let input = browse_input.clone();+ move |_, window, cx| {+ let input = input.clone();+ entity.update(cx, |this, cx| {+ this.browse_for_location(input, window, cx)+ });+ }+ }),+ ),+ )+ .when_some(edit_exists, |el, exists| {+ let FormTarget::Edit { agent, path, custom } = action_target.clone()+ else {+ unreachable!("edit_exists 仅在 Edit 目标下为 Some")+ };+ let remove_entity = entity.clone();+ el.child(+ // 动作行遵循破坏性靠左惯例:Remove 靠左、Show in+ // Finder 靠右。两钮手排:内边距 = 轴缩进,Remove+ // 左侧再减 1.5 补 lucide 字形内白(24 视框留 3+ // 单位),字形左缘正落标签轴;右钮文字右缘正落+ // 浏览钮右缘。全正值内边距,胶囊完整在内容盒里+ h_flex()+ .pt(SPACE_XS)+ .items_center()+ .justify_between()+ .child(+ h_flex()+ .id("loc-remove")+ .h(BUTTON_SM_H)+ .pl(BUTTON_SM_PX - px(1.5))+ .pr(BUTTON_SM_PX)+ .rounded(RADIUS_BUTTON)+ .items_center()+ .gap(px(6.))+ .cursor_pointer()+ .text_size(FONT_BODY)+ .text_color(theme.danger)+ .hover(|s| s.bg(theme.danger.opacity(0.1)))+ .active(|s| s.bg(theme.danger.opacity(0.16)))+ .on_click({+ let remove_entity = remove_entity.clone();+ let stored = custom.then(|| path.clone());+ move |_, window, cx| {+ // 整栈收场(表单+过期面板);+ // delete 内会重开新快照面板+ window.close_all_dialogs(cx);+ let stored = stored.clone();+ remove_entity.update(cx, |this, cx| {+ this.delete_location(+ agent, stored, window, cx,+ )+ });+ }+ })+ .child(+ icon("icons/trash-2.svg")+ .with_size(px(13.))+ .flex_shrink_0(),+ )+ .child("Remove"),+ )+ .when(exists, |el| {+ el.child(+ h_flex()+ .id("loc-reveal")+ .h(BUTTON_SM_H)+ .px(BUTTON_SM_PX)+ .rounded(RADIUS_BUTTON)+ .items_center()+ .gap(px(6.))+ .cursor_pointer()+ .text_size(FONT_BODY)+ .text_color(theme.foreground)+ .hover(|s| s.bg(theme.secondary_hover))+ .active(|s| s.bg(theme.secondary_active))+ .on_click(move |_, _, _| {+ terminal::open_in_finder(&path)+ })+ .child(+ icon("icons/folder.svg")+ .with_size(px(13.))+ .flex_shrink_0()+ .text_color(theme.muted_foreground),+ )+ .child("Show in Finder"),+ )+ }),+ )+ }),+ )+ .on_ok(move |_, window, cx| {+ let path_text = ok_input.read(cx).text().to_string();+ let agent = ok_sel.get();+ ok_entity.update(cx, |this, cx| {+ this.commit_location_form(ok_target.clone(), agent, path_text, window, cx)+ })+ });+ if dirty {+ dialog.footer(move |ok, cancel, window, cx| {+ vec![h_flex()+ .w_full()+ .justify_end()+ .gap(SPACE_SM)+ .px(field_inset)+ .child(cancel(window, cx))+ .child(ok(window, cx))]+ })+ } else {+ dialog+ }+ });+ }++ /// 表单的目录选择按钮:系统选择器,选中即回填输入框(取消无事发生)+ fn browse_for_location(+ &mut self,+ input: Entity<InputState>,+ window: &mut Window,+ cx: &mut Context<Self>,+ ) {+ let rx = cx.prompt_for_paths(PathPromptOptions {+ files: false,+ directories: true,+ multiple: false,+ prompt: Some("Choose".into()),+ });+ cx.spawn_in(window, async move |this, cx| {+ let dir = match rx.await {+ Ok(Ok(Some(paths))) if !paths.is_empty() => paths.into_iter().next().unwrap(),+ _ => return,+ };+ let text = dir.to_string_lossy().to_string();+ this.update_in(cx, |_, window, cx| {+ input.update(cx, |st, cx| st.set_value(text, window, cx));+ })+ .ok();+ })+ .detach();+ }++ /// 表单落库。返回值交给 on_ok:false = 表单留着(校验没过,或已手工收场)。+ /// 纯路径管理:不校验目录内容(2026-08-24 用户定稿),只拒空/相对路径与+ /// 同家重叠;预设行的编辑落库为"压默认 + 记自定义"+ fn commit_location_form(+ &mut self,+ target: FormTarget,+ agent_new: AgentId,+ raw_text: String,+ window: &mut Window,+ cx: &mut Context<Self>,+ ) -> bool {+ let expanded = expand_tilde(raw_text.trim());+ let path = if expanded.len() > 1 {+ expanded.trim_end_matches('/').to_string()+ } else {+ expanded+ };+ if path.is_empty() || !path.starts_with('/') {+ window.push_notification(Notification::warning("Enter an absolute folder path"), cx);+ return false;+ }+ // 各家归一化(codex:直选 sessions 树/平铺 archived 上提到家层,侧档+ // 找回)。静态分派,不依赖该家实例是否还在 roster(默认被移除时也要+ // 生效);归一化后再做无改动/重叠判定,选中默认根数据子目录会正确判"已覆盖"+ let path = wake_core::adapters::normalize_custom_root(+ agent_new,+ std::path::PathBuf::from(&path),+ )+ .to_string_lossy()+ .to_string();+ // 没改就没事:直接让机制关表单,面板未过期。旧目标也要**同规归一化**+ // 再比——默认 Codex 的 sessions/archived 行原路径归一化后即 home,不归一+ // 化就比,单按 Enter 会被误判成编辑、静默把默认改成"压默认+记自定义"+ //(2026-08-24 Codex review)+ let unchanged = match &target {+ FormTarget::Add => false,+ FormTarget::Edit { agent, path: p, .. } => {+ *agent == agent_new+ && wake_core::adapters::normalize_custom_root(+ *agent,+ std::path::PathBuf::from(p.as_ref()),+ )+ .to_string_lossy()+ == path+ }+ };+ if unchanged {+ return true;+ }+ // 同家重叠检查,排除被编辑单元自身派生的根(自定义单元 = 其落库路径+ // 之下的根;预设单元 = 不属于任何该家自定义的根)。嵌进**别家**树里+ // 是合法场景(env 根的先例),同家嵌套才是重复读取+ let customs: Vec<(AgentId, SharedString)> = self+ .store+ .location_overrides()+ .0+ .into_iter()+ .map(|(a, p)| (a, SharedString::from(p.to_string_lossy().to_string())))+ .collect();+ let covered = self+ .adapters+ .iter()+ .filter(|a| a.agent() == agent_new)+ .flat_map(|a| a.data_roots())+ .any(|r| {+ let rs = r.to_string_lossy().to_string();+ let excluded = match &target {+ FormTarget::Add => false,+ FormTarget::Edit { agent, path: unit, custom: true } => {+ *agent == agent_new && path_owns(unit.as_ref(), &rs)+ }+ FormTarget::Edit { agent, custom: false, .. } => {+ *agent == agent_new && custom_owner(&customs, agent_new, &rs).is_none()+ }+ };+ !excluded && (path_owns(&path, &rs) || path_owns(&rs, &path))+ });+ if covered {+ window.push_notification(+ Notification::info("This folder is already in Wake's session locations"),+ cx,+ );+ return false;+ }+ let res = match &target {+ FormTarget::Add => self.store.add_custom_root(agent_new.as_str(), &path),+ // 全形态单事务(含换 agent 的编辑):半程失败不得把配置改成半生效+ //(Codex review P2)+ FormTarget::Edit { agent, path: old, custom } => self.store.replace_location(+ agent.as_str(),+ custom.then(|| old.as_ref()),+ agent_new.as_str(),+ &path,+ ),+ };+ if let Err(e) = res {+ window.push_notification(Notification::error(format!("Save failed: {e}")), cx);+ return false;+ }+ // 整栈收场(表单+过期的面板快照),统一收尾重开新面板。+ // 返回 false 阻止机制再 pop(那会关掉刚开的新面板)+ window.close_all_dialogs(cx);+ let note = match &target {+ FormTarget::Add => "Location added",+ FormTarget::Edit { .. } => "Location updated",+ };+ self.apply_location_change(Ok(()), "", Notification::success(note), window, cx);+ false+ }++ /// 删除一个 location(编辑表单内的 Remove):自定义 = 删记录;预设 =+ /// 压制该家默认实例(codex 的 sessions/archived 同属一实例,成对消失)。+ /// 磁盘文件不动,根下会话按"不在枚举范围"出清,收藏/置顶独立留存+ fn delete_location(+ &mut self,+ agent: AgentId,+ custom: Option<SharedString>,+ window: &mut Window,+ cx: &mut Context<Self>,+ ) {+ let res = match &custom {+ Some(stored) => self.store.remove_custom_root(agent.as_str(), stored),+ None => self.store.add_removed_default(agent.as_str()),+ };+ self.apply_location_change(+ res,+ "Remove failed",+ Notification::info("Location removed"),+ window,+ cx,+ );+ }++ /// Restore defaults:清空全部偏离(自定义 + 被移除的预设),回到内置默认+ fn restore_default_locations(&mut self, window: &mut Window, cx: &mut Context<Self>) {+ let res = self.store.clear_location_overrides();+ self.apply_location_change(+ res,+ "Restore failed",+ Notification::info("Locations restored to defaults"),+ window,+ cx,+ );+ }++ /// location 变更的统一收尾(删/恢复/表单提交成功共用):失败提示后立即回+ /// 面板;成功则 roster 换代 + 补增量 + 提示,面板等补扫终态再重开(此时+ /// 计数才是真值)——第四个变更入口出现时,收尾步骤只在这里长+ fn apply_location_change(+ &mut self,+ res: anyhow::Result<()>,+ err_prefix: &'static str,+ ok_note: Notification,+ window: &mut Window,+ cx: &mut Context<Self>,+ ) {+ match res {+ Err(e) => {+ window.push_notification(Notification::error(format!("{err_prefix}: {e}")), cx);+ self.show_data_sources(window, cx);+ }+ Ok(()) => {+ self.rebuild_roster(cx);+ self.reopen_locations_after_scan = true;+ self.kick_incremental_scan(cx);+ window.push_notification(ok_note, cx);+ }+ }+ }++ /// roster 换代后补一轮增量:新根收录、被移根出清。撞上进行中的扫描+ /// (变更后面板自动重开,连续操作两次就会撞)则排队,由终态事件补扫+ fn kick_incremental_scan(&mut self, cx: &mut Context<Self>) {+ if self.scan.scanning {+ self.pending_rescan = true;+ return;+ }+ self.scan = ScanProgress {+ scanning: true,+ ..Default::default()+ };+ cx.notify();+ spawn_scan(+ self.adapters.clone(),+ self.store.clone(),+ self.scan_events.clone(),+ false,+ );+ }+fn on_bg_event(&mut self, ev: BgEvent, window: &mut Window, cx: &mut Context<Self>) {match ev {BgEvent::Progress(p) => {@@ -820,6 +1458,20 @@ impl Workbench {window.push_notification(note, cx);}self.scan = p;+ // 扫描期间发生过 location 变更:那轮用的是旧 roster,+ // 终态一到立刻用当前 roster 补一轮增量+ if !self.scan.scanning && self.pending_rescan {+ self.pending_rescan = false;+ self.kick_incremental_scan(cx);+ }+ // location 变更的面板重开等到终态:此刻计数才是真值。+ // 用户若在空档里开了别的弹窗(⌘K 等),不去压它+ if !self.scan.scanning && self.reopen_locations_after_scan {+ self.reopen_locations_after_scan = false;+ if !window.has_active_dialog(cx) {+ self.show_data_sources(window, cx);+ }+ }cx.notify();}BgEvent::Changed => self.refresh(window, cx),@@ -909,7 +1561,7 @@ impl Workbench {// 定高 + 列表 flex_1:输入行/footer 尺寸变化时列表自适应,// 不用手工重算列表高度.h(PALETTE_HEIGHT)- .gap_3()+ .gap(SPACE_MD).child(div().flex_shrink_0()@@ -987,7 +1639,7 @@ impl Workbench {.child("Scope: all sessions").child(h_flex()- .gap_3()+ .gap(SPACE_MD).child("\u{2191}\u{2193} navigate").child("\u{21a9} open").child("esc close"),@@ -1133,7 +1785,9 @@ impl Workbench {let adapters = self.adapters.clone();let task = cx.background_spawn(async move {- let adapter = adapters.iter().find(|a| a.agent() == meta.agent)?;+ // adapter_for 按文件路径挑实例:自定义 location 的会话必须由+ // 拥有其根的实例解析(gemini/kimi 的 cwd 反查是实例相对侧档)+ let adapter = adapter_for(&adapters, meta.agent, &meta.file_path)?;let r = SessionFileRef::from_meta(&meta);let t = adapter.parse_transcript(&r).ok()?;let visible: Vec<TranscriptMessage> = t@@ -1287,7 +1941,7 @@ impl Workbench {let meta = detail.meta.clone();let adapters = self.adapters.clone();let task = cx.background_spawn(async move {- let adapter = adapters.iter().find(|a| a.agent() == meta.agent)?;+ let adapter = adapter_for(&adapters, meta.agent, &meta.file_path)?;// from_meta 对虚拟路径(SQLite 型)自动回退,导出不再依赖真实文件存在let r = SessionFileRef::from_meta(&meta);let t = adapter.parse_transcript(&r).ok()?;@@ -1350,10 +2004,7 @@ impl Workbench {let Some(detail) = &self.detail else { return };let meta = detail.meta.clone();// 会话归属哪些磁盘路径(主文件/边车目录)是 adapter 的布局知识- let targets = self- .adapters- .iter()- .find(|a| a.agent() == meta.agent)+ let targets = adapter_for(&self.adapters, meta.agent, &meta.file_path).map(|a| a.session_paths(&meta)).unwrap_or_else(|| vec![meta.file_path.clone()]);let entity = cx.entity();@@ -1363,17 +2014,31 @@ impl Workbench {let entity = entity.clone();let theme = cx.theme();dialog- .title(div().font_semibold().child("Delete this session?"))+ .title(+ div()+ .text_size(FONT_HEADING)+ .font_semibold()+ .child("Delete this session?"),+ ).w(px(440.))+ // 破坏性确认:主按钮点名动作并用 danger 形态,不留裸 "OK"。+ // .confirm() 必须显式调用——Dialog 只在设了 footer 时才渲染+ // 按钮行,只挂 on_ok 的弹窗实际无按钮(仅回车可确认)+ .confirm()+ .button_props(+ gpui_component::dialog::DialogButtonProps::default()+ .ok_text("Move to Trash")+ .ok_variant(gpui_component::button::ButtonVariant::Danger),+ ).child(v_flex()- .gap_2()+ .gap(SPACE_SM).text_size(FONT_BODY).child("The session file will be moved to Trash. You can restore it anytime:").child(div()- .px_2()- .py_1()+ .px(SPACE_SM)+ .py(SPACE_XS).rounded(theme.radius).bg(theme.muted).text_size(FONT_CAPTION)@@ -1482,9 +2147,9 @@ impl Workbench {),).child(- div().flex_shrink_0().px(SIDEBAR_EDGE).pb_3().child(+ div().flex_shrink_0().px(SIDEBAR_EDGE).pb(SPACE_MD).child(h_flex()- .gap_2()+ .gap(SPACE_SM).child(h_flex().id("sidebar-search")@@ -1532,8 +2197,8 @@ impl Workbench {v_flex().flex_shrink_0().px(SIDEBAR_EDGE)- .pb_1()- .gap_1()+ .pb(SPACE_XS)+ .gap(SPACE_XS).child(sidebar_row("all",RowLead::Icon(icon("icons/layers.svg")),@@ -1571,9 +2236,9 @@ impl Workbench {.min_h_0().overflow_y_scroll().px(SIDEBAR_EDGE)- .pt_1()- .pb_4()- .gap_1()+ .pt(SPACE_XS)+ .pb(SPACE_LG)+ .gap(SPACE_XS).child(group_header("agents-header","Agents",@@ -1664,7 +2329,7 @@ impl Workbench {.py(SPACE_SM).items_center().justify_end()- .gap_1()+ .gap(SPACE_XS).child(sidebar_tool_btn("data-sources","Session locations",@@ -2036,7 +2701,7 @@ impl Workbench {.gap(SPACE_SM).child(h_flex()- .gap_2()+ .gap(SPACE_SM).text_size(FONT_LABEL).text_color(theme.muted_foreground).child(img(meta.agent.brand_icon(theme.mode.is_dark())).size(px(15.)).flex_shrink_0())@@ -2046,7 +2711,7 @@ impl Workbench {this.child(h_flex().min_w_0()- .gap_1()+ .gap(SPACE_XS).child(icon("icons/git-branch.svg").with_size(px(11.)).flex_shrink_0()).child(div().min_w_0().truncate().child(branch)),)@@ -2055,7 +2720,7 @@ impl Workbench {.child(h_flex().justify_between()- .gap_5()+ .gap(SPACE_LG).child(div().flex_1()@@ -2068,7 +2733,7 @@ impl Workbench {.child(h_flex().flex_shrink_0()- .gap_1()+ .gap(SPACE_XS).child({// Open In split 按钮(Codex/kooky 风):左段 = 上次// 目标的应用图标,点击直开;右段 chevron 展开列表。@@ -2165,7 +2830,7 @@ impl Workbench {menu = menu.item(PopupMenuItem::element(move |_, _| {h_flex()- .gap_2()+ .gap(SPACE_SM).items_center().child(match &icon_path {Some(p) => img(p.clone())@@ -2223,8 +2888,13 @@ impl Workbench {),).child(+ // 元信息四行收成 4px 紧组:与标题区之间保持 SPACE_SM,+ // "组内紧、组间松"——四行等距摊开读起来像四个并列区块+ v_flex()+ .gap(SPACE_XS)+ .child(h_flex()- .gap_1p5()+ .gap(px(6.)).text_size(FONT_LABEL).text_color(theme.muted_foreground).child(icon("icons/folder.svg").with_size(px(12.)).flex_shrink_0())@@ -2246,7 +2916,7 @@ impl Workbench {stats.push(format!("{} tokens", fmt_tokens(Some(tokens))));}h_flex()- .gap_2()+ .gap(SPACE_SM).text_size(FONT_LABEL).text_color(theme.muted_foreground).when_some(meta.model.clone(), |this, model| {@@ -2268,7 +2938,7 @@ impl Workbench {this.child(outline_badge(source, color))},)- .child(div().min_w_0().truncate().child(stats.join(" · ")))+ .child(div().min_w_0().truncate().child(stats.join(" · ")))}).child({// 时间行:创建 / 最后活动,精确时间@@ -2283,7 +2953,7 @@ impl Workbench {.text_size(FONT_LABEL).text_color(theme.muted_foreground).truncate()- .child(times.join(" · "))+ .child(times.join(" · "))}).child({// 会话文件路径(header 末行):展示用折叠形态(~ 缩写 +@@ -2291,7 +2961,7 @@ impl Workbench {let file_path = meta.file_path.clone();h_flex().id("detail-file-path")- .gap_1p5()+ .gap(px(6.)).text_size(FONT_LABEL).text_color(theme.muted_foreground).cursor_pointer()@@ -2301,14 +2971,15 @@ impl Workbench {}).child(icon("icons/file-text.svg").with_size(px(12.)).flex_shrink_0()).child(div().min_w_0().truncate().child(display_file_path(&meta.file_path)))- }),+ })+ ),).child(if detail.loading {h_flex().flex_1().items_center().justify_center()- .gap_2()+ .gap(SPACE_SM).text_color(theme.muted_foreground).child(Spinner::new().small()).child(div().text_size(FONT_BODY).child("Loading session…"))@@ -2576,6 +3247,19 @@ fn tool_cluster(/// 小胶囊 badge(项目名/model/source 共用):4px 圆角,内部截断。/// 项目名用 muted 灰;model/source 用主题色 tint(淡底+同色文字)。+/// 该数据根是否派生自某条自定义 location(with_custom_root 契约保证派生根+/// 全在其落库目录之下);返回落库路径。面板行标记与表单重叠排除共用同一判据+fn custom_owner<'a>(+ customs: &'a [(AgentId, SharedString)],+ agent: AgentId,+ root: &str,+) -> Option<&'a SharedString> {+ customs+ .iter()+ .find(|(a, p)| *a == agent && path_owns(p.as_ref(), root))+ .map(|(_, p)| p)+}+fn badge(name: impl Into<SharedString>, bg: Hsla, fg: Hsla) -> impl IntoElement {div().min_w_0()diff --git a/scripts/test.sh b/scripts/test.shindex bbd72c7..b6c7ca4 100755--- a/scripts/test.sh+++ b/scripts/test.sh@@ -1,7 +1,7 @@#!/bin/zsh# Wake 本地测试入口——改完代码跑一跑(对齐 kooky 的 `swift test` 习惯)。#-# scripts/test.sh # 数据层 27 测试 + UI 编译门槛,~秒级+# scripts/test.sh # 数据层 48 测试 + UI 编译门槛,~秒级# scripts/test.sh --smoke # 追加真实数据冒烟:全量扫描统计(人眼对量级,# # 基准见 CLAUDE.md;只读你本机的 agent 数据)set -euo pipefail