switchroom 0.5.0

package/telegram-plugin/tests/telegraph.test.ts

@@ -0,0 +1,246 @@
+/**
+ * Unit tests for the Telegraph publisher (#579).
+ *
+ * Three target areas:
+ *   - createTelegraphAccount + createTelegraphPage: API client
+ *     argument validation and success/error response handling.
+ *   - markdownToTelegraphNodes: every block + inline branch in the
+ *     converter.
+ *   - deriveTelegraphTitle: heuristic title extraction.
+ */
+
+import { describe, it, expect } from 'bun:test'
+import {
+  createTelegraphAccount,
+  createTelegraphPage,
+  markdownToTelegraphNodes,
+  parseInline,
+  deriveTelegraphTitle,
+} from '../telegraph.js'
+
+function makeFetch(status: number, body: unknown): typeof fetch {
+  return (async () => ({
+    ok: status >= 200 && status < 300,
+    status,
+    json: async () => body,
+    text: async () => JSON.stringify(body),
+    headers: new Headers(),
+  })) as unknown as typeof fetch
+}
+
+describe('createTelegraphAccount — validation', () => {
+  it('rejects empty short_name', async () => {
+    const r = await createTelegraphAccount({ shortName: '' })
+    expect(r).toMatchObject({ ok: false })
+  })
+
+  it('rejects short_name over 32 chars', async () => {
+    const r = await createTelegraphAccount({ shortName: 'a'.repeat(33) })
+    expect(r).toMatchObject({ ok: false, reason: expect.stringContaining('too long') })
+  })
+})
+
+describe('createTelegraphAccount — happy path', () => {
+  it('returns the access_token from a successful response', async () => {
+    const r = await createTelegraphAccount({
+      shortName: 'klanker',
+      authorName: 'Klanker',
+      fetchImpl: makeFetch(200, {
+        ok: true,
+        result: { short_name: 'klanker', access_token: 'tok-secret-12345' },
+      }),
+    })
+    expect(r.ok).toBe(true)
+    if (r.ok) {
+      expect(r.value.accessToken).toBe('tok-secret-12345')
+      expect(r.value.shortName).toBe('klanker')
+    }
+  })
+
+  it('returns the API error message when ok=false', async () => {
+    const r = await createTelegraphAccount({
+      shortName: 'klanker',
+      fetchImpl: makeFetch(200, { ok: false, error: 'SHORT_NAME_INVALID' }),
+    })
+    expect(r).toMatchObject({ ok: false, reason: 'SHORT_NAME_INVALID' })
+  })
+
+  it('reports HTTP errors verbatim for operator debugging', async () => {
+    const r = await createTelegraphAccount({
+      shortName: 'klanker',
+      fetchImpl: makeFetch(503, 'service unavailable'),
+    })
+    expect(r).toMatchObject({ ok: false, reason: 'http-503' })
+  })
+})
+
+describe('createTelegraphPage', () => {
+  it('returns the published URL on success', async () => {
+    const r = await createTelegraphPage({
+      accessToken: 'tok',
+      title: 'My Article',
+      content: [{ tag: 'p', children: ['hello'] }],
+      fetchImpl: makeFetch(200, {
+        ok: true,
+        result: { url: 'https://telegra.ph/My-Article-01-01', title: 'My Article', views: 0 },
+      }),
+    })
+    expect(r.ok).toBe(true)
+    if (r.ok) expect(r.value.url).toBe('https://telegra.ph/My-Article-01-01')
+  })
+
+  it('rejects missing access_token', async () => {
+    const r = await createTelegraphPage({
+      accessToken: '',
+      title: 't',
+      content: [],
+    })
+    expect(r).toMatchObject({ ok: false, reason: expect.stringContaining('access_token') })
+  })
+
+  it('rejects empty title', async () => {
+    const r = await createTelegraphPage({ accessToken: 'tok', title: '', content: [] })
+    expect(r).toMatchObject({ ok: false, reason: expect.stringContaining('title') })
+  })
+
+  it('rejects title over 256 chars', async () => {
+    const r = await createTelegraphPage({
+      accessToken: 'tok',
+      title: 'x'.repeat(257),
+      content: [],
+    })
+    expect(r).toMatchObject({ ok: false, reason: expect.stringContaining('too long') })
+  })
+})
+
+describe('markdownToTelegraphNodes — block elements', () => {
+  it('emits a single paragraph for plain text', () => {
+    const r = markdownToTelegraphNodes('hello world')
+    expect(r).toHaveLength(1)
+    expect(r[0]).toMatchObject({ tag: 'p' })
+  })
+
+  it('splits paragraphs on blank line', () => {
+    const r = markdownToTelegraphNodes('first.\n\nsecond.')
+    expect(r).toHaveLength(2)
+    expect(r[0]).toMatchObject({ tag: 'p' })
+    expect(r[1]).toMatchObject({ tag: 'p' })
+  })
+
+  it('emits h3 for # heading', () => {
+    const r = markdownToTelegraphNodes('# Section\n\nbody')
+    expect(r[0]).toMatchObject({ tag: 'h3' })
+    expect(r[1]).toMatchObject({ tag: 'p' })
+  })
+
+  it('emits h4 for ## heading', () => {
+    const r = markdownToTelegraphNodes('## Subsection')
+    expect(r[0]).toMatchObject({ tag: 'h4' })
+  })
+
+  it('groups consecutive - lines into one ul', () => {
+    const r = markdownToTelegraphNodes('- one\n- two\n- three')
+    expect(r).toHaveLength(1)
+    expect(r[0].tag).toBe('ul')
+    expect(r[0].children).toHaveLength(3)
+  })
+
+  it('groups consecutive 1. 2. 3. into one ol', () => {
+    const r = markdownToTelegraphNodes('1. first\n2. second\n3. third')
+    expect(r).toHaveLength(1)
+    expect(r[0].tag).toBe('ol')
+    expect(r[0].children).toHaveLength(3)
+  })
+
+  it('preserves fenced code blocks as pre>code', () => {
+    const r = markdownToTelegraphNodes('```\nconst x = 1\n```')
+    expect(r[0].tag).toBe('pre')
+    const child = r[0].children?.[0]
+    expect(typeof child === 'object' && child?.tag).toBe('code')
+  })
+
+  it('renders > quoted lines as blockquote', () => {
+    const r = markdownToTelegraphNodes('> a saying\n> attributed')
+    expect(r[0].tag).toBe('blockquote')
+  })
+
+  it('handles a mixed document end-to-end', () => {
+    const md = '# Title\n\nIntro paragraph.\n\n## Steps\n\n- one\n- two\n\nFinal note.'
+    const r = markdownToTelegraphNodes(md)
+    expect(r.map((n) => n.tag)).toEqual(['h3', 'p', 'h4', 'ul', 'p'])
+  })
+})
+
+describe('parseInline — inline markdown', () => {
+  it('parses inline code', () => {
+    const r = parseInline('use `npm install` to set up')
+    const codeNode = r.find((c) => typeof c === 'object' && c.tag === 'code')
+    expect(codeNode).toBeDefined()
+  })
+
+  it('parses bold', () => {
+    const r = parseInline('this is **important**')
+    const boldNode = r.find((c) => typeof c === 'object' && c.tag === 'b')
+    expect(boldNode).toBeDefined()
+  })
+
+  it('parses italic', () => {
+    const r = parseInline('a *highlighted* word')
+    const italicNode = r.find((c) => typeof c === 'object' && c.tag === 'i')
+    expect(italicNode).toBeDefined()
+  })
+
+  it('parses [text](url) anchors', () => {
+    const r = parseInline('see [docs](https://example.com)')
+    const anchor = r.find((c) => typeof c === 'object' && c.tag === 'a') as
+      | { attrs?: { href?: string } }
+      | undefined
+    expect(anchor?.attrs?.href).toBe('https://example.com')
+  })
+
+  it('auto-links bare URLs', () => {
+    const r = parseInline('visit https://example.com today')
+    const anchor = r.find((c) => typeof c === 'object' && c.tag === 'a') as
+      | { attrs?: { href?: string } }
+      | undefined
+    expect(anchor?.attrs?.href).toBe('https://example.com')
+  })
+
+  it('does not eagerly italic across word-boundaries', () => {
+    // `a*b*c` should NOT match italic — common false-positive.
+    const r = parseInline('a*b*c')
+    const italicNode = r.find((c) => typeof c === 'object' && c.tag === 'i')
+    expect(italicNode).toBeUndefined()
+  })
+
+  it('returns plain text when no markup present', () => {
+    const r = parseInline('just plain words')
+    expect(r).toEqual(['just plain words'])
+  })
+})
+
+describe('deriveTelegraphTitle', () => {
+  it('uses the first heading when present', () => {
+    expect(deriveTelegraphTitle('# Important update\n\nbody')).toBe('Important update')
+  })
+
+  it('falls back to the first non-empty line', () => {
+    expect(deriveTelegraphTitle('\n\nFirst non-empty line.\n\nMore.')).toBe('First non-empty line.')
+  })
+
+  it('strips leading list markers from the title', () => {
+    expect(deriveTelegraphTitle('- first item\n- second')).toBe('first item')
+  })
+
+  it('returns Untitled for fully blank input', () => {
+    expect(deriveTelegraphTitle('   \n\n   ')).toBe('Untitled')
+    expect(deriveTelegraphTitle('')).toBe('Untitled')
+  })
+
+  it('truncates over-long titles to 64 chars + ellipsis', () => {
+    const long = 'x'.repeat(80)
+    const t = deriveTelegraphTitle(long)
+    expect(t.length).toBeLessThanOrEqual(64)
+    expect(t.endsWith('...')).toBe(true)
+  })
+})

