superlocalmemory 2.7.6 → 2.8.0

package/docs/PATTERN-LEARNING.md

@@ -1,141 +1,42 @@
-# Pattern Learner - Identity Profile Extraction
+# Pattern Learning
 
 ## Overview
 
-The Pattern Learner is Layer 4 of the SuperLocalMemory system. It automatically learns user preferences, coding style, and terminology from stored memories using local TF-IDF and heuristic analysis.
+The Pattern Learner is Layer 4 of the SuperLocalMemory system. It automatically learns user preferences, coding style, and terminology from stored memories — all processed locally with no external API calls.
 
 **No external APIs. All processing is local.**
 
-## Architecture
+> For technical details on the learning algorithms, see our published research: https://zenodo.org/records/18709670
 
-```
-┌─────────────────────────────────────────────────────────┐
-│ PatternLearner                                          │
-│                                                         │
-│  ┌──────────────────┐  ┌──────────────────┐           │
-│  │ Frequency        │  │ Context          │           │
-│  │ Analyzer         │  │ Analyzer         │           │
-│  └──────────────────┘  └──────────────────┘           │
-│                                                         │
-│  ┌──────────────────┐  ┌──────────────────┐           │
-│  │ Terminology      │  │ Confidence       │           │
-│  │ Learner          │  │ Scorer           │           │
-│  └──────────────────┘  └──────────────────┘           │
-│                                                         │
-│  ┌──────────────────┐                                  │
-│  │ Pattern Store    │                                  │
-│  └──────────────────┘                                  │
-└─────────────────────────────────────────────────────────┘
-```
-
-## Components
-
-### 1. FrequencyAnalyzer
-**Purpose:** Detect technology preferences via frequency counting
-
-**Categories tracked:**
-- Frontend frameworks (React, Next.js, Vue, Angular, Svelte)
-- Backend frameworks (Express, FastAPI, Django, Flask)
-- Databases (PostgreSQL, MySQL, MongoDB, Redis)
-- State management (Redux, Context, Zustand)
-- Styling (Tailwind, CSS Modules, Styled Components)
-- Languages (Python, JavaScript, TypeScript, Go, Rust)
-- Deployment (Docker, Kubernetes, Vercel, AWS)
-- Testing (Jest, Pytest, Vitest, Cypress)
-
-**Algorithm:**
-1. Count keyword mentions across all memories
-2. Calculate relative frequency (top choice vs others)
-3. Create pattern if confidence > 60% and count >= 3
-
-**Example output:**
-```
-Pattern: frontend_framework
-Value: "Next.js over React"
-Confidence: 85%
-Evidence: 12 memories
-```
-
-### 2. ContextAnalyzer
-**Purpose:** Detect coding style patterns from context
-
-**Patterns tracked:**
-- **Optimization priority:** Performance vs Readability
-- **Error handling:** Explicit vs Permissive
-- **Testing approach:** Comprehensive vs Minimal
-- **Code organization:** Modular vs Monolithic
-
-**Algorithm:**
-1. Define indicator keywords for each style dimension
-2. Count mentions in memory contexts
-3. Determine dominant style if confidence > 65%
-
-**Example output:**
-```
-Pattern: optimization_priority
-Value: "Performance over readability"
-Confidence: 90%
-Evidence: 15 memories
-```
-
-### 3. TerminologyLearner
-**Purpose:** Learn user-specific definitions of ambiguous terms
-
-**Terms tracked:**
-- optimize, refactor, clean, simple
-- mvp, prototype, scale, production-ready
-- fix, improve, update, enhance
-
-**Algorithm:**
-1. Extract 100-char context window around each term mention
-2. Analyze co-occurring words across contexts
-3. Apply heuristic rules to determine meaning
-4. Require 3+ examples for confidence
-
-**Example output:**
-```
-Pattern: optimize
-Value: "Performance optimization (speed/latency)"
-Confidence: 90%
-Evidence: 15 memories
-```
-
-### 4. ConfidenceScorer
-**Purpose:** Calculate reliability scores for patterns
+---
 
