Skip to content

armgit / Wake

Public Imported from GitHub
0

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.md
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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> {
messages
diff --git a/crates/wake-core/src/adapters/opencode.rs b/crates/wake-core/src/adapters/opencode.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.svg
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 panic
fn 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.sh
index 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