@swarmclawai/swarmclaw 1.2.4 → 1.2.5

package/src/lib/server/execution-engine/task-attempt.ts

@@ -0,0 +1,303 @@
+import { checkAgentBudgetLimits } from '@/lib/server/cost'
+import { WORKSPACE_DIR } from '@/lib/server/data-dir'
+import { log } from '@/lib/server/logger'
+import { loadSettings } from '@/lib/server/settings/settings-repository'
+import { loadSessions } from '@/lib/server/sessions/session-repository'
+import { appendPersistedRunEvent, persistRun } from '@/lib/server/runtime/run-ledger'
+import { notify } from '@/lib/server/ws-hub'
+import { captureGuardianCheckpoint } from '@/lib/server/agents/guardian'
+import {
+  assessAutonomyRun,
+  executeSupervisorAutoActions,
+} from '@/lib/server/autonomy/supervisor-reflection'
+import { errorMessage, hmrSingleton } from '@/lib/shared-utils'
+import type {
+  Agent,
+  BoardTask,
+  Session,
+  SessionRunRecord,
+  SessionRunStatus,
+} from '@/types'
+import type { ExecuteChatTurnResult } from '@/lib/server/chat-execution/chat-execution-types'
+import type {
+  EnqueueTaskAttemptExecutionRequest,
+  ExecutionHandle,
+} from '@/lib/server/execution-engine/types'
+import { executeExecutionChatTurn } from '@/lib/server/execution-engine/chat-turn'
+
+const TAG = 'execution-engine'
+
+interface TaskAttemptState {
+  runningByTaskId: Map<string, ExecutionHandle<ExecuteChatTurnResult>>
+}
+
+const taskAttemptState = hmrSingleton<TaskAttemptState>(
+  '__swarmclaw_execution_engine_task_attempt__',
+  () => ({
+    runningByTaskId: new Map<string, ExecutionHandle<ExecuteChatTurnResult>>(),
+  }),
+)
+
+function messagePreview(text: string): string {
+  return (text || '').replace(/\s+/g, ' ').trim().slice(0, 140)
+}
+
+function looksIncomplete(text: string): boolean {
+  if (!text) return false
+  const trimmed = text.trim()
+  if (trimmed.endsWith('...') || trimmed.endsWith('…')) return true
+  if (/(?:^|\n)#{1,3}\s+(?:Step|Phase|Next)\s+\d/i.test(trimmed.slice(-200))) return true
+  const lastChunk = trimmed.slice(-300).toLowerCase()
+  return /\b(?:next i(?:'ll| will)|now i(?:'ll| will)|let me (?:now|next)|moving on to|proceeding to)\b/.test(lastChunk)
+}
+
+function chainCallerSignal(callerSignal: AbortSignal | undefined, controller: AbortController): void {
+  if (!callerSignal) return
+  if (callerSignal.aborted) {
+    controller.abort()
+    return
+  }
+  const onAbort = () => controller.abort()
+  callerSignal.addEventListener('abort', onAbort, { once: true })
+}
+
+function notifyExecutionState(sessionId: string): void {
+  notify('runs')
+  notify('sessions')
+  notify(`session:${sessionId}`)
+}
+
+function emitStatus(run: SessionRunRecord, status: SessionRunStatus, extra?: Record<string, unknown>): void {
+  appendPersistedRunEvent({
+    runId: run.id,
+    sessionId: run.sessionId,
+    kind: run.kind,
+    ownerType: run.ownerType,
+    ownerId: run.ownerId,
+    parentExecutionId: run.parentExecutionId,
+    phase: 'status',
+    status,
+    summary: run.resultPreview || run.error || undefined,
+    event: {
+      t: 'md',
+      text: JSON.stringify({
+        run: {
+          id: run.id,
+          sessionId: run.sessionId,
+          kind: run.kind,
+          ownerType: run.ownerType,
+          ownerId: run.ownerId,
+          status,
+          source: run.source,
+          internal: run.internal,
+          ...extra,
+        },
+      }),
+    },
+  })
+  notifyExecutionState(run.sessionId)
+}
+
+async function executeTaskAttemptTurn(
+  task: BoardTask,
+  agent: Agent,
+  sessionId: string,
+  signal: AbortSignal,
+): Promise<ExecuteChatTurnResult> {
+  if (agent.autoRecovery) {
+    const cwd = task.projectId
+      ? `${WORKSPACE_DIR}/projects/${task.projectId}`
+      : WORKSPACE_DIR
+    captureGuardianCheckpoint(cwd, `task:${task.id}`)
+  }
+
+  const settings = loadSettings()
+  const basePrompt = task.description || task.title
+  const prompt = [
+    basePrompt,
+    '',
+    'Completion requirements:',
+    '- Execute the task before replying; do not reply with only a plan.',
+    '- Include concrete evidence in your final summary: changed file paths, commands run, and verification results.',
+    '- If blocked, state the blocker explicitly and what input or permission is missing.',
+  ].join('\n')
+
+  let latestRun = await executeExecutionChatTurn({
+    sessionId,
+    message: prompt,
+    internal: false,
+    source: 'task',
+    runId: task.id,
+    signal,
+  })
+  let text = typeof latestRun.text === 'string' ? latestRun.text.trim() : ''
+  let previousSummary: string | null = null
+  let totalInputTokens = latestRun.inputTokens || 0
+  let totalOutputTokens = latestRun.outputTokens || 0
+  let totalEstimatedCost = Number(latestRun.estimatedCost || 0)
+
+  if (latestRun.error) {
+    return {
+      ...latestRun,
+      text,
+    }
+  }
+
+  const maxSupervisorFollowups = 2
+  for (let followupIndex = 0; followupIndex < maxSupervisorFollowups; followupIndex += 1) {
+    if (signal.aborted) break
+
+    const sessions = loadSessions()
+    const session = sessions[sessionId] as Session | undefined
+    const assessment = assessAutonomyRun({
+      runId: `${task.id}:attempt-${(task.attempts || 0) + 1}:step-${followupIndex + 1}`,
+      sessionId,
+      taskId: task.id,
+      agentId: agent.id,
+      source: 'task',
+      status: latestRun.error ? 'failed' : 'completed',
+      resultText: text,
+      error: latestRun.error,
+      toolEvents: latestRun.toolEvents,
+      mainLoopState: {
+        followupChainCount: followupIndex + 1,
+        summary: previousSummary,
+        missionCostUsd: totalEstimatedCost,
+      },
+      session: session || null,
+      settings,
+    })
+    if (assessment.shouldBlock) break
+    if (assessment.autoActions?.length) {
+      const result = await executeSupervisorAutoActions({
+        actions: assessment.autoActions,
+        sessionId,
+        agentId: agent.id,
+      })
+      if (result.blocked) break
+    }
+    const followupMessage = assessment.interventionPrompt
+      || (text && looksIncomplete(text)
+        ? 'Continue and complete the remaining steps. Provide a final summary when done.'
+        : null)
+    if (!followupMessage) break
+
+    if (agent.monthlyBudget || agent.dailyBudget || agent.hourlyBudget) {
+      try {
+        const followupBudget = checkAgentBudgetLimits(agent)
+        if (!followupBudget.ok) {
+          log.warn(TAG, `[task_attempt] Budget exceeded for "${agent.name}" during follow-up, stopping.`)
+          break
+        }
+      } catch {
+        // Best-effort safety check only.
+      }
+    }
+
+    previousSummary = text || previousSummary
+    const followUp = await executeExecutionChatTurn({
+      sessionId,
+      message: followupMessage,
+      internal: false,
+      source: 'task',
+      signal,
+    })
+    totalInputTokens += followUp.inputTokens || 0
+    totalOutputTokens += followUp.outputTokens || 0
+    totalEstimatedCost += Number(followUp.estimatedCost || 0)
+    text = typeof followUp.text === 'string' ? followUp.text.trim() : ''
+    latestRun = {
+      ...followUp,
+      text,
+      inputTokens: totalInputTokens,
+      outputTokens: totalOutputTokens,
+      estimatedCost: totalEstimatedCost,
+    }
+    if (latestRun.error) break
+  }
+
+  return {
+    ...latestRun,
+    text,
+    inputTokens: totalInputTokens,
+    outputTokens: totalOutputTokens,
+    estimatedCost: totalEstimatedCost,
+  }
+}
+
+export function enqueueTaskAttemptExecution(
+  input: EnqueueTaskAttemptExecutionRequest,
+): ExecutionHandle<ExecuteChatTurnResult> {
+  const existing = taskAttemptState.runningByTaskId.get(input.task.id)
+  if (existing) return { ...existing, deduped: true }
+
+  const executionId = input.executionId || `${input.task.id}:attempt-${(input.task.attempts || 0) + 1}`
+  const controller = new AbortController()
+  chainCallerSignal(input.callerSignal, controller)
+
+  const run: SessionRunRecord = {
+    id: executionId,
+    sessionId: input.sessionId,
+    missionId: input.task.missionId || null,
+    kind: 'task_attempt',
+    ownerType: 'task',
+    ownerId: input.task.id,
+    parentExecutionId: null,
+    recoveryPolicy: 'restart_recoverable',
+    source: 'task',
+    internal: false,
+    mode: 'task_attempt',
+    status: 'queued',
+    messagePreview: messagePreview(input.task.description || input.task.title),
+    queuedAt: Date.now(),
+  }
+
+  persistRun(run)
+  emitStatus(run, 'queued')
+
+  const promise = (async () => {
+    run.status = 'running'
+    run.startedAt = Date.now()
+    persistRun(run)
+    emitStatus(run, 'running')
+
+    try {
+      const result = await executeTaskAttemptTurn(input.task, input.agent, input.sessionId, controller.signal)
+      run.status = controller.signal.aborted
+        ? 'cancelled'
+        : (result.error ? 'failed' : 'completed')
+      run.endedAt = Date.now()
+      run.error = controller.signal.aborted ? (run.error || 'Cancelled') : result.error
+      run.resultPreview = result.text?.slice(0, 280)
+      if (typeof result.inputTokens === 'number') run.totalInputTokens = result.inputTokens
+      if (typeof result.outputTokens === 'number') run.totalOutputTokens = result.outputTokens
+      if (typeof result.estimatedCost === 'number') run.estimatedCost = result.estimatedCost
+      persistRun(run)
+      emitStatus(run, run.status, {
+        hasText: !!result.text,
+        error: run.error || null,
+      })
+      return result
+    } catch (err: unknown) {
+      run.status = controller.signal.aborted ? 'cancelled' : 'failed'
+      run.endedAt = Date.now()
+      run.error = errorMessage(err)
+      persistRun(run)
+      emitStatus(run, run.status, { error: run.error })
+      throw err
+    } finally {
+      const latest = taskAttemptState.runningByTaskId.get(input.task.id)
+      if (latest?.executionId === executionId) {
+        taskAttemptState.runningByTaskId.delete(input.task.id)
+      }
+    }
+  })()
+
+  const handle: ExecutionHandle<ExecuteChatTurnResult> = {
+    executionId,
+    promise,
+    abort: () => controller.abort(),
+  }
+  taskAttemptState.runningByTaskId.set(input.task.id, handle)
+  return handle
+}

package/src/lib/server/execution-engine/types.ts

@@ -0,0 +1,33 @@
+import type { ExecuteChatTurnResult } from '@/lib/server/chat-execution/chat-execution-types'
+import type { EnqueueSessionRunInput } from '@/lib/server/runtime/session-run-manager/types'
+import type { Agent, BoardTask } from '@/types'
+
+export interface ExecutionHandle<TResult> {
+  executionId: string
+  promise: Promise<TResult>
+  abort: () => void
+  position?: number
+  deduped?: boolean
+  coalesced?: boolean
+  unsubscribe?: () => void
+}
+
+export interface EnqueueSessionTurnExecutionRequest {
+  kind: 'session_turn'
+  input: EnqueueSessionRunInput
+}
+
+export interface EnqueueTaskAttemptExecutionRequest {
+  kind: 'task_attempt'
+  task: BoardTask
+  agent: Agent
+  sessionId: string
+  executionId?: string
+  callerSignal?: AbortSignal
+}
+
+export type EnqueueExecutionRequest =
+  | EnqueueSessionTurnExecutionRequest
+  | EnqueueTaskAttemptExecutionRequest
+
+export type ExecutionResult = ExecuteChatTurnResult

package/src/lib/server/gateways/gateway-profile-repository.ts

@@ -1,4 +1,48 @@
-export {
-  loadGatewayProfiles,
-  saveGatewayProfiles,
+import type { GatewayProfile } from '@/types'
+
+import {
+  deleteStoredItem,
+  loadGatewayProfiles as loadStoredGatewayProfiles,
+  loadStoredItem,
+  saveGatewayProfiles as saveStoredGatewayProfiles,
+  upsertStoredItem,
 } from '@/lib/server/storage'
+import { createRecordRepository } from '@/lib/server/persistence/repository-utils'
+
+export const gatewayProfileRepository = createRecordRepository<GatewayProfile>(
+  'gatewayProfiles',
+  {
+    get(id) {
+      return loadStoredItem('gateway_profiles', id) as GatewayProfile | null
+    },
+    list() {
+      return loadStoredGatewayProfiles() as Record<string, GatewayProfile>
+    },
+    upsert(id, value) {
+      upsertStoredItem('gateway_profiles', id, value)
+    },
+    replace(data) {
+      saveStoredGatewayProfiles(data as Record<string, GatewayProfile>)
+    },
+    patch(id, updater) {
+      const current = loadStoredItem('gateway_profiles', id) as GatewayProfile | null
+      const next = updater(current)
+      if (next === null) {
+        deleteStoredItem('gateway_profiles', id)
+        return null
+      }
+      upsertStoredItem('gateway_profiles', id, next)
+      return next
+    },
+    delete(id) {
+      deleteStoredItem('gateway_profiles', id)
+    },
+  },
+)
+
+export const loadGatewayProfiles = () => gatewayProfileRepository.list()
+export const loadGatewayProfile = (id: string) => gatewayProfileRepository.get(id)
+export const saveGatewayProfiles = (items: Record<string, GatewayProfile | Record<string, unknown>>) => gatewayProfileRepository.replace(items as Record<string, GatewayProfile>)
+export const saveGatewayProfile = (id: string, value: GatewayProfile | Record<string, unknown>) => gatewayProfileRepository.upsert(id, value as GatewayProfile)
+export const patchGatewayProfile = (id: string, updater: (current: GatewayProfile | null) => GatewayProfile | null) => gatewayProfileRepository.patch(id, updater)
+export const deleteGatewayProfile = (id: string) => gatewayProfileRepository.delete(id)

package/src/lib/server/gateways/gateway-profile-service.ts

@@ -0,0 +1,200 @@
+import type { Agent, AgentRoutingTarget, GatewayProfile, OpenClawDeploymentConfig, OpenClawGatewayStats } from '@/types'
+
+import { genId } from '@/lib/id'
+import { normalizeOpenClawEndpoint } from '@/lib/openclaw/openclaw-endpoint'
+import { listAgents, saveAgentMany } from '@/lib/server/agents/agent-repository'
+import { getGatewayProfiles } from '@/lib/server/agents/agent-runtime-config'
+import {
+  loadGatewayProfile,
+  loadGatewayProfiles,
+  saveGatewayProfiles,
+} from '@/lib/server/gateways/gateway-profile-repository'
+import { notify } from '@/lib/server/ws-hub'
+
+function normalizeTags(value: unknown): string[] {
+  if (!Array.isArray(value)) return []
+  return value
+    .map((entry) => (typeof entry === 'string' ? entry.trim() : ''))
+    .filter(Boolean)
+}
+
+function normalizeText(value: unknown): string | null {
+  return typeof value === 'string' && value.trim() ? value.trim() : null
+}
+
+function normalizeNullableNumber(value: unknown): number | null {
+  return typeof value === 'number' && Number.isFinite(value) ? value : null
+}
+
+function normalizeDeployment(value: unknown): OpenClawDeploymentConfig | null {
+  if (!value || typeof value !== 'object') return null
+  const deployment = value as Record<string, unknown>
+  return {
+    method: normalizeText(deployment.method) as OpenClawDeploymentConfig['method'],
+    provider: normalizeText(deployment.provider) as OpenClawDeploymentConfig['provider'],
+    remoteTarget: normalizeText(deployment.remoteTarget) as OpenClawDeploymentConfig['remoteTarget'],
+    useCase: normalizeText(deployment.useCase) as OpenClawDeploymentConfig['useCase'],
+    exposure: normalizeText(deployment.exposure) as OpenClawDeploymentConfig['exposure'],
+    managedBy: normalizeText(deployment.managedBy) as OpenClawDeploymentConfig['managedBy'],
+    localInstanceId: normalizeText(deployment.localInstanceId),
+    localPort: normalizeNullableNumber(deployment.localPort),
+    targetHost: normalizeText(deployment.targetHost),
+    sshHost: normalizeText(deployment.sshHost),
+    sshUser: normalizeText(deployment.sshUser),
+    sshPort: normalizeNullableNumber(deployment.sshPort),
+    sshKeyPath: normalizeText(deployment.sshKeyPath),
+    sshTargetDir: normalizeText(deployment.sshTargetDir),
+    image: normalizeText(deployment.image),
+    version: normalizeText(deployment.version),
+    lastDeployAt: normalizeNullableNumber(deployment.lastDeployAt),
+    lastDeployAction: normalizeText(deployment.lastDeployAction),
+    lastDeployProcessId: normalizeText(deployment.lastDeployProcessId),
+    lastDeploySummary: normalizeText(deployment.lastDeploySummary),
+    lastVerifiedAt: normalizeNullableNumber(deployment.lastVerifiedAt),
+    lastVerifiedOk: typeof deployment.lastVerifiedOk === 'boolean' ? deployment.lastVerifiedOk : null,
+    lastVerifiedMessage: normalizeText(deployment.lastVerifiedMessage),
+    lastBackupPath: normalizeText(deployment.lastBackupPath),
+  }
+}
+
+function normalizeStats(value: unknown): OpenClawGatewayStats | null {
+  if (!value || typeof value !== 'object') return null
+  const stats = value as Record<string, unknown>
+  return {
+    nodeCount: normalizeNullableNumber(stats.nodeCount) ?? undefined,
+    connectedNodeCount: normalizeNullableNumber(stats.connectedNodeCount) ?? undefined,
+    pendingNodePairings: normalizeNullableNumber(stats.pendingNodePairings) ?? undefined,
+    pairedDeviceCount: normalizeNullableNumber(stats.pairedDeviceCount) ?? undefined,
+    pendingDevicePairings: normalizeNullableNumber(stats.pendingDevicePairings) ?? undefined,
+    externalRuntimeCount: normalizeNullableNumber(stats.externalRuntimeCount) ?? undefined,
+  }
+}
+
+export function listOpenClawGatewayProfiles(): GatewayProfile[] {
+  return getGatewayProfiles('openclaw')
+}
+
+export function getGatewayProfileById(id: string): GatewayProfile | null {
+  return loadGatewayProfile(id)
+}
+
+export function createGatewayProfile(input: Record<string, unknown>): GatewayProfile {
+  const now = Date.now()
+  const gateways = loadGatewayProfiles()
+  const id = typeof input.id === 'string' && input.id.trim() ? input.id : `gateway-${genId()}`
+  const isDefault = input.isDefault === true
+
+  if (isDefault) {
+    for (const gateway of Object.values(gateways)) {
+      if (gateway) gateway.isDefault = false
+    }
+  }
+
+  const profile: GatewayProfile = {
+    id,
+    name: typeof input.name === 'string' && input.name.trim() ? input.name.trim() : 'OpenClaw Gateway',
+    provider: 'openclaw',
+    endpoint: normalizeOpenClawEndpoint(typeof input.endpoint === 'string' ? input.endpoint : undefined),
+    wsUrl: normalizeText(input.wsUrl),
+    credentialId: normalizeText(input.credentialId),
+    status: typeof input.status === 'string' && input.status.trim() ? input.status as GatewayProfile['status'] : 'unknown',
+    notes: typeof input.notes === 'string' ? input.notes : null,
+    tags: normalizeTags(input.tags),
+    lastError: null,
+    lastCheckedAt: null,
+    lastModelCount: null,
+    discoveredHost: typeof input.discoveredHost === 'string' ? input.discoveredHost : null,
+    discoveredPort: typeof input.discoveredPort === 'number' ? input.discoveredPort : null,
+    deployment: normalizeDeployment(input.deployment),
+    stats: normalizeStats(input.stats),
+    isDefault,
+    createdAt: now,
+    updatedAt: now,
+  }
+
+  gateways[id] = profile
+  saveGatewayProfiles(gateways)
+  notify('gateways')
+  return profile
+}
+
+export function updateGatewayProfile(id: string, input: Record<string, unknown>): GatewayProfile | null {
+  const gateways = loadGatewayProfiles()
+  const gateway = gateways[id]
+  if (!gateway) return null
+
+  // Clear isDefault on other gateways if this one is becoming default
+  if (input.isDefault === true) {
+    for (const [candidateId, g] of Object.entries(gateways)) {
+      if (candidateId !== id && g) g.isDefault = false
+    }
+  }
+
+  // Apply all field updates to the target gateway
+  if (input.name !== undefined) gateway.name = String(input.name || '').trim() || gateway.name
+  if (input.endpoint !== undefined) gateway.endpoint = normalizeOpenClawEndpoint(typeof input.endpoint === 'string' ? input.endpoint : undefined)
+  if (input.wsUrl !== undefined) gateway.wsUrl = normalizeText(input.wsUrl)
+  if (input.credentialId !== undefined) gateway.credentialId = normalizeText(input.credentialId)
+  if (input.status !== undefined) {
+    const nextStatus = typeof input.status === 'string' && input.status.trim()
+      ? input.status.trim() as GatewayProfile['status']
+      : 'unknown'
+    gateway.status = nextStatus
+  }
+  if (input.notes !== undefined) gateway.notes = typeof input.notes === 'string' ? input.notes : null
+  if (input.tags !== undefined) gateway.tags = normalizeTags(input.tags)
+  if (input.lastError !== undefined) gateway.lastError = typeof input.lastError === 'string' ? input.lastError : null
+  if (input.lastCheckedAt !== undefined) gateway.lastCheckedAt = normalizeNullableNumber(input.lastCheckedAt)
+  if (input.lastModelCount !== undefined) gateway.lastModelCount = normalizeNullableNumber(input.lastModelCount)
+  if (input.discoveredHost !== undefined) gateway.discoveredHost = typeof input.discoveredHost === 'string' ? input.discoveredHost : null
+  if (input.discoveredPort !== undefined) gateway.discoveredPort = normalizeNullableNumber(input.discoveredPort)
+  if (input.deployment !== undefined) gateway.deployment = { ...(gateway.deployment || {}), ...(normalizeDeployment(input.deployment) || {}) }
+  if (input.stats !== undefined) gateway.stats = { ...(gateway.stats || {}), ...(normalizeStats(input.stats) || {}) }
+  if (input.isDefault !== undefined) gateway.isDefault = input.isDefault === true
+  gateway.updatedAt = Date.now()
+
+  gateways[id] = gateway
+  saveGatewayProfiles(gateways)
+  notify('gateways')
+  return gateway
+}
+
+export function deleteGatewayProfileAndDetachAgents(id: string): boolean {
+  const gateways = loadGatewayProfiles()
+  if (!gateways[id]) return false
+  delete gateways[id]
+  saveGatewayProfiles(gateways)
+
+  const agents = listAgents({ includeTrashed: true })
+  const changed: Array<[string, Agent]> = []
+  for (const agent of Object.values(agents)) {
+    let nextAgent: Agent | null = null
+
+    if (agent.gatewayProfileId === id) {
+      nextAgent = {
+        ...agent,
+        gatewayProfileId: null,
+      }
+    }
+
+    if (Array.isArray(agent.routingTargets)) {
+      const nextTargets = agent.routingTargets.map((target: AgentRoutingTarget) => (
+        target.gatewayProfileId === id
+          ? { ...target, gatewayProfileId: null }
+          : target
+      ))
+      if (JSON.stringify(nextTargets) !== JSON.stringify(agent.routingTargets)) {
+        nextAgent = {
+          ...(nextAgent || agent),
+          routingTargets: nextTargets,
+        }
+      }
+    }
+
+    if (nextAgent) changed.push([nextAgent.id, nextAgent])
+  }
+
+  if (changed.length > 0) saveAgentMany(changed)
+  notify('gateways')
+  return true
+}

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

@@ -1,11 +1,12 @@
 import { createHash } from 'crypto'
 import fs from 'fs'
 import path from 'path'
-import type { Agent, MemoryEntry, MemoryReference, Session } from '@/types'
+import type { Agent, MemoryEntry, MemoryReference, Message, Session } from '@/types'
 import { getMemoryDb } from '@/lib/server/memory/memory-db'
 import { loadAgents, loadSessions, saveSessions } from '@/lib/server/storage'
 import { DATA_DIR } from '@/lib/server/data-dir'
 import { isDirectConnectorSession } from '@/lib/server/connectors/session-kind'
+import { getMessageCount, getRecentMessages } from '@/lib/server/messages/message-repository'
 
 const MAX_ARCHIVE_MESSAGES = 36
 const MAX_ARCHIVE_LINE_CHARS = 320
@@ -15,7 +16,7 @@ function toOneLine(value: unknown, maxChars: number): string {
   return String(value || '').replace(/\s+/g, ' ').trim().slice(0, maxChars)
 }
 
-function messageSpeaker(session: Session, agent: Partial<Agent> | null | undefined, message: Session['messages'][number]): string {
+function messageSpeaker(session: Session, agent: Partial<Agent> | null | undefined, message: Message): string {
   if (message.role === 'assistant') return agent?.name || 'assistant'
   return (isDirectConnectorSession(session) ? session.connectorContext?.senderName : null) || session.user || 'user'
 }
@@ -38,9 +39,10 @@ export function buildSessionArchivePayload(
   references: MemoryReference[]
   hash: string
 } | null {
-  if (!Array.isArray(session.messages) || session.messages.length < 2) return null
+  const messageCount = getMessageCount(session.id)
+  if (messageCount < 2) return null
 
-  const excerpt = session.messages.slice(-MAX_ARCHIVE_MESSAGES).map((message) => {
+  const excerpt = getRecentMessages(session.id, MAX_ARCHIVE_MESSAGES).map((message) => {
     const speaker = messageSpeaker(session, agent, message)
     const kind = message.kind && message.kind !== 'chat' ? ` [${message.kind}]` : ''
     const text = toOneLine(message.text, MAX_ARCHIVE_LINE_CHARS)
@@ -57,7 +59,7 @@ export function buildSessionArchivePayload(
     `session_type: ${toOneLine(session.sessionType || 'human', 32)}`,
     `agent_name: ${toOneLine(agent?.name || '', 80)}`,
     `last_active_iso: ${new Date(session.lastActiveAt || Date.now()).toISOString()}`,
-    `message_count: ${session.messages.length}`,
+    `message_count: ${messageCount}`,
     session.identityState?.personaLabel ? `persona_label: ${toOneLine(session.identityState.personaLabel, 120)}` : '',
     '',
     'Transcript excerpt:',
@@ -73,7 +75,7 @@ export function buildSessionArchivePayload(
       archiveHash: hash,
       sessionName: session.name,
       sessionType: session.sessionType || 'human',
-      messageCount: session.messages.length,
+      messageCount,
       lastActiveAt: session.lastActiveAt || Date.now(),
       personaLabel: session.identityState?.personaLabel || null,
     },
@@ -93,7 +95,7 @@ export function buildSessionArchiveMarkdown(
   payload: NonNullable<ReturnType<typeof buildSessionArchivePayload>>,
   agent?: Partial<Agent> | null,
 ): string {
-  const transcriptLines = session.messages.slice(-MAX_ARCHIVE_MESSAGES).map((message) => {
+  const transcriptLines = getRecentMessages(session.id, MAX_ARCHIVE_MESSAGES).map((message) => {
     const speaker = messageSpeaker(session, agent, message)
     const kind = message.kind && message.kind !== 'chat' ? ` (${message.kind})` : ''
     const toolSummary = Array.isArray(message.toolEvents) && message.toolEvents.length > 0
@@ -110,7 +112,7 @@ export function buildSessionArchiveMarkdown(
     `- Session Type: ${toOneLine(session.sessionType || 'human', 32)}`,
     `- Agent: ${toOneLine(agent?.name || session.agentId || 'unknown', 80)}`,
     `- Last Active: ${new Date(session.lastActiveAt || Date.now()).toISOString()}`,
-    `- Messages: ${session.messages.length}`,
+    `- Messages: ${getMessageCount(session.id)}`,
     session.identityState?.personaLabel ? `- Persona: ${toOneLine(session.identityState.personaLabel, 120)}` : '',
     '',
     '## Archive Snapshot',
@@ -168,7 +170,7 @@ export function syncSessionArchiveMemory(
       memoryId: session.sessionArchiveState?.memoryId || existing?.id || null,
       lastHash: payload.hash,
       lastSyncedAt: session.sessionArchiveState?.lastSyncedAt || existing?.updatedAt || null,
-      messageCount: session.messages.length,
+      messageCount: getMessageCount(session.id),
       exportPath: session.sessionArchiveState?.exportPath || null,
     }
     return { stored: false, memoryId: existing?.id || session.sessionArchiveState.memoryId || undefined, reason: 'unchanged' }
@@ -199,7 +201,7 @@ export function syncSessionArchiveMemory(
     memoryId: entry.id,
     lastHash: payload.hash,
     lastSyncedAt: Date.now(),
-    messageCount: session.messages.length,
+    messageCount: getMessageCount(session.id),
     exportPath,
   }