smolerclaw 0.1.0

package/tests/approval.test.ts

@@ -0,0 +1,43 @@
+import { describe, test, expect } from 'bun:test'
+import { needsApproval, formatApprovalPrompt } from '../src/approval'
+
+describe('needsApproval', () => {
+  test('auto mode never needs approval', () => {
+    expect(needsApproval('auto', 'write_file', 'moderate')).toBe(false)
+    expect(needsApproval('auto', 'run_command', 'moderate')).toBe(false)
+  })
+
+  test('confirm-writes approves read tools', () => {
+    expect(needsApproval('confirm-writes', 'read_file', 'safe')).toBe(false)
+    expect(needsApproval('confirm-writes', 'search_files', 'safe')).toBe(false)
+    expect(needsApproval('confirm-writes', 'list_directory', 'safe')).toBe(false)
+  })
+
+  test('confirm-writes requires approval for writes', () => {
+    expect(needsApproval('confirm-writes', 'write_file', 'moderate')).toBe(true)
+    expect(needsApproval('confirm-writes', 'edit_file', 'moderate')).toBe(true)
+    expect(needsApproval('confirm-writes', 'run_command', 'moderate')).toBe(true)
+  })
+
+  test('confirm-all requires approval for all non-safe', () => {
+    expect(needsApproval('confirm-all', 'write_file', 'moderate')).toBe(true)
+    expect(needsApproval('confirm-all', 'fetch_url', 'safe')).toBe(false)
+  })
+})
+
+describe('formatApprovalPrompt', () => {
+  test('formats write_file', () => {
+    expect(formatApprovalPrompt('write_file', { path: 'src/foo.ts' })).toContain('src/foo.ts')
+  })
+
+  test('formats run_command', () => {
+    expect(formatApprovalPrompt('run_command', { command: 'npm test' })).toContain('npm test')
+  })
+
+  test('truncates long commands', () => {
+    const long = 'a'.repeat(100)
+    const result = formatApprovalPrompt('run_command', { command: long })
+    expect(result.length).toBeLessThan(80)
+    expect(result).toContain('...')
+  })
+})

package/tests/briefing.test.ts

@@ -0,0 +1,10 @@
+import { describe, test, expect } from 'bun:test'
+import { generateBriefing } from '../src/briefing'
+
+describe('briefing', () => {
+  test('generateBriefing returns structured output', async () => {
+    const result = await generateBriefing()
+    expect(result).toContain('BRIEFING DIARIO')
+    expect(result).toContain('Semana')
+  }, 30_000) // network timeout for news
+})

package/tests/cli.test.ts

@@ -0,0 +1,53 @@
+import { describe, test, expect } from 'bun:test'
+import { parseArgs } from '../src/cli'
+
+describe('parseArgs', () => {
+  test('defaults', () => {
+    const args = parseArgs([])
+    expect(args.help).toBe(false)
+    expect(args.version).toBe(false)
+    expect(args.print).toBe(false)
+    expect(args.noTools).toBe(false)
+    expect(args.model).toBeUndefined()
+    expect(args.prompt).toBeUndefined()
+  })
+
+  test('--help', () => {
+    expect(parseArgs(['-h']).help).toBe(true)
+    expect(parseArgs(['--help']).help).toBe(true)
+  })
+
+  test('--version', () => {
+    expect(parseArgs(['-v']).version).toBe(true)
+    expect(parseArgs(['--version']).version).toBe(true)
+  })
+
+  test('--model', () => {
+    expect(parseArgs(['-m', 'sonnet']).model).toBe('sonnet')
+    expect(parseArgs(['--model', 'haiku']).model).toBe('haiku')
+  })
+
+  test('--session', () => {
+    expect(parseArgs(['-s', 'work']).session).toBe('work')
+  })
+
+  test('--print', () => {
+    expect(parseArgs(['-p']).print).toBe(true)
+    expect(parseArgs(['--print']).print).toBe(true)
+  })
+
+  test('--no-tools', () => {
+    expect(parseArgs(['--no-tools']).noTools).toBe(true)
+  })
+
+  test('positional args become prompt', () => {
+    expect(parseArgs(['hello', 'world']).prompt).toBe('hello world')
+  })
+
+  test('mixed flags and positional', () => {
+    const args = parseArgs(['-m', 'opus', '-p', 'explain', 'this'])
+    expect(args.model).toBe('opus')
+    expect(args.print).toBe(true)
+    expect(args.prompt).toBe('explain this')
+  })
+})

