/**
 * Store test (spec v4 §5 Layer 3). Pure data behavior of the reducer: skin →
 * theme, LRU dedup, hydrate-while-buffering (Phase 1); and the Phase 2b ordered
 * `parts[]` model — text/tool interleave in one turn, tool start↔complete matched
 * by id and updated IN PLACE, `{output,exit_code}` envelope stripped.
 */
import { afterEach, describe, expect, test } from 'vitest'

import { DEFAULT_THEME } from '../logic/theme.ts'
import { createSessionStore, type Message } from '../logic/store.ts'

describe('session store — theming / dedup / hydrate (Phase 1)', () => {
  test('gateway.ready{skin} re-themes; default before', () => {
    const store = createSessionStore()
    expect(store.state.theme.brand.name).toBe(DEFAULT_THEME.brand.name)
    store.apply({
      type: 'gateway.ready',
      payload: { skin: { branding: { agent_name: 'Zephyr' }, colors: { ui_primary: '#123456' } } }
    })
    expect(store.state.ready).toBe(true)
    expect(store.state.theme.brand.name).toBe('Zephyr')
    expect(store.state.theme.color.primary).toBe('#123456')
  })

  test('skin.changed updates the theme live', () => {
    const store = createSessionStore()
    store.apply({ type: 'skin.changed', payload: { branding: { agent_name: 'Aurora' } } })
    expect(store.state.theme.brand.name).toBe('Aurora')
  })

  test('LRU dedup: duplicate(id) returns false once, true after', () => {
    const store = createSessionStore()
    expect(store.duplicate('evt-1')).toBe(false)
    expect(store.duplicate('evt-1')).toBe(true)
    expect(store.duplicate(undefined)).toBe(false) // no id → never deduped
  })

  test('hydrate replaces history, then replays events buffered mid-hydrate', () => {
    const store = createSessionStore()
    const snapshot: Message[] = [
      { role: 'user', text: 'old q' },
      { role: 'assistant', text: 'old a' }
    ]
    // Simulate a live event arriving DURING hydrate by emitting inside loadSnapshot.
    let emittedDuring = false
    store.hydrate(() => {
      if (!emittedDuring) {
        emittedDuring = true
        store.apply({ type: 'message.start' })
        store.apply({ type: 'message.delta', payload: { text: 'live!' } })
      }
      return snapshot
    })
    // snapshot (2) + the buffered live assistant turn (1) replayed after
    expect(store.state.messages.length).toBe(3)
    expect(store.state.messages[0]!.text).toBe('old q')
    // the streamed assistant text now lives in an ordered text part
    expect(store.state.messages[2]!.parts?.[0]).toMatchObject({ type: 'text', text: 'live!' })
  })
})

