Skip to content

armgit / Wake

Public Imported from GitHub
0

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.md
index 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 blocks
diff --git a/Cargo.lock b/Cargo.lock
index 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.md
index 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.rs
index 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.rs
new file mode 100644
index 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(&current) 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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!(adapter
diff --git a/crates/wake-core/tests/db_roundtrip.rs b/crates/wake-core/tests/db_roundtrip.rs
index 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.json
new file mode 100644
index 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.rs
index 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.toml
index 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/target
diff --git a/crates/wake/src/workbench.rs b/crates/wake/src/workbench.rs
index 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!(