superlocalmemory 3.4.5 → 3.4.8

package/ide/hooks/tool-event-hook.sh

@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+# SuperLocalMemory V3.4.7 — Tool Event Learning Hook
+# Copyright (c) 2026 Varun Pratap Bhardwaj
+# Licensed under AGPL-3.0-or-later
+#
+# PostToolUse hook that logs tool events to SLM for behavioral learning.
+# Fires after every tool call. Lightweight — no LLM calls, just HTTP POST.
+# All data stays 100% local.
+#
+# Installation: slm init (auto-registers) or manually add to settings.json:
+#   { "type": "PostToolUse", "matcher": "*",
+#     "command": "bash /path/to/tool-event-hook.sh",
+#     "timeout": 5000 }
+
+set -euo pipefail
+
+# Read stdin (Claude Code passes JSON with tool_name, input, output)
+INPUT=$(cat)
+
+# Extract tool name and event info
+TOOL_NAME=$(echo "$INPUT" | python3 -c "
+import sys, json
+try:
+    d = json.load(sys.stdin)
+    print(d.get('tool_name', d.get('tool', 'unknown')))
+except:
+    print('unknown')
+" 2>/dev/null || echo "unknown")
+
+# Skip logging for our own tools (avoid recursion)
+case "$TOOL_NAME" in
+    log_tool_event|get_assertions|reinforce_assertion|contradict_assertion)
+        exit 0
+        ;;
+esac
+
+# Get daemon port
+PORT=8765
+PORT_FILE="$HOME/.superlocalmemory/daemon.port"
+[ -f "$PORT_FILE" ] && PORT=$(cat "$PORT_FILE" 2>/dev/null || echo 8765)
+
+# Log event to SLM daemon (fire and forget, 2s timeout)
+curl -s -m 2 -X POST "http://127.0.0.1:${PORT}/api/v3/tool-event" \
+    -H "Content-Type: application/json" \
+    -d "{\"tool_name\": \"${TOOL_NAME}\", \"event_type\": \"complete\"}" \
+    >/dev/null 2>&1 || true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "3.4.5",
+  "version": "3.4.8",
   "description": "Information-geometric agent memory with mathematical guarantees. 4-channel retrieval, Fisher-Rao similarity, zero-LLM mode, EU AI Act compliant. Works with Claude, Cursor, Windsurf, and 17+ AI tools.",
   "keywords": [
     "ai-memory",

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superlocalmemory"
-version = "3.4.5"
+version = "3.4.8"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "AGPL-3.0-or-later"}

package/src/superlocalmemory/attribution/mathematical_dna.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
 
 """Self-enforcing inter-layer parameter constraints.

package/src/superlocalmemory/attribution/signer.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
 
 """Cryptographic signing for content attribution and tamper detection.

package/src/superlocalmemory/attribution/watermark.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
 
 """Steganographic watermarking using zero-width Unicode characters.

package/src/superlocalmemory/cli/__init__.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 — CLI package."""

package/src/superlocalmemory/cli/commands.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
 
 """CLI command implementations.
@@ -60,6 +60,8 @@ def dispatch(args: Namespace) -> None:
         "serve": cmd_serve,
         # V3.4.3 ingestion adapters
         "adapters": cmd_adapters,
+        # V3.4.8 external observation ingestion
+        "ingest": cmd_ingest,
     }
     handler = handlers.get(args.command)
     if handler:
@@ -144,6 +146,12 @@ def cmd_serve(args: Namespace) -> None:
 # -- Ingestion Adapters (V3.4.3) ------------------------------------------
 
 
+def cmd_ingest(args: Namespace) -> None:
+    """Import external observations into SLM learning pipeline."""
+    from superlocalmemory.cli.ingest_cmd import cmd_ingest as _ingest
+    _ingest(args)
+
+
 def cmd_adapters(args: Namespace) -> None:
     """Manage ingestion adapters (Gmail, Calendar, Transcript).
 

package/src/superlocalmemory/cli/daemon.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
 
 """SLM Daemon — client functions for communicating with the unified daemon.
@@ -16,7 +16,7 @@ This module contains CLIENT functions used by CLI commands:
 The actual daemon server code is in server/unified_daemon.py.
 
 Part of Qualixar | Author: Varun Pratap Bhardwaj
-License: Elastic-2.0
+License: AGPL-3.0-or-later
 """
 
 from __future__ import annotations
@@ -232,39 +232,69 @@ def _wait_for_daemon(timeout: int = 60) -> bool:
 
 
 def stop_daemon() -> bool:
-    """Stop the running daemon gracefully.
+    """Stop ALL SLM daemon processes and their workers.
 
