There is not one memory. There are four, and a real agent blends them.

import json
from dataclasses import dataclass, field
from pathlib import Path

ROOT = Path("mix")          # everything lives under one folder for the lab
ROOT.mkdir(exist_ok=True)

EPISODIC = ROOT / "episodes.jsonl"   # what happened: append-only log
SEMANTIC = ROOT / "facts.json"       # durable facts: the Lab 06 shape, by name
RULES    = ROOT / "rules.md"         # procedural: how the agent behaves

# Seed a procedural rules file once. In a real repo this is your CLAUDE.md;
# it is loaded every turn and it does NOT change per task.
if not RULES.exists():
    RULES.write_text(
        "# Agent rules (procedural memory)\n"
        "- Prefer pnpm. Never mix package managers.\n"
        "- If a memory names a file or flag, verify it exists before acting.\n"
        "- Ship only after a green smoke test on the live URL.\n",
        encoding="utf-8",
    )


@dataclass
class MemoryMix:
    """Four backends, one per memory type. Working lives in RAM (volatile);
    the other three persist to disk."""
    working: dict = field(default_factory=dict)   # volatile scratchpad / todo

    # -- WORKING: volatile live state for the current task --------------------
    def set_task(self, task, todo):
        self.working = {"task": task, "todo": list(todo)}

    def check_off(self, item):
        todo = self.working.get("todo", [])
        self.working["todo"] = [t for t in todo if t != item]

    # -- EPISODIC: append one line per thing that happened --------------------
    def log_episode(self, kind, detail):
        rec = {"kind": kind, "detail": detail}
        with EPISODIC.open("a", encoding="utf-8") as f:
            f.write(json.dumps(rec) + "\n")

    def episodes(self):
        if not EPISODIC.exists():
            return []
        return [json.loads(ln) for ln in
                EPISODIC.read_text(encoding="utf-8").splitlines() if ln.strip()]

    # -- SEMANTIC: durable facts keyed by name (the Lab 06 store) -------------
    def write_fact(self, name, description, body):
        facts = self._facts()
        facts[name] = {"description": description, "body": body}
        SEMANTIC.write_text(json.dumps(facts, indent=2), encoding="utf-8")

    def _facts(self):
        if not SEMANTIC.exists():
            return {}
        return json.loads(SEMANTIC.read_text(encoding="utf-8"))

    # -- PROCEDURAL: load the rules file, every turn -------------------------
    def rules(self):
        return RULES.read_text(encoding="utf-8").strip()


if __name__ == "__main__":
    mix = MemoryMix()
    # Write one of each, so you can see all four stores light up.
    mix.set_task("ship the labs page", ["build", "smoke test", "deploy"])  # working
    mix.log_episode("deploy", "shipped labs v1 to prod, smoke green")      # episodic
    mix.write_fact("deploy-cmd",
                   "how this project ships",
                   "Run scripts/deploy.sh from the repo root.")            # semantic
    print("rules loaded:", len(mix.rules().splitlines()), "lines")         # procedural
    print("working todo:", mix.working["todo"])
    print("episodes on disk:", len(mix.episodes()))

    # -- COMPOSE: build the turn's context in priority order -----------------
    def assemble(self, task, budget_chars=1200):
        """Order: procedural -> semantic -> episodic -> working, trimmed to a
        char budget. Then recite the working todo at the very END so recent
        attention holds it (the Manus recitation trick)."""
        q = set(task.lower().split())
        parts = []

        # 1. PROCEDURAL first -- the rules always apply.
        parts.append("[RULES]\n" + self.rules())

        # 2. SEMANTIC next -- only facts whose description matches the task.
        facts = self._facts()
        relevant = [f["body"] for f in facts.values()
                    if q & set(f["description"].lower().split())]
        if relevant:
            parts.append("[FACTS]\n" + "\n".join(relevant))

        # 3. EPISODIC -- the most recent few things that happened.
        recent = self.episodes()[-3:]
        if recent:
            lines = [e["kind"] + ": " + e["detail"] for e in recent]
            parts.append("[RECENT]\n" + "\n".join(lines))

        # 4. WORKING -- the live scratchpad.
        todo = self.working.get("todo", [])
        if todo:
            parts.append("[WORKING] task=" + self.working.get("task", "") +
                         "\ntodo: " + ", ".join(todo))

        context = "\n\n".join(parts)
        if len(context) > budget_chars:          # trim from the MIDDLE, keep
            head = context[: budget_chars // 2]   # rules (front) and working
            tail = context[-budget_chars // 2:]   # (back) intact
            context = head + "\n...[trimmed]...\n" + tail

        # RECITATION: working todo printed again, last, so it stays in view.
        if todo:
            context += "\n\n[RECITE -> do next] " + ", ".join(todo)
        return context

type        store              write policy              recall when
----------  -----------------  ------------------------  -----------------------
WORKING     RAM scratchpad     implicit, every action    every turn (recited last)
EPISODIC    episodes.jsonl     append on every event     pull recent / on replay
SEMANTIC    facts.json         explicit, deliberate      on relevance to the task
PROCEDURAL  rules.md           rare, by a human edit     every turn (loaded first)

    import os, re

    # Reuse the Lab 06 guard: anything reality can confirm, confirm it.
    _PATH_RE = re.compile(r"\b[\w./-]+\.(?:sh|py|ya?ml|json|toml|md|txt|js|ts)\b")

    def _verify_fresh(self, body):
        """Return (ok, problems). A named path that does not exist is stale."""
        problems = []
        for path in self._PATH_RE.findall(body):
            if not self.os.path.exists(path):
                problems.append("path does not exist: " + path)
        return (len(problems) == 0, problems)

    def promote_recurring(self, min_count=2):
        """Promote any episodic detail that recurs >= min_count times into the
        semantic store -- but only after the Lab 06 freshness guard clears it."""
        counts = {}
        for e in self.episodes():
            counts[e["detail"]] = counts.get(e["detail"], 0) + 1

        promoted = []
        for detail, n in counts.items():
            if n < min_count:
                continue
            ok, problems = self._verify_fresh(detail)
            if not ok:
                print("SKIP (stale, not promoted): " + detail)
                for p in problems:
                    print("  - " + p)
                continue
            name = "learned-" + str(abs(hash(detail)) % 10000)
            self.write_fact(name, "learned from repeated episodes", detail)
            promoted.append((name, detail, n))
        return promoted