DEV Community

Cover image for Why Claude Code Loses Context After /compact (And How Bi-Temporal Graph Memory + AST Drift Locks Fix It)
Benni Alencar
Benni Alencar

Posted on Originally published at benni-os.net

Why Claude Code Loses Context After /compact (And How Bi-Temporal Graph Memory + AST Drift Locks Fix It)

By **Benni Alencar* — Chief AI Systems Architect at Benni OS. Canonical article & interactive benchmarks at benni-os.net.*


1. The Post-Compaction Amnesia Cliff

Every engineer running long refactoring or feature-build sessions in Claude Code hits the exact same cliff around turn 40. The context meter climbs past 85%, you run /compact (or auto-compaction triggers), and for the next three turns everything looks fine—until the agent silently re-introduces an ORM pattern you explicitly banned 25 minutes ago, mutates a frozen API response schema, or re-attempts a Redis locking strategy you already proved deadlocks under load.

This is not a model intelligence problem. It is a lossy compression and state-representation problem:

  • Prose Summarization Destroys Negative Constraints: Compaction optimizes for narrative continuity ("what we are building next"), aggressively pruning "what we rejected and why." Without negative constraints, the model's prior distribution pulls it straight back toward the rejected pattern.
  • Flat Markdown Memory Files Drift Over Time: Dumping notes into CLAUDE.md or flat scratchpads lacks temporal validity. An invariant from Tuesday's prototype sits beside Thursday's production override with no way to distinguish active truth from superseded history.
  • No Structural Enforcement at Turn Boundaries: Even if a constraint survives in the system prompt, nothing verifies the actual code emitted on disk against the architectural contract before the turn completes.

    **Core Thesis:** Compaction should compress conversational prose, never architectural truth. **`Benni-OS/claude-code-sovereign`** decouples working memory from structural memory by storing invariants, schema contracts, and rejected alternatives in a local **bi-temporal knowledge graph** exposed via MCP, paired with a deterministic **`Stop`-hook AST Reality Lock**.
    

2. Architecture: Bi-Temporal MCP Graph + Stop-Hook AST Reality Lock

To survive both /compact and /clear without token bloat, claude-code-sovereign separates what is currently true in the codebase from when the agent observed or superseded it. Every architectural decision is stored as a typed edge or node with three timestamps: valid_from, valid_until, and recorded_at.

flowchart LR
    A["Claude Code Turn\n(/compact or /clear)"] -->|"PreCompact / SessionStart Hook"| B["MCP Memory Server\n(SQLite Bi-Temporal Graph)"]
    B -->|"Query: valid_until IS NULL\n(< 1.2ms local)"| C["Active Invariants + Rejected Alts\nInjected as Compact Context"]
    C --> D["Code Generation\n(Edits & Tool Calls)"]
    D -->|"Turn End"| E["Stop Hook: AST Reality Lock\n(Tree-sitter / Python ast)"]
    E -->|"0 Drift Violations"| F["Turn Accepted\n(Commit / Next Step)"]
    E -->|"Contract Violation"| G["Block Stop & Return\nExact AST Diff to Agent"]

Notice the closed feedback loop. Even after a hard /clear, the MCP server re-hydrates only the currently valid subgraph (valid_until IS NULL) in under 1.2 ms—roughly 350–600 tokens of high-density structural facts instead of 40,000 tokens of stale chat history. Then, before Claude Code hands control back to you, the Stop hook runs an AST Reality Lock over every modified file.


3. The Bi-Temporal Schema: Why Three Timestamps Beat Flat Notes

Most "agent memory" plugins use vector similarity search over unstructured text chunks. Vector search is fundamentally broken for coding constraints: if you ask for "auth middleware", cosine similarity retrieves both the deprecated JWT-in-cookie rule and the current mTLS-header rule, letting the LLM guess which one still applies.

A bi-temporal schema solves this deterministically:

  • valid_from: The logical commit, migration, or timestamp when a constraint became active in the repository.
  • valid_until: NULL while the constraint is active; populated the instant a new decision supersedes it (never deleted).
  • recorded_at: The immutable transaction timestamp when the agent wrote the fact, enabling time-travel audits ("what did the agent believe at 14:20?").
import sqlite3
from dataclasses import dataclass
from datetime import datetime, timezone
from typing import List, Optional

@dataclass(frozen=True)
class TemporalFact:
    subject: str
    predicate: str  # e.g. "MUST_USE", "FORBIDS", "REJECTED_ALT", "SCHEMA_LOCK"
    object_val: str
    rationale: str
    valid_from: str
    valid_until: Optional[str]
    recorded_at: str

