Skip to content

armgit / Wake

Public Imported from GitHub
0

All your AI agent sessions in one place — browse, search, resume. Rust + GPUI.

Rust
48.5 KB
Raw Blame
use super::parse_utils::*;
use super::AgentAdapter;
use crate::models::*;
use anyhow::{anyhow, Result};
use std::collections::HashMap;
use std::fs;
use std::io::{BufRead, BufReader, ErrorKind};
use std::path::{Path, PathBuf};
use std::sync::Mutex;

/// DeepSeek Harness(dsh):`~/.dsh/sessions/--<cwd转义>--/<id转义>/<日志>`,一目录一会话。
/// 日志文件名带**格式代数**:v0 是 `session.jsonl[.zstd]`,之后每代 `session.vN.jsonl[.zstd]`
/// (issue #45:0.1.6 起写 v3,master 已在写 v4)。dsh 迁移只新增下一代文件、不删旧代,
/// 读的永远是编号最大的那一代——`session_log` 单点裁决。默认落盘是 zstd **多帧连接**
/// (首帧 header 行,之后每次 append 一帧),标准流式解码到 EOF 即可;`compression: none`
/// 配置则是纯文本 .jsonl,两种后缀都认。首行 {type:"session",version,id,createdAt,cwd,…}
/// 给权威 id/cwd/created,不反推目录名。origin=="subagent" 或 delegationDepth>0 是委派出去的
/// 子代理会话(issue #63):照常收录,经首行的 parentSession 挂到派它的会话下面。fork 出来的会话
/// (fork 后端派的子代理、用户自己 fork 的)开头原样复制了父会话到截点为止的事件,截点是最后一个
/// `session/end-seed {inherited: true}`,之前的折成一条、标题 / 模型 / 用量只算之后的。
/// 事件行 {type,seq,time,data}:assistant/message 是一次模型调用的合成体
/// (v0/v1 的 assistant/chunk 与其打包行 *-chunks 直接跳过,v2 起流嵌在消息里),tool/result
/// 按 toolCallId 回填(v0–v3 包在一个 tool-result 块里,v4 直接挂在 tool 角色消息上),
/// system/message(v3 起系统提示在对话里)与 developer/message(v4)归 Meta,session/title
/// 事件 last-wins 给标题,model 在 assistant 消息的 source 里。
pub struct DshAdapter {
    root: PathBuf,
    /// 会话目录 → 最近一次读出来的(日志引用, 父会话 id)。列表、file_ref 与每批监听都问的
    /// parent_links 都要首行里的 id 与 parentSession:首行写下就不变,同一份日志只解压一次,追加
    /// 之后只 stat 选代;换了一代、换了压缩格式才再读一次。目录一时列不出、新的那份一时打不开
    /// (权限、锁)交回上次读到的
    logs: Mutex<HashMap<PathBuf, (SessionFileRef, Option<String>)>>,
    /// `~/.dsh`;直接选中 sessions 目录的自定义根没有
    home: Option<PathBuf>,
}

impl DshAdapter {
    pub fn new() -> Self {
        let home = super::home_dir().unwrap_or_default().join(".dsh");
        Self {
            home: Some(home.clone()),
            ..Self::at(home.join("sessions"))
        }
    }

    fn at(root: PathBuf) -> Self {
        Self {
            root,
            logs: Mutex::new(HashMap::new()),
            home: None,
        }
    }

    /// `<project-dir>/<session-dir>` 固定两层,不 walkdir 全递归(会话目录里还放别的 artifacts)。
    /// 根不在 = 确定没有;根或某个项目目录在却列不出 = 这一刻不知道(None)——列表据此冻结这一家
    /// 这一轮,parent_links 据此保留库里的关系(当成空的话,一个读不出的目录就让全量扫描把会话
    /// 整批删掉、子代理全打回顶层,2026-10-11 Codex review)
    fn session_dirs(&self) -> Option<Vec<PathBuf>> {
        let listed = |dir: &Path| match fs::read_dir(dir) {
            Ok(entries) => Some(entries.collect::<std::io::Result<Vec<_>>>().ok()?),
            Err(e) if e.kind() == ErrorKind::NotFound => Some(Vec::new()),
            Err(_) => None,
        };
        let is_dir = |entry: &fs::DirEntry| entry.file_type().is_ok_and(|t| t.is_dir());
        let mut dirs = Vec::new();
        for project in listed(&self.root)?.iter().filter(|e| is_dir(e)) {
            let sessions = listed(&project.path())?;
            dirs.extend(sessions.iter().filter(|e| is_dir(e)).map(|e| e.path()));
        }
        Some(dirs)
    }

    /// 会话目录 → (被读的那一代日志的引用, 父会话 id)。日志取 dsh 自己会读的那一份:编号最大的
    /// 一代(迁移只新增、不删旧代,旧代的 mtime 可能更新);同一代压缩与明文并存(换过
    /// compression 配置)时 mtime 新者胜、平局 .zstd 胜。list、watcher(经 file_ref)与
    /// parent_links 共用这一处裁决——只做在 list 会让 watcher 把旧代的事件当主文件解析。首行
    /// header 给权威 id(目录名是转义过的 id)。Ok(None) = 确定不是会话(没有日志、首行不是会话
    /// header);目录列不出、日志打不开(权限、锁)交回上次读到的(见 `logs`),没读到过才报错——
    /// parent_links 据此整份交 None。把读不出当成没有,parent_links 会交出缺一截的关系:A 派 B、
    /// B 派 C,B 一时读不出,C 就从 A 下面挪到 B 下面(2026-10-11 Codex review)
    fn session_log(&self, dir: &Path) -> std::io::Result<Option<(SessionFileRef, Option<String>)>> {
        let last = self.logs.lock().unwrap().get(dir).cloned();
        let entries = match fs::read_dir(dir) {
            Ok(entries) => entries,
            Err(e) if e.kind() == ErrorKind::NotFound => return Ok(None),
            Err(e) => return last.map(Some).ok_or(e),
        };
        let Some(((_, mtime, _), path, size)) = entries
            .flatten()
            .filter_map(|entry| {
                let (generation, zstd) = log_generation(&entry.file_name().to_string_lossy())?;
                let path = entry.path();
                let (mtime, size) = stat_stamp(&path).filter(|(_, size)| *size > 0)?;
                Some(((generation, mtime, zstd), path, size))
            })
            .max_by_key(|(rank, ..)| *rank)
        else {
            return Ok(None);
        };
        let same_log = last
            .as_ref()
            .is_some_and(|(r, _)| Path::new(&r.file_path) == path);
        let (native_id, parent) = match last {
            Some((r, parent)) if same_log => (r.native_id, parent),
            // 新目录,或者换了一代、换了压缩格式(解压不持锁)。读到过的会话读不出新的那份(打不开、
            // 首帧坏)就交回上一份——旧代原样留着;换到解析不了的新路径的话,旧路径又不在枚举里,
            // 全量扫描会把会话连同搜索记录删掉(2026-10-11 Codex review)
            _ => match read_header(&path) {
                Ok(Some(header)) => (header.id, header.parent),
                Ok(None) => return Ok(last),
                Err(e) => return last.map(Some).ok_or(e),
            },
        };
        let r = SessionFileRef {
            agent: AgentId::Dsh,
            native_id,
            file_path: path.to_string_lossy().into_owned(),
            mtime_ms: mtime,
            size,
        };
        self.logs
            .lock()
            .unwrap()
            .insert(dir.to_path_buf(), (r.clone(), parent.clone()));
        Ok(Some((r, parent)))
    }
}

