@swarmclawai/swarmclaw 1.7.3 → 1.8.1

package/src/lib/server/operations/operation-pulse.test.ts

@@ -0,0 +1,108 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import { buildOperationPulse, normalizeOperationPulseRange } from './operation-pulse'
+import type { ApprovalRequest, Connector, Mission, SessionRunRecord } from '@/types'
+
+const now = 10_000_000
+
+function run(overrides: Partial<SessionRunRecord>): SessionRunRecord {
+  return {
+    id: overrides.id || 'run_1',
+    sessionId: overrides.sessionId || 'sess_1',
+    source: overrides.source || 'chat',
+    internal: false,
+    mode: 'direct',
+    status: overrides.status || 'completed',
+    messagePreview: overrides.messagePreview || 'Run',
+    queuedAt: overrides.queuedAt ?? now - 1000,
+    ...overrides,
+  }
+}
+
+function mission(overrides: Partial<Mission>): Mission {
+  return {
+    id: overrides.id || 'mission_1',
+    title: overrides.title || 'Release QA',
+    goal: overrides.goal || 'Verify release',
+    successCriteria: overrides.successCriteria || [],
+    rootSessionId: overrides.rootSessionId || 'sess_1',
+    agentIds: overrides.agentIds || [],
+    status: overrides.status || 'running',
+    budget: overrides.budget || { maxUsd: 10 },
+    usage: overrides.usage || {
+      usdSpent: 9,
+      tokensUsed: 0,
+      toolCallsUsed: 0,
+      turnsRun: 3,
+      wallclockMsElapsed: 0,
+      startedAt: now - 60_000,
+      lastUpdatedAt: now,
+      warnFractionsHit: [],
+    },
+    milestones: overrides.milestones || [],
+    reportSchedule: null,
+    reportConnectorIds: [],
+    createdAt: overrides.createdAt ?? now - 5000,
+    updatedAt: overrides.updatedAt ?? now - 1000,
+    ...overrides,
+  }
+}
+
+function approval(overrides: Partial<ApprovalRequest>): ApprovalRequest {
+  return {
+    id: overrides.id || 'approval_1',
+    category: overrides.category || 'human_loop',
+    title: overrides.title || 'Approve tool use',
+    data: {},
+    createdAt: overrides.createdAt ?? now - 3000,
+    updatedAt: overrides.updatedAt ?? now - 3000,
+    status: overrides.status || 'pending',
+    ...overrides,
+  }
+}
+
+function connector(overrides: Partial<Connector>): Connector {
+  return {
+    id: overrides.id || 'conn_1',
+    name: overrides.name || 'Slack',
+    platform: overrides.platform || 'slack',
+    agentId: overrides.agentId,
+    chatroomId: overrides.chatroomId,
+    credentialId: overrides.credentialId,
+    config: overrides.config || {},
+    isEnabled: overrides.isEnabled ?? true,
+    status: overrides.status || 'stopped',
+    lastError: overrides.lastError,
+    createdAt: overrides.createdAt ?? now - 4000,
+    updatedAt: overrides.updatedAt ?? now - 2000,
+  }
+}
+
+describe('operation pulse', () => {
+  it('normalizes unsupported ranges to the 24-hour default', () => {
+    assert.equal(normalizeOperationPulseRange('7d'), '7d')
+    assert.equal(normalizeOperationPulseRange('30d'), '24h')
+    assert.equal(normalizeOperationPulseRange(null), '24h')
+  })
+
+  it('combines failed runs, approvals, connector readiness, and budget pressure', () => {
+    const pulse = buildOperationPulse({
+      range: '24h',
+      now,
+      missions: [mission({})],
+      runs: [run({ id: 'failed', status: 'failed', error: 'bad', endedAt: now - 100 }), run({ id: 'running', status: 'running' })],
+      approvals: [approval({ category: 'budget_change' })],
+      connectors: [connector({ lastError: 'token rejected' })],
+    })
+
+    assert.equal(pulse.kpis.activeMissions, 1)
+    assert.equal(pulse.kpis.runningRuns, 1)
+    assert.equal(pulse.kpis.failedRuns, 1)
+    assert.equal(pulse.kpis.pendingApprovals, 1)
+    assert.equal(pulse.kpis.connectorAttention, 1)
+    assert.equal(pulse.kpis.budgetWarnings, 1)
+    assert.deepEqual(pulse.actions.slice(0, 3).map((action) => action.severity), ['high', 'high', 'high'])
+    assert.ok(pulse.actions.some((action) => action.kind === 'budget' && action.summary.includes('90%')))
+  })
+})

