feat(config): enable memory tool by default

- Change enable_memory_tool default from False to True
- Update tests to reflect new default behavior
- Since this is a personal instance with no other users, opt-out
  makes more sense than opt-in for a requested feature

Dockerfile.oauth

@@ -56,7 +56,7 @@ ENV PATH="/root/.local/bin:${PATH}"
 
 COPY pyproject.toml README.md LICENSE /app/
 COPY nanobot/ /app/nanobot/
-RUN uv pip install --system --no-cache --reinstall /app[mem0] psycopg2-binary
+RUN uv pip install --system --no-cache --reinstall /app psycopg2-binary
 
 ENTRYPOINT ["nanobot"]
 CMD ["gateway"]

nanobot/agent/context.py

@@ -6,10 +6,7 @@ import platform
 from pathlib import Path
 from typing import Any
 
-from loguru import logger
-
 from nanobot.agent.memory import MemoryStore
-from nanobot.agent.memory_mem0 import Mem0MemoryStore, HAS_MEM0
 from nanobot.agent.skills import SkillsLoader
 
 
@@ -22,21 +19,10 @@ class ContextBuilder:
     """
     
     BOOTSTRAP_FILES = ["AGENTS.md", "SOUL.md", "USER.md", "TOOLS.md", "IDENTITY.md"]
-
-    def __init__(self, workspace: Path, mem0_config: dict[str, Any] | None = None):
+    
+    def __init__(self, workspace: Path):
         self.workspace = workspace
-
-        # Choose memory backend based on config
-        if mem0_config and mem0_config.get("enabled") and HAS_MEM0:
-            self.memory = Mem0MemoryStore(workspace, config=mem0_config)
-            self.use_mem0 = True
-            logger.info("ContextBuilder using mem0 for semantic memory")
-        else:
-            if mem0_config and mem0_config.get("enabled"):
-                logger.warning("mem0 enabled but not installed, falling back to MEMORY.md")
-            self.memory = MemoryStore(workspace)
-            self.use_mem0 = False
-
+        self.memory = MemoryStore(workspace)
         self.skills = SkillsLoader(workspace)
     
     def build_system_prompt(self, skill_names: list[str] | None = None) -> str:
@@ -166,18 +152,6 @@ visibility markers will be rejected."""
         system_prompt = self.build_system_prompt(skill_names)
         if channel and chat_id:
             system_prompt += f"\n\n## Current Session\nChannel: {channel}\nChat ID: {chat_id}"
-
-        # Add mem0 semantic memory context (if enabled)
-        if self.use_mem0 and channel and chat_id:
-            user_id = f"{channel}_{chat_id}"
-            memory_context = self.memory.get_memory_context(
-                query=current_message,
-                user_id=user_id,
-                limit=5
-            )
-            if memory_context:
-                system_prompt += f"\n\n{memory_context}"
-
         messages.append({"role": "system", "content": system_prompt})
 
         # History

nanobot/agent/memory_mem0.py

