devcouncil 0.1.0 → 0.1.1

package/src/devcouncil/telemetry/tracker.py

@@ -1,49 +1,49 @@
-import json
-from pathlib import Path
-from typing import Dict, Any
-
-COST_PER_1K_TOKENS = {
-    "anthropic/claude-3-opus": {"prompt": 0.015, "completion": 0.075},
-    "anthropic/claude-3.5-sonnet": {"prompt": 0.003, "completion": 0.015},
-    "openai/gpt-4o": {"prompt": 0.005, "completion": 0.015},
-    "google/gemini-pro-1.5": {"prompt": 0.00125, "completion": 0.00375},
-}
-
-class TelemetryTracker:
-    def __init__(self, project_root: Path):
-        self.log_file = project_root / ".devcouncil" / "logs" / "telemetry.json"
-        self.stats = self._load()
-
-    def _load(self) -> Dict[str, Any]:
-        if self.log_file.exists():
-            try:
-                with open(self.log_file, "r") as f:
-                    return json.load(f)
-            except Exception:
-                pass
-        return {"total_cost": 0.0, "total_prompt_tokens": 0, "total_completion_tokens": 0, "models": {}}
-
-    def _save(self):
-        self.log_file.parent.mkdir(parents=True, exist_ok=True)
-        with open(self.log_file, "w") as f:
-            json.dump(self.stats, f, indent=2)
-
-    def log_usage(self, model: str, usage: Dict[str, int]):
-        prompt_tokens = usage.get("prompt_tokens", 0)
-        completion_tokens = usage.get("completion_tokens", 0)
-
-        rates = COST_PER_1K_TOKENS.get(model, {"prompt": 0.0, "completion": 0.0})
-        cost = (prompt_tokens / 1000.0) * rates["prompt"] + (completion_tokens / 1000.0) * rates["completion"]
-
-        self.stats["total_cost"] += cost
-        self.stats["total_prompt_tokens"] += prompt_tokens
-        self.stats["total_completion_tokens"] += completion_tokens
-
-        if model not in self.stats["models"]:
-            self.stats["models"][model] = {"cost": 0.0, "prompt_tokens": 0, "completion_tokens": 0}
-
-        self.stats["models"][model]["cost"] += cost
-        self.stats["models"][model]["prompt_tokens"] += prompt_tokens
-        self.stats["models"][model]["completion_tokens"] += completion_tokens
-
-        self._save()
+import json
+from pathlib import Path
+from typing import Dict, Any
+
+COST_PER_1K_TOKENS = {
+    "anthropic/claude-3-opus": {"prompt": 0.015, "completion": 0.075},
+    "anthropic/claude-3.5-sonnet": {"prompt": 0.003, "completion": 0.015},
+    "openai/gpt-4o": {"prompt": 0.005, "completion": 0.015},
+    "google/gemini-pro-1.5": {"prompt": 0.00125, "completion": 0.00375},
+}
+
+class TelemetryTracker:
+    def __init__(self, project_root: Path):
+        self.log_file = project_root / ".devcouncil" / "logs" / "telemetry.json"
+        self.stats = self._load()
+
+    def _load(self) -> Dict[str, Any]:
+        if self.log_file.exists():
+            try:
+                with open(self.log_file, "r") as f:
+                    return json.load(f)
+            except Exception:
+                pass
+        return {"total_cost": 0.0, "total_prompt_tokens": 0, "total_completion_tokens": 0, "models": {}}
+
+    def _save(self):
+        self.log_file.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.log_file, "w") as f:
+            json.dump(self.stats, f, indent=2)
+
+    def log_usage(self, model: str, usage: Dict[str, int]):
+        prompt_tokens = usage.get("prompt_tokens", 0)
+        completion_tokens = usage.get("completion_tokens", 0)
+
+        rates = COST_PER_1K_TOKENS.get(model, {"prompt": 0.0, "completion": 0.0})
+        cost = (prompt_tokens / 1000.0) * rates["prompt"] + (completion_tokens / 1000.0) * rates["completion"]
+
+        self.stats["total_cost"] += cost
+        self.stats["total_prompt_tokens"] += prompt_tokens
+        self.stats["total_completion_tokens"] += completion_tokens
+
+        if model not in self.stats["models"]:
+            self.stats["models"][model] = {"cost": 0.0, "prompt_tokens": 0, "completion_tokens": 0}
+
+        self.stats["models"][model]["cost"] += cost
+        self.stats["models"][model]["prompt_tokens"] += prompt_tokens
+        self.stats["models"][model]["completion_tokens"] += completion_tokens
+
+        self._save()

