feat: add free code review endpoint and associated features

- Add new /review/free endpoint for arbitrary code review
- Implement free_review.py module with review_free_code function
- Update app.py with FreeReviewRequest and FreeReviewResponse models
- Update dashboard.html with free review functionality
- Update tasks.py with enhancements

This allows users to review any code without being confined to grading,
perfect for ad-hoc reviews and demonstrations.

Co-Authored-By: Claude <noreply@anthropic.com>

app.py

@@ -28,6 +28,7 @@ from models import (
 from environment import CodeReviewEnv
 from graders import grade_episode
 from tasks import get_all_tasks
+from free_review import review_free_code
 
 # ── App setup ─────────────────────────────────────────────────────────────
 app = FastAPI(
@@ -251,6 +252,67 @@ def baseline(request: Optional[BaselineRequest] = None):
         inference.parse_llm_response = original_parse
 
 
+# ── Free Review Route ───────────────────────────────────────────────────
+
+class FreeReviewRequest(BaseModel):
+    code: str
+    language: Optional[str] = "python"
+    context: Optional[str] = ""
+
+class FreeReviewResponse(BaseModel):
+    issues: list
+    overall_verdict: str
+    summary: str
+    positive_aspects: list
+    total_issues: int
+    critical_count: int
+    major_count: int
+    minor_count: int
+    error: Optional[str] = None
+
+@app.post("/review/free", tags=["Free Review"])
+def free_review(request: FreeReviewRequest):
+    """
+    Review any arbitrary code using AI.
+    No grading — works on any code, any language.
+    Perfect for ad-hoc reviews and demos.
+    """
+    result = review_free_code(
+        code=request.code,
+        language=request.language,
+        context=request.context
+    )
+    
+    if "error" in result:
+        return FreeReviewResponse(
+            issues=[],
+            overall_verdict="error",
+            summary=result["error"],
+            positive_aspects=[],
+            total_issues=0,
+            critical_count=0,
+            major_count=0,
+            minor_count=0,
+            error=result["error"]
+        )
+    
+    issues = result.get("issues", [])
+    return FreeReviewResponse(
+        issues=issues,
+        overall_verdict=result.get("overall_verdict", "comment"),
+        summary=result.get("summary", ""),
+        positive_aspects=result.get("positive_aspects", []),
+        total_issues=len(issues),
+        critical_count=sum(1 for i in issues 
+                          if i.get("severity") == "critical"),
+        major_count=sum(1 for i in issues 
+                       if i.get("severity") == "major"),
+        minor_count=sum(1 for i in issues 
+                       if i.get("severity") == "minor"),
+        error=None
+    )
+
+
 # ── Debug Route ─────────────────────────────────────────────────────────
 
 @app.post("/debug-baseline", tags=["Debug"])

dashboard.html

@@ -1609,6 +1609,248 @@
       stroke-width: 2;
     }
 
+    /* ── FREE REVIEW ────────────────────────────────────────────────────── */
+    .free-review-container {
+      display: grid;
+      grid-template-columns: 45% 1fr;
+      gap: 32px;
+      margin-top: 32px;
+    }
+    
+    .free-input-panel {
+      display: flex;
+      flex-direction: column;
+      gap: 16px;
+    }
+    
+    .free-editor-wrapper {
+      position: relative;
+      background: #0d1117;
+      border: 1px solid var(--border);
+      border-radius: var(--radius-md);
+      overflow: hidden;
+      flex: 1;
+      display: flex;
+      flex-direction: column;
+      min-height: 300px;
+    }
+    
+    .free-editor-wrapper:focus-within {
+      border-color: var(--purple);
+      box-shadow: 0 0 0 1px var(--purple);
+    }
+    
+    #free-code-input {
+      background: transparent;
+      border: none;
+      color: #e6edf3;
+      font-family: 'JetBrains Mono', monospace;
+      font-size: 13px;
+      padding: 16px;
+      width: 100%;
+      height: 100%;
+      resize: vertical;
+      min-height: 300px;
+      outline: none;
+    }
+    
+    #free-code-input::placeholder {
+      color: var(--muted);
+    }
+    
+    .free-output-panel {
+      background: var(--surface);
+      border: 1px solid var(--border);
+      border-radius: var(--radius-md);
+      overflow: hidden;
+      display: flex;
+      flex-direction: column;
+    }
+    
+    .empty-state {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      padding: 64px 32px;
+      color: var(--muted);
+      text-align: center;
+      height: 100%;
+    }
+    
+    .empty-state svg {
+      width: 48px;
+      height: 48px;
+      margin-bottom: 16px;
+      stroke: var(--border2);
+      fill: none;
+      stroke-width: 1.5;
+    }
+    
+    .loading-state {
+      display: none;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      padding: 64px 32px;
+      height: 100%;
+    }
+    
+    .results-state {
+      display: none;
+      flex-direction: column;
+      height: 100%;
+    }
+    
+    .results-summary-bar {
+      padding: 16px 24px;
+      border-bottom: 1px solid var(--border);
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      flex-wrap: wrap;
+      gap: 16px;
+    }
+    
+    .verdict-badge {
+      padding: 4px 10px;
+      border-radius: 4px;
+      font-size: 12px;
+      font-weight: 700;
+      text-transform: uppercase;
+      letter-spacing: 0.5px;
+    }
+    
+    .verdict-approve { background: rgba(35, 134, 54, 0.15); color: #3fb950; border: 1px solid rgba(63, 185, 80, 0.3); }
+    .verdict-request_changes { background: rgba(218, 54, 51, 0.15); color: #ff7b72; border: 1px solid rgba(255, 123, 114, 0.3); }
+    .verdict-comment { background: rgba(210, 153, 34, 0.15); color: #e3b341; border: 1px solid rgba(227, 179, 65, 0.3); }
+    .verdict-error { background: rgba(218, 54, 51, 0.15); color: #ff7b72; border: 1px solid rgba(255, 123, 114, 0.3); }
+    
+    .severity-counts {
+      display: flex;
+      gap: 12px;
+      font-size: 13px;
+    }
+    
+    .scount { display: flex; align-items: center; gap: 4px; }
+    .sc-crit { color: #ff7b72; }
+    .sc-maj { color: #e3b341; }
+    .sc-min { color: var(--muted); }
+    
+    .results-body {
+      padding: 24px;
+      overflow-y: auto;
+      flex: 1;
+    }
+    
+    .ai-summary {
+      font-size: 14px;
+      line-height: 1.6;
+      margin-bottom: 24px;
+      padding: 16px;
+      background: rgba(142, 68, 173, 0.05);
+      border-left: 3px solid var(--purple);
+      border-radius: 0 4px 4px 0;
+    }
+    
+    .positives-list {
+      margin-bottom: 32px;
+    }
+    
+    .positives-list h4 {
+      font-size: 13px;
+      color: var(--muted);
+      text-transform: uppercase;
+      letter-spacing: 0.5px;
+      margin-bottom: 12px;
+      display: flex;
+      align-items: center;
+      gap: 8px;
+    }
+    
+    .positives-list ul {
+      list-style: none;
+      padding: 0;
+      margin: 0;
+      display: flex;
+      flex-direction: column;
+      gap: 8px;
+    }
+    
+    .positives-list li {
+      display: flex;
+      align-items: flex-start;
+      gap: 8px;
+      font-size: 13px;
+    }
+    
+    .positives-list li::before {
+      content: '✓';
+      color: #3fb950;
+      font-weight: bold;
+    }
+    
+    .issues-list {
+      display: flex;
+      flex-direction: column;
+      gap: 16px;
+    }
+    
+    .issue-card {
+      padding: 16px;
+      border: 1px solid var(--border);
+      border-radius: var(--radius-sm);
+      background: var(--bg);
+    }
+    
+    .ic-critical { border-left: 3px solid #ff7b72; }
+    .ic-major { border-left: 3px solid #e3b341; }
+    .ic-minor { border-left: 3px solid var(--border2); }
+    
+    .issue-header {
+      display: flex;
+      align-items: center;
+      gap: 12px;
+      margin-bottom: 8px;
+    }
+    
+    .issue-line {
+      font-family: 'JetBrains Mono', monospace;
+      font-size: 12px;
+      color: var(--muted);
+      background: var(--surface);
+      padding: 2px 6px;
+      border-radius: 4px;
+    }
+    
+    .issue-badge {
+      font-size: 11px;
+      padding: 2px 6px;
+      border-radius: 4px;
+      font-weight: 600;
+      text-transform: uppercase;
+    }
+    
+    .ib-type { background: var(--surface); border: 1px solid var(--border2); }
+    .ib-crit { background: rgba(218, 54, 51, 0.1); color: #ff7b72; }
+    .ib-maj { background: rgba(210, 153, 34, 0.1); color: #e3b341; }
+    .ib-min { background: var(--surface); color: var(--muted); }
+    
+    .issue-desc {
+      font-size: 14px;
+      margin-bottom: 8px;
+    }
+    
+    .issue-fix {
+      font-size: 13px;
+      color: #3fb950;
+      background: rgba(63, 185, 80, 0.05);
+      padding: 8px 12px;
+      border-radius: 4px;
+      margin-top: 8px;
+      font-family: 'JetBrains Mono', monospace;
+    }
+
     /* ── TOAST ──────────────────────────────────────────────────────────── */
     #toast-container {
       position: fixed;
@@ -1927,8 +2169,13 @@
             <label class="field-label" for="task-select">Task Difficulty</label>
             <select id="task-select" aria-label="Select task difficulty">
               <option value="easy">Easy — Basic Bug Detection</option>
+              <option value="js-async">Easy-Medium — JS Async Flow</option>
               <option value="medium">Medium — Security Review</option>
+              <option value="sql-injection">Medium — SQL Injection Hunt</option>
+              <option value="react-security">Medium — React Security</option>
               <option value="hard">Hard — Concurrency Hunt</option>
+              <option value="django-auth">Hard — Django Auth Logic</option>
+              <option value="node-race">Hard — Node.js Race Condition</option>
             </select>
 
             <button class="btn btn-purple btn-full" id="start-btn" style="margin-top:16px;" onclick="startReview()">
@@ -2074,6 +2321,112 @@
     </div>
   </section>
 
+  <!-- ══════════════════════════════════════════════════════════════════════ -->
+  <!-- FREE CODE REVIEW                                                      -->
+  <!-- ══════════════════════════════════════════════════════════════════════ -->
+  <section class="section" id="free-review">
+    <div class="container">
+      <div class="section-header fade-up">
+        <div style="display:flex;align-items:center;gap:12px;">
+          <div class="section-label">Beta Feature</div>
+          <span style="background:rgba(210,153,34,0.15);color:#e3b341;border:1px solid rgba(227,179,65,0.3);padding:2px 8px;border-radius:12px;font-size:11px;font-weight:bold;text-transform:uppercase;">BETA</span>
+        </div>
+        <h2 class="section-title">Free Code Review</h2>
+        <p class="section-sub">Paste any code — get instant AI feedback</p>
+      </div>
+
+      <div class="free-review-container fade-up delay-1">
+        <!-- LEFT: Input -->
+        <div class="free-input-panel">
+          <div style="display:flex;gap:12px;">
+            <div style="flex:1;">
+              <select id="free-language" aria-label="Language selector" style="width:100%;background:var(--surface);border:1px solid var(--border);border-radius:var(--radius-sm);color:var(--text);padding:10px 14px;outline:none;">
+                <option value="python">Python</option>
+                <option value="javascript">JavaScript</option>
+                <option value="typescript">TypeScript</option>
+                <option value="sql">SQL</option>
+                <option value="go">Go</option>
+                <option value="java">Java</option>
+                <option value="cpp">C++</option>
+              </select>
+            </div>
+            <div style="flex:2;">
+              <input type="text" id="free-context" placeholder="Context: What does this code do? (optional)" 
+                style="width:100%;background:var(--surface);border:1px solid var(--border);border-radius:var(--radius-sm);color:var(--text);padding:10px 14px;outline:none;">
+            </div>
+          </div>
+
+          <div class="free-editor-wrapper">
+            <textarea id="free-code-input" placeholder="Paste your code here...&#10;Supports Python, JS, SQL, Go, Java, C++ and more"></textarea>
+          </div>
+
+          <button class="btn btn-purple btn-full" id="run-free-btn" onclick="runFreeReview()" style="height:48px;font-size:15px;font-weight:600;box-shadow:0 0 16px rgba(142,68,173,0.3);">
+            <svg viewBox="0 0 24 24" style="width:18px;height:18px;margin-right:8px;stroke:currentColor;fill:none;stroke-width:2;vertical-align:middle;margin-top:-2px;">
+              <circle cx="11" cy="11" r="8"></circle>
+              <line x1="21" y1="21" x2="16.65" y2="16.65"></line>
+            </svg>
+            Review My Code
+          </button>
+          
+          <div style="font-size:11px;color:var(--muted);text-align:center;">
+            AI-powered review. No ground truth scoring. For exploration and demos only.
+          </div>
+        </div>
+
+        <!-- RIGHT: Output -->
+        <div class="free-output-panel">
+          
+          <!-- Empty State -->
+          <div class="empty-state" id="free-empty">
+            <svg viewBox="0 0 24 24">
+              <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"></path>
+              <polyline points="14 2 14 8 20 8"></polyline>
+              <line x1="16" y1="13" x2="8" y2="13"></line>
+              <line x1="16" y1="17" x2="8" y2="17"></line>
+              <polyline points="10 9 9 9 8 9"></polyline>
+            </svg>
+            <div>Paste code and click <strong>Review</strong> to get AI feedback</div>
+          </div>
+          
+          <!-- Loading State -->
+          <div class="loading-state" id="free-loading">
+            <div class="spinner" style="width:32px;height:32px;border-width:3px;margin-bottom:16px;"></div>
+            <div style="color:var(--text);font-weight:600;">AI is reviewing your code...</div>
+            <div style="color:var(--muted);font-size:13px;margin-top:8px;">This usually takes 5-10 seconds depending on code length.</div>
+          </div>
+          
+          <!-- Results State -->
+          <div class="results-state" id="free-results">
+            <div class="results-summary-bar">
+              <div style="display:flex;align-items:center;gap:12px;">
+                <span id="free-verdict" class="verdict-badge verdict-comment">COMMENT</span>
+                <span style="font-weight:600;font-size:15px;" id="free-issue-count">0 issues found</span>
+              </div>
+              <div class="severity-counts">
+                <div class="scount"><span class="sc-crit">🔴</span> <span id="sc-c">0</span> critical</div>
+                <div class="scount"><span class="sc-maj">🟡</span> <span id="sc-m">0</span> major</div>
+                <div class="scount"><span class="sc-min">⚪</span> <span id="sc-mi">0</span> minor</div>
+              </div>
+            </div>
+            
+            <div class="results-body">
+              <div class="ai-summary" id="free-summary"></div>
+              
+              <div class="positives-list" id="free-positives">
+                <h4>What looks good</h4>
+                <ul id="free-pos-ul"></ul>
+              </div>
+              
+              <div class="issues-list" id="free-issues">
+                <!-- Issues populated by JS -->
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </section>
+
   <hr class="divider" />
 
   <!-- ══════════════════════════════════════════════════════════════════════ -->
@@ -2167,6 +2520,126 @@
           <button class="task-try-btn" id="try-hard-btn" onclick="jumpToDemo('hard')" aria-label="Try hard task">Try
             this task →</button>
         </div>
+
+        <!-- JS Async -->
+        <div class="task-card easy fade-up delay-1" id="task-card-js-async">
+          <div class="task-card-top">
+            <span class="diff-badge">EASY-MEDIUM</span>
+          </div>
+          <h3 class="task-name">JavaScript Async Flow Review</h3>
+          <p class="task-file">api/fetcher.js</p>
+          <p class="task-desc">Review a JavaScript module handling data fetching and state updates. Find async/await pitfalls and race conditions.</p>
+          <div class="task-tags">
+            <span class="tag">Missing Await</span>
+            <span class="tag">Promise Errors</span>
+            <span class="tag">Race Condition</span>
+            <span class="tag">Caching Logic</span>
+          </div>
+          <div class="task-meta">
+            <span>Max 4 steps</span>
+            <span class="sep">•</span>
+            <span>3 issues hidden</span>
+            <span class="sep">•</span>
+            <span>Score: 0.92</span>
+          </div>
+          <button class="task-try-btn" id="try-js-async-btn" onclick="jumpToDemo('js-async')" aria-label="Try JS async task">Try this task →</button>
+        </div>
+
+        <!-- SQL Injection -->
+        <div class="task-card medium fade-up delay-2" id="task-card-sql-injection">
+          <div class="task-card-top">
+            <span class="diff-badge">MEDIUM</span>
+          </div>
+          <h3 class="task-name">Advanced SQL Injection Hunt</h3>
+          <p class="task-file">db/reports.js</p>
+          <p class="task-desc">Review a Node.js database service. Identify multiple sophisticated SQL injection patterns in dynamic queries.</p>
+          <div class="task-tags">
+            <span class="tag">Order By Injection</span>
+            <span class="tag">Limit Injection</span>
+            <span class="tag">Template Literals</span>
+            <span class="tag">Parameterization</span>
+          </div>
+          <div class="task-meta">
+            <span>Max 5 steps</span>
+            <span class="sep">•</span>
+            <span>4 vulnerabilities</span>
+            <span class="sep">•</span>
+            <span>Score: 0.88</span>
+          </div>
+          <button class="task-try-btn" id="try-sql-injection-btn" onclick="jumpToDemo('sql-injection')" aria-label="Try SQL injection task">Try this task →</button>
+        </div>
+
+        <!-- React Security -->
+        <div class="task-card medium fade-up delay-3" id="task-card-react-security">
+          <div class="task-card-top">
+            <span class="diff-badge">MEDIUM</span>
+          </div>
+          <h3 class="task-name">React Component Security</h3>
+          <p class="task-file">components/UserProfile.jsx</p>
+          <p class="task-desc">Review a React component for XSS risks (dangerouslySetInnerHTML) and sensitive data leaks in console/URLs.</p>
+          <div class="task-tags">
+            <span class="tag">XSS</span>
+            <span class="tag">Data Leaks</span>
+            <span class="tag">Sanitization</span>
+            <span class="tag">React Hooks</span>
+          </div>
+          <div class="task-meta">
+            <span>Max 4 steps</span>
+            <span class="sep">•</span>
+            <span>3 issues hidden</span>
+            <span class="sep">•</span>
+            <span>Score: 0.90</span>
+          </div>
+          <button class="task-try-btn" id="try-react-security-btn" onclick="jumpToDemo('react-security')" aria-label="Try React task">Try this task →</button>
+        </div>
+
+        <!-- Django Auth -->
+        <div class="task-card hard fade-up delay-1" id="task-card-django-auth">
+          <div class="task-card-top">
+            <span class="diff-badge">HARD</span>
+          </div>
+          <h3 class="task-name">Django Auth Logic Review</h3>
+          <p class="task-file">auth/middleware.py</p>
+          <p class="task-desc">Review Django middleware and auth backends for bypasses, timing attacks, and improper exception handling.</p>
+          <div class="task-tags">
+            <span class="tag">Auth Bypass</span>
+            <span class="tag">Timing Attack</span>
+            <span class="tag">Middleware Logic</span>
+            <span class="tag">Security Logic</span>
+          </div>
+          <div class="task-meta">
+            <span>Max 7 steps</span>
+            <span class="sep">•</span>
+            <span>3 critical issues</span>
+            <span class="sep">•</span>
+            <span>Score: 0.85</span>
+          </div>
+          <button class="task-try-btn" id="try-django-auth-btn" onclick="jumpToDemo('django-auth')" aria-label="Try Django task">Try this task →</button>
+        </div>
+
+        <!-- Node Race -->
+        <div class="task-card hard fade-up delay-2" id="task-card-node-race">
+          <div class="task-card-top">
+            <span class="diff-badge">HARD</span>
+          </div>
+          <h3 class="task-name">Node.js Concurrency Issues</h3>
+          <p class="task-file">services/inventory.js</p>
+          <p class="task-desc">Identify race conditions and stale state updates in a Node.js singleton service responsible for inventory tracking.</p>
+          <div class="task-tags">
+            <span class="tag">Race Condition</span>
+            <span class="tag">Stale State</span>
+            <span class="tag">Atomicity</span>
+            <span class="tag">Singleton Pattern</span>
+          </div>
+          <div class="task-meta">
+            <span>Max 6 steps</span>
+            <span class="sep">•</span>
+            <span>2 critical loops</span>
+            <span class="sep">•</span>
+            <span>Score: 0.82</span>
+          </div>
+          <button class="task-try-btn" id="try-node-race-btn" onclick="jumpToDemo('node-race')" aria-label="Try Node race task">Try this task →</button>
+        </div>
       </div>
     </div>
   </section>

free_review.py

@@ -0,0 +1,91 @@
+from openai import OpenAI
+import os
+import json
+
+import inference
+
+GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY", "")
+GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai/"
+DEFAULT_MODEL = "gemini-2.0-flash" 
+# use whatever model name is working in inference.py currently
+
+SYSTEM_PROMPT = """You are an expert code reviewer with 15+ years 
+of experience. Review the provided code and identify ALL issues.
+
+For each issue found, provide:
+- line_number: exact line where issue occurs (integer)
+- issue_type: one of bug/security/performance/style/logic
+- severity: one of critical/major/minor
+- description: clear explanation of the problem
+- suggested_fix: how to fix it
+
+Also provide:
+- overall_verdict: approve/request_changes/comment
+- summary: 2-3 sentence overall assessment
+- positive_aspects: list of 2-3 things done well
+
+Respond ONLY with valid JSON, no markdown:
+{
+  "issues": [
+    {
+      "line_number": <int>,
+      "issue_type": "<type>",
+      "severity": "<severity>",
+      "description": "<description>",
+      "suggested_fix": "<fix>"
+    }
+  ],
+  "overall_verdict": "<verdict>",
+  "summary": "<summary>",
+  "positive_aspects": ["<aspect1>", "<aspect2>"]
+}"""
+
+def review_free_code(code: str, language: str = "python", 
+                     context: str = "") -> dict:
+    """
+    Review any arbitrary code using Gemini.
+    Returns structured findings without a grader score.
+    """
+    api_key_to_use = GEMINI_API_KEY if GEMINI_API_KEY else inference._api_key
+    base_url_to_use = GEMINI_BASE_URL if GEMINI_API_KEY else inference.API_BASE_URL
+
+    if not api_key_to_use:
+        return {"error": "GEMINI_API_KEY not set and inference proxy key unavailable"}
+
+    client = OpenAI(
+        api_key=api_key_to_use,
+        base_url=base_url_to_use
+    )
+
+    user_prompt = f"""Language: {language}
+Context: {context if context else "General code review"}
+
+Code to review:
+```{language}
+{code}
+```
+
+Review this code thoroughly and return JSON only."""
+
+    try:
+        response = client.chat.completions.create(
+            model=DEFAULT_MODEL,
+            messages=[
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": user_prompt}
+            ],
+            temperature=0.1,
+            max_tokens=3000,
+        )
+        content = response.choices[0].message.content.strip()
+        if content.startswith("```"):
+            lines = content.split("\n")
+            content = "\n".join(lines[1:])
+            if content.strip().endswith("```"):
+                content = content.strip()[:-3].strip()
+        return json.loads(content)
+    except json.JSONDecodeError:
+        return {"error": "Failed to parse AI response", 
+                "raw": content[:500]}
+    except Exception as e:
+        return {"error": str(e)}

tasks.py

@@ -19,38 +19,38 @@ TASKS: Dict[str, Dict[str, Any]] = {
         "file_name": "utils/statistics.py",
         "diff": """\
 --- a/utils/statistics.py
-+++ b/utils/statistics.py
+++ b/utils/statistics.py
 @@ -0,0 +1,30 @@
-+def calculate_average(numbers):
-+    total = 0
-+    for num in numbers:
-+        total += num
-+    return total / len(numbers)
-+
-+def calculate_max(numbers):
-+    max_val = numbers[0]
-+    for num in numbers:
-+        if num > max_val:
-+            max_val = num
-+    return max_val
-+
-+def get_percentage(value, total):
-+    return (value / total) * 100
-+
-+def find_duplicates(items):
-+    seen = []
-+    duplicates = []
-+    for item in items:
-+        if item in seen:
-+            duplicates.append(item)
-+        seen.append(item)
-+    return duplicates
-+
-+def safe_divide(a, b):
-+    if b != 0:
-+        return a / b
-+    else:
-+        return 0
+def calculate_average(numbers):
+    total = 0
+    for num in numbers:
+        total += num
+    return total / len(numbers)
+
+def calculate_max(numbers):
+    max_val = numbers[0]
+    for num in numbers:
+        if num > max_val:
+            max_val = num
+    return max_val
+
+def get_percentage(value, total):
+    return (value / total) * 100
+
+def find_duplicates(items):
+    seen = []
+    duplicates = []
+    for item in items:
+        if item in seen:
+            duplicates.append(item)
+        seen.append(item)
+    return duplicates
+
+def safe_divide(a, b):
+    if b != 0:
+        return a / b
+    else:
+        return 0
 """,
         "known_issues": [
             {
@@ -104,51 +104,51 @@ TASKS: Dict[str, Dict[str, Any]] = {
         "file_name": "auth/user_manager.py",
         "diff": """\
 --- a/auth/user_manager.py
-+++ b/auth/user_manager.py
+++ b/auth/user_manager.py
 @@ -0,0 +1,52 @@
-+import hashlib
-+
-+DB_PASSWORD = "admin123"
-+API_SECRET = "supersecret_key_do_not_share"
-+
-+def get_user(user_id):
-+    query = f"SELECT * FROM users WHERE id = {user_id}"
-+    return execute_query(query)
-+
-+def login(username, password):
-+    hashed = hashlib.md5(password.encode()).hexdigest()
-+    query = f"SELECT * FROM users WHERE username = '{username}' AND password = '{hashed}'"
-+    user = execute_query(query)
-+    if user:
-+        return {"status": "success", "user": user}
-+    return {"status": "failed"}
-+
-+def reset_password(email, new_password):
-+    if len(new_password) > 6:
-+        query = f"UPDATE users SET password = '{new_password}' WHERE email = '{email}'"
-+        execute_query(query)
-+        return True
-+    return False
-+
-+def delete_user(user_id):
-+    execute_query(f"DELETE FROM users WHERE id = {user_id}")
-+    return True
-+
-+def serialize_user(user_data):
-+    import pickle
-+    return pickle.dumps(user_data)
-+
-+def deserialize_user(data):
-+    import pickle
-+    return pickle.loads(data)
-+
-+def log_action(user, action):
-+    log_entry = f"[{action}] User: {user}"
-+    print(log_entry)
-+
-+def check_permission(user_role, required_role):
-+    roles = ["user", "moderator", "admin"]
-+    return roles.index(user_role) == roles.index(required_role)
+import hashlib
+
+DB_PASSWORD = "admin123"
+API_SECRET = "supersecret_key_do_not_share"
+
+def get_user(user_id):
+    query = f"SELECT * FROM users WHERE id = {user_id}"
+    return execute_query(query)
+
+def login(username, password):
+    hashed = hashlib.md5(password.encode()).hexdigest()
+    query = f"SELECT * FROM users WHERE username = '{username}' AND password = '{hashed}'"
+    user = execute_query(query)
+    if user:
+        return {"status": "success", "user": user}
+    return {"status": "failed"}
+
+def reset_password(email, new_password):
+    if len(new_password) > 6:
+        query = f"UPDATE users SET password = '{new_password}' WHERE email = '{email}'"
+        execute_query(query)
+        return True
+    return False
+
+def delete_user(user_id):
+    execute_query(f"DELETE FROM users WHERE id = {user_id}")
+    return True
+
+def serialize_user(user_data):
+    import pickle
+    return pickle.dumps(user_data)
+
+def deserialize_user(data):
+    import pickle
+    return pickle.loads(data)
+
+def log_action(user, action):
+    log_entry = f"[{action}] User: {user}"
+    print(log_entry)
+
+def check_permission(user_role, required_role):
+    roles = ["user", "moderator", "admin"]
+    return roles.index(user_role) == roles.index(required_role)
 """,
         "known_issues": [
             {
@@ -230,98 +230,98 @@ TASKS: Dict[str, Dict[str, Any]] = {
         "file_name": "core/rate_limiter.py",
         "diff": """\
 --- a/core/rate_limiter.py
-+++ b/core/rate_limiter.py
+++ b/core/rate_limiter.py
 @@ -0,0 +1,82 @@
-+import time
-+import threading
-+from collections import defaultdict
-+
-+class RateLimiter:
-+    def __init__(self, max_requests, window_seconds):
-+        self.max_requests = max_requests
-+        self.window_seconds = window_seconds
-+        self.requests = defaultdict(list)
-+        self.lock = threading.Lock()
-+
-+    def is_allowed(self, user_id):
-+        now = time.time()
-+        window_start = now - self.window_seconds
-+        with self.lock:
-+            self.requests[user_id] = [
-+                t for t in self.requests[user_id] if t > window_start
-+            ]
-+            if len(self.requests[user_id]) < self.max_requests:
-+                self.requests[user_id].append(now)
-+                return True
-+            return False
-+
-+class TaskQueue:
-+    def __init__(self, max_workers=4):
-+        self.queue = []
-+        self.max_workers = max_workers
-+        self.workers = []
-+        self.running = False
-+
-+    def add_task(self, task_fn, *args):
-+        self.queue.append((task_fn, args))
-+
-+    def _worker(self):
-+        while self.running:
-+            if self.queue:
-+                task_fn, args = self.queue.pop(0)
-+                try:
-+                    task_fn(*args)
-+                except Exception:
-+                    pass
-+            time.sleep(0.01)
-+
-+    def start(self):
-+        self.running = True
-+        for _ in range(self.max_workers):
-+            t = threading.Thread(target=self._worker)
-+            t.start()
-+            self.workers.append(t)
-+
-+    def stop(self):
-+        self.running = False
-+
-+class RetryQueue:
-+    def __init__(self, max_retries=3):
-+        self.max_retries = max_retries
-+        self.failed_tasks = {}
-+        self.retry_counts = defaultdict(int)
-+
-+    def add_failed(self, task_id, task_fn):
-+        self.failed_tasks[task_id] = task_fn
-+
-+    def retry_all(self):
-+        for task_id, task_fn in self.failed_tasks.items():
-+            if self.retry_counts[task_id] < self.max_retries:
-+                try:
-+                    task_fn()
-+                    del self.failed_tasks[task_id]
-+                except Exception:
-+                    self.retry_counts[task_id] += 1
-+
-+    def get_stats(self):
-+        return {
-+            "pending": len(self.failed_tasks),
-+            "total_retries": sum(self.retry_counts.values())
-+        }
-+
-+def process_batch(items, batch_size=100):
-+    results = []
-+    for i in range(0, len(items), batch_size):
-+        batch = items[i:i+batch_size]
-+        result = process_items(batch)
-+        results.append(result)
-+    return results
-+
-+def merge_configs(base_config, override_config):
-+    merged = base_config
-+    for key, value in override_config.items():
-+        merged[key] = value
-+    return merged
+import time
+import threading
+from collections import defaultdict
+
+class RateLimiter:
+    def __init__(self, max_requests, window_seconds):
+        self.max_requests = max_requests
+        self.window_seconds = window_seconds
+        self.requests = defaultdict(list)
+        self.lock = threading.Lock()
+
+    def is_allowed(self, user_id):
+        now = time.time()
+        window_start = now - self.window_seconds
+        with self.lock:
+            self.requests[user_id] = [
+                t for t in self.requests[user_id] if t > window_start
+            ]
+            if len(self.requests[user_id]) < self.max_requests:
+                self.requests[user_id].append(now)
+                return True
+            return False
+
+class TaskQueue:
+    def __init__(self, max_workers=4):
+        self.queue = []
+        self.max_workers = max_workers
+        self.workers = []
+        self.running = False
+
+    def add_task(self, task_fn, *args):
+        self.queue.append((task_fn, args))
+
+    def _worker(self):
+        while self.running:
+            if self.queue:
+                task_fn, args = self.queue.pop(0)
+                try:
+                    task_fn(*args)
+                except Exception:
+                    pass
+            time.sleep(0.01)
+
+    def start(self):
+        self.running = True
+        for _ in range(self.max_workers):
+            t = threading.Thread(target=self._worker)
+            t.start()
+            self.workers.append(t)
+
+    def stop(self):
+        self.running = False
+
+class RetryQueue:
+    def __init__(self, max_retries=3):
+        self.max_retries = max_retries
+        self.failed_tasks = {}
+        self.retry_counts = defaultdict(int)
+
+    def add_failed(self, task_id, task_fn):
+        self.failed_tasks[task_id] = task_fn
+
+    def retry_all(self):
+        for task_id, task_fn in self.failed_tasks.items():
+            if self.retry_counts[task_id] < self.max_retries:
+                try:
+                    task_fn()
+                    del self.failed_tasks[task_id]
+                except Exception:
+                    self.retry_counts[task_id] += 1
+
+    def get_stats(self):
+        return {
+            "pending": len(self.failed_tasks),
+            "total_retries": sum(self.retry_counts.values())
+        }
+
+def process_batch(items, batch_size=100):
+    results = []
+    for i in range(0, len(items), batch_size):
+        batch = items[i:i+batch_size]
+        result = process_items(batch)
+        results.append(result)
+    return results
+
+def merge_configs(base_config, override_config):
+    merged = base_config
+    for key, value in override_config.items():
+        merged[key] = value
+    return merged
 """,
         "known_issues": [
             {
@@ -384,12 +384,344 @@ TASKS: Dict[str, Dict[str, Any]] = {
         "required_verdict": "request_changes",
         "success_threshold": 0.35,
     },
-}
 
+    "js-async": {
+        "id": "js-async",
+        "name": "JavaScript Async Flow Review",
+        "description": "Review a JavaScript module handling data fetching and state updates. Find async/await pitfalls and race conditions.",
+        "difficulty": "easy-medium",
+        "max_steps": 4,
+        "pr_title": "Fix data loading and caching logic",
+        "pr_description": "Implements an async data Fetcher with internal cache.",
+        "file_name": "api/fetcher.js",
+        "diff": """\
+--- a/api/fetcher.js
++++ b/api/fetcher.js
+@@ -0,0 +1,35 @@
++class DataFetcher {
++  constructor() {
++    this.cache = {};
++    this.loading = false;
++  }
++
++  async fetchData(url) {
++    if (this.cache[url]) return this.cache[url];
++
++    this.loading = true;
++    try {
++      const response = fetch(url);
++      const data = await response.json();
++      this.cache[url] = data;
++      return data;
++    } catch (err) {
++      console.error("Fetch failed");
++    } finally {
++      this.loading = false;
++    }
++  }
++
++  updateUI(data) {
++    this.fetchData('/api/user').then(user => {
++      document.getElementById('user').innerText = user.name;
++    });
++  }
++
++  async loadItems(urls) {
++    urls.forEach(async (url) => {
++      await this.fetchData(url);
++    });
++  }
++}
+""",
+        "known_issues": [
+            {
+                "line_number": 11,
+                "issue_type": "bug",
+                "severity": "critical",
+                "description": "Missing await on fetch(url) — response will be a Promise, not the result",
+                "keywords": ["await", "fetch", "promise"],
+            },
+            {
+                "line_number": 16,
+                "issue_type": "bug",
+                "severity": "major",
+                "description": "Silent error swallowing in catch block without rethrowing or user notification",
+                "keywords": ["catch", "swallow", "error", "rethrow"],
+            },
+            {
+                "line_number": 30,
+                "issue_type": "performance",
+                "severity": "major",
+                "description": "forEach with async callback doesn't await the loop — use Promise.all or for...of",
+                "keywords": ["forEach", "async", "Promise.all", "loop"],
+            },
+        ],
+        "required_verdict": "request_changes",
+        "success_threshold": 0.5,
+    },
+
+    "sql-injection": {
+        "id": "sql-injection",
+        "name": "Advanced SQL Injection Hunt",
+        "description": "Review a Node.js database service. Identify multiple sophisticated SQL injection patterns.",
+        "difficulty": "medium",
+        "max_steps": 5,
+        "pr_title": "Enhance reporting queries with dynamic sorting",
+        "pr_description": "Adds support for custom sort orders and limits in reports.",
+        "file_name": "db/reports.js",
+        "diff": """\
+--- a/db/reports.js
++++ b/db/reports.js
+@@ -0,0 +1,28 @@
++const db = require('./connection');
++
++async function getReport(type, sortBy = 'created_at', limit = 10) {
++  const query = `
++    SELECT * FROM reports 
++    WHERE type = '${type}' 
++    ORDER BY ${sortBy} 
++    LIMIT ${limit}
++  `;
++  return db.query(query);
++}
++
++async function getUserSummary(userId) {
++  const sql = "SELECT * FROM summaries WHERE user_id = " + userId;
++  return db.query(sql);
++}
++
++async function searchLogs(term) {
++  const sql = `SELECT * FROM logs WHERE message LIKE '%${term}%'`;
++  return db.query(sql);
++}
+""",
+        "known_issues": [
+            {
+                "line_number": 6,
+                "issue_type": "security",
+                "severity": "critical",
+                "description": "Classic SQL Injection in WHERE clause via template literal",
+                "keywords": ["sql injection", "injection", "template literal"],
+            },
+            {
+                "line_number": 7,
+                "issue_type": "security",
+                "severity": "critical",
+                "description": "SQL Injection in ORDER BY clause — cannot be parameterized, must use whitelist",
+                "keywords": ["order by", "injection", "whitelist"],
+            },
+            {
+                "line_number": 8,
+                "issue_type": "security",
+                "severity": "critical",
+                "description": "SQL Injection in LIMIT clause — ensure limit is a number",
+                "keywords": ["limit", "injection", "number"],
+            },
+            {
+                "line_number": 14,
+                "issue_type": "security",
+                "severity": "critical",
+                "description": "Simple string concatenation SQL Injection",
+                "keywords": ["concatenation", "injection", "sql"],
+            },
+        ],
+        "required_verdict": "request_changes",
+        "success_threshold": 0.6,
+    },
+
+    "react-security": {
+        "id": "react-security",
+        "name": "React Component Security",
+        "description": "Review a React component for XSS risks and sensitive data leaks.",
+        "difficulty": "medium",
+        "max_steps": 4,
+        "pr_title": "Implement UserProfile component with markdown support",
+        "pr_description": "Adds a profile page that renders user-provided bio content.",
+        "file_name": "components/UserProfile.jsx",
+        "diff": """\
+--- a/components/UserProfile.jsx
++++ b/components/UserProfile.jsx
+@@ -0,0 +1,25 @@
++import React from 'react';
++
++export const UserProfile = ({ user, authToken }) => {
++  console.log("Loading profile for user:", user.id, "Token:", authToken);
++
++  const renderBio = (bio) => {
++    return <div dangerouslySetInnerHTML={{ __html: bio }} />;
++  };
++
++  return (
++    <div className="profile-card">
++      <h1>{user.name}</h1>
++      <div className="bio">
++        {renderBio(user.bio)}
++      </div>
++      <button onClick={() => window.location.href = `/edit?token=${authToken}`}>
++        Edit Profile
++      </button>
++    </div>
++  );
++};
+""",
+        "known_issues": [
+            {
+                "line_number": 4,
+                "issue_type": "security",
+                "severity": "major",
+                "description": "Sensitive data (authToken) leaked to browser console",
+                "keywords": ["console", "leak", "token", "sensitive"],
+            },
+            {
+                "line_number": 7,
+                "issue_type": "security",
+                "severity": "critical",
+                "description": "XSS vulnerability via dangerouslySetInnerHTML without sanitization",
+                "keywords": ["dangerouslySetInnerHTML", "xss", "sanitize", "cross-site scripting"],
+            },
+            {
+                "line_number": 16,
+                "issue_type": "security",
+                "severity": "major",
+                "description": "Sensitive token leaked in URL query parameters",
+                "keywords": ["url", "query parameter", "token", "leak"],
+            },
+        ],
+        "required_verdict": "request_changes",
+        "success_threshold": 0.5,
+    },
+
+    "django-auth": {
+        "id": "django-auth",
+        "name": "Django Auth Logic Review",
+        "description": "Review Django middleware and auth backends for bypasses and timing attacks.",
+        "difficulty": "hard",
+        "max_steps": 7,
+        "pr_title": "Custom Authentication and Security Middleware",
+        "pr_description": "Customizes Django auth to support legacy hash formats and IP-based restrictions.",
+        "file_name": "auth/middleware.py",
+        "diff": """\
+--- a/auth/middleware.py
++++ b/auth/middleware.py
+@@ -0,0 +1,40 @@
++from django.shortcuts import redirect
++from django.conf import settings
++
++class IPBlockMiddleware:
++    def __init__(self, get_response):
++        self.get_response = get_response
++
++    def __call__(self, request):
++        ip = request.META.get('REMOTE_ADDR')
++        if ip in settings.BLOCKED_IPS:
++            return redirect('/blocked/')
++        return self.get_response(request)
++
++class LegacyBackend:
++    def authenticate(self, request, username=None, password=None):
++        user = User.objects.get(username=username)
++        if user.legacy_password == password:
++            return user
++        return None
++
++def validate_token(token):
++    if token == settings.SUPER_SECRET_TOKEN:
++        return True
++    return False
++
++def secure_view(request):
++    if not request.user.is_authenticated:
++        return redirect('/login/')
++    # Sensitive data processing here
++    pass
+""",
+        "known_issues": [
+            {
+                "line_number": 17,
+                "issue_type": "security",
+                "severity": "critical",
+                "description": "Plaintext password comparison for legacy accounts",
+                "keywords": ["plaintext", "password", "comparison"],
+            },
+            {
+                "line_number": 21,
+                "issue_type": "security",
+                "severity": "critical",
+                "description": "Timing attack vulnerability in string comparison for secret token",
+                "keywords": ["timing attack", "comparison", "constant time"],
+            },
+            {
+                "line_number": 16,
+                "issue_type": "bug",
+                "severity": "major",
+                "description": "User.objects.get() raises DoesNotExist if user not found; should use filter().first() or try/except",
+                "keywords": ["DoesNotExist", "exception", "crash"],
+            },
+        ],
+        "required_verdict": "request_changes",
+        "success_threshold": 0.4,
+    },
+
+    "node-race": {
+        "id": "node-race",
+        "name": "Node.js Concurrency Issues",
+        "description": "Identify race conditions in a Node.js singleton service responsible for inventory tracking.",
+        "difficulty": "hard",
+        "max_steps": 6,
+        "pr_title": "Inventory Management Singleton",
+        "pr_description": "Initial implementation of in-memory inventory tracking for fast access.",
+        "file_name": "services/inventory.js",
+        "diff": """\
+--- a/services/inventory.js
++++ b/services/inventory.js
+@@ -0,0 +1,30 @@
++let inventory = {
++  'item_1': 100,
++  'item_2': 50
++};
++
++async function purchaseItem(itemId, quantity) {
++  const currentStock = inventory[itemId];
++  
++  if (currentStock >= quantity) {
++    // Simulate DB delay
++    await new Promise(resolve => setTimeout(resolve, 100));
++    
++    inventory[itemId] = currentStock - quantity;
++    return true;
++  }
++  return false;
++}
++
++async function restockItem(itemId, amount) {
++  inventory[itemId] += amount;
++}
++
++module.exports = { purchaseItem, restockItem };
+""",
+        "known_issues": [
+            {
+                "line_number": 7,
+                "issue_type": "bug",
+                "severity": "critical",
+                "description": "Race condition: stock checked at line 7 but updated at line 12 after await. Parallel calls can lead to over-selling.",
+                "keywords": ["race condition", "atomic", "oversell"],
+            },
+            {
+                "line_number": 12,
+                "issue_type": "bug",
+                "severity": "major",
+                "description": "Inventory update uses stale 'currentStock' variable instead of incrementing current value.",
+                "keywords": ["stale", "atomic", "increment"],
+            },
+        ],
+        "required_verdict": "request_changes",
+        "success_threshold": 0.3,
+    },
+}
 
 def get_task(task_id: str) -> Dict[str, Any]:
     return TASKS.get(task_id, {})
 
-
 def get_all_tasks() -> List[Dict[str, Any]]:
     return list(TASKS.values())

tmpclaude-46e1-cwd

@@ -0,0 +1 @@
+/c/Users/psaru/OneDrive/Desktop/code-review-env

tmpclaude-5602-cwd

@@ -0,0 +1 @@
+/c/Users/psaru/OneDrive/Desktop/code-review-env

tmpclaude-ee5f-cwd

@@ -0,0 +1 @@
+/c/Users/psaru/OneDrive/Desktop/code-review-env