diff --git a/skyvern/forge/sdk/db/agent_db.py b/skyvern/forge/sdk/db/agent_db.py
index 6729577ed..c8f921583 100644
--- a/skyvern/forge/sdk/db/agent_db.py
+++ b/skyvern/forge/sdk/db/agent_db.py
@@ -13,20 +13,21 @@ from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
 
 from skyvern.config import settings
 from skyvern.forge.sdk.db.base_alchemy_db import BaseAlchemyDB
-from skyvern.forge.sdk.db.mixins.artifacts import ArtifactsMixin
-from skyvern.forge.sdk.db.mixins.browser_sessions import BrowserSessionsMixin
-from skyvern.forge.sdk.db.mixins.credentials import CredentialsMixin
-from skyvern.forge.sdk.db.mixins.debug import DebugMixin
-from skyvern.forge.sdk.db.mixins.folders import FoldersMixin
-from skyvern.forge.sdk.db.mixins.observer import ObserverMixin
-from skyvern.forge.sdk.db.mixins.organizations import OrganizationsMixin
-from skyvern.forge.sdk.db.mixins.otp import OTPMixin
-from skyvern.forge.sdk.db.mixins.schedules import ScheduleLimitExceededError, SchedulesMixin
-from skyvern.forge.sdk.db.mixins.scripts import ScriptsMixin
-from skyvern.forge.sdk.db.mixins.tasks import TasksMixin
-from skyvern.forge.sdk.db.mixins.workflow_parameters import WorkflowParametersMixin
-from skyvern.forge.sdk.db.mixins.workflow_runs import WorkflowRunsMixin
-from skyvern.forge.sdk.db.mixins.workflows import WorkflowsMixin
+from skyvern.forge.sdk.db.exceptions import ScheduleLimitExceededError  # noqa: F401
+from skyvern.forge.sdk.db.repositories.artifacts import ArtifactsRepository
+from skyvern.forge.sdk.db.repositories.browser_sessions import BrowserSessionsRepository
+from skyvern.forge.sdk.db.repositories.credentials import CredentialRepository
+from skyvern.forge.sdk.db.repositories.debug import DebugRepository
+from skyvern.forge.sdk.db.repositories.folders import FoldersRepository
+from skyvern.forge.sdk.db.repositories.observer import ObserverRepository
+from skyvern.forge.sdk.db.repositories.organizations import OrganizationsRepository
+from skyvern.forge.sdk.db.repositories.otp import OTPRepository
+from skyvern.forge.sdk.db.repositories.schedules import SchedulesRepository
+from skyvern.forge.sdk.db.repositories.scripts import ScriptsRepository
+from skyvern.forge.sdk.db.repositories.tasks import TasksRepository
+from skyvern.forge.sdk.db.repositories.workflow_parameters import WorkflowParametersRepository
+from skyvern.forge.sdk.db.repositories.workflow_runs import WorkflowRunsRepository
+from skyvern.forge.sdk.db.repositories.workflows import WorkflowsRepository
 from skyvern.forge.sdk.db.utils import (
     _custom_json_serializer,
 )
@@ -104,23 +105,7 @@ def _build_engine(database_string: str) -> AsyncEngine:
 __all__ = ["AgentDB", "ScheduleLimitExceededError"]
 
 
-class AgentDB(
-    TasksMixin,
-    WorkflowsMixin,
-    WorkflowRunsMixin,
-    WorkflowParametersMixin,
-    SchedulesMixin,
-    ArtifactsMixin,
-    BrowserSessionsMixin,
-    ScriptsMixin,
-    OTPMixin,
-    CredentialsMixin,
-    FoldersMixin,
-    OrganizationsMixin,
-    ObserverMixin,
-    DebugMixin,
-    BaseAlchemyDB,
-):
+class AgentDB(BaseAlchemyDB):
     def __init__(self, database_string: str, debug_enabled: bool = False, db_engine: AsyncEngine | None = None) -> None:
         super().__init__(db_engine or _build_engine(database_string))
         self.debug_enabled = debug_enabled
@@ -131,6 +116,819 @@ class AgentDB(
             asyncio.Lock() if self.engine.dialect.name == "sqlite" else None
         )
 
+        # -- Zero-dependency repositories --
+        self.tasks = TasksRepository(self.Session, debug_enabled, self.is_retryable_error)
+        self.workflows = WorkflowsRepository(self.Session, debug_enabled, self.is_retryable_error)
+        self.workflow_params = WorkflowParametersRepository(self.Session, debug_enabled, self.is_retryable_error)
+        self.credentials = CredentialRepository(self.Session, debug_enabled, self.is_retryable_error)
+        self.otp = OTPRepository(self.Session, debug_enabled, self.is_retryable_error)
+        self.debug = DebugRepository(self.Session, debug_enabled, self.is_retryable_error)
+        self.organizations = OrganizationsRepository(self.Session, debug_enabled, self.is_retryable_error)
+        self.scripts = ScriptsRepository(self.Session, debug_enabled, self.is_retryable_error)
+        self.browser_sessions = BrowserSessionsRepository(self.Session, debug_enabled, self.is_retryable_error)
+        self.schedules = SchedulesRepository(
+            self.Session,
+            debug_enabled,
+            self.is_retryable_error,
+            sqlite_schedule_lock=self._sqlite_schedule_lock,
+        )
+
+        # -- Cross-dependency repositories --
+        self.workflow_runs = WorkflowRunsRepository(
+            self.Session,
+            debug_enabled,
+            self.is_retryable_error,
+            workflow_parameter_reader=self.workflow_params,
+            dialect_name=self.engine.dialect.name,
+        )
+        self.artifacts = ArtifactsRepository(
+            self.Session,
+            debug_enabled,
+            self.is_retryable_error,
+            run_reader=self.workflow_runs,
+        )
+        self.folders = FoldersRepository(
+            self.Session,
+            debug_enabled,
+            self.is_retryable_error,
+            workflow_reader=self.workflows,
+        )
+        self.observer = ObserverRepository(
+            self.Session,
+            debug_enabled,
+            self.is_retryable_error,
+            task_reader=self.tasks,
+        )
+
     def is_retryable_error(self, error: SQLAlchemyError) -> bool:
         error_msg = str(error).lower()
         return "server closed the connection" in error_msg
+
+    # ======================================================================
+    # Backward-compatible delegate methods
+    # TODO(SKY-62): These delegates erase type information (*args: Any -> Any).
+    # Migrate callers to use typed repository attributes directly
+    # (e.g., db.tasks.get_task(...) instead of db.get_task(...)), then remove.
+    # ======================================================================
+
+    # -- Task delegates --
+
+    async def create_task(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.create_task(*args, **kwargs)
+
+    async def create_step(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.create_step(*args, **kwargs)
+
+    async def get_task(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.get_task(*args, **kwargs)
+
+    async def get_tasks_by_ids(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.get_tasks_by_ids(*args, **kwargs)
+
+    async def get_step(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.get_step(*args, **kwargs)
+
+    async def get_task_steps(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.get_task_steps(*args, **kwargs)
+
+    async def get_steps_by_task_ids(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.get_steps_by_task_ids(*args, **kwargs)
+
+    async def get_total_unique_step_order_count_by_task_ids(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.get_total_unique_step_order_count_by_task_ids(*args, **kwargs)
+
+    async def get_task_step_models(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.get_task_step_models(*args, **kwargs)
+
+    async def get_task_step_count(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.get_task_step_count(*args, **kwargs)
+
+    async def get_task_actions(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.get_task_actions(*args, **kwargs)
+
+    async def get_task_actions_hydrated(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.get_task_actions_hydrated(*args, **kwargs)
+
+    async def get_tasks_actions(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.get_tasks_actions(*args, **kwargs)
+
+    async def get_action_count_for_step(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.get_action_count_for_step(*args, **kwargs)
+
+    async def get_first_step(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.get_first_step(*args, **kwargs)
+
+    async def get_latest_step(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.get_latest_step(*args, **kwargs)
+
+    async def update_step(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.update_step(*args, **kwargs)
+
+    async def clear_task_failure_reason(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.clear_task_failure_reason(*args, **kwargs)
+
+    async def update_task(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.update_task(*args, **kwargs)
+
+    async def update_task_2fa_state(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.update_task_2fa_state(*args, **kwargs)
+
+    async def bulk_update_tasks(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.bulk_update_tasks(*args, **kwargs)
+
+    async def get_tasks(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.get_tasks(*args, **kwargs)
+
+    async def get_tasks_count(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.get_tasks_count(*args, **kwargs)
+
+    async def get_running_tasks_info_globally(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.get_running_tasks_info_globally(*args, **kwargs)
+
+    async def get_latest_task_by_workflow_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.get_latest_task_by_workflow_id(*args, **kwargs)
+
+    async def get_last_task_for_workflow_run(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.get_last_task_for_workflow_run(*args, **kwargs)
+
+    async def get_tasks_by_workflow_run_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.get_tasks_by_workflow_run_id(*args, **kwargs)
+
+    async def delete_task_steps(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.delete_task_steps(*args, **kwargs)
+
+    async def get_previous_actions_for_task(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.get_previous_actions_for_task(*args, **kwargs)
+
+    async def delete_task_actions(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.tasks.delete_task_actions(*args, **kwargs)
+
+    # -- Workflow delegates --
+
+    async def create_workflow(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflows.create_workflow(*args, **kwargs)
+
+    async def soft_delete_workflow_by_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflows.soft_delete_workflow_by_id(*args, **kwargs)
+
+    async def get_workflow(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflows.get_workflow(*args, **kwargs)
+
+    async def get_workflow_by_permanent_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflows.get_workflow_by_permanent_id(*args, **kwargs)
+
+    async def get_workflow_for_workflow_run(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflows.get_workflow_for_workflow_run(*args, **kwargs)
+
+    async def get_workflow_versions_by_permanent_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflows.get_workflow_versions_by_permanent_id(*args, **kwargs)
+
+    async def get_workflows_by_permanent_ids(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflows.get_workflows_by_permanent_ids(*args, **kwargs)
+
+    async def get_workflows_by_organization_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflows.get_workflows_by_organization_id(*args, **kwargs)
+
+    async def update_workflow(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflows.update_workflow(*args, **kwargs)
+
+    async def soft_delete_workflow_and_schedules_by_permanent_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflows.soft_delete_workflow_and_schedules_by_permanent_id(*args, **kwargs)
+
+    async def add_workflow_template(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflows.add_workflow_template(*args, **kwargs)
+
+    async def remove_workflow_template(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflows.remove_workflow_template(*args, **kwargs)
+
+    async def get_org_template_permanent_ids(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflows.get_org_template_permanent_ids(*args, **kwargs)
+
+    async def is_workflow_template(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflows.is_workflow_template(*args, **kwargs)
+
+    # -- Workflow run delegates --
+
+    async def get_running_workflow_runs_info_globally(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_runs.get_running_workflow_runs_info_globally(*args, **kwargs)
+
+    async def create_workflow_run(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_runs.create_workflow_run(*args, **kwargs)
+
+    async def update_workflow_run(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_runs.update_workflow_run(*args, **kwargs)
+
+    async def bulk_update_workflow_runs(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_runs.bulk_update_workflow_runs(*args, **kwargs)
+
+    async def clear_workflow_run_failure_reason(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_runs.clear_workflow_run_failure_reason(*args, **kwargs)
+
+    async def get_all_runs(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_runs.get_all_runs(*args, **kwargs)
+
+    async def get_workflow_run(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_runs.get_workflow_run(*args, **kwargs)
+
+    async def get_last_queued_workflow_run(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_runs.get_last_queued_workflow_run(*args, **kwargs)
+
+    async def get_workflow_runs_by_ids(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_runs.get_workflow_runs_by_ids(*args, **kwargs)
+
+    async def get_last_running_workflow_run(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_runs.get_last_running_workflow_run(*args, **kwargs)
+
+    async def get_last_workflow_run_for_browser_session(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_runs.get_last_workflow_run_for_browser_session(*args, **kwargs)
+
+    async def get_last_workflow_run_for_browser_address(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_runs.get_last_workflow_run_for_browser_address(*args, **kwargs)
+
+    async def get_workflows_depending_on(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_runs.get_workflows_depending_on(*args, **kwargs)
+
+    async def get_workflow_runs(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_runs.get_workflow_runs(*args, **kwargs)
+
+    async def get_workflow_runs_count(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_runs.get_workflow_runs_count(*args, **kwargs)
+
+    async def get_workflow_runs_for_workflow_permanent_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_runs.get_workflow_runs_for_workflow_permanent_id(*args, **kwargs)
+
+    async def get_workflow_runs_by_parent_workflow_run_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_runs.get_workflow_runs_by_parent_workflow_run_id(*args, **kwargs)
+
+    async def get_workflow_run_output_parameters(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_runs.get_workflow_run_output_parameters(*args, **kwargs)
+
+    async def get_workflow_run_output_parameter_by_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_runs.get_workflow_run_output_parameter_by_id(*args, **kwargs)
+
+    async def create_or_update_workflow_run_output_parameter(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_runs.create_or_update_workflow_run_output_parameter(*args, **kwargs)
+
+    async def update_workflow_run_output_parameter(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_runs.update_workflow_run_output_parameter(*args, **kwargs)
+
+    async def create_workflow_run_parameter(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_runs.create_workflow_run_parameter(*args, **kwargs)
+
+    async def get_workflow_run_parameters(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_runs.get_workflow_run_parameters(*args, **kwargs)
+
+    async def get_workflow_run_block_errors(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_runs.get_workflow_run_block_errors(*args, **kwargs)
+
+    # -- Workflow parameter delegates --
+
+    async def create_workflow_parameter(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_params.create_workflow_parameter(*args, **kwargs)
+
+    async def create_aws_secret_parameter(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_params.create_aws_secret_parameter(*args, **kwargs)
+
+    async def create_output_parameter(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_params.create_output_parameter(*args, **kwargs)
+
+    async def save_workflow_definition_parameters(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_params.save_workflow_definition_parameters(*args, **kwargs)
+
+    async def get_workflow_output_parameters(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_params.get_workflow_output_parameters(*args, **kwargs)
+
+    async def get_workflow_output_parameters_by_ids(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_params.get_workflow_output_parameters_by_ids(*args, **kwargs)
+
+    async def get_workflow_parameters(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_params.get_workflow_parameters(*args, **kwargs)
+
+    async def get_workflow_parameter(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_params.get_workflow_parameter(*args, **kwargs)
+
+    async def create_task_generation(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_params.create_task_generation(*args, **kwargs)
+
+    async def create_ai_suggestion(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_params.create_ai_suggestion(*args, **kwargs)
+
+    async def create_workflow_copilot_chat(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_params.create_workflow_copilot_chat(*args, **kwargs)
+
+    async def update_workflow_copilot_chat(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_params.update_workflow_copilot_chat(*args, **kwargs)
+
+    async def create_workflow_copilot_chat_message(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_params.create_workflow_copilot_chat_message(*args, **kwargs)
+
+    async def get_workflow_copilot_chat_messages(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_params.get_workflow_copilot_chat_messages(*args, **kwargs)
+
+    async def get_workflow_copilot_chat_by_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_params.get_workflow_copilot_chat_by_id(*args, **kwargs)
+
+    async def get_latest_workflow_copilot_chat(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_params.get_latest_workflow_copilot_chat(*args, **kwargs)
+
+    async def get_task_generation_by_prompt_hash(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_params.get_task_generation_by_prompt_hash(*args, **kwargs)
+
+    async def create_action(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_params.create_action(*args, **kwargs)
+
+    async def update_action_reasoning(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_params.update_action_reasoning(*args, **kwargs)
+
+    async def retrieve_action_plan(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_params.retrieve_action_plan(*args, **kwargs)
+
+    async def create_task_run(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_params.create_task_run(*args, **kwargs)
+
+    async def update_task_run(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_params.update_task_run(*args, **kwargs)
+
+    async def update_job_run_compute_cost(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_params.update_job_run_compute_cost(*args, **kwargs)
+
+    async def cache_task_run(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_params.cache_task_run(*args, **kwargs)
+
+    async def get_cached_task_run(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_params.get_cached_task_run(*args, **kwargs)
+
+    async def get_run(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.workflow_params.get_run(*args, **kwargs)
+
+    # -- Artifact delegates --
+
+    async def create_artifact(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.artifacts.create_artifact(*args, **kwargs)
+
+    async def bulk_create_artifacts(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.artifacts.bulk_create_artifacts(*args, **kwargs)
+
+    async def get_artifacts_for_task_v2(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.artifacts.get_artifacts_for_task_v2(*args, **kwargs)
+
+    async def get_artifacts_for_task_step(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.artifacts.get_artifacts_for_task_step(*args, **kwargs)
+
+    async def get_artifacts_for_run(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.artifacts.get_artifacts_for_run(*args, **kwargs)
+
+    async def get_artifact_by_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.artifacts.get_artifact_by_id(*args, **kwargs)
+
+    async def get_artifacts_by_ids(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.artifacts.get_artifacts_by_ids(*args, **kwargs)
+
+    async def get_artifacts_by_entity_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.artifacts.get_artifacts_by_entity_id(*args, **kwargs)
+
+    async def get_artifact_by_entity_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.artifacts.get_artifact_by_entity_id(*args, **kwargs)
+
+    async def get_artifact(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.artifacts.get_artifact(*args, **kwargs)
+
+    async def get_artifact_for_run(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.artifacts.get_artifact_for_run(*args, **kwargs)
+
+    async def get_latest_artifact(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.artifacts.get_latest_artifact(*args, **kwargs)
+
+    async def get_latest_n_artifacts(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.artifacts.get_latest_n_artifacts(*args, **kwargs)
+
+    async def delete_task_artifacts(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.artifacts.delete_task_artifacts(*args, **kwargs)
+
+    async def delete_task_v2_artifacts(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.artifacts.delete_task_v2_artifacts(*args, **kwargs)
+
+    async def update_action_screenshot_artifact_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.artifacts.update_action_screenshot_artifact_id(*args, **kwargs)
+
+    # -- Browser session delegates --
+
+    async def create_browser_profile(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.browser_sessions.create_browser_profile(*args, **kwargs)
+
+    async def get_browser_profile(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.browser_sessions.get_browser_profile(*args, **kwargs)
+
+    async def list_browser_profiles(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.browser_sessions.list_browser_profiles(*args, **kwargs)
+
+    async def delete_browser_profile(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.browser_sessions.delete_browser_profile(*args, **kwargs)
+
+    async def get_active_persistent_browser_sessions(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.browser_sessions.get_active_persistent_browser_sessions(*args, **kwargs)
+
+    async def get_persistent_browser_sessions_history(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.browser_sessions.get_persistent_browser_sessions_history(*args, **kwargs)
+
+    async def get_persistent_browser_session_by_runnable_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.browser_sessions.get_persistent_browser_session_by_runnable_id(*args, **kwargs)
+
+    async def get_persistent_browser_session(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.browser_sessions.get_persistent_browser_session(*args, **kwargs)
+
+    async def create_persistent_browser_session(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.browser_sessions.create_persistent_browser_session(*args, **kwargs)
+
+    async def update_persistent_browser_session(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.browser_sessions.update_persistent_browser_session(*args, **kwargs)
+
+    async def set_persistent_browser_session_browser_address(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.browser_sessions.set_persistent_browser_session_browser_address(*args, **kwargs)
+
+    async def update_persistent_browser_session_compute_cost(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.browser_sessions.update_persistent_browser_session_compute_cost(*args, **kwargs)
+
+    async def mark_persistent_browser_session_deleted(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.browser_sessions.mark_persistent_browser_session_deleted(*args, **kwargs)
+
+    async def occupy_persistent_browser_session(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.browser_sessions.occupy_persistent_browser_session(*args, **kwargs)
+
+    async def release_persistent_browser_session(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.browser_sessions.release_persistent_browser_session(*args, **kwargs)
+
+    async def close_persistent_browser_session(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.browser_sessions.close_persistent_browser_session(*args, **kwargs)
+
+    async def get_all_active_persistent_browser_sessions(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.browser_sessions.get_all_active_persistent_browser_sessions(*args, **kwargs)
+
+    async def archive_browser_session_address(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.browser_sessions.archive_browser_session_address(*args, **kwargs)
+
+    async def get_uncompleted_persistent_browser_sessions(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.browser_sessions.get_uncompleted_persistent_browser_sessions(*args, **kwargs)
+
+    async def get_debug_session_by_browser_session_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.browser_sessions.get_debug_session_by_browser_session_id(*args, **kwargs)
+
+    # -- Schedule delegates --
+
+    async def create_workflow_schedule(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.schedules.create_workflow_schedule(*args, **kwargs)
+
+    async def create_workflow_schedule_with_limit(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.schedules.create_workflow_schedule_with_limit(*args, **kwargs)
+
+    async def set_temporal_schedule_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.schedules.set_temporal_schedule_id(*args, **kwargs)
+
+    async def update_workflow_schedule(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.schedules.update_workflow_schedule(*args, **kwargs)
+
+    async def get_workflow_schedule_by_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.schedules.get_workflow_schedule_by_id(*args, **kwargs)
+
+    async def get_workflow_schedules(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.schedules.get_workflow_schedules(*args, **kwargs)
+
+    async def get_all_enabled_schedules(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.schedules.get_all_enabled_schedules(*args, **kwargs)
+
+    async def has_schedule_fired_since(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.schedules.has_schedule_fired_since(*args, **kwargs)
+
+    async def update_workflow_schedule_enabled(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.schedules.update_workflow_schedule_enabled(*args, **kwargs)
+
+    async def delete_workflow_schedule(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.schedules.delete_workflow_schedule(*args, **kwargs)
+
+    async def restore_workflow_schedule(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.schedules.restore_workflow_schedule(*args, **kwargs)
+
+    async def count_workflow_schedules(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.schedules.count_workflow_schedules(*args, **kwargs)
+
+    async def list_organization_schedules(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.schedules.list_organization_schedules(*args, **kwargs)
+
+    async def soft_delete_orphaned_schedules(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.schedules.soft_delete_orphaned_schedules(*args, **kwargs)
+
+    # -- Script delegates --
+
+    async def create_script(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.create_script(*args, **kwargs)
+
+    async def get_scripts(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.get_scripts(*args, **kwargs)
+
+    async def get_script(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.get_script(*args, **kwargs)
+
+    async def get_script_revision(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.get_script_revision(*args, **kwargs)
+
+    async def get_latest_script_version(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.get_latest_script_version(*args, **kwargs)
+
+    async def get_script_versions(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.get_script_versions(*args, **kwargs)
+
+    async def get_script_version_stats(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.get_script_version_stats(*args, **kwargs)
+
+    async def soft_delete_script_by_revision(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.soft_delete_script_by_revision(*args, **kwargs)
+
+    async def create_script_file(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.create_script_file(*args, **kwargs)
+
+    async def create_script_block(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.create_script_block(*args, **kwargs)
+
+    async def update_script_block(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.update_script_block(*args, **kwargs)
+
+    async def get_script_files(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.get_script_files(*args, **kwargs)
+
+    async def get_script_file_by_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.get_script_file_by_id(*args, **kwargs)
+
+    async def get_script_file_by_path(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.get_script_file_by_path(*args, **kwargs)
+
+    async def update_script_file(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.update_script_file(*args, **kwargs)
+
+    async def get_script_block(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.get_script_block(*args, **kwargs)
+
+    async def get_script_block_by_label(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.get_script_block_by_label(*args, **kwargs)
+
+    async def get_script_blocks_by_script_revision_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.get_script_blocks_by_script_revision_id(*args, **kwargs)
+
+    async def create_workflow_script(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.create_workflow_script(*args, **kwargs)
+
+    async def get_workflow_script(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.get_workflow_script(*args, **kwargs)
+
+    async def get_workflow_script_by_cache_key_value(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.get_workflow_script_by_cache_key_value(*args, **kwargs)
+
+    async def get_workflow_cache_key_count(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.get_workflow_cache_key_count(*args, **kwargs)
+
+    async def get_workflow_cache_key_values(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.get_workflow_cache_key_values(*args, **kwargs)
+
+    async def delete_workflow_cache_key_value(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.delete_workflow_cache_key_value(*args, **kwargs)
+
+    async def delete_workflow_scripts_by_permanent_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.delete_workflow_scripts_by_permanent_id(*args, **kwargs)
+
+    async def get_workflow_scripts_by_permanent_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.get_workflow_scripts_by_permanent_id(*args, **kwargs)
+
+    async def get_workflow_runs_for_script(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.get_workflow_runs_for_script(*args, **kwargs)
+
+    async def get_script_run_stats(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.get_script_run_stats(*args, **kwargs)
+
+    async def is_script_pinned(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.is_script_pinned(*args, **kwargs)
+
+    async def pin_workflow_script(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.pin_workflow_script(*args, **kwargs)
+
+    async def unpin_workflow_script(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.unpin_workflow_script(*args, **kwargs)
+
+    async def create_fallback_episode(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.create_fallback_episode(*args, **kwargs)
+
+    async def get_unreviewed_episodes(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.get_unreviewed_episodes(*args, **kwargs)
+
+    async def update_fallback_episode(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.update_fallback_episode(*args, **kwargs)
+
+    async def delete_fallback_episode(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.delete_fallback_episode(*args, **kwargs)
+
+    async def get_fallback_episodes(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.get_fallback_episodes(*args, **kwargs)
+
+    async def get_fallback_episodes_count(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.get_fallback_episodes_count(*args, **kwargs)
+
+    async def get_fallback_episode(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.get_fallback_episode(*args, **kwargs)
+
+    async def mark_episode_reviewed(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.mark_episode_reviewed(*args, **kwargs)
+
+    async def get_recent_reviewed_episodes(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.get_recent_reviewed_episodes(*args, **kwargs)
+
+    async def record_branch_hit(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.record_branch_hit(*args, **kwargs)
+
+    async def get_stale_branches(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.scripts.get_stale_branches(*args, **kwargs)
+
+    # -- OTP delegates --
+
+    async def get_otp_codes(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.otp.get_otp_codes(*args, **kwargs)
+
+    async def get_otp_codes_by_run(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.otp.get_otp_codes_by_run(*args, **kwargs)
+
+    async def get_recent_otp_codes(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.otp.get_recent_otp_codes(*args, **kwargs)
+
+    async def create_otp_code(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.otp.create_otp_code(*args, **kwargs)
+
+    # -- Credential delegates --
+
+    async def create_credential(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.credentials.create_credential(*args, **kwargs)
+
+    async def get_credential(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.credentials.get_credential(*args, **kwargs)
+
+    async def get_credentials(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.credentials.get_credentials(*args, **kwargs)
+
+    async def update_credential(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.credentials.update_credential(*args, **kwargs)
+
+    async def update_credential_vault_data(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.credentials.update_credential_vault_data(*args, **kwargs)
+
+    async def delete_credential(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.credentials.delete_credential(*args, **kwargs)
+
+    async def create_organization_bitwarden_collection(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.credentials.create_organization_bitwarden_collection(*args, **kwargs)
+
+    async def get_organization_bitwarden_collection(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.credentials.get_organization_bitwarden_collection(*args, **kwargs)
+
+    # -- Folder delegates --
+
+    async def create_folder(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.folders.create_folder(*args, **kwargs)
+
+    async def get_folders(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.folders.get_folders(*args, **kwargs)
+
+    async def get_folder(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.folders.get_folder(*args, **kwargs)
+
+    async def update_folder(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.folders.update_folder(*args, **kwargs)
+
+    async def get_workflow_permanent_ids_in_folder(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.folders.get_workflow_permanent_ids_in_folder(*args, **kwargs)
+
+    async def soft_delete_folder(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.folders.soft_delete_folder(*args, **kwargs)
+
+    async def get_folder_workflow_count(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.folders.get_folder_workflow_count(*args, **kwargs)
+
+    async def get_folder_workflow_counts_batch(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.folders.get_folder_workflow_counts_batch(*args, **kwargs)
+
+    async def update_workflow_folder(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.folders.update_workflow_folder(*args, **kwargs)
+
+    # -- Organization delegates --
+
+    async def get_active_verification_requests(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.organizations.get_active_verification_requests(*args, **kwargs)
+
+    async def get_all_organizations(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.organizations.get_all_organizations(*args, **kwargs)
+
+    async def get_organization(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.organizations.get_organization(*args, **kwargs)
+
+    async def get_organization_by_domain(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.organizations.get_organization_by_domain(*args, **kwargs)
+
+    async def create_organization(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.organizations.create_organization(*args, **kwargs)
+
+    async def update_organization(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.organizations.update_organization(*args, **kwargs)
+
+    async def get_valid_org_auth_token(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.organizations.get_valid_org_auth_token(*args, **kwargs)
+
+    async def get_valid_org_auth_tokens(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.organizations.get_valid_org_auth_tokens(*args, **kwargs)
+
+    async def validate_org_auth_token(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.organizations.validate_org_auth_token(*args, **kwargs)
+
+    async def create_org_auth_token(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.organizations.create_org_auth_token(*args, **kwargs)
+
+    async def invalidate_org_auth_tokens(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.organizations.invalidate_org_auth_tokens(*args, **kwargs)
+
+    # -- Observer delegates --
+
+    async def get_task_v2(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.observer.get_task_v2(*args, **kwargs)
+
+    async def delete_thoughts(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.observer.delete_thoughts(*args, **kwargs)
+
+    async def get_task_v2_by_workflow_run_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.observer.get_task_v2_by_workflow_run_id(*args, **kwargs)
+
+    async def get_thought(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.observer.get_thought(*args, **kwargs)
+
+    async def get_thoughts(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.observer.get_thoughts(*args, **kwargs)
+
+    async def create_task_v2(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.observer.create_task_v2(*args, **kwargs)
+
+    async def create_thought(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.observer.create_thought(*args, **kwargs)
+
+    async def update_thought(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.observer.update_thought(*args, **kwargs)
+
+    async def update_task_v2(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.observer.update_task_v2(*args, **kwargs)
+
+    async def create_workflow_run_block(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.observer.create_workflow_run_block(*args, **kwargs)
+
+    async def delete_workflow_run_blocks(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.observer.delete_workflow_run_blocks(*args, **kwargs)
+
+    async def update_workflow_run_block(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.observer.update_workflow_run_block(*args, **kwargs)
+
+    async def get_workflow_run_block(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.observer.get_workflow_run_block(*args, **kwargs)
+
+    async def get_workflow_run_block_by_task_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.observer.get_workflow_run_block_by_task_id(*args, **kwargs)
+
+    async def get_workflow_run_blocks(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.observer.get_workflow_run_blocks(*args, **kwargs)
+
+    # -- Debug delegates --
+
+    async def get_debug_session(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.debug.get_debug_session(*args, **kwargs)
+
+    async def get_latest_block_run(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.debug.get_latest_block_run(*args, **kwargs)
+
+    async def get_latest_completed_block_run(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.debug.get_latest_completed_block_run(*args, **kwargs)
+
+    async def create_block_run(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.debug.create_block_run(*args, **kwargs)
+
+    async def get_latest_debug_session_for_user(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.debug.get_latest_debug_session_for_user(*args, **kwargs)
+
+    async def get_debug_session_by_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.debug.get_debug_session_by_id(*args, **kwargs)
+
+    async def get_workflow_runs_by_debug_session_id(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.debug.get_workflow_runs_by_debug_session_id(*args, **kwargs)
+
+    async def complete_debug_sessions(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.debug.complete_debug_sessions(*args, **kwargs)
+
+    async def create_debug_session(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.debug.create_debug_session(*args, **kwargs)
+
+    # -- NEW delegate methods (missing from branch) --
+
+    async def get_artifact_by_id_no_org(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.artifacts.get_artifact_by_id_no_org(*args, **kwargs)
+
+    async def replace_org_auth_token(self, *args: Any, **kwargs: Any) -> Any:
+        return await self.organizations.replace_org_auth_token(*args, **kwargs)
diff --git a/skyvern/forge/sdk/db/base_repository.py b/skyvern/forge/sdk/db/base_repository.py
new file mode 100644
index 000000000..3f7a0a25b
--- /dev/null
+++ b/skyvern/forge/sdk/db/base_repository.py
@@ -0,0 +1,33 @@
+"""Base class for all repository classes extracted from AgentDB mixins."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Callable
+
+from sqlalchemy.exc import SQLAlchemyError
+
+if TYPE_CHECKING:
+    from skyvern.forge.sdk.db.base_alchemy_db import _SessionFactory
+
+
+class BaseRepository:
+    """Base for domain-specific repositories.
+
+    Provides the session factory, debug flag, and retryable-error check
+    that decorators like ``read_retry`` and ``db_operation`` rely on.
+    """
+
+    def __init__(
+        self,
+        session_factory: _SessionFactory,
+        debug_enabled: bool = False,
+        is_retryable_error_fn: Callable[[SQLAlchemyError], bool] | None = None,
+    ) -> None:
+        self.Session = session_factory
+        self.debug_enabled = debug_enabled
+        self._is_retryable_error_fn = is_retryable_error_fn
+
+    def is_retryable_error(self, error: SQLAlchemyError) -> bool:
+        if self._is_retryable_error_fn:
+            return self._is_retryable_error_fn(error)
+        return False
diff --git a/skyvern/forge/sdk/db/exceptions.py b/skyvern/forge/sdk/db/exceptions.py
index c901a5c9f..e1d9bbbb9 100644
--- a/skyvern/forge/sdk/db/exceptions.py
+++ b/skyvern/forge/sdk/db/exceptions.py
@@ -1,2 +1,13 @@
 class NotFoundError(Exception):
     pass
+
+
+class ScheduleLimitExceededError(Exception):
+    """Raised when attempting to create a schedule that would exceed the per-workflow limit."""
+
+    def __init__(self, organization_id: str, workflow_permanent_id: str, current_count: int, max_allowed: int):
+        self.organization_id = organization_id
+        self.workflow_permanent_id = workflow_permanent_id
+        self.current_count = current_count
+        self.max_allowed = max_allowed
+        super().__init__(f"Schedule limit {max_allowed} reached (current: {current_count})")
diff --git a/skyvern/forge/sdk/db/mixins/__init__.py b/skyvern/forge/sdk/db/mixins/__init__.py
index 37b163b9f..cdff30a18 100644
--- a/skyvern/forge/sdk/db/mixins/__init__.py
+++ b/skyvern/forge/sdk/db/mixins/__init__.py
@@ -1,3 +1,8 @@
+# DEPRECATED: These mixin classes have been superseded by the repository pattern
+# in skyvern/forge/sdk/db/repositories/. AgentDB no longer inherits from these
+# mixins — it composes repository instances instead. These files are retained
+# temporarily to avoid breaking any downstream code that may import from here.
+# TODO(SKY-62): Remove after 2026-Q2 once all imports are verified migrated.
 from skyvern.forge.sdk.db.mixins.artifacts import ArtifactsMixin
 from skyvern.forge.sdk.db.mixins.base import BaseAlchemyDB, read_retry
 from skyvern.forge.sdk.db.mixins.browser_sessions import BrowserSessionsMixin
diff --git a/skyvern/forge/sdk/db/mixins/schedules.py b/skyvern/forge/sdk/db/mixins/schedules.py
index d7db4cb0e..fcc382edd 100644
--- a/skyvern/forge/sdk/db/mixins/schedules.py
+++ b/skyvern/forge/sdk/db/mixins/schedules.py
@@ -7,7 +7,8 @@ from typing import TYPE_CHECKING, Any
 import structlog
 from sqlalchemy import func, or_, select, text, update
 
-from skyvern.forge.sdk.db._error_handling import db_operation, register_passthrough_exception
+from skyvern.forge.sdk.db._error_handling import db_operation
+from skyvern.forge.sdk.db.exceptions import ScheduleLimitExceededError
 from skyvern.forge.sdk.db.models import (
     WorkflowModel,
     WorkflowRunModel,
@@ -26,20 +27,6 @@ LOG = structlog.get_logger()
 _UNSET = object()
 
 
-class ScheduleLimitExceededError(Exception):
-    """Raised when attempting to create a schedule that would exceed the per-workflow limit."""
-
-    def __init__(self, organization_id: str, workflow_permanent_id: str, current_count: int, max_allowed: int):
-        self.organization_id = organization_id
-        self.workflow_permanent_id = workflow_permanent_id
-        self.current_count = current_count
-        self.max_allowed = max_allowed
-        super().__init__(f"Schedule limit {max_allowed} reached (current: {current_count})")
-
-
-register_passthrough_exception(ScheduleLimitExceededError)
-
-
 class SchedulesMixin:
     """Database operations for workflow schedules."""
 
diff --git a/skyvern/forge/sdk/db/protocols.py b/skyvern/forge/sdk/db/protocols.py
new file mode 100644
index 000000000..43fedb192
--- /dev/null
+++ b/skyvern/forge/sdk/db/protocols.py
@@ -0,0 +1,42 @@
+"""Typed Protocol contracts for cross-repository dependencies."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Protocol, runtime_checkable
+
+if TYPE_CHECKING:
+    from skyvern.forge.sdk.schemas.tasks import Task
+    from skyvern.forge.sdk.workflow.models.parameter import WorkflowParameter
+    from skyvern.forge.sdk.workflow.models.workflow import Workflow, WorkflowRun
+
+
+@runtime_checkable
+class TaskReader(Protocol):
+    async def get_task(self, task_id: str, organization_id: str | None = None) -> Task | None: ...
+    async def get_tasks_by_workflow_run_id(self, workflow_run_id: str) -> list[Task]: ...
+
+
+@runtime_checkable
+class WorkflowReader(Protocol):
+    async def get_workflow_by_permanent_id(
+        self,
+        workflow_permanent_id: str,
+        organization_id: str | None = None,
+        version: int | None = None,
+        ignore_version: int | None = None,
+        filter_deleted: bool = True,
+    ) -> Workflow | None: ...
+
+
+@runtime_checkable
+class WorkflowParameterReader(Protocol):
+    async def get_workflow_parameter(
+        self,
+        workflow_parameter_id: str,
+        organization_id: str | None = None,
+    ) -> WorkflowParameter | None: ...
+
+
+@runtime_checkable
+class RunReader(Protocol):
+    async def get_run(self, run_id: str, organization_id: str | None = None) -> WorkflowRun | None: ...
diff --git a/skyvern/forge/sdk/db/repositories/__init__.py b/skyvern/forge/sdk/db/repositories/__init__.py
new file mode 100644
index 000000000..b2f630134
--- /dev/null
+++ b/skyvern/forge/sdk/db/repositories/__init__.py
@@ -0,0 +1,4 @@
+"""Domain-specific repository classes extracted from AgentDB mixins."""
+
+# Sentinel for distinguishing "not passed" from "passed as None" in update methods.
+_UNSET = object()
diff --git a/skyvern/forge/sdk/db/repositories/artifacts.py b/skyvern/forge/sdk/db/repositories/artifacts.py
new file mode 100644
index 000000000..488723b86
--- /dev/null
+++ b/skyvern/forge/sdk/db/repositories/artifacts.py
@@ -0,0 +1,452 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Callable
+
+import structlog
+from sqlalchemy import and_, delete, or_, select, update
+from sqlalchemy.exc import SQLAlchemyError
+
+from skyvern.forge.sdk.artifact.models import Artifact, ArtifactType
+from skyvern.forge.sdk.db._error_handling import db_operation
+from skyvern.forge.sdk.db.base_repository import BaseRepository
+from skyvern.forge.sdk.db.models import ActionModel, ArtifactModel
+from skyvern.forge.sdk.db.protocols import RunReader
+from skyvern.forge.sdk.db.utils import convert_to_artifact
+
+if TYPE_CHECKING:
+    from skyvern.forge.sdk.db.base_alchemy_db import _SessionFactory
+
+LOG = structlog.get_logger()
+
+
+class ArtifactsRepository(BaseRepository):
+    """Database operations for artifact management."""
+
+    def __init__(
+        self,
+        session_factory: _SessionFactory,
+        debug_enabled: bool = False,
+        is_retryable_error_fn: Callable[[SQLAlchemyError], bool] | None = None,
+        run_reader: RunReader | None = None,
+    ) -> None:
+        super().__init__(session_factory, debug_enabled, is_retryable_error_fn)
+        self._run_reader = run_reader
+
+    @db_operation("create_artifact")
+    async def create_artifact(
+        self,
+        artifact_id: str,
+        artifact_type: str,
+        uri: str,
+        organization_id: str,
+        step_id: str | None = None,
+        task_id: str | None = None,
+        workflow_run_id: str | None = None,
+        workflow_run_block_id: str | None = None,
+        task_v2_id: str | None = None,
+        run_id: str | None = None,
+        thought_id: str | None = None,
+        ai_suggestion_id: str | None = None,
+    ) -> Artifact:
+        async with self.Session() as session:
+            new_artifact = ArtifactModel(
+                artifact_id=artifact_id,
+                artifact_type=artifact_type,
+                uri=uri,
+                task_id=task_id,
+                step_id=step_id,
+                workflow_run_id=workflow_run_id,
+                workflow_run_block_id=workflow_run_block_id,
+                observer_cruise_id=task_v2_id,
+                observer_thought_id=thought_id,
+                run_id=run_id,
+                ai_suggestion_id=ai_suggestion_id,
+                organization_id=organization_id,
+            )
+            session.add(new_artifact)
+            await session.commit()
+            await session.refresh(new_artifact)
+            return convert_to_artifact(new_artifact, self.debug_enabled)
+
+    @db_operation("bulk_create_artifacts")
+    async def bulk_create_artifacts(
+        self,
+        artifact_models: list[ArtifactModel],
+    ) -> list[Artifact]:
+        """
+        Bulk create multiple artifacts in a single database transaction.
+
+        Args:
+            artifact_models: List of ArtifactModel instances to insert
+
+        Returns:
+            List of created Artifact objects
+        """
+        if not artifact_models:
+            return []
+
+        async with self.Session() as session:
+            session.add_all(artifact_models)
+            await session.commit()
+
+            # Refresh all artifacts to get their created_at and modified_at values
+            for artifact in artifact_models:
+                await session.refresh(artifact)
+
+            return [convert_to_artifact(artifact, self.debug_enabled) for artifact in artifact_models]
+
+    @db_operation("get_artifacts_for_task_v2")
+    async def get_artifacts_for_task_v2(
+        self,
+        task_v2_id: str,
+        organization_id: str | None = None,
+        artifact_types: list[ArtifactType] | None = None,
+    ) -> list[Artifact]:
+        async with self.Session() as session:
+            query = (
+                select(ArtifactModel)
+                .filter_by(observer_cruise_id=task_v2_id)
+                .filter_by(organization_id=organization_id)
+            )
+            if artifact_types:
+                query = query.filter(ArtifactModel.artifact_type.in_(artifact_types))
+
+            query = query.order_by(ArtifactModel.created_at)
+            if artifacts := (await session.scalars(query)).all():
+                return [convert_to_artifact(artifact, self.debug_enabled) for artifact in artifacts]
+            else:
+                return []
+
+    @db_operation("get_artifacts_for_task_step")
+    async def get_artifacts_for_task_step(
+        self,
+        task_id: str,
+        step_id: str,
+        organization_id: str | None = None,
+    ) -> list[Artifact]:
+        async with self.Session() as session:
+            if artifacts := (
+                await session.scalars(
+                    select(ArtifactModel)
+                    .filter_by(task_id=task_id)
+                    .filter_by(step_id=step_id)
+                    .filter_by(organization_id=organization_id)
+                    .order_by(ArtifactModel.created_at)
+                )
+            ).all():
+                return [convert_to_artifact(artifact, self.debug_enabled) for artifact in artifacts]
+            else:
+                return []
+
+    @db_operation("get_artifacts_for_run")
+    async def get_artifacts_for_run(
+        self,
+        run_id: str,
+        organization_id: str,
+        artifact_types: list[ArtifactType] | None = None,
+        group_by_type: bool = False,
+        sort_by: str = "created_at",
+    ) -> dict[ArtifactType, list[Artifact]] | list[Artifact]:
+        """Return artifacts associated with a run.
+
+        Args:
+            run_id: The ID of the run to get artifacts for
+            organization_id: The ID of the organization that owns the run
+            artifact_types: Optional list of artifact types to filter by
+            group_by_type: If True, returns a dictionary mapping artifact types to lists of artifacts.
+                         If False, returns a flat list of artifacts. Defaults to False.
+            sort_by: Field to sort artifacts by. Must be one of: 'created_at', 'step_id', 'task_id'.
+                   Defaults to 'created_at'.
+
+        Returns:
+            If group_by_type is True, returns a dictionary mapping artifact types to lists of artifacts.
+            If group_by_type is False, returns a list of artifacts sorted by the specified field.
+
+        Raises:
+            ValueError: If sort_by is not one of the allowed values
+        """
+        allowed_sort_fields = {"created_at", "step_id", "task_id"}
+        if sort_by not in allowed_sort_fields:
+            raise ValueError(f"sort_by must be one of {allowed_sort_fields}")
+        if self._run_reader is None:
+            raise RuntimeError("run_reader dependency not set")
+        run = await self._run_reader.get_run(run_id, organization_id=organization_id)
+        if not run:
+            return []
+
+        async with self.Session() as session:
+            query = select(ArtifactModel).filter_by(organization_id=organization_id)
+
+            query = query.filter_by(run_id=run.run_id)
+
+            if artifact_types:
+                query = query.filter(ArtifactModel.artifact_type.in_(artifact_types))
+
+            # Apply sorting
+            if sort_by == "created_at":
+                query = query.order_by(ArtifactModel.created_at)
+            elif sort_by == "step_id":
+                query = query.order_by(ArtifactModel.step_id, ArtifactModel.created_at)
+            elif sort_by == "task_id":
+                query = query.order_by(ArtifactModel.task_id, ArtifactModel.created_at)
+
+            # Execute query and convert to Artifact objects
+            artifacts = [
+                convert_to_artifact(artifact, self.debug_enabled) for artifact in (await session.scalars(query)).all()
+            ]
+
+            # Group artifacts by type if requested
+            if group_by_type:
+                result: dict[ArtifactType, list[Artifact]] = {}
+                for artifact in artifacts:
+                    if artifact.artifact_type not in result:
+                        result[artifact.artifact_type] = []
+                    result[artifact.artifact_type].append(artifact)
+                return result
+
+            return artifacts
+
+    @db_operation("get_artifact_by_id")
+    async def get_artifact_by_id(
+        self,
+        artifact_id: str,
+        organization_id: str,
+    ) -> Artifact | None:
+        async with self.Session() as session:
+            if artifact := (
+                await session.scalars(
+                    select(ArtifactModel).filter_by(artifact_id=artifact_id).filter_by(organization_id=organization_id)
+                )
+            ).first():
+                return convert_to_artifact(artifact, self.debug_enabled)
+            else:
+                return None
+
+    async def get_artifact_by_id_no_org(
+        self,
+        artifact_id: str,
+    ) -> Artifact | None:
+        """Fetch an artifact by ID without an organization filter.
+
+        Only use this when the caller has already verified authorization through
+        an out-of-band mechanism (e.g. a valid HMAC-signed URL).
+        """
+        async with self.Session() as session:
+            if artifact := (await session.scalars(select(ArtifactModel).filter_by(artifact_id=artifact_id))).first():
+                return convert_to_artifact(artifact, self.debug_enabled)
+            else:
+                return None
+
+    @db_operation("get_artifacts_by_ids")
+    async def get_artifacts_by_ids(
+        self,
+        artifact_ids: list[str],
+        organization_id: str,
+    ) -> list[Artifact]:
+        if not artifact_ids:
+            return []
+        async with self.Session() as session:
+            artifacts = (
+                await session.scalars(
+                    select(ArtifactModel)
+                    .filter(ArtifactModel.artifact_id.in_(artifact_ids))
+                    .filter_by(organization_id=organization_id)
+                )
+            ).all()
+            return [convert_to_artifact(artifact, self.debug_enabled) for artifact in artifacts]
+
+    @db_operation("get_artifacts_by_entity_id")
+    async def get_artifacts_by_entity_id(
+        self,
+        *,
+        organization_id: str | None,
+        artifact_type: ArtifactType | None = None,
+        task_id: str | None = None,
+        step_id: str | None = None,
+        workflow_run_id: str | None = None,
+        workflow_run_block_id: str | None = None,
+        thought_id: str | None = None,
+        task_v2_id: str | None = None,
+        limit: int | None = None,
+    ) -> list[Artifact]:
+        async with self.Session() as session:
+            # Build base query
+            query = select(ArtifactModel)
+
+            if artifact_type is not None:
+                query = query.filter_by(artifact_type=artifact_type)
+            if task_id is not None:
+                query = query.filter_by(task_id=task_id)
+            if step_id is not None:
+                query = query.filter_by(step_id=step_id)
+            if workflow_run_id is not None:
+                query = query.filter_by(workflow_run_id=workflow_run_id)
+            if workflow_run_block_id is not None:
+                query = query.filter_by(workflow_run_block_id=workflow_run_block_id)
+            if thought_id is not None:
+                query = query.filter_by(observer_thought_id=thought_id)
+            if task_v2_id is not None:
+                query = query.filter_by(observer_cruise_id=task_v2_id)
+            # Handle backward compatibility where old artifact rows were stored with organization_id NULL
+            if organization_id is not None:
+                query = query.filter(
+                    or_(ArtifactModel.organization_id == organization_id, ArtifactModel.organization_id.is_(None))
+                )
+
+            query = query.order_by(ArtifactModel.created_at.desc())
+
+            if limit is not None:
+                query = query.limit(limit)
+
+            artifacts = (await session.scalars(query)).all()
+            LOG.debug("Artifacts fetched", count=len(artifacts))
+            return [convert_to_artifact(a, self.debug_enabled) for a in artifacts]
+
+    @db_operation("get_artifact_by_entity_id")
+    async def get_artifact_by_entity_id(
+        self,
+        *,
+        artifact_type: ArtifactType,
+        organization_id: str,
+        task_id: str | None = None,
+        step_id: str | None = None,
+        workflow_run_id: str | None = None,
+        workflow_run_block_id: str | None = None,
+        thought_id: str | None = None,
+        task_v2_id: str | None = None,
+    ) -> Artifact | None:
+        artifacts = await self.get_artifacts_by_entity_id(
+            organization_id=organization_id,
+            artifact_type=artifact_type,
+            task_id=task_id,
+            step_id=step_id,
+            workflow_run_id=workflow_run_id,
+            workflow_run_block_id=workflow_run_block_id,
+            thought_id=thought_id,
+            task_v2_id=task_v2_id,
+            limit=1,
+        )
+        return artifacts[0] if artifacts else None
+
+    @db_operation("get_artifact")
+    async def get_artifact(
+        self,
+        task_id: str,
+        step_id: str,
+        artifact_type: ArtifactType,
+        organization_id: str | None = None,
+    ) -> Artifact | None:
+        async with self.Session() as session:
+            artifact = (
+                await session.scalars(
+                    select(ArtifactModel)
+                    .filter_by(task_id=task_id)
+                    .filter_by(step_id=step_id)
+                    .filter_by(organization_id=organization_id)
+                    .filter_by(artifact_type=artifact_type)
+                    .order_by(ArtifactModel.created_at.desc())
+                )
+            ).first()
+            if artifact:
+                return convert_to_artifact(artifact, self.debug_enabled)
+            return None
+
+    @db_operation("get_artifact_for_run")
+    async def get_artifact_for_run(
+        self,
+        run_id: str,
+        artifact_type: ArtifactType,
+        organization_id: str | None = None,
+    ) -> Artifact | None:
+        async with self.Session() as session:
+            artifact = (
+                await session.scalars(
+                    select(ArtifactModel)
+                    .filter(ArtifactModel.run_id == run_id)
+                    .filter(ArtifactModel.artifact_type == artifact_type)
+                    .filter(ArtifactModel.organization_id == organization_id)
+                    .order_by(ArtifactModel.created_at.desc())
+                )
+            ).first()
+            if artifact:
+                return convert_to_artifact(artifact, self.debug_enabled)
+            return None
+
+    @db_operation("get_latest_artifact")
+    async def get_latest_artifact(
+        self,
+        task_id: str,
+        step_id: str | None = None,
+        artifact_types: list[ArtifactType] | None = None,
+        organization_id: str | None = None,
+    ) -> Artifact | None:
+        artifacts = await self.get_latest_n_artifacts(
+            task_id=task_id,
+            step_id=step_id,
+            artifact_types=artifact_types,
+            organization_id=organization_id,
+            n=1,
+        )
+        if artifacts:
+            return artifacts[0]
+        return None
+
+    @db_operation("get_latest_n_artifacts")
+    async def get_latest_n_artifacts(
+        self,
+        task_id: str,
+        step_id: str | None = None,
+        artifact_types: list[ArtifactType] | None = None,
+        organization_id: str | None = None,
+        n: int = 1,
+    ) -> list[Artifact] | None:
+        async with self.Session() as session:
+            artifact_query = select(ArtifactModel).filter_by(task_id=task_id)
+            if organization_id:
+                artifact_query = artifact_query.filter_by(organization_id=organization_id)
+            if step_id:
+                artifact_query = artifact_query.filter_by(step_id=step_id)
+            if artifact_types:
+                artifact_query = artifact_query.filter(ArtifactModel.artifact_type.in_(artifact_types))
+
+            artifacts = (await session.scalars(artifact_query.order_by(ArtifactModel.created_at.desc()))).fetchmany(n)
+            if artifacts:
+                return [convert_to_artifact(artifact, self.debug_enabled) for artifact in artifacts]
+            return None
+
+    @db_operation("delete_task_artifacts")
+    async def delete_task_artifacts(self, organization_id: str, task_id: str) -> None:
+        async with self.Session() as session:
+            # delete artifacts by filtering organization_id and task_id
+            stmt = delete(ArtifactModel).where(
+                and_(
+                    ArtifactModel.organization_id == organization_id,
+                    ArtifactModel.task_id == task_id,
+                )
+            )
+            await session.execute(stmt)
+            await session.commit()
+
+    @db_operation("delete_task_v2_artifacts")
+    async def delete_task_v2_artifacts(self, task_v2_id: str, organization_id: str | None = None) -> None:
+        async with self.Session() as session:
+            stmt = delete(ArtifactModel).where(
+                and_(
+                    ArtifactModel.observer_cruise_id == task_v2_id,
+                    ArtifactModel.organization_id == organization_id,
+                )
+            )
+            await session.execute(stmt)
+            await session.commit()
+
+    @db_operation("update_action_screenshot_artifact_id")
+    async def update_action_screenshot_artifact_id(
+        self, *, organization_id: str, action_id: str, screenshot_artifact_id: str
+    ) -> None:
+        async with self.Session() as session:
+            await session.execute(
+                update(ActionModel)
+                .where(ActionModel.action_id == action_id, ActionModel.organization_id == organization_id)
+                .values(screenshot_artifact_id=screenshot_artifact_id)
+            )
+            await session.commit()
diff --git a/skyvern/forge/sdk/db/repositories/browser_sessions.py b/skyvern/forge/sdk/db/repositories/browser_sessions.py
new file mode 100644
index 000000000..7af27782c
--- /dev/null
+++ b/skyvern/forge/sdk/db/repositories/browser_sessions.py
@@ -0,0 +1,472 @@
+from __future__ import annotations
+
+import uuid
+from datetime import datetime, timedelta, timezone
+
+import structlog
+from sqlalchemy import asc, case, select
+
+from skyvern.exceptions import BrowserProfileNotFound
+from skyvern.forge.sdk.db._error_handling import db_operation
+from skyvern.forge.sdk.db.base_alchemy_db import read_retry
+from skyvern.forge.sdk.db.base_repository import BaseRepository
+from skyvern.forge.sdk.db.exceptions import NotFoundError
+from skyvern.forge.sdk.db.models import (
+    BrowserProfileModel,
+    DebugSessionModel,
+    PersistentBrowserSessionModel,
+)
+from skyvern.forge.sdk.db.utils import serialize_proxy_location
+from skyvern.forge.sdk.schemas.browser_profiles import BrowserProfile
+from skyvern.forge.sdk.schemas.debug_sessions import DebugSession
+from skyvern.forge.sdk.schemas.persistent_browser_sessions import (
+    Extensions,
+    PersistentBrowserSession,
+    PersistentBrowserType,
+)
+from skyvern.schemas.runs import ProxyLocation, ProxyLocationInput
+
+LOG = structlog.get_logger()
+
+
+class BrowserSessionsRepository(BaseRepository):
+    """Database operations for browser profiles and persistent browser sessions."""
+
+    @db_operation("create_browser_profile")
+    async def create_browser_profile(
+        self,
+        organization_id: str,
+        name: str,
+        description: str | None = None,
+    ) -> BrowserProfile:
+        async with self.Session() as session:
+            browser_profile = BrowserProfileModel(
+                organization_id=organization_id,
+                name=name,
+                description=description,
+            )
+            session.add(browser_profile)
+            await session.commit()
+            await session.refresh(browser_profile)
+            return BrowserProfile.model_validate(browser_profile)
+
+    @db_operation("get_browser_profile")
+    async def get_browser_profile(
+        self,
+        profile_id: str,
+        organization_id: str,
+        include_deleted: bool = False,
+    ) -> BrowserProfile | None:
+        async with self.Session() as session:
+            query = (
+                select(BrowserProfileModel)
+                .filter_by(browser_profile_id=profile_id)
+                .filter_by(organization_id=organization_id)
+            )
+            if not include_deleted:
+                query = query.filter(BrowserProfileModel.deleted_at.is_(None))
+
+            browser_profile = (await session.scalars(query)).first()
+            if not browser_profile:
+                return None
+            return BrowserProfile.model_validate(browser_profile)
+
+    @db_operation("list_browser_profiles")
+    async def list_browser_profiles(
+        self,
+        organization_id: str,
+        include_deleted: bool = False,
+    ) -> list[BrowserProfile]:
+        async with self.Session() as session:
+            query = select(BrowserProfileModel).filter_by(organization_id=organization_id)
+            if not include_deleted:
+                query = query.filter(BrowserProfileModel.deleted_at.is_(None))
+            browser_profiles = await session.scalars(query.order_by(asc(BrowserProfileModel.created_at)))
+            return [BrowserProfile.model_validate(profile) for profile in browser_profiles.all()]
+
+    @db_operation("delete_browser_profile")
+    async def delete_browser_profile(
+        self,
+        profile_id: str,
+        organization_id: str,
+    ) -> None:
+        async with self.Session() as session:
+            query = (
+                select(BrowserProfileModel)
+                .filter_by(browser_profile_id=profile_id)
+                .filter_by(organization_id=organization_id)
+                .filter(BrowserProfileModel.deleted_at.is_(None))
+            )
+            browser_profile = (await session.scalars(query)).first()
+            if not browser_profile:
+                raise BrowserProfileNotFound(profile_id=profile_id, organization_id=organization_id)
+            browser_profile.deleted_at = datetime.now(timezone.utc)
+            await session.commit()
+
+    @db_operation("get_active_persistent_browser_sessions")
+    async def get_active_persistent_browser_sessions(
+        self,
+        organization_id: str,
+        active_hours: int = 24,
+    ) -> list[PersistentBrowserSession]:
+        """Get all active persistent browser sessions for an organization."""
+        async with self.Session() as session:
+            result = await session.execute(
+                select(PersistentBrowserSessionModel)
+                .filter_by(organization_id=organization_id)
+                .filter_by(deleted_at=None)
+                .filter_by(completed_at=None)
+                .filter(
+                    PersistentBrowserSessionModel.created_at
+                    > datetime.now(timezone.utc) - timedelta(hours=active_hours)
+                )
+            )
+            sessions = result.scalars().all()
+            return [PersistentBrowserSession.model_validate(session) for session in sessions]
+
+    @db_operation("get_persistent_browser_sessions_history")
+    async def get_persistent_browser_sessions_history(
+        self,
+        organization_id: str,
+        page: int = 1,
+        page_size: int = 10,
+        lookback_hours: int = 24 * 7,
+    ) -> list[PersistentBrowserSession]:
+        """Get persistent browser sessions history for an organization."""
+        async with self.Session() as session:
+            open_first = case(
+                (
+                    PersistentBrowserSessionModel.status == "running",
+                    0,  # open
+                ),
+                else_=1,  # not open
+            )
+
+            result = await session.execute(
+                select(PersistentBrowserSessionModel)
+                .filter_by(organization_id=organization_id)
+                .filter_by(deleted_at=None)
+                .filter(
+                    PersistentBrowserSessionModel.created_at
+                    > (datetime.now(timezone.utc) - timedelta(hours=lookback_hours))
+                )
+                .order_by(
+                    open_first.asc(),  # open sessions first
+                    PersistentBrowserSessionModel.created_at.desc(),  # then newest within each group
+                )
+                .offset((page - 1) * page_size)
+                .limit(page_size)
+            )
+            sessions = result.scalars().all()
+            return [PersistentBrowserSession.model_validate(session) for session in sessions]
+
+    @read_retry()
+    @db_operation("get_persistent_browser_session_by_runnable_id", log_errors=False)
+    async def get_persistent_browser_session_by_runnable_id(
+        self, runnable_id: str, organization_id: str | None = None
+    ) -> PersistentBrowserSession | None:
+        """Get a specific persistent browser session."""
+        async with self.Session() as session:
+            query = (
+                select(PersistentBrowserSessionModel)
+                .filter_by(runnable_id=runnable_id)
+                .filter_by(deleted_at=None)
+                .filter_by(completed_at=None)
+            )
+            if organization_id:
+                query = query.filter_by(organization_id=organization_id)
+            persistent_browser_session = (await session.scalars(query)).first()
+            if persistent_browser_session:
+                return PersistentBrowserSession.model_validate(persistent_browser_session)
+            return None
+
+    @db_operation("get_persistent_browser_session")
+    async def get_persistent_browser_session(
+        self,
+        session_id: str,
+        organization_id: str | None = None,
+    ) -> PersistentBrowserSession | None:
+        """Get a specific persistent browser session."""
+        async with self.Session() as session:
+            persistent_browser_session = (
+                await session.scalars(
+                    select(PersistentBrowserSessionModel)
+                    .filter_by(persistent_browser_session_id=session_id)
+                    .filter_by(organization_id=organization_id)
+                    .filter_by(deleted_at=None)
+                )
+            ).first()
+            if persistent_browser_session:
+                return PersistentBrowserSession.model_validate(persistent_browser_session)
+            return None
+
+    @db_operation("create_persistent_browser_session")
+    async def create_persistent_browser_session(
+        self,
+        organization_id: str,
+        runnable_type: str | None = None,
+        runnable_id: str | None = None,
+        timeout_minutes: int | None = None,
+        proxy_location: ProxyLocationInput = ProxyLocation.RESIDENTIAL,
+        extensions: list[Extensions] | None = None,
+        browser_type: PersistentBrowserType | None = None,
+        browser_profile_id: str | None = None,
+    ) -> PersistentBrowserSession:
+        """Create a new persistent browser session."""
+        extensions_str: list[str] | None = (
+            [extension.value for extension in extensions] if extensions is not None else None
+        )
+        async with self.Session() as session:
+            browser_session = PersistentBrowserSessionModel(
+                organization_id=organization_id,
+                runnable_type=runnable_type,
+                runnable_id=runnable_id,
+                timeout_minutes=timeout_minutes,
+                proxy_location=serialize_proxy_location(proxy_location),
+                extensions=extensions_str,
+                browser_type=browser_type.value if browser_type else None,
+                browser_profile_id=browser_profile_id,
+            )
+            session.add(browser_session)
+            await session.commit()
+            await session.refresh(browser_session)
+            return PersistentBrowserSession.model_validate(browser_session)
+
+    @db_operation("update_persistent_browser_session")
+    async def update_persistent_browser_session(
+        self,
+        browser_session_id: str,
+        *,
+        status: str | None = None,
+        timeout_minutes: int | None = None,
+        organization_id: str | None = None,
+        completed_at: datetime | None = None,
+    ) -> PersistentBrowserSession:
+        async with self.Session() as session:
+            persistent_browser_session = (
+                await session.scalars(
+                    select(PersistentBrowserSessionModel)
+                    .filter_by(persistent_browser_session_id=browser_session_id)
+                    .filter_by(organization_id=organization_id)
+                    .filter_by(deleted_at=None)
+                )
+            ).first()
+            if not persistent_browser_session:
+                raise NotFoundError(f"PersistentBrowserSession {browser_session_id} not found")
+
+            if status:
+                persistent_browser_session.status = status
+            if timeout_minutes:
+                persistent_browser_session.timeout_minutes = timeout_minutes
+            if completed_at:
+                persistent_browser_session.completed_at = completed_at
+
+            await session.commit()
+            await session.refresh(persistent_browser_session)
+            return PersistentBrowserSession.model_validate(persistent_browser_session)
+
+    @db_operation("set_persistent_browser_session_browser_address")
+    async def set_persistent_browser_session_browser_address(
+        self,
+        browser_session_id: str,
+        browser_address: str | None,
+        ip_address: str | None,
+        ecs_task_arn: str | None,
+        organization_id: str | None = None,
+    ) -> None:
+        """Set the browser address for a persistent browser session."""
+        async with self.Session() as session:
+            persistent_browser_session = (
+                await session.scalars(
+                    select(PersistentBrowserSessionModel)
+                    .filter_by(persistent_browser_session_id=browser_session_id)
+                    .filter_by(organization_id=organization_id)
+                    .filter_by(deleted_at=None)
+                )
+            ).first()
+            if persistent_browser_session:
+                if browser_address:
+                    persistent_browser_session.browser_address = browser_address
+                    # once the address is set, the session is started
+                    persistent_browser_session.started_at = datetime.now(timezone.utc)
+                if ip_address:
+                    persistent_browser_session.ip_address = ip_address
+                if ecs_task_arn:
+                    persistent_browser_session.ecs_task_arn = ecs_task_arn
+                await session.commit()
+                await session.refresh(persistent_browser_session)
+            else:
+                raise NotFoundError(f"PersistentBrowserSession {browser_session_id} not found")
+
+    @db_operation("update_persistent_browser_session_compute_cost")
+    async def update_persistent_browser_session_compute_cost(
+        self,
+        session_id: str,
+        organization_id: str,
+        instance_type: str,
+        vcpu_millicores: int,
+        memory_mb: int,
+        duration_ms: int,
+        compute_cost: float,
+    ) -> None:
+        """Update the compute cost fields for a persistent browser session"""
+        async with self.Session() as session:
+            persistent_browser_session = (
+                await session.scalars(
+                    select(PersistentBrowserSessionModel)
+                    .filter_by(persistent_browser_session_id=session_id)
+                    .filter_by(organization_id=organization_id)
+                    .filter_by(deleted_at=None)
+                )
+            ).first()
+            if persistent_browser_session:
+                persistent_browser_session.instance_type = instance_type
+                persistent_browser_session.vcpu_millicores = vcpu_millicores
+                persistent_browser_session.memory_mb = memory_mb
+                persistent_browser_session.duration_ms = duration_ms
+                persistent_browser_session.compute_cost = compute_cost
+                await session.commit()
+                await session.refresh(persistent_browser_session)
+            else:
+                raise NotFoundError(f"PersistentBrowserSession {session_id} not found")
+
+    @db_operation("mark_persistent_browser_session_deleted")
+    async def mark_persistent_browser_session_deleted(self, session_id: str, organization_id: str) -> None:
+        """Mark a persistent browser session as deleted."""
+        async with self.Session() as session:
+            persistent_browser_session = (
+                await session.scalars(
+                    select(PersistentBrowserSessionModel)
+                    .filter_by(persistent_browser_session_id=session_id)
+                    .filter_by(organization_id=organization_id)
+                )
+            ).first()
+            if persistent_browser_session:
+                persistent_browser_session.deleted_at = datetime.now(timezone.utc)
+                await session.commit()
+                await session.refresh(persistent_browser_session)
+            else:
+                raise NotFoundError(f"PersistentBrowserSession {session_id} not found")
+
+    @db_operation("occupy_persistent_browser_session")
+    async def occupy_persistent_browser_session(
+        self, session_id: str, runnable_type: str, runnable_id: str, organization_id: str
+    ) -> None:
+        """Occupy a specific persistent browser session."""
+        async with self.Session() as session:
+            persistent_browser_session = (
+                await session.scalars(
+                    select(PersistentBrowserSessionModel)
+                    .filter_by(persistent_browser_session_id=session_id)
+                    .filter_by(organization_id=organization_id)
+                    .filter_by(deleted_at=None)
+                )
+            ).first()
+            if persistent_browser_session:
+                persistent_browser_session.runnable_type = runnable_type
+                persistent_browser_session.runnable_id = runnable_id
+                await session.commit()
+                await session.refresh(persistent_browser_session)
+            else:
+                raise NotFoundError(f"PersistentBrowserSession {session_id} not found")
+
+    @db_operation("release_persistent_browser_session")
+    async def release_persistent_browser_session(
+        self,
+        session_id: str,
+        organization_id: str,
+    ) -> PersistentBrowserSession:
+        """Release a specific persistent browser session."""
+        async with self.Session() as session:
+            persistent_browser_session = (
+                await session.scalars(
+                    select(PersistentBrowserSessionModel)
+                    .filter_by(persistent_browser_session_id=session_id)
+                    .filter_by(organization_id=organization_id)
+                    .filter_by(deleted_at=None)
+                )
+            ).first()
+            if persistent_browser_session:
+                persistent_browser_session.runnable_type = None
+                persistent_browser_session.runnable_id = None
+                await session.commit()
+                await session.refresh(persistent_browser_session)
+                return PersistentBrowserSession.model_validate(persistent_browser_session)
+            else:
+                raise NotFoundError(f"PersistentBrowserSession {session_id} not found")
+
+    @db_operation("close_persistent_browser_session")
+    async def close_persistent_browser_session(self, session_id: str, organization_id: str) -> PersistentBrowserSession:
+        """Close a specific persistent browser session."""
+        async with self.Session() as session:
+            persistent_browser_session = (
+                await session.scalars(
+                    select(PersistentBrowserSessionModel)
+                    .filter_by(persistent_browser_session_id=session_id)
+                    .filter_by(organization_id=organization_id)
+                    .filter_by(deleted_at=None)
+                )
+            ).first()
+            if persistent_browser_session:
+                if persistent_browser_session.completed_at:
+                    return PersistentBrowserSession.model_validate(persistent_browser_session)
+                persistent_browser_session.completed_at = datetime.now(timezone.utc)
+                persistent_browser_session.status = "completed"
+                await session.commit()
+                await session.refresh(persistent_browser_session)
+                return PersistentBrowserSession.model_validate(persistent_browser_session)
+            raise NotFoundError(f"PersistentBrowserSession {session_id} not found")
+
+    @db_operation("get_all_active_persistent_browser_sessions")
+    async def get_all_active_persistent_browser_sessions(self) -> list[PersistentBrowserSessionModel]:
+        """Get all active persistent browser sessions across all organizations."""
+        async with self.Session() as session:
+            result = await session.execute(select(PersistentBrowserSessionModel).filter_by(deleted_at=None))
+            return result.scalars().all()
+
+    @db_operation("archive_browser_session_address")
+    async def archive_browser_session_address(self, session_id: str, organization_id: str) -> None:
+        """Suffix browser_address with a unique tag so the unique constraint
+        no longer blocks new sessions that reuse the same local address."""
+        async with self.Session() as session:
+            row = (
+                await session.scalars(
+                    select(PersistentBrowserSessionModel)
+                    .filter_by(persistent_browser_session_id=session_id)
+                    .filter_by(organization_id=organization_id)
+                    .filter_by(deleted_at=None)
+                )
+            ).first()
+
+            if not row or not row.browser_address:
+                return
+            if "::closed::" in row.browser_address:
+                return
+
+            row.browser_address = f"{row.browser_address}::closed::{uuid.uuid4().hex}"
+            await session.commit()
+
+    @db_operation("get_uncompleted_persistent_browser_sessions")
+    async def get_uncompleted_persistent_browser_sessions(self) -> list[PersistentBrowserSessionModel]:
+        """Get all browser sessions that have not been completed or deleted."""
+        async with self.Session() as session:
+            result = await session.execute(
+                select(PersistentBrowserSessionModel).filter_by(deleted_at=None).filter_by(completed_at=None)
+            )
+            return result.scalars().all()
+
+    @db_operation("get_debug_session_by_browser_session_id")
+    async def get_debug_session_by_browser_session_id(
+        self,
+        browser_session_id: str,
+        organization_id: str,
+    ) -> DebugSession | None:
+        async with self.Session() as session:
+            query = (
+                select(DebugSessionModel)
+                .filter_by(browser_session_id=browser_session_id)
+                .filter_by(organization_id=organization_id)
+                .filter_by(deleted_at=None)
+            )
+            model = (await session.scalars(query)).first()
+            return DebugSession.model_validate(model) if model else None
diff --git a/skyvern/forge/sdk/db/repositories/credentials.py b/skyvern/forge/sdk/db/repositories/credentials.py
new file mode 100644
index 000000000..9eb0ecf22
--- /dev/null
+++ b/skyvern/forge/sdk/db/repositories/credentials.py
@@ -0,0 +1,209 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+from sqlalchemy import select
+
+from skyvern.forge.sdk.db._error_handling import db_operation
+from skyvern.forge.sdk.db.base_repository import BaseRepository
+from skyvern.forge.sdk.db.exceptions import NotFoundError
+from skyvern.forge.sdk.db.models import CredentialModel, OrganizationBitwardenCollectionModel
+from skyvern.forge.sdk.schemas.credentials import Credential, CredentialType, CredentialVaultType
+from skyvern.forge.sdk.schemas.organization_bitwarden_collections import OrganizationBitwardenCollection
+
+from . import _UNSET
+
+
+class CredentialRepository(BaseRepository):
+    """Database operations for credential and Bitwarden collection management."""
+
+    @db_operation("create_credential")
+    async def create_credential(
+        self,
+        organization_id: str,
+        name: str,
+        vault_type: CredentialVaultType,
+        item_id: str,
+        credential_type: CredentialType,
+        username: str | None,
+        totp_type: str,
+        card_last4: str | None,
+        card_brand: str | None,
+        totp_identifier: str | None = None,
+        secret_label: str | None = None,
+    ) -> Credential:
+        async with self.Session() as session:
+            credential = CredentialModel(
+                organization_id=organization_id,
+                name=name,
+                vault_type=vault_type,
+                item_id=item_id,
+                credential_type=credential_type,
+                username=username,
+                totp_type=totp_type,
+                totp_identifier=totp_identifier,
+                card_last4=card_last4,
+                card_brand=card_brand,
+                secret_label=secret_label,
+            )
+            session.add(credential)
+            await session.commit()
+            await session.refresh(credential)
+            return Credential.model_validate(credential)
+
+    @db_operation("get_credential")
+    async def get_credential(self, credential_id: str, organization_id: str) -> Credential | None:
+        async with self.Session() as session:
+            credential = (
+                await session.scalars(
+                    select(CredentialModel)
+                    .filter_by(credential_id=credential_id)
+                    .filter_by(organization_id=organization_id)
+                    .filter(CredentialModel.deleted_at.is_(None))
+                )
+            ).first()
+            if credential:
+                return Credential.model_validate(credential)
+            return None
+
+    @db_operation("get_credentials")
+    async def get_credentials(
+        self,
+        organization_id: str,
+        page: int = 1,
+        page_size: int = 10,
+        vault_type: str | None = None,
+    ) -> list[Credential]:
+        async with self.Session() as session:
+            query = (
+                select(CredentialModel)
+                .filter_by(organization_id=organization_id)
+                .filter(CredentialModel.deleted_at.is_(None))
+            )
+            if vault_type is not None:
+                query = query.filter(CredentialModel.vault_type == vault_type)
+            credentials = (
+                await session.scalars(
+                    query.order_by(CredentialModel.created_at.desc()).offset((page - 1) * page_size).limit(page_size)
+                )
+            ).all()
+            return [Credential.model_validate(credential) for credential in credentials]
+
+    @db_operation("update_credential")
+    async def update_credential(
+        self,
+        credential_id: str,
+        organization_id: str,
+        name: str | None = None,
+        browser_profile_id: str | None | object = _UNSET,
+        tested_url: str | None | object = _UNSET,
+    ) -> Credential:
+        async with self.Session() as session:
+            credential = (
+                await session.scalars(
+                    select(CredentialModel)
+                    .filter_by(credential_id=credential_id)
+                    .filter_by(organization_id=organization_id)
+                    .filter(CredentialModel.deleted_at.is_(None))
+                )
+            ).first()
+            if not credential:
+                raise NotFoundError(f"Credential {credential_id} not found")
+            if name is not None:
+                credential.name = name
+            if browser_profile_id is not _UNSET:
+                credential.browser_profile_id = browser_profile_id
+            if tested_url is not _UNSET:
+                credential.tested_url = tested_url
+            await session.commit()
+            await session.refresh(credential)
+            return Credential.model_validate(credential)
+
+    @db_operation("update_credential_vault_data")
+    async def update_credential_vault_data(
+        self,
+        credential_id: str,
+        organization_id: str,
+        item_id: str,
+        name: str,
+        credential_type: CredentialType,
+        username: str | None = None,
+        totp_type: str = "none",
+        totp_identifier: str | None = None,
+        card_last4: str | None = None,
+        card_brand: str | None = None,
+        secret_label: str | None = None,
+    ) -> Credential:
+        async with self.Session() as session:
+            credential = (
+                await session.scalars(
+                    select(CredentialModel)
+                    .filter_by(credential_id=credential_id)
+                    .filter_by(organization_id=organization_id)
+                    .filter(CredentialModel.deleted_at.is_(None))
+                    .with_for_update()
+                )
+            ).first()
+            if not credential:
+                raise NotFoundError(f"Credential {credential_id} not found")
+            credential.item_id = item_id
+            credential.name = name
+            credential.credential_type = credential_type
+            credential.username = username
+            credential.totp_type = totp_type
+            credential.totp_identifier = totp_identifier
+            credential.card_last4 = card_last4
+            credential.card_brand = card_brand
+            credential.secret_label = secret_label
+            await session.commit()
+            await session.refresh(credential)
+            return Credential.model_validate(credential)
+
+    @db_operation("delete_credential")
+    async def delete_credential(self, credential_id: str, organization_id: str) -> None:
+        async with self.Session() as session:
+            credential = (
+                await session.scalars(
+                    select(CredentialModel)
+                    .filter_by(credential_id=credential_id)
+                    .filter_by(organization_id=organization_id)
+                )
+            ).first()
+            if not credential:
+                raise NotFoundError(f"Credential {credential_id} not found")
+            credential.deleted_at = datetime.now(timezone.utc)
+            await session.commit()
+            await session.refresh(credential)
+            return None
+
+    @db_operation("create_organization_bitwarden_collection")
+    async def create_organization_bitwarden_collection(
+        self,
+        organization_id: str,
+        collection_id: str,
+    ) -> OrganizationBitwardenCollection:
+        async with self.Session() as session:
+            organization_bitwarden_collection = OrganizationBitwardenCollectionModel(
+                organization_id=organization_id, collection_id=collection_id
+            )
+            session.add(organization_bitwarden_collection)
+            await session.commit()
+            await session.refresh(organization_bitwarden_collection)
+            return OrganizationBitwardenCollection.model_validate(organization_bitwarden_collection)
+
+    @db_operation("get_organization_bitwarden_collection")
+    async def get_organization_bitwarden_collection(
+        self,
+        organization_id: str,
+    ) -> OrganizationBitwardenCollection | None:
+        async with self.Session() as session:
+            organization_bitwarden_collection = (
+                await session.scalars(
+                    select(OrganizationBitwardenCollectionModel)
+                    .filter_by(organization_id=organization_id)
+                    .filter_by(deleted_at=None)
+                )
+            ).first()
+            if organization_bitwarden_collection:
+                return OrganizationBitwardenCollection.model_validate(organization_bitwarden_collection)
+            return None
diff --git a/skyvern/forge/sdk/db/repositories/debug.py b/skyvern/forge/sdk/db/repositories/debug.py
new file mode 100644
index 000000000..0627a4d86
--- /dev/null
+++ b/skyvern/forge/sdk/db/repositories/debug.py
@@ -0,0 +1,254 @@
+from __future__ import annotations
+
+from sqlalchemy import select
+
+from skyvern.forge.sdk.db._error_handling import db_operation
+from skyvern.forge.sdk.db.base_repository import BaseRepository
+from skyvern.forge.sdk.db.models import (
+    BlockRunModel,
+    DebugSessionModel,
+    WorkflowRunModel,
+)
+from skyvern.forge.sdk.schemas.debug_sessions import BlockRun, DebugSession, DebugSessionRun
+from skyvern.forge.sdk.workflow.models.workflow import WorkflowRunStatus
+
+
+class DebugRepository(BaseRepository):
+    """Database operations for debug sessions and block runs."""
+
+    @db_operation("get_debug_session")
+    async def get_debug_session(
+        self,
+        *,
+        organization_id: str,
+        user_id: str,
+        workflow_permanent_id: str,
+    ) -> DebugSession | None:
+        async with self.Session() as session:
+            debug_session = (
+                await session.scalars(
+                    select(DebugSessionModel)
+                    .filter_by(organization_id=organization_id)
+                    .filter_by(workflow_permanent_id=workflow_permanent_id)
+                    .filter_by(user_id=user_id)
+                    .filter_by(deleted_at=None)
+                    .filter_by(status="created")
+                    .order_by(DebugSessionModel.created_at.desc())
+                )
+            ).first()
+
+            if not debug_session:
+                return None
+
+            return DebugSession.model_validate(debug_session)
+
+    @db_operation("get_latest_block_run")
+    async def get_latest_block_run(
+        self,
+        *,
+        organization_id: str,
+        user_id: str,
+        block_label: str,
+    ) -> BlockRun | None:
+        async with self.Session() as session:
+            query = (
+                select(BlockRunModel)
+                .filter_by(organization_id=organization_id)
+                .filter_by(user_id=user_id)
+                .filter_by(block_label=block_label)
+                .order_by(BlockRunModel.created_at.desc())
+            )
+
+            model = (await session.scalars(query)).first()
+
+            return BlockRun.model_validate(model) if model else None
+
+    @db_operation("get_latest_completed_block_run")
+    async def get_latest_completed_block_run(
+        self,
+        *,
+        organization_id: str,
+        user_id: str,
+        block_label: str,
+        workflow_permanent_id: str,
+    ) -> BlockRun | None:
+        async with self.Session() as session:
+            query = (
+                select(BlockRunModel)
+                .join(WorkflowRunModel, BlockRunModel.workflow_run_id == WorkflowRunModel.workflow_run_id)
+                .filter(BlockRunModel.organization_id == organization_id)
+                .filter(BlockRunModel.user_id == user_id)
+                .filter(BlockRunModel.block_label == block_label)
+                .filter(WorkflowRunModel.status == WorkflowRunStatus.completed)
+                .filter(WorkflowRunModel.workflow_permanent_id == workflow_permanent_id)
+                .order_by(BlockRunModel.created_at.desc())
+            )
+
+            model = (await session.scalars(query)).first()
+
+            return BlockRun.model_validate(model) if model else None
+
+    @db_operation("create_block_run")
+    async def create_block_run(
+        self,
+        *,
+        organization_id: str,
+        user_id: str,
+        block_label: str,
+        output_parameter_id: str,
+        workflow_run_id: str,
+    ) -> None:
+        async with self.Session() as session:
+            block_run = BlockRunModel(
+                organization_id=organization_id,
+                user_id=user_id,
+                block_label=block_label,
+                output_parameter_id=output_parameter_id,
+                workflow_run_id=workflow_run_id,
+            )
+
+            session.add(block_run)
+
+            await session.commit()
+
+    @db_operation("get_latest_debug_session_for_user")
+    async def get_latest_debug_session_for_user(
+        self,
+        *,
+        organization_id: str,
+        user_id: str,
+        workflow_permanent_id: str,
+    ) -> DebugSession | None:
+        async with self.Session() as session:
+            query = (
+                select(DebugSessionModel)
+                .filter_by(organization_id=organization_id)
+                .filter_by(deleted_at=None)
+                .filter_by(status="created")
+                .filter_by(user_id=user_id)
+                .filter_by(workflow_permanent_id=workflow_permanent_id)
+                .order_by(DebugSessionModel.created_at.desc())
+            )
+
+            model = (await session.scalars(query)).first()
+
+            return DebugSession.model_validate(model) if model else None
+
+    @db_operation("get_debug_session_by_id")
+    async def get_debug_session_by_id(
+        self,
+        debug_session_id: str,
+        organization_id: str,
+    ) -> DebugSession | None:
+        async with self.Session() as session:
+            query = (
+                select(DebugSessionModel)
+                .filter_by(organization_id=organization_id)
+                .filter_by(deleted_at=None)
+                .filter_by(debug_session_id=debug_session_id)
+            )
+
+            model = (await session.scalars(query)).first()
+
+            return DebugSession.model_validate(model) if model else None
+
+    @db_operation("get_workflow_runs_by_debug_session_id")
+    async def get_workflow_runs_by_debug_session_id(
+        self,
+        debug_session_id: str,
+        organization_id: str,
+    ) -> list[DebugSessionRun]:
+        async with self.Session() as session:
+            query = (
+                select(WorkflowRunModel, BlockRunModel)
+                .join(BlockRunModel, BlockRunModel.workflow_run_id == WorkflowRunModel.workflow_run_id)
+                .filter(WorkflowRunModel.organization_id == organization_id)
+                .filter(WorkflowRunModel.debug_session_id == debug_session_id)
+                .order_by(WorkflowRunModel.created_at.desc())
+            )
+
+            results = (await session.execute(query)).all()
+
+            debug_session_runs = []
+            for workflow_run, block_run in results:
+                debug_session_runs.append(
+                    DebugSessionRun(
+                        ai_fallback=workflow_run.ai_fallback,
+                        block_label=block_run.block_label,
+                        browser_session_id=workflow_run.browser_session_id,
+                        code_gen=workflow_run.code_gen,
+                        debug_session_id=workflow_run.debug_session_id,
+                        failure_reason=workflow_run.failure_reason,
+                        output_parameter_id=block_run.output_parameter_id,
+                        run_with=workflow_run.run_with,
+                        script_run_id=workflow_run.script_run.get("script_run_id") if workflow_run.script_run else None,
+                        status=workflow_run.status,
+                        workflow_id=workflow_run.workflow_id,
+                        workflow_permanent_id=workflow_run.workflow_permanent_id,
+                        workflow_run_id=workflow_run.workflow_run_id,
+                        created_at=workflow_run.created_at,
+                        queued_at=workflow_run.queued_at,
+                        started_at=workflow_run.started_at,
+                        finished_at=workflow_run.finished_at,
+                    )
+                )
+
+            return debug_session_runs
+
+    @db_operation("complete_debug_sessions")
+    async def complete_debug_sessions(
+        self,
+        *,
+        organization_id: str,
+        user_id: str | None = None,
+        workflow_permanent_id: str | None = None,
+    ) -> list[DebugSession]:
+        async with self.Session() as session:
+            query = (
+                select(DebugSessionModel)
+                .filter_by(organization_id=organization_id)
+                .filter_by(deleted_at=None)
+                .filter_by(status="created")
+            )
+
+            if user_id:
+                query = query.filter_by(user_id=user_id)
+            if workflow_permanent_id:
+                query = query.filter_by(workflow_permanent_id=workflow_permanent_id)
+
+            models = (await session.scalars(query)).all()
+
+            for model in models:
+                model.status = "completed"
+
+            debug_sessions = [DebugSession.model_validate(model) for model in models]
+
+            await session.commit()
+
+            return debug_sessions
+
+    @db_operation("create_debug_session")
+    async def create_debug_session(
+        self,
+        *,
+        browser_session_id: str,
+        organization_id: str,
+        user_id: str,
+        workflow_permanent_id: str,
+        vnc_streaming_supported: bool,
+    ) -> DebugSession:
+        async with self.Session() as session:
+            debug_session = DebugSessionModel(
+                organization_id=organization_id,
+                workflow_permanent_id=workflow_permanent_id,
+                user_id=user_id,
+                browser_session_id=browser_session_id,
+                vnc_streaming_supported=vnc_streaming_supported,
+                status="created",
+            )
+
+            session.add(debug_session)
+            await session.commit()
+            await session.refresh(debug_session)
+
+            return DebugSession.model_validate(debug_session)
diff --git a/skyvern/forge/sdk/db/repositories/folders.py b/skyvern/forge/sdk/db/repositories/folders.py
new file mode 100644
index 000000000..f85ac5d63
--- /dev/null
+++ b/skyvern/forge/sdk/db/repositories/folders.py
@@ -0,0 +1,370 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, Callable
+
+from sqlalchemy import func, or_, select, update
+from sqlalchemy.exc import SQLAlchemyError
+
+from skyvern.forge.sdk.db._error_handling import db_operation
+from skyvern.forge.sdk.db.base_repository import BaseRepository
+from skyvern.forge.sdk.db.models import FolderModel, WorkflowModel
+from skyvern.forge.sdk.db.protocols import WorkflowReader
+from skyvern.forge.sdk.db.utils import convert_to_workflow
+from skyvern.forge.sdk.workflow.models.workflow import Workflow
+
+if TYPE_CHECKING:
+    from skyvern.forge.sdk.db.base_alchemy_db import _SessionFactory
+
+
+class FoldersRepository(BaseRepository):
+    """Database operations for folder management."""
+
+    def __init__(
+        self,
+        session_factory: _SessionFactory,
+        debug_enabled: bool = False,
+        is_retryable_error_fn: Callable[[SQLAlchemyError], bool] | None = None,
+        workflow_reader: WorkflowReader | None = None,
+    ) -> None:
+        super().__init__(session_factory, debug_enabled, is_retryable_error_fn)
+        self._workflow_reader = workflow_reader
+
+    @db_operation("create_folder")
+    async def create_folder(
+        self,
+        organization_id: str,
+        title: str,
+        description: str | None = None,
+    ) -> FolderModel:
+        """Create a new folder."""
+        async with self.Session() as session:
+            folder = FolderModel(
+                organization_id=organization_id,
+                title=title,
+                description=description,
+            )
+            session.add(folder)
+            await session.commit()
+            await session.refresh(folder)
+            return folder
+
+    @db_operation("get_folders")
+    async def get_folders(
+        self,
+        organization_id: str,
+        page: int = 1,
+        page_size: int = 10,
+        search_query: str | None = None,
+    ) -> list[FolderModel]:
+        """Get all folders for an organization with pagination and optional search."""
+        async with self.Session() as session:
+            stmt = (
+                select(FolderModel).filter_by(organization_id=organization_id).filter(FolderModel.deleted_at.is_(None))
+            )
+
+            if search_query:
+                search_pattern = f"%{search_query}%"
+                stmt = stmt.filter(
+                    or_(
+                        FolderModel.title.ilike(search_pattern),
+                        FolderModel.description.ilike(search_pattern),
+                    )
+                )
+
+            stmt = stmt.order_by(FolderModel.modified_at.desc())
+            stmt = stmt.offset((page - 1) * page_size).limit(page_size)
+
+            result = await session.execute(stmt)
+            return list(result.scalars().all())
+
+    @db_operation("get_folder")
+    async def get_folder(
+        self,
+        folder_id: str,
+        organization_id: str,
+    ) -> FolderModel | None:
+        """Get a folder by ID."""
+        async with self.Session() as session:
+            stmt = (
+                select(FolderModel)
+                .filter_by(folder_id=folder_id, organization_id=organization_id)
+                .filter(FolderModel.deleted_at.is_(None))
+            )
+            result = await session.execute(stmt)
+            return result.scalar_one_or_none()
+
+    @db_operation("update_folder")
+    async def update_folder(
+        self,
+        folder_id: str,
+        organization_id: str,
+        title: str | None = None,
+        description: str | None = None,
+    ) -> FolderModel | None:
+        """Update a folder's title or description."""
+        async with self.Session() as session:
+            stmt = (
+                select(FolderModel)
+                .filter_by(folder_id=folder_id, organization_id=organization_id)
+                .filter(FolderModel.deleted_at.is_(None))
+            )
+            result = await session.execute(stmt)
+            folder = result.scalar_one_or_none()
+            if not folder:
+                return None
+
+            if title is not None:
+                folder.title = title
+            if description is not None:
+                folder.description = description
+
+            folder.modified_at = datetime.now(timezone.utc)
+            await session.commit()
+            await session.refresh(folder)
+            return folder
+
+    @db_operation("get_workflow_permanent_ids_in_folder")
+    async def get_workflow_permanent_ids_in_folder(
+        self,
+        folder_id: str,
+        organization_id: str,
+    ) -> list[str]:
+        """Get workflow permanent IDs (latest versions only) in a folder."""
+        async with self.Session() as session:
+            # Subquery to get the latest version for each workflow
+            subquery = (
+                select(
+                    WorkflowModel.organization_id,
+                    WorkflowModel.workflow_permanent_id,
+                    func.max(WorkflowModel.version).label("max_version"),
+                )
+                .where(WorkflowModel.organization_id == organization_id)
+                .where(WorkflowModel.deleted_at.is_(None))
+                .group_by(
+                    WorkflowModel.organization_id,
+                    WorkflowModel.workflow_permanent_id,
+                )
+                .subquery()
+            )
+
+            # Get workflow_permanent_ids where the latest version is in this folder
+            stmt = (
+                select(WorkflowModel.workflow_permanent_id)
+                .join(
+                    subquery,
+                    (WorkflowModel.organization_id == subquery.c.organization_id)
+                    & (WorkflowModel.workflow_permanent_id == subquery.c.workflow_permanent_id)
+                    & (WorkflowModel.version == subquery.c.max_version),
+                )
+                .where(WorkflowModel.folder_id == folder_id)
+            )
+            result = await session.execute(stmt)
+            return list(result.scalars().all())
+
+    @db_operation("soft_delete_folder")
+    async def soft_delete_folder(
+        self,
+        folder_id: str,
+        organization_id: str,
+        delete_workflows: bool = False,
+    ) -> bool:
+        """Soft delete a folder. Optionally delete all workflows in the folder."""
+        async with self.Session() as session:
+            # Check if folder exists
+            folder_stmt = (
+                select(FolderModel)
+                .filter_by(folder_id=folder_id, organization_id=organization_id)
+                .filter(FolderModel.deleted_at.is_(None))
+            )
+            folder_result = await session.execute(folder_stmt)
+            folder = folder_result.scalar_one_or_none()
+            if not folder:
+                return False
+
+            # If delete_workflows is True, delete all workflows in the folder
+            if delete_workflows:
+                # Get workflow permanent IDs in the folder (inline logic)
+                subquery = (
+                    select(
+                        WorkflowModel.organization_id,
+                        WorkflowModel.workflow_permanent_id,
+                        func.max(WorkflowModel.version).label("max_version"),
+                    )
+                    .where(WorkflowModel.organization_id == organization_id)
+                    .where(WorkflowModel.deleted_at.is_(None))
+                    .group_by(
+                        WorkflowModel.organization_id,
+                        WorkflowModel.workflow_permanent_id,
+                    )
+                    .subquery()
+                )
+
+                workflow_permanent_ids_stmt = (
+                    select(WorkflowModel.workflow_permanent_id)
+                    .join(
+                        subquery,
+                        (WorkflowModel.organization_id == subquery.c.organization_id)
+                        & (WorkflowModel.workflow_permanent_id == subquery.c.workflow_permanent_id)
+                        & (WorkflowModel.version == subquery.c.max_version),
+                    )
+                    .where(WorkflowModel.folder_id == folder_id)
+                )
+                result = await session.execute(workflow_permanent_ids_stmt)
+                workflow_permanent_ids = list(result.scalars().all())
+
+                # Soft delete all workflows with these permanent IDs in a single bulk update
+                if workflow_permanent_ids:
+                    update_workflows_query = (
+                        update(WorkflowModel)
+                        .where(WorkflowModel.workflow_permanent_id.in_(workflow_permanent_ids))
+                        .where(WorkflowModel.organization_id == organization_id)
+                        .where(WorkflowModel.deleted_at.is_(None))
+                        .values(deleted_at=datetime.now(timezone.utc))
+                    )
+                    await session.execute(update_workflows_query)
+            else:
+                # Just remove folder_id from all workflows in this folder
+                update_workflows_query = (
+                    update(WorkflowModel)
+                    .where(WorkflowModel.folder_id == folder_id)
+                    .where(WorkflowModel.organization_id == organization_id)
+                    .values(folder_id=None, modified_at=datetime.now(timezone.utc))
+                )
+                await session.execute(update_workflows_query)
+
+            # Soft delete the folder
+            folder.deleted_at = datetime.now(timezone.utc)
+            await session.commit()
+            return True
+
+    @db_operation("get_folder_workflow_count")
+    async def get_folder_workflow_count(
+        self,
+        folder_id: str,
+        organization_id: str,
+    ) -> int:
+        """Get the count of workflows (latest versions only) in a folder."""
+        async with self.Session() as session:
+            # Subquery to get the latest version for each workflow (same pattern as get_workflows_by_organization_id)
+            subquery = (
+                select(
+                    WorkflowModel.organization_id,
+                    WorkflowModel.workflow_permanent_id,
+                    func.max(WorkflowModel.version).label("max_version"),
+                )
+                .where(WorkflowModel.organization_id == organization_id)
+                .where(WorkflowModel.deleted_at.is_(None))
+                .group_by(
+                    WorkflowModel.organization_id,
+                    WorkflowModel.workflow_permanent_id,
+                )
+                .subquery()
+            )
+
+            # Count workflows where the latest version is in this folder
+            stmt = (
+                select(func.count(WorkflowModel.workflow_permanent_id))
+                .join(
+                    subquery,
+                    (WorkflowModel.organization_id == subquery.c.organization_id)
+                    & (WorkflowModel.workflow_permanent_id == subquery.c.workflow_permanent_id)
+                    & (WorkflowModel.version == subquery.c.max_version),
+                )
+                .where(WorkflowModel.folder_id == folder_id)
+            )
+            result = await session.execute(stmt)
+            return result.scalar_one()
+
+    @db_operation("get_folder_workflow_counts_batch")
+    async def get_folder_workflow_counts_batch(
+        self,
+        folder_ids: list[str],
+        organization_id: str,
+    ) -> dict[str, int]:
+        """Get workflow counts for multiple folders in a single query."""
+        async with self.Session() as session:
+            # Subquery to get the latest version for each workflow
+            subquery = (
+                select(
+                    WorkflowModel.organization_id,
+                    WorkflowModel.workflow_permanent_id,
+                    func.max(WorkflowModel.version).label("max_version"),
+                )
+                .where(WorkflowModel.organization_id == organization_id)
+                .where(WorkflowModel.deleted_at.is_(None))
+                .group_by(
+                    WorkflowModel.organization_id,
+                    WorkflowModel.workflow_permanent_id,
+                )
+                .subquery()
+            )
+
+            # Count workflows grouped by folder_id
+            stmt = (
+                select(
+                    WorkflowModel.folder_id,
+                    func.count(WorkflowModel.workflow_permanent_id).label("count"),
+                )
+                .join(
+                    subquery,
+                    (WorkflowModel.organization_id == subquery.c.organization_id)
+                    & (WorkflowModel.workflow_permanent_id == subquery.c.workflow_permanent_id)
+                    & (WorkflowModel.version == subquery.c.max_version),
+                )
+                .where(WorkflowModel.folder_id.in_(folder_ids))
+                .group_by(WorkflowModel.folder_id)
+            )
+            result = await session.execute(stmt)
+            rows = result.all()
+
+            # Convert to dict; folders with no workflows will be absent from the result
+            return {row.folder_id: row.count for row in rows}
+
+    @db_operation("update_workflow_folder")
+    async def update_workflow_folder(
+        self,
+        workflow_permanent_id: str,
+        organization_id: str,
+        folder_id: str | None,
+    ) -> Workflow | None:
+        """Update folder assignment for the latest version of a workflow."""
+        # Get the latest version of the workflow
+        if self._workflow_reader is None:
+            raise RuntimeError("workflow_reader dependency not set")
+        latest_workflow = await self._workflow_reader.get_workflow_by_permanent_id(
+            workflow_permanent_id=workflow_permanent_id,
+            organization_id=organization_id,
+        )
+
+        if not latest_workflow:
+            return None
+
+        async with self.Session() as session:
+            # Validate folder exists in-org if folder_id is provided
+            if folder_id:
+                stmt = (
+                    select(FolderModel.folder_id)
+                    .where(FolderModel.folder_id == folder_id)
+                    .where(FolderModel.organization_id == organization_id)
+                    .where(FolderModel.deleted_at.is_(None))
+                )
+                if (await session.scalar(stmt)) is None:
+                    raise ValueError(f"Folder {folder_id} not found")
+
+            workflow_model = await session.get(WorkflowModel, latest_workflow.workflow_id)
+            if workflow_model:
+                workflow_model.folder_id = folder_id
+                workflow_model.modified_at = datetime.now(timezone.utc)
+
+                # Update folder's modified_at in the same transaction
+                if folder_id:
+                    folder_model = await session.get(FolderModel, folder_id)
+                    if folder_model:
+                        folder_model.modified_at = datetime.now(timezone.utc)
+
+                await session.commit()
+                await session.refresh(workflow_model)
+
+                return convert_to_workflow(workflow_model, self.debug_enabled)
+            return None
diff --git a/skyvern/forge/sdk/db/repositories/observer.py b/skyvern/forge/sdk/db/repositories/observer.py
new file mode 100644
index 000000000..11373e9b9
--- /dev/null
+++ b/skyvern/forge/sdk/db/repositories/observer.py
@@ -0,0 +1,588 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, Any, Callable
+
+from sqlalchemy import and_, delete, select
+from sqlalchemy.exc import SQLAlchemyError
+
+from skyvern.forge.sdk.db._error_handling import db_operation
+from skyvern.forge.sdk.db.base_alchemy_db import read_retry
+from skyvern.forge.sdk.db.base_repository import BaseRepository
+from skyvern.forge.sdk.db.exceptions import NotFoundError
+
+if TYPE_CHECKING:
+    from skyvern.forge.sdk.db.base_alchemy_db import _SessionFactory
+
+from skyvern.forge.sdk.db.models import (
+    TaskV2Model,
+    ThoughtModel,
+    WorkflowRunBlockModel,
+)
+from skyvern.forge.sdk.db.protocols import TaskReader
+from skyvern.forge.sdk.db.utils import (
+    convert_to_task_v2,
+    convert_to_workflow_run_block,
+    serialize_proxy_location,
+)
+from skyvern.forge.sdk.schemas.task_v2 import TaskV2, TaskV2Status, Thought, ThoughtType
+from skyvern.forge.sdk.schemas.workflow_runs import WorkflowRunBlock
+from skyvern.schemas.runs import ProxyLocationInput, RunEngine
+from skyvern.schemas.workflows import BlockStatus, BlockType
+
+
+class ObserverRepository(BaseRepository):
+    """Database operations for observer tasks (TaskV2), thoughts, and workflow run blocks."""
+
+    def __init__(
+        self,
+        session_factory: _SessionFactory,
+        debug_enabled: bool = False,
+        is_retryable_error_fn: Callable[[SQLAlchemyError], bool] | None = None,
+        task_reader: TaskReader | None = None,
+    ) -> None:
+        super().__init__(session_factory, debug_enabled, is_retryable_error_fn)
+        self._task_reader = task_reader
+
+    @read_retry()
+    @db_operation("get_task_v2", log_errors=False)
+    async def get_task_v2(self, task_v2_id: str, organization_id: str | None = None) -> TaskV2 | None:
+        async with self.Session() as session:
+            if task_v2 := (
+                await session.scalars(
+                    select(TaskV2Model)
+                    .filter_by(observer_cruise_id=task_v2_id)
+                    .filter_by(organization_id=organization_id)
+                )
+            ).first():
+                return convert_to_task_v2(task_v2, debug_enabled=self.debug_enabled)
+            return None
+
+    @db_operation("delete_thoughts")
+    async def delete_thoughts(self, task_v2_id: str, organization_id: str | None = None) -> None:
+        async with self.Session() as session:
+            stmt = delete(ThoughtModel).where(
+                and_(
+                    ThoughtModel.observer_cruise_id == task_v2_id,
+                    ThoughtModel.organization_id == organization_id,
+                )
+            )
+            await session.execute(stmt)
+            await session.commit()
+
+    @db_operation("get_task_v2_by_workflow_run_id")
+    async def get_task_v2_by_workflow_run_id(
+        self,
+        workflow_run_id: str,
+        organization_id: str | None = None,
+    ) -> TaskV2 | None:
+        async with self.Session() as session:
+            if task_v2 := (
+                await session.scalars(
+                    select(TaskV2Model)
+                    .filter_by(organization_id=organization_id)
+                    .filter_by(workflow_run_id=workflow_run_id)
+                )
+            ).first():
+                return convert_to_task_v2(task_v2, debug_enabled=self.debug_enabled)
+            return None
+
+    @db_operation("get_thought")
+    async def get_thought(self, thought_id: str, organization_id: str | None = None) -> Thought | None:
+        async with self.Session() as session:
+            if thought := (
+                await session.scalars(
+                    select(ThoughtModel)
+                    .filter_by(observer_thought_id=thought_id)
+                    .filter_by(organization_id=organization_id)
+                )
+            ).first():
+                return Thought.model_validate(thought)
+            return None
+
+    @db_operation("get_thoughts")
+    async def get_thoughts(
+        self,
+        *,
+        task_v2_id: str,
+        thought_types: list[ThoughtType],
+        organization_id: str,
+    ) -> list[Thought]:
+        async with self.Session() as session:
+            query = (
+                select(ThoughtModel)
+                .filter_by(observer_cruise_id=task_v2_id)
+                .filter_by(organization_id=organization_id)
+                .order_by(ThoughtModel.created_at)
+            )
+            if thought_types:
+                query = query.filter(ThoughtModel.observer_thought_type.in_(thought_types))
+            thoughts = (await session.scalars(query)).all()
+            return [Thought.model_validate(thought) for thought in thoughts]
+
+    @db_operation("create_task_v2")
+    async def create_task_v2(
+        self,
+        workflow_run_id: str | None = None,
+        workflow_id: str | None = None,
+        workflow_permanent_id: str | None = None,
+        prompt: str | None = None,
+        url: str | None = None,
+        organization_id: str | None = None,
+        proxy_location: ProxyLocationInput = None,
+        totp_identifier: str | None = None,
+        totp_verification_url: str | None = None,
+        webhook_callback_url: str | None = None,
+        extracted_information_schema: dict | list | str | None = None,
+        error_code_mapping: dict | None = None,
+        model: dict[str, Any] | None = None,
+        max_screenshot_scrolling_times: int | None = None,
+        extra_http_headers: dict[str, str] | None = None,
+        browser_address: str | None = None,
+        run_with: str | None = None,
+    ) -> TaskV2:
+        async with self.Session() as session:
+            new_task_v2 = TaskV2Model(
+                workflow_run_id=workflow_run_id,
+                workflow_id=workflow_id,
+                workflow_permanent_id=workflow_permanent_id,
+                prompt=prompt,
+                url=url,
+                proxy_location=serialize_proxy_location(proxy_location),
+                totp_identifier=totp_identifier,
+                totp_verification_url=totp_verification_url,
+                webhook_callback_url=webhook_callback_url,
+                extracted_information_schema=extracted_information_schema,
+                error_code_mapping=error_code_mapping,
+                organization_id=organization_id,
+                model=model,
+                max_screenshot_scrolling_times=max_screenshot_scrolling_times,
+                extra_http_headers=extra_http_headers,
+                browser_address=browser_address,
+                run_with=run_with,
+            )
+            session.add(new_task_v2)
+            await session.commit()
+            await session.refresh(new_task_v2)
+            return convert_to_task_v2(new_task_v2, debug_enabled=self.debug_enabled)
+
+    @db_operation("create_thought")
+    async def create_thought(
+        self,
+        task_v2_id: str,
+        workflow_run_id: str | None = None,
+        workflow_id: str | None = None,
+        workflow_permanent_id: str | None = None,
+        workflow_run_block_id: str | None = None,
+        user_input: str | None = None,
+        observation: str | None = None,
+        thought: str | None = None,
+        answer: str | None = None,
+        thought_scenario: str | None = None,
+        thought_type: str = ThoughtType.plan,
+        output: dict[str, Any] | None = None,
+        input_token_count: int | None = None,
+        output_token_count: int | None = None,
+        reasoning_token_count: int | None = None,
+        cached_token_count: int | None = None,
+        thought_cost: float | None = None,
+        organization_id: str | None = None,
+    ) -> Thought:
+        async with self.Session() as session:
+            new_thought = ThoughtModel(
+                observer_cruise_id=task_v2_id,
+                workflow_run_id=workflow_run_id,
+                workflow_id=workflow_id,
+                workflow_permanent_id=workflow_permanent_id,
+                workflow_run_block_id=workflow_run_block_id,
+                user_input=user_input,
+                observation=observation,
+                thought=thought,
+                answer=answer,
+                observer_thought_scenario=thought_scenario,
+                observer_thought_type=thought_type,
+                output=output,
+                input_token_count=input_token_count,
+                output_token_count=output_token_count,
+                reasoning_token_count=reasoning_token_count,
+                cached_token_count=cached_token_count,
+                thought_cost=thought_cost,
+                organization_id=organization_id,
+            )
+            session.add(new_thought)
+            await session.commit()
+            await session.refresh(new_thought)
+            return Thought.model_validate(new_thought)
+
+    @db_operation("update_thought")
+    async def update_thought(
+        self,
+        thought_id: str,
+        workflow_run_block_id: str | None = None,
+        workflow_run_id: str | None = None,
+        workflow_id: str | None = None,
+        workflow_permanent_id: str | None = None,
+        observation: str | None = None,
+        thought: str | None = None,
+        answer: str | None = None,
+        output: dict[str, Any] | None = None,
+        input_token_count: int | None = None,
+        output_token_count: int | None = None,
+        reasoning_token_count: int | None = None,
+        cached_token_count: int | None = None,
+        thought_cost: float | None = None,
+        organization_id: str | None = None,
+    ) -> Thought:
+        async with self.Session() as session:
+            thought_obj = (
+                await session.scalars(
+                    select(ThoughtModel)
+                    .filter_by(observer_thought_id=thought_id)
+                    .filter_by(organization_id=organization_id)
+                )
+            ).first()
+            if thought_obj:
+                if workflow_run_block_id:
+                    thought_obj.workflow_run_block_id = workflow_run_block_id
+                if workflow_run_id:
+                    thought_obj.workflow_run_id = workflow_run_id
+                if workflow_id:
+                    thought_obj.workflow_id = workflow_id
+                if workflow_permanent_id:
+                    thought_obj.workflow_permanent_id = workflow_permanent_id
+                if observation:
+                    thought_obj.observation = observation
+                if thought:
+                    thought_obj.thought = thought
+                if answer:
+                    thought_obj.answer = answer
+                if output:
+                    thought_obj.output = output
+                if input_token_count:
+                    thought_obj.input_token_count = input_token_count
+                if output_token_count:
+                    thought_obj.output_token_count = output_token_count
+                if reasoning_token_count:
+                    thought_obj.reasoning_token_count = reasoning_token_count
+                if cached_token_count:
+                    thought_obj.cached_token_count = cached_token_count
+                if thought_cost:
+                    thought_obj.thought_cost = thought_cost
+                await session.commit()
+                await session.refresh(thought_obj)
+                return Thought.model_validate(thought_obj)
+            raise NotFoundError(f"Thought {thought_id}")
+
+    @db_operation("update_task_v2")
+    async def update_task_v2(
+        self,
+        task_v2_id: str,
+        status: TaskV2Status | None = None,
+        workflow_run_id: str | None = None,
+        workflow_id: str | None = None,
+        workflow_permanent_id: str | None = None,
+        url: str | None = None,
+        prompt: str | None = None,
+        summary: str | None = None,
+        output: dict[str, Any] | None = None,
+        organization_id: str | None = None,
+        webhook_failure_reason: str | None = None,
+        failure_category: list[dict[str, Any]] | None = None,
+    ) -> TaskV2:
+        async with self.Session() as session:
+            task_v2 = (
+                await session.scalars(
+                    select(TaskV2Model)
+                    .filter_by(observer_cruise_id=task_v2_id)
+                    .filter_by(organization_id=organization_id)
+                )
+            ).first()
+            if task_v2:
+                if status:
+                    task_v2.status = status
+                    if status == TaskV2Status.queued and task_v2.queued_at is None:
+                        task_v2.queued_at = datetime.now(timezone.utc)
+                    if status == TaskV2Status.running and task_v2.started_at is None:
+                        task_v2.started_at = datetime.now(timezone.utc)
+                    if status.is_final() and task_v2.finished_at is None:
+                        task_v2.finished_at = datetime.now(timezone.utc)
+                if workflow_run_id:
+                    task_v2.workflow_run_id = workflow_run_id
+                if workflow_id:
+                    task_v2.workflow_id = workflow_id
+                if workflow_permanent_id:
+                    task_v2.workflow_permanent_id = workflow_permanent_id
+                if url:
+                    task_v2.url = url
+                if prompt:
+                    task_v2.prompt = prompt
+                if summary:
+                    task_v2.summary = summary
+                if output:
+                    task_v2.output = output
+                if webhook_failure_reason is not None:
+                    task_v2.webhook_failure_reason = webhook_failure_reason
+                if failure_category is not None:
+                    task_v2.failure_category = failure_category
+                await session.commit()
+                await session.refresh(task_v2)
+                return convert_to_task_v2(task_v2, debug_enabled=self.debug_enabled)
+            raise NotFoundError(f"TaskV2 {task_v2_id} not found")
+
+    @db_operation("create_workflow_run_block")
+    async def create_workflow_run_block(
+        self,
+        workflow_run_id: str,
+        parent_workflow_run_block_id: str | None = None,
+        organization_id: str | None = None,
+        task_id: str | None = None,
+        label: str | None = None,
+        block_type: BlockType | None = None,
+        status: BlockStatus = BlockStatus.running,
+        output: dict | list | str | None = None,
+        continue_on_failure: bool = False,
+        engine: RunEngine | None = None,
+        current_value: str | None = None,
+        current_index: int | None = None,
+    ) -> WorkflowRunBlock:
+        async with self.Session() as session:
+            new_workflow_run_block = WorkflowRunBlockModel(
+                workflow_run_id=workflow_run_id,
+                parent_workflow_run_block_id=parent_workflow_run_block_id,
+                organization_id=organization_id,
+                task_id=task_id,
+                label=label,
+                block_type=block_type,
+                status=status,
+                output=output,
+                continue_on_failure=continue_on_failure,
+                engine=engine,
+                current_value=current_value,
+                current_index=current_index,
+            )
+            session.add(new_workflow_run_block)
+            await session.commit()
+            await session.refresh(new_workflow_run_block)
+
+        task = None
+        if task_id:
+            if self._task_reader is None:
+                raise RuntimeError("task_reader dependency not set")
+            task = await self._task_reader.get_task(task_id, organization_id=organization_id)
+        return convert_to_workflow_run_block(new_workflow_run_block, task=task)
+
+    @db_operation("delete_workflow_run_blocks")
+    async def delete_workflow_run_blocks(self, workflow_run_id: str, organization_id: str | None = None) -> None:
+        async with self.Session() as session:
+            stmt = delete(WorkflowRunBlockModel).where(
+                and_(
+                    WorkflowRunBlockModel.workflow_run_id == workflow_run_id,
+                    WorkflowRunBlockModel.organization_id == organization_id,
+                )
+            )
+            await session.execute(stmt)
+            await session.commit()
+
+    @db_operation("update_workflow_run_block")
+    async def update_workflow_run_block(
+        self,
+        workflow_run_block_id: str,
+        organization_id: str | None = None,
+        status: BlockStatus | None = None,
+        output: dict | list | str | None = None,
+        failure_reason: str | None = None,
+        task_id: str | None = None,
+        loop_values: list | None = None,
+        current_value: str | None = None,
+        current_index: int | None = None,
+        recipients: list[str] | None = None,
+        attachments: list[str] | None = None,
+        subject: str | None = None,
+        body: str | None = None,
+        prompt: str | None = None,
+        wait_sec: int | None = None,
+        description: str | None = None,
+        block_workflow_run_id: str | None = None,
+        engine: str | None = None,
+        # HTTP request block parameters
+        http_request_method: str | None = None,
+        http_request_url: str | None = None,
+        http_request_headers: dict[str, str] | None = None,
+        http_request_body: dict[str, Any] | None = None,
+        http_request_parameters: dict[str, Any] | None = None,
+        http_request_timeout: int | None = None,
+        http_request_follow_redirects: bool | None = None,
+        ai_fallback_triggered: bool | None = None,
+        # block-level error codes (e.g. ["FILE_PARSER_ERROR"])
+        error_codes: list[str] | None = None,
+        # human interaction block
+        instructions: str | None = None,
+        positive_descriptor: str | None = None,
+        negative_descriptor: str | None = None,
+        # conditional block
+        executed_branch_id: str | None = None,
+        executed_branch_expression: str | None = None,
+        executed_branch_result: bool | None = None,
+        executed_branch_next_block: str | None = None,
+    ) -> WorkflowRunBlock:
+        async with self.Session() as session:
+            workflow_run_block = (
+                await session.scalars(
+                    select(WorkflowRunBlockModel)
+                    .filter_by(workflow_run_block_id=workflow_run_block_id)
+                    .filter_by(organization_id=organization_id)
+                )
+            ).first()
+            if workflow_run_block:
+                if status:
+                    workflow_run_block.status = status
+                if output:
+                    workflow_run_block.output = output
+                if task_id:
+                    workflow_run_block.task_id = task_id
+                if failure_reason:
+                    workflow_run_block.failure_reason = failure_reason
+                # Use `is not None` instead of truthiness checks so that falsy
+                # values like current_index=0, empty loop_values=[], or
+                # current_value="" are correctly persisted. Without this,
+                # the first loop iteration (index 0) loses its metadata.
+                if loop_values is not None:
+                    workflow_run_block.loop_values = loop_values
+                if current_value is not None:
+                    workflow_run_block.current_value = current_value
+                if current_index is not None:
+                    workflow_run_block.current_index = current_index
+                if recipients:
+                    workflow_run_block.recipients = recipients
+                if attachments:
+                    workflow_run_block.attachments = attachments
+                if subject:
+                    workflow_run_block.subject = subject
+                if body:
+                    workflow_run_block.body = body
+                if prompt:
+                    workflow_run_block.prompt = prompt
+                if wait_sec:
+                    workflow_run_block.wait_sec = wait_sec
+                if description:
+                    workflow_run_block.description = description
+                if block_workflow_run_id:
+                    workflow_run_block.block_workflow_run_id = block_workflow_run_id
+                if engine:
+                    workflow_run_block.engine = engine
+                # HTTP request block fields
+                if http_request_method:
+                    workflow_run_block.http_request_method = http_request_method
+                if http_request_url:
+                    workflow_run_block.http_request_url = http_request_url
+                if http_request_headers:
+                    workflow_run_block.http_request_headers = http_request_headers
+                if http_request_body:
+                    workflow_run_block.http_request_body = http_request_body
+                if http_request_parameters:
+                    workflow_run_block.http_request_parameters = http_request_parameters
+                if http_request_timeout:
+                    workflow_run_block.http_request_timeout = http_request_timeout
+                if http_request_follow_redirects is not None:
+                    workflow_run_block.http_request_follow_redirects = http_request_follow_redirects
+                if ai_fallback_triggered is not None:
+                    workflow_run_block.script_run = {"ai_fallback_triggered": ai_fallback_triggered}
+                if error_codes is not None:
+                    workflow_run_block.error_codes = error_codes
+                # human interaction block fields
+                if instructions:
+                    workflow_run_block.instructions = instructions
+                if positive_descriptor:
+                    workflow_run_block.positive_descriptor = positive_descriptor
+                if negative_descriptor:
+                    workflow_run_block.negative_descriptor = negative_descriptor
+                # conditional block fields
+                if executed_branch_id:
+                    workflow_run_block.executed_branch_id = executed_branch_id
+                if executed_branch_expression is not None:
+                    workflow_run_block.executed_branch_expression = executed_branch_expression
+                if executed_branch_result is not None:
+                    workflow_run_block.executed_branch_result = executed_branch_result
+                if executed_branch_next_block is not None:
+                    workflow_run_block.executed_branch_next_block = executed_branch_next_block
+                await session.commit()
+                await session.refresh(workflow_run_block)
+            else:
+                raise NotFoundError(f"WorkflowRunBlock {workflow_run_block_id} not found")
+        task = None
+        task_id = workflow_run_block.task_id
+        if task_id:
+            if self._task_reader is None:
+                raise RuntimeError("task_reader dependency not set")
+            task = await self._task_reader.get_task(task_id, organization_id=workflow_run_block.organization_id)
+        return convert_to_workflow_run_block(workflow_run_block, task=task)
+
+    @db_operation("get_workflow_run_block")
+    async def get_workflow_run_block(
+        self,
+        workflow_run_block_id: str,
+        organization_id: str | None = None,
+    ) -> WorkflowRunBlock:
+        async with self.Session() as session:
+            workflow_run_block = (
+                await session.scalars(
+                    select(WorkflowRunBlockModel)
+                    .filter_by(workflow_run_block_id=workflow_run_block_id)
+                    .filter_by(organization_id=organization_id)
+                )
+            ).first()
+            if workflow_run_block:
+                task = None
+                task_id = workflow_run_block.task_id
+                if task_id:
+                    if self._task_reader is None:
+                        raise RuntimeError("task_reader dependency not set")
+                    task = await self._task_reader.get_task(task_id, organization_id=organization_id)
+                return convert_to_workflow_run_block(workflow_run_block, task=task)
+            raise NotFoundError(f"WorkflowRunBlock {workflow_run_block_id} not found")
+
+    @db_operation("get_workflow_run_block_by_task_id")
+    async def get_workflow_run_block_by_task_id(
+        self,
+        task_id: str,
+        organization_id: str | None = None,
+    ) -> WorkflowRunBlock:
+        async with self.Session() as session:
+            workflow_run_block = (
+                await session.scalars(
+                    select(WorkflowRunBlockModel).filter_by(task_id=task_id).filter_by(organization_id=organization_id)
+                )
+            ).first()
+            if workflow_run_block:
+                task = None
+                task_id = workflow_run_block.task_id
+                if task_id:
+                    if self._task_reader is None:
+                        raise RuntimeError("task_reader dependency not set")
+                    task = await self._task_reader.get_task(task_id, organization_id=organization_id)
+                return convert_to_workflow_run_block(workflow_run_block, task=task)
+            raise NotFoundError(f"WorkflowRunBlock not found by {task_id}")
+
+    @db_operation("get_workflow_run_blocks")
+    async def get_workflow_run_blocks(
+        self,
+        workflow_run_id: str,
+        organization_id: str | None = None,
+    ) -> list[WorkflowRunBlock]:
+        async with self.Session() as session:
+            workflow_run_blocks = (
+                await session.scalars(
+                    select(WorkflowRunBlockModel)
+                    .filter_by(workflow_run_id=workflow_run_id)
+                    .filter_by(organization_id=organization_id)
+                    .order_by(WorkflowRunBlockModel.created_at.desc())
+                )
+            ).all()
+            if self._task_reader is None:
+                raise RuntimeError("task_reader dependency not set")
+            tasks = await self._task_reader.get_tasks_by_workflow_run_id(workflow_run_id)
+            tasks_dict = {task.task_id: task for task in tasks}
+            return [
+                convert_to_workflow_run_block(workflow_run_block, task=tasks_dict.get(workflow_run_block.task_id))
+                for workflow_run_block in workflow_run_blocks
+            ]
diff --git a/skyvern/forge/sdk/db/repositories/organizations.py b/skyvern/forge/sdk/db/repositories/organizations.py
new file mode 100644
index 000000000..df9168599
--- /dev/null
+++ b/skyvern/forge/sdk/db/repositories/organizations.py
@@ -0,0 +1,375 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from typing import Literal, overload
+
+from sqlalchemy import select, update
+
+from skyvern.forge.sdk.db._error_handling import db_operation
+from skyvern.forge.sdk.db.base_alchemy_db import read_retry
+from skyvern.forge.sdk.db.base_repository import BaseRepository
+from skyvern.forge.sdk.db.enums import OrganizationAuthTokenType
+from skyvern.forge.sdk.db.exceptions import NotFoundError
+from skyvern.forge.sdk.db.models import (
+    OrganizationAuthTokenModel,
+    OrganizationModel,
+    TaskModel,
+    WorkflowRunModel,
+)
+from skyvern.forge.sdk.db.utils import (
+    convert_to_organization,
+    convert_to_organization_auth_token,
+)
+from skyvern.forge.sdk.encrypt import encryptor
+from skyvern.forge.sdk.encrypt.base import EncryptMethod
+from skyvern.forge.sdk.schemas.organizations import (
+    AzureClientSecretCredential,
+    AzureOrganizationAuthToken,
+    BitwardenCredential,
+    BitwardenOrganizationAuthToken,
+    Organization,
+    OrganizationAuthToken,
+)
+from skyvern.forge.sdk.schemas.tasks import TaskStatus
+from skyvern.forge.sdk.workflow.models.workflow import WorkflowRunStatus
+
+
+class OrganizationsRepository(BaseRepository):
+    """Database operations for organization and auth-token management."""
+
+    @read_retry()
+    @db_operation("get_active_verification_requests", log_errors=False)
+    async def get_active_verification_requests(self, organization_id: str) -> list[dict]:
+        """Return active 2FA verification requests for an organization.
+
+        Queries both tasks and workflow runs where waiting_for_verification_code=True.
+        Used to provide initial state when a WebSocket notification client connects.
+        """
+        results: list[dict] = []
+        async with self.Session() as session:
+            # Tasks waiting for verification (exclude finalized tasks)
+            finalized_task_statuses = [s.value for s in TaskStatus if s.is_final()]
+            task_rows = (
+                await session.scalars(
+                    select(TaskModel)
+                    .filter_by(organization_id=organization_id)
+                    .filter_by(waiting_for_verification_code=True)
+                    .filter_by(workflow_run_id=None)
+                    .filter(TaskModel.status.not_in(finalized_task_statuses))
+                    .filter(TaskModel.created_at > datetime.now(timezone.utc) - timedelta(hours=1))
+                )
+            ).all()
+            for t in task_rows:
+                results.append(
+                    {
+                        "task_id": t.task_id,
+                        "workflow_run_id": None,
+                        "verification_code_identifier": t.verification_code_identifier,
+                        "verification_code_polling_started_at": (
+                            t.verification_code_polling_started_at.isoformat()
+                            if t.verification_code_polling_started_at
+                            else None
+                        ),
+                    }
+                )
+            # Workflow runs waiting for verification (exclude finalized runs)
+            finalized_wr_statuses = [s.value for s in WorkflowRunStatus if s.is_final()]
+            wr_rows = (
+                await session.scalars(
+                    select(WorkflowRunModel)
+                    .filter_by(organization_id=organization_id)
+                    .filter_by(waiting_for_verification_code=True)
+                    .filter(WorkflowRunModel.status.not_in(finalized_wr_statuses))
+                    .filter(WorkflowRunModel.created_at > datetime.now(timezone.utc) - timedelta(hours=1))
+                )
+            ).all()
+            for wr in wr_rows:
+                results.append(
+                    {
+                        "task_id": None,
+                        "workflow_run_id": wr.workflow_run_id,
+                        "verification_code_identifier": wr.verification_code_identifier,
+                        "verification_code_polling_started_at": (
+                            wr.verification_code_polling_started_at.isoformat()
+                            if wr.verification_code_polling_started_at
+                            else None
+                        ),
+                    }
+                )
+        return results
+
+    @db_operation("get_all_organizations")
+    async def get_all_organizations(self) -> list[Organization]:
+        async with self.Session() as session:
+            organizations = (await session.scalars(select(OrganizationModel))).all()
+            return [convert_to_organization(organization) for organization in organizations]
+
+    @db_operation("get_organization")
+    async def get_organization(self, organization_id: str) -> Organization | None:
+        async with self.Session() as session:
+            if organization := (
+                await session.scalars(select(OrganizationModel).filter_by(organization_id=organization_id))
+            ).first():
+                return convert_to_organization(organization)
+            else:
+                return None
+
+    @db_operation("get_organization_by_domain")
+    async def get_organization_by_domain(self, domain: str) -> Organization | None:
+        async with self.Session() as session:
+            if organization := (await session.scalars(select(OrganizationModel).filter_by(domain=domain))).first():
+                return convert_to_organization(organization)
+            return None
+
+    @db_operation("create_organization")
+    async def create_organization(
+        self,
+        organization_name: str,
+        webhook_callback_url: str | None = None,
+        max_steps_per_run: int | None = None,
+        max_retries_per_step: int | None = None,
+        domain: str | None = None,
+    ) -> Organization:
+        async with self.Session() as session:
+            org = OrganizationModel(
+                organization_name=organization_name,
+                webhook_callback_url=webhook_callback_url,
+                max_steps_per_run=max_steps_per_run,
+                max_retries_per_step=max_retries_per_step,
+                domain=domain,
+            )
+            session.add(org)
+            await session.commit()
+            await session.refresh(org)
+
+        return convert_to_organization(org)
+
+    @db_operation("update_organization")
+    async def update_organization(
+        self,
+        organization_id: str,
+        organization_name: str | None = None,
+        webhook_callback_url: str | None = None,
+        max_steps_per_run: int | None = None,
+        max_retries_per_step: int | None = None,
+    ) -> Organization:
+        async with self.Session() as session:
+            organization = (
+                await session.scalars(select(OrganizationModel).filter_by(organization_id=organization_id))
+            ).first()
+            if not organization:
+                raise NotFoundError
+            if organization_name:
+                organization.organization_name = organization_name
+            if webhook_callback_url:
+                organization.webhook_callback_url = webhook_callback_url
+            if max_steps_per_run:
+                organization.max_steps_per_run = max_steps_per_run
+            if max_retries_per_step:
+                organization.max_retries_per_step = max_retries_per_step
+            await session.commit()
+            await session.refresh(organization)
+            return Organization.model_validate(organization)
+
+    @overload
+    async def get_valid_org_auth_token(
+        self,
+        organization_id: str,
+        token_type: Literal["api", "onepassword_service_account", "custom_credential_service"],
+    ) -> OrganizationAuthToken | None: ...
+
+    @overload
+    async def get_valid_org_auth_token(  # type: ignore
+        self,
+        organization_id: str,
+        token_type: Literal["azure_client_secret_credential"],
+    ) -> AzureOrganizationAuthToken | None: ...
+
+    @overload
+    async def get_valid_org_auth_token(  # type: ignore
+        self,
+        organization_id: str,
+        token_type: Literal["bitwarden_credential"],
+    ) -> BitwardenOrganizationAuthToken | None: ...
+
+    @db_operation("get_valid_org_auth_token")
+    async def get_valid_org_auth_token(
+        self,
+        organization_id: str,
+        token_type: Literal[
+            "api",
+            "onepassword_service_account",
+            "azure_client_secret_credential",
+            "bitwarden_credential",
+            "custom_credential_service",
+        ],
+    ) -> OrganizationAuthToken | AzureOrganizationAuthToken | BitwardenOrganizationAuthToken | None:
+        async with self.Session() as session:
+            if token := (
+                await session.scalars(
+                    select(OrganizationAuthTokenModel)
+                    .filter_by(organization_id=organization_id)
+                    .filter_by(token_type=token_type)
+                    .filter_by(valid=True)
+                    .order_by(OrganizationAuthTokenModel.created_at.desc())
+                )
+            ).first():
+                return await convert_to_organization_auth_token(token, token_type)
+            else:
+                return None
+
+    @db_operation("replace_org_auth_token")
+    async def replace_org_auth_token(
+        self,
+        organization_id: str,
+        token_type: OrganizationAuthTokenType,
+        token: str | AzureClientSecretCredential | BitwardenCredential,
+        encrypted_method: EncryptMethod | None = None,
+    ) -> OrganizationAuthToken | AzureOrganizationAuthToken | BitwardenOrganizationAuthToken:
+        """Atomically invalidate existing tokens and create a new one in a single transaction."""
+        if token_type is OrganizationAuthTokenType.azure_client_secret_credential:
+            if not isinstance(token, AzureClientSecretCredential):
+                raise TypeError("Expected AzureClientSecretCredential for this token_type")
+            plaintext_token = token.model_dump_json()
+        elif token_type is OrganizationAuthTokenType.bitwarden_credential:
+            if not isinstance(token, BitwardenCredential):
+                raise TypeError("Expected BitwardenCredential for this token_type")
+            plaintext_token = token.model_dump_json()
+        else:
+            if not isinstance(token, str):
+                raise TypeError("Expected str token for this token_type")
+            plaintext_token = token
+
+        encrypted_token = ""
+        if encrypted_method is not None:
+            encrypted_token = await encryptor.encrypt(plaintext_token, encrypted_method)
+            plaintext_token = ""
+
+        async with self.Session() as session:
+            # Invalidate existing tokens
+            await session.execute(
+                update(OrganizationAuthTokenModel)
+                .filter_by(organization_id=organization_id)
+                .filter_by(token_type=token_type)
+                .filter_by(valid=True)
+                .values(valid=False)
+            )
+            # Create new token
+            auth_token = OrganizationAuthTokenModel(
+                organization_id=organization_id,
+                token_type=token_type,
+                token=plaintext_token,
+                encrypted_token=encrypted_token,
+                encrypted_method=encrypted_method.value if encrypted_method is not None else "",
+            )
+            session.add(auth_token)
+            await session.commit()
+            await session.refresh(auth_token)
+
+        return await convert_to_organization_auth_token(auth_token, token_type)
+
+    @db_operation("get_valid_org_auth_tokens")
+    async def get_valid_org_auth_tokens(
+        self,
+        organization_id: str,
+        token_type: OrganizationAuthTokenType,
+    ) -> list[OrganizationAuthToken]:
+        async with self.Session() as session:
+            tokens = (
+                await session.scalars(
+                    select(OrganizationAuthTokenModel)
+                    .filter_by(organization_id=organization_id)
+                    .filter_by(token_type=token_type)
+                    .filter_by(valid=True)
+                    .order_by(OrganizationAuthTokenModel.created_at.desc())
+                )
+            ).all()
+            return [await convert_to_organization_auth_token(token, token_type) for token in tokens]
+
+    @db_operation("validate_org_auth_token")
+    async def validate_org_auth_token(
+        self,
+        organization_id: str,
+        token_type: OrganizationAuthTokenType,
+        token: str,
+        valid: bool | None = True,
+        encrypted_method: EncryptMethod | None = None,
+    ) -> OrganizationAuthToken | None:
+        encrypted_token = ""
+        if encrypted_method is not None:
+            encrypted_token = await encryptor.encrypt(token, encrypted_method)
+
+        async with self.Session() as session:
+            query = (
+                select(OrganizationAuthTokenModel)
+                .filter_by(organization_id=organization_id)
+                .filter_by(token_type=token_type)
+            )
+            if encrypted_token:
+                query = query.filter_by(encrypted_token=encrypted_token)
+            else:
+                query = query.filter_by(token=token)
+            if valid is not None:
+                query = query.filter_by(valid=valid)
+            if token_obj := (await session.scalars(query)).first():
+                return await convert_to_organization_auth_token(token_obj, token_type)
+            else:
+                return None
+
+    @db_operation("create_org_auth_token")
+    async def create_org_auth_token(
+        self,
+        organization_id: str,
+        token_type: OrganizationAuthTokenType,
+        token: str | AzureClientSecretCredential | BitwardenCredential,
+        encrypted_method: EncryptMethod | None = None,
+    ) -> OrganizationAuthToken | AzureOrganizationAuthToken | BitwardenOrganizationAuthToken:
+        if token_type is OrganizationAuthTokenType.azure_client_secret_credential:
+            if not isinstance(token, AzureClientSecretCredential):
+                raise TypeError("Expected AzureClientSecretCredential for this token_type")
+            plaintext_token = token.model_dump_json()
+        elif token_type is OrganizationAuthTokenType.bitwarden_credential:
+            if not isinstance(token, BitwardenCredential):
+                raise TypeError("Expected BitwardenCredential for this token_type")
+            plaintext_token = token.model_dump_json()
+        else:
+            if not isinstance(token, str):
+                raise TypeError("Expected str token for this token_type")
+            plaintext_token = token
+
+        encrypted_token = ""
+
+        if encrypted_method is not None:
+            encrypted_token = await encryptor.encrypt(plaintext_token, encrypted_method)
+            plaintext_token = ""
+
+        async with self.Session() as session:
+            auth_token = OrganizationAuthTokenModel(
+                organization_id=organization_id,
+                token_type=token_type,
+                token=plaintext_token,
+                encrypted_token=encrypted_token,
+                encrypted_method=encrypted_method.value if encrypted_method is not None else "",
+            )
+            session.add(auth_token)
+            await session.commit()
+            await session.refresh(auth_token)
+
+        return await convert_to_organization_auth_token(auth_token, token_type)
+
+    @db_operation("invalidate_org_auth_tokens")
+    async def invalidate_org_auth_tokens(
+        self,
+        organization_id: str,
+        token_type: OrganizationAuthTokenType,
+    ) -> None:
+        """Invalidate all existing tokens of a specific type for an organization."""
+        async with self.Session() as session:
+            await session.execute(
+                update(OrganizationAuthTokenModel)
+                .filter_by(organization_id=organization_id)
+                .filter_by(token_type=token_type)
+                .filter_by(valid=True)
+                .values(valid=False)
+            )
+            await session.commit()
diff --git a/skyvern/forge/sdk/db/repositories/otp.py b/skyvern/forge/sdk/db/repositories/otp.py
new file mode 100644
index 000000000..1586babb6
--- /dev/null
+++ b/skyvern/forge/sdk/db/repositories/otp.py
@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+
+from sqlalchemy import and_, asc, select
+
+from skyvern.config import settings
+from skyvern.forge.sdk.db._error_handling import db_operation
+from skyvern.forge.sdk.db.base_repository import BaseRepository
+from skyvern.forge.sdk.db.models import TOTPCodeModel
+from skyvern.forge.sdk.schemas.totp_codes import OTPType, TOTPCode
+
+
+class OTPRepository(BaseRepository):
+    """Database operations for OTP/TOTP management."""
+
+    @db_operation("get_otp_codes")
+    async def get_otp_codes(
+        self,
+        organization_id: str,
+        totp_identifier: str,
+        valid_lifespan_minutes: int = settings.TOTP_LIFESPAN_MINUTES,
+        otp_type: OTPType | None = None,
+        workflow_run_id: str | None = None,
+        limit: int | None = None,
+    ) -> list[TOTPCode]:
+        """
+        1. filter by:
+        - organization_id
+        - totp_identifier
+        - workflow_run_id (optional)
+        2. make sure created_at is within the valid lifespan
+        3. sort by task_id/workflow_id/workflow_run_id nullslast and created_at desc
+        4. apply an optional limit at the DB layer
+        """
+        all_null = and_(
+            TOTPCodeModel.task_id.is_(None),
+            TOTPCodeModel.workflow_id.is_(None),
+            TOTPCodeModel.workflow_run_id.is_(None),
+        )
+        async with self.Session() as session:
+            query = (
+                select(TOTPCodeModel)
+                .filter_by(organization_id=organization_id)
+                .filter_by(totp_identifier=totp_identifier)
+                .filter(
+                    TOTPCodeModel.created_at > datetime.now(timezone.utc) - timedelta(minutes=valid_lifespan_minutes)
+                )
+            )
+            if otp_type:
+                query = query.filter(TOTPCodeModel.otp_type == otp_type)
+            if workflow_run_id is not None:
+                query = query.filter(TOTPCodeModel.workflow_run_id == workflow_run_id)
+            query = query.order_by(asc(all_null), TOTPCodeModel.created_at.desc())
+            if limit is not None:
+                query = query.limit(limit)
+            totp_codes = (await session.scalars(query)).all()
+            return [TOTPCode.model_validate(code) for code in totp_codes]
+
+    @db_operation("get_otp_codes_by_run")
+    async def get_otp_codes_by_run(
+        self,
+        organization_id: str,
+        task_id: str | None = None,
+        workflow_run_id: str | None = None,
+        valid_lifespan_minutes: int = settings.TOTP_LIFESPAN_MINUTES,
+        limit: int = 1,
+    ) -> list[TOTPCode]:
+        """Get OTP codes matching a specific task or workflow run (no totp_identifier required).
+
+        Used when the agent detects a 2FA page but no TOTP credentials are pre-configured.
+        The user submits codes manually via the UI, and this method finds them by run context.
+        """
+        if not workflow_run_id and not task_id:
+            return []
+        async with self.Session() as session:
+            query = (
+                select(TOTPCodeModel)
+                .filter_by(organization_id=organization_id)
+                .filter(
+                    TOTPCodeModel.created_at > datetime.now(timezone.utc) - timedelta(minutes=valid_lifespan_minutes)
+                )
+            )
+            if workflow_run_id:
+                query = query.filter(TOTPCodeModel.workflow_run_id == workflow_run_id)
+            elif task_id:
+                query = query.filter(TOTPCodeModel.task_id == task_id)
+            query = query.order_by(TOTPCodeModel.created_at.desc()).limit(limit)
+            results = (await session.scalars(query)).all()
+            return [TOTPCode.model_validate(r) for r in results]
+
+    @db_operation("get_recent_otp_codes")
+    async def get_recent_otp_codes(
+        self,
+        organization_id: str,
+        limit: int = 50,
+        valid_lifespan_minutes: int | None = None,
+        otp_type: OTPType | None = None,
+        workflow_run_id: str | None = None,
+        totp_identifier: str | None = None,
+    ) -> list[TOTPCode]:
+        """
+        Return recent otp codes for an organization ordered by newest first with optional
+        workflow_run_id filtering.
+        """
+        async with self.Session() as session:
+            query = select(TOTPCodeModel).filter_by(organization_id=organization_id)
+
+            if valid_lifespan_minutes is not None:
+                query = query.filter(
+                    TOTPCodeModel.created_at > datetime.now(timezone.utc) - timedelta(minutes=valid_lifespan_minutes)
+                )
+
+            if otp_type:
+                query = query.filter(TOTPCodeModel.otp_type == otp_type)
+            if workflow_run_id is not None:
+                query = query.filter(TOTPCodeModel.workflow_run_id == workflow_run_id)
+            if totp_identifier:
+                query = query.filter(TOTPCodeModel.totp_identifier == totp_identifier)
+            query = query.order_by(TOTPCodeModel.created_at.desc()).limit(limit)
+            totp_codes = (await session.scalars(query)).all()
+            return [TOTPCode.model_validate(totp_code) for totp_code in totp_codes]
+
+    @db_operation("create_otp_code")
+    async def create_otp_code(
+        self,
+        organization_id: str,
+        totp_identifier: str,
+        content: str,
+        code: str,
+        otp_type: OTPType,
+        task_id: str | None = None,
+        workflow_id: str | None = None,
+        workflow_run_id: str | None = None,
+        source: str | None = None,
+        expired_at: datetime | None = None,
+    ) -> TOTPCode:
+        async with self.Session() as session:
+            new_totp_code = TOTPCodeModel(
+                organization_id=organization_id,
+                totp_identifier=totp_identifier,
+                content=content,
+                code=code,
+                task_id=task_id,
+                workflow_id=workflow_id,
+                workflow_run_id=workflow_run_id,
+                source=source,
+                expired_at=expired_at,
+                otp_type=otp_type,
+            )
+            session.add(new_totp_code)
+            await session.commit()
+            await session.refresh(new_totp_code)
+            return TOTPCode.model_validate(new_totp_code)
diff --git a/skyvern/forge/sdk/db/repositories/schedules.py b/skyvern/forge/sdk/db/repositories/schedules.py
new file mode 100644
index 000000000..f13d404cc
--- /dev/null
+++ b/skyvern/forge/sdk/db/repositories/schedules.py
@@ -0,0 +1,602 @@
+"""Database operations for workflow schedules."""
+
+from __future__ import annotations
+
+import asyncio
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING, Any, Callable
+
+import structlog
+from sqlalchemy import exists, func, or_, select, text, update
+from sqlalchemy.exc import SQLAlchemyError
+
+from skyvern.forge.sdk.db._error_handling import db_operation, register_passthrough_exception
+from skyvern.forge.sdk.db.base_repository import BaseRepository
+from skyvern.forge.sdk.db.exceptions import ScheduleLimitExceededError
+from skyvern.forge.sdk.db.models import WorkflowModel, WorkflowRunModel, WorkflowScheduleModel
+from skyvern.forge.sdk.db.utils import convert_to_workflow_schedule
+from skyvern.forge.sdk.schemas.workflow_schedules import OrganizationScheduleItem, WorkflowSchedule
+from skyvern.forge.sdk.workflow.schedules import compute_next_run
+
+if TYPE_CHECKING:
+    from skyvern.forge.sdk.db.base_alchemy_db import _SessionFactory
+
+from . import _UNSET
+
+LOG = structlog.get_logger()
+
+register_passthrough_exception(ScheduleLimitExceededError)
+
+
+class SchedulesRepository(BaseRepository):
+    """Database operations for workflow schedules."""
+
+    def __init__(
+        self,
+        session_factory: _SessionFactory,
+        debug_enabled: bool = False,
+        is_retryable_error_fn: Callable[[SQLAlchemyError], bool] | None = None,
+        sqlite_schedule_lock: asyncio.Lock | None = None,
+    ) -> None:
+        super().__init__(session_factory, debug_enabled, is_retryable_error_fn)
+        self._sqlite_schedule_lock = sqlite_schedule_lock
+
+    @db_operation("create_workflow_schedule")
+    async def create_workflow_schedule(
+        self,
+        organization_id: str,
+        workflow_permanent_id: str,
+        cron_expression: str,
+        timezone: str,
+        enabled: bool,
+        parameters: dict[str, Any] | None = None,
+        temporal_schedule_id: str | None = None,
+        name: str | None = None,
+        description: str | None = None,
+    ) -> WorkflowSchedule:
+        async with self.Session() as session:
+            workflow_schedule = WorkflowScheduleModel(
+                organization_id=organization_id,
+                workflow_permanent_id=workflow_permanent_id,
+                cron_expression=cron_expression,
+                timezone=timezone,
+                enabled=enabled,
+                parameters=parameters,
+                temporal_schedule_id=temporal_schedule_id,
+                name=name,
+                description=description,
+            )
+            session.add(workflow_schedule)
+            await session.commit()
+            await session.refresh(workflow_schedule)
+            return convert_to_workflow_schedule(workflow_schedule, self.debug_enabled)
+
+    @db_operation("create_workflow_schedule_with_limit")
+    async def create_workflow_schedule_with_limit(
+        self,
+        organization_id: str,
+        workflow_permanent_id: str,
+        max_schedules: int | None,
+        cron_expression: str,
+        timezone: str,
+        enabled: bool,
+        parameters: dict[str, Any] | None = None,
+        name: str | None = None,
+        description: str | None = None,
+    ) -> tuple[WorkflowSchedule, int]:
+        """Create a schedule atomically with limit enforcement.
+
+        On PostgreSQL, uses an advisory lock to serialize concurrent creates for
+        the same workflow, preventing TOCTOU races on the schedule count.
+
+        On SQLite, uses an asyncio.Lock (set on AgentDB.__init__) since SQLite
+        is single-writer and has no advisory lock support.
+
+        Returns (created_schedule, count_before_insert).
+        Raises ScheduleLimitExceededError if count >= max_schedules.
+        """
+        # SQLite: serialize via Python lock (no advisory locks available).
+        # The lock is held across the count-check + insert to prevent TOCTOU.
+        if self._sqlite_schedule_lock is not None:
+            async with self._sqlite_schedule_lock:
+                return await self._create_schedule_with_limit_inner(
+                    organization_id,
+                    workflow_permanent_id,
+                    max_schedules,
+                    cron_expression,
+                    timezone,
+                    enabled,
+                    parameters,
+                    name,
+                    description,
+                    use_advisory_lock=False,
+                )
+        return await self._create_schedule_with_limit_inner(
+            organization_id,
+            workflow_permanent_id,
+            max_schedules,
+            cron_expression,
+            timezone,
+            enabled,
+            parameters,
+            name,
+            description,
+            use_advisory_lock=True,
+        )
+
+    # Intentionally not decorated with @db_operation — errors are caught by the
+    # outer create_workflow_schedule_with_limit which owns the operation name.
+    async def _create_schedule_with_limit_inner(
+        self,
+        organization_id: str,
+        workflow_permanent_id: str,
+        max_schedules: int | None,
+        cron_expression: str,
+        timezone: str,
+        enabled: bool,
+        parameters: dict[str, Any] | None,
+        name: str | None,
+        description: str | None,
+        *,
+        use_advisory_lock: bool,
+    ) -> tuple[WorkflowSchedule, int]:
+        async with self.Session() as session:
+            if use_advisory_lock:
+                lock_key = f"schedule:{organization_id}:{workflow_permanent_id}"
+                await session.execute(
+                    text("SELECT pg_advisory_xact_lock(hashtext(:key))"),
+                    {"key": lock_key},
+                )
+
+            count = (
+                await session.execute(
+                    select(func.count()).where(
+                        WorkflowScheduleModel.organization_id == organization_id,
+                        WorkflowScheduleModel.workflow_permanent_id == workflow_permanent_id,
+                        WorkflowScheduleModel.deleted_at.is_(None),
+                    )
+                )
+            ).scalar_one()
+
+            if max_schedules is not None and count >= max_schedules:
+                raise ScheduleLimitExceededError(
+                    organization_id=organization_id,
+                    workflow_permanent_id=workflow_permanent_id,
+                    current_count=count,
+                    max_allowed=max_schedules,
+                )
+
+            workflow_schedule = WorkflowScheduleModel(
+                organization_id=organization_id,
+                workflow_permanent_id=workflow_permanent_id,
+                cron_expression=cron_expression,
+                timezone=timezone,
+                enabled=enabled,
+                parameters=parameters,
+                name=name,
+                description=description,
+            )
+            session.add(workflow_schedule)
+            await session.commit()
+            await session.refresh(workflow_schedule)
+            return convert_to_workflow_schedule(workflow_schedule, self.debug_enabled), count
+
+    @db_operation("set_temporal_schedule_id")
+    async def set_temporal_schedule_id(
+        self,
+        workflow_schedule_id: str,
+        organization_id: str,
+        temporal_schedule_id: str,
+    ) -> WorkflowSchedule | None:
+        async with self.Session() as session:
+            workflow_schedule = (
+                await session.scalars(
+                    select(WorkflowScheduleModel).filter_by(
+                        workflow_schedule_id=workflow_schedule_id,
+                        organization_id=organization_id,
+                        deleted_at=None,
+                    )
+                )
+            ).first()
+
+            if not workflow_schedule:
+                return None
+
+            workflow_schedule.temporal_schedule_id = temporal_schedule_id
+            workflow_schedule.modified_at = datetime.now(UTC)
+            await session.commit()
+            await session.refresh(workflow_schedule)
+            return convert_to_workflow_schedule(workflow_schedule, self.debug_enabled)
+
+    @db_operation("update_workflow_schedule")
+    async def update_workflow_schedule(
+        self,
+        workflow_schedule_id: str,
+        organization_id: str,
+        cron_expression: str,
+        timezone: str,
+        enabled: bool,
+        parameters: dict[str, Any] | None = None,
+        temporal_schedule_id: str | None | object = _UNSET,
+        name: str | None | object = _UNSET,
+        description: str | None | object = _UNSET,
+    ) -> WorkflowSchedule | None:
+        async with self.Session() as session:
+            workflow_schedule = (
+                await session.scalars(
+                    select(WorkflowScheduleModel).filter_by(
+                        workflow_schedule_id=workflow_schedule_id,
+                        organization_id=organization_id,
+                        deleted_at=None,
+                    )
+                )
+            ).first()
+
+            if not workflow_schedule:
+                return None
+
+            workflow_schedule.cron_expression = cron_expression
+            workflow_schedule.timezone = timezone
+            workflow_schedule.enabled = enabled
+            workflow_schedule.parameters = parameters
+            if temporal_schedule_id is not _UNSET:
+                workflow_schedule.temporal_schedule_id = temporal_schedule_id
+            if name is not _UNSET:
+                workflow_schedule.name = name
+            if description is not _UNSET:
+                workflow_schedule.description = description
+            workflow_schedule.modified_at = datetime.now(UTC)
+            await session.commit()
+            await session.refresh(workflow_schedule)
+            return convert_to_workflow_schedule(workflow_schedule, self.debug_enabled)
+
+    @db_operation("get_workflow_schedule_by_id")
+    async def get_workflow_schedule_by_id(
+        self,
+        workflow_schedule_id: str,
+        organization_id: str,
+    ) -> WorkflowSchedule | None:
+        async with self.Session() as session:
+            workflow_schedule = (
+                await session.scalars(
+                    select(WorkflowScheduleModel).filter_by(
+                        workflow_schedule_id=workflow_schedule_id,
+                        organization_id=organization_id,
+                        deleted_at=None,
+                    )
+                )
+            ).first()
+            if not workflow_schedule:
+                return None
+            return convert_to_workflow_schedule(workflow_schedule, self.debug_enabled)
+
+    @db_operation("get_workflow_schedules")
+    async def get_workflow_schedules(
+        self,
+        workflow_permanent_id: str,
+        organization_id: str,
+    ) -> list[WorkflowSchedule]:
+        async with self.Session() as session:
+            rows = (
+                await session.scalars(
+                    select(WorkflowScheduleModel).filter_by(
+                        workflow_permanent_id=workflow_permanent_id,
+                        organization_id=organization_id,
+                        deleted_at=None,
+                    )
+                )
+            ).all()
+            return [convert_to_workflow_schedule(r, self.debug_enabled) for r in rows]
+
+    @db_operation("get_all_enabled_schedules")
+    async def get_all_enabled_schedules(
+        self,
+        organization_id: str | None = None,
+    ) -> list[WorkflowSchedule]:
+        """Fetch all enabled, non-deleted schedules, optionally filtered by org."""
+        async with self.Session() as session:
+            stmt = select(WorkflowScheduleModel).where(
+                WorkflowScheduleModel.enabled.is_(True),
+                WorkflowScheduleModel.deleted_at.is_(None),
+            )
+            if organization_id:
+                stmt = stmt.where(WorkflowScheduleModel.organization_id == organization_id)
+            rows = (await session.scalars(stmt)).all()
+            return [convert_to_workflow_schedule(r, self.debug_enabled) for r in rows]
+
+    @db_operation("has_schedule_fired_since")
+    async def has_schedule_fired_since(
+        self,
+        workflow_schedule_id: str,
+        since: datetime,
+    ) -> bool:
+        """Check if a workflow_run exists for the given schedule since a timestamp."""
+        async with self.Session() as session:
+            row = (
+                await session.execute(
+                    select(
+                        exists().where(
+                            WorkflowRunModel.workflow_schedule_id == workflow_schedule_id,
+                            WorkflowRunModel.created_at >= since,
+                        )
+                    )
+                )
+            ).scalar()
+            return bool(row)
+
+    @db_operation("update_workflow_schedule_enabled")
+    async def update_workflow_schedule_enabled(
+        self,
+        workflow_schedule_id: str,
+        organization_id: str,
+        enabled: bool,
+    ) -> WorkflowSchedule | None:
+        async with self.Session() as session:
+            workflow_schedule = (
+                await session.scalars(
+                    select(WorkflowScheduleModel).filter_by(
+                        workflow_schedule_id=workflow_schedule_id,
+                        organization_id=organization_id,
+                        deleted_at=None,
+                    )
+                )
+            ).first()
+            if not workflow_schedule:
+                return None
+            workflow_schedule.enabled = enabled
+            workflow_schedule.modified_at = datetime.now(UTC)
+            await session.commit()
+            await session.refresh(workflow_schedule)
+            return convert_to_workflow_schedule(workflow_schedule, self.debug_enabled)
+
+    @db_operation("delete_workflow_schedule")
+    async def delete_workflow_schedule(
+        self,
+        workflow_schedule_id: str,
+        organization_id: str,
+    ) -> WorkflowSchedule | None:
+        async with self.Session() as session:
+            workflow_schedule = (
+                await session.scalars(
+                    select(WorkflowScheduleModel).filter_by(
+                        workflow_schedule_id=workflow_schedule_id,
+                        organization_id=organization_id,
+                        deleted_at=None,
+                    )
+                )
+            ).first()
+            if not workflow_schedule:
+                return None
+
+            workflow_schedule.deleted_at = datetime.now(UTC)
+            workflow_schedule.modified_at = datetime.now(UTC)
+            await session.commit()
+            await session.refresh(workflow_schedule)
+            return convert_to_workflow_schedule(workflow_schedule, self.debug_enabled)
+
+    @db_operation("restore_workflow_schedule")
+    async def restore_workflow_schedule(
+        self,
+        workflow_schedule_id: str,
+        organization_id: str,
+    ) -> WorkflowSchedule | None:
+        async with self.Session() as session:
+            workflow_schedule = (
+                await session.scalars(
+                    select(WorkflowScheduleModel)
+                    .filter_by(
+                        workflow_schedule_id=workflow_schedule_id,
+                        organization_id=organization_id,
+                    )
+                    .filter(WorkflowScheduleModel.deleted_at.isnot(None))
+                )
+            ).first()
+            if not workflow_schedule:
+                return None
+
+            workflow_schedule.deleted_at = None
+            workflow_schedule.modified_at = datetime.now(UTC)
+            await session.commit()
+            await session.refresh(workflow_schedule)
+            return convert_to_workflow_schedule(workflow_schedule, self.debug_enabled)
+
+    @db_operation("count_workflow_schedules")
+    async def count_workflow_schedules(
+        self,
+        organization_id: str,
+        workflow_permanent_id: str,
+    ) -> int:
+        async with self.Session() as session:
+            result = await session.execute(
+                select(func.count()).where(
+                    WorkflowScheduleModel.organization_id == organization_id,
+                    WorkflowScheduleModel.workflow_permanent_id == workflow_permanent_id,
+                    WorkflowScheduleModel.deleted_at.is_(None),
+                )
+            )
+            return result.scalar_one()
+
+    @db_operation("list_organization_schedules")
+    async def list_organization_schedules(
+        self,
+        organization_id: str,
+        page: int = 1,
+        page_size: int = 10,
+        enabled_filter: bool | None = None,
+        search: str | None = None,
+    ) -> tuple[list[OrganizationScheduleItem], int]:
+        """
+        List all schedules for an organization, joined with workflow titles.
+        Returns (schedules, total_count).
+        """
+        if page < 1:
+            raise ValueError(f"Page must be greater than 0, got {page}")
+        db_page = page - 1
+        async with self.Session() as session:
+            # Subquery to get the latest version title per workflow_permanent_id
+            latest_version_sq = (
+                select(
+                    WorkflowModel.workflow_permanent_id,
+                    func.max(WorkflowModel.version).label("max_version"),
+                )
+                .where(WorkflowModel.organization_id == organization_id)
+                .where(WorkflowModel.deleted_at.is_(None))
+                .group_by(WorkflowModel.workflow_permanent_id)
+                .subquery()
+            )
+
+            workflow_title_sq = (
+                select(
+                    WorkflowModel.workflow_permanent_id,
+                    WorkflowModel.title,
+                )
+                .join(
+                    latest_version_sq,
+                    (WorkflowModel.workflow_permanent_id == latest_version_sq.c.workflow_permanent_id)
+                    & (WorkflowModel.version == latest_version_sq.c.max_version),
+                )
+                .subquery()
+            )
+
+            # Base query: schedules joined with workflow titles
+            base_filter = (
+                select(WorkflowScheduleModel, workflow_title_sq.c.title.label("workflow_title"))
+                .outerjoin(
+                    workflow_title_sq,
+                    WorkflowScheduleModel.workflow_permanent_id == workflow_title_sq.c.workflow_permanent_id,
+                )
+                .where(WorkflowScheduleModel.organization_id == organization_id)
+                .where(WorkflowScheduleModel.deleted_at.is_(None))
+            )
+
+            if enabled_filter is not None:
+                base_filter = base_filter.where(WorkflowScheduleModel.enabled == enabled_filter)
+
+            if search:
+                base_filter = base_filter.where(
+                    or_(
+                        workflow_title_sq.c.title.icontains(search, autoescape=True),
+                        WorkflowScheduleModel.name.icontains(search, autoescape=True),
+                    )
+                )
+
+            # Count query
+            count_query = select(func.count()).select_from(base_filter.subquery())
+            total_count = (await session.execute(count_query)).scalar_one()
+
+            # Data query with pagination
+            data_query = (
+                base_filter.order_by(WorkflowScheduleModel.created_at.desc())
+                .limit(page_size)
+                .offset(db_page * page_size)
+            )
+            rows = (await session.execute(data_query)).all()
+
+            # Materialize row data while session is open
+            raw_schedules = []
+            for row in rows:
+                schedule_model = row[0]
+                raw_schedules.append(
+                    (
+                        schedule_model.workflow_schedule_id,
+                        schedule_model.organization_id,
+                        schedule_model.workflow_permanent_id,
+                        row[1] or "Untitled Workflow",
+                        schedule_model.cron_expression,
+                        schedule_model.timezone,
+                        schedule_model.enabled,
+                        schedule_model.parameters,
+                        schedule_model.name,
+                        schedule_model.description,
+                        schedule_model.created_at,
+                        schedule_model.modified_at,
+                    )
+                )
+
+        # Compute next_run outside session scope (pure CPU, no DB needed)
+        schedules: list[OrganizationScheduleItem] = []
+        for (
+            ws_id,
+            org_id,
+            wpid,
+            title,
+            cron_expr,
+            tz,
+            enabled,
+            params,
+            name,
+            description,
+            created,
+            modified,
+        ) in raw_schedules:
+            next_run = None
+            if enabled:
+                try:
+                    next_run = compute_next_run(cron_expr, tz)
+                except Exception:
+                    LOG.warning(
+                        "Failed to compute next_run for schedule",
+                        workflow_schedule_id=ws_id,
+                        exc_info=True,
+                    )
+
+            schedules.append(
+                OrganizationScheduleItem(
+                    workflow_schedule_id=ws_id,
+                    organization_id=org_id,
+                    workflow_permanent_id=wpid,
+                    workflow_title=title,
+                    cron_expression=cron_expr,
+                    timezone=tz,
+                    enabled=enabled,
+                    parameters=params,
+                    name=name,
+                    description=description,
+                    next_run=next_run,
+                    created_at=created,
+                    modified_at=modified,
+                )
+            )
+
+        return schedules, total_count
+
+    @db_operation("soft_delete_orphaned_schedules")
+    async def soft_delete_orphaned_schedules(self, limit: int = 500) -> list[tuple[str, str]]:
+        """Soft-delete orphaned schedules and return their identities.
+
+        Uses a single UPDATE ... RETURNING statement so orphan detection and
+        soft-deletion happen atomically in one DB round-trip.
+        """
+        async with self.Session() as session:
+            active_workflow_exists = (
+                select(WorkflowModel.workflow_permanent_id)
+                .where(WorkflowModel.workflow_permanent_id == WorkflowScheduleModel.workflow_permanent_id)
+                .where(WorkflowModel.deleted_at.is_(None))
+                .correlate(WorkflowScheduleModel)
+                .exists()
+            )
+            orphaned_schedules = (
+                select(
+                    WorkflowScheduleModel.workflow_schedule_id.label("workflow_schedule_id"),
+                    WorkflowScheduleModel.workflow_permanent_id.label("workflow_permanent_id"),
+                )
+                .where(WorkflowScheduleModel.deleted_at.is_(None))
+                .where(~active_workflow_exists)
+                .limit(limit)
+                .cte("orphaned_schedules")
+            )
+            update_query = (
+                update(WorkflowScheduleModel)
+                .where(
+                    WorkflowScheduleModel.workflow_schedule_id.in_(select(orphaned_schedules.c.workflow_schedule_id))
+                )
+                .where(WorkflowScheduleModel.deleted_at.is_(None))
+                .values(deleted_at=datetime.now(UTC))
+                .returning(
+                    WorkflowScheduleModel.workflow_schedule_id,
+                    WorkflowScheduleModel.workflow_permanent_id,
+                )
+            )
+            result = await session.execute(update_query)
+            await session.commit()
+            return [(row[0], row[1]) for row in result.all()]
diff --git a/skyvern/forge/sdk/db/repositories/scripts.py b/skyvern/forge/sdk/db/repositories/scripts.py
new file mode 100644
index 000000000..e1673c580
--- /dev/null
+++ b/skyvern/forge/sdk/db/repositories/scripts.py
@@ -0,0 +1,1206 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+
+import structlog
+from sqlalchemy import and_, delete, distinct, func, select, update
+from sqlalchemy.dialects.postgresql import insert
+
+from skyvern.forge.sdk.db._error_handling import db_operation
+from skyvern.forge.sdk.db.base_repository import BaseRepository
+from skyvern.forge.sdk.db.exceptions import NotFoundError
+from skyvern.forge.sdk.db.models import (
+    ScriptBlockModel,
+    ScriptBranchHitModel,
+    ScriptFallbackEpisodeModel,
+    ScriptFileModel,
+    ScriptModel,
+    WorkflowRunModel,
+    WorkflowScriptModel,
+)
+from skyvern.forge.sdk.db.utils import (
+    convert_to_script,
+    convert_to_script_block,
+    convert_to_script_file,
+)
+from skyvern.forge.sdk.utils.sanitization import sanitize_postgres_text
+from skyvern.schemas.scripts import (
+    Script,
+    ScriptBlock,
+    ScriptBranchHit,
+    ScriptFallbackEpisode,
+    ScriptFile,
+    ScriptStatus,
+    WorkflowScript,
+)
+
+LOG = structlog.get_logger()
+
+
+class ScriptsRepository(BaseRepository):
+    """Database operations for scripts, script files, script blocks, workflow scripts, and fallback episodes."""
+
+    @db_operation("create_script")
+    async def create_script(
+        self,
+        organization_id: str,
+        run_id: str | None = None,
+        script_id: str | None = None,
+        version: int | None = None,
+    ) -> Script:
+        async with self.Session() as session:
+            script = ScriptModel(
+                organization_id=organization_id,
+                run_id=run_id,
+            )
+            if script_id:
+                script.script_id = script_id
+            if version:
+                script.version = version
+            session.add(script)
+            await session.commit()
+            await session.refresh(script)
+            return convert_to_script(script)
+
+    @db_operation("get_scripts")
+    async def get_scripts(
+        self,
+        organization_id: str,
+        page: int = 1,
+        page_size: int = 10,
+    ) -> list[Script]:
+        async with self.Session() as session:
+            # Calculate offset for pagination
+            offset = (page - 1) * page_size
+
+            # Subquery to get the latest version of each script
+            latest_versions_subquery = (
+                select(ScriptModel.script_id, func.max(ScriptModel.version).label("latest_version"))
+                .filter_by(organization_id=organization_id)
+                .filter(ScriptModel.deleted_at.is_(None))
+                .group_by(ScriptModel.script_id)
+                .subquery()
+            )
+
+            # Main query to get scripts with their latest versions
+            get_scripts_query = (
+                select(ScriptModel)
+                .join(
+                    latest_versions_subquery,
+                    and_(
+                        ScriptModel.script_id == latest_versions_subquery.c.script_id,
+                        ScriptModel.version == latest_versions_subquery.c.latest_version,
+                    ),
+                )
+                .filter_by(organization_id=organization_id)
+                .filter(ScriptModel.deleted_at.is_(None))
+                .order_by(ScriptModel.created_at.desc())
+                .limit(page_size)
+                .offset(offset)
+            )
+            scripts = (await session.scalars(get_scripts_query)).all()
+            return [convert_to_script(script) for script in scripts]
+
+    @db_operation("get_script")
+    async def get_script(
+        self,
+        script_id: str,
+        organization_id: str,
+        version: int | None = None,
+    ) -> Script | None:
+        """Get a specific script by ID and optionally by version."""
+        async with self.Session() as session:
+            get_script_query = (
+                select(ScriptModel)
+                .filter_by(script_id=script_id)
+                .filter_by(organization_id=organization_id)
+                .filter(ScriptModel.deleted_at.is_(None))
+            )
+
+            if version is not None:
+                get_script_query = get_script_query.filter_by(version=version)
+            else:
+                # Get the latest version
+                get_script_query = get_script_query.order_by(ScriptModel.version.desc()).limit(1)
+
+            if script := (await session.scalars(get_script_query)).first():
+                return convert_to_script(script)
+            return None
+
+    @db_operation("get_script_revision")
+    async def get_script_revision(self, script_revision_id: str, organization_id: str) -> Script | None:
+        async with self.Session() as session:
+            script = (
+                await session.scalars(
+                    select(ScriptModel)
+                    .filter_by(script_revision_id=script_revision_id)
+                    .filter_by(organization_id=organization_id)
+                )
+            ).first()
+            return convert_to_script(script) if script else None
+
+    @db_operation("get_latest_script_version")
+    async def get_latest_script_version(self, script_id: str, organization_id: str) -> Script | None:
+        """Get the latest version of a script by script_id."""
+        async with self.Session() as session:
+            script = (
+                await session.scalars(
+                    select(ScriptModel)
+                    .filter_by(script_id=script_id, organization_id=organization_id)
+                    .filter(ScriptModel.deleted_at.is_(None))
+                    .order_by(ScriptModel.version.desc())
+                    .limit(1)
+                )
+            ).first()
+            return convert_to_script(script) if script else None
+
+    @db_operation("get_script_versions")
+    async def get_script_versions(
+        self,
+        script_id: str,
+        organization_id: str,
+    ) -> list[Script]:
+        """Get all versions of a script, ordered by version DESC."""
+        async with self.Session() as session:
+            query = (
+                select(ScriptModel)
+                .filter(
+                    ScriptModel.script_id == script_id,
+                    ScriptModel.organization_id == organization_id,
+                    ScriptModel.deleted_at.is_(None),
+                )
+                .order_by(ScriptModel.version.desc())
+            )
+            result = await session.scalars(query)
+            return [convert_to_script(row) for row in result.all()]
+
+    @db_operation("get_script_version_stats")
+    async def get_script_version_stats(
+        self,
+        organization_id: str,
+        script_ids: list[str],
+    ) -> dict[str, tuple[int, int]]:
+        """Return {script_id: (latest_version, version_count)} for the given script IDs."""
+        if not script_ids:
+            return {}
+        async with self.Session() as session:
+            query = (
+                select(
+                    ScriptModel.script_id,
+                    # max(version) must include soft-deleted rows so next-version
+                    # assignment doesn't collide with the unique constraint.
+                    func.max(ScriptModel.version),
+                    # version_count only counts live rows (for display).
+                    func.count(ScriptModel.script_revision_id).filter(
+                        ScriptModel.deleted_at.is_(None),
+                    ),
+                )
+                .filter(
+                    ScriptModel.organization_id == organization_id,
+                    ScriptModel.script_id.in_(script_ids),
+                )
+                .group_by(ScriptModel.script_id)
+            )
+            rows = (await session.execute(query)).all()
+            return {row[0]: (row[1], row[2]) for row in rows}
+
+    @db_operation("soft_delete_script_by_revision")
+    async def soft_delete_script_by_revision(self, script_revision_id: str, organization_id: str) -> None:
+        async with self.Session() as session:
+            await session.execute(
+                update(ScriptModel)
+                .filter_by(script_revision_id=script_revision_id)
+                .filter_by(organization_id=organization_id)
+                .values(deleted_at=datetime.now(timezone.utc))
+            )
+            await session.commit()
+
+    @db_operation("create_script_file")
+    async def create_script_file(
+        self,
+        script_revision_id: str,
+        script_id: str,
+        organization_id: str,
+        file_path: str,
+        file_name: str,
+        file_type: str,
+        content_hash: str | None = None,
+        file_size: int | None = None,
+        mime_type: str | None = None,
+        encoding: str = "utf-8",
+        artifact_id: str | None = None,
+    ) -> ScriptFile:
+        """Create a script file."""
+        async with self.Session() as session:
+            script_file = ScriptFileModel(
+                script_revision_id=script_revision_id,
+                script_id=script_id,
+                organization_id=organization_id,
+                file_path=file_path,
+                file_name=file_name,
+                file_type=file_type,
+                content_hash=content_hash,
+                file_size=file_size,
+                mime_type=mime_type,
+                encoding=encoding,
+                artifact_id=artifact_id,
+            )
+            session.add(script_file)
+            await session.commit()
+            await session.refresh(script_file)
+            return convert_to_script_file(script_file)
+
+    @db_operation("create_script_block")
+    async def create_script_block(
+        self,
+        script_revision_id: str,
+        script_id: str,
+        organization_id: str,
+        script_block_label: str,
+        script_file_id: str | None = None,
+        run_signature: str | None = None,
+        workflow_run_id: str | None = None,
+        workflow_run_block_id: str | None = None,
+        input_fields: list[str] | None = None,
+        requires_agent: bool = False,
+    ) -> ScriptBlock:
+        """Create a script block."""
+        async with self.Session() as session:
+            script_block = ScriptBlockModel(
+                script_revision_id=script_revision_id,
+                script_id=script_id,
+                organization_id=organization_id,
+                script_block_label=script_block_label,
+                script_file_id=script_file_id,
+                run_signature=run_signature,
+                workflow_run_id=workflow_run_id,
+                workflow_run_block_id=workflow_run_block_id,
+                input_fields=input_fields,
+                requires_agent=requires_agent,
+            )
+            session.add(script_block)
+            await session.commit()
+            await session.refresh(script_block)
+            return convert_to_script_block(script_block)
+
+    @db_operation("update_script_block")
+    async def update_script_block(
+        self,
+        script_block_id: str,
+        organization_id: str,
+        script_file_id: str | None = None,
+        run_signature: str | None = None,
+        workflow_run_id: str | None = None,
+        workflow_run_block_id: str | None = None,
+        clear_run_signature: bool = False,
+        input_fields: list[str] | None = None,
+        requires_agent: bool | None = None,
+    ) -> ScriptBlock:
+        async with self.Session() as session:
+            script_block = (
+                await session.scalars(
+                    select(ScriptBlockModel)
+                    .filter_by(script_block_id=script_block_id)
+                    .filter_by(organization_id=organization_id)
+                )
+            ).first()
+            if script_block:
+                if script_file_id is not None:
+                    script_block.script_file_id = script_file_id
+                if clear_run_signature:
+                    script_block.run_signature = None
+                elif run_signature is not None:
+                    script_block.run_signature = run_signature
+                if workflow_run_id is not None:
+                    script_block.workflow_run_id = workflow_run_id
+                if workflow_run_block_id is not None:
+                    script_block.workflow_run_block_id = workflow_run_block_id
+                if input_fields is not None:
+                    script_block.input_fields = input_fields
+                if requires_agent is not None:
+                    script_block.requires_agent = requires_agent
+                await session.commit()
+                await session.refresh(script_block)
+                return convert_to_script_block(script_block)
+            else:
+                raise NotFoundError("Script block not found")
+
+    @db_operation("get_script_files")
+    async def get_script_files(self, script_revision_id: str, organization_id: str) -> list[ScriptFile]:
+        async with self.Session() as session:
+            script_files = (
+                await session.scalars(
+                    select(ScriptFileModel)
+                    .filter_by(script_revision_id=script_revision_id)
+                    .filter_by(organization_id=organization_id)
+                )
+            ).all()
+            return [convert_to_script_file(script_file) for script_file in script_files]
+
+    @db_operation("get_script_file_by_id")
+    async def get_script_file_by_id(
+        self,
+        script_revision_id: str,
+        file_id: str,
+        organization_id: str,
+    ) -> ScriptFile | None:
+        async with self.Session() as session:
+            script_file = (
+                await session.scalars(
+                    select(ScriptFileModel)
+                    .filter_by(script_revision_id=script_revision_id)
+                    .filter_by(file_id=file_id)
+                    .filter_by(organization_id=organization_id)
+                )
+            ).first()
+
+            return convert_to_script_file(script_file) if script_file else None
+
+    @db_operation("get_script_file_by_path")
+    async def get_script_file_by_path(
+        self,
+        script_revision_id: str,
+        file_path: str,
+        organization_id: str,
+    ) -> ScriptFile | None:
+        async with self.Session() as session:
+            script_file = (
+                await session.scalars(
+                    select(ScriptFileModel)
+                    .filter_by(script_revision_id=script_revision_id)
+                    .filter_by(file_path=file_path)
+                    .filter_by(organization_id=organization_id)
+                )
+            ).first()
+            return convert_to_script_file(script_file) if script_file else None
+
+    @db_operation("update_script_file")
+    async def update_script_file(
+        self,
+        script_file_id: str,
+        organization_id: str,
+        artifact_id: str | None = None,
+    ) -> ScriptFile:
+        async with self.Session() as session:
+            script_file = (
+                await session.scalars(
+                    select(ScriptFileModel).filter_by(file_id=script_file_id).filter_by(organization_id=organization_id)
+                )
+            ).first()
+            if script_file:
+                if artifact_id:
+                    script_file.artifact_id = artifact_id
+                await session.commit()
+                await session.refresh(script_file)
+                return convert_to_script_file(script_file)
+            else:
+                raise NotFoundError("Script file not found")
+
+    @db_operation("get_script_block")
+    async def get_script_block(
+        self,
+        script_block_id: str,
+        organization_id: str,
+    ) -> ScriptBlock | None:
+        async with self.Session() as session:
+            record = (
+                await session.scalars(
+                    select(ScriptBlockModel)
+                    .filter_by(script_block_id=script_block_id)
+                    .filter_by(organization_id=organization_id)
+                )
+            ).first()
+            return convert_to_script_block(record) if record else None
+
+    @db_operation("get_script_block_by_label")
+    async def get_script_block_by_label(
+        self,
+        organization_id: str,
+        script_revision_id: str,
+        script_block_label: str,
+    ) -> ScriptBlock | None:
+        async with self.Session() as session:
+            record = (
+                await session.scalars(
+                    select(ScriptBlockModel)
+                    .filter_by(script_revision_id=script_revision_id)
+                    .filter_by(script_block_label=script_block_label)
+                    .filter_by(organization_id=organization_id)
+                )
+            ).first()
+            return convert_to_script_block(record) if record else None
+
+    @db_operation("get_script_blocks_by_script_revision_id")
+    async def get_script_blocks_by_script_revision_id(
+        self,
+        script_revision_id: str,
+        organization_id: str,
+    ) -> list[ScriptBlock]:
+        async with self.Session() as session:
+            records = (
+                await session.scalars(
+                    select(ScriptBlockModel)
+                    .filter_by(script_revision_id=script_revision_id)
+                    .filter_by(organization_id=organization_id)
+                    .order_by(ScriptBlockModel.created_at.asc())
+                )
+            ).all()
+            return [convert_to_script_block(record) for record in records]
+
+    @db_operation("create_workflow_script")
+    async def create_workflow_script(
+        self,
+        *,
+        organization_id: str,
+        script_id: str,
+        workflow_permanent_id: str,
+        cache_key: str,
+        cache_key_value: str,
+        workflow_id: str | None = None,
+        workflow_run_id: str | None = None,
+        status: ScriptStatus = ScriptStatus.published,
+    ) -> None:
+        """Create a workflow->script cache mapping entry."""
+        async with self.Session() as session:
+            record = WorkflowScriptModel(
+                organization_id=organization_id,
+                script_id=script_id,
+                workflow_permanent_id=workflow_permanent_id,
+                workflow_id=workflow_id,
+                workflow_run_id=workflow_run_id,
+                cache_key=cache_key,
+                cache_key_value=cache_key_value,
+                status=status,
+            )
+            session.add(record)
+            await session.commit()
+
+    @db_operation("get_workflow_script")
+    async def get_workflow_script(
+        self,
+        organization_id: str,
+        workflow_permanent_id: str,
+        workflow_run_id: str,
+        statuses: list[ScriptStatus] | None = None,
+    ) -> WorkflowScript | None:
+        async with self.Session() as session:
+            query = (
+                select(WorkflowScriptModel)
+                .filter_by(organization_id=organization_id)
+                .filter_by(workflow_permanent_id=workflow_permanent_id)
+                .filter_by(workflow_run_id=workflow_run_id)
+            )
+            if statuses:
+                query = query.filter(WorkflowScriptModel.status.in_(statuses))
+            workflow_script_model = (await session.scalars(query)).first()
+            return WorkflowScript.model_validate(workflow_script_model) if workflow_script_model else None
+
+    @db_operation("get_workflow_script_by_cache_key_value")
+    async def get_workflow_script_by_cache_key_value(
+        self,
+        *,
+        organization_id: str,
+        workflow_permanent_id: str,
+        cache_key_value: str,
+        workflow_run_id: str | None = None,
+        cache_key: str | None = None,
+        statuses: list[ScriptStatus] | None = None,
+    ) -> Script | None:
+        """Get latest script version linked to a workflow by a specific cache_key_value."""
+        async with self.Session() as session:
+            # Build the query: join workflow_scripts with scripts
+            # Join on both script_id and organization_id to leverage uc_org_script_version index
+            query = (
+                select(ScriptModel)
+                .join(
+                    WorkflowScriptModel,
+                    and_(
+                        ScriptModel.organization_id == WorkflowScriptModel.organization_id,
+                        ScriptModel.script_id == WorkflowScriptModel.script_id,
+                    ),
+                )
+                .where(
+                    WorkflowScriptModel.organization_id == organization_id,
+                    WorkflowScriptModel.workflow_permanent_id == workflow_permanent_id,
+                    WorkflowScriptModel.cache_key_value == cache_key_value,
+                    WorkflowScriptModel.deleted_at.is_(None),
+                )
+            )
+
+            if workflow_run_id:
+                query = query.where(WorkflowScriptModel.workflow_run_id == workflow_run_id)
+
+            if cache_key is not None:
+                query = query.where(WorkflowScriptModel.cache_key == cache_key)
+
+            if statuses is not None and len(statuses) > 0:
+                query = query.where(WorkflowScriptModel.status.in_(statuses))
+
+            query = query.order_by(ScriptModel.created_at.desc(), ScriptModel.version.desc()).limit(1)
+
+            script = (await session.scalars(query)).first()
+            return convert_to_script(script) if script else None
+
+    @db_operation("get_workflow_cache_key_count")
+    async def get_workflow_cache_key_count(
+        self,
+        organization_id: str,
+        workflow_permanent_id: str,
+        cache_key: str,
+        filter: str | None = None,
+    ) -> int:
+        async with self.Session() as session:
+            query = (
+                select(func.count())
+                .select_from(WorkflowScriptModel)
+                .filter_by(organization_id=organization_id)
+                .filter_by(workflow_permanent_id=workflow_permanent_id)
+                .filter_by(cache_key=cache_key)
+                .filter_by(deleted_at=None)
+                .filter_by(status="published")
+            )
+
+            if filter:
+                query = query.filter(WorkflowScriptModel.cache_key_value.contains(filter))
+
+            return (await session.execute(query)).scalar_one()
+
+    @db_operation("get_workflow_cache_key_values")
+    async def get_workflow_cache_key_values(
+        self,
+        organization_id: str,
+        workflow_permanent_id: str,
+        cache_key: str,
+        page: int = 1,
+        page_size: int = 100,
+        filter: str | None = None,
+    ) -> list[str]:
+        async with self.Session() as session:
+            query = (
+                select(WorkflowScriptModel.cache_key_value)
+                .order_by(WorkflowScriptModel.cache_key_value.asc())
+                .filter_by(organization_id=organization_id)
+                .filter_by(workflow_permanent_id=workflow_permanent_id)
+                .filter_by(cache_key=cache_key)
+                .filter_by(deleted_at=None)
+                .filter_by(status="published")
+                .offset((page - 1) * page_size)
+                .limit(page_size)
+            )
+
+            if filter:
+                query = query.filter(WorkflowScriptModel.cache_key_value.contains(filter))
+
+            return (await session.scalars(query)).all()
+
+    @db_operation("delete_workflow_cache_key_value")
+    async def delete_workflow_cache_key_value(
+        self,
+        organization_id: str,
+        workflow_permanent_id: str,
+        cache_key_value: str,
+    ) -> bool:
+        """
+        Soft delete workflow cache key values by setting deleted_at timestamp.
+
+        Returns True if any records were deleted, False otherwise.
+        """
+        async with self.Session() as session:
+            stmt = (
+                update(WorkflowScriptModel)
+                .where(
+                    and_(
+                        WorkflowScriptModel.organization_id == organization_id,
+                        WorkflowScriptModel.workflow_permanent_id == workflow_permanent_id,
+                        WorkflowScriptModel.cache_key_value == cache_key_value,
+                        WorkflowScriptModel.deleted_at.is_(None),
+                    )
+                )
+                .values(deleted_at=datetime.now(timezone.utc))
+            )
+
+            result = await session.execute(stmt)
+            await session.commit()
+
+            return result.rowcount > 0
+
+    @db_operation("delete_workflow_scripts_by_permanent_id")
+    async def delete_workflow_scripts_by_permanent_id(
+        self,
+        organization_id: str,
+        workflow_permanent_id: str,
+        statuses: list[ScriptStatus] | None = None,
+        script_ids: list[str] | None = None,
+    ) -> int:
+        """
+        Soft delete all published workflow scripts for a workflow permanent id by setting deleted_at timestamp.
+
+        Returns True if any records were deleted, False otherwise.
+        """
+        async with self.Session() as session:
+            stmt = (
+                update(WorkflowScriptModel)
+                .where(
+                    and_(
+                        WorkflowScriptModel.organization_id == organization_id,
+                        WorkflowScriptModel.workflow_permanent_id == workflow_permanent_id,
+                        WorkflowScriptModel.deleted_at.is_(None),
+                    )
+                )
+                .values(deleted_at=datetime.now(timezone.utc))
+            )
+
+            if statuses:
+                stmt = stmt.where(WorkflowScriptModel.status.in_([s.value for s in statuses]))
+
+            if script_ids:
+                stmt = stmt.where(WorkflowScriptModel.script_id.in_(script_ids))
+
+            result = await session.execute(stmt)
+            await session.commit()
+
+            return result.rowcount
+
+    @db_operation("get_workflow_scripts_by_permanent_id")
+    async def get_workflow_scripts_by_permanent_id(
+        self,
+        organization_id: str,
+        workflow_permanent_id: str,
+        statuses: list[ScriptStatus] | None = None,
+    ) -> list[WorkflowScriptModel]:
+        async with self.Session() as session:
+            query = (
+                select(WorkflowScriptModel)
+                .filter_by(organization_id=organization_id)
+                .filter_by(workflow_permanent_id=workflow_permanent_id)
+                .filter_by(deleted_at=None)
+            )
+
+            if statuses:
+                query = query.filter(WorkflowScriptModel.status.in_([s.value for s in statuses]))
+
+            query = query.order_by(WorkflowScriptModel.modified_at.desc())
+            return (await session.scalars(query)).all()
+
+    # -- Script Run / Stats ------------------------------------------------
+
+    @db_operation("get_workflow_runs_for_script")
+    async def get_workflow_runs_for_script(
+        self,
+        organization_id: str,
+        script_id: str,
+        page_size: int = 50,
+        created_after: datetime | None = None,
+        created_before: datetime | None = None,
+    ) -> tuple[list[WorkflowRunModel], int, dict[str, int]]:
+        """Get workflow runs associated with a script, with total count and status counts.
+
+        Returns (runs, total_count, status_counts) where runs is limited by page_size,
+        total_count is derived from the status_counts GROUP BY, and status_counts is a
+        GROUP BY aggregation of statuses across all runs.
+
+        If created_after/created_before are provided, filters by the workflow_script
+        entry's created_at (not the run's created_at), scoping to the version that
+        was active in that time window.
+        """
+        async with self.Session() as session:
+            # Subquery: distinct run IDs for this script
+            run_ids_subquery = (
+                select(distinct(WorkflowScriptModel.workflow_run_id))
+                .filter_by(organization_id=organization_id, script_id=script_id)
+                .filter(WorkflowScriptModel.deleted_at.is_(None))
+                .filter(WorkflowScriptModel.workflow_run_id.isnot(None))
+            )
+
+            # Time-window filters scope by workflow_script creation time,
+            # which aligns with the script version that was created/used.
+            if created_after is not None:
+                run_ids_subquery = run_ids_subquery.filter(
+                    WorkflowScriptModel.created_at >= created_after,
+                )
+            if created_before is not None:
+                run_ids_subquery = run_ids_subquery.filter(
+                    WorkflowScriptModel.created_at < created_before,
+                )
+
+            # Base filter for workflow runs
+            base_filters = [
+                WorkflowRunModel.workflow_run_id.in_(run_ids_subquery),
+                WorkflowRunModel.organization_id == organization_id,
+            ]
+
+            # Count statuses via GROUP BY (also gives us total_count)
+            status_query = (
+                select(WorkflowRunModel.status, func.count()).filter(*base_filters).group_by(WorkflowRunModel.status)
+            )
+            status_counts = {(s or "unknown"): c for s, c in (await session.execute(status_query)).all()}
+            total_count = sum(status_counts.values())
+
+            if total_count == 0:
+                return [], 0, {}
+
+            # Get the actual workflow runs (paginated)
+            runs_query = (
+                select(WorkflowRunModel)
+                .filter(*base_filters)
+                .order_by(WorkflowRunModel.created_at.desc())
+                .limit(page_size)
+            )
+            runs = list((await session.scalars(runs_query)).all())
+
+            return runs, total_count, status_counts
+
+    @db_operation("get_script_run_stats")
+    async def get_script_run_stats(
+        self,
+        organization_id: str,
+        script_ids: list[str],
+    ) -> dict[str, tuple[float | None, int]]:
+        """Get success rate and total run count for each script_id.
+
+        Both metrics are computed from the same population (workflow_scripts joined
+        to workflow_runs), so they are always consistent.
+
+        Returns a dict mapping script_id -> (success_rate, total_runs) where
+        success_rate is 0.0-1.0 or None if no runs.
+        """
+        if not script_ids:
+            return {}
+        async with self.Session() as session:
+            # Join workflow_scripts -> workflow_runs, group by script_id and status
+            query = (
+                select(
+                    WorkflowScriptModel.script_id,
+                    WorkflowRunModel.status,
+                    func.count(distinct(WorkflowRunModel.workflow_run_id)),
+                )
+                .join(
+                    WorkflowRunModel,
+                    WorkflowScriptModel.workflow_run_id == WorkflowRunModel.workflow_run_id,
+                )
+                .filter(
+                    WorkflowScriptModel.organization_id == organization_id,
+                    WorkflowScriptModel.script_id.in_(script_ids),
+                    WorkflowScriptModel.deleted_at.is_(None),
+                    WorkflowScriptModel.workflow_run_id.isnot(None),
+                    WorkflowRunModel.organization_id == organization_id,
+                )
+                .group_by(WorkflowScriptModel.script_id, WorkflowRunModel.status)
+            )
+            rows = (await session.execute(query)).all()
+
+            # Aggregate per script_id
+            totals: dict[str, int] = {}
+            completed: dict[str, int] = {}
+            for sid, status, count in rows:
+                totals[sid] = totals.get(sid, 0) + count
+                if status == "completed":
+                    completed[sid] = completed.get(sid, 0) + count
+
+            return {
+                sid: (
+                    (completed.get(sid, 0) / totals[sid]) if totals.get(sid) else None,
+                    totals.get(sid, 0),
+                )
+                for sid in script_ids
+            }
+
+    # -- Script Pinning ----------------------------------------------------
+
+    @db_operation("is_script_pinned")
+    async def is_script_pinned(
+        self,
+        organization_id: str,
+        script_id: str,
+    ) -> bool:
+        """Check if any active workflow_script row for this script_id is pinned."""
+        async with self.Session() as session:
+            query = (
+                select(WorkflowScriptModel.is_pinned)
+                .where(
+                    WorkflowScriptModel.organization_id == organization_id,
+                    WorkflowScriptModel.script_id == script_id,
+                    WorkflowScriptModel.is_pinned.is_(True),
+                    WorkflowScriptModel.deleted_at.is_(None),
+                )
+                .limit(1)
+            )
+            result = await session.scalars(query)
+            return result.first() is not None
+
+    @db_operation("pin_workflow_script")
+    async def pin_workflow_script(
+        self,
+        organization_id: str,
+        workflow_permanent_id: str,
+        cache_key_value: str,
+        pinned_by: str | None = None,
+    ) -> WorkflowScriptModel | None:
+        """Pin all workflow scripts for a given cache key value."""
+        async with self.Session() as session:
+            stmt = (
+                update(WorkflowScriptModel)
+                .where(
+                    WorkflowScriptModel.organization_id == organization_id,
+                    WorkflowScriptModel.workflow_permanent_id == workflow_permanent_id,
+                    WorkflowScriptModel.cache_key_value == cache_key_value,
+                    WorkflowScriptModel.deleted_at.is_(None),
+                )
+                .values(
+                    is_pinned=True,
+                    pinned_at=datetime.now(timezone.utc),
+                    pinned_by=pinned_by,
+                )
+            )
+            await session.execute(stmt)
+            await session.commit()
+
+            # Return the first updated model for the response
+            query = (
+                select(WorkflowScriptModel)
+                .filter_by(organization_id=organization_id)
+                .filter_by(workflow_permanent_id=workflow_permanent_id)
+                .filter_by(cache_key_value=cache_key_value)
+                .filter_by(deleted_at=None)
+                .limit(1)
+            )
+            result = await session.scalars(query)
+            return result.first()
+
+    @db_operation("unpin_workflow_script")
+    async def unpin_workflow_script(
+        self,
+        organization_id: str,
+        workflow_permanent_id: str,
+        cache_key_value: str,
+    ) -> WorkflowScriptModel | None:
+        """Unpin workflow scripts for a given cache key value."""
+        async with self.Session() as session:
+            stmt = (
+                update(WorkflowScriptModel)
+                .where(
+                    WorkflowScriptModel.organization_id == organization_id,
+                    WorkflowScriptModel.workflow_permanent_id == workflow_permanent_id,
+                    WorkflowScriptModel.cache_key_value == cache_key_value,
+                    WorkflowScriptModel.deleted_at.is_(None),
+                )
+                .values(
+                    is_pinned=False,
+                    pinned_at=None,
+                    pinned_by=None,
+                )
+            )
+            await session.execute(stmt)
+            await session.commit()
+
+            # Return the first updated model for the response
+            query = (
+                select(WorkflowScriptModel)
+                .filter_by(organization_id=organization_id)
+                .filter_by(workflow_permanent_id=workflow_permanent_id)
+                .filter_by(cache_key_value=cache_key_value)
+                .filter_by(deleted_at=None)
+                .limit(1)
+            )
+            result = await session.scalars(query)
+            return result.first()
+
+    # -- Script Fallback Episode CRUD --------------------------------------
+
+    @db_operation("create_fallback_episode")
+    async def create_fallback_episode(
+        self,
+        organization_id: str,
+        workflow_permanent_id: str,
+        workflow_run_id: str,
+        block_label: str,
+        fallback_type: str,
+        script_revision_id: str | None = None,
+        error_message: str | None = None,
+        classify_result: str | None = None,
+        agent_actions: list | dict | None = None,
+        page_url: str | None = None,
+        page_text_snapshot: str | None = None,
+    ) -> ScriptFallbackEpisode:
+        async with self.Session() as session:
+            episode = ScriptFallbackEpisodeModel(
+                organization_id=organization_id,
+                workflow_permanent_id=workflow_permanent_id,
+                workflow_run_id=workflow_run_id,
+                block_label=block_label,
+                fallback_type=fallback_type,
+                script_revision_id=script_revision_id,
+                error_message=sanitize_postgres_text(error_message) if error_message else None,
+                classify_result=sanitize_postgres_text(classify_result) if classify_result else None,
+                agent_actions=agent_actions,
+                page_url=sanitize_postgres_text(page_url) if page_url else None,
+                page_text_snapshot=sanitize_postgres_text(page_text_snapshot) if page_text_snapshot else None,
+            )
+            session.add(episode)
+            await session.commit()
+            await session.refresh(episode)
+            return ScriptFallbackEpisode.model_validate(episode)
+
+    @db_operation("get_unreviewed_episodes")
+    async def get_unreviewed_episodes(
+        self,
+        workflow_permanent_id: str,
+        organization_id: str,
+        limit: int = 100,
+        script_revision_id: str | None = None,
+    ) -> list[ScriptFallbackEpisode]:
+        async with self.Session() as session:
+            query = (
+                select(ScriptFallbackEpisodeModel)
+                .filter_by(
+                    organization_id=organization_id,
+                    workflow_permanent_id=workflow_permanent_id,
+                    reviewed=False,
+                )
+                .order_by(ScriptFallbackEpisodeModel.created_at.asc())
+                .limit(limit)
+            )
+            if script_revision_id:
+                query = query.filter_by(script_revision_id=script_revision_id)
+            episodes = (await session.scalars(query)).all()
+            return [ScriptFallbackEpisode.model_validate(e) for e in episodes]
+
+    @db_operation("update_fallback_episode")
+    async def update_fallback_episode(
+        self,
+        episode_id: str,
+        organization_id: str,
+        agent_actions: list | dict | None = None,
+        fallback_succeeded: bool | None = None,
+    ) -> None:
+        values: dict = {}
+        if agent_actions is not None:
+            values["agent_actions"] = agent_actions
+        if fallback_succeeded is not None:
+            values["fallback_succeeded"] = fallback_succeeded
+        if not values:
+            return
+        values["modified_at"] = datetime.now(timezone.utc)
+        async with self.Session() as session:
+            await session.execute(
+                update(ScriptFallbackEpisodeModel)
+                .where(ScriptFallbackEpisodeModel.episode_id == episode_id)
+                .where(ScriptFallbackEpisodeModel.organization_id == organization_id)
+                .values(**values)
+            )
+            await session.commit()
+
+    @db_operation("delete_fallback_episode")
+    async def delete_fallback_episode(
+        self,
+        episode_id: str,
+        organization_id: str,
+    ) -> None:
+        async with self.Session() as session:
+            await session.execute(
+                delete(ScriptFallbackEpisodeModel)
+                .where(ScriptFallbackEpisodeModel.episode_id == episode_id)
+                .where(ScriptFallbackEpisodeModel.organization_id == organization_id)
+            )
+            await session.commit()
+
+    @db_operation("get_fallback_episodes")
+    async def get_fallback_episodes(
+        self,
+        organization_id: str,
+        workflow_permanent_id: str,
+        page: int = 1,
+        page_size: int = 20,
+        workflow_run_id: str | None = None,
+        block_label: str | None = None,
+        reviewed: bool | None = None,
+        fallback_type: str | None = None,
+    ) -> list[ScriptFallbackEpisode]:
+        async with self.Session() as session:
+            query = select(ScriptFallbackEpisodeModel).filter(
+                ScriptFallbackEpisodeModel.organization_id == organization_id,
+                ScriptFallbackEpisodeModel.workflow_permanent_id == workflow_permanent_id,
+            )
+            if workflow_run_id is not None:
+                query = query.filter(ScriptFallbackEpisodeModel.workflow_run_id == workflow_run_id)
+            if block_label is not None:
+                query = query.filter(ScriptFallbackEpisodeModel.block_label == block_label)
+            if reviewed is not None:
+                query = query.filter(ScriptFallbackEpisodeModel.reviewed == reviewed)
+            if fallback_type is not None:
+                query = query.filter(ScriptFallbackEpisodeModel.fallback_type == fallback_type)
+
+            offset = (page - 1) * page_size
+            query = query.order_by(ScriptFallbackEpisodeModel.created_at.desc()).limit(page_size).offset(offset)
+
+            result = await session.scalars(query)
+            return [ScriptFallbackEpisode.model_validate(row) for row in result.all()]
+
+    @db_operation("get_fallback_episodes_count")
+    async def get_fallback_episodes_count(
+        self,
+        organization_id: str,
+        workflow_permanent_id: str | None = None,
+        workflow_run_id: str | None = None,
+        block_label: str | None = None,
+        reviewed: bool | None = None,
+        fallback_type: str | None = None,
+        script_revision_id: str | None = None,
+    ) -> int:
+        """Count fallback episodes matching the given filters.
+
+        At least one scoping filter (workflow_permanent_id, workflow_run_id,
+        or script_revision_id) should be provided. Without any, this returns
+        the total count for the entire organization which is rarely intended.
+        """
+        if workflow_permanent_id is None and workflow_run_id is None and script_revision_id is None:
+            LOG.warning(
+                "get_fallback_episodes_count called without any scoping filter",
+                organization_id=organization_id,
+            )
+        async with self.Session() as session:
+            query = (
+                select(func.count())
+                .select_from(ScriptFallbackEpisodeModel)
+                .filter(
+                    ScriptFallbackEpisodeModel.organization_id == organization_id,
+                )
+            )
+            if workflow_permanent_id is not None:
+                query = query.filter(ScriptFallbackEpisodeModel.workflow_permanent_id == workflow_permanent_id)
+            if workflow_run_id is not None:
+                query = query.filter(ScriptFallbackEpisodeModel.workflow_run_id == workflow_run_id)
+            if block_label is not None:
+                query = query.filter(ScriptFallbackEpisodeModel.block_label == block_label)
+            if reviewed is not None:
+                query = query.filter(ScriptFallbackEpisodeModel.reviewed == reviewed)
+            if fallback_type is not None:
+                query = query.filter(ScriptFallbackEpisodeModel.fallback_type == fallback_type)
+            if script_revision_id is not None:
+                query = query.filter(ScriptFallbackEpisodeModel.script_revision_id == script_revision_id)
+
+            result = await session.scalar(query)
+            return result or 0
+
+    @db_operation("get_fallback_episode")
+    async def get_fallback_episode(
+        self,
+        episode_id: str,
+        organization_id: str,
+    ) -> ScriptFallbackEpisode | None:
+        async with self.Session() as session:
+            query = select(ScriptFallbackEpisodeModel).filter(
+                ScriptFallbackEpisodeModel.episode_id == episode_id,
+                ScriptFallbackEpisodeModel.organization_id == organization_id,
+            )
+            result = await session.scalar(query)
+            if result:
+                return ScriptFallbackEpisode.model_validate(result)
+            return None
+
+    @db_operation("mark_episode_reviewed")
+    async def mark_episode_reviewed(
+        self,
+        episode_id: str,
+        organization_id: str,
+        reviewer_output: str | None = None,
+        new_script_revision_id: str | None = None,
+    ) -> None:
+        async with self.Session() as session:
+            await session.execute(
+                update(ScriptFallbackEpisodeModel)
+                .where(ScriptFallbackEpisodeModel.episode_id == episode_id)
+                .where(ScriptFallbackEpisodeModel.organization_id == organization_id)
+                .values(
+                    reviewed=True,
+                    reviewer_output=sanitize_postgres_text(reviewer_output) if reviewer_output else None,
+                    new_script_revision_id=new_script_revision_id,
+                    modified_at=datetime.now(timezone.utc),
+                )
+            )
+            await session.commit()
+
+    @db_operation("get_recent_reviewed_episodes")
+    async def get_recent_reviewed_episodes(
+        self,
+        workflow_permanent_id: str,
+        organization_id: str,
+        limit: int = 20,
+    ) -> list[ScriptFallbackEpisode]:
+        """Return recently reviewed episodes for cross-run historical context.
+
+        These give the reviewer visibility into past failures and fixes so it can
+        avoid repeating the same mistakes.
+        """
+        async with self.Session() as session:
+            query = (
+                select(ScriptFallbackEpisodeModel)
+                .filter_by(
+                    organization_id=organization_id,
+                    workflow_permanent_id=workflow_permanent_id,
+                    reviewed=True,
+                )
+                .order_by(ScriptFallbackEpisodeModel.created_at.desc())
+                .limit(limit)
+            )
+            episodes = (await session.scalars(query)).all()
+            return [ScriptFallbackEpisode.model_validate(e) for e in episodes]
+
+    @db_operation("record_branch_hit")
+    async def record_branch_hit(
+        self,
+        organization_id: str,
+        workflow_permanent_id: str,
+        block_label: str,
+        branch_key: str,
+    ) -> None:
+        """Record a classify branch hit, upserting the hit count and last_hit_at."""
+        now = datetime.now(timezone.utc)
+        async with self.Session() as session:
+            stmt = insert(ScriptBranchHitModel).values(
+                organization_id=organization_id,
+                workflow_permanent_id=workflow_permanent_id,
+                block_label=block_label,
+                branch_key=branch_key,
+                hit_count=1,
+                first_hit_at=now,
+                last_hit_at=now,
+            )
+            stmt = stmt.on_conflict_do_update(
+                index_elements=[
+                    "organization_id",
+                    "workflow_permanent_id",
+                    "block_label",
+                    "branch_key",
+                ],
+                set_={
+                    "hit_count": ScriptBranchHitModel.hit_count + 1,
+                    "last_hit_at": now,
+                },
+            )
+            await session.execute(stmt)
+            await session.commit()
+
+    @db_operation("get_stale_branches")
+    async def get_stale_branches(
+        self,
+        organization_id: str,
+        workflow_permanent_id: str,
+        stale_days: int = 90,
+        limit: int = 200,
+    ) -> list[ScriptBranchHit]:
+        """Get branches that haven't been accessed in stale_days days."""
+        cutoff = datetime.now(timezone.utc) - timedelta(days=stale_days)
+        async with self.Session() as session:
+            query = (
+                select(ScriptBranchHitModel)
+                .filter_by(
+                    organization_id=organization_id,
+                    workflow_permanent_id=workflow_permanent_id,
+                )
+                .filter(ScriptBranchHitModel.last_hit_at < cutoff)
+                .order_by(ScriptBranchHitModel.last_hit_at.asc())
+                .limit(limit)
+            )
+            results = (await session.scalars(query)).all()
+            return [ScriptBranchHit.model_validate(r) for r in results]
diff --git a/skyvern/forge/sdk/db/repositories/tasks.py b/skyvern/forge/sdk/db/repositories/tasks.py
new file mode 100644
index 000000000..4493bcc42
--- /dev/null
+++ b/skyvern/forge/sdk/db/repositories/tasks.py
@@ -0,0 +1,727 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from typing import Any, Sequence
+
+import structlog
+from sqlalchemy import and_, delete, distinct, func, select, tuple_, update
+
+from skyvern.forge.sdk.db._error_handling import db_operation
+from skyvern.forge.sdk.db.base_alchemy_db import read_retry
+from skyvern.forge.sdk.db.base_repository import BaseRepository
+from skyvern.forge.sdk.db.enums import TaskType
+from skyvern.forge.sdk.db.exceptions import NotFoundError
+from skyvern.forge.sdk.db.models import (
+    ActionModel,
+    StepModel,
+    TaskModel,
+    WorkflowRunModel,
+)
+from skyvern.forge.sdk.db.utils import convert_to_step, convert_to_task, hydrate_action, serialize_proxy_location
+from skyvern.forge.sdk.models import Step, StepStatus
+from skyvern.forge.sdk.schemas.tasks import OrderBy, SortDirection, Task, TaskStatus
+from skyvern.forge.sdk.utils.sanitization import sanitize_postgres_text
+from skyvern.schemas.runs import ProxyLocationInput
+from skyvern.schemas.steps import AgentStepOutput
+from skyvern.webeye.actions.actions import Action
+
+LOG = structlog.get_logger()
+
+
+class TasksRepository(BaseRepository):
+    @db_operation("create_task")
+    async def create_task(
+        self,
+        url: str,
+        title: str | None,
+        navigation_goal: str | None,
+        data_extraction_goal: str | None,
+        navigation_payload: dict[str, Any] | list | str | None,
+        status: str = "created",
+        complete_criterion: str | None = None,
+        terminate_criterion: str | None = None,
+        webhook_callback_url: str | None = None,
+        totp_verification_url: str | None = None,
+        totp_identifier: str | None = None,
+        organization_id: str | None = None,
+        proxy_location: ProxyLocationInput = None,
+        extracted_information_schema: dict[str, Any] | list | str | None = None,
+        workflow_run_id: str | None = None,
+        order: int | None = None,
+        retry: int | None = None,
+        max_steps_per_run: int | None = None,
+        error_code_mapping: dict[str, str] | None = None,
+        task_type: str = TaskType.general,
+        application: str | None = None,
+        include_action_history_in_verification: bool | None = None,
+        model: dict[str, Any] | None = None,
+        max_screenshot_scrolling_times: int | None = None,
+        extra_http_headers: dict[str, str] | None = None,
+        browser_session_id: str | None = None,
+        browser_address: str | None = None,
+        download_timeout: float | None = None,
+    ) -> Task:
+        # Sanitize text fields to remove NUL bytes and control characters
+        # that PostgreSQL cannot store in text columns
+        def _sanitize(v: str | None) -> str | None:
+            return sanitize_postgres_text(v) if isinstance(v, str) else v
+
+        navigation_goal = _sanitize(navigation_goal)
+        data_extraction_goal = _sanitize(data_extraction_goal)
+        title = _sanitize(title)
+        url = sanitize_postgres_text(url)
+        complete_criterion = _sanitize(complete_criterion)
+        terminate_criterion = _sanitize(terminate_criterion)
+
+        async with self.Session() as session:
+            new_task = TaskModel(
+                status=status,
+                task_type=task_type,
+                url=url,
+                title=title,
+                webhook_callback_url=webhook_callback_url,
+                totp_verification_url=totp_verification_url,
+                totp_identifier=totp_identifier,
+                navigation_goal=navigation_goal,
+                complete_criterion=complete_criterion,
+                terminate_criterion=terminate_criterion,
+                data_extraction_goal=data_extraction_goal,
+                navigation_payload=navigation_payload,
+                organization_id=organization_id,
+                proxy_location=serialize_proxy_location(proxy_location),
+                extracted_information_schema=extracted_information_schema,
+                workflow_run_id=workflow_run_id,
+                order=order,
+                retry=retry,
+                max_steps_per_run=max_steps_per_run,
+                error_code_mapping=error_code_mapping,
+                application=application,
+                include_action_history_in_verification=include_action_history_in_verification,
+                model=model,
+                max_screenshot_scrolling_times=max_screenshot_scrolling_times,
+                extra_http_headers=extra_http_headers,
+                browser_session_id=browser_session_id,
+                browser_address=browser_address,
+                download_timeout=download_timeout,
+            )
+            session.add(new_task)
+            await session.commit()
+            await session.refresh(new_task)
+            return convert_to_task(new_task, self.debug_enabled)
+
+    @db_operation("create_step")
+    async def create_step(
+        self,
+        task_id: str,
+        order: int,
+        retry_index: int,
+        organization_id: str | None = None,
+        status: StepStatus = StepStatus.created,
+        created_by: str | None = None,
+    ) -> Step:
+        async with self.Session() as session:
+            new_step = StepModel(
+                task_id=task_id,
+                order=order,
+                retry_index=retry_index,
+                status=status,
+                organization_id=organization_id,
+                created_by=created_by,
+            )
+            session.add(new_step)
+            await session.commit()
+            await session.refresh(new_step)
+            return convert_to_step(new_step, debug_enabled=self.debug_enabled)
+
+    @read_retry()
+    @db_operation("get_task", log_errors=False)
+    async def get_task(self, task_id: str, organization_id: str | None = None) -> Task | None:
+        """Get a task by its id"""
+        async with self.Session() as session:
+            query = select(TaskModel).filter_by(task_id=task_id)
+            if organization_id is not None:
+                query = query.filter_by(organization_id=organization_id)
+            if task_obj := (await session.scalars(query)).first():
+                return convert_to_task(task_obj, self.debug_enabled)
+            else:
+                LOG.info(
+                    "Task not found",
+                    task_id=task_id,
+                    organization_id=organization_id,
+                )
+                return None
+
+    @db_operation("get_tasks_by_ids")
+    async def get_tasks_by_ids(
+        self,
+        task_ids: list[str],
+        organization_id: str,
+    ) -> list[Task]:
+        async with self.Session() as session:
+            tasks = (
+                await session.scalars(
+                    select(TaskModel).filter(TaskModel.task_id.in_(task_ids)).filter_by(organization_id=organization_id)
+                )
+            ).all()
+            return [convert_to_task(task, debug_enabled=self.debug_enabled) for task in tasks]
+
+    @db_operation("get_step")
+    async def get_step(self, step_id: str, organization_id: str | None = None) -> Step | None:
+        async with self.Session() as session:
+            if step := (
+                await session.scalars(
+                    select(StepModel).filter_by(step_id=step_id).filter_by(organization_id=organization_id)
+                )
+            ).first():
+                return convert_to_step(step, debug_enabled=self.debug_enabled)
+
+            else:
+                return None
+
+    @db_operation("get_task_steps")
+    async def get_task_steps(self, task_id: str, organization_id: str) -> list[Step]:
+        async with self.Session() as session:
+            if steps := (
+                await session.scalars(
+                    select(StepModel)
+                    .filter_by(task_id=task_id)
+                    .filter_by(organization_id=organization_id)
+                    .order_by(StepModel.order)
+                    .order_by(StepModel.retry_index)
+                )
+            ).all():
+                return [convert_to_step(step, debug_enabled=self.debug_enabled) for step in steps]
+            else:
+                return []
+
+    @db_operation("get_steps_by_task_ids")
+    async def get_steps_by_task_ids(self, task_ids: list[str], organization_id: str | None = None) -> list[Step]:
+        async with self.Session() as session:
+            steps = (
+                await session.scalars(
+                    select(StepModel).filter(StepModel.task_id.in_(task_ids)).filter_by(organization_id=organization_id)
+                )
+            ).all()
+            return [convert_to_step(step, debug_enabled=self.debug_enabled) for step in steps]
+
+    @db_operation("get_total_unique_step_order_count_by_task_ids")
+    async def get_total_unique_step_order_count_by_task_ids(
+        self,
+        *,
+        task_ids: list[str],
+        organization_id: str,
+    ) -> int:
+        """
+        Get the total count of unique (step.task_id, step.order) pairs of StepModel for the given task ids
+        Basically translate this sql query into a SQLAlchemy query: select count(distinct(s.task_id, s.order)) from steps s
+        where s.task_id in task_ids
+        """
+        async with self.Session() as session:
+            query = (
+                select(func.count(distinct(tuple_(StepModel.task_id, StepModel.order))))
+                .where(StepModel.task_id.in_(task_ids))
+                .where(StepModel.organization_id == organization_id)
+            )
+            return (await session.execute(query)).scalar()
+
+    @db_operation("get_task_step_models")
+    async def get_task_step_models(self, task_id: str, organization_id: str | None = None) -> Sequence[StepModel]:
+        async with self.Session() as session:
+            return (
+                await session.scalars(
+                    select(StepModel)
+                    .filter_by(task_id=task_id)
+                    .filter_by(organization_id=organization_id)
+                    .order_by(StepModel.order)
+                    .order_by(StepModel.retry_index)
+                )
+            ).all()
+
+    @db_operation("get_task_step_count")
+    async def get_task_step_count(self, task_id: str, organization_id: str | None = None) -> int:
+        async with self.Session() as session:
+            result = await session.scalar(
+                select(func.count(StepModel.step_id))
+                .filter_by(task_id=task_id)
+                .filter_by(organization_id=organization_id)
+            )
+            return result or 0
+
+    @db_operation("get_task_actions")
+    async def get_task_actions(self, task_id: str, organization_id: str | None = None) -> list[Action]:
+        async with self.Session() as session:
+            query = (
+                select(ActionModel)
+                .filter(ActionModel.organization_id == organization_id)
+                .filter(ActionModel.task_id == task_id)
+                .order_by(ActionModel.created_at)
+            )
+
+            actions = (await session.scalars(query)).all()
+            return [Action.model_validate(action) for action in actions]
+
+    @db_operation("get_task_actions_hydrated")
+    async def get_task_actions_hydrated(self, task_id: str, organization_id: str | None = None) -> list[Action]:
+        async with self.Session() as session:
+            query = (
+                select(ActionModel)
+                .filter(ActionModel.organization_id == organization_id)
+                .filter(ActionModel.task_id == task_id)
+                .order_by(ActionModel.created_at)
+            )
+
+            actions = (await session.scalars(query)).all()
+            return [hydrate_action(action) for action in actions]
+
+    @db_operation("get_tasks_actions")
+    async def get_tasks_actions(self, task_ids: list[str], organization_id: str | None = None) -> list[Action]:
+        async with self.Session() as session:
+            query = (
+                select(ActionModel)
+                .filter(ActionModel.organization_id == organization_id)
+                .filter(ActionModel.task_id.in_(task_ids))
+                .order_by(ActionModel.created_at.desc())
+            )
+            actions = (await session.scalars(query)).all()
+            return [hydrate_action(action) for action in actions]
+
+    @db_operation("get_action_count_for_step")
+    async def get_action_count_for_step(self, step_id: str, task_id: str, organization_id: str) -> int:
+        """Get count of actions for a step. Uses composite index for efficiency."""
+        async with self.Session() as session:
+            query = (
+                select(func.count())
+                .select_from(ActionModel)
+                .where(ActionModel.organization_id == organization_id)
+                .where(ActionModel.task_id == task_id)
+                .where(ActionModel.step_id == step_id)
+            )
+            result = await session.scalar(query)
+            return result or 0
+
+    @db_operation("get_first_step")
+    async def get_first_step(self, task_id: str, organization_id: str | None = None) -> Step | None:
+        async with self.Session() as session:
+            if step := (
+                await session.scalars(
+                    select(StepModel)
+                    .filter_by(task_id=task_id)
+                    .filter_by(organization_id=organization_id)
+                    .order_by(StepModel.order.asc())
+                    .order_by(StepModel.retry_index.asc())
+                )
+            ).first():
+                return convert_to_step(step, debug_enabled=self.debug_enabled)
+            else:
+                LOG.info(
+                    "Latest step not found",
+                    task_id=task_id,
+                    organization_id=organization_id,
+                )
+                return None
+
+    @db_operation("get_latest_step")
+    async def get_latest_step(self, task_id: str, organization_id: str | None = None) -> Step | None:
+        async with self.Session() as session:
+            if step := (
+                await session.scalars(
+                    select(StepModel)
+                    .filter_by(task_id=task_id)
+                    .filter_by(organization_id=organization_id)
+                    .filter(StepModel.status != StepStatus.canceled)
+                    .order_by(StepModel.order.desc())
+                    .order_by(StepModel.retry_index.desc())
+                )
+            ).first():
+                return convert_to_step(step, debug_enabled=self.debug_enabled)
+            else:
+                LOG.info(
+                    "Latest step not found",
+                    task_id=task_id,
+                    organization_id=organization_id,
+                )
+                return None
+
+    @db_operation("update_step")
+    async def update_step(
+        self,
+        task_id: str,
+        step_id: str,
+        status: StepStatus | None = None,
+        output: AgentStepOutput | None = None,
+        is_last: bool | None = None,
+        retry_index: int | None = None,
+        organization_id: str | None = None,
+        incremental_cost: float | None = None,
+        incremental_input_tokens: int | None = None,
+        incremental_output_tokens: int | None = None,
+        incremental_reasoning_tokens: int | None = None,
+        incremental_cached_tokens: int | None = None,
+        created_by: str | None = None,
+    ) -> Step:
+        async with self.Session() as session:
+            if step := (
+                await session.scalars(
+                    select(StepModel)
+                    .filter_by(task_id=task_id)
+                    .filter_by(step_id=step_id)
+                    .filter_by(organization_id=organization_id)
+                )
+            ).first():
+                if status is not None:
+                    step.status = status
+
+                    if status.is_terminal() and step.finished_at is None:
+                        step.finished_at = datetime.now(timezone.utc)
+                if output is not None:
+                    step.output = output.model_dump(exclude_none=True)
+                if is_last is not None:
+                    step.is_last = is_last
+                if retry_index is not None:
+                    step.retry_index = retry_index
+                if incremental_cost is not None:
+                    step.step_cost = incremental_cost + float(step.step_cost or 0)
+                if incremental_input_tokens is not None:
+                    step.input_token_count = incremental_input_tokens + (step.input_token_count or 0)
+                if incremental_output_tokens is not None:
+                    step.output_token_count = incremental_output_tokens + (step.output_token_count or 0)
+                if incremental_reasoning_tokens is not None:
+                    step.reasoning_token_count = incremental_reasoning_tokens + (step.reasoning_token_count or 0)
+                if incremental_cached_tokens is not None:
+                    step.cached_token_count = incremental_cached_tokens + (step.cached_token_count or 0)
+                if created_by is not None:
+                    step.created_by = created_by
+
+                await session.commit()
+                updated_step = await self.get_step(step_id, organization_id)
+                if not updated_step:
+                    raise NotFoundError("Step not found")
+                return updated_step
+            else:
+                raise NotFoundError("Step not found")
+
+    @db_operation("clear_task_failure_reason")
+    async def clear_task_failure_reason(self, organization_id: str, task_id: str) -> Task:
+        async with self.Session() as session:
+            if task := (
+                await session.scalars(
+                    select(TaskModel).filter_by(task_id=task_id).filter_by(organization_id=organization_id)
+                )
+            ).first():
+                task.failure_reason = None
+                await session.commit()
+                await session.refresh(task)
+                return convert_to_task(task, debug_enabled=self.debug_enabled)
+            else:
+                raise NotFoundError("Task not found")
+
+    @db_operation("update_task")
+    async def update_task(
+        self,
+        task_id: str,
+        status: TaskStatus | None = None,
+        extracted_information: dict[str, Any] | list | str | None = None,
+        webhook_failure_reason: str | None = None,
+        failure_reason: str | None = None,
+        errors: list[dict[str, Any]] | None = None,
+        max_steps_per_run: int | None = None,
+        organization_id: str | None = None,
+    ) -> Task:
+        if (
+            status is None
+            and extracted_information is None
+            and failure_reason is None
+            and errors is None
+            and max_steps_per_run is None
+            and webhook_failure_reason is None
+        ):
+            raise ValueError(
+                "At least one of status, extracted_information, or failure_reason must be provided to update the task"
+            )
+        async with self.Session() as session:
+            if task := (
+                await session.scalars(
+                    select(TaskModel).filter_by(task_id=task_id).filter_by(organization_id=organization_id)
+                )
+            ).first():
+                if status is not None:
+                    task.status = status
+                    if status == TaskStatus.queued and task.queued_at is None:
+                        task.queued_at = datetime.now(timezone.utc)
+                    if status == TaskStatus.running and task.started_at is None:
+                        task.started_at = datetime.now(timezone.utc)
+                    if status.is_final() and task.finished_at is None:
+                        task.finished_at = datetime.now(timezone.utc)
+                if extracted_information is not None:
+                    task.extracted_information = extracted_information
+                if failure_reason is not None:
+                    task.failure_reason = failure_reason
+                if errors is not None:
+                    task.errors = (task.errors or []) + errors
+                if max_steps_per_run is not None:
+                    task.max_steps_per_run = max_steps_per_run
+                if webhook_failure_reason is not None:
+                    task.webhook_failure_reason = webhook_failure_reason
+                await session.commit()
+                updated_task = await self.get_task(task_id, organization_id=organization_id)
+                if not updated_task:
+                    raise NotFoundError("Task not found")
+                return updated_task
+            else:
+                raise NotFoundError("Task not found")
+
+    @db_operation("update_task_2fa_state")
+    async def update_task_2fa_state(
+        self,
+        task_id: str,
+        organization_id: str,
+        waiting_for_verification_code: bool,
+        verification_code_identifier: str | None = None,
+        verification_code_polling_started_at: datetime | None = None,
+    ) -> Task:
+        """Update task 2FA verification code waiting state."""
+        async with self.Session() as session:
+            if task := (
+                await session.scalars(
+                    select(TaskModel).filter_by(task_id=task_id).filter_by(organization_id=organization_id)
+                )
+            ).first():
+                task.waiting_for_verification_code = waiting_for_verification_code
+                if verification_code_identifier is not None:
+                    task.verification_code_identifier = verification_code_identifier
+                if verification_code_polling_started_at is not None:
+                    task.verification_code_polling_started_at = verification_code_polling_started_at
+                if not waiting_for_verification_code:
+                    # Clear identifiers when no longer waiting
+                    task.verification_code_identifier = None
+                    task.verification_code_polling_started_at = None
+                await session.commit()
+                updated_task = await self.get_task(task_id, organization_id=organization_id)
+                if not updated_task:
+                    raise NotFoundError("Task not found")
+                return updated_task
+            else:
+                raise NotFoundError("Task not found")
+
+    @db_operation("bulk_update_tasks")
+    async def bulk_update_tasks(
+        self,
+        task_ids: list[str],
+        status: TaskStatus | None = None,
+        failure_reason: str | None = None,
+    ) -> None:
+        """Bulk update tasks by their IDs.
+
+        Args:
+            task_ids: List of task IDs to update
+            status: Optional status to set for all tasks
+            failure_reason: Optional failure reason to set for all tasks
+        """
+        if not task_ids:
+            return
+
+        async with self.Session() as session:
+            update_values = {}
+            if status:
+                update_values["status"] = status.value
+            if failure_reason:
+                update_values["failure_reason"] = failure_reason
+
+            if update_values:
+                update_stmt = update(TaskModel).where(TaskModel.task_id.in_(task_ids)).values(**update_values)
+                await session.execute(update_stmt)
+                await session.commit()
+
+    @db_operation("get_tasks")
+    async def get_tasks(
+        self,
+        page: int = 1,
+        page_size: int = 10,
+        task_status: list[TaskStatus] | None = None,
+        workflow_run_id: str | None = None,
+        organization_id: str | None = None,
+        only_standalone_tasks: bool = False,
+        application: str | None = None,
+        order_by_column: OrderBy = OrderBy.created_at,
+        order: SortDirection = SortDirection.desc,
+    ) -> list[Task]:
+        """
+        Get all tasks.
+        :param page: Starts at 1
+        :param page_size:
+        :param task_status:
+        :param workflow_run_id:
+        :param only_standalone_tasks:
+        :param order_by_column:
+        :param order:
+        :return:
+        """
+        if page < 1:
+            raise ValueError(f"Page must be greater than 0, got {page}")
+
+        async with self.Session() as session:
+            db_page = page - 1  # offset logic is 0 based
+            query = (
+                select(TaskModel, WorkflowRunModel.workflow_permanent_id)
+                .join(WorkflowRunModel, TaskModel.workflow_run_id == WorkflowRunModel.workflow_run_id, isouter=True)
+                .filter(TaskModel.organization_id == organization_id)
+            )
+            if task_status:
+                query = query.filter(TaskModel.status.in_(task_status))
+            if workflow_run_id:
+                query = query.filter(TaskModel.workflow_run_id == workflow_run_id)
+            if only_standalone_tasks:
+                query = query.filter(TaskModel.workflow_run_id.is_(None))
+            if application:
+                query = query.filter(TaskModel.application == application)
+            order_by_col = getattr(TaskModel, order_by_column)
+            query = (
+                query.order_by(order_by_col.desc() if order == SortDirection.desc else order_by_col.asc())
+                .limit(page_size)
+                .offset(db_page * page_size)
+            )
+
+            results = (await session.execute(query)).all()
+
+            return [
+                convert_to_task(task, debug_enabled=self.debug_enabled, workflow_permanent_id=workflow_permanent_id)
+                for task, workflow_permanent_id in results
+            ]
+
+    @db_operation("get_tasks_count")
+    async def get_tasks_count(
+        self,
+        organization_id: str,
+        task_status: list[TaskStatus] | None = None,
+        workflow_run_id: str | None = None,
+        only_standalone_tasks: bool = False,
+        application: str | None = None,
+    ) -> int:
+        async with self.Session() as session:
+            count_query = (
+                select(func.count()).select_from(TaskModel).filter(TaskModel.organization_id == organization_id)
+            )
+            if task_status:
+                count_query = count_query.filter(TaskModel.status.in_(task_status))
+            if workflow_run_id:
+                count_query = count_query.filter(TaskModel.workflow_run_id == workflow_run_id)
+            if only_standalone_tasks:
+                count_query = count_query.filter(TaskModel.workflow_run_id.is_(None))
+            if application:
+                count_query = count_query.filter(TaskModel.application == application)
+            return (await session.execute(count_query)).scalar_one()
+
+    @db_operation("get_running_tasks_info_globally")
+    async def get_running_tasks_info_globally(
+        self,
+        stale_threshold_hours: int = 24,
+    ) -> tuple[int, int]:
+        """
+        Get information about running tasks across all organizations.
+        Used by cleanup service to determine if cleanup should be skipped.
+
+        Args:
+            stale_threshold_hours: Tasks not updated for this many hours are considered stale.
+
+        Returns:
+            Tuple of (active_task_count, stale_task_count).
+            Active tasks are those updated within the threshold.
+            Stale tasks are those not updated within the threshold but still in running status.
+        """
+        async with self.Session() as session:
+            running_statuses = [TaskStatus.created, TaskStatus.queued, TaskStatus.running]
+            stale_cutoff = datetime.now(timezone.utc) - timedelta(hours=stale_threshold_hours)
+
+            # Count active tasks (recently updated)
+            active_query = (
+                select(func.count())
+                .select_from(TaskModel)
+                .filter(TaskModel.status.in_(running_statuses))
+                .filter(TaskModel.modified_at >= stale_cutoff)
+            )
+            active_count = (await session.execute(active_query)).scalar_one()
+
+            # Count stale tasks (not updated for a long time)
+            stale_query = (
+                select(func.count())
+                .select_from(TaskModel)
+                .filter(TaskModel.status.in_(running_statuses))
+                .filter(TaskModel.modified_at < stale_cutoff)
+            )
+            stale_count = (await session.execute(stale_query)).scalar_one()
+
+            return (active_count, stale_count)
+
+    @db_operation("get_latest_task_by_workflow_id")
+    async def get_latest_task_by_workflow_id(
+        self,
+        organization_id: str,
+        workflow_id: str,
+        before: datetime | None = None,
+    ) -> Task | None:
+        async with self.Session() as session:
+            query = select(TaskModel).filter_by(organization_id=organization_id).filter_by(workflow_id=workflow_id)
+            if before:
+                query = query.filter(TaskModel.created_at < before)
+            task = (await session.scalars(query.order_by(TaskModel.created_at.desc()))).first()
+            if task:
+                return convert_to_task(task, debug_enabled=self.debug_enabled)
+            return None
+
+    @db_operation("get_last_task_for_workflow_run")
+    async def get_last_task_for_workflow_run(self, workflow_run_id: str) -> Task | None:
+        async with self.Session() as session:
+            if task := (
+                await session.scalars(
+                    select(TaskModel).filter_by(workflow_run_id=workflow_run_id).order_by(TaskModel.created_at.desc())
+                )
+            ).first():
+                return convert_to_task(task, debug_enabled=self.debug_enabled)
+            return None
+
+    @db_operation("get_tasks_by_workflow_run_id")
+    async def get_tasks_by_workflow_run_id(self, workflow_run_id: str) -> list[Task]:
+        async with self.Session() as session:
+            tasks = (
+                await session.scalars(
+                    select(TaskModel).filter_by(workflow_run_id=workflow_run_id).order_by(TaskModel.created_at)
+                )
+            ).all()
+            return [convert_to_task(task, debug_enabled=self.debug_enabled) for task in tasks]
+
+    @db_operation("delete_task_steps")
+    async def delete_task_steps(self, organization_id: str, task_id: str) -> None:
+        async with self.Session() as session:
+            # delete artifacts by filtering organization_id and task_id
+            stmt = delete(StepModel).where(
+                and_(
+                    StepModel.organization_id == organization_id,
+                    StepModel.task_id == task_id,
+                )
+            )
+            await session.execute(stmt)
+            await session.commit()
+
+    @db_operation("get_previous_actions_for_task")
+    async def get_previous_actions_for_task(self, task_id: str) -> list[Action]:
+        async with self.Session() as session:
+            query = (
+                select(ActionModel)
+                .filter_by(task_id=task_id)
+                .order_by(ActionModel.step_order, ActionModel.action_order, ActionModel.created_at)
+            )
+            actions = (await session.scalars(query)).all()
+            return [Action.model_validate(action) for action in actions]
+
+    @db_operation("delete_task_actions")
+    async def delete_task_actions(self, organization_id: str, task_id: str) -> None:
+        async with self.Session() as session:
+            # delete actions by filtering organization_id and task_id
+            stmt = delete(ActionModel).where(
+                and_(
+                    ActionModel.organization_id == organization_id,
+                    ActionModel.task_id == task_id,
+                )
+            )
+            await session.execute(stmt)
+            await session.commit()
diff --git a/skyvern/forge/sdk/db/repositories/workflow_parameters.py b/skyvern/forge/sdk/db/repositories/workflow_parameters.py
new file mode 100644
index 000000000..004ffef5a
--- /dev/null
+++ b/skyvern/forge/sdk/db/repositories/workflow_parameters.py
@@ -0,0 +1,699 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime, timedelta, timezone
+from typing import Any
+
+import structlog
+from sqlalchemy import select
+
+from skyvern.config import settings
+from skyvern.forge.sdk.db._error_handling import db_operation
+from skyvern.forge.sdk.db.base_repository import BaseRepository
+from skyvern.forge.sdk.db.exceptions import NotFoundError
+from skyvern.forge.sdk.db.models import (
+    ActionModel,
+    AISuggestionModel,
+    AWSSecretParameterModel,
+    AzureVaultCredentialParameterModel,
+    Base,
+    BitwardenCreditCardDataParameterModel,
+    BitwardenLoginCredentialParameterModel,
+    BitwardenSensitiveInformationParameterModel,
+    CredentialParameterModel,
+    OnePasswordCredentialParameterModel,
+    OutputParameterModel,
+    TaskGenerationModel,
+    TaskModel,
+    TaskRunModel,
+    WorkflowCopilotChatMessageModel,
+    WorkflowCopilotChatModel,
+    WorkflowParameterModel,
+)
+from skyvern.forge.sdk.db.utils import (
+    convert_to_aws_secret_parameter,
+    convert_to_output_parameter,
+    convert_to_workflow_copilot_chat_message,
+    convert_to_workflow_parameter,
+    hydrate_action,
+)
+from skyvern.forge.sdk.schemas.ai_suggestions import AISuggestion
+from skyvern.forge.sdk.schemas.runs import Run
+from skyvern.forge.sdk.schemas.task_generations import TaskGeneration
+from skyvern.forge.sdk.schemas.tasks import Task, TaskStatus
+from skyvern.forge.sdk.schemas.workflow_copilot import (
+    WorkflowCopilotChat,
+    WorkflowCopilotChatMessage,
+    WorkflowCopilotChatSender,
+)
+from skyvern.forge.sdk.workflow.models.parameter import (
+    PARAMETER_TYPE,
+    AWSSecretParameter,
+    AzureVaultCredentialParameter,
+    BitwardenCreditCardDataParameter,
+    BitwardenLoginCredentialParameter,
+    BitwardenSensitiveInformationParameter,
+    ContextParameter,
+    CredentialParameter,
+    OnePasswordCredentialParameter,
+    OutputParameter,
+    WorkflowParameter,
+    WorkflowParameterType,
+)
+from skyvern.schemas.runs import RunType
+from skyvern.webeye.actions.actions import Action
+
+from . import _UNSET
+
+LOG = structlog.get_logger()
+
+
+class WorkflowParametersRepository(BaseRepository):
+    """Database operations for workflow parameters, copilot chat, task generation, actions, and runs."""
+
+    @db_operation("create_workflow_parameter")
+    async def create_workflow_parameter(
+        self,
+        workflow_id: str,
+        workflow_parameter_type: WorkflowParameterType,
+        key: str,
+        default_value: Any,
+        description: str | None = None,
+    ) -> WorkflowParameter:
+        async with self.Session() as session:
+            if default_value is None:
+                pass
+            elif workflow_parameter_type == WorkflowParameterType.JSON:
+                default_value = json.dumps(default_value)
+            else:
+                default_value = str(default_value)
+            workflow_parameter = WorkflowParameterModel(
+                workflow_id=workflow_id,
+                workflow_parameter_type=workflow_parameter_type,
+                key=key,
+                default_value=default_value,
+                description=description,
+            )
+            session.add(workflow_parameter)
+            await session.commit()
+            await session.refresh(workflow_parameter)
+            return convert_to_workflow_parameter(workflow_parameter, self.debug_enabled)
+
+    @db_operation("create_aws_secret_parameter")
+    async def create_aws_secret_parameter(
+        self,
+        workflow_id: str,
+        key: str,
+        aws_key: str,
+        description: str | None = None,
+    ) -> AWSSecretParameter:
+        async with self.Session() as session:
+            aws_secret_parameter = AWSSecretParameterModel(
+                workflow_id=workflow_id,
+                key=key,
+                aws_key=aws_key,
+                description=description,
+            )
+            session.add(aws_secret_parameter)
+            await session.commit()
+            await session.refresh(aws_secret_parameter)
+            return convert_to_aws_secret_parameter(aws_secret_parameter)
+
+    @db_operation("create_output_parameter")
+    async def create_output_parameter(
+        self,
+        workflow_id: str,
+        key: str,
+        description: str | None = None,
+    ) -> OutputParameter:
+        async with self.Session() as session:
+            output_parameter = OutputParameterModel(
+                key=key,
+                description=description,
+                workflow_id=workflow_id,
+            )
+            session.add(output_parameter)
+            await session.commit()
+            await session.refresh(output_parameter)
+            return convert_to_output_parameter(output_parameter)
+
+    @staticmethod
+    def _convert_parameter_to_model(parameter: PARAMETER_TYPE) -> Base:
+        """Convert a parameter object to its corresponding SQLAlchemy model."""
+        if isinstance(parameter, WorkflowParameter):
+            if parameter.default_value is None:
+                default_value = None
+            elif parameter.workflow_parameter_type == WorkflowParameterType.JSON:
+                default_value = json.dumps(parameter.default_value)
+            else:
+                default_value = str(parameter.default_value)
+            return WorkflowParameterModel(
+                workflow_parameter_id=parameter.workflow_parameter_id,
+                workflow_parameter_type=parameter.workflow_parameter_type.value,
+                key=parameter.key,
+                description=parameter.description,
+                workflow_id=parameter.workflow_id,
+                default_value=default_value,
+                deleted_at=parameter.deleted_at,
+            )
+        elif isinstance(parameter, OutputParameter):
+            return OutputParameterModel(
+                output_parameter_id=parameter.output_parameter_id,
+                key=parameter.key,
+                description=parameter.description,
+                workflow_id=parameter.workflow_id,
+                deleted_at=parameter.deleted_at,
+            )
+        elif isinstance(parameter, AWSSecretParameter):
+            return AWSSecretParameterModel(
+                aws_secret_parameter_id=parameter.aws_secret_parameter_id,
+                workflow_id=parameter.workflow_id,
+                key=parameter.key,
+                description=parameter.description,
+                aws_key=parameter.aws_key,
+                deleted_at=parameter.deleted_at,
+            )
+        elif isinstance(parameter, BitwardenLoginCredentialParameter):
+            return BitwardenLoginCredentialParameterModel(
+                bitwarden_login_credential_parameter_id=parameter.bitwarden_login_credential_parameter_id,
+                workflow_id=parameter.workflow_id,
+                key=parameter.key,
+                description=parameter.description,
+                bitwarden_client_id_aws_secret_key=parameter.bitwarden_client_id_aws_secret_key,
+                bitwarden_client_secret_aws_secret_key=parameter.bitwarden_client_secret_aws_secret_key,
+                bitwarden_master_password_aws_secret_key=parameter.bitwarden_master_password_aws_secret_key,
+                bitwarden_collection_id=parameter.bitwarden_collection_id,
+                bitwarden_item_id=parameter.bitwarden_item_id,
+                url_parameter_key=parameter.url_parameter_key,
+                deleted_at=parameter.deleted_at,
+            )
+        elif isinstance(parameter, BitwardenSensitiveInformationParameter):
+            return BitwardenSensitiveInformationParameterModel(
+                bitwarden_sensitive_information_parameter_id=parameter.bitwarden_sensitive_information_parameter_id,
+                workflow_id=parameter.workflow_id,
+                key=parameter.key,
+                description=parameter.description,
+                bitwarden_client_id_aws_secret_key=parameter.bitwarden_client_id_aws_secret_key,
+                bitwarden_client_secret_aws_secret_key=parameter.bitwarden_client_secret_aws_secret_key,
+                bitwarden_master_password_aws_secret_key=parameter.bitwarden_master_password_aws_secret_key,
+                bitwarden_collection_id=parameter.bitwarden_collection_id,
+                bitwarden_identity_key=parameter.bitwarden_identity_key,
+                bitwarden_identity_fields=parameter.bitwarden_identity_fields,
+                deleted_at=parameter.deleted_at,
+            )
+        elif isinstance(parameter, BitwardenCreditCardDataParameter):
+            return BitwardenCreditCardDataParameterModel(
+                bitwarden_credit_card_data_parameter_id=parameter.bitwarden_credit_card_data_parameter_id,
+                workflow_id=parameter.workflow_id,
+                key=parameter.key,
+                description=parameter.description,
+                bitwarden_client_id_aws_secret_key=parameter.bitwarden_client_id_aws_secret_key,
+                bitwarden_client_secret_aws_secret_key=parameter.bitwarden_client_secret_aws_secret_key,
+                bitwarden_master_password_aws_secret_key=parameter.bitwarden_master_password_aws_secret_key,
+                bitwarden_collection_id=parameter.bitwarden_collection_id,
+                bitwarden_item_id=parameter.bitwarden_item_id,
+                deleted_at=parameter.deleted_at,
+            )
+        elif isinstance(parameter, CredentialParameter):
+            return CredentialParameterModel(
+                credential_parameter_id=parameter.credential_parameter_id,
+                workflow_id=parameter.workflow_id,
+                key=parameter.key,
+                description=parameter.description,
+                credential_id=parameter.credential_id,
+                deleted_at=parameter.deleted_at,
+            )
+        elif isinstance(parameter, OnePasswordCredentialParameter):
+            return OnePasswordCredentialParameterModel(
+                onepassword_credential_parameter_id=parameter.onepassword_credential_parameter_id,
+                workflow_id=parameter.workflow_id,
+                key=parameter.key,
+                description=parameter.description,
+                vault_id=parameter.vault_id,
+                item_id=parameter.item_id,
+                deleted_at=parameter.deleted_at,
+            )
+        elif isinstance(parameter, AzureVaultCredentialParameter):
+            return AzureVaultCredentialParameterModel(
+                azure_vault_credential_parameter_id=parameter.azure_vault_credential_parameter_id,
+                workflow_id=parameter.workflow_id,
+                key=parameter.key,
+                description=parameter.description,
+                vault_name=parameter.vault_name,
+                username_key=parameter.username_key,
+                password_key=parameter.password_key,
+                totp_secret_key=parameter.totp_secret_key,
+                deleted_at=parameter.deleted_at,
+            )
+        else:
+            raise ValueError(f"Unsupported workflow definition parameter type: {type(parameter).__name__}")
+
+    @db_operation("save_workflow_definition_parameters")
+    async def save_workflow_definition_parameters(self, parameters: list[PARAMETER_TYPE]) -> None:
+        """Save multiple workflow definition parameters in a single transaction."""
+
+        # ContextParameter is not persisted
+        parameters_to_save = [p for p in parameters if not isinstance(p, ContextParameter)]
+        if not parameters_to_save:
+            return
+
+        async with self.Session() as session:
+            for parameter in parameters_to_save:
+                model = self._convert_parameter_to_model(parameter)
+                session.add(model)
+            await session.commit()
+
+    @db_operation("get_workflow_output_parameters")
+    async def get_workflow_output_parameters(self, workflow_id: str) -> list[OutputParameter]:
+        async with self.Session() as session:
+            output_parameters = (
+                await session.scalars(select(OutputParameterModel).filter_by(workflow_id=workflow_id))
+            ).all()
+            return [convert_to_output_parameter(parameter) for parameter in output_parameters]
+
+    @db_operation("get_workflow_output_parameters_by_ids")
+    async def get_workflow_output_parameters_by_ids(self, output_parameter_ids: list[str]) -> list[OutputParameter]:
+        async with self.Session() as session:
+            output_parameters = (
+                await session.scalars(
+                    select(OutputParameterModel).filter(
+                        OutputParameterModel.output_parameter_id.in_(output_parameter_ids)
+                    )
+                )
+            ).all()
+            return [convert_to_output_parameter(parameter) for parameter in output_parameters]
+
+    @db_operation("get_workflow_parameters")
+    async def get_workflow_parameters(self, workflow_id: str) -> list[WorkflowParameter]:
+        async with self.Session() as session:
+            workflow_parameters = (
+                await session.scalars(select(WorkflowParameterModel).filter_by(workflow_id=workflow_id))
+            ).all()
+            return [convert_to_workflow_parameter(parameter) for parameter in workflow_parameters]
+
+    @db_operation("get_workflow_parameter")
+    async def get_workflow_parameter(
+        self, workflow_parameter_id: str, organization_id: str | None = None
+    ) -> WorkflowParameter | None:
+        async with self.Session() as session:
+            if workflow_parameter := (
+                await session.scalars(
+                    select(WorkflowParameterModel).filter_by(workflow_parameter_id=workflow_parameter_id)
+                )
+            ).first():
+                return convert_to_workflow_parameter(workflow_parameter, self.debug_enabled)
+            return None
+
+    @db_operation("create_task_generation")
+    async def create_task_generation(
+        self,
+        organization_id: str,
+        user_prompt: str,
+        user_prompt_hash: str,
+        url: str | None = None,
+        navigation_goal: str | None = None,
+        navigation_payload: dict[str, Any] | None = None,
+        data_extraction_goal: str | None = None,
+        extracted_information_schema: dict[str, Any] | None = None,
+        suggested_title: str | None = None,
+        llm: str | None = None,
+        llm_prompt: str | None = None,
+        llm_response: str | None = None,
+        source_task_generation_id: str | None = None,
+    ) -> TaskGeneration:
+        async with self.Session() as session:
+            new_task_generation = TaskGenerationModel(
+                organization_id=organization_id,
+                user_prompt=user_prompt,
+                user_prompt_hash=user_prompt_hash,
+                url=url,
+                navigation_goal=navigation_goal,
+                navigation_payload=navigation_payload,
+                data_extraction_goal=data_extraction_goal,
+                extracted_information_schema=extracted_information_schema,
+                llm=llm,
+                llm_prompt=llm_prompt,
+                llm_response=llm_response,
+                suggested_title=suggested_title,
+                source_task_generation_id=source_task_generation_id,
+            )
+            session.add(new_task_generation)
+            await session.commit()
+            await session.refresh(new_task_generation)
+            return TaskGeneration.model_validate(new_task_generation)
+
+    @db_operation("create_ai_suggestion")
+    async def create_ai_suggestion(
+        self,
+        organization_id: str,
+        ai_suggestion_type: str,
+    ) -> AISuggestion:
+        async with self.Session() as session:
+            new_ai_suggestion = AISuggestionModel(
+                organization_id=organization_id,
+                ai_suggestion_type=ai_suggestion_type,
+            )
+            session.add(new_ai_suggestion)
+            await session.commit()
+            await session.refresh(new_ai_suggestion)
+            return AISuggestion.model_validate(new_ai_suggestion)
+
+    @db_operation("create_workflow_copilot_chat")
+    async def create_workflow_copilot_chat(
+        self,
+        organization_id: str,
+        workflow_permanent_id: str,
+    ) -> WorkflowCopilotChat:
+        async with self.Session() as session:
+            new_chat = WorkflowCopilotChatModel(
+                organization_id=organization_id,
+                workflow_permanent_id=workflow_permanent_id,
+            )
+            session.add(new_chat)
+            await session.commit()
+            await session.refresh(new_chat)
+            return WorkflowCopilotChat.model_validate(new_chat)
+
+    @db_operation("update_workflow_copilot_chat")
+    async def update_workflow_copilot_chat(
+        self,
+        organization_id: str,
+        workflow_copilot_chat_id: str,
+        proposed_workflow: dict | None | object = _UNSET,
+        auto_accept: bool | None = None,
+    ) -> WorkflowCopilotChat | None:
+        async with self.Session() as session:
+            chat = (
+                await session.scalars(
+                    select(WorkflowCopilotChatModel)
+                    .where(WorkflowCopilotChatModel.organization_id == organization_id)
+                    .where(WorkflowCopilotChatModel.workflow_copilot_chat_id == workflow_copilot_chat_id)
+                )
+            ).first()
+            if not chat:
+                return None
+
+            if proposed_workflow is not _UNSET:
+                chat.proposed_workflow = proposed_workflow
+            if auto_accept is not None:
+                chat.auto_accept = auto_accept
+
+            await session.commit()
+            await session.refresh(chat)
+            return WorkflowCopilotChat.model_validate(chat)
+
+    @db_operation("create_workflow_copilot_chat_message")
+    async def create_workflow_copilot_chat_message(
+        self,
+        organization_id: str,
+        workflow_copilot_chat_id: str,
+        sender: WorkflowCopilotChatSender,
+        content: str,
+        global_llm_context: str | None = None,
+    ) -> WorkflowCopilotChatMessage:
+        async with self.Session() as session:
+            new_message = WorkflowCopilotChatMessageModel(
+                workflow_copilot_chat_id=workflow_copilot_chat_id,
+                organization_id=organization_id,
+                sender=sender,
+                content=content,
+                global_llm_context=global_llm_context,
+            )
+            session.add(new_message)
+            await session.commit()
+            await session.refresh(new_message)
+            return convert_to_workflow_copilot_chat_message(new_message, self.debug_enabled)
+
+    @db_operation("get_workflow_copilot_chat_messages")
+    async def get_workflow_copilot_chat_messages(
+        self,
+        workflow_copilot_chat_id: str,
+    ) -> list[WorkflowCopilotChatMessage]:
+        async with self.Session() as session:
+            query = (
+                select(WorkflowCopilotChatMessageModel)
+                .filter(WorkflowCopilotChatMessageModel.workflow_copilot_chat_id == workflow_copilot_chat_id)
+                .order_by(WorkflowCopilotChatMessageModel.workflow_copilot_chat_message_id.asc())
+            )
+            messages = (await session.scalars(query)).all()
+            return [convert_to_workflow_copilot_chat_message(message, self.debug_enabled) for message in messages]
+
+    @db_operation("get_workflow_copilot_chat_by_id")
+    async def get_workflow_copilot_chat_by_id(
+        self,
+        organization_id: str,
+        workflow_copilot_chat_id: str,
+    ) -> WorkflowCopilotChat | None:
+        async with self.Session() as session:
+            query = (
+                select(WorkflowCopilotChatModel)
+                .filter(WorkflowCopilotChatModel.organization_id == organization_id)
+                .filter(WorkflowCopilotChatModel.workflow_copilot_chat_id == workflow_copilot_chat_id)
+                .order_by(WorkflowCopilotChatModel.created_at.desc())
+                .limit(1)
+            )
+            chat = (await session.scalars(query)).first()
+            if not chat:
+                return None
+            return WorkflowCopilotChat.model_validate(chat)
+
+    @db_operation("get_latest_workflow_copilot_chat")
+    async def get_latest_workflow_copilot_chat(
+        self,
+        organization_id: str,
+        workflow_permanent_id: str,
+    ) -> WorkflowCopilotChat | None:
+        async with self.Session() as session:
+            query = (
+                select(WorkflowCopilotChatModel)
+                .filter(WorkflowCopilotChatModel.organization_id == organization_id)
+                .filter(WorkflowCopilotChatModel.workflow_permanent_id == workflow_permanent_id)
+                .order_by(WorkflowCopilotChatModel.created_at.desc())
+                .limit(1)
+            )
+            chat = (await session.scalars(query)).first()
+            if not chat:
+                return None
+            return WorkflowCopilotChat.model_validate(chat)
+
+    @db_operation("get_task_generation_by_prompt_hash")
+    async def get_task_generation_by_prompt_hash(
+        self,
+        user_prompt_hash: str,
+        query_window_hours: int = settings.PROMPT_CACHE_WINDOW_HOURS,
+    ) -> TaskGeneration | None:
+        before_time = datetime.now(timezone.utc) - timedelta(hours=query_window_hours)
+        async with self.Session() as session:
+            query = (
+                select(TaskGenerationModel)
+                .filter_by(user_prompt_hash=user_prompt_hash)
+                .filter(TaskGenerationModel.llm.is_not(None))
+                .filter(TaskGenerationModel.created_at > before_time)
+            )
+            task_generation = (await session.scalars(query)).first()
+            if not task_generation:
+                return None
+            return TaskGeneration.model_validate(task_generation)
+
+    @db_operation("create_action")
+    async def create_action(self, action: Action) -> Action:
+        async with self.Session() as session:
+            new_action = ActionModel(
+                action_type=action.action_type,
+                source_action_id=action.source_action_id,
+                organization_id=action.organization_id,
+                workflow_run_id=action.workflow_run_id,
+                task_id=action.task_id,
+                step_id=action.step_id,
+                step_order=action.step_order,
+                action_order=action.action_order,
+                status=action.status,
+                reasoning=action.reasoning,
+                intention=action.intention,
+                response=action.response,
+                element_id=action.element_id,
+                skyvern_element_hash=action.skyvern_element_hash,
+                skyvern_element_data=action.skyvern_element_data,
+                screenshot_artifact_id=action.screenshot_artifact_id,
+                action_json=action.model_dump(),
+                confidence_float=action.confidence_float,
+                created_by=action.created_by,
+            )
+            session.add(new_action)
+            await session.commit()
+            await session.refresh(new_action)
+            return hydrate_action(new_action)
+
+    @db_operation("update_action_reasoning")
+    async def update_action_reasoning(
+        self,
+        organization_id: str,
+        action_id: str,
+        reasoning: str,
+    ) -> Action:
+        async with self.Session() as session:
+            action = (
+                await session.scalars(
+                    select(ActionModel).filter_by(action_id=action_id).filter_by(organization_id=organization_id)
+                )
+            ).first()
+            if action:
+                action.reasoning = reasoning
+                await session.commit()
+                await session.refresh(action)
+                return Action.model_validate(action)
+            raise NotFoundError(f"Action {action_id}")
+
+    @db_operation("retrieve_action_plan")
+    async def retrieve_action_plan(self, task: Task) -> list[Action]:
+        async with self.Session() as session:
+            subquery = (
+                select(TaskModel.task_id)
+                .filter(TaskModel.url == task.url)
+                .filter(TaskModel.navigation_goal == task.navigation_goal)
+                .filter(TaskModel.status == TaskStatus.completed)
+                .order_by(TaskModel.created_at.desc())
+                .limit(1)
+                .subquery()
+            )
+
+            query = (
+                select(ActionModel)
+                .filter(ActionModel.task_id == subquery.c.task_id)
+                .order_by(ActionModel.step_order, ActionModel.action_order, ActionModel.created_at)
+            )
+
+            actions = (await session.scalars(query)).all()
+            return [Action.model_validate(action) for action in actions]
+
+    @db_operation("create_task_run")
+    async def create_task_run(
+        self,
+        task_run_type: RunType,
+        organization_id: str,
+        run_id: str,
+        title: str | None = None,
+        url: str | None = None,
+        url_hash: str | None = None,
+    ) -> Run:
+        async with self.Session() as session:
+            task_run = TaskRunModel(
+                task_run_type=task_run_type,
+                organization_id=organization_id,
+                run_id=run_id,
+                title=title,
+                url=url,
+                url_hash=url_hash,
+            )
+            session.add(task_run)
+            await session.commit()
+            await session.refresh(task_run)
+            return Run.model_validate(task_run)
+
+    @db_operation("update_task_run")
+    async def update_task_run(
+        self,
+        organization_id: str,
+        run_id: str,
+        title: str | None = None,
+        url: str | None = None,
+        url_hash: str | None = None,
+    ) -> None:
+        async with self.Session() as session:
+            task_run = (
+                await session.scalars(
+                    select(TaskRunModel).filter_by(run_id=run_id).filter_by(organization_id=organization_id)
+                )
+            ).first()
+            if not task_run:
+                raise NotFoundError(f"TaskRun {run_id} not found")
+
+            if title:
+                task_run.title = title
+            if url:
+                task_run.url = url
+            if url_hash:
+                task_run.url_hash = url_hash
+            await session.commit()
+
+    @db_operation("update_job_run_compute_cost")
+    async def update_job_run_compute_cost(
+        self,
+        organization_id: str,
+        run_id: str,
+        instance_type: str | None = None,
+        vcpu_millicores: int | None = None,
+        memory_mb: int | None = None,
+        duration_ms: int | None = None,
+        compute_cost: float | None = None,
+    ) -> None:
+        """Update compute cost metrics for a job run."""
+        async with self.Session() as session:
+            task_run = (
+                await session.scalars(
+                    select(TaskRunModel).filter_by(run_id=run_id).filter_by(organization_id=organization_id)
+                )
+            ).first()
+            if not task_run:
+                LOG.warning(
+                    "TaskRun not found for compute cost update",
+                    run_id=run_id,
+                    organization_id=organization_id,
+                )
+                return
+
+            if instance_type is not None:
+                task_run.instance_type = instance_type
+            if vcpu_millicores is not None:
+                task_run.vcpu_millicores = vcpu_millicores
+            if memory_mb is not None:
+                task_run.memory_mb = memory_mb
+            if duration_ms is not None:
+                task_run.duration_ms = duration_ms
+            if compute_cost is not None:
+                task_run.compute_cost = compute_cost
+            await session.commit()
+
+    @db_operation("cache_task_run")
+    async def cache_task_run(self, run_id: str, organization_id: str | None = None) -> Run:
+        async with self.Session() as session:
+            task_run = (
+                await session.scalars(
+                    select(TaskRunModel).filter_by(organization_id=organization_id).filter_by(run_id=run_id)
+                )
+            ).first()
+            if task_run:
+                task_run.cached = True
+                await session.commit()
+                await session.refresh(task_run)
+                return Run.model_validate(task_run)
+            raise NotFoundError(f"Run {run_id} not found")
+
+    @db_operation("get_cached_task_run")
+    async def get_cached_task_run(
+        self, task_run_type: RunType, url_hash: str | None = None, organization_id: str | None = None
+    ) -> Run | None:
+        async with self.Session() as session:
+            query = select(TaskRunModel)
+            if task_run_type:
+                query = query.filter_by(task_run_type=task_run_type)
+            if url_hash:
+                query = query.filter_by(url_hash=url_hash)
+            if organization_id:
+                query = query.filter_by(organization_id=organization_id)
+            query = query.filter_by(cached=True).order_by(TaskRunModel.created_at.desc())
+            task_run = (await session.scalars(query)).first()
+            return Run.model_validate(task_run) if task_run else None
+
+    @db_operation("get_run")
+    async def get_run(
+        self,
+        run_id: str,
+        organization_id: str | None = None,
+    ) -> Run | None:
+        async with self.Session() as session:
+            query = select(TaskRunModel).filter_by(run_id=run_id)
+            if organization_id:
+                query = query.filter_by(organization_id=organization_id)
+            task_run = (await session.scalars(query)).first()
+            return Run.model_validate(task_run) if task_run else None
diff --git a/skyvern/forge/sdk/db/repositories/workflow_runs.py b/skyvern/forge/sdk/db/repositories/workflow_runs.py
new file mode 100644
index 000000000..e38076fe3
--- /dev/null
+++ b/skyvern/forge/sdk/db/repositories/workflow_runs.py
@@ -0,0 +1,903 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from typing import TYPE_CHECKING, Any, Callable
+
+import structlog
+from sqlalchemy import Text, and_, cast, exists, func, literal, literal_column, or_, select, update
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.exc import SQLAlchemyError
+
+from skyvern.exceptions import WorkflowParameterNotFound, WorkflowRunNotFound
+from skyvern.forge.sdk.db._error_handling import db_operation
+from skyvern.forge.sdk.db.base_alchemy_db import read_retry
+from skyvern.forge.sdk.db.base_repository import BaseRepository
+from skyvern.forge.sdk.db.enums import WorkflowRunTriggerType
+from skyvern.forge.sdk.db.exceptions import NotFoundError
+
+if TYPE_CHECKING:
+    from skyvern.forge.sdk.db.base_alchemy_db import _SessionFactory
+
+from skyvern.forge.sdk.db.models import (
+    TaskModel,
+    WorkflowModel,
+    WorkflowParameterModel,
+    WorkflowRunBlockModel,
+    WorkflowRunModel,
+    WorkflowRunOutputParameterModel,
+    WorkflowRunParameterModel,
+)
+from skyvern.forge.sdk.db.protocols import WorkflowParameterReader
+from skyvern.forge.sdk.db.utils import (
+    convert_to_task,
+    convert_to_workflow_run,
+    convert_to_workflow_run_output_parameter,
+    convert_to_workflow_run_parameter,
+    serialize_proxy_location,
+)
+from skyvern.forge.sdk.log_artifacts import save_workflow_run_logs
+from skyvern.forge.sdk.schemas.tasks import Task
+from skyvern.forge.sdk.workflow.models.parameter import WorkflowParameter
+from skyvern.forge.sdk.workflow.models.workflow import (
+    WorkflowRun,
+    WorkflowRunOutputParameter,
+    WorkflowRunParameter,
+    WorkflowRunStatus,
+)
+from skyvern.schemas.runs import ProxyLocationInput
+
+from . import _UNSET
+
+LOG = structlog.get_logger()
+
+
+class WorkflowRunsRepository(BaseRepository):
+    """Database operations for workflow runs."""
+
+    def __init__(
+        self,
+        session_factory: _SessionFactory,
+        debug_enabled: bool = False,
+        is_retryable_error_fn: Callable[[SQLAlchemyError], bool] | None = None,
+        workflow_parameter_reader: WorkflowParameterReader | None = None,
+        dialect_name: str = "postgresql",
+    ) -> None:
+        super().__init__(session_factory, debug_enabled, is_retryable_error_fn)
+        self._workflow_parameter_reader = workflow_parameter_reader
+        self._dialect_name = dialect_name
+
+    @db_operation("get_running_workflow_runs_info_globally")
+    async def get_running_workflow_runs_info_globally(
+        self,
+        stale_threshold_hours: int = 24,
+    ) -> tuple[int, int]:
+        """
+        Get information about running workflow runs across all organizations.
+        Used by cleanup service to determine if cleanup should be skipped.
+
+        Args:
+            stale_threshold_hours: Workflow runs not updated for this many hours are considered stale.
+
+        Returns:
+            Tuple of (active_workflow_count, stale_workflow_count).
+            Active workflows are those updated within the threshold.
+            Stale workflows are those not updated within the threshold but still in running status.
+        """
+        async with self.Session() as session:
+            running_statuses = [
+                WorkflowRunStatus.created,
+                WorkflowRunStatus.queued,
+                WorkflowRunStatus.running,
+                WorkflowRunStatus.paused,
+            ]
+            stale_cutoff = datetime.now(timezone.utc) - timedelta(hours=stale_threshold_hours)
+
+            # Count active workflow runs (recently updated)
+            active_query = (
+                select(func.count())
+                .select_from(WorkflowRunModel)
+                .filter(WorkflowRunModel.status.in_(running_statuses))
+                .filter(WorkflowRunModel.modified_at >= stale_cutoff)
+            )
+            active_count = (await session.execute(active_query)).scalar_one()
+
+            # Count stale workflow runs (not updated for a long time)
+            stale_query = (
+                select(func.count())
+                .select_from(WorkflowRunModel)
+                .filter(WorkflowRunModel.status.in_(running_statuses))
+                .filter(WorkflowRunModel.modified_at < stale_cutoff)
+            )
+            stale_count = (await session.execute(stale_query)).scalar_one()
+
+            return (active_count, stale_count)
+
+    @db_operation("create_workflow_run")
+    async def create_workflow_run(
+        self,
+        workflow_permanent_id: str,
+        workflow_id: str,
+        organization_id: str,
+        browser_session_id: str | None = None,
+        browser_profile_id: str | None = None,
+        proxy_location: ProxyLocationInput = None,
+        webhook_callback_url: str | None = None,
+        totp_verification_url: str | None = None,
+        totp_identifier: str | None = None,
+        parent_workflow_run_id: str | None = None,
+        max_screenshot_scrolling_times: int | None = None,
+        extra_http_headers: dict[str, str] | None = None,
+        browser_address: str | None = None,
+        sequential_key: str | None = None,
+        run_with: str | None = None,
+        debug_session_id: str | None = None,
+        ai_fallback: bool | None = None,
+        code_gen: bool | None = None,
+        workflow_run_id: str | None = None,
+        trigger_type: WorkflowRunTriggerType | None = None,
+        workflow_schedule_id: str | None = None,
+    ) -> WorkflowRun:
+        async with self.Session() as session:
+            kwargs: dict[str, Any] = {}
+            if workflow_run_id is not None:
+                kwargs["workflow_run_id"] = workflow_run_id
+            workflow_run = WorkflowRunModel(
+                workflow_permanent_id=workflow_permanent_id,
+                workflow_id=workflow_id,
+                organization_id=organization_id,
+                browser_session_id=browser_session_id,
+                browser_profile_id=browser_profile_id,
+                proxy_location=serialize_proxy_location(proxy_location),
+                status="created",
+                webhook_callback_url=webhook_callback_url,
+                totp_verification_url=totp_verification_url,
+                totp_identifier=totp_identifier,
+                parent_workflow_run_id=parent_workflow_run_id,
+                max_screenshot_scrolling_times=max_screenshot_scrolling_times,
+                extra_http_headers=extra_http_headers,
+                browser_address=browser_address,
+                sequential_key=sequential_key,
+                run_with=run_with,
+                debug_session_id=debug_session_id,
+                ai_fallback=ai_fallback,
+                code_gen=code_gen,
+                trigger_type=trigger_type.value if trigger_type else None,
+                workflow_schedule_id=workflow_schedule_id,
+                **kwargs,
+            )
+            session.add(workflow_run)
+            await session.commit()
+            await session.refresh(workflow_run)
+            return convert_to_workflow_run(workflow_run)
+
+    @db_operation("update_workflow_run")
+    async def update_workflow_run(
+        self,
+        workflow_run_id: str,
+        status: WorkflowRunStatus | None = None,
+        failure_reason: str | None = None,
+        webhook_failure_reason: str | None = None,
+        ai_fallback_triggered: bool | None = None,
+        job_id: str | None = None,
+        run_with: str | None = None,
+        sequential_key: str | None = None,
+        ai_fallback: bool | None = None,
+        depends_on_workflow_run_id: str | None = None,
+        browser_session_id: str | None = None,
+        waiting_for_verification_code: bool | None = None,
+        verification_code_identifier: str | None = None,
+        verification_code_polling_started_at: datetime | None = None,
+        browser_profile_id: str | None | object = _UNSET,
+    ) -> WorkflowRun:
+        async with self.Session() as session:
+            workflow_run = (
+                await session.scalars(select(WorkflowRunModel).filter_by(workflow_run_id=workflow_run_id))
+            ).first()
+            if workflow_run:
+                if status:
+                    workflow_run.status = status
+                if status and status == WorkflowRunStatus.queued and workflow_run.queued_at is None:
+                    workflow_run.queued_at = datetime.now(timezone.utc)
+                if status and status == WorkflowRunStatus.running and workflow_run.started_at is None:
+                    workflow_run.started_at = datetime.now(timezone.utc)
+                if status and status.is_final() and workflow_run.finished_at is None:
+                    workflow_run.finished_at = datetime.now(timezone.utc)
+                if failure_reason:
+                    workflow_run.failure_reason = failure_reason
+                if webhook_failure_reason is not None:
+                    workflow_run.webhook_failure_reason = webhook_failure_reason
+                if ai_fallback_triggered is not None:
+                    workflow_run.script_run = {"ai_fallback_triggered": ai_fallback_triggered}
+                if job_id:
+                    workflow_run.job_id = job_id
+                if run_with:
+                    workflow_run.run_with = run_with
+                if sequential_key:
+                    workflow_run.sequential_key = sequential_key
+                if ai_fallback is not None:
+                    workflow_run.ai_fallback = ai_fallback
+                if depends_on_workflow_run_id:
+                    workflow_run.depends_on_workflow_run_id = depends_on_workflow_run_id
+                if browser_session_id:
+                    workflow_run.browser_session_id = browser_session_id
+                # 2FA verification code waiting state updates
+                if waiting_for_verification_code is not None:
+                    workflow_run.waiting_for_verification_code = waiting_for_verification_code
+                if verification_code_identifier is not None:
+                    workflow_run.verification_code_identifier = verification_code_identifier
+                if verification_code_polling_started_at is not None:
+                    workflow_run.verification_code_polling_started_at = verification_code_polling_started_at
+                if waiting_for_verification_code is not None and not waiting_for_verification_code:
+                    # Clear related fields when waiting is set to False
+                    workflow_run.verification_code_identifier = None
+                    workflow_run.verification_code_polling_started_at = None
+                if browser_profile_id is not _UNSET:
+                    workflow_run.browser_profile_id = browser_profile_id
+                await session.commit()
+                await save_workflow_run_logs(workflow_run_id)
+                await session.refresh(workflow_run)
+                return convert_to_workflow_run(workflow_run)
+            else:
+                raise WorkflowRunNotFound(workflow_run_id)
+
+    @db_operation("bulk_update_workflow_runs")
+    async def bulk_update_workflow_runs(
+        self,
+        workflow_run_ids: list[str],
+        status: WorkflowRunStatus | None = None,
+        failure_reason: str | None = None,
+    ) -> None:
+        """Bulk update workflow runs by their IDs.
+
+        Args:
+            workflow_run_ids: List of workflow run IDs to update
+            status: Optional status to set for all workflow runs
+            failure_reason: Optional failure reason to set for all workflow runs
+        """
+        if not workflow_run_ids:
+            return
+
+        async with self.Session() as session:
+            update_values = {}
+            if status:
+                update_values["status"] = status.value
+            if failure_reason:
+                update_values["failure_reason"] = failure_reason
+
+            if update_values:
+                update_stmt = (
+                    update(WorkflowRunModel)
+                    .where(WorkflowRunModel.workflow_run_id.in_(workflow_run_ids))
+                    .values(**update_values)
+                )
+                await session.execute(update_stmt)
+                await session.commit()
+
+    @db_operation("clear_workflow_run_failure_reason")
+    async def clear_workflow_run_failure_reason(self, workflow_run_id: str, organization_id: str) -> WorkflowRun:
+        async with self.Session() as session:
+            workflow_run = (
+                await session.scalars(
+                    select(WorkflowRunModel)
+                    .filter_by(workflow_run_id=workflow_run_id)
+                    .filter_by(organization_id=organization_id)
+                )
+            ).first()
+            if workflow_run:
+                workflow_run.failure_reason = None
+                await session.commit()
+                await session.refresh(workflow_run)
+                return convert_to_workflow_run(workflow_run)
+            else:
+                raise NotFoundError("Workflow run not found")
+
+    @db_operation("get_all_runs")
+    async def get_all_runs(
+        self,
+        organization_id: str,
+        page: int = 1,
+        page_size: int = 10,
+        status: list[WorkflowRunStatus] | None = None,
+        include_debugger_runs: bool = False,
+        search_key: str | None = None,
+    ) -> list[WorkflowRun | Task]:
+        async with self.Session() as session:
+            # temporary limit to 10 pages
+            if page > 10:
+                return []
+
+            limit = page * page_size
+
+            workflow_run_query = (
+                select(WorkflowRunModel, WorkflowModel.title)
+                .join(WorkflowModel, WorkflowModel.workflow_id == WorkflowRunModel.workflow_id)
+                .filter(WorkflowRunModel.organization_id == organization_id)
+                .filter(WorkflowRunModel.parent_workflow_run_id.is_(None))
+            )
+
+            if not include_debugger_runs:
+                workflow_run_query = workflow_run_query.filter(WorkflowRunModel.debug_session_id.is_(None))
+
+            if search_key:
+                key_like = f"%{search_key}%"
+                # Match workflow_run_id directly
+                id_matches = WorkflowRunModel.workflow_run_id.ilike(key_like)
+                # Match parameter key or description (only for non-deleted parameter definitions)
+                param_key_desc_exists = exists(
+                    select(1)
+                    .select_from(WorkflowRunParameterModel)
+                    .join(
+                        WorkflowParameterModel,
+                        WorkflowParameterModel.workflow_parameter_id == WorkflowRunParameterModel.workflow_parameter_id,
+                    )
+                    .where(WorkflowRunParameterModel.workflow_run_id == WorkflowRunModel.workflow_run_id)
+                    .where(WorkflowParameterModel.deleted_at.is_(None))
+                    .where(
+                        or_(
+                            WorkflowParameterModel.key.ilike(key_like),
+                            WorkflowParameterModel.description.ilike(key_like),
+                        )
+                    )
+                )
+                # Match run parameter value directly (searches all values regardless of parameter definition status)
+                param_value_exists = exists(
+                    select(1)
+                    .select_from(WorkflowRunParameterModel)
+                    .where(WorkflowRunParameterModel.workflow_run_id == WorkflowRunModel.workflow_run_id)
+                    .where(WorkflowRunParameterModel.value.ilike(key_like))
+                )
+                # Match extra HTTP headers (cast JSON to text for search, skip NULLs)
+                extra_headers_match = and_(
+                    WorkflowRunModel.extra_http_headers.isnot(None),
+                    func.cast(WorkflowRunModel.extra_http_headers, Text()).ilike(key_like),
+                )
+                workflow_run_query = workflow_run_query.where(
+                    or_(id_matches, param_key_desc_exists, param_value_exists, extra_headers_match)
+                )
+
+            if status:
+                workflow_run_query = workflow_run_query.filter(WorkflowRunModel.status.in_(status))
+            workflow_run_query = workflow_run_query.order_by(WorkflowRunModel.created_at.desc()).limit(limit)
+            workflow_run_query_result = (await session.execute(workflow_run_query)).all()
+            workflow_runs = [
+                convert_to_workflow_run(run, workflow_title=title, debug_enabled=self.debug_enabled)
+                for run, title in workflow_run_query_result
+            ]
+
+            task_query = (
+                select(TaskModel)
+                .filter(TaskModel.organization_id == organization_id)
+                .filter(TaskModel.workflow_run_id.is_(None))
+            )
+            if status:
+                task_query = task_query.filter(TaskModel.status.in_(status))
+            task_query = task_query.order_by(TaskModel.created_at.desc()).limit(limit)
+            task_query_result = (await session.scalars(task_query)).all()
+            tasks = [convert_to_task(task, debug_enabled=self.debug_enabled) for task in task_query_result]
+
+            runs = workflow_runs + tasks
+
+            runs.sort(key=lambda x: x.created_at, reverse=True)
+
+            lower = (page - 1) * page_size
+            upper = page * page_size
+
+            return runs[lower:upper]
+
+    @read_retry()
+    @db_operation("get_workflow_run", log_errors=False)
+    async def get_workflow_run(
+        self,
+        workflow_run_id: str,
+        organization_id: str | None = None,
+        job_id: str | None = None,
+        status: WorkflowRunStatus | None = None,
+    ) -> WorkflowRun | None:
+        async with self.Session() as session:
+            get_workflow_run_query = select(WorkflowRunModel).filter_by(workflow_run_id=workflow_run_id)
+            if organization_id:
+                get_workflow_run_query = get_workflow_run_query.filter_by(organization_id=organization_id)
+            if job_id:
+                get_workflow_run_query = get_workflow_run_query.filter_by(job_id=job_id)
+            if status:
+                get_workflow_run_query = get_workflow_run_query.filter_by(status=status.value)
+            if workflow_run := (await session.scalars(get_workflow_run_query)).first():
+                return convert_to_workflow_run(workflow_run)
+            return None
+
+    async def get_run(self, run_id: str, organization_id: str | None = None) -> WorkflowRun | None:
+        """Alias satisfying the RunReader protocol."""
+        return await self.get_workflow_run(run_id, organization_id=organization_id)
+
+    @db_operation("get_last_queued_workflow_run")
+    async def get_last_queued_workflow_run(
+        self,
+        workflow_permanent_id: str,
+        organization_id: str | None = None,
+        sequential_key: str | None = None,
+    ) -> WorkflowRun | None:
+        async with self.Session() as session:
+            query = select(WorkflowRunModel).filter_by(workflow_permanent_id=workflow_permanent_id)
+            query = query.filter(WorkflowRunModel.browser_session_id.is_(None))
+            if organization_id:
+                query = query.filter_by(organization_id=organization_id)
+            query = query.filter_by(status=WorkflowRunStatus.queued)
+            if sequential_key:
+                query = query.filter_by(sequential_key=sequential_key)
+            query = query.order_by(WorkflowRunModel.modified_at.desc())
+            workflow_run = (await session.scalars(query)).first()
+            return convert_to_workflow_run(workflow_run) if workflow_run else None
+
+    @db_operation("get_workflow_runs_by_ids")
+    async def get_workflow_runs_by_ids(
+        self,
+        workflow_run_ids: list[str],
+        workflow_permanent_id: str | None = None,
+        organization_id: str | None = None,
+    ) -> list[WorkflowRun]:
+        async with self.Session() as session:
+            query = select(WorkflowRunModel).filter(WorkflowRunModel.workflow_run_id.in_(workflow_run_ids))
+            if workflow_permanent_id:
+                query = query.filter_by(workflow_permanent_id=workflow_permanent_id)
+            if organization_id:
+                query = query.filter_by(organization_id=organization_id)
+            workflow_runs = (await session.scalars(query)).all()
+            return [convert_to_workflow_run(workflow_run) for workflow_run in workflow_runs]
+
+    @db_operation("get_last_running_workflow_run")
+    async def get_last_running_workflow_run(
+        self,
+        workflow_permanent_id: str,
+        organization_id: str | None = None,
+        sequential_key: str | None = None,
+    ) -> WorkflowRun | None:
+        async with self.Session() as session:
+            query = select(WorkflowRunModel).filter_by(workflow_permanent_id=workflow_permanent_id)
+            query = query.filter(WorkflowRunModel.browser_session_id.is_(None))
+            if organization_id:
+                query = query.filter_by(organization_id=organization_id)
+            query = query.filter_by(status=WorkflowRunStatus.running)
+            if sequential_key:
+                query = query.filter_by(sequential_key=sequential_key)
+            query = query.filter(
+                WorkflowRunModel.started_at.isnot(None)
+            )  # filter out workflow runs that does not have a started_at timestamp
+            query = query.order_by(WorkflowRunModel.started_at.desc())
+            workflow_run = (await session.scalars(query)).first()
+            return convert_to_workflow_run(workflow_run) if workflow_run else None
+
+    async def _get_last_workflow_run_by_filter(
+        self,
+        organization_id: str | None = None,
+        **filters: str,
+    ) -> WorkflowRun | None:
+        """Get the last queued or running workflow run matching the given column filters.
+
+        Used for browser_session_id and browser_address sequential execution.
+        """
+        async with self.Session() as session:
+            query = select(WorkflowRunModel).filter_by(**filters)
+            if organization_id:
+                query = query.filter_by(organization_id=organization_id)
+
+            # check if there's a queued run
+            queue_query = query.filter_by(status=WorkflowRunStatus.queued)
+            queue_query = queue_query.order_by(WorkflowRunModel.modified_at.desc())
+            workflow_run = (await session.scalars(queue_query)).first()
+            if workflow_run:
+                return convert_to_workflow_run(workflow_run)
+
+            # check if there's a running run
+            running_query = query.filter_by(status=WorkflowRunStatus.running)
+            running_query = running_query.filter(WorkflowRunModel.started_at.isnot(None))
+            running_query = running_query.order_by(WorkflowRunModel.started_at.desc())
+            workflow_run = (await session.scalars(running_query)).first()
+            if workflow_run:
+                return convert_to_workflow_run(workflow_run)
+            return None
+
+    async def get_last_workflow_run_for_browser_session(
+        self,
+        browser_session_id: str,
+        organization_id: str | None = None,
+    ) -> WorkflowRun | None:
+        return await self._get_last_workflow_run_by_filter(
+            organization_id=organization_id,
+            browser_session_id=browser_session_id,
+        )
+
+    async def get_last_workflow_run_for_browser_address(
+        self,
+        browser_address: str,
+        organization_id: str | None = None,
+    ) -> WorkflowRun | None:
+        return await self._get_last_workflow_run_by_filter(
+            organization_id=organization_id,
+            browser_address=browser_address,
+        )
+
+    @db_operation("get_workflows_depending_on")
+    async def get_workflows_depending_on(
+        self,
+        workflow_run_id: str,
+    ) -> list[WorkflowRun]:
+        """
+        Get all workflow runs that depend on the given workflow_run_id.
+
+        Used to find workflows that should be signaled when a workflow completes,
+        for sequential workflow dependency handling.
+
+        Args:
+            workflow_run_id: The workflow_run_id to find dependents for
+
+        Returns:
+            List of WorkflowRun objects that have depends_on_workflow_run_id set to workflow_run_id
+        """
+        async with self.Session() as session:
+            query = select(WorkflowRunModel).filter_by(depends_on_workflow_run_id=workflow_run_id)
+            workflow_runs = (await session.scalars(query)).all()
+            return [convert_to_workflow_run(workflow_run) for workflow_run in workflow_runs]
+
+    @staticmethod
+    def _apply_search_key_filter(query, search_key: str | None):  # type: ignore[no-untyped-def]
+        if not search_key:
+            return query
+        key_like = f"%{search_key}%"
+        # Match workflow_run_id directly
+        id_matches = WorkflowRunModel.workflow_run_id.ilike(key_like)
+        # Match parameter key or description (only for non-deleted parameter definitions)
+        # Use EXISTS to avoid duplicate rows and to keep pagination correct
+        param_key_desc_exists = exists(
+            select(1)
+            .select_from(WorkflowRunParameterModel)
+            .join(
+                WorkflowParameterModel,
+                WorkflowParameterModel.workflow_parameter_id == WorkflowRunParameterModel.workflow_parameter_id,
+            )
+            .where(WorkflowRunParameterModel.workflow_run_id == WorkflowRunModel.workflow_run_id)
+            .where(WorkflowParameterModel.deleted_at.is_(None))
+            .where(
+                or_(
+                    WorkflowParameterModel.key.ilike(key_like),
+                    WorkflowParameterModel.description.ilike(key_like),
+                )
+            )
+        )
+        # Match run parameter value directly (searches all values regardless of parameter definition status)
+        param_value_exists = exists(
+            select(1)
+            .select_from(WorkflowRunParameterModel)
+            .where(WorkflowRunParameterModel.workflow_run_id == WorkflowRunModel.workflow_run_id)
+            .where(WorkflowRunParameterModel.value.ilike(key_like))
+        )
+        # Match extra HTTP headers (cast JSON to text for search, skip NULLs)
+        extra_headers_match = and_(
+            WorkflowRunModel.extra_http_headers.isnot(None),
+            func.cast(WorkflowRunModel.extra_http_headers, Text()).ilike(key_like),
+        )
+        return query.where(or_(id_matches, param_key_desc_exists, param_value_exists, extra_headers_match))
+
+    def _apply_error_code_filter(self, query, error_code: str | None):  # type: ignore[no-untyped-def]
+        if not error_code:
+            return query
+
+        if self._dialect_name == "sqlite":
+            # Task errors: array of objects like [{"error_code": "timeout", ...}]
+            # Use json_each to iterate + json_extract to match the error_code field
+            error_code_in_tasks = exists(
+                select(1)
+                .select_from(TaskModel)
+                .where(TaskModel.workflow_run_id == WorkflowRunModel.workflow_run_id)
+                .where(
+                    exists(
+                        select(1)
+                        .select_from(func.json_each(TaskModel.errors))
+                        .where(func.json_extract(literal_column("json_each.value"), "$.error_code") == error_code)
+                    )
+                )
+            )
+            # Block errors: flat array of strings like ["timeout", "network_error"]
+            error_code_in_blocks = exists(
+                select(1)
+                .select_from(WorkflowRunBlockModel)
+                .where(WorkflowRunBlockModel.workflow_run_id == WorkflowRunModel.workflow_run_id)
+                .where(
+                    exists(
+                        select(1)
+                        .select_from(func.json_each(WorkflowRunBlockModel.error_codes))
+                        .where(literal_column("json_each.value") == error_code)
+                    )
+                )
+            )
+        else:
+            # PostgreSQL: native JSONB containment
+            error_code_in_tasks = exists(
+                select(1)
+                .select_from(TaskModel)
+                .where(TaskModel.workflow_run_id == WorkflowRunModel.workflow_run_id)
+                .where(cast(TaskModel.errors, JSONB).contains(literal([{"error_code": error_code}], type_=JSONB)))
+            )
+            error_code_in_blocks = exists(
+                select(1)
+                .select_from(WorkflowRunBlockModel)
+                .where(WorkflowRunBlockModel.workflow_run_id == WorkflowRunModel.workflow_run_id)
+                .where(cast(WorkflowRunBlockModel.error_codes, JSONB).contains(literal([error_code], type_=JSONB)))
+            )
+        return query.where(or_(error_code_in_tasks, error_code_in_blocks))
+
+    @db_operation("get_workflow_runs")
+    async def get_workflow_runs(
+        self,
+        organization_id: str,
+        page: int = 1,
+        page_size: int = 10,
+        status: list[WorkflowRunStatus] | None = None,
+        ordering: tuple[str, str] | None = None,
+        search_key: str | None = None,
+        error_code: str | None = None,
+    ) -> list[WorkflowRun]:
+        async with self.Session() as session:
+            db_page = page - 1  # offset logic is 0 based
+
+            query = (
+                select(WorkflowRunModel, WorkflowModel.title)
+                .join(WorkflowModel, WorkflowModel.workflow_id == WorkflowRunModel.workflow_id)
+                .filter(WorkflowRunModel.organization_id == organization_id)
+                .filter(WorkflowRunModel.parent_workflow_run_id.is_(None))
+            )
+
+            query = self._apply_search_key_filter(query, search_key)
+            query = self._apply_error_code_filter(query, error_code)
+
+            if status:
+                query = query.filter(WorkflowRunModel.status.in_(status))
+
+            allowed_ordering_fields = {
+                "created_at": WorkflowRunModel.created_at,
+                "status": WorkflowRunModel.status,
+            }
+
+            field, direction = ("created_at", "desc")
+
+            if ordering and isinstance(ordering, tuple) and len(ordering) == 2:
+                req_field, req_direction = ordering
+                if req_field in allowed_ordering_fields and req_direction in ("asc", "desc"):
+                    field, direction = req_field, req_direction
+
+            order_column = allowed_ordering_fields[field]
+
+            if direction == "asc":
+                query = query.order_by(order_column.asc())
+            else:
+                query = query.order_by(order_column.desc())
+
+            query = query.limit(page_size).offset(db_page * page_size)
+
+            workflow_runs = (await session.execute(query)).all()
+
+            return [
+                convert_to_workflow_run(run, workflow_title=title, debug_enabled=self.debug_enabled)
+                for run, title in workflow_runs
+            ]
+
+    @db_operation("get_workflow_runs_count")
+    async def get_workflow_runs_count(
+        self,
+        organization_id: str,
+        status: list[WorkflowRunStatus] | None = None,
+    ) -> int:
+        async with self.Session() as session:
+            count_query = (
+                select(func.count())
+                .select_from(WorkflowRunModel)
+                .filter(WorkflowRunModel.organization_id == organization_id)
+            )
+            if status:
+                count_query = count_query.filter(WorkflowRunModel.status.in_(status))
+            return (await session.execute(count_query)).scalar_one()
+
+    @db_operation("get_workflow_runs_for_workflow_permanent_id")
+    async def get_workflow_runs_for_workflow_permanent_id(
+        self,
+        workflow_permanent_id: str,
+        organization_id: str,
+        page: int = 1,
+        page_size: int = 10,
+        status: list[WorkflowRunStatus] | None = None,
+        search_key: str | None = None,
+        error_code: str | None = None,
+    ) -> list[WorkflowRun]:
+        """
+        Get runs for a workflow, with optional `search_key` on run ID, parameter key/description/value,
+        or extra HTTP headers.
+        """
+        async with self.Session() as session:
+            db_page = page - 1  # offset logic is 0 based
+            query = (
+                select(WorkflowRunModel, WorkflowModel.title)
+                .join(WorkflowModel, WorkflowModel.workflow_id == WorkflowRunModel.workflow_id)
+                .filter(WorkflowRunModel.workflow_permanent_id == workflow_permanent_id)
+                .filter(WorkflowRunModel.organization_id == organization_id)
+            )
+            query = self._apply_search_key_filter(query, search_key)
+            query = self._apply_error_code_filter(query, error_code)
+            if status:
+                query = query.filter(WorkflowRunModel.status.in_(status))
+            query = query.order_by(WorkflowRunModel.created_at.desc()).limit(page_size).offset(db_page * page_size)
+            workflow_runs_and_titles_tuples = (await session.execute(query)).all()
+            workflow_runs = [
+                convert_to_workflow_run(run, workflow_title=title, debug_enabled=self.debug_enabled)
+                for run, title in workflow_runs_and_titles_tuples
+            ]
+            return workflow_runs
+
+    @db_operation("get_workflow_runs_by_parent_workflow_run_id")
+    async def get_workflow_runs_by_parent_workflow_run_id(
+        self,
+        parent_workflow_run_id: str,
+        organization_id: str | None = None,
+    ) -> list[WorkflowRun]:
+        async with self.Session() as session:
+            query = select(WorkflowRunModel).filter(WorkflowRunModel.parent_workflow_run_id == parent_workflow_run_id)
+            if organization_id is not None:
+                query = query.filter(WorkflowRunModel.organization_id == organization_id)
+            workflow_runs = (await session.scalars(query)).all()
+            return [convert_to_workflow_run(run) for run in workflow_runs]
+
+    @db_operation("get_workflow_run_output_parameters")
+    async def get_workflow_run_output_parameters(self, workflow_run_id: str) -> list[WorkflowRunOutputParameter]:
+        async with self.Session() as session:
+            workflow_run_output_parameters = (
+                await session.scalars(
+                    select(WorkflowRunOutputParameterModel)
+                    .filter_by(workflow_run_id=workflow_run_id)
+                    .order_by(WorkflowRunOutputParameterModel.created_at)
+                )
+            ).all()
+            return [
+                convert_to_workflow_run_output_parameter(parameter, self.debug_enabled)
+                for parameter in workflow_run_output_parameters
+            ]
+
+    @db_operation("get_workflow_run_output_parameter_by_id")
+    async def get_workflow_run_output_parameter_by_id(
+        self, workflow_run_id: str, output_parameter_id: str
+    ) -> WorkflowRunOutputParameter | None:
+        async with self.Session() as session:
+            parameter = (
+                await session.scalars(
+                    select(WorkflowRunOutputParameterModel)
+                    .filter_by(workflow_run_id=workflow_run_id)
+                    .filter_by(output_parameter_id=output_parameter_id)
+                    .order_by(WorkflowRunOutputParameterModel.created_at)
+                )
+            ).first()
+
+            if parameter:
+                return convert_to_workflow_run_output_parameter(parameter, self.debug_enabled)
+
+            return None
+
+    @db_operation("create_or_update_workflow_run_output_parameter")
+    async def create_or_update_workflow_run_output_parameter(
+        self,
+        workflow_run_id: str,
+        output_parameter_id: str,
+        value: dict[str, Any] | list | str | None,
+    ) -> WorkflowRunOutputParameter:
+        async with self.Session() as session:
+            # check if the workflow run output parameter already exists
+            # if it does, update the value
+            if workflow_run_output_parameter := (
+                await session.scalars(
+                    select(WorkflowRunOutputParameterModel)
+                    .filter_by(workflow_run_id=workflow_run_id)
+                    .filter_by(output_parameter_id=output_parameter_id)
+                )
+            ).first():
+                LOG.info(
+                    "Updating existing workflow run output parameter",
+                    workflow_run_id=workflow_run_output_parameter.workflow_run_id,
+                    output_parameter_id=workflow_run_output_parameter.output_parameter_id,
+                )
+                workflow_run_output_parameter.value = value
+                await session.commit()
+                await session.refresh(workflow_run_output_parameter)
+                return convert_to_workflow_run_output_parameter(workflow_run_output_parameter, self.debug_enabled)
+
+            # if it does not exist, create a new one
+            workflow_run_output_parameter = WorkflowRunOutputParameterModel(
+                workflow_run_id=workflow_run_id,
+                output_parameter_id=output_parameter_id,
+                value=value,
+            )
+            session.add(workflow_run_output_parameter)
+            await session.commit()
+            await session.refresh(workflow_run_output_parameter)
+            return convert_to_workflow_run_output_parameter(workflow_run_output_parameter, self.debug_enabled)
+
+    @db_operation("update_workflow_run_output_parameter")
+    async def update_workflow_run_output_parameter(
+        self,
+        workflow_run_id: str,
+        output_parameter_id: str,
+        value: dict[str, Any] | list | str | None,
+    ) -> WorkflowRunOutputParameter:
+        async with self.Session() as session:
+            workflow_run_output_parameter = (
+                await session.scalars(
+                    select(WorkflowRunOutputParameterModel)
+                    .filter_by(workflow_run_id=workflow_run_id)
+                    .filter_by(output_parameter_id=output_parameter_id)
+                )
+            ).first()
+            if not workflow_run_output_parameter:
+                raise NotFoundError(
+                    f"WorkflowRunOutputParameter not found for {workflow_run_id} and {output_parameter_id}"
+                )
+            workflow_run_output_parameter.value = value
+            await session.commit()
+            await session.refresh(workflow_run_output_parameter)
+            return convert_to_workflow_run_output_parameter(workflow_run_output_parameter, self.debug_enabled)
+
+    @db_operation("create_workflow_run_parameter")
+    async def create_workflow_run_parameter(
+        self, workflow_run_id: str, workflow_parameter: WorkflowParameter, value: Any
+    ) -> WorkflowRunParameter:
+        workflow_parameter_id = workflow_parameter.workflow_parameter_id
+        async with self.Session() as session:
+            workflow_run_parameter = WorkflowRunParameterModel(
+                workflow_run_id=workflow_run_id,
+                workflow_parameter_id=workflow_parameter_id,
+                value=value,
+            )
+            session.add(workflow_run_parameter)
+            await session.commit()
+            await session.refresh(workflow_run_parameter)
+            return convert_to_workflow_run_parameter(workflow_run_parameter, workflow_parameter, self.debug_enabled)
+
+    @db_operation("get_workflow_run_parameters")
+    async def get_workflow_run_parameters(
+        self, workflow_run_id: str
+    ) -> list[tuple[WorkflowParameter, WorkflowRunParameter]]:
+        async with self.Session() as session:
+            workflow_run_parameters = (
+                await session.scalars(select(WorkflowRunParameterModel).filter_by(workflow_run_id=workflow_run_id))
+            ).all()
+            results = []
+            for workflow_run_parameter in workflow_run_parameters:
+                if self._workflow_parameter_reader is None:
+                    raise RuntimeError("workflow_parameter_reader dependency not set")
+                workflow_parameter = await self._workflow_parameter_reader.get_workflow_parameter(
+                    workflow_run_parameter.workflow_parameter_id
+                )
+                if not workflow_parameter:
+                    raise WorkflowParameterNotFound(workflow_parameter_id=workflow_run_parameter.workflow_parameter_id)
+                results.append(
+                    (
+                        workflow_parameter,
+                        convert_to_workflow_run_parameter(
+                            workflow_run_parameter,
+                            workflow_parameter,
+                            self.debug_enabled,
+                        ),
+                    )
+                )
+            return results
+
+    @db_operation("get_workflow_run_block_errors")
+    async def get_workflow_run_block_errors(
+        self,
+        workflow_run_id: str,
+        organization_id: str | None = None,
+    ) -> list[tuple[list[str], str | None]]:
+        """Return (error_codes, failure_reason) tuples for blocks with non-null error_codes."""
+        async with self.Session() as session:
+            query = select(WorkflowRunBlockModel.error_codes, WorkflowRunBlockModel.failure_reason).filter_by(
+                workflow_run_id=workflow_run_id
+            )
+            if organization_id is not None:
+                query = query.filter_by(organization_id=organization_id)
+            query = query.where(WorkflowRunBlockModel.error_codes.isnot(None))
+            rows = (await session.execute(query)).all()
+            return [(row.error_codes, row.failure_reason) for row in rows]
diff --git a/skyvern/forge/sdk/db/repositories/workflows.py b/skyvern/forge/sdk/db/repositories/workflows.py
new file mode 100644
index 000000000..fd9cfb9cd
--- /dev/null
+++ b/skyvern/forge/sdk/db/repositories/workflows.py
@@ -0,0 +1,705 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any
+
+import structlog
+from sqlalchemy import exists, func, or_, select, update
+
+from skyvern.constants import DEFAULT_SCRIPT_RUN_ID
+from skyvern.forge.sdk.db._error_handling import db_operation
+from skyvern.forge.sdk.db._soft_delete import exclude_deleted
+from skyvern.forge.sdk.db.base_repository import BaseRepository
+from skyvern.forge.sdk.db.exceptions import NotFoundError
+from skyvern.forge.sdk.db.models import (
+    AWSSecretParameterModel,
+    AzureVaultCredentialParameterModel,
+    BitwardenCreditCardDataParameterModel,
+    BitwardenLoginCredentialParameterModel,
+    BitwardenSensitiveInformationParameterModel,
+    CredentialParameterModel,
+    FolderModel,
+    OnePasswordCredentialParameterModel,
+    OutputParameterModel,
+    WorkflowModel,
+    WorkflowParameterModel,
+    WorkflowRunModel,
+    WorkflowScheduleModel,
+    WorkflowTemplateModel,
+)
+from skyvern.forge.sdk.db.utils import convert_to_workflow, serialize_proxy_location
+from skyvern.forge.sdk.workflow.models.workflow import Workflow
+from skyvern.schemas.runs import ProxyLocationInput
+from skyvern.schemas.workflows import WorkflowStatus
+
+LOG = structlog.get_logger()
+
+
+class WorkflowsRepository(BaseRepository):
+    """Database operations for workflow management."""
+
+    @db_operation("create_workflow")
+    async def create_workflow(
+        self,
+        title: str,
+        workflow_definition: dict[str, Any],
+        organization_id: str | None = None,
+        description: str | None = None,
+        proxy_location: ProxyLocationInput = None,
+        webhook_callback_url: str | None = None,
+        max_screenshot_scrolling_times: int | None = None,
+        extra_http_headers: dict[str, str] | None = None,
+        totp_verification_url: str | None = None,
+        totp_identifier: str | None = None,
+        persist_browser_session: bool = False,
+        model: dict[str, Any] | None = None,
+        workflow_permanent_id: str | None = None,
+        version: int | None = None,
+        is_saved_task: bool = False,
+        status: WorkflowStatus = WorkflowStatus.published,
+        run_with: str | None = None,
+        ai_fallback: bool = True,
+        cache_key: str | None = None,
+        adaptive_caching: bool = False,
+        code_version: int | None = None,
+        generate_script_on_terminal: bool = False,
+        run_sequentially: bool = False,
+        sequential_key: str | None = None,
+        folder_id: str | None = None,
+    ) -> Workflow:
+        async with self.Session() as session:
+            workflow = WorkflowModel(
+                organization_id=organization_id,
+                title=title,
+                description=description,
+                workflow_definition=workflow_definition,
+                proxy_location=serialize_proxy_location(proxy_location),
+                webhook_callback_url=webhook_callback_url,
+                totp_verification_url=totp_verification_url,
+                totp_identifier=totp_identifier,
+                max_screenshot_scrolling_times=max_screenshot_scrolling_times,
+                extra_http_headers=extra_http_headers,
+                persist_browser_session=persist_browser_session,
+                model=model,
+                is_saved_task=is_saved_task,
+                status=status,
+                run_with=run_with,
+                ai_fallback=ai_fallback,
+                cache_key=cache_key or DEFAULT_SCRIPT_RUN_ID,
+                adaptive_caching=adaptive_caching,
+                code_version=code_version,
+                generate_script_on_terminal=generate_script_on_terminal,
+                run_sequentially=run_sequentially,
+                sequential_key=sequential_key,
+                folder_id=folder_id,
+            )
+            if workflow_permanent_id:
+                workflow.workflow_permanent_id = workflow_permanent_id
+            if version:
+                workflow.version = version
+            session.add(workflow)
+
+            # Update folder's modified_at if folder_id is provided
+            if folder_id:
+                # Validate folder exists and belongs to the same organization
+                folder_stmt = (
+                    select(FolderModel)
+                    .where(FolderModel.folder_id == folder_id)
+                    .where(FolderModel.organization_id == organization_id)
+                    .where(FolderModel.deleted_at.is_(None))
+                )
+                folder_model = await session.scalar(folder_stmt)
+                if not folder_model:
+                    raise ValueError(
+                        f"Folder {folder_id} not found or does not belong to organization {organization_id}"
+                    )
+                folder_model.modified_at = datetime.now(timezone.utc)
+
+            await session.commit()
+            await session.refresh(workflow)
+            return convert_to_workflow(workflow, self.debug_enabled)
+
+    @db_operation("soft_delete_workflow_by_id")
+    async def soft_delete_workflow_by_id(self, workflow_id: str, organization_id: str) -> None:
+        async with self.Session() as session:
+            # soft delete the workflow by setting the deleted_at field to the current time
+            update_deleted_at_query = (
+                update(WorkflowModel)
+                .where(WorkflowModel.workflow_id == workflow_id)
+                .where(WorkflowModel.organization_id == organization_id)
+                .where(WorkflowModel.deleted_at.is_(None))
+                .values(deleted_at=datetime.now(timezone.utc))
+            )
+            await session.execute(update_deleted_at_query)
+            await session.commit()
+
+    @db_operation("get_workflow")
+    async def get_workflow(self, workflow_id: str, organization_id: str | None = None) -> Workflow | None:
+        async with self.Session() as session:
+            get_workflow_query = exclude_deleted(
+                select(WorkflowModel).filter_by(workflow_id=workflow_id), WorkflowModel
+            )
+            if organization_id:
+                get_workflow_query = get_workflow_query.filter_by(organization_id=organization_id)
+            if workflow := (await session.scalars(get_workflow_query)).first():
+                is_template = (
+                    await self.is_workflow_template(
+                        workflow_permanent_id=workflow.workflow_permanent_id,
+                        organization_id=workflow.organization_id,
+                    )
+                    if organization_id
+                    else False
+                )
+                return convert_to_workflow(
+                    workflow,
+                    self.debug_enabled,
+                    is_template=is_template,
+                )
+            return None
+
+    @db_operation("get_workflow_by_permanent_id")
+    async def get_workflow_by_permanent_id(
+        self,
+        workflow_permanent_id: str,
+        organization_id: str | None = None,
+        version: int | None = None,
+        ignore_version: int | None = None,
+        filter_deleted: bool = True,
+    ) -> Workflow | None:
+        get_workflow_query = select(WorkflowModel).filter_by(workflow_permanent_id=workflow_permanent_id)
+        if filter_deleted:
+            get_workflow_query = get_workflow_query.filter(WorkflowModel.deleted_at.is_(None))
+        if organization_id:
+            get_workflow_query = get_workflow_query.filter_by(organization_id=organization_id)
+        if version:
+            get_workflow_query = get_workflow_query.filter_by(version=version)
+        if ignore_version:
+            get_workflow_query = get_workflow_query.filter(WorkflowModel.version != ignore_version)
+        get_workflow_query = get_workflow_query.order_by(WorkflowModel.version.desc())
+        async with self.Session() as session:
+            if workflow := (await session.scalars(get_workflow_query)).first():
+                is_template = (
+                    await self.is_workflow_template(
+                        workflow_permanent_id=workflow.workflow_permanent_id,
+                        organization_id=workflow.organization_id,
+                    )
+                    if organization_id
+                    else False
+                )
+                return convert_to_workflow(
+                    workflow,
+                    self.debug_enabled,
+                    is_template=is_template,
+                )
+            return None
+
+    @db_operation("get_workflow_for_workflow_run")
+    async def get_workflow_for_workflow_run(
+        self,
+        workflow_run_id: str,
+        organization_id: str | None = None,
+        filter_deleted: bool = True,
+    ) -> Workflow | None:
+        get_workflow_query = select(WorkflowModel)
+
+        if filter_deleted:
+            get_workflow_query = get_workflow_query.filter(WorkflowModel.deleted_at.is_(None))
+
+        get_workflow_query = get_workflow_query.join(
+            WorkflowRunModel,
+            WorkflowRunModel.workflow_id == WorkflowModel.workflow_id,
+        )
+
+        if organization_id:
+            get_workflow_query = get_workflow_query.filter(WorkflowRunModel.organization_id == organization_id)
+
+        get_workflow_query = get_workflow_query.filter(WorkflowRunModel.workflow_run_id == workflow_run_id)
+        async with self.Session() as session:
+            if workflow := (await session.scalars(get_workflow_query)).first():
+                is_template = (
+                    await self.is_workflow_template(
+                        workflow_permanent_id=workflow.workflow_permanent_id,
+                        organization_id=workflow.organization_id,
+                    )
+                    if organization_id
+                    else False
+                )
+                return convert_to_workflow(
+                    workflow,
+                    self.debug_enabled,
+                    is_template=is_template,
+                )
+            return None
+
+    @db_operation("get_workflow_versions_by_permanent_id")
+    async def get_workflow_versions_by_permanent_id(
+        self,
+        workflow_permanent_id: str,
+        organization_id: str | None = None,
+        filter_deleted: bool = True,
+    ) -> list[Workflow]:
+        """
+        Get all versions of a workflow by its permanent ID, ordered by version descending (newest first).
+        """
+        get_workflows_query = select(WorkflowModel).filter_by(workflow_permanent_id=workflow_permanent_id)
+        if filter_deleted:
+            get_workflows_query = get_workflows_query.filter(WorkflowModel.deleted_at.is_(None))
+        if organization_id:
+            get_workflows_query = get_workflows_query.filter_by(organization_id=organization_id)
+        get_workflows_query = get_workflows_query.order_by(WorkflowModel.version.desc())
+
+        async with self.Session() as session:
+            workflows = (await session.scalars(get_workflows_query)).all()
+            template_permanent_ids: set[str] = set()
+            if workflows and organization_id:
+                template_permanent_ids = await self.get_org_template_permanent_ids(organization_id)
+
+            return [
+                convert_to_workflow(
+                    workflow,
+                    self.debug_enabled,
+                    is_template=workflow.workflow_permanent_id in template_permanent_ids,
+                )
+                for workflow in workflows
+            ]
+
+    @db_operation("get_workflows_by_permanent_ids")
+    async def get_workflows_by_permanent_ids(
+        self,
+        workflow_permanent_ids: list[str],
+        organization_id: str | None = None,
+        page: int = 1,
+        page_size: int = 10,
+        title: str = "",
+        statuses: list[WorkflowStatus] | None = None,
+    ) -> list[Workflow]:
+        """
+        Get all workflows with the latest version for the organization.
+        """
+        if page < 1:
+            raise ValueError(f"Page must be greater than 0, got {page}")
+        db_page = page - 1
+        async with self.Session() as session:
+            subquery = (
+                select(
+                    WorkflowModel.workflow_permanent_id,
+                    func.max(WorkflowModel.version).label("max_version"),
+                )
+                .where(WorkflowModel.workflow_permanent_id.in_(workflow_permanent_ids))
+                .where(WorkflowModel.deleted_at.is_(None))
+                .group_by(
+                    WorkflowModel.workflow_permanent_id,
+                )
+                .subquery()
+            )
+            main_query = select(WorkflowModel).join(
+                subquery,
+                (WorkflowModel.workflow_permanent_id == subquery.c.workflow_permanent_id)
+                & (WorkflowModel.version == subquery.c.max_version),
+            )
+            if organization_id:
+                main_query = main_query.where(WorkflowModel.organization_id == organization_id)
+            if title:
+                main_query = main_query.where(WorkflowModel.title.ilike(f"%{title}%"))
+            if statuses:
+                main_query = main_query.where(WorkflowModel.status.in_(statuses))
+            main_query = (
+                main_query.order_by(WorkflowModel.created_at.desc()).limit(page_size).offset(db_page * page_size)
+            )
+            workflows = (await session.scalars(main_query)).all()
+
+            # Map template status by permanent_id so API responses surface is_template
+            template_permanent_ids: set[str] = set()
+            if workflows and organization_id:
+                template_permanent_ids = await self.get_org_template_permanent_ids(organization_id)
+
+            return [
+                convert_to_workflow(
+                    workflow,
+                    self.debug_enabled,
+                    is_template=workflow.workflow_permanent_id in template_permanent_ids,
+                )
+                for workflow in workflows
+            ]
+
+    @db_operation("get_workflows_by_organization_id")
+    async def get_workflows_by_organization_id(
+        self,
+        organization_id: str,
+        page: int = 1,
+        page_size: int = 10,
+        only_saved_tasks: bool = False,
+        only_workflows: bool = False,
+        only_templates: bool = False,
+        search_key: str | None = None,
+        folder_id: str | None = None,
+        statuses: list[WorkflowStatus] | None = None,
+    ) -> list[Workflow]:
+        """
+        Get all workflows with the latest version for the organization.
+
+        Search semantics:
+        - If `search_key` is provided, its value is used as a unified search term for
+          `workflows.title`, `folders.title`, and workflow parameter metadata (key, description, and default_value).
+        - If `search_key` is not provided, no search filtering is applied.
+        - Parameter metadata search excludes soft-deleted parameter rows across parameter tables.
+        """
+        if page < 1:
+            raise ValueError(f"Page must be greater than 0, got {page}")
+        db_page = page - 1
+        async with self.Session() as session:
+            subquery = (
+                select(
+                    WorkflowModel.organization_id,
+                    WorkflowModel.workflow_permanent_id,
+                    func.max(WorkflowModel.version).label("max_version"),
+                )
+                .where(WorkflowModel.organization_id == organization_id)
+                .where(WorkflowModel.deleted_at.is_(None))
+                .group_by(
+                    WorkflowModel.organization_id,
+                    WorkflowModel.workflow_permanent_id,
+                )
+                .subquery()
+            )
+            main_query = (
+                select(WorkflowModel)
+                .join(
+                    subquery,
+                    (WorkflowModel.organization_id == subquery.c.organization_id)
+                    & (WorkflowModel.workflow_permanent_id == subquery.c.workflow_permanent_id)
+                    & (WorkflowModel.version == subquery.c.max_version),
+                )
+                .outerjoin(
+                    FolderModel,
+                    (WorkflowModel.folder_id == FolderModel.folder_id)
+                    & (FolderModel.organization_id == WorkflowModel.organization_id),
+                )
+            )
+            if only_saved_tasks:
+                main_query = main_query.where(WorkflowModel.is_saved_task.is_(True))
+            elif only_workflows:
+                main_query = main_query.where(WorkflowModel.is_saved_task.is_(False))
+            if only_templates:
+                # Filter by workflow_templates table (templates at permanent_id level)
+                template_subquery = select(WorkflowTemplateModel.workflow_permanent_id).where(
+                    WorkflowTemplateModel.organization_id == organization_id,
+                    WorkflowTemplateModel.deleted_at.is_(None),
+                )
+                main_query = main_query.where(WorkflowModel.workflow_permanent_id.in_(template_subquery))
+            if statuses:
+                main_query = main_query.where(WorkflowModel.status.in_(statuses))
+            if folder_id:
+                main_query = main_query.where(WorkflowModel.folder_id == folder_id)
+            if search_key:
+                search_like = f"%{search_key}%"
+                title_like = WorkflowModel.title.ilike(search_like)
+                folder_title_like = FolderModel.title.ilike(search_like)
+
+                parameter_filters = [
+                    # WorkflowParameterModel
+                    exists(
+                        select(1)
+                        .select_from(WorkflowParameterModel)
+                        .where(WorkflowParameterModel.workflow_id == WorkflowModel.workflow_id)
+                        .where(WorkflowParameterModel.deleted_at.is_(None))
+                        .where(
+                            or_(
+                                WorkflowParameterModel.key.ilike(search_like),
+                                WorkflowParameterModel.description.ilike(search_like),
+                                WorkflowParameterModel.default_value.ilike(search_like),
+                            )
+                        )
+                    ),
+                    # OutputParameterModel
+                    exists(
+                        select(1)
+                        .select_from(OutputParameterModel)
+                        .where(OutputParameterModel.workflow_id == WorkflowModel.workflow_id)
+                        .where(OutputParameterModel.deleted_at.is_(None))
+                        .where(
+                            or_(
+                                OutputParameterModel.key.ilike(search_like),
+                                OutputParameterModel.description.ilike(search_like),
+                            )
+                        )
+                    ),
+                    # AWSSecretParameterModel
+                    exists(
+                        select(1)
+                        .select_from(AWSSecretParameterModel)
+                        .where(AWSSecretParameterModel.workflow_id == WorkflowModel.workflow_id)
+                        .where(AWSSecretParameterModel.deleted_at.is_(None))
+                        .where(
+                            or_(
+                                AWSSecretParameterModel.key.ilike(search_like),
+                                AWSSecretParameterModel.description.ilike(search_like),
+                            )
+                        )
+                    ),
+                    # BitwardenLoginCredentialParameterModel
+                    exists(
+                        select(1)
+                        .select_from(BitwardenLoginCredentialParameterModel)
+                        .where(BitwardenLoginCredentialParameterModel.workflow_id == WorkflowModel.workflow_id)
+                        .where(BitwardenLoginCredentialParameterModel.deleted_at.is_(None))
+                        .where(
+                            or_(
+                                BitwardenLoginCredentialParameterModel.key.ilike(search_like),
+                                BitwardenLoginCredentialParameterModel.description.ilike(search_like),
+                            )
+                        )
+                    ),
+                    # BitwardenSensitiveInformationParameterModel
+                    exists(
+                        select(1)
+                        .select_from(BitwardenSensitiveInformationParameterModel)
+                        .where(BitwardenSensitiveInformationParameterModel.workflow_id == WorkflowModel.workflow_id)
+                        .where(BitwardenSensitiveInformationParameterModel.deleted_at.is_(None))
+                        .where(
+                            or_(
+                                BitwardenSensitiveInformationParameterModel.key.ilike(search_like),
+                                BitwardenSensitiveInformationParameterModel.description.ilike(search_like),
+                            )
+                        )
+                    ),
+                    # BitwardenCreditCardDataParameterModel
+                    exists(
+                        select(1)
+                        .select_from(BitwardenCreditCardDataParameterModel)
+                        .where(BitwardenCreditCardDataParameterModel.workflow_id == WorkflowModel.workflow_id)
+                        .where(BitwardenCreditCardDataParameterModel.deleted_at.is_(None))
+                        .where(
+                            or_(
+                                BitwardenCreditCardDataParameterModel.key.ilike(search_like),
+                                BitwardenCreditCardDataParameterModel.description.ilike(search_like),
+                            )
+                        )
+                    ),
+                    # OnePasswordCredentialParameterModel
+                    exists(
+                        select(1)
+                        .select_from(OnePasswordCredentialParameterModel)
+                        .where(OnePasswordCredentialParameterModel.workflow_id == WorkflowModel.workflow_id)
+                        .where(OnePasswordCredentialParameterModel.deleted_at.is_(None))
+                        .where(
+                            or_(
+                                OnePasswordCredentialParameterModel.key.ilike(search_like),
+                                OnePasswordCredentialParameterModel.description.ilike(search_like),
+                            )
+                        )
+                    ),
+                    # AzureVaultCredentialParameterModel
+                    exists(
+                        select(1)
+                        .select_from(AzureVaultCredentialParameterModel)
+                        .where(AzureVaultCredentialParameterModel.workflow_id == WorkflowModel.workflow_id)
+                        .where(AzureVaultCredentialParameterModel.deleted_at.is_(None))
+                        .where(
+                            or_(
+                                AzureVaultCredentialParameterModel.key.ilike(search_like),
+                                AzureVaultCredentialParameterModel.description.ilike(search_like),
+                            )
+                        )
+                    ),
+                    # CredentialParameterModel
+                    exists(
+                        select(1)
+                        .select_from(CredentialParameterModel)
+                        .where(CredentialParameterModel.workflow_id == WorkflowModel.workflow_id)
+                        .where(CredentialParameterModel.deleted_at.is_(None))
+                        .where(
+                            or_(
+                                CredentialParameterModel.key.ilike(search_like),
+                                CredentialParameterModel.description.ilike(search_like),
+                            )
+                        )
+                    ),
+                ]
+                main_query = main_query.where(or_(title_like, folder_title_like, or_(*parameter_filters)))
+            main_query = (
+                main_query.order_by(WorkflowModel.created_at.desc()).limit(page_size).offset(db_page * page_size)
+            )
+            workflows = (await session.scalars(main_query)).all()
+            template_permanent_ids: set[str] = set()
+            if workflows and organization_id:
+                template_permanent_ids = await self.get_org_template_permanent_ids(organization_id)
+
+            return [
+                convert_to_workflow(
+                    workflow,
+                    self.debug_enabled,
+                    is_template=workflow.workflow_permanent_id in template_permanent_ids,
+                )
+                for workflow in workflows
+            ]
+
+    @db_operation("update_workflow")
+    async def update_workflow(
+        self,
+        workflow_id: str,
+        organization_id: str | None = None,
+        title: str | None = None,
+        description: str | None = None,
+        workflow_definition: dict[str, Any] | None = None,
+        version: int | None = None,
+        run_with: str | None = None,
+        cache_key: str | None = None,
+        status: str | None = None,
+        import_error: str | None = None,
+    ) -> Workflow:
+        async with self.Session() as session:
+            get_workflow_query = exclude_deleted(
+                select(WorkflowModel).filter_by(workflow_id=workflow_id), WorkflowModel
+            )
+            if organization_id:
+                get_workflow_query = get_workflow_query.filter_by(organization_id=organization_id)
+            if workflow := (await session.scalars(get_workflow_query)).first():
+                if title is not None:
+                    workflow.title = title
+                if description is not None:
+                    workflow.description = description
+                if workflow_definition is not None:
+                    workflow.workflow_definition = workflow_definition
+                if version is not None:
+                    workflow.version = version
+                if run_with is not None:
+                    workflow.run_with = run_with
+                if cache_key is not None:
+                    workflow.cache_key = cache_key
+                if status is not None:
+                    workflow.status = status
+                if import_error is not None:
+                    workflow.import_error = import_error
+                await session.commit()
+                await session.refresh(workflow)
+                is_template = (
+                    await self.is_workflow_template(
+                        workflow_permanent_id=workflow.workflow_permanent_id,
+                        organization_id=workflow.organization_id,
+                    )
+                    if organization_id
+                    else False
+                )
+                return convert_to_workflow(
+                    workflow,
+                    self.debug_enabled,
+                    is_template=is_template,
+                )
+            else:
+                raise NotFoundError("Workflow not found")
+
+    @db_operation("soft_delete_workflow_and_schedules_by_permanent_id")
+    async def soft_delete_workflow_and_schedules_by_permanent_id(
+        self,
+        workflow_permanent_id: str,
+        organization_id: str | None = None,
+    ) -> list[str]:
+        """Soft-delete a workflow and its active schedules in a single DB transaction."""
+        async with self.Session() as session:
+            select_query = (
+                select(WorkflowScheduleModel.workflow_schedule_id)
+                .where(WorkflowScheduleModel.workflow_permanent_id == workflow_permanent_id)
+                .where(WorkflowScheduleModel.deleted_at.is_(None))
+            )
+            if organization_id is not None:
+                select_query = select_query.where(WorkflowScheduleModel.organization_id == organization_id)
+            result = await session.execute(select_query)
+            schedule_ids = list(result.scalars().all())
+
+            deleted_at = datetime.now(timezone.utc)
+            if schedule_ids:
+                update_schedules_query = (
+                    update(WorkflowScheduleModel)
+                    .where(WorkflowScheduleModel.workflow_schedule_id.in_(schedule_ids))
+                    .values(deleted_at=deleted_at)
+                )
+                await session.execute(update_schedules_query)
+
+            update_workflow_query = (
+                update(WorkflowModel)
+                .where(WorkflowModel.workflow_permanent_id == workflow_permanent_id)
+                .where(WorkflowModel.deleted_at.is_(None))
+            )
+            if organization_id is not None:
+                update_workflow_query = update_workflow_query.filter_by(organization_id=organization_id)
+            await session.execute(update_workflow_query.values(deleted_at=deleted_at))
+            await session.commit()
+            return schedule_ids
+
+    @db_operation("add_workflow_template")
+    async def add_workflow_template(
+        self,
+        workflow_permanent_id: str,
+        organization_id: str,
+    ) -> None:
+        """Add a workflow to the templates table."""
+        async with self.Session() as session:
+            existing = (
+                await session.scalars(
+                    select(WorkflowTemplateModel)
+                    .where(WorkflowTemplateModel.workflow_permanent_id == workflow_permanent_id)
+                    .where(WorkflowTemplateModel.organization_id == organization_id)
+                )
+            ).first()
+            if existing:
+                if existing.deleted_at is not None:
+                    existing.deleted_at = None
+                    await session.commit()
+                return
+            template = WorkflowTemplateModel(
+                workflow_permanent_id=workflow_permanent_id,
+                organization_id=organization_id,
+            )
+            session.add(template)
+            await session.commit()
+
+    @db_operation("remove_workflow_template")
+    async def remove_workflow_template(
+        self,
+        workflow_permanent_id: str,
+        organization_id: str,
+    ) -> None:
+        """Soft delete a workflow from the templates table."""
+        async with self.Session() as session:
+            update_deleted_at_query = (
+                update(WorkflowTemplateModel)
+                .where(WorkflowTemplateModel.workflow_permanent_id == workflow_permanent_id)
+                .where(WorkflowTemplateModel.organization_id == organization_id)
+                .where(WorkflowTemplateModel.deleted_at.is_(None))
+                .values(deleted_at=datetime.now(timezone.utc))
+            )
+            await session.execute(update_deleted_at_query)
+            await session.commit()
+
+    @db_operation("get_org_template_permanent_ids")
+    async def get_org_template_permanent_ids(
+        self,
+        organization_id: str,
+    ) -> set[str]:
+        """Get all workflow_permanent_ids that are templates for an organization."""
+        async with self.Session() as session:
+            result = await session.scalars(
+                select(WorkflowTemplateModel.workflow_permanent_id)
+                .where(WorkflowTemplateModel.organization_id == organization_id)
+                .where(WorkflowTemplateModel.deleted_at.is_(None))
+            )
+            return set(result.all())
+
+    @db_operation("is_workflow_template")
+    async def is_workflow_template(
+        self,
+        workflow_permanent_id: str,
+        organization_id: str,
+    ) -> bool:
+        """Check if a workflow is marked as a template."""
+        async with self.Session() as session:
+            result = (
+                await session.scalars(
+                    select(WorkflowTemplateModel)
+                    .where(WorkflowTemplateModel.workflow_permanent_id == workflow_permanent_id)
+                    .where(WorkflowTemplateModel.organization_id == organization_id)
+                    .where(WorkflowTemplateModel.deleted_at.is_(None))
+                )
+            ).first()
+            return result is not None
diff --git a/tests/unit/forge/__init__.py b/tests/unit/forge/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/unit/forge/sdk/__init__.py b/tests/unit/forge/sdk/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/unit/forge/sdk/db/__init__.py b/tests/unit/forge/sdk/db/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/unit/forge/sdk/db/test_base_repository.py b/tests/unit/forge/sdk/db/test_base_repository.py
new file mode 100644
index 000000000..c7eaef2e8
--- /dev/null
+++ b/tests/unit/forge/sdk/db/test_base_repository.py
@@ -0,0 +1,56 @@
+from unittest.mock import MagicMock
+
+from sqlalchemy.exc import OperationalError
+
+from skyvern.forge.sdk.db.base_repository import BaseRepository
+from skyvern.forge.sdk.db.protocols import RunReader, TaskReader, WorkflowParameterReader, WorkflowReader
+from skyvern.forge.sdk.db.utils import serialize_proxy_location
+from skyvern.schemas.runs import GeoTarget, ProxyLocation
+
+
+class TestSerializeProxyLocation:
+    def test_none(self):
+        assert serialize_proxy_location(None) is None
+
+    def test_geo_target(self):
+        geo = GeoTarget(country="US", state="CA")
+        result = serialize_proxy_location(geo)
+        assert result is not None
+        assert "US" in result
+
+    def test_enum(self):
+        result = serialize_proxy_location(ProxyLocation.RESIDENTIAL)
+        assert result == "RESIDENTIAL"
+
+
+class TestBaseRepository:
+    def test_init_with_defaults(self):
+        mock_session = MagicMock()
+        repo = BaseRepository(session_factory=mock_session, debug_enabled=True)
+        assert repo.Session is mock_session
+        assert repo.debug_enabled is True
+
+    def test_is_retryable_error_default(self):
+        mock_session = MagicMock()
+        repo = BaseRepository(session_factory=mock_session)
+        error = OperationalError("statement", {}, Exception("server closed the connection unexpectedly"))
+        assert repo.is_retryable_error(error) is False  # default returns False
+
+    def test_is_retryable_error_custom(self):
+        mock_session = MagicMock()
+
+        def custom_fn(e):
+            return "closed" in str(e).lower()
+
+        repo = BaseRepository(session_factory=mock_session, is_retryable_error_fn=custom_fn)
+        error = OperationalError("statement", {}, Exception("server closed the connection"))
+        assert repo.is_retryable_error(error) is True
+
+
+class TestProtocols:
+    def test_protocols_importable(self):
+        """Protocols should be importable and runtime-checkable."""
+        assert TaskReader is not None
+        assert WorkflowReader is not None
+        assert WorkflowParameterReader is not None
+        assert RunReader is not None
diff --git a/tests/unit/forge/sdk/db/test_repositories.py b/tests/unit/forge/sdk/db/test_repositories.py
new file mode 100644
index 000000000..840f881e4
--- /dev/null
+++ b/tests/unit/forge/sdk/db/test_repositories.py
@@ -0,0 +1,238 @@
+"""Tests for all 14 OSS repository instantiations + dependency injection."""
+
+from unittest.mock import MagicMock, patch
+
+
+def test_credential_repository_instantiation():
+    from skyvern.forge.sdk.db.repositories.credentials import CredentialRepository
+
+    mock_session = MagicMock()
+    repo = CredentialRepository(session_factory=mock_session, debug_enabled=False)
+    assert repo.Session is mock_session
+    assert hasattr(repo, "create_credential")
+    assert hasattr(repo, "get_credential")
+    assert hasattr(repo, "get_credentials")
+    assert hasattr(repo, "update_credential")
+    assert hasattr(repo, "delete_credential")
+    assert hasattr(repo, "create_organization_bitwarden_collection")
+    assert hasattr(repo, "get_organization_bitwarden_collection")
+
+
+def test_otp_repository_instantiation():
+    from skyvern.forge.sdk.db.repositories.otp import OTPRepository
+
+    mock_session = MagicMock()
+    repo = OTPRepository(session_factory=mock_session, debug_enabled=False)
+    assert repo.Session is mock_session
+    assert hasattr(repo, "get_otp_codes")
+    assert hasattr(repo, "create_otp_code")
+
+
+def test_debug_repository_instantiation():
+    from skyvern.forge.sdk.db.repositories.debug import DebugRepository
+
+    mock_session = MagicMock()
+    repo = DebugRepository(session_factory=mock_session, debug_enabled=False)
+    assert repo.Session is mock_session
+    assert hasattr(repo, "get_debug_session")
+    assert hasattr(repo, "create_debug_session")
+    assert hasattr(repo, "create_block_run")
+
+
+def test_organizations_repository_instantiation():
+    from skyvern.forge.sdk.db.repositories.organizations import OrganizationsRepository
+
+    mock_session = MagicMock()
+    repo = OrganizationsRepository(session_factory=mock_session, debug_enabled=False)
+    assert repo.Session is mock_session
+    assert hasattr(repo, "get_organization")
+    assert hasattr(repo, "create_organization")
+    assert hasattr(repo, "create_org_auth_token")
+    assert hasattr(repo, "validate_org_auth_token")
+
+
+def test_schedules_repository_instantiation():
+    from skyvern.forge.sdk.db.repositories.schedules import SchedulesRepository
+
+    mock_session = MagicMock()
+    repo = SchedulesRepository(session_factory=mock_session, debug_enabled=False)
+    assert repo.Session is mock_session
+    assert hasattr(repo, "create_workflow_schedule")
+    assert hasattr(repo, "get_workflow_schedules")
+
+
+def test_scripts_repository_instantiation():
+    from skyvern.forge.sdk.db.repositories.scripts import ScriptsRepository
+
+    mock_session = MagicMock()
+    repo = ScriptsRepository(session_factory=mock_session, debug_enabled=False)
+    assert repo.Session is mock_session
+    assert hasattr(repo, "create_script")
+    assert hasattr(repo, "get_scripts")
+
+
+def test_workflow_parameters_repository_instantiation():
+    from skyvern.forge.sdk.db.repositories.workflow_parameters import WorkflowParametersRepository
+
+    mock_session = MagicMock()
+    repo = WorkflowParametersRepository(session_factory=mock_session, debug_enabled=False)
+    assert repo.Session is mock_session
+    assert hasattr(repo, "get_workflow_parameter")
+    assert hasattr(repo, "create_workflow_parameter")
+
+
+def test_tasks_repository_instantiation():
+    from skyvern.forge.sdk.db.repositories.tasks import TasksRepository
+
+    mock_session = MagicMock()
+    repo = TasksRepository(session_factory=mock_session, debug_enabled=False)
+    assert repo.Session is mock_session
+    assert hasattr(repo, "create_task")
+    assert hasattr(repo, "get_task")
+    assert hasattr(repo, "create_step")
+
+
+def test_workflows_repository_instantiation():
+    from skyvern.forge.sdk.db.repositories.workflows import WorkflowsRepository
+
+    mock_session = MagicMock()
+    repo = WorkflowsRepository(session_factory=mock_session, debug_enabled=False)
+    assert repo.Session is mock_session
+    assert hasattr(repo, "get_workflow")
+    assert hasattr(repo, "create_workflow")
+    assert hasattr(repo, "get_workflow_by_permanent_id")
+
+
+def test_browser_sessions_repository_instantiation():
+    from skyvern.forge.sdk.db.repositories.browser_sessions import BrowserSessionsRepository
+
+    mock_session = MagicMock()
+    repo = BrowserSessionsRepository(session_factory=mock_session, debug_enabled=False)
+    assert repo.Session is mock_session
+    assert hasattr(repo, "create_browser_profile")
+    assert hasattr(repo, "get_browser_profile")
+
+
+# ── Cross-dependency repositories ──
+
+
+def test_workflow_runs_repository_with_dependency():
+    from skyvern.forge.sdk.db.repositories.workflow_runs import WorkflowRunsRepository
+
+    mock_session = MagicMock()
+    mock_param_reader = MagicMock()
+    repo = WorkflowRunsRepository(
+        session_factory=mock_session,
+        debug_enabled=False,
+        workflow_parameter_reader=mock_param_reader,
+    )
+    assert repo.Session is mock_session
+    assert repo._workflow_parameter_reader is mock_param_reader
+    assert hasattr(repo, "get_workflow_run_parameters")
+    assert hasattr(repo, "create_workflow_run")
+    assert hasattr(repo, "get_workflow_run")
+
+
+def test_artifacts_repository_with_dependency():
+    from skyvern.forge.sdk.db.repositories.artifacts import ArtifactsRepository
+
+    mock_session = MagicMock()
+    mock_run_reader = MagicMock()
+    repo = ArtifactsRepository(
+        session_factory=mock_session,
+        debug_enabled=False,
+        run_reader=mock_run_reader,
+    )
+    assert repo.Session is mock_session
+    assert repo._run_reader is mock_run_reader
+    assert hasattr(repo, "create_artifact")
+    assert hasattr(repo, "get_artifact")
+
+
+def test_folders_repository_with_dependency():
+    from skyvern.forge.sdk.db.repositories.folders import FoldersRepository
+
+    mock_session = MagicMock()
+    mock_workflow_reader = MagicMock()
+    repo = FoldersRepository(
+        session_factory=mock_session,
+        debug_enabled=False,
+        workflow_reader=mock_workflow_reader,
+    )
+    assert repo.Session is mock_session
+    assert repo._workflow_reader is mock_workflow_reader
+    assert hasattr(repo, "create_folder")
+    assert hasattr(repo, "update_workflow_folder")
+
+
+def test_observer_repository_with_dependency():
+    from skyvern.forge.sdk.db.repositories.observer import ObserverRepository
+
+    mock_session = MagicMock()
+    mock_task_reader = MagicMock()
+    repo = ObserverRepository(
+        session_factory=mock_session,
+        debug_enabled=False,
+        task_reader=mock_task_reader,
+    )
+    assert repo.Session is mock_session
+    assert repo._task_reader is mock_task_reader
+    assert hasattr(repo, "create_workflow_run_block")
+    assert hasattr(repo, "get_workflow_run_blocks")
+
+
+# ── AgentDB composition test ──
+
+
+def test_agent_db_has_typed_repo_attributes():
+    """After refactoring, AgentDB should expose typed repository attributes."""
+    from skyvern.forge.sdk.db.repositories.credentials import CredentialRepository
+    from skyvern.forge.sdk.db.repositories.tasks import TasksRepository
+
+    with patch("skyvern.forge.sdk.db.agent_db.create_async_engine"):
+        from skyvern.forge.sdk.db.agent_db import AgentDB
+
+        db = AgentDB("postgresql+asyncpg://test", debug_enabled=True)
+        assert isinstance(db.tasks, TasksRepository)
+        assert isinstance(db.credentials, CredentialRepository)
+        assert hasattr(db, "get_task")  # backward compat delegate
+        assert hasattr(db, "create_workflow")
+
+
+def test_agent_db_delegates_route_to_repositories():
+    """Verify delegate methods actually forward to the correct repository."""
+    from unittest.mock import AsyncMock
+    from unittest.mock import patch as mock_patch
+
+    with mock_patch("skyvern.forge.sdk.db.agent_db.create_async_engine"):
+        from skyvern.forge.sdk.db.agent_db import AgentDB
+
+        db = AgentDB("postgresql+asyncpg://test", debug_enabled=False)
+
+    # Patch a method on each major repository and verify the delegate calls it
+    delegates_to_check = [
+        ("get_task", "tasks"),
+        ("create_workflow", "workflows"),
+        ("create_artifact", "artifacts"),
+        ("get_organization", "organizations"),
+        ("get_credential", "credentials"),
+        ("create_workflow_run", "workflow_runs"),
+    ]
+
+    import asyncio
+
+    loop = asyncio.new_event_loop()
+    try:
+        for delegate_name, repo_attr in delegates_to_check:
+            repo = getattr(db, repo_attr)
+            mock_method = AsyncMock(return_value="sentinel")
+            original = getattr(repo, delegate_name)
+            setattr(repo, delegate_name, mock_method)
+            try:
+                result = loop.run_until_complete(getattr(db, delegate_name)("arg1", key="val"))
+                mock_method.assert_called_once_with("arg1", key="val")
+                assert result == "sentinel", f"Delegate {delegate_name} did not return repository result"
+            finally:
+                setattr(repo, delegate_name, original)
+    finally:
+        loop.close()
diff --git a/tests/unit/test_agent_db_imports.py b/tests/unit/test_agent_db_imports.py
index 653b830a8..f4256c38b 100644
--- a/tests/unit/test_agent_db_imports.py
+++ b/tests/unit/test_agent_db_imports.py
@@ -5,13 +5,15 @@ Guards against:
 - Re-export contracts breaking (ScheduleLimitExceededError used by cloud/routes/)
 """
 
+from skyvern.forge.sdk.db.base_repository import BaseRepository
+
 
 def test_agent_db_exports_schedule_limit_exceeded_error() -> None:
     """ScheduleLimitExceededError must be importable from agent_db (re-export contract)."""
     from skyvern.forge.sdk.db.agent_db import ScheduleLimitExceededError
 
-    # Verify it's the canonical class, not a shadow
-    from skyvern.forge.sdk.db.mixins.schedules import ScheduleLimitExceededError as Original
+    # Verify it's the canonical class from exceptions.py, not a shadow
+    from skyvern.forge.sdk.db.exceptions import ScheduleLimitExceededError as Original
 
     assert ScheduleLimitExceededError is Original
 
@@ -23,30 +25,35 @@ def test_agent_db_exports_agent_db_class() -> None:
     assert AgentDB is not None
 
 
-def test_all_mixins_in_agent_db_mro() -> None:
-    """All 14 domain mixins must appear in AgentDB's MRO.
+def test_all_repositories_on_agent_db() -> None:
+    """All 14 domain repositories must be present as typed attributes on AgentDB.
 
-    If someone re-introduces a late import for any mixin, this test
-    catches it because the mixin won't be in the class hierarchy.
+    After the mixin-to-repository refactor, AgentDB uses composition instead
+    of inheritance. This test verifies every domain repository is wired up
+    by checking that __init__ assigns BaseRepository instances to each expected name.
     """
     from skyvern.forge.sdk.db.agent_db import AgentDB
 
-    mro_names = {cls.__name__ for cls in AgentDB.__mro__}
-    expected_mixins = [
-        "TasksMixin",
-        "WorkflowsMixin",
-        "WorkflowRunsMixin",
-        "WorkflowParametersMixin",
-        "SchedulesMixin",
-        "ArtifactsMixin",
-        "BrowserSessionsMixin",
-        "ScriptsMixin",
-        "OTPMixin",
-        "CredentialsMixin",
-        "FoldersMixin",
-        "OrganizationsMixin",
-        "ObserverMixin",
-        "DebugMixin",
+    expected_repos = [
+        "tasks",
+        "workflows",
+        "workflow_runs",
+        "workflow_params",
+        "schedules",
+        "artifacts",
+        "browser_sessions",
+        "scripts",
+        "otp",
+        "credentials",
+        "folders",
+        "organizations",
+        "observer",
+        "debug",
     ]
-    for name in expected_mixins:
-        assert name in mro_names, f"{name} missing from AgentDB MRO"
+    # Instantiate with a dummy database string (sqlite in-memory)
+    db = AgentDB("sqlite+aiosqlite:///", debug_enabled=False)
+    for repo in expected_repos:
+        assert hasattr(db, repo), f"Repository '{repo}' missing from AgentDB instance"
+        assert isinstance(getattr(db, repo), BaseRepository), (
+            f"AgentDB.{repo} should be a BaseRepository, got {type(getattr(db, repo))}"
+        )
diff --git a/tests/unit/test_db_operation_decorator.py b/tests/unit/test_db_operation_decorator.py
index d571b6961..e039d80ff 100644
--- a/tests/unit/test_db_operation_decorator.py
+++ b/tests/unit/test_db_operation_decorator.py
@@ -177,7 +177,7 @@ async def test_db_operation_log_errors_false_suppresses_logging() -> None:
 @pytest.mark.asyncio
 async def test_db_operation_schedule_limit_exceeded_is_passthrough() -> None:
     """ScheduleLimitExceededError should be treated as business logic, not unexpected."""
-    from skyvern.forge.sdk.db.mixins.schedules import ScheduleLimitExceededError
+    from skyvern.forge.sdk.db.exceptions import ScheduleLimitExceededError
 
     class ScheduleDB:
         @db_operation("create_schedule")