aline-ai 0.7.2__py3-none-any.whl → 0.7.4__py3-none-any.whl

realign/watcher_core.py

@@ -10,6 +10,7 @@ import os
 import subprocess
 import sys
 import time
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Callable, Optional, Dict, Literal
 from datetime import datetime
@@ -26,6 +27,17 @@ logger = setup_logger("realign.watcher_core", "watcher_core.log")
 SessionType = Literal["claude", "codex", "gemini", "unknown"]
 
 
+@dataclass(frozen=True)
+class StartupScanReport:
+    prev_paths: int
+    prev_missing: int
+    prev_changed: int
+    scan_paths: int
+    scan_new: int
+    scan_changed: int
+    candidates: int
+
+
 def is_path_blacklisted(project_path: Path) -> bool:
     """
     Check if a project path is blacklisted for auto-init.
@@ -211,21 +223,20 @@ 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
         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
 
+        # Stop-hook signals: retry/backoff map so transient enqueue failures don't drop turns.
+        # Key: absolute signal file path.
+        self._stop_signal_retry_after: Dict[str, float] = {}
+        self._stop_signal_failures: Dict[str, int] = {}
+
         # Trigger support for pluggable turn detection
         from .triggers.registry import get_global_registry
 
@@ -250,7 +261,7 @@ class DialogueWatcher:
         self._session_list_last_scan: float = 0.0
         self._session_list_scan_interval: float = 30.0
 
-        # Layer 2: Per-cycle sizes stash (shared between check_for_changes and idle check)
+        # Layer 2: Per-cycle sizes stash (shared between check_for_changes and turn-count cache)
         self._last_cycle_sizes: Dict[str, int] = {}
 
         # Layer 3: Turn count cache (avoid re-parsing JSONL for unchanged files)
@@ -264,6 +275,199 @@ class DialogueWatcher:
         self.user_prompt_signal_dir = self.signal_dir / "user_prompt_submit"
         self.user_prompt_signal_dir.mkdir(parents=True, exist_ok=True)
 
+        # Polling control:
+        # - When the Stop hook is available, periodic session polling/scanning is unnecessary.
+        # - The watcher remains responsible for processing fallback .signal files.
+        self._polling_enabled: bool = True
+
+        # Startup scan enqueue priority (lower than realtime stop-hook/signal work).
+        self._startup_scan_priority: int = 5
+
+        # Codex notify-hook fallback:
+        # Some Codex CLIs don't support (or don't run) the Rust notify hook. When the watcher is
+        # in signal-driven mode (polling disabled), those Codex sessions would otherwise never be
+        # discovered/processed. We keep a lightweight Codex-only polling loop for that case.
+        self._codex_notify_supported: bool | None = None
+        self._codex_fallback_poll_enabled: bool = False
+        self._codex_fallback_poll_last_scan: float = 0.0
+        self._codex_fallback_poll_interval_seconds: float = 2.0
+        self._codex_fallback_last_sizes: Dict[str, int] = {}
+        self._codex_fallback_last_mtimes: Dict[str, float] = {}
+        self._codex_notify_hook_cache: dict[str, tuple[float, bool]] = {}
+        self._codex_notify_hook_cache_ttl_seconds: float = 30.0
+        try:
+            raw = os.environ.get("ALINE_CODEX_POLL_INTERVAL_SECONDS", "").strip()
+            if raw:
+                self._codex_fallback_poll_interval_seconds = max(0.5, float(raw))
+        except Exception:
+            self._codex_fallback_poll_interval_seconds = 2.0
+
+    def _codex_notify_hook_installed_for_session_file(self, session_file: Path) -> bool | None:
+        """Best-effort detect whether Aline's Codex notify hook is installed for this session."""
+        try:
+            from .codex_hooks.notify_hook_installer import ALINE_HOOK_MARKER
+        except Exception:
+            ALINE_HOOK_MARKER = "aline-codex-notify-hook"
+
+        try:
+            from .codex_home import codex_home_from_session_file
+        except Exception:
+            codex_home_from_session_file = None  # type: ignore[assignment]
+
+        codex_home: Path | None = None
+        if codex_home_from_session_file is not None:
+            try:
+                codex_home = codex_home_from_session_file(session_file)
+            except Exception:
+                codex_home = None
+        if codex_home is None:
+            try:
+                p = session_file.resolve()
+                for parent in p.parents:
+                    if parent.name == "sessions":
+                        codex_home = parent.parent
+                        break
+            except Exception:
+                codex_home = None
+
+        if codex_home is None:
+            return None
+
+        now = time.time()
+        key = str(codex_home)
+        cached = self._codex_notify_hook_cache.get(key)
+        if cached and (now - float(cached[0] or 0.0)) < float(self._codex_notify_hook_cache_ttl_seconds):
+            return bool(cached[1])
+
+        installed = False
+        try:
+            toml_path = codex_home / "config.toml"
+            if not toml_path.exists():
+                installed = False
+            else:
+                raw = toml_path.read_text(encoding="utf-8", errors="ignore")
+                if ALINE_HOOK_MARKER in raw:
+                    installed = True
+                elif "notify" in raw and "notify_hook.py" in raw:
+                    installed = True
+                else:
+                    installed = False
+        except Exception:
+            installed = False
+
+        self._codex_notify_hook_cache[key] = (now, installed)
+        return installed
+
+    def _codex_fallback_discover_sessions(self) -> list[Path]:
+        """Discover recent Codex sessions (bounded scan), best-effort."""
+        try:
+            from .adapters import get_adapter_registry
+
+            adapter = get_adapter_registry().get_adapter("codex")
+            if not adapter:
+                return []
+            return [Path(p) for p in (adapter.discover_sessions() or [])]
+        except Exception:
+            return []
+
+    async def _codex_fallback_poll_sessions(self) -> None:
+        """Fallback: enqueue Codex session_process jobs by scanning recent session files.
+
+        Only runs when:
+        - Codex auto-detection is enabled, and
+        - watcher polling is disabled (signal-driven), and
+        - Codex notify hook isn't available/reliable.
+        """
+        if not getattr(self.config, "auto_detect_codex", False):
+            return
+        if not self._codex_fallback_poll_enabled:
+            return
+        if self._polling_enabled:
+            # Main polling already covers Codex via adapter discovery.
+            return
+
+        now = time.time()
+        interval = float(self._codex_fallback_poll_interval_seconds)
+        if (now - float(self._codex_fallback_poll_last_scan or 0.0)) < interval:
+            return
+        self._codex_fallback_poll_last_scan = now
+
+        session_files = self._codex_fallback_discover_sessions()
+        if not session_files:
+            return
+
+        current_sizes: Dict[str, int] = {}
+        current_mtimes: Dict[str, float] = {}
+        for p in session_files:
+            try:
+                st = p.stat()
+            except Exception:
+                continue
+            k = str(p)
+            try:
+                current_sizes[k] = int(st.st_size)
+                current_mtimes[k] = float(st.st_mtime)
+            except Exception:
+                continue
+
+        notify_supported = self._codex_notify_supported is True
+        changed: list[Path] = []
+        for path_key, size in current_sizes.items():
+            old_size = self._codex_fallback_last_sizes.get(path_key)
+            old_mtime = self._codex_fallback_last_mtimes.get(path_key)
+            mtime = current_mtimes.get(path_key)
+            if old_size is None or old_mtime is None:
+                changed.append(Path(path_key))
+                try:
+                    self._maybe_link_codex_terminal(Path(path_key))
+                except Exception:
+                    pass
+                continue
+            # If notify hook works *and* is installed for this CODEX_HOME, we only need
+            # "new session discovery" here. Let notify drive subsequent updates to avoid
+            # duplicate enqueues. If the hook isn't installed (common when Codex sessions are
+            # started outside dashboard-managed CODEX_HOME prep), keep polling updates so
+            # turns still get imported and titles can be generated.
+            if notify_supported:
+                try:
+                    hook_installed = self._codex_notify_hook_installed_for_session_file(Path(path_key))
+                except Exception:
+                    hook_installed = None
+                if hook_installed is True:
+                    continue
+            if size != old_size or (mtime is not None and mtime != old_mtime):
+                changed.append(Path(path_key))
+
+        self._codex_fallback_last_sizes = current_sizes
+        self._codex_fallback_last_mtimes = current_mtimes
+
+        if not changed:
+            return
+
+        try:
+            changed.sort(key=lambda p: p.stat().st_mtime if p.exists() else 0, reverse=True)
+        except Exception:
+            pass
+
+        from .db import get_database
+
+        db = get_database()
+        # Throttle burst enqueues to keep UI responsive if many Codex sessions exist.
+        for session_file in changed[:50]:
+            if not session_file.exists():
+                continue
+            try:
+                db.enqueue_session_process_job(  # type: ignore[attr-defined]
+                    session_file_path=session_file,
+                    session_id=session_file.stem,
+                    workspace_path=None,
+                    session_type="codex",
+                    source_event="codex_poll",
+                    priority=20,
+                )
+            except Exception:
+                continue
+
     def _get_cached_session_list(self, force_rescan: bool = False) -> list[Path]:
         """Return cached list of active session files, re-scanning only every 30s.
 
@@ -290,13 +494,15 @@ class DialogueWatcher:
 
         return self._cached_session_list
 
-    def _get_cycle_session_stats(self) -> tuple[list[Path], Dict[str, int], Dict[str, float]]:
+    def _get_cycle_session_stats(
+        self, *, force_rescan: bool = False
+    ) -> tuple[list[Path], Dict[str, int], Dict[str, float]]:
         """Single stat() pass per cycle over the cached session list.
 
         Returns:
             (session_files, sizes_dict, mtimes_dict)
         """
-        session_files = self._get_cached_session_list()
+        session_files = self._get_cached_session_list(force_rescan=force_rescan)
         sizes: Dict[str, int] = {}
         mtimes: Dict[str, float] = {}
         force_rescan = False
@@ -336,6 +542,208 @@ class DialogueWatcher:
         live_files = [f for f in session_files if str(f) in sizes]
         return live_files, sizes, mtimes
 
+    def _watcher_session_stats_path(self) -> Path:
+        root = Path.home() / ".aline"
+        try:
+            root.mkdir(parents=True, exist_ok=True)
+        except Exception:
+            pass
+        return root / "watcher_session_stats.json"
+
+    def _load_persisted_session_stats(self) -> dict[str, dict[str, float]]:
+        """Load last-run session stats (best-effort)."""
+        path = self._watcher_session_stats_path()
+        if not path.exists():
+            return {}
+        try:
+            raw = json.loads(path.read_text(encoding="utf-8"))
+        except Exception:
+            return {}
+        if not isinstance(raw, dict):
+            return {}
+        out: dict[str, dict[str, float]] = {}
+        for k, v in raw.items():
+            if not isinstance(k, str) or not isinstance(v, dict):
+                continue
+            try:
+                size = float(v.get("size") or 0.0)
+                mtime = float(v.get("mtime") or 0.0)
+            except Exception:
+                continue
+            out[k] = {"size": size, "mtime": mtime}
+        return out
+
+    def _save_persisted_session_stats(
+        self, sizes: Dict[str, int], mtimes: Dict[str, float]
+    ) -> None:
+        """Persist current session stats for next startup scan (best-effort, atomic)."""
+        path = self._watcher_session_stats_path()
+        tmp = path.with_suffix(".json.tmp")
+        payload: dict[str, dict[str, float]] = {}
+        for p, size in (sizes or {}).items():
+            try:
+                payload[str(p)] = {
+                    "size": float(size or 0),
+                    "mtime": float(mtimes.get(p, 0.0) or 0.0),
+                }
+            except Exception:
+                continue
+        try:
+            tmp.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+            tmp.replace(path)
+        except Exception:
+            return
+
+    def _get_stats_for_paths(self, paths: list[Path]) -> tuple[Dict[str, int], Dict[str, float]]:
+        """Stat session files by explicit path (fast path for startup scan)."""
+        sizes: Dict[str, int] = {}
+        mtimes: Dict[str, float] = {}
+        for p in paths:
+            try:
+                st = p.stat()
+            except Exception:
+                continue
+            key = str(p)
+            try:
+                sizes[key] = int(st.st_size)
+                mtimes[key] = float(st.st_mtime)
+            except Exception:
+                continue
+        return sizes, mtimes
+
+    def _startup_scan_collect_candidates(
+        self,
+    ) -> tuple[list[Path], Dict[str, int], Dict[str, float], StartupScanReport]:
+        """
+        Collect backlog session files to enqueue on startup.
+
+        Two phases:
+        1) Fast path: re-stat previously persisted session paths (no directory scan).
+        2) Full scan: scan active session directories to find new/unknown sessions.
+        """
+        prev = self._load_persisted_session_stats()
+
+        prev_paths: list[Path] = []
+        for k in prev.keys():
+            if not isinstance(k, str):
+                continue
+            if not k or k in (".", ".."):
+                continue
+            try:
+                prev_paths.append(Path(k))
+            except Exception:
+                continue
+
+        # Phase 1: fast path stats for known session file paths.
+        known_sizes, known_mtimes = self._get_stats_for_paths(prev_paths)
+        prev_missing = max(0, len(prev_paths) - len(known_sizes))
+
+        candidates: list[Path] = []
+        candidate_keys: set[str] = set()
+        prev_changed = 0
+
+        for p in prev_paths:
+            key = str(p)
+            if key not in known_sizes:
+                continue
+            size = int(known_sizes.get(key, 0) or 0)
+            mtime = float(known_mtimes.get(key, 0.0) or 0.0)
+            prev_stats = prev.get(key) or {}
+            if float(prev_stats.get("size") or 0.0) == float(size) and float(
+                prev_stats.get("mtime") or 0.0
+            ) == float(mtime):
+                continue
+            prev_changed += 1
+            if key not in candidate_keys:
+                candidates.append(p)
+                candidate_keys.add(key)
+
+        # Phase 2: full scan of watch paths to find unknown/new sessions.
+        session_files, scan_sizes, scan_mtimes = self._get_cycle_session_stats(force_rescan=True)
+        scan_new = 0
+        scan_changed = 0
+
+        for session_file in session_files:
+            key = str(session_file)
+            size = scan_sizes.get(key)
+            mtime = scan_mtimes.get(key)
+            if size is None or mtime is None:
+                continue
+            prev_stats = prev.get(key)
+            if prev_stats is None:
+                scan_new += 1
+                if key not in candidate_keys:
+                    candidates.append(session_file)
+                    candidate_keys.add(key)
+                continue
+            if float(prev_stats.get("size") or 0.0) == float(size) and float(
+                prev_stats.get("mtime") or 0.0
+            ) == float(mtime):
+                continue
+            scan_changed += 1
+            if key not in candidate_keys:
+                candidates.append(session_file)
+                candidate_keys.add(key)
+
+        # Merge baselines for next cycle; include known paths even if no longer in scan.
+        merged_sizes: Dict[str, int] = dict(known_sizes)
+        merged_sizes.update(scan_sizes)
+        merged_mtimes: Dict[str, float] = dict(known_mtimes)
+        merged_mtimes.update(scan_mtimes)
+
+        report = StartupScanReport(
+            prev_paths=len(prev_paths),
+            prev_missing=int(prev_missing),
+            prev_changed=int(prev_changed),
+            scan_paths=len(session_files),
+            scan_new=int(scan_new),
+            scan_changed=int(scan_changed),
+            candidates=len(candidates),
+        )
+        return candidates, merged_sizes, merged_mtimes, report
+
+    async def _startup_scan_enqueue_changed_sessions(self) -> None:
+        """Scan sessions once on startup and enqueue backlog work (low priority)."""
+        try:
+            candidates, sizes, mtimes, report = self._startup_scan_collect_candidates()
+
+            # Update in-memory baselines for potential later use (even if polling is disabled).
+            self.last_session_sizes = sizes
+            self.last_session_mtimes = mtimes
+
+            from .db import get_database
+
+            db = get_database()
+
+            enqueued = 0
+            for session_file in candidates:
+                try:
+                    db.enqueue_session_process_job(  # type: ignore[attr-defined]
+                        session_file_path=session_file,
+                        session_id=session_file.stem,
+                        workspace_path=None,
+                        session_type=self._detect_session_type(session_file),
+                        source_event="startup_scan",
+                        priority=self._startup_scan_priority,
+                    )
+                    enqueued += 1
+                except Exception:
+                    continue
+
+            if enqueued:
+                logger.info(
+                    "Startup scan enqueued %s session_process job(s) (prev=%s missing=%s prev_changed=%s scan=%s new=%s scan_changed=%s)",
+                    enqueued,
+                    report.prev_paths,
+                    report.prev_missing,
+                    report.prev_changed,
+                    report.scan_paths,
+                    report.scan_new,
+                    report.scan_changed,
+                )
+        except Exception as e:
+            logger.warning(f"Startup scan failed: {e}")
+
     def _get_cached_turn_counts(
         self, session_file: Path, current_mtime: float, current_size: int
     ) -> tuple[int, int]:
@@ -376,57 +784,17 @@ class DialogueWatcher:
         except Exception:
             return
 
-    def _agent_info_id_for_codex_session(
-        self, session_file: Path, *, db=None
-    ) -> Optional[str]:
-        """Best-effort: resolve agent_info_id from a codex session file."""
-        try:
-            from .codex_home import codex_home_owner_from_session_file
-        except Exception:
-            return None
-
-        try:
-            owner = codex_home_owner_from_session_file(session_file)
-        except Exception:
-            owner = None
-        if not owner or owner[0] != "terminal":
-            return None
-        terminal_id = owner[1]
-        if not terminal_id:
-            return None
-
-        try:
-            if db is None:
-                from .db import get_database
-
-                db = get_database(read_only=True)
-            agent = db.get_agent_by_id(terminal_id)
-        except Exception:
-            return None
-
-        source = (agent.source or "").strip() if agent else ""
-        if source.startswith("agent:"):
-            return source[6:]
-        return None
-
-    def _terminal_id_for_codex_session(self, session_file: Path) -> Optional[str]:
-        """Best-effort: resolve terminal_id from codex session file path."""
         try:
-            from .codex_home import codex_home_owner_from_session_file
-        except Exception:
-            return None
+            from datetime import datetime, timezone
 
-        try:
-            owner = codex_home_owner_from_session_file(session_file)
-        except Exception:
-            owner = None
-        if not owner or owner[0] != "terminal":
-            return None
-        return owner[1]
-
-        try:
-            from .codex_home import codex_home_owner_from_session_file
-            from .codex_terminal_linker import read_codex_session_meta, select_agent_for_codex_session
+            from .codex_home import (
+                agent_id_from_codex_session_file,
+                codex_home_owner_from_session_file,
+            )
+            from .codex_terminal_linker import (
+                read_codex_session_meta,
+                select_agent_for_codex_session,
+            )
             from .db import get_database
 
             meta = read_codex_session_meta(session_file)
@@ -439,11 +807,14 @@ class DialogueWatcher:
             owner = codex_home_owner_from_session_file(session_file)
             agent_id = None
             agent_info_id = None
+            path_agent_info_id = agent_id_from_codex_session_file(session_file)
+            owner_agent_info_id = path_agent_info_id
             if owner:
                 if owner[0] == "terminal":
                     agent_id = owner[1]
                 elif owner[0] == "agent":
                     agent_info_id = owner[1]
+                    owner_agent_info_id = agent_info_id
                     scoped_agents = [
                         a
                         for a in agents
@@ -460,7 +831,6 @@ class DialogueWatcher:
             if not agent_id:
                 return
 
-            owner_agent_info_id = agent_info_id
             # Get existing agent to preserve agent_info_id in source field
             existing_agent = db.get_agent_by_id(agent_id)
             agent_info_id = None
@@ -506,12 +876,84 @@ class DialogueWatcher:
             # Link session to agent_info if available (bidirectional linking)
             if agent_info_id:
                 try:
+                    # Ensure the session row exists so the agent association doesn't get lost
+                    # when this is called before the session is processed into the DB.
+                    started_at = meta.started_at
+                    if started_at is None:
+                        started_at = datetime.fromtimestamp(session_file.stat().st_mtime)
+                    elif started_at.tzinfo is not None:
+                        started_at = started_at.astimezone(timezone.utc).replace(tzinfo=None)
+                    db.get_or_create_session(
+                        session_id=session_file.stem,
+                        session_file_path=session_file,
+                        session_type="codex",
+                        started_at=started_at,
+                        workspace_path=meta.cwd,
+                        metadata={"source": "codex:watcher"},
+                        agent_id=agent_info_id,
+                    )
                     db.update_session_agent_id(session_file.stem, agent_info_id)
                 except Exception:
                     pass
         except Exception:
             return
 
+    def _agent_info_id_for_codex_session(self, session_file: Path, *, db=None) -> Optional[str]:
+        """Best-effort: resolve agent_info_id from a codex session file."""
+        try:
+            from .codex_home import (
+                agent_id_from_codex_session_file,
+                codex_home_owner_from_session_file,
+            )
+        except Exception:
+            return None
+
+        try:
+            agent_id = agent_id_from_codex_session_file(session_file)
+            if agent_id:
+                return agent_id
+        except Exception:
+            pass
+
+        try:
+            owner = codex_home_owner_from_session_file(session_file)
+        except Exception:
+            owner = None
+        if not owner or owner[0] != "terminal":
+            return None
+        terminal_id = owner[1]
+        if not terminal_id:
+            return None
+
+        try:
+            if db is None:
+                from .db import get_database
+
+                db = get_database(read_only=True)
+            agent = db.get_agent_by_id(terminal_id)
+        except Exception:
+            return None
+
+        source = (agent.source or "").strip() if agent else ""
+        if source.startswith("agent:"):
+            return source[6:]
+        return None
+
+    def _terminal_id_for_codex_session(self, session_file: Path) -> Optional[str]:
+        """Best-effort: resolve terminal_id from codex session file path."""
+        try:
+            from .codex_home import codex_home_owner_from_session_file
+        except Exception:
+            return None
+
+        try:
+            owner = codex_home_owner_from_session_file(session_file)
+        except Exception:
+            owner = None
+        if not owner or owner[0] != "terminal":
+            return None
+        return owner[1]
+
     async def start(self):
         """Start watching session files."""
         if not self.config.mcp_auto_commit:
@@ -536,17 +978,75 @@ class DialogueWatcher:
             file=sys.stderr,
         )
 
+        # Codex: require Rust CLI notify hook for reliable integration.
+        if getattr(self.config, "auto_detect_codex", False):
+            try:
+                from .codex_hooks.notify_hook_installer import codex_cli_supports_notify_hook
+
+                supported = codex_cli_supports_notify_hook()
+            except Exception:
+                supported = None
+
+            self._codex_notify_supported = supported
+
+            if supported is False:
+                # Notify hook unsupported: warn. We'll still run a Codex-only fallback poll in
+                # signal-driven mode, so sessions are discovered even without notify.
+                if not getattr(self, "_codex_legacy_warning_logged", False):
+                    self._codex_legacy_warning_logged = True
+                    msg = (
+                        "[Watcher] Codex detected, but your Codex CLI does not support the Rust "
+                        "notify hook. Please update Codex CLI to a recent Rust version. "
+                        "Falling back to lightweight Codex polling."
+                    )
+                    print(msg, file=sys.stderr)
+                    logger.warning(msg)
+            elif supported is None:
+                # If we can't detect support (e.g. codex not on PATH), don't spam logs. The
+                # fallback poll will still provide best-effort discovery.
+                self._codex_notify_supported = None
+
         # Auto-install Claude Code Stop hook for reliable turn completion detection
+        stop_hook_ready = False
         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")
+                stop_hook_ready = True
             else:
                 logger.warning("Failed to install Stop hook, falling back to polling-only mode")
         except Exception as e:
             logger.debug(f"Stop hook installation skipped: {e}")
 
+        disable_polling = os.environ.get("ALINE_WATCHER_DISABLE_POLLING", "") == "1"
+        force_polling = os.environ.get("ALINE_WATCHER_ENABLE_POLLING", "") == "1"
+        if force_polling:
+            self._polling_enabled = True
+        elif disable_polling:
+            self._polling_enabled = False
+        else:
+            # Default: no polling (event-driven hooks preferred). Use --enable env var to opt in.
+            self._polling_enabled = False
+
+        if self._polling_enabled:
+            logger.info("Watcher polling enabled (legacy fallback mode)")
+        else:
+            logger.info("Watcher polling disabled (stop-hook/signal-driven mode)")
+
+        # In signal-driven mode, also do a lightweight Codex-only fallback poll so new Codex
+        # sessions show up even before the first notify event.
+        try:
+            disable_codex_fallback = os.environ.get("ALINE_CODEX_DISABLE_FALLBACK_POLL", "") == "1"
+        except Exception:
+            disable_codex_fallback = False
+        if (
+            not disable_codex_fallback
+            and not self._polling_enabled
+            and getattr(self.config, "auto_detect_codex", False)
+        ):
+            self._codex_fallback_poll_enabled = True
+
         if self.config.enable_temp_turn_titles:
             # Auto-install Claude Code UserPromptSubmit hook for temp title generation
             try:
@@ -561,10 +1061,6 @@ class DialogueWatcher:
             except Exception as e:
                 logger.debug(f"UserPromptSubmit hook installation skipped: {e}")
 
-        # Initialize baseline sizes and stop_reason counts
-        self.last_session_sizes, self.last_session_mtimes = self._get_session_stats()
-        self.last_stop_reason_counts = self._get_stop_reason_counts()
-
         # Note: Idle timeout checking is now integrated into main loop instead of separate task
 
         # Ensure global config/database exists (no per-project init)
@@ -572,8 +1068,8 @@ class DialogueWatcher:
         print("[Watcher] Ensuring global Aline initialization", file=sys.stderr)
         await self.auto_init_projects()
 
-        # Catch up any missed turns using persistent state
-        await self._catch_up_uncommitted_turns()
+        # Startup scan: enqueue backlog sessions changed since last run (no debounce, low priority).
+        await self._startup_scan_enqueue_changed_sessions()
 
         # Poll for file changes more frequently
         while self.running:
@@ -581,19 +1077,23 @@ class DialogueWatcher:
                 # Priority 1: Check Stop hook signals (immediate trigger, no debounce)
                 await self._check_stop_signals()
 
+                # Priority 1.5: Codex notify fallback signals (rare).
+                await self._check_codex_notify_signals()
+
+                # Priority 1.6: Codex fallback polling when notify is unavailable.
+                await self._codex_fallback_poll_sessions()
+
                 # Priority 2: Check UserPromptSubmit signals (temp title generation)
                 if self.config.enable_temp_turn_titles:
                     await self._check_user_prompt_submit_signals()
 
-                # Single stat pass per cycle (Layer 2)
-                cycle_sessions, cycle_sizes, cycle_mtimes = self._get_cycle_session_stats()
-                self._last_cycle_sizes = cycle_sizes
-
-                # Priority 2: Fallback polling mechanism (with debounce)
-                await self.check_for_changes(cycle_sizes, cycle_mtimes)
+                if self._polling_enabled:
+                    # Single stat pass per cycle (Layer 2)
+                    cycle_sessions, cycle_sizes, cycle_mtimes = self._get_cycle_session_stats()
+                    self._last_cycle_sizes = cycle_sizes
 
-                # Check for idle sessions that need final commit
-                await self._check_idle_sessions_for_final_commit(cycle_sessions, cycle_mtimes)
+                    # Legacy: fallback polling mechanism (debounced)
+                    await self.check_for_changes(cycle_sizes, cycle_mtimes)
 
                 await asyncio.sleep(0.5)  # Check every 0.5 seconds for responsiveness
             except Exception as e:
@@ -606,6 +1106,10 @@ class DialogueWatcher:
         self.running = False
         if self.pending_commit_task:
             self.pending_commit_task.cancel()
+        try:
+            self._save_persisted_session_stats(self.last_session_sizes, self.last_session_mtimes)
+        except Exception:
+            pass
         logger.info("Watcher stopped")
         print("[Watcher] Stopped", file=sys.stderr)
 
@@ -628,6 +1132,12 @@ class DialogueWatcher:
 
             for signal_file in self.signal_dir.glob("*.signal"):
                 try:
+                    signal_key = str(signal_file)
+                    now = time.time()
+                    retry_after = float(self._stop_signal_retry_after.get(signal_key, 0.0) or 0.0)
+                    if retry_after and now < retry_after:
+                        continue
+
                     # Read signal data
                     signal_data = json.loads(signal_file.read_text())
                     session_id = signal_data.get("session_id", "")
@@ -641,67 +1151,69 @@ class DialogueWatcher:
 
                     # Find the session file
                     session_file = None
-                    if transcript_path and Path(transcript_path).exists():
-                        session_file = Path(transcript_path)
+                    if transcript_path:
+                        candidate = Path(transcript_path)
+                        if candidate.exists():
+                            session_file = candidate
                     elif session_id:
-                        session_file = self._find_session_by_id(session_id)
+                        # Lightweight fallback: avoid global scanning; only consider sessions we already
+                        # know about from startup scan / previous signals.
+                        for known_path in list(self.last_session_sizes.keys()):
+                            try:
+                                p = Path(known_path)
+                            except Exception:
+                                continue
+                            if p.stem != session_id:
+                                continue
+                            if p.exists():
+                                session_file = p
+                                break
 
                     if session_file and session_file.exists():
-                        # Determine project path
-                        if project_dir and Path(project_dir).exists():
-                            project_path = Path(project_dir)
-                        else:
-                            project_path = self._extract_project_path(session_file)
-
-                        if project_path:
-                            # Calculate the actual turn number that just completed.
-                            # For Claude, count_complete_turns intentionally excludes the last turn,
-                            # so we use total_turns when available.
-                            target_turn = self._get_total_turn_count(session_file)
+                        # Enqueue a per-session job; worker will determine which turns to process.
+                        from .db import get_database
 
-                            # Enqueue durable job for worker (no LLM work in watcher process).
-                            from .db import get_database
+                        db = get_database()
+                        try:
+                            db.enqueue_session_process_job(  # type: ignore[attr-defined]
+                                session_file_path=session_file,
+                                session_id=session_id or session_file.stem,
+                                workspace_path=(project_dir or None),
+                                session_type=self._detect_session_type(session_file),
+                                source_event="stop",
+                                no_track=no_track,
+                                agent_id=agent_id if agent_id else None,
+                            )
 
-                            db = get_database()
-                            try:
-                                db.enqueue_turn_summary_job(  # type: ignore[attr-defined]
-                                    session_file_path=session_file,
-                                    workspace_path=project_path,
-                                    turn_number=target_turn,
-                                    session_type=self._detect_session_type(session_file),
-                                    no_track=no_track,
-                                    agent_id=agent_id if agent_id else None,
-                                )
-                            except Exception as e:
-                                logger.warning(
-                                    f"Failed to enqueue stop-hook job for {session_id}: {e}"
-                                )
-
-                            # Directly link session to agent (in case the turn job
-                            # was already processed by polling without agent_id
-                            # and the new enqueue was deduped).
                             if agent_id and session_id:
                                 try:
                                     db.update_session_agent_id(session_id, agent_id)
                                 except Exception:
                                     pass
 
-                            logger.info(
-                                f"Enqueued turn_summary via Stop hook: {session_id} turn {target_turn} ({project_path.name})"
-                            )
-                            print(
-                                f"[Watcher] Enqueued turn_summary via Stop hook (turn {target_turn})",
-                                file=sys.stderr,
-                            )
-                        else:
+                            self._stop_signal_retry_after.pop(signal_key, None)
+                            self._stop_signal_failures.pop(signal_key, None)
+                            try:
+                                st = session_file.stat()
+                                self.last_session_sizes[str(session_file)] = int(st.st_size)
+                                self.last_session_mtimes[str(session_file)] = float(st.st_mtime)
+                            except Exception:
+                                pass
+                            signal_file.unlink(missing_ok=True)
+                        except Exception as e:
+                            failures = int(self._stop_signal_failures.get(signal_key, 0) or 0) + 1
+                            self._stop_signal_failures[signal_key] = failures
+                            delay = float(min(30.0, 1.0 * (2 ** min(failures, 5))))
+                            self._stop_signal_retry_after[signal_key] = now + delay
                             logger.warning(
-                                f"Could not determine project path for session {session_id}"
+                                f"Failed to enqueue stop-hook session_process for {session_id} (retry in {delay:.0f}s): {e}"
                             )
                     else:
                         logger.warning(f"Session file not found for {session_id}")
-
-                    # Delete the signal only after enqueue succeeds.
-                    signal_file.unlink(missing_ok=True)
+                        # Keep signal for a short time; file discovery can lag behind hook.
+                        failures = int(self._stop_signal_failures.get(signal_key, 0) or 0) + 1
+                        self._stop_signal_failures[signal_key] = failures
+                        self._stop_signal_retry_after[signal_key] = now + 5.0
 
                 except json.JSONDecodeError as e:
                     logger.warning(f"Invalid signal file {signal_file.name}: {e}")
@@ -714,6 +1226,79 @@ class DialogueWatcher:
         except Exception as e:
             logger.error(f"Error checking stop signals: {e}", exc_info=True)
 
+    async def _check_codex_notify_signals(self) -> None:
+        """Process Codex notify-hook fallback signals (rare path)."""
+        try:
+            from .codex_hooks import codex_notify_signal_dir
+
+            signal_dir = codex_notify_signal_dir()
+            if not signal_dir.exists():
+                return
+
+            now = time.time()
+            for signal_file in signal_dir.glob("*.signal"):
+                try:
+                    data = json.loads(signal_file.read_text(encoding="utf-8"))
+                except Exception:
+                    signal_file.unlink(missing_ok=True)
+                    continue
+
+                ts = float(data.get("timestamp") or 0.0)
+                if ts and now - ts < 0.2:
+                    continue
+
+                transcript_path = str(data.get("transcript_path") or "") or str(
+                    data.get("session_file_path") or ""
+                )
+                if not transcript_path:
+                    signal_file.unlink(missing_ok=True)
+                    continue
+
+                session_file = Path(transcript_path)
+                if not session_file.exists():
+                    signal_file.unlink(missing_ok=True)
+                    continue
+
+                session_id = str(data.get("session_id") or session_file.stem).strip()
+                project_dir = str(data.get("project_dir") or data.get("cwd") or "")
+                no_track = bool(data.get("no_track") or False)
+                agent_id = str(data.get("agent_id") or "").strip()
+                terminal_id = str(data.get("terminal_id") or "").strip()
+
+                from .db import get_database
+
+                db = get_database()
+                try:
+                    db.enqueue_session_process_job(  # type: ignore[attr-defined]
+                        session_file_path=session_file,
+                        session_id=session_id,
+                        workspace_path=(project_dir or None),
+                        session_type="codex",
+                        source_event="notify",
+                        no_track=no_track,
+                        agent_id=agent_id if agent_id else None,
+                        terminal_id=terminal_id if terminal_id else None,  # type: ignore[arg-type]
+                    )
+                except TypeError:
+                    try:
+                        db.enqueue_session_process_job(  # type: ignore[attr-defined]
+                            session_file_path=session_file,
+                            session_id=session_id,
+                            workspace_path=(project_dir or None),
+                            session_type="codex",
+                            source_event="notify",
+                            no_track=no_track,
+                            agent_id=agent_id if agent_id else None,
+                        )
+                    except Exception:
+                        pass
+                except Exception:
+                    pass
+
+                signal_file.unlink(missing_ok=True)
+        except Exception:
+            return
+
     async def _check_user_prompt_submit_signals(self):
         """Process UserPromptSubmit hook signals for temporary turn titles."""
         try:
@@ -818,7 +1403,7 @@ class DialogueWatcher:
 
         Note: for Claude Code, this only covers non-last turns, because
         ClaudeTrigger.count_complete_turns() intentionally excludes the last turn
-        to avoid false positives. The last turn is handled by Stop hook or idle fallback.
+        to avoid false positives. The last turn is handled by the Stop hook path.
         """
         session_path = str(session_file)
         session_type = self._detect_session_type(session_file)