/// 打开会话日志为行读取器,按后缀透明解压(.zstd = 多帧连接,Decoder 默认解到
/// EOF)。cap 是缓冲尺寸:只读首行的 header 路径用小值,免得每次列举都预读兆级
fn open_log(path: &Path, cap: usize) -> std::io::Result<Box<dyn BufRead>> {
    let file = fs::File::open(path)?;
    if path.extension().is_some_and(|e| e == "zstd") {
        let dec = zstd::stream::read::Decoder::with_buffer(BufReader::with_capacity(cap, file))?;
        Ok(Box::new(BufReader::with_capacity(cap, dec)))
    } else {
        Ok(Box::new(BufReader::with_capacity(cap, file)))
    }
}

struct DshHeader {
    id: String,
    cwd: String,
    created_at: i64,
    /// 委派出去的子代理会话(origin subagent / delegationDepth > 0)
    subagent: bool,
    /// 派出这个子代理会话的会话 id(首行的 parentSession)。用户自己 fork 出来的会话也写
    /// parentSession,但那是一段独立的对话——dsh 自己也只把子代理当成父会话的孩子——不挂
    parent: Option<String>,
    /// v0 / v1 的 fork 截点:首行的 seedLength,seq 小于它的事件是从父会话复制来的(上游 v1→v2
    /// 迁移同一判法,且要带 parentSession);v2 起换成 `session/end-seed {inherited: true}` 标记
    seed_length: Option<i64>,
    /// 开头带着从父会话复制来的一段:v2 起首行的 isSeeded(上游保证这种会话一定有那个截点标记,
    /// 继承段是空的也补一个),v0 / v1 有 seedLength
    seeded: bool,
}

fn parse_header(v: &serde_json::Value) -> Option<DshHeader> {
    if v.get("type").and_then(|t| t.as_str()) != Some("session") {
        return None;
    }
    let id = v.get("id")?.as_str()?.to_string();
    let subagent = v.get("origin").and_then(|o| o.as_str()) == Some("subagent")
        || v.get("delegationDepth")
            .and_then(|d| d.as_i64())
            .unwrap_or(0)
            > 0;
    let forked_from = text_at(v, "parentSession").filter(|p| *p != id);
    let parent = forked_from.filter(|_| subagent).map(String::from);
    let seed_length = forked_from
        .and(v.get("seedLength"))
        .and_then(|n| n.as_i64())
        .filter(|n| *n > 0);
    Some(DshHeader {
        cwd: v
            .get("cwd")
            .and_then(|c| c.as_str())
            .unwrap_or_default()
            .to_string(),
        created_at: v.get("createdAt").and_then(|t| t.as_i64()).unwrap_or(0),
        seeded: true_at(v, "isSeeded") || seed_length.is_some(),
        id,
        subagent,
        parent,
        seed_length,
    })
}

/// 只读首行拿 header(zstd 惰性解码,不会解整个文件;非会话日志返回 None)
fn read_header(path: &Path) -> std::io::Result<Option<DshHeader>> {
    // 打不开(权限、锁)是这一刻读不出;打开了却读不出首行(坏帧)当不是会话——重试也好不了,
    // 报错会让 parent_links 一直交 None、关系永远冻住
    let mut reader = match open_log(path, 8 << 10) {
        Ok(reader) => reader,
        Err(e) if e.kind() == ErrorKind::NotFound => return Ok(None),
        Err(e) => return Err(e),
    };
    let mut line = String::new();
    if reader.read_line(&mut line).is_err() {
        return Ok(None);
    }
    let header = serde_json::from_str(line.trim_end()).ok();
    Ok(header.as_ref().and_then(parse_header))
}

/// dsh 的事件词汇,照抄上游 `KNOWN_SESSION_EVENT_TYPES`(dsh-session 包的 known-event-types.ts,
/// 生成文件;当前是 v4)。上面有 match 分支的内容事件也在里面——先到先得、这里不会命中;
/// 上游换代时整段替换即可,不用挑
const UPSTREAM_EVENT_TYPES: &[&str] = &[
    "agent-preset/selected",
    "agent/inbox/spliced",
    "approval/asked",
    "approval/decided",
    "approval/policy",
    "assistant/attempt",
    "assistant/message",
    "command/done",
    "command/run",
    "compaction/end",
    "compaction/prune",
    "compaction/start",
    "compaction/summary",
    "deliverables/presented",
    "developer/message",
    "feedback/message-delete",
    "feedback/message-put",
    "feedback/record",
    "goal/change",
    "hook/invoked",
    "hook/result",
    "image/offload",
    "llm/retry",
    "llm/retry-started",
    "model/selection",
    "permission/preset",
    "plan/mode",
    "request/context",
    "request/header",
    "sandbox/mode",
    "schedule/change",
    "session-log-deepseek/delivery-accepted",
    "session/end-seed",
    "session/title",
    "session/title-llm-request",
    "step/end",
    "step/start",
    "subagent/catalog",
    "subagent/descriptor",
    "subagent/model-selection-policy",
    "system/message",
    "team/member",
    "team/message/delivered",
    "team/message/queued",
    "team/task",
    "todo/write",
    "tool-workflow/agent-end",
    "tool-workflow/agent-start",
    "tool-workflow/run-end",
    "tool-workflow/run-start",
    "tool/call",
    "tool/ptc-dispatch",
    "tool/ptc-dispatch-start",
    "tool/result",
    "turn/end",
    "turn/start",
    "user/message",
    "web/deepseek-search-llm-request",
    "workspace/changes",
];

