@swarmclawai/swarmclaw 1.2.1 → 1.2.3

package/src/lib/server/runtime/watch-job-repository.ts

@@ -0,0 +1,35 @@
+import type { WatchJob } from '@/types'
+
+import {
+  deleteWatchJob as deleteStoredWatchJob,
+  loadWatchJobs as loadStoredWatchJobs,
+  upsertWatchJob as upsertStoredWatchJob,
+  upsertWatchJobs as upsertStoredWatchJobs,
+} from '@/lib/server/storage'
+import { createRecordRepository } from '@/lib/server/persistence/repository-utils'
+
+export const watchJobRepository = createRecordRepository<WatchJob>(
+  'watch-jobs',
+  {
+    get(id) {
+      return (loadStoredWatchJobs() as Record<string, WatchJob>)[id] || null
+    },
+    list() {
+      return loadStoredWatchJobs() as Record<string, WatchJob>
+    },
+    upsert(id, value) {
+      upsertStoredWatchJob(id, value as WatchJob)
+    },
+    upsertMany(entries) {
+      upsertStoredWatchJobs(entries as Array<[string, WatchJob]>)
+    },
+    delete(id) {
+      deleteStoredWatchJob(id)
+    },
+  },
+)
+
+export const loadWatchJobs = () => watchJobRepository.list()
+export const upsertWatchJob = (id: string, value: WatchJob | Record<string, unknown>) => watchJobRepository.upsert(id, value as WatchJob)
+export const upsertWatchJobs = (entries: Array<[string, WatchJob | Record<string, unknown>]>) => watchJobRepository.upsertMany(entries as Array<[string, WatchJob]>)
+export const deleteWatchJob = (id: string) => watchJobRepository.delete(id)

package/src/lib/server/runtime/watch-jobs.ts

@@ -5,7 +5,9 @@ import { genId } from '@/lib/id'
 import type { MailboxEnvelope, WatchJob } from '@/types'
 import { dispatchWake } from '@/lib/server/runtime/wake-dispatcher'
 import { enqueueSystemEvent } from '@/lib/server/runtime/system-events'
-import { loadApprovals, loadTasks, loadWatchJobs, upsertWatchJob, upsertWatchJobs } from '@/lib/server/storage'
+import { loadApprovals } from '@/lib/server/approvals/approval-repository'
+import { loadTasks } from '@/lib/server/tasks/task-repository'
+import { loadWatchJobs, upsertWatchJob, upsertWatchJobs } from '@/lib/server/runtime/watch-job-repository'
 import { notify } from '@/lib/server/ws-hub'
 import { fetchMailboxMessages, getMailboxHighwaterUid } from '@/lib/server/chatrooms/mailbox-utils'
 import { errorMessage } from '@/lib/shared-utils'

package/src/lib/server/schedules/schedule-repository.ts

@@ -0,0 +1,42 @@
+import type { Schedule } from '@/types'
+
+import {
+  deleteSchedule as deleteStoredSchedule,
+  loadSchedule as loadStoredSchedule,
+  loadSchedules as loadStoredSchedules,
+  saveSchedules as saveStoredSchedules,
+  upsertSchedule as upsertStoredSchedule,
+  upsertSchedules as upsertStoredSchedules,
+} from '@/lib/server/storage'
+import { createRecordRepository } from '@/lib/server/persistence/repository-utils'
+
+export const scheduleRepository = createRecordRepository<Schedule>(
+  'schedules',
+  {
+    get(id) {
+      return loadStoredSchedule(id) as Schedule | null
+    },
+    list() {
+      return loadStoredSchedules() as Record<string, Schedule>
+    },
+    upsert(id, value) {
+      upsertStoredSchedule(id, value as Schedule)
+    },
+    upsertMany(entries) {
+      upsertStoredSchedules(entries as Array<[string, Schedule]>)
+    },
+    replace(data) {
+      saveStoredSchedules(data as Record<string, Schedule>)
+    },
+    delete(id) {
+      deleteStoredSchedule(id)
+    },
+  },
+)
+
+export const loadSchedules = () => scheduleRepository.list()
+export const loadSchedule = (id: string) => scheduleRepository.get(id)
+export const saveSchedules = (items: Record<string, Schedule | Record<string, unknown>>) => scheduleRepository.replace(items as Record<string, Schedule>)
+export const upsertSchedule = (id: string, value: Schedule | Record<string, unknown>) => scheduleRepository.upsert(id, value as Schedule)
+export const upsertSchedules = (entries: Array<[string, Schedule | Record<string, unknown>]>) => scheduleRepository.upsertMany(entries as Array<[string, Schedule]>)
+export const deleteSchedule = (id: string) => scheduleRepository.delete(id)

