Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript
63.8 KB
Raw Blame
import { describe, expect, it } from 'vitest'
import fc from 'fast-check'
import { mergeAuthoritativeServerMessages, messageServerTurnNumber } from '../chatMessageMerge.js'
import { type ServerTurn, turnsToChatMessages } from '../serverTurnAdapter.js'
import type { ChatMessage, ChatMessageAttachment } from '../types.js'

const imageWithBytes: ChatMessageAttachment = {
  id: 'local-image',
  type: 'uploaded_file',
  label: 'chart.png',
  filename: 'chart.png',
  mimeType: 'image/png',
  encoding: 'base64',
  dataBase64: 'AQID',
  sizeBytes: 3,
}

describe('mergeAuthoritativeServerMessages image byte gap-fill', () => {
  it('never duplicates same-name logical images across reconciliation or a repeated merge', () => {
    fc.assert(
      fc.property(
        fc.array(fc.constantFrom('chart.png', 'photo.png'), { minLength: 1, maxLength: 8 }),
        names => {
          const localImages: ChatMessageAttachment[] = names.map((label, index) => ({
            id: `local-${index}`,
            type: 'uploaded_file',
            label,
            filename: label,
            mimeType: 'image/png',
            encoding: 'base64',
            dataBase64: Buffer.from([index]).toString('base64'),
            sizeBytes: 1,
          }))
          const serverImages: ChatMessageAttachment[] = names.map((label, index) => ({
            id: `parsed:uploaded_file:${index}:${label}`,
            type: 'uploaded_file',
            label,
          }))
          const server: ChatMessage = {
            id: 'turn-1-user',
            role: 'user',
            content: 'Analyze',
            timestamp: 2,
            serverTurnNumber: 1,
            task_id: 'task-1',
            attachments: [
              { id: 'server-plugin', type: 'plugin', label: 'profits/revenue' },
              ...serverImages,
            ],
          }
          const local: ChatMessage = {
            id: 'optimistic-user',
            role: 'user',
            content: 'Analyze',
            timestamp: 1,
            task_id: 'task-1',
            attachments: localImages,
          }
          const [merged] = mergeAuthoritativeServerMessages([local], [server], {
            activeTaskIds: new Set(['task-1']),
          })
          const uploaded = merged?.attachments?.filter(
            attachment => attachment.type === 'uploaded_file'
          )
          expect(uploaded).toHaveLength(names.length)
          expect(uploaded?.map(attachment => attachment.dataBase64)).toEqual(
            localImages.map(attachment => attachment.dataBase64)
          )
          expect(merged?.attachments?.[0]).toEqual(server.attachments?.[0])
          expect(mergeAuthoritativeServerMessages([merged!], [server])[0]?.attachments).toEqual(
            merged?.attachments
          )
        }
      ),
      { numRuns: 250 }
    )
  })

  it('keeps server reference chips and enriches a matching image during live-task replacement', () => {
    const serverPlugin: ChatMessageAttachment = {
      id: 'server-plugin',
      type: 'plugin',
      label: 'profits/revenue',
    }
    const serverImage: ChatMessageAttachment = {
      id: 'parsed-uploaded-file-chart',
      type: 'uploaded_file',
      label: 'chart.png',
    }
    const merged = mergeAuthoritativeServerMessages(
      [
        {
          id: 'optimistic-user',
          role: 'user',
          content: 'Analyze the chart',
          timestamp: 1,
          task_id: 'task-1',
          attachments: [imageWithBytes, { id: 'local-plugin', type: 'plugin', label: 'revenue' }],
        },
      ],
      [
        {
          id: 'turn-1-user',
          role: 'user',
          content: 'Analyze the chart',
          timestamp: 2,
          serverTurnNumber: 1,
          task_id: 'task-1',
          attachments: [serverPlugin, serverImage],
        },
      ],
      { activeTaskIds: new Set(['task-1']) }
    )

    expect(merged).toHaveLength(1)
    expect(merged[0]?.attachments).toEqual([
      serverPlugin,
      {
        ...serverImage,
        filename: 'chart.png',
        mimeType: 'image/png',
        encoding: 'base64',
        dataBase64: 'AQID',
        sizeBytes: 3,
      },
    ])
    expect(mergeAuthoritativeServerMessages(merged, [merged[0]!])).toEqual(merged)
  })

  it('matches an uploaded file by ID when its server label differs from the local name', () => {
    const serverImage: ChatMessageAttachment = {
      id: imageWithBytes.id,
      type: 'uploaded_file',
      label: 'server chart label',
    }
    const merged = mergeAuthoritativeServerMessages(
      [
        {
          id: 'optimistic-user',
          role: 'user',
          content: 'Chart',
          timestamp: 1,
          task_id: 'task-id',
          attachments: [imageWithBytes],
        },
      ],
      [
        {
          id: 'turn-1-user',
          role: 'user',
          content: 'Chart',
          timestamp: 2,
          serverTurnNumber: 1,
          task_id: 'task-id',
          attachments: [serverImage],
        },
      ],
      { activeTaskIds: new Set(['task-id']) }
    )
    expect(merged[0]?.attachments).toEqual([
      {
        ...serverImage,
        filename: 'chart.png',
        mimeType: 'image/png',
        encoding: 'base64',
        dataBase64: 'AQID',
        sizeBytes: 3,
      },
    ])
  })

  it('keeps an unproven local image on its own idle echo', () => {
    const serverPlugin: ChatMessageAttachment = {
      id: 'server-plugin',
      type: 'plugin',
      label: 'profits/revenue',
    }
    const merged = mergeAuthoritativeServerMessages(
      [
        { id: 'turn-1-user', role: 'user', content: 'first', timestamp: 1, serverTurnNumber: 1 },
        {
          id: 'optimistic-user',
          role: 'user',
          content: 'Analyze the chart',
          timestamp: 2,
          task_id: 'settled-task',
          attachments: [
            imageWithBytes,
            { id: 'local-only-label', type: 'agent_file', label: 'notes.md' },
          ],
        },
        {
          id: 'turn-2-user',
          role: 'user',
          content: 'Analyze the chart',
          timestamp: 3,
          serverTurnNumber: 2,
        },
      ],
      [
        { id: 'turn-1-user', role: 'user', content: 'first', timestamp: 4, serverTurnNumber: 1 },
        {
          id: 'turn-2-user',
          role: 'user',
          content: 'Analyze the chart',
          timestamp: 5,
          serverTurnNumber: 2,
          attachments: [serverPlugin],
        },
      ],
      { activeTaskIds: new Set() }
    )

    expect(merged.map(message => message.id)).toEqual([
      'turn-1-user',
      'optimistic-user',
      'turn-2-user',
    ])
    expect(merged[1]?.attachments).toContainEqual(imageWithBytes)
    expect(merged[2]?.attachments).toEqual([serverPlugin])
    expect(merged[2]?.task_id).toBeUndefined()
  })
})

