chore: import upstream snapshot with attribution

tests/classifier.test.ts

@@ -0,0 +1,196 @@
+import { describe, it, expect } from 'vitest'
+
+import { classifyTurn } from '../src/classifier.js'
+import type { ParsedApiCall, ParsedTurn } from '../src/types.js'
+
+function makeCall(opts: Partial<ParsedApiCall> & { tools?: string[]; skills?: string[] }): ParsedApiCall {
+  const tools = opts.tools ?? []
+  return {
+    provider: 'claude',
+    model: 'Opus 4.7',
+    usage: {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheCreationInputTokens: 0,
+      cacheReadInputTokens: 0,
+      cachedInputTokens: 0,
+      reasoningTokens: 0,
+      webSearchRequests: 0,
+    },
+    costUSD: 0,
+    tools,
+    mcpTools: tools.filter(t => t.startsWith('mcp__')),
+    skills: opts.skills ?? [],
+    hasAgentSpawn: tools.includes('Agent'),
+    hasPlanMode: tools.includes('EnterPlanMode'),
+    speed: 'standard',
+    timestamp: '2026-05-04T00:00:00Z',
+    bashCommands: [],
+    deduplicationKey: 'k',
+    ...opts,
+  }
+}
+
+function makeTurn(calls: ParsedApiCall[], userMessage = ''): ParsedTurn {
+  return {
+    userMessage,
+    assistantCalls: calls,
+    timestamp: '2026-05-04T00:00:00Z',
+    sessionId: 's1',
+  }
+}
+
+describe('classifyTurn — Skill subCategory', () => {
+  it('attaches subCategory when a Skill tool fires alone (input.skill)', () => {
+    const turn = makeTurn([makeCall({ tools: ['Skill'], skills: ['init'] })])
+    const c = classifyTurn(turn)
+    expect(c.category).toBe('general')
+    expect(c.subCategory).toBe('init')
+  })
+
+  it('attaches subCategory when skill identifier comes via input.name (extracted upstream)', () => {
+    const turn = makeTurn([makeCall({ tools: ['Skill'], skills: ['atelier'] })])
+    const c = classifyTurn(turn)
+    expect(c.category).toBe('general')
+    expect(c.subCategory).toBe('atelier')
+  })
+
+  it('uses the first skill identifier when a single turn invokes multiple skills', () => {
+    const turn = makeTurn([makeCall({ tools: ['Skill', 'Skill'], skills: ['review', 'security-review'] })])
+    const c = classifyTurn(turn)
+    expect(c.category).toBe('general')
+    expect(c.subCategory).toBe('review')
+  })
+
+  it('aggregates skills across multiple assistant calls in the same turn', () => {
+    const turn = makeTurn([
+      makeCall({ tools: ['Skill'], skills: ['claude-api'] }),
+      makeCall({ tools: ['Skill'], skills: ['init'] }),
+    ])
+    const c = classifyTurn(turn)
+    expect(c.category).toBe('general')
+    expect(c.subCategory).toBe('claude-api')
+  })
+
+  it('does not attach subCategory when the Skill tool fires but no skill name was extracted', () => {
+    const turn = makeTurn([makeCall({ tools: ['Skill'], skills: [] })])
+    const c = classifyTurn(turn)
+    expect(c.category).toBe('general')
+    expect(c.subCategory).toBeUndefined()
+  })
+
+  it('does not attach subCategory when category is not general (e.g. Skill alongside Edit promotes to coding)', () => {
+    const turn = makeTurn([makeCall({ tools: ['Skill', 'Edit'], skills: ['init'] })])
+    const c = classifyTurn(turn)
+    expect(c.category).toBe('coding')
+    expect(c.subCategory).toBeUndefined()
+  })
+
+  it('does not attach subCategory for non-Skill general turns', () => {
+    const turn = makeTurn([makeCall({ tools: [] })], 'just chatting')
+    const c = classifyTurn(turn)
+    expect(c.subCategory).toBeUndefined()
+  })
+
+  it('tolerates missing skills field on legacy ParsedApiCall shape', () => {
+    const baseCall = makeCall({ tools: ['Skill'], skills: ['init'] })
+    const legacyCall = { ...baseCall } as unknown as ParsedApiCall & { skills?: string[] }
+    delete (legacyCall as { skills?: string[] }).skills
+    const c = classifyTurn(makeTurn([legacyCall]))
+    expect(c.category).toBe('general')
+    expect(c.subCategory).toBeUndefined()
+  })
+})
+
+// Regression coverage for issue #196: feature verbs that lead a message
+// were previously hijacked into 'debugging' just because the message contained
+// an incidental "error" / "fix" / "issue" word later in the same sentence.
+// Now whichever keyword pattern matches earliest wins.
+describe('classifyTurn — feature vs debugging precedence (#196)', () => {
+  function codingTurn(userMessage: string): ParsedTurn {
+    return makeTurn([makeCall({ tools: ['Edit'] })], userMessage)
+  }
+
+  it('classifies "add error handling" as feature, not debugging', () => {
+    const c = classifyTurn(codingTurn('add error handling to the auth module'))
+    expect(c.category).toBe('feature')
+  })
+
+  it('classifies "create an issue tracker" as feature, not debugging', () => {
+    const c = classifyTurn(codingTurn('create an issue tracker page in the dashboard'))
+    expect(c.category).toBe('feature')
+  })
+
+  it('classifies "implement the 404 page" as feature, not debugging', () => {
+    const c = classifyTurn(codingTurn('implement the 404 page with a friendly redirect'))
+    expect(c.category).toBe('feature')
+  })
+
+  it('still classifies "fix the layout for the new feature" as debugging', () => {
+    const c = classifyTurn(codingTurn('fix the layout for the new feature'))
+    expect(c.category).toBe('debugging')
+  })
+
+  it('still classifies a plain bug report as debugging', () => {
+    const c = classifyTurn(codingTurn('login is broken, traceback below'))
+    expect(c.category).toBe('debugging')
+  })
+
+  it('classifies "refactor the error handling" as refactoring', () => {
+    const c = classifyTurn(codingTurn('refactor the error handling so it is cleaner'))
+    expect(c.category).toBe('refactoring')
+  })
+
+  it('chat-only message starting with "add" stays feature even with "fix" later', () => {
+    const c = classifyTurn(makeTurn([], 'add a setting page; we will fix the styles after'))
+    expect(c.category).toBe('feature')
+  })
+
+  it('chat-only message starting with "fix" stays debugging even with "add" later', () => {
+    const c = classifyTurn(makeTurn([], 'fix the bug introduced when we added the new flag'))
+    expect(c.category).toBe('debugging')
+  })
+})
+
+describe('classifyTurn — retry detection via toolSequence', () => {
+  it('detects retries from multi-call turns (Claude-style)', () => {
+    const turn = makeTurn([
+      makeCall({ tools: ['Edit'] }),
+      makeCall({ tools: ['Bash'] }),
+      makeCall({ tools: ['Edit'] }),
+    ], 'fix the build')
+    const c = classifyTurn(turn)
+    expect(c.retries).toBe(1)
+  })
+
+  it('detects retries from toolSequence on a single call (Kiro/Goose-style)', () => {
+    const call = makeCall({ tools: ['Edit', 'Bash'] })
+    call.toolSequence = [[{ tool: 'Edit' }], [{ tool: 'Bash' }], [{ tool: 'Edit' }]]
+    const turn = makeTurn([call], 'fix the build')
+    const c = classifyTurn(turn)
+    expect(c.retries).toBe(1)
+  })
+
+  it('returns 0 retries for single call without toolSequence', () => {
+    const call = makeCall({ tools: ['Edit', 'Bash'] })
+    const turn = makeTurn([call], 'fix the build')
+    const c = classifyTurn(turn)
+    expect(c.retries).toBe(0)
+  })
+
+  it('counts multiple retries from toolSequence', () => {
+    const call = makeCall({ tools: ['Edit', 'Bash'] })
+    call.toolSequence = [[{ tool: 'Edit' }], [{ tool: 'Bash' }], [{ tool: 'Edit' }], [{ tool: 'Bash' }], [{ tool: 'Edit' }]]
+    const turn = makeTurn([call], 'fix the build')
+    const c = classifyTurn(turn)
+    expect(c.retries).toBe(2)
+  })
+
+  it('ignores toolSequence with only one step', () => {
+    const call = makeCall({ tools: ['Edit', 'Bash'] })
+    call.toolSequence = [[{ tool: 'Edit' }, { tool: 'Bash' }]]
+    const turn = makeTurn([call], 'fix the build')
+    const c = classifyTurn(turn)
+    expect(c.retries).toBe(0)
+  })
+})