use super::*;
pub fn resolve_session_files(
paths: &[std::path::PathBuf],
scope: SubagentScope,
caller: Caller,
) -> Result<Vec<PathBuf>> {
let Targets {
session_ids,
session_prefixes,
mut agent_hexes,
project_paths,
explicit_dirs,
session_target,
} = collect_targets(paths)?;
let mut dirs: Vec<ProjectDir> = explicit_dirs;
if !project_paths.is_empty() {
for p in &project_paths {
dirs.push(resolve_target(p)?);
}
} else if dirs.is_empty() {
dirs = all_project_dirs()?;
}
let _ = caller; let mut files: Vec<PathBuf> = Vec::new();
let session_path_active = session_target || agent_hexes.is_empty();
if session_path_active {
let (mut top_level, prefix_hits, prefix_agent_hits) =
scan_top_level(&dirs, &session_ids, &session_prefixes);
resolve_prefix_uniqueness(
&session_prefixes,
&prefix_hits,
&prefix_agent_hits,
&mut agent_hexes,
)?;
let mut sub_files: Vec<PathBuf> = Vec::new();
if matches!(scope, SubagentScope::WithSubagents) {
for sf in &top_level {
sub_files.extend(crate::subagent::subagent_transcript_files(sf)?);
}
}
let session_files: Vec<PathBuf> = match scope {
SubagentScope::TopLevelOnly => top_level,
SubagentScope::WithSubagents => {
top_level.extend(sub_files);
top_level
}
};
if session_files.is_empty() && !session_ids.is_empty() {
bail!(
"no session file found for session id [{}] under the resolved target(s)",
session_ids.join(", ")
);
}
files.extend(session_files);
}
for hex in &agent_hexes {
files.extend(resolve_agent_subtree(&dirs, hex, scope)?);
}
files.sort();
files.dedup();
Ok(files)
}
struct Targets {
session_ids: Vec<String>,
session_prefixes: Vec<String>,
agent_hexes: Vec<String>,
project_paths: Vec<std::path::PathBuf>,
explicit_dirs: Vec<ProjectDir>,
session_target: bool,
}
fn collect_targets(paths: &[std::path::PathBuf]) -> Result<Targets> {
let mut session_ids: Vec<String> = Vec::new();
let mut session_prefixes: Vec<String> = Vec::new();
let mut agent_hexes: Vec<String> = Vec::new();
let mut project_paths: Vec<std::path::PathBuf> = Vec::new();
let mut explicit_dirs: Vec<ProjectDir> = Vec::new();
let mut session_target = false;
for p in paths {
let t = p.to_str().unwrap_or_default();
if let Some(id) = t.strip_prefix('@') {
match id {
"main" => {
eprintln!(
"csift: note: @main resolved the TOP-LEVEL session via env. If you \
are a subagent this is NOT your transcript (a subagent's env \
carries the parent's id); a first-try `@trap:<marker>` hit names \
yours."
);
session_ids.push(resolve_env_session()?);
session_target = true;
}
_ if id.starts_with("trap:") => {
match resolve_trap(id.strip_prefix("trap:").unwrap_or(""))? {
TrapSelf::Agent(hex) => agent_hexes.push(hex),
TrapSelf::Session(sid) => {
session_ids.push(sid);
session_target = true;
}
}
}
_ if is_uuid(id) => {
session_ids.push(id.to_string());
session_target = true;
}
_ if is_subagent_id(id) => agent_hexes.push(id.to_string()),
_ if is_uuid_prefix(id) => {
session_prefixes.push(id.to_string());
session_target = true;
}
_ if id.starts_with('-') || is_drive_encoded_token(id) => {
explicit_dirs.push(resolve_target(Path::new(id))?);
session_target = true;
}
_ => {
let hexish = !id.is_empty() && id.bytes().all(|b| b.is_ascii_hexdigit());
if hexish && id.len() < 4 {
bail!(
"`@{id}` is too short for a session-uuid prefix — a prefix \
needs 4-11 leading (dashless) hex chars; add more characters \
(`csift list` shows the full uuids)"
);
}
bail!(
"`@{id}` is not a recognized @-target — expected `@<uuid>` | \
`@<uuid-prefix>` (4-11 dashless leading hex) | `@<agent-id>` \
(what `csift agents` prints) | `@main` | `@trap:<marker>` | \
`@-Users-…` / `@C--Users-…` (an encoded project dir). A project \
PATH is targeted without `@`."
);
}
}
continue;
}
if t.ends_with(".jsonl") {
let file = crate::path::absolutize(Path::new(t))?;
let file = file.as_path();
if crate::elicitation::is_sidecar_path(file) {
bail!(
"{} is a csift elicitation sidecar (hook-written backfill, \
csift-elicitation marker records only), not a Claude Code session \
transcript. It is read automatically when you target its session; it \
cannot be searched directly.",
file.display()
);
}
let is_sub = file
.components()
.any(|c| c.as_os_str().to_str() == Some("subagents"));
let (dir, sid) = session_file_target(file)?;
explicit_dirs.push(dir);
if is_sub {
agent_hexes.push(crate::subagent::session_id_from_path(file));
} else {
session_ids.push(sid);
session_target = true;
}
continue;
}
if let Some(tok) = p.to_str() {
if (is_uuid(tok) || is_uuid_prefix(tok) || is_subagent_id(tok)) && !p.exists() {
bail!(
"'{tok}' looks like a session/agent id, not a project path — did you \
mean '@{tok}'? (ids are targeted with an `@` prefix: `@<uuid>` | \
`@<uuid-prefix>` | `@<agent-id>`)"
);
}
}
project_paths.push(p.clone());
session_target = true;
}
Ok(Targets {
session_ids,
session_prefixes,
agent_hexes,
project_paths,
explicit_dirs,
session_target,
})
}
type PrefixHits = std::collections::BTreeMap<String, std::collections::BTreeSet<String>>;
fn scan_top_level(
dirs: &[ProjectDir],
session_ids: &[String],
session_prefixes: &[String],
) -> (Vec<PathBuf>, PrefixHits, PrefixHits) {
let mut top_level: Vec<PathBuf> = Vec::new();
let mut prefix_hits: PrefixHits = PrefixHits::new();
let mut prefix_agent_hits: PrefixHits = PrefixHits::new();
let have_filter = !session_ids.is_empty() || !session_prefixes.is_empty();
for pd in dirs {
let read = match std::fs::read_dir(&pd.dir) {
Ok(r) => r,
Err(_) => continue, };
for entry in read.flatten() {
let p = entry.path();
let is_file = entry.file_type().map(|ft| ft.is_file()).unwrap_or(false);
if is_file && p.extension().is_some_and(|e| e == "jsonl") {
admit_entry(
p,
pd,
session_ids,
session_prefixes,
have_filter,
&mut top_level,
&mut prefix_hits,
&mut prefix_agent_hits,
);
}
}
}
(top_level, prefix_hits, prefix_agent_hits)
}
#[allow(clippy::too_many_arguments)]
fn admit_entry(
p: PathBuf,
pd: &ProjectDir,
session_ids: &[String],
session_prefixes: &[String],
have_filter: bool,
top_level: &mut Vec<PathBuf>,
prefix_hits: &mut PrefixHits,
prefix_agent_hits: &mut PrefixHits,
) {
let stem = p
.file_stem()
.and_then(|s| s.to_str())
.unwrap_or_default()
.to_string();
if let Some(want) = &pd.target_cwd {
if let Some(stored) = read_first_cwd(&p) {
if !cwd_equivalent(&stored, want) {
return;
}
}
}
if !session_prefixes.is_empty() {
if let Ok(subs) = crate::subagent::subagent_transcript_files(&p) {
for sp in subs {
let sid = crate::subagent::session_id_from_path(&sp);
for pfx in session_prefixes {
if sid.starts_with(pfx.as_str()) {
prefix_agent_hits
.entry(pfx.clone())
.or_default()
.insert(sid.clone());
}
}
}
}
}
let matched_prefix = session_prefixes
.iter()
.find(|pfx| stem.starts_with(pfx.as_str()))
.cloned();
if have_filter {
let by_id = session_ids.iter().any(|sid| sid == &stem);
if !by_id && matched_prefix.is_none() {
return;
}
}
if let Some(pfx) = matched_prefix {
prefix_hits.entry(pfx).or_default().insert(stem);
}
top_level.push(p);
}
fn resolve_prefix_uniqueness(
session_prefixes: &[String],
prefix_hits: &PrefixHits,
prefix_agent_hits: &PrefixHits,
agent_hexes: &mut Vec<String>,
) -> Result<()> {
for pfx in session_prefixes {
let top = prefix_hits.get(pfx);
let agents = prefix_agent_hits.get(pfx);
let n_top = top.map_or(0, std::collections::BTreeSet::len);
let n_agents = agents.map_or(0, std::collections::BTreeSet::len);
match n_top + n_agents {
0 => bail!(
"no session or agent id starts with `{pfx}` under the resolved target(s) — \
check the prefix, or widen the scope."
),
1 => {
if let Some(a) = agents.and_then(|s| s.iter().next()) {
agent_hexes.push(a.clone());
}
}
n => {
let ids: Vec<&str> = top
.into_iter()
.flatten()
.chain(agents.into_iter().flatten())
.map(String::as_str)
.collect();
bail!(
"`@{pfx}` is AMBIGUOUS: {n} ids start with it ({}). Use more of the id.",
ids.join(", ")
);
}
}
}
Ok(())
}
pub(crate) fn resolve_agent_subtree(
dirs: &[ProjectDir],
hex: &str,
scope: SubagentScope,
) -> Result<Vec<PathBuf>> {
for pd in dirs {
for top in top_level_jsonls(&pd.dir) {
let subs = crate::subagent::subagent_transcript_files(&top)?;
let by_id: std::collections::HashMap<String, PathBuf> = subs
.iter()
.map(|p| (crate::subagent::session_id_from_path(p), p.clone()))
.collect();
if !by_id.contains_key(hex) {
continue; }
let nodes = crate::subagent::build_topology(&top, false)?;
let descendants = subtree_agent_ids(&nodes, hex);
let mut out: Vec<PathBuf> = Vec::new();
if let Some(p) = by_id.get(hex) {
out.push(p.clone());
}
if !matches!(scope, SubagentScope::TopLevelOnly) {
for d in &descendants {
if let Some(p) = by_id.get(d) {
out.push(p.clone());
}
}
}
return Ok(out);
}
}
if hex.len() >= 12 && hex.bytes().all(|b| b.is_ascii_hexdigit()) {
let mut hits: std::collections::BTreeSet<String> = std::collections::BTreeSet::new();
for pd in dirs {
for top in top_level_jsonls(&pd.dir) {
for p in crate::subagent::subagent_transcript_files(&top)? {
let sid = crate::subagent::session_id_from_path(&p);
if sid.starts_with(hex) {
hits.insert(sid);
}
}
}
}
match hits.len() {
1 => {
let full = hits.iter().next().map(String::as_str).unwrap_or(hex);
return resolve_agent_subtree(dirs, full, scope);
}
n if n > 1 => {
let ids: Vec<&str> = hits.iter().map(String::as_str).collect();
bail!(
"`@{hex}` is AMBIGUOUS: {n} agent ids start with it ({}). Use more of the id.",
ids.join(", ")
);
}
_ => {}
}
}
bail!(
"no subagent `{hex}` found under the resolved target(s). List ids with \
`csift agents <session>`, then pass one as `@<agent-hex>`."
)
}
pub(crate) fn subtree_agent_ids(
nodes: &[crate::subagent::SubagentNode],
root: &str,
) -> Vec<String> {
let mut children: std::collections::HashMap<&str, Vec<&str>> = std::collections::HashMap::new();
for n in nodes {
if let Some(p) = n.parent_agent_id.as_deref() {
children.entry(p).or_default().push(n.agent_id.as_str());
}
}
let mut out = Vec::new();
let mut visited = std::collections::HashSet::new();
let mut stack = vec![root];
while let Some(cur) = stack.pop() {
if let Some(kids) = children.get(cur) {
for &k in kids {
if visited.insert(k) {
out.push(k.to_string());
stack.push(k);
}
}
}
}
out
}
pub(crate) fn top_level_jsonls(dir: &Path) -> Vec<PathBuf> {
let mut out = Vec::new();
if let Ok(read) = std::fs::read_dir(dir) {
for entry in read.flatten() {
let p = entry.path();
if entry.file_type().map(|ft| ft.is_file()).unwrap_or(false)
&& p.extension().is_some_and(|e| e == "jsonl")
{
out.push(p);
}
}
}
out
}
#[must_use]
pub fn pins_single_session(token: &str) -> bool {
if let Some(id) = token.strip_prefix('@') {
return id == "main"
|| id.starts_with("trap:")
|| is_uuid(id)
|| is_subagent_id(id)
|| is_uuid_prefix(id);
}
token.ends_with(".jsonl")
}