@iceinvein/agent-skills 0.1.25 → 0.1.26

package/README.md

@@ -104,6 +104,7 @@ Skills that compose the other audit skills into higher-level workflows.
 | Skill | What it does |
 |-------|--------------|
 | **improve-my-codebase** | Runs every applicable audit skill in parallel against your codebase, ranks findings by convergence (multiple audits agreeing) and per-file rollup, and writes a prioritized improvement report. Default sweeps everything; positional args switch modes (`quick`, `diff`, `interactive`) or narrow scope (`focus <area>`, `module <path>`). |
+| **magpie** | Interactive PR review pipeline. Runs five parallel specialist subagents (security, bugs, performance, code-smells, architecture), dedupes findings, applies a critic rubric, peer-reviews via `codex exec`, and serves an interactive HTML report for selecting findings to post via `gh`. |
 
 ## Commands
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iceinvein/agent-skills",
-  "version": "0.1.25",
+  "version": "0.1.26",
   "description": "Install agent skills into AI coding tools",
   "author": "iceinvein",
   "license": "MIT",

package/skills/magpie/fixtures/example-pr/diff.patch

@@ -0,0 +1,86 @@
+diff --git a/src/api/session.ts b/src/api/session.ts
+index abc1234..def5678 100644
+--- a/src/api/session.ts
++++ b/src/api/session.ts
+@@ -80,20 +80,35 @@ function validateToken(token: string): boolean {
+   return token.length > 16
+ }
+
+-export async function createSession(userId: string, token: string) {
+-  // Session key uses tenant id for isolation
+-  const key = `session:${userId}`
+-  await redis.set(key, token)
+-  return {
+-    userId,
+-    createdAt: new Date(),
+-  }
++const SESSION_TTL_SECONDS = 60 * 60 * 8 // 8h
++const sessionKey = (tenantId: string, userId: string) => `t:${tenantId}:session:${userId}`
++
++export async function createSession(tenantId: string, userId: string, token: string) {
++  const key = sessionKey(tenantId, userId)
++  await redis.set(key, token, 'EX', SESSION_TTL_SECONDS)
++  const sessionToken = await redis.get(key)
++  return {
++    tenantId,
++    userId,
++    token: sessionToken,
++    createdAt: new Date(),
++    expiresAt: new Date(Date.now() + SESSION_TTL_SECONDS * 1000),
++  }
+ }
+
+diff --git a/src/cache/invalidation.ts b/src/cache/invalidation.ts
+index 1111111..2222222 100644
+--- a/src/cache/invalidation.ts
++++ b/src/cache/invalidation.ts
+@@ -138,10 +138,8 @@ export async function getCacheVersion(): Promise<number> {
+   return parseInt(version, 10)
+ }
+
+-export async function invalidate() {
+-  const version = await redis.get(versionKey)
+-  const newVersion = parseInt(version, 10) + 1
+-  await redis.set(versionKey, String(newVersion))
++export async function invalidate(): Promise<number> {
++  const newVersion = await redis.incr(versionKey)
+   return newVersion
+ }
+
+diff --git a/src/dashboard/recent-activity.tsx b/src/dashboard/recent-activity.tsx
+index 3333333..4444444 100644
+--- a/src/dashboard/recent-activity.tsx
++++ b/src/dashboard/recent-activity.tsx
+@@ -55,10 +55,13 @@ export interface RecentActivityProps {
+   onEventSelect?: (event: Event) => void
+ }
+
+-export function RecentActivity({ events, onEventSelect }: RecentActivityProps) {
+-  const timeline = events
+-    .map(toTimelineEntry)
+-    .sort(byRecency)
++import { useMemo } from 'react'
++
++export function RecentActivity({ events, onEventSelect }: RecentActivityProps) {
++  const timeline = useMemo(
++    () => events.map(toTimelineEntry).sort(byRecency),
++    [events]
++  )
+
+   return (
+     <div className="timeline-container">
+
+diff --git a/src/services/auth/index.ts b/src/services/auth/index.ts
+index 5555555..6666666 100644
+--- a/src/services/auth/index.ts
++++ b/src/services/auth/index.ts
+@@ -20,7 +20,8 @@ export class AuthService {
+   }
+
+   async signIn(email: string, password: string) {
+-    const user = await userDb.getUserById(email)
++    const user = await this.userRepo.findById(email)
++    const lastLoginAt = await this.userRepo.findLastLoginAt(email)
+     if (!user || !this.verifyPassword(password, user.passwordHash)) {
+       throw new Error('Invalid credentials')
+     }

package/skills/magpie/fixtures/example-pr/pr.json

@@ -5,5 +5,17 @@
   "headRefName": "feat/session-redis-and-prompts",
   "baseRefName": "main",
   "headRefOid": "9f3a8c0211dbb5fe7a82a2c1b08e0a45c2d1ee01",
-  "url": "https://github.com/example/repo/pull/1337"
+  "url": "https://github.com/example/repo/pull/1337",
+  "files": [
+    { "path": "src/api/session.ts", "additions": 42, "deletions": 18 },
+    { "path": "src/cache/invalidation.ts", "additions": 28, "deletions": 12 },
+    { "path": "src/dashboard/recent-activity.tsx", "additions": 35, "deletions": 8 },
+    { "path": "src/lib/parser.ts", "additions": 64, "deletions": 45 },
+    { "path": "src/services/auth/index.ts", "additions": 31, "deletions": 15 },
+    { "path": "src/utils/format-currency.ts", "additions": 16, "deletions": 9 },
+    { "path": "src/components/Button.tsx", "additions": 22, "deletions": 11 },
+    { "path": "vendor/legacy/heavy-parser.js", "additions": 8, "deletions": 3 },
+    { "path": "README.md", "additions": 5, "deletions": 2 },
+    { "path": "package.json", "additions": 1, "deletions": 1 }
+  ]
 }

package/skills/magpie/fixtures/fake-gh.sh

@@ -10,7 +10,16 @@ case "$1 $2" in
   "headRefOid": "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
   "baseRefOid": "cafebabecafebabecafebabecafebabecafebabe",
   "author": { "login": "octocat" },
-  "body": "Fake body"
+  "body": "Fake body",
+  "url": "https://github.com/octocat/Hello-World/pull/1234",
+  "files": [
+    {
+      "path": "src/a.ts",
+      "additions": 1,
+      "deletions": 0,
+      "changeType": "modified"
+    }
+  ]
 }
 JSON
     ;;

package/skills/magpie/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magpie",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "private": true,
   "type": "module",
   "scripts": {

package/skills/magpie/scripts/__tests__/diff-utils.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, test } from 'bun:test'
+import { filePathMatches, parseUnifiedDiffToHunks, splitDiffByFile } from '../diff-utils.ts'
+
+const SAMPLE = `diff --git a/src/a.ts b/src/a.ts
+index abc..def 100644
+--- a/src/a.ts
++++ b/src/a.ts
+@@ -1,3 +1,4 @@
+ line1
+-old
++new
++added
+ line3
+diff --git a/src/b.ts b/src/b.ts
+new file mode 100644
+--- /dev/null
++++ b/src/b.ts
+@@ -0,0 +1,2 @@
++first
++second
+`
+
+describe('parseUnifiedDiffToHunks', () => {
+  test('parses a single-file two-hunk diff', () => {
+    const single = SAMPLE.split('diff --git a/src/b.ts')[0] ?? ''
+    const hunks = parseUnifiedDiffToHunks(single)
+    expect(hunks).toHaveLength(1)
+    const hunk = hunks[0]
+    if (!hunk) throw new Error('expected one hunk')
+    expect(hunk.oldStart).toBe(1)
+    expect(hunk.newStart).toBe(1)
+    expect(hunk.lines).toHaveLength(5)
+    const types = hunk.lines.map((l) => l.type)
+    expect(types).toEqual(['context', 'removed', 'added', 'added', 'context'])
+  })
+
+  test('assigns new line numbers only to added and context lines', () => {
+    const single = SAMPLE.split('diff --git a/src/b.ts')[0] ?? ''
+    const hunks = parseUnifiedDiffToHunks(single)
+    const hunk = hunks[0]
+    if (!hunk) throw new Error('expected one hunk')
+    const lines = hunk.lines
+    expect(lines[0]?.newLineNo).toBe(1)
+    expect(lines[1]?.newLineNo).toBeNull()
+    expect(lines[2]?.newLineNo).toBe(2)
+    expect(lines[3]?.newLineNo).toBe(3)
+    expect(lines[4]?.newLineNo).toBe(4)
+  })
+
+  test('assigns old line numbers only to removed and context lines', () => {
+    const single = SAMPLE.split('diff --git a/src/b.ts')[0] ?? ''
+    const hunks = parseUnifiedDiffToHunks(single)
+    const hunk = hunks[0]
+    if (!hunk) throw new Error('expected one hunk')
+    const lines = hunk.lines
+    expect(lines[0]?.oldLineNo).toBe(1)
+    expect(lines[1]?.oldLineNo).toBe(2)
+    expect(lines[2]?.oldLineNo).toBeNull()
+    expect(lines[3]?.oldLineNo).toBeNull()
+    expect(lines[4]?.oldLineNo).toBe(3)
+  })
+
+  test('returns empty array for empty input', () => {
+    expect(parseUnifiedDiffToHunks('')).toEqual([])
+  })
+
+  test('handles "no newline at end of file" marker by ignoring it', () => {
+    const diff = `--- a/x
++++ b/x
+@@ -1 +1 @@
+-old
+\
++new
+\
+`
+    const hunks = parseUnifiedDiffToHunks(diff)
+    const hunk = hunks[0]
+    if (!hunk) throw new Error('expected one hunk')
+    expect(hunk.lines.map((l) => l.type)).toEqual(['removed', 'added'])
+  })
+})
+
+describe('splitDiffByFile', () => {
+  test('returns one entry per file using the "b/" path', () => {
+    const m = splitDiffByFile(SAMPLE)
+    expect(m.size).toBe(2)
+    expect(m.get('src/a.ts')).toContain('@@ -1,3 +1,4 @@')
+    expect(m.get('src/b.ts')).toContain('@@ -0,0 +1,2 @@')
+  })
+
+  test('returns empty map for empty input', () => {
+    expect(splitDiffByFile('').size).toBe(0)
+  })
+})
+
+describe('filePathMatches', () => {
+  test('exact match', () => {
+    expect(filePathMatches('src/a.ts', 'src/a.ts')).toBe(true)
+  })
+  test('tolerates "b/" prefix on one side', () => {
+    expect(filePathMatches('b/src/a.ts', 'src/a.ts')).toBe(true)
+  })
+  test('non-match returns false', () => {
+    expect(filePathMatches('src/a.ts', 'src/b.ts')).toBe(false)
+  })
+})

package/skills/magpie/scripts/__tests__/file-tree.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  buildTree,
+  collapseTree,
+  countDirFindings,
+  type DirNode,
+  findingCountsBySeverity,
+} from '../file-tree.ts'
+import type { PrFileEntry, ReviewFinding } from '../types.ts'
+
+const files: PrFileEntry[] = [
+  { path: 'src/a.ts', additions: 5, deletions: 1 },
+  { path: 'src/b.ts', additions: 2, deletions: 0 },
+  { path: 'src/deep/only.ts', additions: 1, deletions: 0 },
+  { path: 'README.md', additions: 3, deletions: 0 },
+]
+
+const findings: ReviewFinding[] = [
+  {
+    id: '1',
+    file: 'src/a.ts',
+    line: 1,
+    severity: 'blocker',
+    title: 't',
+    description: 'd',
+    risk: { impact: 'high', likelihood: 'likely', confidence: 'high', action: 'must-fix' },
+    domain: 'security',
+  },
+  {
+    id: '2',
+    file: 'src/a.ts',
+    line: 2,
+    severity: 'high',
+    title: 't',
+    description: 'd',
+    risk: { impact: 'high', likelihood: 'likely', confidence: 'high', action: 'should-fix' },
+    domain: 'bugs',
+  },
+  {
+    id: '3',
+    file: 'src/deep/only.ts',
+    line: 1,
+    severity: 'medium',
+    title: 't',
+    description: 'd',
+    risk: { impact: 'medium', likelihood: 'possible', confidence: 'medium', action: 'consider' },
+    domain: 'bugs',
+  },
+] as ReviewFinding[]
+
+describe('buildTree', () => {
+  test('groups files by directory', () => {
+    const tree = buildTree(files)
+    expect(tree.dirs.has('src')).toBe(true)
+    expect(tree.files.find((f) => f.path === 'README.md')).toBeDefined()
+  })
+
+  test('nests deep directories', () => {
+    const tree = buildTree(files)
+    const src = tree.dirs.get('src')
+    if (!src) throw new Error('expected src dir')
+    expect(src.dirs.has('deep')).toBe(true)
+    expect(src.dirs.get('deep')?.files.map((f) => f.path)).toEqual(['src/deep/only.ts'])
+  })
+})
+
+describe('collapseTree', () => {
+  test('collapses nested single-child dirs like apps/server/lib', () => {
+    const f: PrFileEntry[] = [{ path: 'apps/server/lib/x.ts', additions: 1, deletions: 0 }]
+    const tree = collapseTree(buildTree(f))
+    const first = [...tree.dirs.values()][0]
+    if (!first) throw new Error('expected one dir')
+    expect(first.name).toBe('apps/server/lib')
+  })
+})
+
+describe('findingCountsBySeverity', () => {
+  test('returns severity counts for a file in canonical order', () => {
+    const counts = findingCountsBySeverity(findings, 'src/a.ts')
+    expect(counts).toEqual([
+      { severity: 'blocker', count: 1 },
+      { severity: 'high', count: 1 },
+    ])
+  })
+
+  test('returns empty array when the file has no findings', () => {
+    expect(findingCountsBySeverity(findings, 'README.md')).toEqual([])
+  })
+})
+
+describe('countDirFindings', () => {
+  test('sums findings across all files in a subtree', () => {
+    const tree = collapseTree(buildTree(files))
+    const src = tree.dirs.get('src') as DirNode | undefined
+    if (src) expect(countDirFindings(findings, src)).toBe(3)
+  })
+})

package/skills/magpie/scripts/__tests__/gh.test.ts

@@ -26,6 +26,14 @@ test('fetchPr writes pr.json and diff.patch', async () => {
   expect(diff).toContain('export const x = 2')
 })
 
+test('fetchPr includes files in pr.json', async () => {
+  const result = await fetchPr({ ghBin: FAKE_GH, prNumber: 1234, runDir })
+  expect(result.ok).toBe(true)
+  const pr = JSON.parse(await readFile(join(runDir, 'pr.json'), 'utf8'))
+  expect(Array.isArray(pr.files)).toBe(true)
+  expect(pr.files[0]).toMatchObject({ path: 'src/a.ts', additions: 1, deletions: 0 })
+})
+
 test('fetchPr returns ok=false when gh exits non-zero', async () => {
   const result = await fetchPr({
     ghBin: '/usr/bin/false',

package/skills/magpie/scripts/__tests__/helper.test.ts

@@ -57,3 +57,66 @@ test('helper.js sends periodic heartbeats', async () => {
   expect(src).toContain("fetch('/heartbeat'")
   expect(src).toMatch(/setInterval/)
 })
+
+test('helper.js dispatches set-view and toggles body.dataset.view', async () => {
+  const src = await readFile(HELPER, 'utf8')
+  expect(src).toContain('handleSetView')
+  expect(src).toMatch(/document\.body\.dataset\.view\s*=\s*view/)
+})
+
+test('helper.js handles select-file by toggling [data-file-pane] hidden', async () => {
+  const src = await readFile(HELPER, 'utf8')
+  expect(src).toContain('handleSelectFile')
+  expect(src).toContain('data-file-pane')
+})
+
+test('helper.js handles set-diff-mode by toggling .diff-unified / .diff-split', async () => {
+  const src = await readFile(HELPER, 'utf8')
+  expect(src).toContain('handleSetDiffMode')
+  expect(src).toContain('diff-unified')
+  expect(src).toContain('diff-split')
+})
+
+test('helper.js implements per-file finding navigation', async () => {
+  const src = await readFile(HELPER, 'utf8')
+  expect(src).toContain('navigateFinding')
+  expect(src).toContain('fileFindingIdx')
+  expect(src).toContain('is-focused')
+})
+
+test('helper.js toggles suggestions visibility via body.dataset.showSuggestions', async () => {
+  const src = await readFile(HELPER, 'utf8')
+  expect(src).toContain('handleToggleSuggestions')
+  expect(src).toContain('showSuggestions')
+})
+
+test('helper.js toggles severity filter via body.hide-sev-* classes', async () => {
+  const src = await readFile(HELPER, 'utf8')
+  expect(src).toContain('handleFilterSev')
+  expect(src).toContain('hide-sev-')
+})
+
+test('helper.js wires select-sev and select-recommended', async () => {
+  const src = await readFile(HELPER, 'utf8')
+  expect(src).toContain('handleSelectSev')
+  expect(src).toContain('handleSelectRecommended')
+})
+
+test('helper.js updates selected-count via [data-role="selected-count"]', async () => {
+  const src = await readFile(HELPER, 'utf8')
+  expect(src).toContain('updateSelectedCount')
+  expect(src).toContain('selected-count')
+})
+
+test('helper.js POSTs to /api/post-review when Post Selected is wired', async () => {
+  const src = await readFile(HELPER, 'utf8')
+  expect(src).toContain('/api/post-review')
+  expect(src).toContain('handlePostSelected')
+  expect(src).toContain('handlePostRecommended')
+})
+
+test('helper.js applies review result to data-posted on matching annotations', async () => {
+  const src = await readFile(HELPER, 'utf8')
+  expect(src).toContain('applyReviewResult')
+  expect(src).toContain("setAttribute('data-posted'")
+})

package/skills/magpie/scripts/__tests__/pipeline-e2e.test.ts

@@ -77,6 +77,16 @@ test('setup -> dedupe -> render(progress) -> render(findings) -> cleanup compose
   expect(screen).toContain('progress.html')
   expect(screen).toContain('findings.html')
 
+  // Verify Pylon-style DOM markers in findings.html
+  const findingsHtml = await Bun.file(join(runDir, 'screen', 'findings.html')).text()
+  expect(findingsHtml.includes('class="pr-header"')).toBe(true)
+  expect(findingsHtml.includes('data-finding-id')).toBe(true)
+  expect(findingsHtml.includes('data-file-pane')).toBe(true)
+  expect(findingsHtml.includes('data-role="action-bar"')).toBe(true)
+  expect(findingsHtml.includes('data-action="post-recommended"')).toBe(true)
+  expect(findingsHtml.includes('class="annot-body')).toBe(true)
+  expect(findingsHtml.includes('class="issue-card')).toBe(true)
+
   expect(await runCleanup({ runDir, repoPath: repo, gitBin: 'git' })).toBe(0)
   const parent = dirname(runDir)
   const entries = await readdir(parent)

package/skills/magpie/scripts/__tests__/post-cmd.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, expect, test } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
 import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
@@ -8,6 +8,7 @@ import {
   formatPostBody,
   formatReviewSummaryBody,
   parseRepoFromUrl,
+  postFindingsAsReview,
   runPost,
 } from '../post-cmd.ts'
 
@@ -331,3 +332,91 @@ test('runPost appends post stage events to log.jsonl', async () => {
   expect(log).toContain('"status":"start"')
   expect(log).toContain('"status":"dry-run"')
 })
+
+// ---------------------------------------------------------------------------
+// postFindingsAsReview
+// ---------------------------------------------------------------------------
+
+async function scaffoldRunDir(findings: unknown[]): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), 'magpie-post-review-'))
+  await writeFile(join(dir, 'findings.json'), JSON.stringify(findings))
+  return dir
+}
+
+const inlineFinding = (id: string, line: number) => ({
+  id,
+  file: 'src/a.ts',
+  line,
+  severity: 'high',
+  title: `Finding ${id}`,
+  description: 'd',
+  risk: { impact: 'high', likelihood: 'likely', confidence: 'high', action: 'must-fix' },
+  domain: 'security',
+})
+
+describe('postFindingsAsReview', () => {
+  test('builds a payload with N inline comments under dryRun', async () => {
+    const dir = await scaffoldRunDir([
+      inlineFinding('1', 10),
+      inlineFinding('2', 20),
+      inlineFinding('3', 30),
+    ])
+    const r = await postFindingsAsReview({
+      runDir: dir,
+      findingIds: ['1', '2', '3'],
+      prNumber: 42,
+      headSha: 'abc123',
+      dryRun: true,
+    })
+    expect(r.command?.[0]).toBe('gh')
+    expect(r.command?.[2]).toBe('repos/{owner}/{repo}/pulls/42/reviews')
+    expect(r.payload).toBeDefined()
+    const parsed = JSON.parse(r.payload as string) as {
+      comments: Array<{ path: string; line: number; side: string }>
+    }
+    expect(parsed.comments).toHaveLength(3)
+    expect(parsed.comments[0]).toMatchObject({ path: 'src/a.ts', line: 10, side: 'RIGHT' })
+    expect(parsed.comments[1]).toMatchObject({ path: 'src/a.ts', line: 20, side: 'RIGHT' })
+    expect(parsed.comments[2]).toMatchObject({ path: 'src/a.ts', line: 30, side: 'RIGHT' })
+    await rm(dir, { recursive: true, force: true })
+  })
+
+  test('routes line-less findings into the review body', async () => {
+    const dir = await scaffoldRunDir([
+      {
+        id: '1',
+        file: null,
+        line: null,
+        severity: 'high',
+        title: 'general note',
+        description: 'd',
+        risk: { impact: 'high', likelihood: 'likely', confidence: 'high', action: 'must-fix' },
+        domain: 'architecture',
+      },
+    ])
+    const r = await postFindingsAsReview({
+      runDir: dir,
+      findingIds: ['1'],
+      prNumber: 42,
+      headSha: 'abc123',
+      dryRun: true,
+    })
+    const parsed = JSON.parse(r.payload as string) as { body: string; comments: unknown[] }
+    expect(parsed.comments).toHaveLength(0)
+    expect(parsed.body).toContain('general note')
+    await rm(dir, { recursive: true, force: true })
+  })
+
+  test('returns comments for unknown ids under dryRun', async () => {
+    const dir = await scaffoldRunDir([])
+    const r = await postFindingsAsReview({
+      runDir: dir,
+      findingIds: ['missing'],
+      prNumber: 42,
+      headSha: 'abc123',
+      dryRun: true,
+    })
+    expect(r.comments.find((c) => c.id === 'missing')).toBeDefined()
+    await rm(dir, { recursive: true, force: true })
+  })
+})

package/skills/magpie/scripts/__tests__/preview-cmd.test.ts

@@ -190,8 +190,8 @@ test('mixed post-status in the fixture surfaces both posted and failed badges',
     openInBrowser: false,
   })
   const html = await readFile(join(workDir, 'findings.html'), 'utf8')
-  expect(html).toContain('class="badge posted"')
-  expect(html).toContain('class="badge failed"')
+  expect(html).toContain('class="status-chip posted"')
+  expect(html).toContain('class="status-chip failed"')
   // The fixture's failed entry includes a 422 message; make sure it survives.
   expect(html).toContain('422')
 })
