aline-ai 0.5.4__py3-none-any.whl → 0.5.6__py3-none-any.whl

realign/watcher_core.py

@@ -19,7 +19,7 @@ from .hooks import find_all_active_sessions
 from .logging_config import setup_logger
 
 # Initialize logger for watcher
-logger = setup_logger('realign.watcher_core', 'watcher_core.log')
+logger = setup_logger("realign.watcher_core", "watcher_core.log")
 
 
 # Session type detection
@@ -116,18 +116,18 @@ def decode_claude_project_path(project_dir_name: str) -> Optional[Path]:
     if isinstance(project_dir_name, Path):
         project_dir = project_dir_name
         dir_name = project_dir.name
-    elif '/' in project_dir_name:
+    elif "/" in project_dir_name:
         project_dir = Path(project_dir_name)
         dir_name = project_dir.name
     else:
         dir_name = project_dir_name
         project_dir = Path.home() / ".claude" / "projects" / dir_name
 
-    if not dir_name.startswith('-'):
+    if not dir_name.startswith("-"):
         return None
 
     # Try naive decoding first
-    path_str = '/' + dir_name[1:].replace('-', '/')
+    path_str = "/" + dir_name[1:].replace("-", "/")
     project_path = Path(path_str)
 
     if project_path.exists():
@@ -143,8 +143,9 @@ def decode_claude_project_path(project_dir_name: str) -> Optional[Path]:
     # Find any JSONL file (excluding agent files)
     try:
         jsonl_files = [
-            f for f in project_dir.iterdir()
-            if f.suffix == '.jsonl' and not f.name.startswith('agent-')
+            f
+            for f in project_dir.iterdir()
+            if f.suffix == ".jsonl" and not f.name.startswith("agent-")
         ]
 
         if not jsonl_files:
@@ -153,7 +154,7 @@ def decode_claude_project_path(project_dir_name: str) -> Optional[Path]:
 
         # Read lines from first JSONL file to find cwd field
         jsonl_file = jsonl_files[0]
-        with jsonl_file.open('r', encoding='utf-8') as f:
+        with jsonl_file.open("r", encoding="utf-8") as f:
             # Check up to first 20 lines for cwd field
             for i, line in enumerate(f):
                 if i >= 20:
@@ -164,7 +165,7 @@ def decode_claude_project_path(project_dir_name: str) -> Optional[Path]:
                     continue
 
                 session_data = json.loads(line)
-                cwd = session_data.get('cwd')
+                cwd = session_data.get("cwd")
 
                 if cwd:
                     project_path = Path(cwd)
@@ -210,20 +211,27 @@ class DialogueWatcher:
         self.last_commit_times: Dict[str, float] = {}  # Track last commit time per project
         self.last_session_sizes: Dict[str, int] = {}  # Track file sizes
         self.last_stop_reason_counts: Dict[str, int] = {}  # Track stop_reason counts per session
-        self.last_session_mtimes: Dict[str, float] = {}  # Track last mtime of session files for idle detection
-        self.last_final_commit_times: Dict[str, float] = {}  # Track when we last tried final commit per session
+        self.last_session_mtimes: Dict[str, float] = (
+            {}
+        )  # Track last mtime of session files for idle detection
+        self.last_final_commit_times: Dict[str, float] = (
+            {}
+        )  # Track when we last tried final commit per session
         self.min_commit_interval = 5.0  # Minimum 5 seconds between commits (cooldown)
         self.debounce_delay = 10.0  # Wait 10 seconds after file change to ensure turn is complete (increased from 2.0 to handle streaming responses)
         self.final_commit_idle_timeout = 300.0  # 5 minutes idle to trigger final commit
         self.running = False
         self.pending_commit_task: Optional[asyncio.Task] = None
-        self._pending_changed_files: set[str] = set()  # Accumulate changed files instead of cancelling
+        self._pending_changed_files: set[str] = (
+            set()
+        )  # Accumulate changed files instead of cancelling
 
         # Trigger support for pluggable turn detection
         from .triggers.registry import get_global_registry
+
         self.trigger_registry = get_global_registry()
-        self.trigger_name = 'next_turn'  # Default trigger (可配置)
-        self._session_triggers: Dict[str, 'TurnTrigger'] = {}  # Cache triggers per session
+        self.trigger_name = "next_turn"  # Default trigger (可配置)
+        self._session_triggers: Dict[str, "TurnTrigger"] = {}  # Cache triggers per session
 
         # Owner id for DB-backed lease locks (cross-process).
         try:
@@ -238,7 +246,7 @@ class DialogueWatcher:
         self.processing_turn_ttl_seconds = 20 * 60  # 20 minutes
 
         # Signal directory for Stop hook integration
-        self.signal_dir = Path.home() / '.aline' / '.signals'
+        self.signal_dir = Path.home() / ".aline" / ".signals"
         self.signal_dir.mkdir(parents=True, exist_ok=True)
         self.user_prompt_signal_dir = self.signal_dir / "user_prompt_submit"
         self.user_prompt_signal_dir.mkdir(parents=True, exist_ok=True)
@@ -257,14 +265,20 @@ class DialogueWatcher:
         logger.info(f"Supports: Claude Code & Codex (auto-detected)")
         logger.info(f"Debounce: {self.debounce_delay}s, Cooldown: {self.min_commit_interval}s")
         print("[Watcher] Started watching for dialogue completion", file=sys.stderr)