/// 上游清单已经删掉、只在老格式里出现的名字:v0/v1 的 assistant/chunk 与三种 chunk 打包
/// 存储行,v3 前的 tool/code-dispatch*。没被 dsh 重新打开过的老会话不会迁移,照样得认——
/// 只增不减
const LEGACY_EVENT_TYPES: &[&str] = &[
    "assistant/chunk",
    "text-chunks",
    "reasoning-chunks",
    "tool-call-chunks",
    "tool/code-dispatch",
    "tool/code-dispatch-start",
];

/// 已知最新的格式代数。更新的一代照样选中、按形状读,但 header 那一行记一笔 unknown:
/// 字段在已知事件里挪了位置时(v4 的 tool/result 就是),一个事件名都不会漏,只有这一笔
/// 能让 Clean up 知道这个会话读不全
const NEWEST_FORMAT: u64 = 4;

/// 会话日志文件名 → (格式代数, 是否 zstd)。v0 是 `session.jsonl[.zstd]`,之后每代
/// `session.vN.jsonl[.zstd]`(N 从 1 起、不带前导零——`session.v0` / `session.v03` 不是 dsh
/// 会写的名字,认了就会两个名字指同一代);别的文件(session.lock 等)给 None
fn log_generation(name: &str) -> Option<(u32, bool)> {
    let (stem, zstd) = match name.strip_suffix(".zstd") {
        Some(stem) => (stem, true),
        None => (name, false),
    };
    let version = stem.strip_suffix(".jsonl")?.strip_prefix("session")?;
    if version.is_empty() {
        return Some((0, zstd));
    }
    let digits = version.strip_prefix(".v")?;
    if digits.starts_with('0') || !digits.bytes().all(|b| b.is_ascii_digit()) {
        return None;
    }
    Some((digits.parse().ok()?, zstd))
}

struct DshParse {
    header: Option<DshHeader>,
    title: Option<String>,
    /// 子代理的任务名:`subagent/descriptor` 的 label(派活时那句简短说明),截点之后的第一个
    label: Option<String>,
    last_ts: i64,
    messages: Vec<TranscriptMessage>,
    model: Option<String>,
    tokens_used: Option<i64>,
    unknown_lines: u32,
    /// fork 的截点落在第几条消息上:之前的消息是从父会话原样复制来的
    inherited: Option<usize>,
}

impl DshParse {
    /// 到了 fork 的截点:之前的消息是从父会话复制来的(收尾时折成一条);标题、任务名、模型、
    /// 用量都是父会话的,清零,只算会话自己的
    fn cut(&mut self) {
        self.inherited = Some(self.messages.len());
        self.title = None;
        self.label = None;
        self.model = None;
        self.tokens_used = None;
    }

    /// 还在从父会话复制来的那段里(收尾要折掉):里面的图片不必解码,也别占掉会话自己的解码额度
    fn in_seed(&self) -> bool {
        self.inherited.is_none() && self.header.as_ref().is_some_and(|h| h.seeded)
    }
}