package/src/devcouncil/ui/__init__.py

@@ -0,0 +1 @@
+"""Live DevCouncil dashboard helpers."""

package/src/devcouncil/ui/dashboard.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+import json
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from urllib.parse import urlparse
+
+from devcouncil.app.project_status import compute_phase
+from devcouncil.storage.db import get_db
+from devcouncil.storage.repositories import ArtifactGraphRepository, StateRepository, TaskRepository
+from devcouncil.telemetry.traces import read_trace_events
+
+
+def dashboard_payload(project_root: Path) -> dict:
+    db = get_db(project_root)
+    if not db:
+        return {"initialized": False, "phase": "UNINITIALIZED", "tasks": [], "coverage": {}, "events": []}
+    with db.get_session() as session:
+        graph = ArtifactGraphRepository(session).load_graph()
+        state = StateRepository(session).get_state()
+        phase = compute_phase(graph, state.current_phase if state else None)
+        tasks = [task.model_dump() for task in TaskRepository(session).get_all()]
+        return {
+            "initialized": True,
+            "phase": phase,
+            "coverage": graph.coverage_summary(),
+            "tasks": tasks,
+            "events": [event.model_dump(by_alias=True) for event in list(read_trace_events(project_root))[-50:]],
+        }
+
+
+def dashboard_html() -> str:
+    return """<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>DevCouncil Dashboard</title>
+  <style>
+    body { margin: 0; font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; background: #f7f7f5; color: #202124; }
+    header { padding: 20px 28px; border-bottom: 1px solid #d9d9d4; background: #ffffff; display: flex; align-items: center; justify-content: space-between; }
+    main { padding: 24px 28px; display: grid; grid-template-columns: 1fr 1fr; gap: 18px; }
+    section { background: #ffffff; border: 1px solid #d9d9d4; border-radius: 8px; padding: 16px; }
+    h1 { font-size: 20px; margin: 0; }
+    h2 { font-size: 15px; margin: 0 0 12px; }
+    .phase { font-weight: 700; }
+    table { width: 100%; border-collapse: collapse; font-size: 13px; }
+    th, td { text-align: left; border-bottom: 1px solid #ededeb; padding: 8px; vertical-align: top; }
+    pre { margin: 0; white-space: pre-wrap; font-size: 12px; }
+    @media (max-width: 800px) { main { grid-template-columns: 1fr; padding: 16px; } header { padding: 16px; } }
+  </style>
+</head>
+<body>
+  <header><h1>DevCouncil Dashboard</h1><div>Phase: <span id="phase" class="phase">loading</span></div></header>
+  <main>
+    <section><h2>Coverage</h2><pre id="coverage">{}</pre></section>
+    <section><h2>Tasks</h2><table><thead><tr><th>ID</th><th>Status</th><th>Title</th></tr></thead><tbody id="tasks"></tbody></table></section>
+    <section style="grid-column: 1 / -1;"><h2>Recent Trace Events</h2><pre id="events"></pre></section>
+  </main>
+  <script>
+    function setText(cell, value) {
+      cell.textContent = value == null ? '' : String(value);
+      return cell;
+    }
+    async function refresh() {
+      const res = await fetch('/api/status');
+      const data = await res.json();
+      document.getElementById('phase').textContent = data.phase;
+      document.getElementById('coverage').textContent = JSON.stringify(data.coverage, null, 2);
+      const body = document.getElementById('tasks');
+      body.replaceChildren(...(data.tasks || []).map(t => {
+        const row = document.createElement('tr');
+        row.appendChild(setText(document.createElement('td'), t.id));
+        row.appendChild(setText(document.createElement('td'), t.status));
+        row.appendChild(setText(document.createElement('td'), t.title));
+        return row;
+      }));
+      document.getElementById('events').textContent = JSON.stringify(data.events || [], null, 2);
+    }
+    refresh();
+    setInterval(refresh, 2000);
+  </script>
+</body>
+</html>"""
+
+
+def run_dashboard(project_root: Path, host: str = "127.0.0.1", port: int = 8765) -> None:
+    class DashboardServer(ThreadingHTTPServer):
+        allow_reuse_address = True
+        daemon_threads = True
+
+    class Handler(BaseHTTPRequestHandler):
+        def do_GET(self):  # noqa: N802
+            parsed = urlparse(self.path)
+            if parsed.path == "/api/status":
+                body = json.dumps(dashboard_payload(project_root)).encode("utf-8")
+                self.send_response(200)
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Content-Length", str(len(body)))
+                self.end_headers()
+                self.wfile.write(body)
+                return
+            if parsed.path.startswith("/api/"):
+                body = json.dumps({"error": "Not found"}).encode("utf-8")
+                self.send_response(404)
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Content-Length", str(len(body)))
+                self.end_headers()
+                self.wfile.write(body)
+                return
+            body = dashboard_html().encode("utf-8")
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html; charset=utf-8")
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+
+        def log_message(self, format, *args):  # noqa: A002
+            return
+
+    server = DashboardServer((host, port), Handler)
+    server.serve_forever()

