@swarmclawai/swarmclaw 0.5.1 → 0.5.2

package/src/lib/server/daemon-state.ts

@@ -1,4 +1,4 @@
-import { loadQueue, loadSchedules, loadSessions, saveSessions, loadConnectors } from './storage'
+import { loadQueue, loadSchedules, loadSessions, saveSessions, loadConnectors, saveConnectors, loadWebhookRetryQueue, upsertWebhookRetry, deleteWebhookRetry, loadWebhooks, loadAgents, appendWebhookLog } from './storage'
 import { notify } from './ws-hub'
 import { processNext, cleanupFinishedTaskSessions, validateCompletedTasksQueue, recoverStalledRunningTasks } from './queue'
 import { startScheduler, stopScheduler } from './scheduler'
@@ -13,6 +13,10 @@ import {
 } from './connectors/manager'
 import { startHeartbeatService, stopHeartbeatService, getHeartbeatServiceStatus } from './heartbeat-service'
 import { hasOpenClawAgents, ensureGatewayConnected, disconnectGateway, getGateway } from './openclaw-gateway'
+import { enqueueSessionRun } from './session-run-manager'
+import { WORKSPACE_DIR } from './data-dir'
+import { genId } from '@/lib/id'
+import type { WebhookRetryEntry } from '@/types'
 
 const QUEUE_CHECK_INTERVAL = 30_000 // 30 seconds
 const BROWSER_SWEEP_INTERVAL = 60_000 // 60 seconds
@@ -24,6 +28,7 @@ const STALE_AUTO_DISABLE_MULTIPLIER = 16 // auto-disable after much longer susta
 const STALE_AUTO_DISABLE_MIN_MS = 45 * 60 * 1000 // never auto-disable before 45 minutes
 const CONNECTOR_RESTART_BASE_MS = 30_000
 const CONNECTOR_RESTART_MAX_MS = 15 * 60 * 1000
