@zhushanwen/subagent-core 0.4.0 → 0.5.1

package/src/execution/session-file-gc.ts

@@ -2,11 +2,19 @@
 //
 // 概率性清理过期 subagent session 文件（TTL 30 天）。
 // session_start 时调用，best-effort（失败不影响启动）。
+//
+// [D8 池引用计数接线] 同概率门内追加引擎池 TTL 兜底（cleanupExpiredPoolRefs）：
+// journal / refs.json 条目按同 30 天 mtime 回收。record 主数据（主 session 文件里
+// 的 subagent-record entry）由 pi 侧管理，其删除对 core 无触发点——done record 的
+// journal 没有精确回收锚，只能靠此兜底；workflow 域（taskId 占位无 record 生命周期
+// 锚）同样依赖它（D8 分域口径「journal 依赖 30 天 TTL 自然回收」的落地）。
 
 import * as fs from "node:fs";
 import * as path from "node:path";
 
 import { isProcessAlive, readAliveMarker } from "./alive-store.ts";
+import { getEngineDataDir } from "./engine/common/data-dir.ts";
+import { cleanupExpiredPoolRefs } from "./engine/common/pool-manager.ts";
 
 /** 30 天 TTL（毫秒）。 */
 const TTL_DAYS = 30;
@@ -29,21 +37,105 @@ const SUBAGENTS_DIR = "subagents";
  *   1. 概率性触发（CLEANUP_PROBABILITY）
  *   2. 递归扫描 <agentDir>/subagents 下所有 .jsonl 文件
  *   3. mtime 超 TTL → unlink
+ *   4. [D8] 引擎池 TTL 兜底：journal / refs 条目超龄回收（见文件头注释）
  */
 export function maybeCleanupExpiredSessionFiles(agentDir: string, cwd: string): void {
   void cwd;
   try {
     if (Math.random() >= CLEANUP_PROBABILITY) return;
     const dir = path.join(agentDir, SUBAGENTS_DIR);
-    if (!fs.existsSync(dir)) return;
-    const now = Date.now();
-    walkAndClean(dir, now);
+    if (fs.existsSync(dir)) {
+      walkAndClean(dir, Date.now());
+    }
+    cleanupEnginePoolsBestEffort();
   } catch (_e) {
     // best-effort：任何异常不阻断 session_start
     void _e;
   }
 }
 
