claude-smart 0.2.46 → 0.2.48

package/plugin/vendor/reflexio/reflexio/server/services/storage/sqlite_storage/_requests.py

@@ -30,6 +30,8 @@ class RequestMixin:
     _execute: Any
     _fetchone: Any
     _fetchall: Any
+    _subject_ref_for_user_id: Any
+    _assert_subject_writable_locked: Any
 
     # ------------------------------------------------------------------
     # Request methods
@@ -38,20 +40,31 @@ class RequestMixin:
     @SQLiteStorageBase.handle_exceptions
     def add_request(self, request: Request) -> None:
         created_at_iso = _epoch_to_iso(request.created_at)
-        self._execute(
-            """INSERT OR REPLACE INTO requests
-               (request_id, user_id, created_at, source, agent_version, session_id, evaluation_only)
-               VALUES (?,?,?,?,?,?,?)""",
-            (
-                request.request_id,
-                request.user_id,
-                created_at_iso,
-                request.source,
-                request.agent_version,
-                request.session_id,
-                1 if request.evaluation_only else 0,
-            ),
-        )
+        subject_ref = self._subject_ref_for_user_id(request.user_id)
+        with self._lock:
+            try:
+                self.conn.execute("BEGIN IMMEDIATE")
+                self._assert_subject_writable_locked(subject_ref)
+                self.conn.execute(
+                    """INSERT OR REPLACE INTO requests
+                       (request_id, user_id, created_at, source, agent_version, session_id,
+                        evaluation_only, governance_subject_ref)
+                       VALUES (?,?,?,?,?,?,?,?)""",
+                    (
+                        request.request_id,
+                        request.user_id,
+                        created_at_iso,
+                        request.source,
+                        request.agent_version,
+                        request.session_id,
+                        1 if request.evaluation_only else 0,
+                        subject_ref,
+                    ),
+                )
+                self.conn.commit()
+            except Exception:
+                self.conn.rollback()
+                raise
 
     @SQLiteStorageBase.handle_exceptions
     def get_request(self, request_id: str) -> Request | None:
@@ -155,35 +168,62 @@ class RequestMixin:
         end_time: int | None = None,
         top_k: int | None = 30,
         offset: int = 0,
+        source: str | None = None,
     ) -> dict[str, list[RequestInteractionDataModel]]:
-        sql = "SELECT * FROM requests WHERE 1=1"
-        params: list[Any] = []
-
+        # Request-level filters shared by both the session-page query and the
+        # request-fetch query. Pagination is applied at the SESSION level
+        # (top_k/offset count sessions, not request rows) so a session with many
+        # requests is never truncated to a subset of its rows.
+        filter_sql = ""
+        filter_params: list[Any] = []
         if user_id:
-            sql += " AND user_id = ?"
-            params.append(user_id)
+            filter_sql += " AND user_id = ?"
+            filter_params.append(user_id)
         if request_id:
-            sql += " AND request_id = ?"
-            params.append(request_id)
+            filter_sql += " AND request_id = ?"
+            filter_params.append(request_id)
         if session_id:
-            sql += " AND session_id = ?"
-            params.append(session_id)
-        if start_time:
-            sql += " AND created_at >= ?"
-            params.append(_epoch_to_iso(start_time))
-        if end_time:
-            sql += " AND created_at <= ?"
-            params.append(_epoch_to_iso(end_time))
+            filter_sql += " AND session_id = ?"
+            filter_params.append(session_id)
+        if source is not None:
+            filter_sql += " AND source = ?"
+            filter_params.append(source)
+        if start_time is not None:
+            filter_sql += " AND created_at >= ?"
+            filter_params.append(_epoch_to_iso(start_time))
+        if end_time is not None:
+            filter_sql += " AND created_at <= ?"
+            filter_params.append(_epoch_to_iso(end_time))
 
+        # Step 1: select the page of session_ids, ordered by each session's most
+        # recent matching request (latest-first), with session_id as a stable
+        # tiebreak so pages don't overlap or skip.
         effective_limit = top_k or 100
-        sql += " ORDER BY created_at DESC LIMIT ? OFFSET ?"
-        params.extend([effective_limit, offset])
+        page_rows = self._fetchall(
+            f"SELECT session_id, MAX(created_at) AS latest FROM requests "
+            f"WHERE 1=1{filter_sql} "
+            f"GROUP BY session_id ORDER BY latest DESC, session_id DESC "
+            f"LIMIT ? OFFSET ?",
+            [*filter_params, effective_limit, offset],
+        )
+        if not page_rows:
+            return {}
+        page_session_ids = [r["session_id"] for r in page_rows]
 