+const MAX_WAKE_ATTEMPTS = 3
 
 function parseBoolish(value: unknown, fallback: boolean): boolean {
   if (typeof value === 'boolean') return value
@@ -70,16 +75,17 @@ const ds: {
   healthIntervalId: ReturnType<typeof setInterval> | null
   /** Session IDs we've already alerted as stale (alert-once semantics). */
   staleSessionIds: Set<string>
-  connectorRestartState: Map<string, { lastAttemptAt: number; failCount: number }>
+  connectorRestartState: Map<string, { lastAttemptAt: number; failCount: number; wakeAttempts: number }>
   manualStopRequested: boolean
   running: boolean
   lastProcessedAt: number | null
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 } = (globalThis as any)[gk] ?? ((globalThis as any)[gk] = {
   queueIntervalId: null,
   browserSweepId: null,
   healthIntervalId: null,
   staleSessionIds: new Set<string>(),
-  connectorRestartState: new Map<string, { lastAttemptAt: number; failCount: number }>(),
+  connectorRestartState: new Map<string, { lastAttemptAt: number; failCount: number; wakeAttempts: number }>(),
   manualStopRequested: false,
   running: false,
   lastProcessedAt: null,
@@ -87,8 +93,9 @@ const ds: {
 
 // Backfill fields for hot-reloaded daemon state objects from older code versions.
 if (!ds.staleSessionIds) ds.staleSessionIds = new Set<string>()
-if (!ds.connectorRestartState) ds.connectorRestartState = new Map<string, { lastAttemptAt: number; failCount: number }>()
+if (!ds.connectorRestartState) ds.connectorRestartState = new Map<string, { lastAttemptAt: number; failCount: number; wakeAttempts: number }>()
 // Migrate from old issueLastAlertAt map if present (HMR across code versions)
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 if ((ds as any).issueLastAlertAt) delete (ds as any).issueLastAlertAt
 if (ds.healthIntervalId === undefined) ds.healthIntervalId = null
 if (ds.manualStopRequested === undefined) ds.manualStopRequested = false
@@ -221,8 +228,8 @@ async function sendHealthAlert(text: string) {
 
 async function runConnectorHealthChecks(now: number) {
   const connectors = loadConnectors()
-  for (const connector of Object.values(connectors) as any[]) {
-    if (!connector?.id) continue
+  for (const connector of Object.values(connectors) as Record<string, unknown>[]) {
+    if (!connector?.id || typeof connector.id !== 'string') continue
     if (connector.isEnabled !== true) {
       ds.connectorRestartState.delete(connector.id)
       continue
@@ -234,7 +241,22 @@ async function runConnectorHealthChecks(now: number) {
       continue
     }
 
-    const current = ds.connectorRestartState.get(connector.id) || { lastAttemptAt: 0, failCount: 0 }
+    const current = ds.connectorRestartState.get(connector.id) || { lastAttemptAt: 0, failCount: 0, wakeAttempts: 0 }
+    // Backfill wakeAttempts for state objects created before this field existed
+    if (typeof current.wakeAttempts !== 'number') current.wakeAttempts = 0
+
+    // Cap wake attempts — stop retrying after MAX_WAKE_ATTEMPTS consecutive failures
+    if (current.wakeAttempts >= MAX_WAKE_ATTEMPTS) {
+      console.warn(`[health] Connector "${connector.name}" exceeded ${MAX_WAKE_ATTEMPTS} wake attempts — giving up`)
+      connector.status = 'error'
+      connector.lastError = `Auto-restart gave up after ${MAX_WAKE_ATTEMPTS} consecutive failures`
+      connector.updatedAt = Date.now()
+      connectors[connector.id] = connector
+      saveConnectors(connectors)
+      ds.connectorRestartState.delete(connector.id)
+      continue
+    }
+
     const backoffMs = Math.min(
       CONNECTOR_RESTART_MAX_MS,
       CONNECTOR_RESTART_BASE_MS * (2 ** Math.min(6, current.failCount)),
@@ -247,10 +269,154 @@ async function runConnectorHealthChecks(now: number) {
       await startConnector(connector.id)
       ds.connectorRestartState.delete(connector.id)
       await sendHealthAlert(`Connector "${connector.name}" (${connector.platform}) was down and has been auto-restarted.`)
-    } catch (err: any) {
+    } catch (err: unknown) {
       current.failCount += 1
+      current.wakeAttempts += 1
       ds.connectorRestartState.set(connector.id, current)
-      console.warn(`[health] Connector auto-restart failed for ${connector.name}: ${err?.message || String(err)}`)
+      const message = err instanceof Error ? err.message : String(err)
+      console.warn(`[health] Connector auto-restart failed for ${connector.name} (attempt ${current.wakeAttempts}/${MAX_WAKE_ATTEMPTS}): ${message}`)
+    }
+  }
+}
+
+async function processWebhookRetries() {
+  const retryQueue = loadWebhookRetryQueue()
+  const now = Date.now()
+  const dueEntries: WebhookRetryEntry[] = []
+
+  for (const raw of Object.values(retryQueue)) {
+    const entry = raw as WebhookRetryEntry
+    if (entry.deadLettered) continue
+    if (entry.nextRetryAt > now) continue
+    dueEntries.push(entry)
+  }
+
+  if (dueEntries.length === 0) return
+
+  const webhooks = loadWebhooks()
+  const agents = loadAgents()
+  const sessions = loadSessions()
+
+  for (const entry of dueEntries) {
+    const webhook = webhooks[entry.webhookId] as Record<string, unknown> | undefined
+    if (!webhook) {
+      // Webhook deleted — drop the retry
+      deleteWebhookRetry(entry.id)
+      continue
+    }
+
+    const agentId = typeof webhook.agentId === 'string' ? webhook.agentId : ''
+    const agent = agentId ? (agents[agentId] as Record<string, unknown> | undefined) : null
+    if (!agent) {
+      entry.deadLettered = true
+      upsertWebhookRetry(entry.id, entry)
+      console.warn(`[webhook-retry] Dead-lettered ${entry.id}: agent not found for webhook ${entry.webhookId}`)
+      continue
+    }
+
+    // Find or create a webhook session (same logic as the POST handler)
+    const sessionName = `webhook:${entry.webhookId}`
+    let session = Object.values(sessions).find(
+      (s: unknown) => {
+        const rec = s as Record<string, unknown>
+        return rec.name === sessionName && rec.agentId === agent.id
+      },
+    ) as Record<string, unknown> | undefined
+
+    if (!session) {
+      const sessionId = genId()
+      const ts = Date.now()
+      session = {
+        id: sessionId,
+        name: sessionName,
+        cwd: WORKSPACE_DIR,
+        user: 'system',
+        provider: agent.provider || 'claude-cli',
+        model: agent.model || '',
+        credentialId: agent.credentialId || null,
+        apiEndpoint: agent.apiEndpoint || null,
+        claudeSessionId: null,
+        codexThreadId: null,
+        opencodeSessionId: null,
+        delegateResumeIds: { claudeCode: null, codex: null, opencode: null },
+        messages: [],
+        createdAt: ts,
+        lastActiveAt: ts,
+        sessionType: 'orchestrated',
+        agentId: agent.id,
+        parentSessionId: null,
+        tools: agent.tools || [],
+        heartbeatEnabled: (agent.heartbeatEnabled as boolean | undefined) ?? true,
+        heartbeatIntervalSec: (agent.heartbeatIntervalSec as number | null | undefined) ?? null,
+      }
+      sessions[session.id as string] = session
+      const { saveSessions: save } = await import('./storage')
+      save(sessions)
+    }
+
+    const payloadPreview = (entry.payload || '').slice(0, 12_000)
+    const prompt = [
+      'Webhook event received (retry).',
+      `Webhook ID: ${entry.webhookId}`,
+      `Webhook Name: ${(webhook.name as string) || entry.webhookId}`,
+      `Source: ${(webhook.source as string) || 'custom'}`,
+      `Event: ${entry.event}`,
+      `Retry attempt: ${entry.attempts}`,
+      `Original received at: ${new Date(entry.createdAt).toISOString()}`,
+      '',
+      'Payload:',
+      payloadPreview || '(empty payload)',
+      '',
+      'Handle this event now. If this requires notifying the user, use configured connector tools.',
+    ].join('\n')
+
+    try {
+      const run = enqueueSessionRun({
+        sessionId: session.id as string,
+        message: prompt,
+        source: 'webhook',
+        internal: false,
+        mode: 'followup',
+      })
+
+      appendWebhookLog(genId(8), {
+        id: genId(8),
+        webhookId: entry.webhookId,
+        event: entry.event,
+        payload: (entry.payload || '').slice(0, 2000),
+        status: 'success',
+        sessionId: session.id,
+        runId: run.runId,
+        timestamp: Date.now(),
+      })
+
+      deleteWebhookRetry(entry.id)
+      console.log(`[webhook-retry] Successfully retried ${entry.id} for webhook ${entry.webhookId} (attempt ${entry.attempts})`)
+    } catch (err: unknown) {
+      const errorMsg = err instanceof Error ? err.message : String(err)
+      entry.attempts += 1
+
+      if (entry.attempts >= entry.maxAttempts) {
+        entry.deadLettered = true
+        upsertWebhookRetry(entry.id, entry)
+        console.warn(`[webhook-retry] Dead-lettered ${entry.id} after ${entry.attempts} attempts: ${errorMsg}`)
+
+        appendWebhookLog(genId(8), {
+          id: genId(8),
+          webhookId: entry.webhookId,
+          event: entry.event,
+          payload: (entry.payload || '').slice(0, 2000),
+          status: 'error',
+          error: `Dead-lettered after ${entry.attempts} attempts: ${errorMsg}`,
+          timestamp: Date.now(),
+        })
+      } else {
+        // Exponential backoff: 30s * 2^attempt + random jitter (0-5000ms)
+        const jitter = Math.floor(Math.random() * 5000)
+        entry.nextRetryAt = Date.now() + (30_000 * Math.pow(2, entry.attempts)) + jitter
+        upsertWebhookRetry(entry.id, entry)
+        console.warn(`[webhook-retry] Retry ${entry.id} failed (attempt ${entry.attempts}/${entry.maxAttempts}), next at ${new Date(entry.nextRetryAt).toISOString()}: ${errorMsg}`)
+      }
     }
   }
 }
@@ -268,10 +434,12 @@ async function runHealthChecks() {
   const currentlyStale = new Set<string>()
   let sessionsDirty = false
 
-  for (const session of Object.values(sessions) as any[]) {
-    if (!session?.id) continue
+  for (const session of Object.values(sessions) as Record<string, unknown>[]) {
+    if (!session?.id || typeof session.id !== 'string') continue
     if (session.heartbeatEnabled !== true) continue
 
+    const sessionId = session.id
+    const sessionLabel = String(session.name || sessionId)
     const intervalSec = parseHeartbeatIntervalSec(session.heartbeatIntervalSec, 120)
     if (intervalSec <= 0) continue
     const staleAfter = Math.max(intervalSec * STALE_MULTIPLIER * 1000, STALE_MIN_MS)
@@ -285,19 +453,19 @@ async function runHealthChecks() {
         session.heartbeatEnabled = false
         session.lastActiveAt = now
         sessionsDirty = true
-        ds.staleSessionIds.delete(session.id)
+        ds.staleSessionIds.delete(sessionId)
         await sendHealthAlert(
-          `Auto-disabled heartbeat for stale session "${session.name || session.id}" after ${Math.round(staleForMs / 60_000)}m of inactivity.`,
+          `Auto-disabled heartbeat for stale session "${sessionLabel}" after ${Math.round(staleForMs / 60_000)}m of inactivity.`,
         )
         continue
       }
 
-      currentlyStale.add(session.id)
+      currentlyStale.add(sessionId)
       // Only alert on transition from healthy → stale (once per stale episode)
-      if (!ds.staleSessionIds.has(session.id)) {
-        ds.staleSessionIds.add(session.id)
+      if (!ds.staleSessionIds.has(sessionId)) {
+        ds.staleSessionIds.add(sessionId)
         await sendHealthAlert(
-          `Session "${session.name || session.id}" heartbeat appears stale (last active ${(Math.round(staleForMs / 1000))}s ago, interval ${intervalSec}s).`,
+          `Session "${sessionLabel}" heartbeat appears stale (last active ${(Math.round(staleForMs / 1000))}s ago, interval ${intervalSec}s).`,
         )
       }
     }
@@ -313,6 +481,13 @@ async function runHealthChecks() {
   if (sessionsDirty) saveSessions(sessions)
 
   await runConnectorHealthChecks(now)
+
+  // Process webhook retry queue
+  try {
+    await processWebhookRetries()
+  } catch (err: unknown) {
+    console.error('[daemon] Webhook retry processing failed:', err instanceof Error ? err.message : String(err))
+  }
 }
 
 function startHealthMonitor() {
@@ -341,14 +516,20 @@ export function getDaemonStatus() {
 
   // Find next scheduled task
   let nextScheduled: number | null = null
-  for (const s of Object.values(schedules) as any[]) {
+  for (const s of Object.values(schedules) as Record<string, unknown>[]) {
     if (s.status === 'active' && s.nextRunAt) {
-      if (!nextScheduled || s.nextRunAt < nextScheduled) {
-        nextScheduled = s.nextRunAt
+      if (!nextScheduled || (s.nextRunAt as number) < nextScheduled) {
+        nextScheduled = s.nextRunAt as number
       }
     }
   }
 
+  // Webhook retry queue stats
+  const retryQueue = loadWebhookRetryQueue()
+  const retryEntries = Object.values(retryQueue) as WebhookRetryEntry[]
+  const pendingRetries = retryEntries.filter(e => !e.deadLettered).length
+  const deadLettered = retryEntries.filter(e => e.deadLettered).length
+
   return {
     running: ds.running,
     schedulerActive: ds.running,
@@ -364,5 +545,9 @@ export function getDaemonStatus() {
       connectorsInBackoff: ds.connectorRestartState.size,
       checkIntervalSec: Math.trunc(HEALTH_CHECK_INTERVAL / 1000),
     },
+    webhookRetry: {
+      pendingRetries,
+      deadLettered,
+    },
   }
 }

package/src/lib/server/queue.ts

@@ -501,6 +501,22 @@ export async function processNext() {
         continue
       }
 
+      // Dependency guard: skip tasks whose blockers are not all completed
+      const blockers = Array.isArray(task.blockedBy) ? task.blockedBy as string[] : []
+      if (blockers.length > 0) {
+        const allBlockersDone = blockers.every((bid) => {
+          const blocker = tasks[bid] as BoardTask | undefined
+          return blocker?.status === 'completed'
+        })
+        if (!allBlockersDone) {
+          // Put it back in the queue and skip
+          pushQueueUnique(queue, taskId)
+          saveQueue(queue)
+          console.log(`[queue] Skipping task "${task.title}" (${taskId}) — blocked by incomplete dependencies`)
+          continue
+        }
+      }
+
       const agents = loadAgents()
       const agent = agents[task.agentId]
       if (!agent) {

package/src/lib/server/storage.ts

@@ -49,6 +49,8 @@ const COLLECTIONS = [
   'mcp_servers',
   'webhook_logs',
   'projects',
+  'activity',
+  'webhook_retry_queue',
 ] as const
 
 for (const table of COLLECTIONS) {
@@ -741,6 +743,38 @@ export function appendWebhookLog(id: string, entry: any) {
   upsertCollectionItem('webhook_logs', id, entry)
 }
 
+// --- Activity / Audit Trail ---
+export function loadActivity(): Record<string, unknown> {
+  return loadCollection('activity')
+}
+
+export function logActivity(entry: {
+  entityType: string
+  entityId: string
+  action: string
+  actor: string
+  actorId?: string
+  summary: string
+  detail?: Record<string, unknown>
+}) {
+  const id = crypto.randomBytes(8).toString('hex')
+  const record = { id, ...entry, timestamp: Date.now() }
+  upsertCollectionItem('activity', id, record)
+}
+
+// --- Webhook Retry Queue ---
+export function loadWebhookRetryQueue(): Record<string, unknown> {
+  return loadCollection('webhook_retry_queue')
+}
+
+export function upsertWebhookRetry(id: string, entry: unknown) {
+  upsertCollectionItem('webhook_retry_queue', id, entry)
+}
+
+export function deleteWebhookRetry(id: string) {
+  deleteCollectionItem('webhook_retry_queue', id)
+}
+
 export function getSessionMessages(sessionId: string): Message[] {
   const stmt = db.prepare('SELECT data FROM sessions WHERE id = ?')
   const row = stmt.get(sessionId) as { data: string } | undefined

package/src/lib/view-routes.ts

@@ -20,6 +20,7 @@ export const VIEW_TO_PATH: Record<AppView, string> = {
   logs: '/logs',
   settings: '/settings',
   projects: '/projects',
+  activity: '/activity',
 }
 
 const entries = Object.entries(VIEW_TO_PATH) as [AppView, string][]

package/src/lib/ws-client.ts

@@ -31,11 +31,12 @@ function handleMessage(event: MessageEvent) {
 
 function scheduleReconnect() {
   if (reconnectTimer) return
+  const jitter = Math.random() * 2000
   reconnectTimer = setTimeout(() => {
     reconnectTimer = null
     if (!accessKey) return
     connect(accessKey)
-  }, reconnectDelay)
+  }, reconnectDelay + jitter)
   reconnectDelay = Math.min(reconnectDelay * 2, MAX_RECONNECT_DELAY)
 }
 

package/src/stores/use-app-store.ts

@@ -1,7 +1,7 @@
 'use client'
 
 import { create } from 'zustand'
-import type { Sessions, Session, NetworkInfo, Directory, ProviderInfo, Credentials, Agent, Schedule, AppView, BoardTask, AppSettings, OrchestratorSecret, ProviderConfig, Skill, Connector, Webhook, McpServerConfig, PluginMeta, Project, FleetFilter } from '../types'
+import type { Sessions, Session, NetworkInfo, Directory, ProviderInfo, Credentials, Agent, Schedule, AppView, BoardTask, AppSettings, OrchestratorSecret, ProviderConfig, Skill, Connector, Webhook, McpServerConfig, PluginMeta, Project, FleetFilter, ActivityEntry } from '../types'
 import { fetchSessions, fetchDirs, fetchProviders, fetchCredentials } from '../lib/sessions'
 import { fetchAgents } from '../lib/agents'
 import { fetchSchedules } from '../lib/schedules'
@@ -89,6 +89,8 @@ interface AppState {
 
   tasks: Record<string, BoardTask>
   loadTasks: (includeArchived?: boolean) => Promise<void>
+  optimisticUpdateTask: (taskId: string, patch: Partial<BoardTask>) => Promise<boolean>
+  optimisticDeleteTask: (taskId: string) => Promise<boolean>
   showArchivedTasks: boolean
   setShowArchivedTasks: (show: boolean) => void
   taskSheetOpen: boolean
@@ -178,6 +180,10 @@ interface AppState {
   fleetFilter: FleetFilter
   setFleetFilter: (filter: FleetFilter) => void
 
+  // Activity / Audit Trail
+  activityEntries: ActivityEntry[]
+  loadActivity: (filters?: { entityType?: string; limit?: number }) => Promise<void>
+
 }
 
 export const useAppStore = create<AppState>((set, get) => ({
@@ -394,6 +400,32 @@ export const useAppStore = create<AppState>((set, get) => ({
       // ignore
     }
   },
+  optimisticUpdateTask: async (taskId, patch) => {
+    const prev = get().tasks[taskId]
+    if (!prev) return false
+    set({ tasks: { ...get().tasks, [taskId]: { ...prev, ...patch, updatedAt: Date.now() } } })
+    try {
+      await api('PUT', `/tasks/${taskId}`, patch)
+      return true
+    } catch {
+      set({ tasks: { ...get().tasks, [taskId]: prev } })
+      return false
+    }
+  },
+  optimisticDeleteTask: async (taskId) => {
+    const prev = get().tasks[taskId]
+    if (!prev) return false
+    const next = { ...get().tasks }
+    delete next[taskId]
+    set({ tasks: next })
+    try {
+      await api('DELETE', `/tasks/${taskId}`)
+      return true
+    } catch {
+      set({ tasks: { ...get().tasks, [taskId]: prev } })
+      return false
+    }
+  },
   showArchivedTasks: false,
   setShowArchivedTasks: (show) => {
     set({ showArchivedTasks: show })
@@ -544,4 +576,19 @@ export const useAppStore = create<AppState>((set, get) => ({
   fleetFilter: 'all',
   setFleetFilter: (filter) => set({ fleetFilter: filter }),
 
+  // Activity / Audit Trail
+  activityEntries: [],
+  loadActivity: async (filters) => {
+    try {
+      const params = new URLSearchParams()
+      if (filters?.entityType) params.set('entityType', filters.entityType)
+      if (filters?.limit) params.set('limit', String(filters.limit))
+      const qs = params.toString()
+      const entries = await api<ActivityEntry[]>('GET', `/activity${qs ? `?${qs}` : ''}`)
+      set({ activityEntries: entries })
+    } catch {
+      // ignore
+    }
+  },
+
 }))

package/src/stores/use-approval-store.ts

@@ -6,6 +6,7 @@ import { api } from '@/lib/api-client'
 
 interface ApprovalState {
   approvals: Record<string, PendingExecApproval>
+  resolvedIds: Set<string>
   addApproval: (approval: PendingExecApproval) => void
   removeApproval: (id: string) => void
   resolveApproval: (id: string, decision: ExecApprovalDecision) => Promise<void>
@@ -15,6 +16,7 @@ interface ApprovalState {
 
 export const useApprovalStore = create<ApprovalState>((set) => ({
   approvals: {},
+  resolvedIds: new Set<string>(),
 
   addApproval: (approval) => {
     set((s) => ({ approvals: { ...s.approvals, [approval.id]: approval } }))
@@ -46,11 +48,23 @@ export const useApprovalStore = create<ApprovalState>((set) => ({
       })
     } catch (err: unknown) {
       const message = err instanceof Error ? err.message : String(err)
-      set((s) => {
-        const approval = s.approvals[id]
-        if (!approval) return s
-        return { approvals: { ...s.approvals, [id]: { ...approval, resolving: false, error: message } } }
-      })
+      const isConflict = message.includes('409') || message.includes('Already resolved')
+      if (isConflict) {
+        // Another session already resolved this — treat as success
+        set((s) => {
+          const next = { ...s.approvals }
+          delete next[id]
+          const nextResolved = new Set(s.resolvedIds)
+          nextResolved.add(id)
+          return { approvals: next, resolvedIds: nextResolved }
+        })
+      } else {
+        set((s) => {
+          const approval = s.approvals[id]
+          if (!approval) return s
+          return { approvals: { ...s.approvals, [id]: { ...approval, resolving: false, error: message } } }
+        })
+      }
     }
   },
 
@@ -59,7 +73,7 @@ export const useApprovalStore = create<ApprovalState>((set) => ({
     set((s) => {
       const next: Record<string, PendingExecApproval> = {}
       for (const [id, a] of Object.entries(s.approvals)) {
-        if (a.expiresAtMs > now) next[id] = a
+        if (a.expiresAtMs > now && !s.resolvedIds.has(id)) next[id] = a
       }
       return { approvals: next }
     })
@@ -70,7 +84,7 @@ export const useApprovalStore = create<ApprovalState>((set) => ({
       const result = await api<PendingExecApproval[]>('GET', '/openclaw/approvals')
       const approvals: Record<string, PendingExecApproval> = {}
       for (const a of result) approvals[a.id] = a
-      set({ approvals })
+      set({ approvals, resolvedIds: new Set<string>() })
     } catch {
       // ignore — gateway may be offline
     }

package/src/types/index.ts

@@ -336,7 +336,35 @@ export interface MemoryEntry {
 }
 
 export type SessionType = 'human' | 'orchestrated'
-export type AppView = 'agents' | 'schedules' | 'memory' | 'tasks' | 'secrets' | 'providers' | 'skills' | 'connectors' | 'webhooks' | 'mcp_servers' | 'knowledge' | 'plugins' | 'usage' | 'runs' | 'logs' | 'settings' | 'projects'
+export type AppView = 'agents' | 'schedules' | 'memory' | 'tasks' | 'secrets' | 'providers' | 'skills' | 'connectors' | 'webhooks' | 'mcp_servers' | 'knowledge' | 'plugins' | 'usage' | 'runs' | 'logs' | 'settings' | 'projects' | 'activity'
+
+// --- Activity / Audit Trail ---
+
+export interface ActivityEntry {
+  id: string
+  entityType: 'agent' | 'task' | 'connector' | 'session' | 'webhook' | 'schedule'
+  entityId: string
+  action: 'created' | 'updated' | 'deleted' | 'started' | 'stopped' | 'queued' | 'completed' | 'failed' | 'approved' | 'rejected'
+  actor: 'user' | 'agent' | 'system' | 'daemon'
+  actorId?: string
+  summary: string
+  detail?: Record<string, unknown>
+  timestamp: number
+}
+
+// --- Webhook Retry Queue ---
+
+export interface WebhookRetryEntry {
+  id: string
+  webhookId: string
+  event: string
+  payload: string
+  attempts: number
+  maxAttempts: number
+  nextRetryAt: number
+  deadLettered: boolean
+  createdAt: number
+}
 
 export interface Project {
   id: string
@@ -461,6 +489,8 @@ export interface AppSettings {
   // Web search provider
   webSearchProvider?: 'duckduckgo' | 'google' | 'bing' | 'searxng' | 'tavily' | 'brave'
   searxngUrl?: string
+  // Task custom field definitions
+  taskCustomFieldDefs?: Array<{ key: string; label: string; type: 'text' | 'number' | 'select'; options?: string[] }>
   // OpenClaw sync settings
   openclawWorkspacePath?: string | null
   openclawAutoSyncMemory?: boolean
@@ -630,6 +660,15 @@ export interface BoardTask {
     args: Record<string, unknown>
     threadId: string
   } | null
+  // Task dependencies (DAG)
+  blockedBy?: string[]
+  blocks?: string[]
+  // Task tags
+  tags?: string[]
+  // Due date
+  dueAt?: number | null
+  // Custom fields
+  customFields?: Record<string, string | number | boolean>
 }
 
 // --- MCP Servers ---