Implement custom task grading and upload functionality

README.md

@@ -253,10 +253,54 @@ The environment implements the full OpenEnv interface:
 
 | Method | Path | Description |
 |--------|------|-------------|
-| `GET` | `/api/tasks` | List all task metadata |
+| `GET` | `/api/tasks` | List all task metadata (static + uploaded) |
 | `POST` | `/api/reset/{task_id}` | Start an episode |
 | `POST` | `/api/step` | Execute an action |
 | `GET` | `/api/state` | Get current state |
 | `POST` | `/api/auto_action` | Baseline agent picks next action |
+| `POST` | `/api/upload` | Upload custom code for review |
+| `DELETE` | `/api/upload/{task_id}` | Delete an uploaded task |
 
 The container starts the FastAPI backend on port `7860`, which is compatible with a Hugging Face Docker Space contest deployment.
+
+## Custom Code Upload
+
+You can upload your own code files for the AI agent to review. This enables dynamic code review scenarios beyond the built-in tasks.
+
+### Upload via UI
+
+1. Click **"Upload Custom Code"** in the toolbar
+2. Fill in the PR title and description
+3. Drag & drop or select modified files
+4. Optionally add original file versions for automatic diff generation
+5. Click **"Upload & Create Task"**
+6. Select the new task from the dropdown and start reviewing
+
+### Upload via API
+
+```bash
+# Upload files for review
+curl -X POST http://localhost:8000/api/upload \
+  -F "title=Fix authentication bug" \
+  -F "description=Remove admin check from public endpoint" \
+  -F "files=@path/to/modified_file.py" \
+  -F "original_files=@path/to/original_file.py"
+
+# Response:
+# {
+#   "task_id": "upload_20240407_120000_abc12345",
+#   "label": "Fix authentication bug",
+#   "changed_files": ["modified_file.py"],
+#   "message": "Task created successfully..."
+# }
+
+# Start review session with uploaded task
+curl -X POST http://localhost:8000/api/reset/upload_20240407_120000_abc12345
+```
+
+### Upload Limits
+
+- Maximum 10 files per upload
+- Maximum 1MB per file
+- Uploaded tasks expire after 1 hour (configurable)
+- Grading uses "review_only" mode (scores coverage, not correctness)

backend/app.py

@@ -6,7 +6,7 @@ import logging
 import os
 from pathlib import Path
 
-from fastapi import FastAPI
+from fastapi import FastAPI, UploadFile, File, Form
 from fastapi.responses import JSONResponse, FileResponse
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
@@ -16,6 +16,8 @@ import uvicorn
 from baseline import BaselineAgent
 from env.environment import CodeReviewEnv
 from tasks.task_registry import get_available_tasks, get_task_catalog, load_task
+from tasks.dynamic_loader import create_dynamic_task, validate_uploaded_files
+from tasks.dynamic_store import store_dynamic_task, get_dynamic_task, list_dynamic_tasks
 from grader.task_graders import get_grader
 
 # Setup logging
@@ -36,7 +38,7 @@ app = FastAPI(title="Code Review Assistant API")
 app.add_middleware(
     CORSMiddleware,
     allow_origins=ALLOWED_ORIGINS,
-    allow_methods=["GET", "POST"],
+    allow_methods=["GET", "POST", "DELETE"],
     allow_headers=["Content-Type"],
     allow_credentials=True,
 )
@@ -61,9 +63,10 @@ class ActionRequest(BaseModel):
 
 @app.get("/api/tasks")
 def get_tasks():
-    """Get all available tasks with metadata (cached)."""
+    """Get all available tasks with metadata (static + dynamic)."""
     global _task_catalog_cache
     
+    # Build static tasks (cached)
     if _task_catalog_cache is None:
         meta = {"easy": "🟢", "medium": "🟡", "hard": "🔴"}
         tasks = []
@@ -81,19 +84,142 @@ def get_tasks():
             )
         _task_catalog_cache = {"tasks": tasks}
     
