@swarmclawai/swarmclaw 0.6.6 → 0.6.7

package/src/lib/server/dag-validation.ts

@@ -0,0 +1,115 @@
+import type { BoardTask } from '@/types'
+
+interface DagResult {
+  valid: boolean
+  cycle?: string[]
+}
+
+/**
+ * Validate that adding `proposedBlockedBy` to `taskId` would not create a cycle
+ * in the task dependency graph. Uses DFS to check if `taskId` is reachable from
+ * any of its proposed blockers (which would mean a cycle).
+ */
+export function validateDag(
+  tasks: Record<string, BoardTask>,
+  taskId: string,
+  proposedBlockedBy: string[],
+): DagResult {
+  // Build adjacency: task -> tasks it is blocked by (its dependencies)
+  // We temporarily add the proposed edges: taskId is blocked by proposedBlockedBy
+  // A cycle exists if we can reach taskId by following blockedBy edges from any
+  // of the proposed blockers.
+
+  // DFS from each proposed blocker, following existing blockedBy edges.
+  // If we reach taskId, we have a cycle.
+  for (const startId of proposedBlockedBy) {
+    if (startId === taskId) {
+      return { valid: false, cycle: [taskId, taskId] }
+    }
+
+    const visited = new Set<string>()
+    const path: string[] = []
+    const found = dfs(tasks, startId, taskId, visited, path)
+    if (found) {
+      // path contains the route from startId to taskId
+      // The full cycle is: taskId -> startId -> ... -> taskId
+      return { valid: false, cycle: [taskId, ...path] }
+    }
+  }
+
+  return { valid: true }
+}
+
+/**
+ * DFS through the blockedBy graph starting from `current`, looking for `target`.
+ * Returns true if target is found, and populates `path` with the route.
+ */
+function dfs(
+  tasks: Record<string, BoardTask>,
+  current: string,
+  target: string,
+  visited: Set<string>,
+  path: string[],
+): boolean {
+  if (visited.has(current)) return false
+  visited.add(current)
+  path.push(current)
+
+  const task = tasks[current]
+  if (!task) {
+    path.pop()
+    return false
+  }
+
+  const blockers = Array.isArray(task.blockedBy) ? task.blockedBy : []
+  for (const blockerId of blockers) {
+    if (blockerId === target) {
+      path.push(blockerId)
+      return true
+    }
+    if (dfs(tasks, blockerId, target, visited, path)) {
+      return true
+    }
+  }
+
+  path.pop()
+  return false
+}
+
+/**
+ * After a task completes, find all tasks that were blocked by it and check
+ * if all their blockers are now done. If so, auto-queue them.
+ * Returns the IDs of tasks that were unblocked.
+ */
+export function cascadeUnblock(
+  tasks: Record<string, BoardTask>,
+  completedTaskId: string,
+): string[] {
+  const completedTask = tasks[completedTaskId]
+  if (!completedTask || completedTask.status !== 'completed') return []
+
+  const unblocked: string[] = []
+  const blockedIds = Array.isArray(completedTask.blocks) ? completedTask.blocks : []
+
+  for (const blockedId of blockedIds) {
+    const blocked = tasks[blockedId]
+    if (!blocked) continue
+    // Only auto-queue tasks that are in backlog (waiting on dependencies)
+    if (blocked.status !== 'backlog') continue
+
+    const deps = Array.isArray(blocked.blockedBy) ? blocked.blockedBy : []
+    const allDone = deps.every((depId) => {
+      const dep = tasks[depId]
+      return dep?.status === 'completed'
+    })
+
+    if (allDone) {
+      blocked.status = 'queued'
+      blocked.queuedAt = Date.now()
+      blocked.updatedAt = Date.now()
+      unblocked.push(blockedId)
+    }
+  }
+
+  return unblocked
+}

package/src/lib/server/memory-db.ts

@@ -1192,21 +1192,26 @@ export function addKnowledge(params: {
   agentIds?: string[]
   createdByAgentId?: string | null
   createdBySessionId?: string | null
+  source?: string
+  sourceUrl?: string
 }): MemoryEntry {
   const db = getMemoryDb()
+  const metadata: Record<string, unknown> = {
+    tags: params.tags || [],
+    scope: params.scope || 'global',
+    agentIds: params.scope === 'agent' ? (params.agentIds || []) : [],
+    createdByAgentId: params.createdByAgentId || null,
+    createdBySessionId: params.createdBySessionId || null,
+  }
+  if (params.source) metadata.source = params.source
+  if (params.sourceUrl) metadata.sourceUrl = params.sourceUrl
   return db.add({
     agentId: null,
     sessionId: null,
     category: 'knowledge',
     title: params.title,
     content: params.content,
-    metadata: {
-      tags: params.tags || [],
-      scope: params.scope || 'global',
-      agentIds: params.scope === 'agent' ? (params.agentIds || []) : [],
-      createdByAgentId: params.createdByAgentId || null,
-      createdBySessionId: params.createdBySessionId || null,
-    },
+    metadata,
   })
 }
 

