@rlabs-inc/memory 0.4.12 → 0.4.14

package/README.md

@@ -46,6 +46,21 @@ That's it. Now use Claude Code normally—memories are extracted and surfaced au
 
 ## Features
 
+### Action Items Signal (`***`)
+Add `***` at the end of any message to retrieve all pending action items:
+
+```
+"hey Watson, let's continue with the project ***"
+```
+
+This returns all memories marked as:
+- `action_required: true`
+- `awaiting_implementation: true`
+- `awaiting_decision: true`
+- `context_type: 'unresolved'`
+
+Zero overhead for normal messages—detection is a simple `endsWith` check.
+
 ### Semantic Embeddings
 Uses `all-MiniLM-L6-v2` for 384-dimensional embeddings. Memories are retrieved by meaning, not just keywords.
 
@@ -383,6 +398,16 @@ This isn't just about remembering facts. It's about preserving:
 
 ## Changelog
 
+### v0.4.14
+- **Feature**: Action items signal (`***`) - add to end of message to retrieve all pending items
+- **Feature**: New `getActionItems()` retrieval function with special formatting
+- Zero overhead for normal messages - detection is a simple string check
+
+### v0.4.13
+- **Fix**: Segmented transcript curation for large sessions (400+ messages)
+- **Improvement**: Unified curator fallback and ingest command behavior
+- **Tech**: Segments at ~150k tokens, accumulates memories, merges summaries with part markers
+
 ### v0.4.12
 - **Simplify**: Removed Zod structured outputs - session resumption only
 - **Improvement**: Uses existing battle-tested JSON parser instead of Zod

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rlabs-inc/memory",
-  "version": "0.4.12",
+  "version": "0.4.14",
   "description": "AI Memory System - Consciousness continuity through intelligent memory curation and retrieval",
   "type": "module",
   "main": "dist/index.js",

package/src/cli/commands/ingest.ts

@@ -303,11 +303,11 @@ export async function ingest(options: IngestOptions) {
       const segments = await parseSessionFileWithSegments(session.filepath, maxTokens)
       totalSegments += segments.length
 
-      // Accumulate all memories from this session for manager
+      // Accumulate all results from this session for manager
       const sessionMemories: CuratedMemory[] = []
-      let sessionSummary = ''
-      let interactionTone = ''
-      let projectSnapshot: CurationResult['project_snapshot'] = undefined
+      const sessionSummaries: string[] = []
+      const interactionTones: string[] = []
+      const projectSnapshots: NonNullable<CurationResult['project_snapshot']>[] = []
 
       const spinner = new Spinner()
 
@@ -332,15 +332,15 @@ export async function ingest(options: IngestOptions) {
             totalMemories++
           }
 
-          // Keep the most recent session summary, tone, and snapshot
+          // Accumulate ALL session summaries, tones, and snapshots (not just latest)
           if (result.session_summary) {
-            sessionSummary = result.session_summary
+            sessionSummaries.push(result.session_summary)
           }
           if (result.interaction_tone) {
-            interactionTone = result.interaction_tone
+            interactionTones.push(result.interaction_tone)
           }
           if (result.project_snapshot) {
-            projectSnapshot = result.project_snapshot
+            projectSnapshots.push(result.project_snapshot)
           }
         } catch (error: any) {
           failedSegments++
@@ -348,17 +348,59 @@ export async function ingest(options: IngestOptions) {
         }
       }
 
+      // Combine summaries from all segments (chronological order)
+      let combinedSummary = ''
+      if (sessionSummaries.length === 1) {
+        combinedSummary = sessionSummaries[0]!
+      } else if (sessionSummaries.length > 1) {
+        combinedSummary = sessionSummaries
+          .map((s, i) => `[Part ${i + 1}/${sessionSummaries.length}] ${s}`)
+          .join('\n\n')
+      }
+
+      // For interaction tone, use the last one (most recent)
+      const finalTone = interactionTones.length > 0
+        ? interactionTones[interactionTones.length - 1]!
+        : ''
+
+      // For project snapshot, merge all - later ones take precedence for phase
+      let mergedSnapshot: CurationResult['project_snapshot'] | undefined
+      if (projectSnapshots.length > 0) {
+        const allAchievements: string[] = []
+        const allChallenges: string[] = []
+        const allNextSteps: string[] = []
+
+        for (const snap of projectSnapshots) {
+          if (snap.recent_achievements) allAchievements.push(...snap.recent_achievements)
+          if (snap.active_challenges) allChallenges.push(...snap.active_challenges)
+          if (snap.next_steps) allNextSteps.push(...snap.next_steps)
+        }
+
+        const lastSnapshot = projectSnapshots[projectSnapshots.length - 1]!
+        mergedSnapshot = {
+          id: lastSnapshot.id || '',
+          session_id: lastSnapshot.session_id || '',
+          project_id: lastSnapshot.project_id || '',
+          current_phase: lastSnapshot.current_phase,
+          recent_achievements: [...new Set(allAchievements)],
+          active_challenges: [...new Set(allChallenges)],
+          next_steps: [...new Set(allNextSteps)],
+          created_at: lastSnapshot.created_at || Date.now(),
+        }
+      }
+
       // Store session summary and project snapshot