-        req_rows = self._fetchall(sql, params)
+        # Step 2: fetch ALL matching requests for the sessions in this page.
+        placeholders = ",".join("?" for _ in page_session_ids)
+        req_rows = self._fetchall(
+            f"SELECT * FROM requests WHERE 1=1{filter_sql} "
+            f"AND session_id IN ({placeholders}) ORDER BY created_at DESC",
+            [*filter_params, *page_session_ids],
+        )
         if not req_rows:
             return {}
 
-        grouped: dict[str, list[RequestInteractionDataModel]] = {}
+        # Preserve the latest-first session ordering from step 1.
+        grouped: dict[str, list[RequestInteractionDataModel]] = {
+            (sid or ""): [] for sid in page_session_ids
+        }
         for rr in req_rows:
             req = _row_to_request(rr)
             group_name = req.session_id or ""

package/plugin/vendor/reflexio/reflexio/server/services/storage/sqlite_storage/_share_links.py

@@ -164,3 +164,33 @@ class SQLiteShareLinkMixin:
             (self.org_id,),
         )
         return cur.rowcount
+
+    @SQLiteStorageBase.handle_exceptions
+    def delete_expired_share_links(
+        self, *, now: int, grace_seconds: int, limit: int = 1000
+    ) -> int:
+        """Physically delete share links whose expires_at < now - grace_seconds.
+
+        Args:
+            now (int): Current Unix epoch timestamp.
+            grace_seconds (int): Additional grace window; only rows with
+                expires_at < (now - grace_seconds) are deleted.
+            limit (int): Maximum number of rows to delete in one call.
+                Rows are processed in expires_at ASC order (oldest first).
+
+        Returns:
+            int: Number of rows physically deleted.
+        """
+        cutoff = now - grace_seconds
+        # Re-assert the expiry condition inside the DELETE via a subquery so
+        # the predicate cannot race between the SELECT and the DELETE (TOCTOU).
+        # Matches the Supabase RPC sibling which re-asserts expires_at in a single
+        # atomic statement.
+        cur = self._execute(
+            "DELETE FROM share_links WHERE id IN ("
+            "  SELECT id FROM share_links WHERE org_id = ? AND expires_at IS NOT NULL"
+            "  AND expires_at < ? ORDER BY expires_at ASC LIMIT ?"
+            ")",
+            (self.org_id, cutoff, limit),
+        )
+        return cur.rowcount

package/plugin/vendor/reflexio/reflexio/server/services/storage/sqlite_storage/agent_run/__init__.py

@@ -0,0 +1,9 @@
+from ._agent_run_store import SQLiteAgentRunStoreMixin
+from ._pending_tool_call_store import SQLitePendingToolCallStoreMixin
+from ._run_tool_dependency_store import SQLiteRunToolDependencyStoreMixin
+
+__all__ = [
+    "SQLiteAgentRunStoreMixin",
+    "SQLitePendingToolCallStoreMixin",
+    "SQLiteRunToolDependencyStoreMixin",
+]

package/plugin/vendor/reflexio/reflexio/server/services/storage/sqlite_storage/agent_run/_agent_run_store.py