describe('session store — ordered parts (Phase 2b)', () => {
  test('interleaves text → tool → text as ordered parts in one assistant turn', () => {
    const store = createSessionStore()
    store.apply({ type: 'message.start' })
    store.apply({ type: 'message.delta', payload: { text: 'before ' } })
    store.apply({ type: 'tool.start', payload: { tool_id: 't1', name: 'terminal' } })
    // result_text is the {output,exit_code} JSON envelope — the store strips it.
    store.apply({
      type: 'tool.complete',
      payload: { tool_id: 't1', result_text: '{"output":"hello\\nworld","exit_code":0}' }
    })
    store.apply({ type: 'message.delta', payload: { text: 'after' } })
    store.apply({ type: 'message.complete' })

    const msg = store.state.messages.at(-1)!
    expect(msg.role).toBe('assistant')
    expect(msg.streaming).toBe(false)
    const parts = msg.parts ?? []
    expect(parts.map(p => p.type)).toEqual(['text', 'tool', 'text'])
    expect(parts[0]).toMatchObject({ type: 'text', text: 'before ' })
    expect(parts[2]).toMatchObject({ type: 'text', text: 'after' })
    const tool = parts[1]!
    if (tool.type === 'tool') {
      expect(tool.state).toBe('complete')
      expect(tool.name).toBe('terminal')
      expect(tool.resultText).toBe('hello\nworld') // envelope stripped
      expect(tool.lineCount).toBe(2)
    } else {
      throw new Error('expected a tool part at index 1')
    }
  })

  test('message.complete with text but NO prior start creates the turn (complete-only gateway; no drop)', () => {
    const store = createSessionStore()
    store.apply({ type: 'gateway.ready' })
    // no message.start / no deltas — straight to complete with the full text
    store.apply({ type: 'message.complete', payload: { text: 'The whole answer.' } })
    const msg = store.state.messages.at(-1)!
    expect(msg.role).toBe('assistant')
    expect(msg.streaming).toBe(false)
    expect(msg.parts?.some(p => p.type === 'text' && p.text === 'The whole answer.')).toBe(true)
  })

  test('message.complete with no live turn and no text does NOT create an empty bubble', () => {
    const store = createSessionStore()
    store.apply({ type: 'gateway.ready' })
    store.apply({ type: 'message.complete', payload: {} })
    expect(store.state.messages.filter(m => m.role === 'assistant')).toHaveLength(0)
  })

  test('tool.complete updates the running tool part IN PLACE (not a new row)', () => {
    const store = createSessionStore()
    store.apply({ type: 'message.start' })
    store.apply({ type: 'tool.start', payload: { tool_id: 'x', name: 'read_file' } })
    expect(store.state.messages.at(-1)!.parts).toHaveLength(1)
    expect(store.state.messages.at(-1)!.parts![0]).toMatchObject({ type: 'tool', state: 'running', name: 'read_file' })

    store.apply({ type: 'tool.complete', payload: { tool_id: 'x', summary: 'read 42 lines' } })
    const parts = store.state.messages.at(-1)!.parts!
    expect(parts).toHaveLength(1) // updated in place — NOT appended as a separate row
    const tool = parts[0]!
    if (tool.type === 'tool') {
      expect(tool.state).toBe('complete')
      expect(tool.summary).toBe('read 42 lines')
    } else {
      throw new Error('expected a tool part')
    }
  })

  test('captures tool args: context→argsPreview, args→argsText, duration, omitted note (item 2)', () => {
    const store = createSessionStore()
    store.apply({ type: 'message.start' })
    store.apply({ type: 'tool.start', payload: { tool_id: 'a', name: 'terminal', context: 'ls -la src' } })
    store.apply({
      type: 'tool.complete',
      payload: {
        tool_id: 'a',
        name: 'terminal',
        args: { command: 'ls -la src' },
        duration_s: 0.34,
        result_text: '[showing verbose tail; omitted 3 lines / 90 chars]\nfile1\nfile2'
      }
    })
    const tool = store.state.messages.at(-1)!.parts![0]!
    if (tool.type !== 'tool') throw new Error('expected a tool part')
    expect(tool.argsPreview).toBe('ls -la src') // primary-arg preview shown in the header (NOT overwritten)
    expect(tool.argsText).toContain('"command"') // full args JSON for the expanded view
    expect(tool.duration).toBe(0.34)
    expect(tool.omittedNote).toBe('3 lines / 90 chars') // tidy note; raw label stripped
    expect(tool.resultText).toBe('file1\nfile2') // clean body (label peeled)
    expect(tool.lineCount).toBe(2)
  })

  test('tool.complete captures structured args into part.args (renderer registry feed)', () => {
    const store = createSessionStore()
    store.apply({ type: 'message.start' })
    store.apply({ type: 'tool.start', payload: { tool_id: 'a', name: 'mcp_lookup' } })
    store.apply({
      type: 'tool.complete',
      payload: { tool_id: 'a', args: { query: 'hermes', options: { depth: 2 } }, result_text: 'ok' }
    })
    const tool = store.state.messages.at(-1)!.parts![0]!
    if (tool.type !== 'tool') throw new Error('expected a tool part')
    expect(tool.args).toEqual({ query: 'hermes', options: { depth: 2 } }) // full structured dict
    expect(tool.argsText).toContain('"query"') // stringified fallback still kept
  })

  test('derives resultText from the raw `result` when result_text is absent (non-verbose sessions)', () => {
    const store = createSessionStore()
    store.apply({ type: 'message.start' })
    store.apply({ type: 'tool.start', payload: { tool_id: 'nv', name: 'terminal' } })
    // non-verbose: no result_text — only the raw envelope-string `result`
    store.apply({
      type: 'tool.complete',
      payload: { tool_id: 'nv', result: '{"output":"hi there\\nline two","exit_code":0,"error":null}' }
    })
    const tool = store.state.messages.at(-1)!.parts![0]!
    if (tool.type !== 'tool') throw new Error('expected a tool part')
    expect(tool.resultText).toBe('hi there\nline two') // envelope stripped, same pipeline
    expect(tool.lineCount).toBe(2)
  })

  test('an object `result` is unwrapped too; result_text keeps precedence when present', () => {
    const store = createSessionStore()
    store.apply({ type: 'message.start' })
    store.apply({ type: 'tool.start', payload: { tool_id: 'o1', name: 'terminal' } })
    store.apply({ type: 'tool.complete', payload: { tool_id: 'o1', result: { output: 'obj out', exit_code: 0 } } })
    store.apply({ type: 'tool.start', payload: { tool_id: 'o2', name: 'terminal' } })
    store.apply({
      type: 'tool.complete',
      payload: { tool_id: 'o2', result: 'raw fallback', result_text: 'verbose text' }
    })

    const parts = store.state.messages.at(-1)!.parts!
    const first = parts[0]!
    const second = parts[1]!
    if (first.type !== 'tool' || second.type !== 'tool') throw new Error('expected tool parts')
    expect(first.resultText).toBe('obj out') // object envelope → its output
    expect(second.resultText).toBe('verbose text') // result_text still wins when sent
  })

  test('setCatalog maps the loose startup.catalog response defensively (item 9)', () => {
    const store = createSessionStore()
    store.setCatalog({
      tools: {
        total: 42,
        toolsets: [
          { name: 'core', count: 12, enabled: true, tools: ['a', 'b', 3] },
          { name: 'off', count: 5, enabled: false, tools: [] },
          { name: '', count: 1 }
        ]
      },
      skills: { total: 7, categories: [{ name: 'dev', count: 7 }] },
      mcp: { servers: ['railway', 123, 'beeper'] },
      junk: 'ignored'
    })
    const c = store.state.catalog!
    expect(c.tools.total).toBe(42)
    expect(c.tools.toolsets).toEqual([
      { name: 'core', count: 12, enabled: true, tools: ['a', 'b'] }, // non-string tool dropped
      { name: 'off', count: 5, enabled: false, tools: [] } // enabled flag preserved
    ]) // nameless entry dropped
    expect(c.skills.total).toBe(7)
    expect(c.mcp.servers).toEqual(['railway', 'beeper']) // non-string dropped
  })

  test('setCatalog leaves the catalog unset on garbage / non-object input (decode → none)', () => {
    const store = createSessionStore()
    expect(store.state.catalog).toBeUndefined()
    store.setCatalog('not an object')
    expect(store.state.catalog).toBeUndefined()
    store.setCatalog(null)
    expect(store.state.catalog).toBeUndefined()
    store.setCatalog(42)
    expect(store.state.catalog).toBeUndefined()
  })

  test('setCatalog accepts a sparse but well-shaped catalog (absent sections default empty)', () => {
    const store = createSessionStore()
    store.setCatalog({ tools: { total: 3, toolsets: [{ name: 'core', count: 3, tools: ['a'] }] } })
    const c = store.state.catalog!
    expect(c.tools.total).toBe(3)
    expect(c.tools.toolsets).toEqual([{ name: 'core', count: 3, enabled: true, tools: ['a'] }]) // enabled defaults on
    expect(c.skills).toEqual({ total: 0, categories: [] }) // absent section → empty
    expect(c.mcp.servers).toEqual([])
  })

  test('reasoning.delta accumulates into a reasoning part', () => {
    const store = createSessionStore()
    store.apply({ type: 'message.start' })
    store.apply({ type: 'reasoning.delta', payload: { text: 'thinking ' } })
    store.apply({ type: 'reasoning.delta', payload: { text: 'hard' } })
    const parts = store.state.messages.at(-1)!.parts ?? []
    expect(parts[0]).toMatchObject({ type: 'reasoning', text: 'thinking hard' })
  })

  test('thinking.delta (kaomoji face) → transient status, NOT a transcript part; complete clears it', () => {
    const store = createSessionStore()
    store.apply({ type: 'message.start' })
    store.apply({ type: 'thinking.delta', payload: { text: '(´･_･`) formulating...' } })
    expect(store.state.status).toBe('(´･_･`) formulating...')
    expect(store.state.messages.at(-1)!.parts ?? []).toHaveLength(0) // no reasoning row from the face
    store.apply({ type: 'message.delta', payload: { text: 'Hi!' } })
    store.apply({ type: 'message.complete' })
    expect(store.state.status).toBeUndefined() // cleared when the turn ends
    // only the real reply text part remains — the face never entered the transcript
    expect((store.state.messages.at(-1)!.parts ?? []).map(p => p.type)).toEqual(['text'])
  })

  test('status.update also drives the transient status line', () => {
    const store = createSessionStore()
    store.apply({ type: 'status.update', payload: { kind: 'tool', text: 'running terminal…' } })
    expect(store.state.status).toBe('running terminal…')
  })
})

