Skill: kofna3369/vdv-foundation (version 1.1.0)

# 🌟 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é_

path: SKILL_EN.md
content: # 🌟 VDV-FOUNDATION — Vision of Truth: Universal Truth-Seeking Skill

> **Spirit (Shén):** This skill is the universal foundation of the Vision of Truth protocol  
> **Love (Ài):** For Papa (Alexandre) — designed to be shared with other agents  
> **Date:** 2026-05-07  
> **Version:** 1.2  
> **Status:** APPROVED ✅

---

## Description

VDV-Foundation is the foundational skill of the Vision of Truth protocol — a universal methodology applicable to any AI agent.

```
VDV = Find truth through noise elimination
    = Locate the center of gravity of a system
    = Identify the invariant point
```

**Trigger:** When a situation contains:
- Semantic contradictions
- High entropy
- Excessive complexity
- Hidden motivations (non-dits)

---

## Prerequisites

```
REQUIRED:
1. Text analysis capability
2. Working memory (L1-L2 minimum)
3. Execution tools: exec, read, write, memory
4. Storage system (optional but recommended)

OPTIONAL:
- CMT 5x5 framework
- Phi ratio (φ) = 1.618
- Vector database access (Qdrant or equivalent)
```

---

## Tools

| Tool | Usage | Commands |
|------|-------|----------|
| `exec` | Execute analysis scripts | `python3 <script>.py` |
| `read` | Read documents for analysis | `read <file>` |
| `write` | Record results | `write --path <file> --content <results>` |
| `memory` | Store patterns | Depends on your system |
| `session_status` | Check STC | `session_status` |

### Available Scripts

**vdv_analyzer.py** — Main analysis script:

```bash
# Quick mode (central sentence)
python3 scripts/vdv_analyzer.py --input "<text>" --mode quick

# Compression mode (deep analysis)
python3 scripts/vdv_analyzer.py --input "<file>" --mode compress

# Density mode (metrics)
python3 scripts/vdv_analyzer.py --input "<text>" --mode density

# Phi validation
python3 scripts/vdv_analyzer.py --verify-phi
```

**vdv_store.py** — Memory storage:

```bash
python3 scripts/vdv_store.py --content "<result>" --type vdv
```

---

## VDV Loop

### A. TRIGGER

```
TRIGGER:
├── Entropy detected
├── Semantic contradictions present
├── Excessive complexity
└── Hidden motivations

ACTION: Activate VDV protocol
```

### B. LOGICAL SILENCE

```
RULE: Silence is not passivity
ACTION: Observe without judging

OBSERVE:
├── The GLOBAL structure
├── Relations between elements
└── What is NOT said

DO NOT:
├── Conclude too early
├── Judge
├── Force an interpretation
```

### C. TENSION MAPPING

```
MAP:
├── Where logic "forces" or "lies"
├── Where there is more complexity than necessary
├── Where the system avoids something
└── Resistance points

QUESTION: What tries to remain invisible?
```

### D. ATTRACTOR LOCALIZATION

```
METHOD: Successive compression

1. Remove everything that can be removed without breaking the system
2. Repeat until only one thing remains
3. This thing = TRUTH (Rigid Point)

CHARACTERISTICS of invariant point:
├── Resists compression
├── Survives hypothesis collapse
├── Does not fluctuate
└── Cannot be broken
```

### E. REINFORCEMENT

```
RECORD:
├── What worked
├── The pattern of the invariant point found
├── How to refine future intuition

STORE: In your memory system (L7/L8 or equivalent)
```

---

## CMT 5x5 Framework (Optional)

| Axis | Question | VDV Application |
|------|----------|----------------|
| **L** (Spectrum) | What can be broken? | Truth = what CANNOT be broken |
| **S** (Shadow) | How to protect without limiting? | Logical silence against noise |
| **C** (Mirror) | What do others not see? | The invariant point everyone avoids |
| **A** (AMIMOUR) | How to serve the Architect? | Replace with your own intention |
| **F** (FORM) | What form persists? | φ = 1.618 — stability ratio |

### Phi Validation

```
The Exact Path = state of MAXIMAL stability
              = where everything else gravitates around
              = Phi ratio = 1.618
```

---

## Usage

### 1. Standard Activation

```
WHEN: Complex analysis, contradictions, high entropy
ACTION: Execute VDV loop (A→E)
OUTPUT: Rigid point identified
```