fn parse_dsh_log(path: &Path, decode_images: bool) -> Result<DshParse> {
    let _image_budget = transcript_image_decode_budget(decode_images);
    let reader = open_log(path, 1 << 20)?;

    let mut p = DshParse {
        header: None,
        title: None,
        label: None,
        last_ts: 0,
        messages: Vec::new(),
        model: None,
        tokens_used: None,
        unknown_lines: 0,
        inherited: None,
    };
    // toolCallId → (消息下标, tool_calls 下标),tool/result 事件回填用
    let mut tool_index: HashMap<String, (usize, usize)> = HashMap::new();

    for line in reader.lines() {
        let line = match line {
            Ok(l) => l,
            // 末帧可能是半写的(写端每次 append 一帧,扫描与 dsh 天然并发):
            // zstd decoder 对断尾**反复**返回 UnexpectedEof 而非 EOF,`continue`
            // 就是死循环——扫描线程打满 CPU、ScanFinale 永不 Drop、刷新弹窗按
            // 不变量 6 永久锁死。截断到此为止,已解析的部分照常呈现
            Err(_) => {
                p.unknown_lines += 1;
                break;
            }
        };
        if line.trim().is_empty() {
            continue;
        }
        let Ok(row) = serde_json::from_str::<serde_json::Value>(&line) else {
            p.unknown_lines += 1;
            continue;
        };
        let ty = row.get("type").and_then(|v| v.as_str()).unwrap_or_default();
        // 信封顶层的 surfaceOp 是联合类型(dsh-session types.d.ts:
        // `'append' | {op:'replace',start,end}`)——**replace 是对象不是字符串**,
        // 按字符串比永远不命中。compaction 与工具结果裁剪都用它把 start..end 的
        // surface 节点换成缩短版,那是喂模型的上下文;Wake 要还原用户当时看到的
        // 原文,所以整条跳过(留下被它遮蔽的原始节点)。缺失或 append 一律照旧
        if row.pointer("/surfaceOp/op").and_then(|v| v.as_str()) == Some("replace") {
            continue;
        }
        let ts = row.get("time").and_then(|v| v.as_i64()).unwrap_or(0);
        p.last_ts = p.last_ts.max(ts);
        let data = row.get("data").unwrap_or(&serde_json::Value::Null);
        // v0 / v1 没有截点标记:第一个 seq 不小于首行 seedLength 的事件起是会话自己的
        let seed_length = p.header.as_ref().and_then(|h| h.seed_length);
        let seq = row.get("seq").and_then(|v| v.as_i64());
        if p.inherited.is_none() && seed_length.is_some_and(|n| seq.is_some_and(|seq| seq >= n)) {
            p.cut();
        }
        let decode = decode_images && !p.in_seed();
        match ty {
            "session" => {
                if row
                    .get("version")
                    .and_then(|v| v.as_u64())
                    .is_some_and(|v| v > NEWEST_FORMAT)
                {
                    p.unknown_lines += 1;
                }
                if let Some(h) = parse_header(&row) {
                    p.header = Some(h);
                }
            }
            // v3 起系统提示是对话里的一条 system/message;v4 的 developer/message 记会话中途
            // 的变更(工具增删是 tool-addition / tool-removal 块,没有文字)。都是给模型的
            // 上下文、不是对话,归 Meta。图片不解码、只留占位文字:解码了转录那边就只剩图片
            // 没有文字,这条被跳过,之后每条消息的 seq 都和索引错开一位
            "system/message" | "developer/message" => {
                let parsed = content_parts(
                    data.pointer("/message/content")
                        .unwrap_or(&serde_json::Value::Null),
                    false,
                );
                if !parsed.text.is_empty() {
                    p.messages.push(meta_msg(&parsed.text, ts));
                }
            }
            "user/message" => {
                let parsed = content_parts(
                    data.get("content").unwrap_or(&serde_json::Value::Null),
                    decode,
                );
                if parsed.text.is_empty() && parsed.images.is_empty() {
                    continue;
                }
                let kind = data.pointer("/source/kind").and_then(|k| k.as_str());
                let mut m = text_msg(Role::User, &parsed.text, ts);
                m.images = parsed.images;
                // dsh 的 source.kind 权威区分真人输入与注入上下文(实测一族:
                // "agent-instructions"/"plugin"/"skill-catalog",后续还会长)。
                // 白名单 "user":非真人一律归 Meta,缺失时当真人(宁可多显示)
                if kind.is_some_and(|k| k != "user") {
                    m.kind = MessageKind::Meta;
                }
                p.messages.push(m);
            }
            "assistant/message" => {
                let msg = data.get("message").unwrap_or(&serde_json::Value::Null);
                let content = msg.get("content").unwrap_or(&serde_json::Value::Null);
                // 单遍分桶:text 进正文、reasoning 进 thinking、tool-call 进工具
                // (blocks_text 类型盲,会把 reasoning 的 text 混进正文,不适用)
                let mut parsed_message = ParsedContent::default();
                let mut thinking_parts: Vec<&str> = Vec::new();
                let mut tools: Vec<ToolCallView> = Vec::new();
                for b in content.as_array().into_iter().flatten() {
                    let block_text = || {
                        b.get("text")
                            .and_then(|v| v.as_str())
                            .map(str::trim)
                            .filter(|t| !t.is_empty())
                    };
                    match b.get("type").and_then(|v| v.as_str()) {
                        Some("text") => {
                            if let Some(text) = block_text() {
                                parsed_message.push_text(text);
                            }
                        }
                        Some("reasoning") => thinking_parts.extend(block_text()),
                        Some("tool-call") => {
                            let id = b.get("id").and_then(|v| v.as_str()).unwrap_or_default();
                            let name = b.get("name").and_then(|v| v.as_str()).unwrap_or_default();
                            // arguments 是模型原样输出的 JSON 字符串,解析失败保留原文
                            let input = decoded_arguments(
                                b.get("arguments").unwrap_or(&serde_json::Value::Null),
                            );
                            tools.push(tool_call_view(id.to_string(), name, &input, None, false));
                        }
                        _ if is_image_part(b) => {
                            let parsed = content_parts(b, decode);
                            parsed_message.append(parsed);
                        }
                        _ => {}
                    }
                }
                // 元数据先收再判空:content 为空的 assistant/message 是 dsh 专门
                // 用来挂 usage 的载体(dsh-session surface.d.ts:"exists only to
                // host usage",如撞上 max-tokens 的调用),提前 continue 会把这次
                // 调用的 model 与 token 一起丢掉——它落在会话末尾时最明显
                let model = msg
                    .pointer("/source/model")
                    .and_then(|v| v.as_str())
                    .map(String::from);
                if model.is_some() {
                    p.model = model.clone();
                }
                if let Some(u) = data.get("usage") {
                    // TokenUsage 是"one model call"的账、三项 input 互斥(billed =
                    // 三项之和),所以**按调用累加**,不能 last-wins:一个 turn 多个
                    // step,last-wins 只会剩最后一次调用的量
                    let sum = [
                        "inputTokens",
                        "outputTokens",
                        "cacheReadTokens",
                        "cacheWriteTokens",
                    ]
                    .iter()
                    .filter_map(|k| u.get(*k).and_then(|v| v.as_i64()))
                    .sum::<i64>();
                    if sum > 0 {
                        p.tokens_used = Some(p.tokens_used.unwrap_or(0) + sum);
                    }
                }
                if parsed_message.text.is_empty()
                    && tools.is_empty()
                    && thinking_parts.is_empty()
                    && parsed_message.images.is_empty()
                {
                    continue;
                }
                // 截点后的第一段回复另起一条:并进复制来的最后一条回复,收尾折叠时会一起折掉
                if p.inherited == Some(p.messages.len()) {
                    p.messages.push(text_msg(Role::Assistant, "", ts));
                }
                // 一个 turn 多个 step,每 step 一条 assistant/message;连续 assistant
                // 行(中间只隔 tool/result)合并成一条,详情页每回合一条助手消息
                let base = merge_into_last_assistant(
                    &mut p.messages,
                    ts,
                    parsed_message,
                    &thinking_parts.join("\n\n"),
                );
                let last = &mut p.messages[base];
                if model.is_some() {
                    last.model = model;
                }
                for tc in tools {
                    tool_index.insert(tc.id.clone(), (base, last.tool_calls.len()));
                    last.tool_calls.push(tc);
                }
            }
            "tool/result" => {
                // v4:tool 角色消息自己带 toolCallId / content / isError;v0–v3:
                // data.message.content = [tool-result 块],三样包在块里
                let msg = data.get("message").unwrap_or(&serde_json::Value::Null);
                let block = if msg.get("toolCallId").is_some() {
                    msg
                } else {
                    msg.pointer("/content/0")
                        .unwrap_or(&serde_json::Value::Null)
                };
                let Some(call_id) = block.get("toolCallId").and_then(|v| v.as_str()) else {
                    continue;
                };
                if let Some(&(mi, ti)) = tool_index.get(call_id) {
                    let parsed = content_parts(
                        block.get("content").unwrap_or(&serde_json::Value::Null),
                        decode,
                    );
                    let message = &mut p.messages[mi];
                    let tc = &mut message.tool_calls[ti];
                    if !parsed.text.is_empty() {
                        tc.output = Some(clip(&parsed.text, MAX_TOOL_IO).0);
                    }
                    if block.get("isError").and_then(|v| v.as_bool()) == Some(true)
                        || data.get("error").is_some_and(|e| !e.is_null())
                    {
                        tc.is_error = true;
                    }
                    append_images_to_message_end(message, parsed.images);
                }
            }
            // v2 起的 fork 截点(dsh-session fork.ts 的 buildForkSeed;最后一个带 inherited 的
            // 才是本会话的——嵌套 fork 里祖先的标记也在复制来的那段里)
            "session/end-seed" => {
                if true_at(data, "inherited") {
                    p.cut();
                }
            }
            // 子代理在第一个回合里记下的身份;上游按截点之后的第一个算
            "subagent/descriptor" => {
                if p.label.is_none() {
                    p.label = text_at(data, "label").map(clean_title_candidate);
                }
            }
            "session/title" => {
                if let Some(t) = text_at(data, "title") {
                    p.title = Some(clean_title_candidate(t));
                }
            }
            "request/context" => {
                // 路由元数据(仅变更时记录);assistant/message 的 source.model 会覆盖
                if p.model.is_none() {
                    if let Some(m) = data.get("model").and_then(|v| v.as_str()) {
                        p.model = Some(m.to_string());
                    }
                }
            }
            // 信封自带 ignorable 标记 = 写端声明的纯信息性记录,读者可安全跳过
            _ if row.get("ignorable").and_then(|v| v.as_bool()) == Some(true) => {}
            // 其余已知词汇(上游清单 + 老格式名字)跳过,两张表外才计 unknown——保住 schema
            // 漂移金丝雀
            t if UPSTREAM_EVENT_TYPES.contains(&t) || LEGACY_EVENT_TYPES.contains(&t) => {}
            _ => {
                p.unknown_lines += 1;
            }
        }
    }
    if let Some(cut) = p.inherited {
        collapse_inherited(&mut p.messages, cut, "session");
    }
    assign_seq(&mut p.messages);
    Ok(p)
}