+/** 引擎池 TTL 兜底（dataDir 解析失败 = 未配置宿主服务，best-effort 吞掉）。 */
+function cleanupEnginePoolsBestEffort(): void {
+  try {
+    cleanupExpiredPoolRefs(getEngineDataDir(), TTL_MS);
+  } catch (_e) {
+    void _e;
+  }
+}
+
+/** 孤儿 sidecar 名判定：.cancelled/.finalized/.alive，以及 [MF#2] patch 回传
+ *  （<branch>.patch 按 branch 命名，与 .jsonl basename 无关联，删除 .jsonl 时无法同删；
+ *  作为孤儿按 TTL 清理，避免永久堆积）。 */
+function isOrphanSidecarName(name: string): boolean {
+  return (
+    name.endsWith(".cancelled") ||
+    name.endsWith(".finalized") ||
+    name.endsWith(".alive") ||
+    name.endsWith(".patch")
+  );
+}
+
+/** stat 超 TTL 即 unlink（manifest .json 与孤儿 sidecar 共用原语）。失败静默（文件可能已被删除）。 */
+function unlinkIfExpired(full: string, now: number): void {
+  try {
+    const stat = fs.statSync(full);
+    if (now - stat.mtimeMs > TTL_MS) {
+      fs.unlinkSync(full);
+    }
+  } catch (_e) {
+    // 文件可能已被删除，忽略
+    void _e;
+  }
+}
+
+/** .jsonl 超 TTL 清理：.alive 探活保护（活进程的 session 不删，D-024 安全网）+
+ *  同名 sidecar 一起清理。失败静默（文件可能已被删除）。 */
+function cleanExpiredJsonl(full: string, now: number): void {
+  try {
+    const stat = fs.statSync(full);
+    if (now - stat.mtimeMs > TTL_MS) {
+      // .alive 探活：活进程的 session 不删（D-024 安全网）。
+      const aliveMarker = readAliveMarker(full);
+      if (aliveMarker !== undefined && isProcessAlive(aliveMarker.pid)) {
+        return; // 活进程 → 跳过，不清理
+      }
+      fs.unlinkSync(full);
+      // 同名 sidecar 一起清理。
+      for (const ext of [".cancelled", ".finalized", ".alive"]) {
+        try { fs.unlinkSync(`${full}${ext}`); } catch (_e) { void _e; /* sidecar 可能不存在 */ }
+      }
+    }
+  } catch (_e) {
+    // 文件可能已被删除，忽略
+    void _e;
+  }
+}
+
+/** 单条 dirent 分发。分支判断顺序与 fs 副作用时序保持与原实现一致：
+ *  目录递归 →（records 内）manifest .json → .jsonl → 孤儿 sidecar。 */
+function cleanDirent(dir: string, entry: fs.Dirent, now: number, allowManifestJson: boolean): void {
+  const full = path.join(dir, entry.name);
+  if (entry.isDirectory()) {
+    // 只在进入名为 records 的子目录时打开 manifest .json 清理。
+    // records 在 <enc>/records/ 下递归自动覆盖；其他位置（如 subagents/worktrees.json）
+    // 不能匹配 .json——否则会误删 worktree reaper 依赖的状态文件。
+    walkAndClean(full, now, entry.name === "records");
+  } else if (
+    allowManifestJson &&
+    entry.name.endsWith(".json") &&
+    // 跳过 .tmp.：recoverTmpFiles（session_start）同步处理 tmp，GC 不重复。
+    // 不校验内容——30 天 mtime 已是强 orphan 信号，扩展名 + 文件名足够。
+    !entry.name.includes(".tmp.")
+  ) {
+    unlinkIfExpired(full, now);
+  } else if (entry.name.endsWith(".jsonl")) {
+    cleanExpiredJsonl(full, now);
+  } else if (isOrphanSidecarName(entry.name)) {
+    // 孤儿 sidecar（兄弟 .jsonl 已被外部删除）：按同 TTL 清理。
+    unlinkIfExpired(full, now);
+  }
+}
+
 /** 递归扫描目录，unlink 超 TTL 的 .jsonl 文件及其 .cancelled sidecar。
  *  [F2] 进入名为 records 的子目录时，额外清理超 TTL 的 manifest .json（跳过 .tmp.——
  *  recoverTmpFiles 同步处理）。allowManifestJson 仅由父调用按目录名开启，其他位置
@@ -57,64 +149,6 @@ function walkAndClean(dir: string, now: number, allowManifestJson = false): void
     return;
   }
   for (const entry of entries) {
-    const full = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      // 只在进入名为 records 的子目录时打开 manifest .json 清理。
-      // records 在 <enc>/records/ 下递归自动覆盖；其他位置（如 subagents/worktrees.json）
-      // 不能匹配 .json——否则会误删 worktree reaper 依赖的状态文件。
-      walkAndClean(full, now, entry.name === "records");
-    } else if (
-      allowManifestJson &&
-      entry.name.endsWith(".json") &&
-      // 跳过 .tmp.：recoverTmpFiles（session_start）同步处理 tmp，GC 不重复。
-      // 不校验内容——30 天 mtime 已是强 orphan 信号，扩展名 + 文件名足够。
-      !entry.name.includes(".tmp.")
-    ) {
-      try {
-        const stat = fs.statSync(full);
-        if (now - stat.mtimeMs > TTL_MS) {
-          fs.unlinkSync(full);
-        }
-      } catch (_e) {
-        // 文件可能已被删除，忽略
-        void _e;
-      }
-    } else if (entry.name.endsWith(".jsonl")) {
-      try {
-        const stat = fs.statSync(full);
-        if (now - stat.mtimeMs > TTL_MS) {
-          // .alive 探活：活进程的 session 不删（D-024 安全网）。
-          const aliveMarker = readAliveMarker(full);
-          if (aliveMarker !== undefined && isProcessAlive(aliveMarker.pid)) {
-            continue; // 活进程 → 跳过，不清理
-          }
-          fs.unlinkSync(full);
-          // 同名 sidecar 一起清理。
-          for (const ext of [".cancelled", ".finalized", ".alive"]) {
-            try { fs.unlinkSync(`${full}${ext}`); } catch (_e) { void _e; /* sidecar 可能不存在 */ }
-          }
-        }
-      } catch (_e) {
-        // 文件可能已被删除，忽略
-        void _e;
-      }
-    } else if (
-      entry.name.endsWith(".cancelled") ||
-      entry.name.endsWith(".finalized") ||
-      entry.name.endsWith(".alive") ||
-      // [MF#2] patch 回传（<branch>.patch）按 branch 命名，与 .jsonl basename 无关联，
-      // 删除 .jsonl 时无法同删；作为孤儿按 TTL 清理，避免永久堆积。
-      entry.name.endsWith(".patch")
-    ) {
-      // 孤儿 sidecar（兄弟 .jsonl 已被外部删除）：按同 TTL 清理。
-      try {
-        const stat = fs.statSync(full);
-        if (now - stat.mtimeMs > TTL_MS) {
-          fs.unlinkSync(full);
-        }
-      } catch (_e) {
-        void _e;
-      }
-    }
+    cleanDirent(dir, entry, now, allowManifestJson);
   }
 }