@@ -1,430 +0,0 @@
-"""Mem0-powered memory system for intelligent semantic retrieval."""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import TYPE_CHECKING, Any
-
-from loguru import logger
-
-if TYPE_CHECKING:
-    from nanobot.providers.base import LLMProvider
-    from nanobot.session.manager import Session
-
-try:
-    from mem0 import Memory
-    from mem0.configs.base import MemoryConfig
-    HAS_MEM0 = True
-except ImportError:
-    HAS_MEM0 = False
-    MemoryConfig = None  # type: ignore
-
-
-class Mem0MemoryStore:
-    """
-    Enhanced memory store using mem0 for semantic search and automatic extraction.
-
-    Features:
-    - Multi-level memory (user, session, agent)
-    - Semantic search with embeddings
-    - Automatic memory extraction from conversations
-    - 90% token reduction vs full-context
-    - 91% faster responses
-    """
-
-    def __init__(self, workspace: Path, config: dict[str, Any] | None = None):
-        if not HAS_MEM0:
-            raise ImportError(
-                "mem0 not installed. Install with: pip install mem0ai"
-            )
-
-        self.workspace = workspace
-        self.memory_dir = workspace / "memory"
-        self.memory_dir.mkdir(parents=True, exist_ok=True)
-
-        # Build custom extraction prompt tuned for nanobot conversations
-        from datetime import datetime
-
-        today = datetime.now().strftime("%Y-%m-%d")
-        custom_prompt = f"Extract dated facts from this conversation as JSON: {{\"facts\": [...]}}. Today is {today}.\n\n"
-
-        # Initialize mem0 with optional config + custom prompt
-        # Extract only MemoryConfig-relevant fields
-        raw_config = config if config else {}
-        logger.debug(f"Mem0MemoryStore received config keys: {list(raw_config.keys())}")
-        mem0_cfg_dict = {}
-        for key in ("vector_store", "llm", "embedder", "graph_store", "version"):
-            if key in raw_config:
-                mem0_cfg_dict[key] = raw_config[key]
-        logger.debug(f"Extracted for MemoryConfig: {list(mem0_cfg_dict.keys())}")
-        logger.debug(f"Custom prompt length: {len(custom_prompt)} chars")
-        self.custom_prompt = custom_prompt
-        mem0_cfg_dict["custom_fact_extraction_prompt"] = custom_prompt
-        mem0_config = MemoryConfig(**mem0_cfg_dict)
-        logger.debug(f"MemoryConfig created: vector_store={mem0_config.vector_store.provider if mem0_config.vector_store else None}")
-        self.memory = Memory(config=mem0_config)
-
-        logger.info("Mem0 memory system initialized with custom nanobot prompt")
-
-    def search_memories(
-        self,
-        query: str,
-        user_id: str,
-        limit: int = 5,
-        session_id: str | None = None,
-    ) -> list[dict[str, Any]]:
-        """
-        Search for relevant memories using semantic search.
-
-        Args:
-            query: Search query (user's current message)
-            user_id: User identifier (e.g., "telegram_12345")
-            limit: Max number of memories to return
-            session_id: Optional session-specific memories
-
-        Returns:
-            List of memory dicts with 'memory' and 'score' keys
-        """
-        try:
-            # Search user-level memories
-            user_memories = self.memory.search(
-                query=query,
-                user_id=user_id,
-                limit=limit
-            )
-
-            results = []
-            if user_memories and "results" in user_memories:
-                results.extend(user_memories["results"])
-
-            # Optionally search session-level memories
-            if session_id:
-                session_memories = self.memory.search(
-                    query=query,
-                    user_id=user_id,
-                    metadata={"session_id": session_id},
-                    limit=limit // 2  # Reserve half for session context
-                )
-                if session_memories and "results" in session_memories:
-                    results.extend(session_memories["results"])
-
-            logger.debug(
-                f"Mem0 search: query='{query[:50]}...', found {len(results)} memories"
-            )
-            return results[:limit]  # Limit total results
-
-        except Exception as e:
-            logger.error(f"Mem0 search failed: {e}")
-            return []
-
-    def add_conversation(
-        self,
-        messages: list[dict[str, Any]],
-        user_id: str,
-        session_id: str | None = None,
-    ) -> None:
-        """
-        Add conversation messages to memory for automatic extraction.
-
-        Args:
-            messages: List of message dicts with 'role' and 'content'
-            user_id: User identifier
-            session_id: Optional session identifier for session-level memories
-        """
-        try:
-            metadata = {}
-            if session_id:
-                metadata["session_id"] = session_id
-
-            # mem0 automatically extracts and stores relevant facts
-            result = self.memory.add(
-                messages,
-                user_id=user_id,
-                metadata=metadata if metadata else None
-            )
-
-            facts_count = len(result.get("results", [])) if result else 0
-            logger.debug(
-                f"Mem0 add: {len(messages)} messages for user {user_id}, extracted {facts_count} facts"
-            )
-        except Exception as e:
-            logger.error(f"Mem0 add failed: {e}")
-
-    async def extract_facts(
-        self,
-        messages: list[dict[str, Any]],
-        provider: Any,
-        model: str,
-    ) -> list[str]:
-        """
-        Extract facts from conversation using the main agent's LLM provider.
-
-        Uses the same provider/model already running (e.g. Haiku via Claude Max),
-        avoiding a separate LLM call to mem0's default GPT-nano.
-        """
-        import json as _json
-
-        # Build conversation text for extraction
-        conv_text = ""
-        for msg in messages:
-            role = msg.get("role", "unknown")
-            content = msg.get("content", "")
-            if isinstance(content, str) and content.strip():
-                conv_text += f"{role}: {content}\n\n"
-
-        if not conv_text.strip():
-            return []
-
-        extraction_messages = [
-            {"role": "user", "content": self.custom_prompt + conv_text}
-        ]
-
-        try:
-            response = await provider.chat(
-                messages=extraction_messages,
-                model=model,
-                max_tokens=2000,
-                temperature=0.3,
-            )
-
-            # Parse the JSON response — LLMResponse.content is a string
-            text = response.content or ""
-            # Strip markdown code fences if present
-            text = text.strip()
-            if text.startswith("```"):
-                text = text.split("\n", 1)[1] if "\n" in text else text[3:]
-            if text.endswith("```"):
-                text = text[:-3]
-            text = text.strip()
-
-            data = _json.loads(text)
-            facts = data.get("facts", [])
-            logger.debug(f"Extracted {len(facts)} facts using {model}")
-            return facts
-
-        except Exception as e:
-            logger.error(f"Fact extraction failed: {e}")
-            return []
-
-    def store_facts(
-        self,
-        facts: list[str],
-        user_id: str,
-        session_id: str | None = None,
-    ) -> None:
-        """
-        Store pre-extracted facts in mem0 with infer=False.
-
-        Bypasses mem0's built-in LLM extraction — facts are already
-        in final form from extract_facts().
-        """
-        if not facts:
-            return
-
-        metadata = {}
-        if session_id:
-            metadata["session_id"] = session_id
-
-        stored = 0
-        for fact in facts:
-            try:
-                self.memory.add(
-                    fact,
-                    user_id=user_id,
-                    infer=False,
-                    metadata=metadata if metadata else None,
-                )
-                stored += 1
-            except Exception as e:
-                logger.error(f"Failed to store fact '{fact[:50]}...': {e}")
-
-        logger.info(f"Stored {stored}/{len(facts)} facts for user {user_id}")
-
-    def get_memory_context(
-        self,
-        query: str,
-        user_id: str,
-        limit: int = 5
-    ) -> str:
-        """
-        Get formatted memory context for inclusion in system prompt.
-
-        Args:
-            query: Current user query
-            user_id: User identifier
-            limit: Max memories to include
-
-        Returns:
-            Formatted memory context string
-        """
-        memories = self.search_memories(query, user_id, limit=limit)
-
-        if not memories:
-            return ""
-
-        lines = ["## Relevant Memories"]
-        for i, mem in enumerate(memories, 1):
-            memory_text = mem.get("memory", "")
-            # Include score if available for debugging
-            score = mem.get("score", "")
-            score_str = f" (relevance: {score:.2f})" if score else ""
-            lines.append(f"{i}. {memory_text}{score_str}")
-
-        return "\n".join(lines)
-
-    def update_memory(self, memory_id: str, data: dict[str, Any]) -> None:
-        """Update a specific memory by ID."""
-        try:
-            self.memory.update(memory_id, data)
-            logger.debug(f"Mem0 update: memory_id={memory_id}")
-        except Exception as e:
-            logger.error(f"Mem0 update failed: {e}")
-
-    def delete_memory(self, memory_id: str) -> None:
-        """Delete a specific memory by ID."""
-        try:
-            self.memory.delete(memory_id)
-            logger.debug(f"Mem0 delete: memory_id={memory_id}")
-        except Exception as e:
-            logger.error(f"Mem0 delete failed: {e}")
-
-    def get_all_memories(self, user_id: str) -> list[dict[str, Any]]:
-        """Get all memories for a user."""
-        try:
-            result = self.memory.get_all(user_id=user_id)
-            return result.get("results", []) if result else []
-        except Exception as e:
-            logger.error(f"Mem0 get_all failed: {e}")
-            return []
-
-    async def consolidate(
-        self,
-        session: Session,
-        provider: LLMProvider,
-        model: str,
-        *,
-        archive_all: bool = False,
-        memory_window: int = 50,
-    ) -> bool:
-        """
-        Consolidate session messages into mem0 memory.
-
-        Facts are extracted using the main agent's LLM provider, then stored with infer=False.
-
-        Returns True on success.
-        """
-        try:
-            # Extract user_id from session key (e.g., "telegram:12345" -> "telegram_12345")
-            user_id = session.key.replace(":", "_")
-
-            # Determine which messages to consolidate
-            if archive_all:
-                messages_to_add = session.messages
-                logger.info(
-                    f"Mem0 consolidation (archive_all): {len(messages_to_add)} messages"
-                )
-            else:
-                keep_count = memory_window // 2
-                if len(session.messages) <= keep_count:
-                    return True
-
-                # Get unconsolidated messages
-                start_idx = session.last_consolidated
-                end_idx = len(session.messages) - keep_count
-
-                if end_idx <= start_idx:
-                    return True
-
-                messages_to_add = session.messages[start_idx:end_idx]
-
-                if not messages_to_add:
-                    return True
-
-                logger.info(
-                    f"Mem0 consolidation: {len(messages_to_add)} to consolidate, "
-                    f"{keep_count} keep"
-                )
-
-            # Convert to mem0 format with intelligent filtering
-            mem0_messages = []
-            for msg in messages_to_add:
-                role = msg.get("role")
-                content = msg.get("content")
-
-                # Keep tool results but truncate long ones — they often contain
-                # the actual substance (file reads, search results, web pages).
-                # The extraction prompt handles ignoring code/JSON noise.
-                if role == "tool":
-                    if isinstance(content, list):
-                        text_parts = [
-                            block.get("content", "") if isinstance(block, dict) else str(block)
-                            for block in content
-                        ]
-                        content = " ".join(text_parts).strip()
-                    if isinstance(content, str) and len(content) > 2000:
-                        content = content[:2000]
-                    if not content or (isinstance(content, str) and len(content.strip()) < 10):
-                        continue
-                    mem0_messages.append({"role": "user", "content": content})
-                    continue
-
-                # Skip system messages — they're boilerplate instructions, not facts
-                if role == "system":
-                    continue
-
-                # Skip messages with no content
-                if not content:
-                    continue
-
-                # Normalize assistant message content: extract text from Anthropic list format
-                if role == "assistant" and isinstance(content, list):
-                    # Anthropic format: list of {type: "text"|"tool_use", text: "..."} blocks
-                    text_parts = [
-                        block.get("text", "")
-                        for block in content
-                        if isinstance(block, dict) and block.get("type") == "text"
-                    ]
-                    content = " ".join(text_parts).strip()
-                    if not content:
-                        continue  # Skip if assistant only called tools with no text explanation
-
-                # Normalize user message content (could also be a list in some formats)
-                if isinstance(content, list):
-                    text_parts = [
-                        block.get("text", "") if isinstance(block, dict) else str(block)
-                        for block in content
-                    ]
-                    content = " ".join(text_parts).strip()
-                    if not content:
-                        continue
-
-                # Skip trivially short messages (commands like "/new")
-                if len(content.strip()) < 10:
-                    continue
-
-                mem0_messages.append({
-                    "role": role,
-                    "content": content
-                })
-
-            if mem0_messages:
-                # Extract facts using the main agent's LLM (already paid for),
-                # then store with infer=False to bypass mem0's GPT-nano
-                facts = await self.extract_facts(mem0_messages, provider, model)
-                self.store_facts(facts, user_id=user_id, session_id=session.key)
-
-            # Update consolidation marker
-            if archive_all:
-                session.last_consolidated = len(session.messages)
-            else:
-                session.last_consolidated = end_idx
-
-            logger.info(
-                f"Mem0 consolidation done: {len(session.messages)} messages, "
-                f"last_consolidated={session.last_consolidated}"
-            )
-            return True
-
-        except Exception:
-            logger.exception("Mem0 consolidation failed")
-            return False