package/telegram-plugin/tests/tool-labels.test.ts

@@ -0,0 +1,383 @@
+import { describe, it, expect } from 'vitest'
+import { toolLabel, isHumanDescription } from '../tool-labels.js'
+
+describe('toolLabel', () => {
+  it('Read: uses basename of file_path', () => {
+    expect(toolLabel('Read', { file_path: '/home/ken/code/switchroom/src/foo.ts' })).toBe('foo.ts')
+    expect(toolLabel('Read', { file_path: '/home/ken/.claude/settings.json' })).toBe(
+      'settings.json',
+    )
+  })
+
+  it('Read: basename for deeply nested paths', () => {
+    expect(toolLabel('Read', { file_path: '/opt/project/a/b/c/file.ts' })).toBe('file.ts')
+  })
+
+  it('Write / Edit / NotebookEdit use file_path basename', () => {
+    expect(toolLabel('Write', { file_path: '/x/switchroom/new.ts' })).toBe('new.ts')
+    expect(toolLabel('Edit', { file_path: '/x/switchroom/existing.ts' })).toBe('existing.ts')
+    expect(toolLabel('NotebookEdit', { file_path: '/x/switchroom/nb.ipynb' })).toBe('nb.ipynb')
+  })
+
+  it('Bash: shows first line of command', () => {
+    expect(toolLabel('Bash', { command: 'git status' })).toBe('git status')
+    expect(toolLabel('Bash', { command: 'git log\n--oneline' })).toBe('git log')
+  })
+
+  it('Bash: truncates commands at ~40 chars', () => {
+    const cmd = 'a'.repeat(100)
+    const out = toolLabel('Bash', { command: cmd })
+    expect(out.length).toBeLessThanOrEqual(40)
+    expect(out).toMatch(/…$/)
+  })
+
+  it('Bash: prefers description over raw command when present', () => {
+    expect(
+      toolLabel('Bash', {
+        command: 'find /home -name "*.tmp" -mtime +30 -exec rm {} \\;',
+        description: 'Delete old temp files',
+      }),
+    ).toBe('Delete old temp files')
+  })
+
+  it('Bash: description gets a higher cap than raw command', () => {
+    const longDesc = 'Run the migration script and verify schema integrity across all shards'
+    expect(toolLabel('Bash', { command: 'x', description: longDesc })).toBe(longDesc)
+  })
+
+  it('Grep: quotes pattern and shows "(in <path>)" always', () => {
+    // No path given → "(in repo)"
+    expect(toolLabel('Grep', { pattern: 'TODO' })).toBe('"TODO" (in repo)')
+    // Directory path → shows dir with trailing slash
+    expect(toolLabel('Grep', { pattern: 'switchroom vault', path: 'src' })).toBe(
+      '"switchroom vault" (in src/)',
+    )
+    // File path → basename
+    expect(toolLabel('Grep', { pattern: 'x', path: '/home/ken/switchroom/src/foo.ts' })).toBe(
+      '"x" (in foo.ts)',
+    )
+  })
+
+  it('Glob: shows pattern', () => {
+    expect(toolLabel('Glob', { pattern: '**/*.ts' })).toBe('**/*.ts')
+  })
+
+  it('WebFetch: extracts host from URL', () => {
+    expect(toolLabel('WebFetch', { url: 'https://example.com/path' })).toBe('example.com')
+    expect(toolLabel('WebFetch', { url: 'not a url' })).toBe('not a url')
+  })
+
+  it('WebSearch: quotes the query', () => {
+    expect(toolLabel('WebSearch', { query: 'claude code 2026' })).toBe('"claude code 2026"')
+  })
+
+  it('Task / Agent: show description (or subagent_type fallback)', () => {
+    expect(toolLabel('Task', { description: 'Research bug', subagent_type: 'general-purpose' }))
+      .toBe('Research bug')
+    expect(toolLabel('Agent', { subagent_type: 'Explore' })).toBe('Explore')
+  })
+
+  it('Todo* and Task* housekeeping tools return empty (name alone is enough)', () => {
+    expect(toolLabel('TodoWrite', { todos: [] })).toBe('')
+    expect(toolLabel('TaskCreate', { description: 'x' })).toBe('')
+  })
+
+  it('unknown tools try common keys', () => {
+    expect(toolLabel('MyTool', { file_path: '/x/switchroom/foo.ts' })).toBe('foo.ts')
+    expect(toolLabel('MyTool', { url: 'https://a.b' })).toBe('a.b')
+    expect(toolLabel('MyTool', { command: 'ls\nmore' })).toBe('ls')
+    expect(toolLabel('MyTool', {})).toBe('')
+  })
+
+  it('no input / undefined → empty string', () => {
+    expect(toolLabel('Read')).toBe('')
+    expect(toolLabel('Bash', undefined)).toBe('')
+  })
+
+  it('survives hostile inputs', () => {
+    expect(toolLabel('Read', { file_path: '' })).toBe('')
+    expect(toolLabel('Read', { file_path: 42 as unknown as string })).toBe('')
+  })
+
+  describe('preamble pairing (file/search tools)', () => {
+    it('Read: preamble wins over filename fallback when short single-line', () => {
+      expect(
+        toolLabel(
+          'Read',
+          { file_path: '/x/switchroom/foo.ts' },
+          'Checking the progress card reducer',
+        ),
+      ).toBe('Checking the progress card reducer')
+    })
+
+    it('Read: no preamble → basename fallback preserved', () => {
+      expect(toolLabel('Read', { file_path: '/x/switchroom/foo.ts' })).toBe('foo.ts')
+      expect(toolLabel('Read', { file_path: '/x/switchroom/foo.ts' }, undefined)).toBe('foo.ts')
+      expect(toolLabel('Read', { file_path: '/x/switchroom/foo.ts' }, '')).toBe('foo.ts')
+    })
+
+    it('Read: multi-line preamble is a narrative, not a label → basename fallback', () => {
+      expect(
+        toolLabel(
+          'Read',
+          { file_path: '/x/switchroom/foo.ts' },
+          "Here's my plan:\n1. check the file\n2. fix the bug",
+        ),
+      ).toBe('foo.ts')
+    })
+
+    it('Read: preamble over 160 chars falls back to basename', () => {
+      const long = 'a'.repeat(161)
+      expect(toolLabel('Read', { file_path: '/x/switchroom/foo.ts' }, long)).toBe('foo.ts')
+      // exactly 160 chars still counts as preamble
+      const atCap = 'b'.repeat(160)
+      expect(toolLabel('Read', { file_path: '/x/switchroom/foo.ts' }, atCap)).toBe(atCap)
+    })
+
+    it('Read: whitespace-only preamble falls back to basename', () => {
+      expect(toolLabel('Read', { file_path: '/x/switchroom/foo.ts' }, '   ')).toBe('foo.ts')
+    })
+
+    it('Write / Edit / Grep / Glob all prefer preamble', () => {
+      expect(
+        toolLabel('Write', { file_path: '/x/new.ts' }, 'Creating the new helper'),
+      ).toBe('Creating the new helper')
+      expect(
+        toolLabel('Edit', { file_path: '/x/existing.ts' }, 'Patching the reducer'),
+      ).toBe('Patching the reducer')
+      expect(
+        toolLabel('Grep', { pattern: 'TODO' }, 'Searching for leftover TODOs'),
+      ).toBe('Searching for leftover TODOs')
+      expect(
+        toolLabel('Glob', { pattern: '**/*.ts' }, 'Listing all TypeScript sources'),
+      ).toBe('Listing all TypeScript sources')
+    })
+
+    it('Bash: description wins over preamble when both are present', () => {
+      expect(
+        toolLabel(
+          'Bash',
+          { command: 'git status', description: 'Check git status' },
+          'Running git status real quick',
+        ),
+      ).toBe('Check git status')
+    })
+
+    it('Bash: falls back to preamble when description is absent', () => {
+      // Issue #50.1 — post-#41 Bash no longer ignores preamble. When the
+      // agent didn't supply a `description`, the preamble (model's preceding
+      // text narration) wins over the raw command string.
+      expect(
+        toolLabel(
+          'Bash',
+          { command: 'find /home -name "*.tmp" -mtime +30 -exec rm {} \\;' },
+          'Sweep stale temp files',
+        ),
+      ).toBe('Sweep stale temp files')
+    })
+
+    it('Bash: raw command fallback when both description and preamble are absent', () => {
+      expect(toolLabel('Bash', { command: 'git status' })).toBe('git status')
+      expect(toolLabel('Bash', { command: 'git status' }, undefined)).toBe('git status')
+      expect(toolLabel('Bash', { command: 'git status' }, '')).toBe('git status')
+    })
+
+    it('Bash: multi-line preamble is narrative, not a label → command fallback', () => {
+      expect(
+        toolLabel(
+          'Bash',
+          { command: 'git status' },
+          "Here's my plan:\n1. check status\n2. commit",
+        ),
+      ).toBe('git status')
+    })
+
+    it('Task / Agent ignore preamble (description / subagent_type is always set)', () => {
+      expect(
+        toolLabel('Task', { description: 'Research bug' }, 'Kicking off the research agent'),
+      ).toBe('Research bug')
+      expect(
+        toolLabel('Agent', { subagent_type: 'Explore' }, 'Spawning an explorer'),
+      ).toBe('Explore')
+    })
+  })
+
+  describe('ToolSearch', () => {
+    it('select form → "Loading schema: <names>"', () => {
+      expect(
+        toolLabel('ToolSearch', { query: 'select:mcp__hindsight__recall' }),
+      ).toBe('Loading schema: mcp__hindsight__recall')
+    })
+
+    it('select form with multiple names → comma-separated', () => {
+      expect(
+        toolLabel('ToolSearch', {
+          query: 'select:mcp__hindsight__recall,mcp__switchroom-telegram__stream_reply',
+        }),
+      ).toBe(
+        // Truncated at ~60 chars with an ellipsis suffix — just assert the prefix
+        // and that the output is bounded.
+        'Loading schema: mcp__hindsight__recall, mcp__switchroom-tel…',
+      )
+    })
+
+    it('keyword form → "Searching tools: <query>"', () => {
+      expect(
+        toolLabel('ToolSearch', { query: 'notebook jupyter' }),
+      ).toBe('Searching tools: notebook jupyter')
+    })
+
+    it('empty / missing query → empty string', () => {
+      expect(toolLabel('ToolSearch', {})).toBe('')
+      expect(toolLabel('ToolSearch', { query: '' })).toBe('')
+    })
+
+    it('label stays under MAX_LABEL_CHARS', () => {
+      const long = 'x'.repeat(500)
+      expect(toolLabel('ToolSearch', { query: long }).length).toBeLessThanOrEqual(60)
+      expect(
+        toolLabel('ToolSearch', { query: `select:${long}` }).length,
+      ).toBeLessThanOrEqual(60)
+    })
+  })
+
+  describe('MCP tools (mcp__*)', () => {
+    it('derives "<Server>: <action>" with no query', () => {
+      expect(toolLabel('mcp__hindsight__recall', {})).toBe('Hindsight: recall')
+      expect(toolLabel('mcp__hindsight__reflect', {})).toBe('Hindsight: reflect')
+    })
+
+    it('switchroom-telegram → "Telegram: <action>"', () => {
+      expect(toolLabel('mcp__switchroom-telegram__reply', {})).toBe('Telegram: reply')
+      expect(toolLabel('mcp__switchroom-telegram__stream_reply', {})).toBe('Telegram: stream_reply')
+    })
+
+    it('prefers input.description when present', () => {
+      expect(
+        toolLabel('mcp__hindsight__retain', { description: 'Remember Ken prefers TypeScript' }),
+      ).toBe('Remember Ken prefers TypeScript')
+    })
+
+    it('appends truncated query preview', () => {
+      expect(
+        toolLabel('mcp__hindsight__recall', { query: '4 phase Claude auth management' }),
+      ).toBe('Hindsight: recall (4 phase Claude auth management)')
+    })
+
+    it('long query gets truncated, total stays bounded', () => {
+      const q = '4 phase Claude auth management switchroom agents plan phases'
+      const out = toolLabel('mcp__hindsight__recall', { query: q })
+      expect(out.startsWith('Hindsight: recall (')).toBe(true)
+      expect(out.endsWith(')')).toBe(true)
+      // Budget: MAX_LABEL_CHARS (60) + some framing slack — assert under ~80.
+      expect(out.length).toBeLessThanOrEqual(80)
+    })
+
+    it('uses input.text or input.name when no query present', () => {
+      expect(
+        toolLabel('mcp__hindsight__create_directive', { text: 'Prefer TypeScript' }),
+      ).toBe('Hindsight: create_directive (Prefer TypeScript)')
+      expect(
+        toolLabel('mcp__hindsight__get_mental_model', { name: 'User Profile' }),
+      ).toBe('Hindsight: get_mental_model (User Profile)')
+    })
+
+    it('malformed mcp name falls back to generic sweep', () => {
+      // Only one `__` segment after prefix — no action half.
+      expect(toolLabel('mcp__broken', { query: 'foo' })).toBe('foo')
+    })
+
+    it('strips HTML tags from preview text', () => {
+      // stream_reply accepts Telegram-HTML text; raw tags in the preview
+      // would survive escapeHtml() in the renderer and render as literal
+      // `<b>` on screen. The label must come back as plain prose.
+      const out = toolLabel('mcp__switchroom-telegram__stream_reply', {
+        text: '<b>Recommendation, priority-ordered:</b> 1a — scaffold',
+      })
+      expect(out).not.toContain('<b>')
+      expect(out).not.toContain('</b>')
+      expect(out).toContain('Recommendation')
+    })
+
+    it('strips HTML from description fallback', () => {
+      const out = toolLabel('mcp__hindsight__retain', {
+        description: 'Remember <i>Ken</i> prefers TypeScript',
+      })
+      expect(out).toBe('Remember Ken prefers TypeScript')
+    })
+
+    it('preserves comparison operators in non-HTML queries', () => {
+      // stripHtml's regex requires a letter/slash after `<` so plain-text
+      // comparisons like "x < 5 and y > 3" don't get their middle eaten.
+      const out = toolLabel('mcp__hindsight__recall', {
+        query: 'x < 5 and y > 3',
+      })
+      expect(out).toBe('Hindsight: recall (x < 5 and y > 3)')
+    })
+  })
+
+  describe('regression: existing cases still pass with new defaults', () => {
+    it('Bash still wins its explicit case', () => {
+      expect(toolLabel('Bash', { description: 'Check file size' })).toBe('Check file size')
+    })
+
+    it('unknown non-mcp tool still uses generic sweep', () => {
+      expect(toolLabel('SomeRandomTool', { description: 'doing a thing' })).toBe('doing a thing')
+    })
+  })
+})
+
+describe('isHumanDescription', () => {
+  it('Bash with non-empty description → true', () => {
+    expect(isHumanDescription('Bash', { description: 'Check commit state' })).toBe(true)
+    expect(isHumanDescription('Bash', { command: 'git status', description: 'Check git status' })).toBe(true)
+  })
+
+  it('BashOutput with non-empty description → true', () => {
+    expect(isHumanDescription('BashOutput', { description: 'Stream output' })).toBe(true)
+  })
+
+  it('Bash with no description, command only → false', () => {
+    expect(isHumanDescription('Bash', { command: 'git status' })).toBe(false)
+    expect(isHumanDescription('Bash', {})).toBe(false)
+    expect(isHumanDescription('Bash', { description: '' })).toBe(false)
+    expect(isHumanDescription('Bash', { description: '   ' })).toBe(false)
+  })
+
+  it('Task with non-empty description → true', () => {
+    expect(isHumanDescription('Task', { description: 'Research the bug' })).toBe(true)
+  })
+
+  it('Agent with non-empty description → true', () => {
+    expect(isHumanDescription('Agent', { description: 'Deploy the service', subagent_type: 'worker' })).toBe(true)
+  })
+
+  it('Task / Agent without description → false', () => {
+    expect(isHumanDescription('Task', { subagent_type: 'general-purpose' })).toBe(false)
+    expect(isHumanDescription('Agent', {})).toBe(false)
+  })
+
+  it('WebFetch → false (tool name provides context)', () => {
+    expect(isHumanDescription('WebFetch', { url: 'https://example.com', description: 'Check docs' })).toBe(false)
+  })
+
+  it('WebSearch → false', () => {
+    expect(isHumanDescription('WebSearch', { query: 'foo', description: 'Search for foo' })).toBe(false)
+  })
+
+  it('Read / Edit / Grep → false', () => {
+    expect(isHumanDescription('Read', { file_path: '/x/foo.ts' })).toBe(false)
+    expect(isHumanDescription('Edit', { file_path: '/x/foo.ts', description: 'Fix the bug' })).toBe(false)
+    expect(isHumanDescription('Grep', { pattern: 'TODO' })).toBe(false)
+  })
+
+  it('MCP tools → false (handled separately by tool.startsWith("mcp__"))', () => {
+    expect(isHumanDescription('mcp__hindsight__recall', { query: 'foo' })).toBe(false)
+    expect(isHumanDescription('mcp__hindsight__retain', { description: 'Store user pref' })).toBe(false)
+  })
+
+  it('missing or non-object input → false', () => {
+    expect(isHumanDescription('Bash', undefined)).toBe(false)
+    expect(isHumanDescription('Bash')).toBe(false)
+  })
+})