package/src/execution/session-reconstructor.ts

@@ -274,39 +274,16 @@ interface PendingToolCall {
 }
 
 // ============================================================
-// 公开函数
+// 全量重建内部 helper（按处理阶段拆分：读文件 → 扫身份 → 重建 turns → 组装）
 // ============================================================
 
 /**
- * 从 session.jsonl 重建完整 SubagentRecord 数据。
- *
- *   ╔══════════════════════════════════════════════════════════════════╗
- *   ║  1. readFileSync(sessionFile) + 逐行 JSON.parse（跳 header）       ║
- *   ║     （损坏行静默跳过；失败 → undefined）                           ║
- *   ║  2. 扫 custom entry（customType:"subagent-identity"）→ 身份        ║
- *   ║     缺 identity → undefined（无法构造 record）                     ║
- *   ║  3. 顺序遍历 message entries：                                    ║
- *   ║     - role:"assistant" → 开新 Turn                                ║
- *   ║       text/thinking 累积；usage → usageDelta                      ║
- *   ║       toolCall block → 待匹配队列；stopReason error → lastError  ║
- *   ║     - role:"toolResult" → 配对 toolCallId                         ║
- *   ║       产 InternalToolCall(done/failed)推进请求 Turn              ║
- *   ║  4. 闭合所有 turn；算 turnCount/totalTokens/result/eventLog       ║
- *   ╚══════════════════════════════════════════════════════════════════╝
- *
- * 返回 undefined：文件缺失/空/损坏/缺 identity entry/无 assistant message。
- * 不抛——消费方（collectRecords）降级跳过该 record。
- *
- * status 由最后一条 assistant message 的 stopReason 推导（error/aborted → failed，
- * 其余 → done）。cancelled 由 tombstone override（record-store 层），本函数不感知。
- *
- * [perf] 本函数是重路径（全文读 + 全 entry 解析）。列表扫描用 readIdentityHeader
- * （只读头部 identity），详情才走本函数（RecordStore.getFullRecord 懒加载）。
+ * 读文件 + 逐行 JSON.parse（session.jsonl = newline-delimited JSON）。
+ * 第 1 行是 session header（type:"session"，跳过）；后续每行一个 entry。
+ * 损坏行静默跳过（与 SDK parseSessionEntries 行为一致）。
+ * @returns 文件缺失/读失败 → undefined；否则 entry 数组（可能为空）。
  */
