@zhushanwen/pi-subagent-workflow 9.2.1 → 9.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhushanwen/pi-subagent-workflow",
-  "version": "9.2.1",
+  "version": "9.3.0",
   "type": "module",
   "main": "index.ts",
   "description": "Unified subagent execution and multi-agent workflow orchestration for Pi — spawned-process agent runtime with sync/background modes, stateful workflow management with persistence, state machine, and execution tracing.",
@@ -58,22 +58,22 @@
     ]
   },
   "dependencies": {
-    "@zhushanwen/extension-protocol": "0.17.0",
-    "@zhushanwen/session-delivery": "1.0.0",
-    "@zhushanwen/pi-ext-guards": "0.4.2",
-    "@zhushanwen/pi-extension-logger": "0.6.1",
-    "@zhushanwen/pi-notify-ledger-host": "0.2.4",
-    "@zhushanwen/subagent-core": "1.2.1",
-    "@zhushanwen/pi-subagent-cli": "0.5.0",
-    "@zhushanwen/zcode-subagent-cli": "0.4.4"
+    "@zhushanwen/extension-protocol": "0.18.0",
+    "@zhushanwen/session-delivery": "1.1.0",
+    "@zhushanwen/pi-ext-guards": "0.4.3",
+    "@zhushanwen/pi-extension-logger": "0.6.2",
+    "@zhushanwen/pi-notify-ledger-host": "0.3.0",
+    "@zhushanwen/subagent-core": "1.3.0",
+    "@zhushanwen/pi-subagent-cli": "0.6.0",
+    "@zhushanwen/zcode-subagent-cli": "0.5.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": "^0.84.4",
-    "@earendil-works/pi-coding-agent": "^0.84.4",
-    "@earendil-works/pi-tui": "^0.84.4",
-    "typebox": "*",
-    "@zhushanwen/pi-pending-notifications": "0.8.1",
-    "@zhushanwen/pi-structured-output": "6.0.0"
+    "@earendil-works/pi-ai": "^1.0.0",
+    "@earendil-works/pi-coding-agent": "^1.0.0",
+    "@earendil-works/pi-tui": "^1.0.0",
+    "typebox": "1.3.27",
+    "@zhushanwen/pi-pending-notifications": "0.8.2",
+    "@zhushanwen/pi-structured-output": "6.1.0"
   },
   "peerDependenciesMeta": {
     "@earendil-works/pi-coding-agent": {
@@ -87,7 +87,7 @@
     "@types/node": "^24.0.0",
     "@vitest/coverage-v8": "^4.1.9",
     "vitest": "^4.1.8",
-    "@zhushanwen/subagent-engine-sdk": "0.8.0"
+    "@zhushanwen/subagent-engine-sdk": "0.9.0"
   },
   "scripts": {
     "typecheck": "npx tsc --noEmit",

package/src/host/__tests__/inflight-reporter.test.ts

@@ -3,10 +3,11 @@
 // 三视角：
 //   ①使用者（runtime event-adapter 视角）——帧形状：title=SUBAGENT_INFLIGHT_MARKER、
 //     options=[JSON 帧]（inFlight/sessionId/emittedAt）、控制面级 timeout 在场；
-//   ②构建者——初始上报（attachSession 触发，无需任何 subagent 调用）→ ack 清失败
-//     计数；失败折叠 + 延迟重试；推送在途期间多次迁移合并为单帧且携带最新绝对计数；
+//   ②构建者——初始上报（attachSession 触发，无需任何 subagent 调用）；失败折叠 +
+//     置脏（无 timer 自动重试，ADR-0122）；推送在途期间多次迁移合并为单帧且携带
+//     最新绝对计数；
 //   ③观察者——onInFlightChanged 同步返回（不 await select，不进生命周期链）；
-//     detachSession 停重试，session 死后通道静默。
+//     detachSession 后通道静默，session 死后不推帧。
 //
 // [HISTORICAL] 行为于 9f914b749 变更：kind='initial'|'delta' 帧字段与 initialAcked
 // 状态机作为死面删除（消费方 event-adapter 从不读 kind，绝对计数语义下帧间等价；
@@ -35,7 +36,6 @@ import { INFLIGHT_REPORT_ACK, SUBAGENT_INFLIGHT_MARKER } from "@zhushanwen/exten
 
 import { createInFlightReporter } from "../inflight-reporter.ts";
 
-const RETRY_MS = 50;
 const SELECT_TIMEOUT_MS = 1_000;
 
 type SelectCall = { title: string; payload: string; timeout: number | undefined };
@@ -93,7 +93,7 @@ async function advance(ms: number): Promise<void> {
 describe("初始上报（D5：触发时点 = extension 加载完成 / session 就绪）", () => {
   it("attachSession 即发初始帧（count=当下快照，无需任何 subagent 调用）", async () => {
     const channel = makeSelectChannel();
-    const reporter = createInFlightReporter({ retryDelayMs: RETRY_MS, selectTimeoutMs: SELECT_TIMEOUT_MS });
+    const reporter = createInFlightReporter({ selectTimeoutMs: SELECT_TIMEOUT_MS });
 
     reporter.attachSession(makeCtx(channel));
     await advance(0);
@@ -113,7 +113,7 @@ describe("初始上报（D5：触发时点 = extension 加载完成 / session
 
   it("初始未送达前发生的迁移不产生第二帧（合并为单帧，ack 后补推最新快照）", async () => {
     const channel = makeSelectChannel();
-    const reporter = createInFlightReporter({ retryDelayMs: RETRY_MS });
+    const reporter = createInFlightReporter();
     reporter.attachSession(makeCtx(channel));
     await advance(0);
 
@@ -135,7 +135,7 @@ describe("初始上报（D5：触发时点 = extension 加载完成 / session
 describe("绝对计数语义（每帧携带当下值，非增量）", () => {
   it("连续迁移各帧均为整值快照（2 → 0，不做加减）", async () => {
     const channel = makeSelectChannel();
-    const reporter = createInFlightReporter({ retryDelayMs: RETRY_MS });
+    const reporter = createInFlightReporter();
     reporter.attachSession(makeCtx(channel));
     await advance(0);
     channel.settleAll(INFLIGHT_REPORT_ACK);
@@ -158,27 +158,32 @@ describe("绝对计数语义（每帧携带当下值，非增量）", () => {
   });
 });
 
-describe("失败折叠 + 延迟重试（有界：累计 MAX_REPORT_ATTEMPTS 次放弃，D5 缺席语义②）", () => {
-  it("select resolve undefined（超时/旧版 runtime）→ 折叠重试；重试帧携带完整快照；ack 后停", async () => {
+describe("失败折叠（ADR-0122：无 timer 自动重试，事件驱动重推）", () => {
+  it("select resolve undefined（超时/旧版 runtime）→ 置脏不重试；下次迁移事件重推最新快照", async () => {
     const channel = makeSelectChannel();
-    const reporter = createInFlightReporter({ retryDelayMs: RETRY_MS, selectTimeoutMs: SELECT_TIMEOUT_MS });
+    const reporter = createInFlightReporter({ selectTimeoutMs: SELECT_TIMEOUT_MS });
     reporter.attachSession(makeCtx(channel));
     await advance(0);
     expect(channel.calls).toHaveLength(1);
 
-    // 首帧无人 ack，select 以 undefined 落定（超时形态）→ 折叠
+    // 首帧无人 ack，select 以 undefined 落定（超时形态）→ 折叠置脏
     channel.settle(0, undefined);
-    await advance(RETRY_MS - 1);
-    expect(channel.calls).toHaveLength(1); // 未到退避点不重试
-    await advance(1);
+    await advance(0);
+    // 推进远超原重试周期的时间：无 timer 自动重试（ADR-0122），零新帧
+    await advance(60_000);
+    expect(channel.calls).toHaveLength(1);
+
+    // 下一次 in-flight 变化事件驱动重推（携带最新绝对计数快照）
+    reporter.onInFlightChanged();
+    await advance(0);
     expect(channel.calls).toHaveLength(2);
     const retryFrame = parseFrame(channel.calls[1]);
-    expect(retryFrame.kind).toBeUndefined(); // kind 已删（9f914b749）：重试帧与普通帧等价
-    expect(retryFrame.inFlight).toBe(0); // 重试帧携带完整绝对计数快照
+    expect(retryFrame.kind).toBeUndefined(); // kind 已删（9f914b749）：重推帧与普通帧等价
+    expect(retryFrame.inFlight).toBe(0); // 重推帧携带完整绝对计数快照
 
-    // 重试帧得到 ack → 重试停止；随后迁移照常送达
+    // 重推帧得到 ack → 通道恢复；随后迁移照常送达
     channel.settle(1, INFLIGHT_REPORT_ACK);
-    await advance(RETRY_MS * 10);
+    await advance(60_000);
     expect(channel.calls).toHaveLength(2);
 
     reporter.onInFlightChanged();
@@ -188,81 +193,64 @@ describe("失败折叠 + 延迟重试（有界：累计 MAX_REPORT_ATTEMPTS 次
     channel.settleAll(INFLIGHT_REPORT_ACK);
   });
 
-  it("select 通道抛错同样折叠进重试路径", async () => {
+  it("select 通道抛错同样折叠置脏，由迁移事件重推", async () => {
     const channel = makeSelectChannel();
-    const reporter = createInFlightReporter({ retryDelayMs: RETRY_MS });
+    const reporter = createInFlightReporter();
     reporter.attachSession(makeCtx(channel));
     await advance(0);
     channel.settle(0, new Error("channel blew up"));
-    await advance(RETRY_MS);
-    expect(channel.calls.length).toBeGreaterThanOrEqual(2);
-    channel.settleAll(INFLIGHT_REPORT_ACK);
     await advance(0);
-  });
-
-  it("非确认回包（旧版 runtime 的任意字符串）不算送达，继续重试", async () => {
-    const channel = makeSelectChannel();
-    const reporter = createInFlightReporter({ retryDelayMs: RETRY_MS });
-    reporter.attachSession(makeCtx(channel));
+    await advance(60_000); // 无 timer 重试
+    expect(channel.calls).toHaveLength(1);
+    reporter.onInFlightChanged();
     await advance(0);
-    channel.settle(0, '{"ok":1}');
-    await advance(RETRY_MS);
     expect(channel.calls).toHaveLength(2);
     channel.settleAll(INFLIGHT_REPORT_ACK);
     await advance(0);
   });
 
-  it("累计失败达默认上限（3 次）即放弃：不再重试，后续迁移也不再发帧", async () => {
+  it("非确认回包（旧版 runtime 的任意字符串）不算送达，置脏等事件重推", async () => {
     const channel = makeSelectChannel();
-    // 未注入 maxAttempts：锁默认上限 MAX_REPORT_ATTEMPTS = 3（增强面降级语义）。
-    const reporter = createInFlightReporter({ retryDelayMs: RETRY_MS, selectTimeoutMs: SELECT_TIMEOUT_MS });
+    const reporter = createInFlightReporter();
     reporter.attachSession(makeCtx(channel));
     await advance(0);
+    channel.settle(0, '{"ok":1}');
+    await advance(0);
+    await advance(60_000); // 无 timer 重试
     expect(channel.calls).toHaveLength(1);
-
-    // 三帧全部失败落定：首帧 + 2 次退避重试；第 3 次失败触顶
-    channel.settle(0, undefined);
-    await advance(RETRY_MS);
-    expect(channel.calls).toHaveLength(2);
-    channel.settle(1, undefined);
-    await advance(RETRY_MS);
-    expect(channel.calls).toHaveLength(3);
-    channel.settle(2, undefined);
-
-    // 达到上限：放弃为 session 内终态——时间推进与后续迁移都不再发帧
-    await advance(RETRY_MS * 10);
-    expect(channel.calls).toHaveLength(3);
     reporter.onInFlightChanged();
-    await advance(RETRY_MS * 10);
-    expect(channel.calls).toHaveLength(3);
+    await advance(0);
+    expect(channel.calls).toHaveLength(2);
+    channel.settleAll(INFLIGHT_REPORT_ACK);
+    await advance(0);
   });
 });
 
 describe("不阻塞生命周期主链（D5 接线约束①）", () => {
   it("onInFlightChanged 同步返回：select 永不落定也不挂调用方（detach 可丢弃在途帧）", async () => {
     const channel = makeSelectChannel();
-    const reporter = createInFlightReporter({ retryDelayMs: RETRY_MS });
+    const reporter = createInFlightReporter();
     reporter.attachSession(makeCtx(channel));
     await advance(0);
 
     // 第一帧挂起（模拟 runtime 无响应）——迁移调用仍同步返回
     expect(() => reporter.onInFlightChanged()).not.toThrow();
 
-    // session 死后 detach：挂起帧被丢弃，重试链静止（时间推进零新调用）
+    // session 死后 detach：挂起帧被丢弃，通道静止（时间推进零新调用）
     reporter.detachSession();
     channel.settleAll(undefined);
-    await advance(RETRY_MS * 5);
+    await advance(60_000);
     expect(channel.calls).toHaveLength(1);
   });
 
-  it("detachSession 清掉待发重试定时器（session 已死，重试语义随之终结）", async () => {
+  it("detachSession 后失败落定不再发帧（ctx 已空，置脏无效果）", async () => {
     const channel = makeSelectChannel();
-    const reporter = createInFlightReporter({ retryDelayMs: RETRY_MS });
+    const reporter = createInFlightReporter();
     reporter.attachSession(makeCtx(channel));
     await advance(0);
     reporter.detachSession();
-    channel.settleAll(undefined); // 在途帧失败落定——ctx 已空，不排新重试
-    await advance(RETRY_MS * 10);
+    channel.settleAll(undefined); // 在途帧失败落定——ctx 已空，不排重推
+    await advance(60_000);
     expect(channel.calls).toHaveLength(1);
   });
 });

package/src/host/__tests__/journal-reporter.test.ts

@@ -0,0 +1,230 @@
+// journal-reporter.test.ts —— 壳层 journal 事件推送出口（event-push-channel W-P1）。
+//
+// 三视角：
+//   ①使用者（runtime event-adapter 视角）——帧形状：title=SUBAGENT_JOURNAL_MARKER、
+//     options=[JSON 报告]（domain/fileKey/events/sessionId/emittedAt）、控制面级
+//     timeout 在场；
+//   ②构建者——单帧单文件（fileKey 单数）；一次推送尝试在途时新事件并入待推缓冲，
+//     成功后逐组继续；失败（无 ack）→ 待推缓冲整体丢弃不重推（设计 D5，与 inflight
+//     的 dirty 重推刻意分叉——消费方有 seq 水位可判缺口）；
+//   ③观察者——onJournalAppended 同步返回（不 await select，不进落盘主链）；
+//     非 rpc 模式 no-op（不设 ctx，全程零帧）；detach 后通道静默。
+//
+// 与 inflight-reporter 的差异锚：无初始帧（报告语义是增量事件，空 session 无事件
+// 可报，缺席语义归消费方冷读——设计 §3.3）。
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+// ── hoisted mocks（依赖收窄：logger 防文件落盘） ──
+
+const extensionLoggerMock = vi.hoisted(() => ({
+  getLogger: vi.fn(() => ({
+    debug: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  })),
+}));
+
+vi.mock("@zhushanwen/pi-extension-logger", () => extensionLoggerMock);
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { JOURNAL_REPORT_ACK, SUBAGENT_JOURNAL_MARKER } from "@zhushanwen/extension-protocol";
+
+import { createJournalReporter } from "../journal-reporter.ts";
+
+const SELECT_TIMEOUT_MS = 1_000;
+
+type SelectCall = { title: string; payload: string; timeout: number | undefined };
+
+/** 可控 select 通道：每次调用的应答由用例逐帧裁决（ack / undefined / 抛错 / 挂起）。 */
+function makeSelectChannel() {
+  const calls: SelectCall[] = [];
+  const pending: Array<(v: unknown) => void> = [];
+  const select = vi.fn(
+    (title: string, options: string[], opts?: { timeout?: number }): Promise<unknown> => {
+      calls.push({ title, payload: options[0] ?? "", timeout: opts?.timeout });
+      return new Promise((resolve) => pending.push(resolve));
+    },
+  );
+  return {
+    select,
+    calls,
+    /** resolve 第 N 帧（0 起）。 */
+    settle(index: number, value: unknown): void {
+      pending[index]?.(value);
+    },
+    settleAll(value: unknown): void {
+      while (pending.length > 0) pending.shift()?.(value);
+    },
+  };
+}
+
+function makeCtx(channel: ReturnType<typeof makeSelectChannel>, sessionId = "sess-journal"): ExtensionContext {
+  return {
+    cwd: "/w",
+    mode: "rpc",
+    sessionManager: { getSessionId: () => sessionId },
+    ui: { select: channel.select },
+  } as unknown as ExtensionContext;
+
+}
+
+function makeNonRpcCtx(channel: ReturnType<typeof makeSelectChannel>): ExtensionContext {
+  return {
+    cwd: "/w",
+    mode: "tui",
+    sessionManager: { getSessionId: () => "sess-journal" },
+    ui: { select: channel.select },
+  } as unknown as ExtensionContext;
+}
+
+function parseFrame(call: SelectCall): Record<string, unknown> {
+  return JSON.parse(call.payload) as Record<string, unknown>;
+}
+
+beforeEach(() => {
+  vi.useFakeTimers();
+});
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+/** 推进 fake 时间并排空微任务（attempt 的 await 链走完）。 */
+async function advance(ms: number): Promise<void> {
+  await vi.advanceTimersByTimeAsync(ms);
+}
+
+describe("帧形状与单文件单帧（①使用者契约）", () => {
+  it("onJournalAppended → 单帧报告（title/marker、domain/fileKey/events/sessionId、控制面 timeout）", async () => {
+    const channel = makeSelectChannel();
+    const reporter = createJournalReporter({ selectTimeoutMs: SELECT_TIMEOUT_MS });
+    reporter.attachSession(makeCtx(channel));
+
+    reporter.onJournalAppended("run", "wf-1", [{ type: "run-created", ts: 1, seq: 1 }]);
+    await advance(0);
+
+    expect(channel.calls).toHaveLength(1);
+    expect(channel.calls[0].title).toBe(SUBAGENT_JOURNAL_MARKER);
+    expect(channel.calls[0].timeout).toBe(SELECT_TIMEOUT_MS);
+    const frame = parseFrame(channel.calls[0]);
+    expect(frame.domain).toBe("run");
+    expect(frame.fileKey).toBe("wf-1");
+    expect(frame.events).toEqual([{ type: "run-created", ts: 1, seq: 1 }]);
+    expect(frame.sessionId).toBe("sess-journal");
+    expect(typeof frame.emittedAt).toBe("number");
+
+    channel.settleAll(JOURNAL_REPORT_ACK);
+    await advance(0);
+  });
+
+  it("在途期间同文件新事件并入待推缓冲（成功后作为下一帧）；不同文件逐帧发送（fileKey 单数契约）", async () => {
+    const channel = makeSelectChannel();
+    const reporter = createJournalReporter();
+    reporter.attachSession(makeCtx(channel));
+
+    reporter.onJournalAppended("run", "wf-1", [{ type: "run-created", ts: 1, seq: 1 }]);
+    // 第一帧在途：同文件第二事件并入待推缓冲组；另一文件组队
+    reporter.onJournalAppended("run", "wf-1", [{ type: "agent-started", ts: 2, seq: 2 }]);
+    reporter.onJournalAppended("run", "wf-1", [{ type: "agent-settled", ts: 3, seq: 3 }]);
+    reporter.onJournalAppended("record", "sa-1", [{ type: "record-created", ts: 4, seq: 1 }]);
+    await advance(0);
+    expect(channel.calls).toHaveLength(1); // 在途串行化：不并发发帧
+
+    // 帧 0（run-created）ack 落定 → 缓冲组 wf-1（两事件已合并为一组）先发
+    channel.settle(0, JOURNAL_REPORT_ACK);
+    await advance(0);
+    expect(channel.calls).toHaveLength(2);
+    expect(parseFrame(channel.calls[1]).fileKey).toBe("wf-1");
+    expect(parseFrame(channel.calls[1]).events).toEqual([
+      { type: "agent-started", ts: 2, seq: 2 },
+      { type: "agent-settled", ts: 3, seq: 3 },
+    ]);
+
+    // 组间 FIFO：record 组随后
+    channel.settle(1, JOURNAL_REPORT_ACK);
+    await advance(0);
+    expect(channel.calls).toHaveLength(3);
+    expect(parseFrame(channel.calls[2]).fileKey).toBe("sa-1");
+    expect(parseFrame(channel.calls[2]).domain).toBe("record");
+    channel.settle(2, JOURNAL_REPORT_ACK);
+    await advance(0);
+  });
+});
+
+describe("失败折叠（设计 D5：缓冲即弃不重推，完整性归消费方缺口补读）", () => {
+  it("无 ack（超时形态）→ 待推缓冲整体丢弃；时间推进零重推，新事件重新起推", async () => {
+    const channel = makeSelectChannel();
+    const reporter = createJournalReporter();
+    reporter.attachSession(makeCtx(channel));
+
+    reporter.onJournalAppended("run", "wf-1", [{ type: "run-created", ts: 1, seq: 1 }]);
+    await advance(0);
+    channel.settle(0, undefined); // 首帧失败落定（超时形态）
+    await advance(0);
+    // 在途期间并入的事件随失败一并丢弃（缓冲即弃）
+    expect(channel.calls).toHaveLength(1);
+
+    await advance(60_000); // 无 timer 自动重试
+    expect(channel.calls).toHaveLength(1);
+
+    // 新的落盘事件重新起推（缓冲已清空，新事件是唯一载荷——不补发丢失事件）
+    reporter.onJournalAppended("run", "wf-1", [{ type: "agent-started", ts: 2, seq: 2 }]);
+    await advance(0);
+    expect(channel.calls).toHaveLength(2);
+    expect((parseFrame(channel.calls[1]).events as unknown[]).length).toBe(1);
+    channel.settleAll(JOURNAL_REPORT_ACK);
+    await advance(0);
+  });
+
+  it("非确认回包（任意字符串）不算送达，同款缓冲即弃", async () => {
+    const channel = makeSelectChannel();
+    const reporter = createJournalReporter();
+    reporter.attachSession(makeCtx(channel));
+    reporter.onJournalAppended("record", "sa-1", [{ type: "record-created", ts: 1, seq: 1 }]);
+    await advance(0);
+    channel.settle(0, '{"ok":1}');
+    await advance(0);
+    await advance(60_000);
+    expect(channel.calls).toHaveLength(1);
+  });
+});
+
+describe("生命周期与环境门控（③观察者）", () => {
+  it("onJournalAppended 同步返回：select 永不落定也不挂调用方（detach 可丢弃在途帧与缓冲）", async () => {
+    const channel = makeSelectChannel();
+    const reporter = createJournalReporter();
+    reporter.attachSession(makeCtx(channel));
+
+    reporter.onJournalAppended("run", "wf-1", [{ type: "run-created", ts: 1, seq: 1 }]);
+    await advance(0);
+    // 第一帧挂起（模拟 runtime 无响应）——落盘出口调用仍同步返回
+    expect(() => reporter.onJournalAppended("run", "wf-1", [{ type: "agent-started", ts: 2, seq: 2 }])).not.toThrow();
+
+    // session 死后 detach：挂起帧被丢弃、缓冲清空，通道静止
+    reporter.detachSession();
+    channel.settleAll(undefined);
+    await advance(60_000);
+    expect(channel.calls).toHaveLength(1);
+  });
+
+  it("非 rpc 模式 no-op：不设 ctx，落盘事件零帧（裸 pi TUI 下 marker select 会弹真框）", async () => {
+    const channel = makeSelectChannel();
+    const reporter = createJournalReporter();
+    reporter.attachSession(makeNonRpcCtx(channel));
+
+    reporter.onJournalAppended("run", "wf-1", [{ type: "run-created", ts: 1, seq: 1 }]);
+    await advance(60_000);
+    expect(channel.calls).toHaveLength(0);
+  });
+
+  it("attach 前的落盘事件不进缓冲（无 ctx 直返——factory 阶段落盘点早于 session_start 的窗口）", async () => {
+    const channel = makeSelectChannel();
+    const reporter = createJournalReporter();
+    reporter.onJournalAppended("run", "wf-1", [{ type: "run-created", ts: 1, seq: 1 }]);
+    await advance(0);
+    reporter.attachSession(makeCtx(channel));
+    await advance(0);
+    expect(channel.calls).toHaveLength(0); // 丢失面归消费方冷读收敛
+  });
+});

package/src/host/inflight-reporter.ts

@@ -26,15 +26,14 @@
 // （session_start 是 pi 启动序列里最早带 ctx 的钩子 = 「session 就绪」，即设计所指
 // 加载完成时点；不挂任何懒触发（无 subagent 的 session 也必上报）。
 //
-// 失败语义（D5 缺席语义②）：select 失败（超时/通道异常/非确认回包）折叠后延迟重试，
-// **累计 MAX_REPORT_ATTEMPTS（3）次放弃**。上限刻意取小（增强面降级）：GUI live
-// 在途镜像短暂滞后可接受，重试 3 次封顶后放弃，不做长尾可达保证——子任务完成通知
-// 另有账本必达通道，不依赖此镜像。session_start 首帧早于 runtime adapter attach 的
-// 竞态（R2 实证）在 3×2s=6s 窗口内自愈，错过窗口即放弃。送达判据 = runtime resolve
-// 的确认回包
-// （INFLIGHT_REPORT_ACK）——fire-and-forget 下 resolve(undefined) 与超时不可区分，
-// 靠显式 ack 区分「已送达」与「无路由」；放弃后镜像按 absent-report 走 errs 推迟
-// （30min 有界），不丢 errs-safe 兜底。
+// 失败语义（ADR-0122 收紧，原 D5 缺席语义②的 timer 重试已删）：select 失败
+// （超时/通道异常/非确认回包）→ 首败 warn 显式留痕 + 置脏——**不设 setTimeout
+// 自动重试**，等下一个 onInFlightChanged 事件驱动重推（绝对计数语义下任何一帧
+// 成功即整镜恢复）。session_start 首帧早于 runtime adapter attach 的竞态（R2 实证）
+// 由此由后续 in-flight 变化事件自然补推；无后续事件的 session 镜像按 absent-report
+// 走 errs 推迟（30min 有界），完成通知另有账本必达通道，不依赖此镜像。
+// 送达判据 = runtime resolve 的确认回包（INFLIGHT_REPORT_ACK）——fire-and-forget 下
+// resolve(undefined) 与超时不可区分，靠显式 ack 区分「已送达」与「无路由」。
 
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { SUBAGENT_INFLIGHT_MARKER, callMarkerRpc, isInFlightReportAck } from "@zhushanwen/extension-protocol";
@@ -42,21 +41,10 @@ import { getInFlightSnapshot } from "@zhushanwen/subagent-core";
 import { getLogger } from "@zhushanwen/pi-extension-logger";
 import { toErrorMessage } from "@zhushanwen/pi-ext-guards";
 
-/** select 通道级超时（控制面单请求，秒级校准——超时默认原则规则 19）。取值对齐
- *  plugin-bridge 启动 sync 的 2s 自愈闸：session_start 首帧可能早于 runtime adapter
- *  attach（R2 实证），超时折叠后靠有限次重试覆盖 attach 竞态窗口（约 6s，见
- *  MAX_REPORT_ATTEMPTS）；fire-and-forget 帧不留 pending 挂死面。 */
+/** select 通道级超时（控制面单请求，秒级校准——超时默认原则规则 19）；fire-and-forget
+ *  帧不留 pending 挂死面。失败不重试（ADR-0122），置脏等下一个事件。 */
 const SELECT_TIMEOUT_MS = 2_000;
 
-/** 失败重试退避（对齐 plugin-bridge SYNC_RETRY_MS 控制面节奏）。 */
-const RETRY_DELAY_MS = 2_000;
-
-/** 累计失败放弃上限（刻意取小——增强面降级）：GUI live 在途镜像短暂滞后可接受，
- *  3 次封顶（约 6s）后放弃，不做长尾可达保证；完成通知另有账本必达通道，不依赖
- *  此镜像。重试窗口同时覆盖 session_start 首帧早于 runtime adapter attach 的竞态
- *  （R2 实证），并有界防 rpc-but-非-taiji orchestrator 场景的永久空转。 */
-const MAX_REPORT_ATTEMPTS = 3;
-
 /** 在途上报器（组合根 index.ts 持有；per-factory 实例，session_start/shutdown 驱动）。 */
 export interface InFlightReporter {
   /**
@@ -65,7 +53,7 @@ export interface InFlightReporter {
    * （ctx.mode !== 'rpc'）下为 no-op：无 runtime 拦截方，上报通道不该启动。
    */
   attachSession(ctx: ExtensionContext): void;
-  /** session_shutdown 摘除 ctx 并停止重试（session 已死，上报通道随之终结）。 */
+  /** session_shutdown 摘除 ctx（session 已死，上报通道随之终结）。 */
   detachSession(): void;
   /** core 出口回调（notifyInFlightChanged 直连）：同步返回，内部合并 + void 推送。 */
   onInFlightChanged(): void;
@@ -74,16 +62,12 @@ export interface InFlightReporter {
 export interface InFlightReporterOpts {
   /** 测试注入：select 超时（ms）。缺省 SELECT_TIMEOUT_MS。 */
   selectTimeoutMs?: number;
-  /** 测试注入：重试退避（ms）。缺省 RETRY_DELAY_MS。 */
-  retryDelayMs?: number;
-  /** 测试注入：累计失败放弃上限。缺省 MAX_REPORT_ATTEMPTS。 */
-  maxAttempts?: number;
 }
 
 /**
- * sessionId 从 ctx 取（plugin-bridge getSessionId 同款防御）：pi session 文件延迟写入
- * 窗口内取失败不阻断上报——sessionId 缺席时 runtime 按无法归属丢弃整帧（契约
- * SubagentInFlightReport.sessionId 可选语义），不视为协议错误。
+ * sessionId 从 ctx 取：pi session 文件延迟写入窗口内取失败不阻断上报——sessionId
+ * 缺席时 runtime 按无法归属丢弃整帧（契约 SubagentInFlightReport.sessionId 可选语义），
+ * 不视为协议错误。
  */
 function getSessionId(ctx: ExtensionContext): string | undefined {
   try {
@@ -95,35 +79,20 @@ function getSessionId(ctx: ExtensionContext): string | undefined {
 
 export function createInFlightReporter(opts: InFlightReporterOpts = {}): InFlightReporter {
   const selectTimeoutMs = opts.selectTimeoutMs ?? SELECT_TIMEOUT_MS;
-  const retryDelayMs = opts.retryDelayMs ?? RETRY_DELAY_MS;
-  const maxAttempts = opts.maxAttempts ?? MAX_REPORT_ATTEMPTS;
   const logger = getLogger("subagents");
 
   // 闭包状态（per-factory 实例；禁模块级 let——同进程多 factory 实例会串台）。
   let ctx: ExtensionContext | null = null;
   /** 一次推送尝试在途（串行化——绝对计数语义下中间值可安全合并丢弃）。 */
   let attemptInFlight = false;
-  /** 有待推帧（onInFlightChanged 在推送在途期间置位，成功后立即补推最新值）。 */
+  /** 有待推帧（推送在途或上次失败期间置位，下次 onInFlightChanged 事件驱动重推）。 */
   let dirty = false;
-  /** 重试定时器句柄（单飞；成功/dispose 即清）。 */
-  let retryTimer: ReturnType<typeof setTimeout> | null = null;
-  /** 累计失败次数（成功清零；达 maxAttempts 放弃——本 session 不再重试）。 */
-  let failureCount = 0;
-  /** 已放弃（累计到顶；session 内终态，成功路径永不触及）。 */
-  let givenUp = false;
-  /** 首次失败已 warn 留痕（重试循环不刷屏）。 */
+  /** 首次失败已 warn 留痕（后续失败不刷屏）。 */
   let firstFailureLogged = false;
 
-  function clearRetryTimer(): void {
-    if (retryTimer !== null) {
-      clearTimeout(retryTimer);
-      retryTimer = null;
-    }
-  }
-
-  /** 推送在途、已放弃或无 ctx 时仅置脏；否则发起一次尝试（void，不阻塞调用方）。 */
+  /** 推送在途或无 ctx 时仅置脏；否则发起一次尝试（void，不阻塞调用方）。 */
   function kick(): void {
-    if (attemptInFlight || givenUp || ctx === null) {
+    if (attemptInFlight || ctx === null) {
       dirty = true;
       return;
     }
@@ -148,7 +117,7 @@ export function createInFlightReporter(opts: InFlightReporterOpts = {}): InFligh
     });
     // 发送+折叠半边走 protocol 的 callMarkerRpc 原语（D8，fire-and-forget：void 发起
     // 不变）：ok:false 四态（cancelled/timeout/channel-error/non-json）统一折叠进下方
-    // 延迟重试路径；送达判据 = ack 全等匹配（不是 JSON 消费），留在本侧。原语的失败
+    // 失败留痕路径；送达判据 = ack 全等匹配（不是 JSON 消费），留在本侧。原语的失败
     // 留痕经注入的 log 承载本侧「首败 warn / 后续 debug」防刷屏策略。
     // guiCtx = ExtensionContext 的 GuiContext 最小子集（ask-user runRpcInteraction 同款
     // 先例：ui.custom 泛型签名静态不兼容，callMarkerRpc 只读 ui.select）。
@@ -163,37 +132,19 @@ export function createInFlightReporter(opts: InFlightReporterOpts = {}): InFligh
     });
     attemptInFlight = false;
     if (result.ok && isInFlightReportAck(result.value)) {
-      // 送达确认：清重试与失败计数，补推积压脏帧。
-      failureCount = 0;
-      clearRetryTimer();
+      // 送达确认：补推积压脏帧。
       if (dirty && ctx !== null) kick();
       return;
     }
-    // 失败折叠（resolve undefined = 超时/取消/无路由 / 回包非 ack / 通道异常）→ 延迟
-    // 重试，累计到顶放弃（放弃后镜像按 absent-report 走 errs 推迟，30min 有界，
-    // errs-safe 兜底不丢）。
+    // 失败折叠（resolve undefined = 超时/取消/无路由 / 回包非 ack / 通道异常）：
+    // 显式留痕 + 置脏（ADR-0122：无 timer 自动重试）——等下一个 onInFlightChanged
+    // 事件驱动重推；attach 竞态丢失的首帧由后续事件自然补推，无后续事件的 session
+    // 镜像按 absent-report 走 errs 推迟（30min 有界，errs-safe 兜底不丢）。
     logFailure(
       result.ok ? "no ack (non-ack response)" : `no ack (${result.reason})`,
       result.ok ? result.value : undefined,
     );
-    failureCount += 1;
-    if (failureCount >= maxAttempts) {
-      givenUp = true;
-      clearRetryTimer();
-      logger.warn(
-        `[subagent-inflight] in-flight report gave up after ${failureCount} attempts; ` +
-          `mirror will treat this session as absent-report (errs-deferred, bounded)`,
-      );
-      return;
-    }
-    if (ctx !== null && retryTimer === null) {
-      retryTimer = setTimeout(() => {
-        retryTimer = null;
-        kick();
-      }, retryDelayMs);
-      // unref：不阻塞进程退出（退出收割由既有 process hook 负责，与 plugin-bridge 同款）。
-      retryTimer.unref?.();
-    }
+    dirty = true;
   }
 
   /** 原语留痕注入（D8）：msg/detail 由 callMarkerRpc 产出；防刷屏策略（首败 warn /
@@ -205,12 +156,12 @@ export function createInFlightReporter(opts: InFlightReporterOpts = {}): InFligh
   function logFailure(reason: string, detail: unknown): void {
     if (!firstFailureLogged) {
       firstFailureLogged = true;
-      logger.warn(`[subagent-inflight] in-flight report failed (${reason}); retrying every ${retryDelayMs}ms (bounded at ${maxAttempts} attempts)`, {
+      logger.warn(`[subagent-inflight] in-flight report failed (${reason}); will retry on next in-flight change (event-driven, no timer)`, {
         detail: toErrorMessage(detail),
       });
       return;
     }
-    logger.debug(`[subagent-inflight] in-flight report retry failed (${reason})`);
+    logger.debug(`[subagent-inflight] in-flight report failed again (${reason})`);
   }
 
   return {
@@ -219,13 +170,10 @@ export function createInFlightReporter(opts: InFlightReporterOpts = {}): InFligh
       // select 会弹真框（2026-09-12 裸 TUI 无限闪框事故根因）——不设 ctx，本 session
       // 全程 no-op。ask-user 的 ctx.mode === "rpc" 二值判定同款先例。
       if (target.mode !== "rpc") return;
-      // attach = 新 reporting epoch（新 session / respawn 后重载）：放弃态与失败计数
-      // 随旧 session 终结，重置重试资格（同一 session 内放弃不恢复——absent-report 兜底）。
-      givenUp = false;
-      failureCount = 0;
+      // attach = 新 reporting epoch（新 session / respawn 后重载）：首败留痕标记随旧
+      // session 终结重置（新 session 的首败仍 warn 显式上报）。
       firstFailureLogged = false;
       ctx = target;
-      clearRetryTimer();
       // 初始上报（count=当下绝对计数；session 就绪时点恒为 0——子进程只会在后续
       // subagent 调用里出现）。fire-and-forget：不阻塞 session_start 装配链。
       kick();
@@ -234,7 +182,6 @@ export function createInFlightReporter(opts: InFlightReporterOpts = {}): InFligh
     detachSession(): void {
       ctx = null;
       dirty = false;
-      clearRetryTimer();
     },
 
     onInFlightChanged(): void {

package/src/host/journal-reporter.ts

@@ -0,0 +1,204 @@
+// src/host/journal-reporter.ts
+//
+// 壳层 journal 事件推送出口（event-push-channel W-P1，设计权威源
+// .tmp/tech-design/event-push-channel.md §3.1/§3.3/§3.4）。本文件属壳侧（shell），
+// 对 pi SDK（ExtensionContext 的 ctx.ui.select 通道）的消费收敛在 host/ 层——
+// core 闭包红线只约束 core（出口回调由 core 的 journal-notify 注入，见组合根
+// workflow-events.ts 的 setJournalAppendListener 接线）。
+//
+// 链路：core journal 落盘提交点（run 域 terminal-actions / record 域 record-store
+// 族）→ notifyJournalAppended（同步回调）→ 本 reporter（事件按 (domain, fileKey)
+// 分组合并 → select 通道帧，title = SUBAGENT_JOURNAL_MARKER）→ runtime event-adapter
+// marker 路由 → session-records 派生视图（applyJournalReport）。
+//
+// 语义（设计 §3.3）：单帧报告覆盖一个文件（fileKey 单数）；事件 = 刚落盘的行对象
+// （seq 已分配），不做水位协商——去重与缺口判定归消费方（fold seq 单调守卫构造性
+// 幂等）。串行化合并：一次推送尝试在途时，后续事件并入待推缓冲；尝试成功后缓冲
+// 剩余组继续逐组推送（事件驱动，无 timer）。
+//
+// 失败语义（设计 D5，与 inflight reporter 的 dirty 重推刻意分叉）：select 失败
+// （超时/通道异常/非确认回包）→ 首败 warn 留证 + 待推缓冲整体丢弃——**不重试**
+// （本通道消费方有 seq 水位可判缺口，丢失由缺口补读收敛，缓冲重推是重复保险）。
+// 无后续事件的丢失场景由终局条目补读触发兜底（设计 §3.3 终局一致性）。
+// 送达判据 = runtime resolve 的确认回包（JOURNAL_REPORT_ACK）——回执 = 「已应用」
+// （runtime 同步完成 fold 后 resolve）。
+//
+// 环境门控：上报的消费方是 taiji runtime 的 event-adapter marker 路由，runtime
+// spawn pi 恒为 --mode rpc——ctx.mode !== 'rpc' 即无拦截方（裸 pi TUI 下 marker
+// select 会弹真框），此时不启动推送（inflight-reporter 环境门控同款）。
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+  SUBAGENT_JOURNAL_MARKER,
+  callMarkerRpc,
+  isJournalReportAck,
+  type SubagentJournalDomain,
+  type SubagentJournalEvent,
+} from "@zhushanwen/extension-protocol";
+import { getLogger } from "@zhushanwen/pi-extension-logger";
+
+/** select 通道级超时（控制面单请求，秒级校准——超时默认原则规则 19；与 inflight
+ *  reporter 同量级。失败不重试，缺口归消费方补读收敛）。 */
+const SELECT_TIMEOUT_MS = 2_000;
+
+/** 单帧报告字节数的观测阈值（设计 W-P4 ④：只观测不拦截——超限 warn 留痕，供
+ *  worker-log 高频行合并量级评估；不设硬上限，截断会破坏报告内 seq 连续性判定）。 */
+const REPORT_BYTES_WARN_THRESHOLD = 100_000;
+
+/** 单文件待推事件组（报告的逐文件分组形态）。 */
+type PendingFileGroup = {
+  domain: SubagentJournalDomain;
+  fileKey: string;
+  events: SubagentJournalEvent[];
+};
+
+/** journal 事件推送器（workflow-events 装配点持有；per-factory 实例，session_start/shutdown 驱动）。 */
+export interface JournalReporter { // oe-exempt:20261003:framework:host 层对装配点的 reporter 端口契约（attach/detach/onJournalAppended 消费缝先立）
+  /**
+   * session_start 注入当前 ctx（非 rpc 模式下为 no-op：无 runtime 拦截方，推送
+   * 通道不该启动）。journal 推送是纯事件驱动（落盘提交点触发），无初始帧——
+   * 与 inflight 的「加载完成初始上报」刻意不同：报告语义是增量事件，空 session
+   * 无事件可报，缺席语义归消费方冷读。
+   */
+  attachSession(ctx: ExtensionContext): void;
+  /** session_shutdown 摘除 ctx 并丢弃待推缓冲（session 已死，推送通道随之终结；
+   *  未推事件由消费方冷读/缺口补读收敛）。 */
+  detachSession(): void;
+  /** core 出口回调（notifyJournalAppended 直连）：同步返回，内部分组合并 + void 推送。 */
+  onJournalAppended(domain: SubagentJournalDomain, fileKey: string, events: readonly unknown[]): void;
+}
+
+export interface JournalReporterOpts { // oe-exempt:20261003:framework:工厂参数契约（测试注入缝，消费方 workflow-events 以不同 opts 实例化）
+  /** 测试注入：select 超时（ms）。缺省 SELECT_TIMEOUT_MS。 */
+  selectTimeoutMs?: number;
+  /** 测试注入：报告字节数观测阈值。缺省 REPORT_BYTES_WARN_THRESHOLD。 */
+  reportBytesWarnThreshold?: number;
+}
+
+/**
+ * sessionId 从 ctx 取：pi session 文件延迟写入窗口内取失败不阻断推送——sessionId
+ * 缺席时 runtime 按无法归属丢弃整帧（契约 SubagentJournalReport.sessionId 可选语义），
+ * 不视为协议错误。
+ */
+function getSessionId(ctx: ExtensionContext): string | undefined {
+  try {
+    return ctx.sessionManager.getSessionId();
+  } catch {
+    return undefined;
+  }
+}
+
+export function createJournalReporter(opts: JournalReporterOpts = {}): JournalReporter {
+  const selectTimeoutMs = opts.selectTimeoutMs ?? SELECT_TIMEOUT_MS;
+  const reportBytesWarnThreshold = opts.reportBytesWarnThreshold ?? REPORT_BYTES_WARN_THRESHOLD;
+  const logger = getLogger("subagents");
+
+  // 闭包状态（per-factory 实例；禁模块级 let——同进程多 factory 实例会串台）。
+  let ctx: ExtensionContext | null = null;
+  /** 待推缓冲（(domain,fileKey) → 事件组；推送在途期间新事件并入，尝试启动时取走）。 */
+  const pending = new Map<string, PendingFileGroup>();
+  /** 一次推送尝试在途（串行化——组间逐帧发送，避免并发 select 帧交叉）。 */
+  let attemptInFlight = false;
+  /** 首次失败已 warn 留痕（后续失败不刷屏；随 attach 重置——新 session 的首败仍显式上报）。 */
+  let firstFailureLogged = false;
+
+  function groupKeyOf(domain: SubagentJournalDomain, fileKey: string): string {
+    return `${domain}:${fileKey}`;
+  }
+
+  /** core 出口回调直连：事件并入待推缓冲 + 事件驱动 kick（同步返回，不阻塞落盘主链）。 */
+  function onJournalAppended(
+    domain: SubagentJournalDomain,
+    fileKey: string,
+    events: readonly unknown[],
+  ): void {
+    if (ctx === null || events.length === 0) return;
+    const key = groupKeyOf(domain, fileKey);
+    const group = pending.get(key);
+    if (group !== undefined) {
+      group.events.push(...(events as SubagentJournalEvent[]));
+    } else {
+      pending.set(key, { domain, fileKey, events: [...(events as SubagentJournalEvent[])] });
+    }
+    kick();
+  }
+
+  /** 推送在途时不重入（缓冲已承接）；否则逐组发起推送（void，不阻塞调用方）。 */
+  function kick(): void {
+    if (attemptInFlight || ctx === null) return;
+    attemptInFlight = true;
+    void attempt();
+  }
+
+  async function attempt(): Promise<void> {
+    try {
+      let active = ctx;
+      while (active !== null && pending.size > 0) {
+        // 取首组发送（FIFO——Map 插入序 = 事件到达序）；组在发送前移出缓冲：
+        // 失败时该组与其余待推组一起丢弃（D5 缓冲即弃），成功时继续下一组。
+        const [key, group] = pending.entries().next().value as [string, PendingFileGroup];
+        pending.delete(key);
+        const payload = JSON.stringify({
+          domain: group.domain,
+          fileKey: group.fileKey,
+          events: group.events,
+          sessionId: getSessionId(active),
+          emittedAt: Date.now(),
+        });
+        if (payload.length > reportBytesWarnThreshold) {
+          logger.warn(`[subagent-journal] report size exceeds observation threshold (${payload.length} bytes, file=${group.fileKey}, events=${group.events.length}) — observation only, no rejection`);
+        }
+        const guiCtx = {
+          mode: active.mode,
+          hasUI: active.hasUI,
+          ui: { select: active.ui.select.bind(active.ui) },
+        };
+        const result = await callMarkerRpc(guiCtx, SUBAGENT_JOURNAL_MARKER, payload, {
+          timeout: selectTimeoutMs,
+          log: primitiveLog,
+        });
+        if (!(result.ok && isJournalReportAck(result.value))) {
+          logFailure(result.ok ? "no ack (non-ack response)" : `no ack (${result.reason})`);
+          pending.clear(); // D5：失败即弃缓冲（不重推）——完整性归消费方 seq 缺口补读
+          return;
+        }
+        active = ctx; // 尝试期间可能 detach/attach——每轮现读
+      }
+    } finally {
+      attemptInFlight = false;
+    }
+    // 成功路径：detach 后 ctx 为 null（while 退出）——缓冲随 detach 清空，无残留。
+  }
+
+  /** 原语留痕注入：msg/detail 由 callMarkerRpc 产出；防刷屏策略留本侧 logFailure。 */
+  function primitiveLog(msg: string, detail?: object): void {
+    logFailure(detail === undefined ? msg : `${msg} ${JSON.stringify(detail)}`);
+  }
+
+  function logFailure(reason: string): void {
+    if (!firstFailureLogged) {
+      firstFailureLogged = true;
+      logger.warn(`[subagent-journal] journal report failed (${reason}); buffer dropped, convergence via consumer seq-gap backfill (no retry)`);
+      return;
+    }
+    logger.debug(`[subagent-journal] journal report failed again (${reason})`);
+  }
+
+  return {
+    attachSession(target: ExtensionContext): void {
+      // 环境门控：非 rpc 模式（裸 pi TUI / json / print）无 runtime 拦截方，marker
+      // select 会弹真框——不设 ctx，本 session 全程 no-op（inflight 同款先例）。
+      if (target.mode !== "rpc") return;
+      // attach = 新 reporting epoch：首败留痕标记随旧 session 终结重置。
+      firstFailureLogged = false;
+      ctx = target;
+    },
+
+    detachSession(): void {
+      ctx = null;
+      pending.clear();
+    },
+
+    onJournalAppended,
+  };
+}

package/src/interface/command/subagents.ts

@@ -36,8 +36,8 @@ export interface SubagentDirectiveDetails {
 /**
  * 定向消息留痕：向主 session 落 subagent-directive custom_message entry。
  *
- * 按主 agent streaming 状态分流 sendMessage options。pi 0.84.4 sendCustomMessage
- * 实装（agent-session.js）：isStreaming 且无 deliverAs 时默认 agent.steer()——会把
+ * 按主 agent streaming 状态分流 sendMessage options。pi sendCustomMessage
+ * 实装（agent-session.js，1.0.0 复核同构）：isStreaming 且无 deliverAs 时默认 agent.steer()——会把
  * 定向消息注入正在运行的主 agent LLM turn，违反「不经主 agent LLM 直达 subagent」。
  * 故按调用时刻的权威 streaming 状态（ctx.isIdle()，与 sendCustomMessage 内部
  * isStreaming 判据精确互补，含 agent_end 后 retry/continuation 窗口）分流：

package/src/interface/tool/subagent-tool.ts

@@ -92,11 +92,12 @@ function isModelOverrideObj(a: unknown): a is { model?: unknown; thinkingLevel?:
 /**
  * start 路径类参数（skillPath / cwd）运行时守卫：绝对路径 + 禁 `..` 穿越。
  *
- * 校验链事实（pi 0.84.4 实装，登记 PS-20）：pi agent-loop 对注册 typebox schema
- * 有运行时强校验——agent-loop.js:403-404 在 beforeToolCall / execute 之前调
- * validateToolArguments（pi-ai validation.js:247：Value.Convert :249 + Compile :210
- * + Check :265，失败 throw `Validation failed for tool` :272-273）→ catch 走
- * immediate error（agent-loop.js:445-451），execute 不被调用。schema 的
+ * 校验链事实（语义登记 PS-20，verifiedWith 以 pi-semantics.json 为准，逐 claim 行号见该条目
+ * piAnchor）：pi agent-loop 对注册 typebox schema
+ * 有运行时强校验——在 beforeToolCall / execute 之前调
+ * validateToolArguments（pi-ai validation.js：Value.Convert + Compile
+ * + Check，失败 throw `Validation failed for tool`）→ catch 走
+ * immediate error，execute 不被调用。schema 的
  * pattern（skillPath/cwd `^/`）/ maxLength（slug 35）是运行时强制而非仅模型可见
  * 契约；tool-definition-wrapper.js:11 只原样透传 params，校验发生在上游 agent-loop 层。
  *

package/src/interface/tool/tool-workflow-script.ts

@@ -13,8 +13,9 @@
  * C5②（convergence D-6）：generate 五道闸校验管线 + tmp 写盘下沉 core
  * generateWorkflowScript（报错文案逐字平移，CA2 前提）；save/delete 改调 core
  * barrel（第三可选目录参数缺省即 pi 布局 .pi/workflows——pi 现两参调用形态零变化）。
- * 结构化 {ok}|{error} → pi 的 execute-throw 契约转换在本层（pi 只对 execute throw
- * 置 isError:true）；AbortSignal 的 aborted 检查在 execute 入口统一拦截（与
+ * 结构化 {ok}|{error} → pi 的 execute-throw 契约转换在本层（pi 1.0.0：execute 抛出经
+ * pi-agent-core agent-loop.js executePreparedToolCall 外层 catch 统一转 isError:true）；
+ * AbortSignal 的 aborted 检查在 execute 入口统一拦截（与
  * workflow / subagents 两 tool 同源，tool-shared assertNotAborted；C4 偏差 #4）。
  *
  * 层归属：Interface。依赖 Pi SDK + engine script-lint + infra workflow-files。
@@ -183,7 +184,8 @@ export function registerWorkflowScriptTool(
     ): Promise<WorkflowScriptExecuteResult> {
       // P1-2 abort 前置（三 tool 对称）：5 个 action 统一在 execute 入口拦截——
       // 原先只在 generate 内检查，lint/save/delete/list 四路径漏拦。throw（W4b）：
-      // pi 只对 execute throw 置 isError:true，返回值里的 isError 被 agent-loop 丢弃。
+      // 错误路径统一 throw（单一错误路径纪律；pi 1.0.0 agent-loop 对抛出统一转
+      // isError:true error result）。
       assertNotAborted(signal);
       let result: WorkflowScriptExecuteResult;
       switch (params.action) {
@@ -203,8 +205,9 @@ export function registerWorkflowScriptTool(
           result = await actionList(registry);
           break;
         default:
-          // 防御性（schema StringEnum 先拦）：throw（W4b）——pi 只对 execute throw 置
-          // isError:true，返回值里的 isError 被 agent-loop 丢弃（agent-loop.js:453-483）。
+          // 防御性（schema StringEnum 先拦）：throw（W4b）——错误路径统一 throw
+          // （pi 1.0.0 pi-agent-core agent-loop.js executePreparedToolCall :579-588：
+          // 抛出经外层 catch 转 isError:true error result）。
           throw new Error(`Unknown action: ${String(params.action)}`);
       }
       // GUI 协议：RPC 模式下附加 __gui__ 到 details（attach 单点在 tool-shared）
@@ -229,7 +232,8 @@ export function registerWorkflowScriptTool(
 // ── generate action ──────────────────────────────────────────
 
 export function actionGenerate(params: ScriptParams): WorkflowScriptExecuteResult {
-  // throw（W4b）：pi 只对 execute throw 置 isError:true（返回值 isError 被丢弃）。
+  // throw（W4b）：错误路径统一 throw（单一错误路径纪律；pi 1.0.0 agent-loop 对抛出
+  // 统一转 isError:true error result）。
   // abort 前置在 execute 入口统一拦截（三 tool 同源，tool-shared assertNotAborted），
   // 本函数不再自带 signal 检查。
   const name = params.name ?? "";
@@ -386,9 +390,9 @@ async function actionList(registry: WorkflowScriptRegistry): Promise<WorkflowScr
 // ── helper ───────────────────────────────────────────────────
 
 /**
- * 构造纯文本非错误结果（W4b：isError 参数已删除——pi 只对 execute throw 置
- * isError:true，返回值里的 isError 被 agent-loop 丢弃（agent-loop.js:453-483），
- * 错误一律 throw，编译器兜底防回潮）。
+ * 构造纯文本非错误结果（W4b：isError 参数已删除——异常错误路径一律 throw（单一
+ * 错误路径纪律；pi 1.0.0 pi-agent-core agent-loop.js :579-588 对抛出统一转
+ * isError:true error result），编译器兜底防回潮）。
  */
 function textResult(text: string): WorkflowScriptExecuteResult {
   return {

package/src/session-lifecycle.ts

@@ -523,19 +523,17 @@ function appendSubagentIdentityEntry(pi: ExtensionAPI): void {
  * 返回 undefined。
  */
 export function bindLedgerHostAndRecover(pi: ExtensionAPI, ctx: ExtensionContext): NotifyLedgerHost | undefined {
-  // host 五端口接线 + 送达 stale 防御（D5 单通道 {triggerTurn:true} / stale 静默降级 /
-  // abandon 补显形 T4③）收敛在 @zhushanwen/pi-notify-ledger-host 工厂，权威注释随迁
-  // 工厂内；component/logger 参数保持本包 label 前缀与 warn 通道归因不变，
-  // sendDisplayMessage = 生产 bind 恒实现（NotifyLedgerHost 可选端口的本侧既有语义）。
+  // host 五端口接线 + 送达 stale 防御（D5 单通道 {triggerTurn:true} / stale 静默降级）
+  // 收敛在 @zhushanwen/pi-notify-ledger-host 工厂，权威注释随迁工厂内；
+  // component/logger 参数保持本包 label 前缀与 warn 通道归因不变。
   const ledgerHost = createPiNotifyLedgerHost(pi, ctx, {
     component: "subagent-workflow",
     logger,
-    sendDisplayMessage: true,
   });
   // bind 与 recover 拆独立 try（失败归因不同）：
   // - bind 失败：槽上无 ledger，消费方（getBoundNotifyLedger）退回内核直发路径；
   // - recover 失败：bind 已成功、槽上 ledger 仍在，消费方照常走账本路径（重启重放
-  //   缺席，边沿/看门狗仍投新通知）——不得共用 "bind failed" 文案误报。
+  //   缺席，settled 边沿仍投新通知）——不得共用 "bind failed" 文案误报。
   let ledger: ReturnType<typeof bindNotifyLedgerHost>;
   try {
     ledger = bindNotifyLedgerHost(ledgerHost);

package/src/workflow-events.ts

@@ -52,6 +52,9 @@ import { getSubagentService } from "@zhushanwen/subagent-core";
 import type { LauncherDeps } from "@zhushanwen/subagent-core";
 import { terminateRunningRuns } from "@zhushanwen/subagent-core";
 import { setInFlightListener } from "@zhushanwen/subagent-core";
+// [event-push-channel W-P1] journal 落盘事件出口接线：core 两域落盘提交点 → 出口
+// 回调 → 壳层 journal reporter（select marker 通道带回执推送 runtime 派生视图）。
+import { setJournalAppendListener } from "@zhushanwen/subagent-core";
 import {
   evictDoneRunsBeyondCap,
   MAX_RETAINED_DONE_RUNS,
@@ -65,6 +68,10 @@ import { WorkflowScriptRegistryImpl } from "@zhushanwen/subagent-core";
 // [u7a D5] 在途上报出口：实例由本 seam 创建并接线 setInFlightListener（组合根零
 // 管道），session_start / session_shutdown 驱动 attach/detach；测试可注入 fake。
 import { createInFlightReporter, type InFlightReporter } from "./host/inflight-reporter.ts";
+// [event-push-channel W-P1] journal 推送出口：实例由本 seam 创建并接线
+// setJournalAppendListener（与 inflight reporter 同 seam 同款），session_start /
+// session_shutdown 驱动 attach/detach；测试可注入 fake。
+import { createJournalReporter, type JournalReporter } from "./host/journal-reporter.ts";
 // [W2/V1 D1 第 8 行] 判活类消费面（isScriptRunning）经 core 投影单点
 //（runSummary.status 三态投影——终局判定源 = 终局记录注册表）。
 import { type RunSettlementRecord } from "./jsonl-run-store.ts";
@@ -274,7 +281,7 @@ export interface WorkflowDomainHandle {
  */
 export function setupWorkflowDomain(
   pi: ExtensionAPI,
-  wiring: { inflightReporter?: InFlightReporter } = {},
+  wiring: { inflightReporter?: InFlightReporter; journalReporter?: JournalReporter } = {},
 ): WorkflowDomainHandle {
   // [u7a D5] 在途聚合上报接线（自组合根 index.ts 收编）：core 状态迁移
   // （spawn/close/arm/disarm）→ 出口回调 → reporter 经 select 通道推绝对计数帧。
@@ -285,6 +292,14 @@ export function setupWorkflowDomain(
   // 组合根对实例零知识（纯管道参数已删）。
   const inflightReporter = wiring.inflightReporter ?? createInFlightReporter();
   setInFlightListener(inflightReporter.onInFlightChanged);
+  // [event-push-channel W-P1] journal 推送出口接线（与 inflight reporter 同 seam 同款）：
+  // core 两域落盘提交点 → 出口回调 → reporter 按 (domain,fileKey) 分组合并 → select
+  // marker 通道带回执推送 runtime。出口为进程级单监听，后注册覆盖先注册（jiti 重载
+  // 幂等）；回调同步 void，不进任何落盘 await 链。ctx 由 session_start 注入
+  // （factory 阶段无 ui）。wiring.journalReporter 是测试注入面（fake reporter 观察
+  // attach/detach 驱动时点）；生产路径缺省真实创建——组合根对实例零知识。
+  const journalReporter = wiring.journalReporter ?? createJournalReporter();
+  setJournalAppendListener(journalReporter.onJournalAppended);
   // [skill-reload D2] handle.state 即槽对象本身（不做解构重包装——否则容器每次
   //  factory 重跑新建，调用方拿不到「同一 domain state 引用」的接管前提）。
   const domainState = getOrCreateWorkflowDomainState();
@@ -436,16 +451,20 @@ export function setupWorkflowDomain(
   //  开头一致）+ 装配结果写入 per-session sessionState。
   // ════════════════════════════════════════════════════════════
   pi.on("session_start", async (event: SessionStartEvent, ctx: ExtensionContext) => {
-    // 装配链异常不向 pi 事件分发逃逸（pi 0.84.4 extension handler 未捕获的 rejection
-    // 直接炸进程——E1 同机制）：围栏 error 留痕（含 sessionId）后保持 handler 不抛。
+    // 装配链异常不向 pi 事件分发逃逸（0.84.4 的 extension handler 未捕获 rejection
+    // 直接炸进程——E1 同机制；1.0.0 起 runner.emit 以 try/catch 吸收转 emitError 上报，
+    // 围栏仍保留——handler 不依赖 pi 侧异常处理语义）：error 留痕（含 sessionId）后保持 handler 不抛。
     // lsRef 在 try 内先行赋值：getSessionId 自身抛错时 catch 里拿到的是上一 session
     // 的 id（留痕仍可检索）。
     try {
       lsRef.lastSessionId = ctx.sessionManager.getSessionId();
       // [u7a D5] 初始上报（count=当下绝对计数）：触发时点 = extension 加载完成 / session
-      // 就绪（factory 无 ctx/ui，session_start 是最早带 ctx 的钩子——plugin-bridge 同款
-      // 事实）。fire-and-forget 在 await 装配链之前发起，不阻塞也不被阻塞。
+      // 就绪（factory 无 ctx/ui，session_start 是最早带 ctx 的钩子）。fire-and-forget
+      // 在 await 装配链之前发起，不阻塞也不被阻塞。
       inflightReporter.attachSession(ctx);
+      // [event-push-channel W-P1] journal 推送出口 attach（事件驱动，无初始帧——
+      // 报告语义是增量事件，缺席语义归消费方冷读）。
+      journalReporter.attachSession(ctx);
       // [skill-reload D4] adoption 入参接线：reason 是 handler 独占信息（event 参数），
       // existing 是 sessionState（domainState 闭包）里的既有条目——两者都是
       // session-lifecycle seam 的 adoption 分流判据，经 SessionStartOptions 传入。
@@ -546,6 +565,9 @@ export function setupWorkflowDomain(
       getSubagentService()?.invalidatePiBinding("session replacement (reload)");
       // b 动作保留（理由见上方 D1 分支说明）。
       inflightReporter.detachSession();
+      // [event-push-channel W-P1] journal 推送通道随 reload 同步摘 ctx（旧 ctx 的
+      // session 已被 pi 替换，推送帧无法归属；新 session_start 重新 attach）。
+      journalReporter.detachSession();
 
       // [skill-reload D8] reload 分支归因日志：preserved 计数取自跳过清理时的存活
       // 对象真实统计（runs = 各 session 内存 run 聚合根数；records = run.state.calls
@@ -582,6 +604,9 @@ export function setupWorkflowDomain(
     // [u7a D5] 在途上报通道随 session 终结：摘 ctx + 停重试（session 已死，重试直至
     // 成功的语义只对活 session 成立；进程级出口监听保留——后续 /new 重新 attach）。
     inflightReporter.detachSession();
+    // [event-push-channel W-P1] journal 推送通道随 session 终结：摘 ctx + 丢弃待推
+    // 缓冲（未推事件由消费方冷读/缺口补读收敛，不重推——设计 D5）。
+    journalReporter.detachSession();
 
     // ── workflow 域：terminate 所有 running run + store 收尾 + 清理 temp files ──
     // H-5: 遍历所有 sessionState 条目清理（而不只 lastSessionId——