@baique/pi-web-sky 0.1.59 → 0.1.60

package/.next/trace-build

@@ -1 +1 @@
-[{"name":"run-webpack","duration":11699804,"timestamp":191292283381,"id":14,"parentId":1,"tags":{},"startTime":1789900102827,"traceId":"cdfc6ca0ef3552f1"},{"name":"run-typescript","duration":5589684,"timestamp":191303984913,"id":809,"parentId":1,"tags":{},"startTime":1789900114529,"traceId":"cdfc6ca0ef3552f1"},{"name":"static-check","duration":2676964,"timestamp":191309588298,"id":812,"parentId":1,"tags":{},"startTime":1789900120132,"traceId":"cdfc6ca0ef3552f1"},{"name":"static-generation","duration":4034028,"timestamp":191312459363,"id":968,"parentId":1,"tags":{},"startTime":1789900123003,"traceId":"cdfc6ca0ef3552f1"},{"name":"collect-build-traces","duration":28313982,"timestamp":191312267468,"id":965,"parentId":1,"tags":{},"startTime":1789900122811,"traceId":"cdfc6ca0ef3552f1"},{"name":"telemetry-flush","duration":34,"timestamp":191340584252,"id":977,"parentId":1,"tags":{},"startTime":1789900151127,"traceId":"cdfc6ca0ef3552f1"},{"name":"next-build","duration":48482632,"timestamp":191292101660,"id":1,"tags":{"buildMode":"default","version":"16.3.1","bundler":"webpack","has-custom-webpack-config":"false","use-build-worker":"true"},"startTime":1789900102646,"traceId":"cdfc6ca0ef3552f1"}]
+[{"name":"run-webpack","duration":17112532,"timestamp":23154317271,"id":14,"parentId":1,"tags":{},"startTime":1789988434698,"traceId":"c2ff66a5e4c7d328"},{"name":"run-typescript","duration":7106132,"timestamp":23171432664,"id":821,"parentId":1,"tags":{},"startTime":1789988451813,"traceId":"c2ff66a5e4c7d328"},{"name":"static-check","duration":4315677,"timestamp":23178556343,"id":824,"parentId":1,"tags":{},"startTime":1789988458937,"traceId":"c2ff66a5e4c7d328"},{"name":"static-generation","duration":4932951,"timestamp":23183121940,"id":980,"parentId":1,"tags":{},"startTime":1789988463502,"traceId":"c2ff66a5e4c7d328"},{"name":"collect-build-traces","duration":31653292,"timestamp":23182874446,"id":977,"parentId":1,"tags":{},"startTime":1789988463255,"traceId":"c2ff66a5e4c7d328"},{"name":"telemetry-flush","duration":38,"timestamp":23214530709,"id":989,"parentId":1,"tags":{},"startTime":1789988494910,"traceId":"c2ff66a5e4c7d328"},{"name":"next-build","duration":60439935,"timestamp":23154090818,"id":1,"tags":{"buildMode":"default","version":"16.3.1","bundler":"webpack","has-custom-webpack-config":"false","use-build-worker":"true"},"startTime":1789988434472,"traceId":"c2ff66a5e4c7d328"}]

package/lib/transcript.test.mjs

