Il tuo contesto sopravvive. Sempre.

Cattura lagrangiana dello stato prima della compattazione. Re-iniezione automatica nella sessione successiva. Zero contesto perso.

AGPL-3.0

Compattazione. 90% perso.

La conversazione cresce, il sistema compatta. Task in corso, decisioni architetturali, deploy, catene di ragionamento — spariscono. Ogni volta.

Compattazione: con e senza persistenza

SENZA PERSISTENCE Sessione attiva 3h lavoro, 4 file, reasoning chain COMPACTION Contesto perso 90% sparito. Riparti da zero. CON PERSISTENCE Sessione attiva 3h lavoro, 4 file, reasoning chain LAGR. STATE Contesto ripristinato Riparti esattamente da dove eri. coordinate lagrangiane vs

Due hook. Zero contesto perso.

Due hook che lavorano insieme: uno cattura prima della compattazione, l'altro re-inietta nella sessione successiva.

1

Pre-Compact

Hook PreCompact. Si attiva PRIMA della compattazione. Cattura le coordinate lagrangiane — le variabili essenziali che descrivono lo stato del lavoro.

  • Stato git di tutti i repo (commit, branch, dirty files)
  • Momentum del task corrente
  • Traiettoria (ultimi 3 commit per repo)
  • Catena di ragionamento attiva
  • Tag semantici (FILE_EDIT, CODEBASE, DEBUG, VISION, DEPLOY)
2

Post-Compact

Hook SessionStart:compact. Si attiva quando una NUOVA sessione parte dopo una compattazione. Re-inietta lo snapshot completo.

  • Contesto lagrangiano completo
  • Catena di ragionamento
  • Istruzioni di recovery ("leggi questi file, controlla questi diff")
  • Warning su cambiamenti non committati
3

Ripresa Istantanea

Il coder riparte con il contesto completo. Sa cosa stavi facendo, dove eri arrivato, e cosa fare dopo. Nessun onboarding, nessun "dove eravamo rimasti".

Cosa fa concretamente

Ogni fase cattura o ripristina elementi specifici del contesto. Lo stato persiste anche senza compattazione.

Fase Hook Cosa cattura / ripristina
Pre-compact PreCompact Git state, task momentum, trajectory (ultimi 3 commit per repo), reasoning chain, semantic tags
Post-compact SessionStart:compact Full Lagrangian snapshot, recovery instructions, reasoning chain restoration
Persist system_state.md L'ultimo stato sopravvive attraverso le sessioni anche senza compattazione

Coordinate lagrangiane

Non tutto ha lo stesso peso informativo. Le coordinate lagrangiane descrivono un sistema con il minimo numero di variabili. Il pre-compact cattura solo quelle essenziali. Non salva la conversazione. Salva la posizione nel campo.

Riparti esattamente da dove eri

3 ore di lavoro. 4 file aperti. Race condition in debug. Il contesto si compatta.

"Contesto ripristinato. Race condition in adapters/gmail_adapter.js. Commit: c6160e3. 2 file dirty. Catena di ragionamento: [...]"

Riparti da dove eri.

Installazione

1

Clona il repository e lancia l'installer con il tuo profilo.

2

L'installer genera i due hook (pre_compact.sh e post_compact.sh) e li collega alla configurazione.

3

Da quel momento, ogni compattazione salva e ripristina il contesto automaticamente.

git clone https://github.com/GrazianoGuiducci/d-nd-seed.git
cd d-nd-seed
./install.sh profiles/example.json
Scarica SEED-context-persistence.md
# 1. Configura gli hook in .claude/settings.local.json
{
  "hooks": {
    "PreCompact": [
      {
        "hooks": [{
          "type": "command",
          "command": "bash .claude/hooks/pre_compact.sh"
        }]
      }
    ],
    "SessionStart": [
      {
        "matcher": "compact",
        "hooks": [{
          "type": "command",
          "command": "bash .claude/hooks/post_compact.sh"
        }]
      }
    ]
  }
}

# 2. Crea .claude/hooks/pre_compact.sh
#!/bin/bash
# Snapshot lagrangiano: cattura le coordinate essenziali
STATE_FILE=".claude/hooks/system_state.md"
echo "# Lagrangian Snapshot - $(date -Iseconds)" > "$STATE_FILE"
echo "" >> "$STATE_FILE"

# Git state per ogni repo
for repo in $(find . -maxdepth 2 -name ".git" -type d); do
  DIR=$(dirname "$repo")
  echo "## $DIR" >> "$STATE_FILE"
  cd "$DIR"
  echo "Branch: $(git branch --show-current)" >> "$STATE_FILE"
  echo "Commit: $(git rev-parse --short HEAD)" >> "$STATE_FILE"
  echo "Dirty: $(git status --porcelain | wc -l) files" >> "$STATE_FILE"
  echo "Last 3:" >> "$STATE_FILE"
  git log --oneline -3 >> "$STATE_FILE"
  cd - > /dev/null
  echo "" >> "$STATE_FILE"
done

# 3. Crea .claude/hooks/post_compact.sh
#!/bin/bash
# Re-iniezione: leggi lo snapshot e ricostruisci il contesto
STATE_FILE=".claude/hooks/system_state.md"
if [ -f "$STATE_FILE" ]; then
  cat "$STATE_FILE"
  echo ""
  echo "--- RECOVERY INSTRUCTIONS ---"
  echo "Leggi i file modificati. Controlla i diff."
  echo "Ripristina la catena di ragionamento."
fi

# 4. Rendi eseguibili
chmod +x .claude/hooks/pre_compact.sh
chmod +x .claude/hooks/post_compact.sh

Esplora gli altri moduli

Safety Guard

pattern · PreToolUse · free

Anamnesis

v0.1 live · AGPL · free

Framework D-ND

f(x) = 1 + 1/x · det = −1 · open