@swarmclawai/swarmclaw 0.7.1 → 0.7.3

package/src/lib/server/session-reset-policy.ts

@@ -0,0 +1,311 @@
+import type { Agent, AppSettings, Session, SessionResetMode, SessionResetType } from '@/types'
+
+export interface ResolvedSessionResetPolicy {
+  type: SessionResetType
+  mode: SessionResetMode
+  idleTimeoutSec: number | null
+  maxAgeSec: number | null
+  dailyResetAt: string | null
+  timezone: string | null
+}
+
+export interface SessionFreshnessSnapshot {
+  fresh: boolean
+  reason?: string
+  policy: ResolvedSessionResetPolicy
+  idleExpiresAt: number | null
+  dailyBoundaryKey: string | null
+}
+
+const DEFAULT_POLICIES: Record<SessionResetType, ResolvedSessionResetPolicy> = {
+  direct: {
+    type: 'direct',
+    mode: 'idle',
+    idleTimeoutSec: 12 * 60 * 60,
+    maxAgeSec: 7 * 24 * 60 * 60,
+    dailyResetAt: null,
+    timezone: null,
+  },
+  group: {
+    type: 'group',
+    mode: 'idle',
+    idleTimeoutSec: 6 * 60 * 60,
+    maxAgeSec: 3 * 24 * 60 * 60,
+    dailyResetAt: null,
+    timezone: null,
+  },
+  thread: {
+    type: 'thread',
+    mode: 'idle',
+    idleTimeoutSec: 4 * 60 * 60,
+    maxAgeSec: 2 * 24 * 60 * 60,
+    dailyResetAt: null,
+    timezone: null,
+  },
+  main: {
+    type: 'main',
+    mode: 'daily',
+    idleTimeoutSec: 24 * 60 * 60,
+    maxAgeSec: 14 * 24 * 60 * 60,
+    dailyResetAt: '04:00',
+    timezone: null,
+  },
+}
+
+function parseIntBounded(value: unknown, min: number, max: number): number | null {
+  if (value === null || value === undefined || value === '') return null
+  const parsed = typeof value === 'number'
+    ? value
+    : typeof value === 'string'
+      ? Number.parseInt(value.trim(), 10)
+      : Number.NaN
+  if (!Number.isFinite(parsed)) return null
+  return Math.max(min, Math.min(max, Math.trunc(parsed)))
+}
+
+function normalizeMode(raw: unknown, fallback: SessionResetMode): SessionResetMode {
+  const value = typeof raw === 'string' ? raw.trim().toLowerCase() : ''
+  return value === 'daily' ? 'daily' : value === 'idle' ? 'idle' : fallback
+}
+
+function normalizeTimeHHMM(raw: unknown): string | null {
+  if (typeof raw !== 'string') return null
+  const value = raw.trim()
+  const match = value.match(/^(\d{1,2}):(\d{2})$/)
+  if (!match) return null
+  const hours = Number.parseInt(match[1], 10)
+  const minutes = Number.parseInt(match[2], 10)
+  if (!Number.isFinite(hours) || !Number.isFinite(minutes)) return null
+  if (hours < 0 || hours > 23 || minutes < 0 || minutes > 59) return null
+  return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}`
+}
+
+function normalizeTimezone(raw: unknown): string | null {
+  if (typeof raw !== 'string') return null
+  const value = raw.trim()
+  return value || null
+}
+
+function getClockParts(date: Date, timezone?: string | null): { dateKey: string; minutes: number } | null {
+  try {
+    const formatter = new Intl.DateTimeFormat('en-CA', {
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit',
+      hour: '2-digit',
+      minute: '2-digit',
+      hour12: false,
+      timeZone: timezone || undefined,
+    })
+    const parts = formatter.formatToParts(date)
+    const year = parts.find((part) => part.type === 'year')?.value
+    const month = parts.find((part) => part.type === 'month')?.value
+    const day = parts.find((part) => part.type === 'day')?.value
+    const hour = Number.parseInt(parts.find((part) => part.type === 'hour')?.value || '', 10)
+    const minute = Number.parseInt(parts.find((part) => part.type === 'minute')?.value || '', 10)
+    if (!year || !month || !day || !Number.isFinite(hour) || !Number.isFinite(minute)) return null
+    return {
+      dateKey: `${year}-${month}-${day}`,
+      minutes: hour * 60 + minute,
+    }
+  } catch {
+    return null
+  }
+}
+
+function boundaryKeyForNow(now: number, boundaryMinutes: number, timezone?: string | null): string | null {
+  const current = getClockParts(new Date(now), timezone)
+  if (!current) return null
+  if (current.minutes >= boundaryMinutes) return current.dateKey
+  const previous = getClockParts(new Date(now - 24 * 60 * 60 * 1000), timezone)
+  return previous?.dateKey || null
+}
+
+function rawField(
+  session: Partial<Session> | null | undefined,
+  overrides: Record<string, unknown> | undefined,
+  agent: Partial<Agent> | null | undefined,
+  settings: Partial<AppSettings> | null | undefined,
+  key: 'sessionResetMode' | 'sessionIdleTimeoutSec' | 'sessionMaxAgeSec' | 'sessionDailyResetAt' | 'sessionResetTimezone',
+): unknown {
+  if (session && session[key] !== undefined) return session[key]
+  if (overrides && overrides[key] !== undefined) return overrides[key]
+  if (agent && agent[key] !== undefined) return agent[key]
+  if (settings && settings[key] !== undefined) return settings[key]
+  return undefined
+}
+
+export function inferSessionResetType(
+  session: Partial<Session> | null | undefined,
+  opts?: { isGroup?: boolean | null; threadId?: string | null },
+): SessionResetType {
+  if ((session?.sessionType as string | undefined) === 'orchestrated') return 'main'
+  const threadId = opts?.threadId ?? session?.connectorContext?.threadId ?? null
+  if (threadId) return 'thread'
+  const isGroup = opts?.isGroup ?? session?.connectorContext?.isGroup ?? false
+  return isGroup ? 'group' : 'direct'
+}
+
+export function resolveSessionResetPolicy(params: {
+  session?: Partial<Session> | null
+  agent?: Partial<Agent> | null
+  settings?: Partial<AppSettings> | null
+  resetType?: SessionResetType
+  overrides?: Record<string, unknown>
+}): ResolvedSessionResetPolicy {
+  const type = params.resetType ?? inferSessionResetType(params.session)
+  const defaults = DEFAULT_POLICIES[type]
+  return {
+    type,
+    mode: normalizeMode(
+      rawField(params.session, params.overrides, params.agent, params.settings, 'sessionResetMode'),
+      defaults.mode,
+    ),
+    idleTimeoutSec: parseIntBounded(
+      rawField(params.session, params.overrides, params.agent, params.settings, 'sessionIdleTimeoutSec'),
+      0,
+      180 * 24 * 60 * 60,
+    ) ?? defaults.idleTimeoutSec,
+    maxAgeSec: parseIntBounded(
+      rawField(params.session, params.overrides, params.agent, params.settings, 'sessionMaxAgeSec'),
+      0,
+      365 * 24 * 60 * 60,
+    ) ?? defaults.maxAgeSec,
+    dailyResetAt: normalizeTimeHHMM(
+      rawField(params.session, params.overrides, params.agent, params.settings, 'sessionDailyResetAt'),
+    ) ?? defaults.dailyResetAt,
+    timezone: normalizeTimezone(
+      rawField(params.session, params.overrides, params.agent, params.settings, 'sessionResetTimezone'),
+    ) ?? defaults.timezone,
+  }
+}
+
+export function evaluateSessionFreshness(params: {
+  session?: Partial<Session> | null
+  policy: ResolvedSessionResetPolicy
+  now?: number
+}): SessionFreshnessSnapshot {
+  const now = typeof params.now === 'number' ? params.now : Date.now()
+  const session = params.session
+  const policy = params.policy
+  const messageCount = Array.isArray(session?.messages) ? session.messages.length : 0
+  const createdAt = typeof session?.createdAt === 'number' ? session.createdAt : now
+  const lastActiveAt = typeof session?.lastActiveAt === 'number' ? session.lastActiveAt : createdAt
+  const idleExpiresAt = typeof policy.idleTimeoutSec === 'number' && policy.idleTimeoutSec > 0
+    ? lastActiveAt + policy.idleTimeoutSec * 1000
+    : null
+
+  if (!session || messageCount === 0) {
+    return {
+      fresh: true,
+      policy,
+      idleExpiresAt,
+      dailyBoundaryKey: null,
+    }
+  }
+
+  if (idleExpiresAt !== null && now > idleExpiresAt) {
+    return {
+      fresh: false,
+      reason: `idle_timeout:${policy.idleTimeoutSec}`,
+      policy,
+      idleExpiresAt,
+      dailyBoundaryKey: null,
+    }
+  }
+
+  if (typeof policy.maxAgeSec === 'number' && policy.maxAgeSec > 0) {
+    const maxAgeMs = policy.maxAgeSec * 1000
+    if (now - createdAt > maxAgeMs) {
+      return {
+        fresh: false,
+        reason: `max_age:${policy.maxAgeSec}`,
+        policy,
+        idleExpiresAt,
+        dailyBoundaryKey: null,
+      }
+    }
+  }
+
+  if (policy.mode === 'daily' && policy.dailyResetAt) {
+    const boundary = normalizeTimeHHMM(policy.dailyResetAt)
+    if (boundary) {
+      const [hours, minutes] = boundary.split(':').map((value) => Number.parseInt(value, 10))
+      const boundaryMinutes = hours * 60 + minutes
+      const nowBoundaryKey = boundaryKeyForNow(now, boundaryMinutes, policy.timezone)
+      const lastActiveParts = getClockParts(new Date(lastActiveAt), policy.timezone)
+      if (
+        nowBoundaryKey
+        && lastActiveParts
+        && (
+          lastActiveParts.dateKey < nowBoundaryKey
+          || (lastActiveParts.dateKey === nowBoundaryKey && lastActiveParts.minutes < boundaryMinutes)
+        )
+      ) {
+        return {
+          fresh: false,
+          reason: `daily_reset:${policy.dailyResetAt}`,
+          policy,
+          idleExpiresAt,
+          dailyBoundaryKey: nowBoundaryKey,
+        }
+      }
+      return {
+        fresh: true,
+        policy,
+        idleExpiresAt,
+        dailyBoundaryKey: nowBoundaryKey,
+      }
+    }
+  }
+
+  return {
+    fresh: true,
+    policy,
+    idleExpiresAt,
+    dailyBoundaryKey: null,
+  }
+}
+
+export function resetSessionRuntime(
+  session: Session,
+  reason: string,
+  opts?: { now?: number },
+): number {
+  const now = typeof opts?.now === 'number' ? opts.now : Date.now()
+  const cleared = Array.isArray(session.messages) ? session.messages.length : 0
+
+  session.messages = []
+  session.claudeSessionId = null
+  session.codexThreadId = null
+  session.opencodeSessionId = null
+  session.delegateResumeIds = {
+    claudeCode: null,
+    codex: null,
+    opencode: null,
+    gemini: null,
+  }
+  session.createdAt = now
+  session.lastActiveAt = now
+  session.lastAutoMemoryAt = null
+  session.lastHeartbeatText = null
+  session.lastHeartbeatSentAt = null
+  session.conversationTone = undefined
+  session.lastSessionResetAt = now
+  session.lastSessionResetReason = reason
+
+  if (session.connectorContext) {
+    session.connectorContext = {
+      ...session.connectorContext,
+      lastResetAt: now,
+      lastResetReason: reason,
+      lastInboundMessageId: null,
+      lastInboundReplyToMessageId: null,
+      lastInboundThreadId: null,
+      lastOutboundMessageId: null,
+      lastOutboundAt: null,
+    }
+  }
+
+  return cleared
+}

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

@@ -4,7 +4,9 @@ import { active, loadSessions } from './storage'
 import { executeSessionChatTurn, type ExecuteChatTurnResult } from './chat-execution'
 import { loadRuntimeSettings } from './runtime-settings'
 import { log } from './logger'
-import { handleMainLoopRunResult, type MainLoopFollowupRequest } from './main-agent-loop'
+import { isInternalHeartbeatRun } from './heartbeat-source'
+import { cleanupSessionBrowser } from './session-tools/web'
+import { cancelDelegationJobsForParentSession } from './delegation-jobs'
 
 export type SessionRunStatus = 'queued' | 'running' | 'completed' | 'failed' | 'cancelled'
 export type SessionQueueMode = 'followup' | 'steer' | 'collect'
@@ -122,6 +124,23 @@ function emitRunMeta(entry: QueueEntry, status: SessionRunStatus, extra?: Record
   })
 }
 
+function markRunningEntryCancelled(entry: QueueEntry, reason: string) {
+  if (entry.run.status === 'cancelled') return
+  entry.run.status = 'cancelled'
+  entry.run.endedAt = now()
+  entry.run.error = reason
+  emitRunMeta(entry, 'cancelled', { reason })
+}
+
+function abortSessionRuntime(entry: QueueEntry, reason: string) {
+  markRunningEntryCancelled(entry, reason)
+  entry.signalController.abort()
+  try { active.get(entry.run.sessionId)?.kill?.() } catch { /* noop */ }
+  active.delete(entry.run.sessionId)
+  try { cleanupSessionBrowser(entry.run.sessionId) } catch { /* noop */ }
+  try { cancelDelegationJobsForParentSession(entry.run.sessionId, reason) } catch { /* noop */ }
+}
+
 function executionKeyForSession(sessionId: string): string {
   return `session:${sessionId}`
 }
@@ -170,7 +189,7 @@ export function cancelAllHeartbeatRuns(reason = 'Heartbeat disabled globally'):
     if (!queue.length) continue
     const keep: QueueEntry[] = []
     for (const entry of queue) {
-      const isHeartbeat = entry.run.internal === true && entry.run.source === 'heartbeat'
+      const isHeartbeat = isInternalHeartbeatRun(entry.run.internal, entry.run.source)
       if (!isHeartbeat) {
         keep.push(entry)
         continue
@@ -187,47 +206,15 @@ export function cancelAllHeartbeatRuns(reason = 'Heartbeat disabled globally'):
   }
 
   for (const entry of state.runningByExecution.values()) {
-    const isHeartbeat = entry.run.internal === true && entry.run.source === 'heartbeat'
+    const isHeartbeat = isInternalHeartbeatRun(entry.run.internal, entry.run.source)
     if (!isHeartbeat) continue
     abortedRunning += 1
-    entry.signalController.abort()
-    try { active.get(entry.run.sessionId)?.kill?.() } catch { /* noop */ }
+    abortSessionRuntime(entry, reason)
   }
 
   return { cancelledQueued, abortedRunning }
 }
 
-function scheduleMainLoopFollowup(sessionId: string, followup: MainLoopFollowupRequest) {
-  const delayMs = Math.max(0, Math.trunc(followup.delayMs || 0))
-  setTimeout(() => {
-    try {
-      const sessions = loadSessions()
-      const session = sessions[sessionId]
-      if (!session || !isMainMissionSession(session)) return
-      enqueueSessionRun({
-        sessionId,
-        message: followup.message,
-        internal: true,
-        source: 'main-loop-followup',
-        mode: 'collect',
-        dedupeKey: followup.dedupeKey,
-      })
-    } catch (err: any) {
-      log.warn('session-run', `Failed to enqueue main-loop followup for ${sessionId}`, err?.message || String(err))
-    }
-  }, delayMs)
-}
-
-export function isMainMissionSession(session: Record<string, unknown>): boolean {
-  const id = typeof session.id === 'string' ? session.id.trim() : ''
-  const name = typeof session.name === 'string' ? session.name.trim() : ''
-  const sessionType = typeof session.sessionType === 'string' ? session.sessionType : ''
-  if (id.startsWith('main-') || name === '__main__') return true
-  // Only orchestrated thread sessions should receive autonomous main-loop followups.
-  if (sessionType === 'orchestrated') return true
-  return false
-}
-
 async function drainExecution(executionKey: string): Promise<void> {
   if (state.runningByExecution.has(executionKey)) return
   const q = queueForExecution(executionKey)
@@ -271,49 +258,25 @@ async function drainExecution(executionKey: string): Promise<void> {
     })
 
     const failed = !!result.error
-    let followup: MainLoopFollowupRequest | null = null
-    try {
-      followup = handleMainLoopRunResult({
-        sessionId: next.run.sessionId,
-        message: next.message,
-        internal: next.run.internal,
-        source: next.run.source,
-        resultText: result.text,
-        error: result.error,
-        toolEvents: result.toolEvents,
-        inputTokens: result.inputTokens,
-        outputTokens: result.outputTokens,
-        estimatedCost: result.estimatedCost,
-      })
-    } catch (mainLoopErr: any) {
-      log.warn('session-run', `Main-loop update failed for ${next.run.id}`, mainLoopErr?.message || String(mainLoopErr))
-    }
-
-    next.run.status = failed ? 'failed' : 'completed'
-    next.run.endedAt = now()
-    next.run.error = result.error
+    const aborted = next.signalController.signal.aborted
+    next.run.status = aborted ? 'cancelled' : (failed ? 'failed' : 'completed')
+    next.run.endedAt = next.run.endedAt || now()
+    next.run.error = aborted ? (next.run.error || 'Cancelled') : result.error
     next.run.resultPreview = result.text?.slice(0, 280)
     emitRunMeta(next, next.run.status, {
       persisted: result.persisted,
       hasText: !!result.text,
-      error: result.error || null,
+      error: next.run.error || null,
     })
     log.info('session-run', `Run finished ${next.run.id}`, {
       sessionId: next.run.sessionId,
       status: next.run.status,
       persisted: result.persisted,
       hasText: !!result.text,
-      error: result.error || null,
+      error: next.run.error || null,
       durationMs: (next.run.endedAt || now()) - (next.run.startedAt || now()),
     })
     next.resolve(result)
-    if (!failed && followup) {
-      scheduleMainLoopFollowup(next.run.sessionId, followup)
-      log.info('session-run', `Queued main-loop followup after ${next.run.id}`, {
-        sessionId: next.run.sessionId,
-        delayMs: followup.delayMs,
-      })
-    }
   } catch (err: any) {
     const aborted = next.signalController.signal.aborted
     next.run.status = aborted ? 'cancelled' : 'failed'
@@ -326,19 +289,6 @@ async function drainExecution(executionKey: string): Promise<void> {
       error: next.run.error,
       durationMs: (next.run.endedAt || now()) - (next.run.startedAt || now()),
     })
-    try {
-      handleMainLoopRunResult({
-        sessionId: next.run.sessionId,
-        message: next.message,
-        internal: next.run.internal,
-        source: next.run.source,
-        resultText: '',
-        error: next.run.error,
-        toolEvents: [],
-      })
-    } catch {
-      // Main-loop bookkeeping failures should not affect queue execution.
-    }
     next.reject(err instanceof Error ? err : new Error(next.run.error))
   } finally {
     if (runtimeTimer) clearTimeout(runtimeTimer)
@@ -530,7 +480,9 @@ export function getSessionRunState(sessionId: string): {
   const running = state.runningByExecution.get(executionKey)
   const queued = queueForExecution(executionKey).filter((entry) => entry.run.sessionId === sessionId).length
   return {
-    runningRunId: running?.run.sessionId === sessionId ? running.run.id : undefined,
+    runningRunId: (running?.run.sessionId === sessionId && running.run.status === 'running')
+      ? running.run.id
+      : undefined,
     queueLength: queued,
   }
 }
@@ -564,8 +516,7 @@ export function cancelSessionRuns(sessionId: string, reason = 'Cancelled'): { ca
   let cancelledRunning = false
   if (running && running.run.sessionId === sessionId) {
     cancelledRunning = true
-    running.signalController.abort()
-    try { active.get(sessionId)?.kill?.() } catch { /* noop */ }
+    abortSessionRuntime(running, reason)
   }
   const cancelledQueued = cancelPendingForSession(sessionId, reason)
   return { cancelledQueued, cancelledRunning }

package/src/lib/server/session-tools/autonomy-tools.test.ts

@@ -0,0 +1,105 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import path from 'node:path'
+import { describe, it } from 'node:test'
+
+const thisFile = new URL(import.meta.url).pathname
+const toolsDir = path.dirname(thisFile)
+const serverDir = path.resolve(toolsDir, '..')
+
+function readToolSource(fileName: string): string {
+  return fs.readFileSync(path.join(toolsDir, fileName), 'utf-8')
+}
+
+function readServerSource(fileName: string): string {
+  return fs.readFileSync(path.join(serverDir, fileName), 'utf-8')
+}
+
+describe('browser workflow surface', () => {
+  it('advertises the higher-level browser actions in web.ts', () => {
+    const src = readToolSource('web.ts')
+    for (const action of ['read_page', 'extract_links', 'extract_form_fields', 'extract_table', 'fill_form', 'submit_form', 'scroll_until', 'download_file', 'complete_web_task']) {
+      assert.equal(src.includes(`'${action}'`), true, `web.ts should expose ${action}`)
+    }
+  })
+})
+
+describe('durable wait surface', () => {
+  it('advertises the durable wait actions in monitor.ts', () => {
+    const src = readToolSource('monitor.ts')
+    for (const action of ['wait_until', 'wait_for_http', 'wait_for_file', 'wait_for_task', 'wait_for_webhook', 'wait_for_page_change']) {
+      assert.equal(src.includes(`'${action}'`), true, `monitor.ts should expose ${action}`)
+    }
+    assert.equal(src.includes('createDurableWatch'), true)
+  })
+
+  it('routes schedule_wake through durable watch storage', () => {
+    const src = readToolSource('schedule.ts')
+    assert.equal(src.includes('createWatchJob'), true)
+    assert.equal(src.includes("type: 'time'"), true)
+  })
+})
+
+describe('delegation job handles', () => {
+  it('exposes subagent control actions', () => {
+    const src = readToolSource('subagent.ts')
+    for (const action of ['status', 'list', 'wait', 'cancel']) {
+      assert.equal(src.includes(`action === '${action}'`), true, `subagent.ts should handle ${action}`)
+    }
+    assert.equal(src.includes('createDelegationJob'), true)
+  })
+
+  it('builds delegate context from the invoking session and uses job records', () => {
+    const src = readToolSource('delegate.ts')
+    assert.equal(src.includes('buildDelegateContextFromSessionish'), true)
+    assert.equal(src.includes('createDelegationJob'), true)
+    assert.equal(src.includes('waitForDelegateJob'), true)
+  })
+
+  it('scheduler and daemon recover the durable autonomy jobs', () => {
+    const schedulerSrc = readServerSource('scheduler.ts')
+    const daemonSrc = readServerSource('daemon-state.ts')
+    assert.equal(schedulerSrc.includes('processDueWatchJobs'), true)
+    assert.equal(daemonSrc.includes('recoverStaleDelegationJobs'), true)
+  })
+})
+
+describe('primitive plugin surfaces', () => {
+  it('advertises mailbox and human-loop actions', () => {
+    const mailboxSrc = readToolSource('mailbox.ts')
+    const humanSrc = readToolSource('human-loop.ts')
+    for (const action of ['list_messages', 'list_threads', 'search_messages', 'read_message', 'download_attachment', 'reply', 'wait_for_email']) {
+      assert.equal(mailboxSrc.includes(`'${action}'`), true, `mailbox.ts should expose ${action}`)
+    }
+    for (const action of ['request_input', 'request_approval', 'wait_for_reply', 'wait_for_approval', 'list_mailbox', 'ack_mailbox', 'status']) {
+      assert.equal(humanSrc.includes(`'${action}'`), true, `human-loop.ts should expose ${action}`)
+    }
+  })
+
+  it('advertises document, extract, table, and crawl actions', () => {
+    const documentSrc = readToolSource('document.ts')
+    const extractSrc = readToolSource('extract.ts')
+    const tableSrc = readToolSource('table.ts')
+    const crawlSrc = readToolSource('crawl.ts')
+
+    for (const action of ['read', 'metadata', 'ocr', 'extract_tables', 'store', 'list', 'search', 'get', 'delete']) {
+      assert.equal(documentSrc.includes(`'${action}'`), true, `document.ts should expose ${action}`)
+    }
+    for (const action of ['extract_structured', 'summarize', 'status']) {
+      assert.equal(extractSrc.includes(`'${action}'`), true, `extract.ts should expose ${action}`)
+    }
+    for (const action of ['read', 'load_csv', 'load_xlsx', 'summarize', 'filter', 'sort', 'group', 'pivot', 'dedupe', 'join', 'write']) {
+      assert.equal(tableSrc.includes(`'${action}'`), true, `table.ts should expose ${action}`)
+    }
+    for (const action of ['crawl_site', 'follow_pagination', 'extract_sitemap', 'dedupe_pages', 'batch_extract']) {
+      assert.equal(crawlSrc.includes(`'${action}'`), true, `crawl.ts should expose ${action}`)
+    }
+  })
+
+  it('registers the primitive plugins in builtin-plugins.ts', () => {
+    const src = readServerSource('builtin-plugins.ts')
+    for (const moduleName of ['mailbox', 'human-loop', 'document', 'extract', 'table', 'crawl']) {
+      assert.equal(src.includes(`session-tools/${moduleName}`), true, `builtin-plugins.ts should import ${moduleName}`)
+    }
+  })
+})