@pheem49/mint 1.15.0 → 1.17.0

package/src/renderer/shared/components/activity/McpToolResults.tsx

@@ -0,0 +1,118 @@
+import { memo, useEffect, useMemo, useRef, useState } from 'react'
+import { Info, X } from 'lucide-react'
+import type { AgentProgress, McpArtifact } from '../../types'
+import { mediaPlatform } from '../../platform'
+import '../../css/mcp-results.css'
+
+function Artifact({ artifact, chatId }: { artifact: McpArtifact; chatId?: string }) {
+  const [src, setSrc] = useState('')
+  const [error, setError] = useState('')
+  const dialog = useRef<HTMLDialogElement>(null)
+  useEffect(() => {
+    if (artifact.kind === 'link') return
+    let active = true
+    let loaded = ''
+    mediaPlatform.readMcpArtifact(artifact.id, chatId).then(url => {
+      if (!active) { if (url.startsWith('blob:')) URL.revokeObjectURL(url); return }
+      loaded = url; setSrc(url)
+    }).catch(() => { if (active) setError('Attachment unavailable') })
+    return () => { active = false; if (loaded.startsWith('blob:')) URL.revokeObjectURL(loaded) }
+  }, [artifact.id, artifact.kind, chatId])
+  if (artifact.kind === 'link') {
+    // Custom resource URIs are copied as text; only web URLs are navigable.
+    return /^https?:\/\//i.test(artifact.uri || '')
+      ? <a href={artifact.uri} target="_blank" rel="noreferrer">{artifact.name}</a>
+      : <span>{artifact.name}: {artifact.uri}</span>
+  }
+  return <div className="mcp-artifact">
+    {artifact.kind === 'image' && src && <>
+      <button type="button" className="mcp-image-button" onClick={() => dialog.current?.showModal()} aria-label={`View ${artifact.name}`}>
+        <img src={src} alt={artifact.name} onError={() => setError('Image unavailable')} />
+      </button>
+      <dialog ref={dialog} className="mcp-image-dialog" aria-label={artifact.name}
+        onClose={() => dialog.current?.close()} onClick={event => { if (event.target === event.currentTarget) dialog.current?.close() }}>
+        <header>
+          <span title={artifact.name}>{artifact.name}</span>
+          <button type="button" aria-label="Close" onClick={() => dialog.current?.close()}><X size={18} /></button>
+        </header>
+        <img src={src} alt={artifact.name} />
+      </dialog>
+    </>}
+    {src ? <a href={src} download={artifact.name}>{artifact.name} · {(artifact.size / 1024).toFixed(1)} KB</a> : <span>{artifact.name} · {error || 'Loading attachment…'}</span>}
+    {artifact.metadata?.url && <span title={artifact.metadata.url}>{artifact.metadata.url}</span>}
+    {!!artifact.metadata?.width && !!artifact.metadata?.height && <span>{artifact.metadata.width} × {artifact.metadata.height}</span>}
+    {artifact.metadata?.capturedAt && <time dateTime={artifact.metadata.capturedAt}>{artifact.metadata.capturedAt}</time>}
+    {error && src && <span role="status">{error}</span>}
+  </div>
+}
+
+export default memo(function McpToolResults({ progress, running = false, interrupted = false, chatId }: { progress: AgentProgress[]; running?: boolean; interrupted?: boolean; chatId?: string }) {
+  const [, tick] = useState(0)
+  const started = useRef(new Map<string, number>())
+  const { calls, discovery, artifacts, warnings } = useMemo(() => {
+    const calls = new Map<string, { label: string; update?: Extract<AgentProgress, { type: 'ToolProgress' }>['data']['update']; status?: string; device?: Extract<AgentProgress,{type:'DeviceState'}>['data']['update'] }>()
+    const discovery=new Map<string,string>()
+    const artifacts = new Map<string, McpArtifact>()
+    const warnings = new Set<string>()
+    for (const event of progress) {
+      if (event.type === 'ToolStart' && event.data.action === 'mcp_tool' && event.data.callId) {
+        const id = event.data.callId
+        if (!started.current.has(id)) started.current.set(id, Date.now())
+        calls.set(id, { label: `${event.data.input.server}/${event.data.input.tool}` })
+      } else if (event.type === 'ToolDiscovery') {
+        discovery.set(`${event.data.server}/${event.data.tool}`,event.data.message)
+      } else if (event.type === 'DeviceState') {
+        const {callId,server,tool,update}=event.data
+        calls.set(callId,{...calls.get(callId),label:`${server}/${tool}`,device:update})
+      } else if (event.type === 'ToolProgress') {
+        const { callId, server, tool, update } = event.data
+        calls.set(callId, { ...calls.get(callId), label: `${server}/${tool}`, update })
+      } else if (event.type === 'ToolEnd' && event.data.callId && event.data.action === 'mcp_tool') {
+        const previous = calls.get(event.data.callId)
+        calls.set(event.data.callId, { label: previous?.label || `${event.data.input.server}/${event.data.input.tool}`, ...previous, status: event.data.status || (/^(Error:|Blocked|User denied)/.test(event.data.result) ? 'failed' : 'success') })
+      } else if (event.type === 'ToolArtifacts') {
+        for (const artifact of event.data.artifacts) artifacts.set(artifact.id, artifact)
+        for (const warning of event.data.warnings) warnings.add(warning)
+      }
+    }
+    return { calls, discovery, artifacts, warnings }
+  }, [progress])
+  const displayedArtifacts = useMemo(() => {
+    return [...artifacts.values()].filter(artifact => artifact.server !== 'view_image')
+  }, [artifacts])
+  const hasActiveCalls = running && [...calls.values()].some(call => !call.status)
+  useEffect(() => {
+    if (!hasActiveCalls) return
+    const timer = setInterval(() => tick(n => n + 1), 1000)
+    return () => clearInterval(timer)
+  }, [hasActiveCalls])
+  if (!calls.size && !displayedArtifacts.length && !warnings.size && !discovery.size) return null
+  const isOnlyWarnings = !calls.size && !displayedArtifacts.length && !discovery.size && warnings.size > 0
+  return <section className={`mcp-results${isOnlyWarnings ? ' mcp-results-compact' : ''}`} aria-label="MCP results">
+    {[...discovery].map(([label,message])=><div key={label} className="mcp-call-status" role="status"><strong>{label}</strong><span>{message}</span></div>)}
+    {[...calls].map(([id, call]) => {
+      const active = running && !call.status
+      const elapsed = Math.max(call.update?.elapsedSecs || 0, Math.floor((Date.now() - (started.current.get(id) || Date.now())) / 1000))
+      const percent = call.update?.total ? Math.min(100, Math.round(call.update.progress / call.update.total * 100)) : undefined
+      const deviceLabel=call.device && (active && !interrupted || ['verified','failed','unconfirmed'].includes(call.device.state)) ? ({accepted:'Command accepted; awaiting device confirmation',running:'Awaiting device completion',verified:'Device completion verified',failed:'Device reported failure',unconfirmed:'Device completion unconfirmed'}[call.device.state]) : undefined
+      const status = call.status === 'cancelled' || (!call.status && interrupted) ? 'Stopped waiting; remote work may still be running.'
+        : call.status === 'timed_out' ? 'Timed out; remote completion is unconfirmed.'
+        : call.status === 'skipped' ? 'Skipped'
+        : call.status === 'failed' ? 'Failed' : call.status === 'success' ? 'Completed' : active ? `Working · ${elapsed}s` : 'Interrupted; result unconfirmed'
+      return <div key={id} className="mcp-call-status" role="status">
+        <strong>{call.label}</strong><span>{deviceLabel || status}</span>
+        {call.device && <><span>{call.device.message}</span><span>Target: {JSON.stringify(call.device.target)} · Actual: {JSON.stringify(call.device.actual)}</span></>}
+        {active && call.update?.message && <span>{call.update.message}</span>}
+        {active && percent !== undefined && <progress max={100} value={percent} aria-label={`${call.label} progress`}>{percent}%</progress>}
+      </div>
+    })}
+    {displayedArtifacts.length > 0 && <div className="mcp-artifacts">{displayedArtifacts.map(artifact => <Artifact key={artifact.id} artifact={artifact} chatId={chatId} />)}</div>}
+    {[...warnings].map(warning => (
+      <div key={warning} className="mcp-warning-banner" role="status">
+        <Info size={14} className="mcp-warning-icon" aria-hidden="true" />
+        <span className="mcp-warning-text">{warning}</span>
+      </div>
+    ))}
+  </section>
+})
+

