@zhushanwen/pi-session-reader 0.8.0 → 0.9.0

package/src/core/workflow.ts

@@ -3,7 +3,7 @@
 // ============================================================
 //
 // 本文件消费 discovery/workflows.ts 的 readRunSnapshot（v1/旧指针档——返 unknown
-// 原始快照对象，NEW/OLD 双格式分支）与 record 流文本（[D16③] v2 档——journalPath
+// 原始快照对象，NEW/OLD 双格式分支）与 record 流文本（[D16③] v2 档——recordPath
 // 锚点语义重定义为 record 流路径后的新数据源），把 unknown/事件流行类型化为
 // WorkflowOverview，再渲染为人类可读文本。零 IO：parseRunSnapshot /
 // parseRunRecordStream / renderWorkflowOverview 喂 mock 即可单测（w5

package/src/discovery/entry-anchor.ts

@@ -46,12 +46,12 @@ const SUBAGENT_RECORD_ENTRY_V2 = 2
  * 从单条 entry 提取 zcode 锚。形状校验窄而严，任一不满足 = 该条不算命中（返回
  * undefined，调用方继续扫——缺键条目不遮蔽更早的完整条目）：
  * - `type === 'custom'` ∧ `customType === 'subagent-record'`
- * - 版本/判别键二选一（schema 版本守卫，不认识的版本跳过而非猜测——写侧
- *   record-entry.ts classifySubagentRecordEntryData 同口径）：
- *   - v1：`data.v === 1`（全量快照形态，兼容读面）；
- *   - v2：`data.v === 2` ∧ `data.kind === 'settled'`（W1 注册/终态两条小条目——
- *     **锚只取自终态条**：registered 条目不携带 engineHandle，且设计 D1 裁决
- *     「sessionRef 双键取自终态条」；kind 非法 = unknown-kind 跳过）；
+ * - 版本/判别键（schema 版本守卫，不认识的版本跳过而非猜测——写侧
+ *   record-entry.ts classifySubagentRecordEntryData v2-only 同口径）：
+ *   `data.v === 2` ∧ `data.kind === 'settled'`（W1 注册/终态两条小条目——
+ *   **锚只取自终态条**：registered 条目不携带 engineHandle，且设计 D1 裁决
+ *   「sessionRef 双键取自终态条」；kind 非法 = unknown-kind 跳过。v1 全量快照形态
+ *   已随兼容层删除，不再命中，2026-09-30 登记 §3.3）；
  * - `data.id === saId`（record id 即 sa-id，record-access.ts `sa-${uuid}`）
  * - `engineHandle.sessionRef.sessionId` / `.dbPath` 均为非空 string（F8 双键齐判据的
  *   锚字段部分；pi record 的 sessionRef 无 dbPath → 天然不命中，无需 engine 判别）
@@ -66,14 +66,11 @@ function zcodeAnchorOfEntry(entry: Entry, saId: string): ZcodeAnchor | undefined
   return extractZcodeSessionRefAnchor(d.engineHandle)
 }
 