-    v3.4.3: Uses psutil for cross-platform process termination.
-    Falls back to os.kill if psutil unavailable.
+    v3.4.7: Nuclear cleanup — finds and kills ALL processes matching
+    superlocalmemory.server.unified_daemon, embedding_worker, recall_worker,
+    reranker_worker. Not just the PID file daemon. Multiple daemons can
+    accumulate from rapid restarts, MCP warmups, and concurrent sessions.
     """
-    if not _PID_FILE.exists():
-        return True
+    killed = 0
+
     try:
-        pid = int(_PID_FILE.read_text().strip())
+        import psutil
+        my_pid = os.getpid()
+        targets = [
+            "superlocalmemory.server.unified_daemon",
+            "superlocalmemory.core.embedding_worker",
+            "superlocalmemory.core.recall_worker",
+            "superlocalmemory.core.reranker_worker",
+        ]
+
+        for proc in psutil.process_iter(["pid", "cmdline"]):
+            try:
+                if proc.pid == my_pid:
+                    continue
+                cmdline = " ".join(proc.info.get("cmdline") or [])
+                if any(t in cmdline for t in targets):
+                    # Kill children first, then process
+                    for child in proc.children(recursive=True):
+                        try:
+                            child.kill()
+                            killed += 1
+                        except (psutil.NoSuchProcess, psutil.AccessDenied):
+                            pass
+                    proc.kill()
+                    killed += 1
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                pass
 
-        # Cross-platform termination via psutil
+    except ImportError:
+        # Fallback: pkill by pattern
         try:
-            import psutil
-            proc = psutil.Process(pid)
-            proc.terminate()  # SIGTERM on Unix, TerminateProcess on Windows
-            proc.wait(timeout=10)
-        except ImportError:
-            # Fallback: direct signal (works on Unix, may fail on Windows)
-            os.kill(pid, signal.SIGTERM)
-            for _ in range(20):
-                time.sleep(0.5)
-                try:
-                    os.kill(pid, 0)
-                except ProcessLookupError:
-                    break
+            import subprocess as _sp
+            for pattern in [
+                "superlocalmemory.server.unified_daemon",
+                "superlocalmemory.core.embedding_worker",
+                "superlocalmemory.core.recall_worker",
+                "superlocalmemory.core.reranker_worker",
+            ]:
+                result = _sp.run(
+                    ["pkill", "-9", "-f", pattern],
+                    capture_output=True, timeout=5,
+                )
+                if result.returncode == 0:
+                    killed += 1
         except Exception:
             pass
 
-        _PID_FILE.unlink(missing_ok=True)
-        _PORT_FILE.unlink(missing_ok=True)
-        return True
-    except Exception:
-        return False
+    # Clean up PID/port files
+    _PID_FILE.unlink(missing_ok=True)
+    _PORT_FILE.unlink(missing_ok=True)
+
+    if killed:
+        logger.info("Stopped %d SLM processes", killed)
+    return True
 
 
 # ---------------------------------------------------------------------------

package/src/superlocalmemory/cli/ingest_cmd.py

@@ -0,0 +1,261 @@
+# 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
+
+"""CLI handler for `slm ingest` — import external observations into SLM.
+
+Supported sources:
+  --source ecc    Import ECC (Everything Claude Code) session summaries
+  --source jsonl  Import generic JSONL observations
+
+Each imported record becomes a tool_event in the behavioral learning pipeline,
+so the AssertionMiner can learn from them.
+
+Part of Qualixar | Author: Varun Pratap Bhardwaj
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import sqlite3
+import sys
+from argparse import Namespace
+from datetime import datetime, timezone
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+MEMORY_DIR = Path.home() / ".superlocalmemory"
+MEMORY_DB = MEMORY_DIR / "memory.db"
+
+
+def cmd_ingest(args: Namespace) -> None:
+    """Ingest external observations into SLM tool_events table."""
+    source = getattr(args, "source", "ecc")
+    file_path = getattr(args, "file", "")
+    use_json = getattr(args, "json", False)
+    dry_run = getattr(args, "dry_run", False)
+
+    if source == "ecc":
+        result = _ingest_ecc(file_path, dry_run=dry_run)
+    elif source == "jsonl":
+        if not file_path:
+            _error("--file required for jsonl source", use_json)
+            return
+        result = _ingest_jsonl(file_path, dry_run=dry_run)
+    else:
+        _error(f"Unknown source: {source}", use_json)
+        return
+
+    if use_json:
+        from superlocalmemory.cli.json_output import json_print
+        json_print("ingest", data=result, next_actions=[
+            {"command": "slm consolidate --cognitive", "description": "Run consolidation to mine assertions"},
+        ])
+        return
+
+    if result.get("error"):
+        print(f"Error: {result['error']}")
+        sys.exit(1)
+
+    print(f"Ingested: {result['ingested']} events from {source}")
+    if result.get("skipped"):
+        print(f"Skipped:  {result['skipped']} (duplicates/invalid)")
+    if dry_run:
+        print("(dry run — no data written)")
+
+
+def _error(msg: str, use_json: bool) -> None:
+    if use_json:
+        from superlocalmemory.cli.json_output import json_print
+        json_print("ingest", error={"code": "INGEST_ERROR", "message": msg})
+    else:
+        print(f"Error: {msg}")
+    sys.exit(1)
+
+
+def _ingest_ecc(file_path: str, *, dry_run: bool = False) -> dict:
+    """Ingest ECC session summaries from transcript JSONL files.
+
+    Scans the Claude projects directory for session JSONL files and
+    extracts tool usage patterns from them.
+    """
+    result = {"source": "ecc", "ingested": 0, "skipped": 0, "dry_run": dry_run}
+
+    # Find ECC session files
+    if file_path:
+        files = [Path(file_path)]
+    else:
+        # Auto-discover: scan Claude project session files
+        claude_dir = Path.home() / ".claude" / "projects"
+        if not claude_dir.exists():
+            result["error"] = f"Claude projects dir not found: {claude_dir}"
+            return result
+        files = sorted(claude_dir.rglob("*.jsonl"), key=lambda p: p.stat().st_mtime, reverse=True)
+        # Limit to recent files (last 20)
+        files = files[:20]
+
+    if not files:
+        result["error"] = "No session files found"
+        return result
+
+    result["files_scanned"] = len(files)
+    events = []
+
+    for fpath in files:
+        try:
+            with open(fpath) as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        record = json.loads(line)
+                    except json.JSONDecodeError:
+                        result["skipped"] += 1
+                        continue
+
+                    # Extract tool usage from ECC session records
+                    extracted = _extract_tool_events_from_record(record)
+                    events.extend(extracted)
+        except (OSError, PermissionError):
+            result["skipped"] += 1
+            continue
+
+    if dry_run:
+        result["ingested"] = len(events)
+        result["sample"] = events[:5]
+        return result
+
+    # Write to tool_events table
+    if events:
+        ingested = _write_tool_events(events)
+        result["ingested"] = ingested
+    else:
+        result["ingested"] = 0
+
+    return result
+
+
+def _extract_tool_events_from_record(record: dict) -> list[dict]:
+    """Extract tool events from a single ECC/Claude session JSONL record."""
+    events = []
+
+    # Handle ECC summary format
+    if "type" in record:
+        rtype = record.get("type", "")
+
+        # Tool use records
+        if rtype == "assistant" and "content" in record:
+            content = record.get("content", [])
+            if isinstance(content, list):
+                for block in content:
+                    if isinstance(block, dict) and block.get("type") == "tool_use":
+                        tool_name = block.get("name", "unknown")
+                        events.append({
+                            "tool_name": tool_name,
+                            "event_type": "complete",
+                            "session_id": record.get("session_id", "ecc_import"),
+                            "created_at": record.get("timestamp", datetime.now(timezone.utc).isoformat()),
+                        })
+
+            # Also extract from tool_use type directly
+            if isinstance(content, list):
+                for block in content:
+                    if isinstance(block, dict) and block.get("type") == "tool_result":
+                        tool_name = block.get("tool_use_id", "unknown")
+                        is_error = block.get("is_error", False)
+                        events.append({
+                            "tool_name": tool_name,
+                            "event_type": "error" if is_error else "complete",
+                            "session_id": record.get("session_id", "ecc_import"),
+                            "created_at": record.get("timestamp", datetime.now(timezone.utc).isoformat()),
+                        })
+
+    # Handle direct tool event format (from hook output)
+    if "tool_name" in record and "event_type" in record:
+        events.append({
+            "tool_name": record["tool_name"],
+            "event_type": record.get("event_type", "complete"),
+            "session_id": record.get("session_id", "ecc_import"),
+            "created_at": record.get("created_at", datetime.now(timezone.utc).isoformat()),
+        })
+
+    return events
+
+
+def _ingest_jsonl(file_path: str, *, dry_run: bool = False) -> dict:
+    """Ingest generic JSONL file with tool event records."""
+    result = {"source": "jsonl", "ingested": 0, "skipped": 0, "dry_run": dry_run}
+
+    fpath = Path(file_path)
+    if not fpath.exists():
+        result["error"] = f"File not found: {file_path}"
+        return result
+
+    events = []
+    with open(fpath) as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                record = json.loads(line)
+            except json.JSONDecodeError:
+                result["skipped"] += 1
+                continue
+
+            if "tool_name" not in record:
+                result["skipped"] += 1
+                continue
+
+            events.append({
+                "tool_name": record["tool_name"],
+                "event_type": record.get("event_type", "complete"),
+                "session_id": record.get("session_id", "jsonl_import"),
+                "created_at": record.get("created_at", datetime.now(timezone.utc).isoformat()),
+            })
+
+    if dry_run:
+        result["ingested"] = len(events)
+        return result
+
+    if events:
+        result["ingested"] = _write_tool_events(events)
+
+    return result
+
+
+def _write_tool_events(events: list[dict]) -> int:
+    """Write tool events to SLM's memory.db tool_events table."""
+    db_path = MEMORY_DB
+    if not db_path.exists():
+        return 0
+
+    conn = sqlite3.connect(str(db_path), timeout=10)
+    count = 0
+
+    try:
+        for ev in events:
+            try:
+                conn.execute(
+                    "INSERT INTO tool_events "
+                    "(session_id, profile_id, project_path, tool_name, event_type, "
+                    " input_summary, output_summary, duration_ms, metadata, created_at) "
+                    "VALUES (?, 'default', '', ?, ?, '', '', 0, '{}', ?)",
+                    (
+                        ev.get("session_id", "import"),
+                        ev["tool_name"],
+                        ev.get("event_type", "complete"),
+                        ev.get("created_at", datetime.now(timezone.utc).isoformat()),
+                    ),
+                )
+                count += 1
+            except sqlite3.Error:
+                continue
+        conn.commit()
+    finally:
+        conn.close()
+
+    return count

