@swarmclawai/swarmclaw 1.1.8 → 1.2.0

package/src/lib/server/session-tools/skill-runtime.ts

@@ -266,6 +266,15 @@ async function dispatchSkillRun(params: {
   const toolArgs = normalizeDispatchArgs(params.rawArgs)
   const { buildSessionTools } = await import('./index')
   const built = await buildSessionTools(params.bctx.cwd, params.bctx.activeExtensions, params.bctx.ctx)
+  if (!built?.tools) {
+    return JSON.stringify({
+      ok: false,
+      executed: false,
+      mode: 'dispatch_blocked',
+      skill: summarizeRuntimeSkill(params.skill),
+      blocker: 'Unable to load session tools for skill dispatch.',
+    })
+  }
   try {
     const targetTool = built.tools.find((entry) => entry.name === dispatch.toolName)
     if (!targetTool) {
@@ -298,7 +307,7 @@ async function dispatchSkillRun(params: {
         : toolOutput,
     })
   } finally {
-    await built.cleanup()
+    await built?.cleanup()
   }
 }
 

package/src/lib/server/storage-cache.ts

@@ -38,11 +38,13 @@ export class TTLCache<T> {
 type TTLCacheStore = {
   settings?: TTLCache<AppSettings>
   agents?: TTLCache<Record<string, unknown>>
+  sessions?: TTLCache<Record<string, unknown>>
 }
 const ttlCaches: TTLCacheStore = hmrSingleton<TTLCacheStore>('__swarmclaw_ttl_caches__', () => ({}))
 
 export function getSettingsCache() { return ttlCaches.settings ?? (ttlCaches.settings = new TTLCache(60_000)) }
 export function getAgentsCache() { return ttlCaches.agents ?? (ttlCaches.agents = new TTLCache(15_000)) }
+export function getSessionsCache() { return ttlCaches.sessions ?? (ttlCaches.sessions = new TTLCache(5_000)) }
 
 // --- LRU Cache ---
 

package/src/lib/server/storage.ts

@@ -48,6 +48,7 @@ import {
   capacityFor,
   getSettingsCache,
   getAgentsCache,
+  getSessionsCache,
 } from './storage-cache'
 import { normalizeStoredRecord, type NormalizationResult } from './storage-normalization'
 import {
@@ -86,6 +87,9 @@ const db = new Database(DB_PATH)
 if (!IS_BUILD_BOOTSTRAP) {
   db.pragma('journal_mode = WAL')
   db.pragma('busy_timeout = 5000')
+  db.pragma('synchronous = NORMAL')
+  db.pragma('cache_size = -64000')
+  db.pragma('mmap_size = 268435456')
 }
 db.pragma('foreign_keys = ON')
 
@@ -710,8 +714,12 @@ Be concise but not curt. Warmth doesn't require verbosity. When someone asks "ho
 
 // --- Sessions ---
 export function loadSessions(): Record<string, StoredSessionRecord> {
+  const sessionsCache = getSessionsCache()
+  const cached = sessionsCache.get()
+  if (cached) return structuredClone(cached) as unknown as Record<string, StoredSessionRecord>
+
   const sessions = loadCollection('sessions') as unknown as Record<string, StoredSessionRecord>
-  const agents = loadCollection('agents')
+  const agents = loadAgents()
   const changedEntries: Array<[string, StoredSessionRecord]> = []
 
   for (const [id, session] of Object.entries(sessions)) {
@@ -750,6 +758,7 @@ export function loadSessions(): Record<string, StoredSessionRecord> {
 
   // Upsert only changed entries — never full-replace, which deletes concurrent sessions
   if (changedEntries.length > 0) upsertCollectionItems('sessions', changedEntries)
+  sessionsCache.set(sessions as unknown as Record<string, unknown>)
   return sessions
 }
 
@@ -761,6 +770,7 @@ export function saveSessions(s: Record<string, Session | StoredObject>) {
     normalizeValue('sessions', structuredClone(session as unknown as StoredObject)),
   ])
   if (entries.length > 0) upsertCollectionItems('sessions', entries)
+  getSessionsCache().invalidate()
 }
 
 export function loadSession(id: string): Session | null {
@@ -769,10 +779,13 @@ export function loadSession(id: string): Session | null {
 
 export function upsertSession(id: string, session: Session | Record<string, unknown>) {
   upsertCollectionItem('sessions', id, session)
+  getSessionsCache().invalidate()
 }
 
 export function patchSession(id: string, updater: (current: Session | null) => Session | null): Session | null {
-  return patchStoredItem<Session>('sessions', id, updater)
+  const result = patchStoredItem<Session>('sessions', id, updater)
+  getSessionsCache().invalidate()
+  return result
 }
 
 export function disableAllSessionHeartbeats(): number {
@@ -966,7 +979,7 @@ export const upsertTask = tasksStore.upsert
 export const upsertTasks = tasksStore.upsertMany
 export const patchTask = tasksStore.patch as (id: string, updater: (current: BoardTask | null) => BoardTask | null) => BoardTask | null
 export const deleteTask = tasksStore.deleteItem
-export function deleteSession(id: string) { deleteCollectionItem('sessions', id) }
+export function deleteSession(id: string) { deleteCollectionItem('sessions', id); getSessionsCache().invalidate() }
 export function deleteAgent(id: string) { deleteCollectionItem('agents', id); getAgentsCache().invalidate() }
 export const deleteSchedule = schedulesStore.deleteItem
 export function deleteSkill(id: string) { skillsStore.deleteItem(id) }
@@ -1296,6 +1309,20 @@ export const loadRuntimeRunEvents = runtimeRunEventsStore.load as () => Record<s
 export const saveRuntimeRunEvents = runtimeRunEventsStore.save as (items: Record<string, RunEventRecord>) => void
 export const upsertRuntimeRunEvent = runtimeRunEventsStore.upsert as (id: string, value: RunEventRecord) => void
 
+/** Load run events filtered by runId at the SQL level (avoids full-table scan). */
+export function loadRuntimeRunEventsByRunId(runId: string): RunEventRecord[] {
+  const rows = db.prepare(
+    `SELECT data FROM runtime_run_events WHERE json_extract(data, '$.runId') = ? ORDER BY json_extract(data, '$.timestamp') ASC`,
+  ).all(runId) as Array<{ data: string }>
+  const results: RunEventRecord[] = []
+  for (const row of rows) {
+    try {
+      results.push(JSON.parse(row.data) as RunEventRecord)
+    } catch { /* skip malformed */ }
+  }
+  return results
+}
+
 const runtimeEstopStore = createCollectionStore('runtime_estop')
 const ESTOP_STATE_ID = 'global'
 export const loadPersistedEstopState = () => runtimeEstopStore.loadItem(ESTOP_STATE_ID) as EstopState | null

package/src/lib/server/tasks/task-quality-gate.test.ts

@@ -6,7 +6,7 @@ test('normalizeTaskQualityGate uses defaults when unset', () => {
   const gate = normalizeTaskQualityGate(undefined, undefined)
   assert.equal(gate.enabled, true)
   assert.equal(gate.minResultChars, 80)
-  assert.equal(gate.minEvidenceItems, 2)
+  assert.equal(gate.minEvidenceItems, 1)
   assert.equal(gate.requireVerification, false)
   assert.equal(gate.requireArtifact, false)
   assert.equal(gate.requireReport, false)

package/src/lib/server/tasks/task-quality-gate.ts

@@ -12,7 +12,7 @@ export interface NormalizedTaskQualityGate {
 export const DEFAULT_TASK_QUALITY_GATE: NormalizedTaskQualityGate = {
   enabled: true,
   minResultChars: 80,
-  minEvidenceItems: 2,
+  minEvidenceItems: 1,
   requireVerification: false,
   requireArtifact: false,
   requireReport: false,

package/src/stores/slices/data-slice.ts

@@ -30,6 +30,8 @@ export interface DataSlice {
   loadGatewayProfiles: () => Promise<void>
   skills: Record<string, Skill>
   loadSkills: () => Promise<void>
+  skillDraftCount: number
+  loadSkillDraftCount: () => Promise<void>
   connectors: Record<string, Connector>
   loadConnectors: () => Promise<void>
   webhooks: Record<string, Webhook>
@@ -82,6 +84,15 @@ export const createDataSlice: StateCreator<AppState, [], [], DataSlice> = (set,
   loadGatewayProfiles: createLoader<AppState>(set, 'gatewayProfiles', () => api<GatewayProfile[]>('GET', '/gateways'), []),
   skills: {},
   loadSkills: createLoader<AppState>(set, 'skills', () => api<Record<string, Skill>>('GET', '/skills'), {}),
+  skillDraftCount: 0,
+  loadSkillDraftCount: async () => {
+    try {
+      const result = await api<{ total: number }>('GET', '/skill-review-counts')
+      setIfChanged<AppState>(set, 'skillDraftCount', result.total)
+    } catch (err: unknown) {
+      console.warn('Store error:', err)
+    }
+  },
   connectors: {},
   loadConnectors: createLoader<AppState>(set, 'connectors', () => api<Record<string, Connector>>('GET', '/connectors'), {}),
   webhooks: {},

package/src/stores/slices/session-slice.ts

@@ -33,6 +33,9 @@ export const createSessionSlice: StateCreator<AppState, [], [], SessionSlice> =
     await sessionRefreshDedup.dedup(id, async () => {
       try {
         const session = await fetchChat(id)
+        const existing = get().sessions[id]
+        // Skip update if the session data hasn't changed
+        if (existing && JSON.stringify(existing) === JSON.stringify(session)) return
         invalidateFingerprint('sessions')
         set({
           sessions: { ...get().sessions, [id]: session },