Skip to content

armgit / Wake

Public Imported from GitHub
0

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

Rust

fix(dsh): index subagent sessions under the session that started them

Corey Chiu080ba36018d2
diff --git a/CHANGELOG.md b/CHANGELOG.md
index b9cfad9..f34bbd3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,7 @@
- New: Grok Bot conversations show up in Wake, read from what the Grok Bot desktop app keeps on this computer — the latest messages of your recent conversations; in group chats each message shows which bot sent it. A conversation the app no longer keeps stays listed with its last message, and deleting one in Wake only hides it, since the conversation itself lives in Grok Bot's cloud
- Fix: The Settings title lines up with the window buttons and the icons below it, as the main window's title already did
+- Fix: DeepSeek Harness subagent sessions are indexed and listed under the session that started them, titled with their task; a subagent or forked session no longer repeats the conversation it started from, and its tokens are its own. Existing indexes are re-read once after upgrading (#63, thanks @ztcngadget888)
## [0.9.1] — 2026-10-10
diff --git a/PRODUCT.md b/PRODUCT.md
index ba60323..b1116af 100644
--- a/PRODUCT.md
+++ b/PRODUCT.md
@@ -30,7 +30,7 @@ Corey 本人(独立开发者,主力工具 Claude Code 与 Codex,中文为主)。
已实现:二十三家 adapter、FTS5 trigram 搜索(<3 码点 LIKE 降级)、**搜索跳转定位**(2026-08-18:⌘K 命中直达详情页对应消息并高亮,seq 契约保证)、详情页逐消息渲染(气泡/工具折叠簇/thinking/tree-sitter 高亮;2026-08-17 由整篇 markdown 方案升级)、恢复/收藏/置顶/导出/删除(废纸篓+墓碑)、文件监听增量、Insights 统计页(0.3.0:活跃热力图与 streak、时段/星期/月份分布、Agents·Projects·Models 三榜单按 sessions/tokens/prompts 切换;2026-09-03 加 Last 7 days 周对比行与 Over time 近 53 周按 agent 堆叠的每周 prompts 趋势图;口径=主线用户消息,规格见 DESIGN.md)、Updates 页与 macOS Wake 菜单手动检查 GitHub 最新正式版并打开 Release 页更新(不后台联网、不自动替换应用包)、测试套件(adapter 契约、DB 往返、scanner 回归 + CI 三平台 + pre-commit,合成 fixture)、三端桌面(macOS 主平台;Linux/Windows experimental,终端恢复/废纸篓·回收站/剪贴板按平台原生实现,发版 CI 自动出六产物)、窗口记忆(0.3.6:记住所在屏幕/屏内位置/最大化/全屏,重启与 Dock 重开都回到原处,Settings 开在主窗所在屏)、完整 macOS 菜单栏(0.3.6:标准 Edit/Window 菜单、⌘W、Window → Main Window,主窗关闭后 About/Settings/Updates 仍可用)、导出 Markdown 与保存图片走系统「另存为」并记住上次目录(0.3.6,issue #25)、远程 host(0.4.0,issue #21:Settings → Remote hosts 配 SSH 目标,rsync 白名单镜像会话数据到本地缓存后与本地会话同列同搜,`@host` 徽章标识;阶段 1 只读——不动远端文件、远程会话禁删,resume 以 Copy SSH command 形态提供;分期计划见 CLAUDE.md「远程 host」节)、**MCP 接入**(0.5.0:随应用打包的只读 `wake-mcp` stdio server,四个工具 wake_search / wake_list_sessions / wake_get_session / wake_list_projects,Claude Code / Codex / Cursor 等任何 MCP 客户端可搜历史、按项目列会话、分页读转录;Settings → Connect 展示路径与可复制配置片段,只展示不代写别家配置;零 LLM、零网络、不写库;完整参考 docs/mcp.md)、**命令行与 Skill**(0.6.0:并排打包的只读 `wake-cli`,四个子命令 search / sessions / show / projects 加 setup,给"能跑 shell 但不说 MCP"的 agent 和真人用——它不新写查询逻辑,argv 翻成 JSON 喂同一批工具,输出与 MCP 客户端看到的**逐字节相同**(仅 CLI 末尾补一个换行)并由测试卡住,所以文档只需描述一份格式;`skills/wake/SKILL.md` 是可一行安装的 skill(`npx skills add iAmCorey/Wake`),用触发条件而非名词解释写 description,让 agent 自己想得起来去翻会话历史;完整参考 docs/cli.md;0.6.3 加 `wake-cli index`——装了 Wake 却从没启动过时,agent 自己跑一条就能把索引建起来继续干活,而不是停下来问人。它**只建不存在的索引**,已有的库原样交给 GUI:扫描落在旁边的临时库、扫完才原子占位,所以被中途杀掉可重试、撞上 GUI 首扫就退让;2026-09-22 加 `wake-cli refresh`,issue #43:app 不开时增量刷新已有索引,给靠 MCP / CLI 用 Wake、只在浏览时开 app 的人用 launch agent / systemd timer 定时跑,Wake 开着窗或还有扫描在写就退让——GUI 与两个写命令共用一把索引写锁,锁跟 Workbench 与写线程走、关窗即放,GUI 启动会等正在跑的 refresh 收尾)、Connect 页四区块(0.6.1:MCP server / MCP clients / Command line / Skill,每个面的第一块挂自己的文档链接)、**记忆可见层**(2026-09-17 起,只读:把各家 agent 自己写下的记忆——Claude Code 的按项目 auto-memory、Codex 的 memories 与逐会话摘要、ZCode 的按项目记忆——按项目聚合;GUI 的 Memory 页是侧栏底部的整页目的地,侧栏在这一页换成按记忆计数的 All Memory / Agents / Projects 导航;MCP 加第五个工具 `wake_list_memories`,`wake_get_session` 认 `wake://memory/…` 引用现场读文件,`wake_search` 末尾附记忆命中;CLI 加 `memories`;记忆的项目归属按它挂的会话在读时解析,永远跟着索引走。二期(2026-09-21)把用户写给 agent 的指令文件也收进来:各家 home 里的 CLAUDE.md / AGENTS.md(与 `rules/*.rules`)/ GEMINI.md,以及已索引项目根下的 CLAUDE.md / AGENTS.md / GEMINI.md / `.cursor/rules` / `.cursorrules` / `.kiro/steering` / `.github/copilot-instructions.md`,与记忆同列同搜、不另作区分;Settings 加 Memory locations 页,与 Session locations 同形制:逐来源开关、添加自定义目录或文件、Restore defaults。不编辑、不同步、不删除——写别家数据破铁律,要改一个 Reveal 就到;也不做"把会话自动写成记忆")。后续边界(2026-09-07 定):摘要层(需 LLM、opt-in、明示会把会话正文发给用户配置的端点)只在 MCP 接入有真实使用之后再做;Timeline / Profile 一类视图建立在摘要之上;不做 ChatGPT / Claude.ai 导出导入主线、不做实体本体与知识图谱、不做 Chrome 扩展注入。
约束:对 agent 数据目录只读;绝不写 Codex 的 SQLite;不读凭证;GPUI 无 SF Symbols(图标用 lucide SVG 自备)。
-已支持二十三家 agent:Claude Code、Codex(0.6.6 起排除可识别的内部线程:guardian auto-review、`/review`、compaction、memory consolidation 与用户会话同树,adapter 文件边界按首行 session_meta 的 source / thread_source 认出即不枚举;老格式或读不出的首行保守放行,`codex exec --thread-source` 打了标签的自动化线程照常收录,issue #30。`spawn_agent` 子代理是其中唯一的例外,issue #42:那是用户自己派出去的活,收录后挂在派它的会话下面、以任务名为标题,fork 进来的父线程历史折成一条不入库的占位,父会话的对话不会被索引两遍)、Qoder CLI(`~/.qoder/projects` JSONL,active-leaf 分支恢复、tool result 回挂、`QODER_CONFIG_DIR`)、Copilot CLI、Cursor(CLI 转录 + 0.6.7 起 IDE Chat/Composer 历史,PR #32:`globalStorage/state.vscdb` 明文 KV 库,composerData 给顺序、bubbleId 行给正文;转录带正文的会话归转录源,库只补转录缺失或只剩 turn_ended 空壳的会话;库里多数老会话没存工作区路径,落 Unknown project)、OpenCode(含 OpenCode 2 next,stable 的 `opencode.db` 与 next 的 `opencode-next.db` 同时扫描;逐会话兼容 `message+part`、真实 `session+session_message` 及早期 `session_v2` schema;preview 会话标 opencode2 徽章)、Kiro、Gemini CLI(2026-08-17 P1 五家落地)+ Pi、Oh My Pi、Grok Build、Kimi Code、Antigravity(2026-08-19 对齐 kooky 内置 roster,起初只有 `antigravity-cli` 会话索引里的元数据卡片——正文是加密 .pb;2026-10-08 起读新版本桌面端与 IDE 写在 `~/.gemini/antigravity/brain`、`~/.gemini/antigravity-ide/brain` 的明文转录,含工具输出、模型与用户贴图,IDE 会话挂 via 徽章,同一会话转录与卡片按 id 只出一份、没有转录的仍列卡片;显示名由 Antigravity CLI 改为 Antigravity。格式取自 PR #52 @iroha3 对真实数据的整理,本机 brain 目录还没有转录,未经真机验证)+ DeepSeek Harness(dsh,2026-08-20,zstd 事件日志透明解压;格式由源码推断,当天用户跑出真实会话完成首验)+ Hermes Agent(2026-09-03,多档案 state.db,无 cwd 故 project 留空)、OpenClaw(2026-09-03,两代存储同扫;本机零会话,格式由源码推断未经真机验证)、CodeBuddy(2026-09-14,issue #27:`~/.codebuddy/projects` 的 Responses 形 JSONL,custom / ai / topic 三级标题,`CODEBUDDY_CONFIG_DIR`;本机零会话,格式由官方 CLI 文档与三家第三方实现交叉推断、未经真机验证)、WorkBuddy(同日,CodeBuddy 的孪生实例:同一解析核心,`~/.workbuddy/projects`、`WORKBUDDY_CONFIG_DIR`;桌面 app 无 CLI,不提供 resume;同构只有 cc-switch 一家佐证)、ZCode(2026-09-21:Z.ai 的 GLM-5.3 官方 harness,桌面 app;运行时是 OpenCode 衍生物——`~/.zcode/cli/db/db.sqlite` 的 session/message/part 与 OpenCode v1 同形、part 解码复用,但 session 表没有 model/tokens 列故另起一家;`v2/tasks-index.sqlite` 只借 deleted / migration_source 两个过滤位;按 `task_type` 白名单只列 interactive / fork / selection_side_chat(subagent_child 等运行时会话不列);`semantics.transcriptVisibility == hidden` 与用户消息 `origin != real_user` 归 Meta、compact_summary 折成一条、字段缺席放行;`ZCODE_STORAGE_DIR`;桌面 app 无 CLI、`zcode://` 没有按会话打开的深链,不提供 resume;本机 3.14.0 真会话首验通过,同日开源(Apache-2.0)后语义全部按源码核对)、Craft Agents(2026-09-24,issue #44:Craft Docs 的开源桌面 app,自己不带引擎——Anthropic 连接跑 Claude Agent SDK、其余连接(ChatGPT / Codex 订阅、Copilot、Google)跑 Pi SDK,另记一份给用户看的 `~/.craft-agent/workspaces/<工作区>/sessions/<id>/session.jsonl`,Wake 读这一份;子任务与分支挂回原会话,分支从父会话复制来的那段折成一条;Claude 连接在 `~/.claude/projects` 留下的引擎副本由通用的"认领"机制藏掉,原件还在才藏;工作区可建在任意位置,但登记表带 server token 不读,别处的工作区走 Session locations;桌面 app 无 CLI,不提供 resume;本机 0.13.5 真会话首验通过,ChatGPT 与 Claude 连接各一条)、Devin(2026-09-24,issue #46:`~/.local/share/devin/cli/sessions.db` 单库两表,message_nodes 森林按 `main_chain_id` 叶子沿 `parent_node_id` 取主链,hidden 会话与零正文不列,逐消息 `generation_model` 与 `metrics` 按主链累计;`XDG_DATA_HOME`;`devin --resume <id>` 按 cwd 分桶 resume;格式按本机真库验证)、Kilo Code(2026-10-07,issue #59:一家两源——2026-04 起的新版 VS Code 扩展、`kilo` CLI 与 JetBrains 插件是 OpenCode 分支,三端共用 `~/.local/share/kilo/kilo.db`,表与 OpenCode 同形、按 OpenCode 的孪生实例读;session_message 里只有实验开关零星双写的 shell 一类记录时读 message + part(OpenCode 同一条规则);旧版扩展(Roo / Cline 系)每个任务一个目录,在各个 VS Code 系编辑器的 `globalStorage/kilocode.kilo-code/tasks` 里,正文是 Anthropic 消息数组,`<task>` / `<feedback>` / `<answer>` 才是人打的字、编辑器快照丢掉,旧任务用新版导入时给的 `ses_migrated_` id,导入过的那份 kilo.db 胜出;新版 `kilo --session` 在原项目目录续,旧任务没有 Open In、也不实时监听(任务目录里有整份 checkpoints 影子仓库);kilo.db 里同库存着凭证,远程只同步 vscode-server 下的旧任务;本机零会话,新版的表结构按源码的建库语句核过,数据形状由源码推断、未经真机验证)、Grok Bot(2026-10-11:xAI 的常驻 agent,桌面 app 由 Cursor 出品,bot 跑在云端电脑上,对话也存在那里;本机只有桌面端的滚动缓存 `<userData>/sand-client-persistence`——每个对话只留最近 200 条、最多 24 个对话、7 天没写过的被 app 自己清掉。用户定"跟着缓存走":缓存里有的对话出完整消息(你的话、bot 的话、群聊里标出是哪个 bot、bot 之间互发的消息、提问卡片与你的回答、邮件草稿、审批),被清出缓存的退成侧栏列表里的一张卡片(描述 + 最后一条预览),不会从 Wake 里消失;对话本体在云端,删除只隐藏、不动缓存文件;没有命令行,不提供 resume;不做远程同步;格式按 0.68.1 的 app 源码与本机 14 个真实对话核对)。做不了的:Windsurf/Trae 加密,Amp/Factory(Droid)/Warp 云端无本地数据,Reasonix 本机零会话格式未实测。
+已支持二十三家 agent:Claude Code、Codex(0.6.6 起排除可识别的内部线程:guardian auto-review、`/review`、compaction、memory consolidation 与用户会话同树,adapter 文件边界按首行 session_meta 的 source / thread_source 认出即不枚举;老格式或读不出的首行保守放行,`codex exec --thread-source` 打了标签的自动化线程照常收录,issue #30。`spawn_agent` 子代理是其中唯一的例外,issue #42:那是用户自己派出去的活,收录后挂在派它的会话下面、以任务名为标题,fork 进来的父线程历史折成一条不入库的占位,父会话的对话不会被索引两遍)、Qoder CLI(`~/.qoder/projects` JSONL,active-leaf 分支恢复、tool result 回挂、`QODER_CONFIG_DIR`)、Copilot CLI、Cursor(CLI 转录 + 0.6.7 起 IDE Chat/Composer 历史,PR #32:`globalStorage/state.vscdb` 明文 KV 库,composerData 给顺序、bubbleId 行给正文;转录带正文的会话归转录源,库只补转录缺失或只剩 turn_ended 空壳的会话;库里多数老会话没存工作区路径,落 Unknown project)、OpenCode(含 OpenCode 2 next,stable 的 `opencode.db` 与 next 的 `opencode-next.db` 同时扫描;逐会话兼容 `message+part`、真实 `session+session_message` 及早期 `session_v2` schema;preview 会话标 opencode2 徽章)、Kiro、Gemini CLI(2026-08-17 P1 五家落地)+ Pi、Oh My Pi、Grok Build、Kimi Code、Antigravity(2026-08-19 对齐 kooky 内置 roster,起初只有 `antigravity-cli` 会话索引里的元数据卡片——正文是加密 .pb;2026-10-08 起读新版本桌面端与 IDE 写在 `~/.gemini/antigravity/brain`、`~/.gemini/antigravity-ide/brain` 的明文转录,含工具输出、模型与用户贴图,IDE 会话挂 via 徽章,同一会话转录与卡片按 id 只出一份、没有转录的仍列卡片;显示名由 Antigravity CLI 改为 Antigravity。格式取自 PR #52 @iroha3 对真实数据的整理,本机 brain 目录还没有转录,未经真机验证)+ DeepSeek Harness(dsh,2026-08-20,zstd 事件日志透明解压;格式由源码推断,当天用户跑出真实会话完成首验;2026-10-11 起委派出去的子代理会话也收录,挂在派它的会话下、以任务名为标题,issue #63,fork 出来的会话开头复制的父会话历史折成一条,token 只算自己的)+ Hermes Agent(2026-09-03,多档案 state.db,无 cwd 故 project 留空)、OpenClaw(2026-09-03,两代存储同扫;本机零会话,格式由源码推断未经真机验证)、CodeBuddy(2026-09-14,issue #27:`~/.codebuddy/projects` 的 Responses 形 JSONL,custom / ai / topic 三级标题,`CODEBUDDY_CONFIG_DIR`;本机零会话,格式由官方 CLI 文档与三家第三方实现交叉推断、未经真机验证)、WorkBuddy(同日,CodeBuddy 的孪生实例:同一解析核心,`~/.workbuddy/projects`、`WORKBUDDY_CONFIG_DIR`;桌面 app 无 CLI,不提供 resume;同构只有 cc-switch 一家佐证)、ZCode(2026-09-21:Z.ai 的 GLM-5.3 官方 harness,桌面 app;运行时是 OpenCode 衍生物——`~/.zcode/cli/db/db.sqlite` 的 session/message/part 与 OpenCode v1 同形、part 解码复用,但 session 表没有 model/tokens 列故另起一家;`v2/tasks-index.sqlite` 只借 deleted / migration_source 两个过滤位;按 `task_type` 白名单只列 interactive / fork / selection_side_chat(subagent_child 等运行时会话不列);`semantics.transcriptVisibility == hidden` 与用户消息 `origin != real_user` 归 Meta、compact_summary 折成一条、字段缺席放行;`ZCODE_STORAGE_DIR`;桌面 app 无 CLI、`zcode://` 没有按会话打开的深链,不提供 resume;本机 3.14.0 真会话首验通过,同日开源(Apache-2.0)后语义全部按源码核对)、Craft Agents(2026-09-24,issue #44:Craft Docs 的开源桌面 app,自己不带引擎——Anthropic 连接跑 Claude Agent SDK、其余连接(ChatGPT / Codex 订阅、Copilot、Google)跑 Pi SDK,另记一份给用户看的 `~/.craft-agent/workspaces/<工作区>/sessions/<id>/session.jsonl`,Wake 读这一份;子任务与分支挂回原会话,分支从父会话复制来的那段折成一条;Claude 连接在 `~/.claude/projects` 留下的引擎副本由通用的"认领"机制藏掉,原件还在才藏;工作区可建在任意位置,但登记表带 server token 不读,别处的工作区走 Session locations;桌面 app 无 CLI,不提供 resume;本机 0.13.5 真会话首验通过,ChatGPT 与 Claude 连接各一条)、Devin(2026-09-24,issue #46:`~/.local/share/devin/cli/sessions.db` 单库两表,message_nodes 森林按 `main_chain_id` 叶子沿 `parent_node_id` 取主链,hidden 会话与零正文不列,逐消息 `generation_model` 与 `metrics` 按主链累计;`XDG_DATA_HOME`;`devin --resume <id>` 按 cwd 分桶 resume;格式按本机真库验证)、Kilo Code(2026-10-07,issue #59:一家两源——2026-04 起的新版 VS Code 扩展、`kilo` CLI 与 JetBrains 插件是 OpenCode 分支,三端共用 `~/.local/share/kilo/kilo.db`,表与 OpenCode 同形、按 OpenCode 的孪生实例读;session_message 里只有实验开关零星双写的 shell 一类记录时读 message + part(OpenCode 同一条规则);旧版扩展(Roo / Cline 系)每个任务一个目录,在各个 VS Code 系编辑器的 `globalStorage/kilocode.kilo-code/tasks` 里,正文是 Anthropic 消息数组,`<task>` / `<feedback>` / `<answer>` 才是人打的字、编辑器快照丢掉,旧任务用新版导入时给的 `ses_migrated_` id,导入过的那份 kilo.db 胜出;新版 `kilo --session` 在原项目目录续,旧任务没有 Open In、也不实时监听(任务目录里有整份 checkpoints 影子仓库);kilo.db 里同库存着凭证,远程只同步 vscode-server 下的旧任务;本机零会话,新版的表结构按源码的建库语句核过,数据形状由源码推断、未经真机验证)、Grok Bot(2026-10-11:xAI 的常驻 agent,桌面 app 由 Cursor 出品,bot 跑在云端电脑上,对话也存在那里;本机只有桌面端的滚动缓存 `<userData>/sand-client-persistence`——每个对话只留最近 200 条、最多 24 个对话、7 天没写过的被 app 自己清掉。用户定"跟着缓存走":缓存里有的对话出完整消息(你的话、bot 的话、群聊里标出是哪个 bot、bot 之间互发的消息、提问卡片与你的回答、邮件草稿、审批),被清出缓存的退成侧栏列表里的一张卡片(描述 + 最后一条预览),不会从 Wake 里消失;对话本体在云端,删除只隐藏、不动缓存文件;没有命令行,不提供 resume;不做远程同步;格式按 0.68.1 的 app 源码与本机 14 个真实对话核对)。做不了的:Windsurf/Trae 加密,Amp/Factory(Droid)/Warp 云端无本地数据,Reasonix 本机零会话格式未实测。
## Brand Commitments
diff --git a/crates/wake-core/src/adapters/dsh.rs b/crates/wake-core/src/adapters/dsh.rs
index e75c1a5..b88c042 100644
--- a/crates/wake-core/src/adapters/dsh.rs
+++ b/crates/wake-core/src/adapters/dsh.rs
@@ -1,11 +1,12 @@
use super::parse_utils::*;
use super::AgentAdapter;
use crate::models::*;
-use anyhow::Result;
+use anyhow::{anyhow, Result};
use std::collections::HashMap;
use std::fs;
-use std::io::{BufRead, BufReader};
+use std::io::{BufRead, BufReader, ErrorKind};
use std::path::{Path, PathBuf};
+use std::sync::{Arc, Mutex};
/// DeepSeek Harness(dsh):`~/.dsh/sessions/--<cwd转义>--/<id转义>/<日志>`,一目录一会话。
/// 日志文件名带**格式代数**:v0 是 `session.jsonl[.zstd]`,之后每代 `session.vN.jsonl[.zstd]`
@@ -13,30 +14,120 @@ use std::path::{Path, PathBuf};
/// 读的永远是编号最大的那一代——`session_log` 单点裁决。默认落盘是 zstd **多帧连接**
/// (首帧 header 行,之后每次 append 一帧),标准流式解码到 EOF 即可;`compression: none`
/// 配置则是纯文本 .jsonl,两种后缀都认。首行 {type:"session",version,id,createdAt,cwd,…}
-/// 给权威 id/cwd/created,不反推目录名;origin=="subagent" 或 delegationDepth>0 是子代理
-/// 会话,不进列表。事件行 {type,seq,time,data}:assistant/message 是一次模型调用的合成体
+/// 给权威 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,
+ /// 会话目录 → 最近一次读出来的(日志引用, 首行)。列表、file_ref 与每批监听都问的 parent_links
+ /// 都要每个会话的首行:同一份日志((mtime, size) 没变)不再解压;目录或日志一时读不出(权限、
+ /// 锁)交回上次读到的——首行写下就不变,迁移出新一代也是同一个 id / parentSession
+ logs: Mutex<HashMap<PathBuf, (SessionFileRef, Arc<DshHeader>)>>,
}
impl DshAdapter {
pub fn new() -> Self {
- Self {
- root: super::home_dir()
+ Self::at(
+ super::home_dir()
.unwrap_or_default()
.join(".dsh")
.join("sessions"),
+ )
+ }
+
+ fn at(root: PathBuf) -> Self {
+ Self {
+ root,
+ logs: Mutex::new(HashMap::new()),
+ }
+ }
+
+ /// `<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)
+ }
+
+ /// 会话目录 → (被读的那一代日志的引用, 它的首行)。日志取 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, Arc<DshHeader>)>> {
+ let last = self.logs.lock().unwrap().get(dir).cloned();
+ let unreadable = |e: std::io::Error| last.clone().map(Some).ok_or(e);
+ let entries = match fs::read_dir(dir) {
+ Ok(entries) => entries,
+ Err(e) if e.kind() == ErrorKind::NotFound => return Ok(None),
+ Err(e) => return unreadable(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();
+ // fs::metadata 跟随符号链接(DirEntry::metadata 不跟)
+ let meta = fs::metadata(&path)
+ .ok()
+ .filter(|m| m.is_file() && m.len() > 0)?;
+ Some(((generation, mtime_ms(&meta), zstd), path, meta.len() as i64))
+ })
+ .max_by_key(|(rank, ..)| *rank)
+ else {
+ return Ok(None);
+ };
+ let file_path = path.to_string_lossy().to_string();
+ if let Some((r, _)) = &last {
+ if r.file_path == file_path && r.mtime_ms == mtime && r.size == size {
+ return Ok(last);
+ }
}
+ // 解压不持锁
+ let header = match read_header(&path) {
+ Ok(Some(header)) => Arc::new(header),
+ Ok(None) => return Ok(None),
+ Err(e) => return unreadable(e),
+ };
+ let r = SessionFileRef {
+ agent: AgentId::Dsh,
+ native_id: header.id.clone(),
+ file_path,
+ mtime_ms: mtime,
+ size,
+ };
+ self.logs
+ .lock()
+ .unwrap()
+ .insert(dir.to_path_buf(), (r.clone(), header.clone()));
+ Ok(Some((r, header)))
}
}
/// 打开会话日志为行读取器,按后缀透明解压(.zstd = 多帧连接,Decoder 默认解到
/// EOF)。cap 是缓冲尺寸:只读首行的 header 路径用小值,免得每次列举都预读兆级
-fn open_log(path: &Path, cap: usize) -> Result<Box<dyn BufRead>> {
+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))?;
@@ -50,35 +141,61 @@ struct DshHeader {
id: String,
cwd: String,
created_at: i64,
- 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>,
}
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 = v
+ .get("parentSession")
+ .and_then(|p| p.as_str())
+ .filter(|p| !p.is_empty() && *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 {
- id: v.get("id")?.as_str()?.to_string(),
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),
- 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,
+ id,
+ parent,
+ seed_length,
})
}
/// 只读首行拿 header(zstd 惰性解码,不会解整个文件;非会话日志返回 None)
-fn read_header(path: &Path) -> Option<DshHeader> {
- let mut reader = open_log(path, 8 << 10).ok()?;
+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();
- reader.read_line(&mut line).ok()?;
- parse_header(&serde_json::from_str(line.trim_end()).ok()?)
+ 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,
@@ -182,43 +299,30 @@ fn log_generation(name: &str) -> Option<(u32, bool)> {
Some((digits.parse().ok()?, zstd))
}
-/// 会话目录 → 会话引用。日志取 dsh 自己会读的那一份:编号最大的一代(迁移只新增、不删
-/// 旧代,旧代的 mtime 可能更新);同一代压缩与明文并存(换过 compression 配置)时 mtime
-/// 新者胜、平局 .zstd 胜。list 与 watcher(经 file_ref)两条入口共用这一处裁决——只做在
-/// list 会让 watcher 把旧代的事件当主文件解析。首行 header 给权威 id(目录名是转义过的
-/// id);子代理会话在此过滤
-fn session_log(dir: &Path) -> Option<SessionFileRef> {
- let ((_, mtime, _), path, size) = fs::read_dir(dir)
- .ok()?
- .flatten()
- .filter_map(|entry| {
- let (generation, zstd) = log_generation(&entry.file_name().to_string_lossy())?;
- let path = entry.path();
- // fs::metadata 跟随符号链接(DirEntry::metadata 不跟)
- let meta = fs::metadata(&path)
- .ok()
- .filter(|m| m.is_file() && m.len() > 0)?;
- Some(((generation, mtime_ms(&meta), zstd), path, meta.len()))
- })
- .max_by_key(|(rank, ..)| *rank)?;
- let header = read_header(&path).filter(|h| !h.subagent)?;
- Some(SessionFileRef {
- agent: AgentId::Dsh,
- native_id: header.id,
- file_path: path.to_string_lossy().to_string(),
- mtime_ms: mtime,
- size: size as i64,
- })
-}
-
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 parse_dsh_log(path: &Path, decode_images: bool) -> Result<DshParse> {
@@ -228,11 +332,13 @@ fn parse_dsh_log(path: &Path, decode_images: bool) -> Result<DshParse> {
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();
@@ -268,6 +374,12 @@ fn parse_dsh_log(path: &Path, decode_images: bool) -> Result<DshParse> {
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();
+ }
match ty {
"session" => {
if row
@@ -387,6 +499,10 @@ fn parse_dsh_log(path: &Path, decode_images: bool) -> Result<DshParse> {
{
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(
@@ -435,6 +551,24 @@ fn parse_dsh_log(path: &Path, decode_images: bool) -> Result<DshParse> {
append_images_to_message_end(message, parsed.images);
}
}
+ // v2 起的 fork 截点(dsh-session fork.ts 的 buildForkSeed;最后一个带 inherited 的
+ // 才是本会话的——嵌套 fork 里祖先的标记也在复制来的那段里)
+ "session/end-seed" => {
+ if data.get("inherited").and_then(|v| v.as_bool()) == Some(true) {
+ p.cut();
+ }
+ }
+ // 子代理在第一个回合里记下的身份;上游按截点之后的第一个算
+ "subagent/descriptor" => {
+ if p.label.is_none() {
+ p.label = data
+ .get("label")
+ .and_then(|v| v.as_str())
+ .map(str::trim)
+ .filter(|label| !label.is_empty())
+ .map(clean_title_candidate);
+ }
+ }
"session/title" => {
if let Some(t) = data.get("title").and_then(|v| v.as_str()) {
let t = t.trim();
@@ -461,6 +595,9 @@ fn parse_dsh_log(path: &Path, decode_images: bool) -> Result<DshParse> {
}
}
}
+ if let Some(cut) = p.inherited {
+ collapse_inherited(&mut p.messages, cut, "session");
+ }
assign_seq(&mut p.messages);
Ok(p)
}
@@ -470,10 +607,12 @@ fn build_meta(r: &SessionFileRef, p: &DshParse) -> SessionMeta {
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 {
@@ -509,23 +648,20 @@ impl AgentAdapter for DshAdapter {
}
fn list_session_files(&self) -> Result<Vec<SessionFileRef>> {
- let mut refs = Vec::new();
- // 固定两层:<project-dir>/<session-dir>/<日志>,不 walkdir 全递归(会话目录还会
- // 放别的 artifacts);根目录读不了就本家降级为空,不把整轮扫描炸掉
- let Ok(projects) = fs::read_dir(&self.root) else {
- return Ok(refs);
- };
- for project in projects.flatten() {
- if !project.file_type().is_ok_and(|t| t.is_dir()) {
- continue;
- }
- for session in fs::read_dir(project.path()).into_iter().flatten().flatten() {
- if !session.file_type().is_ok_and(|t| t.is_dir()) {
- continue;
- }
- refs.extend(session_log(&session.path()));
- }
- }
+ // 根不在是空;在却列不出报错,scanner 把这一家这一轮冻结住
+ 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)
}
@@ -545,7 +681,35 @@ impl AgentAdapter for DshAdapter {
// 名字先粗筛(session.lock、迁移临时文件等不碰磁盘就不要),再看它是不是这个目录里
// 被读的那一代
log_generation(&path.file_name()?.to_string_lossy())?;
- session_log(path.parent()?).filter(|r| Path::new(&r.file_path) == path)
+ 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。每批监听事件都会问:列目录、每个会话 stat 一次日志,
+ /// 首行读过的用缓存;没入库的会话 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 Some((_, header)) = self.session_log(&dir).ok()? else {
+ continue;
+ };
+ if let Some(parent) = header.parent.as_deref() {
+ links.push((key(&header.id), key(parent)));
+ }
+ }
+ Some(links)
+ }
+
+ /// 关系写在子会话自己的首行里:多 location 下按子会话的胜出文件认边
+ fn parent_links_in_child(&self) -> bool {
+ true
}
fn parse_session(&self, r: &SessionFileRef) -> Result<ParsedSession> {
@@ -586,7 +750,7 @@ impl AgentAdapter for DshAdapter {
} else {
dir
};
- Box::new(Self { root })
+ Box::new(Self::at(root))
}
fn data_roots(&self) -> Vec<PathBuf> {
@@ -596,7 +760,233 @@ impl AgentAdapter for DshAdapter {
#[cfg(test)]
mod tests {
- use super::log_generation;
+ use super::{log_generation, parse_dsh_log, parse_header, DshAdapter};
+ use crate::adapters::AgentAdapter;
+ use crate::models::{MessageKind, Role};
+
+ /// 只有子代理挂到父会话下;用户自己 fork 出来的会话也写 parentSession,是独立的对话
+ #[test]
+ fn only_subagents_hang_under_their_parent() {
+ let parent = |header: serde_json::Value| parse_header(&header).unwrap().parent;
+ let base = |extra: serde_json::Value| {
+ let mut header =
+ serde_json::json!({"type": "session", "version": 4, "id": "c1", "createdAt": 1});
+ header
+ .as_object_mut()
+ .unwrap()
+ .extend(extra.as_object().unwrap().clone());
+ header
+ };
+ assert_eq!(
+ parent(base(
+ serde_json::json!({"origin": "subagent", "delegationDepth": 1, "parentSession": "p1"})
+ )),
+ Some("p1".to_string())
+ );
+ assert_eq!(
+ parent(base(
+ serde_json::json!({"delegationDepth": 2, "parentSession": "p1"})
+ )),
+ Some("p1".to_string())
+ );
+ assert_eq!(
+ parent(base(
+ serde_json::json!({"isSeeded": true, "delegationDepth": 0, "parentSession": "p1"})
+ )),
+ None
+ );
+ assert_eq!(
+ parent(base(serde_json::json!({"origin": "subagent"}))),
+ None
+ );
+ }
+
+ /// v0 / v1 没有截点标记(那时的 session/end-seed 不带 inherited):截点在首行的 seedLength,
+ /// seq 小于它的事件是复制来的;只认带 parentSession 的
+ #[test]
+ fn a_v0_fork_cuts_at_its_seed_length() {
+ let dir = tempfile::tempdir().unwrap();
+ let path = dir.path().join("session.jsonl");
+ let lines = [
+ 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}}}"#,
+ ];
+ std::fs::write(&path, lines.join("\n")).unwrap();
+ let parsed = parse_dsh_log(&path, false).unwrap();
+ let texts: Vec<(Role, MessageKind, &str)> = parsed
+ .messages
+ .iter()
+ .map(|m| (m.role, m.kind, m.text.as_str()))
+ .collect();
+ assert_eq!(
+ texts,
+ 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 不作数(上游迁移同一判法)
+ let header = |extra: &str| {
+ let line = format!(r#"{{"type":"session","version":0,"id":"s","createdAt":1{extra}}}"#);
+ parse_header(&serde_json::from_str(&line).unwrap())
+ .unwrap()
+ .seed_length
+ };
+ assert_eq!(header(r#","seedLength":3"#), None);
+ assert_eq!(header(r#","seedLength":3,"parentSession":"p1""#), 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_reply_right_after_the_cut_is_its_own() {
+ let dir = tempfile::tempdir().unwrap();
+ let path = dir.path().join("session.v4.jsonl");
+ let lines = [
+ 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"}]}}}"#,
+ ];
+ std::fs::write(&path, lines.join("\n")).unwrap();
+ let parsed = parse_dsh_log(&path, false).unwrap();
+ let texts: Vec<(Role, MessageKind, &str)> = parsed
+ .messages
+ .iter()
+ .map(|m| (m.role, m.kind, m.text.as_str()))
+ .collect();
+ assert_eq!(
+ texts,
+ vec![
+ (
+ Role::System,
+ MessageKind::Meta,
+ "── 2 messages inherited from the parent session ──"
+ ),
+ (Role::Assistant, MessageKind::Text, "the fork's own answer"),
+ ]
+ );
+ }
#[test]
fn log_names_carry_their_format_generation() {
diff --git a/crates/wake-core/src/db.rs b/crates/wake-core/src/db.rs
index acbd9f2..29965bf 100644
--- a/crates/wake-core/src/db.rs
+++ b/crates/wake-core/src/db.rs
@@ -223,8 +223,10 @@ CREATE TABLE IF NOT EXISTS claimed_sessions (
/// 的回复合并改走同一个封顶合并(恰好停在上限上的回复也补截断标记),老行靠这轮重解析回填;
/// "12" = Claude Code 的分支会话(开头原样复制了原对话的那种)折掉复制来的一段、挂到原件下,
/// token / 标题 / 创建时间只算分支自己的行;后台任务结束时注入的 `<task-notification>`
-/// user 行归注入内容(Meta),老行靠这轮重解析回填。
-pub const FTS_FORMAT: &str = "12";
+/// user 行归注入内容(Meta),老行靠这轮重解析回填;
+/// "13" = dsh 的子代理会话收录、挂到派它的会话下(issue #63),fork 出来的会话折掉从父会话
+/// 复制来的一段、标题 / 模型 / 用量只算截点之后的,老行靠这轮重解析回填。
+pub const FTS_FORMAT: &str = "13";
/// FTS 压缩的节奏(见 `Store::compact_fts`):距上次压缩满一天、或从没压过才压。没有记录
/// 就算到期——老库升级后、新建库首轮扫描收尾各压一次;`FTS_FORMAT` 换代时 open_conn 把
diff --git a/crates/wake-core/tests/adapter_contracts.rs b/crates/wake-core/tests/adapter_contracts.rs
index 41ea240..795e277 100644
--- a/crates/wake-core/tests/adapter_contracts.rs
+++ b/crates/wake-core/tests/adapter_contracts.rs
@@ -49,6 +49,7 @@ struct TestEnv {
opencode_next_db: PathBuf,
antigravity_db: PathBuf,
dsh_log: PathBuf,
+ dsh_sub_log: PathBuf,
hermes_db: PathBuf,
openclaw_db: PathBuf,
cursor_ide_db: PathBuf,
@@ -103,6 +104,7 @@ fn setup() -> &'static TestEnv {
opencode_next_db: sc.opencode_next_db,
antigravity_db: sc.antigravity_db,
dsh_log: sc.dsh_log,
+ dsh_sub_log: sc.dsh_sub_log,
hermes_db: sc.hermes_db,
openclaw_db: sc.openclaw_db,
cursor_ide_db: sc.cursor_ide_db,
@@ -2736,24 +2738,31 @@ fn dsh_parse_contract() {
let env = setup();
let adapter = DshAdapter::new();
// file_ref 是公开 API:只认会话日志(session[.vN].jsonl[.zstd]),native_id 取
- // header 的权威 id(目录名是转义过的 id);子代理会话(origin=subagent)在此过滤
+ // header 的权威 id(目录名是转义过的 id);子代理会话照常收录(issue #63)
let r = adapter.file_ref(&env.dsh_log).expect("dsh file_ref");
assert_eq!(r.native_id, "dsh-e2e4-0001");
- let sub = env
- .dsh_log
- .parent()
- .and_then(|d| d.parent())
- .expect("dsh project dir")
- .join("dsh-sub-0002")
- .join("session.jsonl");
- assert!(adapter.file_ref(&sub).is_none(), "子代理会话不进列表");
-
- // list 走 <project>/<session>/<日志> 两层布局,子代理被滤掉
- let listed = adapter
+ let sub = adapter
+ .file_ref(&env.dsh_sub_log)
+ .expect("子代理会话也是会话");
+ assert_eq!(sub.native_id, "dsh-sub-0002");
+
+ // list 走 <project>/<session>/<日志> 两层布局
+ let mut listed: Vec<String> = adapter
.list_session_files()
- .expect("dsh list_session_files");
- assert_eq!(listed.len(), 1);
- assert_eq!(listed[0].native_id, "dsh-e2e4-0001");
+ .expect("dsh list_session_files")
+ .into_iter()
+ .map(|r| r.native_id)
+ .collect();
+ listed.sort();
+ assert_eq!(listed, vec!["dsh-e2e4-0001", "dsh-sub-0002"]);
+ // 子代理首行的 parentSession 把它挂到派它的会话下
+ assert_eq!(
+ adapter.parent_links(),
+ Some(vec![(
+ "dsh:dsh-sub-0002".to_string(),
+ "dsh:dsh-e2e4-0001".to_string()
+ )])
+ );
// 压缩配置换挡会两后缀并存:陈旧的一份在 file_ref 就让位(裁决单点,
// watcher 入口同样受保护,不会把旧文件当主文件解析)。在私有拷贝里摆
@@ -2824,6 +2833,54 @@ fn dsh_parse_contract() {
);
}
+/// fork 后端派出的子代理(issue #63):开头原样复制了父会话到截点为止的事件——折成一条,
+/// 标题取派活时的任务名,模型与 token 只算子代理自己的调用,父会话的不重复计
+#[test]
+fn dsh_subagent_keeps_only_its_own_turns() {
+ let env = setup();
+ let adapter = DshAdapter::new();
+ let r = adapter
+ .file_ref(&env.dsh_sub_log)
+ .expect("dsh subagent file_ref");
+ let s = adapter
+ .parse_session(&r)
+ .expect("dsh subagent parse_session");
+ let t = adapter
+ .parse_transcript(&r)
+ .expect("dsh subagent parse_transcript");
+ assert_eq!(s.meta.key, "dsh:dsh-sub-0002");
+ assert_eq!(s.meta.title, "Audit the scanner effects"); // 复制来的 session/title 不算
+ assert_eq!(s.meta.model.as_deref(), Some("deepseek-v4-flash"));
+ assert_eq!(s.meta.tokens_used, Some(1820)); // 复制来的 1480 是父会话的
+ assert_eq!(s.meta.created_at, 1786100005000);
+ assert_eq!(s.meta.message_count, 2);
+ assert_eq!(s.unknown_line_count, 0);
+ assert_eq!(
+ texts(&t.mainline),
+ vec![
+ (
+ Role::System,
+ MessageKind::Meta,
+ "── 2 messages inherited from the parent session ──"
+ ),
+ (
+ Role::User,
+ MessageKind::Text,
+ "Check every effect in the scanner page and report which ones never clean up."
+ ),
+ (
+ Role::Assistant,
+ MessageKind::Text,
+ "Two effects never unsubscribe: the camera stream and the resize listener."
+ ),
+ ]
+ );
+ assert_eq!(
+ s.units.iter().map(|u| u.seq).collect::<Vec<_>>(),
+ vec![1, 2]
+ );
+}
+
#[test]
fn dsh_reads_the_newest_format_generation() {
// dsh 迁移只新增下一代文件、不删旧代(issue #45:0.1.6 起写 session.v3.jsonl.zstd,
@@ -2995,6 +3052,10 @@ fn seq_contract_holds_for_all_agents() {
Box::new(DshAdapter::new()),
fs_ref(AgentId::Dsh, &env.dsh_log, "dsh-e2e4-0001"),
),
+ (
+ Box::new(DshAdapter::new()),
+ fs_ref(AgentId::Dsh, &env.dsh_sub_log, "dsh-sub-0002"),
+ ),
(
Box::new(HermesAdapter::new()),
db_ref(AgentId::Hermes, &env.hermes_db, "hs-0001"),
diff --git a/crates/wake-core/tests/common/mod.rs b/crates/wake-core/tests/common/mod.rs
index 74199ad..6502cd4 100644
--- a/crates/wake-core/tests/common/mod.rs
+++ b/crates/wake-core/tests/common/mod.rs
@@ -295,6 +295,8 @@ pub struct Sidecars {
pub opencode_next_db: PathBuf,
pub antigravity_db: PathBuf,
pub dsh_log: PathBuf,
+ /// fork 后端派出的子代理会话(开头带着从父会话复制来的一段),挂在 dsh_log 那个会话下
+ pub dsh_sub_log: PathBuf,
pub hermes_db: PathBuf,
pub openclaw_db: PathBuf,
pub cursor_ide_db: PathBuf,
@@ -350,7 +352,7 @@ pub fn stage_sidecars(home: &Path) -> Sidecars {
.expect("write kimi session_index");
// dsh:检入的明文 fixture 压成真实写端布局的 zstd 多帧文件(首帧 header
- // 行、次帧事件批,帧直接连接),另放一个子代理会话验证 file_ref 过滤
+ // 行、次帧事件批,帧直接连接),另放一个 fork 后端派出的子代理会话(issue #63)
let dsh_project = home
.join(".dsh")
.join("sessions")
@@ -362,16 +364,9 @@ pub fn stage_sidecars(home: &Path) -> Sidecars {
fs::write(&dsh_log, dsh_zstd(&plain)).expect("write dsh zstd log");
let dsh_sub = dsh_project.join("dsh-sub-0002");
fs::create_dir_all(&dsh_sub).expect("mkdir dsh subagent dir");
- fs::write(
- dsh_sub.join("session.jsonl"),
- concat!(
- r#"{"type":"session","version":0,"id":"dsh-sub-0002","createdAt":1786100000000,"cwd":"/Users/tester/Github/wakefx","origin":"subagent","delegationDepth":1}"#,
- "\n",
- r#"{"type":"user/message","seq":0,"time":1786100001000,"data":{"id":"m","role":"user","content":[{"type":"text","text":"child task"}],"source":{"kind":"user"}}}"#,
- "\n",
- ),
- )
- .expect("write dsh subagent log");
+ let plain = fs::read_to_string(fixture("dsh/subagent.v4.jsonl")).expect("read dsh subagent");
+ let dsh_sub_log = dsh_sub.join("session.v4.jsonl.zstd");
+ fs::write(&dsh_sub_log, dsh_zstd(&plain)).expect("write dsh subagent log");
let hermes_dir = home.join(".hermes");
fs::create_dir_all(&hermes_dir).expect("mkdir .hermes");
@@ -434,6 +429,7 @@ pub fn stage_sidecars(home: &Path) -> Sidecars {
opencode_next_db,
antigravity_db,
dsh_log,
+ dsh_sub_log,
hermes_db,
openclaw_db,
cursor_ide_db,
diff --git a/crates/wake-core/tests/fixtures/dsh/subagent.v4.jsonl b/crates/wake-core/tests/fixtures/dsh/subagent.v4.jsonl
new file mode 100644
index 0000000..49a7d5f
--- /dev/null
+++ b/crates/wake-core/tests/fixtures/dsh/subagent.v4.jsonl
@@ -0,0 +1,12 @@
+{"type":"session","version":4,"id":"dsh-sub-0002","createdAt":1786100005000,"cwd":"/Users/tester/Github/wakefx","isSeeded":true,"delegationDepth":1,"parentSession":"dsh-e2e4-0001","origin":"subagent"}
+{"type":"turn/start","seq":0,"time":1786100001000,"data":{"turn":1}}
+{"type":"user/message","seq":1,"time":1786100001000,"data":{"id":"p-u1","role":"user","content":[{"type":"text","text":"扫码页卸载时崩溃了"}],"source":{"kind":"user"}},"surfaceOp":"append"}
+{"type":"assistant/message","seq":2,"time":1786100002000,"data":{"turn":1,"step":1,"message":{"id":"p-a1","role":"assistant","content":[{"type":"text","text":"我先查一下扫码组件的 effect。"}],"source":{"kind":"model","provider":"deepseek","model":"deepseek-chat-v4"}},"usage":{"inputTokens":1000,"outputTokens":480}},"surfaceOp":"append"}
+{"type":"turn/end","seq":3,"time":1786100002100,"data":{"turn":1,"reason":{"kind":"completed"}}}
+{"type":"session/title","seq":4,"time":1786100002200,"data":{"title":"QR scan dependency fix"}}
+{"type":"session/end-seed","seq":5,"time":1786100002200,"data":{"inherited":true}}
+{"type":"turn/start","seq":6,"time":1786100005100,"data":{"turn":2}}
+{"type":"subagent/descriptor","seq":7,"time":1786100005100,"data":{"version":3,"mode":"one-shot","provider":"fork","label":"Audit the scanner effects"}}
+{"type":"user/message","seq":8,"time":1786100005200,"data":{"id":"c-u1","role":"user","content":[{"type":"text","text":"Check every effect in the scanner page and report which ones never clean up."}],"source":{"kind":"user"}},"surfaceOp":"append"}
+{"type":"assistant/message","seq":9,"time":1786100006000,"data":{"turn":2,"step":1,"message":{"id":"c-a1","role":"assistant","content":[{"type":"text","text":"Two effects never unsubscribe: the camera stream and the resize listener."}],"source":{"kind":"model","provider":"deepseek","model":"deepseek-v4-flash"}},"usage":{"inputTokens":1700,"outputTokens":120}},"surfaceOp":"append"}
+{"type":"turn/end","seq":10,"time":1786100006100,"data":{"turn":2,"reason":{"kind":"completed"}}}
diff --git a/crates/wake-core/tests/scanner_finale.rs b/crates/wake-core/tests/scanner_finale.rs
index f74b3ee..bb1ec52 100644
--- a/crates/wake-core/tests/scanner_finale.rs
+++ b/crates/wake-core/tests/scanner_finale.rs
@@ -1502,6 +1502,49 @@ fn dsh_newer_generation_takes_over_an_indexed_older_one() {
);
}
+/// dsh 委派出去的子代理(issue #63):照常收录,经首行的 parentSession 挂到派它的会话下面,
+/// 不进顶层列表;它自己的 token 计在它名下
+#[test]
+fn dsh_subagents_nest_under_the_session_that_started_them() {
+ use wake_core::adapters::dsh::DshAdapter;
+ let root = tempfile::tempdir().unwrap();
+ let project = root.path().join("--Users-tester-Github-wakefx--");
+ for (dir, fixture) in [
+ ("dsh-e2e4-0001", "dsh/session.jsonl"),
+ ("dsh-sub-0002", "dsh/subagent.v4.jsonl"),
+ ] {
+ let session = project.join(dir);
+ std::fs::create_dir_all(&session).unwrap();
+ let plain = std::fs::read_to_string(common::fixture(fixture)).unwrap();
+ let name = if fixture.ends_with(".v4.jsonl") {
+ "session.v4.jsonl.zstd"
+ } else {
+ "session.jsonl.zstd"
+ };
+ std::fs::write(session.join(name), common::dsh_zstd(&plain)).unwrap();
+ }
+ let adapters: Vec<Box<dyn AgentAdapter>> =
+ vec![DshAdapter::new().with_custom_root(root.path().to_path_buf())];
+ let dir = tempfile::tempdir().unwrap();
+ let store = temp_store(dir.path());
+ run_scan(&adapters, &store, &Recorder::new(), true).unwrap();
+
+ let (parent, child) = ("dsh:dsh-e2e4-0001", "dsh:dsh-sub-0002");
+ assert_eq!(store.parent_key_of(child).unwrap().as_deref(), Some(parent));
+ let sub = store.get_session(child).unwrap().expect("子代理入库");
+ assert_eq!(sub.title, "Audit the scanner effects");
+ assert_eq!(sub.tokens_used, Some(1820));
+ let filter = SessionFilter {
+ roots_only: true,
+ limit: 10,
+ ..Default::default()
+ };
+ let (roots, total) = store.list_sessions(&filter).unwrap();
+ assert_eq!(total, 1, "子代理不进顶层列表");
+ assert_eq!(roots[0].key, parent);
+ assert_eq!(store.child_counts(&filter).unwrap().get(parent), Some(&1));
+}
+
/// Kimi 分叉:关系写在子会话自己的 state.json(`forkedFrom`),全量扫描后子会话挂在父会话
/// 下面;state.json 的 archived 照搬进索引
#[test]