canopy-ui 0.4.0 → 0.6.1

package/src/chat/pairToolMessages.test.ts

@@ -118,6 +118,110 @@ describe("pairToolMessages", () => {
     );
     expect(pending).toHaveLength(2);
   });
+
+  // The case this feature exists for: two tool calls in flight at once (Claude
+  // does this routinely). Their tool_start events land back-to-back, both
+  // still open, before either tool_end arrives — a flat order-based pairing
+  // would have no way to tell which result belongs to which call. The
+  // results also arrive OUT OF ORDER (second call finishes first), which
+  // order-based pairing would get flatly wrong.
+  it("pairs overlapping (parallel) tool calls by id, including out-of-order results", () => {
+    const rows = pairToolMessages([
+      msg({
+        id: "1", role: "tool_use",
+        content: { id: "call-a", name: "Bash", input: { command: "sleep 10" } },
+      }),
+      msg({
+        id: "2", role: "tool_use",
+        content: { id: "call-b", name: "Read", input: { file_path: "/x" } },
+      }),
+      // call-b finishes first even though call-a started first.
+      msg({ id: "3", role: "tool_result", content: { tool_use_id: "call-b" }, plaintext: "file contents" }),
+      msg({ id: "4", role: "tool_result", content: { tool_use_id: "call-a" }, plaintext: "done sleeping" }),
+    ]);
+    expect(rows).toHaveLength(2);
+    expect(rows[0].kind).toBe("tool_pair");
+    expect(rows[1].kind).toBe("tool_pair");
+    if (rows[0].kind === "tool_pair" && rows[1].kind === "tool_pair") {
+      expect(rows[0].use.id).toBe("1");
+      expect(rows[0].result?.id).toBe("4"); // call-a's result, not the earlier-arriving one
+      expect(rows[1].use.id).toBe("2");
+      expect(rows[1].result?.id).toBe("3"); // call-b's result
+    }
+  });
+
+  // Two overlapping calls to the SAME tool name — order/name matching alone
+  // is ambiguous here (that's the whole point of the id); only tool_use_id
+  // disambiguates which result goes with which call.
+  it("pairs two overlapping calls with the same tool name by id", () => {
+    const rows = pairToolMessages([
+      msg({
+        id: "1", role: "tool_use",
+        content: { id: "call-1", name: "Bash", input: { command: "echo one" } },
+      }),
+      msg({
+        id: "2", role: "tool_use",
+        content: { id: "call-2", name: "Bash", input: { command: "echo two" } },
+      }),
+      msg({ id: "3", role: "tool_result", content: { tool_use_id: "call-2" }, plaintext: "two" }),
+      msg({ id: "4", role: "tool_result", content: { tool_use_id: "call-1" }, plaintext: "one" }),
+    ]);
+    expect(rows).toHaveLength(2);
+    if (rows[0].kind === "tool_pair" && rows[1].kind === "tool_pair") {
+      expect(rows[0].use.id).toBe("1");
+      expect(rows[0].result?.id).toBe("4");
+      expect(rows[0].result?.plaintext).toBe("one");
+      expect(rows[1].use.id).toBe("2");
+      expect(rows[1].result?.id).toBe("3");
+      expect(rows[1].result?.plaintext).toBe("two");
+    }
+  });
+
+  // Backward compatibility: events with no correlation id at all (older
+  // ledger rows, or a runner that hasn't been updated yet) must still pair —
+  // falling back to the pre-id FIFO order heuristic.
+  it("falls back to FIFO order pairing when neither side carries an id", () => {
+    const rows = pairToolMessages([
+      msg({ id: "1", role: "tool_use", content: { name: "Bash" } }),
+      msg({ id: "2", role: "tool_use", content: { name: "Read" } }),
+      msg({ id: "3", role: "tool_result", plaintext: "first result" }),
+      msg({ id: "4", role: "tool_result", plaintext: "second result" }),
+    ]);
+    expect(rows).toHaveLength(2);
+    if (rows[0].kind === "tool_pair" && rows[1].kind === "tool_pair") {
+      expect(rows[0].use.id).toBe("1");
+      expect(rows[0].result?.id).toBe("3");
+      expect(rows[1].use.id).toBe("2");
+      expect(rows[1].result?.id).toBe("4");
+    }
+  });
+
+  // The real production shape: a session whose earlier turns predate the
+  // tool_use_id field (no ids) followed by a later turn from an updated
+  // producer (has ids) — both must pair correctly, and the id-less fallback
+  // queue must not accidentally absorb an id-tagged result or vice versa.
+  it("pairs correctly across a mixed stream (legacy no-id turn followed by an id-tagged turn)", () => {
+    const rows = pairToolMessages([
+      // Legacy turn: no ids at all.
+      msg({ id: "1", role: "tool_use", content: { name: "Bash" } }),
+      msg({ id: "2", role: "tool_result", plaintext: "legacy result" }),
+      // Newer turn: two parallel calls, correlated by id.
+      msg({ id: "3", role: "tool_use", content: { id: "new-a", name: "Bash" } }),
+      msg({ id: "4", role: "tool_use", content: { id: "new-b", name: "Bash" } }),
+      msg({ id: "5", role: "tool_result", content: { tool_use_id: "new-b" }, plaintext: "b done" }),
+      msg({ id: "6", role: "tool_result", content: { tool_use_id: "new-a" }, plaintext: "a done" }),
+    ]);
+    expect(rows).toHaveLength(3);
+    expect(rows.every((r) => r.kind === "tool_pair")).toBe(true);
+    if (rows[0].kind === "tool_pair" && rows[1].kind === "tool_pair" && rows[2].kind === "tool_pair") {
+      expect(rows[0].use.id).toBe("1");
+      expect(rows[0].result?.id).toBe("2");
+      expect(rows[1].use.id).toBe("3");
+      expect(rows[1].result?.id).toBe("6"); // new-a's result
+      expect(rows[2].use.id).toBe("4");
+      expect(rows[2].result?.id).toBe("5"); // new-b's result
+    }
+  });
 });
 
 describe("deriveToolStatus", () => {
@@ -206,3 +310,51 @@ describe("toolPreview / toolDisplayName", () => {
     expect(toolDisplayName(use)).toBe("drive_create_file");
   });
 });