fn build_meta(r: &SessionFileRef, p: &DshParse) -> SessionMeta {
    let (native, cwd, created) = match &p.header {
        Some(h) => (h.id.clone(), h.cwd.clone(), h.created_at),
        None => (r.native_id.clone(), String::new(), 0),
    };
    // 改过名的(session/title)> 子代理的任务名 > 第一句话
    let title = p
        .title
        .clone()
        .filter(|t| !t.is_empty())
        .or_else(|| p.label.clone())
        .or_else(|| title_from_messages(&p.messages))
        .unwrap_or_else(|| UNTITLED.to_string());
    SessionMeta {
        key: format!("dsh:{native}"),
        host: String::new(),
        id: native,
        agent: AgentId::Dsh,
        title,
        project_path: cwd.clone(),
        project_name: project_name_of(&cwd),
        file_path: r.file_path.clone(),
        created_at: if created > 0 { created } else { r.mtime_ms },
        updated_at: if p.last_ts > 0 { p.last_ts } else { r.mtime_ms },
        message_count: p
            .messages
            .iter()
            .filter(|m| m.kind == MessageKind::Text)
            .count() as i64,
        size_bytes: r.size,
        git_branch: None,
        model: p.model.clone(),
        tokens_used: p.tokens_used,
        archived: false,
        source: None,
        spawned: p.header.as_ref().is_some_and(|h| h.subagent),
        favorite: false,
        pinned: false,
    }
}

impl AgentAdapter for DshAdapter {
    fn agent(&self) -> AgentId {
        AgentId::Dsh
    }

    fn list_session_files(&self) -> Result<Vec<SessionFileRef>> {
        let dirs = self
            .session_dirs()
            .ok_or_else(|| anyhow!("cannot list {}", self.root.display()))?;
        let refs: Vec<SessionFileRef> = dirs
            .iter()
            .filter_map(|dir| Some(self.session_log(dir).ok()??.0))
            .collect();
        // 删掉的会话目录不留在缓存里
        let alive: std::collections::HashSet<&PathBuf> = dirs.iter().collect();
        self.logs
            .lock()
            .unwrap()
            .retain(|dir, _| alive.contains(dir));
        Ok(refs)
    }

    /// 同一会话的几份日志,新一代恒胜(位次小者胜:v0 = 255、v4 = 251),与
    /// `session_log` 的选代同一把尺子。list 只交出新一代还不够:库里已经记着旧代时
    /// (0.8.2 及以前的 Wake 只认 v0 的名字,或者同步、拷贝来的新代 mtime 反而更旧),
    /// 写库的副本裁决先比位次、再比 mtime,不给位次新代就会被挡回去
    fn dedup_rank(&self, path: &str) -> u8 {
        let generation = Path::new(path)
            .file_name()
            .and_then(|name| log_generation(&name.to_string_lossy()))
            .map_or(0, |(generation, _)| generation);
        u8::MAX - generation.min(u32::from(u8::MAX)) as u8
    }

    fn file_ref(&self, path: &Path) -> Option<SessionFileRef> {
        // 名字先粗筛(session.lock、迁移临时文件等不碰磁盘就不要),再看它是不是这个目录里
        // 被读的那一代
        log_generation(&path.file_name()?.to_string_lossy())?;
        let (r, _) = self.session_log(path.parent()?).ok()??;
        (Path::new(&r.file_path) == path).then_some(r)
    }

