diff --git a/CLAUDE.md b/CLAUDE.md
index 67b59df..f022c6b 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -44,7 +44,7 @@ SKIP_BENCHMARKS=true npm test
 
 ```
 src/
-├── agent/     # Agent Memory System (sessions, working memory, episodic, decay, artifacts, distillation, role profiles, entropy, consolidation scheduler, collaborative synthesis, failure distillation, cognitive load, visibility, MemoryEngine + ImportanceScorer for turn-aware memory with four-tier dedup)
+├── agent/     # Agent Memory System (sessions, working memory, episodic, decay, artifacts, distillation, role profiles, entropy, consolidation scheduler, collaborative synthesis, failure distillation, cognitive load, visibility, MemoryEngine + ImportanceScorer for turn-aware memory with four-tier dedup, reconstruction/ MRAgent Cue–Tag–Content associative memory + active reconstruction)
 ├── cli/       # CLI commands (bin: `memory` / `memoryjs`)
 ├── core/      # Storage backends, entity/relation/observation managers, transactions, RefIndex
 ├── search/    # Search algorithms (BM25, TF-IDF, fuzzy, semantic, hybrid, temporal, LLM-planned)
@@ -90,6 +90,7 @@ ctx.roleAssignmentStore // η.6.1 RBAC role grants registry
 ctx.rbacMiddleware      // η.6.1 RBAC policy (checkPermission)
 ctx.worldModelManager   // 3B.7 World Model orchestrator (snapshots + diff)
 ctx.activeRetrieval     // 3B.5 Active Retrieval (iterative query rewriting)
+ctx.reconstructiveMemory() // MRAgent Cue–Tag–Content associative memory + active multi-step reconstruction
 ```
 
 **v1.9.0 Additions:**
@@ -140,6 +141,13 @@ ctx.activeRetrieval     // 3B.5 Active Retrieval (iterative query rewriting)
 - **Cognitive load** (v1.7.0): `CognitiveLoadAnalyzer` — token density + redundancy ratio + observation diversity → `CognitiveLoadReport`; used by `ContextWindowManager` to prune high-load sections
 - **Visibility hierarchies** (v1.7.0): `VisibilityResolver` — five-level model (`private` | `team` | `org` | `shared` | `public`) with `GroupMembership` registry
 - **Memory Engine** (v1.11.0): `MemoryEngine` — turn-aware conversation memory facade composing over `EpisodicMemoryManager` + `WorkingMemoryManager`. Public API: `addTurn(content, opts)` (dedup-first write with importance scoring + event emission), `checkDuplicate(content, sessionId)`, `getSessionTurns(sessionId, { role?, limit? })` (chronological), `deleteSession`, `listSessions`. Four-tier dedup chain: `checkTierExact` (SHA-256 contentHash) / `checkTierPrefix` (50% prefix overlap) / `checkTierJaccard` (token Jaccard ≥ 0.72) / optional `checkTierSemantic` (embedding similarity). Emits `memoryEngine:turnAdded` / `memoryEngine:duplicateDetected` / `memoryEngine:sessionDeleted` on its own `node:events` `EventEmitter`. Companion: `ImportanceScorer` (length × keyword × recent-turn-overlap signals → integer [0, 10]). Wired via `ctx.memoryEngine` lazy getter; `agentMemory(config)` invalidates the cache on re-instantiation.
