aline-ai 0.1.10__py3-none-any.whl → 0.2.1__py3-none-any.whl

realign/hooks.py

@@ -167,6 +167,41 @@ def find_codex_latest_session(project_path: Path, days_back: int = 7) -> Optiona
     return matching_sessions[0] if matching_sessions else None
 
 
+def find_all_claude_sessions() -> List[Path]:
+    """
+    Find all active Claude Code sessions from ALL projects.
+
+    Scans ~/.claude/projects/ and returns the latest session from each project.
+
+    Returns:
+        List of session file paths from all Claude projects
+    """
+    sessions = []
+    claude_base = Path.home() / ".claude" / "projects"
+
+    if not claude_base.exists():
+        logger.debug(f"Claude projects directory not found: {claude_base}")
+        return sessions
+
+    # Iterate through all project directories
+    for project_dir in claude_base.iterdir():
+        if not project_dir.is_dir():
+            continue
+
+        # Skip system directories
+        if project_dir.name.startswith('.'):
+            continue
+
+        # Find the latest session in this project directory
+        session = find_latest_session(project_dir)
+        if session:
+            sessions.append(session)
+            logger.debug(f"Found Claude session in {project_dir.name}: {session.name}")
+
+    logger.info(f"Found {len(sessions)} Claude session(s) across all projects")
+    return sessions
+
+
 def find_all_active_sessions(
     config: ReAlignConfig,
     project_path: Optional[Path] = None
@@ -181,13 +216,15 @@ def find_all_active_sessions(
 
     Args:
         config: Configuration object
-        project_path: Optional path to the current project (git repo root)
+        project_path: Optional path to the current project (git repo root).
+                     If None, will find sessions from ALL projects (multi-project mode).
 
     Returns:
         List of session file paths (may be empty if no sessions found)
     """
     logger.info("Searching for active AI sessions")
     logger.debug(f"Config: auto_detect_codex={config.auto_detect_codex}, auto_detect_claude={config.auto_detect_claude}")
+    logger.debug(f"Project path: {project_path}")
 
     sessions = []
 
@@ -203,15 +240,47 @@ def find_all_active_sessions(
             logger.warning(f"No session found at explicit path: {history_path}")
         return sessions
 
+    # Multi-project mode: find sessions from ALL projects
+    if project_path is None:
+        logger.info("Multi-project mode: scanning all projects")
+
+        # Find all Claude sessions if enabled
+        if config.auto_detect_claude:
+            logger.debug("Scanning all Claude projects")
+            claude_sessions = find_all_claude_sessions()
+            sessions.extend(claude_sessions)
+
+        # TODO: Add Codex multi-project support if needed
+        # For now, Codex sessions are only found when project_path is specified
+
+        if sessions:
+            logger.info(f"Multi-project scan complete: found {len(sessions)} session(s)")
+            return sessions
+
+        # Fallback: try local history path
+        logger.debug("No sessions found in multi-project scan, trying fallback path")
+        history_path = config.expanded_local_history_path
+        session = find_latest_session(history_path)
+        if session:
+            sessions.append(session)
+            logger.info(f"Found session at fallback path: {session}")
+        else:
+            logger.warning(f"No session found at fallback path: {history_path}")
+
+        return sessions
+
+    # Single-project mode: find sessions for specific project
+    logger.info(f"Single-project mode for: {project_path}")
+
     # Try Codex auto-detection if enabled
-    if config.auto_detect_codex and project_path:
+    if config.auto_detect_codex:
         logger.debug("Attempting Codex auto-detection")
         codex_session = find_codex_latest_session(project_path)
         if codex_session:
             sessions.append(codex_session)
 
     # Try Claude auto-detection if enabled
-    if config.auto_detect_claude and project_path:
+    if config.auto_detect_claude:
         logger.debug("Attempting Claude auto-detection")
         claude_dir = find_claude_sessions_dir(project_path)
         if claude_dir:
@@ -328,13 +397,48 @@ def simple_summarize(content: str, max_chars: int = 500) -> str:
         summary = " | ".join(summaries[:3])
         return summary[:max_chars]
 
+    # Fallback: surface the first few non-empty raw lines to give context
+    fallback_lines = []
+    for raw_line in lines:
+        stripped = raw_line.strip()
+        if not stripped:
+            continue
+        # Skip noisy JSON braces-only lines
+        if stripped in ("{", "}", "[", "]"):
+            continue
+        fallback_lines.append(stripped[:120])
+        if len(fallback_lines) == 3:
+            break
+
+    if fallback_lines:
+        summary = " | ".join(fallback_lines)
+        return summary[:max_chars]
+
     return f"Session updated with {len(lines)} new lines"
 
 
-def generate_summary_with_llm(content: str, max_chars: int = 500, provider: str = "auto") -> Optional[str]:
+def detect_agent_from_session_path(session_relpath: str) -> str:
+    """Infer agent type based on session filename."""
+    lower_path = session_relpath.lower()
+
+    if "codex" in lower_path or "rollout-" in lower_path:
+        return "Codex"
+    if "claude" in lower_path or "agent-" in lower_path:
+        return "Claude"
+    if lower_path.endswith(".jsonl"):
+        # Default to Unknown to avoid mislabeling generic files
+        return "Unknown"
+    return "Unknown"
+
+
+def generate_summary_with_llm(
+    content: str,
+    max_chars: int = 500,
+    provider: str = "auto"
+) -> Tuple[Optional[str], Optional[str]]:
     """
     Generate summary using LLM (Anthropic Claude or OpenAI) for NEW content only.
-    Returns None if LLM is not available or fails.
+    Returns (summary, model_name) tuple, or (None, None) if LLM is unavailable.
 
     Args:
         content: Raw text content of new session additions
@@ -345,7 +449,7 @@ def generate_summary_with_llm(content: str, max_chars: int = 500, provider: str
 
     if not content or not content.strip():
         logger.debug("No content provided for summarization")
-        return "No new content in this session"
+        return "No new content in this session", None
 
     # Truncate content for API (to avoid token limits)
     # Approximately 4000 chars = ~1000 tokens
@@ -395,13 +499,13 @@ def generate_summary_with_llm(content: str, max_chars: int = 500, provider: str
             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]
+            return summary[:max_chars], "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
+                return None, None
             else:
                 print("   ❌ Anthropic package not installed, trying OpenAI...", file=sys.stderr)
         except Exception as e:
@@ -417,7 +521,7 @@ def generate_summary_with_llm(content: str, max_chars: int = 500, provider: str
                     print(f"   ❌ Anthropic quota/credit issue", file=sys.stderr)
                 else:
                     print(f"   ❌ Anthropic API error: {e}", file=sys.stderr)
-                return None
+                return None, None
             else:
                 # Auto mode: try falling back to OpenAI
                 if "authentication" in error_msg.lower() or "invalid" in error_msg.lower():
@@ -433,7 +537,7 @@ def generate_summary_with_llm(content: str, max_chars: int = 500, provider: str
         logger.debug("ANTHROPIC_API_KEY not set")
         if provider == "claude":
             print("   ❌ ANTHROPIC_API_KEY not set", file=sys.stderr)
-            return None
+            return None, None
         else:
             print("   ⓘ ANTHROPIC_API_KEY not set, trying OpenAI...", file=sys.stderr)
 
@@ -471,12 +575,12 @@ def generate_summary_with_llm(content: str, max_chars: int = 500, provider: str
             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]
+            return summary[:max_chars], "gpt-3.5-turbo"
 
         except ImportError:
             logger.warning("OpenAI package not installed")
             print("   ❌ OpenAI package not installed", file=sys.stderr)
-            return None
+            return None, None
         except Exception as e:
             error_msg = str(e)
             logger.error(f"OpenAI API error: {error_msg}", exc_info=True)
@@ -488,17 +592,17 @@ def generate_summary_with_llm(content: str, max_chars: int = 500, provider: str
                 print(f"   ❌ OpenAI quota/billing issue", file=sys.stderr)
             else:
                 print(f"   ❌ OpenAI API error: {e}", file=sys.stderr)
-            return None
+            return None, None
     elif try_openai:
         logger.debug("OPENAI_API_KEY not set")
         print("   ❌ OPENAI_API_KEY not set", file=sys.stderr)
-        return None
+        return 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
+    return None, None
 
 
 def generate_session_filename(user: str, agent: str = "claude") -> str:
@@ -509,6 +613,63 @@ def generate_session_filename(user: str, agent: str = "claude") -> str:
     return f"{timestamp}_{user_short}_{agent}_{short_id}.jsonl"
 
 
+def extract_codex_rollout_hash(filename: str) -> Optional[str]:
+    """
+    Extract stable hash from Codex rollout filename.
+
+    Primary Codex rollout format:
+        rollout-YYYY-MM-DDTHH-MM-SS-<uuid>.jsonl
+        Example: rollout-2025-11-16T18-10-42-019a8ddc-b4b3-7942-9a4f-fac74d1580c9.jsonl
+                 -> 019a8ddc-b4b3-7942-9a4f-fac74d1580c9
+
+    Legacy format (still supported):
+        rollout-<timestamp>-<hash>.jsonl
+        Example: rollout-1763315655-abc123def.jsonl -> abc123def
+
+    Args:
+        filename: Original Codex rollout filename
+
+    Returns:
+        Hash string, or None if parsing fails
+    """
+    if not filename.startswith("rollout-"):
+        return None
+
+    # Normalize filename (strip extension) and remove prefix
+    stem = Path(filename).stem
+    if stem.startswith("rollout-"):
+        stem = stem[len("rollout-"):]
+
+    if not stem:
+        return None
+
+    def looks_like_uuid(value: str) -> bool:
+        """Return True if value matches canonical UUID format."""
+        parts = value.split("-")
+        expected_lengths = [8, 4, 4, 4, 12]
+        if len(parts) != 5:
+            return False
+        hex_digits = set("0123456789abcdefABCDEF")
+        for part, length in zip(parts, expected_lengths):
+            if len(part) != length or not set(part).issubset(hex_digits):
+                return False
+        return True
+
+    # Newer Codex exports append a full UUID after the human-readable timestamp.
+    uuid_candidate_parts = stem.rsplit("-", 5)
+    if len(uuid_candidate_parts) == 6:
+        candidate_uuid = "-".join(uuid_candidate_parts[1:])
+        if looks_like_uuid(candidate_uuid):
+            return candidate_uuid.lower()
+
+    # Fallback for legacy rollout names: everything after first '-' is the hash.
+    legacy_parts = stem.split("-", 1)
+    if len(legacy_parts) == 2 and legacy_parts[1]:
+        return legacy_parts[1]
+
+    return None
+
+
 def get_git_user() -> str:
     """Get git user name."""
     try:
@@ -528,12 +689,12 @@ def copy_session_to_repo(
     repo_root: Path,
     user: str,
     config: Optional[ReAlignConfig] = None
-) -> Tuple[Path, str, bool]:
+) -> Tuple[Path, str, bool, int]:
     """
     Copy session file to repository .realign/sessions/ directory.
     Optionally redacts sensitive information if configured.
     If the source filename is in UUID format, renames it to include username for better identification.
-    Returns (absolute_path, relative_path, was_redacted).
+    Returns (absolute_path, relative_path, was_redacted, content_size).
     """
     logger.info(f"Copying session to repo: {session_file.name}")
     logger.debug(f"Source: {session_file}, Repo root: {repo_root}, User: {user}")
@@ -551,6 +712,8 @@ def copy_session_to_repo(
         '_' not in stem and
         len(stem) == 36  # UUID is 36 chars including hyphens
     )
+    # Codex rollout exports always start with rollout-<timestamp>-
+    is_codex_rollout = original_filename.startswith("rollout-")
 
     # Read session content first to detect agent type
     try:
@@ -566,6 +729,16 @@ def copy_session_to_repo(
             user_short = user.split()[0].lower() if user else "unknown"
             new_filename = f"{user_short}_unknown_{short_id}.jsonl"
             dest_path = sessions_dir / new_filename
+        elif is_codex_rollout:
+            # Extract stable hash from rollout filename
+            rollout_hash = extract_codex_rollout_hash(original_filename)
+            user_short = user.split()[0].lower() if user else "unknown"
+            if rollout_hash:
+                new_filename = f"{user_short}_codex_{rollout_hash}.jsonl"
+            else:
+                # Fallback if hash extraction fails
+                new_filename = generate_session_filename(user, "codex")
+            dest_path = sessions_dir / new_filename
         else:
             dest_path = sessions_dir / original_filename
         temp_path = dest_path.with_suffix(".tmp")
@@ -573,7 +746,12 @@ def copy_session_to_repo(
         temp_path.rename(dest_path)
         rel_path = dest_path.relative_to(repo_root)
         logger.warning(f"Copied session with fallback (no agent detection): {rel_path}")
-        return dest_path, str(rel_path), False
+        # Get file size for the fallback case
+        try:
+            fallback_size = dest_path.stat().st_size
+        except Exception:
+            fallback_size = 0
+        return dest_path, str(rel_path), False, fallback_size
 
     # Detect agent type from session content
     agent_type = "unknown"
@@ -611,6 +789,18 @@ def copy_session_to_repo(
         # Format: username_agent_shortid.jsonl (no timestamp for consistency)
         new_filename = f"{user_short}_{agent_type}_{short_id}.jsonl"
         dest_path = sessions_dir / new_filename
+    elif is_codex_rollout:
+        # Extract stable hash from rollout filename
+        codex_agent = agent_type if agent_type != "unknown" else "codex"
+        rollout_hash = extract_codex_rollout_hash(original_filename)
+        user_short = user.split()[0].lower() if user else "unknown"
+        if rollout_hash:
+            # Format: username_codex_hash.jsonl (stable naming)
+            new_filename = f"{user_short}_{codex_agent}_{rollout_hash}.jsonl"
+        else:
+            # Fallback if hash extraction fails
+            new_filename = generate_session_filename(user, codex_agent)
+        dest_path = sessions_dir / new_filename
     else:
         # Keep original filename (could be timestamp_user_agent_id format or other)
         dest_path = sessions_dir / original_filename
@@ -658,9 +848,68 @@ def copy_session_to_repo(
         shutil.copy2(session_file, dest_path)
         logger.warning("Fallback to simple copy")
 
-    # Return both absolute and relative paths, plus redaction status
+    # Return both absolute and relative paths, plus redaction status and content size
     rel_path = dest_path.relative_to(repo_root)
-    return dest_path, str(rel_path), was_redacted
+    content_size = len(content)
+    return dest_path, str(rel_path), was_redacted, content_size
+
+
+def save_session_metadata(repo_root: Path, session_relpath: str, content_size: int):
+    """
+    Save metadata about a processed session to avoid reprocessing.
+
+    Args:
+        repo_root: Path to repository root
+        session_relpath: Relative path to session file
+        content_size: Size of session content when processed
+    """
+    metadata_dir = repo_root / ".realign" / ".metadata"
+    metadata_dir.mkdir(parents=True, exist_ok=True)
+
+    # Use session filename as metadata key
+    session_name = Path(session_relpath).name
+    metadata_file = metadata_dir / f"{session_name}.meta"
+
+    metadata = {
+        "processed_at": time.time(),
+        "content_size": content_size,
+        "session_relpath": session_relpath,
+    }
+
+    try:
+        with open(metadata_file, 'w', encoding='utf-8') as f:
+            json.dump(metadata, f)
+        logger.debug(f"Saved metadata for {session_relpath}: {content_size} bytes")
+    except Exception as e:
+        logger.warning(f"Failed to save metadata for {session_relpath}: {e}")
+
+
+def get_session_metadata(repo_root: Path, session_relpath: str) -> Optional[Dict[str, Any]]:
+    """
+    Get metadata about a previously processed session.
+
+    Args:
+        repo_root: Path to repository root
+        session_relpath: Relative path to session file
+
+    Returns:
+        Metadata dictionary or None if not found
+    """
+    metadata_dir = repo_root / ".realign" / ".metadata"
+    session_name = Path(session_relpath).name
+    metadata_file = metadata_dir / f"{session_name}.meta"
+
+    if not metadata_file.exists():
+        return None
+
+    try:
+        with open(metadata_file, 'r', encoding='utf-8') as f:
+            metadata = json.load(f)
+        logger.debug(f"Loaded metadata for {session_relpath}: {metadata.get('content_size')} bytes")
+        return metadata
+    except Exception as e:
+        logger.warning(f"Failed to load metadata for {session_relpath}: {e}")
+        return None
 
 
 def process_sessions(
@@ -678,7 +927,7 @@ def process_sessions(
         user: User name override (optional)
 
     Returns:
-        Dictionary with keys: summary, session_relpaths, redacted
+        Dictionary with keys: summary, session_relpaths, redacted, summary_entries, summary_model
     """
     import time
     start_time = time.time()
@@ -730,13 +979,15 @@ def process_sessions(
 
     # Copy all sessions to repo (with optional redaction)
     session_relpaths = []
+    session_metadata_map = {}  # Map session_relpath -> content_size
     any_redacted = False
     for session_file in session_files:
         try:
-            _, session_relpath, was_redacted = copy_session_to_repo(
+            _, session_relpath, was_redacted, content_size = copy_session_to_repo(
                 session_file, repo_root, user, config
             )
             session_relpaths.append(session_relpath)
+            session_metadata_map[session_relpath] = content_size
             if was_redacted:
                 any_redacted = True
         except Exception as e:
@@ -746,18 +997,31 @@ def process_sessions(
 
     if not session_relpaths:
         logger.warning("No session files copied successfully")
-        return {"summary": "", "session_relpaths": [], "redacted": False}
+        return {
+            "summary": "",
+            "session_relpaths": [],
+            "redacted": False,
+            "summary_entries": [],
+            "summary_model": "",
+        }
 
     logger.info(f"Copied {len(session_relpaths)} session(s): {session_relpaths}")
 
-    # If pre-commit mode, just return session paths (summary will be generated later)
+    # If pre-commit mode, save metadata and return session paths (summary will be generated later)
     if pre_commit_mode:
+        # Save metadata for each session to prevent reprocessing
+        for session_relpath, content_size in session_metadata_map.items():
+            save_session_metadata(repo_root, session_relpath, content_size)
+            logger.debug(f"Saved metadata for {session_relpath} in pre-commit")
+
         elapsed = time.time() - start_time
         logger.info(f"======== Hook completed: {hook_type} in {elapsed:.2f}s ========")
         return {
             "summary": "",
             "session_relpaths": session_relpaths,
             "redacted": any_redacted,
+            "summary_entries": [],
+            "summary_model": "",
         }
 
     # For prepare-commit-msg mode, we need to stage files first to get accurate diff
@@ -776,9 +1040,24 @@ def process_sessions(
 
     # For prepare-commit-msg mode, generate summary from all sessions
     logger.info("Generating summaries for sessions")
-    all_summaries = []
+    summary_entries: List[Dict[str, str]] = []
+    legacy_summary_chunks: List[str] = []
+    summary_model_label: Optional[str] = None
 
     for session_relpath in session_relpaths:
+        # Check if this session was already processed in pre-commit hook
+        previous_metadata = get_session_metadata(repo_root, session_relpath)
+        current_size = session_metadata_map.get(session_relpath, 0)
+
+        if previous_metadata:
+            previous_size = previous_metadata.get("content_size", 0)
+            if previous_size == current_size:
+                logger.info(f"Session {session_relpath} unchanged since pre-commit (size: {current_size}), skipping")
+                print(f"⏭️  Skipping {Path(session_relpath).name} (no new content since pre-commit)", file=sys.stderr)
+                continue
+            else:
+                logger.info(f"Session {session_relpath} size changed: {previous_size} -> {current_size}")
+
         # Extract NEW content using git diff
         new_content = get_new_content_from_git_diff(repo_root, session_relpath)
 
@@ -787,37 +1066,54 @@ def process_sessions(
             continue
 
         # Generate summary for NEW content only
-        summary = None
+        summary_text: Optional[str] = None
+        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 = generate_summary_with_llm(new_content, config.summary_max_chars, config.llm_provider)
+            summary_text, llm_model_name = generate_summary_with_llm(
+                new_content,
+                config.summary_max_chars,
+                config.llm_provider
+            )
 
-            if summary:
+            if summary_text:
                 print("✅ LLM summary generated successfully", file=sys.stderr)
+                is_llm_summary = True
+                if summary_model_label is None:
+                    summary_model_label = llm_model_name or config.llm_provider
             else:
                 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:
+        if not summary_text:
             # Fallback to simple summarize
             logger.info("Using local summarization (no LLM)")
             print("📝 Using local summarization (no LLM)", file=sys.stderr)
-            summary = simple_summarize(new_content, config.summary_max_chars)
+            summary_text = simple_summarize(new_content, config.summary_max_chars)
 
         # Identify agent type from filename
-        agent_name = "Unknown"
-        if "rollout-" in session_relpath:
-            agent_name = "Codex"
-        elif "agent-" in session_relpath or ".jsonl" in session_relpath:
-            agent_name = "Claude"
+        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_entries.append({
+            "agent": agent_name,
+            "text": summary_text,
+            "source": "llm" if is_llm_summary else "local",
+        })
+        legacy_summary_chunks.append(f"[{agent_name}] {summary_text}")
 
-        logger.debug(f"Summary for {session_relpath} ({agent_name}): {summary[:100]}...")
-        all_summaries.append(f"[{agent_name}] {summary}")
+        # Update metadata after successfully generating summary
+        save_session_metadata(repo_root, session_relpath, current_size)
+        logger.debug(f"Updated metadata for {session_relpath} in prepare-commit-msg")
 
     # Combine all summaries
-    if all_summaries:
-        combined_summary = " | ".join(all_summaries)
-        logger.info(f"Generated {len(all_summaries)} summary(ies)")
+    if summary_entries:
+        if summary_model_label is None:
+            summary_model_label = "Local summarizer"
+        combined_summary = " | ".join(legacy_summary_chunks)
+        logger.info(f"Generated {len(summary_entries)} summary(ies)")
     else:
         combined_summary = "No new content in sessions"
         logger.info("No summaries generated (no new content)")
@@ -829,6 +1125,8 @@ def process_sessions(
         "summary": combined_summary,
         "session_relpaths": session_relpaths,
         "redacted": any_redacted,
+        "summary_entries": summary_entries,
+        "summary_model": summary_model_label or "",
     }
 
 
@@ -875,22 +1173,37 @@ def prepare_commit_msg_hook():
     Generates session summary and appends to commit message.
     """
     # Get commit message file path from command line arguments
-    if len(sys.argv) < 2:
-        print("Error: Commit message file path not provided", file=sys.stderr)
-        sys.exit(1)
-
-    msg_file = sys.argv[1]
+    # When called via __main__ with --prepare-commit-msg flag, the file is at index 2
+    # When called directly as a hook entry point, the file is at index 1
+    if sys.argv[1] == "--prepare-commit-msg":
+        # Called via: python -m realign.hooks --prepare-commit-msg <msg-file> <source>
+        if len(sys.argv) < 3:
+            print("Error: Commit message file path not provided", file=sys.stderr)
+            sys.exit(1)
+        msg_file = sys.argv[2]
+    else:
+        # Called via: realign-hook-prepare-commit-msg <msg-file> <source>
+        msg_file = sys.argv[1]
 
     # Process sessions and generate summary
     result = process_sessions(pre_commit_mode=False)
 
     # Append summary to commit message
-    if result["summary"] and result["session_relpaths"]:
+    summary_entries = result.get("summary_entries") or []
+    if summary_entries:
         try:
             with open(msg_file, "a", encoding="utf-8") as f:
-                f.write(f"\n\nAgent-Summary: {result['summary']}\n")
-                f.write(f"Agent-Session-Paths: {', '.join(result['session_relpaths'])}\n")
-                if result["redacted"]:
+                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")
+                if result.get("redacted"):
                     f.write("Agent-Redacted: true\n")
         except Exception as e:
             print(f"Warning: Could not append to commit message: {e}", file=sys.stderr)