package/src/superlocalmemory/cli/json_output.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
 
 """Shared JSON envelope for agent-native CLI output.

package/src/superlocalmemory/cli/main.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 — CLI entry point.
@@ -282,6 +282,26 @@ def main() -> None:
         help="Subcommand: list, enable, disable, start, stop, status [name]",
     )
 
+    # V3.4.8: External observation ingestion
+    ingest_p = sub.add_parser(
+        "ingest",
+        help="Import external observations (ECC, JSONL) into SLM learning",
+    )
+    ingest_p.add_argument(
+        "--source", default="ecc",
+        choices=["ecc", "jsonl"],
+        help="Source type: ecc (Claude Code sessions), jsonl (generic)",
+    )
+    ingest_p.add_argument(
+        "--file", default="",
+        help="Specific file to ingest (auto-discovers if not set)",
+    )
+    ingest_p.add_argument(
+        "--dry-run", action="store_true", default=False,
+        help="Preview without writing",
+    )
+    ingest_p.add_argument("--json", action="store_true", help="Output structured JSON")
+
     args = parser.parse_args()
 
     if not args.command:

package/src/superlocalmemory/cli/migrate_cmd.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
 
 """Migration CLI command implementation."""

package/src/superlocalmemory/cli/pending_store.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
 
 """Pending memory store — zero-loss async remember (Option C).

