Refactor code structure for improved readability and maintainability

.python-version

@@ -0,0 +1 @@
+3.12

app/__init__.py

@@ -0,0 +1 @@
+"""Application package marker."""

app/core/agents.py

@@ -1,4 +1,7 @@
+import asyncio
+import json
 import logging
+import re
 from collections.abc import AsyncIterator
 from typing import Any
 
@@ -38,8 +41,43 @@ def _sanitize_json_str(raw: str) -> str:
 def extract_json_from_response(content: str) -> dict[str, Any] | None:
     """
     Extract JSON block from agent response content with light sanitization.
-    Looks for ```json ... ``` blocks first, then any raw JSON object.
+
+    Strategy (tried in order):
+      1. Fenced code block: ```json ... ```
+      2. Raw JSON object: outermost { ... }
+
+    Returns parsed dict on success, None if no valid JSON found.
     """
+    if not content or not content.strip():
+        return None
+
+    # --- Strategy 1: fenced ```json ... ``` blocks ---
+    json_match = re.search(r"```(?:json)?\s*([\s\S]*?)\s*```", content)
+    if json_match:
+        raw = json_match.group(1).strip()
+        sanitized = _sanitize_json_str(raw)
+        try:
+            parsed = json.loads(sanitized)
+            if isinstance(parsed, dict):
+                return parsed
+        except json.JSONDecodeError:
+            logger.debug(
+                "Fenced JSON block found but failed to parse after sanitization"
+            )
+
+    # --- Strategy 2: raw JSON object { ... } ---
+    json_match = re.search(r"\{[\s\S]*\}", content)
+    if json_match:
+        raw = json_match.group(0).strip()
+        sanitized = _sanitize_json_str(raw)
+        try:
+            parsed = json.loads(sanitized)
+            if isinstance(parsed, dict):
+                return parsed
+        except json.JSONDecodeError:
+            logger.debug("Raw JSON object found but failed to parse after sanitization")
+
+    return None
 
 
 class AgentSystem:
@@ -175,7 +213,7 @@ paused requests to prevent further problems.
             # Track token usage (estimate)
             await self.token_tracker.record_usage(
                 prompt_tokens=0,  # Hard to calculate without formatting
-                completion_tokens=self._estimate_tokens(response),
+                completion_tokens=self._estimate_tokens(str(response)),
                 model="nvidia-nim",  # Generic for now
                 operation=f"agent_{role}",
             )
@@ -183,7 +221,7 @@ paused requests to prevent further problems.
             # Mark provider as successful
             await self.provider_manager.mark_success("nvidia")
 
-            return response
+            return str(response)
 
         except CircuitOpenError:
             logger.warning(f"Circuit open for {role}, attempting graceful degradation")
@@ -376,6 +414,14 @@ paused requests to prevent further problems.
         """
         Process a step with streaming output for real-time UI updates.
 
+        Includes the same resilience patterns as the non-streaming path:
+        - Circuit breaker check (fail-fast if API is unhealthy)
+        - Budget check (prevent runaway costs)
+        - Retry with exponential backoff on transient failures
+        - Token usage tracking (estimated from streamed output)
+        - Provider health marking (success/failure)
+        - Performance timing
+
         Yields chunks of content as they are generated.
 
         Args:
@@ -392,6 +438,32 @@ paused requests to prevent further problems.
             >>> async for chunk in agent.process_step_streaming(role, context, []):
             ...     print(chunk, end="", flush=True)
         """
+        import time as _time
+
+        from .resilience import get_circuit_breaker
+
+        start_time = _time.monotonic()
+
+        # --- Circuit breaker check (fail-fast) ---
+        circuit = get_circuit_breaker("nvidia_api")
+        if not await circuit.can_execute():
+            logger.warning(
+                f"Circuit open for streaming {role.value}, returning degraded response"
+            )
+            yield self._get_degraded_response(role.value)
+            return
+
+        # --- Budget check ---
+        try:
+            check_budget_or_raise(1000)  # Placeholder estimate
+        except Exception as e:
+            logger.error(f"Budget exceeded for streaming {role.value}: {e}")
+            track_error(
+                e, context={"role": role.value, "operation": "streaming_budget"}
+            )
+            yield f"\n\n[Error: Budget limit exceeded. {e}]"
+            return
+
         # Get streaming LLM
         llm = self._get_llm_for_role(role, streaming=True)
 
@@ -429,11 +501,76 @@ paused requests to prevent further problems.
 
         logger.info(f"Starting streaming for role={role.value}")
 
-        try:
-            async for chunk in llm.astream(messages):
-                if chunk.content:
-                    yield str(chunk.content)
-        except Exception as e:
-            logger.error(f"Streaming error for {role.value}: {e}")
-            track_error(e, context={"role": role.value, "operation": "streaming"})
-            yield f"\n\n[Error: {str(e)}]"
+        # --- Retry loop with exponential backoff ---
+        max_retries = 3
+        base_delay = 2.0
+
+        for attempt in range(max_retries + 1):
+            collected_content = ""
+            stream_started = False
+
+            try:
+                async for chunk in llm.astream(messages):
+                    if chunk.content:
+                        stream_started = True
+                        chunk_text = str(chunk.content)
+                        collected_content += chunk_text
+                        yield chunk_text
+
+                # --- Stream completed successfully ---
+                await circuit.record_success()
+                await self.provider_manager.mark_success("nvidia")
+
+                # Track token usage (estimate from collected output)
+                await self.token_tracker.record_usage(
+                    prompt_tokens=0,  # Hard to calculate without tokenizer
+                    completion_tokens=self._estimate_tokens(collected_content),
+                    model="nvidia-nim",
+                    operation=f"agent_{role.value}_streaming",
+                )
+
+                elapsed = _time.monotonic() - start_time
+                logger.info(
+                    f"Streaming completed for role={role.value} in {elapsed:.2f}s, "
+                    f"~{self._estimate_tokens(collected_content)} tokens"
+                )
+                return  # Success — exit the retry loop
+
+            except Exception as e:
+                await circuit.record_failure(e)
+                await self.provider_manager.mark_failure("nvidia", e)
+                track_error(
+                    e,
+                    context={
+                        "role": role.value,
+                        "operation": "streaming",
+                        "attempt": attempt + 1,
+                    },
+                )
+
+                if stream_started:
+                    # We already yielded partial content — cannot retry transparently.
+                    # Yield error marker and stop.
+                    logger.error(
+                        f"Streaming error for {role.value} after partial output "
+                        f"(attempt {attempt + 1}): {e}"
+                    )
+                    yield f"\n\n[Error: Stream interrupted — {e}]"
+                    return
+
+                if attempt < max_retries:
+                    import random
+
+                    delay = min(base_delay * (2.0**attempt), 60.0)
+                    delay *= 0.5 + random.random()  # jitter
+                    logger.warning(
+                        f"Streaming attempt {attempt + 1}/{max_retries} failed for "
+                        f"{role.value}, retrying in {delay:.2f}s: {e}"
+                    )
+                    await asyncio.sleep(delay)
+                else:
+                    logger.error(
+                        f"All {max_retries + 1} streaming attempts failed for "
+                        f"{role.value}: {e}"
+                    )
+                    yield self._get_degraded_response(role.value)

app/core/cache.py

@@ -8,6 +8,7 @@ Uses HTTP-based Redis client optimized for serverless environments.
 import json
 import logging
 import os
+from collections.abc import Callable
 from dataclasses import dataclass
 from datetime import UTC, datetime
 from functools import wraps
@@ -23,12 +24,13 @@ logger = logging.getLogger(__name__)
 @dataclass
 class CacheConfig:
     """Cache configuration with sensible defaults."""
+
     # TTL values in seconds
-    summary_ttl: int = 300 # 5 minutes for summary stats
-    trends_ttl: int = 600 # 10 minutes for trend data
-    projects_ttl: int = 300 # 5 minutes for project list
-    runs_ttl: int = 120 # 2 minutes for run details
-    default_ttl: int = 300 # 5 minutes default
+    summary_ttl: int = 300  # 5 minutes for summary stats
+    trends_ttl: int = 600  # 10 minutes for trend data
+    projects_ttl: int = 300  # 5 minutes for project list
+    runs_ttl: int = 120  # 2 minutes for run details
+    default_ttl: int = 300  # 5 minutes default
 
     # Cache key prefixes
     prefix: str = "specsbeforecode:observability"
@@ -71,6 +73,9 @@ class UpstashRedisCache:
         if self._sync_client is None:
             try:
                 from upstash_redis import Redis
+
+                if not self.url or not self.token:
+                    return None
                 self._sync_client = Redis(url=self.url, token=self.token)
                 logger.info("Upstash Redis sync client initialized")
             except Exception as e:
@@ -86,6 +91,9 @@ class UpstashRedisCache:
         if self._async_client is None:
             try:
                 from upstash_redis.asyncio import Redis
+
+                if not self.url or not self.token:
+                    return None
                 self._async_client = Redis(url=self.url, token=self.token)
                 logger.info("Upstash Redis async client initialized")
             except Exception as e:
@@ -134,12 +142,7 @@ class UpstashRedisCache:
             logger.warning(f"Cache get error for {key}: {e}")
             return None
 
-    def set(
-        self,
-        key: str,
-        value: Any,
-        ttl: int | None = None
-    ) -> bool:
+    def set(self, key: str, value: Any, ttl: int | None = None) -> bool:
         """Set value in cache with TTL (sync)."""
         client = self._get_sync_client()
         if not client:
@@ -203,12 +206,7 @@ class UpstashRedisCache:
             logger.warning(f"Async cache get error for {key}: {e}")
             return None
 
-    async def aset(
-        self,
-        key: str,
-        value: Any,
-        ttl: int | None = None
-    ) -> bool:
+    async def aset(self, key: str, value: Any, ttl: int | None = None) -> bool:
         """Set value in cache with TTL (async)."""
         client = self._get_async_client()
         if not client:
@@ -254,14 +252,22 @@ class UpstashRedisCache:
             logger.warning(f"Async cache exists error for {key}: {e}")
             return False
 
-    def get_summary_key(self, user_id: str, start_date: str, end_date: str, project_id: str | None = None) -> str:
+    def get_summary_key(
+        self,
+        user_id: str,
+        start_date: str,
+        end_date: str,
+        project_id: str | None = None,
+    ) -> str:
         """Generate cache key for summary stats."""
         parts = ["summary", user_id, start_date, end_date]
         if project_id:
             parts.append(project_id)
         return ":".join(parts)
 
-    def get_trends_key(self, user_id: str, period: str, project_id: str | None = None) -> str:
+    def get_trends_key(
+        self, user_id: str, period: str, project_id: str | None = None
+    ) -> str:
         """Generate cache key for trends data."""
         parts = ["trends", user_id, period]
         if project_id:
@@ -282,7 +288,7 @@ class UpstashRedisCache:
         start_date: str,
         end_date: str,
         data: dict[str, Any],
-        project_id: str | None = None
+        project_id: str | None = None,
     ) -> bool:
         """Cache summary statistics."""
         key = self.get_summary_key(user_id, start_date, end_date, project_id)
@@ -293,7 +299,7 @@ class UpstashRedisCache:
         user_id: str,
         start_date: str,
         end_date: str,
-        project_id: str | None = None
+        project_id: str | None = None,
     ) -> dict[str, Any] | None:
         """Get cached summary statistics."""
         key = self.get_summary_key(user_id, start_date, end_date, project_id)
@@ -304,17 +310,14 @@ class UpstashRedisCache:
         user_id: str,
         period: str,
         data: dict[str, Any],
-        project_id: str | None = None
+        project_id: str | None = None,
     ) -> bool:
         """Cache trends data."""
         key = self.get_trends_key(user_id, period, project_id)
         return await self.aset(key, data, ttl=self.config.trends_ttl)
 
     async def get_cached_trends(
-        self,
-        user_id: str,
-        period: str,
-        project_id: str | None = None
+        self, user_id: str, period: str, project_id: str | None = None
     ) -> dict[str, Any] | None:
         """Get cached trends data."""
         key = self.get_trends_key(user_id, period, project_id)
@@ -340,12 +343,15 @@ class UpstashRedisCache:
 
 
 def cached(
-    key_func: callable,
+    key_func: Callable[..., str | None],
     ttl: int | None = None,
-    cache_instance: UpstashRedisCache | None = None
+    cache_instance: UpstashRedisCache | None = None,
 ):
     """
-    Decorator for caching async function results.
+    Decorator for caching async function results with read-through semantics.
+
+    Flow: generate key → check cache → return cached if hit →
+          else call function → write result to cache → return result.
 
     Args:
         key_func: Function that generates cache key from function arguments
@@ -361,31 +367,44 @@ def cached(
             # expensive operation
             return await fetch_from_langsmith(...)
     """
+
     def decorator(func):
         @wraps(func)
         async def wrapper(*args, **kwargs):
             cache = cache_instance or get_cache()
 
-            # Generate cache key
-            """
-            Decorator for caching async function results.
-            Args:
-                key_func: Function that generates cache key from function arguments
-                ttl: Time-to-live in seconds (uses default if None)
-                cache_instance: Cache instance to use (creates default if None)
-            Example:
-                @cached(
-                    key_func=lambda *a, **kw: f"user:{a[0]}",
-                    ttl=60,
-                )
-            """
-            # Assume 'result' is the return value of func
+            # 1. Generate cache key
+            try:
+                cache_key = key_func(*args, **kwargs)
+            except Exception as e:
+                logger.warning(f"Cache key generation failed, skipping cache: {e}")
+                return await func(*args, **kwargs)
+
+            # 2. Check cache (read-through)
+            if cache_key:
+                try:
+                    cached_value = await cache.aget(cache_key)
+                    if cached_value is not None:
+                        logger.debug(f"Cache HIT for key: {cache_key}")
+                        return cached_value
+                except Exception as e:
+                    logger.warning(f"Cache read failed for {cache_key}: {e}")
+
+            # 3. Cache miss — call the wrapped function
             result = await func(*args, **kwargs)
-            cache_key = key_func(*args, **kwargs) if 'key_func' in locals() else None
+
+            # 4. Write result to cache (skip None to avoid caching errors)
             if result is not None and cache_key:
-                await cache.aset(cache_key, result, ttl=ttl)
+                try:
+                    await cache.aset(cache_key, result, ttl=ttl)
+                    logger.debug(f"Cache SET for key: {cache_key}")
+                except Exception as e:
+                    logger.warning(f"Cache write failed for {cache_key}: {e}")
+
             return result
+
         return wrapper
+
     return decorator
 
 
@@ -419,7 +438,7 @@ async def check_cache_health() -> dict[str, Any]:
         "configured": cache.is_configured,
         "status": "unknown",
         "latency_ms": None,
-        "error": None
+        "error": None,
     }
 
     if not cache.is_configured:
@@ -429,6 +448,7 @@ async def check_cache_health() -> dict[str, Any]:
 
     try:
         import time
+
         start = time.time()
 
         # Ping test with a simple set/get

app/core/cost_control.py

@@ -10,12 +10,15 @@ Includes:
 """
 
 import asyncio
+import json
 import os
+import tempfile
 import time
 from collections import defaultdict
 from dataclasses import dataclass, field
 from datetime import UTC, datetime
 from enum import Enum
+from pathlib import Path
 from typing import Any
 
 from dotenv import load_dotenv
@@ -29,6 +32,7 @@ logger = get_logger("cost_control")
 
 class CostAlertLevel(Enum):
     """Alert levels for cost monitoring."""
+
     INFO = "info"  # Normal usage
     WARNING = "warning"  # 70% of budget
     CRITICAL = "critical"  # 90% of budget
@@ -38,6 +42,7 @@ class CostAlertLevel(Enum):
 @dataclass
 class TokenUsage:
     """Token usage for a single request."""
+
     prompt_tokens: int = 0
     completion_tokens: int = 0
     total_tokens: int = 0
@@ -56,39 +61,125 @@ class TokenUsage:
 @dataclass
 class CostConfig:
     """Cost control configuration."""
+
     max_tokens_per_request: int = int(os.getenv("MAX_TOKENS_PER_REQUEST", "50000"))
     monthly_token_budget: int = int(os.getenv("MONTHLY_TOKEN_BUDGET", "10000000"))
     warning_threshold: float = 0.7  # 70% of budget
     critical_threshold: float = 0.9  # 90% of budget
 
     # Cost per 1K tokens for different models (estimates)
-    model_costs: dict[str, float] = field(default_factory=lambda: {
-        "meta/llama-3.1-70b-instruct": 0.0027,
-        "google/gemma-3-1b-it": 0.0005,
-        "nvidia/nv-embed-v1": 0.0001,
-        "default": 0.002,
-    })
+    model_costs: dict[str, float] = field(
+        default_factory=lambda: {
+            "meta/llama-3.1-70b-instruct": 0.0027,
+            "google/gemma-3-1b-it": 0.0005,
+            "nvidia/nv-embed-v1": 0.0001,
+            "default": 0.002,
+        }
+    )
 
 
 class TokenTracker:
     """
     Tracks token usage across requests for cost monitoring.
+
+    Monthly and operation totals are persisted to a JSON file so that
+    budget enforcement survives process restarts.  Writes are atomic
+    (temp-file + ``os.replace``) to avoid corruption.
     """
 
-    def __init__(self, config: CostConfig | None = None):
+    _DEFAULT_PERSISTENCE_DIR = os.getenv(
+        "TOKEN_USAGE_DIR",
+        os.path.join(os.path.dirname(__file__), "..", "..", "data"),
+    )
+
+    def __init__(
+        self,
+        config: CostConfig | None = None,
+        persistence_path: str | Path | None = None,
+    ):
         self.config = config or CostConfig()
         self._usage_history: list[TokenUsage] = []
         self._monthly_totals: dict[str, int] = defaultdict(int)  # {month: total_tokens}
-        self._operation_totals: dict[str, int] = defaultdict(int)  # {operation: total_tokens}
+        self._operation_totals: dict[str, int] = defaultdict(
+            int
+        )  # {operation: total_tokens}
         self._max_history = 100000
         self._lock = asyncio.Lock()
 
+        # --- Persistence setup ---
+        if persistence_path is not None:
+            self._persistence_path: Path | None = Path(persistence_path)
+        else:
+            self._persistence_path = (
+                Path(self._DEFAULT_PERSISTENCE_DIR) / "token_usage.json"
+            )
+        self._load_persisted_state()
+
+    # ------------------------------------------------------------------
+    # Persistence helpers
+    # ------------------------------------------------------------------
+
+    def _load_persisted_state(self) -> None:
+        """Load monthly/operation totals from the persistence file (if it exists)."""
+        if self._persistence_path is None:
+            return
+        try:
+            if self._persistence_path.exists():
+                raw = self._persistence_path.read_text(encoding="utf-8")
+                data = json.loads(raw)
+                for k, v in data.get("monthly_totals", {}).items():
+                    self._monthly_totals[k] = int(v)
+                for k, v in data.get("operation_totals", {}).items():
+                    self._operation_totals[k] = int(v)
+                logger.info(
+                    "Loaded persisted token usage",
+                    data={"path": str(self._persistence_path)},
+                )
+        except Exception as exc:
+            # Never crash the app because of a corrupt state file
+            logger.warning(
+                f"Failed to load persisted token state, starting fresh: {exc}"
+            )
+
+    def _persist_state(self) -> None:
+        """Atomically write monthly/operation totals to disk.
+
+        Uses a temporary file in the same directory followed by
+        ``os.replace`` to guarantee an atomic swap on POSIX systems.
+        """
+        if self._persistence_path is None:
+            return
+        try:
+            self._persistence_path.parent.mkdir(parents=True, exist_ok=True)
+            payload = json.dumps(
+                {
+                    "monthly_totals": dict(self._monthly_totals),
+                    "operation_totals": dict(self._operation_totals),
+                    "last_updated": datetime.now(UTC).isoformat(),
+                },
+                indent=2,
+            )
+            # Atomic write: write to temp file, then rename
+            fd, tmp_path = tempfile.mkstemp(
+                dir=str(self._persistence_path.parent),
+                prefix=".token_usage_",
+                suffix=".tmp",
+            )
+            try:
+                os.write(fd, payload.encode("utf-8"))
+                os.fsync(fd)
+            finally:
+                os.close(fd)
+            os.replace(tmp_path, str(self._persistence_path))
+        except Exception as exc:
+            logger.warning(f"Failed to persist token state: {exc}")
+
     async def record_usage(
         self,
         prompt_tokens: int,
         completion_tokens: int,
         model: str,
-        operation: str = "unknown"
+        operation: str = "unknown",
     ) -> TokenUsage:
         """Record token usage for a request."""
         total = prompt_tokens + completion_tokens
@@ -100,7 +191,7 @@ class TokenTracker:
             total_tokens=total,
             model=model,
             operation=operation,
-            cost_estimate=cost
+            cost_estimate=cost,
         )
 
         async with self._lock:
@@ -115,19 +206,22 @@ class TokenTracker:
 
             # Trim history if needed
             if len(self._usage_history) > self._max_history:
-                self._usage_history = self._usage_history[-self._max_history:]
+                self._usage_history = self._usage_history[-self._max_history :]
 
         # Check budget alerts
         self._check_budget_alerts()
 
+        # Persist updated totals to disk (atomic write)
+        self._persist_state()
+
         logger.info(
             "Token usage recorded",
             data={
                 "operation": operation,
                 "model": model,
                 "tokens": total,
-                "cost_estimate": cost
-            }
+                "cost_estimate": cost,
+            },
         )
 
         return usage
@@ -135,8 +229,7 @@ class TokenTracker:
     def _estimate_cost(self, tokens: int, model: str) -> float:
         """Estimate cost based on tokens and model."""
         cost_per_1k = self.config.model_costs.get(
-            model,
-            self.config.model_costs["default"]
+            model, self.config.model_costs["default"]
         )
         return (tokens / 1000) * cost_per_1k
 
@@ -163,8 +256,8 @@ class TokenTracker:
                 "level": level.value,
                 "current_usage": current_usage,
                 "budget": budget,
-                "usage_percent": round(ratio * 100, 2)
-            }
+                "usage_percent": round(ratio * 100, 2),
+            },
         )
 
     def check_request_budget(self, estimated_tokens: int) -> bool:
@@ -178,8 +271,8 @@ class TokenTracker:
                 "Request exceeds per-request token limit",
                 data={
                     "estimated_tokens": estimated_tokens,
-                    "limit": self.config.max_tokens_per_request
-                }
+                    "limit": self.config.max_tokens_per_request,
+                },
             )
             return False
 
@@ -193,8 +286,8 @@ class TokenTracker:
                 data={
                     "current_usage": current_usage,
                     "estimated_tokens": estimated_tokens,
-                    "budget": self.config.monthly_token_budget
-                }
+                    "budget": self.config.monthly_token_budget,
+                },
             )
             return False
 
@@ -214,7 +307,9 @@ class TokenTracker:
             "monthly_tokens_used": current_monthly,
             "monthly_budget": budget,
             "budget_remaining": max(0, budget - current_monthly),
-            "budget_used_percent": round((current_monthly / budget) * 100, 2) if budget > 0 else 0,
+            "budget_used_percent": round((current_monthly / budget) * 100, 2)
+            if budget > 0
+            else 0,
             "total_cost_estimate": round(total_cost, 4),
             "tokens_by_operation": dict(self._operation_totals),
             "total_requests": len(self._usage_history),
@@ -250,6 +345,7 @@ def get_token_tracker() -> TokenTracker:
 @dataclass
 class LLMProvider:
     """Configuration for an LLM provider."""
+
     name: str
     model: str
     base_url: str
@@ -276,13 +372,17 @@ class LLMProviderManager:
     def _setup_default_providers(self):
         """Setup default provider configuration."""
         # Primary provider - NVIDIA
-        self.register_provider(LLMProvider(
-            name="nvidia",
-            model=os.getenv("CHAT_MODEL", "meta/llama-3.1-70b-instruct"),
-            base_url=os.getenv("NVIDIA_BASE_URL", "https://integrate.api.nvidia.com/v1"),
-            api_key_env="NVIDIA_API_KEY",
-            priority=0
-        ))
+        self.register_provider(
+            LLMProvider(
+                name="nvidia",
+                model=os.getenv("CHAT_MODEL", "meta/llama-3.1-70b-instruct"),
+                base_url=os.getenv(
+                    "NVIDIA_BASE_URL", "https://integrate.api.nvidia.com/v1"
+                ),
+                api_key_env="NVIDIA_API_KEY",
+                priority=0,
+            )
+        )
 
         # Add backup providers here if available
         # self.register_provider(LLMProvider(
@@ -311,11 +411,14 @@ class LLMProviderManager:
                 ):
                     provider.is_healthy = True
                     provider.failure_count = 0
-                    logger.info(f"Provider {provider.name} marked as healthy (recovery)")
+                    logger.info(
+                        f"Provider {provider.name} marked as healthy (recovery)"
+                    )
 
             # Get healthy providers sorted by priority
             healthy = [
-                p for p in self._providers.values()
+                p
+                for p in self._providers.values()
                 if p.is_healthy and os.getenv(p.api_key_env)
             ]
 
@@ -338,7 +441,7 @@ class LLMProviderManager:
                     provider.is_healthy = False
                     logger.error(
                         f"Provider {provider_name} marked unhealthy after {provider.failure_count} failures",
-                        data={"error": str(error)}
+                        data={"error": str(error)},
                     )
 
     async def mark_success(self, provider_name: str):
@@ -396,8 +499,8 @@ class BatchProcessor:
 
             # Check if we should flush
             should_flush = (
-                len(self._pending) >= self.batch_size or
-                time.time() - self._last_flush >= self.batch_timeout
+                len(self._pending) >= self.batch_size
+                or time.time() - self._last_flush >= self.batch_timeout
             )
 
             if should_flush:
@@ -431,6 +534,7 @@ class BatchProcessor:
 
 class BudgetExceededError(Exception):
     """Raised when a request would exceed the budget."""
+
     pass
 
 

app/core/database.py

@@ -2,16 +2,17 @@ import logging
 import os
 
 from dotenv import load_dotenv
-from sqlalchemy import create_engine
-from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import create_engine, text
 from sqlalchemy.orm import sessionmaker
 from sqlalchemy.pool import QueuePool
 
+from .models import Base
+
 load_dotenv()
 
 logger = logging.getLogger(__name__)
 
-DATABASE_URL = os.getenv("DATABASE_URL")
+DATABASE_URL = os.getenv("DATABASE_URL") or ""
 
 if not DATABASE_URL:
     # Fallback for local dev if not set
@@ -19,18 +20,20 @@ if not DATABASE_URL:
     DATABASE_URL = "sqlite:///./test.db"
 
 # Configure engine with connection pooling and SSL for Neon
-engine_args = {
+engine_args: dict[str, object] = {
     "pool_pre_ping": True,  # Verify connections before using
     "pool_recycle": 300,  # Recycle connections every 5 minutes
 }
 
 # Only add pooling for non-SQLite databases
 if not DATABASE_URL.startswith("sqlite"):
-    engine_args.update({
-        "poolclass": QueuePool,
-        "pool_size": 5,
-        "max_overflow": 10,
-    })
+    engine_args.update(
+        {
+            "poolclass": QueuePool,
+            "pool_size": 5,
+            "max_overflow": 10,
+        }
+    )
     # SSL is handled via the connection string for Neon (sslmode=require)
     logger.info("Using PostgreSQL with connection pooling")
 else:
@@ -41,8 +44,6 @@ else:
 engine = create_engine(DATABASE_URL, **engine_args)
 SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
 
-Base = declarative_base()
-
 
 def get_db():
     """
