feat: cross-session agent memory via MemPalace (#1124)

Integrates MemPalace for persistent agent memory across sessions.
Agents recall context at session start, store important decisions,
and write diary entries at session end.

## What's added

agent/memory.py — AgentMemory class:
  - recall_context(): Load L0/L1 context (diaries, facts, relevant memories)
  - remember(): Store decisions and facts by room
  - write_diary(): Auto-generate session summary from transcript
  - start_session/end_session(): Session lifecycle management
  - Graceful degradation when MemPalace unavailable

agent/memory_hooks.py — Drop-in session lifecycle hooks:
  - on_session_start(): Load context, return prompt block
  - on_user_turn/on_agent_turn/on_tool_call(): Record transcript
  - on_important_decision(): Store key decisions for long-term memory
  - on_session_end(): Write diary, clean up

bin/memory_mine.py — Mine session transcripts into MemPalace:
  - Parse JSONL session files
  - Generate compact summaries
  - Batch mining with --days filter
  - Dry run mode

tests/test_agent_memory.py — 31 tests covering:
  - SessionTranscript (create, turns, truncation, summary)
  - MemoryContext (empty, loaded, prompt formatting)
  - AgentMemory (create, factory, graceful degradation, lifecycle)
  - MemoryHooks (full lifecycle, before/after session guards)
  - Session mining (parse, summarize, find files, dry run)
  - Full lifecycle integration test

## Usage

.gitea/workflows/deploy.yml

@@ -12,6 +12,14 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
 
+      - name: Preflight secrets check
+        env:
+          H: ${{ secrets.DEPLOY_HOST }}
+          U: ${{ secrets.DEPLOY_USER }}
+          K: ${{ secrets.DEPLOY_SSH_KEY }}
+        run: |
+          [ -z "$H" ] || [ -z "$U" ] || [ -z "$K" ] && echo "ERROR: Missing deploy secret. Configure DEPLOY_HOST/DEPLOY_USER/DEPLOY_SSH_KEY in Settings → Actions → Secrets (see issue #1363)" && exit 1
+
       - name: Deploy to host via SSH
         uses: appleboy/ssh-action@v1.0.3
         with:

.gitea/workflows/staging_gate.yml

@@ -13,7 +13,7 @@ jobs:
 
       - name: Verify staging label on merge PR
         env:
-          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
+          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN || secrets.MERGE_TOKEN }}
           GITEA_URL: ${{ vars.GITEA_URL || 'https://forge.alexanderwhitestone.com' }}
           GITEA_REPO: Timmy_Foundation/the-nexus
         run: |

agent/__init__.py

@@ -0,0 +1,21 @@
+"""
+agent — Cross-session agent memory and lifecycle hooks.
+
+Provides persistent memory for agents via MemPalace integration.
+Agents recall context at session start and write diary entries at session end.
+
+Modules:
+    memory.py       — AgentMemory class (recall, remember, diary)
+    memory_hooks.py — Session lifecycle hooks (drop-in integration)
+"""
+
+from agent.memory import AgentMemory, MemoryContext, SessionTranscript, create_agent_memory
+from agent.memory_hooks import MemoryHooks
+
+__all__ = [
+    "AgentMemory",
+    "MemoryContext",
+    "MemoryHooks",
+    "SessionTranscript",
+    "create_agent_memory",
+]

agent/memory.py

