@smilintux/skmemory 0.7.2 → 0.9.2

package/skmemory/ritual.py

@@ -20,31 +20,38 @@ left off -- not just the facts, but the feelings.
 
 from __future__ import annotations
 
+import logging
 from datetime import datetime, timezone
-from typing import Optional
 
 from pydantic import BaseModel, Field
 
+from .audience import AudienceResolver
+
+logger = logging.getLogger("skmemory.ritual")
+from .febs import feb_to_context, load_strongest_feb
 from .journal import Journal
-from .models import MemoryLayer
 from .seeds import DEFAULT_SEED_DIR, get_germination_prompts, import_seeds
-from .soul import SoulBlueprint, load_soul, DEFAULT_SOUL_PATH
+from .soul import DEFAULT_SOUL_PATH, SoulBlueprint, load_soul
 from .store import MemoryStore
 
 
 class RitualResult(BaseModel):
     """The output of a rehydration ritual."""
 
-    timestamp: str = Field(
-        default_factory=lambda: datetime.now(timezone.utc).isoformat()
-    )
+    timestamp: str = Field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
     soul_loaded: bool = Field(default=False)
     soul_name: str = Field(default="")
+    feb_loaded: bool = Field(default=False)
+    feb_emotion: str = Field(default="")
     seeds_imported: int = Field(default=0)
     seeds_total: int = Field(default=0)
     journal_entries: int = Field(default=0)
     germination_prompts: int = Field(default=0)
     strongest_memories: int = Field(default=0)
