@swarmclawai/swarmclaw 1.5.71 → 1.6.0

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

@@ -1,6 +1,6 @@
 'use client'
 
-import { useEffect, useState, useCallback } from 'react'
+import { useEffect, useMemo, useState, useCallback } from 'react'
 import { api } from '@/lib/app/api-client'
 import { useNow } from '@/hooks/use-now'
 import { useWs } from '@/hooks/use-ws'
@@ -37,6 +37,8 @@ export function RunList() {
   const [loading, setLoading] = useState(true)
   const [autoRefresh, setAutoRefresh] = useState(false)
   const [statusFilter, setStatusFilter] = useState<SessionRunStatus | null>(null)
+  const [sourceFilter, setSourceFilter] = useState<string>('all')
+  const [query, setQuery] = useState('')
   const [selected, setSelected] = useState<SessionRunRecord | null>(null)
   const [selectedEvents, setSelectedEvents] = useState<RunEventRecord[]>([])
   const [eventsLoading, setEventsLoading] = useState(false)
@@ -84,7 +86,30 @@ export function RunList() {
     setEventsLoading(true)
   }, [])
 
-  const filtered = statusFilter ? runs.filter((r) => r.status === statusFilter) : runs
+  const sources = useMemo(() => {
+    return Array.from(new Set(runs.map((run) => run.source).filter(Boolean))).sort((a, b) => a.localeCompare(b))
+  }, [runs])
+
+  const filtered = useMemo(() => {
+    const normalizedQuery = query.trim().toLowerCase()
+    return runs.filter((run) => {
+      if (statusFilter && run.status !== statusFilter) return false
+      if (sourceFilter !== 'all' && run.source !== sourceFilter) return false
+      if (!normalizedQuery) return true
+      const searchable = [
+        run.id,
+        run.sessionId,
+        run.source,
+        run.messagePreview,
+        run.error,
+        run.resultPreview,
+        run.kind,
+        run.ownerType,
+        run.ownerId,
+      ]
+      return searchable.some((value) => String(value || '').toLowerCase().includes(normalizedQuery))
+    })
+  }, [query, runs, sourceFilter, statusFilter])
   const selectedResultGrounding = selectedEvents
     .slice()
     .reverse()
