fix(chat): supersede the row directly above, and never a user row

Three things the review caught, all real.

A `running` row was left standing under the row that said how the
compaction ended, because only a summary-only row was being replaced. Both
were then visible, live. A terminal row now replaces a running one — and
carries over the summary if one had already folded into it, which is the
order running → summary → boundary that live delivery produces and that
would otherwise have dropped the summary on the floor.

The stray-copy scan could take a *user* row that happened to repeat the
summary text. Assistant rows only.

The orphan-summary scan reached backwards past intervening rows, so a
compaction that arrived later could adopt a summary belonging to an earlier
one. Only the row directly above is superseded now; a compaction further
back belongs to itself.

Four cases added: running → done, running → failed, running → summary →
boundary keeping the summary, an orphan left alone behind an ordinary row,
and a user echo of the summary text surviving. Two of them fail without the
first fix.

Signed-off-by: Liran Funaro <liran.funaro@gmail.com>

Author: liran-funaro

src/modules/chat/hooks/useChatMessages.ts

@@ -124,7 +124,8 @@ function appendCompactionRow(
     // directly above, so it is searched for — newest first, ordinary rows only.
     for (let index = converted.length - 1; index >= 0; index -= 1) {
       const row = converted[index];
-      if (!row.compact && (row.content || '').trim() === text) {
+      // Assistant rows only: a user who pastes the same text is not a duplicate.
+      if (row.type === 'assistant' && !row.compact && (row.content || '').trim() === text) {
         converted.splice(index, 1);
         break;
       }
@@ -156,16 +157,19 @@ function appendCompactionRow(
     return false;
   }
 
-  // Live, the summary arrived before this row and made one of its own. Take it
-  // back: this row says what that one could not.
-  let summary: string | undefined;
-  for (let index = converted.length - 1; index >= 0; index -= 1) {
-    const row = converted[index];
-    if (row.compact && row.compactSummary && !row.content) {
-      summary = row.compactSummary;
-      converted.splice(index, 1);
-      break;
-    }
+  // This row supersedes the one directly above it in two cases, and only when it
+  // is directly above — a compaction further back belongs to itself:
+  //
+  //   - a `running` row, now that the compaction has finished or failed;
+  //   - the summary-only row a summary makes when it arrives before its
+  //     boundary, which is the live order. Its summary comes along, since this
+  //     row says what that one could not.
+  const previous = converted[converted.length - 1];
+  const supersedes = Boolean(previous?.compact)
+    && (previous.compact?.phase === 'running' || !previous.content);
+  const summary = supersedes ? previous.compactSummary : undefined;
+  if (supersedes) {
+    converted.pop();
   }
 
   converted.push({

src/modules/chat/tests/compactionRows.test.ts

@@ -71,6 +71,57 @@ describe('compaction rows', () => {
     ]);
   });
 
+  it('replaces the running row with the row that says how it ended', () => {
+    const running = () => row({ content: 'Compacting conversation…', compact: { phase: 'running' } });
+
+    expect(normalizedToChatMessages([running(), boundary()]))
+      .toMatchObject([{ compact: { phase: 'done' } }]);
+
+    const failed = row({
+      content: 'Compaction failed: context still too large',
+      compact: { phase: 'failed', error: 'context still too large' },
+    });
+    expect(normalizedToChatMessages([running(), failed]))
+      .toMatchObject([{ compact: { phase: 'failed' } }]);
+  });
+
+  it('keeps the summary when it folded into a running row the boundary then replaced', () => {
+    const converted = normalizedToChatMessages([
+      row({ content: 'Compacting conversation…', compact: { phase: 'running' } }),
+      summary(),
+      boundary(),
+    ]);
+
+    expect(converted).toHaveLength(1);
+    expect(converted[0].compact?.phase).toBe('done');
+    expect(converted[0].compactSummary).toBe('The summary body');
+  });
+
+  it('leaves an earlier compaction alone: only the row directly above is superseded', () => {
+    const converted = normalizedToChatMessages([
+      summary(),
+      row({ content: 'on with the work' }),
+      boundary(),
+    ]);
+
+    expect(converted).toHaveLength(3);
+    expect(converted[0].compactSummary).toBe('The summary body');
+    expect(converted[1].content).toBe('on with the work');
+    expect(converted[2].compactSummary).toBeUndefined();
+  });
+
+  it('never takes a user row for a stray copy of the summary', () => {
+    const userEcho: NormalizedMessage = {
+      ...row({ content: 'The summary body' }),
+      role: 'user',
+    } as NormalizedMessage;
+
+    const converted = normalizedToChatMessages([userEcho, boundary(), summary()]);
+
+    expect(converted.map((message) => message.type)).toEqual(['user', 'assistant']);
+    expect(converted[1].compactSummary).toBe('The summary body');
+  });
+
   it('keeps a running compaction, and its phase, so the row can say so', () => {
     const converted = normalizedToChatMessages([
       row({ content: 'Compacting conversation…', compact: { phase: 'running' } }),