-    return _task_catalog_cache
+    # Add dynamic uploaded tasks (not cached)
+    result = {"tasks": _task_catalog_cache["tasks"].copy()}
+    dynamic_tasks = list_dynamic_tasks()
+    
+    for dt in dynamic_tasks:
+        result["tasks"].append({
+            "id": dt["id"],
+            "label": dt["label"],
+            "difficulty": "custom",
+            "icon": "📤",
+            "desc": dt["description"],
+            "issue_title": dt["label"],
+            "pass_threshold": 0.5,
+            "is_custom_upload": True,
+        })
+    
+    return result
+
+
+@app.post("/api/upload")
+async def upload_code(
+    title: str = Form(...),
+    description: str = Form(...),
+    files: list[UploadFile] = File(...),
+    original_files: list[UploadFile] = File(default=[]),
+):
+    """
+    Upload custom code for review.
+    
+    Args:
+        title: PR/Issue title
+        description: PR description
+        files: Modified/new files to review
+        original_files: Original versions (optional, for diff generation)
+    
+    Returns:
+        Created task ID and metadata
+    """
+    try:
+        # Validate file count
+        total_files = len(files) + len(original_files)
+        if total_files > 20:
+            return JSONResponse(status_code=400, content={"error": "Maximum 20 files allowed"})
+        
+        # Read and validate files
+        changed_files = {}
+        max_size = 1 * 1024 * 1024  # 1MB
+        
+        # Build original files map
+        originals = {}
+        for orig in original_files:
+            content = await orig.read()
+            if len(content) > max_size:
+                return JSONResponse(status_code=400, content={"error": f"File '{orig.filename}' exceeds 1MB limit"})
+            originals[orig.filename] = content.decode("utf-8", errors="replace")
+        
+        # Process modified files
+        for f in files:
+            content = await f.read()
+            if len(content) > max_size:
+                return JSONResponse(status_code=400, content={"error": f"File '{f.filename}' exceeds 1MB limit"})
+            
+            modified_content = content.decode("utf-8", errors="replace")
+            
+            # Check if we have original version
+            if f.filename in originals:
+                changed_files[f.filename] = {
+                    "original": originals[f.filename],
+                    "modified": modified_content,
+                }
+            else:
+                # New file - no original
+                changed_files[f.filename] = {
+                    "modified": modified_content,
+                }
+        
+        if not changed_files:
+            return JSONResponse(status_code=400, content={"error": "No files uploaded"})
+        
+        # Create dynamic task
+        task = create_dynamic_task(
+            title=title,
+            description=description,
+            changed_files=changed_files,
+            issue_body=description,
+        )
+        
+        # Store task
+        task_id = store_dynamic_task(task)
+        
+        logger.info(f"Created custom task: {task_id} with {len(changed_files)} files")
+        
+        return {
+            "task_id": task_id,
+            "label": title,
+            "description": description,
+            "changed_files": list(changed_files.keys()),
+            "message": f"Task created successfully. Select '{task_id}' to start review.",
+        }
+        
+    except Exception as e:
+        logger.error(f"Upload error: {e}", exc_info=True)
+        return JSONResponse(status_code=500, content={"error": str(e)})
+
+
+@app.delete("/api/upload/{task_id}")
+def delete_upload(task_id: str):
+    """Delete an uploaded task."""
+    from tasks.dynamic_store import delete_dynamic_task
+    
+    if delete_dynamic_task(task_id):
+        logger.info(f"Deleted custom task: {task_id}")
+        return {"message": f"Task {task_id} deleted"}
+    else:
+        return JSONResponse(status_code=404, content={"error": "Task not found"})
 
 
 @app.post("/api/reset/{task_name}")
 def reset(task_name: str):
-    """Reset environment with a specific task."""
-    if task_name not in get_available_tasks():
+    """Reset environment with a specific task (static or dynamic)."""
+    # Check if it's a dynamic uploaded task
+    dynamic_task = get_dynamic_task(task_name)
+    
+    if dynamic_task:
+        # Use the uploaded task
+        task = dynamic_task
+        grader = get_grader(task_name, is_custom=True)
+    elif task_name in get_available_tasks():
+        # Use static task
+        task = load_task(task_name)
+        grader = get_grader(task_name)
+    else:
         logger.warning(f"Unknown task requested: {task_name}")
         return JSONResponse(status_code=400, content={"error": "Unknown task"})
     
     try:
-        task = load_task(task_name)
-        grader = get_grader(task_name)
         obs = _env.reset(task)
         _session.update({"task_name": task_name, "task": task, "grader": grader, "obs": obs, "done": False})
         logger.info(f"Task {task_name} reset successfully")
@@ -105,6 +231,7 @@ def reset(task_name: str):
             "description": task["description"],
             "issue_title": task["issue_title"],
             "issue_body": task["issue_body"],
+            "is_custom_upload": task.get("is_custom_upload", False),
         }
     except Exception as e:
         logger.error(f"Error resetting task {task_name}: {e}", exc_info=True)

backend/grader/grader.py

@@ -9,11 +9,30 @@ from env.reward import RewardEngine
 class TaskGrader:
     """Grades a completed episode against hidden task metadata."""
 
-    def __init__(self, task: Dict[str, Any]):
+    def __init__(self, task: Dict[str, Any], review_only: bool = False):
+        """
+        Initialize grader.
+        
+        Args:
+            task: Task dictionary
+            review_only: If True, grade without ground truth (custom uploads)
+        """
         self.task = task
+        self.review_only = review_only
         self._last_report: Dict[str, Any] = {}
 
     def grade_episode(self, actions_taken: List[Dict[str, Any]]) -> float:
+        """
+        Grade the episode based on actions taken.
+        
+        For review_only mode (custom uploads), grades based on:
+        - How many files were inspected
+        - Whether comments were made
+        - Whether a decision was reached
+        """
+        if self.review_only:
+            return self._grade_review_only(actions_taken)
+        
         score, breakdown = RewardEngine.score_actions(self.task, actions_taken)
         status = "PASS" if score >= float(self.task["pass_threshold"]) else "FAIL"
 
@@ -39,6 +58,63 @@ class TaskGrader:
             "grade_status": status,
         }
         return score