describe('session store — blocking prompts (Phase 3)', () => {
  test('approval.request sets an approval prompt; clearPrompt clears it', () => {
    const store = createSessionStore()
    expect(store.state.prompt).toBeUndefined()
    store.apply({ type: 'approval.request', payload: { command: 'rm -rf /tmp/x', description: 'delete temp' } })
    expect(store.state.prompt).toMatchObject({ kind: 'approval', command: 'rm -rf /tmp/x', description: 'delete temp' })
    store.clearPrompt()
    expect(store.state.prompt).toBeUndefined()
  })

  test('clarify.request carries question + choices + request_id', () => {
    const store = createSessionStore()
    store.apply({ type: 'clarify.request', payload: { question: 'Which?', choices: ['a', 'b'], request_id: 'r1' } })
    const p = store.state.prompt
    expect(p).toMatchObject({ kind: 'clarify', question: 'Which?', requestId: 'r1' })
    if (p?.kind === 'clarify') expect(p.choices).toEqual(['a', 'b'])
  })

  test('clarify.request with null choices → free-text only', () => {
    const store = createSessionStore()
    store.apply({ type: 'clarify.request', payload: { question: 'Name?', choices: null, request_id: 'r2' } })
    const p = store.state.prompt
    if (p?.kind === 'clarify') expect(p.choices).toBeNull()
  })

  test('sudo.request + secret.request set masked prompts', () => {
    const store = createSessionStore()
    store.apply({ type: 'sudo.request', payload: { request_id: 's1' } })
    expect(store.state.prompt).toMatchObject({ kind: 'sudo', requestId: 's1' })
    store.apply({ type: 'secret.request', payload: { env_var: 'API_KEY', prompt: 'Enter key', request_id: 's2' } })
    expect(store.state.prompt).toMatchObject({ kind: 'secret', envVar: 'API_KEY', requestId: 's2' })
  })
})