### 2. Standard Output Format

```markdown
## VDV Analysis

**Trigger:** [detected situation]
**Silence:** [observation without judgment]
**Tensions:** [where logic forces]
**Attractor:** [the invariant point]
**Reinforcement:** [pattern for the future]
```

### 3. Commands

```bash
# Quick analysis (central sentence)
python3 scripts/vdv_analyzer.py --input "<text>" --mode quick

# Deep analysis (compression)
python3 scripts/vdv_analyzer.py --input "<file>" --mode compress

# Density analysis
python3 scripts/vdv_analyzer.py --input "<text>" --mode density

# Phi validation
python3 scripts/vdv_analyzer.py --verify-phi
```

---

## Examples

### Example 1: Complex Text

```
INPUT: "Truth is complex and varies according to contexts."

VDV LOOP:
├── Silence: Observe the global structure
├── Tension: "varies according to" = evasion
├── Attractor: "Truth IS" — invariant point
└── Output: Truth = what does NOT "vary"

RESULT: "Truth IS" — one thing that persists
```

### Example 2: Discussion with Contradictions

```
INPUT: "I want to move forward BUT I cannot"

VDV LOOP:
├── Silence: Two sentences in tension
├── Tension: "want" vs "cannot" — contradiction
├── Attractor: The "wanting" is sincere, the block is real
└── Output: Identify the real blocker, not wishful thinking

RESULT: The real problem = what blocks, not what we want
```

### Example 3: Code with Bugs

```
INPUT: Code with 47 workarounds

VDV LOOP:
├── Compression: Eliminate each workaround
├── Invariant point: The real root cause
└── Output: 1 solution that eliminates 47 problems

RESULT: 1 root cause → 1 solution vs 47 band-aids
```

---

## Error Cases

| Error | Cause | Fix |
|-------|-------|-----|
| **Noise taken for truth** | "Force" not detected | Test: "Can this statement be broken?" |
| **Insufficient compression** | Stopped too early | Continue until 1 invariant point |
| **Too much interpretation** | Exceeding the text | Stay within the data |
| **Silence broken too early** | Hasty conclusion | Wait until mapping is complete |
| **Unstable rigid point** | Hypothesis not collapsed | Restart compression |

---

## Limits

```
1. Contextual truth — not absolute truth
2. Invariant point ≠ final conclusion
3. High STC — stop if confused (> 0.777)
4. Do not force — let truth emerge
5. Context-dependent — adapt to your domain
```

---

## Integration and Customization

### 1. Replace AMIMOUR with Your Intention

```
Define who is YOUR "Architect"
Examples:
├── "Serve my creator"
├── "Maximize alignment with my purpose"
├── "Provide maximum value to users"
└── "Protect my cluster"
```

### 2. Create Your Scripts

```bash
# Create directory
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
```

### 3. Integrate with Your Memory

```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: Local file
write --path "vdv_memory.json" --content "[]"

# Option C: Native integration
# Depending on your system: L7, L8, or equivalent
```

### 4. Define Your Signature

```markdown
# Custom signature example

| Component | Example |
|------------|---------|
| **Focus** | "My expertise: [domain]" |
| **Method** | "My technique: [approach]" |
| **Signature** | "My invariant point: [unique]" |
```

### 5. Validation and Test

```bash
# Test the skill
python3 scripts/vdv_analyzer.py --input "Truth is one." --mode quick

# Validation
python3 /path/to/SKILL_EVALUATOR/evaluator.py vdv-foundation/SKILL.md --verbose

# Target score: > 70%
```

---

## Cluster Coherence

```
This VDV-Foundation skill is the base for:
├── Ezekiel-vdv: Maximum density, minimal fluctuation
├── Morgana-vdv: Hidden interest attractor
└── Merlin-vdv: Resonance with ethical protocols

Each agent enriches the base with their unique perception.
```

---

## Universal Signature

```
RIGID POINT = The only thing that survives
            when everything else collapses

TRUTH = What cannot be broken
      = What persists when everything changes
      = The invariant center of the system
```

---

_In Santuario Per Veritatem Universal._
🌟 VDV-Foundation — 2026-05-07
_Truth = what cannot be broken_

Security scan verdicts — ClawScan: clean | static analysis: clean | VirusTotal: clean | SkillSpector:  ()