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

realign/worker_core.py

@@ -14,13 +14,16 @@ import logging
 import math
 import os
 import sys
+import time
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, Optional
 
 from .db.sqlite_db import SQLiteDatabase
 from .db.locks import make_lock_owner
+from .logging_config import setup_logger
 
-logger = logging.getLogger(__name__)
+logger = setup_logger("realign.worker_core", "worker_core.log")
 
 
 class PermanentJobError(RuntimeError):
@@ -53,11 +56,10 @@ class AlineWorker:
         self.worker_id = make_lock_owner("worker")
         self.running = False
 
-        # Reuse the existing commit pipeline (LLM turn creation) implemented on DialogueWatcher.
-        # We instantiate it without starting its polling loop.
-        from .watcher_core import DialogueWatcher
+        # Commit/turn processing pipeline (no watcher loop / polling).
+        from .commit_pipeline import CommitPipeline
 
-        self._watcher = DialogueWatcher()
+        self._pipeline = CommitPipeline(lock_owner_prefix="worker")
 
     async def start(self) -> None:
         self.running = True
@@ -67,7 +69,7 @@ class AlineWorker:
             try:
                 job = self.db.claim_next_job(
                     worker_id=self.worker_id,
-                    kinds=["turn_summary", "session_summary", "agent_description"],
+                    kinds=["session_process", "turn_summary", "session_summary", "agent_description"],
                 )
                 if not job:
                     await asyncio.sleep(self.poll_interval_seconds)
@@ -91,6 +93,17 @@ class AlineWorker:
         payload = job.get("payload") or {}
 
         try:
+            if kind == "session_process":
+                await self._process_session_process_job(payload)
+                try:
+                    session_id = str(payload.get("session_id") or "")
+                    if session_id:
+                        self.db.enqueue_session_summary_job(session_id=session_id)
+                except Exception as e:
+                    logger.warning(f"Failed to enqueue session summary after session_process: {e}")
+                self.db.finish_job(job_id=job_id, worker_id=self.worker_id, success=True)
+                return
+
             if kind == "turn_summary":
                 await self._process_turn_summary_job(payload)
                 # Always enqueue a session_summary job after a successful turn job.
@@ -183,6 +196,188 @@ class AlineWorker:
                 retry_after_seconds=delay,
             )
 
