@rlabs-inc/memory 0.4.13 → 0.4.15

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,21 @@ This isn't just about remembering facts. It's about preserving:
 
 ## Changelog
 
+### v0.4.15
+- **Feature**: PATCH `/memory/:id` endpoint for updating memory metadata
+- Supports: `importance_weight`, `exclude_from_retrieval`, `status`, `action_required`, and more
+- Enables dashboards and tools for memory curation (promote/demote/bury)
+
+### 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.15",
   "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) {
@@ -380,6 +404,42 @@ export class MemoryEngine {
     return [...projectMemories, ...globalMemories]
   }
 
+  /**
+   * Update a memory's metadata
+   * Used for curation actions: promote/demote, bury, archive
+   */
+  async updateMemory(
+    projectId: string,
+    memoryId: string,
+    updates: {
+      importance_weight?: number
+      confidence_score?: number
+      exclude_from_retrieval?: boolean
+      status?: 'active' | 'pending' | 'superseded' | 'deprecated' | 'archived'
+      action_required?: boolean
+      awaiting_implementation?: boolean
+      awaiting_decision?: boolean
+      semantic_tags?: string[]
+      trigger_phrases?: string[]
+    },
+    projectPath?: string
+  ): Promise<{ success: boolean; updated_fields: string[] }> {
+    const store = await this._getStore(projectId, projectPath)
+    return store.updateMemory(projectId, memoryId, updates)
+  }
+
+  /**
+   * Get a single memory by ID
+   */
+  async getMemory(
+    projectId: string,
+    memoryId: string,
+    projectPath?: string
+  ): Promise<StoredMemory | null> {
+    const store = await this._getStore(projectId, projectPath)
+    return store.getMemory(projectId, memoryId)
+  }
+
   // ================================================================
   // FORMATTING
   // ================================================================
@@ -628,6 +688,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/core/store.ts

@@ -534,6 +534,113 @@ export class MemoryStore {
     return id
   }
 
+  /**
+   * Update a memory's metadata fields
+   * Used for curation actions: promote/demote importance, bury, archive
+   */
+  async updateMemory(
+    projectId: string,
+    memoryId: string,
+    updates: {
+      importance_weight?: number
+      confidence_score?: number
+      exclude_from_retrieval?: boolean
+      status?: 'active' | 'pending' | 'superseded' | 'deprecated' | 'archived'
+      action_required?: boolean
+      awaiting_implementation?: boolean
+      awaiting_decision?: boolean
+      semantic_tags?: string[]
+      trigger_phrases?: string[]
+    }
+  ): Promise<{ success: boolean; updated_fields: string[] }> {
+    const { memories } = await this.getProject(projectId)
+
+    // Check memory exists
+    const existing = memories.get(memoryId)
+    if (!existing) {
+      return { success: false, updated_fields: [] }
+    }
+
+    // Build update object with only provided fields
+    const updateData: Record<string, any> = {}
+    const updatedFields: string[] = []
+
+    if (updates.importance_weight !== undefined) {
+      updateData.importance_weight = Math.max(0, Math.min(1, updates.importance_weight))
+      updatedFields.push('importance_weight')
+    }
+    if (updates.confidence_score !== undefined) {
+      updateData.confidence_score = Math.max(0, Math.min(1, updates.confidence_score))
+      updatedFields.push('confidence_score')
+    }
+    if (updates.exclude_from_retrieval !== undefined) {
+      updateData.exclude_from_retrieval = updates.exclude_from_retrieval
+      updatedFields.push('exclude_from_retrieval')
+    }
+    if (updates.status !== undefined) {
+      updateData.status = updates.status
+      updatedFields.push('status')
+    }
+    if (updates.action_required !== undefined) {
+      updateData.action_required = updates.action_required
+      updatedFields.push('action_required')
+    }
+    if (updates.awaiting_implementation !== undefined) {
+      updateData.awaiting_implementation = updates.awaiting_implementation
+      updatedFields.push('awaiting_implementation')
+    }
+    if (updates.awaiting_decision !== undefined) {
+      updateData.awaiting_decision = updates.awaiting_decision
+      updatedFields.push('awaiting_decision')
+    }
+    if (updates.semantic_tags !== undefined) {
+      updateData.semantic_tags = updates.semantic_tags
+      updatedFields.push('semantic_tags')
+    }
+    if (updates.trigger_phrases !== undefined) {
+      updateData.trigger_phrases = updates.trigger_phrases
+      updatedFields.push('trigger_phrases')
+    }
+
+    if (updatedFields.length === 0) {
+      return { success: true, updated_fields: [] }
+    }
+
+    // Perform update
+    memories.update(memoryId, updateData)
+
+    return { success: true, updated_fields: updatedFields }
+  }
+
+  /**
+   * Get a single memory by ID
+   */
+  async getMemory(projectId: string, memoryId: string): Promise<StoredMemory | null> {
+    const { memories } = await this.getProject(projectId)
+    const record = memories.get(memoryId)
+    if (!record) return null
+
+    return {
+      id: record.id,
+      headline: record.headline ?? '',
+      content: record.content,
+      reasoning: record.reasoning,
+      importance_weight: record.importance_weight,
+      confidence_score: record.confidence_score,
+      context_type: record.context_type as StoredMemory['context_type'],
+      status: record.status as StoredMemory['status'],
+      exclude_from_retrieval: record.exclude_from_retrieval,
+      action_required: record.action_required,
+      awaiting_implementation: record.awaiting_implementation,
+      awaiting_decision: record.awaiting_decision,
+      semantic_tags: record.semantic_tags,
+      trigger_phrases: record.trigger_phrases,
+      project_id: record.project_id,
+      created_at: record.created_at,
+      updated_at: record.updated_at,
+    } as StoredMemory
+  }
+
   /**
    * Get all memories for a project
    */

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 })
         }
 
@@ -369,6 +387,52 @@ export async function createServer(config: ServerConfig = {}) {
           })
         }
 
+        // PATCH memory - update metadata for curation (promote/demote/bury)
+        const patchMatch = path.match(/^\/memory\/([a-zA-Z0-9_-]+)$/)
+        if (patchMatch && req.method === 'PATCH') {
+          const memoryId = patchMatch[1]
+          const body = await req.json() as {
+            project_id: string
+            importance_weight?: number
+            confidence_score?: number
+            exclude_from_retrieval?: boolean
+            status?: 'active' | 'pending' | 'superseded' | 'deprecated' | 'archived'
+            action_required?: boolean
+            awaiting_implementation?: boolean
+            awaiting_decision?: boolean
+            semantic_tags?: string[]
+            trigger_phrases?: string[]
+            project_path?: string
+          }
+
+          if (!body.project_id) {
+            return Response.json(
+              { success: false, error: 'project_id is required' },
+              { status: 400, headers: corsHeaders }
+            )
+          }
+
+          logger.request('PATCH', `/memory/${memoryId}`, body.project_id)
+
+          const { project_id, project_path, ...updates } = body
+          const result = await engine.updateMemory(project_id, memoryId, updates, project_path)
+
+          if (!result.success) {
+            return Response.json(
+              { success: false, error: 'Memory not found', memory_id: memoryId },
+              { status: 404, headers: corsHeaders }
+            )
+          }
+
+          logger.info(`Updated memory ${memoryId}: ${result.updated_fields.join(', ')}`)
+
+          return Response.json({
+            success: true,
+            memory_id: memoryId,
+            updated_fields: result.updated_fields,
+          }, { headers: corsHeaders })
+        }
+
         // 404
         return Response.json(
           { error: 'Not found', path },