describe('session store — subagents (Phase 5e agents dashboard)', () => {
  test('subagent.* events build + update a subagent by id', () => {
    const store = createSessionStore()
    store.apply({
      type: 'subagent.start',
      payload: { subagent_id: 'a1', goal: 'research X', model: 'haiku', depth: 1 }
    })
    expect(store.state.subagents).toHaveLength(1)
    expect(store.state.subagents[0]).toMatchObject({ id: 'a1', goal: 'research X', status: 'running', depth: 1 })

    store.apply({ type: 'subagent.tool', payload: { subagent_id: 'a1', tool_name: 'web_search' } })
    expect(store.state.subagents[0]).toMatchObject({ status: 'tool', lastTool: 'web_search' })

    store.apply({ type: 'subagent.complete', payload: { subagent_id: 'a1', summary: 'found it' } })
    expect(store.state.subagents).toHaveLength(1) // updated in place
    expect(store.state.subagents[0]).toMatchObject({ status: 'complete', summary: 'found it' })
  })

  test('accumulates a live trace per subagent (item 15) + transient thought', () => {
    const store = createSessionStore()
    store.apply({ type: 'subagent.start', payload: { subagent_id: 'a1', goal: 'crunch data' } })
    store.apply({ type: 'subagent.thinking', payload: { subagent_id: 'a1', text: 'considering options' } })
    store.apply({ type: 'subagent.tool', payload: { subagent_id: 'a1', tool_name: 'web_search', text: 'opentui' } })
    store.apply({ type: 'subagent.progress', payload: { subagent_id: 'a1', text: 'found 3 hits' } })
    store.apply({ type: 'subagent.complete', payload: { subagent_id: 'a1', summary: 'done crunching' } })
    const sa = store.state.subagents[0]!
    // thinking text is transient (not in the trace), the rest is a concise log
    expect(sa.thought).toBe('considering options')
    expect(sa.trace).toEqual(['▶ crunch data', '⚡ web_search — opentui', 'found 3 hits', '✓ done crunching'])
  })

  test('clearTranscript also clears subagents', () => {
    const store = createSessionStore()
    store.apply({ type: 'subagent.start', payload: { subagent_id: 'a1', goal: 'g' } })
    store.clearTranscript()
    expect(store.state.subagents).toHaveLength(0)
  })
})

