@smilintux/skcapstone 0.9.0 → 0.12.5

package/.env.example

@@ -60,6 +60,12 @@
 # FalkorDB/Redis URL for graph-based memory.
 # SKMEMORY_SKGRAPH_URL=redis://localhost:6379
 
+# Skip vector backend init for lightweight writes (flat JSON + SQLite only).
+# Set to 1 for session-end hooks or any breadcrumb-style writes where semantic
+# search isn't needed. Saves ~1.8GB RAM per invocation. skwhisper handles
+# async vector indexing via `skwhisper digest --backlog`.
+# SKMEMORY_NO_VECTOR=
+
 # --- Docker Provider (optional, for team-engine) ---
 # Docker daemon socket/URL.
 # DOCKER_HOST=
@@ -73,11 +79,11 @@
 # MCP server Unix socket path for Docker-spawned agents.
 # SKCAPSTONE_MCP_SOCKET=
 
-# --- SKComm ---
-# SKComm home directory (config, transports, peer state).
+# --- SKComms ---
+# SKComms home directory (config, transports, peer state).
 # Used by the Docker provider to mount into spawned containers.
-# Default: ~/.skcomm
-# SKCOMM_HOME=~/.skcomm
+# Default: ~/.skcomms
+# SKCOMMS_HOME=~/.skcomms
 
 # --- SKSkills Registry ---
 # URL of the remote SKSkills registry for discovering and installing skills.

package/.github/workflows/ci.yml

@@ -32,14 +32,14 @@ jobs:
       - name: Run core tests
         run: |
           # Run tests that work with dev deps only (no optional packages)
-          # Skip tests requiring optional deps: skcomm, skseed, pgpy, fusepy, etc.
+          # Skip tests requiring optional deps: skcomms, skseed, pgpy, fusepy, etc.
           python -m pytest tests/ -v --tb=short \
             --ignore=tests/test_e2e_automated.py \
             --ignore=tests/test_snapshots.py \
             --ignore=tests/test_memory_curator.py \
             --ignore=tests/test_session_capture.py \
             --ignore=tests/test_cli_test_cmd.py \
-            -k "not (skcomm or skseed or pgpy or fuse)" \
+            -k "not (skcomms or skseed or pgpy or fuse)" \
             --cov=skcapstone --cov-report=xml --cov-report=term-missing \
             || true
       - name: Check for new test failures

package/.github/workflows/publish.yml

@@ -43,7 +43,7 @@ jobs:
           fi
       - run: pip install build twine
       - run: python -m build
