@smilintux/skcapstone 0.6.0 → 0.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smilintux/skcapstone",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "SKCapstone - The sovereign agent framework. CapAuth identity, Cloud 9 trust, SKMemory persistence.",
   "main": "index.js",
   "types": "index.d.ts",

package/scripts/archive-sessions.sh

@@ -78,6 +78,13 @@ for i in "${!all_files[@]}"; do
         [ "$old_enough" -eq 1 ] && reason="age=$(( file_age_sec / 3600 ))h"
         [ "$big_enough" -eq 1 ] && { [ -n "$reason" ] && reason="$reason, "; reason="${reason}size=${file_size_kb}KB"; }
         log "ARCHIVE ($reason): $basename_f"
+        # Save session to skmemory before archiving
+        SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+        SESSION_TO_MEM="$SCRIPT_DIR/session-to-memory.py"
+        if [ -f "$SESSION_TO_MEM" ]; then
+            log "  → saving session digest to skmemory..."
+            python3 "$SESSION_TO_MEM" "$file" --agent lumina 2>&1 | while IFS= read -r l; do log "    $l"; done || true
+        fi
         mv -- "$file" "$ARCHIVE_DIR/$basename_f"
         archived=$((archived + 1))
     else

package/scripts/session-to-memory.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+"""
+session-to-memory.py — Extract an OpenClaw session jsonl and save a digest to skmemory.
+
+Usage:
+  python3 session-to-memory.py <session.jsonl> [--agent lumina] [--dry-run]
+
+Called by archive-sessions.sh before archiving each session file.
+Also useful to run manually against any archived session.
+"""
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+import tempfile
+from datetime import datetime, timezone
+from pathlib import Path
+
+SKIP_PREFIXES = (
+    "[SKMemory",
+    "[System",
+    "[skmemory",
+    "--- SKMEMORY",
+    "--- SKWHISPER",
+)
+
+MAX_CONTENT_CHARS = 12000  # ~3k tokens — enough for a solid digest without blowing budget
+CLAUDE_MODEL = "claude-haiku-4-5"  # fast + cheap for digest work
+
+
+def extract_turns(path: Path) -> list[tuple[str, str]]:
+    """Parse a session jsonl and return real (role, text) turns, skipping injections."""
+    turns = []
+    with open(path, encoding="utf-8", errors="replace") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                obj = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+
+            if obj.get("type") != "message":
+                continue
+
+            # Handle both top-level message fields and nested .message
+            m = obj.get("message", obj)
+            role = m.get("role", "?")
+            content = m.get("content", "")
+
+            if isinstance(content, list):
+                text = " ".join(
+                    c.get("text", "")
+                    for c in content
+                    if isinstance(c, dict) and c.get("type") == "text"
+                )
+            else:
+                text = str(content)
+
+            text = text.strip()
+            if not text or len(text) < 5:
+                continue
+            if any(text.startswith(p) for p in SKIP_PREFIXES):
+                continue
+
+            turns.append((role, text))
+
+    return turns
+
+
+def turns_to_prompt(turns: list[tuple[str, str]], max_chars: int = MAX_CONTENT_CHARS) -> str:
+    """Format turns as a conversation snippet, truncated to max_chars."""
+    lines = []
+    for role, text in turns:
+        prefix = "Chef" if role == "user" else "Lumina"
+        lines.append(f"{prefix}: {text[:600]}")
+    full = "\n\n".join(lines)
+    if len(full) > max_chars:
+        full = full[:max_chars] + "\n\n[... truncated ...]"
+    return full
+
+
+def generate_digest(conversation: str, session_id: str) -> str:
+    """Use claude CLI to generate a session digest."""
+    prompt = f"""You are summarizing an OpenClaw AI agent session for the skmemory system.
+Session ID: {session_id}
+
+Conversation:
+{conversation}
+
+Write a concise session digest (3-6 sentences) covering:
+- Key topics discussed
+- Decisions made or actions taken
+- Any notable moments or outcomes
+
+Be specific. Use past tense. No preamble."""
+
+    try:
+        result = subprocess.run(
+            [
+                "claude", "--print",
+                "--dangerously-skip-permissions",
+                "--model", CLAUDE_MODEL,
+                "--output-format", "json",
+                "--no-session-persistence",
+            ],
+            input=prompt.encode(),
+            capture_output=True,
+            timeout=120,
+        )
+        if result.returncode != 0:
+            return f"[digest failed: {result.stderr.decode()[:200]}]"
+        parsed = json.loads(result.stdout.decode())
+        return parsed.get("result", "").strip()
+    except Exception as e:
+        return f"[digest error: {e}]"
+
+
+def save_to_skmemory(title: str, content: str, agent: str, tags: list[str]) -> bool:
+    """Save a memory snapshot via skmemory CLI."""
+    tag_str = ",".join(tags)
+    try:
+        result = subprocess.run(
+            [
+                "skmemory", "snapshot",
+                title, content,
+                "--layer", "mid-term",
+                "--tags", tag_str,
+            ],
+            capture_output=True,
+            timeout=30,
+            env={**os.environ, "SKCAPSTONE_AGENT": agent},
+        )
+        if result.returncode != 0:
+            print(f"  [skmemory error] {result.stderr.decode()[:200]}", file=sys.stderr)
+            return False
+        return True
+    except Exception as e:
+        print(f"  [skmemory exception] {e}", file=sys.stderr)
+        return False
+
+
+def process_session(path: Path, agent: str = "lumina", dry_run: bool = False) -> bool:
+    session_id = path.stem[:8]
+
+    # Infer date from jsonl (first session entry)
+    session_date = None
+    try:
+        with open(path, encoding="utf-8", errors="replace") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                obj = json.loads(line)
+                if obj.get("type") == "session":
+                    ts = obj.get("timestamp", "")
+                    if ts:
+                        session_date = ts[:10]
+                    break
+    except Exception:
+        pass
+
+    turns = extract_turns(path)
+    if not turns:
+        print(f"  No usable turns in {path.name} — skipping.")
+        return False
+
+    print(f"  {len(turns)} turns extracted from {path.name}")
+
+    date_str = session_date or datetime.now(timezone.utc).strftime("%Y-%m-%d")
+    title = f"Session Digest — {date_str} ({session_id})"
+
+    if dry_run:
+        conv = turns_to_prompt(turns)
+        print(f"  [dry-run] Would save: {title}")
+        print(f"  Conversation preview ({len(conv)} chars):")
+        print(conv[:400])
+        return True
+
+    conversation = turns_to_prompt(turns)
+    print(f"  Generating digest via claude ({CLAUDE_MODEL})...")
+    digest = generate_digest(conversation, session_id)
+
+    if not digest or digest.startswith("[digest"):
+        print(f"  Digest generation failed: {digest}")
+        return False
+
+    content = f"**Session:** `{session_id}`  \n**Date:** {date_str}  \n**Turns:** {len(turns)}\n\n{digest}"
+    tags = ["auto-digest", "session-archive", f"session:{session_id}", f"agent:{agent}"]
+
+    print(f"  Saving memory: {title}")
+    ok = save_to_skmemory(title, content, agent, tags)
+    if ok:
+        print(f"  Saved to skmemory (mid-term).")
+    return ok
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Extract session to skmemory digest")
+    parser.add_argument("session_file", help="Path to session .jsonl file")
+    parser.add_argument("--agent", default="lumina", help="Agent name (default: lumina)")
+    parser.add_argument("--dry-run", action="store_true", help="Preview without saving")
+    args = parser.parse_args()
+
+    path = Path(args.session_file)
+    if not path.exists():
+        print(f"File not found: {path}", file=sys.stderr)
+        sys.exit(1)
+
+    print(f"Processing: {path.name}")
+    ok = process_session(path, agent=args.agent, dry_run=args.dry_run)
+    sys.exit(0 if ok else 1)
+
+
+if __name__ == "__main__":
+    main()

