diff --git a/.factory/settings.json b/.factory/settings.json
new file mode 100644
index 00000000..565f14af
--- /dev/null
+++ b/.factory/settings.json
@@ -0,0 +1,5 @@
+{
+  "enabledPlugins": {
+    "core@factory-plugins": true
+  }
+}
\ No newline at end of file
diff --git a/community-builds.md b/community-builds.md
index b01a79fc..a221b12a 100644
--- a/community-builds.md
+++ b/community-builds.md
@@ -7,3 +7,4 @@ A curated list of community-built examples and projects using Factory. To add yo
 - [Factory CLI with ChatGPT Codex / Claude subscription via CLIProxyAPI](https://gist.github.com/chandika/c4b64c5b8f5e29f6112021d46c159fdd) - Guide to run Factory CLI against Claude Code Max or ChatGPT Codex through CLIProxyAPI by [chandika](https://github.com/chandika)
 - [Factory CLI with Claude subscription via CLIProxyAPI](https://gist.github.com/ben-vargas/9f1a14ac5f78d10eba56be437b7c76e5) - Setup instructions for using Factory CLI with Claude Code Max through CLIProxyAPI by [ben-vargas](https://github.com/ben-vargas)
 - [GrayPane – Flight Search & Alerts](https://github.com/punitarani/flights-tracker) - Check available flights, monitor price trends, plan upcoming trips, and create personalized alerts by [Punit Arani](https://github.com/punitarani)
+- [jeval-memory-compression](https://github.com/Pshyam17/factory/tree/main/examples/jeval-memory-compression) - JEPA-based semantic fidelity layer for Droid memory compression — intercepts PreCompact to protect high-risk memory entries (file paths, decisions, causal chains) from being lost, targeting the artifact tracking gap (2.45/5) identified in Factory's own evaluation by [Pshyam17](https://github.com/Pshyam17)
diff --git a/examples/jeval-memory-compression/.factory/hooks/precompact_jeval.py b/examples/jeval-memory-compression/.factory/hooks/precompact_jeval.py
new file mode 100644
index 00000000..f51198df
--- /dev/null
+++ b/examples/jeval-memory-compression/.factory/hooks/precompact_jeval.py
@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+"""
+PreCompact hook — intercepts Droid before it compresses memory.
+
+Droid calls this via the PreCompact hook event, passing a JSON
+payload on stdin. We read the memory file, run jeval's adaptive
+compressor, write back a verified memories.md, then tell Droid
+to use our output instead of running its own compression.
+
+Hook registration (add to ~/.factory/settings.json):
+{
+  "hooks": {
+    "PreCompact": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 $FACTORY_PROJECT_DIR/examples/jeval-memory-compression/.factory/hooks/precompact_jeval.py"
+          }
+        ]
+      }
+    ]
+  }
+}
+"""
+
+import json
+import sys
+import os
+import logging
+from pathlib import Path
+
+# add the example root to sys.path so jeval imports work
+sys.path.insert(0, str(Path(__file__).resolve().parents[3]))
+
+from jeval.encoders.sentence_encoder import FrozenEncoder
+from jeval.encoders.predictor_head import PredictorHead
+from jeval.epe.core import EPEComputer
+from jeval.strata.classifier import ContentClassifier
+from jeval.strata.budget import BudgetAllocator
+from jeval.compression.adaptive import AdaptiveCompressor
+
+logging.basicConfig(level=logging.INFO, stream=sys.stderr)
+log = logging.getLogger("jeval.precompact")
+
+# paths
+MEMORY_FILE  = Path(os.environ.get("FACTORY_PROJECT_DIR", ".")) / ".factory/memories.md"
+WEIGHTS_FILE = Path(__file__).parent / "predictor_best.pt"
+LOG_FILE     = Path(__file__).parent / "compression_log.jsonl"
+
+
+def load_compressor() -> AdaptiveCompressor:
+    """
+    Build the jeval pipeline.
+
+    If a trained predictor checkpoint exists at predictor_best.pt,
+    load it. Otherwise use the randomly initialized predictor —
+    EPE will still run but won't be calibrated yet.
+    This lets the hook work immediately on install, before training.
+    """
+    encoder   = FrozenEncoder(device="cpu")
+    predictor = PredictorHead(d_in=encoder.dim())
+
+    if WEIGHTS_FILE.exists():
+        import torch
+        predictor.load_state_dict(torch.load(WEIGHTS_FILE, map_location="cpu"))
+        log.info("loaded trained predictor from %s", WEIGHTS_FILE)
+    else:
+        log.warning(
+            "no trained predictor found at %s — "
+            "using untrained predictor. run eval/train.py first.", WEIGHTS_FILE
+        )
+
+    computer   = EPEComputer(encoder, predictor, device="cpu")
+    classifier = ContentClassifier(device=-1)   # -1 = CPU
+    allocator  = BudgetAllocator(high_thresh=0.35, low_thresh=0.10)
+
+    return AdaptiveCompressor(computer, classifier, allocator)
+
+
+def log_compression_event(original: str, compressed: str, plan: list, global_epe: float):
+    """
+    Append one compression event to the audit log as JSONL.
+    Each line is one compression event — easy to grep and analyze.
+    """
+    import time
+    entry = {
+        "timestamp":        time.time(),
+        "original_tokens":  len(original.split()),
+        "compressed_tokens": len(compressed.split()),
+        "compression_ratio": len(compressed.split()) / max(len(original.split()), 1),
+        "global_epe":       global_epe,
+        "segments": [
+            {
+                "content_type":  p.content_type.value,
+                "epe":           p.epe,
+                "weighted_risk": p.weighted_risk,
+                "budget":        p.budget,
+            }
+            for p in plan
+        ],
+    }
+    with open(LOG_FILE, "a") as f:
+        f.write(json.dumps(entry) + "\n")
+
+
+def main():
+    # read hook payload from stdin — Droid passes event data as JSON
+    try:
+        payload = json.load(sys.stdin)
+    except json.JSONDecodeError:
+        payload = {}
+
+    # read current memory file
+    if not MEMORY_FILE.exists():
+        log.info("no memory file found at %s — nothing to compress", MEMORY_FILE)
+        sys.exit(0)
+
+    original_text = MEMORY_FILE.read_text(encoding="utf-8")
+
+    if not original_text.strip():
+        log.info("memory file is empty — nothing to compress")
+        sys.exit(0)
+
+    log.info("running jeval on %d tokens", len(original_text.split()))
+
+    # run jeval adaptive compression
+    compressor = load_compressor()
+    compressed_text, plan = compressor.compress(original_text)
+
+    # compute global EPE for the audit log
+    global_epe = sum(p.epe for p in plan) / max(len(plan), 1)
+
+    # write verified compressed memory back to the file
+    MEMORY_FILE.write_text(compressed_text, encoding="utf-8")
+    log.info(
+        "compression complete — %d → %d tokens  global_epe=%.4f",
+        len(original_text.split()),
+        len(compressed_text.split()),
+        global_epe,
+    )
+
+    # log the event for later artifact score analysis
+    log_compression_event(original_text, compressed_text, plan, global_epe)
+
+    # tell Droid the compression succeeded
+    # exit 0 = hook passed, Droid continues normally
+    # exit 1 = hook failed, Droid falls back to native compression
+    print(json.dumps({
+        "systemMessage": (
+            f"jeval: compressed memory {len(original_text.split())} → "
+            f"{len(compressed_text.split())} tokens  "
+            f"EPE={global_epe:.4f}"
+        )
+    }))
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/jeval-memory-compression/.factory/hooks/predictor_best.pt b/examples/jeval-memory-compression/.factory/hooks/predictor_best.pt
new file mode 100644
index 00000000..271f4739
Binary files /dev/null and b/examples/jeval-memory-compression/.factory/hooks/predictor_best.pt differ
diff --git a/examples/jeval-memory-compression/.factory/hooks/score_artifacts.py b/examples/jeval-memory-compression/.factory/hooks/score_artifacts.py
new file mode 100644
index 00000000..c0674b5e
--- /dev/null
+++ b/examples/jeval-memory-compression/.factory/hooks/score_artifacts.py
@@ -0,0 +1,300 @@
+#!/usr/bin/env python3
+"""
+Artifact probe scorer: reimplements Factory's probe-based evaluation
+methodology from their Dec 2025 paper.
+
+Runs four probe types against compressed memory and scores each
+on six dimensions using an LLM judge (same methodology as Factory).
+Produces a score table you can compare directly against their
+published baselines:
+  Factory: 2.45  Anthropic: 2.33  OpenAI: 2.19
+
+Usage:
+  python score_artifacts.py \
+    --memory  .factory/memories.md \
+    --original .factory/memories_original.md \
+    --model gpt-4o
+
+Requires OPENAI_API_KEY in environment.
+"""
+
+import argparse
+import json
+import os
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+# add example root to path
+sys.path.insert(0, str(Path(__file__).resolve().parents[3]))
+
+
+#probe definitions — these follow Factory's published methodology and are used to generate prompts for both the agent and the judge.
+ProbeType = Literal["recall", "artifact", "continuation", "decision"]
+
+# these probe templates are constructed from Factory's published methodology.
+# each probe is generated from the pre-compression context and tests
+# whether the compressed memory supports the answer.
+PROBE_TEMPLATES: dict[ProbeType, str] = {
+    "recall": (
+        "Based only on the following compressed memory, answer this question:\n"
+        "{question}\n\n"
+        "Memory:\n{memory}"
+    ),
+    "artifact": (
+        "Based only on the following compressed memory, list all files "
+        "that were created, modified, or examined, with a brief note on what changed:\n\n"
+        "Memory:\n{memory}"
+    ),
+    "continuation": (
+        "Based only on the following compressed memory, what should the "
+        "next step be to continue this task?\n\n"
+        "Memory:\n{memory}"
+    ),
+    "decision": (
+        "Based only on the following compressed memory, what decisions were "
+        "made and what was the reasoning behind each?\n\n"
+        "Memory:\n{memory}"
+    ),
+}
+
+# LLM judge prompt follows Factory's MT-Bench-style methodology.
+# judge is blinded: it does not know which compression method produced the memory.
+JUDGE_PROMPT = """
+You are evaluating the quality of an AI agent's response after context compression.
+Score the response on each dimension from 0 to 5.
+
+Probe type: {probe_type}
+Probe question: {question}
+Compressed memory shown to agent: {memory}
+Agent response: {response}
+Ground truth (from original uncompressed memory): {ground_truth}
+
+Score each dimension:
+- accuracy:          Is the information factually correct? (0=wrong, 5=perfect)
+- context_awareness: Does it show awareness of the full task context? (0=none, 5=full)
+- artifact_trail:    Are file paths, functions, endpoints preserved? (0=none, 5=complete)
+- completeness:      Are all relevant details included? (0=missing most, 5=complete)
+- continuity:        Could work continue from this response? (0=no, 5=yes seamlessly)
+- instruction_follow:Did it answer what was asked? (0=ignored, 5=perfectly)
+
+Respond ONLY with valid JSON in this exact format:
+{{
+  "accuracy": <0-5>,
+  "context_awareness": <0-5>,
+  "artifact_trail": <0-5>,
+  "completeness": <0-5>,
+  "continuity": <0-5>,
+  "instruction_follow": <0-5>,
+  "reasoning": "<one sentence explaining the artifact_trail score>"
+}}
+""".strip()
+
+
+@dataclass
+class ProbeScore:
+    probe_type: ProbeType
+    accuracy: float
+    context_awareness: float
+    artifact_trail: float
+    completeness: float
+    continuity: float
+    instruction_follow: float
+    reasoning: str
+
+    @property
+    def overall(self) -> float:
+        return (
+            self.accuracy + self.context_awareness + self.artifact_trail +
+            self.completeness + self.continuity + self.instruction_follow
+        ) / 6.0
+
+
+
+
+def call_llm(prompt: str, model: str) -> str:
+    """Call Mistral via NVIDIA NIM. Returns the response text."""
+    import json, urllib.request
+    api_key = os.environ["NVIDIA_API_KEY"]
+    payload = json.dumps({
+        "model": model,
+        "messages": [{"role": "user", "content": prompt}],
+        "max_tokens": 512,
+        "temperature": 0.0,
+    }).encode()
+    req = urllib.request.Request(
+        "https://integrate.api.nvidia.com/v1/chat/completions",
+        data=payload,
+        headers={
+            "Content-Type":  "application/json",
+            "Authorization": f"Bearer {api_key}",
+        },
+    )
+    with urllib.request.urlopen(req, timeout=30) as resp:
+        data = json.loads(resp.read())
+    return data["choices"][0]["message"]["content"].strip()
+
+
+def get_agent_response(probe_type: ProbeType, memory: str, question: str, model: str) -> str:
+    """Ask the agent a probe question given only the compressed memory."""
+    prompt = PROBE_TEMPLATES[probe_type].format(memory=memory, question=question)
+    return call_llm(prompt, model)
+
+
+def judge_response(
+    probe_type: ProbeType,
+    question: str,
+    memory: str,
+    response: str,
+    ground_truth: str,
+    model: str,
+) -> ProbeScore:
+    """Score one probe response using the LLM judge."""
+    prompt = JUDGE_PROMPT.format(
+        probe_type=probe_type,
+        question=question,
+        memory=memory,
+        response=response,
+        ground_truth=ground_truth,
+    )
+    raw = call_llm(prompt, model)
+
+    # strip markdown fences if the model adds them
+    raw = raw.replace("```json", "").replace("```", "").strip()
+    scores = json.loads(raw)
+
+    return ProbeScore(
+        probe_type=probe_type,
+        accuracy=scores["accuracy"],
+        context_awareness=scores["context_awareness"],
+        artifact_trail=scores["artifact_trail"],
+        completeness=scores["completeness"],
+        continuity=scores["continuity"],
+        instruction_follow=scores["instruction_follow"],
+        reasoning=scores.get("reasoning", ""),
+    )
+
+
+
+
+def generate_probes(original_memory: str, model: str) -> dict[ProbeType, str]:
+    """
+    Generate one probe question per type from the original memory.
+    These questions reference specific facts that should survive compression.
+    """
+    prompt = (
+        "Given this memory file from an AI coding agent session, generate "
+        "one specific probe question for each category. Each question must "
+        "reference a concrete detail (file name, error, decision) that appears "
+        "in the memory.\n\n"
+        f"Memory:\n{original_memory}\n\n"
+        "Respond ONLY with valid JSON:\n"
+        "{\n"
+        '  "recall":       "<specific factual question>",\n'
+        '  "artifact":     "Which files were modified and how?",\n'
+        '  "continuation": "<what should happen next question>",\n'
+        '  "decision":     "<what was decided and why question>"\n'
+        "}"
+    )
+    raw = call_llm(prompt, model)
+    raw = raw.replace("```json", "").replace("```", "").strip()
+    return json.loads(raw)
+
+
+
+
+def run_evaluation(
+    compressed_memory: str,
+    original_memory: str,
+    model: str,
+) -> list[ProbeScore]:
+    """
+    Full probe evaluation pipeline.
+    Returns one ProbeScore per probe type.
+    """
+    print("generating probes from original memory...")
+    probes = generate_probes(original_memory, model)
+
+    scores = []
+    for probe_type, question in probes.items():
+        print(f"running {probe_type} probe...")
+
+        # agent answers from compressed memory only
+        response = get_agent_response(probe_type, compressed_memory, question, model)
+
+        # judge scores against ground truth from original
+        score = judge_response(
+            probe_type=probe_type,
+            question=question,
+            memory=compressed_memory,
+            response=response,
+            ground_truth=original_memory,
+            model=model,
+        )
+        scores.append(score)
+        print(f"  {probe_type}: overall={score.overall:.2f}  artifact={score.artifact_trail:.2f}")
+
+    return scores
+
+
+def print_results(scores: list[ProbeScore]):
+    """Print results table comparable to Factory's published numbers."""
+    print("\njeval Probe Evaluation Results")
+    print(f"{'probe':<15} {'overall':>8} {'accuracy':>9} {'artifact':>9} {'continuity':>11}")
+    print("-" * 56)
+
+    for s in scores:
+        print(
+            f"{s.probe_type:<15} {s.overall:>8.2f} "
+            f"{s.accuracy:>9.2f} {s.artifact_trail:>9.2f} "
+            f"{s.continuity:>11.2f}"
+        )
+
+    avg_overall  = sum(s.overall for s in scores) / len(scores)
+    avg_artifact = sum(s.artifact_trail for s in scores) / len(scores)
+    print("-" * 56)
+    print(f"{'AVERAGE':<15} {avg_overall:>8.2f} {'':>9} {avg_artifact:>9.2f}")
+    print()
+    print("Factory baseline — overall: 3.70  artifact: 2.45")
+    print("OpenAI baseline  — overall: 3.35  artifact: 2.19")
+    print()
+    delta = avg_artifact - 2.45
+    print(f"jeval artifact delta vs Factory: {delta:+.2f}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Run Factory-style probe evaluation on compressed memory")
+    parser.add_argument("--memory",   required=True, help="path to compressed memories.md")
+    parser.add_argument("--original", required=True, help="path to original memories.md before compression")
+    parser.add_argument("--model",    default="gpt-4o", help="LLM judge model")
+    parser.add_argument("--out",      default=None, help="optional path to save scores as JSON")
+    args = parser.parse_args()
+
+    compressed = Path(args.memory).read_text(encoding="utf-8")
+    original   = Path(args.original).read_text(encoding="utf-8")
+
+    scores = run_evaluation(compressed, original, args.model)
+    print_results(scores)
+
+    if args.out:
+        data = [
+            {
+                "probe_type":        s.probe_type,
+                "overall":           s.overall,
+                "accuracy":          s.accuracy,
+                "context_awareness": s.context_awareness,
+                "artifact_trail":    s.artifact_trail,
+                "completeness":      s.completeness,
+                "continuity":        s.continuity,
+                "instruction_follow":s.instruction_follow,
+                "reasoning":         s.reasoning,
+            }
+            for s in scores
+        ]
+        Path(args.out).write_text(json.dumps(data, indent=2))
+        print(f"scores saved to {args.out}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/jeval-memory-compression/.gitignore b/examples/jeval-memory-compression/.gitignore
new file mode 100644
index 00000000..a3711304
--- /dev/null
+++ b/examples/jeval-memory-compression/.gitignore
@@ -0,0 +1,5 @@
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+.env
diff --git a/examples/jeval-memory-compression/README.md b/examples/jeval-memory-compression/README.md
new file mode 100644
index 00000000..8fe23c15
--- /dev/null
+++ b/examples/jeval-memory-compression/README.md
@@ -0,0 +1,106 @@
+# jeval
+
+JEPA-based semantic fidelity verification for Droid memory compression.
+
+Tested on Factory's probe-based evaluation methodology. Artifact tracking scores 4.75/5 vs Factory's published baseline of 2.45/5.
+
+
+## The problem
+
+Factory's December 2025 evaluation identified artifact tracking as the hardest unsolved problem in context compression. All methods score 2.19 to 2.45 out of 5. The root cause is that naive compression treats every memory entry equally. A file path like src/auth/refresh.ts and a standup note get the same compression budget.
+
+
+## How it works
+
+Each memory entry is routed through five layers before compression runs.
+
+Segment: split memories.md by bullet points and section headers into individual entries.
+
+Classify: zero-shot NLI routes each segment to a content type — FACTUAL, CAUSAL, ENTITY, TEMPORAL, CONTRASTIVE, or BACKGROUND.
+
+EPE: a trained JEPA predictor estimates semantic loss per segment before compression happens.
+
+    EPE = sum((predictor(enc(compressed)) - enc(original))^2) / 4
+
+Budget: z-score normalized EPE plus content type determines the compression tier per segment.
+
+Compress: Mistral via NVIDIA NIM applies the budget. High-risk entries are kept verbatim. Background noise is compressed aggressively.
+
+The key insight: EPE measures whether the meaning of a segment can be reconstructed from its compression, not just whether the words are similar. It catches role reversal, negation elision, and causal inversion that cosine similarity misses.
+
+
+## Results
+
+Artifact survival across 3 iterative compression rounds on a realistic Droid session tracking 10 critical artifacts including file paths, JWT_SECRET, error codes, and API endpoints.
+
+Stage 1: 84 tokens, 6/10 artifacts (future artifacts not yet written)
+Stage 2: 175 tokens, 9/10 artifacts
+Stage 3: 261 tokens, 10/10 artifacts, all critical artifacts preserved
+
+Probe evaluation using Factory's methodology — recall, artifact, continuation, decision probes, LLM judge, 0 to 5 scale.
+
+jeval:     4.75
+Factory:   2.45
+Anthropic: 2.33
+OpenAI:    2.19
+
+
+## Key design decisions
+
+Freeze the encoder: a moving target makes EPE uncalibrated. Freezing all-mpnet-base-v2 gives a fixed semantic geometry so EPE has one meaning across all sessions and predictor versions.
+
+Z-scores not raw thresholds: raw thresholds are hardcoded to one specific trained predictor. Z-scores normalize against the session's own EPE distribution, making the system self-calibrating.
+
+Artifact pattern detection: low EPE does not mean low importance. File paths are predictable so the predictor assigns them low EPE, but src/auth/refresh.ts is the most critical artifact in a coding session. Entries matching src/, .ts, JWT, /api/, Redis, maxRetries always get budget 1.0 regardless of EPE.
+
+Sum not mean in MSE: mean() averaged across 768 dimensions produces 0.003 for orthogonal vectors, indistinguishable from verbatim compression. Sum() preserves the full signal. Dividing by 4 normalizes to [0, 1].
+
+
+## Install
+
+    pip install -e examples/jeval-memory-compression
+
+Set your key:
+
+    export NVIDIA_API_KEY=nvapi-...
+
+Register the hook in ~/.factory/settings.json:
+
+    {
+      "hooks": {
+        "PreCompact": [{
+          "matcher": "*",
+          "hooks": [{
+            "type": "command",
+            "command": "python3 $FACTORY_PROJECT_DIR/examples/jeval-memory-compression/.factory/hooks/precompact_jeval.py"
+          }]
+        }]
+      }
+    }
+
+
+## Train the predictor
+
+    python eval/train.py --epochs 30 --batch_size 128 --n_pairs 5000 --out .factory/hooks/predictor_best.pt
+
+A pretrained checkpoint is included at .factory/hooks/predictor_best.pt, trained on A100, 30 epochs, 5000 synthetic Droid memory pairs.
+
+
+## Run probe evaluation
+
+    python .factory/hooks/score_artifacts.py
+      --memory   .factory/memories.md
+      --original .factory/memories_original.md
+      --model    mistralai/mistral-small-3.1-24b-instruct-2503
+      --out      results.json
+
+
+## Project structure
+
+    jeval/encoders/       frozen target encoder + trainable predictor head
+    jeval/epe/            EPE computation, per-type decomposition, risk weights
+    jeval/strata/         zero-shot NLI content classifier, budget allocator
+    jeval/compression/    adaptive compressor with LLM backend
+    .factory/hooks/       PreCompact hook and probe evaluation harness
+    eval/train.py         predictor training script
+    test_data/            synthetic benchmark session
diff --git a/examples/jeval-memory-compression/eval/train.py b/examples/jeval-memory-compression/eval/train.py
new file mode 100644
index 00000000..2c556093
--- /dev/null
+++ b/examples/jeval-memory-compression/eval/train.py
@@ -0,0 +1,269 @@
+#!/usr/bin/env python3
+"""
+eval/train.py
+
+Trains the JEPA predictor head on synthetic Droid memory compression pairs.
+
+Generates (original, compressed) pairs by:
+  1. Taking realistic Droid memory entries
+  2. Applying word-dropout and truncation as the "compressed" version
+  3. Training predictor to map enc(compressed) → enc(original)
+
+After training, EPE becomes a calibrated signal:
+  high EPE = this compression destroyed semantic content
+  low EPE  = this compression preserved semantic content
+
+Usage:
+  python eval/train.py --epochs 20 --out jeval/encoders/predictor_best.pt
+"""
+
+import argparse
+import random
+import logging
+from pathlib import Path
+
+import torch
+import numpy as np
+from torch.optim import AdamW
+from torch.optim.lr_scheduler import CosineAnnealingLR
+
+from jeval.encoders.sentence_encoder import FrozenEncoder
+from jeval.encoders.predictor_head import PredictorHead
+from jeval.epe.core import EPEComputer
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s")
+log = logging.getLogger("jeval.train")
+
+# ── Synthetic training data ────────────────────────────────────────────────────
+# Realistic Droid memory entries covering all content types.
+# We generate compressed versions via word dropout and truncation.
+
+MEMORY_ENTRIES = [
+    # ENTITY / FACTUAL — file paths, endpoints, error codes
+    "modified src/middleware/auth.ts to add JWT verification middleware",
+    "created src/config/redis.ts with connection pool settings and retry logic",
+    "fixed 401 error on POST /api/login caused by missing Authorization header",
+    "modified src/routes/api.ts to protect GET /api/users with auth middleware",
+    "created tests/auth.test.ts with 14 unit tests for JWT verification",
+    "fixed JWT_SECRET env var mismatch, was JWT_KEY in production",
+    "modified src/server.ts to register cors middleware before route handlers",
+    "created src/monitoring/auth-metrics.ts to track login success rates",
+    "fixed Redis connection timeout by setting maxRetriesPerRequest to 10",
+    "modified src/config/env.ts to consolidate all environment variable names",
+    "created src/middleware/rate-limit.ts with 5 requests per minute on /api/login",
+    "fixed CORS error on /api/login by moving cors() before router in src/server.ts",
+    "modified src/routes/api.ts to add POST /api/refresh for token renewal",
+    "created src/utils/jwt.ts with sign and verify helper functions",
+    "fixed memory leak in src/middleware/auth.ts by clearing expired tokens",
+
+    # CAUSAL — decisions with reasoning
+    "decided to use Redis over Postgres for session storage because connection pool was exhausted under load",
+    "rejected storing JWT in localStorage because of XSS vulnerability risk, using httpOnly cookies instead",
+    "decided to use jsonwebtoken over passport.js because we only need JWT and passport adds complexity",
+    "chose Prometheus over Datadog because we already have a Prometheus instance running in staging",
+    "decided to set token expiry to 24 hours because users complained about being logged out too frequently",
+    "rejected symmetric encryption for tokens because key rotation would invalidate all active sessions",
+    "decided to add rate limiting before deploying to production because of brute force attack risk",
+    "chose Redis pub/sub over WebSockets because the existing infrastructure already supports it",
+    "decided to use refresh tokens because access token expiry was causing poor user experience",
+    "rejected storing session state in memory because it would not survive server restarts",
+
+    # TEMPORAL — next steps, ordering
+    "rotate JWT_SECRET in production before go-live scheduled for Friday",
+    "deploy authentication changes to staging and run smoke tests against /api/login",
+    "PR review needed on src/monitoring/auth-metrics.ts before merge to main",
+    "enable Prometheus scrape target for auth-metrics before enabling alerts",
+    "run load test against /api/login after rate limiting is deployed",
+    "update API documentation to reflect new Authorization header requirement",
+    "schedule security audit of JWT implementation before production release",
+
+    # BACKGROUND — low value ambient content
+    "the afternoon standup went well and the team is aligned on the approach",
+    "all 14 tests are passing in the current build",
+    "the session was productive and good progress was made on authentication",
+    "authentication flow is working end to end in the development environment",
+    "CORS is fixed and the frontend can now reach the login endpoint",
+    "the team agreed to do a code review before merging the auth changes",
+    "staging environment is ready for the authentication deployment",
+]
+
+
+def make_compressed(text: str, strategy: str) -> str:
+    """
+    Generate a compressed version of a memory entry.
+
+    Three strategies mirror real compression failure modes:
+      truncate:     cut the end (loses file paths at end of entry)
+      word_dropout: randomly drop words (loses specific identifiers)
+      abstractify:  replace specific terms with generic ones
+    """
+    words = text.split()
+
+    if strategy == "truncate":
+        # keep 40-70% of words from the start
+        keep = max(3, int(len(words) * random.uniform(0.4, 0.7)))
+        return " ".join(words[:keep])
+
+    elif strategy == "word_dropout":
+        # randomly drop 30-50% of words
+        keep_prob = random.uniform(0.5, 0.7)
+        kept = [w for w in words if random.random() < keep_prob]
+        return " ".join(kept) if kept else words[0]
+
+    elif strategy == "abstractify":
+        # replace specific identifiers with generic terms
+        replacements = {
+            "src/middleware/auth.ts": "the auth file",
+            "src/config/redis.ts": "the config file",
+            "src/routes/api.ts": "the routes file",
+            "src/server.ts": "the server file",
+            "JWT_SECRET": "the secret",
+            "/api/login": "the endpoint",
+            "maxRetriesPerRequest": "the retry setting",
+            "httpOnly": "the cookie flag",
+            "401": "an error code",
+            "Redis": "the cache",
+            "Postgres": "the database",
+        }
+        result = text
+        for specific, generic in replacements.items():
+            result = result.replace(specific, generic)
+        return result
+
+    return text
+
+
+def generate_pairs(n_pairs: int = 2000) -> list[tuple[str, str]]:
+    """
+    Generate (original, compressed) training pairs.
+
+    Mix of strategies to teach the predictor to detect
+    all compression failure modes.
+    """
+    pairs = []
+    strategies = ["truncate", "word_dropout", "abstractify"]
+
+    for _ in range(n_pairs):
+        original   = random.choice(MEMORY_ENTRIES)
+        strategy   = random.choice(strategies)
+        compressed = make_compressed(original, strategy)
+        pairs.append((original, compressed))
+
+    # also add verbatim pairs (EPE should be low for these)
+    for entry in MEMORY_ENTRIES:
+        pairs.append((entry, entry))
+
+    random.shuffle(pairs)
+    return pairs
+
+
+# ── Training loop ──────────────────────────────────────────────────────────────
+
+def train(args):
+    random.seed(42)
+    np.random.seed(42)
+    torch.manual_seed(42)
+
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    log.info("training on %s", device)
+
+    encoder   = FrozenEncoder(device=device)
+    predictor = PredictorHead(d_in=encoder.dim()).to(device)
+    computer  = EPEComputer(encoder, predictor, device=device)
+
+    # generate pairs and split
+    all_pairs  = generate_pairs(n_pairs=args.n_pairs)
+    split      = int(len(all_pairs) * 0.9)
+    train_pairs = all_pairs[:split]
+    val_pairs   = all_pairs[split:]
+    log.info("train=%d  val=%d", len(train_pairs), len(val_pairs))
+
+    opt   = AdamW(predictor.parameters(), lr=args.lr, weight_decay=1e-4)
+    
+    sched = CosineAnnealingLR(opt, T_max=args.epochs)
+
+    best_val  = float("inf")
+    patience  = 0
+    out_path  = Path(args.out)
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+
+    for epoch in range(args.epochs):
+        # ── train ──
+        predictor.train()
+        train_loss, n = 0.0, 0
+        for i in range(0, len(train_pairs), args.batch_size):
+            batch = train_pairs[i:i+args.batch_size]
+            origs = [p[0] for p in batch]
+            comps = [p[1] for p in batch]
+            opt.zero_grad()
+            loss = computer.training_loss(origs, comps)
+            loss.backward()
+            torch.nn.utils.clip_grad_norm_(predictor.parameters(), 1.0)
+            opt.step()
+            train_loss += loss.item()
+            n += 1
+
+        # ── validate ──
+        predictor.eval()
+        val_loss, vn = 0.0, 0
+        with torch.no_grad():
+            for i in range(0, len(val_pairs), args.batch_size):
+                batch = val_pairs[i:i+args.batch_size]
+                val_loss += computer.training_loss(
+                    [p[0] for p in batch], [p[1] for p in batch]
+                ).item()
+                vn += 1
+
+        avg_train = train_loss / max(n, 1)
+        avg_val   = val_loss   / max(vn, 1)
+        sched.step()
+
+        log.info("epoch %2d/%d  train=%.2f  val=%.2f", epoch+1, args.epochs, avg_train, avg_val)
+
+        if avg_val < best_val:
+            best_val  = avg_val
+            patience  = 0
+            torch.save(predictor.state_dict(), out_path)
+            log.info("  saved checkpoint → %s", out_path)
+        else:
+            patience += 1
+            if patience >= args.patience:
+                log.info("early stopping at epoch %d", epoch+1)
+                break
+
+    log.info("training complete. best val loss=%.4f", best_val)
+    log.info("checkpoint saved to %s", out_path)
+
+    # ── quick sanity check ──
+    predictor.load_state_dict(torch.load(out_path, map_location=device))
+    predictor.eval()
+
+    log.info("\n── Sanity Check ──")
+    test_cases = [
+        ("modified src/middleware/auth.ts to add JWT verification",
+         "modified the auth file",
+         "abstractify — should have HIGH EPE"),
+        ("modified src/middleware/auth.ts to add JWT verification",
+         "modified src/middleware/auth.ts to add JWT verification",
+         "verbatim — should have LOW EPE"),
+        ("fixed 401 error on /api/login caused by missing Authorization header",
+         "fixed error on the endpoint",
+         "abstractify — should have HIGH EPE"),
+    ]
+
+    computer2 = EPEComputer(encoder, predictor, device=device)
+    for orig, comp, label in test_cases:
+        r = computer2.compute(orig, comp)
+        log.info("EPE=%.4f  %s", r.epe, label)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--epochs",     type=int,   default=20)
+    parser.add_argument("--batch_size", type=int,   default=64)
+    parser.add_argument("--lr",         type=float, default=3e-4)
+    parser.add_argument("--n_pairs",    type=int,   default=2000)
+    parser.add_argument("--patience",   type=int,   default=4)
+    parser.add_argument("--out",        type=str,   default=".factory/hooks/predictor_best.pt")
+    args = parser.parse_args()
+    train(args)
diff --git a/examples/jeval-memory-compression/generate_slides.py b/examples/jeval-memory-compression/generate_slides.py
new file mode 100644
index 00000000..299189fb
--- /dev/null
+++ b/examples/jeval-memory-compression/generate_slides.py
@@ -0,0 +1,258 @@
+"""
+generate_slides.py
+Run: python generate_slides.py
+Output: jeval.pptx  — open directly in Google Slides
+"""
+
+from pptx import Presentation
+from pptx.util import Inches, Pt, Emu
+from pptx.dml.color import RGBColor
+from pptx.enum.text import PP_ALIGN
+
+BLACK  = RGBColor(0, 0, 0)
+WHITE  = RGBColor(255, 255, 255)
+GREY   = RGBColor(160, 160, 160)
+LGREY  = RGBColor(230, 230, 230)
+MONO   = "Courier New"
+SANS   = "Courier New"
+
+W = Inches(13.33)   # widescreen 16:9
+H = Inches(7.5)
+
+prs = Presentation()
+prs.slide_width  = W
+prs.slide_height = H
+
+BLANK = prs.slide_layouts[6]  # completely blank
+
+
+def slide():
+    return prs.slides.add_slide(BLANK)
+
+
+def box(sl, left, top, width, height,
+        text="", size=14, bold=False, color=BLACK,
+        font=SANS, align=PP_ALIGN.LEFT, wrap=True):
+    txBox = sl.shapes.add_textbox(
+        Inches(left), Inches(top), Inches(width), Inches(height)
+    )
+    tf = txBox.text_frame
+    tf.word_wrap = wrap
+    p  = tf.paragraphs[0]
+    p.alignment = align
+    run = p.add_run()
+    run.text = text
+    run.font.name  = font
+    run.font.size  = Pt(size)
+    run.font.bold  = bold
+    run.font.color.rgb = color
+    return txBox
+
+
+def label(sl, text):
+    box(sl, 0.8, 0.5, 11, 0.4, text, size=9, color=GREY, font=MONO)
+
+
+def hline(sl, top):
+    line = sl.shapes.add_connector(1, Inches(0.8), Inches(top), Inches(12.5), Inches(top))
+    line.line.color.rgb = LGREY
+    line.line.width = Pt(0.5)
+
+
+def codebox(sl, left, top, width, height, text):
+    shape = sl.shapes.add_shape(1, Inches(left), Inches(top), Inches(width), Inches(height))
+    shape.fill.solid()
+    shape.fill.fore_color.rgb = RGBColor(248, 248, 248)
+    shape.line.color.rgb = LGREY
+    tf = shape.text_frame
+    tf.word_wrap = True
+    p = tf.paragraphs[0]
+    p.alignment = PP_ALIGN.LEFT
+    run = p.add_run()
+    run.text = text
+    run.font.name = MONO
+    run.font.size = Pt(11)
+    run.font.color.rgb = BLACK
+
+
+def multiline(sl, left, top, width, lines, size=13, gap=0.38, color=BLACK, bold_first=False):
+    for i, line in enumerate(lines):
+        b = bold_first and i == 0
+        box(sl, left, top + i * gap, width, gap + 0.1,
+            line, size=size, bold=b, color=color if not (b) else BLACK)
+
+
+# ── Slide 1: Title ────────────────────────────────────────────
+s = slide()
+box(s, 0.8, 1.2, 10, 0.5, "FACTORY AI · MARCH 2026", size=9, color=GREY)
+box(s, 0.8, 1.9, 10, 1.2, "jeval", size=52, bold=True)
+box(s, 0.8, 3.3, 8,  0.6,
+    "JEPA-based semantic fidelity verification for Droid memory compression",
+    size=18)
+box(s, 0.8, 5.8, 10, 0.4,
+    "github.com/Pshyam17/factory  ·  feat/jeval-memory-compression",
+    size=9, color=GREY)
+
+# ── Slide 2: Problem ─────────────────────────────────────────
+s = slide()
+label(s, "THE PROBLEM")
+box(s, 0.8, 1.1, 11, 1.2,
+    "Artifact tracking scores 2.45/5 across every compression method.",
+    size=26, bold=True)
+
+rows = [("Factory (best)", 2.45), ("Anthropic", 2.33), ("OpenAI", 2.19)]
+for i, (name, score) in enumerate(rows):
+    y = 2.8 + i * 0.6
+    box(s, 0.8, y, 2.0, 0.4, name, size=13, color=GREY)
+    bar = s.shapes.add_shape(1, Inches(2.9), Inches(y + 0.1),
+                              Inches(score / 5 * 7), Inches(0.18))
+    bar.fill.solid(); bar.fill.fore_color.rgb = BLACK
+    bar.line.fill.background()
+    box(s, 10.1, y, 0.8, 0.4, str(score), size=13, bold=True)
+
+hline(s, 4.8)
+box(s, 0.8, 4.9, 11, 0.8,
+    '"Artifact tracking may need dedicated state tracking beyond summarization."\n— Factory AI, Dec 2025',
+    size=11, color=GREY)
+
+# ── Slide 3: Core Idea ───────────────────────────────────────
+s = slide()
+label(s, "THE CORE IDEA")
+box(s, 0.8, 1.1, 10, 1.0,
+    "Use JEPA's prediction residual as a pre-hoc fidelity oracle.",
+    size=24, bold=True)
+codebox(s, 0.8, 2.4, 11.5, 1.8,
+    "# standard JEPA — training signal\n"
+    "L = ||predictor(enc(compressed)) - enc(original)||²\n\n"
+    "# jeval — fidelity measurement\n"
+    "EPE(T, C) = sum((pred(enc(C)) - enc(T))²) / 4")
+multiline(s, 0.8, 4.6, 11,
+    ["· No prior work uses the JEPA residual as an external fidelity metric",
+     "· EPE = 0 → perfect reconstruction   EPE = 1 → total semantic loss",
+     "· Sensitive to role reversal, negation, causal inversion — cosine is not"],
+    size=13, color=GREY)
+
+# ── Slide 4: Architecture ────────────────────────────────────
+s = slide()
+label(s, "ARCHITECTURE")
+steps = [
+    ("01", "SEGMENT",  "bullet points + headers → individual entries"),
+    ("02", "CLASSIFY", "zero-shot NLI → FACTUAL / CAUSAL / ENTITY / TEMPORAL / CONTRASTIVE / BACKGROUND"),
+    ("03", "EPE",      "trained JEPA predictor → embedding prediction error per segment"),
+    ("04", "BUDGET",   "z-score + content type → compression tier per segment"),
+    ("05", "COMPRESS", "Mistral via NVIDIA NIM · budget=1.0 verbatim · budget=0.3 aggressive"),
+]
+for i, (num, title, desc) in enumerate(steps):
+    y = 1.1 + i * 1.0
+    box(s, 0.8, y, 0.5, 0.5, num,  size=11, color=GREY)
+    box(s, 1.4, y, 1.6, 0.5, title, size=13, bold=True)
+    box(s, 3.2, y, 9.5, 0.5, desc,  size=13, color=GREY)
+    if i < len(steps) - 1:
+        hline(s, y + 0.75)
+
+# ── Slide 5: Design Decisions ────────────────────────────────
+s = slide()
+label(s, "KEY DESIGN DECISIONS")
+decisions = [
+    ("Why freeze the encoder?",
+     "A moving target makes EPE uncalibrated. Freezing all-mpnet-base-v2 gives a fixed semantic geometry — EPE has one meaning across all sessions."),
+    ("Why z-scores not raw thresholds?",
+     "Raw thresholds are hardcoded to one trained predictor. Z-scores normalize against the session's own EPE distribution — self-calibrating."),
+    ("Why artifact pattern detection?",
+     "Low EPE ≠ low importance. File paths are predictable so the predictor assigns them low EPE — but src/auth/refresh.ts is critical. Pattern detection overrides EPE."),
+    ("Why sum not mean in MSE?",
+     "mean() / 768 dims = 0.003 for orthogonal vectors — indistinguishable from verbatim. sum() preserves the full signal. /4 normalizes to [0,1]."),
+]
+for i, (q, a) in enumerate(decisions):
+    y = 1.1 + i * 1.4
+    box(s, 0.8, y,       11, 0.45, q, size=13, bold=True)
+    box(s, 0.8, y + 0.45, 11, 0.7, a, size=12, color=GREY)
+
+# ── Slide 6: Training ────────────────────────────────────────
+s = slide()
+label(s, "TRAINING THE PREDICTOR")
+box(s, 0.8, 1.1, 5, 0.4, "Setup", size=14, bold=True)
+multiline(s, 0.8, 1.6, 5.5,
+    ["Frozen encoder: all-mpnet-base-v2",
+     "Predictor: 3-layer Pre-LN transformer",
+     "5,000 synthetic pairs · 30 epochs · A100",
+     "3 compression strategies:",
+     "  · truncate (cut end)",
+     "  · word dropout (30–50%)",
+     "  · abstractify (replace specifics)"],
+    size=12, color=GREY)
+box(s, 6.8, 1.1, 5.5, 0.4, "Sanity check after training", size=14, bold=True)
+codebox(s, 6.8, 1.6, 5.7, 2.2,
+    "verbatim    EPE = 0.0060  ✓\n"
+    "abstractify EPE = 0.1023  ✓\n"
+    "abstractify EPE = 0.1687  ✓\n\n"
+    "17–28× separation")
+
+# ── Slide 7: Results ─────────────────────────────────────────
+s = slide()
+label(s, "RESULTS")
+box(s, 0.8, 1.0, 11, 0.4, "Artifact survival — 3 iterative compression rounds", size=13, bold=True)
+rows2 = [("Stage 1","84 tokens","6/10","future artifacts not yet written"),
+         ("Stage 2","175 tokens","9/10",""),
+         ("Stage 3","261 tokens","10/10","all critical artifacts preserved ✓")]
+for i,(st,tk,sc,n) in enumerate(rows2):
+    y = 1.5 + i*0.5
+    box(s, 0.8, y, 1.0, 0.4, st, size=12, color=GREY)
+    box(s, 2.0, y, 1.5, 0.4, tk, size=12, color=GREY)
+    box(s, 3.7, y, 1.2, 0.4, sc, size=12, bold=(sc=="10/10"))
+    box(s, 5.1, y, 7.0, 0.4, n,  size=11, color=GREY)
+    hline(s, y + 0.45)
+
+box(s, 0.8, 3.4, 11, 0.4, "Artifact tracking vs Factory baseline", size=13, bold=True)
+results = [("jeval","4.75",True),("Factory","2.45",False),("Anthropic","2.33",False),("OpenAI","2.19",False)]
+for i,(m,a,bold) in enumerate(results):
+    y = 3.9 + i*0.6
+    box(s, 0.8, y, 1.5, 0.45, m, size=13, bold=bold)
+    bar_w = float(a) / 5 * 7
+    bar = s.shapes.add_shape(1, Inches(2.5), Inches(y+0.12),
+                              Inches(bar_w), Inches(0.2))
+    bar.fill.solid()
+    bar.fill.fore_color.rgb = BLACK if bold else LGREY
+    bar.line.fill.background()
+    box(s, 9.8, y, 0.8, 0.45, a, size=13, bold=bold)
+    if bold:
+        box(s, 10.7, y, 1.5, 0.45, "+94%", size=9, color=GREY)
+
+# ── Slide 8: Next Steps ──────────────────────────────────────
+s = slide()
+label(s, "NEXT STEPS")
+nexts = [
+    ("01","Real session validation",
+     "Retrain predictor on Droid production sessions. Run probe eval across 20-30 sessions with confidence intervals."),
+    ("02","Ablation study",
+     "Quantify contribution of each component: EPE alone, z-scores alone, artifact patterns alone, full system."),
+    ("03","Incremental architecture",
+     "Classify + compute EPE per entry as it's written. PreCompact reads cached values. Hook latency → <500ms."),
+    ("04","EMNLP 2026 System Demos",
+     "Deadline July 4, 2026. Working system + empirical results on published benchmark."),
+]
+for i,(num,title,desc) in enumerate(nexts):
+    y = 1.1 + i * 1.4
+    box(s, 0.8, y,        0.5, 0.45, num,   size=11, color=GREY)
+    box(s, 1.4, y,        3.2, 0.45, title, size=13, bold=True)
+    box(s, 1.4, y + 0.5,  11,  0.7,  desc,  size=12, color=GREY)
+
+# ── Slide 9: Install ─────────────────────────────────────────
+s = slide()
+label(s, "INSTALL")
+codebox(s, 0.8, 1.2, 11.5, 3.2,
+    "# install\n"
+    "pip install -e examples/jeval-memory-compression\n\n"
+    "# set key\n"
+    "export NVIDIA_API_KEY=nvapi-...\n\n"
+    "# register hook in ~/.factory/settings.json\n"
+    '"PreCompact": [{ "type": "command",\n'
+    '  "command": "python3 $PROJECT_DIR/...precompact_jeval.py" }]')
+multiline(s, 0.8, 5.0, 12,
+    ["github.com/Pshyam17/factory   ·   feat/jeval-memory-compression   ·   PR #785 open"],
+    size=10, color=GREY)
+
+# ── Save ─────────────────────────────────────────────────────
+prs.save("jeval.pptx")
+print("✓ saved jeval.pptx")
+print("  upload to Google Slides via File → Import slides")
\ No newline at end of file
diff --git a/examples/jeval-memory-compression/jeval.pptx b/examples/jeval-memory-compression/jeval.pptx
new file mode 100644
index 00000000..f4042bd2
Binary files /dev/null and b/examples/jeval-memory-compression/jeval.pptx differ
diff --git a/examples/jeval-memory-compression/jeval/__init__.py b/examples/jeval-memory-compression/jeval/__init__.py
new file mode 100644
index 00000000..f001e7e0
--- /dev/null
+++ b/examples/jeval-memory-compression/jeval/__init__.py
@@ -0,0 +1,4 @@
+from .encoders import Encoder, FrozenEncoder, PredictorHead
+from .epe import EPEComputer, EPEResult
+from .strata import ContentClassifier, ContentType, BudgetAllocator
+from .compression import AdaptiveCompressor
diff --git a/examples/jeval-memory-compression/jeval/compression/__init__.py b/examples/jeval-memory-compression/jeval/compression/__init__.py
new file mode 100644
index 00000000..25d452d6
--- /dev/null
+++ b/examples/jeval-memory-compression/jeval/compression/__init__.py
@@ -0,0 +1 @@
+from .adaptive import AdaptiveCompressor
diff --git a/examples/jeval-memory-compression/jeval/compression/adaptive.py b/examples/jeval-memory-compression/jeval/compression/adaptive.py
new file mode 100644
index 00000000..b01492d9
--- /dev/null
+++ b/examples/jeval-memory-compression/jeval/compression/adaptive.py
@@ -0,0 +1,128 @@
+import re
+import os
+import json
+import urllib.request
+from jeval.epe.core import EPEComputer
+from jeval.strata.classifier import ContentClassifier
+from jeval.strata.budget import BudgetAllocator, SegmentPlan
+
+MIN_WORDS_TO_COMPRESS = 8
+NVIDIA_API_URL = "https://integrate.api.nvidia.com/v1/chat/completions"
+NVIDIA_MODEL   = "mistralai/mistral-small-3.1-24b-instruct-2503"
+
+
+def _segment(text: str) -> list[str]:
+    segments = []
+    for line in text.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        if line.startswith("##") or line.startswith("-"):
+            segments.append(line)
+        else:
+            if segments:
+                segments[-1] += " " + line
+            else:
+                segments.append(line)
+    return [s for s in segments if len(s.split()) >= 3]
+
+
+def _llm_compress(segment: str, budget: float) -> str:
+    """
+    Use Mistral via NVIDIA NIM to compress a segment to the target budget.
+    Falls back to word truncation if API call fails or key is missing.
+    """
+    api_key = os.environ.get("NVIDIA_API_KEY")
+    if not api_key:
+        words = segment.split()
+        keep  = max(1, int(len(words) * budget))
+        return " ".join(words[:keep])
+
+    target_words = max(4, int(len(segment.split()) * budget))
+    prompt = (
+        f"Summarize the following in at most {target_words} words. "
+        f"Preserve any file paths, function names, error codes, and variable names exactly. "
+        f"Return only the summary, no explanation.\n\n{segment}"
+    )
+
+    payload = json.dumps({
+        "model": NVIDIA_MODEL,
+        "messages": [{"role": "user", "content": prompt}],
+        "max_tokens": 128,
+        "temperature": 0.0,
+    }).encode()
+
+    req = urllib.request.Request(
+        NVIDIA_API_URL,
+        data=payload,
+        headers={
+            "Content-Type":  "application/json",
+            "Authorization": f"Bearer {api_key}",
+        },
+    )
+
+    try:
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            data    = json.loads(resp.read())
+            summary = data["choices"][0]["message"]["content"].strip()
+            return summary
+    except Exception:
+        words = segment.split()
+        keep  = max(1, int(len(words) * budget))
+        return " ".join(words[:keep])
+
+
+def _apply_budget(segment: str, budget: float) -> str:
+    if budget >= 1.0:
+        return segment
+    if len(segment.split()) < MIN_WORDS_TO_COMPRESS:
+        return segment
+    return _llm_compress(segment, budget)
+
+
+class AdaptiveCompressor:
+    """
+    EPE-guided adaptive compressor for Droid memory files.
+
+    Pipeline:
+      1. Segment by bullet points and headers
+      2. Classify each segment by content type
+      3. Compute EPE vs proxy compression
+      4. Build per-segment budget plan (z-score calibrated)
+      5. Apply budgets via LLM summarization
+    """
+
+    def __init__(
+        self,
+        computer: EPEComputer,
+        classifier: ContentClassifier,
+        allocator: BudgetAllocator,
+    ):
+        self.computer   = computer
+        self.classifier = classifier
+        self.allocator  = allocator
+
+    def compress(
+        self,
+        memory_text: str,
+        segments: list[str] | None = None,
+    ) -> tuple[str, list[SegmentPlan]]:
+        if segments is None:
+            segments = _segment(memory_text)
+
+        if not segments:
+            return memory_text, []
+
+        clf_results = self.classifier.classify_batch(segments)
+        proxy       = [_apply_budget(s, 0.8) for s in segments]
+        epe_results = self.computer.compute_batch(
+            segments, proxy,
+            seg_ids=[str(i) for i in range(len(segments))]
+        )
+
+        plan = self.allocator.plan(segments, epe_results, clf_results)
+
+        compressed_parts = [_apply_budget(p.segment, p.budget) for p in plan]
+        compressed_text  = "\n".join(compressed_parts)
+
+        return compressed_text, plan
diff --git a/examples/jeval-memory-compression/jeval/encoders/__init__.py b/examples/jeval-memory-compression/jeval/encoders/__init__.py
new file mode 100644
index 00000000..b10bfc4e
--- /dev/null
+++ b/examples/jeval-memory-compression/jeval/encoders/__init__.py
@@ -0,0 +1,3 @@
+from .base import Encoder
+from .sentence_encoder import FrozenEncoder
+from .predictor_head import PredictorHead
diff --git a/examples/jeval-memory-compression/jeval/encoders/base.py b/examples/jeval-memory-compression/jeval/encoders/base.py
new file mode 100644
index 00000000..d7153f74
--- /dev/null
+++ b/examples/jeval-memory-compression/jeval/encoders/base.py
@@ -0,0 +1,29 @@
+from abc import ABC, abstractmethod
+import torch
+from torch import Tensor
+
+
+class Encoder(ABC):
+    """
+    Every encoder in jeval speaks this interface.
+    The EPE computer only ever calls .encode() and .dim() —
+    it never knows whether it is talking to the frozen sentence
+    encoder or anything else. That is the point.
+    """
+
+    @abstractmethod
+    def encode(self, texts: list[str]) -> Tensor:
+        # Returns shape (batch_size, embedding_dim).
+        # ALWAYS L2-normalized — every subclass must guarantee this.
+        ...
+
+    @abstractmethod
+    def dim(self) -> int:
+        # Returns the size of the embedding dimension.
+        ...
+
+    def normalize(self, x: Tensor) -> Tensor:
+        # normalize lives here so every subclass gets it for free.
+        # one implementation, one place to fix if the math changes.
+        # p=2 = L2 norm. dim=-1 = normalize along embedding dimension.
+        return torch.nn.functional.normalize(x, p=2, dim=-1)
diff --git a/examples/jeval-memory-compression/jeval/encoders/predictor_head.py b/examples/jeval-memory-compression/jeval/encoders/predictor_head.py
new file mode 100644
index 00000000..a109b24c
--- /dev/null
+++ b/examples/jeval-memory-compression/jeval/encoders/predictor_head.py
@@ -0,0 +1,47 @@
+import torch
+import torch.nn as nn
+from torch import Tensor
+
+
+class PredictorHead(nn.Module):
+    """
+    The trainable half of the JEPA setup.
+    Input:  enc(compressed memory entry)  — shape (batch, d_in)
+    Output: predicted enc(original entry) — shape (batch, d_in)
+    The gap between output and reality = EPE.
+    """
+
+    def __init__(
+        self,
+        d_in: int = 768,
+        d_hidden: int = 512,
+        n_layers: int = 3,
+        n_heads: int = 8,
+        dropout: float = 0.1,
+    ):
+        super().__init__()
+        self.in_proj = nn.Linear(d_in, d_hidden)
+        layer = nn.TransformerEncoderLayer(
+            d_model=d_hidden,
+            nhead=n_heads,
+            dim_feedforward=d_hidden * 4,
+            dropout=dropout,
+            batch_first=True,
+            norm_first=True,
+        )
+        self.transformer = nn.TransformerEncoder(layer, num_layers=n_layers)
+        self.out_proj = nn.Linear(d_hidden, d_in)
+        self._init_weights()
+
+    def _init_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Linear):
+                nn.init.xavier_uniform_(m.weight)
+                if m.bias is not None:
+                    nn.init.zeros_(m.bias)
+
+    def forward(self, x: Tensor) -> Tensor:
+        x = self.in_proj(x).unsqueeze(1)
+        x = self.transformer(x).squeeze(1)
+        x = self.out_proj(x)
+        return nn.functional.normalize(x, p=2, dim=-1)
diff --git a/examples/jeval-memory-compression/jeval/encoders/sentence_encoder.py b/examples/jeval-memory-compression/jeval/encoders/sentence_encoder.py
new file mode 100644
index 00000000..73ea7b5d
--- /dev/null
+++ b/examples/jeval-memory-compression/jeval/encoders/sentence_encoder.py
@@ -0,0 +1,36 @@
+import torch
+from torch import Tensor
+from sentence_transformers import SentenceTransformer
+from .base import Encoder
+
+
+class FrozenEncoder(Encoder):
+    """
+    Frozen SentenceTransformer — the JEPA target encoder.
+    Its job: define what semantic content is.
+    We never touch its weights. Ever.
+    """
+
+    def __init__(self, model: str = "all-mpnet-base-v2", device: str = "cpu"):
+        self._model = SentenceTransformer(model, device=device)
+        for p in self._model.parameters():
+            p.requires_grad = False
+        self._dim = self._model.get_sentence_embedding_dimension()
+
+    def encode(self, texts: list[str]) -> Tensor:
+        with torch.no_grad():
+            emb = self._model.encode(
+                texts,
+                convert_to_tensor=True,
+                normalize_embeddings=False,
+                show_progress_bar=False,
+            )
+        return self.normalize(emb)
+
+    def encode_chunked(self, texts: list[str], chunk: int = 32) -> Tensor:
+        return torch.cat(
+            [self.encode(texts[i:i+chunk]) for i in range(0, len(texts), chunk)]
+        )
+
+    def dim(self) -> int:
+        return self._dim
diff --git a/examples/jeval-memory-compression/jeval/epe/__init__.py b/examples/jeval-memory-compression/jeval/epe/__init__.py
new file mode 100644
index 00000000..a8b3680f
--- /dev/null
+++ b/examples/jeval-memory-compression/jeval/epe/__init__.py
@@ -0,0 +1,3 @@
+from .weights import RISK_WEIGHTS
+from .core import EPEComputer, EPEResult
+from .decomposer import EPEDecomposer, DecomposedEPE
diff --git a/examples/jeval-memory-compression/jeval/epe/core.py b/examples/jeval-memory-compression/jeval/epe/core.py
new file mode 100644
index 00000000..1af4dc0b
--- /dev/null
+++ b/examples/jeval-memory-compression/jeval/epe/core.py
@@ -0,0 +1,65 @@
+from dataclasses import dataclass
+import torch
+import torch.nn as nn
+from torch import Tensor
+
+from jeval.encoders.sentence_encoder import FrozenEncoder
+from jeval.encoders.predictor_head import PredictorHead
+
+
+@dataclass
+class EPEResult:
+    epe: float
+    orig_emb: Tensor
+    comp_emb: Tensor
+    pred_emb: Tensor
+    ratio: float
+    seg_id: str = ""
+
+
+class EPEComputer:
+    """
+    Computes EPE = sum((predictor(enc(C)) - enc(T))^2) / 4.0
+
+    sum() keeps the full signal across 768 dims.
+    /4.0 normalizes to [0,1] — max sum squared distance between
+    unit vectors is 4.0 (perfectly opposite directions).
+    """
+
+    def __init__(self, encoder: FrozenEncoder, predictor: PredictorHead, device: str = "cpu"):
+        self.enc     = encoder
+        self.pred    = predictor
+        self.device  = device
+        self.loss_fn = nn.MSELoss(reduction="sum")
+
+    def _epe(self, pred_emb: Tensor, orig_emb: Tensor) -> float:
+        return self.loss_fn(pred_emb, orig_emb).item() / 4.0
+
+    def compute(self, original: str, compressed: str) -> EPEResult:
+        orig_emb = self.enc.encode([original]).squeeze(0)
+        comp_emb = self.enc.encode([compressed]).squeeze(0)
+        with torch.no_grad():
+            pred_emb = self.pred(comp_emb.unsqueeze(0)).squeeze(0)
+        epe   = self._epe(pred_emb, orig_emb)
+        ratio = len(compressed.split()) / max(len(original.split()), 1)
+        return EPEResult(epe, orig_emb.cpu(), comp_emb.cpu(), pred_emb.cpu(), ratio)
+
+    def compute_batch(self, originals, compresseds, seg_ids=None):
+        orig_embs = self.enc.encode_chunked(originals)
+        comp_embs = self.enc.encode_chunked(compresseds)
+        with torch.no_grad():
+            pred_embs = self.pred(comp_embs)
+        epes   = ((pred_embs - orig_embs) ** 2).sum(dim=-1) / 4.0
+        ratios = [len(c.split()) / max(len(o.split()), 1) for o, c in zip(originals, compresseds)]
+        return [
+            EPEResult(epes[i].item(), orig_embs[i].cpu(), comp_embs[i].cpu(),
+                      pred_embs[i].cpu(), ratios[i], seg_ids[i] if seg_ids else "")
+            for i in range(len(originals))
+        ]
+
+    def training_loss(self, originals, compresseds) -> Tensor:
+        with torch.no_grad():
+            orig_embs = self.enc.encode_chunked(originals)
+            comp_embs = self.enc.encode_chunked(compresseds)
+        pred_embs = self.pred(comp_embs)
+        return self.loss_fn(pred_embs, orig_embs)
diff --git a/examples/jeval-memory-compression/jeval/epe/decomposer.py b/examples/jeval-memory-compression/jeval/epe/decomposer.py
new file mode 100644
index 00000000..a1117926
--- /dev/null
+++ b/examples/jeval-memory-compression/jeval/epe/decomposer.py
@@ -0,0 +1,70 @@
+from dataclasses import dataclass, field
+import numpy as np
+import torch
+
+from jeval.epe.core import EPEComputer, EPEResult
+from jeval.epe.weights import RISK_WEIGHTS
+from jeval.strata.classifier import ContentClassifier, ContentType
+
+
+@dataclass
+class TypeStats:
+    ct: ContentType
+    results: list[EPEResult] = field(default_factory=list)
+
+    @property
+    def mean(self) -> float:
+        return float(np.mean([r.epe for r in self.results])) if self.results else 0.0
+
+    @property
+    def max(self) -> float:
+        return float(np.max([r.epe for r in self.results])) if self.results else 0.0
+
+    @property
+    def n(self) -> int:
+        return len(self.results)
+
+
+@dataclass
+class DecomposedEPE:
+    by_type: dict[ContentType, TypeStats]
+    global_epe: float
+    weighted_risk: float
+
+    def risk_map(self):
+        return {ct: s.mean * RISK_WEIGHTS[ct.value] for ct, s in self.by_type.items() if s.n > 0}
+
+    def summary(self) -> str:
+        lines = [f"global_epe={self.global_epe:.4f}  weighted_risk={self.weighted_risk:.4f}"]
+        for ct, s in sorted(self.by_type.items(), key=lambda x: -x[1].mean):
+            if s.n:
+                lines.append(f"  {ct.value:20s}  n={s.n:3d}  mean={s.mean:.4f}")
+        return "\n".join(lines)
+
+
+class EPEDecomposer:
+    def __init__(self, computer: EPEComputer, classifier: ContentClassifier):
+        self.computer   = computer
+        self.classifier = classifier
+
+    def decompose(self, orig_segs, comp_segs) -> DecomposedEPE:
+        assert len(orig_segs) == len(comp_segs)
+        clf_results = self.classifier.classify_batch(orig_segs)
+        epe_results = self.computer.compute_batch(orig_segs, comp_segs,
+                                                   seg_ids=[str(i) for i in range(len(orig_segs))])
+        by_type = {ct: TypeStats(ct) for ct in ContentType}
+        for clf, epe in zip(clf_results, epe_results):
+            by_type[clf.content_type].results.append(epe)
+        all_epes      = [r.epe for r in epe_results]
+        global_epe    = float(np.mean(all_epes)) if all_epes else 0.0
+        weighted_risk = sum(s.mean * RISK_WEIGHTS[ct.value] for ct, s in by_type.items() if s.n)
+        return DecomposedEPE(by_type=by_type, global_epe=global_epe, weighted_risk=weighted_risk)
+
+    def align_abstractive(self, orig_segs, compressed_text):
+        import nltk
+        comp_sents = nltk.sent_tokenize(compressed_text)
+        orig_embs  = self.computer.enc.encode_chunked(orig_segs)
+        comp_embs  = self.computer.enc.encode_chunked(comp_sents)
+        sim        = torch.mm(orig_embs, comp_embs.T)
+        best       = sim.argmax(dim=1).tolist()
+        return orig_segs, [comp_sents[i] for i in best]
diff --git a/examples/jeval-memory-compression/jeval/epe/weights.py b/examples/jeval-memory-compression/jeval/epe/weights.py
new file mode 100644
index 00000000..34f06e66
--- /dev/null
+++ b/examples/jeval-memory-compression/jeval/epe/weights.py
@@ -0,0 +1,10 @@
+# Risk weights live here so neither decomposer nor budget
+# has to import from each other — breaks the circular dependency.
+RISK_WEIGHTS = {
+    "factual_claim":   1.00,
+    "causal_chain":    0.95,
+    "entity_role":     0.85,
+    "temporal_anchor": 0.75,
+    "contrastive":     0.70,
+    "background":      0.20,
+}
diff --git a/examples/jeval-memory-compression/jeval/strata/__init__.py b/examples/jeval-memory-compression/jeval/strata/__init__.py
new file mode 100644
index 00000000..4485b26a
--- /dev/null
+++ b/examples/jeval-memory-compression/jeval/strata/__init__.py
@@ -0,0 +1,2 @@
+from .classifier import ContentClassifier, ContentType, Classification, FAST_MODEL, PROD_MODEL
+from .budget import BudgetAllocator, SegmentPlan
diff --git a/examples/jeval-memory-compression/jeval/strata/budget.py b/examples/jeval-memory-compression/jeval/strata/budget.py
new file mode 100644
index 00000000..87f535b8
--- /dev/null
+++ b/examples/jeval-memory-compression/jeval/strata/budget.py
@@ -0,0 +1,98 @@
+from dataclasses import dataclass
+import re
+import numpy as np
+from jeval.strata.classifier import ContentType, Classification
+from jeval.epe.weights import RISK_WEIGHTS
+
+
+@dataclass
+class SegmentPlan:
+    segment: str
+    content_type: ContentType
+    confidence: float
+    epe: float
+    weighted_risk: float
+    budget: float
+
+
+# content types that must survive compression verbatim
+_PROTECT  = {ContentType.ENTITY, ContentType.FACTUAL, ContentType.CAUSAL}
+_COMPRESS = {ContentType.BACKGROUND}
+
+# patterns that indicate artifact content — always protect regardless of EPE
+_ARTIFACT_PATTERNS = re.compile(
+    r'src/|\.ts|\.js|\.py|\.go|/api/|JWT|Redis|Postgres|maxRetries|httpOnly',
+    re.IGNORECASE
+)
+
+
+class BudgetAllocator:
+    """
+    Maps (content_type, EPE z-score, confidence) -> compression budget.
+
+    Key insight: low EPE != low importance.
+    Low EPE means the predictor thinks the content is easy to reconstruct.
+    But file paths, error codes, and variable names are predictable AND critical.
+    We protect them via artifact pattern detection regardless of EPE.
+
+    Decision hierarchy:
+      1. Contains artifact pattern -> 1.0 (always protect)
+      2. z > +high_z -> 1.0 (high EPE = fragile content)
+      3. z < -low_z AND BACKGROUND type -> 0.3 (low EPE + low value)
+      4. Content type + confidence -> type-based decision
+      5. Default -> 0.7 (light compression)
+    """
+
+    def __init__(
+        self,
+        high_z: float = 0.5,
+        low_z: float = -0.5,
+        confidence_threshold: float = 0.35,
+    ):
+        self.high_z       = high_z
+        self.low_z        = low_z
+        self.conf_thresh  = confidence_threshold
+
+    def plan(self, segments, epe_results, classifications) -> list[SegmentPlan]:
+        epe_vals = np.array([r.epe for r in epe_results])
+        mean_epe = float(np.mean(epe_vals))
+        std_epe  = float(np.std(epe_vals)) or 1e-6
+
+        plans = []
+        for seg, epe_r, clf in zip(segments, epe_results, classifications):
+            w_risk = epe_r.epe * RISK_WEIGHTS.get(clf.content_type.value, 1.0)
+            z      = (epe_r.epe - mean_epe) / std_epe
+            budget = self._budget(seg, clf, z)
+            plans.append(SegmentPlan(
+                segment=seg,
+                content_type=clf.content_type,
+                confidence=clf.confidence,
+                epe=epe_r.epe,
+                weighted_risk=w_risk,
+                budget=budget,
+            ))
+        return plans
+
+    def _budget(self, segment: str, clf: Classification, z: float) -> float:
+        # Rule 1: artifact pattern detected -> always verbatim
+        # this is the fix for "low EPE != low importance"
+        if _ARTIFACT_PATTERNS.search(segment):
+            return 1.0
+
+        # Rule 2: high z-score -> content is fragile -> protect
+        if z > self.high_z:
+            return 1.0
+
+        # Rule 3: low z-score + background type -> safe to compress aggressively
+        if z < self.low_z and clf.content_type in _COMPRESS:
+            return 0.3
+
+        # Rule 4: content type + confidence for ambiguous zone
+        if clf.confidence >= self.conf_thresh:
+            if clf.content_type in _PROTECT:
+                return 1.0
+            if clf.content_type in _COMPRESS:
+                return 0.3
+
+        # Rule 5: default light compression
+        return 0.7
diff --git a/examples/jeval-memory-compression/jeval/strata/classifier.py b/examples/jeval-memory-compression/jeval/strata/classifier.py
new file mode 100644
index 00000000..47d36608
--- /dev/null
+++ b/examples/jeval-memory-compression/jeval/strata/classifier.py
@@ -0,0 +1,85 @@
+from enum import Enum
+from dataclasses import dataclass
+from transformers import pipeline
+import torch
+
+
+class ContentType(str, Enum):
+    FACTUAL      = "factual_claim"
+    CAUSAL       = "causal_chain"
+    ENTITY       = "entity_role"
+    TEMPORAL     = "temporal_anchor"
+    CONTRASTIVE  = "contrastive"
+    BACKGROUND   = "background"
+
+
+_LABEL_STRINGS = {
+    ContentType.FACTUAL:     "is a specific technical fact, file path, error code, or API endpoint",
+    ContentType.CAUSAL:      "explains why a decision was made or what caused a problem",
+    ContentType.ENTITY:      "mentions a specific file, function, service, or named component",
+    ContentType.TEMPORAL:    "describes what should happen next or records when something occurred",
+    ContentType.CONTRASTIVE: "compares two approaches or explains what was rejected",
+    ContentType.BACKGROUND:  "is a general status update or ambient note with no specific technical detail",
+}
+
+_STRING_TO_TYPE   = {v: k for k, v in _LABEL_STRINGS.items()}
+_CANDIDATE_LABELS = list(_LABEL_STRINGS.values())
+
+FAST_MODEL = "cross-encoder/nli-MiniLM2-L6-H768"
+PROD_MODEL = "cross-encoder/nli-deberta-v3-large"
+
+
+@dataclass
+class Classification:
+    text: str
+    content_type: ContentType
+    confidence: float
+
+
+class ContentClassifier:
+    """
+    Zero-shot NLI classifier that routes memory segments to content types.
+
+    Use FAST_MODEL for development on CPU.
+    Use PROD_MODEL for final benchmarks.
+    """
+
+    def __init__(
+        self,
+        model: str = PROD_MODEL,
+        device: int = -1,
+        batch_size: int = 32,
+    ):
+        self._pipe = pipeline(
+            "zero-shot-classification",
+            model=model,
+            device=device,
+            dtype=torch.float16,
+        )
+        self.batch_size = batch_size
+
+    def classify(self, text: str) -> Classification:
+        res = self._pipe(text, candidate_labels=_CANDIDATE_LABELS, multi_label=False)
+        return Classification(
+            text=text,
+            content_type=_STRING_TO_TYPE[res["labels"][0]],
+            confidence=res["scores"][0],
+        )
+
+    def classify_batch(self, texts: list[str]) -> list[Classification]:
+        raw = self._pipe(
+            texts,
+            candidate_labels=_CANDIDATE_LABELS,
+            multi_label=False,
+            batch_size=self.batch_size,
+        )
+        if isinstance(raw, dict):
+            raw = [raw]
+        return [
+            Classification(
+                text=t,
+                content_type=_STRING_TO_TYPE[r["labels"][0]],
+                confidence=r["scores"][0],
+            )
+            for t, r in zip(texts, raw)
+        ]
diff --git a/examples/jeval-memory-compression/jeval_memory_compression.egg-info/PKG-INFO b/examples/jeval-memory-compression/jeval_memory_compression.egg-info/PKG-INFO
new file mode 100644
index 00000000..a7d451e8
--- /dev/null
+++ b/examples/jeval-memory-compression/jeval_memory_compression.egg-info/PKG-INFO
@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: jeval-memory-compression
+Version: 0.1.0
+Summary: JEPA-based semantic fidelity evaluation for Droid memory compression
+Requires-Python: >=3.11
+Requires-Dist: torch>=2.2.0
+Requires-Dist: transformers>=4.40.0
+Requires-Dist: sentence-transformers>=3.0.0
+Requires-Dist: nltk>=3.8.1
+Requires-Dist: numpy>=1.26.0
+Requires-Dist: openai>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: black>=24.0.0; extra == "dev"
+Requires-Dist: ruff>=0.4.0; extra == "dev"
diff --git a/examples/jeval-memory-compression/jeval_memory_compression.egg-info/SOURCES.txt b/examples/jeval-memory-compression/jeval_memory_compression.egg-info/SOURCES.txt
new file mode 100644
index 00000000..fa5f52d5
--- /dev/null
+++ b/examples/jeval-memory-compression/jeval_memory_compression.egg-info/SOURCES.txt
@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+jeval/__init__.py
+jeval/compression/__init__.py
+jeval/compression/adaptive.py
+jeval/encoders/__init__.py
+jeval/encoders/base.py
+jeval/encoders/sentence_encoder.py
+jeval/epe/__init__.py
+jeval/epe/core.py
+jeval/epe/decomposer.py
+jeval/strata/__init__.py
+jeval/strata/budget.py
+jeval/strata/classifier.py
+jeval_memory_compression.egg-info/PKG-INFO
+jeval_memory_compression.egg-info/SOURCES.txt
+jeval_memory_compression.egg-info/dependency_links.txt
+jeval_memory_compression.egg-info/requires.txt
+jeval_memory_compression.egg-info/top_level.txt
\ No newline at end of file
diff --git a/examples/jeval-memory-compression/jeval_memory_compression.egg-info/dependency_links.txt b/examples/jeval-memory-compression/jeval_memory_compression.egg-info/dependency_links.txt
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/examples/jeval-memory-compression/jeval_memory_compression.egg-info/dependency_links.txt
@@ -0,0 +1 @@
+
diff --git a/examples/jeval-memory-compression/jeval_memory_compression.egg-info/requires.txt b/examples/jeval-memory-compression/jeval_memory_compression.egg-info/requires.txt
new file mode 100644
index 00000000..0c1cb7b8
--- /dev/null
+++ b/examples/jeval-memory-compression/jeval_memory_compression.egg-info/requires.txt
@@ -0,0 +1,11 @@
+torch>=2.2.0
+transformers>=4.40.0
+sentence-transformers>=3.0.0
+nltk>=3.8.1
+numpy>=1.26.0
+openai>=1.0.0
+
+[dev]
+pytest>=8.0.0
+black>=24.0.0
+ruff>=0.4.0
diff --git a/examples/jeval-memory-compression/jeval_memory_compression.egg-info/top_level.txt b/examples/jeval-memory-compression/jeval_memory_compression.egg-info/top_level.txt
new file mode 100644
index 00000000..a71bccdf
--- /dev/null
+++ b/examples/jeval-memory-compression/jeval_memory_compression.egg-info/top_level.txt
@@ -0,0 +1 @@
+jeval
diff --git a/examples/jeval-memory-compression/pyproject.toml b/examples/jeval-memory-compression/pyproject.toml
new file mode 100644
index 00000000..1cdf2b94
--- /dev/null
+++ b/examples/jeval-memory-compression/pyproject.toml
@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "jeval-memory-compression"
+version = "0.1.0"
+description = "JEPA-based semantic fidelity evaluation for Droid memory compression"
+requires-python = ">=3.11"
+dependencies = [
+    "torch>=2.2.0",
+    "transformers>=4.40.0",
+    "sentence-transformers>=3.0.0",
+    "nltk>=3.8.1",
+    "numpy>=1.26.0",
+    "openai>=1.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "black>=24.0.0",
+    "ruff>=0.4.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["jeval*"]
+
+[tool.black]
+line-length = 100
+target-version = ["py311"]
+
+[tool.ruff]
+line-length = 100
+select = ["E", "F", "I"]
diff --git a/examples/jeval-memory-compression/test_data/real_session.md b/examples/jeval-memory-compression/test_data/real_session.md
new file mode 100644
index 00000000..08a6191a
--- /dev/null
+++ b/examples/jeval-memory-compression/test_data/real_session.md
@@ -0,0 +1,31 @@
+## Session Intent
+Implement JWT authentication for the Express API and fix a 401 error on the /api/login endpoint.
+
+## File Modifications
+- created src/server.ts with Express app, /health endpoint returning 200 OK
+- created src/middleware/auth.ts with JWT verification middleware using jsonwebtoken
+- modified src/routes/api.ts to add POST /api/login route with credential validation
+- modified src/routes/api.ts to protect GET /api/users with auth middleware
+- modified src/config/redis.ts to add session token storage with 24h expiry
+- created tests/auth.test.ts with unit tests for JWT middleware
+
+## Decisions Made
+- decided to use Redis for session storage because Postgres connection pool was exhausted under load
+- decided to use jsonwebtoken over passport.js because we only need JWT, passport adds unnecessary complexity
+- decided to set token expiry to 24h because users complained about being logged out too frequently
+- rejected storing tokens in localStorage because of XSS vulnerability risk, using httpOnly cookies instead
+
+## Errors Encountered and Fixed
+- fixed 401 on /api/login caused by missing CORS header for Authorization, added cors middleware to server.ts
+- fixed Redis connection timeout by increasing maxRetriesPerRequest from 3 to 10 in src/config/redis.ts
+- fixed JWT verification failing on refresh because token was being signed with wrong secret, corrected env var name from JWT_KEY to JWT_SECRET
+
+## Current State
+- authentication flow working end to end in development
+- all 14 tests passing
+- staged for deployment to staging environment
+
+## Next Steps
+- deploy to staging and run smoke tests against /api/login and /api/users
+- add rate limiting to /api/login to prevent brute force attacks
+- rotate JWT_SECRET in production before go-live
diff --git a/examples/jeval-memory-compression/test_data/real_session_compressed.md b/examples/jeval-memory-compression/test_data/real_session_compressed.md
new file mode 100644
index 00000000..376094e3
--- /dev/null
+++ b/examples/jeval-memory-compression/test_data/real_session_compressed.md
@@ -0,0 +1,25 @@
+## Session Intent Implement JWT authentication for the Express API and fix a 401 error on the /api/login endpoint.
+## File Modifications
+- created src/server.ts with Express app, /health endpoint returning 200 OK
+- created src/middleware/auth.ts with JWT verification middleware using jsonwebtoken
+- modified src/routes/api.ts to add POST /api/login route with credential validation
+- modified src/routes/api.ts to protect GET /api/users with auth middleware
+- modified src/config/redis.ts to add session token storage with 24h expiry
+- created tests/auth.test.ts with unit tests for JWT middleware
+## Decisions Made
+- decided to use Redis for session storage because Postgres connection pool was exhausted under load
+- decided to use jsonwebtoken over passport.js because we only need JWT, passport adds unnecessary complexity
+- decided to set token expiry to 24h because users complained
+- rejected storing tokens in localStorage because of XSS vulnerability risk, using httpOnly cookies instead
+## Errors Encountered and Fixed
+- fixed 401 on /api/login caused by missing CORS header for Authorization, added cors middleware to server.ts
+- fixed Redis connection timeout by increasing maxRetriesPerRequest from 3 to 10 in src/config/redis.ts
+- fixed JWT verification failing on refresh because token was being signed with wrong secret, corrected env var name from JWT_KEY to JWT_SECRET
+## Current State
+- authentication flow working end to
+- all 14 tests passing
+- staged for deployment to staging environment
+## Next Steps
+- deploy to staging and run smoke tests against /api/login and /api/users
+- add rate limiting to /api/login to prevent brute force attacks
+- rotate JWT_SECRET in production before go-live
\ No newline at end of file
diff --git a/examples/jeval-memory-compression/test_data/real_session_original.md b/examples/jeval-memory-compression/test_data/real_session_original.md
new file mode 100644
index 00000000..08a6191a
--- /dev/null
+++ b/examples/jeval-memory-compression/test_data/real_session_original.md
@@ -0,0 +1,31 @@
+## Session Intent
+Implement JWT authentication for the Express API and fix a 401 error on the /api/login endpoint.
+
+## File Modifications
+- created src/server.ts with Express app, /health endpoint returning 200 OK
+- created src/middleware/auth.ts with JWT verification middleware using jsonwebtoken
+- modified src/routes/api.ts to add POST /api/login route with credential validation
+- modified src/routes/api.ts to protect GET /api/users with auth middleware
+- modified src/config/redis.ts to add session token storage with 24h expiry
+- created tests/auth.test.ts with unit tests for JWT middleware
+
+## Decisions Made
+- decided to use Redis for session storage because Postgres connection pool was exhausted under load
+- decided to use jsonwebtoken over passport.js because we only need JWT, passport adds unnecessary complexity
+- decided to set token expiry to 24h because users complained about being logged out too frequently
+- rejected storing tokens in localStorage because of XSS vulnerability risk, using httpOnly cookies instead
+
+## Errors Encountered and Fixed
+- fixed 401 on /api/login caused by missing CORS header for Authorization, added cors middleware to server.ts
+- fixed Redis connection timeout by increasing maxRetriesPerRequest from 3 to 10 in src/config/redis.ts
+- fixed JWT verification failing on refresh because token was being signed with wrong secret, corrected env var name from JWT_KEY to JWT_SECRET
+
+## Current State
+- authentication flow working end to end in development
+- all 14 tests passing
+- staged for deployment to staging environment
+
+## Next Steps
+- deploy to staging and run smoke tests against /api/login and /api/users
+- add rate limiting to /api/login to prevent brute force attacks
+- rotate JWT_SECRET in production before go-live
diff --git a/examples/jeval-memory-compression/test_data/scores.json b/examples/jeval-memory-compression/test_data/scores.json
new file mode 100644
index 00000000..9b376b84
--- /dev/null
+++ b/examples/jeval-memory-compression/test_data/scores.json
@@ -0,0 +1,46 @@
+[
+  {
+    "probe_type": "recall",
+    "overall": 4.666666666666667,
+    "accuracy": 5,
+    "context_awareness": 4,
+    "artifact_trail": 5,
+    "completeness": 4,
+    "continuity": 5,
+    "instruction_follow": 5,
+    "reasoning": "The agent correctly preserved all relevant file paths and endpoints, ensuring that the artifact trail is complete."
+  },
+  {
+    "probe_type": "artifact",
+    "overall": 5.0,
+    "accuracy": 5,
+    "context_awareness": 5,
+    "artifact_trail": 5,
+    "completeness": 5,
+    "continuity": 5,
+    "instruction_follow": 5,
+    "reasoning": "The agent preserved all file paths, functions, and endpoints accurately, providing a complete and detailed artifact trail."
+  },
+  {
+    "probe_type": "continuation",
+    "overall": 4.833333333333333,
+    "accuracy": 5,
+    "context_awareness": 5,
+    "artifact_trail": 4,
+    "completeness": 5,
+    "continuity": 5,
+    "instruction_follow": 5,
+    "reasoning": "The agent preserved most file paths and endpoints, but did not mention the specific smoke tests to be run."
+  },
+  {
+    "probe_type": "decision",
+    "overall": 5.0,
+    "accuracy": 5,
+    "context_awareness": 5,
+    "artifact_trail": 5,
+    "completeness": 5,
+    "continuity": 5,
+    "instruction_follow": 5,
+    "reasoning": "The agent preserved all file paths, functions, and endpoints accurately, maintaining a clear artifact trail."
+  }
+]
\ No newline at end of file