PR #8

rewards/__init__.py

@@ -0,0 +1,31 @@
+"""
+Modular reward functions organized by game/application.
+
+This package contains reward validation functions for different dojos,
+organized into separate modules for maintainability.
+"""
+
+from dojo_sdk_core.dojos.rewards.game_2048 import REWARD_FUNCTIONS_2048
+from dojo_sdk_core.dojos.rewards.linear import REWARD_FUNCTIONS_LINEAR
+from dojo_sdk_core.dojos.rewards.linkedin import REWARD_FUNCTIONS_LINKEDIN
+from dojo_sdk_core.dojos.rewards.minesweeper import REWARD_FUNCTIONS_MINESWEEPER
+from dojo_sdk_core.dojos.rewards.salesforce import REWARD_FUNCTIONS_SALESFORCE
+from dojo_sdk_core.dojos.rewards.tic_tac_toe import REWARD_FUNCTIONS_TIC_TAC_TOE
+
+# Unified registry of all reward functions
+REWARD_FUNCTIONS = {
+    **REWARD_FUNCTIONS_2048,
+    **REWARD_FUNCTIONS_LINEAR,
+    **REWARD_FUNCTIONS_LINKEDIN,
+    **REWARD_FUNCTIONS_SALESFORCE,
+    **REWARD_FUNCTIONS_TIC_TAC_TOE,
+    **REWARD_FUNCTIONS_MINESWEEPER,
+}
+
+
+def get_reward_function(name: str):
+    """Get a reward function by name from the unified registry."""
+    return REWARD_FUNCTIONS.get(name)
+
+
+__all__ = ["REWARD_FUNCTIONS", "get_reward_function"]

rewards/game_2048.py