package/tests/context-window.test.ts

@@ -0,0 +1,83 @@
+import { describe, test, expect } from 'bun:test'
+import { estimateTokens, estimateMessageTokens, compressToolResults } from '../src/context-window'
+import type { Message } from '../src/types'
+
+describe('estimateTokens', () => {
+  test('estimates roughly 1 token per 3.5 chars', () => {
+    const tokens = estimateTokens('Hello, world!')
+    expect(tokens).toBeGreaterThan(2)
+    expect(tokens).toBeLessThan(10)
+  })
+
+  test('empty string is 0 tokens', () => {
+    expect(estimateTokens('')).toBe(0)
+  })
+})
+
+describe('estimateMessageTokens', () => {
+  test('counts tokens across messages', () => {
+    const msgs: Message[] = [
+      { role: 'user', content: 'Hello', timestamp: 0 },
+      { role: 'assistant', content: 'Hi there, how can I help?', timestamp: 0 },
+    ]
+    const tokens = estimateMessageTokens(msgs)
+    expect(tokens).toBeGreaterThan(10)
+  })
+
+  test('includes tool call tokens', () => {
+    const withTools: Message[] = [{
+      role: 'assistant',
+      content: 'Let me check.',
+      toolCalls: [{ id: '1', name: 'read_file', input: { path: 'foo.ts' }, result: 'file contents here' }],
+      timestamp: 0,
+    }]
+    const withoutTools: Message[] = [{
+      role: 'assistant',
+      content: 'Let me check.',
+      timestamp: 0,
+    }]
+    expect(estimateMessageTokens(withTools)).toBeGreaterThan(estimateMessageTokens(withoutTools))
+  })
+})
+
+describe('compressToolResults', () => {
+  test('short results pass through unchanged', () => {
+    const msgs: Message[] = [{
+      role: 'assistant',
+      content: 'done',
+      toolCalls: [{ id: '1', name: 'read_file', input: { path: 'x' }, result: 'short' }],
+      timestamp: 0,
+    }]
+    const compressed = compressToolResults(msgs)
+    expect(compressed[0].toolCalls![0].result).toBe('short')
+  })
+
+  test('long results are truncated without negative count', () => {
+    const longResult = Array.from({ length: 100 }, (_, i) => `line ${i}`).join('\n')
+    const msgs: Message[] = [{
+      role: 'assistant',
+      content: 'done',
+      toolCalls: [{ id: '1', name: 'read_file', input: { path: 'x' }, result: longResult }],
+      timestamp: 0,
+    }]
+    const compressed = compressToolResults(msgs, 50)
+    const result = compressed[0].toolCalls![0].result
+    expect(result).toContain('omitted')
+    // Should never contain negative count
+    expect(result).not.toMatch(/\(-\d+ lines omitted\)/)
+  })
+
+  test('results with few lines do not produce negative omitted count', () => {
+    const fiveLines = 'a\nb\nc\nd\ne'
+    const msgs: Message[] = [{
+      role: 'assistant',
+      content: 'done',
+      toolCalls: [{ id: '1', name: 'read_file', input: { path: 'x' }, result: fiveLines }],
+      timestamp: 0,
+    }]
+    // Force compression with very low maxResultLen
+    const compressed = compressToolResults(msgs, 2)
+    const result = compressed[0].toolCalls![0].result
+    expect(result).not.toMatch(/-\d+ lines/)
+  })
+})

package/tests/images.test.ts

@@ -0,0 +1,28 @@
+import { describe, test, expect } from 'bun:test'
+import { extractImages } from '../src/images'
+
+describe('extractImages', () => {
+  test('plain text with no images passes through', () => {
+    const { text, images } = extractImages('hello world')
+    expect(text).toBe('hello world')
+    expect(images).toHaveLength(0)
+  })
+
+  test('non-existent image path is kept as text', () => {
+    const { text, images } = extractImages('look at /nonexistent/image.png')
+    expect(text).toContain('/nonexistent/image.png')
+    expect(images).toHaveLength(0)
+  })
+
+  test('recognizes image extensions', () => {
+    // These paths don't exist, so they stay as text — but the logic is tested
+    const { text } = extractImages('file.txt file.png file.jpg')
+    expect(text).toContain('file.txt')
+  })
+
+  test('handles empty input', () => {
+    const { text, images } = extractImages('')
+    expect(text).toBe('')
+    expect(images).toHaveLength(0)
+  })
+})