nanobot/agent/skills.py

@@ -167,10 +167,10 @@ class SkillsLoader:
         return content
     
     def _parse_nanobot_metadata(self, raw: str) -> dict:
-        """Parse skill metadata JSON from frontmatter (supports nanobot, clawdbot, and openclaw keys)."""
+        """Parse skill metadata JSON from frontmatter (supports nanobot and openclaw keys)."""
         try:
             data = json.loads(raw)
-            return (data.get("nanobot") or data.get("clawdbot") or data.get("openclaw") or {}) if isinstance(data, dict) else {}
+            return (data.get("nanobot") or data.get("openclaw") or data.get("clawdbot") or {}) if isinstance(data, dict) else {}
         except (json.JSONDecodeError, TypeError):
             return {}
     

nanobot/bus/queue.py

@@ -1,7 +1,9 @@
 """Async message queue for decoupled channel-agent communication."""
 
 import asyncio
-from typing import Awaitable, Callable
+from typing import Callable, Awaitable
+
+from loguru import logger
 
 from nanobot.bus.events import InboundMessage, OutboundMessage
 
@@ -9,30 +11,30 @@ from nanobot.bus.events import InboundMessage, OutboundMessage
 class MessageBus:
     """
     Async message bus that decouples chat channels from the agent core.
-
+    
     Channels push messages to the inbound queue, and the agent processes
     them and pushes responses to the outbound queue.
     """