-        print(f"[Watcher] Mode: Multi-project monitoring (all Claude Code projects)", file=sys.stderr)
+        print(
+            f"[Watcher] Mode: Multi-project monitoring (all Claude Code projects)", file=sys.stderr
+        )
         print(f"[Watcher] Trigger: Per-request (at end of each AI response)", file=sys.stderr)
         print(f"[Watcher] Supports: Claude Code & Codex (auto-detected)", file=sys.stderr)
-        print(f"[Watcher] Debounce: {self.debounce_delay}s, Cooldown: {self.min_commit_interval}s", file=sys.stderr)
+        print(
+            f"[Watcher] Debounce: {self.debounce_delay}s, Cooldown: {self.min_commit_interval}s",
+            file=sys.stderr,
+        )
 
         # Auto-install Claude Code Stop hook for reliable turn completion detection
         try:
             from .claude_hooks.stop_hook_installer import ensure_stop_hook_installed
+
             if ensure_stop_hook_installed(quiet=True):
                 logger.info("Claude Code Stop hook is ready")
             else:
@@ -278,6 +292,7 @@ class DialogueWatcher:
                 from .claude_hooks.user_prompt_submit_hook_installer import (
                     ensure_user_prompt_submit_hook_installed,
                 )
+
                 if ensure_user_prompt_submit_hook_installed(quiet=True):
                     logger.info("Claude Code UserPromptSubmit hook is ready")
                 else:
@@ -346,13 +361,13 @@ class DialogueWatcher:
             if not self.signal_dir.exists():
                 return
 
-            for signal_file in self.signal_dir.glob('*.signal'):
+            for signal_file in self.signal_dir.glob("*.signal"):
                 try:
                     # Read signal data
                     signal_data = json.loads(signal_file.read_text())
-                    session_id = signal_data.get('session_id', '')
-                    project_dir = signal_data.get('project_dir', '')
-                    transcript_path = signal_data.get('transcript_path', '')
+                    session_id = signal_data.get("session_id", "")
+                    project_dir = signal_data.get("project_dir", "")
+                    transcript_path = signal_data.get("transcript_path", "")
 
                     logger.info(f"Stop signal received for session {session_id}")
                     print(f"[Watcher] Stop signal received for {session_id}", file=sys.stderr)
@@ -389,7 +404,9 @@ class DialogueWatcher:
                                     session_type=self._detect_session_type(session_file),
                                 )
                             except Exception as e:
-                                logger.warning(f"Failed to enqueue stop-hook job for {session_id}: {e}")
+                                logger.warning(
+                                    f"Failed to enqueue stop-hook job for {session_id}: {e}"
+                                )
                                 continue
 
                             logger.info(
@@ -400,7 +417,9 @@ class DialogueWatcher:
                                 file=sys.stderr,
                             )
                         else:
-                            logger.warning(f"Could not determine project path for session {session_id}")
+                            logger.warning(
+                                f"Could not determine project path for session {session_id}"
+                            )
                     else:
                         logger.warning(f"Session file not found for {session_id}")
 
@@ -492,9 +511,9 @@ class DialogueWatcher:
                 return 0
 
             # For Claude trigger, use get_detailed_analysis to get total turns
-            if hasattr(trigger, 'get_detailed_analysis'):
+            if hasattr(trigger, "get_detailed_analysis"):
                 analysis = trigger.get_detailed_analysis(session_file)
-                return analysis.get('total_turns', 0)
+                return analysis.get("total_turns", 0)
 
             # Fallback: use count_complete_turns + 1 (assuming last turn just completed)
             return trigger.count_complete_turns(session_file) + 1
@@ -537,7 +556,7 @@ class DialogueWatcher:
         """
         try:
             # Search in Claude Code sessions directory
-            claude_base = Path.home() / '.claude' / 'projects'
+            claude_base = Path.home() / ".claude" / "projects"
             if claude_base.exists():
                 for project_dir in claude_base.iterdir():
                     if project_dir.is_dir():
@@ -559,11 +578,11 @@ class DialogueWatcher:
 
     def _get_session_stats(self) -> tuple[Dict[str, int], Dict[str, float]]:
         """Get (sizes, mtimes) for all active session files.
-        
+
         For directory-based sessions (e.g., Antigravity), computes:
         - size: sum of all artifact file sizes
         - mtime: max mtime of all artifact files