package/src/lib/server/sessions/session-repository.ts

@@ -0,0 +1,85 @@
+import type { Message, Session } from '@/types'
+
+import {
+  deleteSession as deleteStoredSession,
+  disableAllSessionHeartbeats as disableAllStoredSessionHeartbeats,
+  getSessionMessages as getStoredSessionMessages,
+  loadSession as loadStoredSession,
+  loadSessions as loadStoredSessions,
+  patchSession as patchStoredSession,
+  saveSessions as replaceStoredSessions,
+  upsertSession as upsertStoredSession,
+} from '@/lib/server/storage'
+import { createRecordRepository } from '@/lib/server/persistence/repository-utils'
+
+export const sessionRepository = createRecordRepository<Session>(
+  'sessions',
+  {
+    get(id) {
+      return loadStoredSession(id) as Session | null
+    },
+    list() {
+      return loadStoredSessions() as Record<string, Session>
+    },
+    upsert(id, value) {
+      upsertStoredSession(id, value as Session)
+    },
+    upsertMany(entries) {
+      replaceStoredSessions(Object.fromEntries(entries))
+    },
+    replace(data) {
+      replaceStoredSessions(data)
+    },
+    patch(id, updater) {
+      return patchStoredSession(id, updater as (current: Session | null) => Session | null) as Session | null
+    },
+    delete(id) {
+      deleteStoredSession(id)
+    },
+  },
+)
+
+export function listSessions(): Record<string, Session> {
+  return sessionRepository.list()
+}
+
+export function getSession(id: string): Session | null {
+  return sessionRepository.get(id)
+}
+
+export function getSessions(ids: string[]): Record<string, Session> {
+  return sessionRepository.getMany(ids)
+}
+
+export function saveSession(id: string, session: Session | Record<string, unknown>): void {
+  sessionRepository.upsert(id, session as Session)
+}
+
+export function saveSessionMany(entries: Array<[string, Session | Record<string, unknown>]>): void {
+  sessionRepository.upsertMany(entries as Array<[string, Session]>)
+}
+
+export function replaceSessions(sessions: Record<string, Session | Record<string, unknown>>): void {
+  sessionRepository.replace(sessions as Record<string, Session>)
+}
+
+export function patchSession(id: string, updater: (current: Session | null) => Session | null): Session | null {
+  return sessionRepository.patch(id, updater)
+}
+
+export function deleteSession(id: string): void {
+  sessionRepository.delete(id)
+}
+
+export function getSessionMessages(sessionId: string): Message[] {
+  return getStoredSessionMessages(sessionId)
+}
+
+export function disableAllSessionHeartbeats(): number {
+  return disableAllStoredSessionHeartbeats()
+}
+
+export const loadSessions = listSessions
+export const loadSession = getSession
+export const saveSessions = replaceSessions
+export const upsertSession = saveSession

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