class BiTemporalGraphStore:
    """Local SQLite bi-temporal graph exposed to Claude Code over stdio MCP."""

    def __init__(self, db_path: str = ".sovereign/memory.db"):
        self.conn = sqlite3.connect(db_path)
        self.conn.execute("""
            CREATE TABLE IF NOT EXISTS graph_facts (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                subject TEXT NOT NULL,
                predicate TEXT NOT NULL,
                object_val TEXT NOT NULL,
                rationale TEXT NOT NULL,
                valid_from TEXT NOT NULL,
                valid_until TEXT DEFAULT NULL,
                recorded_at TEXT NOT NULL
            )
        """)
        self.conn.execute(
            "CREATE INDEX IF NOT EXISTS idx_active ON graph_facts(subject, valid_until)"
        )
        self.conn.commit()

    def assert_fact(
        self,
        subject: str,
        predicate: str,
        object_val: str,
        rationale: str,
        supersedes_predicate: Optional[str] = None,
    ) -> None:
        now = datetime.now(timezone.utc).isoformat()
        with self.conn:
            if supersedes_predicate:
                self.conn.execute(
                    """
                    UPDATE graph_facts
                    SET valid_until = ?
                    WHERE subject = ? AND predicate = ? AND valid_until IS NULL
                    """,
                    (now, subject, supersedes_predicate),
                )
            self.conn.execute(
                """
                INSERT INTO graph_facts
                (subject, predicate, object_val, rationale, valid_from, valid_until, recorded_at)
                VALUES (?, ?, ?, ?, ?, NULL, ?)
                """,
                (subject, predicate, object_val, rationale, now, now),
            )

    def query_active_invariants(self, subject_prefix: str = "") -> List[TemporalFact]:
        """Returns only currently valid constraints (< 1.2ms) for post-/compact injection."""
        cur = self.conn.execute(
            """
            SELECT subject, predicate, object_val, rationale,
                   valid_from, valid_until, recorded_at
            FROM graph_facts
            WHERE valid_until IS NULL AND subject LIKE ?
            ORDER BY recorded_at ASC
            """,
            (f"{subject_prefix}%",),
        )
        return [TemporalFact(*row) for row in cur.fetchall()]
Enter fullscreen mode Exit fullscreen mode

Notice how REJECTED_ALT facts stay active (valid_until IS NULL) across the lifetime of the feature. When Claude Code runs /compact, the PreCompact or SessionStart hook queries query_active_invariants() and pins every FORBIDS and REJECTED_ALT edge into the fresh context window—preventing the agent from wasting 10 turns rediscovering why a design was rejected.


4. The Stop-Hook AST Reality Lock: Zero Silent Drift

Memory injection alone is advisory; models can still overlook a constraint during a complex multi-file edit. That is why claude-code-sovereign pairs the MCP graph with a deterministic Stop hook that inspects the actual Abstract Syntax Tree of modified files before a turn is allowed to complete.

Unlike regex linters, an AST Reality Lock understands imports, function signatures, class inheritance, and schema fields. Below is a minimal Python AST Reality Lock enforced on Claude Code's Stop lifecycle event:

import ast
import json
import subprocess
import sys
from pathlib import Path
from typing import Dict, List

def get_modified_python_files() -> List[Path]:
    res = subprocess.run(
        ["git", "diff", "--name-only", "HEAD"],
        capture_output=True,
        text=True,
        check=False,
    )
    return [Path(p) for p in res.stdout.splitlines() if p.endswith(".py") and Path(p).exists()]

def verify_ast_contracts(files: List[Path], forbidden_imports: Dict[str, str]) -> List[str]:
    violations: List[str] = []
    for path in files:
        tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
        for node in ast.walk(tree):
            if isinstance(node, ast.Import):
                for alias in node.names:
                    if alias.name in forbidden_imports:
                        violations.append(
                            f"{path}:{node.lineno} imports forbidden module '{alias.name}' "
                            f"({forbidden_imports[alias.name]})"
                        )
            elif isinstance(node, ast.ImportFrom) and node.module:
                root_mod = node.module.split(".")[0]
                if root_mod in forbidden_imports:
                    violations.append(
                        f"{path}:{node.lineno} imports from forbidden module '{root_mod}' "
                        f"({forbidden_imports[root_mod]})"
                    )
    return violations

if __name__ == "__main__":
    # In production, loaded dynamically from BiTemporalGraphStore (predicate='FORBIDS')
    active_bans = {
        "sqlalchemy": "REJECTED_ALT #12: Project uses raw asyncpg + typed SQL contracts.",
        "pickle": "SECURITY_LOCK #04: Untrusted deserialization banned across all services.",
    }
    drift = verify_ast_contracts(get_modified_python_files(), active_bans)
    if drift:
        # Claude Code Stop hook contract: exit code 2 blocks stop and feeds stderr back to model
        print(json.dumps({"decision": "block", "reason": "\n".join(drift)}), file=sys.stderr)
        sys.exit(2)
Enter fullscreen mode Exit fullscreen mode