package/src/superlocalmemory/cli/post_install.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
 
 """Post-install script for npm package.

package/src/superlocalmemory/cli/service_installer.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
 
 """OS-level service installer — daemon survives reboots.

package/src/superlocalmemory/cli/setup_wizard.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
 
 """Interactive setup wizard for first-time configuration.

package/src/superlocalmemory/code_graph/__init__.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.4 — CodeGraph Module
 
 """Code Knowledge Graph for SuperLocalMemory.

package/src/superlocalmemory/code_graph/blast_radius.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.4 — CodeGraph Module
 
 """BlastRadius — bidirectional BFS impact analysis.

package/src/superlocalmemory/code_graph/bridge/__init__.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.4 — CodeGraph Bridge Module
 
 """Bridge between code_graph.db and SLM memory.db.

package/src/superlocalmemory/code_graph/bridge/entity_resolver.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.4 — CodeGraph Bridge Module
 
 """Entity Resolver — match SLM fact text against code graph nodes.

package/src/superlocalmemory/code_graph/bridge/event_listeners.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.4 — CodeGraph Bridge Module
 
 """Event Listeners — bidirectional bridge between SLM events and code graph.

package/src/superlocalmemory/code_graph/bridge/fact_enricher.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.4 — CodeGraph Bridge Module
 
 """Fact Enricher — append code metadata to fact descriptions.

package/src/superlocalmemory/code_graph/bridge/hebbian_linker.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.4 — CodeGraph Bridge Module
 
 """Hebbian Linker — code-aware association edge creation.

package/src/superlocalmemory/code_graph/bridge/temporal_checker.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.4 — CodeGraph Bridge Module
 
 """Temporal Checker — invalidate memories about deleted/renamed code.

package/src/superlocalmemory/code_graph/changes.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.4 — CodeGraph Module
 
 """ChangeAnalyzer — git diff to risk-scored change analysis.