Skip to content

armgit / Wake

Public Imported from GitHub
0

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

Rust

feat(craft): index Craft Agents sessions and hide their Claude engine copies (#44)

Corey Chiubff990e7acb2
diff --git a/CHANGELOG.md b/CHANGELOG.md
index d89682c..4a786fe 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
# Changelog
+## [Unreleased]
+
+- New: Craft Agents sessions are indexed from its workspaces — titles, models, tool calls and token counts, with archived sessions, sub-tasks and branches, whether the session ran on a Claude connection or on ChatGPT, Copilot or Google. The copy that a Claude connection also leaves in Claude Code's history is hidden while the Craft session exists, so each conversation is listed once. Workspaces kept outside `~/.craft-agent/workspaces` can be added in Settings → Session locations. Read-only, and no Open In (#44, thanks @qiajue)
+
## [0.8.1] — 2026-09-23
- New: `wake-cli refresh` updates an existing index from the terminal, so a scheduled task (launchd, systemd timer) keeps search and session lists fresh while Wake is closed; it steps aside while Wake has its window open, and Wake waits for a running refresh before opening the index (#43, thanks @aka-kika)
diff --git a/PRODUCT.md b/PRODUCT.md
index be25ae3..b6381ec 100644
--- a/PRODUCT.md
+++ b/PRODUCT.md
@@ -28,9 +28,9 @@ 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 趋势图;口径=主线用户消息,规格见 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 方案升级)、恢复/收藏/置顶/导出/删除(废纸篓+墓碑)、文件监听增量、Insights 统计页(0.3.0:活跃热力图与 streak、时段/星期/月份分布、Agents·Projects·Models 三榜单按 sessions/tokens/prompts 切换;2026-09-03 加 Last 7 days 周对比行与 Over time 近 53 周按 agent 堆叠的每周 prompts 趋势图;口径=主线用户消息,规格见 DESIGN.md)、Updates 页与 macOS Wake 菜单手动检查 GitHub 最新正式版并打开 Release 页更新(不后台联网、不自动替换应用包)、测试套件(adapter 契约、DB 往返、scanner 回归 + CI 三平台 + pre-commit,合成 fixture)、三端桌面(macOS 主平台;Linux/Windows experimental,终端恢复/废纸篓·回收站/剪贴板按平台原生实现,发版 CI 自动出六产物)、窗口记忆(0.3.6:记住所在屏幕/屏内位置/最大化/全屏,重启与 Dock 重开都回到原处,Settings 开在主窗所在屏)、完整 macOS 菜单栏(0.3.6:标准 Edit/Window 菜单、⌘W、Window → Main Window,主窗关闭后 About/Settings/Updates 仍可用)、导出 Markdown 与保存图片走系统「另存为」并记住上次目录(0.3.6,issue #25)、远程 host(0.4.0,issue #21:Settings → Remote hosts 配 SSH 目标,rsync 白名单镜像会话数据到本地缓存后与本地会话同列同搜,`@host` 徽章标识;阶段 1 只读——不动远端文件、远程会话禁删,resume 以 Copy SSH command 形态提供;分期计划见 CLAUDE.md「远程 host」节)、**MCP 接入**(0.5.0:随应用打包的只读 `wake-mcp` stdio server,四个工具 wake_search / wake_list_sessions / wake_get_session / wake_list_projects,Claude Code / Codex / Cursor 等任何 MCP 客户端可搜历史、按项目列会话、分页读转录;Settings → Connect 展示路径与可复制配置片段,只展示不代写别家配置;零 LLM、零网络、不写库;完整参考 docs/mcp.md)、**命令行与 Skill**(0.6.0:并排打包的只读 `wake-cli`,四个子命令 search / sessions / show / projects 加 setup,给"能跑 shell 但不说 MCP"的 agent 和真人用——它不新写查询逻辑,argv 翻成 JSON 喂同一批工具,输出与 MCP 客户端看到的**逐字节相同**(仅 CLI 末尾补一个换行)并由测试卡住,所以文档只需描述一份格式;`skills/wake/SKILL.md` 是可一行安装的 skill(`npx skills add iAmCorey/Wake`),用触发条件而非名词解释写 description,让 agent 自己想得起来去翻会话历史;完整参考 docs/cli.md;0.6.3 加 `wake-cli index`——装了 Wake 却从没启动过时,agent 自己跑一条就能把索引建起来继续干活,而不是停下来问人。它**只建不存在的索引**,已有的库原样交给 GUI:扫描落在旁边的临时库、扫完才原子占位,所以被中途杀掉可重试、撞上 GUI 首扫就退让;2026-09-22 加 `wake-cli refresh`,issue #43:app 不开时增量刷新已有索引,给靠 MCP / CLI 用 Wake、只在浏览时开 app 的人用 launch agent / systemd timer 定时跑,Wake 开着窗或还有扫描在写就退让——GUI 与两个写命令共用一把索引写锁,锁跟 Workbench 与写线程走、关窗即放,GUI 启动会等正在跑的 refresh 收尾)、Connect 页四区块(0.6.1:MCP server / MCP clients / Command line / Skill,每个面的第一块挂自己的文档链接)、**记忆可见层**(2026-09-17 起,只读:把各家 agent 自己写下的记忆——Claude Code 的按项目 auto-memory、Codex 的 memories 与逐会话摘要、ZCode 的按项目记忆——按项目聚合;GUI 的 Memory 页是侧栏底部的整页目的地,侧栏在这一页换成按记忆计数的 All Memory / Agents / Projects 导航;MCP 加第五个工具 `wake_list_memories`,`wake_get_session` 认 `wake://memory/…` 引用现场读文件,`wake_search` 末尾附记忆命中;CLI 加 `memories`;记忆的项目归属按它挂的会话在读时解析,永远跟着索引走。二期(2026-09-21)把用户写给 agent 的指令文件也收进来:各家 home 里的 CLAUDE.md / AGENTS.md(与 `rules/*.rules`)/ GEMINI.md,以及已索引项目根下的 CLAUDE.md / AGENTS.md / GEMINI.md / `.cursor/rules` / `.cursorrules` / `.kiro/steering` / `.github/copilot-instructions.md`,与记忆同列同搜、不另作区分;Settings 加 Memory locations 页,与 Session locations 同形制:逐来源开关、添加自定义目录或文件、Restore defaults。不编辑、不同步、不删除——写别家数据破铁律,要改一个 Reveal 就到;也不做"把会话自动写成记忆")。后续边界(2026-09-07 定):摘要层(需 LLM、opt-in、明示会把会话正文发给用户配置的端点)只在 MCP 接入有真实使用之后再做;Timeline / Profile 一类视图建立在摘要之上;不做 ChatGPT / Claude.ai 导出导入主线、不做实体本体与知识图谱、不做 Chrome 扩展注入。
约束:对 agent 数据目录只读;绝不写 Codex 的 SQLite;不读凭证;GPUI 无 SF Symbols(图标用 lucide SVG 自备)。
-已支持十九家 agent:Claude Code、Codex(0.6.6 起排除可识别的内部线程:guardian auto-review、`/review`、compaction、memory consolidation 与用户会话同树,adapter 文件边界按首行 session_meta 的 source / thread_source 认出即不枚举;老格式或读不出的首行保守放行,`codex exec --thread-source` 打了标签的自动化线程照常收录,issue #30。`spawn_agent` 子代理是其中唯一的例外,issue #42:那是用户自己派出去的活,收录后挂在派它的会话下面、以任务名为标题,fork 进来的父线程历史折成一条不入库的占位,父会话的对话不会被索引两遍)、Qoder CLI(`~/.qoder/projects` JSONL,active-leaf 分支恢复、tool result 回挂、`QODER_CONFIG_DIR`)、Copilot CLI、Cursor(CLI 转录 + 0.6.7 起 IDE Chat/Composer 历史,PR #32:`globalStorage/state.vscdb` 明文 KV 库,composerData 给顺序、bubbleId 行给正文;转录带正文的会话归转录源,库只补转录缺失或只剩 turn_ended 空壳的会话;库里多数老会话没存工作区路径,落 Unknown project)、OpenCode(含 OpenCode 2 next,stable 的 `opencode.db` 与 next 的 `opencode-next.db` 同时扫描;逐会话兼容 `message+part`、真实 `session+session_message` 及早期 `session_v2` schema;preview 会话标 opencode2 徽章)、Kiro、Gemini CLI(2026-08-17 P1 五家落地)+ Pi、Oh My Pi、Grok Build、Kimi Code、Antigravity CLI(2026-08-19 对齐 kooky 内置 roster;Antigravity 正文加密仅元数据卡片)+ DeepSeek Harness(dsh,2026-08-20,zstd 事件日志透明解压;格式由源码推断,当天用户跑出真实会话完成首验)+ Hermes Agent(2026-09-03,多档案 state.db,无 cwd 故 project 留空)、OpenClaw(2026-09-03,两代存储同扫;本机零会话,格式由源码推断未经真机验证)、CodeBuddy(2026-09-14,issue #27:`~/.codebuddy/projects` 的 Responses 形 JSONL,custom / ai / topic 三级标题,`CODEBUDDY_CONFIG_DIR`;本机零会话,格式由官方 CLI 文档与三家第三方实现交叉推断、未经真机验证)、WorkBuddy(同日,CodeBuddy 的孪生实例:同一解析核心,`~/.workbuddy/projects`、`WORKBUDDY_CONFIG_DIR`;桌面 app 无 CLI,不提供 resume;同构只有 cc-switch 一家佐证)、ZCode(2026-09-21:Z.ai 的 GLM-5.3 官方 harness,桌面 app;运行时是 OpenCode 衍生物——`~/.zcode/cli/db/db.sqlite` 的 session/message/part 与 OpenCode v1 同形、part 解码复用,但 session 表没有 model/tokens 列故另起一家;`v2/tasks-index.sqlite` 只借 deleted / migration_source 两个过滤位;按 `task_type` 白名单只列 interactive / fork / selection_side_chat(subagent_child 等运行时会话不列);`semantics.transcriptVisibility == hidden` 与用户消息 `origin != real_user` 归 Meta、compact_summary 折成一条、字段缺席放行;`ZCODE_STORAGE_DIR`;桌面 app 无 CLI、`zcode://` 没有按会话打开的深链,不提供 resume;本机 3.14.0 真会话首验通过,同日开源(Apache-2.0)后语义全部按源码核对)。做不了的:Windsurf/Trae 加密,Amp/Factory(Droid)/Warp 云端无本地数据,Reasonix 本机零会话格式未实测。
+已支持二十家 agent:Claude Code、Codex(0.6.6 起排除可识别的内部线程:guardian auto-review、`/review`、compaction、memory consolidation 与用户会话同树,adapter 文件边界按首行 session_meta 的 source / thread_source 认出即不枚举;老格式或读不出的首行保守放行,`codex exec --thread-source` 打了标签的自动化线程照常收录,issue #30。`spawn_agent` 子代理是其中唯一的例外,issue #42:那是用户自己派出去的活,收录后挂在派它的会话下面、以任务名为标题,fork 进来的父线程历史折成一条不入库的占位,父会话的对话不会被索引两遍)、Qoder CLI(`~/.qoder/projects` JSONL,active-leaf 分支恢复、tool result 回挂、`QODER_CONFIG_DIR`)、Copilot CLI、Cursor(CLI 转录 + 0.6.7 起 IDE Chat/Composer 历史,PR #32:`globalStorage/state.vscdb` 明文 KV 库,composerData 给顺序、bubbleId 行给正文;转录带正文的会话归转录源,库只补转录缺失或只剩 turn_ended 空壳的会话;库里多数老会话没存工作区路径,落 Unknown project)、OpenCode(含 OpenCode 2 next,stable 的 `opencode.db` 与 next 的 `opencode-next.db` 同时扫描;逐会话兼容 `message+part`、真实 `session+session_message` 及早期 `session_v2` schema;preview 会话标 opencode2 徽章)、Kiro、Gemini CLI(2026-08-17 P1 五家落地)+ Pi、Oh My Pi、Grok Build、Kimi Code、Antigravity CLI(2026-08-19 对齐 kooky 内置 roster;Antigravity 正文加密仅元数据卡片)+ DeepSeek Harness(dsh,2026-08-20,zstd 事件日志透明解压;格式由源码推断,当天用户跑出真实会话完成首验)+ Hermes Agent(2026-09-03,多档案 state.db,无 cwd 故 project 留空)、OpenClaw(2026-09-03,两代存储同扫;本机零会话,格式由源码推断未经真机验证)、CodeBuddy(2026-09-14,issue #27:`~/.codebuddy/projects` 的 Responses 形 JSONL,custom / ai / topic 三级标题,`CODEBUDDY_CONFIG_DIR`;本机零会话,格式由官方 CLI 文档与三家第三方实现交叉推断、未经真机验证)、WorkBuddy(同日,CodeBuddy 的孪生实例:同一解析核心,`~/.workbuddy/projects`、`WORKBUDDY_CONFIG_DIR`;桌面 app 无 CLI,不提供 resume;同构只有 cc-switch 一家佐证)、ZCode(2026-09-21:Z.ai 的 GLM-5.3 官方 harness,桌面 app;运行时是 OpenCode 衍生物——`~/.zcode/cli/db/db.sqlite` 的 session/message/part 与 OpenCode v1 同形、part 解码复用,但 session 表没有 model/tokens 列故另起一家;`v2/tasks-index.sqlite` 只借 deleted / migration_source 两个过滤位;按 `task_type` 白名单只列 interactive / fork / selection_side_chat(subagent_child 等运行时会话不列);`semantics.transcriptVisibility == hidden` 与用户消息 `origin != real_user` 归 Meta、compact_summary 折成一条、字段缺席放行;`ZCODE_STORAGE_DIR`;桌面 app 无 CLI、`zcode://` 没有按会话打开的深链,不提供 resume;本机 3.14.0 真会话首验通过,同日开源(Apache-2.0)后语义全部按源码核对)、Craft Agents(2026-09-24,issue #44:Craft Docs 的开源桌面 app,自己不带引擎——Anthropic 连接跑 Claude Agent SDK、其余连接(ChatGPT / Codex 订阅、Copilot、Google)跑 Pi SDK,另记一份给用户看的 `~/.craft-agent/workspaces/<工作区>/sessions/<id>/session.jsonl`,Wake 读这一份;子任务与分支挂回原会话,分支从父会话复制来的那段折成一条;Claude 连接在 `~/.claude/projects` 留下的引擎副本由通用的"认领"机制藏掉,原件还在才藏;工作区可建在任意位置,但登记表带 server token 不读,别处的工作区走 Session locations;桌面 app 无 CLI,不提供 resume;本机 0.13.5 真会话首验通过,ChatGPT 与 Claude 连接各一条)。做不了的:Windsurf/Trae 加密,Amp/Factory(Droid)/Warp 云端无本地数据,Reasonix 本机零会话格式未实测。
## Brand Commitments
diff --git a/README.md b/README.md
index 5112317..61cd39d 100644
--- a/README.md
+++ b/README.md
@@ -51,8 +51,11 @@ Your agent history is scattered across `~/.claude`, `~/.codex`, and a dozen othe
| CodeBuddy | `~/.codebuddy/projects/*/*.jsonl` (`CODEBUDDY_CONFIG_DIR` is respected) | ✅ | — |
| WorkBuddy | `~/.workbuddy/projects/*/*.jsonl` (`WORKBUDDY_CONFIG_DIR` is respected; desktop app, so no resume) | ✅ | — |
| ZCode | `~/.zcode/cli/db/db.sqlite` + `v2/tasks-index.sqlite` (read-only; `ZCODE_STORAGE_DIR` is respected; desktop app, so no resume) | ✅ | — |
+| Craft Agents | `~/.craft-agent/workspaces/*/sessions/*/session.jsonl` (workspaces kept elsewhere can be added under Session locations; desktop app, so no resume) | ✅ | ✅ |
-**Model** = whether Wake shows which LLM a session used (the model the session last used). **Via** = whether Wake shows where the session was started from (CLI, IDE extension, desktop app) — Codex records this in its local data; Hermes and OpenClaw record the channel a session came in through (Telegram, Discord, …). A "—" means the agent's local data simply doesn't record that field, not a missing feature.
+**Model** = whether Wake shows which LLM a session used (the model the session last used). **Via** = whether Wake shows where the session was started from (CLI, IDE extension, desktop app) — Codex records this in its local data; Hermes and OpenClaw record the channel a session came in through (Telegram, Discord, …); Craft Agents marks sessions its automations started. A "—" means the agent's local data simply doesn't record that field, not a missing feature.
+
+Craft Agents runs other agents' engines rather than its own: a Claude connection drives the Claude Agent SDK, which also saves every conversation into Claude Code's history. Wake lists the Craft session and hides that engine copy for as long as the Craft session exists — delete the session in Craft and the copy shows up again as a Claude Code session. Craft's short title-generation calls on a Claude connection are saved by the SDK too, and appear as one-message Claude Code sessions under *Unknown project*.
Codex writes its background threads — the guardian auto-review, `/review`, compaction and memory consolidation — into the same `sessions` directory as your conversations. Wake recognises them from the metadata on their first line and skips them; sub-agents you start with `spawn_agent` are kept and listed under the session that spawned them; a file it cannot identify stays visible rather than risk hiding a real conversation.
diff --git a/crates/wake-core/src/adapters/codex.rs b/crates/wake-core/src/adapters/codex.rs
index 20ff84a..e7ff743 100644
--- a/crates/wake-core/src/adapters/codex.rs
+++ b/crates/wake-core/src/adapters/codex.rs
@@ -837,7 +837,9 @@ fn parse_rollout(path: &Path, decode_images: bool) -> Result<CodexParse> {
// 它一非空就会在 has_real 为假时被选中,一条标记足以把子线程自己的
// response_item 整条流挤掉(只跑了工具、还没出正文的子代理正是这形态)
if let Some((cut, cut_fallback)) = inherited {
- collapse_inherited(&mut messages, cut);
+ // fork_turns 复制进来的父线程历史(实测复制的是真实 message 行,不是打包成
+ // 一条的 "Codex agent history" 块,`is_injected_user_content` 拦不住)
+ collapse_inherited(&mut messages, cut, "thread");
event_fallback.drain(..cut_fallback.min(event_fallback.len()));
}
@@ -868,33 +870,6 @@ fn parse_rollout(path: &Path, decode_images: bool) -> Result<CodexParse> {
})
}
-/// `spawn_agent` 的 `fork_turns` 会把父线程的历史逐条复制进子线程的 rollout
-/// (实测 `fork_turns:"all"` 复制的是真实 message 行,不是打包成一条的
-/// "Codex agent history" 块,`is_injected_user_content` 拦不住)。原样入库
-/// 就是:子线程偷走父线程的标题、父线程每一轮在 FTS 里出现两次、Insights
-/// 的 prompt 数翻倍。折成一条 Meta——Meta 不进 FTS、不算 message_count、
-/// 不参与标题推导,GUI / 导出 / MCP 也都跳过它——留一条而不是整段删掉,
-/// 是为了"这里原本有东西"不至于无声消失;内容本体就在上一层的父会话里。
-fn collapse_inherited(messages: &mut Vec<TranscriptMessage>, cut: usize) {
- if cut == 0 {
- return;
- }
- let turns = messages[..cut]
- .iter()
- .filter(|m| m.kind == MessageKind::Text)
- .count();
- let ts = messages[..cut]
- .iter()
- .find_map(|m| m.timestamp)
- .unwrap_or_default();
- let text = format!(
- "── {turns} message{} inherited from the parent thread ──",
- crate::text::plural(turns as i64)
- );
- let marker = mk_msg(Role::System, MessageKind::Meta, &text, ts);
- messages.splice(..cut, std::iter::once(marker));
-}
-
/// Codex Desktop 会把文件清单包在真实提问外面,并在正文写入指向临时文件
/// 的 `<image ...>` 标签;图片本体由独立内容块承载。
fn clean_user_text(text: &str) -> String {
diff --git a/crates/wake-core/src/adapters/craft.rs b/crates/wake-core/src/adapters/craft.rs
new file mode 100644
index 0000000..3af27cf
--- /dev/null
+++ b/crates/wake-core/src/adapters/craft.rs
@@ -0,0 +1,715 @@
+use super::parse_utils::*;
+use super::AgentAdapter;
+use crate::models::*;
+use anyhow::{Context as _, Result};
+use serde_json::Value;
+use std::collections::HashMap;
+use std::fs;
+use std::io::{self, BufRead, BufReader};
+use std::path::{Path, PathBuf};
+use std::sync::Mutex;
+
+/// Craft Agents(craft-ai-agents/craft-agents-oss,Craft Docs 出的开源桌面 app;
+/// 2026-09-24 按 v0.13.5 源码落地、真机两条会话核对,issue #44)。它自己不带 agent
+/// 引擎:Anthropic 连接跑 Claude Agent SDK(无头 Claude Code,用的是用户真实的
+/// `~/.claude`),其余连接(ChatGPT / Codex 订阅、Copilot、Google、OpenAI key…)跑
+/// Pi SDK;Craft 在引擎之上另记一份给用户看的会话,Wake 读的就是这一份。
+///
+/// 布局:`<工作区>/sessions/<id>/session.jsonl`,默认工作区在
+/// `~/.craft-agent/workspaces/<slug>/`。工作区可以建在磁盘任意位置(Obsidian 式,
+/// 文件夹即工作区),登记在全局 `~/.craft-agent/config.json`——那个文件存着 server
+/// token 与远程工作区 token,**不读**;别处的工作区由用户在 Session locations 里加
+/// (根可以选工作区集合、单个工作区或 `.craft-agent` 本身)。
+///
+/// 首行 SessionHeader(name 是 AI 起的或用户改的标题,preview 是首条提问,
+/// workingDirectory 是用户设的项目目录,sdkSessionId 是引擎那份转录的 id…),其余每行
+/// 一条 StoredMessage:`type` ∈ user / assistant / tool / plan / info / error /
+/// warning / auth-request;工具调用一行自带 toolInput 与 toolResult;不落 thinking。
+/// 会话目录里的路径在盘上写成 `{{SESSION_PATH}}` 占位,读时展开。整文件重写
+/// (写 .tmp → **先 unlink 正本** → rename)。会话 id(`YYMMDD-形容词-名词`)只在工作区
+/// 内唯一,native id 因此带工作区命名空间:`<工作区 config.json 的 id>/<会话目录>`
+/// (见 workspace_ns)。
+///
+/// 引擎的原料不读:Pi 的写在会话目录里的 `.pi-sessions/`(Wake 的 Pi adapter 不扫那里);
+/// Claude 的那份落在 `~/.claude/projects/<sdkCwd>/<sdkSessionId>.jsonl`、被 Claude
+/// adapter 收成一条 Claude Code 会话——由 `claimed_sessions` 认领掉,同一段对话只列一次
+pub struct CraftAdapter {
+ /// 工作区集合(默认 `~/.craft-agent/workspaces`)或单个工作区
+ root: PathBuf,
+ heads: HeadCache,
+ workspaces: WorkspaceIds,
+}
+
+impl CraftAdapter {
+ pub fn new() -> Self {
+ Self::at(
+ super::home_dir()
+ .unwrap_or_default()
+ .join(".craft-agent")
+ .join("workspaces"),
+ )
+ }
+
+ fn at(root: PathBuf) -> Self {
+ Self {
+ root,
+ heads: HeadCache::default(),
+ workspaces: WorkspaceIds::default(),
+ }
+ }
+
+ /// 根下每个会话目录的 session.jsonl 路径(含隐藏会话——列表过滤在 file_ref,认领要看
+ /// 全部;文件在不在交给调用方那一次 stat),顺带把首行缓存收成只剩这些路径。根是工作区
+ /// 集合时会话在 `<根>/<工作区>/sessions/*`,是单个工作区时在 `<根>/sessions/*`,两种
+ /// 形态都走一遍:错位的那一层没有 sessions/,NotFound 自然跳过。第二项为 false = 有目录
+ /// 在却读不出来:枚举照用读到的那些,父子关系与认领的快照则不能当完整的交出去
+ fn session_files(&self) -> (Vec<PathBuf>, bool) {
+ let mut complete = true;
+ let mut subdirs = |dir: &Path| -> Vec<PathBuf> {
+ match fs::read_dir(dir) {
+ Ok(entries) => entries
+ .flatten()
+ .filter(|e| e.file_type().is_ok_and(|t| t.is_dir()))
+ .map(|e| e.path())
+ .collect(),
+ Err(e) => {
+ complete &= matches!(
+ e.kind(),
+ io::ErrorKind::NotFound | io::ErrorKind::NotADirectory
+ );
+ Vec::new()
+ }
+ }
+ };
+ let mut workspaces = vec![self.root.clone()];
+ workspaces.extend(subdirs(&self.root));
+ let mut files: Vec<PathBuf> = workspaces
+ .iter()
+ .flat_map(|workspace| subdirs(&workspace.join("sessions")))
+ .map(|session| session.join(SESSION_FILE))
+ .collect();
+ files.sort();
+ self.heads.retain_only(&files);
+ (files, complete)
+ }
+
+ /// 全部会话的首行摘要(父子关系与认领用)。**`None` = 这一刻有东西读不出来、又没有
+ /// 上次读到的可顶**:拿缺一块的快照去对账,那块的认领会被撤掉、父子关系会被当成解除。
+ /// 首行本身写坏了(craft 自己也列不出这种会话)才算没有
+ fn all_heads(&self) -> Option<Vec<(PathBuf, Head)>> {
+ let (files, complete) = self.session_files();
+ if !complete {
+ return None;
+ }
+ let mut heads = Vec::with_capacity(files.len());
+ for path in files {
+ let head = fs::metadata(&path)
+ .and_then(|meta| self.heads.get(&path, mtime_ms(&meta), meta.len() as i64));
+ match head {
+ Ok(Some(head)) => heads.push((path, head)),
+ Ok(None) => {}
+ // 读不出来(含 craft 原子写"先删正本、再把 .tmp 改名过来"的那个空档)沿用上次
+ // 读到的;没读过的,文件不在就当它还没有,别的错误才是真不知道
+ Err(e) => match self.heads.last(&path) {
+ Some(head) => heads.push((path, head)),
+ None if e.kind() == io::ErrorKind::NotFound => {}
+ None => return None,
+ },
+ }
+ }
+ Some(heads)
+ }
+
+ /// 工作区在会话 key 里的命名空间:它自己 config.json 里的 `id`(craft 建工作区时随机
+ /// 生成,改名、挪位置都不变;整个工作区备份一份,备份里的会话仍算同一条)。不用目录名:
+ /// 会话 id 只在工作区内唯一,两个同名文件夹的工作区同一天生成同一个 id 就撞 key,被当成
+ /// 副本吞掉一条。没有 config.json(craft 自己都不认它是工作区)或里面没有 id,退回目录名;
+ /// config.json 在却读不出来,沿用上次读到的,没读过给 None——别拿目录名顶,key 一换就是
+ /// 另一条会话(craft 写 config.json 是 tmp + rename,正常不会读到半截)
+ fn workspace_ns(&self, workspace_dir: &Path) -> Option<String> {
+ let dir_name = || Some(workspace_dir.file_name()?.to_string_lossy().to_string());
+ let config = workspace_dir.join("config.json");
+ let mut cache = self.workspaces.0.lock().unwrap();
+ let last = cache.get(workspace_dir).cloned();
+ let stamp = match fs::metadata(&config) {
+ Ok(meta) => (mtime_ms(&meta), meta.len() as i64),
+ Err(e) if e.kind() == io::ErrorKind::NotFound => return dir_name(),
+ Err(_) => return last.map(|(_, ns)| ns),
+ };
+ if let Some((_, ns)) = last.as_ref().filter(|(cached, _)| *cached == stamp) {
+ return Some(ns.clone());
+ }
+ let Some(config) = fs::read_to_string(&config)
+ .ok()
+ .and_then(|raw| serde_json::from_str::<Value>(&raw).ok())
+ else {
+ return last.map(|(_, ns)| ns);
+ };
+ let ns = str_at(&config, "id")
+ .map(str::to_string)
+ .or_else(dir_name)?;
+ cache.insert(workspace_dir.to_path_buf(), (stamp, ns.clone()));
+ Some(ns)
+ }
+
+ /// 会话文件 → native id;不是 `<工作区>/sessions/<会话>/session.jsonl` 形状、或工作区 id
+ /// 这一刻读不出来,给 None
+ fn native_id_of(&self, session_file: &Path) -> Option<String> {
+ let session_dir = session_file.parent()?;
+ let sessions_dir = session_dir.parent()?;
+ if sessions_dir.file_name()? != "sessions" {
+ return None;
+ }
+ let ns = self.workspace_ns(sessions_dir.parent()?)?;
+ Some(native_id(&ns, &session_dir.file_name()?.to_string_lossy()))
+ }
+}
+
+/// 入库前的自定义根归一化(`adapters::normalize_custom_root` 按 agent 分派到这里):
+/// 目录选择器里选中的是某个工作区的 `sessions/` 就上提到工作区——那一层下面的
+/// `<会话>/session.jsonl` 两种枚举形态都够不着。自己底下还有 `sessions/` 的,说明
+/// 它本身就是个叫 sessions 的工作区,不动
+pub fn normalize_custom_root(dir: PathBuf) -> PathBuf {
+ let is_sessions_dir =
+ dir.file_name().is_some_and(|n| n == "sessions") && !dir.join("sessions").is_dir();
+ match dir.parent() {
+ Some(workspace) if is_sessions_dir => workspace.to_path_buf(),
+ _ => dir,
+ }
+}
+
+const SESSION_FILE: &str = "session.jsonl";
+/// 盘上写成占位的会话目录(craft `makeSessionPathPortable`),读时换回真实路径
+const SESSION_PATH_TOKEN: &str = "{{SESSION_PATH}}";
+/// Claude 后端的回合锚点边车:Craft 的助手消息 id → 它所在的引擎会话
+const CLAUDE_ANCHORS: &str = "meta/claude-turn-anchors.json";
+
+/// native id = `<工作区命名空间>/<会话目录>`(见 workspace_ns)。`:` 是会话 key 的分段符、
+/// `/` 分开两段,出现在各段里就换掉。会话自己与 parent_links 里的父会话都经这里拼——两端
+/// 差一个字符父子关系就静默对不上
+fn native_id(ns: &str, session: &str) -> String {
+ format!(
+ "{}/{}",
+ ns.replace([':', '/'], "_"),
+ session.replace([':', '/'], "_")
+ )
+}
+
+fn workspace_dir_of(session_file: &Path) -> Option<&Path> {
+ session_file.parent()?.parent()?.parent()
+}
+
+fn session_key_of(native: &str) -> String {
+ session_key(AgentId::CraftAgents, "", native)
+}
+
+/// 首行里枚举、父子关系与认领要用的几项(缓存单位)
+#[derive(Clone)]
+struct Head {
+ /// 不进列表:mini 编辑会话(hidden)与看板上还没领养的任务草稿(taskDraft)
+ hidden: bool,
+ /// 同工作区的父会话目录名:spawn_session 派出的子任务(parentSessionId),
+ /// 或分支的来源(branchFromSessionPath 的末段)
+ parent: Option<String>,
+ /// 这条会话在 Claude 引擎那边的转录 id(Pi 后端的会话没有)
+ claude_ids: Vec<String>,
+}
+
+fn str_at<'a>(v: &'a Value, key: &str) -> Option<&'a str> {
+ v.get(key)
+ .and_then(Value::as_str)
+ .map(str::trim)
+ .filter(|s| !s.is_empty())
+}
+
+fn true_at(v: &Value, key: &str) -> bool {
+ v.get(key).and_then(Value::as_bool) == Some(true)
+}
+
+/// 首行 header。消息行都带 `type`,header 没有——拿它区分。`Ok(None)` = 首行不是 header
+/// (写坏了,craft 自己也列不出这种会话);打不开、读出错是 `Err`——那是"这一刻不知道"
+fn read_header(path: &Path) -> io::Result<Option<Value>> {
+ let mut line = String::new();
+ BufReader::with_capacity(16 << 10, fs::File::open(path)?).read_line(&mut line)?;
+ Ok(parse_header(&line))
+}
+
+fn parse_header(line: &str) -> Option<Value> {
+ let v: Value = serde_json::from_str(line.trim_end()).ok()?;
+ (v.is_object() && v.get("type").is_none()).then_some(v)
+}
+
+fn is_pi_model(header: &Value) -> bool {
+ str_at(header, "model").is_some_and(|m| m.starts_with("pi/"))
+}
+
+fn head_of(path: &Path, header: &Value) -> io::Result<Head> {
+ let parent = str_at(header, "parentSessionId")
+ .map(str::to_string)
+ .or_else(|| {
+ str_at(header, "branchFromSessionPath").and_then(|p| {
+ // 绝对路径(craft 不把它转成 ~ 形态);两种分隔符都认
+ p.rsplit(['/', '\\'])
+ .find(|s| !s.is_empty())
+ .map(str::to_string)
+ })
+ });
+ let mut claude_ids = Vec::new();
+ // Pi 后端的 sdkSessionId 是 Pi 自己的会话 id,认领它只会往表里塞永远对不上的 key
+ if !is_pi_model(header) {
+ claude_ids.extend(str_at(header, "sdkSessionId").map(str::to_string));
+ // 回合锚点记着每条助手消息实际落在哪份引擎转录里:续跑或恢复换过 SDK 会话时,
+ // 旧的那份照样装着这条会话的对话。没有边车、边车写坏了就只认 header 里当前那份;
+ // 读出错往上报(不知道)。与 header 重复的 id 在 claimed_sessions 里去重
+ let anchors = match path
+ .parent()
+ .map(|dir| fs::read_to_string(dir.join(CLAUDE_ANCHORS)))
+ {
+ Some(Ok(raw)) => serde_json::from_str::<Value>(&raw).ok(),
+ Some(Err(e)) if e.kind() != io::ErrorKind::NotFound => return Err(e),
+ _ => None,
+ };
+ claude_ids.extend(
+ anchors
+ .iter()
+ .filter_map(|a| a.get("anchors")?.as_object())
+ .flat_map(|m| m.values())
+ .filter_map(|record| str_at(record, "sdkSessionId"))
+ .map(str::to_string),
+ );
+ }
+ Ok(Head {
+ hidden: true_at(header, "hidden") || true_at(header, "taskDraft"),
+ parent,
+ claude_ids,
+ })
+}
+
+/// 首行摘要按 (session.jsonl 的 mtime、size, 锚点边车的 mtime) 缓存:每轮扫描、每批
+/// watcher 事件都要把全部会话的首行过一遍(列表过滤、父子关系、认领),文件没变
+/// 就不再打开
+#[derive(Default)]
+struct HeadCache(Mutex<HashMap<PathBuf, ((i64, i64, i64), Head)>>);
+
+impl HeadCache {
+ /// `mtime` / `size` 是调用方已经 stat 过的 session.jsonl。`Ok(None)` = 首行不是 header
+ fn get(&self, path: &Path, mtime: i64, size: i64) -> io::Result<Option<Head>> {
+ let anchors_mtime = path
+ .parent()
+ .and_then(|dir| fs::metadata(dir.join(CLAUDE_ANCHORS)).ok())
+ .map(|m| mtime_ms(&m))
+ .unwrap_or(0);
+ let stamp = (mtime, size, anchors_mtime);
+ if let Some((cached, head)) = self.0.lock().unwrap().get(path) {
+ if *cached == stamp {
+ return Ok(Some(head.clone()));
+ }
+ }
+ let Some(header) = read_header(path)? else {
+ return Ok(None);
+ };
+ let head = head_of(path, &header)?;
+ self.0
+ .lock()
+ .unwrap()
+ .insert(path.to_path_buf(), (stamp, head.clone()));
+ Ok(Some(head))
+ }
+
+ /// 上次读到的(不管文件后来变没变):这一刻读不出来时顶上
+ fn last(&self, path: &Path) -> Option<Head> {
+ self.0
+ .lock()
+ .unwrap()
+ .get(path)
+ .map(|(_, head)| head.clone())
+ }
+
+ /// 缓存只留这次枚举到的会话文件(删掉的会话不再占着)
+ fn retain_only(&self, files: &[PathBuf]) {
+ let live: std::collections::HashSet<&Path> = files.iter().map(PathBuf::as_path).collect();
+ self.0
+ .lock()
+ .unwrap()
+ .retain(|p, _| live.contains(p.as_path()));
+ }
+}
+
+/// 工作区命名空间(workspace_ns)按工作区目录缓存,戳是它 config.json 的 (mtime, size):
+/// 每个会话的 key 都要问一次,工作区只有几个
+#[derive(Default)]
+struct WorkspaceIds(Mutex<HashMap<PathBuf, ((i64, i64), String)>>);
+
+/// JSON 值里所有字符串中的 `{{SESSION_PATH}}` 换回会话目录。解析之后再换:
+/// Windows 路径里的反斜杠直接塞进 JSON 文本会破坏转义
+fn expand_session_path(v: &mut Value, dir: &str) {
+ match v {
+ Value::String(s) if s.contains(SESSION_PATH_TOKEN) => {
+ *s = s.replace(SESSION_PATH_TOKEN, dir);
+ }
+ Value::Array(items) => items.iter_mut().for_each(|i| expand_session_path(i, dir)),
+ Value::Object(map) => map.values_mut().for_each(|i| expand_session_path(i, dir)),
+ _ => {}
+ }
+}
+
+struct CraftParse {
+ header: Value,
+ messages: Vec<TranscriptMessage>,
+ last_ts: i64,
+ unknown_lines: u32,
+}
+
+/// 用户消息正文:原话 + 附件名(与 craft 递给模型的 `[Attached file: …]` 同一写法)
+fn user_text(row: &Value) -> String {
+ let mut text = str_at(row, "content").unwrap_or_default().to_string();
+ for name in row
+ .get("attachments")
+ .and_then(Value::as_array)
+ .into_iter()
+ .flatten()
+ .filter_map(|a| str_at(a, "name"))
+ {
+ if !text.is_empty() {
+ text.push('\n');
+ }
+ text.push_str(&format!("[Attached file: {name}]"));
+ }
+ text
+}
+
+fn tool_view(row: &Value) -> ToolCallView {
+ let id = str_at(row, "toolUseId")
+ .or_else(|| str_at(row, "id"))
+ .unwrap_or_default()
+ .to_string();
+ let input = row.get("toolInput").cloned().unwrap_or(Value::Null);
+ let output = str_at(row, "toolResult").map(str::to_string);
+ // craft 对没显式标错、但以 [ERROR] / Error: 开头的结果也记成 error 状态
+ let is_error = true_at(row, "isError") || str_at(row, "toolStatus") == Some("error");
+ tool_call_view(
+ id,
+ str_at(row, "toolName").unwrap_or_default(),
+ &input,
+ output,
+ is_error,
+ )
+}
+
+fn meta_msg(text: &str, ts: i64) -> TranscriptMessage {
+ let mut m = text_msg(Role::System, text, ts);
+ m.kind = MessageKind::Meta;
+ m
+}
+
+fn parse_file(path: &Path) -> Result<CraftParse> {
+ let raw = fs::read_to_string(path)
+ .with_context(|| format!("read craft session {}", path.display()))?;
+ let dir = path
+ .parent()
+ .map(|d| d.to_string_lossy().to_string())
+ .unwrap_or_default();
+ let mut lines = raw.lines();
+ let mut header = lines
+ .next()
+ .and_then(parse_header)
+ .context("craft session.jsonl has no session header")?;
+ expand_session_path(&mut header, &dir);
+ let branch_point = str_at(&header, "branchFromMessageId").map(str::to_string);
+
+ let mut messages: Vec<TranscriptMessage> = Vec::new();
+ // 分支会话自己的消息从这个下标开始;之前的是从父会话复制来的(折叠用)
+ let mut own_from: Option<usize> = None;
+ let mut last_ts = 0i64;
+ let mut unknown_lines = 0u32;
+ for line in lines {
+ if line.trim().is_empty() {
+ continue;
+ }
+ // 崩溃时写断的行 craft 自己也是跳过(parseMessagesResilient)
+ let Ok(mut row) = serde_json::from_str::<Value>(line) else {
+ unknown_lines += 1;
+ continue;
+ };
+ expand_session_path(&mut row, &dir);
+ let ts = row.get("timestamp").map(to_epoch_ms).unwrap_or(0);
+ last_ts = last_ts.max(ts);
+ // 子代理(Task 工具)内部的话与工具调用挂着 parentToolUseId:不进主线,
+ // 子代理的结论在 Task 工具自己的结果里
+ let nested = str_at(&row, "parentToolUseId").is_some();
+ match row.get("type").and_then(Value::as_str).unwrap_or_default() {
+ "user" => {
+ let text = user_text(&row);
+ if !text.trim().is_empty() {
+ let mut m = text_msg(Role::User, &text, ts);
+ // 系统生成、只给模型看的推动消息(后台任务完成的提醒一类)
+ if true_at(&row, "hidden") {
+ m.kind = MessageKind::Meta;
+ }
+ messages.push(m);
+ }
+ }
+ "assistant" if !nested => {
+ if let Some(text) = str_at(&row, "content") {
+ messages.push(text_msg(Role::Assistant, text, ts));
+ }
+ }
+ // 计划(Explore 模式下 SubmitPlan 交上来的整份 Markdown)是助手的产出
+ "plan" => {
+ if let Some(text) = str_at(&row, "content") {
+ messages.push(text_msg(Role::Assistant, text, ts));
+ }
+ }
+ "tool" if !nested => {
+ // 挂到本段最近的助手消息上(craft 先落助手的过渡话、再落它发起的工具);
+ // 前面没有可挂的(工具先行,或上一条是分叉点之前复制来的)就起一条空的承载
+ let host = messages.len().checked_sub(1).filter(|&last| {
+ messages[last].role == Role::Assistant
+ && messages[last].kind == MessageKind::Text
+ && own_from.is_none_or(|from| last >= from)
+ });
+ let ix = match host {
+ Some(ix) => ix,
+ None => {
+ messages.push(text_msg(Role::Assistant, "", ts));
+ messages.len() - 1
+ }
+ };
+ messages[ix].tool_calls.push(tool_view(&row));
+ }
+ "assistant" | "tool" => {}
+ // 压缩完成、授权请求、报错与警告:会话里的系统事件
+ "info" | "error" | "warning" | "auth-request" => {
+ let text = str_at(&row, "content").or_else(|| str_at(&row, "errorTitle"));
+ if let Some(text) = text {
+ messages.push(meta_msg(text, ts));
+ }
+ }
+ // 进度状态 craft 本就不落盘(persist 前滤掉),见到也不算漂移
+ "status" => {}
+ _ => unknown_lines += 1,
+ }
+ if own_from.is_none()
+ && branch_point.is_some()
+ && str_at(&row, "id") == branch_point.as_deref()
+ {
+ own_from = Some(messages.len());
+ }
+ }
+
+ // 分支 = 父会话到分叉点为止的消息原样复制进来 + 自己的续写(craft createSession
+ // 的 branch copy),复制段折成一条标记
+ if let Some(cut) = own_from {
+ collapse_inherited(&mut messages, cut, "session");
+ }
+ assign_seq(&mut messages);
+ Ok(CraftParse {
+ header,
+ messages,
+ last_ts,
+ unknown_lines,
+ })
+}
+
+fn epoch_at(v: &Value, key: &str) -> i64 {
+ v.get(key).map(to_epoch_ms).unwrap_or(0)
+}
+
+fn build_meta(r: &SessionFileRef, p: &CraftParse) -> SessionMeta {
+ let path = Path::new(&r.file_path);
+ let h = &p.header;
+ // 标题:craft 的 name(AI 起的或用户改的)> 首条真实提问 > craft 记的预览。分支的
+ // 预览是父会话的首条提问,不拿它当自己的标题
+ let title = str_at(h, "name")
+ .map(clean_title_candidate)
+ .filter(|t| !t.is_empty())
+ .or_else(|| title_from_messages(&p.messages))
+ .or_else(|| {
+ str_at(h, "preview")
+ .filter(|_| str_at(h, "branchFromMessageId").is_none())
+ .map(clean_title_candidate)
+ .filter(|t| !t.is_empty())
+ })
+ .unwrap_or_else(|| UNTITLED.to_string());
+ // 项目:用户给会话设了工作目录就是它;没设(craft 的默认)就归到工作区本身——取首行记的
+ // 工作区路径:远程镜像里文件所在的是本机缓存目录,拿它当项目,按远端路径就筛不到。首行
+ // 的路径是 craft 的 ~ 形态(toPortablePath,workingDirectory 同样),按本机家目录展开——
+ // 远程镜像的 ~ 本该是远端家目录,那边探测不到,与其他远程路径假设同一局限;没记才退回文件位置
+ let project_path = str_at(h, "workingDirectory")
+ .or_else(|| str_at(h, "workspaceRootPath"))
+ .map(super::expand_tilde)
+ .or_else(|| workspace_dir_of(path).map(|w| w.to_string_lossy().to_string()))
+ .unwrap_or_default();
+ let created = epoch_at(h, "createdAt");
+ // lastUsedAt 连"点开看一眼"都会刷新,不是活动时间。lastMessageAt 实测只在用户发言时
+ // 前移(助手几秒后的回复不算),与消息自己的时间戳取大者
+ let updated = [epoch_at(h, "lastMessageAt").max(p.last_ts), created]
+ .into_iter()
+ .find(|t| *t > 0)
+ .unwrap_or(r.mtime_ms);
+ let usage = h.get("tokenUsage").unwrap_or(&Value::Null);
+ let count = |key: &str| usage.get(key).and_then(Value::as_f64).unwrap_or(0.0) as i64;
+ let tokens = match count("totalTokens") {
+ 0 => count("inputTokens") + count("outputTokens"),
+ total => total,
+ };
+ SessionMeta {
+ key: session_key_of(&r.native_id),
+ id: r.native_id.clone(),
+ host: String::new(),
+ agent: AgentId::CraftAgents,
+ title,
+ project_name: project_name_of(&project_path),
+ project_path,
+ file_path: r.file_path.clone(),
+ created_at: if created > 0 { created } else { r.mtime_ms },
+ updated_at: updated,
+ message_count: p
+ .messages
+ .iter()
+ .filter(|m| m.kind == MessageKind::Text)
+ .count() as i64,
+ size_bytes: r.size,
+ git_branch: None,
+ // Pi 后端的模型写成 `pi/<id>`
+ model: str_at(h, "model").map(|m| m.strip_prefix("pi/").unwrap_or(m).to_string()),
+ tokens_used: (tokens > 0).then_some(tokens),
+ archived: true_at(h, "isArchived"),
+ // 自动化(定时 / 标签变化触发的 prompt)建出来的会话
+ source: h
+ .get("triggeredBy")
+ .is_some_and(|t| t.is_object())
+ .then(|| "automation".to_string()),
+ favorite: false,
+ pinned: false,
+ }
+}
+
+impl AgentAdapter for CraftAdapter {
+ fn agent(&self) -> AgentId {
+ AgentId::CraftAgents
+ }
+
+ fn list_session_files(&self) -> Result<Vec<SessionFileRef>> {
+ let (files, _) = self.session_files();
+ Ok(files.iter().filter_map(|f| self.file_ref(f)).collect())
+ }
+
+ fn file_ref(&self, path: &Path) -> Option<SessionFileRef> {
+ // 只认会话主文件:.tmp(原子写的中间态)、.pi-sessions/ 里 Pi 引擎的原料都不是
+ if path.file_name()? != SESSION_FILE {
+ return None;
+ }
+ let mut r = default_file_ref(AgentId::CraftAgents, path)?;
+ r.native_id = self.native_id_of(path)?;
+ let head = match self.heads.get(path, r.mtime_ms, r.size) {
+ // None = 首行写坏了,craft 自己也列不出
+ Ok(head) => head?,
+ // 这一刻读不出来:按上次读到的算,没读过就先不列
+ Err(_) => self.heads.last(path)?,
+ };
+ (!head.hidden).then_some(r)
+ }
+
+ fn parse_session(&self, r: &SessionFileRef) -> Result<ParsedSession> {
+ let parsed = parse_file(Path::new(&r.file_path))?;
+ Ok(ParsedSession::derive(
+ build_meta(r, &parsed),
+ &parsed.messages,
+ parsed.unknown_lines,
+ ))
+ }
+
+ fn parse_transcript(&self, r: &SessionFileRef) -> Result<ParsedTranscript> {
+ let parsed = parse_file(Path::new(&r.file_path))?;
+ Ok(ParsedTranscript {
+ meta: build_meta(r, &parsed),
+ mainline: parsed.messages,
+ sidechains: Vec::new(),
+ unknown_line_count: parsed.unknown_lines,
+ })
+ }
+
+ fn session_paths(&self, meta: &SessionMeta) -> Vec<String> {
+ // 一目录一会话:附件、计划、下载、引擎原料都在会话目录里,整个 trash
+ // (craft 自己删会话也是删整个目录)
+ match Path::new(&meta.file_path).parent() {
+ Some(dir) => vec![dir.to_string_lossy().to_string()],
+ None => vec![meta.file_path.clone()],
+ }
+ }
+
+ fn cleanup_paths(&self, meta: &SessionMeta) -> Option<Vec<String>> {
+ Some(self.session_paths(meta))
+ }
+
+ fn manages_parent_links(&self) -> bool {
+ true
+ }
+
+ /// 子任务(spawn_session / 看板)与分支都挂到同工作区的父会话下。任一会话的首行或
+ /// 工作区 id 这一刻读不出来,整份交回 None(不知道),别让缺的那几条被当成关系解除
+ fn parent_links(&self) -> Option<Vec<(String, String)>> {
+ let mut links = Vec::new();
+ for (path, head) in self.all_heads()? {
+ let Some(parent) = head.parent.filter(|_| !head.hidden) else {
+ continue;
+ };
+ let ns = self.workspace_ns(workspace_dir_of(&path)?)?;
+ let child = native_id(&ns, &path.parent()?.file_name()?.to_string_lossy());
+ let parent = native_id(&ns, &parent);
+ if parent != child {
+ links.push((session_key_of(&child), session_key_of(&parent)));
+ }
+ }
+ Some(links)
+ }
+
+ /// 关系写在子会话自己的首行里(不是 Grok 那种长在父会话 location 里的边车):
+ /// 多 location 下 scanner 按子会话的胜出文件认边
+ fn parent_links_in_child(&self) -> bool {
+ true
+ }
+
+ /// 首行(隐藏会话的也算——它们 file_ref 不收)与回合锚点边车决定父子关系与认领
+ fn is_snapshot_event(&self, path: &Path) -> bool {
+ path.file_name().is_some_and(|n| n == SESSION_FILE) || path.ends_with(CLAUDE_ANCHORS)
+ }
+
+ fn manages_claims(&self) -> bool {
+ true
+ }
+
+ /// Claude 后端的会话在 `~/.claude/projects` 里各有一份引擎转录。隐藏的 mini 编辑
+ /// 会话也认领:它们不进列表,引擎那份同样不该以 Claude Code 会话冒出来。有首行读不
+ /// 出来就交回 None,scanner 保留库里的认领
+ fn claimed_sessions(&self) -> Option<Vec<(AgentId, String)>> {
+ let mut ids: Vec<String> = self
+ .all_heads()?
+ .into_iter()
+ .flat_map(|(_, head)| head.claude_ids)
+ .collect();
+ ids.sort();
+ ids.dedup();
+ Some(
+ ids.into_iter()
+ .map(|id| (AgentId::ClaudeCode, id))
+ .collect(),
+ )
+ }
+
+ fn with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {
+ // 选中的是 `.craft-agent` 本身就下到它的 workspaces/;工作区集合与单个工作区
+ // 两种形态 session_files 都认
+ let root = if dir.join("workspaces").is_dir() {
+ dir.join("workspaces")
+ } else {
+ dir
+ };
+ Box::new(Self::at(root))
+ }
+
+ fn data_roots(&self) -> Vec<PathBuf> {
+ vec![self.root.clone()]
+ }
+}
diff --git a/crates/wake-core/src/adapters/grok.rs b/crates/wake-core/src/adapters/grok.rs
index 9f85786..509771d 100644
--- a/crates/wake-core/src/adapters/grok.rs
+++ b/crates/wake-core/src/adapters/grok.rs
@@ -408,7 +408,7 @@ impl AgentAdapter for GrokAdapter {
Some(grok_group::parent_links(&self.group_ctx()))
}
- fn is_parent_link_event(&self, path: &Path) -> bool {
+ fn is_snapshot_event(&self, path: &Path) -> bool {
path.strip_prefix(&self.root).ok().is_some_and(|relative| {
relative
.components()
diff --git a/crates/wake-core/src/adapters/mod.rs b/crates/wake-core/src/adapters/mod.rs
index aeac1b0..a3cac4f 100644
--- a/crates/wake-core/src/adapters/mod.rs
+++ b/crates/wake-core/src/adapters/mod.rs
@@ -3,6 +3,7 @@ pub mod claude;
pub mod codebuddy;
pub mod codex;
pub mod copilot;
+pub mod craft;
pub mod cursor;
pub mod cursor_ide;
pub mod dsh;
@@ -153,9 +154,11 @@ pub trait AgentAdapter: Send + Sync {
fn parent_links(&self) -> Option<Vec<(String, String)>> {
Some(Vec::new())
}
- /// watcher 事件是否会改变父子关系快照。关系边车不是会话主文件,不能塞进
- /// `file_ref`;命中后 watcher 会单独刷新同 agent 的所有关系快照。
- fn is_parent_link_event(&self, _path: &Path) -> bool {
+ /// watcher 事件是否会改变本家的跨会话快照(`parent_links` / `claimed_sessions`)。
+ /// 这类文件未必是 `file_ref` 收的会话主文件(Grok 的关系边车、Craft 隐藏会话的
+ /// 首行与回合锚点),命中后 watcher 在写库前刷新认领、写库后刷新父子关系——
+ /// 不论事件种类(删除也算)
+ fn is_snapshot_event(&self, _path: &Path) -> bool {
false
}
/// 本家会话文件所在的根位置(目录,或 SQLite 型的库文件),**不论当前存不存在**。
@@ -164,7 +167,7 @@ pub trait AgentAdapter: Send + Sync {
/// 拥有本家 session 文件的位置",凭据/配置/索引这类不产生会话的文件不列。
/// 新增 adapter 必须实现:没有默认值,漏了编译就过不去
fn data_roots(&self) -> Vec<std::path::PathBuf>;
- /// 文件监听根目录。默认 = data_roots 中现存的目录,十九家实测全部吻合:
+ /// 文件监听根目录。默认 = data_roots 中现存的目录,二十家实测全部吻合:
/// 目录型给出自己的 root,SQLite 型的根是库文件、天然筛空(watcher 只认
/// .jsonl,库变更靠启动/手动刷新),codex 的 sessions + archived 一并覆盖。
/// 只有当监听范围确实不同于数据根时才覆写——否则一次根路径搬迁
@@ -209,6 +212,29 @@ pub trait AgentAdapter: Send + Sync {
fn parent_links_global(&self) -> bool {
false
}
+ /// `parent_links` 的边写在**子会话**自己的文件里(Craft 的首行 parentSessionId / 分支来源),
+ /// 不是长在 parent 那个 location 里的边车:多 location 下 scanner 改认"报边者拥有 child 的
+ /// 胜出文件"——落选的旧副本里过期的关系不采纳,parent 归别的 location 时边也不丢。
+ /// 远程装饰器必须转发
+ fn parent_links_in_child(&self) -> bool {
+ false
+ }
+ /// 本家会话在**别家**目录里的替身。外壳产品(Craft Agents)跑的是别家的引擎,
+ /// 引擎自己也往自家目录落了一份转录(Claude Agent SDK → `~/.claude/projects`),
+ /// 同一段对话就会以两家身份各列一次。返回那些替身的 `(别家, 别家 native id)`:
+ /// scanner 按本实例的 host 拼成会话 key(`session_key` 单点,远程装饰器因此照原样
+ /// 转发),不索引它们、已入库的删掉;本家会话消失后认领随之撤销,替身在下一轮扫描
+ /// 回来——Wake 只在原件也在索引里时才藏副本。要现读当前状态(或按文件戳缓存):
+ /// scanner 不保证之前调过 begin_scan。**`None` 是"这一刻读不出来"**,scanner 保留库里
+ /// 这一家的认领(与 parent_links 同一纪律)
+ fn claimed_sessions(&self) -> Option<Vec<(AgentId, String)>> {
+ Some(Vec::new())
+ }
+ /// 是否认领别家会话(见 claimed_sessions)。能力位与 manages_parent_links 同理:
+ /// 只有它为 true 的家参与认领对账,其余家不会每轮往表里写一遍空集
+ fn manages_claims(&self) -> bool {
+ false
+ }
}
/// 入库前的自定义根归一化:把用户选中的目录整形成本家"该存哪一层"的形态。
@@ -220,6 +246,7 @@ pub fn normalize_custom_root(agent: AgentId, dir: std::path::PathBuf) -> std::pa
match agent {
AgentId::Codex => codex::normalize_custom_root(dir),
AgentId::Zcode => zcode::normalize_custom_root(dir),
+ AgentId::CraftAgents => craft::normalize_custom_root(dir),
_ => dir,
}
}
@@ -239,7 +266,7 @@ pub(crate) fn env_dir(key: &str) -> Option<std::path::PathBuf> {
/// 各家数据根共用的 HOME。**全部 adapter 必须走这里**,不要直接
/// `dirs::home_dir()`——`WAKE_HOME` 是整组 adapter 的统一改道开关:
-/// 契约测试靠它把十九家指向 fixture 目录,而 `dirs::home_dir()` 只在
+/// 契约测试靠它把二十家指向 fixture 目录,而 `dirs::home_dir()` 只在
/// POSIX 上看 `$HOME`,Windows 上走 SHGetKnownFolderPath、无论如何都指向
/// 真实用户目录(于是 Windows 上的契约测试全部落空,2026-08-25 review)。
/// 对用户它顺带是便携安装/多档案切换的手动开关。
@@ -247,7 +274,7 @@ pub(crate) fn home_dir() -> Option<std::path::PathBuf> {
env_dir("WAKE_HOME").or_else(dirs::home_dir)
}
-/// 全量十九家 roster,**不按 detect 过滤**。这是全应用唯一的构造点:
+/// 全量二十家 roster,**不按 detect 过滤**。这是全应用唯一的构造点:
/// scanner/watcher/resume/Session locations 面板共享 Workbench 启动时的
/// 同一份实例。缺根的家由各自 list_session_files 降级为 Ok(空)(scanner
/// 对 Err 会 `?` 截断整轮,新 adapter 必须维持这条降级约定,contract 测试
@@ -281,6 +308,7 @@ pub fn create_adapters() -> Vec<Box<dyn AgentAdapter>> {
Box::new(codebuddy::CodebuddyAdapter::new()),
Box::new(codebuddy::CodebuddyAdapter::workbuddy()),
Box::new(zcode::ZcodeAdapter::new()),
+ Box::new(craft::CraftAdapter::new()),
]
}
@@ -546,7 +574,7 @@ fn wake_lookups_from_messages(messages: &[TranscriptMessage]) -> Vec<WakeLookup>
}
impl ParsedSession {
- /// 十八家 parse_session 的唯一出口:解析层只产 meta + messages,入库派生
+ /// 各家 parse_session 的唯一出口:解析层只产 meta + messages,入库派生
/// (FTS 单元、Wake 调用记录)全在这里——再加派生字段不用碰任何 adapter
pub(crate) fn derive(
meta: SessionMeta,
diff --git a/crates/wake-core/src/adapters/parse_utils.rs b/crates/wake-core/src/adapters/parse_utils.rs
index 446b70f..3dd81a6 100644
--- a/crates/wake-core/src/adapters/parse_utils.rs
+++ b/crates/wake-core/src/adapters/parse_utils.rs
@@ -118,6 +118,37 @@ pub fn title_from_messages(messages: &[TranscriptMessage]) -> Option<String> {
.find(|title| !title.is_empty())
}
+/// 会话开头从父会话原样复制来的那段(Codex `spawn_agent` 的 fork_turns、Craft Agents
+/// 的分支)折成一条 Meta 标记。原样入库就是:子会话偷走父会话的标题、父会话的每一句
+/// 在 FTS 里出现两次、Insights 的 prompt 数翻倍。Meta 不进 FTS、不算 message_count、
+/// 不参与标题推导,GUI / 导出 / MCP 也都跳过它——留一条而不是整段删掉,是为了"这里
+/// 原本有东西"不至于无声消失;内容本体就在父会话里。`parent` 是标记里父会话的叫法
+/// (Codex 说 thread)
+pub fn collapse_inherited(messages: &mut Vec<TranscriptMessage>, cut: usize, parent: &str) {
+ if cut == 0 {
+ return;
+ }
+ let inherited = &messages[..cut];
+ let turns = inherited
+ .iter()
+ .filter(|m| m.kind == MessageKind::Text)
+ .count();
+ let ts = inherited
+ .iter()
+ .find_map(|m| m.timestamp)
+ .unwrap_or_default();
+ let mut marker = text_msg(
+ Role::System,
+ &format!(
+ "── {turns} message{} inherited from the parent {parent} ──",
+ crate::text::plural(turns as i64)
+ ),
+ ts,
+ );
+ marker.kind = MessageKind::Meta;
+ messages.splice(..cut, std::iter::once(marker));
+}
+
/// `AgentAdapter::file_ref` 的默认实现:非空 .jsonl,stem 即 native_id。
/// 覆写方可在此结果上做路径过滤或 native_id 改写。
pub fn default_file_ref(agent: AgentId, path: &std::path::Path) -> Option<SessionFileRef> {
diff --git a/crates/wake-core/src/adapters/remote.rs b/crates/wake-core/src/adapters/remote.rs
index 98c16b8..2786b23 100644
--- a/crates/wake-core/src/adapters/remote.rs
+++ b/crates/wake-core/src/adapters/remote.rs
@@ -50,7 +50,7 @@ impl RemoteAdapter {
}
}
-/// 对一个 host 构造整组远程实例:十九家模板 × `with_custom_root`(缓存内
+/// 对一个 host 构造整组远程实例:二十家模板 × `with_custom_root`(缓存内
/// 挂载点,见 remote::REMOTE_LAYOUTS)× 装饰器。追加进 roster 的 active 尾部
/// (不进 Session locations 面板)。`templates` 由 roster 唯一构造点传入
/// (不变量 8:本模块不得自行二次 create_adapters());产物的数据根 100%
@@ -185,8 +185,8 @@ impl AgentAdapter for RemoteAdapter {
)
}
- fn is_parent_link_event(&self, path: &Path) -> bool {
- self.inner.is_parent_link_event(path)
+ fn is_snapshot_event(&self, path: &Path) -> bool {
+ self.inner.is_snapshot_event(path)
}
fn data_roots(&self) -> Vec<std::path::PathBuf> {
@@ -217,6 +217,19 @@ impl AgentAdapter for RemoteAdapter {
self.inner.parent_links_global()
}
+ fn parent_links_in_child(&self) -> bool {
+ self.inner.parent_links_in_child()
+ }
+
+ fn manages_claims(&self) -> bool {
+ self.inner.manages_claims()
+ }
+
+ fn claimed_sessions(&self) -> Option<Vec<(AgentId, String)>> {
+ // 给的是 (别家, native id),host 段由 scanner 按本实例的 host 拼
+ self.inner.claimed_sessions()
+ }
+
fn excluding_data_roots(&self, roots: &[std::path::PathBuf]) -> Option<Box<dyn AgentAdapter>> {
let inner = self.inner.excluding_data_roots(roots)?;
Some(Box::new(Self::new(inner, self.host.clone())))
diff --git a/crates/wake-core/src/bin/wake_cli.rs b/crates/wake-core/src/bin/wake_cli.rs
index fe07dc6..e6fe69c 100644
--- a/crates/wake-core/src/bin/wake_cli.rs
+++ b/crates/wake-core/src/bin/wake_cli.rs
@@ -186,7 +186,7 @@ fn setup(db: &Option<PathBuf>) -> String {
// sibling_named 取的就是 current_exe 同级目录,从 wake-cli 调恰好对
let mcp_bin = mcp::sibling_file("wake-mcp");
let path = db_path(db);
- // 只探库,不必为一行提示把十九家 roster 建起来
+ // 只探库,不必为一行提示把二十家 roster 建起来
let db_error = Store::open_read_only(&path).err().map(|e| format!("{e:#}"));
cli::setup_text(&cli::SetupFacts {
cli_bin: &cli_bin,
diff --git a/crates/wake-core/src/bin/wake_mcp.rs b/crates/wake-core/src/bin/wake_mcp.rs
index e30f81b..cc57e01 100644
--- a/crates/wake-core/src/bin/wake_mcp.rs
+++ b/crates/wake-core/src/bin/wake_mcp.rs
@@ -102,7 +102,7 @@ fn main() -> ExitCode {
for s in mcp::setup_snippets(&bin) {
let _ = writeln!(out, "## {} — {}\n\n{}\n", s.client, s.hint, s.text);
}
- // 只探库,不必为一行提示把十九家 roster 建起来
+ // 只探库,不必为一行提示把二十家 roster 建起来
if let Err(e) = Store::open_read_only(&db_path(&args.db)) {
let _ = writeln!(out, "Note: {e:#}");
}
diff --git a/crates/wake-core/src/db.rs b/crates/wake-core/src/db.rs
index 70a55d7..129d625 100644
--- a/crates/wake-core/src/db.rs
+++ b/crates/wake-core/src/db.rs
@@ -183,6 +183,17 @@ CREATE TABLE IF NOT EXISTS wake_lookups (
tool TEXT NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_wake_lookups_session ON wake_lookups(session_key);
+
+-- 外壳产品认领的别家会话(2026-09-24,Craft Agents:它的 Claude 后端跑的是 Claude Agent
+-- SDK,引擎在 ~/.claude/projects 里另落一份转录,同一段对话会以 Claude Code 身份再列一次)。
+-- key 是替身的会话 key,claimant 是认领方 agent。被认领的 key 不入库(写入闸门在
+-- write_session_guarded / write_meta_only 的事务里),认领落地时已入库的一并删掉;
+-- 每轮扫描按认领方整组替换,认领方的会话没了,替身下一轮就回来。只有 GUI 与写库的
+-- CLI 碰它,只读读者不查(NEWEST_* 不动)
+CREATE TABLE IF NOT EXISTS claimed_sessions (
+ key TEXT PRIMARY KEY,
+ claimant TEXT NOT NULL
+);
"#;
/// 会话元数据和 FTS 单元的派生规则版本(`adapters::units_from_messages` 及其上游解析)。改了派生
@@ -741,6 +752,10 @@ impl Store {
) -> Result<bool> {
let mut conn = self.write.lock().unwrap();
let tx = conn.transaction()?;
+ // 被外壳产品认领的替身不入库。与写入同一事务:认领在并发间隙落地也挡得住
+ if is_claimed(&tx, &meta.key)? {
+ return Ok(false);
+ }
let cur: Option<(String, i64)> = tx
.query_row(
"SELECT file_path, file_mtime FROM sessions WHERE key = ?1",
@@ -776,7 +791,10 @@ impl Store {
let mut conn = self.write.lock().unwrap();
let tx = conn.transaction()?;
for (meta, mtime) in metas {
- upsert_session(&tx, meta, *mtime)?;
+ // quick 路径也是写库路径,认领的替身同样挡在门外
+ if !is_claimed(&tx, &meta.key)? {
+ upsert_session(&tx, meta, *mtime)?;
+ }
}
tx.commit()?;
Ok(())
@@ -981,9 +999,7 @@ impl Store {
|r| r.get(0),
)
.optional()?;
- clear_session_rows(&tx, key)?;
- tx.execute("DELETE FROM titles_fts WHERE key = ?1", params![key])?;
- tx.execute("DELETE FROM sessions WHERE key = ?1", params![key])?;
+ delete_session_row(&tx, key)?;
if tombstone {
if let Some(fp) = file_path.or_else(|| {
recorded
@@ -1515,6 +1531,81 @@ impl Store {
.unwrap_or(false)
}
+ /// 被外壳产品认领的全部会话 key(见 claimed_sessions 表)。scanner 在枚举时一次
+ /// 取齐,跳过这些文件的解析;写入闸门另在事务里逐条查
+ pub fn claimed_keys(&self) -> Result<std::collections::HashSet<String>> {
+ let conn = self.read.lock().unwrap();
+ let mut stmt = conn.prepare_cached("SELECT key FROM claimed_sessions")?;
+ let rows = stmt.query_map([], |r| r.get::<_, String>(0))?;
+ Ok(rows.collect::<rusqlite::Result<_>>()?)
+ }
+
+ /// 单条查询版,watcher 的增量路由用(与 is_key_tombstoned 同位置)
+ pub fn is_key_claimed(&self, key: &str) -> bool {
+ is_claimed(&self.read.lock().unwrap(), key).unwrap_or(false)
+ }
+
+ /// 库里持有认领的 agent。roster 里已经没有的认领方(location 全删、停用)要整组
+ /// 撤销,否则它藏起来的替身就一直藏着
+ pub fn claimants(&self) -> Result<Vec<AgentId>> {
+ let conn = self.read.lock().unwrap();
+ let mut stmt = conn.prepare_cached("SELECT DISTINCT claimant FROM claimed_sessions")?;
+ let rows = stmt.query_map([], |r| r.get::<_, String>(0))?;
+ let names: Vec<String> = rows.collect::<rusqlite::Result<_>>()?;
+ Ok(names.iter().filter_map(|n| AgentId::from_str(n)).collect())
+ }
+
+ /// 用某个认领方的全量快照原子替换它的认领,并在同一事务里删掉已经入库的替身
+ /// (认领之前扫进来的那些——清法与 remove_sessions 相同,不留墓碑:认领撤销后
+ /// 替身要能回来)。返回库是否变了
+ pub fn replace_claims(&self, claimant: AgentId, keys: &[String]) -> Result<bool> {
+ let wanted: std::collections::BTreeSet<&str> = keys.iter().map(String::as_str).collect();
+ let unchanged = |conn: &Connection| -> Result<bool> {
+ let mut stmt = conn.prepare_cached(
+ "SELECT key FROM claimed_sessions WHERE claimant = ?1 ORDER BY key",
+ )?;
+ let held: Vec<String> = stmt
+ .query_map(params![claimant.as_str()], |r| r.get::<_, String>(0))?
+ .collect::<rusqlite::Result<_>>()?;
+ Ok(held.iter().map(String::as_str).eq(wanted.iter().copied()))
+ };
+ // 认领方每存一次盘、每轮扫描都会走到这里,而认领集合几乎从不变:在读连接上比一眼
+ // 就回,不碰写锁。集合没变时库里也不会冒出替身——写入闸门一直挡着
+ if unchanged(&self.read.lock().unwrap())? {
+ return Ok(false);
+ }
+ let mut conn = self.write.lock().unwrap();
+ let tx = conn.transaction()?;
+ // 并发的另一轮可能刚写完同一份
+ if unchanged(&tx)? {
+ return Ok(false);
+ }
+ tx.execute(
+ "DELETE FROM claimed_sessions WHERE claimant = ?1",
+ params![claimant.as_str()],
+ )?;
+ {
+ let mut insert = tx.prepare_cached(
+ "INSERT OR IGNORE INTO claimed_sessions(key, claimant) VALUES (?1, ?2)",
+ )?;
+ for key in &wanted {
+ insert.execute(params![key, claimant.as_str()])?;
+ }
+ }
+ let indexed: Vec<String> = tx
+ .prepare_cached(
+ "SELECT s.key FROM sessions s JOIN claimed_sessions c ON c.key = s.key
+ WHERE c.claimant = ?1",
+ )?
+ .query_map(params![claimant.as_str()], |r| r.get::<_, String>(0))?
+ .collect::<rusqlite::Result<_>>()?;
+ for key in &indexed {
+ delete_session_row(&tx, key)?;
+ }
+ tx.commit()?;
+ Ok(true)
+ }
+
pub fn list_sessions(&self, f: &SessionFilter) -> Result<(Vec<SessionMeta>, i64)> {
let mut wheres: Vec<String> = Vec::new();
let mut args: Vec<Box<dyn rusqlite::ToSql>> = Vec::new();
@@ -3028,6 +3119,25 @@ fn clear_session_rows(tx: &rusqlite::Transaction<'_>, key: &str) -> Result<()> {
Ok(())
}
+/// 认领检查:写入闸门(write_session_guarded / write_meta_only,在写事务里)与
+/// is_key_claimed(读连接)共用
+fn is_claimed(conn: &Connection, key: &str) -> Result<bool> {
+ Ok(conn
+ .prepare_cached("SELECT 1 FROM claimed_sessions WHERE key = ?1")?
+ .query_row(params![key], |_| Ok(()))
+ .optional()?
+ .is_some())
+}
+
+/// 从库里删掉一条会话:派生行、标题索引与会话行本身。删除(remove_sessions)与认领
+/// (replace_claims)共用,墓碑由调用方决定
+fn delete_session_row(tx: &rusqlite::Transaction<'_>, key: &str) -> Result<()> {
+ clear_session_rows(tx, key)?;
+ tx.execute("DELETE FROM titles_fts WHERE key = ?1", params![key])?;
+ tx.execute("DELETE FROM sessions WHERE key = ?1", params![key])?;
+ Ok(())
+}
+
/// write_session / write_session_guarded 共用的事务内核
fn write_session_tx(
tx: &rusqlite::Transaction<'_>,
diff --git a/crates/wake-core/src/mcp/tools.rs b/crates/wake-core/src/mcp/tools.rs
index ab3003e..adc799f 100644
--- a/crates/wake-core/src/mcp/tools.rs
+++ b/crates/wake-core/src/mcp/tools.rs
@@ -380,6 +380,7 @@ fn parse_agent(s: &str) -> Option<AgentId> {
"claude" => Some(AgentId::ClaudeCode),
"deepseek" => Some(AgentId::Dsh),
"opencode2" | "opencodenext" => Some(AgentId::Opencode),
+ "craft" => Some(AgentId::CraftAgents),
_ => None,
})
}
diff --git a/crates/wake-core/src/models.rs b/crates/wake-core/src/models.rs
index e47faca..368ea0f 100644
--- a/crates/wake-core/src/models.rs
+++ b/crates/wake-core/src/models.rs
@@ -24,13 +24,14 @@ pub enum AgentId {
Codebuddy,
Workbuddy,
Zcode,
+ CraftAgents,
}
impl AgentId {
- /// 全部十九家,**枚举声明序**(= Ord = 用户钉的侧栏展示序;面板成组、
+ /// 全部二十家,**枚举声明序**(= Ord = 用户钉的侧栏展示序;面板成组、
/// 表单下拉共用同一顺序)。曾误抄 create_adapters 的构造序,下拉与侧栏
/// 排序当场对不上——契约测试现在卡它与 Ord 一致
- pub const ALL: [AgentId; 19] = [
+ pub const ALL: [AgentId; 20] = [
AgentId::ClaudeCode,
AgentId::Codex,
AgentId::Grok,
@@ -50,6 +51,7 @@ impl AgentId {
AgentId::Codebuddy,
AgentId::Workbuddy,
AgentId::Zcode,
+ AgentId::CraftAgents,
];
pub fn as_str(&self) -> &'static str {
@@ -73,6 +75,7 @@ impl AgentId {
AgentId::Codebuddy => "codebuddy",
AgentId::Workbuddy => "workbuddy",
AgentId::Zcode => "zcode",
+ AgentId::CraftAgents => "craft-agents",
}
}
@@ -97,6 +100,7 @@ impl AgentId {
"codebuddy" => Some(AgentId::Codebuddy),
"workbuddy" => Some(AgentId::Workbuddy),
"zcode" => Some(AgentId::Zcode),
+ "craft-agents" => Some(AgentId::CraftAgents),
_ => None,
}
}
@@ -122,6 +126,7 @@ impl AgentId {
AgentId::Codebuddy => "CodeBuddy",
AgentId::Workbuddy => "WorkBuddy",
AgentId::Zcode => "ZCode",
+ AgentId::CraftAgents => "Craft Agents",
}
}
@@ -204,6 +209,7 @@ impl AgentId {
AgentId::Workbuddy => "brands/workbuddy.png",
// 官方 app 图标(黑底白 Z),两模式通用
AgentId::Zcode => "brands/zcode.png",
+ AgentId::CraftAgents => "brands/craft-agents.png",
}
}
}
@@ -941,7 +947,7 @@ pub const UNTITLED: &str = "Untitled";
/// 会话 key 的唯一构造点:本地 `{agent}:{native_id}`,远程
/// `{agent}:{host}:{native_id}`。scanner 的墓碑查询、watcher 的幸存者反查、
/// 远程装饰器的 key 改写都走这里——"远程 key 长什么样"只此一处知识。
-/// (十九家 adapter 的本地两段构造保留各自 `format!`,它们从不涉及 host。)
+/// (二十家 adapter 的本地两段构造保留各自 `format!`,它们从不涉及 host。)
pub fn session_key(agent: AgentId, host: &str, native_id: &str) -> String {
if host.is_empty() {
format!("{}:{native_id}", agent.as_str())
diff --git a/crates/wake-core/src/remote.rs b/crates/wake-core/src/remote.rs
index a8c63ef..630bf6f 100644
--- a/crates/wake-core/src/remote.rs
+++ b/crates/wake-core/src/remote.rs
@@ -16,7 +16,7 @@
//! ①openrsync(macOS 15+ 的 /usr/bin/rsync)做发送端时,某个源连父目录
//! 都不存在会让它中止整份文件列表,排在后面的源全部静默不传,退出码却
//! 只是 23;②rsync 家族只要发送端遇到任何 I/O 错误(缺源即算)就整体跳过
-//! 删除阶段——没有哪台机器十九家全装,`--delete` 就永远不会生效。
+//! 删除阶段——没有哪台机器二十家全装,`--delete` 就永远不会生效。
//!
//! 同步跑在**独立于扫描的线程**(Workbench::spawn_remote_sync):本地扫描
//! 不等网络,不可达 host 只拖慢自己;缓存落盘由 watcher 增量收编,同步
@@ -49,7 +49,7 @@ pub struct RemoteAgentLayout {
pub exclude: &'static [&'static str],
}
-/// 十九家的远程布局。远程主机按 Linux/macOS 默认路径假设(两平台一致,
+/// 二十家的远程布局。远程主机按 Linux/macOS 默认路径假设(两平台一致,
/// 均为 home 相对;OpenCode 的 XDG 变体、CODEX_HOME 这类 env 覆盖在远端
/// 探测不到,阶段 1 不支持非默认远程布局)。
pub const REMOTE_LAYOUTS: &[RemoteAgentLayout] = &[
@@ -214,6 +214,35 @@ pub const REMOTE_LAYOUTS: &[RemoteAgentLayout] = &[
],
exclude: &[],
},
+ RemoteAgentLayout {
+ agent: AgentId::CraftAgents,
+ // 工作区集合层(远端建在默认位置之外的工作区同步不到)。只要每个会话的
+ // session.jsonl 与 meta/ 里的回合锚点:工作区的 sources/ 是源配置(可能带 OAuth
+ // client secret;凭证本体 credentials.enc 在 home 直属、不在白名单里),
+ // automations.json 可能带 webhook 头;会话目录里的附件 / 下载 / 数据 / 长回复 /
+ // 计划 / 缩小过的图片(tmp)/ 源服务存下的大响应(responses)与引擎原料
+ // (.pi-sessions、.pi-agent——Pi 的 agentDir 默认放 auth.json)量大且不读。模式带
+ // 层级:不带 `/` 的 rsync 模式按文件名全树匹配,`data` / `sources` 这种泛名会把
+ // 同名的工作区整个漏掉(默认位置下叫 "Data" 的工作区目录就是 data/)
+ mount: ".craft-agent/workspaces",
+ sync_paths: &[".craft-agent/workspaces"],
+ exclude: &[
+ "workspaces/*/sources",
+ "workspaces/*/skills",
+ "workspaces/*/automations.json",
+ "workspaces/*/events.jsonl",
+ "workspaces/*/sessions/*/attachments",
+ "workspaces/*/sessions/*/downloads",
+ "workspaces/*/sessions/*/data",
+ "workspaces/*/sessions/*/long_responses",
+ "workspaces/*/sessions/*/plans",
+ "workspaces/*/sessions/*/tmp",
+ "workspaces/*/sessions/*/responses",
+ "workspaces/*/sessions/*/.pi-sessions",
+ "workspaces/*/sessions/*/.pi-agent",
+ "session.jsonl.tmp",
+ ],
+ },
];
/// host 名合法性:进 session key 作中段(不能有 ':')、直接作为 ssh/rsync
@@ -655,7 +684,9 @@ mod tests {
);
// 目标在最后
assert_eq!(args.last().unwrap(), "/tmp/cache/devbox");
- // 各家声明的 exclude 全部落到命令行(OpenClaw 的凭证靠它挡)
+ // 各家声明的 exclude 全部落到命令行(OpenClaw 的凭证靠它挡)。`/` 在字符集里:
+ // exclude 是单独一个 argv 交给本地 rsync、经协议传给发送端,不过任何 shell;
+ // 带层级的模式(Craft 的 workspaces/*/sources)只匹配那一层,不误伤同名目录
for pat in REMOTE_LAYOUTS.iter().flat_map(|l| l.exclude.iter()) {
assert!(
args.contains(&format!("--exclude={pat}")),
@@ -663,10 +694,15 @@ mod tests {
);
assert!(
pat.chars()
- .all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '_' | '-' | '*')),
+ .all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '_' | '-' | '*' | '/')),
"exclude {pat:?} needs quoting"
);
+ assert!(
+ !pat.starts_with('/'),
+ "exclude {pat:?} 锚在传输根上,别家的树对不上"
+ );
}
assert!(args.contains(&"--exclude=openclaw-agent.sqlite*".to_string()));
+ assert!(args.contains(&"--exclude=workspaces/*/sources".to_string()));
}
}
diff --git a/crates/wake-core/src/scanner.rs b/crates/wake-core/src/scanner.rs
index aa6f2a6..1bdbcfe 100644
--- a/crates/wake-core/src/scanner.rs
+++ b/crates/wake-core/src/scanner.rs
@@ -320,6 +320,10 @@ fn run_scan_inner(
for adapter in adapters {
adapter.begin_scan();
}
+ // 认领先对账、再枚举:新认领的替身在这一步就出库,枚举时直接跳过、不白解析;
+ // 撤销的认领(认领方会话没了)这一轮就放替身回来
+ refresh_claims(adapters, store, events);
+ let claimed = store.claimed_keys().unwrap_or_default();
let force_grok_backfill = store.needs_grok_parent_backfill();
// FTS 派生规则换代(db::FTS_FORMAT):这一轮把 mtime/size 没变的也全部重解析。
// 跑完就清旗子,不按"全部成功"重试——解析失败的文件下次也不会自己好,它变了
@@ -371,6 +375,9 @@ fn run_scan_inner(
.filter(|r| {
!store.is_tombstoned(&r.file_path) && !store.is_key_tombstoned(&key_of(ix, r))
})
+ // 被外壳产品认领的替身(Craft 的 Claude 后端在 ~/.claude 落的那份)不索引:
+ // 不在 seen_paths 里,库里若还有它的行,下面的删除检测一并清掉
+ .filter(|r| !claimed.contains(&key_of(ix, r)))
// 无任何根认领的引用(越界枚举或合成测试)保守放行给枚举者;
// 过滤只裁决"确有更深的根拥有它"的情形
.filter(|r| owner_of(&r.file_path).is_none_or(|o| o == ix))
@@ -607,7 +614,7 @@ fn run_scan_inner(
}
}
- if sync_parent_links(adapters, store)? {
+ if sync_parent_links(adapters, store, None)? {
events.on_sessions_changed();
}
if sync_memories(adapters, store) {
@@ -748,13 +755,20 @@ fn sync_memories(adapters: &[Box<dyn AgentAdapter>], store: &Arc<Store>) -> bool
/// 多 location 下关系元数据跟着 parent 会话,而 child 的胜出文件可能在另一根。
/// 因此先接受“关系目标 parent 的胜出文件也属于该快照”的直接边,再跨快照把
/// 嵌套链扁平到 root。解除/换父前重解析 child,恢复被旧父项目覆盖的自身归属。
-fn sync_parent_links(adapters: &[Box<dyn AgentAdapter>], store: &Arc<Store>) -> Result<bool> {
+/// `only` 把对账限在这些 agent(watcher 增量只动了它们的文件;关系只连同家会话,
+/// 别家的快照不会因此变);全量扫描给 None 对账全部
+fn sync_parent_links(
+ adapters: &[Box<dyn AgentAdapter>],
+ store: &Arc<Store>,
+ only: Option<&std::collections::HashSet<AgentId>>,
+) -> Result<bool> {
let mut managed_agents = std::collections::HashSet::new();
let mut unknown_agents = std::collections::HashSet::new();
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() {
+ if adapter.manages_parent_links() && only.is_none_or(|only| only.contains(&adapter.agent()))
+ {
managed_agents.insert(adapter.agent());
match adapter.parent_links() {
Some(links) => links_by_adapter.push(links.into_iter().collect()),
@@ -781,8 +795,8 @@ fn sync_parent_links(adapters: &[Box<dyn AgentAdapter>], store: &Arc<Store>) ->
}
// 这一家眼下一条关系都没有、库里也没有:整段对账是纯浪费——
// session_sources_for_agent 要把这家全部会话读一遍,replace_parent_links
- // 还要开写事务与扫描线程抢锁。watcher 只要**任一**受影响 agent 管关系
- // 就会走到这里,而多数 agent 常年零关系(Codex 是 spawn_agent 用过才有)
+ // 还要开写事务与扫描线程抢锁。全量扫描对每家管关系的都走一遍,而多数
+ // agent 常年零关系(Codex 是 spawn_agent 用过才有)
let current = store.parent_links_for_agent(agent)?;
let has_links = links_by_adapter
.iter()
@@ -803,15 +817,19 @@ fn sync_parent_links(adapters: &[Box<dyn AgentAdapter>], store: &Arc<Store>) ->
}
// meta.json 位于 parent 的 location。只采纳由当前胜出 parent 所属快照
- // 提供的边,避免另一份陈旧备份把已解除的关系重新挂回去。
+ // 提供的边,避免另一份陈旧备份把已解除的关系重新挂回去。关系写在 child
+ // 自己文件里的家(`parent_links_in_child`,Craft)按同一道理换成 child 的
+ // 胜出文件:那份首行才是现行的关系,parent 归哪个 location 无关
let mut direct = std::collections::HashMap::new();
for (adapter_ix, links) in links_by_adapter.iter().enumerate() {
if adapters[adapter_ix].agent() != agent {
continue;
}
+ let in_child = adapters[adapter_ix].parent_links_in_child();
for (child, parent) in links {
+ let holder = if in_child { child } else { parent };
if source_by_key.contains_key(child)
- && owner_by_key.get(parent).copied() == Some(adapter_ix)
+ && owner_by_key.get(holder).copied() == Some(adapter_ix)
{
direct.insert(child.clone(), parent.clone());
}
@@ -853,13 +871,20 @@ fn sync_parent_links(adapters: &[Box<dyn AgentAdapter>], store: &Arc<Store>) ->
// 在 parent 写进库之前就读了 sources 快照。少了这道判断,这一批会拿
// replace_parent_links 的整家清空把全量刚建好的关系抹掉,而 Codex 没有
// is_parent_link_event、state DB 也不在监听路径里,没有第二次机会补救
+ // 关系写在 child 里的家只算 child 胜出文件那份的声称:落选的旧备份还写着的
+ // 过期关系不该靠这道守卫留下来
+ let owners = &owner_by_key;
let asserted: std::collections::HashSet<(&str, &str)> = links_by_adapter
.iter()
.enumerate()
.filter(|(adapter_ix, _)| adapters[*adapter_ix].agent() == agent)
- .flat_map(|(_, links)| {
+ .flat_map(|(adapter_ix, links)| {
+ let in_child = adapters[adapter_ix].parent_links_in_child();
links
.iter()
+ .filter(move |(child, _)| {
+ !in_child || owners.get(*child).copied() == Some(adapter_ix)
+ })
.map(|(child, parent)| (child.as_str(), parent.as_str()))
})
.collect();
@@ -897,7 +922,66 @@ fn sync_parent_links(adapters: &[Box<dyn AgentAdapter>], store: &Arc<Store>) ->
Ok(changed)
}
-/// watcher 收到关系边车事件、但没有会话主文件可交给 `scan_files` 时使用。
+/// 外壳产品对别家替身的认领(`AgentAdapter::claimed_sessions`)按认领方 agent 整组对账:
+/// 同家各实例(默认根、自定义根、远程镜像)的结果合并,key 按**报认领的实例**的 host 拼
+/// (与枚举时的 key_of 同一个 session_key);任一实例这一刻读不出(None)这一家整段跳过、
+/// 库里的认领原样保留(与 sync_parent_links 同一纪律)。库里有、roster 里已经没有的认领方
+/// (location 全删或停用)整组撤销——它藏起来的替身得放回来。替身的删除在
+/// `replace_claims` 的事务里做;返回库是否变了
+fn sync_claims(adapters: &[Box<dyn AgentAdapter>], store: &Arc<Store>) -> Result<bool> {
+ let mut claims: std::collections::BTreeMap<AgentId, Option<Vec<String>>> =
+ std::collections::BTreeMap::new();
+ for adapter in adapters.iter().filter(|a| a.manages_claims()) {
+ let slot = claims
+ .entry(adapter.agent())
+ .or_insert_with(|| Some(Vec::new()));
+ match adapter.claimed_sessions() {
+ Some(claimed) => {
+ if let Some(keys) = slot {
+ keys.extend(
+ claimed
+ .iter()
+ .map(|(agent, native)| session_key(*agent, adapter.host(), native)),
+ );
+ }
+ }
+ None => {
+ eprintln!(
+ "[scanner] claims of {} unreadable this round; keeping the indexed ones",
+ adapter.agent().as_str()
+ );
+ *slot = None;
+ }
+ }
+ }
+ for claimant in store.claimants()? {
+ claims.entry(claimant).or_insert_with(|| Some(Vec::new()));
+ }
+ let mut changed = false;
+ for (claimant, keys) in claims {
+ if let Some(keys) = keys {
+ changed |= store.replace_claims(claimant, &keys)?;
+ }
+ }
+ Ok(changed)
+}
+
+/// 对账认领并通知列表;全量扫描开头与 watcher(认领方的快照事件,写库之前)共用。
+/// 失败只记日志、不截断扫描——写入闸门仍按库里现有的认领把关。撤销的认领不会让替身
+/// 在这一刻回来:它的行早删了、文件也没变,下一轮扫描枚举到它才重新入库
+pub fn refresh_claims(
+ adapters: &[Box<dyn AgentAdapter>],
+ store: &Arc<Store>,
+ events: &dyn ScanEvents,
+) {
+ match sync_claims(adapters, store) {
+ Ok(true) => events.on_sessions_changed(),
+ Ok(false) => {}
+ Err(error) => eprintln!("[scanner] claim refresh failed: {error}"),
+ }
+}
+
+/// watcher 收到快照事件(关系边车一类)、但没有会话主文件可交给 `scan_files` 时使用。
/// 同 agent 的全部 location 必须一起刷新,否则跨 location 的父链会被局部快照截断。
pub fn refresh_parent_links(
adapters: &[Box<dyn AgentAdapter>],
@@ -915,7 +999,8 @@ pub fn refresh_parent_links(
if !refreshable {
return;
}
- match sync_parent_links(adapters, store) {
+ let only: std::collections::HashSet<AgentId> = affected_agents.iter().copied().collect();
+ match sync_parent_links(adapters, store, Some(&only)) {
Ok(true) => events.on_sessions_changed(),
Ok(false) => {}
Err(error) => eprintln!("[scanner] parent-link sidecar refresh failed: {error}"),
@@ -1003,6 +1088,7 @@ pub fn scan_files(
adapter.begin_scan();
}
}
+ let mut changed = false;
// 按**实例**分组,不是按 agent:自定义 location 让同 agent 有多实例,
// 文件必须交给拥有其根的那个(gemini/kimi 的 cwd 反查、codex 的 state DB
// 都是实例相对侧档);quick_meta 是整库查询,每组只查一次,不能逐文件调。
@@ -1016,13 +1102,14 @@ pub fn scan_files(
let Some(ix) = crate::adapters::adapter_ix_for(adapters, r.agent, &r.file_path) else {
continue;
};
- if store.is_key_tombstoned(&session_key(r.agent, adapters[ix].host(), &r.native_id)) {
+ let key = session_key(r.agent, adapters[ix].host(), &r.native_id);
+ // 认领的替身连解析都省了;合并改过 key 的情形由写入闸门兜住
+ if store.is_key_tombstoned(&key) || store.is_key_claimed(&key) {
continue;
}
by_adapter.entry(ix).or_default().push(r);
}
- let mut changed = false;
for (ix, group) in by_adapter {
let adapter = &adapters[ix];
let quick = adapter.quick_meta(&group);
@@ -1069,10 +1156,11 @@ pub fn scan_files(
.iter()
.any(|adapter| affected_agents.contains(&adapter.agent()) && adapter.manages_parent_links())
{
- changed |= sync_parent_links(adapters, store).unwrap_or_else(|error| {
- eprintln!("[scanner] parent-link refresh failed: {error}");
- false
- });
+ changed |=
+ sync_parent_links(adapters, store, Some(&affected_agents)).unwrap_or_else(|error| {
+ eprintln!("[scanner] parent-link refresh failed: {error}");
+ false
+ });
}
if changed {
events.on_sessions_changed();
diff --git a/crates/wake-core/src/services/terminal/mod.rs b/crates/wake-core/src/services/terminal/mod.rs
index 07199a6..94f6dd5 100644
--- a/crates/wake-core/src/services/terminal/mod.rs
+++ b/crates/wake-core/src/services/terminal/mod.rs
@@ -145,6 +145,9 @@ pub fn agent_bin(agent: AgentId) -> Option<&'static str> {
// ZCode 同样是桌面 app;app 内的 zcode.cjs 是常驻运行时的一部分、
// 持有 db.sqlite 的写锁,外面再起一个不安全
AgentId::Zcode => None,
+ // Craft Agents 是桌面 app;它的 craft-cli 只会连一台在跑的 Craft server
+ // 发消息,不是能在终端里接着聊的界面
+ AgentId::CraftAgents => None,
}
}
@@ -194,6 +197,9 @@ fn resume_args(meta: &SessionMeta) -> Option<(Vec<String>, bool)> {
AgentId::Workbuddy => None,
// ZCode:没有 CLI,`zcode://` scheme 的参数未公开——不画 Open In
AgentId::Zcode => None,
+ // Craft Agents:`craftagents://` 能定位会话,但要带全局 config.json 里的
+ // 工作区 id(那个文件存着 server token,不读);也不是终端命令——不画 Open In
+ AgentId::CraftAgents => None,
// Kiro / Gemini CLI 没有按会话 id 续会话的形制
AgentId::Kiro | AgentId::Gemini => None,
}
diff --git a/crates/wake-core/src/watcher.rs b/crates/wake-core/src/watcher.rs
index 4167959..f2d3be9 100644
--- a/crates/wake-core/src/watcher.rs
+++ b/crates/wake-core/src/watcher.rs
@@ -1,7 +1,7 @@
use crate::adapters::AgentAdapter;
use crate::db::Store;
use crate::models::*;
-use crate::scanner::{refresh_parent_links, scan_files, ScanEvents};
+use crate::scanner::{refresh_claims, refresh_parent_links, scan_files, ScanEvents};
use notify::{RecursiveMode, Watcher};
use std::collections::{HashMap, HashSet};
use std::path::{Path, PathBuf};
@@ -111,6 +111,94 @@ pub fn promote_survivors(
}
}
+/// 一批去抖后的事件落库。从监听线程里拆出来,测试可以不经文件系统通知、直接喂
+/// 构造好的事件(通知的到达时序三平台各不相同,拿真通知测会很脆)。`roots` 是
+/// (监听根, 实例下标),路径归属按最长匹配根(resolve_watch_agent)。
+///
+/// **事件种类不作数,按处理这一刻的现状裁决**:文件在就重解析,不在就出库。先 unlink
+/// 再 rename 的原子替换(Craft Agents 为兼容 Windows 就这么存会话)会先报一条 Remove,
+/// rename 的事件还可能落进下一批;改名走掉的旧路径报的又是改名而不是删除——按种类
+/// 分派,前者让会话在列表里闪没、正在看的详情被踢掉,后者让库里的行一直指着不存在的
+/// 路径,直到下次全量扫描
+pub(crate) fn process_batch(
+ adapters: &[Box<dyn AgentAdapter>],
+ store: &Arc<Store>,
+ events: &dyn ScanEvents,
+ roots: &[(PathBuf, usize)],
+ batch: Vec<notify::Result<notify::Event>>,
+) {
+ let mut present: HashMap<PathBuf, usize> = HashMap::new();
+ let mut gone: HashSet<PathBuf> = HashSet::new();
+ let mut snapshot_agents: HashSet<AgentId> = HashSet::new();
+ let mut rescan = false;
+ for ev in batch {
+ let Ok(ev) = ev.inspect_err(|e| eprintln!("watcher: notify error: {e}")) else {
+ continue;
+ };
+ // 后端丢过事件(FSEvents MustScanSubDirs / inotify Q_OVERFLOW):
+ // 这条不指向具体会话文件——macOS 挂的是出事的目录、Linux 干脆
+ // 无路径——按路径处理会被 file_ref 静默丢弃,改由整轮增量兜底
+ if ev.need_rescan() {
+ rescan = true;
+ continue;
+ }
+ for path in ev.paths {
+ let owner_ix = resolve_watch_agent(roots, &path);
+ if let Some(adapter) = owner_ix.and_then(|ix| adapters.get(ix)) {
+ if adapter.is_snapshot_event(&path) {
+ snapshot_agents.insert(adapter.agent());
+ }
+ }
+ if path.exists() {
+ gone.remove(&path);
+ if let Some(ix) = owner_ix {
+ present.insert(path, ix);
+ }
+ } else {
+ present.remove(&path);
+ gone.insert(path);
+ }
+ }
+ }
+
+ let removed_keys: Vec<String> = gone
+ .iter()
+ .filter_map(|path| store.remove_by_path(&path.to_string_lossy()).ok().flatten())
+ .collect();
+ if !removed_keys.is_empty() {
+ events.on_sessions_changed();
+ }
+ promote_survivors(adapters, store, events, &removed_keys);
+ // 认领方的快照变了(会话存盘或删掉,隐藏会话与回合锚点也算):写库之前对账——同一批里
+ // 引擎那份转录的写入才会被闸门挡住,原件没了的认领随之撤销
+ if adapters
+ .iter()
+ .any(|a| a.manages_claims() && snapshot_agents.contains(&a.agent()))
+ {
+ refresh_claims(adapters, store, events);
+ }
+
+ // 路径是否本 agent 的会话文件、native_id 怎么取,统一问**拥有
+ // 该根的实例**(下标即 roots 表登记的归属)
+ let refs: Vec<SessionFileRef> = present
+ .into_iter()
+ .filter_map(|(path, ix)| adapters.get(ix).and_then(|a| a.file_ref(&path)))
+ .collect();
+ let scanned_agents: HashSet<AgentId> = refs.iter().map(|reference| reference.agent).collect();
+ if !refs.is_empty() {
+ scan_files(adapters, store, events, refs);
+ }
+ // scan_files 已经为它扫到的家刷过父子关系
+ snapshot_agents.retain(|agent| !scanned_agents.contains(agent));
+ if !snapshot_agents.is_empty() {
+ let agents: Vec<AgentId> = snapshot_agents.into_iter().collect();
+ refresh_parent_links(adapters, store, events, &agents);
+ }
+ if rescan {
+ events.on_rescan_needed();
+ }
+}
+
pub fn start_watcher(
adapters: Arc<Vec<Box<dyn AgentAdapter>>>,
store: Arc<Store>,
@@ -140,10 +228,6 @@ pub fn start_watcher(
}
let thread = std::thread::spawn(move || {
- let resolve_ix = |path: &Path| resolve_watch_agent(&roots, path);
-
- let mut pending: HashMap<PathBuf, usize> = HashMap::new();
- let mut removed: Vec<PathBuf> = Vec::new();
loop {
// 等首个事件(阻塞),然后 800ms 窗口收敛
let first = match rx.recv() {
@@ -160,64 +244,7 @@ pub fn start_watcher(
break;
}
}
-
- let mut parent_link_agents = HashSet::new();
- let mut rescan = false;
- for ev in batch {
- let Ok(ev) = ev.inspect_err(|e| eprintln!("watcher: notify error: {e}")) else {
- continue;
- };
- // 后端丢过事件(FSEvents MustScanSubDirs / inotify Q_OVERFLOW):
- // 这条不指向具体会话文件——macOS 挂的是出事的目录、Linux 干脆
- // 无路径——按路径处理会被 file_ref 静默丢弃,改由整轮增量兜底
- if ev.need_rescan() {
- rescan = true;
- continue;
- }
- for path in ev.paths {
- let owner_ix = resolve_ix(&path);
- if let Some(adapter) = owner_ix.and_then(|ix| adapters.get(ix)) {
- if adapter.is_parent_link_event(&path) {
- parent_link_agents.insert(adapter.agent());
- }
- }
- if matches!(ev.kind, notify::EventKind::Remove(_)) {
- pending.remove(&path);
- removed.push(path.clone());
- } else if let Some(ix) = owner_ix {
- pending.insert(path.clone(), ix);
- }
- }
- }
-
- let mut removed_keys: Vec<String> = Vec::new();
- for path in removed.drain(..) {
- if let Ok(Some(key)) = store.remove_by_path(&path.to_string_lossy()) {
- removed_keys.push(key);
- }
- events.on_sessions_changed();
- }
- promote_survivors(&adapters, &store, events.as_ref(), &removed_keys);
-
- // 路径是否本 agent 的会话文件、native_id 怎么取,统一问**拥有
- // 该根的实例**(下标即 roots 表登记的归属)
- let refs: Vec<SessionFileRef> = pending
- .drain()
- .filter_map(|(path, ix)| adapters.get(ix).and_then(|a| a.file_ref(&path)))
- .collect();
- let scanned_agents: HashSet<AgentId> =
- refs.iter().map(|reference| reference.agent).collect();
- if !refs.is_empty() {
- scan_files(&adapters, &store, events.as_ref(), refs);
- }
- parent_link_agents.retain(|agent| !scanned_agents.contains(agent));
- if !parent_link_agents.is_empty() {
- let agents: Vec<AgentId> = parent_link_agents.into_iter().collect();
- refresh_parent_links(&adapters, &store, events.as_ref(), &agents);
- }
- if rescan {
- events.on_rescan_needed();
- }
+ process_batch(&adapters, &store, events.as_ref(), &roots, batch);
}
});
@@ -227,3 +254,119 @@ pub fn start_watcher(
watched,
})
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::adapters::craft::CraftAdapter;
+ use crate::scanner::NullEvents;
+ use notify::event::{CreateKind, EventKind, ModifyKind, RemoveKind, RenameMode};
+
+ /// Craft 的会话首行(Claude 后端,引擎转录 id = `sdk`)+ 一句用户话
+ fn header(name: &str, sdk: &str, hidden: bool) -> String {
+ format!(
+ "{{\"id\":\"s\",\"name\":\"{name}\",\"sdkSessionId\":\"{sdk}\",\"hidden\":{hidden},\"model\":\"claude-opus-5-5\",\"createdAt\":1786200000000}}\n\
+ {{\"id\":\"m1\",\"type\":\"user\",\"content\":\"hello\",\"timestamp\":1786200001000}}\n"
+ )
+ }
+
+ struct Fixture {
+ _tmp: tempfile::TempDir,
+ store: Arc<Store>,
+ adapters: Vec<Box<dyn AgentAdapter>>,
+ roots: Vec<(PathBuf, usize)>,
+ root: PathBuf,
+ file: PathBuf,
+ }
+
+ impl Fixture {
+ fn new() -> Self {
+ let tmp = tempfile::tempdir().unwrap();
+ let root = tmp.path().join("workspaces");
+ let fx = Self {
+ store: Arc::new(Store::open(&tmp.path().join("wake.db")).unwrap()),
+ adapters: vec![CraftAdapter::new().with_custom_root(root.clone())],
+ roots: vec![(root.clone(), 0)],
+ file: root.join("ws/sessions/260801-brave-otter/session.jsonl"),
+ root,
+ _tmp: tmp,
+ };
+ fx.write(&fx.file, &header("first", "sdk-1", false));
+ fx
+ }
+
+ fn write(&self, path: &Path, content: &str) {
+ std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+ std::fs::write(path, content).unwrap();
+ }
+
+ fn batch(&self, kind: EventKind, path: &Path) {
+ let batch = vec![Ok(notify::Event::new(kind).add_path(path.to_path_buf()))];
+ process_batch(&self.adapters, &self.store, &NullEvents, &self.roots, batch);
+ }
+
+ fn title(&self) -> Option<String> {
+ self.store
+ .get_session("craft-agents:ws/260801-brave-otter")
+ .unwrap()
+ .map(|s| s.title)
+ }
+ }
+
+ /// Craft 存会话是"写 .tmp → 先 unlink 正本 → rename",rename 的事件可能落进下一批。
+ /// 这一批只收到 Remove、而文件已经回来了:当修改处理(重解析),不删会话;
+ /// 文件真没了才出库
+ #[test]
+ fn a_remove_for_a_file_that_is_back_is_a_modification() {
+ let fx = Fixture::new();
+ fx.batch(EventKind::Create(CreateKind::File), &fx.file);
+ assert_eq!(fx.title().as_deref(), Some("first"));
+
+ let tmp = fx.file.with_file_name("session.jsonl.tmp");
+ fx.write(&tmp, &header("second", "sdk-1", false));
+ std::fs::remove_file(&fx.file).unwrap();
+ std::fs::rename(&tmp, &fx.file).unwrap();
+ fx.batch(EventKind::Remove(RemoveKind::File), &fx.file);
+ assert_eq!(
+ fx.title().as_deref(),
+ Some("second"),
+ "一条过时的 Remove 把会话删了,或没按修改重解析"
+ );
+
+ std::fs::remove_file(&fx.file).unwrap();
+ fx.batch(EventKind::Remove(RemoveKind::File), &fx.file);
+ assert_eq!(fx.title(), None);
+ }
+
+ /// 改名走掉的旧路径报的是改名而不是删除:照样按"文件已不在"出库
+ #[test]
+ fn a_path_renamed_away_leaves_the_index() {
+ let fx = Fixture::new();
+ fx.batch(EventKind::Create(CreateKind::File), &fx.file);
+ std::fs::rename(&fx.file, fx.file.with_file_name("session.jsonl.bak")).unwrap();
+ fx.batch(
+ EventKind::Modify(ModifyKind::Name(RenameMode::From)),
+ &fx.file,
+ );
+ assert_eq!(fx.title(), None);
+ }
+
+ /// 认领方(Craft)的会话一存盘就认领它的引擎转录——隐藏的 mini 会话 file_ref 不收,
+ /// 它的首行照样是快照事件;会话被删,认领随之撤销
+ #[test]
+ fn claimant_snapshot_events_keep_claims_current() {
+ let fx = Fixture::new();
+ fx.batch(EventKind::Create(CreateKind::File), &fx.file);
+ let hidden = fx.root.join("ws/sessions/260802-mini-edit/session.jsonl");
+ fx.write(&hidden, &header("mini", "sdk-2", true));
+ fx.batch(EventKind::Create(CreateKind::File), &hidden);
+ let claimed = fx.store.claimed_keys().unwrap();
+ assert!(claimed.contains("claude-code:sdk-1"), "{claimed:?}");
+ assert!(claimed.contains("claude-code:sdk-2"), "{claimed:?}");
+
+ std::fs::remove_dir_all(fx.file.parent().unwrap()).unwrap();
+ fx.batch(EventKind::Remove(RemoveKind::File), &fx.file);
+ let claimed = fx.store.claimed_keys().unwrap();
+ assert!(!claimed.contains("claude-code:sdk-1"), "{claimed:?}");
+ }
+}
diff --git a/crates/wake-core/tests/adapter_contracts.rs b/crates/wake-core/tests/adapter_contracts.rs
index 03ce367..bc92aaa 100644
--- a/crates/wake-core/tests/adapter_contracts.rs
+++ b/crates/wake-core/tests/adapter_contracts.rs
@@ -18,6 +18,7 @@ use wake_core::adapters::claude::ClaudeAdapter;
use wake_core::adapters::codebuddy::CodebuddyAdapter;
use wake_core::adapters::codex::CodexAdapter;
use wake_core::adapters::copilot::CopilotAdapter;
+use wake_core::adapters::craft::CraftAdapter;
use wake_core::adapters::cursor::CursorAdapter;
use wake_core::adapters::cursor_ide::CursorIdeAdapter;
use wake_core::adapters::dsh::DshAdapter;
@@ -1803,10 +1804,10 @@ fn grok_parse_contract() {
"grok:77777777-aaaa-bbbb-cccc-000000000007".into(),
)));
let parent_meta = fixture("grok/sessions/%2FUsers%2Ftester%2FGithub%2Fwakefx/77777777-aaaa-bbbb-cccc-000000000007/subagents/child-fixture/meta.json");
- assert!(adapter.is_parent_link_event(&parent_meta));
+ assert!(adapter.is_snapshot_event(&parent_meta));
// file_ref 是公开 API:只认 updates.jsonl,native_id 取会话目录名
let path = fixture("grok/sessions/%2FUsers%2Ftester%2FGithub%2Fwakefx/77777777-aaaa-bbbb-cccc-000000000007/updates.jsonl");
- assert!(!adapter.is_parent_link_event(&path));
+ assert!(!adapter.is_snapshot_event(&path));
let r = adapter.file_ref(&path).expect("grok file_ref");
assert_eq!(r.native_id, "77777777-aaaa-bbbb-cccc-000000000007");
assert!(adapter
@@ -2254,12 +2255,366 @@ fn seq_contract_holds_for_all_agents() {
Box::new(ZcodeAdapter::new()),
db_ref(AgentId::Zcode, &env.zcode_db, "zc-0001"),
),
+ (
+ CraftAdapter::new().with_custom_root(fixture("craft-agents")),
+ craft_ref("260801-brave-otter"),
+ ),
+ (
+ CraftAdapter::new().with_custom_root(fixture("craft-agents")),
+ craft_ref("260803-bold-pine"),
+ ),
];
for (adapter, r) in &checks {
assert_seq_contract(adapter.as_ref(), r);
}
}
+fn craft_session_dir(session: &str) -> PathBuf {
+ fixture("craft-agents/workspaces/wakefx-ws/sessions").join(session)
+}
+
+fn craft_ref(session: &str) -> SessionFileRef {
+ fs_ref(
+ AgentId::CraftAgents,
+ &craft_session_dir(session).join("session.jsonl"),
+ &format!("ws_f1x7e5a0/{session}"),
+ )
+}
+
+#[test]
+fn craft_agents_parse_contract() {
+ setup();
+ let adapter = CraftAdapter::new().with_custom_root(fixture("craft-agents"));
+ // 选中 `.craft-agent` 本身、工作区集合、单个工作区,枚举出同一批会话。隐藏的 mini
+ // 编辑会话(260804)不进列表;原子写的 .tmp、Pi 引擎的 .pi-sessions/ 都不是会话
+ let listed = adapter.list_session_files().expect("craft list");
+ let ids: Vec<String> = listed.iter().map(|r| r.native_id.clone()).collect();
+ assert_eq!(
+ ids,
+ [
+ "ws_f1x7e5a0/260801-brave-otter",
+ "ws_f1x7e5a0/260802-quiet-lake",
+ "ws_f1x7e5a0/260803-bold-pine",
+ "ws_f1x7e5a0/260805-calm-reed",
+ ]
+ );
+ for root in [
+ fixture("craft-agents/workspaces"),
+ fixture("craft-agents/workspaces/wakefx-ws"),
+ ] {
+ let again: Vec<String> = CraftAdapter::new()
+ .with_custom_root(root)
+ .list_session_files()
+ .unwrap()
+ .into_iter()
+ .map(|r| r.native_id)
+ .collect();
+ assert_eq!(again, ids);
+ }
+ let otter = craft_session_dir("260801-brave-otter");
+ assert!(adapter.file_ref(&otter.join("session.jsonl.tmp")).is_none());
+ assert!(adapter
+ .file_ref(&craft_session_dir("260802-quiet-lake").join(
+ ".pi-sessions/2026-08-09T09-00-00-000Z_01a0d3b2-0000-7000-8000-000000000002.jsonl"
+ ))
+ .is_none());
+ assert!(
+ adapter
+ .file_ref(&craft_session_dir("260804-tiny-fern").join("session.jsonl"))
+ .is_none(),
+ "隐藏的 mini 会话不进列表"
+ );
+
+ // Claude 后端的主会话:标题是 craft 的 name,项目是用户设的工作目录,活动时间取
+ // lastMessageAt(lastUsedAt 连"点开看一眼"都会刷新)
+ let r = craft_ref("260801-brave-otter");
+ let s = adapter.parse_session(&r).expect("craft parse_session");
+ let t = adapter
+ .parse_transcript(&r)
+ .expect("craft parse_transcript");
+ assert_eq!(s.meta.key, "craft-agents:ws_f1x7e5a0/260801-brave-otter");
+ assert_eq!(s.meta.title, "Fix QR scanner crash");
+ assert_eq!(s.meta.project_path, "/Users/tester/Github/wakefx");
+ assert_eq!(s.meta.model.as_deref(), Some("claude-opus-5-5"));
+ assert_eq!(s.meta.tokens_used, Some(1500));
+ assert_eq!(s.meta.created_at, 1786200000000);
+ assert_eq!(s.meta.updated_at, 1786200060000);
+ assert_eq!(s.meta.message_count, 3);
+ assert_eq!(s.unknown_line_count, 1, "词汇表外的行计数(漂移金丝雀)");
+ assert_eq!(
+ roles_kinds(&t.mainline),
+ vec![
+ (Role::User, MessageKind::Text),
+ (Role::Assistant, MessageKind::Text),
+ (Role::Assistant, MessageKind::Text),
+ (Role::System, MessageKind::Meta), // 压缩完成
+ (Role::User, MessageKind::Meta), // 只给模型看的推动消息
+ ]
+ );
+ assert!(t.mainline[0].text.contains("crashes on unmount"));
+ assert!(t.mainline[0].text.contains("[Attached file: crash.png]"));
+ // 工具挂在发起它的那段助手话上;子代理(Task)内部的工具与话不进主线
+ let tools = &t.mainline[1].tool_calls;
+ assert_eq!(
+ tools.iter().map(|tc| tc.name.as_str()).collect::<Vec<_>>(),
+ ["Read", "Bash"]
+ );
+ assert!(tools[0]
+ .output
+ .as_deref()
+ .unwrap_or_default()
+ .contains("useEffect"));
+ assert!(!tools[0].is_error);
+ assert!(tools[1].is_error);
+ let bash_input = tools[1].input.as_deref().unwrap_or_default();
+ assert!(!bash_input.contains("{{SESSION_PATH}}"), "{bash_input}");
+ assert!(bash_input.contains("260801-brave-otter/plans/notes.md"));
+ assert!(!t.mainline.iter().any(|m| m.text.contains("Subagent notes")));
+
+ // Pi 后端(连 ChatGPT 的那种):模型剥掉 pi/ 前缀;没设工作目录就归到工作区本身——
+ // 取首行记的工作区路径(~ 形态按家目录展开),不是文件此刻所在的位置;归档与
+ // "自动化建的"如实带上
+ let lake = adapter.parse_session(&listed[1]).unwrap().meta;
+ assert_eq!(lake.model.as_deref(), Some("gpt-6-astra"));
+ assert_eq!(
+ lake.tokens_used,
+ Some(1000),
+ "totalTokens 为 0 时退回 input + output"
+ );
+ assert!(lake.archived);
+ assert_eq!(lake.source.as_deref(), Some("automation"));
+ assert_eq!(
+ lake.project_path,
+ wake_core::adapters::expand_tilde("~/.craft-agent/workspaces/wakefx-ws")
+ );
+ assert_eq!(lake.project_name, "wakefx-ws");
+
+ // 分支:从父会话复制来的那段折成一条标记;标题取分支自己的第一句,不拿父会话的
+ // 预览顶替;紧跟分叉点的工具起一条新的承载,不挂到被折掉的父会话消息上
+ let pine = adapter.parse_transcript(&listed[2]).unwrap();
+ assert_eq!(
+ roles_kinds(&pine.mainline),
+ vec![
+ (Role::System, MessageKind::Meta),
+ (Role::Assistant, MessageKind::Text),
+ (Role::User, MessageKind::Text),
+ (Role::Assistant, MessageKind::Text),
+ ]
+ );
+ assert!(pine.mainline[0].text.contains("2 messages inherited"));
+ assert_eq!(pine.mainline[1].tool_calls.len(), 1);
+ assert_eq!(pine.meta.title, "Try the camera module instead");
+
+ // 子任务:计划(SubmitPlan 交上来的 Markdown)是助手正文,授权请求与报错是系统事件
+ let reed = adapter.parse_transcript(&listed[3]).unwrap();
+ assert_eq!(
+ roles_kinds(&reed.mainline),
+ vec![
+ (Role::User, MessageKind::Text),
+ (Role::Assistant, MessageKind::Text),
+ (Role::System, MessageKind::Meta),
+ (Role::System, MessageKind::Meta),
+ ]
+ );
+ assert!(reed.mainline[1].text.contains("Regression test plan"));
+ // lastMessageAt 只跟到用户那句;之后的计划 / 报错也是活动
+ assert_eq!(reed.meta.updated_at, 1786700004000);
+
+ // 子任务与分支挂回原会话
+ assert!(adapter.manages_parent_links());
+ let mut links = adapter.parent_links().unwrap();
+ links.sort();
+ let otter_key = "craft-agents:ws_f1x7e5a0/260801-brave-otter".to_string();
+ assert_eq!(
+ links,
+ vec![
+ (
+ "craft-agents:ws_f1x7e5a0/260803-bold-pine".to_string(),
+ otter_key.clone()
+ ),
+ (
+ "craft-agents:ws_f1x7e5a0/260805-calm-reed".to_string(),
+ otter_key
+ ),
+ ]
+ );
+
+ // 认领 Claude 引擎的转录:首行的 sdkSessionId、锚点边车里更早的那份、隐藏会话的;
+ // Pi 后端的 sdkSessionId 是 Pi 自己的 id,不认
+ assert!(adapter.manages_claims());
+ let claims = adapter.claimed_sessions().unwrap();
+ assert!(claims
+ .iter()
+ .all(|(agent, _)| *agent == AgentId::ClaudeCode));
+ assert_eq!(
+ claims.iter().map(|(_, id)| id.as_str()).collect::<Vec<_>>(),
+ [
+ "c1a0de00-aaaa-4bbb-8ccc-000000000001",
+ "c1a0de00-aaaa-4bbb-8ccc-000000000003",
+ "c1a0de00-aaaa-4bbb-8ccc-000000000004",
+ "c1a0de00-aaaa-4bbb-8ccc-000000000005",
+ "c1a0de00-aaaa-4bbb-8ccc-00000000000a",
+ ],
+ "排好序、去过重(锚点边车里又出现了一次首行那份)"
+ );
+ // 快照事件:任何会话的首行(含隐藏会话)与回合锚点边车,别的文件不算
+ assert!(adapter.is_snapshot_event(&craft_session_dir("260804-tiny-fern").join("session.jsonl")));
+ assert!(adapter.is_snapshot_event(&otter.join("meta/claude-turn-anchors.json")));
+ assert!(!adapter.is_snapshot_event(&otter.join("attachments/crash.png")));
+}
+
+/// 合成一条 craft 会话:首行 + 一句用户消息
+fn write_craft_session(workspace: &Path, session: &str, header: serde_json::Value) {
+ let dir = workspace.join("sessions").join(session);
+ fs::create_dir_all(&dir).unwrap();
+ let mut header = header;
+ header["id"] = serde_json::json!(session);
+ let line = serde_json::json!({
+ "id": "m1", "type": "user", "content": "hello", "timestamp": 1786200000000i64
+ });
+ fs::write(dir.join("session.jsonl"), format!("{header}\n{line}\n")).unwrap();
+}
+
+#[test]
+fn craft_keys_are_namespaced_by_the_workspace_id() {
+ // 会话 id 只在工作区内唯一:两个同名文件夹的工作区同一天各生成一条同名会话,key 不能撞
+ // (撞了会被 scanner 当成副本吞掉一条);命名空间取工作区 config.json 的 id,没有
+ // config.json 或 id 缺席才退回目录名
+ let tmp = tempfile::tempdir().unwrap();
+ let a = tmp.path().join("a/notes");
+ let b = tmp.path().join("b/notes");
+ let bare = tmp.path().join("c/bare");
+ let idless = tmp.path().join("d/idless");
+ for ws in [&a, &b, &bare, &idless] {
+ write_craft_session(ws, "260901-same-name", serde_json::json!({}));
+ }
+ fs::write(
+ a.join("config.json"),
+ r#"{"id":"ws_aaaa1111","slug":"notes"}"#,
+ )
+ .unwrap();
+ fs::write(
+ b.join("config.json"),
+ r#"{"id":"ws_bbbb2222","slug":"notes"}"#,
+ )
+ .unwrap();
+ fs::write(idless.join("config.json"), r#"{"slug":"idless"}"#).unwrap();
+ let native_of = |ws: &Path| -> Vec<String> {
+ CraftAdapter::new()
+ .with_custom_root(ws.to_path_buf())
+ .list_session_files()
+ .unwrap()
+ .into_iter()
+ .map(|r| r.native_id)
+ .collect()
+ };
+ assert_eq!(native_of(&a), ["ws_aaaa1111/260901-same-name"]);
+ assert_eq!(native_of(&b), ["ws_bbbb2222/260901-same-name"]);
+ assert_eq!(native_of(&bare), ["bare/260901-same-name"]);
+ assert_eq!(native_of(&idless), ["idless/260901-same-name"]);
+
+ // 父子关系两端都在同一个命名空间里拼
+ write_craft_session(
+ &a,
+ "260902-child",
+ serde_json::json!({"parentSessionId": "260901-same-name"}),
+ );
+ let adapter = CraftAdapter::new().with_custom_root(a.clone());
+ assert_eq!(
+ adapter.parent_links().unwrap(),
+ [(
+ "craft-agents:ws_aaaa1111/260902-child".to_string(),
+ "craft-agents:ws_aaaa1111/260901-same-name".to_string()
+ )]
+ );
+ // config.json 写坏了:沿用上次读到的 id,不退回目录名换 key
+ fs::write(a.join("config.json"), "{ not json").unwrap();
+ assert_eq!(
+ adapter.list_session_files().unwrap()[0].native_id,
+ "ws_aaaa1111/260901-same-name"
+ );
+ // 没读到过就不知道:这一刻不列,别拿目录名顶
+ assert!(CraftAdapter::new()
+ .with_custom_root(a)
+ .list_session_files()
+ .unwrap()
+ .is_empty());
+}
+
+#[test]
+fn craft_snapshots_tell_unreadable_from_absent() {
+ let tmp = tempfile::tempdir().unwrap();
+ let ws = tmp.path().join("ws");
+ let claude = |n: u8| format!("c1a0de00-0000-4000-8000-0000000000{n:02}");
+ write_craft_session(
+ &ws,
+ "260901-one",
+ serde_json::json!({"sdkSessionId": claude(1)}),
+ );
+ write_craft_session(
+ &ws,
+ "260902-two",
+ serde_json::json!({"sdkSessionId": claude(2)}),
+ );
+ let ids = |adapter: &dyn AgentAdapter| -> Option<Vec<String>> {
+ Some(
+ adapter
+ .claimed_sessions()?
+ .into_iter()
+ .map(|(_, id)| id)
+ .collect(),
+ )
+ };
+ let adapter = CraftAdapter::new().with_custom_root(ws.clone());
+ assert_eq!(ids(adapter.as_ref()).unwrap(), [claude(1), claude(2)]);
+
+ // 首行写坏了(不是 JSON):craft 自己也列不出,当它没有——快照照样完整
+ let two = ws.join("sessions/260902-two/session.jsonl");
+ fs::write(&two, "{ torn\n").unwrap();
+ assert_eq!(ids(adapter.as_ref()).unwrap(), [claude(1)]);
+ // 原子写的空档(正本已删、.tmp 还没改名过来):沿用上次读到的,认领不撤
+ let one = ws.join("sessions/260901-one/session.jsonl");
+ let parked = one.with_extension("jsonl.tmp");
+ fs::rename(&one, &parked).unwrap();
+ assert_eq!(ids(adapter.as_ref()).unwrap(), [claude(1)]);
+ fs::rename(&parked, &one).unwrap();
+
+ // 读不出来(权限)又没读到过:整份快照交回 None,scanner 保留库里的认领与父子关系;
+ // 读到过的沿用上次那份
+ #[cfg(unix)]
+ {
+ use std::os::unix::fs::PermissionsExt;
+ fs::set_permissions(&one, fs::Permissions::from_mode(0o000)).unwrap();
+ // root 跑测试时权限拦不住,这一段没有意义
+ if fs::File::open(&one).is_err() {
+ assert_eq!(ids(adapter.as_ref()).unwrap(), [claude(1)]);
+ let fresh = CraftAdapter::new().with_custom_root(ws.clone());
+ assert!(fresh.claimed_sessions().is_none());
+ assert!(fresh.parent_links().is_none());
+ assert!(
+ fresh.list_session_files().unwrap().is_empty(),
+ "没读到过首行的会话不列:分不清它是不是隐藏会话"
+ );
+ }
+ fs::set_permissions(&one, fs::Permissions::from_mode(0o644)).unwrap();
+ }
+}
+
+#[test]
+fn craft_custom_root_lifts_a_chosen_sessions_dir_to_its_workspace() {
+ let tmp = tempfile::tempdir().unwrap();
+ let workspace = tmp.path().join("Notes");
+ fs::create_dir_all(workspace.join("sessions")).unwrap();
+ let normalize =
+ |dir: PathBuf| wake_core::adapters::normalize_custom_root(AgentId::CraftAgents, dir);
+ assert_eq!(normalize(workspace.join("sessions")), workspace);
+ assert_eq!(normalize(workspace.clone()), workspace);
+ // 一个恰好叫 sessions 的工作区(底下还有自己的 sessions/)不上提
+ let odd = tmp.path().join("sessions");
+ fs::create_dir_all(odd.join("sessions")).unwrap();
+ assert_eq!(normalize(odd.clone()), odd);
+}
+
/// 旧版转录取假 HOME 里 stage_sidecars 拷入的那份(file_ref 只认自己根下的路径)
fn openclaw_legacy_ref(env: &TestEnv) -> SessionFileRef {
let sessions = env
diff --git a/crates/wake-core/tests/common/mod.rs b/crates/wake-core/tests/common/mod.rs
index 1096c33..d5064ad 100644
--- a/crates/wake-core/tests/common/mod.rs
+++ b/crates/wake-core/tests/common/mod.rs
@@ -223,6 +223,7 @@ pub fn stage_dir_fixtures(home: &Path) {
("qoder", ".qoder"),
("codebuddy", ".codebuddy"),
("codebuddy", ".workbuddy"),
+ ("craft-agents", ".craft-agent"),
] {
copy_tree(&fixture(src), &home.join(dst));
}
diff --git a/crates/wake-core/tests/db_roundtrip.rs b/crates/wake-core/tests/db_roundtrip.rs
index bcc65c5..3f8b67d 100644
--- a/crates/wake-core/tests/db_roundtrip.rs
+++ b/crates/wake-core/tests/db_roundtrip.rs
@@ -2003,3 +2003,53 @@ fn an_unwritable_holder_note_does_not_forfeit_the_lock() {
Ownership::Ours(_) => panic!("the lock must still be held"),
}
}
+
+/// 外壳产品的认领(claimed_sessions 表):认领落地即删掉已入库的替身(连 FTS 一起)、
+/// 两条写库路径都挡住它、认领撤销后能照常写回;认领方清单给"roster 里已经没有的
+/// 认领方整组撤销"用
+#[test]
+fn claims_hide_the_copy_until_released() {
+ let (_dir, store) = temp_store();
+ let copy = meta("claude-code:engine-1", "引擎那份转录");
+ store
+ .write_session(
+ &copy,
+ copy.updated_at,
+ &[unit(0, Role::User, "二维码扫描崩了")],
+ )
+ .unwrap();
+ let never_ranks = |_: &str| 0u8;
+
+ assert!(store
+ .replace_claims(AgentId::CraftAgents, &[copy.key.clone()])
+ .unwrap());
+ assert!(
+ store.get_session(&copy.key).unwrap().is_none(),
+ "替身没出库"
+ );
+ assert!(
+ store.search("二维码", &[], None, 10).unwrap().0.is_empty(),
+ "替身的正文还在 FTS 里"
+ );
+ assert!(store.is_key_claimed(&copy.key));
+ assert_eq!(store.claimants().unwrap(), vec![AgentId::CraftAgents]);
+ // 全量 / 增量共用的写入闸门与 quick 路径都挡
+ assert!(!store
+ .write_session_guarded(&copy, copy.updated_at, &[], &[], &never_ranks, None)
+ .unwrap());
+ store.write_meta_only(&[(copy.clone(), 0)]).unwrap();
+ assert!(store.get_session(&copy.key).unwrap().is_none());
+ // 同一快照再对一遍:没有变化
+ assert!(!store
+ .replace_claims(AgentId::CraftAgents, &[copy.key.clone()])
+ .unwrap());
+
+ // 撤销(认领方会话没了):替身可以写回
+ assert!(store.replace_claims(AgentId::CraftAgents, &[]).unwrap());
+ assert!(!store.is_key_claimed(&copy.key));
+ assert!(store.claimants().unwrap().is_empty());
+ assert!(store
+ .write_session_guarded(&copy, copy.updated_at, &[], &[], &never_ranks, None)
+ .unwrap());
+ assert!(store.get_session(&copy.key).unwrap().is_some());
+}
diff --git a/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/config.json b/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/config.json
new file mode 100644
index 0000000..4ad1a58
--- /dev/null
+++ b/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/config.json
@@ -0,0 +1,10 @@
+{
+ "id": "ws_f1x7e5a0",
+ "name": "WakeFx",
+ "slug": "wakefx-ws",
+ "defaults": {
+ "permissionMode": "ask"
+ },
+ "createdAt": 1786100000000,
+ "updatedAt": 1786100000000
+}
diff --git a/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260801-brave-otter/attachments/crash.png b/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260801-brave-otter/attachments/crash.png
new file mode 100644
index 0000000..8f8c607
--- /dev/null
+++ b/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260801-brave-otter/attachments/crash.png
@@ -0,0 +1 @@
+not-a-png
diff --git a/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260801-brave-otter/meta/claude-turn-anchors.json b/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260801-brave-otter/meta/claude-turn-anchors.json
new file mode 100644
index 0000000..a6bb303
--- /dev/null
+++ b/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260801-brave-otter/meta/claude-turn-anchors.json
@@ -0,0 +1,13 @@
+{
+ "version": 1,
+ "anchors": {
+ "msg-1786200002000-a2": {
+ "sdkSessionId": "c1a0de00-aaaa-4bbb-8ccc-00000000000a",
+ "sdkMessageUuid": "msg_01Fixture01"
+ },
+ "msg-1786200005000-a3": {
+ "sdkSessionId": "c1a0de00-aaaa-4bbb-8ccc-000000000001",
+ "sdkMessageUuid": "msg_01Fixture03"
+ }
+ }
+}
diff --git a/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260801-brave-otter/session.jsonl b/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260801-brave-otter/session.jsonl
new file mode 100644
index 0000000..b7a7dfa
--- /dev/null
+++ b/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260801-brave-otter/session.jsonl
@@ -0,0 +1,11 @@
+{"id":"260801-brave-otter","workspaceRootPath":"~/.craft-agent/workspaces/wakefx-ws","sdkSessionId":"c1a0de00-aaaa-4bbb-8ccc-000000000001","sdkCwd":"/Users/tester/Github/wakefx","createdAt":1786200000000,"lastUsedAt":1786299999999,"lastMessageAt":1786200060000,"name":"Fix QR scanner crash","isFlagged":false,"permissionMode":"ask","workingDirectory":"/Users/tester/Github/wakefx","model":"claude-opus-5-5","llmConnection":"claude-max","connectionLocked":true,"messageCount":9,"lastMessageRole":"user","preview":"The QR scanner crashes on unmount, can you look?","tokenUsage":{"inputTokens":1200,"outputTokens":300,"totalTokens":1500,"contextTokens":0,"costUsd":0.02},"lastFinalMessageId":"msg-1786200005000-a3"}
+{"id":"msg-1786200001000-a1","type":"user","content":"The QR scanner crashes on unmount, can you look? [file:src/qr.tsx]","timestamp":1786200001000,"attachments":[{"id":"att-1","type":"image","name":"crash.png","mimeType":"image/png","size":8,"storedPath":"{{SESSION_PATH}}/attachments/crash.png"}]}
+{"id":"msg-1786200002000-a2","type":"assistant","content":"Let me read the scanner component first.","timestamp":1786200002000,"isIntermediate":true,"turnId":"msg_01Fixture01"}
+{"id":"msg-1786200003000-t1","type":"tool","content":"Running Read...","timestamp":1786200003000,"toolName":"Read","toolUseId":"toolu_01","toolInput":{"file_path":"src/qr.tsx"},"toolResult":"useEffect(() => { start(device) }, [])","toolStatus":"completed","toolIntent":"Read the scanner component","turnId":"msg_01Fixture01"}
+{"id":"msg-1786200003500-t2","type":"tool","content":"","timestamp":1786200003500,"toolName":"Grep","toolUseId":"toolu_sub_01","toolInput":{"pattern":"device"},"toolResult":"src/qr.tsx:3","toolStatus":"completed","parentToolUseId":"toolu_task_01"}
+{"id":"msg-1786200003600-a4","type":"assistant","content":"Subagent notes: device is captured once.","timestamp":1786200003600,"isIntermediate":true,"parentToolUseId":"toolu_task_01"}
+{"id":"msg-1786200004000-t3","type":"tool","content":"Running Bash...","timestamp":1786200004000,"toolName":"Bash","toolUseId":"toolu_02","toolInput":{"command":"cat {{SESSION_PATH}}/plans/notes.md"},"toolResult":"[ERROR] cat: notes.md: No such file or directory","toolStatus":"error","isError":true,"turnId":"msg_01Fixture01"}
+{"id":"msg-1786200005000-a3","type":"assistant","content":"The dependency array is missing `device`, so the effect never re-subscribes after unmount.","timestamp":1786200005000,"isIntermediate":false,"turnId":"msg_01Fixture03"}
+{"id":"msg-1786200006000-i1","type":"info","content":"Compacted conversation","timestamp":1786200006000,"statusType":"compaction_complete"}
+{"id":"msg-1786200007000-u2","type":"user","content":"Background task finished: lint passed","timestamp":1786200007000,"hidden":true}
+{"id":"msg-1786200008000-x1","type":"mystery-row","content":"?","timestamp":1786200008000}
diff --git a/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260801-brave-otter/session.jsonl.tmp b/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260801-brave-otter/session.jsonl.tmp
new file mode 100644
index 0000000..8946ad0
--- /dev/null
+++ b/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260801-brave-otter/session.jsonl.tmp
@@ -0,0 +1 @@
+{"id":"260801-brave-otter","workspaceRootPath":"~/.craft-agent/workspaces/wakefx-ws","createdAt":1786200000000,"lastUsedAt":1786200000000,"name":"half-written atomic save","messageCount":0,"tokenUsage":{"inputTokens":0,"outputTokens":0,"totalTokens":0,"contextTokens":0,"costUsd":0}}
diff --git a/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260802-quiet-lake/.pi-sessions/2026-08-09T09-00-00-000Z_01a0d3b2-0000-7000-8000-000000000002.jsonl b/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260802-quiet-lake/.pi-sessions/2026-08-09T09-00-00-000Z_01a0d3b2-0000-7000-8000-000000000002.jsonl
new file mode 100644
index 0000000..9165f3f
--- /dev/null
+++ b/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260802-quiet-lake/.pi-sessions/2026-08-09T09-00-00-000Z_01a0d3b2-0000-7000-8000-000000000002.jsonl
@@ -0,0 +1,2 @@
+{"type":"session","version":3,"id":"01a0d3b2-0000-7000-8000-000000000002","timestamp":"2026-08-09T09:00:00.000Z","cwd":"/Users/tester/.craft-agent/workspaces/wakefx-ws"}
+{"type":"message","id":"p1","parentId":null,"timestamp":"2026-08-09T09:00:01.000Z","message":{"role":"user","content":[{"type":"text","text":"**USER'S DATE AND TIME: Sunday, August 9, 2026** <session_state>sessionId: 260802-quiet-lake</session_state> Summarise yesterday's merged PRs"}]}}
diff --git a/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260802-quiet-lake/session.jsonl b/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260802-quiet-lake/session.jsonl
new file mode 100644
index 0000000..398293c
--- /dev/null
+++ b/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260802-quiet-lake/session.jsonl
@@ -0,0 +1,3 @@
+{"id":"260802-quiet-lake","workspaceRootPath":"~/.craft-agent/workspaces/wakefx-ws","sdkSessionId":"01a0d3b2-0000-7000-8000-000000000002","sdkCwd":"~/.craft-agent/workspaces/wakefx-ws/sessions/260802-quiet-lake","createdAt":1786300000000,"lastUsedAt":1786399999999,"lastMessageAt":1786300030000,"name":"Daily standup brief","sessionStatus":"done","labels":["Scheduled"],"model":"pi/gpt-6-astra","llmConnection":"chatgpt-plus","connectionLocked":true,"isArchived":true,"archivedAt":1786400000000,"triggeredBy":{"automationName":"Standup","event":"SchedulerTick","timestamp":1786300000000},"messageCount":2,"lastMessageRole":"assistant","preview":"Summarise yesterday's merged PRs","tokenUsage":{"inputTokens":900,"outputTokens":100,"totalTokens":0,"contextTokens":0,"costUsd":0.01}}
+{"id":"msg-1786300001000-b1","type":"user","content":"Summarise yesterday's merged PRs","timestamp":1786300001000}
+{"id":"msg-1786300030000-b2","type":"assistant","content":"Two PRs merged: the QR scanner fix and the lint bump.","timestamp":1786300030000,"isIntermediate":false,"turnId":"pi-turn-1__m0"}
diff --git a/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260803-bold-pine/session.jsonl b/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260803-bold-pine/session.jsonl
new file mode 100644
index 0000000..e13009e
--- /dev/null
+++ b/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260803-bold-pine/session.jsonl
@@ -0,0 +1,6 @@
+{"id":"260803-bold-pine","workspaceRootPath":"~/.craft-agent/workspaces/wakefx-ws","sdkSessionId":"c1a0de00-aaaa-4bbb-8ccc-000000000003","sdkCwd":"/Users/tester/Github/wakefx","createdAt":1786500000000,"lastUsedAt":1786599999999,"lastMessageAt":1786500020000,"workingDirectory":"/Users/tester/Github/wakefx","model":"claude-opus-5-5","llmConnection":"claude-max","branchFromMessageId":"msg-1786200002000-a2","branchFromSdkSessionId":"c1a0de00-aaaa-4bbb-8ccc-000000000001","branchFromSessionPath":"/Users/tester/.craft-agent/workspaces/wakefx-ws/sessions/260801-brave-otter","branchFromSdkCwd":"/Users/tester/Github/wakefx","messageCount":5,"lastMessageRole":"assistant","preview":"The QR scanner crashes on unmount, can you look?","tokenUsage":{"inputTokens":400,"outputTokens":80,"totalTokens":480,"contextTokens":0,"costUsd":0.01}}
+{"id":"msg-1786200001000-a1","type":"user","content":"The QR scanner crashes on unmount, can you look? [file:src/qr.tsx]","timestamp":1786200001000}
+{"id":"msg-1786200002000-a2","type":"assistant","content":"Let me read the scanner component first.","timestamp":1786200002000,"isIntermediate":true,"turnId":"msg_01Fixture01"}
+{"id":"msg-1786500010000-c1","type":"tool","content":"","timestamp":1786500010000,"toolName":"Read","toolUseId":"toolu_c1","toolInput":{"file_path":"src/camera.tsx"},"toolResult":"export function Camera() {}","toolStatus":"completed"}
+{"id":"msg-1786500011000-c2","type":"user","content":"Try the camera module instead","timestamp":1786500011000}
+{"id":"msg-1786500020000-c3","type":"assistant","content":"The camera module releases the device correctly.","timestamp":1786500020000,"isIntermediate":false,"turnId":"msg_01Fixture05"}
diff --git a/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260804-tiny-fern/session.jsonl b/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260804-tiny-fern/session.jsonl
new file mode 100644
index 0000000..8a39857
--- /dev/null
+++ b/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260804-tiny-fern/session.jsonl
@@ -0,0 +1,2 @@
+{"id":"260804-tiny-fern","workspaceRootPath":"~/.craft-agent/workspaces/wakefx-ws","sdkSessionId":"c1a0de00-aaaa-4bbb-8ccc-000000000004","sdkCwd":"~/.craft-agent/workspaces/wakefx-ws/sessions/260804-tiny-fern","createdAt":1786600000000,"lastUsedAt":1786600010000,"lastMessageAt":1786600005000,"model":"claude-haiku-4-5","hidden":true,"messageCount":1,"lastMessageRole":"user","preview":"rename the Scheduled label","tokenUsage":{"inputTokens":50,"outputTokens":10,"totalTokens":60,"contextTokens":0,"costUsd":0}}
+{"id":"msg-1786600005000-d1","type":"user","content":"<edit_request>rename the Scheduled label</edit_request>","timestamp":1786600005000}
diff --git a/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260805-calm-reed/session.jsonl b/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260805-calm-reed/session.jsonl
new file mode 100644
index 0000000..135977e
--- /dev/null
+++ b/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sessions/260805-calm-reed/session.jsonl
@@ -0,0 +1,5 @@
+{"id":"260805-calm-reed","workspaceRootPath":"~/.craft-agent/workspaces/wakefx-ws","sdkSessionId":"c1a0de00-aaaa-4bbb-8ccc-000000000005","sdkCwd":"/Users/tester/Github/wakefx","createdAt":1786700000000,"lastUsedAt":1786799999999,"lastMessageAt":1786700001000,"name":"Write regression test","workingDirectory":"/Users/tester/Github/wakefx","model":"claude-opus-5-5","llmConnection":"claude-max","parentSessionId":"260801-brave-otter","messageCount":4,"lastMessageRole":"error","preview":"Add a regression test for the unmount crash","tokenUsage":{"inputTokens":300,"outputTokens":60,"totalTokens":360,"contextTokens":0,"costUsd":0.01}}
+{"id":"msg-1786700001000-e1","type":"user","content":"Add a regression test for the unmount crash","timestamp":1786700001000}
+{"id":"plan-1786700002000-e2","type":"plan","content":"# Regression test plan\n1. Mount and unmount the scanner\n2. Assert the device is released","timestamp":1786700002000,"planPath":"{{SESSION_PATH}}/plans/2026-08-12-regression-test.md"}
+{"id":"msg-1786700003000-e3","type":"auth-request","content":"Sign in to GitHub to continue","timestamp":1786700003000,"authRequestId":"auth-1","authRequestType":"oauth","authSourceSlug":"github","authStatus":"pending"}
+{"id":"msg-1786700004000-e4","type":"error","content":"Rate limited, retrying later","timestamp":1786700004000,"errorCode":"rate_limited","errorTitle":"Rate limited"}
diff --git a/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sources/github/config.json b/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sources/github/config.json
new file mode 100644
index 0000000..bc9da1f
--- /dev/null
+++ b/crates/wake-core/tests/fixtures/craft-agents/workspaces/wakefx-ws/sources/github/config.json
@@ -0,0 +1,7 @@
+{
+ "slug": "github",
+ "type": "api",
+ "api": {
+ "googleOAuthClientSecret": "NOT-A-REAL-SECRET"
+ }
+}
diff --git a/crates/wake-core/tests/remote_sync.rs b/crates/wake-core/tests/remote_sync.rs
index b5ee47f..a6c40ba 100644
--- a/crates/wake-core/tests/remote_sync.rs
+++ b/crates/wake-core/tests/remote_sync.rs
@@ -166,6 +166,21 @@ fn remote_pipeline_end_to_end() {
);
assert!(!cache.join(".codex/auth.json").exists(), "凭证进了缓存");
assert!(!cache.join(".copilot").exists());
+ // Craft Agents:会话与回合锚点(认领要读)到位;源配置(可能带 client secret)、
+ // 附件、引擎原料与原子写的中间文件被带层级的 exclude 挡在外面
+ let craft_ws = cache.join(".craft-agent/workspaces/wakefx-ws");
+ let otter = craft_ws.join("sessions/260801-brave-otter");
+ assert!(
+ otter.join("session.jsonl").is_file(),
+ "Craft 会话没同步到缓存"
+ );
+ assert!(otter.join("meta/claude-turn-anchors.json").is_file());
+ assert!(!craft_ws.join("sources").exists(), "Craft 的源配置进了缓存");
+ assert!(!otter.join("attachments").exists());
+ assert!(!otter.join("session.jsonl.tmp").exists());
+ assert!(!craft_ws
+ .join("sessions/260802-quiet-lake/.pi-sessions")
+ .exists());
assert!(
cache
.join(".gemini/antigravity-cli/conversation_summaries.db")
diff --git a/crates/wake-core/tests/scanner_finale.rs b/crates/wake-core/tests/scanner_finale.rs
index 3ab529f..62e85de 100644
--- a/crates/wake-core/tests/scanner_finale.rs
+++ b/crates/wake-core/tests/scanner_finale.rs
@@ -1825,3 +1825,233 @@ fn local_and_remote_copies_of_same_native_id_both_survive() {
assert!(store.get_session(&local_key).unwrap().is_some());
assert!(store.get_session(&remote_key).unwrap().is_some());
}
+
+/// Craft fixture 认领的几份引擎转录:A 首行里的当前 SDK 会话、A 锚点边车里更早的一份、
+/// 子任务 E 的
+const CRAFT_CLAIMED: [&str; 3] = [
+ "c1a0de00-aaaa-4bbb-8ccc-000000000001",
+ "c1a0de00-aaaa-4bbb-8ccc-00000000000a",
+ "c1a0de00-aaaa-4bbb-8ccc-000000000005",
+];
+/// 谁都不认领的普通 Claude Code 会话(对照组)
+const UNCLAIMED: &str = "11111111-aaaa-bbbb-cccc-000000000001";
+
+/// Claude projects 树里摆出这几个 id 的转录(内容借 fixture 的一份,key 取文件名)
+fn stage_claude_transcripts(projects: &Path, ids: &[&str]) {
+ let proj = projects.join("-Users-tester-Github-wakefx");
+ std::fs::create_dir_all(&proj).unwrap();
+ let transcript = common::fixture(&format!(
+ "claude/projects/-Users-tester-Github-wakefx/{UNCLAIMED}.jsonl"
+ ));
+ for id in ids {
+ std::fs::copy(&transcript, proj.join(format!("{id}.jsonl"))).unwrap();
+ }
+}
+
+/// Craft Agents 的 Claude 后端跑的是 Claude Agent SDK,引擎在 `~/.claude/projects` 里另落
+/// 一份转录:同一段对话会以 Claude Code 身份再列一次。Craft 会话认领它(首行的
+/// sdkSessionId + 回合锚点边车里出现过的 id,隐藏的 mini 会话也认领),替身不入库、
+/// 已入库的出库;原件没了(会话被删、Craft 的 location 整个移除)认领撤销,替身回来
+#[test]
+fn craft_claims_hide_claude_engine_copies_until_the_original_goes() {
+ use wake_core::adapters::claude::ClaudeAdapter;
+ use wake_core::adapters::craft::CraftAdapter;
+
+ let home = tempfile::tempdir().unwrap();
+ let projects = home.path().join("claude-projects");
+ let claimed = CRAFT_CLAIMED;
+ stage_claude_transcripts(&projects, &[&claimed[..], &[UNCLAIMED]].concat());
+ let craft_root = home.path().join("workspaces");
+ common::copy_tree(&common::fixture("craft-agents/workspaces"), &craft_root);
+
+ let dir = tempfile::tempdir().unwrap();
+ let store = temp_store(dir.path());
+ let claude = || ClaudeAdapter::new().with_custom_root(projects.clone());
+ let craft = || CraftAdapter::new().with_custom_root(craft_root.clone());
+ let claude_key = |id: &str| format!("claude-code:{id}");
+ let indexed = |key: &str| store.get_session(key).unwrap().is_some();
+
+ // 装 Craft 之前:引擎那几份就是普通的 Claude Code 会话
+ run_scan(&[claude()], &store, &Recorder::new(), true).unwrap();
+ assert!(claimed.iter().all(|id| indexed(&claude_key(id))));
+
+ // 加上 Craft:替身出库,Craft 会话进库,对照组不受影响
+ let events = Recorder::new();
+ run_scan(&[claude(), craft()], &store, &events, false).unwrap();
+ for id in claimed {
+ assert!(!indexed(&claude_key(id)), "{id} 的引擎副本还挂着");
+ }
+ assert!(indexed(&claude_key(UNCLAIMED)));
+ assert!(indexed("craft-agents:ws_f1x7e5a0/260801-brave-otter"));
+ assert!(events.changed() > 0, "替身出库要通知列表刷新");
+ let keys = store.claimed_keys().unwrap();
+ for id in [
+ "c1a0de00-aaaa-4bbb-8ccc-000000000003", // 分支
+ "c1a0de00-aaaa-4bbb-8ccc-000000000004", // 隐藏的 mini 会话:不进列表但照样认领
+ ] {
+ assert!(keys.contains(&claude_key(id)), "{id} 没被认领");
+ }
+ assert!(
+ !keys.iter().any(|k| k.contains("01a0d3b2")),
+ "Pi 后端的会话不该认领 Claude 的 key: {keys:?}"
+ );
+ // 子任务与分支挂在原会话下
+ for child in ["260805-calm-reed", "260803-bold-pine"] {
+ assert_eq!(
+ store
+ .parent_key_of(&format!("craft-agents:ws_f1x7e5a0/{child}"))
+ .unwrap()
+ .as_deref(),
+ Some("craft-agents:ws_f1x7e5a0/260801-brave-otter"),
+ "{child}"
+ );
+ }
+
+ // 引擎那份还在长(Craft 里继续聊):watcher 的增量也不许把它写回来
+ let engine = projects
+ .join("-Users-tester-Github-wakefx")
+ .join(format!("{}.jsonl", claimed[0]));
+ let r = claude().file_ref(&engine).expect("engine transcript ref");
+ scan_files(&[claude(), craft()], &store, &Recorder::new(), vec![r]);
+ assert!(!indexed(&claude_key(claimed[0])));
+
+ // 在 Craft 里删掉原会话:认领撤销,它的两份引擎副本在这一轮扫描就回来
+ std::fs::remove_dir_all(craft_root.join("wakefx-ws/sessions/260801-brave-otter")).unwrap();
+ run_scan(&[claude(), craft()], &store, &Recorder::new(), false).unwrap();
+ assert!(indexed(&claude_key(claimed[0])));
+ assert!(indexed(&claude_key(claimed[1])));
+ assert!(
+ !indexed(&claude_key(claimed[2])),
+ "子任务还在,它的副本仍被认领"
+ );
+
+ // Craft 整个不在 roster 里了(location 移除):认领方消失,剩下的替身全部放回
+ run_scan(&[claude()], &store, &Recorder::new(), false).unwrap();
+ assert!(indexed(&claude_key(claimed[2])));
+ assert!(store.claimed_keys().unwrap().is_empty());
+}
+
+/// 远程镜像:认领的 key 按**报认领的实例**的 host 拼(`claude-code:devbox:<id>`),只藏
+/// 同一台机器上的替身;本机同 id 的 Claude 会话(不同 host 是另一条会话)不受影响
+#[test]
+fn craft_claims_on_a_remote_host_carry_that_host() {
+ use wake_core::adapters::claude::ClaudeAdapter;
+ use wake_core::adapters::craft::CraftAdapter;
+ use wake_core::adapters::remote::RemoteAdapter;
+
+ let home = tempfile::tempdir().unwrap();
+ let local = home.path().join("local-claude");
+ let mirror = home.path().join("devbox-claude");
+ stage_claude_transcripts(&local, &CRAFT_CLAIMED);
+ stage_claude_transcripts(&mirror, &CRAFT_CLAIMED);
+ let craft_mirror = home.path().join("devbox-workspaces");
+ common::copy_tree(&common::fixture("craft-agents/workspaces"), &craft_mirror);
+ let mirror_prefix = craft_mirror.to_string_lossy().to_string();
+
+ let dir = tempfile::tempdir().unwrap();
+ let store = temp_store(dir.path());
+ let adapters: Vec<Box<dyn AgentAdapter>> = vec![
+ ClaudeAdapter::new().with_custom_root(local),
+ Box::new(RemoteAdapter::new(
+ ClaudeAdapter::new().with_custom_root(mirror),
+ "devbox",
+ )),
+ Box::new(RemoteAdapter::new(
+ CraftAdapter::new().with_custom_root(craft_mirror),
+ "devbox",
+ )),
+ ];
+ run_scan(&adapters, &store, &Recorder::new(), true).unwrap();
+
+ let indexed = |key: &str| store.get_session(key).unwrap().is_some();
+ for id in CRAFT_CLAIMED {
+ assert!(
+ !indexed(&format!("claude-code:devbox:{id}")),
+ "devbox 上的替身没藏"
+ );
+ assert!(indexed(&format!("claude-code:{id}")), "本机那份被误藏");
+ }
+ assert!(indexed(
+ "craft-agents:devbox:ws_f1x7e5a0/260801-brave-otter"
+ ));
+ assert!(store
+ .claimed_keys()
+ .unwrap()
+ .contains(&format!("claude-code:devbox:{}", CRAFT_CLAIMED[0])));
+ // 没设工作目录的会话归到工作区:取首行记的工作区路径,不是文件此刻所在的本机缓存目录
+ //(拿缓存目录当项目,按远端的工作区路径就筛不到它)
+ let lake = store
+ .get_session("craft-agents:devbox:ws_f1x7e5a0/260802-quiet-lake")
+ .unwrap()
+ .expect("lake indexed");
+ assert!(
+ !lake.project_path.starts_with(&mirror_prefix),
+ "{}",
+ lake.project_path
+ );
+ assert_eq!(lake.project_name, "wakefx-ws");
+}
+
+/// 合成一条 craft 会话(首行 + 一句用户消息),返回它的 session.jsonl
+fn craft_session(workspace: &Path, session: &str, parent: Option<&str>) -> std::path::PathBuf {
+ let dir = workspace.join("sessions").join(session);
+ std::fs::create_dir_all(&dir).unwrap();
+ let mut header = serde_json::json!({ "id": session, "createdAt": 1786200000000i64 });
+ if let Some(parent) = parent {
+ header["parentSessionId"] = serde_json::json!(parent);
+ }
+ let line = serde_json::json!({
+ "id": "m1", "type": "user", "content": format!("hello from {session}"),
+ "timestamp": 1786200000000i64
+ });
+ let path = dir.join("session.jsonl");
+ std::fs::write(&path, format!("{header}\n{line}\n")).unwrap();
+ path
+}
+
+/// Craft 的父子关系写在子会话自己的首行里:多 location 下按**子会话的胜出文件**认边。
+/// Grok 那条"报边者必须拥有 parent"(边车长在 parent 的 location 里)套在这里两头都错:
+/// 父会话胜出文件在 A、子会话只在 B,边会被丢掉;A 里还躺着子会话一份更旧的备份、写着
+/// 早已不成立的关系,A 拥有 parent,旧关系反被采纳
+#[test]
+fn craft_parent_links_follow_the_childs_winning_copy() {
+ use wake_core::adapters::craft::CraftAdapter;
+
+ let tmp = tempfile::tempdir().unwrap();
+ let (a, b) = (tmp.path().join("a/notes"), tmp.path().join("b/notes"));
+ for ws in [&a, &b] {
+ std::fs::create_dir_all(ws).unwrap();
+ // 同一个工作区的两份(一份是备份):工作区 id 相同,会话 key 也就相同
+ std::fs::write(ws.join("config.json"), r#"{"id":"ws_same0000"}"#).unwrap();
+ }
+ craft_session(&a, "260901-parent", None);
+ craft_session(&b, "260902-child", Some("260901-parent"));
+
+ let dir = tempfile::tempdir().unwrap();
+ let store = temp_store(dir.path());
+ let adapters: Vec<Box<dyn AgentAdapter>> = vec![
+ CraftAdapter::new().with_custom_root(a.clone()),
+ CraftAdapter::new().with_custom_root(b.clone()),
+ ];
+ let child = "craft-agents:ws_same0000/260902-child";
+ let parent_of = || store.parent_key_of(child).unwrap();
+ run_scan(&adapters, &store, &Recorder::new(), true).unwrap();
+ assert_eq!(
+ parent_of().as_deref(),
+ Some("craft-agents:ws_same0000/260901-parent"),
+ "父会话在另一个 location 也要挂上"
+ );
+
+ // B 里那份改写成没有父会话;A 里多出一份更旧的、还写着旧关系的副本
+ let stale = craft_session(&a, "260902-child", Some("260901-parent"));
+ std::fs::File::options()
+ .write(true)
+ .open(&stale)
+ .and_then(|f| {
+ f.set_modified(std::time::SystemTime::now() - std::time::Duration::from_secs(3600))
+ })
+ .unwrap();
+ craft_session(&b, "260902-child", None);
+ run_scan(&adapters, &store, &Recorder::new(), false).unwrap();
+ assert_eq!(parent_of(), None, "落选副本里的旧关系不该被采纳");
+}
diff --git a/crates/wake/assets/brands/craft-agents.png b/crates/wake/assets/brands/craft-agents.png
new file mode 100644
index 0000000..d43b9de
Binary files /dev/null and b/crates/wake/assets/brands/craft-agents.png differ
diff --git a/crates/wake/src/assets.rs b/crates/wake/src/assets.rs
index 79a4218..2ba7578 100644
--- a/crates/wake/src/assets.rs
+++ b/crates/wake/src/assets.rs
@@ -62,6 +62,7 @@ brands!(
"codebuddy",
"workbuddy",
"zcode",
+ "craft-agents",
);
fn lookup_product(path: &str) -> Option<&'static [u8]> {
diff --git a/crates/wake/src/theme.rs b/crates/wake/src/theme.rs
index 3f545a8..f3680a0 100644
--- a/crates/wake/src/theme.rs
+++ b/crates/wake/src/theme.rs
@@ -108,6 +108,8 @@ pub fn agent_series_color(agent: wake_core::models::AgentId) -> u32 {
Workbuddy => 0x0EC8A9,
// 品牌是黑白的,趋势图里给一档中性石板灰
Zcode => 0x8B95A5,
+ // app 图标像素 "C" 的紫(取自内嵌 PNG),比 Kiro 的电光紫灰、暗
+ CraftAgents => 0x9570BE,
}
}
diff --git a/crates/wake/src/workbench.rs b/crates/wake/src/workbench.rs
index bf34d61..ab1de04 100644
--- a/crates/wake/src/workbench.rs
+++ b/crates/wake/src/workbench.rs
@@ -2344,7 +2344,7 @@ impl UsageBoard {
}
}
- /// Agents 全量列出(总共十九家);项目/模型长尾长,取前 6
+ /// Agents 全量列出(总共二十家);项目/模型长尾长,取前 6
fn limit(self) -> usize {
match self {
Self::Agents => usize::MAX,
diff --git a/docs/cli.md b/docs/cli.md
index a0c4749..2e62cf2 100644
--- a/docs/cli.md
+++ b/docs/cli.md
@@ -303,7 +303,7 @@ Numeric options outside their range are clamped, not rejected: `--limit 999` on
## Agent ids
-`claude-code`, `codex`, `grok`, `dsh`, `cursor`, `opencode`, `pi`, `omp`, `kiro`, `kimi`, `gemini`, `copilot`, `antigravity`, `qoder`, `hermes`, `openclaw`, `codebuddy`, `workbuddy`, `zcode`. Display names (`"Claude Code"`) and a few aliases (`claude`, `deepseek`) work too.
+`claude-code`, `codex`, `grok`, `dsh`, `cursor`, `opencode`, `pi`, `omp`, `kiro`, `kimi`, `gemini`, `copilot`, `antigravity`, `qoder`, `hermes`, `openclaw`, `codebuddy`, `workbuddy`, `zcode`, `craft-agents`. Display names (`"Claude Code"`) and a few aliases (`claude`, `deepseek`, `craft`) work too.
## Session keys and references
diff --git a/docs/mcp.md b/docs/mcp.md
index 5b14c4f..739a2ed 100644
--- a/docs/mcp.md
+++ b/docs/mcp.md
@@ -132,7 +132,7 @@ All five tools are read-only and return Markdown text (`content[0].text`). Param
| Parameter | Type | Meaning |
|---|---|---|
| `project` | string | Scope to one project. Pass an absolute path — the agent's working directory is ideal — or a project name. Path matching is three-tier: an exact match of an indexed project path; otherwise the longest indexed project that contains the path (you are in a subdirectory); otherwise every indexed project below the path (a monorepo root or a parent folder). A bare name matches the project name case-insensitively. When nothing matches, the reply lists the known projects instead of erroring. |
-| `agents` | string[] | Only these agents. Ids: `claude-code`, `codex`, `grok`, `dsh`, `cursor`, `opencode`, `pi`, `omp`, `kiro`, `kimi`, `gemini`, `copilot`, `antigravity`, `qoder`, `hermes`, `openclaw`, `codebuddy`, `workbuddy`, `zcode`. Display names (`"Claude Code"`, `"Gemini CLI"`) and a few aliases (`claude`, `deepseek`, `opencode2`) are accepted too. |
+| `agents` | string[] | Only these agents. Ids: `claude-code`, `codex`, `grok`, `dsh`, `cursor`, `opencode`, `pi`, `omp`, `kiro`, `kimi`, `gemini`, `copilot`, `antigravity`, `qoder`, `hermes`, `openclaw`, `codebuddy`, `workbuddy`, `zcode`, `craft-agents`. Display names (`"Claude Code"`, `"Gemini CLI"`) and a few aliases (`claude`, `deepseek`, `opencode2`, `craft`) are accepted too. |
| `since` | string | Only sessions updated at or after this time. Relative: `30m`, `24h`, `7d`, `2w`. Absolute: `2026-09-01`, `2026-09-01 09:30`, `2026-09-01T09:30:00Z`. Naive date-times are read in local time. |
| `limit` | integer | Maximum items to return; values outside the allowed range are clamped. |