describe('mergeAuthoritativeServerMessages', () => {
  it('preserves a task-backed in-flight message outside the authoritative turn', () => {
    const pending: ChatMessage = {
      id: 'pending',
      role: 'assistant',
      content: 'still running',
      timestamp: 2,
      task_id: 'task-1',
    }
    const merged = mergeAuthoritativeServerMessages(
      [{ id: 'optimistic', role: 'user', content: 'old', timestamp: 1 }, pending],
      [
        {
          id: 'turn-3-user',
          role: 'user',
          content: 'server copy',
          timestamp: 100,
          serverTurnNumber: 3,
        },
      ],
      { activeTaskIds: new Set(['task-1']) }
    )

    expect(merged.map(message => message.id)).toEqual(['turn-3-user', 'pending'])
  })

  it('keeps an active optimistic message without dropping the unscoped server turn (D-3)', () => {
    // The server has not scoped its history row to the optimistic's task, so the
    // row must survive (invariant §3) while the live optimistic stays as a
    // transient duplicate that a later reconciliation collapses (§6).
    const serverMessages = turnsToChatMessages([
      {
        number: 2,
        user_input: 'second',
        started_at: new Date(3).toISOString(),
      },
    ])
    const merged = mergeAuthoritativeServerMessages(
      [
        {
          id: 'turn-1-user',
          role: 'user',
          content: 'first',
          timestamp: 1,
          serverTurnNumber: 1,
        },
        {
          id: 'optimistic-task-2',
          role: 'user',
          content: 'second',
          timestamp: 2,
          task_id: 'task-2',
        },
      ],
      serverMessages,
      { activeTaskIds: new Set(['task-2']) }
    )

    expect(merged.map(message => message.id)).toEqual([
      'turn-1-user',
      'optimistic-task-2',
      'turn-2-user',
    ])
    expect(merged.find(message => message.id === 'optimistic-task-2')).toEqual(
      expect.objectContaining({ content: 'second', task_id: 'task-2' })
    )
  })

  it('replaces an active optimistic message when the server identifies the same task', () => {
    const merged = mergeAuthoritativeServerMessages(
      [
        {
          id: 'optimistic-task-2',
          role: 'user',
          content: 'second',
          timestamp: 2,
          task_id: 'task-2',
        },
      ],
      [
        {
          id: 'turn-2-user',
          role: 'user',
          content: 'second',
          timestamp: 3,
          task_id: 'task-2',
          serverTurnNumber: 2,
        },
      ],
      { activeTaskIds: new Set(['task-2']) }
    )

    expect(merged).toEqual([
      expect.objectContaining({
        id: 'turn-2-user',
        content: 'second',
        task_id: 'task-2',
      }),
    ])
  })

  it('replaces a turnless echo after the previous numbered turn', () => {
    const merged = mergeAuthoritativeServerMessages(
      [
        {
          id: 'turn-1-user',
          role: 'user',
          content: 'first',
          timestamp: 1,
          serverTurnNumber: 1,
        },
        {
          id: 'optimistic-user',
          role: 'user',
          content: 'second',
          timestamp: 2,
        },
      ],
      turnsToChatMessages([
        {
          number: 2,
          user_input: 'second',
          started_at: new Date(3).toISOString(),
        },
      ])
    )

    expect(merged.map(message => message.id)).toEqual(['turn-1-user', 'turn-2-user'])
  })

  it('does not attribute an unscoped completed task ID to an authoritative turn', () => {
    const merged = mergeAuthoritativeServerMessages(
      [
        {
          id: 'optimistic-user',
          role: 'user',
          content: 'hello',
          timestamp: 1,
          task_id: 'completed-task',
        },
        {
          id: 'optimistic-assistant',
          role: 'assistant',
          content: 'done',
          timestamp: 2,
          task_id: 'completed-task',
        },
      ],
      [
        {
          id: 'turn-4-user',
          role: 'user',
          content: 'hello',
          timestamp: 100,
          serverTurnNumber: 4,
        },
        {
          id: 'turn-4-assistant',
          role: 'assistant',
          content: 'done',
          timestamp: 101,
          serverTurnNumber: 4,
        },
      ]
    )

    expect(merged.map(message => message.id)).toEqual(['turn-4-user', 'turn-4-assistant'])
    expect(merged.every(message => message.task_id === undefined)).toBe(true)
  })

  it('preserves turnless system messages inside an authoritative range', () => {
    const system: ChatMessage = {
      id: 'system-note',
      role: 'system',
      content: 'local diagnostic',
      timestamp: 2,
    }
    const merged = mergeAuthoritativeServerMessages(
      [
        {
          id: 'turn-1-assistant',
          role: 'assistant',
          content: 'first',
          timestamp: 1,
          serverTurnNumber: 1,
        },
        system,
        {
          id: 'turn-3-user',
          role: 'user',
          content: 'third',
          timestamp: 3,
          serverTurnNumber: 3,
        },
      ],
      [
        {
          id: 'turn-2-user',
          role: 'user',
          content: 'second',
          timestamp: 20,
          serverTurnNumber: 2,
        },
      ]
    )

    expect(merged.map(message => message.id)).toEqual([
      'turn-1-assistant',
      'system-note',
      'turn-2-user',
      'turn-3-user',
    ])
  })

  it('preserves a local message interleaved between authoritative slots of one turn', () => {
    const local: ChatMessage[] = [
      {
        id: 'turn-1-user',
        role: 'user',
        content: 'question',
        timestamp: 1,
        serverTurnNumber: 1,
      },
      {
        id: 'local-warning',
        role: 'system',
        content: 'local warning',
        timestamp: 2,
        preserveLocal: true,
      },
      {
        id: 'turn-1-assistant',
        role: 'assistant',
        content: 'answer',
        timestamp: 3,
        serverTurnNumber: 1,
      },
    ]
    const authoritative = turnsToChatMessages([
      {
        number: 1,
        user_input: 'question',
        response: 'answer',
        started_at: new Date(1).toISOString(),
        completed_at: new Date(3).toISOString(),
      },
    ])

    const first = mergeAuthoritativeServerMessages(local, authoritative)
    const second = mergeAuthoritativeServerMessages(first, authoritative)

    expect(first.map(message => message.id)).toEqual([
      'turn-1-user',
      'local-warning',
      'turn-1-assistant',
    ])
    expect(second).toEqual(first)
  })

  it('preserves durable turnless message positions between replaced turns', () => {
    const merged = mergeAuthoritativeServerMessages(
      [
        {
          id: 'turn-2-user-local',
          role: 'user',
          content: 'second',
          timestamp: 1,
          serverTurnNumber: 2,
        },
        {
          id: 'system-note',
          role: 'system',
          content: 'local diagnostic',
          timestamp: 2,
        },
        {
          id: 'durable-error',
          role: 'assistant',
          content: 'connection interrupted',
          timestamp: 3,
          isError: true,
        },
        {
          id: 'turn-3-user-local',
          role: 'user',
          content: 'third',
          timestamp: 4,
          serverTurnNumber: 3,
        },
      ],
      [
        {
          id: 'turn-2-user',
          role: 'user',
          content: 'second',
          timestamp: 20,
          serverTurnNumber: 2,
        },
        {
          id: 'turn-3-user',
          role: 'user',
          content: 'third',
          timestamp: 30,
          serverTurnNumber: 3,
        },
      ]
    )

    expect(merged.map(message => message.id)).toEqual([
      'turn-2-user',
      'system-note',
      'durable-error',
      'turn-3-user',
    ])
  })

  it('replaces numbered active-task rows instead of suppressing their server slot', () => {
    const merged = mergeAuthoritativeServerMessages(
      [
        {
          id: 'turn-4-user-local',
          role: 'user',
          content: 'local',
          timestamp: 1,
          serverTurnNumber: 4,
          task_id: 'task-4',
        },
      ],
      [
        {
          id: 'turn-4-user',
          role: 'user',
          content: 'server',
          timestamp: 2,
          serverTurnNumber: 4,
        },
      ],
      { activeTaskIds: new Set(['task-4']) }
    )

    expect(merged).toEqual([
      expect.objectContaining({
        id: 'turn-4-user',
        content: 'server',
        task_id: 'task-4',
      }),
    ])
  })

  it('does not reuse later exact matches when backfilling older server turns', () => {
    const existing: ChatMessage[] = Array.from({ length: 4 }, (_, index) => index + 5).flatMap(
      n => [
        {
          id: `turn-${n}-user-local`,
          role: 'user' as const,
          content: `local q${n}`,
          timestamp: n * 10,
          serverTurnNumber: n,
          task_id: `task-${n}`,
          attachments: [
            {
              id: `upload-${n}`,
              type: 'uploaded_file' as const,
              label: `file-${n}.txt`,
            },
          ],
        },
        {
          id: `turn-${n}-assistant-local`,
          role: 'assistant' as const,
          content: `local a${n}`,
          timestamp: n * 10 + 1,
          serverTurnNumber: n,
          task_id: `task-${n}`,
        },
      ]
    )
    const incoming = turnsToChatMessages(
      Array.from({ length: 8 }, (_, index) => ({
        number: index + 1,
        user_input: `q${index + 1}`,
        response: `a${index + 1}`,
        started_at: new Date(index + 1).toISOString(),
      }))
    )

    const merged = mergeAuthoritativeServerMessages(existing, incoming)

    expect(merged.map(message => message.id)).toEqual(
      Array.from({ length: 8 }, (_, index) => index + 1).flatMap(n => [
        `turn-${n}-user`,
        `turn-${n}-assistant`,
      ])
    )
    expect(
      merged
        .filter(message => message.serverTurnNumber !== undefined && message.serverTurnNumber <= 4)
        .flatMap(message => [message.task_id, message.attachments])
        .filter(Boolean)
    ).toEqual([])
    expect(
      merged
        .filter(message => message.serverTurnNumber === 5)
        .map(message => ({
          id: message.id,
          taskId: message.task_id,
          attachmentId: message.attachments?.[0]?.id,
        }))
    ).toEqual([
      { id: 'turn-5-user', taskId: 'task-5', attachmentId: 'upload-5' },
      { id: 'turn-5-assistant', taskId: 'task-5', attachmentId: undefined },
    ])
  })

  it('does not copy turnless orphan metadata onto unrelated backfilled server turns', () => {
    const existing: ChatMessage[] = [
      {
        id: 'turnless-upload-orphan',
        role: 'user',
        content: 'old local upload',
        timestamp: 1,
        task_id: 'orphan-task',
        attachments: [
          {
            id: 'orphan-upload',
            type: 'uploaded_file',
            label: 'orphan.txt',
          },
        ],
      },
      ...Array.from({ length: 4 }, (_, index) => index + 5).flatMap(n => [
        {
          id: `turn-${n}-user-local`,
          role: 'user' as const,
          content: `local q${n}`,
          timestamp: n * 10,
          serverTurnNumber: n,
          task_id: `task-${n}`,
          attachments: [
            {
              id: `upload-${n}`,
              type: 'uploaded_file' as const,
              label: `file-${n}.txt`,
            },
          ],
        },
        {
          id: `turn-${n}-assistant-local`,
          role: 'assistant' as const,
          content: `local a${n}`,
          timestamp: n * 10 + 1,
          serverTurnNumber: n,
          task_id: `task-${n}`,
        },
      ]),
    ]
    const incoming = turnsToChatMessages(
      Array.from({ length: 8 }, (_, index) => ({
        number: index + 1,
        user_input: `q${index + 1}`,
        response: `a${index + 1}`,
        started_at: new Date(index + 1).toISOString(),
      }))
    )

    const merged = mergeAuthoritativeServerMessages(existing, incoming)

    expect(
      merged
        .filter(message => message.serverTurnNumber !== undefined && message.serverTurnNumber <= 4)
        .flatMap(message => [message.task_id, message.attachments])
        .filter(Boolean)
    ).toEqual([])
    expect(
      merged
        .filter(message => message.serverTurnNumber === 5 && message.role === 'user')
        .map(message => ({
          taskId: message.task_id,
          attachmentId: message.attachments?.[0]?.id,
        }))
    ).toEqual([{ taskId: 'task-5', attachmentId: 'upload-5' }])
  })

  it('preserves local-only failed sends that the server never accepted', () => {
    const failedPrompt: ChatMessage = {
      id: 'failed-post-user',
      role: 'user',
      content: 'this prompt never reached the server',
      timestamp: 3,
      preserveLocal: true,
    }

    const merged = mergeAuthoritativeServerMessages(
      [
        {
          id: 'turn-1-user',
          role: 'user',
          content: 'q1',
          timestamp: 1,
          serverTurnNumber: 1,
        },
        {
          id: 'turn-1-assistant',
          role: 'assistant',
          content: 'a1',
          timestamp: 2,
          serverTurnNumber: 1,
        },
        failedPrompt,
      ],
      turnsToChatMessages([
        {
          number: 1,
          user_input: 'q1',
          response: 'a1',
          started_at: new Date(1).toISOString(),
        },
        {
          number: 2,
          user_input: 'server-only q2',
          response: 'server-only a2',
          started_at: new Date(2).toISOString(),
        },
      ])
    )

    expect(merged).toContainEqual(failedPrompt)
  })

  it('does not delete numbered local slots that the server window did not supply', () => {
    const existing = turnsToChatMessages(
      [3, 4, 5].map(number => ({
        number,
        user_input: `q${number}`,
        response: `a${number}`,
        started_at: new Date(number).toISOString(),
      }))
    )
    const incoming = turnsToChatMessages(
      [3, 5].map(number => ({
        number,
        user_input: `server q${number}`,
        response: `server a${number}`,
        started_at: new Date(number + 10).toISOString(),
      }))
    )

    const merged = mergeAuthoritativeServerMessages(existing, incoming)

    expect(merged.map(message => message.id)).toEqual([
      'turn-3-user',
      'turn-3-assistant',
      'turn-4-user',
      'turn-4-assistant',
      'turn-5-user',
      'turn-5-assistant',
    ])
    expect(
      merged.filter(message => message.serverTurnNumber === 4).map(message => message.content)
    ).toEqual(['q4', 'a4'])
  })

  it('preserves a local assistant when the server supplies only the user slot', () => {
    const merged = mergeAuthoritativeServerMessages(
      [
        {
          id: 'turn-9-user-local',
          role: 'user',
          content: 'local q9',
          timestamp: 1,
          serverTurnNumber: 9,
        },
        {
          id: 'turn-9-assistant-local',
          role: 'assistant',
          content: 'local a9',
          timestamp: 2,
          serverTurnNumber: 9,
        },
      ],
      [
        {
          id: 'turn-9-user',
          role: 'user',
          content: 'server q9',
          timestamp: 3,
          serverTurnNumber: 9,
        },
      ]
    )

    expect(merged.map(message => message.id)).toEqual(['turn-9-user', 'turn-9-assistant-local'])
    expect(merged[1]?.content).toBe('local a9')
  })

  it('does not let an active-task claim leak stale metadata onto another server turn', () => {
    const merged = mergeAuthoritativeServerMessages(
      [
        {
          id: 'live-optimistic',
          role: 'user',
          content: 'live prompt',
          timestamp: 1,
          task_id: 'live',
        },
        {
          id: 'stale-echo-turn4',
          role: 'user',
          content: 'stale turn 4',
          timestamp: 2,
          task_id: 'task-4',
          attachments: [
            {
              id: 'photo-4',
              type: 'uploaded_file',
              label: 'photo-4.png',
            },
          ],
        },
      ],
      [
        {
          id: 'turn-4-user',
          role: 'user',
          content: 'server turn 4',
          timestamp: 4,
          serverTurnNumber: 4,
        },
        {
          id: 'turn-5-user',
          role: 'user',
          content: 'server turn 5',
          timestamp: 5,
          serverTurnNumber: 5,
        },
      ],
      { activeTaskIds: new Set(['live']) }
    )

    const turnFive = merged.find(message => message.id === 'turn-5-user')
    expect(merged.map(message => message.id)).toContain('live-optimistic')
    expect(turnFive?.task_id).toBeUndefined()
    expect(turnFive?.attachments).toBeUndefined()
  })

  it('keeps active-task reconciliation idempotent when a same-turn neighbor appears', () => {
    const existing: ChatMessage[] = [
      {
        id: 'turn-1-user',
        role: 'user',
        content: 'q1',
        timestamp: 1,
        serverTurnNumber: 1,
      },
      {
        id: 'turn-1-assistant',
        role: 'assistant',
        content: 'a1',
        timestamp: 2,
        serverTurnNumber: 1,
      },
      {
        id: 'optimistic-user',
        role: 'user',
        content: 'q3',
        timestamp: 3,
        task_id: 'live',
      },
    ]
    const incoming = turnsToChatMessages([
      {
        number: 3,
        user_input: 'q3',
        response: 'a3',
        started_at: new Date(3).toISOString(),
      },
      {
        number: 4,
        user_input: 'q4',
        response: 'a4',
        started_at: new Date(4).toISOString(),
      },
    ])

    const firstPass = mergeAuthoritativeServerMessages(existing, incoming, {
      activeTaskIds: new Set(['live']),
    })
    const secondPass = mergeAuthoritativeServerMessages(firstPass, incoming, {
      activeTaskIds: new Set(['live']),
    })

    expect(secondPass.map(message => message.id)).toEqual(firstPass.map(message => message.id))
    expect(secondPass.filter(message => message.id === 'turn-3-user')).toHaveLength(1)
  })

  it('keeps authoritative turns through a renderer/main double merge with active tasks', () => {
    const existing: ChatMessage[] = [
      {
        id: 'turn-2-user',
        role: 'user',
        content: 'q2',
        timestamp: 1,
        serverTurnNumber: 2,
      },
      {
        id: 'turn-2-assistant',
        role: 'assistant',
        content: 'a2',
        timestamp: 2,
        serverTurnNumber: 2,
      },
      {
        id: 'turn-4-user',
        role: 'user',
        content: 'q4',
        timestamp: 4,
        serverTurnNumber: 4,
      },
      {
        id: 'optimistic-user',
        role: 'user',
        content: 'live q5',
        timestamp: 5,
        task_id: 'live',
      },
      {
        id: 'optimistic-assistant',
        role: 'assistant',
        content: 'working',
        timestamp: 6,
        task_id: 'live',
      },
    ]
    const serverWindow = turnsToChatMessages(
      [3, 4, 5, 6].map(number => ({
        number,
        user_input: `q${number}`,
        response: `a${number}`,
        started_at: new Date(number).toISOString(),
      }))
    )

    const rendered = mergeAuthoritativeServerMessages(existing, serverWindow, {
      activeTaskIds: new Set(['live']),
    })
    const persisted = mergeAuthoritativeServerMessages(existing, rendered, {
      activeTaskIds: new Set(['live']),
    })

    expect(persisted.map(message => message.id)).toContain('turn-6-user')
    expect(persisted.map(message => message.id)).toContain('turn-6-assistant')
  })

  it('collapses a completed local echo into its server slot without dropping the slot', () => {
    // echo-answer-A is the idle echo of turn-2-assistant; the live task-B bubble
    // must not cause the completed server row turn-2-assistant to be suppressed
    // (invariant §3). The idle local echo collapses into its server row (§6.1),
    // and every numbered server row survives.
    const serverMessages = turnsToChatMessages([
      {
        number: 2,
        user_input: 'question A',
        response: 'answer A',
        started_at: new Date(2).toISOString(),
      },
    ])
    const localMessages: ChatMessage[] = [
      serverMessages[0]!,
      {
        id: 'echo-answer-A',
        role: 'assistant',
        content: 'answer A',
        timestamp: 3,
        task_id: 'task-A',
      },
      {
        id: 'optimistic-user-B',
        role: 'user',
        content: 'question B',
        timestamp: 4,
        task_id: 'task-B',
      },
      {
        id: 'optimistic-assistant-B',
        role: 'assistant',
        content: 'working',
        timestamp: 5,
        task_id: 'task-B',
      },
    ]

    const merged = mergeAuthoritativeServerMessages(localMessages, serverMessages, {
      activeTaskIds: new Set(['task-B']),
    })

    expect(merged.map(message => message.id)).toEqual([
      'turn-2-user',
      'turn-2-assistant',
      'optimistic-user-B',
      'optimistic-assistant-B',
    ])
    // Both numbered server rows survive; the live task-B bubbles remain as
    // transient duplicates.
    expect(merged.map(message => message.id)).toEqual(
      expect.arrayContaining(['turn-2-user', 'turn-2-assistant'])
    )
  })

  it('reinjects turnless incoming messages that are present only in the replacement window', () => {
    const merged = mergeAuthoritativeServerMessages(
      [
        {
          id: 'turn-1-user',
          role: 'user',
          content: 'q1',
          timestamp: 1,
          serverTurnNumber: 1,
        },
      ],
      [
        {
          id: 'turn-1-user',
          role: 'user',
          content: 'q1',
          timestamp: 1,
          serverTurnNumber: 1,
        },
        {
          id: 'turn-2-user',
          role: 'user',
          content: 'q2',
          timestamp: 2,
          serverTurnNumber: 2,
        },
        {
          id: 'local-only-note',
          role: 'assistant',
          content: 'local note',
          timestamp: 3,
        },
      ]
    )

    expect(merged.map(message => message.id)).toEqual([
      'turn-1-user',
      'turn-2-user',
      'local-only-note',
    ])
  })

  it('places a server response after the active optimistic prompt for that turn', () => {
    const merged = mergeAuthoritativeServerMessages(
      [
        {
          id: 'turn-5-user-local',
          role: 'user',
          content: 'q5',
          timestamp: 1,
          serverTurnNumber: 5,
        },
        {
          id: 'turn-5-assistant-local',
          role: 'assistant',
          content: 'a5',
          timestamp: 2,
          serverTurnNumber: 5,
        },
        {
          id: 'optimistic-turn-6-user',
          role: 'user',
          content: 'q6',
          timestamp: 3,
          task_id: 'task-live',
        },
      ],
      [
        {
          id: 'turn-5-user',
          role: 'user',
          content: 'q5',
          timestamp: 4,
          serverTurnNumber: 5,
        },
        {
          id: 'turn-5-assistant',
          role: 'assistant',
          content: 'a5',
          timestamp: 5,
          serverTurnNumber: 5,
        },
        {
          id: 'turn-6-assistant',
          role: 'assistant',
          content: 'a6',
          timestamp: 6,
          serverTurnNumber: 6,
        },
      ],
      { activeTaskIds: new Set(['task-live']) }
    )

    expect(merged.map(message => message.id)).toEqual([
      'turn-5-user',
      'turn-5-assistant',
      'optimistic-turn-6-user',
      'turn-6-assistant',
    ])
  })

  it.each([
    {
      name: 'settled numbered replacement',
      existing: turnsToChatMessages([
        {
          number: 1,
          user_input: 'local q1',
          response: 'local a1',
          started_at: new Date(1).toISOString(),
        },
      ]),
      incoming: turnsToChatMessages([
        {
          number: 1,
          user_input: 'server q1',
          response: 'server a1',
          started_at: new Date(2).toISOString(),
        },
        {
          number: 2,
          user_input: 'server q2',
          response: 'server a2',
          started_at: new Date(3).toISOString(),
        },
      ]),
    },
    {
      name: 'partial window with durable locals',
      existing: [
        ...turnsToChatMessages([
          {
            number: 3,
            user_input: 'local q3',
            response: 'local a3',
            started_at: new Date(3).toISOString(),
          },
        ]),
        {
          id: 'local-failed-send',
          role: 'user' as const,
          content: 'retry me',
          timestamp: 4,
          preserveLocal: true,
        },
        {
          id: 'local-error',
          role: 'assistant' as const,
          content: 'connection lost',
          timestamp: 5,
          isError: true,
        },
      ],
      incoming: turnsToChatMessages([
        {
          number: 3,
          user_input: 'server q3',
          response: 'server a3',
          started_at: new Date(6).toISOString(),
        },
        {
          number: 4,
          user_input: 'server q4',
          started_at: new Date(7).toISOString(),
        },
      ]),
    },
    {
      name: 'interleaved system message',
      existing: [
        ...turnsToChatMessages([
          {
            number: 5,
            user_input: 'local q5',
            started_at: new Date(5).toISOString(),
          },
        ]),
        {
          id: 'system-diagnostic',
          role: 'system' as const,
          content: 'local diagnostic',
          timestamp: 6,
        },
      ],
      incoming: turnsToChatMessages([
        {
          number: 5,
          user_input: 'server q5',
          response: 'server a5',
          started_at: new Date(7).toISOString(),
        },
      ]),
    },
  ])('maintains merge invariants for $name', ({ existing, incoming }) => {
    const first = mergeAuthoritativeServerMessages(existing, incoming)
    const second = mergeAuthoritativeServerMessages(first, incoming)
    const ids = first.map(message => message.id)
    const numberedTurns = first
      .map(message => message.serverTurnNumber)
      .filter((turn): turn is number => turn !== undefined)
    const durableLocalIds = existing
      .filter(message => message.preserveLocal || message.isError || message.role === 'system')
      .map(message => message.id)

    expect(new Set(ids).size).toBe(ids.length)
    expect(numberedTurns).toEqual([...numberedTurns].sort((left, right) => left - right))
    expect(second).toEqual(first)
    expect(ids).toEqual(expect.arrayContaining(durableLocalIds))
  })
})