package/src/devcouncil/utils/__init__.py

@@ -1 +1 @@
-"""Utilities package: redaction, paths, hashing, subprocess helpers."""
+"""Utilities package: redaction, paths, hashing, subprocess helpers."""

package/src/devcouncil/utils/redaction.py

@@ -1,141 +1,141 @@
-"""Proactive secret and PII redaction for LLM-bound prompts.
-
-Two entry points:
-  - redact_string(text)  -- regex-based redaction of known secret patterns
-  - redact_text(text, extra_patterns)  -- enhanced version with custom patterns and typed labels
-  - redact_env_vars(text)  -- redact values in environment variable assignments
-  - redact_dict(data)  -- recursively redact all string values in a dict
-"""
-
-import re
-from typing import Dict, List, Optional, Pattern
-
-# Common patterns for sensitive data — each with a human-readable label
-SECRET_PATTERNS: Dict[str, Pattern] = {
-    "aws_access_key": re.compile(r"(?i)\b(AKIA[0-9A-Z]{16})\b"),
-    "aws_secret_key": re.compile(r"(?i)(?:aws_secret_access_key|aws_secret|secret_key)\s*[=:]\s*([0-9a-zA-Z/+]{40})"),
-    "github_token": re.compile(r"(?i)\b(gh[pusr]_[A-Za-z0-9_]{36})\b"),
-    "slack_token": re.compile(r"(?i)\b(xox[baprs]-[0-9]{12}-[0-9]{12}-[0-9]{12}-[a-z0-9]{32})\b"),
-    "jwt": re.compile(r"(?i)\b(ey[a-zA-Z0-9_-]{10,}\.ey[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,})\b"),
-    "generic_api_key": re.compile(r"(?i)(api[_-]?key|secret|token|password)[\"'\s]*[:=][\"'\s]*([a-zA-Z0-9_\-\.]{16,})"),
-    "private_key": re.compile(r"(?s)-----BEGIN [A-Z]+ PRIVATE KEY-----.*?-----END [A-Z]+ PRIVATE KEY-----"),
-    "bearer": re.compile(r"(?i)\b(Bearer\s+)([a-zA-Z0-9_\-\.]{16,})\b"),
-    "database_url": re.compile(r"(?i)((?:postgresql|mysql|mongodb|redis)://[^:]+:)([^@]+)(@.+)"),
-}
-
-# For backward compatibility
-def redact_string(text: str) -> str:
-    """Redact known sensitive patterns from a string (legacy API)."""
-    return redact_text(text)
-
-
-def redact_text(text: str, extra_patterns: Optional[List[str]] = None) -> str:
-    """Redact known sensitive patterns from a string.
-    
-    Args:
-        text: The input text to redact.
-        extra_patterns: Optional list of regex patterns to additionally redact,
-                       labeled as [REDACTED:custom_N].
-    
-    Returns:
-        Text with all sensitive patterns replaced with [REDACTED:type] labels.
-    """
-    if not isinstance(text, str):
-        return text
-        
-    redacted_text = text
-    
-    for key_type, pattern in SECRET_PATTERNS.items():
-        if key_type == "generic_api_key":
-            # For the generic pattern, replace the value part (group 2)
-            def _make_generic_replacer(kt: str):
-                def replacer(match):
-                    prefix = match.group(1)
-                    separator = match.group(0)[len(match.group(1)):-len(match.group(2))]
-                    return f"{prefix}{separator}[REDACTED:{kt}]"
-                return replacer
-            redacted_text = pattern.sub(_make_generic_replacer(key_type), redacted_text)
-        elif key_type == "bearer":
-            # Preserve "Bearer " prefix, redact the token
-            def _bearer_replacer(match):
-                return f"{match.group(1)}[REDACTED:bearer]"
-            redacted_text = pattern.sub(_bearer_replacer, redacted_text)
-        elif key_type == "database_url":
-            # Preserve protocol and host, redact password
-            def _db_url_replacer(match):
-                return f"{match.group(1)}[REDACTED:database_url]{match.group(3)}"
-            redacted_text = pattern.sub(_db_url_replacer, redacted_text)
-        else:
-            redacted_text = pattern.sub(f"[REDACTED:{key_type}]", redacted_text)
-    
-    # Apply custom extra patterns
-    if extra_patterns:
-        for i, pat_str in enumerate(extra_patterns):
-            try:
-                pat = re.compile(pat_str)
-                redacted_text = pat.sub(f"[REDACTED:custom_{i}]", redacted_text)
-            except re.error:
-                pass  # Skip invalid patterns
-            
-    return redacted_text
-
-
-def redact_env_vars(text: str) -> str:
-    """Redact values in environment variable assignments.
-    
-    Handles patterns like:
-      export KEY=value
-      KEY='value'
-      KEY="value"
-    """
-    if not isinstance(text, str):
-        return text
-
-    # Match: optional export, VAR_NAME = value (with optional quotes)
-    env_pattern = re.compile(
-        r"(?m)^(\s*(?:export\s+)?)"               # optional export
-        r"([A-Z_][A-Z0-9_]*)"                      # variable name
-        r"(\s*=\s*)"                                # equals sign
-        r"(?:'([^']*)'|\"([^\"]*)\"|(\S+))"         # value (quoted or unquoted)
-    )
-
-    sensitive_keys = {
-        "api_key", "secret", "token", "password", "passwd", "credential",
-        "private_key", "access_key", "secret_key", "auth",
-    }
-
-    def _env_replacer(match):
-        prefix = match.group(1)
-        var_name = match.group(2)
-        eq_sign = match.group(3)
-        
-        # Check if the variable name contains a sensitive keyword
-        var_lower = var_name.lower()
-        is_sensitive = any(kw in var_lower for kw in sensitive_keys)
-        
-        if is_sensitive:
-            return f"{prefix}{var_name}{eq_sign}[REDACTED]"
-        
-        return match.group(0)
-
-    return env_pattern.sub(_env_replacer, text)
-
-
-def redact_dict(data: dict) -> dict:
-    """Recursively redact sensitive patterns from a dictionary (e.g. JSON response)."""
-    result = {}
-    for k, v in data.items():
-        if isinstance(v, str):
-            result[k] = redact_text(v)
-        elif isinstance(v, dict):
-            result[k] = redact_dict(v)
-        elif isinstance(v, list):
-            result[k] = [
-                redact_dict(item) if isinstance(item, dict)
-                else redact_text(item) if isinstance(item, str)
-                else item
-                for item in v
-            ]
-        else:
-            result[k] = v
-    return result
+"""Proactive secret and PII redaction for LLM-bound prompts.
+
+Two entry points:
+  - redact_string(text)  -- regex-based redaction of known secret patterns
+  - redact_text(text, extra_patterns)  -- enhanced version with custom patterns and typed labels
+  - redact_env_vars(text)  -- redact values in environment variable assignments
+  - redact_dict(data)  -- recursively redact all string values in a dict
+"""
+
+import re
+from typing import Dict, List, Optional, Pattern
+
+# Common patterns for sensitive data — each with a human-readable label
+SECRET_PATTERNS: Dict[str, Pattern] = {
+    "aws_access_key": re.compile(r"(?i)\b(AKIA[0-9A-Z]{16})\b"),
+    "aws_secret_key": re.compile(r"(?i)(?:aws_secret_access_key|aws_secret|secret_key)\s*[=:]\s*([0-9a-zA-Z/+]{40})"),
+    "github_token": re.compile(r"(?i)\b(gh[pusr]_[A-Za-z0-9_]{36})\b"),
+    "slack_token": re.compile(r"(?i)\b(xox[baprs]-[0-9]{12}-[0-9]{12}-[0-9]{12}-[a-z0-9]{32})\b"),
+    "jwt": re.compile(r"(?i)\b(ey[a-zA-Z0-9_-]{10,}\.ey[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,})\b"),
+    "generic_api_key": re.compile(r"(?i)(api[_-]?key|secret|token|password)[\"'\s]*[:=][\"'\s]*([a-zA-Z0-9_\-\.]{16,})"),
+    "private_key": re.compile(r"(?s)-----BEGIN [A-Z]+ PRIVATE KEY-----.*?-----END [A-Z]+ PRIVATE KEY-----"),
+    "bearer": re.compile(r"(?i)\b(Bearer\s+)([a-zA-Z0-9_\-\.]{16,})\b"),
+    "database_url": re.compile(r"(?i)((?:postgresql|mysql|mongodb|redis)://[^:]+:)([^@]+)(@.+)"),
+}
+
+# For backward compatibility
+def redact_string(text: str) -> str:
+    """Redact known sensitive patterns from a string (legacy API)."""
+    return redact_text(text)
+
+
+def redact_text(text: str, extra_patterns: Optional[List[str]] = None) -> str:
+    """Redact known sensitive patterns from a string.
+    
+    Args:
+        text: The input text to redact.
+        extra_patterns: Optional list of regex patterns to additionally redact,
+                       labeled as [REDACTED:custom_N].
+    
+    Returns:
+        Text with all sensitive patterns replaced with [REDACTED:type] labels.
+    """
+    if not isinstance(text, str):
+        return text
+        
+    redacted_text = text
+    
+    for key_type, pattern in SECRET_PATTERNS.items():
+        if key_type == "generic_api_key":
+            # For the generic pattern, replace the value part (group 2)
+            def _make_generic_replacer(kt: str):
+                def replacer(match):
+                    prefix = match.group(1)
+                    separator = match.group(0)[len(match.group(1)):-len(match.group(2))]
+                    return f"{prefix}{separator}[REDACTED:{kt}]"
+                return replacer
+            redacted_text = pattern.sub(_make_generic_replacer(key_type), redacted_text)
+        elif key_type == "bearer":
+            # Preserve "Bearer " prefix, redact the token
+            def _bearer_replacer(match):
+                return f"{match.group(1)}[REDACTED:bearer]"
+            redacted_text = pattern.sub(_bearer_replacer, redacted_text)
+        elif key_type == "database_url":
+            # Preserve protocol and host, redact password
+            def _db_url_replacer(match):
+                return f"{match.group(1)}[REDACTED:database_url]{match.group(3)}"
+            redacted_text = pattern.sub(_db_url_replacer, redacted_text)
+        else:
+            redacted_text = pattern.sub(f"[REDACTED:{key_type}]", redacted_text)
+    
+    # Apply custom extra patterns
+    if extra_patterns:
+        for i, pat_str in enumerate(extra_patterns):
+            try:
+                pat = re.compile(pat_str)
+                redacted_text = pat.sub(f"[REDACTED:custom_{i}]", redacted_text)
+            except re.error:
+                pass  # Skip invalid patterns
+            
+    return redacted_text
+
+
+def redact_env_vars(text: str) -> str:
+    """Redact values in environment variable assignments.
+    
+    Handles patterns like:
+      export KEY=value
+      KEY='value'
+      KEY="value"
+    """
+    if not isinstance(text, str):
+        return text
+
+    # Match: optional export, VAR_NAME = value (with optional quotes)
+    env_pattern = re.compile(
+        r"(?m)^(\s*(?:export\s+)?)"               # optional export
+        r"([A-Z_][A-Z0-9_]*)"                      # variable name
+        r"(\s*=\s*)"                                # equals sign
+        r"(?:'([^']*)'|\"([^\"]*)\"|(\S+))"         # value (quoted or unquoted)
+    )
+
+    sensitive_keys = {
+        "api_key", "secret", "token", "password", "passwd", "credential",
+        "private_key", "access_key", "secret_key", "auth",
+    }
+
+    def _env_replacer(match):
+        prefix = match.group(1)
+        var_name = match.group(2)
+        eq_sign = match.group(3)
+        
+        # Check if the variable name contains a sensitive keyword
+        var_lower = var_name.lower()
+        is_sensitive = any(kw in var_lower for kw in sensitive_keys)
+        
+        if is_sensitive:
+            return f"{prefix}{var_name}{eq_sign}[REDACTED]"
+        
+        return match.group(0)
+
+    return env_pattern.sub(_env_replacer, text)
+
+
+def redact_dict(data: dict) -> dict:
+    """Recursively redact sensitive patterns from a dictionary (e.g. JSON response)."""
+    result = {}
+    for k, v in data.items():
+        if isinstance(v, str):
+            result[k] = redact_text(v)
+        elif isinstance(v, dict):
+            result[k] = redact_dict(v)
+        elif isinstance(v, list):
+            result[k] = [
+                redact_dict(item) if isinstance(item, dict)
+                else redact_text(item) if isinstance(item, str)
+                else item
+                for item in v
+            ]
+        else:
+            result[k] = v
+    return result

