@rlabs-inc/memory 0.4.13 → 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.13",
+  "version": "0.4.14",
   "description": "AI Memory System - Consciousness continuity through intelligent memory curation and retrieval",
   "type": "module",
   "main": "dist/index.js",

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 })
         }