@@ -1039,160 +1624,6 @@ class DialogueWatcher:
             logger.warning(f"Failed to compute hash for {session_file.name}: {e}")
             return None
 
-    async def _check_idle_sessions_for_final_commit(self, session_files: Optional[list[Path]] = None, current_mtimes: Optional[Dict[str, float]] = None):
-        """Check for idle sessions and trigger final commits if needed."""
-        try:
-            current_time = time.time()
-            if session_files is None:
-                session_files = self._get_cached_session_list()
-            if current_mtimes is None:
-                _, _, current_mtimes = self._get_cycle_session_stats()
-
-            for session_file in session_files:
-                session_path = str(session_file)
-                mtime = current_mtimes.get(session_path)
-                if mtime is None:
-                    continue
-
-                try:
-                    # Initialize tracking if first time seeing this session
-                    if session_path not in self.last_session_mtimes:
-                        self.last_session_mtimes[session_path] = mtime
-                        continue
-
-                    last_mtime = self.last_session_mtimes[session_path]
-
-                    # If file was modified, update mtime and skip
-                    if mtime > last_mtime:
-                        self.last_session_mtimes[session_path] = mtime
-                        # Reset final commit attempt time when file changes
-                        self.last_final_commit_times.pop(session_path, None)
-                        continue
-
-                    # Check if session has been idle long enough
-                    time_since_change = current_time - last_mtime
-                    if time_since_change >= self.final_commit_idle_timeout:
-                        # Check if we've already tried final commit recently
-                        last_attempt = self.last_final_commit_times.get(session_path, 0)
-                        if current_time - last_attempt < 60:  # Don't try more than once per minute
-                            continue
-
-                        from .db import get_database
-
-                        db = get_database()
-
-                        session_id = session_file.stem
-                        session_type = self._detect_session_type(session_file)
-                        # Use cached turn counts (Layer 3) — avoids re-parsing unchanged files
-                        file_size = self._last_cycle_sizes.get(session_path, 0)
-                        completed_count, total_turns = self._get_cached_turn_counts(
-                            session_file, mtime, file_size
-                        )
-                        last_count = self.last_stop_reason_counts.get(session_path, 0)
-
-                        # For Claude, also consider the last turn (not counted in completed_count).
-                        last_turn_to_enqueue: Optional[int] = None
-                        if session_type == "claude":
-                            if total_turns > completed_count:
-                                existing = db.get_turn_by_number(session_id, int(total_turns))
-                                if existing is None:
-                                    last_turn_to_enqueue = int(total_turns)
-                                else:
-                                    existing_status = getattr(existing, "turn_status", None)
-                                    if existing_status == "processing":
-                                        try:
-                                            age_seconds = max(
-                                                0.0,
-                                                (
-                                                    datetime.now()
-                                                    - getattr(
-                                                        existing, "created_at", datetime.now()
-                                                    )
-                                                ).total_seconds(),
-                                            )
-                                        except Exception:
-                                            age_seconds = 0.0
-                                        if age_seconds >= float(self.processing_turn_ttl_seconds):
-                                            last_turn_to_enqueue = int(total_turns)
-
-                        new_turns = []
-                        if completed_count > last_count:
-                            new_turns.extend(range(int(last_count) + 1, int(completed_count) + 1))
-                        if last_turn_to_enqueue and last_turn_to_enqueue > 0:
-                            new_turns.append(last_turn_to_enqueue)
-
-                        if not new_turns:
-                            logger.debug(
-                                f"No new turns in {session_file.name} (count: {completed_count}), skipping idle enqueue"
-                            )
-                            self.last_final_commit_times[session_path] = current_time
-                            continue
-
-                        logger.info(
-                            f"Session {session_file.name} idle for {time_since_change:.0f}s, enqueueing turns: {sorted(set(new_turns))}"
-                        )
-                        print(
-                            f"[Watcher] Session idle for {time_since_change:.0f}s - enqueueing final turns",
-                            file=sys.stderr,
-                        )
-
-                        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"
-                            )
-                            # Mark as attempted to avoid spamming logs
-                            self.last_final_commit_times[session_path] = current_time
-                            continue
-
-                        enqueued_any = False
-                        agent_id = None
-                        if session_type == "codex":
-                            agent_id = self._agent_info_id_for_codex_session(session_file, db=db)
-                            terminal_id = self._terminal_id_for_codex_session(session_file)
-                            if terminal_id:
-                                try:
-                                    db.insert_window_link(
-                                        terminal_id=terminal_id,
-                                        agent_id=agent_id,
-                                        session_id=session_id,
-                                        provider="codex",
-                                        source="codex:watcher",
-                                        ts=time.time(),
-                                    )
-                                except Exception:
-                                    pass
-                        for turn_number in sorted(set(new_turns)):
-                            try:
-                                db.enqueue_turn_summary_job(  # type: ignore[attr-defined]
-                                    session_file_path=session_file,
-                                    workspace_path=project_path,
-                                    turn_number=int(turn_number),
-                                    session_type=session_type,
-                                    agent_id=agent_id if agent_id else None,
-                                )
-                                enqueued_any = True
-                            except Exception as e:
-                                logger.warning(
-                                    f"Failed to enqueue final turn_summary for {session_file.name} #{turn_number}: {e}"
-                                )
-
-                        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_final_commit_times[session_path] = current_time
-
-                except Exception as e:
-                    logger.warning(f"Error checking idle status for {session_path}: {e}")
-                    continue
-
-        except Exception as e:
-            logger.error(f"Error in idle session check: {e}", exc_info=True)
-
     def _extract_project_path(self, session_file: Path) -> Optional[Path]:
         """
         Extract project path (cwd) from session file.
@@ -1297,7 +1728,11 @@ class DialogueWatcher:
             logger.error(f"Trigger error for {session_file.name}: {e}")
             return 0
 
-    async def check_for_changes(self, current_sizes: Optional[Dict[str, int]] = None, current_mtimes: Optional[Dict[str, float]] = None):
+    async def check_for_changes(
+        self,
+        current_sizes: Optional[Dict[str, int]] = None,
+        current_mtimes: Optional[Dict[str, float]] = None,
+    ):
         """Check if any session file has been modified."""
         try:
             if current_sizes is None or current_mtimes is None:
@@ -1321,8 +1756,6 @@ class DialogueWatcher:
                         self._maybe_link_codex_terminal(Path(path))
                     except Exception:
                         pass
-                    # Reset idle final-commit attempt tracking for new files
-                    self.last_final_commit_times.pop(path, None)
                     continue
 
                 if size != old_size or (mtime is not None and mtime != old_mtime):
@@ -1330,8 +1763,6 @@ class DialogueWatcher:
                     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)
 
             if changed_files:
                 # Accumulate changed files instead of cancelling pending task
@@ -1354,7 +1785,7 @@ class DialogueWatcher:
 
             # Update tracked sizes
             self.last_session_sizes = current_sizes
-            # Update tracked mtimes for change + idle detection
+            # Update tracked mtimes for change detection
             self.last_session_mtimes = current_mtimes
 
         except Exception as e:
@@ -1362,7 +1793,7 @@ class DialogueWatcher:
             print(f"[Watcher] Error checking for changes: {e}", file=sys.stderr)
 
     async def _debounced_commit_accumulated(self):
-        """Wait for debounce period, then enqueue jobs for accumulated changed files."""
+        """Wait for debounce period, then enqueue per-session processing jobs."""
         try:
             # Wait for debounce period
             await asyncio.sleep(self.debounce_delay)
@@ -1374,29 +1805,12 @@ class DialogueWatcher:
             if not changed_files:
                 return
 
-            logger.info(f"Processing {len(changed_files)} accumulated session file(s)")
-
-            # Check all changed files for new completed turns
-            sessions_to_enqueue: list[tuple[Path, list[int]]] = []
-            for session_file in changed_files:
-                if not session_file.exists():
-                    continue
-                # Best-effort: keep terminal bindings fresh (especially after watcher restarts).
-                try:
-                    self._maybe_link_codex_terminal(session_file)
-                except Exception:
-                    pass
-                new_turns = self._get_new_completed_turn_numbers(session_file)
-                if new_turns:
-                    sessions_to_enqueue.append((session_file, new_turns))
-
-            if not sessions_to_enqueue:
-                return
+            logger.info(f"Enqueueing session_process for {len(changed_files)} session(s)")
 
             # Prefer processing the most recently modified sessions first
             try:
-                sessions_to_enqueue.sort(
-                    key=lambda it: it[0].stat().st_mtime if it[0].exists() else 0,
+                changed_files.sort(
+                    key=lambda it: it.stat().st_mtime if it.exists() else 0,
                     reverse=True,
                 )
             except Exception:
@@ -1406,58 +1820,24 @@ class DialogueWatcher:
 
             db = get_database()
 
-            for session_file, new_turns in sessions_to_enqueue:
-                logger.info(f"New completed turns detected in {session_file.name}: {new_turns}")
-                print(
-                    f"[Watcher] New completed turns detected in {session_file.name}: {new_turns}",
-                    file=sys.stderr,
-                )
-
-                project_path = self._extract_project_path(session_file)
-                if not project_path:
-                    logger.debug(
-                        f"Could not determine project path for {session_file.name}, skipping enqueue"
-                    )
+            yield_often = len(changed_files) > 1
+            for idx, session_file in enumerate(changed_files, start=1):
+                if not session_file.exists():
                     continue
-
-                enqueued_any = False
-                session_type = self._detect_session_type(session_file)
-                agent_id = None
-                if session_type == "codex":
-                    agent_id = self._agent_info_id_for_codex_session(session_file, db=db)
-                    terminal_id = self._terminal_id_for_codex_session(session_file)
-                    if terminal_id:
-                        try:
-                            db.insert_window_link(
-                                terminal_id=terminal_id,
-                                agent_id=agent_id,
-                                session_id=session_file.stem,
-                                provider="codex",
-                                source="codex:watcher",
-                                ts=time.time(),
-                            )
-                        except Exception:
-                            pass
-                for turn_number in new_turns:
-                    try:
-                        db.enqueue_turn_summary_job(  # type: ignore[attr-defined]
-                            session_file_path=session_file,
-                            workspace_path=project_path,
-                            turn_number=turn_number,
-                            session_type=session_type,
-                            agent_id=agent_id if agent_id else None,
-                        )
-                        enqueued_any = True
-                    except Exception as e:
-                        logger.warning(
-                            f"Failed to enqueue turn_summary for {session_file.name} #{turn_number}: {e}"
-                        )
-
-                if enqueued_any:
-                    session_path = str(session_file)
-                    self.last_stop_reason_counts[session_path] = max(
-                        self.last_stop_reason_counts.get(session_path, 0), max(new_turns)
+                try:
+                    db.enqueue_session_process_job(  # type: ignore[attr-defined]
+                        session_file_path=session_file,
+                        session_id=session_file.stem,
+                        workspace_path=None,
+                        session_type=self._detect_session_type(session_file),
+                        source_event="poll",
                     )
+                except Exception as e:
+                    logger.warning(
+                        f"Failed to enqueue session_process for {session_file.name}: {e}"
+                    )
+                if yield_often:
+                    await asyncio.sleep(0)
 
         except asyncio.CancelledError:
             pass
@@ -1466,7 +1846,7 @@ class DialogueWatcher:
             print(f"[Watcher] Error in debounced enqueue: {e}", file=sys.stderr)
 
     async def _debounced_commit(self, changed_files: list):
-        """Wait for debounce period, then enqueue jobs for changed files.
+        """Wait for debounce period, then enqueue per-session processing jobs.
 
         DEPRECATED: Use _debounced_commit_accumulated instead.
         Kept for backwards compatibility.
@@ -1485,48 +1865,17 @@ class DialogueWatcher:
                 if not session_file.exists():
                     continue
 
-                new_turns = self._get_new_completed_turn_numbers(session_file)
-                if not new_turns:
-                    continue
-
-                project_path = self._extract_project_path(session_file)
-                if not project_path:
+                try:
+                    db.enqueue_session_process_job(  # type: ignore[attr-defined]
+                        session_file_path=session_file,
+                        session_id=session_file.stem,
+                        workspace_path=None,
+                        session_type=self._detect_session_type(session_file),
+                        source_event="poll",
+                    )
+                except Exception:
                     continue
 
-                for turn_number in new_turns:
-                    try:
-                        session_type = self._detect_session_type(session_file)
-                        agent_id = None
-                        if session_type == "codex":
-                            agent_id = self._agent_info_id_for_codex_session(session_file, db=db)
-                            terminal_id = self._terminal_id_for_codex_session(session_file)
-                            if terminal_id:
-                                try:
-                                    db.insert_window_link(
-                                        terminal_id=terminal_id,
-                                        agent_id=agent_id,
-                                        session_id=session_file.stem,
-                                        provider="codex",
-                                        source="codex:watcher",
-                                        ts=time.time(),
-                                    )
-                                except Exception:
-                                    pass
-                        db.enqueue_turn_summary_job(  # type: ignore[attr-defined]
-                            session_file_path=session_file,
-                            workspace_path=project_path,
-                            turn_number=turn_number,
-                            session_type=session_type,
-                            agent_id=agent_id if agent_id else None,
-                        )
-                    except Exception:
-                        continue
-
-                session_path = str(session_file)
-                self.last_stop_reason_counts[session_path] = max(
-                    self.last_stop_reason_counts.get(session_path, 0), max(new_turns)
-                )
-
         except asyncio.CancelledError:
             # Task was cancelled because a newer change was detected
             pass