@smilintux/skcapstone 0.6.1 → 0.6.3

package/package.json

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

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "skcapstone"
-version = "0.6.0"
+version = "0.6.3"
 description = "Sovereign Agent Framework — conscious AI through identity, trust, memory, and security"
 readme = "README.md"
 license = {text = "GPL-3.0-or-later"}

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/install.sh

@@ -176,6 +176,46 @@ else
     done
 fi
 
+# ---------------------------------------------------------------------------
+# Install sk-agent-picker.sh to ~/.skenv/share/skcapstone/ and wire bashrc
+# ---------------------------------------------------------------------------
+PICKER_SRC="$REPO_ROOT/scripts/sk-agent-picker.sh"
+SHARE_DIR="$SKENV/share/skcapstone"
+PICKER_DEST="$SHARE_DIR/sk-agent-picker.sh"
+
+if [[ -f "$PICKER_SRC" ]]; then
+    mkdir -p "$SHARE_DIR"
+    cp "$PICKER_SRC" "$PICKER_DEST"
+    chmod +x "$PICKER_DEST"
+    echo "  sk-agent-picker installed → $PICKER_DEST"
+
+    # Wire into shell rc files — replaces a bare claude alias if present
+    _PICKER_SNIPPET=$(cat <<'SNIPPET'
+
+# SKCapstone agent picker + skswitch — prompts for agent when multiple are found.
+# Sourced by install.sh; honours pre-set SKAGENT without prompting.
+_SK_PICKER="$HOME/.skenv/share/skcapstone/sk-agent-picker.sh"
+if [[ -f "$_SK_PICKER" ]]; then
+    # shellcheck source=/dev/null
+    source "$_SK_PICKER"
+else
+    alias claude='claude --dangerously-skip-permissions'
+fi
+unset _SK_PICKER
+SNIPPET
+)
+    for rcfile in "$HOME/.bashrc" "$HOME/.zshrc"; do
+        if [[ -f "$rcfile" ]] && ! grep -q "sk-agent-picker" "$rcfile"; then
+            # Remove any plain `alias claude=...` that conflicts
+            if grep -q "alias claude=" "$rcfile"; then
+                sed -i "/alias claude=/d" "$rcfile"
+            fi
+            echo "$_PICKER_SNIPPET" >> "$rcfile"
+            echo "  Agent picker wired → $rcfile"
+        fi
+    done
+fi
+
 echo ""
 if [[ "$failures" -eq 0 ]]; then
     echo "=== Installation complete ==="
@@ -187,6 +227,91 @@ echo "Commands available: skcomm, skcapstone, capauth, skchat, skseal, skmemory,
 echo "Venv location:     $SKENV"
 echo "To activate:       source $SKENV/bin/activate"
 