-        
+
         This ensures changes to individual artifacts are detected.
         """
         sizes: Dict[str, int] = {}
@@ -574,21 +593,21 @@ class DialogueWatcher:
                 if not session_file.exists():
                     continue
                 path_key = str(session_file)
-                
+
                 # Handle directory-based sessions (e.g., Antigravity brain directories)
                 if session_file.is_dir():
                     # Check for Antigravity-style artifacts
                     artifacts = ["task.md", "walkthrough.md", "implementation_plan.md"]
                     total_size = 0
                     max_mtime = 0.0
-                    
+
                     for artifact_name in artifacts:
                         artifact_path = session_file / artifact_name
                         if artifact_path.exists():
                             artifact_stat = artifact_path.stat()
                             total_size += artifact_stat.st_size
                             max_mtime = max(max_mtime, artifact_stat.st_mtime)
-                    
+
                     # Only track if at least one artifact exists
                     if max_mtime > 0:
                         sizes[path_key] = total_size
@@ -602,12 +621,21 @@ class DialogueWatcher:
             logger.debug(f"Tracked {len(sizes)} session file(s) across all projects")
         except PermissionError as e:
             # macOS permission issue - only log once
-            if not hasattr(self, '_permission_error_logged'):
+            if not hasattr(self, "_permission_error_logged"):
                 self._permission_error_logged = True
                 logger.error("PERMISSION DENIED: Cannot access Claude Code sessions directory")
-                print("[Watcher] ✗ PERMISSION DENIED: Cannot access ~/.claude/projects/", file=sys.stderr)
-                print("[Watcher] ⓘ Grant Full Disk Access to Acme in System Preferences", file=sys.stderr)
-                print("[Watcher] ⓘ System Preferences → Privacy & Security → Full Disk Access → Add Acme", file=sys.stderr)
+                print(
+                    "[Watcher] ✗ PERMISSION DENIED: Cannot access ~/.claude/projects/",
+                    file=sys.stderr,
+                )
+                print(
+                    "[Watcher] ⓘ Grant Full Disk Access to Acme in System Preferences",
+                    file=sys.stderr,
+                )
+                print(
+                    "[Watcher] ⓘ System Preferences → Privacy & Security → Full Disk Access → Add Acme",
+                    file=sys.stderr,
+                )
         except Exception as e:
             logger.error(f"Error getting session stats: {e}", exc_info=True)
             print(f"[Watcher] Error getting session stats: {e}", file=sys.stderr)
@@ -671,13 +699,21 @@ class DialogueWatcher:
             session_files.sort(key=lambda f: f.stat().st_mtime if f.exists() else 0, reverse=True)
 
             # Limit to max_catchup_sessions
-            max_sessions = getattr(self.config, 'max_catchup_sessions', 3)
+            max_sessions = getattr(self.config, "max_catchup_sessions", 3)
             if len(session_files) > max_sessions:
                 sessions_to_process = session_files[:max_sessions]
                 skipped_count = len(session_files) - max_sessions
-                logger.info(f"Limiting catch-up to {max_sessions} most recent sessions, skipping {skipped_count} older sessions")
-                print(f"[Watcher] Limiting catch-up to {max_sessions} most recent sessions ({skipped_count} skipped)", file=sys.stderr)
-                print(f"[Watcher] Use 'aline watcher session list' to see all sessions", file=sys.stderr)
+                logger.info(
+                    f"Limiting catch-up to {max_sessions} most recent sessions, skipping {skipped_count} older sessions"
+                )
+                print(
+                    f"[Watcher] Limiting catch-up to {max_sessions} most recent sessions ({skipped_count} skipped)",
+                    file=sys.stderr,
+                )
+                print(
+                    f"[Watcher] Use 'aline watcher session list' to see all sessions",
+                    file=sys.stderr,
+                )
             else:
                 sessions_to_process = session_files
 
@@ -709,8 +745,13 @@ class DialogueWatcher:
                     self.last_stop_reason_counts[str(session_file)] = current_count
                     continue
 
-                logger.info(f"Catch-up: {session_file.name} missing {len(missing_turns)} turn(s): {missing_turns}")
-                print(f"[Watcher] Catch-up {session_file.name}: {len(missing_turns)} missing turn(s)", file=sys.stderr)
+                logger.info(
+                    f"Catch-up: {session_file.name} missing {len(missing_turns)} turn(s): {missing_turns}"
+                )
+                print(
+                    f"[Watcher] Catch-up {session_file.name}: {len(missing_turns)} missing turn(s)",
+                    file=sys.stderr,
+                )
 
                 enqueued = 0
                 for turn in missing_turns:
@@ -723,11 +764,15 @@ class DialogueWatcher:
                         )
                         enqueued += 1
                     except Exception as e:
-                        logger.warning(f"Error enqueuing catch-up for {session_file.name} turn {turn}: {e}")
+                        logger.warning(
+                            f"Error enqueuing catch-up for {session_file.name} turn {turn}: {e}"
+                        )
 
                 if enqueued:
                     # Align baseline for future polling (Claude baseline excludes last turn).
-                    self.last_stop_reason_counts[str(session_file)] = self._count_complete_turns(session_file)
+                    self.last_stop_reason_counts[str(session_file)] = self._count_complete_turns(
+                        session_file
+                    )
 
         except Exception as e:
             logger.error(f"Catch-up error: {e}", exc_info=True)
@@ -735,7 +780,7 @@ class DialogueWatcher:
     def _get_file_hash(self, session_file: Path) -> Optional[str]:
         """Compute MD5 hash of session file for duplicate detection."""
         try:
-            with open(session_file, 'rb') as f:
+            with open(session_file, "rb") as f:
                 md5_hash = hashlib.md5()
                 while chunk := f.read(8192):
                     md5_hash.update(chunk)
@@ -806,7 +851,12 @@ class DialogueWatcher:
                                         try:
                                             age_seconds = max(
                                                 0.0,
-                                                (datetime.now() - getattr(existing, "created_at", datetime.now())).total_seconds(),
+                                                (
+                                                    datetime.now()
+                                                    - getattr(
+                                                        existing, "created_at", datetime.now()
+                                                    )
+                                                ).total_seconds(),
                                             )
                                         except Exception:
                                             age_seconds = 0.0
@@ -836,7 +886,9 @@ class DialogueWatcher:
 
                         project_path = self._extract_project_path(session_file)
                         if not project_path:
-                            logger.debug(f"Skipping enqueue for {session_file.name}: could not extract project path")
+                            logger.debug(
+                                f"Skipping enqueue for {session_file.name}: could not extract project path"
+                            )
                             # Mark as attempted to avoid spamming logs
                             self.last_final_commit_times[session_path] = current_time
                             continue
@@ -859,7 +911,8 @@ class DialogueWatcher:
                         if enqueued_any:
                             # Baseline follows completed_count (Claude excludes last turn by design).
                             self.last_stop_reason_counts[session_path] = max(
-                                self.last_stop_reason_counts.get(session_path, 0), int(completed_count)
+                                self.last_stop_reason_counts.get(session_path, 0),
+                                int(completed_count),
                             )
 
                         self.last_final_commit_times[session_path] = current_time
@@ -879,20 +932,23 @@ class DialogueWatcher:
         try:
             # Use AdapterRegistry to find the right adapter
             from .adapters import get_adapter_registry
+
             registry = get_adapter_registry()
-            
+
             adapter = registry.auto_detect_adapter(session_file)
             if adapter:
                 project_path = adapter.extract_project_path(session_file)
                 if project_path:
                     return project_path
-                    
+
             # Fallback for legacy logic if adapter returns None or no adapter found
             # (Keep existing logic as backup if needed, or rely on adapters)
-            
+
             # Method 3: For Gemini CLI / Antigravity - return a pseudo path if adapter failed
-            if '.gemini/' in str(session_file):
-                logger.debug(f"Gemini/Antigravity session detected, using home as pseudo project fallback: {session_file.name}")
+            if ".gemini/" in str(session_file):
+                logger.debug(
+                    f"Gemini/Antigravity session detected, using home as pseudo project fallback: {session_file.name}"
+                )
                 return Path.home()
 
             logger.debug(f"Could not extract project path from {session_file.name}")
@@ -909,6 +965,7 @@ class DialogueWatcher:
         try:
             # Delegate to registry logic to ensure consistency
             from .adapters import get_adapter_registry
+
             registry = get_adapter_registry()
             adapter = registry.auto_detect_adapter(session_file)
             if adapter:
@@ -917,37 +974,41 @@ class DialogueWatcher:
                 name = adapter.name
                 if name in ["claude", "codex", "gemini", "antigravity"]:
                     return name
-            
+
             return "unknown"
 
         except Exception as e:
-            print(f"[Watcher] Error detecting session type for {session_file.name}: {e}", file=sys.stderr)
+            print(
+                f"[Watcher] Error detecting session type for {session_file.name}: {e}",
+                file=sys.stderr,
+            )
             return "unknown"
 
     def _get_trigger_for_session(self, session_file: Path):
         """
         获取或创建session的trigger