@@ -0,0 +1,506 @@
+"""SQLite AgentRunStore methods (the AgentRunStore bucket).
+
+Extracted verbatim from ``_agent_run.py`` (the AgentRunStore bucket): the seven
+agent-run lifecycle methods plus the three ``_..._unlocked`` run-cascade
+privates. The privates are consumed cross-bucket by the pending-tool-call
+methods (``cancel``/``expire``/``update_resolved``/``mark_not_applicable``) in
+``SQLitePendingToolCallStoreMixin``, which reach them via MRO co-composition —
+kept SINGLE here, never duplicated.
+
+The residual ``_agent_run.py`` module (helpers-only, no mixin class)
+permanently holds the shared row/datetime helpers (``_dt``, ``_dt_str``,
+``_row_to_agent_run`` …); ``_json_dumps`` comes from ``.._base``. Both are
+imported here rather than duplicated.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+from datetime import UTC, datetime, timedelta
+from typing import Any
+
+from reflexio.server.services.storage.storage_base import (
+    AgentRunRecord,
+    AgentRunStatus,
+    PendingToolCallStatus,
+)
+
+from .._agent_run import _dt_str, _row_to_agent_run
+from .._base import SQLiteStorageBase, _json_dumps
+
+
+class SQLiteAgentRunStoreMixin:
+    """SQLite-backed resumable extraction run store primitives."""
+
+    _lock: Any
+    conn: sqlite3.Connection
+    _fetchone: Any
+    _fetchall: Any
+    _current_timestamp: Any
+    org_id: str
+
+    def _finalize_runs_without_pending_dependencies_unlocked(self, now_s: str) -> None:
+        self.conn.execute(
+            """
+            UPDATE _agent_runs
+            SET status = ?,
+                finalized_at = COALESCE(finalized_at, ?),
+                updated_at = ?
+            WHERE status = ?
+              AND NOT EXISTS (
+                SELECT 1
+                FROM _run_tool_dependencies d
+                JOIN _pending_tool_calls p
+                  ON p.id = d.pending_tool_call_id
+                WHERE d.run_id = _agent_runs.id
+                  AND d.resolved_at IS NULL
+                  AND d.consumed_at IS NULL
+                  AND p.status = ?
+              )
+            """,
+            (
+                AgentRunStatus.FINALIZED.value,
+                now_s,
+                now_s,
+                AgentRunStatus.FINALIZED_PENDING_TOOL.value,
+                PendingToolCallStatus.PENDING.value,
+            ),
+        )
+
+    def _mark_runs_ready_with_actionable_dependencies_unlocked(
+        self, now_s: str, *, pending_tool_call_id: str
+    ) -> None:
+        self.conn.execute(
+            """
+            UPDATE _agent_runs
+            SET status = ?,
+                updated_at = ?
+            WHERE status IN (?, ?)
+              AND EXISTS (
+                SELECT 1
+                FROM _run_tool_dependencies changed
+                WHERE changed.run_id = _agent_runs.id
+                  AND changed.pending_tool_call_id = ?
+              )
+              AND EXISTS (
+                SELECT 1
+                FROM _run_tool_dependencies d
+                JOIN _pending_tool_calls p
+                  ON p.id = d.pending_tool_call_id
+                WHERE d.run_id = _agent_runs.id
+                  AND d.resolved_at IS NOT NULL
+                  AND d.consumed_at IS NULL
+                  AND p.status = ?
+                  AND COALESCE(json_extract(p.result, '$.not_applicable'), 0) != 1
+              )
+            """,
+            (
+                AgentRunStatus.RESUME_READY.value,
+                now_s,
+                AgentRunStatus.FINALIZED.value,
+                AgentRunStatus.FINALIZED_PENDING_TOOL.value,
+                pending_tool_call_id,
+                PendingToolCallStatus.RESOLVED.value,
+            ),
+        )
+
+    def _finalize_runs_without_actionable_dependencies_unlocked(
+        self, now_s: str, *, pending_tool_call_id: str
+    ) -> None:
+        self.conn.execute(
+            """
+            UPDATE _agent_runs
+            SET status = ?,
+                finalized_at = COALESCE(finalized_at, ?),
+                updated_at = ?
+            WHERE status IN (?, ?)
+              AND EXISTS (
+                SELECT 1
+                FROM _run_tool_dependencies changed
+                WHERE changed.run_id = _agent_runs.id
+                  AND changed.pending_tool_call_id = ?
+              )
+              AND NOT EXISTS (
+                SELECT 1
+                FROM _run_tool_dependencies d
+                JOIN _pending_tool_calls p
+                  ON p.id = d.pending_tool_call_id
+                WHERE d.run_id = _agent_runs.id
+                  AND d.resolved_at IS NULL
+                  AND d.consumed_at IS NULL
+                  AND p.status = ?
+              )
+              AND NOT EXISTS (
+                SELECT 1
+                FROM _run_tool_dependencies d
+                JOIN _pending_tool_calls p
+                  ON p.id = d.pending_tool_call_id
+                WHERE d.run_id = _agent_runs.id
+                  AND d.resolved_at IS NOT NULL
+                  AND d.consumed_at IS NULL
+                  AND p.status = ?
+                  AND COALESCE(json_extract(p.result, '$.not_applicable'), 0) != 1
+              )
+            """,
+            (
+                AgentRunStatus.FINALIZED.value,
+                now_s,
+                now_s,
+                AgentRunStatus.FINALIZED_PENDING_TOOL.value,
+                AgentRunStatus.RESUME_READY.value,
+                pending_tool_call_id,
+                PendingToolCallStatus.PENDING.value,
+                PendingToolCallStatus.RESOLVED.value,
+            ),
+        )
+
+    @SQLiteStorageBase.handle_exceptions
+    def create_agent_run(self, record: AgentRunRecord) -> AgentRunRecord:
+        binding = record.binding
+        with self._lock:
+            self.conn.execute(
+                """
+                INSERT INTO _agent_runs (
+                    id, org_id, extractor_kind, user_id,
+                    request_id, agent_version, source, source_interaction_ids,
+                    window_start_interaction_id, window_end_interaction_id,
+                    extractor_config_hash, status, generation_request_snapshot,
+                    service_config_snapshot, agent_context_snapshot,
+                    committed_output, pending_tool_call_ids, max_steps_remaining,
+                    resume_attempts, finalization_attempts, next_resume_at,
+                    claimed_by, claimed_at, agent_completed_at, finalized_at,
+                    expires_at, last_error
+                ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+                """,
+                (
+                    record.id,
+                    binding.org_id,
+                    binding.extractor_kind,
+                    binding.user_id,
+                    binding.request_id,
+                    binding.agent_version,
+                    binding.source,
+                    _json_dumps(binding.source_interaction_ids),
+                    binding.window_start_interaction_id,
+                    binding.window_end_interaction_id,
+                    binding.extractor_config_hash,
+                    record.status.value,
+                    _json_dumps(record.generation_request_snapshot),
+                    _json_dumps(record.service_config_snapshot),
+                    record.agent_context_snapshot,
+                    _json_dumps(record.committed_output),
+                    _json_dumps(record.pending_tool_call_ids),
+                    record.max_steps_remaining,
+                    record.resume_attempts,
+                    record.finalization_attempts,
+                    _dt_str(record.next_resume_at),
+                    record.claimed_by,
+                    _dt_str(record.claimed_at),
+                    _dt_str(record.agent_completed_at),
+                    _dt_str(record.finalized_at),
+                    _dt_str(record.expires_at),
+                    record.last_error,
+                ),
+            )
+            self.conn.commit()
+        stored = self.get_agent_run(record.id)
+        if stored is None:  # pragma: no cover
+            raise RuntimeError(f"Failed to create agent run {record.id}")
+        return stored
+
+    @SQLiteStorageBase.handle_exceptions
+    def get_agent_run(self, run_id: str) -> AgentRunRecord | None:
+        row = self._fetchone("SELECT * FROM _agent_runs WHERE id = ?", (run_id,))
+        return _row_to_agent_run(row) if row else None
+
+    @SQLiteStorageBase.handle_exceptions
+    def update_agent_run_status(
+        self,
+        run_id: str,
+        status: AgentRunStatus,
+        *,
+        committed_output: dict[str, Any] | None = None,
+        pending_tool_call_ids: list[str] | None = None,
+        max_steps_remaining: int | None = None,
+        next_resume_at: datetime | None = None,
+        last_error: str | None = None,
+        increment_finalization_attempts: bool = False,
+        expected_statuses: tuple[AgentRunStatus, ...] | None = None,
+    ) -> AgentRunRecord | None:
+        current_timestamp = self._current_timestamp()
+        assignments = ["status = ?", "updated_at = ?"]
+        params: list[Any] = [status.value, current_timestamp]
+        if committed_output is not None:
+            assignments.append("committed_output = ?")
+            params.append(_json_dumps(committed_output))
+        if pending_tool_call_ids is not None:
+            assignments.append("pending_tool_call_ids = ?")
+            params.append(_json_dumps(pending_tool_call_ids))
+        if max_steps_remaining is not None:
+            assignments.append("max_steps_remaining = ?")
+            params.append(max(0, max_steps_remaining))
+        if next_resume_at is not None:
+            assignments.append("next_resume_at = ?")
+            params.append(_dt_str(next_resume_at))
+        if last_error is not None:
+            assignments.append("last_error = ?")
+            params.append(last_error)
+        if increment_finalization_attempts:
+            assignments.append("finalization_attempts = finalization_attempts + 1")
+        if status == AgentRunStatus.AGENT_COMPLETED:
+            assignments.append("agent_completed_at = ?")
+            params.append(current_timestamp)
+        if status in (AgentRunStatus.FINALIZED, AgentRunStatus.FINALIZED_PENDING_TOOL):
+            assignments.append("finalized_at = ?")
+            params.append(current_timestamp)
+        params.append(run_id)
+        status_filter = ""
+        if expected_statuses:
+            placeholders = ",".join("?" for _ in expected_statuses)
+            status_filter = f" AND status IN ({placeholders})"
+            params.extend(expected.value for expected in expected_statuses)
+        with self._lock:
+            self.conn.execute(
+                f"UPDATE _agent_runs SET {', '.join(assignments)} WHERE id = ?{status_filter}",
+                params,
+            )
+            self.conn.commit()
+        return self.get_agent_run(run_id)
+
+    @SQLiteStorageBase.handle_exceptions
+    def fail_running_agent_runs_for_request(
+        self,
+        *,
+        org_id: str,
+        extractor_kind: str,
+        user_id: str | None,
+        request_id: str,
+        last_error: str,
+    ) -> int:
+        current_timestamp = self._current_timestamp()
+        with self._lock:
+            cursor = self.conn.execute(
+                """
+                UPDATE _agent_runs
+                SET status = ?,
+                    updated_at = ?,
+                    last_error = ?
+                WHERE org_id = ?
+                  AND extractor_kind = ?
+                  AND user_id IS ?
+                  AND request_id = ?
+                  AND status IN (?, ?)
+                """,
+                (
+                    AgentRunStatus.FAILED.value,
+                    current_timestamp,
+                    last_error,
+                    org_id,
+                    extractor_kind,
+                    user_id,
+                    request_id,
+                    AgentRunStatus.RUNNING.value,
+                    AgentRunStatus.RESUMING.value,
+                ),
+            )
+            self.conn.commit()
+            return cursor.rowcount
+
+    @SQLiteStorageBase.handle_exceptions
+    def claim_ready_agent_run(
+        self,
+        *,
+        org_id: str,
+        worker_id: str,
+        now: datetime | None = None,
+        claim_ttl_seconds: int = 600,
+    ) -> AgentRunRecord | None:
+        current = now or datetime.now(UTC)
+        stale_before = current - timedelta(seconds=claim_ttl_seconds)
+        with self._lock:
+            row = self.conn.execute(
+                """
+                SELECT r.*
+                FROM _agent_runs r
+                WHERE r.org_id = ?
+                  AND (
+                    r.status = ?
+                    OR (r.status = ? AND r.claimed_at < ?)
+                )
+                  AND (r.next_resume_at IS NULL OR r.next_resume_at <= ?)
+                  AND EXISTS (
+                    SELECT 1
+                    FROM _run_tool_dependencies d
+                    JOIN _pending_tool_calls p
+                      ON p.id = d.pending_tool_call_id
+                    WHERE d.run_id = r.id
+                      AND d.resolved_at IS NOT NULL
+                      AND d.consumed_at IS NULL
+                      AND p.status = ?
+                      AND COALESCE(json_extract(p.result, '$.not_applicable'), 0) != 1
+                  )
+                ORDER BY
+                    r.org_id ASC,
+                    r.extractor_kind ASC,
+                    COALESCE(r.user_id, '') ASC,
+                    COALESCE(r.window_start_interaction_id, 0) ASC,
+                    r.updated_at ASC
+                LIMIT 1
+                """,
+                (
+                    org_id,
+                    AgentRunStatus.RESUME_READY.value,
+                    AgentRunStatus.RESUMING.value,
+                    _dt_str(stale_before),
+                    _dt_str(current),
+                    PendingToolCallStatus.RESOLVED.value,
+                ),
+            ).fetchone()
+            if row is None:
+                return None
+            self.conn.execute(
+                """
+                UPDATE _agent_runs
+                SET status = ?,
+                    claimed_by = ?,
+                    claimed_at = ?,
+                    resume_attempts = resume_attempts + 1,
+                    updated_at = ?
+                WHERE id = ?
+                """,
+                (
+                    AgentRunStatus.RESUMING.value,
+                    worker_id,
+                    _dt_str(current),
+                    self._current_timestamp(),
+                    row["id"],
+                ),
+            )
+            self.conn.commit()
+        return self.get_agent_run(row["id"])
+
+    @SQLiteStorageBase.handle_exceptions
+    def claim_finalization_failed_agent_run(
+        self,
+        *,
+        org_id: str,
+        worker_id: str,
+        now: datetime | None = None,
+        claim_ttl_seconds: int = 600,
+    ) -> AgentRunRecord | None:
+        current = now or datetime.now(UTC)
+        stale_before = current - timedelta(seconds=claim_ttl_seconds)
+        with self._lock:
+            # Claim runs that still need their committed output finalized:
+            #  - FINALIZATION_FAILED: an explicit retry is due.
+            #  - stale FINALIZING: a worker crashed mid-finalize.
+            #  - stale AGENT_COMPLETED: publish-time finalization never ran or
+            #    crashed before flipping the status (the run row carries
+            #    committed_output but was orphaned); the staleness guard ensures
+            #    we never race an in-flight publish-time finalize.
+            row = self.conn.execute(
+                """
+                SELECT *
+                FROM _agent_runs
+                WHERE org_id = ?
+                  AND (
+                    status = ?
+                    OR (status = ? AND claimed_at < ?)
+                    OR (status = ? AND updated_at < ?)
+                )
+                  AND committed_output IS NOT NULL
+                  AND (next_resume_at IS NULL OR next_resume_at <= ?)
+                ORDER BY
+                    org_id ASC,
+                    extractor_kind ASC,
+                    COALESCE(user_id, '') ASC,
+                    COALESCE(window_start_interaction_id, 0) ASC,
+                    updated_at ASC
+                LIMIT 1
+                """,
+                (
+                    org_id,
+                    AgentRunStatus.FINALIZATION_FAILED.value,
+                    AgentRunStatus.FINALIZING.value,
+                    _dt_str(stale_before),
+                    AgentRunStatus.AGENT_COMPLETED.value,
+                    _dt_str(stale_before),
+                    _dt_str(current),
+                ),
+            ).fetchone()
+            if row is None:
+                return None
+            self.conn.execute(
+                """
+                UPDATE _agent_runs
+                SET status = ?,
+                    claimed_by = ?,
+                    claimed_at = ?,
+                    updated_at = ?
+                WHERE id = ?
+                """,
+                (
+                    AgentRunStatus.FINALIZING.value,
+                    worker_id,
+                    _dt_str(current),
+                    self._current_timestamp(),
+                    row["id"],
+                ),
+            )
+            self.conn.commit()
+        return self.get_agent_run(row["id"])
+
+    @SQLiteStorageBase.handle_exceptions
+    def list_resumable_work_org_ids(
+        self,
+        *,
+        now: datetime | None = None,
+        limit: int = 1000,
+    ) -> list[str]:
+        current = now or datetime.now(UTC)
+        now_s = _dt_str(current)
+        bounded_limit = max(1, min(limit, 10_000))
+        # Cross-org maintenance query. Surfaces any org that has a run ready to
+        # resume / awaiting finalization, or a pending tool call due to expire.
+        rows = self._fetchall(
+            """
+            SELECT DISTINCT org_id FROM (
+                SELECT r.org_id
+                FROM _agent_runs r
+                WHERE r.status IN (?, ?)
+                  AND EXISTS (
+                    SELECT 1
+                    FROM _run_tool_dependencies d
+                    JOIN _pending_tool_calls p
+                      ON p.id = d.pending_tool_call_id
+                    WHERE d.run_id = r.id
+                      AND d.resolved_at IS NOT NULL
+                      AND d.consumed_at IS NULL
+                      AND p.status = ?
+                      AND COALESCE(json_extract(p.result, '$.not_applicable'), 0) != 1
+                  )
+                UNION
+                SELECT org_id FROM _agent_runs
+                WHERE status IN (?, ?, ?)
+                UNION
+                SELECT org_id FROM _pending_tool_calls
+                WHERE status = ?
+                  AND expires_at IS NOT NULL
+                  AND expires_at <= ?
+            )
+            ORDER BY org_id ASC
+            LIMIT ?
+            """,
+            (
+                AgentRunStatus.RESUME_READY.value,
+                AgentRunStatus.RESUMING.value,
+                PendingToolCallStatus.RESOLVED.value,
+                AgentRunStatus.FINALIZATION_FAILED.value,
+                AgentRunStatus.FINALIZING.value,
+                AgentRunStatus.AGENT_COMPLETED.value,
+                PendingToolCallStatus.PENDING.value,
+                now_s,
+                bounded_limit,
+            ),
+        )
+        return [row["org_id"] for row in rows]