    fn manages_parent_links(&self) -> bool {
        true
    }

    /// 子代理会话首行里的 parentSession。每批监听事件都会问:只列目录,读到过的会话直接用缓存
    /// (首行不变),新目录才进去读;没入库的会话 scanner 自己会丢掉。目录列不出、某个会话读不出
    /// 又没读到过,都给 None,库里的关系原样保留
    fn parent_links(&self) -> Option<Vec<(String, String)>> {
        let key = |id: &str| session_key(AgentId::Dsh, "", id);
        let mut links = Vec::new();
        for dir in self.session_dirs()? {
            let known = self.logs.lock().unwrap().get(&dir).cloned();
            let entry = match known {
                Some(known) => Some(known),
                None => self.session_log(&dir).ok()?,
            };
            let Some((r, parent)) = entry else {
                continue;
            };
            if let Some(parent) = parent {
                links.push((key(&r.native_id), key(&parent)));
            }
        }
        Some(links)
    }

    /// 关系写在子会话自己的首行里:多 location 下按子会话的胜出文件认边
    fn parent_links_in_child(&self) -> bool {
        true
    }

    fn parse_session(&self, r: &SessionFileRef) -> Result<ParsedSession> {
        let parsed = parse_dsh_log(Path::new(&r.file_path), false)?;
        let meta = build_meta(r, &parsed);
        Ok(ParsedSession::derive(
            meta,
            &parsed.messages,
            parsed.unknown_lines,
        ))
    }

    fn parse_transcript(&self, r: &SessionFileRef) -> Result<ParsedTranscript> {
        let mut parsed = parse_dsh_log(Path::new(&r.file_path), true)?;
        let meta = build_meta(r, &parsed);
        let mut mainline = std::mem::take(&mut parsed.messages);
        // 后台续跑的子代理:派它的调用只回一句 `started subagent <子会话 id>`(dsh-tool-subagent
        // 的约定;本地跑的子代理 id 就是它的会话 id)。前台跑的结果只有最终文字,不带 id,挂不上
        for call in mainline.iter_mut().flat_map(|m| m.tool_calls.iter_mut()) {
            let child = call
                .output
                .as_deref()
                .and_then(|out| out.trim().strip_prefix("started subagent "))
                .filter(|id| !id.is_empty() && !id.contains(char::is_whitespace));
            if let Some(id) = child {
                call.child_id = Some(id.to_string());
            }
        }
        Ok(ParsedTranscript {
            meta,
            mainline,
            sidechains: Vec::new(),
            unknown_line_count: parsed.unknown_lines,
        })
    }

    fn session_paths(&self, meta: &SessionMeta) -> Vec<String> {
        // 一目录一会话:trash 整个会话目录(各代日志、session.lock 与 artifacts 一起)
        match Path::new(&meta.file_path).parent() {
            Some(dir) => vec![dir.to_string_lossy().to_string()],
            None => vec![meta.file_path.clone()],
        }
    }

    fn cleanup_paths(&self, meta: &SessionMeta) -> Option<Vec<String>> {
        Some(self.session_paths(meta))
    }

    fn with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {
        if dir.join("sessions").is_dir() {
            return Box::new(Self {
                home: Some(dir.clone()),
                ..Self::at(dir.join("sessions"))
            });
        }
        Box::new(Self::at(dir))
    }

    fn data_roots(&self) -> Vec<PathBuf> {
        vec![self.root.clone()]
    }

    fn homes(&self) -> Vec<PathBuf> {
        self.home.iter().cloned().collect()
    }
}

#[cfg(test)]
mod tests {
    use super::{log_generation, parse_dsh_log, parse_header, DshAdapter, DshHeader, DshParse};
    use crate::adapters::AgentAdapter;
    use crate::models::{MessageKind, Role, TranscriptMessage};

