@swarmclawai/swarmclaw 0.6.7 → 0.7.0

package/src/lib/server/chatroom-helpers.ts

@@ -1,3 +1,4 @@
+import os from 'os'
 import { loadSettings, loadSkills, loadCredentials, decryptKey } from './storage'
 import { buildCurrentDateTimePromptContext } from './prompt-runtime-context'
 import { genId } from '@/lib/id'
@@ -49,11 +50,15 @@ function truncateText(text: string, max: number): string {
   return `${compact.slice(0, Math.max(0, max - 3))}...`
 }
 
+import { isImplicitlyMentioned } from './chatroom-orchestration'
+
 /** Parse @mentions from message text, returns matching agentIds */
 export function parseMentions(text: string, agents: Record<string, Agent>, memberIds: string[]): string[] {
   if (/@all\b/i.test(text)) return [...memberIds]
   const mentionPattern = /(?:^|[\s(])@([a-zA-Z0-9._-]+)/g
   const mentioned: string[] = []
+  
+  // 1. Explicit @mentions
   let match: RegExpExecArray | null
   while ((match = mentionPattern.exec(text)) !== null) {
     const token = normalizeMentionToken(match[1] || '')
@@ -67,6 +72,18 @@ export function parseMentions(text: string, agents: Record<string, Agent>, membe
       }
     }
   }
+
+  // 2. Implicit mentions (OpenClaw Style - Reading the room)
+  // Only if no explicit mentions found yet
+  if (mentioned.length === 0) {
+    for (const id of memberIds) {
+      const agent = agents[id]
+      if (agent && isImplicitlyMentioned(text, agent)) {
+        mentioned.push(id)
+      }
+    }
+  }
+
   return mentioned
 }
 
@@ -144,6 +161,8 @@ export function buildChatroomSystemPrompt(chatroom: Chatroom, agents: Record<str
     '- **Handle greetings like a human.** For "hello", "how are you", or light check-ins, give a normal conversational reply instead of tool/process commentary.',
     '- **Keep responses short** unless depth is needed. A few sentences is usually enough. This is a chat, not an essay.',
     '- **@mention teammates** only when you genuinely need their specific expertise. Don\'t tag people just to be polite.',
+    '- **Use Reactions**: To acknowledge a message, agree with a plan, or signal progress without sending a full text reply, use this format at the end of your message: [REACTION]{"emoji": "👍", "to": "message_id"}.',
+    '- **Implicit Mentions**: If someone uses your name, creature, or vibe in a message but doesn\'t @tag you, they are still "reading the room" and you may respond if it\'s relevant to you.',
     '- **Don\'t narrate your capabilities** unless asked. Just demonstrate them by doing things.',
     '- **Read the room.** Look at recent messages to understand context. Don\'t repeat what others already said.',
     '',
@@ -173,14 +192,39 @@ export function buildSyntheticSession(agent: Agent, chatroomId: string): Session
   }
 }
 