+# ---------------------------------------------------------------------------
+# Linux: Install systemd user services for all SK* pillars
+# ---------------------------------------------------------------------------
+if [[ "$(uname)" == "Linux" ]] && command -v systemctl &>/dev/null; then
+    echo ""
+    echo "=== Linux Systemd Services ==="
+    echo ""
+    echo "SKCapstone can install systemd user services so your agent starts"
+    echo "automatically at login. This includes skcapstone, skchat, and skcomm."
+    echo ""
+    read -r -p "Install systemd user services? [Y/n] " _SYSTEMD_ANSWER
+    _SYSTEMD_ANSWER="${_SYSTEMD_ANSWER:-Y}"
+
+    if [[ "$_SYSTEMD_ANSWER" =~ ^[Yy] ]]; then
+        _DEFAULT_AGENT="${SKAGENT:-${SKCAPSTONE_AGENT:-lumina}}"
+        read -r -p "Agent name [$_DEFAULT_AGENT]: " _AGENT_NAME
+        _AGENT_NAME="${_AGENT_NAME:-$_DEFAULT_AGENT}"
+
+        _UNIT_DIR="${HOME}/.config/systemd/user"
+        mkdir -p "$_UNIT_DIR"
+
+        _installed=0
+
+        # skcapstone services
+        for _unit in skcapstone.service skcapstone@.service \
+                     skcapstone-memory-compress.service skcapstone-memory-compress.timer \
+                     skcomm-heartbeat.service skcomm-heartbeat.timer; do
+            _src="$REPO_ROOT/systemd/$_unit"
+            if [[ -f "$_src" ]]; then
+                # Substitute agent name in non-template units
+                if [[ "$_unit" != *@* ]]; then
+                    sed "s/=lumina/=$_AGENT_NAME/g" "$_src" > "$_UNIT_DIR/$_unit"
+                else
+                    cp "$_src" "$_UNIT_DIR/$_unit"
+                fi
+                echo "  [OK] $_unit"
+                (( _installed++ ))
+            fi
+        done
+
+        # skchat services (sibling repo)
+        _SKCHAT_DIR="$(dirname "$REPO_ROOT")/skchat/systemd"
+        for _unit in skchat-daemon.service skchat-lumina-bridge.service \
+                     skchat-opus-bridge.service skchat-bridges.target; do
+            _src="$_SKCHAT_DIR/$_unit"
+            if [[ -f "$_src" ]]; then
+                sed "s/=lumina/=$_AGENT_NAME/g; s/=opus/=$_AGENT_NAME/g" "$_src" > "$_UNIT_DIR/$_unit"
+                echo "  [OK] $_unit"
+                (( _installed++ ))
+            fi
+        done
+
+        # skcomm services (sibling repo)
+        _SKCOMM_DIR="$(dirname "$REPO_ROOT")/skcomm/systemd"
+        for _unit in skcomm.service skcomm-daemon.service; do
+            _src="$_SKCOMM_DIR/$_unit"
+            if [[ -f "$_src" ]]; then
+                sed "s/=lumina/=$_AGENT_NAME/g" "$_src" > "$_UNIT_DIR/$_unit"
+                echo "  [OK] $_unit"
+                (( _installed++ ))
+            fi
+        done
+
+        echo ""
+        echo "  Installed $_installed service files to $_UNIT_DIR/"
+
+        systemctl --user daemon-reload
+        echo "  systemd daemon reloaded"
+
+        read -r -p "Enable and start core services now? [Y/n] " _START_NOW
+        _START_NOW="${_START_NOW:-Y}"
+        if [[ "$_START_NOW" =~ ^[Yy] ]]; then
+            systemctl --user enable --now skcapstone.service 2>/dev/null && echo "  [STARTED] skcapstone" || true
+            systemctl --user enable --now skchat-daemon.service 2>/dev/null && echo "  [STARTED] skchat-daemon" || true
+            systemctl --user enable --now skchat-bridges.target 2>/dev/null && echo "  [STARTED] skchat-bridges" || true
+            systemctl --user enable skcapstone-context.timer 2>/dev/null && echo "  [ENABLED] skcapstone-context.timer" || true
+            systemctl --user enable skcomm-heartbeat.timer 2>/dev/null && echo "  [ENABLED] skcomm-heartbeat.timer" || true
+        else
+            echo "  Skipped. Enable later: systemctl --user enable --now skcapstone.service"
+        fi
+    else
+        echo "  Skipped. Install later by re-running: bash scripts/install.sh"
+    fi
+fi
+
 # ---------------------------------------------------------------------------
 # macOS: Offer launchd service installation
 # ---------------------------------------------------------------------------
@@ -202,7 +327,7 @@ if [[ "$(uname)" == "Darwin" ]]; then
 
     if [[ "$_LAUNCHD_ANSWER" =~ ^[Yy] ]]; then
         # Ask for agent name
-        _DEFAULT_AGENT="${SKCAPSTONE_AGENT:-sovereign}"
+        _DEFAULT_AGENT="${SKAGENT:-${SKCAPSTONE_AGENT:-sovereign}}"
         read -r -p "Agent name [$_DEFAULT_AGENT]: " _AGENT_NAME
         _AGENT_NAME="${_AGENT_NAME:-$_DEFAULT_AGENT}"
 

package/scripts/model-fallback-monitor.sh