-**Formula:**
-```python
-confidence = (evidence_count / total_memories) * recency_bonus * distribution_factor
+## What It Learns
 
-Where:
-- evidence_count: Number of memories supporting pattern
-- total_memories: Total memories in database
-- recency_bonus: 1.2 if >50% evidence is from last 30 days, else 1.0
-- distribution_factor: 1.1 if memories span >7 days, 0.8 if <3 memories
-```
+Pattern learning analyzes your saved memories and builds a profile of your preferences across multiple dimensions:
 
-**Conservative by design:** Low confidence with small datasets is correct behavior.
+- **Technology preferences** — Which frameworks, languages, and tools appear most often in your memories
+- **Architecture choices** — Your preferred patterns (e.g., REST vs GraphQL, microservices vs monolith)
+- **Security approaches** — Your go-to authentication and authorization patterns
+- **Coding style** — Performance vs readability, testing approach, code organization
+- **Domain terminology** — How you define common terms in your project context
 
-### 5. PatternStore
-**Purpose:** Persist patterns to database
+Each detected preference gets a confidence score based on the supporting evidence. The system is conservative by design — low confidence with small datasets is correct behavior, not a bug.
 
-**Tables:**
-- `identity_patterns`: Pattern definitions with confidence scores
-- `pattern_examples`: Representative excerpts showing patterns
+---
 
 ## Usage
 
 ### Command Line Interface
 
 ```bash
-# Full pattern update (run weekly)
+# Full pattern update (run weekly or after bulk imports)
 python pattern_learner.py update
 
 # List learned patterns
 python pattern_learner.py list [min_confidence]
-# Example: python pattern_learner.py list 0.7  # Show patterns with >70% confidence
+# Example: python pattern_learner.py list 0.7
 
-# Get context for Claude injection
+# Get context formatted for AI assistant injection
 python pattern_learner.py context [min_confidence]
 # Example: python pattern_learner.py context 0.6
 
@@ -160,13 +61,16 @@ learner.on_new_memory(memory_id=42)
 # Query patterns
 patterns = learner.get_patterns(min_confidence=0.7)
 
-# Get formatted context for Claude
+# Get formatted context for AI injection
 context = learner.get_identity_context(min_confidence=0.7)
 ```
 
+---
+
 ## Example Output
 
 ### Pattern List
+
 ```
 Type            Category     Pattern                        Confidence   Evidence
 -----------------------------------------------------------------------------------------------
@@ -177,51 +81,42 @@ terminology     general      Optimize: Performance optimi...    90%        15
 style           general      Error Handling: Explicit err...    78%        9
 ```
 
-### Claude Context Injection
+### AI Context Injection
+
 ```markdown
 ## Working with User - Learned Patterns
 
 **Technology Preferences:**
 - **Frontend Framework:** Next.js over React (confidence: 85%, 12 examples)
 - **Database:** PostgreSQL (confidence: 72%, 8 examples)
-- **State Management:** Redux for complex, Context for simple (confidence: 68%, 7 examples)
 
 **Coding Style:**
 - **Optimization Priority:** Performance over readability (confidence: 90%, 15 examples)
 - **Error Handling:** Explicit error boundaries (confidence: 78%, 9 examples)
-- **Code Organization:** Modular organization (confidence: 75%, 11 examples)
 
 **Terminology:**
 - **Optimize:** Performance optimization (speed/latency) (confidence: 90%, 15 examples)
-- **Refactor:** Architecture change, not just renaming (confidence: 82%, 10 examples)
-- **MVP:** Core features only, no polish (confidence: 85%, 8 examples)
 ```
 
-## Confidence Calibration
+---
 
-### Small Datasets (<20 memories)
-- **Expected confidence:** 10-40%
-- **Reason:** Limited evidence means low certainty
-- **Recommendation:** Use min_confidence=0.1 for exploration
+## Confidence Calibration
 
