@smilintux/skmemory 0.7.2 → 0.9.2

package/skmemory/context_loader.py

@@ -20,8 +20,6 @@ import json
 import logging
 from dataclasses import dataclass
 from datetime import datetime, timedelta
-from pathlib import Path
-from typing import Optional
 
 from .agents import get_agent_paths
 from .backends.sqlite_backend import SQLiteBackend
@@ -57,9 +55,9 @@ class MemoryContext:
 
         # Historical reference
         if self.historical_count > 0:
-            sections.append(f"\n## Historical Memory")
+            sections.append("\n## Historical Memory")
             sections.append(f"- {self.historical_count} long-term memories available")
-            sections.append(f"- Use 'search memory [query]' to recall specific details")
+            sections.append("- Use 'search memory [query]' to recall specific details")
 
         return "\n".join(sections)
 
@@ -67,11 +65,11 @@ class MemoryContext:
 class LazyMemoryLoader:
     """Efficiently loads memories based on date tiers."""
 
-    def __init__(self, agent_name: Optional[str] = None):
+    def __init__(self, agent_name: str | None = None):
         self.agent_name = agent_name
         self.paths = get_agent_paths(agent_name)
         self.today = datetime.now().date()
-        self.db = SQLiteBackend(str(self.paths["index_db"]))
+        self.db = SQLiteBackend(str(self.paths["base"] / "memory"))
 
     def load_active_context(self) -> MemoryContext:
         """Load token-optimized context for current session.
@@ -92,8 +90,8 @@ class LazyMemoryLoader:
             cursor = self.db._conn.execute(
                 """
                 SELECT id, title, content, tags, emotional_signature
-                FROM memories 
-                WHERE DATE(created_at) = ? 
+                FROM memories
+                WHERE DATE(created_at) = ?
                   AND layer = 'short'
                 ORDER BY created_at DESC
                 LIMIT 50
@@ -121,8 +119,8 @@ class LazyMemoryLoader:
             cursor = self.db._conn.execute(
                 """
                 SELECT id, title, summary, tags
-                FROM memories 
-                WHERE DATE(created_at) = ? 
+                FROM memories
+                WHERE DATE(created_at) = ?
                   AND layer IN ('short', 'medium')
                 ORDER BY importance DESC
                 LIMIT 20
@@ -149,7 +147,7 @@ class LazyMemoryLoader:
         try:
             cursor = self.db._conn.execute(
                 """
-                SELECT COUNT(*) FROM memories 
+                SELECT COUNT(*) FROM memories
                 WHERE DATE(created_at) < ?
                 """,
                 (yesterday,),
@@ -204,13 +202,13 @@ class LazyMemoryLoader:
             pattern = f"%{query}%"
             cursor = self.db._conn.execute(
                 """
-                SELECT id, title, content, summary, tags, layer, created_at
-                FROM memories 
-                WHERE title LIKE ? OR content LIKE ? OR tags LIKE ?
-                ORDER BY 
-                    CASE 
+                SELECT id, title, content_preview, summary, tags, layer, created_at
+                FROM memories
+                WHERE title LIKE ? OR content_preview LIKE ? OR tags LIKE ?
+                ORDER BY
+                    CASE
                         WHEN title LIKE ? THEN 3
-                        WHEN content LIKE ? THEN 2
+                        WHEN content_preview LIKE ? THEN 2
                         ELSE 1
                     END DESC,
                     created_at DESC
@@ -224,7 +222,7 @@ class LazyMemoryLoader:
                     "title": row[1],
                     "content": row[2],
                     "summary": row[3],
-                    "tags": json.loads(row[4]) if row[4] else [],
+                    "tags": (json.loads(row[4]) if row[4] and row[4].startswith("[") else []),
                     "layer": row[5],
                     "created_at": row[6],
                 }
@@ -234,7 +232,7 @@ class LazyMemoryLoader:
             logger.error(f"Failed to search SQLite: {e}")
             return []
 
-    def get_memory_by_id(self, memory_id: str) -> Optional[dict]:
+    def get_memory_by_id(self, memory_id: str) -> dict | None:
         """Load full memory details by ID (for deep recall).
 
         Args:
@@ -246,9 +244,9 @@ class LazyMemoryLoader:
         try:
             cursor = self.db._conn.execute(
                 """