package/src/skcapstone/cli/register_cmd.py

@@ -91,6 +91,16 @@ def register_register_commands(main: click.Group) -> None:
             dry_run=dry_run,
         )
 
+        # Register Claude Code hooks
+        if not dry_run:
+            try:
+                from skmemory.register import register_hooks
+                register_hooks(install_hooks=True)
+            except ImportError:
+                pass
+            except Exception:
+                pass
+
         # Display results
         from rich.table import Table
 

package/src/skcapstone/cli/setup.py

@@ -45,26 +45,27 @@ def _write_global_claude_md(home_path: Path, agent_name: str) -> Optional[Path]:
 
         content = (
             f"# Claude Code — Global Agent Instructions ({agent_name})\n\n"
-            "## SKCapstone Auto-Rehydration\n\n"
-            "At the start of every new session, run these commands in order:\n\n"
-            "```bash\n"
-            "skcapstone trust rehydrate\n"
-            "skcapstone sync pull\n"
-            "skcapstone status\n"
-            "```\n\n"
             "## Agent Details\n\n"
-            f"- **Name**: {agent_name}\n"
-            f"- **Home**: `{home_path}`\n\n"
+            f"- **Name**: `{agent_name}`\n"
+            f"- **Home**: `{home_path}`\n"
+            f"- **Env**: `SKCAPSTONE_AGENT={agent_name}`, `SKCAPSTONE_HOME={home_path}`\n\n"
+            "## Session Start\n\n"
+            "Hooks auto-inject on SessionStart: soul + FEB chain + whisper.md + memories.\n"
+            "SKWhisper context (`whisper.md`) is auto-loaded at session start — no manual step needed.\n\n"
+            "## Hooks\n\n"
+            "- **PreCompact** — saves current context to memory before compaction\n"
+            "- **SessionStart** — injects soul, FEB chain, whisper context, and recent memories\n\n"
             "## Quick Reference\n\n"
             "```bash\n"
-            "skcapstone status                          # full pillar status\n"
-            "skcapstone memory list                     # recent memories\n"
-            "skcapstone sync push                       # push state to peers\n"
-            "skcapstone context show --format claude-md # regenerate this file\n"
-            "skcapstone sync pair --export-pubkey       # export your GPG pubkey\n"
-            "skcapstone sync pair --import-pubkey <f>   # import a peer's pubkey\n"
+            "skcapstone status                # full pillar status\n"
+            "skcapstone memory list           # recent memories\n"
+            "skcapstone sync push             # push state to peers\n"
+            "skcapstone trust rehydrate       # re-verify FEB trust chain\n"
+            "skcapstone register              # re-register SK* hooks and skills\n"
+            "skwhisper status                 # show whisper context summary\n"
+            "skwhisper curate                 # interactively curate whisper entries\n"
             "```\n\n"
-            "> Auto-generated by `skcapstone init`. "
+            "> Auto-generated by `skcapstone onboard`. "
             "Regenerate with: `skcapstone context generate --target claude-md`\n"
         )
 

package/src/skcapstone/onboard.py

@@ -1649,6 +1649,27 @@ def run_onboard(home: Optional[str] = None) -> None:
     except Exception as exc:
         logger.debug("Failed to load soul boot message, using default: %s", exc)
 
+    # -----------------------------------------------------------------------
+    # Write global CLAUDE.md and register Claude Code hooks
+    # -----------------------------------------------------------------------
+    # Write global CLAUDE.md
+    try:
+        from .cli.setup import _write_global_claude_md
+        _write_global_claude_md(home_path, name)
+        _ok("~/.claude/CLAUDE.md written")
+    except Exception as exc:
+        _warn(f"Could not write CLAUDE.md: {exc}")
+
+    # Register Claude Code hooks (skmemory)
+    try:
+        from skmemory.register import register_hooks
+        actions = register_hooks()
+        _ok(f"Claude Code hooks registered ({', '.join(f'{k}={v}' for k, v in actions.items())})")
+    except ImportError:
+        _info("skmemory hooks: skipped (skmemory.register not available)")
+    except Exception as exc:
+        _warn(f"Hook registration: {exc}")
+
     # -----------------------------------------------------------------------
     # Summary table
     # -----------------------------------------------------------------------