package/src/renderer/shared/components/activity/PlanChecklistWidget.tsx

@@ -0,0 +1,77 @@
+import React from 'react'
+import type { ActivePlan } from '../../types'
+import { CheckCircle2, Circle, Loader2, XCircle, ListTodo } from 'lucide-react'
+
+interface PlanChecklistWidgetProps {
+  plan: ActivePlan
+  className?: string
+}
+
+export function PlanChecklistWidget({ plan, className = '' }: PlanChecklistWidgetProps) {
+  if (!plan || !plan.tasks || plan.tasks.length === 0) {
+    return null
+  }
+
+  const completedCount = plan.tasks.filter((t) => t.status === 'completed').length
+  const totalCount = plan.tasks.length
+  const percent = Math.round((completedCount / totalCount) * 100)
+
+  return (
+    <div className={`plan-checklist-card ${className}`}>
+      <div className="plan-checklist-header">
+        <div className="plan-checklist-title">
+          <ListTodo style={{ width: '15px', height: '15px', color: 'var(--interactive-fg)' }} />
+          <span>{plan.objective || 'Task Plan'}</span>
+        </div>
+        <span className="plan-checklist-count">
+          {completedCount}/{totalCount} ({percent}%)
+        </span>
+      </div>
+
+      {/* Progress Bar */}
+      <div className="plan-progress-track">
+        <div className="plan-progress-bar" style={{ width: `${percent}%` }} />
+      </div>
+
+      {/* Tasks List */}
+      <div className="plan-tasks-list">
+        {plan.tasks.map((task, idx) => {
+          const isDone = task.status === 'completed'
+          const isRunning = task.status === 'in_progress'
+          const isFailed = task.status === 'failed'
+
+          const stateClass = isRunning
+            ? 'in-progress'
+            : isDone
+              ? 'completed'
+              : isFailed
+                ? 'failed'
+                : ''
+
+          return (
+            <div key={task.id || idx} className={`plan-task-item ${stateClass}`}>
+              <span style={{ display: 'inline-flex', alignItems: 'center', flexShrink: 0 }}>
+                {isDone && <CheckCircle2 style={{ width: '14px', height: '14px', color: 'var(--status-speaking, #22c55e)' }} />}
+                {isRunning && (
+                  <Loader2
+                    style={{
+                      width: '14px',
+                      height: '14px',
+                      color: 'var(--status-listening, #7dd3fc)',
+                      animation: 'spin 1s linear infinite',
+                    }}
+                  />
+                )}
+                {isFailed && <XCircle style={{ width: '14px', height: '14px', color: 'var(--status-error, #ef4444)' }} />}
+                {!isDone && !isRunning && !isFailed && (
+                  <Circle style={{ width: '14px', height: '14px', color: 'var(--text-muted)' }} />
+                )}
+              </span>
+              <span className="plan-task-text">{task.title}</span>
+            </div>
+          )
+        })}
+      </div>
+    </div>
+  )
+}

