import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
import { mkdtemp, mkdir, writeFile, rm } from 'fs/promises'
import { join, posix, win32 } from 'path'
import { tmpdir } from 'os'
import { createRequire } from 'node:module'

import { copilot, createCopilotProvider, getVSCodeGlobalStorageDirs, getVSCodeWorkspaceStorageDirs } from '../../src/providers/copilot.js'
import { isSqliteAvailable } from '../../src/sqlite.js'
import type { ParsedProviderCall } from '../../src/providers/types.js'

let tmpDir: string

async function createSessionDir(sessionId: string, lines: string[], cwd = '/home/user/myproject') {
  const sessionDir = join(tmpDir, sessionId)
  await mkdir(sessionDir, { recursive: true })
  await writeFile(join(sessionDir, 'workspace.yaml'), `id: ${sessionId}\ncwd: ${cwd}\n`)
  await writeFile(join(sessionDir, 'events.jsonl'), lines.join('\n') + '\n')
  return join(sessionDir, 'events.jsonl')
}

function modelChange(newModel: string, previousModel?: string) {
  return JSON.stringify({ type: 'session.model_change', timestamp: '2026-04-15T10:00:01Z', data: { newModel, previousModel } })
}

function userMessage(content: string) {
  return JSON.stringify({ type: 'user.message', timestamp: '2026-04-15T10:00:10Z', data: { content, interactionId: 'int-1' } })
}

function assistantMessage(opts: { messageId: string; outputTokens: number; tools?: string[]; timestamp?: string }) {
  return JSON.stringify({
    type: 'assistant.message',
    timestamp: opts.timestamp ?? '2026-04-15T10:00:15Z',
    data: {
      messageId: opts.messageId,
      outputTokens: opts.outputTokens,
      interactionId: 'int-1',
      toolRequests: (opts.tools ?? []).map(name => ({ name, toolCallId: `call-${name}`, type: 'function' })),
    },
  })
}

function transcriptSessionStart(sessionId: string) {
  return JSON.stringify({ type: 'session.start', data: { sessionId, producer: 'copilot-agent' } })
}

function transcriptUserMessage(content: string) {
  return JSON.stringify({ type: 'user.message', data: { content, attachments: [] } })
}

function transcriptAssistantMessage(opts: { messageId: string; content?: string; reasoningText?: string; toolCallIds?: string[]; toolNames?: string[] }) {
  return JSON.stringify({
    type: 'assistant.message',
    data: {
      messageId: opts.messageId,
      content: opts.content ?? '',
      reasoningText: opts.reasoningText ?? '',
      toolRequests: (opts.toolCallIds ?? []).map((id, i) => ({
        toolCallId: id,
        name: opts.toolNames?.[i] ?? (i === 0 ? 'read_file' : 'run_in_terminal'),
        type: 'function',
      })),
    },
  })
}

function chatSessionSampleRequest(overrides: Record<string, unknown> = {}) {
  return {
    requestId: 'request_8c8ce017-6e3f-460a-9931-5a16825d231a',
    modelId: 'copilot/claude-sonnet-4.6',
    completionTokens: 490,
    result: {
      metadata: {
        promptTokens: 32543,
        outputTokens: 60,
        resolvedModel: 'claude-sonnet-4-6',
        toolCallRounds: [{ thinking: { tokens: 0 }, modelId: 'claude-sonnet-4.6' }],
        agentId: 'github.copilot.editsAgent',
      },
    },
    ...overrides,
  }
}

async function createChatSessionFile(filePath: string, entries: unknown[]) {
  await writeFile(filePath, entries.map(entry => JSON.stringify(entry)).join('\n') + '\n')
}

async function collectCalls(source: { path: string; project: string; provider: string; sourceType?: string }, seenKeys = new Set<string>()) {
  const calls: ParsedProviderCall[] = []
  for await (const call of copilot.createSessionParser(source, seenKeys).parse()) calls.push(call)
  return calls
}

describe('copilot provider - JSONL parsing', () => {
  beforeEach(async () => {
    tmpDir = await mkdtemp(join(tmpdir(), 'copilot-test-'))
  })

  afterEach(async () => {
    await rm(tmpDir, { recursive: true, force: true })
  })

  it('parses a basic assistant message', async () => {
    const eventsPath = await createSessionDir('sess-001', [
      modelChange('gpt-4.1'),
      userMessage('write a function'),
      assistantMessage({ messageId: 'msg-1', outputTokens: 150 }),
    ])

    const source = { path: eventsPath, project: 'myproject', provider: 'copilot' }
    const calls: ParsedProviderCall[] = []
    for await (const call of copilot.createSessionParser(source, new Set()).parse()) calls.push(call)

    expect(calls).toHaveLength(1)
    const call = calls[0]!
    expect(call.provider).toBe('copilot')
    expect(call.model).toBe('gpt-4.1')
    expect(call.outputTokens).toBe(150)
    expect(call.inputTokens).toBe(0)
    expect(call.userMessage).toBe('write a function')
    expect(call.sessionId).toBe('sess-001')
    expect(call.bashCommands).toEqual([])
    expect(call.costUSD).toBeGreaterThan(0)
  })

  it('tracks model changes mid-session', async () => {
    const eventsPath = await createSessionDir('sess-002', [
      modelChange('gpt-5-mini'),
      userMessage('first'),
      assistantMessage({ messageId: 'msg-1', outputTokens: 50, timestamp: '2026-04-15T10:00:10Z' }),
      modelChange('gpt-4.1', 'gpt-5-mini'),
      userMessage('second'),
      assistantMessage({ messageId: 'msg-2', outputTokens: 80, timestamp: '2026-04-15T10:01:00Z' }),
    ])

    const source = { path: eventsPath, project: 'test', provider: 'copilot' }
    const calls: ParsedProviderCall[] = []
    for await (const call of copilot.createSessionParser(source, new Set()).parse()) calls.push(call)

    expect(calls).toHaveLength(2)
    expect(calls[0]!.model).toBe('gpt-5-mini')
    expect(calls[1]!.model).toBe('gpt-4.1')
  })

  it('extracts tool names from toolRequests', async () => {
    const eventsPath = await createSessionDir('sess-003', [
      modelChange('gpt-4.1'),
      userMessage('run tests'),
      assistantMessage({ messageId: 'msg-1', outputTokens: 60, tools: ['bash', 'read_file', 'write_file'] }),
    ])

    const source = { path: eventsPath, project: 'test', provider: 'copilot' }
    const calls: ParsedProviderCall[] = []
    for await (const call of copilot.createSessionParser(source, new Set()).parse()) calls.push(call)

    expect(calls[0]!.tools).toEqual(['Bash', 'Read', 'Edit'])
  })

  it('normalizes Copilot MCP tool names from toolRequests', async () => {
    const eventsPath = await createSessionDir('sess-mcp-tools', [
      modelChange('gpt-4.1'),
      userMessage('list MCP-backed tasks and issues'),
      assistantMessage({
        messageId: 'msg-1',
        outputTokens: 60,
        tools: ['github-mcp-server-list_issues', 'cyberday-get_tasks', 'mempalace-mempalace_search', 'bash'],
      }),
    ])

    const source = { path: eventsPath, project: 'test', provider: 'copilot' }
    const calls: ParsedProviderCall[] = []
    for await (const call of copilot.createSessionParser(source, new Set()).parse()) calls.push(call)

    expect(calls[0]!.tools).toEqual([
      'mcp__github_mcp_server__list_issues',
      'mcp__cyberday__get_tasks',
      'mcp__mempalace__mempalace_search',
      'Bash',
    ])
  })

  it('does not crash on malformed toolRequests (string / null / missing)', async () => {
    // Regression guard: a corrupt session previously aborted the whole file's
    // parse loop because .map was called on a non-array. The fix coerces any
    // non-array shape (string, null, missing) to []. We mix one corrupt event
    // between two healthy events and assert both healthy events still parse.
    const corruptToolRequestsString = JSON.stringify({
      type: 'assistant.message',
      timestamp: '2026-04-15T10:00:15Z',
      data: { messageId: 'corrupt-string', outputTokens: 50, toolRequests: 'not an array' },
    })
    const corruptToolRequestsNull = JSON.stringify({
      type: 'assistant.message',
      timestamp: '2026-04-15T10:00:16Z',
      data: { messageId: 'corrupt-null', outputTokens: 50, toolRequests: null },
    })
    const eventsPath = await createSessionDir('sess-corrupt', [
      modelChange('gpt-4.1'),
      assistantMessage({ messageId: 'msg-before', outputTokens: 100 }),
      corruptToolRequestsString,
      corruptToolRequestsNull,
      assistantMessage({ messageId: 'msg-after', outputTokens: 200 }),
    ])

    const source = { path: eventsPath, project: 'test', provider: 'copilot' }
    const calls: ParsedProviderCall[] = []
    for await (const call of copilot.createSessionParser(source, new Set()).parse()) calls.push(call)

    // The healthy messages BEFORE and AFTER the corrupt events both parse —
    // proving that the corrupt event no longer aborts the per-file parse loop.
    // Pre-fix, .map on a non-array threw and we'd see < 4 calls.
    expect(calls).toHaveLength(4)
    expect(calls.find(c => c.outputTokens === 100)).toBeDefined()  // msg-before
    expect(calls.find(c => c.outputTokens === 200)).toBeDefined()  // msg-after
    // Corrupt events produce calls with empty tools, not crashes.
    const corruptCalls = calls.filter(c => c.outputTokens === 50)
    expect(corruptCalls.length).toBe(2)
    for (const c of corruptCalls) {
      expect(c.tools).toEqual([])
    }
  })

  it('ignores malformed non-string tool names', async () => {
    const malformedToolName = JSON.stringify({
      type: 'assistant.message',
      timestamp: '2026-04-15T10:00:15Z',
      data: {
        messageId: 'malformed-tool-name',
        outputTokens: 50,
        toolRequests: [null, { name: 123, toolCallId: 'call-bad', type: 'function' }],
      },
    })
    const eventsPath = await createSessionDir('sess-malformed-tool-name', [
      modelChange('gpt-4.1'),
      malformedToolName,
      assistantMessage({ messageId: 'msg-after', outputTokens: 100, tools: ['github-mcp-server-list_issues'] }),
    ])

    const source = { path: eventsPath, project: 'test', provider: 'copilot' }
    const calls: ParsedProviderCall[] = []
    for await (const call of copilot.createSessionParser(source, new Set()).parse()) calls.push(call)

    expect(calls).toHaveLength(2)
    expect(calls[0]!.tools).toEqual([])
    expect(calls[1]!.tools).toEqual(['mcp__github_mcp_server__list_issues'])
  })

  it('skips assistant messages with zero outputTokens', async () => {
    const eventsPath = await createSessionDir('sess-004', [
      modelChange('gpt-4.1'),
      assistantMessage({ messageId: 'msg-empty', outputTokens: 0 }),
      assistantMessage({ messageId: 'msg-real', outputTokens: 42 }),
    ])

    const source = { path: eventsPath, project: 'test', provider: 'copilot' }
    const calls: ParsedProviderCall[] = []
    for await (const call of copilot.createSessionParser(source, new Set()).parse()) calls.push(call)

    expect(calls).toHaveLength(1)
    expect(calls[0]!.outputTokens).toBe(42)
  })

  it('deduplicates messages across parser runs', async () => {
    const eventsPath = await createSessionDir('sess-005', [
      modelChange('gpt-4.1'),
      assistantMessage({ messageId: 'msg-dup', outputTokens: 100 }),
    ])

    const source = { path: eventsPath, project: 'test', provider: 'copilot' }
    const seenKeys = new Set<string>()

    const calls1: ParsedProviderCall[] = []
    for await (const call of copilot.createSessionParser(source, seenKeys).parse()) calls1.push(call)

    const calls2: ParsedProviderCall[] = []
    for await (const call of copilot.createSessionParser(source, seenKeys).parse()) calls2.push(call)

    expect(calls1).toHaveLength(1)
    expect(calls2).toHaveLength(0)
  })

  it('returns empty for missing file', async () => {
    const source = { path: '/nonexistent/events.jsonl', project: 'test', provider: 'copilot' }
    const calls: ParsedProviderCall[] = []
    for await (const call of copilot.createSessionParser(source, new Set()).parse()) calls.push(call)
    expect(calls).toHaveLength(0)
  })

  it('skips assistant messages before the first model_change event', async () => {
    const eventsPath = await createSessionDir('sess-no-model', [
      assistantMessage({ messageId: 'msg-early', outputTokens: 50 }),
      modelChange('gpt-4.1'),
      assistantMessage({ messageId: 'msg-after', outputTokens: 80 }),
    ])

    const source = { path: eventsPath, project: 'test', provider: 'copilot' }
    const calls: ParsedProviderCall[] = []
    for await (const call of copilot.createSessionParser(source, new Set()).parse()) calls.push(call)

    expect(calls).toHaveLength(1)
    expect(calls[0]!.outputTokens).toBe(80)
    expect(calls[0]!.model).toBe('gpt-4.1')
  })

  it('infers OpenAI auto bucket for transcript toolCallId prefix call_', async () => {
    const eventsPath = await createSessionDir('sess-tr-call', [
      transcriptSessionStart('sess-tr-call'),
      transcriptUserMessage('check model inference'),
      transcriptAssistantMessage({
        messageId: 'msg-1',
        content: 'done',
        toolCallIds: ['call_abc123'],
      }),
    ])

    const source = { path: eventsPath, project: 'test', provider: 'copilot' }
    const calls: ParsedProviderCall[] = []
    for await (const call of copilot.createSessionParser(source, new Set()).parse()) calls.push(call)

    expect(calls).toHaveLength(1)
    expect(calls[0]!.model).toBe('copilot-openai-auto')
  })

  it('infers Anthropic auto bucket for transcript toolCallId prefixes tooluse_/toolu_vrtx_', async () => {
    const eventsPath = await createSessionDir('sess-tr-claude', [
      transcriptSessionStart('sess-tr-claude'),
      transcriptUserMessage('check model inference'),
      transcriptAssistantMessage({
        messageId: 'msg-1',
        content: 'done',
        toolCallIds: ['tooluse_XY', 'toolu_vrtx_01ABC'],
      }),
    ])

    const source = { path: eventsPath, project: 'test', provider: 'copilot' }
    const calls: ParsedProviderCall[] = []
    for await (const call of copilot.createSessionParser(source, new Set()).parse()) calls.push(call)

    expect(calls).toHaveLength(1)
    expect(calls[0]!.model).toBe('copilot-anthropic-auto')
  })

  it('chooses the dominant inferred transcript model when prefixes are mixed', async () => {
    const eventsPath = await createSessionDir('sess-tr-mixed', [
      transcriptSessionStart('sess-tr-mixed'),
      transcriptUserMessage('mixed'),
      transcriptAssistantMessage({
        messageId: 'msg-1',
        content: 'one',
        toolCallIds: ['toolu_bdrk_123'],
      }),
      transcriptAssistantMessage({
        messageId: 'msg-2',
        content: 'two',
        toolCallIds: ['call_1'],
      }),
      transcriptAssistantMessage({
        messageId: 'msg-3',
        content: 'three',
        toolCallIds: ['call_2'],
      }),
    ])

    const source = { path: eventsPath, project: 'test', provider: 'copilot' }
    const calls: ParsedProviderCall[] = []
    for await (const call of copilot.createSessionParser(source, new Set()).parse()) calls.push(call)

    expect(calls).toHaveLength(3)
    expect(calls.every(c => c.model === 'copilot-openai-auto')).toBe(true)
  })

  it('normalizes Copilot MCP tool names from VS Code transcripts', async () => {
    const eventsPath = await createSessionDir('sess-tr-mcp-tools', [
      transcriptSessionStart('sess-tr-mcp-tools'),
      transcriptUserMessage('use GitHub MCP'),
      transcriptAssistantMessage({
        messageId: 'msg-1',
        content: 'done',
        toolCallIds: ['call_abc123', 'call_def456'],
        toolNames: ['github-mcp-server-list_issues', 'read_file'],
      }),
    ])

    const source = { path: eventsPath, project: 'test', provider: 'copilot' }
    const calls: ParsedProviderCall[] = []
    for await (const call of copilot.createSessionParser(source, new Set()).parse()) calls.push(call)

    expect(calls).toHaveLength(1)
    expect(calls[0]!.tools).toEqual(['mcp__github_mcp_server__list_issues', 'Read'])
  })
})

