@zhushanwen/pi-session-reader 0.6.1 → 0.8.0

package/src/__tests__/family-zcode.test.ts

@@ -0,0 +1,255 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { tmpdir } from 'node:os'
+import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from 'node:fs'
+import { join } from 'node:path'
+import { DatabaseSync } from 'node:sqlite'
+
+import { buildFamilyIndex, resolveFamily, buildZcodeSubagentsByRoot } from '../core/family.js'
+import type { Entry, ZcodeFamilyNode } from '../core/family.js'
+import { listZcodeManifests } from '../discovery/zcode-manifest.js'
+
+// ============================================================
+// family zcode 分支（design session-reader-shared-core §3.3 D5-1 / §4 场景 2）。
+//
+// 判据（两项、不开库）：锚可解析（枚举谓词已过）∧ 库文件存在（stat）→ cleanedUp=false；
+// 缺一 → true（GC 语义，不报错不抛异常）。刻意不含「库内 session 查询」第三项——
+// 静息态 CANTOPEN 会误判活会话 + 列表视图不开库；反向断言（库文件在但库内 session
+// 行被删 → 仍 false）即「列表视图不开库」的分工声明断言。
+//
+// 与 pi 判据不同构（D5-1 显式声明）：pi = fileStats JSONL 存在性；zcode 节点无
+// JSONL 文件，按「库可达」判。pi 侧既有 fixture 行为零变化由 family.test.ts 全绿守卫
+// （本文件零改动 family.test.ts——更强的零涟漪证据）。
+// ============================================================
+
+const ROOT = 'root-session-1'
+
+let dir: string
+
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), 'family-zcode-test-'))
+})
+afterEach(() => {
+  rmSync(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 })
+})
+
+function header(id: string): Entry {
+  return { type: 'session', id, parentId: null, cwd: '/proj' }
+}
+
+/** zcode 节点（core 层判据输入，与 ZcodeManifestRecord 结构兼容） */
+function zcodeNode(opts: Partial<ZcodeFamilyNode> & { id: string }): ZcodeFamilyNode {
+  return {
+    rootSessionId: ROOT,
+    slug: 'worker',
+    dbPath: join(dir, 'db.sqlite'),
+    dbFileExists: false,
+    ...opts,
+  }
+}
+
+/** 在 <agentDir>/subagents/<slug>/records/ 下写 zcode manifest（F21 磁盘真实形态：无 sessionFile 键） */
+function writeZcodeManifest(
+  agentDir: string,
+  saId: string,
+  sessionRef: Record<string, string>,
+): void {
+  const recordsDir = join(agentDir, 'subagents', 'proj-a', 'records')
+  mkdirSync(recordsDir, { recursive: true })
+  writeFileSync(
+    join(recordsDir, `${saId}.json`),
+    JSON.stringify({
+      id: saId,
+      rootSessionId: ROOT,
+      agentName: 'worker',
+      status: 'running',
+      engine: 'zcode',
+      engineHandle: { sessionRef, poolKey: 'shared' },
+    }),
+    'utf8',
+  )
+}
+
+/** 造一个真实 sqlite 库（session/message/part 三级表先例形态）并插入 sess 行 */
+function createFixtureDb(dbPath: string, sessionId: string): void {
+  const db = new DatabaseSync(dbPath)
+  try {
+    db.exec('CREATE TABLE session (id TEXT PRIMARY KEY, title TEXT)')
+    db.exec('CREATE TABLE message (id TEXT PRIMARY KEY, session_id TEXT, sequence INTEGER)')
+    db.exec('CREATE TABLE part (id TEXT PRIMARY KEY, message_id TEXT, session_id TEXT)')
+    db.prepare('INSERT INTO session (id, title) VALUES (?, ?)').run(sessionId, 'fixture')
+  } finally {
+    db.close()
+  }
+}
+
+describe('core：buildZcodeSubagentsByRoot / buildFamilyIndex 的 zcode 分支（D5-1 两态）', () => {
+  it('库文件存在 → cleanedUp=false；库文件缺席 → cleanedUp=true（缺一即 true，不抛错）', () => {
+    const index = buildFamilyIndex([header(ROOT)], [], new Map(), [
+      zcodeNode({ id: 'sa-alive', dbFileExists: true }),
+      zcodeNode({ id: 'sa-gone', dbFileExists: false }),
+    ])
+    const family = resolveFamily(ROOT, index)
+
+    const alive = family.subagents.find((s) => s.sessionId === 'sa-alive')
+    const gone = family.subagents.find((s) => s.sessionId === 'sa-gone')
+    expect(alive?.cleanedUp).toBe(false)
+    expect(gone?.cleanedUp).toBe(true)
+  })
+
+  it('zcode 节点按 rootSessionId 挂载，隔代场景与 pi 同链合并（resolveFamily 消费同一 subagentsByRoot）', () => {
+    const FORK = 'fork-session-1'
+    const headers = [header(ROOT), { ...header(FORK), parentSession: `/s/_${ROOT}.jsonl` }]
+    const index = buildFamilyIndex(headers, [], new Map(), [
+      zcodeNode({ id: 'sa-deep', rootSessionId: FORK }),
+    ])
+    // Q1 隔代：zcode subagent 挂在 fork 子代下，从 ROOT resolve 仍可见
+    expect(resolveFamily(ROOT, index).subagents.map((s) => s.sessionId)).toContain('sa-deep')
+  })
+
+  it('不传 zcodeNodes / 传空数组 → pi 行为不变（零涟漪等价）', () => {
+    const piIdent: Entry = {
+      type: 'custom',
+      id: 'sa-pi',
+      parentId: null,
+      customType: 'subagent-identity',
+      data: { rootSessionId: ROOT, slug: 'pi-sub' },
+    }
+    const stats = new Map([[ROOT, { mtime: 1, size: 2 }], ['sa-pi', { mtime: 3, size: 4 }]])
+    const without = buildFamilyIndex([header(ROOT)], [piIdent], stats)
+    const withEmpty = buildFamilyIndex([header(ROOT)], [piIdent], stats, [])
+    const a = resolveFamily(ROOT, without)
+    const b = resolveFamily(ROOT, withEmpty)
+    expect(b.subagents).toEqual(a.subagents)
+    expect(b.subagents[0]?.cleanedUp).toBe(false) // pi 判据：fileStats 命中
+  })
+
+  it('zcode 节点与 pi 孤儿节点并存：判据互不污染（不同构声明断言）', () => {
+    // pi 孤儿：identity 在但 fileStats 不含 → cleanedUp=true（JSONL GC）
+    const piOrphan: Entry = {
+      type: 'custom',
+      id: 'sa-pi-orphan',
+      parentId: null,
+      customType: 'subagent-identity',
+      data: { rootSessionId: ROOT, slug: 'orphan' },
+    }
+    const index = buildFamilyIndex([header(ROOT)], [piOrphan], new Map(), [
+      zcodeNode({ id: 'sa-zcode-gone', dbFileExists: false }),
+    ])
+    const subs = resolveFamily(ROOT, index).subagents
+    // 两节点都 cleanedUp=true，但判据来源不同：pi 走 fileStats，zcode 走 dbFileExists
+    expect(subs.find((s) => s.sessionId === 'sa-pi-orphan')?.cleanedUp).toBe(true)
+    expect(subs.find((s) => s.sessionId === 'sa-zcode-gone')?.cleanedUp).toBe(true)
+  })
+
+  it('SubagentRef 字段映射：富字段透传、sessionFile 不设、mtime/sizeBytes 占位 0', () => {
+    const byRoot = buildZcodeSubagentsByRoot([
+      zcodeNode({
+        id: 'sa-rich',
+        slug: 'rich-slug',
+        agentName: 'explorer',
+        task: 'do research',
+        model: 'glm-5.3',
+        status: 'closed',
+        dbFileExists: true,
+      }),
+    ])
+    const ref = byRoot.get(ROOT)?.[0]
+    expect(ref?.slug).toBe('rich-slug')
+    expect(ref?.agentName).toBe('explorer')
+    expect(ref?.task).toBe('do research')
+    expect(ref?.model).toBe('glm-5.3')
+    expect(ref?.status).toBe('closed')
+    expect(ref?.sessionFile).toBeUndefined() // zcode 无 session.jsonl
+    expect(ref?.mtime).toBe(0)
+    expect(ref?.sizeBytes).toBe(0)
+  })
+})
+
+describe('集成：listZcodeManifests → buildFamilyIndex → resolveFamily（场景 2 两态 + 反向断言）', () => {
+  it('库可达态（dbPath 指向真实 fixture 库）→ cleanedUp=false', async () => {
+    const dbPath = join(dir, 'isolated.sqlite')
+    createFixtureDb(dbPath, 'sess_live')
+    writeZcodeManifest(dir, 'sa-live', { sessionId: 'sess_live', dbPath })
+
+    const nodes = await listZcodeManifests(dir)
+    expect(nodes).toHaveLength(1)
+    expect(nodes[0]?.dbFileExists).toBe(true)
+
+    const family = resolveFamily(ROOT, buildFamilyIndex([header(ROOT)], [], new Map(), nodes))
+    const sub = family.subagents.find((s) => s.sessionId === 'sa-live')
+    expect(sub?.cleanedUp).toBe(false)
+  })
+
+  it('库不存在态（dbPath 指向不存在路径）→ cleanedUp=true（GC 语义，不报错）', async () => {
+    writeZcodeManifest(dir, 'sa-gone', {
+      sessionId: 'sess_gone',
+      dbPath: join(dir, 'subagents', 'proj-a', 'missing.sqlite'),
+    })
+
+    const nodes = await listZcodeManifests(dir)
+    expect(nodes[0]?.dbFileExists).toBe(false)
+
+    const family = resolveFamily(ROOT, buildFamilyIndex([header(ROOT)], [], new Map(), nodes))
+    expect(family.subagents.find((s) => s.sessionId === 'sa-gone')?.cleanedUp).toBe(true)
+  })
+
+  it('反向断言：库文件在但库内 session 行被删 → 仍 cleanedUp=false（列表视图不开库的分工声明）', async () => {
+    // 分工（D5-1）：库内 session 已被 zcode GC 的情形由 read 路径 zcode_session_not_found
+    // 权威承接；family 只 stat 文件存在性。本用例删行留文件，断言 family 不受库内容影响。
+    const dbPath = join(dir, 'gc.sqlite')
+    createFixtureDb(dbPath, 'sess_victim')
+    writeZcodeManifest(dir, 'sa-gced', { sessionId: 'sess_victim', dbPath })
+
+    // 前置核实：fixture 库里确实有该 session 行（反向断言的非平凡性前提）
+    {
+      const db = new DatabaseSync(dbPath)
+      try {
+        const row = db.prepare('SELECT COUNT(*) AS c FROM session WHERE id = ?').get('sess_victim') as
+          | { c: number }
+          | undefined
+        expect(row?.c).toBe(1)
+      } finally {
+        db.close()
+      }
+    }
+
+    // 删库内 session 行（含 message/part 级联），db 文件保留
+    {
+      const db = new DatabaseSync(dbPath)
+      try {
+        db.prepare('DELETE FROM part WHERE session_id = ?').run('sess_victim')
+        db.prepare('DELETE FROM message WHERE session_id = ?').run('sess_victim')
+        db.prepare('DELETE FROM session WHERE id = ?').run('sess_victim')
+      } finally {
+        db.close()
+      }
+    }
+
+    const nodes = await listZcodeManifests(dir)
+    expect(nodes[0]?.dbFileExists).toBe(true) // 只 stat：文件在即 true，不看内容
+
+    const family = resolveFamily(ROOT, buildFamilyIndex([header(ROOT)], [], new Map(), nodes))
+    expect(family.subagents.find((s) => s.sessionId === 'sa-gced')?.cleanedUp).toBe(false)
+  })
+
+  it('坏 manifest 与缺库节点混排 → 好节点照常输出（单节点不可达不炸整屏）', async () => {
+    const dbPath = join(dir, 'ok.sqlite')
+    createFixtureDb(dbPath, 'sess_ok')
+    writeZcodeManifest(dir, 'sa-ok', { sessionId: 'sess_ok', dbPath })
+    // 缺库节点：合法 zcode 形态（dbFileExists=false，不抛错），不剔除出列表
+    writeZcodeManifest(dir, 'sa-broken-manifest', { sessionId: 'sess_x', dbPath: '/nonexistent/x.sqlite' })
+    // 坏 JSON manifest：枚举跳过（不中断）
+    writeFileSync(
+      join(dir, 'subagents', 'proj-a', 'records', 'sa-corrupt.json'),
+      '{{{broken',
+      'utf8',
+    )
+
+    const nodes = await listZcodeManifests(dir)
+    expect(nodes.map((n) => n.id).sort()).toEqual(['sa-broken-manifest', 'sa-ok'])
+
+    const family = resolveFamily(ROOT, buildFamilyIndex([header(ROOT)], [], new Map(), nodes))
+    expect(family.subagents.find((s) => s.sessionId === 'sa-ok')?.cleanedUp).toBe(false)
+    expect(family.subagents.find((s) => s.sessionId === 'sa-broken-manifest')?.cleanedUp).toBe(true)
+  })
+})

