Fix puzzle UI and verifier normalization

space_app/board_utils.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+from typing import Iterable
+
+
+def split_lines(board: str) -> list[str]:
+    return board.replace("\r", "").split("\n")
+
+
+def pad_lines(lines: Iterable[str], width: int) -> list[str]:
+    return [line.ljust(width) for line in lines]
+
+
+def join_grid(grid: list[list[str]]) -> str:
+    return "\n".join("".join(row) for row in grid)
+
+
+def _parse_loopy(problem_ascii: str) -> tuple[list[str], list[tuple[int, int]], list[tuple[int, int]]]:
+    lines = split_lines(problem_ascii)
+    rows = max(0, (len(lines) - 3) // 2)
+    cols = max(0, ((len(lines[0]) if lines else 0) - 3) // 2)
+    horizontal_edges: list[tuple[int, int]] = []
+    vertical_edges: list[tuple[int, int]] = []
+
+    for row in range(rows + 1):
+        for col in range(cols):
+            horizontal_edges.append((1 + 2 * row, 2 + 2 * col))
+
+    for row in range(rows):
+        for col in range(cols + 1):
+            vertical_edges.append((2 + 2 * row, 1 + 2 * col))
+
+    return lines, horizontal_edges, vertical_edges
+
+
+def normalize_loopy_board(problem_ascii: str, board_ascii: str) -> str:
+    puzzle_lines, horizontal_edges, vertical_edges = _parse_loopy(problem_ascii)
+    width = len(puzzle_lines[0]) if puzzle_lines else 0
+    grid = [list(line) for line in pad_lines(split_lines(board_ascii), width)]
+    if not grid:
+        grid = [list(line) for line in pad_lines(puzzle_lines, width)]
+
+    for row, col in horizontal_edges:
+        current = grid[row][col]
+        if current != "-":
+            grid[row][col] = "x"
+
+    for row, col in vertical_edges:
+        current = grid[row][col]
+        if current != "|":
+            grid[row][col] = "x"
+
+    return join_grid(grid)
+
+
+def _parse_pattern_rows(board_ascii: str) -> tuple[list[str], list[str], list[str]]:
+    lines = split_lines(board_ascii)
+    clue_lines: list[str] = []
+    content_lines: list[str] = []
+    border_lines: list[str] = []
+
+    grid_started = False
+    for line in lines:
+        if "|" in line:
+            grid_started = True
+            content_lines.append(line)
+        elif "+" in line and "-" in line:
+            if grid_started:
+                border_lines.append(line)
+            else:
+                clue_lines.append(line)
+        else:
+            clue_lines.append(line)
+
+    return clue_lines, content_lines, border_lines
+
+
+def normalize_pattern_board(board_ascii: str) -> str:
+    clue_lines, content_lines, border_lines = _parse_pattern_rows(board_ascii)
+    if not content_lines:
+        return board_ascii
+
+    normalized: list[str] = [*clue_lines]
+    border_iter = iter(border_lines)
+
+    if border_lines:
+        normalized.append(next(border_iter))
+
+    for content in content_lines:
+        pieces = content.split("|")
+        if len(pieces) < 3:
+            normalized.append(content)
+            continue
+        next_pieces = [pieces[0]]
+        for cell in pieces[1:-1]:
+            next_pieces.append(".." if cell == "  " else cell)
+        next_pieces.append(pieces[-1])
+        normalized.append("|".join(next_pieces))
+        try:
+            normalized.append(next(border_iter))
+        except StopIteration:
+            pass
+
+    return "\n".join(normalized)
+
+
+def normalize_board_for_display(*, puzzle_type: str, problem_ascii: str, board_ascii: str) -> str:
+    if puzzle_type == "loopy":
+        return normalize_loopy_board(problem_ascii, board_ascii)
+    if puzzle_type == "pattern":
+        return normalize_pattern_board(board_ascii)
+    return board_ascii
+
+
+def normalize_board_for_submission(*, puzzle_type: str, problem_ascii: str, board_ascii: str) -> str:
+    if puzzle_type == "loopy":
+        return normalize_loopy_board(problem_ascii, board_ascii)
+    if puzzle_type == "pattern":
+        return normalize_pattern_board(board_ascii)
+    return board_ascii

space_app/main.py

@@ -8,6 +8,7 @@ from fastapi import Depends, FastAPI, Header, HTTPException, Query
 from fastapi.responses import FileResponse
 from fastapi.staticfiles import StaticFiles
 
+from .board_utils import normalize_board_for_display, normalize_board_for_submission
 from .config import Settings
 from .dataset import DatasetStore
 from .db import SessionStore
@@ -28,6 +29,11 @@ def _session_to_response(
     problem_ascii: str,
     image_base64: str | None,
 ) -> SessionResponse:
+    current_board_ascii = normalize_board_for_display(
+        puzzle_type=str(session["puzzle_type"]),
+        problem_ascii=problem_ascii,
+        board_ascii=str(session["submitted_artifact"] or problem_ascii),
+    )
     return SessionResponse(
         session_id=str(session["id"]),
         engine=str(session["engine"]),
@@ -39,7 +45,7 @@ def _session_to_response(
         started_at=session["started_at"],
         payload=SessionPayload(
             problem_ascii=problem_ascii,
-            current_board_ascii=str(session["submitted_artifact"] or problem_ascii),
+            current_board_ascii=current_board_ascii,
             image_base64=image_base64,
         ),
     )
@@ -161,16 +167,21 @@ def create_app(
         if not session["started_at"]:
             raise HTTPException(status_code=409, detail="Session is not ready yet.")
         row = current_dataset_store.get_row(str(session["puzzle_filename"]))
-        verification = current_verifier.verify(
+        normalized_board_ascii = normalize_board_for_submission(
             puzzle_type=str(session["puzzle_type"]),
             problem_ascii=row.problem,
             board_ascii=request.board_ascii,
+        )
+        verification = current_verifier.verify(
+            puzzle_type=str(session["puzzle_type"]),
+            problem_ascii=row.problem,
+            board_ascii=normalized_board_ascii,
             args=str(session["args"]),
         )
         updated = current_session_store.record_submission(
             session_id=session_id,
             solved=bool(verification.get("correct")),
-            submitted_artifact=request.board_ascii,
+            submitted_artifact=normalized_board_ascii,
             verification_payload=verification,
         )
         return SubmitResponse(

space_app/verification.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import subprocess
 import sys
 from pathlib import Path
 from typing import Any
@@ -10,11 +11,56 @@ EVALS_SRC_DIR = ROOT_DIR / "evals" / "src"
 if str(EVALS_SRC_DIR) not in sys.path:
     sys.path.insert(0, str(EVALS_SRC_DIR))
 
-from evals_verifier import verify_flow_free, verify_with_rlp  # type: ignore
+from evals_verifier import (  # type: ignore
+    check_undead_structural_validity,
+    verify_flow_free,
+    verify_with_rlp,
+)
 from puzzles import PUZZLES  # type: ignore
 
 
 class VerificationService:
+    def _verify_undead_with_timeout(
+        self,
+        *,
+        board_ascii: str,
+        args: str,
+    ) -> dict[str, Any]:
+        result = {
+            "board_exists": bool(board_ascii),
+            "board_valid": False,
+            "board_modified": False,
+            "correct": False,
+        }
+        if not board_ascii:
+            return result
+
+        result["board_valid"] = bool(check_undead_structural_validity(board_ascii))
+        if not result["board_valid"]:
+            result["board_modified"] = True
+            return result
+
+        verifier_path = ROOT_DIR / "submodules" / "rlp" / "verifier.py"
+        command = [sys.executable, str(verifier_path), "undead", "--arg", args]
+        try:
+            completed = subprocess.run(
+                command,
+                input=board_ascii,
+                text=True,
+                capture_output=True,
+                cwd=ROOT_DIR,
+                timeout=15,
+                check=False,
+            )
+        except subprocess.TimeoutExpired:
+            result["error"] = "Undead verification timed out."
+            return result
+
+        result["correct"] = completed.returncode == 0 and "SOLVED" in completed.stdout
+        if completed.stderr.strip():
+            result["stderr"] = completed.stderr.strip()[:500]
+        return result
+
     def verify(
         self,
         *,
@@ -26,10 +72,14 @@ class VerificationService:
         spec = PUZZLES[puzzle_type]
         if spec.verifier_type == "flow_free":
             return verify_flow_free(problem_ascii, board_ascii)
+        if spec.verifier_type == "undead":
+            return self._verify_undead_with_timeout(
+                board_ascii=board_ascii,
+                args=args,
+            )
         return verify_with_rlp(
             puzzle_type=spec.verifier_type,
             problem_ascii=problem_ascii,
             extracted_board=board_ascii,
             args=args,
         )
-