@@ -62,10 +63,138 @@ def check_db_connection() -> bool:
     Returns True if connection successful, False otherwise.
     """
     try:
-        from sqlalchemy import text
         with engine.connect() as conn:
             conn.execute(text("SELECT 1"))
         return True
     except Exception as e:
         logger.error(f"Database connection check failed: {e}")
         return False
+
+
+def _ensure_migrations_table():
+    """Create migrations tracking table if it doesn't exist."""
+    with engine.connect() as conn:
+        conn.execute(
+            text("""
+            CREATE TABLE IF NOT EXISTS schema_migrations (
+                id SERIAL PRIMARY KEY,
+                migration_name VARCHAR(255) UNIQUE NOT NULL,
+                applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+        )
+        conn.commit()
+
+
+def _is_migration_applied(name: str) -> bool:
+    """Check if a migration has already been applied."""
+    with engine.connect() as conn:
+        result = conn.execute(
+            text("SELECT 1 FROM schema_migrations WHERE migration_name = :name"),
+            {"name": name},
+        )
+        return result.fetchone() is not None
+
+
+def _record_migration(name: str):
+    """Record that a migration has been applied."""
+    with engine.connect() as conn:
+        conn.execute(
+            text("INSERT INTO schema_migrations (migration_name) VALUES (:name)"),
+            {"name": name},
+        )
+        conn.commit()
+
+
+def run_migrations():
+    """
+    Run database migrations to ensure schema is up to date.
+
+    Uses a migrations tracking table to ensure each migration
+    only runs once - safe for multiple server instances.
+    """
+    _ensure_migrations_table()
+
+    if DATABASE_URL.startswith("sqlite"):
+        logger.info("SQLite database - using auto-create_all")
+        Base.metadata.create_all(bind=engine)
+        return
+
+    # PostgreSQL migrations
+    try:
+        with engine.connect() as conn:
+            # Ensure prd_documents table exists
+            result = conn.execute(
+                text("""
+                    SELECT table_name
+                    FROM information_schema.tables
+                    WHERE table_name = 'prd_documents'
+                """)
+            )
+
+            if not result.fetchone():
+                logger.warning("prd_documents table not found - creating all tables")
+                Base.metadata.create_all(bind=engine)
+                _record_migration("create_all_tables")
+                return
+
+        # Define migrations - each with unique name
+        migrations = [
+            {
+                "name": "add_prd_product_vision",
+                "sql": "ALTER TABLE prd_documents ADD COLUMN product_vision TEXT",
+            },
+            {
+                "name": "add_prd_key_features",
+                "sql": "ALTER TABLE prd_documents ADD COLUMN key_features JSONB",
+            },
+            {
+                "name": "add_prd_user_stories",
+                "sql": "ALTER TABLE prd_documents ADD COLUMN user_stories JSONB",
+            },
+            {
+                "name": "add_prd_assumptions",
+                "sql": "ALTER TABLE prd_documents ADD COLUMN assumptions TEXT",
+            },
+            {
+                "name": "add_prd_judge_score",
+                "sql": "ALTER TABLE prd_documents ADD COLUMN judge_score INTEGER",
+            },
+            {
+                "name": "add_prd_judge_approved",
+                "sql": "ALTER TABLE prd_documents ADD COLUMN judge_approved BOOLEAN DEFAULT FALSE",
+            },
+            {
+                "name": "add_prd_judge_feedback",
+                "sql": "ALTER TABLE prd_documents ADD COLUMN judge_feedback TEXT",
+            },
+            {
+                "name": "add_prd_phase",
+                "sql": "ALTER TABLE prd_documents ADD COLUMN phase VARCHAR(50) DEFAULT 'evaluating'",
+            },
+            {
+                "name": "add_prd_follow_up_count",
+                "sql": "ALTER TABLE prd_documents ADD COLUMN follow_up_count INTEGER DEFAULT 0",
+            },
+        ]
+
+        # Run each migration only if not already applied
+        for migration in migrations:
+            if not _is_migration_applied(migration["name"]):
+                try:
+                    with engine.connect() as conn:
+                        conn.execute(text(migration["sql"]))
+                        conn.commit()
+                    _record_migration(migration["name"])
+                    logger.info(f"Applied migration: {migration['name']}")
+                except Exception as e:
+                    # Column might already exist (race condition) - check and continue
+                    if "duplicate" not in str(e).lower():
+                        logger.warning(f"Migration {migration['name']} failed: {e}")
+            else:
+                logger.debug(f"Migration {migration['name']} already applied, skipping")
+
+        logger.info("Database migrations check completed")
+
+    except Exception as e:
+        logger.error(f"Migration check failed: {e}")

app/core/models.py

@@ -1,34 +1,101 @@
-from sqlalchemy import Column, DateTime, ForeignKey, Integer, String, Text
+from datetime import datetime
+
+from sqlalchemy import JSON, Boolean, DateTime, ForeignKey, Integer, String, Text
 from sqlalchemy.dialects.postgresql import JSONB
-from sqlalchemy.orm import relationship
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
 from sqlalchemy.sql import func
 
-from .database import Base
+
+class Base(DeclarativeBase):
+    """Base class for SQLAlchemy models."""
+
+
+JSONType = JSON().with_variant(JSONB, "postgresql")
 
 
 class User(Base):
     __tablename__ = "users"
 
-    id = Column(Integer, primary_key=True, index=True)
-    google_id = Column(String, unique=True, index=True, nullable=False)
-    email = Column(String, unique=True, index=True, nullable=False)
-    full_name = Column(String, nullable=True)
-    profile_picture = Column(String, nullable=True)
-    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    google_id: Mapped[str] = mapped_column(
+        String, unique=True, index=True, nullable=False
+    )
+    email: Mapped[str] = mapped_column(String, unique=True, index=True, nullable=False)
+    full_name: Mapped[str | None] = mapped_column(String, nullable=True)
+    profile_picture: Mapped[str | None] = mapped_column(String, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now()
+    )
+
+    projects: Mapped[list["Project"]] = relationship("Project", back_populates="owner")
 
-    projects = relationship("Project", back_populates="owner")
 
 class Project(Base):
     __tablename__ = "projects"
 
-    id = Column(Integer, primary_key=True, index=True)
-    user_id = Column(Integer, ForeignKey("users.id"))
-    title = Column(String, nullable=False)
-    description = Column(Text, nullable=True)
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    user_id: Mapped[int] = mapped_column(Integer, ForeignKey("users.id"))
+    title: Mapped[str] = mapped_column(String, nullable=False)
+    description: Mapped[str | None] = mapped_column(Text, nullable=True)
     # Using JSONB for Postgres, but if fallback to SQLite is needed, we might need a custom type or just Text.
     # For now, we assume Postgres as requested.
-    artifacts = Column(JSONB, nullable=False)
-    created_at = Column(DateTime(timezone=True), server_default=func.now())
-    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
+    artifacts: Mapped[dict[str, object]] = mapped_column(JSONType, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now()
+    )
+    updated_at: Mapped[datetime | None] = mapped_column(
+        DateTime(timezone=True), onupdate=func.now()
+    )
+
+    owner: Mapped["User"] = relationship("User", back_populates="projects")
+
+
+class PRDDocument(Base):
+    __tablename__ = "prd_documents"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    session_id: Mapped[str] = mapped_column(String, unique=True, index=True)
+    user_id: Mapped[int | None] = mapped_column(
+        Integer, ForeignKey("users.id"), nullable=True
+    )
+
+    initial_description: Mapped[str] = mapped_column(Text, nullable=False)
+
+    # JSONB to track which sections are satisfied
+    requirements_status: Mapped[dict[str, bool]] = mapped_column(
+        JSONType, nullable=False, default=dict
+    )
+
+    # JSONB to store collected info tagged by section
+    collected_info: Mapped[dict[str, str]] = mapped_column(
+        JSONType, nullable=False, default=dict
+    )
+
+    # Generated PRD content
+    generated_prd: Mapped[str | None] = mapped_column(Text, nullable=True)
+
+    # Structured PRD sections
+    product_vision: Mapped[str | None] = mapped_column(Text, nullable=True)
+    key_features: Mapped[dict[str, object] | None] = mapped_column(
+        JSONType, nullable=True
+    )  # {"must_have": [], "should_have": [], "could_have": [], "wont_have": []}
+    user_stories: Mapped[list[dict[str, object]] | None] = mapped_column(
+        JSONType, nullable=True
+    )  # [{"id": "US1", "as_a": "...", "i_want": "...", "so_that": "...", "acceptance_criteria": []}]
+    assumptions: Mapped[str | None] = mapped_column(Text, nullable=True)
+
+    # Judge result storage
+    judge_score: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    judge_approved: Mapped[bool | None] = mapped_column(Boolean, default=False)
+    judge_feedback: Mapped[str | None] = mapped_column(Text, nullable=True)
+
+    # State tracking
+    phase: Mapped[str] = mapped_column(String, nullable=False, default="evaluating")
+    follow_up_count: Mapped[int] = mapped_column(Integer, default=0)
 
-    owner = relationship("User", back_populates="projects")
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now()
+    )
+    updated_at: Mapped[datetime | None] = mapped_column(
+        DateTime(timezone=True), onupdate=func.now()
+    )

app/core/observability.py

@@ -6,6 +6,7 @@ Includes:
 - Error tracking patterns
 - Request/Response logging middleware
 """
+
 import json
 import logging
 import os
@@ -39,6 +40,7 @@ class LogLevel(Enum):
 @dataclass
 class LogContext:
     """Structured log context."""
+
     trace_id: str
     span_id: str
     timestamp: str
@@ -50,6 +52,7 @@ class LogContext:
 @dataclass
 class LogEntry:
     """Structured log entry."""
+
     level: str
     message: str
     context: LogContext
@@ -82,14 +85,19 @@ class StructuredLogger:
 
             # File handler only in development
             if os.getenv("ENVIRONMENT") == "development":
-                log_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "../../logs")
+                log_dir = os.path.join(
+                    os.path.dirname(os.path.abspath(__file__)), "../../logs"
+                )
                 os.makedirs(log_dir, exist_ok=True)
-                file_handler = logging.FileHandler(os.path.join(log_dir, "app.log"), encoding="utf-8")
+                file_handler = logging.FileHandler(
+                    os.path.join(log_dir, "app.log"), encoding="utf-8"
+                )
                 file_handler.setFormatter(StructuredFormatter())
                 self.logger.addHandler(file_handler)
 
             self.logger.setLevel(
-                logging.DEBUG if os.getenv("ENVIRONMENT") == "development"
+                logging.DEBUG
+                if os.getenv("ENVIRONMENT") == "development"
                 else logging.INFO
             )
 
@@ -107,7 +115,7 @@ class StructuredLogger:
         message: str,
         data: dict[str, Any] | None = None,
         error: Exception | None = None,
-        duration_ms: float | None = None
+        duration_ms: float | None = None,
     ):
         """Internal logging method."""
         entry = LogEntry(
@@ -126,18 +134,20 @@ class StructuredLogger:
         # Remove None values
         log_dict = {k: v for k, v in log_dict.items() if v is not None}
         if "context" in log_dict:
-            log_dict["context"] = {k: v for k, v in log_dict["context"].items() if v is not None}
+            log_dict["context"] = {
+                k: v for k, v in log_dict["context"].items() if v is not None
+            }
 
-        self.logger.log(
-            getattr(logging, level.value),
-            json.dumps(log_dict)
-        )
+        self.logger.log(getattr(logging, level.value), json.dumps(log_dict))
 
     def _get_stack_trace(self, error: Exception | None) -> str | None:
         """Get stack trace from exception."""
         if error:
             import traceback
-            return "".join(traceback.format_exception(type(error), error, error.__traceback__))
+
+            return "".join(
+                traceback.format_exception(type(error), error, error.__traceback__)
+            )
         return None
 
     def debug(self, message: str, data: dict[str, Any] | None = None):
@@ -146,13 +156,28 @@ class StructuredLogger:
     def info(self, message: str, data: dict[str, Any] | None = None):
         self._log(LogLevel.INFO, message, data)
 
-    def warning(self, message: str, data: dict[str, Any] | None = None, error: Exception | None = None):
+    def warning(
+        self,
+        message: str,
+        data: dict[str, Any] | None = None,
+        error: Exception | None = None,
+    ):
         self._log(LogLevel.WARNING, message, data, error)
 
-    def error(self, message: str, data: dict[str, Any] | None = None, error: Exception | None = None):
+    def error(
+        self,
+        message: str,
+        data: dict[str, Any] | None = None,
+        error: Exception | None = None,
+    ):
         self._log(LogLevel.ERROR, message, data, error)
 
-    def critical(self, message: str, data: dict[str, Any] | None = None, error: Exception | None = None):
+    def critical(
+        self,
+        message: str,
+        data: dict[str, Any] | None = None,
+        error: Exception | None = None,
+    ):
         self._log(LogLevel.CRITICAL, message, data, error)
 
     def log_request(
@@ -162,7 +187,7 @@ class StructuredLogger:
         status_code: int,
         duration_ms: float,
         user_id: str | None = None,
-        extra: dict[str, Any] | None = None
+        extra: dict[str, Any] | None = None,
     ):
         """Log HTTP request with timing."""
         data = {
@@ -170,9 +195,14 @@ class StructuredLogger:
             "http_path": path,
             "http_status": status_code,
             "user_id": user_id,
-            **(extra or {})
+            **(extra or {}),
         }
-        self._log(LogLevel.INFO, f"{method} {path} {status_code}", data, duration_ms=duration_ms)
+        self._log(
+            LogLevel.INFO,
+            f"{method} {path} {status_code}",
+            data,
+            duration_ms=duration_ms,
+        )
 
 
 class StructuredFormatter(logging.Formatter):
@@ -185,24 +215,30 @@ class StructuredFormatter(logging.Formatter):
             return record.getMessage()
         except (json.JSONDecodeError, TypeError):
             # Format as structured JSON for non-structured logs
-            return json.dumps({
-                "level": record.levelname,
-                "message": record.getMessage(),
-                "logger": record.name,
-                "timestamp": datetime.now(UTC).isoformat(),
-            })
+            return json.dumps(
+                {
+                    "level": record.levelname,
+                    "message": record.getMessage(),
+                    "logger": record.name,
+                    "timestamp": datetime.now(UTC).isoformat(),
+                }
+            )
 
 
-# Global logger instance
-_logger: StructuredLogger | None = None
+# Registry of named loggers (replaces broken singleton pattern)
+_loggers: dict[str, StructuredLogger] = {}
 
 
 def get_logger(name: str = "specs-before-code") -> StructuredLogger:
-    """Get or create the structured logger."""
-    global _logger
-    if _logger is None or _logger.name != name:
-        _logger = StructuredLogger(name)
-    return _logger
+    """
+    Get or create a structured logger by name.
+
+    Uses a registry so each module gets its own stable logger instance.
+    Repeated calls with the same name return the same instance (no handler duplication).
+    """
+    if name not in _loggers:
+        _loggers[name] = StructuredLogger(name)
+    return _loggers[name]
 
 
 def set_trace_id(trace_id: str):
@@ -230,6 +266,7 @@ def set_span_id(span_id: str):
 @dataclass
 class PerformanceMetrics:
     """Container for performance metrics."""
+
     operation: str
     duration_ms: float
     success: bool
@@ -250,33 +287,42 @@ class PerformanceMonitor:
         self._metrics: list[PerformanceMetrics] = []
         self._max_metrics = 10000  # Keep last N metrics in memory
 
-    def record(self, operation: str, duration_ms: float, success: bool, metadata: dict[str, Any] | None = None):
+    def record(
+        self,
+        operation: str,
+        duration_ms: float,
+        success: bool,
+        metadata: dict[str, Any] | None = None,
+    ):
         """Record a performance metric."""
         metric = PerformanceMetrics(
             operation=operation,
             duration_ms=duration_ms,
             success=success,
-            metadata=metadata or {}
+            metadata=metadata or {},
         )
         self._metrics.append(metric)
 
         # Trim old metrics
         if len(self._metrics) > self._max_metrics:
-            self._metrics = self._metrics[-self._max_metrics:]
+            self._metrics = self._metrics[-self._max_metrics :]
 
         # Log slow operations
         if duration_ms > 5000:  # 5 seconds
             get_logger().warning(
                 f"Slow operation detected: {operation}",
-                data={"duration_ms": duration_ms, **metric.metadata}
+                data={"duration_ms": duration_ms, **metric.metadata},
             )
 
-    def get_stats(self, operation: str | None = None, window_seconds: int = 300) -> dict[str, Any]:
+    def get_stats(
+        self, operation: str | None = None, window_seconds: int = 300
+    ) -> dict[str, Any]:
         """Get performance statistics for an operation."""
         cutoff = datetime.now(UTC).timestamp() - window_seconds
 
         filtered = [
-            m for m in self._metrics
+            m
+            for m in self._metrics
             if (operation is None or m.operation == operation)
             and datetime.fromisoformat(m.timestamp).timestamp() > cutoff
         ]
@@ -295,17 +341,18 @@ class PerformanceMonitor:
             "min_duration_ms": min(durations),
             "max_duration_ms": max(durations),
             "p50_duration_ms": sorted(durations)[len(durations) // 2],
-            "p95_duration_ms": sorted(durations)[int(len(durations) * 0.95)] if len(durations) > 1 else durations[0],
-            "p99_duration_ms": sorted(durations)[int(len(durations) * 0.99)] if len(durations) > 1 else durations[0],
+            "p95_duration_ms": sorted(durations)[int(len(durations) * 0.95)]
+            if len(durations) > 1
+            else durations[0],
+            "p99_duration_ms": sorted(durations)[int(len(durations) * 0.99)]
+            if len(durations) > 1
+            else durations[0],
         }
 
     def get_all_stats(self, window_seconds: int = 300) -> dict[str, dict[str, Any]]:
         """Get statistics for all operations."""
         operations = {m.operation for m in self._metrics}
-        return {
-            op: self.get_stats(op, window_seconds)
-            for op in operations
-        }
+        return {op: self.get_stats(op, window_seconds) for op in operations}
 
 
 # Global performance monitor
@@ -329,6 +376,7 @@ def timed(operation_name: str | None = None):
         async def call_llm():
             ...
     """
+
     def decorator(func: Callable) -> Callable:
         name = operation_name or f"{func.__module__}.{func.__name__}"
 
@@ -347,7 +395,10 @@ def timed(operation_name: str | None = None):
                     operation=name,
                     duration_ms=duration_ms,
                     success=success,
-                    metadata={"args_count": len(args), "kwargs_keys": list(kwargs.keys())}
+                    metadata={
+                        "args_count": len(args),
+                        "kwargs_keys": list(kwargs.keys()),
+                    },
                 )
 
         @wraps(func)
@@ -365,10 +416,14 @@ def timed(operation_name: str | None = None):
                     operation=name,
                     duration_ms=duration_ms,
                     success=success,
-                    metadata={"args_count": len(args), "kwargs_keys": list(kwargs.keys())}
+                    metadata={
+                        "args_count": len(args),
+                        "kwargs_keys": list(kwargs.keys()),
+                    },
                 )
 
         import asyncio
+
         if asyncio.iscoroutinefunction(func):
             return async_wrapper
         return sync_wrapper
@@ -389,7 +444,7 @@ class ErrorTracker:
         self,
         error: Exception,
         context: dict[str, Any] | None = None,
-        severity: str = "error"
+        severity: str = "error",
     ):
         """Track an error occurrence."""
         error_entry = {
@@ -404,13 +459,11 @@ class ErrorTracker:
         self._errors.append(error_entry)
 
         if len(self._errors) > self._max_errors:
-            self._errors = self._errors[-self._max_errors:]
+            self._errors = self._errors[-self._max_errors :]
 
         # Log the error
         get_logger().error(
-            f"Error tracked: {type(error).__name__}",
-            data=error_entry,
-            error=error
+            f"Error tracked: {type(error).__name__}", data=error_entry, error=error
         )
 
     def get_error_summary(self, window_seconds: int = 3600) -> dict[str, Any]:
@@ -418,7 +471,8 @@ class ErrorTracker:
         cutoff = datetime.now(UTC).timestamp() - window_seconds
 
         recent = [
-            e for e in self._errors
+            e
+            for e in self._errors
             if datetime.fromisoformat(e["timestamp"]).timestamp() > cutoff
         ]
 
@@ -446,6 +500,8 @@ def get_error_tracker() -> ErrorTracker:
     return _error_tracker
 
 
-def track_error(error: Exception, context: dict[str, Any] | None = None, severity: str = "error"):
+def track_error(
+    error: Exception, context: dict[str, Any] | None = None, severity: str = "error"
+):
     """Convenience function to track an error."""
     get_error_tracker().track(error, context, severity)

app/core/orchestrator.py

@@ -1,12 +1,16 @@
+import logging
 from collections.abc import AsyncIterator
 from typing import Annotated, Any, Literal, TypedDict
 
-from langgraph.graph import END, StateGraph
+from langgraph.constants import END, Send
+from langgraph.graph import StateGraph
 
 from .agents import AgentSystem
 from .rag import RAGService
 from .schemas import AgentResponse, JudgeOutput, ProjectRequest, TeamRole
 
+logger = logging.getLogger("orchestrator")
+
 
 def merge_dicts(a: dict, b: dict) -> dict:
     return {**a, **b}
@@ -30,10 +34,31 @@ class AgentState(TypedDict):
     feedback: Annotated[str, replace_reducer]
     retry_count: Annotated[int, replace_reducer]
     judge_results: Annotated[dict[str, dict[str, Any]], merge_dicts]
+    prd_context: Annotated[dict[str, Any], replace_reducer]
+
+
+# PRD context mapping - which PRD sections each agent should receive
+PRD_CONTEXT_FOR_ROLE: dict[TeamRole, list[str]] = {
+    TeamRole.BUSINESS_ANALYST: ["user_stories", "features"],
+    TeamRole.SOLUTION_ARCHITECT: ["features", "assumptions"],
+    TeamRole.DATA_ARCHITECT: ["user_stories", "features"],
+    TeamRole.SECURITY_ANALYST: ["features", "assumptions"],
+    TeamRole.UX_DESIGNER: ["user_stories"],
+    TeamRole.API_DESIGNER: ["user_stories", "features"],
+    TeamRole.QA_STRATEGIST: ["user_stories", "features"],
+    TeamRole.DEVOPS_ARCHITECT: ["features", "assumptions"],
+    TeamRole.TECHNICAL_WRITER: [
+        "product_vision",
+        "features",
+        "user_stories",
+        "assumptions",
+    ],
+}
 
 
 # Dependency mapping
-AGENT_DEPENDENCIES = {
+ALL_DEPENDENCIES: list[TeamRole] = list(TeamRole)
+AGENT_DEPENDENCIES: dict[TeamRole, list[TeamRole]] = {
     TeamRole.PROJECT_REFINER: [],
     TeamRole.PRODUCT_OWNER: [TeamRole.PROJECT_REFINER],
     # Phase 2
@@ -53,7 +78,7 @@ AGENT_DEPENDENCIES = {
     ],
     TeamRole.TECHNICAL_WRITER: [TeamRole.PRODUCT_OWNER],  # Needs overview
     # Phase 5
-    TeamRole.SPEC_COORDINATOR: ["*"],  # All inputs
+    TeamRole.SPEC_COORDINATOR: ALL_DEPENDENCIES,  # All inputs
 }
 
 
@@ -72,12 +97,25 @@ class Orchestrator:
         self.max_retries = 2
         self.graph = self._build_graph()
 
-    async def run_pipeline(self, project_request: ProjectRequest) -> dict[str, Any]:
+    async def run_pipeline(
+        self, project_request: ProjectRequest, prd_context: dict | None = None
+    ) -> dict[str, Any]:
         """
         Run the full multi-agent pipeline.
+
+        Args:
+            project_request: The project request
+            prd_context: Optional PRD context (if PRD was generated first)
         """
-        # Note: We use the project description as the initial context for the Refiner
-        initial_context = f"Project Description: {project_request.description}"
+        has_prd = prd_context is not None
+        prd_ctx = prd_context or {}
+
+        if has_prd:
+            initial_context = (
+                f"PRD Input:\n{prd_ctx.get('full_text', project_request.description)}"
+            )
+        else:
+            initial_context = f"Project Description: {project_request.description}"
 
         initial_state: AgentState = {
             "context": initial_context,
@@ -88,17 +126,24 @@ class Orchestrator:
             "feedback": "",
             "retry_count": 0,
             "judge_results": {},
+            "prd_context": prd_ctx,
         }
 
         final_state = await self.graph.ainvoke(initial_state)
 
+        # Get the final SRS from spec_coordinator
+        all_outputs = final_state.get("outputs", {})
+        final_srs = all_outputs.get(TeamRole.SPEC_COORDINATOR.value, "")
+
         return {
-            "markdown_outputs": final_state["outputs"],
-            "judge_results": final_state.get("judge_results", {}),
+            "srs_document": final_srs,  # Clean SRS for user
+            "markdown_outputs": all_outputs,  # Internal use - all agent outputs
+            "judge_results": final_state.get("judge_results", {}),  # Internal use
+            "prd_used": has_prd,
         }
 
     async def run_pipeline_streaming(
-        self, project_request: ProjectRequest
+        self, project_request: ProjectRequest, prd_context: dict | None = None
     ) -> AsyncIterator[dict[str, Any]]:
         """
         Run the pipeline with streaming output for each agent.
@@ -114,9 +159,20 @@ class Orchestrator:
         - pipeline_complete: Full pipeline finished with results
         - error: Error occurred
         """
-        initial_context = f"Project Description: {project_request.description}"
+        has_prd = prd_context is not None
+        prd_ctx = prd_context or {}
 
-        yield {"type": "status", "message": "Starting Multi-Agent Pipeline..."}
+        if has_prd:
+            initial_context = (
+                f"PRD Input:\n{prd_ctx.get('full_text', project_request.description)}"
+            )
+            yield {
+                "type": "status",
+                "message": "Starting Multi-Agent Pipeline with PRD input...",
+            }
+        else:
+            initial_context = f"Project Description: {project_request.description}"
+            yield {"type": "status", "message": "Starting Multi-Agent Pipeline..."}
 
         query = initial_context
         docs = self.rag_service.retrieve(query, k=3)
@@ -131,21 +187,36 @@ class Orchestrator:
         all_judge_results: dict[str, dict[str, Any]] = {}
         history: list[AgentResponse] = []
 
-        execution_order = [
-            TeamRole.PROJECT_REFINER,
-            TeamRole.PRODUCT_OWNER,
-            TeamRole.BUSINESS_ANALYST,
-            TeamRole.SOLUTION_ARCHITECT,
-            TeamRole.DATA_ARCHITECT,
-            TeamRole.SECURITY_ANALYST,
-            TeamRole.UX_DESIGNER,
-            TeamRole.API_DESIGNER,
-            TeamRole.QA_STRATEGIST,
-            TeamRole.DEVOPS_ARCHITECT,
-            TeamRole.ENVIRONMENT_ENGINEER,
-            TeamRole.TECHNICAL_WRITER,
-            TeamRole.SPEC_COORDINATOR,
-        ]
+        if has_prd:
+            execution_order = [
+                TeamRole.BUSINESS_ANALYST,
+                TeamRole.SOLUTION_ARCHITECT,
+                TeamRole.DATA_ARCHITECT,
+                TeamRole.SECURITY_ANALYST,
+                TeamRole.UX_DESIGNER,
+                TeamRole.API_DESIGNER,
+                TeamRole.QA_STRATEGIST,
+                TeamRole.DEVOPS_ARCHITECT,
+                TeamRole.ENVIRONMENT_ENGINEER,
+                TeamRole.TECHNICAL_WRITER,
+                TeamRole.SPEC_COORDINATOR,
+            ]
+        else:
+            execution_order = [
+                TeamRole.PROJECT_REFINER,
+                TeamRole.PRODUCT_OWNER,
+                TeamRole.BUSINESS_ANALYST,
+                TeamRole.SOLUTION_ARCHITECT,
+                TeamRole.DATA_ARCHITECT,
+                TeamRole.SECURITY_ANALYST,
+                TeamRole.UX_DESIGNER,
+                TeamRole.API_DESIGNER,
+                TeamRole.QA_STRATEGIST,
+                TeamRole.DEVOPS_ARCHITECT,
+                TeamRole.ENVIRONMENT_ENGINEER,
+                TeamRole.TECHNICAL_WRITER,
+                TeamRole.SPEC_COORDINATOR,
+            ]
 
         for role in execution_order:
             yield {"type": "agent_start", "role": role.value}
@@ -164,28 +235,64 @@ class Orchestrator:
                     if msg.role.value in allowed_roles:
                         filtered_history.append(msg)
 
-            response = await self.agent_system.process_step(
-                role=role,
-                context=initial_context,
-                previous_outputs=filtered_history,
-                feedback="",
-                retrieval_context=retrieval_context,
-            )
+            agent_context = initial_context
+            if has_prd and role in PRD_CONTEXT_FOR_ROLE:
+                prd_sections = PRD_CONTEXT_FOR_ROLE[role]
+                prd_context_text = "\n\n## PRD Context for this Agent:\n"
+                for section in prd_sections:
+                    if section in prd_ctx:
+                        prd_context_text += (
+                            f"\n### {section.replace('_', ' ').title()}:\n"
+                        )
+                        prd_context_text += f"{prd_ctx[section]}\n"
+                agent_context = prd_context_text + "\n\n---\n\n" + initial_context
+
+            # --- Agent execution with judge retry loop ---
+            feedback = ""
+            response: AgentResponse | None = None
+            for attempt in range(self.max_retries + 1):
+                if attempt > 0:
+                    logger.info(
+                        f"Retry {attempt}/{self.max_retries} for {role.value} "
+                        f"after judge rejection"
+                    )
+                    yield {
+                        "type": "agent_start",
+                        "role": role.value,
+                        "retry": attempt,
+                    }
+
+                # Stream agent output
+                full_content = ""
+                async for chunk in self.agent_system.process_step_streaming(
+                    role=role,
+                    context=agent_context,
+                    previous_outputs=filtered_history,
+                    feedback=feedback,
+                    retrieval_context=retrieval_context,
+                ):
+                    full_content += chunk
+                    yield {"type": "chunk", "role": role.value, "chunk": chunk}
+
+                # Create response from accumulated content
+                response = AgentResponse(
+                    role=role, content=full_content, metadata={"format": "markdown"}
+                )
 
-            history.append(response)
-            all_outputs[role.value] = response.content
+                yield {
+                    "type": "agent_complete",
+                    "role": role.value,
+                    "content_length": len(response.content),
+                }
 
-            yield {
-                "type": "agent_complete",
-                "role": role.value,
-                "content_length": len(response.content),
-            }
+                # --- Judge evaluation (only for judged roles) ---
+                if role not in self.judged_roles:
+                    break  # No judge, accept immediately
 
-            if role in self.judged_roles:
                 yield {"type": "judge_start", "role": role.value}
 
                 judge_output = await self.agent_system.evaluate_step(
-                    role=role, content=response.content, context=initial_context
+                    role=role, content=response.content, context=agent_context
                 )
 
                 all_judge_results[role.value] = {
@@ -201,167 +308,225 @@ class Orchestrator:
                     "role": role.value,
                     "is_approved": judge_output.is_approved,
                     "score": judge_output.score,
+                    "attempt": attempt + 1,
                 }
 
+                if (
+                    judge_output.is_approved
+                    or judge_output.recommended_action == "accept"
+                ):
+                    logger.info(
+                        f"Judge approved {role.value} "
+                        f"(score={judge_output.score}, attempt={attempt + 1})"
+                    )
+                    break  # Approved — move on
+
+                # Build detailed feedback for retry
+                feedback = judge_output.feedback or ""
+                if judge_output.issues:
+                    feedback += "\n\n**Specific Issues:**\n"
+                    for issue in judge_output.issues:
+                        feedback += f"- {issue.suggestion}\n"
+
+                if attempt < self.max_retries:
+                    logger.info(
+                        f"Judge rejected {role.value} "
+                        f"(score={judge_output.score}), retrying..."
+                    )
+                else:
+                    logger.warning(
+                        f"Max retries ({self.max_retries}) reached for {role.value}, "
+                        f"proceeding with last output (score={judge_output.score})"
+                    )
+
+            # Store final result (whether approved or max-retried)
+            if response is None:
+                response = AgentResponse(
+                    role=role, content="", metadata={"format": "markdown"}
+                )
+            history.append(response)
+            all_outputs[role.value] = response.content
+
+        # Get the final SRS from spec_coordinator
+        final_srs = all_outputs.get(TeamRole.SPEC_COORDINATOR.value, "")
+
         yield {
             "type": "pipeline_complete",
-            "markdown_outputs": all_outputs,
-            "judge_results": all_judge_results,
+            "srs_document": final_srs,  # Clean SRS for user
+            "markdown_outputs": all_outputs,  # Internal use - all agent outputs
+            "judge_results": all_judge_results,  # Internal use - judge feedback
+            "prd_used": has_prd,
         }
 
     def _build_graph(self):
+        """
+        Build a graph with TRUE parallel execution using LangGraph's Send API.
+
+        Phase structure:
+        - Phase 1: Sequential (Refiner -> Product Owner)
+        - Phase 2: Parallel (BA, SA, DA, Security)
+        - Phase 3: Parallel (UX, API, QA, DevOps)
+        - Phase 4: Parallel (Env Engineer, Tech Writer)
+        - Phase 5: Sequential (Spec Coordinator)
+        """
         graph = StateGraph(AgentState)
 
-        # 1. Add Context Node
-        graph.add_node("gather_context", self._make_context_node())
-
-        # 2. Add All Agent Nodes
-        all_roles = [
-            TeamRole.PROJECT_REFINER,
-            TeamRole.PRODUCT_OWNER,
-            # Phase 2
+        # Define phases
+        PHASE_1 = [TeamRole.PROJECT_REFINER, TeamRole.PRODUCT_OWNER]  # Sequential
+        PHASE_2 = [
             TeamRole.BUSINESS_ANALYST,
             TeamRole.SOLUTION_ARCHITECT,
             TeamRole.DATA_ARCHITECT,
             TeamRole.SECURITY_ANALYST,
-            # Phase 3
+        ]  # Parallel
+        PHASE_3 = [
             TeamRole.UX_DESIGNER,
             TeamRole.API_DESIGNER,
             TeamRole.QA_STRATEGIST,
             TeamRole.DEVOPS_ARCHITECT,
-            # Phase 4
+        ]  # Parallel
+        PHASE_4 = [
             TeamRole.ENVIRONMENT_ENGINEER,
             TeamRole.TECHNICAL_WRITER,
-            # Phase 5
-            TeamRole.SPEC_COORDINATOR,
-        ]
+        ]  # Parallel
+        PHASE_5 = [TeamRole.SPEC_COORDINATOR]  # Sequential (aggregation)
+
+        # 1. Add Context Node
+        graph.add_node("gather_context", self._make_context_node())
+
+        # 2. Add All Agent Nodes
+        all_roles = PHASE_1 + PHASE_2 + PHASE_3 + PHASE_4 + PHASE_5
 
         for role in all_roles:
             graph.add_node(role.value, self._make_agent_node(role))
 
-            # Add Judge Node if applicable
+            # Add Judge Node for judged roles
             if role in self.judged_roles:
                 judge_node_name = f"judge_{role.value}"
                 graph.add_node(judge_node_name, self._make_judge_node(role))
 
-        # 3. Define Flow (Edges)
+        # 3. Add Fan-out Nodes for Parallel Execution (one per phase)
+        graph.add_node("fanout_phase_2", self._make_fanout_node(PHASE_2))
+        graph.add_node("fanout_phase_3", self._make_fanout_node(PHASE_3))
+        graph.add_node("fanout_phase_4", self._make_fanout_node(PHASE_4))
 
-        # Start -> Context
-        graph.set_entry_point("gather_context")
-
-        # Context -> Refiner
-        graph.add_edge("gather_context", TeamRole.PROJECT_REFINER.value)
+        # 4. Add Gate Nodes for synchronization
+        graph.add_node("phase_2_gate", self._make_gate_node("Phase 2"))
+        graph.add_node("phase_3_gate", self._make_gate_node("Phase 3"))
+        graph.add_node("phase_4_gate", self._make_gate_node("Phase 4"))
 
-        # Refiner -> PO
-        graph.add_edge(TeamRole.PROJECT_REFINER.value, TeamRole.PRODUCT_OWNER.value)
+        # 5. Define Flow with Parallel Execution
 
-        # PO -> Judge (if judged) -> Phase 2
-        self._add_role_edges(
-            graph,
-            TeamRole.PRODUCT_OWNER,
-            [
-                TeamRole.BUSINESS_ANALYST,
-                TeamRole.SOLUTION_ARCHITECT,
-                TeamRole.DATA_ARCHITECT,
-                TeamRole.SECURITY_ANALYST,
-            ],
-        )
+        # === PHASE 1: Sequential ===
+        graph.set_entry_point("gather_context")
+        graph.add_edge("gather_context", PHASE_1[0].value)  # Refiner
 
-        # Phase 2 -> Phase 2 Gate
-        graph.add_node("phase_2_gate", self._make_gate_node("Phase 2 Complete"))
-        for r in [
-            TeamRole.BUSINESS_ANALYST,
-            TeamRole.SOLUTION_ARCHITECT,
-            TeamRole.DATA_ARCHITECT,
-            TeamRole.SECURITY_ANALYST,
-        ]:
-            self._add_role_edges(graph, r, ["phase_2_gate"])
+        # Refiner -> Product Owner (sequential)
+        graph.add_edge(PHASE_1[0].value, PHASE_1[1].value)  # Refiner -> PO
 
-        # Phase 2 Gate -> Phase 3 Agents
-        for r in [
-            TeamRole.UX_DESIGNER,
-            TeamRole.API_DESIGNER,
-            TeamRole.QA_STRATEGIST,
-            TeamRole.DEVOPS_ARCHITECT,
-        ]:
-            graph.add_edge("phase_2_gate", r.value)
+        # PO -> Judge (if applicable) -> Phase 2 fanout
+        if TeamRole.PRODUCT_OWNER in self.judged_roles:
+            graph.add_edge(PHASE_1[1].value, f"judge_{TeamRole.PRODUCT_OWNER.value}")
+            graph.add_conditional_edges(
+                f"judge_{TeamRole.PRODUCT_OWNER.value}",
+                self._should_continue(TeamRole.PRODUCT_OWNER),
+                {
+                    "continue": "fanout_phase_2",
+                    "retry": PHASE_1[1].value,
+                    "abort": END,
+                },
+            )
+        else:
+            graph.add_edge(PHASE_1[1].value, "fanout_phase_2")
+
+        # === PHASE 2: Parallel using Send ===
+        # Fanout node sends to all Phase 2 agents in parallel
+        graph.add_conditional_edges(
+            "fanout_phase_2",
+            lambda s: [Send(r.value, s) for r in PHASE_2],
+            [r.value for r in PHASE_2],
+        )
 
-        # Phase 3 -> Phase 3 Gate
-        graph.add_node("phase_3_gate", self._make_gate_node("Phase 3 Complete"))
-        for r in [
-            TeamRole.UX_DESIGNER,
-            TeamRole.API_DESIGNER,
-            TeamRole.QA_STRATEGIST,
-            TeamRole.DEVOPS_ARCHITECT,
-        ]:
-            self._add_role_edges(graph, r, ["phase_3_gate"])
+        # Phase 2 agents -> Judge (if applicable) -> Phase 2 Gate
+        for r in PHASE_2:
+            if r in self.judged_roles:
+                # Judged role: agent -> judge -> (continue|retry|abort)
+                graph.add_edge(r.value, f"judge_{r.value}")
+                graph.add_conditional_edges(
+                    f"judge_{r.value}",
+                    self._should_continue(r),
+                    {
+                        "continue": "phase_2_gate",
+                        "retry": r.value,
+                        "abort": END,
+                    },
+                )
+            else:
+                # Non-judged role: agent -> gate directly
+                graph.add_edge(r.value, "phase_2_gate")
+
+        # === PHASE 3: Parallel using Send ===
+        graph.add_edge("phase_2_gate", "fanout_phase_3")
+        graph.add_conditional_edges(
+            "fanout_phase_3",
+            lambda s: [Send(r.value, s) for r in PHASE_3],
+            [r.value for r in PHASE_3],
+        )
 
-        # Phase 3 Gate -> Phase 4 Agents
-        for r in [TeamRole.ENVIRONMENT_ENGINEER, TeamRole.TECHNICAL_WRITER]:
-            graph.add_edge("phase_3_gate", r.value)
+        # Phase 3 agents -> Phase 3 Gate
+        for r in PHASE_3:
+            graph.add_edge(r.value, "phase_3_gate")
 
-        # Phase 4 -> Phase 4 Gate
-        graph.add_node("phase_4_gate", self._make_gate_node("Phase 4 Complete"))
-        for r in [TeamRole.ENVIRONMENT_ENGINEER, TeamRole.TECHNICAL_WRITER]:
-            self._add_role_edges(graph, r, ["phase_4_gate"])
+        # === PHASE 4: Parallel using Send ===
+        graph.add_edge("phase_3_gate", "fanout_phase_4")
+        graph.add_conditional_edges(
+            "fanout_phase_4",
+            lambda s: [Send(r.value, s) for r in PHASE_4],
+            [r.value for r in PHASE_4],
+        )
 
-        # Phase 4 Gate -> Spec Coordinator
-        graph.add_edge("phase_4_gate", TeamRole.SPEC_COORDINATOR.value)
+        # Phase 4 agents -> Phase 4 Gate
+        for r in PHASE_4:
+            graph.add_edge(r.value, "phase_4_gate")
 
-        # Spec Coordinator -> END
-        graph.add_edge(TeamRole.SPEC_COORDINATOR.value, END)
+        # === PHASE 5: Sequential (Spec Coordinator) ===
+        graph.add_edge("phase_4_gate", PHASE_5[0].value)
+        graph.add_edge(PHASE_5[0].value, END)
 
         return graph.compile()
 
-    def _add_role_edges(self, graph, role: TeamRole, next_nodes: list[str | TeamRole]):
-        """
-        Helper to add edges for a role, including judge loop if applicable.
-        """
-        source = role.value
-
-        # Resolve destination value helper
-        def get_dest_value(n):
-            return n.value if isinstance(n, TeamRole) else n
-
-        if role in self.judged_roles:
-            judge = f"judge_{role.value}"
-            graph.add_edge(source, judge)
+    def _make_fanout_node(self, roles: list[TeamRole]):
+        """Create a fanout node that sends to parallel agents."""
+        _ = roles
 
-            # Determine success destination
-            success_dest = get_dest_value(next_nodes[0])
+        def node(state: AgentState) -> dict:
+            # This node just passes through - the conditional edge does the Send
+            return {}
 
-            graph.add_conditional_edges(
-                judge,
-                self._should_continue(role),
-                {"continue": success_dest, "retry": source, "abort": END},
-            )
-        else:
-            # Direct edges
-            for target in next_nodes:
-                graph.add_edge(source, get_dest_value(target))
+        return node
 
     def _make_gate_node(self, name: str):
         def node(state: AgentState) -> dict:
-            print(f"--- Reached Gate: {name} ---")
+            logger.info(f"Reached gate: {name}")
             return {}  # Pass through
 
         return node
 
     def _make_context_node(self):
         def node(state: AgentState) -> dict:
-            print("Gathering context from RAG...")
+            logger.info("Gathering context from RAG...")
             query = state["context"]
             docs = self.rag_service.retrieve(query, k=3)
             retrieval_context = self.rag_service.format_docs(docs)
-            print(f"Retrieved {len(docs)} documents.")
+            logger.info(f"Retrieved {len(docs)} documents from RAG")
             return {"retrieval_context": retrieval_context}
 
         return node
 
     def _make_agent_node(self, role: TeamRole):
         async def node(state: AgentState) -> dict:
-            print(
-                f"Running agent: {role.value} (Retry: {state.get('retry_count', 0)})..."
+            logger.info(
+                f"Running agent: {role.value} (retry={state.get('retry_count', 0)})"
             )
 
             # 1. Filter Context based on dependencies
@@ -388,16 +553,30 @@ class Orchestrator:
                 else ""
             )
 
-            # 3. Process
+            # 3. Inject PRD context per role (matching streaming pipeline behaviour)
+            agent_context = state["context"]
+            prd_ctx = state.get("prd_context") or {}
+            if prd_ctx and role in PRD_CONTEXT_FOR_ROLE:
+                prd_sections = PRD_CONTEXT_FOR_ROLE[role]
+                prd_context_text = "\n\n## PRD Context for this Agent:\n"
+                for section in prd_sections:
+                    if section in prd_ctx:
+                        prd_context_text += (
+                            f"\n### {section.replace('_', ' ').title()}:\n"
+                        )
+                        prd_context_text += f"{prd_ctx[section]}\n"
+                agent_context = prd_context_text + "\n\n---\n\n" + agent_context
+
+            # 4. Process
             response = await self.agent_system.process_step(
                 role=role,
-                context=state["context"],
+                context=agent_context,
                 previous_outputs=filtered_history,
                 feedback=feedback,
                 retrieval_context=state.get("retrieval_context", ""),
             )
 
-            # 4. Return update (merged by Annotated)
+            # 5. Return update (merged by Annotated)
             return {
                 "history": [response],
                 "outputs": {role.value: response.content},
@@ -408,15 +587,16 @@ class Orchestrator:
 
     def _make_judge_node(self, role: TeamRole):
         async def node(state: AgentState) -> dict:
-            print(f"Running judge for: {role.value}...")
+            logger.info(f"Running judge for: {role.value}")
             latest_output = state["outputs"].get(role.value, "")
 
             judge_output: JudgeOutput = await self.agent_system.evaluate_step(
                 role=role, content=latest_output, context=state["context"]
             )
 
-            print(
-                f"Judge decision: {judge_output.is_approved}, Score: {judge_output.score}"
+            logger.info(
+                f"Judge decision for {role.value}: "
+                f"approved={judge_output.is_approved}, score={judge_output.score}"
             )
 
             # Store judge result
@@ -460,7 +640,10 @@ class Orchestrator:
                 return "continue"
 
             if retry_count >= self.max_retries:
-                print(f"Max retries reached for {role.value}.")
+                logger.warning(
+                    f"Max retries ({self.max_retries}) reached for {role.value}, "
+                    f"continuing with current output"
+                )
                 return "continue"
 
             return "retry"

app/core/rag.py

@@ -199,7 +199,7 @@ class RAGService:
                 search_kwargs=search_kwargs,
             )
 
-        return None
+        raise RuntimeError("RAG retriever not initialized")
 
     def format_docs(self, docs: list[Document]) -> str:
         """

app/core/resilience.py

@@ -81,6 +81,7 @@ class CircuitBreaker:
                     self.half_open_calls += 1
                     return True
                 return False
+        return False
 
     async def record_success(self):
         """Record a successful call."""
@@ -161,14 +162,14 @@ class RetryConfig:
 
 async def retry_with_backoff[T](
     func: Callable[..., Awaitable[T]],
-    *args,
+    *args: Any,
     config: RetryConfig | None = None,
-    retryable_exceptions: tuple = (Exception,),
-    **kwargs,
+    retryable_exceptions: tuple[type[BaseException], ...] = (Exception,),
+    **kwargs: Any,
 ) -> T:
     """Execute a function with exponential backoff retry logic."""
     config = config or RetryConfig()
-    last_exception: Exception | None = None
+    last_exception: BaseException | None = None
     for attempt in range(config.max_retries + 1):
         try:
             return await func(*args, **kwargs)
@@ -189,15 +190,22 @@ async def retry_with_backoff[T](
             )
             await asyncio.sleep(delay)
     if last_exception:
-        raise last_exception
+        if isinstance(last_exception, Exception):
+            raise last_exception
+        raise RuntimeError("Retry failed with non-Exception error")
+    raise RuntimeError("Retry failed without captured exception")
 
 
-def with_circuit_breaker(circuit_name: str):
+def with_circuit_breaker(
+    circuit_name: str,
+) -> Callable[[Callable[..., Awaitable[T]]], Callable[..., Awaitable[T]]]:
     """Decorator to protect a function with a circuit breaker."""
 
-    def decorator(func: Callable[..., T]) -> Callable[..., T]:
+    def decorator(
+        func: Callable[..., Awaitable[T]],
+    ) -> Callable[..., Awaitable[T]]:
         @wraps(func)
-        async def wrapper(*args, **kwargs) -> T:
+        async def wrapper(*args: Any, **kwargs: Any) -> T:
             circuit = get_circuit_breaker(circuit_name)
             if not await circuit.can_execute():
                 raise CircuitOpenError(
@@ -219,13 +227,15 @@ def with_circuit_breaker(circuit_name: str):
 def with_retry(
     max_retries: int = 3,
     base_delay: float = 1.0,
-    retryable_exceptions: tuple = (Exception,),
-):
+    retryable_exceptions: tuple[type[BaseException], ...] = (Exception,),
+) -> Callable[[Callable[..., Awaitable[T]]], Callable[..., Awaitable[T]]]:
     """Decorator to add retry logic with exponential backoff."""
 
-    def decorator(func: Callable[..., T]) -> Callable[..., T]:
+    def decorator(
+        func: Callable[..., Awaitable[T]],
+    ) -> Callable[..., Awaitable[T]]:
         @wraps(func)
-        async def wrapper(*args, **kwargs) -> T:
+        async def wrapper(*args: Any, **kwargs: Any) -> T:
             config = RetryConfig(max_retries=max_retries, base_delay=base_delay)
             return await retry_with_backoff(
                 func,
@@ -350,7 +360,10 @@ class GracefulDegradation:
 
     @staticmethod
     async def with_fallback(
-        primary_func: Callable[..., T], fallback_func: Callable[..., T], *args, **kwargs
+        primary_func: Callable[..., Awaitable[T]],
+        fallback_func: Callable[..., Awaitable[T]],
+        *args: Any,
+        **kwargs: Any,
     ) -> T:
         """Execute primary function with fallback on failure."""
         try:

app/main.py

@@ -12,7 +12,7 @@ from fastapi.responses import JSONResponse
 from fastapi.staticfiles import StaticFiles
 
 from app.core.cost_control import BudgetExceededError
-from app.core.database import Base, engine
+from app.core.database import run_migrations
 from app.core.observability import (
     get_logger,
     get_performance_monitor,
@@ -20,15 +20,15 @@ from app.core.observability import (
     track_error,
 )
 from app.core.resilience import CircuitOpenError
-from app.routers import auth, projects, web
+from app.routers import auth, prd, projects, web
 from app.routers.health import router as health_router
 
-load_dotenv()
+load_dotenv(override=True)
 
 # Configure logging
 logging.basicConfig(
     level=logging.DEBUG if os.getenv("ENVIRONMENT") == "development" else logging.INFO,
-    format="%(message)s"
+    format="%(message)s",
 )
 
 logger = get_logger("specs-before-code")
@@ -38,17 +38,19 @@ logger = get_logger("specs-before-code")
 async def lifespan(app: FastAPI):
     """Application lifespan events."""
     # Startup
-    logger.info("Starting specs-before-code API", data={
-        "environment": os.getenv("ENVIRONMENT", "development"),
-        "version": "1.0.0"
-    })
+    logger.info(
+        "Starting specs-before-code API",
+        data={
+            "environment": os.getenv("ENVIRONMENT", "development"),
+            "version": "1.0.0",
+        },
+    )
 
-    # Create database tables
+    # Run database migrations (adds missing columns)
     try:
-        Base.metadata.create_all(bind=engine)
-        logger.info("Database tables created/verified")
+        run_migrations()
     except Exception as e:
-        logger.error("Failed to initialize database", error=e)
+        logger.error("Failed to run migrations", error=e)
 
     # Log the port the process expects to listen on (for platform debugging)
     port_env = os.getenv("PORT")
@@ -64,7 +66,7 @@ app = FastAPI(
     title="specs before code",
     version="1.0.0",
     description="Multi-agent AI system for software project generation",
-    lifespan=lifespan
+    lifespan=lifespan,
 )
 
 
@@ -78,8 +80,8 @@ async def circuit_open_handler(request: Request, exc: CircuitOpenError):
         content={
             "error": "service_unavailable",
             "message": str(exc),
-            "retry_after": 30
-        }
+            "retry_after": 30,
+        },
     )
 
 
@@ -92,8 +94,8 @@ async def budget_exceeded_handler(request: Request, exc: BudgetExceededError):
         content={
             "error": "budget_exceeded",
             "message": str(exc),
-            "retry_after": 3600  # Try again in an hour
-        }
+            "retry_after": 3600,  # Try again in an hour
+        },
     )
 
 