package/src/renderer/shared/components/activity/RunSummaryDashboard.test.tsx

@@ -0,0 +1,127 @@
+import { describe, it, expect } from 'vitest'
+// @ts-ignore react-dom/server lacks types without @types/react-dom
+import { renderToStaticMarkup } from 'react-dom/server'
+import React from 'react'
+import { RunSummaryDashboard, formatRunDuration } from './RunSummaryDashboard'
+import type { RunTelemetrySummary } from '../../types'
+
+describe('RunSummaryDashboard and formatRunDuration', () => {
+  it('formats duration correctly under 60 seconds', () => {
+    expect(formatRunDuration(14.5)).toEqual({ value: '14.5s' })
+    expect(formatRunDuration(0.8)).toEqual({ value: '0.8s' })
+  })
+
+  it('formats duration into minutes and seconds when >= 60 seconds', () => {
+    const formatted = formatRunDuration(81.8)
+    expect(formatted.value).toBe('1m 21.8s')
+    expect(formatted.subtext).toBe('81.8s')
+
+    const formatted60 = formatRunDuration(60.0)
+    expect(formatted60.value).toBe('1m 00.0s')
+    expect(formatted60.subtext).toBe('60.0s')
+  })
+
+  it('formats duration with hours when >= 3600 seconds', () => {
+    const formatted = formatRunDuration(3665)
+    expect(formatted.value).toBe('1h 1m')
+    expect(formatted.subtext).toBe('3665.0s')
+  })
+
+  it('renders Duration with minute breakdown and raw seconds in subtext', () => {
+    const mockSummary: RunTelemetrySummary = {
+      runId: 'test-run-123',
+      task: 'test-task',
+      outcome: 'SUCCESS',
+      durationSecs: 81.8,
+      totalTokens: 12500,
+      toolCallsCount: 5,
+      retriesCount: 1,
+      filesChanged: ['a.txt', 'b.txt'],
+      filesCreated: ['b.txt'],
+      toolTimeline: [],
+    }
+
+    const html = renderToStaticMarkup(<RunSummaryDashboard summary={mockSummary} />)
+
+    expect(html).toContain('Run summary')
+    expect(html).toContain('1m 21.8s')
+    expect(html).toContain('· 81.8s')
+    expect(html).toContain('12.5k')
+    expect(html).toContain('Success')
+    expect(html).not.toContain('Tool call timeline')
+  })
+
+  it('renders Completed badge with success class for PARTIAL outcome', () => {
+    const summary: RunTelemetrySummary = {
+      runId: 'r3',
+      task: 'casual chat',
+      outcome: 'PARTIAL',
+      durationSecs: 2.1,
+      totalTokens: 1200,
+      toolCallsCount: 0,
+      retriesCount: 0,
+      filesChanged: [],
+      filesCreated: [],
+      toolTimeline: [],
+    }
+    const html = renderToStaticMarkup(<RunSummaryDashboard summary={summary} />)
+    expect(html).toContain('run-summary-badge success')
+    expect(html).toContain('Completed')
+    expect(html).not.toContain('Failure')
+  })
+
+  it('renders Verified badge with success class for VERIFIED outcome', () => {
+    const summary: RunTelemetrySummary = {
+      runId: 'r4',
+      task: 'verified task',
+      outcome: 'VERIFIED',
+      durationSecs: 15.0,
+      totalTokens: 5000,
+      toolCallsCount: 2,
+      retriesCount: 0,
+      filesChanged: [],
+      filesCreated: [],
+      toolTimeline: [],
+    }
+    const html = renderToStaticMarkup(<RunSummaryDashboard summary={summary} />)
+    expect(html).toContain('run-summary-badge success')
+    expect(html).toContain('Verified')
+  })
+
+  it('renders Failure badge with failure class for FAILED outcome', () => {
+    const summary: RunTelemetrySummary = {
+      runId: 'r5',
+      task: 'failed task',
+      outcome: 'FAILED',
+      durationSecs: 5.0,
+      totalTokens: 2000,
+      toolCallsCount: 1,
+      retriesCount: 0,
+      filesChanged: [],
+      filesCreated: [],
+      toolTimeline: [],
+    }
+    const html = renderToStaticMarkup(<RunSummaryDashboard summary={summary} />)
+    expect(html).toContain('run-summary-badge failure')
+    expect(html).toContain('Failure')
+  })
+
+  it('renders Export Trajectory action button in header', () => {
+    const summary: RunTelemetrySummary = {
+      runId: 'run-traj-42',
+      task: 'export trajectory test',
+      outcome: 'SUCCESS',
+      durationSecs: 3.2,
+      totalTokens: 1500,
+      toolCallsCount: 2,
+      retriesCount: 0,
+      filesChanged: ['src/app.ts'],
+      filesCreated: [],
+      toolTimeline: [],
+    }
+    const html = renderToStaticMarkup(<RunSummaryDashboard summary={summary} />)
+    expect(html).toContain('run-summary-export-btn')
+    expect(html).toContain('Export Trajectory')
+    expect(html).toContain('title="Export SWE-bench / Agent Protocol compliant trajectory JSON"')
+  })
+})