package/src/lib/server/openclaw-doctor.ts

@@ -0,0 +1,48 @@
+import { execFile } from 'child_process'
+import { promisify } from 'util'
+import * as path from 'path'
+import * as os from 'os'
+import { loadSettings } from './storage'
+
+const execFileAsync = promisify(execFile)
+
+export interface DoctorResult {
+  ok: boolean
+  output: string
+  fixed: boolean
+}
+
+function resolveWorkspacePath(override?: string): string {
+  if (override) return override
+  const settings = loadSettings()
+  if (typeof settings.openclawWorkspacePath === 'string' && settings.openclawWorkspacePath.trim()) {
+    return settings.openclawWorkspacePath.trim()
+  }
+  return path.join(os.homedir(), '.openclaw', 'workspace')
+}
+
+export async function runOpenClawDoctor(opts?: { fix?: boolean; workspace?: string }): Promise<DoctorResult> {
+  const workspace = resolveWorkspacePath(opts?.workspace)
+  const args = ['doctor']
+  if (opts?.fix) args.push('--fix')
+
+  try {
+    const { stdout, stderr } = await execFileAsync('openclaw', args, {
+      cwd: workspace,
+      timeout: 30_000,
+      maxBuffer: 256 * 1024,
+    })
+    return {
+      ok: true,
+      output: (stdout + stderr).trim(),
+      fixed: !!opts?.fix,
+    }
+  } catch (err: unknown) {
+    const execErr = err as { code?: number; stdout?: string; stderr?: string; message?: string }
+    return {
+      ok: false,
+      output: ((execErr.stdout || '') + (execErr.stderr || '') || execErr.message || String(err)).trim(),
+      fixed: false,
+    }
+  }
+}

package/src/lib/server/queue.ts

@@ -12,6 +12,7 @@ import { executeSessionChatTurn } from './chat-execution'
 import { extractTaskResult, formatResultBody } from './task-result'
 import { getCheckpointSaver } from './langgraph-checkpoint'
 import { isProtectedMainSession } from './main-session'
+import { cascadeUnblock } from './dag-validation'
 import type { Agent, BoardTask, Connector, Message } from '@/types'
 
 // HMR-safe: pin processing flag to globalThis so hot reloads don't reset it