+
+describe("stale pending rows", () => {
+  const pendingUse = (id: string): Message => ({
+    id: `live-${id}`, turn_index: -1, role: "tool_use",
+    content: { id, name: "Bash", status: "pending" }, plaintext: "",
+    status: "complete", error_detail: null, started_at: null, completed_at: null,
+    created_at: "",
+  })
+  const text = (id: string): Message => ({
+    id, turn_index: 10, role: "assistant", content: {}, plaintext: "done",
+    status: "complete", error_detail: null, started_at: null, completed_at: null,
+    created_at: "",
+  })
+  const resultFor = (id: string): Message => ({
+    id: `r-${id}`, turn_index: 20, role: "tool_result",
+    content: { tool_use_id: id }, plaintext: "out",
+    status: "complete", error_detail: null, started_at: null, completed_at: null,
+    created_at: "",
+  })
+
+  it("keeps a pending row while it is the newest thing — it IS running", () => {
+    const rows = pairToolMessages([text("a"), pendingUse("t1")])
+    expect(rows).toHaveLength(2)
+    expect(rows[1]).toMatchObject({ kind: "tool_pair", result: null })
+  })
+
+  it("drops a pending row once later activity proves it is not in flight", () => {
+    // The live bug: PreToolUse fired, its PostToolUse never arrived, and the row
+    // rendered "running…" forever — while a reload showed nothing, because the
+    // durable transcript never had it.
+    const rows = pairToolMessages([pendingUse("t1"), text("a")])
+    expect(rows).toHaveLength(1)
+    expect(rows[0].kind).toBe("message")
+  })
+
+  it("keeps a pending row whose result DID arrive, so the pair renders", () => {
+    const rows = pairToolMessages([pendingUse("t1"), resultFor("t1"), text("a")])
+    const pair = rows.find((r) => r.kind === "tool_pair")
+    expect(pair).toBeDefined()
+    expect((pair as { result: Message | null }).result).not.toBeNull()
+  })
+
+  it("leaves ordinary completed tool rows untouched", () => {
+    const done: Message = { ...pendingUse("t9"), content: { id: "t9", name: "Bash" } }
+    const rows = pairToolMessages([done, resultFor("t9"), text("a")])
+    expect(rows.filter((r) => r.kind === "tool_pair")).toHaveLength(1)
+  })
+})

