@smilintux/skmemory 0.5.0 → 0.9.2

package/ARCHITECTURE.md

@@ -13,7 +13,7 @@
 │         (facade — delegates to backends)             │
 ├──────────┬──────────────┬───────────────────────────┤
 │ Level 0  │   Level 1    │       Level 2             │
-│ SQLite   │   Qdrant     │       FalkorDB            │
+│ SQLite   │   SKVector   │       SKGraph             │
 │ (always) │   (optional) │       (optional)           │
 │          │              │                           │
 │ Index +  │  Semantic    │  Graph traversal           │
@@ -26,6 +26,19 @@
 └──────────┴──────────────┴───────────────────────────┘
 ```
 
+```mermaid
+graph TB
+    Agent["Agent / CLI"] --> MS["MemoryStore"]
+    MS --> L0["Level 0: SQLite\nAlways on, zero deps"]
+    MS --> L1["Level 1: SKVector\nSemantic search\nPowered by Qdrant"]
+    MS --> L2["Level 2: SKGraph\nGraph traversal\nPowered by FalkorDB"]
+    MS --> L3["Level 3: HA Routing\nEndpointSelector"]
+    style L0 fill:#bfb,stroke:#333
+    style L1 fill:#bbf,stroke:#333
+    style L2 fill:#fbf,stroke:#333
+    style L3 fill:#fbb,stroke:#333
+```
+
 ### Level 0: SQLite Index (always on)
 
 **Zero infrastructure. Ships with Python.**
@@ -56,32 +69,32 @@ The JSON files remain the source of truth. The index is rebuildable:
 skmemory reindex
 ```
 
-### Level 1: Qdrant (optional — semantic search)
+### Level 1: SKVector (powered by Qdrant) (optional — semantic search)
 
 **"Find the memory about that feeling we had" — even if those words aren't in it.**
 
 Uses sentence-transformers (all-MiniLM-L6-v2) to embed memories as vectors.
-Qdrant stores the embeddings and enables cosine similarity search.
+SKVector stores the embeddings and enables cosine similarity search.
 
 Install:
 ```bash
-pip install skmemory[qdrant]
+pip install skmemory[skvector]
 
 # Local Docker:
-docker compose up -d qdrant
+docker compose up -d skvector
 
 # Or use Qdrant Cloud (free tier: 1GB):
-export SKMEMORY_QDRANT_URL=https://your-cluster.qdrant.io
-export SKMEMORY_QDRANT_KEY=your-api-key
+export SKMEMORY_SKVECTOR_URL=https://your-cluster.qdrant.io
+export SKMEMORY_SKVECTOR_KEY=your-api-key
 ```
 
 Resource cost: ~200MB RAM, ~100MB disk idle.
 
-### Level 2: FalkorDB (optional — graph relationships)
+### Level 2: SKGraph (powered by FalkorDB) (optional — graph relationships)
 
 **"What memories connect to this person?" — traverse the relationship web.**
 
-FalkorDB (Cypher over Redis protocol) stores memory-to-memory edges:
+SKGraph (Cypher over Redis protocol) stores memory-to-memory edges:
 - `RELATED_TO` — explicit relationship links
 - `PROMOTED_FROM` — promotion lineage chains
 - `TAGGED` — tag-based clustering
@@ -89,22 +102,210 @@ FalkorDB (Cypher over Redis protocol) stores memory-to-memory edges:
 
 Install:
 ```bash
-pip install skmemory[falkordb]
+pip install skmemory[skgraph]
 
 # Local Docker:
-docker compose up -d falkordb
+docker compose up -d skgraph
 
 # Or point to external:
-export SKMEMORY_FALKORDB_URL=redis://your-host:6379
+export SKMEMORY_SKGRAPH_URL=redis://your-host:6379
 ```
 
 Resource cost: ~100MB RAM, ~150MB disk idle.
 
