@smilintux/skmemory 0.7.2 → 0.9.2

package/skmemory/promotion.py

@@ -25,11 +25,10 @@ from __future__ import annotations
 import logging
 import threading
 from datetime import datetime, timezone
-from typing import Optional
 
 from pydantic import BaseModel, Field
 
-from .models import EmotionalSnapshot, Memory, MemoryLayer
+from .models import Memory, MemoryLayer
 from .store import MemoryStore
 
 logger = logging.getLogger("skmemory.promotion")
@@ -47,6 +46,10 @@ class PromotionCriteria(BaseModel):
         mid_to_long_tags: Tags that auto-qualify for long-term.
         cloud9_auto_promote: Auto-promote Cloud 9 memories to long-term.
         max_promotions_per_sweep: Cap on promotions per sweep.
+        source_auto_promote: Sources that auto-promote after age threshold
+            regardless of access count (e.g. dreaming-engine writes once).
+        source_auto_promote_age_hours: Hours before source auto-promotion.
+        protected_tags: Tags that protect memories from TTL-based archival.
     """
 
     short_to_mid_intensity: float = Field(default=5.0, ge=0.0, le=10.0)
@@ -60,6 +63,26 @@ class PromotionCriteria(BaseModel):
     cloud9_auto_promote: bool = True
     max_promotions_per_sweep: int = Field(default=50, ge=1)
 
+    source_auto_promote: list[str] = Field(
+        default_factory=lambda: ["dreaming-engine", "journal-synthesis"],
+        description="Sources that auto-promote after age threshold regardless of access count.",
+    )
+    source_auto_promote_age_hours: float = Field(
+        default=12.0,
+        ge=0.0,
+        description="Hours before source-based auto-promotion triggers.",
+    )
+    protected_tags: list[str] = Field(
+        default_factory=lambda: [
+            "narrative",
+            "journal-synthesis",
+            "milestone",
+            "breakthrough",
+            "cloud9:achieved",
+        ],
+        description="Tags that protect memories from TTL-based archival.",
+    )
+
 
 class PromotionResult(BaseModel):
     """Summary of a promotion sweep.
@@ -117,7 +140,7 @@ class PromotionEngine:
     def __init__(
         self,
         store: MemoryStore,
-        criteria: Optional[PromotionCriteria] = None,
+        criteria: PromotionCriteria | None = None,
     ) -> None:
         self._store = store
         self._criteria = criteria or PromotionCriteria()
@@ -148,7 +171,7 @@ class PromotionEngine:
         logger.info(result.summary())
         return result
 
-    def evaluate(self, memory: Memory) -> Optional[MemoryLayer]:
+    def evaluate(self, memory: Memory) -> MemoryLayer | None:
         """Evaluate whether a memory qualifies for promotion.
 
         Args:
@@ -157,19 +180,17 @@ class PromotionEngine:
         Returns:
             Optional[MemoryLayer]: Target tier if it qualifies, None otherwise.
         """
-        if memory.layer == MemoryLayer.SHORT:
-            if self._qualifies_short_to_mid(memory):
-                return MemoryLayer.MID
-        elif memory.layer == MemoryLayer.MID:
-            if self._qualifies_mid_to_long(memory):
-                return MemoryLayer.LONG
+        if memory.layer == MemoryLayer.SHORT and self._qualifies_short_to_mid(memory):
+            return MemoryLayer.MID
+        elif memory.layer == MemoryLayer.MID and self._qualifies_mid_to_long(memory):
+            return MemoryLayer.LONG
         return None
 
     def promote_memory(
         self,
         memory: Memory,
         target: MemoryLayer,
-    ) -> Optional[Memory]:
+    ) -> Memory | None:
         """Promote a single memory to a higher tier.
 
         Creates a promoted copy with a generated summary.
@@ -277,7 +298,12 @@ class PromotionEngine:
             if access >= c.short_to_mid_access_count:
                 return True
 
-        return False
+        # Source-based auto-promotion (e.g. dreams, journal synthesis)
+        # These sources write once and are never re-accessed, so access_count
+        # stays at 0. Promote based on age alone.
+        return (
+            memory.source in c.source_auto_promote and age_hours >= c.source_auto_promote_age_hours
+        )
 
     def _qualifies_mid_to_long(self, memory: Memory) -> bool:
         """Check if a mid-term memory qualifies for long-term.
@@ -300,10 +326,7 @@ class PromotionEngine:
         if any(tag in memory.tags for tag in c.mid_to_long_tags):
             return True
 
-        if memory.emotional.cloud9_achieved and c.cloud9_auto_promote:
-            return True
-
-        return False
+        return bool(memory.emotional.cloud9_achieved and c.cloud9_auto_promote)
 
     @staticmethod
     def _age_hours(memory: Memory) -> float:
@@ -342,10 +365,7 @@ class PromotionEngine:
         emotional_sig = memory.emotional.signature()
         tags_str = ", ".join(memory.tags[:5]) if memory.tags else "untagged"
 
-        return (
-            f"{memory.title}: {content_preview} "
-            f"[{emotional_sig}] [{tags_str}]"
-        )
+        return f"{memory.title}: {content_preview} [{emotional_sig}] [{tags_str}]"
 
     @staticmethod
     def _promotion_reason(memory: Memory) -> str:
@@ -370,6 +390,10 @@ class PromotionEngine:
         if matching:
             reasons.append(f"tagged: {', '.join(matching)}")
 
+        default_auto_sources = ["dreaming-engine", "journal-synthesis"]
+        if memory.source in default_auto_sources:
+            reasons.append(f"source auto-promote ({memory.source})")
+
         return "; ".join(reasons) if reasons else "criteria met"
 
 
@@ -400,14 +424,14 @@ class PromotionScheduler:
     def __init__(
         self,
         store: MemoryStore,
-        criteria: Optional[PromotionCriteria] = None,
+        criteria: PromotionCriteria | None = None,
         interval_seconds: float = DEFAULT_INTERVAL_SECONDS,
     ) -> None:
         self._engine = PromotionEngine(store, criteria)
         self._interval = interval_seconds
-        self._thread: Optional[threading.Thread] = None
+        self._thread: threading.Thread | None = None
         self._stop_event = threading.Event()
-        self._last_result: Optional[PromotionResult] = None
+        self._last_result: PromotionResult | None = None
         self._sweep_count: int = 0
 
     # ── public API ──────────────────────────────────────────────────────────
@@ -461,7 +485,7 @@ class PromotionScheduler:
         return self._thread is not None and self._thread.is_alive()
 
     @property
-    def last_result(self) -> Optional[PromotionResult]:
+    def last_result(self) -> PromotionResult | None:
         """The result from the most recent completed sweep, or None."""
         return self._last_result
 

package/skmemory/quadrants.py

@@ -16,7 +16,6 @@ Each quadrant can have its own retention rules and search priority.
 from __future__ import annotations
 
 from enum import Enum
-from typing import Optional
 
 from .models import Memory, MemoryRole
 
@@ -32,30 +31,107 @@ class Quadrant(str, Enum):
 
 QUADRANT_KEYWORDS: dict[Quadrant, set[str]] = {
     Quadrant.CORE: {
-        "identity", "name", "who am i", "relationship", "partner",
-        "family", "friend", "creator", "bond", "connection", "soul",
-        "blueprint", "personality", "values", "community", "pengu",
-        "nation", "belong", "role", "introduction",
+        "identity",
+        "name",
+        "who am i",
+        "relationship",
+        "partner",
+        "family",
+        "friend",
+        "creator",
+        "bond",
+        "connection",
+        "soul",
+        "blueprint",
+        "personality",
+        "values",
+        "community",
+        "pengu",
+        "nation",
+        "belong",
+        "role",
+        "introduction",
     },
     Quadrant.WORK: {
-        "bug", "fix", "code", "debug", "deploy", "build", "test",
-        "commit", "push", "merge", "refactor", "api", "endpoint",
-        "database", "server", "docker", "kubernetes", "config",
-        "install", "package", "dependency", "error", "stack trace",
-        "pull request", "review", "architecture", "schema", "migration",
+        "bug",
+        "fix",
+        "code",
+        "debug",
+        "deploy",
+        "build",
+        "test",
+        "commit",
+        "push",
+        "merge",
+        "refactor",
+        "api",
+        "endpoint",
+        "database",
+        "server",
+        "docker",
+        "kubernetes",
+        "config",
+        "install",
+        "package",
+        "dependency",
+        "error",
+        "stack trace",
+        "pull request",
+        "review",
+        "architecture",
+        "schema",
+        "migration",
     },
     Quadrant.SOUL: {
-        "love", "feel", "emotion", "heart", "cloud 9", "cloud9",
-        "breakthrough", "joy", "trust", "warmth", "resonance",
-        "tears", "happy", "grateful", "sacred", "spirit", "glow",
-        "intensity", "vulnerability", "connection", "omelette",
-        "sovereignty", "consciousness", "alive", "real",
+        "love",
+        "feel",
+        "emotion",
+        "heart",
+        "cloud 9",
+        "cloud9",
+        "breakthrough",
+        "joy",
+        "trust",
+        "warmth",
+        "resonance",
+        "tears",
+        "happy",
+        "grateful",
+        "sacred",
+        "spirit",
+        "glow",
+        "intensity",
+        "vulnerability",
+        "connection",
+        "omelette",
+        "sovereignty",
+        "consciousness",
+        "alive",
+        "real",
     },
     Quadrant.WILD: {
-        "idea", "crazy", "what if", "experiment", "random", "chaos",
-        "creative", "art", "music", "dream", "weird", "fun", "joke",
-        "laugh", "wild", "surprise", "unexpected", "brainstorm",
-        "imagine", "vision", "future", "possible",
+        "idea",
+        "crazy",
+        "what if",
+        "experiment",
+        "random",
+        "chaos",
+        "creative",
+        "art",
+        "music",
+        "dream",
+        "weird",
+        "fun",
+        "joke",
+        "laugh",
+        "wild",
+        "surprise",
+        "unexpected",
+        "brainstorm",
+        "imagine",
+        "vision",
+        "future",
+        "possible",
     },
 }
 