package/src/chat/pairToolMessages.ts

@@ -4,15 +4,27 @@ import type { Message } from "./protocol";
  * A renderable row in the chat: either a single message (user / assistant /
  * standalone tool, etc.) or a paired tool_use + tool_result.
  *
- * Pairing rule: a ``tool_use`` row is paired with the FIRST subsequent
- * ``tool_result`` whose ``content.tool_use_id`` matches the ``tool_use``'s
- * ``content.id``. If no matching result exists yet (the turn is still
- * streaming), the row is rendered as a tool-pair with ``result === null``
- * — UI shows that as the "pending" state.
+ * Pairing rule, id-first with an order-based fallback: a ``tool_use`` row is
+ * paired with the FIRST subsequent ``tool_result`` whose ``content.tool_use_id``
+ * matches the ``tool_use``'s ``content.id``, when both carry one. Correlation
+ * ids are what make this unambiguous — with **parallel** tool calls (routine
+ * for Claude) or two calls sharing a name, a flat tool_start/tool_end stream
+ * has no other way to tell which result belongs to which call.
  *
- * Unpaired ``tool_result`` rows (no preceding ``tool_use`` with a matching
- * id — shouldn't happen in practice, but defend) fall through as standalone
- * messages so we never silently drop content.
+ * Not every producer stamps ids yet: events already in the ledger predate
+ * this field, and some runners (see `packages/canopy_runner`) don't emit it
+ * until updated separately. When a ``tool_result`` carries no id at all, it
+ * falls back to the FIRST still-open ``tool_use`` that *also* has no id
+ * (oldest-first, FIFO) — today's pre-correlation pairing heuristic. That
+ * fallback queue is tracked separately from the id map, so an id-tagged
+ * stream and a legacy no-id stream can be interleaved (e.g. older turns in
+ * the same session predating the id, followed by newer ones that have it)
+ * without cross-pairing into each other.
+ *
+ * Unpaired ``tool_result`` rows (an id that matches no pending ``tool_use``,
+ * or no id and nothing left in the no-id fallback queue — shouldn't happen
+ * in practice, but defend) fall through as standalone messages so we never
+ * silently drop content.
  */
 export type ChatRow =
   | { kind: "message"; message: Message; key: string }
@@ -21,20 +33,61 @@ export type ChatRow =
 function toolUseId(message: Message): string | null {
   const content = message.content as Record<string, unknown> | undefined;
   const id = content?.id;
-  return typeof id === "string" ? id : null;
+  return typeof id === "string" && id !== "" ? id : null;
 }
 
 function toolResultId(message: Message): string | null {
   const content = message.content as Record<string, unknown> | undefined;
   const id = content?.tool_use_id;
-  return typeof id === "string" ? id : null;
+  return typeof id === "string" && id !== "" ? id : null;
+}
+
+/**
+ * A pending live row (`status: "pending"` from PreToolUse, no ordinal) is a
+ * PLACEHOLDER. It is meant to be replaced when its result arrives — but if that
+ * never lands (the turn ended, the runner stopped streaming, a hook was dropped),
+ * it strands a row rendering "running…" forever, which reads as an agent stuck
+ * mid-call. Observed live 2026-07-27: one orphan row per turn, and it vanished on
+ * reload because the durable transcript never contained it.
+ *
+ * A pending row is therefore dropped once ANY later row exists — later activity
+ * is proof that whatever it was waiting on is no longer in flight. It survives
+ * only while it is genuinely the newest thing in the session, which is exactly
+ * when "running…" is true.
+ */
+function dropStaleLiveRows(messages: Message[]): Message[] {
+  const lastIndex = messages.length - 1;
+  return messages.filter((m, i) => {
+    if (m.role !== "tool_use") return true;
+    const content = m.content as Record<string, unknown> | undefined;
+    if (content?.status !== "pending") return true;
+    const id = typeof content.id === "string" ? content.id : null;
+    // Its result arrived — the pair will render normally, keep it.
+    if (
+      id &&
+      messages.some(
+        (o) =>
+          o.role === "tool_result" &&
+          (o.content as Record<string, unknown> | undefined)?.tool_use_id === id,
+      )
+    ) {
+      return true;
+    }
+    // Still the newest row: genuinely in flight.
+    return i === lastIndex;
+  });
 }
 
 export function pairToolMessages(messages: Message[]): ChatRow[] {
+  messages = dropStaleLiveRows(messages);
   const rows: ChatRow[] = [];
   // Map of tool_use_id → index into rows[] for that pair. Lets a tool_result
   // arriving later in the stream slot itself into the existing pair row.
   const pendingByToolId = new Map<string, number>();
+  // FIFO fallback queue of row indices for tool_use rows with NO id — the
+  // pre-correlation pairing heuristic, kept alive for producers/ledger rows
+  // that predate tool_use_id.
+  const pendingNoId: number[] = [];
 
   for (const m of messages) {
     if (m.role === "tool_use") {
@@ -46,8 +99,11 @@ export function pairToolMessages(messages: Message[]): ChatRow[] {
         key: `pair-${m.id}`,
       };
       rows.push(row);
+      const idx = rows.length - 1;
       if (id !== null) {
-        pendingByToolId.set(id, rows.length - 1);
+        pendingByToolId.set(id, idx);
+      } else {
+        pendingNoId.push(idx);
       }
       continue;
     }
@@ -63,10 +119,30 @@ export function pairToolMessages(messages: Message[]): ChatRow[] {
             continue;
           }
         }
+        // An id that matches no pending id-tagged use — a genuine ghost,
+        // never absorbed by the no-id fallback queue (that queue is for
+        // results that carry no id of their own, not for stray ids).
+        rows.push({ kind: "message", message: m, key: `msg-${m.id}` });
+        continue;
+      }
+      // No id on the result at all — fall back to the oldest still-open
+      // no-id tool_use (order-based pairing, same as before correlation
+      // ids existed).
+      let paired = false;
+      while (pendingNoId.length > 0) {
+        const idx = pendingNoId.shift() as number;
+        const row = rows[idx];
+        if (row.kind === "tool_pair" && row.result === null) {
+          rows[idx] = { ...row, result: m };
+          paired = true;
+          break;
+        }
+      }
+      if (!paired) {
+        // Nothing left in the fallback queue to pair with — standalone so
+        // content isn't silently dropped.
+        rows.push({ kind: "message", message: m, key: `msg-${m.id}` });
       }
-      // Fallthrough: no preceding tool_use match — show standalone so
-      // content isn't silently dropped.
-      rows.push({ kind: "message", message: m, key: `msg-${m.id}` });
       continue;
     }
     rows.push({ kind: "message", message: m, key: `msg-${m.id}` });

