@onmars/lunar-core 0.4.7 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onmars/lunar-core",
-  "version": "0.4.7",
+  "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) */

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 */
@@ -582,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')
@@ -794,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(
@@ -849,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>