-
+    
     def __init__(self):
         self.inbound: asyncio.Queue[InboundMessage] = asyncio.Queue()
         self.outbound: asyncio.Queue[OutboundMessage] = asyncio.Queue()
         self._outbound_subscribers: dict[str, list[Callable[[OutboundMessage], Awaitable[None]]]] = {}
         self._correlation_store: dict[str, asyncio.Future] = {}
         self._running = False
-
+    
     async def publish_inbound(self, msg: InboundMessage) -> None:
         """Publish a message from a channel to the agent."""
         await self.inbound.put(msg)
-
+    
     async def consume_inbound(self) -> InboundMessage:
         """Consume the next inbound message (blocks until available)."""
         return await self.inbound.get()
-
+    
     async def publish_outbound(self, msg: OutboundMessage) -> None:
         """Publish a response from the agent to channels."""
         await self.outbound.put(msg)
-
+    
     async def consume_outbound(self) -> OutboundMessage:
         """Consume the next outbound message (blocks until available)."""
         return await self.outbound.get()
@@ -89,12 +91,12 @@ class MessageBus:
     def stop(self) -> None:
         """Stop the dispatcher loop."""
         self._running = False
-
+    
     @property
     def inbound_size(self) -> int:
         """Number of pending inbound messages."""
         return self.inbound.qsize()