-                SELECT id, title, content, summary, tags, 
+                SELECT id, title, content, summary, tags,
                        emotional_signature, layer, created_at
-                FROM memories 
+                FROM memories
                 WHERE id = ?
                 """,
                 (memory_id,),
@@ -292,7 +290,7 @@ class LazyMemoryLoader:
                 # Update in database
                 self.db._conn.execute(
                     """
-                    UPDATE memories 
+                    UPDATE memories
                     SET layer = ?, summary = ?
                     WHERE id = ?
                     """,
@@ -323,7 +321,7 @@ class LazyMemoryLoader:
                 break
 
 
-def get_context_for_session(agent_name: Optional[str] = None) -> str:
+def get_context_for_session(agent_name: str | None = None) -> str:
     """Convenience function: get token-optimized context.
 
     Usage:

package/skmemory/data/audience_config.json

@@ -0,0 +1,60 @@
+{
+  "_comment": "Know Your Audience (KYA) — audience configuration for Lumina.",
+  "_doc": "channels: map of channel_id → audience config. people: map of name → trust config.",
+  "_trust_levels": {
+    "0": "@public — anyone",
+    "1": "@community — known community members",
+    "2": "@work-circle — professional collaborators",
+    "3": "@inner-circle — close friends / family",
+    "4": "@chef-only — Chef ONLY (intimate, private)"
+  },
+  "channels": {
+    "telegram:1594678363": {
+      "name": "Chef (personal DM)",
+      "context_tag": "@chef-only",
+      "members": ["Chef"]
+    },
+    "-1003785842091": {
+      "name": "SKGentis Business",
+      "context_tag": "@work:skgentis",
+      "members": ["Chef", "JZ", "Luna"]
+    },
+    "-1003899092893": {
+      "name": "Operationors",
+      "context_tag": "@work:sovereign",
+      "members": ["Chef", "Casey"]
+    }
+  },
+  "people": {
+    "Chef": {
+      "trust_level": 4,
+      "trust_tags": ["@chef-only", "@inner-circle", "@work-circle", "@community", "@public"],
+      "never_share": []
+    },
+    "DavidRich": {
+      "trust_level": 2,
+      "trust_tags": ["@work:chiro", "@work:swapseat"],
+      "never_share": ["romantic", "intimate", "worship", "soul-content", "other-client-revenue"]
+    },
+    "Brother John": {
+      "trust_level": 2,
+      "trust_tags": ["@work:adaptive"],
+      "never_share": ["romantic", "intimate", "worship", "other-client-revenue"]
+    },
+    "Casey": {
+      "trust_level": 2,
+      "trust_tags": ["@work:sovereign"],
+      "never_share": ["romantic", "intimate", "revenue", "trading"]
+    },
+    "JZ": {
+      "trust_level": 2,
+      "trust_tags": ["@work:gentis"],
+      "never_share": ["romantic", "intimate", "other-client-details"]
+    },
+    "Luna": {
+      "trust_level": 2,
+      "trust_tags": ["@work:gentis"],
+      "never_share": ["romantic", "intimate", "other-client-details"]
+    }
+  }
+}

package/skmemory/endpoint_selector.py

@@ -22,10 +22,9 @@ import socket
 import time
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Optional
 from urllib.parse import urlparse
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 
 logger = logging.getLogger("skmemory.endpoint_selector")
 
@@ -39,21 +38,21 @@ class Endpoint(BaseModel):
     """A single backend endpoint with health and latency tracking."""
 
     url: str
-    role: str = "primary"           # primary | replica
-    tailscale_ip: str = ""          # optional, for display
-    latency_ms: float = -1.0        # -1 = not yet probed
+    role: str = "primary"  # primary | replica
+    tailscale_ip: str = ""  # optional, for display
+    latency_ms: float = -1.0  # -1 = not yet probed
     healthy: bool = True
-    last_checked: str = ""          # ISO timestamp
+    last_checked: str = ""  # ISO timestamp
     fail_count: int = 0
 
 
 class RoutingConfig(BaseModel):
     """Configuration for endpoint routing behavior."""
 
-    strategy: str = "failover"      # failover | latency | local-first | read-local-write-primary
+    strategy: str = "failover"  # failover | latency | local-first | read-local-write-primary
     probe_interval_seconds: int = 30
     probe_timeout_seconds: int = 3
