feat(memory): add Auto Dream — REM-style consolidation cycle

.claude/hooks-examples/auto-dream.json

@@ -0,0 +1,51 @@
+{
+  "_comment": "Auto Dream hook for ulk — copy the 'hooks' block into your ~/.claude/settings.json. Spec : framework/agents/_shared/auto-dream-protocol.md. Cycle de consolidation mémoire inspiré du sommeil REM : merge doublons, normalise horodatages, archive obsolètes, reconstruit l'index. Conditions par défaut : 24h écoulées ET ≥5 sessions depuis le dernier cycle. Le hook lance le trigger en arrière-plan, ne bloque jamais la session.",
+
+  "_install": "Run ./install.sh --with-auto-dream to copy this file into your ~/.claude/hooks-examples/ folder + the trigger script into ~/.claude/hooks/. Then merge the hooks block manually into your ~/.claude/settings.json (this script does NOT modify your settings automatically — by design).",
+
+  "_requires": "framework/tools/hooks/auto-dream.sh installed in ~/.claude/hooks/auto-dream.sh (handled by --with-auto-dream).",
+
+  "hooks": {
+    "SessionStart": [
+      {
+        "_comment": "On session start, increment the session counter and trigger a dream cycle in background if conditions are met (24h + 5 sessions). Pure shell, 0 token cost. The cycle itself runs in background via `claude --headless` and never blocks the user session.",
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "test -x ~/.claude/hooks/auto-dream.sh && ~/.claude/hooks/auto-dream.sh tick >/dev/null 2>&1 || true"
+          }
+        ]
+      }
+    ]
+  },
+
+  "_environment": {
+    "_comment": "Override default thresholds via these env vars in your shell profile or ~/.claude/settings.json (env section).",
+    "AUTO_DREAM_MIN_HOURS": 24,
+    "AUTO_DREAM_MIN_SESSIONS": 5
+  },
+
+  "_commands": {
+    "_comment": "Manual control commands. The trigger script is also useful standalone.",
+    "status": "~/.claude/hooks/auto-dream.sh status",
+    "force_cycle": "~/.claude/hooks/auto-dream.sh force",
+    "reset_counter": "~/.claude/hooks/auto-dream.sh reset",
+    "natural_invocation": "Say 'consolidate my memory files' or 'lovecraft memory dream' inside any Claude Code session — same effect as the hook trigger but synchronous and visible."
+  },
+
+  "_alternative_strict_mode": {
+    "_comment": "Pour les utilisateurs qui veulent un cycle TRES fréquent (debug ou vault à fort turnover) : abaisse les seuils à 8h / 2 sessions. ⚠️ génère plus de churn git sur docs/_memory/.",
+    "SessionStart": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "AUTO_DREAM_MIN_HOURS=8 AUTO_DREAM_MIN_SESSIONS=2 ~/.claude/hooks/auto-dream.sh tick >/dev/null 2>&1 || true"
+          }
+        ]
+      }
+    ]
+  }
+}

.claude/rules/install-reference.md

@@ -22,6 +22,7 @@ paths:
 ./install.sh --with-nothing-design        # + skill Nothing design system (dominikmartn)
 ./install.sh --with-hue-skill             # + skill Hue design language generator (dominikmartn)
 ./install.sh --with-memory-loop           # + hooks memory loop
+./install.sh --with-auto-dream            # + hook Auto Dream consolidation REM-style (24h + 5 sessions → merge doublons, normalise horodatages, archive obsolètes, reconstruit MOC) — sandbox stricte, lock multi-instances, background ; voir _shared/auto-dream-protocol.md
 ./install.sh --with-xavier-hook           # + hook SessionStart Xavier (carte contexte + mini-diff, 0 tokens Claude)
 ./install.sh --with-cli-telemetry         # + hook CLI usage tracking → ./framework/tools/cli-report.sh
 ./install.sh --with-accountability        # + audit trail mutations (Edit/Write/Bash) → .ulk-reports/accountability.jsonl

CLAUDE.md

@@ -155,17 +155,48 @@ Référence canonique : `framework/agents/_shared/design-source-protocol.md`
 
 ### Knowledge Vault Loop (Obsidian-compatible)
 
-Cross-session memory via Obsidian-compatible vault. Three commands on `lovecraft (47)`:
+Cross-session memory via Obsidian-compatible vault. Four commands on `lovecraft (47)`:
 
 - **`lovecraft memory capture`** — `MEMORY.md` (project root) → `docs/_memory/<category>/` (delegates to obsidian-vault 39)
 - **`lovecraft memory distribute`** — `docs/_memory/` → `CLAUDE.md` block `<!-- vault:begin -->...<!-- vault:end -->` (delegates to shuri 01 mode=sync)
 - **`lovecraft memory surface`** — read-only summary for godspeed/bruce/gandalf