const roleRank = (role: ChatMessage['role']): number =>
  role === 'user' ? 0 : role === 'assistant' ? 1 : 2

// Server-turn windows are derived from the real producer (T1). turnsToChatMessages
// never scopes task_id, so any generator here yields the dominant D-3 shape: every
// live optimistic sees only unscoped server rows and none is ever suppressed.
const serverTurnsArb: fc.Arbitrary<ServerTurn[]> = fc
  .uniqueArray(fc.integer({ min: 1, max: 8 }), { minLength: 1, maxLength: 5 })
  .map(numbers => [...numbers].sort((left, right) => left - right))
  .chain(numbers =>
    fc
      .array(fc.boolean(), { minLength: numbers.length, maxLength: numbers.length })
      .map(hasResponse =>
        numbers.map((number, index) => ({
          number,
          user_input: `server q${number}`,
          ...(hasResponse[index] ? { response: `server a${number}` } : {}),
          started_at: new Date(number).toISOString(),
        }))
      )
  )

type TurnlessSpec =
  | { kind: 'durable'; variant: 'system' | 'error' | 'preserve' }
  | { kind: 'live'; role: 'user' | 'assistant'; task: 'live-a' | 'live-b' }
  | { kind: 'idle'; role: 'user' | 'assistant'; task?: 'idle-a' | 'idle-b' }

