feat(kimi-agent): session include_subagents read surface (G-1.4 close)

Closes the resume/replay data gap recorded in CODEX §1.4 #2:
- session/list gains include_subagents (default false) and now filters
  subagent records (swarm-*/task-* written via Agent::durable_state) from
  the default user-facing list — a behavior fix
- session/get_context gains include_subagents; when set, the response
  carries a subagents summary list (agent_id, title, message_count,
  updated_at) — agent_id is the session id since subagents persist under
  agent_id keys in the same sessions table
- wire.gen.ts regenerated via gen-wire-contract (141 types, idempotent);
  SessionSummaryRpc/SessionListResult/SessionContextResult untouched, so
  kimi-server is unaffected (cargo check -p kimi-server clean)
- integration test: default list hides subagents, opt-in lists them,
  get_context returns the summary only when requested
- vscode host wiring (replay-adapter consumption shape) left for a
  separate confirmation; documented in CODEX

Author: 7723qqq

CODEX_MIGRATION_PLAN.md

@@ -47,7 +47,7 @@
 ## 1.4 已知缺口（不阻塞主线的记录）
 
 1. ~~**compaction summarizer 双通道**~~ ✅ **已补（2026-08-10）**：`LlmCompactionDelegate`（任意 `LLM` 实现）+ `ensure_compaction_delegate` 宿主分支——无 native LLM 的 host-proxy 会话经 `HostLlmProxy`（`HostCallbacks::llm_chat`）走宿主通道 compact（原报 `compaction.unable`）；单测 + stdio 集成适配（`session_compact_host_proxy_gets_a_summarizer_delegate`）
-2. **子代理 replay 数据源**：🔶 部分补（2026-08-10）：Task 工具子代理在任务被跟踪时（task_service 存在）经 `run_child_agent_persistent_with_model` 持久化对话到 session store（agent_id = task_id，swarm 同一机制）——resume 面的**数据源已建立**；剩余：resume/session RPC 的 `include_subagents` 读取面（引擎无此参数）待补，vscode replay 测试仍跳过
+2. ~~**子代理 replay 数据源**~~ ✅ **已补（2026-08-10 数据源 + 2026-08-11 读取面）**：Task 工具子代理在任务被跟踪时（task_service 存在）经 `run_child_agent_persistent_with_model` 持久化对话到 session store（agent_id = task_id，swarm 同一机制）；读取面：`session/list` 支持 `include_subagents`（默认过滤子代理记录，opt-in 全量），`session/get_context` 支持 `include_subagents` → 响应 `subagents` 摘要列表（agent_id/消息数/updated_at，`SubagentSummaryRpc`）；单测 + stdio 集成（`session_list_and_context_include_subagents`）。**宿主接线待定**：vscode harness 的 `includeSubagents` 尚未透传到 RPC、replay-adapter 消费的是完整 replay 而非摘要（`parentAgentId` 关联引擎未持久化）——vscode 为白名单包，改需单独确认
 3. **用户真实 config.toml 损坏**：`duplicate defaultModel`（defaultModel 与 default_model 并存）导致 Rust TOML 严格解析拒绝整个配置（用户禁止修改真实文件，隔离配置验证绕开；建议用户侧删 camelCase 行）
 
 > **2026-08-10 收口复核**：原第 4-6 项已消失——vscode typecheck 全过（`replay-adapter.ts` 错误已随 sdk-local 完成消除）；kosong 已退役（flaky 测试随包）；发布打包已接入 CI（`_rust-bin-build.yml` + release 注入）；**vscode legacy backfill 已闭环**（kimi-runtime.ts 迁移会话读 `kimi_cli_source_path` → 写 `vscode_legacy_approval` metadata → session-runtime 消费，create/resume 全链路完整）。另：apps/kimi-code 的 `@moonshot-ai/kimi-agent` devDep 已删（全仓无真实 import，仅注释引用 wire.gen）。

crates/kimi-protocol/src/wire_types.rs

@@ -95,6 +95,16 @@ pub struct SessionIdParams {
     pub session_id: String,
 }
 
