@swarmclawai/swarmclaw 0.6.7 → 0.6.8

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

@@ -1,4 +1,5 @@
 import fs from 'fs'
+import os from 'os'
 import {
   loadSessions,
   saveSessions,
@@ -17,6 +18,7 @@ import { estimateCost, checkBudget } from './cost'
 import { log } from './logger'
 import { logExecution } from './execution-log'
 import { streamAgentChat } from './stream-agent-chat'
+import { runLinkUnderstanding } from './link-understanding'
 import { buildSessionTools } from './session-tools'
 import { stripMainLoopMetaForPersistence } from './main-agent-loop'
 import { normalizeProviderEndpoint } from '@/lib/openclaw-endpoint'
@@ -74,6 +76,9 @@ export interface ExecuteChatTurnResult {
   persisted: boolean
   toolEvents: MessageToolEvent[]
   error?: string
+  inputTokens?: number
+  outputTokens?: number
+  estimatedCost?: number
 }
 
 function extractEventJson(line: string): SSEEvent | null {
@@ -389,18 +394,39 @@ function buildAgentSystemPrompt(session: any): string | undefined {
   if (!session.agentId) return undefined
   const agents = loadAgents()
   const agent = agents[session.agentId]
+  if (!agent) return undefined
 
   const settings = loadSettings()
   const parts: string[] = []
-  // Identity block — agent needs to know who it is
-  const identityLines = [`## My Identity`, `My name is ${agent.name}.`]
-  if (agent.description) identityLines.push(agent.description)
-  identityLines.push('I should always refer to myself by this name. I am not "Assistant" — I have my own name and identity.')
-  parts.push(identityLines.join(' '))
-  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. I am not just an "Assistant" — 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,heartbeats,autonomous_loop,multi_agent_chat`,
+  ]
+  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) {
@@ -408,7 +434,22 @@ function buildAgentSystemPrompt(session: any): string | undefined {
       if (skill?.content) parts.push(`## Skill: ${skill.name}\n${skill.content}`)
     }
   }
-  if (!parts.length) return undefined
+
+  // 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 user should be clear and concise.',
+    'When you have nothing to say, respond with ONLY: NO_MESSAGE',
+  ]
+  parts.push(thinkingHint.join('\n'))
+
+  // 7. Heartbeat Guidance
+  parts.push([
+    '## Heartbeats',
+    'You run on an autonomous heartbeat. If you receive a heartbeat poll and nothing needs attention, reply exactly: HEARTBEAT_OK',
+  ].join('\n'))
+
   return parts.join('\n\n')
 }
 
@@ -676,6 +717,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
   const apiKey = resolveApiKeyForSession(session, provider)
 
   if (!internal) {
+    const linkAnalysis = await runLinkUnderstanding(message)
     session.messages.push({
       role: 'user',
       text: message,
@@ -685,6 +727,14 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
       attachedFiles: attachedFiles?.length ? attachedFiles : undefined,
       replyToId: input.replyToId || undefined,
     })
+    if (linkAnalysis.length > 0) {
+      session.messages.push({
+        role: 'assistant',
+        kind: 'system',
+        text: `[Automated Link Analysis]\n${linkAnalysis.join('\n\n')}`,
+        time: Date.now(),
+      })
+    }
     session.lastActiveAt = Date.now()
     saveSessions(sessions)
   }
@@ -692,6 +742,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
   const systemPrompt = buildAgentSystemPrompt(session)
   const toolEvents: MessageToolEvent[] = []
   const streamErrors: string[] = []