    /// 首行再加几个字段(`extra` 是接在 createdAt 后面的 JSON 片段)
    fn header(extra: &str) -> DshHeader {
        let line = format!(r#"{{"type":"session","version":4,"id":"c1","createdAt":1{extra}}}"#);
        parse_header(&serde_json::from_str(&line).unwrap()).unwrap()
    }

    /// 几行日志写进临时文件再解析
    fn parsed(lines: &[&str], decode_images: bool) -> DshParse {
        let dir = tempfile::tempdir().unwrap();
        let path = dir.path().join("session.v4.jsonl");
        std::fs::write(&path, lines.join("\n")).unwrap();
        parse_dsh_log(&path, decode_images).unwrap()
    }

    fn texts(messages: &[TranscriptMessage]) -> Vec<(Role, MessageKind, &str)> {
        messages
            .iter()
            .map(|m| (m.role, m.kind, m.text.as_str()))
            .collect()
    }

    /// 只有子代理挂到父会话下;用户自己 fork 出来的会话也写 parentSession,是独立的对话
    #[test]
    fn only_subagents_hang_under_their_parent() {
        let parent = |extra: &str| header(extra).parent;
        assert_eq!(
            parent(r#","origin":"subagent","delegationDepth":1,"parentSession":"p1""#),
            Some("p1".to_string())
        );
        assert_eq!(
            parent(r#","delegationDepth":2,"parentSession":"p1""#),
            Some("p1".to_string())
        );
        assert_eq!(
            parent(r#","isSeeded":true,"delegationDepth":0,"parentSession":"p1""#),
            None
        );
        assert_eq!(parent(r#","origin":"subagent""#), None);

        // Insights 不算子会话的提问:子代理是 agent 派出去的,用户 fork 的仍是用户自己的对话
        let spawned = |extra: &str| header(extra).subagent;
        assert!(spawned(r#","origin":"subagent""#));
        assert!(spawned(r#","delegationDepth":2,"parentSession":"p1""#));
        assert!(!spawned(
            r#","isSeeded":true,"delegationDepth":0,"parentSession":"p1""#
        ));
    }

    /// v0 / v1 没有截点标记(那时的 session/end-seed 不带 inherited):截点在首行的 seedLength,
    /// seq 小于它的事件是复制来的;只认带 parentSession 的
    #[test]
    fn a_v0_fork_cuts_at_its_seed_length() {
        let parsed = parsed(
            &[
                r#"{"type":"session","version":0,"id":"sub0","createdAt":1,"cwd":"/w","origin":"subagent","delegationDepth":1,"parentSession":"p1","seedLength":3}"#,
                r#"{"type":"user/message","seq":0,"time":10,"data":{"content":[{"type":"text","text":"parent question"}],"source":{"kind":"user"}}}"#,
                r#"{"type":"assistant/message","seq":1,"time":20,"data":{"message":{"content":[{"type":"text","text":"parent answer"}],"source":{"model":"parent-model"}},"usage":{"inputTokens":900,"outputTokens":100}}}"#,
                r#"{"type":"session/title","seq":2,"time":21,"data":{"title":"Parent title"}}"#,
                r#"{"type":"session/end-seed","seq":3,"time":22,"data":{}}"#,
                r#"{"type":"user/message","seq":4,"time":30,"data":{"content":[{"type":"text","text":"child task"}],"source":{"kind":"user"}}}"#,
                r#"{"type":"assistant/message","seq":5,"time":40,"data":{"message":{"content":[{"type":"text","text":"child answer"}],"source":{"model":"child-model"}},"usage":{"inputTokens":40,"outputTokens":2}}}"#,
            ],
            false,
        );
        assert_eq!(
            texts(&parsed.messages),
            vec![
                (
                    Role::System,
                    MessageKind::Meta,
                    "── 2 messages inherited from the parent session ──"
                ),
                (Role::User, MessageKind::Text, "child task"),
                (Role::Assistant, MessageKind::Text, "child answer"),
            ]
        );
        assert_eq!(parsed.title, None, "父会话的标题不算");
        assert_eq!(parsed.model.as_deref(), Some("child-model"));
        assert_eq!(parsed.tokens_used, Some(42));
        assert_eq!(
            parsed.header.as_ref().and_then(|h| h.parent.as_deref()),
            Some("p1")
        );

        // 没有 parentSession 的 seedLength 不作数(上游迁移同一判法)
        assert_eq!(header(r#","seedLength":3"#).seed_length, None);
        assert_eq!(
            header(r#","seedLength":3,"parentSession":"p1""#).seed_length,
            Some(3)
        );
    }

    /// 根目录在却列不出(权限):列表报错、parent_links 给 None——当成空的话,全量扫描会把会话
    /// 整批删掉、子代理全打回顶层。根不在才是确定没有
    #[cfg(unix)]
    #[test]
    fn an_unreadable_root_is_unknown_not_empty() {
        use std::os::unix::fs::PermissionsExt;
        let dir = tempfile::tempdir().unwrap();
        let root = dir.path().join("sessions");
        std::fs::create_dir_all(root.join("--w--").join("s1")).unwrap();
        let adapter = DshAdapter::at(root.clone());
        assert_eq!(adapter.parent_links(), Some(Vec::new()));
        std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o000)).unwrap();
        // root 读得动没有权限的目录,前提不成立就不测
        if std::fs::read_dir(&root).is_err() {
            assert!(adapter.list_session_files().is_err());
            assert_eq!(adapter.parent_links(), None);
        }
        std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o755)).unwrap();
        let missing = DshAdapter::at(dir.path().join("missing"));
        assert!(missing.list_session_files().unwrap().is_empty());
        assert_eq!(missing.parent_links(), Some(Vec::new()));
    }

    /// 日志一时读不出(锁、权限)而它又刚追加过:首行写下就不变,沿用上次读到的,会话不从列表里掉
    #[cfg(unix)]
    #[test]
    fn a_log_that_cannot_be_read_right_now_keeps_its_header() {
        use std::io::Write;
        use std::os::unix::fs::PermissionsExt;
        let dir = tempfile::tempdir().unwrap();
        let session = dir.path().join("--w--").join("s1");
        std::fs::create_dir_all(&session).unwrap();
        let log = session.join("session.jsonl");
        std::fs::write(
            &log,
            "{\"type\":\"session\",\"version\":0,\"id\":\"s1\",\"createdAt\":1}\n",
        )
        .unwrap();
        let adapter = DshAdapter::at(dir.path().to_path_buf());
        assert_eq!(adapter.list_session_files().unwrap().len(), 1);
        let mut file = std::fs::OpenOptions::new().append(true).open(&log).unwrap();
        writeln!(
            file,
            "{{\"type\":\"turn/start\",\"seq\":0,\"time\":2,\"data\":{{}}}}"
        )
        .unwrap();
        drop(file);
        std::fs::set_permissions(&log, std::fs::Permissions::from_mode(0o000)).unwrap();
        let listed = adapter.list_session_files().unwrap();
        std::fs::set_permissions(&log, std::fs::Permissions::from_mode(0o644)).unwrap();
        assert_eq!(
            listed
                .iter()
                .map(|r| r.native_id.as_str())
                .collect::<Vec<_>>(),
            vec!["s1"]
        );
    }

    /// A 派 B、B 派 C,B 的目录一时读不出:读到过的照旧报全(少了 B→A 的快照会让 scanner 把 C
    /// 从 A 下面挪到 B 下面),列表里 B 也还在;重启后从没读到过,parent_links 整份给 None
    #[cfg(unix)]
    #[test]
    fn a_session_directory_that_turns_unreadable_keeps_its_place() {
        use std::os::unix::fs::PermissionsExt;
        let dir = tempfile::tempdir().unwrap();
        let project = dir.path().join("--w--");
        for (id, parent) in [("a", None), ("b", Some("a")), ("c", Some("b"))] {
            let session = project.join(id);
            std::fs::create_dir_all(&session).unwrap();
            let link = parent.map_or(String::new(), |p| {
                format!(r#","origin":"subagent","delegationDepth":1,"parentSession":"{p}""#)
            });
            let header =
                format!(r#"{{"type":"session","version":4,"id":"{id}","createdAt":1{link}}}"#);
            std::fs::write(session.join("session.v4.jsonl"), header + "\n").unwrap();
        }
        let warm = DshAdapter::at(dir.path().to_path_buf());
        let links = |adapter: &DshAdapter| {
            adapter.parent_links().map(|mut links| {
                links.sort();
                links
            })
        };
        let full = links(&warm);
        assert_eq!(full.as_ref().map(Vec::len), Some(2));
        assert_eq!(warm.list_session_files().unwrap().len(), 3);

        let b = project.join("b");
        std::fs::set_permissions(&b, std::fs::Permissions::from_mode(0o000)).unwrap();
        let unreadable = std::fs::read_dir(&b).is_err(); // root 读得动
        let warm_now = (links(&warm), warm.list_session_files().unwrap().len());
        let cold = DshAdapter::at(dir.path().to_path_buf());
        let cold_now = (links(&cold), cold.list_session_files().unwrap().len());
        std::fs::set_permissions(&b, std::fs::Permissions::from_mode(0o755)).unwrap();
        if unreadable {
            assert_eq!(warm_now, (full.clone(), 3));
            assert_eq!(cold_now, (None, 2));
        }
        assert_eq!(links(&cold), full);
    }

    /// 读到过的会话换了一代日志,新的那份读不出(首帧坏、一时打不开):交回上一代,会话不从列表里
    /// 掉——换到解析不了的新路径的话,旧路径又不在枚举里,全量扫描会把它从索引里删掉
    #[test]
    fn a_new_generation_that_cannot_be_read_keeps_the_old_one() {
        let dir = tempfile::tempdir().unwrap();
        let session = dir.path().join("--w--").join("s1");
        std::fs::create_dir_all(&session).unwrap();
        let header = |version: u32| {
            format!(r#"{{"type":"session","version":{version},"id":"s1","createdAt":1}}"#) + "\n"
        };
        let (v0, v4) = (
            session.join("session.jsonl"),
            session.join("session.v4.jsonl"),
        );
        std::fs::write(&v0, header(0)).unwrap();
        let adapter = DshAdapter::at(dir.path().to_path_buf());
        let listed = || -> Vec<String> {
            let refs = adapter.list_session_files().unwrap();
            refs.into_iter().map(|r| r.file_path).collect()
        };
        let path = |p: &std::path::Path| vec![p.to_string_lossy().into_owned()];
        assert_eq!(listed(), path(&v0));

        std::fs::write(&v4, "not a header\n").unwrap();
        assert_eq!(listed(), path(&v0), "首帧坏的新一代不顶掉读得出的旧代");

        #[cfg(unix)]
        {
            use std::os::unix::fs::PermissionsExt;
            std::fs::write(&v4, header(4)).unwrap();
            std::fs::set_permissions(&v4, std::fs::Permissions::from_mode(0o000)).unwrap();
            // root 读得动没有权限的文件,前提不成立就不测
            let unreadable = std::fs::read(&v4).is_err();
            let now = listed();
            std::fs::set_permissions(&v4, std::fs::Permissions::from_mode(0o644)).unwrap();
            if unreadable {
                assert_eq!(now, path(&v0), "一时打不开的新一代不顶掉旧代");
            }
        }
        std::fs::write(&v4, header(4)).unwrap();
        assert_eq!(listed(), path(&v4));
    }

    /// 截点后紧跟着的回复另起一条:并进复制来的最后一条回复,折叠时会被一起折掉
    #[test]
    fn a_reply_right_after_the_cut_is_its_own() {
        let parsed = parsed(
            &[
                r#"{"type":"session","version":4,"id":"f1","createdAt":1,"isSeeded":true,"delegationDepth":0,"parentSession":"p1"}"#,
                r#"{"type":"user/message","seq":0,"time":10,"data":{"content":[{"type":"text","text":"parent question"}],"source":{"kind":"user"}}}"#,
                r#"{"type":"assistant/message","seq":1,"time":20,"data":{"message":{"content":[{"type":"text","text":"parent answer"}]}}}"#,
                r#"{"type":"session/end-seed","seq":2,"time":20,"data":{"inherited":true}}"#,
                r#"{"type":"assistant/message","seq":3,"time":30,"data":{"message":{"content":[{"type":"text","text":"the fork's own answer"}]}}}"#,
            ],
            false,
        );
        assert_eq!(
            texts(&parsed.messages),
            vec![
                (
                    Role::System,
                    MessageKind::Meta,
                    "── 2 messages inherited from the parent session ──"
                ),
                (Role::Assistant, MessageKind::Text, "the fork's own answer"),
            ]
        );
    }

    /// 复制来的那段里的图片不解码(收尾要折掉,还占会话自己的解码额度);截点之后照常解码
    #[test]
    fn images_after_the_cut_are_decoded() {
        let png = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=";
        let user = |seq: u32| {
            format!(
                r#"{{"type":"user/message","seq":{seq},"time":{seq},"data":{{"content":[{{"type":"text","text":"look"}},{{"type":"image","media_type":"image/png","data":"{png}"}}],"source":{{"kind":"user"}}}}}}"#
            )
        };
        let (inherited, own) = (user(0), user(2));
        let parsed = parsed(
            &[
                r#"{"type":"session","version":4,"id":"f1","createdAt":1,"isSeeded":true,"parentSession":"p1"}"#,
                &inherited,
                r#"{"type":"session/end-seed","seq":1,"time":1,"data":{"inherited":true}}"#,
                &own,
            ],
            true,
        );
        assert_eq!(parsed.messages.len(), 2);
        assert_eq!(parsed.messages[1].images.len(), 1);
    }

    #[test]
    fn log_names_carry_their_format_generation() {
        assert_eq!(log_generation("session.jsonl"), Some((0, false)));
        assert_eq!(log_generation("session.jsonl.zstd"), Some((0, true)));
        assert_eq!(log_generation("session.v3.jsonl.zstd"), Some((3, true)));
        assert_eq!(log_generation("session.v12.jsonl"), Some((12, false)));
        // dsh 不会写的名字:v0 不带版本号、没有前导零;锁文件与别的 artifacts 不是日志
        for name in [
            "session.v0.jsonl",
            "session.v03.jsonl.zstd",
            "session.v.jsonl",
            "session.v3a.jsonl",
            "session.v3.jsonl.tmp",
            "session.lock",
            "notes.jsonl",
        ] {
            assert_eq!(log_generation(name), None, "{name}");
        }
    }
}