+/// Input for `session/get_context` — session id plus the resume replay
+/// switch: when `include_subagents` is true, the result carries subagent
+/// session summaries (Task/swarm children persisted under their agent_id).
+#[derive(Debug, Deserialize)]
+pub struct SessionGetContextParams {
+    pub session_id: String,
+    #[serde(default)]
+    pub include_subagents: Option<bool>,
+}
+
 /// Input for session/fork.
 #[derive(Debug, Deserialize)]
 pub struct SessionForkParams {
@@ -472,6 +482,12 @@ pub struct SessionListParams {
     pub limit: Option<usize>,
     #[serde(default)]
     pub offset: Option<usize>,
+    /// When true, subagent sessions (Task/swarm children persisted under
+    /// their agent_id — see `run_child_agent_persistent_with_model`) are
+    /// included in `sessions`. Default false: the list is main sessions
+    /// only — subagent records are replay data, not user sessions.
+    #[serde(default)]
+    pub include_subagents: Option<bool>,
 }
 
 /// A message in the conversation history.
@@ -801,6 +817,39 @@ pub struct SessionListResult {
     pub sessions: Vec<SessionSummaryRpc>,
 }
 
+/// A subagent session summary returned by `session/get_context` when
+/// `include_subagents` is true. Task/swarm children persist their
+/// conversation in the same `sessions` table keyed by agent id, so
+/// `agent_id` IS the record's session id — the two are one value.
+#[derive(Debug, Serialize)]
+pub struct SubagentSummaryRpc {
+    /// The child agent id — the session id the conversation was persisted
+    /// under (`task_id` for tracked Task children, `swarm-<ts>-<rand>` for
+    /// swarm children).
+    pub agent_id: String,
+    /// Display title. Subagent records carry no title of their own; hosts
+    /// render the task description or agent id instead. Kept for symmetry
+    /// with `SessionSummaryRpc`.
+    #[serde(default)]
+    pub title: String,
+    /// Message count (context history length).
+    pub message_count: usize,
+    /// ISO-8601 last-write timestamp of the persisted record.
+    pub updated_at: String,
+}
+
+/// Result of `session/get_context` when `include_subagents` is requested:
+/// the context snapshot plus subagent session summaries. `subagents` is
+/// omitted when empty, keeping the wire identical to `AgentContextData`
+/// for callers that do not opt in.
+#[derive(Debug, Serialize)]
+pub struct SessionGetContextResult {
+    pub history: Vec<crate::context::ContextMessage>,
+    pub token_count: u64,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub subagents: Vec<SubagentSummaryRpc>,
+}
+
 /// A plugin summary returned by `plugin/list` (and embedded in `plugin/get`).
 #[derive(Debug, Serialize)]
 pub struct PluginSummaryRpc {

packages/kimi-agent/src/main.rs

@@ -1243,17 +1243,53 @@ async fn main() -> anyhow::Result<()> {
     RpcServer::register_arc(&server, types::methods::SESSION_GET_CONTEXT, move |params| {
         let mgr = mgr.clone();
         Box::pin(async move {
-            let input: types::SessionGoalParams = serde_json::from_value(params)
+            let input: types::SessionGetContextParams = serde_json::from_value(params)
                 .map_err(|e| types::JsonRpcError::internal_error(format!("Invalid params: {e}")))?;
             let mut manager = mgr.lock().await;
-            let agent = manager.get_agent(&input.session_id).ok_or_else(|| {
-                types::JsonRpcError::internal_error(format!(
-                    "no agent for session: {}",
-                    input.session_id
-                ))
-            })?;
-            serde_json::to_value(agent.context.data())
-                .map_err(|e| types::JsonRpcError::internal_error(format!("serialize context: {e}")))
+            let data = {
+                let agent = manager.get_agent(&input.session_id).ok_or_else(|| {
+                    types::JsonRpcError::internal_error(format!(
+                        "no agent for session: {}",
+                        input.session_id
+                    ))
+                })?;
+                agent.context.data()
+            };
+            // Resume replay surface (include_subagents): Task/swarm children
+            // persist their conversations under their agent_id in the same
+            // store; summarize them when the host opts in. The page is
+            // effectively unbounded (100k) — subagent summaries are small
+            // and never user-facing.
+            let subagents = if input.include_subagents.unwrap_or(false) {
+                manager
+                    .list_persisted(100_000, 0)
+                    .map_err(|e| types::JsonRpcError::internal_error(e.to_string()))?
+                    .into_iter()
+                    .filter(|record| record.is_subagent())
+                    .map(|record| {
+                        let message_count = record
+                            .state_json
+                            .get("context")
+                            .and_then(|v| v.as_array())
+                            .map(|context| context.len())
+                            .unwrap_or(0);
+                        types::SubagentSummaryRpc {
+                            agent_id: record.id,
+                            title: String::new(),
+                            message_count,
+                            updated_at: record.updated_at,
+                        }
+                    })
+                    .collect()
+            } else {
+                Vec::new()
+            };
+            serde_json::to_value(types::SessionGetContextResult {
+                history: data.history,
+                token_count: data.token_count,
+                subagents,
+            })
+            .map_err(|e| types::JsonRpcError::internal_error(format!("serialize context: {e}")))
         })
     });
 
@@ -1821,11 +1857,16 @@ async fn main() -> anyhow::Result<()> {
         Box::pin(async move {
             let input: types::SessionListParams =
                 serde_json::from_value(params).unwrap_or_default();
+            let include_subagents = input.include_subagents.unwrap_or(false);
             let manager = mgr.lock().await;
             let sessions = manager
                 .list_persisted(input.limit.unwrap_or(50), input.offset.unwrap_or(0))
                 .map_err(|e| types::JsonRpcError::internal_error(e.to_string()))?
                 .into_iter()
+                // Default: main sessions only. Subagent records (Task/swarm
+                // children persisted under their agent_id) are replay data,
+                // not user sessions — including them pollutes the list.
+                .filter(|record| include_subagents || !record.is_subagent())
                 .map(|record| {
                     // The rich session record (work_dir/title) lives inside
                     // state_json; degrade gracefully to the id-only shape.

packages/kimi-agent/src/persistence/session_store.rs

@@ -115,6 +115,25 @@ impl SessionStore {
     }
 }
 
+impl SessionRecord {
+    /// True when this record is a subagent session — a Task/swarm child
+    /// persisted under its agent_id (`TaskInfoBase.agent_id`):
+    ///
+    /// - main sessions serialize `state_json` from
+    ///   `crate::session::types::SessionRecord` (a valid shape), while
+    /// - subagent children write `Agent::durable_state()` (context / goal /
+    ///   metadata …), which lacks the record's key fields and fails (or
+    ///   fails the shape check) on deserialization.
+    ///
+    /// Unreadable or shape-invalid legacy records classify as subagent —
+    /// they are not trustworthy main sessions either way.
+    pub fn is_subagent(&self) -> bool {
+        serde_json::from_value::<crate::session::types::SessionRecord>(self.state_json.clone())
+            .map(|record| !record.is_valid_shape())
+            .unwrap_or(true)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -185,4 +204,63 @@ mod tests {
         store.delete_session("sess-1").unwrap();
         assert!(store.load_session("sess-1").unwrap().is_none());
     }
-}
+
+    #[test]
+    fn test_is_subagent_classifies_records() {
+        use crate::session::types::{ModelConfig, SessionRecord as MainSessionRecord};
+
+        let store = SessionStore::new(SqliteStore::in_memory().unwrap());
+
+        // Main-session shape: state_json is a serialized SessionRecord.
+        let mut main = MainSessionRecord::new("sess-main", ModelConfig::default());
+        main.title = "main".to_string();
+        main.work_dir = "/work".to_string();
+        main.agent_state = serde_json::json!({
+            "goal": null,
+            "context": [{"role": "user", "content": "hi"}],
+            "metadata": {},
+        });
+        store
+            .save_session(&SessionRecord {
+                id: main.id.clone(),
+                created_at: main.created_at.clone(),
+                updated_at: main.updated_at.clone(),
+                config_json: Value::Null,
+                state_json: serde_json::to_value(&main).unwrap(),
+            })
+            .unwrap();
+
+        // Subagent shape: Agent::durable_state() — no SessionRecord key
+        // fields (id/created_at/updated_at), so deserialization fails.
+        store
+            .save_session(&SessionRecord {
+                id: "task-abc12345".into(),
+                created_at: "2025-01-01T00:00:00Z".into(),
+                updated_at: "2025-01-01T01:00:00Z".into(),
+                config_json: Value::Null,
+                state_json: serde_json::json!({
+                    "goal": null,
+                    "context": [
+                        {"role": "user", "content": "a"},
+                        {"role": "assistant", "content": "b"},
+                    ],
+                    "turn_counter": 1,
+                    "token_count": 12,
+                    "metadata": {},
+                }),
+            })
+            .unwrap();
+
+        let all = store.list_sessions(100, 0).unwrap();
+        let main = all.iter().find(|r| r.id == "sess-main").unwrap();
+        let sub = all.iter().find(|r| r.id == "task-abc12345").unwrap();
+        assert!(
+            !main.is_subagent(),
+            "main-session record must not classify as subagent"
+        );
+        assert!(
+            sub.is_subagent(),
+            "durable-state record must classify as subagent"
+        );
+    }
+}

packages/kimi-agent/src/rpc/wire.gen.ts

@@ -304,6 +304,11 @@ export interface SessionIdParams {
   session_id: string;
 }
 
+export interface SessionGetContextParams {
+  session_id: string;
+  include_subagents?: boolean | undefined;
+}
+
 export interface SessionForkParams {
   /** The source session to fork from. */
   session_id: string;
@@ -539,6 +544,7 @@ export interface SessionRenameParams {
 export interface SessionListParams {
   limit?: number | undefined;
   offset?: number | undefined;
+  include_subagents?: boolean | undefined;
 }
 
 export type ContentBlock =
@@ -724,6 +730,22 @@ export interface SessionListResult {
   sessions: Array<SessionSummaryRpc>;
 }
 
+export interface SubagentSummaryRpc {
+  /** The child agent id — the session id the conversation was persisted under (`task_id` for tracked Task children, `swarm-<ts>-<rand>` for swarm children). */
+  agent_id: string;
+  title?: string;
+  /** Message count (context history length). */
+  message_count: number;
+  /** ISO-8601 last-write timestamp of the persisted record. */
+  updated_at: string;
+}
+
+export interface SessionGetContextResult {
+  history: Array<ContextMessage>;
+  token_count: number;
+  subagents?: Array<SubagentSummaryRpc>;
+}
+
 export interface PluginSummaryRpc {
   id: string;
   display_name: string;