All your AI agent sessions in one place — browse, search, resume. Rust + GPUI.
Rust
feat: nest Grok subagent sessions
Corey Chiu73d3e025de84
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 55b65c7..f8c2f43 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -2,6 +2,9 @@## Unreleased+- New: Grok Build `execute-plan` and subagent sessions now nest under their root parent, with expandable child counts, root-level sidebar totals, source-project recovery for worktrees, flat Starred/search results, and cascading Trash deletion+- Credits: Grok subagent nesting was inspired by [PR #3](https://github.com/iAmCorey/Wake/pull/3). Thanks to [@syanbo](https://github.com/syanbo) for mapping Grok's parent metadata and worktree behavior; the final implementation was independently rebuilt on the current codebase+## [0.3.2] — 2026-09-01- Fix: in a Codex branch or subagent thread, the parent conversation's transcript is injected as a `user` message — its assistant replies were being shown as if you had typed them, and were indexed for search. They are now treated as injected context, like the other `<environment_context>`-style blocksdiff --git a/Cargo.lock b/Cargo.lockindex 87fee95..756b796 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -7752,6 +7752,7 @@ dependencies = ["semver","serde","serde_json",+ "tempfile","unicode-segmentation","unicode-width","wake-core",diff --git a/README.md b/README.mdindex fce8b7f..bf9dbe2 100644--- a/README.md+++ b/README.md@@ -15,7 +15,7 @@ Your agent history is scattered across `~/.claude`, `~/.codex`, and a dozen othe## Features-- **Unified browsing** — all sessions grouped by agent / project, live file watching for incremental updates+- **Unified browsing** — all sessions grouped by agent / project, with Grok Build subagents nested under their parent and live file watching for incremental updates- **Full-text search** (⌘K / Ctrl+K) — SQLite FTS5 trigram index; handles CJK text and code substrings (like `useEffect(`) equally well; jumps straight to the matched message in the transcript- **Transcript view** — per-message rendering with user/assistant bubbles, collapsible tool-call clusters, thinking summaries, tree-sitter code highlighting (30+ languages)- **One-click resume** — reopens the session in your terminal (Terminal/iTerm on macOS; native terminal hosts on Linux and Windows) at the original project directory (`claude --resume`, `codex resume`, …)diff --git a/crates/wake-core/src/adapters/grok.rs b/crates/wake-core/src/adapters/grok.rsindex fefd6b2..80ae1e2 100644--- a/crates/wake-core/src/adapters/grok.rs+++ b/crates/wake-core/src/adapters/grok.rs@@ -1,3 +1,4 @@+use super::grok_group::{self, GroupCtx};use super::parse_utils::*;use super::{units_from_messages, AgentAdapter};use crate::models::*;@@ -7,6 +8,7 @@ use std::collections::HashMap;use std::fs;use std::io::{BufRead, BufReader};use std::path::{Path, PathBuf};+use std::sync::{Arc, Mutex};/// Grok Build(xAI 的 coding CLI):`~/.grok/sessions/<url编码cwd>/<uuid>/` 一目录/// 一会话。主文件 `updates.jsonl` 是 ACP 风格完整流水({timestamp(unix秒),@@ -16,17 +18,45 @@ use std::path::{Path, PathBuf};/// Grok 自己的索引,`prompt_history.jsonl` 在 cwd 目录级——都不是会话文件。pub struct GrokAdapter {root: PathBuf,+ grok_home: PathBuf,+ group: Mutex<Option<Arc<GroupCtx>>>,}impl GrokAdapter {pub fn new() -> Self {+ let grok_home = super::home_dir().unwrap_or_default().join(".grok");Self {- root: super::home_dir()- .unwrap_or_default()- .join(".grok")- .join("sessions"),+ root: grok_home.join("sessions"),+ grok_home,+ group: Mutex::new(None),}}++ fn from_custom_dir(dir: PathBuf) -> Self {+ let (root, grok_home) = if dir.join("sessions").is_dir() {+ (dir.join("sessions"), dir)+ } else if dir.file_name().is_some_and(|name| name == "sessions") {+ let home = dir.parent().unwrap_or(&dir).to_path_buf();+ (dir, home)+ } else {+ // 保留旧行为:自定义目录也可以直接就是 sessions root。+ // 此时没有结构证据允许越过用户选择的边界去父目录读 sidecar。+ (dir.clone(), dir)+ };+ Self {+ root,+ grok_home,+ group: Mutex::new(None),+ }+ }++ fn group_ctx(&self) -> Arc<GroupCtx> {+ let mut group = self.group.lock().unwrap();+ if group.is_none() {+ *group = Some(grok_group::load_group_ctx(&self.root, &self.grok_home));+ }+ Arc::clone(group.as_ref().unwrap())+ }}/// summary.json 边车@@ -37,6 +67,7 @@ struct Summary {updated_ms: i64,git_branch: Option<String>,model: Option<String>,+ git_remotes: Vec<String>,}fn read_summary(updates_path: &Path) -> Summary {@@ -47,6 +78,7 @@ fn read_summary(updates_path: &Path) -> Summary {updated_ms: 0,git_branch: None,model: None,+ git_remotes: Vec::new(),};let path = updates_path.with_file_name("summary.json");if let Ok(raw) = fs::read_to_string(&path) {@@ -83,6 +115,14 @@ fn read_summary(updates_path: &Path) -> Summary {.and_then(|x| x.as_str()).filter(|m| !m.is_empty()).map(String::from);+ if let Some(remotes) = v.get("git_remotes").and_then(Value::as_array) {+ s.git_remotes = remotes+ .iter()+ .filter_map(Value::as_str)+ .filter(|remote| !remote.is_empty())+ .map(String::from)+ .collect();+ }}}s@@ -273,7 +313,13 @@ fn parse_grok_updates(path: &Path) -> Result<(Vec<TranscriptMessage>, u32)> {Ok((messages, unknown))}-fn build_meta(r: &SessionFileRef, side: &Summary, messages: &[TranscriptMessage]) -> SessionMeta {+fn build_meta(+ r: &SessionFileRef,+ side: &Summary,+ messages: &[TranscriptMessage],+ grok_home: &Path,+ group: &GroupCtx,+) -> SessionMeta {let title = Some(clean_title_candidate(&side.title)).filter(|t| !t.is_empty()).or_else(|| title_from_messages(messages))@@ -283,13 +329,15 @@ fn build_meta(r: &SessionFileRef, side: &Summary, messages: &[TranscriptMessage].filter_map(|m| m.timestamp).max().unwrap_or(0);+ let (project_path, project_name) =+ grok_group::canonical_project(&side.cwd, &side.git_remotes, grok_home, &r.native_id, group);SessionMeta {key: format!("grok:{}", r.native_id),id: r.native_id.clone(),agent: AgentId::Grok,title,- project_path: side.cwd.clone(),- project_name: project_name_of(&side.cwd),+ project_path,+ project_name,file_path: r.file_path.clone(),created_at: if side.created_ms > 0 {side.created_ms@@ -320,6 +368,26 @@ impl AgentAdapter for GrokAdapter {AgentId::Grok}+ fn begin_scan(&self) {+ *self.group.lock().unwrap() = Some(grok_group::load_group_ctx(&self.root, &self.grok_home));+ }++ fn manages_parent_links(&self) -> bool {+ true+ }++ fn parent_links(&self) -> Vec<(String, String)> {+ grok_group::parent_links(&self.group_ctx())+ }++ fn is_parent_link_event(&self, path: &Path) -> bool {+ path.strip_prefix(&self.root).ok().is_some_and(|relative| {+ relative+ .components()+ .any(|component| component.as_os_str() == "subagents")+ })+ }+fn list_session_files(&self) -> Result<Vec<SessionFileRef>> {let mut refs = Vec::new();let Ok(cwds) = fs::read_dir(&self.root) else {@@ -362,7 +430,7 @@ impl AgentAdapter for GrokAdapter {fn parse_session(&self, r: &SessionFileRef) -> Result<ParsedSession> {let (messages, unknown) = parse_grok_updates(Path::new(&r.file_path))?;let side = read_summary(Path::new(&r.file_path));- let meta = build_meta(r, &side, &messages);+ let meta = build_meta(r, &side, &messages, &self.grok_home, &self.group_ctx());let units = units_from_messages(&messages);Ok(ParsedSession {meta,@@ -375,7 +443,7 @@ impl AgentAdapter for GrokAdapter {let (messages, unknown) = parse_grok_updates(Path::new(&r.file_path))?;let side = read_summary(Path::new(&r.file_path));Ok(ParsedTranscript {- meta: build_meta(r, &side, &messages),+ meta: build_meta(r, &side, &messages, &self.grok_home, &self.group_ctx()),mainline: messages,sidechains: Vec::new(),unknown_line_count: unknown,@@ -383,12 +451,7 @@ 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 })+ Box::new(Self::from_custom_dir(dir))}fn data_roots(&self) -> Vec<PathBuf> {diff --git a/crates/wake-core/src/adapters/grok_group.rs b/crates/wake-core/src/adapters/grok_group.rsnew file mode 100644index 0000000..bf99b0a--- /dev/null+++ b/crates/wake-core/src/adapters/grok_group.rs@@ -0,0 +1,475 @@+//! Grok 会话归组:主会话登记的 subagent 关系优先,无父会话时再用+//! worktree registry、git remote 与临时 worktree 名称恢复真实项目。++use super::parse_utils::project_name_of;+use super::sqlite_ro::open_sqlite_ro;+use serde_json::Value;+use std::collections::{HashMap, HashSet};+use std::fs;+use std::path::Path;+use std::sync::Arc;++/// 一轮扫描内共享的归组快照,避免每解析一个 updates.jsonl 都重扫目录/SQLite。+#[derive(Clone, Debug, Default)]+pub struct GroupCtx {+ worktrees: Vec<WorktreeRow>,+ parents: HashMap<String, ParentRef>,+}++#[derive(Clone, Debug)]+struct WorktreeRow {+ path: String,+ source_repo: String,+ repo_name: String,+}++/// Grok 主会话目录登记的子代理:child id → 直接父 id 与父会话 cwd。+#[derive(Clone, Debug)]+struct ParentRef {+ parent_id: String,+ parent_cwd: String,+}++pub fn load_group_ctx(sessions_root: &Path, grok_home: &Path) -> Arc<GroupCtx> {+ Arc::new(GroupCtx {+ worktrees: load_worktree_rows(grok_home),+ parents: load_subagent_parents(sessions_root),+ })+}++/// 输出当前数据根能确认的直接关系;scanner 合并全部 Grok location 后再+/// 扁平到 root,否则局部快照提前压平会丢失跨 location 的后半段父链。+pub fn parent_links(ctx: &GroupCtx) -> Vec<(String, String)> {+ ctx.parents+ .iter()+ .filter_map(|(child_id, parent)| {+ if parent.parent_id.is_empty() || parent.parent_id == *child_id {+ None+ } else {+ Some((+ format!("grok:{child_id}"),+ format!("grok:{}", parent.parent_id),+ ))+ }+ })+ .collect()+}++pub fn canonical_project(+ cwd: &str,+ remotes: &[String],+ grok_home: &Path,+ child_id: &str,+ ctx: &GroupCtx,+) -> (String, String) {+ if let Some(parent) = root_parent(child_id, &ctx.parents) {+ return (+ parent.parent_cwd.clone(),+ project_name_of(&parent.parent_cwd),+ );+ }+ if cwd.is_empty() {+ return (String::new(), project_name_of(cwd));+ }++ let slug = grok_worktree_slug(cwd, grok_home);+ if let Some(pair) = lookup_source(cwd, slug.as_deref(), &ctx.worktrees) {+ return pair;+ }+ if let Some(slug) = slug {+ let path = grok_home+ .join("worktrees")+ .join(&slug)+ .to_string_lossy()+ .into_owned();+ let name = remotes+ .iter()+ .find_map(|remote| repo_name_from_remote(remote))+ .unwrap_or_else(|| slug.strip_prefix("github-").unwrap_or(&slug).to_string());+ return (path, name);+ }++ if is_ephemeral_worktree(cwd) {+ if let Some(remote) = remotes.iter().find(|remote| !remote.is_empty()) {+ if let Some(local) = local_checkout_from_remote(remote) {+ return (local.clone(), project_name_of(&local));+ }+ if let Some(name) = repo_name_from_remote(remote) {+ return (format!("git-remote:{name}"), name);+ }+ }+ if let Some(path) = ephemeral_plan_path(cwd) {+ return (path.clone(), project_name_of(&path));+ }+ }++ (cwd.to_string(), project_name_of(cwd))+}++fn normalize_path(path: &str) -> String {+ let path = path.trim_end_matches('/');+ if let Some(rest) = path.strip_prefix("/private/") {+ if rest.starts_with("var/") {+ return format!("/{rest}");+ }+ }+ path.to_string()+}++fn load_worktree_rows(grok_home: &Path) -> Vec<WorktreeRow> {+ let Some(ro) = open_sqlite_ro(&grok_home.join("worktrees.db"), "grok-worktrees") else {+ return Vec::new();+ };+ let mut stmt = match ro.conn.prepare(+ "SELECT path, source_repo, repo_name FROM worktrees \+ WHERE path != '' AND source_repo != ''",+ ) {+ Ok(stmt) => stmt,+ Err(_) => return Vec::new(),+ };+ let Ok(rows) = stmt.query_map([], |row| {+ Ok(WorktreeRow {+ path: row.get(0)?,+ source_repo: row.get(1)?,+ repo_name: row.get::<_, String>(2).unwrap_or_default(),+ })+ }) else {+ return Vec::new();+ };+ rows.flatten().collect()+}++fn hex_digit(c: u8) -> Option<u8> {+ Some(match c {+ b'0'..=b'9' => c - b'0',+ b'a'..=b'f' => c - b'a' + 10,+ b'A'..=b'F' => c - b'A' + 10,+ _ => return None,+ })+}++fn percent_decode(input: &str) -> String {+ let bytes = input.as_bytes();+ let mut out = Vec::with_capacity(bytes.len());+ let mut ix = 0;+ while ix < bytes.len() {+ if bytes[ix] == b'%' && ix + 2 < bytes.len() {+ if let (Some(high), Some(low)) = (hex_digit(bytes[ix + 1]), hex_digit(bytes[ix + 2])) {+ out.push((high << 4) | low);+ ix += 3;+ continue;+ }+ }+ out.push(bytes[ix]);+ ix += 1;+ }+ String::from_utf8_lossy(&out).into_owned()+}++fn group_cwd(cwd_dir: &Path) -> String {+ if let Ok(raw) = fs::read_to_string(cwd_dir.join(".cwd")) {+ let cwd = raw.trim();+ if !cwd.is_empty() {+ return cwd.to_string();+ }+ }+ percent_decode(&cwd_dir.file_name().unwrap_or_default().to_string_lossy())+}++fn load_subagent_parents(sessions_root: &Path) -> HashMap<String, ParentRef> {+ let mut parents = HashMap::new();+ let Ok(groups) = fs::read_dir(sessions_root) else {+ return parents;+ };+ for group in groups.flatten() {+ let group_path = group.path();+ if !group_path.is_dir() {+ continue;+ }+ let parent_cwd = group_cwd(&group_path);+ if parent_cwd.is_empty() {+ continue;+ }+ let Ok(sessions) = fs::read_dir(&group_path) else {+ continue;+ };+ for session in sessions.flatten() {+ let session_path = session.path();+ let subagents = session_path.join("subagents");+ if !subagents.is_dir() {+ continue;+ }+ let folder_id = session_path+ .file_name()+ .unwrap_or_default()+ .to_string_lossy()+ .into_owned();+ let Ok(children) = fs::read_dir(subagents) else {+ continue;+ };+ for child in children.flatten() {+ let Ok(raw) = fs::read_to_string(child.path().join("meta.json")) else {+ continue;+ };+ let Ok(value) = serde_json::from_str::<Value>(&raw) else {+ continue;+ };+ let parent_id = value+ .get("parent_session_id")+ .and_then(Value::as_str)+ .filter(|id| !id.is_empty())+ .unwrap_or(&folder_id)+ .to_string();+ let parent = ParentRef {+ parent_id,+ parent_cwd: parent_cwd.clone(),+ };+ for field in ["child_session_id", "subagent_id"] {+ if let Some(id) = value+ .get(field)+ .and_then(Value::as_str)+ .filter(|id| !id.is_empty())+ {+ parents+ .entry(id.to_string())+ .or_insert_with(|| parent.clone());+ }+ }+ }+ }+ }+ parents+}++fn root_parent(child_id: &str, parents: &HashMap<String, ParentRef>) -> Option<ParentRef> {+ if child_id.is_empty() {+ return None;+ }+ let mut current = child_id.to_string();+ let mut seen = HashSet::new();+ let mut last = None;+ while seen.insert(current.clone()) {+ let Some(parent) = parents.get(¤t) else {+ break;+ };+ last = Some(parent.clone());+ if parents.contains_key(&parent.parent_id) {+ current = parent.parent_id.clone();+ } else {+ break;+ }+ }+ last.filter(|parent| !parent.parent_id.is_empty() && !parent.parent_cwd.is_empty())+}++fn grok_worktree_slug(cwd: &str, grok_home: &Path) -> Option<String> {+ let relative = Path::new(cwd)+ .strip_prefix(grok_home.join("worktrees"))+ .ok()?;+ let slug = relative.components().next()?.as_os_str().to_str()?;+ (!slug.is_empty()).then(|| slug.to_string())+}++fn is_ephemeral_worktree(cwd: &str) -> bool {+ let name = Path::new(cwd)+ .file_name()+ .and_then(|name| name.to_str())+ .unwrap_or_default();+ name.starts_with("wt-")+ && (cwd.contains("/T/grok-") || cwd.contains("/var/folders/") || cwd.contains("/tmp/"))+}++fn local_checkout_from_remote(remote: &str) -> Option<String> {+ if !remote.starts_with('/') {+ return None;+ }+ for suffix in [".origin.git", ".git"] {+ if let Some(stem) = remote.strip_suffix(suffix) {+ if !stem.is_empty() {+ return Some(stem.to_string());+ }+ }+ }+ Some(remote.trim_end_matches('/').to_string())+}++fn repo_name_from_remote(remote: &str) -> Option<String> {+ if let Some(local) = local_checkout_from_remote(remote) {+ return Path::new(&local)+ .file_name()+ .map(|name| name.to_string_lossy().into_owned());+ }+ let remote = remote.trim().trim_end_matches('/').trim_end_matches(".git");+ let name = remote.rsplit(['/', ':']).next()?;+ (!name.is_empty() && !name.contains('@')).then(|| name.to_string())+}++fn lookup_source(cwd: &str, slug: Option<&str>, rows: &[WorktreeRow]) -> Option<(String, String)> {+ let cwd = normalize_path(cwd);+ for row in rows {+ let worktree = normalize_path(&row.path);+ if cwd == worktree || cwd.starts_with(&format!("{worktree}/")) {+ let name = if row.repo_name.is_empty() {+ project_name_of(&row.source_repo)+ } else {+ row.repo_name.clone()+ };+ return Some((row.source_repo.clone(), name));+ }+ }++ let slug = slug?;+ let needle = format!("/worktrees/{slug}");+ for row in rows {+ let worktree = normalize_path(&row.path);+ if worktree.contains(&format!("{needle}/"))+ || worktree.ends_with(&needle)+ || row.repo_name == slug+ {+ let name = if row.repo_name.is_empty() {+ project_name_of(&row.source_repo)+ } else {+ row.repo_name.clone()+ };+ return Some((row.source_repo.clone(), name));+ }+ }+ None+}++fn ephemeral_plan_path(cwd: &str) -> Option<String> {+ let path = Path::new(cwd);+ let name = path.file_name()?.to_str()?;+ let plan = name+ .rsplit_once("-pr-")+ .map(|(head, _)| head)+ .unwrap_or(name);+ Some(path.parent()?.join(plan).to_string_lossy().into_owned())+}++#[cfg(test)]+mod tests {+ use super::*;+ use std::path::PathBuf;++ fn grok_home() -> PathBuf {+ PathBuf::from("/Users/tester/.grok")+ }++ #[test]+ fn ordinary_cwd_is_unchanged() {+ let ctx = GroupCtx::default();+ assert_eq!(+ canonical_project("/Users/tester/Github/wakefx", &[], &grok_home(), "", &ctx,),+ ("/Users/tester/Github/wakefx".into(), "wakefx".into())+ );+ }++ #[test]+ fn ephemeral_worktree_follows_local_origin_remote() {+ let ctx = GroupCtx::default();+ assert_eq!(+ canonical_project(+ "/var/folders/xx/T/grok-501/wt-abcd1234-pr-9",+ &["/Users/tester/Github/wakefx.origin.git".into()],+ &grok_home(),+ "",+ &ctx,+ ),+ ("/Users/tester/Github/wakefx".into(), "wakefx".into())+ );+ }++ #[test]+ fn ephemeral_worktrees_for_one_plan_group_together() {+ let ctx = GroupCtx::default();+ let first = canonical_project(+ "/var/folders/xx/T/grok-501/wt-abcd1234-pr-9",+ &[],+ &grok_home(),+ "",+ &ctx,+ );+ let second = canonical_project(+ "/var/folders/xx/T/grok-501/wt-abcd1234-pr-15",+ &[],+ &grok_home(),+ "",+ &ctx,+ );+ assert_eq!(first, second);+ assert_eq!(first.0, "/var/folders/xx/T/grok-501/wt-abcd1234");+ }++ #[test]+ fn registry_maps_named_worktree_to_source_repo() {+ let ctx = GroupCtx {+ worktrees: vec![WorktreeRow {+ path: "/Users/tester/.grok/worktrees/works-app/branch".into(),+ source_repo: "/Users/tester/Works/app".into(),+ repo_name: "app".into(),+ }],+ parents: HashMap::new(),+ };+ assert_eq!(+ canonical_project(+ "/Users/tester/.grok/worktrees/works-app/branch/subagent",+ &[],+ &grok_home(),+ "",+ &ctx,+ ),+ ("/Users/tester/Works/app".into(), "app".into())+ );+ }++ #[test]+ fn nested_subagent_flattens_to_root_parent() {+ let mut parents = HashMap::new();+ parents.insert(+ "child-2".into(),+ ParentRef {+ parent_id: "child-1".into(),+ parent_cwd: "/var/folders/xx/wt".into(),+ },+ );+ parents.insert(+ "child-1".into(),+ ParentRef {+ parent_id: "orchestrator".into(),+ parent_cwd: "/Users/tester/Desktop/AI/Grok".into(),+ },+ );+ let ctx = GroupCtx {+ worktrees: Vec::new(),+ parents,+ };+ assert_eq!(+ canonical_project("/var/folders/xx/wt", &[], &grok_home(), "child-2", &ctx,),+ ("/Users/tester/Desktop/AI/Grok".into(), "Grok".into())+ );+ assert!(parent_links(&ctx).contains(&("grok:child-2".into(), "grok:child-1".into())));+ assert!(parent_links(&ctx).contains(&("grok:child-1".into(), "grok:orchestrator".into())));+ }++ #[test]+ fn loads_parent_relation_from_session_tree() {+ let temp = tempfile::tempdir().unwrap();+ let meta_dir = temp+ .path()+ .join("%2FUsers%2Ftester%2FDesktop%2FAI%2FGrok")+ .join("orchestrator")+ .join("subagents")+ .join("child");+ fs::create_dir_all(&meta_dir).unwrap();+ fs::write(+ meta_dir.join("meta.json"),+ r#"{"parent_session_id":"orchestrator","child_session_id":"child"}"#,+ )+ .unwrap();++ let ctx = load_group_ctx(temp.path(), temp.path());+ assert!(parent_links(&ctx).contains(&("grok:child".into(), "grok:orchestrator".into())));+ assert_eq!(percent_decode("%2FUsers%2Ftester"), "/Users/tester");+ }+}diff --git a/crates/wake-core/src/adapters/mod.rs b/crates/wake-core/src/adapters/mod.rsindex 9911400..d063575 100644--- a/crates/wake-core/src/adapters/mod.rs+++ b/crates/wake-core/src/adapters/mod.rs@@ -12,6 +12,7 @@ pub mod opencode;pub mod pi;pub mod qoder;+pub(crate) mod grok_group;pub(crate) mod parse_utils;pub(crate) mod sqlite_ro;@@ -77,6 +78,23 @@ pub trait AgentAdapter: Send + Sync {fn session_paths(&self, meta: &SessionMeta) -> Vec<String> {vec![meta.file_path.clone()]}+ /// 一轮扫描开始前刷新 adapter 的跨会话快照。默认 adapter 没有这类状态。+ fn begin_scan(&self) {}+ /// 此 adapter 是否负责维护会话父子关系。单独的能力位用于区分“当前没有+ /// 子会话”和“不支持父子关系”,前者必须清掉数据库中的陈旧关系。+ fn manages_parent_links(&self) -> bool {+ false+ }+ /// 当前数据根内的 `(child_key, direct_parent_key)` 全量快照。scanner 会在+ /// 合并同 agent 的所有 location 后统一扁平到 root。+ fn parent_links(&self) -> Vec<(String, String)> {+ Vec::new()+ }+ /// watcher 事件是否会改变父子关系快照。关系边车不是会话主文件,不能塞进+ /// `file_ref`;命中后 watcher 会单独刷新同 agent 的所有关系快照。+ fn is_parent_link_event(&self, _path: &Path) -> bool {+ false+ }/// 本家会话文件所在的根位置(目录,或 SQLite 型的库文件),**不论当前存不存在**。/// 这是路径的**唯一事实源**:watch_paths 由它派生,"Scanned locations" 面板/// 直接展示它,按路径前缀统计会话数也依赖它——故语义定死为"其子树(或其本身)diff --git a/crates/wake-core/src/db.rs b/crates/wake-core/src/db.rsindex 5c696ee..225bd88 100644--- a/crates/wake-core/src/db.rs+++ b/crates/wake-core/src/db.rs@@ -32,7 +32,8 @@ CREATE TABLE IF NOT EXISTS sessions (file_path TEXT NOT NULL UNIQUE,file_size INTEGER DEFAULT 0,file_mtime INTEGER DEFAULT 0,- unknown_lines INTEGER DEFAULT 0+ unknown_lines INTEGER DEFAULT 0,+ parent_key TEXT NOT NULL DEFAULT '');CREATE INDEX IF NOT EXISTS idx_sessions_updated ON sessions(updated_at DESC);CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent_id, updated_at DESC);@@ -98,18 +99,54 @@ fn open_conn(path: &Path) -> Result<Connection> {if let Some(dir) = path.parent() {std::fs::create_dir_all(dir)?;}- let conn = Connection::open(path)?;+ let mut conn = Connection::open(path)?;conn.pragma_update(None, "journal_mode", "WAL")?;conn.pragma_update(None, "synchronous", "NORMAL")?;conn.busy_timeout(std::time::Duration::from_millis(3000))?;+ let sessions_existed: bool = conn.query_row(+ "SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE type='table' AND name='sessions')",+ [],+ |row| row.get(0),+ )?;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", []);+ if !table_has_column(&conn, "sessions", "parent_key")? {+ let tx = conn.transaction()?;+ tx.execute(+ "ALTER TABLE sessions ADD COLUMN parent_key TEXT NOT NULL DEFAULT ''",+ [],+ )?;+ // 只有从旧 schema 升级时才需要强制重解析 Grok;新库第一次增量扫描+ // 本来就会解析全部文件,不应额外记一个永久升级状态。+ if sessions_existed {+ tx.execute(+ "INSERT OR REPLACE INTO schema_meta(key, value) VALUES ('grok_parent_backfill', '1')",+ [],+ )?;+ }+ tx.commit()?;+ }+ conn.execute(+ "CREATE INDEX IF NOT EXISTS idx_sessions_parent ON sessions(parent_key)",+ [],+ )?;Ok(conn)}+fn table_has_column(conn: &Connection, table: &str, column: &str) -> Result<bool> {+ let mut stmt = conn.prepare(&format!("PRAGMA table_info({table})"))?;+ let names = stmt.query_map([], |row| row.get::<_, String>(1))?;+ for name in names {+ if name? == column {+ return Ok(true);+ }+ }+ Ok(false)+}+/// 打开索引库;打不开就把它连同 WAL/SHM 一起挪到 `.corrupt` 旁路再建一个空的。/// 索引本来就能从磁盘全量重扫恢复,重建的真实损失只有 user_data(收藏/置顶)/// 与 location 配置——而它远好过 GUI 无提示秒退。@@ -211,10 +248,121 @@ impl Store {Ok(())}+ /// 旧索引第一次升级到父子会话 schema 后,现有 Grok 行需要强制重解析,+ /// 才能把临时 worktree cwd 统一回主会话项目。+ pub fn needs_grok_parent_backfill(&self) -> bool {+ let conn = self.read.lock().unwrap();+ conn.query_row(+ "SELECT 1 FROM schema_meta WHERE key = 'grok_parent_backfill'",+ [],+ |_| Ok(()),+ )+ .optional()+ .map(|value| value.is_some())+ .unwrap_or(false)+ }++ pub fn finish_grok_parent_backfill(&self) -> Result<()> {+ let conn = self.write.lock().unwrap();+ conn.execute(+ "DELETE FROM schema_meta WHERE key = 'grok_parent_backfill'",+ [],+ )?;+ Ok(())+ }++ /// 当前胜出副本的 `(key, file_path)`,scanner 用 file_path 把同一 agent+ /// 的多 location 会话交回真正拥有它的 adapter 快照。+ pub fn session_sources_for_agent(&self, agent: AgentId) -> Result<Vec<(String, String)>> {+ let conn = self.read.lock().unwrap();+ let mut stmt = conn.prepare_cached(+ "SELECT key, file_path FROM sessions WHERE agent_id = ?1 ORDER BY key",+ )?;+ let rows = stmt.query_map(params![agent.as_str()], |row| {+ Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))+ })?;+ Ok(rows.collect::<rusqlite::Result<_>>()?)+ }++ /// scanner 在替换全量关系前用它找出解除/换父的 child;这些会话必须先+ /// 从自己的源文件重解析,恢复被父项目覆盖前的 canonical project。+ pub fn parent_links_for_agent(&self, agent: AgentId) -> Result<HashMap<String, String>> {+ let conn = self.read.lock().unwrap();+ let mut stmt = conn.prepare_cached(+ "SELECT key, parent_key FROM sessions+ WHERE agent_id = ?1 AND parent_key != '' ORDER BY key",+ )?;+ let rows = stmt.query_map(params![agent.as_str()], |row| {+ Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))+ })?;+ Ok(rows.collect::<rusqlite::Result<_>>()?)+ }++ /// 用某家 adapter 的全量快照原子替换父子关系。只接受库内存在、同 agent、+ /// 非自指的父子键;陈旧关系会被清空。返回是否真的改变了任何行。+ pub fn replace_parent_links(&self, agent: AgentId, links: &[(String, String)]) -> Result<bool> {+ let mut conn = self.write.lock().unwrap();+ let tx = conn.transaction()?;+ let before: Vec<(String, String)> = {+ let mut stmt = tx.prepare_cached(+ "SELECT key, parent_key FROM sessions+ WHERE agent_id = ?1 AND parent_key != '' ORDER BY key",+ )?;+ let rows = stmt.query_map(params![agent.as_str()], |row| {+ Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))+ })?;+ rows.collect::<rusqlite::Result<_>>()?+ };+ tx.execute(+ "UPDATE sessions SET parent_key = '' WHERE agent_id = ?1 AND parent_key != ''",+ params![agent.as_str()],+ )?;+ let mut update = tx.prepare_cached(+ "UPDATE sessions AS child SET+ parent_key = ?1,+ project_path = COALESCE((+ SELECT NULLIF(parent.project_path, '') FROM sessions parent WHERE parent.key = ?1+ ), child.project_path),+ project_name = COALESCE((+ SELECT NULLIF(parent.project_name, '') FROM sessions parent WHERE parent.key = ?1+ ), child.project_name)+ WHERE child.key = ?2 AND child.agent_id = ?3 AND child.key != ?1+ AND EXISTS (+ SELECT 1 FROM sessions parent+ WHERE parent.key = ?1 AND parent.agent_id = child.agent_id+ )",+ )?;+ let mut unique = std::collections::HashSet::new();+ for (child, parent) in links {+ if unique.insert(child.as_str()) {+ update.execute(params![parent, child, agent.as_str()])?;+ }+ }+ drop(update);+ let after: Vec<(String, String)> = {+ let mut stmt = tx.prepare_cached(+ "SELECT key, parent_key FROM sessions+ WHERE agent_id = ?1 AND parent_key != '' ORDER BY key",+ )?;+ let rows = stmt.query_map(params![agent.as_str()], |row| {+ Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))+ })?;+ rows.collect::<rusqlite::Result<_>>()?+ };+ tx.commit()?;+ Ok(before != after)+ }+pub fn remove_session(&self, key: &str, tombstone: bool) -> Result<()> {+ self.remove_sessions(&[key.to_string()], tombstone)+ }++ /// 一棵会话树在索引侧原子删除。磁盘路径由调用方先整体移入废纸篓;若+ /// 任一索引步骤失败,所有 session/message/FTS/tombstone 改动一起回滚。+ pub fn remove_sessions(&self, keys: &[String], tombstone: bool) -> Result<()> {let mut conn = self.write.lock().unwrap();let tx = conn.transaction()?;- {+ for key in keys {let file_path: Option<String> = tx.query_row("SELECT file_path FROM sessions WHERE key = ?1",@@ -606,15 +754,26 @@ impl Store {args.push(Box::new(like.clone()));args.push(Box::new(like));}+ if f.roots_only {+ wheres.push(if f.include_archived {+ ROOT_IGNORING_ARCHIVED.into()+ } else {+ ROOT_WHEN_HIDING_ARCHIVED.into()+ });+ }let where_sql = if wheres.is_empty() {String::new()} else {format!("WHERE {}", wheres.join(" AND "))};- let order_col = match f.sort {- SortKey::Updated => "s.updated_at",- SortKey::Created => "s.created_at",- SortKey::Messages => "s.message_count",+ let order_col = match (f.roots_only, f.sort, f.include_archived) {+ (true, SortKey::Updated, false) => ROOT_UPDATED_ACTIVE,+ (true, SortKey::Updated, true) => ROOT_UPDATED_ALL,+ (true, SortKey::Messages, false) => ROOT_MESSAGES_ACTIVE,+ (true, SortKey::Messages, true) => ROOT_MESSAGES_ALL,+ (_, SortKey::Updated, _) => "s.updated_at",+ (_, SortKey::Created, _) => "s.created_at",+ (_, SortKey::Messages, _) => "s.message_count",};let order_dir = if f.ascending { "ASC" } else { "DESC" };@@ -627,8 +786,17 @@ impl Store {|r| r.get(0),)?;+ let selected_cols = if f.roots_only {+ if f.include_archived {+ ROOT_SESSION_COLS_ALL+ } else {+ ROOT_SESSION_COLS_ACTIVE+ }+ } else {+ SESSION_COLS+ };let sql = format!(- "SELECT {SESSION_COLS} FROM sessions s LEFT JOIN user_data u ON u.session_key = s.key+ "SELECT {selected_cols} FROM sessions s LEFT JOIN user_data u ON u.session_key = s.key{where_sql}ORDER BY COALESCE(u.pinned,0) DESC, {order_col} {order_dir}, s.key ASC LIMIT ? OFFSET ?");@@ -647,6 +815,88 @@ impl Store {Ok((out, total))}+ /// 当前筛选下各根会话可见的直接子会话数。Grok 关系在入库时已扁平到+ /// root,因此一次 GROUP BY 足够覆盖任意原始嵌套深度。+ pub fn child_counts(&self, f: &SessionFilter) -> Result<HashMap<String, i64>> {+ let (where_sql, args) = child_filter_sql(f, None);+ let conn = self.read.lock().unwrap();+ let sql = format!(+ "SELECT s.parent_key, COUNT(*)+ FROM sessions s LEFT JOIN user_data u ON u.session_key = s.key+ {where_sql} GROUP BY s.parent_key"+ );+ let mut stmt = conn.prepare_cached(&sql)?;+ let rows = stmt.query_map(+ rusqlite::params_from_iter(args.iter().map(|arg| arg.as_ref())),+ |row| Ok((row.get::<_, String>(0)?, row.get::<_, i64>(1)?)),+ )?;+ let mut counts = HashMap::new();+ for row in rows {+ let (key, count) = row?;+ if !key.is_empty() {+ counts.insert(key, count);+ }+ }+ Ok(counts)+ }++ pub fn list_children(&self, parent_key: &str, f: &SessionFilter) -> Result<Vec<SessionMeta>> {+ let (where_sql, args) = child_filter_sql(f, Some(parent_key));+ let order_col = match f.sort {+ SortKey::Updated => "s.updated_at",+ SortKey::Created => "s.created_at",+ SortKey::Messages => "s.message_count",+ };+ let order_dir = if f.ascending { "ASC" } else { "DESC" };+ let conn = self.read.lock().unwrap();+ let sql = format!(+ "SELECT {SESSION_COLS}+ FROM sessions s LEFT JOIN user_data u ON u.session_key = s.key+ {where_sql}+ ORDER BY COALESCE(u.pinned,0) DESC, {order_col} {order_dir}, s.key ASC"+ );+ let mut stmt = conn.prepare_cached(&sql)?;+ let rows = stmt.query_map(+ rusqlite::params_from_iter(args.iter().map(|arg| arg.as_ref())),+ row_to_meta,+ )?;+ Ok(rows.collect::<rusqlite::Result<_>>()?)+ }++ pub fn parent_key_of(&self, key: &str) -> Result<Option<String>> {+ let conn = self.read.lock().unwrap();+ let value: Option<String> = conn+ .query_row(+ "SELECT NULLIF(parent_key, '') FROM sessions WHERE key = ?1",+ params![key],+ |row| row.get(0),+ )+ .optional()?+ .flatten();+ Ok(value)+ }++ /// 删除确认使用:不受当前列表筛选和 archived 状态影响,递归取完整子树。+ pub fn all_descendants(&self, key: &str) -> Result<Vec<SessionMeta>> {+ let conn = self.read.lock().unwrap();+ let sql = format!(+ "WITH RECURSIVE descendants(key) AS (+ SELECT key FROM sessions WHERE parent_key = ?1+ UNION+ SELECT child.key FROM sessions child+ JOIN descendants parent ON child.parent_key = parent.key+ )+ SELECT {SESSION_COLS}+ FROM sessions s+ JOIN descendants d ON d.key = s.key+ LEFT JOIN user_data u ON u.session_key = s.key+ ORDER BY s.created_at, s.key"+ );+ let mut stmt = conn.prepare_cached(&sql)?;+ let rows = stmt.query_map(params![key], row_to_meta)?;+ Ok(rows.collect::<rusqlite::Result<_>>()?)+ }+pub fn get_session(&self, key: &str) -> Result<Option<SessionMeta>> {let conn = self.read.lock().unwrap();let sql = format!(@@ -658,9 +908,16 @@ impl Store {pub fn list_projects(&self) -> Result<Vec<ProjectInfo>> {let conn = self.read.lock().unwrap();let mut stmt = conn.prepare_cached(- "SELECT project_path, project_name, COUNT(*), MAX(updated_at)- FROM sessions WHERE archived = 0- GROUP BY project_path ORDER BY MAX(updated_at) DESC",+ "SELECT s.project_path, s.project_name, COUNT(*),+ MAX(MAX(s.updated_at, COALESCE((+ SELECT MAX(c.updated_at) FROM sessions c+ WHERE c.parent_key = s.key AND c.archived = 0+ ), 0))) AS activity+ FROM sessions s+ WHERE s.archived = 0 AND (s.parent_key = '' OR NOT EXISTS (+ SELECT 1 FROM sessions p WHERE p.key = s.parent_key AND p.archived = 0+ ))+ GROUP BY s.project_path ORDER BY activity DESC",)?;let rows = stmt.query_map([], |r| {Ok(ProjectInfo {@@ -690,7 +947,11 @@ impl Store {pub fn agent_counts(&self) -> Result<HashMap<String, i64>> {let conn = self.read.lock().unwrap();let mut stmt = conn.prepare_cached(- "SELECT agent_id, COUNT(*) FROM sessions WHERE archived = 0 GROUP BY agent_id",+ "SELECT s.agent_id, COUNT(*) FROM sessions s+ WHERE s.archived = 0 AND (s.parent_key = '' OR NOT EXISTS (+ SELECT 1 FROM sessions p WHERE p.key = s.parent_key AND p.archived = 0+ ))+ GROUP BY s.agent_id",)?;let rows = stmt.query_map([], |r| Ok((r.get::<_, String>(0)?, r.get::<_, i64>(1)?)))?;let mut map = HashMap::new();@@ -1025,6 +1286,91 @@ const SESSION_COLS: &str =s.git_branch, s.created_at, s.updated_at, s.message_count, s.tokens_used, s.model, s.source,s.archived, s.file_path, s.file_size, COALESCE(u.favorite,0), COALESCE(u.pinned,0)";+const ROOT_WHEN_HIDING_ARCHIVED: &str = "(s.parent_key = '' OR NOT EXISTS (+ SELECT 1 FROM sessions p WHERE p.key = s.parent_key AND p.archived = 0+ ))";+const ROOT_IGNORING_ARCHIVED: &str =+ "(s.parent_key = '' OR NOT EXISTS (SELECT 1 FROM sessions p WHERE p.key = s.parent_key))";+const ROOT_UPDATED_ACTIVE: &str =+ "MAX(s.updated_at, COALESCE((SELECT MAX(c.updated_at) FROM sessions c+ WHERE c.parent_key = s.key AND c.archived = 0), 0))";+const ROOT_UPDATED_ALL: &str =+ "MAX(s.updated_at, COALESCE((SELECT MAX(c.updated_at) FROM sessions c+ WHERE c.parent_key = s.key), 0))";+const ROOT_MESSAGES_ACTIVE: &str =+ "s.message_count + COALESCE((SELECT SUM(c.message_count) FROM sessions c+ WHERE c.parent_key = s.key AND c.archived = 0), 0)";+const ROOT_MESSAGES_ALL: &str =+ "s.message_count + COALESCE((SELECT SUM(c.message_count) FROM sessions c+ WHERE c.parent_key = s.key), 0)";+const ROOT_SESSION_COLS_ACTIVE: &str =+ "s.key, s.agent_id, s.native_id, s.title, s.project_path, s.project_name,+ s.git_branch, s.created_at,+ MAX(s.updated_at, COALESCE((SELECT MAX(c.updated_at) FROM sessions c+ WHERE c.parent_key = s.key AND c.archived = 0), 0)),+ s.message_count + COALESCE((SELECT SUM(c.message_count) FROM sessions c+ WHERE c.parent_key = s.key AND c.archived = 0), 0),+ s.tokens_used, s.model, s.source, s.archived, s.file_path, s.file_size,+ COALESCE(u.favorite,0), COALESCE(u.pinned,0)";+const ROOT_SESSION_COLS_ALL: &str =+ "s.key, s.agent_id, s.native_id, s.title, s.project_path, s.project_name,+ s.git_branch, s.created_at,+ MAX(s.updated_at, COALESCE((SELECT MAX(c.updated_at) FROM sessions c+ WHERE c.parent_key = s.key), 0)),+ s.message_count + COALESCE((SELECT SUM(c.message_count) FROM sessions c+ WHERE c.parent_key = s.key), 0),+ s.tokens_used, s.model, s.source, s.archived, s.file_path, s.file_size,+ COALESCE(u.favorite,0), COALESCE(u.pinned,0)";++fn child_filter_sql(+ filter: &SessionFilter,+ parent_key: Option<&str>,+) -> (String, Vec<Box<dyn rusqlite::ToSql>>) {+ let mut wheres = Vec::new();+ let mut args: Vec<Box<dyn rusqlite::ToSql>> = Vec::new();+ match parent_key {+ Some(parent) => {+ wheres.push("s.parent_key = ?".to_string());+ args.push(Box::new(parent.to_string()));+ }+ None => wheres.push("s.parent_key != ''".to_string()),+ }+ if !filter.agents.is_empty() {+ let placeholders = filter+ .agents+ .iter()+ .map(|_| "?")+ .collect::<Vec<_>>()+ .join(",");+ wheres.push(format!("s.agent_id IN ({placeholders})"));+ for agent in &filter.agents {+ args.push(Box::new(agent.as_str().to_string()));+ }+ }+ if let Some(project) = &filter.project_path {+ wheres.push("s.project_path = ?".to_string());+ args.push(Box::new(project.clone()));+ }+ if filter.favorite_only {+ wheres.push("COALESCE(u.favorite, 0) = 1".to_string());+ }+ if !filter.include_archived {+ wheres.push("s.archived = 0".to_string());+ }+ if let Some(query) = filter+ .title_query+ .as_deref()+ .map(str::trim)+ .filter(|query| !query.is_empty())+ {+ wheres.push("(s.title LIKE ? ESCAPE '\\' OR s.project_name LIKE ? ESCAPE '\\')".into());+ let like = format!("%{}%", escape_like(query));+ args.push(Box::new(like.clone()));+ args.push(Box::new(like));+ }+ (format!("WHERE {}", wheres.join(" AND ")), args)+}+fn row_to_meta(r: &rusqlite::Row<'_>) -> rusqlite::Result<SessionMeta> {let agent_str: String = r.get(1)?;Ok(SessionMeta {diff --git a/crates/wake-core/src/models.rs b/crates/wake-core/src/models.rsindex 400a21e..7f1491b 100644--- a/crates/wake-core/src/models.rs+++ b/crates/wake-core/src/models.rs@@ -316,6 +316,9 @@ pub struct SessionFilter {pub project_path: Option<String>,pub favorite_only: bool,pub include_archived: bool,+ /// 只返回会话树的可见根节点。父节点不存在或被当前归档口径隐藏时,+ /// 子节点会提升为根,避免形成无法从列表进入的孤儿会话。+ pub roots_only: bool,pub title_query: Option<String>,pub sort: SortKey,/// false = 降序(默认,新到旧/多到少)diff --git a/crates/wake-core/src/scanner.rs b/crates/wake-core/src/scanner.rsindex 51348f2..3f6cc24 100644--- a/crates/wake-core/src/scanner.rs+++ b/crates/wake-core/src/scanner.rs@@ -79,6 +79,10 @@ fn run_scan_inner(full: bool,progress: &mut ScanProgress,) -> Result<()> {+ for adapter in adapters {+ adapter.begin_scan();+ }+ let force_grok_backfill = store.needs_grok_parent_backfill();let known = store.known_files()?;let mut seen_paths: std::collections::HashSet<String> = std::collections::HashSet::new();struct WorkItem<'a> {@@ -172,6 +176,7 @@ fn run_scan_inner(}for (adapter, refs) in adapters.iter().zip(per_adapter) {+ let force_adapter = force_grok_backfill && adapter.agent() == AgentId::Grok;for r in &refs {seen_paths.insert(r.file_path.clone());}@@ -192,7 +197,7 @@ fn run_scan_inner(// 墓碑要按**这个最终 key** 再卡——write_meta_only 是第三条// 写库路径,漏了它,已删会话会以空正文卡片复活//(2026-08-24 Codex review P1)- if (changed || full) && !store.is_key_tombstoned(&meta.key) {+ if (changed || full || force_adapter) && !store.is_key_tombstoned(&meta.key) {// fileMtime=0 → 后续全量解析仍会执行Some((meta.clone(), 0))} else {@@ -212,7 +217,7 @@ fn run_scan_inner(None => true,Some((mtime, size, _)) => *mtime != r.mtime_ms || *size != r.size,};- if full || changed {+ if full || force_adapter || changed {let quick = quick_map.as_ref().and_then(|m| m.get(&r.file_path).cloned());@@ -251,7 +256,10 @@ fn run_scan_inner(events.on_progress(progress);let mut last_notify = std::time::Instant::now();+ let mut grok_backfill_succeeded = true;for item in &queue {+ let forced_grok = force_grok_backfill && item.adapter.agent() == AgentId::Grok;+ let mut item_written = false;match item.adapter.parse_session(&item.r) {Ok(parsed) => {// quick/parsed 合并策略属各 adapter(默认 parsed 为准 quick 补缺,@@ -269,8 +277,9 @@ fn run_scan_inner(// 全量写入也走事务内副本裁决:扫描快照里的旧副本不得覆盖// 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);+ match store.write_session_guarded(&meta, item.r.mtime_ms, &parsed.units) {+ Ok(written) => item_written = written,+ Err(e) => eprintln!("[scanner] write failed {}: {e}", item.r.file_path),}}Err(e) => {@@ -289,12 +298,15 @@ fn run_scan_inner(None => parsed.meta,};if store.is_key_tombstoned(&meta.key) {+ item_written = true;break;}- if let Err(e) =- store.write_session_guarded(&meta, fb.mtime_ms, &parsed.units)- {- eprintln!("[scanner] fallback write failed {}: {e}", fb.file_path);+ match store.write_session_guarded(&meta, fb.mtime_ms, &parsed.units) {+ Ok(written) => item_written = written,+ Err(e) => eprintln!(+ "[scanner] fallback write failed {}: {e}",+ fb.file_path+ ),}break;}@@ -305,6 +317,9 @@ fn run_scan_inner(}}}+ if forced_grok && !item_written {+ grok_backfill_succeeded = false;+ }progress.done += 1;if last_notify.elapsed().as_millis() > 800 || progress.done == progress.total {last_notify = std::time::Instant::now();@@ -313,9 +328,174 @@ fn run_scan_inner(}}+ if sync_parent_links(adapters, store)? {+ events.on_sessions_changed();+ }+ if force_grok_backfill && grok_backfill_succeeded {+ store.finish_grok_parent_backfill()?;+ }+Ok(())}+/// 多 location 下关系元数据跟着 parent 会话,而 child 的胜出文件可能在另一根。+/// 因此先接受“关系目标 parent 的胜出文件也属于该快照”的直接边,再跨快照把+/// 嵌套链扁平到 root。解除/换父前重解析 child,恢复被旧父项目覆盖的自身归属。+fn sync_parent_links(adapters: &[Box<dyn AgentAdapter>], store: &Arc<Store>) -> Result<bool> {+ let mut managed_agents = std::collections::HashSet::new();+ let mut links_by_adapter: Vec<std::collections::HashMap<String, String>> =+ Vec::with_capacity(adapters.len());+ for adapter in adapters {+ if adapter.manages_parent_links() {+ managed_agents.insert(adapter.agent());+ links_by_adapter.push(adapter.parent_links().into_iter().collect());+ } else {+ links_by_adapter.push(std::collections::HashMap::new());+ }+ }++ let mut changed = false;+ for agent in managed_agents {+ let sources = store.session_sources_for_agent(agent)?;+ let mut source_by_key = std::collections::HashMap::new();+ let mut owner_by_key = std::collections::HashMap::new();+ for (key, file_path) in &sources {+ if let Some(adapter_ix) = crate::adapters::adapter_ix_for(adapters, agent, file_path) {+ source_by_key.insert(key.clone(), file_path.clone());+ owner_by_key.insert(key.clone(), adapter_ix);+ }+ }++ // meta.json 位于 parent 的 location。只采纳由当前胜出 parent 所属快照+ // 提供的边,避免另一份陈旧备份把已解除的关系重新挂回去。+ let mut direct = std::collections::HashMap::new();+ for (adapter_ix, links) in links_by_adapter.iter().enumerate() {+ if adapters[adapter_ix].agent() != agent {+ continue;+ }+ for (child, parent) in links {+ if source_by_key.contains_key(child)+ && owner_by_key.get(parent).copied() == Some(adapter_ix)+ {+ direct.insert(child.clone(), parent.clone());+ }+ }+ }++ // 各 location 只能看见自己的直接/局部链;合并后再走到全局 root。+ let mut desired_map = std::collections::HashMap::new();+ for child in direct.keys() {+ if let Some(parent) = flattened_parent(child, &direct) {+ desired_map.insert(child.clone(), parent);+ }+ }++ // replace_parent_links 会把关系内 child 的 project 覆写成父项目。关系+ // 解除或换父时,先从 child 自己的胜出文件重解析,恢复 fallback project;+ // 解析失败则保留仍有效的旧关系,下一次 Grok 事件继续重试。+ let current = store.parent_links_for_agent(agent)?;+ for (child, old_parent) in current {+ if desired_map.get(&child) == Some(&old_parent) {+ continue;+ }+ let restored = source_by_key.get(&child).is_some_and(|file_path| {+ reparse_for_parent_change(adapters, store, agent, &child, file_path)+ });+ if !restored && source_by_key.contains_key(&old_parent) {+ desired_map.insert(child, old_parent);+ }+ }++ let mut desired: Vec<(String, String)> = desired_map.into_iter().collect();+ desired.sort();+ changed |= store.replace_parent_links(agent, &desired)?;+ }+ Ok(changed)+}++/// watcher 收到关系边车事件、但没有会话主文件可交给 `scan_files` 时使用。+/// 同 agent 的全部 location 必须一起刷新,否则跨 location 的父链会被局部快照截断。+pub fn refresh_parent_links(+ adapters: &[Box<dyn AgentAdapter>],+ store: &Arc<Store>,+ events: &dyn ScanEvents,+ affected_agents: &[AgentId],+) {+ let mut refreshable = false;+ for adapter in adapters {+ if affected_agents.contains(&adapter.agent()) && adapter.manages_parent_links() {+ adapter.begin_scan();+ refreshable = true;+ }+ }+ if !refreshable {+ return;+ }+ match sync_parent_links(adapters, store) {+ Ok(true) => events.on_sessions_changed(),+ Ok(false) => {}+ Err(error) => eprintln!("[scanner] parent-link sidecar refresh failed: {error}"),+ }+}++fn flattened_parent(+ child: &str,+ direct: &std::collections::HashMap<String, String>,+) -> Option<String> {+ let mut current = child;+ let mut seen = std::collections::HashSet::from([child]);+ loop {+ let parent = direct.get(current)?;+ if !seen.insert(parent.as_str()) {+ return None;+ }+ if direct.contains_key(parent) {+ current = parent;+ } else {+ return Some(parent.clone());+ }+ }+}++fn reparse_for_parent_change(+ adapters: &[Box<dyn AgentAdapter>],+ store: &Arc<Store>,+ agent: AgentId,+ key: &str,+ file_path: &str,+) -> bool {+ let Some(adapter_ix) = crate::adapters::adapter_ix_for(adapters, agent, file_path) else {+ return false;+ };+ let adapter = &adapters[adapter_ix];+ let Some(reference) = adapter.file_ref(std::path::Path::new(file_path)) else {+ eprintln!("[scanner] cannot restore detached session source: {file_path}");+ return false;+ };+ let parsed = match adapter.parse_session(&reference) {+ Ok(parsed) => parsed,+ Err(error) => {+ eprintln!("[scanner] detached session reparse failed {file_path}: {error}");+ return false;+ }+ };+ let quick = adapter.quick_meta(std::slice::from_ref(&reference));+ let meta = match quick.as_ref().and_then(|metas| metas.get(file_path)) {+ Some(quick) => adapter.merge_quick_meta(parsed.meta, quick),+ None => parsed.meta,+ };+ if meta.key != key || store.is_key_tombstoned(&meta.key) {+ return false;+ }+ match store.write_session_guarded(&meta, reference.mtime_ms, &parsed.units) {+ Ok(written) => written,+ Err(error) => {+ eprintln!("[scanner] detached session write failed {file_path}: {error}");+ false+ }+ }+}+/// watcher 触发的单文件增量。与 run_scan 走同一道 quick/parsed 合并——/// 跳过它,Codex 在 state DB 里被用户手动命名的标题就会被首条消息推导的/// 标题静默覆盖(跨文件不变量 5:quickMeta 双路径)。@@ -325,6 +505,13 @@ pub fn scan_files(events: &dyn ScanEvents,refs: Vec<SessionFileRef>,) {+ let affected_agents: std::collections::HashSet<AgentId> =+ refs.iter().map(|reference| reference.agent).collect();+ for adapter in adapters {+ if affected_agents.contains(&adapter.agent()) {+ adapter.begin_scan();+ }+ }// 按**实例**分组,不是按 agent:自定义 location 让同 agent 有多实例,// 文件必须交给拥有其根的那个(gemini/kimi 的 cwd 反查、codex 的 state DB// 都是实例相对侧档);quick_meta 是整库查询,每组只查一次,不能逐文件调@@ -378,6 +565,15 @@ pub fn scan_files(}}}+ if adapters+ .iter()+ .any(|adapter| affected_agents.contains(&adapter.agent()) && adapter.manages_parent_links())+ {+ changed |= sync_parent_links(adapters, store).unwrap_or_else(|error| {+ eprintln!("[scanner] parent-link refresh failed: {error}");+ false+ });+ }if changed {events.on_sessions_changed();}diff --git a/crates/wake-core/src/watcher.rs b/crates/wake-core/src/watcher.rsindex f39ed96..ac6cd2a 100644--- a/crates/wake-core/src/watcher.rs+++ b/crates/wake-core/src/watcher.rs@@ -1,9 +1,9 @@use crate::adapters::AgentAdapter;use crate::db::Store;use crate::models::*;-use crate::scanner::{scan_files, ScanEvents};+use crate::scanner::{refresh_parent_links, scan_files, ScanEvents};use notify::{RecursiveMode, Watcher};-use std::collections::HashMap;+use std::collections::{HashMap, HashSet};use std::path::{Path, PathBuf};use std::sync::mpsc;use std::sync::Arc;@@ -148,12 +148,19 @@ pub fn start_watcher(}}+ let mut parent_link_agents = HashSet::new();for ev in batch.into_iter().flatten() {for path in ev.paths {+ let owner_ix = resolve_ix(&path);+ if let Some(adapter) = owner_ix.and_then(|ix| adapters.get(ix)) {+ if adapter.is_parent_link_event(&path) {+ parent_link_agents.insert(adapter.agent());+ }+ }if matches!(ev.kind, notify::EventKind::Remove(_)) {pending.remove(&path);removed.push(path.clone());- } else if let Some(ix) = resolve_ix(&path) {+ } else if let Some(ix) = owner_ix {pending.insert(path.clone(), ix);}}@@ -174,9 +181,16 @@ pub fn start_watcher(.drain().filter_map(|(path, ix)| adapters.get(ix).and_then(|a| a.file_ref(&path))).collect();+ let scanned_agents: HashSet<AgentId> =+ refs.iter().map(|reference| reference.agent).collect();if !refs.is_empty() {scan_files(&adapters, &store, events.as_ref(), refs);}+ parent_link_agents.retain(|agent| !scanned_agents.contains(agent));+ if !parent_link_agents.is_empty() {+ let agents: Vec<AgentId> = parent_link_agents.into_iter().collect();+ refresh_parent_links(&adapters, &store, events.as_ref(), &agents);+ }}});diff --git a/crates/wake-core/tests/adapter_contracts.rs b/crates/wake-core/tests/adapter_contracts.rsindex 9c1ef33..1f86b1a 100644--- a/crates/wake-core/tests/adapter_contracts.rs+++ b/crates/wake-core/tests/adapter_contracts.rs@@ -1116,9 +1116,17 @@ fn pi_parse_contract() {#[test]fn grok_parse_contract() {setup();- let adapter = GrokAdapter::new();+ let adapter = GrokAdapter::new().with_custom_root(fixture("grok"));+ adapter.begin_scan();+ assert!(adapter.parent_links().contains(&(+ "grok:aaaaaaaa-aaaa-bbbb-cccc-0000000000aa".into(),+ "grok:77777777-aaaa-bbbb-cccc-000000000007".into(),+ )));+ let parent_meta = fixture("grok/sessions/%2FUsers%2Ftester%2FGithub%2Fwakefx/77777777-aaaa-bbbb-cccc-000000000007/subagents/child-fixture/meta.json");+ assert!(adapter.is_parent_link_event(&parent_meta));// file_ref 是公开 API:只认 updates.jsonl,native_id 取会话目录名let path = fixture("grok/sessions/%2FUsers%2Ftester%2FGithub%2Fwakefx/77777777-aaaa-bbbb-cccc-000000000007/updates.jsonl");+ assert!(!adapter.is_parent_link_event(&path));let r = adapter.file_ref(&path).expect("grok file_ref");assert_eq!(r.native_id, "77777777-aaaa-bbbb-cccc-000000000007");assert!(adapterdiff --git a/crates/wake-core/tests/db_roundtrip.rs b/crates/wake-core/tests/db_roundtrip.rsindex 26b296a..030c832 100644--- a/crates/wake-core/tests/db_roundtrip.rs+++ b/crates/wake-core/tests/db_roundtrip.rs@@ -146,6 +146,7 @@ fn list_sessions_filters_and_counts() {project_path: None,favorite_only: false,include_archived: false,+ roots_only: false,title_query: None,sort: SortKey::Updated,ascending: false,@@ -201,6 +202,151 @@ fn list_sessions_pages_have_stable_tie_order() {);}+#[test]+fn nested_sessions_are_aggregated_but_starred_stays_flat() {+ let (_dir, store) = temp_store();+ let mut parent = meta("grok:parent", "parent");+ parent.agent = AgentId::Grok;+ parent.project_path = "/work/source".into();+ parent.project_name = "source".into();+ parent.file_path = "/tmp/grok/a/parent/updates.jsonl".into();+ parent.updated_at = 100;+ parent.message_count = 2;+ let mut child = meta("grok:child", "child");+ child.agent = AgentId::Grok;+ child.project_path = "/tmp/wt-plan-pr-1".into();+ child.project_name = "wt-plan-pr-1".into();+ child.file_path = "/tmp/grok/b/child/updates.jsonl".into();+ child.updated_at = 500;+ child.message_count = 7;+ let mut other = meta("grok:other", "other");+ other.agent = AgentId::Grok;+ other.file_path = "/tmp/grok/a/other/updates.jsonl".into();+ other.updated_at = 400;+ other.message_count = 3;+ store+ .write_meta_only(&[+ (parent.clone(), parent.updated_at),+ (child.clone(), child.updated_at),+ (other, 400),+ ])+ .unwrap();+ store+ .replace_parent_links(AgentId::Grok, &[(child.key.clone(), parent.key.clone())])+ .unwrap();++ let filter = SessionFilter {+ roots_only: true,+ limit: 20,+ ..Default::default()+ };+ let (roots, total) = store.list_sessions(&filter).unwrap();+ assert_eq!(total, 2);+ assert_eq!(+ roots[0].key, parent.key,+ "child activity should sort its root"+ );+ assert_eq!(roots[0].updated_at, 500);+ assert_eq!(roots[0].message_count, 9);+ assert_eq!(store.child_counts(&filter).unwrap()[&parent.key], 1);+ let children = store.list_children(&parent.key, &filter).unwrap();+ assert_eq!(children.len(), 1);+ assert_eq!(children[0].key, child.key);+ assert_eq!(children[0].project_path, parent.project_path);+ assert_eq!(+ store.parent_key_of(&child.key).unwrap(),+ Some(parent.key.clone())+ );+ assert_eq!(store.agent_counts().unwrap()["grok"], 2);+ assert_eq!(+ store+ .list_projects()+ .unwrap()+ .iter()+ .find(|project| project.path == parent.project_path)+ .unwrap()+ .session_count,+ 1+ );++ store.set_user_data(&child.key, Some(true), None).unwrap();+ let starred = SessionFilter {+ favorite_only: true,+ roots_only: false,+ limit: 20,+ ..Default::default()+ };+ let (rows, total) = store.list_sessions(&starred).unwrap();+ assert_eq!(total, 1);+ assert_eq!(+ rows[0].key, child.key,+ "Starred must keep child sessions flat"+ );+}++#[test]+fn removing_a_session_tree_writes_every_tombstone_atomically() {+ let (_dir, store) = temp_store();+ let mut parent = meta("grok:delete-parent", "parent");+ parent.agent = AgentId::Grok;+ let mut child = meta("grok:delete-child", "child");+ child.agent = AgentId::Grok;+ store+ .write_meta_only(&[+ (parent.clone(), parent.updated_at),+ (child.clone(), child.updated_at),+ ])+ .unwrap();+ store+ .replace_parent_links(AgentId::Grok, &[(child.key.clone(), parent.key.clone())])+ .unwrap();+ assert_eq!(store.all_descendants(&parent.key).unwrap().len(), 1);++ store+ .remove_sessions(&[parent.key.clone(), child.key.clone()], true)+ .unwrap();+ assert!(store.get_session(&parent.key).unwrap().is_none());+ assert!(store.get_session(&child.key).unwrap().is_none());+ assert!(store.is_key_tombstoned(&parent.key));+ assert!(store.is_key_tombstoned(&child.key));+ assert!(store.is_tombstoned(&parent.file_path));+ assert!(store.is_tombstoned(&child.file_path));+}++#[test]+fn old_database_marks_grok_backfill_until_scan_finishes() {+ let dir = tempfile::tempdir().unwrap();+ let path = dir.path().join("old.db");+ let conn = rusqlite::Connection::open(&path).unwrap();+ conn.execute_batch(+ "CREATE TABLE sessions (+ key TEXT PRIMARY KEY, agent_id TEXT NOT NULL, native_id TEXT NOT NULL,+ title TEXT NOT NULL DEFAULT '', project_path TEXT NOT NULL DEFAULT '',+ project_name TEXT NOT NULL DEFAULT '', git_branch TEXT, created_at INTEGER DEFAULT 0,+ updated_at INTEGER DEFAULT 0, message_count INTEGER DEFAULT 0, tokens_used INTEGER,+ model TEXT, source TEXT, archived INTEGER DEFAULT 0, file_path TEXT NOT NULL UNIQUE,+ file_size INTEGER DEFAULT 0, file_mtime INTEGER DEFAULT 0, unknown_lines INTEGER DEFAULT 0+ );",+ )+ .unwrap();+ drop(conn);++ let store = Store::open(&path).unwrap();+ assert!(store.needs_grok_parent_backfill());+ store.finish_grok_parent_backfill().unwrap();+ assert!(!store.needs_grok_parent_backfill());++ let conn = rusqlite::Connection::open(path).unwrap();+ let has_parent: bool = conn+ .prepare("PRAGMA table_info(sessions)")+ .unwrap()+ .query_map([], |row| row.get::<_, String>(1))+ .unwrap()+ .flatten()+ .any(|name| name == "parent_key");+ assert!(has_parent);+}+#[test]fn path_counts_respect_agent_and_boundary() {// Session locations 面板的计数按数据根归属。两条真实风险:diff --git a/crates/wake-core/tests/fixtures/grok/sessions/%2FUsers%2Ftester%2FGithub%2Fwakefx/77777777-aaaa-bbbb-cccc-000000000007/subagents/child-fixture/meta.json b/crates/wake-core/tests/fixtures/grok/sessions/%2FUsers%2Ftester%2FGithub%2Fwakefx/77777777-aaaa-bbbb-cccc-000000000007/subagents/child-fixture/meta.jsonnew file mode 100644index 0000000..cd61956--- /dev/null+++ b/crates/wake-core/tests/fixtures/grok/sessions/%2FUsers%2Ftester%2FGithub%2Fwakefx/77777777-aaaa-bbbb-cccc-000000000007/subagents/child-fixture/meta.json@@ -0,0 +1,5 @@+{+ "parent_session_id": "77777777-aaaa-bbbb-cccc-000000000007",+ "child_session_id": "aaaaaaaa-aaaa-bbbb-cccc-0000000000aa",+ "subagent_id": "aaaaaaaa-aaaa-bbbb-cccc-0000000000aa"+}diff --git a/crates/wake-core/tests/scanner_finale.rs b/crates/wake-core/tests/scanner_finale.rsindex 6db046b..1129a8c 100644--- a/crates/wake-core/tests/scanner_finale.rs+++ b/crates/wake-core/tests/scanner_finale.rs@@ -9,7 +9,7 @@ use anyhow::{bail, Result};use wake_core::adapters::AgentAdapter;use wake_core::db::Store;use wake_core::models::*;-use wake_core::scanner::{run_scan, ScanEvents, ScanProgress};+use wake_core::scanner::{refresh_parent_links, run_scan, ScanEvents, ScanProgress};/// 收集全部进度事件与变更通知计数,供断言终态/刷新契约struct Recorder(Mutex<Vec<ScanProgress>>, Mutex<usize>);@@ -93,6 +93,285 @@ fn finale_fires_when_adapter_fails() {assert_terminal_event(&rec.0.lock().unwrap(), "adapter 枚举失败");}+#[test]+fn parent_links_from_multiple_locations_are_merged_by_winning_file() {+ let dir = tempfile::tempdir().unwrap();+ let store = temp_store(dir.path());+ let mut child = seed(+ AgentId::Grok,+ "/tmp/grok-child-location",+ "/tmp/grok-child-location/group/child/updates.jsonl",+ "child",+ 20,+ );+ child.meta.project_path = "/tmp/wt-plan-pr-1".into();+ child.meta.project_name = "wt-plan-pr-1".into();+ child.manages_links = true;++ let mut parent = seed(+ AgentId::Grok,+ "/tmp/grok-parent-location",+ "/tmp/grok-parent-location/group/parent/updates.jsonl",+ "parent",+ 10,+ );+ parent.meta.project_path = "/Users/tester/Github/source".into();+ parent.meta.project_name = "source".into();+ // Grok 的 subagents/meta.json 在 parent 会话目录,所以关系快照属于+ // parent location;child 的胜出 updates.jsonl 则来自另一 location。+ parent.manages_links = true;+ parent.parent_links = vec![("grok:child".into(), "grok:parent".into())];++ let adapters: Vec<Box<dyn AgentAdapter>> = vec![Box::new(child), Box::new(parent)];+ run_scan(&adapters, &store, &Recorder::new(), true).unwrap();++ assert_eq!(+ store.parent_key_of("grok:child").unwrap(),+ Some("grok:parent".into())+ );+ assert_eq!(+ store+ .get_session("grok:child")+ .unwrap()+ .unwrap()+ .project_path,+ "/Users/tester/Github/source"+ );+}++#[test]+fn nested_parent_chain_flattens_across_three_locations() {+ let dir = tempfile::tempdir().unwrap();+ let store = temp_store(dir.path());+ let mut leaf = seed(+ AgentId::Grok,+ "/tmp/grok-leaf-location",+ "/tmp/grok-leaf-location/group/leaf/updates.jsonl",+ "leaf",+ 30,+ );+ leaf.manages_links = true;+ let mut middle = seed(+ AgentId::Grok,+ "/tmp/grok-middle-location",+ "/tmp/grok-middle-location/group/middle/updates.jsonl",+ "middle",+ 20,+ );+ middle.manages_links = true;+ middle.parent_links = vec![("grok:leaf".into(), "grok:middle".into())];+ let mut root = seed(+ AgentId::Grok,+ "/tmp/grok-root-location",+ "/tmp/grok-root-location/group/root/updates.jsonl",+ "root",+ 10,+ );+ root.meta.project_path = "/Users/tester/Github/source".into();+ root.meta.project_name = "source".into();+ root.manages_links = true;+ root.parent_links = vec![("grok:middle".into(), "grok:root".into())];++ let adapters: Vec<Box<dyn AgentAdapter>> =+ vec![Box::new(leaf), Box::new(middle), Box::new(root)];+ run_scan(&adapters, &store, &Recorder::new(), true).unwrap();++ assert_eq!(+ store.parent_key_of("grok:middle").unwrap(),+ Some("grok:root".into())+ );+ assert_eq!(+ store.parent_key_of("grok:leaf").unwrap(),+ Some("grok:root".into())+ );+ assert_eq!(+ store+ .get_session("grok:leaf")+ .unwrap()+ .unwrap()+ .project_path,+ "/Users/tester/Github/source"+ );+}++#[test]+fn removing_parent_link_restores_child_project_on_sidecar_event() {+ let dir = tempfile::tempdir().unwrap();+ let store = temp_store(dir.path());+ let mut child = seed(+ AgentId::Grok,+ "/tmp/grok-child-location",+ "/tmp/grok-child-location/group/child/updates.jsonl",+ "child",+ 20,+ );+ child.meta.project_path = "/tmp/wt-plan-pr-1".into();+ child.meta.project_name = "wt-plan-pr-1".into();+ child.manages_links = true;+ let mut parent = seed(+ AgentId::Grok,+ "/tmp/grok-parent-location",+ "/tmp/grok-parent-location/group/parent/updates.jsonl",+ "parent",+ 10,+ );+ parent.meta.project_path = "/Users/tester/Github/source".into();+ parent.meta.project_name = "source".into();+ parent.manages_links = true;+ parent.parent_links = vec![("grok:child".into(), "grok:parent".into())];++ let adapters: Vec<Box<dyn AgentAdapter>> = vec![Box::new(child), Box::new(parent)];+ run_scan(&adapters, &store, &Recorder::new(), true).unwrap();+ assert_eq!(+ store+ .get_session("grok:child")+ .unwrap()+ .unwrap()+ .project_path,+ "/Users/tester/Github/source"+ );++ let mut child = seed(+ AgentId::Grok,+ "/tmp/grok-child-location",+ "/tmp/grok-child-location/group/child/updates.jsonl",+ "child",+ 20,+ );+ child.meta.project_path = "/tmp/wt-plan-pr-1".into();+ child.meta.project_name = "wt-plan-pr-1".into();+ child.manages_links = true;+ let mut parent = seed(+ AgentId::Grok,+ "/tmp/grok-parent-location",+ "/tmp/grok-parent-location/group/parent/updates.jsonl",+ "parent",+ 10,+ );+ parent.meta.project_path = "/Users/tester/Github/source".into();+ parent.meta.project_name = "source".into();+ parent.manages_links = true;+ let adapters: Vec<Box<dyn AgentAdapter>> = vec![Box::new(child), Box::new(parent)];++ refresh_parent_links(&adapters, &store, &Recorder::new(), &[AgentId::Grok]);++ let child = store.get_session("grok:child").unwrap().unwrap();+ assert_eq!(store.parent_key_of(&child.key).unwrap(), None);+ assert_eq!(child.project_path, "/tmp/wt-plan-pr-1");+ assert_eq!(child.project_name, "wt-plan-pr-1");+}++#[test]+fn migration_backfill_reparses_unchanged_grok_rows_once() {+ let dir = tempfile::tempdir().unwrap();+ let db_path = dir.path().join("scan.db");+ let store = Arc::new(Store::open(&db_path).unwrap());+ let mut adapter = seed(+ AgentId::Grok,+ "/tmp/grok-backfill",+ "/tmp/grok-backfill/group/session/updates.jsonl",+ "session",+ 42,+ );+ adapter.meta.project_path = "/Users/tester/Github/source".into();+ adapter.meta.project_name = "source".into();+ let mut stale = adapter.meta.clone();+ stale.project_path = "/tmp/wt-plan-pr-1".into();+ stale.project_name = "wt-plan-pr-1".into();+ store.write_meta_only(&[(stale, 42)]).unwrap();+ rusqlite::Connection::open(&db_path)+ .unwrap()+ .execute(+ "INSERT OR REPLACE INTO schema_meta(key, value) VALUES ('grok_parent_backfill', '1')",+ [],+ )+ .unwrap();++ run_scan(+ &[Box::new(adapter) as Box<dyn AgentAdapter>],+ &store,+ &Recorder::new(),+ false,+ )+ .unwrap();++ assert_eq!(+ store+ .get_session("grok:session")+ .unwrap()+ .unwrap()+ .project_path,+ "/Users/tester/Github/source"+ );+ assert!(!store.needs_grok_parent_backfill());+}++#[test]+fn migration_backfill_retries_after_parse_failure() {+ let dir = tempfile::tempdir().unwrap();+ let db_path = dir.path().join("retry.db");+ let store = Arc::new(Store::open(&db_path).unwrap());+ let mut broken = seed(+ AgentId::Grok,+ "/tmp/grok-backfill-retry",+ "/tmp/grok-backfill-retry/group/session/updates.jsonl",+ "session",+ 42,+ );+ broken.meta.project_path = "/tmp/wt-plan-pr-1".into();+ broken.meta.project_name = "wt-plan-pr-1".into();+ broken.fail_parse = true;+ store+ .write_meta_only(&[(broken.meta.clone(), broken.r.mtime_ms)])+ .unwrap();+ rusqlite::Connection::open(&db_path)+ .unwrap()+ .execute(+ "INSERT OR REPLACE INTO schema_meta(key, value) VALUES ('grok_parent_backfill', '1')",+ [],+ )+ .unwrap();++ run_scan(+ &[Box::new(broken) as Box<dyn AgentAdapter>],+ &store,+ &Recorder::new(),+ false,+ )+ .unwrap();+ assert!(+ store.needs_grok_parent_backfill(),+ "failed forced rows must remain retryable"+ );++ let mut repaired = seed(+ AgentId::Grok,+ "/tmp/grok-backfill-retry",+ "/tmp/grok-backfill-retry/group/session/updates.jsonl",+ "session",+ 42,+ );+ repaired.meta.project_path = "/Users/tester/Github/source".into();+ repaired.meta.project_name = "source".into();+ run_scan(+ &[Box::new(repaired) as Box<dyn AgentAdapter>],+ &store,+ &Recorder::new(),+ false,+ )+ .unwrap();++ assert_eq!(+ store+ .get_session("grok:session")+ .unwrap()+ .unwrap()+ .project_path,+ "/Users/tester/Github/source"+ );+ assert!(!store.needs_grok_parent_backfill());+}+/// 固定提供一个会话(含 quickMeta 快路径)的 adapter。agent/root 可参数化:/// 防复活、跨根去重、重叠根归属三组测试共用struct SeedAdapter {@@ -105,6 +384,8 @@ struct SeedAdapter {/// 模拟 codex 的 state 改名:quick 给出的 key 与文件 native key 不同,/// merge 时 quick key 压过 parsed(codex 同款优先级)quick_key: Option<String>,+ manages_links: bool,+ parent_links: Vec<(String, String)>,}impl AgentAdapter for SeedAdapter {@@ -114,6 +395,9 @@ impl AgentAdapter for SeedAdapter {fn list_session_files(&self) -> Result<Vec<SessionFileRef>> {Ok(vec![self.r.clone()])}+ fn file_ref(&self, path: &Path) -> Option<SessionFileRef> {+ (path.to_string_lossy() == self.r.file_path).then(|| self.r.clone())+ }fn quick_meta(&self,_refs: &[SessionFileRef],@@ -132,6 +416,12 @@ impl AgentAdapter for SeedAdapter {}parsed}+ fn manages_parent_links(&self) -> bool {+ self.manages_links+ }+ fn parent_links(&self) -> Vec<(String, String)> {+ self.parent_links.clone()+ }fn parse_session(&self, _: &SessionFileRef) -> Result<ParsedSession> {if self.fail_parse {bail!("simulated corrupt copy")@@ -156,6 +446,8 @@ impl AgentAdapter for SeedAdapter {meta: self.meta.clone(),fail_parse: self.fail_parse,quick_key: self.quick_key.clone(),+ manages_links: self.manages_links,+ parent_links: self.parent_links.clone(),})}}@@ -194,6 +486,8 @@ fn seed(agent: AgentId, root: &str, path: &str, native_id: &str, mtime: i64) ->},fail_parse: false,quick_key: None,+ manages_links: false,+ parent_links: Vec::new(),}}@@ -237,6 +531,8 @@ fn tombstoned_session_does_not_resurrect_on_rescan() {meta: meta.clone(),fail_parse: false,quick_key: None,+ manages_links: false,+ parent_links: Vec::new(),})];let rec = Recorder::new();diff --git a/crates/wake/Cargo.toml b/crates/wake/Cargo.tomlindex 15e8cee..faf3ab8 100644--- a/crates/wake/Cargo.toml+++ b/crates/wake/Cargo.toml@@ -27,6 +27,7 @@ unicode-segmentation = "1.13"[dev-dependencies]gpui = { git = "https://github.com/zed-industries/zed", features = ["test-support"] }+tempfile = "3"# exe 图标 + 版本资源(build.rs 里按 CARGO_CFG_TARGET_OS 判目标生效)。# 不做 target 门控:build-dependencies 的 [target.*] 匹配语义在 host/targetdiff --git a/crates/wake/src/workbench.rs b/crates/wake/src/workbench.rsindex bf7dd0c..9ed7802 100644--- a/crates/wake/src/workbench.rs+++ b/crates/wake/src/workbench.rs@@ -192,36 +192,44 @@ fn session_group_label(ts: i64, today: NaiveDate) -> SharedString {date.format("%B %Y").to_string().into()}-fn build_session_groups_at(- sessions: &[SessionMeta],+#[derive(Debug, Clone)]+struct SessionListRow {+ meta: SessionMeta,+ depth: u8,+ child_count: i64,+ expanded: bool,+ /// 子会话必须紧跟父会话,不能因自己的时间戳被拆进另一个日期 section。+ group_timestamp: i64,+ group_pinned: bool,+}++fn build_row_groups_at(+ rows: &[SessionListRow],sort: SortKey,ascending: bool,today: NaiveDate,) -> Vec<SessionGroup> {let time_descending = !ascending && matches!(sort, SortKey::Updated | SortKey::Created);- if sessions.is_empty() || !time_descending {+ if rows.is_empty() || !time_descending {return vec![SessionGroup {label: "".into(),- range: 0..sessions.len(),+ range: 0..rows.len(),}];}let mut groups = Vec::new();- let pinned_count = sessions.iter().take_while(|session| session.pinned).count();+ let pinned_count = rows.iter().take_while(|row| row.group_pinned).count();if pinned_count > 0 {groups.push(SessionGroup {label: "Pinned".into(),range: 0..pinned_count,});}-let mut start = pinned_count;- while start < sessions.len() {- let label = session_group_label(session_group_timestamp(&sessions[start], sort), today);+ while start < rows.len() {+ let label = session_group_label(rows[start].group_timestamp, today);let mut end = start + 1;- while end < sessions.len()- && session_group_label(session_group_timestamp(&sessions[end], sort), today) == label- {+ while end < rows.len() && session_group_label(rows[end].group_timestamp, today) == label {end += 1;}groups.push(SessionGroup {@@ -238,6 +246,7 @@ fn same_session_query(left: &SessionFilter, right: &SessionFilter) -> bool {&& left.project_path == right.project_path&& left.favorite_only == right.favorite_only&& left.include_archived == right.include_archived+ && left.roots_only == right.roots_only&& left.title_query == right.title_query&& left.sort == right.sort&& left.ascending == right.ascending@@ -264,7 +273,12 @@ fn session_matches_filter(session: &SessionMeta, filter: &SessionFilter) -> bool}pub struct SessionsDelegate {+ /// 分页查询返回的根会话;next_offset 只能按它推进,展开的孩子不参与分页。pub sessions: Vec<SessionMeta>,+ rows: Vec<SessionListRow>,+ children: HashMap<String, Vec<SessionMeta>>,+ child_counts: HashMap<String, i64>,+ expanded: HashSet<String>,groups: Vec<SessionGroup>,grouped_on: NaiveDate,sort: SortKey,@@ -283,15 +297,20 @@ impl SessionsDelegate {ascending: bool,grouped_on: NaiveDate,) -> Self {- let groups = build_session_groups_at(&sessions, sort, ascending, grouped_on);- Self {+ let mut delegate = Self {sessions,- groups,+ rows: Vec::new(),+ children: HashMap::new(),+ child_counts: HashMap::new(),+ expanded: HashSet::new(),+ groups: Vec::new(),grouped_on,sort,ascending,pagination: None,- }+ };+ delegate.rebuild_rows_at(grouped_on);+ delegate}fn paged(@@ -300,7 +319,13 @@ impl SessionsDelegate {total: i64,store: Arc<Store>,) -> Self {+ let child_counts = if filter.roots_only {+ store.child_counts(&filter).unwrap_or_default()+ } else {+ HashMap::new()+ };let mut delegate = Self::new(sessions, filter.sort, filter.ascending);+ delegate.child_counts = child_counts;delegate.pagination = Some(SessionPagination {store,total: total.max(0),@@ -310,12 +335,55 @@ impl SessionsDelegate {loading: false,failed: false,});+ delegate.rebuild_rows();delegate}- fn rebuild_groups(&mut self) {- let today = Local::now().date_naive();- self.groups = build_session_groups_at(&self.sessions, self.sort, self.ascending, today);+ fn tree_mode(&self) -> bool {+ self.pagination+ .as_ref()+ .is_some_and(|page| page.filter.roots_only)+ }++ fn rebuild_rows(&mut self) {+ self.rebuild_rows_at(Local::now().date_naive());+ }++ fn rebuild_rows_at(&mut self, today: NaiveDate) {+ let tree_mode = self.tree_mode();+ let mut rows = Vec::new();+ for root in &self.sessions {+ let child_count = if tree_mode {+ self.child_counts.get(&root.key).copied().unwrap_or(0)+ } else {+ 0+ };+ let expanded = child_count > 0 && self.expanded.contains(&root.key);+ let group_timestamp = session_group_timestamp(root, self.sort);+ let group_pinned = root.pinned;+ rows.push(SessionListRow {+ meta: root.clone(),+ depth: 0,+ child_count,+ expanded,+ group_timestamp,+ group_pinned,+ });+ if expanded {+ if let Some(children) = self.children.get(&root.key) {+ rows.extend(children.iter().cloned().map(|child| SessionListRow {+ meta: child,+ depth: 1,+ child_count: 0,+ expanded: false,+ group_timestamp,+ group_pinned,+ }));+ }+ }+ }+ self.rows = rows;+ self.groups = build_row_groups_at(&self.rows, self.sort, self.ascending, today);self.grouped_on = today;}@@ -323,7 +391,7 @@ impl SessionsDelegate {if self.grouped_on == today {return false;}- let groups = build_session_groups_at(&self.sessions, self.sort, self.ascending, today);+ let groups = build_row_groups_at(&self.rows, self.sort, self.ascending, today);let changed = groups != self.groups;self.groups = groups;self.grouped_on = today;@@ -340,17 +408,93 @@ impl SessionsDelegate {page.into_iter().filter(|session| keys.insert(session.key.clone())),);- self.rebuild_groups();+ if let Some(pagination) = &self.pagination {+ if pagination.filter.roots_only {+ self.child_counts = pagination+ .store+ .child_counts(&pagination.filter)+ .unwrap_or_default();+ }+ }+ self.rebuild_rows();}- /// 把组件发出的分组坐标还原为 `sessions` 的平铺下标。+ fn restore_expanded(&mut self, expanded: HashSet<String>) {+ if !self.tree_mode() {+ return;+ }+ let root_keys: HashSet<&str> = self.sessions.iter().map(|root| root.key.as_str()).collect();+ self.expanded = expanded+ .into_iter()+ .filter(|key| root_keys.contains(key.as_str()))+ .collect();+ self.reload_expanded();+ }++ fn reload_expanded(&mut self) {+ let Some(pagination) = &self.pagination else {+ return;+ };+ let store = pagination.store.clone();+ let filter = pagination.filter.clone();+ self.children.clear();+ for key in &self.expanded {+ if let Ok(children) = store.list_children(key, &filter) {+ self.children.insert(key.clone(), children);+ }+ }+ self.rebuild_rows();+ }++ fn toggle(&mut self, key: &str) -> bool {+ if !self.tree_mode() || self.child_counts.get(key).copied().unwrap_or(0) == 0 {+ return false;+ }+ if self.expanded.remove(key) {+ self.children.remove(key);+ } else {+ let Some(pagination) = &self.pagination else {+ return false;+ };+ let Ok(children) = pagination.store.list_children(key, &pagination.filter) else {+ return false;+ };+ self.expanded.insert(key.to_string());+ self.children.insert(key.to_string(), children);+ }+ self.rebuild_rows();+ true+ }++ fn ensure_expanded(&mut self, key: &str) -> bool {+ if self.expanded.contains(key) {+ return true;+ }+ self.toggle(key)+ }++ fn row_index(&self, key: &str) -> Option<usize> {+ self.rows.iter().position(|row| row.meta.key == key)+ }++ fn row_key(&self, ix: IndexPath) -> Option<&str> {+ self.flat_index(ix)+ .and_then(|flat| self.rows.get(flat))+ .map(|row| row.meta.key.as_str())+ }++ fn row_has_children(&self, key: &str) -> bool {+ self.child_counts.get(key).copied().unwrap_or(0) > 0+ }++ /// 把组件发出的分组坐标还原为可见 `rows` 的平铺下标。fn flat_index(&self, ix: IndexPath) -> Option<usize> {let group = self.groups.get(ix.section)?;let flat = group.range.start.checked_add(ix.row)?;(flat < group.range.end).then_some(flat)}- /// 搜索跳转仍以 `sessions` 平铺下标定位;进入列表前转成分组坐标。+ /// 搜索/选择以可见 `rows` 平铺下标定位;进入列表前转成分组坐标。fn index_path(&self, flat: usize) -> Option<IndexPath> {self.groups.iter()@@ -381,85 +525,231 @@ impl ListDelegate for SessionsDelegate {cx: &mut Context<ListState<Self>>,) -> Option<Self::Item> {let flat_ix = self.flat_index(ix)?;- let s = self.sessions.get(flat_ix)?;+ let row = self.rows.get(flat_ix)?.clone();+ let s = &row.meta;let theme = cx.theme();let shown_ts = session_group_timestamp(s, self.sort);let shown_time: SharedString = smart_time(shown_ts).into();let shown_tooltip: SharedString = abs_date(shown_ts).into();let title_tooltip: SharedString = s.title.clone().into();- let icon_width = 3 * (usize::from(s.pinned) + usize::from(s.favorite));+ let show_chevron = self.tree_mode() && row.child_count > 0;+ let icon_width =+ 3 * (usize::from(s.pinned) + usize::from(s.favorite) + usize::from(show_chevron));let title: SharedString =clip_display(&s.title, SESSION_TITLE_MAX_WIDTH.saturating_sub(icon_width)).into();+ let key = s.key.clone();+ let open_key = key.clone();+ let toggle_key = key.clone();+ let child_count = row.child_count;+ let expanded = row.expanded;+ let depth = row.depth;+ let child_line_color = theme.muted_foreground.opacity(0.38);+ // 2px 线的中心与父行 15px Grok 图标的 11.5px 中轴一致。+ let child_line_left = SPACE_XS + px(6.5);Some(- ListItem::new(ix).rounded(theme.radius).mx(SPACE_SM).child(- v_flex()- .w_full()- .px(SPACE_XS)- .py(SPACE_SM)- .gap(SPACE_XS)- .child(- h_flex()- .gap(px(6.))- .child(+ // 稳定元素身份必须是 session key:展开插入孩子后,IndexPath 会整体+ // 位移;继续拿下标当 id 会复用到另一会话的点击状态。+ ListItem::new(SharedString::from(key.clone()))+ .rounded(theme.radius)+ .mx(SPACE_SM)+ .child(+ v_flex()+ .id(SharedString::from(format!("session-row:{key}")))+ .relative()+ .w_full()+ .px(SPACE_XS)+ .py(SPACE_SM)+ .gap(SPACE_XS)+ .when(depth > 0, |this| {+ this.pl(px(20.)).child(div()- .id(("session-title", flat_ix))- .flex_1()- .min_w_0()- .overflow_hidden()- .whitespace_nowrap()- .text_size(FONT_BODY)- .font_medium()- .text_color(theme.foreground)- .child(title)- .tooltip(move |window, cx| {- gpui_component::tooltip::Tooltip::new(title_tooltip.clone())- .build(window, cx)- }),+ .absolute()+ .left(child_line_left)+ .top(SPACE_SM)+ .bottom(SPACE_SM)+ .w(px(2.))+ .rounded_full()+ .bg(child_line_color),)- .when(s.pinned, |this| {- this.child(- icon("icons/pin-filled.svg")- .with_size(px(11.))- .text_color(theme.primary),+ })+ .on_mouse_down(+ MouseButton::Left,+ cx.listener(move |this, _, window, cx| {+ cx.stop_propagation();+ let Some(flat) = this.delegate().row_index(&open_key) else {+ return;+ };+ let Some(path) = this.delegate().index_path(flat) else {+ return;+ };+ let already_selected = this+ .selected_index()+ .and_then(|selected| this.delegate().row_key(selected))+ == Some(open_key.as_str());+ if already_selected && this.delegate().row_has_children(&open_key) {+ this.delegate_mut().toggle(&open_key);+ if let Some(new_path) = this+ .delegate()+ .row_index(&open_key)+ .and_then(|flat| this.delegate().index_path(flat))+ {+ this.set_selected_index(Some(new_path), window, cx);+ }+ cx.notify();+ return;+ }+ this.focus(window, cx);+ this.set_selected_index(Some(path), window, cx);+ cx.emit(ListEvent::Confirm(path));+ cx.notify();+ }),+ )+ .child(+ h_flex()+ .gap(px(6.))+ .when(show_chevron, |this| {+ this.child(+ div()+ .id(SharedString::from(format!(+ "session-expand:{toggle_key}"+ )))+ .size(px(16.))+ .flex_shrink_0()+ .flex()+ .items_center()+ .justify_center()+ .rounded(px(4.))+ .cursor_pointer()+ .hover(|style| style.bg(theme.muted))+ .on_mouse_down(+ MouseButton::Left,+ cx.listener(move |this, _, window, cx| {+ cx.stop_propagation();+ let selected_key = this+ .selected_index()+ .and_then(|selected| {+ this.delegate()+ .row_key(selected)+ .map(str::to_string)+ });+ if !this.delegate_mut().toggle(&toggle_key) {+ return;+ }+ let selected_path = selected_key+ .as_deref()+ .and_then(|key| {+ this.delegate().row_index(key).and_then(+ |flat| {+ this.delegate().index_path(flat)+ },+ )+ })+ .or_else(|| {+ this.delegate()+ .row_index(&toggle_key)+ .and_then(|flat| {+ this.delegate().index_path(flat)+ })+ });+ this.set_selected_index(+ selected_path,+ window,+ cx,+ );+ cx.notify();+ }),+ )+ .child(+ icon("icons/chevron-right.svg")+ .with_size(px(13.))+ .text_color(theme.muted_foreground)+ .when(expanded, |icon| {+ icon.rotate(Radians(+ std::f32::consts::FRAC_PI_2,+ ))+ }),+ ),+ )+ })+ .child(+ div()+ .id(("session-title", flat_ix))+ .flex_1()+ .min_w_0()+ .overflow_hidden()+ .whitespace_nowrap()+ .text_size(FONT_BODY)+ .font_medium()+ .text_color(theme.foreground)+ .child(title)+ .tooltip(move |window, cx| {+ gpui_component::tooltip::Tooltip::new(+ title_tooltip.clone(),+ )+ .build(window, cx)+ }),)- })- .when(s.favorite, |this| {- this.child(- icon("icons/star-filled.svg")- .with_size(px(11.))- .text_color(rgb(crate::theme::STAR_YELLOW)),+ .when(s.pinned, |this| {+ this.child(+ icon("icons/pin-filled.svg")+ .with_size(px(11.))+ .text_color(theme.primary),+ )+ })+ .when(s.favorite, |this| {+ this.child(+ icon("icons/star-filled.svg")+ .with_size(px(11.))+ .text_color(rgb(crate::theme::STAR_YELLOW)),+ )+ }),+ )+ .child(+ h_flex()+ .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(),)- }),- )- .child(- h_flex()- .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(),- )- .child(badge(- s.project_name.clone(),- theme.muted,- theme.muted_foreground,- ))- .child(div().flex_1())- .child(- div()- .id(("session-time", flat_ix))- .flex_shrink_0()- .child(shown_time)- .tooltip(move |window, cx| {- gpui_component::tooltip::Tooltip::new(shown_tooltip.clone())+ .child(badge(+ s.project_name.clone(),+ theme.muted,+ theme.muted_foreground,+ ))+ .when(show_chevron, |this| {+ this.child(+ div()+ .id(("session-child-count", flat_ix))+ .flex_shrink_0()+ .child(format!("{child_count}"))+ .tooltip(move |window, cx| {+ gpui_component::tooltip::Tooltip::new(format!(+ "{child_count} nested session{}",+ if child_count == 1 { "" } else { "s" }+ ))+ .build(window, cx)+ }),+ )+ })+ .child(div().flex_1())+ .child(+ div()+ .id(("session-time", flat_ix))+ .flex_shrink_0()+ .child(shown_time)+ .tooltip(move |window, cx| {+ gpui_component::tooltip::Tooltip::new(+ shown_tooltip.clone(),+ ).build(window, cx)- }),- ),- ),- ),+ }),+ ),+ ),+ ),)}@@ -566,19 +856,21 @@ impl ListDelegate for SessionsDelegate {mod session_group_tests {use std::collections::HashSet;use std::path::PathBuf;+ use std::sync::Arc;use chrono::{Local, NaiveDate, TimeZone as _};use gpui_component::IndexPath;use wake_core::adapters::AgentAdapter;+ use wake_core::db::Store;use wake_core::models::{AgentId, ParsedSession, ParsedTranscript, SessionFileRef, SessionFilter, SessionMeta,SortKey, ToolCallView,};use super::{- build_session_groups_at, clip_tool_text, load_visible_transcript, non_blank_tool_text,- same_session_query, session_group_label, session_matches_filter, toggle_expanded_row,- tool_cluster_heading, visible_git_branch, SessionsDelegate, SESSION_PAGE_SIZE,+ clip_tool_text, load_visible_transcript, non_blank_tool_text, same_session_query,+ session_group_label, session_matches_filter, toggle_expanded_row, tool_cluster_heading,+ visible_git_branch, SessionsDelegate, SESSION_PAGE_SIZE,};struct FailingAdapter;@@ -688,12 +980,13 @@ mod session_group_tests {session("week", local_ms(2026, 8, 31), false),session("month", local_ms(2026, 8, 30), false),];- let groups = build_session_groups_at(- &sessions,+ let delegate = SessionsDelegate::new_at(+ sessions,SortKey::Updated,false,NaiveDate::from_ymd_opt(2026, 9, 2).unwrap(),);+ let groups = &delegate.groups;let labels: Vec<&str> = groups.iter().map(|group| group.label.as_ref()).collect();assert_eq!(@@ -709,14 +1002,6 @@ mod session_group_tests {assert_eq!(groups[0].range, 0..1);assert_eq!(groups[3].range, 3..4);- let delegate = SessionsDelegate {- sessions,- groups,- grouped_on: NaiveDate::from_ymd_opt(2026, 9, 2).unwrap(),- sort: SortKey::Updated,- ascending: false,- pagination: None,- };assert_eq!(delegate.flat_index(IndexPath::new(0).section(3)), Some(3));assert_eq!(delegate.index_path(4), Some(IndexPath::new(0).section(4)));}@@ -728,12 +1013,13 @@ mod session_group_tests {session("two", local_ms(2026, 9, 1), false),];for (sort, ascending) in [(SortKey::Messages, false), (SortKey::Updated, true)] {- let groups = build_session_groups_at(- &sessions,+ let delegate = SessionsDelegate::new_at(+ sessions.clone(),sort,ascending,NaiveDate::from_ymd_opt(2026, 9, 2).unwrap(),);+ let groups = &delegate.groups;assert_eq!(groups.len(), 1);assert!(groups[0].label.is_empty());assert_eq!(groups[0].range, 0..2);@@ -756,6 +1042,59 @@ mod session_group_tests {assert_eq!(delegate.index_path(1), Some(IndexPath::new(1)));}+ #[test]+ fn tree_delegate_expands_children_without_changing_root_pagination() {+ let temp = tempfile::tempdir().unwrap();+ let store = Arc::new(Store::open(&temp.path().join("tree.db")).unwrap());+ let mut parent = session("grok:parent", local_ms(2026, 9, 1), false);+ parent.agent = AgentId::Grok;+ parent.file_path = "/tmp/grok/parent/updates.jsonl".into();+ let mut child = session("grok:child", local_ms(2026, 9, 2), false);+ child.agent = AgentId::Grok;+ child.file_path = "/tmp/grok/child/updates.jsonl".into();+ let mut other = session("grok:other", local_ms(2026, 8, 31), false);+ other.agent = AgentId::Grok;+ other.file_path = "/tmp/grok/other/updates.jsonl".into();+ store+ .write_meta_only(&[+ (parent.clone(), parent.updated_at),+ (child.clone(), child.updated_at),+ (other.clone(), other.updated_at),+ ])+ .unwrap();+ store+ .replace_parent_links(AgentId::Grok, &[(child.key.clone(), parent.key.clone())])+ .unwrap();+ let filter = SessionFilter {+ roots_only: true,+ sort: SortKey::Messages,+ limit: SESSION_PAGE_SIZE,+ ..Default::default()+ };+ let (roots, total) = store.list_sessions(&filter).unwrap();+ let mut delegate = SessionsDelegate::paged(roots, filter, total, store);++ assert_eq!(delegate.sessions.len(), 2);+ assert_eq!(delegate.rows.len(), 2);+ assert_eq!(delegate.rows[0].child_count, 1);+ assert_eq!(delegate.row_index(&other.key), Some(1));+ assert!(delegate.toggle(&parent.key));+ assert_eq!(+ delegate.sessions.len(),+ 2,+ "children must not advance pagination"+ );+ assert_eq!(delegate.rows.len(), 3);+ assert_eq!(delegate.rows[0].meta.key, parent.key);+ assert_eq!(delegate.rows[1].meta.key, child.key);+ assert_eq!(delegate.rows[1].depth, 1);+ assert_eq!(delegate.index_path(1), Some(IndexPath::new(1)));+ assert_eq!(delegate.row_index(&other.key), Some(2));+ assert!(delegate.toggle(&parent.key));+ assert_eq!(delegate.rows.len(), 2);+ assert_eq!(delegate.row_index(&other.key), Some(1));+ }+#[test]fn date_change_rebuilds_groups_and_stable_indexes() {let september_second = NaiveDate::from_ymd_opt(2026, 9, 2).unwrap();@@ -1750,6 +2089,7 @@ impl Workbench {project_path: self.selected_project.clone(),favorite_only: self.favorite_only,include_archived: false,+ roots_only: !self.favorite_only,title_query: None,sort: self.sort_key,ascending: self.sort_ascending,@@ -1762,9 +2102,8 @@ impl Workbench {let list = self.list_state.read(cx);let delegate = list.delegate();list.selected_index()- .and_then(|path| delegate.flat_index(path))- .and_then(|flat| delegate.sessions.get(flat))- .map(|session| session.key.clone())+ .and_then(|path| delegate.row_key(path))+ .map(str::to_string)}fn refresh(&mut self, cx: &mut Context<Self>) {@@ -1783,6 +2122,7 @@ impl Workbench {.map(|_| delegate.sessions.len()).unwrap_or_default()};+ let expanded = self.list_state.read(cx).delegate().expanded.clone();if previously_loaded > SESSION_PAGE_SIZE as usize {filter.limit = i64::try_from(previously_loaded).unwrap_or(i64::MAX);}@@ -1790,7 +2130,9 @@ impl Workbench {self.total_sessions = total;let store = self.store.clone();self.list_state.update(cx, |state, cx| {- *state.delegate_mut() = SessionsDelegate::paged(sessions, filter, total, store);+ let mut delegate = SessionsDelegate::paged(sessions, filter, total, store);+ delegate.restore_expanded(expanded);+ *state.delegate_mut() = delegate;cx.notify();});self.pending_list_selection = selected_key;@@ -2807,12 +3149,18 @@ impl Workbench {let key = {let list = list.read(cx);let delegate = list.delegate();- delegate- .flat_index(ix)- .and_then(|flat| delegate.sessions.get(flat))- .map(|session| session.key.clone())+ delegate.row_key(ix).map(str::to_string)};if let Some(key) = key {+ if matches!(ev, ListEvent::Confirm(_))+ && self+ .detail+ .as_ref()+ .is_some_and(|detail| detail.meta.key == key)+ && self.toggle_list_key(&key, window, cx)+ {+ return;+ }// 用户手动选择优先于尚未完成的搜索定位,避免旧任务稍后抢回高亮。self._list_seek_task = None;self.open_detail(&key, None, window, cx);@@ -3209,9 +3557,15 @@ impl Workbench {)};let (generation, mut filter, mut offset, mut total) = request;+ let root_key = if filter.roots_only {+ self.visible_parent_key(key)+ .unwrap_or_else(|| key.to_string())+ } else {+ key.to_string()+ };if !self.store- .get_session(key)+ .get_session(&root_key).ok().flatten().is_some_and(|session| session_matches_filter(&session, &filter))@@ -3220,7 +3574,7 @@ impl Workbench {}let store = self.store.clone();let key = key.to_string();- let wanted_key = key.clone();+ let wanted_key = root_key.clone();let query = cx.background_spawn(async move {let mut loaded = Vec::new();let mut found = false;@@ -3280,30 +3634,80 @@ impl Workbench {window: &mut Window,cx: &mut Context<Self>,) -> bool {- let path = {- let list = self.list_state.read(cx);- let delegate = list.delegate();- delegate- .sessions- .iter()- .position(|session| session.key == key)- .and_then(|flat| delegate.index_path(flat))- };+ let parent_key = self+ .list_state+ .read(cx)+ .delegate()+ .tree_mode()+ .then(|| self.visible_parent_key(key))+ .flatten();self.list_state.update(cx, |state, cx| {+ if state.delegate().row_index(key).is_none() {+ if let Some(parent) = parent_key.as_deref() {+ if state.delegate().row_index(parent).is_some() {+ state.delegate_mut().ensure_expanded(parent);+ }+ }+ }+ let path = state+ .delegate()+ .row_index(key)+ .and_then(|flat| state.delegate().index_path(flat));state.set_selected_index(path, window, cx);if scroll {- let Some(path) = path else { return };- // 组件无 strict-Top:非 Center 策略都是"最小滚动恰好可见",- // 目标从下方进入会贴底。先把 offset 拉到超底,deferred 消费时- // 目标位于视口上方,最小滚动分支即把它对齐到视口顶。- // 耦合 gpui-component 0.5.1 行为;上游 DeferredScrollToItem 的- // scroll_strict 字段目前写死 false 未被读——它被接通之日,- // 换成 strict-Top 调用并删掉这行 set_offset- state.scroll_handle().set_offset(point(px(0.), px(-1e9)));- state.scroll_to_item(path, ScrollStrategy::Top, window, cx);+ if let Some(path) = path {+ // 组件无 strict-Top:非 Center 策略都是"最小滚动恰好可见",+ // 目标从下方进入会贴底。先把 offset 拉到超底,deferred 消费时+ // 目标位于视口上方,最小滚动分支即把它对齐到视口顶。+ // 耦合 gpui-component 0.5.1 行为;上游 DeferredScrollToItem 的+ // scroll_strict 字段目前写死 false 未被读——它被接通之日,+ // 换成 strict-Top 调用并删掉这行 set_offset+ state.scroll_handle().set_offset(point(px(0.), px(-1e9)));+ state.scroll_to_item(path, ScrollStrategy::Top, window, cx);+ }}- });- path.is_some()+ path.is_some()+ })+ }++ fn visible_parent_key(&self, key: &str) -> Option<String> {+ let parent_key = self.store.parent_key_of(key).ok().flatten()?;+ self.store+ .get_session(&parent_key)+ .ok()+ .flatten()+ .filter(|parent| !parent.archived)+ .map(|_| parent_key)+ }++ /// 展开/收起后按 session key 恢复选择,避免插入的子行让 IndexPath 漂到+ /// 下一条会话。若被收起的正是已选子会话,则选择回父会话。+ fn toggle_list_key(&mut self, key: &str, window: &mut Window, cx: &mut Context<Self>) -> bool {+ self.list_state.update(cx, |state, cx| {+ if !state.delegate().row_has_children(key) {+ return false;+ }+ let selected_key = state+ .selected_index()+ .and_then(|path| state.delegate().row_key(path))+ .map(str::to_string);+ if !state.delegate_mut().toggle(key) {+ return false;+ }+ let selected_path = selected_key+ .as_deref()+ .and_then(|selected| state.delegate().row_index(selected))+ .and_then(|flat| state.delegate().index_path(flat))+ .or_else(|| {+ state+ .delegate()+ .row_index(key)+ .and_then(|flat| state.delegate().index_path(flat))+ });+ state.set_selected_index(selected_path, window, cx);+ cx.notify();+ true+ })}// ---------- 操作 ----------@@ -3407,25 +3811,41 @@ impl Workbench {/// 否则界面在授权框弹出的整段时间里完全冻结。fn do_delete(&mut self,- key: String,+ keys: Vec<String>,targets: Vec<String>,window: &mut Window,cx: &mut Context<Self>,) {let store = self.store.clone();- let trash_key = key.clone();+ let trash_keys = keys.clone();+ let count = keys.len();let task = cx.background_spawn(async move {- terminal::trash_paths(&targets).and_then(|()| store.remove_session(&trash_key, true))+ terminal::trash_paths(&targets)?;+ store.remove_sessions(&trash_keys, true)});cx.spawn_in(window, async move |this, cx| {let result = task.await;this.update_in(cx, |this, window, cx| match result {Ok(()) => {- // 等待期间用户可能已翻到别的会话,只在仍停在被删那条时才清空- if this.detail.as_ref().is_some_and(|d| d.meta.key == key) {+ // 等待期间用户可能已翻到别的会话,只在仍停在被删子树时清空。+ if this+ .detail+ .as_ref()+ .is_some_and(|detail| keys.iter().any(|key| key == &detail.meta.key))+ {this.detail = None;}- window.push_notification(Notification::success(SESSION_TRASHED), cx);+ let message = if count == 1 {+ SESSION_TRASHED.to_string()+ } else {+ format!(+ "{count} sessions {}",+ SESSION_TRASHED+ .strip_prefix("Session ")+ .unwrap_or(SESSION_TRASHED)+ )+ };+ window.push_notification(Notification::success(message), cx);// 立刻把它从列表摘掉,不等 watcher 那 800ms 去抖this.refresh(cx);}@@ -3441,13 +3861,28 @@ impl Workbench {fn confirm_delete(&mut self, window: &mut Window, cx: &mut Context<Self>) {let Some(detail) = &self.detail else { return };let meta = detail.meta.clone();- // 会话归属哪些磁盘路径(主文件/边车目录)是 adapter 的布局知识- 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 mut sessions = vec![meta.clone()];+ sessions.extend(self.store.all_descendants(&meta.key).unwrap_or_default());+ let nested_count = sessions.len().saturating_sub(1);+ let keys: Vec<String> = sessions.iter().map(|session| session.key.clone()).collect();+ // 每个子会话按自己的胜出 file_path 找 adapter;多 location 下不能沿用+ // 根会话所属实例。磁盘目标保持稳定顺序并去重。+ let mut seen_targets = HashSet::new();+ let mut targets = Vec::new();+ for session in &sessions {+ let paths = adapter_for(&self.adapters, session.agent, &session.file_path)+ .map(|adapter| adapter.session_paths(session))+ .unwrap_or_else(|| vec![session.file_path.clone()]);+ for path in paths {+ if seen_targets.insert(path.clone()) {+ targets.push(path);+ }+ }+ }let entity = cx.entity();window.open_alert_dialog(cx, move |dialog, _window, cx| {let meta = meta.clone();+ let keys = keys.clone();let targets = targets.clone();let entity = entity.clone();let theme = cx.theme();@@ -3456,7 +3891,11 @@ impl Workbench {div().text_size(FONT_HEADING).font_semibold()- .child("Delete this session?"),+ .child(if nested_count > 0 {+ "Delete this session tree?"+ } else {+ "Delete this session?"+ }),).width(px(440.))// 破坏性确认:主按钮点名动作并用 danger 形态,不留裸 "OK"。@@ -3472,7 +3911,15 @@ impl Workbench {v_flex().gap(SPACE_SM).text_size(FONT_BODY)- .child(TRASH_CONFIRM_BODY)+ .child(if nested_count > 0 {+ format!(+ "This session and {nested_count} nested session{} will be moved to {}. You can restore them anytime:",+ if nested_count == 1 { "" } else { "s" },+ if cfg!(target_os = "windows") { "the Recycle Bin" } else { "Trash" },+ )+ } else {+ TRASH_CONFIRM_BODY.to_string()+ }).child(div().px(SPACE_SM)@@ -3497,7 +3944,7 @@ impl Workbench {).on_ok(move |_, window, cx| {entity.update(cx, |this, cx| {- this.do_delete(meta.key.clone(), targets.clone(), window, cx);+ this.do_delete(keys.clone(), targets.clone(), window, cx);});true})@@ -3840,7 +4287,7 @@ impl Workbench {fn render_session_list(&self, cx: &Context<Self>) -> impl IntoElement {let theme = cx.theme();- let shown = self.list_state.read(cx).delegate().sessions.len();+ let shown = self.list_state.read(cx).delegate().rows.len();let library_empty = self.agent_counts.iter().map(|(_, n)| *n).sum::<i64>() == 0;let listed_count = self.total_sessions.max(0);let shown_label: SharedString = format!(