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: add Hermes Agent and OpenClaw adapters

Corey Chiu052f7d3baeb8
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 26bc22e..0a493cf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
## Unreleased
+- New: Hermes Agent sessions — Wake reads `~/.hermes/state.db` (and every `profiles/*/state.db`), including tool calls, reasoning and the channel a session came from; `HERMES_HOME` is respected
+- New: OpenClaw sessions — both the current per-agent SQLite store and legacy `sessions/*.jsonl` transcripts are scanned, showing only the active branch of each conversation; `OPENCLAW_STATE_DIR` is respected
+- Update: remote hosts mirror Hermes session databases and OpenClaw legacy transcripts too — OpenClaw's SQLite store stays on the remote machine because it also holds credentials
+
## [0.4.0] — 2026-09-03
- New: remote hosts — mirror agent sessions from other machines over SSH into the index. Add a host in Settings → Remote hosts (an alias from `~/.ssh/config` or `user@host`); sessions sync on launch, refresh, and Sync now, then browse and search them alongside local ones with an `@host` badge
diff --git a/PRODUCT.md b/PRODUCT.md
index 365cfb7..fe688bf 100644
--- a/PRODUCT.md
+++ b/PRODUCT.md
@@ -28,9 +28,9 @@ Corey 本人(独立开发者,主力工具 Claude Code 与 Codex,中文为主)。
## Capabilities and Constraints
-已实现:十四家 adapter、FTS5 trigram 搜索(<3 码点 LIKE 降级)、**搜索跳转定位**(2026-08-18:⌘K 命中直达详情页对应消息并高亮,seq 契约保证)、详情页逐消息渲染(气泡/工具折叠簇/thinking/tree-sitter 高亮;2026-08-17 由整篇 markdown 方案升级)、恢复/收藏/置顶/导出/删除(废纸篓+墓碑)、文件监听增量、Insights 统计页(0.3.0:活跃热力图与 streak、时段/星期/月份分布、Agents·Projects·Models 三榜单按 sessions/tokens/prompts 切换;口径=主线用户消息,规格见 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」节)。
+已实现:十六家 adapter、FTS5 trigram 搜索(<3 码点 LIKE 降级)、**搜索跳转定位**(2026-08-18:⌘K 命中直达详情页对应消息并高亮,seq 契约保证)、详情页逐消息渲染(气泡/工具折叠簇/thinking/tree-sitter 高亮;2026-08-17 由整篇 markdown 方案升级)、恢复/收藏/置顶/导出/删除(废纸篓+墓碑)、文件监听增量、Insights 统计页(0.3.0:活跃热力图与 streak、时段/星期/月份分布、Agents·Projects·Models 三榜单按 sessions/tokens/prompts 切换;口径=主线用户消息,规格见 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」节)。
约束:对 agent 数据目录只读;绝不写 Codex 的 SQLite;不读凭证;GPUI 无 SF Symbols(图标用 lucide SVG 自备)。
-已支持十四家 agent:Claude Code、Codex、Qoder CLI(`~/.qoder/projects` JSONL,active-leaf 分支恢复、tool result 回挂、`QODER_CONFIG_DIR`)、Copilot CLI、Cursor(CLI transcripts)、OpenCode(含 OpenCode 2 next,stable 的 `opencode.db` 与 next 的 `opencode-next.db` 同时扫描;逐会话兼容 `message+part`、真实 `session+session_message` 及早期 `session_v2` schema;preview 会话标 opencode2 徽章)、Kiro、Gemini CLI(2026-08-17 P1 五家落地)+ Pi、Oh My Pi、Grok Build、Kimi Code、Antigravity CLI(2026-08-19 对齐 kooky 内置 roster;Antigravity 正文加密仅元数据卡片)+ DeepSeek Harness(dsh,2026-08-20,zstd 事件日志透明解压;格式由源码推断,当天用户跑出真实会话完成首验)。做不了的:Cursor IDE chats 正文加密,Windsurf/Trae 加密,Amp/Factory(Droid)/Warp 云端无本地数据,Reasonix 本机零会话格式未实测。
+已支持十六家 agent:Claude Code、Codex、Qoder CLI(`~/.qoder/projects` JSONL,active-leaf 分支恢复、tool result 回挂、`QODER_CONFIG_DIR`)、Copilot CLI、Cursor(CLI transcripts)、OpenCode(含 OpenCode 2 next,stable 的 `opencode.db` 与 next 的 `opencode-next.db` 同时扫描;逐会话兼容 `message+part`、真实 `session+session_message` 及早期 `session_v2` schema;preview 会话标 opencode2 徽章)、Kiro、Gemini CLI(2026-08-17 P1 五家落地)+ Pi、Oh My Pi、Grok Build、Kimi Code、Antigravity CLI(2026-08-19 对齐 kooky 内置 roster;Antigravity 正文加密仅元数据卡片)+ DeepSeek Harness(dsh,2026-08-20,zstd 事件日志透明解压;格式由源码推断,当天用户跑出真实会话完成首验)。做不了的:Cursor IDE chats 正文加密,Windsurf/Trae 加密,Amp/Factory(Droid)/Warp 云端无本地数据,Reasonix 本机零会话格式未实测。
## Brand Commitments
diff --git a/README.md b/README.md
index 660cf65..99db7d6 100644
--- a/README.md
+++ b/README.md
@@ -44,8 +44,10 @@ Your agent history is scattered across `~/.claude`, `~/.codex`, and a dozen othe
| Kimi Code | `~/.kimi-code/sessions/**/wire.jsonl` | — | — |
| Antigravity CLI | `~/.gemini/antigravity-cli/conversation_summaries.db` (metadata only — transcripts are encrypted) | — | — |
| DeepSeek Harness (`dsh`) | `~/.dsh/sessions/**/session.jsonl[.zstd]` (zstd-compressed logs are decoded transparently) | ✅ | — |
+| Hermes Agent | `~/.hermes/state.db` + `profiles/*/state.db` (`HERMES_HOME` is respected) | ✅ | ✅ |
+| OpenClaw | `~/.openclaw/agents/*/agent/openclaw-agent.sqlite` + legacy `agents/*/sessions/*.jsonl` (`OPENCLAW_STATE_DIR` is respected) | ✅ | ✅ |
-**Model** = whether Wake shows which LLM a session used (the model the session last used). **Via** = whether Wake shows where the session was started from (CLI, IDE extension, desktop app) — only Codex records this in its local data. A "—" means the agent's local data simply doesn't record that field, not a missing feature.
+**Model** = whether Wake shows which LLM a session used (the model the session last used). **Via** = whether Wake shows where the session was started from (CLI, IDE extension, desktop app) — Codex records this in its local data; Hermes and OpenClaw record the channel a session came in through (Telegram, Discord, …). A "—" means the agent's local data simply doesn't record that field, not a missing feature.
Cursor IDE chats, Windsurf, and Trae encrypt their local data; Amp, Factory (Droid), and Warp keep sessions in the cloud — none of those are supported. Reasonix stores sessions locally but hasn't been mapped yet.
@@ -138,7 +140,7 @@ CI runs `cargo test -p wake-core` plus a full app build on every push to main an
```
crates/
├── wake-core # pure data layer, no UI dependencies
-│ ├── adapters/ # claude / codex / qoder / copilot / cursor / opencode / kiro
+│ ├── adapters/ # claude / codex / qoder / copilot / cursor / opencode / kiro / hermes / openclaw
│ │ # gemini / pi / omp / grok / kimi / antigravity / dsh
│ │ # (AgentAdapter trait — add an adapter, get the whole UI for free;
│ │ # remote.rs wraps any adapter over a synced cache for remote hosts)
diff --git a/crates/wake-core/src/adapters/hermes.rs b/crates/wake-core/src/adapters/hermes.rs
new file mode 100644
index 0000000..738a4f5
--- /dev/null
+++ b/crates/wake-core/src/adapters/hermes.rs
@@ -0,0 +1,551 @@
+use super::parse_utils::*;
+use super::sqlite_ro::{open_sqlite_ro, strip_virtual_path, virtual_path, SqliteRo};
+use super::{units_from_messages, AgentAdapter};
+use crate::models::*;
+use anyhow::{anyhow, Result};
+use serde_json::Value;
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+use std::sync::OnceLock;
+
+/// Hermes Agent(Nous Research):`~/.hermes/state.db` 全明文 SQLite
+/// (`HERMES_HOME` 可改道;`profiles/<name>/state.db` 是多档案,同扫)。
+/// sessions(id,source,model,title,started_at,ended_at,token 各列)+
+/// messages(role,content,tool_calls,tool_call_id,tool_name,reasoning,timestamp)。
+/// 时间戳是 unix **秒**(REAL),tool_calls 是 JSON 数组——写端两种形状并存:
+/// Hermes 自家精简版 `[{name,arguments}]`(arguments 多为 JSON 字符串)与
+/// OpenAI 原样 `[{id,type,function:{name,arguments}}]`;工具结果是独立
+/// `role="tool"` 行,按 tool_call_id 回填,精简形状没有 id 时按 tool_name
+/// 顺位回填。`source` 是启动面(cli/telegram/discord/…),`tool` 是
+/// session_search 工具内部起的检索会话,不列。会话行没有 cwd(Hermes 是
+/// 通用助手,不按项目分桶),project 留空。
+/// 无每会话文件,SessionFileRef 用虚拟路径 `<db>#<id>`;多库结构与 opencode 同款。
+pub struct HermesAdapter {
+ dbs: Vec<HermesDb>,
+}
+
+struct HermesDb {
+ path: PathBuf,
+ /// 聚合行按库(含 -wal)mtime 缓存一轮扫描内的重复调用
+ rows_cache: MtimeCache<Vec<HermesRow>>,
+ /// 各迁移版本才有的列,每库探一次(见 HermesSchema)
+ schema: OnceLock<HermesSchema>,
+}
+
+impl HermesDb {
+ fn new(path: PathBuf) -> Self {
+ Self {
+ path,
+ rows_cache: MtimeCache::new(),
+ schema: OnceLock::new(),
+ }
+ }
+}
+
+/// Hermes 库是按 schema_version 逐版 ALTER 上来的(hermes_state.py):title 列 v3、
+/// cache_*/reasoning_tokens v5、messages.reasoning v6。老版本 Hermes 写出的库
+/// 没升过就没有这些列,查询里硬引用会让 prepare 失败、整家会话消失——缺列
+/// 一律用默认表达式顶上
+#[derive(Clone, Copy)]
+struct HermesSchema {
+ title: bool,
+ cache_read: bool,
+ cache_write: bool,
+ reasoning_tokens: bool,
+ msg_reasoning: bool,
+}
+
+impl HermesSchema {
+ fn probe(conn: &rusqlite::Connection) -> Self {
+ let has = |table: &str, col: &str| {
+ conn.prepare(&format!(
+ "SELECT 1 FROM pragma_table_info('{table}') WHERE name = ?1"
+ ))
+ .and_then(|mut s| s.exists([col]))
+ .unwrap_or(false)
+ };
+ Self {
+ title: has("sessions", "title"),
+ cache_read: has("sessions", "cache_read_tokens"),
+ cache_write: has("sessions", "cache_write_tokens"),
+ reasoning_tokens: has("sessions", "reasoning_tokens"),
+ msg_reasoning: has("messages", "reasoning"),
+ }
+ }
+}
+
+/// 一个 Hermes home 下的全部库:主库 + `profiles/<name>/state.db`(构造时刻
+/// 快照,不变量 8);默认实例与目录形态的自定义根同一枚举,档案不会静默缺失
+fn dbs_under(root: &Path) -> Vec<PathBuf> {
+ let mut paths = vec![root.join("state.db")];
+ if let Ok(entries) = std::fs::read_dir(root.join("profiles")) {
+ let mut extra: Vec<PathBuf> = entries
+ .flatten()
+ .map(|e| e.path().join("state.db"))
+ .filter(|p| p.is_file())
+ .collect();
+ extra.sort();
+ paths.extend(extra);
+ }
+ paths
+}
+
+/// 会话所属的 Hermes profile 名(resume 用):`profiles/<name>/state.db` → name,
+/// 其余(主库、远程缓存里的主库)→ "default"。Hermes 的 `--profile` 显式覆盖
+/// sticky 的 active_profile,不带它时在别的档案激活期间会找不到会话
+pub fn profile_of(file_path: &str) -> String {
+ let db = Path::new(strip_virtual_path(file_path));
+ db.parent()
+ .filter(|dir| dir.parent().and_then(Path::file_name) == Some("profiles".as_ref()))
+ .and_then(Path::file_name)
+ .map(|n| n.to_string_lossy().to_string())
+ .unwrap_or_else(|| "default".to_string())
+}
+
+impl HermesAdapter {
+ pub fn new() -> Self {
+ let home = super::home_dir().unwrap_or_default();
+ // HERMES_HOME 只是候选:指向的目录里有 state.db 才采信,否则回落 ~/.hermes
+ let root = super::env_dir("HERMES_HOME")
+ .filter(|d| d.join("state.db").is_file())
+ .unwrap_or_else(|| home.join(".hermes"));
+ Self::with_paths(dbs_under(&root))
+ }
+
+ fn with_paths(paths: Vec<PathBuf>) -> Self {
+ Self {
+ dbs: paths.into_iter().map(HermesDb::new).collect(),
+ }
+ }
+
+ fn rows(db: &HermesDb) -> Option<Vec<HermesRow>> {
+ let stamp = super::sqlite_ro::db_cache_stamp(&db.path);
+ db.rows_cache.get_or_try_build(stamp, || {
+ let ro = open_sqlite_ro(&db.path, "hermes")?;
+ query_rows(&ro, db)
+ })
+ }
+
+ fn db_for_ref(&self, r: &SessionFileRef) -> Option<&HermesDb> {
+ let db_path = Path::new(strip_virtual_path(&r.file_path));
+ self.dbs.iter().find(|db| db.path == db_path)
+ }
+
+ fn build_meta(
+ r: &SessionFileRef,
+ 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());
+ SessionMeta {
+ key: format!("hermes:{}", row.id),
+ host: String::new(),
+ id: row.id.clone(),
+ agent: AgentId::Hermes,
+ title,
+ project_path: String::new(),
+ project_name: project_name_of(""),
+ file_path: r.file_path.clone(),
+ created_at: if row.started_ms > 0 {
+ row.started_ms
+ } else {
+ r.mtime_ms
+ },
+ updated_at: if row.updated_ms > 0 {
+ row.updated_ms
+ } else {
+ r.mtime_ms
+ },
+ message_count: messages
+ .iter()
+ .filter(|m| m.kind == MessageKind::Text)
+ .count() as i64,
+ size_bytes: r.size,
+ git_branch: None,
+ model: row.model.clone().filter(|m| !m.is_empty()),
+ tokens_used: (row.tokens > 0).then_some(row.tokens),
+ archived: false,
+ // cli 是默认启动面,徽章只给非 cli 的(telegram/discord/…)
+ source: row.source.clone().filter(|s| !s.is_empty() && s != "cli"),
+ favorite: false,
+ pinned: false,
+ }
+ }
+
+ /// 单会话解析:会话行取缓存的聚合表,只有消息按会话查
+ fn parse(&self, r: &SessionFileRef) -> Result<(SessionMeta, Vec<TranscriptMessage>)> {
+ let db = self
+ .db_for_ref(r)
+ .ok_or_else(|| anyhow!("hermes store for {} not in this instance", r.file_path))?;
+ let row = Self::rows(db)
+ .and_then(|rows| rows.into_iter().find(|row| row.id == r.native_id))
+ .ok_or_else(|| anyhow!("hermes session {} not in store", r.native_id))?;
+ let ro = open_sqlite_ro(&db.path, "hermes")
+ .ok_or_else(|| anyhow!("cannot open hermes store"))?;
+ let schema = *db.schema.get_or_init(|| HermesSchema::probe(&ro.conn));
+ let reasoning_col = if schema.msg_reasoning {
+ "reasoning"
+ } else {
+ "NULL"
+ };
+ let mut stmt = ro.conn.prepare(&format!(
+ "SELECT id, role, content, tool_call_id, tool_calls, tool_name, {reasoning_col}, timestamp
+ FROM messages WHERE session_id = ?1 ORDER BY timestamp, id"
+ ))?;
+ let msgs = stmt.query_map([&r.native_id], |m| {
+ Ok(RawMsg {
+ id: m.get(0)?,
+ role: m.get::<_, Option<String>>(1)?.unwrap_or_default(),
+ content: m.get(2)?,
+ tool_call_id: m.get(3)?,
+ tool_calls: m.get(4)?,
+ tool_name: m.get(5)?,
+ reasoning: m.get(6)?,
+ ts_ms: secs_to_ms(m.get::<_, Option<f64>>(7)?.unwrap_or(0.0)),
+ })
+ })?;
+
+ let mut messages: Vec<TranscriptMessage> = Vec::new();
+ // tool_call_id → (消息下标, tool_calls 下标)
+ let mut by_id: HashMap<String, (usize, usize)> = HashMap::new();
+ // 精简形状没有 id:尚未回填的调用按出现顺序排队,tool 行按 tool_name 认领
+ let mut pending: Vec<(usize, usize)> = Vec::new();
+ for m in msgs.flatten() {
+ match m.role.as_str() {
+ "user" => {
+ let text = content_text(m.content.as_deref());
+ if !text.is_empty() {
+ messages.push(text_msg(Role::User, &text, m.ts_ms));
+ }
+ }
+ "assistant" => {
+ let text = content_text(m.content.as_deref());
+ let calls = tool_calls_of(m.tool_calls.as_deref(), m.id);
+ let thinking = m
+ .reasoning
+ .as_deref()
+ .map(str::trim)
+ .filter(|s| !s.is_empty())
+ .map(String::from);
+ if text.is_empty() && calls.is_empty() && thinking.is_none() {
+ continue;
+ }
+ // 连续 assistant 行(中间只隔 tool 行)合并成一条,与 pi 同款
+ if !matches!(messages.last(), Some(l) if l.role == Role::Assistant) {
+ messages.push(text_msg(Role::Assistant, "", m.ts_ms));
+ }
+ let base = messages.len() - 1;
+ let last = &mut messages[base];
+ if !text.is_empty() {
+ let mut part = ParsedContent::default();
+ part.push_text(&text);
+ append_content_to_message(last, part, "\n\n");
+ if last.text.len() > MAX_MSG_TEXT {
+ let (t, _) = clip(&last.text, MAX_MSG_TEXT);
+ last.text = t;
+ last.truncated = true;
+ }
+ }
+ if let Some(t) = thinking {
+ let merged = match last.thinking.take() {
+ Some(existing) => format!("{existing}\n\n{t}"),
+ None => t,
+ };
+ last.thinking = Some(clip(&merged, MAX_TOOL_IO).0);
+ }
+ for (has_id, tc) in calls {
+ let slot = (base, last.tool_calls.len());
+ if has_id {
+ by_id.insert(tc.id.clone(), slot);
+ }
+ pending.push(slot);
+ last.tool_calls.push(tc);
+ }
+ }
+ "tool" => {
+ let output = content_text(m.content.as_deref());
+ let name = m.tool_name.as_deref().unwrap_or_default();
+ let slot = m
+ .tool_call_id
+ .as_deref()
+ .and_then(|id| by_id.get(id).copied())
+ .or_else(|| {
+ // 无 id:同名的最早待回填项,再退最早的待回填项
+ let unfilled = |&(mi, ti): &(usize, usize)| {
+ messages[mi].tool_calls[ti].output.is_none()
+ };
+ pending
+ .iter()
+ .copied()
+ .find(|s| {
+ unfilled(s)
+ && (name.is_empty()
+ || messages[s.0].tool_calls[s.1].name == name)
+ })
+ .or_else(|| pending.iter().copied().find(unfilled))
+ });
+ if let Some((mi, ti)) = slot {
+ messages[mi].tool_calls[ti].output = Some(clip(&output, MAX_TOOL_IO).0);
+ pending.retain(|s| *s != (mi, ti));
+ }
+ }
+ "system" => {
+ let text = content_text(m.content.as_deref());
+ if !text.is_empty() {
+ let mut msg = text_msg(Role::System, &text, m.ts_ms);
+ msg.kind = MessageKind::Meta;
+ messages.push(msg);
+ }
+ }
+ _ => {}
+ }
+ }
+ assign_seq(&mut messages);
+ let meta = Self::build_meta(r, &row, &messages);
+ Ok((meta, messages))
+ }
+}
+
+struct RawMsg {
+ id: i64,
+ role: String,
+ content: Option<String>,
+ tool_call_id: Option<String>,
+ tool_calls: Option<String>,
+ tool_name: Option<String>,
+ reasoning: Option<String>,
+ ts_ms: i64,
+}
+
+#[derive(Clone)]
+struct HermesRow {
+ id: String,
+ source: Option<String>,
+ model: Option<String>,
+ title: String,
+ started_ms: i64,
+ updated_ms: i64,
+ tokens: i64,
+ message_count: i64,
+ content_len: i64,
+ /// `/branch`、上下文压缩续段、子代理委派都会设它;这些仍是用户可见的
+ /// 会话,照常列出,但按父子关系挂到父会话下(parent_links)
+ parent_id: Option<String>,
+}
+
+/// Hermes 全部时间戳恒为 unix 秒(写端 time.time()),不做秒/毫秒猜测
+fn secs_to_ms(secs: f64) -> i64 {
+ ((secs * 1000.0).round() as i64).max(0)
+}
+
+/// 全表聚合行(list/quick/parse 共用,经 MtimeCache 一轮只跑一次)
+fn query_rows(ro: &SqliteRo, db: &HermesDb) -> Option<Vec<HermesRow>> {
+ let schema = *db.schema.get_or_init(|| HermesSchema::probe(&ro.conn));
+ let col = |present: bool, name: &str| {
+ if present {
+ format!("COALESCE(s.{name},0)")
+ } else {
+ "0".to_string()
+ }
+ };
+ let title_col = if schema.title {
+ "COALESCE(s.title, '')"
+ } else {
+ "''"
+ };
+ let sql = format!(
+ "SELECT s.id, s.source, s.model, {title_col}, s.started_at, s.ended_at,
+ COALESCE(s.input_tokens,0) + COALESCE(s.output_tokens,0) + {} + {} + {},
+ COUNT(m.id), COALESCE(MAX(m.timestamp), 0),
+ COALESCE(SUM(LENGTH(COALESCE(m.content,'')) + LENGTH(COALESCE(m.tool_calls,''))), 0),
+ s.parent_session_id
+ FROM sessions s LEFT JOIN messages m ON m.session_id = s.id
+ GROUP BY s.id",
+ col(schema.cache_read, "cache_read_tokens"),
+ col(schema.cache_write, "cache_write_tokens"),
+ col(schema.reasoning_tokens, "reasoning_tokens"),
+ );
+ let mut stmt = ro.conn.prepare(&sql).ok()?;
+ let rows = stmt
+ .query_map([], |r| {
+ let started = r.get::<_, Option<f64>>(4)?.unwrap_or(0.0);
+ let ended = r.get::<_, Option<f64>>(5)?.unwrap_or(0.0);
+ let last_msg = r.get::<_, Option<f64>>(8)?.unwrap_or(0.0);
+ Ok(HermesRow {
+ id: r.get(0)?,
+ source: r.get(1)?,
+ model: r.get(2)?,
+ title: r.get::<_, Option<String>>(3)?.unwrap_or_default(),
+ started_ms: secs_to_ms(started),
+ updated_ms: secs_to_ms(ended.max(last_msg).max(started)),
+ tokens: r.get::<_, Option<i64>>(6)?.unwrap_or(0),
+ message_count: r.get(7)?,
+ content_len: r.get(9)?,
+ parent_id: r.get::<_, Option<String>>(10)?.filter(|p| !p.is_empty()),
+ })
+ })
+ .ok()?
+ .collect::<rusqlite::Result<Vec<_>>>()
+ .ok();
+ rows
+}
+
+/// content 列多为纯文本;多模态时写端存 JSON 块数组字符串,识别后走
+/// content_parts(图片退占位符,Hermes 库里存的是路径不是数据)
+fn content_text(content: Option<&str>) -> String {
+ let trimmed = content.unwrap_or_default().trim();
+ if let Some(parsed) = trimmed
+ .starts_with(['[', '{'])
+ .then(|| serde_json::from_str::<Value>(trimmed).ok())
+ .flatten()
+ .map(|v| content_parts(&v, false))
+ .filter(|p| !p.text.is_empty())
+ {
+ return parsed.text;
+ }
+ trimmed.to_string()
+}
+
+/// tool_calls JSON → (是否自带 id, view)。两种写端形状都认;arguments 若是
+/// JSON 字符串先解成对象,预览与详情才不是一坨转义
+fn tool_calls_of(raw: Option<&str>, msg_id: i64) -> Vec<(bool, ToolCallView)> {
+ let Some(Value::Array(items)) = raw.and_then(|r| serde_json::from_str::<Value>(r).ok()) else {
+ return Vec::new();
+ };
+ items
+ .iter()
+ .enumerate()
+ .map(|(i, item)| {
+ let func = item.get("function").unwrap_or(item);
+ let name = func.get("name").and_then(Value::as_str).unwrap_or_default();
+ let args = func.get("arguments").cloned().unwrap_or(Value::Null);
+ let input = args
+ .as_str()
+ .and_then(|s| serde_json::from_str::<Value>(s).ok())
+ .unwrap_or(args);
+ let (has_id, id) = match item
+ .get("id")
+ .and_then(Value::as_str)
+ .filter(|s| !s.is_empty())
+ {
+ Some(s) => (true, s.to_string()),
+ None => (false, format!("hermes-{msg_id}-{i}")),
+ };
+ (has_id, tool_call_view(id, name, &input, None, false))
+ })
+ .collect()
+}
+
+impl AgentAdapter for HermesAdapter {
+ fn agent(&self) -> AgentId {
+ AgentId::Hermes
+ }
+
+ fn list_session_files(&self) -> Result<Vec<SessionFileRef>> {
+ let mut out = Vec::new();
+ for db in &self.dbs {
+ let Some(rows) = Self::rows(db) else { continue };
+ out.extend(
+ rows.into_iter()
+ // 空会话(刚起就退)与 session_search 工具内部的检索会话不列
+ .filter(|row| row.message_count > 0 && row.source.as_deref() != Some("tool"))
+ .map(|row| SessionFileRef {
+ agent: AgentId::Hermes,
+ native_id: row.id.clone(),
+ file_path: virtual_path(&db.path, &row.id),
+ mtime_ms: row.updated_ms,
+ size: row.content_len,
+ }),
+ );
+ }
+ Ok(out)
+ }
+
+ fn quick_meta(&self, refs: &[SessionFileRef]) -> Option<HashMap<String, SessionMeta>> {
+ let mut out = HashMap::new();
+ for db in &self.dbs {
+ let Some(rows) = Self::rows(db) else { continue };
+ let by_id: HashMap<&str, &HermesRow> =
+ rows.iter().map(|r| (r.id.as_str(), r)).collect();
+ for r in refs
+ .iter()
+ .filter(|r| Path::new(strip_virtual_path(&r.file_path)) == db.path)
+ {
+ if let Some(row) = by_id.get(r.native_id.as_str()) {
+ out.insert(r.file_path.clone(), Self::build_meta(r, row, &[]));
+ }
+ }
+ }
+ Some(out)
+ }
+
+ fn parse_session(&self, r: &SessionFileRef) -> Result<ParsedSession> {
+ let (meta, messages) = self.parse(r)?;
+ let units = units_from_messages(&messages);
+ Ok(ParsedSession {
+ meta,
+ units,
+ unknown_line_count: 0,
+ })
+ }
+
+ fn parse_transcript(&self, r: &SessionFileRef) -> Result<ParsedTranscript> {
+ let (meta, messages) = self.parse(r)?;
+ Ok(ParsedTranscript {
+ meta,
+ mainline: messages,
+ sidechains: Vec::new(),
+ unknown_line_count: 0,
+ })
+ }
+
+ fn manages_parent_links(&self) -> bool {
+ true
+ }
+
+ /// (child, parent) 全量快照:跨档案的父指针不成立(各库独立),只在库内配对
+ fn parent_links(&self) -> Vec<(String, String)> {
+ let mut links = Vec::new();
+ for db in &self.dbs {
+ let Some(rows) = Self::rows(db) else { continue };
+ let ids: std::collections::HashSet<&str> = rows.iter().map(|r| r.id.as_str()).collect();
+ links.extend(rows.iter().filter_map(|r| {
+ let parent = r.parent_id.as_deref().filter(|p| ids.contains(p))?;
+ Some((format!("hermes:{}", r.id), format!("hermes:{parent}")))
+ }));
+ }
+ links
+ }
+
+ fn with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {
+ // 选中库文件本身、Hermes home(连同其 profiles/*)或单个档案目录都认;
+ // 整形判据只看 dir 内结构,目录不存在时也落到 <dir>/state.db(远程挂载点契约)
+ let paths = if dir.is_file() {
+ vec![dir]
+ } else {
+ dbs_under(&dir)
+ };
+ Box::new(Self::with_paths(paths))
+ }
+
+ fn data_roots(&self) -> Vec<PathBuf> {
+ self.dbs.iter().map(|db| db.path.clone()).collect()
+ }
+
+ fn supports_individual_root_removal(&self) -> bool {
+ self.dbs.len() > 1
+ }
+
+ fn excluding_data_roots(&self, roots: &[PathBuf]) -> Option<Box<dyn AgentAdapter>> {
+ let kept = self
+ .dbs
+ .iter()
+ .filter(|db| !roots.contains(&db.path))
+ .map(|db| db.path.clone())
+ .collect();
+ Some(Box::new(Self::with_paths(kept)))
+ }
+}
diff --git a/crates/wake-core/src/adapters/mod.rs b/crates/wake-core/src/adapters/mod.rs
index 411a52a..9b93787 100644
--- a/crates/wake-core/src/adapters/mod.rs
+++ b/crates/wake-core/src/adapters/mod.rs
@@ -6,8 +6,10 @@ pub mod cursor;
pub mod dsh;
pub mod gemini;
pub mod grok;
+pub mod hermes;
pub mod kimi;
pub mod kiro;
+pub mod openclaw;
pub mod opencode;
pub mod pi;
pub mod qoder;
@@ -16,6 +18,7 @@ pub mod remote;
pub(crate) mod grok_group;
pub(crate) mod parse_utils;
+pub(crate) mod pi_format;
pub(crate) mod sqlite_ro;
use crate::models::*;
@@ -109,7 +112,7 @@ pub trait AgentAdapter: Send + Sync {
/// 拥有本家 session 文件的位置",凭据/配置/索引这类不产生会话的文件不列。
/// 新增 adapter 必须实现:没有默认值,漏了编译就过不去
fn data_roots(&self) -> Vec<std::path::PathBuf>;
- /// 文件监听根目录。默认 = data_roots 中现存的目录,十四家实测全部吻合:
+ /// 文件监听根目录。默认 = data_roots 中现存的目录,十六家实测全部吻合:
/// 目录型给出自己的 root,SQLite 型的根是库文件、天然筛空(watcher 只认
/// .jsonl,库变更靠启动/手动刷新),codex 的 sessions + archived 一并覆盖。
/// 只有当监听范围确实不同于数据根时才覆写——否则一次根路径搬迁
@@ -168,7 +171,7 @@ pub(crate) fn env_dir(key: &str) -> Option<std::path::PathBuf> {
/// 各家数据根共用的 HOME。**全部 adapter 必须走这里**,不要直接
/// `dirs::home_dir()`——`WAKE_HOME` 是整组 adapter 的统一改道开关:
-/// 契约测试靠它把十四家指向 fixture 目录,而 `dirs::home_dir()` 只在
+/// 契约测试靠它把十六家指向 fixture 目录,而 `dirs::home_dir()` 只在
/// POSIX 上看 `$HOME`,Windows 上走 SHGetKnownFolderPath、无论如何都指向
/// 真实用户目录(于是 Windows 上的契约测试全部落空,2026-08-25 review)。
/// 对用户它顺带是便携安装/多档案切换的手动开关。
@@ -176,7 +179,7 @@ pub(crate) fn home_dir() -> Option<std::path::PathBuf> {
env_dir("WAKE_HOME").or_else(dirs::home_dir)
}
-/// 全量十四家 roster,**不按 detect 过滤**。这是全应用唯一的构造点:
+/// 全量十六家 roster,**不按 detect 过滤**。这是全应用唯一的构造点:
/// scanner/watcher/resume/Session locations 面板共享 Workbench 启动时的
/// 同一份实例。缺根的家由各自 list_session_files 降级为 Ok(空)(scanner
/// 对 Err 会 `?` 截断整轮,新 adapter 必须维持这条降级约定,contract 测试
@@ -199,6 +202,8 @@ pub fn create_adapters() -> Vec<Box<dyn AgentAdapter>> {
Box::new(kimi::KimiAdapter::new()),
Box::new(antigravity::AntigravityAdapter::new()),
Box::new(dsh::DshAdapter::new()),
+ Box::new(hermes::HermesAdapter::new()),
+ Box::new(openclaw::OpenclawAdapter::new()),
]
}
diff --git a/crates/wake-core/src/adapters/openclaw.rs b/crates/wake-core/src/adapters/openclaw.rs
new file mode 100644
index 0000000..9027d52
--- /dev/null
+++ b/crates/wake-core/src/adapters/openclaw.rs
@@ -0,0 +1,685 @@
+use super::parse_utils::*;
+use super::pi_format::{PiRender, PiRenderOptions};
+use super::sqlite_ro::{open_sqlite_ro, strip_virtual_path, virtual_path};
+use super::{units_from_messages, AgentAdapter};
+use crate::models::*;
+use anyhow::{anyhow, Result};
+use serde_json::Value;
+use std::collections::{HashMap, HashSet};
+use std::fs;
+use std::io::{BufRead, BufReader};
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, Mutex};
+
+/// OpenClaw(原 Clawdbot/Moltbot):状态目录 `~/.openclaw`(`OPENCLAW_STATE_DIR`
+/// 可改道,老装机名 `~/.clawdbot`),会话按 agent 分桶在 `agents/<agentId>/` 下,
+/// **两代存储并存、同扫**:
+/// - 现版(2026.8+):`agent/openclaw-agent.sqlite`,session_windows(每个
+/// session_id 一行,reset/rollover 后旧窗口保留)+ session_nodes(按 session_key
+/// 的活跃指针与 label)+ transcript_events(session_id, seq, event_json)——
+/// event_json 就是 pi 系 SessionManager 的一行(首行 `{type:"session",cwd}`
+/// header,其余带 id/parentId 的树形条目),`session_transcript_active_events`
+/// 按 active_position 给出当前可见分支,缺表/缺行时退回"最后一条为叶"回溯。
+/// - 旧版:`sessions/<sessionId>.jsonl` 同格式明文,`sessions.json` 是按
+/// session_key 的索引(label/model/totalTokens/spawnedBy)。
+///
+/// 同一会话被 `doctor --fix` 迁进库后旧 jsonl 仍在,同 native_id 双副本由
+/// scanner 按 mtime 裁决(不变量 8⑦),这里不做二选一。
+/// 消息形状即 pi-ai,渲染核心与 pi.rs 共用(pi_format);OpenClaw 独有的是
+/// thinking 块、`runtimeContextCarrier` 归 Meta、compaction/branch_summary/
+/// custom_message/session_info 四种条目。spawned_by 非空 = 子代理,不列。
+pub struct OpenclawAdapter {
+ /// `<state dir>/agents`
+ root: PathBuf,
+ /// 每库一份窗口行缓存(键 = 库路径),按库(含 -wal)mtime 失效
+ rows_cache: Mutex<HashMap<PathBuf, Arc<MtimeCache<Vec<ClawRow>>>>>,
+ /// 旧版 sessions.json 索引,每个 sessions 目录一份,按文件 mtime 失效
+ index_cache: Mutex<HashMap<PathBuf, Arc<MtimeCache<LegacyIndex>>>>,
+}
+
+/// sessions.json 解析结果:sessionId → 条目
+type LegacyIndex = Arc<HashMap<String, Value>>;
+
+const DB_NAME: &str = "openclaw-agent.sqlite";
+/// 转录事件 JSON 的已知非内容类型:静默跳过,表外计 unknown(格式漂移金丝雀)
+const KNOWN_SKIP: &[&str] = &[
+ "session",
+ "thinking_level_change",
+ "label",
+ "custom",
+ "reset",
+];
+
+impl OpenclawAdapter {
+ pub fn new() -> Self {
+ let home = super::home_dir().unwrap_or_default();
+ // OPENCLAW_STATE_DIR 只是候选:里面真有 agents/ 才采信;默认 ~/.openclaw,
+ // 只装过老版本的机器(无 .openclaw、有 .clawdbot)回落旧名——与上游
+ // resolveStateDir 的判序一致
+ let state = super::env_dir("OPENCLAW_STATE_DIR")
+ .filter(|d| d.join("agents").is_dir())
+ .unwrap_or_else(|| {
+ let new = home.join(".openclaw");
+ let legacy = home.join(".clawdbot");
+ if !new.exists() && legacy.exists() {
+ legacy
+ } else {
+ new
+ }
+ });
+ Self::with_root(state.join("agents"))
+ }
+
+ fn with_root(root: PathBuf) -> Self {
+ Self {
+ root,
+ rows_cache: Mutex::new(HashMap::new()),
+ index_cache: Mutex::new(HashMap::new()),
+ }
+ }
+
+ /// `agents/<agentId>/` 目录(构造时不要求存在,枚举时缺根降级为空)
+ fn agent_dirs(&self) -> Vec<PathBuf> {
+ let Ok(entries) = fs::read_dir(&self.root) else {
+ return Vec::new();
+ };
+ let mut dirs: Vec<PathBuf> = entries
+ .flatten()
+ .filter(|e| e.file_type().map(|t| t.is_dir()).unwrap_or(false))
+ .filter(|e| !e.file_name().to_string_lossy().starts_with('.'))
+ .map(|e| e.path())
+ .collect();
+ dirs.sort();
+ dirs
+ }
+
+ fn rows(&self, db: &Path) -> Option<Vec<ClawRow>> {
+ let cache = Arc::clone(
+ self.rows_cache
+ .lock()
+ .unwrap()
+ .entry(db.to_path_buf())
+ .or_insert_with(|| Arc::new(MtimeCache::new())),
+ );
+ let stamp = super::sqlite_ro::db_cache_stamp(db);
+ cache.get_or_try_build(stamp, || {
+ let ro = open_sqlite_ro(db, "openclaw")?;
+ query_rows(&ro.conn)
+ })
+ }
+
+ /// 旧版 `sessions.json`:按 sessionId 的索引(原文件按 session_key 键)
+ fn legacy_index(&self, sessions_dir: &Path) -> LegacyIndex {
+ let file = sessions_dir.join("sessions.json");
+ let cache = Arc::clone(
+ self.index_cache
+ .lock()
+ .unwrap()
+ .entry(file.clone())
+ .or_insert_with(|| Arc::new(MtimeCache::new())),
+ );
+ let stamp = fs::metadata(&file).map(|m| mtime_ms(&m)).unwrap_or(0);
+ cache
+ .get_or_try_build(stamp, || {
+ let text = fs::read_to_string(&file).ok()?;
+ let Value::Object(map) = serde_json::from_str::<Value>(&text).ok()? else {
+ return None;
+ };
+ Some(Arc::new(
+ map.into_values()
+ .filter_map(|v| Some((v.get("sessionId")?.as_str()?.to_string(), v)))
+ .collect(),
+ ))
+ })
+ .unwrap_or_default()
+ }
+
+ fn legacy_hint(&self, path: &Path, native_id: &str) -> RowHint {
+ let Some(dir) = path.parent() else {
+ return RowHint::default();
+ };
+ let index = self.legacy_index(dir);
+ // topic 转录 `<sessionId>-topic-<id>.jsonl` 共用父会话的索引项
+ let base = native_id.split("-topic-").next().unwrap_or(native_id);
+ let Some(v) = index.get(native_id).or_else(|| index.get(base)) else {
+ return RowHint::default();
+ };
+ let s = |k: &str| v.get(k).and_then(Value::as_str).map(String::from);
+ RowHint {
+ label: s("label").or_else(|| s("displayName")),
+ model: s("model"),
+ tokens: v.get("totalTokens").and_then(Value::as_i64),
+ channel: None,
+ created_ms: 0,
+ updated_ms: norm_ms(v.get("updatedAt").and_then(Value::as_i64).unwrap_or(0)),
+ }
+ }
+
+ fn build_meta(r: &SessionFileRef, p: &ClawParse, hint: &RowHint) -> SessionMeta {
+ let title = p
+ .name
+ .clone()
+ .or_else(|| hint.label.clone())
+ .map(|t| clean_title_candidate(&t))
+ .filter(|t| !t.is_empty())
+ .or_else(|| title_from_messages(&p.messages))
+ .unwrap_or_else(|| UNTITLED.to_string());
+ SessionMeta {
+ key: format!("openclaw:{}", r.native_id),
+ host: String::new(),
+ id: r.native_id.clone(),
+ agent: AgentId::Openclaw,
+ title,
+ project_path: p.cwd.clone(),
+ project_name: project_name_of(&p.cwd),
+ file_path: r.file_path.clone(),
+ created_at: [p.created_at, hint.created_ms, r.mtime_ms]
+ .into_iter()
+ .find(|t| *t > 0)
+ .unwrap_or(0),
+ updated_at: [p.last_ts, hint.updated_ms, r.mtime_ms]
+ .into_iter()
+ .find(|t| *t > 0)
+ .unwrap_or(0),
+ message_count: p
+ .messages
+ .iter()
+ .filter(|m| m.kind == MessageKind::Text)
+ .count() as i64,
+ size_bytes: r.size,
+ git_branch: None,
+ model: p
+ .model
+ .clone()
+ .or_else(|| hint.model.clone())
+ .filter(|m| !m.is_empty()),
+ tokens_used: p.tokens_used.or(hint.tokens).filter(|t| *t > 0),
+ archived: false,
+ // 频道即启动面(telegram/discord/webchat…);cli/空不打徽章
+ source: hint.channel.clone().filter(|c| !c.is_empty() && c != "cli"),
+ favorite: false,
+ pinned: false,
+ }
+ }
+
+ fn parse(&self, r: &SessionFileRef, decode_images: bool) -> Result<(SessionMeta, ClawParse)> {
+ let path = Path::new(&r.file_path);
+ if path.is_file() {
+ // 旧版 jsonl:整文件即条目流,叶 = 最后一条
+ let (entries, bad) = read_jsonl_entries(path)?;
+ let mut p = render(linearize(entries, None), decode_images);
+ p.unknown_lines += bad;
+ let hint = self.legacy_hint(path, &r.native_id);
+ let meta = Self::build_meta(r, &p, &hint);
+ return Ok((meta, p));
+ }
+ let db = Path::new(strip_virtual_path(&r.file_path));
+ let row = self
+ .rows(db)
+ .and_then(|rows| rows.into_iter().find(|row| row.session_id == r.native_id))
+ .ok_or_else(|| anyhow!("openclaw session {} not in store", r.native_id))?;
+ let ro = open_sqlite_ro(db, "openclaw")
+ .ok_or_else(|| anyhow!("cannot open openclaw store {}", db.display()))?;
+ let mut stmt = ro.conn.prepare(
+ "SELECT seq, event_json FROM transcript_events WHERE session_id = ?1 ORDER BY seq",
+ )?;
+ let mut entries: Vec<(i64, Value)> = Vec::new();
+ let mut unknown = 0u32;
+ for row in stmt.query_map([&r.native_id], |x| {
+ Ok((x.get::<_, i64>(0)?, x.get::<_, String>(1)?))
+ })? {
+ match row
+ .ok()
+ .and_then(|(seq, json)| serde_json::from_str::<Value>(&json).ok().map(|v| (seq, v)))
+ {
+ Some(entry) => entries.push(entry),
+ None => unknown += 1,
+ }
+ }
+ // 当前可见分支(按 active_position);表缺失/为空时退回树回溯
+ let active: Vec<i64> = ro
+ .conn
+ .prepare(
+ "SELECT event_seq FROM session_transcript_active_events
+ WHERE session_id = ?1 ORDER BY active_position",
+ )
+ .and_then(|mut s| {
+ s.query_map([&r.native_id], |x| x.get::<_, i64>(0))
+ .map(|it| it.flatten().collect::<Vec<_>>())
+ })
+ .unwrap_or_default();
+ let active_ix = (!active.is_empty()).then(|| {
+ let by_seq: HashMap<i64, usize> = entries
+ .iter()
+ .enumerate()
+ .map(|(i, (seq, _))| (*seq, i))
+ .collect();
+ active
+ .iter()
+ .filter_map(|s| by_seq.get(s).copied())
+ .collect()
+ });
+ let values: Vec<Value> = entries.into_iter().map(|(_, v)| v).collect();
+ let mut p = render(linearize(values, active_ix), decode_images);
+ p.unknown_lines += unknown;
+ let meta = Self::build_meta(r, &p, &row.hint);
+ Ok((meta, p))
+ }
+}
+
+/// 库内一条会话窗口(session_windows ⋈ session_nodes)
+#[derive(Clone)]
+struct ClawRow {
+ session_id: String,
+ spawned_by: Option<String>,
+ event_count: i64,
+ content_len: i64,
+ hint: RowHint,
+}
+
+/// 库行 / 旧版索引给解析结果补缺的元数据
+#[derive(Clone, Default)]
+struct RowHint {
+ label: Option<String>,
+ model: Option<String>,
+ tokens: Option<i64>,
+ channel: Option<String>,
+ created_ms: i64,
+ updated_ms: i64,
+}
+
+/// 上游全部 ms 整数;防御性兼容秒,阈值与 parse_utils::to_epoch_ms 同一条线
+fn norm_ms(v: i64) -> i64 {
+ to_epoch_ms(&Value::from(v))
+}
+
+fn query_rows(conn: &rusqlite::Connection) -> Option<Vec<ClawRow>> {
+ let mut stmt = conn
+ .prepare(
+ "SELECT w.session_id, w.spawned_by, w.created_at, w.updated_at,
+ w.transcript_updated_at, w.started_at, w.model, w.channel, w.display_name,
+ n.label, n.display_name, n.entry_json,
+ COUNT(e.seq), COALESCE(SUM(LENGTH(e.event_json)), 0),
+ COALESCE(MAX(e.created_at), 0)
+ FROM session_windows w
+ LEFT JOIN session_nodes n ON n.session_key = w.session_key
+ LEFT JOIN transcript_events e ON e.session_id = w.session_id
+ GROUP BY w.session_id",
+ )
+ .ok()?;
+ let rows = stmt
+ .query_map([], |r| {
+ let session_id: String = r.get(0)?;
+ let created = norm_ms(r.get::<_, Option<i64>>(2)?.unwrap_or(0));
+ let started = norm_ms(r.get::<_, Option<i64>>(5)?.unwrap_or(0));
+ let updated = norm_ms(r.get::<_, Option<i64>>(3)?.unwrap_or(0));
+ let transcript_updated = norm_ms(r.get::<_, Option<i64>>(4)?.unwrap_or(0));
+ let last_event = norm_ms(r.get::<_, Option<i64>>(14)?.unwrap_or(0));
+ let entry: Value = r
+ .get::<_, Option<String>>(11)?
+ .and_then(|s| serde_json::from_str(&s).ok())
+ .unwrap_or(Value::Null);
+ let entry_str = |k: &str| entry.get(k).and_then(Value::as_str).map(String::from);
+ let label = r
+ .get::<_, Option<String>>(9)?
+ .or(r.get::<_, Option<String>>(10)?)
+ .or(r.get::<_, Option<String>>(8)?)
+ .or_else(|| entry_str("label"))
+ .or_else(|| entry_str("displayName"))
+ .filter(|s| !s.trim().is_empty());
+ let model = r
+ .get::<_, Option<String>>(6)?
+ .or_else(|| entry_str("model"));
+ // 只有当前活跃窗口的 entry_json 归它;老窗口的 node 指向新窗口,
+ // 计数不能张冠李戴
+ let is_current = entry.get("sessionId").and_then(Value::as_str) == Some(&session_id);
+ let tokens = is_current
+ .then(|| entry.get("totalTokens").and_then(Value::as_i64))
+ .flatten();
+ Ok(ClawRow {
+ spawned_by: r.get::<_, Option<String>>(1)?.filter(|s| !s.is_empty()),
+ event_count: r.get(12)?,
+ content_len: r.get(13)?,
+ hint: RowHint {
+ label,
+ model,
+ tokens,
+ channel: r.get(7)?,
+ created_ms: [started, created].into_iter().find(|t| *t > 0).unwrap_or(0),
+ updated_ms: [transcript_updated, last_event, updated]
+ .into_iter()
+ .max()
+ .unwrap_or(0),
+ },
+ session_id,
+ })
+ })
+ .ok()?
+ .collect::<rusqlite::Result<Vec<_>>>()
+ .ok();
+ rows
+}
+
+/// 旧版转录文件名过滤:归档/回滚快照/压缩检查点都不是活会话
+fn is_legacy_transcript(name: &str) -> bool {
+ name.ends_with(".jsonl")
+ && !name.starts_with('.')
+ && !name.contains(".deleted.")
+ && !name.contains(".reset.")
+ && !name.contains(".checkpoint.")
+}
+
+/// (条目, 坏行数)
+fn read_jsonl_entries(path: &Path) -> Result<(Vec<Value>, u32)> {
+ let file = fs::File::open(path)?;
+ let reader = BufReader::with_capacity(1 << 20, file);
+ let mut out = Vec::new();
+ let mut bad = 0u32;
+ for line in reader.lines() {
+ let Ok(line) = line else {
+ bad += 1;
+ continue;
+ };
+ if line.trim().is_empty() {
+ continue;
+ }
+ match serde_json::from_str::<Value>(&line) {
+ Ok(v) => out.push(v),
+ Err(_) => bad += 1,
+ }
+ }
+ Ok((out, bad))
+}
+
+/// 树形条目 → 当前分支的线性序列(header 在首位)。`active` 给出(下标)显式
+/// 分支时照单;否则以最后一条带 id 的条目为叶沿 parentId 回溯到根(pi
+/// SessionManager 的默认叶语义,旧版 jsonl 只有这一种)。
+fn linearize(mut entries: Vec<Value>, active: Option<Vec<usize>>) -> Vec<Value> {
+ let header_ix = entries
+ .iter()
+ .position(|v| v.get("type").and_then(Value::as_str) == Some("session"));
+ let chain: Vec<usize> = match active {
+ Some(ix) => ix,
+ None => {
+ let by_id: HashMap<&str, usize> = entries
+ .iter()
+ .enumerate()
+ .filter_map(|(i, v)| v.get("id").and_then(Value::as_str).map(|id| (id, i)))
+ .collect();
+ let mut chain = Vec::new();
+ let mut seen = HashSet::new();
+ let mut cursor = entries
+ .iter()
+ .rposition(|v| v.get("id").and_then(Value::as_str).is_some());
+ while let Some(i) = cursor {
+ if !seen.insert(i) {
+ break;
+ }
+ chain.push(i);
+ cursor = entries[i]
+ .get("parentId")
+ .and_then(Value::as_str)
+ .and_then(|p| by_id.get(p).copied());
+ }
+ chain.reverse();
+ chain
+ }
+ };
+ let mut out = Vec::with_capacity(chain.len() + 1);
+ if let Some(h) = header_ix {
+ out.push(std::mem::take(&mut entries[h]));
+ }
+ for i in chain {
+ if Some(i) != header_ix {
+ out.push(std::mem::take(&mut entries[i]));
+ }
+ }
+ out
+}
+
+struct ClawParse {
+ cwd: String,
+ created_at: i64,
+ last_ts: i64,
+ messages: Vec<TranscriptMessage>,
+ model: Option<String>,
+ tokens_used: Option<i64>,
+ /// session_info 的 name(用户/自动命名),标题首选
+ name: Option<String>,
+ unknown_lines: u32,
+}
+
+fn entry_ts(v: &Value, msg: Option<&Value>) -> i64 {
+ v.get("timestamp")
+ .and_then(Value::as_str)
+ .map(iso_ms)
+ .filter(|t| *t > 0)
+ .or_else(|| {
+ msg.and_then(|m| m.get("timestamp"))
+ .map(to_epoch_ms)
+ .filter(|t| *t > 0)
+ })
+ .unwrap_or(0)
+}
+
+fn render(chain: Vec<Value>, decode_images: bool) -> ClawParse {
+ let _image_budget = transcript_image_decode_budget(decode_images);
+ let mut p = ClawParse {
+ cwd: String::new(),
+ created_at: 0,
+ last_ts: 0,
+ messages: Vec::new(),
+ model: None,
+ tokens_used: None,
+ name: None,
+ unknown_lines: 0,
+ };
+ let mut render = PiRender::new(
+ PiRenderOptions {
+ thinking_blocks: true,
+ meta_carrier: true,
+ raw_tool_results: true,
+ },
+ decode_images,
+ );
+ // 非 message 条目(compaction 摘要等)要按位置插在消息流里,故由 render
+ // 接管 messages,这里只借它推进
+ for v in &chain {
+ let Some(typ) = v.get("type").and_then(Value::as_str) else {
+ p.unknown_lines += 1;
+ continue;
+ };
+ match typ {
+ "session" => {
+ if let Some(c) = v.get("cwd").and_then(Value::as_str) {
+ p.cwd = c.to_string();
+ }
+ if let Some(t) = v.get("timestamp").and_then(Value::as_str) {
+ p.created_at = iso_ms(t);
+ }
+ }
+ "message" => {
+ let Some(msg) = v.get("message") else {
+ p.unknown_lines += 1;
+ continue;
+ };
+ let ts = entry_ts(v, Some(msg));
+ p.last_ts = p.last_ts.max(ts);
+ if !render.push(msg, ts) {
+ p.unknown_lines += 1;
+ }
+ }
+ "model_change" => {
+ if let Some(m) = v.get("modelId").and_then(Value::as_str) {
+ render.model = Some(m.to_string());
+ }
+ }
+ "compaction" | "branch_summary" => {
+ let ts = entry_ts(v, None);
+ p.last_ts = p.last_ts.max(ts);
+ if let Some(s) = v.get("summary").and_then(Value::as_str) {
+ if !s.trim().is_empty() {
+ let mut m = text_msg(Role::System, s, ts);
+ m.kind = MessageKind::CompactSummary;
+ render.messages.push(m);
+ }
+ }
+ }
+ "custom_message" => {
+ // 扩展注入进上下文的消息:display=true 才是给人看的,折叠为 Meta
+ if v.get("display").and_then(Value::as_bool) == Some(true) {
+ let parsed = content_parts(v.get("content").unwrap_or(&Value::Null), false);
+ if !parsed.text.is_empty() {
+ let mut m = text_msg(Role::System, &parsed.text, entry_ts(v, None));
+ m.kind = MessageKind::Meta;
+ render.messages.push(m);
+ }
+ }
+ }
+ "session_info" => {
+ if let Some(n) = v.get("name").and_then(Value::as_str) {
+ let n = n.trim();
+ p.name = (!n.is_empty()).then(|| n.to_string());
+ }
+ }
+ other if KNOWN_SKIP.contains(&other) => {}
+ _ => p.unknown_lines += 1,
+ }
+ }
+ p.messages = render.messages;
+ p.model = render.model;
+ p.tokens_used = render.tokens_used;
+ assign_seq(&mut p.messages);
+ p
+}
+
+impl AgentAdapter for OpenclawAdapter {
+ fn agent(&self) -> AgentId {
+ AgentId::Openclaw
+ }
+
+ fn list_session_files(&self) -> Result<Vec<SessionFileRef>> {
+ let mut out = Vec::new();
+ for dir in self.agent_dirs() {
+ let db = dir.join("agent").join(DB_NAME);
+ if db.is_file() {
+ if let Some(rows) = self.rows(&db) {
+ out.extend(
+ rows.into_iter()
+ .filter(|row| row.spawned_by.is_none() && row.event_count > 0)
+ .map(|row| SessionFileRef {
+ agent: AgentId::Openclaw,
+ native_id: row.session_id.clone(),
+ file_path: virtual_path(&db, &row.session_id),
+ mtime_ms: row.hint.updated_ms,
+ size: row.content_len,
+ }),
+ );
+ }
+ }
+ let sessions = dir.join("sessions");
+ let Ok(entries) = fs::read_dir(&sessions) else {
+ continue;
+ };
+ let index = self.legacy_index(&sessions);
+ let spawned: HashSet<&str> = index
+ .iter()
+ .filter(|(_, v)| {
+ v.get("spawnedBy")
+ .and_then(Value::as_str)
+ .is_some_and(|s| !s.is_empty())
+ })
+ .map(|(id, _)| id.as_str())
+ .collect();
+ for e in entries.flatten() {
+ let name = e.file_name().to_string_lossy().to_string();
+ if !is_legacy_transcript(&name) {
+ continue;
+ }
+ let Ok(meta) = e.metadata() else { continue };
+ if !meta.is_file() || meta.len() == 0 {
+ continue;
+ }
+ let stem = name.strip_suffix(".jsonl").unwrap_or(&name);
+ let base = stem.split("-topic-").next().unwrap_or(stem);
+ if spawned.contains(stem) || spawned.contains(base) {
+ continue;
+ }
+ out.push(SessionFileRef {
+ agent: AgentId::Openclaw,
+ native_id: stem.to_string(),
+ file_path: e.path().to_string_lossy().to_string(),
+ mtime_ms: mtime_ms(&meta),
+ size: meta.len() as i64,
+ });
+ }
+ }
+ Ok(out)
+ }
+
+ fn file_ref(&self, path: &Path) -> Option<SessionFileRef> {
+ // 只认 agents/<id>/sessions/<name>.jsonl 这一层;归档/检查点同 list 过滤
+ let name = path.file_name()?.to_string_lossy().to_string();
+ if !is_legacy_transcript(&name) {
+ return None;
+ }
+ let sessions = path.parent()?;
+ if sessions.file_name()?.to_str()? != "sessions" {
+ return None;
+ }
+ if sessions.parent()?.parent()? != self.root {
+ return None;
+ }
+ default_file_ref(AgentId::Openclaw, path)
+ }
+
+ // quick_meta 不覆写:库行给不出标题的可靠来源(名字在 session_info 事件里),
+ // 走全解析
+
+ fn parse_session(&self, r: &SessionFileRef) -> Result<ParsedSession> {
+ let (meta, p) = self.parse(r, false)?;
+ let units = units_from_messages(&p.messages);
+ Ok(ParsedSession {
+ meta,
+ units,
+ unknown_line_count: p.unknown_lines,
+ })
+ }
+
+ fn parse_transcript(&self, r: &SessionFileRef) -> Result<ParsedTranscript> {
+ let (meta, p) = self.parse(r, true)?;
+ Ok(ParsedTranscript {
+ meta,
+ mainline: p.messages,
+ sidechains: Vec::new(),
+ unknown_line_count: p.unknown_lines,
+ })
+ }
+
+ fn with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {
+ // 选中状态目录(~/.openclaw)或 agents 目录本身都认;目录尚不存在时按
+ // 名字判:叫 agents 即是根,否则视作状态目录(远程挂载点 `.openclaw/agents`
+ // 同步前就落在正确形态)
+ let is_agents = dir.file_name().and_then(|n| n.to_str()) == Some("agents")
+ || (!dir.join("agents").is_dir() && looks_like_agents(&dir));
+ let root = if is_agents { dir } else { dir.join("agents") };
+ Box::new(Self::with_root(root))
+ }
+
+ fn data_roots(&self) -> Vec<PathBuf> {
+ vec![self.root.clone()]
+ }
+}
+
+/// 目录里已有 `<x>/sessions` 或 `<x>/agent/openclaw-agent.sqlite` 形态的子目录
+/// → 它本身就是 agents 根(用户把 agents 目录改名拷出来的情形)
+fn looks_like_agents(dir: &Path) -> bool {
+ fs::read_dir(dir)
+ .map(|it| {
+ it.flatten().any(|e| {
+ let p = e.path();
+ p.join("sessions").is_dir() || p.join("agent").join(DB_NAME).is_file()
+ })
+ })
+ .unwrap_or(false)
+}
diff --git a/crates/wake-core/src/adapters/pi.rs b/crates/wake-core/src/adapters/pi.rs
index e4f26d4..5a0082b 100644
--- a/crates/wake-core/src/adapters/pi.rs
+++ b/crates/wake-core/src/adapters/pi.rs
@@ -1,8 +1,8 @@
use super::parse_utils::*;
+use super::pi_format::{PiRender, PiRenderOptions};
use super::{units_from_messages, AgentAdapter};
use crate::models::*;
use anyhow::Result;
-use std::collections::HashMap;
use std::fs;
use std::io::{BufRead, BufReader};
use std::path::{Path, PathBuf};
@@ -75,8 +75,8 @@ fn parse_pi_jsonl(path: &Path, decode_images: bool) -> Result<PiParse> {
tokens_used: None,
unknown_lines: 0,
};
- // toolCallId → (消息下标, tool_calls 下标),toolResult 行回填用
- let mut tool_index: HashMap<String, (usize, usize)> = HashMap::new();
+ // 消息渲染核心与 OpenClaw 共用(pi_format);Pi 是它的基础配置
+ let mut render = PiRender::new(PiRenderOptions::default(), decode_images);
for line in reader.lines() {
let Ok(line) = line else {
@@ -113,100 +113,8 @@ fn parse_pi_jsonl(path: &Path, decode_images: bool) -> Result<PiParse> {
.map(iso_ms)
.unwrap_or(0);
p.last_ts = p.last_ts.max(ts);
- let content = msg.get("content").unwrap_or(&serde_json::Value::Null);
- match msg.get("role").and_then(|v| v.as_str()) {
- Some("user") => {
- let parsed = content_parts(content, decode_images);
- if !parsed.text.is_empty() || !parsed.images.is_empty() {
- let mut message = text_msg(Role::User, &parsed.text, ts);
- message.images = parsed.images;
- p.messages.push(message);
- }
- }
- Some("assistant") => {
- let parsed = content_parts(content, decode_images);
- let mut tools: Vec<ToolCallView> = Vec::new();
- for b in content.as_array().into_iter().flatten() {
- if b.get("type").and_then(|v| v.as_str()) == Some("toolCall") {
- let id = b.get("id").and_then(|v| v.as_str()).unwrap_or_default();
- let name =
- b.get("name").and_then(|v| v.as_str()).unwrap_or_default();
- let input = b
- .get("arguments")
- .cloned()
- .unwrap_or(serde_json::Value::Null);
- tools.push(tool_call_view(
- id.to_string(),
- name,
- &input,
- None,
- false,
- ));
- }
- }
- if parsed.text.is_empty() && tools.is_empty() && parsed.images.is_empty() {
- continue;
- }
- let model = msg.get("model").and_then(|v| v.as_str()).map(String::from);
- if model.is_some() {
- p.model = model.clone();
- }
- if let Some(t) = msg
- .get("usage")
- .and_then(|u| u.get("totalTokens"))
- .and_then(|v| v.as_i64())
- {
- p.tokens_used = Some(t);
- }
- // 连续 assistant 行(中间只隔 toolResult)合并成一条,
- // 详情页每个回合一条助手消息
- if !matches!(p.messages.last(), Some(m) if m.role == Role::Assistant) {
- p.messages.push(text_msg(Role::Assistant, "", ts));
- }
- let base = p.messages.len() - 1;
- let last = &mut p.messages[base];
- // 合并后统一压 MAX_MSG_TEXT 上限(整个 agentic 回合并成
- // 一条消息,不能靠单行的 text_msg clip)
- if !parsed.text.is_empty() || !parsed.images.is_empty() {
- if last.text.len() < MAX_MSG_TEXT {
- append_content_to_message(last, parsed, "\n\n");
- } else {
- append_images_to_message_end(last, parsed.images);
- }
- if last.text.len() > MAX_MSG_TEXT {
- let (t, _) = clip(&last.text, MAX_MSG_TEXT);
- last.text = t;
- last.truncated = true;
- }
- }
- if model.is_some() {
- last.model = model;
- }
- for tc in tools {
- tool_index.insert(tc.id.clone(), (base, last.tool_calls.len()));
- last.tool_calls.push(tc);
- }
- }
- Some("toolResult") => {
- let Some(call_id) = msg.get("toolCallId").and_then(|v| v.as_str()) else {
- continue;
- };
- if let Some(&(mi, ti)) = tool_index.get(call_id) {
- let parsed = content_parts(content, decode_images);
- let message = &mut p.messages[mi];
- let tc = &mut message.tool_calls[ti];
- if !parsed.text.is_empty() {
- tc.output = Some(clip(&parsed.text, MAX_TOOL_IO).0);
- }
- if msg.get("isError").and_then(|v| v.as_bool()) == Some(true) {
- tc.is_error = true;
- }
- append_images_to_message_end(message, parsed.images);
- }
- }
- _ => {
- p.unknown_lines += 1;
- }
+ if !render.push(msg, ts) {
+ p.unknown_lines += 1;
}
}
// 已知的非内容行:模型/思考档位切换等,静默跳过
@@ -216,6 +124,9 @@ fn parse_pi_jsonl(path: &Path, decode_images: bool) -> Result<PiParse> {
}
}
}
+ p.messages = render.messages;
+ p.model = render.model;
+ p.tokens_used = render.tokens_used;
assign_seq(&mut p.messages);
Ok(p)
}
diff --git a/crates/wake-core/src/adapters/pi_format.rs b/crates/wake-core/src/adapters/pi_format.rs
new file mode 100644
index 0000000..0a9e36a
--- /dev/null
+++ b/crates/wake-core/src/adapters/pi_format.rs
@@ -0,0 +1,171 @@
+//! pi-ai 消息形状的共用渲染核心:Pi / Oh My Pi 的 `<ts>_<uuid>.jsonl` 与 OpenClaw
+//! 的转录条目都是同一族——`{role:user|assistant|toolResult, content:[…]}`,
+//! assistant 块 text|thinking|toolCall,toolResult 独立 role 按 toolCallId 回填,
+//! 连续 assistant(中间只隔 toolResult)合并成一条。合并与截断逻辑只此一份,
+//! 两家的差异全部落在 `PiRenderOptions`。
+
+use super::parse_utils::*;
+use crate::models::*;
+use serde_json::Value;
+use std::collections::HashMap;
+
+#[derive(Clone, Copy, Default)]
+pub(crate) struct PiRenderOptions {
+ /// assistant 的 `thinking` 块进 `thinking`(Pi 不落盘 thinking,OpenClaw 落)
+ pub thinking_blocks: bool,
+ /// user 行带 `runtimeContextCarrier:true` 是运行时注入的上下文,归 Meta
+ pub meta_carrier: bool,
+ /// toolResult 正文走 tool_result_parts(未知对象保留 JSON 原文)而非 content_parts
+ pub raw_tool_results: bool,
+}
+
+/// 逐条喂 message 的累加器;`messages` 定型后由调用方 assign_seq
+pub(crate) struct PiRender {
+ pub messages: Vec<TranscriptMessage>,
+ pub model: Option<String>,
+ pub tokens_used: Option<i64>,
+ opts: PiRenderOptions,
+ decode_images: bool,
+ /// toolCallId → (消息下标, tool_calls 下标)
+ tool_index: HashMap<String, (usize, usize)>,
+}
+
+impl PiRender {
+ pub fn new(opts: PiRenderOptions, decode_images: bool) -> Self {
+ Self {
+ messages: Vec::new(),
+ model: None,
+ tokens_used: None,
+ opts,
+ decode_images,
+ tool_index: HashMap::new(),
+ }
+ }
+
+ /// 一条 `{role,content,…}`;未知 role 返回 false(调用方计 unknown)
+ pub fn push(&mut self, msg: &Value, ts: i64) -> bool {
+ let content = msg.get("content").unwrap_or(&Value::Null);
+ match msg.get("role").and_then(Value::as_str) {
+ Some("user") => {
+ let parsed = content_parts(content, self.decode_images);
+ if parsed.text.is_empty() && parsed.images.is_empty() {
+ return true;
+ }
+ let mut message = text_msg(Role::User, &parsed.text, ts);
+ message.images = parsed.images;
+ if self.opts.meta_carrier
+ && msg.get("runtimeContextCarrier").and_then(Value::as_bool) == Some(true)
+ {
+ message.kind = MessageKind::Meta;
+ }
+ self.messages.push(message);
+ }
+ Some("assistant") => self.push_assistant(msg, content, ts),
+ Some("toolResult") => {
+ let Some(call_id) = msg.get("toolCallId").and_then(Value::as_str) else {
+ return true;
+ };
+ let Some(&(mi, ti)) = self.tool_index.get(call_id) else {
+ return true;
+ };
+ let parsed = if self.opts.raw_tool_results {
+ tool_result_parts(content, self.decode_images)
+ } else {
+ content_parts(content, self.decode_images)
+ };
+ let message = &mut self.messages[mi];
+ let tc = &mut message.tool_calls[ti];
+ if !parsed.text.is_empty() {
+ tc.output = Some(clip(&parsed.text, MAX_TOOL_IO).0);
+ }
+ if msg.get("isError").and_then(Value::as_bool) == Some(true) {
+ tc.is_error = true;
+ }
+ append_images_to_message_end(message, parsed.images);
+ }
+ _ => return false,
+ }
+ true
+ }
+
+ fn push_assistant(&mut self, msg: &Value, content: &Value, ts: i64) {
+ let parsed = content_parts(content, self.decode_images);
+ let mut tools: Vec<ToolCallView> = Vec::new();
+ let mut thinking = String::new();
+ for b in content.as_array().into_iter().flatten() {
+ match b.get("type").and_then(Value::as_str) {
+ Some("toolCall") => {
+ let id = b.get("id").and_then(Value::as_str).unwrap_or_default();
+ let name = b.get("name").and_then(Value::as_str).unwrap_or_default();
+ let input = b.get("arguments").cloned().unwrap_or(Value::Null);
+ tools.push(tool_call_view(id.to_string(), name, &input, None, false));
+ }
+ Some("thinking") if self.opts.thinking_blocks => {
+ if let Some(t) = b.get("thinking").and_then(Value::as_str) {
+ let t = t.trim();
+ if !t.is_empty() {
+ if !thinking.is_empty() {
+ thinking.push_str("\n\n");
+ }
+ thinking.push_str(t);
+ }
+ }
+ }
+ _ => {}
+ }
+ }
+ if parsed.text.is_empty()
+ && tools.is_empty()
+ && parsed.images.is_empty()
+ && thinking.is_empty()
+ {
+ return;
+ }
+ let model = msg.get("model").and_then(Value::as_str).map(String::from);
+ if model.is_some() {
+ self.model = model.clone();
+ }
+ if let Some(t) = msg
+ .get("usage")
+ .and_then(|u| u.get("totalTokens"))
+ .and_then(Value::as_i64)
+ {
+ self.tokens_used = Some(t);
+ }
+ // 连续 assistant(中间只隔 toolResult)合并成一条,详情页每个回合一条助手消息
+ if !matches!(self.messages.last(), Some(m) if m.role == Role::Assistant) {
+ self.messages.push(text_msg(Role::Assistant, "", ts));
+ }
+ let base = self.messages.len() - 1;
+ let last = &mut self.messages[base];
+ // 合并后统一压 MAX_MSG_TEXT 上限(整个 agentic 回合并成一条,不能靠单行的 text_msg clip)
+ if !parsed.text.is_empty() || !parsed.images.is_empty() {
+ if last.text.len() < MAX_MSG_TEXT {
+ append_content_to_message(last, parsed, "\n\n");
+ } else {
+ append_images_to_message_end(last, parsed.images);
+ }
+ if last.text.len() > MAX_MSG_TEXT {
+ let (t, _) = clip(&last.text, MAX_MSG_TEXT);
+ last.text = t;
+ last.truncated = true;
+ }
+ }
+ if !thinking.is_empty() {
+ // 与正文/工具 IO 同一上限:长推理合并后也不能无限增长
+ let merged = match last.thinking.take() {
+ Some(existing) => format!("{existing}\n\n{thinking}"),
+ None => thinking,
+ };
+ last.thinking = Some(clip(&merged, MAX_TOOL_IO).0);
+ }
+ if model.is_some() {
+ last.model = model;
+ }
+ for tc in tools {
+ self.tool_index
+ .insert(tc.id.clone(), (base, last.tool_calls.len()));
+ last.tool_calls.push(tc);
+ }
+ }
+}
diff --git a/crates/wake-core/src/adapters/remote.rs b/crates/wake-core/src/adapters/remote.rs
index be2d0d5..eeb1e6f 100644
--- a/crates/wake-core/src/adapters/remote.rs
+++ b/crates/wake-core/src/adapters/remote.rs
@@ -50,7 +50,7 @@ impl RemoteAdapter {
}
}
-/// 对一个 host 构造整组远程实例:十四家模板 × `with_custom_root`(缓存内
+/// 对一个 host 构造整组远程实例:十六家模板 × `with_custom_root`(缓存内
/// 挂载点,见 remote::REMOTE_LAYOUTS)× 装饰器。追加进 roster 的 active 尾部
/// (不进 Session locations 面板)。`templates` 由 roster 唯一构造点传入
/// (不变量 8:本模块不得自行二次 create_adapters());产物的数据根 100%
diff --git a/crates/wake-core/src/models.rs b/crates/wake-core/src/models.rs
index d5013b6..7e6f88f 100644
--- a/crates/wake-core/src/models.rs
+++ b/crates/wake-core/src/models.rs
@@ -19,13 +19,15 @@ pub enum AgentId {
Copilot,
Antigravity,
Qoder,
+ Hermes,
+ Openclaw,
}
impl AgentId {
- /// 全部十四家,**枚举声明序**(= Ord = 用户钉的侧栏展示序;面板成组、
+ /// 全部十六家,**枚举声明序**(= Ord = 用户钉的侧栏展示序;面板成组、
/// 表单下拉共用同一顺序)。曾误抄 create_adapters 的构造序,下拉与侧栏
/// 排序当场对不上——契约测试现在卡它与 Ord 一致
- pub const ALL: [AgentId; 14] = [
+ pub const ALL: [AgentId; 16] = [
AgentId::ClaudeCode,
AgentId::Codex,
AgentId::Grok,
@@ -40,6 +42,8 @@ impl AgentId {
AgentId::Copilot,
AgentId::Antigravity,
AgentId::Qoder,
+ AgentId::Hermes,
+ AgentId::Openclaw,
];
pub fn as_str(&self) -> &'static str {
@@ -58,6 +62,8 @@ impl AgentId {
AgentId::Kimi => "kimi",
AgentId::Antigravity => "antigravity",
AgentId::Dsh => "dsh",
+ AgentId::Hermes => "hermes",
+ AgentId::Openclaw => "openclaw",
}
}
@@ -77,6 +83,8 @@ impl AgentId {
"kimi" => Some(AgentId::Kimi),
"antigravity" => Some(AgentId::Antigravity),
"dsh" => Some(AgentId::Dsh),
+ "hermes" => Some(AgentId::Hermes),
+ "openclaw" => Some(AgentId::Openclaw),
_ => None,
}
}
@@ -97,6 +105,8 @@ impl AgentId {
AgentId::Kimi => "Kimi Code",
AgentId::Antigravity => "Antigravity CLI",
AgentId::Dsh => "DeepSeek Harness",
+ AgentId::Hermes => "Hermes Agent",
+ AgentId::Openclaw => "OpenClaw",
}
}
@@ -104,8 +114,9 @@ impl AgentId {
/// 与 kooky 同源)。后缀必须带上(与 SVG 图标同理,漏后缀 = 静默空白)。
/// Copilot/Cursor/OpenCode/Pi/Grok/Kimi 是单色字形(白色+alpha):深色模式
/// 用白色版,浅色模式用 `-light`(深墨 #2B2A26)版——等效 kooky 的染色;
- /// Qoder 是白/黑字形配绿色品牌色,同样按模式切图;其余彩色品牌
- /// (Claude/Codex/Gemini/Kiro/Omp/Antigravity)保持原色,两模式通用。
+ /// Qoder 是白/黑字形配绿色品牌色,同样按模式切图;Hermes(lobe-icons 的
+ /// NousResearch 字形)同为单色双版;其余彩色品牌(Claude/Codex/Gemini/Kiro/
+ /// Omp/Antigravity/OpenClaw 的红龙虾)保持原色,两模式通用。
pub fn brand_icon(&self, dark: bool) -> &'static str {
match self {
AgentId::ClaudeCode => "brands/claude-code.png",
@@ -164,6 +175,14 @@ impl AgentId {
}
AgentId::Antigravity => "brands/antigravity.png",
AgentId::Dsh => "brands/deepseek.png",
+ AgentId::Hermes => {
+ if dark {
+ "brands/hermes.png"
+ } else {
+ "brands/hermes-light.png"
+ }
+ }
+ AgentId::Openclaw => "brands/openclaw.png",
}
}
}
@@ -450,7 +469,7 @@ pub const UNTITLED: &str = "Untitled";
/// 会话 key 的唯一构造点:本地 `{agent}:{native_id}`,远程
/// `{agent}:{host}:{native_id}`。scanner 的墓碑查询、watcher 的幸存者反查、
/// 远程装饰器的 key 改写都走这里——"远程 key 长什么样"只此一处知识。
-/// (十四家 adapter 的本地两段构造保留各自 `format!`,它们从不涉及 host。)
+/// (十六家 adapter 的本地两段构造保留各自 `format!`,它们从不涉及 host。)
pub fn session_key(agent: AgentId, host: &str, native_id: &str) -> String {
if host.is_empty() {
format!("{}:{native_id}", agent.as_str())
diff --git a/crates/wake-core/src/remote.rs b/crates/wake-core/src/remote.rs
index 19ce37f..a189df0 100644
--- a/crates/wake-core/src/remote.rs
+++ b/crates/wake-core/src/remote.rs
@@ -16,7 +16,7 @@
//! ①openrsync(macOS 15+ 的 /usr/bin/rsync)做发送端时,某个源连父目录
//! 都不存在会让它中止整份文件列表,排在后面的源全部静默不传,退出码却
//! 只是 23;②rsync 家族只要发送端遇到任何 I/O 错误(缺源即算)就整体跳过
-//! 删除阶段——没有哪台机器十四家全装,`--delete` 就永远不会生效。
+//! 删除阶段——没有哪台机器十六家全装,`--delete` 就永远不会生效。
//!
//! 同步跑在**独立于扫描的线程**(Workbench::spawn_remote_sync):本地扫描
//! 不等网络,不可达 host 只拖慢自己;缓存落盘由 watcher 增量收编,同步
@@ -44,9 +44,12 @@ pub struct RemoteAgentLayout {
///(缺了 sqlite_ro 的 copy 梯度兜底)。字符集限 `[A-Za-z0-9._/-]`——
/// 它们不加引号直接进探测脚本(sh -c 单引号串内)与 rsync 源参数(单测卡)
pub sync_paths: &'static [&'static str],
+ /// rsync `--exclude` 模式(按文件名匹配,作用于整次同步)。凭证与本家不读的
+ /// 大索引写在自己这一行——不放全局列表,新增带凭证的 agent 在这里声明
+ pub exclude: &'static [&'static str],
}
-/// 十四家的远程布局。远程主机按 Linux/macOS 默认路径假设(两平台一致,
+/// 十六家的远程布局。远程主机按 Linux/macOS 默认路径假设(两平台一致,
/// 均为 home 相对;OpenCode 的 XDG 变体、CODEX_HOME 这类 env 覆盖在远端
/// 探测不到,阶段 1 不支持非默认远程布局)。
pub const REMOTE_LAYOUTS: &[RemoteAgentLayout] = &[
@@ -54,6 +57,7 @@ pub const REMOTE_LAYOUTS: &[RemoteAgentLayout] = &[
agent: AgentId::ClaudeCode,
mount: ".claude/projects",
sync_paths: &[".claude/projects"],
+ exclude: &[],
},
RemoteAgentLayout {
agent: AgentId::Codex,
@@ -65,22 +69,26 @@ pub const REMOTE_LAYOUTS: &[RemoteAgentLayout] = &[
".codex/state_5.sqlite",
".codex/state_5.sqlite-wal",
],
+ exclude: &[],
},
RemoteAgentLayout {
agent: AgentId::Qoder,
mount: ".qoder/projects",
sync_paths: &[".qoder/projects"],
+ exclude: &[],
},
RemoteAgentLayout {
agent: AgentId::Copilot,
// 目录层:db = <mount>/session-store.db(is_file 判据对未同步目录失真)
mount: ".copilot",
sync_paths: &[".copilot/session-store.db", ".copilot/session-store.db-wal"],
+ exclude: &[],
},
RemoteAgentLayout {
agent: AgentId::Cursor,
mount: ".cursor/projects",
sync_paths: &[".cursor/projects"],
+ exclude: &[],
},
RemoteAgentLayout {
agent: AgentId::Opencode,
@@ -92,38 +100,46 @@ pub const REMOTE_LAYOUTS: &[RemoteAgentLayout] = &[
".local/share/opencode/opencode-next.db",
".local/share/opencode/opencode-next.db-wal",
],
+ exclude: &[],
},
RemoteAgentLayout {
agent: AgentId::Kiro,
mount: ".kiro/sessions/cli",
sync_paths: &[".kiro/sessions/cli"],
+ exclude: &[],
},
RemoteAgentLayout {
agent: AgentId::Gemini,
// tmp 层:projects.json 由 parent 派生(.gemini 顶层有凭证,不整树同步)
mount: ".gemini/tmp",
sync_paths: &[".gemini/tmp", ".gemini/projects.json"],
+ exclude: &[],
},
RemoteAgentLayout {
agent: AgentId::Pi,
mount: ".pi/agent/sessions",
sync_paths: &[".pi/agent/sessions"],
+ exclude: &[],
},
RemoteAgentLayout {
agent: AgentId::Omp,
mount: ".omp/agent/sessions",
sync_paths: &[".omp/agent/sessions"],
+ exclude: &[],
},
RemoteAgentLayout {
agent: AgentId::Grok,
// sessions 目录名判据 → home=parent,summary/chat_history 都在树内
mount: ".grok/sessions",
sync_paths: &[".grok/sessions"],
+ // Grok 自家的搜索索引库,量大且 Wake 不读
+ exclude: &["session_search.sqlite*"],
},
RemoteAgentLayout {
agent: AgentId::Kimi,
mount: ".kimi-code/sessions",
sync_paths: &[".kimi-code/sessions", ".kimi-code/session_index.jsonl"],
+ exclude: &[],
},
RemoteAgentLayout {
agent: AgentId::Antigravity,
@@ -133,11 +149,30 @@ pub const REMOTE_LAYOUTS: &[RemoteAgentLayout] = &[
".gemini/antigravity-cli/conversation_summaries.db",
".gemini/antigravity-cli/conversation_summaries.db-wal",
],
+ exclude: &[],
},
RemoteAgentLayout {
agent: AgentId::Dsh,
mount: ".dsh/sessions",
sync_paths: &[".dsh/sessions"],
+ exclude: &[],
+ },
+ RemoteAgentLayout {
+ agent: AgentId::Hermes,
+ // 库所在目录层:db = <mount>/state.db(profiles 多档案不同步)
+ mount: ".hermes",
+ sync_paths: &[".hermes/state.db", ".hermes/state.db-wal"],
+ exclude: &[],
+ },
+ RemoteAgentLayout {
+ agent: AgentId::Openclaw,
+ // agents/<id>/ 整树,exclude 挡掉每个 agent 目录里的凭证:auth-profiles.json
+ // 与 openclaw-agent.sqlite(库内 auth_profile_store 表存着 API key/OAuth
+ // token,会话与凭证同库,只能整库不拉)——远程 OpenClaw 因此只覆盖旧版
+ // sessions/*.jsonl 转录
+ mount: ".openclaw/agents",
+ sync_paths: &[".openclaw/agents"],
+ exclude: &["auth-profiles.json", "openclaw-agent.sqlite*"],
},
];
@@ -219,16 +254,18 @@ fn present_remote_paths(stdout: &str) -> Vec<&'static str> {
/// 布局;`--delete` 让远程删除传播到缓存(watcher 收 Remove 后清库内行)——
/// 它只作用于各源树**内部**,整棵源消失由 sync_host 的缺席清理负责。
fn rsync_args(host: &str, dest: &Path, paths: &[&str]) -> Vec<String> {
- let mut args = vec![
- "-az".to_string(),
- "-R".to_string(),
- "--delete".to_string(),
- // Grok 自家的搜索索引库,量大且 Wake 不读
- "--exclude=session_search.sqlite*".to_string(),
+ let mut args = vec!["-az".to_string(), "-R".to_string(), "--delete".to_string()];
+ args.extend(
+ REMOTE_LAYOUTS
+ .iter()
+ .flat_map(|l| l.exclude.iter())
+ .map(|pat| format!("--exclude={pat}")),
+ );
+ args.extend([
"--timeout=120".to_string(),
"-e".to_string(),
format!("ssh {}", SSH_OPTS.join(" ")),
- ];
+ ]);
args.extend(paths.iter().map(|path| format!("{host}:./{path}")));
args.push(dest.to_string_lossy().to_string());
args
@@ -555,5 +592,18 @@ mod tests {
);
// 目标在最后
assert_eq!(args.last().unwrap(), "/tmp/cache/devbox");
+ // 各家声明的 exclude 全部落到命令行(OpenClaw 的凭证靠它挡)
+ for pat in REMOTE_LAYOUTS.iter().flat_map(|l| l.exclude.iter()) {
+ assert!(
+ args.contains(&format!("--exclude={pat}")),
+ "{pat} 未进 rsync 参数"
+ );
+ assert!(
+ pat.chars()
+ .all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '_' | '-' | '*')),
+ "exclude {pat:?} needs quoting"
+ );
+ }
+ assert!(args.contains(&"--exclude=openclaw-agent.sqlite*".to_string()));
}
}
diff --git a/crates/wake-core/src/services/terminal/macos.rs b/crates/wake-core/src/services/terminal/macos.rs
index f25e38b..d70e1d3 100644
--- a/crates/wake-core/src/services/terminal/macos.rs
+++ b/crates/wake-core/src/services/terminal/macos.rs
@@ -367,7 +367,7 @@ fn launch_kooky_cli(meta: &SessionMeta) -> ResumeOutcome {
"kooky-cli not found — update Kooky to 0.51+".into(),
);
};
- let Some((bin, (args, _))) = session_bin(meta).zip(resume_args(meta.agent, &meta.id)) else {
+ let Some((bin, (args, _))) = session_bin(meta).zip(resume_args(meta)) else {
return fail(
String::new(),
format!(
diff --git a/crates/wake-core/src/services/terminal/mod.rs b/crates/wake-core/src/services/terminal/mod.rs
index c9843ad..5867aaa 100644
--- a/crates/wake-core/src/services/terminal/mod.rs
+++ b/crates/wake-core/src/services/terminal/mod.rs
@@ -137,11 +137,14 @@ pub fn agent_bin(agent: AgentId) -> Option<&'static str> {
// dsh 官方唯一分发形态是 npx(README 只有 `npx @deepseek-ai/dsh web`,
// 不发全局命令);包名由 resume_args 作首参带上
AgentId::Dsh => Some("npx"),
+ AgentId::Hermes => Some("hermes"),
+ AgentId::Openclaw => Some("openclaw"),
}
}
-fn resume_args(agent: AgentId, id: &str) -> Option<(Vec<String>, bool)> {
- match agent {
+fn resume_args(meta: &SessionMeta) -> Option<(Vec<String>, bool)> {
+ let id = meta.id.as_str();
+ match meta.agent {
AgentId::ClaudeCode => Some((vec!["--resume".into(), id.into()], true)),
AgentId::Codex => Some((vec!["resume".into(), id.into()], false)),
// Qoder 的历史会话按 cwd 分桶,`--resume <id>` 需在原项目目录启动。
@@ -162,7 +165,24 @@ fn resume_args(agent: AgentId, id: &str) -> Option<(Vec<String>, bool)> {
// 按官方原样 `npx @deepseek-ai/dsh web` 拉起(workspace 由启动目录
// 决定),会话在 UI 里即点即续。官方发布 tui bundle 后切回定点 resume
AgentId::Dsh => Some((vec!["@deepseek-ai/dsh".into(), "web".into()], true)),
- _ => None,
+ // Hermes 会话不按 cwd 分桶(库里没有 cwd),任何目录都行;`--profile` 必带:
+ // 它显式覆盖 sticky 的 active_profile,会话在哪个档案库里就开哪个档案
+ // (主库 = "default"),否则别的档案激活期间会 "session not found"
+ AgentId::Hermes => Some((
+ vec![
+ "--profile".into(),
+ crate::adapters::hermes::profile_of(&meta.file_path),
+ "--resume".into(),
+ id.into(),
+ ],
+ false,
+ )),
+ // OpenClaw 的 TUI 只按 session **key**(agent:main:main)打开会话,
+ // `--session-id` 只有一次性的 `openclaw agent` 认;Wake 存的是 session id,
+ // 历史窗口(reset/rollover 之前的)也没有可续的 key——不提供 Open In
+ AgentId::Openclaw => None,
+ // Kiro / Gemini CLI 没有按会话 id 续会话的形制
+ AgentId::Kiro | AgentId::Gemini => None,
}
}
@@ -205,7 +225,7 @@ pub fn ssh_resume_command(meta: &SessionMeta) -> Option<String> {
if meta.host.is_empty() {
return None;
}
- let (args, _requires_cwd) = resume_args(meta.agent, &meta.id)?;
+ let (args, _requires_cwd) = resume_args(meta)?;
let bin = session_bin(meta)?;
// cwd 是远程路径,本地 is_dir 判据无意义:非空就 cd,空则落 ssh 默认 home
let cwd = (!meta.project_path.is_empty()).then_some(meta.project_path.as_str());
@@ -229,6 +249,11 @@ pub enum ResumeTarget {
}
pub fn resume_targets(meta: &SessionMeta) -> Vec<ResumeTarget> {
+ // 没有 resume 形制的 agent(OpenClaw)不列任何目标——否则菜单里每一项都是
+ // 点了才报 "isn't supported" 的死项;本地/远程两条路同源于 resume_args
+ if resume_args(meta).is_none() {
+ return Vec::new();
+ }
if meta.host.is_empty() {
terminals_for(meta.agent)
.into_iter()
@@ -248,7 +273,7 @@ pub fn resume_target(meta: &SessionMeta, target: ResumeTarget) -> ResumeOutcome
fn copy_ssh_outcome(meta: &SessionMeta) -> ResumeOutcome {
let Some(command) = ssh_resume_command(meta) else {
- // 十四家全有 resume_args,此臂当前不可达;护栏语义同 resume_session_in
+ // OpenClaw 之外全有 resume_args;护栏语义同 resume_session_in
return ResumeOutcome {
ok: false,
command: String::new(),
@@ -282,7 +307,7 @@ pub fn resume_session_in(meta: &SessionMeta, term: TerminalApp) -> ResumeOutcome
if let Some(outcome) = platform::deep_link_resume(meta, term) {
return outcome;
}
- let Some((args, requires_cwd)) = resume_args(meta.agent, &meta.id) else {
+ let Some((args, requires_cwd)) = resume_args(meta) else {
return ResumeOutcome {
ok: false,
command: String::new(),
diff --git a/crates/wake-core/tests/adapter_contracts.rs b/crates/wake-core/tests/adapter_contracts.rs
index 21e31a2..cd8fe9b 100644
--- a/crates/wake-core/tests/adapter_contracts.rs
+++ b/crates/wake-core/tests/adapter_contracts.rs
@@ -1,4 +1,4 @@
-//! 十四家 adapter 的解析契约测试:全部走公开 API(`AgentAdapter` trait),
+//! 十六家 adapter 的解析契约测试:全部走公开 API(`AgentAdapter` trait),
//! fixture 为全合成数据(tests/fixtures/,SQLite 型在临时 HOME 里现建,
//! dsh 的 zstd 日志由检入的明文 fixture 在临时 HOME 里压制)。
//!
@@ -21,8 +21,10 @@ use wake_core::adapters::cursor::CursorAdapter;
use wake_core::adapters::dsh::DshAdapter;
use wake_core::adapters::gemini::GeminiAdapter;
use wake_core::adapters::grok::GrokAdapter;
+use wake_core::adapters::hermes::HermesAdapter;
use wake_core::adapters::kimi::KimiAdapter;
use wake_core::adapters::kiro::KiroAdapter;
+use wake_core::adapters::openclaw::OpenclawAdapter;
use wake_core::adapters::opencode::OpencodeAdapter;
use wake_core::adapters::pi::PiAdapter;
use wake_core::adapters::qoder::QoderAdapter;
@@ -40,6 +42,8 @@ struct TestEnv {
opencode_next_db: PathBuf,
antigravity_db: PathBuf,
dsh_log: PathBuf,
+ hermes_db: PathBuf,
+ openclaw_db: PathBuf,
/// 假 HOME 目录本体,持有 TempDir 保证整个测试进程期间不被清理
_home: tempfile::TempDir,
}
@@ -69,12 +73,16 @@ fn setup() -> &'static TestEnv {
std::env::remove_var("XDG_DATA_HOME");
std::env::remove_var("CODEX_HOME");
std::env::remove_var("QODER_CONFIG_DIR");
+ std::env::remove_var("HERMES_HOME");
+ std::env::remove_var("OPENCLAW_STATE_DIR");
TestEnv {
copilot_db: sc.copilot_db,
opencode_db: sc.opencode_db,
opencode_next_db: sc.opencode_next_db,
antigravity_db: sc.antigravity_db,
dsh_log: sc.dsh_log,
+ hermes_db: sc.hermes_db,
+ openclaw_db: sc.openclaw_db,
_home: home,
}
})
@@ -1250,13 +1258,13 @@ fn overlapping_watch_roots_dispatch_to_deepest() {
#[test]
fn data_roots_contract() {
- // roster 单实例契约:create_adapters 返回全量十四家(不按 detect 过滤,
+ // roster 单实例契约:create_adapters 返回全量十六家(不按 detect 过滤,
// scanner 对缺根家靠各自 list_session_files 降级为空);每家必须给出
// 绝对路径的数据根——"Session locations" 面板、watch_paths 派生、按
// (agent, 根) 计数全都建立在它上面
let _env = setup();
let adapters = wake_core::adapters::create_adapters();
- assert_eq!(adapters.len(), 14, "全量 roster 必须十四家,含本机没装的");
+ assert_eq!(adapters.len(), 16, "全量 roster 必须十六家,含本机没装的");
for a in &adapters {
let tag = a.agent().as_str();
let roots = a.data_roots();
@@ -1430,12 +1438,319 @@ fn seq_contract_holds_for_all_agents() {
Box::new(DshAdapter::new()),
fs_ref(AgentId::Dsh, &env.dsh_log, "dsh-e2e4-0001"),
),
+ (
+ Box::new(HermesAdapter::new()),
+ db_ref(AgentId::Hermes, &env.hermes_db, "hs-0001"),
+ ),
+ (
+ Box::new(OpenclawAdapter::new()),
+ db_ref(AgentId::Openclaw, &env.openclaw_db, "claw-0001"),
+ ),
+ (Box::new(OpenclawAdapter::new()), openclaw_legacy_ref(env)),
];
for (adapter, r) in &checks {
assert_seq_contract(adapter.as_ref(), r);
}
}
+/// 旧版转录取假 HOME 里 stage_sidecars 拷入的那份(file_ref 只认自己根下的路径)
+fn openclaw_legacy_ref(env: &TestEnv) -> SessionFileRef {
+ let sessions = env
+ .openclaw_db
+ .parent()
+ .and_then(Path::parent)
+ .expect("openclaw agent dir")
+ .join("sessions");
+ fs_ref(
+ AgentId::Openclaw,
+ &sessions.join("cccccccc-aaaa-bbbb-cccc-000000000017.jsonl"),
+ "cccccccc-aaaa-bbbb-cccc-000000000017",
+ )
+}
+
+#[test]
+fn hermes_parse_contract() {
+ let env = setup();
+ let adapter = HermesAdapter::new();
+ // 枚举:tool 内部会话与零消息会话不列
+ let mut ids: Vec<String> = adapter
+ .list_session_files()
+ .expect("hermes list")
+ .into_iter()
+ .map(|r| r.native_id)
+ .collect();
+ ids.sort();
+ assert_eq!(ids, vec!["hs-0001", "hs-0002", "hs-0005"]);
+ // /branch 分支挂到父会话下(parent_session_id),不当顶层
+ assert!(adapter.manages_parent_links());
+ assert_eq!(
+ adapter.parent_links(),
+ vec![("hermes:hs-0005".to_string(), "hermes:hs-0001".to_string())]
+ );
+
+ let r = db_ref(AgentId::Hermes, &env.hermes_db, "hs-0001");
+ let s = adapter.parse_session(&r).expect("hermes parse_session");
+ let t = adapter
+ .parse_transcript(&r)
+ .expect("hermes parse_transcript");
+ assert_eq!(s.meta.key, "hermes:hs-0001");
+ assert_eq!(s.meta.title, "Hermes QR fix"); // 库内标题优先
+ assert_eq!(s.meta.model.as_deref(), Some("gpt-5.4"));
+ assert_eq!(s.meta.tokens_used, Some(450));
+ assert_eq!(s.meta.source, None); // cli 不打徽章
+ assert_eq!(s.meta.project_path, ""); // 库里没有 cwd
+ assert_eq!(s.meta.created_at, ms("2026-08-08T07:00:00Z"));
+ assert_eq!(s.meta.updated_at, ms("2026-08-08T07:02:00Z"));
+ assert_eq!(s.meta.message_count, 3);
+ assert!(s.meta.file_path.ends_with("#hs-0001"));
+ // assistant(tool_calls)→ tool → assistant(text) 合并成一条
+ assert_eq!(
+ roles_kinds(&t.mainline),
+ vec![
+ (Role::User, MessageKind::Text),
+ (Role::Assistant, MessageKind::Text),
+ (Role::User, MessageKind::Text),
+ ]
+ );
+ let a = &t.mainline[1];
+ assert_eq!(a.text, "是依赖数组问题,我给出了修复补丁。");
+ assert_eq!(a.thinking.as_deref(), Some("先读一下组件源码"));
+ assert_eq!(a.timestamp, Some(ms("2026-08-08T07:00:08Z")));
+ assert_eq!(a.tool_calls.len(), 1);
+ assert_eq!(a.tool_calls[0].name, "read_file");
+ // arguments 是 JSON 字符串,解开后预览才有路径
+ assert!(a.tool_calls[0].input_preview.contains("QrScanner"));
+ assert_eq!(
+ a.tool_calls[0].output.as_deref(),
+ Some("useEffect(() => watch())")
+ );
+ assert_eq!(
+ s.units.iter().map(|u| u.seq).collect::<Vec<_>>(),
+ vec![0, 1, 2]
+ );
+
+ // 无标题 → 首条用户消息;telegram 启动面成徽章;精简形状 tool_calls 无 id
+ // 按 tool_name 顺位回填;多模态 content 数组只取文本(图片退占位)
+ let r2 = db_ref(AgentId::Hermes, &env.hermes_db, "hs-0002");
+ let s2 = adapter.parse_session(&r2).expect("hermes fallback parse");
+ let t2 = adapter
+ .parse_transcript(&r2)
+ .expect("hermes fallback transcript");
+ assert_eq!(s2.meta.title, "无标题会话的兜底标题应取这句");
+ assert_eq!(s2.meta.source.as_deref(), Some("telegram"));
+ assert_eq!(s2.meta.tokens_used, None);
+ assert_eq!(s2.meta.updated_at, ms("2026-08-08T08:00:08Z")); // 无 ended_at 取末条消息
+ let a2 = &t2.mainline[1];
+ assert_eq!(a2.tool_calls.len(), 1);
+ assert_eq!(a2.tool_calls[0].name, "terminal");
+ assert_eq!(a2.tool_calls[0].output.as_deref(), Some("README.md"));
+ assert_eq!(a2.text, "好的。");
+
+ // 自定义 location:选 Hermes home(连同 profiles/*)或库文件本身都认
+ let home = env.hermes_db.parent().unwrap().to_path_buf();
+ let profile_db = home.join("profiles").join("coder").join("state.db");
+ fs::create_dir_all(profile_db.parent().unwrap()).unwrap();
+ common::build_hermes_db(&profile_db);
+ let rooted = HermesAdapter::new().with_custom_root(home.clone());
+ assert_eq!(
+ rooted.data_roots(),
+ vec![env.hermes_db.clone(), profile_db.clone()]
+ );
+ let direct = HermesAdapter::new().with_custom_root(env.hermes_db.clone());
+ assert_eq!(direct.data_roots(), vec![env.hermes_db.clone()]);
+ // resume 必须带所属档案:主库 = default,profiles/<name> = name(虚拟路径同样认)
+ use wake_core::adapters::hermes::profile_of;
+ assert_eq!(
+ profile_of(&format!("{}#hs-0001", env.hermes_db.display())),
+ "default"
+ );
+ assert_eq!(
+ profile_of(&format!("{}#hs-0001", profile_db.display())),
+ "coder"
+ );
+ fs::remove_dir_all(home.join("profiles")).unwrap();
+}
+
+/// 没被新版 Hermes 迁移过的库(schema v2:无 title、无 cache/reasoning 列、
+/// messages 无 reasoning)必须照常枚举与解析,不能整家消失
+#[test]
+fn hermes_legacy_schema_still_parses() {
+ setup();
+ let dir = tempfile::tempdir().unwrap();
+ let db = dir.path().join("state.db");
+ let conn = rusqlite::Connection::open(&db).unwrap();
+ conn.execute_batch(
+ r#"
+ CREATE TABLE sessions (
+ id TEXT PRIMARY KEY, source TEXT NOT NULL, model TEXT, parent_session_id TEXT,
+ started_at REAL NOT NULL, ended_at REAL, message_count INTEGER DEFAULT 0,
+ input_tokens INTEGER DEFAULT 0, output_tokens INTEGER DEFAULT 0
+ );
+ CREATE TABLE messages (
+ id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT NOT NULL, role TEXT NOT NULL,
+ content TEXT, tool_call_id TEXT, tool_calls TEXT, tool_name TEXT,
+ timestamp REAL NOT NULL, finish_reason TEXT
+ );
+ INSERT INTO sessions VALUES ('old-1', 'cli', 'gpt-5.4', NULL, 1786172400.0, NULL, 2, 10, 5);
+ INSERT INTO messages (session_id, role, content, timestamp) VALUES
+ ('old-1', 'user', '老库里的会话', 1786172401.0),
+ ('old-1', 'assistant', '仍要能解析', 1786172402.0);
+ "#,
+ )
+ .unwrap();
+ drop(conn);
+ let adapter = HermesAdapter::new().with_custom_root(db.clone());
+ let refs = adapter.list_session_files().expect("legacy list");
+ assert_eq!(refs.len(), 1);
+ let s = adapter.parse_session(&refs[0]).expect("legacy parse");
+ assert_eq!(s.meta.title, "老库里的会话");
+ assert_eq!(s.meta.tokens_used, Some(15));
+ assert_eq!(s.meta.message_count, 2);
+}
+
+#[test]
+fn openclaw_parse_contract() {
+ let env = setup();
+ let adapter = OpenclawAdapter::new();
+ // 枚举:库里的活跃窗口 + reset 前旧窗口 + 旧版 jsonl;子代理(spawned_by /
+ // sessions.json 的 spawnedBy)与 checkpoint 快照都不列
+ let mut ids: Vec<String> = adapter
+ .list_session_files()
+ .expect("openclaw list")
+ .into_iter()
+ .map(|r| r.native_id)
+ .collect();
+ ids.sort();
+ assert_eq!(
+ ids,
+ vec![
+ "cccccccc-aaaa-bbbb-cccc-000000000017",
+ "claw-0001",
+ "claw-0003"
+ ]
+ );
+
+ // —— 现版 SQLite:active_events 给出可见分支,死分支 a2-dead 不出现
+ let r = db_ref(AgentId::Openclaw, &env.openclaw_db, "claw-0001");
+ let s = adapter.parse_session(&r).expect("openclaw parse_session");
+ let t = adapter
+ .parse_transcript(&r)
+ .expect("openclaw parse_transcript");
+ assert_eq!(s.meta.key, "openclaw:claw-0001");
+ assert_eq!(s.meta.title, "Node label"); // 无 session_info 时取 node label
+ assert_eq!(s.meta.project_path, "/Users/tester/Github/wakefx"); // header cwd
+ assert_eq!(s.meta.model.as_deref(), Some("claude-opus-5"));
+ assert_eq!(s.meta.tokens_used, Some(7300));
+ assert_eq!(s.meta.source.as_deref(), Some("telegram"));
+ assert_eq!(s.meta.created_at, ms("2026-08-08T09:00:00Z"));
+ assert_eq!(s.meta.updated_at, ms("2026-08-08T09:00:30Z"));
+ assert_eq!(s.meta.message_count, 3);
+ assert_eq!(s.unknown_line_count, 0);
+ assert_eq!(
+ roles_kinds(&t.mainline),
+ vec![
+ (Role::User, MessageKind::Text),
+ (Role::Assistant, MessageKind::Text),
+ (Role::User, MessageKind::Text),
+ ]
+ );
+ let a = &t.mainline[1];
+ assert_eq!(a.text, "找到泄漏点,已补清理回调。");
+ assert_eq!(a.tool_calls.len(), 1);
+ assert_eq!(a.tool_calls[0].name, "exec");
+ assert!(a.tool_calls[0].is_error);
+ assert!(a.tool_calls[0]
+ .output
+ .as_deref()
+ .unwrap_or_default()
+ .contains("QrScanner"));
+ assert_eq!(
+ s.units.iter().map(|u| u.seq).collect::<Vec<_>>(),
+ vec![0, 1, 2]
+ );
+
+ // 旧窗口:无 active_events 退回树回溯;node 的 totalTokens 不归它
+ let r3 = db_ref(AgentId::Openclaw, &env.openclaw_db, "claw-0003");
+ let s3 = adapter.parse_session(&r3).expect("openclaw old window");
+ assert_eq!(s3.meta.title, "Node label");
+ assert_eq!(s3.meta.model.as_deref(), Some("gpt-5.5"));
+ assert_eq!(s3.meta.tokens_used, None);
+ assert_eq!(s3.meta.source, None); // cli 不打徽章
+ assert_eq!(s3.meta.message_count, 2);
+
+ // —— 旧版 jsonl:file_ref 只认 agents/<id>/sessions/ 下的活转录
+ let legacy = openclaw_legacy_ref(env);
+ let path = Path::new(&legacy.file_path);
+ let by_ref = adapter.file_ref(path).expect("openclaw file_ref");
+ assert_eq!(by_ref.native_id, "cccccccc-aaaa-bbbb-cccc-000000000017");
+ let checkpoint = path.with_file_name("cccccccc-aaaa-bbbb-cccc-000000000017.checkpoint.1.jsonl");
+ assert!(adapter.file_ref(&checkpoint).is_none());
+ assert!(adapter
+ .file_ref(&path.parent().unwrap().join("sessions.json"))
+ .is_none());
+
+ let s = adapter
+ .parse_session(&legacy)
+ .expect("openclaw legacy parse_session");
+ let t = adapter
+ .parse_transcript(&legacy)
+ .expect("openclaw legacy parse_transcript");
+ assert_eq!(s.meta.title, "OpenClaw QR cleanup"); // session_info 压过 sessions.json 的 label
+ assert_eq!(s.meta.project_path, "/Users/tester/Github/wakefx");
+ assert_eq!(s.meta.model.as_deref(), Some("claude-opus-5"));
+ assert_eq!(s.meta.tokens_used, Some(5200));
+ assert_eq!(s.meta.created_at, ms("2026-08-07T09:00:00Z"));
+ assert_eq!(s.meta.updated_at, ms("2026-08-07T09:00:30Z"));
+ // wibble-entry 是叶:回溯经 u3→c1→a2→r1→a1→u2→u1→i1→m1,死分支 a2-dead 不在链上;
+ // 未知类型计 1
+ assert_eq!(s.unknown_line_count, 1);
+ assert_eq!(
+ roles_kinds(&t.mainline),
+ vec![
+ (Role::User, MessageKind::Meta), // runtimeContextCarrier
+ (Role::User, MessageKind::Text),
+ (Role::Assistant, MessageKind::Text),
+ (Role::System, MessageKind::CompactSummary),
+ (Role::User, MessageKind::Text),
+ ]
+ );
+ assert_eq!(s.meta.message_count, 3);
+ let a = &t.mainline[2];
+ assert_eq!(a.text, "找到泄漏点,已补清理回调。");
+ assert_eq!(a.thinking.as_deref(), Some("先搜一下 useEffect"));
+ assert_eq!(a.tool_calls.len(), 1);
+ assert!(!a.tool_calls[0].is_error);
+ assert!(t.mainline[3].text.contains("useEffect 泄漏"));
+
+ // OpenClaw 没有 resume 形制:详情页不该给任何 Open In 目标
+ assert!(wake_core::services::terminal::resume_targets(&s.meta).is_empty());
+
+ // 自定义 location:状态目录、agents 目录都整形到 agents 层
+ let state = env
+ .openclaw_db
+ .parent()
+ .unwrap()
+ .parent()
+ .unwrap()
+ .parent()
+ .unwrap()
+ .parent()
+ .unwrap();
+ let agents = state.join("agents");
+ assert_eq!(
+ OpenclawAdapter::new()
+ .with_custom_root(state.to_path_buf())
+ .data_roots(),
+ vec![agents.clone()]
+ );
+ assert_eq!(
+ OpenclawAdapter::new()
+ .with_custom_root(agents.clone())
+ .data_roots(),
+ vec![agents]
+ );
+}
+
// ---------------------------------------------------------------- quickMeta 合并
fn mk_meta(agent: AgentId, key: &str, id: &str, title: &str, source: Option<&str>) -> SessionMeta {
@@ -1629,7 +1944,7 @@ fn agent_id_all_matches_ord_and_roster() {
fn removed_defaults_suppress_instances() {
setup();
let roster = wake_core::adapters::create_adapters_with(&[], &[AgentId::ClaudeCode]);
- assert_eq!(roster.len(), 13);
+ assert_eq!(roster.len(), 15);
assert!(roster.iter().all(|a| a.agent() != AgentId::ClaudeCode));
let dir = tempfile::tempdir().unwrap();
@@ -1927,13 +2242,13 @@ fn adapter_ix_for_routes_to_owning_instance() {
let custom = dir.path().to_path_buf();
let roster =
wake_core::adapters::create_adapters_with(&[(AgentId::ClaudeCode, custom.clone())], &[]);
- assert_eq!(roster.len(), 15, "14 默认 + 1 自定义");
- assert_eq!(roster[14].agent(), AgentId::ClaudeCode);
+ assert_eq!(roster.len(), 17, "16 默认 + 1 自定义");
+ assert_eq!(roster[16].agent(), AgentId::ClaudeCode);
let under = format!("{}/projects/p/x.jsonl", custom.display());
assert_eq!(
wake_core::adapters::adapter_ix_for(&roster, AgentId::ClaudeCode, &under),
- Some(14),
+ Some(16),
"自定义根下的文件应路由到自定义实例"
);
// 兄弟目录(裸前缀)不得吸入
@@ -1966,7 +2281,7 @@ fn remote_adapters_stay_inside_cache_and_rewrite_keys() {
let empty = tempfile::tempdir().unwrap();
let adapters =
wake_core::adapters::remote::create_remote_adapters(&templates, "devbox", empty.path());
- assert_eq!(adapters.len(), 14, "每家一个远程实例");
+ assert_eq!(adapters.len(), 16, "每家一个远程实例");
let cache_prefix = empty.path().to_string_lossy().to_string();
for adapter in &adapters {
assert_eq!(adapter.host(), "devbox");
@@ -2142,7 +2457,7 @@ fn roster_appends_remote_instances_for_enabled_hosts() {
store.add_remote_host("devbox").unwrap();
let roster = wake_core::adapters::create_adapter_roster_for(&store);
- assert_eq!(roster.active.len(), local_n + 14, "每家一个远程实例");
+ assert_eq!(roster.active.len(), local_n + 16, "每家一个远程实例");
assert_eq!(
roster.locations.len(),
locations_n,
@@ -2153,7 +2468,7 @@ fn roster_appends_remote_instances_for_enabled_hosts() {
.iter()
.filter(|a| a.host() == "devbox")
.count();
- assert_eq!(remote_count, 14);
+ assert_eq!(remote_count, 16);
// 顺序契约:默认实例在前,"按 agent 找第一个"的兜底不受远程影响
assert!(roster.active[..local_n].iter().all(|a| a.host().is_empty()));
diff --git a/crates/wake-core/tests/common/mod.rs b/crates/wake-core/tests/common/mod.rs
index 884dbb9..296f906 100644
--- a/crates/wake-core/tests/common/mod.rs
+++ b/crates/wake-core/tests/common/mod.rs
@@ -53,6 +53,8 @@ pub struct Sidecars {
pub opencode_next_db: PathBuf,
pub antigravity_db: PathBuf,
pub dsh_log: PathBuf,
+ pub hermes_db: PathBuf,
+ pub openclaw_db: PathBuf,
}
/// 侧档与 SQLite 型 fixture 库:copilot/opencode(两代)/antigravity 现建库,
@@ -125,15 +127,154 @@ pub fn stage_sidecars(home: &Path) -> Sidecars {
)
.expect("write dsh subagent log");
+ let hermes_dir = home.join(".hermes");
+ fs::create_dir_all(&hermes_dir).expect("mkdir .hermes");
+ let hermes_db = hermes_dir.join("state.db");
+ build_hermes_db(&hermes_db);
+
+ // openclaw:现版库与旧版 jsonl(检入 fixture)同在一个 agent 目录——两代
+ // 存储并存是真机形态(doctor --fix 迁库后旧转录仍留在 sessions/)
+ let claw_agent = home.join(".openclaw").join("agents").join("main");
+ copy_tree(
+ &fixture("openclaw/agents/main/sessions"),
+ &claw_agent.join("sessions"),
+ );
+ let claw_dir = claw_agent.join("agent");
+ fs::create_dir_all(&claw_dir).expect("mkdir openclaw agent dir");
+ let openclaw_db = claw_dir.join("openclaw-agent.sqlite");
+ build_openclaw_db(&openclaw_db);
+
Sidecars {
copilot_db,
opencode_db,
opencode_next_db,
antigravity_db,
dsh_log,
+ hermes_db,
+ openclaw_db,
}
}
+/// Hermes `state.db` 最小同构库:sessions + messages(时间戳 unix 秒 REAL)。
+/// hs-0001 有用户标题、OpenAI 形状的 tool_calls 与 reasoning;hs-0002 无标题
+///(回退首条用户消息)、telegram 启动面、精简形状 tool_calls(无 id,按顺位回填)、
+/// 多模态 content 是 JSON 块数组;hs-0003 是 session_search 工具内部会话
+///(source=tool,不列);hs-0004 零消息(不列);hs-0005 是 hs-0001 的 /branch 分支
+///(parent_session_id,照常列出、挂父子关系)。
+pub fn build_hermes_db(path: &Path) {
+ let conn = rusqlite::Connection::open(path).expect("create hermes fixture db");
+ conn.execute_batch(
+ r#"
+ CREATE TABLE sessions (
+ id TEXT PRIMARY KEY, source TEXT NOT NULL, user_id TEXT, model TEXT,
+ model_config TEXT, system_prompt TEXT, parent_session_id TEXT,
+ started_at REAL NOT NULL, ended_at REAL, end_reason TEXT,
+ message_count INTEGER DEFAULT 0, tool_call_count INTEGER DEFAULT 0,
+ input_tokens INTEGER DEFAULT 0, output_tokens INTEGER DEFAULT 0,
+ cache_read_tokens INTEGER DEFAULT 0, cache_write_tokens INTEGER DEFAULT 0,
+ reasoning_tokens INTEGER DEFAULT 0, title TEXT
+ );
+ CREATE TABLE messages (
+ id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT NOT NULL,
+ role TEXT NOT NULL, content TEXT, tool_call_id TEXT, tool_calls TEXT,
+ tool_name TEXT, timestamp REAL NOT NULL, token_count INTEGER,
+ finish_reason TEXT, reasoning TEXT, reasoning_details TEXT,
+ codex_reasoning_items TEXT
+ );
+ INSERT INTO sessions (id, source, model, started_at, ended_at, message_count,
+ input_tokens, output_tokens, cache_read_tokens, title) VALUES
+ ('hs-0001', 'cli', 'gpt-5.4', 1786172400.0, 1786172520.0, 4, 300, 50, 100, 'Hermes QR fix'),
+ ('hs-0002', 'telegram', 'claude-opus-5', 1786176000.0, NULL, 3, 0, 0, 0, NULL),
+ ('hs-0003', 'tool', 'gpt-5.4', 1786176100.0, 1786176101.0, 2, 0, 0, 0, NULL),
+ ('hs-0004', 'cli', 'gpt-5.4', 1786176200.0, 1786176201.0, 0, 0, 0, 0, NULL);
+ INSERT INTO sessions (id, source, model, started_at, ended_at, message_count, parent_session_id, title) VALUES
+ ('hs-0005', 'cli', 'gpt-5.4', 1786176300.0, 1786176301.0, 1, 'hs-0001', 'Hermes QR fix #2');
+ INSERT INTO messages (session_id, role, content, tool_call_id, tool_calls, tool_name, timestamp, reasoning) VALUES
+ ('hs-0001', 'user', 'Hermes 看看二维码扫描为何闪退,是不是 useEffect() 的问题', NULL, NULL, NULL, 1786172405.0, NULL),
+ ('hs-0001', 'assistant', NULL, NULL,
+ '[{"id":"call_h1","type":"function","function":{"name":"read_file","arguments":"{\"path\":\"src/QrScanner.tsx\"}"}}]',
+ NULL, 1786172408.0, '先读一下组件源码'),
+ ('hs-0001', 'tool', 'useEffect(() => watch())', 'call_h1', NULL, 'read_file', 1786172409.0, NULL),
+ ('hs-0001', 'assistant', '是依赖数组问题,我给出了修复补丁。', NULL, NULL, NULL, 1786172412.0, NULL),
+ ('hs-0001', 'user', '谢谢,合并了', NULL, NULL, NULL, 1786172520.0, NULL),
+ ('hs-0002', 'user', '[{"type":"text","text":"无标题会话的兜底标题应取这句"},{"type":"image_url","image_url":{"url":"file:///tmp/a.png"}}]', NULL, NULL, NULL, 1786176005.0, NULL),
+ ('hs-0002', 'assistant', NULL, NULL, '[{"name":"terminal","arguments":"{\"command\":\"ls\"}"}]', NULL, 1786176006.0, NULL),
+ ('hs-0002', 'tool', 'README.md', NULL, NULL, 'terminal', 1786176007.0, NULL),
+ ('hs-0002', 'assistant', '好的。', NULL, NULL, NULL, 1786176008.0, NULL),
+ ('hs-0003', 'user', 'internal search', NULL, NULL, NULL, 1786176100.5, NULL),
+ ('hs-0005', 'user', 'branched from hs-0001', NULL, NULL, NULL, 1786176300.5, NULL),
+ ('hs-0003', 'assistant', 'nothing', NULL, NULL, NULL, 1786176101.0, NULL);
+ "#,
+ )
+ .expect("populate hermes fixture db");
+}
+
+/// OpenClaw `openclaw-agent.sqlite` 最小同构库:session_nodes + session_windows +
+/// transcript_events + session_transcript_active_events(列集只取 Wake 读的)。
+/// claw-0001 是活跃窗口:事件树里塞了一条被回滚的死分支(a2-dead),
+/// active_events 只列可见分支;claw-0002 是被 spawn 的子代理窗口(不列);
+/// claw-0003 是 reset 前的旧窗口,node 指向 claw-0001,无 active_events
+///(退回树回溯),entry_json 的 totalTokens 不归它。
+pub fn build_openclaw_db(path: &Path) {
+ let conn = rusqlite::Connection::open(path).expect("create openclaw fixture db");
+ conn.execute_batch(
+ r#"
+ CREATE TABLE session_nodes (
+ session_key TEXT NOT NULL PRIMARY KEY, current_session_id TEXT NOT NULL,
+ entry_json TEXT NOT NULL, updated_at INTEGER NOT NULL, label TEXT,
+ display_name TEXT, spawned_by TEXT, parent_session_key TEXT, archived_at INTEGER
+ );
+ CREATE TABLE session_windows (
+ session_id TEXT NOT NULL PRIMARY KEY, session_key TEXT NOT NULL,
+ created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL,
+ transcript_updated_at INTEGER, started_at INTEGER, model TEXT,
+ model_provider TEXT, channel TEXT, chat_type TEXT, spawned_by TEXT,
+ parent_session_key TEXT, display_name TEXT
+ );
+ CREATE TABLE transcript_events (
+ session_id TEXT NOT NULL, seq INTEGER NOT NULL, event_json TEXT NOT NULL,
+ created_at INTEGER NOT NULL, PRIMARY KEY (session_id, seq)
+ );
+ CREATE TABLE session_transcript_active_events (
+ session_id TEXT NOT NULL, active_position INTEGER NOT NULL,
+ event_seq INTEGER NOT NULL, message_position INTEGER,
+ PRIMARY KEY (session_id, active_position)
+ );
+ INSERT INTO session_nodes VALUES
+ ('agent:main:main', 'claw-0001',
+ '{"sessionId":"claw-0001","updatedAt":1786266030000,"model":"claude-opus-5","totalTokens":7300,"label":"Node label"}',
+ 1786266030000, 'Node label', NULL, NULL, NULL, NULL),
+ ('agent:main:subagent:sub1', 'claw-0002',
+ '{"sessionId":"claw-0002","updatedAt":1786266100000,"spawnedBy":"agent:main:main"}',
+ 1786266100000, NULL, NULL, 'agent:main:main', 'agent:main:main', NULL);
+ INSERT INTO session_windows VALUES
+ ('claw-0001', 'agent:main:main', 1786266000000, 1786266030000, 1786266030000, 1786266000000,
+ 'claude-opus-5', 'anthropic', 'telegram', 'direct', NULL, NULL, NULL),
+ ('claw-0002', 'agent:main:subagent:sub1', 1786266100000, 1786266100000, 1786266100000, 1786266100000,
+ 'claude-opus-5', 'anthropic', NULL, NULL, 'agent:main:main', 'agent:main:main', NULL),
+ ('claw-0003', 'agent:main:main', 1786176000000, 1786176030000, 1786176030000, 1786176000000,
+ 'gpt-5.5', 'openai', 'cli', 'direct', NULL, NULL, NULL);
+ INSERT INTO transcript_events VALUES
+ ('claw-0001', 0, '{"type":"session","version":3,"id":"claw-0001","timestamp":"2026-08-08T09:00:00.000Z","cwd":"/Users/tester/Github/wakefx"}', 1786266000000),
+ ('claw-0001', 1, '{"type":"message","id":"u1","parentId":null,"timestamp":"2026-08-08T09:00:05.000Z","message":{"role":"user","content":"OpenClaw 库里的会话:查二维码组件 useEffect() 清理","timestamp":1786266005000}}', 1786266005000),
+ ('claw-0001', 2, '{"type":"message","id":"a1","parentId":"u1","timestamp":"2026-08-08T09:00:08.000Z","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_db_1","name":"exec","arguments":{"command":"rg useEffect src/"}}],"api":"anthropic-messages","provider":"anthropic","model":"claude-opus-5","usage":{"input":100,"output":20,"cacheRead":0,"cacheWrite":0,"totalTokens":7100},"timestamp":1786266008000}}', 1786266008000),
+ ('claw-0001', 3, '{"type":"message","id":"r1","parentId":"a1","timestamp":"2026-08-08T09:00:09.000Z","message":{"role":"toolResult","toolCallId":"call_db_1","toolName":"exec","content":[{"type":"text","text":"src/QrScanner.tsx: useEffect(() => watch())"}],"isError":true,"timestamp":1786266009000}}', 1786266009000),
+ ('claw-0001', 4, '{"type":"message","id":"a2-dead","parentId":"r1","timestamp":"2026-08-08T09:00:11.000Z","message":{"role":"assistant","content":[{"type":"text","text":"死分支,不该出现"}],"api":"anthropic-messages","provider":"anthropic","model":"claude-opus-5","timestamp":1786266011000}}', 1786266011000),
+ ('claw-0001', 5, '{"type":"message","id":"a2","parentId":"r1","timestamp":"2026-08-08T09:00:12.000Z","message":{"role":"assistant","content":[{"type":"text","text":"找到泄漏点,已补清理回调。"}],"api":"anthropic-messages","provider":"anthropic","model":"claude-opus-5","usage":{"input":200,"output":30,"cacheRead":0,"cacheWrite":0,"totalTokens":7300},"timestamp":1786266012000}}', 1786266012000),
+ ('claw-0001', 6, '{"type":"message","id":"u2","parentId":"a2","timestamp":"2026-08-08T09:00:30.000Z","message":{"role":"user","content":"谢谢,合并了","timestamp":1786266030000}}', 1786266030000),
+ ('claw-0002', 0, '{"type":"session","version":3,"id":"claw-0002","timestamp":"2026-08-08T09:01:40.000Z","cwd":"/Users/tester/Github/wakefx"}', 1786266100000),
+ ('claw-0002', 1, '{"type":"message","id":"u1","parentId":null,"timestamp":"2026-08-08T09:01:41.000Z","message":{"role":"user","content":"child task","timestamp":1786266101000}}', 1786266101000),
+ ('claw-0003', 0, '{"type":"session","version":3,"id":"claw-0003","timestamp":"2026-08-07T08:00:00.000Z","cwd":"/Users/tester/Github/wakefx"}', 1786176000000),
+ ('claw-0003', 1, '{"type":"message","id":"u1","parentId":null,"timestamp":"2026-08-07T08:00:05.000Z","message":{"role":"user","content":"reset 之前的老窗口","timestamp":1786176005000}}', 1786176005000),
+ ('claw-0003', 2, '{"type":"message","id":"a1","parentId":"u1","timestamp":"2026-08-07T08:00:30.000Z","message":{"role":"assistant","content":[{"type":"text","text":"收到。"}],"api":"openai-responses","provider":"openai","model":"gpt-5.5","timestamp":1786176030000}}', 1786176030000);
+ INSERT INTO session_transcript_active_events VALUES
+ ('claw-0001', 0, 1, 0), ('claw-0001', 1, 2, 1), ('claw-0001', 2, 3, 2),
+ ('claw-0001', 3, 5, 3), ('claw-0001', 4, 6, 4);
+ "#,
+ )
+ .expect("populate openclaw fixture db");
+}
+
/// Copilot `session-store.db` 最小同构库:sessions + turns。
/// cop-0002 的 summary 为空,验证标题回退首条用户消息。
pub fn build_copilot_db(path: &Path) {
diff --git a/crates/wake-core/tests/fixtures/openclaw/agents/main/sessions/cccccccc-aaaa-bbbb-cccc-000000000017.checkpoint.1.jsonl b/crates/wake-core/tests/fixtures/openclaw/agents/main/sessions/cccccccc-aaaa-bbbb-cccc-000000000017.checkpoint.1.jsonl
new file mode 100644
index 0000000..a71b9b1
--- /dev/null
+++ b/crates/wake-core/tests/fixtures/openclaw/agents/main/sessions/cccccccc-aaaa-bbbb-cccc-000000000017.checkpoint.1.jsonl
@@ -0,0 +1 @@
+{"type":"session","version":3,"id":"cccccccc-aaaa-bbbb-cccc-000000000017","timestamp":"2026-08-07T09:00:00.000Z","cwd":"/Users/tester/Github/wakefx"}
diff --git a/crates/wake-core/tests/fixtures/openclaw/agents/main/sessions/cccccccc-aaaa-bbbb-cccc-000000000017.jsonl b/crates/wake-core/tests/fixtures/openclaw/agents/main/sessions/cccccccc-aaaa-bbbb-cccc-000000000017.jsonl
new file mode 100644
index 0000000..b12a793
--- /dev/null
+++ b/crates/wake-core/tests/fixtures/openclaw/agents/main/sessions/cccccccc-aaaa-bbbb-cccc-000000000017.jsonl
@@ -0,0 +1,12 @@
+{"type":"session","version":3,"id":"cccccccc-aaaa-bbbb-cccc-000000000017","timestamp":"2026-08-07T09:00:00.000Z","cwd":"/Users/tester/Github/wakefx"}
+{"type":"model_change","id":"m1","parentId":null,"timestamp":"2026-08-07T09:00:01.000Z","provider":"anthropic","modelId":"claude-opus-5"}
+{"type":"session_info","id":"i1","parentId":"m1","timestamp":"2026-08-07T09:00:01.500Z","name":"OpenClaw QR cleanup"}
+{"type":"message","id":"u1","parentId":"i1","timestamp":"2026-08-07T09:00:05.000Z","message":{"role":"user","content":"[runtime] Current time: 2026-08-07 09:00 UTC","timestamp":1786179605000,"runtimeContextCarrier":true}}
+{"type":"message","id":"u2","parentId":"u1","timestamp":"2026-08-07T09:00:06.000Z","message":{"role":"user","content":[{"type":"text","text":"OpenClaw 看看二维码组件的 useEffect() 清理"}],"timestamp":1786179606000}}
+{"type":"message","id":"a1","parentId":"u2","timestamp":"2026-08-07T09:00:08.000Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"先搜一下 useEffect"},{"type":"toolCall","id":"call_claw_1","name":"exec","arguments":{"command":"rg useEffect src/"}}],"api":"anthropic-messages","provider":"anthropic","model":"claude-opus-5","usage":{"input":100,"output":20,"cacheRead":0,"cacheWrite":0,"totalTokens":5100},"timestamp":1786179608000}}
+{"type":"message","id":"r1","parentId":"a1","timestamp":"2026-08-07T09:00:09.000Z","message":{"role":"toolResult","toolCallId":"call_claw_1","toolName":"exec","content":[{"type":"text","text":"src/QrScanner.tsx: useEffect(() => watch())"}],"isError":false,"timestamp":1786179609000}}
+{"type":"message","id":"a2","parentId":"r1","timestamp":"2026-08-07T09:00:12.000Z","message":{"role":"assistant","content":[{"type":"text","text":"找到泄漏点,已补清理回调。"}],"api":"anthropic-messages","provider":"anthropic","model":"claude-opus-5","usage":{"input":200,"output":30,"cacheRead":0,"cacheWrite":0,"totalTokens":5200},"timestamp":1786179612000}}
+{"type":"message","id":"a2-dead","parentId":"r1","timestamp":"2026-08-07T09:00:11.000Z","message":{"role":"assistant","content":[{"type":"text","text":"这条是被回滚掉的旧分支,不该出现"}],"api":"anthropic-messages","provider":"anthropic","model":"claude-opus-5","timestamp":1786179611000}}
+{"type":"compaction","id":"c1","parentId":"a2","timestamp":"2026-08-07T09:00:20.000Z","summary":"之前的对话:排查二维码组件 useEffect 泄漏并修复","firstKeptEntryId":"u2","tokensBefore":5200}
+{"type":"message","id":"u3","parentId":"c1","timestamp":"2026-08-07T09:00:30.000Z","message":{"role":"user","content":"谢谢,合并了","timestamp":1786179630000}}
+{"type":"wibble-entry","id":"x1","parentId":"u3","timestamp":"2026-08-07T09:00:31.000Z"}
diff --git a/crates/wake-core/tests/fixtures/openclaw/agents/main/sessions/dddddddd-aaaa-bbbb-cccc-000000000018.jsonl b/crates/wake-core/tests/fixtures/openclaw/agents/main/sessions/dddddddd-aaaa-bbbb-cccc-000000000018.jsonl
new file mode 100644
index 0000000..f191fda
--- /dev/null
+++ b/crates/wake-core/tests/fixtures/openclaw/agents/main/sessions/dddddddd-aaaa-bbbb-cccc-000000000018.jsonl
@@ -0,0 +1,2 @@
+{"type":"session","version":3,"id":"dddddddd-aaaa-bbbb-cccc-000000000018","timestamp":"2026-08-07T10:00:00.000Z","cwd":"/Users/tester/Github/wakefx"}
+{"type":"message","id":"u1","parentId":null,"timestamp":"2026-08-07T10:00:05.000Z","message":{"role":"user","content":"child task from the orchestrator","timestamp":1786183205000}}
diff --git a/crates/wake-core/tests/fixtures/openclaw/agents/main/sessions/sessions.json b/crates/wake-core/tests/fixtures/openclaw/agents/main/sessions/sessions.json
new file mode 100644
index 0000000..d0d6732
--- /dev/null
+++ b/crates/wake-core/tests/fixtures/openclaw/agents/main/sessions/sessions.json
@@ -0,0 +1,4 @@
+{
+ "agent:main:main": {"sessionId":"cccccccc-aaaa-bbbb-cccc-000000000017","updatedAt":1786179630000,"label":"legacy label loses to session_info","model":"claude-opus-5","totalTokens":5200,"chatType":"direct"},
+ "agent:main:subagent:dddddddd": {"sessionId":"dddddddd-aaaa-bbbb-cccc-000000000018","updatedAt":1786183205000,"spawnedBy":"agent:main:main","label":"child"}
+}
diff --git a/crates/wake-core/tests/remote_sync.rs b/crates/wake-core/tests/remote_sync.rs
index 6e5b162..97f4f5e 100644
--- a/crates/wake-core/tests/remote_sync.rs
+++ b/crates/wake-core/tests/remote_sync.rs
@@ -121,7 +121,13 @@ fn remote_pipeline_end_to_end() {
// 开发机的真实数据;env 根覆盖一并清掉
std::env::set_var("WAKE_HOME", &local_home);
std::env::set_var("HOME", &local_home);
- for var in ["XDG_DATA_HOME", "CODEX_HOME", "QODER_CONFIG_DIR"] {
+ for var in [
+ "XDG_DATA_HOME",
+ "CODEX_HOME",
+ "QODER_CONFIG_DIR",
+ "HERMES_HOME",
+ "OPENCLAW_STATE_DIR",
+ ] {
std::env::remove_var(var);
}
build_remote_home(&home);
@@ -177,7 +183,7 @@ fn remote_pipeline_end_to_end() {
"SQLite 型的文件源没到"
);
- // ② 真实 roster + 全量扫描:十三家远程会话以三段 key 入库,host/id/file_path 都对
+ // ② 真实 roster + 全量扫描:十五家远程会话以三段 key 入库,host/id/file_path 都对
let roster = create_adapter_roster_for(&store);
run_scan(&roster.active, &store, &NullEvents, true).expect("scan ok");
let all = SessionFilter {
@@ -316,7 +322,13 @@ fn live_remote_host() {
fs::create_dir_all(&local_home).unwrap();
// 本地 roster 指向空 home(HOME 保留,ssh 要读 ~/.ssh)
std::env::set_var("WAKE_HOME", &local_home);
- for var in ["XDG_DATA_HOME", "CODEX_HOME", "QODER_CONFIG_DIR"] {
+ for var in [
+ "XDG_DATA_HOME",
+ "CODEX_HOME",
+ "QODER_CONFIG_DIR",
+ "HERMES_HOME",
+ "OPENCLAW_STATE_DIR",
+ ] {
std::env::remove_var(var);
}
let store = Arc::new(Store::open(&tmp.path().join("wake.db")).unwrap());
diff --git a/crates/wake/assets/brands/hermes-light.png b/crates/wake/assets/brands/hermes-light.png
new file mode 100644
index 0000000..b6a10b7
Binary files /dev/null and b/crates/wake/assets/brands/hermes-light.png differ
diff --git a/crates/wake/assets/brands/hermes.png b/crates/wake/assets/brands/hermes.png
new file mode 100644
index 0000000..d46cac9
Binary files /dev/null and b/crates/wake/assets/brands/hermes.png differ
diff --git a/crates/wake/assets/brands/openclaw.png b/crates/wake/assets/brands/openclaw.png
new file mode 100644
index 0000000..eb1ff4e
Binary files /dev/null and b/crates/wake/assets/brands/openclaw.png differ
diff --git a/crates/wake/src/assets.rs b/crates/wake/src/assets.rs
index 7a96926..37c1ed0 100644
--- a/crates/wake/src/assets.rs
+++ b/crates/wake/src/assets.rs
@@ -56,6 +56,9 @@ brands!(
"kimi-light",
"antigravity",
"deepseek",
+ "hermes",
+ "hermes-light",
+ "openclaw",
);
fn lookup_product(path: &str) -> Option<&'static [u8]> {
diff --git a/crates/wake/src/workbench.rs b/crates/wake/src/workbench.rs
index 8a3d8e3..13dfc1d 100644
--- a/crates/wake/src/workbench.rs
+++ b/crates/wake/src/workbench.rs
@@ -2118,7 +2118,7 @@ impl UsageBoard {
}
}
- /// Agents 全量列出(总共十四家);项目/模型长尾长,取前 6
+ /// Agents 全量列出(总共十六家);项目/模型长尾长,取前 6
fn limit(self) -> usize {
match self {
Self::Agents => usize::MAX,
@@ -6188,7 +6188,11 @@ impl Workbench {
h_flex()
.flex_shrink_0()
.gap(SPACE_XS)
- .child(if let [terminal::ResumeTarget::CopySshCommand] =
+ .child(if terminal::resume_targets(&meta).is_empty() {
+ // 没有 resume 形制的 agent(OpenClaw 的 TUI 只按 session
+ // key 开会话):不画 Open In,别给一组点了才报错的死按钮
+ div().into_any_element()
+ } else if let [terminal::ResumeTarget::CopySshCommand] =
terminal::resume_targets(&meta).as_slice()
{
// 远程会话(阶段 1 只有 Copy SSH command):单段控件用
@@ -6219,7 +6223,14 @@ impl Workbench {
// 目标的应用图标,点击直开;右段 chevron 展开列表。
// 目标列表按 agent 过滤(Kooky 深链不认 dsh);
// 偏好目标不在列表时(如 dsh 会话 + 偏好 Kooky)回退首项
- let terms = terminal::terminals_for(meta.agent);
+ let terms: Vec<terminal::TerminalApp> =
+ terminal::resume_targets(&meta)
+ .into_iter()
+ .filter_map(|t| match t {
+ terminal::ResumeTarget::App(app) => Some(app),
+ _ => None,
+ })
+ .collect();
let current = self.open_in_target(meta.agent, &terms);
let current_icon = current
.and_then(|t| self.terminal_icons.get(t.id()).cloned());