benchmark: add AIEB v1.0 agent intelligence benchmark

9 tasks across 3 tiers (reasoning, search, code generation).
Automated scoring with keyword matching, LOC verification,
and runtime import/execution tests.

First run: odek + deepseek-v4-flash = 90% score, 199s, 208K tokens.

Usage: python3 benchmark/run_aieb.py

Author: molty3000

benchmark/__pycache__/aieb.cpython-311.pyc

@@ -0,0 +1,11 @@
+"""Chain of Responsibility base."""
+from abc import ABC, abstractmethod
+from typing import Any
+
+class BaseHandler(ABC):
+    def __init__(self): self._next: BaseHandler | None = None
+    def set_next(self, h: "BaseHandler") -> "BaseHandler": self._next = h; return h
+    @abstractmethod
+    def handle(self, r: dict[str, Any]) -> dict[str, Any] | None: ...
+    def _pass(self, r: dict[str, Any]) -> dict[str, Any] | None:
+        return self._next.handle(r) if self._next else None

benchmark/aieb.py

@@ -0,0 +1,17 @@
+"""Concrete handlers."""
+from typing import Any
+from .base import BaseHandler
+
+class AuthHandler(BaseHandler):
+    def handle(self, r: dict[str, Any]) -> dict[str, Any] | None:
+        if r.get("auth") == "valid": r["authenticated"] = True; return self._pass(r)
+        return {"error": "unauthorized"}
+
+class RateLimitHandler(BaseHandler):
+    def __init__(self, max_rps=100): super().__init__(); self.max_rps = max_rps
+    def handle(self, r: dict[str, Any]) -> dict[str, Any] | None:
+        return self._pass(r) if r.get("rate",0) <= self.max_rps else {"error":"rate_limited"}
+
+class BusinessLogicHandler(BaseHandler):
+    def handle(self, r: dict[str, Any]) -> dict[str, Any] | None:
+        return self._pass(r) or {"status":"processed","data":r}

benchmark/benchmark_data/__pycache__/refactor_me.cpython-311.pyc

@@ -0,0 +1,7 @@
+"""Pipeline builder."""
+from .handlers import AuthHandler, RateLimitHandler, BusinessLogicHandler
+
+def build_pipeline(max_rps=100):
+    a = AuthHandler(); r = RateLimitHandler(max_rps); l = BusinessLogicHandler()
+    a.set_next(r).set_next(l)
+    return a

benchmark/benchmark_data/__pycache__/under_tested.cpython-311.pyc

@@ -0,0 +1,12 @@
+"""User authentication — CONTAINS A BUG."""
+def authenticate(username: str, password: str, user_db: dict) -> bool:
+    if not username or not password:
+        return False
+    user = user_db.get(username)
+    if user is None:
+        return False
+    if user["active"] = False:  # BUG: assignment, not comparison
+        return False
+    if user["password"] != password:
+        return False
+    return True

benchmark/benchmark_data/arch_project/__init__.py

@@ -0,0 +1,33 @@
+"""Event processing utilities."""
+from collections import defaultdict
+from datetime import datetime
+from typing import Any
+
+def process_events(events: list[dict[str, Any]], window_seconds: int = 300) -> list[dict[str, Any]]:
+    """Process a list of timestamped events."""
+    if not events:
+        return []
+    seen: set[str] = set()
+    unique: list[dict[str, Any]] = []
+    for evt in events:
+        eid = evt.get("id", "")
+        if eid and eid not in seen:
+            seen.add(eid)
+            unique.append(evt)
+    unique.sort(key=lambda e: e.get("ts", datetime.min))
+    windows: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    for evt in unique:
+        ts = evt.get("ts")
+        if ts is None:
+            continue
+        bucket = ts.replace(second=0, microsecond=0)
+        windows[bucket.isoformat()].append(evt)
+    result: list[dict[str, Any]] = []
+    for window_key, bucket in sorted(windows.items()):
+        result.append({
+            "window": window_key, "count": len(bucket),
+            "types": list({e.get("type", "unknown") for e in bucket}),
+            "earliest": min(e["ts"] for e in bucket).isoformat(),
+            "latest": max(e["ts"] for e in bucket).isoformat(),
+        })
+    return result