const turnlessSpecArb: fc.Arbitrary<TurnlessSpec> = fc.oneof(
  fc.record({
    kind: fc.constant('durable' as const),
    variant: fc.constantFrom('system' as const, 'error' as const, 'preserve' as const),
  }),
  fc.record({
    kind: fc.constant('live' as const),
    role: fc.constantFrom('user' as const, 'assistant' as const),
    task: fc.constantFrom('live-a' as const, 'live-b' as const),
  }),
  fc.record({
    kind: fc.constant('idle' as const),
    role: fc.constantFrom('user' as const, 'assistant' as const),
    task: fc.option(fc.constantFrom('idle-a' as const, 'idle-b' as const), { nil: undefined }),
  })
)

interface MergeScenario {
  existing: ChatMessage[]
  incoming: ChatMessage[]
  activeTaskIds: ReadonlySet<string>
}

// A disk state is a previously-sorted transcript: numbered rows stay ascending,
// turnless durable/optimistic messages are spliced between them. The active set is
// fixed to the live-* pool so every 'live' spec is a genuine optimistic-live bubble
// — including the R1-B1 shape (no numbered rows + live optimistics + a completed
// incoming window).
const mergeScenarioArb: fc.Arbitrary<MergeScenario> = fc
  .record({
    serverTurns: serverTurnsArb,
    numberedNumbers: fc
      .uniqueArray(fc.integer({ min: 1, max: 8 }), { maxLength: 5 })
      .map(numbers => [...numbers].sort((left, right) => left - right)),
    numberedAssistant: fc.array(fc.boolean(), { maxLength: 8 }),
    turnless: fc.array(turnlessSpecArb, { maxLength: 6 }),
    inserts: fc.array(fc.nat(), { maxLength: 12 }),
  })
  .map(({ serverTurns, numberedNumbers, numberedAssistant, turnless, inserts }) => {
    const incoming = turnsToChatMessages(serverTurns)
    let uid = 0
    const numbered: ChatMessage[] = []
    numberedNumbers.forEach((number, index) => {
      numbered.push({
        id: `disk-turn-${number}-user-${uid++}`,
        role: 'user',
        content: `local q${number}`,
        timestamp: number * 10,
        serverTurnNumber: number,
      })
      if (numberedAssistant[index]) {
        numbered.push({
          id: `disk-turn-${number}-assistant-${uid++}`,
          role: 'assistant',
          content: `local a${number}`,
          timestamp: number * 10 + 1,
          serverTurnNumber: number,
        })
      }
    })
    const turnlessRows: ChatMessage[] = turnless.map((spec, index) => {
      const id = `tl-${index}-${uid++}`
      const timestamp = 1000 + index
      if (spec.kind === 'durable') {
        if (spec.variant === 'system')
          return { id, role: 'system', content: 'diagnostic', timestamp }
        if (spec.variant === 'error')
          return { id, role: 'assistant', content: 'error', timestamp, isError: true }
        return { id, role: 'user', content: 'retry me', timestamp, preserveLocal: true }
      }
      return { id, role: spec.role, content: `optimistic ${index}`, timestamp, task_id: spec.task }
    })
    const existing = [...numbered]
    turnlessRows.forEach((row, index) => {
      const position =
        existing.length === 0 ? 0 : (inserts[index] ?? existing.length) % (existing.length + 1)
      existing.splice(position, 0, row)
    })
    return { existing, incoming, activeTaskIds: new Set(['live-a', 'live-b']) }
  })