describe('copilot provider - chatSessions parsing', () => {
  beforeEach(async () => {
    tmpDir = await mkdtemp(join(tmpdir(), 'copilot-chatsessions-test-'))
    vi.stubEnv('CODEBURN_COPILOT_DISABLE_OTEL', '1')
  })

  afterEach(async () => {
    await rm(tmpDir, { recursive: true, force: true })
    vi.unstubAllEnvs()
  })

  it('parses sample journal token counts and cost', async () => {
    const filePath = join(tmpDir, 'sample.jsonl')
    await createChatSessionFile(filePath, [
      { kind: 0, v: { version: 3, creationDate: 1780157113020, sessionId: 'chat-session-1', requests: [] } },
      { kind: 2, k: ['requests'], v: [chatSessionSampleRequest()] },
    ])

    const calls = await collectCalls({ path: filePath, project: 'myproject', provider: 'copilot', sourceType: 'chatsession' })

    expect(calls).toHaveLength(1)
    expect(calls[0]!.inputTokens).toBe(32543)
    expect(calls[0]!.outputTokens).toBe(60)
    expect(calls[0]!.model).toBe('claude-sonnet-4-6')
    expect(calls[0]!.costUSD).toBeGreaterThan(0)
  })

  it('returns no calls for an empty reconstructed requests array', async () => {
    const filePath = join(tmpDir, 'empty.jsonl')
    await createChatSessionFile(filePath, [
      { kind: 0, v: { version: 3, creationDate: 1780157113020, sessionId: 'chat-empty', requests: [] } },
    ])

    const calls = await collectCalls({ path: filePath, project: 'myproject', provider: 'copilot', sourceType: 'chatsession' })

    expect(calls).toHaveLength(0)
  })

  it('discovers and parses emptyWindowChatSessions from globalStorage', async () => {
    const globalDir = join(tmpDir, 'globalStorage')
    const emptyWindowDir = join(globalDir, 'emptyWindowChatSessions')
    await mkdir(emptyWindowDir, { recursive: true })
    const filePath = join(emptyWindowDir, 'empty-window.jsonl')
    await createChatSessionFile(filePath, [
      { kind: 0, v: { version: 3, creationDate: 1780157113020, sessionId: 'empty-window-session', requests: [] } },
      { kind: 2, k: ['requests'], v: [chatSessionSampleRequest()] },
    ])

    const provider = createCopilotProvider('/nonexistent/legacy', '/nonexistent/ws', globalDir)
    const sessions = await provider.discoverSessions()

    expect(sessions).toHaveLength(1)
    expect(sessions[0]!.project).toBe('copilot-chat')
    expect((sessions[0] as { sourceType?: string }).sourceType).toBe('chatsession')

    const calls: ParsedProviderCall[] = []
    for await (const call of provider.createSessionParser(sessions[0]!, new Set()).parse()) calls.push(call)
    expect(calls).toHaveLength(1)
    expect(calls[0]!.inputTokens).toBe(32543)
  })

  it('skips chatSessions discovery when an OTel source is present', async () => {
    if (!isSqliteAvailable()) return

    vi.unstubAllEnvs()
    const dbPath = join(tmpDir, 'agent-traces.db')
    vi.stubEnv('CODEBURN_COPILOT_OTEL_DB', dbPath)
    vi.stubEnv('CODEBURN_COPILOT_DISABLE_OTEL', '')
    createOtelDb(dbPath)
    insertSpan(dbPath, {
      spanId: 'span-chatsession-skip',
      traceId: 'trace-chatsession-skip',
      operationName: 'chat',
      startTimeMs: 1000,
      attrs: {
        'gen_ai.conversation.id': 'conv-chatsession-skip',
        'gen_ai.response.model': 'gpt-4.1',
        'gen_ai.usage.input_tokens': 100,
        'gen_ai.usage.output_tokens': 10,
      },
    })

    const wsDir = join(tmpDir, 'vscode-ws')
    const hashDir = join(wsDir, 'abc123')
    const workspaceChatSessionsDir = join(hashDir, 'chatSessions')
    const globalDir = join(tmpDir, 'globalStorage')
    const emptyWindowDir = join(globalDir, 'emptyWindowChatSessions')
    await mkdir(workspaceChatSessionsDir, { recursive: true })
    await mkdir(emptyWindowDir, { recursive: true })
    await writeFile(join(hashDir, 'workspace.json'), JSON.stringify({ folder: 'file:///home/user/myapp' }))
    await createChatSessionFile(join(workspaceChatSessionsDir, 'workspace.jsonl'), [
      { kind: 0, v: { version: 3, creationDate: 1780157113020, sessionId: 'chat-workspace', requests: [] } },
      { kind: 2, k: ['requests'], v: [chatSessionSampleRequest()] },
    ])
    await createChatSessionFile(join(emptyWindowDir, 'empty-window.jsonl'), [
      { kind: 0, v: { version: 3, creationDate: 1780157113020, sessionId: 'chat-empty-window', requests: [] } },
      { kind: 2, k: ['requests'], v: [chatSessionSampleRequest({ requestId: 'request-empty-window' })] },
    ])

    const provider = createCopilotProvider('/nonexistent/legacy', wsDir, globalDir)
    const sources = await provider.discoverSessions()

    expect(sources.filter(s => (s as { sourceType?: string }).sourceType === 'otel')).toHaveLength(1)
    expect(sources.filter(s => (s as { sourceType?: string }).sourceType === 'chatsession')).toHaveLength(0)
  })

  it('applies append-then-edit journal updates', async () => {
    const filePath = join(tmpDir, 'append-edit.jsonl')
    await createChatSessionFile(filePath, [
      { kind: 0, v: { version: 3, creationDate: 1780157113020, sessionId: 'chat-edit', requests: [] } },
      { kind: 2, k: ['requests'], v: [chatSessionSampleRequest()] },
      { kind: 1, k: ['requests', 0, 'result', 'metadata', 'outputTokens'], v: 88 },
    ])

    const calls = await collectCalls({ path: filePath, project: 'myproject', provider: 'copilot', sourceType: 'chatsession' })

    expect(calls).toHaveLength(1)
    expect(calls[0]!.outputTokens).toBe(88)
  })

  it('deduplicates by requestId across parser runs', async () => {
    const filePath = join(tmpDir, 'dedupe.jsonl')
    await createChatSessionFile(filePath, [
      { kind: 0, v: { version: 3, creationDate: 1780157113020, sessionId: 'chat-dedupe', requests: [] } },
      { kind: 2, v: [chatSessionSampleRequest()] },
    ])
    const source = { path: filePath, project: 'myproject', provider: 'copilot', sourceType: 'chatsession' }
    const seenKeys = new Set<string>()

    const calls1 = await collectCalls(source, seenKeys)
    const calls2 = await collectCalls(source, seenKeys)

    expect(calls1).toHaveLength(1)
    expect(calls2).toHaveLength(0)
  })

  it('ignores prototype-pollution journal paths without crashing', async () => {
    const filePath = join(tmpDir, 'proto.jsonl')
    await createChatSessionFile(filePath, [
      { kind: 0, v: { version: 3, creationDate: 1780157113020, sessionId: 'chat-proto', requests: [] } },
      { kind: 1, k: ['__proto__', 'polluted'], v: true },
      { kind: 1, k: ['constructor', 'prototype', 'polluted'], v: true },
      { kind: 2, k: ['requests'], v: [chatSessionSampleRequest()] },
    ])

    expect(({} as { polluted?: unknown }).polluted).toBeUndefined()
    const calls = await collectCalls({ path: filePath, project: 'myproject', provider: 'copilot', sourceType: 'chatsession' })

    expect(calls).toHaveLength(1)
    expect(({} as { polluted?: unknown }).polluted).toBeUndefined()
  })

  it('skips legacy transcripts for a workspace hash that has chatSessions', async () => {
    const wsDir = join(tmpDir, 'vscode-ws')
    const hashDir = join(wsDir, 'abc123')
    const chatSessionsDir = join(hashDir, 'chatSessions')
    const transcriptsDir = join(hashDir, 'GitHub.copilot-chat', 'transcripts')
    await mkdir(chatSessionsDir, { recursive: true })
    await mkdir(transcriptsDir, { recursive: true })
    await writeFile(join(hashDir, 'workspace.json'), JSON.stringify({ folder: 'file:///home/user/myapp' }))
    await createChatSessionFile(join(chatSessionsDir, 'chat.jsonl'), [
      { kind: 0, v: { version: 3, creationDate: 1780157113020, sessionId: 'chat-modern', requests: [] } },
      { kind: 2, k: ['requests'], v: [chatSessionSampleRequest()] },
    ])
    await writeFile(join(transcriptsDir, 'legacy.jsonl'), transcriptSessionStart('legacy') + '\n')

    const provider = createCopilotProvider('/nonexistent/legacy', wsDir, '/nonexistent/global')
    const sessions = await provider.discoverSessions()

    expect(sessions).toHaveLength(1)
    expect((sessions[0] as { sourceType?: string }).sourceType).toBe('chatsession')
    expect(sessions[0]!.path).toContain(`${join('abc123', 'chatSessions')}`)
  })
})