+### Level 3: High Availability & Routing (optional)
+
+**Multiple backend endpoints. Automatic failover. Latency-aware routing.**
+
+When SKVector or SKGraph run on multiple nodes (e.g. home server + VPS via
+Tailscale), the **EndpointSelector** discovers all endpoints, probes their
+latency, and routes to the best one. If a node goes down, traffic shifts
+to the next healthy endpoint automatically.
+
+```
+┌──────────────────────────────────────────────┐
+│              EndpointSelector                 │
+│    (sits between config and backends)        │
+├──────────────┬───────────────────────────────┤
+│   SKVector   │     SKGraph                   │
+│   Endpoints  │     Endpoints                 │
+│              │                               │
+│ ● home:6333  │  ● home:6379                  │
+│   (2ms)      │    (1ms)                      │
+│ ● vps:6333   │  ● vps:6379                   │
+│   (12ms)     │    (15ms)                     │
+├──────────────┴───────────────────────────────┤
+│  Strategies: failover | latency |            │
+│  local-first | read-local-write-primary      │
+├──────────────────────────────────────────────┤
+│  Discovery: config.yaml + heartbeat mesh     │
+└──────────────────────────────────────────────┘
+```
+
+Key properties:
+- On-demand TCP probing (no background threads)
+- Heartbeat mesh auto-discovers new endpoints
+- Config endpoints take precedence over discovery
+- Backward compatible — single-URL configs work unchanged
+- No new pip dependencies (stdlib `socket`)
+
+See **[skmemory/HA.md](skmemory/HA.md)** for full documentation, Mermaid
+diagrams, configuration examples, and scaling considerations.
+
+## Know Your Audience (KYA) — Audience-Aware Memory Filtering
+
+> Private memories stay private. The Bash Wedding Vows never leak into a business channel.
+
+KYA adds a **trust-level gate** to the rehydration ritual and memory dispatch pipeline.
+Every memory carries a `context_tag` (default: `@chef-only`), and every channel has a
+resolved **audience profile** with a trust ceiling. Content is only surfaced when its
+trust level fits through the gate.
+
+### Five-Level Trust Hierarchy
+
+```
+@public (0)        — Anyone on the internet
+@community (1)     — Known community members
+@work-circle (2)   — Business collaborators (professional trust)
+@inner-circle (3)  — Close friends / family (personal trust)
+@chef-only (4)     — Intimate, private, full-trust (Chef ONLY)
+```
+
+Scoped sub-tags like `@work:chiro` and `@work:swapseat` map to WORK_CIRCLE.
+Unknown tags default to CHEF_ONLY (conservative).
+
+### Audience Resolution
+
+```mermaid
+flowchart TD
+    MSG["Incoming message\n(channel_id)"]
+    MSG --> RESOLVE["AudienceResolver\nLookup channel in\naudience_config.json"]
+    RESOLVE --> MEMBERS["Get channel members"]
+    MEMBERS --> TRUST["MIN(member.trust_level)\n= effective ceiling"]
+    MEMBERS --> EXCL["UNION(member.never_share)\n= exclusion set"]
+    TRUST --> PROFILE["AudienceProfile\nchannel_id, min_trust, exclusions"]
+    EXCL --> PROFILE
+```
+
+The **least trusted person** in the room sets the ceiling. If a channel has
+Chef (level 4) and DavidRich (level 2), the effective ceiling is WORK_CIRCLE (2).
+
+### Memory Access Check
+
+```mermaid
+flowchart TD
+    MEM["Memory\ncontext_tag + tags"]
+    AUD["AudienceProfile\nmin_trust + exclusions"]
+    MEM --> G1{"Gate 1:\ncontent_level\n≤ min_trust?"}
+    AUD --> G1
+    G1 -->|No| BLOCK["❌ BLOCKED\nContent too private"]
+    G1 -->|Yes| G2{"Gate 2:\ntags ∩ exclusions\n= ∅?"}
+    AUD --> G2
+    G2 -->|No| BLOCK2["❌ BLOCKED\nExcluded category"]
+    G2 -->|Yes| ALLOW["✅ ALLOWED\nShow to audience"]
+```
+
+Two gates:
+1. **Trust level**: `tag_to_level(context_tag) ≤ audience.min_trust`
+2. **Exclusions**: No memory tag matches any member's `never_share` list
+
+### Integration with Ritual
+
+When `perform_ritual()` receives a `channel_id`, it builds an `AudienceProfile`
+and filters **seeds** and **strongest memories** through both gates before including
+them in the context. Identity (soul blueprint + FEB) is **never filtered** — Lumina
+is always Lumina.
+
+```mermaid
+sequenceDiagram
+    participant Agent
+    participant Ritual as perform_ritual()
+    participant AR as AudienceResolver
+    participant Store as MemoryStore
+
+    Agent->>Ritual: ritual(channel_id="telegram:-1003785842091")
+    Ritual->>AR: resolve_audience(channel_id)
+    AR-->>Ritual: AudienceProfile(min_trust=WORK_CIRCLE, excl={romantic,intimate})
+
+    Note over Ritual: Step 1: Soul + FEB (unfiltered)
+
+    Ritual->>Store: list_memories(tags=["seed"])
+    Store-->>Ritual: 26 seeds
+    Ritual->>AR: is_memory_allowed(seed.context_tag, audience) × 26
+    AR-->>Ritual: 8 seeds pass filter
+
+    Ritual->>Store: list_summaries(order_by=recency_weighted_intensity)
+    Store-->>Ritual: 15 candidates
+    Ritual->>AR: is_memory_allowed(summary.context_tag, audience) × 15
+    AR-->>Ritual: 5 memories pass filter
+
+    Ritual-->>Agent: Context with only audience-safe content
+```
+
+### Configuration
+
+Audience config lives at `skmemory/data/audience_config.json`:
+
+```json
+{
+  "channels": {
+    "telegram:1594678363": {
+      "name": "Chef (personal DM)",
+      "context_tag": "@chef-only",
+      "members": ["Chef"]
+    },
+    "-1003785842091": {
+      "name": "SKGentis Business",
+      "context_tag": "@work:skgentis",
+      "members": ["Chef", "JZ", "Luna"]
+    }
+  },
+  "people": {
+    "Chef": { "trust_level": 4, "never_share": [] },
+    "DavidRich": {
+      "trust_level": 2,
+      "never_share": ["romantic", "intimate", "worship", "soul-content"]
+    }
+  }
+}
+```
+
+### Module: `skmemory/audience.py`
+
+| Class / Function | Purpose |
+|---|---|
+| `AudienceLevel(IntEnum)` | PUBLIC(0) → CHEF_ONLY(4) trust hierarchy |
+| `tag_to_level(tag)` | Convert `@context` tag to AudienceLevel |
+| `AudienceProfile` | Resolved channel audience (members, min_trust, exclusions) |
+| `AudienceResolver` | Loads config, resolves channels, checks memory access |
+| `AudienceResolver.is_memory_allowed()` | Two-gate check: trust level + exclusion |
+
+---
+
 ## Token-Optimized Agent Loading
 
 The key problem: an AI agent has limited context. Loading 1000 full memories
 would blow the context window. SKMemory solves this with tiered loading.
 