package/src/__tests__/family.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest'
 import { buildFamilyIndex, resolveFamily } from '../core/family.js'
-import type { Entry } from '../core/parser.js'
+import type { Entry } from '@zhushanwen/session-core'
 
 // ---- fixture 常量（映射 design §3.3 D-7 Q1 真实场景）----
 const ROOT = '019fe620' // 家族根（无 parentSession）

package/src/__tests__/find.test.ts

@@ -3,7 +3,7 @@ import { tmpdir } from 'node:os'
 import { mkdtemp, mkdir, writeFile, rm, utimes } from 'node:fs/promises'
 import { join } from 'node:path'
 import { findSessions } from '../discovery/find.js'
-import { REAL_AGENT_DIR, HAS_E6, HAS_REAL_SUBAGENTS_DIR, REAL_DATA_TIMEOUT_MS } from './real-data.js'
+import { FIX_E6 } from './fixtures.js'
 
 /**
  * 建一个假 session 文件：首行 header（type=session，含 id/cwd/parentSession），
@@ -186,6 +186,29 @@ describe('findSessions', () => {
     expect(matches[0].cwd).toBe('/proj-a')
   })
 
+  it('缺 cwd 的 header 进候选集（谓词不统一负面锚，design §4 负面行为验证）', async () => {
+    // header 行只有 id（无 cwd/timestamp）：runtime 导入侧「id+cwd 非空」严谓词会拒收，
+    // reader 宽谓词（仅要求 type==='session' ∧ id 为 string）必须照常收录——基座化
+    // （readFirstJsonlLine 改指 session-core）不得顺手统一谓词，本用例即机器锚。
+    const headerPath = join(slugDir, 'no-cwd.jsonl')
+    await mkdir(slugDir, { recursive: true })
+    await writeFile(headerPath, JSON.stringify({ type: 'session', id: '019e0001-no-cwd' }) + '\n')
+    await makeSession(slugDir, { name: 'with-cwd.jsonl', id: '019e0002-with-cwd', cwd: '/demo' })
+
+    // find 结果：缺 cwd header 命中，cwd 归一化为空串（buildCandidate 的 header.cwd ?? ''）
+    const { matches } = await findSessions('no-cwd', agentDir)
+    expect(matches).toHaveLength(1)
+    expect(matches[0].sessionId).toBe('019e0001-no-cwd')
+    expect(matches[0].cwd).toBe('')
+
+    // 候选枚举（recent 路径枚举全部候选）：缺 cwd header 未被候选集排除
+    const recent = await findSessions('recent', agentDir)
+    expect(recent.matches.map((m) => m.sessionId).sort()).toEqual([
+      '019e0001-no-cwd',
+      '019e0002-with-cwd',
+    ])
+  })
+
   it('limit 截断：truncated 标记正确', async () => {
     // 5 个文件 id 都含 "common"，uuid 片段 "common" 全匹配
     for (let i = 0; i < 5; i++) {
@@ -511,61 +534,21 @@ describe('findSessions', () => {
       // B 不入选（uuid 命中短路，不走 task 匹配）
       expect(matches.some((m) => m.sessionId === idB)).toBe(false)
     })
-
-    it.skipIf(!HAS_REAL_SUBAGENTS_DIR)(
-      'TC-u5-real-data-guard：find codex source:subagent 命中（本机有 codex 相关 subagent task）',
-      async () => {
-        const { matches, truncated } = await findSessions('codex', REAL_AGENT_DIR, {
-          source: 'subagent',
-          limit: 50,
-        })
-        expect(matches.length).toBeGreaterThan(0)
-        expect(matches.every((m) => m.source === 'subagent')).toBe(true)
-        expect(typeof truncated).toBe('boolean')
-      },
-      REAL_DATA_TIMEOUT_MS,
-    )
   })
 
-  it.skipIf(!HAS_E6)('真实数据：e6c96 匹配 019e6c96 开头的 session', async () => {
-    const { matches } = await findSessions('e6c96', REAL_AGENT_DIR)
+  it('uuid 片段命中候选补全元数据：fileName/mtime/sizeBytes 真实值（019e6c96 锚）', async () => {
+    // 2 条 session、恰 1 条 id 含片段 'e6c96'：uuid 片段路径命中后仍补读元数据字段。
+    // 命中文件按真实 pi 落盘命名（<id>.jsonl），fileName 断言含该 id
+    await makeSession(slugDir, { name: `${FIX_E6}.jsonl`, id: FIX_E6, cwd: '/demo' })
+    await makeSession(slugDir, { name: 'other.jsonl', id: '019ffff-cccc-dddd', cwd: '/demo' })
+
+    const { matches } = await findSessions('e6c96', agentDir)
     expect(matches.length).toBeGreaterThan(0)
-    expect(matches.some((m) => m.sessionId.startsWith('019e6c96'))).toBe(true)
-    // 真实值校验
     const hit = matches.find((m) => m.sessionId.startsWith('019e6c96'))!
     expect(hit.fileName).toContain('019e6c96')
     expect(hit.mtime).toBeGreaterThan(0)
     expect(hit.sizeBytes).toBeGreaterThan(0)
-  }, REAL_DATA_TIMEOUT_MS)
-
-  it.skipIf(!HAS_E6)("真实数据：recent 返回最近 N 个，mtime 倒序，truncated=true", async () => {
-    const { matches, truncated } = await findSessions('recent', REAL_AGENT_DIR, { limit: 5 })
-    expect(matches.length).toBeGreaterThan(0)
-    expect(matches.length).toBeLessThanOrEqual(5)
-    // mtime 倒序
-    for (let i = 1; i < matches.length; i++) {
-      expect(matches[i - 1].mtime).toBeGreaterThanOrEqual(matches[i].mtime)
-    }
-    // 真实 session 文件远多于 5 → 截断
-    expect(truncated).toBe(true)
-  }, REAL_DATA_TIMEOUT_MS)
-
-  it.skipIf(!HAS_REAL_SUBAGENTS_DIR)(
-    "真实数据：source:'subagent' 能找到 completed subagent（§7 场景 1 find 部分）",
-    async () => {
-      const { matches } = await findSessions('recent', REAL_AGENT_DIR, {
-        source: 'subagent',
-        limit: 5,
-      })
-      expect(matches.length).toBeGreaterThan(0)
-      // 全部 source==='subagent'，fileName 在 subagents/ 目录下
-      for (const m of matches) {
-        expect(m.source).toBe('subagent')
-        expect(m.fileName).toContain('subagents')
-      }
-    },
-    REAL_DATA_TIMEOUT_MS,
-  )
+  })
 })
 
 // ============================================================

package/src/__tests__/fixtures.ts

@@ -0,0 +1,15 @@
+/**
+ * 测试 fixture 常量（跨测试文件共享的 uuid 形态标识符）。
+ *
+ * 全部用例的项目内数据 = 各测试文件用 mkdtemp 自建自删的最小 session 文件
+ *（按测试断言逻辑构造，不读本机真实用户数据目录）。本文件只登记 uuid 常量，
+ * 取值约束：
+ * - 合法 uuid 形态（满足 extractSessionIdFromFilename / header id 谓词）；
+ * - FIX_E6 含十六进制片段 'e6c96'，作 uuid 片段匹配路径（find/resolveSessionId）的锚 id，
+ *   且完整 id 以 '019e6c96' 开头，供前缀断言。
+ *
+ * 本文件无 .test.ts 后缀，vitest include 只收集 `src/__tests__/` 下以 .test.ts 结尾的文件，不收集本文件。
+ */
+
+/** 主 fixture session id：片段 'e6c96' 命中 + 完整 id '019e6c96' 前缀断言的锚。 */
+export const FIX_E6 = '019e6c96-0a0c-74b8-a73f-d1854d88e2a7'