@@ -1111,6 +1112,17 @@ export async function processNext() {
           getCheckpointSaver().deleteThread(taskId).catch((e) =>
             console.warn(`[queue] Failed to clean up checkpoints for task ${taskId}:`, e)
           )
+          // Cascade unblock: auto-queue tasks whose blockers are all done
+          const latestTasks = loadTasks()
+          const unblockedIds = cascadeUnblock(latestTasks, taskId)
+          if (unblockedIds.length > 0) {
+            saveTasks(latestTasks)
+            for (const uid of unblockedIds) {
+              enqueueTask(uid)
+              console.log(`[queue] Auto-unblocked task "${latestTasks[uid]?.title}" (${uid})`)
+            }
+            notify('tasks')
+          }
           console.log(`[queue] Task "${task.title}" completed`)
         } else {
           if (doneTask?.status === 'queued') {

package/src/lib/server/session-run-manager.ts

@@ -85,6 +85,17 @@ function registerRun(run: SessionRunRecord) {
   trimRecentRuns()
 }
 
+/** Chain an external AbortSignal to an internal AbortController so that
+ *  when the caller (e.g. HTTP request) disconnects, the run is cancelled. */
+function chainCallerSignal(callerSignal: AbortSignal, controller: AbortController): void {
+  if (callerSignal.aborted) {
+    controller.abort()
+    return
+  }
+  const onAbort = () => controller.abort()
+  callerSignal.addEventListener('abort', onAbort, { once: true })
+}
+
 function emitToSubscribers(entry: QueueEntry, event: SSEEvent) {
   for (const send of entry.onEvents) {
     try {
@@ -347,6 +358,8 @@ export interface EnqueueSessionRunInput {
   modelOverride?: string
   heartbeatConfig?: { ackMaxChars: number; showOk: boolean; showAlerts: boolean; target: string | null }
   replyToId?: string
+  /** External abort signal (e.g. from the HTTP request) — chained to the run's internal AbortController */
+  callerSignal?: AbortSignal
 }
 
 export interface EnqueueSessionRunResult {
@@ -355,6 +368,8 @@ export interface EnqueueSessionRunResult {
   deduped?: boolean
   coalesced?: boolean
   promise: Promise<ExecuteChatTurnResult>
+  /** Abort the run's internal AbortController (cancels the LLM stream). */
+  abort: () => void
 }
 
 export function enqueueSessionRun(input: EnqueueSessionRunInput): EnqueueSessionRunResult {
@@ -371,11 +386,13 @@ export function enqueueSessionRun(input: EnqueueSessionRunInput): EnqueueSession
   const dedupe = findDedupeMatch(input.sessionId, input.dedupeKey)
   if (dedupe) {
     if (input.onEvent) dedupe.onEvents.push(input.onEvent)
+    if (input.callerSignal) chainCallerSignal(input.callerSignal, dedupe.signalController)
     return {
       runId: dedupe.run.id,
       position: 0,
       deduped: true,
       promise: dedupe.promise,
+      abort: () => dedupe.signalController.abort(),
     }
   }
 
@@ -413,12 +430,14 @@ export function enqueueSessionRun(input: EnqueueSessionRunInput): EnqueueSession
         candidate.run.queuedAt = nowMs
       }
       if (input.onEvent) candidate.onEvents.push(input.onEvent)
+      if (input.callerSignal) chainCallerSignal(input.callerSignal, candidate.signalController)
       emitRunMeta(candidate, 'queued', { position: 0, coalesced: true, mergedIntoRunId: candidate.run.id })
       return {
         runId: candidate.run.id,
         position: 0,
         coalesced: true,
         promise: candidate.promise,
+        abort: () => candidate.signalController.abort(),
       }
     }
   }
@@ -463,12 +482,14 @@ export function enqueueSessionRun(input: EnqueueSessionRunInput): EnqueueSession
     promise,
   }
 
+  if (input.callerSignal) chainCallerSignal(input.callerSignal, entry.signalController)
+
   q.push(entry)
   const position = (running ? 1 : 0) + q.length - 1
   emitRunMeta(entry, 'queued', { position })
   void drainExecution(executionKey)
 
-  return { runId, position, promise }
+  return { runId, position, promise, abort: () => entry.signalController.abort() }
 }
 
 export function getSessionRunState(sessionId: string): {

package/src/lib/server/session-tools/index.ts

@@ -22,6 +22,7 @@ import { buildCanvasTools } from './canvas'
 import { buildHttpTools } from './http'
 import { buildGitTools } from './git'
 import { buildWalletTools } from './wallet'
+import { buildOpenClawWorkspaceTools } from './openclaw-workspace'
 
 export type { ToolContext, SessionToolsResult }
 export { sweepOrphanedBrowsers, cleanupSessionBrowser, getActiveBrowserCount, hasActiveBrowser }
@@ -111,6 +112,7 @@ export async function buildSessionTools(cwd: string, enabledTools: string[], ctx
     ...buildHttpTools(bctx),
     ...buildGitTools(bctx),
     ...buildWalletTools(bctx),
+    ...buildOpenClawWorkspaceTools(bctx),
   )
 
   // ---------------------------------------------------------------------------

package/src/lib/server/session-tools/memory.ts

@@ -165,12 +165,16 @@ export function buildMemoryTools(bctx: ToolBuildContext): StructuredToolInterfac
             if (action === 'knowledge_store') {
               const { addKnowledge } = await import('../memory-db')
               if (!value) return 'Error: value (content) is required for knowledge_store'
+              const source = (input as Record<string, unknown>).source as string | undefined
+              const sourceUrl = (input as Record<string, unknown>).sourceUrl as string | undefined
               const entry = addKnowledge({
                 title: key || 'Untitled',
                 content: value,
                 tags: tags,
                 createdByAgentId: ctx?.agentId || null,
                 createdBySessionId: ctx?.sessionId || null,
+                source: source || undefined,
+                sourceUrl: sourceUrl || undefined,
               })
               return `Knowledge stored: "${entry.title}" (id: ${entry.id})`
             }
@@ -178,11 +182,24 @@ export function buildMemoryTools(bctx: ToolBuildContext): StructuredToolInterfac
               const { searchKnowledge } = await import('../memory-db')
               const results = searchKnowledge(query || key || '', tags, 10)
               if (!results.length) return 'No knowledge entries found.'
-              return results.map(r => `[${r.id}] ${r.title}: ${r.content.slice(0, 200)}`).join('\n---\n')
+              return results.map(r => {
+                const meta = r.metadata as Record<string, unknown> | undefined
+                const src = meta?.source as string | undefined
+                const srcUrl = meta?.sourceUrl as string | undefined
+                let line = `[${r.id}] ${r.title}: ${r.content.slice(0, 200)}`
+                if (src && srcUrl) {
+                  line += ` [${src}](${srcUrl})`
+                } else if (src) {
+                  line += ` (source: ${src})`
+                } else if (srcUrl) {
+                  line += ` (${srcUrl})`
+                }
+                return line
+              }).join('\n---\n')
             }
             return `Unknown action "${action}". Use: store, get, search, list, delete, link, unlink, knowledge_store, or knowledge_search.`
-          } catch (err: any) {
-            return `Error: ${err.message}`
+          } catch (err: unknown) {
+            return `Error: ${err instanceof Error ? err.message : String(err)}`
           }
         },
         {
@@ -224,6 +241,8 @@ export function buildMemoryTools(bctx: ToolBuildContext): StructuredToolInterfac
             linkedLimit: z.number().optional().describe('Max linked memories expanded during traversal. Respects configured server cap.'),
             targetIds: z.array(z.string()).optional().describe('Memory IDs to link/unlink (for link/unlink actions)'),
             tags: z.array(z.string()).optional().describe('Tags for categorizing knowledge entries'),
+            source: z.string().optional().describe("Source of the knowledge, e.g. 'user', 'web', 'document'"),
+            sourceUrl: z.string().optional().describe('URL where the knowledge was sourced from'),
             pinned: z.boolean().optional().describe('Mark memory as pinned (always preloaded in agent context). For store action.'),
             sharedWith: z.array(z.string()).optional().describe('Agent IDs to share this memory with (for store action). They can read it in their context.'),
           }),