describe('copilot provider - discoverSessions', () => {
  beforeEach(async () => {
    tmpDir = await mkdtemp(join(tmpdir(), 'copilot-test-'))
    // Disable OTel discovery so tests aren't contaminated by real sessions
    vi.stubEnv('CODEBURN_COPILOT_DISABLE_OTEL', '1')
  })

  afterEach(async () => {
    await rm(tmpDir, { recursive: true, force: true })
    vi.unstubAllEnvs()
  })

  it('discovers sessions from directory', async () => {
    await createSessionDir('sess-disc-001', [modelChange('gpt-4.1')])
    await createSessionDir('sess-disc-002', [modelChange('gpt-4.1')])

    const provider = createCopilotProvider(tmpDir, '/nonexistent/vscode')
    const sessions = await provider.discoverSessions()

    expect(sessions).toHaveLength(2)
    expect(sessions.every(s => s.provider === 'copilot')).toBe(true)
    expect(sessions.every(s => s.path.endsWith('events.jsonl'))).toBe(true)
  })

  it('reads project name from workspace.yaml cwd', async () => {
    await createSessionDir('sess-disc-003', [modelChange('gpt-4.1')], '/home/user/myapp')

    const provider = createCopilotProvider(tmpDir, '/nonexistent/vscode')
    const sessions = await provider.discoverSessions()

    expect(sessions).toHaveLength(1)
    expect(sessions[0]!.project).toBe('myapp')
  })

  it('strips quotes and trailing comments from workspace.yaml cwd', async () => {
    const sessionDir = join(tmpDir, 'sess-quoted')
    await mkdir(sessionDir, { recursive: true })
    await writeFile(join(sessionDir, 'workspace.yaml'), 'cwd: "/home/user/myapp"  # project root\n')
    await writeFile(join(sessionDir, 'events.jsonl'), '\n')

    const provider = createCopilotProvider(tmpDir, '/nonexistent/vscode')
    const sessions = await provider.discoverSessions()

    expect(sessions).toHaveLength(1)
    expect(sessions[0]!.project).toBe('myapp')
  })

  it('returns empty when directory does not exist', async () => {
    const provider = createCopilotProvider('/nonexistent/path', '/nonexistent/vscode')
    const sessions = await provider.discoverSessions()
    expect(sessions).toHaveLength(0)
  })

  it('skips entries without events.jsonl', async () => {
    const emptyDir = join(tmpDir, 'empty-session')
    await mkdir(emptyDir, { recursive: true })

    const provider = createCopilotProvider(tmpDir, '/nonexistent/vscode')
    const sessions = await provider.discoverSessions()
    expect(sessions).toHaveLength(0)
  })

  it('discovers VS Code workspace transcripts', async () => {
    const wsDir = join(tmpDir, 'vscode-ws')
    const transcriptsDir = join(wsDir, 'abc123', 'GitHub.copilot-chat', 'transcripts')
    await mkdir(transcriptsDir, { recursive: true })
    await writeFile(join(wsDir, 'abc123', 'workspace.json'), JSON.stringify({ folder: 'file:///home/user/myapp' }))
    await writeFile(join(transcriptsDir, 'session-1.jsonl'), JSON.stringify({ type: 'session.start', data: { sessionId: 's1', producer: 'copilot-agent' } }) + '\n')

    const provider = createCopilotProvider('/nonexistent/legacy', wsDir)
    const sessions = await provider.discoverSessions()

    expect(sessions).toHaveLength(1)
    expect(sessions[0]!.project).toBe('myapp')
    expect(sessions[0]!.path).toContain('session-1.jsonl')
  })

  it('includes VSCodium workspaceStorage paths on all supported platforms', () => {
    expect(getVSCodeWorkspaceStorageDirs('/Users/test', 'darwin')).toContain(
      posix.join('/Users/test', 'Library', 'Application Support', 'VSCodium', 'User', 'workspaceStorage'),
    )
    expect(getVSCodeWorkspaceStorageDirs('C:\\Users\\test', 'win32')).toContain(
      win32.join('C:\\Users\\test', 'AppData', 'Roaming', 'VSCodium', 'User', 'workspaceStorage'),
    )
    expect(getVSCodeWorkspaceStorageDirs('/home/test', 'linux')).toContain(
      posix.join('/home/test', '.config', 'VSCodium', 'User', 'workspaceStorage'),
    )
  })

  it('includes VSCodium globalStorage paths on all supported platforms', () => {
    expect(getVSCodeGlobalStorageDirs('/Users/test', 'darwin')).toContain(
      posix.join('/Users/test', 'Library', 'Application Support', 'VSCodium', 'User', 'globalStorage'),
    )
    expect(getVSCodeGlobalStorageDirs('C:\\Users\\test', 'win32')).toContain(
      win32.join('C:\\Users\\test', 'AppData', 'Roaming', 'VSCodium', 'User', 'globalStorage'),
    )
    expect(getVSCodeGlobalStorageDirs('/home/test', 'linux')).toContain(
      posix.join('/home/test', '.config', 'VSCodium', 'User', 'globalStorage'),
    )
  })
})

describe('copilot provider - metadata', () => {
  it('has correct name and displayName', () => {
    expect(copilot.name).toBe('copilot')
    expect(copilot.displayName).toBe('Copilot')
  })

  it('normalizes tool display names', () => {
    expect(copilot.toolDisplayName('bash')).toBe('Bash')
    expect(copilot.toolDisplayName('read_file')).toBe('Read')
    expect(copilot.toolDisplayName('write_file')).toBe('Edit')
    expect(copilot.toolDisplayName('web_search')).toBe('WebSearch')
    expect(copilot.toolDisplayName('github-mcp-server-list_issues')).toBe('mcp__github_mcp_server__list_issues')
    expect(copilot.toolDisplayName('unknown_tool')).toBe('unknown_tool')
  })

  it('normalizes model display names', () => {
    expect(copilot.modelDisplayName('gpt-4.1')).toBe('GPT-4.1')
    expect(copilot.modelDisplayName('gpt-4.1-mini')).toBe('GPT-4.1 Mini')
    expect(copilot.modelDisplayName('gpt-4.1-nano')).toBe('GPT-4.1 Nano')
    expect(copilot.modelDisplayName('gpt-5-mini')).toBe('GPT-5 Mini')
    expect(copilot.modelDisplayName('o3')).toBe('o3')
    expect(copilot.modelDisplayName('o4-mini')).toBe('o4-mini')
    expect(copilot.modelDisplayName('copilot-openai-auto')).toBe('Copilot (OpenAI auto)')
    expect(copilot.modelDisplayName('copilot-anthropic-auto')).toBe('Copilot (Anthropic auto)')
    expect(copilot.modelDisplayName('unknown-model-xyz')).toBe('unknown-model-xyz')
  })

  it('longest-prefix match wins for versioned model IDs', () => {
    // gpt-5-mini-2026-01-01 must match gpt-5-mini, not gpt-5
    expect(copilot.modelDisplayName('gpt-5-mini-2026-01-01')).toBe('GPT-5 Mini')
    expect(copilot.modelDisplayName('gpt-4.1-mini-2026-01-01')).toBe('GPT-4.1 Mini')
  })
})