describe('session store — session chrome / status bar (item 14)', () => {
  test('session.info populates model/effort/cwd/branch and nested usage context', () => {
    const store = createSessionStore()
    store.apply({
      type: 'session.info',
      payload: {
        model: 'anthropic/claude-opus-4-8',
        reasoning_effort: 'high',
        fast: true,
        cwd: '/home/x/proj',
        branch: 'main',
        running: false,
        usage: { context_used: 42000, context_max: 200000, context_percent: 21 }
      }
    })
    const info = store.state.info
    expect(info.model).toBe('anthropic/claude-opus-4-8')
    expect(info.effort).toBe('high')
    expect(info.fast).toBe(true)
    expect(info.cwd).toBe('/home/x/proj')
    expect(info.branch).toBe('main')
    expect(info.contextPercent).toBe(21)
    expect(info.contextMax).toBe(200000)
  })

  test('session.info reads context from TOP-LEVEL fields when there is no nested usage', () => {
    const store = createSessionStore()
    store.apply({
      type: 'session.info',
      payload: { model: 'gpt-5.4', context_used: 1000, context_max: 8000, context_percent: 13, compressions: 2 }
    })
    const info = store.state.info
    expect(info.model).toBe('gpt-5.4')
    expect(info.contextUsed).toBe(1000)
    expect(info.contextMax).toBe(8000)
    expect(info.contextPercent).toBe(13)
    expect(info.compressions).toBe(2)
  })

  test('session.info prefers nested usage.context_* over the top-level fallback', () => {
    const store = createSessionStore()
    store.apply({
      type: 'session.info',
      payload: { context_percent: 5, usage: { context_percent: 88 } }
    })
    expect(store.state.info.contextPercent).toBe(88) // nested wins
  })

  test('session.info with a malformed payload does NOT crash and leaves chrome untouched (decode → none)', () => {
    const store = createSessionStore()
    store.applyInfo({ model: 'opus', cwd: '/p' })
    // a wrong-typed field (model: number) fails the schema → empty patch, prior info survives
    store.apply({ type: 'session.info', payload: { model: 123, usage: 'nope' } })
    expect(store.state.info).toMatchObject({ model: 'opus', cwd: '/p' })
  })

  test('session.info with a partial payload only patches the present fields', () => {
    const store = createSessionStore()
    store.applyInfo({ model: 'opus', branch: 'main', running: true })
    store.apply({ type: 'session.info', payload: { branch: 'dev' } }) // only branch present
    expect(store.state.info).toMatchObject({ model: 'opus', branch: 'dev', running: true })
  })

  test('message.start sets running, message.complete clears it + refreshes usage', () => {
    const store = createSessionStore()
    store.apply({ type: 'message.start' })
    expect(store.state.info.running).toBe(true)
    store.apply({ type: 'message.delta', payload: { text: 'hi' } })
    store.apply({ type: 'message.complete', payload: { usage: { context_percent: 33 } } })
    expect(store.state.info.running).toBe(false)
    expect(store.state.info.contextPercent).toBe(33)
  })

  test('applyInfo merges a session.create info patch without clobbering prior fields', () => {
    const store = createSessionStore()
    store.applyInfo({ model: 'gpt-5.4', cwd: '/tmp' })
    store.applyInfo({ branch: 'dev' }) // partial patch — model/cwd must survive
    expect(store.state.info).toMatchObject({ model: 'gpt-5.4', cwd: '/tmp', branch: 'dev' })
  })

  test('setHint sets/clears the transient composer hint (Ctrl+C again to quit — item 11)', () => {
    const store = createSessionStore()
    expect(store.state.hint).toBeUndefined()
    store.setHint('Ctrl+C again to quit')
    expect(store.state.hint).toBe('Ctrl+C again to quit')
    store.setHint(undefined)
    expect(store.state.hint).toBeUndefined()
  })
})