package/src/renderer/shared/components/activity/RunSummaryDashboard.tsx

@@ -0,0 +1,222 @@
+import React, { useState, useCallback } from 'react'
+import type { RunTelemetrySummary, StandardTrajectoryRun } from '../../types'
+import {
+  CheckCircle2,
+  XCircle,
+  RotateCcw,
+  Clock,
+  Coins,
+  Wrench,
+  FileCode2,
+  Activity,
+  Download,
+  Check,
+} from 'lucide-react'
+
+interface Props {
+  summary: RunTelemetrySummary
+  className?: string
+}
+
+export function formatRunDuration(secs: number): { value: string; subtext?: string } {
+  if (secs < 60) {
+    return { value: `${secs.toFixed(1)}s` }
+  }
+  const mins = Math.floor(secs / 60)
+  const remSecs = secs % 60
+  const remSecsStr = remSecs < 10 ? `0${remSecs.toFixed(1)}` : remSecs.toFixed(1)
+
+  if (mins >= 60) {
+    const hours = Math.floor(mins / 60)
+    const remMins = mins % 60
+    return {
+      value: `${hours}h ${remMins}m`,
+      subtext: `${secs.toFixed(1)}s`,
+    }
+  }
+
+  return {
+    value: `${mins}m ${remSecsStr}s`,
+    subtext: `${secs.toFixed(1)}s`,
+  }
+}
+
+export function RunSummaryDashboard({ summary, className = '' }: Props) {
+  const [exported, setExported] = useState(false)
+
+  const handleExportTrajectory = useCallback(() => {
+    try {
+      const trajectoryData: StandardTrajectoryRun = summary.trajectory || {
+        schemaVersion: '1.0',
+        runId: summary.runId,
+        chatId: 'default',
+        task: summary.task || 'Agent Run',
+        model: 'unknown',
+        provider: 'unknown',
+        startedAt: new Date(Date.now() - summary.durationSecs * 1000).toISOString(),
+        completedAt: new Date().toISOString(),
+        outcome: summary.outcome,
+        totalSteps: summary.toolCallsCount,
+        totalTokens: summary.totalTokens,
+        durationSecs: summary.durationSecs,
+        filesCreated: summary.filesCreated || [],
+        filesModified: (summary.filesChanged || []).filter(
+          (f) => !(summary.filesCreated || []).includes(f)
+        ),
+        trajectory: (summary.toolTimeline || []).map((item, idx) => ({
+          step: item.step || idx + 1,
+          timestamp: new Date().toISOString(),
+          thought: '',
+          action: item.action,
+          input: { target: item.target },
+          observation: item.success ? 'Success' : 'Failed',
+          status: item.success ? 'success' : 'failed',
+          durationMs: 0,
+          tokens: { inputTokens: 0, generatedTokens: 0 },
+        })),
+      }
+
+      const json = JSON.stringify(trajectoryData, null, 2)
+      if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+        const blob = new Blob([json], { type: 'application/json' })
+        const url = URL.createObjectURL(blob)
+        const a = document.createElement('a')
+        a.href = url
+        a.download = `${summary.runId}-trajectory.json`
+        document.body.appendChild(a)
+        a.click()
+        document.body.removeChild(a)
+        URL.revokeObjectURL(url)
+      }
+      if (typeof navigator !== 'undefined' && navigator.clipboard) {
+        navigator.clipboard.writeText(json).catch(() => {})
+      }
+      setExported(true)
+      setTimeout(() => setExported(false), 2000)
+    } catch (e) {
+      console.error('Failed to export trajectory:', e)
+    }
+  }, [summary])
+
+  const isSuccess = summary.outcome === 'SUCCESS' || summary.outcome === 'VERIFIED'
+  const isCompleted = summary.outcome === 'PARTIAL' || summary.outcome === 'COMPLETED'
+  const isRolledBack = summary.outcome === 'ROLLED_BACK'
+  const isUnverified = summary.outcome === 'UNVERIFIED'
+  const isFailed = summary.outcome === 'FAILED'
+
+  const formattedTokens =
+    summary.totalTokens >= 1000
+      ? `${(summary.totalTokens / 1000).toFixed(1)}k`
+      : summary.totalTokens.toString()
+
+  const formattedDuration = formatRunDuration(summary.durationSecs)
+
+  const badgeClass = isSuccess || isCompleted
+    ? 'run-summary-badge success'
+    : isRolledBack || isUnverified
+      ? 'run-summary-badge rollback'
+      : 'run-summary-badge failure'
+
+  const badgeText = isSuccess
+    ? (summary.outcome === 'VERIFIED' ? 'Verified' : 'Success')
+    : isCompleted
+      ? 'Completed'
+      : isRolledBack
+        ? 'Rolled Back'
+        : isUnverified
+          ? 'Unverified'
+          : 'Failure'
+
+  return (
+    <div className={`run-summary-card ${className}`}>
+      {/* Header */}
+      <div className="run-summary-header">
+        <div className="run-summary-title">
+          <Activity size={16} aria-hidden="true" />
+          <span className="run-summary-heading"><strong>Run summary</strong><small title={`Run ${summary.runId}`}>#{summary.runId}</small></span>
+        </div>
+        <div className="run-summary-actions">
+          <button
+            type="button"
+            className="run-summary-export-btn"
+            onClick={handleExportTrajectory}
+            title="Export SWE-bench / Agent Protocol compliant trajectory JSON"
+            aria-label="Export trajectory"
+          >
+            {exported ? (
+              <Check style={{ width: '12px', height: '12px' }} />
+            ) : (
+              <Download style={{ width: '12px', height: '12px' }} />
+            )}
+            <span>{exported ? 'Exported!' : 'Export Trajectory'}</span>
+          </button>
+          <span className={badgeClass}>
+            {(isSuccess || isCompleted) && <CheckCircle2 style={{ width: '12px', height: '12px' }} />}
+            {(isRolledBack || isUnverified) && <RotateCcw style={{ width: '12px', height: '12px' }} />}
+            {(!isSuccess && !isCompleted && !isRolledBack && !isUnverified) && <XCircle style={{ width: '12px', height: '12px' }} />}
+            <span>{badgeText}</span>
+          </span>
+        </div>
+      </div>
+
+      {/* KPI Grid */}
+      <div className="run-kpi-grid">
+        <div className="run-kpi-box">
+          <div className="run-kpi-label">
+            <Clock style={{ width: '12px', height: '12px' }} />
+            <span>Duration</span>
+          </div>
+          <div className="run-kpi-value" title={`${summary.durationSecs.toFixed(1)}s`}>
+            {formattedDuration.value}
+            {formattedDuration.subtext && (
+              <span className="run-kpi-subtext"> · {formattedDuration.subtext}</span>
+            )}
+          </div>
+        </div>
+
+        <div className="run-kpi-box">
+          <div className="run-kpi-label">
+            <Coins style={{ width: '12px', height: '12px' }} />
+            <span>Tokens</span>
+          </div>
+          <div className="run-kpi-value">{formattedTokens}</div>
+        </div>
+
+        <div className="run-kpi-box">
+          <div className="run-kpi-label">
+            <Wrench style={{ width: '12px', height: '12px' }} />
+            <span>Tools</span>
+          </div>
+          <div className="run-kpi-value">
+            {summary.toolCallsCount}
+            {summary.retriesCount > 0 && <span className="run-kpi-subtext"> · {summary.retriesCount} retried</span>}
+          </div>
+        </div>
+
+        <div className="run-kpi-box">
+          <div className="run-kpi-label">
+            <FileCode2 style={{ width: '12px', height: '12px' }} />
+            <span>Files</span>
+          </div>
+          <div className="run-kpi-value">
+            {summary.filesCreated && summary.filesCreated.length > 0 && summary.filesChanged.length - summary.filesCreated.length > 0 ? (
+              <>
+                {summary.filesCreated.length} <span className="run-kpi-subtext">created</span>, {summary.filesChanged.length - summary.filesCreated.length} <span className="run-kpi-subtext">modified</span>
+              </>
+            ) : summary.filesCreated && summary.filesCreated.length > 0 ? (
+              <>
+                {summary.filesCreated.length}{' '}
+                <span className="run-kpi-subtext">created</span>
+              </>
+            ) : summary.filesChanged.length > 0 ? (
+              <>
+                {summary.filesChanged.length}{' '}
+                <span className="run-kpi-subtext">modified</span>
+              </>
+            ) : <>0 <span className="run-kpi-subtext">files</span></>}
+          </div>
+        </div>
+      </div>
+    </div>
+  )
+}

