@swarmclawai/swarmclaw 1.2.0 → 1.2.2

package/src/lib/server/storage.ts

@@ -1,12 +1,13 @@
 import fs from 'fs'
 import path from 'path'
 import crypto from 'crypto'
-import os from 'os'
-import type { ChildProcess } from 'node:child_process'
 import Database from 'better-sqlite3'
 
 import { perf } from '@/lib/server/runtime/perf'
+import { log } from '@/lib/server/logger'
 import { notify } from '@/lib/server/ws-hub'
+
+const TAG = 'storage'
 import { DATA_DIR, IS_BUILD_BOOTSTRAP, WORKSPACE_DIR } from './data-dir'
 import { normalizeHeartbeatSettingFields } from '@/lib/runtime/heartbeat-defaults'
 import { normalizeRuntimeSettingFields } from '@/lib/runtime/runtime-loop'
@@ -102,11 +103,6 @@ export function withTransaction<T>(fn: () => T): T {
 type StoredObject = Record<string, unknown>
 type StoredSessionRecord = Session
 type StoredAgentRecord = Agent
-type ActiveProcess = ChildProcess | {
-  runId?: string | null
-  source?: string
-  kill: (signal?: NodeJS.Signals | number) => boolean | void
-}
 
 // Collection tables (id → JSON blob)
 const COLLECTIONS = [
@@ -264,8 +260,8 @@ function saveCollection(table: string, data: Record<string, unknown>) {
   // partial collection instead of a full load-modify-save.  This prevents
   // accidental data wipes (e.g. tests calling saveCredentials with 1 item).
   if (toDelete.length > 0 && next.size > 0 && toDelete.length > next.size) {
-    console.error(
-      `[storage] BLOCKED destructive saveCollection("${table}"): ` +
+    log.error(TAG,
+      `BLOCKED destructive saveCollection("${table}"): ` +
       `would delete ${toDelete.length} rows but only upsert ${next.size}. ` +
       `Use deleteCollectionItem() for explicit deletes or load-modify-save to update.`,
     )
@@ -303,7 +299,18 @@ function deleteCollectionItem(table: string, id: string) {
   db.prepare(`DELETE FROM ${table} WHERE id = ?`).run(id)
   const cached = collectionCache.get(table)
   if (cached) cached.delete(id)
+  invalidateDerivedCollectionCaches(table)
+}
+
+function invalidateDerivedCollectionCaches(table: string): void {
   factoryTtlCaches.get(table)?.invalidate()
+  if (table === 'sessions') {
+    getSessionsCache().invalidate()
+    return
+  }
+  if (table === 'agents') {
+    getAgentsCache().invalidate()
+  }
 }
 
 /**
@@ -319,7 +326,7 @@ function upsertCollectionItem(table: string, id: string, value: unknown) {
   if (cached) {
     cached.set(id, serialized)
   }
-  factoryTtlCaches.get(table)?.invalidate()
+  invalidateDerivedCollectionCaches(table)
 }
 
 function loadCollectionItem(table: string, id: string): unknown | null {
@@ -353,7 +360,7 @@ function upsertCollectionItems(table: string, entries: Array<[string, unknown]>)
       cached.set(id, serialized)
     }
   }
-  factoryTtlCaches.get(table)?.invalidate()
+  invalidateDerivedCollectionCaches(table)
 }
 
 export function loadStoredItem(table: StorageCollection, id: string): unknown | null {
@@ -537,7 +544,7 @@ const MIGRATION_FLAG = path.join(DATA_DIR, '.sqlite_migrated')
 function migrateFromJson() {
   if (fs.existsSync(MIGRATION_FLAG)) return
 
-  console.log('[storage] Migrating from JSON files to SQLite...')
+  log.info(TAG, 'Migrating from JSON files to SQLite...')
 
   const transaction = db.transaction(() => {
     for (const [table, jsonPath] of Object.entries(JSON_FILES)) {
@@ -549,7 +556,7 @@ function migrateFromJson() {
             for (const [id, val] of Object.entries(data)) {
               ins.run(id, JSON.stringify(val))
             }
-            console.log(`[storage]   Migrated ${table}: ${Object.keys(data).length} records`)
+            log.info(TAG, `Migrated ${table}: ${Object.keys(data).length} records`)
           }
         } catch { /* skip malformed files */ }
       }
@@ -562,7 +569,7 @@ function migrateFromJson() {
         const data = JSON.parse(fs.readFileSync(settingsPath, 'utf8'))
         if (data && Object.keys(data).length > 0) {
           saveSingleton('settings', data)
-          console.log('[storage]   Migrated settings')
+          log.info(TAG, 'Migrated settings')
         }
       } catch { /* skip */ }
     }
@@ -574,7 +581,7 @@ function migrateFromJson() {
         const data = JSON.parse(fs.readFileSync(queuePath, 'utf8'))
         if (Array.isArray(data) && data.length > 0) {
           saveSingleton('queue', data)
-          console.log(`[storage]   Migrated queue: ${data.length} items`)
+          log.info(TAG, `Migrated queue: ${data.length} items`)
         }
       } catch { /* skip */ }
     }
@@ -592,14 +599,14 @@ function migrateFromJson() {
             }
           }
         }