+- **`lovecraft memory dream`** — **(AUTO-DREAM)** REM-style consolidation cycle : merge doublons (≥ 0.85), normalise horodatages relatifs en dates absolues, archive obsolètes (> 90j + non-référencées), promeut patterns récurrents en règles, reconstruit `00-MOC.md`. Sandbox d'écriture stricte. Capture écrit, dream nettoie.
 
 Auto-integration: 2b3 (Phase 5.7) captures, godspeed (Phase 1.5) surfaces, gandalf (Phase 5) audits health.
 
 Opt-in hooks: `./install.sh --with-memory-loop` copies `.claude/hooks-examples/memory-loop.json` (manual merge into `~/.claude/settings.json` required).
 
-Spec: `framework/agents/_shared/memory-protocol.md`
+Spec: `framework/agents/_shared/memory-protocol.md` · Auto Dream : `framework/agents/_shared/auto-dream-protocol.md`
+
+### Auto Dream — Memory Consolidation (REM-style, depuis 2026-05-07)
+
+Cycle de consolidation mémoire inspiré du sommeil REM, complémentaire à la boucle capture/distribute/surface. Inspiré d'Anthropic *Auto Dream* (Claude Code v2.1.83+, feature flag) et du papier *Sleep-time Compute* (UC Berkeley).
+
+**Problème résolu** : sur la durée, `docs/_memory/` accumule du bruit, des contradictions, des doublons, des horodatages relatifs périmés, des index pourris. Sans nettoyage, Claude lit du contenu désuet et prend des décisions sur cette base. **Capture écrit, dream nettoie.**
+
+**Déclenchement automatique** : hook `SessionStart` qui incrémente un compteur de sessions et déclenche un cycle en arrière-plan (`& disown`) quand **24h écoulées ET ≥ 5 sessions** depuis le dernier dream. État dans `.claude/state/auto-dream.json`. Seuils configurables via `AUTO_DREAM_MIN_HOURS` / `AUTO_DREAM_MIN_SESSIONS`.
+
+**Déclenchement manuel** : `lovecraft memory dream` · `--force` (ignore conditions) · `--dry-run` (simulation) · alias naturel « consolidate my memory files ».
+
+**Garde-fous** :
+- **Sandbox d'écriture stricte** — pendant un cycle, écriture autorisée uniquement dans `docs/_memory/**`, `.claude/memory-archive/**`, `.claude/state/auto-dream.json`, `.ulk-reports/auto-dream-*.json` et le bloc `<!-- vault:begin -->` de `CLAUDE.md`. Jamais code source / tests / config / specs. Enforcement : `permissions: scoped-write` + post-flight diff qui flagge `🚨 SCOPE VIOLATION`.
+- **Lock file** (`.claude/state/auto-dream.lock`) — `flock -n` ou `mkdir` atomique. Si tenu par une autre instance → exit silencieux. TTL 30 min pour dead-lock cleanup.
+- **Background non-bloquant** — fork via `& disown`, ne ralentit jamais la session courante.
+- **Aucune création** — strictement transformatif (merge / normalise / archive / rebuild). Pas de nouvelle entrée — c'est le rôle de `capture`.
+
+**Pipeline** (D1-D8) : scan → détection incohérences (doublons/contradictions/obsolètes/horodatages relatifs/wikilinks morts) → promotion patterns récurrents → reconstruction `00-MOC.md` → rapport machine `.ulk-reports/auto-dream-<ts>.json` → reset state + rapport humain.
+
+**Activation** : `./install.sh --with-auto-dream` (copie hook + script). Merge manuel du bloc `hooks` dans `~/.claude/settings.json` (settings jamais modifiés automatiquement — par design).
+
+**Pourquoi c'est bien pour les 85 agents du framework** :
+1. **Le vault est partagé** — tous les agents lisent `docs/_memory/`. Le bruit s'amplifie en cascade ; un cycle dream améliore tous les futurs runs (multiplicateur d'effet).
+2. **`distribute` injecte dans `CLAUDE.md`** — chaque entrée périmée/contradictoire devient un faux signal pour Claude à chaque session. Dream coupe la chaîne d'erreur à la source.
+3. **Complémentaire à `curate`** — `curate` détecte (manuel, lecture seule). `dream` corrige (auto, écrit avec sandbox). Les deux coexistent.
+4. **Invisible quand ça marche** — exécution background, 0 token côté hook (pur shell), 0 friction utilisateur. Le coût LLM n'apparaît que quand un cycle est effectivement lancé (~1× / semaine pour un projet actif).
+5. **Indépendant du feature flag Anthropic** — la spec Anthropic est server-gated. ulk implémente côté projet, sur le vault projet, sans dépendance externe.
+6. **Discipline forcée par sandbox** — la sandbox `permissions: scoped-write` empêche un cycle dream qui dérive de toucher du code. Robuste face à un futur LLM moins prudent.
+
+Spec : `framework/agents/_shared/auto-dream-protocol.md` · Script : `framework/tools/hooks/auto-dream.sh` · Hook : `.claude/hooks-examples/auto-dream.json`
 
 ## Path-Specific Rules (`.claude/rules/`)
 