describe('mergeAuthoritativeServerMessages property invariants (R1-B1)', () => {
  it('holds all six merge properties under fuzzing including the active-task path', () => {
    const durableIds = (messages: ChatMessage[]) =>
      messages.filter(m => m.role === 'system' || m.isError || m.preserveLocal).map(m => m.id)
    const numberedIds = (messages: ChatMessage[]) =>
      messages.filter(m => messageServerTurnNumber(m) !== undefined).map(m => m.id)

    fc.assert(
      fc.property(mergeScenarioArb, ({ existing, incoming, activeTaskIds }) => {
        const merged = mergeAuthoritativeServerMessages(existing, incoming, { activeTaskIds })
        const mergedIds = merged.map(m => m.id)

        // Property 3: no duplicate ids.
        expect(new Set(mergedIds).size).toBe(mergedIds.length)

        // Property 1: every incoming server row with a turn number survives by id
        // (this is the one that catches R1-B1 — no server row is ever suppressed).
        for (const server of incoming) {
          if (messageServerTurnNumber(server) !== undefined) {
            expect(mergedIds).toContain(server.id)
          }
        }

        // Property 2: numbered output is ordered by (turn, roleRank).
        const orderKeys = merged
          .filter(m => messageServerTurnNumber(m) !== undefined)
          .map(m => [messageServerTurnNumber(m)!, roleRank(m.role)] as const)
        for (let index = 1; index < orderKeys.length; index += 1) {
          const [previousTurn, previousRank] = orderKeys[index - 1]!
          const [turn, rank] = orderKeys[index]!
          expect(previousTurn < turn || (previousTurn === turn && previousRank <= rank)).toBe(true)
        }

        // Property 4: durable locals (system/error/preserveLocal) are never lost.
        for (const id of durableIds(existing)) {
          expect(mergedIds).toContain(id)
        }

        // Property 5: idempotence, including the active-task path.
        const remerged = mergeAuthoritativeServerMessages(merged, incoming, { activeTaskIds })
        expect(remerged).toEqual(merged)

        // Property 6: composability at the renderer/main seam — reapplying the same
        // authoritative window preserves the numbered subsequence exactly.
        expect(numberedIds(remerged)).toEqual(numberedIds(merged))
      }),
      { numRuns: 40000 }
    )
  }, 120000)
})

describe('mergeAuthoritativeServerMessages invariant §3 (R1-B1)', () => {
  it('never drops a completed server turn because a live turnless optimistic is present', () => {
    // Exact reproduction of mini-spec §2: disk holds only two live optimistic
    // bubbles for task-1, the server replaces with a completed turn-1, task-1 is
    // still active. The completed server turn must not disappear.
    const incoming = turnsToChatMessages([
      {
        number: 1,
        user_input: 'live question',
        response: 'live answer',
        started_at: new Date(1).toISOString(),
      },
    ])
    const existing: ChatMessage[] = [
      { id: 'opt-user', role: 'user', content: 'live question', timestamp: 10, task_id: 'task-1' },
      {
        id: 'opt-assistant',
        role: 'assistant',
        content: 'working',
        timestamp: 11,
        task_id: 'task-1',
      },
    ]

    const merged = mergeAuthoritativeServerMessages(existing, incoming, {
      activeTaskIds: new Set(['task-1']),
    })

    const ids = merged.map(message => message.id)
    expect(ids).toContain('turn-1-user')
    expect(ids).toContain('turn-1-assistant')
  })
})