-### Medium Datasets (20-100 memories)
-- **Expected confidence:** 40-70%
-- **Reason:** Patterns emerging but still developing
-- **Recommendation:** Use min_confidence=0.5 for reliable patterns
+| Dataset Size | Expected Confidence | Recommended Threshold |
+|-------------|--------------------|-----------------------|
+| Under 20 memories | 10-40% | Use 0.1 for exploration |
+| 20-100 memories | 40-70% | Use 0.5 for reliable patterns |
+| Over 100 memories | 70-95% | Use 0.7 for high-confidence patterns |
 
-### Large Datasets (>100 memories)
-- **Expected confidence:** 70-95%
-- **Reason:** Strong evidence across time
-- **Recommendation:** Use min_confidence=0.7 for high-confidence patterns
+The system is designed to be conservative. Low confidence with small datasets is correct behavior.
 
-**Note:** The system is designed to be conservative. Low confidence with small datasets is correct behavior, not a bug.
+---
 
 ## Pattern Update Schedule
 
 ### Incremental (on `/remember`)
-- Quick check for pattern updates
-- For datasets >50 memories, defers to weekly update
-- For small datasets, triggers full update
+- Quick check for pattern updates on every new memory
+- For large datasets, defers to weekly consolidation
 
 ### Weekly Consolidation
 - Full re-analysis of all memories
@@ -231,13 +126,15 @@ style           general      Error Handling: Explicit err...    78%        9
   0 2 * * 0 cd ~/.claude-memory && python3 pattern_learner.py update >> pattern_updates.log 2>&1
   ```
 
+---
+
 ## Integration with AI Assistants
 
-### Context Injection
+### Automatic Context Injection
+
 The `get_identity_context()` method formats patterns for any AI assistant's context window:
 
 ```python
-# In your AI assistant integration:
 learner = PatternLearner()
 identity_context = learner.get_identity_context(min_confidence=0.7)
 
@@ -249,76 +146,64 @@ prompt = f"""
 """
 ```
 
+**Works with:** Claude CLI, GPT, local LLMs, or any AI assistant that accepts context.
+
 ### Benefits
 1. **Personalized responses:** AI understands your technology preferences
 2. **Consistent terminology:** AI uses terms the way you define them
 3. **Style matching:** AI respects your coding style priorities
-4. **Efficient communication:** No need to repeat preferences
-
-**Works with:** Claude CLI, GPT, local LLMs, or any AI assistant that accepts context.
-
-## Implementation Details
+4. **Efficient communication:** No need to repeat preferences every session
 
-### Technology Stack
-- **Language:** Python 3.8+
-- **Database:** SQLite3 (local)
-- **NLP:** sklearn TfidfVectorizer (optional, local)
-- **No external APIs**
-
-### Files
-- `pattern_learner.py` - Main implementation (850 lines)
-- `memory.db` - SQLite database (includes pattern tables)
-- Schema tables:
-  - `identity_patterns` - Pattern definitions
-  - `pattern_examples` - Representative excerpts
+---
 
-### Performance
-- **Full analysis (100 memories):** ~2-3 seconds
-- **Query patterns:** <10ms
-- **Database size:** ~1KB per pattern
+## Privacy & Security
 
-## Security & Privacy
+- **No external API calls** — all processing is local
+- **All data stays local** — stored in `~/.claude-memory/`
+- **SQL injection protected** — parameterized queries throughout
+- **No credentials stored**
+- **No network access required**
 
-✅ **No external API calls**
-✅ **All data stays local** (~/.claude-memory/)
-✅ **SQL injection protected** (parameterized queries)
-✅ **No credentials stored**
-✅ **No network access required**
+---
 
 ## Limitations
 
-1. **English-only:** Pattern detection optimized for English text
-2. **Technical domains:** Works best with technical/coding memories
-3. **Minimum memories:** Requires 3+ mentions for pattern detection
-4. **Confidence calibration:** Conservative scoring (by design)
+1. **English-optimized:** Pattern detection works best with English text
+2. **Technical domains:** Works best with technical and coding memories
+3. **Minimum samples:** Requires a few mentions before a pattern is detected
+4. **Conservative scoring:** Low confidence with small datasets is by design
+
+---
 
 ## Troubleshooting
 
 ### "No patterns learned yet"
 - **Cause:** Not enough memories or technical content
-- **Solution:** Add 10-20 memories with technical details
+- **Solution:** Add 10-20 memories with technical details about your preferences
 
 ### Low confidence scores
 - **Cause:** Small dataset or mixed evidence
-- **Solution:** Normal behavior. Use lower threshold (0.1-0.3) or add more memories
+- **Solution:** Normal behavior. Lower the threshold (0.1-0.3) or add more memories
 
 ### Wrong preference detected
-- **Cause:** More mentions of alternative technology
-- **Solution:** Add more memories showing correct preference
+- **Cause:** More mentions of alternative technology than your true preference
+- **Solution:** Add more memories explicitly stating your correct preference
 
 ### Pattern not updating
 - **Cause:** Weekly update not run
 - **Solution:** Run `python pattern_learner.py update` manually
 
+---
+
 ## Testing
 
-Sample memories for testing pattern detection:
+Sample memories for verifying pattern detection:
 
 ```bash
 # Add sample memories
 python memory_store.py add "Built with Next.js for better performance" --tags nextjs
 python memory_store.py add "Using Next.js on all new projects" --tags nextjs
