@swarmclawai/swarmclaw 0.5.2 → 0.6.0

package/src/hooks/use-view-router.ts

@@ -2,48 +2,98 @@
 
 import { useEffect, useRef } from 'react'
 import { useAppStore } from '@/stores/use-app-store'
-import { VIEW_TO_PATH, PATH_TO_VIEW, DEFAULT_VIEW } from '@/lib/view-routes'
+import { useChatroomStore } from '@/stores/use-chatroom-store'
+import { parsePath, buildPath, DEFAULT_VIEW } from '@/lib/view-routes'
+
+/** Map a view to the relevant entity ID from stores */
+function getIdForView(view: string): string | null {
+  if (view === 'agents') return useAppStore.getState().currentAgentId
+  if (view === 'chatrooms') return useChatroomStore.getState().currentChatroomId
+  return null
+}
+
+/** Apply a parsed route to the stores */
+function applyRoute(view: string, id: string | null) {
+  if (view === 'agents') useAppStore.getState().setCurrentAgent(id)
+  if (view === 'chatrooms') useChatroomStore.getState().setCurrentChatroom(id)
+}
 
 export function useViewRouter() {
   const fromPopstate = useRef(false)
+  const suppressPush = useRef(false)
 
-  // Mount: read pathname → set active view
+  // Mount: read pathname → set active view + entity ID
   useEffect(() => {
-    const view = PATH_TO_VIEW[window.location.pathname]
-    if (view) {
-      useAppStore.getState().setActiveView(view)
+    const parsed = parsePath(window.location.pathname)
+    if (parsed) {
+      suppressPush.current = true
+      useAppStore.getState().setActiveView(parsed.view)
+      applyRoute(parsed.view, parsed.id)
+      suppressPush.current = false
     } else {
       useAppStore.getState().setActiveView(DEFAULT_VIEW)
-      window.history.replaceState(null, '', VIEW_TO_PATH[DEFAULT_VIEW])
+      window.history.replaceState(null, '', buildPath(DEFAULT_VIEW))
     }
   }, [])
 
-  // State→URL: push new path when activeView changes
+  // State→URL: push new path when activeView or entity ID changes
   useEffect(() => {
-    let prev = useAppStore.getState().activeView
-    const unsub = useAppStore.subscribe((state) => {
-      const next = state.activeView
-      if (next === prev) return
-      prev = next
+    let prevView = useAppStore.getState().activeView
+    let prevId = getIdForView(prevView)
+
+    const unsubApp = useAppStore.subscribe((state) => {
+      if (suppressPush.current) return
+      const nextView = state.activeView
+      const nextId = getIdForView(nextView)
+
+      if (nextView === prevView && nextId === prevId) return
+      prevView = nextView
+      prevId = nextId
+
+      if (fromPopstate.current) {
+        fromPopstate.current = false
+        return
+      }
+      const targetPath = buildPath(nextView, nextId)
+      if (window.location.pathname !== targetPath) {
+        window.history.pushState(null, '', targetPath)
+      }
+    })
+
+    const unsubChatroom = useChatroomStore.subscribe((state) => {
+      if (suppressPush.current) return
+      const currentView = useAppStore.getState().activeView
+      if (currentView !== 'chatrooms') return
+      const nextId = state.currentChatroomId
+      if (nextId === prevId) return
+      prevId = nextId
+
       if (fromPopstate.current) {
         fromPopstate.current = false
         return
       }
-      const targetPath = VIEW_TO_PATH[next]
-      if (targetPath && window.location.pathname !== targetPath) {
+      const targetPath = buildPath('chatrooms', nextId)
+      if (window.location.pathname !== targetPath) {
         window.history.pushState(null, '', targetPath)
       }
     })
-    return unsub
+
+    return () => {
+      unsubApp()
+      unsubChatroom()
+    }
   }, [])
 
-  // Popstate: browser back/forward → update view
+  // Popstate: browser back/forward → update view + entity ID
   useEffect(() => {
     const onPopstate = () => {
-      const view = PATH_TO_VIEW[window.location.pathname]
-      if (view) {
+      const parsed = parsePath(window.location.pathname)
+      if (parsed) {
         fromPopstate.current = true
-        useAppStore.getState().setActiveView(view)
+        suppressPush.current = true
+        useAppStore.getState().setActiveView(parsed.view)
+        applyRoute(parsed.view, parsed.id)
+        suppressPush.current = false
       }
     }
     window.addEventListener('popstate', onPopstate)

package/src/instrumentation.ts

@@ -2,9 +2,23 @@ export async function register() {
   if (process.env.NEXT_RUNTIME === 'nodejs') {
     const { startScheduler } = await import('./lib/server/scheduler')
     const { resumeQueue } = await import('./lib/server/queue')
-    const { initWsServer } = await import('./lib/server/ws-hub')
+    const { initWsServer, closeWsServer } = await import('./lib/server/ws-hub')
+    const { stopDaemon } = await import('./lib/server/daemon-state')
     startScheduler()
     resumeQueue()
     initWsServer()
+
+    // Graceful shutdown: stop background services and close WS connections
+    let shuttingDown = false
+    const shutdown = async (signal: string) => {
+      if (shuttingDown) return
+      shuttingDown = true
+      console.log(`[server] ${signal} received, shutting down gracefully...`)
+      stopDaemon({ source: signal })
+      await closeWsServer()
+      process.exit(0)
+    }
+    process.on('SIGTERM', () => shutdown('SIGTERM'))
+    process.on('SIGINT', () => shutdown('SIGINT'))
   }
 }

package/src/lib/chat.ts

@@ -4,6 +4,7 @@ import { getStoredAccessKey } from './api-client'
 interface StreamChatOptions {
   internal?: boolean
   queueMode?: 'followup' | 'steer' | 'collect'
+  replyToId?: string
 }
 
 export async function streamChat(
@@ -39,6 +40,7 @@ export async function streamChat(
       attachedFiles,
       internal: !!opts?.internal,
       queueMode: opts?.queueMode,
+      ...(opts?.replyToId ? { replyToId: opts.replyToId } : {}),
     }),
   })
 

package/src/lib/cron-human.ts

@@ -0,0 +1,114 @@
+const DAY_NAMES = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'] as const
+const MONTH_NAMES = [
+  '', 'January', 'February', 'March', 'April', 'May', 'June',
+  'July', 'August', 'September', 'October', 'November', 'December',
+] as const
+
+function formatTime(hour: number, minute: number): string {
+  const period = hour >= 12 ? 'PM' : 'AM'
+  const h = hour === 0 ? 12 : hour > 12 ? hour - 12 : hour
+  const m = minute.toString().padStart(2, '0')
+  return `${h}:${m} ${period}`
+}
+
+function ordinal(n: number): string {
+  const s = ['th', 'st', 'nd', 'rd']
+  const v = n % 100
+  return n + (s[(v - 20) % 10] || s[v] || s[0])
+}
+
+function parseDowRange(field: string): string | null {
+  // Normalize 7 → 0 (both mean Sunday)
+  const normalized = field.replace(/7/g, '0')
+  if (normalized === '1-5') return 'Weekdays'
+  if (normalized === '0,6' || normalized === '6,0') return 'Weekends'
+  // Single day
+  const single = parseInt(normalized, 10)
+  if (!isNaN(single) && single >= 0 && single <= 6) return `Every ${DAY_NAMES[single]}`
+  // Comma-separated days
+  if (/^[0-6](,[0-6])+$/.test(normalized)) {
+    const days = normalized.split(',').map((d) => DAY_NAMES[parseInt(d, 10)])
+    return days.join(', ')
+  }
+  // Range like 1-3
+  const rangeMatch = normalized.match(/^([0-6])-([0-6])$/)
+  if (rangeMatch) {
+    const start = parseInt(rangeMatch[1], 10)
+    const end = parseInt(rangeMatch[2], 10)
+    return `${DAY_NAMES[start]} through ${DAY_NAMES[end]}`
+  }
+  return null
+}
+
+/**
+ * Convert a 5-field cron expression to a human-readable string.
+ * Falls back to the raw expression for patterns too complex to describe simply.
+ */
+export function cronToHuman(expression: string): string {
+  const raw = expression.trim()
+  const parts = raw.split(/\s+/)
+  if (parts.length !== 5) return raw
+
+  const [minute, hour, dom, month, dow] = parts
+
+  // Every minute
+  if (raw === '* * * * *') return 'Every minute'
+
+  // Step minutes: */N * * * *
+  if (/^\*\/\d+$/.test(minute) && hour === '*' && dom === '*' && month === '*' && dow === '*') {
+    const n = parseInt(minute.slice(2), 10)
+    return n === 1 ? 'Every minute' : `Every ${n} minutes`
+  }
+
+  // Step hours: 0 */N * * *
+  if (minute === '0' && /^\*\/\d+$/.test(hour) && dom === '*' && month === '*' && dow === '*') {
+    const n = parseInt(hour.slice(2), 10)
+    return n === 1 ? 'Every hour' : `Every ${n} hours`
+  }
+
+  // Fixed minute, every hour: M * * * *
+  if (/^\d+$/.test(minute) && hour === '*' && dom === '*' && month === '*' && dow === '*') {
+    const m = parseInt(minute, 10)
+    return m === 0 ? 'Every hour' : `Every hour at minute ${m}`
+  }
+
+  // From here, we need a fixed minute and hour
+  const fixedMinute = /^\d+$/.test(minute) ? parseInt(minute, 10) : null
+  const fixedHour = /^\d+$/.test(hour) ? parseInt(hour, 10) : null
+
+  if (fixedMinute === null || fixedHour === null) return raw
+
+  const time = formatTime(fixedHour, fixedMinute)
+  const atTime = fixedHour === 0 && fixedMinute === 0 ? 'at midnight' : `at ${time}`
+
+  // Specific day-of-week
+  if (dom === '*' && month === '*' && dow !== '*') {
+    const dowDesc = parseDowRange(dow)
+    if (!dowDesc) return raw
+    if (dowDesc === 'Weekdays' || dowDesc === 'Weekends') return `${dowDesc} ${atTime}`
+    return `${dowDesc} ${atTime}`
+  }
+
+  // Specific day-of-month (any month)
+  if (/^\d+$/.test(dom) && month === '*' && dow === '*') {
+    const d = parseInt(dom, 10)
+    return `${ordinal(d)} of every month ${atTime}`
+  }
+
+  // Specific month and day-of-month
+  if (/^\d+$/.test(dom) && /^\d+$/.test(month) && dow === '*') {
+    const d = parseInt(dom, 10)
+    const mo = parseInt(month, 10)
+    if (mo >= 1 && mo <= 12) {
+      return `${MONTH_NAMES[mo]} ${ordinal(d)} ${atTime}`
+    }
+  }
+
+  // Every day at specific time
+  if (dom === '*' && month === '*' && dow === '*') {
+    return `Every day ${atTime}`
+  }
+
+  // Fallback
+  return raw
+}

package/src/lib/memory.ts

@@ -40,3 +40,6 @@ export const updateMemory = (id: string, data: Partial<MemoryEntry>) =>
 
 export const deleteMemory = (id: string) =>
   api<string>('DELETE', `/memory/${id}`)
+
+export const getMemoryCounts = () =>
+  api<Record<string, number>>('GET', '/memory?counts=true')

package/src/lib/server/chat-execution.ts

@@ -55,6 +55,7 @@ export interface ExecuteChatTurnInput {
   onEvent?: (event: SSEEvent) => void
   modelOverride?: string
   heartbeatConfig?: { ackMaxChars: number; showOk: boolean; showAlerts: boolean; target: string | null }
+  replyToId?: string
 }
 
 export interface ExecuteChatTurnResult {
@@ -341,13 +342,26 @@ function resolveApiKeyForSession(session: SessionWithCredentials, provider: Prov
   return null
 }
 
+function stripMarkupForHeartbeat(text: string): string {
+  return text
+    .replace(/<[^>]*>/g, ' ')       // strip HTML tags
+    .replace(/&nbsp;/gi, ' ')       // decode nbsp
+    .replace(/^[*`~_]+/, '')        // strip leading markdown
+    .replace(/[*`~_]+$/, '')        // strip trailing markdown
+    .trim()
+}
+
+const HEARTBEAT_OK_RE = /HEARTBEAT_OK[^\w]{0,4}$/
+const NO_MESSAGE_RE = /NO_MESSAGE[^\w]{0,4}$/
+
 function classifyHeartbeatResponse(text: string, ackMaxChars: number): 'suppress' | 'strip' | 'keep' {
-  const trimmed = text.trim()
-  if (trimmed === 'HEARTBEAT_OK' || trimmed === 'NO_MESSAGE') return 'suppress'
-  const stripped = trimmed.replace(/HEARTBEAT_OK/gi, '').replace(/NO_MESSAGE/gi, '').trim()
+  const cleaned = stripMarkupForHeartbeat(text)
+  if (cleaned === 'HEARTBEAT_OK' || cleaned === 'NO_MESSAGE') return 'suppress'
+  if (HEARTBEAT_OK_RE.test(cleaned) || NO_MESSAGE_RE.test(cleaned)) return 'suppress'
+  const stripped = cleaned.replace(/HEARTBEAT_OK/gi, '').replace(/NO_MESSAGE/gi, '').trim()
   if (!stripped) return 'suppress'
   if (stripped.length <= ackMaxChars) return 'suppress'
-  return stripped.length < trimmed.length ? 'strip' : 'keep'
+  return stripped.length < cleaned.length ? 'strip' : 'keep'
 }
 
 function estimateConversationTone(text: string): string {
@@ -542,6 +556,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
       imagePath: imagePath || undefined,
       imageUrl: imageUrl || undefined,
       attachedFiles: attachedFiles?.length ? attachedFiles : undefined,
+      replyToId: input.replyToId || undefined,
     })
     session.lastActiveAt = Date.now()
     saveSessions(sessions)
@@ -857,6 +872,11 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     heartbeatClassification = classifyHeartbeatResponse(textForPersistence, heartbeatConfig?.ackMaxChars ?? 300)
   }
 
+  // Emit WS notification for every heartbeat completion so UI can show pulse
+  if (isHeartbeatRun && session.agentId) {
+    notify(`heartbeat:agent:${session.agentId}`)
+  }
+
   const shouldPersistAssistant = textForPersistence.length > 0
     && heartbeatClassification !== 'suppress'
 

package/src/lib/server/connectors/manager.ts

@@ -7,6 +7,8 @@ import { WORKSPACE_DIR } from '../data-dir'
 import { streamAgentChat } from '../stream-agent-chat'
 import { notify } from '../ws-hub'
 import { logExecution } from '../execution-log'
+import { enqueueSystemEvent } from '../system-events'
+import { requestHeartbeatNow } from '../heartbeat-wake'
 import type { Connector } from '@/types'
 import type { ConnectorInstance, InboundMessage, InboundMedia } from './types'
 import {
@@ -431,6 +433,15 @@ async function routeMessage(connector: Connector, msg: InboundMessage): Promise<
   const agent = agents[effectiveAgentId]
   if (!agent) return '[Error] Connector agent not found.'
 
+  // Enqueue system event + heartbeat wake for the agent
+  const preview = (msg.text || '').slice(0, 80)
+  enqueueSystemEvent(
+    `connector:${connector.id}:${msg.channelId}`,
+    `Inbound message from ${msg.platform}: ${preview}`,
+    'connector-message',
+  )
+  requestHeartbeatNow({ agentId: effectiveAgentId, reason: 'connector-message' })
+
   // Log connector trigger
   const triggerSessionKey = `connector:${connector.id}:${msg.channelId}`
   const allSessions = loadSessions()

package/src/lib/server/context-manager.ts

@@ -1,6 +1,17 @@
-import type { Message, ProviderType } from '@/types'
+import type { Message } from '@/types'
 import { getMemoryDb } from './memory-db'
 
+// --- LLM compaction constants ---
+
+const COMPACTION_CHUNK_BUDGET_RATIO = 0.4   // 40% of context per summarization chunk
+const COMPACTION_SAFETY_MARGIN = 1.2         // 20% buffer for token underestimation
+const COMPACTION_OVERHEAD_TOKENS = 4096      // reserved for summarization prompt + response
+const MAX_TOOL_FAILURES = 8
+const MAX_FAILURE_CHARS = 240
+
+/** Callback that sends a prompt to an LLM and returns response text */
+export type LLMSummarizer = (prompt: string) => Promise<string>
+
 // --- Context window sizes (tokens) per provider/model ---
 
 const PROVIDER_CONTEXT_WINDOWS: Record<string, number> = {
@@ -160,6 +171,125 @@ export function consolidateToMemory(
   return stored
 }
 
+// --- LLM compaction helpers ---
+
+/** Extract recent tool failures from messages for metadata appendix */
+export function extractToolFailures(messages: Message[]): string[] {
+  const failures: string[] = []
+  for (const m of messages) {
+    if (!m.toolEvents) continue
+    for (const te of m.toolEvents) {
+      if (!te.error) continue
+      const snippet = (te.output || '').slice(0, MAX_FAILURE_CHARS)
+      failures.push(`[${te.name}] error: ${snippet}`)
+    }
+  }
+  return failures.slice(-MAX_TOOL_FAILURES)
+}
+
+/** Extract file paths read and modified from tool events */
+export function extractFileOperations(messages: Message[]): { read: string[]; modified: string[] } {
+  const readSet = new Set<string>()
+  const modifiedSet = new Set<string>()
+
+  const READ_TOOLS = new Set(['read_file', 'list_files'])
+  const WRITE_TOOLS = new Set(['write_file', 'edit_file', 'copy_file', 'move_file', 'delete_file'])
+
+  for (const m of messages) {
+    if (!m.toolEvents) continue
+    for (const te of m.toolEvents) {
+      let parsed: Record<string, unknown> | null = null
+      try { parsed = JSON.parse(te.input) } catch { /* not JSON */ }
+      if (!parsed) continue
+
+      const paths: string[] = []
+      for (const key of ['filePath', 'sourcePath', 'destinationPath']) {
+        const v = parsed[key]
+        if (typeof v === 'string' && v) paths.push(v)
+      }
+
+      const isRead = READ_TOOLS.has(te.name)
+      const isWrite = WRITE_TOOLS.has(te.name)
+      for (const p of paths) {
+        if (isWrite) modifiedSet.add(p)
+        else if (isRead) readSet.add(p)
+      }
+    }
+  }
+  return { read: [...readSet], modified: [...modifiedSet] }
+}
+
+/** Split messages into chunks that fit within a token budget each */
+export function splitMessagesByTokenBudget(messages: Message[], budgetPerChunk: number): Message[][] {
+  if (messages.length === 0) return []
+  const chunks: Message[][] = []
+  let current: Message[] = []
+  let currentTokens = 0
+
+  for (const m of messages) {
+    const msgTokens = estimateMessagesTokens([m])
+    if (current.length > 0 && currentTokens + msgTokens > budgetPerChunk) {
+      chunks.push(current)
+      current = []
+      currentTokens = 0
+    }
+    current.push(m)
+    currentTokens += msgTokens
+  }
+  if (current.length > 0) chunks.push(current)
+  return chunks
+}
+
+/** Build an OpenClaw-aligned summarization prompt for a batch of messages */
+function buildSummarizationPrompt(messages: Message[]): string {
+  const transcript = messages.map((m) => {
+    let line = `[${m.role}]: ${m.text}`
+    if (m.toolEvents?.length) {
+      for (const te of m.toolEvents) {
+        const inp = (te.input || '').slice(0, 500)
+        const out = (te.output || '').slice(0, 500)
+        line += `\n  tool:${te.name}(${inp})${te.error ? ' [ERROR]' : ''} → ${out}`
+      }
+    }
+    return line
+  }).join('\n\n')
+
+  return [
+    'Summarize the following conversation transcript into structured notes.',
+    '',
+    'Rules:',
+    '- Preserve all decisions, TODOs, open questions, and constraints',
+    '- Preserve all opaque identifiers exactly as they appear (UUIDs, hashes, IDs, URLs, file paths, API keys, variable names)',
+    '- Note errors encountered and their resolutions',
+    '- Keep technical details needed to continue work (versions, configs, commands)',
+    '- Aim for 20-40% of original length',
+    '- Use structured notes with bullet points, not narrative prose',
+    '- Group by topic/theme when possible',
+    '',
+    '---TRANSCRIPT---',
+    transcript,
+    '---END TRANSCRIPT---',
+  ].join('\n')
+}
+
+/** Build a merge prompt for combining multiple partial summaries */
+function buildMergePrompt(partialSummaries: string[]): string {
+  const numbered = partialSummaries.map((s, i) => `--- Part ${i + 1} ---\n${s}`).join('\n\n')
+
+  return [
+    'Merge the following partial conversation summaries into a single cohesive summary.',
+    '',
+    'Rules:',
+    '- Remove redundancy across parts while preserving all important details',
+    '- Preserve all opaque identifiers exactly (UUIDs, hashes, IDs, URLs, file paths)',
+    '- Keep decisions, TODOs, open questions, constraints, and error resolutions',
+    '- Use structured notes with bullet points',
+    '- The result should be shorter than the combined input',
+    '',
+    numbered,
+  ].join('\n')
+}
+
 // --- Compaction strategies ---
 
 export interface CompactionResult {
@@ -178,15 +308,18 @@ export function slidingWindowCompact(
   return messages.slice(-keepLastN)
 }
 
-/** Summarize old messages, keep recent ones */
-export async function summarizeAndCompact(opts: {
+/** LLM-powered compaction: summarize old messages using an LLM, with progressive fallback */
+export async function llmCompact(opts: {
   messages: Message[]
-  keepLastN: number
+  provider: string
+  model: string
   agentId: string | null
   sessionId: string
-  generateSummary: (text: string) => Promise<string>
+  summarize: LLMSummarizer
+  keepLastN?: number
 }): Promise<CompactionResult> {
-  const { messages, keepLastN, agentId, sessionId, generateSummary } = opts
+  const { messages, provider, model, agentId, sessionId, summarize, keepLastN = 10 } = opts
+
   if (messages.length <= keepLastN) {
     return { messages, prunedCount: 0, memoriesStored: 0, summaryAdded: false }
   }
@@ -194,19 +327,75 @@ export async function summarizeAndCompact(opts: {
   const oldMessages = messages.slice(0, -keepLastN)
   const recentMessages = messages.slice(-keepLastN)
 
-  // Consolidate important info to memory before pruning
+  // 1. Consolidate important info to memory (existing regex extraction)
   const memoriesStored = consolidateToMemory(oldMessages, agentId, sessionId)
 
-  // Build text for summarization
-  const conversationText = oldMessages
-    .map((m) => `${m.role}: ${m.text}`)
-    .join('\n\n')
+  // 2. Extract metadata from old messages
+  const toolFailures = extractToolFailures(oldMessages)
+  const fileOps = extractFileOperations(oldMessages)
+
+  // 3. Compute chunk budget
+  const contextWindow = getContextWindowSize(provider, model)
+  const chunkBudget = Math.floor((contextWindow / COMPACTION_SAFETY_MARGIN) * COMPACTION_CHUNK_BUDGET_RATIO) - COMPACTION_OVERHEAD_TOKENS
+
+  // 4. Split old messages into chunks
+  const chunks = splitMessagesByTokenBudget(oldMessages, Math.max(chunkBudget, 2000))
+
+  // 5. Summarize chunks (progressive fallback on failure)
+  let finalSummary: string | null = null
+  try {
+    if (chunks.length === 1) {
+      finalSummary = await summarize(buildSummarizationPrompt(chunks[0]))
+    } else {
+      // Multi-chunk: summarize each, then merge
+      const partialSummaries: string[] = []
+      for (const chunk of chunks) {
+        try {
+          const partial = await summarize(buildSummarizationPrompt(chunk))
+          if (partial?.trim()) partialSummaries.push(partial.trim())
+        } catch {
+          // Skip failed chunks — progressive fallback
+        }
+      }
+      if (partialSummaries.length === 0) {
+        finalSummary = null // all chunks failed
+      } else if (partialSummaries.length === 1) {
+        finalSummary = partialSummaries[0]
+      } else {
+        finalSummary = await summarize(buildMergePrompt(partialSummaries))
+      }
+    }
+  } catch {
+    finalSummary = null
+  }
+
+  // 6. Fall back to sliding window if LLM summarization failed entirely
+  if (!finalSummary?.trim()) {
+    return {
+      messages: slidingWindowCompact(messages, keepLastN),
+      prunedCount: oldMessages.length,
+      memoriesStored,
+      summaryAdded: false,
+    }
+  }
+
+  // 7. Append metadata sections
+  const metaSections: string[] = [finalSummary.trim()]
 
-  const summary = await generateSummary(conversationText)
+  if (toolFailures.length > 0) {
+    metaSections.push('\n## Tool Failures\n' + toolFailures.join('\n'))
+  }
+  if (fileOps.read.length > 0 || fileOps.modified.length > 0) {
+    const parts: string[] = []
+    if (fileOps.read.length) parts.push('Read: ' + fileOps.read.join(', '))
+    if (fileOps.modified.length) parts.push('Modified: ' + fileOps.modified.join(', '))
+    metaSections.push('\n## File Operations\n' + parts.join('\n'))
+  }
 
+  // 8. Build context summary message
   const summaryMessage: Message = {
     role: 'assistant',
-    text: `[Context Summary]\n${summary}`,
+    text: `[Context Summary]\n${metaSections.join('\n')}`,
     time: Date.now(),
     kind: 'system',
   }
@@ -219,6 +408,29 @@ export async function summarizeAndCompact(opts: {
   }
 }
 
+/** Summarize old messages, keep recent ones. Delegates to llmCompact for LLM-powered summarization. */
+export async function summarizeAndCompact(opts: {
+  messages: Message[]
+  keepLastN: number
+  agentId: string | null
+  sessionId: string
+  provider: string
+  model: string
+  generateSummary: LLMSummarizer
+}): Promise<CompactionResult> {
+  const { messages, keepLastN, agentId, sessionId, provider, model, generateSummary } = opts
+
+  return llmCompact({
+    messages,
+    provider,
+    model,
+    agentId,
+    sessionId,
+    summarize: generateSummary,
+    keepLastN,
+  })
+}
+
 /** Auto-compact: triggers when estimated tokens exceed threshold */
 export function shouldAutoCompact(
   messages: Message[],