-        console.log('[storage]   Migrated usage records')
+        log.info(TAG, 'Migrated usage records')
       } catch { /* skip */ }
     }
   })
 
   transaction()
   fs.writeFileSync(MIGRATION_FLAG, new Date().toISOString())
-  console.log('[storage] Migration complete. JSON files preserved as backup.')
+  log.info(TAG, 'Migration complete. JSON files preserved as backup.')
 }
 
 if (!IS_BUILD_BOOTSTRAP) {
@@ -1400,6 +1407,14 @@ export function appendUsage(sessionId: string, record: unknown) {
   ins.run(sessionId, JSON.stringify(record))
 }
 
+export function pruneOldUsage(maxAgeMs: number): number {
+  const cutoff = Date.now() - maxAgeMs
+  const result = db.prepare(
+    `DELETE FROM usage WHERE CAST(COALESCE(json_extract(data, '$.timestamp'), 0) AS INTEGER) < ?`
+  ).run(cutoff)
+  return result.changes
+}
+
 // --- Connectors ---
 const connectorsStore = createCollectionStore('connectors', { ttlMs: 30_000 })
 export const loadConnectors = connectorsStore.load
@@ -1427,21 +1442,6 @@ const webhooksStore = createCollectionStore('webhooks')
 export const loadWebhooks = webhooksStore.load
 export const saveWebhooks = webhooksStore.save
 
-// --- Active processes ---
-export const active = new Map<string, ActiveProcess>()
-export const devServers = new Map<string, { proc: ChildProcess; url: string }>()
-
-// --- Utilities ---
-export function localIP(): string {
-  for (const ifaces of Object.values(os.networkInterfaces())) {
-    if (!ifaces) continue
-    for (const i of ifaces) {
-      if (i.family === 'IPv4' && !i.internal) return i.address
-    }
-  }
-  return 'localhost'
-}
-
 // --- MCP Servers ---
 const mcpServersStore = createCollectionStore('mcp_servers')
 export const loadMcpServers = mcpServersStore.load

package/src/lib/server/tasks/task-followups.ts

@@ -7,6 +7,9 @@ import { WORKSPACE_DIR } from '@/lib/server/data-dir'
 import { loadConnectors, loadSessions, UPLOAD_DIR } from '@/lib/server/storage'
 import { errorMessage } from '@/lib/shared-utils'
 import { isMainSession } from '@/lib/server/agents/main-agent-loop'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'task-followups'
 
 export { normalizeWhatsappTarget }
 
@@ -507,7 +510,7 @@ export async function notifyConnectorTaskFollowups(params: {
       })
     } catch (err: unknown) {
       const errMsg = errorMessage(err)
-      console.warn(`[queue] Failed task follow-up send on connector ${target.connectorId}: ${errMsg}`)
+      log.warn(TAG, `Failed task follow-up send on connector ${target.connectorId}: ${errMsg}`)
     }
   }
 }

package/src/lib/server/tasks/task-repository.ts