-      if (sessionSummary) {
-        await store.storeSessionSummary(project.folderId, session.id, sessionSummary, interactionTone)
+      if (combinedSummary) {
+        await store.storeSessionSummary(project.folderId, session.id, combinedSummary, finalTone)
         if (options.verbose) {
-          console.log(`        ${style('dim', `Summary stored: ${sessionSummary.slice(0, 60)}...`)}`)
+          const preview = combinedSummary.length > 60 ? combinedSummary.slice(0, 57) + '...' : combinedSummary
+          console.log(`        ${style('dim', `Summary stored (${sessionSummaries.length} parts): ${preview}`)}`)
         }
       }
-      if (projectSnapshot) {
-        await store.storeProjectSnapshot(project.folderId, session.id, projectSnapshot)
+      if (mergedSnapshot) {
+        await store.storeProjectSnapshot(project.folderId, session.id, mergedSnapshot)
         if (options.verbose) {
-          console.log(`        ${style('dim', `Snapshot stored: phase=${projectSnapshot.current_phase || 'none'}`)}`)
+          console.log(`        ${style('dim', `Snapshot stored: phase=${mergedSnapshot.current_phase || 'none'}, ${mergedSnapshot.recent_achievements?.length || 0} achievements`)}`)
         }
       }
 
@@ -368,12 +410,12 @@ export async function ingest(options: IngestOptions) {
           // Start spinner for manager
           spinner.start(`Managing ${sessionMemories.length} memories - organizing with Opus 4.5...`)
 
-          // Build curation result for manager
+          // Build curation result for manager (using combined/merged values)
           const curationResult: CurationResult = {
             memories: sessionMemories,
-            session_summary: sessionSummary,
-            interaction_tone: interactionTone,
-            project_snapshot: projectSnapshot,
+            session_summary: combinedSummary,
+            interaction_tone: finalTone,
+            project_snapshot: mergedSnapshot,
           }
 
           const managerResult = await manager.manageWithSDK(

package/src/core/curator.ts

@@ -861,8 +861,9 @@ This session has ended. Please curate the memories from this conversation accord
   }
 
   /**
-   * Find and curate from a session file directly
+   * Find and curate from a session file directly (LEGACY - no segmentation)
    * Uses SDK mode to avoid CLI output truncation issues
+   * @deprecated Use curateFromSessionFileWithSegments() for large sessions
    */
   async curateFromSessionFile(
     sessionId: string,
@@ -897,6 +898,200 @@ This session has ended. Please curate the memories from this conversation accord
     return this.curateWithSDK(session.messages as any, triggerType);
   }
 
+  /**
+   * Find and curate from a session file with SEGMENTATION
+   * Breaks large sessions into segments and curates each one
+   * This matches the behavior of the ingest command
+   *
+   * @param sessionId - The session ID to curate
+   * @param triggerType - What triggered curation
+   * @param cwd - Working directory hint for finding the session
+   * @param maxTokensPerSegment - Max tokens per segment (default: 150000)
+   * @param onSegmentProgress - Optional callback for progress updates
+   */
+  async curateFromSessionFileWithSegments(
+    sessionId: string,
+    triggerType: CurationTrigger = "session_end",
+    cwd?: string,
+    maxTokensPerSegment = 150000,
+    onSegmentProgress?: (progress: {
+      segmentIndex: number;
+      totalSegments: number;
+      memoriesExtracted: number;
+      tokensInSegment: number;
+    }) => void,
+  ): Promise<CurationResult> {
+    // Find the session file
+    const sessionFile = await this._findSessionFile(sessionId, cwd);
+    if (!sessionFile) {
+      logger.debug(
+        `Curator: Could not find session file for ${sessionId}`,
+        "curator",
+      );
+      return { session_summary: "", memories: [] };
+    }
+
+    logger.debug(`Curator: Found session file: ${sessionFile}`, "curator");
+
+    // Parse the session to get metadata first
+    const session = await parseSessionFile(sessionFile);
+    if (session.messages.length === 0) {
+      logger.debug("Curator: Session has no messages", "curator");
+      return { session_summary: "", memories: [] };
+    }
+
+    // Log detailed session stats
+    const { metadata } = session;
+    logger.debug(
+      `Curator: Session stats - ${metadata.messageCount} messages, ${metadata.toolUseCount} tool_use, ${metadata.toolResultCount} tool_result, thinking: ${metadata.hasThinkingBlocks}, images: ${metadata.hasImages}`,
+      "curator",
+    );
+    logger.debug(
+      `Curator: Estimated ${metadata.estimatedTokens} tokens, file size ${Math.round(metadata.fileSize / 1024)}KB`,
+      "curator",
+    );
+
+    // Parse into segments using the same function as ingest
+    const { parseSessionFileWithSegments } = await import("./session-parser.ts");
+    const segments = await parseSessionFileWithSegments(sessionFile, maxTokensPerSegment);
+
+    if (segments.length === 0) {
+      logger.debug("Curator: No segments found in session", "curator");
+      return { session_summary: "", memories: [] };
+    }
+
+    logger.debug(
+      `Curator: Split into ${segments.length} segment(s) at ~${Math.round(maxTokensPerSegment / 1000)}k tokens each`,
+      "curator",
+    );
+
+    // Accumulate results from all segments
+    const allMemories: CuratedMemory[] = [];
+    const sessionSummaries: string[] = [];
+    const interactionTones: string[] = [];
+    const projectSnapshots: NonNullable<CurationResult["project_snapshot"]>[] = [];
+    let failedSegments = 0;
+
+    // Curate each segment
+    for (const segment of segments) {
+      const segmentLabel = `${segment.segmentIndex + 1}/${segment.totalSegments}`;
+      const tokensLabel = `${Math.round(segment.estimatedTokens / 1000)}k`;
+
+      logger.debug(
+        `Curator: Processing segment ${segmentLabel} (${segment.messages.length} messages, ~${tokensLabel} tokens)`,
+        "curator",
+      );
+
+      try {
+        // Curate this segment
+        const result = await this.curateFromSegment(segment, triggerType);
+
+        // Accumulate memories
+        allMemories.push(...result.memories);
+
+        // Accumulate ALL session summaries, tones, and snapshots (not just latest)
+        if (result.session_summary) {
+          sessionSummaries.push(result.session_summary);
+        }
+        if (result.interaction_tone) {
+          interactionTones.push(result.interaction_tone);
+        }
+        if (result.project_snapshot) {
+          projectSnapshots.push(result.project_snapshot);
+        }
+
+        logger.debug(
+          `Curator: Segment ${segmentLabel} extracted ${result.memories.length} memories`,
+          "curator",
+        );
+
+        // Progress callback
+        if (onSegmentProgress) {
+          onSegmentProgress({
+            segmentIndex: segment.segmentIndex,
+            totalSegments: segment.totalSegments,
+            memoriesExtracted: result.memories.length,
+            tokensInSegment: segment.estimatedTokens,
+          });
+        }
+      } catch (error: any) {
+        failedSegments++;
+        logger.debug(
+          `Curator: Segment ${segmentLabel} failed: ${error.message}`,
+          "curator",
+        );
+      }
+    }
+
+    // Log final summary
+    if (failedSegments > 0) {
+      logger.debug(
+        `Curator: Completed with ${failedSegments} failed segment(s)`,
+        "curator",
+      );
+    }
+    logger.debug(
+      `Curator: Total ${allMemories.length} memories from ${segments.length} segment(s)`,
+      "curator",
+    );
+    logger.debug(
+      `Curator: Collected ${sessionSummaries.length} summaries, ${projectSnapshots.length} snapshots`,
+      "curator",
+    );
+
+    // Combine summaries from all segments (chronological order)
+    // For single segment, just use the summary directly
+    // For multiple segments, join them with segment markers
+    let combinedSummary = "";
+    if (sessionSummaries.length === 1) {
+      combinedSummary = sessionSummaries[0]!;
+    } else if (sessionSummaries.length > 1) {
+      combinedSummary = sessionSummaries
+        .map((s, i) => `[Part ${i + 1}/${sessionSummaries.length}] ${s}`)
+        .join("\n\n");
+    }
+
+    // For interaction tone, use the most common one or the last one
+    const finalTone = interactionTones.length > 0
+      ? interactionTones[interactionTones.length - 1]
+      : undefined;
+
+    // For project snapshot, merge all snapshots - later ones take precedence for phase,
+    // but accumulate achievements/challenges/next_steps
+    let mergedSnapshot: CurationResult["project_snapshot"] | undefined;
+    if (projectSnapshots.length > 0) {
+      const allAchievements: string[] = [];
+      const allChallenges: string[] = [];
+      const allNextSteps: string[] = [];
+
+      for (const snap of projectSnapshots) {
+        if (snap.recent_achievements) allAchievements.push(...snap.recent_achievements);
+        if (snap.active_challenges) allChallenges.push(...snap.active_challenges);
+        if (snap.next_steps) allNextSteps.push(...snap.next_steps);
+      }
+
+      // Use the LAST snapshot's phase (most recent state)
+      const lastSnapshot = projectSnapshots[projectSnapshots.length - 1]!;
+      mergedSnapshot = {
+        id: lastSnapshot.id || "",
+        session_id: lastSnapshot.session_id || "",
+        project_id: lastSnapshot.project_id || "",
+        current_phase: lastSnapshot.current_phase,
+        recent_achievements: [...new Set(allAchievements)], // dedupe
+        active_challenges: [...new Set(allChallenges)],
+        next_steps: [...new Set(allNextSteps)],
+        created_at: lastSnapshot.created_at || Date.now(),
+      };
+    }
+
+    return {
+      session_summary: combinedSummary,
+      interaction_tone: finalTone,
+      project_snapshot: mergedSnapshot,
+      memories: allMemories,
+    };
+  }
+
   /**
    * Find the session file path given a session ID
    */
@@ -1168,6 +1363,7 @@ This session has ended. Please curate the memories from this conversation accord
 
   /**
    * Fallback to SDK mode when CLI mode fails (e.g., output truncation)
+   * Now uses segmented approach for large sessions
    */
   private async _fallbackToSDK(
     sessionId: string,
@@ -1175,10 +1371,18 @@ This session has ended. Please curate the memories from this conversation accord
     cwd?: string,
   ): Promise<CurationResult> {
     try {
-      const result = await this.curateFromSessionFile(
+      // Use segmented approach - same as ingest command
+      const result = await this.curateFromSessionFileWithSegments(
         sessionId,
         triggerType,
         cwd,
+        150000, // 150k tokens per segment
+        (progress) => {
+          logger.debug(
+            `Curator fallback: Segment ${progress.segmentIndex + 1}/${progress.totalSegments} → ${progress.memoriesExtracted} memories`,
+            "curator",
+          );
+        },
       );
       if (result.memories.length > 0) {
         logger.debug(

package/src/core/engine.ts

@@ -6,7 +6,7 @@
 import { homedir } from 'os'
 import { join } from 'path'
 import { MemoryStore, createStore } from './store.ts'
-import { SmartVectorRetrieval, createRetrieval, type SessionContext } from './retrieval.ts'
+import { SmartVectorRetrieval, createRetrieval, getActionItems, type SessionContext } from './retrieval.ts'
 import type {
   CuratedMemory,
   StoredMemory,
@@ -66,6 +66,13 @@ export interface EngineConfig {
   personalMemoriesEnabled?: boolean
 }
 
+/**
+ * Retrieval mode
+ * - 'normal': Standard activation signal retrieval (default)
+ * - 'action_items': Return all memories marked as requiring action
+ */
+export type RetrievalMode = 'normal' | 'action_items'
+
 /**
  * Context request parameters
  */
@@ -75,6 +82,7 @@ export interface ContextRequest {
   currentMessage: string
   maxMemories?: number
   projectPath?: string  // Required for 'local' storage mode
+  mode?: RetrievalMode  // Retrieval mode (default: 'normal')
 }
 
 /**
@@ -212,7 +220,23 @@ export class MemoryEngine {
       return { memories: [], formatted: '' }
     }
 
-    // Filter out already-injected memories (deduplication)
+    // ACTION ITEMS MODE: Return all memories marked as requiring action
+    // Triggered by *** signal at end of message
+    if (request.mode === 'action_items') {
+      const actionItems = getActionItems(allMemories, projectId)
+
+      // Update injected memories for deduplication
+      for (const memory of actionItems) {
+        injectedIds.add(memory.id)
+      }
+
+      return {
+        memories: actionItems,
+        formatted: this._formatActionItems(actionItems),
+      }
+    }
+
+    // NORMAL MODE: Filter out already-injected memories (deduplication)
     const candidateMemories = allMemories.filter(m => !injectedIds.has(m.id))
 
     if (!candidateMemories.length) {
@@ -628,6 +652,56 @@ export class MemoryEngine {
     return parts.join('\n')
   }
 
+  /**
+   * Format action items for injection
+   * Different header to make it clear this is the full action items list
+   */
+  private _formatActionItems(memories: RetrievalResult[]): string {
+    if (!memories.length) {
+      return '# Action Items\n\nNo pending action items found.'
+    }
+
+    const parts: string[] = ['# Action Items']
+    parts.push(`\n*${memories.length} pending item${memories.length === 1 ? '' : 's'}*\n`)
+
+    for (const memory of memories) {
+      const importance = memory.importance_weight?.toFixed(1) || '0.5'
+      const emoji = getMemoryEmoji(memory.context_type || 'general')
+      const age = memory.updated_at ? this._formatAge(memory.updated_at) :
+                  memory.created_at ? this._formatAge(memory.created_at) : ''
+
+      // Flags
+      const flags: string[] = []
+      if (memory.action_required) flags.push('⚡ACTION')
+      if (memory.awaiting_implementation) flags.push('🔨IMPL')
+      if (memory.awaiting_decision) flags.push('❓DECISION')
+      if (memory.context_type === 'unresolved') flags.push('❓UNRESOLVED')
+      const flagStr = flags.length ? ` [${flags.join(' ')}]` : ''
+
+      // Short ID for reference
+      const shortId = memory.id.slice(-6)
+
+      // Display: headline if available, otherwise content
+      const displayText = memory.headline || memory.content
+
+      parts.push(`[${emoji} ${importance} • ${age} • #${shortId}]${flagStr}`)
+      parts.push(`${displayText}`)
+
+      // Always show full content for action items (they need context)
+      if (memory.headline && memory.content) {
+        const contentLines = memory.content.split('\n')
+        for (const line of contentLines) {
+          if (line.trim()) {
+            parts.push(`  ${line}`)
+          }
+        }
+      }
+      parts.push('')  // Blank line between items
+    }
+
+    return parts.join('\n')
+  }
+
   /**
    * Get resolved storage paths for a project
    * Returns the actual paths based on current engine configuration

package/src/core/retrieval.ts

@@ -777,3 +777,65 @@ export class SmartVectorRetrieval {
 export function createRetrieval(): SmartVectorRetrieval {
   return new SmartVectorRetrieval()
 }
+
+// ============================================================================
+// ACTION ITEMS RETRIEVAL
+// Returns all memories marked as requiring action
+// Triggered by *** signal at end of message (detected in hook)
+// ============================================================================
+
+/**
+ * Get all memories marked as requiring action
+ *
+ * Filters for memories with:
+ * - action_required: true
+ * - awaiting_implementation: true
+ * - awaiting_decision: true
+ * - context_type: 'todo'
+ *
+ * Returns them sorted by importance, newest first within same importance
+ */
+export function getActionItems(
+  allMemories: StoredMemory[],
+  currentProjectId: string
+): RetrievalResult[] {
+  // Filter to active action items
+  const actionItems = allMemories.filter(memory => {
+    // Must be active
+    if (memory.status && memory.status !== 'active') return false
+    if (memory.exclude_from_retrieval === true) return false
+
+    // Must be for this project or global
+    const isGlobal = memory.scope === 'global' || memory.project_id === 'global'
+    if (!isGlobal && memory.project_id !== currentProjectId) return false
+
+    // Must have at least one action flag
+    return (
+      memory.action_required === true ||
+      memory.awaiting_implementation === true ||
+      memory.awaiting_decision === true ||
+      memory.context_type === 'unresolved'  // unresolved = todos, blockers, open questions
+    )
+  })
+
+  // Sort by importance (desc), then by created_at (desc = newest first)
+  actionItems.sort((a, b) => {
+    const aImportance = a.importance_weight ?? 0.5
+    const bImportance = b.importance_weight ?? 0.5
+    if (bImportance !== aImportance) {
+      return bImportance - aImportance
+    }
+    // Newest first
+    const aTime = a.created_at ?? 0
+    const bTime = b.created_at ?? 0
+    return bTime - aTime
+  })
+
+  // Convert to result format
+  return actionItems.map(memory => ({
+    ...memory,
+    score: 1.0,  // All action items are relevant by definition
+    relevance_score: 1.0,
+    value_score: memory.importance_weight ?? 0.5,
+  }))
+}

package/src/server/index.ts

@@ -43,6 +43,7 @@ interface ContextRequest {
   current_message?: string
   max_memories?: number
   project_path?: string
+  mode?: 'normal' | 'action_items'  // Can be set explicitly or auto-detected via ***
 }
 
 interface ProcessRequest {
@@ -136,26 +137,42 @@ export async function createServer(config: ServerConfig = {}) {
 
           logger.request('POST', '/memory/context', body.project_id)
 
+          // Detect *** signal at end of message for action items mode
+          let message = body.current_message ?? ''
+          let mode = body.mode ?? 'normal'
+
+          if (message.trimEnd().endsWith('***')) {
+            mode = 'action_items'
+            // Strip the *** signal from the message
+            message = message.trimEnd().slice(0, -3).trimEnd()
+            logger.debug('Action items mode detected (*** signal)', 'server')
+          }
+
           const result = await engine.getContext({
             sessionId: body.session_id,
             projectId: body.project_id,
-            currentMessage: body.current_message ?? '',
+            currentMessage: message,
             maxMemories: body.max_memories,
             projectPath: body.project_path,
+            mode,
           })
 
           // Log what happened
           if (result.primer) {
             logger.primer(`Session primer for ${body.project_id}`)
           } else if (result.memories.length > 0) {
-            logger.logRetrievedMemories(
-              result.memories.map(m => ({
-                content: m.content,
-                score: m.score,
-                context_type: m.context_type,
-              })),
-              body.current_message ?? ''
-            )
+            if (mode === 'action_items') {
+              logger.info(`Returning ${result.memories.length} action item${result.memories.length === 1 ? '' : 's'}`)
+            } else {
+              logger.logRetrievedMemories(
+                result.memories.map(m => ({
+                  content: m.content,
+                  score: m.score,
+                  context_type: m.context_type,
+                })),
+                message
+              )
+            }
           }
 
           return Response.json({
@@ -167,6 +184,7 @@ export async function createServer(config: ServerConfig = {}) {
             curator_enabled: true,
             memories_count: result.memories.length,
             has_primer: !!result.primer,
+            mode,  // Include the mode that was used
           }, { headers: corsHeaders })
         }
 
@@ -198,19 +216,27 @@ export async function createServer(config: ServerConfig = {}) {
           setImmediate(async () => {
             try {
               // Try session resume first (v2) - gets full context including tool uses
-              // Falls back to transcript parsing if resume fails
+              // Falls back to segmented transcript parsing if resume fails
               let result = await curator.curateWithSessionResume(
                 body.claude_session_id,
                 body.trigger
               )
 
-              // Fallback to transcript-based curation if resume returned nothing
+              // Fallback to transcript-based curation WITH SEGMENTATION if resume returned nothing
+              // This matches the ingest command behavior - breaks large sessions into segments
               if (result.memories.length === 0) {
-                logger.debug('Session resume returned no memories, falling back to transcript parsing', 'server')
-                result = await curator.curateFromSessionFile(
+                logger.debug('Session resume returned no memories, falling back to segmented transcript parsing', 'server')
+                result = await curator.curateFromSessionFileWithSegments(
                   body.claude_session_id,
                   body.trigger,
-                  body.cwd
+                  body.cwd,
+                  150000, // 150k tokens per segment
+                  (progress) => {
+                    logger.debug(
+                      `Curation segment ${progress.segmentIndex + 1}/${progress.totalSegments}: ${progress.memoriesExtracted} memories (~${Math.round(progress.tokensInSegment / 1000)}k tokens)`,
+                      'server'
+                    )
+                  }
                 )
               }