When Claude Code attempts to finish a turn after accidentally importing sqlalchemy post-compaction, the Stop hook exits with code 2, surfaces the exact file, line number, and bi-temporal rationale (REJECTED_ALT #12), and forces the agent to self-correct immediately before the human operator even sees the diff.


5. Architecture Comparison: Default /compact vs. Flat CLAUDE.md vs. claude-code-sovereign

Dimension Default /compact Flat CLAUDE.md + Vector RAG Benni-OS/claude-code-sovereign
Negative Constraints & Rejected Alts Pruned during prose summarization Lost in chunk noise / stale rankings Pinned via Typed Graph Edges (REJECTED_ALT)
Temporal Superseding None (chronological blur) Manual edits; old & new chunks collide Bi-Temporal (valid_from, valid_until, recorded_at)
Post-/clear Recovery 0% session memory retained Requires manual prompt re-seeding Automatic MCP Subgraph Re-Hydration (< 2 ms)
Drift Enforcement Prompt-only (advisory) Prompt-only (advisory) Deterministic Stop-Hook AST Reality Lock
Infrastructure & Privacy Cloud session state Often requires cloud embeddings/vector DB 100% Local SQLite + stdio MCP (Zero Cloud Cost)

6. Wiring the Sovereign Lifecycle in .claude/settings.json

Integrating the bi-temporal MCP server and the Stop-hook AST Reality Lock requires zero changes to Claude Code's binary. You wire both into your repository's .claude/settings.json and MCP configuration:

{
  "mcpServers": {
    "sovereign-memory": {
      "command": "python",
      "args": ["-m", "claude_code_sovereign.mcp_server", "--db", ".sovereign/memory.db"]
    }
  },
  "hooks": {
    "PreCompact": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "python -m claude_code_sovereign.hooks.snapshot_invariants"
          }
        ]
      }
    ],
    "Stop": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "python -m claude_code_sovereign.hooks.ast_reality_lock"
          }
        ]
      }
    ]
  }
}
Enter fullscreen mode Exit fullscreen mode

With this configuration active, every /compact snapshots active decisions, every fresh session queries only non-superseded invariants, and every completed turn is structurally verified against the repository's AST contracts.

Make Claude Code Forget-Proof Across /compact

Clone Benni-OS/claude-code-sovereign, attach the local SQLite bi-temporal MCP server, and enforce deterministic AST Reality Locks on every turn.

    Explore Benni-OS/claude-code-sovereign on GitHub →
Enter fullscreen mode Exit fullscreen mode




Frequently Asked Questions


      Why does Claude Code forget architectural decisions right after /compact?
The /compact command replaces raw conversation turns with a lossy prose summary to reclaim context window space. While high-level task goals survive, negative constraints, rejected alternatives, and exact schema contracts are compressed away, causing the model to re-propose discarded designs or silently violate invariants.
  What makes a knowledge graph bi-temporal (valid_from, valid_until, recorded_at)?
  A bi-temporal graph tracks two independent timelines: valid time (`valid_from` and `valid_until`, representing when a fact or constraint is true in the codebase) and transaction time (`recorded_at`, representing when the agent learned or superseded it). This prevents stale rules from leaking into current prompts while preserving a full audit trail of rejected alternatives.


  How does the Stop-hook AST Reality Lock prevent architectural drift?
  Before Claude Code finishes a turn, the `Stop` hook parses modified files into an Abstract Syntax Tree (AST) and compares exported symbols, type signatures, and forbidden imports against active constraints in the bi-temporal graph. If drift is detected, the hook blocks completion and feeds the exact structural violation back to the agent.


  Does claude-code-sovereign require an external cloud vector database?
  No. `Benni-OS/claude-code-sovereign` runs 100% locally over SQLite and stdio MCP, with zero external API calls, zero cloud lock-in, and sub-millisecond graph queries across `/compact` and `/clear` boundaries.
Enter fullscreen mode Exit fullscreen mode
Enter fullscreen mode Exit fullscreen mode




Frequently Asked Questions

Why does Claude Code forget architectural decisions right after /compact?

The /compact command replaces raw conversation turns with a lossy prose summary to reclaim context window space. While high-level task goals survive, negative constraints, rejected alternatives, and exact schema contracts are compressed away, causing the model to re-propose discarded designs or silently violate invariants.

What makes a knowledge graph bi-temporal (valid_from, valid_until, recorded_at)?

A bi-temporal graph tracks two independent timelines: valid time (valid_from and valid_until, representing when a fact or constraint is true in the codebase) and transaction time (recorded_at, representing when the agent learned or superseded it). This prevents stale rules from leaking into current prompts while preserving a full audit trail of rejected alternatives.

How does the Stop-hook AST Reality Lock prevent architectural drift?

Before Claude Code finishes a turn, the Stop hook parses modified files into an Abstract Syntax Tree (AST) and compares exported symbols, type signatures, and forbidden imports against active constraints in the bi-temporal graph. If drift is detected, the hook blocks completion and feeds the exact structural violation back to the agent.

Does claude-code-sovereign require an external cloud vector database?

No. Benni-OS/claude-code-sovereign runs 100% locally over SQLite and stdio MCP, with zero external API calls, zero cloud lock-in, and sub-millisecond graph queries across /compact and /clear boundaries.


Explore the Benni Master OS Open-Source Ecosystem

Top comments (0)