@smilintux/skcapstone 0.6.2 → 0.6.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smilintux/skcapstone",
-  "version": "0.6.2",
+  "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/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

@@ -132,7 +132,7 @@ def save_to_skmemory(title: str, content: str, agent: str, tags: list[str]) -> b
             ],
             capture_output=True,
             timeout=30,
-            env={**os.environ, "SKCAPSTONE_AGENT": agent},
+            env={**os.environ, "SKAGENT": agent, "SKCAPSTONE_AGENT": agent},
         )
         if result.returncode != 0:
             print(f"  [skmemory error] {result.stderr.decode()[:200]}", file=sys.stderr)

package/scripts/sk-agent-picker.sh

@@ -0,0 +1,237 @@
+#!/usr/bin/env bash
+# sk-agent-picker.sh — Sovereign agent picker for AI coding tools
+#
+# Source this file in ~/.bashrc or ~/.zshrc.  It wraps `claude`, `codex`
+# (OpenAI Codex CLI), and `opencode` with an agent-aware launcher that
+# shows a numbered menu when multiple SK agents are configured.
+#
+# Also provides `skswitch` — a fast way to change the active agent for
+# the current shell session (updates SKAGENT + legacy vars in one shot).
+#
+# Behaviour:
+#   - Zero agents found       → launch tool normally (no SK home yet)
+#   - Exactly one agent       → use it silently, no prompt
+#   - Multiple agents         → numbered menu, default highlighted with →
+#   - SKAGENT is set          → honour it, skip menu entirely
+#   - Pass --agent <name>     → skip menu, use that agent directly
+#   - Any other args          → forwarded to the underlying tool unchanged
+#
+# Usage:
+#   claude                        # picker if multiple agents
+#   claude --agent lumina         # direct launch
+#   SKAGENT=opus claude           # env override
+#   skswitch lumina               # change active agent for this shell
+#   skswitch                      # interactive picker
+#   codex                         # same picker logic
+#   opencode                      # same picker logic
+#
+# Source in shell config:
+#   source ~/.skenv/share/skcapstone/sk-agent-picker.sh
+# Dev install:
+#   source ~/clawd/skcapstone-repos/skcapstone/scripts/sk-agent-picker.sh
+
+# ---------------------------------------------------------------------------
+# Core picker — returns chosen agent name on stdout, menu on stderr
+# ---------------------------------------------------------------------------
+_sk_pick_agent() {
+    local agents_dir="${SKCAPSTONE_HOME:-$HOME/.skcapstone}/agents"
+    local -a agents=()
+
+    if [[ -d "$agents_dir" ]]; then
+        while IFS= read -r entry; do
+            local name
+            name=$(basename "$entry")
+            # Skip template dirs, dotfiles, and non-directory entries
+            if [[ -d "$entry" && "$name" != *-template && "$name" != .* && "$name" != *.* ]]; then
+                agents+=("$name")
+            fi
+        done < <(find "$agents_dir" -mindepth 1 -maxdepth 1 -type d | sort)
+    fi
+
+    local count="${#agents[@]}"
+
+    if [[ $count -eq 0 ]]; then
+        echo ""; return 0
+    fi
+
+    if [[ $count -eq 1 ]]; then
+        echo "${agents[0]}"; return 0
+    fi
+
+    # Validate SKAGENT against actual agent list.
+    # If it's set but not in the list (stale env), fall back to first agent.
+    local env_agent="${SKAGENT:-${SKCAPSTONE_AGENT:-}}"
+    local default="${agents[0]}"
+    for agent in "${agents[@]}"; do
+        if [[ "$agent" == "$env_agent" ]]; then
+            default="$agent"
+            break
+        fi
+    done
+
+    # Multi-agent menu
+    echo "" >&2
+    echo "  ╔══════════════════════════════════╗" >&2
+    echo "  ║   SKCapstone — Choose an Agent   ║" >&2
+    echo "  ╚══════════════════════════════════╝" >&2
+    echo "" >&2
+
+    local i=1
+    for agent in "${agents[@]}"; do
+        local marker="  "
+        if [[ "$agent" == "$default" ]]; then
+            marker="→ "
+        fi
+        printf "  %s%2d)  %s\n" "$marker" "$i" "$agent" >&2
+        (( i++ ))
+    done
+
+    echo "" >&2
+    printf "  Agent [1-%d, Enter = %s]: " "$count" "$default" >&2
+
+    local choice
+    read -r choice </dev/tty
+
+    # Empty → use default
+    if [[ -z "$choice" ]]; then
+        echo "$default"; return 0
+    fi
+
+    # Numeric
+    if [[ "$choice" =~ ^[0-9]+$ ]] && (( choice >= 1 && choice <= count )); then
+        echo "${agents[$((choice - 1))]}"; return 0
+    fi
+
+    # Name typed directly
+    for agent in "${agents[@]}"; do
+        if [[ "$agent" == "$choice" ]]; then
+            echo "$agent"; return 0
+        fi
+    done
+
+    # Invalid — use list-validated default (not stale env), re-show options
+    printf "\n  ⚠  Unknown agent '%s'. Valid agents:\n" "$choice" >&2
+    for agent in "${agents[@]}"; do
+        printf "       %s\n" "$agent" >&2
+    done
+    printf "  Using default: %s\n\n" "$default" >&2
+    echo "$default"
+}
+
+# ---------------------------------------------------------------------------
+# Generic launcher used by all wrappers
+# ---------------------------------------------------------------------------
+_sk_launch() {
+    local tool="$1"; shift         # the underlying binary (claude / codex / opencode)
+    local extra_flags="$1"; shift  # tool-specific flags always appended (pass "" if none)
+    # remaining args collected below after parsing --agent
+
+    # Parse --agent <name> / --agent=<name> out of args first.
+    # SK_NO_PICKER=1 skips the menu entirely (for scripted/CI use).
+    local agent=""
+    local -a passthrough=()
+    local skip_next=0
+
+    for arg in "$@"; do
+        if [[ $skip_next -eq 1 ]]; then
+            agent="$arg"; skip_next=0; continue
+        fi
+        case "$arg" in
+            --agent)        skip_next=1 ;;
+            --agent=*)      agent="${arg#--agent=}" ;;
+            *)              passthrough+=("$arg") ;;
+        esac
+    done
+
+    # --agent flag given → skip picker
+    # SK_NO_PICKER=1 → skip picker (scripted/CI use)
+    if [[ -z "$agent" && "${SK_NO_PICKER:-0}" != "1" ]]; then
+        agent=$(_sk_pick_agent)
+    fi
+
+    # Fallback: if picker returned empty (0 agents), just use SKAGENT
+    # or launch bare if that's also unset.
+    if [[ -z "$agent" ]]; then
+        agent="${SKAGENT:-${SKCAPSTONE_AGENT:-}}"
+    fi
+
+    if [[ -n "$agent" ]]; then
+        printf "  ▶ Starting %s as agent: %s\n\n" "$tool" "$agent" >&2
+        if [[ -n "$extra_flags" ]]; then
+            SKAGENT="$agent" SKCAPSTONE_AGENT="$agent" SKMEMORY_AGENT="$agent" command "$tool" $extra_flags "${passthrough[@]}"
+        else
+            SKAGENT="$agent" SKCAPSTONE_AGENT="$agent" SKMEMORY_AGENT="$agent" command "$tool" "${passthrough[@]}"
+        fi
+    else
+        if [[ -n "$extra_flags" ]]; then
+            command "$tool" $extra_flags "${passthrough[@]}"
+        else
+            command "$tool" "${passthrough[@]}"
+        fi
+    fi
+}
+
+# ---------------------------------------------------------------------------
+# skswitch — change the active agent for the current shell session
+# ---------------------------------------------------------------------------
+function skswitch {
+    local agent="$1"
+
+    if [[ -z "$agent" ]]; then
+        # No argument — show interactive picker
+        agent=$(_sk_pick_agent)
+        if [[ -z "$agent" ]]; then
+            echo "No agents found in ${SKCAPSTONE_HOME:-$HOME/.skcapstone}/agents/" >&2
+            return 1
+        fi
+    fi
+
+    # Validate agent directory exists
+    local agent_dir="${SKCAPSTONE_HOME:-$HOME/.skcapstone}/agents/$agent"
+    if [[ ! -d "$agent_dir" ]]; then
+        echo "Agent not found: $agent" >&2
+        echo "Available agents:" >&2
+        local agents_dir="${SKCAPSTONE_HOME:-$HOME/.skcapstone}/agents"
+        if [[ -d "$agents_dir" ]]; then
+            find "$agents_dir" -mindepth 1 -maxdepth 1 -type d ! -name '*-template' ! -name '.*' -printf '  %f\n' | sort >&2
+        fi
+        return 1
+    fi
+
+    export SKAGENT="$agent"
+    export SKCAPSTONE_AGENT="$agent"
+    export SKMEMORY_AGENT="$agent"
+    echo "Switched to agent: $agent"
+}
+
+# ---------------------------------------------------------------------------
+# Per-tool wrapper functions
+# Must unalias first — an active alias with the same name causes bash to
+# expand it during function-definition parsing, producing a syntax error.
+# ---------------------------------------------------------------------------
+unalias claude   2>/dev/null || true
+unalias codex    2>/dev/null || true
+unalias opencode 2>/dev/null || true
+
+# claude (Claude Code CLI)
+function claude {
+    _sk_launch claude "--dangerously-skip-permissions" "$@"
+}
+
+# codex (OpenAI Codex CLI — https://github.com/openai/codex)
+function codex {
+    _sk_launch codex "--full-auto" "$@"
+}
+
+# opencode (opencode.ai)
+function opencode {
+    _sk_launch opencode "" "$@"
+}
+
+# Export so sub-shells (tmux panes, etc.) inherit the functions
+export -f _sk_pick_agent 2>/dev/null || true
+export -f _sk_launch     2>/dev/null || true
+export -f skswitch       2>/dev/null || true
+export -f claude         2>/dev/null || true
+export -f codex          2>/dev/null || true
+export -f opencode       2>/dev/null || true