-export function reconstructFromFile(sessionFile: string): ReconstructedRecord | undefined {
-  // 读文件 + 逐行 JSON.parse（session.jsonl = newline-delimited JSON）。
-  // 第 1 行是 session header（跳过）；后续每行一个 entry。
-  // 损坏行静默跳过（与 SDK parseSessionEntries 行为一致）。
+function readJsonlEntries(sessionFile: string): JsonlEntry[] | undefined {
   let raw: string;
   try {
     raw = fs.readFileSync(sessionFile, "utf-8");
@@ -338,10 +315,18 @@ export function reconstructFromFile(sessionFile: string): ReconstructedRecord |
       void _e; // 损坏行跳过（不阻断后续行）。
     }
   }
+  return entries;
+}
 
-  if (entries.length === 0) return undefined;
+/** 身份/模型扫描产出（identity custom entry + 途经的 model/thinking_level change）。 */
+interface IdentityScan {
+  identity: SubagentIdentityData | undefined;
+  model: string;
+  thinkingLevel: string | undefined;
+}
 
-  // ── 扫身份 custom entry（必须存在，否则无法构造 record）──
+/** 扫 identity custom entry（必须存在，否则无法构造 record）+ 途经 model/thinking_level。 */
+function scanIdentityAndModel(entries: JsonlEntry[]): IdentityScan {
   let identity: SubagentIdentityData | undefined;
   let model = "";
   let thinkingLevel: string | undefined;
@@ -357,14 +342,95 @@ export function reconstructFromFile(sessionFile: string): ReconstructedRecord |
       if (typeof entry.thinkingLevel === "string") thinkingLevel = entry.thinkingLevel;
     }
   }
-  if (!identity) return undefined; // 缺身份 → 无法构造 record。
+  return { identity, model, thinkingLevel };
+}
+
+/** message entries 重建产出（turns + 跨 entry 累积状态）。 */
+interface RebuiltTurns {
+  turns: Turn[];
+  lastError: string | undefined;
+  totalTokens: number;
+  /** 最后一条 entry 的时间戳（ms），推导 endedAt（避免重建 record 耗时随墙钟无限增长）。 */
+  lastEntryTsMs: number | undefined;
+}
+
+/**
+ * assistant message → 填充调用方已创建的空 Turn：text/thinking 累积；toolCall block 进
+ * 待匹配队列；usage → usageDelta（token 总量增量返回给调用方累加）。
+ *
+ * stopReason 语义（与 updateFromEvent 一致）：error/aborted → 设 lastError；
+ * stop（正常结束）→ 清 lastError（镜像 turn_end 的清除语义，即前序 turn 的瞬态
+ * error 在后续成功 turn 后恢复，不误判 success=false）；其余 stopReason → 保持
+ * prevLastError 原值。 [v4 B-1] status 恒 closed 后 lastStopReason 不再参与推导，死变量已删。
+ *
+ * content 非数组 → 跳过 usage/stopReason 处理（镜像原实现的 continue）：turn 仍存在
+ * （由调用方 push），lastError 透传 prevLastError、token 增量为 0。
+ */
+function applyAssistantMessage(
+  msg: JsonlAssistantMessage,
+  turn: Turn,
+  pending: PendingToolCall[],
+  prevLastError: string | undefined,
+): { lastError: string | undefined; totalTokensDelta: number } {
+  if (!Array.isArray(msg.content)) {
+    return { lastError: prevLastError, totalTokensDelta: 0 };
+  }
+  for (const block of msg.content) {
+    if (block.type === "text") {
+      turn.text += block.text;
+    } else if (block.type === "thinking") {
+      turn.thinking += block.thinking;
+    } else if (block.type === "toolCall") {
+      pending.push({
+        toolCallId: block.id,
+        toolName: block.name,
+        args: block.arguments,
+        turn,
+        startedTs: msg.timestamp,
+      });
+    }
+  }
+
+  let totalTokensDelta = 0;
+  if (msg.usage) {
+    const u = toAgentUsage(msg.usage);
+    turn.usageDelta = addUsage(turn.usageDelta, u);
+    totalTokensDelta = u.input + u.output + u.cacheRead + u.cacheWrite;
+  }
+
+  let lastError = prevLastError;
+  if (msg.stopReason === "error" || msg.stopReason === "aborted") {
+    lastError = msg.errorMessage ?? msg.stopReason;
+  } else if (msg.stopReason === "stop") {
+    lastError = undefined;
+  }
+  return { lastError, totalTokensDelta };
+}
 