-        
+
         Args:
             session_file: session文件路径
-            
+
         Returns:
             TurnTrigger实例，如果session类型不支持则返回None
         """
         session_path = str(session_file)
-        
+
         if session_path not in self._session_triggers:
             # Use registry to get adapter and trigger
             from .adapters import get_adapter_registry
+
             registry = get_adapter_registry()
             adapter = registry.auto_detect_adapter(session_file)
-            
+
             if not adapter:
                 logger.error(f"Unknown session type for {session_file.name}, cannot select trigger")
                 return None
-                
+
             self._session_triggers[session_path] = adapter.trigger
-            
+
         return self._session_triggers[session_path]
 
     def _count_complete_turns(self, session_file: Path) -> int:
@@ -991,7 +1052,9 @@ class DialogueWatcher:
 
                 if size != old_size or (mtime is not None and mtime != old_mtime):
                     changed_files.append(Path(path))
-                    logger.debug(f"Session file changed: {Path(path).name} (size {old_size} -> {size} bytes)")
+                    logger.debug(
+                        f"Session file changed: {Path(path).name} (size {old_size} -> {size} bytes)"
+                    )
                     # Any activity should reset idle final-commit attempts
                     self.last_final_commit_times.pop(path, None)
 
@@ -1003,12 +1066,16 @@ class DialogueWatcher:
 
                 # Only create new task if no pending task or previous one completed
                 if not self.pending_commit_task or self.pending_commit_task.done():
-                    logger.info(f"Scheduling commit check for {len(self._pending_changed_files)} session file(s)")
+                    logger.info(
+                        f"Scheduling commit check for {len(self._pending_changed_files)} session file(s)"
+                    )
                     self.pending_commit_task = asyncio.create_task(
                         self._debounced_commit_accumulated()
                     )
                 else:
-                    logger.debug(f"Accumulated {len(changed_files)} file(s), total pending: {len(self._pending_changed_files)}")
+                    logger.debug(
+                        f"Accumulated {len(changed_files)} file(s), total pending: {len(self._pending_changed_files)}"
+                    )
 
             # Update tracked sizes
             self.last_session_sizes = current_sizes
@@ -1227,7 +1294,9 @@ class DialogueWatcher:
                 if target_turn:
                     current_count = max(current_count, target_turn)
                 self.last_stop_reason_counts[session_path] = current_count
-                logger.debug(f"Updated turn count baseline for {session_file.name}: {current_count}")
+                logger.debug(
+                    f"Updated turn count baseline for {session_file.name}: {current_count}"
+                )
             else:
                 logger.warning(f"Commit failed for {project_path.name}")
 
@@ -1249,7 +1318,7 @@ class DialogueWatcher:
         debug_callback: Optional[Callable[[Dict[str, Any]], None]] = None,
         skip_dedup: bool = False,
         skip_session_summary: bool = False,
-        ) -> bool:
+    ) -> bool:
         """
         Execute commit with DB-backed lease locking to prevent cross-process races.
 
