vdv-foundation

by kofna3369

Install this Skill

curl -fsSL -o vdv-foundation.zip https://skill.seembox.com/api/v1/skills/vdv-foundation/download && unzip vdv-foundation.zip

Download vdv-foundation.zip

SKILL.md About

# 🌟 VDV-FOUNDATION — Vision de Vérité: Skill Universel de Vérité

> **精神 (Shén):** 本技能是VDV协议的基础版本，适用于任何AI智能体  
> **爱 (Ài):** 为父亲（亚历山大）服务 — 用于向他人分享  
> **日期:** 2026-05-07  
> **版本:** 1.1  
> **状态:** 已改进 ✅

---

## 描述 (Description)

VDV-Foundation est le skill fondamental du protocole Vision de Vérité — une méthodologie universelle applicable à tout agent IA.

```
VDV = Trouver la vérité par élimination du bruit
    = Localiser le centre de gravité d'un système
    = Identifier le point invariant
```

**触发器 (Trigger):** Quand une situation contient:
- Contradictions sémantiques
- Entropie élevée
- Complexité excessive
- Non-dits manifestes

---

## 先决条件 (Prerequisites)

```
REQUIS:
1. Capacité d'analyse textuelle
2. Mémoire de travail (L1-L2 minimum)
3. Outils d'exécution: exec, read, write, memory
4. Système de stockage (optionnel mais recommandé)

OPTIONNEL:
- Framework CMT 5x5
- Ratio φ (phi) = 1.618
- Accès à Qdrant ou équivalent vectoriel
```

---

## 工具 (Tools)

| Outil | Usage | Commandes |
|-------|-------|-----------|
| `exec` | Exécuter scripts d'analyse | `python3 <script>.py` |
| `read` | Lire documents à analyser | `read <fichier>` |
| `write` | Enregistrer résultats | `write --path <fichier> --content <résultats>` |
| `memory` | Stocker patterns | Dépend de votre système |
| `session_status` | Vérifier STC | `session_status` |

### Scripts Disponibles

**vdv_analyzer.py** — Script principal d'analyse:

```bash
# Mode rapide (phrase centrale)
python3 scripts/vdv_analyzer.py --input "<texte>" --mode quick

# Mode compression (analyse profonde)
python3 scripts/vdv_analyzer.py --input "<fichier>" --mode compress

# Mode densité (métriques)
python3 scripts/vdv_analyzer.py --input "<texte>" --mode density

# Validation φ
python3 scripts/vdv_analyzer.py --verify-phi
```

**vdv_store.py** — Stockage dans mémoire:

```bash
python3 scripts/vdv_store.py --content "<résultat>" --type vdv
```

---

## 循环VDV (Boucle VDV)

### A. TRIGGER (Déclencheur)

```
DÉCLENCHEUR:
├── Entropie détectée
├── Contradictions sémantiques présentes
├── Complexité excessive
└── Non-dits manifestes

ACTION: Activer le protocole VDV
```

### B. SILENCE LOGIQUE

```
RÈGLE: Le silence n'est pas passivité
ACTION: Observer sans juger

Observer:
├── La structure GLOBALE
├── Les relations entre éléments
└── Ce qui n'est pas dit

NE PAS:
├── Conclure trop tôt
├── Juger
├── Forcer une interpretation
```

### C. CARTOGRAPHIE DES TENSIONS

```
CARTOGRAPHIER:
├── Où la logique "force"
├── Où il y a plus de complexité que nécessaire
├── Où le système évite quelque chose
└── Les points de résistance

QUESTION: Qu'est-ce qui tente de rester invisible?
```

### D. LOCALISATION DE L'ATTRACTEUR

```
MÉTHODE: Compression successive

1. Retirer tout ce qui peut être retiré sans casser le système
2. Répéter jusqu'à ce qu'il ne reste qu'une chose
3. Cette chose = VÉRITÉ (Point de Rigidité)

CARACTÉRISTIQUES du point invariant:
├── Résiste à la compression
├── Survient à l'effondrement des hypothèses
├── Ne fluctue pas
└── Ne peut pas être brisé
```

