@swarmclawai/swarmclaw 1.9.7 → 1.9.9

package/src/components/schedules/schedule-console.tsx

@@ -14,10 +14,10 @@ import { api } from '@/lib/app/api-client'
 import { archiveSchedule, purgeSchedule, restoreSchedule, runSchedule, updateSchedule } from '@/lib/schedules/schedules'
 import { cronToHuman } from '@/lib/schedules/cron-human'
 import { timeAgo, timeUntil } from '@/lib/time-format'
-import type { BoardTask, ProtocolRun, Schedule, ScheduleStatus } from '@/types'
+import type { BoardTask, ProtocolRun, Schedule, ScheduleHistoryEntry, ScheduleStatus } from '@/types'
 import { toast } from 'sonner'
 
-type ScheduleScope = 'live' | 'archived' | 'runs'
+type ScheduleScope = 'live' | 'archived' | 'runs' | 'history'
 type ScheduleFilterStatus = 'all' | ScheduleStatus
 type ScheduleRunStatusFilter = 'all' | Extract<BoardTask['status'], 'queued' | 'running' | 'completed' | 'failed' | 'cancelled'>
 type ScheduleCadenceFilter = 'all' | Schedule['scheduleType']
@@ -35,6 +35,12 @@ type ScheduleConsoleRunRow = {
   scheduleId: string | null
   scheduleName: string
 }
