@onmars/lunar-core 0.4.5 → 0.5.0

package/package.json

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

package/src/lib/hook-runner.ts

@@ -42,7 +42,7 @@ export interface HookContext {
   /** Current session message count */
   messageCount: number
   /** Session messages (for summarize, promote) */
-  messages?: Array<{ role: string; content: string }>
+  messages?: Array<{ role: string; content: string; timestamp?: string }>
   /** Recall results — mutable (afterRecall boost modifies scores) */
   results?: MemoryResult[]
   /** Search query — mutable (beforeRecall can expand/modify) */
@@ -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

@@ -151,6 +151,55 @@ export class MemoryOrchestrator implements MemoryProvider {
     return this.diaryResults.length
   }
 
+  /**
+   * Refresh episode for a new session (called after /clear).
+   * Creates a new episode with today's date, replacing the stale one.
+   */
+  async refreshEpisode(channel?: string): Promise<void> {
+    if (!this.hookRunner?.hasHooks('sessionStart')) return
+
+    const context: HookContext = {
+      messageCount: 0,
+      channel,
+      sessionDate: new Date().toISOString().split('T')[0],
+    }
+    const result = await this.hookRunner.run('sessionStart', context)
+    if (result.episodeId) {
+      this.currentEpisodeId = result.episodeId
+      this.currentSessionDate = result.sessionDate
+      log.info(
+        { episodeId: result.episodeId, sessionDate: result.sessionDate },
+        'Episode refreshed after clear',
+      )
+    }
+    if (result.results?.length) {
+      this.diaryResults = result.results
+    }
+  }
+
+  /**
+   * Get or create an episode for a specific date (used by day-split in /clear).
+   * Does NOT change the current orchestrator state.
+   */
+  async getEpisodeForDate(date: string, channel?: string): Promise<string | undefined> {
+    // Find a provider that supports getOrCreateEpisode (Brain provider)
+    const brain = [...this.providersByName.values()].find(
+      (p) => (p as any).getOrCreateEpisode !== undefined,
+    ) as any
+    if (!brain?.getOrCreateEpisode) return undefined
+
+    try {
+      const episode = await brain.getOrCreateEpisode(date, channel)
+      return episode.id
+    } catch (err) {
+      log.warn(
+        { error: err instanceof Error ? err.message : String(err), date },
+        'Failed to get episode for date',
+      )
+      return undefined
+    }
+  }
+
   /**
    * Destroy all providers.
    */
@@ -291,7 +340,7 @@ export class MemoryOrchestrator implements MemoryProvider {
    *   3. afterSessionEnd hooks (promote → Engram facts → Brain)
    */
   async onSessionEnd(context: {
-    messages: Array<{ role: string; content: string }>
+    messages: Array<{ role: string; content: string; timestamp?: string }>
     sessionSummary?: string
     topics?: string[]
     episodeId?: string

package/src/lib/router.ts

@@ -60,7 +60,7 @@ export class Router {
    * In-memory message history per session — used for graceful session close.
    * Capped at MAX_SESSION_HISTORY messages per session to bound memory usage.
    */
-  private sessionMessages = new Map<string, Array<{ role: string; content: string }>>()
+  private sessionMessages = new Map<string, Array<{ role: string; content: string; timestamp?: string }>>()
   private static readonly MAX_SESSION_HISTORY = 200
 
   /** Tracks cumulative token usage per session */
@@ -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)
     }
   }
 
@@ -560,18 +582,53 @@ export class Router {
       if (messages.length > 0) {
         try {
           const orchestrator = this.memory as unknown as MemoryOrchestrator
-          const clearContext: Record<string, unknown> = {
-            messages,
-            topics: this.extractTopics(messages),
+
+          // Group messages by day (using timestamp if available, else today)
+          const today = new Date().toISOString().split('T')[0]
+          const messagesByDay = new Map<string, typeof messages>()
+
+          for (const msg of messages) {
+            const day = msg.timestamp ? msg.timestamp.split('T')[0] : today
+            if (!messagesByDay.has(day)) messagesByDay.set(day, [])
+            messagesByDay.get(day)!.push(msg)
+          }
+
+          // Sort days chronologically
+          const sortedDays = [...messagesByDay.keys()].sort()
+
+          // Extract channel from sessionKey (format: agentId:platform:channelId)
+          const channel = sessionKey.split(':').slice(1).join(':')
+
+          // Run hooks for each day's messages
+          for (const day of sortedDays) {
+            const dayMessages = messagesByDay.get(day)!
+            const clearContext: Record<string, unknown> = {
+              messages: dayMessages,
+              topics: this.extractTopics(dayMessages),
+              sessionDate: day,
+            }
+
+            // Get or create episode for this specific day
+            if (orchestrator?.getEpisodeForDate) {
+              const episodeId = await orchestrator.getEpisodeForDate(day, channel)
+              if (episodeId) clearContext.episodeId = episodeId
+            }
+
+            await this.memory!.onSessionEnd(
+              clearContext as Parameters<NonNullable<MemoryProvider['onSessionEnd']>>[0],
+            )
           }
-          if (orchestrator?.episodeId) clearContext.episodeId = orchestrator.episodeId
-          if (orchestrator?.sessionDate) clearContext.sessionDate = orchestrator.sessionDate
 
-          await this.memory.onSessionEnd(
-            clearContext as Parameters<NonNullable<MemoryProvider['onSessionEnd']>>[0],
-          )
           hooksRan = true
-          log.info({ sessionKey, messageCount: messages.length }, 'Memory hooks ran before clear')
+          log.info(
+            { sessionKey, messageCount: messages.length, days: sortedDays.length },
+            'Memory hooks ran before clear',
+          )
+
+          // Refresh episode for next session
+          if (orchestrator?.refreshEpisode) {
+            await orchestrator.refreshEpisode(channel)
+          }
         } catch (err) {
           const errMsg = err instanceof Error ? err.message : String(err)
           log.warn({ sessionKey, error: errMsg }, 'Memory hooks failed during /clear')
@@ -772,19 +829,48 @@ export class Router {
       closePromises.push(
         (async () => {
           try {
-            // Pass episodeId from orchestrator if available
             const orchestrator = this.memory as unknown as MemoryOrchestrator
-            const sessionContext: Record<string, unknown> = {
-              messages,
-              topics: this.extractTopics(messages),
+
+            // Group messages by day (using timestamp if available, else today)
+            const today = new Date().toISOString().split('T')[0]
+            const messagesByDay = new Map<string, typeof messages>()
+
+            for (const msg of messages) {
+              const day = msg.timestamp ? msg.timestamp.split('T')[0] : today
+              if (!messagesByDay.has(day)) messagesByDay.set(day, [])
+              messagesByDay.get(day)!.push(msg)
+            }
+
+            // Sort days chronologically
+            const sortedDays = [...messagesByDay.keys()].sort()
+
+            // Extract channel from sessionKey (format: agentId:platform:channelId)
+            const channel = sessionKey.split(':').slice(1).join(':')
+
+            // Run hooks for each day's messages
+            for (const day of sortedDays) {
+              const dayMessages = messagesByDay.get(day)!
+              const sessionContext: Record<string, unknown> = {
+                messages: dayMessages,
+                topics: this.extractTopics(dayMessages),
+                sessionDate: day,
+              }
+
+              // Get or create episode for this specific day
+              if (orchestrator?.getEpisodeForDate) {
+                const episodeId = await orchestrator.getEpisodeForDate(day, channel)
+                if (episodeId) sessionContext.episodeId = episodeId
+              }
+
+              await this.memory!.onSessionEnd!(
+                sessionContext as Parameters<NonNullable<MemoryProvider['onSessionEnd']>>[0],
+              )
             }
-            if (orchestrator?.episodeId) sessionContext.episodeId = orchestrator.episodeId
-            if (orchestrator?.sessionDate) sessionContext.sessionDate = orchestrator.sessionDate
 
-            await this.memory!.onSessionEnd!(
-              sessionContext as Parameters<NonNullable<MemoryProvider['onSessionEnd']>>[0],
+            log.info(
+              { sessionKey, messageCount: messages.length, days: sortedDays.length },
+              'Session closed gracefully',
             )
-            log.info({ sessionKey, messageCount: messages.length }, 'Session closed gracefully')
           } catch (err) {
             const errMsg = err instanceof Error ? err.message : String(err)
             log.warn(
@@ -827,7 +913,7 @@ export class Router {
       this.sessionMessages.set(sessionKey, history)
     }
 
-    history.push({ role, content })
+    history.push({ role, content, timestamp: new Date().toISOString() })
 
     // Cap to prevent unbounded memory growth
     if (history.length > Router.MAX_SESSION_HISTORY) {

package/src/types/memory.ts

@@ -78,7 +78,7 @@ export interface MemoryProvider {
    *   - Markdown: write daily note
    */
   onSessionEnd?(context: {
-    messages: Array<{ role: string; content: string }>
+    messages: Array<{ role: string; content: string; timestamp?: string }>
     sessionSummary?: string
     topics?: string[]
   }): Promise<void>