-  // ── 重建 turns[] ──
+/** toolResult message → 按 toolCallId 配对回填 InternalToolCall；未配对（孤儿）→ 丢弃。 */
+function applyToolResultMessage(msg: JsonlToolResultMessage, pending: PendingToolCall[]): void {
+  const idx = pending.findIndex((p) => p.toolCallId === msg.toolCallId);
+  if (idx >= 0) {
+    const p = pending[idx];
+    pending.splice(idx, 1);
+    const tc: InternalToolCall = {
+      toolName: p.toolName,
+      args: p.args,
+      result: { content: msg.content, details: msg.details },
+      isError: msg.isError ?? false,
+      _status: msg.isError ? "failed" : "done",
+      startedTs: p.startedTs,
+    };
+    p.turn.toolCalls.push(tc);
+  }
+}
+
+/** 顺序遍历 entries 重建 turns[]（assistant 开 turn / toolResult 配对回填；user 跳过）。 */
+function rebuildTurns(entries: JsonlEntry[]): RebuiltTurns {
   const turns: Turn[] = [];
   const pending: PendingToolCall[] = [];
   let lastError: string | undefined;
   let totalTokens = 0;
-  /** 最后一条 entry 的时间戳（ms），推导 endedAt（避免重建 record 耗时随墙钟无限增长）。 */
   let lastEntryTsMs: number | undefined;
 
   for (const entry of entries) {
@@ -383,81 +449,38 @@ export function reconstructFromFile(sessionFile: string): ReconstructedRecord |
     if (msg.role === "assistant") {
       const turn = emptyTurn();
       turns.push(turn);
-
-      if (!Array.isArray(msg.content)) continue;
-      for (const block of msg.content) {
-        if (block.type === "text") {
-          turn.text += block.text;
-        } else if (block.type === "thinking") {
-          turn.thinking += block.thinking;
-        } else if (block.type === "toolCall") {
-          pending.push({
-            toolCallId: block.id,
-            toolName: block.name,
-            args: block.arguments,
-            turn,
-            startedTs: msg.timestamp,
-          });
-        }
-      }
-
-      if (msg.usage) {
-        const u = toAgentUsage(msg.usage);
-        turn.usageDelta = addUsage(turn.usageDelta, u);
-        totalTokens += u.input + u.output + u.cacheRead + u.cacheWrite;
-      }
-
-      // stopReason 驱动 lastError（与 updateFromEvent 一致）：
-      // error/aborted → 设 lastError；stop（正常结束）→ 清 lastError（镜像 turn_end 的清除语义，
-      // 即前序 turn 的瞬态 error 在后续成功 turn 后恢复，不误判 success=false）。
-      // [v4 B-1] status 恒 closed 后 lastStopReason 不再参与推导，死变量已删。
-      if (msg.stopReason === "error" || msg.stopReason === "aborted") {
-        lastError = msg.errorMessage ?? msg.stopReason;
-      } else if (msg.stopReason === "stop") {
-        lastError = undefined;
-      }
+      const applied = applyAssistantMessage(msg, turn, pending, lastError);
+      totalTokens += applied.totalTokensDelta;
+      lastError = applied.lastError;
     } else if (msg.role === "toolResult") {
-      const idx = pending.findIndex((p) => p.toolCallId === msg.toolCallId);
-      if (idx >= 0) {
-        const p = pending[idx];
-        pending.splice(idx, 1);
-        const tc: InternalToolCall = {
-          toolName: p.toolName,
-          args: p.args,
-          result: { content: msg.content, details: msg.details },
-          isError: msg.isError ?? false,
-          _status: msg.isError ? "failed" : "done",
-          startedTs: p.startedTs,
-        };
-        p.turn.toolCalls.push(tc);
-      }
-      // 未配对（孤儿 toolResult）→ 丢弃。
+      applyToolResultMessage(msg, pending);
     }
     // role:"user" → 跳过（task 来自 identity custom entry）。
   }
+  return { turns, lastError, totalTokens, lastEntryTsMs };
+}
 
