aline-ai 0.2.5__py3-none-any.whl → 0.2.6__py3-none-any.whl

{aline_ai-0.2.5.dist-info → aline_ai-0.2.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aline-ai
-Version: 0.2.5
+Version: 0.2.6
 Summary: Shared AI memory; everyone knows everything in teams
 Author: Sharemind
 License: MIT

{aline_ai-0.2.5.dist-info → aline_ai-0.2.6.dist-info}/RECORD

@@ -1,17 +1,17 @@
-aline_ai-0.2.5.dist-info/licenses/LICENSE,sha256=H8wTqV5IF1oHw_HbBtS1PSDU8G_q81yblEIL_JfV8Vo,1077
-realign/__init__.py,sha256=zx1q8jbbAtSFt2eDYbUqaqss8LohQnvmI4gRY_HWVWY,68
+aline_ai-0.2.6.dist-info/licenses/LICENSE,sha256=H8wTqV5IF1oHw_HbBtS1PSDU8G_q81yblEIL_JfV8Vo,1077
+realign/__init__.py,sha256=kYl1kB-KlgNv4t7nc-BFE8PSabtXYIzbte8yU4ZaTvY,68
 realign/claude_detector.py,sha256=NLxI0zJWcqNxNha9jAy9AslTMwHKakCc9yPGdkrbiFE,3028
 realign/cli.py,sha256=WSdT9zpHLswBeDPjb5M_U2cvhIm7yrgnXPDyb7vD-jg,2798
 realign/codex_detector.py,sha256=RI3JbZgebrhoqpRfTBMfclYCAISN7hZAHVW3bgftJpU,4428
 realign/config.py,sha256=jarinbr0mA6e5DmgY19b_VpMnxk6SOYTwyvB9luq0ww,7207
 realign/file_lock.py,sha256=-9c3tMdMj_ZxmasK5y6hV9Gfo6KDsSO3Q7PXiTBhsu4,3369
-realign/hooks.py,sha256=GzkEbW35-ifwAilYbVxDpNURZ_7XrF68DTqDSQ8v7fE,50670
+realign/hooks.py,sha256=ZckwB_W7nx5WO_JfyqXP78peL-HDiefoZWE43yBhRtI,63854
 realign/logging_config.py,sha256=KvkKktF-bkUu031y9vgUoHpsbnOw7ud25jhpzliNZwA,4929
 realign/mcp_server.py,sha256=Q82nuEm6LF17eKUZfHHt6exQjzOWbbBmGXLYwNIGnoo,21002
-realign/mcp_watcher.py,sha256=ffYOXDLuf9T6Kab3CdGNAOY3DBlAbjZrVrSjM5RdYGU,26828
+realign/mcp_watcher.py,sha256=XmpaX5X8Dm91RCZKC5PoGPNaF1ssUcpRKOe4zWPJ-0A,26751
 realign/redactor.py,sha256=FizaGSdW-QTBAQl4h-gtmMpx2mFrfd2a5DoPEPyLfRg,9989
 realign/commands/__init__.py,sha256=caHulsUeguKyy2ZIIa9hVwzGwNHfIbeHwZIC67C8gnI,213
-realign/commands/auto_commit.py,sha256=jgjAYZHqN34NmQkncZg3Vtwsl3MyAlsvucxEBwUj7ko,7450
+realign/commands/auto_commit.py,sha256=3QMlUerXlIJgiwN1BKH6U--qwEqZupzoLPgyAivLr1A,7899
 realign/commands/commit.py,sha256=mlwrv5nfTRY17WlcAdiJKKGh5uM7dGvT7sMxhdbsfkw,12605
 realign/commands/config.py,sha256=iiu7usqw00djKZja5bx0iDH8DB0vU2maUPMkXLdgXwI,6609
 realign/commands/hide.py,sha256=i_XLsmsB4duLKNIA-eRAUvniS4N6GdQUyfN92CGndEA,34138
@@ -21,8 +21,8 @@ realign/commands/review.py,sha256=3TY6F87RGNEbutxvUr_konr24-gCyj5fmD9usd3n4-U,15
 realign/commands/search.py,sha256=xTWuX0lpjQPX8cen0ewl-BNF0FeWgjMwN06bdeesED8,18770
 realign/commands/session_utils.py,sha256=L1DwZIGCOBirp6tkAswACJEeDa6i9aAAfsialAs4rRY,864
 realign/commands/show.py,sha256=A9LvhOBcY6_HoI76irPB2rBOSgdftBuX2uZiO8IwNoU,16338
-aline_ai-0.2.5.dist-info/METADATA,sha256=Deqqt3Tjs66ZW_76UA7itCXB_YLnhcO-rGa6vN_6vys,1437
-aline_ai-0.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aline_ai-0.2.5.dist-info/entry_points.txt,sha256=h-NocHDzSueXfsepHTIdRPNQzhNZQPAztJfldd-mQTE,202
-aline_ai-0.2.5.dist-info/top_level.txt,sha256=yIL3s2xv9nf1GwD5n71Aq_JEIV4AfzCIDNKBzewuRm4,8
-aline_ai-0.2.5.dist-info/RECORD,,
+aline_ai-0.2.6.dist-info/METADATA,sha256=UqZkpvO5NlU8KpL2KN7DezSmaWMTiS_Lrbcs-_xHmtg,1437
+aline_ai-0.2.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aline_ai-0.2.6.dist-info/entry_points.txt,sha256=h-NocHDzSueXfsepHTIdRPNQzhNZQPAztJfldd-mQTE,202
+aline_ai-0.2.6.dist-info/top_level.txt,sha256=yIL3s2xv9nf1GwD5n71Aq_JEIV4AfzCIDNKBzewuRm4,8
+aline_ai-0.2.6.dist-info/RECORD,,

realign/__init__.py

@@ -1,3 +1,3 @@
 """Aline - AI Agent Chat Session Tracker."""
 
-__version__ = "0.2.5"
+__version__ = "0.2.6"

realign/commands/auto_commit.py

@@ -85,10 +85,16 @@ def get_session_mtimes(repo_root: Path) -> dict:
 
 
 def generate_commit_message() -> str:
-    """Generate an automatic commit message."""
-    from datetime import datetime
-    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    return f"chore: Auto-commit MCP session ({timestamp})"
+    """
+    Generate an automatic commit message.
+
+    DEPRECATED: This function is no longer used for auto-commits.
+    The commit message is now generated by the prepare-commit-msg hook
+    with LLM-based summaries and keywords.
+
+    Returns empty string to let the hook generate the message.
+    """
+    return ""
 
 
 def auto_commit_once(repo_root: Path, message: Optional[str] = None, silent: bool = False) -> bool:
@@ -97,12 +103,13 @@ def auto_commit_once(repo_root: Path, message: Optional[str] = None, silent: boo
 
     Args:
         repo_root: Path to the repository root
-        message: Custom commit message (auto-generated if not provided)
+        message: Custom commit message (if provided, will be used as-is and aline summary appended)
         silent: If True, suppress console output (for watcher mode)
 
     Returns:
         True if commit was successful, False otherwise
     """
+    # If user provided a custom message, use it; otherwise let the hook generate it
     commit_message = message or generate_commit_message()
 
     try:
@@ -124,7 +131,11 @@ def auto_commit_once(repo_root: Path, message: Optional[str] = None, silent: boo
 
         if result.returncode == 0:
             if not silent:
-                console.print(f"[green]✓[/green] Auto-committed: {commit_message}")
+                # If message was provided by user, show it; otherwise indicate auto-commit
+                if message:
+                    console.print(f"[green]✓[/green] Auto-committed: {message}")
+                else:
+                    console.print("[green]✓[/green] Auto-committed successfully")
             return True
         else:
             # Check if it's just "no changes" error

realign/hooks.py

@@ -356,6 +356,115 @@ def find_latest_session(history_path: Path, explicit_path: Optional[str] = None)
     return max(session_files, key=lambda p: p.stat().st_mtime)
 
 
+def filter_session_content(content: str) -> Tuple[str, str, str]:
+    """
+    Filter session content to extract meaningful information for LLM summarization.
+
+    Filters out exploratory operations (Read, Grep, Glob) and technical details,
+    keeping only user requests, AI responses, and code changes.
+
+    Args:
+        content: Raw text content of new session additions
+
+    Returns:
+        Tuple of (user_messages, assistant_replies, code_changes)
+    """
+    if not content or not content.strip():
+        return "", "", ""
+
+    user_messages = []
+    assistant_replies = []
+    code_changes = []
+
+    lines = content.strip().split("\n")
+
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+
+        try:
+            obj = json.loads(line)
+
+            # Extract user messages and tool results
+            if obj.get("type") == "user":
+                msg = obj.get("message", {})
+                if isinstance(msg, dict):
+                    content_data = msg.get("content", "")
+                    if isinstance(content_data, str) and content_data.strip():
+                        user_messages.append(content_data.strip())
+                    elif isinstance(content_data, list):
+                        # Extract text from content list
+                        for item in content_data:
+                            if isinstance(item, dict):
+                                if item.get("type") == "text":
+                                    text = item.get("text", "").strip()
+                                    if text:
+                                        user_messages.append(text)
+                                # Extract code changes from tool results
+                                elif item.get("type") == "tool_result":
+                                    tool_use_result = obj.get("toolUseResult", {})
+                                    if "oldString" in tool_use_result and "newString" in tool_use_result:
+                                        # This is an Edit operation
+                                        new_string = tool_use_result.get("newString", "")
+                                        if new_string:
+                                            code_changes.append(f"Edit: {new_string[:300]}")
+                                    elif "content" in tool_use_result and "filePath" in tool_use_result:
+                                        # This is a Write operation
+                                        new_content = tool_use_result.get("content", "")
+                                        if new_content:
+                                            code_changes.append(f"Write: {new_content[:300]}")
+
+            # Extract assistant text replies (not tool use)
+            elif obj.get("type") == "assistant":
+                msg = obj.get("message", {})
+                if isinstance(msg, dict):
+                    content_data = msg.get("content", [])
+                    if isinstance(content_data, list):
+                        for item in content_data:
+                            if isinstance(item, dict):
+                                # Only extract text blocks, skip tool_use blocks
+                                if item.get("type") == "text":
+                                    text = item.get("text", "").strip()
+                                    if text:
+                                        assistant_replies.append(text)
+                                # Extract code changes from Edit/Write tool uses
+                                elif item.get("type") == "tool_use":
+                                    tool_name = item.get("name", "")
+                                    if tool_name in ("Edit", "Write"):
+                                        params = item.get("input", {})
+                                        if tool_name == "Edit":
+                                            new_string = params.get("new_string", "")
+                                            if new_string:
+                                                code_changes.append(f"Edit: {new_string[:200]}")
+                                        elif tool_name == "Write":
+                                            new_content = params.get("content", "")
+                                            if new_content:
+                                                code_changes.append(f"Write: {new_content[:200]}")
+
+            # Also handle simple role/content format (for compatibility)
+            elif obj.get("role") == "user":
+                content_text = obj.get("content", "")
+                if isinstance(content_text, str) and content_text.strip():
+                    user_messages.append(content_text.strip())
+
+            elif obj.get("role") == "assistant":
+                content_text = obj.get("content", "")
+                if isinstance(content_text, str) and content_text.strip():
+                    assistant_replies.append(content_text.strip())
+
+        except (json.JSONDecodeError, KeyError, TypeError):
+            # Not JSON or doesn't have expected structure, skip
+            continue
+
+    # Join with newlines for better readability
+    user_str = "\n".join(user_messages) if user_messages else ""
+    assistant_str = "\n".join(assistant_replies) if assistant_replies else ""
+    code_str = "\n".join(code_changes) if code_changes else ""
+
+    return user_str, assistant_str, code_str
+
+
 def simple_summarize(content: str, max_chars: int = 500) -> str:
     """
     Generate a simple summary from new session content.
@@ -445,34 +554,71 @@ def generate_summary_with_llm(
     content: str,
     max_chars: int = 500,
     provider: str = "auto"
-) -> Tuple[Optional[str], Optional[str]]:
+) -> Tuple[Optional[str], Optional[str], Optional[str]]:
     """
     Generate summary using LLM (Anthropic Claude or OpenAI) for NEW content only.
-    Returns (summary, model_name) tuple, or (None, None) if LLM is unavailable.
+    Returns (title, model_name, description) tuple, or (None, None, None) if LLM is unavailable.
 
     Args:
         content: Raw text content of new session additions
-        max_chars: Maximum characters in summary
+        max_chars: Maximum characters in summary (not used, kept for compatibility)
         provider: LLM provider to use - "auto" (try Claude then OpenAI), "claude", or "openai"
+
+    Returns:
+        Tuple of (title, model_name, description) where:
+        - title: One-line summary (max 150 chars)
+        - model_name: Name of the model used
+        - description: Detailed description of what happened (200-400 chars)
     """
-    logger.info(f"Attempting to generate LLM summary (provider: {provider}, max_chars: {max_chars})")
+    logger.info(f"Attempting to generate LLM summary (provider: {provider})")
 
     if not content or not content.strip():
         logger.debug("No content provided for summarization")
-        return "No new content in this session", None
-
-    # Truncate content for API (to avoid token limits)
-    # Approximately 4000 chars = ~1000 tokens
-    truncated_content = content[:4000]
-    if len(content) > 4000:
-        logger.debug(f"Content truncated from {len(content)} to 4000 chars for LLM API")
-
-    # System prompt for summarization
-    system_prompt = (
-        "You are a helpful assistant that summarizes NEW content added to AI agent chat sessions. "
-        "Provide a concise summary in English focusing on the main topics and actions in the NEW content."
-    )
-    user_prompt = f"Summarize this NEW content from an AI chat session in one or two sentences:\n\n{truncated_content}"
+        return "No new content in this session", None, ""
+
+    # Filter content to extract meaningful information
+    user_messages, assistant_replies, code_changes = filter_session_content(content)
+
+    # If no meaningful content after filtering, return early
+    if not user_messages and not assistant_replies and not code_changes:
+        logger.debug("No meaningful content after filtering")
+        return "Session update with no significant changes", None, "No significant changes detected in this session"
+
+    # System prompt for structured summarization
+    system_prompt = """You are a git commit message generator for AI chat sessions.
+Analyze the conversation and code changes, then generate a summary in JSON format:
+{
+  "title": "One-line summary (max 150 chars, imperative mood, like 'Add feature X' or 'Fix bug in Y'. NEVER truncate words - keep whole words only. Omit articles like 'the', 'a' when possible to save space)",
+  "description": "Detailed description of what happened in this session (200-400 chars). Focus on key actions, decisions, and outcomes. Don't worry about perfect grammar - clarity and completeness matter more. Include specific details like function names, features discussed, bugs fixed, etc."
+}
+
+IMPORTANT for description:
+- Be specific and informative (200-400 characters)
+- Focus on WHAT was accomplished and WHY, not HOW
+- Include technical details: function names, module names, specific features
+- Mention key decisions or discussions
+- Don't worry about perfect grammar - focus on conveying the right meaning clearly
+- Avoid mentioning tool names like 'Edit', 'Write', 'Read'
+- For discussions without code: summarize the topics and conclusions
+- For code changes: describe what was changed and the purpose
+
+Return JSON only, no other text."""
+
+    # Build user prompt with filtered content
+    user_prompt_parts = ["Summarize this AI chat session:\n"]
+
+    if user_messages:
+        user_prompt_parts.append(f"User requests:\n{user_messages[:1500]}\n")
+
+    if assistant_replies:
+        user_prompt_parts.append(f"AI responses:\n{assistant_replies[:1500]}\n")
+
+    if code_changes:
+        user_prompt_parts.append(f"Code changes:\n{code_changes[:1500]}\n")
+
+    user_prompt_parts.append("\nReturn JSON only, no other text.")
+
+    user_prompt = "\n".join(user_prompt_parts)
 
     # Determine which providers to try based on the provider parameter
     try_claude = provider in ("auto", "claude")
@@ -493,7 +639,7 @@ def generate_summary_with_llm(
 
             response = client.messages.create(
                 model="claude-3-5-haiku-20241022",  # Fast and cost-effective
-                max_tokens=150,
+                max_tokens=300,  # Increased for keywords
                 temperature=0.7,
                 system=system_prompt,
                 messages=[
@@ -505,17 +651,44 @@ def generate_summary_with_llm(
             )
 
             elapsed = time.time() - start_time
-            summary = response.content[0].text.strip()
-            logger.info(f"Claude API success: {len(summary)} chars in {elapsed:.2f}s")
-            logger.debug(f"Claude response: {summary[:100]}...")
-            print("   ✅ Anthropic (Claude) summary successful", file=sys.stderr)
-            return summary[:max_chars], "claude-3-5-haiku-20241022"
+            response_text = response.content[0].text.strip()
+            logger.info(f"Claude API success: {len(response_text)} chars in {elapsed:.2f}s")
+            logger.debug(f"Claude response: {response_text[:200]}...")
+
+            # Parse JSON response
+            try:
+                # Try to extract JSON if wrapped in markdown code blocks
+                if "```json" in response_text:
+                    json_start = response_text.find("```json") + 7
+                    json_end = response_text.find("```", json_start)
+                    json_str = response_text[json_start:json_end].strip()
+                elif "```" in response_text:
+                    json_start = response_text.find("```") + 3
+                    json_end = response_text.find("```", json_start)
+                    json_str = response_text[json_start:json_end].strip()
+                else:
+                    json_str = response_text
+
+                summary_data = json.loads(json_str)
+                title = summary_data.get("title", "")[:150]  # Enforce 150 char limit
+                description = summary_data.get("description", "")[:400]  # Enforce 400 char limit
+
+                print("   ✅ Anthropic (Claude) summary successful", file=sys.stderr)
+                return title, "claude-3-5-haiku-20241022", description
+
+            except json.JSONDecodeError as e:
+                logger.warning(f"Failed to parse JSON from Claude response: {e}")
+                logger.debug(f"Raw response: {response_text}")
+                # Fallback: use first line as title, empty description
+                first_line = response_text.split("\n")[0][:150]
+                print("   ⚠️  Claude response was not valid JSON, using fallback", file=sys.stderr)
+                return first_line, "claude-3-5-haiku-20241022", ""
 
         except ImportError:
             logger.warning("Anthropic package not installed")
             if provider == "claude":
                 print("   ❌ Anthropic package not installed", file=sys.stderr)
-                return None, None
+                return None, None, None
             else:
                 print("   ❌ Anthropic package not installed, trying OpenAI...", file=sys.stderr)
         except Exception as e:
@@ -531,7 +704,7 @@ def generate_summary_with_llm(
                     print(f"   ❌ Anthropic quota/credit issue", file=sys.stderr)
                 else:
                     print(f"   ❌ Anthropic API error: {e}", file=sys.stderr)
-                return None, None
+                return None, None, None
             else:
                 # Auto mode: try falling back to OpenAI
                 if "authentication" in error_msg.lower() or "invalid" in error_msg.lower():
@@ -547,7 +720,7 @@ def generate_summary_with_llm(
         logger.debug("ANTHROPIC_API_KEY not set")
         if provider == "claude":
             print("   ❌ ANTHROPIC_API_KEY not set", file=sys.stderr)
-            return None, None
+            return None, None, None
         else:
             print("   ⓘ ANTHROPIC_API_KEY not set, trying OpenAI...", file=sys.stderr)
 
@@ -576,21 +749,48 @@ def generate_summary_with_llm(
                         "content": user_prompt
                     }
                 ],
-                max_tokens=150,
+                max_tokens=300,  # Increased for keywords
                 temperature=0.7,
             )
 
             elapsed = time.time() - start_time
-            summary = response.choices[0].message.content.strip()
-            logger.info(f"OpenAI API success: {len(summary)} chars in {elapsed:.2f}s")
-            logger.debug(f"OpenAI response: {summary[:100]}...")
-            print("   ✅ OpenAI (GPT) summary successful", file=sys.stderr)
-            return summary[:max_chars], "gpt-3.5-turbo"
+            response_text = response.choices[0].message.content.strip()
+            logger.info(f"OpenAI API success: {len(response_text)} chars in {elapsed:.2f}s")
+            logger.debug(f"OpenAI response: {response_text[:200]}...")
+
+            # Parse JSON response
+            try:
+                # Try to extract JSON if wrapped in markdown code blocks
+                if "```json" in response_text:
+                    json_start = response_text.find("```json") + 7
+                    json_end = response_text.find("```", json_start)
+                    json_str = response_text[json_start:json_end].strip()
+                elif "```" in response_text:
+                    json_start = response_text.find("```") + 3
+                    json_end = response_text.find("```", json_start)
+                    json_str = response_text[json_start:json_end].strip()
+                else:
+                    json_str = response_text
+
+                summary_data = json.loads(json_str)
+                title = summary_data.get("title", "")[:150]  # Enforce 150 char limit
+                description = summary_data.get("description", "")[:400]  # Enforce 400 char limit
+
+                print("   ✅ OpenAI (GPT) summary successful", file=sys.stderr)
+                return title, "gpt-3.5-turbo", description
+
+            except json.JSONDecodeError as e:
+                logger.warning(f"Failed to parse JSON from OpenAI response: {e}")
+                logger.debug(f"Raw response: {response_text}")
+                # Fallback: use first line as title, empty description
+                first_line = response_text.split("\n")[0][:150]
+                print("   ⚠️  OpenAI response was not valid JSON, using fallback", file=sys.stderr)
+                return first_line, "gpt-3.5-turbo", ""
 
         except ImportError:
             logger.warning("OpenAI package not installed")
             print("   ❌ OpenAI package not installed", file=sys.stderr)
-            return None, None
+            return None, None, None
         except Exception as e:
             error_msg = str(e)
             logger.error(f"OpenAI API error: {error_msg}", exc_info=True)
@@ -602,17 +802,17 @@ def generate_summary_with_llm(
                 print(f"   ❌ OpenAI quota/billing issue", file=sys.stderr)
             else:
                 print(f"   ❌ OpenAI API error: {e}", file=sys.stderr)
-            return None, None
+            return None, None, None
     elif try_openai:
         logger.debug("OPENAI_API_KEY not set")
         print("   ❌ OPENAI_API_KEY not set", file=sys.stderr)
-        return None, None
+        return None, None, None
 
     # No API keys available or provider not configured
     logger.warning(f"No LLM API keys available (provider: {provider})")
     if provider == "auto":
         print("   ❌ No LLM API keys configured", file=sys.stderr)
-    return None, None
+    return None, None, None
 
 
 def generate_session_filename(user: str, agent: str = "claude") -> str:
@@ -694,6 +894,46 @@ def get_git_user() -> str:
         return os.getenv("USER", "unknown")
 
 
+def get_username(session_relpath: str = "") -> str:
+    """
+    Get username for commit message.
+
+    Tries to get from git config first, then falls back to extracting
+    from session filename.
+
+    Args:
+        session_relpath: Relative path to session file (used for fallback)
+
+    Returns:
+        Username string
+    """
+    # Try git config first
+    try:
+        result = subprocess.run(
+            ["git", "config", "user.name"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        username = result.stdout.strip()
+        if username:
+            return username
+    except subprocess.CalledProcessError:
+        pass
+
+    # Fallback: extract from session filename
+    # Format: username_agent_hash.jsonl
+    if session_relpath:
+        filename = Path(session_relpath).name
+        parts = filename.split("_")
+        if len(parts) >= 3:
+            # First part is username
+            return parts[0]
+
+    # Final fallback
+    return os.getenv("USER", "unknown")
+
+
 def copy_session_to_repo(
     session_file: Path,
     repo_root: Path,
@@ -1106,18 +1346,19 @@ def process_sessions(
             continue
 
         # Generate summary for NEW content only
-        summary_text: Optional[str] = None
+        summary_title: Optional[str] = None
+        summary_description: str = ""
         is_llm_summary = False
         llm_model_name: Optional[str] = None
         if config.use_LLM:
             print(f"🤖 Attempting to generate LLM summary (provider: {config.llm_provider})...", file=sys.stderr)
-            summary_text, llm_model_name = generate_summary_with_llm(
+            summary_title, llm_model_name, summary_description = generate_summary_with_llm(
                 new_content,
                 config.summary_max_chars,
                 config.llm_provider
             )
 
-            if summary_text:
+            if summary_title:
                 print("✅ LLM summary generated successfully", file=sys.stderr)
                 is_llm_summary = True
                 if summary_model_label is None:
@@ -1126,23 +1367,26 @@ def process_sessions(
                 print("⚠️  LLM summary failed - falling back to local summarization", file=sys.stderr)
                 print("   Check your API keys: ANTHROPIC_API_KEY or OPENAI_API_KEY", file=sys.stderr)
 
-        if not summary_text:
+        if not summary_title:
             # Fallback to simple summarize
             logger.info("Using local summarization (no LLM)")
             print("📝 Using local summarization (no LLM)", file=sys.stderr)
-            summary_text = simple_summarize(new_content, config.summary_max_chars)
+            summary_title = simple_summarize(new_content, config.summary_max_chars)
+            summary_description = ""
 
         # Identify agent type from filename
         agent_name = detect_agent_from_session_path(session_relpath)
 
-        summary_text = summary_text.strip()
-        logger.debug(f"Summary for {session_relpath} ({agent_name}): {summary_text[:100]}...")
+        summary_title = summary_title.strip()
+        logger.debug(f"Summary for {session_relpath} ({agent_name}): {summary_title[:100]}...")
+        logger.debug(f"Description: {summary_description[:100]}...")
         summary_entries.append({
             "agent": agent_name,
-            "text": summary_text,
+            "title": summary_title,
+            "description": summary_description,
             "source": "llm" if is_llm_summary else "local",
         })
-        legacy_summary_chunks.append(f"[{agent_name}] {summary_text}")
+        legacy_summary_chunks.append(f"[{agent_name}] {summary_title}")
 
         # Update metadata after successfully generating summary
         save_session_metadata(repo_root, session_relpath, current_size)
@@ -1230,23 +1474,59 @@ def prepare_commit_msg_hook():
 
     # Append summary to commit message
     summary_entries = result.get("summary_entries") or []
+    session_relpaths = result.get("session_relpaths") or []
+
     if summary_entries:
         try:
+            # Read existing commit message to check if user provided one
+            with open(msg_file, "r", encoding="utf-8") as f:
+                existing_msg = f.read().strip()
+
+            # Check if this is an auto-commit (empty message or only comments)
+            is_auto_commit = not existing_msg or all(
+                line.startswith("#") for line in existing_msg.split("\n") if line.strip()
+            )
+
+            # Get username from first session path
+            username = get_username(session_relpaths[0] if session_relpaths else "")
+
+            # Get timestamp
+            from datetime import datetime
+            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
             with open(msg_file, "a", encoding="utf-8") as f:
-                summary_model = result.get("summary_model") or "Local summarizer"
-                f.write("\n\n")
-                f.write(f"--- LLM-Summary ({summary_model}) ---\n")
-                for entry in summary_entries:
-                    agent_label = entry.get("agent", "Agent")
-                    text = (entry.get("text") or "").strip()
-                    if not text:
-                        continue
-                    f.write(f"* [{agent_label}] {text}\n")
-                f.write("\n")
+                # Combine all summaries
+                first_entry = summary_entries[0]
+                title = first_entry.get("title", "Session update").strip()
+                agent_label = first_entry.get("agent", "Unknown")
+                description = first_entry.get("description", "").strip()
+
+                if is_auto_commit:
+                    # Auto-commit format: use aline summary as the main message
+                    f.write(f"aline: {title}\n\n")
+                    if description:
+                        f.write(f"{description}\n\n")
+                    f.write(f"Agent: {agent_label}\n")
+                    f.write(f"User: {username}\n")
+                    f.write(f"Timestamp: {timestamp}\n")
+                else:
+                    # User-provided commit message format: append aline summary after separator
+                    f.write("\n\n---\n")
+                    f.write(f"aline: {title}\n\n")
+                    if description:
+                        f.write(f"{description}\n\n")
+                    f.write(f"Agent: {agent_label}\n")
+                    f.write(f"User: {username}\n")
+                    f.write(f"Timestamp: {timestamp}\n")
+
+                # Add redaction marker if applicable
                 if result.get("redacted"):
-                    f.write("Agent-Redacted: true\n")
+                    f.write("Redacted: true\n")
+
         except Exception as e:
             print(f"Warning: Could not append to commit message: {e}", file=sys.stderr)
+            import traceback
+            logger.error(f"Commit message formatting error: {traceback.format_exc()}")
 
     sys.exit(0)
 

realign/mcp_watcher.py

@@ -442,9 +442,8 @@ class DialogueWatcher:
             session_file: Session file that triggered the commit
         """
         try:
-            # Generate commit message
-            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-            message = f"chore: Auto-commit MCP session ({timestamp})"
+            # Use empty message to let prepare-commit-msg hook generate it with LLM summary
+            message = ""
 
             # Use realign commit command
             result = await asyncio.get_event_loop().run_in_executor(
@@ -455,8 +454,8 @@ class DialogueWatcher:
             )
 
             if result:
-                logger.info(f"✓ Committed to {project_path.name}: {message}")
-                print(f"[MCP Watcher] ✓ Committed to {project_path.name}: {message}", file=sys.stderr)
+                logger.info(f"✓ Committed to {project_path.name}")
+                print(f"[MCP Watcher] ✓ Auto-committed to {project_path.name}", file=sys.stderr)
                 # Update last commit time for this project
                 self.last_commit_times[str(project_path)] = time.time()
                 # Baseline counts already updated in _check_if_turn_complete()