package/src/lib/server/session-tools/openclaw-workspace.ts

@@ -0,0 +1,132 @@
+import { z } from 'zod'
+import { tool, type StructuredToolInterface } from '@langchain/core/tools'
+import { execFile } from 'child_process'
+import { promisify } from 'util'
+import * as path from 'path'
+import * as os from 'os'
+import { loadSettings } from '../storage'
+import type { ToolBuildContext } from './context'
+import { MAX_OUTPUT } from './context'
+
+const execFileAsync = promisify(execFile)
+
+function resolveWorkspacePath(): string {
+  const settings = loadSettings()
+  if (typeof settings.openclawWorkspacePath === 'string' && settings.openclawWorkspacePath.trim()) {
+    return settings.openclawWorkspacePath.trim()
+  }
+  return path.join(os.homedir(), '.openclaw', 'workspace')
+}
+
+async function gitInWorkspace(args: string[], timeoutMs = 15_000): Promise<{ stdout: string; stderr: string }> {
+  const cwd = resolveWorkspacePath()
+  return execFileAsync('git', args, {
+    cwd,
+    timeout: timeoutMs,
+    maxBuffer: MAX_OUTPUT,
+    env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+  })
+}
+
+export function buildOpenClawWorkspaceTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  if (!bctx.hasTool('openclaw_workspace')) return []
+
+  return [
+    tool(
+      async ({ message }) => {
+        try {
+          const workspace = resolveWorkspacePath()
+          // Verify it's a git repo
+          await execFileAsync('git', ['rev-parse', '--is-inside-work-tree'], {
+            cwd: workspace,
+            timeout: 5000,
+          })
+
+          const label = message || new Date().toISOString().replace(/[:.]/g, '-')
+          await gitInWorkspace(['add', '-A'])
+
+          // Check if there's anything to commit
+          const status = await gitInWorkspace(['status', '--porcelain'])
+          if (!status.stdout.trim()) {
+            return JSON.stringify({ ok: true, commitHash: null, message: 'Nothing to commit — workspace is clean.' })
+          }
+
+          await gitInWorkspace(['commit', '-m', `backup: ${label}`])
+          const { stdout } = await gitInWorkspace(['rev-parse', 'HEAD'])
+          return JSON.stringify({ ok: true, commitHash: stdout.trim() })
+        } catch (err: unknown) {
+          const execErr = err as { stderr?: string; message?: string }
+          return JSON.stringify({ ok: false, error: execErr.stderr || execErr.message || String(err) })
+        }
+      },
+      {
+        name: 'openclaw_workspace_backup',
+        description: 'Create a git backup of the OpenClaw workspace. Stages all changes and commits.',
+        schema: z.object({
+          message: z.string().optional().describe('Optional backup message (defaults to timestamp)'),
+        }),
+      },
+    ),
+    tool(
+      async ({ commitHash }) => {
+        try {
+          if (!commitHash) {
+            // Find first stable commit (skip auto-generated ones)
+            const { stdout } = await gitInWorkspace(['log', '--oneline', '--format=%H %s', '-50'])
+            const lines = stdout.trim().split('\n').filter(Boolean)
+            const autoPattern = /^(rollback|daily-backup|auto-backup|guardian-auto|backup:)/i
+            const stable = lines.find((line) => {
+              const msg = line.substring(41) // after hash + space
+              return !autoPattern.test(msg)
+            })
+            if (!stable) {
+              return JSON.stringify({ ok: false, error: 'No stable commit found to roll back to.' })
+            }
+            commitHash = stable.substring(0, 40)
+          }
+
+          const { stdout: prevHead } = await gitInWorkspace(['rev-parse', 'HEAD'])
+          await gitInWorkspace(['reset', '--hard', commitHash])
+          return JSON.stringify({ ok: true, rolledBackTo: commitHash, previousHead: prevHead.trim() })
+        } catch (err: unknown) {
+          const execErr = err as { stderr?: string; message?: string }
+          return JSON.stringify({ ok: false, error: execErr.stderr || execErr.message || String(err) })
+        }
+      },
+      {
+        name: 'openclaw_workspace_rollback',
+        description: 'Roll back the OpenClaw workspace to a specific commit, or automatically find the last stable (non-auto-generated) commit.',
+        schema: z.object({
+          commitHash: z.string().optional().describe('Target commit hash (if omitted, uses the last stable commit)'),
+        }),
+      },
+    ),
+    tool(
+      async ({ limit }) => {
+        try {
+          const count = Math.max(1, Math.min(limit ?? 20, 100))
+          const { stdout } = await gitInWorkspace(['log', '--oneline', `--format=%H %s`, `-${count}`])
+          const commits = stdout
+            .trim()
+            .split('\n')
+            .filter(Boolean)
+            .map((line) => ({
+              hash: line.substring(0, 40),
+              message: line.substring(41),
+            }))
+          return JSON.stringify({ commits })
+        } catch (err: unknown) {
+          const execErr = err as { stderr?: string; message?: string }
+          return JSON.stringify({ ok: false, error: execErr.stderr || execErr.message || String(err) })
+        }
+      },
+      {
+        name: 'openclaw_workspace_history',
+        description: 'List recent git commits in the OpenClaw workspace.',
+        schema: z.object({
+          limit: z.number().optional().describe('Number of commits to return (default 20, max 100)'),
+        }),
+      },
+    ),
+  ]
+}