-  if (turns.length === 0) return undefined; // 无 assistant message → 空壳，降级。
-
-  // 闭合所有 turn（重建的是历史，全是已完成 turn）。
-  for (const turn of turns) {
-    turn.closed = true;
-  }
-
-  const turnCount = turns.length;
-  const resultText = turns
-    .map((t) => t.text)
-    .filter((t) => t.length > 0)
-    .join("\n\n");
-
-  // eventLog 从 turns[] 派生（与活态 record 的 getEventLog 同形，消费方无感知差异）。
-  const eventLog = deriveEventLog(turns, lastError, identity.startedAt);
-
+/** 组装 ReconstructedRecord（终态投影：status 恒 closed/gc + 身份字段归一化 + 派生数据）。 */
+function buildReconstructedRecord(
+  sessionFile: string,
+  identity: SubagentIdentityData,
+  rebuilt: RebuiltTurns,
+  eventLog: AgentEventLogEntry[],
+  model: string,
+  thinkingLevel: string | undefined,
+): ReconstructedRecord {
   // 终态 status：最后一条 assistant message 的 stopReason 推导（与 finalizeRecord 的判定一致）。
   // SP-1：done/failed 合并为 closed，cancelled 由 tombstone override（record-store 层），本函数不感知。
   const status: ExecutionStatus = "closed";
   // closedReason 统 gc（通用完成/失败）。error/aborted 的区分由 error 字段保留。
   const closedReason: import("./types.ts").ClosedReason = "gc";
 
+  const turnCount = rebuilt.turns.length;
+  const resultText = rebuilt.turns
+    .map((t) => t.text)
+    .filter((t) => t.length > 0)
+    .join("\n\n");
+
   // rootSessionId 归一化：新文件读 rootSessionId，旧文件 fallback parentSessionId。
   const rootSessionId = identity.rootSessionId ?? identity.parentSessionId;
   // slug 兜底：旧 identity entry 无 slug 字段 → 空串（与 SubagentRecord.slug: string 契约一致）。
@@ -472,19 +495,74 @@ export function reconstructFromFile(sessionFile: string): ReconstructedRecord |
     sessionFile,
     status,
     closedReason,
-    turns,
+    turns: rebuilt.turns,
     turnCount,
-    totalTokens,
-    lastError,
+    totalTokens: rebuilt.totalTokens,
+    lastError: rebuilt.lastError,
     model,
     thinkingLevel,
-    endedAt: lastEntryTsMs,
+    endedAt: rebuilt.lastEntryTsMs,
     result: resultText.length > 0 ? resultText : undefined,
-    error: lastError,
+    error: rebuilt.lastError,
     eventLog,
   };
 }
 