// ---------------------------------------------------------------------------
// OTel cache token tests
//
// These tests verify that the OTel SQLite parser correctly extracts
// cacheReadInputTokens and cacheCreationInputTokens from the agent-traces.db
// schema, and that multiple conversations from the same DB file are each
// parsed independently with their full cache token data intact.
//
// This is the regression guard for the bug documented in DEBUG_HANDOFF.md:
// cache tokens were extracted during parsing but lost in aggregation because
// all conversations shared the same file path key in the session cache.
// ---------------------------------------------------------------------------

const requireForTest = createRequire(import.meta.url)

type TestDb = {
  exec(sql: string): void
  prepare(sql: string): { run(...params: unknown[]): void }
  close(): void
}

/** Creates a minimal agent-traces.db schema matching the VS Code Copilot Chat OTel store. */
function createOtelDb(dbPath: string): void {
  const { DatabaseSync } = requireForTest('node:sqlite') as { DatabaseSync: new (path: string) => TestDb }
  const db = new DatabaseSync(dbPath)
  db.exec(`
    CREATE TABLE spans (
      span_id      TEXT PRIMARY KEY NOT NULL,
      trace_id     TEXT NOT NULL,
      operation_name TEXT,
      start_time_ms INTEGER NOT NULL DEFAULT 0,
      response_model TEXT
    );
    CREATE TABLE span_attributes (
      id      INTEGER PRIMARY KEY AUTOINCREMENT,
      span_id TEXT NOT NULL,
      key     TEXT NOT NULL,
      value   TEXT
    );
  `)
  db.close()
}

interface SpanDef {
  spanId: string
  traceId: string
  operationName: string
  startTimeMs?: number
  responseModel?: string
  attrs: Record<string, string | number>
}

function insertSpan(dbPath: string, span: SpanDef): void {
  const { DatabaseSync } = requireForTest('node:sqlite') as { DatabaseSync: new (path: string) => TestDb }
  const db = new DatabaseSync(dbPath)
  db.prepare(
    `INSERT INTO spans (span_id, trace_id, operation_name, start_time_ms, response_model)
     VALUES (?, ?, ?, ?, ?)`
  ).run(span.spanId, span.traceId, span.operationName, span.startTimeMs ?? 0, span.responseModel ?? null)
  const attrStmt = db.prepare(
    `INSERT INTO span_attributes (span_id, key, value) VALUES (?, ?, ?)`
  )
  for (const [key, value] of Object.entries(span.attrs)) {
    attrStmt.run(span.spanId, key, String(value))
  }
  db.close()
}

describe('copilot provider - OTel cache token parsing', () => {
  let tmpDir: string
  let dbPath: string

  beforeEach(async () => {
    tmpDir = await mkdtemp(join(tmpdir(), 'copilot-otel-test-'))
    dbPath = join(tmpDir, 'agent-traces.db')
    vi.stubEnv('CODEBURN_COPILOT_OTEL_DB', dbPath)
    vi.stubEnv('CODEBURN_COPILOT_DISABLE_OTEL', '')
  })

  afterEach(async () => {
    await rm(tmpDir, { recursive: true, force: true })
    vi.unstubAllEnvs()
  })

  it('skips tests when node:sqlite is unavailable', () => {
    if (!isSqliteAvailable()) return
    // Placeholder — subsequent tests use isSqliteAvailable guard
  })

  it('extracts cache tokens from a single OTel conversation', async () => {
    if (!isSqliteAvailable()) return

    createOtelDb(dbPath)
    insertSpan(dbPath, {
      spanId: 'span-001',
      traceId: 'trace-001',
      operationName: 'chat',
      startTimeMs: 1000,
      responseModel: 'gpt-4.1',
      attrs: {
        'gen_ai.conversation.id': 'conv-001',
        'gen_ai.response.model': 'gpt-4.1',
        'gen_ai.usage.input_tokens': 1000,
        'gen_ai.usage.output_tokens': 200,
        'gen_ai.usage.cache_read.input_tokens': 50000,
        'gen_ai.usage.cache_creation.input_tokens': 500,
      },
    })

    const provider = createCopilotProvider('/nonexistent/jsonl', '/nonexistent/ws')
    const sources = await provider.discoverSessions()

    const otelSources = sources.filter(s => s.path.startsWith(dbPath))
    expect(otelSources).toHaveLength(1)
    expect(otelSources[0]!.provider).toBe('copilot')

    const calls: ParsedProviderCall[] = []
    for await (const call of provider.createSessionParser(otelSources[0]!, new Set()).parse()) {
      calls.push(call)
    }

    expect(calls).toHaveLength(1)
    const call = calls[0]!
    expect(call.model).toBe('gpt-4.1')
    expect(call.inputTokens).toBe(1000)
    expect(call.outputTokens).toBe(200)
    expect(call.cacheReadInputTokens).toBe(50000)
    expect(call.cacheCreationInputTokens).toBe(500)
    expect(call.costUSD).toBeGreaterThan(0)
  })

  it('discovers one source per OTel DB file (not per conversation)', async () => {
    if (!isSqliteAvailable()) return

    createOtelDb(dbPath)

    // Two independent conversations in the same DB
    insertSpan(dbPath, {
      spanId: 'span-a1', traceId: 'trace-a', operationName: 'chat', startTimeMs: 1000,
      attrs: {
        'gen_ai.conversation.id': 'conv-alpha',
        'gen_ai.response.model': 'gpt-4.1',
        'gen_ai.usage.input_tokens': 800,
        'gen_ai.usage.output_tokens': 100,
        'gen_ai.usage.cache_read.input_tokens': 40000,
        'gen_ai.usage.cache_creation.input_tokens': 400,
      },
    })
    insertSpan(dbPath, {
      spanId: 'span-b1', traceId: 'trace-b', operationName: 'chat', startTimeMs: 2000,
      attrs: {
        'gen_ai.conversation.id': 'conv-beta',
        'gen_ai.response.model': 'claude-sonnet-4',
        'gen_ai.usage.input_tokens': 600,
        'gen_ai.usage.output_tokens': 80,
        'gen_ai.usage.cache_read.input_tokens': 30000,
        'gen_ai.usage.cache_creation.input_tokens': 300,
      },
    })

    const provider = createCopilotProvider('/nonexistent/jsonl', '/nonexistent/ws')
    const sources = await provider.discoverSessions()

    // One source per DB file (not per conversation)
    const otelSources = sources.filter(s => s.path === dbPath)
    expect(otelSources).toHaveLength(1)
    expect(otelSources[0]!.path).toBe(dbPath)

    // But the parser still yields calls from BOTH conversations
    const calls: ParsedProviderCall[] = []
    for await (const call of provider.createSessionParser(otelSources[0]!, new Set()).parse()) {
      calls.push(call)
    }
    expect(calls).toHaveLength(2)
    const sessionIds = new Set(calls.map(c => c.sessionId))
    expect(sessionIds.size).toBe(2)
  })

  it('preserves cache tokens when parsing multiple conversations from one DB', async () => {
    if (!isSqliteAvailable()) return

    createOtelDb(dbPath)

    insertSpan(dbPath, {
      spanId: 'span-c1', traceId: 'trace-c', operationName: 'chat', startTimeMs: 1000,
      attrs: {
        'gen_ai.conversation.id': 'conv-c',
        'gen_ai.response.model': 'gpt-4.1',
        'gen_ai.usage.input_tokens': 500,
        'gen_ai.usage.output_tokens': 100,
        'gen_ai.usage.cache_read.input_tokens': 20000,
        'gen_ai.usage.cache_creation.input_tokens': 200,
      },
    })
    insertSpan(dbPath, {
      spanId: 'span-d1', traceId: 'trace-d', operationName: 'chat', startTimeMs: 2000,
      attrs: {
        'gen_ai.conversation.id': 'conv-d',
        'gen_ai.response.model': 'gpt-4.1',
        'gen_ai.usage.input_tokens': 700,
        'gen_ai.usage.output_tokens': 150,
        'gen_ai.usage.cache_read.input_tokens': 35000,
        'gen_ai.usage.cache_creation.input_tokens': 350,
      },
    })

    const provider = createCopilotProvider('/nonexistent/jsonl', '/nonexistent/ws')
    const sources = await provider.discoverSessions()
    // One source per DB file — the parser iterates all conversations internally
    const otelSource = sources.find(s => s.path === dbPath)
    expect(otelSource).toBeDefined()
    const allCalls: ParsedProviderCall[] = []
    for await (const call of provider.createSessionParser(otelSource!, new Set()).parse()) {
      allCalls.push(call)
    }

    expect(allCalls).toHaveLength(2)

    const totalCacheRead = allCalls.reduce((sum, c) => sum + c.cacheReadInputTokens, 0)
    const totalCacheCreate = allCalls.reduce((sum, c) => sum + c.cacheCreationInputTokens, 0)

    // Both conversations' cache tokens must survive end-to-end
    expect(totalCacheRead).toBe(55000)   // 20000 + 35000
    expect(totalCacheCreate).toBe(550)   // 200 + 350
  })

  it('includes tool names from execute_tool spans in the same trace', async () => {
    if (!isSqliteAvailable()) return

    createOtelDb(dbPath)
    // chat span
    insertSpan(dbPath, {
      spanId: 'span-e1', traceId: 'trace-e', operationName: 'chat', startTimeMs: 1000,
      attrs: {
        'gen_ai.conversation.id': 'conv-e',
        'gen_ai.response.model': 'gpt-4.1',
        'gen_ai.usage.input_tokens': 300,
        'gen_ai.usage.output_tokens': 50,
        'gen_ai.usage.cache_read.input_tokens': 10000,
        'gen_ai.usage.cache_creation.input_tokens': 100,
      },
    })
    // execute_tool span in the same trace
    insertSpan(dbPath, {
      spanId: 'span-e2', traceId: 'trace-e', operationName: 'execute_tool', startTimeMs: 1500,
      attrs: {
        'gen_ai.tool.name': 'readFile',
      },
    })

    const provider = createCopilotProvider('/nonexistent/jsonl', '/nonexistent/ws')
    const sources = await provider.discoverSessions()
    const src = sources.find(s => s.path.startsWith(dbPath))
    expect(src).toBeDefined()

    const calls: ParsedProviderCall[] = []
    for await (const call of provider.createSessionParser(src!, new Set()).parse()) {
      calls.push(call)
    }

    expect(calls).toHaveLength(1)
    expect(calls[0]!.tools).toContain('Read')
    expect(calls[0]!.cacheReadInputTokens).toBe(10000)
  })

  it('skips OTel spans with zero input and output tokens', async () => {
    if (!isSqliteAvailable()) return

    createOtelDb(dbPath)
    insertSpan(dbPath, {
      spanId: 'span-f1', traceId: 'trace-f', operationName: 'chat', startTimeMs: 1000,
      attrs: {
        'gen_ai.conversation.id': 'conv-f',
        'gen_ai.response.model': 'gpt-4.1',
        'gen_ai.usage.input_tokens': 0,
        'gen_ai.usage.output_tokens': 0,
        'gen_ai.usage.cache_read.input_tokens': 50000,
        'gen_ai.usage.cache_creation.input_tokens': 500,
      },
    })

    const provider = createCopilotProvider('/nonexistent/jsonl', '/nonexistent/ws')
    const sources = await provider.discoverSessions()
    const src = sources.find(s => s.path.startsWith(dbPath))
    expect(src).toBeDefined()

    const calls: ParsedProviderCall[] = []
    for await (const call of provider.createSessionParser(src!, new Set()).parse()) {
      calls.push(call)
    }
    // Span with zero input AND output tokens is skipped
    expect(calls).toHaveLength(0)
  })

  it('OTel source path equals the plain DB file path and durableSources is true', async () => {
    if (!isSqliteAvailable()) return

    createOtelDb(dbPath)
    insertSpan(dbPath, {
      spanId: 'span-g1', traceId: 'trace-g', operationName: 'chat', startTimeMs: 1000,
      attrs: {
        'gen_ai.conversation.id': 'conv-g',
        'gen_ai.response.model': 'gpt-4.1',
        'gen_ai.usage.input_tokens': 100,
        'gen_ai.usage.output_tokens': 10,
        'gen_ai.usage.cache_read.input_tokens': 0,
        'gen_ai.usage.cache_creation.input_tokens': 0,
      },
    })

    const provider = createCopilotProvider('/nonexistent/jsonl', '/nonexistent/ws')

    // durableSources must be true on the copilot provider
    expect(provider.durableSources).toBe(true)

    const sources = await provider.discoverSessions()
    const otelSrc = sources.find(s => s.path.startsWith(dbPath))
    expect(otelSrc).toBeDefined()

    // Path is the plain DB file path (no #otel-conv= compound suffix)
    expect(otelSrc!.path).toBe(dbPath)

    // Parser must open the DB and produce results for all conversations
    const calls: ParsedProviderCall[] = []
    for await (const call of provider.createSessionParser(otelSrc!, new Set()).parse()) {
      calls.push(call)
    }
    expect(calls).toHaveLength(1)
    expect(calls[0]!.inputTokens).toBe(100)
  })

  it('attributes genuine subagents but excludes the root agent', async () => {
    if (!isSqliteAvailable()) return

    createOtelDb(dbPath)

    // Root agent turn: chat span + invoke_agent WITHOUT a parent session.
    insertSpan(dbPath, {
      spanId: 'span-root-chat', traceId: 'trace-root', operationName: 'chat', startTimeMs: 1000,
      attrs: {
        'gen_ai.conversation.id': 'conv-h',
        'gen_ai.response.model': 'gpt-4.1',
        'gen_ai.usage.input_tokens': 400,
        'gen_ai.usage.output_tokens': 60,
        'gen_ai.usage.cache_read.input_tokens': 0,
        'gen_ai.usage.cache_creation.input_tokens': 0,
      },
    })
    insertSpan(dbPath, {
      spanId: 'span-root-agent', traceId: 'trace-root', operationName: 'invoke_agent', startTimeMs: 1010,
      attrs: {
        'gen_ai.conversation.id': 'conv-h',
        'gen_ai.agent.name': 'GitHub Copilot Chat',
      },
    })

    // Genuine subagent: its own trace holds the subagent's chat span plus an
    // invoke_agent span carrying copilot_chat.parent_chat_session_id.
    insertSpan(dbPath, {
      spanId: 'span-sub-chat', traceId: 'trace-sub', operationName: 'chat', startTimeMs: 2000,
      attrs: {
        'gen_ai.conversation.id': 'conv-h',
        'gen_ai.response.model': 'claude-haiku-4.5',
        'gen_ai.usage.input_tokens': 250,
        'gen_ai.usage.output_tokens': 30,
        'gen_ai.usage.cache_read.input_tokens': 0,
        'gen_ai.usage.cache_creation.input_tokens': 0,
      },
    })
    insertSpan(dbPath, {
      spanId: 'span-sub-agent', traceId: 'trace-sub', operationName: 'invoke_agent', startTimeMs: 2010,
      attrs: {
        'gen_ai.conversation.id': 'conv-h',
        'gen_ai.agent.name': 'Explore',
        'copilot_chat.parent_chat_session_id': 'conv-h',
      },
    })

    const provider = createCopilotProvider('/nonexistent/jsonl', '/nonexistent/ws')
    const sources = await provider.discoverSessions()
    const src = sources.find(s => s.path.startsWith(dbPath))
    expect(src).toBeDefined()

    const calls: ParsedProviderCall[] = []
    for await (const call of provider.createSessionParser(src!, new Set()).parse()) {
      calls.push(call)
    }

    expect(calls).toHaveLength(2)
    const rootCall = calls.find(c => c.model === 'gpt-4.1')!
    const subCall = calls.find(c => c.model === 'claude-haiku-4.5')!

    // Root agent must NOT surface as a subagent
    expect(rootCall.subagentTypes ?? []).not.toContain('GitHub Copilot Chat')
    expect(rootCall.subagentTypes ?? []).toHaveLength(0)

    // Genuine subagent is attributed to its own call
    expect(subCall.subagentTypes).toEqual(['Explore'])
  })

  it('normalises multi-line OTel shell scripts, dropping control-flow keywords', async () => {
    if (!isSqliteAvailable()) return

    createOtelDb(dbPath)
    insertSpan(dbPath, {
      spanId: 'span-sh-chat', traceId: 'trace-sh', operationName: 'chat', startTimeMs: 1000,
      attrs: {
        'gen_ai.conversation.id': 'conv-sh',
        'gen_ai.response.model': 'gpt-4.1',
        'gen_ai.usage.input_tokens': 100,
        'gen_ai.usage.output_tokens': 10,
        'gen_ai.usage.cache_read.input_tokens': 0,
        'gen_ai.usage.cache_creation.input_tokens': 0,
      },
    })
    // A full multi-line script with control flow and newline-separated commands,
    // exactly as the OTel store records it.
    insertSpan(dbPath, {
      spanId: 'span-sh-tool', traceId: 'trace-sh', operationName: 'execute_tool', startTimeMs: 1500,
      attrs: {
        'gen_ai.tool.name': 'run_in_terminal',
        'gen_ai.tool.call.arguments': JSON.stringify({
          command: 'for f in *.ts; do\n  echo "$f"\ndone\ngit status\nnpm test',
        }),
      },
    })

    const provider = createCopilotProvider('/nonexistent/jsonl', '/nonexistent/ws')
    const sources = await provider.discoverSessions()
    const src = sources.find(s => s.path.startsWith(dbPath))
    expect(src).toBeDefined()

    const calls: ParsedProviderCall[] = []
    for await (const call of provider.createSessionParser(src!, new Set()).parse()) {
      calls.push(call)
    }

    expect(calls).toHaveLength(1)
    const bash = calls[0]!.bashCommands
    // Real commands separated by newlines/`;` are captured
    expect(bash).toEqual(expect.arrayContaining(['echo', 'git', 'npm']))
    // Control-flow keywords are NOT reported as commands
    for (const kw of ['for', 'do', 'done']) {
      expect(bash).not.toContain(kw)
    }
  })
})