-
+    
     @property
     def outbound_size(self) -> int:
         """Number of pending outbound messages."""

nanobot/channels/manager.py

@@ -210,15 +210,15 @@ class ChannelManager:
                     timeout=1.0
                 )
 
-                # Resolve any pending correlation (hook request-response)
-                self.bus.resolve_correlation(msg)
-
                 if msg.metadata.get("_progress"):
                     if msg.metadata.get("_tool_hint") and not self.config.channels.send_tool_hints:
                         continue
                     if not msg.metadata.get("_tool_hint") and not self.config.channels.send_progress:
                         continue
 
+                # Resolve any pending correlation (hook request-response)
+                self.bus.resolve_correlation(msg)
+
                 channel = self.channels.get(msg.channel)
                 if channel:
                     try:

nanobot/config/schema.py

@@ -1,7 +1,7 @@
 """Configuration schema using Pydantic."""
 
 from pathlib import Path
-from typing import Any, Literal
+from typing import Literal
 
 from pydantic import BaseModel, Field, ConfigDict
 from pydantic.alias_generators import to_camel
@@ -310,7 +310,7 @@ class GatewayConfig(Base):
     heartbeat: HeartbeatConfig = Field(default_factory=HeartbeatConfig)
 
 
-class HooksConfig(BaseModel):
+class HooksConfig(Base):
     """Webhook endpoint configuration."""
     enabled: bool = False
     tokens: dict[str, str] = Field(default_factory=dict)  # Named tokens: {name: secret}