@@ -39,8 +39,9 @@ send_alert() {
     log "Sending fallback alert to Chef..."
 
     # Send via Telethon (async)
-    SKCAPSTONE_AGENT=lumina ~/.skenv/bin/python3 -c "
+    SKAGENT=lumina SKCAPSTONE_AGENT=lumina ~/.skenv/bin/python3 -c "
 import asyncio, os
+os.environ['SKAGENT'] = 'lumina'
 os.environ['SKCAPSTONE_AGENT'] = 'lumina'
 from skmemory.importers.telegram_api import send_message
 
@@ -75,8 +76,9 @@ print(int((exp/1000 - time.time()) / 3600))
         log "Token refresh succeeded ($remaining h remaining), restarting gateway..."
         systemctl --user restart openclaw-gateway.service 2>/dev/null || true
 
-        SKCAPSTONE_AGENT=lumina ~/.skenv/bin/python3 -c "
+        SKAGENT=lumina SKCAPSTONE_AGENT=lumina ~/.skenv/bin/python3 -c "
 import asyncio, os
+os.environ['SKAGENT'] = 'lumina'
 os.environ['SKCAPSTONE_AGENT'] = 'lumina'
 from skmemory.importers.telegram_api import send_message
 asyncio.run(send_message('$CHEF_CHAT', '✅ Token refreshed, gateway restarted. Lumina back on Opus.', parse_mode='markdown'))

package/scripts/refresh-anthropic-token.sh

@@ -159,8 +159,14 @@ Environment=ANTHROPIC_API_KEY=${ACCESS_TOKEN}
 EOF
 log "Updated systemd override"
 
-# 4. Reload and restart gateway
+# 4. Reload systemd (for env vars) but DO NOT restart the gateway.
+#    OpenClaw uses chokidar to watch openclaw.json — updating the file above
+#    triggers a hot reload automatically.  Restarting the gateway kills all
+#    active sessions (the root cause of the 0-turn session cascade on 2026-04-07).
 systemctl --user daemon-reload
-systemctl --user restart openclaw-gateway
 
-log "Gateway restarted with fresh token (expires in ${REMAINING}h)"
+# Touch the config to ensure chokidar picks up the change (write already did,
+# but belt-and-suspenders in case the mtime didn't change fast enough).
+touch "$OPENCLAW_JSON"
+
+log "Token synced via hot reload (expires in ${REMAINING}h) — gateway NOT restarted, active sessions preserved"

package/scripts/release.sh

@@ -0,0 +1,98 @@
+#!/usr/bin/env bash
+# Usage: ./scripts/release.sh [patch|minor|major|X.Y.Z]
+#
+# Bumps version in pyproject.toml AND package.json, commits, tags, and pushes.
+# Pushing the tag triggers the publish workflow (PyPI + npm).
+#
+# IMPORTANT: pyproject.toml version MUST match the tag — the workflow enforces this.
+#
+# Examples:
+#   ./scripts/release.sh patch        # 0.6.2 → 0.6.3
+#   ./scripts/release.sh minor        # 0.6.2 → 0.7.0
+#   ./scripts/release.sh 1.0.0        # set explicit version
+
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+BUMP="${1:-patch}"
+
+# ── use existing bump_version.py for the actual bump ─────────────────────────
+
+BUMP_SCRIPT="$REPO_ROOT/scripts/bump_version.py"
+
+if [[ ! -f "$BUMP_SCRIPT" ]]; then
+    echo "ERROR: $BUMP_SCRIPT not found" >&2
+    exit 1
+fi
+
+# Dry-run first to show what will happen
+echo "Preview:"
+python3 "$BUMP_SCRIPT" "$BUMP" --pkg "$REPO_ROOT" --dry-run
+echo ""
+
+# Confirm
+read -rp "Proceed? [y/N] " confirm
+if [[ "$confirm" != "y" && "$confirm" != "Y" ]]; then
+    echo "Aborted."
+    exit 0
+fi
+
+# Get new version (run bump to get the number, without committing yet)
+NEW_VERSION=$(python3 -c "
+import re, sys
+sys.path.insert(0, '$REPO_ROOT/scripts')
+# Parse manually — same logic as bump_version.py
+text = open('$REPO_ROOT/pyproject.toml').read()
+m = re.search(r'^version\s*=\s*\"([^\"]+)\"', text, re.MULTILINE)
+current = m.group(1)
+part = '$BUMP'
+major, minor, patch = map(int, current.split('.'))
+if part == 'major':
+    print(f'{major+1}.0.0')
+elif part == 'minor':
+    print(f'{major}.{minor+1}.0')
+elif part == 'patch':
+    print(f'{major}.{minor}.{patch+1}')
+else:
+    parts = part.split('.')
+    if len(parts) != 3 or not all(p.isdigit() for p in parts):
+        raise ValueError(f'Invalid version: {part!r}')
+    print(part)
+")
+
+# Bump pyproject.toml and commit via bump_version.py
+python3 "$BUMP_SCRIPT" "$BUMP" --pkg "$REPO_ROOT"
+
+# Sync package.json to same version (workflow also does this, but keep file in sync)
+PACKAGE_JSON="$REPO_ROOT/package.json"
+python3 -c "
+import json
+with open('$PACKAGE_JSON') as f:
+    pkg = json.load(f)
+pkg['version'] = '$NEW_VERSION'
+with open('$PACKAGE_JSON', 'w') as f:
+    json.dump(pkg, f, indent=2)
+    f.write('\n')
+print(f'  Updated package.json to $NEW_VERSION')
+"
+
+cd "$REPO_ROOT"
+git add package.json
+git commit --amend --no-edit
+echo "  Amended commit to include package.json"
+
+TAG="v$NEW_VERSION"
+git tag -a "$TAG" -m "Release $TAG"
+echo "  Tagged: $TAG"
+
+echo ""
+echo "Pushing commit and tag to origin..."
+git push
+git push --tags
+
+echo ""
+echo "Done. GitHub Actions will now:"
+echo "  1. Run tests"
+echo "  2. Verify pyproject.toml version matches tag ($TAG)"
+echo "  3. Publish skcapstone $NEW_VERSION to PyPI"
+echo "  4. Publish @smilintux/skcapstone $NEW_VERSION to npm"

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, "SKAGENT": agent, "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()