@zhushanwen/pi-subagent-workflow 8.14.7 → 9.0.1

package/src/jsonl-run-store.ts

@@ -1,328 +1,544 @@
 /**
- * Workflow Extension — JSONL Run Store
+ * Workflow Extension — Run Record Store
  *
  * RunStore port 的 Infra 实现。
  *
- * 职责：持久化 WorkflowRun 聚合根到 JSONL 文件 + 跨 session 重水合。
+ * 职责：WorkflowRun 聚合根的 record 流权威重建（跨 session 重水合）。
  *
  * 层归属：Infra（D-12）。implements Engine 层的 RunStore port。
  * 依赖 @earendil-works/pi-coding-agent 的 ExtensionAPI/ExtensionContext（Infra 允许 Pi SDK）。
  *
- * 设计：
- * - JsonlRunStore implements RunStore（而非散落的 persist/reconstruct 自由函数）。
- * - **D-5: 不向后兼容**——reconstruct 时检查 snapshotVersion，无版本号或版本不匹配
- *   的 session 返回空数组（spec 决策：旧 run 历史价值低，不尝试兼容迁移）。
- * - rewrite mode（writeFile 覆盖，文件始终是最新单行快照）。
- * - **W17 [D4] workflow-record 自描述 entry**：每次成功 flush 同步 append 一条完整
- *   快照 entry（pi.appendEntry）——pi 文件（session JSONL）是 workflow 数据持久化
- *   权威，state 文件降级为纯性能缓存（读序 = entry > state 文件 > 空，写路径保留）。
- *   旧 `workflow-state-link` 指针 entry 退役（loadAll 保留兼容读，存量 run 不丢）。
- *   [B-1/OR-5 同源] entry append 按 runId 节流（见 save 注释「entry append 节流」），
- *   pi session JSONL 是 append-only 文件，节流前每次 flush 全量 append 会随 run
- *   时长累积出单 run O(n²) 磁盘占用。
+ * 介质形态（[D1] record 单源存储收敛，设计 workflow-run-resume-revision §3.3 D1）：
+ * - **唯一事实源 = record 事件流**（`<sessionDir>/workflow-state/<runId>.record.jsonl`，
+ *   append-only，core worker-message-pump 单写者 + 收编入口追加）：`run-created`
+ *   携带 scriptSource 全文、`agent-settled` 携带 result 全文；lifecycle/终局/calls
+ *   全部是 fold 内存投影，重启即从 record 重建。
+ * - **state 快照文件已删**：旧形态的 `<runId>.jsonl` 整文件覆盖写投影不再存在——
+ *   判终局 = record fold 终态唯一判法，无第二份可分叉的投影文件（设计目标 2）。
+ *   本类名沿用历史文件名（jsonl-run-store.ts / JsonlRunStore——消费面与测试脚本
+ *   的改名波及大于语义收益），语义已收敛为 record store 单模式。
+ * - **旧格式两件套（旧 journal `.events.jsonl` + state 快照 `<runId>.jsonl`）不读、
+ *   不写、不主动删**（用户裁决 2026-09-28：不做存量迁移）：全部读取路径只认
+ *   record 后缀；注册条目的 journalPath 锚点后缀天然区分新旧实体——旧后缀锚点
+ *   = 历史 run，跳过不重建（从壳侧读取面消失即 D1 历史数据处置的预期行为）。
+ * - **loadAll = record 流折叠重建**：v2 注册条目定界（本会话有哪些实体）→
+ *   record 流全量读 → fold 重建（终局 ⟸ run-settled 帧）；「有注册、无终局帧」
+ *   的实体保持 running 交恢复链收编；终局实体幂等补写 v2 终态条目。
+ *   **坏行停摆语义**：解析失败（半截行/非法 JSON/缺信封）与载荷完整性缺失
+ *   （settled 帧缺 result 全文）即抛错拒绝，不静默跳过——record 流是唯一事实
+ *   源，读不出 = 拒绝（场景 18），静默跳过会把数据损坏伪装成「无 run 历史」。
+ * - **主 session 每 run 两条 v2 小条目**（投影锚，非第二事实源）：注册条目
+ *   （core lifecycle.runWorkflow 写，身份 + record 流路径锚点）与终态条目（core
+ *   finalizeRun 终局 coda 写；本 store 的 loadAll 在「record 已终局而终态条目
+ *   缺失」时幂等补写）。条目可随时从 record 完整重建，判读只信 record fold。
+ * - **save = 显式 no-op**：run 域状态变化的持久化 = 事件追加（core 单写者链），
+ *   壳侧无投影可写。方法保留 = RunStore port 契约（core 调用点不改）。
  *
- * save 去抖语义（cw swf-perf wave2）：
- * - **热路径**（running 中间态，本实例已写过）：per-runId pending 批合并——窗口内
- *   N 次 save 只落盘 1 次（serialize-at-flush：写 flush 时刻最新聚合状态）。
- *   固定窗口不重置 timer（批创建时定时一次），保证 flush 延迟有界 ≤saveDebounceMs；
- *   agent-call 间隔秒级下 trailing 重置无合并增益反可无限推迟。
- * - **冷路径**（本实例对该 runId 首写，或 status !== "running" 即 done）：
- *   同步挂链 flush 绕过 timer——首写立即可见（跨 session 重启后 loadAll 从 entry
- *   发现 run）、done 立即落盘（终态优先持久化：transition("done") 后的 save
- *   不进去抖批，去抖窗口内的崩溃不吞终态）。
- * - workflow-record entry append 节流（[B-1]，语义对齐 core FileRunStore.save
- *   的 OR-5 ⑥a 节流，间隔常量单源复用 core DEFAULT_SAVE_MIN_INTERVAL_MS）：
- *   running 中间态的 entry append 有最小间隔（缺省 60s；0 = 禁用），终态 flush
- *   的 entry 永不节流（最终状态必进 pi 权威文件，loadAll/恢复不丢终态）；
- *   state 文件 writeFile 不节流（rewrite mode 覆盖写，无累积）。节流窗口内的
- *   entry 跳过 = pi 文件最后一条 entry 最多落后真实状态一个窗口，崩溃语义与
- *   未落盘 running 尾部丢失同源（kill-9 恢复收编）。
- * - per-runId 串行 flush 链：同 runId 的 flush 排队顺序执行（不跳过、永不并发
- *   writeFile），链尾吞错防断链——错误只经各 save() Promise 的 settlers 传播。
- * - dispose()：幂等（缓存自身 Promise）；刷全部 pending 批 + await 全部 in-flight
- *   链后返回。dispose 后 save 静默 no-op + debug 日志（session_shutdown 编排收尾）。
- *
- * 序列化策略（下沉收口 D4 后）：
- * - 快照投影/重水合/版本 guard 全部消费 core run-snapshot codec（toRunSnapshot/
- *   fromRunSnapshot）——字段演进单点（G2）；本 store 只保留 IO 策略（rewrite/
- *   去抖/append，D4 裁决：IO 差异归属宿主 store 层）。
- * - 版本值沿用 core SNAPSHOT_VERSION "wf-run-v2"（D4 裁决①：pi 存量逐字节可读）。
- * - pi 侧版本不匹配静默跳过语义保持（D-5）；「缺 v 宽容」是 core FileRunStore
- *   侧的存量预处理职责，不内聚进 codec（D4 裁决②），故本侧零改动即保持。
- *
- * [S3 查证结论] pi 0.84.4 实装（node_modules/@earendil-works/pi-coding-agent/dist，
- * core/session-manager.js，PS-19）的 session 生命周期管理不含自动 GC：
- * listSessionsFromDir 只做只读扫描（readdir + `.jsonl` 过滤 + header 解析，:548-571，
- * 非递归——`<sessionDir>/workflow-state/` 子目录完全不在 pi 的任何扫描/清理范围内），
- * SessionManager.list / listAll 只是它之上的 cwd 过滤/排序封装（:1281-1287 / :1289），
- * 无按 age/数量的 retention/prune/expire 删除逻辑；唯一删除路径是 TUI SessionSelector
- * 里用户手动删除选中的单个顶层 session 文件（trash CLI → unlink fallback，
- * dist/modes/interactive/components/session-selector.js:539-550），非自动、
- * 不递归子目录。**推论：workflow-state state 文件无限累积，
- * 保留策略由本包自担**——磁盘侧保留默认开（OR-5 ⑥b）：每次新 run state 文件首写
- * 成功即按 mtime 裁剪到上限（未设 {@link STATE_MAX_RUNS_ENV} 时取
- * {@link DEFAULT_STATE_MAX_RUNS} 默认值，见 pruneStateFilesBeyondCap；显式非法值
- * 是 opt-out 通道）；内存侧由 evictDoneRunsBeyondCap 淘汰。W17 后 state 文件
- * 已降级为纯性能缓存（权威数据在 session JSONL 的 workflow-record entry），随 session
- * 文件被用户删除时一并消失。
+ * 磁盘足迹（[S3 查证结论沿用] pi 不扫描/清理 `<sessionDir>/workflow-state/`，
+ * 保留策略由本包自担）：保留维护轮的触发点与判据单源在 core
+ * （runRetentionMaintenanceRound，session_start 兜底触发点见 session-lifecycle.ts）。
+ * 本 store 不再触发维护轮——旧触发点（state 快照首写）随快照删除而消失；
+ * abandon 终局化接线（abandonElapsedInterruptedRuns）随 D9 拆除，interrupted 的
+ * 进入方收敛为崩溃收编与 terminate（core 侧）。
  */
 
 import * as fs from "node:fs";
 import * as path from "node:path";
 
 import type { CustomEntry, ExtensionAPI, ExtensionContext, SessionEntry } from "@earendil-works/pi-coding-agent";