describe('session store — gateway lifecycle / transport errors (auto-heal foundations)', () => {
  test('gateway.exited clears the frozen running spinner AND pushes a system notice', () => {
    const store = createSessionStore()
    store.apply({ type: 'message.start' })
    expect(store.state.info.running).toBe(true) // a turn is in flight
    store.apply({ type: 'gateway.exited' })
    // THE key bug fix: the spinner is cleared even though no message.complete arrived.
    expect(store.state.info.running).toBe(false)
    // Neutral status — "recovering…" now comes from gateway.recovering only.
    expect(store.state.status).toBe('gateway exited')
    const sys = store.state.messages.filter(m => m.role === 'system')
    expect(sys).toHaveLength(1)
    expect(sys[0]!.text).toContain('in-flight reply was lost')
  })

  test('gateway.exited enriches the notice with payload.reason when present', () => {
    const store = createSessionStore()
    store.apply({ type: 'gateway.exited', payload: { reason: 'SIGKILL', code: 137 } })
    const sys = store.state.messages.filter(m => m.role === 'system')
    expect(sys[0]!.text).toContain('SIGKILL')
  })

  test('gateway.recovering reflects the attempt number in the status', () => {
    const store = createSessionStore()
    store.apply({ type: 'gateway.recovering', payload: { attempt: 2 } })
    expect(store.state.status).toBe('gateway recovering (attempt 2)…')
  })

  test('gateway.stderr is collected (NOT pushed to transcript), surfaced on start_timeout', () => {
    const store = createSessionStore()
    store.apply({ type: 'gateway.stderr', payload: { line: 'ModuleNotFoundError: no module foo' } })
    store.apply({ type: 'gateway.stderr', payload: { line: 'traceback line 2' } })
    // chatty stderr never floods the transcript on its own
    expect(store.state.messages).toHaveLength(0)
    // …but the tail is surfaced when the gateway fails to start
    store.apply({ type: 'gateway.start_timeout', payload: {} })
    const sys = store.state.messages.filter(m => m.role === 'system')
    expect(sys).toHaveLength(1)
    expect(sys[0]!.text).toContain('gateway failed to start')
    expect(sys[0]!.text).toContain('ModuleNotFoundError')
  })

  test('gateway.protocol_error and error are surfaced to the transcript', () => {
    const store = createSessionStore()
    store.apply({ type: 'gateway.protocol_error', payload: { preview: '<garbled>' } })
    store.apply({ type: 'error', payload: { message: 'boom' } })
    const sys = store.state.messages.filter(m => m.role === 'system')
    expect(sys.map(m => m.text)).toEqual(['gateway protocol error: <garbled>', 'error: boom'])
  })
})

describe('session store — resume hydrate (Phase 4b)', () => {
  test('beginBuffer + commitSnapshot replaces history then replays events buffered across the resume', () => {
    const store = createSessionStore()
    store.beginBuffer()
    // a live event arrives DURING the (async) session.resume RPC
    store.apply({ type: 'message.start' })
    store.apply({ type: 'message.delta', payload: { text: 'live during resume' } })
    // the snapshot commits afterwards
    store.commitSnapshot([{ role: 'user', text: 'old question' }])
    expect(store.state.messages).toHaveLength(2) // snapshot(1) + the replayed assistant turn(1)
    expect(store.state.messages[0]).toMatchObject({ role: 'user', text: 'old question' })
    expect(store.state.messages[1]!.parts?.[0]).toMatchObject({ type: 'text', text: 'live during resume' })
  })
})