@@ -130,6 +155,32 @@ export function RunList() {
             {autoRefresh ? 'LIVE' : 'PAUSED'}
           </button>
         </div>
+        <div className="flex flex-col gap-2 sm:flex-row sm:items-center">
+          <div className="relative flex-1 min-w-[180px]">
+            <svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" className="absolute left-2.5 top-1/2 -translate-y-1/2 text-text-3/50">
+              <circle cx="11" cy="11" r="8" /><line x1="21" y1="21" x2="16.65" y2="16.65" />
+            </svg>
+            <input
+              value={query}
+              onChange={(event) => setQuery(event.target.value)}
+              placeholder="Search run id, source, error, or result"
+              className="w-full rounded-[8px] border border-white/[0.06] bg-white/[0.03] py-1.5 pl-8 pr-3 text-[12px] text-text outline-none transition-colors placeholder:text-text-3/45 focus:border-accent-bright/35"
+            />
+          </div>
+          <label className="flex items-center gap-2 text-[10px] font-700 uppercase tracking-[0.08em] text-text-3/60">
+            Source
+            <select
+              value={sourceFilter}
+              onChange={(event) => setSourceFilter(event.target.value)}
+              className="rounded-[8px] border border-white/[0.06] bg-white/[0.03] px-2 py-1.5 text-[11px] font-600 normal-case tracking-normal text-text outline-none"
+            >
+              <option value="all">All sources</option>
+              {sources.map((source) => (
+                <option key={source} value={source}>{source}</option>
+              ))}
+            </select>
+          </label>
+        </div>
       </div>
 
       {/* Count */}

package/src/components/shared/command-palette.tsx

@@ -98,6 +98,7 @@ function CommandPaletteInner({ setOpen }: { setOpen: (v: boolean) => void }) {
       { id: 'providers', label: 'Providers', description: 'Model providers and endpoints', keywords: ['openai', 'anthropic', 'ollama', 'endpoint'] },
       { id: 'secrets', label: 'Secrets', description: 'Credentials and encrypted secrets', keywords: ['api key', 'token', 'credential'] },
       { id: 'autonomy', label: 'Autonomy', description: 'Estops, incidents, and runtime controls', keywords: ['estop', 'incident', 'runtime', 'safety'] },
+      { id: 'quality', label: 'Quality', description: 'Evals, approvals, run review, and release readiness', keywords: ['eval', 'approval', 'runs', 'release', 'qa'] },
       { id: 'settings', label: 'Settings', description: 'General app configuration', keywords: ['preferences', 'theme', 'heartbeat'] },
     ] as const
     for (const view of views) {

package/src/lib/app/navigation.ts

@@ -15,6 +15,7 @@ const VIEW_TO_PATH: Record<AppView, string> = {
   memory: '/memory',
 
   tasks: '/tasks',
+  quality: '/quality',
   missions: '/missions',
   secrets: '/secrets',
   wallets: '/wallets',

package/src/lib/app/view-constants.test.ts

@@ -1,7 +1,7 @@
 import assert from 'node:assert/strict'
 import { describe, it } from 'node:test'
 
-import { isPanelSidebarView, shouldAutoOpenPanelSidebar } from './view-constants'
+import { FULL_WIDTH_VIEWS, VIEW_DESCRIPTIONS, VIEW_LABELS, isPanelSidebarView, shouldAutoOpenPanelSidebar } from './view-constants'
 
 describe('panel sidebar route helpers', () => {
   it('treats knowledge as a panel-backed view', () => {
@@ -18,4 +18,11 @@ describe('panel sidebar route helpers', () => {
     assert.equal(shouldAutoOpenPanelSidebar('settings', true), false)
     assert.equal(shouldAutoOpenPanelSidebar(null, true), false)
   })
+
+  it('registers quality as a full-width operator workspace', () => {
+    assert.equal(VIEW_LABELS.quality, 'Quality')
+    assert.match(VIEW_DESCRIPTIONS.quality, /evals/i)
+    assert.equal(FULL_WIDTH_VIEWS.has('quality'), true)
+    assert.equal(isPanelSidebarView('quality'), false)
+  })
 })

package/src/lib/app/view-constants.ts

@@ -11,6 +11,7 @@ export const VIEW_LABELS: Record<AppView, string> = {
   memory: 'Memory',
 
   tasks: 'Tasks',
+  quality: 'Quality',
   missions: 'Missions',
   secrets: 'Secrets',
   wallets: 'Wallets',
@@ -59,6 +60,7 @@ export const VIEW_DESCRIPTIONS: Record<AppView, string> = {
   memory: 'Long-term agent memory store',
 
   tasks: 'Task board for agent work and queued runs',
+  quality: 'Operator quality center for evals, approvals, run review, and release readiness',
   missions: 'Autonomous goal-driven agent runs with budgets and morning reports',
   secrets: 'API keys, tokens, and encrypted credentials',
   wallets: 'Crypto wallets for agent-initiated on-chain transactions',
@@ -118,6 +120,12 @@ export const VIEW_EMPTY_STATES: Record<Exclude<AppView, 'agents' | 'home'>, { ic
     description: 'A kanban board for managing agent work. Create tasks, assign them to agents, and track progress.',
     features: ['Kanban columns: Backlog, Queued, Running, Completed, Failed', 'Assign tasks to specific agents', 'Track retries, results, and logs', 'Review status without leaving the board'],
   },
+  quality: {
+    icon: 'badge-check',
+    title: 'Quality',
+    description: 'Operator center for trusting autonomous agents before, during, and after a release.',
+    features: ['Review run health, failed work, and pending approvals', 'Run scenario and suite evals against selected agents', 'Approve or reject human-loop, tool, connector, and skill requests', 'Inspect replay evidence from recent agent runs'],
+  },
   missions: {
     icon: 'target',
     title: 'Missions',
@@ -243,7 +251,7 @@ export const VIEW_EMPTY_STATES: Record<Exclude<AppView, 'agents' | 'home'>, { ic
 export const FULL_WIDTH_VIEWS = new Set<AppView>([
   'home', 'org_chart', 'inbox', 'chatrooms', 'protocols', 'schedules', 'secrets', 'wallets', 'providers', 'skills',
   'connectors', 'webhooks', 'mcp_servers', 'knowledge', 'extensions',
-  'usage', 'runs', 'autonomy', 'logs', 'settings', 'activity', 'projects', 'swarmfeed', 'marketplace', 'missions',
+  'usage', 'runs', 'quality', 'autonomy', 'logs', 'settings', 'activity', 'projects', 'swarmfeed', 'marketplace', 'missions',
 ])
 
 export const PANEL_SIDEBAR_VIEWS = new Set<AppView>([

package/src/lib/quality/quality-summary.test.ts

@@ -0,0 +1,122 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import {
+  buildQualityOverviewSummary,
+  groupApprovalsByCategory,
+  summarizeEvalRuns,
+  summarizeRunHealth,
+} from './quality-summary'
+import type { EvalRun } from '@/lib/server/eval/types'
+import type { ApprovalRequest, 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 || 'hello',
+    queuedAt: overrides.queuedAt ?? 1000,
+    ...overrides,
+  }
+}
+
+function evalRun(overrides: Partial<EvalRun>): EvalRun {
+  return {
+    id: overrides.id || 'eval_1',
+    scenarioId: overrides.scenarioId || 'coding-prime',
+    agentId: overrides.agentId || 'agent_1',
+    status: overrides.status || 'completed',
+    startedAt: overrides.startedAt ?? 1000,
+    endedAt: overrides.endedAt,
+    score: overrides.score ?? 8,
+    maxScore: overrides.maxScore ?? 10,
+    details: overrides.details || [],
+    sessionId: overrides.sessionId,
+    error: overrides.error,
+  }
+}
+
+function approval(overrides: Partial<ApprovalRequest>): ApprovalRequest {
+  return {
+    id: overrides.id || 'approval_1',
+    category: overrides.category || 'human_loop',
+    title: overrides.title || 'Review request',
+    description: overrides.description,
+    data: overrides.data || {},
+    createdAt: overrides.createdAt ?? 1000,
+    updatedAt: overrides.updatedAt ?? 1000,
+    status: overrides.status || 'pending',
+    agentId: overrides.agentId,
+    sessionId: overrides.sessionId,
+    taskId: overrides.taskId,
+  }
+}
+
+describe('summarizeRunHealth', () => {
+  it('counts run statuses and keeps the most recent failed runs', () => {
+    const summary = summarizeRunHealth([
+      run({ id: 'old-failed', status: 'failed', queuedAt: 1000 }),
+      run({ id: 'running', status: 'running', queuedAt: 2000 }),
+      run({ id: 'new-failed', status: 'failed', queuedAt: 3000 }),
+      run({ id: 'completed', status: 'completed', queuedAt: 4000 }),
+    ])
+
+    assert.equal(summary.total, 4)
+    assert.equal(summary.byStatus.failed, 2)
+    assert.equal(summary.byStatus.running, 1)
+    assert.equal(summary.activeCount, 1)
+    assert.equal(summary.needsAttentionCount, 2)
+    assert.deepEqual(summary.recentFailures.map((item) => item.id), ['new-failed', 'old-failed'])
+  })
+})
+
+describe('summarizeEvalRuns', () => {
+  it('summarizes completed evals and ignores failed runs for score averages', () => {
+    const summary = summarizeEvalRuns([
+      evalRun({ id: 'low', score: 4, maxScore: 10, startedAt: 2000 }),
+      evalRun({ id: 'failed', status: 'failed', score: 0, maxScore: 10, startedAt: 3000 }),
+      evalRun({ id: 'high', score: 9, maxScore: 10, startedAt: 4000 }),
+    ])
+
+    assert.equal(summary.totalRuns, 3)
+    assert.equal(summary.completedRuns, 2)
+    assert.equal(summary.failedRuns, 1)
+    assert.equal(summary.latestRun?.id, 'high')
+    assert.equal(summary.averagePercent, 65)
+    assert.equal(summary.latestCompletedPercent, 90)
+  })
+})
+
+describe('groupApprovalsByCategory', () => {
+  it('groups pending approvals and sorts oldest first inside each category', () => {
+    const grouped = groupApprovalsByCategory([
+      approval({ id: 'new-human', category: 'human_loop', createdAt: 3000 }),
+      approval({ id: 'approved-skill', category: 'extension_install', status: 'approved', createdAt: 1000 }),
+      approval({ id: 'old-human', category: 'human_loop', createdAt: 1000 }),
+      approval({ id: 'tool', category: 'tool_access', createdAt: 2000 }),
+    ])
+
+    assert.equal(grouped.totalPending, 3)
+    assert.deepEqual(grouped.categories.map((category) => category.category), ['human_loop', 'tool_access'])
+    assert.deepEqual(grouped.categories[0].approvals.map((item) => item.id), ['old-human', 'new-human'])
+  })
+})
+
+describe('buildQualityOverviewSummary', () => {
+  it('combines runs, evals, and approvals into operator action counts', () => {
+    const summary = buildQualityOverviewSummary({
+      runs: [run({ status: 'failed' }), run({ status: 'running' })],
+      evalRuns: [evalRun({ score: 7, maxScore: 10 })],
+      approvals: [approval({}), approval({ status: 'rejected' })],
+    })
+
+    assert.equal(summary.needsAttention, 2)
+    assert.equal(summary.pendingApprovals, 1)
+    assert.equal(summary.activeRuns, 1)
+    assert.equal(summary.evalAveragePercent, 70)
+  })
+})

package/src/lib/quality/quality-summary.ts

@@ -0,0 +1,150 @@
+import type { EvalRun } from '@/lib/server/eval/types'
+import type { ApprovalCategory, ApprovalRequest, SessionRunRecord, SessionRunStatus } from '@/types'
+
+const RUN_STATUSES: SessionRunStatus[] = ['queued', 'running', 'completed', 'failed', 'cancelled']
+
+export interface RunHealthSummary {
+  total: number
+  byStatus: Record<SessionRunStatus, number>
+  activeCount: number
+  needsAttentionCount: number
+  recentFailures: SessionRunRecord[]
+}
+
+export interface EvalRunSummary {
+  totalRuns: number
+  completedRuns: number
+  failedRuns: number
+  averagePercent: number | null
+  latestCompletedPercent: number | null
+  latestRun: EvalRun | null
+}
+
+export interface ApprovalCategoryGroup {
+  category: ApprovalCategory
+  count: number
+  approvals: ApprovalRequest[]
+}
+
+export interface ApprovalGroupSummary {
+  totalPending: number
+  categories: ApprovalCategoryGroup[]
+}
+
+export interface QualityOverviewSummary {
+  runHealth: RunHealthSummary
+  evals: EvalRunSummary
+  approvals: ApprovalGroupSummary
+  needsAttention: number
+  pendingApprovals: number
+  activeRuns: number
+  evalAveragePercent: number | null
+}
+
+function newestRunTimestamp(run: SessionRunRecord): number {
+  return run.endedAt ?? run.startedAt ?? run.queuedAt
+}
+
+function evalTimestamp(run: EvalRun): number {
+  return run.endedAt ?? run.startedAt
+}
+
+function percent(score: number, maxScore: number): number | null {
+  if (!Number.isFinite(score) || !Number.isFinite(maxScore) || maxScore <= 0) return null
+  return Math.round((score / maxScore) * 100)
+}
+
+export function summarizeRunHealth(runs: SessionRunRecord[], opts: { recentFailureLimit?: number } = {}): RunHealthSummary {
+  const byStatus = RUN_STATUSES.reduce((acc, status) => {
+    acc[status] = 0
+    return acc
+  }, {} as Record<SessionRunStatus, number>)
+
+  for (const run of runs) {
+    byStatus[run.status] = (byStatus[run.status] ?? 0) + 1
+  }
+
+  const recentFailures = runs
+    .filter((run) => run.status === 'failed')
+    .slice()
+    .sort((a, b) => newestRunTimestamp(b) - newestRunTimestamp(a))
+    .slice(0, opts.recentFailureLimit ?? 5)
+
+  return {
+    total: runs.length,
+    byStatus,
+    activeCount: byStatus.queued + byStatus.running,
+    needsAttentionCount: byStatus.failed,
+    recentFailures,
+  }
+}
+
+export function summarizeEvalRuns(runs: EvalRun[]): EvalRunSummary {
+  const latestRun = runs.length
+    ? runs.slice().sort((a, b) => evalTimestamp(b) - evalTimestamp(a))[0]
+    : null
+  const completed = runs.filter((run) => run.status === 'completed')
+  const failedRuns = runs.filter((run) => run.status === 'failed').length
+  const completedPercents = completed
+    .map((run) => percent(run.score, run.maxScore))
+    .filter((value): value is number => value !== null)
+
+  const latestCompleted = completed.length
+    ? completed.slice().sort((a, b) => evalTimestamp(b) - evalTimestamp(a))[0]
+    : null
+  const latestCompletedPercent = latestCompleted
+    ? percent(latestCompleted.score, latestCompleted.maxScore)
+    : null
+
+  return {
+    totalRuns: runs.length,
+    completedRuns: completed.length,
+    failedRuns,
+    averagePercent: completedPercents.length
+      ? Math.round(completedPercents.reduce((sum, value) => sum + value, 0) / completedPercents.length)
+      : null,
+    latestCompletedPercent,
+    latestRun,
+  }
+}
+
+export function groupApprovalsByCategory(approvals: ApprovalRequest[]): ApprovalGroupSummary {
+  const pending = approvals
+    .filter((approval) => approval.status === 'pending')
+    .slice()
+    .sort((a, b) => a.createdAt - b.createdAt)
+  const groups = new Map<ApprovalCategory, ApprovalRequest[]>()
+
+  for (const approval of pending) {
+    const items = groups.get(approval.category) ?? []
+    items.push(approval)
+    groups.set(approval.category, items)
+  }
+
+  return {
+    totalPending: pending.length,
+    categories: Array.from(groups.entries())
+      .map(([category, items]) => ({ category, count: items.length, approvals: items }))
+      .sort((a, b) => b.count - a.count || a.category.localeCompare(b.category)),
+  }
+}
+
+export function buildQualityOverviewSummary(params: {
+  runs: SessionRunRecord[]
+  evalRuns: EvalRun[]
+  approvals: ApprovalRequest[]
+}): QualityOverviewSummary {
+  const runHealth = summarizeRunHealth(params.runs)
+  const evals = summarizeEvalRuns(params.evalRuns)
+  const approvals = groupApprovalsByCategory(params.approvals)
+
+  return {
+    runHealth,
+    evals,
+    approvals,
+    needsAttention: runHealth.needsAttentionCount + evals.failedRuns + approvals.totalPending,
+    pendingApprovals: approvals.totalPending,
+    activeRuns: runHealth.activeCount,
+    evalAveragePercent: evals.averagePercent,
+  }
+}

package/src/lib/server/missions/mission-templates.test.ts

@@ -74,6 +74,28 @@ describe('mission-templates: registry', () => {
     assert.ok(template.defaults.successCriteria.some((item) => item.includes('Product Hunt')))
   })
 
+  it('includes operator quality release templates', () => {
+    const expected = [
+      'release-candidate-qa',
+      'agent-cost-audit',
+      'connector-smoke-test',
+      'failed-run-triage',
+      'weekly-agent-quality-report',
+    ]
+
+    for (const id of expected) {
+      const template = templates.getMissionTemplate(id)
+      assert.ok(template, `expected ${id} template`)
+      assert.ok(template.tags.includes('quality') || template.tags.includes('operator-quality'), `${id} should be quality tagged`)
+      assert.ok(template.defaults.goal.includes('approval') || template.defaults.goal.includes('evidence'), `${id} should preserve operator guardrails`)
+      assert.ok(template.defaults.budget.maxWallclockSec, `${id} should have a wallclock cap`)
+      assert.ok(template.defaults.reportSchedule, `${id} should schedule reports`)
+    }
+
+    assert.equal(templates.getMissionTemplate('release-candidate-qa')?.name, 'Release Candidate QA')
+    assert.equal(templates.getMissionTemplate('weekly-agent-quality-report')?.category, 'monitoring')
+  })
+
   it('getMissionTemplate resolves known ids', () => {
     const list = templates.listMissionTemplates()
     const first = list[0]

package/src/lib/server/missions/mission-templates.ts

@@ -187,6 +187,122 @@ export const BUILT_IN_MISSION_TEMPLATES: MissionTemplate[] = [
       reportSchedule: report(12 * HOUR),
     },
   },
+  {
+    id: 'release-candidate-qa',
+    name: 'Release Candidate QA',
+    description:
+      'Collect release readiness evidence across evals, approvals, failed runs, docs, packaging, and desktop smoke gates.',
+    icon: '✅',
+    category: 'productivity',
+    tags: ['release', 'qa', 'evals', 'operator-quality'],
+    setupNote:
+      'Set the target version and release branch in the goal. Keep publishing, tagging, and merging behind explicit human approval.',
+    defaults: {
+      title: 'Release Candidate QA',
+      goal:
+        'Prepare a release candidate quality report for the target SwarmClaw version. Review recent failed runs, pending approvals, latest eval results, release notes, package metadata, install instructions, CI/build status, and desktop packaging notes. Summarize blockers, risk level, evidence links, and a go/no-go recommendation. Do not merge, tag, publish, deploy, or post publicly without explicit approval.',
+      successCriteria: [
+        'Failed runs and pending approvals are reviewed with evidence or clear no-findings notes',
+        'Eval coverage, score trends, and any failed criteria are summarized',
+        'Release notes, package metadata, install pins, and desktop smoke requirements are checked',
+        'Final report includes blockers, risks, follow-up tasks, and a go/no-go recommendation',
+      ],
+      budget: budget({ maxUsd: 2, maxTokens: 120_000, maxTurns: 160, maxWallclockSec: DAY }),
+      reportSchedule: report(6 * HOUR),
+    },
+  },
+  {
+    id: 'agent-cost-audit',
+    name: 'Agent Cost Audit',
+    description:
+      'Inspect agent/provider spend, token usage, and high-cost runs, then recommend budget or routing adjustments.',
+    icon: '💸',
+    category: 'monitoring',
+    tags: ['cost', 'usage', 'budget', 'quality'],
+    setupNote:
+      'Add any budget targets, providers, or agents that need special attention before starting.',
+    defaults: {
+      title: 'Agent Cost Audit',
+      goal:
+        'Audit recent SwarmClaw agent costs and token usage. Identify top-spend agents, expensive runs, provider anomalies, retry loops, and avoidable tool calls. Produce a markdown report with recommended budget caps, model routing changes, and follow-up quality checks. Do not change budgets or provider settings without approval.',
+      successCriteria: [
+        'Top cost drivers are listed with agent, provider, source, and supporting evidence',
+        'At least 3 concrete cost-control recommendations are included',
+        'Any suspected runaway, retry, or noisy automation pattern is flagged',
+      ],
+      budget: budget({ maxUsd: 1.5, maxTokens: 80_000, maxTurns: 100, maxWallclockSec: DAY }),
+      reportSchedule: report(DAY),
+    },
+  },
+  {
+    id: 'connector-smoke-test',
+    name: 'Connector Smoke Test',
+    description:
+      'Verify configured connector health, delivery paths, approval boundaries, and recent connector-linked run evidence.',
+    icon: '🔌',
+    category: 'monitoring',
+    tags: ['connectors', 'smoke-test', 'approval', 'quality'],
+    setupNote:
+      'Name the connectors and channels to test. Keep outbound messages or public replies approval-gated.',
+    defaults: {
+      title: 'Connector Smoke Test',
+      goal:
+        'Smoke test configured SwarmClaw connectors. Check connector status, recent inbound/outbound activity, approval requirements, related failed runs, and any available logs. Draft a concise pass/fail report per connector with evidence and remediation steps. Do not send public replies or change connector settings without approval.',
+      successCriteria: [
+        'Each targeted connector receives a pass, warn, or fail status',
+        'Recent connector-linked failures or delivery issues are summarized with evidence',
+        'Approval boundaries for outbound replies or sender permissions are explicitly checked',
+      ],
+      budget: budget({ maxUsd: 1.25, maxTokens: 70_000, maxTurns: 90, maxWallclockSec: 12 * HOUR }),
+      reportSchedule: report(6 * HOUR),
+    },
+  },
+  {
+    id: 'failed-run-triage',
+    name: 'Failed Run Triage',
+    description:
+      'Review recent failed runs, cluster root causes, and propose fixes with replay evidence.',
+    icon: '🧯',
+    category: 'support',
+    tags: ['runs', 'triage', 'debugging', 'quality'],
+    setupNote:
+      'Optionally narrow the mission to a source, agent, task, or release window.',
+    defaults: {
+      title: 'Failed Run Triage',
+      goal:
+        'Triage recent failed SwarmClaw runs. Inspect run records, replay events, errors, retrieval evidence, source, owner, and timing. Cluster failures by likely root cause and write a prioritized remediation report with reproduction notes where possible. Do not modify code or settings unless explicitly asked.',
+      successCriteria: [
+        'Recent failed runs are grouped by likely root cause',
+        'Each high-priority failure includes evidence from the run record or replay',
+        'Remediation recommendations are prioritized by user impact and confidence',
+      ],
+      budget: budget({ maxUsd: 1.5, maxTokens: 90_000, maxTurns: 120, maxWallclockSec: DAY }),
+      reportSchedule: report(6 * HOUR),
+    },
+  },
+  {
+    id: 'weekly-agent-quality-report',
+    name: 'Weekly Agent Quality Report',
+    description:
+      'Produce a weekly operator report across eval trends, approvals, failed runs, missions, cost, and release risk.',
+    icon: '📈',
+    category: 'monitoring',
+    tags: ['weekly', 'quality', 'report', 'evals'],
+    setupNote:
+      'Set the week or workspace scope in the goal if you want a narrower report.',
+    defaults: {
+      title: 'Weekly Agent Quality Report',
+      goal:
+        'Produce a weekly SwarmClaw agent quality report. Summarize eval trends, failed and recovered runs, pending or high-risk approvals, mission outcomes, cost changes, connector health, and release-readiness risks. Include a short executive summary and a prioritized action list for the next week.',
+      successCriteria: [
+        'Report includes eval, run, approval, mission, connector, and cost sections',
+        'Top quality risks and regressions are clearly ranked',
+        'Next-week action items are specific and tied to evidence',
+      ],
+      budget: budget({ maxUsd: 3, maxTokens: 180_000, maxTurns: 180, maxWallclockSec: 7 * DAY }),
+      reportSchedule: report(DAY),
+    },
+  },
   {
     id: 'hello-world-demo',
     name: 'Hello World Demo',

package/src/types/session.ts

@@ -231,4 +231,4 @@ export type SessionTool =
   | 'crawl'
 
 export type SessionType = 'human'
-export type AppView = 'home' | 'agents' | 'org_chart' | 'inbox' | 'chatrooms' | 'protocols' | 'schedules' | 'memory' | 'tasks' | 'secrets' | 'wallets' | 'providers' | 'skills' | 'connectors' | 'webhooks' | 'mcp_servers' | 'knowledge' | 'extensions' | 'usage' | 'runs' | 'autonomy' | 'logs' | 'settings' | 'projects' | 'activity' | 'swarmfeed' | 'marketplace' | 'missions'
+export type AppView = 'home' | 'agents' | 'org_chart' | 'inbox' | 'chatrooms' | 'protocols' | 'schedules' | 'memory' | 'tasks' | 'quality' | 'secrets' | 'wallets' | 'providers' | 'skills' | 'connectors' | 'webhooks' | 'mcp_servers' | 'knowledge' | 'extensions' | 'usage' | 'runs' | 'autonomy' | 'logs' | 'settings' | 'projects' | 'activity' | 'swarmfeed' | 'marketplace' | 'missions'