aline-ai 0.6.5__py3-none-any.whl → 0.6.7__py3-none-any.whl

realign/watcher_core.py

@@ -259,8 +259,56 @@ 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 terminal_id_from_codex_session_file
+            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
+
+        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 .db import get_database
 
@@ -271,13 +319,50 @@ class DialogueWatcher:
             db = get_database(read_only=False)
             agents = db.list_agents(status="active", limit=1000)
             # Deterministic mapping: session file stored under ~/.aline/codex_homes/<terminal_id>/...
-            agent_id = terminal_id_from_codex_session_file(session_file)
+            owner = codex_home_owner_from_session_file(session_file)
+            agent_id = None
+            agent_info_id = None
+            if owner:
+                if owner[0] == "terminal":
+                    agent_id = owner[1]
+                elif owner[0] == "agent":
+                    agent_info_id = owner[1]
+                    scoped_agents = [
+                        a
+                        for a in agents
+                        if getattr(a, "provider", "") == "codex"
+                        and getattr(a, "status", "") == "active"
+                        and (getattr(a, "source", "") or "") == f"agent:{agent_info_id}"
+                    ]
+                    agent_id = select_agent_for_codex_session(
+                        scoped_agents, session=meta, max_time_delta_seconds=None
+                    )
             if not agent_id:
                 # Fallback heuristic mapping (legacy default ~/.codex/sessions).
                 agent_id = select_agent_for_codex_session(agents, session=meta)
             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
+            existing_source = None
+            if existing_agent:
+                existing_source = existing_agent.source or ""
+                if existing_source.startswith("agent:"):
+                    agent_info_id = existing_source[6:]
+
+            if not agent_info_id and owner_agent_info_id:
+                agent_info_id = owner_agent_info_id
+
+            if existing_source:
+                source = existing_source
+            elif agent_info_id:
+                source = f"agent:{agent_info_id}"
+            else:
+                source = "codex:auto-link"
+
             db.update_agent(
                 agent_id,
                 provider="codex",
@@ -286,8 +371,27 @@ class DialogueWatcher:
                 transcript_path=str(session_file),
                 cwd=meta.cwd,
                 project_dir=meta.cwd,
-                source="codex:auto-link",
+                source=source,
             )
+
+            try:
+                db.insert_window_link(
+                    terminal_id=agent_id,
+                    agent_id=agent_info_id,
+                    session_id=session_file.stem,
+                    provider="codex",
+                    source="codex:watcher",
+                    ts=time.time(),
+                )
+            except Exception:
+                pass
+
+            # Link session to agent_info if available (bidirectional linking)
+            if agent_info_id:
+                try:
+                    db.update_session_agent_id(session_file.stem, agent_info_id)
+                except Exception:
+                    pass
         except Exception:
             return
 
@@ -409,6 +513,7 @@ class DialogueWatcher:
                     project_dir = signal_data.get("project_dir", "")
                     transcript_path = signal_data.get("transcript_path", "")
                     no_track = bool(signal_data.get("no_track", False))
+                    agent_id = signal_data.get("agent_id", "")
 
                     logger.info(f"Stop signal received for session {session_id}")
                     print(f"[Watcher] Stop signal received for {session_id}", file=sys.stderr)
@@ -444,6 +549,7 @@ class DialogueWatcher:
                                     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(
@@ -505,6 +611,7 @@ class DialogueWatcher:
                 transcript_path = str(signal_data.get("transcript_path") or "")
                 project_dir = str(signal_data.get("project_dir") or "")
                 no_track = bool(signal_data.get("no_track", False))
+                agent_id = str(signal_data.get("agent_id") or "")
 
                 session_file = None
                 if transcript_path and Path(transcript_path).exists():
@@ -534,6 +641,16 @@ class DialogueWatcher:
                     no_track,
                 )
 
+                # Link session to agent if agent_id is provided
+                if agent_id and session_id:
+                    try:
+                        from .db import get_database
+
+                        db = get_database()
+                        db.update_session_agent_id(session_id, agent_id)
+                    except Exception:
+                        pass
+
                 signal_file.unlink(missing_ok=True)
         except Exception as e:
             logger.error(f"Error checking user prompt signals: {e}", exc_info=True)
@@ -794,6 +911,23 @@ class DialogueWatcher:
                     file=sys.stderr,
                 )
 
+                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
+
                 enqueued = 0
                 for turn in missing_turns:
                     try:
@@ -802,6 +936,7 @@ class DialogueWatcher:
                             workspace_path=project_path,
                             turn_number=turn,
                             session_type=session_type,