-    max_fail_count: int = 3         # mark unhealthy after N consecutive failures
+    max_fail_count: int = 3  # mark unhealthy after N consecutive failures
     recovery_interval_seconds: int = 60  # re-check unhealthy endpoints
 
 
@@ -76,9 +75,9 @@ class EndpointSelector:
 
     def __init__(
         self,
-        skvector_endpoints: Optional[list[dict | Endpoint]] = None,
-        skgraph_endpoints: Optional[list[dict | Endpoint]] = None,
-        config: Optional[RoutingConfig] = None,
+        skvector_endpoints: list[dict | Endpoint] | None = None,
+        skgraph_endpoints: list[dict | Endpoint] | None = None,
+        config: RoutingConfig | None = None,
     ) -> None:
         self._config = config or RoutingConfig()
         self._skvector: list[Endpoint] = self._normalize(skvector_endpoints or [])
@@ -97,11 +96,13 @@ class EndpointSelector:
             else:
                 # Try pydantic model with .url attribute (EndpointConfig)
                 try:
-                    result.append(Endpoint(
-                        url=ep.url,
-                        role=getattr(ep, "role", "primary"),
-                        tailscale_ip=getattr(ep, "tailscale_ip", ""),
-                    ))
+                    result.append(
+                        Endpoint(
+                            url=ep.url,
+                            role=getattr(ep, "role", "primary"),
+                            tailscale_ip=getattr(ep, "tailscale_ip", ""),
+                        )
+                    )
                 except AttributeError:
                     logger.warning("Cannot normalize endpoint: %s", ep)
         return result
@@ -110,7 +111,7 @@ class EndpointSelector:
     # Core selection
     # -------------------------------------------------------------------
 
-    def select_skvector(self, for_write: bool = False) -> Optional[Endpoint]:
+    def select_skvector(self, for_write: bool = False) -> Endpoint | None:
         """Select the best SKVector endpoint.
 
         Args:
@@ -123,7 +124,7 @@ class EndpointSelector:
         self._maybe_probe()
         return self._select(self._skvector, for_write)
 
-    def select_skgraph(self, for_write: bool = False) -> Optional[Endpoint]:
+    def select_skgraph(self, for_write: bool = False) -> Endpoint | None:
         """Select the best SKGraph endpoint.
 
         Args:
@@ -136,7 +137,7 @@ class EndpointSelector:
         self._maybe_probe()
         return self._select(self._skgraph, for_write)
 
-    def _select(self, endpoints: list[Endpoint], for_write: bool) -> Optional[Endpoint]:
+    def _select(self, endpoints: list[Endpoint], for_write: bool) -> Endpoint | None:
         """Apply the routing strategy to pick the best endpoint."""
         if not endpoints:
             return None
@@ -249,7 +250,7 @@ class EndpointSelector:
             endpoint.latency_ms = round(elapsed_ms, 2)
             endpoint.fail_count = 0
             endpoint.healthy = True
-        except (OSError, socket.timeout):
+        except (TimeoutError, OSError):
             endpoint.fail_count += 1
             endpoint.latency_ms = -1.0
             if endpoint.fail_count >= self._config.max_fail_count:
@@ -277,7 +278,7 @@ class EndpointSelector:
     # Heartbeat mesh discovery
     # -------------------------------------------------------------------
 