describe('mergeAuthoritativeServerMessages unique claim (D-1 ↔ D-2)', () => {
  // The server does not scope task_id on history rows today (mini-spec §6), so a
  // task-scoped server row cannot come from turnsToChatMessages. We derive the base
  // row from the real producer and add the scope by hand to exercise D-1/D-2 — the
  // one place the code must stay correct for if the server ever gains the field.
  const scopedServerUserRow = (task: string): ChatMessage => {
    const [base] = turnsToChatMessages([
      { number: 1, user_input: 'q1', started_at: new Date(1).toISOString() },
    ])
    return { ...base!, task_id: task }
  }

  it('D-1: a single live optimistic is consumed by its exact-task server row', () => {
    const merged = mergeAuthoritativeServerMessages(
      [{ id: 'opt-1', role: 'user', content: 'q1', timestamp: 5, task_id: 'task-x' }],
      [scopedServerUserRow('task-x')],
      { activeTaskIds: new Set(['task-x']) }
    )

    expect(merged.map(message => message.id)).toEqual(['turn-1-user'])
  })

  it('D-2: two live optimistics of the same role/task neither double-claim the row nor lose a local', () => {
    const merged = mergeAuthoritativeServerMessages(
      [
        { id: 'opt-1', role: 'user', content: 'q1', timestamp: 5, task_id: 'task-x' },
        { id: 'opt-2', role: 'user', content: 'q1b', timestamp: 6, task_id: 'task-x' },
      ],
      [scopedServerUserRow('task-x')],
      { activeTaskIds: new Set(['task-x']) }
    )

    const ids = merged.map(message => message.id)
    // The single server row is claimed by neither local; both locals survive and
    // the server row is preserved (Property 1).
    expect(ids).toEqual(expect.arrayContaining(['opt-1', 'opt-2', 'turn-1-user']))
    expect(ids).toHaveLength(3)
  })
})