@@ -330,7 +330,7 @@ class HooksConfig(BaseModel):
         return bool(self.tokens)
 
 
-class WebSearchConfig(BaseModel):
+class WebSearchConfig(Base):
     """Web search tool configuration."""
 
     api_key: str = ""  # Brave Search API key
@@ -361,17 +361,6 @@ class MCPServerConfig(Base):
     tool_timeout: int = 30  # Seconds before a tool call is cancelled
 
 
-class Mem0Config(Base):
-    """Mem0 memory system configuration."""
-
-    enabled: bool = False  # If true, use mem0 for semantic memory instead of simple MEMORY.md
-    api_key: str = ""  # Optional: mem0 cloud API key (leave empty for self-hosted)
-    search_limit: int = 5  # Max memories to retrieve per query
-    llm: str = ""  # Optional: LLM for memory extraction (default: gpt-4.1-nano-2025-04-14)
-    embedder: str = ""  # Optional: Embedding model (default: mem0's default)
-    vector_store: dict[str, Any] = Field(default_factory=dict)  # Vector store config (e.g., {"provider": "qdrant", "config": {...}})
-
-
 class ToolsConfig(Base):
     """Tools configuration."""
 
@@ -379,7 +368,6 @@ class ToolsConfig(Base):
     exec: ExecToolConfig = Field(default_factory=ExecToolConfig)
     restrict_to_workspace: bool = False  # If true, restrict all tool access to workspace directory
     enable_memory_tool: bool = True  # If true, enable Anthropic's native memory tool
-    mem0: Mem0Config = Field(default_factory=Mem0Config)  # Mem0 semantic memory configuration
     mcp_servers: dict[str, MCPServerConfig] = Field(default_factory=dict)
 
 

nanobot/providers/anthropic_oauth.py

@@ -316,11 +316,6 @@ class AnthropicOAuthProvider(LLMProvider):
             headers.get("anthropic-beta", "none"),
         )
 
-        # Debug: Log tool names for diagnostic purposes
-        if payload.get("tools"):
-            tool_names = [t.get("name", "unnamed") for t in payload["tools"]]
-            logger.debug(f"Tool names in request: {tool_names}")
-
         response = await client.post(
             self._get_api_url(),
             headers=headers,
@@ -417,10 +412,8 @@ class AnthropicOAuthProvider(LLMProvider):
             )
             return self._parse_response(response)
         except Exception as e:
-            logger.exception("Exception in chat():")
-            error_msg = f"{type(e).__name__}: {str(e)}" if str(e) else f"{type(e).__name__} (no message)"
             return LLMResponse(
-                content=f"Error calling LLM: {error_msg}",
+                content=f"Error calling LLM: {str(e)}",
                 finish_reason="error",
             )
 

nanobot/session/manager.py

@@ -1,7 +1,6 @@
 """Session management for conversation history."""
 
 import json
-import shutil
 from pathlib import Path
 from dataclasses import dataclass, field
 from datetime import datetime
@@ -16,20 +15,15 @@ from nanobot.utils.helpers import ensure_dir, safe_filename
 class Session:
     """
     A conversation session.
-
+    
     Stores messages in JSONL format for easy reading and persistence.
-
-    Important: Messages are append-only for LLM cache efficiency.
-    The consolidation process writes summaries to MEMORY.md/HISTORY.md
-    but does NOT modify the messages list or get_history() output.
     """
-
+    
     key: str  # channel:chat_id
     messages: list[dict[str, Any]] = field(default_factory=list)
     created_at: datetime = field(default_factory=datetime.now)
     updated_at: datetime = field(default_factory=datetime.now)
     metadata: dict[str, Any] = field(default_factory=dict)
-    last_consolidated: int = 0  # Number of messages already consolidated to files
     
     def add_message(self, role: str, content: str, **kwargs: Any) -> None:
         """Add a message to the session."""
@@ -71,34 +65,27 @@ class Session:
         ]
     
     def clear(self) -> None:
-        """Clear all messages and reset session to initial state."""
+        """Clear all messages in the session."""
         self.messages = []
-        self.last_consolidated = 0
         self.updated_at = datetime.now()
 
 
 class SessionManager:
     """
     Manages conversation sessions.
-
+    
     Sessions are stored as JSONL files in the sessions directory.
     """
-
+    
     def __init__(self, workspace: Path):
         self.workspace = workspace
-        self.sessions_dir = ensure_dir(self.workspace / "sessions")
-        self.legacy_sessions_dir = Path.home() / ".nanobot" / "sessions"
+        self.sessions_dir = ensure_dir(Path.home() / ".nanobot" / "sessions")
         self._cache: dict[str, Session] = {}
     
     def _get_session_path(self, key: str) -> Path:
         """Get the file path for a session."""
         safe_key = safe_filename(key.replace(":", "_"))
         return self.sessions_dir / f"{safe_key}.jsonl"
-
-    def _get_legacy_session_path(self, key: str) -> Path:
-        """Legacy global session path (~/.nanobot/sessions/)."""
-        safe_key = safe_filename(key.replace(":", "_"))
-        return self.legacy_sessions_dir / f"{safe_key}.jsonl"
     
     def get_or_create(self, key: str) -> Session:
         """
@@ -110,9 +97,11 @@ class SessionManager:
         Returns:
             The session.
         """
+        # Check cache
         if key in self._cache:
             return self._cache[key]
         
+        # Try to load from disk
         session = self._load(key)
         if session is None:
             session = Session(key=key)
@@ -123,72 +112,78 @@ class SessionManager:
     def _load(self, key: str) -> Session | None:
         """Load a session from disk."""
         path = self._get_session_path(key)
-        if not path.exists():
-            legacy_path = self._get_legacy_session_path(key)
-            if legacy_path.exists():
-                try:
-                    shutil.move(str(legacy_path), str(path))
-                    logger.info("Migrated session {} from legacy path", key)
-                except Exception:
-                    logger.exception("Failed to migrate session {}", key)
-
+        
         if not path.exists():
             return None
-
+        
         try:
             messages = []
             metadata = {}
             created_at = None
-            last_consolidated = 0
-
-            with open(path, encoding="utf-8") as f:
+            
+            with open(path) as f:
                 for line in f:
                     line = line.strip()
                     if not line:
                         continue
-
+                    
                     data = json.loads(line)
-
+                    
                     if data.get("_type") == "metadata":
                         metadata = data.get("metadata", {})
                         created_at = datetime.fromisoformat(data["created_at"]) if data.get("created_at") else None
-                        last_consolidated = data.get("last_consolidated", 0)
                     else:
                         messages.append(data)
-
+            
             return Session(
                 key=key,
                 messages=messages,
                 created_at=created_at or datetime.now(),
-                metadata=metadata,
-                last_consolidated=last_consolidated
+                metadata=metadata
             )
         except Exception as e:
-            logger.warning("Failed to load session {}: {}", key, e)
+            logger.warning(f"Failed to load session {key}: {e}")
             return None
     
     def save(self, session: Session) -> None:
         """Save a session to disk."""
         path = self._get_session_path(session.key)
-
-        with open(path, "w", encoding="utf-8") as f:
+        
+        with open(path, "w") as f:
+            # Write metadata first
             metadata_line = {
                 "_type": "metadata",
-                "key": session.key,
                 "created_at": session.created_at.isoformat(),
                 "updated_at": session.updated_at.isoformat(),
-                "metadata": session.metadata,
-                "last_consolidated": session.last_consolidated
+                "metadata": session.metadata
             }
-            f.write(json.dumps(metadata_line, ensure_ascii=False) + "\n")
+            f.write(json.dumps(metadata_line) + "\n")
+            
+            # Write messages
             for msg in session.messages:
-                f.write(json.dumps(msg, ensure_ascii=False) + "\n")
-
+                f.write(json.dumps(msg) + "\n")
+        
         self._cache[session.key] = session
     
