@team-agent/installer 0.2.3 → 0.2.5

package/src/team_agent/message_store/core.py

@@ -2,19 +2,49 @@ from __future__ import annotations
 
 import json
 import sqlite3
+import time
 import uuid
 from contextlib import closing
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
-from typing import Any
+from typing import Any, Callable
 
 from . import agent_health as _agent_health
 from . import result_watchers as _result_watchers
 from .schema import SCHEMA_VERSION, initialize_schema, utcnow
+from .schema_migration import MANAGED_TABLE_LAYOUTS
 from team_agent.paths import runtime_dir
 from team_agent.spec import validate_result_envelope
 
 
+MESSAGE_SELECT = ", ".join(MANAGED_TABLE_LAYOUTS["messages"])
+RESULT_SELECT = ", ".join(MANAGED_TABLE_LAYOUTS["results"])
+SCHEDULED_EVENT_SELECT = ", ".join(MANAGED_TABLE_LAYOUTS["scheduled_events"])
+DELIVERY_TOKEN_SELECT = ", ".join(MANAGED_TABLE_LAYOUTS["delivery_tokens"])
+
+
+def _is_sqlite_locked(exc: sqlite3.OperationalError) -> bool:
+    message = str(exc).lower()
+    return (
+        "database is locked" in message
+        or "database table is locked" in message
+        or "database schema is locked" in message
+    )
+
+
+def _with_sqlite_busy_retry(action: Callable[[], None]) -> None:
+    delay = 0.05
+    for attempt in range(6):
+        try:
+            action()
+            return
+        except sqlite3.OperationalError as exc:
+            if not _is_sqlite_locked(exc) or attempt == 5:
+                raise
+            time.sleep(delay)
+            delay *= 2
+
+
 class MessageStore:
     SCHEMA_VERSION = SCHEMA_VERSION
 
@@ -27,13 +57,16 @@ class MessageStore:
     def connect(self) -> sqlite3.Connection:
         conn = sqlite3.connect(self.path, timeout=30.0, isolation_level=None)
         conn.row_factory = sqlite3.Row
-        conn.execute("PRAGMA journal_mode=WAL")
         conn.execute("PRAGMA busy_timeout=30000")
+        conn.execute("PRAGMA journal_mode=WAL")
         return conn
 
     def _init(self) -> None:
-        with closing(self.connect()) as conn:
-            initialize_schema(conn)
+        def initialize() -> None:
+            with closing(self.connect()) as conn:
+                initialize_schema(conn, self.path)
+
+        _with_sqlite_busy_retry(initialize)
 
     def create_message(
         self,
@@ -198,10 +231,10 @@ class MessageStore:
     def messages(self, owner_team_id: str | None = None) -> list[dict[str, Any]]:
         with closing(self.connect()) as conn:
             if owner_team_id is None:
-                rows = conn.execute("select * from messages order by created_at").fetchall()
+                rows = conn.execute(f"select {MESSAGE_SELECT} from messages order by created_at").fetchall()
             else:
                 rows = conn.execute(
-                    "select * from messages where owner_team_id = ? or owner_team_id is null order by created_at",
+                    f"select {MESSAGE_SELECT} from messages where owner_team_id = ? or owner_team_id is null order by created_at",
                     (owner_team_id,),
                 ).fetchall()
         return [dict(row) for row in rows]
@@ -210,8 +243,8 @@ class MessageStore:
         with closing(self.connect()) as conn:
             if owner_team_id is None:
                 rows = conn.execute(
-                    """
-                    select * from messages
+                    f"""
+                    select {MESSAGE_SELECT} from messages
                     where sender = ? or recipient = ?
                     order by created_at desc
                     limit ?
@@ -220,8 +253,8 @@ class MessageStore:
                 ).fetchall()
             else:
                 rows = conn.execute(
-                    """
-                    select * from messages
+                    f"""
+                    select {MESSAGE_SELECT} from messages
                     where (sender = ? or recipient = ?)
                       and (owner_team_id = ? or owner_team_id is null)
                     order by created_at desc
@@ -233,7 +266,7 @@ class MessageStore:
 
     def delivery_tokens(self) -> list[dict[str, Any]]:
         with closing(self.connect()) as conn:
-            rows = conn.execute("select * from delivery_tokens order by injected_at").fetchall()
+            rows = conn.execute(f"select {DELIVERY_TOKEN_SELECT} from delivery_tokens order by injected_at").fetchall()
         return [dict(row) for row in rows]
 
     def add_scheduled_event(
@@ -259,8 +292,8 @@ class MessageStore:
         with closing(self.connect()) as conn:
             if owner_team_id is None:
                 rows = conn.execute(
-                    """
-                    select * from scheduled_events
+                    f"""
+                    select {SCHEDULED_EVENT_SELECT} from scheduled_events
                     where status = 'pending' and due_at <= ?
                     order by due_at, id
                     """,
@@ -268,8 +301,8 @@ class MessageStore:
                 ).fetchall()
             else:
                 rows = conn.execute(
-                    """
-                    select * from scheduled_events
+                    f"""
+                    select {SCHEDULED_EVENT_SELECT} from scheduled_events
                     where status = 'pending' and due_at <= ?
                       and (owner_team_id = ? or owner_team_id is null)
                     order by due_at, id
@@ -412,14 +445,14 @@ class MessageStore:
         if uncollected_only:
             clauses.append("status not in ('collected', 'invalid')")
         where = " where " + " and ".join(clauses) if clauses else ""
-        query = f"select * from results{where} order by created_at"
+        query = f"select {RESULT_SELECT} from results{where} order by created_at"
         with closing(self.connect()) as conn:
             rows = conn.execute(query, args).fetchall()
         return [dict(row) for row in rows]
 
     def result_by_id(self, result_id: str) -> dict[str, Any] | None:
         with closing(self.connect()) as conn:
-            row = conn.execute("select * from results where result_id = ?", (result_id,)).fetchone()
+            row = conn.execute(f"select {RESULT_SELECT} from results where result_id = ?", (result_id,)).fetchone()
         return dict(row) if row else None
 
     def latest_results(self, limit: int = 5, owner_team_id: str | None = None) -> list[dict[str, Any]]:
@@ -428,7 +461,7 @@ class MessageStore:
         with closing(self.connect()) as conn:
             rows = conn.execute(
                 f"""
-                select * from results
+                select {RESULT_SELECT} from results
                 where status != 'invalid' {owner_clause}
                 order by created_at desc
                 limit ?

package/src/team_agent/message_store/leader_notification_log.py

@@ -11,8 +11,24 @@ from __future__ import annotations
 
 from contextlib import closing
 from datetime import datetime, timedelta, timezone
+import sqlite3
+import time
 from typing import Any
 
+from team_agent.message_store.schema_migration import MANAGED_TABLE_LAYOUTS
+
+
+LEADER_NOTIFICATION_SELECT = ", ".join(MANAGED_TABLE_LAYOUTS["leader_notification_log"])
+
+
+def _sqlite_locked(exc: sqlite3.OperationalError) -> bool:
+    message = str(exc).lower()
+    return (
+        "database is locked" in message
+        or "database table is locked" in message
+        or "database schema is locked" in message
+    )
+
 
 def claim_leader_notification_delivery(
     store: Any,
@@ -28,43 +44,52 @@ def claim_leader_notification_delivery(
     rowcount=0 means a prior row exists for (result_id, leader_session_uuid); SELECT
     it and return so the caller can decide to suppress (same envelope_hash) or surface
     legitimate-duplicate (different envelope_hash)."""
-    now = datetime.now(timezone.utc).isoformat()
-    with closing(store.connect()) as conn:
-        with conn:
-            cur = conn.execute(
-                "insert or ignore into leader_notification_log("
-                "  result_id, leader_session_uuid, notified_message_id, notified_at,"
-                "  leader_pane_id_at_notify, envelope_content_hash, owner_team_id"
-                ") values (?, ?, ?, ?, ?, ?, ?)",
-                (
-                    result_id, leader_session_uuid, proposed_message_id, now,
-                    pane_id, envelope_hash, owner_team_id,
-                ),
-            )
-            if cur.rowcount == 1:
-                return {
-                    "status": "claimed_by_you",
-                    "notified_message_id": proposed_message_id,
-                    "notified_at": now,
-                    "envelope_content_hash": envelope_hash,
-                }
-            row = conn.execute(
-                "select notified_message_id, notified_at, envelope_content_hash, "
-                "leader_pane_id_at_notify from leader_notification_log "
-                "where result_id = ? and leader_session_uuid = ?",
-                (result_id, leader_session_uuid),
-            ).fetchone()
+    delay = 0.05
+    row = None
+    for attempt in range(6):
+        now = datetime.now(timezone.utc).isoformat()
+        try:
+            with closing(store.connect()) as conn:
+                with conn:
+                    cur = conn.execute(
+                        "insert or ignore into leader_notification_log("
+                        "  result_id, leader_session_uuid, notified_message_id, notified_at,"
+                        "  leader_pane_id_at_notify, envelope_content_hash, owner_team_id"
+                        ") values (?, ?, ?, ?, ?, ?, ?)",
+                        (
+                            result_id, leader_session_uuid, proposed_message_id, now,
+                            pane_id, envelope_hash, owner_team_id,
+                        ),
+                    )
+                    if cur.rowcount == 1:
+                        return {
+                            "status": "claimed_by_you",
+                            "notified_message_id": proposed_message_id,
+                            "notified_at": now,
+                            "envelope_content_hash": envelope_hash,
+                        }
+                    row = conn.execute(
+                        "select notified_message_id, notified_at, envelope_content_hash, "
+                        "leader_pane_id_at_notify from leader_notification_log "
+                        "where result_id = ? and leader_session_uuid = ?",
+                        (result_id, leader_session_uuid),
+                    ).fetchone()
+            break
+        except sqlite3.OperationalError as exc:
+            if not _sqlite_locked(exc) or attempt == 5:
+                raise
+            time.sleep(delay)
+            delay *= 2
     if row is None:
         # Should not happen (INSERT OR IGNORE returned 0 → row must exist), but be defensive.
         return {"status": "claimed_by_you", "notified_message_id": proposed_message_id,
                 "notified_at": now, "envelope_content_hash": envelope_hash}
-    prev_message_id, prev_ts, prev_hash, prev_pane = row[0], row[1], row[2], row[3]
     return {
         "status": "already_notified_by",
-        "notified_message_id": prev_message_id,
-        "notified_at": prev_ts,
-        "envelope_content_hash": prev_hash,
-        "leader_pane_id_at_notify": prev_pane,
+        "notified_message_id": row["notified_message_id"],
+        "notified_at": row["notified_at"],
+        "envelope_content_hash": row["envelope_content_hash"],
+        "leader_pane_id_at_notify": row["leader_pane_id_at_notify"],
     }
 
 
@@ -88,11 +113,11 @@ def peek_leader_notification(
     if row is None:
         return None
     return {
-        "notified_message_id": row[0],
-        "notified_at": row[1],
-        "envelope_content_hash": row[2],
-        "leader_pane_id_at_notify": row[3],
-        "owner_team_id": row[4],
+        "notified_message_id": row["notified_message_id"],
+        "notified_at": row["notified_at"],
+        "envelope_content_hash": row["envelope_content_hash"],
+        "leader_pane_id_at_notify": row["leader_pane_id_at_notify"],
+        "owner_team_id": row["owner_team_id"],
     }
 
 
@@ -113,11 +138,11 @@ def leader_notification_log_rows(store: Any, *, owner_team_id: str | None = None
     with closing(store.connect()) as conn:
         if owner_team_id is None:
             rows = conn.execute(
-                "select * from leader_notification_log order by notified_at"
+                f"select {LEADER_NOTIFICATION_SELECT} from leader_notification_log order by notified_at"
             ).fetchall()
         else:
             rows = conn.execute(
-                "select * from leader_notification_log where owner_team_id = ? "
+                f"select {LEADER_NOTIFICATION_SELECT} from leader_notification_log where owner_team_id = ? "
                 "or owner_team_id is null order by notified_at",
                 (owner_team_id,),
             ).fetchall()

package/src/team_agent/message_store/result_watchers.py

@@ -4,9 +4,13 @@ import uuid
 from contextlib import closing
 from typing import Any
 
+from team_agent.message_store.schema_migration import MANAGED_TABLE_LAYOUTS
 from team_agent.message_store.schema import utcnow
 
 
+RESULT_WATCHER_SELECT = ", ".join(MANAGED_TABLE_LAYOUTS["result_watchers"])
+
+
 def create_result_watcher(
     self,
     task_id: str | None,
@@ -32,11 +36,13 @@ def create_result_watcher(
 def pending_result_watchers(self, owner_team_id: str | None = None) -> list[dict[str, Any]]:
     with closing(self.connect()) as conn:
         if owner_team_id is None:
-            rows = conn.execute("select * from result_watchers where status = 'pending' order by created_at").fetchall()
+            rows = conn.execute(
+                f"select {RESULT_WATCHER_SELECT} from result_watchers where status = 'pending' order by created_at"
+            ).fetchall()
         else:
             rows = conn.execute(
-                """
-                select * from result_watchers
+                f"""
+                select {RESULT_WATCHER_SELECT} from result_watchers
                 where status = 'pending' and (owner_team_id = ? or owner_team_id is null)
                 order by created_at
                 """,
@@ -47,17 +53,17 @@ def pending_result_watchers(self, owner_team_id: str | None = None) -> list[dict
 def retryable_result_watchers(self) -> list[dict[str, Any]]:
     with closing(self.connect()) as conn:
         rows = conn.execute(
-            "select * from result_watchers where status in ('pending', 'notify_failed') order by created_at"
+            f"select {RESULT_WATCHER_SELECT} from result_watchers where status in ('pending', 'notify_failed') order by created_at"
         ).fetchall()
     return [dict(row) for row in rows]
 
 def result_watchers(self, owner_team_id: str | None = None) -> list[dict[str, Any]]:
     with closing(self.connect()) as conn:
         if owner_team_id is None:
-            rows = conn.execute("select * from result_watchers order by created_at").fetchall()
+            rows = conn.execute(f"select {RESULT_WATCHER_SELECT} from result_watchers order by created_at").fetchall()
         else:
             rows = conn.execute(
-                "select * from result_watchers where owner_team_id = ? or owner_team_id is null order by created_at",
+                f"select {RESULT_WATCHER_SELECT} from result_watchers where owner_team_id = ? or owner_team_id is null order by created_at",
                 (owner_team_id,),
             ).fetchall()
     return [dict(row) for row in rows]
@@ -92,7 +98,7 @@ def requeue_delivery_exhausted_watchers(self) -> list[str]:
             rows = conn.execute(
                 "select watcher_id from result_watchers where status = 'delivery_exhausted'"
             ).fetchall()
-            watcher_ids = [row[0] for row in rows]
+            watcher_ids = [row["watcher_id"] for row in rows]
             if watcher_ids:
                 # Phase D hotfix-3 (78055bc) cleared notified_message_id here; Gap 32 dedupe
                 # reverses that — preserve notified_message_id so the retry path can re-confirm
@@ -153,9 +159,9 @@ def _claim_leader_notification_disabled_impl(  # legacy reference for archaeolog
                     "order by coalesce(completed_at, created_at) limit 1",
                     (result_id, owner_team_id),
                 ).fetchone()
-            if sibling and sibling[0]:
+            if sibling and sibling["notified_message_id"]:
                 conn.execute("COMMIT")
-                return {"status": "already_notified_by", "canonical_message_id": sibling[0]}
+                return {"status": "already_notified_by", "canonical_message_id": sibling["notified_message_id"]}
             cur = conn.execute(
                 "update result_watchers "
                 "set notified_message_id = ?, result_id = coalesce(result_id, ?) "
@@ -172,7 +178,7 @@ def _claim_leader_notification_disabled_impl(  # legacy reference for archaeolog
             conn.execute("COMMIT")
             return {
                 "status": "already_notified_by",
-                "canonical_message_id": (row[0] if row else None) or None,
+                "canonical_message_id": (row["notified_message_id"] if row else None) or None,
             }
         except Exception:
             try:
@@ -242,4 +248,4 @@ def leader_notified_message_id_for_result(
                 "order by coalesce(completed_at, created_at) limit 1",
                 (result_id, owner_team_id),
             ).fetchone()
-    return row[0] if row else None
+    return row["notified_message_id"] if row else None

package/src/team_agent/message_store/schema.py

@@ -2,6 +2,10 @@ from __future__ import annotations
 
 import sqlite3
 from datetime import datetime, timezone
+from pathlib import Path
+
+from team_agent.message_store import schema_migration as _schema_migration
+from team_agent.message_store.schema_migration import ensure_table_layout, table_layout
 
 
 MESSAGE_COLUMNS = {
@@ -68,16 +72,26 @@ RESULT_WATCHER_COLUMNS = {
     "notified_message_id",
     "error",
 }
+LEADER_NOTIFICATION_LOG_COLUMNS = {
+    "result_id",
+    "leader_session_uuid",
+    "notified_message_id",
+    "notified_at",
+    "leader_pane_id_at_notify",
+    "envelope_content_hash",
+    "owner_team_id",
+}
 
 
 def utcnow() -> str:
     return datetime.now(timezone.utc).isoformat()
 
 SCHEMA_VERSION = 3
+SCHEMA_MIGRATIONS = _schema_migration.SCHEMA_MIGRATIONS
 
 
 def _table_columns(conn: sqlite3.Connection, table: str) -> set[str]:
-    return {row[1] for row in conn.execute(f"pragma table_info({table})").fetchall()}
+    return set(table_layout(conn, table))
 
 
 def _ensure_table_columns(
@@ -97,7 +111,9 @@ def _ensure_table_columns(
         conn.execute(migrations[name])
 
 
-def initialize_schema(conn: sqlite3.Connection) -> None:
+def initialize_schema(conn: sqlite3.Connection, db_path: Path | None = None) -> None:
+    _schema_migration.SCHEMA_MIGRATIONS = SCHEMA_MIGRATIONS
+    ensure_table_layout(conn, schema_version=SCHEMA_VERSION, db_path=db_path)
     with conn:
         conn.execute(
             """
@@ -260,6 +276,7 @@ def initialize_schema(conn: sqlite3.Connection) -> None:
             "create index if not exists idx_leader_notification_log_uuid "
             "on leader_notification_log(leader_session_uuid, notified_at)"
         )
+        _ensure_table_columns(conn, "leader_notification_log", LEADER_NOTIFICATION_LOG_COLUMNS)
         conn.execute("create index if not exists idx_messages_owner_team_id on messages(owner_team_id)")
         conn.execute("create index if not exists idx_scheduled_events_owner_team_id on scheduled_events(owner_team_id)")
         conn.execute("create index if not exists idx_agent_health_owner_team_id on agent_health(owner_team_id)")