superlocalmemory 3.4.5 → 3.4.8

package/src/superlocalmemory/learning/assertion_miner.py

@@ -0,0 +1,403 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
+
+"""Behavioral Assertion Miner — extracts learned patterns from tool events and facts.
+
+Zero-LLM approach: uses frequency analysis, co-occurrence detection, and
+temporal clustering to discover behavioral patterns. No external model calls.
+
+Runs as Step 8 in the consolidation pipeline.
+
+Part of Qualixar | Author: Varun Pratap Bhardwaj
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import sqlite3
+import uuid
+from collections import Counter
+from datetime import datetime, timezone
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+MIN_EVIDENCE = 3  # Minimum events to create an assertion
+MAX_ASSERTIONS_PER_RUN = 20  # Cap assertions per mining cycle
+REINFORCEMENT_NUDGE = 0.15  # Bayesian confidence increase
+PROMOTION_MIN_PROJECTS = 2  # Minimum projects for cross-project promotion
+PROMOTION_MIN_CONFIDENCE = 0.8  # Minimum avg confidence for promotion
+
+
+class AssertionMiner:
+    """Mine tool_events + atomic_facts for behavioral assertions.
+
+    Discovers patterns like:
+    - "User always reads a file before editing it" (tool sequence)
+    - "User corrects verbose output frequently" (correction pattern)
+    - "User prefers morning for debugging tasks" (temporal clustering)
+    - "User pairs tool X with tool Y 90% of the time" (co-occurrence)
+    """
+
+    def __init__(self, db_path: str | Path):
+        self._db_path = str(db_path)
+
+    def mine(self, profile_id: str = "default") -> dict:
+        """Run all mining strategies. Returns summary of assertions created/reinforced."""
+        conn = sqlite3.connect(self._db_path, timeout=10)
+        conn.row_factory = sqlite3.Row
+        results = {"created": 0, "reinforced": 0, "strategies": {}}
+
+        try:
+            # Strategy 1: Tool sequence patterns
+            s1 = self._mine_tool_sequences(conn, profile_id)
+            results["strategies"]["tool_sequences"] = s1
+            results["created"] += s1.get("created", 0)
+            results["reinforced"] += s1.get("reinforced", 0)
+
+            # Strategy 2: Correction patterns
+            s2 = self._mine_correction_patterns(conn, profile_id)
+            results["strategies"]["corrections"] = s2
+            results["created"] += s2.get("created", 0)
+            results["reinforced"] += s2.get("reinforced", 0)
+
+            # Strategy 3: Tool preference patterns
+            s3 = self._mine_tool_preferences(conn, profile_id)
+            results["strategies"]["tool_preferences"] = s3
+            results["created"] += s3.get("created", 0)
+            results["reinforced"] += s3.get("reinforced", 0)
+
+            # Strategy 4: Temporal patterns
+            s4 = self._mine_temporal_patterns(conn, profile_id)
+            results["strategies"]["temporal"] = s4
+            results["created"] += s4.get("created", 0)
+            results["reinforced"] += s4.get("reinforced", 0)
+
+            # Strategy 5: Cross-project assertion promotion
+            s5 = self._promote_cross_project(conn, profile_id)
+            results["strategies"]["cross_project"] = s5
+            results["created"] += s5.get("promoted", 0)
+
+            conn.commit()
+        except Exception as exc:
+            logger.warning("Assertion mining failed: %s", exc)
+            results["error"] = str(exc)
+        finally:
+            conn.close()
+
+        logger.info(
+            "Assertion mining: %d created, %d reinforced",
+            results["created"], results["reinforced"],
+        )
+        return results
+
+    # ------------------------------------------------------------------
+    # Strategy 1: Tool sequence patterns
+    # ------------------------------------------------------------------
+
+    def _mine_tool_sequences(self, conn: sqlite3.Connection, profile_id: str) -> dict:
+        """Detect repeated tool sequences (A→B patterns)."""
+        result = {"created": 0, "reinforced": 0}
+
+        rows = conn.execute(
+            "SELECT tool_name, created_at FROM tool_events "
+            "WHERE profile_id = ? ORDER BY created_at ASC LIMIT 5000",
+            (profile_id,),
+        ).fetchall()
+
+        if len(rows) < MIN_EVIDENCE * 2:
+            return result
+
+        # Count bigram sequences
+        bigrams: Counter = Counter()
+        for i in range(len(rows) - 1):
+            a = rows[i]["tool_name"]
+            b = rows[i + 1]["tool_name"]
+            if a != b:  # Skip self-loops
+                bigrams[(a, b)] += 1
+
+        total_transitions = sum(bigrams.values())
+        for (tool_a, tool_b), count in bigrams.most_common(10):
+            if count < MIN_EVIDENCE:
+                break
+            pct = count / total_transitions
+            if pct < 0.05:  # Skip rare sequences
+                continue
+
+            trigger = f"when using {tool_a}"
+            action = f"typically follow with {tool_b} ({count} times, {pct:.0%} of transitions)"
+            r = self._upsert_assertion(
+                conn, profile_id,
+                trigger=trigger, action=action,
+                category="tool_preference",
+                evidence_count=count,
+                confidence=min(0.9, pct * 2),
+            )
+            result[r] = result.get(r, 0) + 1
+
+        return result
+
+    # ------------------------------------------------------------------
+    # Strategy 2: Correction patterns
+    # ------------------------------------------------------------------
+
+    def _mine_correction_patterns(self, conn: sqlite3.Connection, profile_id: str) -> dict:
+        """Detect tools with high correction rates."""
+        result = {"created": 0, "reinforced": 0}
+
+        rows = conn.execute(
+            "SELECT tool_name, event_type, COUNT(*) as cnt "
+            "FROM tool_events WHERE profile_id = ? "
+            "GROUP BY tool_name, event_type",
+            (profile_id,),
+        ).fetchall()
+
+        tool_stats: dict = {}
+        for row in rows:
+            tool = row["tool_name"]
+            if tool not in tool_stats:
+                tool_stats[tool] = {"total": 0, "corrections": 0, "errors": 0}
+            tool_stats[tool]["total"] += row["cnt"]
+            if row["event_type"] == "correction":
+                tool_stats[tool]["corrections"] = row["cnt"]
+            elif row["event_type"] == "error":
+                tool_stats[tool]["errors"] = row["cnt"]
+
+        for tool, stats in tool_stats.items():
+            if stats["total"] < MIN_EVIDENCE:
+                continue
+            correction_rate = stats["corrections"] / stats["total"]
+            if correction_rate > 0.15:  # 15%+ correction rate
+                trigger = f"when using {tool}"
+                action = (
+                    f"high correction rate ({stats['corrections']}/{stats['total']} = "
+                    f"{correction_rate:.0%}) — review output before accepting"
+                )
+                r = self._upsert_assertion(
+                    conn, profile_id,
+                    trigger=trigger, action=action,
+                    category="workflow",
+                    evidence_count=stats["corrections"],
+                    confidence=min(0.85, correction_rate),
+                )
+                result[r] = result.get(r, 0) + 1
+
+        return result
+
+    # ------------------------------------------------------------------
+    # Strategy 3: Tool preference patterns
+    # ------------------------------------------------------------------
+
+    def _mine_tool_preferences(self, conn: sqlite3.Connection, profile_id: str) -> dict:
+        """Detect dominant tool usage patterns."""
+        result = {"created": 0, "reinforced": 0}
+
+        rows = conn.execute(
+            "SELECT tool_name, COUNT(*) as cnt "
+            "FROM tool_events WHERE profile_id = ? "
+            "GROUP BY tool_name ORDER BY cnt DESC LIMIT 10",
+            (profile_id,),
+        ).fetchall()
+
+        if not rows:
+            return result
+
+        total = sum(r["cnt"] for r in rows)
+        for row in rows[:5]:
+            tool = row["tool_name"]
+            count = row["cnt"]
+            pct = count / total
+            if count >= MIN_EVIDENCE and pct > 0.1:
+                trigger = "general workflow"
+                action = f"frequently uses {tool} ({count} times, {pct:.0%} of all tool usage)"
+                r = self._upsert_assertion(
+                    conn, profile_id,
+                    trigger=trigger, action=action,
+                    category="tool_preference",
+                    evidence_count=count,
+                    confidence=min(0.8, pct),
+                )
+                result[r] = result.get(r, 0) + 1
+
+        return result
+
+    # ------------------------------------------------------------------
+    # Strategy 4: Temporal patterns
+    # ------------------------------------------------------------------
+
+    def _mine_temporal_patterns(self, conn: sqlite3.Connection, profile_id: str) -> dict:
+        """Detect time-of-day usage patterns."""
+        result = {"created": 0, "reinforced": 0}
+
+        rows = conn.execute(
+            "SELECT created_at FROM tool_events "
+            "WHERE profile_id = ? AND created_at IS NOT NULL LIMIT 5000",
+            (profile_id,),
+        ).fetchall()
+
+        if len(rows) < MIN_EVIDENCE:
+            return result
+
+        hour_counts: Counter = Counter()
+        for row in rows:
+            try:
+                dt = datetime.fromisoformat(row["created_at"])
+                hour_counts[dt.hour] += 1
+            except (ValueError, TypeError):
+                continue
+
+        if not hour_counts:
+            return result
+
+        total = sum(hour_counts.values())
+        # Find peak hours (>15% of activity)
+        peak_hours = [h for h, c in hour_counts.most_common() if c / total > 0.15]
+        if peak_hours:
+            hour_labels = ", ".join(f"{h}:00" for h in sorted(peak_hours))
+            trigger = "session scheduling"
+            action = f"peak activity hours: {hour_labels} (based on {total} events)"
+            r = self._upsert_assertion(
+                conn, profile_id,
+                trigger=trigger, action=action,
+                category="workflow",
+                evidence_count=total,
+                confidence=0.6,
+            )
+            result[r] = result.get(r, 0) + 1
+
+        return result
+
+    # ------------------------------------------------------------------
+    # Strategy 5: Cross-project assertion promotion
+    # ------------------------------------------------------------------
+
+    def _promote_cross_project(
+        self, conn: sqlite3.Connection, profile_id: str,
+    ) -> dict:
+        """Promote assertions that appear in 2+ projects to global scope.
+
+        When the same trigger+action pattern is observed across multiple
+        project_paths with avg confidence >= 0.8, create a global assertion
+        (project_path='') so it applies everywhere.
+        """
+        result = {"promoted": 0, "candidates": 0}
+
+        # Find assertions grouped by trigger+action across projects
+        rows = conn.execute(
+            "SELECT trigger_condition, action, category, "
+            "COUNT(DISTINCT project_path) AS project_count, "
+            "AVG(confidence) AS avg_confidence, "
+            "SUM(evidence_count) AS total_evidence "
+            "FROM behavioral_assertions "
+            "WHERE profile_id = ? AND project_path != '' "
+            "GROUP BY trigger_condition, action "
+            "HAVING COUNT(DISTINCT project_path) >= ?",
+            (profile_id, PROMOTION_MIN_PROJECTS),
+        ).fetchall()
+
+        result["candidates"] = len(rows)
+
+        for row in rows:
+            avg_conf = row["avg_confidence"]
+            if avg_conf < PROMOTION_MIN_CONFIDENCE:
+                continue
+
+            trigger = row["trigger_condition"]
+            action = row["action"]
+            category = row["category"]
+            total_ev = row["total_evidence"]
+            project_count = row["project_count"]
+
+            # Check if global assertion already exists
+            global_id = hashlib.sha256(
+                f"{profile_id}:{trigger}:{action}".encode()
+            ).hexdigest()[:16]
+
+            existing = conn.execute(
+                "SELECT id FROM behavioral_assertions "
+                "WHERE id = ? AND project_path = ''",
+                (global_id,),
+            ).fetchone()
+
+            if existing:
+                # Reinforce existing global assertion
+                now = datetime.now(timezone.utc).isoformat()
+                conn.execute(
+                    "UPDATE behavioral_assertions SET "
+                    "confidence = MIN(0.95, confidence + ?), "
+                    "evidence_count = ?, "
+                    "reinforcement_count = reinforcement_count + 1, "
+                    "last_reinforced_at = ?, updated_at = ? "
+                    "WHERE id = ?",
+                    (REINFORCEMENT_NUDGE, total_ev, now, now, global_id),
+                )
+            else:
+                # Create new global assertion from cross-project evidence
+                now = datetime.now(timezone.utc).isoformat()
+                promoted_conf = min(0.9, avg_conf)
+                conn.execute(
+                    "INSERT INTO behavioral_assertions "
+                    "(id, profile_id, project_path, trigger_condition, action, "
+                    " category, confidence, evidence_count, source, "
+                    " created_at, updated_at) "
+                    "VALUES (?, ?, '', ?, ?, ?, ?, ?, 'cross_project', ?, ?)",
+                    (global_id, profile_id, trigger, action,
+                     category, round(promoted_conf, 4), total_ev, now, now),
+                )
+                result["promoted"] += 1
+                logger.info(
+                    "Promoted assertion to global: '%s' → '%s' "
+                    "(from %d projects, avg_conf=%.2f)",
+                    trigger, action, project_count, avg_conf,
+                )
+
+        return result
+
+    # ------------------------------------------------------------------
+    # Upsert logic
+    # ------------------------------------------------------------------
+
+    def _upsert_assertion(
+        self, conn: sqlite3.Connection, profile_id: str, *,
+        trigger: str, action: str, category: str,
+        evidence_count: int, confidence: float,
+        project_path: str = "",
+    ) -> str:
+        """Create or reinforce a behavioral assertion. Returns 'created' or 'reinforced'."""
+        now = datetime.now(timezone.utc).isoformat()
+
+        # Deterministic ID from trigger+action for idempotent upsert
+        assertion_id = hashlib.sha256(
+            f"{profile_id}:{trigger}:{action}".encode()
+        ).hexdigest()[:16]
+
+        existing = conn.execute(
+            "SELECT id, confidence, reinforcement_count FROM behavioral_assertions WHERE id = ?",
+            (assertion_id,),
+        ).fetchone()
+
+        if existing:
+            # Reinforce: Bayesian nudge toward 1.0
+            old_conf = existing["confidence"]
+            new_conf = old_conf + (1.0 - old_conf) * REINFORCEMENT_NUDGE
+            conn.execute(
+                "UPDATE behavioral_assertions SET confidence = ?, "
+                "evidence_count = ?, reinforcement_count = reinforcement_count + 1, "
+                "last_reinforced_at = ?, updated_at = ? WHERE id = ?",
+                (round(new_conf, 4), evidence_count, now, now, assertion_id),
+            )
+            return "reinforced"
+        else:
+            # Create new assertion at initial confidence
+            conn.execute(
+                "INSERT INTO behavioral_assertions "
+                "(id, profile_id, project_path, trigger_condition, action, "
+                " category, confidence, evidence_count, source, created_at, updated_at) "
+                "VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'auto', ?, ?)",
+                (assertion_id, profile_id, project_path, trigger, action,
+                 category, round(min(confidence, 0.7), 4), evidence_count, now, now),
+            )
+            return "created"

package/src/superlocalmemory/learning/behavioral.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """SuperLocalMemory V3 — Behavioral Pattern Store.