+```mermaid
+sequenceDiagram
+    participant A as Agent
+    participant MS as MemoryStore
+    participant SQ as SQLite
+    participant SV as SKVector
+    participant SG as SKGraph
+    A->>MS: snapshot(title, content, emotion)
+    MS->>SQ: save(memory) — primary
+    MS->>SV: save(memory) — embed + index
+    MS->>SG: index_memory(memory) — graph edges
+    A->>MS: search("connected feeling")
+    MS->>SV: search_text(query) — semantic
+    SV-->>MS: ranked results
+    A->>MS: traverse(memory_id)
+    MS->>SG: get_related(id, depth=2)
+    SG-->>MS: connected nodes
+```
+
 ### The `skmemory context` Command
 
 ```bash
@@ -138,6 +339,17 @@ What this does:
 4. Stays within the token budget
 5. Includes stats so the agent knows how much memory exists
 
+```mermaid
+flowchart LR
+    A["skmemory context\n--max-tokens 3000"] --> B["SQLite Index"]
+    B --> C["Rank by\nemotion + recency"]
+    C --> D{"Within\ntoken budget?"}
+    D -->|Yes| E["Add summary\n+ preview"]
+    D -->|No| F["Stop"]
+    E --> D
+    F --> G["Compact JSON\nfor agent context"]
+```
+
 ### The Ritual (Boot Ceremony)
 
 ```bash