+- **Reconstructive Memory** (`src/agent/reconstruction/`): MRAgent implementation of *"Memory is Reconstructed, Not Retrieved: Graph Memory for LLM Agents"* (Ji, Li & Hooi, ICML 2026). Models memory as a heterogeneous **Cue–Tag–Content** associative graph `M = (C, V, R)` where associative **tags** bridge fine-grained cues to memory contents, organised into three multi-granular layers (`episodic` / `semantic` / `topic`). Components:
+  - `CueTagContentGraph` — the CTC graph with O(1) mapping operators (paper Eq. 5/8/9): `tagsForCue` (φ_{c→g}), `contentsForCueTag` (φ_{(c,g)→v}), `cueTagsForContent` (reverse φ_{v→(c,g)}), `episodesForTopic` (φ_{τ→e}); snapshot round-trip via `toSnapshot`/`fromSnapshot`.
+  - `MemoryToolkit` — the seven typed traversal operators (paper Table 4): `queryTagEvents`, `queryConversationTime`, `queryEventKeywords`, `queryEventContext`, `queryPersonalInformation`, `queryPersonalAspect`, `queryTopicEvents`.
+  - `MemoryDistiller` — construction pipeline (§3.3/App. B.1): rewrite (pronoun resolution + temporal normalisation + episodic segmentation) → tag + cue extraction → semantic-fact extraction → topic abstraction. Uses an optional `LLMProvider` (paper's App. E prompts) with deterministic heuristic fallback (zero-config), mirroring `LLMQueryPlanner`.
+  - `MemoryReconstructor` — **active reconstruction** loop (Algorithm 1): maintains reconstruction state `S(t) = (Z(t), H(t))` and iterates action-selection (`f_select`) → controlled traversal (forward/reverse/topic actions) → routing+prune (`f_route`) → stop, accumulating evidence across reasoning turns. LLM answer synthesis (App. E QA prompt) with extractive fallback.
+  - `MemoryGraphBridge` — links the three CTC layers to MemoryJS's live modules (paper §3.2 layer↔cognitive-memory mapping): **episodic** contents → `memoryType:'episodic'` entities stamped with the conversation timestamp so they land on the `EpisodicMemoryManager` timeline (temporally linked `precedes`/`follows`); **semantic** facts → `memoryType:'semantic'` entities anchored to their person entity via a `has_<aspect>` relation and indexed for `SemanticSearch`; **topic** nodes → topic entities linked to constituent episodes via `summarizes` relations. Routing reuses `SemanticSearch.calculateSimilarity` when available (lexical fallback). Driven through the structural `ReconstructiveBacking` interface (real managers or test fakes).
+  - `ReconstructiveMemory` — facade: `ingest(turns)` (construction; persists via the bridge when a `backing` is configured) + `reconstruct(query, opts)` (Algorithm 1) + `toolkit` / `memoryGraph` / `toSnapshot` / `lastPersistResult`. Wired via `ctx.reconstructiveMemory(config?)` lazy getter, which **defaults the backing to the context's own `entityManager` / `relationManager` / `semanticSearch`** so reconstructed memory is durable + searchable out of the box (pass `backing: undefined` to opt out). `@experimental`.
 
 ### Data Model
 
diff --git a/src/agent/index.ts b/src/agent/index.ts
index 91568f9..5dc5e3a 100644
--- a/src/agent/index.ts
+++ b/src/agent/index.ts
@@ -462,3 +462,21 @@ export {
   type RoleAssignmentStoreOptions,
   type RbacMiddlewareOptions,
 } from './rbac/index.js';
+
+// Reconstructive (MRAgent-style) associative memory — "Memory is Reconstructed,
+// Not Retrieved": Cue–Tag–Content graph + active multi-step reconstruction.
+export {
+  CueTagContentGraph,
+  normalizeKey,
+  MemoryToolkit,
+  type EventKeywords,
+  MemoryDistiller,
+  extractJson,
+  MemoryReconstructor,
+  ReconstructiveMemory,
+  type ReconstructiveMemoryConfig,
+  MemoryGraphBridge,
+  TOPIC_SUMMARIZES,
+  type ReconstructiveBacking,
+  type BridgePersistResult,
+} from './reconstruction/index.js';
diff --git a/src/agent/reconstruction/CueTagContentGraph.ts b/src/agent/reconstruction/CueTagContentGraph.ts
new file mode 100644
index 0000000..4162e58
Binary files /dev/null and b/src/agent/reconstruction/CueTagContentGraph.ts differ
diff --git a/src/agent/reconstruction/MemoryDistiller.ts b/src/agent/reconstruction/MemoryDistiller.ts
new file mode 100644
index 0000000..069bcce
--- /dev/null
+++ b/src/agent/reconstruction/MemoryDistiller.ts
@@ -0,0 +1,356 @@
+/**
+ * Memory distillation pipeline — populates the Cue–Tag–Content graph from raw
+ * dialogue (MRAgent §3.3 / Appendix B.1).
+ *
+ * The pipeline mirrors the paper's element-generation phase:
+ *   1. **Rewrite** raw turns into self-contained sentences — pronoun resolution,
+ *      temporal normalisation (`YYYY-MM-DD`), and episodic segmentation.
+ *   2. **Tag** each episode with a short associative phrase (`T_LLM`).
+ *   3. **Cue** extraction — fine-grained entities/attributes (`K_LLM`).
+ *   4. **Semantic** extraction — person-anchored stable facts (`S_LLM`).
+ *   5. **Topic** abstraction — recurring patterns across episodes (`A_LLM`).
+ *
+ * When an {@link LLMProvider} is supplied the pipeline uses the paper's prompts
+ * (Appendix E); otherwise it falls back to deterministic heuristics so the
+ * feature works with zero configuration — matching the LLM-optional pattern used
+ * elsewhere in the codebase (e.g. `LLMQueryPlanner`).
+ *
+ * @module agent/reconstruction/MemoryDistiller
+ * @experimental
+ */
+
+import type { LLMProvider } from '../../search/LLMQueryPlanner.js';
+import { KeywordExtractor } from '../../features/KeywordExtractor.js';
+import type {
+  DialogueTurn,
+  DistillationResult,
+  DistilledSentence,
+  PersonalFact,
+} from '../../types/reconstruction.js';
+import { CueTagContentGraph } from './CueTagContentGraph.js';
+
+/** Prompt used for dialogue rewriting + topic/personal extraction (Appendix E). */
+const DIALOGUE_PROMPT = `You are a dialogue processor. Only output valid JSON.
+Task: For each sentence in the dialogue:
+- Preserve every original sentence.
+- Replace all pronouns with explicit entities or noun phrases from context.
+- Do not modify verbs, adjectives, or other words.
+- Assign a short concrete tag (at most two words).
+- Normalize time to YYYY-MM-DD using conversation time.
+- If a question is answered by the next sentence, merge them.
+Topics: Derive at least ten concrete topics overall. Assign topic IDs (t1..tn); each sentence lists applicable topics or [].
+PersonalInformation: Extract person-related facts into personal_sentences.
+Output a single-line JSON object with keys: conversation_time, sentence[], topics{}, personal_sentences[].
+Each sentence: {"id","text","tag","origin","topic":[],"time"}.
+Each personal_sentence: {"id","text","tag","origin","person"}.`;
+
+/** Prompt used for cue/keyword extraction (Appendix E). */
+const KEYWORD_PROMPT = `You are an information extraction system. Only output valid JSON.
+Task: For each input sentence, extract 2-30 keywords directly from the original text.
+- Do not invent, paraphrase, or generalize keywords.
+- Only include words or phrases that explicitly appear in the text.
+- Extract entity, topic, verb, time, location, task, event, people keywords if present.
+Output: {"sentence":[{"sentence_id":"...","keyword":["..."]}]}`;
+
+/** Lightweight regexes for heuristic semantic-fact detection. */
+const FACT_VERBS =
+  /\b(is|are|was|were|likes?|loves?|prefers?|enjoys?|works?|lives?|owns?|has|have|studied|graduated|married|named)\b/i;
+
+/** Heuristic relative-date → absolute-date normaliser. */
+function normalizeDate(text: string, reference?: string): string | undefined {
+  const iso = text.match(/\b(\d{4})-(\d{2})-(\d{2})\b/);
+  if (iso) return iso[0];
+  return reference;
+}
+
+export class MemoryDistiller {
+  private readonly keywords = new KeywordExtractor();
+
+  constructor(private readonly llm?: LLMProvider) {}
+
+  /** Run the full distillation pipeline over a dialogue. */
+  async distill(turns: DialogueTurn[]): Promise<DistillationResult> {
+    if (this.llm) {
+      try {
+        return await this.distillWithLLM(turns);
+      } catch {
+        // Fall through to heuristics on malformed LLM output.
+      }
+    }
+    return this.distillHeuristic(turns);
+  }
+
+  /**
+   * Build (or extend) a {@link CueTagContentGraph} from a distillation result.
+   * Episodic, semantic and topic layers are populated in one pass.
+   */
+  buildGraph(result: DistillationResult, graph = new CueTagContentGraph()): CueTagContentGraph {
+    // Topic abstraction layer — create topic content nodes first so episodes can link.
+    for (const [topicId, description] of Object.entries(result.topics)) {
+      graph.addContent({ id: topicId, layer: 'topic', text: description });
+    }
+
+    // Episodic layer — Cue–Tag–Episode triples.
+    for (const sentence of result.sentences) {
+      const episodeId = sentence.id;
+      graph.addContent({
+        id: episodeId,
+        layer: 'episodic',
+        text: sentence.text,
+        timestamp: sentence.time ?? result.conversationTime,
+        topicIds: sentence.topics,
+        origin: sentence.origin,
+      });
+      const cues = result.keywords[sentence.id] ?? [];
+      for (const cue of cues) {
+        graph.addTriple(cue, sentence.tag, episodeId);
+      }
+    }
+
+    // Semantic layer — Cue(person)–Tag(aspect)–Semantic triples.
+    for (const fact of result.personalFacts) {
+      graph.addContent({
+        id: fact.id,
+        layer: 'semantic',
+        text: fact.text,
+        person: fact.person,
+        origin: fact.origin,
+      });
+      graph.addTriple(fact.person, fact.tag, fact.id);
+    }
+
+    return graph;
+  }
+
+  // ==================== LLM path ====================
+
+  private async distillWithLLM(turns: DialogueTurn[]): Promise<DistillationResult> {
+    const dialogueText = turns
+      .map(t => `${t.id}${t.speaker ? ` (${t.speaker})` : ''}: ${t.text}`)
+      .join('\n');
+    const refDate = turns.find(t => t.timestamp)?.timestamp;
+
+    const dialogueRaw = await this.llm!.complete(
+      `${DIALOGUE_PROMPT}\n\nConversation time: ${refDate ?? 'unknown'}\nDialogue:\n${dialogueText}`,
+    );
+    const parsed = extractJson<{
+      conversation_time?: string;
+      sentence?: Array<{
+        id: string;
+        text: string;
+        tag?: string;
+        origin?: string;
+        topic?: string[];
+        time?: string;
+      }>;
+      topics?: Record<string, string>;
+      personal_sentences?: Array<{
+        id: string;
+        text: string;
+        tag?: string;
+        origin?: string;
+        person?: string;
+      }>;
+    }>(dialogueRaw);
+    if (!parsed?.sentence) throw new Error('LLM dialogue output missing sentences');
+
+    const sentences: DistilledSentence[] = parsed.sentence.map(s => ({
+      id: s.id,
+      text: s.text,
+      tag: s.tag?.trim() || 'event',
+      origin: s.origin,
+      topics: s.topic ?? [],
+      time: s.time,
+    }));
+
+    // Keyword/cue extraction pass.
+    const kwRaw = await this.llm!.complete(
+      `${KEYWORD_PROMPT}\n\nTEXT:\n${JSON.stringify(
+        sentences.map(s => ({ id: s.id, text: s.text })),
+      )}`,
+    );
+    const kwParsed = extractJson<{
+      sentence?: Array<{ sentence_id: string; keyword: string[] }>;
+    }>(kwRaw);
+    const keywords: Record<string, string[]> = {};
+    for (const s of sentences) {
+      const hit = kwParsed?.sentence?.find(k => k.sentence_id === s.id);
+      keywords[s.id] = hit?.keyword?.length ? hit.keyword : this.keywords.extractTop(s.text, 6);
+    }
+
+    const personalFacts: PersonalFact[] = (parsed.personal_sentences ?? []).map((p, i) => ({
+      id: p.id || `p${i + 1}`,
+      text: p.text,
+      tag: p.tag?.trim() || 'fact',
+      person: p.person?.trim() || 'unknown',
+      origin: p.origin,
+    }));
+
+    return {
+      conversationTime: parsed.conversation_time ?? refDate,
+      sentences,
+      topics: parsed.topics ?? {},
+      personalFacts,
+      keywords,
+    };
+  }
+
+  // ==================== Heuristic path ====================
+
+  private distillHeuristic(turns: DialogueTurn[]): DistillationResult {
+    const refDate = turns.find(t => t.timestamp)?.timestamp;
+    const sentences: DistilledSentence[] = [];
+    const keywords: Record<string, string[]> = {};
+    const personalFacts: PersonalFact[] = [];
+
+    for (const turn of turns) {
+      const speaker = turn.speaker?.trim();
+      const rawSentences = splitSentences(turn.text);
+      rawSentences.forEach((raw, idx) => {
+        const id = `${turn.id}-${idx + 1}`;
+        const text = speaker ? resolvePronouns(raw, speaker) : raw;
+        const scored = this.keywords.extract(text);
+        const cues = dedupe([
+          ...extractEntities(text),
+          ...scored.slice(0, 6).map(k => k.keyword),
+        ]);
+        const tag = scored[0]?.keyword ?? 'event';
+        sentences.push({
+          id,
+          text,
+          tag,
+          origin: turn.id,
+          topics: [],
+          time: normalizeDate(text, turn.timestamp ?? refDate),
+        });
+        keywords[id] = cues.length ? cues : [tag];
+
+        // Semantic fact heuristic: a declarative statement about a known person.
+        if (speaker && FACT_VERBS.test(raw)) {
+          personalFacts.push({
+            id: `p${personalFacts.length + 1}`,
+            text,
+            tag: classifyAspect(raw),
+            person: speaker,
+            origin: turn.id,
+          });
+        }
+      });
+    }
+
+    const topics = this.deriveTopics(sentences, keywords);
+
+    return {
+      conversationTime: refDate,
+      sentences,
+      topics: topics.descriptions,
+      personalFacts,
+      keywords,
+    };
+  }
+
+  /** Cluster episodes by their most salient shared cue into topic nodes. */
+  private deriveTopics(
+    sentences: DistilledSentence[],
+    keywords: Record<string, string[]>,
+  ): { descriptions: Record<string, string> } {
+    const byCue = new Map<string, string[]>();
+    for (const s of sentences) {
+      const top = keywords[s.id]?.[0];
+      if (!top) continue;
+      const list = byCue.get(top) ?? [];
+      list.push(s.id);
+      byCue.set(top, list);
+    }
+    const descriptions: Record<string, string> = {};
+    let ti = 1;
+    for (const [cue, ids] of [...byCue.entries()].sort((a, b) => b[1].length - a[1].length)) {
+      if (ids.length < 2) continue; // a topic must summarise ≥ 2 episodes
+      const topicId = `t${ti++}`;
+      descriptions[topicId] = `Topic: ${cue}`;
+      for (const sid of ids) {
+        const s = sentences.find(x => x.id === sid);
+        if (s) s.topics = dedupe([...(s.topics ?? []), topicId]);
+      }
+    }
+    return { descriptions };
+  }
+}
+
+// ==================== Helpers ====================
+
+/** Extract the first JSON object/array from a possibly noisy LLM completion. */
+export function extractJson<T>(raw: string): T | undefined {
+  if (!raw) return undefined;
+  const fenced = raw.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  const body = fenced ? fenced[1] : raw;
+  const start = body.search(/[[{]/);
+  if (start === -1) return undefined;
+  const open = body[start];
+  const close = open === '{' ? '}' : ']';
+  let depth = 0;
+  let inStr = false;
+  let esc = false;
+  for (let i = start; i < body.length; i++) {
+    const ch = body[i];
+    if (inStr) {
+      if (esc) esc = false;
+      else if (ch === '\\') esc = true;
+      else if (ch === '"') inStr = false;
+      continue;
+    }
+    if (ch === '"') inStr = true;
+    else if (ch === open) depth++;
+    else if (ch === close) {
+      depth--;
+      if (depth === 0) {
+        try {
+          return JSON.parse(body.slice(start, i + 1)) as T;
+        } catch {
+          return undefined;
+        }
+      }
+    }
+  }
+  return undefined;
+}
+
+function splitSentences(text: string): string[] {
+  return text
+    .split(/(?<=[.!?])\s+/)
+    .map(s => s.trim())
+    .filter(Boolean);
+}
+
+/** Resolve first-person pronouns to the speaker (lightweight coreference). */
+function resolvePronouns(text: string, speaker: string): string {
+  return text
+    .replace(/\bI'm\b/g, `${speaker} is`)
+    .replace(/\bI've\b/g, `${speaker} has`)
+    .replace(/\bI'll\b/g, `${speaker} will`)
+    .replace(/\bI\b/g, speaker)
+    .replace(/\b[Mm]y\b/g, `${speaker}'s`)
+    .replace(/\b[Mm]e\b/g, speaker)
+    .replace(/\b[Mm]yself\b/g, speaker);
+}
+
+/** Pull capitalised multi-word entities as cues. */
+function extractEntities(text: string): string[] {
+  const matches = text.match(/\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\b/g) ?? [];
+  return matches.filter(m => m.length > 2);
+}
+
+/** Classify a personal fact into an aspect-level tag. */
+function classifyAspect(text: string): string {
+  const t = text.toLowerCase();
+  if (/\b(likes?|loves?|prefers?|enjoys?|favorite|favourite)\b/.test(t)) return 'preference';
+  if (/\b(works?|job|career|occupation|profession)\b/.test(t)) return 'occupation';
+  if (/\b(lives?|located|from|based)\b/.test(t)) return 'location';
+  if (/\b(studied|graduated|degree|university|school)\b/.test(t)) return 'education';
+  if (/\b(married|wife|husband|family|brother|sister|son|daughter)\b/.test(t)) return 'relationship';
+  return 'attribute';
+}
+
+function dedupe(items: string[]): string[] {
+  return [...new Set(items.map(i => i.trim()).filter(Boolean))];
+}
diff --git a/src/agent/reconstruction/MemoryGraphBridge.ts b/src/agent/reconstruction/MemoryGraphBridge.ts
new file mode 100644
index 0000000..cf4d885
--- /dev/null
+++ b/src/agent/reconstruction/MemoryGraphBridge.ts
@@ -0,0 +1,227 @@
+/**
+ * Bridge between the Cue–Tag–Content graph and MemoryJS's live memory modules.
+ *
+ * The paper organises memory into multi-granular layers (episodic / semantic /
+ * topic) that mirror cognitive memory types (§3.2). MemoryJS already implements
+ * those types, so the bridge persists each CTC content node into the
+ * corresponding module so reconstructed memory is durable and visible to the
+ * rest of the stack:
+ *
+ *   - **Episodic** → first-class `memoryType: 'episodic'` entities stamped with
+ *     the conversation timestamp, so they land on the
+ *     {@link EpisodicMemoryManager} timeline and are temporally linked
+ *     (`precedes`/`follows`).
+ *   - **Semantic** → `memoryType: 'semantic'` fact entities anchored to their
+ *     person entity via a typed relation, and indexed for `SemanticSearch`.
+ *   - **Topic** → topic entities linked to their constituent episodes via a
+ *     `summarizes` relation (queryable through `GraphTraversal`).
+ *
+ * The bridge writes through narrow structural interfaces so it can be driven by
+ * the real `ManagerContext` managers or by fakes in tests.
+ *
+ * @module agent/reconstruction/MemoryGraphBridge
+ * @experimental
+ */
+
+import type { Entity, Relation } from '../../types/types.js';
+import type { AgentEntity } from '../../types/agent-memory.js';
+import { EpisodicRelations } from '../EpisodicMemoryManager.js';
+import type { DistillationResult } from '../../types/reconstruction.js';
+import { CueTagContentGraph, normalizeKey } from './CueTagContentGraph.js';
+
+/** Relation type connecting a topic entity to one of its episodes. */
+export const TOPIC_SUMMARIZES = 'summarizes';
+
+/**
+ * The live-store dependencies the bridge writes through. Satisfied by the
+ * `ManagerContext` managers (`entityManager`, `relationManager`,
+ * `semanticSearch`) or by test doubles.
+ */
+export interface ReconstructiveBacking {
+  /** Persist entities (existing names are skipped by `EntityManager`). */
+  createEntities(entities: Entity[]): Promise<unknown>;
+  /** Persist relations. */
+  createRelations(relations: Relation[]): Promise<unknown>;
+  /** Optional semantic similarity in `[0, 1]` for routing/answer ranking. */
+  similarity?(a: string, b: string): Promise<number>;
+  /** Optional: index a freshly-created entity for semantic search. */
+  indexEntity?(entity: Entity): Promise<unknown>;
+  /** Session id used to scope episodes onto the timeline. Default `mragent`. */
+  sessionId?: string;
+}
+
+/** Summary of what a {@link MemoryGraphBridge.persist} call wrote. */
+export interface BridgePersistResult {
+  episodes: number;
+  semanticFacts: number;
+  topics: number;
+  relations: number;
+}
+
+/** Convert a possibly-partial date to an ISO datetime, offset to keep order. */
+function toIso(date: string | undefined, orderOffsetMs: number): string {
+  const base = date ? new Date(date) : new Date(0);
+  const ms = Number.isNaN(base.getTime()) ? orderOffsetMs : base.getTime() + orderOffsetMs;
+  return new Date(ms).toISOString();
+}
+
+/** Make a string safe to embed in an entity name / relation type. */
+function slug(text: string): string {
+  return text.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+}
+
+export class MemoryGraphBridge {
+  private readonly sessionId: string;
+
+  constructor(private readonly backing: ReconstructiveBacking) {
+    this.sessionId = backing.sessionId ?? 'mragent';
+  }
+
+  /** The session id episodes are written under (use with `getTimeline`). */
+  get session(): string {
+    return this.sessionId;
+  }
+
+  /**
+   * Persist a distillation result into the live store and annotate the in-memory
+   * graph's content nodes with their backing entity names.
+   */
+  async persist(result: DistillationResult, graph: CueTagContentGraph): Promise<BridgePersistResult> {
+    const prefix = `mragent-${slug(this.sessionId)}`;
+    const entities: AgentEntity[] = [];
+    const relations: Relation[] = [];
+    const persons = new Set<string>();
+
+    // ---- Topic abstraction layer ----
+    const topicEntityName = new Map<string, string>();
+    for (const [topicId, description] of Object.entries(result.topics)) {
+      const name = `${prefix}-topic-${slug(topicId)}`;
+      topicEntityName.set(topicId, name);
+      entities.push(agentEntity(name, 'topic', description, 'semantic'));
+      annotate(graph, topicId, name);
+    }
+
+    // ---- Episodic layer (timeline + temporal links) ----
+    const ordered = [...result.sentences].sort((a, b) =>
+      (a.time ?? '').localeCompare(b.time ?? ''),
+    );
+    let previousEpisode: string | undefined;
+    ordered.forEach((sentence, idx) => {
+      const name = `${prefix}-ep-${slug(sentence.id)}`;
+      const cues = result.keywords[sentence.id] ?? [];
+      const ep = agentEntity(name, 'episode', sentence.text, 'episodic', {
+        sessionId: this.sessionId,
+        createdAt: toIso(sentence.time ?? result.conversationTime, idx * 1000),
+        tags: cues,
+      });
+      entities.push(ep);
+      annotate(graph, sentence.id, name);
+
+      // Topic → episode links.
+      for (const topicId of sentence.topics ?? []) {
+        const topicName = topicEntityName.get(topicId);
+        if (topicName) {
+          relations.push({ from: topicName, to: name, relationType: TOPIC_SUMMARIZES });
+        }
+      }
+
+      // Unified timeline: link consecutive episodes (precedes/follows).
+      if (previousEpisode) {
+        relations.push({ from: previousEpisode, to: name, relationType: EpisodicRelations.PRECEDES });
+        relations.push({ from: name, to: previousEpisode, relationType: EpisodicRelations.FOLLOWS });
+      }
+      previousEpisode = name;
+    });
+
+    // ---- Semantic layer (person-anchored facts + SemanticSearch) ----
+    for (const fact of result.personalFacts) {
+      const name = `${prefix}-fact-${slug(fact.id)}`;
+      entities.push(agentEntity(name, 'semantic_fact', fact.text, 'semantic', {
+        tags: [fact.person, fact.tag],
+      }));
+      annotate(graph, fact.id, name);
+
+      const personName = fact.person?.trim();
+      if (personName) {
+        persons.add(personName);
+        relations.push({
+          from: personName,
+          to: name,
+          relationType: `has_${slug(fact.tag) || 'attribute'}`,
+        });
+      }
+    }
+
+    // Ensure anchor person entities exist (createEntities skips duplicates).
+    for (const person of persons) {
+      entities.push(agentEntity(person, 'person', `Person: ${person}`, 'semantic'));
+    }
+
+    // ---- Commit ----
+    if (entities.length) await this.backing.createEntities(entities as Entity[]);
+    if (relations.length) await this.backing.createRelations(relations);
+
+    // Index episodic + semantic content for semantic search.
+    if (this.backing.indexEntity) {
+      for (const e of entities) {
+        if (e.memoryType === 'episodic' || e.entityType === 'semantic_fact') {
+          try {
+            await this.backing.indexEntity(e as Entity);
+          } catch {
+            // Indexing is best-effort; lexical routing remains available.
+          }
+        }
+      }
+    }
+
+    return {
+      episodes: ordered.length,
+      semanticFacts: result.personalFacts.length,
+      topics: Object.keys(result.topics).length,
+      relations: relations.length,
+    };
+  }
+}
+
+/** Annotate a graph content node with its backing entity name (best-effort). */
+function annotate(graph: CueTagContentGraph, contentId: string, entityName: string): void {
+  const node = graph.getContent(contentId);
+  if (node) node.entityName = entityName;
+}
+
+/** Build an `AgentEntity` for a CTC content node. */
+function agentEntity(
+  name: string,
+  entityType: string,
+  content: string,
+  memoryType: 'episodic' | 'semantic',
+  extra?: { sessionId?: string; createdAt?: string; tags?: string[] },
+): AgentEntity {
+  return {
+    name,
+    entityType,
+    observations: [content],
+    memoryType,
+    accessCount: 0,
+    confirmationCount: 0,
+    visibility: 'private',
+    importance: memoryType === 'semantic' ? 6 : 5,
+    confidence: 0.8,
+    sessionId: extra?.sessionId,
+    createdAt: extra?.createdAt,
+    tags: extra?.tags && extra.tags.length ? dedupeTags(extra.tags) : undefined,
+  };
+}
+
+function dedupeTags(tags: string[]): string[] {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const t of tags) {
+    const key = normalizeKey(t);
+    if (key && !seen.has(key)) {
+      seen.add(key);
+      out.push(t);
+    }
+  }
+  return out;
+}
diff --git a/src/agent/reconstruction/MemoryReconstructor.ts b/src/agent/reconstruction/MemoryReconstructor.ts
new file mode 100644
index 0000000..2b68188
--- /dev/null
+++ b/src/agent/reconstruction/MemoryReconstructor.ts
@@ -0,0 +1,360 @@
+/**
+ * Active memory reconstruction (MRAgent §4 / Algorithm 1).
+ *
+ * Rather than a one-shot "retrieve-then-reason" lookup, the reconstructor
+ * formulates memory access as a stateful, multi-step process over the
+ * Cue–Tag–Content graph. It maintains a reconstruction state `S(t) = (Z(t),
+ * H(t))` — an active set of candidate elements `Z` and the accumulated
+ * reconstructed context `H` — and iterates:
+ *
+ *   1. **Action selection** `f_select(x, H, Z)` — choose promising traversal
+ *      directions (forward cue→tag / (cue,tag)→content, reverse content→(cue,tag),
+ *      top-down topic→episode), reducing noise vs. exhaustive expansion.
+ *   2. **Controlled traversal** — execute the selected actions to produce
+ *      candidates `Z̃(t+1)`.
+ *   3. **Routing + state update** `f_route(x, H, Z̃)` — keep the candidates most
+ *      relevant to the query and prune the rest, then fold them into `H`.
+ *   4. **Stopping** — terminate once accumulated evidence suffices.
+ *
+ * The default policy is a deterministic, embedding-free heuristic so the feature
+ * works with zero configuration. When an {@link LLMProvider} is supplied the
+ * final answer is synthesised by the LLM under the paper's QA prompt (Appendix E),
+ * and routing is LLM-assisted; otherwise an extractive answer is returned.
+ *
+ * @module agent/reconstruction/MemoryReconstructor
+ * @experimental
+ */
+
+import type { LLMProvider } from '../../search/LLMQueryPlanner.js';
+import { KeywordExtractor } from '../../features/KeywordExtractor.js';
+import type {
+  ContentNode,
+  CueNode,
+  ReconstructionOptions,
+  ReconstructionResult,
+  TagNode,
+  TraversalActionType,
+  TraversalStep,
+} from '../../types/reconstruction.js';
+import { CueTagContentGraph } from './CueTagContentGraph.js';
+import { MemoryToolkit } from './MemoryToolkit.js';
+import { extractJson } from './MemoryDistiller.js';
+
+/** The active set `Z(t)` — cues, tags and contents currently under consideration. */
+interface ActiveSet {
+  cues: CueNode[];
+  pairs: Array<{ cue: CueNode; tag: TagNode }>;
+  contents: ContentNode[];
+}
+
+const QA_PROMPT = `You are a question-answering agent with access to event-based memory.
+Answer the question using ONLY the reconstructed evidence provided.
+Answer Rules:
+- Yes/No questions: output Yes, No, Likely yes, or Likely no.
+- Location questions: answer with a specific place name.
+- Counting questions: answer with the number of relevant items.
+- Other questions: output the minimal concrete entity or phrase.
+Output a single-line JSON object: {"answer":"...","confidence":0.0-1.0}`;
+
+const DEFAULTS: Required<ReconstructionOptions> = {
+  maxSteps: 8,
+  perStepBudget: 10,
+  evidenceTarget: 12,
+};
+
+export class MemoryReconstructor {
+  private readonly toolkit: MemoryToolkit;
+  private readonly keywords = new KeywordExtractor();
+
+  constructor(
+    private readonly graph: CueTagContentGraph,
+    private readonly llm?: LLMProvider,
+    /**
+     * Optional semantic similarity in `[0, 1]` (e.g. `SemanticSearch`), used to
+     * rank candidates during routing/answer when a live-store backing supplies
+     * it. Falls back to lexical overlap when absent.
+     */
+    private readonly similarityFn?: (query: string, text: string) => Promise<number>,
+  ) {
+    this.toolkit = new MemoryToolkit(graph);
+  }
+
+  /** Run active reconstruction for a query (Algorithm 1). */
+  async reconstruct(
+    query: string,
+    options: ReconstructionOptions = {},
+  ): Promise<ReconstructionResult> {
+    const opts = { ...DEFAULTS, ...options };
+    const trajectory: TraversalStep[] = [];
+
+    // EXTRACTCUES(x) + ACTIVESETINIT(C, G) — line 1-2.
+    const initialCues = this.extractQueryCues(query);
+    let active: ActiveSet = { cues: initialCues, pairs: [], contents: [] };
+
+    // H(0) ← ∅ — line 3-4. Track seen content ids to keep H concise.
+    const evidence: ContentNode[] = [];
+    const seen = new Set<string>();
+    let stoppedEarly = false;
+
+    for (let step = 0; step < opts.maxSteps; step++) {
+      // f_select — line 7.
+      const actions = this.selectActions(active);
+      if (actions.length === 0) break;
+
+      // Controlled traversal — lines 9-12. Produces candidate set Z̃(t+1).
+      const candidate = this.traverse(active, actions);
+
+      // f_route + state update — lines 14-15.
+      const routed = await this.route(query, candidate.contents, seen, opts.perStepBudget);
+      for (const node of routed) {
+        seen.add(node.id);
+        evidence.push(node);
+      }
+
+      trajectory.push({
+        step,
+        actions,
+        routed,
+        rationale: describeActions(actions),
+      });
+
+      // The next active set carries forward newly discovered cues/tags plus the
+      // routed contents, so subsequent steps can reason over accumulated evidence.
+      active = {
+        cues: dedupeCues([...active.cues, ...candidate.cues]),
+        pairs: dedupePairs([...active.pairs, ...candidate.pairs]),
+        contents: routed,
+      };
+
+      // STOP(x, H) — lines 16-18.
+      if (this.shouldStop(evidence, routed, opts.evidenceTarget)) {
+        stoppedEarly = true;
+        break;
+      }
+    }
+
+    // ŷ ← ANSWER_LLM(x, H) — line 20.
+    const { answer, confidence } = await this.answer(query, evidence);
+
+    return { query, answer, confidence, evidence, trajectory, stoppedEarly };
+  }
+
+  // ==================== EXTRACTCUES ====================
+
+  private extractQueryCues(query: string): CueNode[] {
+    const phrases = new Set<string>();
+    // Capitalised entities are strong cues.
+    for (const m of query.match(/\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\b/g) ?? []) {
+      phrases.add(m);
+    }
+    for (const k of this.keywords.extractTop(query, 8)) phrases.add(k);
+
+    const matched = new Map<string, CueNode>();
+    for (const phrase of phrases) {
+      for (const cue of this.graph.matchCues(phrase)) matched.set(cue.id, cue);
+    }
+    return [...matched.values()];
+  }
+
+  // ==================== f_select ====================
+
+  /**
+   * Select promising traversal directions from the current active set. The
+   * heuristic prefers to advance cues → tags → content, expands retrieved
+   * content both reverse (new cues/tags) and top-down (topic → episode).
+   */
+  private selectActions(active: ActiveSet): TraversalActionType[] {
+    const actions: TraversalActionType[] = [];
+    // Forward: active cues are advanced through tags to content within the same
+    // turn (the paper allows multiple tool calls per reasoning turn).
+    if (active.cues.length > 0) {
+      actions.push('cue->tag');
+      actions.push('cuetag->content');
+    } else if (active.pairs.length > 0) {
+      actions.push('cuetag->content');
+    }
+    if (active.contents.some(c => c.layer === 'topic')) actions.push('topic->episode');
+    // Reverse: surface fresh cues/tags from episodic evidence to redirect search.
+    if (active.contents.some(c => c.layer === 'episodic')) actions.push('content->cuetag');
+    return actions;
+  }
+
+  // ==================== Controlled traversal ====================
+
+  private traverse(active: ActiveSet, actions: TraversalActionType[]): ActiveSet {
+    const out: ActiveSet = { cues: [], pairs: [], contents: [] };
+
+    // Tags newly activated this turn are chained straight into content retrieval,
+    // so a single turn can progress cue → tag → content (Eq. 8).
+    const pairPool: Array<{ cue: CueNode; tag: TagNode }> = [...active.pairs];
+
+    if (actions.includes('cue->tag')) {
+      for (const cue of active.cues) {
+        for (const tag of this.graph.tagsForCue(cue.text)) {
+          const pair = { cue, tag };
+          out.pairs.push(pair);
+          pairPool.push(pair);
+        }
+      }
+    }
+
+    if (actions.includes('cuetag->content')) {
+      for (const { cue, tag } of pairPool) {
+        out.contents.push(...this.graph.contentsForCueTag(cue.text, tag.text));
+      }
+    }
+
+    if (actions.includes('topic->episode')) {
+      for (const topic of active.contents.filter(c => c.layer === 'topic')) {
+        out.contents.push(...this.toolkit.queryTopicEvents(topic.id));
+      }
+    }
+
+    if (actions.includes('content->cuetag')) {
+      for (const content of active.contents.filter(c => c.layer === 'episodic')) {
+        for (const { cue, tag } of this.graph.cueTagsForContent(content.id)) {
+          out.cues.push(cue);
+          out.pairs.push({ cue, tag });
+        }
+      }
+    }
+
+    out.cues = dedupeCues(out.cues);
+    out.pairs = dedupePairs(out.pairs);
+    return out;
+  }
+
+  // ==================== f_route ====================
+
+  /**
+   * Rank candidate content by lexical relevance to the query, drop already-seen
+   * nodes, and keep the top `budget`. This is the noise-pruning step that keeps
+   * the reconstructed context focused.
+   */
+  private async route(
+    query: string,
+    candidates: ContentNode[],
+    seen: Set<string>,
+    budget: number,
+  ): Promise<ContentNode[]> {
+    const queryTerms = new Set(this.keywords.extractTop(query, 12));
+    const unique = new Map<string, ContentNode>();
+    for (const node of candidates) {
+      if (!seen.has(node.id)) unique.set(node.id, node);
+    }
+
+    const scored = await Promise.all(
+      [...unique.values()].map(async node => ({
+        node,
+        score: await this.relevance(query, node, queryTerms),
+      })),
+    );
+
+    return scored
+      .sort((a, b) => b.score - a.score)
+      .slice(0, budget)
+      .map(s => s.node);
+  }
+
+  /**
+   * Relevance of a candidate to the query. Uses semantic similarity when a
+   * backing supplies it (embedding-based, captures paraphrase), otherwise falls
+   * back to lexical keyword overlap.
+   */
+  private async relevance(
+    query: string,
+    node: ContentNode,
+    queryTerms: Set<string>,
+  ): Promise<number> {
+    // Semantic facts are compact and high-value; give them a mild prior.
+    const layerBonus = node.layer === 'semantic' ? 0.5 : 0;
+
+    if (this.similarityFn) {
+      try {
+        const sim = await this.similarityFn(query, node.text);
+        // Scale into a comparable range with the lexical path.
+        return sim * 10 + layerBonus;
+      } catch {
+        // Fall through to lexical scoring.
+      }
+    }
+
+    if (queryTerms.size === 0) return 1 + layerBonus;
+    const nodeTerms = this.keywords.extract(node.text).map(k => k.keyword);
+    let overlap = 0;
+    for (const term of nodeTerms) if (queryTerms.has(term)) overlap++;
+    return overlap + layerBonus;
+  }
+
+  // ==================== STOP ====================
+
+  private shouldStop(
+    evidence: ContentNode[],
+    routedThisStep: ContentNode[],
+    target: number,
+  ): boolean {
+    if (evidence.length >= target) return true;
+    // No new evidence discovered this step → the trajectory is exhausted.
+    return routedThisStep.length === 0;
+  }
+
+  // ==================== ANSWER ====================
+
+  private async answer(
+    query: string,
+    evidence: ContentNode[],
+  ): Promise<{ answer?: string; confidence?: number }> {
+    if (evidence.length === 0) return { answer: undefined, confidence: 0 };
+
+    if (this.llm) {
+      try {
+        const context = evidence
+          .map((e, i) => `D${i + 1}: ${e.timestamp ? `[${e.timestamp}] ` : ''}${e.text}`)
+          .join('\n');
+        const raw = await this.llm.complete(
+          `${QA_PROMPT}\n\nQuestion: ${query}\n\nReconstructed evidence:\n${context}`,
+        );
+        const parsed = extractJson<{ answer?: string; confidence?: number }>(raw);
+        if (parsed?.answer) {
+          return { answer: parsed.answer, confidence: parsed.confidence ?? 0.7 };
+        }
+      } catch {
+        // Fall back to extractive answer below.
+      }
+    }
+
+    // Extractive fallback: the highest-relevance evidence item.
+    const queryTerms = new Set(this.keywords.extractTop(query, 12));
+    const ranked = await Promise.all(
+      evidence.map(async node => ({ node, score: await this.relevance(query, node, queryTerms) })),
+    );
+    const best = ranked.sort((a, b) => b.score - a.score)[0].node;
+    return { answer: best.text, confidence: 0.4 };
+  }
+}
+
+// ==================== Helpers ====================
+
+function describeActions(actions: TraversalActionType[]): string {
+  const labels: Record<TraversalActionType, string> = {
+    'cue->tag': 'activate tags from cues',
+    'cuetag->content': 'retrieve content for cue–tag pairs',
+    'content->cuetag': 'surface new cues/tags from content',
+    'topic->episode': 'descend topics to episodes',
+  };
+  return actions.map(a => labels[a]).join('; ');
+}
+
+function dedupeCues(cues: CueNode[]): CueNode[] {
+  const map = new Map<string, CueNode>();
+  for (const c of cues) map.set(c.id, c);
+  return [...map.values()];
+}
+
+function dedupePairs(
+  pairs: Array<{ cue: CueNode; tag: TagNode }>,
+): Array<{ cue: CueNode; tag: TagNode }> {
+  const map = new Map<string, { cue: CueNode; tag: TagNode }>();
+  for (const p of pairs) map.set(`${p.cue.id} ${p.tag.id}`, p);
+  return [...map.values()];
+}
diff --git a/src/agent/reconstruction/MemoryToolkit.ts b/src/agent/reconstruction/MemoryToolkit.ts
new file mode 100644
index 0000000..2ab2854
--- /dev/null
+++ b/src/agent/reconstruction/MemoryToolkit.ts
@@ -0,0 +1,110 @@
+/**
+ * Memory toolkit for controlled traversal of the Cue–Tag–Content graph.
+ *
+ * Implements the seven typed traversal operators of MRAgent (paper Table 4).
+ * Each tool corresponds to a typed mapping between memory components, letting an
+ * agent (LLM- or heuristic-driven) explicitly control the direction and
+ * granularity of memory access rather than retrieving a fixed similarity set.
+ *
+ * @module agent/reconstruction/MemoryToolkit
+ * @experimental
+ */
+
+import type { ContentNode, TagNode } from '../../types/reconstruction.js';
+import { CueTagContentGraph } from './CueTagContentGraph.js';
+
+/** Result of the keyword/context introspection tools. */
+export interface EventKeywords {
+  cues: string[];
+  tags: string[];
+}
+
+/**
+ * The MRAgent traversal toolkit. Stateless over the graph — each call is a pure
+ * mapping operator invocation, which keeps memory access interpretable.
+ */
+export class MemoryToolkit {
+  constructor(private readonly graph: CueTagContentGraph) {}
+
+  /**
+   * `query_tag_events` — φ_{(c,g)→e}: retrieve episodic events associated with a
+   * cue–tag pair. The workhorse for multi-hop questions (paper Table 6).
+   */
+  queryTagEvents(cue: string, tag: string): ContentNode[] {
+    return this.graph.contentsForCueTag(cue, tag, 'episodic');
+  }
+
+  /**
+   * `query_conversation_time` — φ_{e→t}: return the conversation timestamp of an
+   * episodic event. Primary operator for temporal questions.
+   */
+  queryConversationTime(eventId: string): string | undefined {
+    const node = this.graph.getContent(eventId);
+    return node?.layer === 'episodic' ? node.timestamp : undefined;
+  }
+
+  /**
+   * `query_event_keywords` — φ_{e→(c,g)}: extract the cues and tags associated
+   * with an episodic event (reverse traversal to discover new retrieval paths).
+   */
+  queryEventKeywords(eventId: string): EventKeywords {
+    const pairs = this.graph.cueTagsForContent(eventId);
+    const cues = new Set<string>();
+    const tags = new Set<string>();
+    for (const { cue, tag } of pairs) {
+      cues.add(cue.text);
+      tags.add(tag.text);
+    }
+    return { cues: [...cues], tags: [...tags] };
+  }
+
+  /**
+   * `query_event_context` — φ_{e→ctx}: retrieve the textual context surrounding
+   * an episodic event (the event's own text plus its temporal neighbours on the
+   * unified timeline).
+   */
+  queryEventContext(eventId: string, window = 1): string {
+    const node = this.graph.getContent(eventId);
+    if (!node || node.layer !== 'episodic') return '';
+    const timeline = this.graph.contentsByLayer('episodic');
+    const idx = timeline.findIndex(e => e.id === eventId);
+    if (idx === -1) return node.text;
+    const start = Math.max(0, idx - window);
+    const end = Math.min(timeline.length, idx + window + 1);
+    return timeline
+      .slice(start, end)
+      .map(e => (e.timestamp ? `[${e.timestamp}] ${e.text}` : e.text))
+      .join('\n');
+  }
+
+  /**
+   * `query_personal_information` — φ_{cs→gs}: return the semantic aspects (tags)
+   * associated with a person entity, e.g. `preference`, `occupation`.
+   */
+  queryPersonalInformation(person: string): TagNode[] {
+    // Aspects are tags that route to semantic content for this entity cue.
+    const aspects: TagNode[] = [];
+    for (const tag of this.graph.tagsForCue(person)) {
+      if (this.graph.contentsForCueTag(person, tag.text, 'semantic').length > 0) {
+        aspects.push(tag);
+      }
+    }
+    return aspects;
+  }
+
+  /**
+   * `query_personal_aspect` — φ_{(cs,gs)→vs}: retrieve the semantic content for a
+   * `(person, aspect)` pair without scanning long episodic histories.
+   */
+  queryPersonalAspect(person: string, aspect: string): ContentNode[] {
+    return this.graph.contentsForCueTag(person, aspect, 'semantic');
+  }
+
+  /**
+   * `query_topic_events` — φ_{τ→e}: retrieve episodic events associated with a
+   * topic node, enabling efficient top-down localisation.
+   */
+  queryTopicEvents(topicId: string): ContentNode[] {
+    return this.graph.episodesForTopic(topicId);
+  }
+}
diff --git a/src/agent/reconstruction/ReconstructiveMemory.ts b/src/agent/reconstruction/ReconstructiveMemory.ts
new file mode 100644
index 0000000..d6d4788
--- /dev/null
+++ b/src/agent/reconstruction/ReconstructiveMemory.ts
@@ -0,0 +1,131 @@
+/**
+ * Reconstructive memory facade — the public entry point for the MRAgent-style
+ * Cue–Tag–Content associative memory and active reconstruction.
+ *
+ * Wraps the construction pipeline ({@link MemoryDistiller}), the associative
+ * graph ({@link CueTagContentGraph}), the traversal {@link MemoryToolkit}, and
+ * the active {@link MemoryReconstructor} behind one cohesive API:
+ *
+ * ```typescript
+ * const rm = new ReconstructiveMemory();
+ * await rm.ingest([
+ *   { id: 'D1:1', speaker: 'Nate', text: "I won a video game tournament in July." },
+ *   { id: 'D1:2', speaker: 'Caroline', text: "I started a new painting class that month." },
+ * ]);
+ * const result = await rm.reconstruct("What did Caroline do in July?");
+ * console.log(result.answer, result.evidence);
+ * ```
+ *
+ * @module agent/reconstruction/ReconstructiveMemory
+ * @experimental
+ */
+
+import type { LLMProvider } from '../../search/LLMQueryPlanner.js';
+import type {
+  CTCGraphSnapshot,
+  DialogueTurn,
+  DistillationResult,
+  ReconstructionOptions,
+  ReconstructionResult,
+} from '../../types/reconstruction.js';
+import { CueTagContentGraph } from './CueTagContentGraph.js';
+import { MemoryDistiller } from './MemoryDistiller.js';
+import { MemoryReconstructor } from './MemoryReconstructor.js';
+import { MemoryToolkit } from './MemoryToolkit.js';
+import {
+  MemoryGraphBridge,
+  type BridgePersistResult,
+  type ReconstructiveBacking,
+} from './MemoryGraphBridge.js';
+
+/** Configuration for {@link ReconstructiveMemory}. */
+export interface ReconstructiveMemoryConfig {
+  /** Optional LLM provider for distillation + answer synthesis. */
+  llmProvider?: LLMProvider;
+  /** Pre-existing graph snapshot to restore from. */
+  snapshot?: CTCGraphSnapshot;
+  /**
+   * Optional live-store backing. When supplied, ingested memory is persisted
+   * into MemoryJS's episodic / semantic / topic modules (durable + searchable),
+   * and semantic similarity is reused for reconstruction routing. When absent,
+   * the facade runs the self-contained in-memory graph.
+   */
+  backing?: ReconstructiveBacking;
+}
+
+export class ReconstructiveMemory {
+  private graph: CueTagContentGraph;
+  private readonly distiller: MemoryDistiller;
+  private readonly llm?: LLMProvider;
+  private readonly bridge?: MemoryGraphBridge;
+  private lastPersist?: BridgePersistResult;
+
+  constructor(config: ReconstructiveMemoryConfig = {}) {
+    this.llm = config.llmProvider;
+    this.graph = config.snapshot
+      ? CueTagContentGraph.fromSnapshot(config.snapshot)
+      : new CueTagContentGraph();
+    this.distiller = new MemoryDistiller(this.llm);
+    this.bridge = config.backing ? new MemoryGraphBridge(config.backing) : undefined;
+    this.backing = config.backing;
+  }
+
+  private readonly backing?: ReconstructiveBacking;
+
+  /**
+   * Construction phase: distil raw dialogue into Cue–Tag–Content structure and
+   * merge it into the in-memory graph. When a live-store backing is configured,
+   * the episodic / semantic / topic layers are also persisted into the
+   * corresponding MemoryJS modules. Multiple `ingest` calls accumulate.
+   */
+  async ingest(turns: DialogueTurn[]): Promise<DistillationResult> {
+    const result = await this.distiller.distill(turns);
+    this.distiller.buildGraph(result, this.graph);
+    if (this.bridge) {
+      this.lastPersist = await this.bridge.persist(result, this.graph);
+    }
+    return result;
+  }
+
+  /** Summary of what the most recent `ingest` persisted to the live store. */
+  get lastPersistResult(): BridgePersistResult | undefined {
+    return this.lastPersist;
+  }
+
+  /**
+   * Reconstruction phase: answer a query via active, multi-step traversal of the
+   * memory graph (Algorithm 1).
+   */
+  async reconstruct(
+    query: string,
+    options?: ReconstructionOptions,
+  ): Promise<ReconstructionResult> {
+    const reconstructor = new MemoryReconstructor(this.graph, this.llm, this.backing?.similarity);
+    return reconstructor.reconstruct(query, options);
+  }
+
+  /** Direct access to the traversal toolkit for manual graph exploration. */
+  get toolkit(): MemoryToolkit {
+    return new MemoryToolkit(this.graph);
+  }
+
+  /** The underlying associative graph (read/inspect cues, tags, contents). */
+  get memoryGraph(): CueTagContentGraph {
+    return this.graph;
+  }
+
+  /** Graph size statistics. */
+  stats(): ReturnType<CueTagContentGraph['stats']> {
+    return this.graph.stats();
+  }
+
+  /** Serialise the current graph (e.g. to persist alongside the knowledge base). */
+  toSnapshot(): CTCGraphSnapshot {
+    return this.graph.toSnapshot();
+  }
+
+  /** Replace the current graph with a restored snapshot. */
+  loadSnapshot(snapshot: CTCGraphSnapshot): void {
+    this.graph = CueTagContentGraph.fromSnapshot(snapshot);
+  }
+}
diff --git a/src/agent/reconstruction/index.ts b/src/agent/reconstruction/index.ts
new file mode 100644
index 0000000..fd974c3
--- /dev/null
+++ b/src/agent/reconstruction/index.ts
@@ -0,0 +1,20 @@
+/**
+ * Reconstructive (MRAgent-style) associative memory.
+ *
+ * Barrel for the Cue–Tag–Content associative memory graph and active memory
+ * reconstruction, implementing "Memory is Reconstructed, Not Retrieved: Graph
+ * Memory for LLM Agents" (Ji, Li & Hooi, ICML 2026).
+ *
+ * @module agent/reconstruction
+ * @experimental
+ */
+
+export { CueTagContentGraph, normalizeKey } from './CueTagContentGraph.js';
+export { MemoryToolkit } from './MemoryToolkit.js';
+export type { EventKeywords } from './MemoryToolkit.js';
+export { MemoryDistiller, extractJson } from './MemoryDistiller.js';
+export { MemoryReconstructor } from './MemoryReconstructor.js';
+export { ReconstructiveMemory } from './ReconstructiveMemory.js';
+export type { ReconstructiveMemoryConfig } from './ReconstructiveMemory.js';
+export { MemoryGraphBridge, TOPIC_SUMMARIZES } from './MemoryGraphBridge.js';
+export type { ReconstructiveBacking, BridgePersistResult } from './MemoryGraphBridge.js';
diff --git a/src/core/ManagerContext.ts b/src/core/ManagerContext.ts
index 3acd4b9..5dc7951 100644
--- a/src/core/ManagerContext.ts
+++ b/src/core/ManagerContext.ts
@@ -94,6 +94,11 @@ import { RbacMiddleware } from '../agent/rbac/RbacMiddleware.js';
 import { RoleAssignmentStore } from '../agent/rbac/RoleAssignmentStore.js';
 import { WorldModelManager } from '../agent/world/WorldModelManager.js';
 import { ActiveRetrievalController } from '../agent/retrieval/ActiveRetrievalController.js';
+import {
+  ReconstructiveMemory,
+  type ReconstructiveMemoryConfig,
+  type ReconstructiveBacking,
+} from '../agent/reconstruction/index.js';
 
 /**
  * Options for constructing a ManagerContext.
@@ -189,6 +194,7 @@ export class ManagerContext {
   private _roleAssignmentStore?: RoleAssignmentStore;
   private _worldModelManager?: WorldModelManager;
   private _activeRetrieval?: ActiveRetrievalController;
+  private _reconstructiveMemory?: ReconstructiveMemory;
   private _accessTracker?: AccessTracker;
   private _decayEngine?: DecayEngine;
   private _decayScheduler?: DecayScheduler;
@@ -1063,6 +1069,61 @@ export class ManagerContext {
     return this._activeRetrieval;
   }
 
+  /**
+   * `ReconstructiveMemory` — MRAgent-style associative memory ("Memory is
+   * Reconstructed, Not Retrieved"). Builds a Cue–Tag–Content graph from
+   * dialogue (`ingest`) and answers queries via active, multi-step memory
+   * reconstruction (`reconstruct`). Lazy; works zero-config with heuristic
+   * distillation/reconstruction, or pass an `LLMProvider` for the paper's
+   * LLM-driven distillation and answer synthesis.
+   *
+   * @param config Optional LLM provider / restored graph snapshot. Passing a
+   *   config re-instantiates the facade (invalidates the cached instance).
+   */
+  reconstructiveMemory(config?: ReconstructiveMemoryConfig): ReconstructiveMemory {
+    if (config) {
+      // Default the live-store backing to this context's managers unless the
+      // caller opts out by passing their own (or `backing: undefined` explicitly).
+      const backing = 'backing' in config ? config.backing : this.buildReconstructiveBacking();
+      this._reconstructiveMemory = new ReconstructiveMemory({ ...config, backing });
+    } else if (!this._reconstructiveMemory) {
+      this._reconstructiveMemory = new ReconstructiveMemory({
+        backing: this.buildReconstructiveBacking(),
+      });
+    }
+    return this._reconstructiveMemory;
+  }
+
+  /**
+   * Build a {@link ReconstructiveBacking} that bridges the Cue–Tag–Content
+   * layers to this context's live modules: episodic episodes onto the
+   * `EpisodicMemoryManager` timeline, semantic facts into the entity graph +
+   * `SemanticSearch`, and topic links as relations.
+   */
+  private buildReconstructiveBacking(): ReconstructiveBacking {
+    const semantic = this.semanticSearch;
+    return {
+      // Agent entities (memoryType/sessionId/…) bypass the plain-Entity schema by
+      // appending directly to storage — the same path EpisodicMemoryManager uses.
+      // Names already present are skipped so repeated ingests don't duplicate
+      // anchor (person/topic) entities.
+      createEntities: async entities => {
+        const graph = await this.storage.loadGraph();
+        const existing = new Set(graph.entities.map(e => e.name));
+        for (const entity of entities) {
+          if (existing.has(entity.name)) continue;
+          existing.add(entity.name);
+          await this.storage.appendEntity(entity);
+        }
+      },
+      createRelations: relations => this.relationManager.createRelations(relations),
+      similarity: semantic
+        ? (a, b) => semantic.calculateSimilarity(a, b)
+        : undefined,
+      indexEntity: semantic ? entity => semantic.indexEntity(entity) : undefined,
+    };
+  }
+
   /**
    * TransitionLedger - Append-only audit trail for state changes.
    * Returns null if not enabled via MEMORY_TRANSITION_LEDGER env var.
diff --git a/src/types/index.ts b/src/types/index.ts
index 75a83a7..abde09c 100644
--- a/src/types/index.ts
+++ b/src/types/index.ts
@@ -242,6 +242,25 @@ export {
   createDetailedProgressReporter,
 } from './progress.js';
 
+// Reconstructive (MRAgent-style) associative memory types — Cue–Tag–Content
+// graph nodes, distillation results, and active reconstruction structures.
+export type {
+  ContentLayer,
+  CueNode,
+  TagNode,
+  ContentNode,
+  CTCTriple,
+  CTCGraphSnapshot,
+  DistilledSentence,
+  PersonalFact,
+  DistillationResult as ReconstructionDistillationResult,
+  DialogueTurn,
+  TraversalActionType,
+  TraversalStep,
+  ReconstructionResult,
+  ReconstructionOptions,
+} from './reconstruction.js';
+
 // Result<T, E> — discriminated-union return type for expected domain
 // failures (see CONTRIBUTING.md > Error Handling).
 export type { Result } from './result.js';
diff --git a/src/types/reconstruction.ts b/src/types/reconstruction.ts
new file mode 100644
index 0000000..ed2ef71
--- /dev/null
+++ b/src/types/reconstruction.ts
@@ -0,0 +1,194 @@
+/**
+ * Types for the Cue–Tag–Content associative memory graph and active memory
+ * reconstruction, implementing the MRAgent design from
+ * "Memory is Reconstructed, Not Retrieved: Graph Memory for LLM Agents"
+ * (Ji, Li & Hooi, ICML 2026).
+ *
+ * The memory system is modelled as a heterogeneous graph `M = (C, V, R)`:
+ *   - Cues `c ∈ C`   — fine-grained keywords (entities, attributes, descriptors)
+ *   - Contents `v ∈ V` — memory items, organised into multi-granular layers
+ *   - Relations `R ⊆ C × G × V` — typed `(cue, tag, content)` triples where the
+ *     associative **tag** `g ∈ G` is the semantic bridge between cue and content.
+ *
+ * @module types/reconstruction
+ * @experimental
+ */
+
+/**
+ * Multi-granular memory layers (paper §3.2).
+ *
+ * - `episodic` — event-specific units grounded in a particular time/context.
+ * - `semantic` — stable knowledge (attributes, preferences, facts) anchored to
+ *   an entity-level cue via an aspect-level tag.
+ * - `topic` — higher-level abstractions summarising recurring patterns across a
+ *   coherent set of episodes.
+ */
+export type ContentLayer = 'episodic' | 'semantic' | 'topic';
+
+/** A fine-grained retrieval cue (entity, attribute, or salient descriptor). */
+export interface CueNode {
+  /** Stable identifier (normalised cue text). */
+  id: string;
+  /** Human-readable cue surface form. */
+  text: string;
+}
+
+/**
+ * An associative tag — a short phrase summarising the relational pattern that
+ * links a cue to memory content. Tags are the controllable intermediate that
+ * lets the agent prune traversal branches before touching expensive content.
+ */
+export interface TagNode {
+  /** Stable identifier (normalised tag text). */
+  id: string;
+  /** Human-readable tag surface form (≤ ~2 words). */
+  text: string;
+}
+
+/** A memory content node — an episode, a semantic fact, or a topic abstraction. */
+export interface ContentNode {
+  /** Stable identifier (e.g. `e1`, `s2`, `t3`). */
+  id: string;
+  /** Which multi-granular layer this content belongs to. */
+  layer: ContentLayer;
+  /** The content text (episode description, fact, or topic summary). */
+  text: string;
+  /** ISO `YYYY-MM-DD` conversation timestamp (episodic layer). */
+  timestamp?: string;
+  /** Topic ids this episode belongs to (episodic → topic links). */
+  topicIds?: string[];
+  /** Entity-level anchor for semantic content (the person/subject the fact is about). */
+  person?: string;
+  /** Free-form provenance (e.g. originating dialogue id). */
+  origin?: string;
+  /**
+   * Name of the persisted MemoryJS entity backing this content node, set when the
+   * graph is bridged to the live store (episodic→`EpisodicMemoryManager` timeline,
+   * semantic→entity/observation graph, topic→topic entity). Absent when running
+   * the self-contained in-memory graph.
+   */
+  entityName?: string;
+}
+
+/** A `(cue, tag, content)` association — one edge of the relation set `R`. */
+export interface CTCTriple {
+  /** Cue id. */
+  cue: string;
+  /** Tag id. */
+  tag: string;
+  /** Content id. */
+  content: string;
+}
+
+/** Serialisable snapshot of a {@link CueTagContentGraph}. */
+export interface CTCGraphSnapshot {
+  cues: CueNode[];
+  tags: TagNode[];
+  contents: ContentNode[];
+  triples: CTCTriple[];
+}
+
+// ==================== Construction (distillation) ====================
+
+/** A single processed/rewritten dialogue sentence produced by distillation. */
+export interface DistilledSentence {
+  /** Sentence id (e.g. `D1:1-1`). */
+  id: string;
+  /** Rewritten, self-contained text (pronouns resolved, time normalised). */
+  text: string;
+  /** Short associative tag (≤ ~2 words). */
+  tag: string;
+  /** Originating raw sentence id. */
+  origin?: string;
+  /** Topic ids this sentence belongs to. */
+  topics?: string[];
+  /** ISO `YYYY-MM-DD` timestamp. */
+  time?: string;
+}
+
+/** A person-anchored semantic fact extracted during distillation. */
+export interface PersonalFact {
+  /** Fact id (e.g. `p1`). */
+  id: string;
+  /** Normalised fact text. */
+  text: string;
+  /** Aspect-level tag (e.g. `preference`, `occupation`). */
+  tag: string;
+  /** The person/entity the fact is about. */
+  person: string;
+  /** Originating raw sentence id. */
+  origin?: string;
+}
+
+/** Result of running the LLM distillation pipeline over a dialogue. */
+export interface DistillationResult {
+  /** Conversation reference date (ISO `YYYY-MM-DD`). */
+  conversationTime?: string;
+  /** Rewritten episodic sentences. */
+  sentences: DistilledSentence[];
+  /** topic-id → topic description. */
+  topics: Record<string, string>;
+  /** Extracted person-anchored semantic facts. */
+  personalFacts: PersonalFact[];
+  /** sentence-id → extracted cue surface forms. */
+  keywords: Record<string, string[]>;
+}
+
+/** Raw dialogue input accepted by the distiller. */
+export interface DialogueTurn {
+  /** Stable id for the turn (e.g. `D1:1`). */
+  id: string;
+  /** Speaker name, if known. */
+  speaker?: string;
+  /** Raw utterance text. */
+  text: string;
+  /** ISO timestamp for the turn, if known. */
+  timestamp?: string;
+}
+
+// ==================== Active reconstruction ====================
+
+/** A traversal action the agent may take over the memory graph (paper §4.1). */
+export type TraversalActionType =
+  | 'cue->tag' // Forward: activate associative tags from active cues
+  | 'cuetag->content' // Forward: retrieve content conditioned on (cue, tag)
+  | 'content->cuetag' // Reverse: surface new cues/tags from retrieved content
+  | 'topic->episode'; // Top-down: descend from a topic to its episodes
+
+/** One executed traversal action and the candidates it produced. */
+export interface TraversalStep {
+  /** 0-based reconstruction step index. */
+  step: number;
+  /** The action(s) the policy selected this step. */
+  actions: TraversalActionType[];
+  /** Content nodes routed into the reconstructed context this step. */
+  routed: ContentNode[];
+  /** Short rationale for the step (policy- or LLM-supplied). */
+  rationale?: string;
+}
+
+/** Final output of an active reconstruction run (Algorithm 1). */
+export interface ReconstructionResult {
+  /** The query that was reconstructed against. */
+  query: string;
+  /** Final answer, when an answering policy is supplied. */
+  answer?: string;
+  /** Confidence in `[0, 1]`, when available. */
+  confidence?: number;
+  /** Accumulated evidence (the reconstructed context `H`). */
+  evidence: ContentNode[];
+  /** The step-by-step traversal trajectory. */
+  trajectory: TraversalStep[];
+  /** Whether the loop stopped on a satisfied stopping condition (vs. budget). */
+  stoppedEarly: boolean;
+}
+
+/** Tunables for the reconstruction loop. */
+export interface ReconstructionOptions {
+  /** Max reasoning turns `T` (paper caps at 8). Default 8. */
+  maxSteps?: number;
+  /** Max content nodes routed per step (per-turn retrieval budget `K`). Default 10. */
+  perStepBudget?: number;
+  /** Stop once this many distinct evidence items are accumulated. Default 12. */
+  evidenceTarget?: number;
+}
diff --git a/tests/unit/agent/reconstruction/CueTagContentGraph.test.ts b/tests/unit/agent/reconstruction/CueTagContentGraph.test.ts
new file mode 100644
index 0000000..5d42d8d
--- /dev/null
+++ b/tests/unit/agent/reconstruction/CueTagContentGraph.test.ts
@@ -0,0 +1,87 @@
+import { describe, it, expect } from 'vitest';
+import {
+  CueTagContentGraph,
+  normalizeKey,
+} from '../../../../src/agent/reconstruction/CueTagContentGraph.js';
+
+describe('CueTagContentGraph', () => {
+  function buildGraph(): CueTagContentGraph {
+    const g = new CueTagContentGraph();
+    // Episodic content.
+    g.addContent({ id: 'e1', layer: 'episodic', text: 'Nate won a tournament', timestamp: '2023-07-04' });
+    g.addContent({ id: 'e2', layer: 'episodic', text: 'Caroline started painting', timestamp: '2023-07-10' });
+    g.addTriple('Nate', 'tournament win', 'e1');
+    g.addTriple('tournament', 'tournament win', 'e1');
+    g.addTriple('Caroline', 'new hobby', 'e2');
+    return g;
+  }
+
+  it('normalizeKey lowercases and collapses whitespace', () => {
+    expect(normalizeKey('  Video   Game ')).toBe('video game');
+  });
+
+  it('φ_{c→g}: tagsForCue returns associated tags', () => {
+    const g = buildGraph();
+    const tags = g.tagsForCue('Nate');
+    expect(tags.map(t => t.text)).toContain('tournament win');
+  });
+
+  it('φ_{(c,g)→v}: contentsForCueTag returns content for a cue–tag pair', () => {
+    const g = buildGraph();
+    const contents = g.contentsForCueTag('Nate', 'tournament win');
+    expect(contents.map(c => c.id)).toEqual(['e1']);
+  });
+
+  it('φ_{(c,g)→v} filters by layer', () => {
+    const g = buildGraph();
+    g.addContent({ id: 's1', layer: 'semantic', text: 'Nate likes chess', person: 'Nate' });
+    g.addTriple('Nate', 'preference', 's1');
+    expect(g.contentsForCueTag('Nate', 'preference', 'episodic')).toHaveLength(0);
+    expect(g.contentsForCueTag('Nate', 'preference', 'semantic')).toHaveLength(1);
+  });
+
+  it('φ_{v→(c,g)}: reverse traversal surfaces cues and tags from content', () => {
+    const g = buildGraph();
+    const pairs = g.cueTagsForContent('e1');
+    const cueTexts = pairs.map(p => p.cue.text).sort();
+    expect(cueTexts).toEqual(['Nate', 'tournament']);
+  });
+
+  it('φ_{τ→e}: topic links resolve to episodes', () => {
+    const g = buildGraph();
+    g.addContent({ id: 't1', layer: 'topic', text: 'Topic: games' });
+    g.addContent({
+      id: 'e3',
+      layer: 'episodic',
+      text: 'Nate played a new game',
+      topicIds: ['t1'],
+    });
+    expect(g.episodesForTopic('t1').map(e => e.id)).toEqual(['e3']);
+  });
+
+  it('episodic contents come back in timeline order', () => {
+    const g = buildGraph();
+    expect(g.contentsByLayer('episodic').map(e => e.id)).toEqual(['e1', 'e2']);
+  });
+
+  it('matchCues finds exact and substring cue matches', () => {
+    const g = buildGraph();
+    expect(g.matchCues('Nate').map(c => c.id)).toEqual(['nate']);
+    expect(g.matchCues('tourna').map(c => c.id)).toContain('tournament');
+  });
+
+  it('addTriple is idempotent and rejects unknown content', () => {
+    const g = buildGraph();
+    const before = g.stats().triples;
+    g.addTriple('Nate', 'tournament win', 'e1'); // duplicate
+    expect(g.stats().triples).toBe(before);
+    expect(() => g.addTriple('X', 'y', 'missing')).toThrow();
+  });
+
+  it('round-trips through a snapshot', () => {
+    const g = buildGraph();
+    const restored = CueTagContentGraph.fromSnapshot(g.toSnapshot());
+    expect(restored.stats()).toEqual(g.stats());
+    expect(restored.contentsForCueTag('Caroline', 'new hobby').map(c => c.id)).toEqual(['e2']);
+  });
+});
diff --git a/tests/unit/agent/reconstruction/MemoryGraphBridge.test.ts b/tests/unit/agent/reconstruction/MemoryGraphBridge.test.ts
new file mode 100644
index 0000000..bf19227
--- /dev/null
+++ b/tests/unit/agent/reconstruction/MemoryGraphBridge.test.ts
@@ -0,0 +1,119 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { ManagerContext } from '../../../../src/core/ManagerContext.js';
+import { ReconstructiveMemory } from '../../../../src/agent/reconstruction/ReconstructiveMemory.js';
+import { MemoryGraphBridge } from '../../../../src/agent/reconstruction/MemoryGraphBridge.js';
+import type { Entity, Relation } from '../../../../src/types/types.js';
+import type { DialogueTurn } from '../../../../src/types/reconstruction.js';
+
+const TURNS: DialogueTurn[] = [
+  { id: 'D1:1', speaker: 'Joanna', text: 'I submitted my first screenplay to a studio on 2023-01-05.', timestamp: '2023-01-05' },
+  { id: 'D2:1', speaker: 'Joanna', text: 'The studio rejected my first screenplay on 2023-03-01.', timestamp: '2023-03-01' },
+  { id: 'D3:1', speaker: 'Joanna', text: 'I prefer writing thriller screenplays.', timestamp: '2023-03-01' },
+];
+
+describe('MemoryGraphBridge — links CTC layers to live modules', () => {
+  it('persists episodic, semantic and topic content with a fake backing', async () => {
+    const entities: Entity[] = [];
+    const relations: Relation[] = [];
+    const backing = {
+      createEntities: async (es: Entity[]) => { entities.push(...es); },
+      createRelations: async (rs: Relation[]) => { relations.push(...rs); },
+      sessionId: 'sess-1',
+    };
+    const rm = new ReconstructiveMemory({ backing });
+    await rm.ingest(TURNS);
+
+    // Episodic entities land on the timeline (memoryType episodic + sessionId).
+    const episodes = entities.filter(e => (e as { memoryType?: string }).memoryType === 'episodic');
+    expect(episodes.length).toBeGreaterThan(0);
+    expect(episodes.every(e => (e as { sessionId?: string }).sessionId === 'sess-1')).toBe(true);
+    // Conversation timestamps drive createdAt → timeline order.
+    expect(episodes.every(e => !!e.createdAt)).toBe(true);
+
+    // Semantic facts persisted as entities + anchored to the person.
+    const facts = entities.filter(e => e.entityType === 'semantic_fact');
+    expect(facts.length).toBeGreaterThan(0);
+    expect(entities.some(e => e.name === 'Joanna' && e.entityType === 'person')).toBe(true);
+    expect(relations.some(r => r.from === 'Joanna' && r.relationType.startsWith('has_'))).toBe(true);
+
+    // Temporal links between consecutive episodes.
+    expect(relations.some(r => r.relationType === 'precedes')).toBe(true);
+    expect(relations.some(r => r.relationType === 'follows')).toBe(true);
+
+    // Content nodes annotated with their backing entity names.
+    const snap = rm.toSnapshot();
+    expect(snap.contents.some(c => c.layer === 'episodic' && !!c.entityName)).toBe(true);
+    expect(snap.contents.some(c => c.layer === 'semantic' && !!c.entityName)).toBe(true);
+
+    // Persist summary surfaced.
+    expect(rm.lastPersistResult?.episodes).toBe(episodes.length);
+  });
+
+  it('reuses the backing similarity function for routing', async () => {
+    const calls: Array<[string, string]> = [];
+    const backing = {
+      createEntities: async () => {},
+      createRelations: async () => {},
+      similarity: async (a: string, b: string) => {
+        calls.push([a, b]);
+        return /screenplay/i.test(b) ? 0.9 : 0.1;
+      },
+    };
+    const rm = new ReconstructiveMemory({ backing });
+    await rm.ingest(TURNS);
+    const result = await rm.reconstruct('Which screenplays were rejected?');
+    expect(calls.length).toBeGreaterThan(0); // similarity actually consulted
+    expect(result.evidence.length).toBeGreaterThan(0);
+  });
+
+  it('exposes the session id used for timeline scoping', () => {
+    const bridge = new MemoryGraphBridge({
+      createEntities: async () => {},
+      createRelations: async () => {},
+      sessionId: 'abc',
+    });
+    expect(bridge.session).toBe('abc');
+  });
+});
+
+describe('ManagerContext.reconstructiveMemory — end-to-end live bridge', () => {
+  let dir: string;
+  let ctx: ManagerContext;
+
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), 'mragent-bridge-'));
+    ctx = new ManagerContext(join(dir, 'memory.jsonl'));
+  });
+
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('persists reconstructed memory into the real entity/relation store', async () => {
+    const rm = ctx.reconstructiveMemory();
+    await rm.ingest(TURNS);
+
+    // Episodes are queryable as real entities in the live store.
+    const all = (await ctx.storage.loadGraph()).entities;
+    const episodes = all.filter(e => (e as { memoryType?: string }).memoryType === 'episodic');
+    expect(episodes.length).toBeGreaterThan(0);
+
+    // And visible on the EpisodicMemoryManager timeline (sorted by conversation date).
+    const bridgeSession = 'mragent';
+    const timeline = await ctx.agentMemory().episodicMemory.getTimeline(bridgeSession);
+    expect(timeline.length).toBeGreaterThan(0);
+    const times = timeline.map(e => new Date(e.createdAt ?? 0).getTime());
+    expect([...times].sort((a, b) => a - b)).toEqual(times); // ascending
+
+    // Semantic facts + person anchor persisted.
+    expect(all.some(e => e.entityType === 'semantic_fact')).toBe(true);
+    expect(all.some(e => e.name === 'Joanna')).toBe(true);
+
+    // Reconstruction still answers against the live-backed graph.
+    const result = await rm.reconstruct('What did Joanna submit?');
+    expect(result.evidence.length).toBeGreaterThan(0);
+  });
+});
diff --git a/tests/unit/agent/reconstruction/MemoryToolkit.test.ts b/tests/unit/agent/reconstruction/MemoryToolkit.test.ts
new file mode 100644
index 0000000..5732efb
--- /dev/null
+++ b/tests/unit/agent/reconstruction/MemoryToolkit.test.ts
@@ -0,0 +1,60 @@
+import { describe, it, expect } from 'vitest';
+import { CueTagContentGraph } from '../../../../src/agent/reconstruction/CueTagContentGraph.js';
+import { MemoryToolkit } from '../../../../src/agent/reconstruction/MemoryToolkit.js';
+
+function fixture(): MemoryToolkit {
+  const g = new CueTagContentGraph();
+  g.addContent({ id: 'e1', layer: 'episodic', text: 'Joanna submitted her first screenplay', timestamp: '2023-01-05', topicIds: ['t1'] });
+  g.addContent({ id: 'e2', layer: 'episodic', text: 'A production company rejected the screenplay', timestamp: '2023-02-01', topicIds: ['t1'] });
+  g.addContent({ id: 't1', layer: 'topic', text: 'Topic: screenplays' });
+  g.addContent({ id: 's1', layer: 'semantic', text: 'Joanna prefers thriller genres', person: 'Joanna' });
+  g.addTriple('Joanna', 'screenplay submission', 'e1');
+  g.addTriple('screenplay', 'screenplay submission', 'e1');
+  g.addTriple('Joanna', 'screenplay rejection', 'e2');
+  g.addTriple('Joanna', 'preference', 's1');
+  g.linkTopicEpisode('t1', 'e1');
+  g.linkTopicEpisode('t1', 'e2');
+  return new MemoryToolkit(g);
+}
+
+describe('MemoryToolkit (7 traversal operators, paper Table 4)', () => {
+  it('query_tag_events retrieves episodic events for a cue–tag pair', () => {
+    const tk = fixture();
+    expect(tk.queryTagEvents('Joanna', 'screenplay submission').map(e => e.id)).toEqual(['e1']);
+  });
+
+  it('query_conversation_time returns the event timestamp', () => {
+    const tk = fixture();
+    expect(tk.queryConversationTime('e2')).toBe('2023-02-01');
+    expect(tk.queryConversationTime('s1')).toBeUndefined(); // semantic has no timestamp
+  });
+
+  it('query_event_keywords surfaces cues and tags of an event', () => {
+    const tk = fixture();
+    const { cues, tags } = tk.queryEventKeywords('e1');
+    expect(cues.sort()).toEqual(['Joanna', 'screenplay']);
+    expect(tags).toContain('screenplay submission');
+  });
+
+  it('query_event_context returns surrounding timeline text', () => {
+    const tk = fixture();
+    const ctx = tk.queryEventContext('e1', 1);
+    expect(ctx).toContain('Joanna submitted her first screenplay');
+    expect(ctx).toContain('rejected'); // neighbour on the timeline
+  });
+
+  it('query_personal_information lists semantic aspects of a person', () => {
+    const tk = fixture();
+    expect(tk.queryPersonalInformation('Joanna').map(t => t.text)).toEqual(['preference']);
+  });
+
+  it('query_personal_aspect retrieves semantic content for (person, aspect)', () => {
+    const tk = fixture();
+    expect(tk.queryPersonalAspect('Joanna', 'preference').map(s => s.id)).toEqual(['s1']);
+  });
+
+  it('query_topic_events descends a topic to its episodes', () => {
+    const tk = fixture();
+    expect(tk.queryTopicEvents('t1').map(e => e.id).sort()).toEqual(['e1', 'e2']);
+  });
+});
diff --git a/tests/unit/agent/reconstruction/ReconstructiveMemory.test.ts b/tests/unit/agent/reconstruction/ReconstructiveMemory.test.ts
new file mode 100644
index 0000000..736730e
--- /dev/null
+++ b/tests/unit/agent/reconstruction/ReconstructiveMemory.test.ts
@@ -0,0 +1,115 @@
+import { describe, it, expect } from 'vitest';
+import { ReconstructiveMemory } from '../../../../src/agent/reconstruction/ReconstructiveMemory.js';
+import { MemoryDistiller, extractJson } from '../../../../src/agent/reconstruction/MemoryDistiller.js';
+import type { DialogueTurn } from '../../../../src/types/reconstruction.js';
+import type { LLMProvider } from '../../../../src/search/LLMQueryPlanner.js';
+
+const NATE_CAROLINE: DialogueTurn[] = [
+  { id: 'D1:1', speaker: 'Nate', text: 'I won a video game tournament on 2023-07-04.', timestamp: '2023-07-04' },
+  { id: 'D1:2', speaker: 'Caroline', text: 'I started a new painting class on 2023-07-10.', timestamp: '2023-07-10' },
+  { id: 'D1:3', speaker: 'Nate', text: 'I prefer strategy games over shooters.', timestamp: '2023-07-04' },
+];
+
+describe('MemoryDistiller (heuristic construction)', () => {
+  it('resolves pronouns to the speaker during rewriting', async () => {
+    const d = new MemoryDistiller();
+    const result = await d.distill(NATE_CAROLINE);
+    const s = result.sentences.find(x => x.origin === 'D1:1')!;
+    expect(s.text).toContain('Nate');
+    expect(s.text).not.toMatch(/\bI\b/);
+  });
+
+  it('normalizes timestamps to YYYY-MM-DD', async () => {
+    const d = new MemoryDistiller();
+    const result = await d.distill(NATE_CAROLINE);
+    expect(result.sentences.every(s => !s.time || /^\d{4}-\d{2}-\d{2}$/.test(s.time))).toBe(true);
+  });
+
+  it('extracts person-anchored semantic facts', async () => {
+    const d = new MemoryDistiller();
+    const result = await d.distill(NATE_CAROLINE);
+    const pref = result.personalFacts.find(f => f.tag === 'preference');
+    expect(pref?.person).toBe('Nate');
+  });
+
+  it('builds a multi-layer Cue–Tag–Content graph', async () => {
+    const d = new MemoryDistiller();
+    const result = await d.distill(NATE_CAROLINE);
+    const graph = d.buildGraph(result);
+    const stats = graph.stats();
+    expect(stats.contents).toBeGreaterThan(0);
+    expect(stats.triples).toBeGreaterThan(0);
+    expect(graph.contentsByLayer('semantic').length).toBeGreaterThan(0);
+  });
+});
+
+describe('ReconstructiveMemory — active reconstruction (Algorithm 1)', () => {
+  it('ingests dialogue and answers via graph traversal', async () => {
+    const rm = new ReconstructiveMemory();
+    await rm.ingest(NATE_CAROLINE);
+    const result = await rm.reconstruct('What did Caroline do in July?');
+    expect(result.evidence.length).toBeGreaterThan(0);
+    // Caroline's painting episode should be reconstructed.
+    expect(result.evidence.some(e => /painting/i.test(e.text))).toBe(true);
+    expect(result.trajectory.length).toBeGreaterThan(0);
+  });
+
+  it('records a multi-step traversal trajectory with typed actions', async () => {
+    const rm = new ReconstructiveMemory();
+    await rm.ingest(NATE_CAROLINE);
+    const result = await rm.reconstruct('Nate tournament');
+    const allActions = result.trajectory.flatMap(s => s.actions);
+    expect(allActions).toContain('cue->tag');
+    expect(allActions).toContain('cuetag->content');
+  });
+
+  it('respects the maxSteps budget', async () => {
+    const rm = new ReconstructiveMemory();
+    await rm.ingest(NATE_CAROLINE);
+    const result = await rm.reconstruct('Nate', { maxSteps: 2 });
+    expect(result.trajectory.length).toBeLessThanOrEqual(2);
+  });
+
+  it('returns an empty-evidence result for an unknown query', async () => {
+    const rm = new ReconstructiveMemory();
+    await rm.ingest(NATE_CAROLINE);
+    const result = await rm.reconstruct('quantum chromodynamics in ancient Rome');
+    expect(result.evidence).toHaveLength(0);
+    expect(result.confidence).toBe(0);
+  });
+
+  it('round-trips the graph through a snapshot', async () => {
+    const rm = new ReconstructiveMemory();
+    await rm.ingest(NATE_CAROLINE);
+    const snap = rm.toSnapshot();
+    const rm2 = new ReconstructiveMemory({ snapshot: snap });
+    expect(rm2.stats()).toEqual(rm.stats());
+  });
+});
+
+describe('ReconstructiveMemory — LLM path', () => {
+  it('synthesizes an answer via the LLM provider when supplied', async () => {
+    const llm: LLMProvider = {
+      async complete(prompt: string): Promise<string> {
+        if (prompt.includes('question-answering agent')) {
+          return JSON.stringify({ answer: 'painting class', confidence: 0.9 });
+        }
+        // Force heuristic distillation by returning unparseable text.
+        return 'n/a';
+      },
+    };
+    const rm = new ReconstructiveMemory({ llmProvider: llm });
+    await rm.ingest(NATE_CAROLINE);
+    const result = await rm.reconstruct('What did Caroline do?');
+    expect(result.answer).toBe('painting class');
+    expect(result.confidence).toBe(0.9);
+  });
+});
+
+describe('extractJson', () => {
+  it('parses fenced and bare JSON, ignoring surrounding prose', () => {
+    expect(extractJson('here: {"a":1} done')).toEqual({ a: 1 });
+    expect(extractJson('```json\n{"b":[1,2]}\n```')).toEqual({ b: [1, 2] });
+    expect(extractJson('no json here')).toBeUndefined();
+  });
+});