+    
+    def _grade_review_only(self, actions_taken: List[Dict[str, Any]]) -> float:
+        """Grade custom upload based on review completeness."""
+        inspected_diffs = set()
+        inspected_files = set()
+        comments = []
+        final_decision = None
+        
+        changed_files = set(self.task.get("changed_files", []))
+        
+        for action in actions_taken:
+            action_type = action.get("action_type")
+            path = action.get("path")
+            text = action.get("text", "")
+            
+            if action_type == "inspect_diff" and path:
+                inspected_diffs.add(path)
+            elif action_type == "inspect_file" and path:
+                inspected_files.add(path)
+            elif action_type == "comment" and text:
+                comments.append(text)
+            elif action_type in ("approve", "reject", "escalate"):
+                final_decision = action_type
+        
+        # Calculate coverage score
+        total_changed = len(changed_files) if changed_files else 1
+        coverage = len(inspected_diffs & changed_files) / total_changed
+        
+        # Score components for review-only mode
+        coverage_score = min(coverage, 1.0) * 0.40  # 40% for file coverage
+        comment_score = min(len(comments) / 3, 1.0) * 0.30  # 30% for comments (up to 3)
+        decision_score = 0.30 if final_decision else 0.0  # 30% for making a decision
+        
+        total_score = coverage_score + comment_score + decision_score
+        
+        # Build report
+        self._last_report = {
+            "task_id": self.task["id"],
+            "difficulty": "custom",
+            "issue_title": self.task.get("issue_title", "Custom Review"),
+            "review_mode": "review_only",
+            "inspected_diffs": list(inspected_diffs),
+            "inspected_files": list(inspected_files),
+            "changed_files": list(changed_files),
+            "coverage": round(coverage, 2),
+            "comments_made": len(comments),
+            "comments_preview": [c[:100] + "..." if len(c) > 100 else c for c in comments[:3]],
+            "submitted_decision": final_decision,
+            "coverage_score": round(coverage_score, 4),
+            "comment_score": round(comment_score, 4),
+            "decision_score": round(decision_score, 4),
+            "final_score": round(total_score, 4),
+            "grade_status": "REVIEWED",
+            "note": "Custom uploads are graded on review completeness, not correctness.",
+        }
+        
+        return total_score
 
     def generate_grade_report(self) -> Dict[str, Any]:
         """Return the report from the last grade_episode call."""

backend/grader/task_graders.py

@@ -6,5 +6,23 @@ from grader.grader import TaskGrader
 from tasks.task_registry import load_task
 
 
-def get_grader(task_id: str) -> TaskGrader:
+def get_grader(task_id: str, is_custom: bool = False) -> TaskGrader:
+    """
+    Get a grader for a task.
+    
+    Args:
+        task_id: Task identifier
+        is_custom: If True, use custom task grading (review-only mode)
+    
+    Returns:
+        TaskGrader instance
+    """
+    if is_custom:
+        # For custom uploads, get from dynamic store
+        from tasks.dynamic_store import get_dynamic_task
+        task = get_dynamic_task(task_id)
+        if task:
+            return TaskGrader(task, review_only=True)
+        raise ValueError(f"Custom task not found: {task_id}")
+    
     return TaskGrader(load_task(task_id))

backend/tasks/dynamic_loader.py

@@ -0,0 +1,156 @@
+"""Dynamic task generation from user-uploaded code."""
+
+from __future__ import annotations
+
+import uuid
+import difflib
+from datetime import datetime
+from typing import Dict, Any, List
+
+
+def generate_task_id() -> str:
+    """Generate a unique task ID for uploaded content."""
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    short_uuid = str(uuid.uuid4())[:8]
+    return f"upload_{timestamp}_{short_uuid}"
+
+
+def create_diff(original: str, modified: str, filename: str) -> str:
+    """Create unified diff from original and modified file contents."""
+    original_lines = original.splitlines(keepends=True)
+    modified_lines = modified.splitlines(keepends=True)
+    
+    diff = difflib.unified_diff(
+        original_lines,
+        modified_lines,
+        fromfile=f"a/{filename}",
+        tofile=f"b/{filename}",
+        lineterm=""
+    )
+    
+    return "".join(diff)
+
+
+def create_dynamic_task(
+    title: str,
+    description: str,
+    changed_files: Dict[str, Dict[str, str]],
+    context_files: Dict[str, str] | None = None,
+    issue_body: str | None = None,
+    ground_truth: Dict[str, Any] | None = None,
+) -> Dict[str, Any]:
+    """
+    Create a task dictionary from uploaded content.
+    
+    Args:
+        title: PR/Issue title
+        description: PR description/summary
+        changed_files: Dict of {path: {"original": str, "modified": str}} or {path: {"diff": str}}
+        context_files: Optional dict of {path: content} for additional context
+        issue_body: Optional detailed issue description
+        ground_truth: Optional ground truth for scoring (if known)
+    
+    Returns:
+        Task dictionary compatible with CodeReviewEnv
+    """
+    task_id = generate_task_id()
+    
+    # Process changed files and generate diffs
+    diffs = {}
+    files = {}
+    changed_paths = []
+    
+    for path, content in changed_files.items():
+        changed_paths.append(path)
+        
+        # If diff is provided directly, use it
+        if "diff" in content:
+            diffs[path] = content["diff"]
+            # Store modified version as the file content
+            if "modified" in content:
+                files[path] = content["modified"]
+        
+        # If original and modified are provided, generate diff
+        elif "original" in content and "modified" in content:
+            diffs[path] = create_diff(content["original"], content["modified"], path)
+            files[path] = content["modified"]
+        
+        # If only modified is provided (new file)
+        elif "modified" in content:
+            files[path] = content["modified"]
+            # Generate diff showing entire file as added
+            diffs[path] = create_diff("", content["modified"], path)
+    
+    # Add context files
+    if context_files:
+        files.update(context_files)
+    
+    # Build available files list (all files that can be inspected)
+    available_files = list(set(changed_paths + list(context_files.keys() if context_files else [])))
+    
+    # Create task structure
+    task = {
+        "id": task_id,
+        "difficulty": "custom",
+        "label": title,
+        "description": description,
+        "issue_title": title,
+        "issue_body": issue_body or description,
+        "changed_files": changed_paths,
+        "available_files": available_files,
+        "diffs": diffs,
+        "files": files,
+        "pass_threshold": 0.5,  # Default for custom uploads
+        "is_custom_upload": True,
+        "uploaded_at": datetime.now().isoformat(),
+    }
+    
+    # Add ground truth if provided (for testing)
+    if ground_truth:
+        task["ground_truth"] = ground_truth
+    
+    return task
+
+
+def validate_uploaded_files(files: List[Dict[str, Any]], max_size_mb: float = 1.0, max_files: int = 10) -> tuple[bool, str | None]:
+    """
+    Validate uploaded files for size and count limits.
+    
+    Returns:
+        (is_valid, error_message)
+    """
+    if len(files) > max_files:
+        return False, f"Too many files: maximum {max_files} files allowed"
+    
+    max_size_bytes = max_size_mb * 1024 * 1024
+    
+    for file_info in files:
+        size = file_info.get("size", 0)
+        if size > max_size_bytes:
+            filename = file_info.get("filename", "unknown")
+            return False, f"File '{filename}' exceeds {max_size_mb}MB limit"
+    
+    return True, None
+
+
+# Example usage for testing
+if __name__ == "__main__":
+    # Example: Simple file modification
+    test_task = create_dynamic_task(
+        title="Fix authentication bug",
+        description="Remove admin check from public endpoint",
+        changed_files={
+            "api/routes.py": {
+                "original": "@admin_required\ndef export_data():\n    return data",
+                "modified": "def export_data():\n    return data"
+            }
+        },
+        context_files={
+            "api/__init__.py": "from .routes import *"
+        }
+    )
+    
+    print(f"Generated task: {test_task['id']}")
+    print(f"Changed files: {test_task['changed_files']}")
+    print(f"Available files: {test_task['available_files']}")
+    print(f"Diff sample:\n{test_task['diffs']['api/routes.py'][:200]}")