// ---------------------------------------------------------------------------
// JetBrains (IntelliJ / PyCharm / …) session parsing
// ---------------------------------------------------------------------------
//
// The JetBrains Copilot plugin persists sessions to a Nitrite (H2 MVStore) .db
// (~/.config/github-copilot/<ide>/<kind>/<storeId>/copilot-*-nitrite.db) of
// Java-serialized documents. Assistant replies are nested-escaped
// {"__first__":{"type":"Subgraph",…}} blobs; the model and projectName are
// separate serialized fields. These helpers reproduce that on-disk shape so
// tests exercise the real regex/scan extraction path.

describe('copilot provider - JetBrains parsing', () => {
  beforeEach(async () => {
    tmpDir = await mkdtemp(join(tmpdir(), 'copilot-jetbrains-test-'))
    vi.stubEnv('CODEBURN_COPILOT_DISABLE_OTEL', '1')
  })

  afterEach(async () => {
    await rm(tmpDir, { recursive: true, force: true })
    vi.unstubAllEnvs()
  })

  // A JetBrains source: session content lives in the Nitrite .db.
  function jbDbSource(path: string, sessionId: string, mtime = '2026-07-03T12:00:00.000Z') {
    return {
      path, project: 'copilot-jetbrains', provider: 'copilot', sourceType: 'jetbrains',
      sessionId, storeId: sessionId, dbPath: path, mtime,
    } as unknown as { path: string; project: string; provider: string; sourceType?: string }
  }

  // ---- Nitrite .db parsing ----

  // Build an assistant response blob in the real nested-escaped shape:
  // {"__first__":{"type":"Subgraph","value":"{\"<uuid>\":{\"type\":\"Value\",
  //   \"value\":\"{\\\"type\\\":\\\"Markdown\\\",\\\"data\\\":\\\"{\\\\\\\"text\\\\\\\":...}\"}"}}
  function jbAssistantBlob(text: string, opts: { model?: string; errored?: boolean; files?: string[] } = {}) {
    const innerMd = { type: 'Markdown', data: JSON.stringify({ text, annotations: [] }) }
    const valueMap: Record<string, unknown> = {
      'a1b2c3d4-0000-0000-0000-000000000001': { type: 'Value', value: JSON.stringify(innerMd) },
    }
    if (opts.model) valueMap['__model__'] = { type: 'Value', value: `{"model":"${opts.model}"}` }
    // Files the turn referenced — project is derived from these file:// paths.
    if (opts.files) {
      valueMap['__refs__'] = {
        type: 'Value',
        value: JSON.stringify({ type: 'References', data: opts.files.map((f) => `file://${f}`).join(' ') }),
      }
    }
    const outer: Record<string, unknown> = {
      __first__: { type: 'Subgraph', value: JSON.stringify(valueMap) },
    }
    if (opts.errored) {
      // Real failed turns store the error under a type:"Error" record with a
      // `message` field (NOT a Markdown `text`), so it is not billable output.
      outer['__err__'] = {
        type: 'Value',
        value: JSON.stringify({ type: 'Error', message: 'Sorry, an error occurred while generating a response' }),
      }
    }
    return JSON.stringify(outer)
  }

  // An AGENT-MODE assistant blob: the reply lives in an AgentRound record, and
  // (as in real agent sessions) the Markdown record holds the USER's prompt,
  // which must NOT be counted as the reply. `rounds` is a list of AgentRound
  // replies (a single blob can carry several); a pure tool-call round has ''.
  function jbAgentBlob(rounds: string[], opts: { model?: string; userPrompt?: string; errored?: boolean } = {}) {
    const valueMap: Record<string, unknown> = {}
    let n = 0
    // The user prompt as a Markdown record — a decoy the reply extractor must
    // skip in agent mode (real stores put the prompt here, not the answer).
    if (opts.userPrompt !== undefined) {
      const md = { type: 'Markdown', data: JSON.stringify({ text: opts.userPrompt, annotations: [] }) }
      valueMap[`u0000000-0000-0000-0000-00000000000${n++}`] = { type: 'Value', value: JSON.stringify(md) }
    }
    for (const reply of rounds) {
      const ar = { type: 'AgentRound', data: JSON.stringify({ roundId: n, reply, toolCalls: [] }) }
      valueMap[`a0000000-0000-0000-0000-00000000000${n++}`] = { type: 'Value', value: JSON.stringify(ar) }
    }
    if (opts.model) valueMap['__model__'] = { type: 'Value', value: `{"model":"${opts.model}"}` }
    const outer: Record<string, unknown> = { __first__: { type: 'Subgraph', value: JSON.stringify(valueMap) } }
    if (opts.errored) {
      outer['__err__'] = {
        type: 'Value',
        value: JSON.stringify({ type: 'Error', message: 'Sorry, an error occurred while generating a response' }),
      }
    }
    return JSON.stringify(outer)
  }

  // A conversation title record in the real framing: `$<GUID>…name…value<TITLE>t\x00\x06source`.
  function jbConversationRecord(guid: string, title: string) {
    return `$${guid}t\x00\x04namesq\x00\x01?@\x00\x00w\x00\x00t\x00value t\x00${title}t\x00\x06sourcet\x00copilotx`
  }

  // Assemble a minimal Nitrite-.db-shaped buffer: MVStore header + entity-class
  // anchor + optional conversation records + assistant blobs. When a blob is
  // preceded by a conversation record, turns attribute to that conversation.
  function jbDbContent(blobs: string[], conversations: string[] = []) {
    return (
      'H:2,block:9,blockSize:1000,format:3\n' +
      'com.github.copilot.agent.session.persistence.nitrite.entity.NtAgentTurn\n' +
      conversations.join('\n') + '\n' +
      blobs.join('\nt\x00\x00model\n') +
      '\n'
    )
  }

  async function createJetBrainsDb(root: string, ide: string, kind: string, storeId: string, content: string) {
    const dir = join(root, ide, kind, storeId)
    await mkdir(dir, { recursive: true })
    const dbName =
      kind === 'chat-agent-sessions'
        ? 'copilot-agent-sessions-nitrite.db'
        : kind === 'chat-edit-sessions'
          ? 'copilot-edit-sessions-nitrite.db'
          : 'copilot-chat-nitrite.db'
    await writeFile(join(dir, dbName), content)
    return join(dir, dbName)
  }

  // The plugin-recorded project label, in the real Java-serialized framing:
  // the field key `projectName` followed by TC_STRING `0x74 <u16 len> <value>`,
  // then the sibling `user` field. This is what extractJetBrainsProjectName reads.
  function jbProjectNameField(name: string) {
    // TC_STRING length is the UTF-8 BYTE count (the .db is written UTF-8 and
    // read back as latin1), not the JS UTF-16 code-unit count.
    const len = Buffer.byteLength(name, 'utf8')
    const hi = String.fromCharCode((len >> 8) & 0xff)
    const lo = String.fromCharCode(len & 0xff)
    return `t\x00\x0bprojectName\x74${hi}${lo}${name}t\x00\x04usert\x00\x08dev-user`
  }

  it('parses assistant turns from a Nitrite .db and estimates cost', async () => {
    const content = jbDbContent([
      jbAssistantBlob('Hello! How can I help you today?'),
      jbAssistantBlob('Here is a longer architecture overview with plenty of detail.', { model: 'claude-opus-4.5' }),
    ])
    const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'conv-1', content)

    const calls = await collectCalls(jbDbSource(dbPath, 'conv-1'))
    expect(calls).toHaveLength(2)
    expect(calls[0]!.outputTokens).toBeGreaterThan(0)
    expect(calls[0]!.costIsEstimated).toBe(true)
    expect(calls[0]!.inputTokens).toBe(0)
    // Per-turn model recovered from inside the blob, normalised dots→dashes.
    expect(calls[1]!.model).toBe('claude-opus-4-5')
    expect(calls[1]!.costUSD).toBeGreaterThan(0)
    // Dedup keys are conversation-scoped, content-derived, and distinct.
    expect(calls[0]!.deduplicationKey).toMatch(/^copilot:jb:conv-1:[0-9a-f]{12}:1$/)
    expect(calls[1]!.deduplicationKey).toMatch(/^copilot:jb:conv-1:[0-9a-f]{12}:1$/)
    expect(calls[0]!.deduplicationKey).not.toBe(calls[1]!.deduplicationKey)
  })

  it('recovers a reply containing quotes without garbling or duplicating it', async () => {
    // Regression: the unescape loop must run extraction ONLY on the final,
    // fully-unescaped form. Accumulating matches at every depth would union a
    // half-unescaped (quote-truncated) capture with the full one, producing a
    // garbled duplicate and inflating the token/cost estimate.
    const reply = 'Use `printf "%s"` to print, then check "status" here.'
    const content = jbDbContent([jbAssistantBlob(reply, { model: 'claude-opus-4.5' })])
    const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'conv-quote', content)

    const calls = await collectCalls(jbDbSource(dbPath, 'conv-quote'))
    expect(calls).toHaveLength(1)
    // Token estimate reflects the true reply length (CHARS_PER_TOKEN = 4), not
    // an inflated garbled copy.
    expect(calls[0]!.outputTokens).toBe(Math.ceil(reply.length / 4))
  })

  it('counts a multibyte UTF-8 reply by codepoints, not latin1 bytes', async () => {
    // The .db is read as latin1; the parser must re-decode to UTF-8 so a
    // multibyte char counts as one codepoint for the token estimate.
    const reply = 'café ☕ déjà vu — naïve façade' // several multibyte chars
    const content = jbDbContent([jbAssistantBlob(reply, { model: 'claude-opus-4.5' })])
    const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'conv-utf8', content)

    const calls = await collectCalls(jbDbSource(dbPath, 'conv-utf8'))
    expect(calls).toHaveLength(1)
    expect(calls[0]!.outputTokens).toBe(Math.ceil(reply.length / 4))
  })

  it('extracts agent-mode replies from AgentRound (not the user prompt Markdown)', async () => {
    // Agent-mode sessions (e.g. PyCharm) store the reply in an AgentRound record;
    // the Markdown record holds the USER prompt. The reply extractor must read
    // the AgentRound reply and ignore the prompt — otherwise the turn bills $0
    // (reply never found) or bills the user's words as output.
    const reply = "Here's a quick summary of this repo: it does X, Y, and Z."
    const content = jbDbContent([
      jbAgentBlob([reply], { model: 'claude-opus-4.5', userPrompt: 'summarise this repo' }),
    ])
    const dbPath = await createJetBrainsDb(tmpDir, 'py', 'chat-agent-sessions', 'conv-agent', content)

    const calls = await collectCalls(jbDbSource(dbPath, 'conv-agent'))
    expect(calls).toHaveLength(1)
    // Priced from the AgentRound reply, not the (shorter) user prompt.
    expect(calls[0]!.outputTokens).toBe(Math.ceil(reply.length / 4))
    expect(calls[0]!.costUSD).toBeGreaterThan(0)
    expect(calls[0]!.model).toBe('claude-opus-4-5')
  })

  it('skips pure tool-call agent rounds (empty reply → no billable output)', async () => {
    // A round that only issued tool calls has reply:'' — it contributes nothing,
    // exactly like a Steps-only ask-mode blob.
    const content = jbDbContent([jbAgentBlob([''], { model: 'claude-opus-4.5' })])
    const dbPath = await createJetBrainsDb(tmpDir, 'py', 'chat-agent-sessions', 'conv-toolonly', content)
    const calls = await collectCalls(jbDbSource(dbPath, 'conv-toolonly'))
    expect(calls).toHaveLength(0)
  })

  it('a failed agent turn bills $0 and never counts the user prompt as the reply', async () => {
    // Failed agent turn: empty AgentRound reply + an error marker + a user-prompt
    // Markdown record. The parser must NOT fall back to the Markdown (that would
    // bill the user's words); an agent blob is agent mode regardless of whether
    // its reply is empty, so this is an errored turn → $0.
    const content = jbDbContent([
      jbAgentBlob([''], { model: 'claude-opus-4.5', userPrompt: 'do the thing', errored: true }),
    ])
    const dbPath = await createJetBrainsDb(tmpDir, 'py', 'chat-agent-sessions', 'conv-agenterr', content)
    const calls = await collectCalls(jbDbSource(dbPath, 'conv-agenterr'))
    expect(calls).toHaveLength(1)
    expect(calls[0]!.outputTokens).toBe(0)
    expect(calls[0]!.costUSD).toBe(0)
  })

  it('collects multiple AgentRound replies within one blob', async () => {
    // A multi-round agent turn: the first round explores (tool call, empty
    // reply), the second answers. Both non-empty replies are joined.
    const content = jbDbContent([
      jbAgentBlob(['Let me explore the project.', '', 'Done — here is what it does.'], {
        model: 'claude-opus-4.5',
      }),
    ])
    const dbPath = await createJetBrainsDb(tmpDir, 'py', 'chat-agent-sessions', 'conv-multiround', content)
    const calls = await collectCalls(jbDbSource(dbPath, 'conv-multiround'))
    expect(calls).toHaveLength(1)
    const joined = 'Let me explore the project.\nDone — here is what it does.'
    expect(calls[0]!.outputTokens).toBe(Math.ceil(joined.length / 4))
  })

  it('treats errored turns as $0 (failed generation, no billable output)', async () => {
    const content = jbDbContent([
      jbAssistantBlob('', { errored: true }),
      jbAssistantBlob('A real successful reply.', { model: 'claude-opus-4.5' }),
    ])
    const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'conv-err', content)

    const calls = await collectCalls(jbDbSource(dbPath, 'conv-err'))
    expect(calls).toHaveLength(2)
    const errored = calls.find((c) => c.outputTokens === 0)
    const good = calls.find((c) => c.outputTokens > 0)
    expect(errored).toBeDefined()
    expect(errored!.costUSD).toBe(0)
    expect(good).toBeDefined()
    expect(good!.costUSD).toBeGreaterThan(0)
  })

  it('de-duplicates repeated byte-copies of the same reply within a .db', async () => {
    const content = jbDbContent([
      jbAssistantBlob('identical reply text stored twice'),
      jbAssistantBlob('identical reply text stored twice'),
    ])
    const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'conv-dup', content)

    const calls = await collectCalls(jbDbSource(dbPath, 'conv-dup'))
    expect(calls).toHaveLength(1)
  })

  it('skips Steps/progress-only assistant blobs (no billable text)', async () => {
    const stepsBlob = JSON.stringify({
      __first__: {
        type: 'Subgraph',
        value: JSON.stringify({ x: { type: 'Value', value: JSON.stringify({ type: 'Steps', data: '[]' }) } }),
      },
    })
    const content = jbDbContent([stepsBlob, jbAssistantBlob('The only real answer.')])
    const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'conv-steps', content)

    const calls = await collectCalls(jbDbSource(dbPath, 'conv-steps'))
    expect(calls).toHaveLength(1)
    expect(calls[0]!.outputTokens).toBeGreaterThan(0)
  })

  it('per-turn model differences within one .db (opus vs gpt) are priced separately', async () => {
    const content = jbDbContent([
      jbAssistantBlob('Opus answer with enough words to score tokens.', { model: 'claude-opus-4.5' }),
      jbAssistantBlob('GPT answer with enough words to score tokens.', { model: 'gpt-5.3' }),
    ])
    const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'conv-multi', content)

    const calls = await collectCalls(jbDbSource(dbPath, 'conv-multi'))
    expect(calls).toHaveLength(2)
    expect(calls.map((c) => c.model).sort()).toEqual(['claude-opus-4-5', 'gpt-5.3'])
  })

  it('splits one .db into sessions by conversation; project = repo, title = session label', async () => {
    const guidA = '6acf5299-f9f7-404f-812d-dbe8300e1e5b'
    const guidB = '485825c0-3331-46a7-acb2-c71875ad6640'
    // Conversation A references a file in a real git repo; B touches no files.
    const repoDir = join(tmpDir, 'container', 'web-api')
    await mkdir(join(repoDir, '.git'), { recursive: true })
    await mkdir(join(repoDir, 'src'), { recursive: true })
    const fileA = join(repoDir, 'src', 'Main.java')
    // Interleave each conversation record before its own turns (turns attribute
    // to the nearest preceding conversation GUID). Title evolves default→final.
    const content =
      'H:2,block:9,blockSize:1000,format:3\n' +
      'com.github.copilot.agent.session.persistence.nitrite.entity.NtAgentTurn\n' +
      jbConversationRecord(guidA, 'New Agent Session') + '\n' +
      jbConversationRecord(guidA, 'Understanding the API Architecture') + '\n' +
      jbAssistantBlob('Answer about the web API.', { model: 'claude-opus-4.5', files: [fileA] }) + '\n' +
      jbConversationRecord(guidB, 'Exploring the Controller Layer in Spring Boot') + '\n' +
      jbAssistantBlob('Answer about the controller layer breakdown.', { model: 'gpt-5.3' }) + '\n'
    const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'multi-conv', content)

    const calls = await collectCalls(jbDbSource(dbPath, 'multi-conv'))
    expect(calls).toHaveLength(2)
    const bySession = new Map(calls.map((c) => [c.sessionId, c]))
    // Sessions are split by conversation GUID.
    expect(bySession.has(guidA)).toBe(true)
    expect(bySession.has(guidB)).toBe(true)
    // Project = the git repo root of the referenced file; else the generic
    // bucket when the chat touched no files.
    expect(bySession.get(guidA)!.project).toBe('web-api')
    expect(bySession.get(guidB)!.project).toBe('copilot-jetbrains')
    // The conversation TITLE is the session label (userMessage), NOT the project.
    expect(bySession.get(guidA)!.userMessage).toBe('Understanding the API Architecture')
    expect(bySession.get(guidB)!.userMessage).toBe('Exploring the Controller Layer in Spring Boot')
    // Titles must never appear as project names (they are chat threads).
    expect(calls.map((c) => c.project)).not.toContain('Understanding the API Architecture')
  })

  it('is idempotent across re-parses of the same .db (shared seenKeys)', async () => {
    const content = jbDbContent([jbAssistantBlob('first reply'), jbAssistantBlob('second reply')])
    const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'conv-idem', content)

    const seen = new Set<string>()
    const first = await collectCalls(jbDbSource(dbPath, 'conv-idem'), seen)
    const second = await collectCalls(jbDbSource(dbPath, 'conv-idem'), seen)
    expect(first).toHaveLength(2)
    expect(second).toHaveLength(0)
  })

  it('discovers a store dir with a Nitrite .db', async () => {
    const content = jbDbContent([jbAssistantBlob('hi there')])
    await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'db-only', content)

    const provider = createCopilotProvider('/nonexistent/legacy', '/nonexistent/ws', '/nonexistent/global', tmpDir)
    const sessions = await provider.discoverSessions()
    const jb = sessions.filter((s) => (s as { sourceType?: string }).sourceType === 'jetbrains')
    expect(jb).toHaveLength(1)
    expect((jb[0] as { dbPath?: string }).dbPath).toContain('copilot-agent-sessions-nitrite.db')
  })

  it('infers project as the git repo root of a referenced file (deep subdir → repo root)', async () => {
    // Create a real git repo on disk so the .git walk-up can resolve it.
    const repoDir = join(tmpDir, 'container', 'myapp')
    await mkdir(join(repoDir, '.git'), { recursive: true })
    await mkdir(join(repoDir, 'src', 'a'), { recursive: true })
    const fileA = join(repoDir, 'src', 'a', 'One.ts')
    const content = jbDbContent([
      jbAssistantBlob('Editing files in a real repo.', { model: 'gpt-4.1', files: [fileA] }),
    ])
    const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'conv-gitwalk', content)

    const calls = await collectCalls(jbDbSource(dbPath, 'conv-gitwalk'))
    expect(calls).toHaveLength(1)
    // Project = basename of the nearest ancestor with .git (the repo root
    // 'myapp'), NOT the deep subdir 'a'/'src' or the container dir.
    expect(calls[0]!.project).toBe('myapp')
    expect(calls[0]!.model).toBe('gpt-4.1')
  })

  it('falls back to copilot-jetbrains when no referenced file resolves to a git repo', async () => {
    const content = jbDbContent([
      jbAssistantBlob('Editing a file outside any repo.', {
        model: 'gpt-4.1',
        files: ['/nonexistent/no-repo-here/src/One.ts'],
      }),
    ])
    const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'conv-norepo', content)
    const calls = await collectCalls(jbDbSource(dbPath, 'conv-norepo'))
    expect(calls).toHaveLength(1)
    expect(calls[0]!.project).toBe('copilot-jetbrains')
  })

  it('resolves a git repo whose name contains a space', async () => {
    const repoDir = join(tmpDir, 'My Project')
    await mkdir(join(repoDir, '.git'), { recursive: true })
    await mkdir(join(repoDir, 'src'), { recursive: true })
    const file = join(repoDir, 'src', 'One.ts')
    const content = jbDbContent([
      jbAssistantBlob('Reading a file in a spaced repo.', { model: 'gpt-4.1', files: [file] }),
    ])
    const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'conv-space', content)
    const calls = await collectCalls(jbDbSource(dbPath, 'conv-space'))
    expect(calls).toHaveLength(1)
    expect(calls[0]!.project).toBe('My Project')
  })

  it('discovers JetBrains sessions across IDE dirs and session kinds', async () => {
    const content = jbDbContent([jbAssistantBlob('Hello from agent mode.', { model: 'claude-opus-4.5' })])
    await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'a1', content)
    await createJetBrainsDb(tmpDir, 'intellij', 'chat-agent-sessions', 'b1', content)

    const provider = createCopilotProvider('/nonexistent/legacy', '/nonexistent/ws', '/nonexistent/global', tmpDir)
    const sessions = await provider.discoverSessions()
    const jb = sessions.filter((s) => (s as { sourceType?: string }).sourceType === 'jetbrains')
    expect(jb.map((s) => (s as { sessionId?: string }).sessionId).sort()).toEqual(['a1', 'b1'])
  })

  it('does not crash on a corrupt/truncated .db', async () => {
    const dbPath = await createJetBrainsDb(
      tmpDir,
      'iu',
      'chat-agent-sessions',
      'conv-corrupt',
      'H:2,block:9\ncom.github.copilot.agent.session.persistence.nitrite.entity.NtAgentTurn\n{"__first__":{"type":"Subgraph"' // truncated, unbalanced
    )
    const calls = await collectCalls(jbDbSource(dbPath, 'conv-corrupt'))
    expect(Array.isArray(calls)).toBe(true) // no throw; may be empty
  })

  // ---- projectName field (JetBrains Copilot 1.12+) ----

  it('uses the plugin-recorded projectName over the file-path git-walk', async () => {
    // Same store carries both a projectName AND a file ref; projectName wins.
    const repoDir = join(tmpDir, 'container', 'walkable-repo')
    await mkdir(join(repoDir, '.git'), { recursive: true })
    const file = join(repoDir, 'Main.java')
    const content = jbDbContent([
      jbProjectNameField('shared-utils'),
      jbAssistantBlob('An answer referencing a file in a real git repo.', {
        model: 'claude-opus-4.5',
        files: [file],
      }),
    ])
    const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'conv-pn', content)
    // discoverSessions populates source.projectName; feed the resolved source.
    const provider = createCopilotProvider('/nonexistent/legacy', '/nonexistent/ws', '/nonexistent/global', tmpDir)
    const sessions = await provider.discoverSessions()
    const src = sessions.find((s) => (s as { storeId?: string }).storeId === 'conv-pn')!
    expect((src as { projectName?: string }).projectName).toBe('shared-utils')
    const calls = await collectCalls(src as never)
    expect(calls.length).toBeGreaterThan(0)
    // projectName beats the git-walk result (`walkable-repo`).
    expect(calls.every((c) => c.project === 'shared-utils')).toBe(true)
  })

  it('joins projectName across kind dirs by store id (turns in agent, name in edit)', async () => {
    // The billable turns live in chat-agent-sessions but carry NO projectName;
    // the sibling chat-edit-sessions store (same id) records it. Discovery must
    // join them so the agent session is labelled with the real repo.
    const storeId = 'store-xyz-123'
    const agentContent = jbDbContent([
      jbAssistantBlob('Architecture overview of the repo, no file refs at all.', { model: 'claude-opus-4.5' }),
    ])
    await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', storeId, agentContent)
    // Edit-kind store: has the projectName, but no billable turns.
    const editContent = jbDbContent([], []) + jbProjectNameField('web-api')
    await createJetBrainsDb(tmpDir, 'iu', 'chat-edit-sessions', storeId, editContent)

    const provider = createCopilotProvider('/nonexistent/legacy', '/nonexistent/ws', '/nonexistent/global', tmpDir)
    const sessions = await provider.discoverSessions()
    const jb = sessions.filter((s) => (s as { sourceType?: string }).sourceType === 'jetbrains')
    // Every source for this store id inherits the sibling-recorded name.
    for (const s of jb) {
      expect((s as { projectName?: string }).projectName).toBe('web-api')
    }
    const agentSrc = jb.find((s) => ((s as { dbPath?: string }).dbPath ?? '').includes('chat-agent-sessions'))!
    const calls = await collectCalls(agentSrc as never)
    expect(calls.length).toBeGreaterThan(0)
    expect(calls.every((c) => c.project === 'web-api')).toBe(true)
  })

  it('falls back to git-walk then bucket when no projectName is recorded', async () => {
    // No projectName, no file refs → the honest generic bucket (older plugins).
    const content = jbDbContent([jbAssistantBlob('A reply with no project signal at all.')])
    const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'conv-nopn', content)
    const provider = createCopilotProvider('/nonexistent/legacy', '/nonexistent/ws', '/nonexistent/global', tmpDir)
    const sessions = await provider.discoverSessions()
    const src = sessions.find((s) => (s as { storeId?: string }).storeId === 'conv-nopn')!
    expect((src as { projectName?: string }).projectName).toBeUndefined()
    const calls = await collectCalls(src as never)
    expect(calls.every((c) => c.project === 'copilot-jetbrains')).toBe(true)
  })

  it('extractJetBrainsProjectName reads the length-prefixed value, immune to embedded quotes', async () => {
    // A value containing a quote/newline must not truncate: length-prefixed read.
    const tricky = 'weird"name'
    const raw = jbDbContent([jbAssistantBlob('x')]) + jbProjectNameField(tricky)
    const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-sessions', 'conv-tricky', raw)
    const provider = createCopilotProvider('/nonexistent/legacy', '/nonexistent/ws', '/nonexistent/global', tmpDir)
    const sessions = await provider.discoverSessions()
    const src = sessions.find((s) => (s as { storeId?: string }).storeId === 'conv-tricky')!
    expect((src as { projectName?: string }).projectName).toBe(tricky)
  })

  it('reads a non-ASCII (multibyte UTF-8) projectName', async () => {
    // The value is length-delimited in UTF-8 bytes and re-decoded latin1→utf8,
    // so a repo name with multibyte characters must round-trip intact.
    const name = 'проект-café'
    const raw = jbDbContent([jbAssistantBlob('x')]) + jbProjectNameField(name)
    const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-sessions', 'conv-utf8name', raw)
    const provider = createCopilotProvider('/nonexistent/legacy', '/nonexistent/ws', '/nonexistent/global', tmpDir)
    const sessions = await provider.discoverSessions()
    const src = sessions.find((s) => (s as { storeId?: string }).storeId === 'conv-utf8name')!
    expect((src as { projectName?: string }).projectName).toBe(name)
  })

  // ---------------------------------------------------------------------------
  // Old plugin format (≤1.5.x, e.g. 1.5.59-243)
  // ---------------------------------------------------------------------------
  // In the old plugin all session turns live inside ONE large binary-framed
  // outer Nitrite document. Each turn's response is stored as a UUID-keyed
  // Value entry containing an AgentRound record (one escaping level deeper than
  // the __first__/Subgraph format used by plugins ≥1.12.x).

  /**
   * Build an outer Nitrite document in the old plugin format.
   * The document is preceded by a single binary byte (0x81) and starts with a
   * UUID-keyed Value entry. Each AgentRound is stored as a Value whose value
   * field is a JSON string containing {\"type\":\"AgentRound\",\"data\":\"...\"}
   * (one level of JSON-string escaping from the document root).
   */
  function jbOldFormatDoc(rounds: Array<{ reply: string; model?: string }>, opts: { upperUuid?: boolean } = {}) {
    const cased = (u: string) => (opts.upperUuid ? u.toUpperCase() : u)
    const entries: Record<string, unknown> = {}
    // Lead entry (mimics the References record always present in real DBs)
    entries[cased('0f383f5c-f169-4fee-9115-c06d4dd8985f')] = {
      type: 'Value',
      value: JSON.stringify({ type: 'References', data: '[]' }),
    }
    rounds.forEach((r, i) => {
      const uuid = cased(`ccadf30b-fa34-4387-9f14-0a5f63457d${String(i).padStart(2, '0')}`)
      const agentRoundData = JSON.stringify({ roundId: i + 1, reply: r.reply, toolCalls: [] })
      const agentRoundValue = JSON.stringify({ type: 'AgentRound', data: agentRoundData })
      entries[uuid] = { type: 'Value', value: agentRoundValue }
      if (r.model) {
        const modelUuid = cased(`bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbb${String(i).padStart(4, '0')}`)
        entries[modelUuid] = { type: 'Value', value: `{"model":"${r.model}"}` }
      }
    })
    // Binary framing byte (0x81) followed by the JSON document
    return '\x81' + JSON.stringify(entries)
  }

  it('parses agent turns from old plugin format (≤1.5.x, no __first__ blobs)', async () => {
    // The old plugin stores all turns in one big outer Nitrite document with a
    // binary framing byte. The fallback path must find and parse it.
    const convGuid = '17a5d71b-27f7-4937-8803-7fc2cbb705cb'
    const convRecord = jbConversationRecord(convGuid, 'Understanding HBase Architecture')
    const oldFormatContent =
      'H:2,block:8,blockSize:1000,format:3\n' +
      'com.github.copilot.agent.session.persistence.nitrite.entity.NtAgentTurn\n' +
      convRecord + '\n' +
      jbOldFormatDoc([
        { reply: "I'll scan the repository to find the top-level project structure.", model: 'gpt-4.1' },
        { reply: "Now I'll open the README to explain architecture." },
        { reply: '' }, // empty reply (pure tool-call round) — must not produce a call
      ])

    const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'old-fmt-1', oldFormatContent)
    const calls = await collectCalls(jbDbSource(dbPath, 'old-fmt-1'))

    // The fallback emits one call per outer document (all replies joined).
    expect(calls).toHaveLength(1)
    expect(calls[0]!.costIsEstimated).toBe(true)
    // The two NON-EMPTY rounds are captured and joined; the empty (tool-call)
    // round contributes nothing. Assert the exact combined token count so the
    // test fails if either reply is dropped or the empty round leaks in.
    const joined =
      "I'll scan the repository to find the top-level project structure.\n" +
      "Now I'll open the README to explain architecture."
    expect(calls[0]!.outputTokens).toBe(Math.ceil(joined.length / 4))
    // The session label is the conversation TITLE, not the reply text.
    expect(calls[0]!.userMessage).toBe('Understanding HBase Architecture')
  })

  it('parses old plugin format when the outer-doc UUIDs are uppercase hex', async () => {
    // The outer-doc detection must be case-insensitive: an uppercase UUID must
    // not make the whole session fall through to $0.
    const convRecord = jbConversationRecord('27b6e82c-38f8-4048-9914-8fd3dcc816dc', 'Conv Upper')
    const content =
      'H:2,block:8,blockSize:1000,format:3\n' +
      'com.github.copilot.agent.session.persistence.nitrite.entity.NtAgentTurn\n' +
      convRecord + '\n' +
      jbOldFormatDoc([{ reply: 'An uppercase-UUID reply with enough words to score.' }], { upperUuid: true })
    const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'old-fmt-upper', content)
    const calls = await collectCalls(jbDbSource(dbPath, 'old-fmt-upper'))
    expect(calls).toHaveLength(1)
    expect(calls[0]!.outputTokens).toBeGreaterThan(0)
  })

  it('old plugin format: does not parse when __first__ blobs already yield turns (no double-count)', async () => {
    // When the newer __first__/Subgraph path finds turns, the old-format fallback
    // must not run (turns.length > 0 prevents it).
    const content = jbDbContent([
      jbAgentBlob(['A reply from the new format.']),
    ])
    const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'new-fmt-guard', content)
    const calls = await collectCalls(jbDbSource(dbPath, 'new-fmt-guard'))
    // Only the one Subgraph-format turn — no old-format duplicates
    expect(calls).toHaveLength(1)
    expect(calls[0]!.outputTokens).toBeGreaterThan(0)
  })
})