+                            agent_id=agent_id if agent_id else None,
                         )
                         enqueued += 1
                     except Exception as e:
@@ -935,6 +1070,22 @@ class DialogueWatcher:
                             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]
@@ -942,6 +1093,7 @@ class DialogueWatcher:
                                     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:
@@ -1192,13 +1344,31 @@ class DialogueWatcher:
                     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=self._detect_session_type(session_file),
+                            session_type=session_type,
+                            agent_id=agent_id if agent_id else None,
                         )
                         enqueued_any = True
                     except Exception as e:
@@ -1248,11 +1418,29 @@ class DialogueWatcher:
 
                 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=self._detect_session_type(session_file),
+                            session_type=session_type,
+                            agent_id=agent_id if agent_id else None,
                         )
                     except Exception:
                         continue

realign/worker_core.py

@@ -4,6 +4,7 @@ Background worker for durable jobs queue.
 This process consumes jobs from the SQLite `jobs` table:
 - turn_summary: generate/store a turn (LLM + content snapshot)
 - session_summary: aggregate session title/summary from turns
+- agent_description: regenerate agent description from session summaries
 """
 
 from __future__ import annotations
@@ -66,7 +67,7 @@ class AlineWorker:
             try:
                 job = self.db.claim_next_job(
                     worker_id=self.worker_id,
-                    kinds=["turn_summary", "session_summary"],
+                    kinds=["turn_summary", "session_summary", "agent_description"],
                 )
                 if not job:
                     await asyncio.sleep(self.poll_interval_seconds)
@@ -134,6 +135,11 @@ class AlineWorker:
                         )
                 return
 
+            if kind == "agent_description":
+                await self._process_agent_description_job(payload)
+                self.db.finish_job(job_id=job_id, worker_id=self.worker_id, success=True)
+                return
+
             # Unknown job kind: mark as permanently failed to avoid infinite loops.
             self.db.finish_job(
                 job_id=job_id,
@@ -187,6 +193,7 @@ class AlineWorker:
         expected_turns = int(expected_turns_raw) if expected_turns_raw is not None else None
         skip_dedup = bool(payload.get("skip_dedup") or False)
         no_track = bool(payload.get("no_track") or False)
+        agent_id = str(payload.get("agent_id") or "")
 
         if not session_id or turn_number <= 0 or not session_file_path:
             raise ValueError(f"Invalid turn_summary payload: {payload}")
@@ -216,6 +223,16 @@ class AlineWorker:
             no_track=no_track,
         )
 
+        # Link session to agent after commit ensures session exists in DB
+        if session_id:
+            try:
+                if agent_id:
+                    self.db.update_session_agent_id(session_id, agent_id)
+                else:
+                    self._maybe_link_session_from_terminal(session_id)
+            except Exception:
+                pass
+
         if created:
             if expected_turns:
                 self._enqueue_session_summary_if_complete(session_id, expected_turns)
@@ -247,6 +264,38 @@ class AlineWorker:
         except Exception as e:
             logger.warning(f"Failed to enqueue session summary after import for {session_id}: {e}")
 
+    def _maybe_link_session_from_terminal(self, session_id: str) -> None:
+        """Best-effort: backfill sessions.agent_id using terminal mapping."""
+        try:
+            session = self.db.get_session_by_id(session_id)
+            if session and getattr(session, "agent_id", None):
+                return
+        except Exception:
+            return
+
+        try:
+            agents = self.db.list_agents(status=None, limit=1000)
+        except Exception:
+            return
+
+        agent_info_id = None
+        for agent in agents:
+            try:
+                if (agent.session_id or "").strip() != session_id:
+                    continue
+                source = (agent.source or "").strip()
+                if source.startswith("agent:"):
+                    agent_info_id = source[6:]
+                    break
+            except Exception:
+                continue
+
+        if agent_info_id:
+            try:
+                self.db.update_session_agent_id(session_id, agent_info_id)
+            except Exception:
+                pass
+
     async def _process_session_summary_job(self, payload: Dict[str, Any]) -> bool:
         session_id = str(payload.get("session_id") or "")
         if not session_id:
@@ -255,3 +304,12 @@ class AlineWorker:
         from .events.session_summarizer import update_session_summary_now
 
         return bool(update_session_summary_now(self.db, session_id))
+
+    async def _process_agent_description_job(self, payload: Dict[str, Any]) -> None:
+        agent_id = str(payload.get("agent_id") or "")
+        if not agent_id:
+            raise ValueError(f"Invalid agent_description payload: {payload}")
+
+        from .events.agent_summarizer import force_update_agent_description
+
+        force_update_agent_description(self.db, agent_id)