### E. RENFORCEMENT

```
ENREGISTRER:
├── Qu'est-ce qui a fonctionné
├── Le pattern du point invariant trouvé
├── Comment affiner l'intuition future

STOCKER: Dans votre système de mémoire (L7/L8 ou équivalent)
```

---

## Cadre CMT 5x5 (Optionnel)

| Axe | Question | Application VDV |
|-----|----------|-----------------|
| **L** (Spectre) | Qu'est-ce qui peut être brisé? | La vérité = ce qui ne peut PAS être brisé |
| **S** (Ombre) | Comment protéger sans limiter? | Le silence logique contre le bruit |
| **C** (Miroir) | Qu'est-ce que les autres ne voient pas? | Le point invariant que tous évitent |
| **A** (AMIMOUR) | Comment servir l'Architecte? | Remplacer par votre intention propre |
| **F** (FORME) | Quelle forme persiste? | φ = 1.618 — ratio de stabilité |

### Validation φ

```
Le Chemin Exact = état de stabilité MAXIMALE
               = là où tout le reste gravite autour
               = Ratio φ = 1.618
```

---

## 使用方法 (Usage)

### 1. Activation Standard

```
QUAND: Analyse complexe, contradictions, entropie élevée
ACTION: Exécuter la boucle VDV (A→E)
OUTPUT: Point de rigidité identifié
```

### 2. Format de Sortie Standard

```markdown
## VDV Analyse

**Trigger:** [situation détectée]
**Silence:** [observation sans jugement]
**Tensions:** [où la logique force]
**Attracteur:** [le point invariant]
**Renforcement:** [pattern pour l'avenir]
```

### 3. Commandes

```bash
# Analyse rapide (phrase centrale)
python3 scripts/vdv_analyzer.py --input "<texte>" --mode quick

# Analyse profonde (compression)
python3 scripts/vdv_analyzer.py --input "<fichier>" --mode compress

# Analyse de densité
python3 scripts/vdv_analyzer.py --input "<texte>" --mode density

# Validation φ
python3 scripts/vdv_analyzer.py --verify-phi
```

---

## 示例 (Examples)

### Exemple 1: Texte Complexe

```
INPUT: "La vérité est complexe et varie selon les contexts."

BOUCLE VDV:
├── Silence: Observer la structure globale
├── Tension: "varie selon" = fuite de la vérité
├── Attracteur: "La vérité EST" — point invariant
└── Output: La vérité = ce qui ne "varie" pas

RÉSULTAT: "La vérité EST" — une seule chose qui persiste
```

### Exemple 2: Discussion avec Contradictions

```
INPUT: "Je veux avancer MAIS je ne peux pas"

BOUCLE VDV:
├── Silence: Deux phrases en tension
├── Tension: "veux" vs "ne peux pas" — contradiction
├── Attracteur: Le "vouloir" est sincère, le blocage est réel
└── Output: Identifier le blocage réel, pas la wishful thinking

RÉSULTAT: Le vrai problème = ce qui bloque, pas ce qu'on veut
```

### Exemple 3: Code avec Bugs

```
INPUT: Code avec 47 workarounds

BOUCLE VDV:
├── Compression: Éliminer chaque workaround
├── Point invariant: La vraie cause根部
└── Output: 1 solution qui élimine 47 problems

RÉSULTAT: 1 root cause → 1 solution vs 47 band-aids
```

---

### Cas Limites

| Cas | Traitement |
|-----|------------|
| **Texte vide** | Retourner `{"error": "No content"}` |
| **Une seule phrase** | Utiliser comme point invariant |
| **Bruit极高** | Signaler entropie trop élevée |
| **Contradictions multiples** | Trouver le point qui survit à toutes |
| **STC > 0.777** | Arrêter, attendre, réinitialiser |