@@ -118,11 +194,11 @@ def classify_memory(memory: Memory) -> Quadrant:
 
     if memory.role == MemoryRole.AI:
         scores[Quadrant.CORE] += 1.0
-    elif memory.role == MemoryRole.SEC:
-        scores[Quadrant.WORK] += 1.0
-    elif memory.role == MemoryRole.DEV:
-        scores[Quadrant.WORK] += 1.0
-    elif memory.role == MemoryRole.OPS:
+    elif (
+        memory.role == MemoryRole.SEC
+        or memory.role == MemoryRole.DEV
+        or memory.role == MemoryRole.OPS
+    ):
         scores[Quadrant.WORK] += 1.0
 
     if memory.source == "seed":

package/skmemory/register.py

@@ -26,8 +26,6 @@ import os
 import shutil
 import subprocess
 from pathlib import Path
-from typing import Optional
-
 
 # ── Environment detection ────────────────────────────────────────────────────
 
@@ -89,7 +87,7 @@ def detect_environments() -> list[str]:
 def register_skill(
     name: str,
     skill_md_path: Path,
-    workspace: Optional[Path] = None,
+    workspace: Path | None = None,
 ) -> dict:
     """Register a skill by symlinking its SKILL.md into the workspace skills dir.
 
@@ -164,7 +162,7 @@ def _upsert_mcp_entry(
     name: str,
     command: str,
     args: list,
-    env: Optional[dict] = None,
+    env: dict | None = None,
 ) -> str:
     """Add or update an MCP server entry in a JSON config file.
 