package/src/devcouncil/verification/__init__.py

@@ -1 +1 @@
-
+

package/src/devcouncil/verification/implementation_reviewer.py

@@ -1,55 +1,55 @@
-import json
-from typing import List
-from pydantic import BaseModel
-from devcouncil.domain.task import Task
-from devcouncil.domain.requirement import Requirement
-from devcouncil.domain.gap import Gap
-from devcouncil.llm.router import ModelRouter
-from devcouncil.utils.redaction import redact_string
-
-class ReviewOutput(BaseModel):
-    is_satisfactory: bool
-    findings: List[Gap]
-
-class ImplementationReviewer:
-    """Uses LLM to review code changes against task requirements."""
-    
-    def __init__(self, router: ModelRouter):
-        self.router = router
-
-    async def review_changes(
-        self, 
-        task: Task, 
-        requirements: List[Requirement], 
-        diff: str
-    ) -> ReviewOutput:
-        linked_reqs = [r for r in requirements if r.id in task.requirement_ids]
-        if not linked_reqs:
-            linked_reqs = requirements
-        requirements_json = json.dumps([r.model_dump() for r in linked_reqs], indent=2)
-        redacted_diff = redact_string(diff)
-        prompt = f"""
-You are an expert software reviewer. Review the following code changes against the task requirements.
-Task: {task.title}
-Description: {task.description}
-
-Requirements:
-{requirements_json}
-
-Code Diff:
-{redacted_diff}
-
-Your task is to identify if the implementation is complete, correct, and follows best practices.
-- Identify missing edge cases.
-- Identify architectural drift.
-- Identify security risks not caught by static scans.
-
-Return a JSON object with 'is_satisfactory' and a list of 'findings' (as Gap objects).
-"""
-        messages = [{"role": "user", "content": prompt}]
-        
-        return await self.router.complete_structured(
-            role="implementation_reviewer",
-            messages=messages,
-            schema=ReviewOutput
-        )
+import json
+from typing import List
+from pydantic import BaseModel
+from devcouncil.domain.task import Task
+from devcouncil.domain.requirement import Requirement
+from devcouncil.domain.gap import Gap
+from devcouncil.llm.router import ModelRouter
+from devcouncil.utils.redaction import redact_string
+
+class ReviewOutput(BaseModel):
+    is_satisfactory: bool
+    findings: List[Gap]
+
+class ImplementationReviewer:
+    """Uses LLM to review code changes against task requirements."""
+    
+    def __init__(self, router: ModelRouter):
+        self.router = router
+
+    async def review_changes(
+        self, 
+        task: Task, 
+        requirements: List[Requirement], 
+        diff: str
+    ) -> ReviewOutput:
+        linked_reqs = [r for r in requirements if r.id in task.requirement_ids]
+        if not linked_reqs:
+            linked_reqs = requirements
+        requirements_json = json.dumps([r.model_dump() for r in linked_reqs], indent=2)
+        redacted_diff = redact_string(diff)
+        prompt = f"""
+You are an expert software reviewer. Review the following code changes against the task requirements.
+Task: {task.title}
+Description: {task.description}
+
+Requirements:
+{requirements_json}
+
+Code Diff:
+{redacted_diff}
+
+Your task is to identify if the implementation is complete, correct, and follows best practices.
+- Identify missing edge cases.
+- Identify architectural drift.
+- Identify security risks not caught by static scans.
+
+Return a JSON object with 'is_satisfactory' and a list of 'findings' (as Gap objects).
+"""
+        messages = [{"role": "user", "content": prompt}]
+        
+        return await self.router.complete_structured(
+            role="implementation_reviewer",
+            messages=messages,
+            schema=ReviewOutput
+        )