package/src/chat/protocol.ts

@@ -62,6 +62,10 @@ export interface Participant {
 
 export interface SessionState {
   messages: Message[];
+  /** Live agent activity, from the runner's turn-boundary hooks. Undefined when
+   *  no hook has reported yet — the caller then falls back to the server's
+   *  coarser `running` flag. */
+  activity?: "working" | "idle";
   active_draft: Draft | null;
   participants: Participant[];
   presence_user_ids: number[];
@@ -85,9 +89,18 @@ export type WsEvent =
   | { event: "session.error"; data: { code: string; message: string; detail?: unknown } }
   | { event: "session.title_updated"; data: { title: string } }
   | { event: "chat.stream_start"; data: { message_id: string; turn_index: number } }
+  // The agent started or finished a turn. Distinct from tool events: it fires
+  // while Claude is THINKING, before any content exists to show.
+  | { event: "session.activity"; data: { state: "working" | "idle" } }
+  // A human typed into emdash rather than into this page. No client echoed it,
+  // so this is the only way it reaches the browser before a reload.
+  | { event: "chat.user_message"; data: { message_id: string; turn_index: number; plaintext: string } }
   | { event: "chat.delta"; data: { message_id: string; text: string } }
-  | { event: "chat.tool_use"; data: { parent_message_id: string | null; tool_message_id: string; block: Record<string, unknown> } }
-  | { event: "chat.tool_result"; data: { parent_message_id: string | null; tool_message_id: string; block: Record<string, unknown> } }
+  // `turn_index` is the row's transcript ordinal — the same key the persisted
+  // Message carries, so a live tool row sorts into exactly the position it will
+  // occupy after a reload. Optional: an older server omits it.
+  | { event: "chat.tool_use"; data: { parent_message_id: string | null; tool_message_id: string; turn_index?: number; block: Record<string, unknown> } }
+  | { event: "chat.tool_result"; data: { parent_message_id: string | null; tool_message_id: string; turn_index?: number; block: Record<string, unknown> } }
   | { event: "chat.stream_complete"; data: { message_id: string; plaintext: string } }
   | { event: "chat.stream_error"; data: { message_id: string; detail: string } }
   | { event: "chat.stream_cancelled"; data: { message_id: string | null; partial_len: number } }

package/src/chat/sessionReducer.test.ts

@@ -122,13 +122,86 @@ describe("sessionReducer — chat stream", () => {
     expect(next.messages[0].error_detail).toMatch(/142/)
   })
 
-  it("chat.tool_use is a no-op", () => {
+  it("chat.tool_use appends a tool row carrying the block as its content", () => {
+    // The block IS the content the UI pairs and renders on — dropping the
+    // frame (the old no-op) meant a running agent's tool calls only appeared
+    // after a manual reload, which is precisely when you want to see them.
     const prev = makeState({ messages: [makeMessage()] })
+    const next = sessionReducer(prev, {
+      event: "chat.tool_use",
+      data: {
+        parent_message_id: null,
+        tool_message_id: "seq:64",
+        turn_index: 64,
+        block: { id: "toolu_1", name: "Bash", input: { command: "ls" }, text: "" },
+      },
+    } as WsEvent)
+    expect(next.messages).toHaveLength(2)
+    const row = next.messages[1]
+    expect(row.role).toBe("tool_use")
+    expect(row.id).toBe("seq:64")
+    expect(row.turn_index).toBe(64)
+    expect(row.content).toEqual({
+      id: "toolu_1",
+      name: "Bash",
+      input: { command: "ls" },
+      text: "",
+    })
+  })
+
+  it("chat.tool_result carries the result body as plaintext", () => {
+    const prev = makeState({ messages: [] })
+    const next = sessionReducer(prev, {
+      event: "chat.tool_result",
+      data: {
+        parent_message_id: null,
+        tool_message_id: "seq:128",
+        turn_index: 128,
+        block: { tool_use_id: "toolu_1", is_error: false, text: "a.txt" },
+      },
+    } as WsEvent)
+    expect(next.messages[0].role).toBe("tool_result")
+    expect(next.messages[0].plaintext).toBe("a.txt")
+    expect(next.messages[0].status).toBe("complete")
+  })
+
+  it("a failed tool result is marked error so the pair renders as one", () => {
+    const next = sessionReducer(makeState(), {
+      event: "chat.tool_result",
+      data: {
+        parent_message_id: null,
+        tool_message_id: "seq:128",
+        turn_index: 128,
+        block: { tool_use_id: "toolu_1", is_error: true, text: "boom" },
+      },
+    } as WsEvent)
+    expect(next.messages[0].status).toBe("error")
+  })
+
+  it("a re-delivered tool frame upserts instead of doubling the row", () => {
+    // Reconnect catch-up and a retried post both re-ship rows; a duplicated
+    // tool_use would leave one copy permanently stuck showing "running…".
+    const frame = {
+      event: "chat.tool_use",
+      data: {
+        parent_message_id: null,
+        tool_message_id: "seq:64",
+        turn_index: 64,
+        block: { id: "toolu_1", name: "Bash", input: {}, text: "" },
+      },
+    } as WsEvent
+    const once = sessionReducer(makeState(), frame)
+    const twice = sessionReducer(once, frame)
+    expect(twice.messages).toHaveLength(1)
+  })
+
+  it("a tool frame without an ordinal still lands after the newest row", () => {
+    const prev = makeState({ messages: [makeMessage({ turn_index: 7 })] })
     const next = sessionReducer(prev, {
       event: "chat.tool_use",
       data: { parent_message_id: null, tool_message_id: "t1", block: {} },
     } as WsEvent)
-    expect(next).toBe(prev)
+    expect(next.messages[1].turn_index).toBe(8)
   })
 })
 
@@ -282,3 +355,187 @@ describe("sessionReducer — session.error draft_version_mismatch", () => {
     expect(next).toBe(prev)
   })
 })