@@ -0,0 +1,54 @@
+import type { BoardTask } from '@/types'
+
+import {
+  deleteTask as deleteStoredTask,
+  loadTask as loadStoredTask,
+  loadTasks as loadStoredTasks,
+  patchTask as patchStoredTask,
+  saveTasks as saveStoredTasks,
+  upsertTask as upsertStoredTask,
+  upsertTasks as upsertStoredTasks,
+} from '@/lib/server/storage'
+import { createRecordRepository } from '@/lib/server/persistence/repository-utils'
+
+export const taskRepository = createRecordRepository<BoardTask>(
+  'tasks',
+  {
+    get(id) {
+      return loadStoredTask(id) as BoardTask | null
+    },
+    list() {
+      return loadStoredTasks() as Record<string, BoardTask>
+    },
+    upsert(id, value) {
+      upsertStoredTask(id, value as BoardTask)
+    },
+    upsertMany(entries) {
+      upsertStoredTasks(entries as Array<[string, BoardTask]>)
+    },
+    replace(data) {
+      saveStoredTasks(data as Record<string, BoardTask>)
+    },
+    patch(id, updater) {
+      return patchStoredTask(id, updater as (current: BoardTask | null) => BoardTask | null) as BoardTask | null
+    },
+    delete(id) {
+      deleteStoredTask(id)
+    },
+  },
+)
+
+export const getTask = (id: string) => taskRepository.get(id)
+export const getTasks = (ids: string[]) => taskRepository.getMany(ids)
+export const listTasks = () => taskRepository.list()
+export const saveTask = (id: string, task: BoardTask | Record<string, unknown>) => taskRepository.upsert(id, task as BoardTask)
+export const saveTaskMany = (entries: Array<[string, BoardTask | Record<string, unknown>]>) => taskRepository.upsertMany(entries as Array<[string, BoardTask]>)
+export const replaceTasks = (items: Record<string, BoardTask | Record<string, unknown>>) => taskRepository.replace(items as Record<string, BoardTask>)
+export const patchTask = (id: string, updater: (current: BoardTask | null) => BoardTask | null) => taskRepository.patch(id, updater)
+export const deleteTask = (id: string) => taskRepository.delete(id)
+
+export const loadTasks = listTasks
+export const loadTask = getTask
+export const saveTasks = replaceTasks
+export const upsertTask = saveTask
+export const upsertTasks = saveTaskMany

package/src/lib/server/tool-loop-detection.ts

@@ -71,9 +71,9 @@ const DEFAULT_THRESHOLDS: LoopDetectionThresholds = {
   pollCritical: 8,
   pingPongWarn: 3,
   pingPongCritical: 5,
-  circuitBreaker: 20,
-  toolFrequencyWarn: 15,
-  toolFrequencyCritical: 30,
+  circuitBreaker: 15,
+  toolFrequencyWarn: 12,
+  toolFrequencyCritical: 25,
 }
 
 // ---------------------------------------------------------------------------
@@ -182,6 +182,11 @@ export class ToolLoopTracker {
     this.keyCount.clear()
   }
 