+  const accumulatedUsage = { inputTokens: 0, outputTokens: 0, estimatedCost: 0 }
 
   let thinkingText = ''
   const emit = (ev: SSEEvent) => {
@@ -705,6 +756,17 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     if (ev.t === 'thinking' && ev.text) {
       thinkingText += ev.text
     }
+    if (ev.t === 'md' && ev.text) {
+      try {
+        const mdPayload = JSON.parse(ev.text) as Record<string, unknown>
+        const usage = mdPayload.usage as { inputTokens?: number; outputTokens?: number; estimatedCost?: number } | undefined
+        if (usage) {
+          if (typeof usage.inputTokens === 'number') accumulatedUsage.inputTokens += usage.inputTokens
+          if (typeof usage.outputTokens === 'number') accumulatedUsage.outputTokens += usage.outputTokens
+          if (typeof usage.estimatedCost === 'number') accumulatedUsage.estimatedCost += usage.estimatedCost
+        }
+      } catch { /* ignore non-JSON md events */ }
+    }
     collectToolEvent(ev, toolEvents)
     onEvent?.(ev)
   }
@@ -738,6 +800,8 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
   const directUsage = { inputTokens: 0, outputTokens: 0, received: false }
   const hasTools = !!sessionForRun.tools?.length && !NON_LANGGRAPH_PROVIDER_IDS.has(providerType)
 
+  let durationMs = 0
+  const startTs = Date.now()
   try {
     // Heartbeat runs get a small tail of recent messages so the agent can see
     // prior findings and avoid repeating the same searches. Full history is
@@ -747,7 +811,6 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
       : undefined
 
     console.log(`[chat-execution] provider=${providerType}, hasTools=${hasTools}, imagePath=${imagePath || 'none'}, attachedFiles=${attachedFiles?.length || 0}, tools=${(sessionForRun.tools || []).length}`)
-
     fullResponse = hasTools
       ? (await streamAgentChat({
           session: sessionForRun,
@@ -772,8 +835,9 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
           onUsage: (u) => { directUsage.inputTokens = u.inputTokens; directUsage.outputTokens = u.outputTokens; directUsage.received = true },
           signal: abortController.signal,
         })
-  } catch (err: any) {
-    errorMessage = err?.message || String(err)
+    durationMs = Date.now() - startTs
+  } catch (err: unknown) {
+    errorMessage = err instanceof Error ? err.message : String(err)
     const failureText = errorMessage || 'Run failed.'
     markProviderFailure(providerType, failureText)
     emit({ t: 'err', text: failureText })
@@ -811,6 +875,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
         totalTokens,
         estimatedCost: cost,
         timestamp: Date.now(),
+        durationMs,
       }
       appendUsage(sessionId, usageRecord)
       emit({
@@ -1024,6 +1089,18 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
   let heartbeatClassification: 'suppress' | 'strip' | 'keep' | null = null
   if (isHeartbeatRun && textForPersistence.length > 0) {
     heartbeatClassification = classifyHeartbeatResponse(textForPersistence, heartbeatConfig?.ackMaxChars ?? 300, toolEvents.length > 0)
+
+    // Deduplication logic from OpenClaw (nagging prevention)
+    // If the model repeats itself exactly within 24h, suppress the heartbeat alert.
+    if (heartbeatClassification !== 'suppress' && !toolEvents.length) {
+      const prevText = session.lastHeartbeatText || ''
+      const prevSentAt = session.lastHeartbeatSentAt || 0
+      const isDuplicate = prevText.trim() === textForPersistence.trim()
+        && (Date.now() - prevSentAt) < 24 * 60 * 60 * 1000
+      if (isDuplicate) {
+        heartbeatClassification = 'suppress'
+      }
+    }
   }
 
   // Emit WS notification for every heartbeat completion so UI can show pulse
@@ -1094,6 +1171,10 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
       } else {
         current.messages.push(nextAssistantMessage)
       }
+      if (isHeartbeatRun) {
+        current.lastHeartbeatText = persistedText
+        current.lastHeartbeatSentAt = nowTs
+      }
       changed = true
 
       // Conversation tone detection
@@ -1184,5 +1265,8 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     persisted: shouldPersistAssistant,
     toolEvents,
     error: errorMessage,
+    inputTokens: accumulatedUsage.inputTokens || undefined,
+    outputTokens: accumulatedUsage.outputTokens || undefined,
+    estimatedCost: accumulatedUsage.estimatedCost || undefined,
   }
 }

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/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')}`,