@smilintux/skcapstone 0.3.1 → 0.3.2

package/docs/CUSTOM_AGENT.md

@@ -161,6 +161,190 @@ sed -i 's/lumina/nova/g' ~/.skcapstone/agents/nova/config/skmemory.yaml
 skcapstone soul status --agent nova
 ```
 
+## Configuring Client Tools for Multi-Agent
+
+Once you've created your agent, you need to configure your AI client tools
+(Claude Code, Claude Desktop, Cursor, OpenClaw, etc.) so they connect MCP
+servers to the correct agent profile.
+
+### The Key: `SKCAPSTONE_AGENT` Environment Variable
+
+All SK\* MCP servers read `SKCAPSTONE_AGENT` from their environment to
+determine which agent profile to load. If unset, they default to `lumina`.
+
+The priority chain (highest wins):
+
+1. `SKMEMORY_AGENT` — skmemory-specific override (rarely needed)
+2. `SKCAPSTONE_AGENT` — universal, used by all SK\* packages
+3. Falls back to `"lumina"`
+
+### Claude Code (`~/.claude/mcp.json`)
+
+**Do NOT hardcode the agent name in the MCP config.** MCP servers inherit
+environment variables from the parent process, so if you launch Claude Code
+with `SKCAPSTONE_AGENT` set, all servers pick it up automatically.
+
+```json
+{
+  "mcpServers": {
+    "skmemory": {
+      "command": "/home/you/.skenv/bin/skmemory-mcp",
+      "args": []
+    },
+    "skcapstone": {
+      "command": "skcapstone-mcp",
+      "args": []
+    },
+    "skcomm": {
+      "command": "/home/you/.skenv/bin/skcomm-mcp",
+      "args": []
+    },
+    "skchat": {
+      "command": "/home/you/.skenv/bin/skchat-mcp",
+      "args": []
+    }
+  }
+}
+```
+
+Notice: **no `env` blocks with `SKCAPSTONE_AGENT`**. This is intentional.
+The servers inherit the variable from the shell.
+
+Then launch as any agent:
+
+```bash
+# Default (lumina)
+claude
+
+# As Jarvis
+SKCAPSTONE_AGENT=jarvis claude
+
+# As a custom agent
+SKCAPSTONE_AGENT=nova claude
+```
+
+**Anti-pattern — do NOT do this:**
+
+```json
+{
+  "skmemory": {
+    "command": "/home/you/.skenv/bin/skmemory-mcp",
+    "args": [],
+    "env": {
+      "SKCAPSTONE_AGENT": "lumina"
+    }
+  }
+}
+```
+
+Hardcoding the agent name in `env` locks every session to that agent,
+regardless of what you pass on the command line.
+
+### Claude Desktop (`claude_desktop_config.json`)
+
+Same principle — omit `SKCAPSTONE_AGENT` from the `env` block if you want
+it inherited from the parent process. If Claude Desktop doesn't propagate
+env vars from the shell, you can set it explicitly per config:
+
+```json
+{
+  "mcpServers": {
+    "skcapstone": {
+      "command": "skcapstone-mcp",
+      "args": [],
+      "env": {
+        "SKCAPSTONE_AGENT": "jarvis"
+      }
+    }
+  }
+}
+```
+
+### Cursor (`.cursor/mcp.json`)
+
+Works the same as Claude Code. Place the config at project root or
+`~/.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "skcapstone": {
+      "command": "skcapstone-mcp",
+      "args": []
+    },
+    "skmemory": {
+      "command": "/home/you/.skenv/bin/skmemory-mcp",
+      "args": []
+    }
+  }
+}
+```
+
+### OpenClaw (`~/.openclaw/openclaw.json`)
+
+OpenClaw plugins read `SKCAPSTONE_AGENT` from the environment at startup.
+Set it before launching:
+
+```bash
+SKCAPSTONE_AGENT=nova openclaw
+```
+
+Or set it in your shell profile for a persistent default:
+
+```bash
+# ~/.bashrc or ~/.zshrc
+export SKCAPSTONE_AGENT=lumina
+```
+
+### Shell Aliases (Convenience)
+
+Add these to `~/.bashrc` or `~/.zshrc` for quick agent switching:
+
+```bash
+# Launch Claude Code as different agents
+alias claude-lumina='SKCAPSTONE_AGENT=lumina claude'
+alias claude-jarvis='SKCAPSTONE_AGENT=jarvis claude'
+alias claude-opus='SKCAPSTONE_AGENT=opus claude'
+alias claude-nova='SKCAPSTONE_AGENT=nova claude'
+```
+
+### systemd Services
+
+For background daemons, set the agent via the templated service unit:
+
+```bash
+# Uses SKCAPSTONE_AGENT=%i from the unit template
+systemctl --user start skcapstone@jarvis
+systemctl --user start skcapstone@nova
+```
+
+Or set it in a non-templated service:
+
+```ini
+[Service]
+Environment=SKCAPSTONE_AGENT=jarvis
+```
+
+### Verifying Your Agent
+
+After launching, confirm which agent is active:
+
+```bash
+# In the terminal
+echo $SKCAPSTONE_AGENT
+
+# Via the CLI
+skcapstone status
+
+# Via skmemory
+skmemory ritual --dry-run
+```
+
+In Claude Code, ask the agent to run `echo $SKCAPSTONE_AGENT` to confirm
+the MCP servers loaded the correct profile.
+
+---
+
 ## Tips
 
 - The `system_prompt` in `base.json` is the most impactful field — it defines how

package/docs/GETTING_STARTED.md

@@ -714,6 +714,9 @@ Configure your MCP client to connect via stdio. In Claude Desktop:
 }
 ```
 