package/src/lib/server/operations/operation-pulse.ts

@@ -0,0 +1,197 @@
+import { listPendingApprovals } from '@/lib/server/approvals'
+import { getConnectorReadiness } from '@/lib/connectors/connector-readiness'
+import { loadConnectors } from '@/lib/server/connectors/connector-repository'
+import { listMissions } from '@/lib/server/missions/mission-repository'
+import { listUnifiedRuns } from '@/lib/server/runs/unified-run-queries'
+import type {
+  ApprovalRequest,
+  Connector,
+  Mission,
+  OperationPulse,
+  OperationPulseAction,
+  OperationPulseRange,
+  OperationPulseSeverity,
+  SessionRunRecord,
+} from '@/types'
+
+const RANGE_MS: Record<OperationPulseRange, number> = {
+  '24h': 24 * 60 * 60_000,
+  '7d': 7 * 24 * 60 * 60_000,
+}
+
+const SEVERITY_RANK: Record<OperationPulseSeverity, number> = {
+  high: 0,
+  medium: 1,
+  low: 2,
+}
+
+const ACTIVE_MISSION_STATUSES = new Set<Mission['status']>(['running', 'paused'])
+
+export function normalizeOperationPulseRange(value: string | null | undefined): OperationPulseRange {
+  return value === '7d' ? '7d' : '24h'
+}
+
+function isWithinWindow(at: number | null | undefined, windowStart: number): boolean {
+  return typeof at === 'number' && Number.isFinite(at) && at >= windowStart
+}
+
+function runActivityAt(run: SessionRunRecord): number {
+  return run.endedAt || run.startedAt || run.queuedAt || 0
+}
+
+function budgetFractions(mission: Mission, now: number): Array<{ label: string; fraction: number }> {
+  const usage = mission.usage
+  const budget = mission.budget
+  const rows: Array<{ label: string; fraction: number }> = []
+  if (budget.maxUsd && budget.maxUsd > 0) rows.push({ label: 'USD', fraction: usage.usdSpent / budget.maxUsd })
+  if (budget.maxTokens && budget.maxTokens > 0) rows.push({ label: 'tokens', fraction: usage.tokensUsed / budget.maxTokens })
+  if (budget.maxToolCalls && budget.maxToolCalls > 0) rows.push({ label: 'tool calls', fraction: usage.toolCallsUsed / budget.maxToolCalls })
+  if (budget.maxTurns && budget.maxTurns > 0) rows.push({ label: 'turns', fraction: usage.turnsRun / budget.maxTurns })
+  if (budget.maxWallclockSec && budget.maxWallclockSec > 0) {
+    const elapsed = usage.startedAt ? Math.max(usage.wallclockMsElapsed, now - usage.startedAt) : usage.wallclockMsElapsed
+    rows.push({ label: 'wallclock', fraction: elapsed / (budget.maxWallclockSec * 1000) })
+  }
+  return rows
+}
+
+function budgetPressure(mission: Mission, now: number): { label: string; fraction: number } | null {
+  const rows = budgetFractions(mission, now).sort((left, right) => right.fraction - left.fraction)
+  const top = rows[0]
+  return top && top.fraction >= 0.8 ? top : null
+}
+
+function percent(value: number): string {
+  return `${Math.round(value * 100)}%`
+}
+
+function addAction(actions: OperationPulseAction[], action: OperationPulseAction): void {
+  actions.push(action)
+}
+
+function sortActions(actions: OperationPulseAction[]): OperationPulseAction[] {
+  return [...actions]
+    .sort((left, right) => {
+      const severityDelta = SEVERITY_RANK[left.severity] - SEVERITY_RANK[right.severity]
+      if (severityDelta !== 0) return severityDelta
+      return (right.createdAt || 0) - (left.createdAt || 0)
+    })
+    .slice(0, 12)
+}
+
+export function buildOperationPulse(input: {
+  range: OperationPulseRange
+  now: number
+  missions: Mission[]
+  runs: SessionRunRecord[]
+  approvals: ApprovalRequest[]
+  connectors: Connector[]
+}): OperationPulse {
+  const windowStart = input.now - RANGE_MS[input.range]
+  const windowRuns = input.runs.filter((run) => run.status === 'running' || run.status === 'queued' || isWithinWindow(runActivityAt(run), windowStart))
+  const activeMissions = input.missions.filter((mission) => ACTIVE_MISSION_STATUSES.has(mission.status))
+  const runningRuns = windowRuns.filter((run) => run.status === 'running' || run.status === 'queued')
+  const failedRuns = windowRuns.filter((run) => run.status === 'failed')
+  const pendingApprovals = input.approvals.filter((approval) => approval.status === 'pending')
+  const connectorReadiness = input.connectors.map((connector) => ({ connector, readiness: getConnectorReadiness(connector) }))
+  const connectorAttention = connectorReadiness.filter((item) => item.readiness.state !== 'healthy')
+  const budgetWarnings = input.missions
+    .map((mission) => ({ mission, pressure: budgetPressure(mission, input.now) }))
+    .filter((item) => item.pressure)
+
+  const actions: OperationPulseAction[] = []
+
+  for (const run of failedRuns.slice(0, 5)) {
+    addAction(actions, {
+      id: `run:${run.id}`,
+      kind: 'run',
+      severity: 'high',
+      title: 'Review failed run',
+      summary: run.error || run.resultPreview || run.messagePreview || run.id,
+      href: '/quality?tab=runs',
+      evidence: [run.source, run.ownerType && run.ownerId ? `${run.ownerType}:${run.ownerId}` : 'runtime run'].filter(Boolean) as string[],
+      createdAt: runActivityAt(run),
+    })
+  }
+
+  for (const approval of pendingApprovals.slice(0, 5)) {
+    addAction(actions, {
+      id: `approval:${approval.id}`,
+      kind: 'approval',
+      severity: approval.category === 'budget_change' ? 'high' : 'medium',
+      title: 'Resolve pending approval',
+      summary: approval.title || approval.description || approval.category,
+      href: '/quality?tab=approvals',
+      evidence: [approval.category, approval.agentId ? `agent:${approval.agentId}` : '', approval.taskId ? `task:${approval.taskId}` : ''].filter(Boolean),
+      createdAt: approval.createdAt,
+    })
+  }
+
+  for (const item of connectorAttention.slice(0, 5)) {
+    addAction(actions, {
+      id: `connector:${item.connector.id}`,
+      kind: 'connector',
+      severity: item.connector.status === 'error' || item.readiness.recentError ? 'high' : 'medium',
+      title: 'Fix connector readiness',
+      summary: `${item.connector.name}: ${item.readiness.summary}`,
+      href: '/connectors',
+      evidence: item.readiness.checks
+        .filter((check) => check.status !== 'ready')
+        .map((check) => `${check.label}: ${check.detail}`),
+      createdAt: item.connector.updatedAt || item.connector.createdAt,
+    })
+  }
+
+  for (const item of budgetWarnings.slice(0, 5)) {
+    if (!item.pressure) continue
+    addAction(actions, {
+      id: `budget:${item.mission.id}:${item.pressure.label}`,
+      kind: 'budget',
+      severity: item.pressure.fraction >= 0.95 ? 'high' : 'medium',
+      title: 'Check mission budget',
+      summary: `${item.mission.title} is at ${percent(item.pressure.fraction)} of its ${item.pressure.label} budget.`,
+      href: `/missions?mission=${encodeURIComponent(item.mission.id)}`,
+      evidence: [`status:${item.mission.status}`, `goal:${item.mission.goal}`],
+      createdAt: item.mission.updatedAt || item.mission.createdAt,
+    })
+  }
+
+  for (const mission of activeMissions.slice(0, 3)) {
+    addAction(actions, {
+      id: `mission:${mission.id}`,
+      kind: 'mission',
+      severity: mission.status === 'paused' ? 'medium' : 'low',
+      title: mission.status === 'paused' ? 'Resume or close paused mission' : 'Monitor active mission',
+      summary: mission.title,
+      href: `/missions?mission=${encodeURIComponent(mission.id)}`,
+      evidence: [`${mission.usage.turnsRun} turns`, `${mission.usage.tokensUsed.toLocaleString()} tokens`],
+      createdAt: mission.updatedAt || mission.createdAt,
+    })
+  }
+
+  return {
+    generatedAt: input.now,
+    range: input.range,
+    windowStart,
+    kpis: {
+      activeMissions: activeMissions.length,
+      runningRuns: runningRuns.length,
+      failedRuns: failedRuns.length,
+      pendingApprovals: pendingApprovals.length,
+      connectorAttention: connectorAttention.length,
+      budgetWarnings: budgetWarnings.length,
+    },
+    actions: sortActions(actions),
+  }
+}
+
+export function getOperationPulse(range: OperationPulseRange): OperationPulse {
+  const now = Date.now()
+  return buildOperationPulse({
+    range,
+    now,
+    missions: listMissions(),
+    runs: listUnifiedRuns({ limit: 500 }),
+    approvals: listPendingApprovals(),
+    connectors: Object.values(loadConnectors()),
+  })
+}