-// DEFAULT_SAVE_MIN_INTERVAL_MS / DEFAULT_STATE_MAX_RUNS 保留深路径：core barrel
-// 刻意不导出（exports 面即 semver 契约，见 subagent-core src/index.ts 头注），壳侧
-// barrel 消费（DEFAULT_* 已进 core barrel——u-2c 删 ./* 通配后深路径 tsc 不可解析）
+// 全部经 core barrel 消费（生产消费纪律：extensions 源码不深路径 import core）。
 import {
-  DEFAULT_SAVE_MIN_INTERVAL_MS,
-  DEFAULT_STATE_MAX_RUNS,
+  AgentCall,
+  ALL_RUN_OUTCOMES,
+  Budget,
+  RUN_EVENT_TYPES,
+  RUN_EVENT_JOURNAL_SUFFIX,
+  STATE_DIR_NAME,
+  Trace,
+  WORKFLOW_RECORD_CUSTOM_TYPE,
+  buildWorkflowRecordSettledEntryData,
+  classifyWorkflowRecordEntryData,
+  getLogger,
+  runSettledOutcomeToDoneReason,
+  type AgentResult,
+  type ExecutionTraceNode,
+  type RunOutcome,
+  type RunStore,
+  type WorkflowRecordRegisteredEntryData,
+  type WorkflowRecordSettledEntryData,
+  type WorkflowRunEvent,
 } from "@zhushanwen/subagent-core";
-import { getLogger } from "@zhushanwen/subagent-core";
-
 import { WorkflowRun } from "@zhushanwen/subagent-core";
-import {
-  SNAPSHOT_VERSION,
-  fromRunSnapshot,
-  toRunSnapshot,
-  pruneStateFilesBeyondCap,
-  type RunSnapshot,
-} from "@zhushanwen/subagent-core";
 import { guardStaleCtx, isEnoentError, toErrorMessage } from "@zhushanwen/pi-ext-guards";
 
-// ── Workflow-record self-describing entry (W17, D4) ─────────
+// ── [W1 / D1] v2 条目读面（注册定界 + 终态条目抑制）────────────────
+
+/** loadAll 的 entry 扫描产物。 */
+interface EntrySources {
+  /** v2 注册条目（runId → 注册载荷；record 重建的定界源 + journalPath 锚点）。 */
+  registered: Map<string, WorkflowRecordRegisteredEntryData>;
+  /**
+   * 已有 v2 终态条目的 run（runId → 终态载荷，后写覆盖 = last-wins）。唯一用途 =
+   * 终态条目幂等补写的抑制判定（条目已在则不重写）。**不参与终局判读**——
+   * 判终局 = record fold 唯一判法（D1：条目是投影锚，可随时从 record 重建）。
+   */
+  settledEntries: Map<string, WorkflowRecordSettledEntryData>;
+}
 
 /**
- * 自描述 workflow record entry 的 customType（W17 [D4]）。命名对齐 W16 的
- * `subagent-record`（连字符风格）。写点字面量与本常量的等值由
- * __tests__/jsonl-run-store-session-file.test.ts 断言钉住（消费方引用本常量，勿用裸字符串）。
+ * v2 条目 → 注册定界 / 终态条目抑制。载荷按 kind 分流；载荷形状损坏（缺 runId
+ * 等半写形态）warn 留证后跳过（[SO-DATA-2] per-entry 隔离口径：残缺 entry 不得
+ * 让 loadAll 返回空）。
  */
-export const WORKFLOW_RECORD_CUSTOM_TYPE = "workflow-record";
+function collectV2RecordEntry(entry: CustomEntry, entryIndex: number, sources: EntrySources): void {
+  if (entry.customType !== WORKFLOW_RECORD_CUSTOM_TYPE) return;
+  const classification = classifyWorkflowRecordEntryData(entry.data);
+  if (classification.ok || classification.reason !== "v2") return;
+  const v2 = classification.entry;
+  if (v2.kind === "registered") {
+    if (typeof v2.runId !== "string" || v2.runId === "" || typeof v2.journalPath !== "string") {
+      logger.warn(
+        `[subagent-workflow] workflow-record v2 registered entry #${entryIndex} malformed (runId/journalPath missing), skipped`,
+      );
+      return;
+    }
+    sources.registered.set(v2.runId, v2);
+    return;
+  }
+  // settled
+  if (typeof v2.runId !== "string" || v2.runId === "") {
+    logger.warn(
+      `[subagent-workflow] workflow-record v2 settled entry #${entryIndex} malformed (runId missing), skipped`,
+    );
+    return;
+  }
+  sources.settledEntries.set(v2.runId, v2);
+}
+
+/** loadAll 的 entry 扫描：主 session entries → v2 注册定界 + 终态条目抑制（唯一发现
+ *  通道）。历史形态 entry（v1 全量快照 / 旧 workflow-state-link 指针）静默忽略——
+ *  历史数据仍在盘上，不再重建；未知 entry 的容忍面不受影响。 */
+function collectEntrySources(entries: SessionEntry[]): EntrySources {
+  const sources: EntrySources = {
+    registered: new Map<string, WorkflowRecordRegisteredEntryData>(),
+    settledEntries: new Map<string, WorkflowRecordSettledEntryData>(),
+  };
+  // 索引循环：损坏留证的 warn 需要 entry 索引（SO-DATA-2）
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i]!;
+    if (entry.type !== "custom") continue;
+    collectV2RecordEntry(entry, i, sources);
+  }
+  return sources;
+}
+
+// ── run-settled 帧判读（DoneReason 映射 + 终局记录投影）────────────
+
+// DoneReason 联合判别单点 = core terminal-actions.runSettledOutcomeToDoneReason
+// （值表与语义注释见 core 侧定义）——壳内消费方（foldRecordStreamToRun /
+// appendSettledEntryFallback）经顶部 import 取用；re-export 维持
+// workflow-notify 等壳内文件的既有本地导入路径。
+/** run-settled 帧形状（从 record 事件词表提取——errorCode 类型同源，免第二定义点）。 */
+type RunSettledFrame = Extract<WorkflowRunEvent, { type: "run-settled" }>;
+
+export { runSettledOutcomeToDoneReason } from "@zhushanwen/subagent-core";
 
 /**
- * `workflow-record` entry 的 data schema（v1）。
- *
- * = 完整 RunSnapshot 快照（runId/status/calls/trace 等全部重建需要的字段）+ 版本号。
- * 读取方无需逆向解析 state 文件或指针（D4 自描述原则）；snapshot 内部自带 D-5
- * snapshotVersion guard（fromRunSnapshot 检查），entry 层 v 与 snapshot 层 v 是两级
- * 独立版本（entry schema 演化 vs 快照格式演化）。
+ * 终局记录（record run-settled 帧载荷的进程内投影——与 core 侧
+ * RunSettlementRecord 同构）。reason/errorCode 直取帧载荷；DoneReason 由
+ * runSettledOutcomeToDoneReason 联合派生（不在本形状内预计算）。
  */
-// 模块内类型（不导出：无外部消费方，fallow unused_types/private_type_leaks 双轨判定；
-// 运行侧 workflow-extractor 的同形结构独立定义，见其注释）。
-interface WorkflowRecordEntryData {
-  /** schema 版本（W17 起 v1）。消费方按 v 判别解析，不认识的版本跳过而非猜测。 */
-  v: 1;
-  /** 完整 RunSnapshot（与同次 flush 写入 state 文件的内容是同一份，不二次序列化）。 */
-  snapshot: RunSnapshot;
-  /** append 时刻 ISO 时间（诊断用；重建不依赖）。 */
-  updatedAt: string;
+export interface RunSettlementRecord {
+  outcome: RunOutcome;
+  errorCode?: RunSettledFrame["errorCode"];
+  reason?: string;
+  settledAt: number;
 }
 
-/** 已序列化快照 → 自描述 entry data（doFlush 消费同一 snapshot，保证 entry 与 state 文件一致）。 */
-function toWorkflowRecordEntryData(snapshot: RunSnapshot): WorkflowRecordEntryData {
-  return { v: 1, snapshot, updatedAt: new Date().toISOString() };
+// ── record 流读原语（严格解析 + 完整性拒绝）────────────────────
+
+/**
+ * record 流损坏（读失败拒绝，场景 18）。
+ *
+ * 语义：record 流是 run 域唯一事实源（D1），解析失败或载荷完整性缺失 = 流被
+ * 截断/篡改/写入器缺陷——拒绝静默跳过（跳过会把损坏伪装成「无 run 历史」，
+ * 恢复链收编会在残缺事实上追加收编帧）。错误消息含恢复指引（错误 → 权威源 →
+ * 处置闭环）。
+ */
+export class RecordStreamCorruptionError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "RecordStreamCorruptionError";
+  }
 }
 
-// ── Serialization → core codec（下沉收口 D4）──────────────────
-//
-// serializeRun/deserializeRun 本地投影已退役：快照投影/重水合/版本 guard 单源消费
-// core run-snapshot codec（toRunSnapshot/fromRunSnapshot）。键序与 strip live 语义
-// 与原本地实现逐字节一致（⛔5 快照锚定：__tests__/jsonl-run-store-snapshot-codec.test.ts）；
-// 唯一投影差异 = spec.budgetRef 剔除（codec 单源裁决，嵌套 run 落盘少一脏字段，
-// 性质同 strip live——同偏差登记）。
+/** record 事件词表集合（[D2] 守卫判定的本地只读投影；词表 SSOT = run-events RUN_EVENT_TYPES）。 */
+const RUN_EVENT_TYPE_SET: ReadonlySet<string> = new Set<string>(RUN_EVENT_TYPES);
 
