@swarmclawai/swarmclaw 1.7.3 → 1.8.1

package/src/components/runs/run-list.tsx

@@ -5,7 +5,8 @@ import { api } from '@/lib/app/api-client'
 import { useNow } from '@/hooks/use-now'
 import { useWs } from '@/hooks/use-ws'
 import { BottomSheet } from '@/components/shared/bottom-sheet'
-import type { RunEventRecord, SessionRunRecord, SessionRunStatus } from '@/types'
+import { EvidenceShelf } from '@/components/evidence/evidence-shelf'
+import type { EvidenceArtifact, RunBrief, RunEventRecord, SessionRunRecord, SessionRunStatus } from '@/types'
 import { PageLoader } from '@/components/ui/page-loader'
 import { formatElapsed } from '@/lib/format-display'
 import { GroundingPanel } from '@/components/knowledge/grounding-panel'
@@ -41,7 +42,11 @@ export function RunList() {
   const [query, setQuery] = useState('')
   const [selected, setSelected] = useState<SessionRunRecord | null>(null)
   const [selectedEvents, setSelectedEvents] = useState<RunEventRecord[]>([])
+  const [selectedBrief, setSelectedBrief] = useState<RunBrief | null>(null)
+  const [selectedArtifacts, setSelectedArtifacts] = useState<EvidenceArtifact[]>([])
   const [eventsLoading, setEventsLoading] = useState(false)
+  const [briefLoading, setBriefLoading] = useState(false)
+  const [artifactsLoading, setArtifactsLoading] = useState(false)
 
   const fetchRuns = useCallback(async () => {
     try {
@@ -61,29 +66,42 @@ export function RunList() {
   useEffect(() => {
     if (!selected) return
     let cancelled = false
-    api<RunEventRecord[]>('GET', `/runs/${selected.id}/events?limit=200`)
-      .then((events) => {
-        if (cancelled) return
-        setSelectedEvents(Array.isArray(events) ? events : [])
-      })
-      .catch(() => {
-        if (!cancelled) setSelectedEvents([])
-      })
-      .finally(() => {
-        if (!cancelled) setEventsLoading(false)
-      })
+    void Promise.allSettled([
+      api<RunEventRecord[]>('GET', `/runs/${selected.id}/events?limit=200`),
+      api<RunBrief>('GET', `/runs/${selected.id}/brief`),
+      api<EvidenceArtifact[]>('GET', `/artifacts?runId=${encodeURIComponent(selected.id)}`),
+    ]).then(([eventsResult, briefResult, artifactsResult]) => {
+      if (cancelled) return
+      setSelectedEvents(eventsResult.status === 'fulfilled' && Array.isArray(eventsResult.value) ? eventsResult.value : [])
+      setSelectedBrief(briefResult.status === 'fulfilled' ? briefResult.value : null)
+      setSelectedArtifacts(artifactsResult.status === 'fulfilled' && Array.isArray(artifactsResult.value) ? artifactsResult.value : [])
+    }).finally(() => {
+      if (cancelled) return
+      setEventsLoading(false)
+      setBriefLoading(false)
+      setArtifactsLoading(false)
+    })
     return () => { cancelled = true }
   }, [selected])
 
   const closeSelected = useCallback(() => {
     setSelected(null)
     setSelectedEvents([])
+    setSelectedBrief(null)
+    setSelectedArtifacts([])
     setEventsLoading(false)
+    setBriefLoading(false)
+    setArtifactsLoading(false)
   }, [])
 
   const openSelected = useCallback((run: SessionRunRecord) => {
     setSelected(run)
+    setSelectedEvents([])
+    setSelectedBrief(null)
+    setSelectedArtifacts([])
     setEventsLoading(true)
+    setBriefLoading(true)
+    setArtifactsLoading(true)
   }, [])
 
   const sources = useMemo(() => {
@@ -242,6 +260,61 @@ export function RunList() {
               <p className="text-[12px] text-text-3/60 font-mono">{selected.id}</p>
             </div>
 
+            {/* Brief */}
+            <div className="mb-6">
+              <label className="block font-display text-[12px] font-600 text-text-2 uppercase tracking-[0.08em] mb-2">Brief</label>
+              {briefLoading ? (
+                <div className="rounded-[12px] border border-white/[0.04] bg-white/[0.02] p-4 text-[11px] text-text-3/60">
+                  Loading brief...
+                </div>
+              ) : selectedBrief ? (
+                <div className="rounded-[12px] border border-white/[0.05] bg-white/[0.025] p-4">
+                  <div className="text-[13px] font-700 text-text">{selectedBrief.title}</div>
+                  <p className="mt-1 text-[12px] leading-relaxed text-text-3/70">{selectedBrief.objective}</p>
+                  <div className="mt-3 grid gap-2 sm:grid-cols-2">
+                    <div className="rounded-[10px] border border-white/[0.04] bg-white/[0.02] px-3 py-2">
+                      <div className="text-[10px] uppercase tracking-[0.08em] text-text-3/55">Owner</div>
+                      <div className="mt-1 text-[11px] text-text-2">{selectedBrief.owner ? `${selectedBrief.owner.type}:${selectedBrief.owner.id}` : selectedBrief.source}</div>
+                    </div>
+                    <div className="rounded-[10px] border border-white/[0.04] bg-white/[0.02] px-3 py-2">
+                      <div className="text-[10px] uppercase tracking-[0.08em] text-text-3/55">Usage</div>
+                      <div className="mt-1 text-[11px] text-text-2">
+                        {selectedBrief.usage.inputTokens ?? 0} in / {selectedBrief.usage.outputTokens ?? 0} out
+                        {selectedBrief.usage.estimatedCost != null ? ` - $${selectedBrief.usage.estimatedCost.toFixed(4)}` : ''}
+                      </div>
+                    </div>
+                  </div>
+                  {selectedBrief.warnings.length > 0 && (
+                    <div className="mt-3 flex flex-col gap-1.5">
+                      {selectedBrief.warnings.map((warning) => (
+                        <div key={warning} className="rounded-[9px] border border-amber-500/20 bg-amber-500/[0.06] px-3 py-2 text-[11px] text-amber-200">
+                          {warning}
+                        </div>
+                      ))}
+                    </div>
+                  )}
+                  {selectedBrief.timeline.length > 0 && (
+                    <div className="mt-3 flex flex-wrap gap-1.5">
+                      {selectedBrief.timeline.slice(0, 5).map((item, index) => (
+                        <span key={`${item.label}:${item.at}:${index}`} className="rounded-full bg-white/[0.05] px-2 py-1 text-[10px] font-700 text-text-3/80">
+                          {item.label} {new Date(item.at).toLocaleTimeString()}
+                        </span>
+                      ))}
+                    </div>
+                  )}
+                  {selectedBrief.evidence.length > 0 && (
+                    <div className="mt-3 text-[11px] text-text-3/65">
+                      {selectedBrief.evidence.length} brief evidence item{selectedBrief.evidence.length === 1 ? '' : 's'} found.
+                    </div>
+                  )}
+                </div>
+              ) : (
+                <div className="rounded-[12px] border border-white/[0.04] bg-white/[0.02] p-4 text-[11px] text-text-3/60">
+                  No brief available for this run.
+                </div>
+              )}
+            </div>
+
             {/* Timing */}
             <div className="mb-6 space-y-2">
               <label className="block font-display text-[12px] font-600 text-text-2 uppercase tracking-[0.08em]">Timing</label>
@@ -308,6 +381,15 @@ export function RunList() {
               </div>
             )}
 
+            <div className="mb-6">
+              <EvidenceShelf
+                artifacts={selectedArtifacts}
+                loading={artifactsLoading}
+                title="Evidence Shelf"
+                emptyLabel="No linked artifacts, files, reports, or citations for this run."
+              />
+            </div>
+
             <div className="mb-2">
               <label className="block font-display text-[12px] font-600 text-text-2 uppercase tracking-[0.08em] mb-2">Replay</label>
               <div className="rounded-[12px] border border-white/[0.04] bg-white/[0.02] max-h-[260px] overflow-auto">

package/src/lib/connectors/connector-readiness.ts

@@ -0,0 +1,127 @@
+import type { Connector } from '@/types'
+
+export type ConnectorReadinessState = 'needs_setup' | 'attention' | 'healthy'
+export type ConnectorReadinessCheckStatus = 'ready' | 'warning' | 'error'
+
+export interface ConnectorReadinessCheck {
+  id: 'credentials' | 'route' | 'pairing' | 'connection' | 'gateway'
+  label: string
+  status: ConnectorReadinessCheckStatus
+  detail: string
+  actionLabel?: string | null
+  actionHref?: string | null
+}
+
+export interface ConnectorReadiness {
+  state: ConnectorReadinessState
+  summary: string
+  checks: ConnectorReadinessCheck[]
+  recentError: string | null
+  doctorHref: string
+  dashboardHref?: string | null
+}
+
+export function hasConnectorCredentials(connector: Connector): boolean {
+  return connector.platform === 'whatsapp'
+    || connector.platform === 'openclaw'
+    || connector.platform === 'signal'
+    || connector.platform === 'email'
+    || connector.platform === 'swarmdock'
+    || (connector.platform === 'bluebubbles' && (!!connector.credentialId || !!connector.config?.password))
+    || !!connector.credentialId
+}
+
+function hasRoute(connector: Connector): boolean {
+  return Boolean(connector.agentId || connector.chatroomId)
+}
+
+function connectionLabel(connector: Connector): string {
+  if (connector.status === 'running') return 'Connected'
+  if (connector.status === 'starting') return 'Starting'
+  if (connector.status === 'error') return 'Error'
+  return 'Stopped'
+}
+
+function openClawEndpointLabel(connector: Connector): string {
+  const wsUrl = typeof connector.config?.wsUrl === 'string' && connector.config.wsUrl.trim()
+    ? connector.config.wsUrl.trim()
+    : 'ws://localhost:18789'
+  return `Gateway ${wsUrl}`
+}
+
+export function getConnectorReadiness(connector: Connector): ConnectorReadiness {
+  const credentialsReady = hasConnectorCredentials(connector)
+  const routeReady = hasRoute(connector)
+  const checks: ConnectorReadinessCheck[] = [
+    {
+      id: 'credentials',
+      label: 'Credentials',
+      status: credentialsReady ? 'ready' : 'error',
+      detail: credentialsReady ? 'Credential path is configured.' : 'Add the token, password, or pairing credential.',
+    },
+    {
+      id: 'route',
+      label: 'Route target',
+      status: routeReady ? 'ready' : 'warning',
+      detail: routeReady ? 'Inbound messages have an agent or room target.' : 'Choose an agent or chatroom route.',
+    },
+  ]
+
+  if (connector.qrDataUrl) {
+    checks.push({
+      id: 'pairing',
+      label: 'Pairing',
+      status: 'warning',
+      detail: 'Pairing is waiting for a QR scan.',
+      actionLabel: 'Pair device',
+    })
+  }
+
+  if (connector.platform === 'openclaw') {
+    checks.push({
+      id: 'gateway',
+      label: 'OpenClaw Gateway',
+      status: connector.status === 'error' ? 'error' : 'ready',
+      detail: openClawEndpointLabel(connector),
+      actionLabel: 'Dashboard',
+      actionHref: connector.agentId
+        ? `/api/openclaw/dashboard-url?agentId=${encodeURIComponent(connector.agentId)}`
+        : null,
+    })
+  }
+
+  checks.push({
+    id: 'connection',
+    label: 'Connection',
+    status: connector.status === 'running'
+      ? 'ready'
+      : connector.status === 'error'
+        ? 'error'
+        : 'warning',
+    detail: connector.lastError || connectionLabel(connector),
+  })
+
+  const hasError = checks.some((check) => check.status === 'error')
+  const hasWarning = checks.some((check) => check.status === 'warning')
+  const state: ConnectorReadinessState = hasError || !credentialsReady || !routeReady
+    ? 'needs_setup'
+    : hasWarning
+      ? 'attention'
+      : 'healthy'
+  const summary = state === 'healthy'
+    ? 'Ready for inbound autonomy'
+    : state === 'attention'
+      ? 'Configured, but not fully connected'
+      : 'Setup work required before it can run'
+
+  return {
+    state,
+    summary,
+    checks,
+    recentError: connector.lastError || null,
+    doctorHref: `/api/connectors/${encodeURIComponent(connector.id)}/doctor`,
+    dashboardHref: connector.platform === 'openclaw' && connector.agentId
+      ? `/api/openclaw/dashboard-url?agentId=${encodeURIComponent(connector.agentId)}`
+      : null,
+  }
+}

package/src/lib/server/artifacts/artifact-resolver.test.ts

@@ -0,0 +1,98 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { test } from 'node:test'
+
+import type { BoardTask, KnowledgeCitation, Mission, MissionReport, ProtocolRun, RunEventRecord, SessionRunRecord } from '@/types'
+import type { ShareLink } from '@/lib/server/sharing/share-link-repository'
+
+test('buildEvidenceArtifactsFromRecords merges run, task, protocol, mission, and share evidence', async () => {
+  process.env.DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-artifacts-'))
+  process.env.ACCESS_KEY = 'test-key'
+  process.env.CREDENTIAL_SECRET = 'test-secret-32-characters-long!!'
+
+  const { buildEvidenceArtifactsFromRecords } = await import('./artifact-resolver')
+  const run: SessionRunRecord = {
+    id: 'run_1',
+    sessionId: 'sess_1',
+    source: 'chat',
+    internal: false,
+    mode: 'direct',
+    status: 'completed',
+    messagePreview: 'Release QA',
+    queuedAt: 1000,
+    endedAt: 5000,
+    resultPreview: 'QA finished.',
+  }
+  const citation: KnowledgeCitation = {
+    sourceId: 'source_1',
+    sourceTitle: 'Runbook',
+    sourceKind: 'manual',
+    sourceUrl: 'https://example.test/runbook',
+    sourceLabel: null,
+    chunkId: 'chunk_1',
+    chunkIndex: 0,
+    chunkCount: 1,
+    charStart: 0,
+    charEnd: 10,
+    sectionLabel: null,
+    snippet: 'Attach evidence.',
+    whyMatched: null,
+    score: 0.8,
+  }
+  const events: RunEventRecord[] = [{
+    id: 'event_1',
+    runId: 'run_1',
+    sessionId: 'sess_1',
+    timestamp: 4000,
+    phase: 'event',
+    event: { t: 'md', text: 'cited' },
+    citations: [citation],
+  }]
+  const protocolRun = {
+    id: 'protocol_1',
+    title: 'Protocol',
+    templateName: 'Template',
+    artifacts: [{ id: 'artifact_1', kind: 'summary', title: 'Summary', content: 'Structured output.', createdAt: 3000 }],
+  } as ProtocolRun
+  const task = {
+    id: 'task_1',
+    title: 'Build package',
+    description: '',
+    status: 'completed',
+    agentId: 'agent_1',
+    createdAt: 1000,
+    updatedAt: 3500,
+    completedAt: 3500,
+    outputFiles: ['dist/report.md'],
+    completionReportPath: 'reports/task.md',
+    result: 'Package built.',
+  } as BoardTask
+  const mission = {
+    id: 'mission_1',
+    title: 'Mission',
+    goal: 'Ship',
+    status: 'completed',
+    milestones: [{ id: 'ms_1', at: 4500, kind: 'completed', summary: 'Done', evidence: ['run_1'] }],
+  } as Mission
+  const report = { id: 'report_1', missionId: 'mission_1', title: 'Report', body: 'Launch report.', format: 'markdown', generatedAt: 6000 } as MissionReport
+  const share = { id: 'share_1', token: 'token_1', entityType: 'mission', entityId: 'mission_1', label: 'Public report', createdAt: 6500, expiresAt: null, revokedAt: null } as ShareLink
+
+  const artifacts = buildEvidenceArtifactsFromRecords({
+    run,
+    runEvents: events,
+    protocolRun,
+    task,
+    mission,
+    missionReports: [report],
+    shareLinks: [share],
+  })
+
+  assert.deepEqual(
+    artifacts.map((artifact) => artifact.kind),
+    ['share_link', 'mission_report', 'run_result', 'mission_milestone', 'run_citation', 'task_output', 'completion_report', 'task_result', 'protocol_artifact'],
+  )
+  assert.equal(artifacts.find((artifact) => artifact.kind === 'run_citation')?.url, 'https://example.test/runbook')
+  assert.equal(artifacts.find((artifact) => artifact.kind === 'task_output')?.url, '/api/files/serve?path=dist%2Freport.md')
+})

package/src/lib/server/artifacts/artifact-resolver.ts

@@ -0,0 +1,241 @@
+import { getMission, listMissionReports } from '@/lib/server/missions/mission-repository'
+import { loadProtocolRunById } from '@/lib/server/protocols/protocol-queries'
+import { listShareLinks, type ShareLink } from '@/lib/server/sharing/share-link-repository'
+import { loadTask } from '@/lib/server/tasks/task-repository'
+import { getUnifiedRunById, listUnifiedRunEvents } from '@/lib/server/runs/unified-run-queries'
+import type {
+  BoardTask,
+  EvidenceArtifact,
+  KnowledgeCitation,
+  Mission,
+  MissionReport,
+  ProtocolRun,
+  RunEventRecord,
+  SessionRunRecord,
+} from '@/types'
+
+const MAX_PREVIEW = 360
+
+function compactText(value: string | null | undefined, maxChars = MAX_PREVIEW): string | null {
+  const text = (value || '').split(/\s+/).filter(Boolean).join(' ').trim()
+  if (!text) return null
+  return text.length > maxChars ? `${text.slice(0, maxChars - 1)}...` : text
+}
+
+function fileServeUrl(filePath: string): string {
+  return `/api/files/serve?path=${encodeURIComponent(filePath)}`
+}
+
+function addUnique(items: EvidenceArtifact[], item: EvidenceArtifact, seen: Set<string>): void {
+  const key = `${item.kind}:${item.id}`
+  if (seen.has(key)) return
+  seen.add(key)
+  items.push(item)
+}
+
+function artifactsForTask(task: BoardTask, seen: Set<string>): EvidenceArtifact[] {
+  const items: EvidenceArtifact[] = []
+  for (const artifact of task.artifacts || []) {
+    addUnique(items, {
+      id: `${task.id}:${artifact.filename}`,
+      kind: 'task_artifact',
+      title: artifact.filename || artifact.type,
+      description: `${artifact.type} artifact from task ${task.title}`,
+      url: artifact.url,
+      createdAt: task.completedAt || task.updatedAt || task.createdAt,
+      source: { type: 'task', id: task.id, label: task.title },
+    }, seen)
+  }
+  for (const outputPath of task.outputFiles || []) {
+    addUnique(items, {
+      id: `${task.id}:output:${outputPath}`,
+      kind: 'task_output',
+      title: outputPath.split('/').pop() || outputPath,
+      description: 'Task output file',
+      url: fileServeUrl(outputPath),
+      createdAt: task.completedAt || task.updatedAt || task.createdAt,
+      source: { type: 'task', id: task.id, label: task.title },
+    }, seen)
+  }
+  if (task.completionReportPath) {
+    addUnique(items, {
+      id: `${task.id}:completion-report`,
+      kind: 'completion_report',
+      title: 'Completion report',
+      description: task.completionReportPath,
+      url: fileServeUrl(task.completionReportPath),
+      createdAt: task.completedAt || task.updatedAt || task.createdAt,
+      source: { type: 'task', id: task.id, label: task.title },
+    }, seen)
+  }
+  if (task.file) {
+    addUnique(items, {
+      id: `${task.id}:source-file`,
+      kind: 'task_output',
+      title: task.file.split('/').pop() || task.file,
+      description: 'Linked task file',
+      url: fileServeUrl(task.file),
+      createdAt: task.updatedAt || task.createdAt,
+      source: { type: 'task', id: task.id, label: task.title },
+    }, seen)
+  }
+  if (task.result) {
+    addUnique(items, {
+      id: `${task.id}:result`,
+      kind: 'task_result',
+      title: 'Task result',
+      preview: compactText(task.result),
+      createdAt: task.completedAt || task.updatedAt || task.createdAt,
+      source: { type: 'task', id: task.id, label: task.title },
+    }, seen)
+  }
+  return items
+}
+
+function artifactsForProtocolRun(run: ProtocolRun, seen: Set<string>): EvidenceArtifact[] {
+  const items: EvidenceArtifact[] = []
+  for (const artifact of run.artifacts || []) {
+    addUnique(items, {
+      id: artifact.id,
+      kind: 'protocol_artifact',
+      title: artifact.title || artifact.kind,
+      description: artifact.kind,
+      preview: compactText(artifact.content),
+      createdAt: artifact.createdAt,
+      source: { type: 'protocol', id: run.id, label: run.title || run.templateName },
+    }, seen)
+  }
+  return items
+}
+
+function citationArtifact(run: SessionRunRecord, event: RunEventRecord, citation: KnowledgeCitation): EvidenceArtifact {
+  return {
+    id: `${run.id}:${citation.sourceId}:${citation.chunkId}:${citation.chunkIndex}`,
+    kind: 'run_citation',
+    title: citation.sourceTitle || citation.sourceLabel || citation.sourceId,
+    description: citation.whyMatched || `Citation ${citation.chunkIndex + 1} of ${citation.chunkCount}`,
+    preview: compactText(citation.snippet),
+    url: citation.sourceUrl || null,
+    createdAt: event.timestamp,
+    source: { type: 'run', id: run.id, label: run.messagePreview || run.source },
+  }
+}
+
+function artifactsForRun(run: SessionRunRecord, events: RunEventRecord[], seen: Set<string>): EvidenceArtifact[] {
+  const items: EvidenceArtifact[] = []
+  if (run.resultPreview) {
+    addUnique(items, {
+      id: `${run.id}:result`,
+      kind: 'run_result',
+      title: 'Run result',
+      preview: compactText(run.resultPreview),
+      createdAt: run.endedAt || run.startedAt || run.queuedAt,
+      source: { type: 'run', id: run.id, label: run.messagePreview || run.source },
+    }, seen)
+  }
+  if (run.error) {
+    addUnique(items, {
+      id: `${run.id}:error`,
+      kind: 'run_error',
+      title: 'Run error',
+      preview: compactText(run.error),
+      createdAt: run.endedAt || run.startedAt || run.queuedAt,
+      source: { type: 'run', id: run.id, label: run.messagePreview || run.source },
+    }, seen)
+  }
+  for (const event of events) {
+    for (const citation of [...(event.citations || []), ...(event.retrievalTrace?.hits || [])]) {
+      addUnique(items, citationArtifact(run, event, citation), seen)
+    }
+  }
+  return items
+}
+
+function artifactsForMission(mission: Mission, reports: MissionReport[], shareLinks: ShareLink[], seen: Set<string>): EvidenceArtifact[] {
+  const items: EvidenceArtifact[] = []
+  for (const report of reports) {
+    addUnique(items, {
+      id: report.id,
+      kind: 'mission_report',
+      title: report.title,
+      description: `${report.format} report`,
+      preview: compactText(report.body),
+      createdAt: report.generatedAt,
+      source: { type: 'mission', id: mission.id, label: mission.title },
+    }, seen)
+  }
+  for (const milestone of mission.milestones || []) {
+    if (!milestone.evidence?.length) continue
+    addUnique(items, {
+      id: milestone.id,
+      kind: 'mission_milestone',
+      title: milestone.summary,
+      description: milestone.kind,
+      preview: milestone.evidence.join('\n'),
+      createdAt: milestone.at,
+      source: { type: 'mission', id: mission.id, label: mission.title },
+    }, seen)
+  }
+  for (const link of shareLinks.filter((entry) => entry.entityType === 'mission' && entry.entityId === mission.id)) {
+    addUnique(items, {
+      id: link.id,
+      kind: 'share_link',
+      title: link.label || 'Mission share link',
+      description: link.revokedAt ? 'Revoked public share' : 'Active public share',
+      href: `/s/${link.token}`,
+      createdAt: link.createdAt,
+      source: { type: 'share', id: link.id, label: mission.title },
+    }, seen)
+  }
+  return items
+}
+
+export function buildEvidenceArtifactsFromRecords(input: {
+  run?: SessionRunRecord | null
+  runEvents?: RunEventRecord[]
+  protocolRun?: ProtocolRun | null
+  task?: BoardTask | null
+  mission?: Mission | null
+  missionReports?: MissionReport[]
+  shareLinks?: ShareLink[]
+}): EvidenceArtifact[] {
+  const seen = new Set<string>()
+  const items: EvidenceArtifact[] = []
+  if (input.run) {
+    for (const item of artifactsForRun(input.run, input.runEvents || [], seen)) items.push(item)
+  }
+  if (input.protocolRun) {
+    for (const item of artifactsForProtocolRun(input.protocolRun, seen)) items.push(item)
+  }
+  if (input.task) {
+    for (const item of artifactsForTask(input.task, seen)) items.push(item)
+  }
+  if (input.mission) {
+    for (const item of artifactsForMission(input.mission, input.missionReports || [], input.shareLinks || [], seen)) items.push(item)
+  }
+  return items.sort((left, right) => (right.createdAt || 0) - (left.createdAt || 0))
+}
+
+export function listEvidenceArtifacts(params: {
+  runId?: string | null
+  missionId?: string | null
+  taskId?: string | null
+  mission?: Mission | null
+}): EvidenceArtifact[] {
+  const run = params.runId ? getUnifiedRunById(params.runId) : null
+  const runEvents = params.runId && run ? listUnifiedRunEvents(params.runId, 300) : []
+  const protocolRun = params.runId ? loadProtocolRunById(params.runId) : null
+  const protocolTask = protocolRun?.taskId ? loadTask(protocolRun.taskId) : null
+  const task = params.taskId ? loadTask(params.taskId) : protocolTask
+  const mission = params.mission || (params.missionId ? getMission(params.missionId) : null)
+
+  return buildEvidenceArtifactsFromRecords({
+    run,
+    runEvents,
+    protocolRun,
+    task,
+    mission,
+    missionReports: params.missionId ? listMissionReports(params.missionId, 20) : [],
+    shareLinks: params.missionId ? listShareLinks() : [],
+  })
+}