@swarmclawai/swarmclaw 0.8.4 → 0.8.7

package/src/components/chat/streaming-bubble.tsx

@@ -1,21 +1,135 @@
 'use client'
 
-import { useMemo, useState } from 'react'
+import { memo, useMemo, useState } from 'react'
 import { AiAvatar } from '@/components/shared/avatar'
 import { AgentAvatar } from '@/components/agents/agent-avatar'
-import { ToolCallBubble, extractMedia } from './tool-call-bubble'
+import { ToolCallBubble, extractMedia, getInputPreview, getToolLabel } from './tool-call-bubble'
 import { ActivityMoment, isNotableTool } from './activity-moment'
 import { useChatStore, type ToolEvent } from '@/stores/use-chat-store'
 import { isStructuredMarkdown } from './markdown-utils'
 
-function ToolEventsSection({ toolEvents }: { toolEvents: ToolEvent[] }) {
+function summarizeToolResult(event: ToolEvent): string | null {
+  if (!event.output) return null
+
+  const media = extractMedia(event.output)
+  const parts: string[] = []
+
+  if (media.images.length > 0) parts.push(`${media.images.length} image${media.images.length === 1 ? '' : 's'}`)
+  if (media.videos.length > 0) parts.push(`${media.videos.length} video${media.videos.length === 1 ? '' : 's'}`)
+  if (media.pdfs.length > 0) parts.push(`${media.pdfs.length} PDF${media.pdfs.length === 1 ? '' : 's'}`)
+  if (media.files.length > 0) parts.push(`${media.files.length} file${media.files.length === 1 ? '' : 's'}`)
+  if (parts.length > 0) return parts.join(' · ')
+
+  const clean = media.cleanText.replace(/\s+/g, ' ').trim()
+  if (!clean) return null
+  return clean.length > 120 ? `${clean.slice(0, 120)}...` : clean
+}
+
+const ToolStatusPill = memo(function ToolStatusPill({ status }: { status: ToolEvent['status'] }) {
+  const tone = status === 'running'
+    ? 'border-white/[0.08] bg-white/[0.05] text-text-3'
+    : status === 'error'
+      ? 'border-rose-500/25 bg-rose-500/10 text-rose-300'
+      : 'border-emerald-500/25 bg-emerald-500/10 text-emerald-300'
+
+  const label = status === 'running' ? 'Running' : status === 'error' ? 'Failed' : 'Done'
+
+  return (
+    <span className={`rounded-full border px-2 py-0.5 text-[10px] font-600 uppercase tracking-[0.08em] ${tone}`}>
+      {label}
+    </span>
+  )
+})
+
+const ToolSummaryRow = memo(function ToolSummaryRow({ event, caption }: { event: ToolEvent; caption: string }) {
+  const isRunning = event.status === 'running'
+  const isError = event.status === 'error'
+  const label = useMemo(() => getToolLabel(event.name, event.input), [event.input, event.name])
+  const inputPreview = useMemo(() => getInputPreview(event.name, event.input), [event.input, event.name])
+  const resultPreview = useMemo(() => summarizeToolResult(event), [event])
+  const color = isError ? '#F43F5E' : isRunning ? '#F59E0B' : '#22C55E'
+
+  return (
+    <div
+      className={`rounded-[14px] border px-3.5 py-3 ${
+      isRunning
+        ? 'border-amber-500/20 bg-amber-500/[0.06]'
+        : isError
+          ? 'border-rose-500/18 bg-rose-500/[0.05]'
+          : 'border-white/[0.06] bg-white/[0.03]'
+    }`}
+      data-testid="tool-call-row"
+      data-tool-name={event.name}
+      data-tool-status={event.status}
+    >
+      <div className="flex items-start gap-3">
+        <div className="mt-0.5 shrink-0">
+          {isRunning ? (
+            <span className="block w-3.5 h-3.5 rounded-full border-2 border-current animate-spin" style={{ color, borderTopColor: 'transparent' }} />
+          ) : isError ? (
+            <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke={color} strokeWidth="2.5" strokeLinecap="round">
+              <line x1="18" y1="6" x2="6" y2="18" />
+              <line x1="6" y1="6" x2="18" y2="18" />
+            </svg>
+          ) : (
+            <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke={color} strokeWidth="2.5" strokeLinecap="round">
+              <polyline points="20 6 9 17 4 12" />
+            </svg>
+          )}
+        </div>
+        <div className="min-w-0 flex-1">
+          <div className="flex flex-wrap items-center gap-2">
+            <span className="text-[10px] font-600 uppercase tracking-[0.08em] text-text-3/55">{caption}</span>
+            <span className="text-[13px] font-600 text-text-2">{label}</span>
+            <ToolStatusPill status={event.status} />
+          </div>
+          {inputPreview && (
+            <div className="mt-1 text-[12px] font-mono text-text-2 truncate">
+              {inputPreview}
+            </div>
+          )}
+          {resultPreview && !isRunning && (
+            <div className={`mt-1 text-[12px] ${isError ? 'text-rose-200/80' : 'text-text-3/70'}`}>
+              {resultPreview}
+            </div>
+          )}
+        </div>
+      </div>
+    </div>
+  )
+})
+
+const ToolEventsSection = memo(function ToolEventsSection({ toolEvents }: { toolEvents: ToolEvent[] }) {
   const [expanded, setExpanded] = useState(false)
-  const shouldCollapse = toolEvents.length > 2
-  const latestTool = toolEvents[toolEvents.length - 1]
+  const summary = useMemo(() => {
+    let running = 0
+    let done = 0
+    let error = 0
+    for (const event of toolEvents) {
+      if (event.status === 'running') running += 1
+      else if (event.status === 'error') error += 1
+      else done += 1
+    }
+    return { total: toolEvents.length, running, done, error }
+  }, [toolEvents])
+
+  const spotlightEvent = useMemo(() => {
+    for (let i = toolEvents.length - 1; i >= 0; i--) {
+      if (toolEvents[i].status === 'running') return toolEvents[i]
+    }
+    return toolEvents[toolEvents.length - 1] || null
+  }, [toolEvents])
+
+  const secondaryEvents = useMemo(() => {
+    if (!spotlightEvent) return []
+    return toolEvents
+      .filter((event) => event.id !== spotlightEvent.id)
+      .slice(-2)
+      .reverse()
+  }, [spotlightEvent, toolEvents])
 
-  // When collapsed, collect deduplicated media from all tool events so files remain visible
   const collapsedMedia = useMemo(() => {
-    if (!shouldCollapse || expanded) return null
+    if (expanded) return null
     const seen = new Set<string>()
     const images: string[] = []
     const videos: string[] = []
@@ -23,41 +137,97 @@ function ToolEventsSection({ toolEvents }: { toolEvents: ToolEvent[] }) {
     const files: { name: string; url: string }[] = []
     for (const ev of toolEvents) {
       if (!ev.output) continue
-      const m = extractMedia(ev.output)
-      for (const url of m.images) { if (!seen.has(url)) { seen.add(url); images.push(url) } }
-      for (const url of m.videos) { if (!seen.has(url)) { seen.add(url); videos.push(url) } }
-      for (const p of m.pdfs) { if (!seen.has(p.url)) { seen.add(p.url); pdfs.push(p) } }
-      for (const f of m.files) { if (!seen.has(f.url)) { seen.add(f.url); files.push(f) } }
+      const media = extractMedia(ev.output)
+      for (const url of media.images) { if (!seen.has(url)) { seen.add(url); images.push(url) } }
+      for (const url of media.videos) { if (!seen.has(url)) { seen.add(url); videos.push(url) } }
+      for (const pdf of media.pdfs) { if (!seen.has(pdf.url)) { seen.add(pdf.url); pdfs.push(pdf) } }
+      for (const file of media.files) { if (!seen.has(file.url)) { seen.add(file.url); files.push(file) } }
     }
     if (!images.length && !videos.length && !pdfs.length && !files.length) return null
     return { images, videos, pdfs, files }
-  }, [toolEvents, shouldCollapse, expanded])
-
-  if (shouldCollapse && !expanded) {
-    return (
-      <div className="max-w-[85%] md:max-w-[72%] flex flex-col gap-2 mb-2">
-        <button
-          type="button"
-          onClick={() => setExpanded(true)}
-          className="self-start flex items-center gap-2 px-3 py-1.5 rounded-[8px] bg-white/[0.04] hover:bg-white/[0.07] border border-white/[0.06] cursor-pointer transition-colors"
-        >
-          <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" className="text-text-3/60">
-            <polyline points="6 9 12 15 18 9" />
-          </svg>
-          <span className="text-[11px] text-text-3 font-mono">
-            {toolEvents.length} tool calls
-          </span>
-          <span className="text-[10px] text-text-3/50">
-            latest: {latestTool?.name || 'unknown'}
-          </span>
-        </button>
+  }, [expanded, toolEvents])
+
+  return (
+    <div className="max-w-[85%] md:max-w-[72%] mb-2" data-testid="tool-activity">
+      <div className="rounded-[16px] border border-white/[0.08] bg-surface/72 backdrop-blur-sm overflow-hidden">
+        <div className="px-4 py-3.5">
+          <div className="flex flex-wrap items-start gap-3 justify-between">
+            <div>
+              <div className="text-[11px] font-600 uppercase tracking-[0.08em] text-text-3/55">
+                Tool Activity
+              </div>
+              <div className="mt-1 text-[13px] text-text-2">
+                {summary.total} call{summary.total === 1 ? '' : 's'} in this response
+              </div>
+            </div>
+            <div className="flex flex-wrap items-center gap-1.5">
+              {summary.running > 0 && (
+                <span className="rounded-full border border-amber-500/25 bg-amber-500/10 px-2 py-0.5 text-[10px] font-600 uppercase tracking-[0.08em] text-amber-300">
+                  {summary.running} running
+                </span>
+              )}
+              {summary.done > 0 && (
+                <span className="rounded-full border border-emerald-500/25 bg-emerald-500/10 px-2 py-0.5 text-[10px] font-600 uppercase tracking-[0.08em] text-emerald-300">
+                  {summary.done} done
+                </span>
+              )}
+              {summary.error > 0 && (
+                <span className="rounded-full border border-rose-500/25 bg-rose-500/10 px-2 py-0.5 text-[10px] font-600 uppercase tracking-[0.08em] text-rose-300">
+                  {summary.error} failed
+                </span>
+              )}
+            </div>
+          </div>
+
+          {spotlightEvent && (
+            <div className="mt-3">
+              <ToolSummaryRow
+                event={spotlightEvent}
+                caption={spotlightEvent.status === 'running' ? 'Current step' : 'Latest step'}
+              />
+            </div>
+          )}
+
+          {secondaryEvents.length > 0 && (
+            <div className="mt-2 flex flex-col gap-2">
+              {secondaryEvents.map((event) => (
+                <ToolSummaryRow key={`summary-${event.id}`} event={event} caption="Recent step" />
+              ))}
+            </div>
+          )}
+
+          <div className="mt-3 flex flex-wrap items-center gap-2">
+            <button
+              type="button"
+              onClick={() => setExpanded((value) => !value)}
+              data-testid="tool-activity-toggle"
+              className="inline-flex items-center gap-2 rounded-[10px] border border-white/[0.08] bg-white/[0.03] px-3 py-1.5 text-[11px] font-600 text-text-2 hover:bg-white/[0.06] cursor-pointer transition-colors"
+            >
+              <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" className={`transition-transform ${expanded ? 'rotate-180' : ''}`}>
+                <polyline points="6 9 12 15 18 9" />
+              </svg>
+              {expanded ? 'Hide call details' : `View ${summary.total === 1 ? 'call' : `${summary.total} calls`} details`}
+            </button>
+            {summary.running > 0 && (
+              <span className="text-[11px] text-text-3/55">
+                Updates stream here without reflowing the whole thread
+              </span>
+            )}
+          </div>
+        </div>
+
         {collapsedMedia && (
-          <>
+          <div className="px-4 pb-4 flex flex-col gap-2">
             {collapsedMedia.images.map((src, i) => (
               // eslint-disable-next-line @next/next/no-img-element
-              <img key={`ci-${i}`} src={src} alt={`Screenshot ${i + 1}`} loading="lazy"
+              <img
+                key={`ci-${i}`}
+                src={src}
+                alt={`Screenshot ${i + 1}`}
+                loading="lazy"
                 className="max-w-[400px] rounded-[10px] border border-white/10"
-                onError={(e) => { (e.target as HTMLImageElement).style.display = 'none' }} />
+                onError={(e) => { (e.target as HTMLImageElement).style.display = 'none' }}
+              />
             ))}
             {collapsedMedia.videos.map((src, i) => (
               <video key={`cv-${i}`} src={src} controls playsInline preload="none" className="max-w-full rounded-[10px] border border-white/10" />
@@ -76,29 +246,20 @@ function ToolEventsSection({ toolEvents }: { toolEvents: ToolEvent[] }) {
                 {file.name}
               </a>
             ))}
-          </>
+          </div>
         )}
-      </div>
-    )
-  }
 
-  return (
-    <div className="max-w-[85%] md:max-w-[72%] flex flex-col gap-2 mb-2">
-      {shouldCollapse && (
-        <button
-          type="button"
-          onClick={() => setExpanded(false)}
-          className="self-start px-2.5 py-1 rounded-[8px] bg-white/[0.04] hover:bg-white/[0.07] text-[11px] text-text-3 border border-white/[0.06] cursor-pointer transition-colors"
-        >
-          Collapse tool calls
-        </button>
-      )}
-      {toolEvents.map((event) => (
-        <ToolCallBubble key={event.id} event={event} />
-      ))}
+        {expanded && (
+          <div className="border-t border-white/[0.06] px-3.5 pb-3 pt-3 flex flex-col gap-2">
+            {toolEvents.map((event) => (
+              <ToolCallBubble key={event.id} event={event} />
+            ))}
+          </div>
+        )}
+      </div>
     </div>
   )
-}
+})
 
 interface Props {
   text: string
@@ -108,17 +269,15 @@ interface Props {
   agentName?: string
 }
 
-export function StreamingBubble({ text, assistantName, agentAvatarSeed, agentAvatarUrl, agentName }: Props) {
+export const StreamingBubble = memo(function StreamingBubble({ text, assistantName, agentAvatarSeed, agentAvatarUrl, agentName }: Props) {
   const toolEvents = useChatStore((s) => s.toolEvents)
   const streamPhase = useChatStore((s) => s.streamPhase)
   const streamToolName = useChatStore((s) => s.streamToolName)
   const thinkingText = useChatStore((s) => s.thinkingText)
   const wide = useMemo(() => isStructuredMarkdown(text), [text])
 
-  // Track which activity moments have been dismissed
   const [dismissedIds, setDismissedIds] = useState<Set<string>>(new Set())
 
-  // Find the latest completed notable tool event that hasn't been dismissed
   let currentMoment: { id: string; name: string; input: string } | null = null
   for (let i = toolEvents.length - 1; i >= 0; i--) {
     const event = toolEvents[i]
@@ -156,7 +315,6 @@ export function StreamingBubble({ text, assistantName, agentAvatarSeed, agentAva
         )}
       </div>
 
-      {/* Collapsed thinking section (shown when text has started but thinking exists) */}
       {text && thinkingText && (
         <div className="max-w-[85%] md:max-w-[72%] mb-2">
           <details className="group rounded-[12px] border border-purple-500/15 bg-purple-500/[0.04]">
@@ -176,7 +334,6 @@ export function StreamingBubble({ text, assistantName, agentAvatarSeed, agentAva
         </div>
       )}
 
-      {/* Tool call events (collapsible when > 2) */}
       {toolEvents.length > 0 && (
         <ToolEventsSection toolEvents={toolEvents} />
       )}
@@ -190,4 +347,4 @@ export function StreamingBubble({ text, assistantName, agentAvatarSeed, agentAva
       )}
     </div>
   )
-}
+})

package/src/components/chat/swarm-panel.test.ts

@@ -0,0 +1,274 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+import { parseSwarmOutput, parseSwarmStatusOutput } from './swarm-panel'
+
+describe('parseSwarmOutput', () => {
+  it('returns null for non-spawn_subagent tools', () => {
+    assert.equal(parseSwarmOutput('execute_command', '{}'), null)
+    assert.equal(parseSwarmOutput('delegate_to_agent', '{}'), null)
+  })
+
+  it('returns null for invalid JSON', () => {
+    assert.equal(parseSwarmOutput('spawn_subagent', 'not json'), null)
+  })
+
+  it('returns null for unrecognized output shapes', () => {
+    assert.equal(parseSwarmOutput('spawn_subagent', '{"foo":"bar"}'), null)
+  })
+
+  it('parses batch running output', () => {
+    const output = JSON.stringify({
+      action: 'batch',
+      status: 'running',
+      jobIds: ['job-1', 'job-2', 'job-3'],
+      taskCount: 3,
+    })
+
+    const result = parseSwarmOutput('spawn_subagent', output)
+    assert.ok(result)
+    assert.equal(result.kind, 'batch')
+    assert.equal(result.status, 'running')
+    assert.equal(result.agents.length, 3)
+    assert.deepEqual(result.jobIds, ['job-1', 'job-2', 'job-3'])
+    assert.equal(result.agents[0].status, 'running')
+    assert.equal(result.agents[0].agentName, 'Agent 1')
+  })
+
+  it('parses batch completed output', () => {
+    const output = JSON.stringify({
+      action: 'batch',
+      status: 'completed',
+      jobIds: ['job-1', 'job-2'],
+      completed: 1,
+      failed: 1,
+      cancelled: 0,
+      timedOut: 0,
+      totalDurationMs: 5000,
+      results: [
+        { jobId: 'job-1', agentName: 'Research Agent', status: 'completed', response: 'Found results' },
+        { jobId: 'job-2', agentName: 'Code Agent', status: 'failed', error: 'Compilation error' },
+      ],
+    })
+
+    const result = parseSwarmOutput('spawn_subagent', output)
+    assert.ok(result)
+    assert.equal(result.kind, 'batch')
+    assert.equal(result.status, 'partial') // has failures
+    assert.equal(result.agents.length, 2)
+    assert.equal(result.completed, 1)
+    assert.equal(result.failed, 1)
+    assert.equal(result.totalDurationMs, 5000)
+
+    assert.equal(result.agents[0].agentName, 'Research Agent')
+    assert.equal(result.agents[0].status, 'completed')
+    assert.equal(result.agents[0].response, 'Found results')
+
+    assert.equal(result.agents[1].agentName, 'Code Agent')
+    assert.equal(result.agents[1].status, 'failed')
+    assert.equal(result.agents[1].error, 'Compilation error')
+  })
+
+  it('parses batch completed all-success output', () => {
+    const output = JSON.stringify({
+      action: 'batch',
+      status: 'completed',
+      jobIds: ['job-1'],
+      completed: 1,
+      failed: 0,
+      cancelled: 0,
+      timedOut: 0,
+      totalDurationMs: 2000,
+      results: [
+        { jobId: 'job-1', agentName: 'Solo Agent', status: 'completed', response: 'Done' },
+      ],
+    })
+
+    const result = parseSwarmOutput('spawn_subagent', output)
+    assert.ok(result)
+    assert.equal(result.status, 'completed') // no failures
+  })
+
+  it('parses single spawn running output', () => {
+    const output = JSON.stringify({
+      jobId: 'job-abc',
+      status: 'running',
+      agentId: 'research-agent',
+      agentName: 'Research Agent',
+      sessionId: 'sess-123',
+      lineageId: 'lin-456',
+      lifecycleState: 'running',
+    })
+
+    const result = parseSwarmOutput('spawn_subagent', output)
+    assert.ok(result)
+    assert.equal(result.kind, 'single')
+    assert.equal(result.status, 'running')
+    assert.equal(result.agents.length, 1)
+    assert.equal(result.agents[0].agentName, 'Research Agent')
+    assert.equal(result.agents[0].status, 'running')
+    assert.equal(result.agents[0].lineageId, 'lin-456')
+  })
+
+  it('parses single spawn completed output', () => {
+    const output = JSON.stringify({
+      jobId: 'job-xyz',
+      status: 'completed',
+      agentId: 'code-agent',
+      agentName: 'Code Agent',
+      sessionId: 'sess-789',
+      lineageId: 'lin-012',
+      response: 'All tests passing',
+      depth: 1,
+      childCount: 0,
+      durationMs: 15000,
+      stateHistory: [],
+    })
+
+    const result = parseSwarmOutput('spawn_subagent', output)
+    assert.ok(result)
+    assert.equal(result.kind, 'single')
+    assert.equal(result.status, 'completed')
+    assert.equal(result.agents[0].agentName, 'Code Agent')
+    assert.equal(result.agents[0].response, 'All tests passing')
+    assert.equal(result.agents[0].durationMs, 15000)
+    assert.equal(result.completed, 1)
+    assert.equal(result.totalDurationMs, 15000)
+  })
+
+  it('parses single spawn failed output', () => {
+    const output = JSON.stringify({
+      jobId: 'job-fail',
+      status: 'failed',
+      agentId: 'bad-agent',
+      agentName: 'Bad Agent',
+      sessionId: 'sess-bad',
+      error: 'Connection timeout',
+    })
+
+    const result = parseSwarmOutput('spawn_subagent', output)
+    assert.ok(result)
+    assert.equal(result.kind, 'single')
+    assert.equal(result.status, 'failed')
+    assert.equal(result.agents[0].error, 'Connection timeout')
+    assert.equal(result.failed, 1)
+  })
+
+  it('parses swarm completed output with snapshot', () => {
+    const output = JSON.stringify({
+      action: 'swarm',
+      status: 'completed',
+      swarmId: 'swarm-1',
+      snapshot: {
+        swarmId: 'swarm-1',
+        parentSessionId: 'parent-1',
+        status: 'completed',
+        createdAt: 1000,
+        completedAt: 5000,
+        memberCount: 2,
+        completedCount: 2,
+        failedCount: 0,
+        members: [
+          { index: 0, agentId: 'a1', agentName: 'Agent A', jobId: 'j1', sessionId: 's1', task: 'Do X', status: 'completed', resultPreview: 'Done X', error: null, durationMs: 2000 },
+          { index: 1, agentId: 'a2', agentName: 'Agent B', jobId: 'j2', sessionId: 's2', task: 'Do Y', status: 'completed', resultPreview: 'Done Y', error: null, durationMs: 3000 },
+        ],
+      },
+    })
+
+    const result = parseSwarmOutput('spawn_subagent', output)
+    assert.ok(result)
+    assert.equal(result.kind, 'batch')
+    assert.equal(result.status, 'completed')
+    assert.equal(result.agents.length, 2)
+    assert.equal(result.agents[0].agentName, 'Agent A')
+    assert.equal(result.agents[0].response, 'Done X')
+    assert.equal(result.agents[1].agentName, 'Agent B')
+    assert.equal(result.completed, 2)
+    assert.equal(result.failed, 0)
+  })
+
+  it('parses swarm running output without snapshot', () => {
+    const output = JSON.stringify({
+      action: 'swarm',
+      status: 'running',
+      swarmId: 'swarm-2',
+      memberCount: 3,
+    })
+
+    const result = parseSwarmOutput('spawn_subagent', output)
+    assert.ok(result)
+    assert.equal(result.kind, 'batch')
+    assert.equal(result.status, 'running')
+    assert.equal(result.agents.length, 3)
+    assert.equal(result.agents[0].status, 'running')
+  })
+
+  it('parses swarm with spawn errors as failed', () => {
+    const output = JSON.stringify({
+      action: 'swarm',
+      status: 'partial',
+      swarmId: 'swarm-3',
+      snapshot: {
+        swarmId: 'swarm-3',
+        status: 'partial',
+        memberCount: 2,
+        completedCount: 1,
+        failedCount: 1,
+        members: [
+          { index: 0, agentId: 'a1', agentName: 'OK Agent', status: 'completed', resultPreview: 'Done', error: null, durationMs: 1000 },
+          { index: 1, agentId: '', agentName: '', status: 'spawn_error', resultPreview: null, error: 'Agent not found', durationMs: 0 },
+        ],
+      },
+    })
+
+    const result = parseSwarmOutput('spawn_subagent', output)
+    assert.ok(result)
+    assert.equal(result.status, 'partial')
+    assert.equal(result.agents[1].status, 'failed') // spawn_error mapped to failed
+    assert.equal(result.agents[1].error, 'Agent not found')
+  })
+})
+
+describe('parseSwarmStatusOutput', () => {
+  it('returns null for non-swarm output', () => {
+    assert.equal(parseSwarmStatusOutput('spawn_subagent', JSON.stringify({ action: 'batch', results: [] })), null)
+    assert.equal(parseSwarmStatusOutput('other_tool', '{}'), null)
+    assert.equal(parseSwarmStatusOutput('spawn_subagent', 'invalid'), null)
+  })
+
+  it('returns null when no snapshot is present', () => {
+    assert.equal(parseSwarmStatusOutput('spawn_subagent', JSON.stringify({ action: 'swarm', status: 'running' })), null)
+  })
+
+  it('parses swarm output into SwarmStatusData', () => {
+    const output = JSON.stringify({
+      action: 'swarm',
+      swarmId: 'swarm-rich',
+      snapshot: {
+        swarmId: 'swarm-rich',
+        parentSessionId: 'parent-1',
+        status: 'completed',
+        createdAt: 1000,
+        completedAt: 5000,
+        memberCount: 2,
+        completedCount: 2,
+        failedCount: 0,
+        members: [
+          { index: 0, agentId: 'researcher', agentName: 'Researcher', jobId: 'j1', sessionId: 's1', task: 'Research APIs', status: 'completed', resultPreview: 'Found 3 APIs', error: null, durationMs: 2500 },
+          { index: 1, agentId: 'coder', agentName: 'Coder', jobId: 'j2', sessionId: 's2', task: 'Write code', status: 'completed', resultPreview: 'Module ready', error: null, durationMs: 4000 },
+        ],
+      },
+    })
+
+    const result = parseSwarmStatusOutput('spawn_subagent', output)
+    assert.ok(result)
+    assert.equal(result.swarmId, 'swarm-rich')
+    assert.equal(result.status, 'completed')
+    assert.equal(result.memberCount, 2)
+    assert.equal(result.completedCount, 2)
+    assert.equal(result.members.length, 2)
+    assert.equal(result.members[0].agentName, 'Researcher')
+    assert.equal(result.members[0].task, 'Research APIs')
+    assert.equal(result.members[1].resultPreview, 'Module ready')
+    assert.equal(result.parentAgentName, 'Orchestrator')
+  })
+})