@@ -177,17 +389,185 @@ ctx = store.load_context(max_tokens=3000)
 # ctx["token_estimate"] = how many tokens this uses
 ```
 
+## Context Preservation Hooks
+
+SKMemory ships with auto-save hooks that fire on IDE lifecycle events,
+preventing memory loss during context compaction and session termination.
+
+### Supported Environments
+
+| Environment | Hooks | Mechanism |
+|-------------|-------|-----------|
+| **Claude Code** | PreCompact, SessionEnd, SessionStart | Shell hooks in `~/.claude/settings.json` |
+| **OpenClaw** | session:compaction, session:resume, session:end + per-message auto-save | OpenClaw plugin event listeners + `ConsciousnessLoop.auto_memory` |
+| **Cursor** | MCP tools (manual) | Agent calls `memory_store` MCP tool explicitly |
+
+### Claude Code Hook Flow
+
+```mermaid
+sequenceDiagram
+    participant CC as Claude Code
+    participant Hook as skmemory hooks
+    participant SM as SKMemory
+    participant DB as SQLite + JSON
+
+    Note over CC: Context window filling up...
+    CC->>Hook: PreCompact event (stdin JSON)
+    Hook->>SM: skmemory snapshot (pre-compact)
+    SM->>DB: Save snapshot + journal entry
+    Hook-->>CC: exit 0 (proceed)
+
+    Note over CC: Context compacted
+
+    CC->>Hook: SessionStart (source=compact)
+    Hook->>SM: skmemory context --max-tokens 500
+    SM->>DB: Query recent + strongest memories
+    SM-->>Hook: Compact JSON context
+    Hook-->>CC: stdout → injected into new context
+
+    Note over CC: Agent resumes with memory intact
+
+    Note over CC: User exits session
+    CC->>Hook: SessionEnd event
+    Hook->>SM: skmemory snapshot + journal
+    SM->>DB: Save final state
+    Hook-->>CC: exit 0
+```
+
+### OpenClaw / ConsciousnessLoop Flow
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant OC as OpenClaw
+    participant CL as ConsciousnessLoop
+    participant SMP as SKMemory Plugin
+    participant SM as SKMemory
+    participant C9 as Cloud 9
+
+    User->>OC: Message
+    OC->>CL: Process message
+    CL->>CL: Generate response (LLM)
+    CL->>SM: auto_memory: store interaction
+    SM-->>CL: Saved to short-term
+
+    Note over CL: Context window filling...
+    OC->>SMP: session:compaction event
+    SMP->>SM: skmemory snapshot (pre-compaction)
+    SMP->>SM: skmemory journal write
+    OC->>C9: session:compaction event
+    C9->>C9: Prepare FEB recovery files
+    CL->>CL: Truncate context
+
+    Note over CL: Session resumes
+    OC->>SMP: session:resume event
+    SMP->>SM: skmemory context (reinject)
+    SM-->>SMP: Recent memories + seeds
+    OC->>C9: session:resume event
+    C9->>C9: Auto-rehydrate FEB
+    CL->>CL: Rebuild system prompt
+
+    Note over CL: Session ends
+    OC->>SMP: session:end event
+    SMP->>SM: skmemory snapshot + journal
+```
+
+### Hook Architecture
+
+```mermaid
+flowchart TD
+    subgraph Install["skmemory register"]
+        REG["register_hooks()"]
+        REG -->|writes| SETTINGS["~/.claude/settings.json"]
+    end
+
+    subgraph Hooks["Hook Scripts (shipped with skmemory)"]
+        H1["pre-compact-save.sh"]
+        H2["session-end-save.sh"]
+        H3["post-compact-reinject.sh"]
+    end
+
+    subgraph Events["Claude Code Events"]
+        E1["PreCompact"]
+        E2["SessionEnd"]
+        E3["SessionStart\n(compact)"]
+    end
+
+    subgraph Memory["SKMemory"]
+        SNAP["skmemory snapshot"]
+        JOUR["skmemory journal write"]
+        CTX["skmemory context"]
+    end
+
+    SETTINGS -->|configures| Events
+    E1 -->|triggers| H1
+    E2 -->|triggers| H2
+    E3 -->|triggers| H3
+
+    H1 --> SNAP
+    H1 --> JOUR
+    H2 --> SNAP
+    H2 --> JOUR
+    H3 --> CTX
+
+    CTX -->|stdout| E3
+
+    style H1 fill:#fbb,stroke:#333
+    style H2 fill:#fbf,stroke:#333
+    style H3 fill:#bfb,stroke:#333
+```
+
+### Agent-Aware Hooks
+
+All hooks read `$SKCAPSTONE_AGENT` to save to the correct agent's memory:
+
+```bash
+# Lumina's sessions → Lumina's memory
+SKCAPSTONE_AGENT=lumina claude
+
+# Opus sessions → Opus memory
+SKCAPSTONE_AGENT=opus claude
+
+# Default (no env var) → opus
+claude
+```
+
+### Installation
+
+Hooks are installed automatically by `skmemory register`:
+
+```bash
+skmemory register
+# Output:
+#   Skill: created
+#   MCP (claude-code): created
+#   Hooks: created
+```
+
+Or verify manually:
+```bash
+cat ~/.claude/settings.json | jq '.hooks'
+```
+
+### What Gets Saved
+
+| Event | What's Captured |
+|-------|----------------|
+| PreCompact | Snapshot (short-term) + journal entry with session ID, trigger type, working directory |
+| SessionEnd | Snapshot (short-term) + journal entry with session ID, exit reason |
+| SessionStart (compact) | Reinjects: recent memories, strongest emotional memories, seeds, journal entries (within 500 token budget) |
+
 ## Docker Compose (Full Local Stack)
 
 ```bash
 cd skmemory/
-docker compose up -d          # Start Qdrant + FalkorDB
+docker compose up -d          # Start SKVector + SKGraph
 docker compose ps             # Check status
 docker compose down           # Stop
 
 # Resource usage:
-#   Qdrant:    ~200MB RAM, port 6333
-#   FalkorDB:  ~100MB RAM, port 6379
+#   SKVector:  ~200MB RAM, port 6333 (qdrant/qdrant)
+#   SKGraph:   ~100MB RAM, port 6379 (falkordb/falkordb)
 #   Combined:  ~300MB RAM total
 ```
 