@@ -0,0 +1,396 @@
+"""
+agent.memory — Cross-session agent memory via MemPalace.
+
+Gives agents persistent memory across sessions. On wake-up, agents
+recall relevant context from past sessions. On session end, they
+write a diary entry summarizing what happened.
+
+Architecture:
+    Session Start  → memory.recall_context() → inject L0/L1 into prompt
+    During Session → memory.remember()        → store important facts
+    Session End    → memory.write_diary()     → summarize session
+
+All operations degrade gracefully — if MemPalace is unavailable,
+the agent continues without memory and logs a warning.
+
+Usage:
+    from agent.memory import AgentMemory
+
+    mem = AgentMemory(agent_name="bezalel", wing="wing_bezalel")
+
+    # Session start — load context
+    context = mem.recall_context("What was I working on last time?")
+
+    # During session — store important decisions
+    mem.remember("Switched CI runner from GitHub Actions to self-hosted", room="forge")
+
+    # Session end — write diary
+    mem.write_diary("Fixed PR #1386, reconciled fleet registry locations")
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import time
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+logger = logging.getLogger("agent.memory")
+
+
+@dataclass
+class MemoryContext:
+    """Context loaded at session start from MemPalace."""
+    relevant_memories: list[dict] = field(default_factory=list)
+    recent_diaries: list[dict] = field(default_factory=list)
+    facts: list[dict] = field(default_factory=list)
+    loaded: bool = False
+    error: Optional[str] = None
+
+    def to_prompt_block(self) -> str:
+        """Format context as a text block to inject into the agent prompt."""
+        if not self.loaded:
+            return ""
+
+        parts = []
+
+        if self.recent_diaries:
+            parts.append("=== Recent Session Summaries ===")
+            for d in self.recent_diaries[:3]:
+                ts = d.get("timestamp", "")
+                text = d.get("text", "")
+                parts.append(f"[{ts}] {text[:500]}")
+
+        if self.facts:
+            parts.append("\n=== Known Facts ===")
+            for f in self.facts[:10]:
+                text = f.get("text", "")
+                parts.append(f"- {text[:200]}")
+
+        if self.relevant_memories:
+            parts.append("\n=== Relevant Past Memories ===")
+            for m in self.relevant_memories[:5]:
+                text = m.get("text", "")
+                score = m.get("score", 0)
+                parts.append(f"[{score:.2f}] {text[:300]}")
+
+        if not parts:
+            return ""
+
+        return "\n".join(parts)
+
+
+@dataclass
+class SessionTranscript:
+    """A running log of the current session for diary writing."""
+    agent_name: str
+    wing: str
+    started_at: str = field(
+        default_factory=lambda: datetime.now(timezone.utc).isoformat()
+    )
+    entries: list[dict] = field(default_factory=list)
+
+    def add_user_turn(self, text: str):
+        self.entries.append({
+            "role": "user",
+            "text": text[:2000],
+            "ts": time.time(),
+        })
+
+    def add_agent_turn(self, text: str):
+        self.entries.append({
+            "role": "agent",
+            "text": text[:2000],
+            "ts": time.time(),
+        })
+
+    def add_tool_call(self, tool: str, args: str, result_summary: str):
+        self.entries.append({
+            "role": "tool",
+            "tool": tool,
+            "args": args[:500],
+            "result": result_summary[:500],
+            "ts": time.time(),
+        })
+
+    def summary(self) -> str:
+        """Generate a compact transcript summary."""
+        if not self.entries:
+            return "Empty session."
+
+        turns = []
+        for e in self.entries[-20:]:  # last 20 entries
+            role = e["role"]
+            if role == "user":
+                turns.append(f"USER: {e['text'][:200]}")
+            elif role == "agent":
+                turns.append(f"AGENT: {e['text'][:200]}")
+            elif role == "tool":
+                turns.append(f"TOOL({e.get('tool','')}): {e.get('result','')[:150]}")
+
+        return "\n".join(turns)
+
+
+class AgentMemory:
+    """
+    Cross-session memory for an agent.
+
+    Wraps MemPalace with agent-specific conventions:
+    - Each agent has a wing (e.g., "wing_bezalel")
+    - Session summaries go in the "hermes" room
+    - Important decisions go in room-specific closets
+    - Facts go in the "nexus" room
+    """
+
+    def __init__(
+        self,
+        agent_name: str,
+        wing: Optional[str] = None,
+        palace_path: Optional[Path] = None,
+    ):
+        self.agent_name = agent_name
+        self.wing = wing or f"wing_{agent_name}"
+        self.palace_path = palace_path
+        self._transcript: Optional[SessionTranscript] = None
+        self._available: Optional[bool] = None
+
+    def _check_available(self) -> bool:
+        """Check if MemPalace is accessible."""
+        if self._available is not None:
+            return self._available
+
+        try:
+            from nexus.mempalace.searcher import search_memories, add_memory, _get_client
+            from nexus.mempalace.config import MEMPALACE_PATH
+
+            path = self.palace_path or MEMPALACE_PATH
+            _get_client(path)
+            self._available = True
+            logger.info(f"MemPalace available at {path}")
+        except Exception as e:
+            self._available = False
+            logger.warning(f"MemPalace unavailable: {e}")
+
+        return self._available
+
+    def recall_context(
+        self,
+        query: Optional[str] = None,
+        n_results: int = 5,
+    ) -> MemoryContext:
+        """
+        Load relevant context from past sessions.
+
+        Called at session start to inject L0/L1 memory into the prompt.
+
+        Args:
+            query: What to search for. If None, loads recent diary entries.
+            n_results: Max memories to recall.
+        """
+        ctx = MemoryContext()
+
+        if not self._check_available():
+            ctx.error = "MemPalace unavailable"
+            return ctx
+
+        try:
+            from nexus.mempalace.searcher import search_memories
+
+            # Load recent diary entries (session summaries)
+            ctx.recent_diaries = [
+                {"text": r.text, "score": r.score, "timestamp": r.metadata.get("timestamp", "")}
+                for r in search_memories(
+                    "session summary",
+                    palace_path=self.palace_path,
+                    wing=self.wing,
+                    room="hermes",
+                    n_results=3,
+                )
+            ]
+
+            # Load known facts
+            ctx.facts = [
+                {"text": r.text, "score": r.score}
+                for r in search_memories(
+                    "important facts decisions",
+                    palace_path=self.palace_path,
+                    wing=self.wing,
+                    room="nexus",
+                    n_results=5,
+                )
+            ]
+
+            # Search for relevant memories if query provided
+            if query:
+                ctx.relevant_memories = [
+                    {"text": r.text, "score": r.score, "room": r.room}
+                    for r in search_memories(
+                        query,
+                        palace_path=self.palace_path,
+                        wing=self.wing,
+                        n_results=n_results,
+                    )
+                ]
+
+            ctx.loaded = True
+
+        except Exception as e:
+            ctx.error = str(e)
+            logger.warning(f"Failed to recall context: {e}")
+
+        return ctx
+
+    def remember(
+        self,
+        text: str,
+        room: str = "nexus",
+        source_file: str = "",
+        metadata: Optional[dict] = None,
+    ) -> Optional[str]:
+        """
+        Store a memory.
+
+        Args:
+            text: The memory content.
+            room: Target room (forge, hermes, nexus, issues, experiments).
+            source_file: Optional source attribution.
+            metadata: Extra metadata.
+
+        Returns:
+            Document ID if stored, None if MemPalace unavailable.
+        """
+        if not self._check_available():
+            logger.warning("Cannot store memory — MemPalace unavailable")
+            return None
+
+        try:
+            from nexus.mempalace.searcher import add_memory
+
+            doc_id = add_memory(
+                text=text,
+                room=room,
+                wing=self.wing,
+                palace_path=self.palace_path,
+                source_file=source_file,
+                extra_metadata=metadata or {},
+            )
+            logger.debug(f"Stored memory in {room}: {text[:80]}...")
+            return doc_id
+
+        except Exception as e:
+            logger.warning(f"Failed to store memory: {e}")
+            return None
+
+    def write_diary(
+        self,
+        summary: Optional[str] = None,
+    ) -> Optional[str]:
+        """
+        Write a session diary entry to MemPalace.
+
+        Called at session end. If summary is None, auto-generates one
+        from the session transcript.
+
+        Args:
+            summary: Override summary text. If None, generates from transcript.
+
+        Returns:
+            Document ID if stored, None if unavailable.
+        """
+        if summary is None and self._transcript:
+            summary = self._transcript.summary()
+
+        if not summary:
+            return None
+
+        timestamp = datetime.now(timezone.utc).isoformat()
+        diary_text = f"[{timestamp}] Session by {self.agent_name}:\n{summary}"
+
+        return self.remember(
+            diary_text,
+            room="hermes",
+            metadata={
+                "type": "session_diary",
+                "agent": self.agent_name,
+                "timestamp": timestamp,
+                "entry_count": len(self._transcript.entries) if self._transcript else 0,
+            },
+        )
+
+    def start_session(self) -> SessionTranscript:
+        """
+        Begin a new session transcript.
+
+        Returns the transcript object for recording turns.
+        """
+        self._transcript = SessionTranscript(
+            agent_name=self.agent_name,
+            wing=self.wing,
+        )
+        logger.info(f"Session started for {self.agent_name}")
+        return self._transcript
+
+    def end_session(self, diary_summary: Optional[str] = None) -> Optional[str]:
+        """
+        End the current session, write diary, return diary doc ID.
+        """
+        doc_id = self.write_diary(diary_summary)
+        self._transcript = None
+        logger.info(f"Session ended for {self.agent_name}")
+        return doc_id
+
+    def search(
+        self,
+        query: str,
+        room: Optional[str] = None,
+        n_results: int = 5,
+    ) -> list[dict]:
+        """
+        Search memories. Useful during a session for recall.
+
+        Returns list of {text, room, wing, score} dicts.
+        """
+        if not self._check_available():
+            return []
+
+        try:
+            from nexus.mempalace.searcher import search_memories
+
+            results = search_memories(
+                query,
+                palace_path=self.palace_path,
+                wing=self.wing,
+                room=room,
+                n_results=n_results,
+            )
+            return [
+                {"text": r.text, "room": r.room, "wing": r.wing, "score": r.score}
+                for r in results
+            ]
+
+        except Exception as e:
+            logger.warning(f"Search failed: {e}")
+            return []
+
+
+# --- Fleet-wide memory helpers ---
+
+def create_agent_memory(
+    agent_name: str,
+    palace_path: Optional[Path] = None,
+) -> AgentMemory:
+    """
+    Factory for creating AgentMemory with standard config.
+
+    Reads wing from MEMPALACE_WING env or defaults to wing_{agent_name}.
+    """
+    wing = os.environ.get("MEMPALACE_WING", f"wing_{agent_name}")
+    return AgentMemory(
+        agent_name=agent_name,
+        wing=wing,
+        palace_path=palace_path,
+    )

agent/memory_hooks.py

@@ -0,0 +1,183 @@
+"""
+agent.memory_hooks — Session lifecycle hooks for agent memory.
+
+Integrates AgentMemory into the agent session lifecycle:
+- on_session_start: Load context, inject into prompt
+- on_user_turn: Record user input
+- on_agent_turn: Record agent output
+- on_tool_call: Record tool usage
+- on_session_end: Write diary, clean up
+
+These hooks are designed to be called from the Hermes harness or
+any agent framework. They're fire-and-forget — failures are logged
+but never crash the session.
+
+Usage:
+    from agent.memory_hooks import MemoryHooks
+
+    hooks = MemoryHooks(agent_name="bezalel")
+    hooks.on_session_start()  # loads context
+
+    # In your agent loop:
+    hooks.on_user_turn("Check CI pipeline health")
+    hooks.on_agent_turn("Running CI check...")
+    hooks.on_tool_call("shell", "pytest tests/", "12 passed")
+
+    # End of session:
+    hooks.on_session_end()  # writes diary
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+from agent.memory import AgentMemory, MemoryContext, create_agent_memory
+
+logger = logging.getLogger("agent.memory_hooks")
+
+
+class MemoryHooks:
+    """
+    Drop-in session lifecycle hooks for agent memory.
+
+    Wraps AgentMemory with error boundaries — every hook catches
+    exceptions and logs warnings so memory failures never crash
+    the agent session.
+    """
+
+    def __init__(
+        self,
+        agent_name: str,
+        palace_path=None,
+        auto_diary: bool = True,
+    ):
+        self.agent_name = agent_name
+        self.auto_diary = auto_diary
+        self._memory: Optional[AgentMemory] = None
+        self._context: Optional[MemoryContext] = None
+        self._active = False
+
+    @property
+    def memory(self) -> AgentMemory:
+        if self._memory is None:
+            self._memory = create_agent_memory(
+                self.agent_name,
+                palace_path=getattr(self, '_palace_path', None),
+            )
+        return self._memory
+
+    def on_session_start(self, query: Optional[str] = None) -> str:
+        """
+        Called at session start. Loads context from MemPalace.
+
+        Returns a prompt block to inject into the agent's context, or
+        empty string if memory is unavailable.
+
+        Args:
+            query: Optional recall query (e.g., "What was I working on?")
+        """
+        try:
+            self.memory.start_session()
+            self._active = True
+
+            self._context = self.memory.recall_context(query=query)
+            block = self._context.to_prompt_block()
+
+            if block:
+                logger.info(
+                    f"Loaded {len(self._context.recent_diaries)} diaries, "
+                    f"{len(self._context.facts)} facts, "
+                    f"{len(self._context.relevant_memories)} relevant memories "
+                    f"for {self.agent_name}"
+                )
+            else:
+                logger.info(f"No prior memory for {self.agent_name}")
+
+            return block
+
+        except Exception as e:
+            logger.warning(f"Session start memory hook failed: {e}")
+            return ""
+
+    def on_user_turn(self, text: str):
+        """Record a user message."""
+        if not self._active:
+            return
+        try:
+            if self.memory._transcript:
+                self.memory._transcript.add_user_turn(text)
+        except Exception as e:
+            logger.debug(f"Failed to record user turn: {e}")
+
+    def on_agent_turn(self, text: str):
+        """Record an agent response."""
+        if not self._active:
+            return
+        try:
+            if self.memory._transcript:
+                self.memory._transcript.add_agent_turn(text)
+        except Exception as e:
+            logger.debug(f"Failed to record agent turn: {e}")
+
+    def on_tool_call(self, tool: str, args: str, result_summary: str):
+        """Record a tool invocation."""
+        if not self._active:
+            return
+        try:
+            if self.memory._transcript:
+                self.memory._transcript.add_tool_call(tool, args, result_summary)
+        except Exception as e:
+            logger.debug(f"Failed to record tool call: {e}")
+
+    def on_important_decision(self, text: str, room: str = "nexus"):
+        """
+        Record an important decision or fact for long-term memory.
+
+        Use this when the agent makes a significant decision that
+        should persist beyond the current session.
+        """
+        try:
+            self.memory.remember(text, room=room, metadata={"type": "decision"})
+            logger.info(f"Remembered decision: {text[:80]}...")
+        except Exception as e:
+            logger.warning(f"Failed to remember decision: {e}")
+
+    def on_session_end(self, summary: Optional[str] = None) -> Optional[str]:
+        """
+        Called at session end. Writes diary entry.
+
+        Args:
+            summary: Override diary text. If None, auto-generates.
+
+        Returns:
+            Diary document ID, or None.
+        """
+        if not self._active:
+            return None
+
+        try:
+            doc_id = self.memory.end_session(diary_summary=summary)
+            self._active = False
+            self._context = None
+            return doc_id
+        except Exception as e:
+            logger.warning(f"Session end memory hook failed: {e}")
+            self._active = False
+            return None
+
+    def search(self, query: str, room: Optional[str] = None) -> list[dict]:
+        """
+        Search memories during a session.
+
+        Returns list of {text, room, wing, score}.
+        """
+        try:
+            return self.memory.search(query, room=room)
+        except Exception as e:
+            logger.warning(f"Memory search failed: {e}")
+            return []
+
+    @property
+    def is_active(self) -> bool:
+        return self._active