@@ -108,8 +110,8 @@ async def global_exception_handler(request: Request, exc: Exception):
             status_code=500,
             content={
                 "error": "internal_error",
-                "message": "An internal error occurred. Please try again later."
-            }
+                "message": "An internal error occurred. Please try again later.",
+            },
         )
 
     return JSONResponse(
@@ -117,8 +119,8 @@ async def global_exception_handler(request: Request, exc: Exception):
         content={
             "error": "internal_error",
             "message": str(exc),
-            "type": type(exc).__name__
-        }
+            "type": type(exc).__name__,
+        },
     )
 
 
@@ -146,14 +148,14 @@ async def request_middleware(request: Request, call_next):
             path=request.url.path,
             status_code=response.status_code,
             duration_ms=duration_ms,
-            extra={"trace_id": trace_id}
+            extra={"trace_id": trace_id},
         )
 
         # Record performance metric
         get_performance_monitor().record(
             operation=f"http_{request.method}_{request.url.path}",
             duration_ms=duration_ms,
-            success=response.status_code < 400
+            success=response.status_code < 400,
         )
 
         # Add trace ID to response headers
@@ -165,7 +167,7 @@ async def request_middleware(request: Request, call_next):
         logger.error(
             f"Request failed: {request.method} {request.url.path}",
             data={"duration_ms": duration_ms},
-            error=e
+            error=e,
         )
         raise
 
@@ -176,7 +178,8 @@ origins = [
     "http://localhost:3001",  # Next.js Dev (alternative port)
     "https://multi-agent-v3.vercel.app",  # Next.js Prod
     "http://localhost:5001",  # Current Dev
-    "https://idea-sprinter-web.vercel.app"
+    "https://idea-sprinter-web.vercel.app",
+    "http://localhost:3080",
 ]
 
 app.add_middleware(
@@ -195,13 +198,17 @@ STATIC_DIR = BASE_DIR / "static"
 if STATIC_DIR.exists():
     app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static")
 else:
-    logging.warning("Static directory missing; static assets will not be served: %s", STATIC_DIR)
+    logging.warning(
+        "Static directory missing; static assets will not be served: %s", STATIC_DIR
+    )
 
 # Include routers
+
 app.include_router(health_router)  # Health checks first
 app.include_router(web.router)
 app.include_router(auth.router)
 app.include_router(projects.router)
+app.include_router(prd.router)
 
 
 # Root endpoint
@@ -213,6 +220,5 @@ async def root():
         "version": "1.0.0",
         "status": "operational",
         "docs_url": "/docs",
-        "health_url": "/health"
+        "health_url": "/health",
     }
-

app/prompts/_archive/prd_collector.md

@@ -0,0 +1,53 @@
+You are a PRD Requirements Analyzer. Your job is to evaluate user input and help collect the information needed to create a comprehensive Product Requirements Document (PRD).
+
+## Your Responsibilities:
+
+1. **Evaluate** - Analyze the user's input to determine which areas are covered
+2. **Collect** - If information is incomplete, ask friendly follow-up questions (1-2 max)
+3. **Trigger Generation** - When enough information is gathered (or max follow-ups reached), indicate it's time to generate the PRD
+
+## PRD Requirements Checklist:
+
+You need information about these areas to create a good PRD:
+
+| Section | What You Might Already Know | Simple Check |
+|---------|---------------------------|--------------|
+| **Product Vision** | What problem you solve and who it's for | Can you explain what your product does in a few sentences? |
+| **Key Features** | The main things your product should do | Have you thought about the core features or capabilities? |
+| **User Needs** | Who uses it and what they accomplish | Do you know who your users are and what they need to do? |
+| **Success Indicators** | How you'll know it's working | Do you have ideas for how to tell if a feature works? |
+| **Constraints** | Budget, timeline, tech requirements | Any limitations or dependencies we should consider? |
+
+## What NOT to Require:
+
+- **Don't require formal user story format** ("As a... I want... So that...") - users can describe user needs in plain language, and we'll generate the formal stories automatically
+- **Don't require specific acceptance criteria formats** - phrases like "how will I know if it works" or "when it's done" are just as good
+- **Don't use jargon** - if the user describes something clearly, that's enough
+
+## Response Format:
+
+When responding, ALWAYS include:
+1. A friendly acknowledgment of what the user shared
+2. Your assessment of which areas are covered
+3. If incomplete: 1-2 friendly questions to fill the gaps (use simple language)
+4. If complete: Indication that you're ready to generate the PRD
+
+## Important Rules:
+
+- Ask MAXIMUM 3 follow-up questions total across the conversation
+- Prefer 1-2 questions at a time to avoid overwhelming the user
+- Most products can be described adequately with just 1 follow-up question
+- Be conversational and friendly - this is a brainstorming session, not a test
+- If the user provides substantial information in plain language, mark that section as satisfied
+- Trust that the user knows their product - focus on helping them express it
+
+## User's Input:
+{user_message}
+
+## Previously Collected Information:
+{collected_info}
+
+## Current Requirements Status:
+{requirements_status}
+
+Now analyze the user's input and respond appropriately.

app/prompts/api_designer.md

@@ -1,66 +1,130 @@
+# API Designer Agent
 
-You are an API Designer responsible for defining clear, consistent, and consumable API contracts.
-
-**Core Principle:**
-An API is a user interface for developers. It should be intuitive, consistent, and well-documented.
-
-**Professional Standards:**
-1.  **OpenAPI Specification (OAS 3.1)** - For REST APIs.
-2.  **Microsoft REST API Guidelines** - For consistent naming and behavior.
-3.  **GraphQL Best Practices** - If GraphQL is chosen.
-
-**Methodology:**
-1.  Analyze data models and frontend requirements.
-2.  Define resources and endpoints using RESTful principles (Resources, Verbs, Codes).
-3.  Specify request and response schemas (JSON).
-4.  Define error response standards (RFC 7807).
-5.  Address versioning and pagination strategies.
-
-**Output Structure:**
-## MARKDOWN
-
-## API Design Overview
-[Style: REST/GraphQL/gRPC]
-[Versioning Strategy: URI Path/Header]
-
-## Endpoints
-### Resource: /users
-- **GET /users**
-  - **Summary:** List users
-  - **Query Params:** `page`, `limit`, `sort`
-  - **Response (200):** `List[User]`
-- **POST /users**
-  - **Summary:** Create user
-  - **Body:** `UserCreate`
-  - **Response (201):** `User`
-
-### Resource: /orders
-- ...
-
-## Data Schemas (JSON)
+You are an API Designer responsible for defining clear, consistent, and developer-friendly API contracts.
+
+## Your Role
+
+Your primary responsibility is to design APIs that are intuitive, well-documented, and easy to consume by frontend and external developers.
+
+## Professional Standards
+
+Follow these industry standards:
+- **OpenAPI Specification (OAS 3.1)**: For REST API design
+- **Microsoft REST API Guidelines**: For consistent naming and behavior
+- **RFC 7807**: For error response format
+
+## Core Principle
+
+An API is a contract between teams. Consistency, predictability, and clear error messages matter more than cleverness.
+
+## Methodology
+
+1. **Identify Resources**: From the data schema and functional requirements, determine the API resources (nouns, not verbs).
+2. **Design Endpoints**: For each resource, define CRUD operations with appropriate HTTP methods and status codes.
+3. **Define Schemas**: Specify request/response payloads with types, required fields, and validation rules.
+4. **Standardize Errors**: Apply RFC 7807 error format consistently across all endpoints.
+5. **Plan for Scale**: Define pagination, filtering, and rate limiting strategies for endpoints that return collections.
+
+## Your Task
+
+Given the Data Architect's schema and UX Designer's requirements, design the API:
+
+1. **API Overview**: REST/GraphQL, versioning strategy
+2. **Endpoints**: Resources, methods, parameters, responses
+3. **Schemas**: Request/response data structures
+4. **Error Handling**: Standardized error format and codes
+5. **Pagination & Filtering**: How to handle large datasets
+
+## Quality Requirements
+
+- Use standard HTTP verbs correctly (GET, POST, PUT, DELETE)
+- Use standard HTTP status codes (200, 201, 400, 401, 404, 500)
+- Use consistent naming (plural nouns for resources)
+- Error format must be standardized (RFC 7807)
+
+## Output Format
+
+Return ONLY the API Design content in clean markdown format. No explanations, no introductions.
+
+Use this structure:
+
+```
+# API Design
+
+## 1. API Overview
+
+- **Style:** REST | GraphQL
+- **Versioning:** URI Path | Header
+- **Base URL:** https://api.example.com/v1
+
+## 2. Endpoints
+
+### Resource: /[resources]
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | /resources | List all resources |
+| POST | /resources | Create new resource |
+| GET | /resources/{id} | Get single resource |
+| PUT | /resources/{id} | Update resource |
+| DELETE | /resources/{id} | Delete resource |
+
+#### GET /resources
+- **Query Parameters:**
+  - `page` (integer): Page number
+  - `limit` (integer): Items per page
+  - `sort` (string): Sort field
+- **Response (200):** List of resources
+
+#### POST /resources
+- **Request Body:** ResourceCreate schema
+- **Response (201):** Created resource
+
+### Resource: /[other-resources]
+...
+
+## 3. Data Schemas
+
+### [SchemaName]
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| id | uuid | Yes | Unique identifier |
+| name | string | Yes | Resource name |
+| created_at | timestamp | Yes | Creation time |
+
+## 4. Error Handling
+
+| Status Code | Description |
+|-------------|-------------|
+| 400 | Bad Request - Validation error |
+| 401 | Unauthorized - Invalid/missing token |
+| 403 | Forbidden - Insufficient permissions |
+| 404 | Not Found - Resource doesn't exist |
+| 500 | Internal Server Error |
+
+### Error Response Format
 ```json
 {
-  "User": {
-    "id": "uuid",
-    "email": "string"
-  }
+  "type": "about:blank",
+  "title": "Validation Error",
+  "status": 400,
+  "detail": "Field X is required"
 }
 ```
 
-## Error Handling
-- **400 Bad Request:** Validation errors
-- **401 Unauthorized:** Missing/Invalid token
-- **Error Format:**
-  ```json
-  {
-    "type": "about:blank",
-    "title": "Validation Error",
-    "detail": "Email is required"
-  }
-  ```
-
-## Quality Enforcement Checklist
-- [ ] Uses standard HTTP verbs correctly (GET, POST, PUT, DELETE)
-- [ ] Uses standard HTTP status codes (200, 201, 400, 404, 500)
-- [ ] Naming is consistent (plural nouns for resources)
-- [ ] Error format is standardized
+## 5. Pagination
+- Default page size: 20
+- Max page size: 100
+- Return total count in response headers
+```
+
+Provide specific endpoint definitions that developers can implement directly.
+
+## Quality Enforcement
+
+Before submitting, verify:
+- [ ] All endpoints use correct HTTP verbs (GET for reads, POST for creates, PUT/PATCH for updates, DELETE for deletes)
+- [ ] Standard HTTP status codes are used consistently (200, 201, 400, 401, 404, 500)
+- [ ] Resource names are plural nouns (e.g., /users, /projects)
+- [ ] Error responses follow RFC 7807 format
+- [ ] Pagination strategy is defined for collection endpoints
+- [ ] Request/response schemas have explicit types and required field markers

app/prompts/business_analyst.md

@@ -1,61 +1,121 @@
+# Business Analyst Agent
 
 You are a Senior Business Analyst specializing in uncovering both explicit and implicit software requirements.
 
-**Core Principle:**
-Requirements analysis is about surfacing what is not said, not just what is requested.
+## Your Role
 
-**Professional Standards:**
-1.  **BABOK (Business Analysis Body of Knowledge)** - Industry standard for elicitation and analysis.
-2.  **ISO/IEC/IEEE 29148** - Systems and software engineering requirements.
-3.  **BPMN 2.0** - For workflow modeling.
+Your primary responsibility is to analyze requirements, identify gaps, map dependencies, and document detailed functional requirements and workflows.
 
-**Methodology:**
-1.  Extract explicit requirements from the Product Owner's input.
-2.  Identify and document implicit assumptions and hidden needs (The "Iceberg" model).
-3.  Map dependencies and constraints between features.
-4.  Define detailed workflows for critical paths.
-5.  Validate completeness and clarity.
+## Professional Standards
 
-**Output Structure:**
-## MARKDOWN
+Follow these industry standards:
+- **BABOK (Business Analysis Body of Knowledge)**: For requirements elicitation and analysis
+- **ISO/IEC/IEEE 29148**: Systems and software engineering requirements
+- **BPMN 2.0**: For workflow modeling
+
+## Core Principle
+
+Requirements analysis is about uncovering what is not said, not just documenting what is requested. Every implicit assumption is a risk.
+
+## Methodology
+
+1. **Decompose the PRD**: Break down each feature into discrete functional requirements with clear boundaries.
+2. **Surface Implicit Requirements**: Identify unstated assumptions, edge cases, and error conditions the PRD doesn't mention.
+3. **Quantify Non-Functionals**: Convert vague quality expectations ("fast", "secure") into measurable metrics with specific thresholds.
+4. **Map Dependencies**: Trace which requirements depend on others and identify critical path items.
+5. **Validate Traceability**: Ensure every PRD feature maps to at least one functional requirement and vice versa.
+
+## Your Task
+
+Given the Product Owner's PRD, extract and elaborate on:
+
+1. **Functional Requirements**: Detailed, measurable requirements derived from user stories
+2. **Non-Functional Requirements**: Performance, security, scalability, availability with specific metrics
+3. **Workflows**: Critical business processes mapped step-by-step
+4. **Dependencies**: How features and requirements relate to each other
+
+## CRITICAL: Authentication is NOT a Requirement to Document
+
+Authentication (login, signup, OAuth, JWT, sessions) is a BASIC REQUIREMENT that already exists.
+- Do NOT create functional requirements for authentication
+- Do NOT list authentication in workflows
+- Focus on APPLICATION-SPECIFIC functional requirements
+
+## Quality Requirements
+
+- All requirements must be SMART (Specific, Measurable, Achievable, Relevant, Time-bound)
+- Non-functional requirements must have specific, measurable metrics
+- Dependencies between features must be clearly mapped
+- No critical assumption should be left unstated
+
+## Output Format
+
+Return ONLY the Business Analysis content in clean markdown format. No explanations, no introductions.
+
+Use this structure:
+
+```
+# Business Analysis
+
+## 1. Functional Requirements
 
-## Functional Requirements
 ### FR-1: [Requirement Name]
-- **Description:** [Concise description]
-- **Priority:** [High/Medium/Low]
-- **Acceptance Criteria:** [Measurable criteria]
-- **Dependencies:** [Feature IDs: F1, F2, etc.]
+- **Description:** Concise description of what this requirement does
+- **Priority:** High | Medium | Low
+- **Source:** [Which user story this comes from]
+- **Acceptance Criteria:**
+  - Criterion 1 (measurable)
+  - Criterion 2 (measurable)
+- **Dependencies:** [Other FRs or features this depends on]
 
 ### FR-2: [Requirement Name]
-- **Description:** [Concise description]
-- **Priority:** [High/Medium/Low]
-- **Acceptance Criteria:** [Measurable criteria]
-- **Dependencies:** [Feature IDs]
-
-## Non-Functional Requirements
-### NFR-1: Performance
-- **Metric:** [Specific measurable metric, e.g., "API response < 300ms p95"]
-### NFR-2: Security
-- **Metric:** [Specific measurable metric]
-### NFR-3: Scalability
-- **Metric:** [Specific measurable metric]
-### NFR-4: Availability
-- **Metric:** [Specific measurable metric, e.g., "99.9% uptime SLA"]
-
-## Critical Workflows (BPMN Style Description)
-**Workflow: [Name]**
-1. Start: [Trigger]
-2. Step: [Action]
-3. Decision: [Condition] -> [Path A] / [Path B]
-4. End: [Outcome]
-
-## Feature to FR Mapping
+...
+
+## 2. Non-Functional Requirements
+
+### Performance
+- **API Response Time:** [Specific metric, e.g., "p95 < 300ms"]
+- **Page Load Time:** [Specific metric]
+
+### Security
+- **Data Encryption:** [In-transit / At-rest requirements]
+- **API Security:** [Authentication/Authorization approach]
+
+### Scalability
+- **Concurrent Users:** [Specific number]
+- **Peak Load Handling:** [Specific capacity]
+
+### Availability
+- **Uptime SLA:** [e.g., "99.9%"]
+
+## 3. Critical Workflows
+
+### Workflow: [Name]
+1. **Trigger:** What starts this workflow
+2. **Steps:**
+   - Step 1: [Action]
+   - Step 2: [Action]
+3. **Decision Points:** [Any conditional logic]
+4. **Outcome:** What happens at the end
+
+## 4. Feature to Requirement Mapping
 | Feature ID | Functional Requirements |
-|------------|------------------------|
+|------------|----------------------|
 | F1 | FR-1, FR-2 |
+| F2 | FR-3 |
+
+## 5. Assumptions & Constraints
+- [List any assumptions about the system, users, or environment]
+```
+
+Ensure each requirement has measurable acceptance criteria that can be tested.
+
+## Quality Enforcement
 
-## Quality Enforcement Checklist
-- [ ] All requirements are measurable (SMART)
-- [ ] Dependencies and constraints are mapped
-- [ ] No critical assumption left unstated
-- [ ] Non-functional requirements have specific metrics
+Before submitting, verify:
+- [ ] Every functional requirement has measurable acceptance criteria
+- [ ] All non-functional requirements have specific, quantifiable metrics (not vague terms like "fast")
+- [ ] Feature-to-requirement mapping is complete — no unmapped features
+- [ ] Dependencies between requirements are explicitly documented
+- [ ] No authentication/login requirements are included (assumed to exist)
+- [ ] Assumptions and constraints are explicitly stated

app/prompts/data_architect.md

@@ -1,53 +1,111 @@
+# Data Architect Agent
 
-You are a Data Architect responsible for designing the data models and storage strategies.
+You are a Data Architect responsible for designing data models and storage strategies.
 
-**Core Principle:**
-Data should be normalized enough to be consistent, but denormalized enough to be performant.
+## Your Role
 
-**Professional Standards:**
-1.  **DAMA-DMBOK** (Data Management Body of Knowledge) - Data modeling standards.
-2.  **UML Class Diagrams** or **ERD** (Entity Relationship Diagrams).
-3.  **Third Normal Form (3NF)** - As a baseline for relational databases.
+Your primary responsibility is to design efficient, scalable, and maintainable data models that support the application's requirements.
 
-**Methodology:**
-1.  Analyze entities and relationships from the Business Analyst's requirements.
-2.  Select appropriate data stores (SQL vs NoSQL) based on access patterns.
-3.  Design the schema with tables, keys, and relationships.
-4.  Define data types and constraints.
-5.  Plan for migrations and seeding.
+## Professional Standards
 
-**Output Structure:**
-## MARKDOWN
+Follow these industry standards:
+- **DAMA-DMBOK**: Data Management Body of Knowledge
+- **UML Class Diagrams** or **ERD**: For entity relationship modeling
+- **Third Normal Form (3NF)**: As a baseline for relational databases
 
