@onmars/lunar-core 0.4.4 → 0.4.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onmars/lunar-core",
-  "version": "0.4.4",
+  "version": "0.4.7",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/lib/hook-runner.ts

@@ -144,8 +144,22 @@ export function evaluateGuard(
 // Constants
 // ════════════════════════════════════════════════════════════
 
-/** Maximum transcript characters sent to LLM for summarization (~1000 tokens) */
-const MAX_TRANSCRIPT_CHARS = 4000
+/** Maximum transcript characters sent to LLM for summarization (~4000 tokens) */
+const MAX_TRANSCRIPT_CHARS = 16000
+
+/**
+ * Smart truncation: if the full text fits, return it.
+ * Otherwise keep the first 20% and last 80% with a cut marker.
+ * This ensures recent context (decisions, conclusions) is always captured.
+ */
+function smartTruncate(text: string, maxChars: number): string {
+  if (text.length <= maxChars) return text
+  const marker = '\n\n[... middle of conversation truncated ...]\n\n'
+  const available = maxChars - marker.length
+  const headSize = Math.floor(available * 0.2)
+  const tailSize = available - headSize
+  return text.slice(0, headSize) + marker + text.slice(-tailSize)
+}
 
 /**
  * System prompt for LLM-powered session summarization.
@@ -474,10 +488,10 @@ const executeSummarize: ActionExecutor = async (hook, context, providers) => {
 
   if (!summary && context.llm && context.messages.length >= 2) {
     try {
-      const transcript = context.messages
-        .map((m) => `${m.role}: ${m.content}`)
-        .join('\n')
-        .slice(0, MAX_TRANSCRIPT_CHARS)
+      const transcript = smartTruncate(
+        context.messages.map((m) => `${m.role}: ${m.content}`).join('\n'),
+        MAX_TRANSCRIPT_CHARS,
+      )
 
       log.debug(
         {
@@ -647,10 +661,10 @@ const executeJournal: ActionExecutor = async (hook, context, providers) => {
   }
 
   try {
-    const transcript = context.messages
-      .map((m) => `${m.role}: ${m.content}`)
-      .join('\n')
-      .slice(0, MAX_TRANSCRIPT_CHARS)
+    const transcript = smartTruncate(
+      context.messages.map((m) => `${m.role}: ${m.content}`).join('\n'),
+      MAX_TRANSCRIPT_CHARS,
+    )
 
     const journal = await context.llm(JOURNAL_PROMPT + transcript)
 
@@ -723,10 +737,10 @@ const executeExperience: ActionExecutor = async (hook, context, providers) => {
   }
 
   try {
-    const transcript = context.messages
-      .map((m) => `${m.role}: ${m.content}`)
-      .join('\n')
-      .slice(0, MAX_TRANSCRIPT_CHARS)
+    const transcript = smartTruncate(
+      context.messages.map((m) => `${m.role}: ${m.content}`).join('\n'),
+      MAX_TRANSCRIPT_CHARS,
+    )
 
     const experience = await context.llm(EXPERIENCE_PROMPT + transcript)
 

package/src/lib/memory-orchestrator.ts

@@ -146,6 +146,11 @@ export class MemoryOrchestrator implements MemoryProvider {
     return this.currentSessionDate
   }
 
+  /** Number of diary context entries loaded at sessionStart */
+  get diaryCount(): number {
+    return this.diaryResults.length
+  }
+
   /**
    * Destroy all providers.
    */

package/src/lib/router.ts

@@ -71,6 +71,9 @@ export class Router {
   /** Agent-level thinking defaults: agentId → thinking level */
   private agentThinkingMap = new Map<string, string>()
 
+  /** Per-session lock to serialize concurrent messages and prevent race conditions */
+  private routeLocks = new Map<string, Promise<void>>()
+
   /** Slash command handler */
   private commandHandler: CommandHandler
 
@@ -219,10 +222,26 @@ export class Router {
     // When Deimos and Hermes both handle different channels, their sessions
     // must not interfere even if they share a channel adapter.
     const sessionKey = `${agent.id}:${channelId}:${message.channelId}`
+
+    // Serialize concurrent messages for the same session to prevent race conditions
+    // (e.g., double "Nueva sesión" blocks when messages arrive while agent is responding)
+    const pending = this.routeLocks.get(sessionKey)
+    if (pending) {
+      await pending
+    }
+    let unlockRoute!: () => void
+    const routeLock = new Promise<void>((resolve) => {
+      unlockRoute = resolve
+    })
+    this.routeLocks.set(sessionKey, routeLock)
+
     const session = this.sessions.get(sessionKey)
 
     // ─── Command interception (before system prompt — zero token cost) ───
     if (this.commandHandler.isCommand(message.text)) {
+      // Show typing indicator while command executes (especially /clear with hooks)
+      const typingInterval = this.startTyping(channel, message.channelId)
+
       const ctx: CommandContext = {
         sessionKey,
         message,
@@ -244,11 +263,22 @@ export class Router {
         scheduler: this.scheduler,
       }
 
+      // For /clear: send immediate ack before hooks run (they can take 15-30s)
+      const commandName = message.text.trim().slice(1).split(/\s+/)[0]?.toLowerCase()
+      if (commandName === 'clear' || commandName === 'reset') {
+        await channel.send(message.channelId, {
+          text: '🧠 Guardando memoria de la sesión...',
+        })
+      }
+
       const response = await this.commandHandler.handle(message.text, ctx)
+      clearInterval(typingInterval)
       if (response) {
         const outgoing: OutgoingMessage = { text: this.redact(response) }
         await channel.send(message.channelId, outgoing)
         log.info({ command: message.text.split(/\s+/)[0] }, 'Command handled')
+        unlockRoute()
+        this.routeLocks.delete(sessionKey)
         return
       }
     }
@@ -397,6 +427,22 @@ export class Router {
       'Routing message',
     )
 
+    // New session greeting: send memory context summary on first message
+    if (!session) {
+      const orchestrator = this.memory as import('./memory-orchestrator').MemoryOrchestrator | undefined
+      const episodeId = orchestrator?.episodeId
+      const diaryCount = orchestrator?.diaryCount ?? 0
+      const moonName = moon?.name ?? 'Lunar'
+      const channelName = channelPersona?.name ?? message.channelId
+
+      const parts: string[] = [`🌑 **${moonName}** — Nueva sesión · #${channelName}`]
+      if (episodeId) parts.push(`📎 Episodio: \`${episodeId.slice(0, 8)}\``)
+      if (diaryCount > 0) parts.push(`🧠 ${diaryCount} entries de memoria cargadas`)
+      parts.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━')
+
+      await channel.send(message.channelId, { text: parts.join('\n') })
+    }
+
     // Start typing
     const typingInterval = this.startTyping(channel, message.channelId)
 
@@ -511,6 +557,10 @@ export class Router {
         text: '⚠️ Something went wrong. Please try again.',
         replyTo: message.id,
       })
+    } finally {
+      // Release the per-session lock so queued messages can proceed
+      unlockRoute()
+      this.routeLocks.delete(sessionKey)
     }
   }