+  /** Partial reset: clear per-tool frequency counts but preserve circuit breaker and repeat history. */
+  resetFrequencyCounts(): void {
+    this.nameCount.clear()
+  }
+
   /** Get the full call history (for diagnostics). */
   getHistory(): ReadonlyArray<ToolCallRecord> {
     return this.history

package/src/lib/server/tool-planning.ts

@@ -39,6 +39,7 @@ const CORE_TOOL_PLANNING: Record<string, ToolPlanningEntry[]> = {
       capabilities: ['artifact.files'],
       disciplineGuidance: [
         'For `files`, include an explicit action whenever possible. Common patterns: `{"action":"list","dirPath":"."}`, `{"action":"read","filePath":"path/to/file.md"}`, and `{"action":"write","files":[{"path":"path/to/file.md","content":"..."}]}`.',
+        'Prefer a single write call with multiple files over writing one file at a time.',
       ],
       requestMatchers: [],
     },
@@ -49,6 +50,7 @@ const CORE_TOOL_PLANNING: Record<string, ToolPlanningEntry[]> = {
       capabilities: ['runtime.shell'],
       disciplineGuidance: [
         'For `shell`, use `{"action":"execute","command":"..."}` for commands and `{"action":"status","processId":"..."}` or `{"action":"log","processId":"..."}` for long-lived processes.',
+        'Chain related commands in a single shell call using && to reduce round-trips. Avoid running the same build or test command repeatedly — if it fails, diagnose the error before retrying.',
       ],
       requestMatchers: [],
     },
@@ -59,6 +61,7 @@ const CORE_TOOL_PLANNING: Record<string, ToolPlanningEntry[]> = {
       capabilities: [TOOL_CAPABILITY.researchSearch],
       disciplineGuidance: [
         'For `web_search`, use `{"query":"..."}` to research fresh information. For current events, breaking news, or "latest" requests, start with `web_search` before summarizing.',
+        'Gather 2-3 key sources, then synthesize. Do not search-read-search-read in a loop.',
       ],
       requestMatchers: [
         {
@@ -73,6 +76,7 @@ const CORE_TOOL_PLANNING: Record<string, ToolPlanningEntry[]> = {
       capabilities: [TOOL_CAPABILITY.researchFetch],
       disciplineGuidance: [
         'For `web_fetch`, use `{"url":"https://..."}` to read a specific page or article after you know the URL.',
+        'Fetch the pages you need, then synthesize. Do not fetch-read-fetch-read in a loop.',
       ],
       requestMatchers: [
         {
@@ -91,6 +95,7 @@ const CORE_TOOL_PLANNING: Record<string, ToolPlanningEntry[]> = {
         'For `browser`, when the task includes a literal URL, pass that exact URL string to `{"action":"navigate","url":"..."}`. Do not invent placeholder URLs like `[Your URL]`, `Example_URL`, or `MockMailPage_URL`.',
         'For `browser` form work, prefer `{"action":"fill_form","fields":[{"element":"#email","value":"user@example.com"},{"element":"#password","value":"..."}]}`. A shorthand `form` object keyed by input id/name also works for simple forms.',
         'Use `browser` when the user asks for screenshots, visual proof, page capture, PDFs, or a rendered view of a page. `navigate` alone is not a screenshot.',
+        'Limit browser navigations to what is needed. Each navigation is expensive. Plan your browser session: list the pages you need, visit each once, extract what you need.',
       ],
       requestMatchers: [
         {
@@ -117,6 +122,7 @@ const CORE_TOOL_PLANNING: Record<string, ToolPlanningEntry[]> = {
         'For outbound delivery, inspect available channels with `connector_message_tool` using `{"action":"list_running"}` before claiming something cannot be sent.',
         'Use `connector_message_tool` with `{"action":"send","message":"...","mediaPath":"..."}` for text/media and `{"action":"send_voice_note","voiceText":"..."}` for voice notes.',
         'If no channel or recipient is configured, explain that connector/channel setup is missing rather than claiming the capability does not exist.',
+        'Check channel availability once with `list_running`, then send. Do not re-list channels between each message.',
       ],
       requestMatchers: [
         {
@@ -140,6 +146,7 @@ const CORE_TOOL_PLANNING: Record<string, ToolPlanningEntry[]> = {
       capabilities: ['network.http'],
       disciplineGuidance: [
         'For `http_request`, send exact literal URLs from the task or from prior tool results. Keep JSON request bodies as raw JSON strings.',
+        'If an API call fails, inspect the error before retrying with the same request. Do not retry the same failing call in a loop.',
       ],
       requestMatchers: [],
     },
@@ -150,6 +157,7 @@ const CORE_TOOL_PLANNING: Record<string, ToolPlanningEntry[]> = {
       capabilities: ['delivery.email'],
       disciplineGuidance: [
         'For `email`, send mail with `{"action":"send","to":"user@example.com","subject":"...","body":"..."}`. If delivery depends on SMTP setup, check `{"action":"status"}` before claiming success.',
+        'Compose the full message in one send call. Do not send partial drafts followed by corrections.',
       ],
       requestMatchers: [],
     },
@@ -162,6 +170,7 @@ const CORE_TOOL_PLANNING: Record<string, ToolPlanningEntry[]> = {
         'For `google_workspace`, pass exact `gws` arguments in `{"args":[...]}` form. Prefer list/get/read commands first to confirm IDs and current state before mutating Drive, Docs, Sheets, Gmail, Calendar, or Chat resources.',
         'Use `params` and `jsonInput` for `--params` / `--json` payloads instead of packing raw JSON blobs into the `args` array.',
         'Do not call interactive `gws auth login` or `gws auth setup` from the agent. Use the extension settings or a pre-authenticated `gws` install.',
+        'Confirm resource IDs with a single list/get call before mutating. Do not repeatedly list the same resources between edits.',
       ],
       requestMatchers: [
         {
@@ -179,6 +188,223 @@ const CORE_TOOL_PLANNING: Record<string, ToolPlanningEntry[]> = {
         'For `ask_human`, when a workflow needs a code, approval, or out-of-band value from a person, do not guess or keep re-submitting blank forms. Use `{"action":"request_input","question":"..."}` and, for durable pauses, `{"action":"wait_for_reply","correlationId":"..."}`.',
         'Reuse the same `correlationId` from `request_input` when you call `wait_for_reply`. Once the durable wait returns active, stop the turn immediately and wait for the reply instead of calling `request_input` again.',
         'Do not ask the same pending human question twice before the durable wait resumes unless the question materially changes.',
+        'Batch related questions into a single request rather than asking one question at a time.',
+      ],
+      requestMatchers: [],
+    },
+  ],
+
+  // --- Internal platform tools ---
+
+  manage_agents: [
+    {
+      toolName: 'manage_agents',
+      capabilities: ['platform.agents'],
+      disciplineGuidance: [
+        'List agents once at the start of a task, then work with specific agent IDs. Do not re-list between each action.',
+      ],
+      requestMatchers: [],
+    },
+  ],
+  manage_projects: [
+    {
+      toolName: 'manage_projects',
+      capabilities: ['platform.projects'],
+      disciplineGuidance: [
+        'List projects once to orient, then operate on specific project IDs. Do not re-list after each update.',
+      ],
+      requestMatchers: [],
+    },
+  ],
+  manage_tasks: [
+    {
+      toolName: 'manage_tasks',
+      capabilities: ['platform.tasks'],
+      disciplineGuidance: [
+        'Read the task list once, make your changes, then move on. Do not re-read the task list after every update.',
+      ],
+      requestMatchers: [],
+    },
+  ],
+  manage_schedules: [
+    {
+      toolName: 'manage_schedules',
+      capabilities: ['platform.schedules'],
+      disciplineGuidance: [
+        'List schedules once to check current state. Do not re-list after each modification.',
+      ],
+      requestMatchers: [],
+    },
+  ],
+  manage_skills: [
+    {
+      toolName: 'manage_skills',
+      capabilities: ['platform.skills'],
+      disciplineGuidance: [
+        'Use `recommend_for_task` to find a relevant skill efficiently. Do not repeatedly list or search skills between each action.',
+      ],
+      requestMatchers: [],
+    },
+  ],
+  manage_webhooks: [
+    {
+      toolName: 'manage_webhooks',
+      capabilities: ['platform.webhooks'],
+      disciplineGuidance: [
+        'List webhooks once for current state. Do not re-list after each change.',
+      ],
+      requestMatchers: [],
+    },
+  ],
+  manage_secrets: [
+    {
+      toolName: 'manage_secrets',
+      capabilities: ['platform.secrets'],
+      disciplineGuidance: [
+        'Store secrets directly. Use the `check` action (not `list`) to verify if a credential already exists before requesting a new one.',
+      ],
+      requestMatchers: [],
+    },
+  ],
+  manage_chatrooms: [
+    {
+      toolName: 'manage_chatrooms',
+      capabilities: ['platform.chatrooms'],
+      disciplineGuidance: [
+        'List chatrooms once to orient, then operate on specific IDs. Do not re-list after each message or update.',
+      ],
+      requestMatchers: [],
+    },
+  ],
+  manage_protocols: [
+    {
+      toolName: 'manage_protocols',
+      capabilities: ['platform.protocols'],
+      disciplineGuidance: [
+        'Read the protocol definition once, then execute steps. Do not re-read the protocol between each step.',
+      ],
+      requestMatchers: [],
+    },
+  ],
+  manage_platform: [
+    {
+      toolName: 'manage_platform',
+      capabilities: ['platform.umbrella'],
+      disciplineGuidance: [
+        'Prefer the direct `manage_*` tools (manage_agents, manage_tasks, etc.) when they are enabled. Use `manage_platform` only as a fallback when the specific tool is not available.',
+      ],
+      requestMatchers: [],
+    },
+  ],
+  spawn_subagent: [
+    {
+      toolName: 'spawn_subagent',
+      capabilities: ['delegation.subagent'],
+      disciplineGuidance: [
+        'Use `waitForCompletion: true` (the default) or `wait`/`wait_all` actions to await results. Do not poll `status` in a loop.',
+        'Batch related delegations — spawn multiple subagents at once if tasks are independent.',
+        'For multi-step or cross-domain work, delegate to a subagent rather than attempting everything in one long tool chain.',
+      ],
+      requestMatchers: [],
+    },
+  ],
+  delegate: [
+    {
+      toolName: 'delegate',
+      capabilities: ['delegation.cli'],
+      disciplineGuidance: [
+        'Give the delegate a complete task description in one call. Do not send incremental instructions across multiple delegation calls.',
+      ],
+      requestMatchers: [],
+    },
+  ],
+  manage_sessions: [
+    {
+      toolName: 'sessions_tool',
+      capabilities: ['platform.sessions'],
+      disciplineGuidance: [
+        'Check session identity once at the start. Do not re-query session info between each action.',
+      ],
+      requestMatchers: [],
+    },
+  ],
+  memory: [
+    {
+      toolName: 'memory_tool',
+      capabilities: ['memory.search', 'memory.store'],
+      disciplineGuidance: [
+        'Search memory once with a good query, then use the results. Do not run multiple overlapping searches for the same topic.',
+        'For stores and updates, write once with complete content. Do not read-back immediately after writing to confirm.',
+      ],
+      requestMatchers: [],
+    },
+  ],
+  context_mgmt: [
+    {
+      toolName: 'context_status',
+      capabilities: ['context.management'],
+      disciplineGuidance: [
+        'Check context status only when you suspect you are running low. Do not check after every tool call.',
+      ],
+      requestMatchers: [],
+    },
+  ],
+  monitor: [
+    {
+      toolName: 'monitor_tool',
+      capabilities: ['monitoring.watch'],
+      disciplineGuidance: [
+        'Prefer `wait_until`, `wait_for_http`, `wait_for_file`, or other `wait_for_*` shortcut actions — they create a durable wait that resumes your turn automatically. Avoid creating a watch with `create_watch` then polling `get_watch` in a loop.',
+      ],
+      requestMatchers: [],
+    },
+  ],
+  wallet: [
+    {
+      toolName: 'wallet_tool',
+      capabilities: [TOOL_CAPABILITY.walletInspect, TOOL_CAPABILITY.walletExecute],
+      disciplineGuidance: [
+        'Inspect wallet state once, then act. Use `simulate_transaction` to validate before executing. Do not re-inspect balances between each operation unless the operation changes them.',
+      ],
+      requestMatchers: [],
+    },
+  ],
+  image_gen: [
+    {
+      toolName: 'generate_image',
+      capabilities: ['media.image_generation'],
+      disciplineGuidance: [
+        'Describe the image fully in one generation call. Do not generate multiple variations unless the user asks for options.',
+      ],
+      requestMatchers: [],
+    },
+  ],
+  replicate: [
+    {
+      toolName: 'replicate',
+      capabilities: ['media.replicate'],
+      disciplineGuidance: [
+        'Submit the job with complete parameters in one call. Use `wait: true` for synchronous completion. If running async, let the built-in polling handle it — do not add your own polling loop on top.',
+      ],
+      requestMatchers: [],
+    },
+  ],
+  schedule_wake: [
+    {
+      toolName: 'schedule_wake',
+      capabilities: ['runtime.schedule'],
+      disciplineGuidance: [
+        'Schedule the wake once with the correct time. Do not reschedule repeatedly to adjust by small increments.',
+      ],
+      requestMatchers: [],
+    },
+  ],
+  mailbox: [
+    {
+      toolName: 'mailbox',
+      capabilities: ['delivery.mailbox'],
+      disciplineGuidance: [
+        'Use `search_messages` for targeted retrieval instead of listing all messages. Do not poll the inbox in a loop waiting for replies.',
       ],
       requestMatchers: [],
     },

package/src/lib/server/tool-retry.ts

@@ -3,6 +3,9 @@
  */
 
 import { sleep, jitteredBackoff } from '@/lib/shared-utils'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'tool-retry'
 
 export interface RetryOptions {
   maxAttempts?: number
@@ -51,9 +54,7 @@ export async function withRetry<TArgs>(
     if (attempt < maxAttempts && isRetryableError(lastResult, retryable)) {
       await opts?.onRetry?.(attempt, lastResult)
       const delay = jitteredBackoff(backoffMs, attempt - 1, backoffMs * 16)
-      console.warn(
-        `[tool-retry] Attempt ${attempt}/${maxAttempts} matched retryable pattern, retrying in ${delay}ms`,
-      )
+      log.warn(TAG, `Attempt ${attempt}/${maxAttempts} matched retryable pattern, retrying in ${delay}ms`)
       await sleep(delay)
       continue
     }

package/src/lib/server/usage/usage-repository.ts

@@ -0,0 +1,30 @@
+import type { UsageRecord } from '@/types'
+
+import {
+  appendUsage as appendStoredUsage,
+  getUsageSpendSince as getStoredUsageSpendSince,
+  loadUsage as loadStoredUsage,
+  pruneOldUsage as pruneStoredUsage,
+  saveUsage as saveStoredUsage,
+} from '@/lib/server/storage'
+import { perf } from '@/lib/server/runtime/perf'
+
+export function loadUsage(): Record<string, UsageRecord[]> {
+  return perf.measureSync('repository', 'usage.list', () => loadStoredUsage())
+}
+
+export function saveUsage(data: Record<string, UsageRecord[]>): void {
+  perf.measureSync('repository', 'usage.replace', () => saveStoredUsage(data), { count: Object.keys(data).length })
+}
+
+export function appendUsage(sessionId: string, record: unknown): void {
+  perf.measureSync('repository', 'usage.append', () => appendStoredUsage(sessionId, record), { sessionId })
+}
+
+export function getUsageSpendSince(minTimestamp: number): number {
+  return perf.measureSync('repository', 'usage.spendSince', () => getStoredUsageSpendSince(minTimestamp), { minTimestamp })
+}
+
+export function pruneOldUsage(maxAgeMs: number): number {
+  return perf.measureSync('repository', 'usage.prune', () => pruneStoredUsage(maxAgeMs), { maxAgeMs })
+}

package/src/lib/server/wallet/wallet-portfolio.ts

@@ -84,9 +84,37 @@ export interface GetWalletPortfolioOptions {
   allowStale?: boolean
 }
 
+const PORTFOLIO_CACHE_MAX = 200
 const portfolioCache = new Map<string, WalletPortfolioCacheEntry>()
 const evmContractDiscoveryCache = new Map<string, EvmContractDiscoveryCacheEntry>()
 
+function pruneExpiredPortfolioCaches(): void {
+  const now = Date.now()
+  for (const [key, entry] of portfolioCache) {
+    if (entry.expiresAt <= now) portfolioCache.delete(key)
+  }
+  for (const [key, entry] of evmContractDiscoveryCache) {
+    if (entry.expiresAt <= now) evmContractDiscoveryCache.delete(key)
+  }
+  // Hard cap as safety net
+  if (portfolioCache.size > PORTFOLIO_CACHE_MAX) {
+    const excess = portfolioCache.size - PORTFOLIO_CACHE_MAX
+    const iter = portfolioCache.keys()
+    for (let i = 0; i < excess; i++) {
+      const k = iter.next().value
+      if (k !== undefined) portfolioCache.delete(k)
+    }
+  }
+  if (evmContractDiscoveryCache.size > PORTFOLIO_CACHE_MAX) {
+    const excess = evmContractDiscoveryCache.size - PORTFOLIO_CACHE_MAX
+    const iter = evmContractDiscoveryCache.keys()
+    for (let i = 0; i < excess; i++) {
+      const k = iter.next().value
+      if (k !== undefined) evmContractDiscoveryCache.delete(k)
+    }
+  }
+}
+
 const KNOWN_SOLANA_TOKENS: Record<string, { symbol: string; name: string }> = {
   EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v: { symbol: 'USDC', name: 'USD Coin' },
 }
@@ -721,6 +749,7 @@ export async function getWalletPortfolio(wallet: AgentWallet, options?: GetWalle
     label: `wallet portfolio ${wallet.id}`,
   })
 
+  pruneExpiredPortfolioCaches()
   portfolioCache.set(cacheKey, {
     expiresAt: Date.now() + PORTFOLIO_CACHE_TTL_MS,
     portfolio,

package/src/lib/server/webhooks/webhook-repository.ts

@@ -0,0 +1,10 @@
+export {
+  appendWebhookLog,
+  deleteWebhookRetry,
+  loadWebhookLogs,
+  loadWebhookRetryQueue,
+  loadWebhooks,
+  saveWebhookRetryQueue,
+  saveWebhooks,
+  upsertWebhookRetry,
+} from '@/lib/server/storage'