-/** [zcodeAnchorOfEntry 拆分] 条目形态判别：v1 全量快照 或 v2 终态条（registered
- * 条目不携带 engineHandle，且设计 D1 裁决「sessionRef 双键取自终态条」；kind
- * 非法 = unknown-kind 跳过）。 */
+/** [zcodeAnchorOfEntry 拆分] 条目形态判别：当前版本终态条（registered 条目不携带
+ *  engineHandle，且设计 D1 裁决「sessionRef 双键取自终态条」；kind 非法 = 跳过。
+ *  v1 全量快照形态已随兼容层删除，不再命中）。 */
 function isAnchorEligibleRecordEntryVersion(d: Record<string, unknown>): boolean {
-  if (d.v === SUBAGENT_RECORD_ENTRY_V2) {
-    return d.kind === 'settled'
-  }
-  return d.v === 1
+  return d.v === SUBAGENT_RECORD_ENTRY_V2 && d.kind === 'settled'
 }
 
 /** [zcodeAnchorOfEntry 拆分] engineHandle.sessionRef 双键提取（sessionId/dbPath

package/src/discovery/workflows.ts

@@ -5,109 +5,45 @@ import type { SessionRef, WorkflowRef } from '../core/family.js'
 import { extractSessionIdFromFilename } from './subagents.js'
 
 // ============================================================
-// workflow-state 发现链路（w5 从 subagents.ts 物理迁移，架构归位 SSOT §6.3）
+// workflow-record 发现链路（单档：v2 注册条目 recordPath 主源）
 // ============================================================
 //
 // 本文件持有 workflow run 的发现与 sessionFile 提取逻辑（IO 适配层）：
-// - resolveWorkflows：三档发现链（按 runId 合并，高档条目在即用高档）——
-//   ① v2 journalPath 主源（[D16③] 发现链重锚：journalPath 锚点语义 = record 流路径）：
-//     workflow-record v2 注册条目的 journalPath 指向 <runId>.record.jsonl（[D1] record
-//     单源事件流），发现链读 record 流行自提 calls——sessionFile 取 agent-settled 帧
-//     result 全文携带的 sessionFile（[D1] 载荷表：result 全文入事件，AgentResult
-//     自带 sessionFile 字段——家族链数据源同 record 流，无第二承载位）；旧后缀锚点
-//     （.events.jsonl 形态）= 历史实体（[D1] 历史数据处置：旧两件不读）→ calls=[]
-//     仅 run 存在性兜底；
-//   ② v1 快照层：workflow-record v1 快照条目（W17~W1 期间创建的 run——快照是全量的，
-//     直接从 snapshot.calls 提 sessionFile，家族链数据完整）；
-//   ③ 旧指针 fallback：workflow-state-link 指针条目（W17 前的 run，照旧读 link 指向的
-//     wf-state 文件）。
-// - readRunSnapshot：读 wf-state 文件尾向找首个可解析行，返回原始对象（unknown，格式收窄交 core 层）。
-// - extractCallSessionFiles：从快照对象提 calls 的 sessionFile 绝对路径数组（NEW/OLD 双格式）。
+// - resolveWorkflows：workflow-record v2 注册条目（`v === 2` ∧ `kind === 'registered'`
+//   ∧ runId/recordPath 均非空 string）是唯一发现通道——recordPath 锚点语义 = record
+//   流路径（[D16③]），指向 <runId>.record.jsonl（[D1] record 单源事件流），发现链读
+//   record 流行自提 calls——sessionFile 取 agent-settled 帧 result 全文携带的
+//   sessionFile（[D1] 载荷表：result 全文入事件，AgentResult 自带 sessionFile 字段
+//   ——家族链数据源同 record 流，无第二承载位）；旧后缀锚点（.events.jsonl 形态）=
+//   历史实体（[D1] 历史数据处置：旧两件不读）→ calls=[] 仅 run 存在性兜底。
+//   历史格式条目（v1 全量快照 / workflow-state-link 指针）不识别、静默从发现链消失
+//   （不拒读、不报错）——run 侧 v1 读面已删除（ADR-0095，同 record 侧裁决：项目未
+//   上线无历史数据，不迁移不兼容）。
+// - readRunSnapshot：读 wf-state 文件尾向找首个可解析行，返回原始对象（unknown，格式
+//   收窄交 core 层）。唯一消费方 = tool-handler workflow 概览的快照链分支。
 // - extractRecordStreamSessionFiles：[D16③] 从 record 事件流提 calls 的 sessionFile
 //   （agent-settled 帧 result.sessionFile——活跃 run 与已收编 run 同源可用）。
-// - sessionRefFromPath：sessionFile 路径 → SessionRef（命中 pathToRef 取完整，否则文件名提取最小 ref）。
+// - sessionRefFromPath：sessionFile 路径 → SessionRef（命中 pathToRef 取完整，否则
+//   文件名提取最小 ref）。
 //
 // 分层约定（w5 TC-wf-core-pure-logic）：IO 全在 discovery/，core/workflow.ts 的
-// parseRunSnapshot/renderWorkflowOverview 是纯逻辑零 IO（喂 mock 可单测）。readRunSnapshot 返
-// unknown 不收窄——NEW/OLD 双格式的类型化是 core 层 parseRunSnapshot 的职责（TC-wf-snapshot-version-union）。
+// parseRunSnapshot/renderWorkflowOverview 是纯逻辑零 IO（喂 mock 可单测）。
+// readRunSnapshot 返 unknown 不收窄——类型化是 core 层 parseRunSnapshot 的职责
+// （TC-wf-snapshot-version-union）。
 //
-// extractSessionIdFromFilename 留在 subagents.ts（find.ts + 导出契约测试直接消费），此处反向 import。
-
-/**
- * 从 wf-state 快照对象提取 calls[].sessionFile（绝对路径数组）。
- *
- * 两种格式（探查确认，本机 371 个 wf 文件）：
- * - NEW (v="wf-run-v1" 或 "wf-run-v2"，读取面形状一致)：state.calls[]，每项顶层
- *   .sessionFile（258 文件 / 1590 sessionFile）。v2 由 pi-subagent-workflow 8.x 一次性
- *   生命周期收敛引入（status 两态、无 pausedAt），calls[].sessionFile/result 保留
- * - OLD (无 v)：callCache[]=[{key,value}]，value.sessionFile（112 文件 / 0 sessionFile，旧 pi 不持久化）
- */
-export function extractCallSessionFiles(snap: unknown): string[] {
-  const out: string[] = []
-  if (typeof snap !== 'object' || snap === null) return out
-  const s = snap as Record<string, unknown>
-  const isNew = isNewSnapshotFormat(s)
-  const callsRaw = extractCallsRaw(s, isNew)
-  if (!Array.isArray(callsRaw)) return out
-  for (const c of callsRaw) {
-    if (typeof c !== 'object' || c === null) continue
-    const item = resolveCallItem(c as Record<string, unknown>, isNew)
-    const sf = extractSessionFileFromItem(item)
-    if (sf !== undefined) out.push(sf)
-  }
-  return out
-}
-
-/** 快照是否为 NEW 格式（v="wf-run-v1"/"wf-run-v2"，读取面形状一致） */
-function isNewSnapshotFormat(s: Record<string, unknown>): boolean {
-  return s.v === 'wf-run-v1' || s.v === 'wf-run-v2'
-}
-
-/** 按格式取 calls 原始集合：NEW 读 state.calls（state 守卫后取），OLD 读顶层 callCache */
-function extractCallsRaw(s: Record<string, unknown>, isNew: boolean): unknown {
-  if (isNew) {
-    const state = s.state
-    return typeof state === 'object' && state !== null
-      ? (state as Record<string, unknown>).calls
-      : undefined
-  }
-  return s.callCache
-}
-
-/**
- * 单条 call 归一为可取 sessionFile 的对象：
- * NEW: call 本身；OLD: {key, value}，取 value（value 非对象时回退 call 本身，容错脏数据）
- */
-function resolveCallItem(co: Record<string, unknown>, isNew: boolean): Record<string, unknown> {
-  if (isNew) return co
-  const value = co.value
-  return typeof value === 'object' && value !== null ? (value as Record<string, unknown>) : co
-}
-
-/** 从归一后的 call 对象提 sessionFile：顶层优先，回退 result.sessionFile；均缺 → undefined */
-function extractSessionFileFromItem(item: Record<string, unknown>): string | undefined {
-  const sf = item.sessionFile
-  if (typeof sf === 'string') return sf
-  const result = item.result
-  const sf2 =
-    typeof result === 'object' && result !== null
-      ? (result as Record<string, unknown>).sessionFile
-      : undefined
-  if (typeof sf2 === 'string') return sf2
-  return undefined
-}
+// extractSessionIdFromFilename 留在 subagents.ts（find.ts + 导出契约测试直接消费），
+// 此处反向 import。
 
 /**
  * 读 wf-state 文件，从尾向头找首个 trim 非空且 JSON.parse 成功的行，返回解析后的原始对象。
  *
- * 拆解自原 readWorkflowCallSessionFiles 的读行职责（w5 TC-wf-core-pure-logic）——后者=读行+
- * 提 sessionFile 的胶水，迁移后由 readRunSnapshot（读行，返 unknown）+ extractCallSessionFiles
- * （提 sessionFile）组合替代。返回类型 unknown：IO 层不假设格式，类型收窄交 core/workflow.ts
- * 的 parseRunSnapshot（C-readrunsnapshot-unknown，TC-wf-snapshot-version-union）。
+ * 拆解自原 readWorkflowCallSessionFiles 的读行职责（w5 TC-wf-core-pure-logic）——
+ * 读行（本函数，返 unknown）+ 类型化（core/workflow.ts 的 parseRunSnapshot，
+ * C-readrunsnapshot-unknown）分层。
  *
  * 尾向回退策略（沿用原实现，ES-wf-snapshot-partial）：wf 文件是 rewrite 覆盖模式，读撞 rewrite
  * 中点时末行是半截 JSON（parse 失败）→ 试上一完整行；单行文件半行 → 全失败 → undefined。
- * 文件不存在/读失败/全行不可解析 → undefined（不抛错，调用方 resolveWorkflows 据此 calls=[]）。
+ * 文件不存在/读失败/全行不可解析 → undefined（不抛错，调用方据此跳过该 run）。
  */
 export async function readRunSnapshot(wfPath: string): Promise<unknown | undefined> {
   let content: string
@@ -146,7 +82,7 @@ function sessionRefFromPath(path: string, pathToRef: Map<string, SessionRef>): S
 }
 
 // ============================================================