@@ -1348,10 +1417,13 @@ class DialogueWatcher:
             # Extract session information
             session_id = session_file.stem  # e.g., "minhao_claude_abc123"
             turn_number = target_turn or self._get_current_turn_number(session_file)
-            user_message = user_message_override or self._extract_user_message_for_turn(session_file, turn_number)
+            user_message = user_message_override or self._extract_user_message_for_turn(
+                session_file, turn_number
+            )
 
             # V9: Get user identity for creator tracking
             from .config import ReAlignConfig
+
             config = ReAlignConfig.load()
 
             # Compute hash of current turn content (not the whole session file)
@@ -1368,7 +1440,9 @@ class DialogueWatcher:
             db = get_database()
 
             file_stat = session_file.stat()
-            file_created = datetime.fromtimestamp(getattr(file_stat, "st_birthtime", file_stat.st_ctime))
+            file_created = datetime.fromtimestamp(
+                getattr(file_stat, "st_birthtime", file_stat.st_ctime)
+            )
             db.get_or_create_session(
                 session_id=session_id,
                 session_file_path=session_file,
@@ -1390,7 +1464,10 @@ class DialogueWatcher:
                     try:
                         age_seconds = max(
                             0.0,
-                            (datetime.now() - getattr(existing_turn, "created_at", datetime.now())).total_seconds(),
+                            (
+                                datetime.now()
+                                - getattr(existing_turn, "created_at", datetime.now())
+                            ).total_seconds(),
                         )
                     except Exception:
                         age_seconds = 0.0
@@ -1463,6 +1540,7 @@ class DialogueWatcher:
 
                     # Check if it's an API key problem
                     from .hooks import get_last_llm_error
+
                     last_error = get_last_llm_error()
                     if last_error:
                         if "API_KEY not set" in last_error or "api_key" in last_error.lower():
@@ -1490,7 +1568,11 @@ class DialogueWatcher:
                     print(f"[Watcher] ✗ Invalid commit message title: '{title}'", file=sys.stderr)
                     raise RuntimeError(f"Invalid LLM title: {title!r}")
 
-                if title.strip() in ["{", "}", "[", "]"] or title.startswith("{") and not title.endswith("}"):
+                if (
+                    title.strip() in ["{", "}", "[", "]"]
+                    or title.startswith("{")
+                    and not title.endswith("}")
+                ):
                     logger.error(f"Title appears to be truncated JSON: '{title}' - skipping commit")
                     print(f"[Watcher] ✗ Truncated JSON in title: '{title}'", file=sys.stderr)
                     raise RuntimeError(f"Truncated JSON title: {title!r}")
@@ -1526,7 +1608,10 @@ class DialogueWatcher:
             except Exception as e:
                 # If we were taking over a stale processing turn, a failure here should stop further retries.
                 if takeover_attempt:
-                    logger.error(f"Takeover attempt failed for {session_id} #{turn_number}: {e}", exc_info=True)
+                    logger.error(
+                        f"Takeover attempt failed for {session_id} #{turn_number}: {e}",
+                        exc_info=True,
+                    )
                     failed_turn = TurnRecord(
                         id=str(uuid.uuid4()),
                         session_id=session_id,
@@ -1577,7 +1662,9 @@ class DialogueWatcher:
             logger.error(f"Failed to find latest session: {e}")
             return None
 
-    def _handle_session_redaction(self, session_file: Path, project_path: Path, quiet: bool = False) -> Path:
+    def _handle_session_redaction(
+        self, session_file: Path, project_path: Path, quiet: bool = False
+    ) -> Path:
         """Check and redact sensitive information from session file.
 
         Args:
@@ -1594,7 +1681,7 @@ class DialogueWatcher:
         try:
             from .redactor import check_and_redact_session, save_original_session
 
-            content = session_file.read_text(encoding='utf-8')
+            content = session_file.read_text(encoding="utf-8")
             redacted_content, has_secrets, secrets = check_and_redact_session(
                 content, redact_mode="auto", quiet=quiet
             )
@@ -1602,7 +1689,7 @@ class DialogueWatcher:
             if has_secrets:
                 logger.warning(f"Secrets detected: {len(secrets)} secret(s)")
                 backup_path = save_original_session(session_file, project_path)
-                session_file.write_text(redacted_content, encoding='utf-8')
+                session_file.write_text(redacted_content, encoding="utf-8")
                 logger.info(f"Session redacted, original saved to {backup_path}")
 
             return session_file
@@ -1630,7 +1717,7 @@ class DialogueWatcher:
         try:
             user_messages = []
 
-            with open(session_file, 'r', encoding='utf-8') as f:
+            with open(session_file, "r", encoding="utf-8") as f:
                 for line in f:
                     try:
                         data = json.loads(line.strip())
@@ -1716,6 +1803,7 @@ class DialogueWatcher:
                 return
 
             from .hooks import clean_user_message
+
             user_message = clean_user_message(prompt) if prompt else ""
             if not user_message:
                 user_message = str(group.get("user_message") or "")
@@ -1743,7 +1831,9 @@ class DialogueWatcher:
             db = get_database()
 
             file_stat = session_file.stat()
-            file_created = datetime.fromtimestamp(getattr(file_stat, "st_birthtime", file_stat.st_ctime))
+            file_created = datetime.fromtimestamp(
+                getattr(file_stat, "st_birthtime", file_stat.st_ctime)
+            )
 
             project_path = None
             if project_dir:
@@ -1830,14 +1920,21 @@ class DialogueWatcher:
                 if turn_info and turn_info.get("turn_content"):
                     return turn_info["turn_content"]
                 # Fallback: construct content from group data
-                return json.dumps({
-                    "turn_number": turn_number,
-                    "user_message": group.get("user_message", ""),
-                    "assistant_response": group.get("summary_message", ""),
-                }, ensure_ascii=False, indent=2)
+                return json.dumps(
+                    {
+                        "turn_number": turn_number,
+                        "user_message": group.get("user_message", ""),
+                        "assistant_response": group.get("summary_message", ""),
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
 
             if session_format == "antigravity_markdown":
-                print(f"[Debug] Extracting Antigravity content for turn {turn_number}", file=sys.stderr)
+                print(
+                    f"[Debug] Extracting Antigravity content for turn {turn_number}",
+                    file=sys.stderr,
+                )
                 # Directly read artifact files from directory (don't rely on trigger.user_message which is empty)
                 session_dir = session_file if session_file.is_dir() else session_file.parent
                 artifacts = ["task.md", "walkthrough.md", "implementation_plan.md"]
@@ -1846,15 +1943,20 @@ class DialogueWatcher:
                     path = session_dir / filename
                     if path.exists():
                         try:
-                            text = path.read_text(encoding='utf-8')
+                            text = path.read_text(encoding="utf-8")
                             content_parts.append(f"--- {filename} ---\n{text}")
                         except Exception as e:
                             print(f"[Debug] Failed to read {filename}: {e}", file=sys.stderr)
                 full_content = "\n\n".join(content_parts)
                 if full_content:
-                    print(f"[Debug] Antigravity content extracted: {len(full_content)} chars", file=sys.stderr)
+                    print(
+                        f"[Debug] Antigravity content extracted: {len(full_content)} chars",
+                        file=sys.stderr,
+                    )
                     return full_content
-                print(f"[Debug] Antigravity content empty - no artifact files found", file=sys.stderr)
+                print(
+                    f"[Debug] Antigravity content empty - no artifact files found", file=sys.stderr
+                )
                 return ""
 
             # For JSONL formats, extract by line numbers
@@ -1864,7 +1966,7 @@ class DialogueWatcher:
                 return ""
 
             lines = []
-            with open(session_file, 'r', encoding='utf-8') as f:
+            with open(session_file, "r", encoding="utf-8") as f:
                 for idx, line in enumerate(f, 1):
                     if start_line <= idx <= end_line:
                         lines.append(line)
@@ -1880,7 +1982,7 @@ class DialogueWatcher:
         """Extract a summary of the assistant's response from session file."""
         try:
             if session_file.is_dir():
-                # For directory sessions (Antigravity), we don't have a simple way to extract assistant summary 
+                # For directory sessions (Antigravity), we don't have a simple way to extract assistant summary
                 # from a single file scan. Return generic message or use trigger if possible.
                 return "Antigravity Session State"
 
@@ -1894,11 +1996,11 @@ class DialogueWatcher:
         try:
             # Extract last assistant response text
             assistant_text = ""
-            
+
             if session_file.is_dir():
                 return "Antigravity Session"
 
-            with open(session_file, 'r', encoding='utf-8') as f:
+            with open(session_file, "r", encoding="utf-8") as f:
                 for line in f:
                     try:
                         data = json.loads(line.strip())
@@ -1940,8 +2042,8 @@ class DialogueWatcher:
         try:
             if session_file.is_dir():
                 return None
-                
-            with open(session_file, 'r', encoding='utf-8') as f:
+
+            with open(session_file, "r", encoding="utf-8") as f:
                 lines = f.readlines()
 
             for line in reversed(lines):
@@ -1994,15 +2096,15 @@ class DialogueWatcher:
                 # or extracting just the User Message to identify intent.
                 trigger = self._get_trigger_for_session(session_file)
                 if trigger:
-                     # Get current turn number
-                     turn = self._get_current_turn_number(session_file)
-                     info = trigger.extract_turn_info(session_file, turn)
-                     if info:
-                         return info.user_message
+                    # Get current turn number
+                    turn = self._get_current_turn_number(session_file)
+                    info = trigger.extract_turn_info(session_file, turn)
+                    if info:
+                        return info.user_message
                 return ""
 
             # Read all lines and track user message positions
-            with open(session_file, 'r', encoding='utf-8') as f:
+            with open(session_file, "r", encoding="utf-8") as f:
                 for idx, line in enumerate(f):
                     lines.append(line)
                     try:
@@ -2014,16 +2116,21 @@ class DialogueWatcher:
                             # Check if this is a real user message (not tool result, IDE notification, etc.)
                             is_real_message = False
                             if isinstance(content, str):
-                                if not content.startswith("This session is being continued") and \
-                                   not content.startswith("<ide_opened_file>"):
+                                if not content.startswith(
+                                    "This session is being continued"
+                                ) and not content.startswith("<ide_opened_file>"):
                                     is_real_message = True
                             elif isinstance(content, list):
-                                text_parts = [item.get("text", "") for item in content
-                                            if isinstance(item, dict) and item.get("type") == "text"]
+                                text_parts = [
+                                    item.get("text", "")
+                                    for item in content
+                                    if isinstance(item, dict) and item.get("type") == "text"
+                                ]
                                 if text_parts:
                                     combined_text = "\n".join(text_parts)
-                                    if not combined_text.startswith("This session is being continued") and \
-                                       not combined_text.startswith("<ide_opened_file>"):
+                                    if not combined_text.startswith(
+                                        "This session is being continued"
+                                    ) and not combined_text.startswith("<ide_opened_file>"):
                                         is_real_message = True
 
                             if is_real_message:
@@ -2089,6 +2196,7 @@ class DialogueWatcher:
             try:
                 # Get recent turns from database for context
                 from .db import get_database
+
                 db = get_database()
                 session_id = resolved_session_id
                 recent_turns = db.get_turns_for_session(session_id)
@@ -2100,7 +2208,9 @@ class DialogueWatcher:
                     # Get the most recent title
                     if previous_records:
                         previous_commit_title = previous_records[-1]
-                        recent_ctx = "Recent turns:\n" + "\n".join(f"- {t}" for t in previous_records)
+                        recent_ctx = "Recent turns:\n" + "\n".join(
+                            f"- {t}" for t in previous_records
+                        )
             except Exception:
                 recent_ctx = ""
                 previous_records = []
@@ -2115,7 +2225,14 @@ class DialogueWatcher:
                 try:
                     trigger = self._get_trigger_for_session(session_file)
                     analysis = trigger.get_detailed_analysis(session_file)
-                    group = next((g for g in analysis.get("groups", []) if g.get("turn_number") == turn_number), None)
+                    group = next(
+                        (
+                            g
+                            for g in analysis.get("groups", [])
+                            if g.get("turn_number") == turn_number
+                        ),
+                        None,
+                    )
                 except Exception:
                     group = None
 
@@ -2129,43 +2246,77 @@ class DialogueWatcher:
                 turn_status = group.get("turn_status") or turn_status
 
             # Robust fallback for directory sessions (Antigravity) if group lookup failed
-            if session_file is not None and session_file.is_dir() and (not user_message or not assistant_summary):
+            if (
+                session_file is not None
+                and session_file.is_dir()
+                and (not user_message or not assistant_summary)
+            ):
                 logger.info("Using fallback extraction for Antigravity directory session")
-                print(f"[Debug] Antigravity fallback: user_message={bool(user_message)}, assistant_summary={bool(assistant_summary)}", file=sys.stderr)
+                print(
+                    f"[Debug] Antigravity fallback: user_message={bool(user_message)}, assistant_summary={bool(assistant_summary)}",
+                    file=sys.stderr,
+                )
                 if not user_message:
                     # For Antigravity, turn_content is essentially the user message (full state)
                     user_message = turn_content
-                    print(f"[Debug] Set user_message from turn_content: {len(user_message) if user_message else 0} chars", file=sys.stderr)
+                    print(
+                        f"[Debug] Set user_message from turn_content: {len(user_message) if user_message else 0} chars",
+                        file=sys.stderr,
+                    )
                 if not assistant_summary:
                     assistant_summary = "Antigravity Session State"
                 turn_status = "completed"
 
-            print(f"[Debug] Before LLM call: user_message={len(user_message) if user_message else 0} chars, assistant_summary={bool(assistant_summary)}", file=sys.stderr)
+            print(
+                f"[Debug] Before LLM call: user_message={len(user_message) if user_message else 0} chars, assistant_summary={bool(assistant_summary)}",
+                file=sys.stderr,
+            )
             if user_message and assistant_summary:
                 from .hooks import generate_summary_with_llm_from_turn_context
+
                 # Pass full turn content to include all messages (user, assistant text, thinking)
                 # but exclude tool use and code changes (handled by filter_session_content)
-                title, model_name, description, if_last_task, satisfaction = generate_summary_with_llm_from_turn_context(
-                    user_message=user_message,
-                    assistant_summary=assistant_summary,
-                    turn_status=turn_status,
-                    recent_commit_context=recent_ctx,
-                    provider=self.config.llm_provider,
-                    previous_commit_title=previous_commit_title,
-                    full_turn_content=turn_content,  # Pass full turn content
-                    previous_records=previous_records,  # Pass extracted records from git history
-                    debug_callback=debug_callback,  # Pass debug callback
+                title, model_name, description, if_last_task, satisfaction = (
+                    generate_summary_with_llm_from_turn_context(
+                        user_message=user_message,
+                        assistant_summary=assistant_summary,
+                        turn_status=turn_status,
+                        recent_commit_context=recent_ctx,
+                        provider=self.config.llm_provider,
+                        previous_commit_title=previous_commit_title,
+                        full_turn_content=turn_content,  # Pass full turn content
+                        previous_records=previous_records,  # Pass extracted records from git history
+                        debug_callback=debug_callback,  # Pass debug callback
+                    )
                 )
 
                 if title:
                     logger.info(f"Generated LLM summary from turn context using {model_name}")
-                    print(f"[Watcher] ✓ Generated summary from turn context ({model_name})", file=sys.stderr)
-                    return (title, model_name or "unknown", description or "", if_last_task, satisfaction)
+                    print(
+                        f"[Watcher] ✓ Generated summary from turn context ({model_name})",
+                        file=sys.stderr,
+                    )
+                    return (
+                        title,
+                        model_name or "unknown",
+                        description or "",
+                        if_last_task,
+                        satisfaction,
+                    )
 
                 if session_file is not None and session_file.is_dir():
                     # Fallback if LLM fails for Antigravity
-                    print(f"[Watcher] ⚠ LLM summary failed/empty, using generic fallback for Antigravity", file=sys.stderr)
-                    return ("Update Antigravity Brain", "fallback", "Automatic update of brain artifacts", "yes", "fine")
+                    print(
+                        f"[Watcher] ⚠ LLM summary failed/empty, using generic fallback for Antigravity",
+                        file=sys.stderr,
+                    )
+                    return (
+                        "Update Antigravity Brain",
+                        "fallback",
+                        "Automatic update of brain artifacts",
+                        "yes",
+                        "fine",
+                    )
 
             # Fallback: Extract turn content and use the legacy pipeline
             if turn_content is None and session_file is not None:
@@ -2196,7 +2347,6 @@ class DialogueWatcher:
                 except Exception:
                     pass
 
-
             # Use direct API calls for LLM summary
             from .hooks import generate_summary_with_llm
 
@@ -2212,14 +2362,29 @@ class DialogueWatcher:
                 if model_name:
                     logger.info(f"Generated LLM summary using {model_name}")
                     print(f"[Watcher] ✓ Generated LLM summary using {model_name}", file=sys.stderr)
-                return (title, model_name or "unknown", description or "", if_last_task, satisfaction)
+                return (
+                    title,
+                    model_name or "unknown",
+                    description or "",
+                    if_last_task,
+                    satisfaction,
+                )
             else:
                 logger.warning("LLM summary generation returned empty result")
 
                 if session_file is not None and session_file.is_dir():
                     # Fallback if LLM fails for Antigravity (generic path)
-                    print(f"[Watcher] ⚠ LLM summary returned empty, using fallback for Antigravity", file=sys.stderr)
-                    return ("Update Antigravity Brain", "fallback", "Automatic update of brain artifacts", "yes", "fine")
+                    print(
+                        f"[Watcher] ⚠ LLM summary returned empty, using fallback for Antigravity",
+                        file=sys.stderr,
+                    )
+                    return (
+                        "Update Antigravity Brain",
+                        "fallback",
+                        "Automatic update of brain artifacts",
+                        "yes",
+                        "fine",
+                    )
 
                 return None
 
@@ -2229,16 +2394,25 @@ class DialogueWatcher:
 
             # Record the error for later use in fallback logic
             from .hooks import set_last_llm_error
+
             set_last_llm_error(str(e))
 
             # Robust fallback for Antigravity directory sessions if anything fails
             if session_file is not None and session_file.is_dir():
-                 print(f"[Watcher] ⚠ Using generic fallback after exception for Antigravity", file=sys.stderr)
-                 return ("Update Antigravity Brain", "fallback", "Automatic update of brain artifacts", "yes", "fine")
+                print(
+                    f"[Watcher] ⚠ Using generic fallback after exception for Antigravity",
+                    file=sys.stderr,
+                )
+                return (
+                    "Update Antigravity Brain",
+                    "fallback",
+                    "Automatic update of brain artifacts",
+                    "yes",
+                    "fine",
+                )
 
             return None
 
-
     @staticmethod
     def _extract_latest_commit_title(context: str) -> Optional[str]:
         """
@@ -2273,11 +2447,11 @@ class DialogueWatcher:
                 # For directories, just use creation time
                 try:
                     stat = session_file.stat()
-                    return getattr(stat, 'st_birthtime', stat.st_ctime)
+                    return getattr(stat, "st_birthtime", stat.st_ctime)
                 except:
                     return session_file.stat().st_ctime
 
-            with open(session_file, 'r', encoding='utf-8') as f:
+            with open(session_file, "r", encoding="utf-8") as f:
                 for line in f:
                     try:
                         data = json.loads(line.strip())
@@ -2287,7 +2461,8 @@ class DialogueWatcher:
                         if timestamp_str:
                             # Parse ISO 8601 timestamp
                             from datetime import datetime
-                            dt = datetime.fromisoformat(timestamp_str.replace('Z', '+00:00'))
+
+                            dt = datetime.fromisoformat(timestamp_str.replace("Z", "+00:00"))
                             return dt.timestamp()
 
                     except (json.JSONDecodeError, ValueError, KeyError):