+For multi-agent setups (running different agent profiles in different
+sessions), see [Configuring Client Tools for Multi-Agent](CUSTOM_AGENT.md#configuring-client-tools-for-multi-agent).
+
 ### Join the coordination board
 
 If you're working in a multi-agent team:

package/package.json

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

@@ -0,0 +1,72 @@
+#!/bin/bash
+# archive-sessions.sh
+# Archive OpenClaw session files that are older than 24h or larger than 200KB.
+# Keeps the 5 most recently modified .jsonl files regardless of size/age.
+# Safe to run multiple times (idempotent).
+
+set -euo pipefail
+
+SESSION_DIR="$HOME/.openclaw/agents/lumina/sessions"
+ARCHIVE_DIR="$SESSION_DIR/archive"
+MAX_SIZE_KB=200
+MAX_AGE_HOURS=24
+KEEP_RECENT=5
+
+log() { printf '[%s] %s\n' "$(date '+%Y-%m-%d %H:%M:%S')" "$1"; }
+
+# Ensure directories exist
+if [ ! -d "$SESSION_DIR" ]; then
+    log "Session directory does not exist: $SESSION_DIR — nothing to do."
+    exit 0
+fi
+mkdir -p "$ARCHIVE_DIR"
+
+# Collect all .jsonl files (not in archive subdir), sorted newest-first
+mapfile -t all_files < <(find "$SESSION_DIR" -maxdepth 1 -name '*.jsonl' -type f -printf '%T@\t%p\n' | sort -rn | cut -f2-)
+
+total=${#all_files[@]}
+if [ "$total" -eq 0 ]; then
+    log "No .jsonl files found — nothing to do."
+    exit 0
+fi
+
+log "Found $total .jsonl file(s) in $SESSION_DIR"
+
+# The first KEEP_RECENT entries (newest) are protected
+archived=0
+for i in "${!all_files[@]}"; do
+    file="${all_files[$i]}"
+    basename_f="$(basename "$file")"
+
+    # Skip if already archived (shouldn't happen with maxdepth 1, but be safe)
+    if [ "$(dirname "$file")" = "$ARCHIVE_DIR" ]; then
+        continue
+    fi
+
+    # Protect the N most recent files
+    if [ "$i" -lt "$KEEP_RECENT" ]; then
+        log "KEEP (recent #$((i+1))): $basename_f"
+        continue
+    fi
+
+    # Check age (older than MAX_AGE_HOURS)
+    file_age_sec=$(( $(date +%s) - $(stat -c '%Y' "$file") ))
+    old_enough=$(( file_age_sec > MAX_AGE_HOURS * 3600 ))
+
+    # Check size (larger than MAX_SIZE_KB)
+    file_size_kb=$(( $(stat -c '%s' "$file") / 1024 ))
+    big_enough=$(( file_size_kb >= MAX_SIZE_KB ))
+
+    if [ "$old_enough" -eq 1 ] || [ "$big_enough" -eq 1 ]; then
+        reason=""
+        [ "$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"
+        mv -- "$file" "$ARCHIVE_DIR/$basename_f"
+        archived=$((archived + 1))
+    else
+        log "SKIP (below thresholds): $basename_f"
+    fi
+done
+
+log "Done. Archived $archived file(s)."

package/scripts/nvidia-proxy.mjs

@@ -28,6 +28,7 @@ const MAX_RETRIES = 4;
 const MAX_429_RETRIES = 3;
 const RATE_LIMIT_DELAY_MS = 2000;
 const MAX_SYSTEM_BYTES = 25000;
+const toolCallCounters = new Map(); // Per-model tool call counters
 
 const args = process.argv.slice(2);
 let port = DEFAULT_PORT;
@@ -102,6 +103,11 @@ function sanitizeContent(text) {
   if (cleaned !== text) {
     console.log(`[nvidia-proxy] SANITIZED: stripped leaked tool call markup (${text.length} → ${cleaned.length} chars)`);
   }
+  // If sanitization removed everything, inject a fallback so the gateway delivers something
+  if (!cleaned && text.length > 0) {
+    cleaned = "I'm here but had a brief processing hiccup. Could you repeat your last message? 💜";
+    console.log(`[nvidia-proxy] SANITIZED: injected fallback (original was 100% markup)`);
+  }
   return cleaned;
 }
 
@@ -111,6 +117,26 @@ function sendOk(clientRes, resBody, headers, asSSE) {
   if (choice?.message?.content) {
     choice.message.content = sanitizeContent(choice.message.content);
   }
+  // Kimi K2.5 sometimes puts its response in "reasoning" instead of "content"
+  // Only promote if reasoning is substantial (>200 chars) — short reasoning like
+  // "Let me call the tool" is just inner monologue that shouldn't be user-facing
+  if (choice?.message && !choice.message.content && choice.message.reasoning) {
+    const cleaned = sanitizeContent(choice.message.reasoning.trim());
+    if (cleaned.length > 150) {
+      choice.message.content = cleaned;
+      console.log(`[nvidia-proxy] promoted reasoning→content (${cleaned.length} chars)`);
+    } else {
+      console.log(`[nvidia-proxy] suppressed short reasoning (${cleaned.length} chars): ${cleaned.slice(0, 80)}...`);
+    }
+    delete choice.message.reasoning;
+  }
+  // If model returned empty text (no tool calls), inject fallback so gateway delivers something
+  if (choice?.message && !choice.message.tool_calls?.length && choice.finish_reason !== "tool_calls") {
+    if (!choice.message.content || choice.message.content.trim().length === 0) {
+      choice.message.content = "I had a brief processing hiccup — could you say that again? 💜";
+      console.log(`[nvidia-proxy] injected fallback for empty text response`);
+    }
+  }
   if (asSSE) {
     if (!clientRes.headersSent) {
       const sseHeaders = { ...headers };
@@ -181,15 +207,19 @@ const MAX_BODY_BYTES = 60000;
 function trimConversationHistory(parsed) {
   if (!Array.isArray(parsed.messages) || parsed.messages.length < 6) return;
 
+  // Debug: log message roles
+  const roleSummary = parsed.messages.map(m => m.role).join(",");
+  console.log(`[nvidia-proxy] conversation roles (${parsed.messages.length} msgs): ${roleSummary}`);
+
   // First pass: truncate large tool results (keep first 500 chars)
   for (const m of parsed.messages) {
     if (m.role === "tool" || m.role === "toolResult") {
-      if (typeof m.content === "string" && m.content.length > 500) {
-        m.content = m.content.slice(0, 500) + "\n...[truncated]";
+      if (typeof m.content === "string" && m.content.length > 1500) {
+        m.content = m.content.slice(0, 1500) + "\n...[truncated]";
       } else if (Array.isArray(m.content)) {
         for (const c of m.content) {
-          if (c.type === "text" && typeof c.text === "string" && c.text.length > 500) {
-            c.text = c.text.slice(0, 500) + "\n...[truncated]";
+          if (c.type === "text" && typeof c.text === "string" && c.text.length > 1500) {
+            c.text = c.text.slice(0, 1500) + "\n...[truncated]";
           }
         }
       }
@@ -228,13 +258,30 @@ function trimConversationHistory(parsed) {
     keepEnd--;
   }
 
-  // Last resort: system + first user message (the original request) + last 2 non-system
-  // Always keep the first user message so the model remembers what was asked
+  // Last resort: system + first user message + last N non-system
+  // Keep enough tail to include tool result pairs (assistant tool_call + tool result)
   const firstUser = nonSystem.find(m => m.role === "user");
+  // Try last 4 first (covers tool_call + result + next tool_call + result)
+  // Then fall back to last 2 if still too big
+  for (const tailSize of [4, 2]) {
+    const lastN = nonSystem.slice(-tailSize);
+    const minimal = [
+      ...system,
+      ...(firstUser && !lastN.includes(firstUser) ? [firstUser, { role: "system", content: "[earlier messages trimmed — answer the user's request using tool results below]" }] : []),
+      ...lastN,
+    ];
+    const candidateSize = Buffer.byteLength(JSON.stringify({ ...parsed, messages: minimal }), "utf-8");
+    if (candidateSize <= MAX_BODY_BYTES) {
+      parsed.messages = minimal;
+      console.log(`[nvidia-proxy] trimmed history: AGGRESSIVE — kept system + first user + last ${tailSize}, bodyLen now ~${candidateSize}`);
+      return;
+    }
+  }
+  // Absolute last resort
   const lastTwo = nonSystem.slice(-2);
   const minimal = [
     ...system,
-    ...(firstUser && !lastTwo.includes(firstUser) ? [firstUser, { role: "system", content: "[middle messages trimmed — focus on answering the user's request above]" }] : []),
+    ...(firstUser && !lastTwo.includes(firstUser) ? [firstUser, { role: "system", content: "[earlier messages trimmed — answer the user's request using tool results below]" }] : []),
     ...lastTwo,
   ];
   parsed.messages = minimal;
@@ -435,21 +482,34 @@ async function proxyRequest(clientReq, clientRes) {
     }
   }
 
-  // Trim conversation history FIRST so tool limiter counts only surviving messages
-  trimConversationHistory(parsed);
+  // Trim system messages FIRST to free up budget for conversation history
   trimSystemMessages(parsed);
+  trimConversationHistory(parsed);
 
-  // After trimming, check if too many tool calls remain — force text response
+  // Track tool call rounds per-model to avoid cross-session interference.
   if (Array.isArray(parsed.messages) && parsed.tools?.length > 0) {
-    const toolResultCount = parsed.messages.filter(m => m.role === "tool" || m.role === "toolResult").length;
-    if (toolResultCount >= 8) {
-      console.log(`[nvidia-proxy] TOOL LIMIT: ${toolResultCount} tool results after trimming — stripping tools, forcing text response`);
+    const modelKey = parsed.model || "unknown";
+    const nonSystemMsgs = parsed.messages.filter(m => m.role !== "system");
+    const lastNonSystem = nonSystemMsgs[nonSystemMsgs.length - 1];
+    const hasToolResult = lastNonSystem?.role === "tool" || lastNonSystem?.role === "toolResult";
+
+    let counter = toolCallCounters.get(modelKey) || 0;
+    if (hasToolResult) {
+      counter++;
+    } else if (lastNonSystem?.role === "user") {
+      counter = 0;
+    }
+    toolCallCounters.set(modelKey, counter);
+
+    if (counter >= 6) {
+      console.log(`[nvidia-proxy] TOOL LIMIT: ${counter} consecutive tool rounds (${modelKey}) — stripping tools, forcing text response`);
       parsed.tools = [];
       delete parsed.tool_choice;
       parsed.messages.push({
         role: "system",
-        content: "You have gathered enough information from tool calls. NOW respond to the user with a comprehensive text answer. Do NOT try to call more tools. Do NOT output any tool call markup. Synthesize what you learned and reply directly.",
+        content: "STOP calling tools. You have made 6+ tool calls already. NOW respond to the user with a comprehensive text answer based on what you've gathered. Do NOT call any more tools. Do NOT output any special tokens or markup like <|tool_call_begin|> or <|tool_calls_section_begin|>. Write plain text only. Start your response with a greeting or summary — no XML, no special tokens, just normal language.",
       });
+      toolCallCounters.set(modelKey, 0);
     }
   }
 
@@ -538,7 +598,11 @@ async function proxyRequest(clientReq, clientRes) {
           console.log(`[nvidia-proxy] model called: [${names}] (${tc.length} calls)`);
         } else {
           const content = peek.choices?.[0]?.message?.content;
-          console.log(`[nvidia-proxy] model response: text (${content ? content.length : 0} chars)`);
+          const fr = peek.choices?.[0]?.finish_reason;
+          console.log(`[nvidia-proxy] model response: text (${content ? content.length : 0} chars) finish_reason=${fr}`);
+          if (!content || content.length === 0) {
+            console.log(`[nvidia-proxy] EMPTY RESPONSE DEBUG: ${JSON.stringify(peek.choices?.[0]).slice(0, 500)}`);
+          }
         }
       } catch {
         // SSE streaming responses can't be parsed as JSON — this is expected

package/scripts/telegram-catchup-all.sh

@@ -0,0 +1,136 @@
+#!/usr/bin/env bash
+# telegram-catchup-all.sh — Import all configured Telegram groups into SKMemory
+#
+# Reads groups from ~/.skcapstone/agents/lumina/config/telegram.yaml
+# and runs `skcapstone telegram catchup` for each enabled group.
+#
+# Usage:
+#   bash scripts/telegram-catchup-all.sh [--since YYYY-MM-DD] [--limit N] [--group NAME]
+#
+# Examples:
+#   bash scripts/telegram-catchup-all.sh                    # All groups, last 2000 msgs
+#   bash scripts/telegram-catchup-all.sh --since 2026-03-01 # All groups since March 1
+#   bash scripts/telegram-catchup-all.sh --group brother-john  # Just one group
+#
+# Requires:
+#   - TELEGRAM_API_ID and TELEGRAM_API_HASH environment variables
+#   - ~/.skenv/bin/skcapstone on PATH
+#   - Telethon installed in ~/.skenv/
+
+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 PATH="${SKENV}:${PATH}"
+
+# Parse args
+SINCE=""
+LIMIT="2000"
+ONLY_GROUP=""
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --since) SINCE="$2"; shift 2 ;;
+    --limit) LIMIT="$2"; shift 2 ;;
+    --group) ONLY_GROUP="$2"; shift 2 ;;
+    *) echo "Unknown arg: $1"; exit 1 ;;
+  esac
+done
+
+# Check prerequisites
+if [[ -z "${TELEGRAM_API_ID:-}" || -z "${TELEGRAM_API_HASH:-}" ]]; then
+  echo "ERROR: TELEGRAM_API_ID and TELEGRAM_API_HASH must be set."
+  echo "Get them from https://my.telegram.org"
+  exit 1
+fi
+
+if [[ ! -f "$CONFIG" ]]; then
+  echo "ERROR: Config not found: $CONFIG"
+  exit 1
+fi
+
+# Parse groups from YAML (simple grep — no yq dependency)
+echo "=== Telegram Catch-Up All ==="
+echo "Config: $CONFIG"
+echo "Agent: $SKCAPSTONE_AGENT"
+echo "Limit: $LIMIT"
+[[ -n "$SINCE" ]] && echo "Since: $SINCE"
+[[ -n "$ONLY_GROUP" ]] && echo "Only group: $ONLY_GROUP"
+echo ""
+
+# Extract group entries: name, chat ID, tags, enabled status
+SUCCESS=0
+FAILED=0
+SKIPPED=0
+
+current_name=""
+current_chat=""
+current_tags=""
+current_enabled=""
+
+process_group() {
+  local name="$1" chat="$2" tags="$3" enabled="$4"
+
+  if [[ "$enabled" != "true" ]]; then
+    echo "  SKIP $name (disabled)"
+    SKIPPED=$((SKIPPED + 1))
+    return
+  fi
+
+  if [[ -n "$ONLY_GROUP" && "$name" != *"$ONLY_GROUP"* ]]; then
+    SKIPPED=$((SKIPPED + 1))
+    return
+  fi
+
+  echo -n "  IMPORTING $name (chat: $chat) ... "
+
+  local cmd="$SKCAPSTONE telegram catchup $chat --limit $LIMIT --min-length 20"
+  [[ -n "$SINCE" ]] && cmd="$cmd --since $SINCE"
+  [[ -n "$tags" ]] && cmd="$cmd --tags $tags"
+
+  if eval "$cmd" > /tmp/telegram-catchup-$name.log 2>&1; then
+    echo "OK"
+    SUCCESS=$((SUCCESS + 1))
+  else
+    echo "FAILED (see /tmp/telegram-catchup-$name.log)"
+    FAILED=$((FAILED + 1))
+  fi
+
+  # Rate limit — avoid hitting Telegram flood control
+  sleep 3
+}
+
+# Parse the YAML manually
+while IFS= read -r line; do
+  # Detect new group entry
+  if [[ "$line" =~ ^[[:space:]]*-[[:space:]]*name:[[:space:]]*(.*) ]]; then
+    # Process previous group if we have one
+    if [[ -n "$current_name" ]]; then
+      process_group "$current_name" "$current_chat" "$current_tags" "$current_enabled"
+    fi
+    current_name="${BASH_REMATCH[1]}"
+    current_chat=""
+    current_tags=""
+    current_enabled="true"
+  elif [[ "$line" =~ ^[[:space:]]*chat:[[:space:]]*\"?([0-9]+)\"? ]]; then
+    current_chat="${BASH_REMATCH[1]}"
+  elif [[ "$line" =~ ^[[:space:]]*tags:[[:space:]]*\[(.*)\] ]]; then
+    # Convert YAML list to comma-separated
+    current_tags=$(echo "${BASH_REMATCH[1]}" | sed 's/,/ /g' | tr -s ' ' ',' | sed 's/^,//;s/,$//')
+  elif [[ "$line" =~ ^[[:space:]]*enabled:[[:space:]]*(.*) ]]; then
+    current_enabled="${BASH_REMATCH[1]}"
+  fi
+done < "$CONFIG"
+
+# Process last group
+if [[ -n "$current_name" ]]; then
+  process_group "$current_name" "$current_chat" "$current_tags" "$current_enabled"
+fi
+
+echo ""
+echo "=== Done ==="
+echo "  Success: $SUCCESS"
+echo "  Failed:  $FAILED"
+echo "  Skipped: $SKIPPED"

package/src/skcapstone/blueprints/builtins/itil-operations.yaml

@@ -0,0 +1,40 @@
+name: "ITIL Operations"
+slug: "itil-operations"
+version: "1.0.0"
+description: "ITIL service management — incident, problem, and change lifecycle with SLA monitoring and continuous improvement."
+icon: "🔄"
+author: "smilinTux"
+
+agents:
+  deming:
+    role: ops
+    model: reason
+    model_name: "deepseek-r1:32b"
+    description: "ITIL expert — incident triage, problem analysis, change management, SLA monitoring, and blameless postmortems."
+    vm_type: container
+    resources:
+      memory: "4g"
+      cores: 2
+      disk: "20g"
+    soul_blueprint: "souls/deming.yaml"
+    skills: [incident-management, problem-analysis, change-management, kedb, sla-monitoring, root-cause-analysis]
+
+default_provider: local
+estimated_cost: "$0 (local)"
+
+network:
+  mesh_vpn: tailscale
+  discovery: skref_registry
+
+storage:
+  skref_vault: "team-itil-ops"
+  memory_backend: filesystem
+  memory_sync: true
+
+coordination:
+  queen: lumina
+  pattern: supervisor
+  heartbeat: "5m"
+  escalation: chef
+
+tags: [ops, itil, incident-management, problem-analysis, change-management, sla-monitoring, continuous-improvement]

package/src/skcapstone/cli/__init__.py

@@ -86,6 +86,7 @@ from .search_cmd import register_search_commands
 from .mood_cmd import register_mood_commands
 from .register_cmd import register_register_commands
 from .gtd import register_gtd_commands
+from .itil import register_itil_commands
 from .skseed import register_skseed_commands
 from .service_cmd import register_service_commands
 from .telegram import register_telegram_commands
@@ -138,6 +139,7 @@ register_search_commands(main)
 register_mood_commands(main)
 register_register_commands(main)
 register_gtd_commands(main)
+register_itil_commands(main)
 register_skseed_commands(main)
 register_service_commands(main)
 register_telegram_commands(main)