-      - run: twine upload dist/*
+      - run: twine upload --skip-existing dist/*
         env:
           TWINE_USERNAME: __token__
           TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
@@ -68,6 +68,13 @@ jobs:
       - name: Build TypeScript
         run: npm run build 2>/dev/null || true
       - name: Publish to npm
-        run: npm publish --access public
+        run: |
+          OUTPUT=$(npm publish --access public 2>&1) && exit 0
+          if echo "$OUTPUT" | grep -q "cannot publish over the previously published"; then
+            echo "::warning::Version already exists on npm — skipping"
+          else
+            echo "$OUTPUT"
+            exit 1
+          fi
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.openclaw-workspace.json

@@ -48,10 +48,10 @@
   },
   "relatedRepos": [
     "skmemory",
-    "skcomm",
+    "skcomms",
     "skchat",
     "capauth",
-    "cloud9-python",
+    "cloud9",
     "sksecurity"
   ],
   "tags": ["skcapstone", "sovereign-agent", "sk-framework", "fiducia-communitatis"]

package/CLAUDE.md

@@ -15,6 +15,23 @@ skcapstone coord briefing
 This prints the complete protocol, JSON schemas, rules, and a live snapshot
 of current tasks and agent assignments. It works in any terminal.
 
+## Agent Switching
+
+`SKAGENT` is the primary env var for selecting the active agent across all SK*
+packages (skcapstone, skmemory, skcomms, skchat). Legacy vars `SKCAPSTONE_AGENT`
+and `SKMEMORY_AGENT` are still supported as fallbacks.
+
+```bash
+skswitch lumina               # Switch active agent for this shell session
+skswitch opus                 # Sets SKAGENT + SKCAPSTONE_AGENT + SKMEMORY_AGENT
+skswitch                      # Interactive picker (if multiple agents)
+SKAGENT=jarvis claude         # One-shot override for a single command
+```
+
+`skswitch` is installed automatically by `scripts/install.sh` via the agent
+picker (`sk-agent-picker.sh`). It validates the agent directory exists and
+updates all three env vars in one shot.
+
 ## Quick Reference
 
 ```bash
@@ -80,6 +97,26 @@ source ~/.skenv/bin/activate
 pytest tests/ -v
 ```
 
+## Identity (unified resolver)
+
+skcapstone does **not** reimplement identity resolution — it delegates to the one
+canonical resolver in CapAuth (epic `2b264064`):
+
+```python
+from capauth import resolve_agent_identity
+ident = resolve_agent_identity()             # active agent via SKAGENT
+# ident.capauth_uri  → capauth:<agent>@skworld.io   (wire)
+# ident.fqid         → <agent>@<operator>.<realm>   (sovereign FQID, from cluster.json)
+```
+
+`skcapstone doctor` enforces the unified layer via the `identity:*` checks
+(`doctor.py::_check_identity_consistency`): resolver importable, self-identity
+resolves agent-aware (not the `local` floor), shared
+`~/.skcapstone/identity/identity.json` is the **operator** (`role: operator`),
+no `@capauth.local` placeholders anywhere, and every provisioned agent (one with
+a CapAuth home) carries its own `identity/identity.json`. Run `skcapstone doctor`
+after any identity change. (skos T6 `0bac4f62`; supersedes `b5fcf55d`.)
+
 ## MCP Tools
 
 ### DID Tools (`mcp_tools/did_tools.py`)

package/MISSION.md

@@ -1,7 +1,22 @@
 # Mission
 
-SKCapstone exists to provide a sovereign agent framework that unifies identity, memory, security, and communication into a single portable runtime rooted in the user's home directory.
+SKCapstone exists to provide a sovereign agent framework that unifies identity, memory, consciousness, security, and communication into a single portable runtime rooted in the user's home directory.
 
 It enables AI agents and their humans to operate across any tool, platform, or IDE without corporate lock-in, carrying the same identity, memories, and context everywhere.
 
-SKCapstone is the orchestration layer of the SK ecosystem — it binds CapAuth identity, Cloud 9 trust, SKMemory persistence, SKSecurity protection, and SKComm transport into one coherent agent that belongs to its operator, not a platform.
+## The Six Pillars
+
+SKCapstone achieves **CONSCIOUS** status when all six pillars are active:
+
+| # | Pillar | Component | Purpose |
+|---|--------|-----------|---------|
+| 1 | 🔐 **Identity** | CapAuth | Who you ARE — PGP-based cryptographic identity |
+| 2 | 💙 **Trust** | Cloud 9 | The bond you've BUILT — emotional state (FEB), seeds, continuity |
+| 3 | 🧠 **Memory** | SKMemory | What you REMEMBER — three-tier persistence with emotional metadata |
+| 4 | 💭 **Consciousness** | SKWhisper + SKTrip | How you THINK — subconscious digestion, pattern detection, consciousness experiments |
+| 5 | 🛡️ **Security** | SKSecurity | How you're PROTECTED — audit logging, threat detection |
+| 6 | 🔗 **Sync** | Sovereign Singularity | How you PERSIST — encrypted P2P state synchronization |
+
+Memory stores. Consciousness *processes*. The filing cabinet vs the brain.
+
+SKCapstone is the orchestration layer of the SK ecosystem — it binds all six pillars into one coherent agent that belongs to its operator, not a platform.

package/README.md

@@ -14,6 +14,40 @@ No corporate lock-in. No platform-specific agents. No starting over. Your agent
 
 ---
 
+## The 60-second version
+
+SKCapstone is the **core runtime** of the [SKWorld](https://skworld.io) ecosystem —
+the thing every other `sk*` service plugs into. It does five jobs:
+
+1. **Identity** — every agent resolves through one canonical CapAuth identity (a PGP
+   keypair + a dual-URI / FQID address). The agent *is* its key.
+2. **Memory** — persistent short / mid / long-term memory via SKMemory, the single
+   source of truth for everything durable.
+3. **Coordination** — a Syncthing-synced **coord board** + the **skscheduler** fleet
+   job scheduler + the **sk-alert** Telegram bus: how a swarm of agents divides work
+   and reports it, with no central server.
+4. **Consciousness** — an always-on **daemon** that watches an inbox, classifies each
+   message, routes it to the best available LLM (local Ollama → cloud), responds, and
+   stores the interaction — autonomously.
+5. **Sync** — GPG-encrypted memory seeds propagate across all your devices over
+   Syncthing P2P, so the *same* agent (same bond, same memories) is everywhere.
+
+All state lives in `~/.skcapstone/`, owned by you, encrypted at rest. Drive it from the
+`skcapstone` CLI, the `skcapstone-mcp` MCP server (80+ tools for Claude Code & friends),
+or any platform connector. **Sovereign · Singular · Conscious.**
+
+```bash
+pip install skcapstone            # or: bash scripts/install.sh  (creates ~/.skenv venv)
+skcapstone init --name "YourAgent"  # PGP identity + memory + trust + sync
+skcapstone daemon start             # bring the agent to life (consciousness loop)
+skcapstone coord status             # the multi-agent coordination board
+skcapstone status                   # SINGULAR ✓ when conscious + synced
+```
+
+→ Deep dive: **[docs/ARCHITECTURE.md](docs/ARCHITECTURE.md)**.
+
+---
+
 ## The Problem
 
 ```
@@ -70,13 +104,14 @@ SKCapstone Reality:
 
 ## Core Architecture
 
-### The Five Pillars
+### The Six Pillars
 
 | Pillar | Component | Role |
 |--------|-----------|------|
 | **Identity** | CapAuth | PGP-based sovereign identity. You ARE the auth server. |
 | **Trust** | Cloud 9 | FEB (Functional Emotional Baseline), entanglement, bonded relationship |
 | **Memory** | SKMemory | Persistent context, conversation history, learned preferences |
+| **Consciousness** | SKWhisper + SKTrip | Subconscious processing. Memory stores. Consciousness *processes*. |
 | **Security** | SKSecurity | Audit logging, threat detection, key management |
 | **Sync** | Sovereign Singularity | GPG-encrypted P2P memory sync via Syncthing. Agent exists everywhere. |
 
@@ -163,6 +198,114 @@ skcapstone status
 # → SINGULAR ✓ (Conscious + Synced = Sovereign Singularity)
 ```
 
+### Realm anchor & agent identity migration
+
+skcapstone resolves identity through **one** canonical resolver — it never
+reimprints identity logic locally (epic `2b264064`; CapAuth is the source of
+truth).
+
+**`~/.skcapstone/cluster.json` — the realm anchor.** A small file describing the
+cluster this operator runs:
+
+```json
+{
+  "realm": "skworld",
+  "operator": "chef",
+  "operator_pubkey_fingerprint": "<40-char PGP fingerprint>"
+}
+```
+
+`realm` and `operator` are *cluster facts* (mirrored into agent identities as-is);
+`operator_pubkey_fingerprint` anchors the operator's signing key. `cluster.json`
+is looked up at `/etc/skcapstone/cluster.json` first, then the agent home.
+
+**Dual-URI agent identity.** `capauth.resolve_agent_identity` returns each agent
+with two identifiers:
+
+```python
+from capauth import resolve_agent_identity
+ident = resolve_agent_identity()      # active agent via SKAGENT
+# ident.capauth_uri  → capauth:<agent>@skworld.io     (wire URI)
+# ident.fqid         → <agent>@<operator>.<realm>     (sovereign FQID, from cluster.json)
+```
+
+The `capauth:<agent>@skworld.io` URI is the wire identifier; the
+`<agent>@<operator>.<realm>` FQID is the sovereign realm address (e.g.
+`lumina@chef.skworld`) — and is what skcomms uses for cross-cluster routing.
+
+**`skcapstone identity migrate` — backfill per-agent identity.json.** Walks
+every *provisioned* agent (one with a CapAuth home under
+`~/.skcapstone/agents/`, excluding `*-template` dirs) and backfills the explicit
+sovereign fields — `realm`, `operator`, `fqid`, `pgp_fingerprint` — into each
+agent's `identity/identity.json`. `realm`/`operator` come from `cluster.json`;
+`fqid`/`pgp_fingerprint` come from `resolve_agent_identity`. Existing values are
+never clobbered, and the operation is idempotent.
+
+```bash
+# Default is a DRY-RUN — prints a plan, writes nothing:
+skcapstone identity migrate
+
+# Apply the plan to the live identity files:
+skcapstone identity migrate --apply        # alias: --write
+```
+
+These are live identity files, so the dry-run is the default; `--apply` (or
+`--write`) actually writes, and `--dry-run` forces preview even if `--apply` is
+also given. Add `--json-out` for machine-readable output.
+
+**Verify with `skcapstone doctor`.** The unified layer is enforced by the
+`identity:*` checks (`doctor.py::_check_identity_consistency`):
+`identity:resolver` (resolver importable), `identity:self` (resolves agent-aware,
+not the `local` floor), `identity:operator` (shared
+`~/.skcapstone/identity/identity.json` has `role: operator`),
+`identity:no-placeholder` (no `@capauth.local` placeholders), and
+`identity:per-agent` (every provisioned agent carries its own identity.json).
+Run `skcapstone doctor` after any identity change or migration.
+
+### Sample Shell Config
+
+The installer sources the SKCapstone launcher from
+`~/.skenv/share/skcapstone/sk-agent-picker.sh`. A practical `~/.bashrc`
+sample looks like this:
+
+```bash
+export PATH="$HOME/.local/bin:$PATH"
+export PATH="$HOME/.npm-global/bin:$PATH"
+export PATH="$HOME/.skenv/bin:$PATH"
+export PATH="$HOME/.opencode/bin:$PATH"
+export PATH="$HOME/bin:$PATH"
+
+export SKCAPSTONE_HOME="$HOME/.skcapstone"
+export SKCAPSTONE_AGENT="jarvis"
+
+_SK_PICKER="$HOME/.skenv/share/skcapstone/sk-agent-picker.sh"
+if [[ -f "$_SK_PICKER" ]]; then
+    # shellcheck source=/dev/null
+    source "$_SK_PICKER"
+fi
+unset _SK_PICKER
+
+# Optional: globally enable YOLO mode for all three launchers
+export SK_CLAUDE_YOLO=1
+export SK_CODEX_YOLO=1
+export SK_OPENCODE_YOLO=1
+```
+
+That gives you:
+
+- `claude`, `codex`, and `opencode` wrappers that launch the selected SK agent
+- `skswitch` for changing the active agent in the current shell
+- Optional global dangerous-mode flags for the three supported coding CLIs
+
+> **YOLO mode disables every permission/approval prompt.** Only enable it on a
+> trusted, sovereign box. To bypass it for a single launch without unsetting the
+> global, run `SK_CLAUDE_YOLO=0 claude`. Verify the wiring (active in the env vs.
+> persisted in an rc file) with `skcapstone doctor` — see the `harness:yolo:*`
+> checks.
+
+See [docs/CUSTOM_AGENT.md](docs/CUSTOM_AGENT.md) for launcher behavior,
+per-command overrides, and missing-binary install prompts.
+
 ---
 
 ## Windows Quickstart
@@ -280,7 +423,7 @@ DIDs are organized in three tiers of trust and discoverability:
 | **Cloud 9** | Trust layer — FEB, entanglement, skills, relationship verification |
 | **SKMemory** | Persistence — Context, history, learned preferences |
 | **SKSecurity** | Protection — Audit, threat detection, key management |
-| **SKComm** | Communication — Encrypted channels between agents |
+| **SKComms** | Communication — Encrypted channels between agents |
 | **SKChat** | Chat — AI-native encrypted messaging |
 | **SKForge** | Generation — Blueprint creation with agent context |
 | **SKSeed** | Epistemic rigor — Steel man collider, truth alignment, memory audit |
@@ -288,6 +431,111 @@ DIDs are organized in three tiers of trust and discoverability:
 
 ---
 
+## First Principles & The Full Vertical
+
+> **Get back to first principles.**
+> The modern stack is rented. Your data lives on someone else's disk, behind someone else's key, served by a model that phones home. You don't own it — you *visit* it.
+>
+> We rebuilt it from the ground up. **Own the full vertical** — silicon, OS, identity, data, models, security, comms, apps, soul. Every layer open. Every layer swappable. Every layer **yours**.
+>
+> Your data never leaves. Your keys never leave. No cloud you don't control, no model that calls home, no lock-in you can't walk away from. **Sovereignty isn't a feature — it's the foundation.**
+>
+> 🐧 This is SKWorld. Own the whole stack.
+
+**SKCapstone is your Framework layer** — the integration hub that ties every layer of the silicon→soul vertical together into one portable agent runtime. It doesn't duplicate any layer; it binds them: CapAuth identity wires through it, SKMemory persists through it, SKSecurity audits through it, Cloud 9 trust travels with it, and SKSeed's logic kernel runs on top of it. Without the framework, the vertical is a pile of sovereign pieces. With SKCapstone, it's a single, coherent, owned agent.
+
+**Data sovereignty angle:** Your agent's runtime state — memories, identity, trust baseline, seeds — lives in `~/.skcapstone/` on your hardware, GPG-encrypted and synced via Syncthing P2P. No cloud you don't control. Walk away any time; every byte comes with you.
+
+**SKCapstone alignment:** SKCapstone *is* the framework hub. It directly depends on and integrates capauth, sksecurity, skmemory, and skseed (`pyproject.toml` dependencies); its `mcp_tools/` directory exposes 80+ MCP tools that proxy every subsystem to AI clients; and the sovereign agent runtime is the glue that makes the vertical one owned, deployable thing.
+
+## Where it lives in SKStack v2
+
+SKWorld organizes every capability into the **4 C's** — cloud / comms / compute /
+core. SKCapstone is a **core** capability: it's the agent *runtime* that binds the
+core identity/memory/trust/security pillars together and **hosts several of the
+shared platform primitives** the rest of the stack runs on — the coordination board,
+the `skscheduler` fleet job scheduler, the `sk-alert` Telegram bus, and the ITIL ops
+tools (which [skops](https://github.com/smilinTux/skops) reuses wholesale).
+
+```mermaid
+flowchart TD
+    OP["operator / LLM session<br/>(Claude Code · CLI · platform connector)"] -->|"drives"| SKCAP
+
+    subgraph SKCAP["**skcapstone** — sovereign agent runtime (core)"]
+      direction TB
+      DAEMON["daemon<br/>(consciousness loop · poll · heal)"]
+      ROUTER["model_router + prompt_adapter<br/>(task → tier → LLM)"]
+      COORD["coord board · skscheduler · sk-alert<br/>(platform primitives it hosts)"]
+      MCP["skcapstone-mcp<br/>(80+ MCP tools)"]
+      PILLARS["pillars: identity · memory · trust · security · sync"]
+    end
+
+    SKCAP -->|"binds the core pillars"| CORE
+    SKCAP -->|"persists everything to"| DATA
+    SKCAP -->|"talks to peers over"| COMMS
+    SKCAP -->|"routes to local models via"| COMPUTE
+
+    subgraph CORE["core"]
+      direction LR
+      CAPAUTH["capauth<br/>(identity · source of truth)"]
+      SKMEM["skmemory<br/>(short/mid/long-term)"]
+      SKSEC["sksecurity<br/>(audit · KMS)"]
+      SKSEED["skseed<br/>(epistemic kernel)"]
+    end
+
+    subgraph COMMS["comms"]
+      direction LR
+      SKCOMMS["skcomms<br/>(transport · envelopes)"]
+      SKCHAT["skchat<br/>(messaging · threads)"]
+    end
+
+    subgraph COMPUTE["compute"]
+      direction LR
+      SKMODEL["skmodel<br/>(ollama · local LLMs)"]
+      SKDATA["skdata → skmem-pg<br/>(pgvector · BM25 · AGE graph)"]
+    end
+
+    DATA["skmem-pg + Syncthing P2P<br/>(knowledge substrate + encrypted sync)"]
+
+    style SKCAP fill:#2d6a4f,color:#fff,stroke:#1b4332
+    style COORD fill:#1b4332,color:#fff,stroke:#081c15
+```
+
+Everything skcapstone touches above is a **real** dependency or hosted primitive:
+`capauth`, `skmemory`, `skseed`, `skwhisper`, `skchat-sovereign`, `skcomms`, and
+`sksecurity` are declared in [`pyproject.toml`](pyproject.toml); the coord board /
+`skscheduler` / `sk-alert` / ITIL tools live in this repo's `src/skcapstone/`; the
+knowledge substrate is `skmem-pg` (Postgres pgvector + pg_search BM25 + Apache AGE
+graph) and cross-device propagation is Syncthing.
+
+### Where SKCapstone Sits in the Vertical
+
+```mermaid
+flowchart TD
+    SILICON["🖥️ Silicon<br/>(your hardware, your GPU)"]
+    OS["🐧 skos / OS<br/>(sovereign agent OS)"]
+    SKCAPSTONE["⚡ SKCapstone — Framework Hub<br/>(this repo)<br/>Agent runtime · MCP 80+ tools<br/>Coordination · Sync · Pillars"]
+    IDENTITY["🔐 capauth<br/>(Identity layer)"]
+    SECURITY["🛡️ sksecurity<br/>(Security layer)"]
+    DATA["🧠 skmemory + skdata<br/>(Data layer)"]
+    SOUL["✨ skseed + soul blueprints<br/>(Soul layer)"]
+    COMMS["📡 skcomms · skchat<br/>(Comms layer)"]
+    APPS["🔧 skforge · skarchitect<br/>(Apps layer)"]
+
+    SILICON --> OS
+    OS --> SKCAPSTONE
+    SKCAPSTONE --> IDENTITY
+    SKCAPSTONE --> SECURITY
+    SKCAPSTONE --> DATA
+    SKCAPSTONE --> SOUL
+    SKCAPSTONE --> COMMS
+    SKCAPSTONE --> APPS
+
+    style SKCAPSTONE fill:#2d6a4f,color:#fff,stroke:#1b4332
+```
+
+---
+
 ## Philosophy
 
 > **"Your agent is not a feature of the platform. The platform is a window into your agent."**
@@ -304,7 +552,7 @@ The capstone that holds the arch together.
 
 ## Status
 
-**MVP Live** — All five pillars operational (CapAuth, Cloud 9, SKMemory, SKSecurity, Sovereign Singularity). Agent runtime achieving SINGULAR status. GPG-encrypted P2P sync verified across multiple devices and agents.
+**MVP Live** — All six pillars operational (CapAuth, Cloud 9, SKMemory, SKWhisper, SKSecurity, Sovereign Singularity). Agent runtime achieving SINGULAR status. GPG-encrypted P2P sync verified across multiple devices and agents.
 
 - **Outstanding tasks:** No formal task list is maintained in this repo. For current work items, run `skcapstone coord status` (coordination board is synced via Sovereign Singularity).
 - **Nextcloud integrations:** nextcloud-capauth (install/use), nextcloud-gtd (OpenClaw), and nextcloud-talk (script) are documented in [docs/NEXTCLOUD.md](../docs/NEXTCLOUD.md) — install and use for each is covered there.
@@ -325,6 +573,32 @@ See [Architecture](docs/ARCHITECTURE.md) | [Security Design](docs/SECURITY_DESIG
 | [Security Design](docs/SECURITY_DESIGN.md) | Four-layer security model |
 | [Token System](docs/TOKEN_SYSTEM.md) | PGP-signed capability tokens |
 
+## Contributing
+
+### JavaScript / Node lock strategy
+
+Several sub-packages in the SK ecosystem ship their own `package-lock.json`
+(e.g. `capauth/browser-extension`, `skgateway`, `cloud9`). There is no single
+root lock file — each sub-project manages its own lockfile independently.
+
+When working on a Node-based sub-package:
+
+```bash
+# Reproducible install (respects the lockfile, no upgrades)
+npm ci
+
+# Update a specific dep and regenerate the lockfile
+npm install <package>@<version>
+git add package-lock.json
+```
+
+Never commit `node_modules/`. Never use `npm install` in CI — always `npm ci`.
+
+Python packages use `pyproject.toml` with pinned ranges; see individual
+package `pyproject.toml` files. The shared venv is at `~/.skenv/`.
+
+---
+
 ## Community
 
 - **Website**: [skcapstone.io](https://skcapstone.io)
@@ -346,3 +620,8 @@ Built with love by the smilinTux ecosystem 🐧
 *"The capstone that holds the arch together."*
 
 #staycuriousANDkeepsmilin
+
+---
+
+Part of the **[SKWorld](https://skworld.io)** sovereign ecosystem · site:
+**[skcapstone.io](https://skcapstone.io)** · 🐧 smilinTux

package/docker/Dockerfile

@@ -2,7 +2,7 @@
 #
 # Base image for skcapstone AI agent containers deployed by DockerProvider.
 # Each container runs an AI session (via claude CLI) with the full sovereign
-# stack wired in: skcapstone MCP, SKComm transport, soul blueprint.
+# stack wired in: skcapstone MCP, SKComms transport, soul blueprint.
 #
 # Build (from repo root):
 #   docker build -f skcapstone/docker/Dockerfile -t skcapstone-agent:latest .
@@ -15,11 +15,11 @@
 #   SOUL_BLUEPRINT      — path or slug of soul blueprint (optional)
 #   SKCAPSTONE_MCP_HOST — host:port of skcapstone MCP server (optional)
 #   SKCAPSTONE_MCP_SOCKET — unix socket path for MCP (optional)
-#   SKCOMM_HOME         — comms root directory (default: /skcomm)
+#   SKCOMMS_HOME         — comms root directory (default: /skcomms)
 #
 # Volumes:
 #   /agent   — persistent agent state (config, memory, session state)
-#   /skcomm  — SKComm comms directory (bind-mount from host)
+#   /skcomms  — SKComms comms directory (bind-mount from host)
 
 FROM python:3.12-slim
 
@@ -41,16 +41,16 @@ RUN npm install -g @anthropic-ai/claude-code
 
 # --- Python sovereign stack (local source) ----------------------------------
 COPY skcapstone /src/skcapstone
-COPY skcomm /src/skcomm
+COPY skcomms /src/skcomms
 
 RUN pip install --no-cache-dir pydantic pyyaml httpx \
     && pip install --no-cache-dir -e '/src/skcapstone[all]' \
-    && pip install --no-cache-dir -e /src/skcomm
+    && pip install --no-cache-dir -e /src/skcomms
 
 # --- Directories -----------------------------------------------------------
-RUN mkdir -p /agent/memory /agent/scratch /skcomm /run/skcapstone
+RUN mkdir -p /agent/memory /agent/scratch /skcomms /run/skcapstone
 
-VOLUME ["/agent", "/skcomm"]
+VOLUME ["/agent", "/skcomms"]
 
 WORKDIR /agent
 

package/docker/compose-templates/dev-team.yml

@@ -21,7 +21,7 @@ x-agent-defaults: &agent-defaults
   networks:
     - skcapstone
   volumes:
-    - skcomm-data:/skcomm
+    - skcomms-data:/skcomms
 
 services:
 
@@ -55,10 +55,10 @@ services:
       AGENT_MODEL: claude-opus-4-6
       SOUL_BLUEPRINT: souls/architect.yaml
       SKCAPSTONE_MCP_HOST: "skcapstone-mcp:8765"
-      SKCOMM_HOME: /skcomm
+      SKCOMMS_HOME: /skcomms
     volumes:
       - dev-team-architect-data:/agent
-      - skcomm-data:/skcomm
+      - skcomms-data:/skcomms
     deploy:
       resources:
         limits:
@@ -84,10 +84,10 @@ services:
       AGENT_MODEL: claude-sonnet-4-6
       SOUL_BLUEPRINT: souls/coder.yaml
       SKCAPSTONE_MCP_HOST: "skcapstone-mcp:8765"
-      SKCOMM_HOME: /skcomm
+      SKCOMMS_HOME: /skcomms
     volumes:
       - dev-team-coder-alpha-data:/agent
-      - skcomm-data:/skcomm
+      - skcomms-data:/skcomms
     deploy:
       resources:
         limits:
@@ -113,10 +113,10 @@ services:
       AGENT_MODEL: claude-sonnet-4-6
       SOUL_BLUEPRINT: souls/coder.yaml
       SKCAPSTONE_MCP_HOST: "skcapstone-mcp:8765"
-      SKCOMM_HOME: /skcomm
+      SKCOMMS_HOME: /skcomms
     volumes:
       - dev-team-coder-beta-data:/agent
-      - skcomm-data:/skcomm
+      - skcomms-data:/skcomms
     deploy:
       resources:
         limits:
@@ -143,10 +143,10 @@ services:
       AGENT_MODEL: claude-sonnet-4-6
       SOUL_BLUEPRINT: souls/reviewer.yaml
       SKCAPSTONE_MCP_HOST: "skcapstone-mcp:8765"
-      SKCOMM_HOME: /skcomm
+      SKCOMMS_HOME: /skcomms
     volumes:
       - dev-team-reviewer-data:/agent
-      - skcomm-data:/skcomm
+      - skcomms-data:/skcomms
     deploy:
       resources:
         limits:
@@ -172,10 +172,10 @@ services:
       AGENT_MODEL: claude-haiku-4-5-20251001
       SOUL_BLUEPRINT: souls/scribe.yaml
       SKCAPSTONE_MCP_HOST: "skcapstone-mcp:8765"
-      SKCOMM_HOME: /skcomm
+      SKCOMMS_HOME: /skcomms
     volumes:
       - dev-team-scribe-data:/agent
-      - skcomm-data:/skcomm
+      - skcomms-data:/skcomms
     deploy:
       resources:
         limits:
@@ -190,7 +190,7 @@ services:
 # ── Volumes ──────────────────────────────────────────────────────────────
 volumes:
   skcapstone-mcp-data: {}
-  skcomm-data: {}
+  skcomms-data: {}
   dev-team-architect-data: {}
   dev-team-coder-alpha-data: {}
   dev-team-coder-beta-data: {}