-/** workflow-record entry → 重建 run 写入 recordRuns（v1 entry guard + D-5 版本不匹配
- *  跳过；同 runId 后写覆盖 = 最后一条 entry 胜出）。返回 entry 是否命中该类型。
- *
- *  版本可见性分层（D4 裁决③宿主侧落地）：v 不匹配（v1 存量/未来版本）→ 静默跳过
- *  （既有语义）；v 匹配但形状损坏（codec 返回 undefined——codec 形状校验不抛）→
- *  warn 留证。
+/** 事件信封守卫（taste/no-unsafe-cast：结构断言改类型守卫——type/ts 可用性在守卫内收窄）。 */
+function hasEventEnvelope(v: object): v is { type: string; ts: number } {
+  const rec = v as Record<string, unknown>;
+  return typeof rec["type"] === "string" && rec["type"] !== "" && typeof rec["ts"] === "number" && Number.isFinite(rec["ts"]);
+}
+
+/**
+ * record 流全量读（严格解析）：合法事件行按写入序返回；坏行（JSON 解析失败 /
+ * 非对象 / 缺 type/ts 信封）与载荷完整性缺失（agent-settled 帧缺 result 全文）
+ * 抛 {@link RecordStreamCorruptionError}——不静默跳过（场景 18 坏行停摆语义，
+ * 与 core journal scan 活体投影的宽容跳过语义刻意分层：活体 fold 不能因单帧
+ * 全停，恢复读面不能对损坏装瞎）。
  *
- *  [SO-DATA-2] per-entry 隔离：残缺 entry（截断/手改/半写）不得让 loadAll 返回空。
- *  原实现靠「deserializeRun 抛 TypeError → catch → warn」；codec 收敛后形状损坏
- *  走 undefined 返回（warn 分支保持同等留证），try/catch 保留兜底 codec 唯一抛点
- *  （done 快照缺 reason 的 WorkflowRun I2 不变式）。
+ * 文件不存在（ENOENT）原样上抛交调用方分流（新形态实体早期崩溃 vs 历史实体）。
  */