@@ -0,0 +1,25 @@
+import type { AppSettings } from '@/types'
+
+import {
+  loadPublicSettings as loadStoredPublicSettings,
+  loadSettings as loadStoredSettings,
+  saveSettings as saveStoredSettings,
+} from '@/lib/server/storage'
+import { createSingletonRepository } from '@/lib/server/persistence/repository-utils'
+
+export const settingsRepository = createSingletonRepository<AppSettings>(
+  'settings',
+  {
+    get() {
+      return loadStoredSettings()
+    },
+    save(value) {
+      saveStoredSettings(value)
+    },
+  },
+)
+
+export const loadSettings = () => settingsRepository.get()
+export const saveSettings = (value: AppSettings | Record<string, unknown>) => settingsRepository.save(value as AppSettings)
+export const patchSettings = (updater: (current: AppSettings) => AppSettings | Record<string, unknown>) => settingsRepository.patch(updater as (current: AppSettings) => AppSettings)
+export const loadPublicSettings = () => loadStoredPublicSettings()

package/src/lib/server/skills/skill-discovery.test.ts

@@ -5,14 +5,14 @@ import path from 'node:path'
 import test from 'node:test'
 import { clearDiscoveredSkillsCache, discoverSkills } from './skill-discovery'
 
-test('discoverSkills includes tracked bundled skills from bundled-skills', () => {
+test('discoverSkills includes tracked bundled skills from skills', () => {
   const skills = discoverSkills({ cwd: path.join(process.cwd(), 'src') })
   const googleWorkspaceSkill = skills.find((skill) => skill.name === 'google-workspace')
 
   assert.ok(googleWorkspaceSkill)
   assert.equal(googleWorkspaceSkill?.source, 'bundled')
   assert.equal(
-    googleWorkspaceSkill?.sourcePath.endsWith(path.join('bundled-skills', 'google-workspace', 'SKILL.md')),
+    googleWorkspaceSkill?.sourcePath.endsWith(path.join('skills', 'google-workspace', 'SKILL.md')),
     true,
   )
 })

package/src/lib/server/skills/skill-discovery.ts

@@ -19,7 +19,7 @@ interface DiscoveryCache {
 }
 
 const CACHE_TTL_MS = 5_000
-const BUNDLED_SKILLS_DIR = path.join(process.cwd(), 'bundled-skills')
+const BUNDLED_SKILLS_DIR = path.join(process.cwd(), 'skills')
 const LEGACY_BUNDLED_SKILLS_DIR = path.join(DATA_DIR, 'skills')
 
 let cache: DiscoveryCache | null = null
@@ -84,7 +84,7 @@ function scanLayer(
 
 /**
  * Discover skills from three layers:
- *   1. Bundled: `bundled-skills/` (tracked with the app)
+ *   1. Bundled: `skills/` (tracked with the app)
  *      Legacy fallback: `data/skills/`
  *   2. Workspace: `<swarmclaw-home>/skills/` (user-installed)
  *   3. Project: `<cwd>/skills/` (project-local)

package/src/lib/server/skills/skill-repository.ts

@@ -0,0 +1,14 @@
+export {
+  deleteLearnedSkill,
+  deleteSkill,
+  loadLearnedSkill,
+  loadLearnedSkills,
+  loadSkillSuggestions,
+  loadSkills,
+  patchLearnedSkill,
+  patchSkillSuggestion,
+  saveLearnedSkills,
+  saveSkills,
+  upsertLearnedSkill,
+  upsertSkillSuggestion,
+} from '@/lib/server/storage'

package/src/lib/server/storage.ts

@@ -1,8 +1,6 @@
 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'
@@ -105,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 = [
@@ -306,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()
+  }
 }
 
 /**
@@ -322,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 {
@@ -356,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 {
@@ -1438,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-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/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/webhooks/webhook-repository.ts

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

package/src/lib/strip-internal-metadata.test.ts

@@ -1,4 +1,5 @@
-import { describe, it, expect } from 'vitest'
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
 import { stripInternalJson, stripLoopDetectionMessages, stripAllInternalMetadata } from './strip-internal-metadata'
 
 // ---------------------------------------------------------------------------
@@ -8,37 +9,37 @@ import { stripInternalJson, stripLoopDetectionMessages, stripAllInternalMetadata
 describe('stripInternalJson', () => {
   it('removes single-line classification JSON', () => {
     const input = '{ "isDeliverableTask": true, "quality_score": 0.8, "isBroadGoal": false }'
-    expect(stripInternalJson(input).trim()).toBe('')
+    assert.equal(stripInternalJson(input).trim(), '')
   })
 
   it('removes classification JSON embedded in surrounding text', () => {
     const input = 'Here is the answer.\n{ "isDeliverableTask": true, "confidence": 0.9 }\nMore text follows.'
     const result = stripInternalJson(input)
-    expect(result).toContain('Here is the answer.')
-    expect(result).toContain('More text follows.')
-    expect(result).not.toContain('isDeliverableTask')
+    assert.match(result, /Here is the answer\./)
+    assert.match(result, /More text follows\./)
+    assert.doesNotMatch(result, /isDeliverableTask/)
   })
 
   it('preserves legitimate JSON that does not contain internal keys', () => {
     const input = 'The config is { "name": "test", "port": 3000 }'
-    expect(stripInternalJson(input)).toBe(input)
+    assert.equal(stripInternalJson(input), input)
   })
 
   it('preserves JSON with nested objects if no internal keys', () => {
     const input = '{ "user": { "name": "alice" } }'
-    expect(stripInternalJson(input)).toBe(input)
+    assert.equal(stripInternalJson(input), input)
   })
 
   it('removes JSON with nested objects when internal keys are present', () => {
     const input = '{ "walletIntent": "send", "details": { "amount": 100 } }'
-    expect(stripInternalJson(input).trim()).toBe('')
+    assert.equal(stripInternalJson(input).trim(), '')
   })
 
   it('handles multiple JSON blocks, only removing internal ones', () => {
     const input = '{ "isDeliverableTask": true } some text { "foo": "bar" }'
     const result = stripInternalJson(input)
-    expect(result).not.toContain('isDeliverableTask')
-    expect(result).toContain('{ "foo": "bar" }')
+    assert.doesNotMatch(result, /isDeliverableTask/)
+    assert.match(result, /\{ "foo": "bar" \}/)
   })
 })
 
@@ -49,110 +50,110 @@ describe('stripInternalJson', () => {
 describe('stripLoopDetectionMessages', () => {
   it('strips tool frequency "called N times" messages', () => {
     const input = 'Tool "shell" called 30 times this turn. Excessive repetition — wrap up with available results.'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips tool frequency "would be called" messages', () => {
     const input = 'Tool "shell" would be called 31 times this turn. Excessive repetition — wrap up with available results.'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips "nearing overuse" messages', () => {
     const input = 'Tool "read" is nearing overuse (15 calls this turn). Consider whether another call is needed.'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips generic repeat "You called" messages', () => {
     const input = 'You called "browser" 6 times with identical input. Input: "{"action":"screenshot"}" — State your blocker or deliver what you have.'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips generic repeat "You called" warning messages', () => {
     const input = 'You called "search" 4 times with identical input. Input: "query" — Try a fundamentally different approach or deliver partial results.'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips "would repeat the same input" messages', () => {
     const input = '"search" would repeat the same input 12 times. Input: "query" — State your blocker or deliver what you have.'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips "is about to repeat the same input" messages', () => {
     const input = '"search" is about to repeat the same input 6 times. Input: "query" — Try a different approach.'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips circuit breaker messages', () => {
     const input = 'Circuit breaker: "shell" called 20 times with identical input. Halting to prevent runaway.'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips circuit breaker preview messages', () => {
     const input = 'Circuit breaker: "shell" would be called 20 times with identical input. Halting before another runaway call.'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips polling stall messages', () => {
     const input = 'Polling stall: "status_check" returned identical output 8 times consecutively. The polled resource is not changing.'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips ping-pong "are alternating" messages', () => {
     const input = 'Ping-pong: "read" and "write" are alternating with identical results (5 cycles). Breaking the loop.'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips ping-pong "may be stuck" messages', () => {
     const input = 'Ping-pong: "read" and "write" may be stuck in an alternating loop (3 cycles).'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips output stagnation messages', () => {
     const input = 'Output stagnation: last 8 tool calls all produced identical output. The approach is not working — try something fundamentally different or report the blocker.'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips output stagnation warning messages', () => {
     const input = 'Output stagnation: 6 of the last 8 tool calls produced identical output. Your tools may not be making progress.'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips error convergence messages', () => {
     const input = 'Error convergence: 5 of the last 6 tool calls returned errors. Stop retrying and report the underlying issue (likely an infrastructure or configuration problem).'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips error convergence warning messages', () => {
     const input = 'Error convergence: 4 of the last 6 tool calls returned errors. You may be hitting a systemic issue — consider a different approach or report the blocker.'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips messages wrapped in [Error: ...] brackets', () => {
     const input = '[Error: You called "browser" 6 times with identical input. Input: "{"action":"screenshot"}" — State your blocker or deliver what you have.]'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips [Error: ...] wrapped tool frequency messages', () => {
     const input = '[Error: Tool "shell" called 30 times this turn. Excessive repetition — wrap up with available results.]'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips [Error: ...] wrapped output stagnation messages', () => {
     const input = '[Error: Output stagnation: last 8 tool calls all produced identical output.]'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('preserves normal text that mentions tools', () => {
     const input = 'I used the shell tool to run the command.'
-    expect(stripLoopDetectionMessages(input)).toBe(input)
+    assert.equal(stripLoopDetectionMessages(input), input)
   })
 
   it('strips loop message embedded in surrounding text', () => {
     const input = 'Working on it.\nTool "shell" called 30 times this turn. Excessive repetition — wrap up with available results.\nHere are the results.'
     const result = stripLoopDetectionMessages(input)
-    expect(result).toContain('Working on it.')
-    expect(result).toContain('Here are the results.')
-    expect(result).not.toContain('called 30 times')
+    assert.match(result, /Working on it\./)
+    assert.match(result, /Here are the results\./)
+    assert.doesNotMatch(result, /called 30 times/)
   })
 })
 
@@ -169,32 +170,32 @@ describe('stripAllInternalMetadata', () => {
       'The answer is 42.',
     ].join('\n')
     const result = stripAllInternalMetadata(input)
-    expect(result).not.toContain('isDeliverableTask')
-    expect(result).not.toContain('called 30 times')
-    expect(result).toContain('Here is my analysis.')
-    expect(result).toContain('The answer is 42.')
+    assert.doesNotMatch(result, /isDeliverableTask/)
+    assert.doesNotMatch(result, /called 30 times/)
+    assert.match(result, /Here is my analysis\./)
+    assert.match(result, /The answer is 42\./)
   })
 
   it('collapses excessive newlines after stripping', () => {
     const input = 'Hello.\n\n\n\n{ "isDeliverableTask": true }\n\n\n\nWorld.'
     const result = stripAllInternalMetadata(input)
-    expect(result).not.toMatch(/\n{3,}/)
+    assert.doesNotMatch(result, /\n{3,}/)
   })
 
   it('returns empty string for purely internal content', () => {
     const input = '{ "isDeliverableTask": true, "quality_score": 0.9 }'
-    expect(stripAllInternalMetadata(input)).toBe('')
+    assert.equal(stripAllInternalMetadata(input), '')
   })
 
   it('leaves normal messages untouched', () => {
     const input = 'Here is a normal response with no internal metadata.'
-    expect(stripAllInternalMetadata(input)).toBe(input)
+    assert.equal(stripAllInternalMetadata(input), input)
   })
 
   it('preserves code blocks with JSON that happen to have similar-looking keys', () => {
     // JSON in code blocks uses real braces, so the regex will match the block.
     // But since 'name' and 'age' are not internal keys, it should be preserved.
     const input = 'Result: { "name": "Alice", "age": 30 }'
-    expect(stripAllInternalMetadata(input)).toBe(input)
+    assert.equal(stripAllInternalMetadata(input), input)
   })
 })