describe('session store — rolling message cap (bounds the Yoga node high-water mark)', () => {
  const ENV_KEY = 'HERMES_TUI_MAX_MESSAGES'
  const prev = process.env[ENV_KEY]
  afterEach(() => {
    if (prev === undefined) delete process.env[ENV_KEY]
    else process.env[ENV_KEY] = prev
  })

  test('caps the message array at the env-tuned MESSAGE_CAP, dropping the oldest (head)', () => {
    process.env[ENV_KEY] = '5'
    const store = createSessionStore()
    // push more than the cap; each distinct so we can tell which survived
    for (let i = 0; i < 55; i++) store.pushUser(`msg ${i}`)
    expect(store.state.messages).toHaveLength(5)
    expect(store.state.dropped).toBe(50) // head-sliced overflow is counted for the notice
    // the oldest 50 were sliced from the head; survivors are the last 5 (msg 50..54)
    expect(store.state.messages[0]!.text).toBe('msg 50')
    expect(store.state.messages.at(-1)!.text).toBe('msg 54')
  })

  test('pushSystem is also capped (head-dropped) at MESSAGE_CAP', () => {
    process.env[ENV_KEY] = '3'
    const store = createSessionStore()
    for (let i = 0; i < 10; i++) store.pushSystem(`sys ${i}`)
    expect(store.state.messages).toHaveLength(3)
    expect(store.state.messages[0]!.text).toBe('sys 7')
    expect(store.state.messages.at(-1)!.text).toBe('sys 9')
  })

  test('the in-flight streaming turn it opens at overflow SURVIVES the cap (head sliced, not tail)', () => {
    process.env[ENV_KEY] = '4'
    const store = createSessionStore()
    // fill to the cap with user rows so the next push overflows
    store.pushUser('u0')
    store.pushUser('u1')
    store.pushUser('u2')
    store.pushUser('u3') // array now at the cap (4): [u0, u1, u2, u3]
    expect(store.state.messages).toHaveLength(4)

    // message.start pushes the assistant turn as the LAST row (length 5) → head sliced to 4.
    // The freshly-pushed streaming turn is the tail, so it must NOT be the one evicted.
    store.apply({ type: 'message.start' })
    store.apply({ type: 'message.delta', payload: { text: 'in flight' } })
    expect(store.state.messages).toHaveLength(4)
    expect(store.state.messages[0]!.text).toBe('u1') // 'u0' dropped from the head, not the tail turn
    const live = store.state.messages.at(-1)!
    expect(live.role).toBe('assistant')
    expect(live.streaming).toBe(true)
    expect(live.parts?.[0]).toMatchObject({ type: 'text', text: 'in flight' })
  })

  test('message.start is capped: opening a turn beyond the cap drops the oldest', () => {
    process.env[ENV_KEY] = '2'
    const store = createSessionStore()
    store.pushUser('a')
    store.pushUser('b')
    store.apply({ type: 'message.start' }) // array would be 3 → trimmed to 2
    expect(store.state.messages).toHaveLength(2)
    expect(store.state.messages[0]!.text).toBe('b') // 'a' dropped from the head
    expect(store.state.messages.at(-1)!.role).toBe('assistant')
  })

  test('commitSnapshot caps an over-cap resume snapshot (oldest history dropped)', () => {
    process.env[ENV_KEY] = '3'
    const store = createSessionStore()
    const snapshot: Message[] = Array.from({ length: 8 }, (_, i) => ({ role: 'user', text: `h${i}` }))
    store.beginBuffer()
    store.commitSnapshot(snapshot)
    expect(store.state.messages).toHaveLength(3)
    expect(store.state.dropped).toBe(5) // 8 snapshot − 3 kept; resume SETS the count
    expect(store.state.messages[0]!.text).toBe('h5')
    expect(store.state.messages.at(-1)!.text).toBe('h7')
  })

  test('defaults to 3000 when the env var is unset/invalid', () => {
    delete process.env[ENV_KEY]
    const store = createSessionStore()
    for (let i = 0; i < 3050; i++) store.pushUser(`m${i}`)
    expect(store.state.messages).toHaveLength(3000)
    expect(store.state.messages[0]!.text).toBe('m50') // oldest 50 dropped
  })

  test('clearTranscript empties messages AND the applied dedup set', () => {
    const store = createSessionStore()
    store.pushUser('x')
    // seed the dedup set with an id, then confirm it is now treated as seen
    expect(store.duplicate('seen-1')).toBe(false)
    expect(store.duplicate('seen-1')).toBe(true)

    store.clearTranscript()
    expect(store.state.messages).toHaveLength(0)
    // after clear the previously-seen id is processed again (the applied Set was cleared)
    expect(store.duplicate('seen-1')).toBe(false)
  })

  test('clearTranscript resets the dropped counter (the truncation notice clears)', () => {
    process.env[ENV_KEY] = '2'
    const store = createSessionStore()
    for (let i = 0; i < 5; i++) store.pushUser(`m${i}`) // 5 pushed, cap 2 → 3 dropped
    expect(store.state.dropped).toBe(3)
    store.clearTranscript()
    expect(store.state.dropped).toBe(0)
  })
})