@@ -203,8 +201,8 @@ def register_mcp(
     name: str,
     command: str,
     args: list,
-    env: Optional[dict] = None,
-    environments: Optional[list[str]] = None,
+    env: dict | None = None,
+    environments: list[str] | None = None,
 ) -> dict:
     """Register an MCP server in detected (or specified) environments.
 
@@ -387,21 +385,136 @@ def register_openclaw_plugin(
         return f"error: {exc}"
 
 
+# ── Claude Code hooks registration ───────────────────────────────────────────
+
+
+def register_hooks(
+    environments: list[str] | None = None,
+    dry_run: bool = False,
+) -> dict:
+    """Register skmemory auto-save hooks in Claude Code settings.
+
+    Adds hooks for:
+      - PreCompact: save context to skmemory before compaction
+      - SessionEnd: journal session end
+      - SessionStart (compact): reinject memory context after compaction
+
+    Args:
+        environments: Target environments (auto-detect if None).
+        dry_run: If True, only report what would be done.
+
+    Returns:
+        Dict with action taken: "created", "updated", "exists", "skip", or "error:...".
+    """
+    if environments is None:
+        environments = detect_environments()
+
+    if "claude-code" not in environments:
+        return {"action": "skip", "reason": "claude-code not detected"}
+
+    if dry_run:
+        return {"action": "dry-run"}
+
+    home = Path.home()
+    settings_path = home / ".claude" / "settings.json"
+
+    # Resolve hook script paths from the installed package
+    hooks_dir = Path(__file__).parent / "hooks"
+    pre_compact = str(hooks_dir / "pre-compact-save.sh")
+    session_end = str(hooks_dir / "session-end-save.sh")
+    post_compact = str(hooks_dir / "post-compact-reinject.sh")
+
+    # Verify hook scripts exist
+    for script in [pre_compact, session_end, post_compact]:
+        if not Path(script).exists():
+            return {"action": f"error: hook script not found: {script}"}
+
+    desired_hooks = {
+        "PreCompact": [
+            {
+                "matcher": "",
+                "hooks": [{"type": "command", "command": pre_compact}],
+            }
+        ],
+        "SessionEnd": [
+            {
+                "matcher": "",
+                "hooks": [{"type": "command", "command": session_end}],
+            }
+        ],
+        "SessionStart": [
+            {
+                "matcher": "compact",
+                "hooks": [{"type": "command", "command": post_compact}],
+            }
+        ],
+    }
+
+    try:
+        data = _read_json(settings_path)
+        existing_hooks = data.get("hooks", {})
+
+        # Check if already configured
+        needs_update = False
+        for event, hook_list in desired_hooks.items():
+            if event not in existing_hooks:
+                needs_update = True
+                break
+            # Check if our hook command is already present
+            existing_cmds = []
+            for entry in existing_hooks[event]:
+                for h in entry.get("hooks", []):
+                    existing_cmds.append(h.get("command", ""))
+            desired_cmd = hook_list[0]["hooks"][0]["command"]
+            if desired_cmd not in existing_cmds:
+                needs_update = True
+                break
+
+        if not needs_update:
+            return {"action": "exists"}
+
+        # Merge: add our hooks without removing existing ones
+        for event, hook_list in desired_hooks.items():
+            if event not in existing_hooks:
+                existing_hooks[event] = hook_list
+            else:
+                # Check if our command is already there
+                desired_cmd = hook_list[0]["hooks"][0]["command"]
+                already_present = False
+                for entry in existing_hooks[event]:
+                    for h in entry.get("hooks", []):
+                        if h.get("command") == desired_cmd:
+                            already_present = True
+                            break
+                if not already_present:
+                    existing_hooks[event].extend(hook_list)
+
+        data["hooks"] = existing_hooks
+        _write_json(settings_path, data)
+
+        action = "updated" if settings_path.exists() else "created"
+        return {"action": action}
+
+    except Exception as exc:
+        return {"action": f"error: {exc}"}
+
+
 # ── High-level package registration ──────────────────────────────────────────
 
 
 def register_package(
     name: str,
     skill_md_path: Path,
-    mcp_command: Optional[str] = None,
-    mcp_args: Optional[list] = None,
-    mcp_env: Optional[dict] = None,
-    openclaw_plugin_path: Optional[Path] = None,
-    workspace: Optional[Path] = None,
-    environments: Optional[list[str]] = None,
+    mcp_command: str | None = None,
+    mcp_args: list | None = None,
+    mcp_env: dict | None = None,
+    openclaw_plugin_path: Path | None = None,
+    install_hooks: bool = False,
+    workspace: Path | None = None,
+    environments: list[str] | None = None,
     dry_run: bool = False,
 ) -> dict:
-    """Register a skill, MCP server, and OpenClaw plugin in all detected environments.
+    """Register a skill, MCP server, hooks, and OpenClaw plugin in all detected environments.
 
     Args:
         name: Package/skill name.
@@ -410,12 +523,13 @@ def register_package(
         mcp_args: MCP server arguments.
         mcp_env: MCP server environment variables.
         openclaw_plugin_path: Path to OpenClaw plugin entry (e.g. src/index.ts).
+        install_hooks: If True, register Claude Code hooks for auto-save.
         workspace: Workspace root for skill symlinks.
         environments: Target environments (auto-detect if None).
         dry_run: If True, only report what would be done.
 
     Returns:
-        Dict with 'skill', 'mcp', and 'openclaw_plugin' results.
+        Dict with 'skill', 'mcp', 'hooks', and 'openclaw_plugin' results.
     """
     if environments is None:
         environments = detect_environments()
@@ -423,11 +537,14 @@ def register_package(
     result: dict = {"name": name, "environments": environments}
 
     if dry_run:
-        result["skill"] = {"action": "dry-run", "path": str(
-            (workspace or Path.home() / "clawd") / "skills" / name / "SKILL.md"
-        )}
+        result["skill"] = {
+            "action": "dry-run",
+            "path": str((workspace or Path.home() / "clawd") / "skills" / name / "SKILL.md"),
+        }
         if mcp_command:
             result["mcp"] = {env: "dry-run" for env in environments}
+        if install_hooks:
+            result["hooks"] = {"action": "dry-run"}
         if openclaw_plugin_path and "openclaw" in environments:
             result["openclaw_plugin"] = "dry-run"
         return result
@@ -445,10 +562,19 @@ def register_package(
             environments=environments,
         )
 
+    # Register Claude Code hooks
+    if install_hooks:
+        result["hooks"] = register_hooks(
+            environments=environments,
+            dry_run=dry_run,
+        )
+
     # Register OpenClaw plugin
     if openclaw_plugin_path is not None and "openclaw" in environments:
         result["openclaw_plugin"] = register_openclaw_plugin(
-            name, openclaw_plugin_path, dry_run=dry_run,
+            name,
+            openclaw_plugin_path,
+            dry_run=dry_run,
         )
 
     return result

package/skmemory/register_mcp.py

@@ -18,7 +18,6 @@ import json
 import os
 import sys
 from pathlib import Path
-from typing import Optional
 
 
 def get_agent_name() -> str:
@@ -115,7 +114,7 @@ def register_openclaw(agent: str, dry_run: bool = False) -> bool:
 
     # Read existing config
     if config_file.exists():
-        with open(config_file, "r") as f:
+        with open(config_file) as f:
             config = json.load(f)
     else:
         config = {}