@onmars/lunar-core 0.4.5 → 0.4.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onmars/lunar-core",
-  "version": "0.4.5",
+  "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/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,6 +222,19 @@ 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) ───
@@ -261,6 +277,8 @@ export class Router {
         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
       }
     }
@@ -539,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)
     }
   }