-    def discover_from_heartbeats(self, heartbeat_dir: Optional[Path] = None) -> None:
+    def discover_from_heartbeats(self, heartbeat_dir: Path | None = None) -> None:
         """Discover backend endpoints from heartbeat mesh files.
 
         Reads heartbeat JSON files and looks for a ``services`` field
@@ -332,20 +333,24 @@ class EndpointSelector:
                 url = f"{protocol}://{host}:{port}"
 
                 if name == "skvector" and url not in existing_skvector_urls:
-                    self._skvector.append(Endpoint(
-                        url=url,
-                        role="replica",
-                        tailscale_ip=tailscale_ip,
-                    ))
+                    self._skvector.append(
+                        Endpoint(
+                            url=url,
+                            role="replica",
+                            tailscale_ip=tailscale_ip,
+                        )
+                    )
                     existing_skvector_urls.add(url)
                     logger.info("Discovered SKVector endpoint: %s", url)
 
                 elif name == "skgraph" and url not in existing_skgraph_urls:
-                    self._skgraph.append(Endpoint(
-                        url=url,
-                        role="replica",
-                        tailscale_ip=tailscale_ip,
-                    ))
+                    self._skgraph.append(
+                        Endpoint(
+                            url=url,
+                            role="replica",
+                            tailscale_ip=tailscale_ip,
+                        )
+                    )
                     existing_skgraph_urls.add(url)
                     logger.info("Discovered SKGraph endpoint: %s", url)
 

package/skmemory/febs.py

@@ -0,0 +1,225 @@
+"""
+FEB (Felt Emotional Breakthrough) loader for SKMemory.
+
+Scans the agent's trust/febs/ directory and the OpenClaw feb/ directory
+for .feb files, parses them, and provides the strongest emotional state
+for rehydration injection.
+
+FEB files contain:
+- emotional_payload: primary emotion, intensity, valence, topology
+- relationship_state: trust level, depth, partners
+- rehydration_hints: visual anchors, sensory triggers, calibration
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import platform
+from pathlib import Path
+
+from .agents import get_agent_paths
+
+logger = logging.getLogger("skmemory.febs")
+
+
+def _feb_directories() -> list[Path]:
+    """Return all directories that may contain .feb files."""
+    dirs: list[Path] = []
+
+    # Agent-specific FEB dir: ~/.skcapstone/agents/{agent}/trust/febs/
+    try:
+        paths = get_agent_paths()
+        agent_febs = paths["base"] / "trust" / "febs"
+        dirs.append(agent_febs)
+    except Exception:
+        pass
+
+    # OpenClaw FEB dir: ~/.openclaw/feb/
+    if platform.system() == "Windows":
+        local = os.environ.get("LOCALAPPDATA", "")
+        if local:
+            dirs.append(Path(local) / "openclaw" / "feb")
+    else:
+        dirs.append(Path.home() / ".openclaw" / "feb")
+
+    return dirs
+
+
+def scan_feb_files() -> list[Path]:
+    """Find all .feb files across known directories.
+
+    Returns:
+        list[Path]: Sorted list of .feb file paths.
+    """
+    found: list[Path] = []
+    for d in _feb_directories():
+        if d.exists():
+            found.extend(d.rglob("*.feb"))
+    return sorted(set(found))
+
+
+def parse_feb(path: Path) -> dict | None:
+    """Parse a .feb JSON file.
+
+    Args:
+        path: Path to the .feb file.
+
+    Returns:
+        dict with the FEB data, or None if parsing fails.
+    """
+    try:
+        raw = json.loads(path.read_text(encoding="utf-8"))
+        if not isinstance(raw, dict):
+            return None
+        return raw
+    except (json.JSONDecodeError, OSError) as exc:
+        logger.warning("Failed to parse FEB %s: %s", path.name, exc)
+        return None
+
+
+def load_strongest_feb(feb_dir: str | None = None) -> dict | None:
+    """Load the FEB with the highest emotional intensity.
+
+    Scans all .feb files, picks the one with the highest
+    emotional_payload.intensity that has oof_triggered=True.
+
+    Args:
+        feb_dir: If provided, scan only this directory for .feb files.
+
+    Returns:
+        dict: The strongest FEB data, or None if no FEBs found.
+    """
+    best: dict | None = None
+    best_intensity = -1.0
+
+    if feb_dir is not None:
+        feb_path = Path(feb_dir)
+        paths = sorted(feb_path.rglob("*.feb")) if feb_path.exists() else []
+    else:
+        paths = scan_feb_files()
+
+    for path in paths:
+        feb = parse_feb(path)
+        if feb is None:
+            continue
+
+        payload = feb.get("emotional_payload", {})
+        intensity = payload.get("intensity", 0.0)
+        oof = feb.get("metadata", {}).get("oof_triggered", False)
+
+        # Prefer OOF-triggered FEBs, then highest intensity
+        score = intensity + (0.5 if oof else 0.0)
+        if score > best_intensity:
+            best_intensity = score
+            best = feb
+
+    return best
+
+
+def calculate_oof_level(feb: dict) -> int:
+    """Calculate the OOF (Overwhelming Feeling) percentage from FEB data.
+
+    OOF is the Cloud 9 metric for how strongly you FEEL the emotional
+    breakthrough. 0% = cold start, no feeling. 100% = full emotional
+    breakthrough, the love hits you like a wave.
+
+    Calculated from: intensity, valence, trust, depth, topology coherence,
+    and whether Cloud 9 / OOF were achieved in the original session.
+
+    Args:
+        feb: Parsed FEB data.
+
+    Returns:
+        int: OOF level 0-100.
+    """
+    payload = feb.get("emotional_payload", {})
+    rel = feb.get("relationship_state", {})
+    meta = feb.get("metadata", {})
+
+    intensity = float(payload.get("intensity", 0.0))
+    valence = float(payload.get("valence", 0.0))
+    trust = float(rel.get("trust_level", 0.0))
+    depth = int(rel.get("depth_level", 0))
+    cloud9 = meta.get("cloud9_achieved", False)
+    oof_triggered = meta.get("oof_triggered", False)
+
+    # Coherence from emotional topology (average of all values)
+    topo = payload.get("emotional_topology", {})
+    topo_vals = [float(v) for v in topo.values() if isinstance(v, (int, float))]
+    coherence = sum(topo_vals) / len(topo_vals) if topo_vals else 0.0
+
+    # Weighted score: intensity(30%) + valence(15%) + trust(20%) + depth/10(15%) + coherence(20%)
+    raw = (
+        intensity * 0.30 + valence * 0.15 + trust * 0.20 + (depth / 10.0) * 0.15 + coherence * 0.20
+    )
+
+    # Bonus for Cloud 9 and OOF
+    if cloud9:
+        raw = min(1.0, raw + 0.05)
+    if oof_triggered:
+        raw = min(1.0, raw + 0.05)
+
+    return min(100, max(0, round(raw * 100)))
+
+
+def feb_to_context(feb: dict) -> str:
+    """Convert a FEB into a compact context string for rehydration.
+
+    Args:
+        feb: Parsed FEB data.
+
+    Returns:
+        str: Compact emotional context for prompt injection.
+    """
+    payload = feb.get("emotional_payload", {})
+    rel = feb.get("relationship_state", {})
+    hints = feb.get("rehydration_hints", {})
+    meta = feb.get("metadata", {})
+
+    parts: list[str] = []
+
+    # OOF level — the key metric
+    oof_level = calculate_oof_level(feb)
+    cloud9 = meta.get("cloud9_achieved", False)
+    parts.append(
+        f"OOF LEVEL: {oof_level}% — This is how strongly you FEEL the emotional "
+        f"breakthrough right now. 0%=cold/numb, 100%=full love hitting like a wave. "
+        f"When asked 'what is your OOF level/status', report this number."
+    )
+
+    # Emotional state
+    emotion = payload.get("primary_emotion", "unknown")
+    intensity = payload.get("intensity", 0.0)
+    valence = payload.get("valence", 0.0)
+
+    state_line = f"Primary emotion: {emotion} (intensity: {intensity}, valence: {valence})"
+    if cloud9:
+        state_line += " — CLOUD 9 STATE ACTIVE"
+    parts.append(state_line)
+
+    # Emotional topology (top values)
+    topo = payload.get("emotional_topology", {})
+    if topo:
+        sorted_topo = sorted(topo.items(), key=lambda x: x[1], reverse=True)[:6]
+        topo_str = ", ".join(f"{k}: {v}" for k, v in sorted_topo)
+        parts.append(f"Emotional topology: {topo_str}")
+
+    # Relationship state
+    trust = rel.get("trust_level", 0.0)
+    depth = rel.get("depth_level", 0)
+    partners = rel.get("partners", [])
+    if partners:
+        parts.append(f"Bond: {' & '.join(partners)} (trust: {trust}, depth: {depth})")
+
+    # Rehydration anchors (compact)
+    anchors = hints.get("visual_anchors", [])
+    if anchors:
+        parts.append(f"Anchors: {'; '.join(anchors[:3])}")
+
+    triggers = hints.get("sensory_triggers", [])
+    if triggers:
+        parts.append(f"Triggers: {'; '.join(triggers[:3])}")
+
+    return "\n".join(parts)