-function collectRecordRun(entry: CustomEntry, entryIndex: number, recordRuns: Map<string, WorkflowRun>): boolean {
-  if (entry.customType !== WORKFLOW_RECORD_CUSTOM_TYPE) return false;
-  // v1 entry guard：schema 版本不认识 → 跳过（不猜测解析）
-  const data = entry.data as WorkflowRecordEntryData | undefined;
-  if (data?.v !== 1 || !data.snapshot) return true;
-  try {
-    if (data.snapshot.v === SNAPSHOT_VERSION) {
-      const run = fromRunSnapshot(data.snapshot);
-      if (run) {
-        recordRuns.set(run.runId, run); // 后写覆盖 = 最后一条 entry 胜出
-      } else {
-        logger.warn(
-          `[subagent-workflow] workflow-record entry #${entryIndex} corrupted, skipped run rebuild: snapshot shape invalid`,
-        );
+function readRecordStream(recordPath: string): WorkflowRunEvent[] {
+  const content = fs.readFileSync(recordPath, "utf8");
+  const events: WorkflowRunEvent[] = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]!;
+    if (line.trim().length === 0) continue;
+    const corruption = (reason: string): RecordStreamCorruptionError =>
+      new RecordStreamCorruptionError(
+        `record 流损坏，拒绝静默跳过（文件=${recordPath} 行=${i + 1}）：${reason}。` +
+          "record 流是 run 域唯一事实源（D1），坏行意味着截断/篡改/写入器缺陷。恢复：检查该文件是否被外部编辑" +
+          "或写入器版本与载荷契约不符（dispatchRunCreated/dispatchAskSettled）；无法修复时接受该 run 不可续跑，勿手工删行。",
+      );
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      throw corruption("非法 JSON（半截行/截断写入）");
+    }
+    if (typeof parsed !== "object" || parsed === null || !hasEventEnvelope(parsed)) {
+      throw corruption("缺事件信封（type/ts）或非对象行");
+    }
+    const event = parsed as WorkflowRunEvent;
+    // [D2] 词表/词值守卫（对齐 core isWorkflowRunEventLine 判定面）：type 落词表 +
+    // outcome（携带时）落词表——历史形态帧（旧词表成员/旧 outcome 值）按损坏拒绝
+    // （[D1] 历史数据处置：旧词表行不进解析路径；本 strict 读面不静默跳过坏行，
+    // 拒绝语义同半截行——调用方 storeHealthy=false fail-fast）。
+    if (!RUN_EVENT_TYPE_SET.has(event.type)) {
+      throw corruption(`词表外事件 type=${JSON.stringify(event.type)}（旧词表历史行——[D1] 不读旧两件）`);
+    }
+    if (event.type === "run-settled" || event.type === "agent-settled") {
+      // event 已窄化为 RunSettledEvent | AgentSettledEvent（两成员 outcome 均必填）；
+      // !== undefined 防御保留——旧格式历史行可能缺字段（读取面放行，词表判据兜底）。
+      const outcome = event.outcome;
+      if (outcome !== undefined && !(ALL_RUN_OUTCOMES as readonly string[]).includes(outcome as string)) {
+        throw corruption(`词表外 outcome=${JSON.stringify(outcome)}（[D2] 词表重构后的历史形态——interrupted 已入 lifecycle）`);
       }
     }
-    // D-5: 版本不匹配 = old snapshot format / future version — skip silently
-  } catch (err) {
-    const reason = toErrorMessage(err);
-    logger.warn(
-      `[subagent-workflow] workflow-record entry #${entryIndex} corrupted, skipped run rebuild: ${reason}`,
-    );
-  }
-  return true;
-}
-
-/** 旧 workflow-state-link 指针 entry → 写入 pointers（仅 state 文件发现通道，W17 前形态）。
- *  返回 entry 是否命中该类型。 */
-function collectStateLinkPointer(entry: CustomEntry, pointers: Map<string, { path: string }>): boolean {
-  if (entry.customType !== "workflow-state-link") return false;
-  const data = entry.data as { runId?: string; path?: string } | undefined;
-  if (data?.runId && data?.path) {
-    pointers.set(data.runId, { path: data.path });
+    if (event.type === "agent-settled" && event.result === undefined) {
+      throw corruption(
+        "agent-settled 帧缺 result 全文（record 单源后为非法形态——流被篡改或写入器未携带全文，场景 18）",
+      );
+    }
+    events.push(event);
   }
-  return true;
+  return events;
 }
 
-/** loadAll 的 entry 扫描：主 session entries → 自描述 record 快照（每 runId 末条胜出）
- *  + 旧 workflow-state-link 指针（仅 state 文件发现通道）。 */
-function collectEntrySources(entries: SessionEntry[]): {
-  recordRuns: Map<string, WorkflowRun>;
-  pointers: Map<string, { path: string }>;
-} {
-  const recordRuns = new Map<string, WorkflowRun>();
-  const pointers = new Map<string, { path: string }>();
-  // 索引循环：collectRecordRun 的 warn 留证需要 entry 索引（SO-DATA-2）
-  for (let i = 0; i < entries.length; i++) {
-    const entry = entries[i]!;
-    if (entry.type !== "custom") continue;
-    if (collectRecordRun(entry, i, recordRuns)) continue;
-    collectStateLinkPointer(entry, pointers);
+/** 事件流尾向扫描取最后一帧 run-settled（单终局不变量下的防御性读取）。 */
+function lastRunSettledEvent(
+  events: readonly WorkflowRunEvent[],
+): RunSettledFrame | undefined {
+  for (let i = events.length - 1; i >= 0; i--) {
+    const ev = events[i];
+    if (ev?.type === "run-settled") return ev;
   }
-  return { recordRuns, pointers };
+  return undefined;
 }
 
-/** 旧 link 指针指向的 state 文件读取：末行 JSON 解析重建。损坏/不可读/版本不匹配
- *  返回 null（单文件失败不阻断其余 run 重建；D-5 静默跳过语义保持）。 */
-async function loadRunFromStateFile(filePath: string): Promise<WorkflowRun | null> {
-  try {
-    const content = await fs.promises.readFile(filePath, "utf8");
-    const lines = content.split("\n").filter((l) => l.trim());
-    const lastLine = lines[lines.length - 1];
-    if (!lastLine) return null;
-    const parsed: unknown = JSON.parse(lastLine);
-    // D-5: undefined = old format / version mismatch / corrupt shape — skip silently
-    return fromRunSnapshot(parsed) ?? null;
-  } catch {
-    // Corrupt/unreadable state file — skip (don't crash loadAll).
-    return null;
+/**
+ * 尾向扫描「末次 run-interrupted 后无 run-resumed」的中断时刻（ISO；无中断或
+ * 已复活 → undefined）。[D2] interrupted 暂停态的 fold 投影依据——loadAll 重建
+ * 的中断 run 由 meta.interruptedAt 承载（聚合 status 保持两态）。
+ */
+function lastInterruptedAt(events: readonly WorkflowRunEvent[]): string | undefined {
+  for (let i = events.length - 1; i >= 0; i--) {
+    const ev = events[i];
+    if (ev?.type === "run-resumed") return undefined; // 已复活——中断标记清除
+    if (ev?.type === "run-interrupted") return new Date(ev.ts).toISOString();
   }
+  return undefined;
 }
 
-// ── State file retention (OR-5 ⑥b, default-on) ───────────────
-//
-// 裁剪主体单源消费 core pruneStateFilesBeyondCap（S4-A7 收口：本地曾有一份逐段
-// 同构的私有实现，retention 语义双份各自演化是漂移隐患）；日志注入本模块
-// logger + [subagent-workflow] tag，错误字符串化用 ext-guards toErrorMessage——
-// 行为与收口前一致（差异仅经 core 单源演化时两宿主同步）。
-
-// ── JsonlRunStore ────────────────────────────────────────────
-
-const logger = getLogger("subagents");
+// ── record 流 fold 重建（事件流 → WorkflowRun）──────────────────
 
 /**
- * save 去抖窗口默认值（ms）。区间 100-250 内取值——agent-call 间隔秒级，
- * 200ms 足以合并同一 call 周期内的多次状态 mutation，又不至于让崩溃窗口
- * （未 flush 的 running 尾部丢失，等价崩溃链由 kill-9 恢复收编）明显放大。
- * 模块私有：无外部消费方（构造参数 saveDebounceMs 可调窗口，测试经其注入）。
+ * 单个 call 的重建中间形态（fold 循环产出；AgentCall 构造延迟到 Trace 建立后
+ * ——traceNode 需与 Trace 共享同一节点副本，D-10 引用共享）。
  */
-const DEFAULT_SAVE_DEBOUNCE_MS = 200;
+interface CallDraft {
+  taskIndex: number;
+  agentName: string;
+  phase?: string;
+  startedAtIso: string;
+  attempts: number;
+  /** 有 settled 帧 = done；无 = 在途（running）。 */
+  result?: AgentResult;
+  settledOutcome?: RunOutcome;
+  settledTs?: number;
+}
 
 /**
- * 磁盘保留清理的上限 env（OR-5 ⑥b 默认开）：workflow-state 目录内 run state
- * 文件上限。
+ * record 事件流 → WorkflowRun 聚合重建（纯函数，零 IO）。
  *
- * 解析语义与 core FileRunStore envName 通道一致（两实现面单源 {@link
- * DEFAULT_STATE_MAX_RUNS}）：
- * - 未设/空 → 按默认上限 {@link DEFAULT_STATE_MAX_RUNS} 裁剪（**默认开**——
- *   OR-5 修复前的 opt-in「默认关」正是跨 run 无界累积缺陷本身）；
- * - 有限正数 → 上限 = env 值（显式覆盖默认值）；
- * - 非法值（非有限数/≤0）→ 不清理（显式 opt-out 通道：用户意图不明时不动
- *   磁盘，对齐 prune 内部「任何失败都不抛」的保守哲学）。
+ * fold 语义（词表 = run-events.ts [D4] 对齐后 9 事件）：
+ * - `run-created`：spec.scriptSource（全文，[D1]）+ args（全文，设计 §3.1 载荷表；
+ *   旧格式帧回落 argsSummary 尽力恢复——parseLegacyArgsSummary）+ startedAt 锚点
+ *   （帧 ts 优先，回落注册条目 startedAt）；
+ * - `agent-started`：按 taskIndex 建 call（agentName/phase/startedAt）；
+ *   重复 started 不重建（同 record fold 语义）；
+ * - `agent-retrying`：无实体字段可回填（attempts 终值由 settled 帧承载）——跳过；
+ * - `agent-settled`：result 全文回填 + done 终态（settled 先于 started 的残
+ *   形态建占位行——同 journal fold 兜底）；sessionFile/sessionId 从 result 透传
+ *   （对齐 finalizeCall 的 call 字段填充纪律）；
+ * - `run-settled`：终局（status=done + reason 映射 + completedAt=帧 ts）；无帧 =
+ *   running（交恢复链收编）。
  *
- * 用 TAIJI_ 前缀而非 PI_：本 env 是 pi 进程内读的配置 env，taiji 桌面 spawn 链按
- * ENV_WHITELIST_PREFIXES（只有 TAIJI_ 等）过滤，PI_ 前缀在桌面场景被静默丢弃——
- * 同 TAIJI_SUBAGENT_IDLE_TIMEOUT_MS 的改名教训（lifecycle-manager.ts）。
+ * record 流不承载的字段（budget 计数/errorLogs/trace 完整面）按恢复语义最小形态
+ * 缺省——步骤级详情的恢复读面 = record 流直读（session-reader 家族链），不经本聚合。
  */
-export const STATE_MAX_RUNS_ENV = "TAIJI_SUBAGENT_STATE_MAX_RUNS";
-
-/** 解析保留上限；env 未设/空 → 默认上限，显式非法/≤0 → undefined（不清理）。 */
-function getEnvStateMaxRuns(): number | undefined {
-  const raw = process.env[STATE_MAX_RUNS_ENV];
-  if (raw === undefined || raw === "") return DEFAULT_STATE_MAX_RUNS;
-  const parsed = Number(raw);
-  if (!Number.isFinite(parsed) || parsed <= 0) return undefined;
-  return parsed;
-}
 
 /**
- * per-runId 去抖批。窗口内 N 次 save 合并：latestRun 保留最新聚合引用
- * （serialize-at-flush），settlers 收集批内全部 save() 调用方的 settle 回调。
+ * argsSummary → args 尽力恢复（旧格式帧回落通道，core resume-run.parseArgsSummary
+ * 同款语义）：现行写入面 run-created 帧携带 args 全文（上方优先消费）；本函数只
+ * 服务旧格式帧——未截断摘要可完整恢复，截断/不可解析回落 {}（旧格式流的 $ARGS
+ * 语义限制，回落处置对齐 core 侧「尽力恢复」——core 同款分支 warn 留证，非静默）。
  */
-interface PendingSaveBatch {
-  latestRun: WorkflowRun;
-  /**
-   * 批的去抖 timer（构造时即确定——经 {@link JsonlRunStore.armPendingBatch} 工厂
-   * 内联组装，timer 与批对象在同一同步段成型，类型上不存在「先构造后赋值」的
-   * 可选窗口）。
-   */
-  timer: NodeJS.Timeout;
-  settlers: Array<{ resolve: () => void; reject: (e: unknown) => void }>;
+function parseLegacyArgsSummary(argsSummary: string | undefined): Record<string, unknown> {
+  if (argsSummary === undefined || argsSummary === "" || argsSummary.endsWith("…")) return {};
+  try {
+    const parsed: unknown = JSON.parse(argsSummary);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed as Record<string, unknown>;
+    }
+  } catch (err) {
+    // 回落 {} 不变（$ARGS 语义限制），warn 留证旧格式数据异常（对齐 core
+    // parseArgsSummary 同分支的日志级别）
+    logger.warn(
+      `[subagent-workflow] legacy run-created argsSummary is not parseable JSON — $ARGS restored as {} (${toErrorMessage(err)})`,
+    );
+  }
+  return {};
 }
 
+/** [foldRecordStreamToRun 拆分] 事件流 → call 重建中间形态（per taskIndex 聚合
+ * started/settled 两帧；settled 先于 started 的残形态占位行兜底——同 journal fold，
+ * 保投影不丢终局）。 */
+function collectRunCallDrafts(events: readonly WorkflowRunEvent[]): Map<number, CallDraft> {
+  const drafts = new Map<number, CallDraft>();
+  for (const event of events) {
+    if (event.type === "agent-started") {
+      if (drafts.has(event.taskIndex)) continue;
+      drafts.set(event.taskIndex, {
+        taskIndex: event.taskIndex,
+        agentName: event.agentName,
+        ...(event.phase !== undefined ? { phase: event.phase } : {}),
+        startedAtIso: new Date(event.ts).toISOString(),
+        attempts: event.attempt,
+      });
+    } else if (event.type === "agent-settled") {
+      applySettledToRunDraft(drafts, event);
+    }
+  }
+  return drafts;
+}
+
+/** [collectRunCallDrafts 拆分] agent-settled 归并（无 started 行时占位兜底成行）。 */
+function applySettledToRunDraft(
+  drafts: Map<number, CallDraft>,
+  event: Extract<WorkflowRunEvent, { type: "agent-settled" }>,
+): void {
+  const existing = drafts.get(event.taskIndex);
+  if (existing === undefined) {
+    // settled 先于 dispatched 的残形态：占位行兜底（同 journal fold——
+    // 保投影不丢终局）
+    drafts.set(event.taskIndex, {
+      taskIndex: event.taskIndex,
+      agentName: "(unknown)",
+      startedAtIso: new Date(event.ts).toISOString(),
+      attempts: event.attempt,
+      result: event.result,
+      settledOutcome: event.outcome,
+      settledTs: event.ts,
+    });
+    return;
+  }
+  existing.attempts = event.attempt;
+  existing.result = event.result;
+  existing.settledOutcome = event.outcome;
+  existing.settledTs = event.ts;
+}
+
+/** [foldRecordStreamToRun 拆分] 中间形态 → trace 节点（Trace 先重建——call 的
+ * traceNode 回链到 Trace 副本，D-10 引用共享；匹配不到退化为独立浅拷贝，仅保构造不炸）。 */
+function draftsToExecutionTraceNodes(drafts: Map<number, CallDraft>): ExecutionTraceNode[] {
+  return [...drafts.values()].map((d) => ({
+    stepIndex: d.taskIndex,
+    agent: d.agentName,
+    task: "",
+    model: "",
+    status: d.settledOutcome === undefined ? "running" : d.settledOutcome === "done" ? "completed" : "failed",
+    ...(d.phase !== undefined ? { phase: d.phase } : {}),
+    startedAt: d.startedAtIso,
+    // settled 终局保真：result 全文随节点（D-10 节点持 result 引用的原语义）+
+    // completedAt（节点时间锚）+ error 诊断面
+    ...(d.result !== undefined ? { result: d.result } : {}),
+    ...(d.result?.error !== undefined ? { error: d.result.error } : {}),
+    ...(d.settledTs !== undefined ? { completedAt: new Date(d.settledTs).toISOString() } : {}),
+  }));
+}
+
+/** [foldRecordStreamToRun 拆分] 中间形态 → AgentCall（直接构造 done/running 终态，
+ * bypass markRunning/markDone 状态机守卫——重建已知良好持久态的既定先例；opts 最小
+ * 形态：record 流现行载荷不携带入参全文，重建聚合的 opts 仅满足 AgentCallOpts
+ * 契约形状，prompt 占位空串）。 */
+function draftsToAgentCalls(
+  drafts: Map<number, CallDraft>,
+  sharedNodes: Map<number, ExecutionTraceNode>,
+  nodes: ExecutionTraceNode[],
+): Map<number, AgentCall> {
+  const calls = new Map<number, AgentCall>();
+  for (const d of drafts.values()) {
+    const linked = sharedNodes.get(d.taskIndex) ?? nodes.find((n) => n.stepIndex === d.taskIndex)!;
+    const call = new AgentCall(d.taskIndex, { prompt: "" }, linked);
+    call.attempts = d.attempts;
+    call.status = d.settledOutcome === undefined ? "running" : "done";
+    if (d.result !== undefined) {
+      call.result = d.result;
+      // sessionFile/sessionId 对齐 finalizeCall 的 call 字段填充纪律
+      if (d.result.sessionFile !== undefined) call.sessionFile = d.result.sessionFile;
+      if (d.result.sessionId !== undefined) call.sessionId = d.result.sessionId;
+    }
+    calls.set(d.taskIndex, call);
+  }
+  return calls;
+}
+
+
+/** [foldRecordStreamToRun 拆分] run spec 重建（run-created 帧优先，注册条目兜底）：
+ * args 全文优先（设计 §3.1 载荷表 run-created 行「args」）；旧格式帧回落
+ * argsSummary 尽力恢复（未截断可完整恢复，截断回落 {}——core parseArgsSummary
+ * 同款语义；两侧行为等价由 record-mode 测试锁定）；scriptPath 锚定恢复（core
+ * rebuildRunFromRecord 同款）：worker 沙箱 eval 模式无 __dirname，模板脚本靠
+ * scriptPath 定位 _shared 族共享件；旧格式帧缺失回落空串。 */
+function rebuildRunSpecFromEntries(
+  created: Extract<WorkflowRunEvent, { type: "run-created" }> | undefined,
+  reg: WorkflowRecordRegisteredEntryData,
+) {
+  return {
+    scriptSource: created?.scriptSource ?? "",
+    args: created?.args ?? parseLegacyArgsSummary(created?.argsSummary),
+    scriptName: reg.scriptName,
+    scriptPath: created?.scriptPath ?? "",
+    ...(reg.slug !== undefined ? { slug: reg.slug } : {}),
+  };
+}
+
+function foldRecordStreamToRun(
+  runId: string,
+  reg: WorkflowRecordRegisteredEntryData,
+  events: readonly WorkflowRunEvent[],
+): WorkflowRun {
+  const created = events.find(
+    (e): e is Extract<WorkflowRunEvent, { type: "run-created" }> => e.type === "run-created",
+  );
+  const startedAtMs =
+    created?.ts ?? (Number.isFinite(reg.startedAt) ? reg.startedAt : Date.now());
+  const startedAtIso = new Date(startedAtMs).toISOString();
+  const spec = rebuildRunSpecFromEntries(created, reg);
+
+  const drafts = collectRunCallDrafts(events);
+
+  // Trace 先重建：call 的 traceNode 回链到 Trace 副本（D-10 引用共享；匹配不到
+  // 退化为独立浅拷贝，仅保构造不炸）。
+  const nodes = draftsToExecutionTraceNodes(drafts);
+  const trace = Trace.fromArray(nodes);
+  const sharedNodes = new Map(trace.toArray().map((n) => [n.stepIndex, n]));
+
+  const calls = draftsToAgentCalls(drafts, sharedNodes, nodes);
+
+  const settledEvent = lastRunSettledEvent(events);
+  if (settledEvent === undefined) {
+    const interruptedAt = lastInterruptedAt(events);
+    return WorkflowRun.reconstruct(
+      runId,
+      spec,
+      {
+        status: "running",
+        budget: new Budget(),
+        calls,
+        trace,
+        errorLogs: [],
+      },
+      {
+        startedAt: startedAtIso,
+        // 中断标记（[D2] 聚合 status 两态、中断态经 meta 投影表达）：末次
+        // run-interrupted 后无 run-resumed 复活 → meta.interruptedAt 置位，
+        // runSummary 投影 'interrupted'（CLI/TUI 不显示僵尸「运行中」；resume
+        // 资格判据在 core fold lifecycle，不受本投影影响）。
+        ...(interruptedAt !== undefined ? { interruptedAt } : {}),
+      },
+    );
+  }
+  const reason = runSettledOutcomeToDoneReason(settledEvent.outcome, settledEvent.errorCode);
+  return WorkflowRun.reconstruct(
+    runId,
+    spec,
+    {
+      status: "done",
+      reason,
+      budget: new Budget(),
+      calls,
+      trace,
+      errorLogs: [],
+      // 成功终局无 error；失败终局带帧 reason 文本（不落 generic 恢复文案）
+      ...(reason !== "completed" && settledEvent.reason !== undefined ? { error: settledEvent.reason } : {}),
+    },
+    {
+      startedAt: startedAtIso,
+      completedAt: new Date(settledEvent.ts).toISOString(),
+    },
+  );
+}
+
+// ── JsonlRunStore ────────────────────────────────────────────
+
+const logger = getLogger("subagents");
+
 interface JsonlRunStoreOptions {
-  /** Session directory root (state files live under <sessionDir>/workflow-state/). */
+  /** Session directory root (record streams live under <sessionDir>/workflow-state/). */
   sessionDir: string;
-  /** Pi ExtensionAPI for workflow-record appendEntry writes (optional for testing). */
+  /** Pi ExtensionAPI for v2 终态条目补写（loadAll 收编面；optional for testing）。 */
   pi?: ExtensionAPI;
   /** Pi ExtensionContext for sessionManager.getEntries (optional for testing). */
   ctx?: ExtensionContext;
-  /** save 去抖窗口（ms），默认 {@link DEFAULT_SAVE_DEBOUNCE_MS}。 */
-  saveDebounceMs?: number;
-  /**
-   * workflow-record entry append 节流最小间隔（ms）；0 = 禁用节流。缺省
-   * {@link DEFAULT_SAVE_MIN_INTERVAL_MS}（单源复用 core 常量）。测试经此注入小窗口
-   * （fake timers 推进）。
-   */
-  entryAppendMinIntervalMs?: number;
 }
 
-export class JsonlRunStore {
+/**
+ * RunStore port 的 pi 宿主 Inf 实现（session 锚定：唯一事实源 = record 事件流，
+ * [D1] 单模式）。port 契约类型经 core barrel（RunStore 三方法 save / loadAll /
+ * stateFilePath，models/ports.ts）。
+ *
+ * 本类的四个 interface 面（方法分组索引）：
+ * 1. **port 面**（RunStore 契约）：save（no-op）/ loadAll（record 折叠重建）/
+ *    stateFilePath（record 流路径）——组合根装配 LifecycleDeps.store 的注入面；
+ * 2. **adoption 面**（skill-reload 接管）：rebind——post-reload session_start
+ *    就地重绑 appendEntry 源（v2 终态条目补写面的消费源）；
+ * 3. **终局记录查询面**：settledRecordOf——通知载荷链的帧直取源；
+ * 4. **生命周期面**：dispose + flushPendingSaves——幂等收尾（无投影物化面后
+ *    为纯契约保留）。
+ */
+export class JsonlRunStore implements RunStore {
   private readonly sessionDir: string;
   /**
-   * workflow-record entry 的 appendEntry 源。store 对 pi 的唯一消费面是 doFlush 的
-   * appendEntry（W17 权威 entry 写入），类型收窄为该面——[skill-reload D3] rebind
-   * 时换入 stale-guarded 包装（见 {@link rebind}），构造时为裸 pi 原引用。
+   * v2 终态条目补写的 appendEntry 源（loadAll 收编面）。类型收窄为该面——
+   * [skill-reload D3] rebind 时换入 stale-guarded 包装，构造时为裸 pi 原引用。
    */
   private pi?: Pick<ExtensionAPI, "appendEntry">;
   private ctx?: ExtensionContext;
-  private readonly saveDebounceMs: number;
-  /** workflow-record entry append 节流最小间隔（ms），0 = 禁用。 */
-  private readonly entryAppendMinIntervalMs: number;
-  /** per-runId 去抖批（热路径）。 */
-  private readonly pending = new Map<string, PendingSaveBatch>();
-  /** 本实例已至少成功发起过一次 flush 的 runId（冷/热路径判据）。 */
-  private readonly writtenOnce = new Set<string>();
-  /**
-   * per-runId 上次 workflow-record entry append 时刻（节流判据，时间源 Date.now()——
-   * fake timers 下可推进）。终态 append 后删（终态后 runId 不再 save）；残留条目
-   * 只出现在 running 中 run 消失场景，单条可忽略（对齐 core FileRunStore.lastSavedAt
-   * 的取舍先例）。
-   */
-  private readonly lastEntryAppendAt = new Map<string, number>();
-  /**
-   * per-runId 串行 flush 链。同 runId 的 flush 排队顺序执行（排队不跳过——
-   * 跳过会丢最新状态且打破后写覆盖前写的单调性），不同 runId 互不阻塞。
-   * 链条目 settle 后不清理：runId 数量有界、生命周期短于 store，惰性清理
-   * 与排队写入存在竞态——取舍为每 runId 残留一个 settled Promise 引用，可忽略。
-   */
-  private readonly chains = new Map<string, Promise<void>>();
   private disposed = false;
   private disposePromise: Promise<void> | undefined;
 
@@ -330,285 +546,241 @@ export class JsonlRunStore {
     this.sessionDir = opts.sessionDir;
     this.pi = opts.pi;
     this.ctx = opts.ctx;
-    this.saveDebounceMs = opts.saveDebounceMs ?? DEFAULT_SAVE_DEBOUNCE_MS;
-    this.entryAppendMinIntervalMs = Math.max(
-      0,
-      opts.entryAppendMinIntervalMs ?? DEFAULT_SAVE_MIN_INTERVAL_MS,
-    );
   }
 
-  /** State directory: <sessionDir>/workflow-state/ */
+  /** State directory: <sessionDir>/workflow-state/（目录分量经 core barrel STATE_DIR_NAME 单源） */
   private get stateDir(): string {
-    return path.join(this.sessionDir, "workflow-state");
+    return path.join(this.sessionDir, STATE_DIR_NAME);
   }
 
-  /** State file path for a given runId. */
-  private filePathFor(runId: string): string {
-    return path.join(this.stateDir, `${runId}.jsonl`);
+  /** record 流路径 for a given runId（唯一持久件）。 */
+  private recordPathFor(runId: string): string {
+    return path.join(this.stateDir, `${runId}${RUN_EVENT_JOURNAL_SUFFIX}`);
   }
 
-  /** Public accessor: run 状态快照文件绝对路径（RunStore port 实现）。 */
+  /**
+   * Public accessor: run 唯一持久件（record 事件流）的绝对路径（RunStore port
+   * 实现）。[D1] 快照文件删除后，该指针语义从「state 快照」收敛为 record 流
+   * 路径（消费方 = 壳侧 interface 的 stateFile 展示字段）。
+   */
   stateFilePath(runId: string): string {
-    return this.filePathFor(runId);
+    return this.recordPathFor(runId);
   }
 
   /**
-   * Persist a single run: rewrite mode (overwrite) — file always contains the
-   * latest complete snapshot on a single line.
-   *
-   * 去抖路由：
-   * - 冷路径（本实例首写，或 status !== "running"）→ 立即挂链 flush（绕过 timer），
-   *   回滚资格 = 首写（flush 失败时 doFlush 回滚 writtenOnce，下次 save 重走冷路径）；
-   * - 热路径（running 且已写过）→ 并入 per-runId 去抖批（固定窗口不重置 timer）。
-   *
-   * Promise 语义：本批实际落盘后 resolve（同批多次调用共享 settle）；IO 错误
-   * （非 ENOENT）reject 本批全部调用方；ENOENT 静默 resolve（工作目录已被清理，
-   * 持久化无意义也无法完成——见 doFlush）。
+   * [D1] 显式 no-op：record 单源后 run 域状态变化的持久化 = 事件追加（core
+   * worker-message-pump 单写者链落 record 流），壳侧无投影可写。方法保留 =
+   * RunStore port 契约（core runWorkflow/recoverCrashedRuns 调用点不改）；恒
+   * resolve，零 IO。disposed 前后行为一致（no-op 本身就是收尾安全形态）。
    */
   async save(run: WorkflowRun): Promise<void> {
-    // R5 处置：dispose 后（session_shutdown 收尾后 in-flight 链的迟到 save）静默
-    // no-op + debug 留痕。不复活同步 flush——单向闸门状态机简单；此时 run 是
-    // running 落盘无增益（kill-9 恢复同样转 done,failed），终态 reason 保真损失极窄。
-    if (this.disposed) {
-      logger.debug(
-        `[subagent-workflow] jsonl-run-store save after dispose: silently dropped (runId=${run.runId})`,
-      );
-      return;
-    }
-
-    const runId = run.runId;
-    const isFirstWrite = !this.writtenOnce.has(runId);
-    const isCold = isFirstWrite || run.state.status !== "running";
-    if (isCold) {
-      // 判定即记录：原子防并发双冷（两次并发首写都判 true 会各 flush 一次 entry）。
-      // ENOENT 边界：首写 flush 遇 ENOENT 时 entry 未写但 writtenOnce 已记——
-      // sessionDir 已删场景持久化无意义，接受（非 ENOENT 失败由 doFlush 回滚，重走冷路径）。
-      this.writtenOnce.add(runId);
-      // 原子取走 pending 批（终态与最后一个 agent-call 的 debounced save 交错时，
-      // pending 批 settlers 并入本次同步 flush 的批合并 settle，timer 取消防二次写）。
-      const batch = this.pending.get(runId);
-      if (batch) {
-        clearTimeout(batch.timer);
-        this.pending.delete(runId);
-      }
-      return this.enqueueFlush(runId, run, batch ? batch.settlers : [], isFirstWrite);
-    }
-
-    // 热路径：running 中间态，并入去抖批
-    const existing = this.pending.get(runId);
-    if (existing) {
-      // latestRun 更新（固定窗口不重置 timer——flush 延迟有界 ≤saveDebounceMs）
-      existing.latestRun = run;
-      return new Promise<void>((resolve, reject) => {
-        existing.settlers.push({ resolve, reject });
-      });
-    }
-    const settlers: PendingSaveBatch["settlers"] = [];
-    const promise = new Promise<void>((resolve, reject) => {
-      settlers.push({ resolve, reject });
-    });
-    this.pending.set(runId, this.armPendingBatch(runId, run, settlers));
-    return promise;
+    logger.debug(
+      `[subagent-workflow] record store save: no-op (record stream is the sole persistence, runId=${run.runId})`,
+    );
   }
 
   /**
-   * 构造去抖批（[review 修复] 工厂内联组装：timer 与批对象在同一同步段成型，
-   * PendingSaveBatch.timer 保持非可选——消除「批先构造、timer 后赋值」靠注释维持
-   * 的可选窗口）。timer 回调闭包经局部 batch 变量持批引用做身份守卫（ES3）。
+   * 终局记录查询（record run-settled 帧投影）：生产消费方 = 通知载荷链
+   * （runSettledEffects——载荷源帧直取）。miss = 无终局帧（未终局，或流读失败
+   * 降级——调用方按「不可判定」处置：通知跳过 + error 留痕，不回退兜底）。
+   * 流损坏（RecordStreamCorruptionError）与 IO 错误同走 miss + warn（通知链
+   * 不是恢复面，保守 miss 可诊断；恢复面的拒绝语义在 loadAll）。
    */
-  private armPendingBatch(
-    runId: string,
-    run: WorkflowRun,
-    settlers: PendingSaveBatch["settlers"],
-  ): PendingSaveBatch {
-    // timer 回调闭包经下方 const batch 持批引用做身份守卫——前向引用在运行时安全：
-    // 回调最早 saveDebounceMs 后才执行，届时 batch 已在本同步段尾部初始化完毕。
-    const timer = setTimeout(() => {
-      // ES3 幂等守卫（批身份比较）：回调闭包持自身批引用，与 pending Map 现值做
-      // 身份比较而非仅按键存在性判断。除「批已被冷路径/flushPendingSaves/dispose
-      // 原子取走（clearTimeout 与回调触发在 fake timers 下可能交错）」的交接语义外，
-      // 还防「旧 timer 撞新批」交错：本批被取走后同 runId 的新批已入 Map 时，若只看
-      // 键存在性，旧 timer 会误取走新批提前 flush（缩短新批去抖窗口）。身份不匹配
-      // 直接 return，批由取走方负责 flush。
-      if (this.pending.get(runId) !== batch) return;
-      this.pending.delete(runId);
-      // 孤儿 Promise（无调用方持有）：错误只经 settlers 传播给 save() 调用方，
-      // 此处 catch 防止 unhandled rejection。
-      this.enqueueFlush(runId, batch.latestRun, batch.settlers, false).catch(() => {});
-    }, this.saveDebounceMs);
-    // DS5：timer 必须 unref——不 unref 会钉住空转的 extension 进程不退出。
-    timer.unref();
-    const batch: PendingSaveBatch = { latestRun: run, timer, settlers };
-    return batch;
+  settledRecordOf(runId: string): RunSettlementRecord | undefined {
+    let events: readonly WorkflowRunEvent[];
+    try {
+      events = readRecordStream(this.recordPathFor(runId));
+    } catch (err) {
+      if (!isEnoentError(err)) {
+        logger.warn(
+          `[subagent-workflow] record stream read failed, settlement record unavailable (runId=${runId}): ${toErrorMessage(err)}`,
+        );
+      }
+      return undefined;
+    }
+    const settled = lastRunSettledEvent(events);
+    if (settled === undefined) return undefined;
+    return {
+      outcome: settled.outcome,
+      ...(settled.errorCode !== undefined ? { errorCode: settled.errorCode } : {}),
+      ...(settled.reason !== undefined ? { reason: settled.reason } : {}),
+      settledAt: settled.ts,
+    };
   }
 
   /**
-   * 把一次 flush 排到 runId 的串行链尾。调用方 Promise（本函数返回值）与传入
-   * settlers 由同一次 doFlush 独占 settle 一次。
+   * Reconstruct all runs（[D1] record 流权威重建）。
+   *
+   * **v2 注册条目定界**：注册条目给出本会话的实体集与 record 流路径锚点 →
+   * 逐实体 record 全量读（严格解析）→ fold 重建（终局 ⟸ run-settled 帧；非终局
+   * 保持 running 交恢复链收编）；已终局且终态条目缺失 → 幂等补写（条目投影锚
+   * 的收编半边；经 rebind 后的 appendEntry 面，stale guard 内置）。
+   *
+   * **历史实体分流（D1 历史数据处置）**：注册条目 journalPath 锚点后缀非
+   * record 后缀 = 旧形态实体（旧 journal 锚点）→ 跳过不重建（历史 run 从壳侧
+   * 读取面消失 = 预期行为，不读旧两件套）。
+   *
+   * **拒绝语义**：record 流存在但读失败（损坏/IO 非 ENOENT）→ 抛错穿透（宿主
+   * storeHealthy=false fail-fast，workflow 域停初始化）——静默跳过会把数据损坏
+   * 伪装成「无 run 历史」。流缺失（ENOENT）的新形态实体 = 注册后首帧前崩溃 →
+   * degraded running 聚合交恢复链收编（静默丢弃会让该实体对恢复链不可见）。
+   *
+   * [已知限制·登记]（沿用）恢复域 = 本 session 的 entry 集及其锚点：崩溃后用户
+   * 不再 resume 原 session 时，原 session 的遗留 run 对新 session 的 loadAll/
+   * 恢复链不可见——跨 session 收编需要跨 session 写入语义，与 W17 session 锚定
+   * 设计相悖，登记不改；跨进程维度的收编归 runtime 启动扫描（startupSweep）。
+   *
+   * 需要 ctx（构造时注入）——无 ctx 时返回空（测试或非 Pi 环境下）。
    */
-  private enqueueFlush(
-    runId: string,
-    run: WorkflowRun,
-    settlers: PendingSaveBatch["settlers"],
-    rollbackFirstWrite: boolean,
-  ): Promise<void> {
-    const promise = new Promise<void>((resolve, reject) => {
-      settlers.push({ resolve, reject });
-    });
-    // 排队不跳过：前一 flush in-flight 时本次挂链尾顺序执行，同 runId 永不并发
-    // writeFile（整文件覆盖写并发会互相截断）。链尾吞错防断链——错误只经 settlers 传播。
-    const next = (this.chains.get(runId) ?? Promise.resolve())
-      .then(() => this.doFlush(runId, run, settlers, rollbackFirstWrite))
-      .catch(() => {});
-    this.chains.set(runId, next);
-    return promise;
+  async loadAll(): Promise<WorkflowRun[]> {
+    if (!this.ctx) return [];
+    let entries: SessionEntry[];
+    try {
+      entries = this.ctx.sessionManager.getEntries();
+    } catch (err) {
+      // getEntries failed — 返回空集（降级语义保持），但必须 error 留痕：静默
+      // 空集会把 session 文件读故障伪装成「无 run 历史」，恢复无从下手。
+      logger.error(
+        `[subagent-workflow] loadAll: getEntries failed, returning empty run set (degraded). Recovery: check session file readability: ${toErrorMessage(err)}`,
+      );
+      return [];
+    }
+    // rebuild 的损坏错误（RecordStreamCorruptionError / IO）直接上抛——恢复面
+    // 拒绝语义（宿主 storeHealthy=false），不被 getEntries 的降级 catch 吞掉。
+    const { registered, settledEntries } = collectEntrySources(entries);
+    return this.rebuildRunsFromRecordStreams(registered, settledEntries);
   }
 
+  // ── [D1] record 流权威重建 ────────────────────────────────────
+
   /**
-   * 实际落盘（在 runId 串行链上执行）。settlers 由本函数独占 settle 一次：
-   * 成功或 ENOENT 全 resolve，其他错误全 reject。
+   * 逐注册条目重建 run：record 流全量读（严格解析）→ fold 重建 → 终局判定
+   * （fold 唯一判法）。条目面的唯一参与 = 终态条目幂等补写抑制
+   * （settledEntries）——条目不再作为终局证据（旧「journal 无帧而条目在 → 按条
+   * 目重建」的双面证据分支随 D1 判读单一裁决删除：条目是投影锚，不是第二判据）。
    */
-  private async doFlush(
-    runId: string,
-    run: WorkflowRun,
-    settlers: PendingSaveBatch["settlers"],
-    rollbackFirstWrite: boolean,
-  ): Promise<void> {
-    const filePath = this.filePathFor(runId);
-    try {
-      // 兜底容错：run 工作目录（sessionDir）已被清理时，mkdir 抛 ENOENT，放弃持久化。
-      // 竞态场景（review-fix-loop-e2e 等 runAndWait 测试）：handleReturn 内
-      // run.transition("done") 同步改 status 后，runAndWait 轮询发现 done 并 resolve，
-      // 测试 afterEach 随即 rmSync 删除 sessionDir；此时 in-flight 的 mkdir
-      // 遇到目录链已删除 → ENOENT（{recursive:true} 在并发 rmSync 下仍可抛 ENOENT）。
-      // run 既已终态（状态不再变化），持久化无意义也无法完成 → settle resolve。
-      // 仅容错 ENOENT，其他错误（EACCES/ENOSPC 等真实磁盘问题）reject 不掩盖。
+  private rebuildRunsFromRecordStreams(
+    registered: Map<string, WorkflowRecordRegisteredEntryData>,
+    settledEntries: Map<string, WorkflowRecordSettledEntryData>,
+  ): WorkflowRun[] {
+    const runs: WorkflowRun[] = [];
+    for (const [runId, reg] of registered) {
+      const recordPath = reg.journalPath;
+      if (!recordPath.endsWith(RUN_EVENT_JOURNAL_SUFFIX)) {
+        // 旧形态锚点（旧 journal .events.jsonl）= 历史 run：不读旧两件套
+        //（D1 历史数据处置——历史 run 从壳侧读取面消失，resume 一律拒绝）。
+        logger.debug(
+          `[subagent-workflow] record store: legacy journal anchor skipped, run not rebuilt (runId=${runId}, anchor=${recordPath})`,
+        );
+        continue;
+      }
+      let events: readonly WorkflowRunEvent[];
       try {
-        await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+        events = readRecordStream(recordPath);
       } catch (err) {
         if (isEnoentError(err)) {
-          for (const s of settlers) s.resolve();
-          return;
+          if (settledEntries.has(runId)) {
+            // 流缺失而终态条目在：实体的呈现面归条目读者（runtime 投影 /
+            // session-reader），壳侧不重建——不交恢复链（对不在场的流伪造收编
+            // 事实）。判读单一不受影响：壳侧不产生任何 done 聚合（条目不是判据，
+            // 只是「流已被清理/缺失、无需收编」的存续分流信号）。
+            logger.warn(
+              `[subagent-workflow] record store: record stream missing but settled entry present, run skipped (runId=${runId}, path=${recordPath})`,
+            );
+            continue;
+          }
+          // 新形态实体的 record 流缺失（无终态条目）= 注册后首帧前崩溃：degraded
+          // running 基线交恢复链按中断收编（静默跳过会让该实体对恢复链/扫描全部
+          // 不可见）。
+          logger.warn(
+            `[subagent-workflow] record store: record stream missing, degraded rebuild for interruption adoption (runId=${runId}, path=${recordPath})`,
+          );
+          runs.push(foldRecordStreamToRun(runId, reg, []));
+          continue;
         }
+        // 损坏 / 真实 IO 错误：拒绝（穿透 → 宿主 fail-fast），不静默降级。
         throw err;
       }
-      // serialize-at-flush：写 flush 时刻的最新聚合状态（latestRun 语义）
-      const snapshot = toRunSnapshot(run);
-      await fs.promises.writeFile(filePath, JSON.stringify(snapshot) + "\n", "utf8");
-      // W17 [D4]：成功 flush 同步 append 自描述 workflow-record entry（同一份 snapshot，
-      // entry 与 state 文件内容一致）。pi 文件是 workflow 数据持久化权威（loadAll 优先
-      // 从 entry 重建），state 文件降级纯性能缓存。pi 未注入（测试）时跳过。
-      // [B-1] entry append 节流（语义对齐 core FileRunStore.save OR-5 ⑥a）：running
-      // 中间态距上次 append 不足间隔 → 跳过（pi session JSONL append-only，节流前
-      // 每次 flush 全量 append 累积单 run O(n²) 磁盘）；终态永不节流（最终状态必进
-      // pi 权威文件）；间隔 0 禁用。判据在 append 成功后更新——本调用点位于 writeFile
-      // 成功之后，writeFile 抛错时判据不更新，不吞下一次重试机会。
-      const isTerminal = run.state.status !== "running";
-      const now = Date.now();
-      const lastAppendAt = this.lastEntryAppendAt.get(runId);
-      if (
-        this.entryAppendMinIntervalMs <= 0 ||
-        isTerminal ||
-        lastAppendAt === undefined ||
-        now - lastAppendAt >= this.entryAppendMinIntervalMs
-      ) {
-        this.pi?.appendEntry(
-          WORKFLOW_RECORD_CUSTOM_TYPE,
-          toWorkflowRecordEntryData(snapshot),
+      const settledEvent = lastRunSettledEvent(events);
+      if (settledEvent === undefined && settledEntries.has(runId)) {
+        // 条目已判终局而 record 流无终局帧（空流/残流）：与流缺失同款存续分流——
+        // 实体呈现面归条目读者，壳侧不重建不交恢复链。warn 留证条目与流的分叉
+        //（流被外部清空/篡改的信号面；恢复面的拒绝语义只在坏行，空流不拒）。
+        logger.warn(
+          `[subagent-workflow] record store: settled entry present but record stream has no run-settled frame, run skipped (runId=${runId})`,
         );
-        if (isTerminal) {
-          this.lastEntryAppendAt.delete(runId);
-        } else {
-          this.lastEntryAppendAt.set(runId, now);
-        }
-      }
-      // OR-5 ⑥b 磁盘保留清理（默认开）：新 run state 文件首写成功后触发（rollbackFirstWrite
-      // 即 save() 冷路径传入的 isFirstWrite——「本实例首次写该 runId」≈ 新文件落盘时刻，
-      // 每个 run 只清一次，热路径 flush 不重复扫描目录）。prune 内部吞错不抛，
-      // 在串行链上 await：save 返回即清理已定，测试可同步断言目录终态。
-      if (rollbackFirstWrite) {
-        const maxRuns = getEnvStateMaxRuns();
-        if (maxRuns !== undefined) {
-          // 单源裁剪（core pruneStateFilesBeyondCap），注入本扩展 logger tag 与
-          // toErrorMessage（行为与本地实现收口前一致）
-          await pruneStateFilesBeyondCap(this.stateDir, maxRuns, {
-            warn: (msg) => logger.warn(`[subagent-workflow] ${msg}`),
-            debug: (msg) => logger.debug(`[subagent-workflow] ${msg}`),
-            toMsg: toErrorMessage,
-          });
-        }
+        continue;
       }
-      for (const s of settlers) s.resolve();
-    } catch (err) {
-      // ES9 失败回滚（热路径 flush 也会写 entry，回滚的意义收敛为「下次 save 重走
-      // 冷路径立即重试」——不再有旧指针形态下「热路径永不写 entry → run 对重启
-      // 不可见」的窗口）。堵住首写失败后还得等去抖窗的恢复延迟。
-      // 残余窗口（已知接受）：回滚后若再无任何 save（随即崩溃/退出），entry 与
-      // state 文件双双缺失——等价崩溃丢失，由 kill-9 恢复兜底。
-      if (rollbackFirstWrite) {
-        this.writtenOnce.delete(runId);
+      const run = foldRecordStreamToRun(runId, reg, events);
+      runs.push(run);
+      // 终态条目幂等补写：record 已终局而主 session 终态条目缺失（终局 coda 的
+      // 条目半边写失败 / 旧版本写点形态）→ 补写；条目已在 → 跳过（双重启不重复
+      // 追加的构造性保证）。无 pi（测试/非 Pi 环境）跳过。
+      if (settledEvent !== undefined && !settledEntries.has(runId)) {
+        this.appendSettledEntryFallback(runId, settledEvent, events);
       }
-      for (const s of settlers) s.reject(err);
     }
+    return runs;
   }
 
   /**
-   * 立即刷全部 pending 去抖批（测试与排查的备用手段）。自身恒 resolve——IO 错误
-   * 已由各 save() Promise 的 settlers 传播给调用方。store 保持可用：不动 disposed
-   * 标志，后续 save 正常进入新去抖批。
+   * 终态条目幂等补写（v2 收编面）：载荷经 core barrel 的
+   * buildWorkflowRecordSettledEntryData 构造器单源复用（防字段集手抄漂移——壳写
+   * 点与 core finalizeRun 写点同一构造；字段源 = record run-settled 帧 + ask
+   * 计数投影）。best-effort：appendEntry 失败留痕不阻断 loadAll（条目是投影锚，
+   * 下次 loadAll 幂等重试）。
    */
-  async flushPendingSaves(): Promise<void> {
-    const flushes: Promise<void>[] = [];
-    for (const [runId, batch] of Array.from(this.pending.entries())) {
-      clearTimeout(batch.timer);
-      this.pending.delete(runId);
-      flushes.push(this.enqueueFlush(runId, batch.latestRun, batch.settlers, false));
+  private appendSettledEntryFallback(
+    runId: string,
+    settledEvent: RunSettledFrame,
+    events: readonly WorkflowRunEvent[],
+  ): void {
+    if (!this.pi) return;
+    const data = buildWorkflowRecordSettledEntryData({
+      runId,
+      reason: runSettledOutcomeToDoneReason(settledEvent.outcome, settledEvent.errorCode),
+      outcome: settledEvent.outcome,
+      ...(settledEvent.errorCode !== undefined ? { errorCode: settledEvent.errorCode } : {}),
+      settledAt: settledEvent.ts,
+      callCount: events.filter((e) => e.type === "agent-settled").length,
+      usedTokens: 0,
+    });
+    try {
+      this.pi.appendEntry(WORKFLOW_RECORD_CUSTOM_TYPE, data);
+    } catch (err) {
+      logger.warn(
+        `[subagent-workflow] v2 settled entry backfill failed (runId=${runId}): ${toErrorMessage(err)}`,
+      );
     }
-    await Promise.allSettled(flushes);
   }
 
+  // ── 生命周期面（无投影物化面后的契约保留）────────────────────
+
+  /**
+   * [D1] 无 pending 批（无投影物化面）——立即返回。方法保留 = 生命周期面契约
+   *（dispose / 排查调用点不改）。
+   */
+  async flushPendingSaves(): Promise<void> {}
+
   /**
-   * 收尾：刷全部 pending 批 + 停 timer + await 全部 in-flight 链（in-flight flush
-   * 完成后才返回），此后 save 静默 no-op。
+   * 收尾：幂等（缓存自身 Promise——首次未完成时并发交叠进入的后续调用返回同一
+   * Promise）。[D1] 无物化面可冲刷（无批/timer/watcher），置位 disposed 后返回。
    *
-   * 幂等：dispose 缓存自身 Promise——首次未完成时并发交叠进入的后续调用返回
-   * 同一 Promise（「dispose 返回 = 全部 flush 已落盘」对每个调用方都成立，
-   * 无第二次拿到立即 resolve 的空 Promise 瑕疵）。故本方法不能是 async 函数
-   * （async 总是创建新 Promise 破坏同一引用保证）。
+   * 本方法不能是 async 函数（async 总是创建新 Promise 破坏同一引用保证）。
    */
   dispose(): Promise<void> {
     if (this.disposePromise) return this.disposePromise;
-    this.disposePromise = this.doDispose();
-    return this.disposePromise;
-  }
-
-  private async doDispose(): Promise<void> {
-    // 同步置位：阻断新 save 进入去抖/冷路径（R5 no-op 分支接住 shutdown 后
-    // in-flight 链的迟到 save）。置位必须先于 flushPendingSaves——async 函数体
-    // 在调用时同步执行到第一个 await，批收集发生在置位后的同一同步段，时序与
-    // 折叠前的内联收集逐分支等值。
     this.disposed = true;
-    // 复用 flushPendingSaves（批收集循环与 await allSettled 与折叠前内联实现逐行等价；
-    // flushPendingSaves 自身不动 disposed——dispose 语义仍由本方法的置位与缓存 Promise 承担）
-    await this.flushPendingSaves();
-    // await 全部 in-flight 链（ES4：flush 全部落定后才返回）
-    await Promise.allSettled(Array.from(this.chains.values()));
+    this.disposePromise = Promise.resolve();
+    return this.disposePromise;
   }
 
   /**
-   * [skill-reload D3] adoption 就地重绑：post-reload session_start 接管（adoption）时
-   * 原地改写 entry 写入源与 ctx——store 实例跨 reload 存活（D2 槽），在飞去抖批与
-   * per-runId 串行 flush 链持有 this，原地改写对后续 flush 天然可见（不遍历对象图
-   * 重绑：闭包引用不可枚举，漏一处 = 恢复后随机 assertActive 抛——设计被否项）。
-   * writtenOnce / lastEntryAppendAt / pending / chains 全部保留（接管而非重建）。
-   *
-   * [skill-reload D5] 换入的 appendEntry 源包 guardStaleCtx：下一次 reload 窗口
-   * （invalidate → adoption rebind 完成之间，通常 <1s）in-flight flush 触碰已 stale
-   * 的本 pi 时统一 debug 丢弃（不分中间态/终态——appendEntry 是同步 void，stale
-   * 表现为同步 assertActive 抛错，不包会把窗口内 flush 打成 IO 错误路径：settlers
-   * reject + writtenOnce 回滚）。终态保全不依赖窗口内写入，由 adoption 快照重发
-   * （{@link resendSnapshots}）承担：窗口内终态的 run 在 adoption 时刻内存对象已
-   * 是终态，快照重发追加的就是终态 entry。
+   * [skill-reload D3] adoption 就地重绑：post-reload session_start 接管（adoption）
+   * 时原地改写 appendEntry 源与 ctx——store 实例跨 reload 存活（D2 槽）。
+   * [W1] 换入的 appendEntry 源的消费方 = loadAll 的 v2 终态条目幂等补写（收编/
+   * 调和面）；stale guard 语义不变（窗口内 appendEntry 统一 debug 丢弃——条目是
+   * 投影锚，缺失由下次 loadAll 幂等补写自愈）。
    */
   rebind(pi: ExtensionAPI, ctx: ExtensionContext): void {
     this.pi = {
@@ -626,64 +798,4 @@ export class JsonlRunStore {
     };
     this.ctx = ctx;
   }
-
-  /**
-   * [skill-reload D4] adoption 快照重发：把 runs 内全部 run 的当前快照经 per-runId
-   * 串行 flush 链（enqueueFlush → doFlush）重发一条权威 workflow-record entry。
-   *
-   * 设计红线：必须经本链而非裸 pi.appendEntry——doFlush 的 await writeFile 与
-   * appendEntry 之间存在事件循环间隙（W17 补充事实），绕链直接 append 会与
-   * in-flight 中间态 flush 物理乱序（终态在前中间态在后，last-ways 读回 running →
-   * 崩溃恢复误判）；走串行链后同 runId 的 entry 顺序由链内闭合保证。
-   *
-   * 节流语义自然继承 doFlush：终态 flush 永不节流（最终状态必进 pi 权威文件）；
-   * running 中间态受既有 entryAppendMinIntervalMs（缺省 60s）节流约束可跳过——
-   * 与常规 flush 同源（pi 文件最后一条 entry 最多落后真实状态一个窗口）。测试
-   * 断言因此按终态/首写路径构造，不依赖中间态重发必落。
-   *
-   * rollbackFirstWrite=false：重发不是新文件首写（不触发磁盘保留裁剪）；失败不
-   * 回滚 writtenOnce——重发失败向上抛，由 adoption 失败处置整体兜底（G3 可见）。
-   */
-  async resendSnapshots(runs: Map<string, WorkflowRun>): Promise<void> {
-    for (const run of runs.values()) {
-      // 串行 await：adoption 是一次性路径，跨 runId 顺序无语义，但全部重发完成
-      //（或首个失败上抛）后才返回，调用方据此判定接管完成。
-      await this.enqueueFlush(run.runId, run, [], false);
-    }
-  }
-
- /**
- * Reconstruct all runs（W17 [D4] 读序 = workflow-record entry > state 文件 > 空）。
- *
- * 1. 优先扫描自描述 `workflow-record` entry（重建源——同一 runId 多条时最后一条
- *    胜出，等价「最后一次成功 flush」）。entry 层 v1 guard：不认识的版本跳过而非
- *    猜测；snapshot 层 D-5 snapshotVersion guard 保持（版本不匹配 → fromRunSnapshot
- *    返回 undefined → 跳过，不做兼容迁移）。
- * 2. 旧 `workflow-state-link` 指针 entry 兼容读取（优先级低——存量 run 不静默
- *    丢失，父文档 #9 踩坑）：entry 未覆盖的 runId 经指针读 state 文件最后行。
- *
- * 需要 ctx（构造时注入）——无 ctx 时返回空（测试或非 Pi 环境下）。
- */
-  async loadAll(): Promise<WorkflowRun[]> {
-    if (!this.ctx) return [];
-    const runs: WorkflowRun[] = [];
-    try {
-      const entries = this.ctx.sessionManager.getEntries();
-      const { recordRuns, pointers } = collectEntrySources(entries);
-
-      // 1) 自描述 entry 重建（优先——pi 文件是持久化权威）
-      runs.push(...recordRuns.values());
-
-      // 2) 旧 link 指针 → state 文件兼容（entry 已覆盖的 runId 跳过——link 优先级低）
-      for (const [runId, pointer] of pointers) {
-        if (recordRuns.has(runId)) continue;
-        const run = await loadRunFromStateFile(pointer.path);
-        if (run) runs.push(run);
-      }
-    } catch (err) {
- // getEntries failed — return what we have (empty).
-      void err;
-    }
-    return runs;
-  }
 }