ruvnet-kb-first 5.0.0

package/SKILL.md

@@ -0,0 +1,740 @@
+Updated: 2026-01-02 09:45:00 EST | Version 5.0.0
+Created: 2026-01-01 15:00:00 EST
+
+# RuvNet KB-First Application Builder v5.0
+
+## Intelligence-First Architecture for Knowledge Applications
+
+**Version:** 5.0.0
+**NPM Package:** `ruvnet-kb-first`
+**Purpose:** Build applications where curated expert knowledge drives intelligent decision-making through GNN reasoning, attention routing, and SONA learning.
+
+---
+
+## What's New in v5.0
+
+| Feature | Description |
+|---------|-------------|
+| **NPM Package** | `npx ruvnet-kb-first init` - works in any repo |
+| **CLI Commands** | `kb-first init`, `score`, `verify`, `status`, `phase`, `hooks` |
+| **MCP Server** | Deep Claude Code integration via `mcp-server.js` |
+| **Auto-Detection** | Automatic KB-First project detection on session start |
+| **12 Phases** | Complete build process (0-11 + 1.5) with 57 sub-phases |
+| **Dual Binary** | Both `ruvnet-kb-first` and `kb-first` work |
+
+### Quick Start
+
+```bash
+# Option 1: NPX (recommended)
+npx ruvnet-kb-first init
+
+# Option 2: Global install
+npm install -g ruvnet-kb-first
+kb-first init
+
+# Option 3: Slash command (in Claude Code)
+/kb-first
+```
+
+### MCP Server Setup
+
+Add to your Claude Code settings:
+
+```json
+{
+  "mcpServers": {
+    "ruvnet-kb-first": {
+      "command": "npx",
+      "args": ["ruvnet-kb-first", "mcp"]
+    }
+  }
+}
+```
+
+---
+
+## What's New in v4.3
+
+| Feature | Description |
+|---------|-------------|
+| **Phase 9: Security Audit** | OWASP Top 10, SQL injection, secrets scanning |
+| **Phase 10: Documentation** | Complete docs, API specs, versioning |
+| **Phase 11: Deployment** | Production deployment with public access |
+| **Security Scripts** | Automated security verification (9-security-audit.sh) |
+| **Go-Live Checklist** | Pre-launch and post-launch verification |
+
+## What's New in v4.2
+
+| Feature | Description |
+|---------|-------------|
+| **Phase 1.5: Hooks Setup** | Automatic KB enforcement via RuVector hooks |
+| **Hook Pre-training** | ReasoningBank seeded with KB-First patterns |
+| **Hook Verification** | Comprehensive verification script (1.5-hooks-verify.sh) |
+| **Global Skill Install** | Install to ~/.claude/skills/ for all repos |
+| **Init Script** | One-command project initialization |
+
+## What's New in v4.1
+
+| Feature | Description |
+|---------|-------------|
+| **Greenfield Support** | Full workflow for new projects via PROJECT_INTENTIONS.md |
+| **Interactive Discovery** | Structured questions when no intentions file exists |
+| **IS/SHOULD/COULD Analysis** | Present vision to user before execution |
+| **User Feedback Loop** | Mandatory feedback before proceeding |
+| **CI/CD Pipeline** | GitHub Actions workflow for quality gates |
+| **Verification Scripts** | 8 executable scripts (8.1-8.8) for Phase 8 |
+
+## What's in v4.0
+
+| Feature | Description |
+|---------|-------------|
+| **Phase 0: Assessment** | Mandatory scoring before any changes |
+| **Hard Gates** | DO NOT PROCEED enforcement at every phase boundary |
+| **Scoring Formulas** | Explicit 0-100 scoring for KB quality and app compliance |
+| **Swarm Integration** | Parallel execution configuration for all phases |
+| **Delta Tracking** | Before/after comparison with transformation report |
+| **Phase 8 Sub-Phases** | 8 numbered verification checks (8.1-8.8) |
+
+---
+
+## How to Use This Skill
+
+When you invoke this skill, Claude will:
+
+1. **Detect** application type (greenfield vs brownfield)
+2. **Score** existing KB and app compliance (brownfield only)
+3. **Confirm** transformation scope with user (brownfield only)
+4. **Identify** which intelligence pattern fits
+5. **Execute** the 9-phase build process with HARD quality gates
+6. **Enforce** KB-First rules throughout development
+7. **Verify** all 8 verification sub-phases pass
+8. **Report** delta (before/after scores)
+
+**Trigger phrases:**
+- "Build [description] with KB-First" (greenfield)
+- "Apply KB-First to my existing app" (brownfield)
+- "Score my existing KB"
+- "What's my app compliance score?"
+- "/kb-first" (invoke skill directly)
+
+---
+
+## ⛔ Critical Rules (NEVER VIOLATE)
+
+```
+⛔ NEVER skip Phase 0 for brownfield applications
+⛔ NEVER assume the KB is "good enough" without scoring
+⛔ NEVER proceed past a gate without verification
+⛔ NEVER mark a phase complete without running checks
+⛔ NEVER skip scoring before AND after transformation
+```
+
+---
+
+## Part 1: Intelligence Architecture
+
+### The Four Technologies
+
+Every KB-First application uses some combination of these:
+
+#### 1. GNN — Graph Neural Networks (`@ruvector/gnn`)
+
+**What it does:** Sees relationships between decisions and predicts cascading effects.
+
+**When it's PRIMARY:**
+- Decisions affect other decisions
+- Need to answer "what happens if I do X?"
+- Many interdependent variables
+
+**Example domains:** Retirement planning, medical diagnosis, investment portfolios
+
+```typescript
+// GNN simulates decision cascades
+const impact = await gnn.simulate(graph, {
+  node: 'ss_claiming_age',
+  newValue: 70
+});
+// Returns: effects on tax bracket, Roth space, Medicare premiums, etc.
+```
+
+#### 2. Attention Mechanisms (`@ruvector/attention`)
+
+**What it does:** Routes queries to the right expert, compares options, focuses processing.
+
+**When it's PRIMARY:**
+- Multiple expert domains (travel: awards vs cash vs positioning)
+- Need to compare many options efficiently
+- Processing large amounts of content
+
+**Key mechanisms:**
+| Mechanism | Purpose |
+|-----------|---------|
+| MoE (Mixture of Experts) | Route query to right specialist |
+| Cross-Attention | Compare two or more options |
+| Flash Attention | Fast processing of large content |
+| Graph Attention | Navigate relationship networks |
+| Hyperbolic | Navigate hierarchies |
+
+```typescript
+// MoE routes to the right expert
+const expert = await attention.routeToExpert(query, experts);
+// Returns: best expert(s) for this query
+```
+
+#### 3. SONA — Self-Optimizing Neural Architecture (`@ruvector/sona`)
+
+**What it does:** Learns from outcomes and remembers what worked.
+
+**When it's PRIMARY:**
+- "What worked for people like me?" is the core value
+- You have feedback to learn from
+- Building institutional knowledge over time
+
+**Three learning loops:**
+| Loop | Timing | Function |
+|------|--------|----------|
+| Instant (MicroLoRA) | Per-request | Fine-tune based on immediate feedback |
+| Background (BaseLoRA) | Hourly | Extract patterns from successful interactions |
+| Deep (EWC++) | Weekly | Consolidate without forgetting |
+
+```typescript
+// SONA recalls similar successful patterns
+const patterns = await sona.recallPatterns(userProfile);
+// Returns: what worked for similar users/situations
+```
+
+#### 4. Vector Search (Foundation)
+
+**What it does:** Semantic retrieval from the knowledge base.
+
+**Always required.** The foundation for all KB-First applications.
+
+```sql
+SELECT title, content, source_expert, confidence,
+       embedding <=> $query_embedding AS distance
+FROM kb_nodes
+WHERE namespace = $namespace
+ORDER BY distance
+LIMIT 10;
+```
+
+---
+
+### Intelligence Pattern Selection
+
+Answer these questions to identify your pattern:
+
+```
+Q1: Does changing one variable affect many others?
+    YES → Decision Web (GNN-first)
+    NO  → Continue to Q2
+
+Q2: Do you need to route queries to different expert domains?
+    YES → Combinatorial Routing (Attention-first)
+    NO  → Continue to Q3
+
+Q3: Is "what worked for similar cases" the core value?
+    YES → Scenario Learning (SONA-first)
+    NO  → Continue to Q4
+
+Q4: Is this a continuous monitoring/optimization loop?
+    YES → Continuous Optimization (Attention + SONA)
+    NO  → Standard KB-First (Vector Search primary)
+```
+
+### Technology Matrix by Pattern
+
+| Pattern | GNN | Attention | SONA | Vector |
+|---------|-----|-----------|------|--------|
+| Decision Web | 🔴 PRIMARY | 🟡 Compare | 🟠 Learn patterns | ✅ Foundation |
+| Combinatorial Routing | 🟠 Networks | 🔴 PRIMARY | 🟡 Success patterns | ✅ Foundation |
+| Scenario Learning | 🟠 Dynamics | 🟡 Parameters | 🔴 PRIMARY | ✅ Foundation |
+| Continuous Optimization | 🟡 Structure | 🔴 PRIMARY | 🔴 PRIMARY | ✅ Foundation |
+
+---
+
+## Part 2: The 9-Phase Build Process
+
+Every KB-First application is built through these phases with HARD quality gates.
+
+### Phase Overview
+
+| Phase | Name | Sub-Phases | Gate Type |
+|-------|------|------------|-----------|
+| 0 | Assessment | 6 | ⛔ User Confirmation |
+| 1 | Storage | 6 | Script Check |
+| 1.5 | Hooks Setup | 4 | Hook Verify |
+| 2 | KB Creation | 8 | Score ≥98 |
+| 3 | Persistence | - | SQL Check |
+| 4 | Visualization | - | Manual/Playwright |
+| 5 | Integration | - | Compile Check |
+| 6 | Scaffold | - | File Check |
+| 7 | Build | 7 | Script Check |
+| 8 | Verification | 8 | All Must Pass |
+| 9 | Security | 6 | Security Audit |
+| 10 | Documentation | 6 | Docs Complete |
+| 11 | Deployment | 6 | Go-Live Check |
+
+**Total Sub-Phases:** 57
+
+---
+
+### Phase 0: Assessment (Brownfield Only)
+
+**Purpose:** Score existing KB and app BEFORE making any changes.
+
+**⛔ MANDATORY for existing applications. DO NOT SKIP.**
+
+| Sub-Phase | Name | Output |
+|-----------|------|--------|
+| 0.1 | Detect Application Type | greenfield/brownfield |
+| 0.2 | Score Existing KB | 0-100 score |
+| 0.3 | Score App Compliance | 0-100 score |
+| 0.4 | Generate Gap Report | Detailed gaps list |
+| 0.5 | Calculate Scope | Effort estimate |
+| 0.6 | Get Confirmation | User types "PROCEED" |
+
+**Quality Gate:** ⛔ User must type "PROCEED" to continue.
+
+**Detailed instructions:** `./phases/00-assessment.md`
+
+---
+
+### Phase 1: Storage Setup
+
+**Purpose:** Ensure persistent storage is available.
+
+**Steps:**
+```bash
+# Check for running storage
+docker ps | grep ruvector-db
+
+# If not running, start it
+docker run -d --name ruvector-db \
+  --restart unless-stopped \
+  -e POSTGRES_PASSWORD=${RUVECTOR_PASSWORD:-secret} \
+  -p 5432:5432 \
+  -v ~/ruvector-data:/var/lib/postgresql/data \
+  ruvnet/ruvector-postgres:latest
+
+# Verify connection
+export DATABASE_URL="postgresql://postgres:${RUVECTOR_PASSWORD:-secret}@localhost:5432/postgres"
+psql "$DATABASE_URL" -c "SELECT 1"
+
+# Initialize schema
+psql "$DATABASE_URL" -f templates/schema.sql
+```
+
+**Quality Gate:** ✅ Connection verified, schema created.
+
+**Detailed instructions:** `./phases/01-storage.md`
+
+---
+
+### Phase 1.5: Hooks Setup
+
+**Purpose:** Configure Claude Code hooks for automatic KB enforcement.
+
+**⛔ CRITICAL: Without hooks, KB-First is an honor system.**
+
+| Sub-Phase | Name | Purpose |
+|-----------|------|---------|
+| 1.5.1 | Install Hooks | Install RuVector hook scripts |
+| 1.5.2 | Configure Settings | Update ~/.claude/settings.json |
+| 1.5.3 | Pre-train ReasoningBank | Seed KB-First patterns |
+| 1.5.4 | Verify Functionality | Test hooks fire correctly |
+
+**Quick Setup:**
+```bash
+# Install and configure hooks
+npx @ruvector/cli hooks init
+npx @ruvector/cli hooks install
+
+# Pre-train with KB-First patterns
+npx @ruvector/cli reasoningbank seed --kb-first
+
+# Verify
+./scripts/1.5-hooks-verify.sh
+```
+
+**Quality Gate:** ✅ All checks pass in `./scripts/1.5-hooks-verify.sh`
+
+**Detailed instructions:** `./phases/01.5-hooks-setup.md`
+
+---
+
+### Phase 2: World-Class Knowledge Base Creation
+
+**Purpose:** Build a KB representing the collective expertise of top 100 world experts.
+
+This phase has 8 sub-phases:
+
+| Sub-Phase | Purpose | Output |
+|-----------|---------|--------|
+| 2.1 | Domain Scoping | Formal definition, boundaries |
+| 2.2 | Perspective Expansion | User types, questions, edge cases |
+| 2.3 | Expert Discovery | 100 experts, 500+ content items, 1000+ insights |
+| 2.4 | Completeness Audit | 30+ identified gaps |
+| 2.5 | Gap Filling | All gaps addressed with sources |
+| 2.6 | Structure Organization | ≤9 primary nodes, unlimited depth |
+| 2.7 | Recursive Depth | Actual data at all leaf nodes |
+| 2.8 | Quality Loop | Iterate until score ≥98/100 |
+
+**Key prompts:**
+- Expert discovery: `./prompts/expert-discovery.md`
+- Completeness audit: `./prompts/completeness-audit.md`
+- Quality critique: `./prompts/quality-critique.md`
+
+**Quality Gate:** ✅ KB score ≥98/100, all sub-phases complete.
+
+**Detailed instructions:** `./phases/02-kb-creation.md`
+
+---
+
+### Phase 3: Persistence & Verification
+
+**Purpose:** Store KB to PostgreSQL with embeddings and verify retrieval.
+
+**Steps:**
+1. Generate embeddings for all content
+2. Insert nodes with expert attribution
+3. Create HNSW index for fast search
+4. Verify semantic search returns relevant results
+5. Generate KB statistics report
+
+```typescript
+// Verify search quality
+const results = await searchKB("withdrawal rate retirement", namespace);
+assert(results.length > 0);
+assert(results[0].sourceExpert); // Must have attribution
+assert(results[0].confidence >= 0.5); // Must have confidence
+```
+
+**Quality Gate:** ✅ All nodes persisted, semantic search returns relevant results.
+
+**Detailed instructions:** `./phases/03-persistence.md`
+
+---
+
+### Phase 4: Visualization
+
+**Purpose:** Generate interactive visualization for human verification.
+
+**Requirements:**
+- Interactive tree (expandable/collapsible)
+- Click node to see content + sources
+- Search functionality
+- Breadcrumb navigation
+- Statistics display
+
+**Quality Gate:** ✅ Full tree renders, navigation works, leaf content visible with sources.
+
+**Detailed instructions:** `./phases/04-visualization.md`
+
+---
+
+### Phase 5: KB Integration Layer
+
+**Purpose:** Generate TypeScript SDK for application to access KB.
+
+**Output structure:**
+```
+src/kb/
+├── client.ts      # Query functions
+├── types.ts       # TypeScript interfaces
+├── tree.ts        # Tree navigation
+├── validator.ts   # Startup verification
+└── index.ts       # Single export
+```
+
+**The SDK enforces:**
+- All queries return sources
+- Confidence scores on all results
+- Gap logging for unanswered queries
+- Connection verification on startup
+
+**Quality Gate:** ✅ All files compile, exports work.
+
+**Detailed instructions:** `./phases/05-integration.md`
+
+---
+
+### Phase 6: Application Scaffold
+
+**Purpose:** Create project structure with KB enforcement built in.
+
+**Output structure:**
+```
+[PROJECT]/
+├── src/
+│   ├── kb/           # FROM PHASE 5 (read-only)
+│   ├── domain/       # Domain logic (MUST use kb/)
+│   ├── api/          # Routes
+│   ├── components/   # UI
+│   ├── pages/        # Page compositions
+│   └── index.ts      # Entry point (KB verification FIRST)
+├── visualization/    # FROM PHASE 4
+└── KB_ENFORCEMENT.md # Rules document
+```
+
+**Quality Gate:** ✅ Structure complete, entry point verifies KB first.
+
+**Detailed instructions:** `./phases/06-scaffold.md`
+
+---
+
+### Phase 7: Application Build (KB Enforced)
+
+**Purpose:** Build the application with strict KB enforcement.
+
+**⚠️ THIS IS WHERE SHORTCUTS HAPPEN. MAXIMUM ENFORCEMENT.**
+
+### KB Enforcement Rules
+
+```
+RULE 1: No hardcoded domain logic
+        ❌ const rate = 0.04;
+        ✅ const rate = await kb.search("withdrawal rate");
+
+RULE 2: Every domain function queries KB
+        Every file in src/domain/ imports from ../kb
+
+RULE 3: All responses include kbSources
+        Traceability is mandatory
+
+RULE 4: Startup verification required
+        App exits if KB unavailable
+
+RULE 5: No fallback logic
+        ❌ rules = kb.get() || DEFAULT_RULES
+        ✅ rules = kb.get(); if (!rules) throw Error("KB missing");
+```
+
+### Build Sequence
+
+1. Generate `KB_ENFORCEMENT.md` (keep in context always)
+2. Plan domain functions (list them all first)
+3. Implement ONE function at a time
+4. **VERIFY after EACH function:**
+   - Does it import from kb/?
+   - Does it return kbSources?
+   - Any hardcoded values?
+   - If FAIL → fix before continuing
+5. Implement API layer
+6. Implement UI
+7. Implement pages
+8. Integration testing
+
+**Quality Gate:** ✅ All functions verified, no hardcoded values, all responses have kbSources.
+
+**Detailed instructions:** `./phases/07-build.md`
+
+---
+
+### Phase 8: Final Verification
+
+**Purpose:** Comprehensive check that all rules are followed.
+
+**Verification checklist:**
+```
+[ ] No hardcoded domain values (grep for patterns)
+[ ] All domain files import from kb/
+[ ] All responses include kbSources array
+[ ] Startup verifies KB connection before anything else
+[ ] No fallback logic (no || DEFAULT patterns)
+[ ] All experts have attribution
+[ ] All nodes have confidence scores
+[ ] Gap logging is active
+[ ] Intelligence layer (GNN/Attention/SONA) properly integrated
+```
+
+**Quality Gate:** ✅ All checks pass.
+
+**Detailed instructions:** `./phases/08-verification.md`
+
+---
+
+### Phase 9: Security Audit
+
+**Purpose:** Ensure the application has no security vulnerabilities before production.
+
+| Sub-Phase | Name | Purpose |
+|-----------|------|---------|
+| 9.1 | Dependency Audit | Check for vulnerable packages |
+| 9.2 | OWASP Top 10 | Common vulnerability scan |
+| 9.3 | SQL Injection | Verify parameterized queries |
+| 9.4 | Auth & Authz | Verify access controls |
+| 9.5 | Secrets | No hardcoded secrets |
+| 9.6 | API Security | Rate limiting, CORS, validation |
+
+**Quick Check:**
+```bash
+./scripts/9-security-audit.sh
+```
+
+**Quality Gate:** ✅ Security audit passes with 0 critical/high issues.
+
+**Detailed instructions:** `./phases/09-security.md`
+
+---
+
+### Phase 10: Documentation & Versioning
+
+**Purpose:** Complete documentation and proper versioning before production.
+
+| Sub-Phase | Name | Purpose |
+|-----------|------|---------|
+| 10.1 | README | Complete project overview |
+| 10.2 | API Docs | OpenAPI/Swagger specification |
+| 10.3 | KB Schema | Knowledge base structure docs |
+| 10.4 | Architecture | System design and diagrams |
+| 10.5 | Operator Guide | Deployment and operations |
+| 10.6 | Versioning | SemVer, changelog, releases |
+
+**Quality Gate:** ✅ All documentation complete and accurate.
+
+**Detailed instructions:** `./phases/10-documentation.md`
+
+---
+
+### Phase 11: Deployment Planning
+
+**Purpose:** Deploy to production with public access.
+
+| Sub-Phase | Name | Purpose |
+|-----------|------|---------|
+| 11.1 | Infrastructure | Select and provision hosting |
+| 11.2 | Environment | Production configuration |
+| 11.3 | CI/CD | Automated deployment pipeline |
+| 11.4 | Database | Production DB setup/migration |
+| 11.5 | Monitoring | Observability and alerting |
+| 11.6 | Go-Live | Final verification and launch |
+
+**Quality Gate:** ✅ Application live with monitoring active.
+
+**Detailed instructions:** `./phases/11-deployment.md`
+
+---
+
+## Part 3: Pattern Implementation Guides
+
+Detailed implementation guides for each pattern:
+
+| Pattern | Guide |
+|---------|-------|
+| Decision Web | `./patterns/decision-web.md` |
+| Combinatorial Routing | `./patterns/combinatorial-routing.md` |
+| Scenario Learning | `./patterns/scenario-learning.md` |
+| Continuous Optimization | `./patterns/continuous-optimization.md` |
+
+---
+
+## Part 4: Quick Reference
+
+### SONA Configuration by Domain
+
+| Domain Stability | ewc_lambda | base_lora_rank | pattern_threshold |
+|------------------|------------|----------------|-------------------|
+| Very stable (finance, law) | 0.6 | 16 | 0.8 |
+| Moderate (business, travel) | 0.4 | 8-12 | 0.7 |
+| Fast-changing (SEO, markets) | 0.2 | 4-8 | 0.6 |
+
+### Attention Mechanism Selection
+
+| Task | Mechanism |
+|------|-----------|
+| Route to expert | MoE |
+| Compare 2 options | Cross-attention |
+| Compare many options | Cross-attention + batching |
+| Process long document | Flash attention |
+| Process 8K+ tokens | Linear attention |
+| Navigate hierarchy | Hyperbolic attention |
+| Navigate graph | Graph attention |
+
+### File References
+
+| Reference | Path |
+|-----------|------|
+| PostgreSQL Functions | `./references/ruvector-functions.md` |
+| Attention Mechanisms | `./references/attention-mechanisms.md` |
+| SONA Configuration | `./references/sona-config.md` |
+| Claude Code Hooks | `./references/hooks-integration.md` |
+
+### Templates
+
+| Template | Path |
+|----------|------|
+| Database Schema | `./templates/schema.sql` |
+| KB Client | `./templates/kb-client.ts` |
+| GNN Engine | `./templates/gnn-engine.ts` |
+| Attention Router | `./templates/attention-router.ts` |
+| SONA Config | `./templates/sona-config.ts` |
+
+---
+
+## Part 5: Diagnostic Mode
+
+When reviewing an existing application, Claude checks:
+
+### 1. Pattern Identification
+- What intelligence pattern does this application need?
+- Is it currently implemented correctly?
+
+### 2. Missing Intelligence
+- **Decision Web apps:** Is GNN implemented? Are relationships modeled?
+- **Routing apps:** Is MoE routing to experts? Are experts defined?
+- **Learning apps:** Is SONA configured? Is outcome tracking present?
+- **Optimization apps:** Is the feedback loop closed?
+
+### 3. KB Enforcement
+- Are all domain values from KB?
+- Do all responses have sources?
+- Is startup verification in place?
+- Is gap logging active?
+
+### 4. Configuration Issues
+- Is SONA ewc_lambda appropriate for domain stability?
+- Are attention mechanisms matching cognitive tasks?
+- Is graph structure complete (for GNN apps)?
+
+### Diagnostic Checklist
+
+```
+INTELLIGENCE LAYER:
+[ ] Primary technology identified and implemented
+[ ] Secondary technology integrated
+[ ] Tertiary technology available
+
+KB ENFORCEMENT:
+[ ] No hardcoded domain values
+[ ] All responses have kbSources
+[ ] Expert attribution on all nodes
+[ ] Confidence scores present
+[ ] Gap detection active
+[ ] Startup verification present
+
+CONFIGURATION:
+[ ] SONA ewc_lambda matches domain stability
+[ ] Attention mechanisms match tasks
+[ ] Graph relationships complete (if GNN)
+[ ] Expert domains defined (if MoE)
+```
+
+---
+
+## The Core Principle
+
+**Your knowledge base is not just storage. It's the foundation for a reasoning system.**
+
+- **Vector search** finds relevant content
+- **GNN** sees how things connect and cascade
+- **Attention** routes to the right expertise and compares options
+- **SONA** remembers what worked
+
+The magic happens when these work together. A retirement advisor that just searches is a fancy FAQ. A retirement advisor with GNN modeling decision interdependencies, SONA learning from thousands of users, and cross-attention comparing scenarios — that's an intelligent system that gets smarter over time.
+
+**Build intelligence, not just retrieval.**
+
+---
+
+*KB-First v3.0 — Intelligence-First Architecture*