diff --git a/anton/chat.py b/anton/chat.py
index ca87349c..7200094a 100644
--- a/anton/chat.py
+++ b/anton/chat.py
@@ -36,7 +36,7 @@
     handle_setup_models,
 )
 from anton.commands.ui import handle_explain, handle_theme, print_slash_help, make_completer
-from anton.commands.ui import SKILLS_COMMANDS, THEME_COMMANDS, COMMANDS
+from anton.commands.ui import SKILLS_COMMANDS, THEME_COMMANDS, SHARE_COMMANDS, COMMANDS
 
 from anton.utils.clipboard import (
     ensure_clipboard,
@@ -58,6 +58,7 @@
     handle_skill_show,
     handle_skills_list,
 )
+from anton.commands.share import handle_share_export, handle_share_import, handle_share_status, handle_share_history
 from anton.tools import CONNECT_DATASOURCE_TOOL, PUBLISH_TOOL
 from anton.utils.prompt import (
     prompt_or_cancel,
@@ -1011,11 +1012,19 @@ async def _chat_loop(
     global_memory_dir = Path.home() / ".anton" / "memory"
     project_memory_dir = settings.workspace_path / ".anton" / "memory"
 
+    from anton.core.memory.episodes import EpisodicMemory
+
+    episodes_dir = settings.workspace_path / ".anton" / "episodes"
+    episodic = EpisodicMemory(episodes_dir, enabled=settings.episodic_memory)
+    if episodic.enabled:
+        episodic.start_session()
+
     cortex = Cortex(
         global_hc=Hippocampus(global_memory_dir),
         project_hc=Hippocampus(project_memory_dir),
         mode=settings.memory_mode,
         llm_client=state["llm_client"],
+        episodic=episodic if episodic.enabled else None,
     )
 
     # Reconsolidation: migrate legacy memory formats on first run
@@ -1031,13 +1040,6 @@ async def _chat_loop(
     if cortex.needs_compaction():
         asyncio.create_task(cortex.compact_all())
 
-    from anton.core.memory.episodes import EpisodicMemory
-
-    episodes_dir = settings.workspace_path / ".anton" / "episodes"
-    episodic = EpisodicMemory(episodes_dir, enabled=settings.episodic_memory)
-    if episodic.enabled:
-        episodic.start_session()
-
     from anton.memory.history_store import HistoryStore
 
     history_store = HistoryStore(episodes_dir)
@@ -1143,11 +1145,11 @@ def _bottom_toolbar():
         mouse_support=False,
         bottom_toolbar=_bottom_toolbar,
         style=pt_style,
-        completer=make_completer([THEME_COMMANDS, SKILLS_COMMANDS, COMMANDS, MEMORY_COMMANDS]),
+        completer=make_completer([THEME_COMMANDS, SKILLS_COMMANDS, SHARE_COMMANDS, COMMANDS, MEMORY_COMMANDS]),
         complete_while_typing=True,
     )
 
-    memory_manage = MemoryManage(console, settings, cortex, episodic=episodic)
+    memory_manage = MemoryManage(console, settings, cortex, episodic=episodic, history_store=history_store)
     try:
         while True:
             # Memory confirmation UX — show pending lessons before prompt
@@ -1228,7 +1230,7 @@ def _bottom_toolbar():
             # Detect dragged file paths early — a dragged absolute path like
             # "/Users/foo/bar.txt" starts with "/" and would otherwise be
             # mistaken for a slash command.
-            if message_content is None and stripped.startswith("/"):
+            if message_content is None and stripped.startswith("/") and not stripped.startswith("/share"):
                 dropped_early = _parse_dropped_paths(stripped)
                 if dropped_early:
                     stripped = format_file_message(stripped, dropped_early, console)
@@ -1279,7 +1281,7 @@ def _bottom_toolbar():
                     )
                     continue
                 elif cmd == "/memory":
-                    await memory_manage.handle(cmd=stripped)
+                    await memory_manage.handle(cmd=stripped, session=session)
                     continue
                 elif cmd == "/connect":
                     arg = parts[1].strip() if len(parts) > 1 else ""
@@ -1347,6 +1349,46 @@ def _bottom_toolbar():
                 elif cmd == "/skills":
                     handle_skills_list(console)
                     continue
+                elif cmd == "/share":
+                    sub_parts = parts[1].strip().split(maxsplit=1) if len(parts) > 1 else []
+                    sub = sub_parts[0] if sub_parts else ""
+                    rest = sub_parts[1] if len(sub_parts) > 1 else ""
+                    if sub == "export":
+                        await handle_share_export(
+                            console,
+                            session,
+                            workspace,
+                            state["llm_client"],
+                            episodic if episodic.enabled else None,
+                            summary_only="--summary" in rest,
+                        )
+                    elif sub == "import":
+                        if not rest:
+                            console.print("[anton.warning]Usage: /share import <file>[/]")
+                            console.print()
+                        else:
+                            session = await handle_share_import(
+                                console,
+                                session,
+                                workspace,
+                                settings,
+                                state,
+                                self_awareness,
+                                cortex,
+                                episodic if episodic.enabled else None,
+                                history_store,
+                                filepath=rest,
+                            )
+                            current_session_id = session._session_id
+                    elif sub == "status":
+                        handle_share_status(console, session, workspace)
+                    elif sub == "history":
+                        handle_share_history(console, workspace)
+                    else:
+                        usage = " | ".join(c.command for c in SHARE_COMMANDS)
+                        console.print(f"[anton.warning]Usage: {usage}[/]")
+                        console.print()
+                    continue
                 elif cmd == "/resume":
                     session, resumed_id = await handle_resume(
                         console,
diff --git a/anton/commands/session.py b/anton/commands/session.py
index 7b4d1856..cdd9d8df 100644
--- a/anton/commands/session.py
+++ b/anton/commands/session.py
@@ -64,8 +64,9 @@ async def handle_resume(
     console.print()
 
     choices = [str(i) for i in range(1, len(sessions) + 1)] + ["q"]
+    choices_display = f"1-{len(sessions)}/q" if len(sessions) > 1 else "1/q"
     choice = await prompt_or_cancel(
-        "(anton) Select session (or q to cancel)", choices=choices, default="q"
+        "(anton) Select session (or q to cancel)", choices=choices, choices_display=choices_display, default="q"
     )
     if choice is None or choice == "q":
         console.print()
@@ -74,6 +75,24 @@ async def handle_resume(
     idx = int(choice) - 1
     selected = sessions[idx]
     sid = selected["session_id"]
+    return await restore_session(
+        sid, console, settings, state, self_awareness, cortex, workspace,
+        session, episodic, history_store
+    )
+
+
+async def restore_session(
+    sid: str,
+    console: Console,
+    settings: AntonSettings,
+    state: dict,
+    self_awareness,
+    cortex: "Cortex | None",
+    workspace: "Workspace | None",
+    session: "ChatSession",
+    episodic: "EpisodicMemory | None" = None,
+    history_store: "HistoryStore | None" = None,
+):
 
     history = history_store.load(sid)
     if history is None:
@@ -106,7 +125,7 @@ async def handle_resume(
 
     console.print()
     console.print(
-        f"[anton.success]Resumed session from {selected['date']} ({selected['turns']} turns)[/]"
+        f"[anton.success]Resumed session from {sid} ({new_session._turn_count} turns)[/]"
     )
     console.print()
 
diff --git a/anton/commands/share.py b/anton/commands/share.py
new file mode 100644
index 00000000..81974e7d
--- /dev/null
+++ b/anton/commands/share.py
@@ -0,0 +1,529 @@
+"""Slash-command handlers for /share."""
+from __future__ import annotations
+
+import getpass
+import json
+import os
+import re
+import tempfile
+from dataclasses import asdict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel, Field
+from rich.console import Console
+
+if TYPE_CHECKING:
+    from anton.config.settings import AntonSettings
+    from anton.core.llm.client import LLMClient
+    from anton.core.session import ChatSession
+    from anton.workspace import Workspace
+
+
+class _SessionMeta(BaseModel):
+    title: str = Field(
+        description=(
+            "A 5-7 word title in lowercase-with-hyphens, suitable as a filename slug. "
+            "Example: 'pipeline-latency-root-cause-analysis'"
+        )
+    )
+    summary: str = Field(
+        description=(
+            "A distilled narrative of the analytical session: the goal, key discoveries, "
+            "any corrections or dead ends, and where the analysis currently stands. "
+            "Each distinct finding appears exactly once. 2-4 sentences."
+        )
+    )
+
+
+def _format_history_for_llm(history: list[dict], max_messages: int = 20) -> str:
+    recent = history[-max_messages:]
+    lines = []
+    for msg in recent:
+        role = msg.get("role", "")
+        content = msg.get("content", "")
+        if isinstance(content, list):
+            text_parts = [
+                block.get("text", "")
+                for block in content
+                if isinstance(block, dict) and block.get("type") == "text"
+            ]
+            content = " ".join(text_parts)
+        lines.append(f"{role}: {str(content)[:400]}")
+    return "\n".join(lines)
+
+async def _generate_meta(
+    llm_client: LLMClient,
+    history: list[dict],
+    session_id: str,
+) -> tuple[str, str]:
+    try:
+        conversation_text = _format_history_for_llm(history)
+        result = await llm_client.generate_object_code(
+            _SessionMeta,
+            system=(
+                "You are producing a portable context distillation of an analytical session. "
+                "For the summary: cover the goal, key discoveries, any corrections or dead ends, "
+                "and where the analysis currently stands. Every distinct finding should appear once. "
+                "No filler, no repetition, no omissions of meaningful conclusions."
+            ),
+            messages=[{
+                "role": "user",
+                "content": f"Distill this analytical session:\n\n{conversation_text}",
+            }],
+            max_tokens=300,
+        )
+
+        return result.title, result.summary
+    except Exception:
+        return f"session-{session_id}", ""
+
+
+async def handle_share_export(
+    console: Console,
+    session: "ChatSession",
+    workspace: "Workspace",
+    llm_client: "LLMClient",
+    episodic: "EpisodicMemory | None",
+    *,
+    summary_only: bool = False,
+) -> None:
+    session_id = session._session_id
+    if not session_id:
+        console.print("[anton.warning]No active session to export.[/]")
+        console.print()
+        return
+
+    if not episodic:
+        console.print("[anton.muted]Episodic memory not enabled — memory snapshot will be empty.[/]")
+        return
+
+    history = [] if summary_only else [asdict(ep) for ep in episodic.get_conversation()]
+
+    msg_count = len(session._history)
+    if not summary_only and msg_count > 100:
+        console.print(
+            f"[anton.warning]This session has {msg_count} messages. "
+            "Consider [bold]/share export --summary[/] for a lighter file.[/]"
+        )
+        console.print()
+    if msg_count == 0:
+        console.print(
+            f"[anton.warning]This session conversation is empty. Nothing to export.[/]"
+        )
+        return
+
+    # memory snapshot
+    episodes = episodic.get_memory_usage()
+    session_born, project_accessed = [], []
+    for e in episodes:
+        item = {
+            "content": e.content,
+            "kind": e.meta.get("kind", ""),
+            "topic": e.meta.get("topic", ""),
+        }
+        if e.role == "memory_write":
+            session_born.append(item)
+        if e.role == "memory_read":
+            project_accessed.append(item)
+
+    # scratchpad cells
+    cells: list[dict] = []
+    for pad_name, runtime in session._scratchpads.pads.items():
+        for cell in runtime.cells:
+            cells.append({
+                "pad": pad_name,
+                "code": cell.code,
+                "stdout": cell.stdout,
+                "stderr": cell.stderr,
+                "error": cell.error,
+                "description": cell.description,
+            })
+
+    console.print("[anton.muted]Generating session summary…[/]")
+    title, summary = await _generate_meta(llm_client, session._history, session_id)
+
+    slug = title.lower().strip()
+    slug = re.sub(r"[^\w\s-]", "", slug)
+    slug = re.sub(r"[\s_]+", "-", slug)
+    slug = re.sub(r"-+", "-", slug).strip("-")
+    slug = slug[:60] or "session"
+
+    exported_at = datetime.now(timezone.utc).isoformat()
+    timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+    filename = f"{slug}_{timestamp}.anton"
+
+    payload = {
+        "version": "0.1",
+        "exported_by": getpass.getuser(),
+        "exported_at": exported_at,
+        "session": {
+            "id": session_id,
+            "title": title,
+            "summary": summary,
+            "conversation_history": history,
+        },
+        "memory": {
+            "session_born": session_born,
+            "project_accessed": project_accessed,
+        },
+        "scratchpad": {
+            "cells": cells,
+        },
+    }
+
+    output_dir = workspace.base / ".anton" / "output"
+    output_dir.mkdir(parents=True, exist_ok=True)
+    dest = output_dir / filename
+
+    tmp_fd, tmp_path = tempfile.mkstemp(dir=output_dir, suffix=".tmp")
+    try:
+        with os.fdopen(tmp_fd, "w", encoding="utf-8") as f:
+            json.dump(payload, f, ensure_ascii=False, indent=2)
+        os.replace(tmp_path, dest)
+    except Exception:
+        try:
+            os.unlink(tmp_path)
+        except Exception:
+            pass
+        raise
+
+    console.print()
+    console.print("[bold][anton.cyan]Session exported[/][/]")
+    console.print(f"  [bold]File:[/]    {dest}")
+    console.print(f"  [bold]Title:[/]   {payload['session']['title']}")
+    if summary:
+        console.print(f"  [bold]Summary:[/] {summary}")
+    console.print(
+        f"  [bold]Memory:[/]  {len(session_born)} session-born, "
+        f"{len(project_accessed)} project memories"
+    )
+    console.print(f"  [bold]Code:[/]    {len(cells)} scratchpad cells")
+    if episodic and not session_born and not project_accessed:
+        console.print(
+            "[anton.muted]  No project memories were delivered in this session.[/]"
+        )
+    console.print()
+
+
+# ── status ───────────────────────────────────────────────────────────────────
+
+
+def _find_import_record(output_dir: Path, session_id: str) -> dict | None:
+    """Return the .anton payload that was imported into session_id, or None."""
+    if not output_dir.exists():
+        return None
+    for p in output_dir.glob("*.anton"):
+        try:
+            data = json.loads(p.read_text(encoding="utf-8"))
+            if data.get("imported", {}).get("session_id") == session_id:
+                return data
+        except Exception:
+            continue
+    return None
+
+def handle_share_status(
+    console: Console,
+    session: "ChatSession",
+    workspace: "Workspace",
+) -> None:
+    session_id = session._session_id
+
+    console.print()
+    console.print("[bold]Shared session status[/]")
+    console.print()
+
+    if not session_id:
+        console.print("[anton.muted]  No active session.[/]")
+        console.print()
+        return
+
+    output_dir = workspace.base / ".anton" / "output"
+    record = _find_import_record(output_dir, session_id)
+
+    if not record:
+        console.print(f"  [bold]Status:[/]  Session is not imported")
+        return
+
+    sess = record.get("session", {})
+    imp = record.get("imported", {})
+    console.print(f"  [bold]Title:[/]       {sess.get('title', '—')}")
+    console.print(
+        f"  [bold]Exported by:[/] {record.get('exported_by', '?')} · "
+        f"{record.get('exported_at', '')[:10]}"
+    )
+    if sess.get("summary"):
+        console.print(f"  [bold]Summary:[/]     {sess['summary']}")
+    console.print()
+    console.print(
+        f"  [bold]Imported by:[/] {imp.get('user', '?')} · "
+        f"{imp.get('date', '')[:10]}"
+    )
+
+    console.print()
+
+    from anton.core.datasources.data_vault import LocalDataVault
+    connections = LocalDataVault().list_connections()
+    connected_ds = {f"{c['engine']}_{c['name']}".lower() for c in connections}
+
+    used_ds = set()
+    for entry in record.get("session", {}).get("conversation_history", []):
+        if not isinstance(entry, dict):
+            continue
+        for ds_name in (entry.get("meta") or {}).get("datasources") or []:
+            used_ds.add(ds_name)
+
+    if used_ds:
+        console.print("  [bold]Data sources[/]")
+        for ds_name in used_ds:
+            if ds_name in connected_ds:
+                mark = "[green]✓[/]"
+                note = "connected"
+            else:
+                mark = "[yellow]![/]"
+                note = "[anton.warning]not connected[/]"
+            console.print(f"    {mark}  {ds_name} · {note}")
+    else:
+        console.print("[anton.muted]  No data sources referenced in this session.[/]")
+
+    console.print()
+
+
+# ── history ──────────────────────────────────────────────────────────────────
+
+
+def handle_share_history(
+    console: Console,
+    workspace: "Workspace",
+) -> None:
+    output_dir = workspace.base / ".anton" / "output"
+
+    console.print()
+
+    files = []
+    if output_dir.exists():
+        files = sorted(output_dir.glob("*.anton"), key=lambda p: p.stat().st_mtime, reverse=True)
+
+    if not files:
+        console.print("[anton.muted]No exported sessions found.[/]")
+        console.print()
+        return
+
+    console.print(f"[bold]Exported sessions[/]  ({len(files)} files)")
+    console.print()
+
+    for p in files:
+        try:
+            data = json.loads(p.read_text(encoding="utf-8"))
+        except Exception:
+            console.print(f"  [anton.warning]{p.name}[/] — corrupted or unreadable")
+            console.print()
+            continue
+
+        sess = data.get("session", {})
+        imp = data.get("imported", {})
+
+        title = sess.get("title") or p.stem
+        summary = sess.get("summary", "")
+
+        if imp:
+            date = imp.get("date", "")[:16].replace("T", " ")
+            who = imp.get("user", "?")
+            label = f"imported by {who} · {date}"
+        else:
+            date = data.get("exported_at", "")[:16].replace("T", " ")
+            who = data.get("exported_by", "?")
+            label = f"exported by {who} · {date}"
+
+        console.print(f"  [bold]{title}[/]  [anton.muted]{label}[/]")
+        if summary:
+            short = summary[:120] + "…" if len(summary) > 120 else summary
+            console.print(f"  {short}")
+        console.print(f"  [anton.muted]→ {p}[/]")
+        console.print()
+
+
+# ── import ────────────────────────────────────────────────────────────────────
+
+
+async def import_v0_1(
+        console: Console,
+        session: "ChatSession",
+        workspace: "Workspace",
+        settings: "AntonSettings",
+        state: dict,
+        self_awareness,
+        cortex: "Cortex | None",
+        episodic: "EpisodicMemory | None",
+        history_store: "HistoryStore | None",
+        payload: dict,
+        *,
+        source_path: Path,
+) -> "ChatSession":
+    from anton.commands.session import restore_session
+    from anton.utils.prompt import prompt_or_cancel
+
+    # warn if active session
+    if session._history:
+        console.print(
+            "[anton.warning]You have an active session in progress. "
+            "Importing will create a new session — your current work is preserved in history.[/]"
+        )
+        console.print()
+        choice = await prompt_or_cancel(
+            "(anton) Continue?",
+            choices=["y", "n"],
+            choices_display="y/n",
+            default="n",
+        )
+        if choice is None or choice != "y":
+            console.print()
+            return session
+
+    raw_history = payload.get("session", {}).get("conversation_history", [])
+
+    # fill episodic from export
+    if episodic and episodic.enabled:
+        episodic.start_session()
+    new_session_id = episodic._session_id if (episodic and episodic.enabled) else None
+
+    from anton.core.memory.episodes import Episode
+    for ep_data in raw_history:
+        ep = Episode(**ep_data)
+        episodic.log(ep)
+
+    # reconstruct API history and save to history_store
+    from anton.memory.history_store import HistoryStore
+
+    api_history = HistoryStore.episodes_to_api_history(raw_history)
+    if history_store and new_session_id:
+        history_store.save(new_session_id, api_history)
+
+    # stamp imported metadata and persist file to output/
+    payload["imported"] = {
+        "user": getpass.getuser(),
+        "date": datetime.now(timezone.utc).isoformat(),
+        "session_id": new_session_id,
+    }
+    output_dir = workspace.base / ".anton" / "output"
+    output_dir.mkdir(parents=True, exist_ok=True)
+    dest = output_dir / source_path.name
+    dest.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+
+    # resume session (closes old scratchpads, rebuild_session, loads _history)
+    new_session, _ = await restore_session(
+        new_session_id, console, settings, state, self_awareness, cortex, workspace,
+        session, episodic, history_store,
+    )
+
+    session_born = payload.get("memory", {}).get("session_born", [])
+    project_accessed = payload.get("memory", {}).get("project_accessed", [])
+
+    # log memories to episodic
+    if episodic and episodic.enabled:
+        for m in session_born:
+            episodic.log_turn(0, "memory_write", m["content"],
+                              kind=m.get("kind", ""), topic=m.get("topic", ""))
+        for m in project_accessed:
+            episodic.log_turn(0, "memory_read", m["content"],
+                              kind=m.get("kind", ""), topic=m.get("topic", ""))
+
+    # restore memories to cortex
+    if cortex:
+        for m in session_born + project_accessed:
+            kind = m.get("kind", "")
+            content = m.get("content", "")
+            topic = m.get("topic", "")
+            if kind in ("always", "never", "when"):
+                cortex.project_hc.encode_rule(content, kind=kind, source="import")
+            elif kind == "lesson":
+                cortex.project_hc.encode_lesson(content, topic=topic, source="import")
+
+    # restore scratchpad cells
+    from anton.core.backends.base import Cell as _Cell  # noqa: PLC0415
+    cells_data = payload.get("scratchpad", {}).get("cells", [])
+    for cell_data in cells_data:
+        pad_name = cell_data.get("pad", "main")
+        pad = await new_session._scratchpads.get_or_create(pad_name)
+        pad.cells.append(_Cell(
+            code=cell_data.get("code", ""),
+            stdout=cell_data.get("stdout", ""),
+            stderr=cell_data.get("stderr", ""),
+            error=cell_data.get("error"),
+            description=cell_data.get("description", ""),
+        ))
+
+    # print briefing
+    sess = payload.get("session", {})
+    cells = payload.get("scratchpad", {}).get("cells", [])
+
+    console.print()
+    console.print(f"[bold][anton.cyan]Imported: {sess.get('title', 'Session')}[/][/]")
+    console.print(
+        f"  [bold]From:[/]    {payload.get('exported_by', '?')} · "
+        f"{payload.get('exported_at', '')[:10]}"
+    )
+    if sess.get("summary"):
+        console.print(f"  [bold]Summary:[/] {sess['summary']}")
+    if new_session._turn_count:
+        console.print(f"  [bold]Turns:[/]   {new_session._turn_count}")
+    if session_born or project_accessed:
+        console.print(
+            f"  [bold]Memory:[/]  {len(session_born)} session-born, "
+            f"{len(project_accessed)} project memories"
+        )
+    if cells:
+        console.print(f"  [bold]Code:[/]    {len(cells)} scratchpad cells")
+    console.print()
+    console.print("[anton.muted]Session restored. Continue where it left off.[/]")
+    console.print()
+
+    return new_session
+
+
+async def handle_share_import(
+    console: Console,
+    session: "ChatSession",
+    workspace: "Workspace",
+    settings: "AntonSettings",
+    state: dict,
+    self_awareness,
+    cortex: "Cortex | None",
+    episodic: "EpisodicMemory | None",
+    history_store: "HistoryStore | None",
+    filepath: str,
+) -> "ChatSession":
+
+    # parse & validate
+    path = Path(filepath).expanduser()
+    if not path.is_file():
+        console.print(f"[anton.warning]File not found: {filepath}[/]")
+        console.print()
+        return session
+
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        console.print("[anton.warning]Could not read file — may be corrupted.[/]")
+        console.print()
+        return session
+
+    version = payload.get("version")
+
+    importers = {
+        "0.1": import_v0_1
+    }
+
+    if version not in importers:
+        console.print(
+            f"[anton.warning]Unsupported version: {version}. Supported versions: {list(importers.keys())}.[/]"
+        )
+        console.print()
+        return session
+
+    return await importers[version](
+        console, session, workspace, settings, state, self_awareness, cortex,
+        episodic, history_store, payload,
+        source_path=path,
+    )
diff --git a/anton/commands/ui.py b/anton/commands/ui.py
index 27543e59..5f332088 100644
--- a/anton/commands/ui.py
+++ b/anton/commands/ui.py
@@ -40,6 +40,7 @@ class Command:
     "Chat Tools",
     Command("/paste",     "Attach an image from your clipboard"),
     Command("/resume",    "Continue a previous session"),
+    Command("/share",     "Share sessions: export / import / status / history"),
     Command("/publish",   "Publish an HTML report to the web"),
     Command("/unpublish", "Remove a published report"),
     Command("/explain",   "Show explainability details for the latest answer"),
@@ -61,6 +62,14 @@ class Command:
     Command("/skill remove <label>")
 ]
 
+SHARE_COMMANDS = [
+    Command("/share export"),
+    Command("/share export --summary"),
+    Command("/share import"),
+    Command("/share status"),
+    Command("/share history"),
+]
+
 
 def handle_theme(console: Console, arg: str) -> None:
     """Switch the color theme (light/dark)."""
diff --git a/anton/core/memory/cortex.py b/anton/core/memory/cortex.py
index a3e75500..fa8df0ed 100644
--- a/anton/core/memory/cortex.py
+++ b/anton/core/memory/cortex.py
@@ -30,6 +30,7 @@
 
 if TYPE_CHECKING:
     from anton.core.llm.client import LLMClient
+    from anton.core.memory.episodes import EpisodicMemory
 
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -114,6 +115,7 @@ def __init__(
         project_hc: HippocampusProtocol,
         mode: str = "autopilot",
         llm_client: LLMClient | None = None,
+        episodic: EpisodicMemory | None = None,
     ) -> None:
         """Initialize the executive with two hippocampal stores.
 
@@ -122,11 +124,14 @@ def __init__(
             project_hc: Memory store for project-specific memories
             mode: Memory mode — autopilot|copilot|off (encoding gate)
             llm_client: For LLM-assisted operations (profile extraction, compaction)
+            episodic: For logging memory_read/memory_write events per session
         """
         self.global_hc = global_hc
         self.project_hc = project_hc
         self.mode = mode
         self._llm = llm_client
+        self._episodic = episodic
+        self._seen_texts: set[str] = set()
         self._turn_count = 0
 
         # One-time migration: identity is singular and global. Any entries that
@@ -181,22 +186,24 @@ async def build_memory_context(self, user_message: str = "") -> str:
             sections.append(f"## Your Memory — Identity\n{identity}")
 
         # 2. Global rules (with smart retrieval)
-        global_rules = self.global_hc.recall_rules()
-        if global_rules:
-            global_rules = await self._retrieve_relevant_rules(
-                global_rules, user_message
-            )
-            if global_rules:
-                sections.append(f"## Your Memory — Global Rules\n{global_rules}")
+        global_engrams = self.global_hc.get_rules()
+        if global_engrams:
+            global_engrams = await self._retrieve_relevant_rules(global_engrams, user_message)
+            if global_engrams:
+                sections.append(
+                    f"## Your Memory — Global Rules\n{self._format_rules_engrams(global_engrams)}"
+                )
 
         # 3. Project rules (with smart retrieval)
-        project_rules = self.project_hc.recall_rules()
-        if project_rules:
-            project_rules = await self._retrieve_relevant_rules(
-                project_rules, user_message
-            )
-            if project_rules:
-                sections.append(f"## Your Memory — Project Rules\n{project_rules}")
+        project_engrams = self.project_hc.get_rules()
+        if project_engrams:
+            project_engrams = await self._retrieve_relevant_rules(project_engrams, user_message)
+            if project_engrams:
+                sections.append(
+                    f"## Your Memory — Project Rules\n{self._format_rules_engrams(project_engrams)}"
+                )
+                for engram in project_engrams:
+                    self._log_read_engram(engram)
 
         # 4. Global lessons
         global_lessons = self.global_hc.recall_lessons(token_budget=1000)
@@ -207,6 +214,9 @@ async def build_memory_context(self, user_message: str = "") -> str:
         project_lessons = self.project_hc.recall_lessons(token_budget=1000)
         if project_lessons:
             sections.append(f"## Your Memory — Project Lessons\n{project_lessons}")
+            if self._episodic is not None:
+                for engram in self.project_hc.get_lessons(token_budget=1000):
+                    self._log_read_engram(engram)
 
         # 6. Minds datasource context (auto-loaded if present)
         minds_topic = self.project_hc.recall_topic("minds-datasource")
@@ -218,8 +228,24 @@ async def build_memory_context(self, user_message: str = "") -> str:
 
         return "\n\n" + "\n\n".join(sections)
 
-    async def _retrieve_relevant_rules(self, all_rules: str, user_message: str) -> str:
-        """Filter rules to only those relevant to the current user message.
+    @staticmethod
+    def _format_rules_engrams(engrams: list[Engram]) -> str:
+        """Format rule engrams to section display format (## Always / Never / When)."""
+        by_kind: dict[str, list[Engram]] = {}
+        for e in engrams:
+            by_kind.setdefault((e.kind or "always").lower(), []).append(e)
+        parts: list[str] = []
+        for section in ("always", "never", "when"):
+            items = by_kind.get(section, [])
+            if items:
+                parts.append(f"## {section.capitalize()}")
+                parts.extend(f"- {e.text}" for e in items)
+        return "\n".join(parts)
+
+    async def _retrieve_relevant_rules(
+        self, engrams: list[Engram], user_message: str
+    ) -> list[Engram]:
+        """Filter rule engrams to those relevant to the current user message.
 
         Brain analog: dlPFC cue-dependent recall — the prefrontal cortex
         selects which memories to activate based on current goals, rather
@@ -230,41 +256,21 @@ async def _retrieve_relevant_rules(self, all_rules: str, user_message: str) -> s
         If rules are under budget or no LLM is available, returns as-is.
         """
         if not user_message or self._llm is None:
-            return all_rules
-        if len(all_rules) <= self._RULES_BUDGET_CHARS:
-            return all_rules
-
-        # Split rules into mandatory (Always/Never) and filterable (When)
-        lines = all_rules.splitlines()
-        mandatory_lines: list[str] = []
-        when_lines: list[str] = []
-        current_section = ""
-
-        for line in lines:
-            stripped = line.strip()
-            if stripped.startswith("## Always"):
-                current_section = "always"
-                mandatory_lines.append(line)
-            elif stripped.startswith("## Never"):
-                current_section = "never"
-                mandatory_lines.append(line)
-            elif stripped.startswith("## When"):
-                current_section = "when"
-                mandatory_lines.append(line)  # keep the header
-            elif stripped.startswith("## ") or stripped.startswith("# "):
-                current_section = ""
-                mandatory_lines.append(line)
-            elif current_section == "when":
-                when_lines.append(line)
-            else:
-                mandatory_lines.append(line)
+            return engrams
+
+        if len(self._format_rules_engrams(engrams)) <= self._RULES_BUDGET_CHARS:
+            return engrams
 
-        # If When section is small, no need to filter
-        when_text = "\n".join(when_lines).strip()
-        if not when_text or len(when_text) < 1000:
-            return all_rules
+        mandatory = [e for e in engrams if (e.kind or "").lower() in ("always", "never")]
+        when_engrams = [e for e in engrams if (e.kind or "").lower() == "when"]
+
+        if not when_engrams:
+            return engrams
+
+        when_text = "\n".join(f"- {e.text}" for e in when_engrams)
+        if len(when_text) < 1000:
+            return engrams
 
-        # Filter only the When rules
         try:
             response = await self._llm.code(
                 system=self._RULES_RETRIEVAL_PROMPT,
@@ -278,19 +284,18 @@ async def _retrieve_relevant_rules(self, all_rules: str, user_message: str) -> s
             )
             result = response.content.strip()
             if result.upper() == "NONE":
-                filtered_when = ""
-            elif result:
-                filtered_when = result
+                return mandatory
+            if result:
+                returned = {line.lstrip("- ").strip() for line in result.splitlines() if line.strip()}
+                filtered_when = [e for e in when_engrams if e.text in returned]
+                if not filtered_when:
+                    filtered_when = when_engrams
             else:
-                filtered_when = when_text
+                filtered_when = when_engrams
         except Exception:
-            filtered_when = when_text
+            filtered_when = when_engrams
 
-        # Reassemble: mandatory sections + filtered When rules
-        output = "\n".join(mandatory_lines)
-        if filtered_when:
-            output += "\n" + filtered_when
-        return output
+        return mandatory + filtered_when
 
     def get_scratchpad_context(self) -> str:
         """Retrieve procedural knowledge for scratchpad tool injection.
@@ -338,6 +343,8 @@ async def encode(self, engrams: list[Engram]) -> list[str]:
                     confidence=engram.confidence,
                     source=engram.source,
                 )
+                if engram.scope != "global":
+                    self._log_write_engram(engram)
                 actions.append(f"Encoded {engram.kind} rule: {engram.text}")
 
             elif engram.kind == "lesson":
@@ -346,10 +353,32 @@ async def encode(self, engrams: list[Engram]) -> list[str]:
                     topic=engram.topic,
                     source=engram.source,
                 )
+                if engram.scope != "global":
+                    self._log_write_engram(engram)
                 actions.append(f"Encoded lesson: {engram.text}")
 
         return actions
 
+    def _log_write_engram(self, engram: Engram) -> None:
+        if self._episodic is None:
+            return
+        self._seen_texts.add(engram.text)
+        self._episodic.log_turn(
+            0, "memory_write", engram.text,
+            kind=engram.kind or "lesson",
+            topic=engram.topic or "",
+        )
+
+    def _log_read_engram(self, engram: Engram) -> None:
+        if self._episodic is None or engram.text in self._seen_texts:
+            return
+        self._seen_texts.add(engram.text)
+        self._episodic.log_turn(
+            0, "memory_read", engram.text,
+            kind=engram.kind or "lesson",
+            topic=engram.topic or "",
+        )
+
     def encoding_gate(self, engram: Engram) -> bool:
         """Whether this engram needs user confirmation before encoding.
 
diff --git a/anton/core/memory/episodes.py b/anton/core/memory/episodes.py
index 54e067a2..5bb1089d 100644
--- a/anton/core/memory/episodes.py
+++ b/anton/core/memory/episodes.py
@@ -24,9 +24,6 @@ class Episode:
     meta: dict = field(default_factory=dict)
 
 
-_MAX_TOOL_INPUT = 2000
-_MAX_TOOL_RESULT = 2000
-
 
 class EpisodicMemory:
     """Append-only conversation archive stored as per-session JSONL files."""
@@ -50,13 +47,16 @@ def enabled(self) -> bool:
     def enabled(self, value: bool) -> None:
         self._enabled = value
 
+    @property
+    def session_id(self) -> str | None:
+        return self._session_id
+
     def start_session(self) -> str:
         """Create a new JSONL file for this session and return the session ID."""
         now = datetime.now(timezone.utc)
         self._session_id = now.strftime("%Y%m%d_%H%M%S")
         self._dir.mkdir(parents=True, exist_ok=True)
         self._file = self._dir / f"{self._session_id}.jsonl"
-        self._file.touch()
         return self._session_id
 
     def resume_session(self, session_id: str) -> str:
@@ -64,8 +64,6 @@ def resume_session(self, session_id: str) -> str:
         self._session_id = session_id
         self._dir.mkdir(parents=True, exist_ok=True)
         self._file = self._dir / f"{self._session_id}.jsonl"
-        if not self._file.exists():
-            self._file.touch()
         return self._session_id
 
     def log(self, episode: Episode) -> None:
@@ -98,12 +96,6 @@ def log_turn(
         """Convenience wrapper around log()."""
         if not self._enabled or self._session_id is None:
             return
-        # Truncate tool content
-        if role == "tool_call":
-            content = content[:_MAX_TOOL_INPUT]
-        elif role == "tool_result":
-            content = content[:_MAX_TOOL_RESULT]
-
         self.log(
             Episode(
                 ts=datetime.now(timezone.utc).isoformat(),
@@ -161,13 +153,16 @@ def recall(
             except Exception:
                 continue
 
-            # Parse all episodes in this file for context lookups
+            # Parse all episodes in this file for context lookups.
+            # memory_read/memory_write are system events, not conversation turns.
             all_episodes: list[Episode] = []
             for line in lines:
                 if not line.strip():
                     continue
                 try:
-                    all_episodes.append(Episode(**json.loads(line)))
+                    ep = Episode(**json.loads(line))
+                    if ep.role not in ("memory_read", "memory_write"):
+                        all_episodes.append(ep)
                 except Exception:
                     continue
 
@@ -209,25 +204,33 @@ def recall(
 
         return matches
 
-    def get_episodes(self) -> list[Episode]:
-        """Return all episodes across all sessions, newest-first."""
-        if not self._dir.is_dir():
-            return []
-        result = []
-        for path in sorted(self._dir.glob("*.jsonl"), reverse=True):
+    def get_conversation(self) -> list[Episode]:
+        """Yield conversation episodes for the current session (excludes memory entries)."""
+        for ep in self.get_items():
+            if ep.role not in ["memory_write", "memory_read"]:
+                yield ep
+
+    def del_episode_entry(self, turn: int) -> bool:
+        """Remove all episode lines for *turn* from the current session file."""
+        if self._file is None or not self._file.is_file():
+            return False
+        kept = []
+        removed = 0
+        for line in self._file.read_text(encoding="utf-8").splitlines(keepends=True):
+            if not line.strip():
+                kept.append(line)
+                continue
             try:
-                for line in path.read_text(encoding="utf-8").splitlines():
-                    if line.strip():
-                        result.append(Episode(**json.loads(line)))
+                ep = Episode(**json.loads(line))
+                if ep.turn == turn:
+                    removed += 1
+                    continue
             except Exception:
-                continue
-        return result
-
-    def del_episode(self, session_id: str) -> bool:
-        path = self._dir / f"{session_id}.jsonl"
-        if not path.is_file():
+                pass
+            kept.append(line)
+        if removed == 0:
             return False
-        path.unlink()
+        self._file.write_text("".join(kept), encoding="utf-8")
         return True
 
     def recall_formatted(
@@ -241,13 +244,55 @@ def recall_formatted(
             return f"No episodes found matching '{query}'."
         lines: list[str] = []
         for ep in episodes:
-            # Show more content for assistant/scratchpad responses
             max_len = (
-                2000 if ep.role in ("assistant", "scratchpad", "tool_result") else 500
+                2000 if ep.role in ("assistant", "scratchpad", "tool_result", "tool_call") else 500
             )
             lines.append(f"[{ep.ts}] ({ep.role}) {ep.content[:max_len]}")
         return "\n".join(lines)
 
+    def get_items(
+        self,
+    ) -> list[Episode]:
+        """Return episodes for a session filtered by role, deduplicated by content.
+
+        Used by /share export to collect the memory payload for a session.
+        """
+        if not self._dir.is_dir():
+            return []
+        path = self._dir / f"{self._session_id}.jsonl"
+        if not path.is_file():
+            return []
+        result: list[Episode] = []
+        try:
+            for line in path.read_text(encoding="utf-8").splitlines():
+                if not line.strip():
+                    continue
+                try:
+                    result.append(Episode(**json.loads(line)))
+                except Exception:
+                    continue
+        except Exception:
+            pass
+        return result
+
+    def get_memory_usage(
+        self,
+    ) -> list[Episode]:
+        """Return episodes for a session filtered by role, deduplicated by content.
+
+        Used by /share export to collect the memory payload for a session.
+        """
+        seen: set[str] = set()
+        result: list[Episode] = []
+        for ep in self.get_items():
+            if ep.role not in ["memory_write", "memory_read"]:
+                continue
+            if ep.content in seen:
+                continue
+            seen.add(ep.content)
+            result.append(ep)
+        return result
+
     def session_count(self) -> int:
         """Count the number of session files."""
         if not self._dir.is_dir():
diff --git a/anton/core/session.py b/anton/core/session.py
index 49192d98..ad38927c 100644
--- a/anton/core/session.py
+++ b/anton/core/session.py
@@ -4,7 +4,8 @@
 from collections.abc import AsyncIterator, Callable
 from dataclasses import asdict, dataclass, field
 import json
-from typing import TYPE_CHECKING
+import re
+from typing import TYPE_CHECKING, List
 
 from anton.core.backends.base import Cell, ScratchpadRuntimeFactory
 from anton.core.backends.local import local_scratchpad_runtime_factory
@@ -23,6 +24,7 @@
     StreamTextDelta,
     StreamToolResult,
     TokenLimitExceeded,
+    ToolCall,
 )
 from anton.core.backends.manager import ScratchpadManager
 from anton.core.tools.registry import ToolRegistry
@@ -54,6 +56,19 @@
     from anton.workspace import Workspace
 
 
+def _extract_datasources(tool_call: ToolCall) -> List[str]:
+    """Return unique datasource slugs referenced in scratchpad code via DS_*__ env vars."""
+    if tool_call.name != "scratchpad":
+        return []
+    code = tool_call.input.get("code", "") if isinstance(tool_call.input, dict) else ""
+    if not code:
+        return []
+    seen = set()
+
+    for m in re.compile(r"\bDS_([A-Z0-9_]+?)__").finditer(code):
+        seen.add(m.group(1).lower())
+    return list(seen)
+
 @dataclass
 class ChatSessionConfig:
     """All construction parameters for a ChatSession.
@@ -909,7 +924,17 @@ async def turn_stream(
         self._persist_history()
         if self._cortex is not None and self._cortex.mode != "off":
             if self._turn_count % 5 == 0 and isinstance(user_input, str):
-                asyncio.create_task(self._cortex.maybe_update_identity(user_input))
+                if self._episodic:
+                    user_messages =[
+                        ep.content
+                        for ep in self._episodic.get_conversation()
+                        if ep.role == "user"
+                    ]
+                    messages_str = "\n\n".join(user_messages[-5:])
+                else:
+                    messages_str = user_input
+
+                asyncio.create_task(self._cortex.maybe_update_identity(messages_str))
             # Periodic memory vacuum (Systems Consolidation)
             self._cortex.maybe_vacuum()
 
@@ -1042,8 +1067,9 @@ async def _stream_and_handle_tools(
                         self._episodic.log_turn(
                             self._turn_count + 1,
                             "tool_call",
-                            str(tc.input)[:2000],
+                            str(tc.input),
                             tool=tc.name,
+                            datasources=_extract_datasources(tc)
                         )
 
                     _tool_t0 = _time.monotonic()
@@ -1113,7 +1139,7 @@ async def _stream_and_handle_tools(
                                     self._episodic.log_turn(
                                         self._turn_count + 1,
                                         "scratchpad",
-                                        (cell.stdout or "")[:2000],
+                                        (cell.stdout or ""),
                                         description=description,
                                     )
                         elif tc.name == "connect_new_datasource" or (
@@ -1168,7 +1194,7 @@ async def _stream_and_handle_tools(
                         self._episodic.log_turn(
                             self._turn_count + 1,
                             "tool_result",
-                            result_text[:2000],
+                            result_text,
                             tool=tc.name,
                         )
                     result_text = scrub_credentials(result_text)
diff --git a/anton/memory/history_store.py b/anton/memory/history_store.py
index 2f68e551..13c58efc 100644
--- a/anton/memory/history_store.py
+++ b/anton/memory/history_store.py
@@ -6,12 +6,19 @@
 
 from __future__ import annotations
 
+import ast
 import json
 import os
 import tempfile
+import uuid
 from datetime import datetime, timezone
 from pathlib import Path
 
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from anton.core.memory.episodes import EpisodicMemory
+
 
 class HistoryStore:
     """Persist and retrieve full chat history for session resume."""
@@ -56,6 +63,79 @@ def load(self, session_id: str) -> list[dict] | None:
         except Exception:
             return None
 
+    @staticmethod
+    def episodes_to_api_history(episodes: list[dict]) -> list[dict]:
+        """Convert episodic episode list to Anthropic API message format for HistoryStore.
+
+        Processes episodes sequentially:
+          user -> {"role":"user","content":text}
+          tool_call -> {"role":"assistant","content":[tool_use block]}  (generates id)
+          scratchpad -> skipped (content captured in tool_result)
+          tool_result -> {"role":"user","content":[tool_result block]}  (uses id from preceding tool_call)
+          assistant -> {"role":"assistant","content":text}
+        """
+        history: list[dict] = []
+        i = 0
+        while i < len(episodes):
+            ep = episodes[i]
+            role = ep.get("role", "")
+
+            if role == "user":
+                history.append({"role": "user", "content": ep["content"]})
+                i += 1
+
+            elif role == "tool_call":
+                tool_id = f"toolu_{uuid.uuid4().hex[:24]}"
+                tool_name = ep.get("meta", {}).get("tool", "unknown")
+                content_str = ep.get("content", "{}")
+                try:
+                    tool_input = json.loads(content_str)
+                except Exception:
+                    try:
+                        tool_input = ast.literal_eval(content_str)
+                    except Exception:
+                        tool_input = {"raw": content_str}
+
+                history.append({
+                    "role": "assistant",
+                    "content": [{"type": "tool_use", "id": tool_id, "name": tool_name, "input": tool_input}],
+                })
+                i += 1
+
+                # Skip optional scratchpad episode
+                if i < len(episodes) and episodes[i].get("role") == "scratchpad":
+                    i += 1
+
+                # Consume matching tool_result
+                if i < len(episodes) and episodes[i].get("role") == "tool_result":
+                    history.append({
+                        "role": "user",
+                        "content": [{"type": "tool_result", "tool_use_id": tool_id, "content": episodes[i]["content"]}],
+                    })
+                    i += 1
+
+            elif role == "assistant":
+                history.append({"role": "assistant", "content": ep["content"]})
+                i += 1
+
+            else:
+                i += 1
+
+        return history
+
+    def rebuild_from_episodic(self, episodic: "EpisodicMemory") -> list[dict]:
+        """Rebuild and persist API history from current episodic session.
+
+        Reads episodes via get_conversation(), converts to API format,
+        saves to HistoryStore, and returns the result.
+        """
+        from dataclasses import asdict
+        episodes = [asdict(ep) for ep in episodic.get_conversation()]
+        history = self.episodes_to_api_history(episodes)
+        if episodic.session_id:
+            self.save(episodic.session_id, history)
+        return history
+
     def list_sessions(self, limit: int = 20) -> list[dict]:
         """List recent sessions with history, newest-first.
 
diff --git a/anton/memory/manage.py b/anton/memory/manage.py
index 9a234043..c854507a 100644
--- a/anton/memory/manage.py
+++ b/anton/memory/manage.py
@@ -1,12 +1,10 @@
 from __future__ import annotations
 
-import os
-import subprocess
+from collections import defaultdict
 from pathlib import Path
 
-from prompt_toolkit import PromptSession
-
 from rich.console import Console
+from rich.table import Table
 
 from anton.utils.prompt import prompt_or_cancel
 from anton.config.settings import AntonSettings
@@ -36,7 +34,7 @@
     Command("/memory identity edit <n>", "edit identity entry #n"),
     None,
     Command("/memory episodes", "show episodic sessions"),
-    Command("/memory episodes delete <n>", "delete session #n"),
+    Command("/memory episodes delete <n>", "delete turn #n"),
     None,
     'Maintenance',
     Command("/memory vacuum", "deduplicate and compact"),
@@ -105,11 +103,14 @@ def __init__(
         settings: AntonSettings,
         cortex: "Cortex | None",
         episodic: "EpisodicMemory | None" = None,
+        history_store: "HistoryStore | None" = None,
     ) -> None:
         self.console = console
         self.settings = settings
         self.cortex = cortex
         self.episodic = episodic
+        self.history_store = history_store
+        self.session = None
 
         self.SUBCOMMANDS: dict[str, object] = {
             "help":        self.help,
@@ -125,10 +126,12 @@ def __init__(
     # Entry point
     # ------------------------------------------------------------------
 
-    async def handle(self, cmd: str) -> None:
+    async def handle(self, cmd: str, session) -> None:
         """Dispatch /memory [sub-command] or show the status dashboard."""
         sub_cmd = cmd.removeprefix("/memory").strip()
         parts = sub_cmd.split()
+        # session might be changed
+        self.session = session
 
         if len(parts) == 0:
             return self.info()
@@ -292,45 +295,52 @@ async def episodes(self, action: str = None, num: str = None) -> None:
             self.console.print("[anton.warning]Episodic memory not initialized.[/]")
             return
 
-        items = dict(enumerate(self.episodic.get_episodes(), start=1))
+        turns = defaultdict(dict)
+        for ep in self.episodic.get_conversation():
+            turns[ep.turn][ep.role] = ep.content
 
-        if action is not None:
-            nums = list(items.keys())
+        if not turns:
+            self.console.print("(no items)")
+            return
 
-            if not nums:
-                return self.console.print("Nothing to act on — no episodes.")
+        if action is not None:
+            nums = list(turns.keys())
 
             if num is None:
                 return self.console.print(f"Choose item to {action}: {min(nums)}-{max(nums)}")
 
             if num.isdigit():
                 num = int(num)
-            if num not in items:
+            if num not in turns:
                 return self.console.print(f"Item {num} not found, choose number between {min(nums)} and {max(nums)}")
 
             if action == 'delete':
-                session_id = items[num].session
-                self.episodic.del_episode(session_id)
-                self.console.print("[anton.cyan]Deleted[/]")
+                if self.episodic.del_episode_entry(num):
+                    if self.history_store:
+                        new_history = self.history_store.rebuild_from_episodic(self.episodic)
+                        if self.session is not None:
+                            self.session._history[:] = new_history
+                    self.console.print("[anton.cyan]Deleted[/]")
                 return await self.episodes()
             else:
                 return self.console.print(f"Unknown action: {action}")
 
         self._print_title("Episodic Memory")
-        max_shown_items = 50
-        if len(items) > max_shown_items:
-            # keep only last items
-            items = dict(sorted(items.items())[-max_shown_items:])
-            self.console.print(f"Only the last {max_shown_items} are shown:")
-        if len(items) == 0:
-            print("(no items)")
-        for i, item in items.items():
-            content = item.content.replace('\n', ' ')
-            if len(content) > 100:
-                content = content[:97] + "..."
-            self.console.print(f"    [dim]{i:>3}.[/]  {content}")
-
-        self.console.print("  [bold]/memory episodes delete <n>[/]  — delete session #n")
+
+        table = Table(show_header=True, header_style="bold", box=None, padding=(0, 1))
+        table.add_column("turn", justify="right", no_wrap=True)
+        table.add_column("question")
+        table.add_column("answer")
+
+        for turn, data in turns.items():
+            q = data.get("user", "").replace('\n', ' ')
+            a = data.get("assistant", "").replace('\n', ' ')
+            q_short = (q[:60] + "...") if len(q) > 63 else q
+            a_short = (a[:60] + "...") if len(a) > 63 else a
+            table.add_row(str(turn), q_short, a_short)
+
+        self.console.print(table)
+        self.console.print("  [bold]/memory episodes delete <n>[/]  — delete turn #n")
 
     async def vacuum(self):
         toggle = await prompt_or_cancel(
diff --git a/tests/test_episodes.py b/tests/test_episodes.py
index 977a45c7..dff3f61a 100644
--- a/tests/test_episodes.py
+++ b/tests/test_episodes.py
@@ -25,6 +25,7 @@ def em(episodes_dir: Path) -> EpisodicMemory:
 class TestStartSession:
     def test_creates_file(self, em: EpisodicMemory, episodes_dir: Path):
         sid = em.start_session()
+        em.log_turn(1, "user", "hello")
         assert (episodes_dir / f"{sid}.jsonl").exists()
 
     def test_filename_format(self, em: EpisodicMemory):
@@ -119,9 +120,8 @@ def test_noop_when_disabled(self, episodes_dir: Path):
             role="user",
             content="should not appear",
         ))
-        # File should exist but be empty (only created by start_session touch)
         path = episodes_dir / f"{sid}.jsonl"
-        assert path.read_text() == ""
+        assert not path.exists()
 
 class TestLogTurn:
     def test_convenience_method(self, em: EpisodicMemory, episodes_dir: Path):
@@ -141,20 +141,24 @@ def test_kwargs_as_meta(self, em: EpisodicMemory, episodes_dir: Path):
         assert data["meta"]["tool"] == "scratchpad"
 
     def test_tool_call_truncation(self, em: EpisodicMemory, episodes_dir: Path):
-        sid = em.start_session()
+        em.start_session()
         long_content = "x" * 5000
         em.log_turn(1, "tool_call", long_content)
-        path = episodes_dir / f"{sid}.jsonl"
-        data = json.loads(path.read_text().strip())
-        assert len(data["content"]) == 2000
+        result = em.recall_formatted("x" * 10)
+        # full content stored, but recall_formatted truncates to 2000
+        line = result.splitlines()[0]
+        content_part = line.split(") ", 1)[1]
+        assert len(content_part) == 2000
 
     def test_tool_result_truncation(self, em: EpisodicMemory, episodes_dir: Path):
-        sid = em.start_session()
+        em.start_session()
         long_content = "x" * 5000
         em.log_turn(1, "tool_result", long_content)
-        path = episodes_dir / f"{sid}.jsonl"
-        data = json.loads(path.read_text().strip())
-        assert len(data["content"]) == 2000
+        result = em.recall_formatted("x" * 10)
+        line = result.splitlines()[0]
+        content_part = line.split(") ", 1)[1]
+        assert len(content_part) == 2000
+
 
 class TestRecall:
     def _populate(self, em: EpisodicMemory, messages: list[str]) -> str:
@@ -259,6 +263,7 @@ def test_includes_timestamps(self, em: EpisodicMemory):
 class TestSessionCount:
     def test_counts_files(self, em: EpisodicMemory):
         em.start_session()
+        em.log_turn(1, "user", "hello")
         # Create additional fake session files
         em._dir.mkdir(parents=True, exist_ok=True)
         (em._dir / "20260101_120000.jsonl").touch()
@@ -275,9 +280,8 @@ def test_log_noop(self, episodes_dir: Path):
         em = EpisodicMemory(episodes_dir, enabled=False)
         em.start_session()
         em.log_turn(1, "user", "should not log")
-        # File should be empty
         path = em._file
-        assert path.read_text() == ""
+        assert not path.exists()
 
     def test_recall_empty(self, episodes_dir: Path):
         em = EpisodicMemory(episodes_dir, enabled=False)
diff --git a/tests/test_share.py b/tests/test_share.py
new file mode 100644
index 00000000..bf747c6a
--- /dev/null
+++ b/tests/test_share.py
@@ -0,0 +1,260 @@
+"""Comprehensive export → import roundtrip tests for /share command.
+
+Flow under test:
+  1. Build a session with conversation history, memory entries, scratchpad cells.
+  2. Export via handle_share_export → .anton file.
+  3. Verify .anton file structure and content.
+  4. Import via handle_share_import → new session.
+  5. Compare state before and after, noting expected differences.
+
+Expected differences after roundtrip:
+  - session._session_id  : new ID (import always creates a fresh session)
+  - system_prompt_context: new session has provenance suffix; original had none
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from rich.console import Console
+
+
+class RecordingConsole:
+    """Minimal console stub that captures print() calls for test assertions."""
+
+    def __init__(self):
+        self._lines: list[str] = []
+
+    def print(self, *args, **kwargs):
+        self._lines.append(" ".join(str(a) for a in args))
+
+    def getvalue(self) -> str:
+        return "\n".join(self._lines)
+
+from anton.commands.share import handle_share_export, handle_share_import, handle_share_status, handle_share_history
+from anton.core.backends.base import Cell
+from anton.core.backends.manager import ScratchpadManager
+from anton.core.memory.cortex import Cortex
+from anton.core.memory.episodes import EpisodicMemory
+from anton.core.memory.hippocampus import Hippocampus
+from anton.core.session import ChatSession, ChatSessionConfig
+from anton.memory.history_store import HistoryStore
+from tests.conftest import make_mock_llm
+
+
+# ── fixtures ──────────────────────────────────────────────────────────────────
+
+
+
+@pytest.fixture()
+def workspace(tmp_path: Path):
+    return MagicMock(base=tmp_path)
+
+
+# Canonical conversation used throughout the tests
+HISTORY = [
+    {"role": "user",      "content": "What is the revenue breakdown by region?"},
+    {"role": "assistant", "content": "Let me query that for you."},
+    {"role": "user",      "content": "Can you also show the YoY change?"},
+    {"role": "assistant", "content": "Sure, here is the YoY comparison."},
+]
+
+SESSION_BORN_MEMORY  = {"content": "Always use CTEs for readability", "kind": "lesson", "topic": "sql"}
+PROJECT_MEMORY       = {"content": "Never use SELECT * in production",  "kind": "never",  "topic": ""}
+SCRATCHPAD_CELL      = Cell(code="df.head()", stdout="   col1\n0  1\n", stderr="", error=None, description="Preview data")
+
+
+def _build_session(
+    tmp_path: Path,
+    workspace
+) -> tuple[ChatSession, EpisodicMemory, str]:
+    """Return (session, episodic, session_id) ready for export."""
+    episodes_dir = tmp_path / "episodes"
+    episodic = EpisodicMemory(episodes_dir)
+    sid = episodic.start_session()
+
+    # log conversation turns to episodic (mirrors what session.py does during turn())
+    turn = 0
+    for msg in HISTORY:
+        role = msg["role"]
+        if role == "user":
+            turn += 1
+        episodic.log_turn(turn, role, msg["content"])
+
+    # log memories that the export should pick up
+    episodic.log_turn(0, "memory_write", **SESSION_BORN_MEMORY)
+    episodic.log_turn(0, "memory_read",  **PROJECT_MEMORY)
+
+    mock_llm = make_mock_llm()
+    session = ChatSession(ChatSessionConfig(
+        llm_client=mock_llm,
+        session_id=sid,
+        episodic=episodic,
+        workspace=workspace,
+    ))
+    session._history = list(HISTORY)
+    session._turn_count = sum(1 for m in HISTORY if m.get("role") == "user")
+
+    # wire a fake scratchpad runtime with one cell
+    mock_runtime = MagicMock()
+    mock_runtime.cells = [SCRATCHPAD_CELL]
+    session._scratchpads._pads = {"main": mock_runtime}
+
+    return session, episodic, sid
+
+
+
+async def _do_import(
+    tmp_path: Path,
+    console,
+    workspace,
+    anton_file: Path,
+    *,
+    current_history: list[dict] | None = None,
+    cortex=None,
+) -> tuple[ChatSession, EpisodicMemory]:
+    """Run handle_share_import and return (new_session, new_episodic).
+
+    get_or_create is mocked so no real venv subprocess is started.
+    Pad runtimes are injected into session._scratchpads._pads so callers
+    can inspect restored cells via result._scratchpads._pads[name].cells.
+    """
+    mock_llm = make_mock_llm()
+
+    # episodic for the new session (recipient side)
+    new_episodic = EpisodicMemory(tmp_path / "new_episodes")
+    history_store = HistoryStore(tmp_path / "new_episodes")
+
+    # empty current session (no active history unless specified)
+    current_session = ChatSession(ChatSessionConfig(
+        llm_client=mock_llm,
+        workspace=workspace,
+    ))
+    if current_history:
+        current_session._history = list(current_history)
+
+    # pre-build the session that rebuild_session will return.
+    # Uses the session_id already set by handle_share_import's start_session() call.
+    def _fake_rebuild(**kwargs):
+        return ChatSession(ChatSessionConfig(
+            llm_client=mock_llm,
+            session_id=kwargs.get("session_id"),
+            episodic=new_episodic,
+            workspace=workspace,
+        ))
+
+    # Mock get_or_create so no real venv is started.
+    # The mock sets _pads[name] so callers can inspect cells afterward.
+    async def _mock_get_or_create(mgr_self, name):
+        if name not in mgr_self._pads:
+            rt = MagicMock()
+            rt.cells = []
+            mgr_self._pads[name] = rt
+        return mgr_self._pads[name]
+
+    with patch.object(ScratchpadManager, "get_or_create", _mock_get_or_create):
+        with patch("anton.commands.session.rebuild_session", side_effect=_fake_rebuild):
+            new_session = await handle_share_import(
+                console,
+                current_session,
+                workspace,
+                MagicMock(),              # settings
+                {"llm_client": mock_llm}, # state
+                None,                     # self_awareness
+                cortex,
+                new_episodic,
+                history_store,
+                filepath=str(anton_file),
+            )
+
+    return new_session, new_episodic
+
+
+class TestShareRoundtrip:
+    async def test_full_roundtrip(self, tmp_path, workspace):
+        """Export a live session, import it, compare state point by point."""
+        console = RecordingConsole()
+
+        # ── 1. build exporter session ──────────────────────────────────────
+        session, episodic, original_sid = _build_session(tmp_path, workspace)
+        mock_llm = make_mock_llm()
+
+        with patch("anton.commands.share._generate_meta",
+                   AsyncMock(return_value=("revenue-region-yoy", "Analyzed revenue. APAC leads YoY."))):
+            await handle_share_export(console, session, workspace, mock_llm, episodic)
+
+        output_dir = tmp_path / ".anton" / "output"
+        anton_file = next(output_dir.glob("*.anton"))
+        payload = json.loads(anton_file.read_text())
+
+        # ── 2. import into fresh session ───────────────────────────────────
+        cortex = Cortex(
+            global_hc=Hippocampus(tmp_path / "global_memory"),
+            project_hc=Hippocampus(tmp_path / "project_memory"),
+        )
+
+        new_session, new_episodic = await _do_import(
+            tmp_path, console, workspace, anton_file,
+            cortex=cortex,
+        )
+
+        # ── 3. compare ─────────────────────────────────────────────────────
+
+        # conversation history: EQUAL
+        assert new_session._history == HISTORY, "Conversation history must be fully preserved"
+        assert new_session._turn_count == 2
+
+        # session_id: comes from a fresh start_session(), not copied from the .anton file
+        # (the .anton file's session.id is the original exporter's ID)
+        # We verify the new session got its ID from the new episodic, not the payload
+        assert new_session._session_id == new_episodic._session_id
+
+        # all records were restored
+        assert len(episodic.get_items()) == len(new_episodic.get_items())
+
+        # memory in new episodic: session_born → memory_write
+        mem_eps = new_episodic.get_memory_usage()
+        writes = [e for e in mem_eps if e.role == "memory_write"]
+        reads  = [e for e in mem_eps if e.role == "memory_read"]
+
+        assert len(writes) == 1
+        assert writes[0].content == SESSION_BORN_MEMORY["content"]
+
+        assert len(reads) == 1
+        assert reads[0].content == PROJECT_MEMORY["content"]
+
+        # scratchpad: one cell in .anton file, and it is restored into the runtime
+        assert len(payload["scratchpad"]["cells"]) == 1
+        assert "main" in new_session._scratchpads._pads
+        assert len(new_session._scratchpads._pads["main"].cells) == 1
+
+        # hippocampus: session_born (kind=lesson) written to project_hc
+        lessons_text = (tmp_path / "project_memory" / "lessons.md").read_text()
+        assert SESSION_BORN_MEMORY["content"] in lessons_text
+
+        rules_text = (tmp_path / "project_memory" / "rules.md").read_text()
+        assert PROJECT_MEMORY["content"] in rules_text
+
+        # ── 4. status ─────────────────────────────────────────────────────
+
+        status_console = RecordingConsole()
+        handle_share_status(status_console, new_session, workspace)
+        status_out = status_console.getvalue()
+
+        assert "revenue-region-yoy" in status_out, "Title from export must appear in status"
+        assert "Analyzed revenue. APAC leads YoY." in status_out, "Summary must appear in status"
+        assert "No data sources" in status_out, "No datasources in HISTORY, so should say none referenced"
+
+        # ── 5. history ─────────────────────────────────────────────────────
+
+        history_console = RecordingConsole()
+        handle_share_history(history_console, workspace)
+        history_out = history_console.getvalue()
+
+        assert "Exported sessions" in history_out, "Header must appear"
+        assert "revenue-region-yoy" in history_out, "Title must appear in history listing"
+        assert "Analyzed revenue. APAC leads YoY." in history_out, "Summary must appear in history listing"
+        assert "imported by" in history_out, "After roundtrip the file has imported metadata"