framework/agents/_shared/auto-dream-protocol.md

@@ -0,0 +1,251 @@
+# Auto Dream Protocol — Memory Consolidation Cycle
+
+> Cycle de **consolidation mémoire** inspiré du sommeil REM humain.
+> Étape 4 de la boucle mémoire ulk : `capture` → `distribute` → `surface` → **`dream`**.
+> Source : Anthropic *Auto Dream* (Claude Code v2.1.83+) · base académique « Sleep-time Compute » (UC Berkeley).
+>
+> Lu par : `47-lovecraft`, `00-godspeed`, `34-gandalf`, `08-2b3`, `framework/tools/hooks/auto-dream.sh`.
+
+---
+
+## 1. Pourquoi
+
+Le vault `docs/_memory/` accumule au fil des sessions :
+- **du bruit** — détails de session qui n'ont jamais resservi
+- **des contradictions** — un pattern adopté il y a 2 mois, abandonné depuis sans archivage
+- **des doublons** — similarité > 0.85 que `curate` a signalés mais que personne n'a fusionnés
+- **des horodatages relatifs périmés** — « il y a 3 jours » dans une entrée vieille de 4 mois
+- **des index pourris** — `00-MOC.md` qui ne reflète plus la structure réelle
+
+Sans nettoyage, ces incohérences finissent par **perturber le modèle** : Claude lit du contenu désuet ou contradictoire et prend des décisions sur cette base.
+
+**`capture` écrit. `dream` nettoie.** Les deux étapes sont complémentaires.
+
+---
+
+## 2. Position dans la boucle
+
+```
+Session active
+   │
+   ├── Claude écrit → MEMORY.md
+   │
+   └── Fin de session
+              │
+              ▼
+       lovecraft memory capture        ← écriture (étape 1)
+              │
+              ▼
+       lovecraft memory distribute     ← projection vers CLAUDE.md (étape 2)
+              │
+              ▼
+       Session suivante
+              │
+              ├── godspeed Phase 1.5
+              │     └── lovecraft memory surface  ← lecture (étape 3)
+              │
+              └── (en arrière-plan, conditions remplies)
+                          │
+                          ▼
+                  lovecraft memory dream  ← consolidation (étape 4)
+                          │
+                          └── nettoie, fusionne, normalise, rebâtit l'index
+```
+
+`dream` ne crée jamais de nouvelles entrées. Il **transforme l'existant** : merge, archive, normalise, réécrit l'index.
+
+---
+
+## 3. Conditions de déclenchement
+
+Par défaut (alignées sur la spec Anthropic) :
+
+| Condition | Valeur défaut | Variable d'env |
+|-----------|---------------|----------------|
+| Temps écoulé depuis le dernier dream | ≥ 24 h | `AUTO_DREAM_MIN_HOURS` |
+| Sessions écoulées depuis le dernier dream | ≥ 5 | `AUTO_DREAM_MIN_SESSIONS` |
+
+**Les deux conditions doivent être vraies.** Si l'une manque → skip silencieux.
+
+Override manuel : `lovecraft memory dream --force` ignore les conditions (utile pour tester ou forcer un nettoyage avant un audit).
+
+Le compteur de sessions est incrémenté par le hook `SessionStart` (voir §6). Il est remis à zéro à la fin de chaque cycle dream.
+
+---
+
+## 4. Garde-fous (non négociables)
+
+### 4.1 Sandbox d'écriture
+
+Pendant un cycle dream, l'agent ne peut écrire **que dans** :
+
+- `docs/_memory/**` — vault de mémoire (cible principale)
+- `docs/_memory/00-MOC.md` — index reconstruit
+- `docs/_memory/archive/**` — entrées obsolètes déplacées
+- `.claude/memory-archive/**` — archives MEMORY.md historiques (purge éventuelle)
+- `.ulk-reports/auto-dream-<ts>.json` — rapport de cycle
+
+**Interdit** : code source, configuration, tests, `CLAUDE.md` (sauf bloc `<!-- vault:begin -->`), specs, fichiers projet hors `docs/_memory/`.
+
+L'enforcement est triple :
+1. **Frontmatter `permissions: scoped-write` + `permissions_scope:`** sur l'invocation lovecraft mode=dream
+2. **Pré-flight script** dans `framework/tools/hooks/auto-dream.sh` qui vérifie la liste avant de lancer Claude
+3. **Post-flight diff** : si le cycle a touché un fichier hors scope, le rapport flagge `🚨 SCOPE VIOLATION` et un revert manuel est suggéré
+
+### 4.2 Lock file (concurrence multi-instances)
+
+`.claude/state/auto-dream.lock` créé via `flock -n` avant tout cycle. Si déjà détenu par une autre instance Claude Code ouverte sur le même projet → exit 0 silencieux.
+
+Mécanisme : `flock` Linux/macOS · fallback `mkdir` atomique si `flock` indisponible. PID + timestamp écrits dans le fichier pour debug. Lock libéré explicitement à la fin OU expiré après 30 minutes (TTL mort).
+
+### 4.3 Exécution non-bloquante
+
+Le hook `SessionStart` ne lance jamais le cycle synchronous. Il fork un processus en arrière-plan (`& disown`) et rend la main immédiatement. La session courante n'est jamais ralentie. Si le cycle plante, la session continue normalement.
+
+### 4.4 Aucune création d'entrée
+
+`dream` est strictement transformatif. Il ne fabrique pas de nouvelle leçon, pattern, mistake. Il ne déduit rien à partir de la transcription de session courante (c'est le rôle de `capture`).
+
+---
+
+## 5. Pipeline du cycle
+
+### Phase D1 — Scan
+```bash
+find docs/_memory/ -name "*.md" -not -path "*/archive/*"
+```
+Pour chaque fichier : parser frontmatter (`title`, `category`, `date`, `tags`, `severity`, `status`).
+
+### Phase D2 — Détection des incohérences
+
+| Type | Détection | Action |
+|------|-----------|--------|
+| **Doublon** | similarité titre normalisé ≥ 0.85 dans la même catégorie | merge (ajoute contenu en bas, garde le plus ancien comme canonique, archive l'autre) |
+| **Contradiction** | deux entrées même catégorie/sujet avec verdict opposé (`use X` vs `avoid X`) | flag dans rapport, pas de merge auto, status `contradicts: <slug>` ajouté aux deux |
+| **Obsolète** | `date > 90 j` ET `severity != critical` ET pas référencée par CLAUDE.md depuis 30 j | `status: archived` + déplace vers `docs/_memory/archive/` |
+| **Horodatage relatif** | regex `\b(hier|il y a \d+ (jour|semaine|mois)|recently|last week)\b` | remplace par date absolue calculée depuis `frontmatter.date` |
+| **Wikilink mort** | `[[...]]` pointant vers fichier inexistant | flag dans rapport (pas de fix auto) |
+
+### Phase D3 — Promotion
+
+Si un `pattern` a été référencé ≥ 3 fois dans `CLAUDE.md` distribute sur une fenêtre de 60 jours → promotion en `rule` avec `enforcement: advisory`.
+
+### Phase D4 — Reconstruction de l'index
+
+Régénère `docs/_memory/00-MOC.md` :
+- Liste catégorisée par `category`
+- Top 10 entrées par `severity: critical` puis recency
+- Compteurs par catégorie
+- Date de dernière consolidation
+
+### Phase D5 — Rapport
+
+Écrit `.ulk-reports/auto-dream-<YYYY-MM-DD-HHmm>.json` :
+
+```json
+{
+  "ts": "2026-05-07T03:14:00Z",
+  "duration_ms": 1842,
+  "trigger": "auto" | "manual" | "force",
+  "scanned": 47,
+  "merged": 3,
+  "archived": 5,
+  "promoted": 1,
+  "contradictions_flagged": 2,
+  "wikilinks_dead": 4,
+  "timestamps_normalized": 12,
+  "moc_rebuilt": true,
+  "scope_violations": [],
+  "files_touched": ["docs/_memory/00-MOC.md", "docs/_memory/03-lessons/...", "..."]
+}
+```
+
+### Phase D6 — Mise à jour state
+
+Écrit `.claude/state/auto-dream.json` :
+```json
+{
+  "last_run_at": "2026-05-07T03:14:00Z",
+  "sessions_since_last_dream": 0,
+  "total_dreams": 7,
+  "first_session_at": "2026-04-12T08:30:00Z"
+}
+```
+
+---
+
+## 6. Hook `SessionStart`
+
+Installé via `./install.sh --with-auto-dream`. Recette dans `.claude/hooks-examples/auto-dream.json` (l'utilisateur merge manuellement dans `~/.claude/settings.json` — pas de modification automatique des settings).
+
+Le hook lance `framework/tools/hooks/auto-dream.sh tick` qui :
+
+1. Incrémente `sessions_since_last_dream` dans `.claude/state/auto-dream.json`
+2. Vérifie les conditions (24 h + 5 sessions)
+3. Si remplies → fork en arrière-plan : `claude --headless --no-interactive 'lovecraft memory dream' &`
+4. Sinon → exit 0 silencieux
+
+Le coût hook côté tokens : **0** (le check est pur shell, sans LLM).
+
+---
+
+## 7. Invocation manuelle
+
+Sans hook, l'utilisateur peut déclencher un cycle :
+
+```bash
+# Via Claude Code
+"consolidate my memory files"          # alias naturel
+"lovecraft memory dream"               # commande directe
+"lovecraft memory dream --force"       # ignore les conditions
+"lovecraft memory dream --dry-run"     # simulation, n'écrit rien
+```
+
+Sans la commande `/dream` officielle d'Anthropic (statut feature flag), c'est l'invocation textuelle qui pilote le cycle dans ulk.
+
+---
+
+## 8. Intégration agents
+
+| Agent | Phase | Action |
+|-------|-------|--------|
+| `47-lovecraft` | mode `dream` | Pipeline D1-D6 ci-dessus |
+| `00-godspeed` | Phase 1.5 (surface) | Si `last_run_at` > 7 jours → flag « vault non consolidé » dans le diagnostic |
+| `34-gandalf` | Phase 5 (vault health) | Lit `.claude/state/auto-dream.json` ; alerte si conditions remplies depuis > 48 h sans cycle (= hook désactivé ou cassé) |
+| `08-2b3` | Phase 5.7 | Inchangé. Capture seule. Le checkpoint ne déclenche pas dream (séparation des responsabilités). |
+
+---
+
+## 9. Différence avec `curate`
+
+`curate` et `dream` partagent une partie de leur logique mais diffèrent sur trois axes :
+
+| Axe | `curate` | `dream` |
+|-----|----------|---------|
+| **Déclenchement** | Manuel uniquement | Automatique (hook) ou manuel |
+| **Périmètre** | Scoring + détection doublons → liste pour humain | Pipeline complet, exécute les corrections (merge, normalise, rebuild MOC) |
+| **Granularité** | Une catégorie à la fois (`--threshold-days N`) | Vault entier en un cycle |
+| **Output** | Rapport humain (review nécessaire) | Vault corrigé + rapport machine (`.ulk-reports/auto-dream-*.json`) |
+
+`curate` reste utile pour des nettoyages ciblés. `dream` est pensé pour tourner sans supervision.
+
+---
+
+## 10. Statut et déploiement
+
+- **Spec ulk** : actif depuis 2026-05-07 (cette implémentation).
+- **Spec Anthropic** : feature flag côté serveur, déploiement progressif. Tous les utilisateurs Claude Code n'ont pas accès au toggle `/memory` *Auto-dream: on*.
+- **Indépendance** : ulk implémente Auto Dream **côté projet** (vault `docs/_memory/`, hook local, état dans `.claude/state/`). Aucune dépendance au feature flag Anthropic. Le jour où Claude Code déploie nativement, les deux mécanismes coexistent (le notre opère sur le vault projet ulk, le natif sur la mémoire utilisateur Anthropic).
+
+---
+
+## 11. Références
+
+- `_shared/memory-protocol.md` — boucle mémoire (capture/distribute/surface/curate)
+- `47-lovecraft.md` — orchestrateur, mode `dream`
+- `framework/tools/hooks/auto-dream.sh` — trigger script
+- `.claude/hooks-examples/auto-dream.json` — recette hook
+- Anthropic feature : tessl.io · claudefa.st · zenvanriel.com · antoniocortes.com · wmedia.es
+- Académique : « Sleep-time Compute », UC Berkeley
+
+> Protocole défini le 2026-05-07. ULK-AUTODREAM-001.