This is a comment left during a code review.
Path: ui/src/ui/app-tool-stream.ts
Line: 443-455

Comment:
**`startsWith` check breaks on third+ segments**

The deduplication logic only works correctly for the first two text segments (one tool-call interruption). For any subsequent text segment, `lastText` holds a **delta** string (e.g. `" world"`) rather than the cumulative prefix of `host.chatStream`, so the `startsWith` check always fails and the `else if` branch falls through, committing the full cumulative text instead of just the new portion.

Concrete trace with two tool-call interruptions:
1. Tool call 1: `chatStream = "Hello"`, `lastText = ""` → `startsWith("") = true` → segment[0] = `"Hello"` ✓  
2. Tool call 2: `chatStream = "Hello world"`, `lastText = "Hello"` → `startsWith("Hello") = true` → segment[1] = `" world"` ✓  
3. Tool call 3: `chatStream = "Hello world, how"`, `lastText = " world"` (a delta!) → `"Hello world, how".startsWith(" world") = false` → **else if fires → segment[2] = `"Hello world, how"`** (full cumulative text, duplicating earlier content) ✗

The fix only holds when there is exactly one tool-call interruption. Any response with two or more text→tool→text→tool→text sequences will re-introduce the duplication bug the PR set out to fix.

A robust solution is to track the total committed character count by summing all prior segment lengths:

```typescript
const committedLength = host.chatStreamSegments.reduce(
  (sum, seg) => sum + seg.text.length,
  0,
);
const newText = host.chatStream.slice(committedLength);
if (newText.trim().length > 0) {
  host.chatStreamSegments = [...host.chatStreamSegments, { text: newText, ts: now }];
}
```

This is O(n) on the number of segments (small) but eliminates the fragile string-prefix assumption entirely.

How can I resolve this? If you propose a fix, please make it concise.

---

This is a comment left during a code review.
Path: ui/src/ui/app-tool-stream.ts
Line: 438-458

Comment:
**No test coverage for multi-segment deduplication**

The test file `app-tool-stream.node.test.ts` only covers fallback/lifecycle events. There are currently no tests for the segment-deduplication behaviour introduced by this fix — the very logic that was supposed to cure the duplicate-bubble regression. 

Adding a test that exercises the text→tool→text→tool→text path (3+ segments) would have caught the `startsWith` edge case described in the adjacent comment, and will guard against future regressions. Consider adding a test like:

```typescript
it("stores only the delta for each text segment across multiple tool interruptions", () => {
  const host = createHost({ chatRunId: "run-1", sessionKey: "main" });
  const toolEvent = (toolCallId: string, chatStream: string) => ({
    runId: "run-1", seq: 1, stream: "tool", ts: Date.now(), sessionKey: "main",
    data: { toolCallId, name: "tool", phase: "start", args: {} },
    // prime the stream before each tool call
    _chatStream: chatStream,
  });

  // Segment 0
  host.chatStream = "Hello";
  handleAgentEvent(host, { runId: "run-1", seq: 1, stream: "tool", ts: Date.now(), sessionKey: "main", data: { toolCallId: "t1", name: "tool", phase: "start" } });
  expect(host.chatStreamSegments[0]?.text).toBe("Hello");

  // Segment 1
  host.chatStream = "Hello world";
  handleAgentEvent(host, { runId: "run-1", seq: 2, stream: "tool", ts: Date.now(), sessionKey: "main", data: { toolCallId: "t2", name: "tool", phase: "start" } });
  expect(host.chatStreamSegments[1]?.text).toBe(" world");

  // Segment 2 – this is the case the current fix gets wrong
  host.chatStream = "Hello world, how";
  handleAgentEvent(host, { runId: "run-1", seq: 3, stream: "tool", ts: Date.now(), sessionKey: "main", data: { toolCallId: "t3", name: "tool", phase: "start" } });
  expect(host.chatStreamSegments[2]?.text).toBe(", how");
});
```

How can I resolve this? If you propose a fix, please make it concise.