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: MiMo Code sessions (#77)

Corey Chiu8c8cfcfdf3cc
diff --git a/CHANGELOG.md b/CHANGELOG.md
index abfaa64..c1a7679 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
# Changelog
+## [Unreleased]
+
+- New: MiMo Code sessions are indexed from its local database (`~/.local/share/mimocode/mimocode.db`, read-only) — titles, models, thinking, tool calls and token counts included. Sub-agents are listed under the session that started them, and the tool call that started one opens it. A session you imported into MiMo Code from Claude Code, Codex or OpenCode is listed only once you continue it there, and only the new part is indexed. Open In continues a session with `mimo --session` in its project directory. Not mirrored from remote hosts, since the database also holds MiMo Code's sign-in tokens (#77, thanks @lin-code-world)
+
## [0.10.0] — 2026-10-23
- New: A Skills page lists the skills your agents have installed, which agents share each one, and where copies of the same skill have drifted apart (#62, thanks @ICEY4040727)
diff --git a/PRODUCT.md b/PRODUCT.md
index abbfd4a..4a3a825 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 方案升级)、恢复/收藏/置顶/导出/删除(废纸篓+墓碑)、**子代理即子会话**(2026-10-12:各家 agent 派出去的子代理一律作为子会话挂在派它的会话下;Claude Code、Cursor、CodeBuddy / WorkBuddy、Qoder、Kimi Code 放在会话目录里的子代理转录也各自入库,能单独搜索、打开,Claude Code 的 Workflow 步骤同样;列表最多两层嵌套(原件 → 分支 → 分支派的子代理);详情页里派活的工具调用上有"打开子代理会话"、子会话头部有回到父会话的链接,对得上派活调用的家才有按钮;子代理随父会话一起删除,Claude Code 的分支不随原件删;子代理不能单独恢复,不给 Open In)、文件监听增量、Insights 统计页(0.3.0:活跃热力图与 streak、时段/星期/月份分布、Agents·Projects·Models 三榜单按 sessions/tokens/prompts 切换;2026-09-03 加 Last 7 days 周对比行与 Over time 近 53 周按 agent 堆叠的每周 prompts 趋势图;口径=主线用户消息,agent 派出去的子会话不算会话与提问、token 照算(2026-10-12),规格见 DESIGN.md)、Updates 页与 macOS Wake 菜单手动检查 GitHub 最新正式版并打开 Release 页更新(不后台联网、不自动替换应用包)、测试套件(adapter 契约、DB 往返、scanner 回归 + CI 三平台 + pre-commit,合成 fixture)、三端桌面(macOS 主平台;Linux/Windows experimental,终端恢复/废纸篓·回收站/剪贴板按平台原生实现,发版 CI 自动出六产物)、窗口记忆(0.3.6:记住所在屏幕/屏内位置/最大化/全屏,重启与 Dock 重开都回到原处,Settings 开在主窗所在屏)、完整 macOS 菜单栏(0.3.6:标准 Edit/Window 菜单、⌘W、Window → Main Window,主窗关闭后 About/Settings/Updates 仍可用)、导出 Markdown 与保存图片走系统「另存为」并记住上次目录(0.3.6,issue #25)、远程 host(0.4.0,issue #21:Settings → Remote hosts 配 SSH 目标,rsync 白名单镜像会话数据到本地缓存后与本地会话同列同搜,`@host` 徽章标识;阶段 1 只读——不动远端文件、远程会话禁删,resume 以 Copy SSH command 形态提供;分期计划见 CLAUDE.md「远程 host」节)、**MCP 接入**(0.5.0:随应用打包的只读 `wake-mcp` stdio server,四个工具 wake_search / wake_list_sessions / wake_get_session / wake_list_projects,Claude Code / Codex / Cursor 等任何 MCP 客户端可搜历史、按项目列会话、分页读转录;Settings → Connect 展示路径与可复制配置片段,只展示不代写别家配置;零 LLM、零网络、不写库;完整参考 docs/mcp.md)、**命令行与 Skill**(0.6.0:并排打包的只读 `wake-cli`,四个子命令 search / sessions / show / projects 加 setup,给"能跑 shell 但不说 MCP"的 agent 和真人用——它不新写查询逻辑,argv 翻成 JSON 喂同一批工具,输出与 MCP 客户端看到的**逐字节相同**(仅 CLI 末尾补一个换行)并由测试卡住,所以文档只需描述一份格式;`skills/wake/SKILL.md` 是可一行安装的 skill(`npx skills add iAmCorey/Wake`),用触发条件而非名词解释写 description,让 agent 自己想得起来去翻会话历史;完整参考 docs/cli.md;0.6.3 加 `wake-cli index`——装了 Wake 却从没启动过时,agent 自己跑一条就能把索引建起来继续干活,而不是停下来问人。它**只建不存在的索引**,已有的库原样交给 GUI:扫描落在旁边的临时库、扫完才原子占位,所以被中途杀掉可重试、撞上 GUI 首扫就退让;2026-09-22 加 `wake-cli refresh`,issue #43:app 不开时增量刷新已有索引,给靠 MCP / CLI 用 Wake、只在浏览时开 app 的人用 launch agent / systemd timer 定时跑,Wake 开着窗或还有扫描在写就退让——GUI 与两个写命令共用一把索引写锁,锁跟 Workbench 与写线程走、关窗即放,GUI 启动会等正在跑的 refresh 收尾)、Connect 页四区块(0.6.1:MCP server / MCP clients / Command line / Skill,每个面的第一块挂自己的文档链接)、**记忆可见层**(2026-09-17 起,只读:把各家 agent 自己写下的记忆——Claude Code 的按项目 auto-memory、Codex 的 memories 与逐会话摘要、ZCode 的按项目记忆——按项目聚合;GUI 的 Memory 页是侧栏底部的整页目的地,侧栏在这一页换成按记忆计数的 All Memory / Agents / Projects 导航;MCP 加第五个工具 `wake_list_memories`,`wake_get_session` 认 `wake://memory/…` 引用现场读文件,`wake_search` 末尾附记忆命中;CLI 加 `memories`;记忆的项目归属按它挂的会话在读时解析,永远跟着索引走。二期(2026-09-21)把用户写给 agent 的指令文件也收进来:各家 home 里的 CLAUDE.md / AGENTS.md(与 `rules/*.rules`)/ GEMINI.md,以及已索引项目根下的 CLAUDE.md / AGENTS.md / GEMINI.md / `.cursor/rules` / `.cursorrules` / `.kiro/steering` / `.github/copilot-instructions.md`,与记忆同列同搜、不另作区分;Settings 加 Memory locations 页,与 Session locations 同形制:逐来源开关、添加自定义目录或文件、Restore defaults。不编辑、不同步、不删除——写别家数据破铁律,要改一个 Reveal 就到;也不做"把会话自动写成记忆")、**Skills 只读总览**(2026-10-15,issue #62:各家 agent 把 skill 各自收在自己的目录里,同一个 skill 在几家各装一份、慢慢改得不一样,没处看全。Skills 页是侧栏底部的第四个整页目的地:按名字列出本机所有 skill——各家的用户级目录、多家共读的 `~/.agents/skills`、已索引项目里的项目级目录、Claude Code 插件自带的——每个 skill 标出装在哪几家、几份真实拷贝、哪些是符号链接、拷贝之间 SKILL.md 有没有分叉;侧栏是 All Skills / Duplicated / Agents(共享目录排第一)/ Projects;阅读面先列各处位置(点一处看那一份、标出与它相同还是不同、逐处 Reveal),再渲染 SKILL.md。只读:不安装、不拷贝、不链接、不同步、不删除——跨 agent 装同一份交给 `npx skills add`,Wake 只在有多份拷贝时提一句;不进索引库、不进 MCP / CLI(agent 本来就读自己的 skill))。后续边界(2026-09-07 定):摘要层(需 LLM、opt-in、明示会把会话正文发给用户配置的端点)只在 MCP 接入有真实使用之后再做;Timeline / Profile 一类视图建立在摘要之上;不做 ChatGPT / Claude.ai 导出导入主线、不做实体本体与知识图谱、不做 Chrome 扩展注入。
+已实现:二十四家 adapter、FTS5 trigram 搜索(<3 码点 LIKE 降级)、**搜索跳转定位**(2026-08-18:⌘K 命中直达详情页对应消息并高亮,seq 契约保证)、详情页逐消息渲染(气泡/工具折叠簇/thinking/tree-sitter 高亮;2026-08-17 由整篇 markdown 方案升级)、恢复/收藏/置顶/导出/删除(废纸篓+墓碑)、**子代理即子会话**(2026-10-12:各家 agent 派出去的子代理一律作为子会话挂在派它的会话下;Claude Code、Cursor、CodeBuddy / WorkBuddy、Qoder、Kimi Code 放在会话目录里的子代理转录也各自入库,能单独搜索、打开,Claude Code 的 Workflow 步骤同样;列表最多两层嵌套(原件 → 分支 → 分支派的子代理);详情页里派活的工具调用上有"打开子代理会话"、子会话头部有回到父会话的链接,对得上派活调用的家才有按钮;子代理随父会话一起删除,Claude Code 的分支不随原件删;子代理不能单独恢复,不给 Open In)、文件监听增量、Insights 统计页(0.3.0:活跃热力图与 streak、时段/星期/月份分布、Agents·Projects·Models 三榜单按 sessions/tokens/prompts 切换;2026-09-03 加 Last 7 days 周对比行与 Over time 近 53 周按 agent 堆叠的每周 prompts 趋势图;口径=主线用户消息,agent 派出去的子会话不算会话与提问、token 照算(2026-10-12),规格见 DESIGN.md)、Updates 页与 macOS Wake 菜单手动检查 GitHub 最新正式版并打开 Release 页更新(不后台联网、不自动替换应用包)、测试套件(adapter 契约、DB 往返、scanner 回归 + CI 三平台 + pre-commit,合成 fixture)、三端桌面(macOS 主平台;Linux/Windows experimental,终端恢复/废纸篓·回收站/剪贴板按平台原生实现,发版 CI 自动出六产物)、窗口记忆(0.3.6:记住所在屏幕/屏内位置/最大化/全屏,重启与 Dock 重开都回到原处,Settings 开在主窗所在屏)、完整 macOS 菜单栏(0.3.6:标准 Edit/Window 菜单、⌘W、Window → Main Window,主窗关闭后 About/Settings/Updates 仍可用)、导出 Markdown 与保存图片走系统「另存为」并记住上次目录(0.3.6,issue #25)、远程 host(0.4.0,issue #21:Settings → Remote hosts 配 SSH 目标,rsync 白名单镜像会话数据到本地缓存后与本地会话同列同搜,`@host` 徽章标识;阶段 1 只读——不动远端文件、远程会话禁删,resume 以 Copy SSH command 形态提供;分期计划见 CLAUDE.md「远程 host」节)、**MCP 接入**(0.5.0:随应用打包的只读 `wake-mcp` stdio server,四个工具 wake_search / wake_list_sessions / wake_get_session / wake_list_projects,Claude Code / Codex / Cursor 等任何 MCP 客户端可搜历史、按项目列会话、分页读转录;Settings → Connect 展示路径与可复制配置片段,只展示不代写别家配置;零 LLM、零网络、不写库;完整参考 docs/mcp.md)、**命令行与 Skill**(0.6.0:并排打包的只读 `wake-cli`,四个子命令 search / sessions / show / projects 加 setup,给"能跑 shell 但不说 MCP"的 agent 和真人用——它不新写查询逻辑,argv 翻成 JSON 喂同一批工具,输出与 MCP 客户端看到的**逐字节相同**(仅 CLI 末尾补一个换行)并由测试卡住,所以文档只需描述一份格式;`skills/wake/SKILL.md` 是可一行安装的 skill(`npx skills add iAmCorey/Wake`),用触发条件而非名词解释写 description,让 agent 自己想得起来去翻会话历史;完整参考 docs/cli.md;0.6.3 加 `wake-cli index`——装了 Wake 却从没启动过时,agent 自己跑一条就能把索引建起来继续干活,而不是停下来问人。它**只建不存在的索引**,已有的库原样交给 GUI:扫描落在旁边的临时库、扫完才原子占位,所以被中途杀掉可重试、撞上 GUI 首扫就退让;2026-09-22 加 `wake-cli refresh`,issue #43:app 不开时增量刷新已有索引,给靠 MCP / CLI 用 Wake、只在浏览时开 app 的人用 launch agent / systemd timer 定时跑,Wake 开着窗或还有扫描在写就退让——GUI 与两个写命令共用一把索引写锁,锁跟 Workbench 与写线程走、关窗即放,GUI 启动会等正在跑的 refresh 收尾)、Connect 页四区块(0.6.1:MCP server / MCP clients / Command line / Skill,每个面的第一块挂自己的文档链接)、**记忆可见层**(2026-09-17 起,只读:把各家 agent 自己写下的记忆——Claude Code 的按项目 auto-memory、Codex 的 memories 与逐会话摘要、ZCode 的按项目记忆——按项目聚合;GUI 的 Memory 页是侧栏底部的整页目的地,侧栏在这一页换成按记忆计数的 All Memory / Agents / Projects 导航;MCP 加第五个工具 `wake_list_memories`,`wake_get_session` 认 `wake://memory/…` 引用现场读文件,`wake_search` 末尾附记忆命中;CLI 加 `memories`;记忆的项目归属按它挂的会话在读时解析,永远跟着索引走。二期(2026-09-21)把用户写给 agent 的指令文件也收进来:各家 home 里的 CLAUDE.md / AGENTS.md(与 `rules/*.rules`)/ GEMINI.md,以及已索引项目根下的 CLAUDE.md / AGENTS.md / GEMINI.md / `.cursor/rules` / `.cursorrules` / `.kiro/steering` / `.github/copilot-instructions.md`,与记忆同列同搜、不另作区分;Settings 加 Memory locations 页,与 Session locations 同形制:逐来源开关、添加自定义目录或文件、Restore defaults。不编辑、不同步、不删除——写别家数据破铁律,要改一个 Reveal 就到;也不做"把会话自动写成记忆")、**Skills 只读总览**(2026-10-15,issue #62:各家 agent 把 skill 各自收在自己的目录里,同一个 skill 在几家各装一份、慢慢改得不一样,没处看全。Skills 页是侧栏底部的第四个整页目的地:按名字列出本机所有 skill——各家的用户级目录、多家共读的 `~/.agents/skills`、已索引项目里的项目级目录、Claude Code 插件自带的——每个 skill 标出装在哪几家、几份真实拷贝、哪些是符号链接、拷贝之间 SKILL.md 有没有分叉;侧栏是 All Skills / Duplicated / Agents(共享目录排第一)/ Projects;阅读面先列各处位置(点一处看那一份、标出与它相同还是不同、逐处 Reveal),再渲染 SKILL.md。只读:不安装、不拷贝、不链接、不同步、不删除——跨 agent 装同一份交给 `npx skills add`,Wake 只在有多份拷贝时提一句;不进索引库、不进 MCP / CLI(agent 本来就读自己的 skill))。后续边界(2026-09-07 定):摘要层(需 LLM、opt-in、明示会把会话正文发给用户配置的端点)只在 MCP 接入有真实使用之后再做;Timeline / Profile 一类视图建立在摘要之上;不做 ChatGPT / Claude.ai 导出导入主线、不做实体本体与知识图谱、不做 Chrome 扩展注入。
约束:对 agent 数据目录只读;绝不写 Codex 的 SQLite;不读凭证;GPUI 无 SF Symbols(图标用 lucide SVG 自备)。
-已支持二十三家 agent:Claude Code、Codex(0.6.6 起排除可识别的内部线程:guardian auto-review、`/review`、compaction、memory consolidation 与用户会话同树,adapter 文件边界按首行 session_meta 的 source / thread_source 认出即不枚举;老格式或读不出的首行保守放行,`codex exec --thread-source` 打了标签的自动化线程照常收录,issue #30。`spawn_agent` 子代理是其中唯一的例外,issue #42:那是用户自己派出去的活,收录后挂在派它的会话下面、以任务名为标题,fork 进来的父线程历史折成一条不入库的占位,父会话的对话不会被索引两遍)、Qoder CLI(`~/.qoder/projects` JSONL,active-leaf 分支恢复、tool result 回挂、`QODER_CONFIG_DIR`)、Copilot CLI、Cursor(CLI 转录 + 0.6.7 起 IDE Chat/Composer 历史,PR #32:`globalStorage/state.vscdb` 明文 KV 库,composerData 给顺序、bubbleId 行给正文;转录带正文的会话归转录源,库只补转录缺失或只剩 turn_ended 空壳的会话;库里多数老会话没存工作区路径,落 Unknown project)、OpenCode(含 OpenCode 2 next,stable 的 `opencode.db` 与 next 的 `opencode-next.db` 同时扫描;逐会话兼容 `message+part`、真实 `session+session_message` 及早期 `session_v2` schema;preview 会话标 opencode2 徽章;2026-10-12 起 task 工具派出的子代理会话也收录,挂在派它的会话下)、Kiro、Gemini CLI(2026-08-17 P1 五家落地)+ Pi、Oh My Pi、Grok Build、Kimi Code、Antigravity(2026-08-19 对齐 kooky 内置 roster,起初只有 `antigravity-cli` 会话索引里的元数据卡片——正文是加密 .pb;2026-10-08 起读新版本桌面端与 IDE 写在 `~/.gemini/antigravity/brain`、`~/.gemini/antigravity-ide/brain` 的明文转录(2026-10-19 起也读 CLI 写在 `~/.gemini/antigravity-cli/brain` 的那份,PR #71 @dingtwo;之前 CLI 会话只剩卡片),含工具输出、模型与用户贴图,IDE 会话挂 via 徽章,同一会话转录与卡片按 id 只出一份、没有转录的仍列卡片;显示名由 Antigravity CLI 改为 Antigravity;2026-10-12 起索引里记了父会话的子会话挂在父会话下。格式取自 PR #52 @iroha3 对真实数据的整理,CLI 那份由 PR #71 @dingtwo 用真实转录核过;本机 brain 目录还没有转录,未经真机验证)+ DeepSeek Harness(dsh,2026-08-20,zstd 事件日志透明解压;格式由源码推断,当天用户跑出真实会话完成首验;2026-10-11 起委派出去的子代理会话也收录,挂在派它的会话下、以任务名为标题,issue #63,fork 出来的会话开头复制的父会话历史折成一条,token 只算自己的)+ Hermes Agent(2026-09-03,多档案 state.db,无 cwd 故 project 留空)、OpenClaw(2026-09-03,两代存储同扫;2026-10-12 起派生的子代理与面板上开的子会话挂在父会话下;本机零会话,格式由源码推断未经真机验证)、CodeBuddy(2026-09-14,issue #27:`~/.codebuddy/projects` 的 Responses 形 JSONL,custom / ai / topic 三级标题,`CODEBUDDY_CONFIG_DIR`;本机零会话,格式由官方 CLI 文档与三家第三方实现交叉推断、未经真机验证)、WorkBuddy(同日,CodeBuddy 的孪生实例:同一解析核心,`~/.workbuddy/projects`、`WORKBUDDY_CONFIG_DIR`;桌面 app 无 CLI,不提供 resume;同构只有 cc-switch 一家佐证)、ZCode(2026-09-21:Z.ai 的 GLM-5.3 官方 harness,桌面 app;运行时是 OpenCode 衍生物——`~/.zcode/cli/db/db.sqlite` 的 session/message/part 与 OpenCode v1 同形、part 解码复用,但 session 表没有 model/tokens 列故另起一家;`v2/tasks-index.sqlite` 只借 deleted / migration_source 两个过滤位;照桌面端自己的分法列:任务列表里的 interactive / fork / workflow_parent 顶层列出,辅助对话、子代理与工作流的子会话挂在父任务下(2026-10-12);分叉开头从父任务复制来的历史折成一条,辅助对话以首条提问为标题;`semantics.transcriptVisibility == hidden` 与用户消息 `origin != real_user` 归 Meta、compact_summary 折成一条、字段缺席放行;`ZCODE_STORAGE_DIR`;桌面 app 无 CLI、`zcode://` 没有按会话打开的深链,不提供 resume;本机 3.14.0 真会话首验通过,同日开源(Apache-2.0)后语义全部按源码核对)、Craft Agents(2026-09-24,issue #44:Craft Docs 的开源桌面 app,自己不带引擎——Anthropic 连接跑 Claude Agent SDK、其余连接(ChatGPT / Codex 订阅、Copilot、Google)跑 Pi SDK,另记一份给用户看的 `~/.craft-agent/workspaces/<工作区>/sessions/<id>/session.jsonl`,Wake 读这一份;子任务与分支挂回原会话,分支从父会话复制来的那段折成一条;Claude 连接在 `~/.claude/projects` 留下的引擎副本由通用的"认领"机制藏掉,原件还在才藏;工作区可建在任意位置,但登记表带 server token 不读,别处的工作区走 Session locations;桌面 app 无 CLI,不提供 resume;本机 0.13.5 真会话首验通过,ChatGPT 与 Claude 连接各一条)、Devin(2026-09-24,issue #46:`~/.local/share/devin/cli/sessions.db` 单库两表,message_nodes 森林按 `main_chain_id` 叶子沿 `parent_node_id` 取主链,hidden 会话与零正文不列,逐消息 `generation_model` 与 `metrics` 按主链累计;`XDG_DATA_HOME`;`devin --resume <id>` 按 cwd 分桶 resume;格式按本机真库验证)、Kilo Code(2026-10-07,issue #59:一家两源——2026-04 起的新版 VS Code 扩展、`kilo` CLI 与 JetBrains 插件是 OpenCode 分支,三端共用 `~/.local/share/kilo/kilo.db`,表与 OpenCode 同形、按 OpenCode 的孪生实例读,子代理会话同样挂在父会话下;session_message 里只有实验开关零星双写的 shell 一类记录时读 message + part(OpenCode 同一条规则);旧版扩展(Roo / Cline 系)每个任务一个目录,在各个 VS Code 系编辑器的 `globalStorage/kilocode.kilo-code/tasks` 里,正文是 Anthropic 消息数组,`<task>` / `<feedback>` / `<answer>` 才是人打的字、编辑器快照丢掉,旧任务用新版导入时给的 `ses_migrated_` id,导入过的那份 kilo.db 胜出;新版 `kilo --session` 在原项目目录续,旧任务没有 Open In、也不实时监听(任务目录里有整份 checkpoints 影子仓库);kilo.db 里同库存着凭证,远程只同步 vscode-server 下的旧任务;本机零会话,新版的表结构按源码的建库语句核过,数据形状由源码推断、未经真机验证)、Grok Bot(2026-10-11:xAI 的常驻 agent,桌面 app 由 Cursor 出品,bot 跑在云端电脑上,对话也存在那里;本机只有桌面端的滚动缓存 `<userData>/sand-client-persistence`——每个对话只留最近 200 条、最多 24 个对话、7 天没写过的被 app 自己清掉。用户定"跟着缓存走":缓存里有的对话出完整消息(你的话、bot 的话、群聊里标出是哪个 bot、bot 之间互发的消息、提问卡片与你的回答、邮件草稿、审批),被清出缓存的退成侧栏列表里的一张卡片(描述 + 最后一条预览),不会从 Wake 里消失;对话本体在云端,删除只隐藏、不动缓存文件;没有命令行,不提供 resume;不做远程同步;格式按 0.68.1 的 app 源码与本机 14 个真实对话核对)。做不了的:Windsurf/Trae 加密,Amp/Factory(Droid)/Warp 云端无本地数据,Reasonix 本机零会话格式未实测。
+已支持二十四家 agent:Claude Code、Codex(0.6.6 起排除可识别的内部线程:guardian auto-review、`/review`、compaction、memory consolidation 与用户会话同树,adapter 文件边界按首行 session_meta 的 source / thread_source 认出即不枚举;老格式或读不出的首行保守放行,`codex exec --thread-source` 打了标签的自动化线程照常收录,issue #30。`spawn_agent` 子代理是其中唯一的例外,issue #42:那是用户自己派出去的活,收录后挂在派它的会话下面、以任务名为标题,fork 进来的父线程历史折成一条不入库的占位,父会话的对话不会被索引两遍)、Qoder CLI(`~/.qoder/projects` JSONL,active-leaf 分支恢复、tool result 回挂、`QODER_CONFIG_DIR`)、Copilot CLI、Cursor(CLI 转录 + 0.6.7 起 IDE Chat/Composer 历史,PR #32:`globalStorage/state.vscdb` 明文 KV 库,composerData 给顺序、bubbleId 行给正文;转录带正文的会话归转录源,库只补转录缺失或只剩 turn_ended 空壳的会话;库里多数老会话没存工作区路径,落 Unknown project)、OpenCode(含 OpenCode 2 next,stable 的 `opencode.db` 与 next 的 `opencode-next.db` 同时扫描;逐会话兼容 `message+part`、真实 `session+session_message` 及早期 `session_v2` schema;preview 会话标 opencode2 徽章;2026-10-12 起 task 工具派出的子代理会话也收录,挂在派它的会话下)、Kiro、Gemini CLI(2026-08-17 P1 五家落地)+ Pi、Oh My Pi、Grok Build、Kimi Code、Antigravity(2026-08-19 对齐 kooky 内置 roster,起初只有 `antigravity-cli` 会话索引里的元数据卡片——正文是加密 .pb;2026-10-08 起读新版本桌面端与 IDE 写在 `~/.gemini/antigravity/brain`、`~/.gemini/antigravity-ide/brain` 的明文转录(2026-10-19 起也读 CLI 写在 `~/.gemini/antigravity-cli/brain` 的那份,PR #71 @dingtwo;之前 CLI 会话只剩卡片),含工具输出、模型与用户贴图,IDE 会话挂 via 徽章,同一会话转录与卡片按 id 只出一份、没有转录的仍列卡片;显示名由 Antigravity CLI 改为 Antigravity;2026-10-12 起索引里记了父会话的子会话挂在父会话下。格式取自 PR #52 @iroha3 对真实数据的整理,CLI 那份由 PR #71 @dingtwo 用真实转录核过;本机 brain 目录还没有转录,未经真机验证)+ DeepSeek Harness(dsh,2026-08-20,zstd 事件日志透明解压;格式由源码推断,当天用户跑出真实会话完成首验;2026-10-11 起委派出去的子代理会话也收录,挂在派它的会话下、以任务名为标题,issue #63,fork 出来的会话开头复制的父会话历史折成一条,token 只算自己的)+ Hermes Agent(2026-09-03,多档案 state.db,无 cwd 故 project 留空)、OpenClaw(2026-09-03,两代存储同扫;2026-10-12 起派生的子代理与面板上开的子会话挂在父会话下;本机零会话,格式由源码推断未经真机验证)、CodeBuddy(2026-09-14,issue #27:`~/.codebuddy/projects` 的 Responses 形 JSONL,custom / ai / topic 三级标题,`CODEBUDDY_CONFIG_DIR`;本机零会话,格式由官方 CLI 文档与三家第三方实现交叉推断、未经真机验证)、WorkBuddy(同日,CodeBuddy 的孪生实例:同一解析核心,`~/.workbuddy/projects`、`WORKBUDDY_CONFIG_DIR`;桌面 app 无 CLI,不提供 resume;同构只有 cc-switch 一家佐证)、ZCode(2026-09-21:Z.ai 的 GLM-5.3 官方 harness,桌面 app;运行时是 OpenCode 衍生物——`~/.zcode/cli/db/db.sqlite` 的 session/message/part 与 OpenCode v1 同形、part 解码复用,但 session 表没有 model/tokens 列故另起一家;`v2/tasks-index.sqlite` 只借 deleted / migration_source 两个过滤位;照桌面端自己的分法列:任务列表里的 interactive / fork / workflow_parent 顶层列出,辅助对话、子代理与工作流的子会话挂在父任务下(2026-10-12);分叉开头从父任务复制来的历史折成一条,辅助对话以首条提问为标题;`semantics.transcriptVisibility == hidden` 与用户消息 `origin != real_user` 归 Meta、compact_summary 折成一条、字段缺席放行;`ZCODE_STORAGE_DIR`;桌面 app 无 CLI、`zcode://` 没有按会话打开的深链,不提供 resume;本机 3.14.0 真会话首验通过,同日开源(Apache-2.0)后语义全部按源码核对)、Craft Agents(2026-09-24,issue #44:Craft Docs 的开源桌面 app,自己不带引擎——Anthropic 连接跑 Claude Agent SDK、其余连接(ChatGPT / Codex 订阅、Copilot、Google)跑 Pi SDK,另记一份给用户看的 `~/.craft-agent/workspaces/<工作区>/sessions/<id>/session.jsonl`,Wake 读这一份;子任务与分支挂回原会话,分支从父会话复制来的那段折成一条;Claude 连接在 `~/.claude/projects` 留下的引擎副本由通用的"认领"机制藏掉,原件还在才藏;工作区可建在任意位置,但登记表带 server token 不读,别处的工作区走 Session locations;桌面 app 无 CLI,不提供 resume;本机 0.13.5 真会话首验通过,ChatGPT 与 Claude 连接各一条)、Devin(2026-09-24,issue #46:`~/.local/share/devin/cli/sessions.db` 单库两表,message_nodes 森林按 `main_chain_id` 叶子沿 `parent_node_id` 取主链,hidden 会话与零正文不列,逐消息 `generation_model` 与 `metrics` 按主链累计;`XDG_DATA_HOME`;`devin --resume <id>` 按 cwd 分桶 resume;格式按本机真库验证)、Kilo Code(2026-10-07,issue #59:一家两源——2026-04 起的新版 VS Code 扩展、`kilo` CLI 与 JetBrains 插件是 OpenCode 分支,三端共用 `~/.local/share/kilo/kilo.db`,表与 OpenCode 同形、按 OpenCode 的孪生实例读,子代理会话同样挂在父会话下;session_message 里只有实验开关零星双写的 shell 一类记录时读 message + part(OpenCode 同一条规则);旧版扩展(Roo / Cline 系)每个任务一个目录,在各个 VS Code 系编辑器的 `globalStorage/kilocode.kilo-code/tasks` 里,正文是 Anthropic 消息数组,`<task>` / `<feedback>` / `<answer>` 才是人打的字、编辑器快照丢掉,旧任务用新版导入时给的 `ses_migrated_` id,导入过的那份 kilo.db 胜出;新版 `kilo --session` 在原项目目录续,旧任务没有 Open In、也不实时监听(任务目录里有整份 checkpoints 影子仓库);kilo.db 里同库存着凭证,远程只同步 vscode-server 下的旧任务;本机零会话,新版的表结构按源码的建库语句核过,数据形状由源码推断、未经真机验证)、Grok Bot(2026-10-11:xAI 的常驻 agent,桌面 app 由 Cursor 出品,bot 跑在云端电脑上,对话也存在那里;本机只有桌面端的滚动缓存 `<userData>/sand-client-persistence`——每个对话只留最近 200 条、最多 24 个对话、7 天没写过的被 app 自己清掉。用户定"跟着缓存走":缓存里有的对话出完整消息(你的话、bot 的话、群聊里标出是哪个 bot、bot 之间互发的消息、提问卡片与你的回答、邮件草稿、审批),被清出缓存的退成侧栏列表里的一张卡片(描述 + 最后一条预览),不会从 Wake 里消失;对话本体在云端,删除只隐藏、不动缓存文件;没有命令行,不提供 resume;不做远程同步;格式按 0.68.1 的 app 源码与本机 14 个真实对话核对)、MiMo Code(2026-10-23,issue #77:小米 MiMo 团队的终端 coding agent,OpenCode 分支,`~/.local/share/mimocode/mimocode.db` 的 session / message / part 三表与 OpenCode v1 同形、正文解码复用,但 session 表没有 model / tokens 列故另起一家;一个会话里有好几条道——主线、同会话的子代理、peer 子会话自己那条——会话照 MiMo 自己的界面显示其中一条,其余的子代理道各成一条子会话(标题是派活时的说明,派活的工具调用能跳过去);peer 子会话与旁问同样挂在父会话下,运行时自己派的 checkpoint-writer / dream / distill 不列;从 Claude Code、Codex、OpenCode 导入的会话只在 MiMo 里接着聊过才列、导入的那段折成一条;fork 开头复制来的历史折成一条;`mimo --session` 在原项目目录续;库里同时存着登录 token,不做远程同步;本机零会话,格式由源码推断、未经真机验证)。做不了的:Windsurf/Trae 加密,Amp/Factory(Droid)/Warp 云端无本地数据,Reasonix 本机零会话格式未实测。
## Brand Commitments
diff --git a/README.md b/README.md
index 3851b94..8e0b01d 100644
--- a/README.md
+++ b/README.md
@@ -61,6 +61,7 @@ Your agent history is scattered across `~/.claude`, `~/.codex` and many other fo
| Devin | `~/.local/share/devin/cli/sessions.db` | ✅ | — |
| Kilo Code | `~/.local/share/kilo/kilo.db` + the legacy extension's `globalStorage/kilocode.kilo-code/tasks` | ✅ | ✅ |
| Grok Bot | the desktop app's cache (`Grok Bot/sand-client-persistence`) | — | — |
+| MiMo Code | `~/.local/share/mimocode/mimocode.db` | ✅ | — |
Agents' own environment variables (`CODEX_HOME`, `XDG_DATA_HOME`, …) are respected, and Settings → Session locations adds folders anywhere else.
@@ -71,6 +72,7 @@ Agents' own environment variables (`CODEX_HOME`, `XDG_DATA_HOME`, …) are respe
- **Craft Agents** — on a Claude connection, Wake shows the Craft session and hides the duplicate Claude Code copy
- **Kilo Code** — the new extension, CLI and JetBrains plugin share `kilo.db`; tasks from the legacy extension are listed too
- **Grok Bot** — conversations live in Grok Bot's cloud; Wake reads the latest messages the desktop app keeps on this computer, a conversation it no longer keeps stays listed with its last message, and deleting one in Wake only hides it
+- **MiMo Code** — a session imported from Claude Code, Codex or OpenCode is listed once you continue it in MiMo Code, without the imported part
Not supported: Windsurf and Trae (encrypted), Amp, Factory and Warp (cloud only).
diff --git a/crates/wake-core/src/adapters/devin.rs b/crates/wake-core/src/adapters/devin.rs
index 0608c72..d8c0978 100644
--- a/crates/wake-core/src/adapters/devin.rs
+++ b/crates/wake-core/src/adapters/devin.rs
@@ -168,11 +168,7 @@ fn build_meta(
messages: &[TranscriptMessage],
tokens: i64,
) -> SessionMeta {
- let title = Some(row.title.as_str())
- .map(clean_title_candidate)
- .filter(|t| !t.is_empty())
- .or_else(|| title_from_messages(messages))
- .unwrap_or_else(|| UNTITLED.to_string());
+ let title = session_title(&row.title, false, messages);
SessionMeta {
key: format!("devin:{}", row.id),
host: String::new(),
diff --git a/crates/wake-core/src/adapters/grok.rs b/crates/wake-core/src/adapters/grok.rs
index 78db7b6..a0c2a05 100644
--- a/crates/wake-core/src/adapters/grok.rs
+++ b/crates/wake-core/src/adapters/grok.rs
@@ -398,10 +398,7 @@ fn build_meta(
grok_home: &Path,
group: &GroupCtx,
) -> SessionMeta {
- let title = Some(clean_title_candidate(&side.title))
- .filter(|t| !t.is_empty())
- .or_else(|| title_from_messages(messages))
- .unwrap_or_else(|| UNTITLED.to_string());
+ let title = session_title(&side.title, false, messages);
let msg_ts_max = messages
.iter()
.filter_map(|m| m.timestamp)
diff --git a/crates/wake-core/src/adapters/hermes.rs b/crates/wake-core/src/adapters/hermes.rs
index e549133..3750bd4 100644
--- a/crates/wake-core/src/adapters/hermes.rs
+++ b/crates/wake-core/src/adapters/hermes.rs
@@ -137,10 +137,7 @@ impl HermesAdapter {
row: &HermesRow,
messages: &[TranscriptMessage],
) -> SessionMeta {
- let title = Some(clean_title_candidate(&row.title))
- .filter(|t| !t.is_empty())
- .or_else(|| title_from_messages(messages))
- .unwrap_or_else(|| UNTITLED.to_string());
+ let title = session_title(&row.title, false, messages);
SessionMeta {
key: format!("hermes:{}", row.id),
host: String::new(),
diff --git a/crates/wake-core/src/adapters/kimi.rs b/crates/wake-core/src/adapters/kimi.rs
index a66450c..8ba28d3 100644
--- a/crates/wake-core/src/adapters/kimi.rs
+++ b/crates/wake-core/src/adapters/kimi.rs
@@ -695,10 +695,7 @@ fn build_meta(
cwd: &str,
messages: &[TranscriptMessage],
) -> SessionMeta {
- let title = Some(clean_title_candidate(&state.title))
- .filter(|t| !t.is_empty())
- .or_else(|| title_from_messages(messages))
- .unwrap_or_else(|| UNTITLED.to_string());
+ let title = session_title(&state.title, false, messages);
// Kimi 在 Windows 上把 workDir 记成 `C:/…`,别家记 `C:\…`:换成同一种写法才归到同一个项目
let project = canonical_project_path(cwd);
SessionMeta {
diff --git a/crates/wake-core/src/adapters/kiro.rs b/crates/wake-core/src/adapters/kiro.rs
index 951c4ee..b2ab24c 100644
--- a/crates/wake-core/src/adapters/kiro.rs
+++ b/crates/wake-core/src/adapters/kiro.rs
@@ -113,10 +113,7 @@ fn parse_kiro_jsonl(path: &Path, decode_images: bool) -> Result<(Vec<TranscriptM
}
fn build_meta(r: &SessionFileRef, side: &Sidecar, messages: &[TranscriptMessage]) -> SessionMeta {
- let title = Some(clean_title_candidate(&side.title))
- .filter(|t| !t.is_empty())
- .or_else(|| title_from_messages(messages))
- .unwrap_or_else(|| UNTITLED.to_string());
+ let title = session_title(&side.title, false, messages);
let msg_ts_max = messages
.iter()
.filter_map(|m| m.timestamp)
diff --git a/crates/wake-core/src/adapters/mimo.rs b/crates/wake-core/src/adapters/mimo.rs
new file mode 100644
index 0000000..322ee2e
--- /dev/null
+++ b/crates/wake-core/src/adapters/mimo.rs
@@ -0,0 +1,744 @@
+//! MiMo Code(小米 MiMo 团队的终端 coding agent,github.com/XiaomiMiMo/MiMo-Code,MIT;
+//! issue #77)。从 OpenCode fork 出来:`<数据根>/mimocode.db` 的 session / message / part
+//! 三表与 OpenCode v1 同名,part 的 JSON 同形,正文解码走 opencode.rs 的
+//! `parse_v1_messages`。分家的地方(与 ZCode 同一个理由,不能当孪生实例):
+//!
+//! - session 表没有 model / tokens 三列(fork 自 2026-01 的 OpenCode,那时还没有这几列),
+//! OpenCode 的枚举 SQL 对它 prepare 就失败。模型取助手消息的 `modelID`,token 按调用累加
+//! `tokens.input / output / reasoning`(与 OpenCode 会话列同一个口径)。
+//! - 一个会话里不止一条"道":`message.agent_id` 为 `main` 的是主线,同会话的子代理(actor 的
+//! subagent 模式,`explore-1` 这类)各写各的道。会话本身显示哪条照 MiMo 自己界面的
+//! `selectMessages`:有 main 用 main;peer 模式派出的子会话把自己那几轮写在以子会话 id 命名的
+//! 道上;都没有(`ask:` 旁问的宿主会话)用最新的那条。其余的道各是一条子会话(Kimi 的
+//! `agents/<非 main>` 同形):原生 id `<会话>/<actor id>`(`lane_id`),父会话写在 id 里
+//! (`parent_in_path`:停在直接父会话上、不能单独恢复),标题是派活时那句 description(没给时
+//! 它等于 agent 类型名,退回收到的任务),跟着所在会话归档,token 各算各的道;派它的 actor
+//! 调用跳得过去。运行时自己派的那几种(见下)的道是簿记、不列;fork 复制来的道(每条消息都早于
+//! 会话的创建)也不列。
+//! - 会导入别家的会话(`external_import`:Claude Code、Codex、OpenCode,用户在 MiMo 里点导入):
+//! 导进来的消息原样复制进 main 道,`message_ids` 记着哪些是导入的。那几家 Wake 本来就索引着,
+//! 只有导入的会话不列;导入后在 MiMo 里接着聊过的照列,导入的那段折成一条标记、token 不算。
+//! `message_ids` 读不出的老记录分不清哪些是导入的,整条当导入。
+//! - fork(`Session.fork`)把原会话的消息复制进新会话(新 id、保留原时间)、不记父会话:复制来的
+//! 消息时间都早于新会话的创建时间,按这一条折成一条标记,token 与模型只算之后的(Codex / ZCode
+//! 的分叉同一个理由)。
+//! - 哪些会话显示照 MiMo 的 `session/visibility.ts`:顶层会话与 peer 子会话都显示;运行时自己派的
+//! checkpoint-writer / dream / distill(`SYSTEM_SPAWNED_AGENT_TYPES`)的宿主子会话是簿记、
+//! 不是对话,不列。自动整理记忆的 "Auto Dream" / "Auto Distill" 顶层会话 MiMo 自己照列(带
+//! Auto 徽章),这里也列,但不算用户开的会话(`spawned`)。
+//!
+//! 用户消息带 `provenance`(钩子、主机自动化、别的 agent 发来的)就不是人打的字,归 Meta(MiMo
+//! 自己起标题也这么认);钩子发来的、收件箱投递的文本块本身就标了 synthetic。助手消息
+//! `summary: true` 是压缩出的摘要、带 `checkpoint` 块的那条是检查点重建的上下文,都折成摘要。
+//! 标题来源 `fallback` 时标题只是占位的 "Untitled",退回首条提问(2026-09 之前的老库占位是空串)。
+//!
+//! 数据根:它用的 xdg-basedir 5.1.0 在三个平台都给 `~/.local/share/mimocode`(`XDG_DATA_HOME`
+//! 覆盖),设了 `MIMOCODE_HOME` 就是 `$MIMOCODE_HOME/data`。它的 README 说 macOS 在
+//! `~/Library/Application Support/mimocode`、Windows 在 `%LOCALAPPDATA%\mimocode`,与代码对不上,
+//! 两处都只当候选(真有库才采信,Devin 同款)。`MIMOCODE_DB` 与渠道库(`mimocode-<渠道>.db`)
+//! 只有测试与开发构建用,不跟。库里同时存着账号的 access / refresh token,所以不做远程同步。
+//!
+//! 本机没装 MiMo Code:格式全按源码(main 2026-10-22,v0.1.15 之后)推断、**未经真机验证**,
+//! fixture 合成。
+use super::opencode::{parse_v1_messages, V1Query};
+use super::parse_utils::*;
+use super::sqlite_ro::{
+ db_cache_stamp, has_table, open_sqlite_ro, split_virtual_path, strip_virtual_path,
+ table_columns, virtual_path, SqliteRo,
+};
+use super::{AgentAdapter, ParentInPath};
+use crate::models::*;
+use anyhow::{anyhow, Result};
+use rusqlite::{Connection, OptionalExtension as _};
+use serde_json::Value;
+use std::collections::HashSet;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+const DB_NAME: &str = "mimocode.db";
+/// XDG data 根下的目录名
+const DATA_DIR: &str = "mimocode";
+/// 运行时自己派的 agent(MiMo 的 `SYSTEM_SPAWNED_AGENT_TYPES`):它们的宿主子会话与道不是对话
+const SYSTEM_AGENTS: [&str; 3] = ["checkpoint-writer", "dream", "distill"];
+/// 自动整理记忆的顶层会话(MiMo 的 `isSystemSession` 按标题认)
+const SYSTEM_TITLES: [&str; 2] = ["Auto Dream", "Auto Distill"];
+
+/// 同会话子代理那条道作为子会话时的原生 id:`<会话>/<actor id>`(两段里都没有 `/`:会话 id 是
+/// `ses_…`,actor id 是 `<agent>-<n>`)
+fn lane_id(session: &str, actor: &str) -> String {
+ format!("{session}/{actor}")
+}
+
+/// `lane_id` 反过来:原生 id 拆成 (会话, 道);会话本身没有道
+fn split_lane(id: &str) -> (&str, Option<&str>) {
+ match id.split_once('/') {
+ Some((session, actor)) => (session, Some(actor)),
+ None => (id, None),
+ }
+}
+
+/// 道子会话的父会话(`parent_in_path`):虚拟路径 `<库>#<会话>/<actor id>` 里的会话 id;会话本身
+/// 给 None
+fn lane_parent(path: &Path) -> Option<String> {
+ let (_, id) = split_virtual_path(path.to_str()?)?;
+ let (session, actor) = split_lane(id);
+ actor.map(|_| session.to_string())
+}
+
+/// actor 工具派活调用跳去的子会话(`ToolCallView::child_id`):metadata 记着会话与 actor。peer 是
+/// 另一个会话(actor id 就是它的会话 id),同会话的子代理是这个会话里的一条道;指回会话自己的
+/// (缺了 actorId,分不出是哪条道)不算
+fn actor_child(session: &str, metadata: &Value) -> Option<String> {
+ let target = optional_string(metadata.get("sessionId"))?;
+ let child = match optional_string(metadata.get("actorId")) {
+ Some(actor) if actor != target => lane_id(&target, &actor),
+ _ => target,
+ };
+ (child != session).then_some(child)
+}
+
+/// part 的类型(`text` / `tool` / `checkpoint` …)
+fn part_type(part: &Value) -> Option<&str> {
+ part.get("type").and_then(Value::as_str)
+}
+
+pub struct MimoAdapter {
+ db: PathBuf,
+ /// 列出来的会话与道子会话,按库戳缓存一轮扫描内的重复调用(枚举查询带全表相关子查询)
+ rows_cache: MtimeCache<Arc<Vec<MiRow>>>,
+}
+
+/// 列出来的一条:会话本身(`query_rows`),或会话里同会话子代理的一条道(`query_lanes`)
+struct MiRow {
+ /// 原生 id:会话 id,或道的 `lane_id`
+ id: String,
+ /// 消息所在的会话
+ session: String,
+ /// 道子会话读的那条道;None = 会话本身(读要显示的那条)
+ actor: Option<String>,
+ /// 道子会话的项目与归档跟着所在的会话
+ directory: String,
+ /// 会话的标题;道子会话是派活时那句 description(没给是空串,退回收到的任务)
+ title: String,
+ /// 标题来源 `fallback`:占位的 "Untitled"
+ placeholder_title: bool,
+ created_ms: i64,
+ updated_ms: i64,
+ archived: bool,
+ /// part.data 字节数(会话算全部道)——SessionFileRef.size 的脏判据(单条取行时不算)
+ content_len: i64,
+ /// 会话自己那一行的 parent_id;道子会话的父会话在 id 里(`lane_parent`)
+ parent: Option<String>,
+}
+
+impl MiRow {
+ /// `query_rows` 与 `query_lanes` 共用的列序:会话 id、道(会话本身是 NULL)、目录、标题、标题
+ /// 来源、起止时间、归档时间、parent_id、part 字节数。缺列给默认值:老库不得整家消失
+ fn from_sql(r: &rusqlite::Row<'_>) -> rusqlite::Result<Self> {
+ let session: String = r.get(0)?;
+ let actor: Option<String> = r.get(1)?;
+ Ok(Self {
+ id: match &actor {
+ Some(actor) => lane_id(&session, actor),
+ None => session.clone(),
+ },
+ session,
+ actor,
+ directory: r.get::<_, Option<String>>(2)?.unwrap_or_default(),
+ title: r.get::<_, Option<String>>(3)?.unwrap_or_default(),
+ placeholder_title: r.get::<_, Option<String>>(4)?.as_deref() == Some("fallback"),
+ created_ms: r.get::<_, Option<i64>>(5)?.unwrap_or(0),
+ updated_ms: r.get::<_, Option<i64>>(6)?.unwrap_or(0),
+ archived: r.get::<_, Option<i64>>(7)?.is_some(),
+ parent: r
+ .get::<_, Option<String>>(8)?
+ .filter(|parent| !parent.is_empty()),
+ content_len: r.get::<_, Option<i64>>(9)?.unwrap_or(0),
+ })
+ }
+
+ /// 不是用户开的会话:子会话(peer 子代理、旁问、工作流的一步、同会话子代理的道),与自动整理
+ /// 记忆的那两种
+ fn spawned(&self) -> bool {
+ self.actor.is_some()
+ || self.parent.is_some()
+ || SYSTEM_TITLES.contains(&self.title.as_str())
+ }
+}
+
+/// 逐版加进来的表与列各自在不在(初始 schema 里的不用探)
+#[derive(Clone, Copy)]
+struct MiSchema {
+ /// 刚建好、还没迁移的库没有会话表:确定没有会话
+ sessions: bool,
+ /// message.agent_id(2026-05 起;之前一个会话只有一条道)
+ lanes: bool,
+ /// message.agent_id 还可以为空:2026-05-21 加这一列时主线的消息留着 NULL,05-26 才补成 'main'
+ /// 并改成 NOT NULL。停在这几天之间的库,NULL 就是主线(`agent`)
+ null_main: bool,
+ /// session.title_source(2026-09 起)
+ title_source: bool,
+ /// external_import 表(2026-06 起)
+ imports: bool,
+ /// actor_registry 带着 session_id / mode / agent:它 2026-05-15 由 task_registry 改名而来,
+ /// 05-21 重建之后才是这个形状,只探表名会把中间那几天的库读挂
+ actors: bool,
+}
+
+impl MiSchema {
+ /// 查询出错(文件不是 SQLite、读到一半出错)往上交,别当成没有
+ fn probe(conn: &Connection) -> rusqlite::Result<Self> {
+ let actors = table_columns(conn, "actor_registry");
+ // agent_id 在不在、是不是 NOT NULL
+ let agent_id: Option<bool> = conn
+ .query_row(
+ "SELECT \"notnull\" FROM pragma_table_info('message') WHERE name = 'agent_id'",
+ [],
+ |r| r.get(0),
+ )
+ .optional()?;
+ Ok(Self {
+ sessions: has_table(conn, "session")?,
+ lanes: agent_id.is_some(),
+ null_main: agent_id == Some(false),
+ title_source: table_columns(conn, "session").contains("title_source"),
+ imports: has_table(conn, "external_import")?,
+ actors: ["session_id", "mode", "agent"]
+ .iter()
+ .all(|c| actors.contains(*c)),
+ })
+ }
+
+ /// 消息在哪条道(`col` 是 agent_id 列,带表名):`null_main` 的库里 NULL 算 main。别的库原样用
+ /// 列,(session_id, agent_id) 索引照走
+ fn agent(&self, col: &str) -> String {
+ if self.null_main {
+ format!("COALESCE({col}, 'main')")
+ } else {
+ col.to_string()
+ }
+ }
+
+ /// 会话要显示的那条道(MiMo 界面的 `selectMessages`):有 main 用 main,peer 子会话用以它自己的
+ /// id 命名的那条,都没有用最新消息所在的那条。`sid` 是会话 id 的 SQL 表达式;老库只有一条道
+ fn lane(&self, sid: &str) -> Option<String> {
+ let agent = self.agent("x.agent_id");
+ self.lanes.then(|| {
+ format!(
+ "(CASE WHEN EXISTS (SELECT 1 FROM message x WHERE x.session_id = {sid} AND {agent} = 'main') THEN 'main'
+ WHEN EXISTS (SELECT 1 FROM message x WHERE x.session_id = {sid} AND {agent} = {sid}) THEN {sid}
+ ELSE (SELECT {agent} FROM message x WHERE x.session_id = {sid} ORDER BY x.id DESC LIMIT 1) END)"
+ )
+ })
+ }
+
+ /// 列哪些会话(枚举的 WHERE)。一是 MiMo 的 `classifySession`:顶层会话与 peer 子会话恒显示,
+ /// 宿主着运行时自己派的 agent 的子会话不显示。二是导入的会话只在 MiMo 里接着聊过才列——main 道
+ /// 里有不是导入的消息(导入只写 main 道);导入记录分不清哪些是导入的(`message_ids` 为空或读
+ /// 不出),整条当导入。导入那几个子查询都不相关、整条语句只建一次:按 s.id 取的相关写法每条
+ /// 消息求值一遍、每遍整表扫 external_import(它在 session_id 上没有索引),一千条导入就要好几秒
+ fn listed(&self) -> String {
+ let mut conds = Vec::new();
+ if self.actors {
+ conds.push(format!(
+ "NOT (COALESCE(s.parent_id, '') != ''
+ AND NOT EXISTS (SELECT 1 FROM actor_registry a WHERE a.session_id = s.id AND a.mode = 'peer')
+ AND EXISTS (SELECT 1 FROM actor_registry a WHERE a.session_id = s.id AND a.agent IN ({})))",
+ system_agents()
+ ));
+ }
+ if self.imports {
+ conds.push(format!(
+ "(s.id NOT IN (SELECT session_id FROM external_import)
+ OR (s.id NOT IN (SELECT session_id FROM external_import
+ WHERE message_ids IS NULL OR NOT json_valid(message_ids))
+ AND EXISTS (SELECT 1 FROM message m WHERE m.session_id = s.id AND {} = 'main'
+ AND m.id NOT IN {})))",
+ self.agent("m.agent_id"),
+ imported_ids(None)
+ ));
+ }
+ if conds.is_empty() {
+ "1".to_string()
+ } else {
+ conds.join(" AND ")
+ }
+ }
+
+ /// 转录读哪些消息(`V1Query::filter`,`?1` = 会话 id):会话读要显示的那条道、导入过就去掉
+ /// 导入的;道子会话读它那条道
+ fn transcript(&self, row: &MiRow, imported: bool) -> Option<String> {
+ let lane = match &row.actor {
+ Some(actor) => Some(sql_text(actor)),
+ None => self.lane("?1"),
+ };
+ let conds: Vec<String> = [
+ lane.map(|lane| format!("{} = {lane}", self.agent("agent_id"))),
+ imported.then(|| format!("id NOT IN {}", imported_ids(Some("?1")))),
+ ]
+ .into_iter()
+ .flatten()
+ .collect();
+ (!conds.is_empty()).then(|| conds.join(" AND "))
+ }
+}
+
+/// SQL 字符串字面量(单引号转义)
+fn sql_text(s: &str) -> String {
+ format!("'{}'", s.replace('\'', "''"))
+}
+
+/// 运行时自己派的 agent,拼进 `IN (…)`
+fn system_agents() -> String {
+ SYSTEM_AGENTS
+ .iter()
+ .map(|a| sql_text(a))
+ .collect::<Vec<_>>()
+ .join(", ")
+}
+
+/// 导入来的消息 id(`external_import.message_ids`);`scope` 给了(会话 id 的 SQL 表达式)就只取
+/// 那个会话的。不是合法 JSON 的按空的算;只取字符串元素——`NOT IN` 的列表里混进一个 NULL,整个
+/// 条件就是 NULL、一条都选不中。消息 id 是主键,左边只放它一列、不配会话 id:换成 (会话, 消息) 对
+/// 的话,SQLite 没法一次判完列表里有没有 NULL,每次没命中都把整份列表扫一遍(一千多条导入时列
+/// 一遍会话要两秒多)
+fn imported_ids(scope: Option<&str>) -> String {
+ let scope = scope
+ .map(|sid| format!(" AND e.session_id = {sid}"))
+ .unwrap_or_default();
+ format!(
+ "(SELECT j.value FROM external_import e,
+ json_each(CASE WHEN json_valid(e.message_ids) THEN e.message_ids ELSE '[]' END) j
+ WHERE j.type = 'text'{scope})"
+ )
+}
+
+/// 一次会话解析的产物:正文之外还带枚举列里没有的 token 累计
+struct Parsed {
+ messages: Vec<TranscriptMessage>,
+ unknown: u32,
+ tokens: i64,
+}
+
+impl MimoAdapter {
+ pub fn new() -> Self {
+ let home = super::home_dir().unwrap_or_default();
+ let local = home.join(".local").join("share").join(DATA_DIR);
+ // MIMOCODE_HOME 必须是绝对路径(MiMo 自己对相对路径直接报错)
+ let mimo_home = super::env_dir("MIMOCODE_HOME")
+ .filter(|dir| dir.is_absolute())
+ .map(|dir| dir.join("data"));
+ let xdg = super::env_dir("XDG_DATA_HOME").map(|dir| dir.join(DATA_DIR));
+ // README 的说法(与 xdg-basedir 的实现对不上):macOS 的 Application Support、Windows 的
+ // %LOCALAPPDATA%;别的平台上不存在,无条件作候选无害
+ let app_support = home
+ .join("Library")
+ .join("Application Support")
+ .join(DATA_DIR);
+ let local_appdata = home.join("AppData").join("Local").join(DATA_DIR);
+ let hit = mimo_home
+ .iter()
+ .chain(&xdg)
+ .chain([&local, &app_support, &local_appdata])
+ .find(|dir| dir.join(DB_NAME).is_file())
+ .cloned();
+ // 哪儿都没有库:环境变量指着的位置(MiMo 在同一个环境里会写到那里),再回落默认位置
+ let root = hit.unwrap_or_else(|| mimo_home.or(xdg).unwrap_or(local));
+ Self::with_db(root.join(DB_NAME))
+ }
+
+ fn with_db(db: PathBuf) -> Self {
+ Self {
+ db,
+ rows_cache: MtimeCache::new(),
+ }
+ }
+
+ fn open(&self) -> Option<SqliteRo> {
+ open_sqlite_ro(&self.db, "mimo-code")
+ }
+
+ /// 列出来的会话与道子会话(没有正文的不收),按库(含 -wal)戳缓存。None = 库在却读不出
+ /// (打不开、查询出错)
+ fn rows(&self) -> Option<Arc<Vec<MiRow>>> {
+ let stamp = db_cache_stamp(&self.db);
+ self.rows_cache.get_or_try_build(stamp, || {
+ let ro = self.open()?;
+ let schema = MiSchema::probe(&ro.conn).ok()?;
+ let mut rows = query_rows(&ro.conn, schema, None).ok()?;
+ // 列出来的会话里的道才是子会话(导入的、簿记的会话里的不算)
+ let listed: HashSet<&str> = rows.iter().map(|row| row.session.as_str()).collect();
+ let lanes: Vec<MiRow> = query_lanes(&ro.conn, schema, None)
+ .ok()?
+ .into_iter()
+ .filter(|lane| listed.contains(lane.session.as_str()))
+ .collect();
+ rows.extend(lanes);
+ rows.retain(|row| row.content_len > 0);
+ Some(Arc::new(rows))
+ })
+ }
+
+ fn parse(
+ &self,
+ r: &SessionFileRef,
+ decode_images: bool,
+ ) -> Result<(SessionMeta, Vec<TranscriptMessage>, u32)> {
+ let _image_budget = transcript_image_decode_budget(decode_images);
+ if Path::new(strip_virtual_path(&r.file_path)) != self.db.as_path() {
+ return Err(anyhow!("mimo code database is outside adapter roots"));
+ }
+ let ro = self
+ .open()
+ .ok_or_else(|| anyhow!("cannot open mimo code db"))?;
+ let schema = MiSchema::probe(&ro.conn)?;
+ let (session, actor) = split_lane(&r.native_id);
+ let row = match actor {
+ None => query_rows(&ro.conn, schema, Some(session))?,
+ Some(actor) => query_lanes(&ro.conn, schema, Some((session, actor)))?,
+ }
+ .into_iter()
+ .next()
+ .ok_or_else(|| anyhow!("mimo code session {} not in db", r.native_id))?;
+ let parsed = parse_messages(&ro, &row, schema, decode_images)?;
+ let meta = build_meta(r, &row, &parsed);
+ Ok((meta, parsed.messages, parsed.unknown))
+ }
+}
+
+fn build_meta(r: &SessionFileRef, row: &MiRow, parsed: &Parsed) -> SessionMeta {
+ let project_path = canonical_project_path(&row.directory);
+ SessionMeta {
+ key: session_key(AgentId::MimoCode, "", &row.id),
+ host: String::new(),
+ id: row.id.clone(),
+ agent: AgentId::MimoCode,
+ title: session_title(&row.title, row.placeholder_title, &parsed.messages),
+ project_name: project_name_of(&project_path),
+ project_path,
+ file_path: r.file_path.clone(),
+ created_at: if row.created_ms > 0 {
+ row.created_ms
+ } else {
+ r.mtime_ms
+ },
+ updated_at: if row.updated_ms > 0 {
+ row.updated_ms
+ } else {
+ r.mtime_ms
+ },
+ message_count: parsed
+ .messages
+ .iter()
+ .filter(|m| m.kind == MessageKind::Text)
+ .count() as i64,
+ size_bytes: r.size,
+ git_branch: None,
+ // 同一会话会换模型,取最后一条助手消息用的
+ model: parsed.messages.iter().rev().find_map(|m| m.model.clone()),
+ tokens_used: (parsed.tokens > 0).then_some(parsed.tokens),
+ archived: row.archived,
+ source: None,
+ spawned: row.spawned(),
+ favorite: false,
+ pinned: false,
+ }
+}
+
+/// 自定义 location:选中库文件本身就用它;选中 `MIMOCODE_HOME`(里面是 data/)或 XDG data 根
+/// (里面是 mimocode/)往下找一层;其余当数据目录本身。MiMo Code 不做远程同步,没有"同步前
+/// 目录还不存在"的挂载点,可以看存在性(OpenCode 的 custom_db_paths 同样)
+fn custom_db(dir: PathBuf) -> PathBuf {
+ if dir.extension().is_some_and(|ext| ext == "db") {
+ return dir;
+ }
+ ["data", DATA_DIR]
+ .iter()
+ .map(|sub| dir.join(sub).join(DB_NAME))
+ .find(|db| db.is_file())
+ .unwrap_or_else(|| dir.join(DB_NAME))
+}
+
+/// 枚举 / 单会话取行
+fn query_rows(
+ conn: &Connection,
+ schema: MiSchema,
+ id: Option<&str>,
+) -> rusqlite::Result<Vec<MiRow>> {
+ if !schema.sessions {
+ return Ok(Vec::new());
+ }
+ let title_source = if schema.title_source {
+ "s.title_source"
+ } else {
+ "NULL"
+ };
+ // 单会话取行按主键找,不卡列不列(列表那一步卡过)、不算字节数(parse 拿的是 r.size)。
+ // 枚举用 octet_length:只读记录头、不碰溢出页,工具输出动辄几十 KB,LENGTH 得把它们整份读
+ // 出来数字符;字节数照样是合格的脏判据
+ let (content_len, filter) = match id {
+ Some(_) => ("0", "s.id = ?1".to_string()),
+ None => (
+ "(SELECT COALESCE(SUM(octet_length(p.data)), 0) FROM part p WHERE p.session_id = s.id)",
+ schema.listed(),
+ ),
+ };
+ let sql = format!(
+ "SELECT s.id, NULL, s.directory, s.title, {title_source}, s.time_created, s.time_updated,
+ s.time_archived, s.parent_id, {content_len}
+ FROM session s WHERE {filter}"
+ );
+ let mut stmt = conn.prepare(&sql)?;
+ let rows = stmt.query_map(rusqlite::params_from_iter(id), MiRow::from_sql)?;
+ rows.collect()
+}
+
+/// 同会话子代理的道:不是所在会话要显示的那条,不是运行时自己派的(那几种是簿记),至少有一条消息
+/// 不早于会话的创建(只有 fork 复制来的消息的道,原会话里已经有一份);时间只按这些消息算,项目与
+/// 归档跟着所在的会话。更新时间取消息的 time_updated:它是这条道的变更戳,消息原地改写(事后补写
+/// token 之类)时 part 字节数未必变,拿创建时间当戳,增量扫描就认不出、一直留着旧值。`one` 给了
+/// (会话, actor id) 就只取那一条、不算字节数。按道判的两条放在 HAVING、每条道求一遍:放进 WHERE
+/// 就是每条消息一遍,"要显示哪条道"那个 CASE 的 ELSE 还要把整个会话排一遍序
+fn query_lanes(
+ conn: &Connection,
+ schema: MiSchema,
+ one: Option<(&str, &str)>,
+) -> rusqlite::Result<Vec<MiRow>> {
+ let Some(shown) = schema.lane("m.session_id") else {
+ return Ok(Vec::new());
+ };
+ // 派活时那句 description;没给时它等于 agent 类型名,算没有
+ let (description, system) = if schema.actors {
+ (
+ "(SELECT NULLIF(a.description, a.agent) FROM actor_registry a
+ WHERE a.session_id = m.session_id AND a.actor_id = m.agent_id)",
+ format!(
+ " AND NOT EXISTS (SELECT 1 FROM actor_registry a WHERE a.session_id = m.session_id
+ AND a.actor_id = m.agent_id AND a.agent IN ({}))",
+ system_agents()
+ ),
+ )
+ } else {
+ ("NULL", String::new())
+ };
+ // `m.agent_id != 'main'` 也不收 NULL:`null_main` 的库里那是主线
+ let (content_len, parts, which) = match one {
+ Some(_) => ("0", "", " AND m.session_id = ?1 AND m.agent_id = ?2"),
+ None => (
+ "SUM(octet_length(p.data))",
+ " LEFT JOIN part p ON p.message_id = m.id",
+ "",
+ ),
+ };
+ let sql = format!(
+ "SELECT m.session_id, m.agent_id, s.directory, {description}, NULL, MIN(m.time_created),
+ MAX(m.time_updated), s.time_archived, NULL, {content_len}
+ FROM message m JOIN session s ON s.id = m.session_id{parts}
+ WHERE m.agent_id != 'main' AND m.time_created >= s.time_created{which}
+ GROUP BY m.session_id, m.agent_id
+ HAVING m.agent_id != {shown}{system}"
+ );
+ let mut stmt = conn.prepare(&sql)?;
+ let params: Vec<&str> = one.map(|(s, a)| vec![s, a]).unwrap_or_default();
+ let lanes = stmt.query_map(rusqlite::params_from_iter(params), MiRow::from_sql)?;
+ lanes.collect()
+}
+
+/// OpenCode 的 v1 两表循环 + MiMo 自己的几处差异(见模块注释):只读这条会话的那条道、导入的
+/// 不读;助手消息逐条带模型与 token;actor 派活的调用跳到它派出的子会话;provenance 归 Meta,
+/// 检查点与压缩摘要折成摘要;fork 复制来的那段折成一条、token 不算;导入过的会话开头留一条标记
+fn parse_messages(
+ ro: &SqliteRo,
+ row: &MiRow,
+ schema: MiSchema,
+ decode_images: bool,
+) -> Result<Parsed> {
+ // 导入只写在会话的 main 道上
+ let import = match row.actor {
+ None => import_of(&ro.conn, schema, &row.session)?,
+ Some(_) => None,
+ };
+ let query = V1Query {
+ filter: schema.transcript(row, import.is_some()),
+ ..V1Query::OPENCODE
+ };
+ let mut tokens = 0i64;
+ // 已拼出几条消息;最后一条 fork 复制来的(含)之前有几条
+ let mut built = 0usize;
+ let mut inherited = 0usize;
+ let (mut messages, unknown) = parse_v1_messages(
+ ro,
+ &row.session,
+ decode_images,
+ &query,
+ |md, parts, role, message| {
+ // fork 复制来的:时间早于会话(道子会话是它那条道)的起点
+ let ts = md
+ .pointer("/time/created")
+ .and_then(Value::as_i64)
+ .unwrap_or(0);
+ let copied = row.created_ms > 0 && ts > 0 && ts < row.created_ms;
+ // 一次调用 = input + output + reasoning,与 OpenCode 会话列同一个口径;拼不出消息的
+ // 失败 turn 照算
+ if role == Role::Assistant && !copied {
+ tokens += ["input", "output", "reasoning"]
+ .iter()
+ .filter_map(|k| md.get("tokens")?.get(k)?.as_i64())
+ .sum::<i64>();
+ }
+ let Some(m) = message else { return };
+ built += 1;
+ if copied {
+ inherited = built;
+ }
+ // 共用解析每个 tool 块按序出一个调用
+ let tools = parts.iter().filter(|p| part_type(p) == Some("tool"));
+ for (part, call) in tools.zip(&mut m.tool_calls) {
+ call.child_id = part
+ .pointer("/state/metadata")
+ .and_then(|metadata| actor_child(&row.session, metadata));
+ }
+ // 检查点重建的上下文:带 checkpoint 块、只有 synthetic 文本(共用解析给成 Meta)的那条
+ if m.kind == MessageKind::Meta
+ && parts.iter().any(|p| part_type(p) == Some("checkpoint"))
+ {
+ m.kind = MessageKind::CompactSummary;
+ }
+ match role {
+ Role::Assistant => {
+ m.model = optional_string(md.get("modelID"));
+ if true_at(md, "summary") {
+ m.kind = MessageKind::CompactSummary;
+ }
+ }
+ Role::User if md.get("provenance").is_some_and(|p| !p.is_null()) => {
+ m.kind = MessageKind::Meta;
+ }
+ _ => {}
+ }
+ },
+ )?;
+ collapse_inherited(&mut messages, inherited, "session");
+ // 导入的那段(转录里已经去掉)在开头留一条标记,与分叉复制来的那段同一种折法——内容本体在原来
+ // 那家 agent 的会话里
+ if let Some((source, count)) = import.filter(|(_, count)| *count > 0) {
+ let from = match source.as_str() {
+ "cc" => Some(AgentId::ClaudeCode),
+ other => AgentId::from_str(other),
+ }
+ .map_or(source.as_str(), |agent| agent.display_name());
+ messages.insert(
+ 0,
+ collapsed_marker(
+ count as usize,
+ &format!("imported from {from}"),
+ row.created_ms,
+ ),
+ );
+ }
+ assign_seq(&mut messages);
+ Ok(Parsed {
+ messages,
+ unknown,
+ tokens,
+ })
+}
+
+/// 这个会话的导入记录:来源(cc / codex / opencode)与导入了几条。没有导入表、没导入过给 None
+fn import_of(
+ conn: &Connection,
+ schema: MiSchema,
+ sid: &str,
+) -> rusqlite::Result<Option<(String, i64)>> {
+ if !schema.imports {
+ return Ok(None);
+ }
+ conn.query_row(
+ "SELECT source, CASE WHEN json_valid(message_ids) THEN json_array_length(message_ids) ELSE 0 END
+ FROM external_import WHERE session_id = ?1 ORDER BY time_imported DESC LIMIT 1",
+ [sid],
+ |r| Ok((r.get(0)?, r.get(1)?)),
+ )
+ .optional()
+}
+
+impl AgentAdapter for MimoAdapter {
+ fn agent(&self) -> AgentId {
+ AgentId::MimoCode
+ }
+
+ fn list_session_files(&self) -> Result<Vec<SessionFileRef>> {
+ // 库不在 = 没有会话;库在却读不出报 Err,scanner 冻结这一家这一轮(不变量 8①)——
+ // 当成没有会话的话,这一轮会把整家会话当"磁盘已删"清掉
+ if !self.db.is_file() {
+ return Ok(Vec::new());
+ }
+ let rows = self
+ .rows()
+ .ok_or_else(|| anyhow!("{} exists but could not be read", self.db.display()))?;
+ Ok(rows
+ .iter()
+ .map(|row| SessionFileRef {
+ agent: AgentId::MimoCode,
+ native_id: row.id.clone(),
+ file_path: virtual_path(&self.db, &row.id),
+ mtime_ms: row.updated_ms,
+ // 道子会话跟着会话归档,而 MiMo 归档只改会话那一行:归档那一位并进引用,道的戳没动
+ // 也会重解析(Kimi 的子代理同款)
+ size: row.content_len + i64::from(row.archived),
+ })
+ .collect())
+ }
+
+ fn manages_parent_links(&self) -> bool {
+ true
+ }
+
+ /// 子会话那一行的 parent_id,取这一轮枚举读到的那份(`MtimeCache::latest`,OpenCode 同款:
+ /// 扫描末尾才问到这里,按戳重读就是把整个枚举查询再跑一遍);还没枚举过就现读。库不在 =
+ /// 没有关系;库在却从没读成功过 = 不知道(None),库里的关系原样保留。道子会话的父会话写在
+ /// 它的 id 里(`parent_in_path`),不在这里报
+ fn parent_links(&self) -> Option<Vec<(String, String)>> {
+ if !self.db.is_file() {
+ return Some(Vec::new());
+ }
+ let rows = self.rows_cache.latest().or_else(|| self.rows())?;
+ Some(super::link_keys(
+ AgentId::MimoCode,
+ rows.iter()
+ .filter_map(|row| Some((row.id.as_str(), row.parent.as_deref()?))),
+ ))
+ }
+
+ /// 关系记在子会话自己那一行:多 location 下按子会话的胜出副本认边
+ fn parent_links_in_child(&self) -> bool {
+ true
+ }
+
+ fn parent_in_path(&self) -> Option<ParentInPath> {
+ Some(lane_parent)
+ }
+
+ fn parse_session(&self, r: &SessionFileRef) -> Result<ParsedSession> {
+ let (meta, messages, unknown) = self.parse(r, false)?;
+ Ok(ParsedSession::derive(meta, &messages, unknown))
+ }
+
+ fn parse_transcript(&self, r: &SessionFileRef) -> Result<ParsedTranscript> {
+ let (meta, messages, unknown) = self.parse(r, true)?;
+ Ok(ParsedTranscript {
+ meta,
+ mainline: messages,
+ sidechains: Vec::new(),
+ unknown_line_count: unknown,
+ })
+ }
+
+ fn data_roots(&self) -> Vec<PathBuf> {
+ vec![self.db.clone()]
+ }
+
+ fn with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {
+ Box::new(Self::with_db(custom_db(dir)))
+ }
+}
diff --git a/crates/wake-core/src/adapters/mod.rs b/crates/wake-core/src/adapters/mod.rs
index 91d3604..62e1997 100644
--- a/crates/wake-core/src/adapters/mod.rs
+++ b/crates/wake-core/src/adapters/mod.rs
@@ -15,6 +15,7 @@ pub mod hermes;
pub mod kilo;
pub mod kimi;
pub mod kiro;
+pub mod mimo;
pub mod openclaw;
pub mod opencode;
pub mod pi;
@@ -416,6 +417,7 @@ pub fn create_adapters() -> Vec<Box<dyn AgentAdapter>> {
Box::new(opencode::OpencodeAdapter::kilo()),
Box::new(kilo::KiloLegacyAdapter::new()),
Box::new(grok_bot::GrokBotAdapter::new()),
+ Box::new(mimo::MimoAdapter::new()),
]
}
diff --git a/crates/wake-core/src/adapters/opencode.rs b/crates/wake-core/src/adapters/opencode.rs
index f45db95..fa0510c 100644
--- a/crates/wake-core/src/adapters/opencode.rs
+++ b/crates/wake-core/src/adapters/opencode.rs
@@ -362,8 +362,8 @@ impl OpencodeAdapter {
&ro,
&r.native_id,
decode_images,
- &V1Order::OPENCODE,
- |_, _, _| {},
+ &V1Query::OPENCODE,
+ |_, _, _, _| {},
)?,
};
let count = messages
@@ -375,17 +375,21 @@ impl OpencodeAdapter {
}
}
-/// v1 两表路径的排序子句。OpenCode 按 id(前缀时间有序);ZCode 的两张表另有
-/// autofill 的 sequence 列,优先按它
-pub(crate) struct V1Order {
+/// v1 两表路径的取法:排序子句,与 message 表上的筛选。OpenCode 按 id(前缀时间有序)读整个
+/// 会话;ZCode 的两张表另有 autofill 的 sequence 列,优先按它;MiMo Code 只读要显示的那一段
+pub(crate) struct V1Query {
pub(crate) part: &'static str,
pub(crate) message: &'static str,
+ /// message 表上追加的条件。`?1` 是会话 id;条件既拼进 message 查询,也拼进 part 查询里挑消息
+ /// 的子查询,不带表名的列都要落在 message 表上;part 只取被选中的消息的。None = 整个会话
+ pub(crate) filter: Option<String>,
}
-impl V1Order {
- pub(crate) const OPENCODE: V1Order = V1Order {
+impl V1Query {
+ pub(crate) const OPENCODE: V1Query = V1Query {
part: "message_id, id",
message: "time_created, id",
+ filter: None,
};
}
@@ -399,21 +403,31 @@ fn json_at(r: &rusqlite::Row<'_>, ix: usize) -> rusqlite::Result<Option<Value>>
}
/// v1 正文:message 表(角色/时间)+ part 表(内容块)按 message_id 分组。
-/// `on_message` 对每一行 message 都调一次——带上已判好的角色,第三个参数是这一行拼出的消息,
-/// 全空(如只有 error 的失败 turn)时为 None;ZCode 用它拿 model / token /
-/// semantics,OpenCode 传空闭包。两家的差异只在这里和排序子句
+/// `on_message` 对每一行 message 都调一次——带上这一行的 part 与已判好的角色,第四个参数是这一行
+/// 拼出的消息,全空(如只有 error 的失败 turn)时为 None;ZCode / MiMo Code 用它拿 model / token /
+/// semantics(MiMo 还从 part 里认派活的道与检查点),OpenCode 传空闭包。各家的差异只在这里和取法
+/// (`V1Query`)
pub(crate) fn parse_v1_messages(
ro: &SqliteRo,
sid: &str,
decode_images: bool,
- order: &V1Order,
- mut on_message: impl FnMut(&Value, Role, Option<&mut TranscriptMessage>),
+ query: &V1Query,
+ mut on_message: impl FnMut(&Value, &[Value], Role, Option<&mut TranscriptMessage>),
) -> Result<(Vec<TranscriptMessage>, u32)> {
+ // 筛过的只取被选中消息的 part,按 message_id 走索引:挑消息的子查询已经钉住了会话,再写
+ // `session_id = ?1` 会让 SQLite 改走会话索引,把整个会话的 part 读一遍再排序
+ let (part_where, message_filter) = match &query.filter {
+ Some(f) => (
+ format!("message_id IN (SELECT id FROM message WHERE session_id = ?1 AND {f})"),
+ format!(" AND {f}"),
+ ),
+ None => ("session_id = ?1".to_string(), String::new()),
+ };
let mut parts_by_msg: HashMap<String, Vec<Value>> = HashMap::new();
{
let mut stmt = ro.conn.prepare(&format!(
- "SELECT message_id, data FROM part WHERE session_id = ?1 ORDER BY {}",
- order.part
+ "SELECT message_id, data FROM part WHERE {part_where} ORDER BY {}",
+ query.part
))?;
let rows = stmt.query_map([sid], |p| Ok((p.get::<_, String>(0)?, json_at(p, 1)?)))?;
for (mid, data) in rows.flatten() {
@@ -426,8 +440,8 @@ pub(crate) fn parse_v1_messages(
let mut messages: Vec<TranscriptMessage> = Vec::new();
let mut unknown = 0u32;
let mut stmt = ro.conn.prepare(&format!(
- "SELECT id, data FROM message WHERE session_id = ?1 ORDER BY {}",
- order.message
+ "SELECT id, data FROM message WHERE session_id = ?1{message_filter} ORDER BY {}",
+ query.message
))?;
let msg_rows = stmt.query_map([sid], |m| Ok((m.get::<_, String>(0)?, json_at(m, 1)?)))?;
for (mid, data) in msg_rows.flatten() {
@@ -446,13 +460,14 @@ pub(crate) fn parse_v1_messages(
.and_then(|v| v.as_i64())
.unwrap_or(0);
let mut acc = BlockAcc::default();
- for p in parts_by_msg.remove(&mid).unwrap_or_default() {
- if !acc.push_part(&p, decode_images) {
+ let parts = parts_by_msg.remove(&mid).unwrap_or_default();
+ for p in &parts {
+ if !acc.push_part(p, decode_images) {
unknown += 1;
}
}
let mut built = acc.into_message(role, ts, None);
- on_message(&md, role, built.as_mut());
+ on_message(&md, &parts, role, built.as_mut());
if let Some(m) = built {
messages.push(m);
}
@@ -602,7 +617,7 @@ struct BlockAcc {
impl BlockAcc {
/// 一个 part 块 → 累加器;返回 false = 表外类型(调用方计 unknown)。
- /// ZCode 的 part 与这里同形(它的运行时是 OpenCode 衍生物),两家共用这一个分派
+ /// ZCode 与 MiMo Code 的 part 与这里同形(都是 OpenCode 的衍生物),共用这一个分派
fn push_part(&mut self, p: &Value, decode_images: bool) -> bool {
match p.get("type").and_then(|v| v.as_str()) {
Some("text") => {
@@ -633,9 +648,11 @@ impl BlockAcc {
}
// agent = 正文里 @ 了哪个代理(文字本身在 text 块里);retry = 请求重试的记录;
// compaction = 触发压缩的标记(摘要本身是后面那条助手消息);timeline = ZCode 画在
- // 对话里的分隔条(分叉、压缩进度),没有正文
+ // 对话里的分隔条(分叉、压缩进度),没有正文;checkpoint = MiMo Code 的上下文检查点
+ // (那条消息怎么折由 MiMo 的钩子定)
Some("step-start") | Some("step-finish") | Some("snapshot") | Some("patch")
- | Some("agent") | Some("retry") | Some("compaction") | Some("timeline") => {}
+ | Some("agent") | Some("retry") | Some("compaction") | Some("timeline")
+ | Some("checkpoint") => {}
Some("file") if is_image_part(p) => self.push_image(p, decode_images),
Some("file") => {}
_ => return false,
diff --git a/crates/wake-core/src/adapters/parse_utils.rs b/crates/wake-core/src/adapters/parse_utils.rs
index 4c467f2..6712a5f 100644
--- a/crates/wake-core/src/adapters/parse_utils.rs
+++ b/crates/wake-core/src/adapters/parse_utils.rs
@@ -241,6 +241,30 @@ pub fn title_from_messages(messages: &[TranscriptMessage]) -> Option<String> {
.find(|title| !title.is_empty())
}
+/// 会话标题:存着的名字为准,没有就退回首条提问;`placeholder` 时反过来——存着的只是占位
+/// (ZCode 的 default、MiMo Code 的 fallback),有提问就用提问。都没有给 UNTITLED
+pub fn session_title(stored: &str, placeholder: bool, messages: &[TranscriptMessage]) -> String {
+ let stored = Some(clean_title_candidate(stored)).filter(|t| !t.is_empty());
+ let asked = || title_from_messages(messages);
+ if placeholder {
+ asked().or(stored)
+ } else {
+ stored.or_else(asked)
+ }
+ .unwrap_or_else(|| UNTITLED.to_string())
+}
+
+/// 折掉的一段留下的那条标记:"── N messages <来由> ──",System 角色的 Meta
+pub fn collapsed_marker(count: usize, origin: &str, ts: i64) -> TranscriptMessage {
+ meta_msg(
+ &format!(
+ "── {count} message{} {origin} ──",
+ crate::text::plural(count as i64)
+ ),
+ ts,
+ )
+}
+
/// 会话开头从父会话原样复制来的那段(Codex `spawn_agent` 的 fork_turns、Craft Agents
/// 的分支)折成一条 Meta 标记。原样入库就是:子会话偷走父会话的标题、父会话的每一句
/// 在 FTS 里出现两次、Insights 的 prompt 数翻倍。Meta 不进 FTS、不算 message_count、
@@ -260,15 +284,7 @@ pub fn collapse_inherited(messages: &mut Vec<TranscriptMessage>, cut: usize, par
.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;
+ let marker = collapsed_marker(turns, &format!("inherited from the parent {parent}"), ts);
messages.splice(..cut, std::iter::once(marker));
}
diff --git a/crates/wake-core/src/adapters/zcode.rs b/crates/wake-core/src/adapters/zcode.rs
index f69f048..564aa2a 100644
--- a/crates/wake-core/src/adapters/zcode.rs
+++ b/crates/wake-core/src/adapters/zcode.rs
@@ -58,7 +58,7 @@
//! 本机目录还是空的:目录名规则对真机核过(`default-0e81bcb7a4286b1b` 正是库里唯一
//! 工作区 `~/.zcode/workspace/default` 的 hash),文件格式按源码推断、**未经真机验证**
//! (OpenClaw / CodeBuddy 同款),fixture 合成。
-use super::opencode::{parse_v1_messages, V1Order};
+use super::opencode::{parse_v1_messages, V1Query};
use super::parse_utils::*;
use super::sqlite_ro::{
db_cache_stamp, open_sqlite_ro, strip_virtual_path, table_columns, virtual_path, SqliteRo,
@@ -144,18 +144,19 @@ impl ZcSchema {
}
/// 两张表都有 autofill 触发器给的 sequence 列;老库没有就退回 OpenCode 的序
- fn order(&self) -> V1Order {
- V1Order {
+ fn query(&self) -> V1Query {
+ V1Query {
part: if self.part_sequence {
"message_id, sequence, id"
} else {
- V1Order::OPENCODE.part
+ V1Query::OPENCODE.part
},
message: if self.message_sequence {
"sequence, time_created, id"
} else {
- V1Order::OPENCODE.message
+ V1Query::OPENCODE.message
},
+ filter: None,
}
}
}
@@ -276,29 +277,21 @@ impl ZcodeAdapter {
.into_iter()
.next()
.ok_or_else(|| anyhow!("zcode session {} not in db", r.native_id))?;
- let parsed = parse_messages(&ro, &r.native_id, decode_images, &schema.order())?;
+ let parsed = parse_messages(&ro, &r.native_id, decode_images, &schema.query())?;
let meta = build_meta(r, &row, &parsed);
Ok((meta, parsed.messages, parsed.unknown))
}
}
fn build_meta(r: &SessionFileRef, row: &ZcRow, parsed: &Parsed) -> SessionMeta {
- // 占位标题退回首条真人消息,一句都没有才用它;其余三级(first_input / generated /
- // custom)库里的就是最终值
- let stored = Some(clean_title_candidate(&row.title)).filter(|t| !t.is_empty());
- let asked = || title_from_messages(&parsed.messages);
- let title = if row.placeholder_title {
- asked().or(stored)
- } else {
- stored.or_else(asked)
- }
- .unwrap_or_else(|| UNTITLED.to_string());
SessionMeta {
key: session_key(AgentId::Zcode, "", &row.id),
host: String::new(),
id: row.id.clone(),
agent: AgentId::Zcode,
- title,
+ // 占位标题退回首条真人消息,一句都没有才用它;其余三级(first_input / generated /
+ // custom)库里的就是最终值
+ title: session_title(&row.title, row.placeholder_title, &parsed.messages),
project_path: row.directory.clone(),
project_name: project_name_of(&row.directory),
file_path: r.file_path.clone(),
@@ -477,14 +470,14 @@ fn parse_messages(
ro: &SqliteRo,
sid: &str,
decode_images: bool,
- order: &V1Order,
+ query: &V1Query,
) -> Result<Parsed> {
let mut tokens = 0i64;
// 已拼出几条消息;最后一条复制边界(含)之前有几条
let mut built = 0usize;
let mut inherited = 0usize;
let (mut messages, unknown) =
- parse_v1_messages(ro, sid, decode_images, order, |md, role, message| {
+ parse_v1_messages(ro, sid, decode_images, query, |md, _, role, message| {
let semantics = md.get("semantics");
let semantic = |key: &str| semantics.and_then(|s| s.get(key)).and_then(Value::as_str);
if role == Role::Assistant {
diff --git a/crates/wake-core/src/mcp/tools.rs b/crates/wake-core/src/mcp/tools.rs
index 2d2bb46..d982008 100644
--- a/crates/wake-core/src/mcp/tools.rs
+++ b/crates/wake-core/src/mcp/tools.rs
@@ -538,6 +538,7 @@ fn parse_agent(s: &str) -> Option<AgentId> {
"deepseek" => Some(AgentId::Dsh),
"opencode2" | "opencodenext" => Some(AgentId::Opencode),
"craft" => Some(AgentId::CraftAgents),
+ "mimo" => Some(AgentId::MimoCode),
_ => None,
})
}
@@ -1561,6 +1562,10 @@ mod tests {
assert_eq!(parse_agent("oh-my-pi"), Some(AgentId::Omp));
assert_eq!(parse_agent("DeepSeek"), Some(AgentId::Dsh));
assert_eq!(parse_agent("opencode2"), Some(AgentId::Opencode));
+ // 命令名、正名、连写的产品名都认
+ assert_eq!(parse_agent("mimo"), Some(AgentId::MimoCode));
+ assert_eq!(parse_agent("MiMo Code"), Some(AgentId::MimoCode));
+ assert_eq!(parse_agent("MiMoCode"), Some(AgentId::MimoCode));
assert_eq!(parse_agent("chatgpt"), None);
}
diff --git a/crates/wake-core/src/models.rs b/crates/wake-core/src/models.rs
index 89c834a..517584f 100644
--- a/crates/wake-core/src/models.rs
+++ b/crates/wake-core/src/models.rs
@@ -29,13 +29,14 @@ pub enum AgentId {
CraftAgents,
Devin,
Kilo,
+ MimoCode,
}
impl AgentId {
/// 全部 agent,**枚举声明序**(= Ord = 用户钉的侧栏展示序;面板成组、
/// 表单下拉共用同一顺序)。曾误抄 create_adapters 的构造序,下拉与侧栏
/// 排序当场对不上——契约测试现在卡它与 Ord 一致
- pub const ALL: [AgentId; 23] = [
+ pub const ALL: [AgentId; 24] = [
AgentId::ClaudeCode,
AgentId::Codex,
AgentId::Grok,
@@ -59,6 +60,7 @@ impl AgentId {
AgentId::CraftAgents,
AgentId::Devin,
AgentId::Kilo,
+ AgentId::MimoCode,
];
pub fn as_str(&self) -> &'static str {
@@ -86,6 +88,7 @@ impl AgentId {
AgentId::Devin => "devin",
AgentId::Kilo => "kilo",
AgentId::GrokBot => "grok-bot",
+ AgentId::MimoCode => "mimo-code",
}
}
@@ -114,6 +117,7 @@ impl AgentId {
"devin" => Some(AgentId::Devin),
"kilo" => Some(AgentId::Kilo),
"grok-bot" => Some(AgentId::GrokBot),
+ "mimo-code" => Some(AgentId::MimoCode),
_ => None,
}
}
@@ -143,6 +147,7 @@ impl AgentId {
AgentId::Devin => "Devin",
AgentId::Kilo => "Kilo Code",
AgentId::GrokBot => "Grok Bot",
+ AgentId::MimoCode => "MiMo Code",
}
}
@@ -248,6 +253,15 @@ impl AgentId {
// 官方 app 图标(黑底圆角方块里一张带两只眼睛的白脸),两模式通用,ZCode 同款。图标里只有
// 256px 的位图,侧栏尺寸下够用
AgentId::GrokBot => "brands/grok-bot.png",
+ // 官网 favicon 与 lobe-icons 的 xiaomimimo 是同一个单色字标(上 "Xiaomi"、下 "MIMO"),
+ // 同 Kilo / Devin 按模式取白版或深墨版
+ AgentId::MimoCode => {
+ if dark {
+ "brands/mimo-code.png"
+ } else {
+ "brands/mimo-code-light.png"
+ }
+ }
}
}
}
diff --git a/crates/wake-core/src/remote.rs b/crates/wake-core/src/remote.rs
index 4f9a04d..5192784 100644
--- a/crates/wake-core/src/remote.rs
+++ b/crates/wake-core/src/remote.rs
@@ -282,6 +282,9 @@ pub const NOT_SYNCED: &[AgentId] = &[
// 本机那份是云端对话的缓存:另一台机器上的 app 缓存着同一批对话,同步过来同一个对话会按 host
// 各列一遍(副本去重的域含 host)。缓存目录名带空格是次要的,白名单补上引号也不该同步
AgentId::GrokBot,
+ // 会话只在 mimocode.db 里,同一个库还有存 access / refresh token 的 account 表;SQLite 是
+ // 整文件,拉会话就得连凭证一起拷到本机(Kilo 新版的 kilo.db 与 OpenClaw 的库同样因此不拉)
+ AgentId::MimoCode,
];
/// host 名合法性:进 session key 作中段(不能有 ':')、直接作为 ssh/rsync
diff --git a/crates/wake-core/src/services/terminal/macos.rs b/crates/wake-core/src/services/terminal/macos.rs
index ce11989..ce11129 100644
--- a/crates/wake-core/src/services/terminal/macos.rs
+++ b/crates/wake-core/src/services/terminal/macos.rs
@@ -228,7 +228,7 @@ fn kooky_cli_path() -> Option<&'static Path> {
/// 注册就退 0,Wake 这边看不出失败——所以名单外必须改走 kooky-cli 的哑管道。
/// 注意 Antigravity 不在里面:kooky 的 stores 表注释写明其 CLI 数据布局未经
/// 核实、"Absent by design"。新增 agent 时按 kooky 那张表核对,别默认落进深链
-/// (2026-10 Kilo Code 加入时核对过:kooky 不认它,走 kooky-cli)
+/// (2026-10 Kilo Code、MiMo Code 加入时核对过:kooky 都不认,走 kooky-cli)
const KOOKY_ROSTER: &[AgentId] = &[
AgentId::ClaudeCode,
AgentId::Codex,
diff --git a/crates/wake-core/src/services/terminal/mod.rs b/crates/wake-core/src/services/terminal/mod.rs
index 50917a1..a35aaa8 100644
--- a/crates/wake-core/src/services/terminal/mod.rs
+++ b/crates/wake-core/src/services/terminal/mod.rs
@@ -157,6 +157,8 @@ pub fn agent_bin(agent: AgentId) -> Option<&'static str> {
AgentId::Kilo => Some("kilo"),
// Grok Bot 是桌面 app,bot 跑在云端电脑上,没有命令行
AgentId::GrokBot => None,
+ // 官方安装脚本装进 ~/.mimocode/bin 并写进 shell 的 PATH;npm 包同名
+ AgentId::MimoCode => Some("mimo"),
}
}
@@ -234,6 +236,8 @@ fn resume_args(meta: &SessionMeta) -> Option<(Vec<String>, bool)> {
AgentId::Kilo => Some((vec!["--session".into(), id.into()], true)),
// Grok Bot:对话在云端、只有桌面 app,没有能接着聊的命令——不画 Open In
AgentId::GrokBot => None,
+ // MiMo Code(OpenCode 分支)与 OpenCode 同形制;会话按项目目录记,在原目录启动
+ AgentId::MimoCode => Some((vec!["--session".into(), id.into()], true)),
// Kiro / Gemini CLI 没有按会话 id 续会话的形制
AgentId::Kiro | AgentId::Gemini => None,
}
@@ -714,6 +718,7 @@ mod tests {
(AgentId::Codebuddy, vec!["--resume", id], true),
(AgentId::Devin, vec!["--resume", id], true),
(AgentId::Kilo, vec!["--session", id], true),
+ (AgentId::MimoCode, vec!["--session", id], true),
] {
let meta = remote_meta(agent, id, "");
let (args, cwd) = super::resume_args(&meta).unwrap();
diff --git a/crates/wake-core/src/skills.rs b/crates/wake-core/src/skills.rs
index 11c9018..06852c7 100644
--- a/crates/wake-core/src/skills.rs
+++ b/crates/wake-core/src/skills.rs
@@ -288,6 +288,9 @@ fn user_dirs(agent: AgentId) -> Option<UserDirs> {
// 新版与旧版扩展
AgentId::Kilo => Fixed(Base::Home, &[".kilo/skills", ".kilocode/skills"]),
AgentId::Opencode => Fixed(Base::Config, &["opencode/skills"]),
+ // OpenCode 分支,同一套 xdg-basedir(MIMOCODE_HOME 改道不跟,OpenCode 的 OPENCODE_CONFIG_DIR
+ // 同样);它还读 `skill/` 单数与 `~/.mimocode`,常用的是这一处
+ AgentId::MimoCode => Fixed(Base::Config, &["mimocode/skills"]),
AgentId::Devin => Fixed(Base::AppConfig, &["devin/skills"]),
AgentId::Kimi | AgentId::GrokBot | AgentId::Workbuddy => return None,
})
@@ -315,6 +318,7 @@ fn project_dirs(agent: AgentId) -> &'static [&'static str] {
AgentId::Zcode => &[".zcode/skills"],
AgentId::Devin => &[".devin/skills"],
AgentId::Kilo => &[".kilo/skills"],
+ AgentId::MimoCode => &[".mimocode/skills"],
AgentId::Openclaw
| AgentId::CraftAgents
| AgentId::Kimi
diff --git a/crates/wake-core/tests/adapter_contracts.rs b/crates/wake-core/tests/adapter_contracts.rs
index fa404ae..ab93364 100644
--- a/crates/wake-core/tests/adapter_contracts.rs
+++ b/crates/wake-core/tests/adapter_contracts.rs
@@ -30,6 +30,7 @@ use wake_core::adapters::hermes::HermesAdapter;
use wake_core::adapters::kilo::{legacy_task_key, migrated_session_id, KiloLegacyAdapter};
use wake_core::adapters::kimi::KimiAdapter;
use wake_core::adapters::kiro::KiroAdapter;
+use wake_core::adapters::mimo::MimoAdapter;
use wake_core::adapters::openclaw::OpenclawAdapter;
use wake_core::adapters::opencode::OpencodeAdapter;
use wake_core::adapters::pi::PiAdapter;
@@ -58,6 +59,7 @@ struct TestEnv {
kilo_db: PathBuf,
kilo_tasks: PathBuf,
kilo_cursor_tasks: PathBuf,
+ mimo_db: PathBuf,
/// Grok Bot 的缓存目录(`<userData>/sand-client-persistence`)
grok_bot_store: PathBuf,
/// 假 HOME 目录本体,持有 TempDir 保证整个测试进程期间不被清理
@@ -113,6 +115,7 @@ fn setup() -> &'static TestEnv {
kilo_db: sc.kilo_db,
kilo_tasks: sc.kilo_tasks,
kilo_cursor_tasks: sc.kilo_cursor_tasks,
+ mimo_db: sc.mimo_db,
grok_bot_store,
_home: home,
}
@@ -3650,7 +3653,14 @@ fn data_roots_contract() {
.filter(|a| a.detect())
.map(|a| a.agent().as_str())
.collect();
- for expect in ["copilot", "opencode", "antigravity", "dsh", "kilo"] {
+ for expect in [
+ "copilot",
+ "opencode",
+ "antigravity",
+ "dsh",
+ "kilo",
+ "mimo-code",
+ ] {
assert!(
detected.contains(&expect),
"{expect} 应被检出,实际 {detected:?}"
@@ -4023,7 +4033,7 @@ fn dsh_reads_the_newest_format_generation() {
#[test]
fn seq_contract_holds_for_all_agents() {
let env = setup();
- let checks: Vec<(Box<dyn AgentAdapter>, SessionFileRef)> = vec![
+ let mut checks: Vec<(Box<dyn AgentAdapter>, SessionFileRef)> = vec![
(Box::new(ClaudeAdapter::new()), claude_ref()),
(Box::new(CodexAdapter::new()), codex_ref()),
(Box::new(QoderAdapter::new()), qoder_ref()),
@@ -4121,6 +4131,21 @@ fn seq_contract_holds_for_all_agents() {
grok_bot_ref(GB_SCOUT, true),
),
];
+ // MiMo Code:主线、道子会话、peer 子会话、旁问宿主、导入后接着聊、fork——各从不同的道读、
+ // 各有折叠
+ for id in [
+ "ses_mimo_0001",
+ "ses_mimo_0001/explore-1",
+ "ses_mimo_0002",
+ "ses_mimo_0004",
+ "ses_mimo_0006",
+ "ses_mimo_0008",
+ ] {
+ checks.push((
+ Box::new(MimoAdapter::new()),
+ db_ref(AgentId::MimoCode, &env.mimo_db, id),
+ ));
+ }
for (adapter, r) in &checks {
assert_seq_contract(adapter.as_ref(), r);
}
@@ -4780,6 +4805,13 @@ fn unreadable_session_databases_freeze_instead_of_emptying() {
let openclaw = OpenclawAdapter::new().with_custom_root(agents);
assert!(openclaw.list_session_files().is_err());
assert_eq!(openclaw.parent_links(), None);
+
+ let mimo = MimoAdapter::new().with_custom_root(bad("mimocode.db"));
+ assert!(mimo.list_session_files().is_err());
+ assert_eq!(mimo.parent_links(), None);
+ let mimo = MimoAdapter::new().with_custom_root(fresh("mimocode.db"));
+ assert!(mimo.list_session_files().unwrap().is_empty());
+ assert_eq!(mimo.parent_links(), Some(Vec::new()));
}
/// 只有 agent 派生的子会话不算 Insights 里的会话:sessions_spawn 起的可见子会话只记
@@ -5257,6 +5289,424 @@ fn devin_custom_root_normalization() {
assert_eq!(adapter.data_roots(), vec![lone]);
}
+// ---------------------------------------------------------------- MiMo Code
+
+/// MiMo Code:OpenCode 形状的 v1 两表,但一个会话里有好几条道(主线 main、同会话的子代理、peer
+/// 子会话以自己的 id 命名的那条);照 MiMo 自己的规则挑会话显示哪条道、挑哪些会话显示,其余的道
+/// 各是一条子会话;导入别家的会话只有在 MiMo 里接着聊过才列;fork 复制来的那段折成一条
+#[test]
+fn mimo_code_parse_contract() {
+ let env = setup();
+ let adapter: Box<dyn AgentAdapter> = Box::new(MimoAdapter::new());
+ let mimo_ref = |id: &str| db_ref(AgentId::MimoCode, &env.mimo_db, id);
+ let mut ids: Vec<String> = adapter
+ .list_session_files()
+ .expect("mimo code list")
+ .into_iter()
+ .map(|r| r.native_id)
+ .collect();
+ ids.sort();
+ // 0003 是 checkpoint-writer 的宿主,0005 是没聊过的导入,0007 是分不清哪些是导入的老记录,
+ // 0012 没有正文;0001 里 checkpoint-writer 的道是簿记,0008 里的 explore-1 道全是 fork 复制来的
+ assert_eq!(
+ ids,
+ vec![
+ "ses_mimo_0001",
+ "ses_mimo_0001/explore-1",
+ "ses_mimo_0002",
+ "ses_mimo_0002/explore-1",
+ "ses_mimo_0004",
+ "ses_mimo_0006",
+ "ses_mimo_0008",
+ "ses_mimo_0009",
+ "ses_mimo_0010",
+ "ses_mimo_0011",
+ "ses_mimo_0011/explore-1",
+ ]
+ );
+ assert_eq!(
+ sorted_links(adapter.as_ref()),
+ vec![
+ edge("mimo-code:ses_mimo_0002", "mimo-code:ses_mimo_0001"),
+ edge("mimo-code:ses_mimo_0004", "mimo-code:ses_mimo_0001"),
+ ]
+ );
+ // 道子会话的父会话写在 id 里,停在直接父会话上(peer 子会话自己的道挂在 peer 子会话下)
+ assert_eq!(
+ path_links(adapter.as_ref()),
+ vec![
+ edge(
+ "mimo-code:ses_mimo_0001/explore-1",
+ "mimo-code:ses_mimo_0001"
+ ),
+ edge(
+ "mimo-code:ses_mimo_0002/explore-1",
+ "mimo-code:ses_mimo_0002"
+ ),
+ edge(
+ "mimo-code:ses_mimo_0011/explore-1",
+ "mimo-code:ses_mimo_0011"
+ ),
+ ]
+ );
+ // agent 派出去的(peer 子会话、旁问的宿主、同会话子代理的道)与自动整理记忆的 Auto Dream 不算
+ // 用户开的会话
+ assert_eq!(
+ spawned_ids(adapter.as_ref()),
+ vec![
+ "ses_mimo_0001/explore-1",
+ "ses_mimo_0002",
+ "ses_mimo_0002/explore-1",
+ "ses_mimo_0004",
+ "ses_mimo_0010",
+ "ses_mimo_0011/explore-1",
+ ]
+ );
+
+ // 主线:同会话子代理的道各是一条子会话,不进转录、token 也各算各的(150 + 25 + 20)
+ let r = mimo_ref("ses_mimo_0001");
+ let s = adapter.parse_session(&r).expect("mimo code parse_session");
+ let t = adapter
+ .parse_transcript(&r)
+ .expect("mimo code parse_transcript");
+ assert_eq!(s.meta.key, "mimo-code:ses_mimo_0001");
+ assert_eq!(s.meta.agent, AgentId::MimoCode);
+ assert_eq!(s.meta.title, "MiMo 二维码泄漏排查");
+ assert_eq!(s.meta.project_path, "/Users/tester/Github/wakefx");
+ assert_eq!(s.meta.model.as_deref(), Some("mimo-v2.5-pro"));
+ assert_eq!(s.meta.tokens_used, Some(195));
+ assert_eq!(s.meta.created_at, 1790000000000);
+ assert_eq!(s.meta.updated_at, 1790000080000);
+ assert_eq!(s.meta.message_count, 3);
+ assert!(!s.meta.archived);
+ assert_eq!(
+ s.unknown_line_count, 0,
+ "checkpoint / compaction 都是已知的 part"
+ );
+ assert_eq!(
+ roles_kinds(&t.mainline),
+ vec![
+ (Role::User, MessageKind::Text),
+ (Role::Assistant, MessageKind::Text),
+ // 钩子带着 provenance 发来的,不是人打的字
+ (Role::User, MessageKind::Meta),
+ (Role::Assistant, MessageKind::Text),
+ // 检查点重建的上下文、压缩出的摘要;只有 compaction 标记的那条没有正文
+ (Role::User, MessageKind::CompactSummary),
+ (Role::Assistant, MessageKind::CompactSummary),
+ ]
+ );
+ assert!(
+ t.mainline
+ .iter()
+ .all(|m| !m.text.contains("useEffect(() =>")),
+ "子代理那条道不进转录"
+ );
+ let a = &t.mainline[1];
+ assert_eq!(a.text, "找到了:卸载时没有停止扫描。");
+ assert_eq!(a.thinking.as_deref(), Some("先看清理函数"));
+ assert_eq!(a.model.as_deref(), Some("mimo-v2.5-pro"));
+ // 派同会话子代理的调用跳到那条道子会话,派 peer 的跳到子会话
+ assert_eq!(
+ a.tool_calls[0].child_id.as_deref(),
+ Some("ses_mimo_0001/explore-1")
+ );
+ assert_eq!(
+ t.mainline[3].tool_calls[0].child_id.as_deref(),
+ Some("ses_mimo_0002")
+ );
+ assert!(t.mainline[4].text.contains("Recent activity"));
+ assert_eq!(t.mainline[5].text, "Summary of the QR work so far.");
+
+ // 道子会话:标题是派活时那句 description,时间、token 只算它那条道;不能单独恢复
+ let lane = mimo_ref("ses_mimo_0001/explore-1");
+ let sl = adapter.parse_session(&lane).unwrap();
+ let tl = adapter.parse_transcript(&lane).unwrap();
+ assert_eq!(sl.meta.key, "mimo-code:ses_mimo_0001/explore-1");
+ assert_eq!(sl.meta.title, "find the QR hook");
+ assert_eq!(sl.meta.project_path, "/Users/tester/Github/wakefx");
+ assert_eq!(sl.meta.model.as_deref(), Some("mimo-v2.5-flash"));
+ assert_eq!(sl.meta.tokens_used, Some(35));
+ assert_eq!(
+ (sl.meta.created_at, sl.meta.updated_at),
+ (1790000020000, 1790000030000)
+ );
+ assert!(!sl.meta.archived);
+ assert!(!resumable(&adapter, &sl.meta));
+ assert_eq!(
+ roles_kinds(&tl.mainline),
+ vec![
+ (Role::User, MessageKind::Text),
+ (Role::Assistant, MessageKind::Text)
+ ]
+ );
+ assert_eq!(
+ tl.mainline[1].text,
+ "src/QrScanner.tsx:42 useEffect(() => {"
+ );
+
+ // peer 子会话:消息在以它自己的 id 命名的道上
+ let s2 = adapter.parse_session(&mimo_ref("ses_mimo_0002")).unwrap();
+ assert_eq!(s2.meta.title, "general: run the QR tests");
+ assert_eq!(s2.meta.message_count, 2);
+ assert_eq!(s2.meta.tokens_used, Some(15));
+ // 它派的道没给 description(等于 agent 类型名):标题退回收到的任务
+ let s2l = adapter
+ .parse_session(&mimo_ref("ses_mimo_0002/explore-1"))
+ .unwrap();
+ assert_eq!(s2l.meta.title, "list the QR test files");
+ assert_eq!(s2l.meta.tokens_used, Some(5));
+
+ // 旁问的宿主:没有主线、也没有以自己命名的道,读最新的那条(build-1)
+ let t4 = adapter
+ .parse_transcript(&mimo_ref("ses_mimo_0004"))
+ .unwrap();
+ assert_eq!(
+ roles_kinds(&t4.mainline),
+ vec![
+ (Role::User, MessageKind::Text),
+ (Role::Assistant, MessageKind::Text)
+ ]
+ );
+ assert_eq!(
+ t4.mainline[1].text,
+ "Because the cleanup never stops the camera."
+ );
+
+ // 从 Codex 导入后在 MiMo 里接着聊过:导入的两条折成一条标记,不进 FTS、token 不算
+ let r6 = mimo_ref("ses_mimo_0006");
+ let s6 = adapter.parse_session(&r6).unwrap();
+ let t6 = adapter.parse_transcript(&r6).unwrap();
+ assert_eq!(
+ roles_kinds(&t6.mainline),
+ vec![
+ (Role::System, MessageKind::Meta),
+ (Role::User, MessageKind::Text),
+ (Role::Assistant, MessageKind::Text),
+ ]
+ );
+ assert!(t6.mainline[0]
+ .text
+ .contains("2 messages imported from Codex"));
+ assert_eq!(s6.meta.title, "Codex 那边问过的");
+ assert_eq!(s6.meta.tokens_used, Some(8));
+ assert!(s6.units.iter().all(|u| !u.text.contains("Codex 那边的")));
+
+ // fork:开头复制来的两条(时间早于 fork 的创建时间)折成一条;token 与模型只算之后的,
+ // 子代理道里复制来的那条也不算
+ let r8 = mimo_ref("ses_mimo_0008");
+ let s8 = adapter.parse_session(&r8).unwrap();
+ let t8 = adapter.parse_transcript(&r8).unwrap();
+ assert_eq!(
+ roles_kinds(&t8.mainline),
+ vec![
+ (Role::System, MessageKind::Meta),
+ (Role::User, MessageKind::Text),
+ (Role::Assistant, MessageKind::Text),
+ ]
+ );
+ assert!(t8.mainline[0]
+ .text
+ .contains("2 messages inherited from the parent session"));
+ assert_eq!(s8.meta.tokens_used, Some(7));
+ assert_eq!(s8.meta.model.as_deref(), Some("mimo-v2.5-flash"));
+ assert!(s8.units.iter().all(|u| !u.text.contains("二维码")));
+
+ // 占位标题退回首条提问
+ let s9 = adapter.parse_session(&mimo_ref("ses_mimo_0009")).unwrap();
+ assert_eq!(s9.meta.title, "占位标题取这句");
+
+ // Auto Dream:任务那句是钩子发的(synthetic),不是提问
+ let s10 = adapter.parse_session(&mimo_ref("ses_mimo_0010")).unwrap();
+ assert_eq!(s10.meta.title, "Auto Dream");
+ assert_eq!(s10.meta.message_count, 1);
+
+ let s11 = adapter.parse_session(&mimo_ref("ses_mimo_0011")).unwrap();
+ assert!(s11.meta.archived);
+ // 道子会话跟着所在会话归档:不跟的话会话被藏、它的子代理冒成顶层
+ let s11l = adapter
+ .parse_session(&mimo_ref("ses_mimo_0011/explore-1"))
+ .unwrap();
+ assert!(s11l.meta.archived);
+}
+
+/// 老库(2026-05 之前没有 message.agent_id、2026-09 之前没有 title_source,也没有导入表与
+/// actor_registry)不能让整家消失:一个会话只有一条道,parent_id 照样挂
+#[test]
+fn mimo_code_degrades_on_old_schema() {
+ setup();
+ let dir = tempfile::tempdir().unwrap();
+ let conn = rusqlite::Connection::open(dir.path().join("mimocode.db")).unwrap();
+ conn.execute_batch(
+ r#"
+ CREATE TABLE session (id TEXT PRIMARY KEY, project_id TEXT, parent_id TEXT, slug TEXT,
+ directory TEXT, title TEXT, version TEXT, time_created INTEGER,
+ time_updated INTEGER, time_archived INTEGER);
+ CREATE TABLE message (id TEXT PRIMARY KEY, session_id TEXT, time_created INTEGER,
+ time_updated INTEGER, data TEXT);
+ CREATE TABLE part (id TEXT PRIMARY KEY, message_id TEXT, session_id TEXT,
+ time_created INTEGER, time_updated INTEGER, data TEXT);
+ INSERT INTO session VALUES ('old-1','p',NULL,'a','/work/old','','0.0.9',1780000000000,1780000002000,NULL);
+ INSERT INTO session VALUES ('old-2','p','old-1','b','/work/old','explore: grep','0.0.9',1780000001000,1780000001500,NULL);
+ INSERT INTO message VALUES ('m1','old-1',1780000000000,1780000000000,'{"role":"user","time":{"created":1780000000000}}');
+ INSERT INTO part VALUES ('p1','m1','old-1',1780000000000,1780000000000,'{"type":"text","text":"老库也要能读"}');
+ INSERT INTO message VALUES ('m2','old-1',1780000002000,1780000002000,'{"role":"assistant","time":{"created":1780000002000},"modelID":"mimo-v1","tokens":{"input":4,"output":1,"reasoning":0}}');
+ INSERT INTO part VALUES ('p2','m2','old-1',1780000002000,1780000002000,'{"type":"text","text":"能。"}');
+ INSERT INTO message VALUES ('m3','old-2',1780000001000,1780000001000,'{"role":"user","time":{"created":1780000001000}}');
+ INSERT INTO part VALUES ('p3','m3','old-2',1780000001000,1780000001000,'{"type":"text","text":"grep"}');
+ "#,
+ )
+ .unwrap();
+ drop(conn);
+
+ let adapter = MimoAdapter::new().with_custom_root(dir.path().to_path_buf());
+ let mut refs = adapter.list_session_files().unwrap();
+ refs.sort_by(|a, b| a.native_id.cmp(&b.native_id));
+ assert_eq!(refs.len(), 2, "老 schema 不得整家消失");
+ assert_eq!(
+ sorted_links(adapter.as_ref()),
+ vec![edge("mimo-code:old-2", "mimo-code:old-1")]
+ );
+ let s = adapter.parse_session(&refs[0]).unwrap();
+ // 老库的占位标题是空串:退回首条提问
+ assert_eq!(s.meta.title, "老库也要能读");
+ assert_eq!(s.meta.message_count, 2);
+ assert_eq!(s.meta.tokens_used, Some(5));
+ assert_eq!(s.meta.model.as_deref(), Some("mimo-v1"));
+ assert_eq!(spawned_ids(adapter.as_ref()), vec!["old-2"]);
+}
+
+/// 道的引用在 part 字节数不变的改动之后也得变,增量扫描才会重解析它:消息原地改写(事后补写
+/// token)、会话归档(MiMo 只改会话那一行,道子会话跟着会话归档)
+#[test]
+fn mimo_code_lane_refs_change_without_new_parts() {
+ setup();
+ let dir = tempfile::tempdir().unwrap();
+ let db = dir.path().join("mimocode.db");
+ common::build_mimo_db(&db);
+ let lane = "ses_mimo_0001/explore-1";
+ // 每次现建一个实例:不靠行缓存认出库变了
+ let adapter = || MimoAdapter::new().with_custom_root(db.clone());
+ let lane_ref = || {
+ adapter()
+ .list_session_files()
+ .unwrap()
+ .into_iter()
+ .find(|r| r.native_id == lane)
+ .expect("道子会话列得出")
+ };
+ let stamp = |r: &SessionFileRef| (r.mtime_ms, r.size);
+ let write = |sql: &str| {
+ rusqlite::Connection::open(&db)
+ .unwrap()
+ .execute(sql, [])
+ .unwrap();
+ };
+
+ // 子代理那条回复事后补写 token:消息改了,part 一个字节都没动
+ let before = lane_ref();
+ write(
+ "UPDATE message SET data = json_set(data, '$.tokens.output', 15), time_updated = 1790000040000
+ WHERE id = 'msg_m1_03'",
+ );
+ let updated = lane_ref();
+ assert_ne!(stamp(&before), stamp(&updated));
+ assert_eq!(
+ adapter().parse_session(&updated).unwrap().meta.tokens_used,
+ Some(45)
+ );
+
+ // 会话归档
+ write(
+ "UPDATE session SET time_archived = 1790009000000, time_updated = 1790009000000
+ WHERE id = 'ses_mimo_0001'",
+ );
+ let archived = lane_ref();
+ assert_ne!(stamp(&updated), stamp(&archived));
+ assert!(adapter().parse_session(&archived).unwrap().meta.archived);
+}
+
+/// 2026-05-21 到 05-26 之间的库:message.agent_id 已经有了、还可以为空,主线的消息是 NULL。NULL
+/// 当作 main——不然主线一条都读不到,子代理那条道反倒成了会话显示的那条
+#[test]
+fn mimo_code_reads_null_agent_id_as_main() {
+ setup();
+ let dir = tempfile::tempdir().unwrap();
+ let conn = rusqlite::Connection::open(dir.path().join("mimocode.db")).unwrap();
+ conn.execute_batch(
+ r#"
+ CREATE TABLE session (id TEXT PRIMARY KEY, project_id TEXT, parent_id TEXT, slug TEXT,
+ directory TEXT, title TEXT, version TEXT, time_created INTEGER,
+ time_updated INTEGER, time_archived INTEGER);
+ CREATE TABLE message (id TEXT PRIMARY KEY, session_id TEXT, agent_id TEXT,
+ time_created INTEGER, time_updated INTEGER, data TEXT);
+ CREATE TABLE part (id TEXT PRIMARY KEY, message_id TEXT, session_id TEXT,
+ time_created INTEGER, time_updated INTEGER, data TEXT);
+ INSERT INTO session VALUES ('win-1','p',NULL,'a','/work/win','','0.1.0',1780000000000,1780000003000,NULL);
+ INSERT INTO message VALUES ('m1','win-1',NULL,1780000000000,1780000000000,'{"role":"user","time":{"created":1780000000000}}');
+ INSERT INTO part VALUES ('p1','m1','win-1',1780000000000,1780000000000,'{"type":"text","text":"主线的消息还是 NULL"}');
+ INSERT INTO message VALUES ('m2','win-1',NULL,1780000002000,1780000002000,'{"role":"assistant","time":{"created":1780000002000},"modelID":"mimo-v1","tokens":{"input":4,"output":1,"reasoning":0}}');
+ INSERT INTO part VALUES ('p2','m2','win-1',1780000002000,1780000002000,'{"type":"text","text":"照样读得到。"}');
+ INSERT INTO message VALUES ('m3','win-1','explore-1',1780000003000,1780000003000,'{"role":"user","time":{"created":1780000003000}}');
+ INSERT INTO part VALUES ('p3','m3','win-1',1780000003000,1780000003000,'{"type":"text","text":"子代理那条道"}');
+ "#,
+ )
+ .unwrap();
+ drop(conn);
+
+ let adapter = MimoAdapter::new().with_custom_root(dir.path().to_path_buf());
+ let mut refs = adapter.list_session_files().unwrap();
+ refs.sort_by(|a, b| a.native_id.cmp(&b.native_id));
+ let ids: Vec<&str> = refs.iter().map(|r| r.native_id.as_str()).collect();
+ assert_eq!(ids, vec!["win-1", "win-1/explore-1"]);
+ let t = adapter.parse_transcript(&refs[0]).unwrap();
+ let texts: Vec<&str> = t.mainline.iter().map(|m| m.text.as_str()).collect();
+ assert_eq!(texts, vec!["主线的消息还是 NULL", "照样读得到。"]);
+ assert_eq!(t.meta.title, "主线的消息还是 NULL");
+ assert_eq!(t.meta.tokens_used, Some(5));
+ let lane = adapter.parse_transcript(&refs[1]).unwrap();
+ let texts: Vec<&str> = lane.mainline.iter().map(|m| m.text.as_str()).collect();
+ assert_eq!(texts, vec!["子代理那条道"]);
+}
+
+/// 自定义 location:选中库文件本身、数据目录、`MIMOCODE_HOME`(data/ 在里面)或 XDG data 根
+/// (mimocode/ 在里面)都落到同一个库;什么都没有就当数据目录本身
+#[test]
+fn mimo_code_custom_root_shapes() {
+ setup();
+ let dir = tempfile::tempdir().unwrap();
+ let home = dir.path().join("mimo-home");
+ let data = home.join("data");
+ fs::create_dir_all(&data).unwrap();
+ let db = data.join("mimocode.db");
+ common::build_mimo_db(&db);
+ for picked in [db.clone(), data.clone(), home] {
+ let adapter = MimoAdapter::new().with_custom_root(picked.clone());
+ assert_eq!(
+ adapter.data_roots(),
+ vec![db.clone()],
+ "{}",
+ picked.display()
+ );
+ assert_eq!(adapter.list_session_files().unwrap().len(), 11);
+ }
+ let share = dir.path().join("share");
+ let xdg_db = share.join("mimocode").join("mimocode.db");
+ fs::create_dir_all(xdg_db.parent().unwrap()).unwrap();
+ common::build_mimo_db(&xdg_db);
+ assert_eq!(
+ MimoAdapter::new().with_custom_root(share).data_roots(),
+ vec![xdg_db]
+ );
+ let empty = dir.path().join("nothing-here");
+ assert_eq!(
+ MimoAdapter::new()
+ .with_custom_root(empty.clone())
+ .data_roots(),
+ vec![empty.join("mimocode.db")]
+ );
+}
+
// ---------------------------------------------------------------- Kilo Code
const KILO_T1: &str = "1736400000000";
diff --git a/crates/wake-core/tests/common/mod.rs b/crates/wake-core/tests/common/mod.rs
index a0cf441..d868073 100644
--- a/crates/wake-core/tests/common/mod.rs
+++ b/crates/wake-core/tests/common/mod.rs
@@ -330,6 +330,7 @@ pub struct Sidecars {
/// Kilo Code 旧版扩展装在 VS Code / Cursor 里各自的任务目录
pub kilo_tasks: PathBuf,
pub kilo_cursor_tasks: PathBuf,
+ pub mimo_db: PathBuf,
}
/// 侧档与 SQLite 型 fixture 库:copilot/opencode(两代)/antigravity 现建库,
@@ -446,6 +447,11 @@ pub fn stage_sidecars(home: &Path) -> Sidecars {
let kilo_cursor_tasks = cursor_ide_dir.join("kilocode.kilo-code").join("tasks");
copy_tree(&fixture("kilo-legacy/Cursor/tasks"), &kilo_cursor_tasks);
+ let mimo_dir = home.join(".local").join("share").join("mimocode");
+ fs::create_dir_all(&mimo_dir).expect("mkdir mimocode data dir");
+ let mimo_db = mimo_dir.join("mimocode.db");
+ build_mimo_db(&mimo_db);
+
Sidecars {
copilot_db,
opencode_db,
@@ -461,6 +467,7 @@ pub fn stage_sidecars(home: &Path) -> Sidecars {
kilo_db,
kilo_tasks,
kilo_cursor_tasks,
+ mimo_db,
}
}
@@ -1241,6 +1248,7 @@ pub fn clear_agent_env_overrides() {
"WORKBUDDY_CONFIG_DIR",
"ZCODE_STORAGE_DIR",
"KIMI_CODE_HOME",
+ "MIMOCODE_HOME",
// 库路径的覆盖:指向现存文件时会被加进数据根,读到合成 HOME 之外的真实库
"OPENCODE_DB",
"KILO_DB",
@@ -1430,6 +1438,185 @@ pub fn build_devin_db(path: &Path) {
.expect("populate devin fixture db");
}
+/// MiMo Code `~/.local/share/mimocode/mimocode.db`(OpenCode 分支,列按源码 session.sql.ts 的
+/// 建表取子集):
+/// - `ses_mimo_0001`:主线(main 道);同会话的子代理 explore-1 写在自己的道上,是一条道子会话
+/// (`ses_mimo_0001/explore-1`,标题是派活时的 description),派它的工具调用跳到那里,派 peer
+/// 的跳到子会话;老版本留下的 checkpoint-writer-1 道是簿记、不列;一条带 provenance 的钩子消息、
+/// 一条检查点、一对压缩(compaction 标记 + summary 回复)
+/// - `ses_mimo_0002`:peer 子会话,消息写在以它自己的 id 命名的道上;它自己派的 explore-1 道没给
+/// description(等于 agent 类型名),标题退回收到的任务
+/// - `ses_mimo_0003`:checkpoint-writer 的宿主子会话(簿记,不列)
+/// - `ses_mimo_0004`:`ask:` 旁问的宿主子会话,消息在 build-1 道上(照列)
+/// - `ses_mimo_0005`:从 Claude Code 导入、没在 MiMo 里聊过(不列)
+/// - `ses_mimo_0006`:从 Codex 导入后在 MiMo 里接着聊过(照列,导入的两条折成一条)
+/// - `ses_mimo_0007`:message_ids 为空的老导入(分不清,不列)
+/// - `ses_mimo_0008`:0001 的 fork,复制来的(主线两条、子代理道一条)时间都早于它的创建时间
+/// - `ses_mimo_0009`:占位标题(title_source = fallback)
+/// - `ses_mimo_0010`:自动整理记忆的 "Auto Dream"
+/// - `ses_mimo_0011`:已归档,它的 explore-1 道跟着归档;`ses_mimo_0012`:没有正文(不列)
+///
+/// 另有 account 表与一行假凭证:真库就长这样,adapter 绝不读它
+pub fn build_mimo_db(path: &Path) {
+ let conn = rusqlite::Connection::open(path).expect("create mimo code fixture db");
+ conn.execute_batch(
+ r###"
+ CREATE TABLE session (
+ id TEXT PRIMARY KEY, project_id TEXT NOT NULL, workspace_id TEXT, parent_id TEXT,
+ context_from TEXT, context_watermark TEXT, slug TEXT NOT NULL, directory TEXT NOT NULL,
+ title TEXT NOT NULL, title_source TEXT NOT NULL DEFAULT 'user',
+ title_revision INTEGER NOT NULL DEFAULT 0, version TEXT NOT NULL,
+ time_created INTEGER NOT NULL, time_updated INTEGER NOT NULL,
+ time_compacting INTEGER, time_archived INTEGER
+ );
+ CREATE TABLE message (
+ id TEXT PRIMARY KEY, session_id TEXT NOT NULL, agent_id TEXT NOT NULL DEFAULT 'main',
+ time_created INTEGER NOT NULL, time_updated INTEGER NOT NULL, data TEXT NOT NULL
+ );
+ CREATE TABLE part (
+ id TEXT PRIMARY KEY, message_id TEXT NOT NULL, session_id TEXT NOT NULL,
+ time_created INTEGER NOT NULL, time_updated INTEGER NOT NULL, data TEXT NOT NULL
+ );
+ CREATE TABLE external_import (
+ source TEXT NOT NULL, source_key TEXT NOT NULL, session_id TEXT NOT NULL,
+ source_path TEXT NOT NULL, source_mtime INTEGER NOT NULL, time_imported INTEGER NOT NULL,
+ message_ids TEXT, PRIMARY KEY (source, source_key)
+ );
+ CREATE TABLE actor_registry (
+ session_id TEXT NOT NULL, actor_id TEXT NOT NULL, mode TEXT NOT NULL,
+ parent_actor_id TEXT, status TEXT NOT NULL, lifecycle TEXT NOT NULL, agent TEXT NOT NULL,
+ description TEXT NOT NULL, context_mode TEXT NOT NULL, background INTEGER NOT NULL,
+ last_turn_time INTEGER NOT NULL, turn_count INTEGER NOT NULL DEFAULT 0,
+ instance_id TEXT NOT NULL, time_created INTEGER NOT NULL, time_updated INTEGER NOT NULL,
+ PRIMARY KEY (session_id, actor_id)
+ );
+ CREATE TABLE account (
+ id TEXT PRIMARY KEY, email TEXT NOT NULL, url TEXT NOT NULL, access_token TEXT NOT NULL,
+ refresh_token TEXT NOT NULL, token_expiry INTEGER,
+ time_created INTEGER NOT NULL, time_updated INTEGER NOT NULL
+ );
+ INSERT INTO account VALUES
+ ('acc-1','[email protected]','https://mimo.xiaomi.com','NOT-A-REAL-TOKEN','NOT-A-REAL-REFRESH',NULL,0,0);
+
+ INSERT INTO session (id, project_id, parent_id, context_from, slug, directory, title,
+ title_source, version, time_created, time_updated, time_archived) VALUES
+ ('ses_mimo_0001','prj1',NULL,NULL,'brave-otter','/Users/tester/Github/wakefx','MiMo 二维码泄漏排查','generated','0.1.15',1790000000000,1790000080000,NULL),
+ ('ses_mimo_0002','prj1','ses_mimo_0001','ses_mimo_0001','calm-pine','/Users/tester/Github/wakefx','general: run the QR tests','user','0.1.15',1790000045000,1790000048000,NULL),
+ ('ses_mimo_0003','prj1','ses_mimo_0001',NULL,'quiet-lake','/Users/tester/Github/wakefx','checkpoint-writer: msg_m1_01..msg_m1_06','user','0.1.15',1790000061000,1790000062000,NULL),
+ ('ses_mimo_0004','prj1','ses_mimo_0001',NULL,'bold-reed','/Users/tester/Github/wakefx','ask: why does the scanner leak','user','0.1.15',1790000089000,1790000095000,NULL),
+ ('ses_mimo_0005','prj1',NULL,NULL,'old-fern','/Users/tester/Github/wakefx','Imported Claude session','user','claude-code',1789000000000,1789000005000,NULL),
+ ('ses_mimo_0006','prj1',NULL,NULL,'warm-sky','/Users/tester/Github/wakefx','Codex 那边问过的','user','codex',1789100000000,1790000105000,NULL),
+ ('ses_mimo_0007','prj1',NULL,NULL,'dry-moss','/Users/tester/Github/wakefx','老导入','user','claude-code',1789200000000,1790000110000,NULL),
+ ('ses_mimo_0008','prj1',NULL,NULL,'fast-hare','/Users/tester/Github/wakefx','MiMo 二维码泄漏排查 (fork #1)','user','0.1.15',1790001000000,1790001020000,NULL),
+ ('ses_mimo_0009','prj1',NULL,NULL,'new-moon','/Users/tester/Github/wakefx','Untitled','fallback','0.1.15',1790002000000,1790002005000,NULL),
+ ('ses_mimo_0010','prj1',NULL,NULL,'deep-dream','/Users/tester/Github/wakefx','Auto Dream','user','0.1.15',1790003000000,1790003005000,NULL),
+ ('ses_mimo_0011','prj1',NULL,NULL,'gray-owl','/Users/tester/Github/wakefx','Archived MiMo session','user','0.1.15',1790004000000,1790004001000,1790005000000),
+ ('ses_mimo_0012','prj1',NULL,NULL,'empty-sky','/Users/tester/Github/wakefx','Untitled','fallback','0.1.15',1790006000000,1790006000000,NULL);
+
+ INSERT INTO actor_registry (session_id, actor_id, mode, parent_actor_id, status, lifecycle,
+ agent, description, context_mode, background, last_turn_time,
+ instance_id, time_created, time_updated) VALUES
+ ('ses_mimo_0001','explore-1','subagent',NULL,'idle','ephemeral','explore','find the QR hook','none',0,1790000030000,'i1',1790000015000,1790000030000),
+ ('ses_mimo_0001','checkpoint-writer-1','subagent',NULL,'idle','ephemeral','checkpoint-writer','checkpoint writer','full',1,1790000065000,'i1',1790000065000,1790000065000),
+ ('ses_mimo_0002','ses_mimo_0002','peer',NULL,'idle','persistent','general','run the QR tests','full',0,1790000048000,'i1',1790000045000,1790000048000),
+ ('ses_mimo_0002','explore-1','subagent',NULL,'idle','ephemeral','explore','explore','none',0,1790000047000,'i1',1790000046400,1790000047000),
+ ('ses_mimo_0011','explore-1','subagent',NULL,'idle','ephemeral','explore','look around','none',0,1790004000500,'i1',1790004000400,1790004000500),
+ ('ses_mimo_0003','checkpoint-writer-1','subagent',NULL,'idle','ephemeral','checkpoint-writer','checkpoint writer','full',1,1790000062000,'i1',1790000061000,1790000062000),
+ ('ses_mimo_0004','build-1','subagent',NULL,'idle','ephemeral','build','fork-query','full',0,1790000095000,'i1',1790000089000,1790000095000);
+
+ INSERT INTO external_import VALUES
+ ('cc','55555555-aaaa-bbbb-cccc-000000000005','ses_mimo_0005','/Users/tester/.claude/projects/-Users-tester-Github-wakefx/55555555-aaaa-bbbb-cccc-000000000005.jsonl',1,1790000000000,'["msg_m5_01","msg_m5_02"]'),
+ ('codex','66666666-aaaa-bbbb-cccc-000000000006','ses_mimo_0006','/Users/tester/.codex/sessions/2026/09/01/rollout-2026-09-01T09-00-00-66666666-aaaa-bbbb-cccc-000000000006.jsonl',1,1790000000000,'["msg_m6_01","msg_m6_02"]'),
+ ('cc','77777777-aaaa-bbbb-cccc-000000000007','ses_mimo_0007','/Users/tester/.claude/projects/-Users-tester-Github-wakefx/77777777-aaaa-bbbb-cccc-000000000007.jsonl',1,1789200000000,NULL);
+
+ INSERT INTO message (id, session_id, agent_id, time_created, time_updated, data) VALUES
+ ('msg_m1_01','ses_mimo_0001','main',1790000010000,1790000010000,'{"role":"user","time":{"created":1790000010000},"agent":"build","model":{"providerID":"xiaomi","modelID":"mimo-v2.5-pro"}}'),
+ ('msg_m1_02','ses_mimo_0001','explore-1',1790000020000,1790000020000,'{"role":"user","time":{"created":1790000020000},"agent":"explore","model":{"providerID":"xiaomi","modelID":"mimo-v2.5-flash"}}'),
+ ('msg_m1_03','ses_mimo_0001','explore-1',1790000030000,1790000030000,'{"role":"assistant","time":{"created":1790000030000},"parentID":"msg_m1_02","modelID":"mimo-v2.5-flash","providerID":"xiaomi","mode":"explore","agent":"explore","cost":0,"tokens":{"input":30,"output":5,"reasoning":0,"cache":{"read":0,"write":0}}}'),
+ ('msg_m1_04','ses_mimo_0001','main',1790000035000,1790000039000,'{"role":"assistant","time":{"created":1790000035000,"completed":1790000039000},"parentID":"msg_m1_01","modelID":"mimo-v2.5-pro","providerID":"xiaomi","mode":"build","agent":"build","cost":0,"tokens":{"input":100,"output":40,"reasoning":10,"cache":{"read":500,"write":0}}}'),
+ ('msg_m1_05','ses_mimo_0001','main',1790000040000,1790000040000,'{"role":"user","time":{"created":1790000040000},"agent":"build","model":{"providerID":"xiaomi","modelID":"mimo-v2.5-pro"},"provenance":{"hookPhase":"post","hookIteration":0,"pluginNames":["lint-gate"],"hookIDs":["h1"]}}'),
+ ('msg_m1_06','ses_mimo_0001','main',1790000050000,1790000050000,'{"role":"assistant","time":{"created":1790000050000},"parentID":"msg_m1_05","modelID":"mimo-v2.5-pro","providerID":"xiaomi","mode":"build","agent":"build","cost":0,"tokens":{"input":20,"output":5,"reasoning":0,"cache":{"read":0,"write":0}}}'),
+ ('msg_m1_07','ses_mimo_0001','main',1790000060000,1790000060000,'{"role":"user","time":{"created":1790000060000},"agent":"build","model":{"providerID":"xiaomi","modelID":"mimo-v2.5-pro"}}'),
+ ('msg_m1_08','ses_mimo_0001','main',1790000070000,1790000070000,'{"role":"user","time":{"created":1790000070000},"agent":"build","model":{"providerID":"xiaomi","modelID":"mimo-v2.5-pro"}}'),
+ ('msg_m1_09','ses_mimo_0001','main',1790000080000,1790000080000,'{"role":"assistant","time":{"created":1790000080000},"parentID":"msg_m1_08","modelID":"mimo-v2.5-pro","providerID":"xiaomi","mode":"compaction","agent":"compaction","summary":true,"cost":0,"tokens":{"input":10,"output":10,"reasoning":0,"cache":{"read":0,"write":0}}}'),
+ ('msg_m2_01','ses_mimo_0002','ses_mimo_0002',1790000046000,1790000046000,'{"role":"user","time":{"created":1790000046000},"agent":"general","model":{"providerID":"xiaomi","modelID":"mimo-v2.5-flash"}}'),
+ ('msg_m2_02','ses_mimo_0002','ses_mimo_0002',1790000048000,1790000048000,'{"role":"assistant","time":{"created":1790000048000},"parentID":"msg_m2_01","modelID":"mimo-v2.5-flash","providerID":"xiaomi","mode":"general","agent":"general","cost":0,"tokens":{"input":12,"output":3,"reasoning":0,"cache":{"read":0,"write":0}}}'),
+ ('msg_m2_03','ses_mimo_0002','explore-1',1790000046500,1790000046500,'{"role":"user","time":{"created":1790000046500},"agent":"explore","model":{"providerID":"xiaomi","modelID":"mimo-v2.5-flash"}}'),
+ ('msg_m2_04','ses_mimo_0002','explore-1',1790000047000,1790000047000,'{"role":"assistant","time":{"created":1790000047000},"modelID":"mimo-v2.5-flash","tokens":{"input":4,"output":1,"reasoning":0,"cache":{"read":0,"write":0}}}'),
+ ('msg_m1_0w','ses_mimo_0001','checkpoint-writer-1',1790000065000,1790000065000,'{"role":"user","time":{"created":1790000065000},"agent":"checkpoint-writer","model":{"providerID":"xiaomi","modelID":"mimo-v2.5-pro"}}'),
+ ('msg_m11_02','ses_mimo_0011','explore-1',1790004000500,1790004000500,'{"role":"user","time":{"created":1790004000500},"agent":"explore","model":{"providerID":"xiaomi","modelID":"mimo-v2.5-flash"}}'),
+ ('msg_m3_01','ses_mimo_0003','checkpoint-writer-1',1790000061000,1790000061000,'{"role":"user","time":{"created":1790000061000},"agent":"checkpoint-writer","model":{"providerID":"xiaomi","modelID":"mimo-v2.5-pro"}}'),
+ ('msg_m3_02','ses_mimo_0003','checkpoint-writer-1',1790000062000,1790000062000,'{"role":"assistant","time":{"created":1790000062000},"modelID":"mimo-v2.5-pro","tokens":{"input":50,"output":20,"reasoning":0,"cache":{"read":0,"write":0}}}'),
+ ('msg_m4_01','ses_mimo_0004','build-1',1790000090000,1790000090000,'{"role":"user","time":{"created":1790000090000},"agent":"build","model":{"providerID":"xiaomi","modelID":"mimo-v2.5-pro"}}'),
+ ('msg_m4_02','ses_mimo_0004','build-1',1790000095000,1790000095000,'{"role":"assistant","time":{"created":1790000095000},"parentID":"msg_m4_01","modelID":"mimo-v2.5-pro","tokens":{"input":9,"output":1,"reasoning":0,"cache":{"read":0,"write":0}}}'),
+ ('msg_m5_01','ses_mimo_0005','main',1789000000000,1789000000000,'{"role":"user","time":{"created":1789000000000},"agent":"build","model":{"providerID":"anthropic","modelID":"claude-opus-5-5"}}'),
+ ('msg_m5_02','ses_mimo_0005','main',1789000005000,1789000005000,'{"role":"assistant","time":{"created":1789000005000},"modelID":"claude-opus-5-5","tokens":{"input":80,"output":20,"reasoning":0,"cache":{"read":0,"write":0}}}'),
+ ('msg_m6_01','ses_mimo_0006','main',1789100000000,1789100000000,'{"role":"user","time":{"created":1789100000000},"agent":"build","model":{"providerID":"openai","modelID":"gpt-5.5"}}'),
+ ('msg_m6_02','ses_mimo_0006','main',1789100005000,1789100005000,'{"role":"assistant","time":{"created":1789100005000},"modelID":"gpt-5.5","tokens":{"input":100,"output":0,"reasoning":0,"cache":{"read":0,"write":0}}}'),
+ ('msg_m6_03','ses_mimo_0006','main',1790000100000,1790000100000,'{"role":"user","time":{"created":1790000100000},"agent":"build","model":{"providerID":"xiaomi","modelID":"mimo-v2.5-pro"}}'),
+ ('msg_m6_04','ses_mimo_0006','main',1790000105000,1790000105000,'{"role":"assistant","time":{"created":1790000105000},"modelID":"mimo-v2.5-pro","tokens":{"input":6,"output":2,"reasoning":0,"cache":{"read":0,"write":0}}}'),
+ ('msg_m7_01','ses_mimo_0007','main',1789200000000,1789200000000,'{"role":"user","time":{"created":1789200000000},"agent":"build","model":{"providerID":"anthropic","modelID":"claude-opus-5-5"}}'),
+ ('msg_m7_02','ses_mimo_0007','main',1790000110000,1790000110000,'{"role":"user","time":{"created":1790000110000},"agent":"build","model":{"providerID":"xiaomi","modelID":"mimo-v2.5-pro"}}'),
+ ('msg_m8_01','ses_mimo_0008','main',1790000010000,1790000010000,'{"role":"user","time":{"created":1790000010000},"agent":"build","model":{"providerID":"xiaomi","modelID":"mimo-v2.5-pro"}}'),
+ ('msg_m8_02','ses_mimo_0008','main',1790000035000,1790000035000,'{"role":"assistant","time":{"created":1790000035000},"modelID":"mimo-v2.5-pro","tokens":{"input":100,"output":40,"reasoning":10,"cache":{"read":0,"write":0}}}'),
+ ('msg_m8_0x','ses_mimo_0008','explore-1',1790000030000,1790000030000,'{"role":"assistant","time":{"created":1790000030000},"modelID":"mimo-v2.5-flash","tokens":{"input":30,"output":5,"reasoning":0,"cache":{"read":0,"write":0}}}'),
+ ('msg_m8_03','ses_mimo_0008','main',1790001010000,1790001010000,'{"role":"user","time":{"created":1790001010000},"agent":"build","model":{"providerID":"xiaomi","modelID":"mimo-v2.5-flash"}}'),
+ ('msg_m8_04','ses_mimo_0008','main',1790001020000,1790001020000,'{"role":"assistant","time":{"created":1790001020000},"modelID":"mimo-v2.5-flash","tokens":{"input":5,"output":2,"reasoning":0,"cache":{"read":0,"write":0}}}'),
+ ('msg_m9_01','ses_mimo_0009','main',1790002001000,1790002001000,'{"role":"user","time":{"created":1790002001000},"agent":"build","model":{"providerID":"xiaomi","modelID":"mimo-v2.5-pro"}}'),
+ ('msg_m9_02','ses_mimo_0009','main',1790002005000,1790002005000,'{"role":"assistant","time":{"created":1790002005000},"modelID":"mimo-v2.5-pro","tokens":{"input":3,"output":1,"reasoning":0,"cache":{"read":0,"write":0}}}'),
+ ('msg_m10_01','ses_mimo_0010','main',1790003000000,1790003000000,'{"role":"user","time":{"created":1790003000000},"agent":"dream","model":{"providerID":"xiaomi","modelID":"mimo-v2.5-pro"}}'),
+ ('msg_m10_02','ses_mimo_0010','main',1790003005000,1790003005000,'{"role":"assistant","time":{"created":1790003005000},"modelID":"mimo-v2.5-pro","agent":"dream","tokens":{"input":40,"output":10,"reasoning":0,"cache":{"read":0,"write":0}}}'),
+ ('msg_m11_01','ses_mimo_0011','main',1790004000000,1790004000000,'{"role":"user","time":{"created":1790004000000},"agent":"build","model":{"providerID":"xiaomi","modelID":"mimo-v2.5-pro"}}');
+
+ INSERT INTO part (id, message_id, session_id, time_created, time_updated, data) VALUES
+ ('prt_m1_01a','msg_m1_01','ses_mimo_0001',1790000010000,1790000010000,'{"type":"text","text":"MiMo 修一下二维码扫描的 useEffect() 泄漏"}'),
+ ('prt_m1_02a','msg_m1_02','ses_mimo_0001',1790000020000,1790000020000,'{"type":"text","text":"grep the scanner for useEffect"}'),
+ ('prt_m1_03a','msg_m1_03','ses_mimo_0001',1790000030000,1790000030000,'{"type":"text","text":"src/QrScanner.tsx:42 useEffect(() => {"}'),
+ ('prt_m1_04a','msg_m1_04','ses_mimo_0001',1790000035000,1790000035000,'{"type":"step-start"}'),
+ ('prt_m1_04b','msg_m1_04','ses_mimo_0001',1790000035000,1790000035000,'{"type":"reasoning","text":"先看清理函数"}'),
+ ('prt_m1_04c','msg_m1_04','ses_mimo_0001',1790000036000,1790000038000,'{"type":"tool","callID":"call_1","tool":"actor","state":{"status":"completed","input":{"op":"spawn","agent":"explore","task":"grep the scanner for useEffect"},"output":"explore-1 finished","title":"actor","metadata":{"sessionId":"ses_mimo_0001","actorId":"explore-1","model":"mimo-v2.5-flash"}}}'),
+ ('prt_m1_04d','msg_m1_04','ses_mimo_0001',1790000039000,1790000039000,'{"type":"text","text":"找到了:卸载时没有停止扫描。"}'),
+ ('prt_m1_04e','msg_m1_04','ses_mimo_0001',1790000039000,1790000039000,'{"type":"step-finish","reason":"stop","tokens":{"input":100,"output":40,"reasoning":10,"cache":{"read":500,"write":0}}}'),
+ ('prt_m1_05a','msg_m1_05','ses_mimo_0001',1790000040000,1790000040000,'{"type":"text","text":"lint-gate: 2 warnings in src/QrScanner.tsx"}'),
+ ('prt_m1_06a','msg_m1_06','ses_mimo_0001',1790000050000,1790000050000,'{"type":"tool","callID":"call_2","tool":"actor","state":{"status":"completed","input":{"op":"spawn","mode":"peer","agent":"general","task":"run the QR tests"},"output":"spawned ses_mimo_0002","title":"actor","metadata":{"sessionId":"ses_mimo_0002","actorId":"ses_mimo_0002"}}}'),
+ ('prt_m1_06b','msg_m1_06','ses_mimo_0001',1790000050000,1790000050000,'{"type":"text","text":"派了一个 peer 去跑测试。"}'),
+ ('prt_m1_07a','msg_m1_07','ses_mimo_0001',1790000060000,1790000060000,'{"type":"checkpoint","checkpointDir":"","checkpointNumber":0,"coveredUpTo":"msg_m1_06"}'),
+ ('prt_m1_07b','msg_m1_07','ses_mimo_0001',1790000060000,1790000060000,'{"type":"text","synthetic":true,"text":"## Recent activity\n- fixed the QR leak"}'),
+ ('prt_m1_08a','msg_m1_08','ses_mimo_0001',1790000070000,1790000070000,'{"type":"compaction","auto":true}'),
+ ('prt_m1_09a','msg_m1_09','ses_mimo_0001',1790000080000,1790000080000,'{"type":"text","text":"Summary of the QR work so far."}'),
+ ('prt_m2_01a','msg_m2_01','ses_mimo_0002',1790000046000,1790000046000,'{"type":"text","text":"run the QR tests"}'),
+ ('prt_m2_02a','msg_m2_02','ses_mimo_0002',1790000048000,1790000048000,'{"type":"text","text":"All QR tests pass."}'),
+ ('prt_m2_03a','msg_m2_03','ses_mimo_0002',1790000046500,1790000046500,'{"type":"text","text":"list the QR test files"}'),
+ ('prt_m2_04a','msg_m2_04','ses_mimo_0002',1790000047000,1790000047000,'{"type":"text","text":"tests/qr.test.ts"}'),
+ ('prt_m1_0wa','msg_m1_0w','ses_mimo_0001',1790000065000,1790000065000,'{"type":"text","text":"Write the checkpoint for msg_m1_01..msg_m1_06"}'),
+ ('prt_m11_02a','msg_m11_02','ses_mimo_0011',1790004000500,1790004000500,'{"type":"text","text":"look around the archived repo"}'),
+ ('prt_m3_01a','msg_m3_01','ses_mimo_0003',1790000061000,1790000061000,'{"type":"text","text":"Write the checkpoint for msg_m1_01..msg_m1_06"}'),
+ ('prt_m3_02a','msg_m3_02','ses_mimo_0003',1790000062000,1790000062000,'{"type":"text","text":"checkpoint written"}'),
+ ('prt_m4_01a','msg_m4_01','ses_mimo_0004',1790000090000,1790000090000,'{"type":"text","text":"why does the scanner leak?"}'),
+ ('prt_m4_02a','msg_m4_02','ses_mimo_0004',1790000095000,1790000095000,'{"type":"text","text":"Because the cleanup never stops the camera."}'),
+ ('prt_m5_01a','msg_m5_01','ses_mimo_0005',1789000000000,1789000000000,'{"type":"text","text":"Claude 那边的提问"}'),
+ ('prt_m5_02a','msg_m5_02','ses_mimo_0005',1789000005000,1789000005000,'{"type":"text","text":"Claude 那边的回答"}'),
+ ('prt_m6_01a','msg_m6_01','ses_mimo_0006',1789100000000,1789100000000,'{"type":"text","text":"Codex 那边的提问"}'),
+ ('prt_m6_02a','msg_m6_02','ses_mimo_0006',1789100005000,1789100005000,'{"type":"text","text":"Codex 那边的回答"}'),
+ ('prt_m6_03a','msg_m6_03','ses_mimo_0006',1790000100000,1790000100000,'{"type":"text","text":"在 MiMo 里接着问"}'),
+ ('prt_m6_04a','msg_m6_04','ses_mimo_0006',1790000105000,1790000105000,'{"type":"text","text":"接着答"}'),
+ ('prt_m7_01a','msg_m7_01','ses_mimo_0007',1789200000000,1789200000000,'{"type":"text","text":"老版本导入的"}'),
+ ('prt_m7_02a','msg_m7_02','ses_mimo_0007',1790000110000,1790000110000,'{"type":"text","text":"后来接着问的"}'),
+ ('prt_m8_01a','msg_m8_01','ses_mimo_0008',1790000010000,1790000010000,'{"type":"text","text":"MiMo 修一下二维码扫描的 useEffect() 泄漏"}'),
+ ('prt_m8_02a','msg_m8_02','ses_mimo_0008',1790000035000,1790000035000,'{"type":"text","text":"找到了:卸载时没有停止扫描。"}'),
+ ('prt_m8_0xa','msg_m8_0x','ses_mimo_0008',1790000030000,1790000030000,'{"type":"text","text":"src/QrScanner.tsx:42 useEffect(() => {"}'),
+ ('prt_m8_03a','msg_m8_03','ses_mimo_0008',1790001010000,1790001010000,'{"type":"text","text":"fork 之后的问题"}'),
+ ('prt_m8_04a','msg_m8_04','ses_mimo_0008',1790001020000,1790001020000,'{"type":"text","text":"fork 之后的回答"}'),
+ ('prt_m9_01a','msg_m9_01','ses_mimo_0009',1790002001000,1790002001000,'{"type":"text","text":"占位标题取这句"}'),
+ ('prt_m9_02a','msg_m9_02','ses_mimo_0009',1790002005000,1790002005000,'{"type":"text","text":"好。"}'),
+ ('prt_m10_01a','msg_m10_01','ses_mimo_0010',1790003000000,1790003000000,'{"type":"text","synthetic":true,"text":"Run one automatic dream memory consolidation pass for the current project."}'),
+ ('prt_m10_02a','msg_m10_02','ses_mimo_0010',1790003005000,1790003005000,'{"type":"text","text":"Consolidated 3 memories."}'),
+ ('prt_m11_01a','msg_m11_01','ses_mimo_0011',1790004000000,1790004000000,'{"type":"text","text":"an archived question"}');
+ "###,
+ )
+ .expect("populate mimo code fixture db");
+}
+
/// 以某种身份持住索引锁,拿不到就 panic 点名——各测试文件里"扮演 GUI / 另一个
/// wake-cli"的同一句
pub fn lock_as(db: &Path, kind: &str) -> IndexLock {
diff --git a/crates/wake-core/tests/scanner_finale.rs b/crates/wake-core/tests/scanner_finale.rs
index 9d65d15..70f934e 100644
--- a/crates/wake-core/tests/scanner_finale.rs
+++ b/crates/wake-core/tests/scanner_finale.rs
@@ -1644,6 +1644,34 @@ fn dsh_subagents_nest_under_the_session_that_started_them() {
assert_eq!(store.child_counts(&filter).unwrap().get(parent), Some(&1));
}
+/// MiMo Code 同会话子代理的道是子会话:父会话写在 id 里,停在直接父会话上——peer 子会话自己派的
+/// 道挂在 peer 子会话下、不往上压到根(peer 子会话经 parent_id 挂在根下);顶层只有根
+#[test]
+fn mimo_code_lanes_nest_under_the_session_they_run_in() {
+ use wake_core::adapters::mimo::MimoAdapter;
+ let data = tempfile::tempdir().unwrap();
+ common::build_mimo_db(&data.path().join("mimocode.db"));
+ let adapters: Vec<Box<dyn AgentAdapter>> =
+ vec![MimoAdapter::new().with_custom_root(data.path().to_path_buf())];
+ let dir = tempfile::tempdir().unwrap();
+ let store = temp_store(dir.path());
+ run_scan(&adapters, &store, &Recorder::new(), true).unwrap();
+
+ let key = |id: &str| format!("mimo-code:{id}");
+ let parent = |id: &str| store.parent_key_of(&key(id)).unwrap();
+ assert_eq!(parent("ses_mimo_0001"), None);
+ assert_eq!(
+ parent("ses_mimo_0001/explore-1"),
+ Some(key("ses_mimo_0001"))
+ );
+ assert_eq!(parent("ses_mimo_0002"), Some(key("ses_mimo_0001")));
+ assert_eq!(
+ parent("ses_mimo_0002/explore-1"),
+ Some(key("ses_mimo_0002")),
+ "peer 子会话派的道停在 peer 子会话上"
+ );
+}
+
/// Kimi 分叉:关系写在子会话自己的 state.json(`forkedFrom`),全量扫描后子会话挂在父会话
/// 下面;state.json 的 archived 照搬进索引
#[test]
diff --git a/crates/wake/assets/brands/mimo-code-light.png b/crates/wake/assets/brands/mimo-code-light.png
new file mode 100644
index 0000000..dca4283
Binary files /dev/null and b/crates/wake/assets/brands/mimo-code-light.png differ
diff --git a/crates/wake/assets/brands/mimo-code.png b/crates/wake/assets/brands/mimo-code.png
new file mode 100644
index 0000000..8d6bd3f
Binary files /dev/null and b/crates/wake/assets/brands/mimo-code.png differ
diff --git a/crates/wake/src/assets.rs b/crates/wake/src/assets.rs
index 3c8e89e..927ead0 100644
--- a/crates/wake/src/assets.rs
+++ b/crates/wake/src/assets.rs
@@ -68,6 +68,8 @@ brands!(
"kilo",
"kilo-light",
"grok-bot",
+ "mimo-code",
+ "mimo-code-light",
);
fn lookup_product(path: &str) -> Option<&'static [u8]> {
diff --git a/crates/wake/src/theme.rs b/crates/wake/src/theme.rs
index 11d98d5..e31a999 100644
--- a/crates/wake/src/theme.rs
+++ b/crates/wake/src/theme.rs
@@ -126,6 +126,9 @@ pub fn agent_series_color(agent: wake_core::models::AgentId) -> u32 {
// 品牌是黑白的,色板里已有两档灰(Grok Build、ZCode),再加一档分不出来;给离全部现有
// 颜色最远的一档深莓红(最近的 Kimi 粉 ΔE00 19.9)
GrokBot => 0xAC396D,
+ // 标志是单色字标,MiMo Code 的横幅把 "MIMO" 涂成橙色:取小米标准橙,离 Claude 橙 ΔE00
+ // 11.7(Kilo 那档离 Hermes 11.9),比横幅原色(离 Claude 8.7)分得开
+ MimoCode => 0xFF6900,
}
}
diff --git a/docs/cli.md b/docs/cli.md
index 4e91461..27cbccd 100644
--- a/docs/cli.md
+++ b/docs/cli.md
@@ -394,7 +394,7 @@ Numeric options outside their range are clamped, not rejected: `--limit 999` on
## Agent ids
-`claude-code`, `codex`, `grok`, `grok-bot`, `dsh`, `cursor`, `opencode`, `pi`, `omp`, `kiro`, `kimi`, `gemini`, `copilot`, `antigravity`, `qoder`, `hermes`, `openclaw`, `codebuddy`, `workbuddy`, `zcode`, `craft-agents`, `devin`, `kilo`. Display names (`"Claude Code"`) and a few aliases (`claude`, `deepseek`, `craft`) work too.
+`claude-code`, `codex`, `grok`, `grok-bot`, `dsh`, `cursor`, `opencode`, `pi`, `omp`, `kiro`, `kimi`, `gemini`, `copilot`, `antigravity`, `qoder`, `hermes`, `openclaw`, `codebuddy`, `workbuddy`, `zcode`, `craft-agents`, `devin`, `kilo`, `mimo-code`. Display names (`"Claude Code"`) and a few aliases (`claude`, `deepseek`, `craft`, `mimo`) work too.
## Session keys and references
diff --git a/docs/mcp.md b/docs/mcp.md
index 14ab610..84b4232 100644
--- a/docs/mcp.md
+++ b/docs/mcp.md
@@ -174,7 +174,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) — your home folder and the filesystem root never count here, since sessions started there are not about the project you are in; 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`, `grok-bot`, `dsh`, `cursor`, `opencode`, `pi`, `omp`, `kiro`, `kimi`, `gemini`, `copilot`, `antigravity`, `qoder`, `hermes`, `openclaw`, `codebuddy`, `workbuddy`, `zcode`, `craft-agents`, `devin`, `kilo`. Display names (`"Claude Code"`, `"Gemini CLI"`) and a few aliases (`claude`, `deepseek`, `opencode2`, `craft`) are accepted too. |
+| `agents` | string[] | Only these agents. Ids: `claude-code`, `codex`, `grok`, `grok-bot`, `dsh`, `cursor`, `opencode`, `pi`, `omp`, `kiro`, `kimi`, `gemini`, `copilot`, `antigravity`, `qoder`, `hermes`, `openclaw`, `codebuddy`, `workbuddy`, `zcode`, `craft-agents`, `devin`, `kilo`, `mimo-code`. Display names (`"Claude Code"`, `"Gemini CLI"`) and a few aliases (`claude`, `deepseek`, `opencode2`, `craft`, `mimo`) 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. |