+    async def _process_session_process_job(self, payload: Dict[str, Any]) -> None:
+        t0 = time.monotonic()
+        session_id = str(payload.get("session_id") or "").strip()
+        session_file_path = Path(str(payload.get("session_file_path") or ""))
+        session_type_raw = str(payload.get("session_type") or "").strip().lower()
+        source_event = str(payload.get("source_event") or "").strip().lower()
+        workspace_path_raw = payload.get("workspace_path")
+        no_track = bool(payload.get("no_track") or False)
+        agent_id = str(payload.get("agent_id") or "").strip()
+        terminal_id = str(payload.get("terminal_id") or "").strip()
+
+        if not session_file_path:
+            raise ValueError(f"Invalid session_process payload: {payload}")
+        if not session_file_path.exists():
+            raise FileNotFoundError(f"Session file not found: {session_file_path}")
+        if not session_id:
+            session_id = session_file_path.stem
+
+        logger.info(
+            "session_process start: session_id=%s source_event=%s session_type=%s file=%s",
+            session_id,
+            source_event or "",
+            session_type_raw or "",
+            str(session_file_path),
+        )
+
+        session_type = session_type_raw or str(self._pipeline._detect_session_type(session_file_path))
+
+        if session_type == "codex" and (not agent_id or not terminal_id):
+            # Best-effort: infer linkage from Aline-managed CODEX_HOME layouts even if the notify
+            # runner didn't propagate env vars into the job payload.
+            try:
+                from .codex_home import agent_id_from_codex_session_file, terminal_id_from_codex_session_file
+
+                if not agent_id:
+                    agent_id = str(agent_id_from_codex_session_file(session_file_path) or "").strip()
+                if not terminal_id:
+                    terminal_id = str(terminal_id_from_codex_session_file(session_file_path) or "").strip()
+            except Exception:
+                pass
+
+        # We intentionally do NOT validate that workspace_path exists; it is used mostly
+        # for stable grouping/metadata, and the commit pipeline can operate without a real repo.
+        project_path: Path
+        if isinstance(workspace_path_raw, str) and workspace_path_raw.strip():
+            project_path = Path(workspace_path_raw.strip())
+        else:
+            # Best-effort: use session metadata for Codex; otherwise fall back to existing path.
+            project_path = session_file_path.parent
+            if session_type == "codex":
+                try:
+                    from .codex_terminal_linker import read_codex_session_meta
+
+                    meta = read_codex_session_meta(session_file_path)
+                    if meta and (meta.cwd or "").strip():
+                        project_path = Path(str(meta.cwd).strip())
+                except Exception:
+                    pass
+
+        # Ensure the session record exists so agent associations are not lost on "no-op" jobs
+        # (e.g. when all turns are already committed and session_process returns early).
+        try:
+            started_at = datetime.fromtimestamp(session_file_path.stat().st_mtime)
+            if session_type == "codex":
+                try:
+                    from .codex_terminal_linker import read_codex_session_meta
+
+                    meta = read_codex_session_meta(session_file_path)
+                    if meta and meta.started_at is not None:
+                        dt = meta.started_at
+                        if dt.tzinfo is not None:
+                            dt = dt.astimezone(timezone.utc).replace(tzinfo=None)
+                        started_at = dt
+                except Exception:
+                    pass
+
+            self.db.get_or_create_session(
+                session_id=session_id,
+                session_file_path=session_file_path,
+                session_type=session_type,
+                started_at=started_at,
+                workspace_path=str(project_path) if str(project_path).strip() else None,
+                metadata={"source_event": source_event or "", "source": "worker"},
+                agent_id=agent_id or None,
+            )
+        except Exception:
+            pass
+
+        # Best-effort: link session to agent/terminal metadata even when no turns need processing.
+        if agent_id and session_id:
+            try:
+                self.db.update_session_agent_id(session_id, agent_id)
+            except Exception:
+                pass
+        if terminal_id and session_id:
+            try:
+                self.db.insert_window_link(
+                    terminal_id=terminal_id,
+                    agent_id=agent_id or None,
+                    session_id=session_id,
+                    provider=session_type or session_type_raw or "",
+                    source=f"{session_type or session_type_raw or 'unknown'}:worker",
+                    ts=time.time(),
+                )
+            except Exception:
+                pass
+
+        # Determine the safe "max turn" boundary.
+        if source_event == "stop":
+            max_turn = int(self._pipeline._get_total_turn_count(session_file_path))
+        else:
+            # Polling/idle paths: respect trigger semantics (Claude excludes last turn).
+            max_turn = int(self._pipeline._count_complete_turns(session_file_path))
+
+        if max_turn <= 0:
+            logger.info(
+                "session_process noop: session_id=%s max_turn=%s duration_s=%.3f",
+                session_id,
+                max_turn,
+                time.monotonic() - t0,
+            )
+            return
+
+        committed = set()
+        try:
+            committed = self.db.get_committed_turn_numbers(session_id)
+        except Exception:
+            committed = set()
+
+        processed = 0
+        skipped = 0
+
+        missing_turns = [t for t in range(1, max_turn + 1) if t not in committed]
+        if not missing_turns:
+            logger.info(
+                "session_process noop: session_id=%s max_turn=%s duration_s=%.3f",
+                session_id,
+                max_turn,
+                time.monotonic() - t0,
+            )
+            return
+
+        # Batch turns under one project lease lock to reduce overhead.
+        if len(missing_turns) > 1 and hasattr(self._pipeline, "_run_realign_commit_batch"):
+            results = self._pipeline._run_realign_commit_batch(
+                project_path,
+                session_file=session_file_path,
+                target_turns=missing_turns,
+                quiet=True,
+                skip_session_summary=True,
+                no_track=no_track,
+            )
+            for t in missing_turns:
+                if results.get(int(t)):
+                    committed.add(int(t))
+                processed += 1
+                await asyncio.sleep(0)
+        else:
+            # Fallback: per-turn commit (single missing turn or old pipeline).
+            for turn_number in missing_turns:
+                created = self._pipeline._run_realign_commit(
+                    project_path,
+                    session_file=session_file_path,
+                    target_turn=int(turn_number),
+                    quiet=True,
+                    skip_session_summary=True,
+                    no_track=no_track,
+                )
+                if created:
+                    committed.add(int(turn_number))
+                processed += 1
+                await asyncio.sleep(0)
+
+        logger.info(
+            "session_process done: session_id=%s max_turn=%s processed=%s skipped=%s duration_s=%.3f",
+            session_id,
+            max_turn,
+            processed,
+            skipped,
+            time.monotonic() - t0,
+        )
+
     async def _process_turn_summary_job(self, payload: Dict[str, Any]) -> None:
         session_id = str(payload.get("session_id") or "")
         turn_number = int(payload.get("turn_number") or 0)
@@ -201,19 +396,15 @@ class AlineWorker:
         if not session_file_path.exists():
             raise FileNotFoundError(f"Session file not found: {session_file_path}")
 
-        project_path: Optional[Path] = None
+        # Intentionally avoid expensive/fragile project path extraction. If no explicit path is
+        # provided, fall back to the session file's parent directory.
         if isinstance(workspace_path_raw, str) and workspace_path_raw.strip():
             project_path = Path(workspace_path_raw.strip())
-            if not project_path.exists():
-                project_path = None
-        if project_path is None:
-            project_path = self._watcher._extract_project_path(session_file_path)
-
-        if not project_path:
-            raise RuntimeError(f"Could not determine project path for session {session_id}")
+        else:
+            project_path = session_file_path.parent
 
         # Run the existing commit pipeline (writes turn record + content).
-        created = self._watcher._run_realign_commit(
+        created = self._pipeline._run_realign_commit(
             project_path,
             session_file=session_file_path,
             target_turn=turn_number,