@@ -205,6 +205,6 @@ test('bundled fixture covers all five focus domains', async () => {
   })
   const html = await readFile(join(workDir, 'findings.html'), 'utf8')
   for (const domain of ['security', 'bugs', 'performance', 'code-smells', 'architecture']) {
-    expect(html).toContain(`data-filter-value="${domain}"`)
+    expect(html).toContain(`data-domain="${domain}"`)
   }
 })

package/skills/magpie/scripts/__tests__/refresh.test.ts

@@ -60,8 +60,8 @@ test('refreshFindings writes findings.html and prunes any older findings*.html',
   const fresh = await readFile(join(runDir, 'screen', 'findings.html'), 'utf8')
   // The new file is rendered, not the stale OLD content.
   expect(fresh).not.toContain('OLD')
-  // Contains the new interactivity surface (filter bar, data-run-id).
-  expect(fresh).toContain('class="filter-bar"')
+  // Contains the new interactivity surface (segmented tabs, data-run-id).
+  expect(fresh).toContain('data-action="set-view"')
   expect(fresh).toMatch(/data-run-id="[^"]+"/)
   // And the rendered finding itself.
   expect(fresh).toContain('tsst')

package/skills/magpie/scripts/__tests__/render-action-bar.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, test } from 'bun:test'
+import { renderActionBar } from '../render-action-bar.ts'
+import type { ReviewFinding } from '../types.ts'
+
+const findings: ReviewFinding[] = [
+  {
+    id: '1',
+    file: 'a.ts',
+    line: 1,
+    severity: 'blocker',
+    title: 'A',
+    description: 'd',
+    risk: { impact: 'high', likelihood: 'likely', confidence: 'high', action: 'must-fix' },
+    domain: 'security',
+  },
+  {
+    id: '2',
+    file: 'b.ts',
+    line: 1,
+    severity: 'high',
+    title: 'B',
+    description: 'd',
+    risk: { impact: 'high', likelihood: 'likely', confidence: 'high', action: 'should-fix' },
+    domain: 'bugs',
+  },
+  {
+    id: '3',
+    file: 'c.ts',
+    line: 1,
+    severity: 'low',
+    title: 'C',
+    description: 'd',
+    risk: { impact: 'low', likelihood: 'unknown', confidence: 'medium', action: 'optional' },
+    domain: 'code-smells',
+  },
+] as ReviewFinding[]
+
+describe('renderActionBar', () => {
+  test('Post Recommended count excludes suggestions', () => {
+    const html = renderActionBar({ findings })
+    expect(html).toContain('Post Recommended (2)')
+  })
+
+  test('initial Post Selected reads 0', () => {
+    const html = renderActionBar({ findings })
+    expect(html).toContain('Post Selected (')
+    expect(html).toMatch(/data-role="selected-count">0</)
+  })
+
+  test('renders excluded suggestions hint when suggestions present', () => {
+    const html = renderActionBar({ findings })
+    expect(html).toContain('1 suggestion excluded')
+  })
+
+  test('renders severity selection pills with counts', () => {
+    const html = renderActionBar({ findings })
+    expect(html).toContain('data-action="select-sev"')
+    expect(html).toContain('data-sev="blocker"')
+    expect(html).toContain('data-sev="high"')
+  })
+
+  test('renders Select recommended link', () => {
+    const html = renderActionBar({ findings })
+    expect(html).toContain('data-action="select-recommended"')
+  })
+})