Skip to content

armgit / Wake

Public Imported from GitHub
0

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

Rust

fix(kimi): show CLI replies, forks and archive state; read JSONL safely

Corey Chiu268ea9831ef5
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7761e6f..62daf39 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,10 @@
- New: Enlarge the whole interface to 110%, 125% or 150% with ⌘+ / ⌘− / ⌘0 (Ctrl on Linux and Windows), the new View menu, or the new Settings → Appearance page, which also takes over the light / dark choice from General; the level is remembered (#51, thanks @kyomind)
- New: Antigravity conversations are read in full from the plain-text transcripts recent versions of the desktop app and the IDE save — messages, thinking, tool calls with their output, the model and pasted images — and conversations from the IDE carry an IDE badge. Conversations without a transcript are still listed from Antigravity's index, as before. The agent is now called Antigravity instead of Antigravity CLI (#52, thanks @iroha3)
- Fix: Kimi Code sessions are listed on Windows, and sessions from the Kimi Code desktop app show the assistant's replies and thinking instead of only your prompts (#61, thanks @noohpyt)
+- Fix: Kimi Code CLI sessions show the assistant's replies, thinking and tool calls too, and background-task notifications and other system messages no longer appear as things you typed
+- Fix: Forked Kimi Code sessions are listed under the session they came from without repeating its history, archived Kimi sessions are marked archived, renaming or archiving a session in Kimi shows up in Wake right away, sessions imported from the old kimi-cli are listed, and `KIMI_CODE_HOME` is respected
+- Fix: On Windows, Cursor and Gemini CLI sessions update live again, and Claude Code sub-agent transcripts no longer flash up as empty sessions
+- Fix: A session file that can't be read (on a disconnected drive, for example) no longer stalls a refresh; Wake keeps what it already had and tries again next time. One agent whose data can't be read also no longer stops the others from refreshing
## [0.8.6] — 2026-10-01
diff --git a/README.md b/README.md
index a8236aa..c2fa11f 100644
--- a/README.md
+++ b/README.md
@@ -43,7 +43,7 @@ Your agent history is scattered across `~/.claude`, `~/.codex`, and a dozen othe
| Pi | `~/.pi/agent/sessions/**/*.jsonl` | ✅ | — |
| Oh My Pi | `~/.omp/agent/sessions/**/*.jsonl` | ✅ | — |
| Grok Build | `~/.grok/sessions/**/updates.jsonl` | ✅ | — |
-| Kimi Code | `~/.kimi-code/sessions/**/wire.jsonl` | — | — |
+| Kimi Code | `~/.kimi-code/sessions/**/wire.jsonl` (CLI and desktop app; `KIMI_CODE_HOME` is respected) | — | — |
| Antigravity | `~/.gemini/antigravity/brain` and `~/.gemini/antigravity-ide/brain` (the plain-text transcripts recent versions of the desktop app and the IDE write, pasted images included) + `~/.gemini/antigravity-cli/conversation_summaries.db` (the conversation index shared by the CLI, desktop app and IDE; a conversation with no transcript on disk is listed from it as a summary card, since its body is stored encrypted) | ✅ | ✅ |
| DeepSeek Harness (`dsh`) | `~/.dsh/sessions/**/session[.vN].jsonl[.zstd]` (the newest log format generation is read; zstd-compressed logs are decoded transparently) | ✅ | — |
| Hermes Agent | `~/.hermes/state.db` + `profiles/*/state.db` (`HERMES_HOME` is respected) | ✅ | ✅ |
diff --git a/crates/wake-core/src/adapters/antigravity.rs b/crates/wake-core/src/adapters/antigravity.rs
index 36526ba..d097f05 100644
--- a/crates/wake-core/src/adapters/antigravity.rs
+++ b/crates/wake-core/src/adapters/antigravity.rs
@@ -6,7 +6,7 @@ use anyhow::{anyhow, Result};
use serde_json::Value;
use std::borrow::Cow;
use std::collections::HashMap;
-use std::io::{BufRead, BufReader};
+use std::io::BufReader;
use std::path::{Path, PathBuf};
use std::sync::Arc;
@@ -410,15 +410,8 @@ fn read_transcript(path: &Path, decode_images: bool) -> Result<Transcript> {
let mut turn = Turn::default();
let mut document = None;
- for line in reader.lines() {
- let Ok(line) = line else {
- t.unknown_lines += 1;
- continue;
- };
- if line.trim().is_empty() {
- continue;
- }
- let Ok(row) = serde_json::from_str::<Value>(&line) else {
+ for row in jsonl_values(reader) {
+ let Some(row) = row? else {
t.unknown_lines += 1;
continue;
};
diff --git a/crates/wake-core/src/adapters/claude.rs b/crates/wake-core/src/adapters/claude.rs
index 1f2fb46..b8a44b4 100644
--- a/crates/wake-core/src/adapters/claude.rs
+++ b/crates/wake-core/src/adapters/claude.rs
@@ -5,7 +5,7 @@ use anyhow::Result;
use serde_json::Value;
use std::collections::HashMap;
use std::fs;
-use std::io::{BufRead, BufReader};
+use std::io::BufReader;
use std::path::{Path, PathBuf};
/// Claude JSONL 已知的非消息行类型,静默跳过(不计 unknown)
@@ -209,23 +209,10 @@ fn parse_claude_jsonl(
let mut unknown_lines: u32 = 0;
let mut pending: Option<PendingAssistant> = None;
- for line in reader.lines() {
- let line = match line {
- Ok(l) => l,
- Err(_) => {
- unknown_lines += 1;
- continue;
- }
- };
- if line.trim().is_empty() {
+ for row in jsonl_values(reader) {
+ let Some(row) = row? else {
+ unknown_lines += 1;
continue;
- }
- let row: Value = match serde_json::from_str(&line) {
- Ok(v) => v,
- Err(_) => {
- unknown_lines += 1;
- continue;
- }
};
let typ = row.get("type").and_then(|v| v.as_str()).unwrap_or("");
@@ -697,9 +684,11 @@ impl AgentAdapter for ClaudeAdapter {
}
fn file_ref(&self, path: &Path) -> Option<SessionFileRef> {
- let p = path.to_string_lossy();
- // subagents 转录与 memory 边车不是主会话
- if p.contains("/subagents/") || p.contains("/memory/") {
+ // subagents 转录与 memory 边车不是主会话。按所在目录的名字判:按路径分段,Windows 的
+ // 反斜杠路径一样认(原先拿带 `/` 的字符串去比,watcher 报来的路径一条都对不上);只看
+ // 直接所在的目录,数据根上层恰好有叫 memory / subagents 的目录也不误伤
+ let parent = path.parent()?.file_name()?;
+ if parent == "subagents" || parent == "memory" {
return None;
}
default_file_ref(self.agent(), path)
diff --git a/crates/wake-core/src/adapters/codebuddy.rs b/crates/wake-core/src/adapters/codebuddy.rs
index 31f8537..2e631a2 100644
--- a/crates/wake-core/src/adapters/codebuddy.rs
+++ b/crates/wake-core/src/adapters/codebuddy.rs
@@ -5,7 +5,7 @@ use anyhow::Result;
use serde_json::Value;
use std::collections::HashMap;
use std::fs;
-use std::io::{BufRead, BufReader};
+use std::io::BufReader;
use std::path::{Path, PathBuf};
/// CodeBuddy Code(腾讯 CodeBuddy 的 CLI,issue #27):`~/.codebuddy/projects/
@@ -212,15 +212,8 @@ fn parse_codebuddy_jsonl(path: &Path, decode_images: bool) -> Result<ParseResult
let mut tool_index: HashMap<String, (usize, usize)> = HashMap::new();
let mut pending: Option<PendingAssistant> = None;
- for line in reader.lines() {
- let Ok(line) = line else {
- out.unknown_lines += 1;
- continue;
- };
- if line.trim().is_empty() {
- continue;
- }
- let Ok(row) = serde_json::from_str::<Value>(&line) else {
+ for row in jsonl_values(reader) {
+ let Some(row) = row? else {
out.unknown_lines += 1;
continue;
};
@@ -317,19 +310,10 @@ fn parse_codebuddy_jsonl(path: &Path, decode_images: bool) -> Result<ParseResult
.to_string();
let name = row.get("name").and_then(Value::as_str).unwrap_or("");
// arguments 是 JSON 字符串;解不开就原样当字符串给预览
- let parsed_args;
- let arguments: &Value = match row.get("arguments") {
- Some(Value::String(s)) => {
- parsed_args = serde_json::from_str::<Value>(s)
- .unwrap_or_else(|_| Value::String(s.clone()));
- &parsed_args
- }
- Some(v) => v,
- None => &Value::Null,
- };
+ let arguments = decoded_arguments(row.get("arguments").unwrap_or(&Value::Null));
let p = assistant_slot(&mut out, &mut pending, &mut tool_index, ts, &row);
p.tool_calls
- .push(tool_call_view(call_id, name, arguments, None, false));
+ .push(tool_call_view(call_id, name, &arguments, None, false));
}
"function_call_result" => {
let call_id = row.get("callId").and_then(Value::as_str).unwrap_or("");
diff --git a/crates/wake-core/src/adapters/codex.rs b/crates/wake-core/src/adapters/codex.rs
index e7ff743..f0408f2 100644
--- a/crates/wake-core/src/adapters/codex.rs
+++ b/crates/wake-core/src/adapters/codex.rs
@@ -484,21 +484,11 @@ fn parse_rollout(path: &Path, decode_images: bool) -> Result<CodexParse> {
// 子线程里"父线程历史到此为止"的下标(messages / event_fallback 各一)
let mut inherited: Option<(usize, usize)> = None;
- for line in reader.lines() {
- let Ok(line) = line else {
+ for row in jsonl_values(reader) {
+ let Some(row) = row? else {
unknown_lines += 1;
continue;
};
- if line.trim().is_empty() {
- continue;
- }
- let row: Value = match serde_json::from_str(&line) {
- Ok(v) => v,
- Err(_) => {
- unknown_lines += 1;
- continue;
- }
- };
let ts = row.get("timestamp").map(to_epoch_ms).unwrap_or(0);
if ts > 0 {
if created_at == 0 {
diff --git a/crates/wake-core/src/adapters/cursor.rs b/crates/wake-core/src/adapters/cursor.rs
index 46940ad..9e3c870 100644
--- a/crates/wake-core/src/adapters/cursor.rs
+++ b/crates/wake-core/src/adapters/cursor.rs
@@ -4,7 +4,7 @@ use crate::models::*;
use anyhow::Result;
use serde_json::Value;
use std::fs;
-use std::io::{BufRead, BufReader};
+use std::io::BufReader;
use std::path::{Path, PathBuf};
/// Cursor CLI:`~/.cursor/projects/<slug>/agent-transcripts/<uuid>/<uuid>.jsonl` 明文。
@@ -231,23 +231,12 @@ fn parse_cursor_jsonl(path: &Path, decode_images: bool) -> Result<CursorParse> {
// 读不出/不是 JSON 的行(截断、损坏),与"认得出 JSON 但类型未知"分开计
let mut malformed_lines = 0u32;
- for line in reader.lines() {
- let Ok(line) = line else {
+ for row in jsonl_values(reader) {
+ let Some(row) = row? else {
unknown_lines += 1;
malformed_lines += 1;
continue;
};
- if line.trim().is_empty() {
- continue;
- }
- let row: Value = match serde_json::from_str(&line) {
- Ok(v) => v,
- Err(_) => {
- unknown_lines += 1;
- malformed_lines += 1;
- continue;
- }
- };
let Some(role) = row.get("role").and_then(|v| v.as_str()) else {
match row.get("type").and_then(|v| v.as_str()) {
Some("turn_ended") => flush_assistant(&mut pending, &mut messages),
@@ -491,9 +480,9 @@ impl AgentAdapter for CursorAdapter {
}
fn file_ref(&self, path: &Path) -> Option<SessionFileRef> {
- // 只认 transcript 主文件;subagents 转录不是独立会话
- let p = path.to_string_lossy();
- if !p.contains("/agent-transcripts/") || p.contains("/subagents/") {
+ // 只认 transcript 主文件 `agent-transcripts/<会话>/<会话>.jsonl`(subagents 转录多一层,
+ // 不是独立会话)。按路径分段判:Windows 的反斜杠路径一样认
+ if path.parent()?.parent()?.file_name()? != "agent-transcripts" {
return None;
}
let r = default_file_ref(self.agent(), path)?;
diff --git a/crates/wake-core/src/adapters/dsh.rs b/crates/wake-core/src/adapters/dsh.rs
index 2e88e32..e75c1a5 100644
--- a/crates/wake-core/src/adapters/dsh.rs
+++ b/crates/wake-core/src/adapters/dsh.rs
@@ -340,12 +340,9 @@ fn parse_dsh_log(path: &Path, decode_images: bool) -> Result<DshParse> {
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();
// arguments 是模型原样输出的 JSON 字符串,解析失败保留原文
- let raw = b
- .get("arguments")
- .and_then(|v| v.as_str())
- .unwrap_or_default();
- let input = serde_json::from_str::<serde_json::Value>(raw)
- .unwrap_or(serde_json::Value::String(raw.to_string()));
+ let input = decoded_arguments(
+ b.get("arguments").unwrap_or(&serde_json::Value::Null),
+ );
tools.push(tool_call_view(id.to_string(), name, &input, None, false));
}
_ if is_image_part(b) => {
@@ -392,40 +389,13 @@ fn parse_dsh_log(path: &Path, decode_images: bool) -> Result<DshParse> {
}
// 一个 turn 多个 step,每 step 一条 assistant/message;连续 assistant
// 行(中间只隔 tool/result)合并成一条,详情页每回合一条助手消息
- // (合并 + 整体 clip 机制与 pi.rs 同构,改动需两侧同步)
- 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 base = merge_into_last_assistant(
+ &mut p.messages,
+ ts,
+ parsed_message,
+ &thinking_parts.join("\n\n"),
+ );
let last = &mut p.messages[base];
- if !parsed_message.text.is_empty() || !parsed_message.images.is_empty() {
- if last.text.len() < MAX_MSG_TEXT {
- append_content_to_message(last, parsed_message, "\n\n");
- } else {
- append_images_to_message_end(last, parsed_message.images);
- }
- if last.text.len() > MAX_MSG_TEXT {
- let (t, _) = clip(&last.text, MAX_MSG_TEXT);
- last.text = t;
- last.truncated = true;
- }
- }
- // thinking 与全库其他家同压 MAX_TOOL_IO;已到上限就不再拼接
- if !thinking_parts.is_empty()
- && last.thinking.as_deref().map_or(0, str::len) < MAX_TOOL_IO
- {
- let joined = thinking_parts.join("\n\n");
- match &mut last.thinking {
- Some(t) => {
- t.push_str("\n\n");
- t.push_str(&joined);
- if t.len() > MAX_TOOL_IO {
- *t = clip(t, MAX_TOOL_IO).0;
- }
- }
- slot => *slot = Some(clip(&joined, MAX_TOOL_IO).0),
- }
- }
if model.is_some() {
last.model = model;
}
diff --git a/crates/wake-core/src/adapters/gemini.rs b/crates/wake-core/src/adapters/gemini.rs
index 1b442e6..7c93fa9 100644
--- a/crates/wake-core/src/adapters/gemini.rs
+++ b/crates/wake-core/src/adapters/gemini.rs
@@ -5,7 +5,7 @@ use anyhow::Result;
use serde_json::Value;
use std::collections::HashMap;
use std::fs;
-use std::io::{BufRead, BufReader};
+use std::io::BufReader;
use std::path::{Path, PathBuf};
/// Gemini CLI:`~/.gemini/tmp/<slug>/chats/session-*.jsonl`。
@@ -84,15 +84,8 @@ fn parse_gemini_jsonl(path: &Path, decode_images: bool) -> Result<GeminiParse> {
let mut unknown = 0u32;
let mut last_set: Option<Value> = None;
- for line in reader.lines() {
- let Ok(line) = line else {
- unknown += 1;
- continue;
- };
- if line.trim().is_empty() {
- continue;
- }
- let Ok(row) = serde_json::from_str::<Value>(&line) else {
+ for row in jsonl_values(reader) {
+ let Some(row) = row? else {
unknown += 1;
continue;
};
@@ -249,9 +242,10 @@ impl AgentAdapter for GeminiAdapter {
}
fn file_ref(&self, path: &Path) -> Option<SessionFileRef> {
- // 只认 chats/session-*.jsonl(tmp 下其他 jsonl 不是会话)
+ // 只认 chats/session-*.jsonl(tmp 下其他 jsonl 不是会话);所在目录按路径分段判,
+ // Windows 的反斜杠路径一样认
let name = path.file_name()?.to_string_lossy().to_string();
- if !name.starts_with("session-") || !path.to_string_lossy().contains("/chats/") {
+ if !name.starts_with("session-") || path.parent()?.file_name()? != "chats" {
return None;
}
default_file_ref(self.agent(), path)
diff --git a/crates/wake-core/src/adapters/grok.rs b/crates/wake-core/src/adapters/grok.rs
index 509771d..4ec889a 100644
--- a/crates/wake-core/src/adapters/grok.rs
+++ b/crates/wake-core/src/adapters/grok.rs
@@ -6,7 +6,7 @@ use anyhow::Result;
use serde_json::Value;
use std::collections::HashMap;
use std::fs;
-use std::io::{BufRead, BufReader};
+use std::io::BufReader;
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex};
@@ -257,15 +257,8 @@ fn parse_grok_updates(path: &Path, decode_images: bool) -> Result<(Vec<Transcrip
let mut rp = Replay::new();
let mut unknown = 0u32;
- for line in reader.lines() {
- let Ok(line) = line else {
- unknown += 1;
- continue;
- };
- if line.trim().is_empty() {
- continue;
- }
- let Ok(row) = serde_json::from_str::<Value>(&line) else {
+ for row in jsonl_values(reader) {
+ let Some(row) = row? else {
unknown += 1;
continue;
};
diff --git a/crates/wake-core/src/adapters/hermes.rs b/crates/wake-core/src/adapters/hermes.rs
index 033cf14..6cc587c 100644
--- a/crates/wake-core/src/adapters/hermes.rs
+++ b/crates/wake-core/src/adapters/hermes.rs
@@ -219,38 +219,17 @@ impl HermesAdapter {
"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() {
+ let thinking = m.reasoning.as_deref().unwrap_or_default();
+ if text.is_empty() && calls.is_empty() && thinking.trim().is_empty() {
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 part = ParsedContent {
+ text,
+ ..Default::default()
+ };
+ let base = merge_into_last_assistant(&mut messages, m.ts_ms, part, thinking);
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 {
@@ -416,11 +395,7 @@ fn tool_calls_of(raw: Option<&str>, msg_id: i64) -> Vec<(bool, ToolCallView)> {
.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 input = decoded_arguments(func.get("arguments").unwrap_or(&Value::Null));
let (has_id, id) = match item
.get("id")
.and_then(Value::as_str)
diff --git a/crates/wake-core/src/adapters/kimi.rs b/crates/wake-core/src/adapters/kimi.rs
index 4525cc0..46db4f0 100644
--- a/crates/wake-core/src/adapters/kimi.rs
+++ b/crates/wake-core/src/adapters/kimi.rs
@@ -3,36 +3,79 @@ use super::AgentAdapter;
use crate::models::*;
use anyhow::Result;
use serde_json::Value;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
use std::fs;
-use std::io::{BufRead, BufReader};
+use std::io::{self, BufReader};
use std::path::{Path, PathBuf};
+use std::sync::{Arc, Mutex};
-/// Kimi Code(Moonshot AI):`~/.kimi-code/sessions/wd_<名>_<hash>/session_<uuid>/`
-/// 一目录一会话,主文件 `agents/main/wire.jsonl`(事件溯源)。turn.prompt / turn.steer
-/// 是用户输入;桌面端 0.4x 的助手回复在 agent.message.appended(包装层 `{message, meta}`);
-/// CLI 的助手回复按步写在 context.append_loop_event 里,v1 未展开;config / turn.* 等
-/// 已知跳过。`state.json` 边车给标题/时间("New Session" 是占位),cwd 靠根级
-/// `session_index.jsonl` 的 sessionId→workDir 映射(目录名 hash 不可反推)。
+/// Kimi Code(Moonshot AI):`<home>/sessions/wd_<名>_<hash>/<会话>/`,`<home>` 是
+/// `~/.kimi-code`(或 `KIMI_CODE_HOME`)。一目录一会话,主文件 `agents/main/wire.jsonl`
+/// 是事件溯源的记录流,按 Kimi 自己重建转录的方式(agent-core 的 `reduceWireRecords`)读:
+/// - 用户输入是 `turn.prompt` / `turn.steer`,按 origin 分用户自己给的与系统产生的;同一份
+/// 输入随后以 `context.append_message`(role user)进上下文,那是回声、跳过——没有 turn
+/// 记录的(从旧版 Python kimi-cli 迁移来的会话)才由它出用户消息;
+/// - 助手:CLI 按步写在 `context.append_loop_event`(step.begin / content.part 的 text 与
+/// think / tool.call / tool.result / step.end),桌面端 0.4x 写在 `agent.message.appended`
+/// (包装层 `{message, meta}`);同一轮的各步并成一条回复,工具结果回填到调用上;
+/// - `context.apply_compaction` 是上下文压缩的摘要,`forked` 之前是从父会话复制来的。
+///
+/// `state.json` 边车给标题 / 时间 / 归档 / 分叉来源("New Session" 是占位标题),cwd 靠
+/// home 下 `session_index.jsonl` 的 sessionId→workDir(目录名 hash 不可反推)。
/// `agents/<非main>/` 是子代理,不进列表。
pub struct KimiAdapter {
+ /// 会话根:`<home>/sessions`(下面两级 `wd_*/<会话>`),或单个工作目录桶 `wd_*`(会话就在
+ /// 它下面一级)
root: PathBuf,
+ /// home 顶层的 `session_index.jsonl`(sessions 的上一级),由根推出来
index_path: PathBuf,
/// sessionId → workDir,按 index mtime 缓存(全量刷新时逐会话调用)
- cwd_cache: MtimeCache<HashMap<String, String>>,
+ cwd_cache: MtimeCache<Arc<HashMap<String, String>>>,
+ states: StateCache,
}
+const INDEX_FILE: &str = "session_index.jsonl";
+
impl KimiAdapter {
pub fn new() -> Self {
- let home = super::home_dir().unwrap_or_default().join(".kimi-code");
+ Self::from_root(home_from(super::env_dir("KIMI_CODE_HOME")).join("sessions"))
+ }
+
+ fn from_root(root: PathBuf) -> Self {
+ let levels = if is_workdir_bucket(&root) { 2 } else { 1 };
+ let index_path = root
+ .ancestors()
+ .nth(levels)
+ .unwrap_or(&root)
+ .join(INDEX_FILE);
Self {
- root: home.join("sessions"),
- index_path: home.join("session_index.jsonl"),
+ root,
+ index_path,
cwd_cache: MtimeCache::new(),
+ states: StateCache::default(),
}
}
- fn cwd_map(&self) -> HashMap<String, String> {
+ /// 全部会话目录(`<桶>/<会话>`;根就是一个桶时只看它),列表与父子关系共用;读不出的目录跳过
+ fn session_dirs(&self) -> Vec<PathBuf> {
+ let children = |dir: &Path| -> Vec<PathBuf> {
+ fs::read_dir(dir)
+ .map(|entries| entries.flatten().map(|e| e.path()).collect())
+ .unwrap_or_default()
+ };
+ let buckets = if is_workdir_bucket(&self.root) {
+ vec![self.root.clone()]
+ } else {
+ children(&self.root)
+ };
+ buckets
+ .iter()
+ .flat_map(|bucket| children(bucket))
+ .filter(|dir| is_session_dir(dir))
+ .collect()
+ }
+
+ fn cwd_map(&self) -> Arc<HashMap<String, String>> {
let mtime = fs::metadata(&self.index_path)
.map(|m| mtime_ms(&m))
.unwrap_or(0);
@@ -52,7 +95,7 @@ impl KimiAdapter {
}
}
}
- Some(out)
+ Some(Arc::new(out))
})
.unwrap_or_default()
}
@@ -60,6 +103,30 @@ impl KimiAdapter {
fn cwd_for(&self, native_id: &str) -> String {
self.cwd_map().get(native_id).cloned().unwrap_or_default()
}
+
+ fn parse(
+ &self,
+ r: &SessionFileRef,
+ decode_images: bool,
+ ) -> Result<(SessionMeta, Vec<TranscriptMessage>, u32)> {
+ let path = Path::new(&r.file_path);
+ // state.json 在却读不出(又没读到过)就让这次解析失败,先读它、省得白解析整份转录:
+ // 按默认值入库,标题、归档都是错的,而引用里记着它此刻的 mtime / size,文件不再变就
+ // 一直错着
+ let state = match session_dir_of(path) {
+ Some(dir) => self.states.get(dir)?,
+ None => KimiState::default(),
+ };
+ let (messages, unknown) = parse_kimi_wire(path, decode_images)?;
+ let meta = build_meta(r, &state, &self.cwd_for(&r.native_id), &messages);
+ Ok((meta, messages, unknown))
+ }
+}
+
+/// Kimi 的数据目录:`KIMI_CODE_HOME`(Kimi 自己的开关)探得到会话目录才采信,否则 `~/.kimi-code`
+fn home_from(env: Option<PathBuf>) -> PathBuf {
+ env.filter(|dir| dir.join("sessions").is_dir())
+ .unwrap_or_else(|| super::home_dir().unwrap_or_default().join(".kimi-code"))
}
/// 主代理转录相对会话目录的位置。列表、file_ref 与会话目录反推共用这一处,按平台分隔符拼
@@ -70,60 +137,129 @@ fn main_wire_rel() -> PathBuf {
MAIN_WIRE.iter().collect()
}
-/// `…/session_<uuid>/agents/main/wire.jsonl` → 会话目录;子代理(`agents/<非main>/`)与别的
-/// 形状给 None。read_state / native_id / session_paths 共用,漂移会 trash 错目录
+/// 会话目录名的前缀:Kimi Code 建的是 `session_<uuid>`,从旧版 Python kimi-cli 迁移来的是
+/// `ses_<旧 uuid>`
+const SESSION_DIR_PREFIXES: [&str; 2] = ["session_", "ses_"];
+
+/// 会话目录:名字带会话前缀
+fn is_session_dir(dir: &Path) -> bool {
+ dir.file_name()
+ .map(|name| name.to_string_lossy())
+ .is_some_and(|name| SESSION_DIR_PREFIXES.iter().any(|p| name.starts_with(p)))
+}
+
+/// 工作目录桶:`wd_<名>_<hash>`
+fn is_workdir_bucket(dir: &Path) -> bool {
+ dir.file_name()
+ .is_some_and(|name| name.to_string_lossy().starts_with("wd_"))
+}
+
+/// `…/<会话>/agents/main/wire.jsonl` → 会话目录;子代理(`agents/<非main>/`)与别的形状给
+/// None。state.json、file_ref 与 session_paths 共用,漂移会 trash 错目录
fn session_dir_of(wire_path: &Path) -> Option<&Path> {
if !wire_path.ends_with(main_wire_rel()) {
return None;
}
- let dir = wire_path.ancestors().nth(MAIN_WIRE.len())?;
- dir.file_name()?
- .to_string_lossy()
- .starts_with("session_")
- .then_some(dir)
+ wire_path
+ .ancestors()
+ .nth(MAIN_WIRE.len())
+ .filter(|dir| is_session_dir(dir))
}
-/// state.json 边车(会话目录 session_<uuid>/ 下,wire.jsonl 上三级)
+/// 会话目录下的边车:标题 / 时间 / 归档 / 分叉来源
+const STATE_FILE: &str = "state.json";
+
+#[derive(Default, Clone)]
struct KimiState {
title: String,
created_ms: i64,
updated_ms: i64,
+ /// 在 Kimi 里归档了(顶层 `archived: true`)
+ archived: bool,
+ /// 从哪个会话分叉来的(`forkedFrom`)
+ forked_from: Option<String>,
}
-fn read_state(wire_path: &Path) -> KimiState {
- let mut s = KimiState {
- title: String::new(),
- created_ms: 0,
- updated_ms: 0,
- };
- let Some(session_dir) = session_dir_of(wire_path) else {
- return s;
- };
- if let Ok(raw) = fs::read_to_string(session_dir.join("state.json")) {
- if let Ok(v) = serde_json::from_str::<Value>(&raw) {
- if let Some(t) = v.get("title").and_then(|x| x.as_str()) {
- // "New Session" 是 Kimi 的占位标题,不当真实标题
- if t != "New Session" {
- s.title = t.to_string();
- }
- }
- if let Some(t) = v.get("createdAt").and_then(|x| x.as_str()) {
- s.created_ms = iso_ms(t);
- }
- if let Some(t) = v.get("updatedAt").and_then(|x| x.as_str()) {
- s.updated_ms = iso_ms(t);
+/// 读到的 state.json → 字段;不是完整的 JSON 对象给 None。标题照 Kimi 的 `titleFromState`:
+/// 新的写法是 `title` 配一个 `isCustomTitle`,老的把改过的名字放在 `customTitle`
+fn parse_state(raw: &[u8]) -> Option<KimiState> {
+ let v = serde_json::from_slice::<Value>(raw)
+ .ok()
+ .filter(Value::is_object)?;
+ let string = |key: &str| v.get(key).filter(|value| value.is_string());
+ let title = string("title")
+ .filter(|_| v.get("isCustomTitle").is_some_and(Value::is_boolean))
+ .or_else(|| string("customTitle"))
+ .or_else(|| string("title"));
+ let time = |key: &str| v.get(key).and_then(Value::as_str).map(iso_ms).unwrap_or(0);
+ Some(KimiState {
+ // "New Session" 是 Kimi 的占位标题,不当真实标题
+ title: optional_string(title)
+ .filter(|t| t != "New Session")
+ .unwrap_or_default(),
+ created_ms: time("createdAt"),
+ updated_ms: time("updatedAt"),
+ archived: v.get("archived").and_then(Value::as_bool) == Some(true),
+ forked_from: optional_string(v.get("forkedFrom")),
+ })
+}
+
+/// 会话目录 → 它的 state.json,按 (mtime, size) 缓存:父子关系的快照每批监听事件都要把全部
+/// 会话过一遍,文件没变就不再打开。另一个用处是兜底——Kimi 用普通 writeFile 写它(先截断再
+/// 写,不是原子替换),这一刻可能读到空的或半截的,那就沿用上次读到的
+#[derive(Default)]
+struct StateCache(Mutex<HashMap<PathBuf, ((i64, i64), KimiState)>>);
+
+impl StateCache {
+ fn get(&self, session_dir: &Path) -> io::Result<KimiState> {
+ let path = session_dir.join(STATE_FILE);
+ let last = self.0.lock().unwrap().get(session_dir).cloned();
+ let read = fs::metadata(&path).and_then(|meta| {
+ let stamp = (mtime_ms(&meta), meta.len() as i64);
+ match &last {
+ Some((cached, state)) if *cached == stamp => Ok(Some(state.clone())),
+ _ => fs::read(&path).map(|raw| {
+ let state = parse_state(&raw)?;
+ self.0
+ .lock()
+ .unwrap()
+ .insert(session_dir.to_path_buf(), (stamp, state.clone()));
+ Some(state)
+ }),
}
+ });
+ let last = last.map(|(_, state)| state);
+ match read {
+ Ok(Some(state)) => Ok(state),
+ // 没有这个文件:空的默认值
+ Err(e) if e.kind() == io::ErrorKind::NotFound => Ok(KimiState::default()),
+ // 写坏了:沿用上次读到的,没读到过按没有算(Kimi 自己也这样)
+ Ok(None) => Ok(last.unwrap_or_default()),
+ // 读不出:沿用上次读到的,没读到过就是不知道
+ Err(e) => last.ok_or(e),
}
}
- s
+
+ /// 只留这次枚举到的会话(删掉的会话不再占着)
+ fn retain_only(&self, session_dirs: &[PathBuf]) {
+ let live: HashSet<&Path> = session_dirs.iter().map(PathBuf::as_path).collect();
+ self.0
+ .lock()
+ .unwrap()
+ .retain(|dir, _| live.contains(dir.as_path()));
+ }
}
-/// 思考块:content 里的 `{"type":"think","think":"..."}`,多段拼成一段(截断在合并处统一做)
+/// 思考块:`{"type":"think","think":"..."}`,content 数组或单个 part 都认,多段拼成一段
+/// (截断在合并处统一做)
fn think_texts(content: &Value) -> String {
- content
- .as_array()
- .into_iter()
- .flatten()
+ let parts = match content {
+ Value::Array(parts) => parts.as_slice(),
+ part @ Value::Object(_) => std::slice::from_ref(part),
+ _ => &[],
+ };
+ parts
+ .iter()
.filter(|p| p.get("type").and_then(Value::as_str) == Some("think"))
.filter_map(|p| p.get("think").and_then(Value::as_str).map(str::trim))
.filter(|t| !t.is_empty())
@@ -131,104 +267,305 @@ fn think_texts(content: &Value) -> String {
.join("\n\n")
}
-fn parse_kimi_wire(path: &Path, decode_images: bool) -> Result<(Vec<TranscriptMessage>, u32)> {
- let _image_budget = transcript_image_decode_budget(decode_images);
- let file = fs::File::open(path)?;
- let reader = BufReader::with_capacity(1 << 20, file);
- let mut messages: Vec<TranscriptMessage> = Vec::new();
- let mut unknown = 0u32;
- // 这一轮的助手回复还在接着并:新的一轮(turn.* 里除了 turn.step.*)关上它
- let mut reply_open = false;
-
- for line in reader.lines() {
- let Ok(line) = line else {
- unknown += 1;
- continue;
- };
- if line.trim().is_empty() {
- continue;
- }
- let Ok(row) = serde_json::from_str::<Value>(&line) else {
- unknown += 1;
- continue;
- };
- // 事件时间:Kimi 给每条记录打 time(毫秒;metadata 行没有),没有就不标
+/// 记录类型词汇表,照抄 Kimi Code agent-core(0.29)的 `restoreAgentRecord` 与 v2 的
+/// `defineOp`。这些不产生对话内容:配置、权限、用量与请求快照、模式切换、目标、定时与后台
+/// 任务、压缩的起止……`context.clear` / `context.undo` 也在这里——Kimi 的转录同样留着 clear
+/// 之前的消息,undo 撤掉的轮次 Wake 照留。上游加了新类型就在这里补:表外的计未知行,那是格式
+/// 漂移的预警,清理页也靠它判断会话读全了没有。`turn.*` 按前缀认(见解析处)
+const KNOWN_RECORDS: &[&str] = &[
+ "metadata",
+ "config.update",
+ "context.clear",
+ "context.undo",
+ "context.update_token_count",
+ "context_size.measured",
+ "cron.add",
+ "cron.cursor",
+ "cron.delete",
+ "full_compaction.begin",
+ "full_compaction.cancel",
+ "full_compaction.complete",
+ "goal.clear",
+ "goal.create",
+ "goal.update",
+ "llm.request",
+ "llm.tools_snapshot",
+ "mcp.tools_discovered",
+ "micro_compaction.apply",
+ "permission.record_approval_result",
+ "permission.rules.add",
+ "permission.set_mode",
+ "plan_mode.cancel",
+ "plan_mode.enter",
+ "plan_mode.exit",
+ "profile.bind",
+ "skill.activate",
+ "swarm_mode.enter",
+ "swarm_mode.exit",
+ "task.started",
+ "task.terminated",
+ "tools.register_user_tool",
+ "tools.reset_active_tools",
+ "tools.set_active_tools",
+ "tools.unregister_user_tool",
+ "tools.update_store",
+ "usage.record",
+];
+
+/// 这条用户输入是不是用户自己给的,照抄 Kimi 的 `isUserVisibleTurnInputRecord`:user;用户敲
+/// 斜杠触发的 skill / plugin;shell 命令的输入。后台任务通知、定时任务、钩子结果、注入、重试、
+/// 压缩摘要、系统触发(目标续跑)都不是。没有 origin 的(老记录、迁移来的会话)算用户的;
+/// 不认识的 kind 给 None,调用方计未知行
+fn user_visible(origin: Option<&Value>) -> Option<bool> {
+ let Some(origin) = origin.filter(|o| !o.is_null()) else {
+ return Some(true);
+ };
+ let field = |key: &str| origin.get(key).and_then(Value::as_str);
+ Some(match field("kind")? {
+ "user" => true,
+ "skill_activation" | "plugin_command" => field("trigger") == Some("user-slash"),
+ "shell_command" => field("phase") == Some("input"),
+ "background_task" | "compaction_summary" | "cron_job" | "cron_missed" | "hook_result"
+ | "injection" | "retry" | "system_trigger" => false,
+ _ => return None,
+ })
+}
+
+/// 一遍读完 wire.jsonl 的状态
+#[derive(Default)]
+struct WireReader {
+ decode_images: bool,
+ messages: Vec<TranscriptMessage>,
+ unknown: u32,
+ /// 这一轮的助手回复还开着(就是最后一条消息),同一轮的各步并进去;推别的消息之前都要
+ /// 关上它。用户消息、压缩摘要与新的一轮(turn.* 里除了 turn.step.*)关上它——输入渲染
+ /// 不出来的那一轮没有用户消息隔开,也不能并进上一轮
+ reply_open: bool,
+ /// 已显示、回声(context.append_message 里的同一份输入)还没到的用户输入数
+ pending_echo: u32,
+ /// toolCallId → (消息下标, 调用下标),工具结果回填用
+ tool_slots: HashMap<String, (usize, usize)>,
+ /// 最后一个 `forked` 标记之前的消息数:那一段是从父会话复制来的
+ inherited: usize,
+}
+
+impl WireReader {
+ fn record(&mut self, row: &Value) {
let ts = row.get("time").map(to_epoch_ms).unwrap_or(0);
- match row.get("type").and_then(|v| v.as_str()) {
- Some("turn.prompt") | Some("turn.steer") => {
- reply_open = false;
- let parsed = content_parts(row.get("input").unwrap_or(&Value::Null), 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;
- messages.push(message);
+ let kind = row.get("type").and_then(Value::as_str).unwrap_or_default();
+ match kind {
+ "turn.prompt" | "turn.steer" => {
+ let visible = self.visible(row.get("origin"));
+ let input = row.get("input").unwrap_or(&Value::Null);
+ // 显示出来的输入稍后还会以 context.append_message 回声一次;渲染不出来的
+ // (只带视频)不记,让回声顶上——那一份里视频已换成 <video> 标记
+ if self.push_user(input, ts, visible) && visible {
+ self.pending_echo += 1;
}
}
- Some("context.append_message") => {
- let Some(msg) = row.get("message") else {
- unknown += 1;
- continue;
- };
- let role = match msg.get("role").and_then(|v| v.as_str()) {
- Some("assistant") => Role::Assistant,
- // user 输入已由 turn.prompt 覆盖;tool/system 等上下文行跳过
- _ => continue,
+ "context.append_message" => match row.get("message") {
+ Some(message) => self.context_message(message, ts),
+ None => self.unknown += 1,
+ },
+ "context.append_loop_event" => match row.get("event") {
+ Some(event) => self.loop_event(event, ts),
+ None => self.unknown += 1,
+ },
+ // 桌面端 0.4x:包装层 `{message, meta}`。user 与 turn.prompt / turn.steer 重复,
+ // notify 是界面通知;不认识的角色计未知行
+ "agent.message.appended" => {
+ let Some(message) = row.get("message").and_then(|w| w.get("message")) else {
+ self.unknown += 1;
+ return;
};
- let parsed =
- content_parts(msg.get("content").unwrap_or(&Value::Null), decode_images);
- if !parsed.text.is_empty() || !parsed.images.is_empty() {
- let mut message = text_msg(role, &parsed.text, ts);
- message.images = parsed.images;
- messages.push(message);
+ match message.get("role").and_then(Value::as_str) {
+ Some("assistant" | "tool") => self.context_message(message, ts),
+ Some("user" | "notify") => {}
+ _ => self.unknown += 1,
}
}
- // 桌面端(0.4x):助手回复在 agent.message.appended,包装层 `{message, meta}`
- Some("agent.message.appended") => {
- let Some(msg) = row
- .get("message")
- .and_then(|wrapper| wrapper.get("message"))
- else {
- unknown += 1;
- continue;
- };
- match msg.get("role").and_then(Value::as_str) {
- Some("assistant") => {}
- // user 与 turn.prompt / turn.steer 重复;tool 的明细在 loop_event 里,v1 不展开;
- // notify 是界面通知。别的角色计未知行:格式一漂移回复就会悄悄消失,清理页
- // 靠未知行判断这个会话读全了没有
- Some("user" | "tool" | "notify") => continue,
- _ => {
- unknown += 1;
- continue;
- }
+ "context.apply_compaction" => {
+ self.reply_open = false;
+ let summary = row.get("summary").and_then(Value::as_str).unwrap_or("");
+ if !summary.trim().is_empty() {
+ let mut message = text_msg(Role::System, summary, ts);
+ message.kind = MessageKind::CompactSummary;
+ self.messages.push(message);
}
- let content = msg.get("content").unwrap_or(&Value::Null);
- let parsed = content_parts(content, decode_images);
- let thinking = think_texts(content);
- if parsed.text.is_empty() && parsed.images.is_empty() && thinking.is_empty() {
- continue;
+ }
+ // 分叉:Kimi 把父会话的记录原样复制过来,再补这一行(多次分叉以最后一个为准)
+ "forked" => {
+ self.inherited = self.messages.len();
+ self.reply_open = false;
+ self.pending_echo = 0;
+ self.tool_slots.clear();
+ }
+ k if k.starts_with("turn.") => self.reply_open &= k.starts_with("turn.step."),
+ k if KNOWN_RECORDS.contains(&k) => {}
+ _ => self.unknown += 1,
+ }
+ }
+
+ fn visible(&mut self, origin: Option<&Value>) -> bool {
+ user_visible(origin).unwrap_or_else(|| {
+ self.unknown += 1;
+ false
+ })
+ }
+
+ /// 一条用户消息,渲染不出东西就不出(返回 false)。不是用户自己给的(系统通知、注入……)
+ /// 记成 Meta:留在转录里,不进搜索、不算消息数、不当标题
+ fn push_user(&mut self, content: &Value, ts: i64, visible: bool) -> bool {
+ self.reply_open = false;
+ let parsed = content_parts(content, self.decode_images);
+ if parsed.text.is_empty() && parsed.images.is_empty() {
+ return false;
+ }
+ let mut message = text_msg(Role::User, &parsed.text, ts);
+ message.images = parsed.images;
+ if !visible {
+ message.kind = MessageKind::Meta;
+ }
+ self.messages.push(message);
+ true
+ }
+
+ /// 这一轮的回复(没开着就开一条),返回下标
+ fn reply(&mut self, ts: i64) -> usize {
+ if !self.reply_open {
+ self.messages.push(text_msg(Role::Assistant, "", ts));
+ self.reply_open = true;
+ }
+ self.messages.len() - 1
+ }
+
+ /// 一段助手内容(正文、图片、think 块)并进这一轮的回复
+ fn assistant_content(&mut self, content: &Value, ts: i64) {
+ let parsed = content_parts(content, self.decode_images);
+ let thinking = think_texts(content);
+ if parsed.text.is_empty() && parsed.images.is_empty() && thinking.is_empty() {
+ return;
+ }
+ self.reply(ts);
+ merge_into_last_assistant(&mut self.messages, ts, parsed, &thinking);
+ }
+
+ fn tool_call(&mut self, id: &str, name: &str, args: &Value, ts: i64) {
+ let ix = self.reply(ts);
+ let calls = &mut self.messages[ix].tool_calls;
+ calls.push(tool_call_view(id.to_string(), name, args, None, false));
+ if !id.is_empty() {
+ self.tool_slots
+ .insert(id.to_string(), (ix, calls.len() - 1));
+ }
+ }
+
+ /// 工具结果回填到调用上(输出是字符串或 content part 数组,与别家同一个读法)
+ fn tool_result(&mut self, id: &str, output: &Value, is_error: bool) {
+ let Some((m, c)) = self.tool_slots.remove(id) else {
+ return;
+ };
+ let call = &mut self.messages[m].tool_calls[c];
+ call.output = Some(clip(&tool_result_parts(output, false).text, MAX_TOOL_IO).0);
+ call.is_error = is_error;
+ }
+
+ /// `context.append_message`:进上下文的完整消息(桌面端包装层里的同形)
+ fn context_message(&mut self, message: &Value, ts: i64) {
+ let content = message.get("content").unwrap_or(&Value::Null);
+ match message.get("role").and_then(Value::as_str) {
+ Some("user") => {
+ // 系统产生的(注入、提醒、目标续跑……)不显示;用户自己的输入多半是 turn.prompt /
+ // turn.steer 的回声,已经显示过了
+ if !self.visible(message.get("origin")) {
+ return;
+ }
+ if self.pending_echo > 0 {
+ self.pending_echo -= 1;
+ return;
+ }
+ self.push_user(content, ts, true);
+ }
+ // 钩子拦下提问时的说明、迁移来的会话里的回复、桌面端的回复
+ Some("assistant") => {
+ self.assistant_content(content, ts);
+ let calls = message.get("toolCalls").and_then(Value::as_array);
+ for call in calls.into_iter().flatten() {
+ // OpenAI 形,名字与参数在 function 里;Kimi 自己直接放在顶层
+ let func = call.get("function").unwrap_or(call);
+ let name = func.get("name").and_then(Value::as_str).unwrap_or_default();
+ let args = decoded_arguments(func.get("arguments").unwrap_or(&Value::Null));
+ let id = call.get("id").and_then(Value::as_str).unwrap_or_default();
+ self.tool_call(id, name, &args, ts);
}
- // 一轮里每次模型调用一条事件(多半只有 think),并成一条回复;新的一轮另起一条——
- // 输入渲染不出来的那一轮(只带音视频附件)没有用户消息隔开,不能并进上一轮
- if !reply_open {
- messages.push(text_msg(Role::Assistant, "", ts));
- reply_open = true;
+ }
+ Some("tool") => {
+ let id = message
+ .get("toolCallId")
+ .and_then(Value::as_str)
+ .unwrap_or_default();
+ let is_error = message.get("isError").and_then(Value::as_bool) == Some(true);
+ self.tool_result(id, content, is_error);
+ }
+ Some("system") => {}
+ _ => self.unknown += 1,
+ }
+ }
+
+ /// `context.append_loop_event`:CLI 按步写下的模型产出
+ fn loop_event(&mut self, event: &Value, ts: i64) {
+ let text = |key: &str| event.get(key).and_then(Value::as_str).unwrap_or_default();
+ match text("type") {
+ "step.begin" | "step.end" => {}
+ "content.part" => {
+ if let Some(part) = event.get("part") {
+ self.assistant_content(part, ts);
}
- merge_into_last_assistant(&mut messages, ts, parsed, &thinking);
}
- // 已知的配置/生命周期/工具事件行(工具明细在 loop_event 里,v1 不展开)
- Some("metadata")
- | Some("config.update")
- | Some("tools.set_active_tools")
- | Some("context.append_loop_event") => {}
- Some(t) if t.starts_with("turn.") => reply_open &= t.starts_with("turn.step."),
- _ => {
- unknown += 1;
+ "tool.call" => self.tool_call(
+ text("toolCallId"),
+ text("name"),
+ event.get("args").unwrap_or(&Value::Null),
+ ts,
+ ),
+ "tool.result" => {
+ let result = event.get("result");
+ let output = result.and_then(|r| r.get("output")).unwrap_or(&Value::Null);
+ let is_error = result
+ .and_then(|r| r.get("isError"))
+ .and_then(Value::as_bool)
+ == Some(true);
+ self.tool_result(text("toolCallId"), output, is_error);
}
+ _ => self.unknown += 1,
}
}
- assign_seq(&mut messages);
- Ok((messages, unknown))
+
+ fn finish(mut self) -> (Vec<TranscriptMessage>, u32) {
+ collapse_inherited(&mut self.messages, self.inherited, "session");
+ assign_seq(&mut self.messages);
+ (self.messages, self.unknown)
+ }
+}
+
+fn parse_kimi_wire(path: &Path, decode_images: bool) -> Result<(Vec<TranscriptMessage>, u32)> {
+ let _image_budget = transcript_image_decode_budget(decode_images);
+ let reader = BufReader::with_capacity(1 << 20, fs::File::open(path)?);
+ let mut wire = WireReader {
+ decode_images,
+ ..Default::default()
+ };
+ for row in jsonl_values(reader) {
+ match row? {
+ Some(row) => wire.record(&row),
+ None => wire.unknown += 1,
+ }
+ }
+ Ok(wire.finish())
+}
+
+fn session_key_of(native_id: &str) -> String {
+ session_key(AgentId::Kimi, "", native_id)
}
fn build_meta(
@@ -244,7 +581,7 @@ fn build_meta(
// Kimi 在 Windows 上把 workDir 记成 `C:/…`,别家记 `C:\…`:换成同一种写法才归到同一个项目
let project = canonical_project_path(cwd);
SessionMeta {
- key: format!("kimi:{}", r.native_id),
+ key: session_key_of(&r.native_id),
host: String::new(),
id: r.native_id.clone(),
agent: AgentId::Kimi,
@@ -270,22 +607,16 @@ fn build_meta(
git_branch: None,
model: None,
tokens_used: None,
- archived: false,
+ archived: state.archived,
source: None,
favorite: false,
pinned: false,
}
}
-/// 会话目录名即 native_id(与 session_index.jsonl 的 sessionId 同形,
-/// resume 直接可用)
-fn native_id_of(wire_path: &Path) -> Option<String> {
- Some(
- session_dir_of(wire_path)?
- .file_name()?
- .to_string_lossy()
- .to_string(),
- )
+/// 选中的目录里有没有 `wd_*` 工作目录桶(没有 `sessions/` 子目录时据此认"这就是 sessions")
+fn has_workdir_buckets(dir: &Path) -> bool {
+ fs::read_dir(dir).is_ok_and(|entries| entries.flatten().any(|e| is_workdir_bucket(&e.path())))
}
impl AgentAdapter for KimiAdapter {
@@ -294,53 +625,51 @@ impl AgentAdapter for KimiAdapter {
}
fn list_session_files(&self) -> Result<Vec<SessionFileRef>> {
- let mut refs = Vec::new();
- let Ok(wds) = fs::read_dir(&self.root) else {
- return Ok(refs);
- };
- // 主文件判定(session_ 前缀、存在、非空、native_id)统一走 file_ref
+ // 主文件判定(存在、非空、native_id)统一走 file_ref
let rel = main_wire_rel();
- for wd in wds.flatten() {
- let Ok(sessions) = fs::read_dir(wd.path()) else {
- continue;
- };
- for sess in sessions.flatten() {
- let wire = sess.path().join(&rel);
- if let Some(r) = self.file_ref(&wire) {
- refs.push(r);
- }
- }
- }
- Ok(refs)
+ Ok(self
+ .session_dirs()
+ .iter()
+ .filter_map(|dir| self.file_ref(&dir.join(&rel)))
+ .collect())
}
fn file_ref(&self, path: &Path) -> Option<SessionFileRef> {
- // 只认主代理的 wire.jsonl(形状判定在 session_dir_of;agents/<其他>/ 是子代理)
- let native = native_id_of(path)?;
- let mut r = default_file_ref(self.agent(), path)?;
- r.native_id = native;
+ // 只认主代理的 wire.jsonl(形状判定在 session_dir_of;agents/<其他>/ 是子代理)。
+ // state.json 单独改了(在 Kimi 里归档、改名)也要重新解析:监听到它就换成同会话的
+ // 主转录,它的 mtime / size 并进引用——全量扫描按引用判脏
+ let wire = if path.file_name()? == STATE_FILE {
+ path.parent()?.join(main_wire_rel())
+ } else {
+ path.to_path_buf()
+ };
+ let dir = session_dir_of(&wire)?;
+ let mut r = default_file_ref(self.agent(), &wire)?;
+ // 会话目录名即 native_id(与 session_index.jsonl 的 sessionId 同形,resume 直接可用)
+ r.native_id = dir.file_name()?.to_string_lossy().to_string();
+ if let Ok(state) = fs::metadata(dir.join(STATE_FILE)) {
+ r.mtime_ms = r.mtime_ms.max(mtime_ms(&state));
+ r.size += state.len() as i64;
+ }
Some(r)
}
fn session_paths(&self, meta: &SessionMeta) -> Vec<String> {
- // 会话是 session_<uuid>/ 整个目录(state.json + agents/),整目录进废纸篓
+ // 会话是整个会话目录(state.json + agents/),整目录进废纸篓
session_dir_of(Path::new(&meta.file_path))
.map(|d| vec![d.to_string_lossy().to_string()])
.unwrap_or_else(|| vec![meta.file_path.clone()])
}
fn parse_session(&self, r: &SessionFileRef) -> Result<ParsedSession> {
- let (messages, unknown) = parse_kimi_wire(Path::new(&r.file_path), false)?;
- let state = read_state(Path::new(&r.file_path));
- let meta = build_meta(r, &state, &self.cwd_for(&r.native_id), &messages);
+ let (meta, messages, unknown) = self.parse(r, false)?;
Ok(ParsedSession::derive(meta, &messages, unknown))
}
fn parse_transcript(&self, r: &SessionFileRef) -> Result<ParsedTranscript> {
- let (messages, unknown) = parse_kimi_wire(Path::new(&r.file_path), true)?;
- let state = read_state(Path::new(&r.file_path));
+ let (meta, messages, unknown) = self.parse(r, true)?;
Ok(ParsedTranscript {
- meta: build_meta(r, &state, &self.cwd_for(&r.native_id), &messages),
+ meta,
mainline: messages,
sidechains: Vec::new(),
unknown_line_count: unknown,
@@ -351,26 +680,224 @@ impl AgentAdapter for KimiAdapter {
Some(self.session_paths(meta))
}
+ /// 分叉来的会话挂回父会话(state.json 的 `forkedFrom`;复制来的那段在解析时折成一条)
+ fn manages_parent_links(&self) -> bool {
+ true
+ }
+
+ fn parent_links(&self) -> Option<Vec<(String, String)>> {
+ // 每批监听事件都会问:只扫目录、每个会话 stat 一次 state.json(没变就用缓存);转录在不在
+ // 不用看,没入库的子会话 scanner 自己会丢掉
+ let dirs = self.session_dirs();
+ self.states.retain_only(&dirs);
+ let mut links = Vec::new();
+ for dir in &dirs {
+ // 读不出又没读到过:不知道,库里的关系这一轮原样保留
+ let state = self.states.get(dir).ok()?;
+ let child = dir.file_name()?.to_string_lossy();
+ if let Some(parent) = state.forked_from.as_deref().filter(|p| *p != child) {
+ links.push((session_key_of(&child), session_key_of(parent)));
+ }
+ }
+ Some(links)
+ }
+
+ /// 关系写在子会话自己的 state.json 里:多 location 下按子会话的胜出文件认边
+ fn parent_links_in_child(&self) -> bool {
+ true
+ }
+
fn with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {
- // `~/.kimi-code` 形态(含 sessions/)则 index 在其顶层;直接选中
- // sessions 则上一层找。index 相对 dir 派生,落回默认家会拿错 cwd 映射
- let (root, index_path) = if dir.join("sessions").is_dir() {
- (dir.join("sessions"), dir.join("session_index.jsonl"))
- } else {
- let idx = dir
- .parent()
- .map(|p| p.join("session_index.jsonl"))
- .unwrap_or_else(|| dir.join("session_index.jsonl"));
- (dir, idx)
- };
- Box::new(Self {
- root,
- index_path,
- cwd_cache: MtimeCache::new(),
- })
+ // 按名字认形状(远程挂载点在第一次同步之前还不存在):sessions 目录本身、单个
+ // `wd_*` 工作目录桶;其余看选中目录里面:有 sessions/ 是 home,直接放着 wd_* 是
+ // sessions 的拷贝,都没有(home 里还没建 sessions/)按 home 算。索引相对根派生——
+ // 落回默认家会拿错 cwd 映射
+ let is_root = is_workdir_bucket(&dir)
+ || dir.file_name().is_some_and(|name| name == "sessions")
+ || (!dir.join("sessions").is_dir() && has_workdir_buckets(&dir));
+ let root = if is_root { dir } else { dir.join("sessions") };
+ Box::new(Self::from_root(root))
}
fn data_roots(&self) -> Vec<PathBuf> {
vec![self.root.clone()]
}
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use serde_json::json;
+
+ /// `<home>/sessions/wd_app_1/<id>/`:一句用户话的主转录 + 给定的 state.json
+ fn session(home: &Path, id: &str, state: &str) -> PathBuf {
+ let dir = home.join("sessions").join("wd_app_1").join(id);
+ let wire = dir.join(main_wire_rel());
+ fs::create_dir_all(wire.parent().unwrap()).unwrap();
+ fs::write(
+ &wire,
+ "{\"type\":\"turn.prompt\",\"time\":1791417601000,\"input\":[{\"type\":\"text\",\"text\":\"hi\"}],\"origin\":{\"kind\":\"user\"}}\n",
+ )
+ .unwrap();
+ fs::write(dir.join(STATE_FILE), state).unwrap();
+ dir
+ }
+
+ #[test]
+ fn half_written_state_keeps_what_was_read_before() {
+ // Kimi 用普通 writeFile 写 state.json(先截断再写):半截的那一刻沿用上次读到的,
+ // 没读到过的按没有算;读不出来(拿目录顶替文件)是不知道——父子关系整份交 None,
+ // 解析失败、留着库里的旧行
+ let tmp = tempfile::tempdir().unwrap();
+ session(tmp.path(), "session_p", "{\"title\":\"Parent\"}");
+ let child = session(
+ tmp.path(),
+ "session_c",
+ "{\"title\":\"Child\",\"forkedFrom\":\"session_p\",\"archived\":true}",
+ );
+ let link = vec![("kimi:session_c".to_string(), "kimi:session_p".to_string())];
+ let kimi = KimiAdapter::from_root(tmp.path().join("sessions"));
+ assert_eq!(kimi.parent_links(), Some(link.clone()));
+
+ fs::write(child.join(STATE_FILE), "{\"title\":\"Ch").unwrap();
+ assert_eq!(kimi.parent_links(), Some(link.clone()));
+ let r = kimi.file_ref(&child.join(main_wire_rel())).unwrap();
+ let meta = kimi.parse_session(&r).unwrap().meta;
+ assert_eq!((meta.title.as_str(), meta.archived), ("Child", true));
+ let fresh = KimiAdapter::from_root(tmp.path().join("sessions"));
+ assert_eq!(fresh.parent_links(), Some(Vec::new()));
+ assert!(!fresh.parse_session(&r).unwrap().meta.archived);
+
+ fs::remove_file(child.join(STATE_FILE)).unwrap();
+ fs::create_dir(child.join(STATE_FILE)).unwrap();
+ assert_eq!(kimi.parent_links(), Some(link));
+ let fresh = KimiAdapter::from_root(tmp.path().join("sessions"));
+ assert_eq!(fresh.parent_links(), None);
+ assert!(fresh.parse_session(&r).is_err());
+ }
+
+ #[test]
+ fn state_changes_reach_the_session_ref() {
+ // 只改了 state.json(在 Kimi 里归档、改名):它的事件换成同会话的主转录,它的 mtime /
+ // size 并进引用——不然全量扫描判不出脏,归档标记永远停在上次
+ let tmp = tempfile::tempdir().unwrap();
+ let dir = session(tmp.path(), "session_a", "{\"title\":\"A\"}");
+ let kimi = KimiAdapter::from_root(tmp.path().join("sessions"));
+ let before = kimi.file_ref(&dir.join(main_wire_rel())).unwrap();
+ let by_state = kimi.file_ref(&dir.join(STATE_FILE)).unwrap();
+ assert_eq!(by_state.file_path, before.file_path);
+ assert_eq!(by_state.native_id, "session_a");
+ assert_eq!(kimi.list_session_files().unwrap().len(), 1);
+
+ fs::write(dir.join(STATE_FILE), "{\"title\":\"A\",\"archived\":true}").unwrap();
+ let after = kimi.file_ref(&dir.join(main_wire_rel())).unwrap();
+ assert_ne!(after.size, before.size);
+ assert!(kimi.parse_session(&after).unwrap().meta.archived);
+ // 别的目录里的 state.json 不是会话
+ assert!(kimi.file_ref(&tmp.path().join(STATE_FILE)).is_none());
+ }
+
+ #[test]
+ fn kimi_code_home_is_used_only_when_it_has_sessions() {
+ let tmp = tempfile::tempdir().unwrap();
+ let fallback = home_from(None);
+ assert!(fallback.ends_with(".kimi-code"));
+ // 变量指向一个还没有会话的目录:回落默认,不让整家会话凭空消失
+ assert_eq!(home_from(Some(tmp.path().to_path_buf())), fallback);
+ fs::create_dir_all(tmp.path().join("sessions")).unwrap();
+ assert_eq!(home_from(Some(tmp.path().to_path_buf())), tmp.path());
+ }
+
+ #[test]
+ fn origins_follow_kimis_own_visibility_rules() {
+ assert_eq!(user_visible(None), Some(true));
+ for (origin, want) in [
+ (json!({"kind": "user"}), Some(true)),
+ (
+ json!({"kind": "skill_activation", "trigger": "user-slash"}),
+ Some(true),
+ ),
+ (
+ json!({"kind": "skill_activation", "trigger": "model"}),
+ Some(false),
+ ),
+ (
+ json!({"kind": "shell_command", "phase": "input"}),
+ Some(true),
+ ),
+ (json!({"kind": "background_task"}), Some(false)),
+ (
+ json!({"kind": "system_trigger", "name": "goal_continuation"}),
+ Some(false),
+ ),
+ (json!({"kind": "brand_new"}), None),
+ ] {
+ assert_eq!(user_visible(Some(&origin)), want, "{origin}");
+ }
+ }
+
+ #[test]
+ fn titles_follow_kimis_own_rules() {
+ let title = |raw: &str| parse_state(raw.as_bytes()).unwrap().title;
+ assert_eq!(
+ title(r#"{"title":"Renamed","isCustomTitle":true,"customTitle":"Old"}"#),
+ "Renamed"
+ );
+ // 老写法:改过的名字在 customTitle
+ assert_eq!(
+ title(r#"{"title":"Generated","customTitle":"Mine"}"#),
+ "Mine"
+ );
+ assert_eq!(title(r#"{"title":"New Session"}"#), "");
+ }
+
+ /// Kimi 在自己那边归档、改名只改 state.json,转录不动:监听到它也要把会话重新解析一遍;
+ /// 与转录同批到达只解析一次
+ #[test]
+ fn a_state_change_reparses_its_session() {
+ use crate::{db::Store, scanner::NullEvents, watcher::process_batch};
+ use notify::event::{EventKind, ModifyKind};
+ let tmp = tempfile::tempdir().unwrap();
+ let dir = session(tmp.path(), "session_a", "{\"title\":\"Before\"}");
+ let (wire, state) = (dir.join(main_wire_rel()), dir.join(STATE_FILE));
+ let store = Arc::new(Store::open(&tmp.path().join("wake.db")).unwrap());
+ let root = tmp.path().join("sessions");
+ let adapters: Vec<Box<dyn AgentAdapter>> =
+ vec![Box::new(KimiAdapter::from_root(root.clone()))];
+ let roots = vec![(root, 0)];
+ let batch = |paths: &[&Path]| {
+ let event = paths.iter().fold(
+ notify::Event::new(EventKind::Modify(ModifyKind::Any)),
+ |event, path| event.add_path(path.to_path_buf()),
+ );
+ process_batch(&adapters, &store, &NullEvents, &roots, vec![Ok(event)]);
+ };
+ let row = || store.get_session("kimi:session_a").unwrap().unwrap();
+
+ batch(&[&wire, &state]);
+ assert_eq!((row().title, row().archived), ("Before".to_string(), false));
+ fs::write(&state, "{\"title\":\"After\",\"archived\":true}").unwrap();
+ batch(&[&state]);
+ assert_eq!((row().title, row().archived), ("After".to_string(), true));
+ assert_eq!(row().file_path, wire.to_string_lossy());
+ }
+
+ #[test]
+ fn custom_roots_take_their_shape_from_the_name() {
+ let base = Path::new("/x/.kimi-code");
+ let adapter = KimiAdapter::new();
+ let roots = |dir: &Path| adapter.with_custom_root(dir.to_path_buf()).data_roots();
+ assert_eq!(roots(&base.join("sessions")), vec![base.join("sessions")]);
+ let bucket = base.join("sessions").join("wd_app_0123456789ab");
+ assert_eq!(roots(&bucket), vec![bucket.clone()]);
+ // home 里还没建 sessions/:照样按 home 算,建好之后列得出来
+ assert_eq!(roots(base), vec![base.join("sessions")]);
+ // 索引在 home 顶层:根是 sessions 时在上一级,是桶时在上两级
+ for root in [base.join("sessions"), bucket] {
+ assert_eq!(
+ KimiAdapter::from_root(root).index_path,
+ base.join(INDEX_FILE)
+ );
+ }
+ }
+}
diff --git a/crates/wake-core/src/adapters/kiro.rs b/crates/wake-core/src/adapters/kiro.rs
index 8625769..ad8e1ea 100644
--- a/crates/wake-core/src/adapters/kiro.rs
+++ b/crates/wake-core/src/adapters/kiro.rs
@@ -4,7 +4,7 @@ use crate::models::*;
use anyhow::Result;
use serde_json::Value;
use std::fs;
-use std::io::{BufRead, BufReader};
+use std::io::BufReader;
use std::path::{Path, PathBuf};
/// Kiro CLI:`~/.kiro/sessions/cli/<uuid>.{jsonl,json,history}` 三件套。
@@ -78,15 +78,8 @@ fn parse_kiro_jsonl(path: &Path, decode_images: bool) -> Result<(Vec<TranscriptM
let mut messages: Vec<TranscriptMessage> = Vec::new();
let mut unknown = 0u32;
- for line in reader.lines() {
- let Ok(line) = line else {
- unknown += 1;
- continue;
- };
- if line.trim().is_empty() {
- continue;
- }
- let Ok(row) = serde_json::from_str::<Value>(&line) else {
+ for row in jsonl_values(reader) {
+ let Some(row) = row? else {
unknown += 1;
continue;
};
diff --git a/crates/wake-core/src/adapters/mod.rs b/crates/wake-core/src/adapters/mod.rs
index 0f6c055..8420878 100644
--- a/crates/wake-core/src/adapters/mod.rs
+++ b/crates/wake-core/src/adapters/mod.rs
@@ -56,8 +56,10 @@ pub trait AgentAdapter: Send + Sync {
/// 根不在就是确定没有,降级为 Ok(空);Err 只表示"这一刻读不出"(库在却打不开)——
/// scanner 冻结这一家这一轮(库里归它的行原样留着),别家照常。
fn list_session_files(&self) -> Result<Vec<SessionFileRef>>;
- /// watcher 事件路径 → 本 adapter 的会话文件引用;None = 非会话文件
- /// (边车、子代理转录等)。默认:非空 .jsonl,stem 即 native_id。
+ /// watcher 事件路径 → 本 adapter 的会话文件引用;None = 与会话无关(子代理转录等)。
+ /// 解析时还要读的边车可以换成它所属会话的引用(Kimi 的 state.json):引用的 mtime / size
+ /// 要盖住解析读到的每个文件,只改了边车,全量扫描才判得出脏(Kilo legacy、Antigravity
+ /// 把索引那一行算进来是同一个道理)。默认:非空 .jsonl,stem 即 native_id。
/// 各家的路径布局知识收敛在此,watcher 不再硬编码任何 agent 特例。
fn file_ref(&self, path: &Path) -> Option<SessionFileRef> {
parse_utils::default_file_ref(self.agent(), path)
diff --git a/crates/wake-core/src/adapters/openclaw.rs b/crates/wake-core/src/adapters/openclaw.rs
index a906780..86ea2a5 100644
--- a/crates/wake-core/src/adapters/openclaw.rs
+++ b/crates/wake-core/src/adapters/openclaw.rs
@@ -7,7 +7,7 @@ use anyhow::{anyhow, Result};
use serde_json::Value;
use std::collections::{HashMap, HashSet};
use std::fs;
-use std::io::{BufRead, BufReader};
+use std::io::BufReader;
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex};
@@ -375,17 +375,10 @@ fn read_jsonl_entries(path: &Path) -> Result<(Vec<Value>, u32)> {
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,
+ for row in jsonl_values(reader) {
+ match row? {
+ Some(v) => out.push(v),
+ None => bad += 1,
}
}
Ok((out, bad))
diff --git a/crates/wake-core/src/adapters/parse_utils.rs b/crates/wake-core/src/adapters/parse_utils.rs
index fe0f372..1e471d2 100644
--- a/crates/wake-core/src/adapters/parse_utils.rs
+++ b/crates/wake-core/src/adapters/parse_utils.rs
@@ -55,6 +55,53 @@ fn consume_image_decode_budget(bytes: usize) -> bool {
})
}
+/// JSONL 逐行解成 JSON:空行跳过,读不出(坏 UTF-8)或不是 JSON 的行交成 `Ok(None)`,调用方计
+/// 未知行。读错误交一次 `Err` 就结束,调用方 `?` 出去让这次解析失败:`BufRead::lines` 遇到读
+/// 错误会一直交回同一个错误(EIO、断开的网络盘、Windows 上被别的进程锁住的文件),`continue`
+/// 接着读就是死循环——扫描线程卡在 SCAN_GATE 里,刷新弹窗永远关不掉;当成读完了,半截转录就
+/// 带着整个文件的 mtime / size 入库,文件不再变就永远停在半截。解析失败则库里的旧行原样留着、
+/// 下一轮再试
+pub fn jsonl_values<R: std::io::BufRead>(
+ reader: R,
+) -> impl Iterator<Item = std::io::Result<Option<Value>>> {
+ jsonl_lines(reader).filter_map(|line| match line {
+ Ok(Some(line)) if line.trim().is_empty() => None,
+ Ok(line) => Some(Ok(line.and_then(|line| serde_json::from_str(&line).ok()))),
+ Err(e) => Some(Err(e)),
+ })
+}
+
+/// `BufRead::lines` 加上上面那条读错误规则:坏 UTF-8 的行字节已经读过,交成 `Ok(None)` 接着读
+fn jsonl_lines<R: std::io::BufRead>(reader: R) -> JsonlLines<R> {
+ JsonlLines {
+ lines: reader.lines(),
+ done: false,
+ }
+}
+
+struct JsonlLines<R> {
+ lines: std::io::Lines<R>,
+ done: bool,
+}
+
+impl<R: std::io::BufRead> Iterator for JsonlLines<R> {
+ type Item = std::io::Result<Option<String>>;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ if self.done {
+ return None;
+ }
+ match self.lines.next()? {
+ Ok(line) => Some(Ok(Some(line))),
+ Err(e) if e.kind() == std::io::ErrorKind::InvalidData => Some(Ok(None)),
+ Err(e) => {
+ self.done = true;
+ Some(Err(e))
+ }
+ }
+ }
+}
+
/// 文件 mtime → epoch ms(各家 adapter 与 watcher 共用)
pub fn mtime_ms(meta: &std::fs::Metadata) -> i64 {
meta.modified()
@@ -392,16 +439,12 @@ impl ParsedContent {
}
/// 把新内容并入已存在的消息,并同步平移图片的正文偏移。
-pub fn append_content_to_message(
- message: &mut TranscriptMessage,
- content: ParsedContent,
- separator: &str,
-) {
+fn append_content_to_message(message: &mut TranscriptMessage, content: ParsedContent) {
let mut combined = ParsedContent {
text: std::mem::take(&mut message.text),
images: std::mem::take(&mut message.images),
};
- combined.append_with_separator(content, separator);
+ combined.append_with_separator(content, "\n\n");
message.text = combined.text;
message.images = combined.images;
}
@@ -428,14 +471,14 @@ pub fn merge_into_last_assistant(
}
if !content.text.is_empty() || !content.images.is_empty() {
if last.text.len() <= MAX_MSG_TEXT {
- append_content_to_message(last, content, "\n\n");
+ append_content_to_message(last, content);
+ if last.text.len() > MAX_MSG_TEXT {
+ last.text = clip(&last.text, MAX_MSG_TEXT).0;
+ last.truncated = true;
+ }
} else {
append_images_to_message_end(last, content.images);
}
- if last.text.len() > MAX_MSG_TEXT {
- last.text = clip(&last.text, MAX_MSG_TEXT).0;
- last.truncated = true;
- }
}
let thinking = thinking.trim();
if !thinking.is_empty() && last.thinking.as_deref().map_or(0, str::len) <= MAX_TOOL_IO {
@@ -895,6 +938,15 @@ impl<T: Clone> MtimeCache<T> {
}
/// tool_use 块 → ToolCallView(preview + pretty-print input 三件套统一)
+/// 工具调用的参数:模型常把它写成 JSON 字符串,解得开就用解开的,解不开(命令行、自由文本)
+/// 原样留着
+pub fn decoded_arguments(args: &Value) -> std::borrow::Cow<'_, Value> {
+ match args.as_str().and_then(|s| serde_json::from_str(s).ok()) {
+ Some(parsed) => std::borrow::Cow::Owned(parsed),
+ None => std::borrow::Cow::Borrowed(args),
+ }
+}
+
pub fn tool_call_view(
id: String,
name: &str,
@@ -1159,6 +1211,43 @@ pub fn make_preview(input: &Value) -> String {
mod tests {
use super::*;
+ #[test]
+ fn jsonl_lines_stop_on_a_persistent_read_error() {
+ // 一直读不出来(EIO、断开的网络盘):交一次 Err 就结束,不打转
+ struct Broken;
+ impl std::io::Read for Broken {
+ fn read(&mut self, _: &mut [u8]) -> std::io::Result<usize> {
+ Err(std::io::Error::other("disk gone"))
+ }
+ }
+ let mut lines = jsonl_lines(std::io::BufReader::new(Broken));
+ assert!(matches!(lines.next(), Some(Err(_))));
+ assert!(lines.next().is_none());
+ // 坏 UTF-8 的行跳过,接着读
+ let data: &[u8] = b"{\"a\":1}\n\xff\xfe\n{\"b\":2}\n";
+ let lines: Vec<_> = jsonl_lines(data).map(Result::unwrap).collect();
+ assert_eq!(
+ lines,
+ vec![
+ Some("{\"a\":1}".to_string()),
+ None,
+ Some("{\"b\":2}".to_string())
+ ]
+ );
+ // 解成 JSON:空行跳过,坏行与不是 JSON 的行都交 None
+ let data: &[u8] = b"{\"a\":1}\n\n \nnot json\n\xff\n{\"b\":2}";
+ let values: Vec<_> = jsonl_values(data).map(Result::unwrap).collect();
+ assert_eq!(
+ values,
+ vec![
+ Some(serde_json::json!({"a": 1})),
+ None,
+ None,
+ Some(serde_json::json!({"b": 2}))
+ ]
+ );
+ }
+
#[test]
fn merging_into_the_last_assistant_caps_text_and_thinking() {
let content = |text: &str| ParsedContent {
diff --git a/crates/wake-core/src/adapters/pi.rs b/crates/wake-core/src/adapters/pi.rs
index c133594..9a2aa36 100644
--- a/crates/wake-core/src/adapters/pi.rs
+++ b/crates/wake-core/src/adapters/pi.rs
@@ -4,7 +4,7 @@ use super::AgentAdapter;
use crate::models::*;
use anyhow::Result;
use std::fs;
-use std::io::{BufRead, BufReader};
+use std::io::BufReader;
use std::path::{Path, PathBuf};
/// Pi / Oh My Pi(omp 是 pi 的 fork,会话格式同构,只有数据根不同):
@@ -78,15 +78,8 @@ fn parse_pi_jsonl(path: &Path, decode_images: bool) -> Result<PiParse> {
// 消息渲染核心与 OpenClaw 共用(pi_format);Pi 是它的基础配置
let mut render = PiRender::new(PiRenderOptions::default(), decode_images);
- for line in reader.lines() {
- let Ok(line) = line else {
- p.unknown_lines += 1;
- continue;
- };
- if line.trim().is_empty() {
- continue;
- }
- let Ok(row) = serde_json::from_str::<serde_json::Value>(&line) else {
+ for row in jsonl_values(reader) {
+ let Some(row) = row? else {
p.unknown_lines += 1;
continue;
};
diff --git a/crates/wake-core/src/adapters/pi_format.rs b/crates/wake-core/src/adapters/pi_format.rs
index 02dbfac..3bcec8c 100644
--- a/crates/wake-core/src/adapters/pi_format.rs
+++ b/crates/wake-core/src/adapters/pi_format.rs
@@ -1,8 +1,8 @@
//! 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`。
+//! 连续 assistant(中间只隔 toolResult)合并成一条(合并与截断在
+//! `parse_utils::merge_into_last_assistant`,各家共用)。两家的差异全部落在 `PiRenderOptions`。
use super::parse_utils::*;
use crate::models::*;
@@ -137,32 +137,8 @@ impl PiRender {
self.model = model.clone();
}
// 连续 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 base = merge_into_last_assistant(&mut self.messages, ts, parsed, &thinking);
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;
}
diff --git a/crates/wake-core/src/adapters/qoder.rs b/crates/wake-core/src/adapters/qoder.rs
index ce21166..4293747 100644
--- a/crates/wake-core/src/adapters/qoder.rs
+++ b/crates/wake-core/src/adapters/qoder.rs
@@ -5,7 +5,7 @@ use anyhow::Result;
use serde_json::Value;
use std::collections::{HashMap, HashSet};
use std::fs;
-use std::io::{BufRead, BufReader};
+use std::io::BufReader;
use std::path::{Path, PathBuf};
/// Qoder CLI:`~/.qoder/projects/<project-key>/<session-id>.jsonl`。
@@ -265,23 +265,10 @@ fn parse_qoder_jsonl(path: &Path, decode_images: bool) -> Result<QoderParse> {
let mut runtime_model: Option<String> = None;
let mut unknown = 0u32;
- for line in reader.lines() {
- let line = match line {
- Ok(line) => line,
- Err(_) => {
- unknown += 1;
- continue;
- }
- };
- if line.trim().is_empty() {
+ for row in jsonl_values(reader) {
+ let Some(row) = row? else {
+ unknown += 1;
continue;
- }
- let row: Value = match serde_json::from_str(&line) {
- Ok(row) => row,
- Err(_) => {
- unknown += 1;
- continue;
- }
};
let typ = row.get("type").and_then(Value::as_str).unwrap_or("");
match typ {
diff --git a/crates/wake-core/src/db.rs b/crates/wake-core/src/db.rs
index df8ea0d..8c35558 100644
--- a/crates/wake-core/src/db.rs
+++ b/crates/wake-core/src/db.rs
@@ -212,8 +212,11 @@ CREATE TABLE IF NOT EXISTS claimed_sessions (
/// compaction 四种 part(subtask 写回用户敲的 `/命令`,其余不再计未知行),Windows 上
/// OpenCode 存的 `C:/…` 目录换回反斜杠,老行靠这轮重解析回填;
/// "10" = Kimi Code 桌面端(0.4x)的助手回复与思考(agent.message.appended)、每条记录的时间、
-/// Windows 上 `C:/…` 形态的工作目录换成反斜杠(PR #61),老行靠这轮重解析回填。
-pub const FTS_FORMAT: &str = "10";
+/// Windows 上 `C:/…` 形态的工作目录换成反斜杠(PR #61),老行靠这轮重解析回填;
+/// "11" = Kimi Code CLI 的助手回复(context.append_loop_event 的 text / think / 工具调用与结果)、
+/// 系统产生的输入记 Meta、分叉复制来的历史折成一条、迁移来的 `ses_` 会话;pi / dsh / Hermes
+/// 的回复合并改走同一个封顶合并(恰好停在上限上的回复也补截断标记),老行靠这轮重解析回填。
+pub const FTS_FORMAT: &str = "11";
fn open_conn(path: &Path) -> Result<Connection> {
if let Some(dir) = path.parent() {
diff --git a/crates/wake-core/src/mcp/tools.rs b/crates/wake-core/src/mcp/tools.rs
index fc09546..523c81f 100644
--- a/crates/wake-core/src/mcp/tools.rs
+++ b/crates/wake-core/src/mcp/tools.rs
@@ -1316,6 +1316,13 @@ fn get_session(ctx: &ToolContext, args: &Value) -> ToolResult {
plural(page.skipped_meta as i64)
));
}
+ if page.thinking_only > 0 {
+ summary.push_str(&format!(
+ "; {} thinking-only message{} (pass include_thinking to read the thinking)",
+ page.thinking_only,
+ plural(page.thinking_only as i64)
+ ));
+ }
out.push_str(&summary);
out.push_str(".\n");
// 主线页脚两张清单:挂在这条会话下面的子会话(有自己的 key,按 key 读),
diff --git a/crates/wake-core/src/services/exporter.rs b/crates/wake-core/src/services/exporter.rs
index 88aa523..11212d2 100644
--- a/crates/wake-core/src/services/exporter.rs
+++ b/crates/wake-core/src/services/exporter.rs
@@ -243,6 +243,8 @@ pub struct CompactPage {
pub rendered: usize,
/// 本页范围内被跳过的注入上下文(Meta)条数
pub skipped_meta: usize,
+ /// 本页里只有 thinking、又没要 thinking 的回复数(块里只写 "(thinking only)")
+ pub thinking_only: usize,
/// 本页首/末条消息的 seq(rendered = 0 时 None)
pub seq_range: Option<(i64, i64)>,
}
@@ -262,6 +264,7 @@ pub fn render_compact(messages: &[TranscriptMessage], o: &CompactOptions) -> Com
let mut text = String::new();
let mut rendered = 0usize;
let mut skipped_meta = 0usize;
+ let mut thinking_only = 0usize;
let mut chars = 0usize;
let mut next_seq = None;
let mut first_seq = None;
@@ -280,6 +283,7 @@ pub fn render_compact(messages: &[TranscriptMessage], o: &CompactOptions) -> Com
text.push_str(&block);
chars += block_chars;
rendered += 1;
+ thinking_only += usize::from(is_thinking_only(m, o));
first_seq.get_or_insert(m.seq);
last_seq = Some(m.seq);
}
@@ -288,10 +292,20 @@ pub fn render_compact(messages: &[TranscriptMessage], o: &CompactOptions) -> Com
next_seq,
rendered,
skipped_meta,
+ thinking_only,
seq_range: first_seq.zip(last_seq),
}
}
+/// 只想了没说(一轮停在思考上)、又没要 thinking 的回复:不是空的,怎么看由调用方写在页脚
+fn is_thinking_only(m: &TranscriptMessage, o: &CompactOptions) -> bool {
+ !o.include_thinking
+ && m.text.trim().is_empty()
+ && m.tool_calls.is_empty()
+ && m.images.is_empty()
+ && m.thinking.as_deref().is_some_and(|t| !t.trim().is_empty())
+}
+
fn compact_block(m: &TranscriptMessage, o: &CompactOptions) -> String {
let role = m.role.title();
let when = m
@@ -316,7 +330,7 @@ fn compact_block(m: &TranscriptMessage, o: &CompactOptions) -> String {
} else {
None
};
- if let Some(th) = thinking {
+ if let Some(th) = &thinking {
out.push_str("> [thinking] ");
out.push_str(&th.replace('\n', "\n> "));
out.push_str("\n\n");
@@ -324,8 +338,12 @@ fn compact_block(m: &TranscriptMessage, o: &CompactOptions) -> String {
if !body.is_empty() {
out.push_str(&body);
out.push_str("\n\n");
- } else if m.tool_calls.is_empty() {
- out.push_str("(empty)\n\n");
+ } else if m.tool_calls.is_empty() && m.images.is_empty() && thinking.is_none() {
+ out.push_str(if is_thinking_only(m, o) {
+ "(thinking only)\n\n"
+ } else {
+ "(empty)\n\n"
+ });
}
if !m.images.is_empty() {
out.push_str(&format!(
@@ -479,6 +497,28 @@ mod compact_tests {
.contains("> [compacted summary] Conversation compacted"));
}
+ #[test]
+ fn thinking_only_replies_are_not_reported_empty() {
+ let mut reply = msg(0, Role::Assistant, MessageKind::Text, "");
+ reply.thinking = Some("先想一想".into());
+ let messages = vec![reply, msg(1, Role::Assistant, MessageKind::Text, "")];
+ let hidden = render_compact(&messages, &CompactOptions::default());
+ assert!(hidden.text.contains("(thinking only)"));
+ assert_eq!(hidden.thinking_only, 1);
+ let shown = render_compact(
+ &messages,
+ &CompactOptions {
+ include_thinking: true,
+ ..Default::default()
+ },
+ );
+ assert!(shown.text.contains("> [thinking] 先想一想"));
+ assert!(!shown.text.contains("thinking only"));
+ assert_eq!(shown.thinking_only, 0);
+ // 真的什么都没有的那条才是 (empty)
+ assert_eq!(shown.text.matches("(empty)").count(), 1);
+ }
+
#[test]
fn include_flags_add_tool_io_and_thinking() {
let o = CompactOptions {
diff --git a/crates/wake-core/src/watcher.rs b/crates/wake-core/src/watcher.rs
index 01cbcaf..386e2b4 100644
--- a/crates/wake-core/src/watcher.rs
+++ b/crates/wake-core/src/watcher.rs
@@ -179,10 +179,13 @@ pub(crate) fn process_batch(
}
// 路径是否本 agent 的会话文件、native_id 怎么取,统一问**拥有
- // 该根的实例**(下标即 roots 表登记的归属)
+ // 该根的实例**(下标即 roots 表登记的归属)。file_ref 可以把边车换成它所属的会话
+ // 文件(见 trait 文档),边车与正文同批变了只解析一次
+ let mut seen = HashSet::new();
let refs: Vec<SessionFileRef> = present
.into_iter()
.filter_map(|(path, ix)| adapters.get(ix).and_then(|a| a.file_ref(&path)))
+ .filter(|r| seen.insert(r.file_path.clone()))
.collect();
let scanned_agents: HashSet<AgentId> = refs.iter().map(|reference| reference.agent).collect();
if !refs.is_empty() {
diff --git a/crates/wake-core/tests/adapter_contracts.rs b/crates/wake-core/tests/adapter_contracts.rs
index bceb048..2ebca4f 100644
--- a/crates/wake-core/tests/adapter_contracts.rs
+++ b/crates/wake-core/tests/adapter_contracts.rs
@@ -1950,8 +1950,8 @@ fn kimi_parse_contract() {
/// Kimi Code 桌面端(0.4x)的 wire(PR #61):助手回复在 agent.message.appended,包装层
/// `{message, meta}`;一次模型调用一条事件、多半只有 think,同一轮连续的助手事件并成
/// 一条回复(turn.step.* 不分割),think 进 thinking;新的一轮另起一条,哪怕那一轮的输入
-/// 渲染不出来(只带视频)、没有用户消息隔开。user / tool 角色跳过,不认识的角色与缺包装层
-/// 都计未知行;每行带事件时间。列表走 list_session_files——主代理的 wire.jsonl 按路径分段
+/// 渲染不出来(只带视频)、没有用户消息隔开。user 角色与 turn.prompt 重复、跳过,tool 角色
+/// 回填到调用上,不认识的角色与缺包装层都计未知行;每行带事件时间。列表走 list_session_files——主代理的 wire.jsonl 按路径分段
/// 认,原先按字符串比 `/agents/main/wire.jsonl`,Windows 的反斜杠路径一条都列不出来;
/// Kimi 在 Windows 上记的 `c:/…` 工作目录换成别家同款写法
#[test]
@@ -2015,6 +2015,141 @@ fn kimi_desktop_wire_contract() {
assert_seq_contract(adapter.as_ref(), r);
}
+/// Kimi Code CLI(agent-core 0.29)的真实记录流(合成 fixture,形状照 Kimi 自己的
+/// `reduceWireRecords`):助手回复按步写在 context.append_loop_event(think / text 块、
+/// tool.call 与 tool.result),同一轮的各步并成一条、工具结果回填;用户输入的
+/// context.append_message 回声跳过,只带视频的输入渲染不出来时由回声顶上;后台任务通知
+/// 这类系统产生的输入记 Meta,注入与目标续跑不显示;压缩摘要单独一条;不认识的 origin 与
+/// 记录类型计未知行。另有分叉会话(forked 之前折成一条、挂回父会话、已归档)与从旧版
+/// kimi-cli 迁移来的 `ses_` 会话(只有 context.append_message、没有时间)
+#[test]
+fn kimi_cli_wire_contract() {
+ setup();
+ let main_id = "session_c1111111-aaaa-bbbb-cccc-000000000001";
+ let fork_id = "session_c2222222-aaaa-bbbb-cccc-000000000002";
+ let migrated_id = "ses_c3333333-aaaa-bbbb-cccc-000000000003";
+ let adapter = KimiAdapter::new().with_custom_root(fixture("kimi-cli"));
+ let refs: std::collections::HashMap<String, SessionFileRef> = adapter
+ .list_session_files()
+ .expect("kimi list")
+ .into_iter()
+ .map(|r| (r.native_id.clone(), r))
+ .collect();
+ let mut ids: Vec<&str> = refs.keys().map(String::as_str).collect();
+ ids.sort();
+ assert_eq!(ids, vec![migrated_id, main_id, fork_id]);
+
+ let r = &refs[main_id];
+ let t = adapter.parse_transcript(r).expect("kimi cli transcript");
+ assert_eq!(
+ roles_kinds(&t.mainline),
+ vec![
+ (Role::User, MessageKind::Text),
+ (Role::Assistant, MessageKind::Text),
+ (Role::User, MessageKind::Meta),
+ (Role::User, MessageKind::Text),
+ (Role::Assistant, MessageKind::Text),
+ (Role::System, MessageKind::CompactSummary),
+ (Role::User, MessageKind::Meta),
+ ]
+ );
+ let m = &t.mainline;
+ assert_eq!(m[0].text, "QrScanner 的 useEffect 有内存泄漏,修一下");
+ assert_eq!(m[0].timestamp, Some(ms("2026-10-08T00:00:01Z")));
+ // 两步并成一条:think 进 thinking,工具结果回填到调用上
+ assert_eq!(m[1].text, "我先看看 QrScanner。\n\n缺了清理回调,已补上。");
+ assert_eq!(m[1].thinking.as_deref(), Some("先读 QrScanner"));
+ let calls: Vec<(&str, &str, bool)> = m[1]
+ .tool_calls
+ .iter()
+ .map(|c| {
+ (
+ c.name.as_str(),
+ c.output.as_deref().unwrap_or(""),
+ c.is_error,
+ )
+ })
+ .collect();
+ assert_eq!(
+ calls,
+ vec![(
+ "ReadFile",
+ "useEffect(() => { scanner.start() }, [])",
+ false
+ )]
+ );
+ assert!(m[2].text.starts_with("<notification"));
+ // 只带视频的输入渲染不出来:由进上下文的那份回声顶上
+ assert_eq!(m[3].text, "<video path=\"/tmp/demo.mp4\"></video>");
+ assert_eq!(m[4].text, "视频里按钮错位了。");
+ assert_eq!(m[4].tool_calls[0].output.as_deref(), Some("1 failing"));
+ assert!(m[4].tool_calls[0].is_error);
+ assert!(m[5].text.contains("QrScanner 的内存泄漏"));
+ assert_eq!(m[6].text, "来源不认识的输入");
+ // 不认识的 origin 一次 + 不认识的记录类型一次;用量、请求快照、权限等都认得
+ assert_eq!(t.unknown_line_count, 2);
+ let s = adapter.parse_session(r).expect("kimi cli session");
+ assert_eq!(s.meta.title, "修 QrScanner 泄漏");
+ assert_eq!(s.meta.project_path, "/Users/tester/Github/wakefx");
+ assert_eq!(s.meta.message_count, 4);
+ assert!(!s.meta.archived);
+ assert_seq_contract(adapter.as_ref(), r);
+
+ // 分叉:forked 之前从父会话复制来的那段折成一条;state.json 的 archived 照搬
+ let fork = adapter
+ .parse_transcript(&refs[fork_id])
+ .expect("kimi fork transcript");
+ assert_eq!(
+ roles_kinds(&fork.mainline),
+ vec![
+ (Role::System, MessageKind::Meta),
+ (Role::User, MessageKind::Text),
+ (Role::Assistant, MessageKind::Text),
+ ]
+ );
+ assert!(fork.mainline[0]
+ .text
+ .contains("2 messages inherited from the parent session"));
+ assert_eq!(fork.mainline[2].text, "已抽成 useQrScanner。");
+ assert!(fork.meta.archived);
+ assert_eq!(
+ adapter.parent_links(),
+ Some(vec![(format!("kimi:{fork_id}"), format!("kimi:{main_id}"))])
+ );
+
+ // 迁移来的会话:没有 turn 记录,用户消息来自 context.append_message
+ let migrated = adapter
+ .parse_transcript(&refs[migrated_id])
+ .expect("kimi migrated transcript");
+ assert_eq!(
+ roles_kinds(&migrated.mainline),
+ vec![
+ (Role::User, MessageKind::Text),
+ (Role::Assistant, MessageKind::Text),
+ ]
+ );
+ assert_eq!(
+ migrated.mainline[1].text,
+ "我来查一下。\n\n目录里只有 README。"
+ );
+ assert_eq!(
+ migrated.mainline[1].tool_calls[0].output.as_deref(),
+ Some("README.md")
+ );
+ assert_eq!(migrated.unknown_line_count, 0);
+
+ // 自定义 location 只选到某个 wd_* 工作目录桶:会话照样列得出,工作目录照样查得到
+ let bucket = KimiAdapter::new()
+ .with_custom_root(fixture("kimi-cli").join("sessions").join("wd_wakefx_cli1"));
+ let listed = bucket.list_session_files().expect("kimi bucket list");
+ assert_eq!(listed.len(), 3);
+ let one = listed.iter().find(|r| r.native_id == main_id).unwrap();
+ assert_eq!(
+ bucket.parse_session(one).unwrap().meta.project_path,
+ "/Users/tester/Github/wakefx"
+ );
+}
+
#[test]
fn antigravity_parse_contract() {
let env = setup();
@@ -2351,6 +2486,48 @@ fn overlapping_watch_roots_dispatch_to_deepest() {
);
}
+/// 列会话与 file_ref(watcher 的入口)必须是同一个判据。假 HOME 是 copy_tree 拷出来的,路径
+/// 用本平台的分隔符,所以 Windows CI 上这里跑的就是反斜杠路径——拿写死 `/` 的字符串比路径的
+/// file_ref 在那里一条都对不上:会话只在全量扫描时出现,实时更新全丢(Kimi 在 PR #61 之前
+/// 在 Windows 上连列都列不出来,Cursor / Gemini 的实时更新、Claude 的子代理过滤同病)。
+/// 只看真实文件:SQLite 型的 `<db>#<id>` 虚拟路径不走 watcher
+#[test]
+fn listed_sessions_round_trip_through_file_ref() {
+ setup();
+ for adapter in wake_core::adapters::create_adapters() {
+ let tag = adapter.agent().as_str();
+ for r in adapter.list_session_files().unwrap_or_default() {
+ let path = Path::new(&r.file_path);
+ if !path.is_file() {
+ continue;
+ }
+ let back = adapter
+ .file_ref(path)
+ .unwrap_or_else(|| panic!("[{tag}] file_ref 不认列表里的 {}", r.file_path));
+ assert_eq!(back.native_id, r.native_id, "[{tag}] {}", r.file_path);
+ // 戳也得一样:边车并进引用的家,两条路算出来的不一样,增量与全量就互相判脏
+ assert_eq!(
+ (back.mtime_ms, back.size),
+ (r.mtime_ms, r.size),
+ "[{tag}] {}",
+ r.file_path
+ );
+ }
+ }
+ // 反过来:子代理转录(文件确实在)不是会话,按所在目录拒掉。逐段 join,Windows 上同样是
+ // 反斜杠路径
+ let mut sub = fixture("claude");
+ sub.extend([
+ "projects",
+ "-Users-tester-Github-wakefx",
+ "11111111-aaaa-bbbb-cccc-000000000001",
+ "subagents",
+ "agent-fixture01.jsonl",
+ ]);
+ assert!(sub.is_file());
+ assert!(ClaudeAdapter::new().file_ref(&sub).is_none());
+}
+
#[test]
fn data_roots_contract() {
// roster 覆盖契约:create_adapters 返回全量各家(不按 detect 过滤,
diff --git a/crates/wake-core/tests/common/mod.rs b/crates/wake-core/tests/common/mod.rs
index 524eb1b..97821b8 100644
--- a/crates/wake-core/tests/common/mod.rs
+++ b/crates/wake-core/tests/common/mod.rs
@@ -1091,6 +1091,7 @@ pub fn clear_agent_env_overrides() {
"CODEBUDDY_CONFIG_DIR",
"WORKBUDDY_CONFIG_DIR",
"ZCODE_STORAGE_DIR",
+ "KIMI_CODE_HOME",
// 库路径的覆盖:指向现存文件时会被加进数据根,读到合成 HOME 之外的真实库
"OPENCODE_DB",
"KILO_DB",
diff --git a/crates/wake-core/tests/fixtures/kimi-cli/session_index.jsonl b/crates/wake-core/tests/fixtures/kimi-cli/session_index.jsonl
new file mode 100644
index 0000000..feef687
--- /dev/null
+++ b/crates/wake-core/tests/fixtures/kimi-cli/session_index.jsonl
@@ -0,0 +1,3 @@
+{"sessionId": "session_c1111111-aaaa-bbbb-cccc-000000000001", "sessionDir": "/x", "workDir": "/Users/tester/Github/wakefx"}
+{"sessionId": "session_c2222222-aaaa-bbbb-cccc-000000000002", "sessionDir": "/x", "workDir": "/Users/tester/Github/wakefx"}
+{"sessionId": "ses_c3333333-aaaa-bbbb-cccc-000000000003", "sessionDir": "/x", "workDir": "/Users/tester/Github/wakefx"}
diff --git a/crates/wake-core/tests/fixtures/kimi-cli/sessions/wd_wakefx_cli1/ses_c3333333-aaaa-bbbb-cccc-000000000003/agents/main/wire.jsonl b/crates/wake-core/tests/fixtures/kimi-cli/sessions/wd_wakefx_cli1/ses_c3333333-aaaa-bbbb-cccc-000000000003/agents/main/wire.jsonl
new file mode 100644
index 0000000..6e6f345
--- /dev/null
+++ b/crates/wake-core/tests/fixtures/kimi-cli/sessions/wd_wakefx_cli1/ses_c3333333-aaaa-bbbb-cccc-000000000003/agents/main/wire.jsonl
@@ -0,0 +1,5 @@
+{"type":"metadata","protocol_version":"1.0","created_at":1786000000000}
+{"type":"context.append_message","message":{"role":"user","content":[{"type":"text","text":"旧版里问过的问题"}],"toolCalls":[]}}
+{"type":"context.append_message","message":{"role":"assistant","content":[{"type":"text","text":"我来查一下。"}],"toolCalls":[{"type":"function","id":"call_1","name":"Shell","arguments":"{\"command\":\"ls\"}"}]}}
+{"type":"context.append_message","message":{"role":"tool","content":[{"type":"text","text":"README.md"}],"toolCalls":[],"toolCallId":"call_1"}}
+{"type":"context.append_message","message":{"role":"assistant","content":[{"type":"text","text":"目录里只有 README。"}],"toolCalls":[]}}
diff --git a/crates/wake-core/tests/fixtures/kimi-cli/sessions/wd_wakefx_cli1/ses_c3333333-aaaa-bbbb-cccc-000000000003/state.json b/crates/wake-core/tests/fixtures/kimi-cli/sessions/wd_wakefx_cli1/ses_c3333333-aaaa-bbbb-cccc-000000000003/state.json
new file mode 100644
index 0000000..4369b91
--- /dev/null
+++ b/crates/wake-core/tests/fixtures/kimi-cli/sessions/wd_wakefx_cli1/ses_c3333333-aaaa-bbbb-cccc-000000000003/state.json
@@ -0,0 +1,8 @@
+{
+ "title": "旧版会话",
+ "custom": {
+ "imported_from_kimi_cli": true
+ },
+ "createdAt": "2026-08-26T00:00:00.000Z",
+ "updatedAt": "2026-08-26T00:10:00.000Z"
+}
diff --git a/crates/wake-core/tests/fixtures/kimi-cli/sessions/wd_wakefx_cli1/session_c1111111-aaaa-bbbb-cccc-000000000001/agents/main/wire.jsonl b/crates/wake-core/tests/fixtures/kimi-cli/sessions/wd_wakefx_cli1/session_c1111111-aaaa-bbbb-cccc-000000000001/agents/main/wire.jsonl
new file mode 100644
index 0000000..0fc4c19
--- /dev/null
+++ b/crates/wake-core/tests/fixtures/kimi-cli/sessions/wd_wakefx_cli1/session_c1111111-aaaa-bbbb-cccc-000000000001/agents/main/wire.jsonl
@@ -0,0 +1,33 @@
+{"type":"metadata","protocol_version":"1.5","created_at":1791417600000}
+{"type":"config.update","time":1791417600100,"profileName":"agent"}
+{"type":"tools.set_active_tools","time":1791417600200,"names":["ReadFile","Shell"]}
+{"type":"permission.set_mode","time":1791417600300,"mode":"default"}
+{"type":"turn.prompt","time":1791417601000,"input":[{"type":"text","text":"QrScanner 的 useEffect 有内存泄漏,修一下"}],"origin":{"kind":"user"}}
+{"type":"context.append_message","time":1791417601001,"message":{"role":"user","content":[{"type":"text","text":"QrScanner 的 useEffect 有内存泄漏,修一下"}],"toolCalls":[],"origin":{"kind":"user"}}}
+{"type":"llm.tools_snapshot","time":1791417601100,"tools":[]}
+{"type":"llm.request","time":1791417601200,"model":"kimi-k2"}
+{"type":"context.append_loop_event","time":1791417602000,"event":{"type":"step.begin","uuid":"st-1","turnId":"1","step":1}}
+{"type":"context.append_loop_event","time":1791417602100,"event":{"type":"content.part","uuid":"p-1","turnId":"1","step":1,"stepUuid":"st-1","part":{"type":"think","think":"先读 QrScanner"}}}
+{"type":"context.append_loop_event","time":1791417602200,"event":{"type":"content.part","uuid":"p-2","turnId":"1","step":1,"stepUuid":"st-1","part":{"type":"text","text":"我先看看 QrScanner。"}}}
+{"type":"context.append_loop_event","time":1791417602300,"event":{"type":"tool.call","uuid":"tc-1","turnId":"1","step":1,"stepUuid":"st-1","toolCallId":"tc-1","name":"ReadFile","args":{"path":"src/QrScanner.tsx"}}}
+{"type":"context.append_loop_event","time":1791417602400,"event":{"type":"tool.result","parentUuid":"tc-1","toolCallId":"tc-1","result":{"output":"useEffect(() => { scanner.start() }, [])","isError":false}}}
+{"type":"context.append_loop_event","time":1791417602500,"event":{"type":"step.end","uuid":"st-1","turnId":"1","step":1}}
+{"type":"usage.record","time":1791417602600,"model":"kimi-k2","usage":{"input":100,"output":20}}
+{"type":"llm.request","time":1791417602700,"model":"kimi-k2"}
+{"type":"context.append_loop_event","time":1791417603000,"event":{"type":"step.begin","uuid":"st-2","turnId":"1","step":2}}
+{"type":"context.append_loop_event","time":1791417603100,"event":{"type":"content.part","uuid":"p-3","turnId":"1","step":1,"stepUuid":"st-2","part":{"type":"text","text":"缺了清理回调,已补上。"}}}
+{"type":"context.append_loop_event","time":1791417603200,"event":{"type":"step.end","uuid":"st-2","turnId":"1","step":2}}
+{"type":"turn.steer","time":1791417610000,"input":[{"type":"text","text":"<notification id=\"task:7\" category=\"task\">后台测试跑完了</notification>"}],"origin":{"kind":"background_task","taskId":"7"}}
+{"type":"context.append_message","time":1791417610001,"message":{"role":"user","content":[{"type":"text","text":"<notification id=\"task:7\" category=\"task\">后台测试跑完了</notification>"}],"toolCalls":[],"origin":{"kind":"background_task","taskId":"7"}}}
+{"type":"context.append_message","time":1791417610002,"message":{"role":"user","content":[{"type":"text","text":"<system-reminder>\n图片已压缩\n</system-reminder>"}],"toolCalls":[],"origin":{"kind":"injection","variant":"image_compression"}}}
+{"type":"turn.prompt","time":1791417620000,"input":[{"type":"video_url","videoUrl":{"url":"file:///tmp/demo.mp4"}}],"origin":{"kind":"user"}}
+{"type":"context.append_message","time":1791417620001,"message":{"role":"user","content":[{"type":"text","text":"<video path=\"/tmp/demo.mp4\"></video>"}],"toolCalls":[],"origin":{"kind":"user"}}}
+{"type":"context.append_loop_event","time":1791417621000,"event":{"type":"step.begin","uuid":"st-3","turnId":"2","step":1}}
+{"type":"context.append_loop_event","time":1791417621100,"event":{"type":"content.part","uuid":"p-4","turnId":"2","step":1,"stepUuid":"st-3","part":{"type":"text","text":"视频里按钮错位了。"}}}
+{"type":"context.append_loop_event","time":1791417621200,"event":{"type":"tool.call","uuid":"tc-2","turnId":"2","step":1,"stepUuid":"st-3","toolCallId":"tc-2","name":"Shell","args":{"command":"npm test"}}}
+{"type":"context.append_loop_event","time":1791417621300,"event":{"type":"tool.result","parentUuid":"tc-2","toolCallId":"tc-2","result":{"output":[{"type":"text","text":"1 failing"}],"isError":true}}}
+{"type":"context.append_loop_event","time":1791417621400,"event":{"type":"step.end","uuid":"st-3","turnId":"2","step":1}}
+{"type":"context.apply_compaction","time":1791417630000,"summary":"之前修了 QrScanner 的内存泄漏,并查了视频里的按钮错位","compactedCount":6}
+{"type":"context.append_message","time":1791417631000,"message":{"role":"user","content":[{"type":"text","text":"继续推进目标"}],"toolCalls":[],"origin":{"kind":"system_trigger","name":"goal_continuation"}}}
+{"type":"turn.prompt","time":1791417640000,"input":[{"type":"text","text":"来源不认识的输入"}],"origin":{"kind":"alien_origin"}}
+{"type":"mystery.record","time":1791417641000}
diff --git a/crates/wake-core/tests/fixtures/kimi-cli/sessions/wd_wakefx_cli1/session_c1111111-aaaa-bbbb-cccc-000000000001/state.json b/crates/wake-core/tests/fixtures/kimi-cli/sessions/wd_wakefx_cli1/session_c1111111-aaaa-bbbb-cccc-000000000001/state.json
new file mode 100644
index 0000000..931b226
--- /dev/null
+++ b/crates/wake-core/tests/fixtures/kimi-cli/sessions/wd_wakefx_cli1/session_c1111111-aaaa-bbbb-cccc-000000000001/state.json
@@ -0,0 +1,5 @@
+{
+ "title": "修 QrScanner 泄漏",
+ "createdAt": "2026-10-08T00:00:00.000Z",
+ "updatedAt": "2026-10-08T00:00:41.000Z"
+}
diff --git a/crates/wake-core/tests/fixtures/kimi-cli/sessions/wd_wakefx_cli1/session_c2222222-aaaa-bbbb-cccc-000000000002/agents/main/wire.jsonl b/crates/wake-core/tests/fixtures/kimi-cli/sessions/wd_wakefx_cli1/session_c2222222-aaaa-bbbb-cccc-000000000002/agents/main/wire.jsonl
new file mode 100644
index 0000000..d54889f
--- /dev/null
+++ b/crates/wake-core/tests/fixtures/kimi-cli/sessions/wd_wakefx_cli1/session_c2222222-aaaa-bbbb-cccc-000000000002/agents/main/wire.jsonl
@@ -0,0 +1,25 @@
+{"type":"metadata","protocol_version":"1.5","created_at":1791417600000}
+{"type":"config.update","time":1791417600100,"profileName":"agent"}
+{"type":"tools.set_active_tools","time":1791417600200,"names":["ReadFile","Shell"]}
+{"type":"permission.set_mode","time":1791417600300,"mode":"default"}
+{"type":"turn.prompt","time":1791417601000,"input":[{"type":"text","text":"QrScanner 的 useEffect 有内存泄漏,修一下"}],"origin":{"kind":"user"}}
+{"type":"context.append_message","time":1791417601001,"message":{"role":"user","content":[{"type":"text","text":"QrScanner 的 useEffect 有内存泄漏,修一下"}],"toolCalls":[],"origin":{"kind":"user"}}}
+{"type":"llm.tools_snapshot","time":1791417601100,"tools":[]}
+{"type":"llm.request","time":1791417601200,"model":"kimi-k2"}
+{"type":"context.append_loop_event","time":1791417602000,"event":{"type":"step.begin","uuid":"st-1","turnId":"1","step":1}}
+{"type":"context.append_loop_event","time":1791417602100,"event":{"type":"content.part","uuid":"p-1","turnId":"1","step":1,"stepUuid":"st-1","part":{"type":"think","think":"先读 QrScanner"}}}
+{"type":"context.append_loop_event","time":1791417602200,"event":{"type":"content.part","uuid":"p-2","turnId":"1","step":1,"stepUuid":"st-1","part":{"type":"text","text":"我先看看 QrScanner。"}}}
+{"type":"context.append_loop_event","time":1791417602300,"event":{"type":"tool.call","uuid":"tc-1","turnId":"1","step":1,"stepUuid":"st-1","toolCallId":"tc-1","name":"ReadFile","args":{"path":"src/QrScanner.tsx"}}}
+{"type":"context.append_loop_event","time":1791417602400,"event":{"type":"tool.result","parentUuid":"tc-1","toolCallId":"tc-1","result":{"output":"useEffect(() => { scanner.start() }, [])","isError":false}}}
+{"type":"context.append_loop_event","time":1791417602500,"event":{"type":"step.end","uuid":"st-1","turnId":"1","step":1}}
+{"type":"usage.record","time":1791417602600,"model":"kimi-k2","usage":{"input":100,"output":20}}
+{"type":"llm.request","time":1791417602700,"model":"kimi-k2"}
+{"type":"context.append_loop_event","time":1791417603000,"event":{"type":"step.begin","uuid":"st-2","turnId":"1","step":2}}
+{"type":"context.append_loop_event","time":1791417603100,"event":{"type":"content.part","uuid":"p-3","turnId":"1","step":1,"stepUuid":"st-2","part":{"type":"text","text":"缺了清理回调,已补上。"}}}
+{"type":"context.append_loop_event","time":1791417603200,"event":{"type":"step.end","uuid":"st-2","turnId":"1","step":2}}
+{"type":"forked","time":1791417650000}
+{"type":"turn.prompt","time":1791417651000,"input":[{"type":"text","text":"换个思路:把扫描器提到 hook 里"}],"origin":{"kind":"user"}}
+{"type":"context.append_message","time":1791417651001,"message":{"role":"user","content":[{"type":"text","text":"换个思路:把扫描器提到 hook 里"}],"toolCalls":[],"origin":{"kind":"user"}}}
+{"type":"context.append_loop_event","time":1791417652000,"event":{"type":"step.begin","uuid":"st-9","turnId":"2","step":1}}
+{"type":"context.append_loop_event","time":1791417652100,"event":{"type":"content.part","uuid":"p-9","turnId":"2","step":1,"stepUuid":"st-9","part":{"type":"text","text":"已抽成 useQrScanner。"}}}
+{"type":"context.append_loop_event","time":1791417652200,"event":{"type":"step.end","uuid":"st-9","turnId":"2","step":1}}
diff --git a/crates/wake-core/tests/fixtures/kimi-cli/sessions/wd_wakefx_cli1/session_c2222222-aaaa-bbbb-cccc-000000000002/state.json b/crates/wake-core/tests/fixtures/kimi-cli/sessions/wd_wakefx_cli1/session_c2222222-aaaa-bbbb-cccc-000000000002/state.json
new file mode 100644
index 0000000..24082b6
--- /dev/null
+++ b/crates/wake-core/tests/fixtures/kimi-cli/sessions/wd_wakefx_cli1/session_c2222222-aaaa-bbbb-cccc-000000000002/state.json
@@ -0,0 +1,7 @@
+{
+ "title": "修 QrScanner 泄漏",
+ "forkedFrom": "session_c1111111-aaaa-bbbb-cccc-000000000001",
+ "archived": true,
+ "createdAt": "2026-10-08T00:00:50.000Z",
+ "updatedAt": "2026-10-08T00:00:52.000Z"
+}
diff --git a/crates/wake-core/tests/scanner_finale.rs b/crates/wake-core/tests/scanner_finale.rs
index 8dc4e5b..2223d15 100644
--- a/crates/wake-core/tests/scanner_finale.rs
+++ b/crates/wake-core/tests/scanner_finale.rs
@@ -1355,6 +1355,54 @@ fn dsh_newer_generation_takes_over_an_indexed_older_one() {
);
}
+/// Kimi 分叉:关系写在子会话自己的 state.json(`forkedFrom`),全量扫描后子会话挂在父会话
+/// 下面;state.json 的 archived 照搬进索引
+#[test]
+fn kimi_forks_nest_under_their_parent() {
+ use wake_core::adapters::kimi::KimiAdapter;
+ let adapters: Vec<Box<dyn AgentAdapter>> =
+ vec![KimiAdapter::new().with_custom_root(common::fixture("kimi-cli"))];
+ let dir = tempfile::tempdir().unwrap();
+ let store = temp_store(dir.path());
+ run_scan(&adapters, &store, &Recorder::new(), true).unwrap();
+ let parent = "kimi:session_c1111111-aaaa-bbbb-cccc-000000000001";
+ let child = "kimi:session_c2222222-aaaa-bbbb-cccc-000000000002";
+ assert_eq!(store.parent_key_of(child).unwrap().as_deref(), Some(parent));
+ assert!(store.get_session(child).unwrap().unwrap().archived);
+ assert!(!store.get_session(parent).unwrap().unwrap().archived);
+}
+
+/// Kimi 的归档、改名只写 state.json:增量扫描按引用判脏,state.json 的 mtime / size 并在
+/// 引用里,才会重新解析(转录没变、旧引用照旧的话,归档标记永远停在上次)
+#[test]
+fn kimi_state_only_changes_reach_the_index() {
+ use wake_core::adapters::kimi::KimiAdapter;
+ let home = tempfile::tempdir().unwrap();
+ common::copy_tree(&common::fixture("kimi-cli"), home.path());
+ let adapters: Vec<Box<dyn AgentAdapter>> =
+ vec![KimiAdapter::new().with_custom_root(home.path().to_path_buf())];
+ let dir = tempfile::tempdir().unwrap();
+ let store = temp_store(dir.path());
+ run_scan(&adapters, &store, &Recorder::new(), true).unwrap();
+ let key = "kimi:session_c1111111-aaaa-bbbb-cccc-000000000001";
+ assert!(!store.get_session(key).unwrap().unwrap().archived);
+
+ let mut state = home.path().to_path_buf();
+ state.extend([
+ "sessions",
+ "wd_wakefx_cli1",
+ "session_c1111111-aaaa-bbbb-cccc-000000000001",
+ "state.json",
+ ]);
+ std::fs::write(
+ &state,
+ r#"{"title":"修 QrScanner 泄漏","archived":true,"createdAt":"2026-10-08T00:00:00.000Z"}"#,
+ )
+ .unwrap();
+ run_scan(&adapters, &store, &Recorder::new(), false).unwrap();
+ assert!(store.get_session(key).unwrap().unwrap().archived);
+}
+
/// Antigravity:索引里先只有卡片,明文转录后来才写出来——同一个 key 由转录接替
/// (`dedup_rank`,转录的 mtime 与卡片的时间毫不相干),增量与全量两条写路径都是;
/// 转录目录没了、索引还在,卡片回来。库里始终只有一行