+// ============================================================
+// 公开函数
+// ============================================================
+
+/**
+ * 从 session.jsonl 重建完整 SubagentRecord 数据。
+ *
+ *   ╔══════════════════════════════════════════════════════════════════╗
+ *   ║  1. readFileSync(sessionFile) + 逐行 JSON.parse（跳 header）       ║
+ *   ║     （损坏行静默跳过；失败 → undefined）                           ║
+ *   ║  2. 扫 custom entry（customType:"subagent-identity"）→ 身份        ║
+ *   ║     缺 identity → undefined（无法构造 record）                     ║
+ *   ║  3. 顺序遍历 message entries：                                    ║
+ *   ║     - role:"assistant" → 开新 Turn                                ║
+ *   ║       text/thinking 累积；usage → usageDelta                      ║
+ *   ║       toolCall block → 待匹配队列；stopReason error → lastError  ║
+ *   ║     - role:"toolResult" → 配对 toolCallId                         ║
+ *   ║       产 InternalToolCall(done/failed)推进请求 Turn              ║
+ *   ║  4. 闭合所有 turn；算 turnCount/totalTokens/result/eventLog       ║
+ *   ╚══════════════════════════════════════════════════════════════════╝
+ *
+ * 返回 undefined：文件缺失/空/损坏/缺 identity entry/无 assistant message。
+ * 不抛——消费方（collectRecords）降级跳过该 record。
+ *
+ * status 由最后一条 assistant message 的 stopReason 推导（error/aborted → failed，
+ * 其余 → done）。cancelled 由 tombstone override（record-store 层），本函数不感知。
+ *
+ * [perf] 本函数是重路径（全文读 + 全 entry 解析）。列表扫描用 readIdentityHeader
+ * （只读头部 identity），详情才走本函数（RecordStore.getFullRecord 懒加载）。
+ */
+export function reconstructFromFile(sessionFile: string): ReconstructedRecord | undefined {
+  // 1. 读文件 + 逐行 JSON.parse（readJsonlEntries：损坏行静默跳过；文件缺失 → undefined）。
+  const entries = readJsonlEntries(sessionFile);
+  if (!entries || entries.length === 0) return undefined;
+
+  // 2. 扫身份 custom entry（scanIdentityAndModel：identity 缺失 → 无法构造 record）。
+  const { identity, model, thinkingLevel } = scanIdentityAndModel(entries);
+  if (!identity) return undefined; // 缺身份 → 无法构造 record。
+
+  // 3. 重建 turns[]（rebuildTurns：assistant 开 turn / toolResult 配对回填）。
+  const rebuilt = rebuildTurns(entries);
+  if (rebuilt.turns.length === 0) return undefined; // 无 assistant message → 空壳，降级。
+
+  // 4. 闭合所有 turn（重建的是历史，全是已完成 turn）。
+  for (const turn of rebuilt.turns) {
+    turn.closed = true;
+  }
+
+  // eventLog 从 turns[] 派生（与活态 record 的 getEventLog 同形，消费方无感知差异）。
+  // 必须在闭合 turn 之后派生（deriveEventLog 读 turn.closed）。
+  const eventLog = deriveEventLog(rebuilt.turns, rebuilt.lastError, identity.startedAt);
+
+  return buildReconstructedRecord(sessionFile, identity, rebuilt, eventLog, model, thinkingLevel);
+}
+
 // ============================================================
 // 轻量头部读取（列表扫描用）
 // ============================================================
@@ -615,48 +693,62 @@ export function readIdentityTail(sessionFile: string): IdentityHeaderRecon | und
   return undefined;
 }
 