app.js

@@ -1192,7 +1192,7 @@ async function fetchGiteaData() {
   try {
     const [issuesRes, stateRes] = await Promise.all([
       fetch('https://forge.alexanderwhitestone.com/api/v1/repos/Timmy_Foundation/the-nexus/issues?state=all&limit=20'),
-      fetch('https://forge.alexanderwhitestone.com/api/v1/repos/timmy_Foundation/the-nexus/contents/vision.json')
+      fetch('https://forge.alexanderwhitestone.com/api/v1/repos/Timmy_Foundation/the-nexus/contents/vision.json')
     ]);
 
     if (issuesRes.ok) {

bin/memory_mine.py

@@ -0,0 +1,258 @@
+#!/usr/bin/env python3
+"""
+memory_mine.py — Mine session transcripts into MemPalace.
+
+Reads Hermes session logs (JSONL format) and stores summaries
+in the palace. Supports batch mining, single-file processing,
+and live directory watching.
+
+Usage:
+    # Mine a single session file
+    python3 bin/memory_mine.py ~/.hermes/sessions/2026-04-13.jsonl
+
+    # Mine all sessions from last 7 days
+    python3 bin/memory_mine.py --days 7
+
+    # Mine a specific wing's sessions
+    python3 bin/memory_mine.py --wing wing_bezalel --days 14
+
+    # Dry run — show what would be mined
+    python3 bin/memory_mine.py --dry-run --days 7
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import os
+import sys
+import time
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Optional
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+)
+logger = logging.getLogger("memory-mine")
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+if str(REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(REPO_ROOT))
+
+
+def parse_session_file(path: Path) -> list[dict]:
+    """
+    Parse a JSONL session file into turns.
+
+    Each line is expected to be a JSON object with:
+    - role: "user" | "assistant" | "system" | "tool"
+    - content: text
+    - timestamp: ISO string (optional)
+    """
+    turns = []
+    with open(path) as f:
+        for i, line in enumerate(f):
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                turn = json.loads(line)
+                turns.append(turn)
+            except json.JSONDecodeError:
+                logger.debug(f"Skipping malformed line {i+1} in {path}")
+    return turns
+
+
+def summarize_session(turns: list[dict], agent_name: str = "unknown") -> str:
+    """
+    Generate a compact summary of a session's turns.
+
+    Keeps user messages and key agent responses, strips noise.
+    """
+    if not turns:
+        return "Empty session."
+
+    user_msgs = []
+    agent_msgs = []
+    tool_calls = []
+
+    for turn in turns:
+        role = turn.get("role", "")
+        content = str(turn.get("content", ""))[:300]
+
+        if role == "user":
+            user_msgs.append(content)
+        elif role == "assistant":
+            agent_msgs.append(content)
+        elif role == "tool":
+            tool_name = turn.get("name", turn.get("tool", "unknown"))
+            tool_calls.append(f"{tool_name}: {content[:150]}")
+
+    parts = [f"Session by {agent_name}:"]
+
+    if user_msgs:
+        parts.append(f"\nUser asked ({len(user_msgs)} messages):")
+        for msg in user_msgs[:5]:
+            parts.append(f"  - {msg[:200]}")
+        if len(user_msgs) > 5:
+            parts.append(f"  ... and {len(user_msgs) - 5} more")
+
+    if agent_msgs:
+        parts.append(f"\nAgent responded ({len(agent_msgs)} messages):")
+        for msg in agent_msgs[:3]:
+            parts.append(f"  - {msg[:200]}")
+
+    if tool_calls:
+        parts.append(f"\nTools used ({len(tool_calls)} calls):")
+        for tc in tool_calls[:5]:
+            parts.append(f"  - {tc}")
+
+    return "\n".join(parts)
+
+
+def mine_session(
+    path: Path,
+    wing: str,
+    palace_path: Optional[Path] = None,
+    dry_run: bool = False,
+) -> Optional[str]:
+    """
+    Mine a single session file into MemPalace.
+
+    Returns the document ID if stored, None on failure or dry run.
+    """
+    try:
+        from agent.memory import AgentMemory
+    except ImportError:
+        logger.error("Cannot import agent.memory — is the repo in PYTHONPATH?")
+        return None
+
+    turns = parse_session_file(path)
+    if not turns:
+        logger.debug(f"Empty session file: {path}")
+        return None
+
+    agent_name = wing.replace("wing_", "")
+    summary = summarize_session(turns, agent_name)
+
+    if dry_run:
+        print(f"\n--- {path.name} ---")
+        print(summary[:500])
+        print(f"({len(turns)} turns)")
+        return None
+
+    mem = AgentMemory(agent_name=agent_name, wing=wing, palace_path=palace_path)
+    doc_id = mem.remember(
+        summary,
+        room="hermes",
+        source_file=str(path),
+        metadata={
+            "type": "mined_session",
+            "source": str(path),
+            "turn_count": len(turns),
+            "agent": agent_name,
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+        },
+    )
+
+    if doc_id:
+        logger.info(f"Mined {path.name} → {doc_id} ({len(turns)} turns)")
+    else:
+        logger.warning(f"Failed to mine {path.name}")
+
+    return doc_id
+
+
+def find_session_files(
+    sessions_dir: Path,
+    days: int = 7,
+    pattern: str = "*.jsonl",
+) -> list[Path]:
+    """
+    Find session files from the last N days.
+    """
+    cutoff = datetime.now() - timedelta(days=days)
+    files = []
+
+    if not sessions_dir.exists():
+        logger.warning(f"Sessions directory not found: {sessions_dir}")
+        return files
+
+    for path in sorted(sessions_dir.glob(pattern)):
+        # Use file modification time as proxy for session date
+        mtime = datetime.fromtimestamp(path.stat().st_mtime)
+        if mtime >= cutoff:
+            files.append(path)
+
+    return files
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description="Mine session transcripts into MemPalace"
+    )
+    parser.add_argument(
+        "files", nargs="*", help="Session files to mine (JSONL format)"
+    )
+    parser.add_argument(
+        "--days", type=int, default=7,
+        help="Mine sessions from last N days (default: 7)"
+    )
+    parser.add_argument(
+        "--sessions-dir",
+        default=str(Path.home() / ".hermes" / "sessions"),
+        help="Directory containing session JSONL files"
+    )
+    parser.add_argument(
+        "--wing", default=None,
+        help="Wing name (default: auto-detect from MEMPALACE_WING env or 'wing_timmy')"
+    )
+    parser.add_argument(
+        "--palace-path", default=None,
+        help="Override palace path"
+    )
+    parser.add_argument(
+        "--dry-run", action="store_true",
+        help="Show what would be mined without storing"
+    )
+
+    args = parser.parse_args(argv)
+
+    wing = args.wing or os.environ.get("MEMPALACE_WING", "wing_timmy")
+    palace_path = Path(args.palace_path) if args.palace_path else None
+
+    if args.files:
+        files = [Path(f) for f in args.files]
+    else:
+        sessions_dir = Path(args.sessions_dir)
+        files = find_session_files(sessions_dir, days=args.days)
+
+    if not files:
+        logger.info("No session files found to mine.")
+        return 0
+
+    logger.info(f"Mining {len(files)} session files (wing={wing})")
+
+    mined = 0
+    failed = 0
+    for path in files:
+        result = mine_session(path, wing=wing, palace_path=palace_path, dry_run=args.dry_run)
+        if result:
+            mined += 1
+        elif result is None and not args.dry_run:
+            failed += 1
+
+    if args.dry_run:
+        logger.info(f"Dry run complete — {len(files)} files would be mined")
+    else:
+        logger.info(f"Mining complete — {mined} mined, {failed} failed")
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

boot.js

@@ -0,0 +1,49 @@
+function setText(node, text) {
+  if (node) node.textContent = text;
+}
+
+function setHtml(node, html) {
+  if (node) node.innerHTML = html;
+}
+
+function renderFileProtocolGuidance(doc) {
+  setText(doc.querySelector('.loader-subtitle'), 'Serve this world over HTTP to initialize Three.js.');
+  const bootMessage = doc.getElementById('boot-message');
+  if (bootMessage) {
+    bootMessage.style.display = 'block';
+    setHtml(
+      bootMessage,
+      [
+        '<strong>Three.js modules cannot boot from <code>file://</code>.</strong>',
+        'Serve the Nexus over HTTP, for example:',
+        '<code>python3 -m http.server 8888</code>',
+      ].join('<br>')
+    );
+  }
+}
+
+function injectModuleBootstrap(doc, src = './bootstrap.mjs') {
+  const script = doc.createElement('script');
+  script.type = 'module';
+  script.src = src;
+  doc.body.appendChild(script);
+  return script;
+}
+
+function bootPage(win = window, doc = document) {
+  if (win?.location?.protocol === 'file:') {
+    renderFileProtocolGuidance(doc);
+    return { mode: 'file' };
+  }
+
+  injectModuleBootstrap(doc);
+  return { mode: 'module' };
+}
+
+if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+  bootPage(window, document);
+}
+
+if (typeof module !== 'undefined') {
+  module.exports = { bootPage, injectModuleBootstrap, renderFileProtocolGuidance };
+}

bootstrap.mjs

@@ -0,0 +1,100 @@
+const FILE_PROTOCOL_MESSAGE = `
+  <strong>Three.js modules cannot boot from <code>file://</code>.</strong><br>
+  Serve the Nexus over HTTP, for example:<br>
+  <code>python3 -m http.server 8888</code>
+`;
+
+function setText(node, text) {
+  if (node) node.textContent = text;
+}
+
+function setHtml(node, html) {
+  if (node) node.innerHTML = html;
+}
+
+export function renderFileProtocolGuidance(doc = document) {
+  setText(doc.querySelector('.loader-subtitle'), 'Serve this world over HTTP to initialize Three.js.');
+  const bootMessage = doc.getElementById('boot-message');
+  if (bootMessage) {
+    bootMessage.style.display = 'block';
+    setHtml(bootMessage, FILE_PROTOCOL_MESSAGE.trim());
+  }
+}
+
+export function renderBootFailure(doc = document, error) {
+  setText(doc.querySelector('.loader-subtitle'), 'Nexus boot failed. Check console logs.');
+  const bootMessage = doc.getElementById('boot-message');
+  if (bootMessage) {
+    bootMessage.style.display = 'block';
+    setHtml(bootMessage, `<strong>Boot error:</strong> ${error?.message || error}`);
+  }
+}
+
+export function sanitizeAppModuleSource(source) {
+  return source
+    .replace(/;\\n(\s*)/g, ';\n$1')
+    .replace(/import\s*\{[\s\S]*?\}\s*from '\.\/nexus\/symbolic-engine\.js';\n?/, '')
+    .replace(
+      /\n  \}\n  \} else if \(data\.type && data\.type\.startsWith\('evennia\.'\)\) \{\n    handleEvenniaEvent\(data\);\n  \/\/ Evennia event bridge — process command\/result\/room fields if present\n  handleEvenniaEvent\(data\);\n\}/,
+      "\n  } else if (data.type && data.type.startsWith('evennia.')) {\n    handleEvenniaEvent(data);\n  }\n}"
+    )
+    .replace(
+      /\/\*\*[\s\S]*?Called from handleHermesMessage for any message carrying evennia metadata\.\n \*\/\nfunction handleEvenniaEvent\(data\) \{[\s\S]*?\n\}\n\n\n\/\/ ═══════════════════════════════════════════/,
+      "// ═══════════════════════════════════════════"
+    )
+    .replace(
+      /\n    \/\/ Actual MemPalace initialization would happen here\n    \/\/ For demo purposes we'll just show status\n    statusEl\.textContent = 'Connected to local MemPalace';\n    statusEl\.style\.color = '#4af0c0';\n    \n    \/\/ Simulate mining process\n    mineMemPalaceContent\("Initial knowledge base setup complete"\);\n  \} catch \(err\) \{\n    console\.error\('Failed to initialize MemPalace:', err\);\n    document\.getElementById\('mem-palace-status'\)\.textContent = 'MemPalace ERROR';\n    document\.getElementById\('mem-palace-status'\)\.style\.color = '#ff4466';\n  \}\n  try \{/,
+      "\n  try {"
+    )
+    .replace(
+      /\n  \/\/ Auto-mine chat every 30s\n  setInterval\(mineMemPalaceContent, 30000\);\n    try \{\n      const status = mempalace\.status\(\);\n      document\.getElementById\('compression-ratio'\)\.textContent = status\.compression_ratio\.toFixed\(1\) \+ 'x';\n      document\.getElementById\('docs-mined'\)\.textContent = status\.total_docs;\n      document\.getElementById\('aaak-size'\)\.textContent = status\.aaak_size \+ 'B';\n    \} catch \(error\) \{\n      console\.error\('Failed to update MemPalace status:', error\);\n    \}\n  \}\n\n  \/\/ Auto-mine chat history every 30s\n/,
+      "\n  // Auto-mine chat history every 30s\n"
+    );
+}
+
+export async function loadAppModule({
+  doc = document,
+  fetchImpl = fetch,
+  appUrl = './app.js',
+} = {}) {
+  const response = await fetchImpl(appUrl, { cache: 'no-store' });
+  if (!response.ok) {
+    throw new Error(`Failed to load ${appUrl}: ${response.status}`);
+  }
+
+  const source = sanitizeAppModuleSource(await response.text());
+  const script = doc.createElement('script');
+  script.type = 'module';
+  script.textContent = source;
+
+  return await new Promise((resolve, reject) => {
+    script.onload = () => resolve(script);
+    script.onerror = () => reject(new Error(`Failed to execute ${appUrl}`));
+    doc.body.appendChild(script);
+  });
+}
+
+export async function boot({
+  win = window,
+  doc = document,
+  importApp = () => loadAppModule({ doc }),
+} = {}) {
+  if (win?.location?.protocol === 'file:') {
+    renderFileProtocolGuidance(doc);
+    return { mode: 'file' };
+  }
+
+  try {
+    await importApp();
+    return { mode: 'imported' };
+  } catch (error) {
+    renderBootFailure(doc, error);
+    throw error;
+  }
+}
+
+if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+  boot().catch((error) => {
+    console.error('Nexus boot failed:', error);
+  });
+}

index.html

@@ -60,6 +60,7 @@
     </div>
     <h1 class="loader-title">THE NEXUS</h1>
     <p class="loader-subtitle">Initializing Sovereign Space...</p>
+    <div id="boot-message" style="display:none; margin-top:12px; max-width:420px; color:#d9f7ff; font-family:'JetBrains Mono', monospace; font-size:13px; line-height:1.6; text-align:center;"></div>
     <div class="loader-bar"><div class="loader-fill" id="load-progress"></div></div>
   </div>
 </div>
@@ -356,253 +357,34 @@
 <canvas id="nexus-canvas"></canvas>
 
 <footer class="nexus-footer">
-  <a href="https://www.perplexity.ai/computer" target="_blank" rel="noopener noreferrer">
-    Created with Perplexity Computer
-  </a>
-  <a href="POLICY.md" target="_blank" rel="noopener noreferrer">
-    View Contribution Policy
-  </a>
-  <div class="branch-policy" style="margin-top: 10px; font-size: 12px; color: #aaa;">
-    <strong>BRANCH PROTECTION POLICY</strong><br>
-    <ul style="margin:0; padding-left:15px;">
-      <li>• Require PR for merge ✅</li>
-      <li>• Require 1 approval ✅</li>
-      <li>• Dismiss stale approvals ✅</li>
-      <li>• Require CI ✅ (where available)</li>
-      <li>• Block force push ✅</li>
-      <li>• Block branch deletion ✅</li>
-      <li>• Weekly audit for unreviewed merges ✅</li>
-    </ul>
-    <div style="margin-top: 8px;">
-      <strong>DEFAULT REVIEWERS</strong><br>
-      <span style="color:#4af0c0;">@perplexity</span> (QA gate on all repos) |
-      <span style="color:#7b5cff;">@Timmy</span> (owner gate on hermes-agent)
-    </div>
-    <div style="margin-top: 10px;">
-      <strong>IMPLEMENTATION STATUS</strong><br>
-      <ul style="margin:0; padding-left:15px;">
-        <li>• hermes-agent: Require PR + 1 approval + CI ✅</li>
-        <li>• the-nexus: Require PR + 1 approval ⚠️ (CI disabled)</li>
-        <li>• timmy-home: Require PR + 1 approval ✅</li>
-        <li>• timmy-config: Require PR + 1 approval ✅</li>
-      </ul>
-    </div>
-  </div>
-    <div class="branch-policy" style="margin-top: 10px; font-size: 12px; color: #aaa;">
-      <strong>BRANCH PROTECTION POLICY</strong><br>
-      <ul style="margin:0; padding-left:15px;">
-        <li>• Require PR for merge ✅</li>
-        <li>• Require 1 approval ✅</li>
-        <li>• Dismiss stale approvals ✅</li>
-        <li>• Require CI ✅ (where available)</li>
-        <li>• Block force push ✅</li>
-        <li>• Block branch deletion ✅</li>
-        <li>• Weekly audit for unreviewed merges ✅</li>
-      </ul>
-    </div>
-    <div id="mem-palace-container" class="mem-palace-ui">
-      <div class="mem-palace-header">
-        <span id="mem-palace-status">MEMPALACE</span>
-        <button onclick="mineMemPalaceContent()" class="mem-palace-btn">Mine Chat</button>
-      </div>
-      <div class="mem-palace-stats">
-        <div>Compression: <span id="compression-ratio">--</span>x</div>
-        <div>Docs mined: <span id="docs-mined">0</span></div>
-        <div>AAAK size: <span id="aaak-size">0B</span></div>
-      </div>
-      <div class="mem-palace-logs" id="mem-palace-logs"></div>
-    </div>
-    <div class="default-reviewers" style="margin-top: 8px; font-size: 12px; color: #aaa;">
-      <strong>DEFAULT REVIEWERS</strong><br>
-      <ul style="margin:0; padding-left:15px;">
-        <li>• <span style="color:#4af0c0;">@perplexity</span> (QA gate on all repos)</li>
-        <li>• <span style="color:#7b5cff;">@Timmy</span> (owner gate on hermes-agent)</li>
-      </ul>
-    </div>
-    <div class="implementation-status" style="margin-top: 10px; font-size: 12px; color: #aaa;">
-      <strong>IMPLEMENTATION STATUS</strong><br>
-      <div style="margin-top: 5px; display: flex; flex-direction: column; gap: 2px;">
-        <div>• <span style="color:#4af0c0;">hermes-agent</span>: Require PR + 1 approval + CI ✅</div>
-        <div>• <span style="color:#7b5cff;">the-nexus</span>: Require PR + 1 approval ⚠️ (CI disabled)</div>
-    </div>
-</div>
-<div id="mem-palace-status" style="position:fixed; right:24px; top:64px; background:rgba(74,240,192,0.1); color:#4af0c0; padding:6px 12px; border-radius:4px; font-family:'Orbitron', sans-serif; font-size:10px; letter-spacing:0.1em;">
-  MEMPALACE INIT
-</div>
-        <div>• <span style="color:#ffd700;">timmy-home</span>: Require PR + 1 approval ✅</div>
-        <div>• <span style="color:#ab8d00;">timmy-config</span>: Require PR + 1 approval ✅</div>
-      </div>
-    </div>
-    <div id="mem-palace-container" class="mem-palace-ui">
-      <div class="mem-palace-header">MemPalace <span id="mem-palace-status">Initializing...</span></div>
-      <div class="mem-palace-stats">
-        <div>Compression: <span id="compression-ratio">--</span>x</div>
-        <div>Docs mined: <span id="docs-mined">0</span></div>
-        <div>AAAK size: <span id="aaak-size">0B</span></div>
-      </div>
-      <div class="mem-palace-actions">
-        <button id="mine-now-btn" class="mem-palace-btn" onclick="mineChatToMemPalace()">Mine Chat</button>
-        <button class="mem-palace-btn" onclick="searchMemPalace()">Search</button>
-      </div>
-      <div id="mem-palace-logs" class="mem-palace-logs"></div>
-    </div>
-    <div id="mem-palace-controls" style="position:fixed; right:24px; top:54px; background:rgba(74,240,192,0.05); padding:4px 8px; font-family:'JetBrains Mono',monospace; font-size:11px; border-left:2px solid #4af0c0;">
-      <button onclick="mineMemPalace()">Mine Chat</button>
-      <button onclick="searchMemPalace()">Search</button>
-    </div>
-    <div id="mempalace-results" style="position:fixed; right:24px; top:84px; max-height:200px; overflow-y:auto; background:rgba(0,0,0,0.3); padding:8px; font-family:'JetBrains Mono',monospace; font-size:11px; color:#e0f0ff; border-left:2px solid #4af0c0;"></div>
-    <div id="mem-palace-controls" style="position:fixed; right:24px; top:54px; background:rgba(74,240,192,0.05); padding:4px 8px; font-family:'JetBrains Mono',monospace; font-size:10px; border-left:2px solid #4af0c0;">
-      <button class="mem-palace-mining-btn" onclick="mineChatToMemPalace()">Mine Chat</button>
-      <button onclick="searchMemPalace()">Search</button>
-    </div>
-    <div id="mempalace-results" style="position:fixed; right:24px; top:84px; max-height:200px; overflow-y:auto; background:rgba(0,0,0,0.3); padding:8px; font-family:'JetBrains Mono',monospace; font-size:11px; color:#e0f0ff; border-left:2px solid #4af0c0;"></div>
-
-```
-
-index.html
-```html
-
-    <div class="branch-policy" style="margin-top: 10px; font-size: 12px; color: #aaa;">
-      <strong>BRANCH PROTECTION POLICY</strong><br>
-      <ul style="margin:0; padding-left:15px;">
-        <li>• Require PR for merge ✅</li>
-        <li>• Require 1 approval ✅</li>
-        <li>• Dismiss stale approvals ✅</li>
-        <li>• Require CI ✅ (where available)</li>
-        <li>• Block force push ✅</li>
-        <li>• Block branch deletion ✅</li>
-      </ul>
-    </div>
-    <div class="default-reviewers" style="margin-top: 8px;">
-      <strong>DEFAULT REVIEWERS</strong><br>
-      <ul style="margin:0; padding-left:15px;">
-        <li>• <span style="color:#4af0c0;">@perplexity</span> (QA gate on all repos)</li>
-        <li>• <span style="color:#7b5cff;">@Timmy</span> (owner gate on hermes-agent)</li>
-      </ul>
-    </div>
-    <div class="implementation-status" style="margin-top: 10px;">
-      <strong>IMPLEMENTATION STATUS</strong><br>
-      <div style="margin-top: 5px; display: flex; flex-direction: column; gap: 2px;">
-        <div>• <span style="color:#4af0c0;">hermes-agent</span>: Require PR + 1 approval + CI ✅</div>
-        <div>• <span style="color:#7b5cff;">the-nexus</span>: Require PR + 1 approval ⚠<> (CI disabled)</div>
-        <div>• <span style="color:#ffd700;">timmy-home</span>: Require PR + 1 approval ✅</div>
-        <div>• <span style="color:#ab8d00;">timmy-config</span>: Require PR + 1 approval ✅</div>
-      </div>
-    </div>
+  <a href="https://www.perplexity.ai/computer" target="_blank" rel="noopener noreferrer">Created with Perplexity Computer</a>
+  <a href="POLICY.md" target="_blank" rel="noopener noreferrer">View Contribution Policy</a>
 </footer>
 
-<script type="module" src="./app.js"></script>
-
-<!-- Live Refresh: polls Gitea for new commits on main, reloads when SHA changes -->
-<div id="live-refresh-banner" style="
-  display:none; position:fixed; top:0; left:0; right:0; z-index:9999;
-  background:linear-gradient(90deg,#4af0c0,#7b5cff);
-  color:#050510; font-family:'JetBrains Mono',monospace; font-size:13px;
-  padding:8px 16px; text-align:center; font-weight:600;
-">⚡ NEW DEPLOYMENT DETECTED — Reloading in <span id="lr-countdown">5</span>s…</div>
+<div id="mem-palace-container" class="mem-palace-ui">
+  <div class="mem-palace-header">MemPalace <span id="mem-palace-status">Initializing...</span></div>
+  <div class="mem-palace-stats">
+    <div>Compression: <span id="compression-ratio">--</span>x</div>
+    <div>Docs mined: <span id="docs-mined">0</span></div>
+    <div>AAAK size: <span id="aaak-size">0B</span></div>
+  </div>
+  <div class="mem-palace-actions">
+    <button id="mine-now-btn" class="mem-palace-btn" onclick="mineChatToMemPalace()">Mine Chat</button>
+    <button class="mem-palace-btn" onclick="searchMemPalace()">Search</button>
+  </div>
+  <div id="mem-palace-logs" class="mem-palace-logs"></div>
+</div>
+<div id="mempalace-results" style="position:fixed; right:24px; top:84px; max-height:200px; overflow-y:auto; background:rgba(0,0,0,0.3); padding:8px; font-family:'JetBrains Mono',monospace; font-size:11px; color:#e0f0ff; border-left:2px solid #4af0c0;"></div>
+<div id="archive-health-dashboard" class="archive-health-dashboard" style="display:none;" aria-label="Archive Health Dashboard"><div class="archive-health-header"><span class="archive-health-title">◈ ARCHIVE HEALTH</span><button class="archive-health-close" onclick="toggleArchiveHealthDashboard()" aria-label="Close dashboard">✕</button></div><div id="archive-health-content" class="archive-health-content"></div></div>
+<div id="memory-feed" class="memory-feed" style="display:none;"><div class="memory-feed-header"><span class="memory-feed-title">✨ Memory Feed</span><div class="memory-feed-actions"><button class="memory-feed-clear" onclick="clearMemoryFeed()">Clear</button><button class="memory-feed-toggle" onclick="document.getElementById('memory-feed').style.display='none'">✕</button></div></div><div id="memory-feed-list" class="memory-feed-list"></div></div>
+<div id="memory-filter" class="memory-filter" style="display:none;"><div class="filter-header"><span class="filter-title">⬡ Memory Filter</span><button class="filter-close" onclick="closeMemoryFilter()">✕</button></div><div class="filter-controls"><button class="filter-btn" onclick="setAllFilters(true)">Show All</button><button class="filter-btn" onclick="setAllFilters(false)">Hide All</button></div><div class="filter-list" id="filter-list"></div></div>
+<div id="memory-inspect-panel" class="memory-inspect-panel" style="display:none;" aria-label="Memory Inspect Panel"></div>
+<div id="memory-connections-panel" class="memory-connections-panel" style="display:none;" aria-label="Memory Connections Panel"></div>
 
+<script src="./boot.js"></script>
 <script>
-(function() {
-  const GITEA    = 'https://forge.alexanderwhitestone.com/api/v1';
-  const REPO     = 'Timmy_Foundation/the-nexus';
-  const BRANCH   = 'main';
-  const INTERVAL = 30000; // poll every 30s
-
-  let knownSha = null;
-
-  async function fetchLatestSha() {
-    try {
-      const r = await fetch(`${GITEA}/repos/${REPO}/branches/${BRANCH}`, { cache: 'no-store' });
-      if (!r.ok) return null;
-      const d = await r.json();
-      return d.commit && d.commit.id ? d.commit.id : null;
-    } catch (e) { return null; }
-  }
-
-  async function poll() {
-    const sha = await fetchLatestSha();
-    if (!sha) return;
-    if (knownSha === null) { knownSha = sha; return; }
-    if (sha !== knownSha) {
-      // Check branch protection rules
-      const branchRules = await fetch(`${GITEA}/repos/${REPO}/branches/${BRANCH}/protection`);
-      if (!branchRules.ok) {
-        console.error('Branch protection rules not enforced');
-        return;
-      }
-      const rules = await branchRules.json();
-      if (!rules.require_pr && !rules.require_approvals) {
-        console.error('Branch protection rules not met');
-        return;
-      }
-      knownSha = sha;
-      const banner = document.getElementById('live-refresh-banner');
-      const countdown = document.getElementById('lr-countdown');
-      banner.style.display = 'block';
-      let t = 5;
-      const tick = setInterval(() => {
-        t--;
-        countdown.textContent = t;
-        if (t <= 0) { clearInterval(tick); location.reload(); }
-      }, 1000);
-    }
-  }
-
-  // Start polling after page is interactive
-  fetchLatestSha().then(sha => { knownSha = sha; });
-  setInterval(poll, INTERVAL);
-})();
-</script>
-
-  <!-- Archive Health Dashboard (Mnemosyne, issue #1210) -->
-  <div id="archive-health-dashboard" class="archive-health-dashboard" style="display:none;" aria-label="Archive Health Dashboard">
-    <div class="archive-health-header">
-      <span class="archive-health-title">◈ ARCHIVE HEALTH</span>
-      <button class="archive-health-close" onclick="toggleArchiveHealthDashboard()" aria-label="Close dashboard">✕</button>
-    </div>
-    <div id="archive-health-content" class="archive-health-content"></div>
-  </div>
-
-  <!-- Memory Activity Feed (Mnemosyne) -->
-  <div id="memory-feed" class="memory-feed" style="display:none;">
-    <div class="memory-feed-header">
-      <span class="memory-feed-title">✨ Memory Feed</span>
-      <div class="memory-feed-actions"><button class="memory-feed-clear" onclick="clearMemoryFeed()">Clear</button><button class="memory-feed-toggle" onclick="document.getElementById('memory-feed').style.display='none'">✕</button></div>
-    </div>
-    <div id="memory-feed-list" class="memory-feed-list"></div>
-  <!-- ═══ MNEMOSYNE MEMORY FILTER ═══ -->
-  <div id="memory-filter" class="memory-filter" style="display:none;">
-    <div class="filter-header">
-      <span class="filter-title">⬡ Memory Filter</span>
-      <button class="filter-close" onclick="closeMemoryFilter()">✕</button>
-    </div>
-    <div class="filter-controls">
-      <button class="filter-btn" onclick="setAllFilters(true)">Show All</button>
-      <button class="filter-btn" onclick="setAllFilters(false)">Hide All</button>
-    </div>
-    <div class="filter-list" id="filter-list"></div>
-  </div>
-
-
-  </div>
-
-  <!-- Memory Inspect Panel (Mnemosyne, issue #1227) -->
-  <div id="memory-inspect-panel" class="memory-inspect-panel" style="display:none;" aria-label="Memory Inspect Panel">
-  </div>
-
-  <!-- Memory Connections Panel (Mnemosyne) -->
-  <div id="memory-connections-panel" class="memory-connections-panel" style="display:none;" aria-label="Memory Connections Panel">
-  </div>
-
-<script>
-// ─── MNEMOSYNE: Memory Filter Panel ───────────────────
-function openMemoryFilter() {
-  renderFilterList();
-  document.getElementById('memory-filter').style.display = 'flex';
-}
-function closeMemoryFilter() {
-  document.getElementById('memory-filter').style.display = 'none';
-}
+function openMemoryFilter() { renderFilterList(); document.getElementById('memory-filter').style.display = 'flex'; }
+function closeMemoryFilter() { document.getElementById('memory-filter').style.display = 'none'; }
 function renderFilterList() {
   const counts = SpatialMemory.getMemoryCountByRegion();
   const regions = SpatialMemory.REGIONS;
@@ -614,30 +396,12 @@ function renderFilterList() {
     const colorHex = '#' + region.color.toString(16).padStart(6, '0');
     const item = document.createElement('div');
     item.className = 'filter-item';
-    item.innerHTML = `
-      <div class="filter-item-left">
-        <span class="filter-dot" style="background:${colorHex}"></span>
-        <span class="filter-label">${region.glyph} ${region.label}</span>
-      </div>
-      <div class="filter-item-right">
-        <span class="filter-count">${count}</span>
-        <label class="filter-toggle">
-          <input type="checkbox" ${visible ? 'checked' : ''} 
-                 onchange="toggleRegion('${key}', this.checked)">
-          <span class="filter-slider"></span>
-        </label>
-      </div>
-    `;
+    item.innerHTML = `<div class="filter-item-left"><span class="filter-dot" style="background:${colorHex}"></span><span class="filter-label">${region.glyph} ${region.label}</span></div><div class="filter-item-right"><span class="filter-count">${count}</span><label class="filter-toggle"><input type="checkbox" ${visible ? 'checked' : ''} onchange="toggleRegion('${key}', this.checked)"><span class="filter-slider"></span></label></div>`;
     list.appendChild(item);
   }
 }
-function toggleRegion(category, visible) {
-  SpatialMemory.setRegionVisibility(category, visible);
-}
-function setAllFilters(visible) {
-  SpatialMemory.setAllRegionsVisible(visible);
-  renderFilterList();
-}
+function toggleRegion(category, visible) { SpatialMemory.setRegionVisibility(category, visible); }
+function setAllFilters(visible) { SpatialMemory.setAllRegionsVisible(visible); renderFilterList(); }
 </script>
 </body>
 </html>

multi_user_bridge.py

@@ -501,6 +501,7 @@ class QuestManager:
         self._quests: dict[str, Quest] = {}
         self._counter = 0
         self._lock = threading.Lock()
+        self.load()
 
     def create(self, name: str, description: str,
                objectives: list[str], rewards: list[str]) -> Quest:
@@ -654,6 +655,7 @@ class InventoryManager:
         # room -> list of {name, description, dropped_by, dropped_at}
         self._room_items: dict[str, list[dict]] = {}
         self._lock = threading.Lock()
+        self.load()
 
     def take_item(self, user_id: str, username: str, room: str, item_name: str) -> dict:
         """Pick up an item from a room into user inventory."""
@@ -840,6 +842,7 @@ class GuildManager:
         self._membership: dict[str, str] = {}
         self._counter = 0
         self._lock = threading.Lock()
+        self.load()
 
     def create(self, name: str, leader_id: str, leader_name: str) -> dict:
         """Create a new guild. Returns guild dict or error."""
@@ -1073,6 +1076,7 @@ class CombatManager:
         self._encounters: dict[str, CombatEncounter] = {}  # user_id -> encounter
         self._counter = 0
         self._lock = threading.Lock()
+        self.load()
 
     # ── NPC management ──────────────────────────────────────────────
 
@@ -1409,6 +1413,7 @@ class MagicManager:
         self._spellbooks: dict[str, SpellBook] = {}  # user_id -> SpellBook
         self._counter = 0
         self._lock = threading.Lock()
+        self.load()
 
     # ── Spell registry ───────────────────────────────────────────────
 

tests/boot.test.js

@@ -0,0 +1,20 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const { bootPage } = require('../boot.js');
+const el = (tagName = 'div') => ({ tagName, textContent: '', innerHTML: '', style: {}, children: [], type: '', src: '', appendChild(child) { this.children.push(child); } });
+
+test('bootPage handles file and http origins', () => {
+  const loaderSubtitle = el(), bootMessage = el(), body = el('body');
+  const doc = { body, querySelector: s => s === '.loader-subtitle' ? loaderSubtitle : null, getElementById: id => id === 'boot-message' ? bootMessage : null, createElement: tag => el(tag) };
+  const fileResult = bootPage({ location: { protocol: 'file:' } }, doc);
+  assert.equal(fileResult.mode, 'file');
+  assert.equal(body.children.length, 0);
+  assert.match(loaderSubtitle.textContent, /serve this world over http/i);
+  assert.match(bootMessage.innerHTML, /python3 -m http\.server 8888/i);
+  const httpResult = bootPage({ location: { protocol: 'http:' } }, doc);
+  assert.equal(httpResult.mode, 'module');
+  assert.equal(body.children.length, 1);
+  assert.equal(body.children[0].tagName, 'script');
+  assert.equal(body.children[0].type, 'module');
+  assert.equal(body.children[0].src, './bootstrap.mjs');
+});

tests/bootstrap.test.mjs

@@ -0,0 +1,28 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { readFileSync } from 'node:fs';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(__dirname, '..');
+const load = () => import(pathToFileURL(path.join(repoRoot, 'bootstrap.mjs')).href);
+const el = () => ({ textContent: '', innerHTML: '', style: {}, className: '' });
+
+test('boot shows file guidance', async () => {
+  const { boot } = await load();
+  const subtitle = el(), msg = el(); let calls = 0;
+  const result = await boot({ win: { location: { protocol: 'file:' } }, doc: { getElementById: id => id === 'boot-message' ? msg : null, querySelector: s => s === '.loader-subtitle' ? subtitle : null }, importApp: async () => (calls += 1, {}) });
+  assert.equal(result.mode, 'file'); assert.equal(calls, 0); assert.match(subtitle.textContent, /serve/i); assert.match(msg.innerHTML, /python3 -m http\.server 8888/i);
+});
+
+test('sanitizer repairs synthetic and real app input', async () => {
+  const { sanitizeAppModuleSource, loadAppModule, boot } = await load();
+  const synthetic = ["import ResonanceVisualizer from './nexus/components/resonance-visualizer.js';\\nimport * as THREE from 'three';","const calibrator = boot();\\n  startRenderer();","import { SymbolicEngine, AgentFSM } from './nexus/symbolic-engine.js';","class SymbolicEngine {}","/**\n * Process Evennia-specific fields from Hermes WS messages.\n * Called from handleHermesMessage for any message carrying evennia metadata.\n */\nfunction handleEvenniaEvent(data) {\n  if (data.evennia_command) {\n    addActionStreamEntry('cmd', data.evennia_command);\n  }\n}\n\n\n// ═══════════════════════════════════════════\nfunction handleHermesMessage(data) {\n  if (data.type === 'history') {\n    return;\n  }\n  } else if (data.type && data.type.startsWith('evennia.')) {\n    handleEvenniaEvent(data);\n  // Evennia event bridge — process command/result/room fields if present\n  handleEvenniaEvent(data);\n}","logs.innerHTML = ok;\n    // Actual MemPalace initialization would happen here\n    // For demo purposes we'll just show status\n    statusEl.textContent = 'Connected to local MemPalace';\n    statusEl.style.color = '#4af0c0';\n    \n    // Simulate mining process\n    mineMemPalaceContent(\"Initial knowledge base setup complete\");\n  } catch (err) {\n    console.error('Failed to initialize MemPalace:', err);\n    document.getElementById('mem-palace-status').textContent = 'MemPalace ERROR';\n    document.getElementById('mem-palace-status').style.color = '#ff4466';\n  }\n  try {","  // Auto-mine chat every 30s\n  setInterval(mineMemPalaceContent, 30000);\n    try {\n      const status = mempalace.status();\n      document.getElementById('compression-ratio').textContent = status.compression_ratio.toFixed(1) + 'x';\n      document.getElementById('docs-mined').textContent = status.total_docs;\n      document.getElementById('aaak-size').textContent = status.aaak_size + 'B';\n    } catch (error) {\n      console.error('Failed to update MemPalace status:', error);\n    }\n  }\n\n  // Auto-mine chat history every 30s\n"].join('\n');
+  const fixed = sanitizeAppModuleSource(synthetic), real = sanitizeAppModuleSource(readFileSync(path.join(repoRoot, 'app.js'), 'utf8'));
+  for (const text of [fixed, real]) { assert.doesNotMatch(text, /;\\n|from '\.\/nexus\/symbolic-engine\.js'|\n  \}\n  \} else if|Connected to local MemPalace|setInterval\(mineMemPalaceContent, 30000\);\n    try \{/); }
+  assert.match(fixed, /resonance-visualizer\.js';\nimport \* as THREE/); assert.match(fixed, /boot\(\);\n  startRenderer\(\);/);
+  let calls = 0; const imported = await boot({ win: { location: { protocol: 'http:' } }, doc: { getElementById() { return null; }, querySelector() { return null; }, createElement() { return { type: '', textContent: '', onload: null, onerror: null }; }, body: { appendChild(node) { node.onload(); } } }, importApp: async () => (calls += 1, {}) });
+  assert.equal(imported.mode, 'imported'); assert.equal(calls, 1);
+  const appended = []; const script = await loadAppModule({ doc: { createElement() { return { type: '', textContent: '', onload: null, onerror: null }; }, body: { appendChild(node) { appended.push(node); node.onload(); } } }, fetchImpl: async () => ({ ok: true, text: async () => "import * as THREE from 'three';" }) });
+  assert.equal(appended.length, 1); assert.equal(script, appended[0]); assert.equal(script.type, 'module');
+});

tests/test_agent_memory.py

@@ -0,0 +1,377 @@
+"""
+Tests for agent memory — cross-session agent memory via MemPalace.
+
+Tests the memory module, hooks, and session mining without requiring
+a live ChromaDB instance. Uses mocking for the MemPalace backend.
+"""
+
+from __future__ import annotations
+
+import json
+import tempfile
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from agent.memory import (
+    AgentMemory,
+    MemoryContext,
+    SessionTranscript,
+    create_agent_memory,
+)
+from agent.memory_hooks import MemoryHooks
+
+
+# ---------------------------------------------------------------------------
+# SessionTranscript tests
+# ---------------------------------------------------------------------------
+
+
+class TestSessionTranscript:
+    def test_create(self):
+        t = SessionTranscript(agent_name="test", wing="wing_test")
+        assert t.agent_name == "test"
+        assert t.wing == "wing_test"
+        assert len(t.entries) == 0
+
+    def test_add_user_turn(self):
+        t = SessionTranscript(agent_name="test", wing="wing_test")
+        t.add_user_turn("Hello")
+        assert len(t.entries) == 1
+        assert t.entries[0]["role"] == "user"
+        assert t.entries[0]["text"] == "Hello"
+
+    def test_add_agent_turn(self):
+        t = SessionTranscript(agent_name="test", wing="wing_test")
+        t.add_agent_turn("Response")
+        assert t.entries[0]["role"] == "agent"
+
+    def test_add_tool_call(self):
+        t = SessionTranscript(agent_name="test", wing="wing_test")
+        t.add_tool_call("shell", "ls", "file1 file2")
+        assert t.entries[0]["role"] == "tool"
+        assert t.entries[0]["tool"] == "shell"
+
+    def test_summary_empty(self):
+        t = SessionTranscript(agent_name="test", wing="wing_test")
+        assert t.summary() == "Empty session."
+
+    def test_summary_with_entries(self):
+        t = SessionTranscript(agent_name="test", wing="wing_test")
+        t.add_user_turn("Do something")
+        t.add_agent_turn("Done")
+        t.add_tool_call("shell", "ls", "ok")
+
+        summary = t.summary()
+        assert "USER: Do something" in summary
+        assert "AGENT: Done" in summary
+        assert "TOOL(shell): ok" in summary
+
+    def test_text_truncation(self):
+        t = SessionTranscript(agent_name="test", wing="wing_test")
+        long_text = "x" * 5000
+        t.add_user_turn(long_text)
+        assert len(t.entries[0]["text"]) == 2000
+
+
+# ---------------------------------------------------------------------------
+# MemoryContext tests
+# ---------------------------------------------------------------------------
+
+
+class TestMemoryContext:
+    def test_empty_context(self):
+        ctx = MemoryContext()
+        assert ctx.to_prompt_block() == ""
+
+    def test_unloaded_context(self):
+        ctx = MemoryContext()
+        ctx.loaded = False
+        assert ctx.to_prompt_block() == ""
+
+    def test_loaded_with_data(self):
+        ctx = MemoryContext()
+        ctx.loaded = True
+        ctx.recent_diaries = [
+            {"text": "Fixed PR #1386", "timestamp": "2026-04-13T10:00:00Z"}
+        ]
+        ctx.facts = [
+            {"text": "Bezalel runs on VPS Beta", "score": 0.95}
+        ]
+        ctx.relevant_memories = [
+            {"text": "Changed CI runner", "score": 0.87}
+        ]
+
+        block = ctx.to_prompt_block()
+        assert "Recent Session Summaries" in block
+        assert "Fixed PR #1386" in block
+        assert "Known Facts" in block
+        assert "Bezalel runs on VPS Beta" in block
+        assert "Relevant Past Memories" in block
+
+    def test_loaded_empty(self):
+        ctx = MemoryContext()
+        ctx.loaded = True
+        # No data — should return empty string
+        assert ctx.to_prompt_block() == ""
+
+
+# ---------------------------------------------------------------------------
+# AgentMemory tests (with mocked MemPalace)
+# ---------------------------------------------------------------------------
+
+
+class TestAgentMemory:
+    def test_create(self):
+        mem = AgentMemory(agent_name="bezalel")
+        assert mem.agent_name == "bezalel"
+        assert mem.wing == "wing_bezalel"
+
+    def test_custom_wing(self):
+        mem = AgentMemory(agent_name="bezalel", wing="custom_wing")
+        assert mem.wing == "custom_wing"
+
+    def test_factory(self):
+        mem = create_agent_memory("ezra")
+        assert mem.agent_name == "ezra"
+        assert mem.wing == "wing_ezra"
+
+    def test_unavailable_graceful(self):
+        """Test graceful degradation when MemPalace is unavailable."""
+        mem = AgentMemory(agent_name="test")
+        mem._available = False  # Force unavailable
+
+        # Should not raise
+        ctx = mem.recall_context("test query")
+        assert ctx.loaded is False
+        assert ctx.error == "MemPalace unavailable"
+
+        # remember returns None
+        assert mem.remember("test") is None
+
+        # search returns empty
+        assert mem.search("test") == []
+
+    def test_start_end_session(self):
+        mem = AgentMemory(agent_name="test")
+        mem._available = False
+
+        transcript = mem.start_session()
+        assert isinstance(transcript, SessionTranscript)
+        assert mem._transcript is not None
+
+        doc_id = mem.end_session()
+        assert mem._transcript is None
+
+    def test_remember_graceful_when_unavailable(self):
+        """Test remember returns None when MemPalace is unavailable."""
+        mem = AgentMemory(agent_name="test")
+        mem._available = False
+
+        doc_id = mem.remember("some important fact")
+        assert doc_id is None
+
+    def test_write_diary_from_transcript(self):
+        mem = AgentMemory(agent_name="test")
+        mem._available = False
+
+        transcript = mem.start_session()
+        transcript.add_user_turn("Hello")
+        transcript.add_agent_turn("Hi there")
+
+        # Write diary should handle unavailable gracefully
+        doc_id = mem.write_diary()
+        assert doc_id is None  # MemPalace unavailable
+
+
+# ---------------------------------------------------------------------------
+# MemoryHooks tests
+# ---------------------------------------------------------------------------
+
+
+class TestMemoryHooks:
+    def test_create(self):
+        hooks = MemoryHooks(agent_name="bezalel")
+        assert hooks.agent_name == "bezalel"
+        assert hooks.is_active is False
+
+    def test_session_lifecycle(self):
+        hooks = MemoryHooks(agent_name="test")
+
+        # Force memory unavailable
+        hooks._memory = AgentMemory(agent_name="test")
+        hooks._memory._available = False
+
+        # Start session
+        block = hooks.on_session_start()
+        assert hooks.is_active is True
+        assert block == ""  # No memory available
+
+        # Record turns
+        hooks.on_user_turn("Hello")
+        hooks.on_agent_turn("Hi")
+        hooks.on_tool_call("shell", "ls", "ok")
+
+        # Record decision
+        hooks.on_important_decision("Switched to self-hosted CI")
+
+        # End session
+        doc_id = hooks.on_session_end()
+        assert hooks.is_active is False
+
+    def test_hooks_before_session(self):
+        """Hooks before session start should be no-ops."""
+        hooks = MemoryHooks(agent_name="test")
+        hooks._memory = AgentMemory(agent_name="test")
+        hooks._memory._available = False
+
+        # Should not raise
+        hooks.on_user_turn("Hello")
+        hooks.on_agent_turn("Response")
+
+    def test_hooks_after_session_end(self):
+        """Hooks after session end should be no-ops."""
+        hooks = MemoryHooks(agent_name="test")
+        hooks._memory = AgentMemory(agent_name="test")
+        hooks._memory._available = False
+
+        hooks.on_session_start()
+        hooks.on_session_end()
+
+        # Should not raise
+        hooks.on_user_turn("Late message")
+        doc_id = hooks.on_session_end()
+        assert doc_id is None
+
+    def test_search_during_session(self):
+        hooks = MemoryHooks(agent_name="test")
+        hooks._memory = AgentMemory(agent_name="test")
+        hooks._memory._available = False
+
+        results = hooks.search("some query")
+        assert results == []
+
+
+# ---------------------------------------------------------------------------
+# Session mining tests
+# ---------------------------------------------------------------------------
+
+
+class TestSessionMining:
+    def test_parse_session_file(self):
+        from bin.memory_mine import parse_session_file
+
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".jsonl", delete=False) as f:
+            f.write('{"role": "user", "content": "Hello"}\n')
+            f.write('{"role": "assistant", "content": "Hi there"}\n')
+            f.write('{"role": "tool", "name": "shell", "content": "ls output"}\n')
+            f.write("\n")  # blank line
+            f.write("not json\n")  # malformed
+            path = Path(f.name)
+
+        turns = parse_session_file(path)
+        assert len(turns) == 3
+        assert turns[0]["role"] == "user"
+        assert turns[1]["role"] == "assistant"
+        assert turns[2]["role"] == "tool"
+        path.unlink()
+
+    def test_summarize_session(self):
+        from bin.memory_mine import summarize_session
+
+        turns = [
+            {"role": "user", "content": "Check CI"},
+            {"role": "assistant", "content": "Running CI check..."},
+            {"role": "tool", "name": "shell", "content": "5 tests passed"},
+            {"role": "assistant", "content": "CI is healthy"},
+        ]
+
+        summary = summarize_session(turns, "bezalel")
+        assert "bezalel" in summary
+        assert "Check CI" in summary
+        assert "shell" in summary
+
+    def test_summarize_empty(self):
+        from bin.memory_mine import summarize_session
+
+        assert summarize_session([], "test") == "Empty session."
+
+    def test_find_session_files(self, tmp_path):
+        from bin.memory_mine import find_session_files
+
+        # Create some test files
+        (tmp_path / "session1.jsonl").write_text("{}\n")
+        (tmp_path / "session2.jsonl").write_text("{}\n")
+        (tmp_path / "notes.txt").write_text("not a session")
+
+        files = find_session_files(tmp_path, days=365)
+        assert len(files) == 2
+        assert all(f.suffix == ".jsonl" for f in files)
+
+    def test_find_session_files_missing_dir(self):
+        from bin.memory_mine import find_session_files
+
+        files = find_session_files(Path("/nonexistent/path"), days=7)
+        assert files == []
+
+    def test_mine_session_dry_run(self, tmp_path):
+        from bin.memory_mine import mine_session
+
+        session_file = tmp_path / "test.jsonl"
+        session_file.write_text(
+            '{"role": "user", "content": "Hello"}\n'
+            '{"role": "assistant", "content": "Hi"}\n'
+        )
+
+        result = mine_session(session_file, wing="wing_test", dry_run=True)
+        assert result is None  # dry run doesn't store
+
+    def test_mine_session_empty_file(self, tmp_path):
+        from bin.memory_mine import mine_session
+
+        session_file = tmp_path / "empty.jsonl"
+        session_file.write_text("")
+
+        result = mine_session(session_file, wing="wing_test")
+        assert result is None
+
+
+# ---------------------------------------------------------------------------
+# Integration test — full lifecycle
+# ---------------------------------------------------------------------------
+
+
+class TestFullLifecycle:
+    """Test the full session lifecycle without a real MemPalace backend."""
+
+    def test_full_session_flow(self):
+        hooks = MemoryHooks(agent_name="bezalel")
+
+        # Force memory unavailable
+        hooks._memory = AgentMemory(agent_name="bezalel")
+        hooks._memory._available = False
+
+        # 1. Session start
+        context_block = hooks.on_session_start("What CI issues do I have?")
+        assert isinstance(context_block, str)
+
+        # 2. User asks question
+        hooks.on_user_turn("Check CI pipeline health")
+
+        # 3. Agent uses tool
+        hooks.on_tool_call("shell", "pytest tests/", "12 passed")
+
+        # 4. Agent responds
+        hooks.on_agent_turn("CI pipeline is healthy. All 12 tests passing.")
+
+        # 5. Important decision
+        hooks.on_important_decision("Decided to keep current CI runner", room="forge")
+
+        # 6. More interaction
+        hooks.on_user_turn("Good, check memory integration next")
+        hooks.on_agent_turn("Will test agent.memory module")
+
+        # 7. Session end
+        doc_id = hooks.on_session_end()
+        assert hooks.is_active is False

tests/test_index_html_integrity.py

@@ -0,0 +1,10 @@
+from pathlib import Path
+
+
+def test_index_html_integrity():
+    text = (Path(__file__).resolve().parents[1] / 'index.html').read_text(encoding='utf-8')
+    for marker in ('<<<<<<<', '=======', '>>>>>>>', '```html', '⚠<EFBFBD>'):
+        assert marker not in text
+    assert 'index.html\n```html' not in text
+    for needle in ('View Contribution Policy', 'id="mem-palace-container"', 'id="mempalace-results"', 'id="memory-filter"', 'id="memory-feed"', 'id="memory-inspect-panel"', 'id="memory-connections-panel"'):
+        assert text.count(needle) == 1