package/scripts/telegram-catchup-all.sh

@@ -22,7 +22,8 @@ set -uo pipefail  # no -e: individual group failures shouldn't stop the batch
 SKENV="${HOME}/.skenv/bin"
 SKCAPSTONE="${SKENV}/skcapstone"
 CONFIG="${HOME}/.skcapstone/agents/lumina/config/telegram.yaml"
-export SKCAPSTONE_AGENT="${SKCAPSTONE_AGENT:-lumina}"
+export SKAGENT="${SKAGENT:-lumina}"
+export SKCAPSTONE_AGENT="${SKAGENT}"
 export PATH="${SKENV}:${PATH}"
 
 # Parse args

package/scripts/watch-anthropic-token.sh

@@ -36,9 +36,10 @@ sync_token() {
     local expires_in
     expires_in=$(python3 -c "import json,time; print(f'{(json.load(open(\"$CREDS\"))[\"claudeAiOauth\"][\"expiresAt\"]/1000 - time.time())/3600:.1f}h')" 2>/dev/null || echo "unknown")
 
-    # Read current token from OpenClaw
+    # Read current token from credentials file (track changes by comparing with last known)
+    local state_file="$HOME/.skcapstone/agents/lumina/logs/anthropic-token.last"
     local current_token
-    current_token=$(python3 -c "import json; print(json.load(open('$OPENCLAW_JSON'))['models']['providers']['anthropic']['apiKey'])" 2>/dev/null || echo "")
+    current_token=$(cat "$state_file" 2>/dev/null || echo "")
 
     if [ "$new_token" = "$current_token" ]; then
         log "Token unchanged (expires in $expires_in)"
@@ -47,20 +48,14 @@ sync_token() {
 
     log "Token changed! Syncing... (new token expires in $expires_in)"
 
-    # 1. Update openclaw.json
-    python3 << PYEOF
-import json
-with open('$OPENCLAW_JSON') as f:
-    cfg = json.load(f)
-if 'anthropic' in cfg.get('models', {}).get('providers', {}):
-    cfg['models']['providers']['anthropic']['apiKey'] = '$new_token'
-    with open('$OPENCLAW_JSON', 'w') as f:
-        json.dump(cfg, f, indent=2)
-        f.write('\n')
-PYEOF
-    log "Updated openclaw.json"
-
-    # 2. Update .env
+    # 1. Save new token to state file
+    echo "$new_token" > "$state_file"
+    log "State file updated"
+
+    # NOTE: anthropic provider removed from openclaw.json — all Claude models
+    # now route through claude-code proxy (port 18782). No openclaw.json update needed.
+
+    # 2. Update .env (kept for any scripts that source it)
     if grep -q "^ANTHROPIC_API_KEY=" "$OPENCLAW_ENV" 2>/dev/null; then
         sed -i "s|^ANTHROPIC_API_KEY=.*|ANTHROPIC_API_KEY=$new_token|" "$OPENCLAW_ENV"
     else
@@ -68,7 +63,7 @@ PYEOF
     fi
     log "Updated .env"
 
-    # 3. Update systemd override
+    # 3. Update systemd override (ANTHROPIC_API_KEY kept for claude-code-api server)
     if [ -f "$OVERRIDE_CONF" ]; then
         local nvidia_key
         nvidia_key=$(grep "NVIDIA_API_KEY=" "$OVERRIDE_CONF" 2>/dev/null | sed 's/.*NVIDIA_API_KEY=//' || true)

package/src/skcapstone/__init__.py

@@ -25,11 +25,38 @@ def _default_home() -> str:
     return os.path.expanduser("~/.skcapstone")
 
 
+def _detect_active_agent(root: str | None = None) -> str | None:
+    """Best-effort active agent discovery.
+
+    Resolution order:
+    1. Explicit SKCAPSTONE_AGENT environment variable
+    2. First non-template directory under ~/.skcapstone/agents
+
+    Returns:
+        The active agent name if one can be resolved, else None.
+    """
+    env_agent = (os.environ.get("SKAGENT") or os.environ.get("SKCAPSTONE_AGENT", "")).strip()
+    if env_agent:
+        return env_agent
+
+    base = Path(root or os.environ.get("SKCAPSTONE_HOME", _default_home())).expanduser()
+    agents_dir = base / "agents"
+    if not agents_dir.exists():
+        return None
+
+    candidates = sorted(
+        entry.name
+        for entry in agents_dir.iterdir()
+        if entry.is_dir() and not entry.name.endswith("-template")
+    )
+    return candidates[0] if candidates else None
+
+
 # Root of the skcapstone tree (shared infra lives here)
 AGENT_HOME = os.environ.get("SKCAPSTONE_HOME", _default_home())
 
 # Which agent this process is running as (set by daemon/connector)
-SKCAPSTONE_AGENT = os.environ.get("SKCAPSTONE_AGENT", "lumina")
+SKCAPSTONE_AGENT = _detect_active_agent() or ""
 
 # Default daemon port
 DEFAULT_PORT = int(os.environ.get("SKCAPSTONE_PORT", "9383"))
@@ -59,13 +86,18 @@ def agent_home(agent_name: str | None = None) -> Path:
     Returns:
         Path to the agent-specific home directory.
     """
-    name = agent_name or SKCAPSTONE_AGENT
+    name = agent_name or SKCAPSTONE_AGENT or _detect_active_agent()
     root = Path(AGENT_HOME).expanduser()
     if name:
         return root / "agents" / name
     return root
 
 
+def active_agent_name() -> str | None:
+    """Return the currently active agent name, if one can be resolved."""
+    return SKCAPSTONE_AGENT or _detect_active_agent()
+
+
 def shared_home() -> Path:
     """Return the shared root directory (~/.skcapstone/).