-/** 从文本片段解析 identity（头部/全文两入口共享）。解析到 identity 即停（返回）；
- *  找不到返回 undefined。model/thinking_level 仅在 identity 之前的途经 entry 中
- *  best-effort 提取，详情场景由全量重建补齐。 */
-function parseIdentityFromText(text: string, sessionFile: string): IdentityHeaderRecon | undefined {
-  let identity: SubagentIdentityData | undefined;
-  let model = "";
-  let thinkingLevel: string | undefined;
-  for (const line of text.split("\n")) {
-    const s = line.trim();
-    if (!s) continue;
-    // 预筛（[S-4] 同款值匹配）：只有含三种目标 entry 值串的行才值得 JSON.parse——
-    // head 64KB 内大 toolResult 行（数十 KB/行）占多数，全量 parse 是冷扫描 CPU 大头。
-    // 值字符串在任意序列化格式下连续出现，不耦合 pi 的空格习惯。
-    if (
-      !s.includes(IDENTITY_CUSTOM_TYPE) &&
-      !s.includes('"model_change"') &&
-      !s.includes('"thinking_level_change"')
-    ) {
-      continue;
-    }
-    let entry: JsonlEntry;
-    try {
-      entry = JSON.parse(s) as JsonlEntry;
-    } catch {
-      continue; // 损坏行/截断行（头部读取边界）跳过
+// ============================================================
+// 轻量 identity 扫描内部 helper（parseIdentityFromText 按阶段分发）
+// ============================================================
+
+/**
+ * 预筛（[S-4] 同款值匹配）：只有含三种目标 entry 值串的行才值得 JSON.parse——
+ * head 64KB 内大 toolResult 行（数十 KB/行）占多数，全量 parse 是冷扫描 CPU 大头。
+ * 值字符串在任意序列化格式下连续出现，不耦合 pi 的空格习惯。
+ */
+function lineMayCarryScannableEntry(s: string): boolean {
+  return (
+    s.includes(IDENTITY_CUSTOM_TYPE) ||
+    s.includes('"model_change"') ||
+    s.includes('"thinking_level_change"')
+  );
+}
+
+/** 轻量扫描的可变累积态（identity + 途经 model/thinkingLevel）。 */
+interface LightIdentityScan {
+  identity: SubagentIdentityData | undefined;
+  model: string;
+  thinkingLevel: string | undefined;
+}
+
+/**
+ * 单条 entry 并入扫描态。identity 命中（custom + customType 匹配 + data 合法）返回
+ * true 供调用方 break（找到即停，后续行不再解析）；其余恒 false。三个目标 type 互斥，
+ * 与原 if/else-if 链语义一致；custom 但 data 非法 → 不并入、不中断扫描。
+ */
+function absorbScannedEntry(state: LightIdentityScan, entry: JsonlEntry): boolean {
+  if (entry.type === "custom" && entry.customType === IDENTITY_CUSTOM_TYPE) {
+    if (isIdentityData(entry.data)) {
+      state.identity = entry.data;
+      return true;
     }
-    if (entry.type === "custom" && entry.customType === IDENTITY_CUSTOM_TYPE) {
-      if (isIdentityData(entry.data)) {
-        identity = entry.data;
-        break; // 找到即停（后续行不再解析）
-      }
-    } else if (entry.type === "model_change") {
-      if (typeof entry.provider === "string" && typeof entry.modelId === "string") {
-        model = `${entry.provider}/${entry.modelId}`;
-      }
-    } else if (entry.type === "thinking_level_change") {
-      if (typeof entry.thinkingLevel === "string") thinkingLevel = entry.thinkingLevel;
+    return false;
+  }
+  if (entry.type === "model_change") {
+    // model_change: {provider, modelId} → "provider/modelId"（与 record.model 同形）。
+    if (typeof entry.provider === "string" && typeof entry.modelId === "string") {
+      state.model = `${entry.provider}/${entry.modelId}`;
     }
+    return false;
+  }
+  if (entry.type === "thinking_level_change") {
+    if (typeof entry.thinkingLevel === "string") state.thinkingLevel = entry.thinkingLevel;
   }
-  if (!identity) return undefined;
+  return false;
+}
 
-  // 归一化与全量 recon 同源：rootSessionId fallback 旧字段、slug 兜底空串。
+/** 扫描态 → IdentityHeaderRecon（归一化与全量 recon 同源：rootSessionId fallback 旧字段、slug 兜底空串）。 */
+function toIdentityRecon(
+  state: LightIdentityScan,
+  identity: SubagentIdentityData,
+  sessionFile: string,
+): IdentityHeaderRecon {
   const rootSessionId = identity.rootSessionId ?? identity.parentSessionId;
   return {
     id: identity.id,
@@ -671,8 +763,29 @@ function parseIdentityFromText(text: string, sessionFile: string): IdentityHeade
     forkDepth: identity.forkDepth,
     chatMode: identity.chatMode,
     worktree: identity.worktree,
-    model,
-    thinkingLevel,
+    model: state.model,
+    thinkingLevel: state.thinkingLevel,
     sessionFile,
   };
 }
+
+/** 从文本片段解析 identity（头部/全文两入口共享）。解析到 identity 即停（返回）；
+ *  找不到返回 undefined。model/thinking_level 仅在 identity 之前的途经 entry 中
+ *  best-effort 提取，详情场景由全量重建补齐。 */
+function parseIdentityFromText(text: string, sessionFile: string): IdentityHeaderRecon | undefined {
+  const state: LightIdentityScan = { identity: undefined, model: "", thinkingLevel: undefined };
+  for (const line of text.split("\n")) {
+    const s = line.trim();
+    if (!s) continue;
+    if (!lineMayCarryScannableEntry(s)) continue;
+    let entry: JsonlEntry;
+    try {
+      entry = JSON.parse(s) as JsonlEntry;
+    } catch {
+      continue; // 损坏行/截断行（头部读取边界）跳过
+    }
+    if (absorbScannedEntry(state, entry)) break; // 找到即停（后续行不再解析）
+  }
+  if (!state.identity) return undefined;
+  return toIdentityRecon(state, state.identity, sessionFile);
+}