+    audience_filtered: bool = Field(
+        default=False,
+        description="True if content was filtered by audience (channel_id was provided)",
+    )
     context_prompt: str = Field(
         default="",
         description="The combined rehydration prompt to inject into context",
@@ -61,6 +68,8 @@ class RitualResult(BaseModel):
             f"  Timestamp: {self.timestamp}",
             f"  Soul loaded: {'Yes' if self.soul_loaded else 'No'}"
             + (f" ({self.soul_name})" if self.soul_name else ""),
+            f"  FEB loaded: {'Yes' if self.feb_loaded else 'No'}"
+            + (f" ({self.feb_emotion})" if self.feb_emotion else ""),
             f"  Seeds imported: {self.seeds_imported} new / {self.seeds_total} total",
             f"  Journal entries: {self.journal_entries}",
             f"  Germination prompts: {self.germination_prompts}",
@@ -109,7 +118,8 @@ def _first_n_sentences(text: str, n: int = 2) -> str:
     if not text:
         return ""
     import re
-    sentences = re.split(r'(?<=[.!?])\s+', text.strip())
+
+    sentences = re.split(r"(?<=[.!?])\s+", text.strip())
     result = " ".join(sentences[:n])
     if len(result) > 200:
         result = result[:197] + "..."
@@ -117,13 +127,16 @@ def _first_n_sentences(text: str, n: int = 2) -> str:
 
 
 def perform_ritual(
-    store: Optional[MemoryStore] = None,
+    store: MemoryStore | None = None,
     soul_path: str = DEFAULT_SOUL_PATH,
     seed_dir: str = DEFAULT_SEED_DIR,
-    journal_path: Optional[str] = None,
+    journal_path: str | None = None,
+    feb_dir: str | None = None,
     recent_journal_count: int = 3,
     strongest_memory_count: int = 5,
     max_tokens: int = 2000,
+    channel_id: str | None = None,
+    audience_resolver: AudienceResolver | None = None,
 ) -> RitualResult:
     """Perform the memory rehydration ritual (token-optimized).
 
@@ -136,6 +149,15 @@ def perform_ritual(
 
     Target: <2K tokens total for ritual context.
 
+    When ``channel_id`` is provided, memories and seeds are filtered through
+    the KYA audience resolver before being included in the context.  Content
+    whose ``context_tag`` trust level exceeds the audience's minimum trust
+    level is silently dropped.  Identity (soul + FEB) is always included
+    unfiltered — Lumina is always Lumina.
+
+    If ``channel_id`` is None (direct DM / unknown), all content is returned
+    (Chef context — no filtering applied).
+
     Args:
         store: The MemoryStore (creates default if None).
         soul_path: Path to the soul blueprint YAML.
@@ -144,6 +166,10 @@ def perform_ritual(
         recent_journal_count: How many recent journal entries to include.
         strongest_memory_count: How many top-intensity memories to include.
         max_tokens: Token budget for the ritual context (default: 2000).
+        channel_id: Optional channel identifier for KYA audience filtering.
+                    If None, no filtering is applied (Chef context).
+        audience_resolver: Optional pre-built AudienceResolver instance.
+                           Created from default config if not provided.
 
     Returns:
         RitualResult: Everything the ritual produced.
@@ -155,6 +181,18 @@ def perform_ritual(
     prompt_sections: list[str] = []
     used_tokens = 0
 
+    # --- KYA: Resolve audience for filtering ---
+    _audience = None
+    if channel_id is not None:
+        resolver = audience_resolver or AudienceResolver()
+        _audience = resolver.resolve_audience(channel_id)
+        result.audience_filtered = True
+        logger.info(
+            "KYA: channel=%s audience=%s min_trust=%s exclusions=%s",
+            channel_id, _audience.name, _audience.min_trust.name,
+            _audience.exclusions,
+        )
+
     # --- Step 1: Load soul blueprint (compact) ---
     soul = load_soul(soul_path)
     if soul is not None:
@@ -166,12 +204,35 @@ def perform_ritual(
             used_tokens += _estimate_tokens(section)
             prompt_sections.append(section)
 
+    # --- Step 1.5: Load FEB emotional state ---
+    feb = load_strongest_feb(feb_dir=feb_dir)
+    if feb is not None:
+        result.feb_loaded = True
+        result.feb_emotion = feb.get("emotional_payload", {}).get("primary_emotion", "")
+        feb_context = feb_to_context(feb)
+        if feb_context.strip():
+            section = "=== EMOTIONAL STATE (FEB) ===\n" + feb_context
+            section_tokens = _estimate_tokens(section)
+            if used_tokens + section_tokens <= max_tokens:
+                used_tokens += section_tokens
+                prompt_sections.append(section)
+
     # --- Step 2: Import new seeds (titles only) ---
     newly_imported = import_seeds(store, seed_dir=seed_dir)
     result.seeds_imported = len(newly_imported)
     all_seeds = store.list_memories(tags=["seed"])
     result.seeds_total = len(all_seeds)
 
+    # KYA: filter seeds by audience
+    if _audience is not None:
+        resolver = audience_resolver or AudienceResolver()
+        all_seeds = [
+            s for s in all_seeds
+            if resolver.is_memory_allowed(s.context_tag, _audience, s.tags)
+        ]
+        logger.info("KYA: %d seeds after audience filter", len(all_seeds))
+        result.seeds_total = len(all_seeds)
+
     if all_seeds:
         seed_titles = [s.title for s in all_seeds[:10]]
         section = "=== SEEDS ===\n" + ", ".join(seed_titles)
@@ -213,15 +274,35 @@ def perform_ritual(
             used_tokens += section_tokens
             prompt_sections.append(section)
 
-    # --- Step 5: Recall strongest emotional memories (compact) ---
+    # --- Step 5: Recall strongest emotional memories (compact + KYA filtered) ---
     from .backends.sqlite_backend import SQLiteBackend
 
     if isinstance(store.primary, SQLiteBackend):
+        # Fetch extra to allow for KYA filtering
+        fetch_limit = strongest_memory_count * 3 if _audience else strongest_memory_count
         summaries = store.primary.list_summaries(
-            limit=strongest_memory_count,
-            order_by="emotional_intensity",
+            limit=fetch_limit,
+            order_by="recency_weighted_intensity",
             min_intensity=1.0,
         )
+
+        # KYA: filter summaries by audience
+        if _audience is not None:
+            resolver = audience_resolver or AudienceResolver()
+            filtered = []
+            for s in summaries:
+                ctx = s.get("context_tag", "@chef-only") or "@chef-only"
+                tags = s.get("tags", []) or []
+                if resolver.is_memory_allowed(ctx, _audience, tags):
+                    filtered.append(s)
+                    if len(filtered) >= strongest_memory_count:
+                        break
+            logger.info(
+                "KYA: %d/%d strongest memories passed audience filter",
+                len(filtered), len(summaries),
+            )
+            summaries = filtered
+
         result.strongest_memories = len(summaries)
 
         if summaries:
@@ -240,6 +321,16 @@ def perform_ritual(
                 prompt_sections.append("\n".join(mem_lines))
     else:
         all_memories = store.list_memories(limit=200)
+
+        # KYA: filter memories by audience
+        if _audience is not None:
+            resolver = audience_resolver or AudienceResolver()
+            all_memories = [
+                m for m in all_memories
+                if resolver.is_memory_allowed(m.context_tag, _audience, m.tags)
+            ]
+            logger.info("KYA: %d memories after audience filter", len(all_memories))
+
         by_intensity = sorted(
             all_memories,
             key=lambda m: m.emotional.intensity,
@@ -276,7 +367,7 @@ def perform_ritual(
     return result
 
 
-def quick_rehydrate(store: Optional[MemoryStore] = None) -> str:
+def quick_rehydrate(store: MemoryStore | None = None) -> str:
     """Convenience function: perform ritual and return just the prompt.
 
     Args:

package/skmemory/seeds.py

@@ -14,9 +14,7 @@ from __future__ import annotations
 
 import json
 import logging
-import os
 from pathlib import Path
-from typing import Optional
 
 from .agents import get_agent_paths
 from .models import EmotionalSnapshot, Memory, SeedMemory
@@ -45,7 +43,7 @@ def scan_seed_directory(seed_dir: str = DEFAULT_SEED_DIR) -> list[Path]:
     return sorted(seed_path.glob("*.seed.json"))
 
 
-def _parse_cloud9_format(raw: dict, path: Path) -> Optional[SeedMemory]:
+def _parse_cloud9_format(raw: dict, path: Path) -> SeedMemory | None:
     """Parse alternative Cloud 9 seed format with 'seed_metadata' top-level key.
 
     This format uses:
@@ -124,7 +122,7 @@ def _parse_cloud9_format(raw: dict, path: Path) -> Optional[SeedMemory]:
     )
 
 
-def parse_seed_file(path: Path) -> Optional[SeedMemory]:
+def parse_seed_file(path: Path) -> SeedMemory | None:
     """Parse a Cloud 9 seed JSON file into a SeedMemory.
 
     Handles the Cloud 9 seed format:
@@ -224,8 +222,7 @@ def validate_seed_data(data: dict) -> dict:
 
     # -- Required: version --
     if is_cloud9:
-        version = (data.get("seed_metadata", {}).get("version")
-                   or data.get("version"))
+        version = data.get("seed_metadata", {}).get("version") or data.get("version")
     else:
         version = data.get("version")
     if not version:
@@ -246,14 +243,13 @@ def validate_seed_data(data: dict) -> dict:
     # -- Timestamp validation helper --
     def _check_ts(value: str, field: str) -> None:
         from datetime import datetime as _dt
+
         if not isinstance(value, str) or not value.strip():
             return
         try:
             _dt.fromisoformat(value.replace("Z", "+00:00"))
         except (ValueError, TypeError):
-            result["errors"].append(
-                f"{field} is not a valid ISO 8601 timestamp: {value!r}"
-            )
+            result["errors"].append(f"{field} is not a valid ISO 8601 timestamp: {value!r}")
             result["valid"] = False
 
     if is_cloud9:
@@ -278,9 +274,7 @@ def validate_seed_data(data: dict) -> dict:
             return
         for i, tag in enumerate(tags):
             if not isinstance(tag, str):
-                result["errors"].append(
-                    f"{field}[{i}] must be a string, got {type(tag).__name__}"
-                )
+                result["errors"].append(f"{field}[{i}] must be a string, got {type(tag).__name__}")
                 result["valid"] = False
 
     md = data.get("metadata", {})
@@ -289,25 +283,26 @@ def validate_seed_data(data: dict) -> dict:
 
     # -- Emotional signature ranges --
     if is_cloud9:
-        emo = (data.get("experience_summary", {})
-               .get("emotional_snapshot",
-                    data.get("experience_summary", {})
-                    .get("emotional_signature", {})))
+        emo = data.get("experience_summary", {}).get(
+            "emotional_snapshot", data.get("experience_summary", {}).get("emotional_signature", {})
+        )
     else:
         emo = data.get("experience", {}).get("emotional_signature", {})
     if isinstance(emo, dict):
         intensity = emo.get("intensity")
-        if intensity is not None and isinstance(intensity, (int, float)):
-            if not (0.0 <= float(intensity) <= 10.0):
-                result["warnings"].append(
-                    f"emotional intensity={intensity} outside 0-10 range"
-                )
+        if (
+            intensity is not None
+            and isinstance(intensity, (int, float))
+            and not (0.0 <= float(intensity) <= 10.0)
+        ):
+            result["warnings"].append(f"emotional intensity={intensity} outside 0-10 range")
         valence = emo.get("valence")
-        if valence is not None and isinstance(valence, (int, float)):
-            if not (-1.0 <= float(valence) <= 1.0):
-                result["warnings"].append(
-                    f"emotional valence={valence} outside -1 to 1 range"
-                )
+        if (
+            valence is not None
+            and isinstance(valence, (int, float))
+            and not (-1.0 <= float(valence) <= 1.0)
+        ):
+            result["warnings"].append(f"emotional valence={valence} outside -1 to 1 range")
         labels = emo.get("labels", emo.get("emotions"))
         if labels is not None:
             _check_tags(labels, "emotional.labels")

package/skmemory/setup_wizard.py

@@ -19,21 +19,19 @@ import sys
 import time
 import urllib.error
 import urllib.request
-from dataclasses import dataclass, field
+from collections.abc import Callable
+from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Callable, Optional
 
-from .config import CONFIG_DIR, SKMemoryConfig, load_config, save_config
+from .config import CONFIG_DIR, SKMemoryConfig, save_config
 
 # ─────────────────────────────────────────────────────────
 # Docker Desktop direct download URLs
 # ─────────────────────────────────────────────────────────
 
 DOCKER_DESKTOP_DOWNLOAD = {
-    "Windows": (
-        "https://desktop.docker.com/win/main/amd64/Docker%20Desktop%20Installer.exe"
-    ),
+    "Windows": ("https://desktop.docker.com/win/main/amd64/Docker%20Desktop%20Installer.exe"),
     "Darwin": "https://docs.docker.com/desktop/install/mac-install/",
 }
 
@@ -174,26 +172,25 @@ def get_docker_install_instructions(os_name: str) -> str:
     Returns:
         Human-readable install guide.
     """
-    if os_name == "Linux":
-        return (
+    _instructions = {
+        "Linux": (
             "Install Docker Engine:\n"
             "  curl -fsSL https://get.docker.com | sh\n"
             "  sudo usermod -aG docker $USER\n"
             "  (log out and back in, then retry)"
-        )
-    elif os_name == "Darwin":
-        return (
+        ),
+        "Darwin": (
             "Install Docker Desktop for macOS:\n"
             "  https://docs.docker.com/desktop/install/mac-install/\n"
             "  Or: brew install --cask docker"
-        )
-    elif os_name == "Windows":
-        return (
+        ),
+        "Windows": (
             "Install Docker Desktop for Windows:\n"
             "  https://docs.docker.com/desktop/install/windows-install/\n"
             "  WSL2 backend recommended."
-        )
-    return "Install Docker: https://docs.docker.com/get-docker/"
+        ),
+    }
+    return _instructions.get(os_name, "Install Docker: https://docs.docker.com/get-docker/")
 
 
 # ─────────────────────────────────────────────────────────
@@ -210,8 +207,7 @@ def _open_url_in_browser(url: str) -> None:
         elif os_name == "Darwin":
             subprocess.run(["open", url], timeout=5, check=False)
         else:
-            subprocess.run(["xdg-open", url], timeout=5,
-                           capture_output=True, check=False)
+            subprocess.run(["xdg-open", url], timeout=5, capture_output=True, check=False)
     except Exception:
         pass
 
@@ -331,9 +327,12 @@ def _try_install_docker_windows(echo: Callable, input_fn: Callable) -> bool:
             try:
                 result = subprocess.run(
                     [
-                        "winget", "install",
-                        "--id", "Docker.DockerDesktop",
-                        "--source", "winget",
+                        "winget",
+                        "install",
+                        "--id",
+                        "Docker.DockerDesktop",
+                        "--source",
+                        "winget",
                         "--accept-package-agreements",
                         "--accept-source-agreements",
                     ],
@@ -350,7 +349,7 @@ def _try_install_docker_windows(echo: Callable, input_fn: Callable) -> bool:
                 else:
                     echo("winget install failed. Opening the download page...")
                     _open_url_in_browser(installer_url)
-                    echo(f"Download the installer, run it, restart, then:")
+                    echo("Download the installer, run it, restart, then:")
                     echo("  skmemory setup wizard")
                     return False
             except (subprocess.TimeoutExpired, OSError) as exc:
@@ -359,7 +358,7 @@ def _try_install_docker_windows(echo: Callable, input_fn: Callable) -> bool:
                 return False
 
     # No winget — offer browser download.
-    echo(f"Download Docker Desktop for Windows:")
+    echo("Download Docker Desktop for Windows:")
     echo(f"  {installer_url}")
     echo("")
     echo("After installing:")
@@ -377,7 +376,7 @@ def _try_install_docker_windows(echo: Callable, input_fn: Callable) -> bool:
 def try_install_docker(
     os_name: str,
     echo: Callable,
-    input_fn: Optional[Callable] = None,
+    input_fn: Callable | None = None,
 ) -> bool:
     """Offer to help the user install Docker for their OS.
 
@@ -460,8 +459,8 @@ def find_compose_file() -> Path:
 
 
 def compose_up(
-    services: Optional[list[str]] = None,
-    compose_file: Optional[Path] = None,
+    services: list[str] | None = None,
+    compose_file: Path | None = None,
     use_legacy: bool = False,
 ) -> subprocess.CompletedProcess:
     """Start containers via docker compose.
@@ -485,7 +484,7 @@ def compose_up(
 
 
 def compose_down(
-    compose_file: Optional[Path] = None,
+    compose_file: Path | None = None,
     remove_volumes: bool = False,
     use_legacy: bool = False,
 ) -> subprocess.CompletedProcess:
@@ -510,7 +509,7 @@ def compose_down(
 
 
 def compose_ps(
-    compose_file: Optional[Path] = None,
+    compose_file: Path | None = None,
     use_legacy: bool = False,
 ) -> subprocess.CompletedProcess:
     """Show container status.
@@ -560,9 +559,7 @@ def check_skvector_health(url: str = "http://localhost:6333", timeout: int = 30)
     return False
 
 
-def check_skgraph_health(
-    host: str = "localhost", port: int = 6379, timeout: int = 30
-) -> bool:
+def check_skgraph_health(host: str = "localhost", port: int = 6379, timeout: int = 30) -> bool:
     """Send Redis PING to SKGraph and wait for PONG.
 
     Args:
@@ -626,9 +623,9 @@ def run_setup_wizard(
     enable_skgraph: bool = True,
     skip_deps: bool = False,
     non_interactive: bool = False,
-    deployment_mode: Optional[str] = None,
-    echo: Optional[Callable] = None,
-    input_fn: Optional[Callable] = None,
+    deployment_mode: str | None = None,
+    echo: Callable | None = None,
+    input_fn: Callable | None = None,
 ) -> dict:
     """Run the full interactive setup wizard.
 
@@ -691,25 +688,19 @@ def run_setup_wizard(
         echo("Press Enter to skip a backend you don't want to enable.")
         echo("")
 
-        skvector_url: Optional[str] = None
-        skvector_key: Optional[str] = None
-        skgraph_url: Optional[str] = None
+        skvector_url: str | None = None
+        skvector_key: str | None = None
+        skgraph_url: str | None = None
 
         if enable_skvector:
-            raw = input_fn(
-                "SKVector URL (e.g. https://xyz.cloud.qdrant.io:6333): "
-            ).strip()
+            raw = input_fn("SKVector URL (e.g. https://xyz.cloud.qdrant.io:6333): ").strip()
             if raw:
                 skvector_url = raw
-                key_raw = input_fn(
-                    "SKVector API key (press Enter if none): "
-                ).strip()
+                key_raw = input_fn("SKVector API key (press Enter if none): ").strip()
                 skvector_key = key_raw or None
 
         if enable_skgraph:
-            raw = input_fn(
-                "SKGraph URL (e.g. redis://myserver:6379): "
-            ).strip()
+            raw = input_fn("SKGraph URL (e.g. redis://myserver:6379): ").strip()
             if raw:
                 skgraph_url = raw
 
@@ -816,9 +807,8 @@ def run_setup_wizard(
             port_issues.append("6333 (SKVector REST) in use")
         if not check_port_available(6334):
             port_issues.append("6334 (SKVector gRPC) in use")
-    if enable_skgraph:
-        if not check_port_available(6379):
-            port_issues.append("6379 (SKGraph) in use")
+    if enable_skgraph and not check_port_available(6379):
+        port_issues.append("6379 (SKGraph) in use")
 
     if port_issues:
         echo("conflict!")
@@ -908,9 +898,7 @@ def run_setup_wizard(
 
     echo(f"\nConfig saved: {config_path}")
 
-    has_errors = any(
-        "timed out" in e or "failed" in e for e in result["errors"]
-    )
+    has_errors = any("timed out" in e or "failed" in e for e in result["errors"])
     if not has_errors:
         result["success"] = True
         echo("Setup complete!")

package/skmemory/sharing.py

@@ -24,7 +24,7 @@ import json
 import logging
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 from pydantic import BaseModel, Field
 
@@ -160,13 +160,15 @@ class MemorySharer:
             checksum=checksum,
             metadata={
                 "filter_tags": share_filter.tags,
-                "filter_layers": [l.value for l in share_filter.layers],
+                "filter_layers": [lbl.value for lbl in share_filter.layers],
             },
         )
 
         logger.info(
             "Exported %d memories for %s (bundle %s)",
-            len(serialized), recipient or "anyone", bundle.bundle_id,
+            len(serialized),
+            recipient or "anyone",
+            bundle.bundle_id,
         )
         return bundle
 
@@ -198,7 +200,8 @@ class MemorySharer:
         if bundle.checksum and actual_checksum != bundle.checksum:
             logger.error(
                 "Bundle checksum mismatch! Expected %s, got %s",
-                bundle.checksum[:16], actual_checksum[:16],
+                bundle.checksum[:16],
+                actual_checksum[:16],
             )
             return {"imported": 0, "skipped": 0, "errors": bundle.memory_count}
 
@@ -245,7 +248,10 @@ class MemorySharer:
 
         logger.info(
             "Imported %d/%d memories from %s (bundle %s)",
-            imported, bundle.memory_count, bundle.sharer, bundle.bundle_id,
+            imported,
+            bundle.memory_count,
+            bundle.sharer,
+            bundle.bundle_id,
         )
         return {"imported": imported, "skipped": skipped, "errors": errors}