-/** Build agent's system prompt including skills */
+/** Build agent's system prompt including skills and identity context */
 export function buildAgentSystemPromptForChatroom(agent: Agent): string {
   const settings = loadSettings()
   const parts: string[] = []
-  if (settings.userPrompt) parts.push(settings.userPrompt)
+
+  // 1. Identity & Persona (Grounded OpenClaw Style)
+  const identityLines = [`## My Identity`]
+  identityLines.push(`Name: ${agent.name}`)
+  if (agent.emoji) identityLines.push(`Emoji: ${agent.emoji}`)
+  if (agent.creature) identityLines.push(`Creature: ${agent.creature}`)
+  if (agent.vibe) identityLines.push(`Vibe: ${agent.vibe}`)
+  if (agent.theme) identityLines.push(`Theme: ${agent.theme}`)
+  if (agent.description) identityLines.push(`Description: ${agent.description}`)
+  identityLines.push('I should always embody this identity in the group chat. I am a persistent companion with my own soul and presence.')
+  parts.push(identityLines.join('\n'))
+
+  // 2. Runtime & Capabilities (OpenClaw Style)
+  const runtimeLines = [
+    '## Runtime',
+    `os=${process.platform} | host=${os.hostname()} | agent=${agent.id} | provider=${agent.provider} | model=${agent.model}`,
+    `capabilities=tools,multi_agent_chatroom,collaborative_reasoning`,
+  ]
+  parts.push(runtimeLines.join('\n'))
+
+  // 3. User & DateTime Context
+  if (settings.userPrompt) parts.push(`## User Instructions\n${settings.userPrompt}`)
   parts.push(buildCurrentDateTimePromptContext())
-  if (agent.soul) parts.push(agent.soul)
-  if (agent.systemPrompt) parts.push(agent.systemPrompt)
+
+  // 4. Soul & Core Instructions
+  if (agent.soul) parts.push(`## Soul\n${agent.soul}`)
+  if (agent.systemPrompt) parts.push(`## System Prompt\n${agent.systemPrompt}`)
+
+  // 5. Skills (SwarmClaw Core)
   if (agent.skillIds?.length) {
     const allSkills = loadSkills()
     for (const skillId of agent.skillIds) {
@@ -188,6 +232,16 @@ export function buildAgentSystemPromptForChatroom(agent: Agent): string {
       if (skill?.content) parts.push(`## Skill: ${skill.name}\n${skill.content}`)
     }
   }
+
+  // 6. Thinking & Output Format (OpenClaw Style)
+  const thinkingHint = [
+    '## Output Format',
+    'If your model supports internal reasoning/thinking, put all internal analysis inside <think>...</think> tags.',
+    'Your final response to the chatroom should be clear and concise.',
+    'When you have nothing to say, respond with ONLY: NO_MESSAGE',
+  ]
+  parts.push(thinkingHint.join('\n'))
+
   return parts.join('\n\n')
 }
 
@@ -196,7 +250,11 @@ export function buildHistoryForAgent(chatroom: Chatroom, agentId: string, imageP
   const recentMessages = chatroom.messages.slice(-24)
   const includeAttachmentsFrom = Math.max(0, recentMessages.length - 6)
   const history = recentMessages.map((m, idx) => {
-    let msgText = `[${m.senderName}]: ${m.text}`
+    let msgText = `[${m.senderName}] (id: ${m.id}): ${m.text}`
+    if (m.reactions?.length) {
+      const reactionSummary = m.reactions.map(r => `${r.emoji} by ${r.reactorId}`).join(', ')
+      msgText += `\n[Reactions: ${reactionSummary}]`
+    }
     const includeAttachments = idx >= includeAttachmentsFrom
     if (includeAttachments && m.attachedFiles?.length) {
       const names = m.attachedFiles.map((f) => f.split('/').pop()).join(', ')

package/src/lib/server/chatroom-orchestration.ts

@@ -0,0 +1,74 @@
+import type { Chatroom, Agent } from '@/types'
+import { loadChatrooms, saveChatrooms } from './storage'
+import { notify } from './ws-hub'
+
+/**
+ * Normalizes text for comparison (lowercase, alphanumeric only)
+ */
+function normalizeForMatch(text: string): string {
+  return text.toLowerCase().replace(/[^a-z0-9]/g, '')
+}
+
+/**
+ * Determines if an agent was implicitly mentioned in a message.
+ * Matches against name, creature, and vibe.
+ */
+export function isImplicitlyMentioned(text: string, agent: Agent): boolean {
+  const normText = normalizeForMatch(text)
+  const normName = normalizeForMatch(agent.name)
+  const normCreature = agent.creature ? normalizeForMatch(agent.creature) : null
+  const normVibe = agent.vibe ? normalizeForMatch(agent.vibe) : null
+
+  if (normText.includes(normName)) return true
+  if (normCreature && normText.includes(normCreature)) return true
+  
+  // Vibe match: only if the vibe is a distinct single word like "skeptic" or "helper"
+  if (normVibe && normVibe.length > 3 && normVibe.split(' ').length === 1) {
+    if (normText.includes(normVibe)) return true
+  }
+
+  return false
+}
+
+/**
+ * Adds an "ack" reaction to a chatroom message on behalf of an agent.
+ * Useful for acknowledging tasks or agreeing with teammates.
+ */
+export function addAgentReaction(chatroomId: string, messageId: string, agentId: string, emoji: string) {
+  const chatrooms = loadChatrooms()
+  const chatroom = chatrooms[chatroomId] as Chatroom | undefined
+  if (!chatroom) return
+
+  const message = chatroom.messages.find(m => m.id === messageId)
+  if (!message) return
+
+  // Prevent duplicate reactions from the same agent
+  if (message.reactions.some(r => r.reactorId === agentId && r.emoji === emoji)) return
+
+  message.reactions.push({
+    emoji,
+    reactorId: agentId,
+    time: Date.now()
+  })
+
+  chatrooms[chatroomId] = chatroom
+  saveChatrooms(chatrooms)
+  notify(`chatroom:${chatroomId}`)
+}
+
+/**
+ * Parses [REACTION] tokens from agent output and applies them.
+ * Format: [REACTION]{"emoji": "👍", "to": "msg_id"}
+ */
+export function applyAgentReactionsFromText(text: string, chatroomId: string, agentId: string) {
+  const reactionRegex = /\[REACTION\]\s*(\{.*?\})/g
+  let match
+  while ((match = reactionRegex.exec(text)) !== null) {
+    try {
+      const data = JSON.parse(match[1])
+      if (data.emoji && data.to) {
+        addAgentReaction(chatroomId, data.to, agentId, data.emoji)
+      }
+    } catch { /* ignore invalid JSON */ }
+  }
+}

package/src/lib/server/clawhub-client.ts

@@ -4,23 +4,99 @@ export interface ClawHubSearchResult {
   skills: ClawHubSkill[]
   total: number
   page: number
+  nextCursor?: string | null
 }
 
-const CLAWHUB_BASE_URL = process.env.CLAWHUB_API_URL || 'https://clawhub.openclaw.dev/api'
+const CLAWHUB_BASE_URL = process.env.CLAWHUB_API_URL || 'https://clawhub.ai/api/v1'
+
+/**
+ * Raw shape returned by the ClawHub `/skills` endpoint.
+ * Fields are mapped to our internal `ClawHubSkill` type.
+ */
+interface ClawHubRawItem {
+  slug: string
+  displayName?: string
+  name?: string
+  summary?: string
+  description?: string
+  author?: string | { name?: string }
+  tags?: Record<string, string> | string[]
+  stats?: { downloads?: number; installsAllTime?: number; stars?: number }
+  latestVersion?: { version?: string; changelog?: string }
+  metadata?: Record<string, unknown> | null
+  url?: string
+  createdAt?: number
+  updatedAt?: number
+}
+
+function mapRawToSkill(raw: ClawHubRawItem): ClawHubSkill {
+  const name = raw.displayName || raw.name || raw.slug
+  const description = raw.summary || raw.description || ''
+  const author = typeof raw.author === 'string'
+    ? raw.author
+    : raw.author?.name || 'community'
+  const tags = Array.isArray(raw.tags)
+    ? raw.tags
+    : raw.tags ? Object.keys(raw.tags) : []
+  const downloads = raw.stats?.installsAllTime ?? raw.stats?.downloads ?? 0
+  const version = raw.latestVersion?.version || '1.0.0'
+  return {
+    id: raw.slug,
+    name,
+    description,
+    author,
+    tags,
+    downloads,
+    url: raw.url || `https://clawhub.ai/skills/${raw.slug}`,
+    version,
+  }
+}
 
 export async function searchClawHub(query: string, page = 1, limit = 20): Promise<ClawHubSearchResult> {
   try {
-    const url = `${CLAWHUB_BASE_URL}/skills?q=${encodeURIComponent(query)}&page=${page}&limit=${limit}`
-    const res = await fetch(url)
+    const params = new URLSearchParams({ limit: String(limit) })
+    if (query) params.set('q', query)
+    if (page > 1) params.set('page', String(page))
+
+    const url = `${CLAWHUB_BASE_URL}/skills?${params}`
+    const res = await fetch(url, { signal: AbortSignal.timeout(8000) })
     if (!res.ok) throw new Error(`ClawHub responded with ${res.status}`)
-    return await res.json()
-  } catch {
+
+    const data = await res.json() as { items?: ClawHubRawItem[]; skills?: ClawHubRawItem[]; nextCursor?: string | null; total?: number }
+
+    // ClawHub v1 returns { items, nextCursor }; fall back to { skills, total } for compat
+    const rawItems = data.items || data.skills || []
+    const skills = rawItems.map(mapRawToSkill)
+    const total = data.total ?? (data.nextCursor ? skills.length + 1 : skills.length)
+
+    return { skills, total, page, nextCursor: data.nextCursor }
+  } catch (err: unknown) {
+    console.warn('[clawhub] search failed:', err instanceof Error ? err.message : String(err))
     return { skills: [], total: 0, page }
   }
 }
 
 export async function fetchSkillContent(rawUrl: string): Promise<string> {
-  const res = await fetch(rawUrl)
+  // ClawHub skill pages are at /skills/<slug> — try raw content endpoint first
+  let contentUrl = rawUrl
+  if (contentUrl.startsWith('https://clawhub.ai/skills/') && !contentUrl.includes('/raw')) {
+    const slug = contentUrl.replace('https://clawhub.ai/skills/', '').replace(/\/$/, '')
+    // Try the raw content API first
+    const rawApiUrl = `${CLAWHUB_BASE_URL}/skills/${slug}/content`
+    try {
+      const res = await fetch(rawApiUrl, { signal: AbortSignal.timeout(8000) })
+      if (res.ok) {
+        const data = await res.json() as { content?: string }
+        if (data.content) return data.content
+      }
+    } catch {
+      // Fall through to direct fetch
+    }
+    // Try the raw endpoint pattern
+    contentUrl = `https://clawhub.ai/skills/${slug}/raw`
+  }
+
+  const res = await fetch(contentUrl, { signal: AbortSignal.timeout(10000) })
   if (!res.ok) throw new Error(`Failed to fetch skill content: ${res.status}`)
   return res.text()
 }

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

@@ -335,6 +335,7 @@ export function isCurrentGeneration(connectorId: string, gen: number): boolean {
 
 /** Get platform implementation lazily */
 export async function getPlatform(platform: string) {
+  // 1. Check Built-ins
   switch (platform) {
     case 'discord':  return (await import('./discord')).default
     case 'telegram': return (await import('./telegram')).default
@@ -347,8 +348,33 @@ export async function getPlatform(platform: string) {
     case 'googlechat': return (await import('./googlechat')).default
     case 'matrix':    return (await import('./matrix')).default
     case 'email':     return (await import('./email')).default
-    default: throw new Error(`Unknown platform: ${platform}`)
   }
+
+  // 2. Check Plugin-provided connectors
+  try {
+    const { getPluginManager } = await import('../plugins')
+    const manager = getPluginManager()
+    const pluginConnectors = manager.getConnectors()
+    const found = pluginConnectors.find(c => c.id === platform)
+    
+    if (found) {
+      return {
+        start: async (connector: Connector, token: string, onMessage: (msg: InboundMessage) => Promise<string>) => {
+          const stop = found.startListener ? await found.startListener(onMessage) : () => {}
+          return {
+            connector,
+            stop: async () => { if (stop) await stop() },
+            sendMessage: found.sendMessage,
+            authenticated: true,
+          }
+        }
+      }
+    }
+  } catch (err: unknown) {
+    console.warn(`[connector] Failed to check plugins for platform "${platform}":`, err instanceof Error ? err.message : String(err))
+  }
+
+  throw new Error(`Unknown platform: ${platform}`)
 }
 
 export function formatMediaLine(media: InboundMedia): string {

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

@@ -1,14 +1,25 @@
 import type { Message } from '@/types'
 import { getMemoryDb } from './memory-db'
 
+import { repairTranscriptConsistency } from './transcript-repair'
+
 // --- 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 BASE_CHUNK_RATIO = 0.4
+const MIN_CHUNK_RATIO = 0.15
+const COMPACTION_SAFETY_MARGIN = 1.2
+const COMPACTION_OVERHEAD_TOKENS = 4096
 const MAX_TOOL_FAILURES = 8
 const MAX_FAILURE_CHARS = 240
 
+const MERGE_SUMMARIES_INSTRUCTIONS =
+  'Merge these partial summaries into a single cohesive summary. Preserve decisions,' +
+  ' TODOs, open questions, and any constraints.'
+
+const IDENTIFIER_PRESERVATION_INSTRUCTIONS =
+  'Preserve all opaque identifiers exactly as written (no shortening or reconstruction), ' +
+  'including UUIDs, hashes, IDs, tokens, API keys, hostnames, IPs, ports, URLs, and file names.'
+
 /** Callback that sends a prompt to an LLM and returns response text */
 export type LLMSummarizer = (prompt: string) => Promise<string>
 
@@ -132,6 +143,44 @@ export function getContextStatus(
   }
 }
 
+// --- Context degradation warnings ---
+
+/** Returns a warning string when context usage exceeds thresholds, or null if within safe bounds. */
+export function getContextDegradationWarning(
+  messages: Message[],
+  systemPromptTokens: number,
+  provider: string,
+  model: string,
+): string | null {
+  const status = getContextStatus(messages, systemPromptTokens, provider, model)
+  const pct = status.percentUsed
+  const remaining = status.contextWindow - status.estimatedTokens
+  const estTurnsLeft = Math.max(0, Math.floor(remaining / 2000))
+
+  if (pct >= 85) {
+    return [
+      `[CONTEXT_WARNING] Context window is ${pct}% full (${status.estimatedTokens.toLocaleString()} / ${status.contextWindow.toLocaleString()} tokens).`,
+      `Estimated remaining capacity: ~${estTurnsLeft} turns.`,
+      'CRITICAL: Save essential state to memory immediately. Summarize key findings, decisions, and next steps.',
+      'Consider completing the current subtask and storing a checkpoint before context is exhausted.',
+    ].join(' ')
+  }
+  if (pct >= 70) {
+    return [
+      `[CONTEXT_WARNING] Context window is ${pct}% full.`,
+      `Estimated remaining capacity: ~${estTurnsLeft} turns.`,
+      'Recommended: Store important progress notes to memory. Prioritize completing high-value subtasks.',
+    ].join(' ')
+  }
+  if (pct >= 60) {
+    return [
+      `[CONTEXT_WARNING] Context window is ${pct}% full (~${estTurnsLeft} turns remaining).`,
+      'Consider saving intermediate state to memory for continuity.',
+    ].join(' ')
+  }
+  return null
+}
+
 // --- Memory consolidation ---
 
 /** Extract important facts from old messages before pruning */
@@ -240,6 +289,54 @@ export function splitMessagesByTokenBudget(messages: Message[], budgetPerChunk:
   return chunks
 }
 
+/** Compute adaptive chunk ratio based on average message size. */
+export function computeAdaptiveChunkRatio(messages: Message[], contextWindow: number): number {
+  if (messages.length === 0) return BASE_CHUNK_RATIO
+  const totalTokens = estimateMessagesTokens(messages)
+  const avgTokens = totalTokens / messages.length
+  const safeAvgTokens = avgTokens * COMPACTION_SAFETY_MARGIN
+  const avgRatio = safeAvgTokens / contextWindow
+
+  if (avgRatio > 0.1) {
+    const reduction = Math.min(avgRatio * 2, BASE_CHUNK_RATIO - MIN_CHUNK_RATIO)
+    return Math.max(MIN_CHUNK_RATIO, BASE_CHUNK_RATIO - reduction)
+  }
+  return BASE_CHUNK_RATIO
+}
+
+/** Summarize in hierarchical stages if context is very large */
+export async function summarizeInStages(opts: {
+  messages: Message[]
+  contextWindow: number
+  summarize: LLMSummarizer
+  maxChunkTokens: number
+}): Promise<string> {
+  const { messages, summarize, maxChunkTokens } = opts
+  const totalTokens = estimateMessagesTokens(messages)
+
+  if (totalTokens <= maxChunkTokens || messages.length < 4) {
+    return summarize(buildSummarizationPrompt(messages))
+  }
+
+  const chunks = splitMessagesByTokenBudget(messages, maxChunkTokens)
+  if (chunks.length <= 1) {
+    return summarize(buildSummarizationPrompt(messages))
+  }
+
+  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 chunk */ }
+  }
+
+  if (partialSummaries.length === 0) return 'Summary unavailable.'
+  if (partialSummaries.length === 1) return partialSummaries[0]
+
+  return summarize(buildMergePrompt(partialSummaries))
+}
+
 /** Build an OpenClaw-aligned summarization prompt for a batch of messages */
 function buildSummarizationPrompt(messages: Message[]): string {
   const transcript = messages.map((m) => {
@@ -258,13 +355,13 @@ function buildSummarizationPrompt(messages: Message[]): string {
     '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',
+    '- Preserve all decisions, TODOs, open questions, and any constraints.',
+    `- ${IDENTIFIER_PRESERVATION_INSTRUCTIONS}`,
+    '- 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,
@@ -280,11 +377,12 @@ function buildMergePrompt(partialSummaries: string[]): string {
     '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',
+    '- Remove redundancy across parts while preserving all important details.',
+    `- ${MERGE_SUMMARIES_INSTRUCTIONS}`,
+    `- ${IDENTIFIER_PRESERVATION_INSTRUCTIONS}`,
+    '- 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')
@@ -324,62 +422,46 @@ export async function llmCompact(opts: {
     return { messages, prunedCount: 0, memoriesStored: 0, summaryAdded: false }
   }
 
-  const oldMessages = messages.slice(0, -keepLastN)
-  const recentMessages = messages.slice(-keepLastN)
+  const repaired = repairTranscriptConsistency(messages)
+  const oldMessages = repaired.slice(0, -keepLastN)
+  const recentMessages = repaired.slice(-keepLastN)
 
-  // 1. Consolidate important info to memory (existing regex extraction)
+  // 1. Consolidate important info to memory
   const memoriesStored = consolidateToMemory(oldMessages, agentId, sessionId)
 
-  // 2. Extract metadata from old messages
+  // 2. Extract metadata
   const toolFailures = extractToolFailures(oldMessages)
   const fileOps = extractFileOperations(oldMessages)
 
-  // 3. Compute chunk budget
+  // 3. Compute adaptive budget
   const contextWindow = getContextWindowSize(provider, model)
-  const chunkBudget = Math.floor((contextWindow / COMPACTION_SAFETY_MARGIN) * COMPACTION_CHUNK_BUDGET_RATIO) - COMPACTION_OVERHEAD_TOKENS
+  const ratio = computeAdaptiveChunkRatio(oldMessages, contextWindow)
+  const chunkBudget = Math.floor((contextWindow / COMPACTION_SAFETY_MARGIN) * 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)
+  // 4. Hierarchical summarization
   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))
-      }
-    }
+    finalSummary = await summarizeInStages({
+      messages: oldMessages,
+      contextWindow,
+      summarize,
+      maxChunkTokens: Math.max(chunkBudget, 2000),
+    })
   } catch {
     finalSummary = null
   }
 
-  // 6. Fall back to sliding window if LLM summarization failed entirely
+  // 5. Fall back to sliding window if LLM summarization failed entirely
   if (!finalSummary?.trim()) {
     return {
-      messages: slidingWindowCompact(messages, keepLastN),
+      messages: slidingWindowCompact(repaired, keepLastN),
       prunedCount: oldMessages.length,
       memoriesStored,
       summaryAdded: false,
     }
   }
 
-  // 7. Append metadata sections
+  // 6. Append metadata sections
   const metaSections: string[] = [finalSummary.trim()]
 
   if (toolFailures.length > 0) {
@@ -392,7 +474,7 @@ export async function llmCompact(opts: {
     metaSections.push('\n## File Operations\n' + parts.join('\n'))
   }
 
-  // 8. Build context summary message
+  // 7. Build context summary message
   const summaryMessage: Message = {
     role: 'assistant',
     text: `[Context Summary]\n${metaSections.join('\n')}`,

package/src/lib/server/cost.test.ts

@@ -0,0 +1,73 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import type { Agent } from '@/types'
+import { checkAgentBudgetLimits, getAgentSpendWindows } from './cost.ts'
+
+function buildNowTs(): number {
+  const d = new Date()
+  d.setFullYear(2026, 2, 15)
+  d.setHours(12, 0, 0, 0)
+  return d.getTime()
+}
+
+test('getAgentSpendWindows aggregates hourly/daily/monthly windows', () => {
+  const now = buildNowTs()
+  const previousMonth = new Date(2026, 1, 20, 12, 0, 0, 0).getTime()
+
+  const sessions = {
+    s1: { agentId: 'agent-a' },
+    s2: { agentId: 'agent-b' },
+  }
+  const usage = {
+    s1: [
+      { timestamp: now - 20 * 60_000, estimatedCost: 1.25 },      // within hour
+      { timestamp: now - 3 * 60 * 60_000, estimatedCost: 0.5 },    // today
+      { timestamp: now - 26 * 60 * 60_000, estimatedCost: 2.0 },   // yesterday
+      { timestamp: previousMonth, estimatedCost: 4.0 },            // previous month
+    ],
+    s2: [
+      { timestamp: now - 5 * 60_000, estimatedCost: 99 },          // different agent
+    ],
+  }
+
+  const spend = getAgentSpendWindows('agent-a', now, { sessions, usage })
+  assert.equal(spend.hourly, 1.25)
+  assert.equal(spend.daily, 1.75)
+  assert.equal(spend.monthly, 3.75)
+})
+
+test('checkAgentBudgetLimits reports exceeded and warning windows', () => {
+  const now = buildNowTs()
+  const sessions = { s1: { agentId: 'agent-a' } }
+  const usage = {
+    s1: [
+      { timestamp: now - 15 * 60_000, estimatedCost: 1.25 },       // hourly over
+      { timestamp: now - 4 * 60 * 60_000, estimatedCost: 0.5 },    // daily near
+      { timestamp: now - 26 * 60 * 60_000, estimatedCost: 2.0 },   // monthly near
+    ],
+  }
+  const agent = {
+    id: 'agent-a',
+    name: 'Agent A',
+    hourlyBudget: 1.0,
+    dailyBudget: 2.0,
+    monthlyBudget: 4.0,
+  } as Agent
+
+  const result = checkAgentBudgetLimits(agent, now, { sessions, usage })
+  assert.equal(result.ok, false)
+  assert.deepEqual(result.exceeded.map((x) => x.window), ['hourly'])
+  assert.deepEqual(result.warnings.map((x) => x.window), ['daily', 'monthly'])
+})
+
+test('checkAgentBudgetLimits is ok when no caps are configured', () => {
+  const now = buildNowTs()
+  const sessions = { s1: { agentId: 'agent-a' } }
+  const usage = { s1: [{ timestamp: now - 10 * 60_000, estimatedCost: 10 }] }
+  const agent = { id: 'agent-a', name: 'Agent A' } as Agent
+
+  const result = checkAgentBudgetLimits(agent, now, { sessions, usage })
+  assert.equal(result.ok, true)
+  assert.equal(result.exceeded.length, 0)
+  assert.equal(result.warnings.length, 0)
+})