package/tests/memos.test.ts

@@ -0,0 +1,116 @@
+import { describe, test, expect, beforeEach } from 'bun:test'
+import { initMemos, saveMemo, searchMemos, listMemos, updateMemo, deleteMemo, getMemoTags, formatMemoList, formatMemoTags } from '../src/memos'
+import { mkdtempSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+
+describe('memos', () => {
+  beforeEach(() => {
+    const tmpDir = mkdtempSync(join(tmpdir(), 'smolerclaw-memo-'))
+    initMemos(tmpDir)
+  })
+
+  test('saveMemo creates a memo', () => {
+    const memo = saveMemo('Remember to buy milk')
+    expect(memo.id).toBeTruthy()
+    expect(memo.content).toBe('Remember to buy milk')
+    expect(memo.tags).toEqual([])
+  })
+
+  test('saveMemo extracts hashtags', () => {
+    const memo = saveMemo('Deploy steps for #docker #production')
+    expect(memo.tags).toContain('docker')
+    expect(memo.tags).toContain('production')
+  })
+
+  test('saveMemo merges explicit tags with hashtags', () => {
+    const memo = saveMemo('Config for #nginx', ['server', 'infra'])
+    expect(memo.tags).toContain('nginx')
+    expect(memo.tags).toContain('server')
+    expect(memo.tags).toContain('infra')
+  })
+
+  test('saveMemo deduplicates tags', () => {
+    const memo = saveMemo('Test #work', ['work'])
+    const workCount = memo.tags.filter((t) => t === 'work').length
+    expect(workCount).toBe(1)
+  })
+
+  test('listMemos returns recent first', () => {
+    saveMemo('first')
+    saveMemo('second')
+    saveMemo('third')
+    const memos = listMemos()
+    expect(memos.length).toBe(3)
+    expect(memos[0].content).toBe('third')
+  })
+
+  test('listMemos respects limit', () => {
+    for (let i = 0; i < 5; i++) saveMemo(`memo ${i}`)
+    expect(listMemos(3).length).toBe(3)
+  })
+
+  test('searchMemos by content', () => {
+    saveMemo('docker compose setup')
+    saveMemo('kubernetes config')
+    saveMemo('docker swarm notes')
+    const results = searchMemos('docker')
+    expect(results.length).toBe(2)
+  })
+
+  test('searchMemos by tag', () => {
+    saveMemo('step 1 #deploy')
+    saveMemo('step 2 #deploy')
+    saveMemo('other #random')
+    const results = searchMemos('#deploy')
+    expect(results.length).toBe(2)
+  })
+
+  test('searchMemos empty query returns all', () => {
+    saveMemo('a')
+    saveMemo('b')
+    expect(searchMemos('').length).toBe(2)
+  })
+
+  test('updateMemo changes content', () => {
+    const memo = saveMemo('original')
+    const updated = updateMemo(memo.id, 'modified #new')
+    expect(updated?.content).toBe('modified #new')
+    expect(updated?.tags).toContain('new')
+  })
+
+  test('deleteMemo removes memo', () => {
+    const memo = saveMemo('temp')
+    expect(deleteMemo(memo.id)).toBe(true)
+    expect(listMemos().length).toBe(0)
+  })
+
+  test('deleteMemo returns false for unknown', () => {
+    expect(deleteMemo('nonexistent')).toBe(false)
+  })
+
+  test('getMemoTags returns sorted by count', () => {
+    saveMemo('#work task 1')
+    saveMemo('#work task 2')
+    saveMemo('#personal note')
+    const tags = getMemoTags()
+    expect(tags[0].tag).toBe('work')
+    expect(tags[0].count).toBe(2)
+    expect(tags[1].tag).toBe('personal')
+  })
+
+  test('formatMemoList shows memos', () => {
+    saveMemo('test memo #tag1')
+    const text = formatMemoList(listMemos())
+    expect(text).toContain('test memo')
+    expect(text).toContain('#tag1')
+  })
+
+  test('formatMemoList empty', () => {
+    expect(formatMemoList([])).toContain('Nenhum memo')
+  })
+
+  test('formatMemoTags empty', () => {
+    expect(formatMemoTags()).toContain('Nenhuma tag')
+  })
+})

package/tests/models.test.ts

@@ -0,0 +1,34 @@
+import { describe, test, expect } from 'bun:test'
+import { resolveModel, modelDisplayName } from '../src/models'
+
+describe('resolveModel', () => {
+  test('resolves aliases', () => {
+    expect(resolveModel('haiku')).toBe('claude-haiku-4-5-20251001')
+    expect(resolveModel('sonnet')).toBe('claude-sonnet-4-20250514')
+    expect(resolveModel('opus')).toBe('claude-opus-4-20250514')
+  })
+
+  test('passes through exact model IDs', () => {
+    expect(resolveModel('claude-haiku-4-5-20251001')).toBe('claude-haiku-4-5-20251001')
+  })
+
+  test('passes through unknown models', () => {
+    expect(resolveModel('gpt-4o')).toBe('gpt-4o')
+    expect(resolveModel('custom-fine-tuned-v1')).toBe('custom-fine-tuned-v1')
+  })
+
+  test('is case-insensitive for aliases', () => {
+    expect(resolveModel('Haiku')).toBe('claude-haiku-4-5-20251001')
+    expect(resolveModel('SONNET')).toBe('claude-sonnet-4-20250514')
+  })
+})
+
+describe('modelDisplayName', () => {
+  test('returns friendly name for known models', () => {
+    expect(modelDisplayName('claude-haiku-4-5-20251001')).toContain('Haiku')
+  })
+
+  test('returns ID for unknown models', () => {
+    expect(modelDisplayName('gpt-4o')).toBe('gpt-4o')
+  })
+})

package/tests/news.test.ts

@@ -0,0 +1,13 @@
+import { describe, test, expect } from 'bun:test'
+import { getNewsCategories } from '../src/news'
+
+describe('news', () => {
+  test('getNewsCategories returns category list', () => {
+    const result = getNewsCategories()
+    expect(result).toContain('business')
+    expect(result).toContain('tech')
+    expect(result).toContain('finance')
+    expect(result).toContain('brazil')
+    expect(result).toContain('world')
+  })
+})

package/tests/path-guard.test.ts

@@ -0,0 +1,37 @@
+import { describe, test, expect } from 'bun:test'
+import { resolve, sep } from 'node:path'
+
+// Inline the guardPath logic for testing (can't import private function)
+function guardPath(filePath: string): string | null {
+  const resolved = resolve(filePath)
+  const cwd = process.cwd()
+  if (resolved !== cwd && !resolved.startsWith(cwd + sep)) {
+    return `Error: path outside working directory is not permitted: ${resolved}`
+  }
+  return null
+}
+
+describe('guardPath', () => {
+  test('allows paths within cwd', () => {
+    expect(guardPath('src/index.ts')).toBeNull()
+    expect(guardPath('./package.json')).toBeNull()
+    expect(guardPath('tests/foo.test.ts')).toBeNull()
+  })
+
+  test('allows cwd itself', () => {
+    expect(guardPath('.')).toBeNull()
+  })
+
+  test('blocks paths outside cwd', () => {
+    expect(guardPath('/etc/passwd')).not.toBeNull()
+    expect(guardPath('../../.ssh/id_rsa')).not.toBeNull()
+    expect(guardPath('../../../etc/shadow')).not.toBeNull()
+  })
+
+  test('blocks home directory paths', () => {
+    const home = process.env.HOME || process.env.USERPROFILE || ''
+    if (home) {
+      expect(guardPath(home + '/.ssh/id_rsa')).not.toBeNull()
+    }
+  })
+})

package/tests/people.test.ts

@@ -0,0 +1,204 @@
+import { describe, test, expect, beforeEach } from 'bun:test'
+import {
+  initPeople, addPerson, findPerson, listPeople, updatePerson, removePerson,
+  logInteraction, getInteractions, getPendingFollowUps, markFollowUpDone,
+  delegateTask, updateDelegation, getDelegations,
+  formatPeopleList, formatPersonDetail, formatDelegationList, formatFollowUps,
+  generatePeopleDashboard,
+} from '../src/people'
+import { mkdtempSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+
+describe('people', () => {
+  beforeEach(() => {
+    const tmpDir = mkdtempSync(join(tmpdir(), 'smolerclaw-people-'))
+    initPeople(tmpDir)
+  })
+
+  // ── CRUD ──
+
+  test('addPerson creates a person', () => {
+    const p = addPerson('Joao', 'equipe', 'dev frontend')
+    expect(p.id).toBeTruthy()
+    expect(p.name).toBe('Joao')
+    expect(p.group).toBe('equipe')
+    expect(p.role).toBe('dev frontend')
+  })
+
+  test('findPerson by name (partial match)', () => {
+    addPerson('Maria Silva', 'equipe')
+    const found = findPerson('maria')
+    expect(found?.name).toBe('Maria Silva')
+  })
+
+  test('findPerson by id', () => {
+    const p = addPerson('Carlos', 'familia')
+    const found = findPerson(p.id)
+    expect(found?.name).toBe('Carlos')
+  })
+
+  test('findPerson returns null for unknown', () => {
+    expect(findPerson('nobody')).toBeNull()
+  })
+
+  test('listPeople returns all', () => {
+    addPerson('A', 'equipe')
+    addPerson('B', 'familia')
+    addPerson('C', 'contato')
+    expect(listPeople().length).toBe(3)
+  })
+
+  test('listPeople filters by group', () => {
+    addPerson('A', 'equipe')
+    addPerson('B', 'familia')
+    addPerson('C', 'equipe')
+    expect(listPeople('equipe').length).toBe(2)
+    expect(listPeople('familia').length).toBe(1)
+  })
+
+  test('updatePerson changes fields', () => {
+    const p = addPerson('Ana', 'equipe')
+    const updated = updatePerson(p.id, { role: 'tech lead' })
+    expect(updated?.role).toBe('tech lead')
+    expect(updated?.name).toBe('Ana')
+  })
+
+  test('removePerson deletes person and related data', () => {
+    const p = addPerson('Temp', 'contato')
+    logInteraction(p.id, 'conversa', 'test')
+    delegateTask(p.id, 'test task')
+    expect(removePerson(p.id)).toBe(true)
+    expect(findPerson(p.id)).toBeNull()
+    expect(getInteractions(p.id).length).toBe(0)
+    expect(getDelegations(p.id).length).toBe(0)
+  })
+
+  // ── Interactions ──
+
+  test('logInteraction creates an interaction', () => {
+    const p = addPerson('Bob', 'equipe')
+    const i = logInteraction(p.id, 'reuniao', 'Sprint planning')
+    expect(i?.type).toBe('reuniao')
+    expect(i?.summary).toBe('Sprint planning')
+  })
+
+  test('logInteraction returns null for unknown person', () => {
+    expect(logInteraction('nobody', 'conversa', 'hi')).toBeNull()
+  })
+
+  test('getInteractions returns recent first', () => {
+    const p = addPerson('Ana', 'equipe')
+    logInteraction(p.id, 'email', 'first')
+    logInteraction(p.id, 'email', 'second')
+    logInteraction(p.id, 'email', 'third')
+    const list = getInteractions(p.id)
+    expect(list.length).toBe(3)
+    expect(list[0].summary).toBe('third')
+  })
+
+  test('logInteraction with follow-up', () => {
+    const p = addPerson('Joao', 'equipe')
+    const future = new Date(Date.now() - 60_000) // 1 min ago = due
+    logInteraction(p.id, 'conversa', 'cobrar relatorio', future)
+    const followUps = getPendingFollowUps()
+    expect(followUps.length).toBe(1)
+    expect(followUps[0].person.name).toBe('Joao')
+  })
+
+  test('markFollowUpDone clears follow-up', () => {
+    const p = addPerson('Joao', 'equipe')
+    const past = new Date(Date.now() - 60_000)
+    const i = logInteraction(p.id, 'conversa', 'test', past)
+    expect(getPendingFollowUps().length).toBe(1)
+    markFollowUpDone(i!.id)
+    expect(getPendingFollowUps().length).toBe(0)
+  })
+
+  // ── Delegations ──
+
+  test('delegateTask creates delegation', () => {
+    const p = addPerson('Maria', 'equipe')
+    const d = delegateTask(p.id, 'Revisar documento')
+    expect(d?.task).toBe('Revisar documento')
+    expect(d?.status).toBe('pendente')
+  })
+
+  test('delegateTask returns null for unknown person', () => {
+    expect(delegateTask('nobody', 'task')).toBeNull()
+  })
+
+  test('updateDelegation changes status', () => {
+    const p = addPerson('Carlos', 'equipe')
+    const d = delegateTask(p.id, 'Fazer deploy')!
+    const updated = updateDelegation(d.id, 'concluido', 'deploy feito')
+    expect(updated?.status).toBe('concluido')
+    expect(updated?.notes).toBe('deploy feito')
+  })
+
+  test('getDelegations shows overdue tasks', () => {
+    const p = addPerson('Ana', 'equipe')
+    const past = new Date(Date.now() - 86_400_000) // yesterday
+    delegateTask(p.id, 'task atrasada', past)
+    const list = getDelegations(p.id)
+    expect(list.length).toBe(1)
+    expect(list[0].status).toBe('atrasado')
+  })
+
+  test('getDelegations filters completed by default', () => {
+    const p = addPerson('Bob', 'equipe')
+    const d = delegateTask(p.id, 'done task')!
+    updateDelegation(d.id, 'concluido')
+    expect(getDelegations(p.id, true).length).toBe(0)
+    expect(getDelegations(p.id, false).length).toBe(1)
+  })
+
+  // ── Formatting ──
+
+  test('formatPeopleList groups by type', () => {
+    addPerson('Alice', 'equipe')
+    addPerson('Bob', 'familia')
+    const text = formatPeopleList(listPeople())
+    expect(text).toContain('Equipe')
+    expect(text).toContain('Familia')
+    expect(text).toContain('Alice')
+    expect(text).toContain('Bob')
+  })
+
+  test('formatPeopleList empty', () => {
+    expect(formatPeopleList([])).toContain('Nenhuma pessoa')
+  })
+
+  test('formatPersonDetail includes interactions and delegations', () => {
+    const p = addPerson('Ana', 'equipe', 'tech lead')
+    logInteraction(p.id, 'reuniao', 'daily standup')
+    delegateTask(p.id, 'code review')
+    const text = formatPersonDetail(p)
+    expect(text).toContain('Ana')
+    expect(text).toContain('tech lead')
+    expect(text).toContain('daily standup')
+    expect(text).toContain('code review')
+  })
+
+  test('formatDelegationList shows items', () => {
+    const p = addPerson('X', 'equipe')
+    delegateTask(p.id, 'task A')
+    const text = formatDelegationList(getDelegations())
+    expect(text).toContain('task A')
+  })
+
+  test('formatFollowUps empty', () => {
+    expect(formatFollowUps([])).toContain('Nenhum follow-up')
+  })
+
+  // ── Dashboard ──
+
+  test('generatePeopleDashboard returns structured output', () => {
+    addPerson('Team1', 'equipe')
+    addPerson('Family1', 'familia')
+    const text = generatePeopleDashboard()
+    expect(text).toContain('PAINEL DE PESSOAS')
+    expect(text).toContain('Equipe: 1')
+    expect(text).toContain('Familia: 1')
+  })
+})

package/tests/skills.test.ts

@@ -0,0 +1,35 @@
+import { describe, test, expect } from 'bun:test'
+import { loadSkills, formatSkillList } from '../src/skills'
+
+describe('loadSkills', () => {
+  test('returns empty array for non-existent dir', () => {
+    const skills = loadSkills('/nonexistent/dir')
+    // May return local skills from CWD if .smolerclaw/skills exists
+    // But won't crash
+    expect(Array.isArray(skills)).toBe(true)
+  })
+
+  test('loads from existing skills dir', () => {
+    const skills = loadSkills('./skills')
+    expect(skills.length).toBeGreaterThan(0)
+    const names = skills.map((s) => s.name)
+    expect(names).toContain('default')
+    expect(names).toContain('business')
+    expect(skills.every((s) => s.source === 'global')).toBe(true)
+  })
+})
+
+describe('formatSkillList', () => {
+  test('shows no skills message when empty', () => {
+    expect(formatSkillList([])).toContain('No skills')
+  })
+
+  test('shows source labels', () => {
+    const result = formatSkillList([
+      { name: 'test', content: 'x', source: 'global' },
+      { name: 'local-test', content: 'y', source: 'local' },
+    ])
+    expect(result).toContain('[global]')
+    expect(result).toContain('[local]')
+  })
+})