package/src/__tests__/parser.test.ts

@@ -1,7 +1,8 @@
 import { describe, it, expect } from 'vitest'
-import { parseSessionContent, parseSessionFile } from '../core/parser.js'
-import type { Entry } from '../core/parser.js'
-import { REAL_SESSION, HAS_REAL_SESSION } from './real-data.js'
+import { mkdtemp, writeFile, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { parseSessionContent, parseSessionFile, type Entry } from '@zhushanwen/session-core'
 
 /** 构造单行 JSONL entry 字符串 */
 function line(obj: Record<string, unknown>): string {
@@ -158,14 +159,37 @@ describe('parseSessionContent', () => {
 })
 
 describe('parseSessionFile', () => {
-  it.skipIf(!HAS_REAL_SESSION)('真实 session 019e6c96：1204 entries / 0 skipped / 非 partial', async () => {
-    const result = await parseSessionFile(REAL_SESSION)
-
-    expect(result.entries).toHaveLength(1204)
-    expect(result.skippedLines).toBe(0)
-    expect(result.lastLinePartial).toBe(false)
-    // 5.4MB 量级
-    expect(result.totalBytes).toBeGreaterThan(5_000_000)
-    // 5.6MB 全量解析在并发/高负载下可能超 vitest 默认 5s，显式放宽
-  }, 60000)
+  it('磁盘文件全量解析：entries 数 = 行数 / 0 skipped / 非 partial / totalBytes 与内容一致', async () => {
+    // mkdtemp 自建自删的 fixture 文件（不读本机真实数据目录）：session header +
+    // 10 条链式 message 的最小行集，验证「文件读取 → 逐行解析」回路的完整性与计数字段
+    const dir = await mkdtemp(join(tmpdir(), 'parser-file-'))
+    try {
+      const lines = [
+        line({ type: 'session', id: 's1', parentId: null, cwd: '/x' }),
+        ...Array.from({ length: 10 }, (_, i) =>
+          line({
+            type: 'message',
+            id: `m${i}`,
+            parentId: i === 0 ? 's1' : `m${i - 1}`,
+            message: {
+              role: i % 2 === 0 ? 'user' : 'assistant',
+              content: [{ type: 'text', text: `text ${i}` }],
+            },
+          }),
+        ),
+      ]
+      const content = lines.join('\n') + '\n'
+      const path = join(dir, 'fixture-session.jsonl')
+      await writeFile(path, content)
+
+      const result = await parseSessionFile(path)
+
+      expect(result.entries).toHaveLength(11)
+      expect(result.skippedLines).toBe(0)
+      expect(result.lastLinePartial).toBe(false)
+      expect(result.totalBytes).toBe(Buffer.byteLength(content, 'utf8'))
+    } finally {
+      await rm(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 })
+    }
+  })
 })

package/src/__tests__/render.test.ts

@@ -1,12 +1,8 @@
 import { describe, it, expect } from 'vitest'
 import { renderOutline, renderExpand, renderDetail, type ToolResultSummaryEntry } from '../core/render.js'
-import type { Entry } from '../core/parser.js'
+import type { Entry } from '@zhushanwen/session-core'
 import type { Turn } from '../core/turns.js'
 import type { TreeView } from '../core/tree.js'
-import { parseSessionFile } from '../core/parser.js'
-import { buildTreeView } from '../core/tree.js'
-import { segmentTurns } from '../core/turns.js'
-import { REAL_SESSION, HAS_REAL_SESSION } from './real-data.js'
 
 // ---- 构造助手 ----
 
@@ -204,25 +200,32 @@ describe('renderOutline', () => {
     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)
-    const tree = buildTreeView(parsed.entries)
-    const turns = segmentTurns(parsed.entries, new Set(tree.leafPath))
-    const result = renderOutline(turns, tree, { budget: 2000 })
+  it('8. 多 turn outline：tokenEstimate <= 1500 + assistantBrief/toolSummary 非空 + stats 完整（v2 O1）', () => {
+    // v2 O1：加 assistantBrief + 修 toolSummary bug 后 outline 行含结论与工具聚合，
+    // 阈值 1500（design §3.3 D4）。3 turn 合成数据，每 turn 带 toolCall + toolResult
+    const turns = [0, 1, 2].map((i) =>
+      turn(
+        i,
+        [
+          uEntry(`U${i}`, `问题 ${i}`),
+          aEntry(`A${i}`, `结论 ${i}`, [{ name: 'bash' }, { name: 'read' }]),
+          tEntry(`T${i}`, 'output'),
+        ],
+        { userEntry: uEntry(`U${i}`, `问题 ${i}`) },
+      ),
+    )
+    const result = renderOutline(turns, emptyTree(), { budget: 2000 })
 
-    expect(result.turns.length).toBe(32)
+    expect(result.turns.length).toBe(3)
     expect(result.tokenEstimate).toBeLessThanOrEqual(1500)
-    // v2 O1 验证：assistant 结论行存在（非空）+ toolSummary 显示真实工具（修 v1 恒空 bug）
+    // v2 O1 验证：assistant 结论行存在（非空）+ toolSummary 显示工具（修 v1 恒空 bug）
     expect(result.turns.some((b) => b.assistantBrief !== '')).toBe(true)
     expect(result.turns.some((b) => b.toolSummary !== '')).toBe(true)
     // stats 完整性
-    expect(result.stats.totalTurns).toBe(32)
-    // totalEntries 近似（leaf+branch+orphan）不含 session header（segmentTurns 规则1 跳过）；
-    // 工具层仅覆盖 stats.totalBytes 与 skippedLines（ParseResult 无 totalEntries 字段）。M1 验量级。
-    expect(result.stats.totalEntries).toBeGreaterThan(1000)
-    // 5.6MB 全量解析在并发/高负载下可能超 vitest 默认 5s，显式放宽
-  }, 60000)
+    expect(result.stats.totalTurns).toBe(3)
+    // totalEntries 近似（leaf+branch+orphan）不含 session header（segmentTurns 规则1 跳过）
+    expect(result.stats.totalEntries).toBeGreaterThan(0)
+  })
 })
 
 describe('renderExpand', () => {

package/src/__tests__/result.test.ts

@@ -267,10 +267,10 @@ describe('result action（U6）', () => {
     }
   })
 
-  it('6. 不存在 id：sa-id 无 manifest → 无匹配 record；uuid 片段零匹配 → 无匹配 session', async () => {
+  it('6. 不存在 id：sa-id 无 manifest → zcode_record_not_found（U9 统一错误面）；uuid 片段零匹配 → 无匹配 session', async () => {
     await expect(
       handleSessionRead({ action: 'result', session: 'sa-nonexist-9999' }, { agentDir: dir }),
-    ).rejects.toThrow(/无匹配 record/)
+    ).rejects.toThrow(/zcode_record_not_found/)
     try {
       await handleSessionRead({ action: 'result', session: 'sa-nonexist-9999' }, { agentDir: dir })
     } catch (e) {

package/src/__tests__/roots.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest'
 import { tmpdir } from 'node:os'
-import { mkdtemp, mkdir, readdir, writeFile, rm } from 'node:fs/promises'
+import { mkdtemp, mkdir, writeFile, rm } from 'node:fs/promises'
 import { join, dirname } from 'node:path'
 import {
   resolveSessionRoots,
@@ -9,7 +9,7 @@ import {
   type SessionRootSignals,
 } from '../discovery/roots.js'
 import { buildFamilyFromFs } from '../discovery/subagents.js'
-import { REAL_AGENT_DIR, HAS_E6, HAS_REAL_AGENT_DIR, HAS_REAL_SUBAGENTS_DIR, REAL_DATA_TIMEOUT_MS } from './real-data.js'
+import { FIX_E6 } from './fixtures.js'
 
 // ============================================================
 // A3（ext-simplify-04 U4）：listMainSessions/listSubagentSessions 薄包装已删除，
@@ -35,7 +35,7 @@ async function writeJsonl(path: string, content = '{"type":"session","id":"x"}\n
   await writeFile(path, content)
 }
 
-/** 真实形态的 cwd 编码目录名（encodeCwd：`--` 开头 `--` 结尾，实证见 real-data.ts） */
+/** 真实形态的 cwd 编码目录名（encodeCwd：`--` 开头 `--` 结尾） */
 const SLUG = '--Users-foo--'
 
 describe('main 根过滤（原 listMainSessions 等价式，A3 退役后保覆盖）', () => {
@@ -100,8 +100,18 @@ describe('main 根过滤（原 listMainSessions 等价式，A3 退役后保覆
     await expect(mainSessionFiles(join(dir, 'no-such-dir'))).resolves.toEqual([])
   })
 
-  it.skipIf(!HAS_E6)('真实数据：扫描 ~/.pi/agent，含 019e6c96，不含 .finalized 与 wf-', async () => {
-    const result = await mainSessionFiles(REAL_AGENT_DIR)
+  it('扫描 sessions/：含目标 session，排除 .finalized 与 workflow-state 目录（019e6c96 锚）', async () => {
+    // wf-state 文件（wf-*.jsonl）经 workflow-state 目录跳过排除——main 根无独立的
+    // wf- 文件名前缀过滤，slug 顶层放 wf-*.jsonl 会被收进候选集（该形态不在真实
+    // 落盘布局中出现：wf-state 恒在 workflow-state/ 目录内）
+    const slug = '--Users-foo--'
+    const slugDir = join(dir, 'sessions', slug)
+    await mkdir(join(slugDir, 'workflow-state'), { recursive: true })
+    await writeFile(join(slugDir, `${FIX_E6}.jsonl`), `{"type":"session","id":"${FIX_E6}"}\n`)
+    await writeFile(join(slugDir, 'b.jsonl.finalized'), '{"type":"session","id":"b"}\n')
+    await writeFile(join(slugDir, 'workflow-state', 'wf-inner.jsonl'), '{"v":"wf-run-v1"}\n')
+
+    const result = await mainSessionFiles(dir)
     expect(result.length).toBeGreaterThan(0)
     // 含目标 session
     expect(result.some((m) => m.path.includes('019e6c96'))).toBe(true)
@@ -109,11 +119,9 @@ describe('main 根过滤（原 listMainSessions 等价式，A3 退役后保覆
     expect(result.every((m) => !m.path.endsWith('.finalized'))).toBe(true)
     // 排除 workflow-state 目录
     expect(result.every((m) => !m.path.includes('workflow-state'))).toBe(true)
-    // 排除 wf- 前缀文件名
-    expect(result.every((m) => !m.path.split('/').pop()!.startsWith('wf-'))).toBe(true)
     // mtime/size 真实
     expect(result.every((m) => m.mtime > 0 && m.size > 0)).toBe(true)
-  }, REAL_DATA_TIMEOUT_MS)
+  })
 })
 
 describe('subagent 根选择（原 listSubagentSessions 等价式，A3 退役后保覆盖）', () => {
@@ -156,12 +164,6 @@ describe('subagent 根选择（原 listSubagentSessions 等价式，A3 退役后
   it('无 subagents 目录返回 []，不抛错', async () => {
     await expect(subagentSessionFiles(dir)).resolves.toEqual([])
   })
-
-  it.skipIf(!HAS_REAL_SUBAGENTS_DIR)('真实数据：扫描 ~/.pi/agent/subagents 返回非空', async () => {
-    const result = await subagentSessionFiles(REAL_AGENT_DIR)
-    expect(result.length).toBeGreaterThan(0)
-    expect(result.every((m) => !m.path.endsWith('.finalized'))).toBe(true)
-  }, REAL_DATA_TIMEOUT_MS)
 })
 
 // ============================================================
@@ -320,26 +322,22 @@ describe('resolveSessionRoots', () => {
     await expect(resolveSessionRoots({ agentDir: '' })).resolves.toEqual([])
   })
 
-  it.skipIf(!HAS_REAL_AGENT_DIR)(
-    '§11.2 真实路径集合回归：encodeCwd 判据在真实 sessions 子目录上自洽，剥层分支被真实数据覆盖',
-    async () => {
-      const sessionsDir = join(REAL_AGENT_DIR, 'sessions')
-      const entries = await readdir(sessionsDir, { withFileTypes: true })
-      const dirs = entries.filter((e) => e.isDirectory())
-      expect(dirs.length).toBeGreaterThan(0)
-      let encodeCwdCount = 0
-      for (const d of dirs) {
-        const asLive = join(sessionsDir, d.name)
-        const matchesShape = d.name.startsWith('--') && d.name.endsWith('--')
-        // 判据自洽：匹配形态 → 剥层到父目录；不匹配（如 permission-forwarding/）→ 取自身
-        expect(normalizeLiveSessionDir(asLive)).toBe(matchesShape ? sessionsDir : asLive)
-        if (matchesShape) encodeCwdCount++
-      }
-      // 真实集合以 encodeCwd 目录为主体——剥层分支确实被真实数据覆盖
-      expect(encodeCwdCount).toBeGreaterThan(0)
-    },
-    30000,
-  )
+  it('encodeCwd 判据自洽：--xx-- 形态子目录剥层到 sessions 根，普通名子目录取自身', async () => {
+    // 两种目录形态各造一个：encodeCwd 编码目录（剥层分支）与普通目录名（取自身分支）
+    const tmp = await mkdtemp(join(tmpdir(), 'roots-encode-'))
+    try {
+      const sessionsDir = join(tmp, 'agent', 'sessions')
+      const encoded = join(sessionsDir, '--Users-foo--')
+      const plain = join(sessionsDir, 'permission-forwarding')
+      await writeJsonl(join(encoded, 'a.jsonl'))
+      await writeJsonl(join(plain, 'p.jsonl'))
+      // 判据自洽：匹配 encodeCwd 形态 → 剥层到父目录；不匹配（如 permission-forwarding/）→ 取自身
+      expect(normalizeLiveSessionDir(encoded)).toBe(sessionsDir)
+      expect(normalizeLiveSessionDir(plain)).toBe(plain)
+    } finally {
+      await rm(tmp, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 })
+    }
+  })
 })
 
 describe('buildFamilyFromFs not-found 文案（U1 并入：列实际扫描候选根）', () => {