backend/tasks/dynamic_store.py

@@ -0,0 +1,216 @@
+"""Temporary storage for user-uploaded dynamic tasks."""
+
+from __future__ import annotations
+
+import threading
+import time
+from datetime import datetime, timedelta
+from typing import Dict, Any, List
+
+
+class DynamicTaskStore:
+    """Thread-safe in-memory storage for uploaded tasks with TTL."""
+    
+    def __init__(self, ttl_seconds: int = 3600):
+        """
+        Initialize task store.
+        
+        Args:
+            ttl_seconds: Time-to-live for tasks in seconds (default: 1 hour)
+        """
+        self._tasks: Dict[str, Dict[str, Any]] = {}
+        self._timestamps: Dict[str, datetime] = {}
+        self._lock = threading.RLock()
+        self._ttl = timedelta(seconds=ttl_seconds)
+        self._cleanup_thread = None
+        self._running = False
+    
+    def store_task(self, task: Dict[str, Any]) -> str:
+        """
+        Store a task and return its ID.
+        
+        Args:
+            task: Task dictionary (must contain 'id' field)
+        
+        Returns:
+            Task ID
+        """
+        task_id = task["id"]
+        
+        with self._lock:
+            self._tasks[task_id] = task
+            self._timestamps[task_id] = datetime.now()
+        
+        return task_id
+    
+    def get_task(self, task_id: str) -> Dict[str, Any] | None:
+        """
+        Retrieve a task by ID.
+        
+        Args:
+            task_id: Task identifier
+        
+        Returns:
+            Task dictionary or None if not found/expired
+        """
+        with self._lock:
+            if task_id not in self._tasks:
+                return None
+            
+            # Check if expired
+            if self._is_expired(task_id):
+                self._delete_task(task_id)
+                return None
+            
+            return self._tasks[task_id]
+    
+    def delete_task(self, task_id: str) -> bool:
+        """
+        Delete a task by ID.
+        
+        Args:
+            task_id: Task identifier
+        
+        Returns:
+            True if deleted, False if not found
+        """
+        with self._lock:
+            return self._delete_task(task_id)
+    
+    def _delete_task(self, task_id: str) -> bool:
+        """Internal delete (assumes lock is held)."""
+        if task_id in self._tasks:
+            del self._tasks[task_id]
+            del self._timestamps[task_id]
+            return True
+        return False
+    
+    def list_tasks(self) -> List[Dict[str, Any]]:
+        """
+        List all active (non-expired) tasks.
+        
+        Returns:
+            List of task dictionaries
+        """
+        with self._lock:
+            self._cleanup_expired()
+            return [
+                {
+                    "id": task["id"],
+                    "label": task.get("label", task.get("id")),
+                    "difficulty": task.get("difficulty", "custom"),
+                    "description": task.get("description", ""),
+                    "uploaded_at": task.get("uploaded_at"),
+                    "is_custom_upload": True,
+                }
+                for task in self._tasks.values()
+            ]
+    
+    def cleanup_expired(self) -> int:
+        """
+        Remove expired tasks.
+        
+        Returns:
+            Number of tasks removed
+        """
+        with self._lock:
+            return self._cleanup_expired()
+    
+    def _cleanup_expired(self) -> int:
+        """Internal cleanup (assumes lock is held)."""
+        expired = [
+            task_id for task_id in self._tasks.keys()
+            if self._is_expired(task_id)
+        ]
+        
+        for task_id in expired:
+            self._delete_task(task_id)
+        
+        return len(expired)
+    
+    def _is_expired(self, task_id: str) -> bool:
+        """Check if a task has expired."""
+        if task_id not in self._timestamps:
+            return True
+        
+        age = datetime.now() - self._timestamps[task_id]
+        return age > self._ttl
+    
+    def start_background_cleanup(self, interval_seconds: int = 300):
+        """
+        Start background thread that periodically cleans up expired tasks.
+        
+        Args:
+            interval_seconds: Cleanup interval (default: 5 minutes)
+        """
+        if self._running:
+            return
+        
+        self._running = True
+        
+        def cleanup_loop():
+            while self._running:
+                time.sleep(interval_seconds)
+                if self._running:
+                    removed = self.cleanup_expired()
+                    if removed > 0:
+                        print(f"DynamicTaskStore: Cleaned up {removed} expired task(s)")
+        
+        self._cleanup_thread = threading.Thread(target=cleanup_loop, daemon=True)
+        self._cleanup_thread.start()
+    
+    def stop_background_cleanup(self):
+        """Stop the background cleanup thread."""
+        self._running = False
+        if self._cleanup_thread:
+            self._cleanup_thread.join(timeout=1)
+    
+    def clear(self):
+        """Clear all tasks (for testing)."""
+        with self._lock:
+            self._tasks.clear()
+            self._timestamps.clear()
+    
+    def __len__(self) -> int:
+        """Return number of stored tasks."""
+        with self._lock:
+            return len(self._tasks)
+
+
+# Global instance
+_store = DynamicTaskStore()
+
+
+# Public API
+def get_store() -> DynamicTaskStore:
+    """Get the global task store instance."""
+    return _store
+
+
+def store_dynamic_task(task: Dict[str, Any]) -> str:
+    """Store a dynamic task."""
+    return _store.store_task(task)
+
+
+def get_dynamic_task(task_id: str) -> Dict[str, Any] | None:
+    """Retrieve a dynamic task."""
+    return _store.get_task(task_id)
+
+
+def delete_dynamic_task(task_id: str) -> bool:
+    """Delete a dynamic task."""
+    return _store.delete_task(task_id)
+
+
+def list_dynamic_tasks() -> List[Dict[str, Any]]:
+    """List all dynamic tasks."""
+    return _store.list_tasks()
+
+
+def cleanup_expired_tasks() -> int:
+    """Clean up expired tasks."""
+    return _store.cleanup_expired()
+
+
+# Initialize background cleanup on import
+_store.start_background_cleanup()