-// workflow-record 条目契约（三档发现链的条目判别——本地字面量 + 测试守卫漂移）
+// workflow-record 条目契约（v2 注册条目判别——本地字面量 + 测试守卫漂移）
 // ============================================================
 
 /**
@@ -159,111 +95,57 @@ function sessionRefFromPath(path: string, pathToRef: Map<string, SessionRef>): S
  */
 const WORKFLOW_RECORD_CUSTOM_TYPE = 'workflow-record'
 
-/** v2 条目 data 的认识版本词表（W1 起 = 2；写侧 WORKFLOW_RECORD_ENTRY_VERSION 同值）。 */
+/** v2 条目 data 的认识版本（写侧 WORKFLOW_RECORD_ENTRY_VERSION 同值，W1 起 = 2）。 */
 const WORKFLOW_RECORD_ENTRY_V2 = 2
 
 /**
  * run record 流文件名尾段（`<runId>.record.jsonl`）。写侧 subagent-core
- * RUN_EVENT_JOURNAL_SUFFIX 同值（[D1] record 单源后缀）——v2 注册条目的
- * journalPath 锚点后缀判定用（新锚点直读 record 流；旧 `.events.jsonl` 锚点 =
+ * RUN_EVENTS_SUFFIX 同值（[D1] record 单源后缀）——v2 注册条目的
+ * recordPath 锚点后缀判定用（新锚点直读 record 流；旧 `.events.jsonl` 锚点 =
  * 历史实体分流），本地持有 + 测试守卫漂移。
  */
 export const RUN_RECORD_STREAM_SUFFIX = '.record.jsonl'
 