package/src/renderer/shared/components/activity/SubagentDagView.test.ts

@@ -0,0 +1,123 @@
+import { describe, it, expect } from 'vitest'
+import { parseSubagentGraph } from './SubagentDagView'
+import type { AgentProgress } from '../../types'
+
+describe('parseSubagentGraph', () => {
+  it('parses modern swarm lifecycle events (SubagentStarted and SubagentFinished)', () => {
+    const progress: AgentProgress[] = [
+      {
+        type: 'SubagentStarted',
+        data: {
+          subagent: 'stripe-webhook-tracer',
+          profile: 'explorer',
+          task: 'Trace webhook verification flow in routes/webhook.rs',
+        },
+      },
+      {
+        type: 'ToolStart',
+        data: {
+          action: 'read_file',
+          input: { path: 'src/webhook.rs' },
+          subagent: 'stripe-webhook-tracer',
+        },
+      },
+      {
+        type: 'ToolEnd',
+        data: {
+          action: 'read_file',
+          input: { path: 'src/webhook.rs' },
+          result: 'pub fn verify() {}',
+          subagent: 'stripe-webhook-tracer',
+        },
+      },
+      {
+        type: 'SubagentFinished',
+        data: {
+          subagent: 'stripe-webhook-tracer',
+          status: 'completed',
+          elapsed_ms: 1200,
+          steps: 2,
+          summary_preview: 'Found verify function in webhook.rs',
+        },
+      },
+    ]
+
+    const graph = parseSubagentGraph(progress)
+    expect(graph.subagents).toHaveLength(1)
+    const node = graph.subagents[0]
+    expect(node.name).toBe('stripe-webhook-tracer')
+    expect(node.status).toBe('completed')
+    expect(node.tools).toHaveLength(1)
+    expect(node.tools[0].action).toBe('read_file')
+  })
+
+  it('maintains backward compatibility with legacy dispatch_subagent events', () => {
+    const legacyProgress: AgentProgress[] = [
+      {
+        type: 'ToolStart',
+        data: {
+          action: 'dispatch_subagent',
+          input: { name: 'explorer', instruction: 'Search for config files' },
+        },
+      },
+      {
+        type: 'ToolStart',
+        data: {
+          action: 'list_files',
+          input: { path: '.' },
+          subagent: 'explorer',
+        },
+      },
+      {
+        type: 'ToolEnd',
+        data: {
+          action: 'list_files',
+          input: { path: '.' },
+          result: 'Cargo.toml\nREADME.md',
+          subagent: 'explorer',
+        },
+      },
+      {
+        type: 'ToolEnd',
+        data: {
+          action: 'dispatch_subagent',
+          input: { name: 'explorer', instruction: 'Search for config files' },
+          result: '[Subagent explorer result]\nFound Cargo.toml',
+        },
+      },
+    ]
+
+    const graph = parseSubagentGraph(legacyProgress)
+    expect(graph.subagents).toHaveLength(1)
+    const node = graph.subagents[0]
+    expect(node.name).toBe('explorer')
+    expect(node.status).toBe('completed')
+    expect(node.tools).toHaveLength(1)
+  })
+
+  it('marks subagent as failed on error', () => {
+    const progress: AgentProgress[] = [
+      {
+        type: 'SubagentStarted',
+        data: {
+          subagent: 'debugger',
+          profile: 'debugger',
+          task: 'Run failing test',
+        },
+      },
+      {
+        type: 'SubagentFinished',
+        data: {
+          subagent: 'debugger',
+          status: 'failed',
+          elapsed_ms: 500,
+          steps: 1,
+          summary_preview: 'Command exited with 101',
+        },
+      },
+    ]
+
+    const graph = parseSubagentGraph(progress)
+    expect(graph.subagents[0].status).toBe('failed')
+  })
+})