frontend/package-lock.json

@@ -50,6 +50,7 @@
       "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@babel/code-frame": "^7.29.0",
         "@babel/generator": "^7.29.0",
@@ -1164,6 +1165,7 @@
       "integrity": "sha512-z9VXpC7MWrhfWipitjNdgCauoMLRdIILQsAEV+ZesIzBq/oUlxk0m3ApZuMFCXdnS4U7KrI+l3WRUEGQ8K1QKw==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@types/prop-types": "*",
         "csstype": "^3.2.2"
@@ -1250,6 +1252,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "baseline-browser-mapping": "^2.10.12",
         "caniuse-lite": "^1.0.30001782",
@@ -1791,6 +1794,7 @@
       "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
       "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "loose-envify": "^1.1.0"
       },
@@ -1932,6 +1936,7 @@
       "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "esbuild": "^0.21.3",
         "postcss": "^8.4.43",

frontend/src/App.jsx

@@ -1,6 +1,7 @@
 import { useState, useCallback } from 'react';
 import Header from './components/Header';
 import TaskSelector from './components/TaskSelector';
+import UploadPanel from './components/UploadPanel';
 import PRViewer from './components/PRViewer';
 import ActionPanel from './components/ActionPanel';
 import StateViewer from './components/StateViewer';
@@ -19,6 +20,7 @@ export default function App() {
   const [toast, setToast] = useState(null);
   const [loading, setLoading] = useState(false);
   const [autoPilotRunning, setAutoPilotRunning] = useState(false);
+  const [refreshTasks, setRefreshTasks] = useState(0);
 
   const showToast = (message, type = 'info') => {
     setToast({ message, type });
@@ -51,12 +53,14 @@ export default function App() {
         description: data.description,
         issue_title: data.issue_title,
         issue_body: data.issue_body,
+        is_custom_upload: data.is_custom_upload,
       });
       setDone(false);
       setScore(null);
       setReport(null);
       setState(data.state);
-      showToast(`Task "${data.task_id}" loaded — ${data.issue_title}`, 'success');
+      const taskType = data.is_custom_upload ? '📤 Custom' : '';
+      showToast(`${taskType} Task "${data.task_id}" loaded — ${data.issue_title}`, 'success');
     } catch (err) {
       const msg = err.response?.data?.error || 'Failed to start task';
       showToast(msg, 'error');
@@ -65,6 +69,14 @@ export default function App() {
     }
   };
 
