All your AI agent sessions in one place — browse, search, resume. Rust + GPUI.
Rust
feat: index subagent transcripts as child sessions and link dispatch calls to them
Corey Chiu2928d0bcccb7
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 2dd4987..dcf5339 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -9,6 +9,9 @@- Fix: ZCode forks no longer repeat the task they were forked from, and their tokens are their own; side chats are titled with their first question instead of "Selection side chat"- Update: Insights no longer counts subagent sessions, or the prompts in them, as yours; their tokens still count- New: You can have agents use Wake only when you ask, not on their own; "Only when you ask" in the MCP guide shows how (#64, thanks @ItsRyanWu)+- New: Subagents started by Claude Code, Cursor, CodeBuddy, WorkBuddy, Qoder and Kimi Code are sessions of their own, listed under the session that started them, so you can search and open them like any other+- New: A tool call that started a subagent has a button that opens the subagent's session, and a subagent's session links back to the one that started it+- Fix: Claude Code workflow steps no longer show up as separate sessions while they run and vanish on the next refresh## [0.9.1] — 2026-10-10diff --git a/PRODUCT.md b/PRODUCT.mdindex 3301689..7b3e157 100644--- a/PRODUCT.md+++ b/PRODUCT.md@@ -28,7 +28,7 @@ Corey 本人(独立开发者,主力工具 Claude Code 与 Codex,中文为主)。## Capabilities and Constraints-已实现:二十三家 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 趋势图;口径=主线用户消息,agent 派出去的子会话不算会话与提问、token 照算(2026-10-12),规格见 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 扩展注入。+已实现:二十三家 adapter、FTS5 trigram 搜索(<3 码点 LIKE 降级)、**搜索跳转定位**(2026-08-18:⌘K 命中直达详情页对应消息并高亮,seq 契约保证)、详情页逐消息渲染(气泡/工具折叠簇/thinking/tree-sitter 高亮;2026-08-17 由整篇 markdown 方案升级)、恢复/收藏/置顶/导出/删除(废纸篓+墓碑)、**子代理即子会话**(2026-10-12:各家 agent 派出去的子代理一律作为子会话挂在派它的会话下;Claude Code、Cursor、CodeBuddy / WorkBuddy、Qoder、Kimi Code 放在会话目录里的子代理转录也各自入库,能单独搜索、打开,Claude Code 的 Workflow 步骤同样;列表最多两层嵌套(原件 → 分支 → 分支派的子代理);详情页里派活的工具调用上有"打开子代理会话"、子会话头部有回到父会话的链接,对得上派活调用的家才有按钮;子代理随父会话一起删除,Claude Code 的分支不随原件删;子代理不能单独恢复,不给 Open In)、文件监听增量、Insights 统计页(0.3.0:活跃热力图与 streak、时段/星期/月份分布、Agents·Projects·Models 三榜单按 sessions/tokens/prompts 切换;2026-09-03 加 Last 7 days 周对比行与 Over time 近 53 周按 agent 堆叠的每周 prompts 趋势图;口径=主线用户消息,agent 派出去的子会话不算会话与提问、token 照算(2026-10-12),规格见 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 徽章;2026-10-12 起 task 工具派出的子代理会话也收录,挂在派它的会话下)、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;2026-10-12 起索引里记了父会话的子会话挂在父会话下。格式取自 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,两代存储同扫;2026-10-12 起派生的子代理与面板上开的子会话挂在父会话下;本机零会话,格式由源码推断未经真机验证)、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 两个过滤位;照桌面端自己的分法列:任务列表里的 interactive / fork / workflow_parent 顶层列出,辅助对话、子代理与工作流的子会话挂在父任务下(2026-10-12);分叉开头从父任务复制来的历史折成一条,辅助对话以首条提问为标题;`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 本机零会话格式未实测。diff --git a/crates/wake-core/src/adapters/claude.rs b/crates/wake-core/src/adapters/claude.rsindex 2b99f60..e64f6bf 100644--- a/crates/wake-core/src/adapters/claude.rs+++ b/crates/wake-core/src/adapters/claude.rs@@ -361,11 +361,20 @@ impl ClaudeAdapter {}))}- /// 主会话的解析(parse_session 与 parse_transcript 共用):分支先拿继承段- fn parse_main(&self, r: &SessionFileRef, decode_images: bool) -> Result<ParseResult> {+ /// 会话的解析(parse_session 与 parse_transcript 共用):分支先拿继承段;子代理的转录整份+ /// 都是 sidechain 行(`isSidechain: true`),是 agent 派出去的,标题取派活时的任务说明+ fn parse(&self, r: &SessionFileRef, decode_images: bool) -> Result<(SessionMeta, ParseResult)> {let path = Path::new(&r.file_path);- let inherited = self.inherited_for(path)?;- parse_claude_jsonl(path, false, decode_images, inherited.as_ref())+ let subagent = is_subagent_transcript(&r.file_path);+ let inherited = if subagent {+ None+ } else {+ self.inherited_for(path)?+ };+ let parsed = parse_claude_jsonl(path, subagent, decode_images, inherited.as_ref())?;+ let mut meta = build_meta(r, &parsed);+ mark_subagent(&mut meta, path);+ Ok((meta, parsed))}/// auto-memory 树 `projects/<dir>/memory/*.md` 展开成读取单元:每个项目目录的记忆@@ -893,53 +902,6 @@ fn build_meta(r: &SessionFileRef, p: &ParseResult) -> SessionMeta {}}-fn subagents_dir(r: &SessionFileRef) -> PathBuf {- Path::new(&r.file_path)- .parent()- .unwrap_or(Path::new("."))- .join(&r.native_id)- .join("subagents")-}--fn list_sidechains(r: &SessionFileRef) -> Vec<SidechainInfo> {- let dir = subagents_dir(r);- let Ok(entries) = fs::read_dir(&dir) else {- return Vec::new();- };- let mut out = Vec::new();- for entry in entries.flatten() {- let name = entry.file_name().to_string_lossy().to_string();- if !name.ends_with(".jsonl") {- continue;- }- let id = name.trim_end_matches(".jsonl").to_string();- let mut info = SidechainInfo {- id: id.clone(),- agent_type: None,- description: None,- tool_use_id: None,- };- if let Ok(meta_raw) = fs::read_to_string(dir.join(format!("{id}.meta.json"))) {- if let Ok(meta) = serde_json::from_str::<Value>(&meta_raw) {- info.agent_type = meta- .get("agentType")- .and_then(|v| v.as_str())- .map(String::from);- info.description = meta- .get("description")- .and_then(|v| v.as_str())- .map(String::from);- info.tool_use_id = meta- .get("toolUseId")- .and_then(|v| v.as_str())- .map(String::from);- }- }- out.push(info);- }- out-}-/// projects/<有损编码目录>/ 里最新的一份会话(按 mtime,平局取 id 字典序靠后的)/// 的 key:目录名反推不了项目路径,而目录里的会话都是同一个 cwd 起的——记忆挂到/// 这条会话上,项目路径读库时按它从 sessions 表解析(索引已经算过,不再翻文件)。@@ -975,18 +937,21 @@ impl AgentAdapter for ClaudeAdapter {let Ok(entries) = fs::read_dir(&dir) else {continue;};- refs.extend(- entries- .flatten()- .filter_map(|entry| self.session_ref(&entry.path(), &branches)),- );+ for entry in entries.flatten() {+ let path = entry.path();+ // 会话目录(`<id>/`)里是它派的子代理,各自作为子会话+ if entry.file_type().is_ok_and(|kind| kind.is_dir()) {+ refs.extend(subagent_refs(AgentId::ClaudeCode, &path));+ } else if let Some(r) = self.session_ref(&path, &branches) {+ refs.push(r);+ }+ }}Ok(refs)}fn parse_session(&self, r: &SessionFileRef) -> Result<ParsedSession> {- let parsed = self.parse_main(r, false)?;- let meta = build_meta(r, &parsed);+ let (meta, parsed) = self.parse(r, false)?;Ok(ParsedSession::derive(meta,&parsed.messages,@@ -995,27 +960,13 @@ impl AgentAdapter for ClaudeAdapter {}fn parse_transcript(&self, r: &SessionFileRef) -> Result<ParsedTranscript> {- let parsed = self.parse_main(r, true)?;- let sidechains = list_sidechains(r);- let mut mainline = parsed.messages.clone();- // 把 sidechain 挂到主线对应 Task tool call- let by_tool_use: HashMap<&str, &SidechainInfo> = sidechains- .iter()- .filter_map(|s| s.tool_use_id.as_deref().map(|t| (t, s)))- .collect();- for m in &mut mainline {- for tc in &mut m.tool_calls {- if let Some(sc) = by_tool_use.get(tc.id.as_str()) {- tc.sidechain_ref = Some(sc.id.clone());- }- }- }- Ok(ParsedTranscript {- meta: build_meta(r, &parsed),- mainline,- sidechains,- unknown_line_count: parsed.unknown_lines,- })+ let (meta, parsed) = self.parse(r, true)?;+ Ok(transcript_with_subagents(+ r,+ meta,+ parsed.messages,+ parsed.unknown_lines,+ ))}fn load_sidechain(@@ -1023,12 +974,9 @@ impl AgentAdapter for ClaudeAdapter {r: &SessionFileRef,sidechain_id: &str,) -> Result<Vec<TranscriptMessage>> {- let file = subagents_dir(r).join(format!("{sidechain_id}.jsonl"));- if !file.is_file() {- return Ok(Vec::new());- }- let parsed = parse_claude_jsonl(&file, true, true, None)?;- Ok(parsed.messages)+ load_subagent(r, sidechain_id, |file| {+ Ok(parse_claude_jsonl(file, true, true, None)?.messages)+ })}/// 项目目录里的会话文件进出(原件被删、被放回)会改变同目录分支的引用(`session_ref`@@ -1055,19 +1003,24 @@ impl AgentAdapter for ClaudeAdapter {}fn file_ref(&self, path: &Path) -> Option<SessionFileRef> {- // subagents 转录与 memory 边车不是主会话。按所在目录的名字判:按路径分段,Windows 的- // 反斜杠路径一样认(原先拿带 `/` 的字符串去比,watcher 报来的路径一条都对不上);只看- // 直接所在的目录,数据根上层恰好有叫 memory / subagents 的目录也不误伤+ // 子代理转录与它的边车。会话目录得在数据根下的项目目录里+ let in_project =+ |session: &Path| session.parent().and_then(Path::parent) == Some(self.root.as_path());+ if let Some(r) = subagent_event_ref(AgentId::ClaudeCode, path, in_project) {+ return Some(r);+ }+ // 会话主文件只在 `<projects>/<项目目录>/` 这一层:更深的(memory 边车、Workflow 的+ // 运行日志 journal.jsonl)都不是。按路径分段比,Windows 的反斜杠路径一样认let dir = path.parent()?;- let parent = dir.file_name()?;- if parent == "subagents" || parent == "memory" {+ if dir.parent() != Some(self.root.as_path()) {return None;}self.session_ref(path, &self.branches_in(dir))}- /// 分支挂到原件下面(见本文件「分支识别」)。关系由分支自己的文件头与同目录里更早的- /// 同根文件推出,所以算"写在子会话里"(多 location 下按子会话的胜出副本认边)+ /// 分支挂到原件下面(见本文件「分支识别」),子代理挂到派它的会话下面(`parent_in_path`)。+ /// 分支的关系由它自己的文件头与同目录里更早的同根文件推出,所以算"写在子会话里"(多+ /// location 下按子会话的胜出副本认边)fn manages_parent_links(&self) -> bool {true}@@ -1077,9 +1030,9 @@ impl AgentAdapter for ClaudeAdapter {}/// 分支是自己完整的一段对话:删原件不带上它们,原件没了它们变回顶层会话、露出完整历史- /// (重解析由 watcher 经 `ref_dependents` 触发)- fn children_outlive_parent(&self) -> bool {- true+ /// (重解析由 watcher 经 `ref_dependents` 触发)。子代理不是——它的文件就在派它的会话目录里+ fn child_outlives_parent(&self, child_path: &str) -> bool {+ !is_subagent_transcript(child_path)}/// 全量快照只用文件头(不读 uuid 集合):每个分支 → 它所在同根组里最早的那份。分支@@ -1107,7 +1060,15 @@ impl AgentAdapter for ClaudeAdapter {Some(links)}+ /// 子代理挂到派它的会话:所在会话目录的名字就是那个会话的 id+ fn parent_in_path(&self) -> Option<super::ParentInPath> {+ Some(subagent_parent)+ }+fn session_paths(&self, meta: &SessionMeta) -> Vec<String> {+ if is_subagent_transcript(&meta.file_path) {+ return subagent_paths(&meta.file_path);+ }let mut v = vec![meta.file_path.clone()];// <projects>/<dir>/<id>/ 边车目录(subagents 等)随会话一并删if let Some(dir) = Path::new(&meta.file_path).parent() {@@ -1326,9 +1287,9 @@ mod tests {if fs::File::open(&original).is_ok() {return; // root 读得动任何文件,这条测不了}- assert!(adapter.parse_main(&r, false).is_err());+ assert!(adapter.parse(&r, false).is_err());fs::set_permissions(&original, fs::Permissions::from_mode(0o644)).unwrap();- let parsed = adapter.parse_main(&r, false).unwrap();+ let (_, parsed) = adapter.parse(&r, false).unwrap();assert_eq!(parsed.messages[0].kind,MessageKind::Meta,diff --git a/crates/wake-core/src/adapters/codebuddy.rs b/crates/wake-core/src/adapters/codebuddy.rsindex 0d88ac4..217a098 100644--- a/crates/wake-core/src/adapters/codebuddy.rs+++ b/crates/wake-core/src/adapters/codebuddy.rs@@ -10,8 +10,8 @@ use std::path::{Path, PathBuf};/// CodeBuddy Code(腾讯 CodeBuddy 的 CLI,issue #27):`~/.codebuddy/projects//// <cwd 转义>/<sessionId>.jsonl`。文件布局借自 Claude Code——同名目录-/// `<sessionId>/subagents/agent-*.jsonl` 是子代理转录、`<sessionId>.meta.json`-/// 是边车,主列表只枚举 slug 目录直属的 JSONL;**行格式却是 OpenAI Responses+/// `<sessionId>/subagents/agent-*.jsonl` 是子代理转录(作为子会话挂在派它的会话+/// 下面)、`<sessionId>.meta.json` 是边车;**行格式却是 OpenAI Responses/// 形**:`message`(role 挂在信封上,content 块是 input_text / output_text)、/// `reasoning`(rawContent[].reasoning_text)、`function_call`(callId / name //// arguments 是 JSON 字符串)、`function_call_result`(callId / output.text /@@ -408,6 +408,17 @@ fn build_meta(agent: AgentId, r: &SessionFileRef, parsed: &ParseResult) -> Sessi}}+impl CodebuddyAdapter {+ /// 会话或子代理(子代理是 agent 派出去的,标题取边车记的任务说明)+ fn parse(&self, r: &SessionFileRef, decode_images: bool) -> Result<(SessionMeta, ParseResult)> {+ let path = Path::new(&r.file_path);+ let parsed = parse_codebuddy_jsonl(path, decode_images)?;+ let mut meta = build_meta(self.agent, r, &parsed);+ mark_subagent(&mut meta, path);+ Ok((meta, parsed))+ }+}+impl AgentAdapter for CodebuddyAdapter {fn agent(&self) -> AgentId {self.agent@@ -418,18 +429,11 @@ impl AgentAdapter for CodebuddyAdapter {}fn file_ref(&self, path: &Path) -> Option<SessionFileRef> {- let relative = path.strip_prefix(&self.root).ok()?;- // root/<session>.jsonl 或 root/<slug>/<session>.jsonl;更深的- // <session>/subagents/agent-*.jsonl 是子代理转录,不得成为顶层会话- if relative.components().count() > 2 {- return None;- }- default_file_ref(self.agent(), path)+ project_tree_file_ref(&self.root, self.agent, path)}fn parse_session(&self, r: &SessionFileRef) -> Result<ParsedSession> {- let parsed = parse_codebuddy_jsonl(Path::new(&r.file_path), false)?;- let meta = build_meta(self.agent, r, &parsed);+ let (meta, parsed) = self.parse(r, false)?;Ok(ParsedSession::derive(meta,&parsed.messages,@@ -438,16 +442,34 @@ impl AgentAdapter for CodebuddyAdapter {}fn parse_transcript(&self, r: &SessionFileRef) -> Result<ParsedTranscript> {- let parsed = parse_codebuddy_jsonl(Path::new(&r.file_path), true)?;- Ok(ParsedTranscript {- meta: build_meta(self.agent, r, &parsed),- mainline: parsed.messages,- sidechains: Vec::new(),- unknown_line_count: parsed.unknown_lines,+ let (meta, parsed) = self.parse(r, true)?;+ Ok(transcript_with_subagents(+ r,+ meta,+ parsed.messages,+ parsed.unknown_lines,+ ))+ }++ fn load_sidechain(+ &self,+ r: &SessionFileRef,+ sidechain_id: &str,+ ) -> Result<Vec<TranscriptMessage>> {+ load_subagent(r, sidechain_id, |file| {+ Ok(parse_codebuddy_jsonl(file, true)?.messages)})}+ /// 子代理挂到派它的会话下面:所在会话目录的名字就是那个会话的 id+ fn parent_in_path(&self) -> Option<super::ParentInPath> {+ Some(subagent_parent)+ }+fn session_paths(&self, meta: &SessionMeta) -> Vec<String> {+ if is_subagent_transcript(&meta.file_path) {+ return subagent_paths(&meta.file_path);+ }let mut paths = vec![meta.file_path.clone()];if let Some(parent) = Path::new(&meta.file_path).parent() {// <id>.meta.json 边车与 <id>/(subagents 等)随会话一并进废纸篓diff --git a/crates/wake-core/src/adapters/codex.rs b/crates/wake-core/src/adapters/codex.rsindex d371cef..42ba282 100644--- a/crates/wake-core/src/adapters/codex.rs+++ b/crates/wake-core/src/adapters/codex.rs@@ -19,6 +19,8 @@ pub struct CodexAdapter {scan_sessions: bool,scan_archived: bool,links_cache: MtimeCache<Vec<(String, String)>>,+ /// 每条线程派出去的子线程:父线程 id → (agent_path, 子线程 id),按起的先后(`spawned_threads`)+ spawned_cache: MtimeCache<std::sync::Arc<SpawnedThreads>>,/// CODEX_HOME(memories/ 与 memories_1.sqlite 的所在);自定义根选的是独立的/// sessions 目录或裸 rollout 拷贝时没有 home——侧档绝不越界摸父目录(不变量 8⑨)home: Option<PathBuf>,@@ -43,6 +45,7 @@ impl CodexAdapter {scan_sessions: true,scan_archived: true,links_cache: MtimeCache::new(),+ spawned_cache: MtimeCache::new(),home: Some(root),memories: super::MemoryCache::new(),thread_memories: MtimeCache::new(),@@ -293,6 +296,65 @@ fn read_spawn_edges(state_db: &Path) -> Option<HashMap<String, String>> {rows.collect::<rusqlite::Result<HashMap<_, _>>>().ok()}+/// 父线程 id → 它派出去的子线程 (agent_path, 子线程 id),按起的先后+type SpawnedThreads = HashMap<String, Vec<(String, String)>>;++/// state DB 里每条线程派出去的子线程与它们的 agent_path。`None` 与 `Some(空)` 同 `read_spawn_edges`:+/// 没有库、老库没这些表或列 = 确定没有;库在却打不开、逐行读出错 = 不知道(不缓存,下次再读)+fn read_spawned_threads(state_db: &Path) -> Option<std::sync::Arc<SpawnedThreads>> {+ let mut spawned = SpawnedThreads::new();+ if !state_db.is_file() {+ return Some(spawned.into());+ }+ let ro = open_sqlite_ro(state_db, "codex")?;+ let Ok(mut stmt) = ro.conn.prepare(+ "SELECT e.parent_thread_id, t.agent_path, e.child_thread_id FROM thread_spawn_edges e+ JOIN threads t ON t.id = e.child_thread_id+ WHERE t.agent_path IS NOT NULL+ ORDER BY t.created_at_ms, t.id",+ ) else {+ return Some(spawned.into());+ };+ let rows = stmt+ .query_map([], |row| {+ Ok((+ row.get::<_, String>(0)?,+ row.get::<_, String>(1)?,+ row.get::<_, String>(2)?,+ ))+ })+ .ok()?;+ for row in rows {+ let (parent, path, child) = row.ok()?;+ spawned.entry(parent).or_default().push((path, child));+ }+ Some(spawned.into())+}++/// `spawn_agent` 调用指向它起的子线程。调用的输出是子线程的 `agent_path`(`{"task_name":+/// "/root/<任务名>"}`),对上这条线程派出去的子线程各自记着的 agent_path;同一个任务名派两次时+/// 按起的先后依次对上+fn link_spawned_threads(children: &[(String, String)], mainline: &mut [TranscriptMessage]) {+ let mut by_path: HashMap<&str, std::collections::VecDeque<&str>> = HashMap::new();+ for (path, child) in children {+ by_path.entry(path).or_default().push_back(child);+ }+ for call in mainline+ .iter_mut()+ .flat_map(|m| m.tool_calls.iter_mut())+ .filter(|call| call.name == "spawn_agent")+ {+ let path = call+ .output+ .as_deref()+ .and_then(|out| serde_json::from_str::<Value>(out).ok())+ .and_then(|out| optional_string(out.get("task_name")));+ if let Some(child) = path.and_then(|path| by_path.get_mut(path.as_str())?.pop_front()) {+ call.child_id = Some(child.to_string());+ }+ }+}+struct CodexParse {messages: Vec<TranscriptMessage>,cwd: String,@@ -669,7 +731,7 @@ fn parse_rollout(path: &Path, decode_images: bool) -> Result<CodexParse> {},output: None,is_error: false,- sidechain_ref: None,+ child_id: None,};// 末条消息落在 fork 段里(下标 < cut)时必须另起宿主:// collapse_inherited 会把那段整段 splice 掉,挂上去的@@ -1212,9 +1274,25 @@ impl AgentAdapter for CodexAdapter {fn parse_transcript(&self, r: &SessionFileRef) -> Result<ParsedTranscript> {let parsed = parse_rollout(Path::new(&r.file_path), true)?;+ let meta = build_meta(r, &parsed, &self.archived_dir);+ let mut mainline = parsed.messages;+ // 有派活的调用才去问 state DB(按库戳缓存,parent_links 同款);读不出就不挂跳转+ if mainline+ .iter()+ .flat_map(|m| &m.tool_calls)+ .any(|call| call.name == "spawn_agent")+ {+ let stamp = super::sqlite_ro::db_cache_stamp(&self.state_db);+ let spawned = self+ .spawned_cache+ .get_or_try_build(stamp, || read_spawned_threads(&self.state_db));+ if let Some(children) = spawned.as_deref().and_then(|map| map.get(&meta.id)) {+ link_spawned_threads(children, &mut mainline);+ }+ }Ok(ParsedTranscript {- meta: build_meta(r, &parsed, &self.archived_dir),- mainline: parsed.messages,+ meta,+ mainline,sidechains: Vec::new(),unknown_line_count: parsed.unknown_lines,})@@ -1289,6 +1367,7 @@ impl AgentAdapter for CodexAdapter {scan_sessions: true,scan_archived: true,links_cache: MtimeCache::new(),+ spawned_cache: MtimeCache::new(),home,memories: super::MemoryCache::new(),thread_memories: MtimeCache::new(),@@ -1314,6 +1393,7 @@ impl AgentAdapter for CodexAdapter {scan_sessions: self.scan_sessions && !roots.contains(&self.sessions_dir),scan_archived: self.scan_archived && !roots.contains(&self.archived_dir),links_cache: MtimeCache::new(),+ spawned_cache: MtimeCache::new(),home: self.home.clone(),memories: super::MemoryCache::new(),thread_memories: MtimeCache::new(),diff --git a/crates/wake-core/src/adapters/cursor.rs b/crates/wake-core/src/adapters/cursor.rsindex f6146e8..3ac28f4 100644--- a/crates/wake-core/src/adapters/cursor.rs+++ b/crates/wake-core/src/adapters/cursor.rs@@ -3,6 +3,7 @@ use super::{cursor_ide, AgentAdapter};use crate::models::*;use anyhow::Result;use serde_json::Value;+use std::collections::HashMap;use std::fs;use std::io::BufReader;use std::path::{Path, PathBuf};@@ -50,7 +51,13 @@ impl CursorAdapter {fn build_meta(&self, r: &SessionFileRef, p: &CursorParse) -> SessionMeta {let facts = self.composer_facts(r);let cwd = resolve_project_path(r, facts.project.as_ref());- let title = title_from_messages(&p.messages).unwrap_or_else(|| UNTITLED.to_string());+ let spawned = subagent_parent_dir(Path::new(&r.file_path)).is_some();+ // 子代理的 composer 名字是派它时写的任务说明(IDE 里跑的才有),比它收到的整段提示好认+ let title = facts+ .name+ .filter(|_| spawned)+ .or_else(|| title_from_messages(&p.messages))+ .unwrap_or_else(|| UNTITLED.to_string());SessionMeta {key: format!("cursor:{}", r.native_id),host: String::new(),@@ -81,8 +88,7 @@ impl CursorAdapter {tokens_used: None,archived: false,source: None,- // 子代理的转录在父会话目录的 subagents/ 里,不作为顶层转录列出;子代理会话由 IDE 库那一路标- spawned: false,+ spawned,favorite: false,pinned: false,}@@ -190,6 +196,20 @@ struct CursorParse {created_at: i64,updated_at: i64,unknown_lines: u32,+ dispatches: Vec<Dispatch>,+}++/// 主线里派子代理的调用(Task)。转录里的工具调用没有 id,详情页的跳转靠这两样对上+/// subagents/ 里的转录:头一回派的 `prompt` 就是子代理收到的第一句,接着派的 `resume` 直接+/// 点名子代理+struct Dispatch {+ /// 调用所在的消息,与它在那条消息里的位置+ message: usize,+ call: usize,+ prompt: Option<String>,+ resume: Option<String>,+ description: Option<String>,+ agent_type: Option<String>,}#[derive(Default)]@@ -232,6 +252,7 @@ fn parse_cursor_jsonl(path: &Path, decode_images: bool) -> Result<CursorParse> {let mut unknown_lines = 0u32;// 读不出/不是 JSON 的行(截断、损坏),与"认得出 JSON 但类型未知"分开计let mut malformed_lines = 0u32;+ let mut dispatches = Vec::new();for row in jsonl_values(reader) {let Some(row) = row? else {@@ -270,12 +291,7 @@ fn parse_cursor_jsonl(path: &Path, decode_images: bool) -> Result<CursorParse> {ts = parsed;}}- // 真实输入在 <user_query> 壳内;没有壳的行原样保留- let body =- extract_tag(raw, "user_query").unwrap_or_else(|| raw.to_string());- if !body.trim().is_empty() {- parsed_message.push_text(&body);- }+ parsed_message.push_text(&user_query(raw));}_ if is_image_part(b) => {let parsed = content_parts(b, decode_images);@@ -313,6 +329,19 @@ fn parse_cursor_jsonl(path: &Path, decode_images: bool) -> Result<CursorParse> {Some("tool_use") => {let input = b.get("input").cloned().unwrap_or(Value::Null);let name = b.get("name").and_then(|v| v.as_str()).unwrap_or("tool");+ let text = |key: &str| optional_string(input.get(key));+ let (prompt, resume) = (text("prompt"), text("resume"));+ if prompt.is_some() || resume.is_some() {+ // 这条助手消息还没落进 messages:flush 时它就排在这个位置+ dispatches.push(Dispatch {+ message: messages.len(),+ call: p.tool_calls.len(),+ prompt,+ resume,+ description: text("description"),+ agent_type: text("subagent_type"),+ });+ }// transcript 不落盘工具结果,output 恒 Nonep.tool_calls.push(tool_call_view(String::new(),@@ -347,9 +376,126 @@ fn parse_cursor_jsonl(path: &Path, decode_images: bool) -> Result<CursorParse> {created_at,updated_at,unknown_lines,+ dispatches,})}+/// 用户文字块里人打的那句:`<user_query>` 壳里的话,没有壳的原样(解析与 `first_query` 共用,+/// 对派活调用要逐字相同)+fn user_query(raw: &str) -> String {+ extract_tag(raw, "user_query").unwrap_or_else(|| raw.to_string())+}++/// 子代理收到的第一句:第一条用户行里人打的话,与解析出来的那条用户消息同一个取法+fn first_query(path: &Path) -> Option<String> {+ let file = fs::File::open(path).ok()?;+ for row in jsonl_values(BufReader::new(file)) {+ let Ok(Some(row)) = row else { continue };+ if row.get("role").and_then(Value::as_str) != Some("user") {+ continue;+ }+ let mut query = ParsedContent::default();+ for b in row.pointer("/message/content")?.as_array()? {+ if b.get("type").and_then(Value::as_str) == Some("text") {+ if let Some(raw) = b.get("text").and_then(Value::as_str) {+ query.push_text(&user_query(raw));+ }+ }+ }+ return Some(query.text).filter(|q| !q.is_empty());+ }+ None+}++/// Task 派出去的子代理转录 `agent-transcripts/<父会话>/subagents/<id>.jsonl`(没有 Claude 那样的+/// meta 边车),返回父会话的目录+fn subagent_parent_dir(path: &Path) -> Option<&Path> {+ let dir = path.parent()?;+ if dir.file_name()? != "subagents" {+ return None;+ }+ let session = dir.parent()?;+ (session.parent()?.file_name()? == "agent-transcripts").then_some(session)+}++/// 子代理所在会话的原生 id:会话目录的名字(`AgentAdapter::parent_in_path`)+fn subagent_parent(path: &Path) -> Option<String> {+ Some(+ subagent_parent_dir(path)?+ .file_name()?+ .to_string_lossy()+ .into_owned(),+ )+}++/// 父会话的子代理(subagents/ 里的转录,各自也作为子会话入库)。派它的调用对上了(见+/// `Dispatch`)就挂上跳转,任务说明与类型也从那次调用取;子代理自己下面没有 subagents/,给空+fn link_dispatches(+ r: &SessionFileRef,+ mainline: &mut [TranscriptMessage],+ dispatches: &[Dispatch],+) -> Vec<SidechainInfo> {+ let Ok(entries) = fs::read_dir(subagents_dir(r)) else {+ return Vec::new();+ };+ let by_prompt = dispatches+ .iter()+ .any(|d| d.resume.is_none() && d.prompt.is_some());+ let mut sidechains = Vec::new();+ let mut firsts = Vec::new();+ for path in entries.flatten().map(|entry| entry.path()) {+ if path.extension().is_none_or(|ext| ext != "jsonl") {+ continue;+ }+ if let Some(info) = sidechain_info(&path) {+ firsts.push(by_prompt.then(|| first_query(&path)).flatten());+ sidechains.push(info);+ }+ }+ // 头一回派的按第一句对,只认一对一:同一句话派了两次、或两个子代理收到的第一句相同,分不清+ // 谁是谁,不挂跳转——挂了就是几个按钮都指向枚举到的最后一个(Codex review 2026-10-12)+ let mut fresh: HashMap<&str, usize> = HashMap::new();+ for prompt in dispatches+ .iter()+ .filter(|d| d.resume.is_none())+ .filter_map(|d| d.prompt.as_deref())+ {+ *fresh.entry(prompt).or_default() += 1;+ }+ let mut received: HashMap<&str, Option<usize>> = HashMap::new();+ for (ix, first) in firsts.iter().enumerate() {+ if let Some(first) = first.as_deref() {+ received+ .entry(first)+ .and_modify(|only| *only = None)+ .or_insert(Some(ix));+ }+ }+ for d in dispatches {+ // 接着派的按 resume 点名,只认它:它的 prompt 是接着说的话,恰好与另一个子代理的第一句+ // 相同时会对上两个+ let sent = match (&d.resume, d.prompt.as_deref()) {+ (Some(resume), _) => sidechains.iter().position(|info| info.id == *resume),+ (None, Some(prompt)) if fresh.get(prompt) == Some(&1) => {+ received.get(prompt).copied().flatten()+ }+ _ => None,+ };+ let Some(info) = sent.map(|ix| &mut sidechains[ix]) else {+ continue;+ };+ if let Some(call) = mainline+ .get_mut(d.message)+ .and_then(|m| m.tool_calls.get_mut(d.call))+ {+ call.child_id = info.session_id.clone();+ }+ info.description = info.description.take().or_else(|| d.description.clone());+ info.agent_type = info.agent_type.take().or_else(|| d.agent_type.clone());+ }+ sidechains+}+fn subagents_dir(r: &SessionFileRef) -> PathBuf {Path::new(&r.file_path).parent()@@ -364,11 +510,14 @@ fn resolve_project_path(if let Some(workspace) = metadata.and_then(|m| m.workspace.as_ref()) {return workspace.clone();}- // …/projects/<slug>/agent-transcripts/<uuid>/<uuid>.jsonl → slug+ // …/projects/<slug>/agent-transcripts/<uuid>/<uuid>.jsonl → slug(子代理的转录再深一层)let Some(slug) = Path::new(&r.file_path).ancestors()- .nth(3)- .and_then(|d| d.file_name())+ .find(|d| {+ d.file_name()+ .is_some_and(|name| name == "agent-transcripts")+ })+ .and_then(|d| d.parent()?.file_name())else {return String::new();};@@ -451,40 +600,30 @@ impl AgentAdapter for CursorAdapter {continue;};for session in sessions.flatten() {- let Ok(entries) = fs::read_dir(session.path()) else {- continue;+ // 会话自己的转录,与它派出去的子代理(子会话);判据与监听同一个 file_ref+ let dir = session.path();+ let files = |dir: &Path| -> Vec<PathBuf> {+ fs::read_dir(dir)+ .map(|entries| entries.flatten().map(|entry| entry.path()).collect())+ .unwrap_or_default()};- for entry in entries.flatten() {- let name = entry.file_name().to_string_lossy().to_string();- if !name.ends_with(".jsonl") {- continue;- }- let Ok(meta) = entry.metadata() else { continue };- if !meta.is_file() || meta.len() == 0 {- continue;- }- let size = meta.len() as i64;- // 只有回合标记 = IDE 会话在本源的空壳,正文归 cursor_ide- if is_turn_marker_only(&entry.path()) {- continue;- }- refs.push(SessionFileRef {- agent: AgentId::Cursor,- native_id: name.trim_end_matches(".jsonl").to_string(),- file_path: entry.path().to_string_lossy().to_string(),- mtime_ms: mtime_ms(&meta),- size,- });- }+ refs.extend(+ files(&dir)+ .iter()+ .chain(&files(&dir.join("subagents")))+ .filter_map(|path| self.file_ref(path)),+ );}}Ok(refs)}fn file_ref(&self, path: &Path) -> Option<SessionFileRef> {- // 只认 transcript 主文件 `agent-transcripts/<会话>/<会话>.jsonl`(subagents 转录多一层,- // 不是独立会话)。按路径分段判:Windows 的反斜杠路径一样认- if path.parent()?.parent()?.file_name()? != "agent-transcripts" {+ // 会话转录 `agent-transcripts/<会话>/<会话>.jsonl` 与子代理转录 `…/<会话>/subagents/<id>.jsonl`。+ // 按路径分段判:Windows 的反斜杠路径一样认+ if path.parent()?.parent()?.file_name()? != "agent-transcripts"+ && subagent_parent_dir(path).is_none()+ {return None;}let r = default_file_ref(self.agent(), path)?;@@ -497,6 +636,10 @@ impl AgentAdapter for CursorAdapter {}fn session_paths(&self, meta: &SessionMeta) -> Vec<String> {+ // 子代理只有它自己那份转录+ if subagent_parent_dir(Path::new(&meta.file_path)).is_some() {+ return vec![meta.file_path.clone()];+ }// 会话是 <uuid>/ 整个目录(含 subagents/),删除时整目录进废纸篓Path::new(&meta.file_path).parent()@@ -515,27 +658,13 @@ impl AgentAdapter for CursorAdapter {}fn parse_transcript(&self, r: &SessionFileRef) -> Result<ParsedTranscript> {- let parsed = parse_cursor_jsonl(Path::new(&r.file_path), true)?;- // subagents/ 子目录与 Claude 同构,但无 meta 边车、主线 Task 调用无 id,- // 挂不上具体 tool_use——仅列出供导出携带- let mut sidechains = Vec::new();- let dir = subagents_dir(r);- if let Ok(entries) = fs::read_dir(&dir) {- for entry in entries.flatten() {- let name = entry.file_name().to_string_lossy().to_string();- if let Some(id) = name.strip_suffix(".jsonl") {- sidechains.push(SidechainInfo {- id: id.to_string(),- agent_type: None,- description: None,- tool_use_id: None,- });- }- }- }+ let mut parsed = parse_cursor_jsonl(Path::new(&r.file_path), true)?;+ let meta = self.build_meta(r, &parsed);+ let mut mainline = std::mem::take(&mut parsed.messages);+ let sidechains = link_dispatches(r, &mut mainline, &parsed.dispatches);Ok(ParsedTranscript {- meta: self.build_meta(r, &parsed),- mainline: parsed.messages,+ meta,+ mainline,sidechains,unknown_line_count: parsed.unknown_lines,})@@ -557,6 +686,12 @@ impl AgentAdapter for CursorAdapter {Some(self.session_paths(meta))}+ /// 子代理挂到派它的会话下面:转录在派它的会话目录里,目录名就是那个会话的 id。IDE 库那一路+ /// 另报 composer 记的关系+ fn parent_in_path(&self) -> Option<super::ParentInPath> {+ Some(subagent_parent)+ }+fn list_memories(&self,sources: &[MemorySource],diff --git a/crates/wake-core/src/adapters/cursor_ide.rs b/crates/wake-core/src/adapters/cursor_ide.rsindex 9517cdb..d449237 100644--- a/crates/wake-core/src/adapters/cursor_ide.rs+++ b/crates/wake-core/src/adapters/cursor_ide.rs@@ -104,6 +104,8 @@ pub(super) struct ComposerFacts {/// actual workspace, or be one of several repos inside it.pub project: Option<ProjectMetadata>,pub model: Option<String>,+ /// composer 的名字。子代理的 composer 名字就是派它时写的任务说明+ pub name: Option<String>,}/// 批量读,一次连接、一条缓存的语句(转录解析读一个,每轮扫描的侧档刷新读全部)。库打不开@@ -119,6 +121,7 @@ pub(super) fn composer_facts<'a>(let facts = ComposerFacts {project: ProjectMetadata::from_data(&data),model: composer_model(&data),+ name: optional_string(data.get("name")),};Some((id.to_string(), facts))})@@ -645,6 +648,13 @@ impl AgentAdapter for CursorIdeAdapter {true}+ /// 关系记在子代理自己的 composer 那一行里:按子会话的胜出副本认边。父会话多半是转录那份+ /// 胜出(cursor.rs),照"报边者拥有父会话"认的话这条边会被丢掉,子代理成了顶层会话;子代理+ /// 自己也是转录胜出时,转录那一路按路径挂(`parent_in_path`)+ fn parent_links_in_child(&self) -> bool {+ true+ }+fn parent_links(&self) -> Option<Vec<(String, String)>> {// 库读不出 = None(scanner 保留库里的关系),不折成空let mtime = super::sqlite_ro::db_cache_stamp(&self.db);diff --git a/crates/wake-core/src/adapters/dsh.rs b/crates/wake-core/src/adapters/dsh.rsindex fc01cf7..8de19d1 100644--- a/crates/wake-core/src/adapters/dsh.rs+++ b/crates/wake-core/src/adapters/dsh.rs@@ -728,10 +728,24 @@ impl AgentAdapter for DshAdapter {}fn parse_transcript(&self, r: &SessionFileRef) -> Result<ParsedTranscript> {- let parsed = parse_dsh_log(Path::new(&r.file_path), true)?;+ 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: build_meta(r, &parsed),- mainline: parsed.messages,+ meta,+ mainline,sidechains: Vec::new(),unknown_line_count: parsed.unknown_lines,})diff --git a/crates/wake-core/src/adapters/kimi.rs b/crates/wake-core/src/adapters/kimi.rsindex 0560d76..a66450c 100644--- a/crates/wake-core/src/adapters/kimi.rs+++ b/crates/wake-core/src/adapters/kimi.rs@@ -22,7 +22,8 @@ use std::sync::{Arc, Mutex};////// `state.json` 边车给标题 / 时间 / 归档 / 分叉来源("New Session" 是占位标题),cwd 靠/// home 下 `session_index.jsonl` 的 sessionId→workDir(目录名 hash 不可反推)。-/// `agents/<非main>/` 是子代理,不进列表。+/// `agents/<非main>/` 是派出去的子代理(state.json 的 `agents` 里记着 `type: "sub"` 与+/// `parentAgentId`),作为子会话挂在所在会话下面,native id 是 `<会话>/<agent id>`。pub struct KimiAdapter {/// 会话根:`<home>/sessions`(下面两级 `wd_*/<会话>`),或单个工作目录桶 `wd_*`(会话就在/// 它下面一级)@@ -110,15 +111,37 @@ impl KimiAdapter {decode_images: bool,) -> Result<(SessionMeta, Vec<TranscriptMessage>, u32)> {let path = Path::new(&r.file_path);+ let subagent = subagent_of(path);// state.json 在却读不出(又没读到过)就让这次解析失败,先读它、省得白解析整份转录:// 按默认值入库,标题、归档都是错的,而引用里记着它此刻的 mtime / size,文件不再变就- // 一直错着- let state = match session_dir_of(path) {- Some(dir) => self.states.get(dir)?,- None => KimiState::default(),+ // 一直错着。子代理没有自己的 state.json,只跟着所在会话归档——不跟的话会话归档了它还+ // 在,父会话被藏起来,它就成了顶层会话(Codex review 2026-10-12)+ let state = match (session_dir_of(path), subagent) {+ (Some(dir), _) => self.states.get(dir)?,+ (None, Some((session, _))) => KimiState {+ archived: self.states.get(session)?.archived,+ ..KimiState::default()+ },+ (None, None) => KimiState::default(),};let (messages, unknown) = parse_kimi_wire(path, decode_images)?;- let meta = build_meta(r, &state, &self.cwd_for(&r.native_id), &messages);+ // 子代理的工作目录跟着所在会话(索引按会话记)+ let session = subagent_session_id(path).unwrap_or_else(|| r.native_id.clone());+ let mut meta = build_meta(r, &state, &self.cwd_for(&session), &messages);+ if subagent.is_some() {+ // 时间按它自己的消息算+ meta.spawned = true;+ let times = || {+ messages+ .iter()+ .filter_map(|m| m.timestamp)+ .filter(|t| *t > 0)+ };+ if let (Some(first), Some(last)) = (times().min(), times().max()) {+ meta.created_at = first;+ meta.updated_at = last;+ }+ }Ok((meta, messages, unknown))}}@@ -166,6 +189,47 @@ fn session_dir_of(wire_path: &Path) -> Option<&Path> {.filter(|dir| is_session_dir(dir))}+/// 子代理的转录 `…/<会话>/agents/<id>/wire.jsonl`(id 不是 main):返回会话目录与 agent id+fn subagent_of(wire_path: &Path) -> Option<(&Path, &str)> {+ if wire_path.file_name()? != MAIN_WIRE[2] {+ return None;+ }+ let agent_dir = wire_path.parent()?;+ let id = agent_dir.file_name()?.to_str()?;+ let agents = agent_dir.parent()?;+ if id == MAIN_WIRE[1] || agents.file_name()? != MAIN_WIRE[0] {+ return None;+ }+ let session = agents.parent().filter(|dir| is_session_dir(dir))?;+ Some((session, id))+}++/// 子代理的原生 id `<会话>/<agent id>`:带 `/`,不会被当成能恢复的会话 id+fn subagent_native_id(session_dir: &Path, id: &str) -> Option<String> {+ Some(format!(+ "{}/{id}",+ session_dir.file_name()?.to_string_lossy()+ ))+}++/// 子代理所在会话的原生 id(`AgentAdapter::parent_in_path`)+fn subagent_session_id(wire_path: &Path) -> Option<String> {+ let (session, _) = subagent_of(wire_path)?;+ Some(session.file_name()?.to_string_lossy().into_owned())+}++/// 会话目录里派出去的子代理的转录,读不出的目录跳过+fn subagent_wires(session_dir: &Path) -> Vec<PathBuf> {+ let Ok(entries) = fs::read_dir(session_dir.join(MAIN_WIRE[0])) else {+ return Vec::new();+ };+ entries+ .flatten()+ .map(|entry| entry.path().join(MAIN_WIRE[2]))+ .filter(|wire| subagent_of(wire).is_some())+ .collect()+}+/// 会话目录下的边车:标题 / 时间 / 归档 / 分叉来源const STATE_FILE: &str = "state.json";@@ -347,6 +411,9 @@ struct WireReader {tool_slots: HashMap<String, (usize, usize)>,/// 最后一个 `forked` 标记之前的消息数:那一段是从父会话复制来的inherited: usize,+ /// 读的是子代理的转录(`subagent_of`):派它的 Agent 调用写的任务(`system_trigger` /+ /// `subagent`)是它的"用户"那句+ subagent: bool,}impl WireReader {@@ -407,6 +474,13 @@ impl WireReader {}fn visible(&mut self, origin: Option<&Value>) -> bool {+ let field = |key: &str| origin.and_then(|o| o.get(key)).and_then(Value::as_str);+ if self.subagent+ && field("kind") == Some("system_trigger")+ && field("name") == Some("subagent")+ {+ return true;+ }user_visible(origin).unwrap_or_else(|| {self.unknown += 1;false@@ -553,6 +627,7 @@ fn parse_kimi_wire(path: &Path, decode_images: bool) -> Result<(Vec<TranscriptMelet reader = BufReader::with_capacity(1 << 20, fs::File::open(path)?);let mut wire = WireReader {decode_images,+ subagent: subagent_of(path).is_some(),..Default::default()};for row in jsonl_values(reader) {@@ -564,6 +639,52 @@ fn parse_kimi_wire(path: &Path, decode_images: bool) -> Result<(Vec<TranscriptMeOk(wire.finish())}+/// 会话派出去的子代理(各自作为子会话入库)。派它的 Agent 调用按输出里那行 `agent_id: <id>`+/// 对上——头一回派的与接着派的(`resume`)都写这一行;任务说明与类型从调用的参数取+fn link_agent_calls(session_dir: &Path, mainline: &mut [TranscriptMessage]) -> Vec<SidechainInfo> {+ let mut sidechains: Vec<SidechainInfo> = subagent_wires(session_dir)+ .iter()+ .filter_map(|wire| {+ let (_, id) = subagent_of(wire)?;+ Some(SidechainInfo {+ id: id.to_string(),+ session_id: subagent_native_id(session_dir, id),+ ..SidechainInfo::default()+ })+ })+ .collect();+ for call in mainline.iter_mut().flat_map(|m| m.tool_calls.iter_mut()) {+ let Some(id) = call+ .output+ .as_deref()+ .and_then(|out| out.lines().find_map(|line| line.strip_prefix("agent_id: ")))+ else {+ continue;+ };+ let Some(sidechain) = sidechains.iter_mut().find(|s| s.id == id.trim()) else {+ continue;+ };+ call.child_id = sidechain.session_id.clone();+ let input: Option<Value> = call+ .input+ .as_deref()+ .and_then(|i| serde_json::from_str(i).ok());+ let arg = |key: &str| {+ input+ .as_ref()+ .and_then(|v| text_at(v, key))+ .map(String::from)+ };+ sidechain.description = sidechain.description.take().or_else(|| arg("description"));+ sidechain.agent_type = sidechain.agent_type.take().or_else(|| arg("subagent_type"));+ sidechain.tool_use_id = sidechain+ .tool_use_id+ .take()+ .or_else(|| Some(call.id.clone()));+ }+ sidechains+}+fn session_key_of(native_id: &str) -> String {session_key(AgentId::Kimi, "", native_id)}@@ -631,12 +752,24 @@ impl AgentAdapter for KimiAdapter {Ok(self.session_dirs().iter()- .filter_map(|dir| self.file_ref(&dir.join(&rel)))+ .flat_map(|dir| std::iter::once(dir.join(&rel)).chain(subagent_wires(dir)))+ .filter_map(|wire| self.file_ref(&wire)).collect())}fn file_ref(&self, path: &Path) -> Option<SessionFileRef> {- // 只认主代理的 wire.jsonl(形状判定在 session_dir_of;agents/<其他>/ 是子代理)。+ // 子代理(`agents/<非main>/wire.jsonl`):native id 带上所在会话。它跟着会话归档,+ // 归档与否并进引用(只这一位:state.json 每一轮都重写,整份并进来子代理就跟着轮轮+ // 重解析),在 Kimi 里归档 / 取消归档时全量扫描认得出它变了+ if let Some((session, id)) = subagent_of(path) {+ let mut r = default_file_ref(self.agent(), path)?;+ r.native_id = subagent_native_id(session, id)?;+ if self.states.get(session).is_ok_and(|state| state.archived) {+ r.size += 1;+ }+ return Some(r);+ }+ // 主代理的 wire.jsonl(形状判定在 session_dir_of)。// state.json 单独改了(在 Kimi 里归档、改名)也要重新解析:监听到它就换成同会话的// 主转录,它的 mtime / size 并进引用——全量扫描按引用判脏let wire = if path.file_name()? == STATE_FILE {@@ -655,7 +788,27 @@ impl AgentAdapter for KimiAdapter {Some(r)}+ /// 会话的 state.json 变了(在 Kimi 里归档、取消归档):子代理的引用里并着归档那一位,+ /// 它们自己的转录没动、收不到事件,交给 watcher 按引用重比+ fn ref_dependents(&self, path: &Path) -> Vec<PathBuf> {+ match path.parent() {+ Some(dir)+ if path.file_name().is_some_and(|name| name == STATE_FILE)+ && is_session_dir(dir) =>+ {+ subagent_wires(dir)+ }+ _ => Vec::new(),+ }+ }+fn session_paths(&self, meta: &SessionMeta) -> Vec<String> {+ // 子代理是它自己的 agent 目录+ if subagent_of(Path::new(&meta.file_path)).is_some() {+ if let Some(dir) = Path::new(&meta.file_path).parent() {+ return vec![dir.to_string_lossy().to_string()];+ }+ }// 会话是整个会话目录(state.json + agents/),整目录进废纸篓session_dir_of(Path::new(&meta.file_path)).map(|d| vec![d.to_string_lossy().to_string()])@@ -668,15 +821,39 @@ impl AgentAdapter for KimiAdapter {}fn parse_transcript(&self, r: &SessionFileRef) -> Result<ParsedTranscript> {- let (meta, messages, unknown) = self.parse(r, true)?;+ let (meta, mut messages, unknown) = self.parse(r, true)?;+ let sidechains = match session_dir_of(Path::new(&r.file_path)) {+ Some(dir) => link_agent_calls(dir, &mut messages),+ None => Vec::new(),+ };Ok(ParsedTranscript {meta,mainline: messages,- sidechains: Vec::new(),+ sidechains,unknown_line_count: unknown,})}+ fn load_sidechain(+ &self,+ r: &SessionFileRef,+ sidechain_id: &str,+ ) -> Result<Vec<TranscriptMessage>> {+ let Some(dir) = session_dir_of(Path::new(&r.file_path)) else {+ return Ok(Vec::new());+ };+ let wire = dir.join(MAIN_WIRE[0]).join(sidechain_id).join(MAIN_WIRE[2]);+ if subagent_of(&wire).is_none() || !wire.is_file() {+ return Ok(Vec::new());+ }+ Ok(parse_kimi_wire(&wire, true)?.0)+ }++ /// 子代理挂到所在会话下面(它的转录就在会话目录的 agents/ 里)+ fn parent_in_path(&self) -> Option<super::ParentInPath> {+ Some(subagent_session_id)+ }+fn cleanup_paths(&self, meta: &SessionMeta) -> Option<Vec<String>> {Some(self.session_paths(meta))}diff --git a/crates/wake-core/src/adapters/mod.rs b/crates/wake-core/src/adapters/mod.rsindex 3d80179..c98d739 100644--- a/crates/wake-core/src/adapters/mod.rs+++ b/crates/wake-core/src/adapters/mod.rs@@ -38,6 +38,9 @@ use crate::models::*;use anyhow::{Context as _, Result};use std::path::Path;+/// 从子会话转录的路径推它父会话的原生 id(`AgentAdapter::parent_in_path`)+pub type ParentInPath = fn(&Path) -> Option<String>;+/// agent 数据源适配器。列表扫描与详情解析共用同一核心解析器,/// 保证 FTS 的 seq 与详情页消息序号一致(搜索跳转依赖)。pub trait AgentAdapter: Send + Sync {@@ -253,13 +256,24 @@ pub trait AgentAdapter: Send + Sync {fn parent_links_in_child(&self) -> bool {false}- /// 本家的子会话是不是**分支**——从父会话分出去、自己完整的一段对话(Claude Code 的- /// fork),而不是父会话的一部分(子代理、子任务)。是的话删父会话不带上它们:详情页- /// 删除只删父会话本身,Clean Up 里分支自成一棵清理树;父会话没了,分支变回顶层会话、- /// 露出完整历史。默认 false(随父会话一起删)。远程装饰器必须转发- fn children_outlive_parent(&self) -> bool {+ /// 这条子会话(按它的文件)是不是**分支**——从父会话分出去、自己完整的一段对话(Claude+ /// Code 的 fork),而不是父会话的一部分(子代理、子任务)。是的话删父会话不带上它:详情页+ /// 删除只删父会话那一支,Clean Up 里分支自成一棵清理树;父会话没了,分支变回顶层会话、+ /// 露出完整历史。按子会话判而不是按家判:同一家里分支与子代理并存(Claude Code)。默认+ /// false(随父会话一起删)。远程装饰器必须转发+ fn child_outlives_parent(&self, _child_path: &str) -> bool {false}+ /// 父会话就写在子会话自己的**路径**里的家(Claude Code、Cursor、CodeBuddy、Qoder 的子代理转录+ /// 在 `<父会话>/subagents/` 里,Kimi 的在 `<会话>/agents/<名字>/` 里)给出从路径推父会话**原生 id**+ /// 的函数:纯路径计算、不碰文件系统。关系同步对库里这一家的每条会话按它的胜出文件问一遍、按那个+ /// 实例的 host 拼 key,与 `parent_links` 报的合在一起——这类关系不用另外枚举目录(每批监听都要+ /// 同步一次关系);有它也就是这家管父子关系。这样的子会话停在它的父会话上、不往上压平(父会话+ /// 本身是分支或分叉也一样,删它时目录连同子代理一起走),也不是能单独恢复的会话+ /// (`adapters::resumable`)。默认 None。远程装饰器必须转发+ fn parent_in_path(&self) -> Option<ParentInPath> {+ None+ }/// `parent_links` 只记 agent 派出去的子会话(Grok 的 subagents 登记表)时为 true:关系同步/// 把挂上的子会话标成 `SessionMeta::spawned`。这类标记出自别的会话的边车,解析子会话时/// 未必看得见——父会话在另一个 location、登记晚于子会话最后一次写入才落盘——合并了全部@@ -607,11 +621,20 @@ pub fn adapter_for<'a>(adapter_ix_for(adapters, agent, file_path).map(|ix| adapters[ix].as_ref())}-/// 这条会话所在的家,子会话是不是各自完整的对话(`AgentAdapter::children_outlive_parent`):-/// 是的话删除与 Clean Up 都不带上它们。详情页删除问根会话、Clean Up 载入索引时问每条子-/// 会话——关系只连同家会话,两种问法是同一个答案-pub fn children_outlive_parent(adapters: &[Box<dyn AgentAdapter>], meta: &SessionMeta) -> bool {- adapter_for(adapters, meta.agent, &meta.file_path).is_some_and(|a| a.children_outlive_parent())+/// 这条子会话是不是自己完整的对话(`AgentAdapter::child_outlives_parent`,按它的胜出文件问它所在+/// 的实例):是的话删除父会话与 Clean Up 都不带上它+pub fn child_outlives_parent(adapters: &[Box<dyn AgentAdapter>], child: &SessionMeta) -> bool {+ adapter_for(adapters, child.agent, &child.file_path)+ .is_some_and(|a| a.child_outlives_parent(&child.file_path))+}++/// 这条会话能不能单独恢复(详情页的 Open In):转录放在父会话目录里的子代理不能——它是父会话的+/// 一部分,`claude --resume agent-…` 一类打不开。判据是它所在的实例按路径推得出父会话+/// (`AgentAdapter::parent_in_path`),与关系同步同一个+pub fn resumable(adapters: &[Box<dyn AgentAdapter>], meta: &SessionMeta) -> bool {+ adapter_for(adapters, meta.agent, &meta.file_path)+ .and_then(|a| a.parent_in_path())+ .is_none_or(|parent| parent(std::path::Path::new(&meta.file_path)).is_none())}/// `parent_links` 的边:(子会话 id, 父会话 id) 拼成两个本地 key。指向自己的不要——scanner@@ -1348,7 +1371,7 @@ mod tests {input: input.map(String::from),output: None,is_error: false,- sidechain_ref: None,+ child_id: None,}}diff --git a/crates/wake-core/src/adapters/opencode.rs b/crates/wake-core/src/adapters/opencode.rsindex fae5954..3579f55 100644--- a/crates/wake-core/src/adapters/opencode.rs+++ b/crates/wake-core/src/adapters/opencode.rs@@ -682,7 +682,7 @@ impl BlockAcc {}self.content.images.extend(images);}- self.tools.push(tool_call_view(+ let mut call = tool_call_view(b.get("callID").or_else(|| b.get("id")).and_then(|v| v.as_str())@@ -695,7 +695,10 @@ impl BlockAcc {&input,output,state.get("status").and_then(|v| v.as_str()) == Some("error"),- ));+ );+ // task 工具派出去的子会话:它的 id 记在调用的 metadata 里+ call.child_id = optional_string(state.pointer("/metadata/sessionId"));+ self.tools.push(call);}fn push_image(&mut self, block: &Value, decode_images: bool) {diff --git a/crates/wake-core/src/adapters/parse_utils.rs b/crates/wake-core/src/adapters/parse_utils.rsindex b2d8049..88f7270 100644--- a/crates/wake-core/src/adapters/parse_utils.rs+++ b/crates/wake-core/src/adapters/parse_utils.rs@@ -272,6 +272,212 @@ pub fn collapse_inherited(messages: &mut Vec<TranscriptMessage>, cut: usize, parmessages.splice(..cut, std::iter::once(marker));}+// ---- Claude 式会话目录里的子代理(Claude Code、CodeBuddy / WorkBuddy、Qoder 同构) ----++/// 会话的同名目录(`<projects>/<slug>/<id>/`,子代理转录等边车在里面)+pub fn session_dir(r: &SessionFileRef) -> std::path::PathBuf {+ std::path::Path::new(&r.file_path)+ .parent()+ .unwrap_or(std::path::Path::new("."))+ .join(&r.native_id)+}++/// 子代理转录所在会话的目录(目录名就是派它的会话的 id):Task / Agent 派的在+/// `<会话>/subagents/agent-<id>.jsonl`,Workflow 跑出来的再深一层 `subagents/workflows/wf_<id>/`;+/// 同一目录里的 journal.jsonl 是 Workflow 的运行日志,不是转录。这些转录作为子会话入库,但不是+/// 能单独恢复的会话+pub fn subagent_session_dir(path: &std::path::Path) -> Option<&std::path::Path> {+ let name = path.file_name()?.to_str()?;+ if !(name.starts_with("agent-") && name.ends_with(".jsonl")) {+ return None;+ }+ let named = |dir: &std::path::Path, name: &str| dir.file_name().is_some_and(|n| n == name);+ let dir = path.parent()?;+ let subagents = if named(dir, "subagents") {+ dir+ } else {+ let run = dir.file_name()?.to_str()?;+ let workflows = dir.parent()?;+ let subagents = workflows.parent()?;+ (run.starts_with("wf_") && named(workflows, "workflows") && named(subagents, "subagents"))+ .then_some(subagents)?+ };+ subagents.parent()+}++pub fn is_subagent_transcript(path: &str) -> bool {+ subagent_session_dir(std::path::Path::new(path)).is_some()+}++/// 子代理转录所在会话的原生 id(`AgentAdapter::parent_in_path`)+pub fn subagent_parent(path: &std::path::Path) -> Option<String> {+ Some(+ subagent_session_dir(path)?+ .file_name()?+ .to_string_lossy()+ .into_owned(),+ )+}++/// 一个会话目录里全部子代理转录的引用(Task / Agent 派的与 Workflow 跑出来的),读不出的目录跳过+pub fn subagent_refs(agent: AgentId, session_dir: &std::path::Path) -> Vec<SessionFileRef> {+ let files = |dir: &std::path::Path| -> Vec<std::path::PathBuf> {+ std::fs::read_dir(dir)+ .map(|entries| entries.flatten().map(|entry| entry.path()).collect())+ .unwrap_or_default()+ };+ let mut transcripts = Vec::new();+ for path in files(&session_dir.join("subagents")) {+ if path.file_name().is_some_and(|name| name == "workflows") {+ transcripts.extend(files(&path).iter().flat_map(|run| files(run)));+ } else {+ transcripts.push(path);+ }+ }+ transcripts+ .iter()+ .filter(|path| subagent_session_dir(path).is_some())+ .filter_map(|path| subagent_ref(agent, path))+ .collect()+}++/// 监听事件落在子代理转录或它的边车上:换成转录的引用。`session_ok` 判它所在的会话目录是不是这个+/// 实例认的那一层(各家的数据根与目录深度不同)+pub fn subagent_event_ref(+ agent: AgentId,+ path: &std::path::Path,+ session_ok: impl FnOnce(&std::path::Path) -> bool,+) -> Option<SessionFileRef> {+ let transcript = match path.file_name()?.to_str()?.strip_suffix(".meta.json") {+ Some(stem) => path.with_file_name(format!("{stem}.jsonl")),+ None => path.to_path_buf(),+ };+ if !session_ok(subagent_session_dir(&transcript)?) {+ return None;+ }+ subagent_ref(agent, &transcript)+}++/// 子代理转录的边车 `agent-<id>.meta.json`:agentType / 任务说明 / 派它的 tool_use id+fn subagent_sidecar(transcript: &std::path::Path) -> std::path::PathBuf {+ transcript.with_extension("meta.json")+}++/// 子代理转录的引用,边车并进戳(列表与监听同一个)+fn subagent_ref(agent: AgentId, transcript: &std::path::Path) -> Option<SessionFileRef> {+ let mut r = default_file_ref(agent, transcript)?;+ if let Some((mtime, size)) = stat_stamp(&subagent_sidecar(transcript)) {+ r.mtime_ms = r.mtime_ms.max(mtime);+ r.size += size;+ }+ Some(r)+}++/// 一份子代理转录读成 `SidechainInfo`:边车给是谁、干什么、哪次调用派的(没有边车的家这几项为空);+/// 它同时作为子会话入库,`session_id` 就是文件名+pub fn sidechain_info(transcript: &std::path::Path) -> Option<SidechainInfo> {+ let id = transcript.file_stem()?.to_string_lossy().to_string();+ let sidecar = std::fs::read_to_string(subagent_sidecar(transcript))+ .ok()+ .and_then(|raw| serde_json::from_str::<Value>(&raw).ok());+ let field = |key: &str| {+ sidecar+ .as_ref()+ .and_then(|v| text_at(v, key))+ .map(String::from)+ };+ Some(SidechainInfo {+ session_id: Some(id.clone()),+ agent_type: field("agentType"),+ description: field("description"),+ tool_use_id: field("toolUseId"),+ id,+ })+}++/// 会话直属的子代理(`<会话>/subagents/` 那一层;MCP 的 `subagent` 参数与导出按它读),派活的+/// 调用按边车记的 tool_use id 指向子会话。子代理自己下面没有这一层目录,给空+pub fn link_subagents(+ session_dir: &std::path::Path,+ mainline: &mut [TranscriptMessage],+) -> Vec<SidechainInfo> {+ let Ok(entries) = std::fs::read_dir(session_dir.join("subagents")) else {+ return Vec::new();+ };+ let sidechains: Vec<SidechainInfo> = entries+ .flatten()+ .map(|entry| entry.path())+ .filter(|path| subagent_session_dir(path).is_some())+ .filter_map(|path| sidechain_info(&path))+ .collect();+ let by_call: std::collections::HashMap<&str, &SidechainInfo> = sidechains+ .iter()+ .filter_map(|s| s.tool_use_id.as_deref().map(|id| (id, s)))+ .collect();+ for call in mainline.iter_mut().flat_map(|m| m.tool_calls.iter_mut()) {+ if let Some(sidechain) = by_call.get(call.id.as_str()) {+ call.child_id = sidechain.session_id.clone();+ }+ }+ sidechains+}++/// Claude 式布局的会话转录:会话里派活的调用指向它派出去的子会话(`link_subagents`)+pub fn transcript_with_subagents(+ r: &SessionFileRef,+ meta: SessionMeta,+ mut mainline: Vec<TranscriptMessage>,+ unknown_line_count: u32,+) -> ParsedTranscript {+ let sidechains = link_subagents(&session_dir(r), &mut mainline);+ ParsedTranscript {+ meta,+ mainline,+ sidechains,+ unknown_line_count,+ }+}++/// 按 id 读会话直属的一份子代理转录(`AgentAdapter::load_sidechain`,MCP 的 `subagent` 参数);+/// 没有这份给空+pub fn load_subagent(+ r: &SessionFileRef,+ id: &str,+ parse: impl FnOnce(&std::path::Path) -> anyhow::Result<Vec<TranscriptMessage>>,+) -> anyhow::Result<Vec<TranscriptMessage>> {+ let file = session_dir(r).join("subagents").join(format!("{id}.jsonl"));+ if !file.is_file() {+ return Ok(Vec::new());+ }+ parse(&file)+}++/// 子代理转录作为子会话:是 agent 派出去的(Insights 不算),标题取边车记的任务说明——没有就照常+/// (多半是派活那句话)。不是子代理转录的不动+pub fn mark_subagent(meta: &mut SessionMeta, transcript: &std::path::Path) {+ if subagent_session_dir(transcript).is_none() {+ return;+ }+ meta.spawned = true;+ if let Some(task) = sidechain_info(transcript)+ .and_then(|info| info.description)+ .map(|task| clean_title_candidate(&task))+ .filter(|task| !task.is_empty())+ {+ meta.title = task;+ }+}++/// 子代理自己的文件:转录与它的边车(删除时一起走)+pub fn subagent_paths(transcript: &str) -> Vec<String> {+ let sidecar = subagent_sidecar(std::path::Path::new(transcript));+ let mut paths = vec![transcript.to_string()];+ if sidecar.is_file() {+ paths.push(sidecar.to_string_lossy().to_string());+ }+ paths+}+/// `AgentAdapter::file_ref` 的默认实现:非空 .jsonl,stem 即 native_id。/// 覆写方可在此结果上做路径过滤或 native_id 改写。pub fn default_file_ref(agent: AgentId, path: &std::path::Path) -> Option<SessionFileRef> {@@ -295,22 +501,28 @@ pub fn default_file_ref(agent: AgentId, path: &std::path::Path) -> Option<Sessio/// Claude 式 projects 树(Qoder / CodeBuddy / WorkBuddy)的会话枚举:根直属的/// `<session>.jsonl` 与下一层 `<slug>/<session>.jsonl` 都收——自定义 location-/// 允许直接选中某个 slug 目录;**不再往下走**,`<session>/subagents/` 里的子-/// 代理转录不是顶层会话(递归的 list_jsonl_refs 会把它们吞进来)。按路径排序+/// 允许直接选中某个 slug 目录;会话同名目录里派出去的子代理(`<session>/subagents/`)+/// 作为子会话一并收,别的边车不收(递归的 list_jsonl_refs 会把它们吞进来)。按路径排序pub fn list_project_tree_refs(root: &std::path::Path, agent: AgentId) -> Vec<SessionFileRef> {let mut refs = Vec::new();let Ok(entries) = std::fs::read_dir(root) else {return refs;};+ let is_dir = |entry: &std::fs::DirEntry| entry.file_type().is_ok_and(|t| t.is_dir());for entry in entries.flatten() {let path = entry.path();- if entry.file_type().is_ok_and(|t| t.is_dir()) {- if let Ok(inner) = std::fs::read_dir(&path) {- refs.extend(- inner- .flatten()- .filter_map(|e| default_file_ref(agent, &e.path())),- );+ if is_dir(&entry) {+ // slug 目录(里面是会话),或者根本身就是 slug 目录时的会话同名目录+ refs.extend(subagent_refs(agent, &path));+ let Ok(inner) = std::fs::read_dir(&path) else {+ continue;+ };+ for e in inner.flatten() {+ if is_dir(&e) {+ refs.extend(subagent_refs(agent, &e.path()));+ } else if let Some(r) = default_file_ref(agent, &e.path()) {+ refs.push(r);+ }}} else if let Some(r) = default_file_ref(agent, &path) {refs.push(r);@@ -320,6 +532,26 @@ pub fn list_project_tree_refs(root: &std::path::Path, agent: AgentId) -> Vec<Sesrefs}+/// Claude 式 projects 树里监听事件对应的会话(Qoder / CodeBuddy / WorkBuddy):根下一两层的+/// `<session>.jsonl`,或会话同名目录里的子代理转录(边车的事件换成转录的引用)。更深的+/// 别的边车(state、memory)都不是+pub fn project_tree_file_ref(+ root: &std::path::Path,+ agent: AgentId,+ path: &std::path::Path,+) -> Option<SessionFileRef> {+ let relative = path.strip_prefix(root).ok()?;+ if relative.components().count() <= 2 {+ return default_file_ref(agent, path);+ }+ // 会话同名目录在根下一两层(根是 projects 目录或某个 slug 目录)+ subagent_event_ref(agent, path, |session| {+ session+ .strip_prefix(root)+ .is_ok_and(|session| session.components().count() <= 2)+ })+}+/// 上面那棵树里有没有任何会话文件:env 候选根只在探到真实数据时才采信/// (存在但空的候选不能遮掉默认根)。见首个就停,不做完整枚举——它跑在/// adapter 构造时、也就是应用启动路径上@@ -1035,7 +1267,7 @@ pub fn tool_call_view(},output: output.map(|o| clip(&o, MAX_TOOL_IO).0),is_error,- sidechain_ref: None,+ child_id: None,}}@@ -1117,6 +1349,8 @@ fn clean_user_text(raw: &str, whole_command: bool) -> String {let mut s = strip_tag_block(raw, "system-reminder");s = strip_tag_block(&s, "local-command-caveat");s = strip_tag_block(&s, "local-command-stdout");+ // Kimi 派出去的 explore 子代理收到的任务前面垫着仓库现状+ s = strip_tag_block(&s, "git-context");let args = extract_tag(&s, "command-args");let name = extract_tag(&s, "command-name");diff --git a/crates/wake-core/src/adapters/qoder.rs b/crates/wake-core/src/adapters/qoder.rsindex 1cfc64f..b84f494 100644--- a/crates/wake-core/src/adapters/qoder.rs+++ b/crates/wake-core/src/adapters/qoder.rs@@ -12,8 +12,8 @@ use std::path::{Path, PathBuf};////// user/assistant/system 行以 `uuid` + `parentUuid` 组成可回退的消息树,尾部/// `active-leaf` 指向当前分支;标题、工作目录和运行配置则以独立元数据行追加。-/// 会话同名目录还保存 state/subagents 等边车,主列表只枚举 project-key 目录-/// 直属的 JSONL,不能把 `subagents/agent-*.jsonl` 当成顶层会话。+/// 会话同名目录还保存 state/subagents 等边车:`subagents/agent-*.jsonl` 是派出去的+/// 子代理(整份都是 `isSidechain: true` 的行),作为子会话挂在派它的会话下面。pub struct QoderAdapter {root: PathBuf,}@@ -249,7 +249,9 @@ fn active_chain(out}+/// 会话自己的转录跳过 sidechain 行;子代理的转录(`subagents/agent-*.jsonl`)整份都是 sidechain 行fn parse_qoder_jsonl(path: &Path, decode_images: bool) -> Result<QoderParse> {+ let sidechain = subagent_session_dir(path).is_some();let _image_budget = transcript_image_decode_budget(decode_images);let file = fs::File::open(path)?;let reader = BufReader::with_capacity(1 << 20, file);@@ -319,7 +321,7 @@ fn parse_qoder_jsonl(path: &Path, decode_images: bool) -> Result<QoderParse> {// attachment 本身不展示,但它有时会成为下一条消息的 parent,必须// 留在树里,否则 active-leaf 回溯会在这里提前断链。"user" | "assistant" | "system" | "attachment" => {- if row.get("isSidechain").and_then(Value::as_bool) == Some(true) {+ if !sidechain && row.get("isSidechain").and_then(Value::as_bool) == Some(true) {continue;}let Some(uuid) = optional_string(row.get("uuid")) else {@@ -620,6 +622,15 @@ fn build_meta(r: &SessionFileRef, parsed: &QoderParse) -> SessionMeta {}}+/// 会话或子代理(子代理是 agent 派出去的,标题取边车记的任务说明)+fn parse(r: &SessionFileRef, decode_images: bool) -> Result<(SessionMeta, QoderParse)> {+ let path = Path::new(&r.file_path);+ let parsed = parse_qoder_jsonl(path, decode_images)?;+ let mut meta = build_meta(r, &parsed);+ mark_subagent(&mut meta, path);+ Ok((meta, parsed))+}+impl AgentAdapter for QoderAdapter {fn agent(&self) -> AgentId {AgentId::Qoder@@ -630,18 +641,11 @@ impl AgentAdapter for QoderAdapter {}fn file_ref(&self, path: &Path) -> Option<SessionFileRef> {- let relative = path.strip_prefix(&self.root).ok()?;- // root/<session>.jsonl 或 root/<project-key>/<session>.jsonl;更深的- // state/subagents/memory 均是边车,不得成为顶层会话。- if relative.components().count() > 2 {- return None;- }- default_file_ref(self.agent(), path)+ project_tree_file_ref(&self.root, AgentId::Qoder, path)}fn parse_session(&self, r: &SessionFileRef) -> Result<ParsedSession> {- let parsed = parse_qoder_jsonl(Path::new(&r.file_path), false)?;- let meta = build_meta(r, &parsed);+ let (meta, parsed) = parse(r, false)?;Ok(ParsedSession::derive(meta,&parsed.messages,@@ -650,16 +654,34 @@ impl AgentAdapter for QoderAdapter {}fn parse_transcript(&self, r: &SessionFileRef) -> Result<ParsedTranscript> {- let parsed = parse_qoder_jsonl(Path::new(&r.file_path), true)?;- Ok(ParsedTranscript {- meta: build_meta(r, &parsed),- mainline: parsed.messages,- sidechains: Vec::new(),- unknown_line_count: parsed.unknown_lines,+ let (meta, parsed) = parse(r, true)?;+ Ok(transcript_with_subagents(+ r,+ meta,+ parsed.messages,+ parsed.unknown_lines,+ ))+ }++ fn load_sidechain(+ &self,+ r: &SessionFileRef,+ sidechain_id: &str,+ ) -> Result<Vec<TranscriptMessage>> {+ load_subagent(r, sidechain_id, |file| {+ Ok(parse_qoder_jsonl(file, true)?.messages)})}+ /// 子代理挂到派它的会话下面:所在会话目录的名字就是那个会话的 id+ fn parent_in_path(&self) -> Option<super::ParentInPath> {+ Some(subagent_parent)+ }+fn session_paths(&self, meta: &SessionMeta) -> Vec<String> {+ if is_subagent_transcript(&meta.file_path) {+ return subagent_paths(&meta.file_path);+ }let mut paths = vec![meta.file_path.clone()];if let Some(parent) = Path::new(&meta.file_path).parent() {let sidecar = parent.join(&meta.id);diff --git a/crates/wake-core/src/adapters/remote.rs b/crates/wake-core/src/adapters/remote.rsindex 945f360..7922e85 100644--- a/crates/wake-core/src/adapters/remote.rs+++ b/crates/wake-core/src/adapters/remote.rs@@ -234,8 +234,12 @@ impl AgentAdapter for RemoteAdapter {self.inner.parent_links_in_child()}- fn children_outlive_parent(&self) -> bool {- self.inner.children_outlive_parent()+ fn child_outlives_parent(&self, child_path: &str) -> bool {+ self.inner.child_outlives_parent(child_path)+ }++ fn parent_in_path(&self) -> Option<super::ParentInPath> {+ self.inner.parent_in_path()}fn linked_children_are_spawned(&self) -> bool {diff --git a/crates/wake-core/src/cleanup.rs b/crates/wake-core/src/cleanup.rsindex b8287f5..3206f4f 100644--- a/crates/wake-core/src/cleanup.rs+++ b/crates/wake-core/src/cleanup.rs@@ -1,7 +1,7 @@//! Local session cleanup: immutable review plans, conservative ownership checks,//! per-target Trash results and a durable journal. No source database writes.use crate::{- adapters::{adapter_for, children_outlive_parent, AgentAdapter},+ adapters::{adapter_for, child_outlives_parent, AgentAdapter},db::{put_back_fingerprint, Store},models::*,services::terminal,@@ -423,19 +423,88 @@ struct CleanupPlan {targets: Vec<CleanupTarget>,}-/// 清理用的会话索引。分支——所在的家声明子会话是自己完整的对话(`children_outlive_parent`,+/// 清理用的会话索引。分支——所在的家声明子会话是自己完整的对话(`child_outlives_parent`,/// Claude Code 的 fork)——在这里就摘掉父会话:它自成一棵清理树,单独列、单独清,也不随父/// 会话一起清;子代理、子任务照旧是父会话树的一部分fn cleanup_index(store: &Store, adapters: &[Box<dyn AgentAdapter>]) -> Result<Vec<IndexedSession>> {let mut index = store.cleanup_index()?;for s in &mut index {- if !s.parent.is_empty() && children_outlive_parent(adapters, &s.meta) {+ if !s.parent.is_empty() && child_outlives_parent(adapters, &s.meta) {s.parent.clear();}}Ok(index)}+/// 套在别的路径里的不单列、重复的只留一份(父会话的目录里装着它派出去的子代理的转录:先移走+/// 外层,再移里面那份就找不着了)。详情页删除与 Clean Up 共用+pub fn outermost(paths: impl IntoIterator<Item = PathBuf>) -> Vec<PathBuf> {+ let mut paths: Vec<PathBuf> = paths.into_iter().collect();+ paths.sort();+ paths.dedup();+ let mut roots: Vec<PathBuf> = vec![];+ for path in paths {+ if !roots.iter().any(|p| path.starts_with(p)) {+ roots.push(path);+ }+ }+ roots+}++/// 详情页删一条会话:随它一起删的子会话与要移进废纸篓的路径+pub struct DeletePlan {+ /// 第一条是要删的那条会话+ pub sessions: Vec<SessionMeta>,+ /// `session_paths` 的并集,套在别的目标里的不单列(`outermost`)+ pub targets: Vec<String>,+ /// 留下来的分支有几条+ pub kept_branches: usize,+}++/// 删一条会话时一起删什么:子代理、子任务随父会话走;分支(`child_outlives_parent`)连同挂在它+/// 下面的会话留下——它是自己完整的对话,原件没了变回顶层会话(Clean Up 的 `cleanup_index` 同一条+/// 规矩)。每条子会话按自己的胜出文件找实例:多 location 下不能沿用根会话所属的那个+pub fn delete_plan(+ store: &Store,+ adapters: &[Box<dyn AgentAdapter>],+ root: &SessionMeta,+) -> Result<DeletePlan> {+ let tree = store.all_descendants(&root.key)?;+ let mut children: HashMap<&str, Vec<&IndexedSession>> = HashMap::new();+ for s in &tree {+ children.entry(s.parent.as_str()).or_default().push(s);+ }+ let mut sessions = vec![root.clone()];+ let mut seen = HashSet::from([root.key.clone()]);+ let mut kept_branches = 0;+ let mut cursor = 0;+ while cursor < sessions.len() {+ let parent = sessions[cursor].key.clone();+ for child in children.get(parent.as_str()).into_iter().flatten() {+ if child_outlives_parent(adapters, &child.meta) {+ kept_branches += 1;+ } else if seen.insert(child.meta.key.clone()) {+ sessions.push(child.meta.clone());+ }+ }+ cursor += 1;+ }+ let paths = sessions.iter().flat_map(|s| {+ adapter_for(adapters, s.agent, &s.file_path)+ .map(|adapter| adapter.session_paths(s))+ .unwrap_or_else(|| vec![s.file_path.clone()])+ });+ let targets = outermost(paths.map(PathBuf::from))+ .into_iter()+ .map(|p| p.to_string_lossy().into_owned())+ .collect();+ Ok(DeletePlan {+ sessions,+ targets,+ kept_branches,+ })+}+fn build_plan(root: &IndexedSession,index: &[IndexedSession],@@ -479,14 +548,7 @@ fn build_plan(paths.push(p);}}- paths.sort();- paths.dedup();- let mut roots: Vec<PathBuf> = vec![];- for path in paths {- if !roots.iter().any(|p| path.starts_with(p)) {- roots.push(path);- }- }+ let roots = outermost(paths);for other in index.iter().filter(|s| !keys.contains(s.meta.key.as_str())) {ensure!(!roots@@ -1083,7 +1145,7 @@ mod tests {struct FilesAdapter {root: PathBuf,supported: bool,- /// 子会话是不是分支(`children_outlive_parent`)+ /// 子会话是不是分支(`child_outlives_parent`)branches: bool,}impl AgentAdapter for FilesAdapter {@@ -1132,7 +1194,7 @@ mod tests {fn cleanup_paths(&self, m: &SessionMeta) -> Option<Vec<String>> {self.supported.then(|| self.session_paths(m))}- fn children_outlive_parent(&self) -> bool {+ fn child_outlives_parent(&self, _child_path: &str) -> bool {self.branches}}@@ -1223,6 +1285,26 @@ mod tests {.unwrap();m}+ /// 父会话的目录里装着子代理的转录:一起删时只移外层,不然第二下找不着文件、整批报错+ #[test]+ fn nested_targets_collapse_into_the_outer_one() {+ let p = |s: &str| PathBuf::from(s);+ assert_eq!(+ outermost([+ p("/h/projects/-w/5ab0.jsonl"),+ p("/h/projects/-w/5ab0"),+ p("/h/projects/-w/5ab0/subagents/agent-a1.jsonl"),+ p("/h/projects/-w/5ab0-other"),+ p("/h/projects/-w/5ab0"),+ ]),+ [+ p("/h/projects/-w/5ab0"),+ p("/h/projects/-w/5ab0-other"),+ p("/h/projects/-w/5ab0.jsonl"),+ ]+ );+ }+/// 分支(所在的家声明子会话是自己完整的对话)自成一棵清理树:原件的清理计划不带上它,/// 它自己也是一个候选、过得了复核;默认(子代理一类)照旧随父会话#[test]diff --git a/crates/wake-core/src/cli.rs b/crates/wake-core/src/cli.rsindex 7214ff7..4025efd 100644--- a/crates/wake-core/src/cli.rs+++ b/crates/wake-core/src/cli.rs@@ -204,7 +204,7 @@ const F_SUBAGENT: FlagSpec = FlagSpec::new("subagent",Arity::Value,"ID",- "read this subagent transcript instead of the main one (ids are listed at the end of the main transcript)",+ "read this subagent transcript instead of the main one ('*' lists the ids)",);const SEARCH_FLAGS: &[FlagSpec] = &[F_PROJECT, F_AGENT, F_SINCE, F_LIMIT];diff --git a/crates/wake-core/src/db.rs b/crates/wake-core/src/db.rsindex 0708794..25a7fc6 100644--- a/crates/wake-core/src/db.rs+++ b/crates/wake-core/src/db.rs@@ -230,8 +230,11 @@ CREATE TABLE IF NOT EXISTS claimed_sessions (/// "14" = ZCode 的分叉折掉从父任务复制来的一段、辅助对话的固定标题退回首条提问,两者的/// token / 模型只算复制边界之后的,时间线分隔条不再计未知行,老行靠这轮重解析回填;/// "15" = 各家把 agent 派出去的子会话标出来(sessions.spawned,Insights 的提问数与会话数不算-/// 它),老行靠这轮重解析写对。-pub const FTS_FORMAT: &str = "15";+/// 它),老行靠这轮重解析写对;+/// "16" = 会话目录里的子代理转录(Claude Code 含 Workflow、Cursor CLI、CodeBuddy / WorkBuddy、+/// Qoder、Kimi)作为子会话入库、标 spawned,`<git-context>` 不进标题;旧版监听当顶层会话收进来+/// 的 Workflow 转录(sidechain 行被滤掉、零消息)文件没变、引用也没变,靠这轮重解析写对。+pub const FTS_FORMAT: &str = "16";/// FTS 压缩的节奏(见 `Store::compact_fts`):距上次压缩满一天、或从没压过才压。没有记录/// 就算到期——老库升级后、新建库首轮扫描收尾各压一次;`FTS_FORMAT` 换代时 open_conn 把@@ -1027,95 +1030,43 @@ impl Store {/// 用某家 adapter 的全量快照原子替换父子关系。只接受库内存在、同 agent、/// 非自指的父子键;陈旧关系会被清空。返回是否真的改变了任何行。pub fn replace_parent_links(&self, agent: AgentId, links: &[(String, String)]) -> Result<bool> {- // Claude 的分支关系每批 watcher 事件都会对账一遍,绝大多数时候什么都没变:在读连接- // 上比一眼即回,不开写事务(replace_claims 同款早退)- if self.parent_links_settled(agent, links)? {+ // 关系每批 watcher 事件都会对账一遍,绝大多数时候什么都没变:在读连接上比一眼即回,+ // 不开写事务(replace_claims 同款早退)。有要改的也只改那几行——Claude 的子代理一挂就是+ // 上千条关系,整组清掉重写一次要持写锁十几毫秒+ if parent_link_changes(&self.read.lock().unwrap(), agent, links)?.is_empty() {return Ok(false);}let mut conn = self.write.lock().unwrap();let tx = conn.transaction()?;- let before: Vec<(String, String)> = {- let mut stmt = tx.prepare_cached(- "SELECT key, parent_key FROM sessions- WHERE agent_id = ?1 AND parent_key != '' ORDER BY key",+ // 写事务里再算一遍:读连接那一眼之后可能有别的写入+ let changes = parent_link_changes(&tx, agent, links)?;+ let mut changed = false;+ {+ let mut clear =+ tx.prepare_cached("UPDATE sessions SET parent_key = '' WHERE key = ?1")?;+ // 项目在 parent_link_changes 里按这一轮的关系算好:逐行照父会话此刻的抄,结果就看+ // 先写父还是先写子+ let mut set = tx.prepare_cached(+ "UPDATE sessions AS child SET parent_key = ?1, project_path = ?2, project_name = ?3+ WHERE child.key = ?4 AND child.agent_id = ?5 AND child.key != ?1+ AND EXISTS (+ SELECT 1 FROM sessions parent+ WHERE parent.key = ?1 AND parent.agent_id = child.agent_id+ )",)?;- let rows = stmt.query_map(params![agent.as_str()], |row| {- Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))- })?;- rows.collect::<rusqlite::Result<_>>()?- };- tx.execute(- "UPDATE sessions SET parent_key = '' WHERE agent_id = ?1 AND parent_key != ''",- params![agent.as_str()],- )?;- let mut update = tx.prepare_cached(- "UPDATE sessions AS child SET- parent_key = ?1,- project_path = COALESCE((- SELECT NULLIF(parent.project_path, '') FROM sessions parent WHERE parent.key = ?1- ), child.project_path),- project_name = COALESCE((- SELECT NULLIF(parent.project_name, '') FROM sessions parent WHERE parent.key = ?1- ), child.project_name)- WHERE child.key = ?2 AND child.agent_id = ?3 AND child.key != ?1- AND EXISTS (- SELECT 1 FROM sessions parent- WHERE parent.key = ?1 AND parent.agent_id = child.agent_id- )",- )?;- let mut unique = std::collections::HashSet::new();- for (child, parent) in links {- if unique.insert(child.as_str()) {- update.execute(params![parent, child, agent.as_str()])?;+ // 只铺项目、父会话没换的不算关系变了(与整组重写时的口径一样,不惊动列表)+ for change in &changes {+ let written = match &change.parent {+ Some((parent, path, name)) => {+ set.execute(params![parent, path, name, change.child, agent.as_str()])?+ }+ None => clear.execute(params![change.child])?,+ };+ changed |= written > 0 && change.relinks;}}- drop(update);- let after: Vec<(String, String)> = {- let mut stmt = tx.prepare_cached(- "SELECT key, parent_key FROM sessions- WHERE agent_id = ?1 AND parent_key != '' ORDER BY key",- )?;- let rows = stmt.query_map(params![agent.as_str()], |row| {- Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))- })?;- rows.collect::<rusqlite::Result<_>>()?- };tx.commit()?;- Ok(before != after)- }-- /// `replace_parent_links` 写下去会不会什么都不变:每个子会话挂的父会话与写入路径算的- /// 一致(每个子会话取第一条边;父会话不在库里、或就是自己的不挂),而且挂着的子会话- /// 已经是父会话的项目(写入路径会把父会话的项目再铺一遍——子会话重解析后自己的项目- /// 会盖回来,这时必须写)- fn parent_links_settled(&self, agent: AgentId, links: &[(String, String)]) -> Result<bool> {- let conn = self.read.lock().unwrap();- let mut stmt = conn.prepare_cached(- "SELECT key, parent_key, project_path, project_name FROM sessions WHERE agent_id = ?1",- )?;- let rows: HashMap<String, (String, String, String)> = stmt- .query_map(params![agent.as_str()], |r| {- Ok((r.get(0)?, (r.get(1)?, r.get(2)?, r.get(3)?)))- })?- .collect::<rusqlite::Result<_>>()?;- let mut first: HashMap<&str, &str> = HashMap::new();- for (child, parent) in links {- first.entry(child.as_str()).or_insert(parent.as_str());- }- Ok(rows.iter().all(|(key, (parent_key, path, name))| {- let wanted = first- .get(key.as_str())- .filter(|parent| **parent != key.as_str())- .and_then(|parent| rows.get(*parent).map(|row| (*parent, row)));- match wanted {- None => parent_key.is_empty(),- Some((parent, (_, parent_path, parent_name))) => {- parent_key == parent- && (parent_path.is_empty() || path == parent_path)- && (parent_name.is_empty() || name == parent_name)- }- }- }))+ Ok(changed)}/// 把这些会话标成 agent 派出去的(sessions.spawned;`AgentAdapter::linked_children_are_spawned`@@ -1389,12 +1340,7 @@ impl Store {let conn = self.read.lock().unwrap();let sql = format!("SELECT {SESSION_COLS}, s.parent_key FROM sessions s LEFT JOIN user_data u ON u.session_key = s.key");let mut stmt = conn.prepare(&sql)?;- let rows = stmt.query_map([], |r| {- Ok(crate::cleanup::IndexedSession {- meta: row_to_meta(r)?,- parent: r.get(19)?,- })- })?;+ let rows = stmt.query_map([], row_to_indexed)?;Ok(rows.collect::<rusqlite::Result<_>>()?)}@@ -1879,8 +1825,8 @@ impl Store {// 根会话的"活动时间"是连子会话一起聚合的(排序、返回值都如此),since// 过滤必须用同一口径——只看父行会把"父旧子新"的整棵树滤掉let updated_col = match (f.roots_only, f.include_archived) {- (true, false) => ROOT_UPDATED_ACTIVE,- (true, true) => ROOT_UPDATED_ALL,+ (true, false) => TREE_UPDATED_ACTIVE,+ (true, true) => TREE_UPDATED_ALL,_ => "s.updated_at",};push_session_filters(f, updated_col, &mut wheres, &mut args);@@ -1897,10 +1843,10 @@ impl Store {format!("WHERE {}", wheres.join(" AND "))};let order_col = match (f.roots_only, f.sort, f.include_archived) {- (true, SortKey::Updated, false) => ROOT_UPDATED_ACTIVE,- (true, SortKey::Updated, true) => ROOT_UPDATED_ALL,- (true, SortKey::Messages, false) => ROOT_MESSAGES_ACTIVE,- (true, SortKey::Messages, true) => ROOT_MESSAGES_ALL,+ (true, SortKey::Updated, false) => TREE_UPDATED_ACTIVE,+ (true, SortKey::Updated, true) => TREE_UPDATED_ALL,+ (true, SortKey::Messages, false) => TREE_MESSAGES_ACTIVE,+ (true, SortKey::Messages, true) => TREE_MESSAGES_ALL,(_, SortKey::Updated, _) => "s.updated_at",(_, SortKey::Created, _) => "s.created_at",(_, SortKey::Messages, _) => "s.message_count",@@ -1946,8 +1892,8 @@ impl Store {Ok((out, total))}- /// 当前筛选下各根会话可见的直接子会话数。Grok 关系在入库时已扁平到- /// root,因此一次 GROUP BY 足够覆盖任意原始嵌套深度。+ /// 当前筛选下各会话可见的直接子会话数,一次 GROUP BY parent_key:关系入库时已压平(树最多+ /// 两层),分支下面的子代理算在分支名下pub fn child_counts(&self, f: &SessionFilter) -> Result<HashMap<String, i64>> {let (where_sql, args) = child_filter_sql(f, None);let conn = self.read.lock().unwrap();@@ -2006,7 +1952,8 @@ impl Store {}/// 删除确认使用:不受当前列表筛选和 archived 状态影响,递归取完整子树。- pub fn all_descendants(&self, key: &str) -> Result<Vec<SessionMeta>> {+ /// 一条会话下面的全部子孙,各带它的直接父会话(删除时按它判哪些挂在留下的分支下面)+ pub fn all_descendants(&self, key: &str) -> Result<Vec<crate::cleanup::IndexedSession>> {let conn = self.read.lock().unwrap();let sql = format!("WITH RECURSIVE descendants(key) AS (@@ -2015,17 +1962,33 @@ impl Store {SELECT child.key FROM sessions childJOIN descendants parent ON child.parent_key = parent.key)- SELECT {SESSION_COLS}+ SELECT {SESSION_COLS}, s.parent_keyFROM sessions sJOIN descendants d ON d.key = s.keyLEFT JOIN user_data u ON u.session_key = s.keyORDER BY s.created_at, s.key");let mut stmt = conn.prepare_cached(&sql)?;- let rows = stmt.query_map(params![key], row_to_meta)?;+ let rows = stmt.query_map(params![key], row_to_indexed)?;Ok(rows.collect::<rusqlite::Result<_>>()?)}+ /// 这些 key 里库里有的(详情页只给索引里真有的子会话画跳转按钮)+ pub fn indexed_keys<'a>(+ &self,+ keys: impl IntoIterator<Item = &'a str>,+ ) -> Result<std::collections::HashSet<String>> {+ let conn = self.read.lock().unwrap();+ let mut stmt = conn.prepare_cached("SELECT 1 FROM sessions WHERE key = ?1")?;+ let mut found = std::collections::HashSet::new();+ for key in keys {+ if stmt.exists(params![key])? {+ found.insert(key.to_string());+ }+ }+ Ok(found)+ }+pub fn get_session(&self, key: &str) -> Result<Option<SessionMeta>> {let conn = self.read.lock().unwrap();let sql = format!(@@ -2052,10 +2015,10 @@ impl Store {/// 归档会话,只剩归档会话的项目不能在解析这一步就被挡掉pub fn list_projects(&self, include_archived: bool) -> Result<Vec<ProjectInfo>> {let (root_updated, root_cond, archived) = if include_archived {- (ROOT_UPDATED_ALL, ROOT_IGNORING_ARCHIVED, "")+ (TREE_UPDATED_ALL, ROOT_IGNORING_ARCHIVED, "")} else {(- ROOT_UPDATED_ACTIVE,+ TREE_UPDATED_ACTIVE,ROOT_WHEN_HIDING_ARCHIVED,"s.archived = 0 AND ",)@@ -3016,36 +2979,59 @@ const ROOT_WHEN_HIDING_ARCHIVED: &str = "(s.parent_key = '' OR NOT EXISTS ())";const ROOT_IGNORING_ARCHIVED: &str ="(s.parent_key = '' OR NOT EXISTS (SELECT 1 FROM sessions p WHERE p.key = s.parent_key))";-const ROOT_UPDATED_ACTIVE: &str =- "MAX(s.updated_at, COALESCE((SELECT MAX(c.updated_at) FROM sessions c- WHERE c.parent_key = s.key AND c.archived = 0), 0))";-const ROOT_UPDATED_ALL: &str =- "MAX(s.updated_at, COALESCE((SELECT MAX(c.updated_at) FROM sessions c- WHERE c.parent_key = s.key), 0))";-const ROOT_MESSAGES_ACTIVE: &str =- "s.message_count + COALESCE((SELECT SUM(c.message_count) FROM sessions c- WHERE c.parent_key = s.key AND c.archived = 0), 0)";-const ROOT_MESSAGES_ALL: &str =- "s.message_count + COALESCE((SELECT SUM(c.message_count) FROM sessions c- WHERE c.parent_key = s.key), 0)";-const ROOT_SESSION_COLS_ACTIVE: &str =- "s.key, s.agent_id, s.native_id, s.title, s.project_path, s.project_name,- s.git_branch, s.created_at,- MAX(s.updated_at, COALESCE((SELECT MAX(c.updated_at) FROM sessions c- WHERE c.parent_key = s.key AND c.archived = 0), 0)),- s.message_count + COALESCE((SELECT SUM(c.message_count) FROM sessions c- WHERE c.parent_key = s.key AND c.archived = 0), 0),- s.tokens_used, s.model, s.source, s.archived, s.file_path, s.file_size,- COALESCE(u.favorite,0), COALESCE(u.pinned,0), s.host";-const ROOT_SESSION_COLS_ALL: &str =- "s.key, s.agent_id, s.native_id, s.title, s.project_path, s.project_name,- s.git_branch, s.created_at,- MAX(s.updated_at, COALESCE((SELECT MAX(c.updated_at) FROM sessions c- WHERE c.parent_key = s.key), 0)),- s.message_count + COALESCE((SELECT SUM(c.message_count) FROM sessions c- WHERE c.parent_key = s.key), 0),- s.tokens_used, s.model, s.source, s.archived, s.file_path, s.file_size,- COALESCE(u.favorite,0), COALESCE(u.pinned,0), s.host";+/// 会话 `s` 下面的子孙 `c`:子会话与孙会话——分支、分叉下面还挂着它们派的子代理,树最多两层+/// (scanner 的 `flattened_parent`)。`active` 不算归档的,也不算归档了的子会话下面的:隐藏归档+/// 时那些自成一棵(`ROOT_WHEN_HIDING_ARCHIVED`)+macro_rules! in_tree {+ (active) => {+ "c.archived = 0 AND (c.parent_key = s.key OR c.parent_key IN (+ SELECT m.key FROM sessions m WHERE m.parent_key = s.key AND m.archived = 0))"+ };+ (all) => {+ "(c.parent_key = s.key OR c.parent_key IN (+ SELECT m.key FROM sessions m WHERE m.parent_key = s.key))"+ };+}+/// 连子孙一起的活动时间:根会话排序、返回值与 since 过滤同一口径——只算一层的话,原件与分支+/// 都旧、只有分支派的子代理刚跑过的整棵树会被 since 滤掉(Codex review 2026-10-12)+macro_rules! tree_updated {+ ($tree:ident) => {+ concat!(+ "MAX(s.updated_at, COALESCE((SELECT MAX(c.updated_at) FROM sessions c WHERE ",+ in_tree!($tree),+ "), 0))"+ )+ };+}+macro_rules! tree_messages {+ ($tree:ident) => {+ concat!(+ "s.message_count + COALESCE((SELECT SUM(c.message_count) FROM sessions c WHERE ",+ in_tree!($tree),+ "), 0)"+ )+ };+}+/// `SESSION_COLS` 的根会话版:活动时间与消息数连子孙一起算+macro_rules! root_session_cols {+ ($tree:ident) => {+ concat!(+ "s.key, s.agent_id, s.native_id, s.title, s.project_path, s.project_name,+ s.git_branch, s.created_at, ",+ tree_updated!($tree),+ ", ",+ tree_messages!($tree),+ ", s.tokens_used, s.model, s.source, s.archived, s.file_path, s.file_size,+ COALESCE(u.favorite,0), COALESCE(u.pinned,0), s.host"+ )+ };+}+const TREE_UPDATED_ACTIVE: &str = tree_updated!(active);+const TREE_UPDATED_ALL: &str = tree_updated!(all);+const TREE_MESSAGES_ACTIVE: &str = tree_messages!(active);+const TREE_MESSAGES_ALL: &str = tree_messages!(all);+const ROOT_SESSION_COLS_ACTIVE: &str = root_session_cols!(active);+const ROOT_SESSION_COLS_ALL: &str = root_session_cols!(all);/// 主线上某个角色最近的单元里,第一个 `decode` 读得出话的(往回最多看 `limit` 条)。按 id/// 倒着走 idx_messages_session:同一会话的单元按 seq 顺序写入、追加只加在后面@@ -3083,7 +3069,13 @@ fn child_filter_sql(}None => wheres.push("s.parent_key != ''".to_string()),}- push_session_filters(filter, "s.updated_at", &mut wheres, &mut args);+ // 子会话下面也可能挂着子会话(分支派的子代理):since 与根会话同一口径,连它下面的一起算+ let updated_col = if filter.include_archived {+ TREE_UPDATED_ALL+ } else {+ TREE_UPDATED_ACTIVE+ };+ push_session_filters(filter, updated_col, &mut wheres, &mut args);(format!("WHERE {}", wheres.join(" AND ")), args)}@@ -3308,6 +3300,95 @@ fn upsert_memory(tx: &rusqlite::Transaction<'_>, d: &MemoryDoc) -> Result<()> {Ok(())}+/// `replace_parent_links` 要改的一行+struct LinkChange {+ child: String,+ /// Some = 挂上它、铺上这个项目(路径, 名字);None = 解挂+ parent: Option<(String, String, String)>,+ /// 父会话换了(解挂也算);只是重铺项目的为 false+ relinks: bool,+}++/// `replace_parent_links` 要改的行。每个子会话按它的第一条边;父会话不在库里、或就是自己的不挂;+/// 挂着的子会话还得已经是它该有的项目(挂上时把祖先的项目铺下来——子会话重解析后自己的项目会+/// 盖回来,那时要再铺一遍)。该有的项目按**这一轮的关系**一路往上找:从根往下第一个有项目的祖先+/// 的,都没有就是它自己的。只看父会话此刻的项目会漏掉孙会话——分支这一轮才挂到别的项目的原件下,+/// 它派的子代理还比着分支的旧项目,算成已经铺好(Codex review 2026-10-12)+fn parent_link_changes(+ conn: &Connection,+ agent: AgentId,+ links: &[(String, String)],+) -> Result<Vec<LinkChange>> {+ let mut stmt = conn.prepare_cached(+ "SELECT key, parent_key, project_path, project_name FROM sessions WHERE agent_id = ?1",+ )?;+ let rows: HashMap<String, (String, String, String)> = stmt+ .query_map(params![agent.as_str()], |r| {+ Ok((r.get(0)?, (r.get(1)?, r.get(2)?, r.get(3)?)))+ })?+ .collect::<rusqlite::Result<_>>()?;+ let mut first: HashMap<&str, &str> = HashMap::new();+ for (child, parent) in links {+ first.entry(child.as_str()).or_insert(parent.as_str());+ }+ let wanted = |key: &str| {+ first+ .get(key)+ .copied()+ .filter(|parent| *parent != key && rows.contains_key(*parent))+ };+ let mut changes = Vec::new();+ for (key, (parent_key, path, name)) in &rows {+ let Some(parent) = wanted(key) else {+ if !parent_key.is_empty() {+ changes.push(LinkChange {+ child: key.clone(),+ parent: None,+ relinks: true,+ });+ }+ continue;+ };+ let mut ancestors = vec![parent];+ while let Some(next) = wanted(ancestors[ancestors.len() - 1]) {+ if next == key.as_str() || ancestors.contains(&next) {+ break;+ }+ ancestors.push(next);+ }+ let inherited = |field: fn(&(String, String, String)) -> &String, own: &String| {+ ancestors+ .iter()+ .rev()+ .map(|ancestor| field(&rows[*ancestor]))+ .find(|value| !value.is_empty())+ .unwrap_or(own)+ .clone()+ };+ let project_path = inherited(|row| &row.1, path);+ let project_name = inherited(|row| &row.2, name);+ let relinks = parent_key != parent;+ if relinks || *path != project_path || *name != project_name {+ changes.push(LinkChange {+ child: key.clone(),+ parent: Some((parent.to_string(), project_path, project_name)),+ relinks,+ });+ }+ }+ // 先解挂再挂上,按 key 排:两次计算给出同一个次序+ changes.sort_by(|a, b| (a.parent.is_some(), &a.child).cmp(&(b.parent.is_some(), &b.child)));+ Ok(changes)+}++/// `SESSION_COLS` 后面再跟一列 parent_key 的行+fn row_to_indexed(r: &rusqlite::Row<'_>) -> rusqlite::Result<crate::cleanup::IndexedSession> {+ Ok(crate::cleanup::IndexedSession {+ meta: row_to_meta(r)?,+ parent: r.get(19)?,+ })+}+fn row_to_meta(r: &rusqlite::Row<'_>) -> rusqlite::Result<SessionMeta> {let agent_str: String = r.get(1)?;Ok(SessionMeta {diff --git a/crates/wake-core/src/mcp/tools.rs b/crates/wake-core/src/mcp/tools.rsindex fb9bd0c..2d2bb46 100644--- a/crates/wake-core/src/mcp/tools.rs+++ b/crates/wake-core/src/mcp/tools.rs@@ -226,7 +226,7 @@ pub fn definitions_for(usage: Usage) -> Vec<Value> {"max_message_chars": { "type": "integer", "minimum": 100, "maximum": 50000, "default": 4000, "description": "Longer messages are truncated to this many characters." },"include_tools": { "type": "boolean", "default": false, "description": "Include tool-call inputs and outputs (verbose)." },"include_thinking": { "type": "boolean", "default": false, "description": "Include the assistant's thinking/reasoning text where the agent recorded it." },- "subagent": { "type": "string", "description": "Read this subagent transcript instead of the session's main transcript. The main transcript lists the ids at its end; paging works the same way." },+ "subagent": { "type": "string", "description": "Read this subagent transcript (one kept in the session's folder) instead of the session's main transcript; `*` lists their ids. Paging works the same way. Each subagent is also a session of its own, listed by key at the end of the main transcript." },},"required": ["key"],},@@ -1365,9 +1365,7 @@ fn get_session(ctx: &ToolContext, args: &Value) -> ToolResult {.cloned().unwrap_or_else(|| SidechainInfo {id: id.to_string(),- agent_type: None,- description: None,- tool_use_id: None,+ ..SidechainInfo::default()});Some((info, messages))}@@ -1498,15 +1496,28 @@ fn get_session(ctx: &ToolContext, args: &Value) -> ToolResult {out.push_str(&summary);out.push_str(".\n");// 主线页脚两张清单:挂在这条会话下面的子会话(有自己的 key,按 key 读),- // 与侧边的子代理转录(不并进主线、各有自己的 seq,按 id 读)+ // 与侧边的子代理转录(不并进主线、各有自己的 seq,按 id 读)。已经作为子会话列出来的+ // 子代理(Claude Code、Cursor 的)不再列第二遍;`subagent` 参数照样认它们的 idchildren_footer(&mut out);if sub_id.is_none() {- if !transcript.sidechains.is_empty() {+ // 子会话与这条会话同一家、同一台机器:按原生 id 比+ let listed: HashSet<&str> = children.iter().map(|c| c.id.as_str()).collect();+ let unlisted: Vec<SidechainInfo> = transcript+ .sidechains+ .iter()+ .filter(|sc| {+ sc.session_id+ .as_deref()+ .is_none_or(|id| !listed.contains(id))+ })+ .cloned()+ .collect();+ if !unlisted.is_empty() {out.push_str(&format!("{} subagent transcript{} (pass an id as `subagent` to read one):\n{}",- transcript.sidechains.len(),- plural(transcript.sidechains.len() as i64),- subagent_lines(&transcript.sidechains, Some(MAX_SUBAGENTS_LISTED))+ unlisted.len(),+ plural(unlisted.len() as i64),+ subagent_lines(&unlisted, Some(MAX_SUBAGENTS_LISTED))));}}diff --git a/crates/wake-core/src/models.rs b/crates/wake-core/src/models.rsindex 772e74b..9b48e65 100644--- a/crates/wake-core/src/models.rs+++ b/crates/wake-core/src/models.rs@@ -301,7 +301,10 @@ pub struct ToolCallView {pub input: Option<String>,pub output: Option<String>,pub is_error: bool,- pub sidechain_ref: Option<String>,+ /// 这次调用派出去的子会话的原生 id(Claude 的 Task / Agent、OpenCode 的 task…):子会话与这份+ /// 转录同一家、同一台机器,key 由用的地方按这份转录的 agent 与 host 拼。详情页的"打开子代理+ /// 会话"按它跳。对不上的家给 None+ pub child_id: Option<String>,}#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]@@ -369,12 +372,14 @@ pub struct TranscriptMessage {pub images: Vec<ImageAttachment>,}-#[derive(Debug, Clone, Serialize, Deserialize)]+#[derive(Debug, Clone, Default, Serialize, Deserialize)]pub struct SidechainInfo {pub id: String,pub agent_type: Option<String>,pub description: Option<String>,pub tool_use_id: Option<String>,+ /// 这份转录同时作为子会话入库时,那条子会话的原生 id(MCP 的页脚列子会话时就不再重复列它)+ pub session_id: Option<String>,}impl SidechainInfo {diff --git a/crates/wake-core/src/scanner.rs b/crates/wake-core/src/scanner.rsindex 24b4d19..b194c56 100644--- a/crates/wake-core/src/scanner.rs+++ b/crates/wake-core/src/scanner.rs@@ -821,6 +821,11 @@ fn sync_memories(adapters: &[Box<dyn AgentAdapter>], store: &Arc<Store>) -> boolchanged}+/// 这个实例管不管父子关系:报 `parent_links` 的,与父会话写在路径里的(`parent_in_path`)+fn manages_links(adapter: &dyn AgentAdapter) -> bool {+ adapter.manages_parent_links() || adapter.parent_in_path().is_some()+}+/// 多 location 下关系元数据跟着 parent 会话,而 child 的胜出文件可能在另一根。/// 因此先接受“关系目标 parent 的胜出文件也属于该快照”的直接边,再跨快照把/// 嵌套链扁平到 root。解除/换父前重解析 child,恢复被旧父项目覆盖的自身归属。@@ -836,7 +841,8 @@ fn sync_parent_links(let mut links_by_adapter: Vec<std::collections::HashMap<String, String>> =Vec::with_capacity(adapters.len());for adapter in adapters {- if adapter.manages_parent_links() && only.is_none_or(|only| only.contains(&adapter.agent()))+ if manages_links(adapter.as_ref())+ && only.is_none_or(|only| only.contains(&adapter.agent())){managed_agents.insert(adapter.agent());match adapter.parent_links() {@@ -862,16 +868,19 @@ fn sync_parent_links(if unknown_agents.contains(&agent) {continue;}- // 这一家眼下一条关系都没有、库里也没有:整段对账是纯浪费——- // session_sources_for_agent 要把这家全部会话读一遍,replace_parent_links- // 还要开写事务与扫描线程抢锁。全量扫描对每家管关系的都走一遍,而多数- // agent 常年零关系(Codex 是 spawn_agent 用过才有)+ // 这一家眼下一条关系都没有、库里也没有:对账是纯浪费——要把这家的会话读一遍,+ // replace_parent_links 还要与扫描线程抢锁。全量扫描对每家管关系的都走一遍,而多数+ // agent 常年零关系(Codex 是 spawn_agent 用过才有)。父会话写在路径里的家得先看过+ // 会话才知道有没有let current = store.parent_links_for_agent(agent)?;- let has_links = links_by_adapter+ let reported = links_by_adapter.iter().enumerate().any(|(ix, links)| adapters[ix].agent() == agent && !links.is_empty());- if !has_links && current.is_empty() {+ let in_paths = adapters+ .iter()+ .any(|a| a.agent() == agent && a.parent_in_path().is_some());+ if !reported && !in_paths && current.is_empty() {continue;}@@ -884,6 +893,21 @@ fn sync_parent_links(owner_by_key.insert(key.clone(), adapter_ix);}}+ // 父会话写在路径里的(子代理转录):按每条会话的胜出文件推、按那个实例的 host 拼 key,+ // 天然是现行的关系+ let from_paths: Vec<(String, String)> = source_by_key+ .iter()+ .filter_map(|(child, path)| {+ let adapter = &adapters[owner_by_key[child]];+ let parent = adapter.parent_in_path()?(Path::new(path))?;+ Some((child.clone(), session_key(agent, adapter.host(), &parent)))+ })+ .collect();+ if !reported && from_paths.is_empty() && current.is_empty() {+ continue;+ }+ let pinned: std::collections::HashSet<String> =+ from_paths.iter().map(|(child, _)| child.clone()).collect();// meta.json 位于 parent 的 location。只采纳由当前胜出 parent 所属快照// 提供的边,避免另一份陈旧备份把已解除的关系重新挂回去。关系写在 child@@ -904,6 +928,7 @@ fn sync_parent_links(}}}+ direct.extend(from_paths);// 上面那条"报边的实例必须拥有 parent"是照 Grok 写的:它的边车长在// parent 自己的 location 里,报边者天然就是拥有者。Codex 的// thread_spawn_edges 是 home 的一张总表,parent 的胜出文件完全可能@@ -927,10 +952,11 @@ fn sync_parent_links(}}- // 各 location 只能看见自己的直接/局部链;合并后再走到全局 root。+ // 各 location 只能看见自己的直接/局部链;合并后再走到全局 root。转录放在父会话+ // 目录里的子代理停在那个会话上(见 flattened_parent)let mut desired_map = std::collections::HashMap::new();for child in direct.keys() {- if let Some(parent) = flattened_parent(child, &direct) {+ if let Some(parent) = flattened_parent(child, &direct, |key| pinned.contains(key)) {desired_map.insert(child.clone(), parent);}}@@ -1068,7 +1094,7 @@ pub fn refresh_parent_links() {let mut refreshable = false;for adapter in adapters {- if affected_agents.contains(&adapter.agent()) && adapter.manages_parent_links() {+ if affected_agents.contains(&adapter.agent()) && manages_links(adapter.as_ref()) {adapter.begin_scan();refreshable = true;}@@ -1084,9 +1110,15 @@ pub fn refresh_parent_links(}}+/// 沿直接关系往上走到根。`pinned` 的会话(父会话写在路径里的子代理,`parent_in_path`)+/// 停在直接父会话上、不再往上走:它的转录在那个会话的目录里,删那个会话时连目录一起进+/// 废纸篓,树得与目录一致——压到更上一层,删分支 / 分叉时它的墓碑就漏了,另一个 location+/// 里的副本会再冒出来(Codex review 2026-10-12)。这种子代理的目录里不再套会话,也没有哪家+/// 从子代理分叉,所以树最多两层:根 → 分支或分叉 → 它派的子代理(db 的 ROOT_* 汇总按两层算)fn flattened_parent(child: &str,direct: &std::collections::HashMap<String, String>,+ pinned: impl Fn(&str) -> bool,) -> Option<String> {let mut current = child;let mut seen = std::collections::HashSet::from([child]);@@ -1095,11 +1127,10 @@ fn flattened_parent(if !seen.insert(parent.as_str()) {return None;}- if direct.contains_key(parent) {- current = parent;- } else {+ if pinned(current) || !direct.contains_key(parent) {return Some(parent.clone());}+ current = parent;}}@@ -1248,10 +1279,9 @@ pub fn scan_files(}}}- if adapters- .iter()- .any(|adapter| affected_agents.contains(&adapter.agent()) && adapter.manages_parent_links())- {+ if adapters.iter().any(|adapter| {+ affected_agents.contains(&adapter.agent()) && manages_links(adapter.as_ref())+ }) {changed |=sync_parent_links(adapters, store, Some(&affected_agents)).unwrap_or_else(|error| {eprintln!("[scanner] parent-link refresh failed: {error}");diff --git a/crates/wake-core/src/services/exporter.rs b/crates/wake-core/src/services/exporter.rsindex 11212d2..17bceea 100644--- a/crates/wake-core/src/services/exporter.rs+++ b/crates/wake-core/src/services/exporter.rs@@ -452,7 +452,7 @@ mod compact_tests {input: Some("{\"path\":\"src/db.rs\"}".into()),output: Some("ok, 3 lines changed".into()),is_error: false,- sidechain_ref: None,+ child_id: None,});tool.thinking = Some("私下想一想".into());vec![@@ -574,7 +574,7 @@ mod compact_tests {input: Some(format!("cargo test --test case_{i:03}")),output: Some("ok. 12 passed; 0 failed\n".repeat(40)),is_error: false,- sidechain_ref: None,+ child_id: None,});}let o = CompactOptions {diff --git a/crates/wake-core/src/watcher.rs b/crates/wake-core/src/watcher.rsindex 560bbf3..9ece98f 100644--- a/crates/wake-core/src/watcher.rs+++ b/crates/wake-core/src/watcher.rs@@ -55,13 +55,28 @@ pub fn resolve_watch_agent<T: Copy>(roots: &[(PathBuf, T)], path: &Path) -> Opti/// 引用,交常规增量收编(该 key 已无既有行,scan_files 的副本裁决自然放行)。/// 期望 key 经 session_key 按实例 host 构造——远程三段 key 也走名字快路径。/// codex 经 state DB 改写过的 key(thread-id ≠ 文件 native_id)反查不到,由-/// 下一次全量扫描兜底;删除事件罕见,逐家枚举(纯 stat)代价可忽略+/// 下一次全量扫描兜底。每个实例只枚举一次(纯 stat):删掉一个会话目录时,它派出去的子代理+/// 各是一个被删的 key,逐个重列整家会把同一份清单列上百遍pub fn promote_survivors(adapters: &[Box<dyn AgentAdapter>],store: &Arc<Store>,events: &dyn ScanEvents,removed_keys: &[String],) {+ let agents: std::collections::HashSet<AgentId> = removed_keys+ .iter()+ .filter_map(|key| key.split(':').next().and_then(AgentId::from_str))+ .collect();+ let listings: Vec<Vec<SessionFileRef>> = adapters+ .iter()+ .map(|a| {+ if agents.contains(&a.agent()) {+ a.list_session_files().unwrap_or_default()+ } else {+ Vec::new()+ }+ })+ .collect();let mut seen = std::collections::HashSet::new();let mut survivors: Vec<SessionFileRef> = Vec::new();for key in removed_keys {@@ -71,36 +86,37 @@ pub fn promote_survivors(let Some(agent) = key.split(':').next().and_then(AgentId::from_str) else {continue;};- let mut agent_refs: Vec<SessionFileRef> = Vec::new();- let mut by_name: Vec<SessionFileRef> = Vec::new();- for a in adapters.iter().filter(|a| a.agent() == agent) {- // host 段对不上的实例整个跳过(本地实例对远程 key、A 机对 B 机):- // 名字与解析比对都不可能命中——实例出口的 key 恒带自己的 host- let Some(native_id) = strip_key_prefix(key, agent, a.host()) else {- continue;- };- if let Ok(refs) = a.list_session_files() {- by_name.extend(refs.iter().filter(|r| r.native_id == native_id).cloned());- agent_refs.extend(refs);- }- }+ // host 段对不上的实例整个跳过(本地实例对远程 key、A 机对 B 机):+ // 名字与解析比对都不可能命中——实例出口的 key 恒带自己的 host+ let candidates: Vec<(&str, &[SessionFileRef])> = adapters+ .iter()+ .zip(&listings)+ .filter(|(a, _)| a.agent() == agent)+ .filter_map(|(a, refs)| Some((strip_key_prefix(key, agent, a.host())?, &refs[..])))+ .collect();+ let by_name: Vec<SessionFileRef> = candidates+ .iter()+ .flat_map(|(native_id, refs)| refs.iter().filter(move |r| r.native_id == *native_id))+ .cloned()+ .collect();if !by_name.is_empty() {survivors.extend(by_name);continue;}// key 后缀是**内容 id** 的家(gemini 的 sessionId、pi/dsh 的首行 id)// 文件名对不上——退而解析比对,规模封顶防重罚(超限交下次全量扫描)- if agent_refs.len() <= 32 {+ let agent_refs = candidates.iter().flat_map(|(_, refs)| refs.iter());+ if agent_refs.clone().count() <= 32 {for r in agent_refs {let Some(owner) = crate::adapters::adapter_for(adapters, r.agent, &r.file_path)else {continue;};if owner- .parse_session(&r)+ .parse_session(r).is_ok_and(|p| p.meta.key.as_str() == key.as_str()){- survivors.push(r);+ survivors.push(r.clone());break;}}@@ -521,6 +537,60 @@ mod tests {assert_eq!(parent_of_b(), Some(key_a));}+ /// Kimi 在自己那边归档会话只写 state.json:子代理跟着归档。它们的转录没动、没有事件——+ /// state.json 的事件经 `ref_dependents` 把它们补进同一批,不用等下一次全量扫描+ #[test]+ fn kimi_subagents_follow_their_session_into_the_archive() {+ use crate::adapters::kimi::KimiAdapter;+ let tmp = tempfile::tempdir().unwrap();+ let home = tmp.path().join("kimi");+ let session = home.join("sessions").join("wd_x_1").join("session_w1");+ let agents = session.join("agents");+ let prompt = |text: &str, origin: serde_json::Value| {+ serde_json::json!({ "type": "turn.prompt", "time": 1791417601000i64,+ "input": [{ "type": "text", "text": text }], "origin": origin })+ .to_string()+ + "\n"+ };+ for (agent, line) in [+ (+ "main",+ prompt("Review the parser", serde_json::json!({ "kind": "user" })),+ ),+ (+ "agent-1",+ prompt(+ "Look at src/parser.rs",+ serde_json::json!({ "kind": "system_trigger", "name": "subagent" }),+ ),+ ),+ ] {+ std::fs::create_dir_all(agents.join(agent)).unwrap();+ std::fs::write(agents.join(agent).join("wire.jsonl"), line).unwrap();+ }+ let state = session.join("state.json");+ std::fs::write(&state, r#"{"title":"Review the parser"}"#).unwrap();++ let store = Arc::new(Store::open(&tmp.path().join("wake.db")).unwrap());+ let adapters: Vec<Box<dyn AgentAdapter>> = vec![KimiAdapter::new().with_custom_root(home)];+ let roots: Vec<(PathBuf, usize)> = adapters[0]+ .watch_paths()+ .into_iter()+ .map(|path| (path, 0))+ .collect();+ crate::scanner::run_scan(&adapters, &store, &NullEvents, true).unwrap();+ let archived = |key: &str| store.get_session(key).unwrap().unwrap().archived;+ assert!(!archived("kimi:session_w1/agent-1"));++ std::fs::write(&state, r#"{"title":"Review the parser","archived":true}"#).unwrap();+ let batch = vec![Ok(+ notify::Event::new(EventKind::Modify(ModifyKind::Any)).add_path(state.clone())+ )];+ process_batch(&adapters, &store, &NullEvents, &roots, batch);+ assert!(archived("kimi:session_w1"));+ assert!(archived("kimi:session_w1/agent-1"), "子代理没跟着会话归档");+ }+#[test]fn dropping_watcher_joins_worker_and_releases_its_state() {let fx = Fixture::new();diff --git a/crates/wake-core/tests/adapter_contracts.rs b/crates/wake-core/tests/adapter_contracts.rsindex 5262316..0ba18e6 100644--- a/crates/wake-core/tests/adapter_contracts.rs+++ b/crates/wake-core/tests/adapter_contracts.rs@@ -173,6 +173,32 @@ fn sorted_links(adapter: &dyn AgentAdapter) -> Vec<(String, String)> {links}+/// 列出来的会话里父会话写在路径里的(`parent_in_path`):(子会话 key, 父会话 key),按 key 排序+fn path_links(adapter: &dyn AgentAdapter) -> Vec<(String, String)> {+ let Some(parent_in_path) = adapter.parent_in_path() else {+ return Vec::new();+ };+ let mut links: Vec<(String, String)> = adapter+ .list_session_files()+ .unwrap()+ .iter()+ .filter_map(|r| {+ let parent = parent_in_path(Path::new(&r.file_path))?;+ Some((+ session_key(r.agent, "", &r.native_id),+ session_key(r.agent, "", &parent),+ ))+ })+ .collect();+ links.sort();+ links+}++/// 这条会话在 `adapter` 里能不能单独恢复(`adapters::resumable`)+fn resumable(adapter: &Box<dyn AgentAdapter>, meta: &SessionMeta) -> bool {+ wake_core::adapters::resumable(std::slice::from_ref(adapter), meta)+}+/// 列出来的会话里哪些标成了 agent 派出去的(`SessionMeta.spawned`),按 id 排序fn spawned_ids(adapter: &dyn AgentAdapter) -> Vec<String> {let mut refs = adapter.list_session_files().unwrap();@@ -540,6 +566,343 @@ fn claude_parse_contract() {assert_eq!(s2.meta.message_count, 1);}+/// Claude Code 的子代理转录作为子会话:Task / Agent 派的与 Workflow 跑出来的都列出、挂到派它+/// 的会话下,标题取边车里的任务说明(没有就是派活那句话),算 agent 派出去的;Workflow 的运行+/// 日志 journal.jsonl 不是转录。边车的事件换成它的转录;派活的工具调用指向那条子会话;子代理+/// 不随原件留下(分支才留下),删除带走转录与边车。在私有临时目录里搭(共用的假 HOME 只读)+#[test]+fn claude_subagents_become_child_sessions() {+ let tmp = tempfile::tempdir().unwrap();+ let projects = tmp.path().join("projects");+ let dir = projects.join("-Users-tester-Github-subfx");+ let parent = "5ab0a6e0-0000-4000-8000-000000000001";+ let (task, step) = common::stage_claude_subagents(&dir, parent, "p", "toolu_task_1");+ let parent_path = dir.join(format!("{parent}.jsonl"));+ let line = |value: serde_json::Value| format!("{value}\n");+ fs::write(+ &parent_path,+ [+ line(serde_json::json!({+ "parentUuid": null, "isSidechain": false, "cwd": "/Users/tester/Github/subfx",+ "sessionId": parent, "type": "user", "uuid": "p-u1",+ "timestamp": "2026-10-01T10:00:00.000Z",+ "message": { "role": "user", "content": "Review the parser" },+ })),+ line(serde_json::json!({+ "parentUuid": "p-u1", "isSidechain": false, "cwd": "/Users/tester/Github/subfx",+ "sessionId": parent, "type": "assistant", "uuid": "p-a1",+ "timestamp": "2026-10-01T10:00:05.000Z",+ "message": { "id": "msg_p_1", "role": "assistant", "model": "claude-opus-5-5",+ "content": [{ "type": "tool_use", "id": "toolu_task_1", "name": "Agent",+ "input": { "description": "Check the parser", "prompt": "Look at src/parser.rs" } }] },+ })),+ line(serde_json::json!({+ "parentUuid": "p-a1", "isSidechain": false, "cwd": "/Users/tester/Github/subfx",+ "sessionId": parent, "type": "user", "uuid": "p-u2",+ "timestamp": "2026-10-01T10:00:30.000Z",+ "message": { "role": "user", "content": [{ "type": "tool_result",+ "tool_use_id": "toolu_task_1", "content": "The parser handles every case." }] },+ })),+ ]+ .concat(),+ )+ .unwrap();+ let adapter = ClaudeAdapter::new().with_custom_root(projects.clone());++ let listed = adapter.list_session_files().unwrap();+ let mut ids: Vec<&str> = listed.iter().map(|r| r.native_id.as_str()).collect();+ ids.sort();+ assert_eq!(+ ids,+ [parent, step.as_str(), task.as_str()],+ "journal.jsonl 不是转录"+ );++ let subagents = dir.join(parent).join("subagents");+ let transcript = subagents.join(format!("{task}.jsonl"));+ let sidecar = subagents.join(format!("{task}.meta.json"));+ let by_sidecar = adapter.file_ref(&sidecar).expect("边车换成转录的引用");+ let listed_task = listed.iter().find(|r| r.native_id == task).unwrap();+ assert_eq!(by_sidecar.file_path, transcript.to_string_lossy());+ assert_eq!(+ (by_sidecar.mtime_ms, by_sidecar.size),+ (listed_task.mtime_ms, listed_task.size),+ "边车并进引用,watcher 与列表一致"+ );+ let run = subagents.join("workflows").join("wf_p-run");+ assert!(adapter.file_ref(&run.join("journal.jsonl")).is_none());++ let child = adapter.parse_session(&by_sidecar).unwrap();+ assert_eq!(child.meta.key, format!("claude-code:{task}"));+ assert_eq!(child.meta.title, "Check the parser");+ assert!(child.meta.spawned, "子代理是 agent 派出去的");+ assert_eq!(child.meta.message_count, 2);+ assert_eq!(child.meta.tokens_used, Some(15));+ assert_seq_contract(adapter.as_ref(), &by_sidecar);+ let workflow = listed.iter().find(|r| r.native_id == step).unwrap();+ let step_meta = adapter.parse_session(workflow).unwrap().meta;+ assert_eq!(+ step_meta.title, "Workflow step: run the tests",+ "没有任务说明就取派活那句话"+ );+ assert!(step_meta.spawned);++ let parent_key = format!("claude-code:{parent}");+ assert_eq!(+ path_links(adapter.as_ref()),+ vec![+ edge(&format!("claude-code:{step}"), &parent_key),+ edge(&format!("claude-code:{task}"), &parent_key),+ ]+ );+ assert!(+ sorted_links(adapter.as_ref()).is_empty(),+ "子代理的关系按路径推,不另外枚举"+ );++ // 父会话:自己的消息里没有子代理的行;派活的调用指向子会话+ let parent_ref = listed.iter().find(|r| r.native_id == parent).unwrap();+ assert!(!adapter.parse_session(parent_ref).unwrap().meta.spawned);+ let t = adapter.parse_transcript(parent_ref).unwrap();+ let call = t+ .mainline+ .iter()+ .flat_map(|m| &m.tool_calls)+ .find(|c| c.id == "toolu_task_1")+ .expect("派活的调用");+ assert_eq!(call.child_id.as_deref(), Some(task.as_str()));++ // 子代理不能单独恢复(`claude --resume agent-…` 打不开),它的父会话照常+ assert!(!resumable(&adapter, &child.meta));+ assert!(resumable(+ &adapter,+ &adapter.parse_session(parent_ref).unwrap().meta+ ));++ // 删除:子代理随父会话走(分支才留下),自己删时带走转录与边车+ assert!(adapter.child_outlives_parent(&parent_ref.file_path));+ assert!(!adapter.child_outlives_parent(&by_sidecar.file_path));+ assert_eq!(+ adapter.session_paths(&child.meta),+ [+ transcript.to_string_lossy().to_string(),+ sidecar.to_string_lossy().to_string()+ ]+ );+}++/// Cursor 的子代理(Task 派出去的,转录在父会话目录的 subagents/ 里)作为子会话入库:按路径挂到+/// 父会话下、标成派出去的;父会话里派活的调用指向它——头一回派的按子代理收到的第一句对上,+/// 接着派的按 `resume` 点名。对不上派活调用的照样列出、挂在父会话下。在私有临时目录里搭+#[test]+fn cursor_subagents_become_child_sessions() {+ let tmp = tempfile::tempdir().unwrap();+ let projects = tmp.path().join("projects");+ let parent = "c0a6e0aa-0000-4000-8000-000000000001";+ let (sub, orphan) = (+ "c0a6e0aa-0000-4000-8000-0000000000a1",+ "c0a6e0aa-0000-4000-8000-0000000000a2",+ );+ let session = projects+ .join("-Users-tester-Github-cursub")+ .join("agent-transcripts")+ .join(parent);+ let subagents = session.join("subagents");+ fs::create_dir_all(&subagents).unwrap();+ let lines = |rows: &[serde_json::Value]| -> String {+ rows.iter().map(|row| format!("{row}\n")).collect()+ };+ let user = |text: &str| {+ serde_json::json!({ "role": "user", "message": { "content": [+ { "type": "text", "text": format!("<user_query>\n{text}\n</user_query>") }] } })+ };+ let reply = |content: serde_json::Value| serde_json::json!({ "role": "assistant", "message": { "content": content } });+ let parent_path = session.join(format!("{parent}.jsonl"));+ fs::write(+ &parent_path,+ lines(&[+ user("Review the parser"),+ reply(serde_json::json!([+ { "type": "text", "text": "Sending a reviewer." },+ { "type": "tool_use", "name": "Task", "input": {+ "description": "Check the parser", "subagent_type": "explore",+ "prompt": "Look at src/parser.rs and report problems" } }+ ])),+ serde_json::json!({ "type": "turn_ended" }),+ user("Ask it again"),+ reply(serde_json::json!([+ { "type": "tool_use", "name": "Task", "input": {+ "description": "Check the parser", "prompt": "Repeat the findings",+ "resume": sub } }+ ])),+ ]),+ )+ .unwrap();+ let sub_path = subagents.join(format!("{sub}.jsonl"));+ fs::write(+ &sub_path,+ lines(&[+ user("Look at src/parser.rs and report problems"),+ reply(serde_json::json!([{ "type": "text", "text": "Two problems found." }])),+ user("Repeat the findings"),+ reply(serde_json::json!([{ "type": "text", "text": "Same two problems." }])),+ ]),+ )+ .unwrap();+ // 派它的调用没留在主线里;第一句恰好与接着派的那句相同——点了 resume 的调用只认它点名的+ fs::write(+ subagents.join(format!("{orphan}.jsonl")),+ lines(&[+ user("Repeat the findings"),+ reply(serde_json::json!([{ "type": "text", "text": "Done." }])),+ ]),+ )+ .unwrap();+ let adapter = CursorAdapter::new().with_custom_root(projects.clone());++ let listed = adapter.list_session_files().unwrap();+ let mut ids: Vec<&str> = listed.iter().map(|r| r.native_id.as_str()).collect();+ ids.sort();+ assert_eq!(ids, [parent, sub, orphan]);+ let sub_ref = adapter.file_ref(&sub_path).expect("监听认子代理的转录");+ assert_eq!(sub_ref.native_id, sub);++ let child = adapter.parse_session(&sub_ref).unwrap().meta;+ let parent_ref = listed.iter().find(|r| r.native_id == parent).unwrap();+ let parent_meta = adapter.parse_session(parent_ref).unwrap().meta;+ assert_eq!(child.key, format!("cursor:{sub}"));+ assert!(child.spawned && !parent_meta.spawned);+ assert_eq!(+ child.title, "Look at src/parser.rs and report problems",+ "没有 IDE 库就取派活那句话"+ );+ assert_eq!(child.message_count, 4);+ assert_eq!(+ child.project_path, parent_meta.project_path,+ "项目按子代理所在的 slug 目录还原"+ );+ assert_seq_contract(adapter.as_ref(), &sub_ref);++ let parent_key = format!("cursor:{parent}");+ assert_eq!(+ path_links(adapter.as_ref()),+ vec![+ edge(&format!("cursor:{sub}"), &parent_key),+ edge(&format!("cursor:{orphan}"), &parent_key),+ ]+ );++ let t = adapter.parse_transcript(parent_ref).unwrap();+ let opened: Vec<Option<String>> = t+ .mainline+ .iter()+ .flat_map(|m| &m.tool_calls)+ .map(|c| c.child_id.clone())+ .collect();+ assert_eq!(+ opened,+ [Some(sub.to_string()), Some(sub.to_string())],+ "头一回派的按第一句对上,接着派的按 resume"+ );+ let mut sidechains = t.sidechains.clone();+ sidechains.sort_by(|a, b| a.id.cmp(&b.id));+ let described: Vec<(&str, Option<&str>, Option<&str>, Option<String>)> = sidechains+ .iter()+ .map(|s| {+ (+ s.id.as_str(),+ s.description.as_deref(),+ s.agent_type.as_deref(),+ s.session_id.clone(),+ )+ })+ .collect();+ assert_eq!(+ described,+ [+ (+ sub,+ Some("Check the parser"),+ Some("explore"),+ Some(sub.to_string())+ ),+ (orphan, None, None, Some(orphan.to_string())),+ ]+ );+ assert!(adapter+ .parse_transcript(&sub_ref)+ .unwrap()+ .sidechains+ .is_empty());++ // 删除:子代理只带走自己那份转录,父会话整个目录(含 subagents/)+ assert_eq!(+ adapter.session_paths(&child),+ [sub_path.to_string_lossy().to_string()]+ );+ assert_eq!(+ adapter.session_paths(&parent_meta),+ [session.to_string_lossy().to_string()]+ );+ assert!(!adapter.child_outlives_parent(&sub_ref.file_path));+ assert!(!resumable(&adapter, &child), "子代理不能单独恢复");+}++/// 同一句话头一回派了两次(两个子代理收到的第一句一样):分不清哪个调用派的是哪个,两个都不挂+/// 跳转——挂了就是两个按钮都指向枚举到的最后一个+#[test]+fn cursor_identical_dispatches_open_nothing() {+ let tmp = tempfile::tempdir().unwrap();+ let projects = tmp.path().join("projects");+ let parent = "c0a6e0aa-0000-4000-8000-000000000002";+ let session = projects+ .join("-Users-tester-Github-cursub")+ .join("agent-transcripts")+ .join(parent);+ let subagents = session.join("subagents");+ fs::create_dir_all(&subagents).unwrap();+ let line = |row: serde_json::Value| format!("{row}\n");+ let user = |text: &str| {+ line(+ serde_json::json!({ "role": "user", "message": { "content": [+ { "type": "text", "text": format!("<user_query>\n{text}\n</user_query>") }] } }),+ )+ };+ let task = serde_json::json!({ "type": "tool_use", "name": "Task", "input": {+ "description": "Run the suite", "prompt": "Run the tests" } });+ fs::write(+ session.join(format!("{parent}.jsonl")),+ user("Run the tests twice")+ + &line(serde_json::json!({ "role": "assistant", "message": { "content": [task.clone(), task] } })),+ )+ .unwrap();+ for sub in [+ "c0a6e0aa-0000-4000-8000-0000000000b1",+ "c0a6e0aa-0000-4000-8000-0000000000b2",+ ] {+ fs::write(+ subagents.join(format!("{sub}.jsonl")),+ user("Run the tests"),+ )+ .unwrap();+ }+ let adapter = CursorAdapter::new().with_custom_root(projects);+ let parent_ref = adapter+ .list_session_files()+ .unwrap()+ .into_iter()+ .find(|r| r.native_id == parent)+ .unwrap();+ let t = adapter.parse_transcript(&parent_ref).unwrap();+ let opened: Vec<Option<String>> = t+ .mainline+ .iter()+ .flat_map(|m| &m.tool_calls)+ .map(|c| c.child_id.clone())+ .collect();+ assert_eq!(opened, [None, None]);+}+/// Claude Code 的分支会话(开头原样复制了原对话的一段):复制来的一段折成一条 Meta、分支/// 挂到原件下;标题、token、创建时间只算分支自己的行;自定义标题照抄原件的不当标题用。/// 列表与 file_ref 的引用都把"更早的同根文件有几份"计进 size,原件没了引用随之变化、@@ -867,6 +1230,17 @@ fn codex_spawned_subagent_keeps_only_its_own_turns() {adapter.parent_links().unwrap(),vec![(format!("codex:{child_id}"), format!("codex:{parent_id}"))]);++ // 父线程里的 spawn_agent 调用指向它起的子线程(输出的 agent_path 对 state DB)+ let calls: Vec<(String, Option<String>)> = adapter+ .parse_transcript(parent)+ .unwrap()+ .mainline+ .iter()+ .flat_map(|m| &m.tool_calls)+ .map(|c| (c.name.clone(), c.child_id.clone()))+ .collect();+ assert_eq!(calls, [("spawn_agent".to_string(), Some(child_id.clone()))]);}/// 首行没写 `subagent_history_start_ordinal`(老写端)时退回派活信封,并且@@ -1161,16 +1535,32 @@ fn qoder_parse_contract() {vec![1, 2, 3, 4]);- // 默认 projects 根只枚举 project-key 直属会话,不能吸入会话边车。+ // projects 根枚举 project-key 直属会话,与会话同名目录里派出去的子代理(整份都是+ // sidechain 行,作为子会话按路径挂到父会话下)let rooted = QoderAdapter::new().with_custom_root(fixture("qoder/projects"));let refs = rooted.list_session_files().expect("qoder list sessions");- assert_eq!(refs.len(), 2);+ assert_eq!(refs.len(), 3);assert!(refs.iter().any(|session| session.native_id == r.native_id));assert_eq!(rooted.session_paths(&s.meta).len(), 2);- let sideagent = fixture(+ let subagent = fixture("qoder/projects/-Users-tester-Github-wakefx/abababab-aaaa-bbbb-cccc-000000000014/subagents/agent-child.jsonl",);- assert!(rooted.file_ref(&sideagent).is_none());+ let sub_ref = rooted.file_ref(&subagent).expect("子代理转录作为子会话");+ let child = rooted.parse_session(&sub_ref).unwrap().meta;+ assert_eq!(child.key, "qoder:agent-child");+ assert!(child.spawned);+ assert_eq!(+ child.title, "子代理任务:检查清理回调",+ "sidechain 行照常读"+ );+ assert_eq!(+ path_links(rooted.as_ref()),+ vec![edge(+ "qoder:agent-child",+ "qoder:abababab-aaaa-bbbb-cccc-000000000014"+ )]+ );+ assert_seq_contract(rooted.as_ref(), &sub_ref);}#[test]@@ -1714,6 +2104,42 @@ fn gemini_parse_contract() {);}+/// OpenCode / Kilo 的 task 工具派出去的子会话:调用 state 里的 `metadata.sessionId` 就是它,+/// 详情页按它跳+#[test]+fn opencode_task_calls_open_the_session_they_spawned() {+ let tmp = tempfile::tempdir().unwrap();+ let db = tmp.path().join("opencode.db");+ common::build_opencode_db(&db);+ rusqlite::Connection::open(&db)+ .unwrap()+ .execute_batch(+ r#"+ INSERT INTO message VALUES+ ('msg-d','oc-0001','{"id":"msg-d","role":"assistant","time":{"created":1786000300000}}',1786000300000);+ INSERT INTO part VALUES+ ('prt-d-01','oc-0001','msg-d','{"type":"tool","callID":"oc_call_task","tool":"task","state":{"status":"completed","input":{"description":"Check the parser","prompt":"Look at src/parser.rs","subagent_type":"explore"},"output":"Two problems.","metadata":{"sessionId":"oc-child"}}}');+ "#,+ )+ .unwrap();+ for adapter in [OpencodeAdapter::new(), OpencodeAdapter::kilo()] {+ let adapter = adapter.with_custom_root(db.clone());+ let r = db_ref(adapter.agent(), &db, "oc-0001");+ let t = adapter.parse_transcript(&r).unwrap();+ let calls: Vec<(&str, Option<&str>)> = t+ .mainline+ .iter()+ .flat_map(|m| &m.tool_calls)+ .map(|c| (c.id.as_str(), c.child_id.as_deref()))+ .collect();+ assert_eq!(+ calls,+ [("oc_call_1", None), ("oc_call_task", Some("oc-child"))],+ "只有派了子会话的调用能跳"+ );+ }+}+#[test]fn opencode_v2_parse_contract() {let env = setup();@@ -2165,18 +2591,23 @@ fn kimi_desktop_wire_contract() {let session_id = "session_77777777-aaaa-bbbb-cccc-000000000007";let adapter = KimiAdapter::new().with_custom_root(fixture("kimi-desktop"));let refs = adapter.list_session_files().expect("kimi list");- assert_eq!(- refs.iter()- .map(|r| r.native_id.as_str())- .collect::<Vec<_>>(),- vec![session_id]- );- let r = &refs[0];- // 子代理的 wire.jsonl(文件确实在)按路径分段拒掉+ let sub_id = format!("{session_id}/sub-1");+ let mut ids: Vec<&str> = refs.iter().map(|r| r.native_id.as_str()).collect();+ ids.sort();+ assert_eq!(ids, vec![session_id, sub_id.as_str()]);+ let r = refs.iter().find(|r| r.native_id == session_id).unwrap();+ // 子代理的 wire.jsonl 作为子会话,按路径分段认let agents = Path::new(&r.file_path).parent().unwrap().parent().unwrap();let sub = agents.join("sub-1").join("wire.jsonl");- assert!(sub.is_file());- assert!(adapter.file_ref(&sub).is_none());+ let sub_ref = adapter.file_ref(&sub).expect("子代理作为子会话");+ assert_eq!(sub_ref.native_id, sub_id);+ assert_eq!(+ path_links(adapter.as_ref()),+ vec![edge(+ &format!("kimi:{sub_id}"),+ &format!("kimi:{session_id}")+ )]+ );let t = adapter.parse_transcript(r)@@ -2220,6 +2651,145 @@ fn kimi_desktop_wire_contract() {assert_seq_contract(adapter.as_ref(), r);}+/// Kimi 派出去的子代理(`agents/<id>/wire.jsonl`,state.json 里 `type: "sub"`)作为子会话入库:+/// native id 带上所在会话、按路径挂到会话下、标成派出去的;它收到的任务(origin+/// `system_trigger` / `subagent`)是它的"用户"那句,垫在前面的 `<git-context>` 不进标题。会话+/// 里派活的 Agent 调用按输出里的 `agent_id:` 指向子会话。在私有临时目录里搭+#[test]+fn kimi_subagents_become_child_sessions() {+ let tmp = tempfile::tempdir().unwrap();+ let session_id = "session_d1111111-aaaa-bbbb-cccc-000000000001";+ let session = tmp+ .path()+ .join("sessions")+ .join("wd_subfx_1")+ .join(session_id);+ let main = session.join("agents").join("main");+ let sub = session.join("agents").join("agent-1");+ fs::create_dir_all(&main).unwrap();+ fs::create_dir_all(&sub).unwrap();+ let lines = |rows: &[serde_json::Value]| -> String {+ rows.iter().map(|row| format!("{row}\n")).collect()+ };+ let event = |time: i64, event: serde_json::Value| serde_json::json!({ "type": "context.append_loop_event", "time": time, "event": event });+ fs::write(+ session.join("state.json"),+ serde_json::json!({ "title": "Review the parser", "agents": {+ "main": { "type": "main", "parentAgentId": null },+ "agent-1": { "type": "sub", "parentAgentId": "main" } } })+ .to_string(),+ )+ .unwrap();+ fs::write(+ main.join("wire.jsonl"),+ lines(&[+ serde_json::json!({ "type": "turn.prompt", "time": 1791417601000i64,+ "input": [{ "type": "text", "text": "Review the parser" }],+ "origin": { "kind": "user" } }),+ event(1791417602000, serde_json::json!({ "type": "tool.call", "toolCallId": "call-1",+ "name": "Agent", "args": { "description": "Check the parser",+ "prompt": "Look at src/parser.rs", "subagent_type": "explore" } })),+ event(1791417609000, serde_json::json!({ "type": "tool.result", "toolCallId": "call-1",+ "result": { "isError": false, "output":+ "agent_id: agent-1\nactual_subagent_type: explore\nstatus: completed\n\n[summary]\nTwo problems." } })),+ ]),+ )+ .unwrap();+ fs::write(+ sub.join("wire.jsonl"),+ lines(&[+ serde_json::json!({ "type": "turn.prompt", "time": 1791417603000i64,+ "input": [{ "type": "text",+ "text": "<git-context>\nWorking directory: /w\n</git-context>\n\nLook at src/parser.rs" }],+ "origin": { "kind": "system_trigger", "name": "subagent" } }),+ event(1791417605000, serde_json::json!({ "type": "content.part",+ "part": { "type": "text", "text": "Two problems." } })),+ ]),+ )+ .unwrap();+ let adapter = KimiAdapter::new().with_custom_root(tmp.path().to_path_buf());++ let sub_id = format!("{session_id}/agent-1");+ let refs = adapter.list_session_files().unwrap();+ let mut ids: Vec<&str> = refs.iter().map(|r| r.native_id.as_str()).collect();+ ids.sort();+ assert_eq!(ids, [session_id, sub_id.as_str()]);+ let sub_ref = refs.iter().find(|r| r.native_id == sub_id).unwrap();+ let child = adapter.parse_session(sub_ref).unwrap().meta;+ assert_eq!(child.key, format!("kimi:{sub_id}"));+ assert!(child.spawned);+ assert_eq!(+ child.title, "Look at src/parser.rs",+ "任务前面垫的仓库现状不进标题"+ );+ assert_eq!(child.message_count, 2, "它收到的任务是它的用户消息");+ assert_eq!(+ (child.created_at, child.updated_at),+ (1791417603000, 1791417605000),+ "时间按它自己的消息算,不用会话的 state.json"+ );+ assert_seq_contract(adapter.as_ref(), sub_ref);+ assert_eq!(+ path_links(adapter.as_ref()),+ vec![edge(+ &format!("kimi:{sub_id}"),+ &format!("kimi:{session_id}")+ )]+ );+ assert_eq!(+ adapter.session_paths(&child),+ [sub.to_string_lossy().to_string()],+ "子代理只带走它自己的 agent 目录"+ );+ assert!(!resumable(&adapter, &child), "子代理不是能单独恢复的会话");++ let main_ref = refs.iter().find(|r| r.native_id == session_id).unwrap();+ let t = adapter.parse_transcript(main_ref).unwrap();+ let call = t+ .mainline+ .iter()+ .flat_map(|m| &m.tool_calls)+ .find(|c| c.id == "call-1")+ .expect("派活的调用");+ assert_eq!(call.child_id, Some(sub_id.clone()));+ let sidechains: Vec<(&str, Option<&str>, Option<&str>)> = t+ .sidechains+ .iter()+ .map(|s| {+ (+ s.id.as_str(),+ s.description.as_deref(),+ s.agent_type.as_deref(),+ )+ })+ .collect();+ assert_eq!(+ sidechains,+ [("agent-1", Some("Check the parser"), Some("explore"))]+ );+ assert_eq!(+ adapter.load_sidechain(main_ref, "agent-1").unwrap().len(),+ 2,+ "MCP 的 subagent 参数读得到"+ );++ // 在 Kimi 里归档会话只改 state.json:子代理跟着归档。它的转录没动、收不到事件——引用里+ // 并着归档那一位,state.json 的事件经 ref_dependents 交出它+ assert!(!child.archived);+ let state = session.join("state.json");+ fs::write(&state, r#"{"title":"Review the parser","archived":true}"#).unwrap();+ let wire = sub.join("wire.jsonl");+ assert_eq!(adapter.ref_dependents(&state), [wire.clone()]);+ assert!(adapter.ref_dependents(&main.join("wire.jsonl")).is_empty());+ let archived = adapter.file_ref(&wire).unwrap();+ assert_ne!(+ (archived.mtime_ms, archived.size),+ (sub_ref.mtime_ms, sub_ref.size),+ "全量扫描认得出它变了"+ );+ assert!(adapter.parse_session(&archived).unwrap().meta.archived);+}+/// Kimi Code CLI(agent-core 0.29)的真实记录流(合成 fixture,形状照 Kimi 自己的/// `reduceWireRecords`):助手回复按步写在 context.append_loop_event(think / text 块、/// tool.call 与 tool.result),同一轮的各步并成一条、工具结果回填;用户输入的@@ -2976,6 +3546,52 @@ fn dsh_subagent_keeps_only_its_own_turns() {);}+/// dsh 后台续跑的子代理:派它的调用只回一句 `started subagent <子会话 id>`,详情页按它跳到+/// 子会话;前台跑的结果只有最终文字,挂不上+#[test]+fn dsh_background_subagent_calls_open_the_child_session() {+ let tmp = tempfile::tempdir().unwrap();+ let dir = tmp.path().join("sessions").join("--w--").join("dsh-par-1");+ fs::create_dir_all(&dir).unwrap();+ let call = |seq: u32, id: &str| {+ format!(+ r#"{{"type":"assistant/message","seq":{seq},"time":1788000002000,"data":{{"turn":1,"step":1,"message":{{"id":"m-{id}","role":"assistant","content":[{{"type":"tool-call","id":"{id}","name":"subagent","arguments":"{{}}"}}],"source":{{"kind":"model","provider":"deepseek","model":"deepseek-v4-pro"}}}},"stream":[]}},"surfaceOp":"append"}}"#+ )+ };+ let result = |seq: u32, id: &str, text: &str| {+ format!(+ r#"{{"type":"tool/result","seq":{seq},"time":1788000002100,"data":{{"turn":1,"step":1,"message":{{"id":"r-{id}","role":"tool","source":{{"kind":"tool","callId":"{id}"}},"toolCallId":"{id}","content":[{{"type":"text","text":"{text}"}}]}}}},"surfaceOp":"append"}}"#+ )+ };+ let lines = [+ r#"{"type":"session","version":4,"id":"dsh-par-1","createdAt":1788000000000,"cwd":"/w","isSeeded":false,"delegationDepth":0}"#.to_string(),+ r#"{"type":"user/message","seq":1,"time":1788000001000,"data":{"id":"m-u1","role":"user","content":[{"type":"text","text":"Audit the scanner"}],"source":{"kind":"user"}},"surfaceOp":"append"}"#.to_string(),+ call(2, "call-bg"),+ result(3, "call-bg", "started subagent dsh-child-1"),+ call(4, "call-fg"),+ result(5, "call-fg", "Two effects never clean up."),+ ];+ fs::write(dir.join("session.v4.jsonl"), lines.join("\n") + "\n").unwrap();+ let adapter = DshAdapter::new().with_custom_root(tmp.path().to_path_buf());+ let refs = adapter.list_session_files().unwrap();+ assert_eq!(refs.len(), 1);+ let calls: Vec<(String, Option<String>)> = adapter+ .parse_transcript(&refs[0])+ .unwrap()+ .mainline+ .iter()+ .flat_map(|m| &m.tool_calls)+ .map(|c| (c.id.clone(), c.child_id.clone()))+ .collect();+ assert_eq!(+ calls,+ [+ ("call-bg".to_string(), Some("dsh-child-1".to_string())),+ ("call-fg".to_string(), None),+ ]+ );+}+#[test]fn dsh_reads_the_newest_format_generation() {// dsh 迁移只新增下一代文件、不删旧代(issue #45:0.1.6 起写 session.v3.jsonl.zstd,@@ -6077,26 +6693,56 @@ fn codebuddy_topic_title_and_model_id_fallback() {.is_some_and(|x| x.contains("merged PRs")));}-/// 枚举只认 slug 目录直属的转录:`<session>/subagents/agent-*.jsonl` 既不进列表、-/// watcher 事件也被 file_ref 拒掉;自定义 location 选 `~/.codebuddy` 或 projects-/// 目录都认;删除把 `<id>.meta.json` 与 `<id>/` 边车一并带走+/// 枚举收 slug 目录直属的转录,与会话同名目录里派出去的子代理(`<session>/subagents/+/// agent-*.jsonl`,作为子会话按路径挂到父会话下);别的边车不收。自定义 location 选+/// `~/.codebuddy` 或 projects 目录都认;删除把 `<id>.meta.json` 与 `<id>/` 边车一并带走#[test]-fn codebuddy_lists_only_top_level_transcripts() {+fn codebuddy_lists_transcripts_and_their_subagents() {let _env = setup();// 契约测试的假 home 不摆目录型 fixture(那是 cli / mcp / remote_sync 的活),// 直接把检入的 fixture 树当自定义 locationlet adapter = CodebuddyAdapter::new().with_custom_root(fixture("codebuddy"));let root = adapter.data_roots()[0].clone();let refs = adapter.list_session_files().unwrap();- assert_eq!(refs.len(), 2, "两条顶层会话");- assert!(refs.iter().all(|r| !r.file_path.contains("subagents")));+ assert_eq!(refs.len(), 3, "两条会话与一个子代理");let main = root.join("Users-fixture-src-wakefx/cb000001-aaaa-bbbb-cccc-000000000001.jsonl");let sub = root.join("Users-fixture-src-wakefx/cb000001-aaaa-bbbb-cccc-000000000001/subagents/agent-deadbeef.jsonl");assert!(sub.is_file(), "fixture 应带子代理转录");- assert!(adapter.file_ref(&main).is_some());- assert!(adapter.file_ref(&sub).is_none(), "子代理转录不是顶层会话");+ let main_ref = adapter.file_ref(&main).unwrap();+ let sub_ref = adapter.file_ref(&sub).expect("子代理转录作为子会话");+ let child = adapter.parse_session(&sub_ref).unwrap().meta;+ assert_eq!(child.key, "codebuddy:agent-deadbeef");+ assert!(child.spawned, "子代理是 agent 派出去的");+ assert_eq!(+ child.title,+ "Sub-agent task: list the files under src/components"+ );+ assert_eq!(+ path_links(adapter.as_ref()),+ vec![edge(+ "codebuddy:agent-deadbeef",+ "codebuddy:cb000001-aaaa-bbbb-cccc-000000000001"+ )]+ );+ assert_seq_contract(adapter.as_ref(), &sub_ref);+ assert_eq!(adapter.session_paths(&child), [sub_ref.file_path.clone()]);+ let t = adapter.parse_transcript(&main_ref).unwrap();+ let ids: Vec<(&str, Option<&str>)> = t+ .sidechains+ .iter()+ .map(|s| (s.id.as_str(), s.session_id.as_deref()))+ .collect();+ assert_eq!(ids, [("agent-deadbeef", Some("agent-deadbeef"))]);+ assert_eq!(+ adapter+ .load_sidechain(&main_ref, "agent-deadbeef")+ .unwrap()+ .len(),+ 2,+ "MCP 的 subagent 参数照旧读得到"+ );let meta = adapter.parse_session(&refs[0]).unwrap().meta;let paths = adapter.session_paths(&meta);@@ -6113,7 +6759,7 @@ fn codebuddy_lists_only_top_level_transcripts() {for dir in ["codebuddy", "codebuddy/projects"] {let rooted = CodebuddyAdapter::new().with_custom_root(fixture(dir));- assert_eq!(rooted.list_session_files().unwrap().len(), 2, "{dir}");+ assert_eq!(rooted.list_session_files().unwrap().len(), 3, "{dir}");}}@@ -6128,7 +6774,7 @@ fn workbuddy_is_a_codebuddy_twin() {let rooted = twin.with_custom_root(fixture("codebuddy"));let refs = rooted.list_session_files().unwrap();- assert_eq!(refs.len(), 2);+ assert_eq!(refs.len(), 3);assert!(refs.iter().all(|r| r.agent == AgentId::Workbuddy));let meta = rooted.parse_session(&refs[0]).unwrap().meta;assert_eq!(meta.agent, AgentId::Workbuddy);diff --git a/crates/wake-core/tests/common/mod.rs b/crates/wake-core/tests/common/mod.rsindex 2f8fd89..f3d9597 100644--- a/crates/wake-core/tests/common/mod.rs+++ b/crates/wake-core/tests/common/mod.rs@@ -159,6 +159,26 @@ pub fn stage_codex_spawn_pair(home: &Path) -> (String, String, PathBuf) {parent_head.clone(),message("user", "inherited parent turn about the qr login bug"),message("assistant", "inherited parent answer"),+ // 派活:输出是子线程的 agent_path,详情页按它跳到子线程+ serde_json::json!({+ "timestamp": "2026-09-16T09:29:00.000Z",+ "type": "response_item",+ "payload": {+ "type": "function_call",+ "name": "spawn_agent",+ "call_id": "call_spawn_1",+ "arguments": "{\"task_name\":\"review_issue17\",\"message\":\"Review issue 17\"}"+ }+ }),+ serde_json::json!({+ "timestamp": "2026-09-16T09:29:01.000Z",+ "type": "response_item",+ "payload": {+ "type": "function_call_output",+ "call_id": "call_spawn_1",+ "output": "{\"task_name\":\"/root/review_issue17\"}"+ }+ }),],);@@ -219,28 +239,30 @@ pub fn stage_codex_spawn_pair(home: &Path) -> (String, String, PathBuf) {conn.execute_batch("CREATE TABLE threads (id TEXT, rollout_path TEXT, cwd TEXT, title TEXT, name TEXT,tokens_used INTEGER, archived INTEGER, git_branch TEXT, model TEXT, source TEXT,- created_at_ms INTEGER, updated_at_ms INTEGER);+ created_at_ms INTEGER, updated_at_ms INTEGER, agent_path TEXT);CREATE TABLE thread_spawn_edges (parent_thread_id TEXT NOT NULL,child_thread_id TEXT NOT NULL PRIMARY KEY, status TEXT NOT NULL);",).unwrap();- for (id, file, source) in [+ for (id, file, source, agent_path) in [(&parent_id,format!("rollout-2026-09-16T09-00-00-{parent_id}.jsonl"),"cli",+ None,),(&child_id,format!("rollout-2026-09-16T09-30-00-{child_id}.jsonl"),// 真机把整个结构化来源原样存进 source 列"{\"subagent\":{\"thread_spawn\":{}}}",+ Some("/root/review_issue17"),),] {conn.execute("INSERT INTO threads VALUES (?1, ?2, '/work/wake', '', NULL, 0, 0,- NULL, NULL, ?3, 1789000000000, 1789000000000)",- rusqlite::params![id, day.join(file).to_string_lossy(), source],+ NULL, NULL, ?3, 1789000000000, 1789000000000, ?4)",+ rusqlite::params![id, day.join(file).to_string_lossy(), source, agent_path],).unwrap();}@@ -1425,6 +1447,100 @@ pub fn lock_as(db: &Path, kind: &str) -> IndexLock {}}+/// Claude Code 的子代理:在会话目录 `<项目目录>/<parent>/subagents/` 下放一份 Task / Agent 派的+/// 转录(边车写着任务说明与派它的 tool_use id)和一份 Workflow 跑出来的(边车只有 agentType),+/// 外加 Workflow 的运行日志 journal.jsonl(不是转录)。`prefix` 让同一测试里的几组 id 不撞。+/// 返回 (Task 那份的 id, Workflow 那份的 id)+pub fn stage_claude_subagents(+ project: &Path,+ parent: &str,+ prefix: &str,+ tool_use_id: &str,+) -> (String, String) {+ let subagents = project.join(parent).join("subagents");+ let run = subagents.join("workflows").join(format!("wf_{prefix}-run"));+ fs::create_dir_all(&run).unwrap();+ let rows = |lines: &[(&str, &str, &str)]| -> String {+ lines+ .iter()+ .enumerate()+ .map(|(ix, (typ, ts, text))| {+ let message = if *typ == "user" {+ serde_json::json!({ "role": "user", "content": text })+ } else {+ serde_json::json!({+ "id": format!("msg_{prefix}_{ix}"),+ "role": "assistant",+ "model": "claude-opus-5-5",+ "content": [{ "type": "text", "text": text }],+ "usage": { "input_tokens": 10, "output_tokens": 5 },+ })+ };+ format!(+ "{}\n",+ serde_json::json!({+ "parentUuid": null,+ "isSidechain": true,+ "cwd": "/Users/tester/Github/subfx",+ "sessionId": parent,+ "type": typ,+ "message": message,+ "uuid": format!("{prefix}-{ix}"),+ "timestamp": ts,+ })+ )+ })+ .collect()+ };+ let task = format!("agent-{prefix}task");+ let step = format!("agent-{prefix}step");+ fs::write(+ subagents.join(format!("{task}.jsonl")),+ rows(&[+ (+ "user",+ "2026-10-01T10:00:10.000Z",+ "Look at src/parser.rs and report problems",+ ),+ (+ "assistant",+ "2026-10-01T10:00:20.000Z",+ "The parser handles every case.",+ ),+ ]),+ )+ .unwrap();+ fs::write(+ subagents.join(format!("{task}.meta.json")),+ serde_json::json!({+ "agentType": "Explore",+ "description": "Check the parser",+ "toolUseId": tool_use_id,+ })+ .to_string(),+ )+ .unwrap();+ fs::write(+ run.join(format!("{step}.jsonl")),+ rows(&[+ (+ "user",+ "2026-10-01T10:01:00.000Z",+ "Workflow step: run the tests",+ ),+ ("assistant", "2026-10-01T10:01:30.000Z", "All tests pass."),+ ]),+ )+ .unwrap();+ fs::write(+ run.join(format!("{step}.meta.json")),+ r#"{"agentType":"workflow-subagent","spawnDepth":1}"#,+ )+ .unwrap();+ fs::write(run.join("journal.jsonl"), "{\"type\":\"workflow-start\"}\n").unwrap();+ (task, step)+}+/// Claude Code 的分支会话:原件 A 问了两轮;B 是从 A 第一轮之后分出来的——Claude 把 A 到/// 分叉点为止的行**原样**复制进 B 的开头(uuid、message.id、时间戳都不变,只改 sessionId),/// 头几行(custom-title 照抄 A 的标题、queue-operation)是复制那一刻写的,时间晚于 A 的开头。diff --git a/crates/wake-core/tests/db_roundtrip.rs b/crates/wake-core/tests/db_roundtrip.rsindex 08da209..f05bc32 100644--- a/crates/wake-core/tests/db_roundtrip.rs+++ b/crates/wake-core/tests/db_roundtrip.rs@@ -543,6 +543,127 @@ fn since_on_root_lists_uses_aggregated_child_activity() {);}+/// 分叉(或分支)下面还挂着它派的子代理:根会话的活动时间、消息数与 since 过滤连孙会话一起算,+/// 子会话列表的 since 也连它下面的算。隐藏归档时,归档了的分叉下面的子代理自成一棵、不算进原件+#[test]+fn grandchildren_count_toward_their_root() {+ let (_dir, store) = temp_store();+ let session = |id: &str, updated_at: i64, message_count: i64| SessionMeta {+ agent: AgentId::Kimi,+ file_path: format!("/tmp/kimi/{id}/wire.jsonl"),+ updated_at,+ message_count,+ ..meta(&format!("kimi:{id}"), id)+ };+ let original = session("a", 100, 2);+ let fork = session("b", 200, 3);+ let sub = session("b/agent-1", 900, 5);+ store+ .write_meta_only(&[+ (original.clone(), 100),+ (fork.clone(), 200),+ (sub.clone(), 900),+ ])+ .unwrap();+ store+ .replace_parent_links(+ AgentId::Kimi,+ &[+ (fork.key.clone(), original.key.clone()),+ (sub.key.clone(), fork.key.clone()),+ ],+ )+ .unwrap();++ let recent = SessionFilter {+ roots_only: true,+ updated_since: Some(500),+ limit: 20,+ ..Default::default()+ };+ let (rows, total) = store.list_sessions(&recent).unwrap();+ assert_eq!(total, 1, "只有孙会话是新的,整棵树也得留着");+ assert_eq!(+ (+ rows[0].key.as_str(),+ rows[0].updated_at,+ rows[0].message_count+ ),+ (original.key.as_str(), 900, 10)+ );+ let children = store.list_children(&original.key, &recent).unwrap();+ assert_eq!(+ children.iter().map(|c| c.key.as_str()).collect::<Vec<_>>(),+ [fork.key.as_str()],+ "子会话的 since 同样连它下面的算"+ );+ assert_eq!(store.child_counts(&recent).unwrap()[&fork.key], 1);+ assert_eq!(store.list_projects(false).unwrap()[0].last_active, 900);++ store+ .write_meta_only(&[(+ SessionMeta {+ archived: true,+ ..fork.clone()+ },+ 200,+ )])+ .unwrap();+ let active = SessionFilter {+ roots_only: true,+ limit: 20,+ ..Default::default()+ };+ let (rows, _) = store.list_sessions(&active).unwrap();+ let summary: Vec<(&str, i64, i64)> = rows+ .iter()+ .map(|s| (s.key.as_str(), s.updated_at, s.message_count))+ .collect();+ assert_eq!(+ summary,+ [(sub.key.as_str(), 900, 5), (original.key.as_str(), 100, 2)]+ );+}++/// 分叉这一轮才挂到别的项目的原件下:已经挂在分叉下的子代理同一轮跟着换成原件的项目,不等下一轮+/// (只比父会话此刻的项目,子代理会被当成已经铺好)+#[test]+fn a_relinked_parent_carries_its_children_into_the_new_project() {+ let (_dir, store) = temp_store();+ let session = |id: &str, project: &str| SessionMeta {+ agent: AgentId::Kimi,+ project_path: format!("/w/{project}"),+ project_name: project.to_string(),+ file_path: format!("/tmp/kimi/{id}/wire.jsonl"),+ ..meta(&format!("kimi:{id}"), id)+ };+ let original = session("a", "alpha");+ let fork = session("b", "beta");+ let sub = session("b/agent-1", "beta");+ store+ .write_meta_only(&[(original.clone(), 1), (fork.clone(), 1), (sub.clone(), 1)])+ .unwrap();+ store+ .replace_parent_links(AgentId::Kimi, &[(sub.key.clone(), fork.key.clone())])+ .unwrap();+ store+ .replace_parent_links(+ AgentId::Kimi,+ &[+ (fork.key.clone(), original.key.clone()),+ (sub.key.clone(), fork.key.clone()),+ ],+ )+ .unwrap();+ let project = |key: &str| {+ let s = store.get_session(key).unwrap().unwrap();+ (s.project_path, s.project_name)+ };+ let alpha = ("/w/alpha".to_string(), "alpha".to_string());+ assert_eq!(project(&fork.key), alpha);+ assert_eq!(project(&sub.key), alpha, "孙会话同一轮跟着换");+}+#[test]fn ignore_pins_gives_true_recency_order() {let (_dir, store) = temp_store();diff --git a/crates/wake-core/tests/fixtures/qoder/projects/-Users-tester-Github-wakefx/abababab-aaaa-bbbb-cccc-000000000014/subagents/agent-child.jsonl b/crates/wake-core/tests/fixtures/qoder/projects/-Users-tester-Github-wakefx/abababab-aaaa-bbbb-cccc-000000000014/subagents/agent-child.jsonlindex d592845..36bb7a2 100644--- a/crates/wake-core/tests/fixtures/qoder/projects/-Users-tester-Github-wakefx/abababab-aaaa-bbbb-cccc-000000000014/subagents/agent-child.jsonl+++ b/crates/wake-core/tests/fixtures/qoder/projects/-Users-tester-Github-wakefx/abababab-aaaa-bbbb-cccc-000000000014/subagents/agent-child.jsonl@@ -1 +1 @@-{"type":"user","uuid":"q-child-user","parentUuid":null,"isSidechain":true,"cwd":"/Users/tester/Github/wakefx","sessionId":"child-agent","timestamp":"2026-08-08T09:02:30.000Z","message":{"role":"user","content":"这是会话边车,不能成为主列表项"}}+{"type":"user","uuid":"q-child-user","parentUuid":null,"isSidechain":true,"cwd":"/Users/tester/Github/wakefx","sessionId":"child-agent","timestamp":"2026-08-08T09:02:30.000Z","message":{"role":"user","content":"子代理任务:检查清理回调"}}diff --git a/crates/wake-core/tests/mcp_stdio.rs b/crates/wake-core/tests/mcp_stdio.rsindex 2d1d5af..93c3953 100644--- a/crates/wake-core/tests/mcp_stdio.rs+++ b/crates/wake-core/tests/mcp_stdio.rs@@ -323,14 +323,26 @@ fn stdio_contract_end_to_end() {"tool calls fold to one line by default");- // 4b. 子代理转录:主线页脚列出 id,按 id 读、同一套分页;未知 id 是给 LLM 看- // 的失败结果并附上有哪些+ // 4b. 子代理转录:作为子会话列在主线页脚(标题是派活时的任务说明),按它自己的 key 读,+ // 头部指回父会话;不再在 subagent transcripts 里列第二遍。`subagent` 参数照样按 id 读、+ // 同一套分页;未知 id 是给 LLM 看的失败结果并附上有哪些assert!(plain_page.contains(- "1 subagent transcript (pass an id as `subagent` to read one):\n- agent-fixture01 — Explore: find the QR scanner code\n"+ "1 child session (read one with wake_get_session using its key):\n- `claude-code:agent-fixture01` — \"find the QR scanner code\" · 3 messages\n"),"{plain_page}");+ assert!(!plain_page.contains("subagent transcript"), "{plain_page}");+ let (child, is_err) = c.call(+ "wake_get_session",+ json!({ "key": "claude-code:agent-fixture01" }),+ );+ assert!(!is_err, "{child}");+ assert!(+ child.contains(&format!("parent: `{CLAUDE_KEY}`")),+ "{child}"+ );+ assert!(child.contains("QR scanner is wired up"), "{child}");let (sub, is_err) = c.call("wake_get_session",json!({ "key": CLAUDE_KEY, "subagent": "agent-fixture01", "max_messages": 1 }),diff --git a/crates/wake-core/tests/scanner_finale.rs b/crates/wake-core/tests/scanner_finale.rsindex b16bd89..d42a084 100644--- a/crates/wake-core/tests/scanner_finale.rs+++ b/crates/wake-core/tests/scanner_finale.rs@@ -143,6 +143,108 @@ fn codex_spawned_subagents_nest_under_their_parent() {);}+/// Claude Code 的子代理端到端:原件与分支各自派了子代理(一份 Task 派的、一份 Workflow 跑的)。+/// 扫描后原件的子代理挂在原件下,分支的挂在分支下——子代理停在转录所在的那个会话上,它的文件在+/// 分支的会话目录里,挂到原件上删除与清理都会把它弄丢。Insights 只算原件与分支两条会话;清理时+/// 原件那棵树带走原件的子代理,分支自成一棵、带着分支的子代理,谁也不越界+#[test]+fn claude_subagents_nest_under_the_session_that_spawned_them() {+ let home = tempfile::tempdir().unwrap();+ // 清理要真实路径(macOS 的临时目录在 /var 这个别名后面)+ let projects = home.path().canonicalize().unwrap().join("projects");+ let (project, a, b) = common::stage_claude_branch(&projects);+ let (a_task, a_step) = common::stage_claude_subagents(&project, &a, "o", "toolu_o");+ let (b_task, b_step) = common::stage_claude_subagents(&project, &b, "b", "toolu_b");+ let dir = tempfile::tempdir().unwrap();+ let store = temp_store(dir.path());+ let adapters: Vec<Box<dyn AgentAdapter>> =+ vec![ClaudeAdapter::new().with_custom_root(projects)];+ run_scan(&adapters, &store, &Recorder::new(), true).unwrap();++ let key = |id: &str| format!("claude-code:{id}");+ let parent = |id: &str| store.parent_key_of(&key(id)).unwrap();+ assert_eq!(parent(&b), Some(key(&a)), "分支挂在原件下");+ for child in [&a_task, &a_step] {+ assert_eq!(parent(child), Some(key(&a)), "{child}");+ }+ for child in [&b_task, &b_step] {+ assert_eq!(parent(child), Some(key(&b)), "{child} 挂在派它的分支下");+ }+ let today = chrono::NaiveDate::from_ymd_opt(2026, 10, 12).unwrap();+ assert_eq!(store.insights(today).unwrap().sessions, 2, "子代理不算会话");++ let inventory = wake_core::cleanup::inventory(&store, &adapters).unwrap();+ let tree = |root: &str| -> std::collections::BTreeSet<String> {+ inventory+ .candidates+ .iter()+ .find(|c| c.root.key == key(root))+ .unwrap_or_else(|| {+ let why: Vec<(&str, &str)> = inventory+ .unavailable+ .iter()+ .map(|u| (u.session.key.as_str(), u.reason.as_str()))+ .collect();+ panic!("{root} 没有自己的清理树: {why:?}")+ })+ .sessions+ .iter()+ .map(|s| s.key.clone())+ .collect()+ };+ assert_eq!(tree(&a), [key(&a), key(&a_task), key(&a_step)].into());+ assert_eq!(tree(&b), [key(&b), key(&b_task), key(&b_step)].into());+}++/// 旧版监听把 Claude Code Workflow 的子代理转录当顶层会话收进来过(sidechain 行被滤掉、零消息)。+/// 文件没变、引用也没变,升级后的增量扫描本会跳过它——FTS_FORMAT "16" 那一轮重解析把它写对:+/// 正文搜得到、挂到派它的会话下+#[test]+fn stale_workflow_rows_from_old_versions_are_reparsed() {+ let home = tempfile::tempdir().unwrap();+ let projects = home.path().join("projects");+ let (project, a, _) = common::stage_claude_branch(&projects);+ let (_, step) = common::stage_claude_subagents(&project, &a, "o", "toolu_o");+ let adapters: Vec<Box<dyn AgentAdapter>> =+ vec![ClaudeAdapter::new().with_custom_root(projects)];+ let r = adapters[0]+ .list_session_files()+ .unwrap()+ .into_iter()+ .find(|r| r.native_id == step)+ .unwrap();+ let key = format!("claude-code:{step}");+ let dir = tempfile::tempdir().unwrap();+ let db_path = dir.path().join("wake.db");+ {+ let store = Store::open(&db_path).unwrap();+ let stale = SessionMeta {+ message_count: 0,+ size_bytes: r.size,+ file_path: r.file_path.clone(),+ ..common::meta(&key, "Workflow step: run the tests")+ };+ store.write_meta_only(&[(stale, r.mtime_ms)]).unwrap();+ }+ rusqlite::Connection::open(&db_path)+ .unwrap()+ .execute(+ "UPDATE schema_meta SET value = '15' WHERE key = 'fts_format'",+ [],+ )+ .unwrap();++ let store = Arc::new(Store::open(&db_path).unwrap());+ run_scan(&adapters, &store, &Recorder::new(), false).unwrap();+ assert_eq!(store.get_session(&key).unwrap().unwrap().message_count, 2);+ assert_eq!(+ store.parent_key_of(&key).unwrap(),+ Some(format!("claude-code:{a}"))+ );+ let (hits, _) = store.search("All tests pass", &[], None, 10).unwrap();+ assert!(hits.iter().any(|h| h.session.key == key), "正文搜得到");+}+/// Claude Code 分支端到端:全量扫描后分支挂在原件下、顶层只列原件;两份共有的那一轮只在/// 原件里搜得到,分支自己的话在分支里;原件删掉后分支变回顶层、拿回完整历史#[test]@@ -1559,6 +1661,70 @@ fn kimi_forks_nest_under_their_parent() {assert!(!store.get_session(parent).unwrap().unwrap().archived);}+/// Kimi 的分叉 B 派了子代理 C:C 的转录在 B 的会话目录里,挂在 B 下、不往上压到原件——删 B 时+/// 目录连同 C 一起进废纸篓,C 得在删除计划里(要记墓碑),否则另一个 location 里的副本会再冒+/// 出来。C 跟着 B 归档:B 在 Kimi 里归档了,C 不能变成顶层会话(Codex review 2026-10-12)+#[test]+fn kimi_fork_subagents_stay_under_the_fork() {+ use wake_core::adapters::kimi::KimiAdapter;+ let home = tempfile::tempdir().unwrap();+ let home = home.path().canonicalize().unwrap();+ common::copy_tree(&common::fixture("kimi-cli"), &home);+ let fork_id = "session_c2222222-aaaa-bbbb-cccc-000000000002";+ let mut fork_dir = home.clone();+ fork_dir.extend(["sessions", "wd_wakefx_cli1", fork_id]);+ let sub_dir = fork_dir.join("agents").join("agent-1");+ std::fs::create_dir_all(&sub_dir).unwrap();+ std::fs::write(+ sub_dir.join("wire.jsonl"),+ [+ json!({ "type": "turn.prompt", "time": 1791417603000i64,+ "input": [{ "type": "text", "text": "Look at src/parser.rs" }],+ "origin": { "kind": "system_trigger", "name": "subagent" } }),+ json!({ "type": "context.append_loop_event", "time": 1791417605000i64,+ "event": { "type": "content.part", "part": { "type": "text", "text": "Two problems." } } }),+ ]+ .map(|row| format!("{row}\n"))+ .concat(),+ )+ .unwrap();+ let adapters: Vec<Box<dyn AgentAdapter>> =+ vec![KimiAdapter::new().with_custom_root(home.clone())];+ let dir = tempfile::tempdir().unwrap();+ let store = temp_store(dir.path());+ run_scan(&adapters, &store, &Recorder::new(), true).unwrap();++ let original = "kimi:session_c1111111-aaaa-bbbb-cccc-000000000001";+ let fork = format!("kimi:{fork_id}");+ let sub = format!("kimi:{fork_id}/agent-1");+ assert_eq!(+ store.parent_key_of(&fork).unwrap().as_deref(),+ Some(original)+ );+ assert_eq!(+ store.parent_key_of(&sub).unwrap(),+ Some(fork.clone()),+ "子代理停在它所在的分叉上"+ );+ assert!(store.get_session(&sub).unwrap().unwrap().archived);+ let active = SessionFilter {+ roots_only: true,+ limit: 10,+ ..Default::default()+ };+ let (roots, _) = store.list_sessions(&active).unwrap();+ assert!(+ roots.iter().all(|s| s.key != sub),+ "分叉归档了,子代理不冒成顶层会话"+ );++ let fork_meta = store.get_session(&fork).unwrap().unwrap();+ let plan = wake_core::cleanup::delete_plan(&store, &adapters, &fork_meta).unwrap();+ let doomed: Vec<&str> = plan.sessions.iter().map(|s| s.key.as_str()).collect();+ assert_eq!(doomed, [fork.as_str(), sub.as_str()]);+ assert_eq!(plan.targets, [fork_dir.to_string_lossy().into_owned()]);+}+/// Kimi 的归档、改名只写 state.json:增量扫描按引用判脏,state.json 的 mtime / size 并在/// 引用里,才会重新解析(转录没变、旧引用照旧的话,归档标记永远停在上次)#[test]diff --git a/crates/wake/assets/icons/corner-down-right.svg b/crates/wake/assets/icons/corner-down-right.svgnew file mode 100644index 0000000..47a21d6--- /dev/null+++ b/crates/wake/assets/icons/corner-down-right.svg@@ -0,0 +1,16 @@+<!-- @license lucide-static v0.462.0 - ISC -->+<svg+ class="lucide lucide-corner-down-right"+ xmlns="http://www.w3.org/2000/svg"+ width="24"+ height="24"+ viewBox="0 0 24 24"+ fill="none"+ stroke="currentColor"+ stroke-width="2"+ stroke-linecap="round"+ stroke-linejoin="round"+>+ <polyline points="15 10 20 15 15 20" />+ <path d="M4 4v7a4 4 0 0 0 4 4h12" />+</svg>diff --git a/crates/wake/assets/icons/corner-left-up.svg b/crates/wake/assets/icons/corner-left-up.svgnew file mode 100644index 0000000..f02024e--- /dev/null+++ b/crates/wake/assets/icons/corner-left-up.svg@@ -0,0 +1,16 @@+<!-- @license lucide-static v0.462.0 - ISC -->+<svg+ class="lucide lucide-corner-left-up"+ xmlns="http://www.w3.org/2000/svg"+ width="24"+ height="24"+ viewBox="0 0 24 24"+ fill="none"+ stroke="currentColor"+ stroke-width="2"+ stroke-linecap="round"+ stroke-linejoin="round"+>+ <polyline points="14 9 9 4 4 9" />+ <path d="M20 20h-7a4 4 0 0 1-4-4V4" />+</svg>diff --git a/crates/wake/locales/zh-Hans.json b/crates/wake/locales/zh-Hans.jsonindex b3b2200..664673e 100644--- a/crates/wake/locales/zh-Hans.json+++ b/crates/wake/locales/zh-Hans.json@@ -201,6 +201,8 @@"Not found next to the Wake app — reinstall Wake": "没在 Wake 应用旁边找到 —— 重装 Wake","Not started": "未开始","Only the local file is removed — Codex's own records stay intact.": "只会删除本地文件 —— Codex 自己的记录不受影响。",+ "Open parent session": "打开父会话",+ "Open subagent session": "打开子代理会话","Open system trash": "打开系统废纸篓","Open this session": "打开此会话","Open this session in {}": "在 {} 中打开此会话",diff --git a/crates/wake/src/assets.rs b/crates/wake/src/assets.rsindex e9bba72..fbabf42 100644--- a/crates/wake/src/assets.rs+++ b/crates/wake/src/assets.rs@@ -108,6 +108,8 @@ icons!("layers","close","git-branch",+ "corner-left-up",+ "corner-down-right","refresh-cw","inbox","chevron-down",diff --git a/crates/wake/src/workbench.rs b/crates/wake/src/workbench.rsindex f59d016..3f6a968 100644--- a/crates/wake/src/workbench.rs+++ b/crates/wake/src/workbench.rs@@ -47,8 +47,8 @@ use gpui_component::{};use wake_core::adapters::{- adapter_for, children_outlive_parent, create_adapter_roster_for, path_owns,- session_source_path, AdapterLocation, AgentAdapter,+ adapter_for, create_adapter_roster_for, path_owns, session_source_path, AdapterLocation,+ AgentAdapter,};use wake_core::db::Store;use wake_core::models::Role as MessageRole;@@ -491,43 +491,52 @@ impl SessionsDelegate {}fn rebuild_rows_at(&mut self, today: NaiveDate) {- let tree_mode = self.tree_mode();let mut rows = Vec::new();+ let mut listed = HashSet::new();for root in &self.sessions {- let child_count = if tree_mode {- self.child_counts.get(&root.key).copied().unwrap_or(0)- } else {- 0- };- let expanded = child_count > 0 && self.expanded.contains(&root.key);- let group_timestamp = session_group_timestamp(root, self.sort);- let group_pinned = root.pinned;- rows.push(SessionListRow {- meta: root.clone(),- depth: 0,- child_count,- expanded,- group_timestamp,- group_pinned,- });- if expanded {- if let Some(children) = self.children.get(&root.key) {- rows.extend(children.iter().cloned().map(|child| SessionListRow {- meta: child,- depth: 1,- child_count: 0,- expanded: false,- group_timestamp,- group_pinned,- }));- }- }+ let group = (session_group_timestamp(root, self.sort), root.pinned);+ self.push_row(&mut rows, &mut listed, root, 0, group);}self.rows = rows;self.groups = build_row_groups_at(&self.rows, self.sort, self.ascending, today);self.grouped_on = today;}+ /// 一行会话;它展开着就接着列它的子会话(分支下面还挂着它派的子代理)。子行跟着根行的分组+ /// 时间,留在根所在的日期段里。一条会话只列一次:关系万一成环也不会一直往下走+ fn push_row<'a>(+ &'a self,+ rows: &mut Vec<SessionListRow>,+ listed: &mut HashSet<&'a str>,+ meta: &'a SessionMeta,+ depth: u8,+ (group_timestamp, group_pinned): (i64, bool),+ ) {+ if !listed.insert(meta.key.as_str()) {+ return;+ }+ let child_count = if self.tree_mode() {+ self.child_counts.get(&meta.key).copied().unwrap_or(0)+ } else {+ 0+ };+ let expanded = child_count > 0 && self.expanded.contains(&meta.key);+ rows.push(SessionListRow {+ meta: meta.clone(),+ depth,+ child_count,+ expanded,+ group_timestamp,+ group_pinned,+ });+ if expanded {+ for child in self.children.get(&meta.key).into_iter().flatten() {+ let group = (group_timestamp, group_pinned);+ self.push_row(rows, listed, child, depth.saturating_add(1), group);+ }+ }+ }+fn rebuild_groups_at(&mut self, today: NaiveDate) -> bool {let lang = crate::i18n::generation();if self.grouped_on == today && self.grouped_lang == lang {@@ -566,14 +575,11 @@ impl SessionsDelegate {if !self.tree_mode() {return;}- let root_keys: HashSet<&str> = self.sessions.iter().map(|root| root.key.as_str()).collect();- self.expanded = expanded- .into_iter()- .filter(|key| root_keys.contains(key.as_str()))- .collect();+ self.expanded = expanded;self.reload_expanded();}+ /// 从这一页的根往下重取展开过的子会话;不在这一页里的展开记录丢掉fn reload_expanded(&mut self) {let Some(pagination) = &self.pagination else {return;@@ -581,11 +587,28 @@ impl SessionsDelegate {let store = pagination.store.clone();let filter = pagination.filter.clone();self.children.clear();- for key in &self.expanded {- if let Ok(children) = store.list_children(key, &filter) {- self.children.insert(key.clone(), children);+ let mut pending: Vec<String> = self+ .sessions+ .iter()+ .map(|root| root.key.clone())+ .filter(|key| self.expanded.contains(key))+ .collect();+ while let Some(key) = pending.pop() {+ if self.children.contains_key(&key) {+ continue;+ }+ if let Ok(children) = store.list_children(&key, &filter) {+ pending.extend(+ children+ .iter()+ .map(|child| child.key.clone())+ .filter(|child| self.expanded.contains(child)),+ );+ self.children.insert(key, children);}}+ let loaded = &self.children;+ self.expanded.retain(|key| loaded.contains_key(key));self.rebuild_rows();}@@ -687,8 +710,9 @@ impl ListDelegate for SessionsDelegate {let expanded = row.expanded;let depth = row.depth;let child_line_color = theme.muted_foreground.opacity(0.38);- // 2px 线的中心与父行 15px Grok 图标的 11.5px 中轴一致。- let child_line_left = SPACE_XS + zpx(6.5);+ // 2px 线的中心与上一层行 15px 图标的 11.5px 中轴一致;每深一层右移一级缩进+ let indent = zpx(20.) * f32::from(depth);+ let child_line_left = SPACE_XS + zpx(6.5) + (indent - zpx(20.));Some(// 稳定元素身份必须是 session key:展开插入孩子后,IndexPath 会整体@@ -705,7 +729,7 @@ impl ListDelegate for SessionsDelegate {.py(SPACE_SM).gap(SPACE_XS).when(depth > 0, |this| {- this.pl(zpx(20.)).child(+ this.pl(indent).child(div().absolute().left(child_line_left)@@ -1085,7 +1109,7 @@ mod session_group_tests {input: Some(input_preview.to_string()),output: None,is_error: false,- sidechain_ref: None,+ child_id: None,}}@@ -1679,6 +1703,8 @@ struct DetailState {/// 放大预览操作的短暂就地反馈。绑定具体图片,避免切换预览后把上一张的/// 成功状态带过来;generation 让较早的复位计时器不能清掉较新的反馈。image_action_feedback: [Option<ImageActionFeedback>; 2],+ /// 挂在哪条会话下面(key, 标题):头部那行"回到父会话"。打开时查一次,不在 render 里查库+ parent: Option<(String, SharedString)>,}impl DetailState {@@ -1700,6 +1726,7 @@ impl DetailState {images: Vec::new(),zoom: None,image_action_feedback: [None; 2],+ parent: None,}}}@@ -4873,7 +4900,10 @@ impl Workbench {let Ok(Some(meta)) = self.store.get_session(key) else {return;};- let detail = DetailState::loading(meta.clone(), jump_seq);+ let mut detail = DetailState::loading(meta.clone(), jump_seq);+ detail.parent = self+ .visible_parent(key)+ .map(|parent| (parent.key, parent.title.into()));let load_id = detail.load_id;self.detail = Some(detail);// 搜索路径:中栏列表同步选中并滚到该会话。@@ -4907,8 +4937,31 @@ impl Workbench {.detach();let adapters = self.adapters.clone();+ let store = self.store.clone();let task = cx.background_spawn(async move {let result = load_visible_transcript(&adapters, &meta).map(|mut messages| {+ // 跳转按钮只给索引里真有的子会话:子会话可能删掉了,有的家是按工具输出认的。+ // 子会话与这一条同一家、同一台机器+ let child_key = |id: &str| session_key(meta.agent, &meta.host, id);+ let keys: Vec<String> = messages+ .iter()+ .flat_map(|m| &m.tool_calls)+ .filter_map(|call| call.child_id.as_deref().map(child_key))+ .collect();+ if !keys.is_empty() {+ let indexed = store+ .indexed_keys(keys.iter().map(String::as_str))+ .unwrap_or_default();+ for call in messages.iter_mut().flat_map(|m| m.tool_calls.iter_mut()) {+ if call+ .child_id+ .as_deref()+ .is_some_and(|id| !indexed.contains(&child_key(id)))+ {+ call.child_id = None;+ }+ }+ }let images = take_image_slots(&mut messages);(messages, images)});@@ -4991,6 +5044,29 @@ impl Workbench {self.set_scope(None, None, false, cx);}+ /// 从详情页跳到相关的会话(派活的工具调用 → 子会话,子会话 → 父会话):打开它,中栏列表+ /// 同步选中。父子会话一般在同一个侧栏筛选里,选得上就不动筛选;选不上再走搜索命中那条路+ fn open_related_session(&mut self, key: &str, window: &mut Window, cx: &mut Context<Self>) {+ self.leave_cleanup(cx);+ self.open_detail(key, None, window, cx);+ self.pending_list_selection = None;+ if !self.select_list_key(key, true, window, cx) {+ self.sync_list_selection(key, window, cx);+ }+ }++ /// 打开正在看的这条会话派出去的子会话:它与这一条同一家、同一台机器,key 按原生 id 拼+ fn open_child_session(&mut self, id: &str, window: &mut Window, cx: &mut Context<Self>) {+ let Some(key) = self+ .detail+ .as_ref()+ .map(|detail| session_key(detail.meta.agent, &detail.meta.host, id))+ else {+ return;+ };+ self.open_related_session(&key, window, cx);+ }+/// 搜索命中打开:侧栏切回 All Sessions(搜索是全库范围,过滤视图下/// 命中可能不在列表里),中栏定位选中该会话并滚到可见fn sync_list_selection(&mut self, key: &str, window: &mut Window, cx: &mut Context<Self>) {@@ -5040,7 +5116,8 @@ impl Workbench {};let (generation, mut filter, mut offset, mut total) = request;let root_key = if filter.roots_only {- self.visible_parent_key(key)+ self.visible_ancestors(key)+ .pop().unwrap_or_else(|| key.to_string())} else {key.to_string()@@ -5116,19 +5193,20 @@ impl Workbench {window: &mut Window,cx: &mut Context<Self>,) -> bool {- let parent_key = self- .list_state- .read(cx)- .delegate()- .tree_mode()- .then(|| self.visible_parent_key(key))- .flatten();+ // 行还没列出来(子会话所在的那一支收着)才去找它的祖先+ let ancestors = {+ let delegate = self.list_state.read(cx).delegate();+ if delegate.tree_mode() && delegate.row_index(key).is_none() {+ self.visible_ancestors(key)+ } else {+ Vec::new()+ }+ };self.list_state.update(cx, |state, cx| {- if state.delegate().row_index(key).is_none() {- if let Some(parent) = parent_key.as_deref() {- if state.delegate().row_index(parent).is_some() {- state.delegate_mut().ensure_expanded(parent);- }+ // 从根往下逐层展开:上一层展开了,下一层的行才出现+ for ancestor in ancestors.iter().rev() {+ if state.delegate().row_index(ancestor).is_some() {+ state.delegate_mut().ensure_expanded(ancestor);}}let path = state@@ -5152,14 +5230,28 @@ impl Workbench {})}- fn visible_parent_key(&self, key: &str) -> Option<String> {+ /// 一条会话往上的可见祖先,近的在前(子代理 → 分支 → 原件),一直到根;关系万一成环就停+ fn visible_ancestors(&self, key: &str) -> Vec<String> {+ let mut ancestors: Vec<String> = Vec::new();+ let mut current = key.to_string();+ while let Some(parent) = self.visible_parent(¤t) {+ if parent.key == key || ancestors.contains(&parent.key) {+ break;+ }+ current = parent.key.clone();+ ancestors.push(parent.key);+ }+ ancestors+ }++ /// 列表里看得见的父会话(归档的不算)+ fn visible_parent(&self, key: &str) -> Option<SessionMeta> {let parent_key = self.store.parent_key_of(key).ok().flatten()?;self.store.get_session(&parent_key).ok().flatten().filter(|parent| !parent.archived)- .map(|_| parent_key)}/// 展开/收起后按 session key 恢复选择,避免插入的子行让 IndexPath 漂到@@ -5367,18 +5459,21 @@ impl Workbench {/// 否则界面在授权框弹出的整段时间里完全冻结。fn do_delete(&mut self,- sessions: Vec<SessionMeta>,- targets: Vec<String>,+ plan: Arc<wake_core::cleanup::DeletePlan>,window: &mut Window,cx: &mut Context<Self>,) {let store = self.store.clone();- let keys: Vec<String> = sessions.iter().map(|session| session.key.clone()).collect();+ let keys: Vec<String> = plan+ .sessions+ .iter()+ .map(|session| session.key.clone())+ .collect();let count = keys.len();let lock = self.index_lock.clone();let task = cx.background_spawn(async move {let _lock = lock;- wake_core::cleanup::trash_sessions(&store, &sessions, &targets)+ wake_core::cleanup::trash_sessions(&store, &plan.sessions, &plan.targets)});cx.spawn_in(window, async move |this, cx| {let result = task.await;@@ -5428,50 +5523,29 @@ impl Workbench {return;}let meta = detail.meta.clone();- // 子会话查不出来就别删:只删根会把子代理一类留成孤儿- let descendants = match self.store.all_descendants(&meta.key) {- Ok(descendants) => descendants,+ // 子会话查不出来就别删:只删根会把子代理一类留成孤儿。分支(Claude Code 的 fork)不随+ // 原件删:原件没了分支变回顶层会话,watcher 随即把它重解析出完整历史(`ref_dependents`)+ let plan = match wake_core::cleanup::delete_plan(&self.store, &self.adapters, &meta) {+ Ok(plan) => Arc::new(plan),Err(e) => {window.push_notification(Notification::error(crate::tf!("Delete failed: {}", e)), cx);return;}};- // 分支(Claude Code 的 fork)是自己完整的对话,不随原件一起删:原件没了它们变回顶层- // 会话,watcher 随即把它们重解析出完整历史(`ref_dependents`)- let mut sessions = vec![meta.clone()];- let kept_branches = if children_outlive_parent(&self.adapters, &meta) {- descendants.len()- } else {- sessions.extend(descendants);- 0- };- let nested_count = sessions.len().saturating_sub(1);- // 每个子会话按自己的胜出 file_path 找 adapter;多 location 下不能沿用- // 根会话所属实例。磁盘目标保持稳定顺序并去重。- let mut seen_targets = HashSet::new();- let mut targets = Vec::new();- for session in &sessions {- let paths = adapter_for(&self.adapters, session.agent, &session.file_path)- .map(|adapter| adapter.session_paths(session))- .unwrap_or_else(|| vec![session.file_path.clone()]);- for path in paths {- if seen_targets.insert(path.clone()) {- targets.push(path);- }- }- }+ let nested_count = plan.sessions.len().saturating_sub(1);+ let kept_branches = plan.kept_branches;// 没有一个目标真在磁盘上 = 会话只活在 agent 自己的库里(OpenCode、Copilot、// Cursor IDE…的虚拟路径 `<db>#<id>`):Wake 不改别家的库,能做的只是不再列出它。// 先前这里照样说"移到废纸篓、随时可还原",两句都不成立- let hide_only = !targets+ let hide_only = !plan+ .targets.iter().any(|path| std::path::Path::new(path).exists());let entity = cx.entity();open_alert(window, cx, 440., move |dialog, _, cx| {let meta = meta.clone();- let sessions = sessions.clone();- let targets = targets.clone();+ let plan = plan.clone();let entity = entity.clone();let theme = cx.theme();// 文件型:说清怎么找回——从废纸篓放回原处,扫描认出它就重新列出@@ -5566,9 +5640,7 @@ impl Workbench {}),).on_ok(move |_, window, cx| {- entity.update(cx, |this, cx| {- this.do_delete(sessions.clone(), targets.clone(), window, cx);- });+ entity.update(cx, |this, cx| this.do_delete(plan.clone(), window, cx));true})});@@ -6616,6 +6688,7 @@ impl Workbench {}cx.notify();}),+ cx.entity(),cx,));}@@ -7274,13 +7347,17 @@ impl Workbench {.into_any_element(),);}- let open_in: AnyElement = if terminal::resume_targets(meta).is_empty() {+ // 放在父会话目录里的子代理不能单独恢复(`resumable`)+ let resume_targets = if wake_core::adapters::resumable(&self.adapters, meta) {+ terminal::resume_targets(meta)+ } else {+ Vec::new()+ };+ let open_in: AnyElement = if resume_targets.is_empty() {// 没有 resume 形制的 agent(OpenClaw 的 TUI 只按 session// key 开会话):不画 Open In,别给一组点了才报错的死按钮div().into_any_element()- } else if let [terminal::ResumeTarget::CopySshCommand] =- terminal::resume_targets(meta).as_slice()- {+ } else if let [terminal::ResumeTarget::CopySshCommand] = resume_targets.as_slice() {// 远程会话(阶段 1 只有 Copy SSH command):单段控件用// 现成 Button,无 chevron 无记忆(split 按钮手搓只因它// 要双段共壳)。本地会话即便只剩一个终端也走 split@@ -7301,7 +7378,7 @@ impl Workbench {// 目标的应用图标,点击直开;右段 chevron 展开列表。// 目标列表按 agent 过滤(Kooky 深链不认 dsh);// 偏好目标不在列表时(如 dsh 会话 + 偏好 Kooky)回退首项- let terms: Vec<terminal::TerminalApp> = terminal::resume_targets(meta)+ let terms: Vec<terminal::TerminalApp> = resume_targets.into_iter().filter_map(|t| match t {terminal::ResumeTarget::App(app) => Some(app),@@ -7492,6 +7569,37 @@ impl Workbench {.child(div().min_w_0().truncate().child(detail_path)).into_any_element(),];+ // 子会话:回到派它的(或它分出来的)那条会话+ if let Some((parent_key, parent_title)) = self+ .detail+ .as_ref()+ .and_then(|detail| detail.parent.clone())+ {+ meta_rows.push(+ h_flex()+ .id("detail-parent")+ .w_full()+ .min_w_0()+ .gap(ICON_TEXT_GAP)+ .items_center()+ .cursor_pointer()+ .hover(|style| style.text_colored(theme.foreground, FONT_LABEL))+ .tooltip(|window, cx| {+ gpui_component::tooltip::Tooltip::new(t("Open parent session"))+ .build(window, cx)+ })+ .on_click(cx.listener(move |this, _, window, cx| {+ this.open_related_session(&parent_key, window, cx);+ }))+ .child(+ icon("icons/corner-left-up.svg")+ .with_size(zpx(12.))+ .flex_shrink_0(),+ )+ .child(div().min_w_0().truncate().child(parent_title))+ .into_any_element(),+ );+ }if self.cleanup.open {meta_rows.push(self.render_cleanup_detail_facts(cx));}@@ -9157,10 +9265,17 @@ fn tool_cluster(arg_cells: usize,expanded: bool,on_toggle: impl Fn(&ClickEvent, &mut Window, &mut App) + 'static,+ workbench: Entity<Workbench>,cx: &App,) -> Div {let theme = cx.theme();let failed = calls.iter().filter(|c| c.is_error).count();+ // 收起时标题行上也给一个入口——只在这一簇恰好派了一个子会话时(派了几个就展开了挑)+ let mut children = calls.iter().filter_map(|c| c.child_id.as_deref());+ let only_child = match (expanded, children.next(), children.next()) {+ (false, Some(id), None) => Some(id.to_string()),+ _ => None,+ };let (head_name, head_arg) = tool_cluster_heading(calls, arg_cells);let mono = theme.mono_font_family.clone();let panel_border = theme.border;@@ -9211,6 +9326,15 @@ fn tool_cluster()}).child(div().flex_1())+ .when_some(only_child, |header, child| {+ header.child(open_child_button(+ ("tool-open-child", ix),+ child,+ workbench.clone(),+ false,+ theme,+ ))+ }).when(failed > 0, |header| {header.child(div()@@ -9274,6 +9398,16 @@ fn tool_cluster();}+ if let Some(id) = call.child_id.clone() {+ item = item.child(h_flex().child(open_child_button(+ SharedString::from(format!("tool-open-child-{ix}-{call_ix}")),+ id,+ workbench.clone(),+ true,+ theme,+ )));+ }+let input = call.input.as_deref().and_then(non_blank_tool_text);if let Some(input) = input {item = item.child(tool_section(@@ -9318,6 +9452,43 @@ fn non_blank_tool_text(text: &str) -> Option<&str> {(!text.trim().is_empty()).then_some(text)}+/// 派活的工具调用 → 它派出去的子会话:详情页打开那条会话,列表同步选中。`with_label` 给展开后+/// 每个调用里那一行;标题行上只放图标(在折叠钮的点击区里,点它不能顺带展开收起)+/// "打开子代理会话":`child` 是子会话的原生 id(与正在看的会话同一家、同一台机器)+fn open_child_button(+ id: impl Into<ElementId>,+ child: String,+ workbench: Entity<Workbench>,+ with_label: bool,+ theme: &gpui_component::Theme,+) -> Stateful<Div> {+ h_flex()+ .id(id)+ .flex_shrink_0()+ .items_center()+ .gap(ICON_TEXT_GAP)+ .h(zpx(20.))+ .px(if with_label { SPACE_SM } else { SPACE_XS })+ .rounded(RADIUS_BADGE)+ .cursor_pointer()+ .text_size(FONT_MSG_THINKING)+ .text_color(theme.muted_foreground)+ .hover(|style| {+ style+ .bg(theme.secondary_hover)+ .text_colored(theme.foreground, FONT_MSG_THINKING)+ })+ .tooltip(|window, cx| {+ gpui_component::tooltip::Tooltip::new(t("Open subagent session")).build(window, cx)+ })+ .on_click(move |_, window, cx| {+ cx.stop_propagation();+ workbench.update(cx, |this, cx| this.open_child_session(&child, window, cx));+ })+ .child(icon("icons/corner-down-right.svg").with_size(zpx(12.)))+ .when(with_label, |this| this.child(t("Open subagent session")))+}+fn tool_section(copy_id: SharedString,label: &'static str,diff --git a/docs/cli.md b/docs/cli.mdindex ecd8360..4e91461 100644--- a/docs/cli.md+++ b/docs/cli.md@@ -64,7 +64,7 @@ wake-cli search -- --dry-run # a query that starts with a dash### `sessions`-The most recently updated sessions. Sub-agents that their agent records as sessions of their own (Codex `spawn_agent`, Grok, OpenCode, DeepSeek Harness and others) are folded into their parents — `show` on the parent lists them by key; Claude Code and Cursor subagent transcripts live inside their session and are read with `show --subagent`; Codex's background threads (auto-review, `/review`, compaction, memory consolidation) are not indexed at all. Archived sessions are excluded. This is what to run when you want the key of "the session from yesterday".+The most recently updated sessions. Sub-agents (Claude Code and Cursor subagents, Codex `spawn_agent`, Grok, OpenCode, DeepSeek Harness and others) are sessions of their own, folded into their parents — `show` on the parent lists them by key; Codex's background threads (auto-review, `/review`, compaction, memory consolidation) are not indexed at all. Archived sessions are excluded. This is what to run when you want the key of "the session from yesterday".Same options as `search`, plus `--starred` (only sessions you starred in Wake). `--limit` defaults to 20, max 100.@@ -85,7 +85,7 @@ One session's transcript, parsed live from the agent's own files, as compact Mar| `--message-chars` | N | truncate each message, default 4000, range 100–50000 || `--tools` | — | include tool inputs and outputs (verbose) || `--thinking` | — | include the assistant's thinking where the agent recorded it |-| `--subagent` | ID | read this subagent transcript instead of the main one; the main transcript lists the ids at its end (at most 30), and `'*'` lists them all |+| `--subagent` | ID | read this subagent transcript instead of the main one; `'*'` lists the ids |`show` also accepts a bare native id (the one the agent's own `--resume` wants) and falls back to looking it up. When the same id exists on more than one host it lists the candidates instead of guessing.diff --git a/docs/mcp.md b/docs/mcp.mdindex 36940c0..14ab610 100644--- a/docs/mcp.md+++ b/docs/mcp.md@@ -150,7 +150,7 @@ Everything above happens locally; Wake itself does not change and the other agen### What it does not do- No write tools: nothing can delete, star, rename or resume a session. Resuming stays in Wake.-- Subagent transcripts that live inside a session (Claude Code sidechains, Cursor subagents) are not merged into the main transcript: `wake_get_session` lists their ids at the end and reads one when it is passed as `subagent`. Sub-agents that their agent records as sessions of their own (Codex `spawn_agent`, Grok) are folded under their parent in `wake_list_sessions`; the parent's `wake_get_session` output lists them by key, and each reads like any other session.+- Sub-agents are not merged into the main transcript. They are sessions of their own, folded under their parent in `wake_list_sessions`; the parent's `wake_get_session` output lists them by key, and each reads like any other session. A subagent transcript that lives in its parent's folder (Claude Code, Cursor, CodeBuddy, Qoder, Kimi Code) can also be read through the parent, by passing its id as `subagent`.- Antigravity conversations with no plain-text transcript on disk (older versions store the body encrypted) are metadata only, so an agent gets the same preview card Wake shows.- Archived Codex sessions appear in search results but not in `wake_list_sessions` or `wake_list_projects`.- Codex's own background threads — the guardian auto-review, `/review`, compaction and memory consolidation that Codex writes into the same `sessions` directory — are not indexed at all: they never show up in search, lists or project counts, and there is no key to read them by. Threads started by `spawn_agent` are the exception: they are work the user asked for, so they are indexed under the session that spawned them, titled with the task name. The turns Codex copies from the parent when it forks a sub-agent are dropped, so the parent's own conversation is only indexed once. After upgrading, rows an older Wake had indexed disappear once Wake itself has rescanned (launch it, or press Refresh); `wake-mcp` only reads the index and never rescans.@@ -224,7 +224,7 @@ One transcript as compact Markdown, parsed live from the agent's files.| `max_message_chars` | integer 100–50000 | 4000 | budget per message, shared by its text, thinking and tool calls; longer content is truncated and marked || `include_tools` | boolean | false | include tool inputs and outputs (verbose) || `include_thinking` | boolean | false | include the assistant's recorded thinking |-| `subagent` | string | | read this subagent transcript instead of the main one; the main transcript lists the ids at its end (at most 30), and `*` lists them all |+| `subagent` | string | | read this subagent transcript instead of the main one; `*` lists the ids |The reply starts with a header (title, key, agent, host, project and branch, model, time range, message count), then one block per message:@@ -238,9 +238,7 @@ inotify queues overflow when …- 🔧 Grep: need_rescan```-Tool calls are folded to one line each (name plus input preview) unless `include_tools` is set; at most 40 tool calls are listed per message, the rest are counted. Injected context (system reminders, IDE context) is skipped and counted. Compaction summaries are kept as quotes. Images are noted, not included. Subagent transcripts (Claude Code sidechains, Cursor subagents) are listed at the end of the main transcript with their ids; pass one as `subagent` to read it, with the same paging options. The footer lists at most 30; `subagent: "*"` returns the full list without a transcript.--Child sessions (sub-agents kept as sessions of their own, such as Codex `spawn_agent`, Grok, OpenCode and DeepSeek Harness) are listed after it, by key — `wake_list_sessions` only returns roots, so the parent is where they are found. A child names its parent in the header line instead.+Tool calls are folded to one line each (name plus input preview) unless `include_tools` is set; at most 40 tool calls are listed per message, the rest are counted. Injected context (system reminders, IDE context) is skipped and counted. Compaction summaries are kept as quotes. Images are noted, not included. Child sessions (sub-agents, such as Claude Code and Cursor subagents, Codex `spawn_agent`, Grok, OpenCode and DeepSeek Harness) are listed after it, by key — `wake_list_sessions` only returns roots, so the parent is where they are found. A child names its parent in the header line instead. Subagent transcripts that live in the parent's folder can also be read through the parent: pass the subagent's id as `subagent`, with the same paging options; `subagent: "*"` lists those ids without a transcript.The footer says which seqs were shown and either `End of transcript.` or a `from_seq=<n>` hint for the next page. Seq numbers are the same ones Wake's own search results and transcript view use.diff --git a/skills/wake/SKILL.md b/skills/wake/SKILL.mdindex fd64f23..c1f3a23 100644--- a/skills/wake/SKILL.md+++ b/skills/wake/SKILL.md@@ -65,12 +65,10 @@ wake-cli show 'claude-code:1b2c3d4e-…'```Add `--tools` for tool inputs and outputs, `--thinking` for recorded reasoning. Both are-verbose — start without them. Work done by subagents (Claude Code sidechains, Cursor-subagents) is not in the main transcript; its ids are listed at the end of the output —-read one with `--subagent ID`, or `--subagent '*'` to list them all. Sub-agents that run-as sessions of their own (Codex `spawn_agent`, Grok, OpenCode, DeepSeek Harness and others)-are listed at the end too, by key; `sessions` only lists parents, so this is where to find-them.+verbose — start without them. Work done by subagents is not in the main transcript: each+subagent is a session of its own, listed at the end of the output by key — `sessions` only+lists parents, so this is where to find them. Claude Code and Cursor subagents can also be+read through the parent with `--subagent ID`, or `--subagent '*'` to list their ids.**Which projects have history**