aline-ai 0.6.4__py3-none-any.whl → 0.6.6__py3-none-any.whl

realign/db/sqlite_db.py

@@ -21,6 +21,7 @@ from .base import (
     EventRecord,
     LockRecord,
     AgentRecord,
+    AgentInfoRecord,
     AgentContextRecord,
     UserRecord,
 )
@@ -293,6 +294,7 @@ class SQLiteDatabase(DatabaseInterface):
         started_at: datetime,
         workspace_path: Optional[str] = None,
         metadata: Optional[Dict[str, Any]] = None,
+        agent_id: Optional[str] = None,
     ) -> SessionRecord:
         """Get existing session or create new one."""
         conn = self._get_connection()
@@ -317,8 +319,8 @@ class SQLiteDatabase(DatabaseInterface):
             INSERT INTO sessions (
                 id, session_file_path, session_type, workspace_path,
                 started_at, last_activity_at, created_at, updated_at, metadata,
-                created_by
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                created_by, agent_id
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
             """,
             (
                 session_id,
@@ -331,6 +333,7 @@ class SQLiteDatabase(DatabaseInterface):
                 now,
                 metadata_json,
                 config.uid,
+                agent_id,
             ),
         )
         conn.commit()
@@ -353,8 +356,18 @@ class SQLiteDatabase(DatabaseInterface):
             metadata=metadata or {},
             workspace_path=workspace_path,
             created_by=config.uid,
+            agent_id=agent_id,
         )
 
+    def update_session_agent_id(self, session_id: str, agent_id: Optional[str]) -> None:
+        """Set or update the agent_id on an existing session (V19)."""
+        conn = self._get_connection()
+        conn.execute(
+            "UPDATE sessions SET agent_id = ?, updated_at = ? WHERE id = ?",
+            (agent_id, datetime.now(), session_id),
+        )
+        conn.commit()
+
     def update_session_activity(self, session_id: str, last_activity_at: datetime) -> None:
         """Update last activity timestamp."""
         conn = self._get_connection()
@@ -557,6 +570,30 @@ class SQLiteDatabase(DatabaseInterface):
         )
         return [self._row_to_session(row) for row in cursor.fetchall()]
 
+    def get_sessions_by_agent_id(self, agent_id: str, limit: int = 1000) -> List[SessionRecord]:
+        """Get all sessions linked to an agent.
+
+        Args:
+            agent_id: The agent_info ID
+            limit: Maximum number of sessions to return
+
+        Returns:
+            List of SessionRecord objects for this agent
+        """
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        try:
+            cursor.execute(
+                """SELECT * FROM sessions
+                   WHERE agent_id = ?
+                   ORDER BY last_activity_at DESC
+                   LIMIT ?""",
+                (agent_id, limit),
+            )
+            return [self._row_to_session(row) for row in cursor.fetchall()]
+        except sqlite3.OperationalError:
+            return []
+
     def get_turn_content(self, turn_id: str) -> Optional[str]:
         """Get the JSONL content for a turn."""
         conn = self._get_connection()
@@ -973,6 +1010,7 @@ class SQLiteDatabase(DatabaseInterface):
         expected_turns: Optional[int] = None,
         skip_dedup: bool = False,
         no_track: bool = False,
+        agent_id: Optional[str] = None,
     ) -> str:
         session_id = session_file_path.stem
         dedupe_key = f"turn:{session_id}:{int(turn_number)}"
@@ -991,6 +1029,8 @@ class SQLiteDatabase(DatabaseInterface):
             payload["skip_dedup"] = True
         if no_track:
             payload["no_track"] = True
+        if agent_id:
+            payload["agent_id"] = agent_id
 
         # For append-only session formats (Claude/Codex/Gemini), a turn is immutable once completed.
         # Avoid re-running already-done turn jobs on repeated enqueue attempts.
@@ -1033,6 +1073,17 @@ class SQLiteDatabase(DatabaseInterface):
             requeue_done=True,
         )
 
+    def enqueue_agent_description_job(self, *, agent_id: str) -> str:
+        dedupe_key = f"agent_desc:{agent_id}"
+        payload: Dict[str, Any] = {"agent_id": agent_id}
+        return self.enqueue_job(
+            kind="agent_description",
+            dedupe_key=dedupe_key,
+            payload=payload,
+            priority=12,
+            requeue_done=True,
+        )
+
     def claim_next_job(
         self,
         *,
@@ -2770,6 +2821,13 @@ class SQLiteDatabase(DatabaseInterface):
         except (IndexError, KeyError):
             pass
 
+        # V19: agent association
+        agent_id = None
+        try:
+            agent_id = row["agent_id"]
+        except (IndexError, KeyError):
+            pass
+
         return SessionRecord(
             id=row["id"],
             session_file_path=Path(row["session_file_path"]),
@@ -2790,6 +2848,7 @@ class SQLiteDatabase(DatabaseInterface):
             shared_by=shared_by,
             total_turns=total_turns,
             total_turns_mtime=total_turns_mtime,
+            agent_id=agent_id,
         )
 
     def _row_to_turn(self, row: sqlite3.Row) -> TurnRecord:
@@ -3015,3 +3074,127 @@ class SQLiteDatabase(DatabaseInterface):
         except sqlite3.OperationalError:
             pass
         return None
+
+    # -------------------------------------------------------------------------
+    # Agent info table methods (Schema V20)
+    # -------------------------------------------------------------------------
+
+    def _row_to_agent_info(self, row: sqlite3.Row) -> AgentInfoRecord:
+        """Convert a database row to an AgentInfoRecord."""
+        visibility = "visible"
+        try:
+            if "visibility" in row.keys():
+                visibility = row["visibility"] or "visible"
+        except Exception:
+            visibility = "visible"
+        return AgentInfoRecord(
+            id=row["id"],
+            name=row["name"],
+            description=row["description"] or "",
+            created_at=self._parse_datetime(row["created_at"]),
+            updated_at=self._parse_datetime(row["updated_at"]),
+            visibility=visibility,
+        )
+
+    def get_or_create_agent_info(
+        self, agent_id: str, name: Optional[str] = None
+    ) -> AgentInfoRecord:
+        """Get existing agent info or create a new one.
+
+        Args:
+            agent_id: UUID for the agent.
+            name: Display name (if None, caller should provide a generated name).
+        """
+        conn = self._get_connection()
+        cursor = conn.cursor()
+
+        try:
+            cursor.execute("SELECT * FROM agent_info WHERE id = ?", (agent_id,))
+            row = cursor.fetchone()
+            if row:
+                return self._row_to_agent_info(row)
+        except sqlite3.OperationalError:
+            pass
+
+        display_name = name or agent_id[:8]
+        cursor.execute(
+            """
+            INSERT INTO agent_info (id, name, description, visibility, created_at, updated_at)
+            VALUES (?, ?, '', 'visible', datetime('now'), datetime('now'))
+            """,
+            (agent_id, display_name),
+        )
+        conn.commit()
+
+        cursor.execute("SELECT * FROM agent_info WHERE id = ?", (agent_id,))
+        row = cursor.fetchone()
+        return self._row_to_agent_info(row)
+
+    def get_agent_info(self, agent_id: str) -> Optional[AgentInfoRecord]:
+        """Get agent info by ID, or None if not found."""
+        conn = self._get_connection()
+        try:
+            cursor = conn.execute("SELECT * FROM agent_info WHERE id = ?", (agent_id,))
+            row = cursor.fetchone()
+            if row:
+                return self._row_to_agent_info(row)
+        except sqlite3.OperationalError:
+            pass
+        return None
+
+    def update_agent_info(
+        self,
+        agent_id: str,
+        *,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        visibility: Optional[str] = None,
+    ) -> Optional[AgentInfoRecord]:
+        """Update agent info fields. Returns updated record or None if not found."""
+        conn = self._get_connection()
+        sets: list[str] = []
+        params: list[Any] = []
+
+        if name is not None:
+            sets.append("name = ?")
+            params.append(name)
+        if description is not None:
+            sets.append("description = ?")
+            params.append(description)
+        if visibility is not None:
+            sets.append("visibility = ?")
+            params.append(visibility)
+
+        if not sets:
+            return self.get_agent_info(agent_id)
+
+        sets.append("updated_at = datetime('now')")
+        params.append(agent_id)
+
+        try:
+            conn.execute(
+                f"UPDATE agent_info SET {', '.join(sets)} WHERE id = ?",
+                params,
+            )
+            conn.commit()
+        except sqlite3.OperationalError:
+            return None
+
+        return self.get_agent_info(agent_id)
+
+    def list_agent_info(self, *, include_invisible: bool = False) -> list[AgentInfoRecord]:
+        """List agent info records, ordered by created_at descending."""
+        conn = self._get_connection()
+        try:
+            if include_invisible:
+                cursor = conn.execute("SELECT * FROM agent_info ORDER BY created_at DESC")
+            else:
+                try:
+                    cursor = conn.execute(
+                        "SELECT * FROM agent_info WHERE visibility = 'visible' ORDER BY created_at DESC"
+                    )
+                except sqlite3.OperationalError:
+                    cursor = conn.execute("SELECT * FROM agent_info ORDER BY created_at DESC")
+            return [self._row_to_agent_info(row) for row in cursor.fetchall()]
+        except sqlite3.OperationalError:
+            return []

realign/events/agent_summarizer.py

@@ -0,0 +1,157 @@
+"""Agent description generation from session summaries using LLM."""
+
+import logging
+from pathlib import Path
+from typing import List, Optional
+
+from ..db.sqlite_db import SQLiteDatabase
+from ..db.base import SessionRecord
+from ..db.locks import lease_lock, lock_key_for_agent_description, make_lock_owner
+from ..llm_client import call_llm_cloud
+
+logger = logging.getLogger(__name__)
+
+
+def schedule_agent_description_update(db: SQLiteDatabase, agent_id: str) -> None:
+    """
+    Enqueue an agent description update job (durable).
+
+    Call this after a session summary is updated for an agent-linked session.
+
+    Args:
+        db: Database instance
+        agent_id: ID of the agent to update
+    """
+    try:
+        db.enqueue_agent_description_job(agent_id=agent_id)
+        logger.debug(f"Enqueued agent description job for agent_id={agent_id}")
+    except Exception as e:
+        logger.debug(f"Failed to enqueue agent description job, falling back: {e}")
+        force_update_agent_description(db, agent_id)
+
+
+def force_update_agent_description(db: SQLiteDatabase, agent_id: str) -> None:
+    """
+    Immediately update agent description, bypassing the job queue.
+
+    Args:
+        db: Database instance
+        agent_id: ID of the agent to update
+    """
+    _update_agent_description(db, agent_id)
+
+
+def _update_agent_description(db: SQLiteDatabase, agent_id: str) -> None:
+    """
+    Actually perform the agent description update.
+
+    Args:
+        db: Database instance
+        agent_id: ID of the agent to update
+    """
+    logger.info(f"Updating agent description for agent_id={agent_id}")
+
+    owner = make_lock_owner("agent_description")
+    lock_key = lock_key_for_agent_description(agent_id)
+
+    with lease_lock(
+        db,
+        lock_key,
+        owner=owner,
+        ttl_seconds=10 * 60,  # 10 minutes
+        wait_timeout_seconds=0.0,
+    ) as acquired:
+        if not acquired:
+            logger.debug(f"Agent description lock held by another process: agent_id={agent_id}")
+            return
+
+        sessions = db.get_sessions_by_agent_id(agent_id)
+        if not sessions:
+            logger.warning(f"No sessions found for agent_id={agent_id}")
+            return
+
+        # Filter to sessions with non-empty title or summary
+        sessions_with_content = [
+            s for s in sessions if s.session_title or s.session_summary
+        ]
+        if not sessions_with_content:
+            logger.warning(f"No sessions with summaries for agent_id={agent_id}")
+            return
+
+        description = _generate_agent_description_llm(sessions_with_content)
+        db.update_agent_info(agent_id, description=description)
+        logger.info(
+            f"Agent description updated: '{description[:60]}...' for agent_id={agent_id}"
+        )
+
+
+def _generate_agent_description_llm(sessions: List[SessionRecord]) -> str:
+    """
+    Use LLM to generate an agent description from all its sessions.
+
+    Args:
+        sessions: List of sessions linked to the agent
+
+    Returns:
+        Description string
+    """
+    if not sessions:
+        return ""
+
+    # Build sessions payload
+    sessions_data = []
+    for i, session in enumerate(sessions):
+        sessions_data.append(
+            {
+                "session_number": i + 1,
+                "title": session.session_title or f"Session {session.id[:8]}",
+                "summary": session.session_summary or "(no summary)",
+            }
+        )
+
+    # Try cloud provider
+    try:
+        from ..auth import is_logged_in
+
+        if is_logged_in():
+            logger.debug("Attempting cloud LLM for agent description")
+            custom_prompt = None
+            user_prompt_path = Path.home() / ".aline" / "prompts" / "agent_description.md"
+            try:
+                if user_prompt_path.exists():
+                    custom_prompt = user_prompt_path.read_text(encoding="utf-8").strip()
+            except Exception:
+                pass
+
+            _, result = call_llm_cloud(
+                task="agent_description",
+                payload={"sessions": sessions_data},
+                custom_prompt=custom_prompt,
+                silent=True,
+            )
+
+            if result:
+                description = result.get("description", "")
+                logger.info(f"Cloud LLM agent description success: {description[:60]}...")
+                return description
+            else:
+                logger.warning("Cloud LLM agent description failed, using fallback")
+                return _fallback_agent_description(sessions)
+    except ImportError:
+        logger.debug("Auth module not available, skipping cloud LLM")
+
+    logger.warning("Not logged in, cannot use cloud LLM for agent description")
+    return _fallback_agent_description(sessions)
+
+
+def _fallback_agent_description(sessions: List[SessionRecord]) -> str:
+    """Fallback when LLM fails: simple concatenation of recent session summaries."""
+    summaries = [s.session_summary for s in sessions if s.session_summary]
+    if not summaries:
+        titles = [s.session_title for s in sessions if s.session_title]
+        if titles:
+            return f"Agent with {len(sessions)} sessions. Recent work: {'; '.join(titles[-3:])}"
+        return f"Agent with {len(sessions)} sessions."
+
+    recent = summaries[:3]  # sessions already ordered by last_activity_at DESC
+    return f"Agent with {len(sessions)} sessions. " + " ".join(recent)

realign/events/session_summarizer.py

@@ -145,6 +145,9 @@ def update_session_summary_now(db: SQLiteDatabase, session_id: str) -> bool:
 
         # Trigger event summary updates for all parent events (if any)
         _trigger_parent_event_updates(db, session_id)
+
+        # Trigger agent description update if session is linked to an agent
+        _trigger_agent_description_update(db, session_id)
         return True
 
 
@@ -168,6 +171,28 @@ def _trigger_parent_event_updates(db: SQLiteDatabase, session_id: str) -> None:
         logger.warning(f"Failed to trigger event updates: {e}")
 
 
+def _trigger_agent_description_update(db: SQLiteDatabase, session_id: str) -> None:
+    """
+    Trigger agent description update if the session is linked to an agent.
+
+    Args:
+        db: Database instance
+        session_id: ID of the session whose agent should be updated
+    """
+    try:
+        session = db.get_session_by_id(session_id)
+        if session and getattr(session, "agent_id", None):
+            from .agent_summarizer import schedule_agent_description_update
+
+            schedule_agent_description_update(db, session.agent_id)
+            logger.debug(
+                f"Triggered agent description update for agent_id={session.agent_id}"
+            )
+    except Exception as e:
+        # Don't fail session summary update if agent trigger fails
+        logger.warning(f"Failed to trigger agent description update: {e}")
+
+
 def _get_session_summary_prompt() -> str:
     """
     Load session summary prompt with user customization support.

realign/watcher_core.py

@@ -260,7 +260,7 @@ class DialogueWatcher:
             return
 
         try:
-            from .codex_home import terminal_id_from_codex_session_file
+            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 +271,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 +323,15 @@ class DialogueWatcher:
                 transcript_path=str(session_file),
                 cwd=meta.cwd,
                 project_dir=meta.cwd,
-                source="codex:auto-link",
+                source=source,
             )
+
+            # 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 +453,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 +489,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 +551,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 +581,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)

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,13 @@ class AlineWorker:
             no_track=no_track,
         )
 
+        # Link session to agent after commit ensures session exists in DB
+        if agent_id and session_id:
+            try:
+                self.db.update_session_agent_id(session_id, agent_id)
+            except Exception:
+                pass
+
         if created:
             if expected_turns:
                 self._enqueue_session_summary_if_complete(session_id, expected_turns)
@@ -255,3 +269,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)