package/src/superlocalmemory/learning/behavioral_listener.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """Behavioral listener — subscribes to event bus, captures patterns.

package/src/superlocalmemory/learning/bootstrap.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """Synthetic bootstrap for cold-start ML ranking.

package/src/superlocalmemory/learning/consolidation_quantization_worker.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """CCQ Worker — background scheduling for Cognitive Consolidation Quantization.

package/src/superlocalmemory/learning/consolidation_worker.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """Sleep-Time Consolidation Worker — background memory maintenance.
@@ -332,14 +332,30 @@ class ConsolidationWorker:
                     except (ValueError, TypeError):
                         pass
 
+            # v3.4.7: Resolve entity IDs to readable canonical names
+            entity_names: dict = {}
+            try:
+                eid_list = list(entity_counts.keys())
+                if eid_list:
+                    placeholders = ",".join("?" * len(eid_list))
+                    name_rows = conn.execute(
+                        f"SELECT entity_id, canonical_name FROM canonical_entities "
+                        f"WHERE entity_id IN ({placeholders})",
+                        eid_list,
+                    ).fetchall()
+                    entity_names = {dict(r)["entity_id"]: dict(r)["canonical_name"] for r in name_rows}
+            except Exception:
+                pass
+
             for entity, count in entity_counts.most_common(15):
                 if count >= 3 and not dry_run:
+                    readable = entity_names.get(entity, entity)
                     confidence = min(1.0, count / max(len(facts) * 0.05, 10))
                     store.record_pattern(
                         profile_id=profile_id,
-                        pattern_type="interest",
-                        data={"topic": entity, "pattern_key": f"entity:{entity}",
-                              "value": entity, "evidence": count,
+                        pattern_type="entity_preferences",
+                        data={"topic": readable, "pattern_key": f"entity:{readable}",
+                              "value": readable, "evidence": count,
                               "source": "entity_frequency"},
                         success_rate=confidence,
                         confidence=confidence,
@@ -359,7 +375,7 @@ class ConsolidationWorker:
                 if heavy_sessions and not dry_run:
                     store.record_pattern(
                         profile_id=profile_id,
-                        pattern_type="workflow",
+                        pattern_type="session_activity",
                         data={"pattern_key": "heavy_session_usage",
                               "value": f"{len(heavy_sessions)} intensive sessions",
                               "evidence": len(heavy_sessions),
@@ -382,7 +398,7 @@ class ConsolidationWorker:
                 pct = round(dominant_type[1] / total_ft * 100)
                 store.record_pattern(
                     profile_id=profile_id,
-                    pattern_type="style",
+                    pattern_type="fact_type_distribution",
                     data={"pattern_key": "memory_style",
                           "value": f"{dominant_type[0]} dominant ({pct}%)",
                           "evidence": dominant_type[1],
@@ -415,7 +431,7 @@ class ConsolidationWorker:
                     if cnt >= 5 and not dry_run:
                         store.record_pattern(
                             profile_id=profile_id,
-                            pattern_type="style",
+                            pattern_type="channel_performance",
                             data={"pattern_key": f"channel:{ch}",
                                   "value": f"{ch} ({cnt} hits, {avg_sig} avg)",
                                   "evidence": cnt,
@@ -437,7 +453,7 @@ class ConsolidationWorker:
                     if coret_rows and not dry_run:
                         store.record_pattern(
                             profile_id=profile_id,
-                            pattern_type="workflow",
+                            pattern_type="co_retrieval_clusters",
                             data={"pattern_key": "co_retrieval_clusters",
                                   "value": f"{len(coret_rows)} strong fact pairs",
                                   "evidence": len(coret_rows),
@@ -466,7 +482,7 @@ class ConsolidationWorker:
                     total_comm = sum(dict(r)["cnt"] for r in comm_rows)
                     store.record_pattern(
                         profile_id=profile_id,
-                        pattern_type="style",
+                        pattern_type="knowledge_structure",
                         data={"pattern_key": "knowledge_structure",
                               "value": f"{len(comm_rows)} topic communities, {total_comm} classified facts",
                               "evidence": total_comm,

package/src/superlocalmemory/learning/cross_project.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """Cross-project knowledge aggregator.

package/src/superlocalmemory/learning/database.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """SuperLocalMemory V3 — Learning Database.

package/src/superlocalmemory/learning/engagement.py

@@ -1,7 +1,6 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: Elastic-2.0
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Part of Qualixar | Author: Varun Pratap Bhardwaj (qualixar.com | varunpratap.com)
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 """
 EngagementTracker -- Local-only engagement metrics for V3 learning.
 

package/src/superlocalmemory/learning/entity_compiler.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """Entity Compilation Engine — auto-generates compiled truth per entity.

package/src/superlocalmemory/learning/features.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """V3-native feature extractor for adaptive ranking.

package/src/superlocalmemory/learning/forgetting_scheduler.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """Forgetting scheduler — periodic retention decay and lifecycle management.

package/src/superlocalmemory/learning/outcomes.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """SuperLocalMemory V3 — Outcome Tracking & Inference.

package/src/superlocalmemory/learning/project_context.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """Project context detection via filesystem analysis.

package/src/superlocalmemory/learning/quantization_scheduler.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3
 
 """Quantization Scheduler -- combined SAGQ + EAP precision management.

package/src/superlocalmemory/learning/ranker.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """3-phase adaptive ranker — from heuristic to ML.

package/src/superlocalmemory/learning/signals.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """Zero-Cost Learning Signals — mathematical learning without LLM tokens.

package/src/superlocalmemory/learning/workflows.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """Workflow pattern miner -- sliding-window sequence and temporal mining.

package/src/superlocalmemory/llm/backbone.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """LLM backbone — unified interface for LLM providers.

package/src/superlocalmemory/math/ebbinghaus.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """Ebbinghaus forgetting curve — memory strength and retention.

package/src/superlocalmemory/math/fisher.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """Fisher-Rao geodesic metric with Bayesian variance update.

package/src/superlocalmemory/math/fisher_quantized.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """Fisher-Rao Quantization-Aware Distance (FRQAD).

package/src/superlocalmemory/math/hopfield.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3
 
 """Modern Continuous Hopfield Network (Ramsauer et al., 2020).