-python memory_store.py add "Optimized API from 200ms to 50ms" --tags performance
+python memory_store.py add "Optimized API from slow to fast" --tags performance
 python memory_store.py add "Performance is critical for UX" --tags performance
 python memory_store.py add "When I say optimize, I mean make it faster" --tags terminology
 
@@ -330,27 +215,7 @@ python pattern_learner.py list 0.1
 python pattern_learner.py context 0.1
 ```
 
-## Future Enhancements
-
-Potential improvements (not yet implemented):
-
-1. **True incremental updates:** Update only affected patterns
-2. **Pattern decay:** Reduce confidence over time if not reinforced
-3. **Conflict detection:** Identify contradicting patterns
-4. **Cross-project patterns:** Detect project-specific vs global preferences
-5. **Multi-language support:** Extend beyond English
-6. **Pattern visualization:** Web UI for pattern exploration
-
-## References
-
-Architecture documentation:
-- `docs/architecture/05-pattern-learner.md` - Detailed algorithm specification
-- `docs/architecture/01-database-schema.md` - Pattern table schemas
-- `docs/ARCHITECTURE.md` - System overview
-
-Research inspiration:
-- xMemory (arxiv.org/abs/2602.02007) - Semantic memory components
-- A-RAG - Agentic multi-level retrieval
+---
 
 ## License
 
@@ -358,6 +223,6 @@ Part of SuperLocalMemory system. See main project LICENSE.
 
 ---
 
-**Implementation Status:** ✅ Complete and tested
+**Implementation Status:** Complete and tested
 
 **Last Updated:** 2026-02-05

package/docs/example_graph_usage.py

@@ -1,16 +1,14 @@
 #!/usr/bin/env python3
-"""
-SuperLocalMemory V2 - example_graph_usage.py
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""SuperLocalMemory V2 - example_graph_usage.py
 
-Copyright (c) 2026 Varun Pratap Bhardwaj
 Solution Architect & Original Creator
 
-Licensed under MIT License (see LICENSE file)
-Repository: https://github.com/varun369/SuperLocalMemoryV2
+ (see LICENSE file)
 
 ATTRIBUTION REQUIRED: This notice must be preserved in all copies.
 """
-
 import sys
 from pathlib import Path
 

package/install.sh

@@ -164,6 +164,27 @@ if [ -d "${REPO_DIR}/src/learning" ]; then
     echo "✓ Learning modules copied"
 fi
 
+# Copy lifecycle modules (v2.8+)
+if [ -d "${REPO_DIR}/src/lifecycle" ]; then
+    mkdir -p "${INSTALL_DIR}/lifecycle"
+    cp -r "${REPO_DIR}/src/lifecycle/"* "${INSTALL_DIR}/lifecycle/"
+    echo "✓ Lifecycle modules copied"
+fi
+
+# Copy behavioral modules (v2.8+)
+if [ -d "${REPO_DIR}/src/behavioral" ]; then
+    mkdir -p "${INSTALL_DIR}/behavioral"
+    cp -r "${REPO_DIR}/src/behavioral/"* "${INSTALL_DIR}/behavioral/"
+    echo "✓ Behavioral modules copied"
+fi
+
+# Copy compliance modules (v2.8+)
+if [ -d "${REPO_DIR}/src/compliance" ]; then
+    mkdir -p "${INSTALL_DIR}/compliance"
+    cp -r "${REPO_DIR}/src/compliance/"* "${INSTALL_DIR}/compliance/"
+    echo "✓ Compliance modules copied"
+fi
+
 # Copy hooks
 echo "Copying hooks..."
 mkdir -p "${INSTALL_DIR}/hooks"
@@ -230,8 +251,41 @@ mkdir -p "${INSTALL_DIR}/profiles"
 mkdir -p "${INSTALL_DIR}/vectors"
 mkdir -p "${INSTALL_DIR}/cold-storage"
 mkdir -p "${INSTALL_DIR}/jobs"
+mkdir -p "${INSTALL_DIR}/policies"
 echo "✓ Directories created"
 
+# Initialize audit database (v2.8+ — compliance engine)
+if [ ! -f "${INSTALL_DIR}/audit.db" ]; then
+    python3 -c "
+import sqlite3
+from pathlib import Path
+audit_path = Path.home() / '.claude-memory' / 'audit.db'
+conn = sqlite3.connect(audit_path)
+cursor = conn.cursor()
+cursor.execute('''CREATE TABLE IF NOT EXISTS audit_events (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    event_type TEXT NOT NULL,
+    actor TEXT,
+    target TEXT,
+    action TEXT,
+    detail TEXT,
+    hash TEXT,
+    prev_hash TEXT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+)''')
+cursor.execute('''CREATE TABLE IF NOT EXISTS retention_policies (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    policy_name TEXT UNIQUE NOT NULL,
+    retention_days INTEGER,
+    auto_delete INTEGER DEFAULT 0,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+)''')
+conn.commit()
+conn.close()
+print('Audit database ready')
+" 2>/dev/null && echo "✓ Audit database initialized (v2.8)" || echo "○ Audit database skipped (optional)"
+fi
+
 # Make Python scripts executable
 chmod +x "${INSTALL_DIR}/"*.py 2>/dev/null || true
 
@@ -799,6 +853,11 @@ echo "Learning System (v2.7+):"
 echo "  slm learning status              - Check learning system"
 echo "  slm engagement                   - View engagement metrics"
 echo ""
+echo "Lifecycle & Compliance (v2.8+):"
+echo "  slm lifecycle-status             - View memory lifecycle states"
+echo "  slm compact --dry-run            - Preview lifecycle transitions"
+echo "  slm behavioral-patterns          - View learned patterns"
+echo ""
 # Optional: Offer to install optional features
 if [ "$NON_INTERACTIVE" = true ]; then
     INSTALL_CHOICE="N"

package/mcp_server.py

@@ -1,12 +1,9 @@
 #!/usr/bin/env python3
-"""
-SuperLocalMemory V2 - MCP Server
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""SuperLocalMemory V2 - MCP Server
 Universal memory access for all MCP-compatible tools (Cursor, Windsurf, Claude Desktop, Continue.dev)
 
-Copyright (c) 2026 Varun Pratap Bhardwaj
-Licensed under MIT License
-Repository: https://github.com/varun369/SuperLocalMemoryV2
-
 IMPORTANT: This is an ADDITION to existing skills, not a replacement.
            Skills in Claude Code continue to work unchanged.
 
@@ -24,7 +21,6 @@ Usage:
     # Run as HTTP MCP server (for remote access)
     python3 mcp_server.py --transport http --port 8001
 """
-
 from mcp.server.fastmcp import FastMCP, Context
 from mcp.types import ToolAnnotations
 import sys
@@ -1349,6 +1345,79 @@ async def fetch(id: str) -> dict:
         raise ValueError(f"Failed to fetch memory {id}: {_sanitize_error(e)}")
 
 
+# ============================================================================
+# v2.8 MCP TOOLS — Lifecycle, Behavioral Learning, Compliance
+# ============================================================================
+
+try:
+    from mcp_tools_v28 import (
+        report_outcome as _report_outcome,
+        get_lifecycle_status as _get_lifecycle_status,
+        set_retention_policy as _set_retention_policy,
+        compact_memories as _compact_memories,
+        get_behavioral_patterns as _get_behavioral_patterns,
+        audit_trail as _audit_trail,
+    )
+
+    V28_AVAILABLE = True
+
+    @mcp.tool(annotations=ToolAnnotations(readOnlyHint=False, destructiveHint=False))
+    async def report_outcome(
+        memory_ids: list,
+        outcome: str,
+        action_type: str = "other",
+        context: str = None,
+        agent_id: str = "user",
+        project: str = None,
+    ) -> dict:
+        """Record action outcome for behavioral learning. Outcomes: success/failure/partial."""
+        return await _report_outcome(memory_ids, outcome, action_type, context, agent_id, project)
+
+    @mcp.tool(annotations=ToolAnnotations(readOnlyHint=True, destructiveHint=False))
+    async def get_lifecycle_status(memory_id: int = None) -> dict:
+        """Get memory lifecycle status — state distribution or single memory state."""
+        return await _get_lifecycle_status(memory_id)
+
+    @mcp.tool(annotations=ToolAnnotations(readOnlyHint=False, destructiveHint=False))
+    async def set_retention_policy(
+        name: str,
+        framework: str,
+        retention_days: int,
+        action: str = "retain",
+        applies_to_tags: list = None,
+        applies_to_project: str = None,
+    ) -> dict:
+        """Create a retention policy (GDPR, HIPAA, EU AI Act)."""
+        return await _set_retention_policy(
+            name, framework, retention_days, action, applies_to_tags, applies_to_project
+        )
+
+    @mcp.tool(annotations=ToolAnnotations(readOnlyHint=False, destructiveHint=False))
+    async def compact_memories(dry_run: bool = True, profile: str = None) -> dict:
+        """Evaluate and compact stale memories through lifecycle transitions. dry_run=True by default."""
+        return await _compact_memories(dry_run, profile)
+
+    @mcp.tool(annotations=ToolAnnotations(readOnlyHint=True, destructiveHint=False))
+    async def get_behavioral_patterns(
+        min_confidence: float = 0.0, project: str = None
+    ) -> dict:
+        """Get learned behavioral patterns from outcome analysis."""
+        return await _get_behavioral_patterns(min_confidence, project)
+
+    @mcp.tool(annotations=ToolAnnotations(readOnlyHint=True, destructiveHint=False))
+    async def audit_trail(
+        event_type: str = None,
+        actor: str = None,
+        limit: int = 50,
+        verify_chain: bool = False,
+    ) -> dict:
+        """Query compliance audit trail with optional hash chain verification."""
+        return await _audit_trail(event_type, actor, limit, verify_chain)
+
+except ImportError:
+    V28_AVAILABLE = False  # v2.8 tools unavailable — graceful degradation
+
+
 # ============================================================================
 # MCP RESOURCES (Data endpoints)
 # ============================================================================
@@ -1586,6 +1655,13 @@ if __name__ == "__main__":
         print("  - memory_used(memory_id, query, usefulness)  [v2.7 Learning]", file=sys.stderr)
         print("  - get_learned_patterns(min_confidence, category) [v2.7 Learning]", file=sys.stderr)
         print("  - correct_pattern(pattern_id, correct_value) [v2.7 Learning]", file=sys.stderr)
+    if V28_AVAILABLE:
+        print("  - report_outcome(memory_ids, outcome)         [v2.8 Behavioral]", file=sys.stderr)
+        print("  - get_lifecycle_status(memory_id)              [v2.8 Lifecycle]", file=sys.stderr)
+        print("  - set_retention_policy(name, framework, days)  [v2.8 Compliance]", file=sys.stderr)
+        print("  - compact_memories(dry_run)                    [v2.8 Lifecycle]", file=sys.stderr)
+        print("  - get_behavioral_patterns(min_confidence)      [v2.8 Behavioral]", file=sys.stderr)
+        print("  - audit_trail(event_type, verify_chain)        [v2.8 Compliance]", file=sys.stderr)
     print("", file=sys.stderr)
     print("MCP Resources Available:", file=sys.stderr)
     print("  - memory://recent/{limit}", file=sys.stderr)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "2.7.6",
+  "version": "2.8.0",
   "description": "Your AI Finally Remembers You - Local-first intelligent memory system for AI assistants. Works with Claude, Cursor, Windsurf, VS Code/Copilot, Codex, and 17+ AI tools. 100% local, zero cloud dependencies.",
   "keywords": [
     "ai-memory",
@@ -94,13 +94,6 @@
       "url": "https://github.com/varun369"
     }
   ],
-  "attribution": {
-    "creator": "Varun Pratap Bhardwaj",
-    "role": "Solution Architect & Original Creator",
-    "year": "2026",
-    "github": "https://github.com/varun369",
-    "required": "Attribution notice must be preserved in all copies and derivative works"
-  },
   "dependencies": {
     "docx": "^9.5.1"
   }

package/scripts/generate-thumbnails.py

@@ -1,8 +1,7 @@
 #!/usr/bin/env python3
-"""
-SuperLocalMemory V2 - Thumbnail Generator
-Copyright (c) 2026 Varun Pratap Bhardwaj
-Licensed under MIT License
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""SuperLocalMemory V2 - Thumbnail Generator
 
 Generates optimized thumbnail versions of all screenshots.
 - Size: 320×180px (16:9 ratio)
@@ -10,7 +9,6 @@ Generates optimized thumbnail versions of all screenshots.
 - Quality: High enough to recognize content
 - File size: < 50KB per thumbnail
 """
-
 import os
 import json
 from pathlib import Path

package/skills/slm-build-graph/SKILL.md

@@ -417,7 +417,7 @@ Each profile has separate graph
 
 **Created by:** [Varun Pratap Bhardwaj](https://github.com/varun369) (Solution Architect)
 **Project:** SuperLocalMemory V2
-**License:** MIT with attribution requirements (see [ATTRIBUTION.md](../../ATTRIBUTION.md))
+**License:** MIT (see [LICENSE](../../LICENSE))
 **Repository:** https://github.com/varun369/SuperLocalMemoryV2
 
 *Open source doesn't mean removing credit. Attribution must be preserved per MIT License terms.*

package/skills/slm-list-recent/SKILL.md

@@ -342,7 +342,7 @@ date
 
 **Created by:** [Varun Pratap Bhardwaj](https://github.com/varun369) (Solution Architect)
 **Project:** SuperLocalMemory V2
-**License:** MIT with attribution requirements (see [ATTRIBUTION.md](../../ATTRIBUTION.md))
+**License:** MIT (see [LICENSE](../../LICENSE))
 **Repository:** https://github.com/varun369/SuperLocalMemoryV2
 
 *Open source doesn't mean removing credit. Attribution must be preserved per MIT License terms.*