-/** 单遍扫描 entries 的三档收集结果（档内同 runId 后写覆盖前写，跨档优先级见 resolveWorkflows）。 */
-interface WorkflowEntryTiers {
-  /** ① v2 注册条目：runId → journalPath 锚点（W1+ 的 run）。 */
-  v2ByRunId: Map<string, string>
-  /** ② v1 快照条目：runId → 全量快照对象（W17~W1 期间创建的 run）。 */
-  v1ByRunId: Map<string, unknown>
-  /** ③ 旧指针条目：runId → link path（W17 前的 run）。 */
-  linkByRunId: Map<string, { runId: string; path: string }>
-  /** runId 首见序（输出稳定序——条目在 session 文件中的出现顺序）。 */
-  runIdOrder: string[]
+/** v2 注册条目收集结果（同 runId 后写覆盖前写；order = 条目在 session 文件中的首见序）。 */
+interface RegisteredRecordPaths {
+  byRunId: Map<string, string>
+  order: string[]
 }
 
 /**
- * 单遍扫描 entries 按三档形态分桶（纯收集，无 IO）：
- * - workflow-record v2 注册条目：`v === 2` ∧ `kind === 'registered'` ∧ runId/journalPath
- *   均非空 string（终态条目不携带 journalPath，非发现链数据源，不收集）；
- * - workflow-record v1 快照条目：`v === 1` ∧ snapshot 为对象 ∧ `snapshot.runId` 为
- *   string（runId 在快照内——entry data 顶层无 runId 字段）；
- * - workflow-state-link 指针条目：现状判别。
+ * 单遍扫描 entries 收集 workflow-record v2 注册条目（纯收集，无 IO）：
+ * `v === 2` ∧ `kind === 'registered'` ∧ runId/recordPath 均非空 string。终态条目
+ * （kind === 'settled'）不携带 recordPath、不参与发现链，不收集。
  */
-function collectWorkflowEntryTiers(entries: readonly Entry[]): WorkflowEntryTiers {
-  const tiers: WorkflowEntryTiers = {
-    v2ByRunId: new Map(),
-    v1ByRunId: new Map(),
-    linkByRunId: new Map(),
-    runIdOrder: [],
-  }
+function collectRegisteredRecordPaths(entries: readonly Entry[]): RegisteredRecordPaths {
+  const byRunId = new Map<string, string>()
+  const order: string[] = []
   const seen = new Set<string>()
-  const noteRunId = (runId: string): void => {
-    if (!seen.has(runId)) {
-      seen.add(runId)
-      tiers.runIdOrder.push(runId)
-    }
-  }
   for (const e of entries) {
     const data = e.data as Record<string, unknown> | undefined
-    if (e.customType === WORKFLOW_RECORD_CUSTOM_TYPE && data !== undefined) {
-      collectWorkflowRecordEntryTier(tiers, noteRunId, data)
-      continue
-    }
-    // legacy 指针档字面量：常量 SSOT 在 subagent-core（WORKFLOW_STATE_LINK_CUSTOM_TYPE，
-    // orchestration/workflow-record-entry.ts）。reader 生产依赖面不引 subagent-core
-    // （包架构裁决，同 entry-anchor.ts 的协议字面量模式），保持本地镜像，值等价由
-    // __tests__/workflow.test.ts 跨包契约守卫断言锚定。
-    if (e.customType === 'workflow-state-link') {
-      collectWorkflowStateLinkTier(tiers, noteRunId, data)
-    }
-  }
-  return tiers
-}
-
-/** [collectWorkflowEntryTiers 拆分] workflow-record 条目两代分流（v2 注册 / v1 快照）。 */
-function collectWorkflowRecordEntryTier(
-  tiers: WorkflowEntryTiers,
-  noteRunId: (runId: string) => void,
-  data: Record<string, unknown>,
-): void {
-  if (data.v === WORKFLOW_RECORD_ENTRY_V2 && data.kind === 'registered') {
+    if (e.customType !== WORKFLOW_RECORD_CUSTOM_TYPE || data === undefined) continue
+    if (data.v !== WORKFLOW_RECORD_ENTRY_V2 || data.kind !== 'registered') continue
     const runId = data.runId
-    const journalPath = data.journalPath
-    if (typeof runId === 'string' && runId !== '' && typeof journalPath === 'string' && journalPath !== '') {
-      tiers.v2ByRunId.set(runId, journalPath)
-      noteRunId(runId)
+    const recordPath = data.recordPath
+    if (typeof runId !== 'string' || runId === '' || typeof recordPath !== 'string' || recordPath === '') {
+      continue
     }
-  } else if (data.v === 1 && typeof data.snapshot === 'object' && data.snapshot !== null) {
-    const snapshotRunId = (data.snapshot as Record<string, unknown>).runId
-    if (typeof snapshotRunId === 'string' && snapshotRunId !== '') {
-      tiers.v1ByRunId.set(snapshotRunId, data.snapshot)
-      noteRunId(snapshotRunId)
+    if (!seen.has(runId)) {
+      seen.add(runId)
+      order.push(runId)
     }
+    byRunId.set(runId, recordPath) // 后写覆盖前写（取最新锚点）
   }
-}
-
-/** [collectWorkflowEntryTiers 拆分] workflow-state-link 指针条目（后写覆盖前写——取最新 link）。 */
-function collectWorkflowStateLinkTier(
-  tiers: WorkflowEntryTiers,
-  noteRunId: (runId: string) => void,
-  data: Record<string, unknown> | undefined,
-): void {
-  const runId = data?.runId
-  const path = data?.path
-  if (typeof runId === 'string' && typeof path === 'string') {
-    tiers.linkByRunId.set(runId, { runId, path }) // 后写覆盖前写（取最新 link）
-    noteRunId(runId)
-  }
+  return { byRunId, order }
 }
 
 /**
- * [D16③] journalPath 后缀分流：`.record.jsonl` 锚点 = 新形态（record 流直读）；
+ * [D16③] recordPath 后缀分流：`.record.jsonl` 锚点 = 新形态（record 流直读）；
  * 其余（含旧 `.events.jsonl` 锚点）= 历史实体（[D1] 历史数据处置——旧两件不读
  * 不写，历史 run 从发现链数据面退空即预期行为）。
  */
-function isNewRecordStreamAnchor(journalPath: string): boolean {
-  return journalPath.endsWith(RUN_RECORD_STREAM_SUFFIX)
+function isNewRecordStreamAnchor(recordPath: string): boolean {
+  return recordPath.endsWith(RUN_RECORD_STREAM_SUFFIX)
 }
 
 /** agent-settled 帧的最小消费视图（record 流宽容解析只消费 taskIndex 与
@@ -310,20 +192,16 @@ export function extractRecordStreamSessionFiles(content: string): string[] {
 }
 
 /**
- * 读目标 session 文件全文，按三档发现链构造 WorkflowRef[]（D10 断链修复：W17 前/
- * W17~W1/W1+ 三类 run 全部有发现通道）。同一 runId 的多条目按 runId 去重取档内
- * 最新（后写覆盖）；跨档优先级 = v2 注册条目 > v1 快照条目 > 旧指针——一个 run 只
- * 以一种形态写条目（创建时点决定），跨档同 runId 是坏数据防御，高档在即用高档。
+ * 读目标 session 文件全文，从 workflow-record v2 注册条目构造 WorkflowRef[]
+ * （单档发现链——v1 快照条目与 workflow-state-link 指针条目不再识别，历史 run
+ * 从发现链数据面退空即预期行为，见 ADR-0095）。同一 runId 的多条目后写覆盖
+ * （条目顺序 = 时间顺序，取最新锚点）。
  *
- * **签名与返回值结构（WorkflowRef[]{runId,stateFile,calls:SessionRef[]}）完全不变**
- * （C-resolveworkflows-signature，保 m1 已冻结交付的消费者）。三档的 stateFile 语义：
- * - v2 档：stateFile = journalPath 本身（record 流路径——[D16③] 锚点语义重定义，
- *   D1 后 v2 条目携带的锚点即 record 事件流文件）；record 流直读提 calls
- *   （agent-settled.result.sessionFile），流被清理/不可读 → calls=[]（run 存在性
- *   兜底）；
- * - v1 档：空串（v1 快照条目不携带 state 路径，快照数据直接从条目提 calls；概览
- *   消费面 readRunSnapshot('') 自然落「快照不可读」跳过，家族链 calls 不受影响）；
- * - 旧指针档：link 的 path（现状）。
+ * **签名与返回值结构（WorkflowRef[]{runId,stateFile,calls:SessionRef[]}）不变**
+ * （C-resolveworkflows-signature，保 m1 已冻结交付的消费者）。stateFile = recordPath
+ * 本身（record 流路径——[D16③] 锚点语义，D1 后 v2 条目携带的锚点即 record 事件流
+ * 文件）；record 流直读提 calls（agent-settled.result.sessionFile），流被清理/
+ * 不可读 → calls=[]（run 存在性兜底）。
  */
 export async function resolveWorkflows(
   sessionId: string,
@@ -339,49 +217,23 @@ export async function resolveWorkflows(
     return []
   }
   const { entries } = parseSessionContent(content)
-  const tiers = collectWorkflowEntryTiers(entries)
+  const recordPaths = collectRegisteredRecordPaths(entries)
   const workflows: WorkflowRef[] = []
-  for (const runId of tiers.runIdOrder) {
-    const journalPath = tiers.v2ByRunId.get(runId)
-    if (journalPath !== undefined) {
-      // ① v2 档（[D16③] 重锚）：journalPath = record 流路径——新后缀锚点直读流提
-      // calls（agent-settled.result.sessionFile）；旧后缀锚点 = 历史实体（[D1]
-      // 不读旧两件）→ calls=[] 仅 run 存在性兜底。
-      let sessionFiles: string[] = []
-      if (isNewRecordStreamAnchor(journalPath)) {
-        let content: string | undefined
-        try {
-          content = await readFile(journalPath, 'utf8')
-        } catch {
-          content = undefined // 流被保留期清理/不可读 → calls=[]（run 存在性兜底）
-        }
-        sessionFiles = content === undefined ? [] : extractRecordStreamSessionFiles(content)
+  for (const runId of recordPaths.order) {
+    const recordPath = recordPaths.byRunId.get(runId)
+    if (recordPath === undefined) continue
+    let streamContent: string | undefined
+    if (isNewRecordStreamAnchor(recordPath)) {
+      try {
+        streamContent = await readFile(recordPath, 'utf8')
+      } catch {
+        streamContent = undefined // 流被保留期清理/不可读 → calls=[]（run 存在性兜底）
       }
-      workflows.push({
-        runId,
-        stateFile: journalPath,
-        calls: sessionFiles.map((sf) => sessionRefFromPath(sf, pathToRef)),
-      })
-      continue
-    }
-    const snapshot = tiers.v1ByRunId.get(runId)
-    if (snapshot !== undefined) {
-      // ② v1 快照档：快照全量在场，直接提 calls（W17~W1 中间档恢复）
-      workflows.push({
-        runId,
-        stateFile: '',
-        calls: extractCallSessionFiles(snapshot).map((sf) => sessionRefFromPath(sf, pathToRef)),
-      })
-      continue
     }
-    // ③ 旧指针档：现状（link path → wf-state 文件）
-    const link = tiers.linkByRunId.get(runId)
-    if (link === undefined) continue
-    const snap = await readRunSnapshot(link.path)
-    const sessionFiles = snap === undefined ? [] : extractCallSessionFiles(snap)
+    const sessionFiles = streamContent === undefined ? [] : extractRecordStreamSessionFiles(streamContent)
     workflows.push({
-      runId: link.runId,
-      stateFile: link.path,
+      runId,
+      stateFile: recordPath,
       calls: sessionFiles.map((sf) => sessionRefFromPath(sf, pathToRef)),
     })
   }

package/src/tool-handler.ts

@@ -1129,7 +1129,7 @@ async function renderSingleWorkflowRun(
     contentParts: string[]
   },
 ): Promise<void> {
-  // [D16③] 概览链换源：v2 档的 stateFile = record 流路径（journalPath 锚点语义
+  // [D16③] 概览链换源：v2 档的 stateFile = record 流路径（recordPath 锚点语义
   // 重定义）——直读流经 parseRunRecordStream 概览（[D2] 三态 status；空流/读失败
   // 投影 running，活跃 run 概览不退化为 skipped——红线）。record 后缀以外的
   // stateFile（v1 快照档空串 / 旧指针档 link path）走原快照链。

package/src/zcode-anchor-classify.ts

@@ -19,9 +19,9 @@ const SUBAGENT_RECORD_ENTRY_V2 = 2
 
 /**
  * 目标 sa-id 的 zcode 形态 subagent-record data：type/customType/版本关/id/engine
- * 全过才返回。版本关（W1 v2 学习，entry-anchor.ts zcodeAnchorOfEntry 同口径）：
- * v1 全量快照（`d.v === 1`，兼容读面）或 v2 终态条（`d.v === 2` ∧
- * `d.kind === 'settled'`——engineHandle 只在终态条，registered 不携带不归因）。
+ * 全过才返回。版本关（与 entry-anchor.ts zcodeAnchorOfEntry 同口径）：
+ * v2 终态条（`d.v === 2` ∧ `d.kind === 'settled'`——engineHandle 只在终态条，
+ * registered 不携带不归因；v1 全量快照形态已随兼容层删除，2026-09-30 登记 §3.3）。
  * engine 判别（D5）在此——`d.engine !== 'zcode'` 的记录（pi 形态：
  * engine 缺省、sessionRef 无 dbPath）不是「zcode 锚不完整」，返回 undefined 跳过
  * 不归因：误归因 missing-dbPath 会把「pi record 先于 manifest settle 落盘」的正常
@@ -34,11 +34,7 @@ function zcodeRecordDataOf(entry: Entry, saId: string): Record<string, unknown>
   if (typeof data !== 'object' || data === null) return undefined
   const d = data as Record<string, unknown>
   if (d.id !== saId) return undefined
-  if (d.v === SUBAGENT_RECORD_ENTRY_V2) {
-    if (d.kind !== 'settled') return undefined
-  } else if (d.v !== 1) {
-    return undefined
-  }
+  if (d.v !== SUBAGENT_RECORD_ENTRY_V2 || d.kind !== 'settled') return undefined
   if (d.engine !== 'zcode') return undefined
   return d
 }