+
+describe("sessionReducer — live/durable reconciliation", () => {
+  const liveToolUse = {
+    event: "chat.tool_use",
+    data: {
+      parent_message_id: null,
+      tool_message_id: "seq:-1",
+      turn_index: -1,
+      block: { id: "toolu_9", name: "Bash", input: { command: "ls" }, text: "" },
+    },
+  } as WsEvent
+
+  const durableToolUse = {
+    event: "chat.tool_use",
+    data: {
+      parent_message_id: null,
+      tool_message_id: "42",
+      turn_index: 128,
+      block: { id: "toolu_9", name: "Bash", input: { command: "ls" }, text: "" },
+    },
+  } as WsEvent
+
+  it("a durable row REPLACES the live placeholder for the same tool call", () => {
+    // The same call arrives twice by design — live from a hook (no ordinal) and
+    // durably from the transcript. They share only tool_use_id, so without
+    // reconciling on it the user sees every tool call twice.
+    const live = sessionReducer(makeState(), liveToolUse)
+    expect(live.messages).toHaveLength(1)
+    const settled = sessionReducer(live, durableToolUse)
+    expect(settled.messages).toHaveLength(1)
+  })
+
+  it("the surviving row takes the durable identity, not the placeholder's", () => {
+    // Otherwise later updates key on a `seq:-1` that no longer means anything.
+    const settled = sessionReducer(
+      sessionReducer(makeState(), liveToolUse),
+      durableToolUse,
+    )
+    expect(settled.messages[0].id).toBe("42")
+    expect(settled.messages[0].turn_index).toBe(128)
+  })
+
+  it("reconciles tool_result on tool_use_id too", () => {
+    const mk = (id: string, turn_index: number) =>
+      ({
+        event: "chat.tool_result",
+        data: {
+          parent_message_id: null,
+          tool_message_id: id,
+          turn_index,
+          block: { tool_use_id: "toolu_9", is_error: false, text: "a.txt" },
+        },
+      }) as WsEvent
+    const settled = sessionReducer(
+      sessionReducer(makeState(), mk("seq:-1", -1)),
+      mk("77", 192),
+    )
+    expect(settled.messages).toHaveLength(1)
+    expect(settled.messages[0].id).toBe("77")
+  })
+
+  it("two different tool calls stay two rows", () => {
+    const other = {
+      event: "chat.tool_use",
+      data: {
+        parent_message_id: null,
+        tool_message_id: "seq:-1b",
+        turn_index: -1,
+        block: { id: "toolu_OTHER", name: "Read", input: {}, text: "" },
+      },
+    } as WsEvent
+    const next = sessionReducer(sessionReducer(makeState(), liveToolUse), other)
+    expect(next.messages).toHaveLength(2)
+  })
+
+  it("a row with no correlation id still falls back to matching on message id", () => {
+    const noId = {
+      event: "chat.tool_use",
+      data: { parent_message_id: null, tool_message_id: "t1", block: {} },
+    } as WsEvent
+    const next = sessionReducer(sessionReducer(makeState(), noId), noId)
+    expect(next.messages).toHaveLength(1)
+  })
+})
+
+describe("sessionReducer — pending → complete lifecycle", () => {
+  const mk = (status: string, id = "seq:-1") =>
+    ({
+      event: "chat.tool_use",
+      data: {
+        parent_message_id: null,
+        tool_message_id: id,
+        turn_index: -1,
+        block: { id: "toolu_LIVE", name: "Bash", input: { command: "npm test" }, status, text: "" },
+      },
+    }) as WsEvent
+
+  it("a pending row from PreToolUse appears immediately, with no result", () => {
+    // The whole point: a long tool call should read as RUNNING, not as nothing
+    // happening. Before PreToolUse was forwarded, the row only appeared once the
+    // call had already finished.
+    const next = sessionReducer(makeState(), mk("pending"))
+    expect(next.messages).toHaveLength(1)
+    expect(next.messages[0].role).toBe("tool_use")
+    expect(next.messages[0].content.status).toBe("pending")
+    // No tool_result row — that's what makes ToolCallPair render "running…".
+    expect(next.messages.some((m) => m.role === "tool_result")).toBe(false)
+  })
+
+  it("the completed row REPLACES the pending one rather than doubling it", () => {
+    const pending = sessionReducer(makeState(), mk("pending"))
+    const done = sessionReducer(pending, mk("complete", "seq:-1"))
+    expect(done.messages).toHaveLength(1)
+    expect(done.messages[0].content.status).toBe("complete")
+  })
+
+  it("the durable transcript row then supersedes both", () => {
+    // Three deliveries of one call — pending hook, completed hook, transcript —
+    // must converge on a single row carrying the durable identity.
+    const durable = {
+      event: "chat.tool_use",
+      data: {
+        parent_message_id: null,
+        tool_message_id: "991",
+        turn_index: 4096,
+        block: { id: "toolu_LIVE", name: "Bash", input: { command: "npm test" }, text: "" },
+      },
+    } as WsEvent
+    const settled = sessionReducer(
+      sessionReducer(sessionReducer(makeState(), mk("pending")), mk("complete")),
+      durable,
+    )
+    expect(settled.messages).toHaveLength(1)
+    expect(settled.messages[0].id).toBe("991")
+    expect(settled.messages[0].turn_index).toBe(4096)
+  })
+})
+
+describe("sessionReducer — a web send arriving twice", () => {
+  it("does not render the same message twice at two different ordinals", () => {
+    // THE live bug (2026-07-27): a web send writes its row at a DENSE index
+    // (_next_index), then the agent reads it and the transcript re-ships the
+    // same text at a COMPOSITE ordinal. Different index, different id, so
+    // matching on turn_index alone missed and the message appeared twice — while
+    // a reload showed it once, because get_or_create dedupes server-side.
+    const seeded = makeState({
+      messages: [
+        makeMessage({ id: "501", turn_index: 37, role: "user", plaintext: "try one more time" }),
+      ],
+    })
+    const fromTranscript = {
+      event: "chat.user_message",
+      data: { message_id: "902", turn_index: 144448, plaintext: "try one more time" },
+    } as WsEvent
+    const next = sessionReducer(seeded, fromTranscript)
+    expect(next.messages).toHaveLength(1)
+    // And it adopts the durable ordinal, so it sorts where a reload puts it.
+    expect(next.messages[0].turn_index).toBe(144448)
+    expect(next.messages[0].id).toBe("902")
+  })
+
+  it("a genuine repeat sent much later is still its own row", () => {
+    // The dedupe must not swallow real repetition — only the tail is compared.
+    const many = Array.from({ length: 9 }, (_, i) =>
+      makeMessage({ id: `u${i}`, turn_index: i, role: "user", plaintext: i === 0 ? "yes" : `m${i}` }),
+    )
+    const next = sessionReducer(makeState({ messages: many }), {
+      event: "chat.user_message",
+      data: { message_id: "new", turn_index: 500, plaintext: "yes" },
+    } as WsEvent)
+    expect(next.messages).toHaveLength(10)
+  })
+
+  it("an empty-text frame never collapses onto another empty row", () => {
+    const seeded = makeState({
+      messages: [makeMessage({ id: "1", turn_index: 1, role: "user", plaintext: "" })],
+    })
+    const next = sessionReducer(seeded, {
+      event: "chat.user_message",
+      data: { message_id: "2", turn_index: 2, plaintext: "" },
+    } as WsEvent)
+    expect(next.messages).toHaveLength(2)
+  })
+})