+type ScheduleHistoryRow = {
+  id: string
+  schedule: Schedule
+  entry: ScheduleHistoryEntry
+  searchText: string
+}
 
 const STATUS_STYLES: Record<string, string> = {
   active: 'bg-emerald-500/12 text-emerald-400 border-emerald-500/20',
@@ -139,6 +145,38 @@ function protocolRunPreview(run: ProtocolRun): string {
   return (goal || run.title || 'Structured session run').slice(0, 180)
 }
 
+function historyActionLabel(action: ScheduleHistoryEntry['action']): string {
+  switch (action) {
+    case 'created':
+      return 'Created'
+    case 'updated':
+      return 'Updated'
+    case 'archived':
+      return 'Archived'
+    case 'restored':
+      return 'Restored'
+    case 'run_started':
+      return 'Run started'
+    case 'skipped':
+      return 'Skipped'
+    case 'failed':
+      return 'Failed'
+    default:
+      return action
+  }
+}
+
+function historyActionBadge(action: ScheduleHistoryEntry['action']): string {
+  if (action === 'created' || action === 'restored' || action === 'run_started') return badgeClass('completed')
+  if (action === 'failed') return badgeClass('failed')
+  if (action === 'skipped' || action === 'archived') return badgeClass('paused')
+  return badgeClass('running')
+}
+
+function formatHistoryValue(value: string | null | undefined): string {
+  return value == null || value === '' ? 'empty' : value
+}
+
 function ActionButton(
   props: ButtonHTMLAttributes<HTMLButtonElement> & { tone?: 'default' | 'danger' },
 ) {
@@ -337,6 +375,42 @@ export function ScheduleConsole() {
       .sort((a, b) => b.updatedAt - a.updatedAt)
   }, [agentFilter, agents, cadenceFilter, projectScopedProtocolRuns, projectScopedRuns, runStatusFilter, schedules, search])
 
+  const filteredHistory = useMemo<ScheduleHistoryRow[]>(() => {
+    const q = search.trim().toLowerCase()
+    return projectScopedSchedules
+      .filter((schedule) => {
+        if (statusFilter !== 'all' && schedule.status !== statusFilter) return false
+        if (cadenceFilter !== 'all' && schedule.scheduleType !== cadenceFilter) return false
+        if (agentFilter !== 'all' && schedule.agentId !== agentFilter) return false
+        return true
+      })
+      .flatMap((schedule) => {
+        const agentName = agents[schedule.agentId]?.name || ''
+        const history = Array.isArray(schedule.history) ? schedule.history : []
+        return history.map((entry) => {
+          const changeText = Array.isArray(entry.changes)
+            ? entry.changes.map((change) => [change.label, change.before, change.after].filter(Boolean).join(' ')).join(' ')
+            : ''
+          return {
+            id: `${schedule.id}:${entry.id}`,
+            schedule,
+            entry,
+            searchText: [
+              schedule.name,
+              schedule.taskPrompt,
+              agentName,
+              entry.summary,
+              entry.actor,
+              historyActionLabel(entry.action),
+              changeText,
+            ].filter(Boolean).join(' ').toLowerCase(),
+          }
+        })
+      })
+      .filter((row) => !q || row.searchText.includes(q))
+      .sort((a, b) => b.entry.at - a.entry.at || b.entry.revision - a.entry.revision)
+  }, [agentFilter, agents, cadenceFilter, projectScopedSchedules, search, statusFilter])
+
   const handleArchive = async (scheduleId: string) => {
     setBusyId(scheduleId)
     try {
@@ -432,7 +506,11 @@ export function ScheduleConsole() {
     setSortBy('nextRunAt')
   }
 
-  const scopeCount = scope === 'runs' ? filteredRuns.length : filteredSchedules.length
+  const scopeCount = scope === 'runs'
+    ? filteredRuns.length
+    : scope === 'history'
+      ? filteredHistory.length
+      : filteredSchedules.length
 
   if (!loaded) {
     return <PageLoader label="Loading schedules..." />
@@ -464,6 +542,7 @@ export function ScheduleConsole() {
                   <FilterPill label="Live" active={scope === 'live'} onClick={() => setScope('live')} />
                   <FilterPill label="Archived" active={scope === 'archived'} onClick={() => setScope('archived')} />
                   <FilterPill label="Runs" active={scope === 'runs'} onClick={() => setScope('runs')} />
+                  <FilterPill label="History" active={scope === 'history'} onClick={() => setScope('history')} />
                 </div>
               </div>
               <div className="w-full lg:max-w-[360px]">
@@ -472,7 +551,11 @@ export function ScheduleConsole() {
                   value={search}
                   onChange={(e) => setSearch(e.target.value)}
                   onClear={() => setSearch('')}
-                  placeholder={scope === 'runs' ? 'Search runs, schedules, or agents...' : 'Search schedules, agents, or recipients...'}
+                  placeholder={scope === 'runs'
+                    ? 'Search runs, schedules, or agents...'
+                    : scope === 'history'
+                      ? 'Search history, schedules, or changes...'
+                      : 'Search schedules, agents, or recipients...'}
                 />
               </div>
             </div>
@@ -544,7 +627,7 @@ export function ScheduleConsole() {
                 </select>
               </label>
 
-              {scope !== 'runs' ? (
+              {scope !== 'runs' && scope !== 'history' ? (
                 <label className="text-[12px] text-text-3/70">
                   <span className="block mb-1.5 font-600 uppercase tracking-[0.08em] text-[10px]">Delivery</span>
                   <select
@@ -562,16 +645,26 @@ export function ScheduleConsole() {
 
               <label className="text-[12px] text-text-3/70">
                 <span className="block mb-1.5 font-600 uppercase tracking-[0.08em] text-[10px]">Sort</span>
-                <select
-                  value={sortBy}
-                  onChange={(e) => setSortBy(e.target.value as ScheduleSortBy)}
-                  className="w-full px-3 py-2.5 rounded-[12px] border border-white/[0.06] bg-surface text-text-2"
-                >
-                  <option value="nextRunAt">Next run</option>
-                  <option value="lastRunAt">Last run</option>
-                  <option value="updatedAt">Recently updated</option>
-                  <option value="name">Name</option>
-                </select>
+                {scope === 'history' ? (
+                  <select
+                    value="history"
+                    disabled
+                    className="w-full px-3 py-2.5 rounded-[12px] border border-white/[0.06] bg-surface text-text-3"
+                  >
+                    <option value="history">Newest changes</option>
+                  </select>
+                ) : (
+                  <select
+                    value={sortBy}
+                    onChange={(e) => setSortBy(e.target.value as ScheduleSortBy)}
+                    className="w-full px-3 py-2.5 rounded-[12px] border border-white/[0.06] bg-surface text-text-2"
+                  >
+                    <option value="nextRunAt">Next run</option>
+                    <option value="lastRunAt">Last run</option>
+                    <option value="updatedAt">Recently updated</option>
+                    <option value="name">Name</option>
+                  </select>
+                )}
               </label>
 
               <div className="flex items-end">
@@ -628,6 +721,71 @@ export function ScheduleConsole() {
                 )
               })}
             </div>
+          ) : scope === 'history' ? (
+            <div className="divide-y divide-white/[0.05]">
+              {filteredHistory.length === 0 ? (
+                <div className="px-5 py-10 text-center text-text-3/60">No schedule history matches the current filters.</div>
+              ) : filteredHistory.map((row) => {
+                const { schedule, entry } = row
+                const agent = agents[schedule.agentId]
+                const changes = Array.isArray(entry.changes) ? entry.changes.slice(0, 4) : []
+                const remainingChanges = Math.max(0, (entry.changes?.length || 0) - changes.length)
+                return (
+                  <div key={row.id} className="px-5 py-4 hover:bg-white/[0.02] transition-colors">
+                    <div className="flex flex-col gap-3 xl:flex-row xl:items-start xl:justify-between">
+                      <div className="min-w-0">
+                        <div className="flex flex-wrap items-center gap-2 mb-1.5">
+                          <span className={`px-2 py-0.5 rounded-[8px] border text-[10px] font-700 uppercase tracking-[0.08em] ${historyActionBadge(entry.action)}`}>
+                            {historyActionLabel(entry.action)}
+                          </span>
+                          <span className="text-[11px] text-text-3/60 uppercase tracking-[0.08em]">{schedule.scheduleType}</span>
+                          <span className="text-[11px] text-text-3/40 uppercase tracking-[0.08em]">rev {entry.revision}</span>
+                        </div>
+                        <div className="text-[15px] font-600 text-text-2">{schedule.name}</div>
+                        <div className="text-[13px] text-text-3 mt-1 line-clamp-2">{entry.summary}</div>
+                        {changes.length > 0 && (
+                          <div className="mt-3 grid grid-cols-1 md:grid-cols-2 gap-2">
+                            {changes.map((change) => (
+                              <div key={`${entry.id}:${change.field}`} className="rounded-[10px] border border-white/[0.06] bg-white/[0.025] px-3 py-2">
+                                <div className="text-[10px] uppercase tracking-[0.08em] text-text-3/50 font-700">{change.label}</div>
+                                <div className="mt-1 text-[12px] text-text-2 break-words">
+                                  <span className="text-text-3">{formatHistoryValue(change.before)}</span>
+                                  <span className="mx-1.5 text-text-3/40">-&gt;</span>
+                                  <span>{formatHistoryValue(change.after)}</span>
+                                </div>
+                              </div>
+                            ))}
+                            {remainingChanges > 0 && (
+                              <div className="rounded-[10px] border border-white/[0.06] bg-white/[0.025] px-3 py-2 text-[12px] text-text-3">
+                                {remainingChanges} more change{remainingChanges === 1 ? '' : 's'}
+                              </div>
+                            )}
+                          </div>
+                        )}
+                        <div className="flex flex-wrap items-center gap-2 mt-3">
+                          {agent && (
+                            <div className="inline-flex items-center gap-2 rounded-[10px] bg-white/[0.03] px-2.5 py-1.5 text-[12px] text-text-2">
+                              <AgentAvatar
+                                seed={agent.avatarSeed}
+                                avatarUrl={agent.avatarUrl}
+                                name={agent.name}
+                                size={16}
+                              />
+                              <span>{agent.name}</span>
+                            </div>
+                          )}
+                          <span className="text-[12px] text-text-3/60">{timeAgo(entry.at, now)}</span>
+                          <span className="text-[12px] text-text-3/50">Actor: {entry.actor}</span>
+                        </div>
+                      </div>
+                      <div className="flex flex-wrap items-center gap-2 shrink-0">
+                        <ActionButton onClick={() => openSchedule(schedule.id)}>Open Schedule</ActionButton>
+                      </div>
+                    </div>
+                  </div>
+                )
+              })}
+            </div>
           ) : (
             <div className="divide-y divide-white/[0.05]">
               {filteredSchedules.length === 0 ? (

package/src/lib/quality/release-readiness.test.ts

@@ -0,0 +1,129 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import { buildReleaseReadinessReport } from './release-readiness'
+import type { EvalGateResult } from '@/lib/server/eval/types'
+import type { OperationPulse } from '@/types'
+
+const now = 100_000
+
+function pulse(overrides: Partial<OperationPulse> = {}): OperationPulse {
+  return {
+    generatedAt: now,
+    range: '24h',
+    windowStart: now - 86_400_000,
+    kpis: {
+      activeMissions: 0,
+      runningRuns: 0,
+      failedRuns: 0,
+      pendingApprovals: 0,
+      connectorAttention: 0,
+      gatewayAttention: 0,
+      budgetWarnings: 0,
+    },
+    actions: [],
+    ...overrides,
+  }
+}
+
+function evalGate(overrides: Partial<EvalGateResult> = {}): EvalGateResult {
+  return {
+    agentId: 'agent_1',
+    scope: {
+      type: 'suite',
+      id: 'core',
+      label: 'core',
+      scenarioIds: ['coding-prime'],
+    },
+    status: 'pass',
+    generatedAt: now,
+    baseline: null,
+    latestRuns: [],
+    currentScore: 10,
+    currentMaxScore: 10,
+    currentPercent: 100,
+    regressionPoints: 0,
+    minPercent: 80,
+    maxRegressionPoints: 5,
+    checks: [{ code: 'score_threshold_met', status: 'pass', message: 'Current score meets the 80% gate.' }],
+    ...overrides,
+  }
+}
+
+describe('release readiness report', () => {
+  it('passes when eval gate and operations pulse are clean', () => {
+    const report = buildReleaseReadinessReport({
+      pulse: pulse(),
+      evalGate: evalGate(),
+    })
+
+    assert.equal(report.status, 'ready')
+    assert.equal(report.score, 100)
+    assert.equal(report.blockerCount, 0)
+    assert.equal(report.warningCount, 0)
+    assert.ok(report.checks.some((check) => check.code === 'eval_gate_passed'))
+  })
+
+  it('warns when no eval gate is selected', () => {
+    const report = buildReleaseReadinessReport({
+      pulse: pulse(),
+      evalGate: null,
+    })
+
+    assert.equal(report.status, 'warning')
+    assert.equal(report.blockerCount, 0)
+    assert.equal(report.warningCount, 1)
+    assert.ok(report.score < 100)
+    assert.ok(report.checks.some((check) => check.code === 'eval_gate_missing'))
+  })
+
+  it('blocks when eval regression gate fails', () => {
+    const report = buildReleaseReadinessReport({
+      pulse: pulse(),
+      evalGate: evalGate({
+        status: 'fail',
+        currentPercent: 60,
+        checks: [{ code: 'score_below_threshold', status: 'fail', message: 'Current score is below the 80% gate.' }],
+      }),
+    })
+
+    assert.equal(report.status, 'blocked')
+    assert.equal(report.blockerCount, 1)
+    assert.ok(report.score <= 70)
+    assert.ok(report.checks.some((check) => check.code === 'eval_gate_failed'))
+  })
+
+  it('blocks on failed runs and pending approvals, then surfaces pulse actions', () => {
+    const report = buildReleaseReadinessReport({
+      pulse: pulse({
+        kpis: {
+          activeMissions: 1,
+          runningRuns: 1,
+          failedRuns: 2,
+          pendingApprovals: 3,
+          connectorAttention: 1,
+          gatewayAttention: 1,
+          budgetWarnings: 1,
+        },
+        actions: [{
+          id: 'run:failed',
+          kind: 'run',
+          severity: 'high',
+          title: 'Review failed run',
+          summary: 'Run failed',
+          href: '/quality?tab=runs',
+          evidence: ['run'],
+          createdAt: now,
+        }],
+      }),
+      evalGate: evalGate(),
+    })
+
+    assert.equal(report.status, 'blocked')
+    assert.equal(report.blockerCount, 2)
+    assert.ok(report.warningCount >= 4)
+    assert.equal(report.nextActions[0]?.id, 'run:failed')
+    assert.ok(report.checks.some((check) => check.code === 'failed_runs_present'))
+    assert.ok(report.checks.some((check) => check.code === 'pending_approvals_present'))
+  })
+})

package/src/lib/quality/release-readiness.ts

@@ -0,0 +1,187 @@
+import type { EvalGateResult } from '@/lib/server/eval/types'
+import type { OperationPulse, OperationPulseAction, OperationPulseRange } from '@/types'
+
+export type ReleaseReadinessStatus = 'ready' | 'warning' | 'blocked'
+
+export interface ReleaseReadinessCheck {
+  code: string
+  status: ReleaseReadinessStatus
+  title: string
+  summary: string
+  href?: string
+  evidence?: string[]
+}
+
+export interface ReleaseReadinessReport {
+  generatedAt: number
+  range: OperationPulseRange
+  status: ReleaseReadinessStatus
+  score: number
+  blockerCount: number
+  warningCount: number
+  pulse: OperationPulse
+  evalGate: EvalGateResult | null
+  checks: ReleaseReadinessCheck[]
+  nextActions: OperationPulseAction[]
+}
+
+const BLOCKER_PENALTY = 30
+const WARNING_PENALTY = 10
+
+function readinessStatus(checks: ReleaseReadinessCheck[]): ReleaseReadinessStatus {
+  if (checks.some((check) => check.status === 'blocked')) return 'blocked'
+  if (checks.some((check) => check.status === 'warning')) return 'warning'
+  return 'ready'
+}
+
+function readinessScore(checks: ReleaseReadinessCheck[]): number {
+  const penalty = checks.reduce((sum, check) => {
+    if (check.status === 'blocked') return sum + BLOCKER_PENALTY
+    if (check.status === 'warning') return sum + WARNING_PENALTY
+    return sum
+  }, 0)
+  return Math.max(0, 100 - penalty)
+}
+
+function plural(count: number, singular: string, pluralLabel = `${singular}s`): string {
+  return `${count} ${count === 1 ? singular : pluralLabel}`
+}
+
+function addCheck(checks: ReleaseReadinessCheck[], check: ReleaseReadinessCheck): void {
+  checks.push(check)
+}
+
+export function buildReleaseReadinessReport(input: {
+  pulse: OperationPulse
+  evalGate?: EvalGateResult | null
+}): ReleaseReadinessReport {
+  const checks: ReleaseReadinessCheck[] = []
+  const evalGate = input.evalGate ?? null
+
+  if (!evalGate) {
+    addCheck(checks, {
+      code: 'eval_gate_missing',
+      status: 'warning',
+      title: 'Select an eval gate',
+      summary: 'No eval regression gate is included in this readiness report.',
+      href: '/quality?tab=evals',
+    })
+  } else if (evalGate.status === 'fail') {
+    addCheck(checks, {
+      code: 'eval_gate_failed',
+      status: 'blocked',
+      title: 'Eval gate failed',
+      summary: `${evalGate.scope.label} is not passing the configured eval release gate.`,
+      href: '/quality?tab=evals',
+      evidence: evalGate.checks
+        .filter((check) => check.status === 'fail')
+        .map((check) => check.message),
+    })
+  } else if (evalGate.status === 'warn') {
+    addCheck(checks, {
+      code: 'eval_gate_warning',
+      status: 'warning',
+      title: 'Eval gate needs a baseline',
+      summary: `${evalGate.scope.label} passes the score threshold but still has release-gate warnings.`,
+      href: '/quality?tab=evals',
+      evidence: evalGate.checks
+        .filter((check) => check.status === 'warn')
+        .map((check) => check.message),
+    })
+  } else {
+    addCheck(checks, {
+      code: 'eval_gate_passed',
+      status: 'ready',
+      title: 'Eval gate passed',
+      summary: `${evalGate.scope.label} meets the configured score and regression checks.`,
+      href: '/quality?tab=evals',
+      evidence: [`${evalGate.currentPercent ?? 'n/a'}% current score`],
+    })
+  }
+
+  if (input.pulse.kpis.failedRuns > 0) {
+    addCheck(checks, {
+      code: 'failed_runs_present',
+      status: 'blocked',
+      title: 'Failed runs need review',
+      summary: `${plural(input.pulse.kpis.failedRuns, 'failed run')} found in the ${input.pulse.range} operations window.`,
+      href: '/quality?tab=runs',
+    })
+  }
+
+  if (input.pulse.kpis.pendingApprovals > 0) {
+    addCheck(checks, {
+      code: 'pending_approvals_present',
+      status: 'blocked',
+      title: 'Pending approvals need decisions',
+      summary: `${plural(input.pulse.kpis.pendingApprovals, 'approval')} still waiting on an operator.`,
+      href: '/quality?tab=approvals',
+    })
+  }
+
+  if (input.pulse.kpis.runningRuns > 0) {
+    addCheck(checks, {
+      code: 'active_runs_present',
+      status: 'warning',
+      title: 'Runs are still active',
+      summary: `${plural(input.pulse.kpis.runningRuns, 'run')} queued or running while this report was generated.`,
+      href: '/runs',
+    })
+  }
+
+  if (input.pulse.kpis.connectorAttention > 0) {
+    addCheck(checks, {
+      code: 'connector_attention_present',
+      status: 'warning',
+      title: 'Connector readiness needs attention',
+      summary: `${plural(input.pulse.kpis.connectorAttention, 'connector')} reporting degraded readiness.`,
+      href: '/connectors',
+    })
+  }
+
+  if (input.pulse.kpis.gatewayAttention > 0) {
+    addCheck(checks, {
+      code: 'gateway_attention_present',
+      status: 'warning',
+      title: 'Gateway readiness needs attention',
+      summary: `${plural(input.pulse.kpis.gatewayAttention, 'gateway')} reporting topology or environment warnings.`,
+      href: '/providers',
+    })
+  }
+
+  if (input.pulse.kpis.budgetWarnings > 0) {
+    addCheck(checks, {
+      code: 'budget_warnings_present',
+      status: 'warning',
+      title: 'Mission budget pressure',
+      summary: `${plural(input.pulse.kpis.budgetWarnings, 'mission')} near a configured budget limit.`,
+      href: '/missions',
+    })
+  }
+
+  if (input.pulse.kpis.activeMissions > 0) {
+    addCheck(checks, {
+      code: 'active_missions_present',
+      status: 'warning',
+      title: 'Missions are still active',
+      summary: `${plural(input.pulse.kpis.activeMissions, 'mission')} running or paused in the operations window.`,
+      href: '/missions',
+    })
+  }
+
+  const blockerCount = checks.filter((check) => check.status === 'blocked').length
+  const warningCount = checks.filter((check) => check.status === 'warning').length
+
+  return {
+    generatedAt: input.pulse.generatedAt,
+    range: input.pulse.range,
+    status: readinessStatus(checks),
+    score: readinessScore(checks),
+    blockerCount,
+    warningCount,
+    pulse: input.pulse,
+    evalGate,
+    checks,
+    nextActions: input.pulse.actions.slice(0, 8),
+  }
+}

package/src/lib/schedules/schedules.ts

@@ -1,5 +1,5 @@
 import { api } from '@/lib/app/api-client'
-import type { Schedule } from '@/types'
+import type { Schedule, ScheduleHistoryEntry } from '@/types'
 
 export interface ScheduleArchiveResponse {
   ok: boolean
@@ -19,6 +19,12 @@ export interface SchedulePurgeResponse {
   purgedIds: string[]
 }
 
+export interface ScheduleHistoryResponse {
+  scheduleId: string
+  revision: number
+  history: ScheduleHistoryEntry[]
+}
+
 export const fetchSchedules = (includeArchived = false) =>
   api<Record<string, Schedule>>('GET', `/schedules${includeArchived ? '?includeArchived=true' : ''}`)
 
@@ -42,3 +48,6 @@ export const purgeSchedule = (id: string) =>
 
 export const runSchedule = (id: string) =>
   api<{ ok: boolean; queued?: boolean; reason?: string; taskId?: string; runNumber?: number }>('POST', `/schedules/${id}/run`)
+
+export const fetchScheduleHistory = (id: string) =>
+  api<ScheduleHistoryResponse>('GET', `/schedules/${id}/history`)