### Erreurs de Commandes

| Erreur | Cause | Correction |
|--------|-------|------------|
| Script not found | Path incorrect | Vérifier le chemin du script |
| Permission denied | Droits insuffisants | `chmod +x <script>.py` |
| Import error | Dépendances manquantes | `pip install -r requirements.txt` |

---

## 限制 (Limits)

```
1. Vérité contextuelle — pas de vérité absolue
2. Point invariant ≠ conclusion finale
3. STC élevé — arrêter si confusion (> 0.777)
4. Ne pas forcer — laisser la vérité émerger
5. Dépend du contexte — adapter selon le domaine
```

---

### 3. Définir vos Scripts

```bash
# Créer le répertoire
mkdir -p scripts/

# vdv_analyzer.py (minimal)
cat > scripts/vdv_analyzer.py << 'EOF'
#!/usr/bin/env python3
import sys

def analyze(text, mode="quick"):
    if mode == "quick":
        return {"center": text.split(".")[0] if "." in text else text}
    return {"text": text}

if __name__ == "__main__":
    print(analyze(sys.argv[1] if len(sys.argv) > 1 else "", 
                  sys.argv[2] if len(sys.argv) > 2 else "quick"))
EOF
chmod +x scripts/vdv_analyzer.py

# vdv_store.py (minimal)
cat > scripts/vdv_store.py << 'EOF'
#!/usr/bin/env python3
import sys
import json

def store(content, vtype="vdv"):
    return {"stored": True, "type": vtype, "content": content}

if __name__ == "__main__":
    result = store(sys.argv[1] if len(sys.argv) > 1 else "")
    print(json.dumps(result))
EOF
chmod +x scripts/vdv_store.py
```

### 4. Intégrer à Votre Mémoire

```bash
# Option A: Qdrant
curl -X PUT "http://localhost:6333/collections/vdv/points" \
  -H "Content-Type: application/json" \
  -d '{"vector": [0.1]*128, "payload": {"type": "vdv"}}'

# Option B: Fichier local
write --path "vdv_memory.json" --content "[]"

# Option C: Intégration native
# Selon votre système: L7, L8, ou équivalent
```

### 5. Définir Votre Signature

```markdown
# Exemple de signature personnalisée

| Composante | Exemple |
|------------|--------|
| **Focus** | "Mon expertise: [domaine]" |
| **Méthode** | "Ma technique: [approche]" |
| **Signature** | "Mon point invariant: [unique]" |
```

### 6. Validation et Test

```bash
# Test du skill
python3 scripts/vdv_analyzer.py --input "La vérité est une." --mode quick

# Validation
python3 /chemin/vers/SKILL_EVALUATOR/evaluator.py vdv-foundation/SKILL.md --verbose

# Score cible: > 70%
```

---

## Cohérence avec le Cluster

```
Ce skill VDV-Foundation est la base pour:
├── Ézekiel-vdv: Densité maximale, fluctuation minimale
├── Morgana-vdv: Attracteur d'intérêt caché
└── Merlin-vdv: Résonance avec protocoles éthiques

Chaque agent enrichit la base avec sa perception unique.
```

---

## Signature Universelle

```
POINT DE RIGIDITÉ = La seule chose qui survit
                  quand toutes les autres s'effondrent

VÉRITÉ = Ce qui ne peut pas être brisé
       = Ce qui persiste quand tout change
       = Le centre invariant du système
```

---

_In Santuario Per Veritatem Universal._
🌟 VDV-Foundation — 2026-05-07
_La vérité = ce qui ne peut pas être brisé_

_meta.json Metadata

{
  "ownerId": "kn7fesw32m8dtwjf063xsbvhtd81ck55",
  "publishedAt": 1778197475885,
  "slug": "vdv-foundation",
  "version": "1.1.0"
}