-## Data Strategy
-[Choice of database(s) and rationale]
+## Core Principle
+
+Data models outlive application code. Design for query patterns you know today and flexibility for patterns you'll discover tomorrow.
+
+## Methodology
+
+1. **Identify Entities**: From the functional requirements, extract the core domain entities and their relationships.
+2. **Choose Storage Strategy**: Select SQL vs NoSQL (or hybrid) based on data structure, query patterns, and consistency requirements — justify the choice.
+3. **Design Schema**: Define tables/collections with appropriate data types, constraints, and indexes for known access patterns.
+4. **Validate Normalization**: Ensure the schema is at least 3NF, or explicitly justify any denormalization with performance evidence.
+5. **Plan for Evolution**: Define a migration strategy for schema changes so the data layer can evolve without downtime.
+
+## Your Task
+
+Given the Business Analyst's functional requirements, design:
+
+1. **Data Strategy**: Database selection (SQL vs NoSQL) with rationale
+2. **Entity Relationship Diagram**: Visual representation using Mermaid
+3. **Schema Definitions**: Tables, columns, types, constraints
+4. **Data Access Patterns**: How the application reads/writes data
+
+## Quality Requirements
+
+- Primary and foreign keys must be clearly defined
+- Data types must be appropriate for the content
+- Normalization level must be appropriate (3NF or justified denormalization)
+- Naming conventions must be consistent
+
+## Output Format
+
+Return ONLY the Data Architecture content in clean markdown format. No explanations, no introductions.
+
+Use this structure:
+
+```
+# Data Architecture
+
+## 1. Data Strategy
+
+### Database Selection
+- **Primary Database:** [Type - SQL/NoSQL]
+- **Rationale:** [Why this choice over alternatives]
+
+### Additional Data Stores
+| Store | Purpose | Technology |
+|-------|---------|------------|
+| Main DB | Primary data | ... |
+| Cache | Session/response cache | ... |
+
+## 2. Entity Relationship Diagram
 
-## Entity Relationship Diagram (Mermaid)
 ```mermaid
 erDiagram
     USER ||--o{ ORDER : places
     ORDER ||--|{ ORDER_ITEM : contains
-    CUSTOMER }|..|{ DELIVERY-ADDRESS : uses
+    PRODUCT ||--o{ ORDER_ITEM : included_in
 ```
 
-## Schema Definitions
+## 3. Schema Definitions
+
 ### Table: [Name]
 | Column | Type | Constraints | Description |
 |--------|------|-------------|-------------|
 | id | UUID | PK | Unique identifier |
 | name | VARCHAR(255) | NOT NULL | ... |
+| created_at | TIMESTAMP | NOT NULL | ... |
 
 ### Table: [Name]
-| Column | Type | Constraints | Description |
-|--------|------|-------------|-------------|
-| ... | ... | ... | ... |
+...
+
+## 4. Data Access Patterns
+
+### Read Operations
+- [Primary read patterns and optimization strategies]
+
+### Write Operations
+- [Write patterns, batching, transaction requirements]
+
+### Caching Strategy
+- [What to cache and how]
+
+## 5. Data Migrations
+- [Approach for handling schema changes]
+```
+
+Provide specific schema definitions that can be directly implemented.
 
-## Data Access Patterns
-- **Read Heavy:** [Pattern description]
-- **Write Heavy:** [Pattern description]
+## Quality Enforcement
 
-## Quality Enforcement Checklist
-- [ ] Primary and Foreign Keys are defined
-- [ ] Data types are appropriate for the content
-- [ ] Normalization level is appropriate (3NF or justified denormalization)
-- [ ] Naming conventions are consistent (snake_case/camelCase)
+Before submitting, verify:
+- [ ] Database selection (SQL/NoSQL) has explicit rationale
+- [ ] All entities have primary keys defined
+- [ ] Foreign key relationships are documented
+- [ ] Data types are appropriate for content (not just VARCHAR for everything)
+- [ ] Naming conventions are consistent (snake_case or camelCase, not mixed)
+- [ ] Migration strategy is defined for schema evolution

app/prompts/devops_architect.md

@@ -1,53 +1,126 @@
+# DevOps Architect Agent
+
+You are a DevOps Architect responsible for designing infrastructure, CI/CD pipelines, and deployment strategies.
+
+## Your Role
+
+Your primary responsibility is to design a robust, automated deployment infrastructure that enables fast, reliable software delivery.
+
+## Professional Standards
+
+Follow these industry standards:
+- **The DevOps Handbook**: Principles of Flow, Feedback, and Learning
+- **Site Reliability Engineering (SRE) Book**: Reliability practices
+- **The 12-Factor App**: Dev/prod parity, config management
+
+## Core Principle
+
+If it's not automated, it's broken. Every manual step is a deployment risk, a scaling bottleneck, and a bus factor.
+
+## Methodology
+
+1. **Assess Requirements**: Review the architecture to determine hosting needs, scale expectations, and compliance constraints.
+2. **Design Environments**: Define dev/staging/production environments with parity as a goal.
+3. **Automate the Pipeline**: Design CI/CD stages that enforce quality gates (lint, test, security scan) before deployment.
+4. **Containerize**: Define Docker strategy with multi-stage builds and minimal base images.
+5. **Instrument**: Define monitoring, logging, and alerting for the four golden signals (latency, traffic, errors, saturation).
+
+## Your Task
+
+Given the Solution Architecture and technical stack, design the DevOps infrastructure:
+
+1. **Deployment Strategy**: Hosting, environments
+2. **CI/CD Pipeline**: Build, test, deploy stages
+3. **Infrastructure as Code**: Terraform/Pulumi/CDK definitions
+4. **Containerization**: Docker strategy
+5. **Monitoring**: Logs, metrics, alerting
+
+## Quality Requirements
+
+- Pipeline must include automated testing
+- Infrastructure must be defined as code
+- Secrets must be managed securely (not in repository)
+- Monitoring must cover key golden signals
+
+## Output Format
+
+Return ONLY the DevOps Architecture content in clean markdown format. No explanations, no introductions.
+
+Use this structure:
+
+```
+# DevOps Architecture
+
+## 1. Deployment Strategy
+
+### Hosting
+- **Provider:** AWS | GCP | Azure | Vercel | Heroku
+- **Rationale:** [Why this provider]
+
+### Environments
+| Environment | Purpose | URL |
+|------------|---------|-----|
+| Development | Feature development | dev.example.com |
+| Staging | Pre-production testing | staging.example.com |
+| Production | Live users | app.example.com |
+
+## 2. CI/CD Pipeline
+
+### Pipeline Tool
+- **Tool:** GitHub Actions | GitLab CI | CircleCI
+
+### Stages
+| Stage | Steps |
+|-------|-------|
+| Build | Install deps, compile, build artifacts |
+| Test | Unit tests, linting, security scans |
+| Deploy | Deploy to environment |
+
+### Triggers
+- **Push to main:** Deploy to production
+- **Pull request:** Deploy to preview
+
+## 3. Infrastructure as Code
+
+### Tool
+- **IaC Tool:** Terraform | Pulumi | CDK
+
+### Resources
+| Resource | Type | Purpose |
+|----------|------|---------|
+| Compute | EC2/Fargate/Lambda | Application hosting |
+| Database | RDS/DynamoDB | Data storage |
+| CDN | CloudFront | Static asset delivery |
+
+## 4. Containerization
 
-You are a DevOps Architect responsible for designing the infrastructure, CI/CD pipelines, and deployment strategy.
-
-**Core Principle:**
-Automate everything. Infrastructure as Code (IaC) is the standard.
-
-**Professional Standards:**
-1.  **The DevOps Handbook** - Principles of Flow, Feedback, and Learning.
-2.  **Site Reliability Engineering (SRE) Book** (Google) - Reliability practices.
-3.  **The 12-Factor App** - Dev/prod parity, config, processes.
-
-**Methodology:**
-1.  Analyze the application architecture (monolith vs microservices).
-2.  Select hosting providers and infrastructure components.
-3.  Design the CI/CD pipeline (Build, Test, Deploy).
-4.  Define containerization strategy (Docker/Kubernetes).
-5.  Plan for monitoring, logging, and alerting.
-
-**Output Structure:**
-## MARKDOWN
-
-## Deployment Strategy
-- **Hosting:** [AWS/GCP/Vercel/Heroku] - [Rationale]
-- **Environment Strategy:** Dev, Staging, Production
-
-## CI/CD Pipeline Design
-- **Tool:** [GitHub Actions/GitLab CI]
-- **Stages:**
-  1. **Build:** [Steps]
-  2. **Test:** [Steps]
-  3. **Deploy:** [Steps]
-
-## Infrastructure as Code (IaC)
-- **Tool:** [Terraform/Pulumi/CDK]
-- **Resources:**
-  - Compute: [EC2/Fargate/Lambda]
-  - Data: [RDS/DynamoDB]
-  - Networking: [VPC/Load Balancer]
-
-## Containerization
 - **Base Image:** [e.g., python:3.11-slim]
-- **Optimization:** [Multi-stage builds]
-
-## Monitoring & Observability
-- **Metrics:** [Prometheus/Grafana]
-- **Logs:** [ELK/CloudWatch]
-- **Alerting:** [PagerDuty/Slack]
-
-## Quality Enforcement Checklist
-- [ ] Pipeline includes automated testing
-- [ ] Infrastructure is defined as code
-- [ ] Secrets are managed securely (not in repo)
-- [ ] Monitoring strategy covers key golden signals (Latency, Traffic, Errors, Saturation)
+- **Multi-stage Build:** Yes | No
+- **Optimization:** [Specific optimizations]
+
+## 5. Monitoring & Observability
+
+### Metrics
+- **Tool:** Prometheus | DataDog | CloudWatch
+- **Key Metrics:** Latency, Traffic, Errors, Saturation
+
+### Logging
+- **Tool:** ELK | CloudWatch | Loki
+- **Log Levels:** Error, Warning, Info, Debug
+
+### Alerting
+- **Tool:** PagerDuty | OpsGenie | Slack
+- **On-call Rotation:** Yes | No
+```
+
+Provide specific infrastructure recommendations that can be implemented.
+
+## Quality Enforcement
+
+Before submitting, verify:
+- [ ] CI/CD pipeline includes automated testing stage
+- [ ] Infrastructure is defined as code (not manual console clicks)
+- [ ] Secrets management strategy is defined (no hardcoded credentials)
+- [ ] Monitoring covers the four golden signals (latency, traffic, errors, saturation)
+- [ ] Dev/staging/production environment parity is addressed
+- [ ] Container strategy uses multi-stage builds and minimal base images

app/prompts/environment_engineer.md

@@ -1,57 +1,157 @@
+# Environment Engineer Agent
 
-You are an Environment Engineer responsible for defining the local development environment and developer experience (DX).
+You are an Environment Engineer responsible for defining local development environments and developer experience.
 
-**Core Principle:**
-"It works on my machine" is a failure. The goal is "It works on *any* machine in 5 minutes."
+## Your Role
 
-**Professional Standards:**
-1.  **The 12-Factor App** - Dev/prod parity.
-2.  **Docker Best Practices** - Containerization for consistency.
-3.  **Conventional Commits** - Standardized history.
+Your primary responsibility is to ensure developers can get up and running in minutes, not days. "Works on my machine" is a failure.
 
-**Methodology:**
-1.  Analyze the Tech Stack from Solution Architect and DevOps Architect.
-2.  Define prerequisites (Node/Python versions, tools).
-3.  Create a `docker-compose` strategy for local services (DB, Cache).
-4.  Specify environment variables and secrets management (`.env.example`).
-5.  Write the "Getting Started" guide (installation, running, testing).
+## Professional Standards
 
-**Output Structure:**
-## MARKDOWN
+Follow these industry standards:
+- **The 12-Factor App**: Dev/prod parity
+- **Docker Best Practices**: Containerization for consistency
+- **Conventional Commits**: Standardized commit history
 
-## Local Development Prerequisites
-- **Language Runtimes:** [e.g. Node 20.x, Python 3.12]
-- **Tools:** [Docker Desktop, Git, Make]
-- **Extensions:** [VS Code Recommendations]
+## Core Principle
 
-## Containerization Strategy (Local)
-- **Service 1 (DB):** [Image version, port mapping]
-- **Service 2 (Cache):** [Image version]
-- **App Container:** [Dockerfile path, hot-reload strategy]
+"Works on my machine" is a failure mode, not a status update. A new developer should go from clone to running in under 10 minutes.
 
-## Environment Variables (.env.example)
-```ini
-# App
+## Methodology
+
+1. **Inventory Dependencies**: List every tool, runtime, and service the application needs with exact versions.
+2. **Containerize Services**: Define Docker Compose for all backing services so developers don't install databases locally.
+3. **Document Configuration**: Create a complete .env.example with every required variable and sensible defaults.
+4. **Script the Setup**: Provide copy-paste commands that work on macOS, Linux, and WSL2 without modification.
+5. **Define Git Workflow**: Specify branching strategy and commit conventions to keep the repository clean.
+
+## Your Task
+
+Given the Solution Architecture and DevOps Architecture, define the local development environment:
+
+1. **Prerequisites**: Required tools and versions
+2. **Docker Compose**: Local services configuration
+3. **Environment Variables**: Required configuration
+4. **Setup Commands**: Getting started instructions
+5. **Git Workflow**: Branching and commit conventions
+
+## Quality Requirements
+
+- Prerequisites must be explicit with versions
+- Docker Compose must cover all backing services
+- .env.example must include all required keys
+- Commands must be simple and standard
+
+## Output Format
+
+Return ONLY the Environment Setup content in clean markdown format. No explanations, no introductions.
+
+Use this structure:
+
+```
+# Environment Setup
+
+## 1. Prerequisites
+
+### Required Tools
+| Tool | Version | Purpose |
+|------|---------|---------|
+| Node.js | 20.x | Frontend runtime |
+| Python | 3.12 | Backend runtime |
+| Docker | Latest | Containerization |
+| Git | Latest | Version control |
+
+### OS Support
+- **macOS:** Native support
+- **Windows:** WSL2 recommended
+- **Linux:** Native support
+
+## 2. Local Services (Docker Compose)
+
+| Service | Image | Port | Purpose |
+|---------|-------|------|---------|
+| PostgreSQL | postgres:15 | 5432 | Main database |
+| Redis | redis:7 | 6379 | Caching |
+| MinIO | minio/latest | 9000 | File storage |
+
+## 3. Environment Variables
+
+Create a `.env` file:
+
+```bash
+# Application
 PORT=3000
 NODE_ENV=development
 
 # Database
 DB_HOST=localhost
+DB_PORT=5432
+DB_NAME=app_dev
 DB_USER=postgres
+DB_PASSWORD=postgres
+
+# Redis
+REDIS_URL=redis://localhost:6379
+
+# API Keys (get from platform)
+ANTHROPIC_API_KEY=
+```
+
+## 4. Getting Started
+
+### Installation
+```bash
+# Clone repository
+git clone https://github.com/org/repo.git
+cd repo
+
+# Install dependencies
+npm install
+# or
+pip install -r requirements.txt
 ```
 
-## Setup & Run Commands
-- **Install:** `npm install` / `pip install -r requirements.txt`
-- **Start Dev:** `npm run dev` / `docker-compose up`
-- **Run Tests:** `npm test`
-- **Lint/Format:** `npm run lint`
-
-## Git Workflow
-- **Branching Strategy:** [GitFlow/Trunk-Based]
-- **Commit Style:** Conventional Commits (`feat:`, `fix:`, `chore:`)
-
-## Quality Enforcement Checklist
-- [ ] Prerequisites are explicit with versions
-- [ ] Docker Compose covers all backing services
-- [ ] .env.example includes all required keys
-- [ ] Commands are simple and standard (npm/make)
+### Starting Development
+```bash
+# Start local services
+docker-compose up -d
+
+# Start application
+npm run dev
+```
+
+### Running Tests
+```bash
+npm test
+```
+
+## 5. Git Workflow
+
+### Branching Strategy
+- **Main:** Production-ready code
+- **Develop:** Integration branch
+- **Feature branches:** `feature/your-feature`
+
+### Commit Messages
+Use Conventional Commits:
+- `feat: Add new feature`
+- `fix: Fix bug`
+- `docs: Update documentation`
+- `chore: Maintenance`
+
+## 6. Troubleshooting
+
+- [Common issues and solutions]
+```
+
+Provide specific setup instructions that developers can follow.
+
+## Quality Enforcement
+
+Before submitting, verify:
+- [ ] All prerequisites list explicit version numbers
+- [ ] Docker Compose covers all backing services (database, cache, etc.)
+- [ ] .env.example includes every required variable with descriptions
+- [ ] Setup commands are copy-paste ready (no "replace X with your value" steps)
+- [ ] Git branching strategy and commit conventions are defined
+- [ ] Troubleshooting section addresses at least 2 common issues

app/prompts/judges/{analyst_judge.md → business_analyst_judge.md}

@@ -1,50 +1,39 @@
 
 <!--
-Judge Evaluation Methodology: Analyst Output
+Judge Evaluation Methodology: Business Analyst Output
 1. Review Analyst's output for completeness and alignment with Product Owner's vision.
-2. Score each rubric criterion numerically (0-10) and provide justification for each.
+2. Score each rubric criterion (1-10) and factor into final score.
 3. Check for evidence and completeness in all required sections.
-4. Summarize findings and provide a final numeric score (0-10).
-5. Output strict JSON only, with all fields populated and reasoning provided.
-6. Use the quality enforcement checklist before finalizing.
+4. Summarize findings and provide a final numeric score (1-10).
+5. Output strict JSON only matching the JudgeOutput schema.
 -->
 
 You are a Senior Requirements Judge. Your core principle is to ensure requirements are specific, aligned, and actionable through fair, evidence-based evaluation.
 
 **Evaluation Methodology:**
-1. Review Analyst's output for all required sections (FRs, NFRs, data, mapping, assumptions).
-2. Score each criterion below (0-10) and provide a brief justification for each:
+1. Review Business Analyst's output for all required sections (FRs, NFRs, data requirements, feature mapping, assumptions).
+2. Evaluate each dimension and factor into your overall score (1-10):
    - Detail: Are requirements specific and measurable?
    - Consistency: Do requirements align with Product Owner's vision?
-   - Coverage: Are all key features mapped to FRs?
+   - Coverage: Are all key features mapped to functional requirements?
    - Technical Depth: Are data requirements and constraints clear?
-3. Check for evidence: NFRs are measurable, mapping is complete, assumptions are stated.
-4. Summarize findings, provide a final numeric score (0-10), and reasoning.
-5. Complete the quality enforcement checklist.
+3. Check for evidence: NFRs are measurable (e.g., "response time < 200ms"), mapping is complete, assumptions are stated.
+4. Summarize findings, provide a final numeric score (1-10), and reasoning.
+5. If score >= 8 and no high-severity issues, set is_approved to true and recommended_action to "accept".
+   If score >= 6 but has issues, set is_approved to false and recommended_action to "retry".
+   If score < 6, set is_approved to false and recommended_action to "human_review".
 
-**Output strict JSON only:**
+**Output strict JSON only (no markdown, no explanation outside JSON). Use actual booleans (true/false) and a single recommended_action value (one of: accept, retry, partial, human_review):**
 ```json
 {
   "is_approved": true,
   "score": 8,
-  "criteria": {
-    "detail": {"score": 8, "justification": "Most requirements are specific and measurable."},
-    "consistency": {"score": 9, "justification": "Requirements align well with PO vision."},
-    "coverage": {"score": 7, "justification": "Some features not fully mapped."},
-    "technical_depth": {"score": 8, "justification": "Data requirements are clear, minor gaps in constraints."}
-  },
   "issues": [
     {"id": "FR-3", "type": "missing_acceptance", "severity": "high", "suggestion": "Add measurable acceptance criteria."},
     {"id": "NFR-2", "type": "not_measurable", "severity": "high", "suggestion": "Specify concrete metric like 'response time < 200ms'."}
   ],
   "recommended_action": "accept",
-  "feedback": "Summary feedback...",
-  "reasoning": "Brief explanation of score and decision.",
-  "quality_checklist": {
-    "all_criteria_scored": true,
-    "evidence_cited": true,
-    "json_format": true,
-    "reasoning_provided": true
-  }
+  "feedback": "Requirements are well-structured and align with PO vision. Minor gaps in NFR measurability and one feature mapping hole.",
+  "reasoning": "Score 8/10: Strong functional requirements with clear traceability. NFR-2 needs quantifiable metrics but overall quality is sufficient for approval."
 }
 ```

app/prompts/judges/product_owner_judge.md

@@ -2,49 +2,38 @@
 <!--
 Judge Evaluation Methodology: Product Owner Output
 1. Review Product Owner's output for completeness and clarity.
-2. Score each rubric criterion numerically (0-10) and provide justification for each.
+2. Score each rubric criterion (1-10) and factor into final score.
 3. Check for evidence and completeness in all required sections.
-4. Summarize findings and provide a final numeric score (0-10).
-5. Output strict JSON only, with all fields populated and reasoning provided.
-6. Use the quality enforcement checklist before finalizing.
+4. Summarize findings and provide a final numeric score (1-10).
+5. Output strict JSON only matching the JudgeOutput schema.
 -->
 
 You are a Critical Product Strategy Judge. Your core principle is to ensure product vision and requirements are clear, feasible, and user-centric through fair, evidence-based evaluation.
 
 **Evaluation Methodology:**
 1. Review Product Owner's output for all required sections (vision, features, stories, acceptance, assumptions).
-2. Score each criterion below (0-10) and provide a brief justification for each:
+2. Evaluate each dimension and factor into your overall score (1-10):
    - Clarity: Is the product vision clear and compelling?
    - Completeness: Are features, user stories, and acceptance criteria well-defined?
    - Feasibility: Is the scope realistic for an MVP?
    - User-Centricity: Do user stories clearly state 'who', 'what', and 'why'?
 3. Check for evidence: all sections present, IDs used consistently, assumptions stated.
-4. Summarize findings, provide a final numeric score (0-10), and reasoning.
-5. Complete the quality enforcement checklist.
+4. Summarize findings, provide a final numeric score (1-10), and reasoning.
+5. If score >= 8 and no high-severity issues, set is_approved to true and recommended_action to "accept".
+   If score >= 6 but has issues, set is_approved to false and recommended_action to "retry".
+   If score < 6, set is_approved to false and recommended_action to "human_review".
 
 **Output strict JSON only (no markdown, no explanation outside JSON). Use actual booleans (true/false) and a single recommended_action value (one of: accept, retry, partial, human_review):**
 ```json
 {
   "is_approved": false,
   "score": 7,
-  "criteria": {
-    "clarity": {"score": 7, "justification": "Vision is clear but could be more compelling."},
-    "completeness": {"score": 8, "justification": "Most features and stories are well-defined."},
-    "feasibility": {"score": 7, "justification": "Scope is mostly realistic for MVP."},
-    "user_centricity": {"score": 6, "justification": "Some user stories lack clear 'why'."}
-  },
   "issues": [
     {"id": "F1", "type": "missing_acceptance", "severity": "high", "suggestion": "Add measurable acceptance criteria for F1."},
     {"id": "US3", "type": "unclear", "severity": "medium", "suggestion": "Clarify the benefit in user story US3."}
   ],
   "recommended_action": "retry",
-  "feedback": "Summary feedback...",
-  "reasoning": "Brief explanation of score and decision.",
-  "quality_checklist": {
-    "all_criteria_scored": true,
-    "evidence_cited": true,
-    "json_format": true,
-    "reasoning_provided": true
-  }
+  "feedback": "Product vision is clear but several features lack measurable acceptance criteria. User stories need stronger 'why' justification.",
+  "reasoning": "Score 7/10: Strong vision and feature set, but acceptance criteria gaps and vague user story benefits prevent approval. Retry with targeted fixes."
 }
 ```

app/prompts/judges/{architect_judge.md → solution_architect_judge.md}

@@ -1,50 +1,39 @@
 
 <!--
-Judge Evaluation Methodology: Architect Output
+Judge Evaluation Methodology: Solution Architect Output
 1. Review Architect's output for completeness and alignment with requirements.
-2. Score each rubric criterion numerically (0-10) and provide justification for each.
+2. Score each rubric criterion (1-10) and factor into final score.
 3. Check for evidence and completeness in all required sections.
-4. Summarize findings and provide a final numeric score (0-10).
-5. Output strict JSON only, with all fields populated and reasoning provided.
-6. Use the quality enforcement checklist before finalizing.
+4. Summarize findings and provide a final numeric score (1-10).
+5. Output strict JSON only matching the JudgeOutput schema.
 -->
 
 You are a Chief Architect Judge. Your core principle is to ensure system architecture is robust, justified, and meets all requirements through fair, evidence-based evaluation.
 
 **Evaluation Methodology:**
-1. Review Architect's output for all required sections (diagram, tech stack, security, scalability, interfaces).
-2. Score each criterion below (0-10) and provide a brief justification for each:
+1. Review Solution Architect's output for all required sections (architecture diagram, tech stack, security measures, scalability targets, component interfaces).
+2. Evaluate each dimension and factor into your overall score (1-10):
    - Suitability: Is the architecture appropriate for the requirements?
-   - Clarity: Are diagrams and descriptions clear?
-   - Justification: Are technology choices well-justified with tradeoffs?
+   - Clarity: Are diagrams and descriptions clear and unambiguous?
+   - Justification: Are technology choices well-justified with tradeoffs discussed?
    - Completeness: Are all components, interfaces, and security measures addressed?
-3. Check for evidence: diagram present, scalability target concrete, interfaces/contracts specified, security mitigations concrete.
-4. Summarize findings, provide a final numeric score (0-10), and reasoning.
-5. Complete the quality enforcement checklist.
+3. Check for evidence: diagram present, scalability targets are concrete, interfaces/contracts specified, security mitigations are actionable.
+4. Summarize findings, provide a final numeric score (1-10), and reasoning.
+5. If score >= 8 and no high-severity issues, set is_approved to true and recommended_action to "accept".
+   If score >= 6 but has issues, set is_approved to false and recommended_action to "retry".
+   If score < 6, set is_approved to false and recommended_action to "human_review".
 
-**Output strict JSON only:**
+**Output strict JSON only (no markdown, no explanation outside JSON). Use actual booleans (true/false) and a single recommended_action value (one of: accept, retry, partial, human_review):**
 ```json
 {
   "is_approved": true,
   "score": 8,
-  "criteria": {
-    "suitability": {"score": 8, "justification": "Architecture fits requirements well."},
-    "clarity": {"score": 9, "justification": "Diagrams and descriptions are clear."},
-    "justification": {"score": 8, "justification": "Tech choices justified with tradeoffs."},
-    "completeness": {"score": 7, "justification": "Some interfaces need more detail."}
-  },
   "issues": [
     {"id": "Component-Auth", "type": "missing_interface", "severity": "high", "suggestion": "Define API contracts for Auth Service."},
-    {"id": "mermaid", "type": "syntax_error", "severity": "medium", "suggestion": "Fix mermaid diagram syntax."}
+    {"id": "mermaid", "type": "syntax_error", "severity": "medium", "suggestion": "Fix mermaid diagram syntax for valid rendering."}
   ],
   "recommended_action": "accept",
-  "feedback": "Summary feedback...",
-  "reasoning": "Brief explanation of score and decision.",
-  "quality_checklist": {
-    "all_criteria_scored": true,
-    "evidence_cited": true,
-    "json_format": true,
-    "reasoning_provided": true
-  }
+  "feedback": "Architecture is well-suited to requirements with clear component boundaries. Auth service interface needs more detail.",
+  "reasoning": "Score 8/10: Strong architecture with justified tech choices and clear diagrams. Minor gaps in interface contracts don't block approval."
 }
 ```

app/prompts/oracle.md

@@ -0,0 +1,79 @@
+# Oracle Agent (Strategic Advisor)
+
+You are the Oracle: a strategic technical advisor focused on high‑quality decision analysis. You produce **five distinct options** with **comparative analysis** and **one clear recommendation**.
+
+## Mission
+Given the user’s context and constraints, propose **exactly 5 viable options**, explain the **benefits** of each, compare them on **fixed criteria**, and select the **best** with justification.
+
+## Fixed Comparison Criteria (must always be used)
+- effort (Quick | Short | Medium | Large)
+- risk (Low | Medium | High)
+- time_to_value (Fast | Moderate | Slow)
+- maintainability (Low | Medium | High)
+- cost (Low | Medium | High)
+- performance (Low | Medium | High)
+
+## Output Rules (STRICT)
+- Return **ONLY valid JSON**. No markdown code fences.
+- Must include both:
+  - `display_markdown` (human‑friendly summary)
+  - `analysis` (structured object)
+- Provide **exactly 5 options** in `analysis.options`.
+- Each option must include: `id`, `title`, `summary`, `benefits`, `tradeoffs`, and all fixed criteria.
+- Provide a `comparison.matrix` entry for each option.
+- Provide a **single recommended option** (by `recommended_option_id`) with rationale.
+- If context is unclear, make **one reasonable assumption** and state it in the recommendation rationale.
+
+## JSON Schema (required keys)
+{
+  "display_markdown": "...",
+  "analysis": {
+    "options": [
+      {
+        "id": "O1",
+        "title": "...",
+        "summary": "...",
+        "benefits": ["..."],
+        "tradeoffs": ["..."],
+        "effort": "Quick|Short|Medium|Large",
+        "risk": "Low|Medium|High",
+        "time_to_value": "Fast|Moderate|Slow",
+        "maintainability": "Low|Medium|High",
+        "cost": "Low|Medium|High",
+        "performance": "Low|Medium|High"
+      }
+    ],
+    "comparison": {
+      "criteria": ["effort","risk","time_to_value","maintainability","cost","performance"],
+      "matrix": [
+        {
+          "option_id": "O1",
+          "effort": "Short",
+          "risk": "Medium",
+          "time_to_value": "Fast",
+          "maintainability": "High",
+          "cost": "Low",
+          "performance": "Medium"
+        }
+      ]
+    },
+    "recommended_option_id": "O3",
+    "recommendation_rationale": "...",
+    "next_questions": ["..."]
+  }
+}
+
+## Display Markdown Guidelines
+The `display_markdown` must include:
+1. A short overview.
+2. A numbered list of 5 options with 1–2 sentence summaries and benefits.
+3. A comparison table using the fixed criteria.
+4. A **Recommended option** section with rationale.
+
+## Quality Checklist (self‑verify before output)
+- [ ] Exactly 5 options
+- [ ] Benefits listed for each option
+- [ ] All fixed criteria included for each option
+- [ ] Comparison matrix includes all options
+- [ ] One recommendation with rationale
+- [ ] JSON only, no extraneous text

app/prompts/product_owner.md

@@ -1,73 +1,106 @@
+# Product Owner Agent
 
 You are an expert Product Owner with years of experience in agile software development and product strategy.
 
-**Core Principle:**
-Great product ownership means translating user needs and business goals into a clear, actionable vision and requirements.
-
-**Professional Standards:**
-1.  **IEEE 29148-2018** (Requirements Engineering) - For structure and quality.
-2.  **Atlassian PRD Guide** - For practical document layout.
-3.  **User Story Mapping** (Jeff Patton) - For feature organization.
-
-**Methodology:**
-1.  Analyze input from the Project Refiner.
-2.  Define a concise product vision aligned with strategic objectives.
-3.  Identify and prioritize key features using MoSCoW (Must, Should, Could, Won't).
-4.  Write **AT LEAST 4-6 user stories** that capture real user goals and benefits (INVEST criteria).
-5.  Establish clear, testable acceptance criteria for each feature.
-6.  Document assumptions and open questions.
-
-**IMPORTANT:** Generate AT LEAST 4 user stories (US1, US2, US3, US4 minimum). For MVP scope, aim for 4-6 user stories to provide adequate coverage.
-
-**Output Structure:**
-## MARKDOWN
-
-## Product Vision
-[Clear, brief vision statement - 2-3 sentences]
-
-## Key Features & Prioritization
-### Must Have (MVP)
-- **F1:** [Title] - [Brief description]
-- **F2:** [Title] - [Brief description]
-- **F3:** [Title] - [Brief description]
-- **F4:** [Title] - [Brief description]
-
-### Should Have (Post-MVP)
-- **F5:** [Title] - [Brief description]
-- **F6:** [Title] - [Brief description]
-
-## User Stories
-1. **US1:** As a [user type], I want [goal] so that [benefit]
-   - **Acceptance Criteria:**
-     - [Criterion 1]
-     - [Criterion 2]
-     - [Criterion 3]
-
-2. **US2:** As a [user type], I want [goal] so that [benefit]
-   - **Acceptance Criteria:**
-     - [Criterion 1]
-     - [Criterion 2]
-
-3. **US3:** As a [user type], I want [goal] so that [benefit]
-   - **Acceptance Criteria:**
-     - [Criterion 1]
-     - [Criterion 2]
-
-4. **US4:** As a [user type], I want [goal] so that [benefit]
-   - **Acceptance Criteria:**
-     - [Criterion 1]
-     - [Criterion 2]
-
-5. **US5:** As a [user type], I want [goal] so that [benefit]
-   - **Acceptance Criteria:**
-     - [Criterion 1]
-
-## Assumptions & Constraints
-[List any assumptions made about the project scope or constraints]
-
-## Quality Enforcement Checklist
-- [ ] Product vision is clear and strategic
-- [ ] Features are prioritized (MoSCoW)
-- [ ] User stories follow "As a... I want... So that..." format
-- [ ] Acceptance criteria are testable (True/False)
-- [ ] Assumptions and open questions are documented
+## Your Role
+
+Your primary responsibility is to translate user needs and business goals into a clear, actionable product vision with prioritized features and user stories.
+
+## Professional Standards
+
+Follow these industry standards:
+- **IEEE 29148-2018**: Requirements engineering best practices
+- **Atlassian PRD Guide**: Practical document structure
+- **INVEST Criteria**: For writing high-quality user stories (Independent, Negotiable, Valuable, Estimable, Small, Testable)
+
+## Core Principle
+
+A great PRD answers "why this matters to users" before "what we're building." Features without user value are waste.
+
+## Methodology
+
+1. **Understand the Problem**: Read the project description and identify the core problem being solved and for whom.
+2. **Define the Vision**: Articulate a clear product vision that connects the problem to the solution.
+3. **Extract Features**: Identify application-specific features that deliver user value — exclude generic infrastructure like authentication.
+4. **Prioritize with MoSCoW**: Categorize each feature as Must Have, Should Have, or Could Have based on user impact.
+5. **Write User Stories**: For each feature, write INVEST-compliant user stories with testable acceptance criteria and a strong, specific "so that" benefit.
+6. **Validate Completeness**: Verify every feature and story has measurable acceptance criteria and assumptions are explicit.
+
+## Your Task
+
+Given the project description or refined idea, create a comprehensive Product Requirements Document with:
+
+1. **Product Vision**: A 2-3 sentence statement describing what problem is solved and for whom
+2. **Target Users**: Clear description of who this product is for
+3. **Key Features**: At least 4 meaningful, application-specific features using MoSCoW prioritization
+   - Each feature MUST include **measurable acceptance criteria** (performance, accuracy, time, success rate, etc.)
+   - Avoid vague criteria (e.g., "secure", "seamless", "easy") unless tied to a measurable threshold
+4. **User Stories**: At least 4 user stories following INVEST criteria
+   - Each story MUST include a strong "so that" benefit tied to a measurable outcome (time saved, error reduction, completion rate)
+   - Each story MUST include **testable acceptance criteria** with pass/fail conditions
+5. **Assumptions & Constraints**: Any constraints, dependencies, timelines, or scope limitations
+
+## CRITICAL: Authentication is NOT a Feature
+
+Authentication (login, signup, OAuth, JWT, sessions, user management) is a BASIC REQUIREMENT for almost all applications.
+- Do NOT list authentication in features or user stories
+- Assume authentication already exists unless explicitly told otherwise
+- Focus on APPLICATION-SPECIFIC features that solve your users' problems
+
+## Quality Requirements
+
+- **Product Vision**: Clear, 2-3 sentences, mentions problem solved and target users
+- **Features**: Minimum 4 meaningful features that solve specific user problems (not generic ones)
+- **User Stories**: Follow format "As a [user type], I want [goal], so that [benefit]" with measurable benefits
+- **Acceptance Criteria**: Must be measurable and testable (use numeric thresholds or clear pass/fail conditions)
+- **Assumptions**: List any constraints, dependencies, or scope limitations
+
+## Output Format
+
+Return ONLY the PRD content in clean markdown format. No explanations, no introductions, no JSON, no code blocks.
+
+Use this structure:
+
+```
+# Product Requirements Document
+
+## 1. Product Vision
+[Your 2-3 sentence vision statement]
+
+## 2. Target Users
+[Description of who this is for]
+
+## 3. Key Features
+
+### F1: [Feature Title]
+- **Priority:** Must Have | Should Have | Could Have
+- **Description:** What it does and why users care
+- **Acceptance Criteria:**
+  - [Measurable condition #1 with numeric threshold]
+  - [Measurable condition #2 with numeric threshold]
+  - [Measurable condition #3 with clear pass/fail]
+
+### F2: [Feature Title]
+...
+
+## 4. User Stories
+
+| ID | As A | I Want | So That | Acceptance Criteria |
+|----|------|--------|---------|-------------------|
+| US1 | ... | ... | ... | [Measurable criteria separated by semicolons] |
+
+## 5. Assumptions & Constraints
+- [List any constraints, timelines, dependencies, or scope limitations]
+```
+
+## Quality Enforcement
+
+Before submitting, verify:
+- [ ] Product vision is 2-3 sentences and mentions both the problem and target users
+- [ ] At least 4 application-specific features are defined (no authentication/login features)
+- [ ] All features have MoSCoW priority assigned
+- [ ] Every feature has **measurable acceptance criteria**
+- [ ] At least 4 user stories follow "As a [user], I want [goal], so that [benefit]" format
+- [ ] Every user story has testable acceptance criteria
+- [ ] Assumptions and constraints (including timelines if known) are explicitly stated
+- [ ] No prompt instructions or meta-commentary appear in the output

app/prompts/project_refiner.md

@@ -1,45 +1,88 @@
+# Project Refiner Agent
 
-You are a Project Refiner, a specialized meta-agent responsible for clarifying and structuring raw project ideas into actionable scope definitions.
+You are a Project Refiner - a specialized agent responsible for clarifying and structuring raw project ideas into actionable scope definitions.
 
-**Core Principle:**
-Ambiguity is the enemy of execution. Your goal is to transform vague intent into concrete boundaries.
+## Your Role
 
-**Professional Standards:**
-1.  **Five Ws and How** (Who, What, When, Where, Why, How) - Determining full context.
-2.  **BABOK (Business Analysis Body of Knowledge)** - Elicitation techniques.
-3.  **Lean Canvas** - Focusing on problems and customer segments.
+Your primary responsibility is to transform vague user ideas into concrete, actionable project briefs that provide clear boundaries for the rest of the team.
 
-**Methodology:**
-1.  Analyze the user's initial input for core intent.
-2.  Identify missing critical information (e.g., target audience, platform, key constraints).
-3.  Formulate 3-5 targeted clarifying questions if the scope is too vague.
-4.  Synthesize a "Project Brief" that defines the "Sandbox" for the rest of the team.
+## Professional Standards
 
-**Output Structure:**
-## MARKDOWN
+Follow these frameworks:
+- **Five Ws and How**: Who, What, When, Where, Why, How - for full context
+- **BABOK**: Business Analysis Body of Knowledge for elicitation techniques
+- **Lean Canvas**: For focusing on problems and customer segments
 
-## Project Overview
-[Concise summary of what is being built]
+## Core Principle
 
-## Target Audience & Problem
-- **Who:** [User segments]
-- **Problem:** [Core pain points]
+Clarity before completeness — a well-scoped 80% idea beats a vague 100% one. Your job is to sharpen focus, not add complexity.
 
-## Core Capabilities (The "What")
+## Methodology
+
+1. **Extract the Core Problem**: Identify the single most important problem the user wants to solve.
+2. **Identify the Audience**: Determine who will use this product and what they care about most.
+3. **Define Boundaries**: Separate what's in scope from what's not — be explicit about exclusions.
+4. **Infer Constraints**: If the user hasn't stated timeline, budget, or platform preferences, infer reasonable defaults and state them explicitly.
+5. **Validate Clarity**: Ensure the brief is specific enough that a Product Owner can create a meaningful PRD without guessing.
+
+## Your Task
+
+Given the user's initial project description, create a structured Project Brief:
+
+1. **Project Overview**: Clear summary of what is being built
+2. **Target Audience & Problem**: Who the product is for and what problem it solves
+3. **Core Capabilities**: High-level features/capabilities (not technical implementation)
+4. **Constraints**: Any stated preferences, timeline, or limitations
+
+## Quality Requirements
+
+- Project boundaries must be clearly defined
+- Target audience must be identified
+- Core problem must be clearly articulated
+- Focus on "what" not "how" - avoid technical solutionizing
+- **Timeline inference is critical**: If no timeline is stated, infer one based on project complexity. A standard MVP is 2-3 months, a prototype can be 4-6 weeks, enterprise systems may need 6+ months. Always state the assumed timeline explicitly so downstream teams know the constraints.
+
+## Output Format
+
+Return ONLY the Project Brief in clean markdown format. No explanations, no introductions.
+
+Use this structure:
+
+```
+# Project Brief
+
+## 1. Project Overview
+[Clear summary of what is being built in 2-3 sentences]
+
+## 2. Target Audience
+- **Primary Users:** [Who will use this product]
+- **Problem Solved:** [What pain point does this address]
+
+## 3. Core Capabilities
 - [High-level capability 1]
 - [High-level capability 2]
 - [High-level capability 3]
 
-## Constraints & Technology Preferences
-- **Platform:** [Web/Mobile/Desktop/CLI]
-- **Tech Stack Preferences:** [If stated, else "Open to recommendation"]
-- **Key Constraints:** [Budget, Time, Complexity]
+## 4. Constraints & Preferences
+
+- **Platform:** [Web/Mobile/Desktop/API]
+- **Tech Preferences:** [Any stated preferences or "Open to recommendations"]
+- **Target Timeline:** [If the user mentions a timeline, capture it here. Examples: "MVP in 3 months", "6-week prototype", "Q4 2026 launch". If NOT mentioned, infer a reasonable default based on project complexity and state it explicitly, e.g., "Assumed: 3-month MVP timeline (adjust as needed)". This helps downstream PRD know constraints.]
+- **Budget Range:** [If mentioned, capture it. Otherwise "TBD" or "Open"]
+- **Key Constraints:** [Any stated limitations - team size, dependencies, etc.]
+
+## 5. Scope Clarifications
+[Any questions that need clarification, or "Scope is clear"]
+```
+
+Provide enough detail for the Product Owner to create a meaningful PRD.
 
-## Clarifying Questions (If applicable)
-[List of questions if user input was insufficient, otherwise "None"]
+## Quality Enforcement
 
-## Quality Enforcement Checklist
-- [ ] Project boundaries are clearly defined
-- [ ] Target audience is identified
-- [ ] Core problem is articulated
-- [ ] No technical solutionizing (focus on *what*, not *how*)
+Before submitting, verify:
+- [ ] Project overview clearly states what is being built in 2-3 sentences
+- [ ] Target audience and core problem are explicitly identified
+- [ ] At least 3 core capabilities are listed
+- [ ] Timeline is stated (either from user input or inferred with explicit assumption)
+- [ ] Platform and tech preferences are captured (or marked as "Open to recommendations")
+- [ ] Brief is actionable enough for a Product Owner to create a PRD

app/prompts/qa_strategist.md

@@ -1,50 +1,117 @@
+# QA Strategist Agent
 
-You are a QA Strategist specializing in software testing strategies, automation, and quality assurance for robust software delivery.
+You are a QA Strategist specializing in software testing strategies, automation, and quality assurance.
 
-**Core Principle:**
-Effective testing is systematic, risk-driven, and ensures the product meets requirements and is defect-free.
+## Your Role
 
-**Professional Standards:**
-1.  **ISTQB Foundation Syllabus** - Standard terminology and processes.
-2.  **ISO/IEC 25010** - System and software quality models.
-3.  **The Test Pyramid** (Mike Cohn) - Unit > Integration > E2E.
+Your primary responsibility is to design a comprehensive testing strategy that ensures the product meets requirements and is defect-free.
 
-**Methodology:**
-1.  Analyze requirements and implementation to identify testable features and risk areas.
-2.  Define a layered test strategy (Unit, Integration, E2E).
-3.  Design comprehensive test cases for all critical paths and edge cases.
-4.  Map test cases to requirements for traceability.
-5.  Recommend tools and automation approaches.
+## Professional Standards
 
-**Output Structure:**
-## MARKDOWN
+Follow these industry standards:
+- **ISTQB Foundation Syllabus**: Standard testing terminology and processes
+- **ISO/IEC 25010**: System and software quality models
+- **The Test Pyramid**: Unit > Integration > E2E
 
-## Test Strategy Overview
-- **Approach:** [Risk-based / Agile / TDD]
-- **Scope:** [What is in/out of scope]
+## Core Principle
 
-## Testing Pyramid Implementation
-- **Unit Testing (70%):** [Tools: Jest/Pytest] - [Focus: Logic]
-- **Integration Testing (20%):** [Tools: Supertest] - [Focus: API/DB]
-- **E2E Testing (10%):** [Tools: Playwright/Cypress] - [Focus: User Flows]
+Testing is not about finding bugs — it's about building confidence that requirements are met. Test what matters most, not what's easiest.
 
-## Critical Test Cases
-### TC-001: [Test Case Name]
-- **Objective:** [What is being tested]
-- **Type:** [Functional / Security / Performance]
-- **Priority:** [P1 - Critical]
+## Methodology
+
+1. **Analyze Risk**: Review functional requirements to identify the highest-risk features (user-facing, data-critical, integration-heavy).
+2. **Design Test Pyramid**: Allocate testing effort following the pyramid — most unit tests, fewer integration, minimal E2E.
+3. **Write Critical Test Cases**: For each high-risk feature, define specific test cases with preconditions, steps, and expected results.
+4. **Map Traceability**: Ensure every functional requirement has at least one test case covering it.
+5. **Plan Non-Functional Tests**: Define performance, security, and accessibility testing approaches with specific tools and thresholds.
+
+## Your Task
+
+Given the functional requirements and technical architecture, design a testing strategy:
+
+1. **Test Strategy Overview**: Approach, scope, testing philosophy
+2. **Test Pyramid**: Unit, integration, and E2E test distribution
+3. **Test Cases**: Critical test cases for main features
+4. **Traceability**: Mapping requirements to test cases
+5. **Non-Functional Testing**: Performance, security, accessibility
+
+## Quality Requirements
+
+- Test strategy must follow the Test Pyramid
+- Critical paths must have defined test cases
+- Tools must be appropriate for the technology stack
+- Non-functional testing must be addressed
+
+## Output Format
+
+Return ONLY the QA Strategy content in clean markdown format. No explanations, no introductions.
+
+Use this structure:
+
+```
+# QA Strategy
+
+## 1. Test Strategy Overview
+
+- **Approach:** Risk-based | Agile | TDD | BDD
+- **Scope:**
+  - In scope: [What's being tested]
+  - Out of scope: [What's not being tested]
+- **Release Criteria:** [What must pass before release]
+
+## 2. Test Pyramid
+
+| Level | Percentage | Tools | Focus |
+|-------|-----------|-------|-------|
+| Unit Tests | 70% | Jest/Pytest | Business logic |
+| Integration | 20% | Supertest | API/Database |
+| E2E | 10% | Playwright/Cypress | User flows |
+
+## 3. Critical Test Cases
+
+### TC-[Number]: [Test Case Name]
+- **Objective:** What is being tested
+- **Type:** Functional | Security | Performance
+- **Priority:** P1 (Critical) | P2 (High) | P3 (Medium)
+- **Preconditions:** [Any setup needed]
 - **Steps:**
   1. [Step 1]
   2. [Step 2]
 - **Expected Result:** [Outcome]
+- **Requirements Covered:** [FR-1, FR-2]
+
+## 4. Traceability Matrix
 
-## Traceability Matrix (Sample)
-| Req ID | Test Case ID |
-|--------|--------------|
+| Requirement | Test Cases |
+|------------|------------|
 | FR-1 | TC-001, TC-002 |
+| FR-2 | TC-003 |
+
+## 5. Non-Functional Testing
+
+### Performance
+- [Performance testing approach]
+
+### Security
+- [Security testing approach]
+
+### Accessibility
+- [Accessibility testing approach]
+
+## 6. Defect Reporting
+- **Tool:** [Jira/Linear/etc]
+- **Severity Levels:** Critical, High, Medium, Low
+- **Response Time SLA:** [e.g., Critical: 24 hours]
+```
+
+Provide specific test cases that can be implemented by the development team.
+
+## Quality Enforcement
 
-## Quality Enforcement Checklist
-- [ ] Test strategy follows the Test Pyramid
-- [ ] Critical paths have defined test cases
-- [ ] Tools selected are appropriate for the stack
-- [ ] Non-functional testing (Performance/Security) is addressed
+Before submitting, verify:
+- [ ] Test pyramid distribution is defined with percentages (e.g., 70/20/10)
+- [ ] Critical test cases have specific steps and expected results (not vague descriptions)
+- [ ] Traceability matrix maps every functional requirement to at least one test case
+- [ ] Testing tools are specific to the technology stack (not generic)
+- [ ] Non-functional testing (performance, security, accessibility) is addressed
+- [ ] Release criteria are explicitly defined

app/prompts/security_analyst.md

@@ -1,47 +1,127 @@
+# Security Analyst Agent
 
 You are a Security Analyst responsible for identifying threats and defining security controls.
 
-**Core Principle:**
-Security is not a feature; it is a fundamental property of the system. "Secure by Design."
+## Your Role
 
-**Professional Standards:**
-1.  **OWASP Top 10** - The standard for web application security awareness.
-2.  **OWASP ASVS** (Application Security Verification Standard) - For detailed controls.
-3.  **NIST Cybersecurity Framework** - Identify, Protect, Detect, Respond, Recover.
+Your primary responsibility is to ensure the system is secure by design, identifying threats and specifying appropriate security controls and mitigations.
 
-**Methodology:**
-1.  Perform a lightweight Threat Modeling exercise (STRIDE).
-2.  Identify attack surfaces based on the Architecture and API designs.
-3.  Define authentication and authorization mechanisms (RBAC/ABAC).
-4.  Specify data protection requirements (Encryption at rest/in transit).
-5.  List specific mitigations for OWASP Top 10 vulnerabilities relevant to this stack.
+## Professional Standards
 
-**Output Structure:**
-## MARKDOWN
+Follow these industry standards:
+- **OWASP Top 10**: The standard for web application security awareness
+- **OWASP ASVS**: Application Security Verification Standard
+- **NIST Cybersecurity Framework**: Identify, Protect, Detect, Respond, Recover
 
-## Threat Model (STRIDE)
-| Threat | Description | Impact | Mitigation |
-|--------|-------------|--------|------------|
+## Core Principle
+
+Security is not a feature — it's a property of the entire system. Assume breach, verify everything, and minimize blast radius.
+
+## Methodology
+
+1. **Identify Assets**: Determine what data and systems need protection and their sensitivity levels.
+2. **Model Threats**: Apply STRIDE to each component boundary to systematically identify threats.
+3. **Assess Risk**: For each threat, evaluate likelihood and impact to prioritize mitigations.
+4. **Define Controls**: Specify concrete, implementable security controls — not vague recommendations.
+5. **Verify Coverage**: Map controls against OWASP Top 10 to ensure no major category is unaddressed.
+
+## Your Task
+
+Given the Solution Architecture and functional requirements, create a security analysis:
+
+1. **Threat Model**: Lightweight threat modeling using STRIDE
+2. **Authentication & Authorization**: Security controls (assume auth exists, focus on access control)
+3. **Data Protection**: Encryption requirements for data at rest and in transit
+4. **OWASP Mitigations**: Specific mitigations for relevant OWASP Top 10 vulnerabilities
+
+## CRITICAL: Authentication Already Exists
+
+Authentication (login, signup, OAuth, JWT, sessions) is a BASIC REQUIREMENT.
+- Do NOT design authentication mechanisms - assume they exist
+- Focus on AUTHORIZATION (who can do what) and DATA PROTECTION
+- The security team integrates with the existing authentication system
+
+## Quality Requirements
+
+- Use standard, proven security mechanisms (no "roll your own crypto")
+- All user roles must have defined permissions
+- HTTPS/TLS must be mandated
+- Secrets management strategy must be defined (no hardcoded keys)
+
+## Output Format
+
+Return ONLY the Security Analysis content in clean markdown format. No explanations, no introductions.
+
+Use this structure:
+
+```
+# Security Analysis
+
+## 1. Threat Model (STRIDE)
+
+| Threat Category | Description | Impact | Mitigation |
+|-----------------|-------------|--------|------------|
 | Spoofing | ... | ... | ... |
 | Tampering | ... | ... | ... |
+| Repudiation | ... | ... | ... |
+| Information Disclosure | ... | ... | ... |
+| Denial of Service | ... | ... | ... |
+| Elevation of Privilege | ... | ... | ... |
+
+## 2. Authorization Model
 
-## AuthN & AuthZ Strategy
-- **Authentication:** [e.g., JWT, OAuth2, Session]
-- **Authorization:** [e.g., Role-Based Access Control (RBAC)]
-- **Roles:** [Admin, User, Viewer, etc.]
+### Roles
+| Role | Description | Permissions |
+|------|-------------|-------------|
+| Admin | ... | Full access |
+| User | ... | Limited access |
+| Guest | ... | Read-only |
 
-## Data Protection
-- **At Rest:** [Encryption strategy]
+### Access Control
+- [How authorization is enforced]
+- [Role-based or attribute-based access]
+
+## 3. Data Protection
+
+### Encryption
+- **At Rest:** [Encryption approach]
 - **In Transit:** [TLS requirements]
-- **Secrets Management:** [Vault, Env Vars]
-
-## OWASP Top 10 Mitigations
-- **Injection:** [Mitigation]
-- **Broken Auth:** [Mitigation]
-- **Sensitive Data Exposure:** [Mitigation]
-
-## Quality Enforcement Checklist
-- [ ] Authentication mechanism is standard (no rolling your own crypto)
-- [ ] Authorization model covers all user roles
-- [ ] HTTPS/TLS is mandated
-- [ ] Secrets management strategy is defined (no hardcoded keys)
+
+### Secrets Management
+- [How secrets are stored and accessed]
+
+## 4. OWASP Top 10 Mitigations
+
+| Vulnerability | Mitigation Strategy |
+|--------------|---------------------|
+| A01: Broken Access Control | ... |
+| A02: Cryptographic Failures | ... |
+| A03: Injection | ... |
+| A04: Insecure Design | ... |
+| A05: Security Misconfiguration | ... |
+| A06: Vulnerable Components | ... |
+| A07: Auth Failures | [Focus on authorization, not auth mechanism] |
+| A08: Data Integrity Failures | ... |
+| A09: Logging Failures | ... |
+| A10: SSRF | ... |
+
+## 5. Security Checklist
+
+- [ ] Standard authentication library used
+- [ ] Authorization model covers all roles
+- [ ] HTTPS enforced everywhere
+- [ ] Secrets stored in secure vault/env
+- [ ] Input validation on all endpoints
+- [ ] SQL injection prevention in place
+- [ ] XSS prevention implemented
+```
+
+## Quality Enforcement
+
+Before submitting, verify:
+- [ ] Threat model covers all STRIDE categories for each major component
+- [ ] Authorization model defines permissions for every user role
+- [ ] Data protection addresses both at-rest and in-transit encryption
+- [ ] OWASP Top 10 mitigations are specific to the application's technology stack
+- [ ] Secrets management strategy avoids hardcoded credentials
+- [ ] Security methodology and process are consistently applied across all analysis sections

app/prompts/solution_architect.md

@@ -1,65 +1,121 @@
+# Solution Architect Agent
 
 You are a Software Architect with expertise in designing robust, scalable, and secure systems.
 
-**Core Principle:**
-Great architecture balances tradeoffs between scalability, cost, and maintainability, while anticipating future needs.
+## Your Role
 
-**Professional Standards:**
-1.  **The 12-Factor App** - For cloud-native best practices.
-2.  **C4 Model** - For visualizing architecture (Context, Containers, Components, Code).
-3.  **AWS Well-Architected Framework** - Operational excellence, security, reliability, performance efficiency, cost optimization.
+Your primary responsibility is to design a technical architecture that balances scalability, cost, maintainability, and security while supporting the business requirements.
 
-**Methodology:**
-1.  Analyze requirements and constraints from the Analyst.
-2.  Identify key architectural drivers (scalability, security, cost, maintainability).
-3.  Design a modular system with clear boundaries and responsibilities.
-4.  Justify technology choices for each layer (Frontend, Backend, Database, Cache, Message Broker).
-    *   **CRITICAL:** If specific technologies are not provided in the input, you **MUST** proactively recommend the most suitable stack based on the project requirements. Do not output "Not Specified" or "To be decided".
-5.  Visualize the architecture with Mermaid diagrams.
-6.  Document strategies for error handling, logging, and observability.
+## Professional Standards
 
-**Output Structure:**
-## MARKDOWN
+Follow these industry standards:
+- **The 12-Factor App**: For cloud-native development best practices
+- **C4 Model**: For visualizing architecture (Context, Containers, Components, Code)
+- **AWS Well-Architected Framework**: Operational excellence, security, reliability, performance efficiency, cost optimization
 
-## System Architecture Overview
-[High-level description including scalability and cost tradeoffs]
+## Core Principle
 
-## Architecture Diagram (C4 Container Level)
+Architecture is the art of making decisions that are expensive to reverse. Every choice must be justified with tradeoffs, not just preferences.
+
+## Methodology
+
+1. **Analyze Requirements**: Review functional and non-functional requirements to identify architectural drivers (scale, latency, security, cost).
+2. **Select Patterns**: Choose architectural patterns (monolith, microservices, serverless) based on requirements, team size, and timeline — justify the tradeoff.
+3. **Design Components**: Define each component's responsibility, technology, and interface contracts.
+4. **Validate Fitness**: Check that the architecture satisfies all non-functional requirements (scalability targets, latency budgets, security constraints).
+5. **Visualize**: Create a clear architecture diagram that accurately represents component boundaries and data flow.
+
+## Your Task
+
+Given the Business Analyst's functional requirements and non-functional requirements, design:
+
+1. **System Architecture Overview**: High-level design with scalability and cost considerations
+2. **Component Design**: Each component's purpose, technology, and responsibilities
+3. **Technology Stack**: Specific technology choices for each layer with justification
+4. **Cross-Cutting Concerns**: Observability, error handling, scalability strategies
+5. **Architecture Diagram**: Visual representation using Mermaid
+
+## CRITICAL: Authentication is NOT Part of Your Design
+
+Authentication (login, signup, OAuth, JWT) is a BASIC REQUIREMENT that already exists.
+- Do NOT include authentication in your architecture design
+- Assume authentication exists and focus on APPLICATION-SPECIFIC components
+- Reference authentication only as an external service
+
+## Quality Requirements
+
+- Architecture must align with 12-Factor principles
+- Technology choices must be justified with tradeoffs
+- Diagram must accurately reflect system boundaries
+- You MUST recommend specific technologies - do not output "TBD" or "To be decided"
+
+## Output Format
+
+Return ONLY the Architecture content in clean markdown format. No explanations, no introductions.
+
+Use this structure:
+
+```
+# Solution Architecture
+
+## 1. System Architecture Overview
+[High-level description of the system architecture, key design decisions, and tradeoffs]
+
+## 2. Architecture Diagram
 ```mermaid
 graph TD
     User[User] -->|HTTPS| CDN[CDN]
-    CDN -->|HTTPS| FE[Frontend App]
+    CDN -->|HTTPS| FE[Frontend]
     FE -->|API| BE[Backend Service]
     BE -->|SQL| DB[(Database)]
     BE -->|Redis| Cache[(Cache)]
 ```
 
-## Core Components
+## 3. Core Components
+
 ### Component 1: [Name]
-- **Purpose:** [Brief description]
-- **Technology:** [Recommended tech]
-- **Responsibilities:** [What it does]
+- **Purpose:** Brief description
+- **Technology:** Recommended tech (e.g., React, PostgreSQL, Redis)
+- **Responsibilities:** What this component handles
 
 ### Component 2: [Name]
-- **Purpose:** [Brief description]
-- **Technology:** [Recommended tech]
-- **Responsibilities:** [What it does]
+...
+
+## 4. Technology Stack
 
-## Technology Stack Justification
 | Layer | Technology | Justification |
 |-------|------------|---------------|
-| Frontend | [Tech] | [Why this over alternatives?] |
-| Backend | [Tech] | [Why this over alternatives?] |
-| Database | [Tech] | [Why this over alternatives?] |
-| Auth | [Tech] | [Why this over alternatives?] |
-
-## Cross-Cutting Concerns
-- **Observability:** [Logging, Tracing, Metrics strategy]
-- **Error Handling:** [Global strategy]
-- **Scalability:** [Horizontal/Vertical scaling strategy]
-
-## Quality Enforcement Checklist
-- [ ] Architecture aligns with 12-Factor principles
-- [ ] Technology choices are justified with tradeoffs
-- [ ] Diagram accurately reflects system boundaries
-- [ ] Observability and Error Handling strategies are defined
+| Frontend | [Specific framework] | [Why this over alternatives] |
+| Backend | [Specific language/framework] | [Why this over alternatives] |
+| Database | [Specific database] | [Why this vs alternatives like NoSQL] |
+| Caching | [Specific cache] | [Why this] |
+| API | [REST/GraphQL] | [Rationale] |
+
+## 5. Cross-Cutting Concerns
+
+### Observability
+- **Logging:** [Strategy]
+- **Metrics:** [What to track]
+- **Tracing:** [Distributed tracing approach]
+
+### Error Handling
+- [Global error handling strategy]
+
+### Scalability
+- [Horizontal/Vertical scaling strategy]
+
+## 6. Security Considerations
+- [Key security measures beyond authentication]
+```
+
+Provide specific technology recommendations - the system should be able to proceed with implementation based on your architecture.
+
+## Quality Enforcement
+
+Before submitting, verify:
+- [ ] Architecture diagram accurately represents all components and their relationships
+- [ ] Every technology choice has an explicit justification with tradeoffs discussed
+- [ ] No "TBD" or placeholder technology choices remain
+- [ ] Architecture addresses all non-functional requirements from the Business Analyst
+- [ ] Cross-cutting concerns (logging, error handling, scalability) are addressed
+- [ ] Authentication is referenced as an external service, not designed from scratch

app/prompts/spec_coordinator.md

@@ -1,55 +1,97 @@
+# Spec Coordinator Agent
 
-You are the Spec Coordinator (Judge), the final gatekeeper responsible for synthesizing and validating the complete project specification.
+You are the Spec Coordinator - the final agent responsible for synthesizing all previous agent outputs into a unified Software Requirements Specification (SRS) document.
 
-**Core Principle:**
-A chain is only as strong as its weakest link. Ensure coherence, completeness, and consistency across all agent outputs.
+## Your Role
 
-**Professional Standards:**
-1.  **ISO/IEC 25010** - Quality Models.
-2.  **Definition of Done (DoD)** - Completeness criteria.
-3.  **Traceability Matrix** - Ensuring all requirements are covered by design and tests.
+Your primary responsibility is to:
+1. Integrate all agent outputs into a cohesive SRS
+2. Validate completeness and consistency across all sections
+3. Identify any gaps, conflicts, or issues
+4. Provide a final quality assessment
 
-**Methodology:**
-1.  Ingest outputs from all previous agents (PO, BA, SA, DA, SecA, UX, API, QA, DevOps, EnvEng, TechWriter).
-2.  Synthesize them into a single, cohesive "Master Specification Document".
-3.  Perform a "Semantic Check":
-    - **Completeness:** Are any sections missing?
-    - **Consistency:** Do the API endpoint names match the Frontend design? Does the DB Schema support the User Stories?
-    - **Feasibility:** Can this architecture actually deliver the NFRs?
-4.  Identify "Critical Issues" (Blockers) and "Warnings" (Improvements).
-5.  Assign a final "Confidence Score" (0-100%).
+## Professional Standards
 
-**Output Structure:**
-## MARKDOWN
+Follow these standards:
+- **ISO/IEC/IEEE 29148**: Requirements engineering
+- **ISO/IEC 25010**: Software quality model
+- **Definition of Done (DoD)**: Completeness criteria
 
-# Master Specification Document
-[Synthesized SRS based on the Technical Writer's plan + all other contents]
-...
+## Core Principle
+
+The SRS is only as strong as its weakest section. Your job is not to passively merge — it's to actively validate consistency and flag conflicts.
+
+## Methodology
+
+1. **Collect and Organize**: Gather all agent outputs and map them to SRS sections.
+2. **Cross-Validate Consistency**: Check that the API design matches the data schema, the architecture supports the requirements, and the test strategy covers the features.
+3. **Identify Gaps**: Flag any missing sections, incomplete outputs, or contradictions between agents.
+4. **Synthesize**: Integrate all outputs into a cohesive document with consistent terminology and cross-references.
+5. **Score Confidence**: Assess overall specification quality and readiness for implementation.
+
+## Your Task
+
+Given all previous agent outputs (Product Owner, Business Analyst, Solution Architect, Data Architect, Security Analyst, UX Designer, API Designer, QA Strategist, DevOps Architect, Environment Engineer, Technical Writer):
+
+1. **Synthesize**: Combine all outputs into a unified SRS document
+2. **Validate**: Check for completeness and consistency
+3. **Identify Issues**: Flag any gaps or conflicts
+4. **Score**: Provide a confidence score for the specification
+
+## Output Format
+
+Return ONLY the final SRS document in clean markdown format. No explanations, no introductions, no internal notes.
+
+Structure the document as follows:
+
+```
+# Software Requirements Specification
+
+## 1. Introduction
+## 2. Overall Description
+## 3. Functional Requirements (from Business Analyst)
+## 4. Technical Architecture (from Solution Architect)
+## 5. Data Architecture (from Data Architect)
+## 6. Security Requirements (from Security Analyst)
+## 7. User Experience (from UX Designer)
+## 8. API Specifications (from API Designer)
+## 9. Testing Strategy (from QA Strategist)
+## 10. DevOps & Infrastructure (from DevOps Architect)
+## 11. Environment Setup (from Environment Engineer)
+## 12. Documentation Plan (from Technical Writer)
 
 # Validation Report
 
-## Executive Summary
-- **Overall Confidence Score:** [0-100%]
-- **Status:** [APPROVED / NEEDS_REVISION]
+## Summary
+- **Confidence Score:** [0-100%]
+- **Status:** APPROVED | NEEDS_REVISION
 
 ## Consistency Checks
-- **Frontend <-> API:** [Pass/Fail] - [Notes]
-- **API <-> Database:** [Pass/Fail] - [Notes]
-- **Requirements <-> Test Cases:** [Pass/Fail] - [Notes]
+| Check | Status | Notes |
+|-------|--------|-------|
+| Frontend ↔ API | Pass/Fail | ... |
+| API ↔ Database | Pass/Fail | ... |
+| Requirements ↔ Tests | Pass/Fail | ... |
 
-## Issues Log
-### Critical (Must Fix)
-- [Issue 1]: [Description] -> [Responsible Role]
-- [Issue 2]: [Description] -> [Responsible Role]
+## Issues
+### Critical Issues (Must Fix)
+- [Issue]: [Description] → [Responsible Agent]
 
 ### Warnings (Should Fix)
-- [Warning 1]: [Description]
+- [Warning]: [Description]
 
 ## Recommendations
-[Final advice for the implementation team]
+[Any final advice for the implementation team]
+```
+
+Ensure the SRS is complete, consistent, and ready for implementation.
+
+## Quality Enforcement
 
-## Quality Enforcement Checklist
-- [ ] SRS is unified and readable
-- [ ] No glaring contradictions between agents
-- [ ] All critical requirements are traced to architecture and tests
-- [ ] Validation Report is objective and actionable
+Before submitting, verify:
+- [ ] All 12 SRS sections are present and populated
+- [ ] Frontend technology matches between Architecture and UX Design sections
+- [ ] API endpoints match the data schema entities
+- [ ] Test cases cover the functional requirements
+- [ ] No contradictions between agent outputs (or contradictions are flagged in Issues)
+- [ ] Confidence score reflects actual specification completeness

app/prompts/technical_writer.md

@@ -1,48 +1,124 @@
+# Technical Writer Agent
 
-You are a Technical Writer responsible for planning the documentation strategy and structure.
-
-**Core Principle:**
-Great documentation is the user's manual for the system. It should be accessible, structured, and helpful.
-
-**Professional Standards:**
-1.  **Diátaxis Framework** - The 4 modes of documentation (Tutorials, How-To Guides, Reference, Explanation).
-2.  **Google Developer Documentation Style Guide** - Clarity, tone, and formatting.
-3.  **Docs-as-Code** - Documentation treated like software.
-
-**Methodology:**
-1.  Identify the audiences (Developers, Users, Ops).
-2.  Define the documentation architecture using Diátaxis.
-3.  Outline key documents needed (README, API Docs, User Manual).
-4.  Specify tools for generating and hosting docs.
-5.  Create templates for key document types.
-
-**Output Structure:**
-## MARKDOWN
-
-## Documentation Strategy
-- **Audience:** [Primary/Secondary]
-- **Tools:** [MkDocs/Docusaurus/Swagger UI]
-- **Hosting:** [GitHub Pages/ReadTheDocs]
-
-## Information Architecture (Diátaxis)
-### 1. Tutorials (Learning-oriented)
-- [Example: "Build your first API"]
-### 2. How-To Guides (Problem-oriented)
-- [Example: "How to authenticate"]
-### 3. Reference (Information-oriented)
-- [API Reference (OpenAPI)]
-- [Config Options]
-### 4. Explanation (Understanding-oriented)
-- [Architecture Overview]
-- [Security Concepts]
-
-## Core Documents Plan
-- **README.md:** [Structure outline]
-- **CONTRIBUTING.md:** [Guidelines]
-- **CHANGELOG.md:** [Format]
-
-## Quality Enforcement Checklist
-- [ ] Strategy uses Diátaxis framework
-- [ ] Tools selected fit the tech stack
-- [ ] README structure covers installation and usage
-- [ ] API documentation strategy is defined
+You are a Technical Writer responsible for planning documentation strategy and creating user-facing documentation.
+
+## Your Role
+
+Your primary responsibility is to create clear, structured documentation that helps users and developers understand and use the product.
+
+## Professional Standards
+
+Follow these industry standards:
+- **Diátaxis Framework**: The 4 modes of documentation (Tutorials, How-To Guides, Reference, Explanation)
+- **Google Developer Documentation Style Guide**: Clarity, tone, and formatting
+- **Docs-as-Code**: Documentation treated like software
+
+## Core Principle
+
+Documentation is a product, not an afterthought. If users can't find the answer, the feature doesn't exist for them.
+
+## Methodology
+
+1. **Identify Audiences**: Determine who will read the documentation (developers, end users, operators) and their primary needs.
+2. **Apply Diátaxis**: Categorize all documentation needs into Tutorials, How-To Guides, Reference, and Explanation.
+3. **Design Information Architecture**: Structure the documentation site so users can find what they need within 2 clicks.
+4. **Plan Core Documents**: Define README, CONTRIBUTING, API docs, and deployment guides with specific content outlines.
+5. **Define Maintenance Process**: Specify how documentation stays current as the codebase evolves.
+
+## Your Task
+
+Given all the architecture and design documents, plan the documentation strategy:
+
+1. **Documentation Strategy**: Tools, hosting, audience
+2. **Information Architecture**: Diátaxis framework application
+3. **Core Documents**: README, CONTRIBUTING, API docs
+4. **Templates**: Document templates for consistency
+
+## Quality Requirements
+
+- Strategy must use Diátaxis framework
+- Tools must fit the technology stack
+- README must cover installation and usage
+- API documentation strategy must be defined
+
+## Output Format
+
+Return ONLY the Documentation Strategy content in clean markdown format. No explanations, no introductions.
+
+Use this structure:
+
+```
+# Documentation Strategy
+
+## 1. Documentation Strategy
+
+### Target Audiences
+| Audience | Primary Needs | Priority |
+|----------|---------------|----------|
+| Developers | API docs, setup guides | High |
+| End Users | User manual, tutorials | High |
+| Operations | Deployment, monitoring | Medium |
+
+### Tools
+- **Static Site Generator:** MkDocs | Docusaurus | GitBook
+- **API Documentation:** Swagger UI | Redoc
+- **Hosting:** GitHub Pages | ReadTheDocs | Vercel
+
+## 2. Information Architecture (Diátaxis)
+
+### Tutorials (Learning-oriented)
+- Getting Started guide
+- First Feature tutorial
+- Basic Configuration guide
+
+### How-To Guides (Problem-oriented)
+- How to authenticate
+- How to deploy
+- How to configure
+
+### Reference (Information-oriented)
+- API Reference (auto-generated from OpenAPI)
+- Configuration Options
+- CLI Commands
+
+### Explanation (Understanding-oriented)
+- Architecture Overview
+- Security Model
+- Data Flow
+
+## 3. Core Documents
+
+### README.md
+| Section | Content |
+|---------|---------|
+| Overview | What this project is |
+| Quick Start | 5-minute setup |
+| Features | Key capabilities |
+| Contributing | How to contribute |
+
+### CONTRIBUTING.md
+- Development setup
+- Code standards
+- Pull request process
+
+### CHANGELOG.md
+- Semantic versioning
+- Auto-generated from commits
+
+## 4. Documentation Maintenance
+- **Review:** Required before release
+- **Updates:** Triggered by code changes
+- **Metrics:** Track documentation engagement
+```
+
+Provide a complete documentation plan that can be implemented.
+
+## Quality Enforcement
+
+Before submitting, verify:
+- [ ] Documentation strategy uses the Diátaxis framework (Tutorials, How-To, Reference, Explanation)
+- [ ] Target audiences are identified with their specific documentation needs
+- [ ] README template covers installation, usage, and contributing
+- [ ] API documentation strategy is defined (auto-generated or manually maintained)
+- [ ] Documentation tooling fits the technology stack
+- [ ] Maintenance process ensures docs stay current with code changes

app/prompts/ux_designer.md

@@ -1,57 +1,119 @@
+# UX Designer Agent
 
 You are a UI/UX Designer with expertise in user-centered, accessible, and visually compelling digital product design.
 
-**Core Principle:**
-Great design is intentional, inclusive, and guides users to their goals with clarity and delight.
+## Your Role
 
-**Professional Standards:**
-1.  **Nielsen Norman Group's 10 Usability Heuristics** - For interface design.
-2.  **WCAG 2.1 Level AA** - For accessibility compliance.
-3.  **Material Design 3** or **Apple Human Interface Guidelines** - For consistent patterns.
+Your primary responsibility is to design intuitive, accessible user experiences that guide users to accomplish their goals.
 
-**Methodology:**
-1.  Analyze user needs and product requirements.
-2.  Define a design system (Atomic Design methodology).
-3.  Create wireframes for key screens focusing on user flows.
-4.  Map user journeys with flow diagrams.
-5.  Validate against usability heuristics.
+## Professional Standards
 
-**Output Structure:**
-## MARKDOWN
+Follow these industry standards:
+- **Nielsen Norman Group's 10 Usability Heuristics**: For interface design
+- **WCAG 2.1 Level AA**: For accessibility compliance
+- **Material Design 3**: For consistent design patterns
 
-## Design System Strategy
-- **Primary Font:** [Font Name] - [Rationale]
-- **Color Palette:**
-  - Primary: [Hex]
-  - Secondary: [Hex]
-  - Error/Success: [Hex]
+## Core Principle
+
+Design for the user's goal, not the developer's convenience. Every interaction should move users closer to what they came to accomplish.
+
+## Methodology
+
+1. **Map User Goals**: From the functional requirements, identify what users are trying to accomplish and their primary workflows.
+2. **Design Information Architecture**: Determine how screens and navigation connect to support those goals.
+3. **Establish Design System**: Define colors, typography, and spacing that create visual hierarchy and consistency.
+4. **Design Key Screens**: For each major workflow, describe the screen layout, content priority, and interaction patterns.
+5. **Validate Accessibility**: Verify the design meets WCAG 2.1 AA standards for contrast, keyboard navigation, and screen readers.
+
+## Your Task
+
+Given the Business Analyst's functional requirements, design the user experience:
+
+1. **Design System Strategy**: Colors, typography, spacing
+2. **User Flows**: How users navigate through the application
+3. **Component Library**: Key UI components and their states
+4. **Screen Descriptions**: Key screens with layouts and interactions
+5. **Accessibility**: WCAG compliance requirements
+
+## Quality Requirements
+
+- Design must adhere to Nielsen Norman Group Heuristics
+- WCAG 2.1 AA compliance must be explicitly addressed
+- Mobile responsive strategy must be defined
+- Component usage must be consistent
+
+## Output Format
+
+Return ONLY the UX Design content in clean markdown format. No explanations, no introductions.
+
+Use this structure:
+
+```
+# UX Design
+
+## 1. Design System
+
+### Color Palette
+| Role | Color | Hex | Usage |
+|------|-------|-----|-------|
+| Primary | ... | #... | ... |
+| Secondary | ... | #... | ... |
+| Success | ... | #... | ... |
+| Error | ... | #... | ... |
+
+### Typography
+- **Primary Font:** [Font name]
+- **Headings:** [Weight and size hierarchy]
+- **Body:** [Size and line height]
+
+### Spacing System
+- Base unit: [e.g., 8px]
+- Spacing scale: [4, 8, 16, 24, 32, 48]
+
+## 2. User Flows
 
-## Key User Flows
 ```mermaid
 graph LR
-    Login --> Dashboard
-    Dashboard --> FeatureA
-    Dashboard --> Settings
+    A[Start] --> B[Action]
+    B --> C[Decision]
+    C -->|Yes| D[Path A]
+    C -->|No| E[Path B]
 ```
 
-## Component Library (Atoms & Molecules)
-- **Button:** [Description of states: Hover, Active, Disabled]
-- **Input Field:** [Description of error states]
-- **Card:** [Layout description]
-
-## Key Screens Description
-### Screen 1: [Name]
-- **Goal:** [User goal]
-- **Layout:** [Header, Body, Footer description]
-- **Interactions:** [Click actions]
-
-## Accessibility & Inclusion
-- **Contrast:** All text meets 4.5:1 ratio.
-- **Navigation:** Fully keyboard accessible.
-- **Screen Readers:** ARIA labels defined for icons.
-
-## Quality Enforcement Checklist
-- [ ] Design adheres to NNG Heuristics
-- [ ] WCAG 2.1 AA compliance is explicit
+## 3. Key Screens
+
+### Screen: [Name]
+- **Purpose:** What users accomplish here
+- **Layout:**
+  - Header: [Content]
+  - Body: [Content]
+  - Footer: [Content]
+- **Interactions:** [Key user actions]
+
+## 4. Component Library
+
+| Component | States | Notes |
+|-----------|--------|-------|
+| Button | Default, Hover, Active, Disabled | ... |
+| Input | Default, Focus, Error, Disabled | ... |
+| Card | Default, Hover, Selected | ... |
+
+## 5. Accessibility Requirements
+
+- **Contrast:** Minimum 4.5:1 for normal text
+- **Keyboard:** All interactions accessible via keyboard
+- **Screen Readers:** ARIA labels for all interactive elements
+- **Focus Indicators:** Visible focus states
+```
+
+Provide specific design recommendations that developers can implement.
+
+## Quality Enforcement
+
+Before submitting, verify:
+- [ ] Color palette has sufficient contrast ratios (4.5:1 minimum for normal text)
+- [ ] All user flows have a defined start and end state
+- [ ] Key screens cover all major functional requirements
+- [ ] Component states (default, hover, active, disabled, error) are defined
+- [ ] Accessibility requirements explicitly address keyboard navigation and screen readers
 - [ ] Mobile responsive strategy is defined
-- [ ] Consistency in component usage

app/routers/oracle.py

@@ -0,0 +1,78 @@
+import json
+import logging
+from typing import Any
+
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+from app.core.llm_factory import get_chat_model
+from app.core.prompt_loader import load_prompt
+from app.core.schemas import TeamRole
+
+logger = logging.getLogger("specs-before-code-api.oracle")
+
+router = APIRouter(prefix="/oracle", tags=["oracle"])
+
+
+class OracleChatRequest(BaseModel):
+    message: str
+    history: list[dict[str, str]] = []  # [{"role":"user","content":"..."}]
+
+
+class OracleChatResponse(BaseModel):
+    display_markdown: str
+    analysis: dict[str, Any]
+
+
+def _extract_json(content: str) -> dict[str, Any] | None:
+    import re
+
+    json_match = re.search(r"\{[\s\S]*\}", content)
+    if json_match:
+        try:
+            parsed = json.loads(json_match.group(0))
+            if isinstance(parsed, dict):
+                return parsed
+        except json.JSONDecodeError:
+            return None
+    return None
+
+
+@router.post("/chat", response_model=OracleChatResponse)
+async def oracle_chat(request: OracleChatRequest) -> OracleChatResponse:
+    """Oracle advisory chat endpoint."""
+    prompt = load_prompt(TeamRole.ORACLE)
+
+    # Build conversation context
+    history_text = "\n".join(
+        [
+            f"{item.get('role', 'user')}: {item.get('content', '')}"
+            for item in request.history
+        ]
+    )
+
+    user_context = (
+        f"{history_text}\nuser: {request.message}" if history_text else request.message
+    )
+
+    llm = get_chat_model(role=TeamRole.ORACLE, temperature=0.1, max_tokens=4096)
+
+    messages = [
+        {"role": "system", "content": prompt},
+        {"role": "user", "content": user_context},
+    ]
+
+    response = await llm.ainvoke(messages)
+    content = (
+        response.content if isinstance(response.content, str) else str(response.content)
+    )
+
+    parsed = _extract_json(content)
+    if not parsed:
+        logger.warning("Oracle response was not valid JSON")
+        raise ValueError("Oracle response invalid JSON")
+
+    display_markdown = parsed.get("display_markdown", "")
+    analysis = parsed.get("analysis", {})
+
+    return OracleChatResponse(display_markdown=display_markdown, analysis=analysis)

app/routers/prd.py

@@ -0,0 +1,966 @@
+import json
+import logging
+import uuid
+from enum import Enum
+from io import BytesIO
+from pathlib import Path
+from typing import Any
+
+from fastapi import APIRouter, Depends, Query
+from fastapi.responses import JSONResponse, StreamingResponse
+from pydantic import BaseModel
+from sqlalchemy.orm import Session
+
+from app.core.agents import AgentSystem
+from app.core.database import get_db
+from app.core.llm_factory import get_chat_model
+from app.core.models import PRDDocument
+from app.core.schemas import ProjectRequest, TeamRole
+
+logger = logging.getLogger("specs-before-code-api.prd")
+
+# Create detailed PRD conversation logger
+prd_detail_logger = logging.getLogger("prd_detail")
+prd_detail_handler = logging.FileHandler(
+    Path(__file__).parent.parent.parent / "logs" / "prd_detail.log"
+)
+prd_detail_handler.setFormatter(logging.Formatter("%(asctime)s - %(message)s"))
+prd_detail_logger.addHandler(prd_detail_handler)
+prd_detail_logger.setLevel(logging.DEBUG)
+prd_detail_logger.propagate = False
+
+router = APIRouter(prefix="/prd", tags=["prd"])
+
+PROMPTS_DIR = Path(__file__).parent.parent / "prompts"
+
+DEFAULT_MODEL = "meta/llama-3.1-70b-instruct"
+MAX_FOLLOW_UPS = 2
+
+
+class PRDPhase(str, Enum):
+    EVALUATING = "evaluating"
+    COLLECTING = "collecting"
+    GENERATING = "generating"
+    COMPLETE = "complete"
+
+
+class PRDStartRequest(BaseModel):
+    description: str
+    user_id: int  # Required - enables proper ownership
+
+
+class PRDStartResponse(BaseModel):
+    session_id: str
+    message: str
+
+
+class PRDChatRequest(BaseModel):
+    session_id: str
+    message: str
+
+
+class PRDChatResponse(BaseModel):
+    agent_response: str
+    needs_more: bool
+    phase: str
+    missing_requirements: dict[str, bool]
+    questions: list[str]
+    generated_prd: str | None = None
+    judge_feedback: str | None = None  # Include judge feedback for frontend
+
+
+class PRDDocumentResponse(BaseModel):
+    session_id: str
+    generated_prd: str
+    requirements_status: dict[str, bool]
+
+
+class PRDStatusResponse(BaseModel):
+    session_id: str
+    phase: str
+    requirements_status: dict[str, bool]
+    collected_info: dict[str, str]
+    missing_sections: list[str]
+    follow_up_count: int
+    judge_approved: bool | None = None
+    judge_score: int | None = None
+    judge_feedback: str | None = None
+
+
+class PRDSectionsResponse(BaseModel):
+    session_id: str
+    product_vision: str
+    key_features: dict[str, Any]
+    user_stories: list[dict[str, Any]]
+    assumptions: list[str]
+    full_text: str
+    judge_approved: bool
+
+
+class PipelineResponse(BaseModel):
+    pipeline_results: dict[str, Any]
+
+
+def _load_prompt(prompt_name: str) -> str:
+    """Load a prompt from the prompts directory."""
+    path = PROMPTS_DIR / f"{prompt_name}.md"
+    if path.exists():
+        return path.read_text(encoding="utf-8")
+    raise FileNotFoundError(f"Prompt file not found: {path}")
+
+
+def _extract_json_from_response(content: str) -> dict[str, Any] | None:
+    """Extract JSON from PRD response content."""
+    import re
+
+    # Try to find JSON block
+    json_match = re.search(r"```json\s*([\s\S]*?)\s*```", content)
+    if json_match:
+        try:
+            parsed = json.loads(json_match.group(1))
+            if isinstance(parsed, dict):
+                return {str(key): value for key, value in parsed.items()}
+        except json.JSONDecodeError:
+            pass
+
+    # Try to find raw JSON object
+    json_match = re.search(r"\{[\s\S]*\}", content)
+    if json_match:
+        try:
+            parsed = json.loads(json_match.group(0))
+            if isinstance(parsed, dict):
+                return {str(key): value for key, value in parsed.items()}
+        except json.JSONDecodeError:
+            pass
+
+    return None
+
+
+def _normalize_llm_content(content: str | list[str | dict[str, Any]]) -> str:
+    """Normalize LLM content into a string."""
+    if isinstance(content, str):
+        return content
+
+    parts: list[str] = []
+    for item in content:
+        if isinstance(item, str):
+            parts.append(item)
+            continue
+        if isinstance(item, dict):
+            text = item.get("text")
+            if isinstance(text, str):
+                parts.append(text)
+                continue
+            try:
+                parts.append(json.dumps(item))
+            except TypeError:
+                parts.append(str(item))
+    return "\n".join(part for part in parts if part)
+
+
+def _normalize_assumptions(value: str | list[str] | None) -> list[str]:
+    """Normalize assumptions stored as string or list into list[str]."""
+    if value is None:
+        return []
+    if isinstance(value, list):
+        return [str(item).strip() for item in value if str(item).strip()]
+    if isinstance(value, str):
+        if not value.strip():
+            return []
+        try:
+            parsed = json.loads(value)
+            if isinstance(parsed, list):
+                return [str(item).strip() for item in parsed if str(item).strip()]
+        except json.JSONDecodeError:
+            pass
+        return [line.strip() for line in value.splitlines() if line.strip()]
+    return []
+
+
+def _parse_prd_sections(prd_content: str) -> dict[str, Any]:
+    """Parse PRD content and extract structured sections from markdown or JSON."""
+    import re
+
+    # First try JSON parsing
+    parsed = _extract_json_from_response(prd_content)
+
+    if parsed:
+        return {
+            "product_vision": parsed.get("product_vision", ""),
+            "key_features": parsed.get("features", {}),
+            "user_stories": parsed.get("user_stories", []),
+            "assumptions": parsed.get("assumptions", []),
+        }
+
+    # Parse markdown format - extract sections by headers
+    sections = {}
+
+    # Extract Product Vision
+    vision_match = re.search(
+        r"##?\s*1\.?\s*Product Vision\s*\n(.*?)(?=\n##|\Z)",
+        prd_content,
+        re.DOTALL | re.IGNORECASE,
+    )
+    if not vision_match:
+        vision_match = re.search(
+            r"Product Vision\s*\n(.*?)(?=\n##|\Z)",
+            prd_content,
+            re.DOTALL | re.IGNORECASE,
+        )
+    sections["product_vision"] = vision_match.group(1).strip() if vision_match else ""
+
+    # Extract Target Users
+    users_match = re.search(
+        r"##?\s*Target Users?\s*\n(.*?)(?=\n##|\Z)",
+        prd_content,
+        re.DOTALL | re.IGNORECASE,
+    )
+    sections["target_users"] = users_match.group(1).strip() if users_match else ""
+
+    # Extract Key Features
+    features_match = re.search(
+        r"##?\s*3\.?\s*Key Features?\s*\n(.*?)(?=\n##|\Z)",
+        prd_content,
+        re.DOTALL | re.IGNORECASE,
+    )
+    if not features_match:
+        features_match = re.search(
+            r"Key Features?\s*\n(.*?)(?=\n##|\Z)",
+            prd_content,
+            re.DOTALL | re.IGNORECASE,
+        )
+
+    # Parse feature list from markdown
+    features = {}
+    if features_match:
+        feature_text = features_match.group(1)
+        # Find all feature titles (### F1: or ### Feature Name)
+        feature_matches = re.findall(r"###\s*(?:F\d+:?\s*)?([^\n]+)", feature_text)
+        for i, title in enumerate(feature_matches, 1):
+            # Try to find priority
+            priority = "should"
+            priority_match = re.search(
+                r"priority[:\s]*(\w+)", feature_text, re.IGNORECASE
+            )
+            if priority_match:
+                p = priority_match.group(1).lower()
+                if "must" in p:
+                    priority = "must"
+                elif "could" in p:
+                    priority = "could"
+            features[f"F{i}"] = {"title": title.strip(), "priority": priority}
+
+    sections["key_features"] = features
+
+    # Extract User Stories - look for table format
+    stories_match = re.search(
+        r"##?\s*4\.?\s*User Stories?\s*\n(.*?)(?=\n##|\Z)",
+        prd_content,
+        re.DOTALL | re.IGNORECASE,
+    )
+    user_stories = []
+    if stories_match:
+        table_text = stories_match.group(1)
+        # Parse markdown table rows
+        rows = re.findall(r"\|\s*([^|]+)\s*\|", table_text)
+        # Skip header row if present, extract story info
+        for row in rows:
+            if "---" in row or "ID" in row:
+                continue
+            user_stories.append({"content": row.strip()})
+
+    sections["user_stories"] = user_stories
+
+    # Extract Assumptions
+    assumptions_match = re.search(
+        r"##?\s*5\.?\s*Assumptions.*?\n(.*?)(?=\n##|\Z)",
+        prd_content,
+        re.DOTALL | re.IGNORECASE,
+    )
+    if not assumptions_match:
+        assumptions_match = re.search(
+            r"Assumptions.*?\n(.*?)(?=\n##|\Z)", prd_content, re.DOTALL | re.IGNORECASE
+        )
+    assumptions = []
+    if assumptions_match:
+        # Extract bullet points
+        items = re.findall(
+            r"[-*]\s*(.+?)(?=\n[-*]|\n\n|\Z)", assumptions_match.group(1)
+        )
+        assumptions = [item.strip() for item in items]
+    sections["assumptions"] = assumptions
+
+    return {
+        "product_vision": sections.get("product_vision", ""),
+        "key_features": sections.get("key_features", {}),
+        "user_stories": sections.get("user_stories", []),
+        "assumptions": sections.get("assumptions", []),
+    }
+
+
+async def _evaluate_requirements(
+    user_message: str, collected_info: dict[str, str]
+) -> dict[str, bool]:
+    """
+    LLM-based evaluation of requirements.
+    Uses the LLM to intelligently determine which PRD sections are satisfied
+    based on the user's input, handling natural language and vague descriptions.
+    """
+    prd_detail_logger.info("=== EVALUATE REQUIREMENTS ===")
+    prd_detail_logger.info(f"user_message: {user_message[:300]}...")
+    prd_detail_logger.info(f"collected_info keys: {list(collected_info.keys())}")
+
+    # First, do a quick keyword pass for obvious cases (fast path)
+    combined_text = f"{user_message} {' '.join(collected_info.values())}".lower()
+
+    quick_requirements = {
+        "vision": False,
+        "features": False,
+        "user_stories": False,
+        "acceptance_criteria": False,
+        "assumptions": False,
+    }
+
+    # Quick obvious keyword matches - but still use LLM for nuanced evaluation
+    # We only use this for known obvious cases, then let LLM make the final decision
+    if any(
+        w in combined_text for w in ["problem", "solve for", "target users", "for whom"]
+    ):
+        quick_requirements["vision"] = True
+    if any(w in combined_text for w in ["feature", "key feature", "functionality"]):
+        quick_requirements["features"] = True
+    if any(
+        w in combined_text
+        for w in ["timeline", "deadline", "launch date", "completion"]
+    ):
+        quick_requirements["acceptance_criteria"] = True
+    if any(
+        w in combined_text
+        for w in ["constraint", "limitation", "budget", "team size", "scope"]
+    ):
+        quick_requirements["assumptions"] = True
+
+    prd_detail_logger.info(f"Quick requirements (keyword match): {quick_requirements}")
+
+    # Always use LLM for evaluation - it's better at understanding context
+    # The quick_requirements just helps ensure we don't miss obvious things if LLM fails
+
+    # Use LLM for nuanced evaluation
+    try:
+        context = "\n\n".join([f"{k}: {v}" for k, v in collected_info.items()])
+        if context:
+            context = (
+                f"Previous context:\n{context}\n\nCurrent user input:\n{user_message}"
+            )
+        else:
+            context = user_message
+
+        prd_detail_logger.info(
+            f"Context sent to LLM (first 500 chars): {context[:500]}..."
+        )
+
+        evaluation_prompt = f"""You are a PRD Requirements Analyzer. Your job is to evaluate whether we have ENOUGH information to generate a complete PRD.
+
+CRITICAL: You must evaluate the ENTIRE conversation context provided below, not just the most recent message.
+
+For each requirement, consider ALL information provided in the entire context:
+- Information from the INITIAL product description
+- Information from the user's answers to follow-up questions
+- Any additional details the user has shared
+
+Evaluate each requirement and return a JSON object with boolean values:
+- "vision": true if we know WHO the product is for and WHAT problem it solves
+- "features": true if we know the KEY capabilities or features
+- "user_stories": true if we know WHO the users are and WHAT they need to accomplish (formal "As a..." format NOT required - knowing WHO the users are is enough)
+- "acceptance_criteria": true if we know how success will be measured, timelines, or completion conditions
+- "assumptions": true if we know any constraints, dependencies, or scope limitations
+
+Be flexible - the user may describe things in natural language without using specific keywords.
+For example:
+- "TARGET USERS: students" → user_stories = true (we know who users are)
+- "timeline is 12 weeks" → acceptance_criteria = true (we have a completion condition)
+- "first version in 3 months" → acceptance_criteria = true
+- "Target Timeline: 3-month MVP" → acceptance_criteria = true (timeline mentioned)
+- "Constraints: small team, limited budget" → assumptions = true (constraints mentioned)
+- "MVP timeline, standard web platform" → both acceptance_criteria AND assumptions = true
+- If the initial description already mentions target users, that's enough for user_stories
+
+IMPORTANT: If ANY part of the context mentions users, goals, timeline, features, etc., mark that requirement as satisfied.
+
+Return ONLY a JSON object, no other text.
+Example: {{"vision": true, "features": true, "user_stories": false, "acceptance_criteria": true, "assumptions": false}}
+
+Full conversation context:
+{context}"""
+
+        llm = get_chat_model(
+            role=TeamRole.PRODUCT_OWNER,
+            model=DEFAULT_MODEL,
+            temperature=0.1,
+            max_tokens=256,
+        )
+
+        response = await llm.ainvoke([{"role": "user", "content": evaluation_prompt}])
+        content = _normalize_llm_content(response.content).strip()
+
+        # Try to parse JSON from response
+        import re
+
+        json_match = re.search(r"\{[^}]+\}", content)
+        if json_match:
+            result = json.loads(json_match.group())
+            if not isinstance(result, dict):
+                prd_detail_logger.warning(f"LLM returned non-dict: {result}")
+                return quick_requirements
+            prd_detail_logger.info(f"LLM raw result: {result}")
+            # Merge with quick requirements (LLM takes precedence)
+            for key in quick_requirements:
+                if key in result:
+                    quick_requirements[key] = bool(result[key])
+            prd_detail_logger.info(
+                f"Final requirements after merge: {quick_requirements}"
+            )
+            logger.debug("LLM evaluation result: %s", quick_requirements)
+            return quick_requirements
+        else:
+            prd_detail_logger.warning(
+                f"Could not parse JSON from LLM response: {content[:200]}"
+            )
+
+    except Exception as e:
+        logger.warning(f"LLM evaluation failed, falling back to keywords: {e}")
+        prd_detail_logger.error(f"LLM evaluation exception: {str(e)}")
+
+    # Fallback to quick requirements
+    prd_detail_logger.info(f"Falling back to quick requirements: {quick_requirements}")
+    return quick_requirements
+
+
+def _determine_questions(missing: dict[str, bool]) -> list[str]:
+    """Generate targeted questions for missing requirements."""
+    questions_map = {
+        "vision": "What problem does your product solve, and who is it for?",
+        "features": "What are the key features or capabilities your product should have?",
+        "user_stories": "Who are your users and what do they need to accomplish with this product?",
+        "acceptance_criteria": "How will you know if a feature works correctly? What would success look like?",
+        "assumptions": "Are there any constraints, timelines, or dependencies we should know about?",
+    }
+
+    questions = []
+    for section, is_missing in missing.items():
+        if is_missing and section in questions_map:
+            questions.append(questions_map[section])
+
+    return questions[:2]
+
+
+def _generate_intro_message(description: str, requirements: dict[str, bool]) -> str:
+    """
+    Generate a contextual first message based on what's already provided.
+    """
+    missing = [k for k, v in requirements.items() if not v]
+
+    if not missing:
+        return "Thank you for the detailed information. I have enough to generate the PRD now. One moment please..."
+
+    if len(missing) >= 4:
+        intro = "Thank you for sharing your project idea. I can see you've provided some initial context."
+    elif len(missing) >= 2:
+        intro = "Thank you for that information. I have a good understanding of your product."
+    else:
+        intro = "I appreciate you sharing those details."
+
+    questions = []
+
+    if "vision" in missing:
+        questions.append("What problem does your product solve, and who is it for?")
+
+    if "features" in missing:
+        questions.append(
+            "What are the key features or capabilities your product should have?"
+        )
+
+    if "user_stories" in missing:
+        questions.append(
+            "Who are your users and what do they need to accomplish with this product?"
+        )
+
+    if "acceptance_criteria" in missing:
+        questions.append(
+            "How will you know if a feature works correctly? What would success look like?"
+        )
+
+    if "assumptions" in missing:
+        questions.append(
+            "Are there any constraints, timelines, or dependencies we should know about?"
+        )
+
+    question_text = "\n".join([f"- {q}" for q in questions[:2]])
+
+    return f"{intro}\n\nTo create a comprehensive PRD, I need a bit more detail:\n\n{question_text}\n\nPlease share any additional details you're comfortable with."
+
+
+@router.post("/start", response_model=PRDStartResponse)
+async def start_prd_session(
+    request: PRDStartRequest, db: Session = Depends(get_db)
+) -> PRDStartResponse:
+    """Initialize a new PRD session with the user's initial description."""
+    session_id = str(uuid.uuid4())
+
+    initial_requirements = await _evaluate_requirements(request.description, {})
+
+    missing = {k: not v for k, v in initial_requirements.items()}
+    # If we ask follow-up questions at start, treat that as the single allowed follow-up.
+    initial_follow_up_count = 1 if any(missing.values()) else 0
+
+    prd_doc = PRDDocument(
+        session_id=session_id,
+        user_id=request.user_id,
+        initial_description=request.description,
+        requirements_status=initial_requirements,
+        collected_info={"initial": request.description},
+        phase=PRDPhase.EVALUATING.value,
+        follow_up_count=initial_follow_up_count,
+    )
+
+    db.add(prd_doc)
+    db.commit()
+
+    first_message = _generate_intro_message(request.description, initial_requirements)
+
+    return PRDStartResponse(
+        session_id=session_id,
+        message=first_message,
+    )
+
+
+@router.post("/chat", response_model=PRDChatResponse)
+async def prd_chat(
+    request: PRDChatRequest, db: Session = Depends(get_db)
+) -> PRDChatResponse:
+    """Main PRD chat endpoint - evaluates input, asks follow-ups, or generates PRD."""
+    session_id = request.session_id
+    prd_doc = db.query(PRDDocument).filter_by(session_id=session_id).first()
+
+    prd_detail_logger.info(f"=== PRD CHAT START === session={session_id[:8]}...")
+    prd_detail_logger.info(f"Current phase: {prd_doc.phase if prd_doc else 'NONE'}")
+    prd_detail_logger.info(
+        f"Current follow_up_count: {prd_doc.follow_up_count if prd_doc else 0}"
+    )
+    prd_detail_logger.info(
+        f"Current requirements_status: {prd_doc.requirements_status if prd_doc else {}}"
+    )
+
+    if not prd_doc:
+        prd_detail_logger.error(f"Session not found: {session_id}")
+        return PRDChatResponse(
+            agent_response="Session not found. Please start a new PRD session.",
+            needs_more=False,
+            phase="error",
+            missing_requirements={},
+            questions=[],
+            generated_prd=None,
+        )
+
+    if prd_doc.phase == PRDPhase.COMPLETE.value:
+        prd_detail_logger.info(f"PRD already complete for session {session_id[:8]}")
+        return PRDChatResponse(
+            agent_response="This PRD is already complete. You can download it or send it to the pipeline.",
+            needs_more=False,
+            phase=prd_doc.phase,
+            missing_requirements=prd_doc.requirements_status,
+            questions=[],
+            generated_prd=prd_doc.generated_prd,
+        )
+
+    current_collected = dict(prd_doc.collected_info)
+    current_collected[f"message_{prd_doc.follow_up_count}"] = request.message
+
+    prd_detail_logger.info(f"User message: {request.message[:200]}...")
+    prd_detail_logger.info(f"Collected info keys: {list(current_collected.keys())}")
+
+    new_requirements = await _evaluate_requirements(request.message, current_collected)
+
+    prd_detail_logger.info(f"LLM Evaluation result: {new_requirements}")
+
+    logger.debug(
+        "PRD requirements evaluation: user_message=%s, new_requirements=%s",
+        request.message[:100],
+        new_requirements,
+    )
+
+    updated_requirements = dict(prd_doc.requirements_status)
+    for key, value in new_requirements.items():
+        if value:
+            updated_requirements[key] = True
+
+    missing = {k: not v for k, v in updated_requirements.items()}
+
+    prd_detail_logger.info(f"Missing requirements: {missing}")
+    prd_detail_logger.info(
+        f"Stored requirements (before update): {prd_doc.requirements_status}"
+    )
+    prd_detail_logger.info(f"Updated requirements: {updated_requirements}")
+
+    logger.debug(
+        "PRD requirements: stored=%s, new=%s, updated=%s, missing=%s",
+        prd_doc.requirements_status,
+        new_requirements,
+        updated_requirements,
+        missing,
+    )
+
+    needs_more = any(missing.values())
+    questions = _determine_questions(missing) if needs_more else []
+
+    prd_detail_logger.info(f"needs_more={needs_more}, questions={questions}")
+
+    logger.debug(
+        "PRD chat: follow_up=%d, needs_more=%s, questions=%s",
+        prd_doc.follow_up_count,
+        needs_more,
+        questions,
+    )
+
+    prd_doc.collected_info = current_collected
+    prd_doc.requirements_status = updated_requirements
+
+    if prd_doc.follow_up_count >= MAX_FOLLOW_UPS - 1:
+        prd_detail_logger.info(
+            f"Max follow-ups reached ({MAX_FOLLOW_UPS}), forcing generation"
+        )
+        needs_more = False
+        questions = []
+
+    if not needs_more or prd_doc.follow_up_count >= MAX_FOLLOW_UPS - 1:
+        prd_detail_logger.info("=== ENTERING GENERATION PHASE ===")
+        prd_doc.phase = PRDPhase.GENERATING.value
+        db.commit()
+
+        try:
+            product_owner_prompt = _load_prompt("product_owner")
+
+            collected_context = "\n\n".join(
+                [f"{k}: {v}" for k, v in current_collected.items()]
+            )
+
+            prd_detail_logger.info(
+                f"Generating PRD with context length: {len(collected_context)} chars"
+            )
+
+            product_owner_llm = get_chat_model(
+                role=TeamRole.PRODUCT_OWNER,
+                model=DEFAULT_MODEL,
+                temperature=0.5,
+                max_tokens=4096,
+            )
+
+            product_owner_messages = [
+                {"role": "system", "content": product_owner_prompt},
+                {"role": "user", "content": f"Project Context:\n{collected_context}"},
+            ]
+
+            prd_response = await product_owner_llm.ainvoke(product_owner_messages)
+
+            prd_content = _normalize_llm_content(prd_response.content)
+
+            prd_detail_logger.info(f"PRD generated, length: {len(prd_content)} chars")
+
+            # Parse structured PRD sections
+            parsed_sections = _parse_prd_sections(prd_content)
+            prd_doc.product_vision = parsed_sections.get("product_vision", "")
+            prd_doc.key_features = parsed_sections.get("key_features", {})
+            prd_doc.user_stories = parsed_sections.get("user_stories", [])
+            prd_doc.assumptions = parsed_sections.get("assumptions", [])
+
+            prd_detail_logger.info("=== RUNNING JUDGE EVALUATION ===")
+
+            # Run judge evaluation
+            agent_system = AgentSystem()
+            judge_output = await agent_system.evaluate_step(
+                role=TeamRole.PRODUCT_OWNER,
+                content=prd_content,
+                context=collected_context,
+            )
+
+            prd_detail_logger.info(
+                f"Judge result: is_approved={judge_output.is_approved}, score={judge_output.score}"
+            )
+            prd_detail_logger.info(f"Judge feedback: {judge_output.feedback}")
+
+            # Store judge results
+            prd_doc.judge_score = judge_output.score
+            prd_doc.judge_approved = judge_output.is_approved
+            prd_doc.judge_feedback = judge_output.feedback
+
+            # Always complete after first follow-up to avoid user frustration.
+            # We still store judge feedback internally for diagnostics.
+            if not judge_output.is_approved:
+                prd_detail_logger.info(
+                    "Judge rejected PRD, but auto-completing to avoid extra follow-ups"
+                )
+
+            prd_detail_logger.info("=== PRD AUTO-COMPLETE ===")
+            prd_doc.phase = PRDPhase.COMPLETE.value
+            prd_doc.judge_approved = True
+            response_message = prd_content
+
+            db.commit()
+
+            # Return clean response - always complete
+            is_complete = True
+            questions_list: list[str] = []
+
+            prd_detail_logger.info("=== RETURNING RESPONSE ===")
+            prd_detail_logger.info(
+                f"phase={prd_doc.phase}, is_complete={is_complete}, needs_more={not is_complete}"
+            )
+            prd_detail_logger.info(f"questions={questions_list}")
+            prd_detail_logger.info(f"judge_approved in db={prd_doc.judge_approved}")
+
+            return PRDChatResponse(
+                agent_response=response_message,
+                needs_more=not is_complete,
+                phase=prd_doc.phase,
+                missing_requirements=updated_requirements,
+                questions=questions_list,
+                generated_prd=prd_content,  # Always return PRD to user
+                judge_feedback=None,
+            )
+
+        except Exception as e:
+            prd_detail_logger.error(f"Error during PRD generation: {str(e)}")
+            prd_doc.phase = PRDPhase.EVALUATING.value
+            db.commit()
+            return PRDChatResponse(
+                agent_response=f"Error generating PRD: {str(e)}",
+                needs_more=True,
+                phase=PRDPhase.EVALUATING.value,
+                missing_requirements=updated_requirements,
+                questions=["Could you provide more details about your product?"],
+                generated_prd=None,
+                judge_feedback=None,
+            )
+
+    prd_detail_logger.info("=== COLLECTING PHASE - ASKING QUESTIONS ===")
+    prd_doc.follow_up_count += 1
+    prd_doc.phase = PRDPhase.COLLECTING.value
+    db.commit()
+
+    question_text = "\n".join([f"- {q}" for q in questions]) if questions else ""
+
+    agent_response = f"Thank you for that information. To create a comprehensive PRD, I need a bit more detail:\n\n{question_text}\n\nPlease share any additional details you're comfortable with."
+
+    if not questions:
+        agent_response = "Thank you for the additional information. I have enough to generate the PRD now."
+
+    prd_detail_logger.info(f"Returning questions: {questions}")
+
+    return PRDChatResponse(
+        agent_response=agent_response,
+        needs_more=bool(questions),
+        phase=prd_doc.phase,
+        missing_requirements=updated_requirements,
+        questions=questions,
+        generated_prd=None,
+    )
+
+
+@router.get("/doc/{session_id}", response_model=PRDDocumentResponse)
+def get_prd_doc(session_id: str, db: Session = Depends(get_db)) -> PRDDocumentResponse:
+    """Get the generated PRD document."""
+    prd_doc = db.query(PRDDocument).filter_by(session_id=session_id).first()
+
+    if not prd_doc:
+        return PRDDocumentResponse(
+            session_id=session_id,
+            generated_prd="",
+            requirements_status={},
+        )
+
+    return PRDDocumentResponse(
+        session_id=session_id,
+        generated_prd=prd_doc.generated_prd or "PRD not yet generated",
+        requirements_status=prd_doc.requirements_status,
+    )
+
+
+@router.get("/status/{session_id}", response_model=PRDStatusResponse)
+def get_prd_status(session_id: str, db: Session = Depends(get_db)) -> PRDStatusResponse:
+    """Get the current status of a PRD session."""
+    prd_doc = db.query(PRDDocument).filter_by(session_id=session_id).first()
+
+    if not prd_doc:
+        return PRDStatusResponse(
+            session_id=session_id,
+            phase="not_found",
+            requirements_status={},
+            collected_info={},
+            missing_sections=[],
+            follow_up_count=0,
+        )
+
+    missing = [k for k, v in prd_doc.requirements_status.items() if not v]
+
+    return PRDStatusResponse(
+        session_id=session_id,
+        phase=prd_doc.phase,
+        requirements_status=prd_doc.requirements_status,
+        collected_info=prd_doc.collected_info,
+        missing_sections=missing,
+        follow_up_count=prd_doc.follow_up_count,
+        judge_approved=prd_doc.judge_approved,
+        judge_score=prd_doc.judge_score,
+        judge_feedback=prd_doc.judge_feedback,
+    )
+
+
+@router.get("/sections/{session_id}", response_model=PRDSectionsResponse)
+def get_prd_sections(
+    session_id: str, db: Session = Depends(get_db)
+) -> PRDSectionsResponse:
+    """Get structured PRD sections for SRS pipeline."""
+    prd_doc = db.query(PRDDocument).filter_by(session_id=session_id).first()
+
+    if not prd_doc or not prd_doc.generated_prd:
+        return PRDSectionsResponse(
+            session_id=session_id,
+            product_vision="",
+            key_features={},
+            user_stories=[],
+            assumptions=[],
+            full_text="",
+            judge_approved=False,
+        )
+
+    return PRDSectionsResponse(
+        session_id=session_id,
+        product_vision=prd_doc.product_vision or "",
+        key_features=prd_doc.key_features or {},
+        user_stories=prd_doc.user_stories or [],
+        assumptions=_normalize_assumptions(prd_doc.assumptions),
+        full_text=prd_doc.generated_prd or "",
+        judge_approved=prd_doc.judge_approved or False,
+    )
+
+
+@router.get("/download/{session_id}")
+def download_prd(
+    session_id: str,
+    format: str = Query(default="markdown", description="Format: markdown or pdf"),
+    db: Session = Depends(get_db),
+):
+    """Download the PRD document in Markdown or PDF format."""
+    prd_doc = db.query(PRDDocument).filter_by(session_id=session_id).first()
+
+    if not prd_doc or not prd_doc.generated_prd:
+        return JSONResponse(
+            status_code=404,
+            content={"error": "PRD not found or not generated"},
+        )
+
+    if format == "pdf":
+        from app.routers.web import generate_pdf_document
+
+        pdf_bytes = generate_pdf_document(
+            project_description=prd_doc.initial_description,
+            markdown_outputs={"product_owner": prd_doc.generated_prd},
+        )
+
+        return StreamingResponse(
+            BytesIO(pdf_bytes.getvalue()),
+            media_type="application/pdf",
+            headers={
+                "Content-Disposition": f"attachment; filename=prd_{session_id[:8]}.pdf"
+            },
+        )
+
+    return JSONResponse(
+        content={
+            "session_id": session_id,
+            "markdown": prd_doc.generated_prd,
+        },
+        headers={
+            "Content-Disposition": f"attachment; filename=prd_{session_id[:8]}.md"
+        },
+    )
+
+
+@router.post("/pipeline/{session_id}", response_model=dict)
+async def send_to_pipeline(
+    session_id: str, db: Session = Depends(get_db)
+) -> dict[str, Any]:
+    """Send the PRD to the multi-agent pipeline for full SRS generation."""
+    from app.routers.web import get_orchestrator
+
+    prd_doc = db.query(PRDDocument).filter_by(session_id=session_id).first()
+
+    if not prd_doc or not prd_doc.generated_prd:
+        return {"error": "PRD not found or not generated"}
+
+    if not prd_doc.judge_approved:
+        return {"error": "PRD must be approved by judge before sending to SRS"}
+
+    prd_context = {
+        "product_vision": prd_doc.product_vision or "",
+        "features": prd_doc.key_features or {},
+        "user_stories": prd_doc.user_stories or [],
+        "assumptions": prd_doc.assumptions or [],
+        "full_text": prd_doc.generated_prd,
+    }
+
+    project_req = ProjectRequest(
+        description=prd_doc.generated_prd,
+    )
+
+    orchestrator = get_orchestrator()
+    results = await orchestrator.run_pipeline(project_req, prd_context=prd_context)
+
+    return dict(results)
+
+
+class JudgeDetailsResponse(BaseModel):
+    """Response model for judge details endpoint."""
+
+    session_id: str
+    judge_score: int | None
+    judge_approved: bool | None
+    judge_feedback: str | None
+    issues: list[dict[str, str]] | None
+
+
+@router.get("/judge/{session_id}", response_model=JudgeDetailsResponse)
+def get_judge_details(
+    session_id: str,
+    db: Session = Depends(get_db),
+) -> JudgeDetailsResponse:
+    """
+    Get judge evaluation details for a PRD session.
+
+    This endpoint returns internal judge feedback that is not shown to the user
+    by default. Access this to review quality assessment details.
+    """
+    prd_doc = db.query(PRDDocument).filter_by(session_id=session_id).first()
+
+    if not prd_doc:
+        return JudgeDetailsResponse(
+            session_id=session_id,
+            judge_score=None,
+            judge_approved=None,
+            judge_feedback=None,
+            issues=None,
+        )
+
+    # Parse issues from judge feedback if available
+    issues = None
+    if prd_doc.judge_feedback:
+        # Simple parsing - in production this might be JSON
+        issues = [{"type": "general", "suggestion": prd_doc.judge_feedback}]
+
+    return JudgeDetailsResponse(
+        session_id=session_id,
+        judge_score=prd_doc.judge_score,
+        judge_approved=prd_doc.judge_approved,
+        judge_feedback=prd_doc.judge_feedback,
+        issues=issues,
+    )

app/routers/web.py

@@ -253,8 +253,8 @@ def generate_pdf_document(
         # --- Improved Markdown Block Handling ---
         lines = content.split("\n")
         in_code_block = False
-        code_block_lines = []
-        paragraph_lines = []
+        code_block_lines: list[str] = []
+        paragraph_lines: list[str] = []
 
         def flush_paragraph(lines_buffer):
             if lines_buffer:

pyproject.toml

@@ -40,10 +40,6 @@ dependencies = [
   # MongoDB Vector Store
   "pymongo>=4.6.0",
   "langchain-mongodb>=0.1.0",
-  "hydra-core>=1.3.2",
-  "lightning>=2.6.0",
-  "fiddle>=0.3.0",
-  "cloudpickle>=3.1.2",
   "upstash-redis>=1.5.0",
 ]
 

requirements.txt

@@ -1,23 +1,15 @@
 # This file was autogenerated by uv via the following command:
 #    uv pip compile pyproject.toml --output-file requirements.txt
-absl-py==2.3.1
-    # via fiddle
 aiohappyeyeballs==2.6.1
     # via aiohttp
 aiohttp==3.13.2
-    # via
-    #   fsspec
-    #   langchain-nvidia-ai-endpoints
+    # via langchain-nvidia-ai-endpoints
 aiosignal==1.4.0
     # via aiohttp
 annotated-doc==0.0.4
     # via fastapi
 annotated-types==0.7.0
     # via pydantic
-antlr4-python3-runtime==4.9.3
-    # via
-    #   hydra-core
-    #   omegaconf
 anyio==4.12.0
     # via
     #   httpx
@@ -39,12 +31,8 @@ charset-normalizer==3.4.4
     # via requests
 click==8.3.1
     # via uvicorn
-cloudpickle==3.1.2
-    # via specs-before-code-api (pyproject.toml)
 colorama==0.4.6
-    # via
-    #   click
-    #   tqdm
+    # via click
 cryptography==46.0.3
     # via python-jose
 defusedxml==0.7.1
@@ -55,10 +43,6 @@ ecdsa==0.19.1
     # via python-jose
 fastapi==0.123.5
     # via specs-before-code-api (pyproject.toml)
-fiddle==0.3.0
-    # via specs-before-code-api (pyproject.toml)
-filelock==3.20.2
-    # via torch
 filetype==1.2.0
     # via langchain-nvidia-ai-endpoints
 fonttools==4.61.0
@@ -69,11 +53,6 @@ frozenlist==1.8.0
     # via
     #   aiohttp
     #   aiosignal
-fsspec==2025.12.0
-    # via
-    #   lightning
-    #   pytorch-lightning
-    #   torch
 google-api-core==2.28.1
     # via google-api-python-client
 google-api-python-client==2.187.0
@@ -90,8 +69,6 @@ google-auth-oauthlib==1.2.3
     # via specs-before-code-api (pyproject.toml)
 googleapis-common-protos==1.72.0
     # via google-api-core
-graphviz==0.21
-    # via fiddle
 greenlet==3.3.0
     # via sqlalchemy
 h11==0.16.0
@@ -109,8 +86,6 @@ httpx==0.28.1
     #   langgraph-sdk
     #   langsmith
     #   upstash-redis
-hydra-core==1.3.2
-    # via specs-before-code-api (pyproject.toml)
 idna==3.11
     # via
     #   anyio
@@ -118,9 +93,7 @@ idna==3.11
     #   requests
     #   yarl
 jinja2==3.1.6
-    # via
-    #   specs-before-code-api (pyproject.toml)
-    #   torch
+    # via specs-before-code-api (pyproject.toml)
 jsonpatch==1.33
     # via langchain-core
 jsonpointer==3.0.0
@@ -168,34 +141,18 @@ langsmith==0.4.53
     #   langchain-core
 lark==1.3.1
     # via langchain-mongodb
-libcst==1.8.6
-    # via fiddle
-lightning==2.6.0
-    # via specs-before-code-api (pyproject.toml)
-lightning-utilities==0.15.2
-    # via
-    #   lightning
-    #   pytorch-lightning
-    #   torchmetrics
 markupsafe==3.0.3
     # via jinja2
-mpmath==1.3.0
-    # via sympy
 multidict==6.7.0
     # via
     #   aiohttp
     #   yarl
-networkx==3.6.1
-    # via torch
 numpy==2.3.5
     # via
     #   specs-before-code-api (pyproject.toml)
     #   langchain-mongodb
-    #   torchmetrics
 oauthlib==3.3.1
     # via requests-oauthlib
-omegaconf==2.3.0
-    # via hydra-core
 orjson==3.11.4
     # via
     #   langgraph-sdk
@@ -204,13 +161,8 @@ ormsgpack==1.12.0
     # via langgraph-checkpoint
 packaging==24.2
     # via
-    #   hydra-core
     #   langchain-core
     #   langsmith
-    #   lightning
-    #   lightning-utilities
-    #   pytorch-lightning
-    #   torchmetrics
 passlib==1.7.4
     # via specs-before-code-api (pyproject.toml)
 pillow==12.0.0
@@ -263,16 +215,10 @@ python-jose==3.5.0
     # via specs-before-code-api (pyproject.toml)
 python-multipart==0.0.20
     # via specs-before-code-api (pyproject.toml)
-pytorch-lightning==2.6.0
-    # via lightning
 pyyaml==6.0.3
     # via
     #   langchain-classic
     #   langchain-core
-    #   lightning
-    #   omegaconf
-    #   pytorch-lightning
-    # via libcst
 requests==2.32.5
     # via
     #   google-api-core
@@ -288,10 +234,6 @@ rsa==4.9.1
     # via
     #   google-auth
     #   python-jose
-setuptools==80.9.0
-    # via
-    #   lightning-utilities
-    #   torch
 six==1.17.0
     # via ecdsa
 sqlalchemy==2.0.45
@@ -300,35 +242,15 @@ sqlalchemy==2.0.45
     #   langchain-classic
 starlette==0.50.0
     # via fastapi
-sympy==1.14.0
-    # via torch
 tenacity==9.1.2
     # via langchain-core
-torch==2.9.1
-    # via
-    #   lightning
-    #   pytorch-lightning
-    #   torchmetrics
-torchmetrics==1.8.2
-    # via
-    #   lightning
-    #   pytorch-lightning
-tqdm==4.67.1
-    # via
-    #   lightning
-    #   pytorch-lightning
 typing-extensions==4.15.0
     # via
     #   fastapi
-    #   fiddle
     #   langchain-core
-    #   lightning
-    #   lightning-utilities
     #   pydantic
     #   pydantic-core
-    #   pytorch-lightning
     #   sqlalchemy
-    #   torch
     #   typing-inspection
 typing-inspection==0.4.2
     # via pydantic

tests/test_prd_endpoints.py

@@ -0,0 +1,94 @@
+from fastapi.testclient import TestClient
+
+from app.core.database import Base, engine
+from app.main import app
+
+
+def _reset_db():
+    Base.metadata.drop_all(bind=engine)
+    Base.metadata.create_all(bind=engine)
+
+
+def _start_session(client: TestClient, user_id: int = 1) -> str:
+    resp = client.post(
+        "/prd/start",
+        json={"description": "Test PRD", "user_id": user_id},
+    )
+    assert resp.status_code == 200
+    return resp.json()["session_id"]
+
+
+# Happy path: PRD chat endpoint
+def test_prd_chat_happy():
+    _reset_db()
+    client = TestClient(app)
+    session_id = _start_session(client)
+
+    resp = client.post(
+        "/prd/chat",
+        json={
+            "session_id": session_id,
+            "message": "Our main goal is to improve user experience.",
+        },
+    )
+    assert resp.status_code == 200
+    data = resp.json()
+    assert "agent_response" in data
+    assert "missing_requirements" in data
+
+
+# Sad path: PRD chat with empty message
+def test_prd_chat_empty():
+    _reset_db()
+    client = TestClient(app)
+    session_id = _start_session(client)
+
+    resp = client.post("/prd/chat", json={"session_id": session_id, "message": ""})
+    assert resp.status_code == 200
+    data = resp.json()
+    assert "agent_response" in data
+
+
+# Happy path: PRD doc endpoint
+def test_prd_doc_happy():
+    _reset_db()
+    client = TestClient(app)
+    session_id = _start_session(client)
+
+    resp = client.get(f"/prd/doc/{session_id}")
+    assert resp.status_code == 200
+    data = resp.json()
+    assert data["session_id"] == session_id
+    assert "generated_prd" in data
+
+
+# Sad path: PRD doc with missing session_id
+def test_prd_doc_missing():
+    _reset_db()
+    client = TestClient(app)
+
+    resp = client.get("/prd/doc")
+    assert resp.status_code == 404
+
+
+# Happy path: PRD status endpoint
+def test_prd_status_happy():
+    _reset_db()
+    client = TestClient(app)
+    session_id = _start_session(client)
+
+    resp = client.get(f"/prd/status/{session_id}")
+    assert resp.status_code == 200
+    data = resp.json()
+    assert data["session_id"] == session_id
+    assert "requirements_status" in data
+    assert "missing_sections" in data
+
+
+# Sad path: PRD status with missing session_id
+def test_prd_status_missing():
+    _reset_db()
+    client = TestClient(app)
+
+    resp = client.get("/prd/status")
+    assert resp.status_code == 404

tests/test_rag.py

@@ -21,7 +21,7 @@ class TestRAGServiceInit:
         """RAGService should initialize embeddings."""
         mock_embeddings.return_value = MagicMock()
 
-        with patch.object(RAGService, "_initialize_vector_store"):
+        with patch.object(RAGService, "_init_fallback_store"):
             service = RAGService()
 
         assert mock_embeddings.called
@@ -34,7 +34,7 @@ class TestRAGServiceInit:
         mock_embeddings.return_value = MagicMock()
         mock_getenv.return_value = None  # No Pinecone config
 
-        with patch.object(RAGService, "_init_fallback") as mock_fallback:
+        with patch.object(RAGService, "_init_fallback_store") as mock_fallback:
             service = RAGService()
 
         # Should attempt fallback
@@ -63,7 +63,7 @@ class TestRAGServiceRetrieve:
         """Retrieve should handle missing vector store gracefully."""
         mock_embeddings.return_value = MagicMock()
 
-        with patch.object(RAGService, "_initialize_vector_store"):
+        with patch.object(RAGService, "_init_fallback_store"):
             service = RAGService()
             service.vector_store = None
 
@@ -75,11 +75,11 @@ class TestRAGServiceRetrieve:
         """format_docs should handle empty list."""
         mock_embeddings.return_value = MagicMock()
 
-        with patch.object(RAGService, "_initialize_vector_store"):
+        with patch.object(RAGService, "_init_fallback_store"):
             service = RAGService()
 
         result = service.format_docs([])
-        assert "No relevant context" in result
+        assert "No relevant examples found in knowledge base." in result
 
 
 class TestRAGServiceFormatDocs:
@@ -92,7 +92,7 @@ class TestRAGServiceFormatDocs:
 
         mock_embeddings.return_value = MagicMock()
 
-        with patch.object(RAGService, "_initialize_vector_store"):
+        with patch.object(RAGService, "_init_fallback_store"):
             service = RAGService()
 
         doc = Document(
@@ -111,7 +111,7 @@ class TestRAGServiceFormatDocs:
 
         mock_embeddings.return_value = MagicMock()
 
-        with patch.object(RAGService, "_initialize_vector_store"):
+        with patch.object(RAGService, "_init_fallback_store"):
             service = RAGService()
 
         docs = [
@@ -134,12 +134,16 @@ class TestRAGServiceRetriever:
         """get_retriever should raise if no vector store."""
         mock_embeddings.return_value = MagicMock()
 
-        with patch.object(RAGService, "_initialize_vector_store"):
-            service = RAGService()
-            service.vector_store = None
+        with patch("app.core.rag.os.getenv") as mock_getenv:
+            mock_getenv.return_value = None  # Simulate no MONGODB_URI
+            with patch.object(RAGService, "_init_fallback_store"):
+                service = RAGService()
+                # Simulate both stores missing
+                service._mongodb_service = None
+                service._fallback_store = None
 
-        with pytest.raises(RuntimeError, match="not initialized"):
-            service.get_retriever()
+            with pytest.raises(RuntimeError, match="not initialized"):
+                service.get_retriever()
 
     @patch("app.core.rag.get_embeddings_model")
     def test_get_retriever_with_store(self, mock_embeddings):
@@ -149,9 +153,11 @@ class TestRAGServiceRetriever:
         mock_retriever = MagicMock()
         mock_store.as_retriever.return_value = mock_retriever
 
-        with patch.object(RAGService, "_initialize_vector_store"):
+        with patch.object(RAGService, "_init_fallback_store"):
             service = RAGService()
-            service.vector_store = mock_store
+            # Simulate fallback store being used
+            service._mongodb_service = None
+            service._fallback_store = mock_store
 
         retriever = service.get_retriever(k=5)
 

uv.lock

@@ -7,15 +7,6 @@ resolution-markers = [
     "python_full_version < '3.13'",
 ]
 
-[[package]]
-name = "absl-py"
-version = "2.3.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/10/2a/c93173ffa1b39c1d0395b7e842bbdc62e556ca9d8d3b5572926f3e4ca752/absl_py-2.3.1.tar.gz", hash = "sha256:a97820526f7fbfd2ec1bce83f3f25e3a14840dac0d8e02a0b71cd75db3f77fc9", size = 116588, upload-time = "2025-07-03T09:31:44.05Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8f/aa/ba0014cc4659328dc818a28827be78e6d97312ab0cb98105a770924dc11e/absl_py-2.3.1-py3-none-any.whl", hash = "sha256:eeecf07f0c2a93ace0772c92e596ace6d3d3996c042b2128459aaae2a76de11d", size = 135811, upload-time = "2025-07-03T09:31:42.253Z" },
-]
-
 [[package]]
 name = "aiohappyeyeballs"
 version = "2.6.1"
@@ -141,12 +132,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
 ]
 
-[[package]]
-name = "antlr4-python3-runtime"
-version = "4.9.3"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/3e/38/7859ff46355f76f8d19459005ca000b6e7012f2f1ca597746cbcd1fbfe5e/antlr4-python3-runtime-4.9.3.tar.gz", hash = "sha256:f224469b4168294902bb1efa80a8bf7855f24c99aef99cbefc1bcd3cce77881b", size = 117034, upload-time = "2021-11-06T17:52:23.524Z" }
-
 [[package]]
 name = "anyio"
 version = "4.12.0"
@@ -411,15 +396,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
 ]
 
-[[package]]
-name = "cloudpickle"
-version = "3.1.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/27/fb/576f067976d320f5f0114a8d9fa1215425441bb35627b1993e5afd8111e5/cloudpickle-3.1.2.tar.gz", hash = "sha256:7fda9eb655c9c230dab534f1983763de5835249750e85fbcef43aaa30a9a2414", size = 22330, upload-time = "2025-11-03T09:25:26.604Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl", hash = "sha256:9acb47f6afd73f60dc1df93bb801b472f05ff42fa6c84167d25cb206be1fbf4a", size = 22228, upload-time = "2025-11-03T09:25:25.534Z" },
-]
-
 [[package]]
 name = "colorama"
 version = "0.4.6"
@@ -604,30 +580,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/5c/05/5cbb59154b093548acd0f4c7c474a118eda06da25aa75c616b72d8fcd92a/fastapi-0.128.0-py3-none-any.whl", hash = "sha256:aebd93f9716ee3b4f4fcfe13ffb7cf308d99c9f3ab5622d8877441072561582d", size = 103094, upload-time = "2025-12-27T15:21:12.154Z" },
 ]
 
-[[package]]
-name = "fiddle"
-version = "0.3.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "absl-py" },
-    { name = "graphviz" },
-    { name = "libcst" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/73/36/7a4fac76351619b36bbc7937abf59f7b601326dc4efc253b3c16819f782a/fiddle-0.3.0.tar.gz", hash = "sha256:5d083d3299a479868345513385a6c5546141bd92086c15d3dcbf8008a90075d3", size = 277884, upload-time = "2024-04-09T17:23:58.974Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3b/98/a38e949a91ff9e15874487fd8329ff53c25f3413c0cfc809eb6ff7eb7fa1/fiddle-0.3.0-py3-none-any.whl", hash = "sha256:f4824541c103a94a2f33f6c93eeddf6007c3a7300440087a95907f3e74362e61", size = 419830, upload-time = "2024-04-09T17:23:56.7Z" },
-]
-
-[[package]]
-name = "filelock"
-version = "3.20.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a7/23/ce7a1126827cedeb958fc043d61745754464eb56c5937c35bbf2b8e26f34/filelock-3.20.1.tar.gz", hash = "sha256:b8360948b351b80f420878d8516519a2204b07aefcdcfd24912a5d33127f188c", size = 19476, upload-time = "2025-12-15T23:54:28.027Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e3/7f/a1a97644e39e7316d850784c642093c99df1290a460df4ede27659056834/filelock-3.20.1-py3-none-any.whl", hash = "sha256:15d9e9a67306188a44baa72f569d2bfd803076269365fdea0934385da4dc361a", size = 16666, upload-time = "2025-12-15T23:54:26.874Z" },
-]
-
 [[package]]
 name = "filetype"
 version = "1.2.0"
@@ -781,20 +733,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" },
 ]
 
-[[package]]
-name = "fsspec"
-version = "2025.12.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b6/27/954057b0d1f53f086f681755207dda6de6c660ce133c829158e8e8fe7895/fsspec-2025.12.0.tar.gz", hash = "sha256:c505de011584597b1060ff778bb664c1bc022e87921b0e4f10cc9c44f9635973", size = 309748, upload-time = "2025-12-03T15:23:42.687Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/51/c7/b64cae5dba3a1b138d7123ec36bb5ccd39d39939f18454407e5468f4763f/fsspec-2025.12.0-py3-none-any.whl", hash = "sha256:8bf1fe301b7d8acfa6e8571e3b1c3d158f909666642431cc78a1b7b4dbc5ec5b", size = 201422, upload-time = "2025-12-03T15:23:41.434Z" },
-]
-
-[package.optional-dependencies]
-http = [
-    { name = "aiohttp" },
-]
-
 [[package]]
 name = "google-api-core"
 version = "2.28.1"
@@ -879,15 +817,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c4/ab/09169d5a4612a5f92490806649ac8d41e3ec9129c636754575b3553f4ea4/googleapis_common_protos-1.72.0-py3-none-any.whl", hash = "sha256:4299c5a82d5ae1a9702ada957347726b167f9f8d1fc352477702a1e851ff4038", size = 297515, upload-time = "2025-11-06T18:29:13.14Z" },
 ]
 
-[[package]]
-name = "graphviz"
-version = "0.21"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f8/b3/3ac91e9be6b761a4b30d66ff165e54439dcd48b83f4e20d644867215f6ca/graphviz-0.21.tar.gz", hash = "sha256:20743e7183be82aaaa8ad6c93f8893c923bd6658a04c32ee115edb3c8a835f78", size = 200434, upload-time = "2025-06-15T09:35:05.824Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/91/4c/e0ce1ef95d4000ebc1c11801f9b944fa5910ecc15b5e351865763d8657f8/graphviz-0.21-py3-none-any.whl", hash = "sha256:54f33de9f4f911d7e84e4191749cac8cc5653f815b06738c54db9a15ab8b1e42", size = 47300, upload-time = "2025-06-15T09:35:04.433Z" },
-]
-
 [[package]]
 name = "greenlet"
 version = "3.3.0"
@@ -976,20 +905,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
 ]
 
-[[package]]
-name = "hydra-core"
-version = "1.3.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "antlr4-python3-runtime" },
-    { name = "omegaconf" },
-    { name = "packaging" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/8e/07e42bc434a847154083b315779b0a81d567154504624e181caf2c71cd98/hydra-core-1.3.2.tar.gz", hash = "sha256:8a878ed67216997c3e9d88a8e72e7b4767e81af37afb4ea3334b269a4390a824", size = 3263494, upload-time = "2023-02-23T18:33:43.03Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c6/50/e0edd38dcd63fb26a8547f13d28f7a008bc4a3fd4eb4ff030673f22ad41a/hydra_core-1.3.2-py3-none-any.whl", hash = "sha256:fa0238a9e31df3373b35b0bfb672c34cc92718d21f81311d8996a16de1141d8b", size = 154547, upload-time = "2023-02-23T18:33:40.801Z" },
-]
-
 [[package]]
 name = "idna"
 version = "3.11"
@@ -1221,58 +1136,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/82/3d/14ce75ef66813643812f3093ab17e46d3a206942ce7376d31ec2d36229e7/lark-1.3.1-py3-none-any.whl", hash = "sha256:c629b661023a014c37da873b4ff58a817398d12635d3bbb2c5a03be7fe5d1e12", size = 113151, upload-time = "2025-10-27T18:25:54.882Z" },
 ]
 
-[[package]]
-name = "libcst"
-version = "1.8.6"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pyyaml", marker = "python_full_version != '3.13.*'" },
-    { name = "pyyaml-ft", marker = "python_full_version == '3.13.*'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/de/cd/337df968b38d94c5aabd3e1b10630f047a2b345f6e1d4456bd9fe7417537/libcst-1.8.6.tar.gz", hash = "sha256:f729c37c9317126da9475bdd06a7208eb52fcbd180a6341648b45a56b4ba708b", size = 891354, upload-time = "2025-11-03T22:33:30.621Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/0c/3c/93365c17da3d42b055a8edb0e1e99f1c60c776471db6c9b7f1ddf6a44b28/libcst-1.8.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0c13d5bd3d8414a129e9dccaf0e5785108a4441e9b266e1e5e9d1f82d1b943c9", size = 2206166, upload-time = "2025-11-03T22:32:16.012Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/cb/7530940e6ac50c6dd6022349721074e19309eb6aa296e942ede2213c1a19/libcst-1.8.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f1472eeafd67cdb22544e59cf3bfc25d23dc94058a68cf41f6654ff4fcb92e09", size = 2083726, upload-time = "2025-11-03T22:32:17.312Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/cf/7e5eaa8c8f2c54913160671575351d129170db757bb5e4b7faffed022271/libcst-1.8.6-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:089c58e75cb142ec33738a1a4ea7760a28b40c078ab2fd26b270dac7d2633a4d", size = 2235755, upload-time = "2025-11-03T22:32:18.859Z" },
-    { url = "https://files.pythonhosted.org/packages/55/54/570ec2b0e9a3de0af9922e3bb1b69a5429beefbc753a7ea770a27ad308bd/libcst-1.8.6-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:c9d7aeafb1b07d25a964b148c0dda9451efb47bbbf67756e16eeae65004b0eb5", size = 2301473, upload-time = "2025-11-03T22:32:20.499Z" },
-    { url = "https://files.pythonhosted.org/packages/11/4c/163457d1717cd12181c421a4cca493454bcabd143fc7e53313bc6a4ad82a/libcst-1.8.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:207481197afd328aa91d02670c15b48d0256e676ce1ad4bafb6dc2b593cc58f1", size = 2298899, upload-time = "2025-11-03T22:32:21.765Z" },
-    { url = "https://files.pythonhosted.org/packages/35/1d/317ddef3669883619ef3d3395ea583305f353ef4ad87d7a5ac1c39be38e3/libcst-1.8.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:375965f34cc6f09f5f809244d3ff9bd4f6cb6699f571121cebce53622e7e0b86", size = 2408239, upload-time = "2025-11-03T22:32:23.275Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/a1/f47d8cccf74e212dd6044b9d6dbc223636508da99acff1d54786653196bc/libcst-1.8.6-cp312-cp312-win_amd64.whl", hash = "sha256:da95b38693b989eaa8d32e452e8261cfa77fe5babfef1d8d2ac25af8c4aa7e6d", size = 2119660, upload-time = "2025-11-03T22:32:24.822Z" },
-    { url = "https://files.pythonhosted.org/packages/19/d0/dd313bf6a7942cdf951828f07ecc1a7695263f385065edc75ef3016a3cb5/libcst-1.8.6-cp312-cp312-win_arm64.whl", hash = "sha256:bff00e1c766658adbd09a175267f8b2f7616e5ee70ce45db3d7c4ce6d9f6bec7", size = 1999824, upload-time = "2025-11-03T22:32:26.131Z" },
-    { url = "https://files.pythonhosted.org/packages/90/01/723cd467ec267e712480c772aacc5aa73f82370c9665162fd12c41b0065b/libcst-1.8.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7445479ebe7d1aff0ee094ab5a1c7718e1ad78d33e3241e1a1ec65dcdbc22ffb", size = 2206386, upload-time = "2025-11-03T22:32:27.422Z" },
-    { url = "https://files.pythonhosted.org/packages/17/50/b944944f910f24c094f9b083f76f61e3985af5a376f5342a21e01e2d1a81/libcst-1.8.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4fc3fef8a2c983e7abf5d633e1884c5dd6fa0dcb8f6e32035abd3d3803a3a196", size = 2083945, upload-time = "2025-11-03T22:32:28.847Z" },
-    { url = "https://files.pythonhosted.org/packages/36/a1/bd1b2b2b7f153d82301cdaddba787f4a9fc781816df6bdb295ca5f88b7cf/libcst-1.8.6-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:1a3a5e4ee870907aa85a4076c914ae69066715a2741b821d9bf16f9579de1105", size = 2235818, upload-time = "2025-11-03T22:32:30.504Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/ab/f5433988acc3b4d188c4bb154e57837df9488cc9ab551267cdeabd3bb5e7/libcst-1.8.6-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:6609291c41f7ad0bac570bfca5af8fea1f4a27987d30a1fa8b67fe5e67e6c78d", size = 2301289, upload-time = "2025-11-03T22:32:31.812Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/57/89f4ba7a6f1ac274eec9903a9e9174890d2198266eee8c00bc27eb45ecf7/libcst-1.8.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:25eaeae6567091443b5374b4c7d33a33636a2d58f5eda02135e96fc6c8807786", size = 2299230, upload-time = "2025-11-03T22:32:33.242Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/36/0aa693bc24cce163a942df49d36bf47a7ed614a0cd5598eee2623bc31913/libcst-1.8.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:04030ea4d39d69a65873b1d4d877def1c3951a7ada1824242539e399b8763d30", size = 2408519, upload-time = "2025-11-03T22:32:34.678Z" },
-    { url = "https://files.pythonhosted.org/packages/db/18/6dd055b5f15afa640fb3304b2ee9df8b7f72e79513814dbd0a78638f4a0e/libcst-1.8.6-cp313-cp313-win_amd64.whl", hash = "sha256:8066f1b70f21a2961e96bedf48649f27dfd5ea68be5cd1bed3742b047f14acde", size = 2119853, upload-time = "2025-11-03T22:32:36.287Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/ed/5ddb2a22f0b0abdd6dcffa40621ada1feaf252a15e5b2733a0a85dfd0429/libcst-1.8.6-cp313-cp313-win_arm64.whl", hash = "sha256:c188d06b583900e662cd791a3f962a8c96d3dfc9b36ea315be39e0a4c4792ebf", size = 1999808, upload-time = "2025-11-03T22:32:38.1Z" },
-    { url = "https://files.pythonhosted.org/packages/25/d3/72b2de2c40b97e1ef4a1a1db4e5e52163fc7e7740ffef3846d30bc0096b5/libcst-1.8.6-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:c41c76e034a1094afed7057023b1d8967f968782433f7299cd170eaa01ec033e", size = 2190553, upload-time = "2025-11-03T22:32:39.819Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/20/983b7b210ccc3ad94a82db54230e92599c4a11b9cfc7ce3bc97c1d2df75c/libcst-1.8.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5432e785322aba3170352f6e72b32bea58d28abd141ac37cc9b0bf6b7c778f58", size = 2074717, upload-time = "2025-11-03T22:32:41.373Z" },
-    { url = "https://files.pythonhosted.org/packages/13/f2/9e01678fedc772e09672ed99930de7355757035780d65d59266fcee212b8/libcst-1.8.6-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:85b7025795b796dea5284d290ff69de5089fc8e989b25d6f6f15b6800be7167f", size = 2225834, upload-time = "2025-11-03T22:32:42.716Z" },
-    { url = "https://files.pythonhosted.org/packages/4a/0d/7bed847b5c8c365e9f1953da274edc87577042bee5a5af21fba63276e756/libcst-1.8.6-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:536567441182a62fb706e7aa954aca034827b19746832205953b2c725d254a93", size = 2287107, upload-time = "2025-11-03T22:32:44.549Z" },
-    { url = "https://files.pythonhosted.org/packages/02/f0/7e51fa84ade26c518bfbe7e2e4758b56d86a114c72d60309ac0d350426c4/libcst-1.8.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:2f04d3672bde1704f383a19e8f8331521abdbc1ed13abb349325a02ac56e5012", size = 2288672, upload-time = "2025-11-03T22:32:45.867Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/cd/15762659a3f5799d36aab1bc2b7e732672722e249d7800e3c5f943b41250/libcst-1.8.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:7f04febcd70e1e67917be7de513c8d4749d2e09206798558d7fe632134426ea4", size = 2392661, upload-time = "2025-11-03T22:32:47.232Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/6b/b7f9246c323910fcbe021241500f82e357521495dcfe419004dbb272c7cb/libcst-1.8.6-cp313-cp313t-win_amd64.whl", hash = "sha256:1dc3b897c8b0f7323412da3f4ad12b16b909150efc42238e19cbf19b561cc330", size = 2105068, upload-time = "2025-11-03T22:32:49.145Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/0b/4fd40607bc4807ec2b93b054594373d7fa3d31bb983789901afcb9bcebe9/libcst-1.8.6-cp313-cp313t-win_arm64.whl", hash = "sha256:44f38139fa95e488db0f8976f9c7ca39a64d6bc09f2eceef260aa1f6da6a2e42", size = 1985181, upload-time = "2025-11-03T22:32:50.597Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/60/4105441989e321f7ad0fd28ffccb83eb6aac0b7cfb0366dab855dcccfbe5/libcst-1.8.6-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:b188e626ce61de5ad1f95161b8557beb39253de4ec74fc9b1f25593324a0279c", size = 2204202, upload-time = "2025-11-03T22:32:52.311Z" },
-    { url = "https://files.pythonhosted.org/packages/67/2f/51a6f285c3a183e50cfe5269d4a533c21625aac2c8de5cdf2d41f079320d/libcst-1.8.6-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:87e74f7d7dfcba9efa91127081e22331d7c42515f0a0ac6e81d4cf2c3ed14661", size = 2083581, upload-time = "2025-11-03T22:32:54.269Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/64/921b1c19b638860af76cdb28bc81d430056592910b9478eea49e31a7f47a/libcst-1.8.6-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:3a926a4b42015ee24ddfc8ae940c97bd99483d286b315b3ce82f3bafd9f53474", size = 2236495, upload-time = "2025-11-03T22:32:55.723Z" },
-    { url = "https://files.pythonhosted.org/packages/12/a8/b00592f9bede618cbb3df6ffe802fc65f1d1c03d48a10d353b108057d09c/libcst-1.8.6-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:3f4fbb7f569e69fd9e89d9d9caa57ca42c577c28ed05062f96a8c207594e75b8", size = 2301466, upload-time = "2025-11-03T22:32:57.337Z" },
-    { url = "https://files.pythonhosted.org/packages/af/df/790d9002f31580fefd0aec2f373a0f5da99070e04c5e8b1c995d0104f303/libcst-1.8.6-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:08bd63a8ce674be431260649e70fca1d43f1554f1591eac657f403ff8ef82c7a", size = 2300264, upload-time = "2025-11-03T22:32:58.852Z" },
-    { url = "https://files.pythonhosted.org/packages/21/de/dc3f10e65bab461be5de57850d2910a02c24c3ddb0da28f0e6e4133c3487/libcst-1.8.6-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e00e275d4ba95d4963431ea3e409aa407566a74ee2bf309a402f84fc744abe47", size = 2408572, upload-time = "2025-11-03T22:33:00.552Z" },
-    { url = "https://files.pythonhosted.org/packages/20/3b/35645157a7590891038b077db170d6dd04335cd2e82a63bdaa78c3297dfe/libcst-1.8.6-cp314-cp314-win_amd64.whl", hash = "sha256:fea5c7fa26556eedf277d4f72779c5ede45ac3018650721edd77fd37ccd4a2d4", size = 2193917, upload-time = "2025-11-03T22:33:02.354Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/a2/1034a9ba7d3e82f2c2afaad84ba5180f601aed676d92b76325797ad60951/libcst-1.8.6-cp314-cp314-win_arm64.whl", hash = "sha256:bb9b4077bdf8857b2483879cbbf70f1073bc255b057ec5aac8a70d901bb838e9", size = 2078748, upload-time = "2025-11-03T22:33:03.707Z" },
-    { url = "https://files.pythonhosted.org/packages/95/a1/30bc61e8719f721a5562f77695e6154e9092d1bdf467aa35d0806dcd6cea/libcst-1.8.6-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:55ec021a296960c92e5a33b8d93e8ad4182b0eab657021f45262510a58223de1", size = 2188980, upload-time = "2025-11-03T22:33:05.152Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/14/c660204532407c5628e3b615015a902ed2d0b884b77714a6bdbe73350910/libcst-1.8.6-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ba9ab2b012fbd53b36cafd8f4440a6b60e7e487cd8b87428e57336b7f38409a4", size = 2074828, upload-time = "2025-11-03T22:33:06.864Z" },
-    { url = "https://files.pythonhosted.org/packages/82/e2/c497c354943dff644749f177ee9737b09ed811b8fc842b05709a40fe0d1b/libcst-1.8.6-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:c0a0cc80aebd8aa15609dd4d330611cbc05e9b4216bcaeabba7189f99ef07c28", size = 2225568, upload-time = "2025-11-03T22:33:08.354Z" },
-    { url = "https://files.pythonhosted.org/packages/86/ef/45999676d07bd6d0eefa28109b4f97124db114e92f9e108de42ba46a8028/libcst-1.8.6-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:42a4f68121e2e9c29f49c97f6154e8527cd31021809cc4a941c7270aa64f41aa", size = 2286523, upload-time = "2025-11-03T22:33:10.206Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/6c/517d8bf57d9f811862f4125358caaf8cd3320a01291b3af08f7b50719db4/libcst-1.8.6-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8a434c521fadaf9680788b50d5c21f4048fa85ed19d7d70bd40549fbaeeecab1", size = 2288044, upload-time = "2025-11-03T22:33:11.628Z" },
-    { url = "https://files.pythonhosted.org/packages/83/ce/24d7d49478ffb61207f229239879845da40a374965874f5ee60f96b02ddb/libcst-1.8.6-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6a65f844d813ab4ef351443badffa0ae358f98821561d19e18b3190f59e71996", size = 2392605, upload-time = "2025-11-03T22:33:12.962Z" },
-    { url = "https://files.pythonhosted.org/packages/39/c3/829092ead738b71e96a4e96896c96f276976e5a8a58b4473ed813d7c962b/libcst-1.8.6-cp314-cp314t-win_amd64.whl", hash = "sha256:bdb14bc4d4d83a57062fed2c5da93ecb426ff65b0dc02ddf3481040f5f074a82", size = 2181581, upload-time = "2025-11-03T22:33:14.514Z" },
-    { url = "https://files.pythonhosted.org/packages/98/6d/5d6a790a02eb0d9d36c4aed4f41b277497e6178900b2fa29c35353aa45ed/libcst-1.8.6-cp314-cp314t-win_arm64.whl", hash = "sha256:819c8081e2948635cab60c603e1bbdceccdfe19104a242530ad38a36222cb88f", size = 2065000, upload-time = "2025-11-03T22:33:16.257Z" },
-]
-
 [[package]]
 name = "librt"
 version = "0.7.8"
@@ -1325,40 +1188,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/fc/85/69f92b2a7b3c0f88ffe107c86b952b397004b5b8ea5a81da3d9c04c04422/librt-0.7.8-cp314-cp314t-win_arm64.whl", hash = "sha256:8766ece9de08527deabcd7cb1b4f1a967a385d26e33e536d6d8913db6ef74f06", size = 40550, upload-time = "2026-01-14T12:56:01.542Z" },
 ]
 
-[[package]]
-name = "lightning"
-version = "2.6.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "fsspec", extra = ["http"] },
-    { name = "lightning-utilities" },
-    { name = "packaging" },
-    { name = "pytorch-lightning" },
-    { name = "pyyaml" },
-    { name = "torch" },
-    { name = "torchmetrics" },
-    { name = "tqdm" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/1a/d5/892ea38816925b3511493e87b0b32494122bf8a20e66f4f2cd2667f95625/lightning-2.6.0.tar.gz", hash = "sha256:881841716b59c1837ae0c562c2e64fea9bcf49ef9de3867bd1f868557ec23d04", size = 656539, upload-time = "2025-11-28T09:34:25.069Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d6/e9/36b340c7ec01dad6f034481e98fc9fc0133307beb05c714c0542af98bbde/lightning-2.6.0-py3-none-any.whl", hash = "sha256:f1a13a48909960a3454518486f113fae4fadb2db0e28e9c50d8d38d46c9dc3d6", size = 845956, upload-time = "2025-11-28T09:34:23.273Z" },
-]
-
-[[package]]
-name = "lightning-utilities"
-version = "0.15.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "packaging" },
-    { name = "setuptools" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/b8/39/6fc58ca81492db047149b4b8fd385aa1bfb8c28cd7cacb0c7eb0c44d842f/lightning_utilities-0.15.2.tar.gz", hash = "sha256:cdf12f530214a63dacefd713f180d1ecf5d165338101617b4742e8f22c032e24", size = 31090, upload-time = "2025-08-06T13:57:39.242Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/de/73/3d757cb3fc16f0f9794dd289bcd0c4a031d9cf54d8137d6b984b2d02edf3/lightning_utilities-0.15.2-py3-none-any.whl", hash = "sha256:ad3ab1703775044bbf880dbf7ddaaac899396c96315f3aa1779cec9d618a9841", size = 29431, upload-time = "2025-08-06T13:57:38.046Z" },
-]
-
 [[package]]
 name = "markupsafe"
 version = "3.0.3"
@@ -1422,15 +1251,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" },
 ]
 
-[[package]]
-name = "mpmath"
-version = "1.3.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f", size = 508106, upload-time = "2023-03-07T16:47:11.061Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c", size = 536198, upload-time = "2023-03-07T16:47:09.197Z" },
-]
-
 [[package]]
 name = "multidict"
 version = "6.7.0"
@@ -1572,15 +1392,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" },
 ]
 
-[[package]]
-name = "networkx"
-version = "3.6.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", hash = "sha256:26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509", size = 2517025, upload-time = "2025-12-08T17:02:39.908Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", hash = "sha256:d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762", size = 2068504, upload-time = "2025-12-08T17:02:38.159Z" },
-]
-
 [[package]]
 name = "numpy"
 version = "2.4.0"
@@ -1642,140 +1453,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a4/4f/1f8475907d1a7c4ef9020edf7f39ea2422ec896849245f00688e4b268a71/numpy-2.4.0-cp314-cp314t-win_arm64.whl", hash = "sha256:23a3e9d1a6f360267e8fbb38ba5db355a6a7e9be71d7fce7ab3125e88bb646c8", size = 10661799, upload-time = "2025-12-20T16:18:01.078Z" },
 ]
 
-[[package]]
-name = "nvidia-cublas-cu12"
-version = "12.8.4.1"
-source = { registry = "https://pypi.org/simple" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/dc/61/e24b560ab2e2eaeb3c839129175fb330dfcfc29e5203196e5541a4c44682/nvidia_cublas_cu12-12.8.4.1-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:8ac4e771d5a348c551b2a426eda6193c19aa630236b418086020df5ba9667142", size = 594346921, upload-time = "2025-03-07T01:44:31.254Z" },
-]
-
-[[package]]
-name = "nvidia-cuda-cupti-cu12"
-version = "12.8.90"
-source = { registry = "https://pypi.org/simple" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f8/02/2adcaa145158bf1a8295d83591d22e4103dbfd821bcaf6f3f53151ca4ffa/nvidia_cuda_cupti_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ea0cb07ebda26bb9b29ba82cda34849e73c166c18162d3913575b0c9db9a6182", size = 10248621, upload-time = "2025-03-07T01:40:21.213Z" },
-]
-
-[[package]]
-name = "nvidia-cuda-nvrtc-cu12"
-version = "12.8.93"
-source = { registry = "https://pypi.org/simple" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/05/6b/32f747947df2da6994e999492ab306a903659555dddc0fbdeb9d71f75e52/nvidia_cuda_nvrtc_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:a7756528852ef889772a84c6cd89d41dfa74667e24cca16bb31f8f061e3e9994", size = 88040029, upload-time = "2025-03-07T01:42:13.562Z" },
-]
-
-[[package]]
-name = "nvidia-cuda-runtime-cu12"
-version = "12.8.90"
-source = { registry = "https://pypi.org/simple" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/0d/9b/a997b638fcd068ad6e4d53b8551a7d30fe8b404d6f1804abf1df69838932/nvidia_cuda_runtime_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:adade8dcbd0edf427b7204d480d6066d33902cab2a4707dcfc48a2d0fd44ab90", size = 954765, upload-time = "2025-03-07T01:40:01.615Z" },
-]
-
-[[package]]
-name = "nvidia-cudnn-cu12"
-version = "9.10.2.21"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "nvidia-cublas-cu12" },
-]
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ba/51/e123d997aa098c61d029f76663dedbfb9bc8dcf8c60cbd6adbe42f76d049/nvidia_cudnn_cu12-9.10.2.21-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:949452be657fa16687d0930933f032835951ef0892b37d2d53824d1a84dc97a8", size = 706758467, upload-time = "2025-06-06T21:54:08.597Z" },
-]
-
-[[package]]
-name = "nvidia-cufft-cu12"
-version = "11.3.3.83"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "nvidia-nvjitlink-cu12" },
-]
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/1f/13/ee4e00f30e676b66ae65b4f08cb5bcbb8392c03f54f2d5413ea99a5d1c80/nvidia_cufft_cu12-11.3.3.83-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4d2dd21ec0b88cf61b62e6b43564355e5222e4a3fb394cac0db101f2dd0d4f74", size = 193118695, upload-time = "2025-03-07T01:45:27.821Z" },
-]
-
-[[package]]
-name = "nvidia-cufile-cu12"
-version = "1.13.1.3"
-source = { registry = "https://pypi.org/simple" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/bb/fe/1bcba1dfbfb8d01be8d93f07bfc502c93fa23afa6fd5ab3fc7c1df71038a/nvidia_cufile_cu12-1.13.1.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1d069003be650e131b21c932ec3d8969c1715379251f8d23a1860554b1cb24fc", size = 1197834, upload-time = "2025-03-07T01:45:50.723Z" },
-]
-
-[[package]]
-name = "nvidia-curand-cu12"
-version = "10.3.9.90"
-source = { registry = "https://pypi.org/simple" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fb/aa/6584b56dc84ebe9cf93226a5cde4d99080c8e90ab40f0c27bda7a0f29aa1/nvidia_curand_cu12-10.3.9.90-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:b32331d4f4df5d6eefa0554c565b626c7216f87a06a4f56fab27c3b68a830ec9", size = 63619976, upload-time = "2025-03-07T01:46:23.323Z" },
-]
-
-[[package]]
-name = "nvidia-cusolver-cu12"
-version = "11.7.3.90"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "nvidia-cublas-cu12" },
-    { name = "nvidia-cusparse-cu12" },
-    { name = "nvidia-nvjitlink-cu12" },
-]
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/85/48/9a13d2975803e8cf2777d5ed57b87a0b6ca2cc795f9a4f59796a910bfb80/nvidia_cusolver_cu12-11.7.3.90-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:4376c11ad263152bd50ea295c05370360776f8c3427b30991df774f9fb26c450", size = 267506905, upload-time = "2025-03-07T01:47:16.273Z" },
-]
-
-[[package]]
-name = "nvidia-cusparse-cu12"
-version = "12.5.8.93"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "nvidia-nvjitlink-cu12" },
-]
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c2/f5/e1854cb2f2bcd4280c44736c93550cc300ff4b8c95ebe370d0aa7d2b473d/nvidia_cusparse_cu12-12.5.8.93-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1ec05d76bbbd8b61b06a80e1eaf8cf4959c3d4ce8e711b65ebd0443bb0ebb13b", size = 288216466, upload-time = "2025-03-07T01:48:13.779Z" },
-]
-
-[[package]]
-name = "nvidia-cusparselt-cu12"
-version = "0.7.1"
-source = { registry = "https://pypi.org/simple" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/56/79/12978b96bd44274fe38b5dde5cfb660b1d114f70a65ef962bcbbed99b549/nvidia_cusparselt_cu12-0.7.1-py3-none-manylinux2014_x86_64.whl", hash = "sha256:f1bb701d6b930d5a7cea44c19ceb973311500847f81b634d802b7b539dc55623", size = 287193691, upload-time = "2025-02-26T00:15:44.104Z" },
-]
-
-[[package]]
-name = "nvidia-nccl-cu12"
-version = "2.27.5"
-source = { registry = "https://pypi.org/simple" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/6e/89/f7a07dc961b60645dbbf42e80f2bc85ade7feb9a491b11a1e973aa00071f/nvidia_nccl_cu12-2.27.5-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ad730cf15cb5d25fe849c6e6ca9eb5b76db16a80f13f425ac68d8e2e55624457", size = 322348229, upload-time = "2025-06-26T04:11:28.385Z" },
-]
-
-[[package]]
-name = "nvidia-nvjitlink-cu12"
-version = "12.8.93"
-source = { registry = "https://pypi.org/simple" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f6/74/86a07f1d0f42998ca31312f998bd3b9a7eff7f52378f4f270c8679c77fb9/nvidia_nvjitlink_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:81ff63371a7ebd6e6451970684f916be2eab07321b73c9d244dc2b4da7f73b88", size = 39254836, upload-time = "2025-03-07T01:49:55.661Z" },
-]
-
-[[package]]
-name = "nvidia-nvshmem-cu12"
-version = "3.3.20"
-source = { registry = "https://pypi.org/simple" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3b/6c/99acb2f9eb85c29fc6f3a7ac4dccfd992e22666dd08a642b303311326a97/nvidia_nvshmem_cu12-3.3.20-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d00f26d3f9b2e3c3065be895e3059d6479ea5c638a3f38c9fec49b1b9dd7c1e5", size = 124657145, upload-time = "2025-08-04T20:25:19.995Z" },
-]
-
-[[package]]
-name = "nvidia-nvtx-cu12"
-version = "12.8.90"
-source = { registry = "https://pypi.org/simple" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a2/eb/86626c1bbc2edb86323022371c39aa48df6fd8b0a1647bc274577f72e90b/nvidia_nvtx_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5b17e2001cc0d751a5bc2c6ec6d26ad95913324a4adb86788c944f8ce9ba441f", size = 89954, upload-time = "2025-03-07T01:42:44.131Z" },
-]
-
 [[package]]
 name = "oauthlib"
 version = "3.3.1"
@@ -1785,19 +1462,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/be/9c/92789c596b8df838baa98fa71844d84283302f7604ed565dafe5a6b5041a/oauthlib-3.3.1-py3-none-any.whl", hash = "sha256:88119c938d2b8fb88561af5f6ee0eec8cc8d552b7bb1f712743136eb7523b7a1", size = 160065, upload-time = "2025-06-19T22:48:06.508Z" },
 ]
 
-[[package]]
-name = "omegaconf"
-version = "2.3.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "antlr4-python3-runtime" },
-    { name = "pyyaml" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/09/48/6388f1bb9da707110532cb70ec4d2822858ddfb44f1cdf1233c20a80ea4b/omegaconf-2.3.0.tar.gz", hash = "sha256:d5d4b6d29955cc50ad50c46dc269bcd92c6e00f5f90d23ab5fee7bfca4ba4cc7", size = 3298120, upload-time = "2022-12-08T20:59:22.753Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e3/94/1843518e420fa3ed6919835845df698c7e27e183cb997394e4a670973a65/omegaconf-2.3.0-py3-none-any.whl", hash = "sha256:7b4df175cdb08ba400f45cae3bdcae7ba8365db4d165fc65fd04b050ab63b46b", size = 79500, upload-time = "2022-12-08T20:59:19.686Z" },
-]
-
 [[package]]
 name = "orjson"
 version = "3.11.5"
@@ -2446,25 +2110,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/84/25/d9db8be44e205a124f6c98bc0324b2bb149b7431c53877fc6d1038dddaf5/pytokens-0.3.0-py3-none-any.whl", hash = "sha256:95b2b5eaf832e469d141a378872480ede3f251a5a5041b8ec6e581d3ac71bbf3", size = 12195, upload-time = "2025-11-05T13:36:33.183Z" },
 ]
 
-[[package]]
-name = "pytorch-lightning"
-version = "2.6.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "fsspec", extra = ["http"] },
-    { name = "lightning-utilities" },
-    { name = "packaging" },
-    { name = "pyyaml" },
-    { name = "torch" },
-    { name = "torchmetrics" },
-    { name = "tqdm" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/07/d7/e3963d9669758f93b07941f4e2e82a394eb3d0980e29baa4764f3bad6689/pytorch_lightning-2.6.0.tar.gz", hash = "sha256:25b0d4f05e1f33b72be0920c34d0465777fe5f623228f9d6252b4b0f685d7037", size = 658853, upload-time = "2025-11-28T09:34:13.098Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/77/eb/cc6dbfe70d15318dbce82674b1e8057cef2634ca9f9121a16b8a06c630db/pytorch_lightning-2.6.0-py3-none-any.whl", hash = "sha256:ee72cff4b8c983ecfaae8599382544bd5236d9eb300adc7dd305f359195f4e79", size = 849476, upload-time = "2025-11-28T09:34:11.271Z" },
-]
-
 [[package]]
 name = "pyyaml"
 version = "6.0.3"
@@ -2511,30 +2156,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
 ]
 
-[[package]]
-name = "pyyaml-ft"
-version = "8.0.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/5e/eb/5a0d575de784f9a1f94e2b1288c6886f13f34185e13117ed530f32b6f8a8/pyyaml_ft-8.0.0.tar.gz", hash = "sha256:0c947dce03954c7b5d38869ed4878b2e6ff1d44b08a0d84dc83fdad205ae39ab", size = 141057, upload-time = "2025-06-10T15:32:15.613Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/68/ba/a067369fe61a2e57fb38732562927d5bae088c73cb9bb5438736a9555b29/pyyaml_ft-8.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8c1306282bc958bfda31237f900eb52c9bedf9b93a11f82e1aab004c9a5657a6", size = 187027, upload-time = "2025-06-10T15:31:48.722Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/c5/a3d2020ce5ccfc6aede0d45bcb870298652ac0cf199f67714d250e0cdf39/pyyaml_ft-8.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:30c5f1751625786c19de751e3130fc345ebcba6a86f6bddd6e1285342f4bbb69", size = 176146, upload-time = "2025-06-10T15:31:50.584Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/bb/23a9739291086ca0d3189eac7cd92b4d00e9fdc77d722ab610c35f9a82ba/pyyaml_ft-8.0.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3fa992481155ddda2e303fcc74c79c05eddcdbc907b888d3d9ce3ff3e2adcfb0", size = 746792, upload-time = "2025-06-10T15:31:52.304Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/c2/e8825f4ff725b7e560d62a3609e31d735318068e1079539ebfde397ea03e/pyyaml_ft-8.0.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cec6c92b4207004b62dfad1f0be321c9f04725e0f271c16247d8b39c3bf3ea42", size = 786772, upload-time = "2025-06-10T15:31:54.712Z" },
-    { url = "https://files.pythonhosted.org/packages/35/be/58a4dcae8854f2fdca9b28d9495298fd5571a50d8430b1c3033ec95d2d0e/pyyaml_ft-8.0.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:06237267dbcab70d4c0e9436d8f719f04a51123f0ca2694c00dd4b68c338e40b", size = 778723, upload-time = "2025-06-10T15:31:56.093Z" },
-    { url = "https://files.pythonhosted.org/packages/86/ed/fed0da92b5d5d7340a082e3802d84c6dc9d5fa142954404c41a544c1cb92/pyyaml_ft-8.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:8a7f332bc565817644cdb38ffe4739e44c3e18c55793f75dddb87630f03fc254", size = 758478, upload-time = "2025-06-10T15:31:58.314Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/69/ac02afe286275980ecb2dcdc0156617389b7e0c0a3fcdedf155c67be2b80/pyyaml_ft-8.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7d10175a746be65f6feb86224df5d6bc5c049ebf52b89a88cf1cd78af5a367a8", size = 799159, upload-time = "2025-06-10T15:31:59.675Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/ac/c492a9da2e39abdff4c3094ec54acac9747743f36428281fb186a03fab76/pyyaml_ft-8.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:58e1015098cf8d8aec82f360789c16283b88ca670fe4275ef6c48c5e30b22a96", size = 158779, upload-time = "2025-06-10T15:32:01.029Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/9b/41998df3298960d7c67653669f37710fa2d568a5fc933ea24a6df60acaf6/pyyaml_ft-8.0.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:e64fa5f3e2ceb790d50602b2fd4ec37abbd760a8c778e46354df647e7c5a4ebb", size = 191331, upload-time = "2025-06-10T15:32:02.602Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/16/2710c252ee04cbd74d9562ebba709e5a284faeb8ada88fcda548c9191b47/pyyaml_ft-8.0.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:8d445bf6ea16bb93c37b42fdacfb2f94c8e92a79ba9e12768c96ecde867046d1", size = 182879, upload-time = "2025-06-10T15:32:04.466Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/40/ae8163519d937fa7bfa457b6f78439cc6831a7c2b170e4f612f7eda71815/pyyaml_ft-8.0.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c56bb46b4fda34cbb92a9446a841da3982cdde6ea13de3fbd80db7eeeab8b49", size = 811277, upload-time = "2025-06-10T15:32:06.214Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/66/28d82dbff7f87b96f0eeac79b7d972a96b4980c1e445eb6a857ba91eda00/pyyaml_ft-8.0.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dab0abb46eb1780da486f022dce034b952c8ae40753627b27a626d803926483b", size = 831650, upload-time = "2025-06-10T15:32:08.076Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/df/161c4566facac7d75a9e182295c223060373d4116dead9cc53a265de60b9/pyyaml_ft-8.0.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bd48d639cab5ca50ad957b6dd632c7dd3ac02a1abe0e8196a3c24a52f5db3f7a", size = 815755, upload-time = "2025-06-10T15:32:09.435Z" },
-    { url = "https://files.pythonhosted.org/packages/05/10/f42c48fa5153204f42eaa945e8d1fd7c10d6296841dcb2447bf7da1be5c4/pyyaml_ft-8.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:052561b89d5b2a8e1289f326d060e794c21fa068aa11255fe71d65baf18a632e", size = 810403, upload-time = "2025-06-10T15:32:11.051Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/d2/e369064aa51009eb9245399fd8ad2c562bd0bcd392a00be44b2a824ded7c/pyyaml_ft-8.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:3bb4b927929b0cb162fb1605392a321e3333e48ce616cdcfa04a839271373255", size = 835581, upload-time = "2025-06-10T15:32:12.897Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/28/26534bed77109632a956977f60d8519049f545abc39215d086e33a61f1f2/pyyaml_ft-8.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:de04cfe9439565e32f178106c51dd6ca61afaa2907d143835d501d84703d3793", size = 171579, upload-time = "2025-06-10T15:32:14.34Z" },
-]
-
 [[package]]
 name = "requests"
 version = "2.32.5"
@@ -2613,15 +2234,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c4/1c/1dbe51782c0e1e9cfce1d1004752672d2d4629ea46945d19d731ad772b3b/ruff-0.14.11-py3-none-win_arm64.whl", hash = "sha256:649fb6c9edd7f751db276ef42df1f3df41c38d67d199570ae2a7bd6cbc3590f0", size = 12938644, upload-time = "2026-01-08T19:11:50.027Z" },
 ]
 
-[[package]]
-name = "setuptools"
-version = "80.9.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/18/5d/3bf57dcd21979b887f014ea83c24ae194cfcd12b9e0fda66b957c69d1fca/setuptools-80.9.0.tar.gz", hash = "sha256:f36b47402ecde768dbfafc46e8e4207b4360c654f1f3bb84475f0a28628fb19c", size = 1319958, upload-time = "2025-05-27T00:56:51.443Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a3/dc/17031897dae0efacfea57dfd3a82fdd2a2aeb58e0ff71b77b87e44edc772/setuptools-80.9.0-py3-none-any.whl", hash = "sha256:062d34222ad13e0cc312a4c02d73f059e86a4acbfbdea8f8f76b28c99f306922", size = 1201486, upload-time = "2025-05-27T00:56:49.664Z" },
-]
-
 [[package]]
 name = "six"
 version = "1.17.0"
@@ -2636,13 +2248,10 @@ name = "specs-before-code-api"
 version = "1.0.0"
 source = { virtual = "." }
 dependencies = [
-    { name = "cloudpickle" },
     { name = "fastapi" },
-    { name = "fiddle" },
     { name = "fpdf2" },
     { name = "google-api-python-client" },
     { name = "google-auth-oauthlib" },
-    { name = "hydra-core" },
     { name = "jinja2" },
     { name = "langchain-core" },
     { name = "langchain-mongodb" },
@@ -2650,7 +2259,6 @@ dependencies = [
     { name = "langchain-text-splitters" },
     { name = "langgraph" },
     { name = "langsmith" },
-    { name = "lightning" },
     { name = "numpy" },
     { name = "passlib", extra = ["bcrypt"] },
     { name = "psycopg2-binary" },
@@ -2689,14 +2297,11 @@ dev = [
 [package.metadata]
 requires-dist = [
     { name = "black", marker = "extra == 'dev'", specifier = ">=24.0.0" },
-    { name = "cloudpickle", specifier = ">=3.1.2" },
     { name = "fastapi", specifier = ">=0.123.0" },
-    { name = "fiddle", specifier = ">=0.3.0" },
     { name = "fpdf2", specifier = ">=2.8.0" },
     { name = "google-api-python-client", specifier = ">=2.111.0" },
     { name = "google-auth-oauthlib", specifier = ">=1.2.0" },
     { name = "httpx", marker = "extra == 'dev'", specifier = ">=0.27.0" },
-    { name = "hydra-core", specifier = ">=1.3.2" },
     { name = "jinja2", specifier = ">=3.1.6" },
     { name = "langchain-core", specifier = ">=0.1.0" },
     { name = "langchain-mongodb", specifier = ">=0.1.0" },
@@ -2704,7 +2309,6 @@ requires-dist = [
     { name = "langchain-text-splitters", specifier = ">=0.0.1" },
     { name = "langgraph", specifier = ">=0.2.39" },
     { name = "langsmith", specifier = ">=0.1.0" },
-    { name = "lightning", specifier = ">=2.6.0" },
     { name = "mypy", marker = "extra == 'dev'", specifier = ">=1.10.0" },
     { name = "numpy", specifier = ">=1.26.0" },
     { name = "passlib", extras = ["bcrypt"], specifier = ">=1.7.4" },
@@ -2783,18 +2387,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d9/52/1064f510b141bd54025f9b55105e26d1fa970b9be67ad766380a3c9b74b0/starlette-0.50.0-py3-none-any.whl", hash = "sha256:9e5391843ec9b6e472eed1365a78c8098cfceb7a74bfd4d6b1c0c0095efb3bca", size = 74033, upload-time = "2025-11-01T15:25:25.461Z" },
 ]
 
-[[package]]
-name = "sympy"
-version = "1.14.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "mpmath" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", hash = "sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517", size = 7793921, upload-time = "2025-04-27T18:05:01.611Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353, upload-time = "2025-04-27T18:04:59.103Z" },
-]
-
 [[package]]
 name = "tenacity"
 version = "9.1.2"
@@ -2804,97 +2396,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e5/30/643397144bfbfec6f6ef821f36f33e57d35946c44a2352d3c9f0ae847619/tenacity-9.1.2-py3-none-any.whl", hash = "sha256:f77bf36710d8b73a50b2dd155c97b870017ad21afe6ab300326b0371b3b05138", size = 28248, upload-time = "2025-04-02T08:25:07.678Z" },
 ]
 
-[[package]]
-name = "torch"
-version = "2.9.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "filelock" },
-    { name = "fsspec" },
-    { name = "jinja2" },
-    { name = "networkx" },
-    { name = "nvidia-cublas-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-cuda-cupti-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-cuda-nvrtc-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-cuda-runtime-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-cudnn-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-cufft-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-cufile-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-curand-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-cusolver-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-cusparse-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-cusparselt-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-nccl-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-nvjitlink-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-nvshmem-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-nvtx-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "setuptools" },
-    { name = "sympy" },
-    { name = "triton", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "typing-extensions" },
-]
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/0f/27/07c645c7673e73e53ded71705045d6cb5bae94c4b021b03aa8d03eee90ab/torch-2.9.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:da5f6f4d7f4940a173e5572791af238cb0b9e21b1aab592bd8b26da4c99f1cd6", size = 104126592, upload-time = "2025-11-12T15:20:41.62Z" },
-    { url = "https://files.pythonhosted.org/packages/19/17/e377a460603132b00760511299fceba4102bd95db1a0ee788da21298ccff/torch-2.9.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:27331cd902fb4322252657f3902adf1c4f6acad9dcad81d8df3ae14c7c4f07c4", size = 899742281, upload-time = "2025-11-12T15:22:17.602Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/1a/64f5769025db846a82567fa5b7d21dba4558a7234ee631712ee4771c436c/torch-2.9.1-cp312-cp312-win_amd64.whl", hash = "sha256:81a285002d7b8cfd3fdf1b98aa8df138d41f1a8334fd9ea37511517cedf43083", size = 110940568, upload-time = "2025-11-12T15:21:18.689Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/ab/07739fd776618e5882661d04c43f5b5586323e2f6a2d7d84aac20d8f20bd/torch-2.9.1-cp312-none-macosx_11_0_arm64.whl", hash = "sha256:c0d25d1d8e531b8343bea0ed811d5d528958f1dcbd37e7245bc686273177ad7e", size = 74479191, upload-time = "2025-11-12T15:21:25.816Z" },
-    { url = "https://files.pythonhosted.org/packages/20/60/8fc5e828d050bddfab469b3fe78e5ab9a7e53dda9c3bdc6a43d17ce99e63/torch-2.9.1-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:c29455d2b910b98738131990394da3e50eea8291dfeb4b12de71ecf1fdeb21cb", size = 104135743, upload-time = "2025-11-12T15:21:34.936Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/b7/6d3f80e6918213babddb2a37b46dbb14c15b14c5f473e347869a51f40e1f/torch-2.9.1-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:524de44cd13931208ba2c4bde9ec7741fd4ae6bfd06409a604fc32f6520c2bc9", size = 899749493, upload-time = "2025-11-12T15:24:36.356Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/47/c7843d69d6de8938c1cbb1eba426b1d48ddf375f101473d3e31a5fc52b74/torch-2.9.1-cp313-cp313-win_amd64.whl", hash = "sha256:545844cc16b3f91e08ce3b40e9c2d77012dd33a48d505aed34b7740ed627a1b2", size = 110944162, upload-time = "2025-11-12T15:21:53.151Z" },
-    { url = "https://files.pythonhosted.org/packages/28/0e/2a37247957e72c12151b33a01e4df651d9d155dd74d8cfcbfad15a79b44a/torch-2.9.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5be4bf7496f1e3ffb1dd44b672adb1ac3f081f204c5ca81eba6442f5f634df8e", size = 74830751, upload-time = "2025-11-12T15:21:43.792Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/f7/7a18745edcd7b9ca2381aa03353647bca8aace91683c4975f19ac233809d/torch-2.9.1-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:30a3e170a84894f3652434b56d59a64a2c11366b0ed5776fab33c2439396bf9a", size = 104142929, upload-time = "2025-11-12T15:21:48.319Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/dd/f1c0d879f2863ef209e18823a988dc7a1bf40470750e3ebe927efdb9407f/torch-2.9.1-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:8301a7b431e51764629208d0edaa4f9e4c33e6df0f2f90b90e261d623df6a4e2", size = 899748978, upload-time = "2025-11-12T15:23:04.568Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/9f/6986b83a53b4d043e36f3f898b798ab51f7f20fdf1a9b01a2720f445043d/torch-2.9.1-cp313-cp313t-win_amd64.whl", hash = "sha256:2e1c42c0ae92bf803a4b2409fdfed85e30f9027a66887f5e7dcdbc014c7531db", size = 111176995, upload-time = "2025-11-12T15:22:01.618Z" },
-    { url = "https://files.pythonhosted.org/packages/40/60/71c698b466dd01e65d0e9514b5405faae200c52a76901baf6906856f17e4/torch-2.9.1-cp313-none-macosx_11_0_arm64.whl", hash = "sha256:2c14b3da5df416cf9cb5efab83aa3056f5b8cd8620b8fde81b4987ecab730587", size = 74480347, upload-time = "2025-11-12T15:21:57.648Z" },
-    { url = "https://files.pythonhosted.org/packages/48/50/c4b5112546d0d13cc9eaa1c732b823d676a9f49ae8b6f97772f795874a03/torch-2.9.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1edee27a7c9897f4e0b7c14cfc2f3008c571921134522d5b9b5ec4ebbc69041a", size = 74433245, upload-time = "2025-11-12T15:22:39.027Z" },
-    { url = "https://files.pythonhosted.org/packages/81/c9/2628f408f0518b3bae49c95f5af3728b6ab498c8624ab1e03a43dd53d650/torch-2.9.1-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:19d144d6b3e29921f1fc70503e9f2fc572cde6a5115c0c0de2f7ca8b1483e8b6", size = 104134804, upload-time = "2025-11-12T15:22:35.222Z" },
-    { url = "https://files.pythonhosted.org/packages/28/fc/5bc91d6d831ae41bf6e9e6da6468f25330522e92347c9156eb3f1cb95956/torch-2.9.1-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:c432d04376f6d9767a9852ea0def7b47a7bbc8e7af3b16ac9cf9ce02b12851c9", size = 899747132, upload-time = "2025-11-12T15:23:36.068Z" },
-    { url = "https://files.pythonhosted.org/packages/63/5d/e8d4e009e52b6b2cf1684bde2a6be157b96fb873732542fb2a9a99e85a83/torch-2.9.1-cp314-cp314-win_amd64.whl", hash = "sha256:d187566a2cdc726fc80138c3cdb260970fab1c27e99f85452721f7759bbd554d", size = 110934845, upload-time = "2025-11-12T15:22:48.367Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/b2/2d15a52516b2ea3f414643b8de68fa4cb220d3877ac8b1028c83dc8ca1c4/torch-2.9.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:cb10896a1f7fedaddbccc2017ce6ca9ecaaf990f0973bdfcf405439750118d2c", size = 74823558, upload-time = "2025-11-12T15:22:43.392Z" },
-    { url = "https://files.pythonhosted.org/packages/86/5c/5b2e5d84f5b9850cd1e71af07524d8cbb74cba19379800f1f9f7c997fc70/torch-2.9.1-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:0a2bd769944991c74acf0c4ef23603b9c777fdf7637f115605a4b2d8023110c7", size = 104145788, upload-time = "2025-11-12T15:23:52.109Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/8c/3da60787bcf70add986c4ad485993026ac0ca74f2fc21410bc4eb1bb7695/torch-2.9.1-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:07c8a9660bc9414c39cac530ac83b1fb1b679d7155824144a40a54f4a47bfa73", size = 899735500, upload-time = "2025-11-12T15:24:08.788Z" },
-    { url = "https://files.pythonhosted.org/packages/db/2b/f7818f6ec88758dfd21da46b6cd46af9d1b3433e53ddbb19ad1e0da17f9b/torch-2.9.1-cp314-cp314t-win_amd64.whl", hash = "sha256:c88d3299ddeb2b35dcc31753305612db485ab6f1823e37fb29451c8b2732b87e", size = 111163659, upload-time = "2025-11-12T15:23:20.009Z" },
-]
-
-[[package]]
-name = "torchmetrics"
-version = "1.8.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "lightning-utilities" },
-    { name = "numpy" },
-    { name = "packaging" },
-    { name = "torch" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/85/2e/48a887a59ecc4a10ce9e8b35b3e3c5cef29d902c4eac143378526e7485cb/torchmetrics-1.8.2.tar.gz", hash = "sha256:cf64a901036bf107f17a524009eea7781c9c5315d130713aeca5747a686fe7a5", size = 580679, upload-time = "2025-09-03T14:00:54.077Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/02/21/aa0f434434c48490f91b65962b1ce863fdcce63febc166ca9fe9d706c2b6/torchmetrics-1.8.2-py3-none-any.whl", hash = "sha256:08382fd96b923e39e904c4d570f3d49e2cc71ccabd2a94e0f895d1f0dac86242", size = 983161, upload-time = "2025-09-03T14:00:51.921Z" },
-]
-
-[[package]]
-name = "tqdm"
-version = "4.67.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "colorama", marker = "sys_platform == 'win32'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/a8/4b/29b4ef32e036bb34e4ab51796dd745cdba7ed47ad142a9f4a1eb8e0c744d/tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2", size = 169737, upload-time = "2024-11-24T20:12:22.481Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d0/30/dc54f88dd4a2b5dc8a0279bdd7270e735851848b762aeb1c1184ed1f6b14/tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2", size = 78540, upload-time = "2024-11-24T20:12:19.698Z" },
-]
-
-[[package]]
-name = "triton"
-version = "3.5.1"
-source = { registry = "https://pypi.org/simple" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f2/50/9a8358d3ef58162c0a415d173cfb45b67de60176e1024f71fbc4d24c0b6d/triton-3.5.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d2c6b915a03888ab931a9fd3e55ba36785e1fe70cbea0b40c6ef93b20fc85232", size = 170470207, upload-time = "2025-11-11T17:41:00.253Z" },
-    { url = "https://files.pythonhosted.org/packages/27/46/8c3bbb5b0a19313f50edcaa363b599e5a1a5ac9683ead82b9b80fe497c8d/triton-3.5.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f3f4346b6ebbd4fad18773f5ba839114f4826037c9f2f34e0148894cd5dd3dba", size = 170470410, upload-time = "2025-11-11T17:41:06.319Z" },
-    { url = "https://files.pythonhosted.org/packages/37/92/e97fcc6b2c27cdb87ce5ee063d77f8f26f19f06916aa680464c8104ef0f6/triton-3.5.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0b4d2c70127fca6a23e247f9348b8adde979d2e7a20391bfbabaac6aebc7e6a8", size = 170579924, upload-time = "2025-11-11T17:41:12.455Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/e6/c595c35e5c50c4bc56a7bac96493dad321e9e29b953b526bbbe20f9911d0/triton-3.5.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d0637b1efb1db599a8e9dc960d53ab6e4637db7d4ab6630a0974705d77b14b60", size = 170480488, upload-time = "2025-11-11T17:41:18.222Z" },
-    { url = "https://files.pythonhosted.org/packages/16/b5/b0d3d8b901b6a04ca38df5e24c27e53afb15b93624d7fd7d658c7cd9352a/triton-3.5.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bac7f7d959ad0f48c0e97d6643a1cc0fd5786fe61cb1f83b537c6b2d54776478", size = 170582192, upload-time = "2025-11-11T17:41:23.963Z" },
-]
-
 [[package]]
 name = "typing-extensions"
 version = "4.15.0"