feat: add cross-session memory (summarize + inject context)

When a user starts a new session via /new, the previous session's
conversation is summarized by Claude and stored in SQLite. On the next
new session, stored summaries are injected into the system prompt,
giving Claude context about prior work.

- Migration 5: session_memories table
- SessionMemoryModel + SessionMemoryRepository
- SessionMemoryService (summarize + retrieve)
- System prompt injection via memory_context parameter
- Feature flag: ENABLE_SESSION_MEMORY (default false)
- Background summarization on /new (fire-and-forget)
- Unit tests for service and repository

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: sogadaiki

src/bot/orchestrator.py

@@ -464,9 +464,7 @@ async def agentic_start(
         dir_display = f"<code>{current_dir}/</code>"
 
         safe_name = escape_html(user.first_name)
-        welcome_text = t(
-            "welcome", self._lang(), name=safe_name, dir=dir_display
-        )
+        welcome_text = t("welcome", self._lang(), name=safe_name, dir=dir_display)
         await update.message.reply_text(
             f"{welcome_text}{sync_line}",
             parse_mode="HTML",
@@ -476,12 +474,51 @@ async def agentic_new(
         self, update: Update, context: ContextTypes.DEFAULT_TYPE
     ) -> None:
         """Reset session, one-line confirmation."""
+        old_session_id = context.user_data.get("claude_session_id")
+
         context.user_data["claude_session_id"] = None
         context.user_data["session_started"] = True
         context.user_data["force_new_session"] = True
 
         await update.message.reply_text(t("session_reset", self._lang()))
 
+        # Trigger background summarization of the old session
+        if old_session_id and self.settings.enable_session_memory:
+            memory_service = context.bot_data.get("session_memory_service")
+            if memory_service:
+                current_dir = context.user_data.get(
+                    "current_directory", str(self.settings.approved_directory)
+                )
+                asyncio.create_task(
+                    self._summarize_session_safe(
+                        memory_service,
+                        old_session_id,
+                        update.effective_user.id,
+                        str(current_dir),
+                    )
+                )
+
+    async def _summarize_session_safe(
+        self,
+        memory_service: Any,
+        session_id: str,
+        user_id: int,
+        project_path: str,
+    ) -> None:
+        """Summarize session in background, logging errors instead of raising."""
+        try:
+            await memory_service.summarize_session(
+                session_id=session_id,
+                user_id=user_id,
+                project_path=project_path,
+            )
+        except Exception as e:
+            logger.warning(
+                "Background session summarization failed",
+                session_id=session_id,
+                error=str(e),
+            )
+
     async def agentic_status(
         self, update: Update, context: ContextTypes.DEFAULT_TYPE
     ) -> None:
@@ -507,7 +544,13 @@ async def agentic_status(
                 pass
 
         await update.message.reply_text(
-            t("status", self._lang(), dir=dir_display, session=session_status, cost=cost_str)
+            t(
+                "status",
+                self._lang(),
+                dir=dir_display,
+                session=session_status,
+                cost=cost_str,
+            )
         )
 
     def _get_verbose_level(self, context: ContextTypes.DEFAULT_TYPE) -> int:
@@ -526,7 +569,12 @@ async def agentic_verbose(
         if not args:
             current = self._get_verbose_level(context)
             await update.message.reply_text(
-                t("verbose_current", lang, level=current, label=verbose_label(current, lang)),
+                t(
+                    "verbose_current",
+                    lang,
+                    level=current,
+                    label=verbose_label(current, lang),
+                ),
                 parse_mode="HTML",
             )
             return
@@ -671,7 +719,9 @@ async def _on_stream(update_obj: StreamUpdate) -> None:
                         # Collapse to first meaningful line, cap length
                         first_line = text.split("\n", 1)[0].strip()
                         if first_line:
-                            tool_log.append({"kind": "text", "detail": first_line[:120]})
+                            tool_log.append(
+                                {"kind": "text", "detail": first_line[:120]}
+                            )
 
             # Throttle progress message edits to avoid Telegram rate limits
             now = time.time()
@@ -870,7 +920,11 @@ async def agentic_document(
         max_size = 10 * 1024 * 1024
         if document.file_size > max_size:
             await update.message.reply_text(
-                t("file_too_large", lang, size=f"{document.file_size / 1024 / 1024:.1f}")
+                t(
+                    "file_too_large",
+                    lang,
+                    size=f"{document.file_size / 1024 / 1024:.1f}",
+                )
             )
             return
 
@@ -1111,7 +1165,12 @@ async def agentic_repo(
             session_badge = " · session resumed" if session_id else ""
 
             await update.message.reply_text(
-                t("repo_switched", lang, name=escape_html(target_name), badges=f"{git_badge}{session_badge}"),
+                t(
+                    "repo_switched",
+                    lang,
+                    name=escape_html(target_name),
+                    badges=f"{git_badge}{session_badge}",
+                ),
                 parse_mode="HTML",
             )
             return
@@ -1127,7 +1186,9 @@ async def agentic_repo(
                 key=lambda d: d.name,
             )
         except OSError as e:
-            await update.message.reply_text(t("repo_workspace_error", lang, error=str(e)))
+            await update.message.reply_text(
+                t("repo_workspace_error", lang, error=str(e))
+            )
             return
 
         if not entries:

src/claude/facade.py

@@ -9,6 +9,7 @@
 import structlog
 
 from ..config.settings import Settings
+from .memory import SessionMemoryService
 from .sdk_integration import ClaudeResponse, ClaudeSDKManager, StreamUpdate
 from .session import SessionManager
 
@@ -23,11 +24,13 @@ def __init__(
         config: Settings,
         sdk_manager: Optional[ClaudeSDKManager] = None,
         session_manager: Optional[SessionManager] = None,
+        memory_service: Optional[SessionMemoryService] = None,
     ):
         """Initialize Claude integration facade."""
         self.config = config
         self.sdk_manager = sdk_manager or ClaudeSDKManager(config)
         self.session_manager = session_manager
+        self.memory_service = memory_service
 
     async def run_command(
         self,
@@ -78,13 +81,22 @@ async def run_command(
             # For new sessions, don't pass session_id to Claude Code
             claude_session_id = session.session_id if should_continue else None
 
+            # Inject memory context for new sessions
+            memory_context = None
+            if is_new and self.memory_service and self.config.enable_session_memory:
+                memory_context = await self.memory_service.get_memory_context(
+                    user_id=user_id,
+                    project_path=str(working_directory),
+                )
+
             try:
                 response = await self._execute(
                     prompt=prompt,
                     working_directory=working_directory,
                     session_id=claude_session_id,
                     continue_session=should_continue,
                     stream_callback=on_stream,
+                    memory_context=memory_context,
                 )
             except Exception as resume_error:
                 # If resume failed (e.g., session expired/missing on Claude's side),
@@ -109,6 +121,7 @@ async def run_command(
                         session_id=None,
                         continue_session=False,
                         stream_callback=on_stream,
+                        memory_context=memory_context,
                     )
                 else:
                     raise
@@ -152,6 +165,7 @@ async def _execute(
         session_id: Optional[str] = None,
         continue_session: bool = False,
         stream_callback: Optional[Callable] = None,
+        memory_context: Optional[str] = None,
     ) -> ClaudeResponse:
         """Execute command via SDK."""
         return await self.sdk_manager.execute_command(
@@ -160,6 +174,7 @@ async def _execute(
             session_id=session_id,
             continue_session=continue_session,
             stream_callback=stream_callback,
+            memory_context=memory_context,
         )
 
     async def _find_resumable_session(

src/claude/memory.py

@@ -0,0 +1,152 @@
+"""Session memory service for cross-session context.
+
+Summarizes ended sessions and injects context into new sessions.
+"""
+
+from typing import List, Optional
+
+import structlog
+
+from ..config.settings import Settings
+from ..storage.facade import Storage
+from ..storage.models import MessageModel
+from .sdk_integration import ClaudeSDKManager
+
+logger = structlog.get_logger()
+
+_SUMMARIZATION_PROMPT = (
+    "Summarize the following conversation between a user and an AI coding assistant. "
+    "Focus on: (1) what the user was working on, (2) key decisions made, "
+    "(3) problems encountered and how they were resolved, (4) current state of the work. "
+    "Keep the summary concise (3-5 bullet points, max 500 words).\n\n"
+    "Conversation:\n{transcript}"
+)
+
+_MAX_TRANSCRIPT_CHARS = 12000
+
+
+class SessionMemoryService:
+    """Manages session memory: summarization and retrieval."""
+
+    def __init__(
+        self,
+        storage: Storage,
+        sdk_manager: ClaudeSDKManager,
+        config: Settings,
+    ):
+        self.storage = storage
+        self.sdk_manager = sdk_manager
+        self.config = config
+
+    async def summarize_session(
+        self,
+        session_id: str,
+        user_id: int,
+        project_path: str,
+    ) -> Optional[str]:
+        """Summarize a session and store the memory."""
+        messages = await self.storage.messages.get_session_messages(
+            session_id, limit=50
+        )
+
+        if len(messages) < self.config.session_memory_min_messages:
+            logger.info(
+                "Session too short to summarize",
+                session_id=session_id,
+                message_count=len(messages),
+            )
+            return None
+
+        transcript = self._build_transcript(messages)
+        summary = await self._generate_summary(transcript)
+
+        await self.storage.session_memories.save_memory(
+            user_id=user_id,
+            project_path=project_path,
+            session_id=session_id,
+            summary=summary,
+        )
+
+        await self.storage.session_memories.deactivate_old_memories(
+            user_id=user_id,
+            project_path=project_path,
+            keep_count=self.config.session_memory_max_count,
+        )
+
+        logger.info(
+            "Session memory saved",
+            session_id=session_id,
+            summary_length=len(summary),
+        )
+        return summary
+
+    async def get_memory_context(
+        self,
+        user_id: int,
+        project_path: str,
+    ) -> Optional[str]:
+        """Retrieve stored memories formatted for system prompt injection."""
+        memories = await self.storage.session_memories.get_active_memories(
+            user_id=user_id,
+            project_path=project_path,
+            limit=self.config.session_memory_max_count,
+        )
+
+        if not memories:
+            return None
+
+        header = (
+            "## Previous Session Context\n"
+            "Summaries from previous sessions with this user:\n"
+        )
+        sections = []
+        for mem in memories:
+            ts = mem.created_at.isoformat() if mem.created_at else "unknown"
+            sections.append(f"- [{ts}] {mem.summary}")
+
+        context = header + "\n".join(sections)
+
+        # Cap total length to avoid bloating system prompt
+        if len(context) > 2000:
+            context = context[:2000] + "\n... (truncated)"
+
+        return context
+
+    def _build_transcript(self, messages: List[MessageModel]) -> str:
+        """Build a condensed transcript from messages."""
+        # Messages come newest-first from DB, reverse for chronological order
+        messages = list(reversed(messages))
+        parts = []
+        total_len = 0
+
+        for msg in messages:
+            line = f"User: {msg.prompt}"
+            if msg.response:
+                # Truncate long responses
+                resp = (
+                    msg.response[:500] + "..."
+                    if len(msg.response) > 500
+                    else msg.response
+                )
+                line += f"\nAssistant: {resp}"
+
+            if total_len + len(line) > _MAX_TRANSCRIPT_CHARS:
+                break
+            parts.append(line)
+            total_len += len(line)
+
+        return "\n\n".join(parts)
+
+    async def _generate_summary(self, transcript: str) -> str:
+        """Call Claude to generate a summary of the conversation."""
+        from pathlib import Path
+
+        prompt = _SUMMARIZATION_PROMPT.format(transcript=transcript)
+
+        response = await self.sdk_manager.execute_command(
+            prompt=prompt,
+            working_directory=Path(self.config.approved_directory),
+            session_id=None,
+            continue_session=False,
+        )
+        return response.content

src/claude/sdk_integration.py

@@ -251,6 +251,7 @@ async def execute_command(
         session_id: Optional[str] = None,
         continue_session: bool = False,
         stream_callback: Optional[Callable[[StreamUpdate], None]] = None,
+        memory_context: Optional[str] = None,
     ) -> ClaudeResponse:
         """Execute Claude Code command via SDK."""
         start_time = asyncio.get_event_loop().time()
@@ -270,15 +271,18 @@ def _stderr_callback(line: str) -> None:
                 stderr_lines.append(line)
                 logger.debug("Claude CLI stderr", line=line)
 
-            # Build system prompt: persona (if loaded) + directory constraint
+            # Build system prompt: persona + memory context + directory constraint
             dir_constraint = (
                 f"All file operations must stay within {working_directory}. "
                 "Use relative paths."
             )
+            parts = []
             if self._persona_prompt:
-                system_prompt = f"{self._persona_prompt}\n\n---\n\n{dir_constraint}"
-            else:
-                system_prompt = dir_constraint
+                parts.append(self._persona_prompt)
+            if memory_context:
+                parts.append(memory_context)
+            parts.append(dir_constraint)
+            system_prompt = "\n\n---\n\n".join(parts)
 
             # Build Claude Agent options
             cli_path = find_claude_cli(self.config.claude_cli_path)