describe('mergeAuthoritativeServerMessages — R2-H1 idle echo liveness (§6.1, prop #7)', () => {
  // Models the active -> idle transition the real flow performs across TWO merge
  // calls with different activeTaskIds:
  //   1. active reconcile persists the numbered server turn NEXT TO the still-live
  //      optimistic bubble (D-3, what fix 229369e4 now does).
  //   2. the task leaves activeTaskIds (idle).
  //   3. the idle reconcile MUST collapse the residual optimistic echo — but only
  //      because its content matches the adjacent numbered turn (gate (b)).
  // Assertion is on the observable id list the user sees (T4).
  it('collapses the transient duplicate once the task leaves activeTaskIds (exact repro)', () => {
    // Server window derived from the real producer (T1): no hand-built rows.
    const incoming = turnsToChatMessages([
      { number: 1, user_input: 'first', started_at: new Date(1).toISOString() },
      { number: 2, user_input: 'second', started_at: new Date(3).toISOString() },
    ])

    // Disk after the ACTIVE reconcile of task-2: the numbered turn-2-user the fix
    // now persists sits as the immediate numbered neighbour of the still-turnless
    // optimistic bubble, whose content ('second') mirrors turn-2-user.
    const activePersisted: ChatMessage[] = [
      { id: 'turn-1-user', role: 'user', content: 'first', timestamp: 1, serverTurnNumber: 1 },
      { id: 'optimistic-task-2', role: 'user', content: 'second', timestamp: 2, task_id: 'task-2' },
      { id: 'turn-2-user', role: 'user', content: 'second', timestamp: 3, serverTurnNumber: 2 },
    ]

    // While task-2 is still active the duplicate is tolerated (§3 / D-3).
    const activeMerge = mergeAuthoritativeServerMessages(activePersisted, incoming, {
      activeTaskIds: new Set(['task-2']),
    })
    expect(activeMerge.map(m => m.id)).toContain('optimistic-task-2')
    expect(activeMerge.map(m => m.id)).toEqual(
      expect.arrayContaining(['turn-1-user', 'turn-2-user'])
    )

    // Transition to idle: task-2 has left activeTaskIds. The echo collapses because
    // its content == turn-2-user; both server turns remain. FAILS against 229369e4.
    const idleMerge = mergeAuthoritativeServerMessages(activePersisted, incoming, {
      activeTaskIds: new Set(),
    })
    expect(idleMerge.map(m => m.id)).toEqual(['turn-1-user', 'turn-2-user'])

    // Convergence: re-applying the merge does not re-materialise the echo.
    const reMerge = mergeAuthoritativeServerMessages(idleMerge, incoming, {
      activeTaskIds: new Set(),
    })
    expect(reMerge.map(m => m.id)).toEqual(['turn-1-user', 'turn-2-user'])
  })

  it('compares the idle echo against the authoritative incoming row, not the stale disk neighbour (STALE/FRESH)', () => {
    // Regression for the R2-H1 content-gate defect: the collapse gate must compare
    // the idle local against the AUTHORITATIVE incoming row that fills the neighbour
    // slot, not against the stale numbered neighbour from `existing`. Here the disk
    // turn-2-user still holds the pre-reconcile text 'STALE'; incoming carries the
    // fresh 'FRESH' for that same slot. The idle optimistic content 'STALE' equals
    // the STALE disk neighbour but NOT the FRESH authoritative row that actually
    // lands in the output. Dropping it would erase local text that is nowhere in the
    // output. Server rows are derived from the real producer (T1).
    const incoming = turnsToChatMessages([
      { number: 1, user_input: 'A', started_at: new Date(1).toISOString() },
      { number: 2, user_input: 'FRESH', started_at: new Date(3).toISOString() },
    ])
    const existing: ChatMessage[] = [
      { id: 'turn-1-user', role: 'user', content: 'A', timestamp: 1, serverTurnNumber: 1 },
      {
        id: 'optimistic-stale',
        role: 'user',
        content: 'STALE',
        timestamp: 2,
        task_id: 'done-task',
      },
      { id: 'turn-2-user', role: 'user', content: 'STALE', timestamp: 2, serverTurnNumber: 2 },
    ]

    const merged = mergeAuthoritativeServerMessages(existing, incoming, {
      activeTaskIds: new Set(),
    })
    const ids = merged.map(m => m.id)

    // The local's text must survive: the optimistic is not dropped, because its
    // content matches neither authoritative neighbour (turn-1='A', turn-2='FRESH').
    expect(ids).toContain('optimistic-stale')
    expect(merged.find(m => m.id === 'optimistic-stale')).toEqual(
      expect.objectContaining({ content: 'STALE' })
    )
    // 'STALE' text is present in the output at least once (via the surviving local).
    expect(merged.some(m => m.content === 'STALE')).toBe(true)
    // Non-reintroduction of R1-B1: both authoritative rows survive, carrying FRESH.
    expect(ids).toEqual(expect.arrayContaining(['turn-1-user', 'turn-2-user']))
    expect(merged.find(m => m.id === 'turn-2-user')?.content).toBe('FRESH')
  })

  it('does NOT drop an idle orphan whose content diverges from its numbered neighbours (gate (b))', () => {
    // The key test of remediation (b): an accepted task that never registered a
    // server turn (cancelled-in-queue / budget-denied / persistTurnStart failure,
    // verified in mcp-host) leaves a turnless idle non-durable user message. When
    // it lands sandwiched between two consecutive same-role numbered turns, the
    // content-blind positional rule would delete it — LOSING local text. The
    // content gate keeps it because its content ('B') matches neither neighbour.
    // Server turns are derived from the real producer (T1).
    const incoming = turnsToChatMessages([
      { number: 1, user_input: 'A', started_at: new Date(1).toISOString() },
      { number: 2, user_input: 'C', started_at: new Date(3).toISOString() },
    ])
    const [turn1User, turn2User] = incoming
    const existing: ChatMessage[] = [
      turn1User!,
      { id: 'orphan-user', role: 'user', content: 'B', timestamp: 2, task_id: 'done-task' },
      turn2User!,
    ]

    const merged = mergeAuthoritativeServerMessages(existing, incoming, {
      activeTaskIds: new Set(),
    })

    // The orphan survives (at worst a duplicate) — no local text is lost.
    expect(merged.map(m => m.id)).toContain('orphan-user')
    expect(merged.find(m => m.id === 'orphan-user')).toEqual(
      expect.objectContaining({ content: 'B' })
    )
    // Non-reintroduction of R1-B1: both numbered server rows survive.
    expect(merged.map(m => m.id)).toEqual(expect.arrayContaining(['turn-1-user', 'turn-2-user']))
  })

  it('does NOT collapse an optimistic-live bubble even when slot-saturated (I-5 gate)', () => {
    // Same sandwich shape and matching content as the exact repro, but the task is
    // ACTIVE: the in-flight bubble must remain visible in the UI (§1/§3, I-5).
    const incoming = turnsToChatMessages([
      { number: 1, user_input: 'first', started_at: new Date(1).toISOString() },
      { number: 2, user_input: 'second', started_at: new Date(3).toISOString() },
    ])
    const existing: ChatMessage[] = [
      { id: 'turn-1-user', role: 'user', content: 'first', timestamp: 1, serverTurnNumber: 1 },
      { id: 'optimistic-task-2', role: 'user', content: 'second', timestamp: 2, task_id: 'task-2' },
      { id: 'turn-2-user', role: 'user', content: 'second', timestamp: 3, serverTurnNumber: 2 },
    ]
    const merged = mergeAuthoritativeServerMessages(existing, incoming, {
      activeTaskIds: new Set(['task-2']),
    })
    expect(merged.map(m => m.id)).toContain('optimistic-task-2')
  })

  it('property: a same-role sandwiched idle echo collapses, an orphan survives, and no numbered row is lost', () => {
    const durableIds = (messages: ChatMessage[]) =>
      messages.filter(m => m.role === 'system' || m.isError || m.preserveLocal).map(m => m.id)
    const numberedIds = (messages: ChatMessage[]) =>
      messages.filter(m => messageServerTurnNumber(m) !== undefined).map(m => m.id)

    const scenarioArb = fc.record({
      start: fc.integer({ min: 1, max: 6 }),
      role: fc.constantFrom<'user' | 'assistant'>('user', 'assistant'),
      // fresh-echo -> content mirrors the AUTHORITATIVE incoming row (collapses when
      //   idle); stale-echo -> content mirrors a STALE disk neighbour that diverges
      //   from incoming for the same slot (must NOT collapse — its text is nowhere
      //   in the output otherwise); orphan -> content matches neither (survives).
      bubbleMode: fc.constantFrom<'fresh-echo' | 'stale-echo' | 'orphan'>(
        'fresh-echo',
        'stale-echo',
        'orphan'
      ),
      // If active, the bubble is optimistic-live and must never collapse (I-5).
      active: fc.boolean(),
      // R2-M1: whether the optimistic bubble carries side metadata
      // (toolSteps/attachments) that the reconciled server row does NOT have. When
      // an idle echo collapses, that metadata must survive on the authoritative row.
      withMeta: fc.boolean(),
    })

    fc.assert(
      fc.property(scenarioArb, ({ start, role, bubbleMode, active, withMeta }) => {
        const turns = [
          { number: start, user_input: `q${start}`, started_at: new Date(start).toISOString() },
          {
            number: start + 1,
            user_input: `q${start + 1}`,
            started_at: new Date(start + 1).toISOString(),
          },
        ]
        // Keep only the requested role slot so the bubble is truly sandwiched by
        // two consecutive same-role numbered turns (Q = P + 1). turnsToChatMessages
        // emits an assistant slot only when a response is present; there is none
        // here, so for the assistant role there is no sandwich to build.
        const numbered = turnsToChatMessages(turns).filter(m => m.role === role)
        if (numbered.length !== 2) return
        const [low, high] = numbered
        const incoming = numbered
        // The disk copy of the higher numbered neighbour. In stale-echo it carries a
        // pre-reconcile text that diverges from the authoritative incoming row for the
        // same (turn, role) slot; the first loop replaces it with the fresh incoming
        // row in the output, so a gate comparing against this disk row would false-
        // match and drop a local whose text never reaches the output.
        const staleContent = `stale-${start + 1}`
        const diskHigh: ChatMessage =
          bubbleMode === 'stale-echo' ? { ...high!, content: staleContent } : high!
        const bubbleContent =
          bubbleMode === 'fresh-echo'
            ? high!.content
            : bubbleMode === 'stale-echo'
              ? staleContent
              : `orphan-${start}`
        // R2-M1: side metadata the reconciled server rows never carry. When the
        // idle echo collapses it must be merged onto the authoritative row.
        const bubbleToolSteps = [
          { toolName: 'search', displayName: 'Search', state: 'completed' as const },
        ]
        const bubbleAttachments = [
          { id: 'echo-file', type: 'response_file' as const, label: 'result.txt' },
        ]
        const bubble: ChatMessage = {
          id: 'sandwiched-bubble',
          role,
          content: bubbleContent,
          timestamp: 999,
          task_id: 'the-task',
          ...(withMeta ? { toolSteps: bubbleToolSteps, attachments: bubbleAttachments } : {}),
        }
        const existing: ChatMessage[] = [low!, bubble, diskHigh]

        const activeTaskIds = active ? new Set(['the-task']) : new Set<string>()
        const merged = mergeAuthoritativeServerMessages(existing, incoming, { activeTaskIds })
        const ids = merged.map(m => m.id)

        // Prop #7 liveness: ONLY an idle bubble whose content matches the AUTHORITATIVE
        // incoming row collapses. A live bubble (I-5), a content-divergent orphan, and
        // a stale-echo (matches the disk neighbour but not incoming) all survive —
        // gate (b) plus the authoritative-comparison fix: no local text is lost.
        if (bubbleMode === 'fresh-echo' && !active) {
          expect(ids).not.toContain('sandwiched-bubble')
          // R2-M1: the collapsed echo's side metadata survives on the surviving
          // authoritative row (never dropped with the local, never rewriting content).
          if (withMeta) {
            const authRow = merged.find(m => m.serverTurnNumber === start + 1 && m.role === role)
            expect(authRow?.toolSteps).toEqual(bubbleToolSteps)
            expect(authRow?.attachments).toEqual(bubbleAttachments)
          }
          // The done task's identity never leaks onto a numbered server row (§6.2).
          for (const server of incoming) {
            expect(merged.find(m => m.id === server.id)?.task_id).toBeUndefined()
          }
        } else {
          expect(ids).toContain('sandwiched-bubble')
          // The surviving bubble keeps its original text in the output.
          expect(merged.find(m => m.id === 'sandwiched-bubble')?.content).toBe(bubbleContent)
          // R2-M1: an un-collapsed bubble keeps its own metadata and never leaks it
          // onto the authoritative row (no false merge).
          if (withMeta) {
            expect(merged.find(m => m.id === 'sandwiched-bubble')?.toolSteps).toEqual(
              bubbleToolSteps
            )
          }
        }
        // The authoritative higher turn always lands with its FRESH content.
        expect(merged.find(m => m.serverTurnNumber === start + 1 && m.role === role)?.content).toBe(
          high!.content
        )

        // Prop #1: no numbered server row is ever suppressed (R1-B1 guard).
        for (const server of incoming) {
          if (messageServerTurnNumber(server) !== undefined) {
            expect(ids).toContain(server.id)
          }
        }
        // Prop #3: no duplicate ids.
        expect(new Set(ids).size).toBe(ids.length)
        // Prop #2: numbered output ordered by (turn, roleRank).
        const orderKeys = merged
          .filter(m => messageServerTurnNumber(m) !== undefined)
          .map(m => [messageServerTurnNumber(m)!, roleRank(m.role)] as const)
        for (let index = 1; index < orderKeys.length; index += 1) {
          const [previousTurn, previousRank] = orderKeys[index - 1]!
          const [turn, rank] = orderKeys[index]!
          expect(previousTurn < turn || (previousTurn === turn && previousRank <= rank)).toBe(true)
        }
        // Prop #4: durable locals never lost (none here, but the invariant holds).
        for (const id of durableIds(existing)) expect(ids).toContain(id)
        // Prop #5 idempotence + Prop #6 composability at the seam.
        const remerged = mergeAuthoritativeServerMessages(merged, incoming, { activeTaskIds })
        expect(remerged).toEqual(merged)
        expect(numberedIds(remerged)).toEqual(numberedIds(merged))
      }),
      { numRuns: 20000 }
    )
  }, 120000)
})