package/src/lib/server/storage.ts

@@ -9,6 +9,100 @@ import type { Message } from '@/types'
 import { ensureMainSessionFlag } from './main-session'
 export const UPLOAD_DIR = path.join(DATA_DIR, 'uploads')
 
+// --- LRU Cache ---
+
+const DEFAULT_LRU_CAPACITY = 5000
+
+/** Per-collection capacity overrides from COLLECTION_CACHE_LIMITS env var (JSON). */
+function parseCacheLimits(): Record<string, number> {
+  const raw = process.env.COLLECTION_CACHE_LIMITS
+  if (!raw) return {}
+  try {
+    const parsed: unknown = JSON.parse(raw)
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return {}
+    const result: Record<string, number> = {}
+    for (const [k, v] of Object.entries(parsed as Record<string, unknown>)) {
+      if (typeof v === 'number' && v > 0) result[k] = v
+    }
+    return result
+  } catch {
+    return {}
+  }
+}
+
+const cacheLimits = parseCacheLimits()
+
+function capacityFor(collection: string): number {
+  return cacheLimits[collection] ?? DEFAULT_LRU_CAPACITY
+}
+
+/**
+ * A Map wrapper with LRU eviction. JS Maps iterate in insertion order,
+ * so the *first* key is the least-recently-used entry.
+ */
+class LRUMap<K, V> {
+  private readonly map = new Map<K, V>()
+  readonly capacity: number
+
+  constructor(capacity: number) {
+    this.capacity = Math.max(1, capacity)
+  }
+
+  get(key: K): V | undefined {
+    if (!this.map.has(key)) return undefined
+    const value = this.map.get(key)!
+    // Move to end (most-recently-used)
+    this.map.delete(key)
+    this.map.set(key, value)
+    return value
+  }
+
+  set(key: K, value: V): this {
+    if (this.map.has(key)) {
+      this.map.delete(key)
+    }
+    this.map.set(key, value)
+    // Evict oldest if over capacity
+    if (this.map.size > this.capacity) {
+      const oldest = this.map.keys().next().value as K
+      this.map.delete(oldest)
+    }
+    return this
+  }
+
+  has(key: K): boolean {
+    return this.map.has(key)
+  }
+
+  delete(key: K): boolean {
+    return this.map.delete(key)
+  }
+
+  get size(): number {
+    return this.map.size
+  }
+
+  clear(): void {
+    this.map.clear()
+  }
+
+  keys(): MapIterator<K> {
+    return this.map.keys()
+  }
+
+  values(): MapIterator<V> {
+    return this.map.values()
+  }
+
+  entries(): MapIterator<[K, V]> {
+    return this.map.entries()
+  }
+
+  [Symbol.iterator](): MapIterator<[K, V]> {
+    return this.map[Symbol.iterator]()
+  }
+}
+
 // Ensure directories exist
 for (const dir of [DATA_DIR, UPLOAD_DIR, WORKSPACE_DIR]) {
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
@@ -26,12 +120,12 @@ db.pragma('foreign_keys = ON')
 
 const collectionCacheKey = '__swarmclaw_storage_collection_cache__' as const
 type StorageGlobals = typeof globalThis & {
-  [collectionCacheKey]?: Map<string, Map<string, string>>
+  [collectionCacheKey]?: Map<string, LRUMap<string, string>>
 }
 const storageGlobals = globalThis as StorageGlobals
-const collectionCache: Map<string, Map<string, string>> =
+const collectionCache: Map<string, LRUMap<string, string>> =
   storageGlobals[collectionCacheKey]
-  ?? (storageGlobals[collectionCacheKey] = new Map<string, Map<string, string>>())
+  ?? (storageGlobals[collectionCacheKey] = new Map<string, LRUMap<string, string>>())
 
 // Collection tables (id → JSON blob)
 const COLLECTIONS = [
@@ -57,6 +151,8 @@ const COLLECTIONS = [
   'wallets',
   'wallet_transactions',
   'wallet_balance_history',
+  'moderation_logs',
+  'connector_health',
 ] as const
 
 for (const table of COLLECTIONS) {
@@ -69,16 +165,16 @@ db.exec(`CREATE TABLE IF NOT EXISTS queue (id INTEGER PRIMARY KEY CHECK (id = 1)
 db.exec(`CREATE TABLE IF NOT EXISTS usage (session_id TEXT NOT NULL, data TEXT NOT NULL)`)
 db.exec(`CREATE INDEX IF NOT EXISTS idx_usage_session ON usage(session_id)`)
 
-function readCollectionRaw(table: string): Map<string, string> {
+function readCollectionRaw(table: string): LRUMap<string, string> {
   const rows = db.prepare(`SELECT id, data FROM ${table}`).all() as { id: string; data: string }[]
-  const raw = new Map<string, string>()
+  const raw = new LRUMap<string, string>(capacityFor(table))
   for (const row of rows) {
     raw.set(row.id, row.data)
   }
   return raw
 }
 
-function getCollectionRawCache(table: string): Map<string, string> {
+function getCollectionRawCache(table: string): LRUMap<string, string> {
   // Always reload from SQLite so concurrent Next.js workers/processes
   // observe each other's writes immediately.
   const loaded = readCollectionRaw(table)
@@ -864,6 +960,24 @@ export function upsertWalletBalanceSnapshot(id: string, snapshot: unknown) {
   upsertCollectionItem('wallet_balance_history', id, snapshot)
 }
 
+// --- Moderation Logs ---
+export function loadModerationLogs(): Record<string, unknown> {
+  return loadCollection('moderation_logs')
+}
+
+export function appendModerationLog(id: string, entry: unknown) {
+  upsertCollectionItem('moderation_logs', id, entry)
+}
+
+// --- Connector Health ---
+export function loadConnectorHealth(): Record<string, unknown> {
+  return loadCollection('connector_health')
+}
+
+export function upsertConnectorHealthEvent(id: string, event: unknown) {
+  upsertCollectionItem('connector_health', id, event)
+}
+
 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