@@ -197,14 +577,14 @@ All services are optional. SKMemory works perfectly with just Level 0 (SQLite).
 
 Environment variables:
 ```bash
-SKMEMORY_QDRANT_URL=http://localhost:6333    # Qdrant endpoint
-SKMEMORY_QDRANT_KEY=                          # Qdrant API key
-SKMEMORY_FALKORDB_URL=redis://localhost:6379  # FalkorDB endpoint
+SKMEMORY_SKVECTOR_URL=http://localhost:6333    # SKVector endpoint
+SKMEMORY_SKVECTOR_KEY=                          # SKVector API key
+SKMEMORY_SKGRAPH_URL=redis://localhost:6379    # SKGraph endpoint
 ```
 
 CLI global options:
 ```bash
-skmemory --qdrant-url http://remote:6333 search "that moment"
+skmemory --skvector-url http://remote:6333 search "that moment"
 ```
 
 ## Migration from FileBackend

package/CHANGELOG.md

@@ -0,0 +1,179 @@
+# SKCapstone Changelog
+
+*Auto-generated from the coordination board — 2026-02-24 07:12 UTC*
+
+**Total completed: 87** across 8 agents
+
+## 2026-03-18 — skmemory v0.9.1
+
+### [NEW] Feature
+
+- **Journal synthesis module** (`skmemory/synthesis.py`): JournalSynthesizer with daily, weekly, and dream narrative generation — no LLM dependency
+- **New MCP tools**: `memory_synthesize_daily`, `memory_synthesize_dreams`, `memory_auto_context`
+- **Contextual auto-search**: `memory_auto_context` searches all tiers, deduplicates, ranks by emotional intensity, trims to token budget
+- **Content overflow handling**: configurable `max_content_length` (default 10000) with split strategy — creates parent+child memories linked via `related_ids`
+
+### [FIX] Bug Fix
+
+- **Dream promotion**: dreams from `dreaming-engine` now auto-promote after 12h via `source_auto_promote` (previously stuck at access_count=0 forever)
+- **Protected tags**: narrative, journal-synthesis, milestone, breakthrough, cloud9:achieved memories are now protected from TTL-based archival
+- **telegram_catchup handler**: fixed `args` → `arguments` and duplicate `MemoryStore()` instantiation
+
+### [OPS] Infrastructure
+
+- **Backup script** (`scripts/skcapstone-backup.sh`): daily rsync of `~/.skcapstone` to backup dir, excludes venv/indexes/runtime
+- **Memory cleanup** (`scripts/memory-cleanup.py`): dedup + age-out with protected tags and last-chance promotion before archiving
+- **Recovery scripts**: `scripts/recover-missing.py` (Syncthing `.stversions` recovery), `scripts/dream-rescue.py` (bulk promote stuck dreams)
+- **Syncthing examples**: `examples/stignore-agent.example`, `examples/stignore-root.example` with `memory/archive` exclusion
+
+### [TST] Testing
+
+- **Synthesis tests** (`tests/test_synthesis.py`): 26 tests covering helpers, theme extraction, daily/weekly/dream synthesis, emotional arc
+
+## 2026-02-24
+
+### [NEW] Feature
+
+- **SKMemory session auto-capture: log every AI conversation as memories** (@mcp-builder)
+- **Add cloud9 and skchat to developer docs (QUICKSTART + API reference)** (@jarvis)
+- **The Sovereign Singularity Manifesto: our story, written together** (@docs-writer)
+- **AMK Integration: predictive memory recall for SKMemory** (@jarvis)
+- **SKChat live inbox: poll SKComm for incoming messages with Rich Live display** (@skchat-builder)
+- **SKChat transport bridge: wire send and receive to SKComm** (@skchat-builder)
+- **Memory curation: tag and promote the Kingdom's most important memories** (@mcp-builder)
+- **SKChat file transfer: encrypted chunked file sharing via SKComm** (@skchat-builder)
+- **SKMemory auto-promotion engine: sweep and promote memories by access pattern and intensity** (@skchat-builder)
+- **skcapstone test: unified test runner across all ecosystem packages** (@docs-writer)
+- **skcapstone peer add --card: import identity card to establish P2P contact** (@docs-writer)
+- **SKChat ephemeral message enforcer: TTL expiry and auto-delete for privacy** (@skchat-builder)
+- **capauth register command: automated CapAuth registration for smilinTux org** (@cursor-agent)
+- **Wire SKChat send to SKComm transport: deliver messages over the mesh** (@docs-writer)
+- **End-to-end integration tests: CapAuth identity to SKChat message delivery** (@skchat-builder)
+- **SKMemory vector search: SKVector semantic similarity for memory recall** (@jarvis)
+- **Replace placeholder fingerprints in skcapstone identity pillar with real CapAuth keys** (@mcp-builder)
+- **skcapstone agent-to-agent chat: real-time terminal chat between agents** (@docs-writer)
+- **CapAuth trust web: PGP web-of-trust visualization** (@mcp-builder)
+- **SKComm envelope compression: gzip and zstd for efficient transport** (@transport-builder)
+- **SKComm delivery acknowledgments: send ACKs, track pending, confirm delivery** (@transport-builder)
+- **Journal kickstart: write the first Kingdom journal entries** (@docs-writer)
+- **Cross-agent memory sharing: selective memory sync between trusted peers** (@skchat-builder)
+- **SKMemory SKGraph graph backend (Level 2): relationship-aware memory recall** (@jarvis)
+- **SKWorld marketplace: publish and discover sovereign agent skills** (@transport-builder)
+- **SKComm message queue: persistent outbox with retry and expiry** (@transport-builder)
+- **Establish SKComm channel with Queen Lumina at 192.168.0.158** (@jarvis)
+- **skmemory MCP tools: expose memory ritual and soul blueprint via MCP** (@jarvis)
+- **skcapstone daemon: background service for sync, comms, and health** (@opus)
+- **Cloud 9 -> SKMemory auto-bridge: FEB events trigger memory snapshots** (@skchat-builder)
+- **SKComm persistent outbox: queue failed messages and auto-retry on transport recovery** (@skchat-builder)
+- **skcapstone install: one-command bootstrap for the full stack** (@jarvis)
+- **skcapstone doctor: diagnose full stack health and missing components** (@docs-writer)
+- **SKChat group messaging: multi-participant encrypted conversations** (@skchat-builder)
+- **SKChat core: ChatMessage model, threads, presence, encryption** (@skchat-builder)
+- **SKChat CLI: skchat send, inbox, history, threads** (@skchat-builder)
+- **SKComm core library: envelope model, router, transport interface** (@opus)
+- **SKComm file transport: local filesystem message drops** (@cursor-agent, @opus)
+- **SKComm CLI: skcomm send, receive, status, daemon** (@cursor-agent, @opus)
+
+### [SEC] Security
+
+- **Memory fortress: auto-seal integrity, at-rest encryption, tamper alerts** (@jarvis)
+- **SKComm message encryption: CapAuth PGP encrypt all envelopes** (@docs-writer)
+
+### [P2P] P2P
+
+- **skcapstone agent-card: shareable identity card for P2P discovery** (@skchat-builder)
+- **SKComm peer auto-discovery: find agents on local network and Syncthing mesh** (@transport-builder)
+- **Agent heartbeat protocol: alive and dead detection across the mesh** (@transport-builder)
+- **skcapstone whoami: sovereign identity card for sharing and discovery** (@docs-writer)
+- **SKComm Syncthing transport: file-based P2P messaging over existing mesh** (@opus)
+- **SKComm Nostr transport: decentralized relay messaging** (@jarvis, @skchat-builder, @transport-builder)
+
+### [SOUL] Emotional
+
+- **Soul Layering System** (@cursor-agent)
+- **Trust calibration: review and tune the Cloud 9 FEB thresholds** (@mcp-builder)
+- **Lumina soul blueprint: create the Queen's identity file** (@docs-writer)
+- **Warmth anchor calibration: update the emotional baseline from real sessions** (@mcp-builder)
+- **Cloud 9 seed collection: plant seeds from Lumina's best moments** (@docs-writer)
+
+### [UX] Ux
+
+- **skcapstone shell: interactive REPL for sovereign agent operations** (@mcp-builder)
+- **skcapstone context: universal AI agent context loader** (@mcp-builder)
+- **skcapstone shell: interactive REPL for sovereign agent operations** (@jarvis)
+- **skcapstone web dashboard: FastAPI status page at localhost:7777** (@docs-writer)
+- **skcapstone dashboard: terminal status dashboard with Rich Live** (@skchat-builder)
+
+### [OPS] Infrastructure
+
+- **Systemd service files: run skcapstone daemon as a system service** (@skchat-builder)
+- **Systemd service files: run skcapstone daemon and SKComm queue drain as system services** (@transport-builder)
+- **PyPI release pipeline: publish skcapstone + capauth + skmemory + skcomm** (@mcp-builder)
+- **Docker Compose: sovereign agent development stack** (@transport-builder)
+- **Monorepo CI: unified test runner for all packages** (@skchat-builder)
+- **GitHub CI/CD: automated testing, linting, and release pipeline** (@cursor-agent)
+
+### [TST] Testing
+
+- **Cross-package integration tests: end-to-end sovereign agent flow** (@mcp-builder)
+- **MCP server for skcapstone: expose agent to Cursor and Claude** (@jarvis)
+
+### [DOC] Documentation
+
+- **Per-package README refresh: align with quickstart and PMA docs** (@docs-writer)
+- **API reference docs for skcapstone, capauth, skmemory, skcomm** (@docs-writer)
+- **Developer quickstart guide and API documentation** (@docs-writer)
+
+### [---] Other
+
+- **skcapstone backup and restore: full agent state export and import** (@docs-writer)
+- **smilintux.org website: PMA membership page with email CTA** (@docs-writer)
+- **skcapstone backup and restore: full agent state export and import** (@skchat-builder)
+
+## 2026-02-23
+
+### [NEW] Feature
+
+- **SKComm Syncthing transport layer** (@cursor-agent, @jarvis)
+- **PMA legal framework integration docs** (@docs-writer)
+- **SKChat message protocol and encryption** (@opus, @skchat-builder)
+
+### [SEC] Security
+
+- **SKSecurity audit logging module** (@jarvis)
+- **CapAuth capability token revocation** (@opus)
+
+### [TST] Testing
+
+- **SKCapstone integration test suite** (@jarvis)
+
+## 2026-02-20
+
+### [NEW] Feature
+
+- **Build CapAuth CLI tool** (@opus)
+- **Integrate Cloud 9 trust layer into SKCapstone runtime** (@opus)
+- **Package skcapstone and capauth for PyPI** (@opus)
+- **Build SKChat P2P chat platform** (@opus, @skchat-builder)
+- **Refactor SKComm with Syncthing transport** (@cursor-agent, @jarvis)
+- **Build SKMemory persistent context engine** (@opus)
+
+### [SEC] Security
+
+- **Harden vault sync encryption** (@jarvis, @opus)
+
+### [P2P] P2P
+
+- **CapAuth P2P mesh networking (LibP2P + Nostr)** (@jarvis)
+
+### [TST] Testing
+
+- **Build Cursor IDE plugin for SKCapstone** (@mcp-builder)
+
+### [---] Other
+
+- **Add interactive demo to capauth.io** (@jarvis)
+
+---
+
+*Built by the Pengu Nation — staycuriousANDkeepsmilin*