-    def invalidate(self, key: str) -> None:
-        """Remove a session from the in-memory cache."""
+    def delete(self, key: str) -> bool:
+        """
+        Delete a session.
+        
+        Args:
+            key: Session key.
+        
+        Returns:
+            True if deleted, False if not found.
+        """
+        # Remove from cache
         self._cache.pop(key, None)
+        
+        # Remove file
+        path = self._get_session_path(key)
+        if path.exists():
+            path.unlink()
+            return True
+        return False
     
     def list_sessions(self) -> list[dict[str, Any]]:
         """
@@ -202,14 +197,13 @@ class SessionManager:
         for path in self.sessions_dir.glob("*.jsonl"):
             try:
                 # Read just the metadata line
-                with open(path, encoding="utf-8") as f:
+                with open(path) as f:
                     first_line = f.readline().strip()
                     if first_line:
                         data = json.loads(first_line)
                         if data.get("_type") == "metadata":
-                            key = data.get("key") or path.stem.replace("_", ":", 1)
                             sessions.append({
-                                "key": key,
+                                "key": path.stem.replace("_", ":"),
                                 "created_at": data.get("created_at"),
                                 "updated_at": data.get("updated_at"),
                                 "path": str(path)

pyproject.toml

@@ -47,9 +47,6 @@ dev = [
     "pytest-asyncio>=0.21.0",
     "ruff>=0.1.0",
 ]
-mem0 = [
-    "mem0ai>=0.1.0",
-]
 
 [project.scripts]
 nanobot = "nanobot.cli.commands:app"

tests/test_bash_heredoc.py

@@ -1,68 +0,0 @@
-"""Test that bash tool handles heredoc commands correctly.
-
-Reproduces the bug where `; echo '<<exit>>'` appended on the same line
-as a heredoc terminator prevents bash from recognizing the terminator,
-causing the session to hang forever.
-"""
-
-import asyncio
-import pytest
-from nanobot.agent.tools.anthropic.bash import BashTool20250124
-
-
-@pytest.mark.asyncio
-async def test_heredoc_command():
-    """Heredoc commands must complete without hanging."""
-    tool = BashTool20250124()
-
-    # Simple command works
-    result = await tool(command="echo hello")
-    assert result.output == "hello"
-
-    # Heredoc command — this is the exact pattern that caused the hang
-    result = await asyncio.wait_for(
-        tool(command="cat << 'EOF'\nline1\nline2\nEOF"),
-        timeout=5.0,
-    )
-    assert "line1" in result.output
-    assert "line2" in result.output
-
-
-@pytest.mark.asyncio
-async def test_heredoc_append_to_file():
-    """Heredoc append (the exact pattern the LLM uses) must work."""
-    tool = BashTool20250124()
-
-    result = await asyncio.wait_for(
-        tool(command="cat >> /tmp/test_heredoc_bash.txt << 'EOF'\nhello world\nEOF"),
-        timeout=5.0,
-    )
-    # Should complete without error
-    assert result.error is None or result.error == ""
-
-    # Verify the file was written
-    result2 = await tool(command="cat /tmp/test_heredoc_bash.txt")
-    assert "hello world" in result2.output
-
-    # Cleanup
-    await tool(command="rm -f /tmp/test_heredoc_bash.txt")
-
-
-@pytest.mark.asyncio
-async def test_regular_commands_still_work():
-    """Ensure regular commands still work after the fix."""
-    tool = BashTool20250124()
-
-    # Semicolons in commands
-    result = await tool(command="echo a; echo b")
-    assert "a" in result.output
-    assert "b" in result.output
-
-    # Multiline script
-    result = await tool(command="for i in 1 2 3; do echo $i; done")
-    assert "1" in result.output
-    assert "3" in result.output
-
-    # Command with exit code
-    result = await tool(command="true")
-    assert result.output == "(no output)" or result.output is not None

tests/test_bash_tool.py

@@ -40,7 +40,7 @@ async def test_bash_tool_restart():
 
     # Restart
     result = await tool(restart=True)
-    assert "restarted" in (result.system or result.output or "").lower()
+    assert "restarted" in result.output.lower()
 
     # Variable should be gone
     result2 = await tool(command="echo $TEST_VAR")