@@ -0,0 +1,186 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url);
+const {
+  createTranscriptState,
+  transcriptReducer,
+  transcriptMessages,
+  transcriptEntryIds,
+} = await jiti.import("./transcript.ts");
+
+/** 造一条用户消息（提交时客户端自己的形态）。 */
+const user = (text, timestamp) => ({ role: "user", content: [{ type: "text", text }], timestamp });
+const assistant = (text, timestamp) => ({ role: "assistant", content: [{ type: "text", text }], timestamp });
+const system = (text, timestamp) => ({ role: "system", content: text, timestamp });
+
+/** 服务端窗口里的一条 entry。 */
+const entry = (entryId, message, parentId = null) => ({ entryId, parentId, message });
+
+const reduce = (state, ...actions) => actions.reduce(transcriptReducer, state);
+
+test("提交把消息作为 pending 条目放进列表，并给出稳定的客户端 id", () => {
+  const state = reduce(
+    createTranscriptState(),
+    { type: "submit", id: "c1", message: user("你好", 100), runId: 1, submittedAt: 100 },
+  );
+  assert.equal(state.items.length, 1);
+  assert.deepEqual(
+    { id: state.items[0].id, state: state.items[0].state, serverEntryId: state.items[0].serverEntryId },
+    { id: "c1", state: "pending", serverEntryId: null },
+  );
+  assert.deepEqual(transcriptMessages(state).map((m) => m.role), ["user"]);
+});
+
+// 回归：当前实现里 message_end(user) 只有在"乐观气泡刚好还在末尾"时才认它；
+// 中间夹一条别的 message_end 就会改走追加分支 → 界面上两个一样的用户气泡。
+test("回声到达时原地升级，绝不新增条目（即使前面先夹了一条 system）", () => {
+  let state = reduce(
+    createTranscriptState(),
+    { type: "submit", id: "c1", message: user("重复测试", 100), runId: 1, submittedAt: 100 },
+  );
+  // pi 先推一条 system（历史上就是把乐观气泡挤出末尾的那条）
+  state = reduce(state, { type: "server", message: system("system prompt 更新", 101) });
+  // 紧接着才是这条用户消息的回声
+  state = reduce(state, { type: "echo", runId: 1, message: user("重复测试", 102) });
+
+  assert.equal(state.items.filter((i) => i.message.role === "user").length, 1, "用户消息必须只有一条");
+  assert.equal(state.items[0].id, "c1", "必须是同一条目（id 不变 → 渲染不重挂）");
+  assert.equal(state.items[0].state, "confirmed");
+  assert.equal(state.items[0].serverEntryId, null, "回声不带 entryId，等合并时补");
+});
+
+test("合并服务端整表：同一位置沿用原条目 id，不新增、不重挂", () => {
+  let state = reduce(
+    createTranscriptState(),
+    { type: "submit", id: "c1", message: user("合并测试", 100), runId: 1, submittedAt: 100 },
+    { type: "echo", runId: 1, message: user("合并测试", 102) },
+    { type: "server", message: assistant("收到", 110) },
+  );
+  const idsBefore = state.items.map((i) => i.id);
+
+  state = reduce(state, {
+    type: "mergeTail",
+    entries: [
+      entry("e1", user("更早的问题", 10)),
+      entry("e2", assistant("更早的回答", 20)),
+      entry("e3", user("合并测试", 102), "e2"),
+      entry("e4", assistant("收到", 110), "e3"),
+    ],
+  });
+
+  assert.equal(state.items.filter((i) => i.message.role === "user").length, 2, "用户消息两条：历史一条 + 本次一条");
+  // 已存在的条目沿用原 id（命中位置不重挂），更早的历史作为新条目补在前面
+  assert.deepEqual(state.items.map((i) => i.id).slice(-2), idsBefore, "已存在的条目 id 一个都不能变");
+  assert.deepEqual(transcriptEntryIds(state), ["e1", "e2", "e3", "e4"]);
+  assert.ok(state.items.every((i) => i.state === "confirmed"));
+});
+
+// 回归：当前实现里 loadSession 整表替换会把还没落盘的乐观气泡抹掉（"消息消失、AI 直接开始回复"）。
+test("确认前合并：服务端还没有这一条，pending 条目原位保留", () => {
+  let state = reduce(
+    createTranscriptState(),
+    { type: "submit", id: "c1", message: user("还没落盘", 100), runId: 1, submittedAt: 100 },
+  );
+  state = reduce(state, {
+    type: "mergeTail",
+    entries: [entry("e1", user("历史问题", 10)), entry("e2", assistant("历史回答", 20))],
+  });
+
+  assert.equal(state.items.filter((i) => i.message.role === "user").length, 2);
+  const pending = state.items.find((i) => i.id === "c1");
+  assert.equal(pending?.state, "pending", "未确认的条目必须还在");
+  assert.equal(state.items[state.items.length - 1].id, "c1", "pending 排在末尾");
+});
+
+test("合并时空窗口不清空列表（避免瞬态空响应把界面刷白）", () => {
+  let state = reduce(
+    createTranscriptState(),
+    { type: "mergeTail", entries: [entry("e1", user("已有", 10))] },
+  );
+  state = reduce(state, { type: "mergeTail", entries: [] });
+  assert.equal(state.items.length, 1);
+});
+
+test("同文本两条 steer：各自认领，不互相替换、不丢", () => {
+  let state = reduce(
+    createTranscriptState(),
+    { type: "submit", id: "c1", message: user("同样的话", 100), runId: 1, submittedAt: 100 },
+  );
+  state = reduce(
+    state,
+    { type: "echo", runId: 1, message: user("同样的话", 102) },
+    { type: "submit", id: "c2", message: user("同样的话", 200), runId: 1, submittedAt: 200 },
+    { type: "echo", runId: 1, message: user("同样的话", 202) },
+  );
+  assert.deepEqual(state.items.map((i) => i.id), ["c1", "c2"]);
+  assert.equal(state.items.filter((i) => i.message.role === "user").length, 2);
+});
+
+test("没有本地回显的服务端用户消息（别的客户端/扩展发的）作为新条目追加", () => {
+  const state = reduce(
+    createTranscriptState(),
+    { type: "echo", runId: 3, message: user("来自别处", 500) },
+  );
+  assert.equal(state.items.length, 1);
+  assert.equal(state.items[0].state, "confirmed");
+});
+
+test("提交被拒：按 id 移除 pending，别的条目不受影响", () => {
+  let state = reduce(
+    createTranscriptState(),
+    { type: "mergeTail", entries: [entry("e1", assistant("历史", 10))] },
+    { type: "submit", id: "c1", message: user("被拒的消息", 100), runId: 1, submittedAt: 100 },
+  );
+  state = reduce(state, { type: "fail", id: "c1" });
+  assert.deepEqual(state.items.map((i) => i.id), [state.items[0].id]);
+  assert.equal(state.items.length, 1);
+  assert.equal(transcriptMessages(state)[0].role, "assistant");
+});
+
+test("更早一页 prepend：重复 prepend 同一页只算一次", () => {
+  let state = reduce(
+    createTranscriptState(),
+    { type: "mergeTail", entries: [entry("e3", user("最新", 30))] },
+  );
+  const older = [entry("e1", user("最早", 10)), entry("e2", assistant("中间", 20))];
+  state = reduce(state, { type: "prependOlder", entries: older });
+  const once = state.items.map((i) => i.serverEntryId);
+  state = reduce(state, { type: "prependOlder", entries: older });
+  assert.deepEqual(state.items.map((i) => i.serverEntryId), once, "同一页重复加载不得重复插入");
+  assert.equal(state.items.length, 3);
+});
+
+// 回归：回退（navigate_tree）/「编辑从此处」会把 leaf 移到更早的 entry，服务端窗口随之变短。
+// 旧的 loadSession 是整表替换，落在窗口之外的条目会消失；合并实现里必须同样把它们判为"离开当前分支"丢弃，
+// 否则回退后旧消息仍然留在消息流里。
+test("回退到更早的 leaf：窗口之外的已落盘条目必须消失，pending 保留", () => {
+  const e1 = entry("e1", user("第一问", 10));
+  const e2 = entry("e2", assistant("第一答", 20), "e1");
+  const e3 = entry("e3", user("第二问", 30), "e2");
+  const e4 = entry("e4", assistant("第二答", 40), "e3");
+
+  let state = reduce(
+    createTranscriptState(),
+    { type: "mergeTail", entries: [e1, e2, e3, e4] },
+    { type: "submit", id: "c1", message: user("新提交还没落盘", 500), runId: 2, submittedAt: 500 },
+  );
+  assert.equal(state.items.length, 5);
+
+  // 回退到 e2：服务端窗口只到 e2
+  state = reduce(state, { type: "mergeTail", entries: [e1, e2] });
+
+  assert.deepEqual(transcriptEntryIds(state).filter(Boolean), ["e1", "e2"], "离分支的 e3/e4 必须移除");
+  assert.deepEqual(state.items.map((i) => i.id).filter((id) => id.startsWith("srv")), ["srv:e1", "srv:e2"]);
+  assert.deepEqual(state.items.filter((i) => i.state === "pending").map((i) => i.id), ["c1"], "未落盘的提交不能被顺手丢掉");
+});
+
+test("切分支 reset：显式清空（唯一允许清空列表的动作）", () => {
+  let state = reduce(
+    createTranscriptState(),
+    { type: "submit", id: "c1", message: user("旧分支", 100), runId: 1, submittedAt: 100 },
+  );
+  state = reduce(state, { type: "reset" });
+  assert.equal(state.items.length, 0);
+});

