All your AI agent sessions in one place — browse, search, resume. Rust + GPUI.
Rust
//! Local session cleanup: immutable review plans, conservative ownership checks,
//! per-target Trash results and a durable journal. No source database writes.
use crate::{
adapters::{adapter_for, child_outlives_parent, AgentAdapter},
db::{put_back_fingerprint, Store, Tombstone},
models::*,
scanner::{copy_order, scan_files, NullEvents, RootOwners},
services::terminal,
};
use anyhow::{bail, ensure, Context, Result};
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
use std::{
collections::{BTreeMap, BTreeSet, HashMap, HashSet},
io::Read,
path::{Path, PathBuf},
sync::{
atomic::{AtomicBool, Ordering},
Arc,
},
time::UNIX_EPOCH,
};
pub const DAY: i64 = 86_400_000;
pub const PREFS: &str = "cleanup.options.v1";
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
pub enum CleanupSort {
Created,
Updated,
#[default]
Size,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
pub enum TimeField {
Created,
#[default]
Updated,
}
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(from = "SavedCleanupOptions")]
pub struct CleanupOptions {
pub sort: CleanupSort,
/// Old preferences used ascending dates and descending size, with no direction field.
pub ascending: Option<bool>,
pub created_days: i64,
pub updated_days: i64,
/// Empty source sets mean unrestricted; values within each set are ORed.
pub agents: BTreeSet<AgentId>,
pub projects: BTreeSet<String>,
pub exclude_starred: bool,
pub exclude_pinned: bool,
pub only_cleanable: bool,
}
impl Default for CleanupOptions {
fn default() -> Self {
Self {
sort: CleanupSort::Size,
ascending: None,
created_days: 0,
updated_days: 30,
agents: BTreeSet::new(),
projects: BTreeSet::new(),
exclude_starred: false,
exclude_pinned: false,
only_cleanable: false,
}
}
}
/// The original single-date filter is read only for migration. New preferences
/// always save both dates, including explicit zeroes for unrestricted dates.
#[derive(Default, Deserialize)]
#[serde(default)]
struct SavedCleanupOptions {
sort: CleanupSort,
ascending: Option<bool>,
created_days: Option<i64>,
updated_days: Option<i64>,
time: TimeField,
days: Option<i64>,
agents: Option<BTreeSet<AgentId>>,
projects: Option<BTreeSet<String>>,
// Legacy single-source preferences, used only when the new sets are absent.
agent: Option<AgentId>,
project: Option<String>,
exclude_starred: bool,
exclude_pinned: bool,
only_cleanable: bool,
}
impl From<SavedCleanupOptions> for CleanupOptions {
fn from(saved: SavedCleanupOptions) -> Self {
let age = |days, fallback| {
if [0, 30, 90, 180, 365].contains(&days) {
days
} else {
fallback
}
};
let (created_days, updated_days) =
if saved.created_days.is_some() || saved.updated_days.is_some() {
(
age(saved.created_days.unwrap_or(0), 0),
age(saved.updated_days.unwrap_or(0), 30),
)
} else {
let days = age(saved.days.unwrap_or(30), 30);
match saved.time {
TimeField::Created => (days, 0),
TimeField::Updated => (0, days),
}
};
Self {
sort: saved.sort,
ascending: saved.ascending,
created_days,
updated_days,
agents: saved
.agents
.unwrap_or_else(|| saved.agent.into_iter().collect()),
projects: saved
.projects
.unwrap_or_else(|| saved.project.into_iter().collect()),
exclude_starred: saved.exclude_starred,
exclude_pinned: saved.exclude_pinned,
only_cleanable: saved.only_cleanable,
}
}
}
impl CleanupOptions {
pub fn sort_ascending(&self) -> bool {
self.ascending.unwrap_or(self.sort != CleanupSort::Size)
}
pub fn matches(&self, item: &CleanupCandidate, now: i64) -> bool {
self.matches_metadata(&item.root, item.updated_at, &item.sessions, now)
}
fn matches_metadata(
&self,
root: &SessionMeta,
updated_at: i64,
sessions: &[SessionMeta],
now: i64,
) -> bool {
let older_than = |ts, days| days == 0 || (ts > 0 && ts <= now - days * DAY);
older_than(root.created_at, self.created_days)
&& older_than(updated_at, self.updated_days)
&& (!self.exclude_starred || !sessions.iter().any(|s| s.favorite))
&& (!self.exclude_pinned || !sessions.iter().any(|s| s.pinned))
&& (self.agents.is_empty() || self.agents.contains(&root.agent))
&& (self.projects.is_empty() || self.projects.contains(&root.project_path))
}
pub fn matches_entry(&self, item: &CleanupEntry, now: i64) -> bool {
match item {
CleanupEntry::Available(candidate) => self.matches(candidate, now),
CleanupEntry::Unavailable(item) => {
!self.only_cleanable
&& self.matches_metadata(&item.session, item.updated_at(), &item.sessions, now)
}
}
}
pub fn sort_entries(&self, items: &mut [CleanupEntry]) {
let value = |entry: &CleanupEntry| match self.sort {
CleanupSort::Created => {
(entry.session().created_at > 0).then_some(i128::from(entry.session().created_at))
}
CleanupSort::Updated => {
(entry.updated_at() > 0).then_some(i128::from(entry.updated_at()))
}
CleanupSort::Size => entry.candidate().map(|c| i128::from(c.bytes)),
};
items.sort_by(|a, b| {
let order = match (value(a), value(b)) {
(Some(a), Some(b)) if self.sort_ascending() => a.cmp(&b),
(Some(a), Some(b)) => b.cmp(&a),
// Unknown values remain last in either direction.
(Some(_), None) => std::cmp::Ordering::Less,
(None, Some(_)) => std::cmp::Ordering::Greater,
(None, None) => std::cmp::Ordering::Equal,
};
order.then_with(|| a.session().key.cmp(&b.session().key))
});
}
pub fn sort(&self, items: &mut [CleanupCandidate]) {
items.sort_by(|a, b| {
let order = match self.sort {
CleanupSort::Created => a.root.created_at.cmp(&b.root.created_at),
CleanupSort::Updated => a.updated_at.cmp(&b.updated_at),
CleanupSort::Size => a.bytes.cmp(&b.bytes),
};
(if self.sort_ascending() {
order
} else {
order.reverse()
})
.then_with(|| a.root.key.cmp(&b.root.key))
});
}
}
pub struct IndexedSession {
pub meta: SessionMeta,
pub parent: String,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct FileStamp {
pub path: PathBuf,
pub bytes: u64,
pub logical_bytes: u64,
pub modified: u64,
pub identity: (u64, u64),
/// Upper half of Windows' 128-bit file ID (needed on ReFS).
#[serde(default)]
pub identity_high: u64,
pub directory: bool,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CleanupTarget {
pub path: PathBuf,
pub files: Vec<FileStamp>,
}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct CleanupCandidate {
pub root: SessionMeta,
pub sessions: Vec<SessionMeta>,
pub targets: Vec<CleanupTarget>,
pub updated_at: i64,
pub bytes: u64,
pub prompts: i64,
pub empty: bool,
}
impl CleanupCandidate {
pub fn has_starred(&self) -> bool {
self.sessions.iter().any(|s| s.favorite)
}
pub fn has_pinned(&self) -> bool {
self.sessions.iter().any(|s| s.pinned)
}
}
#[derive(Clone)]
pub struct UnavailableSession {
pub session: SessionMeta,
/// Known tree members, used only for filtering and display.
pub sessions: Vec<SessionMeta>,
pub reason: String,
}
impl UnavailableSession {
pub fn updated_at(&self) -> i64 {
self.sessions
.iter()
.map(|s| s.updated_at)
.max()
.unwrap_or(self.session.updated_at)
}
}
#[derive(Clone)]
pub enum CleanupEntry {
Available(CleanupCandidate),
Unavailable(UnavailableSession),
}
impl CleanupEntry {
pub fn session(&self) -> &SessionMeta {
match self {
Self::Available(c) => &c.root,
Self::Unavailable(item) => &item.session,
}
}
pub fn updated_at(&self) -> i64 {
match self {
Self::Available(c) => c.updated_at,
Self::Unavailable(item) => item.updated_at(),
}
}
pub fn candidate(&self) -> Option<&CleanupCandidate> {
match self {
Self::Available(c) => Some(c),
Self::Unavailable(_) => None,
}
}
}
#[derive(Default)]
pub struct CleanupInventory {
pub candidates: Vec<CleanupCandidate>,
pub unavailable: Vec<UnavailableSession>,
}
#[derive(Default)]
pub struct CleanupReview {
pub ready: Vec<CleanupCandidate>,
pub skipped: Vec<UnavailableSession>,
}
/// Check every selected tree without moving files. A failed tree does not hide
/// the review of the remaining selection; the UI must present both groups.
/// Cancellation discards the entire review, so a partial check cannot be confirmed.
pub fn review(
store: &Store,
adapters: &[Box<dyn AgentAdapter>],
chosen: Vec<CleanupCandidate>,
cancel: &AtomicBool,
mut progress: impl FnMut(usize),
) -> Option<CleanupReview> {
let mut result = CleanupReview::default();
for (i, candidate) in chosen.into_iter().enumerate() {
if cancel.load(Ordering::Relaxed) {
return None;
}
match revalidate(store, adapters, &candidate) {
Ok(()) => result.ready.push(candidate),
Err(error) => result.skipped.push(UnavailableSession {
session: candidate.root,
sessions: candidate.sessions,
reason: error.to_string(),
}),
}
progress(i + 1);
}
(!cancel.load(Ordering::Relaxed)).then_some(result)
}
fn stamp(path: &Path) -> Result<FileStamp> {
#[cfg(windows)]
let crate::services::windows_fs::FileSnapshot {
metadata: m,
bytes,
identity,
identity_high,
} = crate::services::windows_fs::snapshot(path)?;
#[cfg(not(windows))]
let m = std::fs::symlink_metadata(path)?;
ensure!(
!m.file_type().is_symlink(),
"Symbolic links are not supported"
);
ensure!(m.is_file() || m.is_dir(), "Not a regular file or directory");
let modified = u64::try_from(m.modified()?.duration_since(UNIX_EPOCH)?.as_nanos())?;
#[cfg(unix)]
let (bytes, identity) = {
use std::os::unix::fs::MetadataExt;
ensure!(
!m.is_file() || m.nlink() == 1,
"Shared hard links are not supported"
);
(
if m.is_file() { m.blocks() * 512 } else { 0 },
(m.dev(), m.ino()),
)
};
Ok(FileStamp {
path: path.to_path_buf(),
bytes,
logical_bytes: m.len(),
modified,
identity,
#[cfg(windows)]
identity_high,
#[cfg(not(windows))]
identity_high: 0,
directory: m.is_dir(),
})
}
fn target(path: &Path) -> Result<CleanupTarget> {
// Canonical equality rejects links in ancestors as well as the target itself.
ensure!(
path.is_absolute() && same_canonical_path(path, &path.canonicalize()?),
"Source path contains links or is not absolute"
);
let mut files = vec![];
for entry in walkdir::WalkDir::new(path).follow_links(false) {
files.push(stamp(entry?.path())?);
}
files.sort_by(|a, b| a.path.cmp(&b.path));
Ok(CleanupTarget {
path: path.to_path_buf(),
files,
})
}
#[cfg(not(windows))]
fn same_canonical_path(path: &Path, canonical: &Path) -> bool {
path == canonical
}
#[cfg(windows)]
fn same_canonical_path(path: &Path, canonical: &Path) -> bool {
use std::path::{Component, Prefix};
fn normalize(prefix: Prefix<'_>) -> Prefix<'_> {
match prefix {
Prefix::VerbatimDisk(drive) => Prefix::Disk(drive),
Prefix::VerbatimUNC(server, share) => Prefix::UNC(server, share),
other => other,
}
}
// Windows canonicalize adds an extended-length prefix even without links.
// Only normalize that prefix; a different ancestor or filename still fails.
let mut original = path.components();
let mut resolved = canonical.components();
match (original.next(), resolved.next()) {
(Some(Component::Prefix(a)), Some(Component::Prefix(b))) => {
normalize(a.kind()) == normalize(b.kind()) && original.eq(resolved)
}
_ => false,
}
}
fn supported_adapter<'a>(
adapters: &'a [Box<dyn AgentAdapter>],
meta: &SessionMeta,
) -> Result<&'a dyn AgentAdapter> {
ensure!(meta.host.is_empty(), "Remote sessions are read-only");
let a = adapter_for(adapters, meta.agent, &meta.file_path).context("Source is not enabled")?;
ensure!(a.host().is_empty(), "Remote mirrors are read-only");
ensure!(
a.cleanup_paths(meta).is_some(),
"This source does not support independent file cleanup"
);
let p = Path::new(&meta.file_path);
ensure!(
a.data_roots()
.iter()
.any(|r| r.is_dir() && p.starts_with(r) && p != r),
"Source is outside the enabled location"
);
Ok(a)
}
/// File ownership and metadata needed for deletion, without display statistics.
struct CleanupPlan {
sessions: Vec<SessionMeta>,
targets: Vec<CleanupTarget>,
}
/// 清理用的会话索引。分支——所在的家声明子会话是自己完整的对话(`child_outlives_parent`,
/// Claude Code 的 fork)——在这里就摘掉父会话:它自成一棵清理树,单独列、单独清,也不随父
/// 会话一起清;子代理、子任务照旧是父会话树的一部分
fn cleanup_index(store: &Store, adapters: &[Box<dyn AgentAdapter>]) -> Result<Vec<IndexedSession>> {
let mut index = store.cleanup_index()?;
for s in &mut index {
if !s.parent.is_empty() && child_outlives_parent(adapters, &s.meta) {
s.parent.clear();
}
}
Ok(index)
}
/// 套在别的路径里的不单列、重复的只留一份(父会话的目录里装着它派出去的子代理的转录:先移走
/// 外层,再移里面那份就找不着了)。详情页删除与 Clean Up 共用
pub fn outermost(paths: impl IntoIterator<Item = PathBuf>) -> Vec<PathBuf> {
let mut paths: Vec<PathBuf> = paths.into_iter().collect();
paths.sort();
paths.dedup();
let mut roots: Vec<PathBuf> = vec![];
for path in paths {
if !roots.iter().any(|p| path.starts_with(p)) {
roots.push(path);
}
}
roots
}
/// 详情页删一条会话:随它一起删的子会话与要移进废纸篓的路径
pub struct DeletePlan {
/// 第一条是要删的那条会话
pub sessions: Vec<SessionMeta>,
/// `session_paths` 的并集,套在别的目标里的不单列(`outermost`)
pub targets: Vec<String>,
/// 留下来的分支有几条
pub kept_branches: usize,
}
/// 删一条会话时一起删什么:子代理、子任务随父会话走;分支(`child_outlives_parent`)连同挂在它
/// 下面的会话留下——它是自己完整的对话,原件没了变回顶层会话(Clean Up 的 `cleanup_index` 同一条
/// 规矩)。每条子会话按自己的胜出文件找实例:多 location 下不能沿用根会话所属的那个
pub fn delete_plan(
store: &Store,
adapters: &[Box<dyn AgentAdapter>],
root: &SessionMeta,
) -> Result<DeletePlan> {
let tree = store.all_descendants(&root.key)?;
let mut children: HashMap<&str, Vec<&IndexedSession>> = HashMap::new();
for s in &tree {
children.entry(s.parent.as_str()).or_default().push(s);
}
let mut sessions = vec![root.clone()];
let mut seen = HashSet::from([root.key.clone()]);
let mut kept_branches = 0;
let mut cursor = 0;
while cursor < sessions.len() {
let parent = sessions[cursor].key.clone();
for child in children.get(parent.as_str()).into_iter().flatten() {
if child_outlives_parent(adapters, &child.meta) {
kept_branches += 1;
} else if seen.insert(child.meta.key.clone()) {
sessions.push(child.meta.clone());
}
}
cursor += 1;
}
let paths = sessions.iter().flat_map(|s| {
adapter_for(adapters, s.agent, &s.file_path)
.map(|adapter| adapter.session_paths(s))
.unwrap_or_else(|| vec![s.file_path.clone()])
});
let targets = outermost(paths.map(PathBuf::from))
.into_iter()
.map(|p| p.to_string_lossy().into_owned())
.collect();
Ok(DeletePlan {
sessions,
targets,
kept_branches,
})
}
fn build_plan(
root: &IndexedSession,
index: &[IndexedSession],
adapters: &[Box<dyn AgentAdapter>],
ownership: &HashMap<String, Vec<PathBuf>>,
) -> Result<CleanupPlan> {
let mut members = vec![root];
let mut keys = HashSet::from([root.meta.key.as_str()]);
let mut cursor = 0;
while cursor < members.len() {
let parent = members[cursor].meta.key.clone();
for child in index.iter().filter(|s| s.parent == parent) {
ensure!(
keys.insert(child.meta.key.as_str()),
"Session tree contains a cycle"
);
members.push(child);
}
cursor += 1;
}
let mut paths = vec![];
for item in &members {
let m = &item.meta;
terminal::validate_trash_path(Path::new(&m.file_path))?;
let a = supported_adapter(adapters, m)?;
let owned = a
.cleanup_paths(m)
.context("This source does not support independent file cleanup")?;
ensure!(!owned.is_empty(), "No independently owned files");
for p in owned {
let p = PathBuf::from(p);
terminal::validate_trash_path(&p)?;
ensure!(
a.data_roots().iter().any(|r| p.starts_with(r) && p != *r),
"Cleanup target is outside the source location"
);
ensure!(
std::fs::symlink_metadata(&p).is_ok(),
"Source file is missing"
);
paths.push(p);
}
}
let roots = outermost(paths);
for other in index.iter().filter(|s| !keys.contains(s.meta.key.as_str())) {
ensure!(
!roots
.iter()
.any(|p| Path::new(&other.meta.file_path).starts_with(p)),
"Target also contains another session"
);
// Sessions outside the current filter still own all of their sidecars.
if let Some(paths) = ownership.get(&other.meta.key) {
ensure!(
!paths.iter().any(|shared| roots
.iter()
.any(|p| shared.starts_with(p) || p.starts_with(shared))),
"Shared cleanup target"
);
}
}
let targets = roots
.iter()
.map(|p| target(p))
.collect::<Result<Vec<_>>>()?;
Ok(CleanupPlan {
sessions: members.iter().map(|s| s.meta.clone()).collect(),
targets,
})
}
fn inventory_candidate(
root: &SessionMeta,
plan: CleanupPlan,
prompt_counts: &HashMap<String, i64>,
adapters: &[Box<dyn AgentAdapter>],
) -> Result<CleanupCandidate> {
let prompts = plan
.sessions
.iter()
.map(|s| prompt_counts.get(&s.key).copied().unwrap_or(0))
.sum();
let updated_at = plan
.sessions
.iter()
.map(|s| s.updated_at)
.max()
.unwrap_or(root.updated_at);
let bytes = plan
.targets
.iter()
.flat_map(|t| &t.files)
.map(|f| f.bytes)
.sum();
let mut empty = plan.sessions.iter().all(|s| s.message_count == 0) && prompts == 0;
// Empty is a positive parse result, never a missing/failed index entry.
if empty {
for s in &plan.sessions {
let p =
supported_adapter(adapters, s)?.parse_transcript(&SessionFileRef::from_meta(s))?;
empty &= p.unknown_line_count == 0 && p.mainline.is_empty() && p.sidechains.is_empty();
}
}
Ok(CleanupCandidate {
root: root.clone(),
sessions: plan.sessions,
targets: plan.targets,
updated_at,
bytes,
prompts,
empty,
})
}
pub fn inventory(store: &Store, adapters: &[Box<dyn AgentAdapter>]) -> Result<CleanupInventory> {
let index = cleanup_index(store, adapters)?;
let prompt_counts = store.cleanup_prompt_counts()?;
let ownership = ownership(&index, adapters);
let mut result = CleanupInventory::default();
for root in index.iter().filter(|s| s.parent.is_empty()) {
match build_plan(root, &index, adapters, &ownership)
.and_then(|plan| inventory_candidate(&root.meta, plan, &prompt_counts, adapters))
{
Ok(c) => result.candidates.push(c),
Err(e) => result.unavailable.push(UnavailableSession {
session: root.meta.clone(),
sessions: known_tree(root, &index),
reason: e.to_string(),
}),
}
}
// Shared sidecars must not be counted twice or moved with an unselected tree.
let mut paths: Vec<_> = result
.candidates
.iter()
.enumerate()
.flat_map(|(i, c)| c.targets.iter().map(move |t| (&t.path, i)))
.collect();
paths.sort();
let mut shared = HashSet::new();
for (i, (a, ai)) in paths.iter().enumerate() {
for (b, bi) in paths.iter().skip(i + 1) {
if !b.starts_with(a) {
break;
}
if ai != bi {
shared.insert(*ai);
shared.insert(*bi);
}
}
}
result.candidates = result
.candidates
.into_iter()
.enumerate()
.filter_map(|(i, c)| {
if shared.contains(&i) {
result.unavailable.push(UnavailableSession {
session: c.root,
sessions: c.sessions,
reason: "Shared cleanup target".into(),
});
None
} else {
Some(c)
}
})
.collect();
for orphan in index
.iter()
.filter(|s| !s.parent.is_empty() && !index.iter().any(|p| p.meta.key == s.parent))
{
result.unavailable.push(UnavailableSession {
session: orphan.meta.clone(),
sessions: known_tree(orphan, &index),
reason: "Parent session is unavailable".into(),
});
}
Ok(result)
}
// Availability failures still need tree-aware dates and flags. This traversal
// tolerates malformed relationships without granting cleanup ownership.
fn known_tree(root: &IndexedSession, index: &[IndexedSession]) -> Vec<SessionMeta> {
let mut members = vec![root.meta.clone()];
let mut keys = HashSet::from([root.meta.key.as_str()]);
let mut cursor = 0;
while cursor < members.len() {
let parent = members[cursor].key.clone();
for child in index.iter().filter(|s| s.parent == parent) {
if keys.insert(child.meta.key.as_str()) {
members.push(child.meta.clone());
}
}
cursor += 1;
}
members
}
fn ownership(
index: &[IndexedSession],
adapters: &[Box<dyn AgentAdapter>],
) -> HashMap<String, Vec<PathBuf>> {
index
.iter()
.filter(|s| s.meta.host.is_empty())
.filter_map(|s| {
adapter_for(adapters, s.meta.agent, &s.meta.file_path).map(|a| {
(
s.meta.key.clone(),
a.session_paths(&s.meta)
.into_iter()
.map(PathBuf::from)
.collect(),
)
})
})
.collect()
}
pub fn revalidate(
store: &Store,
adapters: &[Box<dyn AgentAdapter>],
old: &CleanupCandidate,
) -> Result<()> {
let index = cleanup_index(store, adapters)?;
let root = index
.iter()
.find(|s| s.meta.key == old.root.key)
.context("Session no longer exists")?;
ensure!(root.parent.is_empty(), "Session tree changed");
let new = build_plan(root, &index, adapters, &ownership(&index, adapters))?;
let signature = |sessions: &[SessionMeta]| {
let mut values = sessions
.iter()
.map(|m| {
(
m.key.clone(),
m.file_path.clone(),
m.updated_at,
m.created_at,
m.favorite,
m.pinned,
)
})
.collect::<Vec<_>>();
values.sort();
values
};
ensure!(
signature(&new.sessions) == signature(&old.sessions) && new.targets == old.targets,
"Session or files changed since review; refresh and review again"
);
for meta in &new.sessions {
let parsed =
supported_adapter(adapters, meta)?.parse_session(&SessionFileRef::from_meta(meta))?;
ensure!(
parsed.unknown_line_count == 0,
"Session has unrecognized content"
);
}
// Parsing can take time; stat again before allowing any move.
for old in &new.targets {
ensure!(target(&old.path)? == *old, "Source changed while checking");
}
let index = cleanup_index(store, adapters)?;
let root = index
.iter()
.find(|s| s.meta.key == old.root.key)
.context("Session no longer exists")?;
ensure!(root.parent.is_empty(), "Session tree changed");
let checked = build_plan(root, &index, adapters, &ownership(&index, adapters))?;
ensure!(
signature(&checked.sessions) == signature(&old.sessions) && checked.targets == old.targets,
"Session or files changed since review; refresh and review again"
);
Ok(())
}
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
pub enum TargetStatus {
Pending,
Moving,
Moved,
Failed(String),
}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct CleanupRecord {
pub candidate: CleanupCandidate,
pub targets: Vec<TargetStatus>,
/// Kept when reading old journals; file recovery is handled by the OS.
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub trash_paths: Vec<Option<PathBuf>>,
/// Captured and journaled before any move, independent of inode/allocation
/// changes caused by the OS restoring a file across volumes.
#[serde(default)]
pub content_hashes: HashMap<PathBuf, String>,
pub indexed: bool,
pub restored: bool,
pub error: Option<String>,
}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct CleanupBatch {
pub id: String,
pub stamp: i64,
pub records: Vec<CleanupRecord>,
pub finished: bool,
}
impl CleanupBatch {
pub fn new(candidates: Vec<CleanupCandidate>, stamp: i64) -> Self {
let nonce = std::time::SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_nanos();
Self {
id: format!("{stamp}-{nonce}"),
stamp,
records: candidates
.into_iter()
.map(|candidate| CleanupRecord {
targets: vec![TargetStatus::Pending; candidate.targets.len()],
trash_paths: Vec::new(),
content_hashes: HashMap::new(),
candidate,
indexed: false,
restored: false,
error: None,
})
.collect(),
finished: false,
}
}
pub fn save(&self, store: &Store) -> Result<()> {
store.pref_set(
&format!("cleanup.batch.{}", self.id),
&serde_json::to_string(self)?,
)
}
}
pub fn history(store: &Store) -> Result<Vec<CleanupBatch>> {
store
.cleanup_journals()?
.iter()
.map(|s| serde_json::from_str(s).map_err(Into::into))
.collect()
}
/// Retry only the index transaction for targets durably recorded as moved.
/// An interrupted `Moving` status remains ambiguous and requires user review.
pub fn retry_index_updates(store: &Store, batch: &mut CleanupBatch) -> Result<usize> {
let mut count = 0;
for i in 0..batch.records.len() {
let r = &batch.records[i];
if r.indexed || r.restored || !r.targets.iter().all(|s| *s == TargetStatus::Moved) {
continue;
}
let result = (|| {
for target in &r.candidate.targets {
ensure!(
!target.path.try_exists()?,
"Source is present again; review it before updating the index"
);
}
store.complete_cleanup(&r.candidate.sessions, batch.stamp)
})();
match result {
Ok(()) => {
batch.records[i].indexed = true;
batch.records[i].error = None;
count += 1;
}
Err(e) => batch.records[i].error = Some(e.to_string()),
}
batch.save(store)?;
}
Ok(count)
}
/// 详情页的删除:移动**之前**先给每份会话文件记放回指纹(`put_back_fingerprint`),再把磁盘
/// 目标移进废纸篓、出库并记墓碑(`Store::remove_trashed_sessions`)——用户从废纸篓放回原处,
/// 扫描认出同一份文件就撤掉墓碑。返回 true = 一个文件都没移:会话只在别家自己的库里(虚拟
/// 路径),或者 adapter 的 `session_paths` 把文件留在原处,Wake 只是不再列出它
pub fn trash_sessions(store: &Store, sessions: &[SessionMeta], targets: &[String]) -> Result<bool> {
let mut prints: HashMap<String, (i64, i64)> = sessions
.iter()
.filter_map(|s| {
put_back_fingerprint(Path::new(&s.file_path)).map(|print| (s.file_path.clone(), print))
})
.collect();
let moved = terminal::trash_paths(targets)?;
// 指纹只留给真移进废纸篓的文件:留在原处的那份下一轮扫描就会被认成"放回来了",墓碑当场撤掉
prints.retain(|path, _| moved.iter().any(|m| crate::adapters::path_owns(m, path)));
let keys: Vec<String> = sessions.iter().map(|s| s.key.clone()).collect();
store.remove_trashed_sessions(&keys, &prints)?;
Ok(moved.is_empty())
}
/// Settings → Data 里的一项"已隐藏的会话":同一次删除藏起来、来源还在的会话——用户点的那条
/// 连同随它一起藏起来的子会话
#[derive(Clone, Debug)]
pub struct HiddenGroup {
/// epoch ms
pub hidden_at: i64,
/// 用户点的那条(它解析不出来时由下一条代表)
pub head: SessionMeta,
/// 随它一起藏起来的子会话有几条
pub nested: usize,
/// 取消隐藏时撤掉的墓碑:按 key(墓碑自己记的、各份副本的)也按墓碑的路径
keys: Vec<String>,
paths: Vec<String>,
/// 重新入库时交给扫描的来源(同一会话的几份副本都在,扫描照常按位次挑)
refs: Vec<SessionFileRef>,
}
/// 被 Wake 藏起来、来源却还在的会话:墓碑压着、各家此刻还列得出来的。主要是存在别家自己数据里的
/// 会话被"删除"(其实是隐藏,`trash_sessions` 一个文件都没移);被放回原处却认不出指纹的文件、
/// 别的 location 里的副本也在其列——副本按路径或列表给的 key 认,文件名不是会话 id 的家(Gemini)
/// 认不出:墓碑记的是解析后的 key,要把这几家的会话逐个解析才对得上,每次进 Data 页都这么做太重,
/// 而那只发生在会话进了废纸篓、另一个 location 还留着一份时,从废纸篓放回原件就回来了。已经进了废纸篓的列不出来;批量清理有自己的恢复(清理记录里
/// 的 Restore,先核对放回的文件),也不在其列。判据与扫描同一套:路径或 key 压在墓碑下,文件只归
/// 拥有它的最深的根(`RootOwners`),被外壳认领的替身撤了墓碑也回不来、不算。按删除分组、最近的
/// 在前。要把有墓碑的那几家的会话列一遍,放后台跑
pub fn hidden_sessions(
store: &Store,
adapters: &[Box<dyn AgentAdapter>],
) -> Result<Vec<HiddenGroup>> {
let cleanups: HashSet<i64> = history(store)?.iter().map(|batch| batch.stamp).collect();
let tombstones: Vec<Tombstone> = store
.tombstones()?
.into_iter()
.filter(|t| !cleanups.contains(&t.deleted_at))
.collect();
if tombstones.is_empty() {
return Ok(Vec::new());
}
let owners = RootOwners::new(adapters);
// 只列有墓碑的那几家(老墓碑没记 key,按路径归属认)
let agents: HashSet<AgentId> = tombstones
.iter()
.filter_map(|t| {
t.key
.split(':')
.next()
.and_then(AgentId::from_str)
.or_else(|| owners.owner_of(&t.file_path).map(|ix| adapters[ix].agent()))
})
.collect();
let by_path: HashMap<&str, usize> = tombstones
.iter()
.enumerate()
.map(|(ix, t)| (t.file_path.as_str(), ix))
.collect();
let by_key: HashMap<&str, usize> = tombstones
.iter()
.enumerate()
.filter(|(_, t)| !t.key.is_empty())
.map(|(ix, t)| (t.key.as_str(), ix))
.collect();
let claimed = store.claimed_keys()?;
let key_of =
|ix: usize, r: &SessionFileRef| session_key(r.agent, adapters[ix].host(), &r.native_id);
// 墓碑(按写入先后)→ 压着的来源
let mut found: BTreeMap<usize, Vec<(usize, SessionFileRef)>> = BTreeMap::new();
for (ix, adapter) in adapters.iter().enumerate() {
if !agents.contains(&adapter.agent()) {
continue;
}
// 这一刻读不出的这一家跳过:列不出来就说不清它还在不在
let Ok(listed) = adapter.list_session_files() else {
continue;
};
for r in listed {
let key = key_of(ix, &r);
let Some(&t) = by_path
.get(r.file_path.as_str())
.or_else(|| by_key.get(key.as_str()))
else {
continue;
};
if owners.admits(ix, &r.file_path) && !claimed.contains(&key) {
found.entry(t).or_default().push((ix, r));
}
}
}
// 按删除分组;组内按墓碑写入先后,用户点的那条在前
let mut deletions: BTreeMap<i64, Vec<(usize, Vec<(usize, SessionFileRef)>)>> = BTreeMap::new();
for (t, mut copies) in found {
copies.sort_by(|a, b| copy_order(adapters, a, b));
deletions
.entry(tombstones[t].deleted_at)
.or_default()
.push((t, copies));
}
let mut groups = Vec::new();
for (hidden_at, members) in deletions.into_iter().rev() {
// 解析得出来的第一条给这一组起名字,每条按扫描的回退顺序挨个试副本;一条都解析不出
// 就没法说它是什么,不列
let Some(head) = members.iter().find_map(|(_, copies)| {
copies
.iter()
.find_map(|(ix, r)| adapters[*ix].parse_session(r).ok())
.map(|parsed| parsed.meta)
}) else {
continue;
};
let mut group = HiddenGroup {
hidden_at,
head,
nested: members.len() - 1,
keys: Vec::new(),
paths: Vec::new(),
refs: Vec::new(),
};
for (t, copies) in members {
let tombstone = &tombstones[t];
if !tombstone.key.is_empty() {
group.keys.push(tombstone.key.clone());
}
group.paths.push(tombstone.file_path.clone());
for (ix, r) in copies {
group.keys.push(key_of(ix, &r));
group.refs.push(r);
}
}
groups.push(group);
}
Ok(groups)
}
/// 取消隐藏一组:撤掉压着它们的墓碑,按来源重新入库——扫描照常挑副本、挂回父子关系,
/// 收藏与置顶本来就留着
pub fn unhide(
store: &Arc<Store>,
adapters: &[Box<dyn AgentAdapter>],
group: HiddenGroup,
) -> Result<()> {
store.release_tombstones(&group.keys, &group.paths)?;
scan_files(adapters, store, &NullEvents, group.refs);
Ok(())
}
pub fn execute(
store: &Store,
adapters: &[Box<dyn AgentAdapter>],
batch: &mut CleanupBatch,
cancel: &AtomicBool,
progress: impl Fn(usize),
) -> Result<()> {
execute_with(store, adapters, batch, cancel, progress, |path| {
terminal::trash_paths(&[path.to_string_lossy().into_owned()]).map(drop)
})
}
fn execute_with(
store: &Store,
adapters: &[Box<dyn AgentAdapter>],
batch: &mut CleanupBatch,
cancel: &AtomicBool,
progress: impl Fn(usize),
trash: impl Fn(&Path) -> Result<()>,
) -> Result<()> {
batch.save(store)?;
for i in 0..batch.records.len() {
if cancel.load(Ordering::Relaxed) {
break;
}
let plan = batch.records[i].candidate.clone();
if let Err(e) = revalidate(store, adapters, &plan) {
batch.records[i].error = Some(e.to_string());
batch.save(store)?;
progress(i + 1);
continue;
}
match content_hashes(&plan.targets).and_then(|hashes| {
// Hashing large trees can take time; recheck source ownership and
// user metadata as well as the file snapshots before moving.
revalidate(store, adapters, &plan)?;
Ok(hashes)
}) {
Ok(hashes) => batch.records[i].content_hashes = hashes,
Err(e) => {
batch.records[i].error = Some(e.to_string());
batch.save(store)?;
progress(i + 1);
continue;
}
}
// Recovery evidence must be durable before the first move.
batch.save(store)?;
for (j, expected) in plan.targets.iter().enumerate() {
batch.records[i].targets[j] = TargetStatus::Moving;
batch.save(store)?;
let result = (|| {
ensure!(
target(&expected.path)? == *expected,
"Source changed before move"
);
trash(&expected.path)?;
ensure!(
!expected.path.try_exists()?,
"Source is still present after move"
);
Ok(())
})();
match result {
Ok(()) => batch.records[i].targets[j] = TargetStatus::Moved,
Err(e) => {
batch.records[i].targets[j] = TargetStatus::Failed(format!("{e:#}"));
batch.records[i].error = Some(format!("{e:#}"));
batch.save(store)?;
break;
}
}
batch.save(store)?;
}
if batch.records[i]
.targets
.iter()
.all(|s| *s == TargetStatus::Moved)
{
match store.complete_cleanup(&plan.sessions, batch.stamp) {
Ok(()) => batch.records[i].indexed = true,
Err(e) => batch.records[i].error = Some(e.to_string()),
}
}
batch.save(store)?;
progress(i + 1);
}
batch.finished = true;
batch.save(store)
}
fn hash_file(path: &Path) -> Result<String> {
let mut file = std::fs::File::open(path)?;
let mut digest = Sha256::new();
let mut buffer = [0; 64 * 1024];
loop {
let read = file.read(&mut buffer)?;
if read == 0 {
break;
}
digest.update(&buffer[..read]);
}
Ok(format!("{:x}", digest.finalize()))
}
fn content_hashes(targets: &[CleanupTarget]) -> Result<HashMap<PathBuf, String>> {
let mut hashes = HashMap::new();
for expected in targets {
ensure!(
target(&expected.path)? == *expected,
"Source changed while checking"
);
for file in expected.files.iter().filter(|file| !file.directory) {
hashes.insert(file.path.clone(), hash_file(&file.path)?);
}
ensure!(
target(&expected.path)? == *expected,
"Source changed while checking"
);
}
Ok(hashes)
}
fn verify_restored_files(record: &CleanupRecord) -> Result<Vec<CleanupTarget>> {
let mut checked = Vec::new();
for expected in &record.candidate.targets {
for file in &expected.files {
ensure!(
file.path.try_exists()?,
"Restored files are still missing from their original locations."
);
}
// This also rejects replaced targets/ancestors that are now symlinks.
let current = target(&expected.path)?;
let files: HashMap<_, _> = current.files.iter().map(|f| (&f.path, f)).collect();
for old in &expected.files {
let file = files
.get(&old.path)
.context("Restored session could not be verified")?;
ensure!(
file.directory == old.directory,
"Restored files do not match the deleted files"
);
if !old.directory {
ensure!(
file.logical_bytes == old.logical_bytes,
"Restored files do not match the deleted files"
);
if record.content_hashes.is_empty() {
// Legacy journals lack content evidence. Require matching
// type, length and modification time, plus session parsing.
ensure!(
file.modified == old.modified,
"Restored files do not match the deleted files"
);
} else {
ensure!(
record.content_hashes.get(&old.path) == Some(&hash_file(&old.path)?),
"Restored files do not match the deleted files"
);
}
}
}
ensure!(
target(¤t.path)? == current,
"Restored files changed before verification"
);
checked.push(current);
}
Ok(checked)
}
/// Users restore source files using their OS first. Validate the full tree and
/// remove only this batch's tombstones. The caller starts a normal rescan.
pub fn restore(
store: &Store,
adapters: &[Box<dyn AgentAdapter>],
batch: &mut CleanupBatch,
) -> Result<usize> {
let mut count = 0;
for i in 0..batch.records.len() {
if batch.records[i].restored || !batch.records[i].can_restore() {
continue;
}
let result = (|| {
let record = &batch.records[i];
store.validate_cleanup_restore(&record.candidate.sessions, batch.stamp)?;
let checked = verify_restored_files(record)?;
for meta in &record.candidate.sessions {
let parsed = supported_adapter(adapters, meta)?
.parse_session(&SessionFileRef::from_meta(meta))?;
ensure!(
parsed.unknown_line_count == 0 && parsed.meta.id == meta.id,
"Restored session could not be verified"
);
}
for expected in checked {
ensure!(
target(&expected.path)? == expected,
"Restored files changed before verification"
);
}
store.restore_cleanup(&record.candidate.sessions, batch.stamp)?;
Ok(())
})();
match result {
Ok(()) => {
batch.records[i].restored = true;
batch.records[i].error = None;
count += 1;
}
Err(e) => batch.records[i].error = Some(format!("{e:#}")),
}
batch.save(store)?;
}
if count == 0 {
bail!("No restored sessions found. Check the file locations below.");
}
Ok(count)
}
impl CleanupRecord {
pub fn can_restore(&self) -> bool {
!self.restored
&& self.targets.iter().any(|s| {
matches!(
s,
TargetStatus::Moved | TargetStatus::Moving | TargetStatus::Failed(_)
)
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::{
cell::Cell,
fs::{self, File, FileTimes},
time::Duration,
};
struct FilesAdapter {
root: PathBuf,
supported: bool,
/// 子会话是不是分支(`child_outlives_parent`)
branches: bool,
}
impl AgentAdapter for FilesAdapter {
fn agent(&self) -> AgentId {
AgentId::ClaudeCode
}
fn data_roots(&self) -> Vec<PathBuf> {
vec![self.root.clone()]
}
fn with_custom_root(&self, root: PathBuf) -> Box<dyn AgentAdapter> {
Box::new(Self {
root,
supported: self.supported,
branches: self.branches,
})
}
fn list_session_files(&self) -> Result<Vec<SessionFileRef>> {
Ok(vec![])
}
fn parse_session(&self, r: &SessionFileRef) -> Result<ParsedSession> {
let text = fs::read_to_string(&r.file_path)?;
Ok(ParsedSession {
meta: meta(&self.root, &r.native_id, 100),
units: vec![],
unknown_line_count: u32::from(text == "BAD"),
wake_lookups: Vec::new(),
})
}
fn parse_transcript(&self, r: &SessionFileRef) -> Result<ParsedTranscript> {
let p = self.parse_session(r)?;
Ok(ParsedTranscript {
meta: p.meta,
mainline: vec![],
sidechains: vec![],
unknown_line_count: p.unknown_line_count,
})
}
fn session_paths(&self, m: &SessionMeta) -> Vec<String> {
let mut paths = vec![m.file_path.clone()];
let dir = self.root.join(&m.id);
if dir.exists() {
paths.push(dir.to_string_lossy().into_owned());
}
paths
}
fn cleanup_paths(&self, m: &SessionMeta) -> Option<Vec<String>> {
self.supported.then(|| self.session_paths(m))
}
fn child_outlives_parent(&self, _child_path: &str) -> bool {
self.branches
}
}
fn now() -> i64 {
chrono::Utc::now().timestamp_millis()
}
fn meta(root: &Path, id: &str, age: i64) -> SessionMeta {
SessionMeta {
key: format!("claude-code:{id}"),
id: id.into(),
host: String::new(),
agent: AgentId::ClaudeCode,
title: id.into(),
project_path: "/synthetic/project".into(),
project_name: "project".into(),
file_path: root
.join(format!("{id}.jsonl"))
.to_string_lossy()
.into_owned(),
created_at: now() - 400 * DAY,
updated_at: now() - age * DAY,
message_count: 2,
size_bytes: 4,
git_branch: None,
model: None,
tokens_used: None,
archived: false,
source: None,
spawned: false,
favorite: false,
pinned: false,
}
}
fn age(path: &Path) {
#[cfg(windows)]
let file = {
use std::os::windows::fs::OpenOptionsExt;
use windows_sys::Win32::Storage::FileSystem::{
FILE_FLAG_BACKUP_SEMANTICS, FILE_WRITE_ATTRIBUTES,
};
fs::OpenOptions::new()
.access_mode(FILE_WRITE_ATTRIBUTES)
.custom_flags(FILE_FLAG_BACKUP_SEMANTICS)
.open(path)
.unwrap()
};
#[cfg(not(windows))]
let file = File::open(path).unwrap();
file.set_times(
FileTimes::new()
.set_modified(UNIX_EPOCH + Duration::from_millis((now() - 100 * DAY) as u64)),
)
.unwrap();
}
fn setup() -> (
tempfile::TempDir,
Store,
Vec<Box<dyn AgentAdapter>>,
PathBuf,
) {
let temp = tempfile::tempdir().unwrap();
let root = temp.path().canonicalize().unwrap().join("sessions");
fs::create_dir(&root).unwrap();
let store = Store::open(&temp.path().join("index.db")).unwrap();
let adapters: Vec<Box<dyn AgentAdapter>> = vec![Box::new(FilesAdapter {
root: root.clone(),
supported: true,
branches: false,
})];
(temp, store, adapters, root)
}
fn insert(store: &Store, root: &Path, id: &str, days: i64) -> SessionMeta {
let m = meta(root, id, days);
fs::write(&m.file_path, "test").unwrap();
age(Path::new(&m.file_path));
store
.write_session(
&m,
m.updated_at,
&[IndexUnit {
seq: 0,
sidechain_id: None,
role: Role::User,
timestamp: Some(m.updated_at),
text: "synthetic prompt".into(),
}],
)
.unwrap();
m
}
/// 父会话的目录里装着子代理的转录:一起删时只移外层,不然第二下找不着文件、整批报错
#[test]
fn nested_targets_collapse_into_the_outer_one() {
let p = |s: &str| PathBuf::from(s);
assert_eq!(
outermost([
p("/h/projects/-w/5ab0.jsonl"),
p("/h/projects/-w/5ab0"),
p("/h/projects/-w/5ab0/subagents/agent-a1.jsonl"),
p("/h/projects/-w/5ab0-other"),
p("/h/projects/-w/5ab0"),
]),
[
p("/h/projects/-w/5ab0"),
p("/h/projects/-w/5ab0-other"),
p("/h/projects/-w/5ab0.jsonl"),
]
);
}
/// 分支(所在的家声明子会话是自己完整的对话)自成一棵清理树:原件的清理计划不带上它,
/// 它自己也是一个候选、过得了复核;默认(子代理一类)照旧随父会话
#[test]
fn branches_are_their_own_cleanup_trees() {
let (_temp, store, adapters, root) = setup();
let original = insert(&store, &root, "original", 100);
let branch = insert(&store, &root, "branch", 100);
store
.replace_parent_links(
AgentId::ClaudeCode,
&[(branch.key.clone(), original.key.clone())],
)
.unwrap();
let trees = |adapters: &[Box<dyn AgentAdapter>]| {
let mut trees: Vec<(String, usize)> = inventory(&store, adapters)
.unwrap()
.candidates
.iter()
.map(|c| (c.root.key.clone(), c.sessions.len()))
.collect();
trees.sort();
trees
};
assert_eq!(trees(&adapters), vec![(original.key.clone(), 2)]);
let branching: Vec<Box<dyn AgentAdapter>> = vec![Box::new(FilesAdapter {
root: root.clone(),
supported: true,
branches: true,
})];
assert_eq!(
trees(&branching),
vec![(branch.key.clone(), 1), (original.key.clone(), 1)]
);
for c in inventory(&store, &branching).unwrap().candidates {
revalidate(&store, &branching, &c).unwrap();
}
}
#[test]
fn unavailable_entries_follow_date_source_and_tree_flag_filters() {
let (_temp, store, adapters, root) = setup();
let parent = insert(&store, &root, "unavailable-parent", 180);
let child = insert(&store, &root, "unavailable-child", 60);
store
.replace_parent_links(
AgentId::ClaudeCode,
&[(child.key.clone(), parent.key.clone())],
)
.unwrap();
store
.set_user_data(&child.key, Some(true), Some(true))
.unwrap();
fs::remove_file(&parent.file_path).unwrap(); // Synthetic missing source.
let entry =
CleanupEntry::Unavailable(inventory(&store, &adapters).unwrap().unavailable.remove(0));
let mut options = CleanupOptions::default();
assert!(options.matches_entry(&entry, now()));
options.created_days = 90;
options.updated_days = 90;
assert!(
!options.matches_entry(&entry, now()),
"A recent child must affect the update filter"
);
options.updated_days = 30;
assert!(options.matches_entry(&entry, now()));
options.exclude_starred = true;
assert!(!options.matches_entry(&entry, now()));
options.exclude_starred = false;
options.exclude_pinned = true;
assert!(!options.matches_entry(&entry, now()));
options.exclude_pinned = false;
options.agents = BTreeSet::from([AgentId::Codex]);
assert!(!options.matches_entry(&entry, now()));
options.agents = BTreeSet::from([parent.agent]);
options.projects = BTreeSet::from(["different-project".into()]);
assert!(!options.matches_entry(&entry, now()));
options.projects = BTreeSet::from([parent.project_path]);
assert!(options.matches_entry(&entry, now()));
options.only_cleanable = true;
assert!(!options.matches_entry(&entry, now()));
assert!(
entry.candidate().is_none(),
"Unavailable entries never yield a cleanup target"
);
let restored: CleanupOptions =
serde_json::from_value(serde_json::to_value(options).unwrap()).unwrap();
assert!(restored.only_cleanable);
let old: CleanupOptions = serde_json::from_str(r#"{"days":0}"#).unwrap();
assert!(
!old.only_cleanable,
"Existing preferences must not hide unavailable sessions"
);
}
#[test]
fn mixed_entries_sort_together_with_unknown_size_last_in_both_directions() {
let (_temp, store, adapters, root) = setup();
for (id, days) in [("old", 180), ("middle", 90), ("new", 60)] {
let mut meta = insert(&store, &root, id, days);
// Distinct fixed dates: insertion can occur within one millisecond
// on CI, so wall-clock insertion order is not a creation-date order.
meta.updated_at = 1_800_000_000_000 - days * DAY;
meta.created_at = meta.updated_at - DAY;
store.write_session(&meta, meta.updated_at, &[]).unwrap();
}
fs::remove_file(root.join("middle.jsonl")).unwrap();
let inv = inventory(&store, &adapters).unwrap();
let mut entries: Vec<_> = inv
.candidates
.into_iter()
.map(|mut c| {
c.bytes = if c.root.id == "old" { 0 } else { 128 };
CleanupEntry::Available(c)
})
.chain(inv.unavailable.into_iter().map(CleanupEntry::Unavailable))
.collect();
let mut options = CleanupOptions::default();
for (sort, ascending, expected) in [
(CleanupSort::Size, true, ["old", "new", "middle"]),
(CleanupSort::Size, false, ["new", "old", "middle"]),
(CleanupSort::Created, true, ["old", "middle", "new"]),
(CleanupSort::Updated, false, ["new", "middle", "old"]),
] {
options.sort = sort;
options.ascending = Some(ascending);
options.sort_entries(&mut entries);
assert_eq!(
entries
.iter()
.map(|e| e.session().id.as_str())
.collect::<Vec<_>>(),
expected
);
}
assert_eq!(
entries.iter().filter_map(CleanupEntry::candidate).count(),
2
);
}
#[test]
fn snapshot_uses_mainline_prompt_count_and_keeps_archived_children() {
let (_temp, store, adapters, root) = setup();
let parent = insert(&store, &root, "parent", 120);
let mut child = insert(&store, &root, "child", 90);
child.archived = true;
let units: Vec<_> = [
(Role::User, None),
(Role::Assistant, None),
(Role::User, Some("sidechain")),
]
.into_iter()
.enumerate()
.map(|(seq, (role, sidechain))| IndexUnit {
seq: seq as i64,
sidechain_id: sidechain.map(str::to_string),
role,
timestamp: None,
text: "synthetic".into(),
})
.collect();
store
.write_session(&child, child.updated_at, &units)
.unwrap();
store
.replace_parent_links(
AgentId::ClaudeCode,
&[(child.key.clone(), parent.key.clone())],
)
.unwrap();
let inv = inventory(&store, &adapters).unwrap();
assert_eq!(inv.candidates.len(), 1);
let c = &inv.candidates[0];
assert_eq!(c.sessions.len(), 2);
assert_eq!(c.prompts, 2);
assert_eq!(c.updated_at, child.updated_at);
let mut options = CleanupOptions::default();
store.set_user_data(&child.key, Some(true), None).unwrap();
let starred = inventory(&store, &adapters).unwrap().candidates.remove(0);
assert!(options.matches(&starred, now()));
options.exclude_starred = true;
assert!(!options.matches(&starred, now()));
options.exclude_starred = false;
assert!(options.matches(&starred, now()));
store
.set_user_data(&child.key, Some(false), Some(true))
.unwrap();
let pinned = inventory(&store, &adapters).unwrap().candidates.remove(0);
assert!(options.matches(&pinned, now()));
options.exclude_pinned = true;
assert!(!options.matches(&pinned, now()));
options.exclude_pinned = false;
assert!(options.matches(&pinned, now()));
child.updated_at = now() - DAY;
store.write_session(&child, child.updated_at, &[]).unwrap();
let recent = inventory(&store, &adapters).unwrap().candidates.remove(0);
assert!(!options.matches(&recent, now()));
options.created_days = 30;
assert!(
!options.matches(&recent, now()),
"Both date filters must match"
);
options.updated_days = 0;
assert!(
options.matches(&recent, now()),
"Creation can be filtered independently"
);
options.created_days = 0;
assert!(options.matches(&recent, now()));
}
#[test]
fn reviewed_starred_pinned_and_recent_files_can_be_cleaned_up() {
let (temp, store, adapters, root) = setup();
let m = insert(&store, &root, "recent", 1);
store.set_user_data(&m.key, Some(true), Some(true)).unwrap();
// Fresh file modification time is not an invisible age filter.
fs::write(&m.file_path, "recent content").unwrap();
let candidate = inventory(&store, &adapters).unwrap().candidates.remove(0);
assert!(candidate.has_starred() && candidate.has_pinned());
let mut options: CleanupOptions = serde_json::from_str(r#"{"days":0}"#).unwrap();
assert!(
options.matches(&candidate, now()),
"Old preferences do not introduce hidden exclusions"
);
options.exclude_starred = true;
options.exclude_pinned = true;
let restored: CleanupOptions =
serde_json::from_str(&serde_json::to_string(&options).unwrap()).unwrap();
assert!(restored.exclude_starred && restored.exclude_pinned);
assert!(!restored.matches(&candidate, now()));
let mut batch = CleanupBatch::new(vec![candidate], now());
execute_with(
&store,
&adapters,
&mut batch,
&AtomicBool::new(false),
|_| {},
|p| {
fs::rename(p, temp.path().join("fake-trash"))?;
Ok(())
},
)
.unwrap();
assert!(batch.records[0].indexed);
assert_eq!(batch.records[0].targets, vec![TargetStatus::Moved]);
assert!(store.is_key_tombstoned(&m.key));
}
#[test]
fn date_filters_have_independent_boundaries_and_sort_does_not_change_them() {
let (_temp, store, adapters, root) = setup();
insert(&store, &root, "a", 100);
let mut c = inventory(&store, &adapters).unwrap().candidates.remove(0);
let now = now();
let mut options = CleanupOptions::default();
for days in [30, 90, 180, 365] {
options.updated_days = days;
c.updated_at = now - days * DAY;
assert!(options.matches(&c, now));
c.updated_at += 1;
assert!(!options.matches(&c, now));
}
options.updated_days = 0;
for days in [30, 90, 180, 365] {
options.created_days = days;
c.root.created_at = now - days * DAY;
assert!(options.matches(&c, now));
c.root.created_at += 1;
assert!(!options.matches(&c, now));
}
options.created_days = 180;
options.updated_days = 30;
c.root.created_at = now - 180 * DAY;
c.updated_at = now - 30 * DAY;
assert!(options.matches(&c, now));
c.root.created_at += 1;
assert!(
!options.matches(&c, now),
"A matching update date cannot override creation"
);
c.root.created_at -= 1;
c.updated_at += 1;
assert!(
!options.matches(&c, now),
"A matching creation date cannot override updates"
);
c.root.created_at = 0;
c.updated_at = 0;
assert!(!options.matches(&c, now));
options.updated_days = 0;
assert!(!options.matches(&c, now));
options.created_days = 0;
assert!(options.matches(&c, now));
let mut a = c.clone();
a.root.key = "a".into();
a.root.created_at = 1;
a.updated_at = 100;
a.bytes = 30;
let mut b = c;
b.root.key = "b".into();
b.root.created_at = 2;
b.updated_at = 50;
b.bytes = 80;
let mut items = vec![a, b];
options.sort = CleanupSort::Created;
options.sort(&mut items);
assert_eq!(items[0].root.key, "a");
options.sort = CleanupSort::Updated;
options.sort(&mut items);
assert_eq!(items[0].root.key, "b");
options.sort = CleanupSort::Size;
options.sort(&mut items);
assert_eq!(items[0].root.key, "b");
for (sort, ascending, first) in [
(CleanupSort::Created, true, "a"),
(CleanupSort::Created, false, "b"),
(CleanupSort::Updated, true, "b"),
(CleanupSort::Updated, false, "a"),
(CleanupSort::Size, true, "a"),
(CleanupSort::Size, false, "b"),
] {
options.sort = sort;
options.ascending = Some(ascending);
options.sort(&mut items);
assert_eq!(items[0].root.key, first);
assert_eq!(options.ascending, Some(ascending));
}
items[0].bytes = items[1].bytes;
options.sort(&mut items);
assert_eq!(
items[0].root.key, "a",
"Ties stay stable in descending order"
);
assert_eq!((options.created_days, options.updated_days), (0, 0));
}
#[test]
fn independent_date_preferences_migrate_without_extra_restrictions() {
for (saved, expected) in [
(serde_json::json!({}), (0, 30)),
(serde_json::json!({"time":"Created", "days":90}), (90, 0)),
(serde_json::json!({"time":"Updated", "days":180}), (0, 180)),
(serde_json::json!({"time":"Created"}), (30, 0)),
(serde_json::json!({"time":"Created", "days":0}), (0, 0)),
(serde_json::json!({"days":0}), (0, 0)),
(
serde_json::json!({"created_days":180, "updated_days":30}),
(180, 30),
),
(serde_json::json!({"created_days":90}), (90, 0)),
(serde_json::json!({"updated_days":90}), (0, 90)),
(
serde_json::json!({"created_days":0, "updated_days":0, "time":"Created", "days":90}),
(0, 0),
),
(
serde_json::json!({"created_days":i64::MAX, "updated_days":-1}),
(0, 30),
),
] {
let mut saved = saved;
saved["sort"] = serde_json::json!("Created");
saved["ascending"] = serde_json::json!(false);
saved["project"] = serde_json::json!("/synthetic/project");
saved["exclude_starred"] = serde_json::json!(true);
saved["exclude_pinned"] = serde_json::json!(true);
let options: CleanupOptions = serde_json::from_value(saved).unwrap();
assert_eq!((options.created_days, options.updated_days), expected);
assert_eq!(options.sort, CleanupSort::Created);
assert_eq!(options.ascending, Some(false));
assert_eq!(
options.projects,
BTreeSet::from(["/synthetic/project".into()])
);
assert!(options.exclude_starred && options.exclude_pinned);
let encoded = serde_json::to_value(&options).unwrap();
assert!(encoded.get("time").is_none() && encoded.get("days").is_none());
let restored: CleanupOptions = serde_json::from_value(encoded).unwrap();
assert_eq!((restored.created_days, restored.updated_days), expected);
assert_eq!(restored.ascending, Some(false));
assert!(restored.exclude_starred && restored.exclude_pinned);
}
}
#[test]
fn source_filters_union_each_group_and_intersect_with_other_filters() {
let mut options = CleanupOptions {
agents: BTreeSet::from([AgentId::ClaudeCode, AgentId::Codex]),
projects: BTreeSet::from(["/synthetic/a".into(), "/synthetic/b".into()]),
..CleanupOptions::default()
};
for agent in [AgentId::ClaudeCode, AgentId::Codex, AgentId::Cursor] {
for project in ["/synthetic/a", "/synthetic/b", "/synthetic/c"] {
let mut session = meta(Path::new("/synthetic/sessions"), "source-filter", 100);
session.agent = agent;
session.project_path = project.into();
let matches = options.matches_metadata(
&session,
session.updated_at,
std::slice::from_ref(&session),
now(),
);
assert_eq!(
matches,
agent != AgentId::Cursor && project != "/synthetic/c"
);
}
}
let mut session = meta(Path::new("/synthetic/sessions"), "source-filter", 1);
session.project_path = "/synthetic/a".into();
assert!(
!options.matches_metadata(
&session,
session.updated_at,
std::slice::from_ref(&session),
now()
),
"Date filters still apply to selected sources"
);
options.updated_days = 0;
assert!(options.matches_metadata(
&session,
session.updated_at,
std::slice::from_ref(&session),
now()
));
options.agents.clear();
session.agent = AgentId::Cursor;
assert!(
options.matches_metadata(
&session,
session.updated_at,
std::slice::from_ref(&session),
now()
),
"All agents removes only the agent restriction"
);
session.project_path = "/synthetic/c".into();
assert!(!options.matches_metadata(
&session,
session.updated_at,
std::slice::from_ref(&session),
now()
));
options.projects.clear();
assert!(
options.matches_metadata(
&session,
session.updated_at,
std::slice::from_ref(&session),
now()
),
"Empty source sets include every source"
);
}
#[test]
fn source_preferences_migrate_and_preserve_explicit_clears() {
let old: CleanupOptions = serde_json::from_value(serde_json::json!({
"agent": "codex", "project": "/synthetic/a"
}))
.unwrap();
assert_eq!(old.agents, BTreeSet::from([AgentId::Codex]));
assert_eq!(old.projects, BTreeSet::from(["/synthetic/a".into()]));
let selected: CleanupOptions = serde_json::from_value(serde_json::json!({
"agents": ["claude-code", "codex", "codex"],
"projects": ["/synthetic/a", "/synthetic/b"],
"agent": "cursor", "project": "/synthetic/ignored"
}))
.unwrap();
assert_eq!(
selected.agents,
BTreeSet::from([AgentId::ClaudeCode, AgentId::Codex])
);
let saved = serde_json::to_value(&selected).unwrap();
assert!(saved.get("agent").is_none() && saved.get("project").is_none());
let restored: CleanupOptions = serde_json::from_value(saved).unwrap();
assert_eq!(restored.agents, selected.agents);
assert_eq!(restored.projects, selected.projects);
let cleared: CleanupOptions = serde_json::from_value(serde_json::json!({
"agents": [], "projects": [], "agent": "codex", "project": "/synthetic/a"
}))
.unwrap();
assert!(cleared.agents.is_empty() && cleared.projects.is_empty());
}
#[test]
fn retired_content_preferences_do_not_hide_candidates() {
let (_temp, store, adapters, root) = setup();
insert(&store, &root, "small-session", 100);
let mut candidate = inventory(&store, &adapters).unwrap().candidates.remove(0);
candidate.bytes = 1024;
candidate.prompts = 5;
candidate.empty = false;
assert!(CleanupOptions::default().matches(&candidate, now()));
for preset in ["All", "Large", "Short", "Empty"] {
let options: CleanupOptions = serde_json::from_value(serde_json::json!({
"content": preset,
"days": 90,
"sort": "Created",
"ascending": true
}))
.unwrap();
assert!(options.matches(&candidate, now()));
assert_eq!((options.created_days, options.updated_days), (0, 90));
assert_eq!(options.sort, CleanupSort::Created);
assert!(options.sort_ascending());
assert!(serde_json::to_value(&options)
.unwrap()
.get("content")
.is_none());
}
}
#[test]
fn sort_direction_preferences_preserve_old_order_and_roundtrip() {
for (key, old_ascending) in [("Created", true), ("Updated", true), ("Size", false)] {
let mut options: CleanupOptions =
serde_json::from_value(serde_json::json!({ "sort": key })).unwrap();
assert_eq!(options.sort_ascending(), old_ascending);
options.ascending = Some(!old_ascending);
let saved = serde_json::to_string(&options).unwrap();
let restored: CleanupOptions = serde_json::from_str(&saved).unwrap();
assert_eq!(restored.sort_ascending(), !old_ascending);
assert_eq!(restored.sort, options.sort);
}
}
#[test]
fn changed_files_new_children_and_favorites_invalidate_review() {
let (_temp, store, adapters, root) = setup();
let m = insert(&store, &root, "a", 100);
let c = inventory(&store, &adapters).unwrap().candidates.remove(0);
assert!(revalidate(&store, &adapters, &c).is_ok());
store.set_user_data(&m.key, Some(true), None).unwrap();
assert!(revalidate(&store, &adapters, &c).is_err());
store.set_user_data(&m.key, Some(false), None).unwrap();
let child = insert(&store, &root, "child", 100);
store
.replace_parent_links(AgentId::ClaudeCode, &[(child.key, m.key.clone())])
.unwrap();
assert!(revalidate(&store, &adapters, &c).is_err());
store
.replace_parent_links(AgentId::ClaudeCode, &[])
.unwrap();
fs::write(&m.file_path, "changed").unwrap();
assert!(revalidate(&store, &adapters, &c).is_err());
}
#[test]
fn nested_paths_deduplicate_and_shared_session_prevents_cleanup() {
let (_temp, store, adapters, root) = setup();
let parent = insert(&store, &root, "a", 100);
fs::create_dir(root.join("a")).unwrap();
fs::write(root.join("a/sidecar"), "sidecar").unwrap();
age(&root.join("a/sidecar"));
age(&root.join("a"));
let c = inventory(&store, &adapters).unwrap().candidates.remove(0);
assert_eq!(c.targets.len(), 2);
assert_eq!(
c.targets
.iter()
.flat_map(|t| &t.files)
.filter(|f| !f.directory)
.count(),
2
);
let mut child = insert(&store, &root, "child", 100);
let original = child.file_path.clone();
child.file_path = root.join("a/child.jsonl").to_string_lossy().into_owned();
fs::rename(original, &child.file_path).unwrap();
store.remove_session(&child.key).unwrap();
store.write_session(&child, child.updated_at, &[]).unwrap();
age(&root.join("a"));
assert!(inventory(&store, &adapters)
.unwrap()
.candidates
.iter()
.all(|c| c.root.key != parent.key));
store
.replace_parent_links(AgentId::ClaudeCode, &[(child.key, parent.key)])
.unwrap();
let c = inventory(&store, &adapters).unwrap().candidates.remove(0);
assert_eq!(c.targets.len(), 2);
assert_eq!(c.sessions.len(), 2);
}
#[test]
fn review_reports_every_failed_tree_and_preserves_ready_selection() {
let (_temp, store, adapters, root) = setup();
let good = insert(&store, &root, "good", 100);
let bad = insert(&store, &root, "bad", 100);
let changed = insert(&store, &root, "changed", 100);
fs::write(&bad.file_path, "BAD").unwrap();
let mut chosen = inventory(&store, &adapters).unwrap().candidates;
// A failure in the first item must not prevent checking later trees.
chosen.sort_by_key(|c| c.root.id.clone());
fs::write(&changed.file_path, "new content after selection").unwrap();
let mut progress = vec![];
let checked = review(&store, &adapters, chosen, &AtomicBool::new(false), |n| {
progress.push(n);
})
.unwrap();
assert_eq!(progress, vec![1, 2, 3]);
assert_eq!(checked.ready.len(), 1);
assert_eq!(checked.ready[0].root.key, good.key);
assert_eq!(checked.skipped.len(), 2);
assert_eq!(checked.skipped[0].session.key, bad.key);
assert_eq!(
checked.skipped[0].reason,
"Session has unrecognized content"
);
assert_eq!(checked.skipped[1].session.key, changed.key);
assert!(checked.skipped[1].reason.contains("changed since review"));
for meta in [&good, &bad, &changed] {
assert!(Path::new(&meta.file_path).exists());
assert!(store.get_session(&meta.key).unwrap().is_some());
assert!(!store.is_key_tombstoned(&meta.key));
}
assert!(
history(&store).unwrap().is_empty(),
"Review never starts a cleanup batch"
);
fs::write(&good.file_path, "changed again").unwrap();
let all_failed = review(
&store,
&adapters,
checked.ready,
&AtomicBool::new(false),
|_| {},
)
.unwrap();
assert!(all_failed.ready.is_empty());
assert_eq!(all_failed.skipped.len(), 1);
}
#[test]
fn cancelled_review_discards_partial_results_without_moving_files() {
let (_temp, store, adapters, root) = setup();
let first = insert(&store, &root, "first", 100);
let second = insert(&store, &root, "second", 100);
let chosen = inventory(&store, &adapters).unwrap().candidates;
let cancel = AtomicBool::new(true);
assert!(review(&store, &adapters, chosen.clone(), &cancel, |_| {
panic!("A cancelled review must not start checking");
})
.is_none());
for stop_after in [1, 2] {
cancel.store(false, Ordering::Relaxed);
let mut checked = 0;
assert!(review(&store, &adapters, chosen.clone(), &cancel, |n| {
checked = n;
if n == stop_after {
cancel.store(true, Ordering::Relaxed);
}
})
.is_none());
assert_eq!(checked, stop_after);
}
for meta in [first, second] {
assert!(Path::new(&meta.file_path).exists());
assert!(store.get_session(&meta.key).unwrap().is_some());
assert!(!store.is_key_tombstoned(&meta.key));
}
assert!(history(&store).unwrap().is_empty());
}
#[test]
fn unsupported_remote_missing_and_bad_content_are_not_moved() {
let (_temp, store, adapters, root) = setup();
let mut m = insert(&store, &root, "a", 100);
let unsupported: Vec<Box<dyn AgentAdapter>> = vec![Box::new(FilesAdapter {
root: root.clone(),
supported: false,
branches: false,
})];
assert!(inventory(&store, &unsupported)
.unwrap()
.candidates
.is_empty());
m.host = "remote".into();
store.write_session(&m, m.updated_at, &[]).unwrap();
assert!(inventory(&store, &adapters).unwrap().candidates.is_empty());
m.host.clear();
store.write_session(&m, m.updated_at, &[]).unwrap();
fs::write(&m.file_path, "BAD").unwrap();
age(Path::new(&m.file_path));
let c = inventory(&store, &adapters).unwrap().candidates.remove(0);
let mut batch = CleanupBatch::new(vec![c], now());
execute_with(
&store,
&adapters,
&mut batch,
&AtomicBool::new(false),
|_| {},
|_| panic!("must not move unrecognized content"),
)
.unwrap();
assert!(batch.records[0].error.is_some());
assert!(Path::new(&m.file_path).exists());
fs::remove_file(&m.file_path).unwrap();
assert!(inventory(&store, &adapters).unwrap().candidates.is_empty());
}
#[test]
fn hard_links_are_excluded() {
let (_temp, store, adapters, root) = setup();
let m = insert(&store, &root, "a", 100);
fs::hard_link(&m.file_path, root.join("other")).unwrap();
assert!(inventory(&store, &adapters).unwrap().candidates.is_empty());
fs::remove_file(root.join("other")).unwrap();
assert_eq!(inventory(&store, &adapters).unwrap().candidates.len(), 1);
}
#[cfg(unix)]
#[test]
fn symbolic_links_are_excluded() {
let (_temp, store, adapters, root) = setup();
let m = insert(&store, &root, "a", 100);
fs::rename(&m.file_path, root.join("actual")).unwrap();
std::os::unix::fs::symlink(root.join("actual"), &m.file_path).unwrap();
assert!(inventory(&store, &adapters).unwrap().candidates.is_empty());
}
#[test]
fn canonical_target_accepts_regular_paths_and_rejects_changed_locations() {
let temp = tempfile::tempdir().unwrap();
let root = temp.path().canonicalize().unwrap();
let path = root.join("session.jsonl");
fs::write(&path, "synthetic").unwrap();
assert!(target(&path).is_ok());
assert!(same_canonical_path(&path, &path.canonicalize().unwrap()));
assert!(!same_canonical_path(&root.join("other.jsonl"), &path));
assert!(target(Path::new("relative-session.jsonl")).is_err());
}
#[test]
fn same_size_and_timestamp_replacement_is_rejected_before_deletion() {
let (_temp, store, adapters, root) = setup();
let m = insert(&store, &root, "a", 100);
let candidate = inventory(&store, &adapters).unwrap().candidates.remove(0);
let original = stamp(Path::new(&m.file_path)).unwrap();
let replacement = root.join("replacement");
fs::write(&replacement, "evil").unwrap();
File::options()
.write(true)
.open(&replacement)
.unwrap()
.set_times(
FileTimes::new().set_modified(UNIX_EPOCH + Duration::from_nanos(original.modified)),
)
.unwrap();
fs::rename(&m.file_path, root.join("old-file")).unwrap();
fs::rename(replacement, &m.file_path).unwrap();
let replaced = stamp(Path::new(&m.file_path)).unwrap();
assert_eq!(original.logical_bytes, replaced.logical_bytes);
assert_eq!(original.modified, replaced.modified);
assert_ne!(original.identity, replaced.identity);
assert!(revalidate(&store, &adapters, &candidate).is_err());
let mut batch = CleanupBatch::new(vec![candidate], now());
execute_with(
&store,
&adapters,
&mut batch,
&AtomicBool::new(false),
|_| {},
|_| panic!("A replaced file must never be moved"),
)
.unwrap();
assert!(!store.is_key_tombstoned(&m.key));
assert!(batch.records[0].error.is_some());
}
#[cfg(unix)]
#[test]
fn symbolic_link_in_target_ancestor_is_excluded() {
let temp = tempfile::tempdir().unwrap();
let root = temp.path().canonicalize().unwrap();
fs::create_dir(root.join("actual")).unwrap();
fs::write(root.join("actual/session.jsonl"), "synthetic").unwrap();
std::os::unix::fs::symlink(root.join("actual"), root.join("alias")).unwrap();
assert!(target(&root.join("alias/session.jsonl")).is_err());
}
#[cfg(windows)]
#[test]
fn windows_canonical_prefixes_do_not_hide_regular_sessions() {
use std::path::{Component, Prefix};
let temp = tempfile::tempdir().unwrap();
let canonical = temp.path().canonicalize().unwrap();
let mut components = canonical.components();
let mut root = match components.next().unwrap() {
Component::Prefix(prefix) => match prefix.kind() {
Prefix::VerbatimDisk(drive) => PathBuf::from(format!("{}:", drive as char)),
_ => panic!("Test expects a local temporary directory"),
},
_ => panic!("Test expects an absolute temporary directory"),
};
for component in components {
root.push(component.as_os_str());
}
root.push("sessions");
fs::create_dir(&root).unwrap();
let store = Store::open(&temp.path().join("index.db")).unwrap();
let adapters: Vec<Box<dyn AgentAdapter>> = vec![Box::new(FilesAdapter {
root: root.clone(),
supported: true,
branches: false,
})];
insert(&store, &root, "ordinary-path", 100);
let inv = inventory(&store, &adapters).unwrap();
assert_eq!(inv.candidates.len(), 1);
revalidate(&store, &adapters, &inv.candidates[0]).unwrap();
for (ordinary, extended) in [
(r"C:\sessions\a.jsonl", r"\\?\C:\sessions\a.jsonl"),
(r"\\server\share\a.jsonl", r"\\?\UNC\server\share\a.jsonl"),
] {
assert!(same_canonical_path(
Path::new(ordinary),
Path::new(extended)
));
}
for different in [r"\\?\D:\sessions\a.jsonl", r"\\?\C:\elsewhere\a.jsonl"] {
assert!(!same_canonical_path(
Path::new(r"C:\sessions\a.jsonl"),
Path::new(different)
));
}
}
#[test]
fn revalidation_does_not_depend_on_the_message_index() {
let (temp, store, adapters, root) = setup();
let m = insert(&store, &root, "a", 100);
let c = inventory(&store, &adapters).unwrap().candidates.remove(0);
assert_eq!(c.prompts, 1);
// Any accidental transcript-count query now fails deterministically,
// without a timing assertion or depending on a contributor's database.
rusqlite::Connection::open(temp.path().join("index.db"))
.unwrap()
.execute_batch("DROP TABLE messages")
.unwrap();
revalidate(&store, &adapters, &c).unwrap();
store.set_user_data(&m.key, None, Some(true)).unwrap();
assert!(revalidate(&store, &adapters, &c).is_err());
}
#[test]
fn ownership_is_checked_again_after_parsing() {
use std::sync::Arc;
struct IndexOwnerDuringParse {
inner: FilesAdapter,
store: Arc<Store>,
owner: SessionMeta,
}
impl AgentAdapter for IndexOwnerDuringParse {
fn agent(&self) -> AgentId {
self.inner.agent()
}
fn data_roots(&self) -> Vec<PathBuf> {
self.inner.data_roots()
}
fn with_custom_root(&self, root: PathBuf) -> Box<dyn AgentAdapter> {
self.inner.with_custom_root(root)
}
fn list_session_files(&self) -> Result<Vec<SessionFileRef>> {
self.inner.list_session_files()
}
fn parse_session(&self, r: &SessionFileRef) -> Result<ParsedSession> {
let parsed = self.inner.parse_session(r)?;
// Simulate a scanner discovering an owner while validation parses
// the original tree. The filesystem snapshot does not change.
self.store
.write_session(&self.owner, self.owner.updated_at, &[])?;
Ok(parsed)
}
fn parse_transcript(&self, r: &SessionFileRef) -> Result<ParsedTranscript> {
self.inner.parse_transcript(r)
}
fn session_paths(&self, m: &SessionMeta) -> Vec<String> {
self.inner.session_paths(m)
}
fn cleanup_paths(&self, m: &SessionMeta) -> Option<Vec<String>> {
self.inner.cleanup_paths(m)
}
}
let (_temp, store, adapters, root) = setup();
let m = insert(&store, &root, "a", 100);
fs::create_dir(root.join("a")).unwrap();
let sidecar = root.join("a/sidecar.jsonl");
fs::write(&sidecar, "test").unwrap();
let c = inventory(&store, &adapters).unwrap().candidates.remove(0);
let mut owner = meta(&root, "new-owner", 100);
owner.file_path = sidecar.to_string_lossy().into_owned();
let store = Arc::new(store);
let adapters: Vec<Box<dyn AgentAdapter>> = vec![Box::new(IndexOwnerDuringParse {
inner: FilesAdapter {
root,
supported: true,
branches: false,
},
store: store.clone(),
owner,
})];
let error = revalidate(&store, &adapters, &c).unwrap_err();
assert_eq!(error.to_string(), "Target also contains another session");
assert!(Path::new(&m.file_path).exists());
assert!(!store.is_key_tombstoned(&m.key));
}
#[test]
fn partial_failure_is_journaled_and_restored_files_can_be_reindexed() {
let (temp, store, adapters, root) = setup();
let m = insert(&store, &root, "a", 100);
fs::create_dir(root.join("a")).unwrap();
fs::write(root.join("a/sidecar"), "side").unwrap();
age(&root.join("a/sidecar"));
age(&root.join("a"));
let c = inventory(&store, &adapters).unwrap().candidates.remove(0);
let moved_path = c.targets[0].path.clone();
let dest = temp.path().join("fake-trash");
let calls = Cell::new(0);
let mut batch = CleanupBatch::new(vec![c], now());
execute_with(
&store,
&adapters,
&mut batch,
&AtomicBool::new(false),
|_| {},
|p| {
calls.set(calls.get() + 1);
if calls.get() == 2 {
bail!("fake permission failure");
}
fs::rename(p, &dest)?;
Ok(())
},
)
.unwrap();
assert_eq!(batch.records[0].targets[0], TargetStatus::Moved);
assert!(matches!(
batch.records[0].targets[1],
TargetStatus::Failed(_)
));
assert!(!batch.records[0].indexed);
assert!(!store.is_key_tombstoned(&m.key));
assert_eq!(history(&store).unwrap().len(), 1);
fs::rename(dest, moved_path).unwrap();
assert_eq!(restore(&store, &adapters, &mut batch).unwrap(), 1);
assert!(batch.records[0].restored);
store.rebuild_all().unwrap();
assert_eq!(history(&store).unwrap().len(), 1);
}
#[test]
fn watcher_race_still_writes_tombstones_and_restore_respects_later_deletion() {
let (temp, store, adapters, root) = setup();
let m = insert(&store, &root, "a", 100);
let c = inventory(&store, &adapters).unwrap().candidates.remove(0);
let dest = temp.path().join("fake-trash");
let mut batch = CleanupBatch::new(vec![c], now());
execute_with(
&store,
&adapters,
&mut batch,
&AtomicBool::new(false),
|_| {},
|p| {
fs::rename(p, &dest)?;
store.remove_session(&m.key)?;
Ok(())
},
)
.unwrap();
assert!(batch.records[0].indexed);
assert!(store.is_key_tombstoned(&m.key));
assert!(store.is_tombstoned(&m.file_path).unwrap());
assert!(restore(&store, &adapters, &mut batch).is_err());
fs::rename(dest, &m.file_path).unwrap();
store
.complete_cleanup(std::slice::from_ref(&m), batch.stamp + 1)
.unwrap();
assert!(restore(&store, &adapters, &mut batch).is_err());
assert!(store.is_key_tombstoned(&m.key));
}
#[test]
fn cancellation_stops_before_next_tree_and_never_claims_it_moved() {
let (temp, store, adapters, root) = setup();
insert(&store, &root, "a", 100);
insert(&store, &root, "b", 100);
let items = inventory(&store, &adapters).unwrap().candidates;
let mut batch = CleanupBatch::new(items, now());
let cancel = AtomicBool::new(false);
execute_with(
&store,
&adapters,
&mut batch,
&cancel,
|_| cancel.store(true, Ordering::Relaxed),
|p| {
fs::rename(p, temp.path().join(p.file_name().unwrap()))?;
Ok(())
},
)
.unwrap();
assert!(batch.records[0].indexed);
assert!(!batch.records[1].indexed);
assert_eq!(batch.records[1].targets, vec![TargetStatus::Pending]);
}
#[test]
fn index_conflict_can_be_retried_and_complete_restore_clears_only_its_tombstone() {
let (temp, store, adapters, root) = setup();
let m = insert(&store, &root, "a", 100);
let item = inventory(&store, &adapters).unwrap().candidates.remove(0);
let dest = temp.path().join("fake-trash");
let mut batch = CleanupBatch::new(vec![item], now());
execute_with(
&store,
&adapters,
&mut batch,
&AtomicBool::new(false),
|_| {},
|p| {
fs::rename(p, &dest)?;
store.set_user_data(&m.key, Some(true), None)?;
Ok(())
},
)
.unwrap();
assert!(!batch.records[0].indexed);
assert_eq!(batch.records[0].targets, vec![TargetStatus::Moved]);
assert_eq!(retry_index_updates(&store, &mut batch).unwrap(), 0);
assert!(store.get_session(&m.key).unwrap().is_some());
store.set_user_data(&m.key, Some(false), None).unwrap();
assert_eq!(retry_index_updates(&store, &mut batch).unwrap(), 1);
assert!(store.is_key_tombstoned(&m.key));
fs::rename(dest, &m.file_path).unwrap();
assert_eq!(restore(&store, &adapters, &mut batch).unwrap(), 1);
assert!(!store.is_key_tombstoned(&m.key));
assert!(!store.is_tombstoned(&m.file_path).unwrap());
assert!(history(&store).unwrap()[0].records[0].restored);
}
#[test]
fn manual_restore_check_never_moves_files_and_requires_complete_sidecars() {
let (temp, store, adapters, root) = setup();
let m = insert(&store, &root, "a", 100);
fs::create_dir(root.join("a")).unwrap();
fs::write(root.join("a/sidecar"), "sidecar").unwrap();
let trash = temp.path().join("fake-trash");
fs::create_dir(&trash).unwrap();
let mut batch = CleanupBatch::new(inventory(&store, &adapters).unwrap().candidates, now());
execute_with(
&store,
&adapters,
&mut batch,
&AtomicBool::new(false),
|_| {},
|path| {
fs::rename(path, trash.join(path.file_name().unwrap()))?;
Ok(())
},
)
.unwrap();
assert!(restore(&store, &adapters, &mut batch).is_err());
assert!(trash.join("a.jsonl").exists() && trash.join("a/sidecar").exists());
assert!(!Path::new(&m.file_path).exists());
assert!(store.is_key_tombstoned(&m.key));
// Simulate the user putting back only the main transcript.
fs::rename(trash.join("a.jsonl"), &m.file_path).unwrap();
assert!(restore(&store, &adapters, &mut batch).is_err());
assert!(trash.join("a/sidecar").exists());
assert!(store.is_key_tombstoned(&m.key));
// Only a complete manual restoration clears this batch's tombstones.
fs::create_dir(root.join("a")).unwrap();
fs::create_dir(root.join("a/sidecar")).unwrap();
assert!(restore(&store, &adapters, &mut batch).is_err());
assert!(store.is_key_tombstoned(&m.key));
fs::remove_dir(root.join("a/sidecar")).unwrap();
// Equal length and timestamp still must not pass with different content.
fs::copy(trash.join("a/sidecar"), root.join("a/sidecar")).unwrap();
fs::write(root.join("a/sidecar"), "corrupt").unwrap();
let modified = fs::metadata(trash.join("a/sidecar"))
.unwrap()
.modified()
.unwrap();
File::options()
.write(true)
.open(root.join("a/sidecar"))
.unwrap()
.set_times(FileTimes::new().set_modified(modified))
.unwrap();
assert!(restore(&store, &adapters, &mut batch).is_err());
assert!(!batch.records[0].restored);
assert!(store.is_key_tombstoned(&m.key));
fs::remove_file(root.join("a/sidecar")).unwrap();
#[cfg(unix)]
{
std::os::unix::fs::symlink(trash.join("a/sidecar"), root.join("a/sidecar")).unwrap();
assert!(restore(&store, &adapters, &mut batch).is_err());
fs::remove_file(root.join("a/sidecar")).unwrap();
}
fs::remove_dir(root.join("a")).unwrap();
fs::rename(trash.join("a"), root.join("a")).unwrap();
assert_eq!(restore(&store, &adapters, &mut batch).unwrap(), 1);
assert!(!store.is_key_tombstoned(&m.key));
assert!(history(&store).unwrap()[0].records[0].restored);
}
#[test]
fn restored_copies_can_have_new_file_identities() {
let (temp, store, adapters, root) = setup();
let m = insert(&store, &root, "a", 100);
let trash = temp.path().join("fake-trash");
let mut batch = CleanupBatch::new(inventory(&store, &adapters).unwrap().candidates, now());
execute_with(
&store,
&adapters,
&mut batch,
&AtomicBool::new(false),
|_| {},
|p| {
fs::rename(p, &trash)?;
Ok(())
},
)
.unwrap();
// Reload the journal, proving content evidence was saved before moving.
batch = history(&store).unwrap().remove(0);
assert_eq!(batch.records[0].content_hashes.len(), 1);
fs::copy(&trash, &m.file_path).unwrap();
assert_ne!(
stamp(&trash).unwrap().identity,
stamp(Path::new(&m.file_path)).unwrap().identity
);
assert_eq!(restore(&store, &adapters, &mut batch).unwrap(), 1);
assert!(!store.is_key_tombstoned(&m.key));
}
#[test]
fn legacy_journals_require_matching_type_length_and_timestamp() {
let (_temp, store, adapters, root) = setup();
let m = insert(&store, &root, "a", 100);
let batch = CleanupBatch::new(inventory(&store, &adapters).unwrap().candidates, now());
let mut saved = serde_json::to_value(batch).unwrap();
saved["records"][0]
.as_object_mut()
.unwrap()
.remove("content_hashes");
let mut batch: CleanupBatch = serde_json::from_value(saved).unwrap();
batch.records[0].targets.fill(TargetStatus::Moved);
store
.complete_cleanup(std::slice::from_ref(&m), batch.stamp)
.unwrap();
let modified = fs::metadata(&m.file_path).unwrap().modified().unwrap();
fs::write(&m.file_path, "truncated").unwrap();
assert!(restore(&store, &adapters, &mut batch).is_err());
fs::write(&m.file_path, "test").unwrap();
assert!(restore(&store, &adapters, &mut batch).is_err());
File::options()
.write(true)
.open(&m.file_path)
.unwrap()
.set_times(FileTimes::new().set_modified(modified))
.unwrap();
assert_eq!(restore(&store, &adapters, &mut batch).unwrap(), 1);
}
#[cfg(any(target_os = "linux", windows))]
#[test]
#[ignore = "Uses the system trash for synthetic temporary files; run explicitly in CI"]
fn system_trash_cleanup_round_trip() {
let (_temp, store, adapters, root) = setup();
let m = insert(&store, &root, "会话 with spaces", 100);
fs::create_dir(root.join(&m.id)).unwrap();
fs::write(root.join(&m.id).join("sidecar.jsonl"), "synthetic sidecar").unwrap();
let mut batch = CleanupBatch::new(inventory(&store, &adapters).unwrap().candidates, now());
assert_eq!(batch.records.len(), 1);
execute(
&store,
&adapters,
&mut batch,
&AtomicBool::new(false),
|_| {},
)
.unwrap();
assert!(batch.records[0].indexed, "{:?}", batch.records[0].error);
assert!(store.is_key_tombstoned(&m.key));
assert!(!Path::new(&m.file_path).exists());
// Only restore the uniquely named temp tree created by this test. Never
// restore or purge unrelated entries in the user's/runner's recycle bin.
let paths = &batch.records[0].candidate.targets;
let items: Vec<_> = trash::os_limited::list()
.unwrap()
.into_iter()
.filter(|item| {
paths
.iter()
.any(|t| same_canonical_path(&item.original_path(), &t.path))
})
.collect();
assert_eq!(items.len(), paths.len());
trash::os_limited::restore_all(items).unwrap();
assert_eq!(restore(&store, &adapters, &mut batch).unwrap(), 1);
assert_eq!(
fs::read_to_string(root.join(&m.id).join("sidecar.jsonl")).unwrap(),
"synthetic sidecar"
);
assert!(!store.is_key_tombstoned(&m.key));
}
}