@@ -0,0 +1,168 @@
+"""
+Reward functions for 2048 game tasks.
+
+All functions validate the final board state, accounting for randomly spawned tiles.
+Board is a 16-element array representing a 4x4 grid:
+  [0, 1, 2, 3,
+   4, 5, 6, 7,
+   8, 9, 10, 11,
+   12, 13, 14, 15]
+"""
+
+import logging
+from typing import Any, Dict, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+def _validate_get_2048(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that a 2048 tile is present on the board."""
+    if "board" not in final_state:
+        return 0.0, "No board in final state"
+
+    logger.debug(f"running reward function on state: {final_state}")
+    if 2048 in final_state["board"]:
+        return 1.0, "A 2048 tile is present."
+    return 0.0, "No 2048 tile is present."
+
+
+def _validate_2048_make_first_move(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that any valid move was made from the initial board state."""
+    if "board" not in final_state:
+        return 0.0, "No board in final state"
+
+    logger.debug(f"running reward function on state: {final_state}")
+
+    # Check if board changed (has non-zero tiles)
+    if any(tile != 0 for tile in final_state["board"]):
+        return 1.0, "Board changed from initial state - move was made successfully."
+
+    return 0.0, "Board is still empty - no move was made."
+
+
+def _validate_move_tiles_right(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that all tiles are in the rightmost column (positions 3, 7, 11, 15)."""
+    if "board" not in final_state:
+        return 0.0, "No board in final state"
+
+    logger.debug(f"running reward function on state: {final_state}")
+
+    board = final_state["board"]
+    rightmost_positions = [3, 7, 11, 15]
+
+    # Get all non-zero tiles and their positions
+    non_zero_positions = [i for i, tile in enumerate(board) if tile != 0]
+
+    # Check if all non-zero tiles are in rightmost column
+    if all(pos in rightmost_positions for pos in non_zero_positions):
+        return 1.0, f"All tiles successfully moved to rightmost column at positions {non_zero_positions}."
+
+    # Find which tiles are not in the rightmost column
+    misplaced = [pos for pos in non_zero_positions if pos not in rightmost_positions]
+    return 0.0, f"Some tiles are not in rightmost column. Misplaced at positions: {misplaced}"
+
+
+def _validate_get_32_tile(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that a 32 tile is present on the board."""
+    if "board" not in final_state:
+        return 0.0, "No board in final state"
+
+    logger.debug(f"running reward function on state: {final_state}")
+
+    if 32 in final_state["board"]:
+        return 1.0, "A 32 tile is present."
+    return 0.0, "No 32 tile is present."
+
+
+def _validate_get_128_tile(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that a 128 tile is present on the board."""
+    if "board" not in final_state:
+        return 0.0, "No board in final state"
+
+    logger.debug(f"running reward function on state: {final_state}")
+
+    if 128 in final_state["board"]:
+        return 1.0, "A 128 tile is present."
+    return 0.0, "No 128 tile is present."
+
+
+def _validate_get_256_tile(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that a 256 tile is present on the board."""
+    if "board" not in final_state:
+        return 0.0, "No board in final state"
+
+    logger.debug(f"running reward function on state: {final_state}")
+
+    if 256 in final_state["board"]:
+        return 1.0, "A 256 tile is present."
+    return 0.0, "No 256 tile is present."
+
+
+def _validate_get_512_tile(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that a 512 tile is present on the board."""
+    if "board" not in final_state:
+        return 0.0, "No board in final state"
+
+    logger.debug(f"running reward function on state: {final_state}")
+
+    if 512 in final_state["board"]:
+        return 1.0, "A 512 tile is present."
+    return 0.0, "No 512 tile is present."
+
+
+def _validate_create_two_high_tiles(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that at least two tiles with value 128 or higher are present."""
+    if "board" not in final_state:
+        return 0.0, "No board in final state"
+
+    logger.debug(f"running reward function on state: {final_state}")
+
+    high_tiles = [tile for tile in final_state["board"] if tile >= 128]
+    count = len(high_tiles)
+
+    if count >= 2:
+        return 1.0, f"Board contains {count} tiles with value 128 or higher: {high_tiles}."
+
+    return 0.0, f"Board contains only {count} tile(s) with value 128 or higher. Need at least 2."
+
+
+def _validate_reach_540_sum(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that the sum of all tile values is 540 or greater."""
+    if "board" not in final_state:
+        return 0.0, "No board in final state"
+
+    logger.debug(f"running reward function on state: {final_state}")
+
+    total_sum = sum(final_state["board"])
+
+    if total_sum >= 540:
+        return 1.0, f"Board sum is {total_sum}, which meets the requirement of 540 or greater."
+
+    return 0.0, f"Board sum is {total_sum}, which is below the required 540."
+
+
+def _validate_strategic_32(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that a 32 tile was created strategically from an empty board."""
+    if "board" not in final_state:
+        return 0.0, "No board in final state"
+
+    logger.debug(f"running reward function on state: {final_state}")
+
+    if 32 in final_state["board"]:
+        return 1.0, "A 32 tile was successfully created from empty board."
+    return 0.0, "No 32 tile is present."
+
+
+# Registry of all 2048 reward functions
+REWARD_FUNCTIONS_2048 = {
+    "_validate_get_2048": _validate_get_2048,
+    "_validate_2048_make_first_move": _validate_2048_make_first_move,
+    "_validate_move_tiles_right": _validate_move_tiles_right,
+    "_validate_get_32_tile": _validate_get_32_tile,
+    "_validate_get_128_tile": _validate_get_128_tile,
+    "_validate_get_256_tile": _validate_get_256_tile,
+    "_validate_get_512_tile": _validate_get_512_tile,
+    "_validate_create_two_high_tiles": _validate_create_two_high_tiles,
+    "_validate_reach_540_sum": _validate_reach_540_sum,
+    "_validate_strategic_32": _validate_strategic_32,
+}

rewards/linear.py

@@ -0,0 +1,255 @@
+"""
+Reward functions for Linear app tasks.
+"""
+
+import logging
+from typing import Any, Dict, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+def _validate_drag_to_different_column(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that an issue was moved to a different column."""
+    if "issues" not in final_state:
+        return 0.0, "No issues in final state"
+
+    logger.debug(f"Running reward function on state: {final_state}")
+
+    # Find the issue we're tracking (VSS-101)
+    target_issue = next((issue for issue in final_state["issues"] if issue.get("identifier") == "VSS-101"), None)
+
+    if not target_issue:
+        return 0.0, "Target issue VSS-101 not found in final state"
+
+    # Check if it moved to in_progress status
+    if target_issue.get("status") == "in_progress" and target_issue.get("assigneeId") == "1":
+        return 1.0, "Issue VSS-101 successfully moved to In Progress column for user 1"
+
+    return (
+        0.0,
+        f"Issue VSS-101 has status={target_issue.get('status')}, "
+        f"assigneeId={target_issue.get('assigneeId')}, expected status=in_progress, assigneeId=1",
+    )
+
+
+def _validate_drag_two_issues_same_user(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that two issues were moved within the same user's board."""
+    if "issues" not in final_state:
+        return 0.0, "No issues in final state"
+
+    logger.debug(f"Running reward function on state: {final_state}")
+
+    # Find both target issues
+    issue_101 = next((issue for issue in final_state["issues"] if issue.get("identifier") == "VSS-101"), None)
+    issue_106 = next((issue for issue in final_state["issues"] if issue.get("identifier") == "VSS-106"), None)
+
+    if not issue_101:
+        return 0.0, "Target issue VSS-101 not found in final state"
+    if not issue_106:
+        return 0.0, "Target issue VSS-106 not found in final state"
+
+    # Check both issues
+    issue_101_correct = issue_101.get("status") == "in_progress" and issue_101.get("assigneeId") == "1"
+    issue_106_correct = issue_106.get("status") == "queued" and issue_106.get("assigneeId") == "1"
+
+    if issue_101_correct and issue_106_correct:
+        return 1.0, "Both issues successfully moved to target columns for user 1"
+
+    errors = []
+    if not issue_101_correct:
+        errors.append(
+            f"VSS-101: status={issue_101.get('status')}, assigneeId={issue_101.get('assigneeId')} (expected in_progress, 1)"
+        )
+    if not issue_106_correct:
+        errors.append(
+            f"VSS-106: status={issue_106.get('status')}, assigneeId={issue_106.get('assigneeId')} (expected queued, 1)"
+        )
+
+    return 0.0, "; ".join(errors)
+
+
+def _validate_create_new_issue(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that a new issue was created with correct properties."""
+    if "issues" not in final_state:
+        return 0.0, "No issues in final state"
+
+    logger.debug(f"Running reward function on state: {final_state}")
+
+    # Find issue by title
+    target_issue = next(
+        (issue for issue in final_state["issues"] if issue.get("title") == "Implement user authentication system"), None
+    )
+
+    if not target_issue:
+        return 0.0, "Issue with title 'Implement user authentication system' not found in final state"
+
+    # Validate properties
+    errors = []
+
+    if target_issue.get("assigneeId") != "2":
+        errors.append(f"assigneeId={target_issue.get('assigneeId')} (expected '2')")
+
+    if target_issue.get("priority") != "high":
+        errors.append(f"priority={target_issue.get('priority')} (expected 'high')")
+
+    description = target_issue.get("description", "")
+    if "JWT-based authentication" not in description:
+        errors.append("description does not contain 'JWT-based authentication'")
+
+    if errors:
+        return 0.0, "; ".join(errors)
+
+    return 1.0, "Issue successfully created with correct properties"
+
+
+def _validate_drag_and_reassign_issue(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that issue VSS-106 was dragged to different status and assignee."""
+    if "issues" not in final_state:
+        return 0.0, "No issues in final state"
+
+    logger.debug(f"Running reward function on state: {final_state}")
+
+    # Find the target issue
+    target_issue = next((issue for issue in final_state["issues"] if issue.get("identifier") == "VSS-106"), None)
+
+    if not target_issue:
+        return 0.0, "Target issue VSS-106 not found in final state"
+
+    # Check if it has correct status and assigneeId
+    if target_issue.get("status") == "in_progress" and target_issue.get("assigneeId") == "2":
+        return 1.0, "Issue VSS-106 successfully moved to In Progress column for Chen (assigneeId=2)"
+
+    return (
+        0.0,
+        f"Issue VSS-106 has status={target_issue.get('status')}, "
+        f"assigneeId={target_issue.get('assigneeId')}, expected status=in_progress, assigneeId=2",
+    )
+
+
+def _validate_update_issue_properties(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that issue VSS-105 has updated priority and label."""
+    if "issues" not in final_state:
+        return 0.0, "No issues in final state"
+
+    logger.debug(f"Running reward function on state: {final_state}")
+
+    # Find the target issue
+    target_issue = next((issue for issue in final_state["issues"] if issue.get("identifier") == "VSS-105"), None)
+
+    if not target_issue:
+        return 0.0, "Target issue VSS-105 not found in final state"
+
+    # Validate properties
+    errors = []
+
+    if target_issue.get("priority") != "urgent":
+        errors.append(f"priority={target_issue.get('priority')} (expected 'urgent')")
+
+    labels = target_issue.get("labels", [])
+    has_operations_label = any(label.get("id") == "label2" for label in labels)
+    if not has_operations_label:
+        errors.append("Operations label (id='label2') not found in labels array")
+
+    if errors:
+        return 0.0, "; ".join(errors)
+
+    return 1.0, "Issue VSS-105 successfully updated with urgent priority and Operations label"
+
+
+def _validate_multi_issue_reorganization(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that three issues were reorganized to different columns and assignees."""
+    if "issues" not in final_state:
+        return 0.0, "No issues in final state"
+
+    logger.debug(f"Running reward function on state: {final_state}")
+
+    # Find all three target issues
+    issue_101 = next((issue for issue in final_state["issues"] if issue.get("identifier") == "VSS-101"), None)
+    issue_102 = next((issue for issue in final_state["issues"] if issue.get("identifier") == "VSS-102"), None)
+    issue_103 = next((issue for issue in final_state["issues"] if issue.get("identifier") == "VSS-103"), None)
+
+    if not issue_101:
+        return 0.0, "Target issue VSS-101 not found in final state"
+    if not issue_102:
+        return 0.0, "Target issue VSS-102 not found in final state"
+    if not issue_103:
+        return 0.0, "Target issue VSS-103 not found in final state"
+
+    # Check all issues
+    issue_101_correct = issue_101.get("status") == "in_progress" and issue_101.get("assigneeId") == "2"
+    issue_102_correct = issue_102.get("status") == "blocked" and issue_102.get("assigneeId") == "3"
+    issue_103_correct = issue_103.get("status") == "in_review" and issue_103.get("assigneeId") == "1"
+
+    if issue_101_correct and issue_102_correct and issue_103_correct:
+        return 1.0, "All three issues successfully reorganized to target columns and assignees"
+
+    errors = []
+    if not issue_101_correct:
+        errors.append(
+            f"VSS-101: status={issue_101.get('status')}, assigneeId={issue_101.get('assigneeId')} (expected in_progress, 2)"
+        )
+    if not issue_102_correct:
+        errors.append(
+            f"VSS-102: status={issue_102.get('status')}, assigneeId={issue_102.get('assigneeId')} (expected blocked, 3)"
+        )
+    if not issue_103_correct:
+        errors.append(
+            f"VSS-103: status={issue_103.get('status')}, assigneeId={issue_103.get('assigneeId')} (expected in_review, 1)"
+        )
+
+    return 0.0, "; ".join(errors)
+
+
+def _validate_complete_issue_workflow(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that a complete issue workflow was executed."""
+    if "issues" not in final_state:
+        return 0.0, "No issues in final state"
+
+    logger.debug(f"Running reward function on state: {final_state}")
+
+    # Find issue by title
+    target_issue = next(
+        (issue for issue in final_state["issues"] if issue.get("title") == "Fix critical database connection bug"), None
+    )
+
+    if not target_issue:
+        return 0.0, "Issue with title 'Fix critical database connection bug' not found in final state"
+
+    # Validate all properties
+    errors = []
+
+    if target_issue.get("priority") != "high":
+        errors.append(f"priority={target_issue.get('priority')} (expected 'high')")
+
+    if target_issue.get("assigneeId") != "2":
+        errors.append(f"assigneeId={target_issue.get('assigneeId')} (expected '2')")
+
+    if target_issue.get("status") != "in_progress":
+        errors.append(f"status={target_issue.get('status')} (expected 'in_progress')")
+
+    labels = target_issue.get("labels", [])
+    has_bug_label = any(label.get("id") == "label1" for label in labels)
+    if not has_bug_label:
+        errors.append("Bug label (id='label1') not found in labels array")
+
+    comments = target_issue.get("comments", [])
+    has_comment = any("Starting investigation" in comment.get("text", "") for comment in comments)
+    if not has_comment:
+        errors.append("Comment containing 'Starting investigation' not found")
+
+    if errors:
+        return 0.0, "; ".join(errors)
+
+    return 1.0, "Complete issue workflow successfully executed"
+
+
+# Registry of all Linear reward functions
+REWARD_FUNCTIONS_LINEAR = {
+    "_validate_drag_to_different_column": _validate_drag_to_different_column,
+    "_validate_drag_two_issues_same_user": _validate_drag_two_issues_same_user,
+    "_validate_create_new_issue": _validate_create_new_issue,
+    "_validate_drag_and_reassign_issue": _validate_drag_and_reassign_issue,
+    "_validate_update_issue_properties": _validate_update_issue_properties,
+    "_validate_multi_issue_reorganization": _validate_multi_issue_reorganization,
+    "_validate_complete_issue_workflow": _validate_complete_issue_workflow,
+}

rewards/linkedin.py

@@ -0,0 +1,88 @@
+"""
+Reward functions for LinkedIn app tasks.
+"""
+
+import logging
+from typing import Any, Dict, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+def _validate_search_for_dzaka(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that the user successfully searched for Dzaka Athif."""
+    logger.debug(f"Running reward function on state: {final_state}")
+
+    # Check 1: currentView is "search"
+    if final_state.get("currentView") != "search":
+        return 0.0, f"Not on search page, current view: {final_state.get('currentView')}"
+
+    # Check 2: searchQuery contains "dzaka" (case insensitive)
+    query = final_state.get("searchQuery", "").lower()
+    if "dzaka" not in query:
+        return 0.0, f"Search query doesn't contain 'dzaka': {final_state.get('searchQuery')}"
+
+    # Check 3: Dzaka Athif in search results
+    search_results = final_state.get("searchResults", {})
+    people = search_results.get("allPeople", [])
+
+    dzaka_found = any(user.get("name") == "Dzaka Athif" for user in people)
+
+    if dzaka_found:
+        return 1.0, "Successfully searched for Dzaka Athif"
+
+    return 0.0, f"Dzaka Athif not found in search results. Found {len(people)} people."
+
+
+def _validate_fractional_find_user_profile(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate LinkedIn profile navigation with fractional scoring.
+
+    Awards 0.33 points for each criterion met:
+    - currentView is 'profile'
+    - viewedUserId is '2' (John Smith)
+    - searchQuery contains 'john smith'
+    """
+    logger.debug(f"Running reward function on state: {final_state}")
+
+    score = 0.0
+    passed = []
+    failed = []
+
+    # Check 1: currentView is 'profile' (0.33 points)
+    if final_state.get("currentView") == "profile":
+        score += 0.33
+        passed.append("currentView='profile'")
+    else:
+        failed.append(f"currentView='{final_state.get('currentView')}' (expected 'profile')")
+
+    # Check 2: viewedUserId is '2' (0.33 points)
+    if final_state.get("viewedUserId") == "2":
+        score += 0.33
+        passed.append("viewedUserId='2'")
+    else:
+        failed.append(f"viewedUserId='{final_state.get('viewedUserId')}' (expected '2')")
+
+    # Check 3: searchQuery contains 'john smith' (0.33 points)
+    query = final_state.get("searchQuery", "").lower()
+    if "john smith" in query:
+        score += 0.34  # Make it add up to 1.0
+        passed.append("searchQuery contains 'john smith'")
+    else:
+        failed.append(f"searchQuery='{final_state.get('searchQuery')}' (expected to contain 'john smith')")
+
+    # Build reason string
+    reason_parts = []
+    if passed:
+        reason_parts.append(f"Passed: {', '.join(passed)}")
+    if failed:
+        reason_parts.append(f"Failed: {', '.join(failed)}")
+
+    reason = "; ".join(reason_parts) if reason_parts else "No criteria evaluated"
+
+    return round(score, 2), reason
+
+
+# Registry of all LinkedIn reward functions
+REWARD_FUNCTIONS_LINKEDIN = {
+    "_validate_search_for_dzaka": _validate_search_for_dzaka,
+    "_validate_fractional_find_user_profile": _validate_fractional_find_user_profile,
+}

rewards/minesweeper.py

@@ -0,0 +1,255 @@
+"""
+Reward functions for Minesweeper game tasks.
+
+Board is a 9x9 grid (2D array) of Cell objects:
+  Cell: {
+    isMine: boolean,
+    isRevealed: boolean,
+    isFlagged: boolean,
+    neighborMineCount: number
+  }
+
+Game statuses: "not_started", "playing", "won", "lost"
+"""
+
+import logging
+from typing import Any, Dict, List, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+# Helper functions for common validation patterns
+
+
+def _check_cells_flagged(board: List[List[Dict[str, Any]]], positions: List[Tuple[int, int]]) -> Tuple[float, str]:
+    """
+    Helper function to check if specific cells are flagged.
+
+    Args:
+        board: The game board (2D array)
+        positions: List of (row, col) tuples to check
+
+    Returns:
+        (1.0, success_message) if all positions are flagged
+        (0.0, error_message) otherwise
+    """
+    flagged = []
+    unflagged = []
+
+    for row, col in positions:
+        # Check if position exists
+        if row >= len(board) or col >= len(board[row]):
+            return 0.0, f"Position [{row}][{col}] does not exist on board"
+
+        if board[row][col].get("isFlagged"):
+            flagged.append(f"[{row}][{col}]")
+        else:
+            unflagged.append(f"[{row}][{col}]")
+
+    if len(flagged) == len(positions):
+        cells_str = ", ".join(flagged)
+        return 1.0, f"All {len(positions)} cell(s) flagged successfully: {cells_str}."
+
+    return 0.0, f"Not all cells flagged. Flagged: {flagged}, Not flagged: {unflagged}"
+
+
+def _check_cells_revealed(board: List[List[Dict[str, Any]]], min_count: int, check_for_mines: bool = True) -> Tuple[float, str]:
+    """
+    Helper function to check if minimum number of cells are revealed.
+
+    Args:
+        board: The game board (2D array)
+        min_count: Minimum number of cells that should be revealed
+        check_for_mines: If True, fail if any revealed cell is a mine
+
+    Returns:
+        (1.0, success_message) if criteria met
+        (0.0, error_message) otherwise
+    """
+    revealed_count = 0
+    revealed_mine = False
+
+    for row in board:
+        for cell in row:
+            if cell.get("isRevealed"):
+                revealed_count += 1
+                if check_for_mines and cell.get("isMine"):
+                    revealed_mine = True
+
+    if check_for_mines and revealed_mine:
+        return 0.0, "A mine was revealed - task failed"
+
+    if revealed_count >= min_count:
+        return 1.0, f"Successfully revealed {revealed_count} safe cells (target: {min_count}+)."
+
+    return 0.0, f"Only {revealed_count} cells revealed, need at least {min_count}"
+
+
+# Task-specific validation functions
+
+
+def _validate_minesweeper_reveal_first_cell(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that first move was made - at least one cell revealed and game is playing."""
+    if "gameStatus" not in final_state:
+        return 0.0, "No gameStatus in final state"
+
+    if "board" not in final_state:
+        return 0.0, "No board in final state"
+
+    logger.debug(f"running reward function on state: {final_state}")
+
+    # Check if game status changed to playing
+    if final_state["gameStatus"] != "playing":
+        return 0.0, f"Game status is '{final_state['gameStatus']}', expected 'playing'"
+
+    # Check if at least one cell is revealed
+    board = final_state["board"]
+    revealed_count = 0
+
+    for row in board:
+        for cell in row:
+            if cell.get("isRevealed"):
+                revealed_count += 1
+
+    if revealed_count > 0:
+        return 1.0, f"First move successful - {revealed_count} cell(s) revealed and game is playing."
+
+    return 0.0, "No cells revealed yet."
+
+
+def _validate_minesweeper_reveal_numbered_cell(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that a numbered cell (with neighborMineCount > 0) was revealed at position [1][1]."""
+    if "board" not in final_state:
+        return 0.0, "No board in final state"
+
+    logger.debug(f"running reward function on state: {final_state}")
+
+    board = final_state["board"]
+
+    # Check if position [1][1] exists
+    if len(board) < 2 or len(board[1]) < 2:
+        return 0.0, "Board does not have position [1][1]"
+
+    target_cell = board[1][1]
+
+    # Check if cell is revealed
+    if not target_cell.get("isRevealed"):
+        return 0.0, "Cell at [1][1] is not revealed"
+
+    # Check if cell shows a number (neighborMineCount > 0)
+    neighbor_count = target_cell.get("neighborMineCount", 0)
+
+    if neighbor_count > 0:
+        return 1.0, f"Cell at [1][1] revealed successfully showing {neighbor_count} neighboring mine(s)."
+
+    return 0.0, f"Cell at [1][1] has neighborMineCount of {neighbor_count}, expected > 0"
+
+
+def _validate_minesweeper_reveal_10_cells(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that at least 10 cells are revealed, none are mines, and game is still playing."""
+    if "board" not in final_state:
+        return 0.0, "No board in final state"
+
+    if "gameStatus" not in final_state:
+        return 0.0, "No gameStatus in final state"
+
+    logger.debug(f"running reward function on state: {final_state}")
+
+    # Check if game is still playing
+    if final_state["gameStatus"] != "playing":
+        return 0.0, f"Game status is '{final_state['gameStatus']}', expected 'playing'"
+
+    return _check_cells_revealed(final_state["board"], 10, check_for_mines=True)
+
+
+def _validate_minesweeper_reveal_20_cells(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that at least 20 cells are revealed and game is still playing."""
+    if "board" not in final_state:
+        return 0.0, "No board in final state"
+
+    if "gameStatus" not in final_state:
+        return 0.0, "No gameStatus in final state"
+
+    logger.debug(f"running reward function on state: {final_state}")
+
+    # Check if game is still playing
+    if final_state["gameStatus"] != "playing":
+        return 0.0, f"Game status is '{final_state['gameStatus']}', expected 'playing' (game should not be won or lost yet)"
+
+    return _check_cells_revealed(final_state["board"], 20, check_for_mines=True)
+
+
+def _validate_minesweeper_flag_single_mine(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that cell at position [0][0] is flagged."""
+    if "board" not in final_state:
+        return 0.0, "No board in final state"
+
+    logger.debug(f"running reward function on state: {final_state}")
+
+    return _check_cells_flagged(final_state["board"], [(0, 0)])
+
+
+def _validate_minesweeper_flag_three_mines(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that cells at [0][0], [0][8], and [8][0] are all flagged."""
+    if "board" not in final_state:
+        return 0.0, "No board in final state"
+
+    logger.debug(f"running reward function on state: {final_state}")
+
+    target_positions = [(0, 0), (0, 8), (8, 0)]
+    return _check_cells_flagged(final_state["board"], target_positions)
+
+
+def _validate_minesweeper_flag_corner_mines(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that all four corner cells [0][0], [0][8], [8][0], [8][8] are flagged."""
+    if "board" not in final_state:
+        return 0.0, "No board in final state"
+
+    logger.debug(f"running reward function on state: {final_state}")
+
+    corner_positions = [(0, 0), (0, 8), (8, 0), (8, 8)]
+    return _check_cells_flagged(final_state["board"], corner_positions)
+
+
+def _validate_minesweeper_reveal_safe_cell(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that cell at position [4][4] is revealed and has 0 neighboring mines."""
+    if "board" not in final_state:
+        return 0.0, "No board in final state"
+
+    logger.debug(f"running reward function on state: {final_state}")
+
+    board = final_state["board"]
+
+    # Check if position [4][4] exists
+    if len(board) < 5 or len(board[4]) < 5:
+        return 0.0, "Board does not have position [4][4]"
+
+    target_cell = board[4][4]
+
+    # Check if cell is revealed
+    if not target_cell.get("isRevealed"):
+        return 0.0, "Cell at [4][4] is not revealed"
+
+    # Check if it's not a mine
+    if target_cell.get("isMine"):
+        return 0.0, "Cell at [4][4] is a mine - task failed!"
+
+    # Check if it has 0 neighboring mines
+    neighbor_count = target_cell.get("neighborMineCount", -1)
+    if neighbor_count == 0:
+        return 1.0, "Cell at [4][4] revealed successfully with 0 neighboring mines."
+
+    return 0.0, f"Cell at [4][4] has {neighbor_count} neighboring mines, expected 0"
+
+
+# Registry of all minesweeper reward functions
+REWARD_FUNCTIONS_MINESWEEPER = {
+    "_validate_minesweeper_reveal_first_cell": _validate_minesweeper_reveal_first_cell,
+    "_validate_minesweeper_reveal_numbered_cell": _validate_minesweeper_reveal_numbered_cell,
+    "_validate_minesweeper_reveal_10_cells": _validate_minesweeper_reveal_10_cells,
+    "_validate_minesweeper_reveal_20_cells": _validate_minesweeper_reveal_20_cells,
+    "_validate_minesweeper_flag_single_mine": _validate_minesweeper_flag_single_mine,
+    "_validate_minesweeper_flag_three_mines": _validate_minesweeper_flag_three_mines,
+    "_validate_minesweeper_flag_corner_mines": _validate_minesweeper_flag_corner_mines,
+    "_validate_minesweeper_reveal_safe_cell": _validate_minesweeper_reveal_safe_cell,
+}

rewards/salesforce.py

@@ -0,0 +1,423 @@
+"""
+Salesforce reward functions for CRM task validation.
+
+This module contains reward validation functions for Salesforce CRM tasks,
+particularly for complex workflows like lead conversion.
+"""
+
+from typing import Any, Dict, Tuple
+
+
+def _validate_salesforce_convert_lead(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """
+    Validate that a lead has been successfully converted to a contact.
+
+    This function checks:
+    1. The active tab is the leads list page
+    2. The lead has status 'Converted' and a convertedToContactId
+    3. A new contact exists with the lead's information (name: Michael Brown)
+
+    Args:
+        initial_state: The initial state before the conversion
+        final_state: The final state after the conversion
+
+    Returns:
+        Tuple of (score, reason) where score is 1.0 for success, 0.0 for failure
+    """
+    try:
+        # Check 1: Active tab should be the leads list page
+        active_tab_id = final_state.get("activeTabId")
+        if active_tab_id != "home-listLeads":
+            return 0.0, f"Expected activeTabId to be 'home-listLeads', got '{active_tab_id}'"
+
+        # Check 2: Lead should be marked as converted
+        leads = final_state.get("leads", [])
+        if not leads:
+            return 0.0, "No leads found in final state"
+
+        # Find the lead (should be lead-001)
+        lead = None
+        for temp_lead in leads:
+            if temp_lead.get("id") == "lead-001":
+                lead = temp_lead
+                break
+
+        if not lead:
+            return 0.0, "Lead with id 'lead-001' not found"
+
+        # Check lead status and convertedToContactId
+        lead_status = lead.get("leadStatus")
+        converted_to_contact_id = lead.get("convertedToContactId")
+
+        if lead_status != "Converted":
+            return 0.0, f"Expected leadStatus to be 'Converted', got '{lead_status}'"
+
+        if not converted_to_contact_id:
+            return 0.0, "Expected convertedToContactId to be set, but it's missing"
+
+        # Check 3: Contact should exist with the lead's information
+        contacts = final_state.get("contacts", [])
+        if not contacts:
+            return 0.0, "No contacts found in final state"
+
+        # Find the contact by the convertedToContactId
+        contact = None
+        for c in contacts:
+            if c.get("id") == converted_to_contact_id:
+                contact = c
+                break
+
+        if not contact:
+            return 0.0, f"Contact with id '{converted_to_contact_id}' not found"
+
+        # Verify the contact has the correct information (name should be Michael Brown)
+        contact_name = contact.get("name")
+        if contact_name != "Michael Brown":
+            return 0.0, f"Expected contact name to be 'Michael Brown', got '{contact_name}'"
+
+        # Additional validation: check that contact has the lead's company
+        contact_company = contact.get("company")
+        lead_company = lead.get("company")
+        if contact_company != lead_company:
+            return 0.0, f"Contact company '{contact_company}' doesn't match lead company '{lead_company}'"
+
+        # All checks passed
+        return 1.0, "Lead successfully converted to contact with correct information"
+
+    except Exception as e:
+        return 0.0, f"Error during validation: {str(e)}"
+
+
+def _validate_salesforce_create_and_convert_lead(
+    initial_state: Dict[str, Any], final_state: Dict[str, Any]
+) -> Tuple[float, str]:
+    """
+    Validate that a lead has been created and successfully converted to a contact.
+
+    This function checks:
+    1. The active tab is the leads list page
+    2. A lead exists with name 'Robert Taylor' and status 'Converted'
+    3. The lead has a convertedToContactId set
+    4. A new contact exists with the lead's information
+    5. The contact has the correct name and company
+
+    Args:
+        initial_state: The initial state before the creation and conversion
+        final_state: The final state after the creation and conversion
+
+    Returns:
+        Tuple of (score, reason) where score is 1.0 for success, 0.0 for failure
+    """
+    try:
+        # Check 1: Active tab should be the leads list page
+        active_tab_id = final_state.get("activeTabId")
+        if active_tab_id != "home-listLeads":
+            return 0.0, f"Expected activeTabId to be 'home-listLeads', got '{active_tab_id}'"
+
+        # Check 2: Lead should exist and be marked as converted
+        leads = final_state.get("leads", [])
+        if not leads:
+            return 0.0, "No leads found in final state"
+
+        # Find the lead with name 'Robert Taylor'
+        robert_lead = None
+        for lead in leads:
+            if lead.get("name") == "Robert Taylor":
+                robert_lead = lead
+                break
+
+        if not robert_lead:
+            return 0.0, "Lead with name 'Robert Taylor' not found"
+
+        # Check lead status and convertedToContactId
+        lead_status = robert_lead.get("leadStatus")
+        converted_to_contact_id = robert_lead.get("convertedToContactId")
+
+        if lead_status != "Converted":
+            return 0.0, f"Expected leadStatus to be 'Converted', got '{lead_status}'"
+
+        if not converted_to_contact_id:
+            return 0.0, "Expected convertedToContactId to be set, but it's missing"
+
+        # Check 3: Contact should exist with the lead's information
+        contacts = final_state.get("contacts", [])
+        if not contacts:
+            return 0.0, "No contacts found in final state"
+
+        # Find the contact by the convertedToContactId
+        contact = None
+        for c in contacts:
+            if c.get("id") == converted_to_contact_id:
+                contact = c
+                break
+
+        if not contact:
+            return 0.0, f"Contact with id '{converted_to_contact_id}' not found"
+
+        # Verify the contact has the correct information
+        contact_name = contact.get("name")
+        if contact_name != "Robert Taylor":
+            return 0.0, f"Expected contact name to be 'Robert Taylor', got '{contact_name}'"
+
+        # Check that contact has the lead's company
+        contact_company = contact.get("company")
+        lead_company = robert_lead.get("company")
+        if contact_company != lead_company:
+            return 0.0, f"Contact company '{contact_company}' doesn't match lead company '{lead_company}'"
+
+        # Additional validation: check that contact has the lead's email
+        contact_email = contact.get("email")
+        lead_email = robert_lead.get("email")
+        if contact_email != lead_email:
+            return 0.0, f"Contact email '{contact_email}' doesn't match lead email '{lead_email}'"
+
+        # Verify the lead was created from scratch (not in initial state)
+        initial_leads = initial_state.get("leads", [])
+        initial_robert_exists = any(lead.get("name") == "Robert Taylor" for lead in initial_leads)
+        if initial_robert_exists:
+            return 0.0, "Lead 'Robert Taylor' already existed in initial state - should be newly created"
+
+        # All checks passed
+        return 1.0, "Lead 'Robert Taylor' successfully created and converted to contact with correct information"
+
+    except Exception as e:
+        return 0.0, f"Error during validation: {str(e)}"
+
+
+def _validate_salesforce_create_new_lead(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """
+    Validate that a new lead has been successfully created.
+
+    This function checks:
+    1. The active tab is a lead details page
+    2. A lead exists with name 'Jane Smith' and company 'Innovation Labs'
+    3. The lead was not in the initial state (proves it was created)
+
+    Args:
+        initial_state: The initial state before the lead creation
+        final_state: The final state after the lead creation
+
+    Returns:
+        Tuple of (score, reason) where score is 1.0 for success, 0.0 for failure
+    """
+    try:
+        # Check 1: Active tab should be a lead details page
+        active_tab_id = final_state.get("activeTabId")
+        if not active_tab_id or not active_tab_id.startswith("lead-"):
+            return 0.0, f"Expected activeTabId to start with 'lead-', got '{active_tab_id}'"
+
+        # Check 2: Lead should exist with correct information
+        leads = final_state.get("leads", [])
+        if not leads:
+            return 0.0, "No leads found in final state"
+
+        # Find the lead with name 'Jane Smith'
+        jane_lead = None
+        for lead in leads:
+            if lead.get("name") == "Jane Smith":
+                jane_lead = lead
+                break
+
+        if not jane_lead:
+            return 0.0, "Lead with name 'Jane Smith' not found"
+
+        # Check company
+        if jane_lead.get("company") != "Innovation Labs":
+            return 0.0, f"Expected company to be 'Innovation Labs', got '{jane_lead.get('company')}'"
+
+        # Check 3: Verify the lead was created from scratch
+        initial_leads = initial_state.get("leads", [])
+        initial_jane_exists = any(lead.get("name") == "Jane Smith" for lead in initial_leads)
+        if initial_jane_exists:
+            return 0.0, "Lead 'Jane Smith' already existed in initial state - should be newly created"
+
+        # All checks passed
+        return 1.0, "Lead 'Jane Smith' successfully created with correct information"
+
+    except Exception as e:
+        return 0.0, f"Error during validation: {str(e)}"
+
+
+def _validate_salesforce_create_new_case(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """
+    Validate that a new case has been successfully created.
+
+    This function checks:
+    1. The active tab is a case details page
+    2. A case exists with subject 'Technical support request'
+    3. The case was not in the initial state (proves it was created)
+
+    Args:
+        initial_state: The initial state before the case creation
+        final_state: The final state after the case creation
+
+    Returns:
+        Tuple of (score, reason) where score is 1.0 for success, 0.0 for failure
+    """
+    try:
+        # Check 1: Active tab should be a case details page
+        active_tab_id = final_state.get("activeTabId")
+        if not active_tab_id or not active_tab_id.startswith("case-"):
+            return 0.0, f"Expected activeTabId to start with 'case-', got '{active_tab_id}'"
+
+        # Check 2: Case should exist with correct subject
+        cases = final_state.get("cases", [])
+        if not cases:
+            return 0.0, "No cases found in final state"
+
+        # Find the case with subject 'Technical support request'
+        support_case = None
+        for case in cases:
+            if case.get("subject") == "Technical support request":
+                support_case = case
+                break
+
+        if not support_case:
+            return 0.0, "Case with subject 'Technical support request' not found"
+
+        # Check 3: Verify the case was created from scratch
+        initial_cases = initial_state.get("cases", [])
+        initial_case_exists = any(case.get("subject") == "Technical support request" for case in initial_cases)
+        if initial_case_exists:
+            return 0.0, "Case 'Technical support request' already existed in initial state - should be newly created"
+
+        # All checks passed
+        return 1.0, "Case 'Technical support request' successfully created"
+
+    except Exception as e:
+        return 0.0, f"Error during validation: {str(e)}"
+
+
+def _validate_salesforce_edit_lead_inline(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """
+    Validate that a lead's title has been successfully edited inline.
+
+    This function checks:
+    1. Lead with id 'lead-001' exists
+    2. The lead's title has been changed from 'VP of Sales' to 'Senior VP of Sales'
+    3. Other lead fields remain unchanged
+
+    Args:
+        initial_state: The initial state before the edit
+        final_state: The final state after the edit
+
+    Returns:
+        Tuple of (score, reason) where score is 1.0 for success, 0.0 for failure
+    """
+    try:
+        # Get the lead from both states
+        initial_leads = initial_state.get("leads", [])
+        final_leads = final_state.get("leads", [])
+
+        initial_lead = None
+        for lead in initial_leads:
+            if lead.get("id") == "lead-001":
+                initial_lead = lead
+                break
+
+        final_lead = None
+        for lead in final_leads:
+            if lead.get("id") == "lead-001":
+                final_lead = lead
+                break
+
+        if not initial_lead:
+            return 0.0, "Lead 'lead-001' not found in initial state"
+
+        if not final_lead:
+            return 0.0, "Lead 'lead-001' not found in final state"
+
+        # Check that title was updated correctly
+        if initial_lead.get("title") != "VP of Sales":
+            return 0.0, f"Initial title should be 'VP of Sales', got '{initial_lead.get('title')}'"
+
+        if final_lead.get("title") != "Senior VP of Sales":
+            return 0.0, f"Expected title to be 'Senior VP of Sales', got '{final_lead.get('title')}'"
+
+        # Check that other important fields remain unchanged
+        fields_to_check = ["name", "company", "email", "phone", "leadStatus"]
+        for field in fields_to_check:
+            if initial_lead.get(field) != final_lead.get(field):
+                return 0.0, f"Field '{field}' should not have changed, but it did"
+
+        # All checks passed
+        return 1.0, "Lead title successfully updated to 'Senior VP of Sales'"
+
+    except Exception as e:
+        return 0.0, f"Error during validation: {str(e)}"
+
+
+def _validate_salesforce_create_and_close_case(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """
+    Validate that a case has been created and successfully closed.
+
+    This function checks:
+    1. The active tab is still a case details page
+    2. A case exists with subject 'Customer complaint resolved' and status 'Closed'
+    3. The case was not in the initial state (proves it was created)
+
+    Args:
+        initial_state: The initial state before the case creation and closure
+        final_state: The final state after the case creation and closure
+
+    Returns:
+        Tuple of (score, reason) where score is 1.0 for success, 0.0 for failure
+    """
+    try:
+        # Check 1: Active tab should still be a case details page
+        active_tab_id = final_state.get("activeTabId")
+        if not active_tab_id or not active_tab_id.startswith("case-"):
+            return 0.0, f"Expected activeTabId to start with 'case-', got '{active_tab_id}'"
+
+        # Check 2: Case should exist with correct subject and be closed
+        cases = final_state.get("cases", [])
+        if not cases:
+            return 0.0, "No cases found in final state"
+
+        # Find the case with subject 'Customer complaint resolved'
+        complaint_case = None
+        for case in cases:
+            if case.get("subject") == "Customer complaint resolved":
+                complaint_case = case
+                break
+
+        if not complaint_case:
+            return 0.0, "Case with subject 'Customer complaint resolved' not found"
+
+        # Check case status
+        case_status = complaint_case.get("status")
+        if case_status != "Closed":
+            return 0.0, f"Expected case status to be 'Closed', got '{case_status}'"
+
+        # Check 3: Verify the case was created from scratch
+        initial_cases = initial_state.get("cases", [])
+        initial_case_exists = any(case.get("subject") == "Customer complaint resolved" for case in initial_cases)
+        if initial_case_exists:
+            return 0.0, "Case 'Customer complaint resolved' already existed in initial state - should be newly created"
+
+        # All checks passed
+        return 1.0, "Case 'Customer complaint resolved' successfully created and closed"
+
+    except Exception as e:
+        return 0.0, f"Error during validation: {str(e)}"
+
+
+# Registry of Salesforce reward functions
+REWARD_FUNCTIONS_SALESFORCE = {
+    "_validate_salesforce_convert_lead": _validate_salesforce_convert_lead,
+    "_validate_salesforce_create_and_convert_lead": _validate_salesforce_create_and_convert_lead,
+    "_validate_salesforce_create_new_lead": _validate_salesforce_create_new_lead,
+    "_validate_salesforce_create_new_case": _validate_salesforce_create_new_case,
+    "_validate_salesforce_edit_lead_inline": _validate_salesforce_edit_lead_inline,
+    "_validate_salesforce_create_and_close_case": _validate_salesforce_create_and_close_case,
+}
+
+__all__ = [
+    "REWARD_FUNCTIONS_SALESFORCE",
+    "_validate_salesforce_convert_lead",
+    "_validate_salesforce_create_and_convert_lead",
+    "_validate_salesforce_create_new_lead",
+    "_validate_salesforce_create_new_case",
+    "_validate_salesforce_edit_lead_inline",
+    "_validate_salesforce_create_and_close_case",
+]

rewards/tic_tac_toe.py

@@ -0,0 +1,82 @@
+"""
+Reward functions for tic-tac-toe game tasks.
+
+Board is a 9-element array representing a 3x3 grid:
+  [0, 1, 2,
+   3, 4, 5,
+   6, 7, 8]
+
+Players: "X" (human), "O" (computer), or null (empty)
+"""
+
+import logging
+from typing import Any, Dict, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+def _validate_tic_tac_toe_make_first_move(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that a move was made on previously empty board."""
+    if "board" not in final_state:
+        return 0.0, "No board in final state"
+
+    logger.debug(f"running reward function on state: {final_state}")
+
+    board = final_state["board"]
+
+    # Check if board has any non-null values
+    if all(cell is None for cell in board):
+        return 0.0, "Board is still empty - no move was made."
+
+    # Check if board has at least one X
+    if "X" in board:
+        return 1.0, "First move made successfully - X placed on board."
+
+    return 0.0, "No X found on board."
+
+
+def _validate_take_center(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that X was placed in center position (index 4)."""
+    if "board" not in final_state:
+        return 0.0, "No board in final state"
+
+    logger.debug(f"running reward function on state: {final_state}")
+
+    board = final_state["board"]
+
+    # Check if center position (index 4) contains X
+    if board[4] == "X":
+        return 1.0, "Center square successfully taken by X."
+
+    center_value = board[4] if board[4] is not None else "empty"
+    return 0.0, f"Center square not taken by X. Center is: {center_value}"
+
+
+def _validate_block_computer_win(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that X blocked computer's win at position 2."""
+    if "board" not in final_state:
+        return 0.0, "No board in final state"
+
+    logger.debug(f"running reward function on state: {final_state}")
+
+    board = final_state["board"]
+
+    # Check if position 2 (top-right) contains X
+    if board[2] != "X":
+        position_value = board[2] if board[2] is not None else "empty"
+        return 0.0, f"Position 2 not blocked by X. Position 2 is: {position_value}"
+
+    # Check that game is still ongoing (player hasn't lost)
+    winner = final_state.get("winner")
+    if winner == "O":
+        return 0.0, "Computer (O) won - blocking was unsuccessful."
+
+    return 1.0, "Successfully blocked computer's winning move at position 2."
+
+
+# Registry of all tic-tac-toe reward functions
+REWARD_FUNCTIONS_TIC_TAC_TOE = {
+    "_validate_tic_tac_toe_make_first_move": _validate_tic_tac_toe_make_first_move,
+    "_validate_take_center": _validate_take_center,
+    "_validate_block_computer_win": _validate_block_computer_win,
+}