describe('copilot provider - JetBrains dedup key stability across store rewrites', () => {
  beforeEach(async () => {
    tmpDir = await mkdtemp(join(tmpdir(), 'copilot-jetbrains-dedup-'))
    vi.stubEnv('CODEBURN_COPILOT_DISABLE_OTEL', '1')
  })

  afterEach(async () => {
    await rm(tmpDir, { recursive: true, force: true })
    vi.unstubAllEnvs()
  })

  function jbDedupSource(path: string, sessionId: string) {
    return {
      path, project: 'copilot-jetbrains', provider: 'copilot', sourceType: 'jetbrains',
      sessionId, storeId: sessionId, dbPath: path, mtime: '2026-07-03T12:00:00.000Z',
    } as unknown as { path: string; project: string; provider: string; sourceType?: string }
  }

  function blobFor(text: string) {
    const innerMd = { type: 'Markdown', data: JSON.stringify({ text, annotations: [] }) }
    const valueMap = { 'a1b2c3d4-0000-0000-0000-000000000001': { type: 'Value', value: JSON.stringify(innerMd) } }
    return JSON.stringify({ __first__: { type: 'Subgraph', value: JSON.stringify(valueMap) } })
  }

  function dbContent(blobs: string[]) {
    return (
      'H:2,block:9,blockSize:1000,format:3\n' +
      'com.github.copilot.agent.session.persistence.nitrite.entity.NtAgentTurn\n' +
      '\n' + blobs.join('\nt\x00\x00model\n') + '\n'
    )
  }

  it('a compaction that moves a new blob ahead of an old one must not re-bill the old turn', async () => {
    // copilot is a durable provider: cached turns are never deleted, and a
    // re-parse appends any dedup key it has not seen. MVStore compaction can
    // rewrite the file with blobs in a different byte order. If dedup keys were
    // positional (conversation + scan index), a rewrite that puts a NEW turn
    // before an OLD one would hand the new turn the old turn's key (skipped as
    // already-seen) and re-emit the old turn under a fresh index — billing it
    // twice and never billing the new turn. Content-derived keys are immune.
    const oldReply = 'The original answer, long enough to carry a token estimate.'
    const newReply = 'A fresh answer written after the compaction happened.'

    const dir = join(tmpDir, 'iu', 'chat-agent-sessions', 'conv-rewrite')
    await mkdir(dir, { recursive: true })
    const dbPath = join(dir, 'copilot-agent-sessions-nitrite.db')

    const seen = new Set<string>()

    // Scan 1: the store holds only the old turn.
    await writeFile(dbPath, dbContent([blobFor(oldReply)]))
    const first = await collectCalls(jbDedupSource(dbPath, 'conv-rewrite'), seen)
    expect(first).toHaveLength(1)
    expect(first[0]!.outputTokens).toBe(Math.ceil(oldReply.length / 4))

    // Scan 2: compaction rewrote the file — the new turn now sits BEFORE the
    // old one in byte order.
    await writeFile(dbPath, dbContent([blobFor(newReply), blobFor(oldReply)]))
    const second = await collectCalls(jbDedupSource(dbPath, 'conv-rewrite'), seen)

    // Exactly the new turn must be billed — once, at its own length. The old
    // turn is already cached and must not re-enter under a different key.
    expect(second).toHaveLength(1)
    expect(second[0]!.outputTokens).toBe(Math.ceil(newReply.length / 4))
  })
})