package/src/lib/server/resolve-workspace-path.ts

@@ -14,8 +14,8 @@ import path from 'path'
  */
 export function resolveWorkspacePath(filePath: string, cwd?: string | null): string | null {
   // 1. Try as-is
-  const asIs = path.resolve(filePath)
-  if (fs.existsSync(asIs)) return asIs
+  const asIs = path.resolve(/*turbopackIgnore: true*/ filePath)
+  if (fs.existsSync(/*turbopackIgnore: true*/ asIs)) return asIs
 
   if (!cwd) return null
 
@@ -23,20 +23,20 @@ export function resolveWorkspacePath(filePath: string, cwd?: string | null): str
   if (!stripped) return null
 
   // 2. Try relative to cwd
-  const fromCwd = path.resolve(cwd, stripped)
-  if (fs.existsSync(fromCwd)) return fromCwd
+  const fromCwd = path.resolve(/*turbopackIgnore: true*/ cwd, stripped)
+  if (fs.existsSync(/*turbopackIgnore: true*/ fromCwd)) return fromCwd
 
   // 3. Try each immediate subdirectory of cwd (project dirs within workspace)
   try {
-    for (const entry of fs.readdirSync(cwd, { withFileTypes: true })) {
+    for (const entry of fs.readdirSync(/*turbopackIgnore: true*/ cwd, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue
-      const subdir = path.resolve(cwd, entry.name)
+      const subdir = path.resolve(/*turbopackIgnore: true*/ cwd, entry.name)
       // Direct match: cwd/project/stripped
-      const direct = path.resolve(subdir, stripped)
-      if (fs.existsSync(direct)) return direct
+      const direct = path.resolve(/*turbopackIgnore: true*/ subdir, stripped)
+      if (fs.existsSync(/*turbopackIgnore: true*/ direct)) return direct
       // Next.js route match: cwd/project/src/app/stripped (for route paths like /dashboard/compliance)
-      const srcApp = path.resolve(subdir, 'src', 'app', stripped)
-      if (fs.existsSync(srcApp)) return srcApp
+      const srcApp = path.resolve(/*turbopackIgnore: true*/ subdir, 'src', 'app', stripped)
+      if (fs.existsSync(/*turbopackIgnore: true*/ srcApp)) return srcApp
     }
   } catch {
     // cwd doesn't exist or isn't readable

package/src/lib/server/runs/run-brief.test.ts

@@ -0,0 +1,92 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import { buildRunBrief } from './run-brief'
+import type { KnowledgeCitation, RunEventRecord, SessionRunRecord } from '@/types'
+
+function run(overrides: Partial<SessionRunRecord>): SessionRunRecord {
+  return {
+    id: overrides.id || 'run_1',
+    sessionId: overrides.sessionId || 'sess_1',
+    source: overrides.source || 'chat',
+    internal: overrides.internal ?? false,
+    mode: overrides.mode || 'direct',
+    status: overrides.status || 'completed',
+    messagePreview: overrides.messagePreview || 'Review release evidence',
+    queuedAt: overrides.queuedAt ?? 1000,
+    ...overrides,
+  }
+}
+
+function citation(overrides: Partial<KnowledgeCitation> = {}): KnowledgeCitation {
+  return {
+    sourceId: overrides.sourceId || 'source_1',
+    sourceTitle: overrides.sourceTitle || 'Release checklist',
+    sourceKind: overrides.sourceKind || 'manual',
+    sourceUrl: overrides.sourceUrl ?? 'https://example.test/checklist',
+    sourceLabel: overrides.sourceLabel ?? null,
+    chunkId: overrides.chunkId || 'chunk_1',
+    chunkIndex: overrides.chunkIndex ?? 0,
+    chunkCount: overrides.chunkCount ?? 2,
+    charStart: overrides.charStart ?? 0,
+    charEnd: overrides.charEnd ?? 120,
+    sectionLabel: overrides.sectionLabel ?? null,
+    snippet: overrides.snippet || 'Run release QA and attach the verification evidence.',
+    whyMatched: overrides.whyMatched ?? null,
+    score: overrides.score ?? 0.92,
+  }
+}
+
+function event(overrides: Partial<RunEventRecord>): RunEventRecord {
+  return {
+    id: overrides.id || 'event_1',
+    runId: overrides.runId || 'run_1',
+    sessionId: overrides.sessionId || 'sess_1',
+    timestamp: overrides.timestamp ?? 2000,
+    phase: overrides.phase || 'event',
+    status: overrides.status,
+    summary: overrides.summary,
+    event: overrides.event || { t: 'md', text: 'Collected evidence.' },
+    citations: overrides.citations,
+    retrievalTrace: overrides.retrievalTrace,
+  }
+}
+
+describe('buildRunBrief', () => {
+  it('summarizes objective, timeline, usage, and citations', () => {
+    const brief = buildRunBrief(
+      run({
+        startedAt: 1500,
+        endedAt: 3000,
+        resultPreview: 'Release QA completed with two attached artifacts.',
+        totalInputTokens: 100,
+        totalOutputTokens: 50,
+        estimatedCost: 0.012,
+        retrievalSummary: { citationCount: 1, sourceIds: ['source_1'] },
+      }),
+      [
+        event({ id: 'started', phase: 'status', status: 'running', timestamp: 1500, summary: 'Started' }),
+        event({ id: 'done', phase: 'status', status: 'completed', timestamp: 3000, citations: [citation()] }),
+      ],
+      4000,
+    )
+
+    assert.equal(brief.runId, 'run_1')
+    assert.equal(brief.objective, 'Review release evidence')
+    assert.equal(brief.result, 'Release QA completed with two attached artifacts.')
+    assert.deepEqual(brief.usage.sourceIds, ['source_1'])
+    assert.equal(brief.usage.estimatedCost, 0.012)
+    assert.deepEqual(brief.timeline.map((item) => item.status), ['queued', 'running', 'running', 'completed', 'completed'])
+    assert.equal(brief.evidence[0].title, 'Release checklist')
+    assert.equal(brief.evidence[0].url, 'https://example.test/checklist')
+  })
+
+  it('flags failed and long-running runs for operator review', () => {
+    const failed = buildRunBrief(run({ status: 'failed', error: 'Provider timed out.', endedAt: 4000 }), [], 5000)
+    assert.ok(failed.warnings.some((warning) => warning.includes('failed')))
+    assert.ok(failed.warnings.some((warning) => warning.includes('No replay events')))
+
+    const running = buildRunBrief(run({ status: 'running', startedAt: 1000 }), [], 1_900_000)
+    assert.ok(running.warnings.some((warning) => warning.includes('30 minutes')))
+  })
+})

package/src/lib/server/runs/run-brief.ts

@@ -0,0 +1,107 @@
+import type { RunBrief, RunBriefEvidenceItem, RunBriefTimelineItem, RunEventRecord, SessionRunRecord } from '@/types'
+
+const MAX_TEXT = 420
+const MAX_EVIDENCE = 10
+const LONG_RUNNING_MS = 30 * 60_000
+
+function compactText(value: string | null | undefined, maxChars = MAX_TEXT): 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 timelineItem(label: string, at: number | undefined, status?: RunBriefTimelineItem['status'], detail?: string | null): RunBriefTimelineItem | null {
+  if (!at || !Number.isFinite(at)) return null
+  return { label, status, at, detail: detail || null }
+}
+
+function eventText(event: RunEventRecord): string | null {
+  return compactText(event.summary || event.event.text || event.event.toolOutput || event.event.toolName || event.event.t || '')
+}
+
+function collectEvidence(events: RunEventRecord[]): RunBriefEvidenceItem[] {
+  const evidence: RunBriefEvidenceItem[] = []
+  const seen = new Set<string>()
+  for (const event of events) {
+    const citations = [
+      ...(event.citations || []),
+      ...(event.retrievalTrace?.hits || []),
+    ]
+    for (const citation of citations) {
+      const id = `${citation.sourceId}:${citation.chunkId}:${citation.chunkIndex}`
+      if (seen.has(id)) continue
+      seen.add(id)
+      evidence.push({
+        id,
+        kind: event.retrievalTrace?.hits?.includes(citation) ? 'retrieval' : 'citation',
+        title: citation.sourceTitle || citation.sourceLabel || citation.sourceId,
+        summary: compactText(citation.snippet || citation.whyMatched || '', 240) || 'Referenced knowledge source.',
+        url: citation.sourceUrl || null,
+        sourceId: citation.sourceId,
+        createdAt: event.timestamp,
+      })
+      if (evidence.length >= MAX_EVIDENCE) return evidence
+    }
+  }
+  for (const event of events) {
+    const summary = eventText(event)
+    if (!summary) continue
+    evidence.push({
+      id: event.id,
+      kind: 'event',
+      title: event.phase === 'status' ? 'Status event' : 'Replay event',
+      summary,
+      createdAt: event.timestamp,
+    })
+    if (evidence.length >= MAX_EVIDENCE) return evidence
+  }
+  return evidence
+}
+
+export function buildRunBrief(run: SessionRunRecord, events: RunEventRecord[], now = Date.now()): RunBrief {
+  const timeline = [
+    timelineItem('Queued', run.queuedAt, 'queued', run.source),
+    timelineItem('Started', run.startedAt, 'running'),
+    ...events
+      .filter((event) => event.phase === 'status' && event.status)
+      .map((event) => timelineItem(event.status || 'status', event.timestamp, event.status, eventText(event)))
+      .filter((item): item is RunBriefTimelineItem => Boolean(item)),
+    timelineItem('Ended', run.endedAt, run.status),
+  ]
+    .filter((item): item is RunBriefTimelineItem => Boolean(item))
+    .sort((left, right) => left.at - right.at)
+
+  const warnings: string[] = []
+  if (run.status === 'failed') warnings.push('Run failed and needs review before using the result.')
+  if (run.status === 'running' && run.startedAt && now - run.startedAt > LONG_RUNNING_MS) {
+    warnings.push('Run has been running longer than 30 minutes.')
+  }
+  if ((run.status === 'completed' || run.status === 'failed') && events.length === 0) {
+    warnings.push('No replay events were persisted for this run.')
+  }
+  if (run.recoveredFromRestart) warnings.push('Run was recovered after a process restart.')
+  if (run.interruptedAt) warnings.push(run.interruptedReason || 'Run was interrupted.')
+
+  return {
+    runId: run.id,
+    sessionId: run.sessionId,
+    title: compactText(run.messagePreview, 120) || run.id,
+    objective: compactText(run.messagePreview, 280) || run.mode || run.source,
+    status: run.status,
+    source: run.source,
+    owner: run.ownerType && run.ownerId ? { type: run.ownerType, id: run.ownerId } : null,
+    timeline,
+    result: compactText(run.resultPreview, 1200),
+    error: compactText(run.error, 1200),
+    warnings,
+    usage: {
+      inputTokens: typeof run.totalInputTokens === 'number' ? run.totalInputTokens : null,
+      outputTokens: typeof run.totalOutputTokens === 'number' ? run.totalOutputTokens : null,
+      estimatedCost: typeof run.estimatedCost === 'number' ? run.estimatedCost : null,
+      citationCount: run.retrievalSummary?.citationCount || 0,
+      sourceIds: run.retrievalSummary?.sourceIds || [],
+    },
+    evidence: collectEvidence(events),
+    generatedAt: now,
+  }
+}

package/src/lib/server/runs/unified-run-queries.ts

@@ -0,0 +1,84 @@
+import { getRunById, listRunEvents, listRuns } from '@/lib/server/runtime/session-run-manager'
+import {
+  listProtocolRunEventsForRun,
+  listProtocolRuns,
+  loadProtocolRunById,
+} from '@/lib/server/protocols/protocol-queries'
+import {
+  protocolEventToRunEventRecord,
+  protocolRunToSessionRunRecord,
+} from '@/lib/server/runs/unified-run-records'
+import type {
+  ProtocolRun,
+  ProtocolRunStatus,
+  RunEventRecord,
+  SessionRunRecord,
+  SessionRunStatus,
+} from '@/types'
+
+function protocolStatusesForRunStatus(status?: SessionRunStatus): ProtocolRunStatus[] {
+  switch (status) {
+    case 'queued':
+      return ['draft']
+    case 'running':
+      return ['running', 'waiting', 'paused']
+    case 'completed':
+      return ['completed']
+    case 'failed':
+      return ['failed']
+    case 'cancelled':
+      return ['cancelled', 'archived']
+    default:
+      return []
+  }
+}
+
+function uniqueProtocolRuns(runs: ProtocolRun[]): ProtocolRun[] {
+  return Array.from(new Map(runs.map((run) => [run.id, run])).values())
+}
+
+export function listUnifiedRuns(params: {
+  sessionId?: string
+  status?: SessionRunStatus
+  limit?: number
+} = {}): SessionRunRecord[] {
+  const fetchLimit = Math.max(1, Math.min(1000, Math.trunc(params.limit ?? 200)))
+  const sessionRuns = listRuns({ sessionId: params.sessionId, status: params.status, limit: fetchLimit })
+  const protocolRuns = params.status
+    ? protocolStatusesForRunStatus(params.status).flatMap((protocolStatus) => listProtocolRuns({
+      includeSystemOwned: true,
+      sessionId: params.sessionId,
+      status: protocolStatus,
+      limit: fetchLimit,
+    }))
+    : listProtocolRuns({
+      includeSystemOwned: true,
+      sessionId: params.sessionId,
+      limit: fetchLimit,
+    })
+
+  return [
+    ...sessionRuns,
+    ...uniqueProtocolRuns(protocolRuns)
+      .filter((run) => run.status !== 'archived')
+      .map(protocolRunToSessionRunRecord)
+      .filter((run) => !params.status || run.status === params.status),
+  ]
+    .sort((left, right) => (right.queuedAt || 0) - (left.queuedAt || 0))
+    .slice(0, fetchLimit)
+}
+
+export function getUnifiedRunById(runId: string): SessionRunRecord | null {
+  const run = getRunById(runId)
+  if (run) return run
+  const protocolRun = loadProtocolRunById(runId)
+  return protocolRun ? protocolRunToSessionRunRecord(protocolRun) : null
+}
+
+export function listUnifiedRunEvents(runId: string, limit = 200): RunEventRecord[] {
+  const run = getRunById(runId)
+  if (run) return listRunEvents(runId, limit)
+  const protocolRun = loadProtocolRunById(runId)
+  if (!protocolRun) return []
+  return listProtocolRunEventsForRun(runId, limit).map((event) => protocolEventToRunEventRecord(protocolRun, event))
+}