+  const handleUploadComplete = (result) => {
+    showToast(`Uploaded! Task "${result.task_id}" created. Select it from the dropdown.`, 'success');
+    // Trigger task list refresh
+    setRefreshTasks(prev => prev + 1);
+    // Auto-select the new task
+    setSelectedTask(result.task_id);
+  };
+
   const handleAction = useCallback(async (actionType, payload) => {
     try {
       const data = await stepAction(actionType, payload);
@@ -76,9 +88,10 @@ export default function App() {
         setScore(data.score);
         setReport(data.report);
         const status = data.report?.grade_status || '';
+        const statusType = status === 'PASS' || status === 'REVIEWED' ? 'success' : 'error';
         showToast(
           `Episode finished! Score: ${(data.score * 100).toFixed(1)}% — ${status}`,
-          status === 'PASS' ? 'success' : 'error'
+          statusType
         );
       } else {
         const suffix = payload?.path || payload?.text || actionType;
@@ -115,9 +128,10 @@ export default function App() {
           setScore(data.score);
           setReport(data.report);
           const status = data.report?.grade_status || '';
+          const statusType = status === 'PASS' || status === 'REVIEWED' ? 'success' : 'error';
           showToast(
             `Auto-pilot finished! Score: ${(data.score * 100).toFixed(1)}% — ${status}`,
-            status === 'PASS' ? 'success' : 'error'
+            statusType
           );
         }
       } catch (err) {
@@ -149,6 +163,11 @@ export default function App() {
           disabled={loading || autoPilotRunning}
           loading={loading}
           selectedTask={selectedTask}
+          refreshKey={refreshTasks}
+        />
+        <UploadPanel
+          onUploadComplete={handleUploadComplete}
+          disabled={loading || autoPilotRunning}
         />
         {observation && !done && (
           <button

frontend/src/components/TaskSelector.jsx

@@ -1,12 +1,13 @@
 import { useState, useEffect } from 'react';
 import { fetchTasks } from '../services/api';
 
-export default function TaskSelector({ onSelect, onStart, disabled, loading, selectedTask }) {
+export default function TaskSelector({ onSelect, onStart, disabled, loading, selectedTask, refreshKey = 0 }) {
   const [tasks, setTasks] = useState([]);
   const [fetchLoading, setFetchLoading] = useState(true);
   const [error, setError] = useState(null);
 
   useEffect(() => {
+    setFetchLoading(true);
     fetchTasks()
       .then((data) => {
         setTasks(data.tasks || []);
@@ -16,7 +17,7 @@ export default function TaskSelector({ onSelect, onStart, disabled, loading, sel
         setError('Failed to load tasks');
         setFetchLoading(false);
       });
-  }, []);
+  }, [refreshKey]);
 
   const handleSelect = (e) => {
     const val = e.target.value;

frontend/src/components/UploadPanel.jsx

@@ -0,0 +1,266 @@
+import { useState, useRef } from 'react';
+import { uploadCode } from '../services/api';
+
+export default function UploadPanel({ onUploadComplete, disabled }) {
+  const [isOpen, setIsOpen] = useState(false);
+  const [title, setTitle] = useState('');
+  const [description, setDescription] = useState('');
+  const [files, setFiles] = useState([]);
+  const [originalFiles, setOriginalFiles] = useState([]);
+  const [uploading, setUploading] = useState(false);
+  const [error, setError] = useState(null);
+  const [dragActive, setDragActive] = useState(false);
+  
+  const fileInputRef = useRef(null);
+  const originalInputRef = useRef(null);
+
+  const handleDrag = (e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    if (e.type === 'dragenter' || e.type === 'dragover') {
+      setDragActive(true);
+    } else if (e.type === 'dragleave') {
+      setDragActive(false);
+    }
+  };
+
+  const handleDrop = (e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    setDragActive(false);
+    
+    const droppedFiles = [...e.dataTransfer.files];
+    setFiles(prev => [...prev, ...droppedFiles]);
+  };
+
+  const handleFileSelect = (e) => {
+    const selectedFiles = [...e.target.files];
+    setFiles(prev => [...prev, ...selectedFiles]);
+  };
+
+  const handleOriginalSelect = (e) => {
+    const selectedFiles = [...e.target.files];
+    setOriginalFiles(prev => [...prev, ...selectedFiles]);
+  };
+
+  const removeFile = (index, isOriginal = false) => {
+    if (isOriginal) {
+      setOriginalFiles(prev => prev.filter((_, i) => i !== index));
+    } else {
+      setFiles(prev => prev.filter((_, i) => i !== index));
+    }
+  };
+
+  const handleSubmit = async () => {
+    if (!title.trim()) {
+      setError('Title is required');
+      return;
+    }
+    if (!description.trim()) {
+      setError('Description is required');
+      return;
+    }
+    if (files.length === 0) {
+      setError('At least one file is required');
+      return;
+    }
+
+    setUploading(true);
+    setError(null);
+
+    try {
+      const result = await uploadCode(title, description, files, originalFiles);
+      
+      // Reset form
+      setTitle('');
+      setDescription('');
+      setFiles([]);
+      setOriginalFiles([]);
+      setIsOpen(false);
+      
+      // Notify parent
+      if (onUploadComplete) {
+        onUploadComplete(result);
+      }
+    } catch (err) {
+      setError(err.response?.data?.error || 'Upload failed');
+    } finally {
+      setUploading(false);
+    }
+  };
+
+  const handleClear = () => {
+    setTitle('');
+    setDescription('');
+    setFiles([]);
+    setOriginalFiles([]);
+    setError(null);
+  };
+
+  const handleClose = () => {
+    setIsOpen(false);
+    setError(null);
+  };
+
+  return (
+    <>
+      <button
+        className="btn btn-upload-toggle"
+        onClick={() => setIsOpen(true)}
+        disabled={disabled}
+      >
+        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+          <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/>
+          <polyline points="17 8 12 3 7 8"/>
+          <line x1="12" y1="3" x2="12" y2="15"/>
+        </svg>
+        Upload Code
+      </button>
+
+      {isOpen && (
+        <div className="upload-modal-overlay" onClick={handleClose}>
+          <div className="upload-modal" onClick={(e) => e.stopPropagation()}>
+            <div className="upload-modal-header">
+              <h3>📤 Upload Custom Code for Review</h3>
+              <button className="btn btn-icon" onClick={handleClose} title="Close">
+                <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+                  <line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/>
+                </svg>
+              </button>
+            </div>
+
+            <div className="upload-modal-body">
+              <div className="upload-form-row">
+                <div className="form-group">
+                  <label>PR / Issue Title *</label>
+                  <input
+                    type="text"
+                    value={title}
+                    onChange={(e) => setTitle(e.target.value)}
+                    placeholder="e.g., Fix authentication bug in login handler"
+                    disabled={uploading}
+                  />
+                </div>
+              </div>
+
+              <div className="upload-form-row">
+                <div className="form-group">
+                  <label>Description *</label>
+                  <textarea
+                    value={description}
+                    onChange={(e) => setDescription(e.target.value)}
+                    placeholder="Describe what this PR/code change is about..."
+                    rows={2}
+                    disabled={uploading}
+                  />
+                </div>
+              </div>
+
+              <div className="upload-form-columns">
+                <div className="form-group">
+                  <label>Modified Files * (drag & drop)</label>
+                  <div
+                    className={`drop-zone ${dragActive ? 'active' : ''}`}
+                    onDragEnter={handleDrag}
+                    onDragLeave={handleDrag}
+                    onDragOver={handleDrag}
+                    onDrop={handleDrop}
+                    onClick={() => fileInputRef.current?.click()}
+                  >
+                    <input
+                      ref={fileInputRef}
+                      type="file"
+                      multiple
+                      onChange={handleFileSelect}
+                      style={{ display: 'none' }}
+                    />
+                    <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.5">
+                      <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/>
+                      <polyline points="17 8 12 3 7 8"/>
+                      <line x1="12" y1="3" x2="12" y2="15"/>
+                    </svg>
+                    <span>Drop files or click</span>
+                  </div>
+                  {files.length > 0 && (
+                    <div className="file-list">
+                      {files.map((file, i) => (
+                        <div key={i} className="file-item">
+                          <span className="file-name">📄 {file.name}</span>
+                          <button className="btn btn-icon-sm" onClick={() => removeFile(i)}>×</button>
+                        </div>
+                      ))}
+                    </div>
+                  )}
+                </div>
+
+                <div className="form-group">
+                  <label>Original Files (optional)</label>
+                  <div
+                    className="drop-zone drop-zone-secondary"
+                    onClick={() => originalInputRef.current?.click()}
+                  >
+                    <input
+                      ref={originalInputRef}
+                      type="file"
+                      multiple
+                      onChange={handleOriginalSelect}
+                      style={{ display: 'none' }}
+                    />
+                    <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.5">
+                      <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/>
+                      <polyline points="14 2 14 8 20 8"/>
+                    </svg>
+                    <span>For diff generation</span>
+                  </div>
+                  {originalFiles.length > 0 && (
+                    <div className="file-list file-list-original">
+                      {originalFiles.map((file, i) => (
+                        <div key={i} className="file-item">
+                          <span className="file-name">📋 {file.name}</span>
+                          <button className="btn btn-icon-sm" onClick={() => removeFile(i, true)}>×</button>
+                        </div>
+                      ))}
+                    </div>
+                  )}
+                </div>
+              </div>
+
+              {error && <div className="upload-error">{error}</div>}
+            </div>
+
+            <div className="upload-modal-footer">
+              <button
+                className="btn btn-secondary"
+                onClick={handleClear}
+                disabled={uploading}
+              >
+                Clear
+              </button>
+              <button
+                className="btn btn-primary"
+                onClick={handleSubmit}
+                disabled={uploading || files.length === 0}
+              >
+                {uploading ? (
+                  <>
+                    <span className="btn-spinner" />
+                    Uploading...
+                  </>
+                ) : (
+                  <>
+                    <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+                      <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/>
+                      <polyline points="17 8 12 3 7 8"/>
+                      <line x1="12" y1="3" x2="12" y2="15"/>
+                    </svg>
+                    Upload & Create Task
+                  </>
+                )}
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
+    </>
+  );
+}

frontend/src/index.css

@@ -1116,3 +1116,274 @@ body {
 
   .task-select { min-width: 180px; }
 }
+
+/* ═══════════ UPLOAD MODAL ═══════════ */
+.btn-upload-toggle {
+  background: var(--surface-2);
+  border: 1px dashed var(--border-hi);
+  color: var(--text-2);
+}
+
+.btn-upload-toggle:hover:not(:disabled) {
+  background: var(--surface-3);
+  border-color: var(--accent);
+  color: var(--accent);
+}
+
+.upload-modal-overlay {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background: rgba(0, 0, 0, 0.7);
+  backdrop-filter: blur(4px);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 1000;
+  animation: fadeIn 0.2s ease;
+}
+
+@keyframes fadeIn {
+  from { opacity: 0; }
+  to { opacity: 1; }
+}
+
+.upload-modal {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-lg);
+  width: 90%;
+  max-width: 600px;
+  max-height: 85vh;
+  display: flex;
+  flex-direction: column;
+  box-shadow: 0 20px 60px rgba(0, 0, 0, 0.5);
+  animation: slideUp 0.25s ease;
+}
+
+@keyframes slideUp {
+  from { transform: translateY(20px); opacity: 0; }
+  to { transform: translateY(0); opacity: 1; }
+}
+
+.upload-modal-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 16px 20px;
+  background: var(--surface-2);
+  border-bottom: 1px solid var(--border);
+  border-radius: var(--radius-lg) var(--radius-lg) 0 0;
+}
+
+.upload-modal-header h3 {
+  font-size: 1rem;
+  font-weight: 600;
+  color: var(--text);
+  margin: 0;
+}
+
+.upload-modal-body {
+  padding: 20px;
+  overflow-y: auto;
+  flex: 1;
+}
+
+.upload-form-row {
+  margin-bottom: 16px;
+}
+
+.upload-form-columns {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 16px;
+}
+
+.form-group {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.form-group label {
+  font-size: 0.75rem;
+  font-weight: 600;
+  color: var(--text-2);
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+}
+
+.form-group input,
+.form-group textarea {
+  background: var(--bg);
+  color: var(--text);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  padding: 10px 12px;
+  font-family: var(--font);
+  font-size: 0.85rem;
+  transition: border-color 0.15s;
+}
+
+.form-group input:focus,
+.form-group textarea:focus {
+  outline: none;
+  border-color: var(--accent);
+  box-shadow: 0 0 0 2px rgba(124,110,240,0.15);
+}
+
+.form-group input::placeholder,
+.form-group textarea::placeholder {
+  color: var(--text-3);
+}
+
+.drop-zone {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 6px;
+  padding: 20px 12px;
+  border: 2px dashed var(--border);
+  border-radius: var(--radius);
+  background: var(--bg);
+  cursor: pointer;
+  transition: all 0.2s;
+  min-height: 100px;
+}
+
+.drop-zone:hover,
+.drop-zone.active {
+  border-color: var(--accent);
+  background: rgba(124,110,240,0.05);
+}
+
+.drop-zone svg {
+  color: var(--text-3);
+  transition: color 0.2s;
+}
+
+.drop-zone:hover svg,
+.drop-zone.active svg {
+  color: var(--accent);
+}
+
+.drop-zone span {
+  font-size: 0.78rem;
+  color: var(--text-3);
+  text-align: center;
+}
+
+.drop-zone-secondary {
+  border-style: dotted;
+  background: var(--surface-2);
+}
+
+.file-list {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  margin-top: 8px;
+  max-height: 120px;
+  overflow-y: auto;
+}
+
+.file-item {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 6px 10px;
+  background: var(--surface-2);
+  border-radius: var(--radius);
+  font-size: 0.8rem;
+}
+
+.file-name {
+  flex: 1;
+  color: var(--text);
+  font-family: var(--font-mono);
+  font-size: 0.75rem;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.btn-icon-sm {
+  padding: 2px 6px;
+  font-size: 0.85rem;
+  line-height: 1;
+  border: none;
+  background: transparent;
+  color: var(--text-3);
+  cursor: pointer;
+  border-radius: 4px;
+}
+
+.btn-icon-sm:hover {
+  background: var(--red-bg);
+  color: var(--red);
+}
+
+.file-list-original .file-item {
+  background: var(--blue-bg);
+  border: 1px solid rgba(88,166,255,0.2);
+}
+
+.upload-error {
+  padding: 10px 12px;
+  background: var(--red-bg);
+  border: 1px solid rgba(248,81,73,0.3);
+  border-radius: var(--radius);
+  color: var(--red);
+  font-size: 0.82rem;
+  margin-top: 12px;
+}
+
+.upload-modal-footer {
+  display: flex;
+  justify-content: flex-end;
+  gap: 10px;
+  padding: 16px 20px;
+  background: var(--surface-2);
+  border-top: 1px solid var(--border);
+  border-radius: 0 0 var(--radius-lg) var(--radius-lg);
+}
+
+.btn-secondary {
+  background: var(--surface-2);
+  border: 1px solid var(--border);
+  color: var(--text-2);
+}
+
+.btn-secondary:hover:not(:disabled) {
+  background: var(--surface-3);
+  color: var(--text);
+}
+
+.btn-icon {
+  padding: 4px;
+  background: transparent;
+  border: none;
+  color: var(--text-3);
+  cursor: pointer;
+  border-radius: 4px;
+  transition: all 0.15s;
+}
+
+.btn-icon:hover {
+  background: var(--surface-3);
+  color: var(--text);
+}
+
+@media (max-width: 600px) {
+  .upload-form-columns {
+    grid-template-columns: 1fr;
+  }
+  
+  .upload-modal {
+    width: 95%;
+    max-height: 90vh;
+  }
+}

frontend/src/services/api.js

@@ -32,4 +32,28 @@ export async function autoAction() {
   return res.data;
 }
 
+export async function uploadCode(title, description, files, originalFiles = []) {
+  const formData = new FormData();
+  formData.append('title', title);
+  formData.append('description', description);
+  
+  files.forEach(file => {
+    formData.append('files', file);
+  });
+  
+  originalFiles.forEach(file => {
+    formData.append('original_files', file);
+  });
+  
+  const res = await api.post('/api/upload', formData, {
+    headers: { 'Content-Type': 'multipart/form-data' },
+  });
+  return res.data;
+}
+
+export async function deleteUpload(taskId) {
+  const res = await api.delete(`/api/upload/${taskId}`);
+  return res.data;
+}
+
 export default api;