describe('mergeAuthoritativeServerMessages — R2-M1 idle echo metadata precedence (§6.2)', () => {
  it('R2-M1: preserves a collapsed idle echo side metadata (toolSteps/attachments) on the authoritative row', () => {
    // Regression for R2-M1 (regression of 40cc7afe): a drop-only collapse discarded
    // the optimistic bubble's toolSteps/attachments that the reconciled server row
    // does not carry. Server rows are derived from the real producer (T1) and carry
    // NO tool_steps here, so the metadata lives only on the local bubble. After the
    // idle collapse the metadata must land on the surviving authoritative row (T4).
    const incoming = turnsToChatMessages([
      { number: 1, user_input: 'q1', response: 'a1', started_at: new Date(1).toISOString() },
      { number: 2, user_input: 'q2', response: 'a2', started_at: new Date(2).toISOString() },
    ])
    const optimisticEcho: ChatMessage = {
      id: 'optimistic-assistant',
      role: 'assistant',
      content: 'a2', // mirrors turn-2-assistant → collapses once idle (I-1)
      timestamp: 999,
      task_id: 'done-task',
      toolSteps: [{ toolName: 'search', displayName: 'Search', state: 'completed' }],
      attachments: [{ id: 'echo-file', type: 'response_file', label: 'result.txt' }],
    }
    const existing: ChatMessage[] = [
      {
        id: 'turn-1-assistant',
        role: 'assistant',
        content: 'a1',
        timestamp: 1,
        serverTurnNumber: 1,
      },
      optimisticEcho,
      {
        id: 'turn-2-assistant',
        role: 'assistant',
        content: 'a2',
        timestamp: 3,
        serverTurnNumber: 2,
      },
    ]

    const merged = mergeAuthoritativeServerMessages(existing, incoming, {
      activeTaskIds: new Set(),
    })

    // The echo collapsed (drop of the local), the authoritative row survives.
    expect(merged.map(m => m.id)).not.toContain('optimistic-assistant')
    const outputTurn2Assistant = merged.find(m => m.id === 'turn-2-assistant')
    expect(outputTurn2Assistant).toBeDefined()
    // The side metadata the bubble accumulated survives on the authoritative row.
    expect(outputTurn2Assistant?.toolSteps).toEqual(optimisticEcho.toolSteps)
    expect(outputTurn2Assistant?.attachments).toEqual(optimisticEcho.attachments)
    // content is NOT rewritten (loss-safety of text, §6.2).
    expect(outputTurn2Assistant?.content).toBe('a2')
    // The done task's identity is NOT leaked onto the historical server row (§6.2).
    expect(outputTurn2Assistant?.task_id).toBeUndefined()
    // Non-reintroduction of R1-B1: every numbered server row survives.
    for (const server of incoming) {
      if (messageServerTurnNumber(server) !== undefined) {
        expect(merged.map(m => m.id)).toContain(server.id)
      }
    }
  })

  it('R2-M1: collapse does not leak the idle echo task_id onto the historical server row', () => {
    // Extends the ':602' stale-metadata guard to the COLLAPSE path (F1 regression of
    // d8f45d34): the chained copy used preferredServerMessage, which propagates
    // task_id (local.task_id ?? server.task_id), tagging the historical numbered row
    // with the done task's id. That id leak would break task_id-based dedupe in
    // useAgentChatController (noop) and useChatNotifications (toast dedupe). The
    // collapse must copy attachments/toolSteps ONLY, never task_id. Server rows are
    // derived from the real producer (T1).
    const incoming = turnsToChatMessages([
      { number: 1, user_input: 'q1', response: 'a1', started_at: new Date(1).toISOString() },
      { number: 2, user_input: 'q2', response: 'a2', started_at: new Date(2).toISOString() },
    ])
    const idleEcho: ChatMessage = {
      id: 'idle-echo-assistant',
      role: 'assistant',
      content: 'a2', // mirrors turn-2-assistant → collapses once idle (I-1)
      timestamp: 999,
      task_id: 'done-task',
      toolSteps: [{ toolName: 'search', displayName: 'Search', state: 'completed' }],
    }
    const existing: ChatMessage[] = [
      {
        id: 'turn-1-assistant',
        role: 'assistant',
        content: 'a1',
        timestamp: 1,
        serverTurnNumber: 1,
      },
      idleEcho,
      {
        id: 'turn-2-assistant',
        role: 'assistant',
        content: 'a2',
        timestamp: 3,
        serverTurnNumber: 2,
      },
    ]

    const merged = mergeAuthoritativeServerMessages(existing, incoming, {
      activeTaskIds: new Set(),
    })

    // The echo collapsed; the authoritative row survives.
    expect(merged.map(m => m.id)).not.toContain('idle-echo-assistant')
    const outputTurn2Assistant = merged.find(m => m.id === 'turn-2-assistant')
    expect(outputTurn2Assistant).toBeDefined()
    // task_id identity is NOT leaked onto the historical server row.
    expect(outputTurn2Assistant?.task_id).toBeUndefined()
    // No OTHER authoritative row picks up the done task_id either.
    for (const server of incoming) {
      if (messageServerTurnNumber(server) !== undefined) {
        expect(merged.find(m => m.id === server.id)?.task_id).toBeUndefined()
      }
    }
    // The durable side metadata still survives (the R2-M1 preservation is intact).
    expect(outputTurn2Assistant?.toolSteps).toEqual(idleEcho.toolSteps)
  })

  it('R2-M1: does not collapse a text-less idle bubble on empty-content coincidence', () => {
    // The collapse gate used strict equality, so '' === '' fired on an
    // attachment-only bubble sandwiched between two empty-content numbered turns.
    // §6.2 requires truthy content on both sides: a text-less bubble is not a text
    // echo and must survive with its attachment. Server rows come from the real
    // producer (T1).
    const incoming = turnsToChatMessages([
      { number: 1, user_input: '', started_at: new Date(1).toISOString() },
      { number: 2, user_input: '', started_at: new Date(2).toISOString() },
    ])
    const attachmentOnly: ChatMessage = {
      id: 'attachment-only',
      role: 'user',
      content: '',
      timestamp: 999,
      task_id: 'done-task',
      attachments: [{ id: 'file-9', type: 'uploaded_file', label: 'photo.png' }],
    }
    const existing: ChatMessage[] = [
      { id: 'turn-1-user', role: 'user', content: '', timestamp: 1, serverTurnNumber: 1 },
      attachmentOnly,
      { id: 'turn-2-user', role: 'user', content: '', timestamp: 3, serverTurnNumber: 2 },
    ]

    const merged = mergeAuthoritativeServerMessages(existing, incoming, {
      activeTaskIds: new Set(),
    })

    // The empty bubble is not a text echo: it survives with its attachment.
    expect(merged.map(m => m.id)).toContain('attachment-only')
    expect(merged.find(m => m.id === 'attachment-only')?.attachments).toEqual(
      attachmentOnly.attachments
    )
    // Non-reintroduction of R1-B1: both numbered server rows survive.
    expect(merged.map(m => m.id)).toEqual(expect.arrayContaining(['turn-1-user', 'turn-2-user']))
  })
})