package/lib/transcript.ts

@@ -0,0 +1,304 @@
+import type { AgentMessage } from "@/lib/types";
+
+/**
+ * 会话消息列表的单一 owner（纯函数 reducer）。
+ *
+ * 为什么要它：消息列表原先由 `messages` / `entryIds` / `parentIds` **三个并行数组**维护，
+ * 长度还刻意不一致（发送时先乐观追加 messages、entryIds 不动），于是"对齐"变成每个写入者的义务，
+ * 而"刚发出的消息是哪一个"只能靠「是不是最后一条 + 文本相等」去猜 —— 猜错就重复，被整表替换就消失，
+ * 身份变化就卸载重挂（闪烁）。上游 issue #23 / #24 就是同一类症状，当时的修法（乐观 key + 相邻判定）
+ * 是启发式补丁，我们 fork 时继承的就是那个形态。
+ *
+ * 这里的规矩只有两条：
+ *   1. 每条消息在列表里出现且仅出现一次；
+ *   2. 一条条目的身份（`id`）从创建到销毁不变 —— 渲染 key、滚动锚点、认领回声都用它，
+ *      服务端 entry id 只是落盘后挂上去的元数据。
+ *
+ * 所有"谁是谁"的判断都换成确定性依据：
+ *   - 已有 serverEntryId 的条目 ↔ 服务端窗口：按 entryId 配对；
+ *   - 无 serverEntryId 的条目（SSE 直接追加的、或回声后的 pending）：按 role + timestamp 配对；
+ *   - pending 用户条目 ↔ 服务端用户条目：按提交顺序 FIFO，且服务端 timestamp 不早于提交时刻。
+ * 不出现任何"文本相等"的猜测。
+ */
+
+export interface TranscriptItem {
+  /** 客户端 id：从创建到销毁不变（渲染 key 用它）。 */
+  id: string;
+  /** 服务端落盘后的 entry id；未落盘（pending / 仅经 SSE 到达）时为 null。 */
+  serverEntryId: string | null;
+  parentId: string | null;
+  message: AgentMessage;
+  /** pending = 已提交、尚未在服务端列表里确认；confirmed = 已确认（或不经本地回显直接到达）。 */
+  state: "pending" | "confirmed";
+  /** 提交时的运行序号（把回声认领回正确的 pending 条目）。 */
+  runId: number | null;
+  /** 提交时刻（ms）。合并时用它判断"服务端这条是不是我提交的那条"。 */
+  submittedAt: number;
+}
+
+/** 服务端窗口里的一条 entry（loadSession / loadContext 的返回形态）。 */
+export interface ServerEntry {
+  entryId: string;
+  parentId: string | null;
+  message: AgentMessage;
+}
+
+export interface TranscriptState {
+  items: TranscriptItem[];
+}
+
+export type TranscriptAction =
+  /** 用户提交一条消息（本地立即上屏，等回声确认）。 */
+  | { type: "submit"; id: string; message: AgentMessage; runId: number; submittedAt: number }
+  /** SSE message_end 到达的非用户消息（assistant / toolResult / system …），服务端已经产出。 */
+  | { type: "server"; message: AgentMessage }
+  /** SSE message_end 到达的用户消息：认领对应的 pending 条目并**原位升级**；没有 pending 才追加。 */
+  | { type: "echo"; runId: number; message: AgentMessage }
+  /** 服务端尾部窗口（loadSession）：按身份合并，pending 原位保留。 */
+  | { type: "mergeTail"; entries: ServerEntry[] }
+  /** 更早一页历史（loadContext before）：前置插入并按 entryId 去重。 */
+  | { type: "prependOlder"; entries: ServerEntry[] }
+  /** 提交被拒：按 id 移除该 pending。 */
+  | { type: "fail"; id: string }
+  /** 切换分支 / 会话：显式清空（唯一允许清空列表的动作）。 */
+  | { type: "reset" };
+
+export function createTranscriptState(): TranscriptState {
+  return { items: [] };
+}
+
+export function transcriptMessages(state: TranscriptState): AgentMessage[] {
+  return state.items.map((item) => item.message);
+}
+
+/** 与服务端 entry 一一对应；pending 条目为 null。 */
+export function transcriptEntryIds(state: TranscriptState): (string | null)[] {
+  return state.items.map((item) => item.serverEntryId);
+}
+
+export function transcriptParentIds(state: TranscriptState): (string | null)[] {
+  return state.items.map((item) => item.parentId);
+}
+
+/** 渲染用：条目 id 顺序（ChatWindow 的 key / 滚动锚点）。 */
+export function transcriptItemIds(state: TranscriptState): string[] {
+  return state.items.map((item) => item.id);
+}
+
+function timestampOf(message: AgentMessage): number | null {
+  const value = (message as { timestamp?: unknown }).timestamp;
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
+/** 无 entryId 的条目与服务端 entry 的确定性配对依据：角色 + 时间戳。 */
+function sameRoleAndTimestamp(a: AgentMessage, b: AgentMessage): boolean {
+  if (a.role !== b.role) return false;
+  const at = timestampOf(a);
+  const bt = timestampOf(b);
+  return at !== null && bt !== null && at === bt;
+}
+
+function confirmedFromEntry(entry: ServerEntry, id: string): TranscriptItem {
+  return {
+    id,
+    serverEntryId: entry.entryId,
+    parentId: entry.parentId,
+    message: entry.message,
+    state: "confirmed",
+    runId: null,
+    submittedAt: 0,
+  };
+}
+
+/**
+ * 尾部窗口合并。
+ *
+ * 语义与旧的 `loadSession` 一致（尾部窗口 + 保留已加载的更早历史），但：
+ *   - 命中已有条目的位置**沿用原 id**（不重挂、不闪）；
+ *   - 本地 pending 条目服务端还没落盘时**原位保留**（不消失）；
+ *   - 空窗口不动列表（避免瞬态空响应把界面刷白）。
+ */
+function mergeTail(state: TranscriptState, entries: ServerEntry[]): TranscriptState {
+  if (entries.length === 0) return state;
+
+  const items = state.items;
+  const claimedItem = new Set<number>();
+  const matchedItemByServerIdx = new Map<number, number>();
+
+  // ① 已有 entryId 的条目：按 entryId 配对
+  const itemIdxByEntryId = new Map<string, number>();
+  items.forEach((item, idx) => {
+    if (item.serverEntryId) itemIdxByEntryId.set(item.serverEntryId, idx);
+  });
+  entries.forEach((entry, serverIdx) => {
+    const itemIdx = itemIdxByEntryId.get(entry.entryId);
+    if (itemIdx === undefined || claimedItem.has(itemIdx)) return;
+    claimedItem.add(itemIdx);
+    matchedItemByServerIdx.set(serverIdx, itemIdx);
+  });
+
+  // ② 无 entryId 的条目（SSE 直接追加的 / 回声后的 pending）：按角色 + 时间戳配对
+  entries.forEach((entry, serverIdx) => {
+    if (matchedItemByServerIdx.has(serverIdx)) return;
+    const itemIdx = items.findIndex((item, idx) => (
+      !claimedItem.has(idx) && !item.serverEntryId && sameRoleAndTimestamp(item.message, entry.message)
+    ));
+    if (itemIdx === -1) return;
+    claimedItem.add(itemIdx);
+    matchedItemByServerIdx.set(serverIdx, itemIdx);
+  });
+
+  // ③ pending 用户条目 ↔ 未认领的服务端用户条目：提交顺序 FIFO，服务端时间不早于提交时刻
+  const pendingIdxList = items
+    .map((item, idx) => ({ item, idx }))
+    .filter(({ item, idx }) => item.state === "pending" && item.message.role === "user" && !claimedItem.has(idx))
+    .sort((a, b) => a.item.submittedAt - b.item.submittedAt)
+    .map(({ idx }) => idx);
+  entries.forEach((entry, serverIdx) => {
+    if (matchedItemByServerIdx.has(serverIdx) || entry.message.role !== "user") return;
+    const serverTimestamp = timestampOf(entry.message);
+    const itemIdx = pendingIdxList.find((idx) => (
+      !claimedItem.has(idx)
+      && (serverTimestamp === null || serverTimestamp >= items[idx].submittedAt)
+    ));
+    if (itemIdx === undefined) return;
+    claimedItem.add(itemIdx);
+    matchedItemByServerIdx.set(serverIdx, itemIdx);
+  });
+
+  // ④ 组装：锚点之前的本地条目 = 已加载的更早历史，原样保留在前。
+  // 没有锚点时不能把本地条目当"更早历史"——它们是还没落盘的 pending，应该接在窗口之后。
+  const hasAnchor = matchedItemByServerIdx.size > 0;
+  const anchorItemIdx = hasAnchor
+    ? Math.min(...matchedItemByServerIdx.values())
+    : Number.POSITIVE_INFINITY;
+
+  const out: TranscriptItem[] = [];
+  if (hasAnchor) {
+    items.forEach((item, idx) => {
+      if (idx < anchorItemIdx && !claimedItem.has(idx)) out.push(item);
+    });
+  }
+
+  const consumedItemIdx = new Set<number>();
+  for (let serverIdx = 0; serverIdx < entries.length; serverIdx++) {
+    const entry = entries[serverIdx];
+    const itemIdx = matchedItemByServerIdx.get(serverIdx);
+    if (itemIdx === undefined) {
+      out.push(confirmedFromEntry(entry, `srv:${entry.entryId}`));
+      continue;
+    }
+    const item = items[itemIdx];
+    consumedItemIdx.add(itemIdx);
+    // 原位升级：id 不变，只把服务端信息补上
+    out.push({
+      ...item,
+      serverEntryId: entry.entryId,
+      parentId: entry.parentId,
+      message: entry.message,
+      state: "confirmed",
+    });
+  }
+
+  // ⑤ 尾巴：只接回**还没落盘**的本地条目（pending / 仅经 SSE 到达）。
+  // 有 serverEntryId 却不在窗口里的，说明它们已不在当前 leaf 的分支上（回退 / 「编辑从此处」/ 切分支）——
+  // 服务端窗口是当前分支的权威尾部，这些必须丢弃；否则回退后旧消息会继续挂在消息流里。
+  items.forEach((item, idx) => {
+    if (consumedItemIdx.has(idx) || claimedItem.has(idx)) return;
+    if (item.serverEntryId) return;
+    if (hasAnchor && idx < anchorItemIdx) return; // 已在 ④ 前置保留
+    out.push(item);
+  });
+
+  return { items: out };
+}
+
+function prependOlder(state: TranscriptState, entries: ServerEntry[]): TranscriptState {
+  if (entries.length === 0) return state;
+  const known = new Set(state.items.map((item) => item.serverEntryId).filter(Boolean) as string[]);
+  const fresh = entries.filter((entry) => !known.has(entry.entryId));
+  if (fresh.length === 0) return state;
+  return {
+    items: [
+      ...fresh.map((entry) => confirmedFromEntry(entry, `srv:${entry.entryId}`)),
+      ...state.items,
+    ],
+  };
+}
+
+export function transcriptReducer(state: TranscriptState, action: TranscriptAction): TranscriptState {
+  switch (action.type) {
+    case "submit":
+      return {
+        items: [...state.items, {
+          id: action.id,
+          serverEntryId: null,
+          parentId: null,
+          message: action.message,
+          state: "pending",
+          runId: action.runId,
+          submittedAt: action.submittedAt,
+        }],
+      };
+
+    case "server":
+      return {
+        items: [...state.items, {
+          id: `srv-live:${state.items.length}:${action.message.role}`,
+          serverEntryId: null,
+          parentId: null,
+          message: action.message,
+          state: "confirmed",
+          runId: null,
+          submittedAt: 0,
+        }],
+      };
+
+    case "echo": {
+      // 认领：优先同一 run 的 pending，其次最早的 pending（FIFO）
+      const pending = state.items
+        .map((item, idx) => ({ item, idx }))
+        .filter(({ item }) => item.state === "pending" && item.message.role === "user")
+        .sort((a, b) => a.item.submittedAt - b.item.submittedAt);
+      const target = pending.find(({ item }) => item.runId === action.runId) ?? pending[0];
+      if (target) {
+        // 原位升级：id 不变 → 渲染不重挂；服务端内容为准
+        const items = [...state.items];
+        items[target.idx] = {
+          ...target.item,
+          message: action.message,
+          state: "confirmed",
+          runId: action.runId,
+        };
+        return { items };
+      }
+      // 没有本地回显（别的客户端/扩展发的）→ 作为新条目追加
+      return {
+        items: [...state.items, {
+          id: `echo:${action.runId}:${state.items.length}`,
+          serverEntryId: null,
+          parentId: null,
+          message: action.message,
+          state: "confirmed",
+          runId: action.runId,
+          submittedAt: 0,
+        }],
+      };
+    }
+
+    case "mergeTail":
+      return mergeTail(state, action.entries);
+
+    case "prependOlder":
+      return prependOlder(state, action.entries);
+
+    case "fail":
+      return { items: state.items.filter((item) => item.id !== action.id) };
+
+    case "reset":
+      return { items: [] };
+
+    default:
+      return state;
+  }
+}

package/lib/turn-merge.ts

@@ -71,7 +71,7 @@ export function getAssistantAnswerMarkdown(message: AgentMessage | Partial<Agent
  */
 export function buildDomTurns(
   allMessages: (AgentMessage | Partial<AgentMessage>)[],
-  entryIds: string[],
+  entryIds: (string | null)[],
 ): DomTurn[] {
   const turns: DomTurn[] = [];
   let current: DomTurn | null = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@baique/pi-web-sky",
-  "version": "0.1.59",
+  "version": "0.1.60",
   "description": "Web UI for the pi coding agent — Sky skin edition (fork of @agegr/pi-web / earendil-labs pi-web, MIT)",
   "homepage": "https://github.com/baique/pi-web-sky#readme",
   "repository": {