@zhushanwen/pi-session-reader 0.5.0 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhushanwen/pi-session-reader",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "type": "module",
   "main": "index.ts",
   "xyz-agent": {
@@ -15,10 +15,13 @@
   "keywords": [
     "pi-package"
   ],
+  "dependencies": {
+    "@zhushanwen/pi-ext-guards": "0.4.0"
+  },
   "devDependencies": {
     "@vitest/coverage-v8": "^4.1.9",
     "vitest": "^4.1.8",
-    "@zhushanwen/subagent-core": "0.7.1"
+    "@zhushanwen/subagent-core": "0.10.1"
   },
   "files": [
     "index.ts",

package/src/__tests__/cross-package-subagent-core.test.ts

@@ -12,12 +12,12 @@ import {
   SubagentService,
   type SubagentRecord,
 } from '@zhushanwen/subagent-core'
-import { ManifestStore } from '@zhushanwen/subagent-core/execution/manifest-store.ts'
-import type { ModelRegistryLike } from '@zhushanwen/subagent-core/execution/model-resolver.ts'
+import { ManifestStore } from '@zhushanwen/subagent-core/execution/persistence/manifest-store.ts'
+import type { ModelRegistryLike } from '@zhushanwen/subagent-core/execution/assembly/model-resolver.ts'
 import {
   getSubagentRecordsDir,
   getSubagentSessionDir,
-} from '@zhushanwen/subagent-core/execution/path-encoding.ts'
+} from '@zhushanwen/subagent-core/execution/assembly/path-encoding.ts'
 
 /**
  * W4 跨包集成测试（subagent-sync-collect v2 impl-plan W4 验收条款①，设计 §5 W4：
@@ -213,13 +213,14 @@ describe('跨包集成：subagent-core E1 落标 manifest → session-reader res
     return childFile
   }
 
-  /** 种「崩溃前主文件末条序列」：register（running+sync）→ 轮终（running+resumable+
-   *  result 全文 + sessionFile）——成功成员崩溃时的真实末条形态。 */
+  /** 种「崩溃前主文件末条序列」：register（running+sync）→ 轮终（idle + result
+   *  全文 + sessionFile）——[U4/D4] 翻边后成功成员崩溃时的真实末条形态（U5 前的
+   *  running+resumable 桥接形态已随字段退役消亡）。 */
   function seedRoundTerminalEntries(m: MemberSeed, childFile: string): void {
     const store = makeSeedStore()
     store.reportSubagentRecord(memberRecord({ id: m.id, sessionFile: childFile, model: m.model }))
     store.reportSubagentRecord(
-      memberRecord({ id: m.id, sessionFile: childFile, model: m.model, resumable: true, result: m.resultText }),
+      memberRecord({ id: m.id, sessionFile: childFile, model: m.model, status: 'idle', result: m.resultText }),
     )
   }
 
@@ -265,7 +266,9 @@ describe('跨包集成：subagent-core E1 落标 manifest → session-reader res
     const childFiles = await driveSyncBatchRecovery([m])
 
     // manifest 内容断言（W3 appendBatchFinalizedEntry 投影路径的产物，非手工预写）：
-    // 覆写后 closed 重建快照 → status 如实投影 "closed"；sessionFile 来自 W1 投影扩展。
+    // sessionFile 来自 W1 投影扩展。[U2/U3 两态桥接] E1 落标成员经恢复链覆写后处于
+    // idle（重建单规则）/running 形态、无旧终态遗留位 → legacy status 如实投影
+    // "running"（batchManifestRecord 单点派生，session-reader 视角的活跃成员）。
     const manifest = JSON.parse(
       fs.readFileSync(path.join(getSubagentRecordsDir(agentDir, agentDir), 'sa-cross-1.json'), 'utf-8'),
     ) as Record<string, unknown>
@@ -273,12 +276,12 @@ describe('跨包集成：subagent-core E1 落标 manifest → session-reader res
       id: 'sa-cross-1',
       rootSessionId: ROOT_SESSION,
       agentName: '/agents/worker.md',
-      status: 'closed',
+      status: 'running',
       sessionFile: childFiles.get('sa-cross-1'),
     })
 
     // session-reader 侧：sa- id 反查（v1 此处报「无匹配 record」——manifest 惰性不落盘）
-    const r = await handleSessionRead({ action: 'result', session: 'sa-cross-1' }, agentDir)
+    const r = await handleSessionRead({ action: 'result', session: 'sa-cross-1' }, { agentDir })
     // 同源语义：跨 assistant message "\n\n" join、thinking 块排除——与 record.result 逐字节一致
     expect(r.content[0]?.text).toBe(resultText)
     const d = r.details as {
@@ -302,7 +305,7 @@ describe('跨包集成：subagent-core E1 落标 manifest → session-reader res
     ]
     await driveSyncBatchRecovery(members)
 
-    const r = await handleSessionRead({ action: 'result', session: 'sa-cross-a,sa-cross-b' }, agentDir)
+    const r = await handleSessionRead({ action: 'result', session: 'sa-cross-a,sa-cross-b' }, { agentDir })
     const text = r.content[0]?.text ?? ''
     expect(text).toContain('[1/2] sa-cross-a')
     expect(text).toContain('[2/2] sa-cross-b')

package/src/__tests__/execution-tree.test.ts

@@ -1,6 +1,5 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest'
 import { tmpdir } from 'node:os'
-import { execSync } from 'node:child_process'
 import { mkdtemp, mkdir, writeFile, rm } from 'node:fs/promises'
 import { join } from 'node:path'
 import { buildExecutionTree, formatExecutionTreeText, type ExecutionTreeNode } from '../core/execution-tree.js'
@@ -18,7 +17,11 @@ import { buildExecutionTree, formatExecutionTreeText, type ExecutionTreeNode } f
  * - TC-m3b-cycle-detection：workflow 指针环（A→B→A），visited Set 防环
  * - TC-m3b-single-node：单节点树（无后代，ES5）
  * - TC-m3b-source-priority：parentRecordId 三级数据源优先级（manifest>identity>flat，DM4）
- * - TC-m3b-real-data-guard：本机真实语料解析不抛错、root 定位正确（skipIf CI 无数据）
+ * - TC-m3b-real-data-guard：真实形态数据守卫（合成 fixture）。原直读本机 ~/.pi/agent 动态
+ *   发现家族根（skipIf CI 无数据），真实数据演化后确定性红且触碰真实数据目录（TEST-STRATEGY
+ *   红线），2026-09 数据面合成化：mkdtemp 临时目录仿真真实 agentDir 布局（时间戳前缀文件名 /
+ *   新旧机制混合 / 孤儿 manifest / 坏 manifest / 外来家族），guard 语义不变——解析不抛错 /
+ *   树非空 / 结构自洽，不锁 sourceMode 具体值
  */
 
 // ---- fixture 常量（uuid 特征，互不为子串，满足 extractSessionIdFromFilename）----
@@ -32,20 +35,6 @@ const X_REAL = '0aaaaaaa-bbbb-7ccc-dddd-000000000006'
 const RUN_A = 'wf-1786121304924-runA'
 const RUN_B = 'wf-1786121304924-runB'
 
-/** 真实 pi agent 目录（本机），用于集成测试守卫。 */
-const REAL_AGENT_DIR = '/Users/zhushanwen/.pi/agent'
-const HAS_REAL = (() => {
-  try {
-    return (
-      execSync(`find ${REAL_AGENT_DIR}/sessions -maxdepth 1 -type d 2>/dev/null | head -1`, {
-        encoding: 'utf8',
-      }).trim().length > 0
-    )
-  } catch {
-    return false
-  }
-})()
-
 // ---- fixture helpers（自包含，拓扑同 subagents.test.ts）----
 
 async function makeAgentDir(): Promise<string> {
@@ -64,6 +53,7 @@ async function writeMainSession(dir: string, slug: string, id: string): Promise<
 /**
  * 写 subagent session 文件：首行 header（真实 id）+ 占位 message + 尾行 identity。
  * identity 尾行含 rootSessionId/slug/agent，可选 parentRecordId（数据源 ② 测试用）。
+ * fileName 可选：默认 `<realId>.jsonl`；真实形态守卫用例传时间戳前缀名（<ts>_<id>.jsonl）。
  */
 async function writeSubagentSession(
   dir: string,
@@ -76,10 +66,11 @@ async function writeSubagentSession(
     parentRecordId?: string
     task?: string
   },
+  fileName: string = `${realId}.jsonl`,
 ): Promise<string> {
   const sessionDir = join(dir, 'subagents', slug, 'sessions')
   await mkdir(sessionDir, { recursive: true })
-  const path = join(sessionDir, `${realId}.jsonl`)
+  const path = join(sessionDir, fileName)
   const data: Record<string, unknown> = {
     id: `sa-${realId.slice(0, 8)}`,
     rootSessionId: identity.rootSessionId,
@@ -688,23 +679,140 @@ describe('buildExecutionTree - fixture', () => {
 })
 
 // ============================================================
-// 真实数据守卫（CI 无本机 ~/.pi/agent → skip）
+// 真实形态数据守卫（合成 fixture，2026-09 测试债修复）
 // ============================================================
+//
+// 原用例直读本机 ~/.pi/agent（execSync 探测 + findRealTreeRoot 扫真实 records 动态发现
+// 家族根，skipIf CI 无数据）：真实数据演化后确定性红（impl-plan 台账登记根因），且触碰
+// 真实数据目录违反 TEST-STRATEGY 红线。数据面合成化——mkdtemp 临时目录仿真真实 agentDir
+// 布局，guard 语义断言（解析不抛错 / 树非空 / 结构自洽 / sourceMode 值域）原样保留。
 
-describe.skipIf(!HAS_REAL)('buildExecutionTree - 真实数据守卫', () => {
-  it('TC-m3b-real-data-guard：本机真实语料解析不抛错，root 定位正确', async () => {
-    // 取一个真实存在的 main session（FAM 是 fork 家族根）
-    const FAM = '019fe620-8ae1-78a7-b76a-43a1ba4cc3c7'
-    const tree = await buildExecutionTree(FAM, REAL_AGENT_DIR)
-    // [HISTORICAL] 只断言与宿主数据纪元无关的不变量：sourceMode / totalNodes 取决于 FAM
-    // 家族在 subagents/**/records 下的 manifest 存量，会被 pi GC 清空（2026-09-11 实测该
-    // 家族 records/ 已空 → related=[] → sourceMode='precise'、totalNodes=1，原 flat-fallback
-    // + totalNodes>1 断言随数据演化假红）。flat-fallback 语义由 fixture 用例
-    // TC-m3b-flat-fallback 确定性覆盖，不依赖本机可变语料。
+describe('buildExecutionTree - 真实形态数据守卫（合成）', () => {
+  let dir: string
+
+  beforeEach(async () => {
+    dir = await makeAgentDir()
+  })
+  afterEach(async () => {
+    await rm(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 })
+  })
+
+  it('TC-m3b-real-data-guard：真实形态布局（时间戳文件名/新旧机制混合/孤儿 manifest/坏 manifest/外来家族）解析不抛错，树非空且结构自洽', async () => {
+    // 仿真真实 agentDir 数据形态（原直读本机 ~/.pi/agent，合成化后确定性可重跑）：
+    // - session 文件名带时间戳前缀（<ISO 时间戳>_<sessionId>.jsonl，真实 pi 落盘形态）
+    // - 混合新旧机制：A 顶层（无 parentRecordId）→ B 嵌套（manifest.parentRecordId 精确链）；
+    //   C 旧机制顶层（manifest/identity 均无 parentRecordId → flat 挂 main）
+    // - 孤儿 manifest D：sessionFile 已被 30 天 GC、manifest 残留（真实数据常态）
+    // - 坏 manifest（JSON 损坏）不中断扫描（ES4）
+    // - 外来家族 X（同 agentDir 其他 main 的 record）不应泄漏进目标树
+    const CWD = '--guard-cwd--'
+    const TS = '2026-09-11T10-00-00-000Z'
+    const OTHER_MAIN = '0aaaaaaa-bbbb-7ccc-dddd-000000000009'
+    const prefixed = (id: string): string => `${TS}_${id}.jsonl`
+
+    await writeMainSession(dir, CWD, MAIN)
+    // A：顶层 subagent（identity 尾行走数据源 ② 读路径，无 parentRecordId → 顶层挂 main）
+    const saA = await writeSubagentSession(
+      dir,
+      CWD,
+      A_REAL,
+      { rootSessionId: MAIN, slug: 'guard-a' },
+      prefixed(A_REAL),
+    )
+    await writeRecordManifest(dir, CWD, 'rec-ga', {
+      rootSessionId: MAIN,
+      agentName: 'explorer',
+      sessionFile: saA,
+      slug: 'guard-a',
+      status: 'completed',
+    })
+    // B：A 的嵌套后代（manifest.parentRecordId 精确链，新机制）
+    const saB = await writeSubagentSession(
+      dir,
+      CWD,
+      B_REAL,
+      { rootSessionId: MAIN, slug: 'guard-b' },
+      prefixed(B_REAL),
+    )
+    await writeRecordManifest(dir, CWD, 'rec-gb', {
+      rootSessionId: MAIN,
+      agentName: 'worker',
+      sessionFile: saB,
+      slug: 'guard-b',
+      status: 'completed',
+      parentRecordId: 'rec-ga',
+    })
+    // C：旧机制顶层 subagent（manifest/identity 均无 parentRecordId → flat 挂 main）
+    const saC = await writeSubagentSession(
+      dir,
+      CWD,
+      C_REAL,
+      { rootSessionId: MAIN, slug: 'guard-c' },
+      prefixed(C_REAL),
+    )
+    await writeRecordManifest(dir, CWD, 'rec-gc', {
+      rootSessionId: MAIN,
+      agentName: 'explorer',
+      sessionFile: saC,
+      slug: 'guard-c',
+      status: 'completed',
+    })
+    // D：孤儿 manifest（sessionFile 指向已被 GC 的不存在文件——manifest 残留形态）
+    await writeRecordManifest(dir, CWD, 'rec-gd', {
+      rootSessionId: MAIN,
+      agentName: 'worker',
+      sessionFile: join(dir, 'subagents', CWD, 'sessions', prefixed(D_REAL)),
+      status: 'completed',
+    })
+    // 坏 manifest（JSON 损坏，listRecordManifests 容错跳过不中断）
+    await mkdir(join(dir, 'subagents', CWD, 'records'), { recursive: true })
+    await writeFile(join(dir, 'subagents', CWD, 'records', 'broken.json'), '{oops')
+    // 外来家族 X：同 agentDir 内其他 main（OTHER_MAIN）的 subagent，不应泄漏进 MAIN 的树
+    const saX = await writeSubagentSession(
+      dir,
+      CWD,
+      X_REAL,
+      { rootSessionId: OTHER_MAIN, slug: 'foreign-x' },
+      prefixed(X_REAL),
+    )
+    await writeRecordManifest(dir, CWD, 'rec-gx', {
+      rootSessionId: OTHER_MAIN,
+      agentName: 'explorer',
+      sessionFile: saX,
+      status: 'completed',
+    })
+
+    const tree = await buildExecutionTree(MAIN, dir)
+
+    // 契约值域：sourceMode 只能是两种精度模式之一（record 含 parentRecordId → precise，
+    // 全无 → flat-fallback），不锁具体值
+    expect(['precise', 'flat-fallback']).toContain(tree.sourceMode)
+    // 家族树非空：main + 顶层 A/C/D + A 的嵌套后代 B = 5；外来 X 不泄漏（合成数据确定性
+    // 可数，精确计数即非泄漏守卫）
+    expect(tree.totalNodes).toBe(5)
     expect(tree.root.type).toBe('main')
-    expect(tree.root.sessionId).toBe(FAM)
-    expect(tree.totalNodes).toBeGreaterThanOrEqual(1)
-  }, 60000)
+    expect(tree.root.sessionId).toBe(MAIN)
+    expect(findNode(tree.root, 'subagent', X_REAL)).toBeUndefined()
+    // 孤儿 D 仍入树（sessionFile 残留路径，不因文件缺失抛错/丢弃 record——原真实数据守卫
+    // 独有覆盖面，合成化后保留）
+    const nodeD = findNode(tree.root, 'subagent', D_REAL)
+    expect(nodeD).toBeDefined()
+    expect(nodeD!.sessionFile).toBe(join(dir, 'subagents', CWD, 'sessions', prefixed(D_REAL)))
+    // 树结构自洽（ExecutionTreeNode 契约，与具体数据形态无关）：DFS 实际节点数 ===
+    // totalNodes；子节点 depth = 父 depth + 1；全树 rootSessionId 共享同一顶层 main
+    let count = 0
+    const walk = (node: ExecutionTreeNode): void => {
+      count++
+      expect(node.rootSessionId).toBe(tree.root.rootSessionId)
+      for (const c of node.children) {
+        expect(c.depth).toBe(node.depth + 1)
+        walk(c)
+      }
+    }
+    walk(tree.root)
+    expect(count).toBe(tree.totalNodes)
+    // 不抛错（已隐含：到这行说明成功）
+  })
 })
 
 // ============================================================

package/src/__tests__/family.test.ts

@@ -107,13 +107,6 @@ describe('buildFamilyIndex', () => {
     expect(index.childrenOf.get('aaa')?.[0].sessionId).toBe('bbb')
   })
 
-  it('parentSession 直接是 sessionId 也兼容（简化 fixture）', () => {
-    const headers = [header('aaa'), header('bbb', { parentSession: 'aaa' })]
-    const index = buildFamilyIndex(headers, [], new Map())
-
-    expect(index.childrenOf.get('aaa')?.[0].sessionId).toBe('bbb')
-  })
-
   it('parentSession 反查不到父 → 该 entry 不进 childrenOf（不报错）', () => {
     const headers = [header('bbb', { parentSession: '/missing.jsonl' })]
     const index = buildFamilyIndex(headers, [], new Map())

package/src/__tests__/find.test.ts

@@ -133,7 +133,7 @@ async function makeSubagentSession(
 describe('findSessions', () => {
   let agentDir: string
   let slugDir: string
-  /** subagent fixture 目录（模拟 subagents/<cwd编码>/sessions/ 结构，roots.listSubagentSessions 扫描路径） */
+  /** subagent fixture 目录（模拟 subagents/<cwd编码>/sessions/ 结构，resolveSessionRoots [subagent] 根扫描路径） */
   let saDir: string
 
   let recordsDir: string
@@ -705,8 +705,8 @@ describe('u11 标题元数据（metadataProvider 注入，§6.6）', () => {
     await mkdir(legacyDir, { recursive: true })
     const provider = vi.fn(async (dir: string) =>
       dir === flatMain
-        ? [{ path: pathA, id: 'dup-id-0001', cwd: '/demo', name: '旧标题', modified: 1000 }]
-        : [{ path: pathA, id: 'dup-id-0001', cwd: '/demo', name: '新标题', modified: 2000 }],
+        ? [{ path: pathA, id: 'dup-id-0001', cwd: '/demo', name: '旧标题', modified: new Date(1000) }]
+        : [{ path: pathA, id: 'dup-id-0001', cwd: '/demo', name: '新标题', modified: new Date(2000) }],
     )
     const { matches } = await findSessions('新标题', agentDir, { metadataProvider: provider })
     expect(provider).toHaveBeenCalledTimes(2) // 两个平铺存在的根各一次
@@ -753,8 +753,8 @@ describe('u11 标题元数据（metadataProvider 注入，§6.6）', () => {
     const provider = vi.fn(async (dir: string) =>
       dir === flatMain
         ? [
-            { path: pNew1, id: 'recent-new-1', cwd: '/demo', name: '最新标题一', modified: (base + 300) * 1000 },
-            { path: pNew2, id: 'recent-new-2', cwd: '/demo', name: '最新标题二', modified: (base + 200) * 1000 },
+            { path: pNew1, id: 'recent-new-1', cwd: '/demo', name: '最新标题一', modified: new Date((base + 300) * 1000) },
+            { path: pNew2, id: 'recent-new-2', cwd: '/demo', name: '最新标题二', modified: new Date((base + 200) * 1000) },
           ]
         : [],
     )

package/src/__tests__/real-data.ts

@@ -22,7 +22,7 @@ export const REAL_AGENT_DIR = '/Users/zhushanwen/.pi/agent'
  * 这类用例遍历本机 ~/.pi/agent 全量会话语料（实测 4600+ 文件），空载单用例已需 6-10s；
  * 38 包并行全量测试时 CPU/IO 争抢可降速 3-4 倍，30s 标定必假红。90s ≈ 空载 9 倍余量，
  * 仍能兜住真正的挂死。仅用于遍历全量语料的用例（findSessions / buildFamilyFromFs /
- * listMainSessions 等）；读已知单文件的用例不需要放宽。
+ * resolveSessionRoots 等）；读已知单文件的用例不需要放宽。
  */
 export const REAL_DATA_TIMEOUT_MS = 90_000
 

package/src/__tests__/rebuild-manifest-dual-write.test.ts

@@ -0,0 +1,177 @@
+// 跨包集成（[U4c / G4-S5③] record 持久化收敛 P4c 验收锚点）：
+// subagent-core 重建/终态写面产出的 manifest → session-reader identity 投影不降级。
+//
+// 断言链（设计 subagent-record-persistence-consolidation D5 前向兼容判定 + S5③）：
+//   1. manifest 被人为删除（S5 缓存可丢场景）→ subagent-core RecordStore.rebuildIndexes
+//      全量重建 → session-reader listRecordManifests 重新可见；
+//   2. 重建窗口前后，session-reader identity 投影的输入字段集（rootSessionId/slug/
+//      task/agentName/model/status/sessionFile/parentRecordId）逐字段一致——双写过渡
+//      字段（executionStatus）在场且不被本包消费（旧 status 三态投影继续生效）；
+//   3. 重建源 = `.state` 权威（closedReason 从终态位派生，旧三态 cancelled 形态
+//      保真——buildRecord 分支 1 → derivedManifestRecord 派生）。
+//
+// 形态同 cross-package-subagent-core.test.ts：subagent-core 真实 tmpdir 产出磁盘
+// 状态，本包零 mock 读同一 tmpdir；不触碰真实数据目录（红线）。
+
+import * as fs from 'node:fs'
+import * as os from 'node:os'
+import * as path from 'node:path'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+
+import { RecordStore } from '@zhushanwen/subagent-core'
+// barrel 外符号按包名 .ts 深路径消费（vitest alias 重写，同 cross-package 先例）
+import { createRecord } from '@zhushanwen/subagent-core/execution/persistence/execution-record.ts'
+import {
+  getSubagentRecordsDir,
+  getSubagentSessionDir,
+} from '@zhushanwen/subagent-core/execution/assembly/path-encoding.ts'
+
+import { listRecordManifests, type RecordManifest } from '../discovery/subagents.js'
+
+const ROOT_SESSION = 'root-dual-write'
+
+/** session-reader identity 投影（manifestIdentityData）消费的字段集——重建窗口
+ *  前后必须逐字段一致（降级 = 任一字段缺失/漂移）。 */
+function identityView(m: RecordManifest) {
+  return {
+    id: m.id,
+    rootSessionId: m.rootSessionId,
+    agentName: m.agentName,
+    task: m.task,
+    slug: m.slug,
+    model: m.model,
+    status: m.status,
+    sessionFile: m.sessionFile,
+    parentRecordId: m.parentRecordId,
+  }
+}
+
+describe('跨包集成：subagent-core rebuildIndexes 重建 manifest → session-reader 投影不降级', () => {
+  let agentDir: string
+  let sessionsDir: string
+  let recordsDir: string
+  let childFile: string
+
+  beforeEach(() => {
+    agentDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sr-rebuild-dualwrite-'))
+    sessionsDir = getSubagentSessionDir(agentDir, agentDir)
+    recordsDir = getSubagentRecordsDir(agentDir, agentDir)
+    fs.mkdirSync(sessionsDir, { recursive: true })
+    fs.mkdirSync(recordsDir, { recursive: true })
+
+    // 子 session 文件：session header + model_change（light 重建的 model 源——
+    // identity 前途经 entry best-effort 提取）+ identity entry（session-reader
+    // 步骤 2 首行 header 探测 + manifest 主路径的数据锚）
+    childFile = path.join(sessionsDir, '20260912T000000_sa-dw.jsonl')
+    const ts = new Date(1000).toISOString()
+    fs.writeFileSync(
+      childFile,
+      [
+        JSON.stringify({ type: 'session', version: 3, id: 'sess-sa-dw', timestamp: ts, cwd: agentDir }),
+        JSON.stringify({ type: 'model_change', id: 'mc-1', parentId: null, timestamp: ts, provider: 'prov', modelId: 'm1' }),
+        JSON.stringify({
+          type: 'custom',
+          id: 'id-1',
+          parentId: null,
+          timestamp: ts,
+          customType: 'subagent-identity',
+          data: {
+            id: 'sa-dw',
+            agent: 'worker',
+            mode: 'background',
+            task: 'dual write task',
+            slug: 'dual',
+            startedAt: 1000,
+            rootSessionId: ROOT_SESSION,
+            parentRecordId: 'sa-parent',
+            depth: 1,
+          },
+        }),
+      ].join('\n') + '\n',
+      'utf-8',
+    )
+  })
+
+  afterEach(() => {
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 })
+  })
+
+  it('S5③: manifest 删除 → rebuildIndexes 重建 → identity 投影字段集前后一致（双写字段在场）', async () => {
+    // ── 初始 manifest：subagent-core 终态写面（markFinalized）真实产出 ──
+    const record = createRecord('sa-dw', {
+      agent: 'worker',
+      model: 'prov/m1',
+      mode: 'background',
+      task: 'dual write task',
+      slug: 'dual',
+      startedAt: 1000,
+      rootSessionId: ROOT_SESSION,
+      parentRecordId: 'sa-parent',
+      depth: 1,
+      chatMode: false,
+      controller: new AbortController(),
+    })
+    Object.assign(record, {
+      sessionFile: childFile,
+      status: 'closed' as const,
+      closedReason: 'gc' as const,
+      endedAt: 2000,
+    })
+    const writer = new RecordStore(sessionsDir, undefined, undefined, recordsDir)
+    expect(writer.markFinalized(record, 'gc')).toBe(true)
+    writer.dispose()
+
+    const before = (await listRecordManifests(agentDir)).find((m) => m.id === 'sa-dw')
+    expect(before).toBeDefined()
+    const viewBefore = identityView(before!)
+
+    // 双写过渡字段在写面就位（本包不消费，但前向兼容锚要求其在场）。
+    // [U2 两态] executionStatus 是内部权威词汇（running|idle 两态，终态概念删除）
+    // → 终态化后恒 'idle'；status 旧三态是 session-reader 直读投影（永久保留）→ 'closed'。
+    const rawBefore = JSON.parse(fs.readFileSync(path.join(recordsDir, 'sa-dw.json'), 'utf-8')) as Record<string, unknown>
+    expect(rawBefore.executionStatus).toBe('idle')
+    expect(rawBefore.status).toBe('closed')
+
+    // ── S5 场景：人为删除全部 manifest（缓存可丢）→ 全量重建 ──
+    for (const f of fs.readdirSync(recordsDir)) fs.rmSync(path.join(recordsDir, f))
+    expect((await listRecordManifests(agentDir)).filter((m) => m.id === 'sa-dw')).toHaveLength(0)
+
+    const rebuilder = new RecordStore(sessionsDir, undefined, undefined, recordsDir)
+    expect(rebuilder.rebuildIndexes()).toBe(1)
+    rebuilder.dispose()
+
+    // ── session-reader 视角：重建后 identity 投影不降级 ──
+    const after = (await listRecordManifests(agentDir)).find((m) => m.id === 'sa-dw')
+    expect(after).toBeDefined()
+    expect(identityView(after!)).toEqual(viewBefore)
+
+    // 重建源 = `.state` 权威：closedReason 从终态位派生回 manifest（旧三态 closed）
+    const rawAfter = JSON.parse(fs.readFileSync(path.join(recordsDir, 'sa-dw.json'), 'utf-8')) as Record<string, unknown>
+    expect(rawAfter.status).toBe('closed')
+    expect(rawAfter.executionStatus).toBe('idle')
+    expect(rawAfter.closedReason).toBe('gc')
+  })
+
+  it('惰性通道：查询面（collectRecords）补建的 manifest 同样可被本包读取投影', async () => {
+    // 不经终态写面（无 manifest 初始形态）：磁盘 record 只有 identity + 无 sidecar
+    // → 查询触发惰性补建。
+    const store = new RecordStore(sessionsDir, undefined, undefined, recordsDir)
+    expect(store.collectRecords(10).map((r) => r.id)).toContain('sa-dw')
+    store.dispose()
+
+    const manifests = await listRecordManifests(agentDir)
+    const found = manifests.find((m) => m.id === 'sa-dw')
+    expect(found).toBeDefined()
+    expect(found!.status).toBe('running')
+    expect(found!.task).toBe('dual write task')
+    expect(found!.agentName).toBe('worker')
+    expect(found!.sessionFile).toBe(childFile)
+    expect(found!.parentRecordId).toBe('sa-parent')
+    // 双写过渡字段（[U3 重建单规则] 无 sidecar 重建一律 idle：executionStatus 如实
+    // 投影两态词汇；legacy status 经桥接判据派生——无 closedReason 遗留位的 idle
+    // 投影 "running"（session-reader 视角的活跃成员，§3.2.8 下行映射）。
+    const raw = JSON.parse(fs.readFileSync(path.join(recordsDir, 'sa-dw.json'), 'utf-8')) as Record<string, unknown>
+    expect(raw.executionStatus).toBe('idle')
+    expect(raw.status).toBe('running')
+  })
+})

package/src/__tests__/render.test.ts

@@ -90,6 +90,8 @@ describe('renderOutline', () => {
     // thinking 'secret'(6B) + toolResult 'output'(6B)
     expect(b.omittedBytes).toBe(12)
     expect(result.truncated).toBeUndefined()
+    // E7 行渲染统一：lines 随结果返回，与 turns 一一对应（预算度量 = 展示行同一份）
+    expect(result.lines).toEqual(['T000 · do something · bash×2,read×2 · → sure · [12B omitted]'])
   })
 
   it('2a. 降级：单行 toolSummary 过长超 perTurnBudget → 砍 toolSummary，保 userBrief 骨架', () => {
@@ -108,6 +110,25 @@ describe('renderOutline', () => {
       expect(b.toolSummary).toBe('') // 被砍（降级）
       expect(b.userBrief).toBe('u'.repeat(10)) // 骨架保留
     }
+    // E7：降级后的渲染行（骨架形态）与 briefs 字段同步——行内无 → 结论段、无工具聚合段
+    expect(result.lines).toHaveLength(3)
+    expect(result.lines).toEqual(['T000 · uuuuuuuuuu', 'T001 · uuuuuuuuuu', 'T002 · uuuuuuuuuu'])
+    expect(result.truncated).toBeUndefined()
+  })
+
+  it('2b. 降级（砍 assistantBrief 档）：行内 → 结论段消失、toolSummary 保留，与改前语义一致', () => {
+    // budget=20 → perTurnCharBudget=80；level 0 行 = T000 · u*10 · bash×2 · → a*80… ≈112 > 80
+    // → 砍 assistantBrief 后 ≈26 ≤ 80 停（S3：该档形态与改前 handler 侧渲染降级后 briefs 等价）
+    const t = turn(
+      0,
+      [uEntry('U', 'u'.repeat(10)), aEntry('A', 'a'.repeat(100), [{ name: 'bash' }, { name: 'bash' }])],
+      { userEntry: uEntry('U', 'u'.repeat(10)) },
+    )
+    const result = renderOutline([t], emptyTree(), { budget: 20 })
+
+    expect(result.turns[0].assistantBrief).toBe('') // 被砍
+    expect(result.turns[0].toolSummary).toBe('bash×2') // 保留
+    expect(result.lines).toEqual(['T000 · uuuuuuuuuu · bash×2'])
     expect(result.truncated).toBeUndefined()
   })
 
@@ -122,6 +143,8 @@ describe('renderOutline', () => {
 
     expect(result.truncated).toBe(3)
     expect(result.turns).toHaveLength(2)
+    // E7：lines 与 turns 同步截短（truncateToTotalBudget 双数组一致）
+    expect(result.lines).toHaveLength(2)
   })
 
   it('4. toolSummary 聚合：同名计数 ×N，不同名逗号分隔', () => {
@@ -168,6 +191,19 @@ describe('renderOutline', () => {
     expect(withoutBranches.turns[0].branch).toBeUndefined()
   })
 
+  it('7b. E7 旁支标记统一：渲染行 `[旁支 N entries]`（N = 该 forkPoint 下旁支子树 entry 数）', () => {
+    // branches: U → 3 entries 旁支子树（E7/D3：outline 与 export 两条路径共用此形态）
+    const tree: TreeView = { leafPath: ['U'], branches: new Map([['U', 3]]), orphans: [] }
+    const userEntry = uEntry('U', 'hi')
+    const turns = [turn(0, [userEntry], { userEntry })]
+
+    const result = renderOutline(turns, tree, { allBranches: true })
+    expect(result.lines).toEqual(['T000 · hi · [旁支 3 entries]'])
+    // branchSize 缺失（allBranches:false）不标旁支
+    const noBranch = renderOutline(turns, tree, { allBranches: false })
+    expect(noBranch.lines).toEqual(['T000 · hi'])
+  })
+
   it.skipIf(!HAS_REAL_SESSION)('8. 真实 019e6c96：outline tokenEstimate <= 1500 + assistantBrief/toolSummary 非空（v2 O1）', async () => {
     // v2 O1：加 assistantBrief + 修 toolSummary bug 后 outline 变长，阈值 600→1500（design §3.3 D4）
     const parsed = await parseSessionFile(REAL_SESSION)
@@ -310,7 +346,6 @@ describe('renderDetail', () => {
     expect(summary.summary).toMatch(/^read: f\.ts \(\d+KB\)$/)
     expect(summary.totalLines).toBe(4)
     expect(summary.headLines).toContain('line1')
-    expect(summary.fullEntry.message?.role).toBe('toolResult')
 
     // includeToolResult 全文：返回原 Entry
     const full = renderDetail([t], { includeToolResult: true })