feat: Harden API, pin dependencies, and enable pytest CI gate

- /health/deep: 1-token ping per configured LLM provider (key presence
no longer masquerades as a working model)
- Abuse guards on POST /analyze: per-IP rate limit (10/h), concurrent
workflow cap (3), and 1h TTL eviction for the in-memory store
- CORS: hf.space subdomains via allow_origin_regex (literal wildcard was
a no-op); drop unused allow_credentials
- Lifespan handler replaces deprecated @app .on_event startup hook
- Cache-Control: immutable for hashed /assets, no-cache for the shell
- Dependencies: requirements.in + uv-compiled fully pinned requirements.txt
(captures the exact resolution validated by today's live canary);
Dockerfile uses npm ci for the frontend
- Tests: replace live-integration test (needed API keys, imported deleted
graph_cyclic) with unit tests for loop routing; pytest added to CI

.github/workflows/ci.yml

@@ -16,9 +16,11 @@ jobs:
           python-version: "3.11"
           cache: pip
       - name: Install dependencies
-        run: pip install -r requirements.txt flake8
+        run: pip install -r requirements.txt flake8 pytest
       - name: Lint (critical errors only)
         run: flake8 src --select=E9,F63,F7,F82 --show-source
+      - name: Unit tests
+        run: python -m pytest tests -q
       - name: Import smoke test
         run: python -c "from src.api.app import app; from src.workflow.graph import app as graph_app; print('imports OK')"
 

Dockerfile

@@ -9,8 +9,8 @@ WORKDIR /frontend
 # Copy package files first for better caching
 COPY frontend/package.json frontend/package-lock.json ./
 
-# Install dependencies (use npm install to resolve version mismatches)
-RUN npm install --legacy-peer-deps
+# Install dependencies from the lockfile for reproducible builds
+RUN npm ci --legacy-peer-deps
 
 # Copy frontend source code
 COPY frontend/ ./

docs/audit_checklist.md

@@ -5,42 +5,42 @@
 - [x] Remove `frontend/.env.production` (deleted from working tree 2026-07-17; commit pending)
 - [x] Commit the `BUSINESS_README.md` change (95a89bb, pushed 2026-07-18)
 - [x] Push `origin/main` to the `hf` remote — drift closed, both remotes at 7045b2d (2026-07-18)
-- [ ] After redeploy, fetch the served JS bundle and confirm it contains no `execute-api` URL
+- [x] After redeploy, served JS bundle verified free of `execute-api` URLs (2026-07-18)
 - [x] Update code defaults in `src/llm_client.py` and `.env.example` to the new model IDs (done 2026-07-17; commit pending)
 - [x] Fix `A2A_RESEARCHER_URL` in `.env.example` (done 2026-07-17; commit pending)
 - [x] Replace SEC EDGAR User-Agent placeholder with real contact (fetchers.py + config.py, pushed 2026-07-18)
 - [x] Add a LICENSE file (MIT) to Instant-SWOT-Agent (pushed 2026-07-18)
 - [x] Add a LICENSE file (MIT) to Researcher-Agent (pushed 2026-07-18)
-- [ ] Pin Python dependencies with a lockfile (`uv pip compile` or `pip-compile`) for Instant-SWOT-Agent and rebuild
-- [ ] Pin Python dependencies for Researcher-Agent and its MCP server requirements files
-- [ ] Change Dockerfile frontend stage from `npm install --legacy-peer-deps` to `npm ci`
-- [ ] Verify a clean-clone Docker build succeeds with pinned deps (LangGraph now resolves to 1.x; confirm StateGraph workflow still runs)
+- [x] Pin Python dependencies via uv pip compile (requirements.in -> fully pinned requirements.txt, 2026-07-18)
+- [x] Pin Researcher-Agent root requirements via uv (2026-07-18); per-MCP-server requirements files are for standalone use only (Docker installs root file)
+- [x] Dockerfile frontend stage now uses `npm ci --legacy-peer-deps` (2026-07-18)
+- [x] Pinned resolution (langgraph 0.6.11, langchain 0.3.30) matches the rebuild the live canary validated on 2026-07-18
 - [x] Add GitHub Actions CI (2026-07-18): flake8 critical + import smoke on backend, eslint (non-blocking) + build on frontend; pytest excluded — existing tests are live integration tests needing API keys, modernize under the test-suite item
 - [x] Add GitHub Actions auto-mirror `main` -> HF Space via `HF_TOKEN` secret (2026-07-18)
 - [x] Investigate the 0-revision anomaly: resolved — with working models the loop revises correctly (MSFT run: 3 revisions, score 5.7); earlier 0-revision AAPL run was likely `analyzer_revision_skipped` triggered by dead fallback models
 - [ ] Enable LangSmith tracing (`LANGCHAIN_TRACING_V2=true` + key on the HF Space) to support the loop investigation
-- [ ] Add a deep health check that pings each configured LLM with a 1-token request instead of only checking key presence
+- [x] Add `/health/deep` endpoint pinging each configured LLM with a tiny request (2026-07-18)
 - [x] Check the Supabase project is not paused (confirmed working 2026-07-17: https://atilxlecbaqcksnrgzav.supabase.co)
-- [ ] Document `PIPELINE_SUPABASE_URL` in `.env.example` and CLAUDE.md
+- [x] Document `PIPELINE_SUPABASE_URL` in `.env.example` and CLAUDE.md (2026-07-18)
 - [x] Add missing env vars to Researcher-Agent `.env.example` (pushed 2026-07-18)
 - [ ] Confirm which optional keys (NYT, NewsAPI, Alpha Vantage, Tradier, BLS, BEA) are actually set as Researcher-Agent Space secrets and prune unused ones
 - [x] Decide whether AWS or HF Spaces is the canonical backend (decided: HF; AWS backend torn down 2026-07-17 via AWS CLI — API Gateway, 8 Lambdas, Step Functions, 2 DynamoDB tables, 3 S3 buckets, 2 alarms, 8 log groups, 2 IAM roles deleted; secret `swot-agent-api-keys` scheduled for deletion 2026-07-24)
-- [ ] Remove the now-dead `awsDeployment/` directory and AWS references from the repo (or archive to a branch)
-- [ ] Fix CORS in `src/api/app.py`: replace ineffective literal `https://*.hf.space` with `allow_origin_regex`, drop `allow_credentials=True`
-- [ ] Add per-IP rate limiting (e.g., `slowapi`) and a concurrent-workflow cap on `POST /analyze`
-- [ ] Add TTL eviction for the in-memory `WORKFLOWS` dict in `src/services/workflow_store.py` and the task dict in Researcher-Agent `app.py`
-- [ ] Update README.md and CLAUDE.md to match the real workflow (no Editor node, exit threshold 6 not 7)
-- [ ] Delete dead code: `src/graph_cyclic.py`
-- [ ] Remove unused deps from `requirements.txt`: `langchain-groq`, `google-generativeai`, `tavily-python`, `mcp`
-- [ ] Fix stale `pyproject.toml`: project name, Streamlit deps, wrong repo URLs, broken `app:main` console script
+- [x] Remove `awsDeployment/` directory (2026-07-18; history preserves it)
+- [x] Fix CORS: `allow_origin_regex` for hf.space subdomains, credentials dropped (2026-07-18)
+- [x] Add per-IP rate limit (10/h) and concurrent-workflow cap (3) on `POST /analyze` (2026-07-18, dependency-free in-memory guards)
+- [x] Add 1h TTL eviction for `WORKFLOWS` (analysis route) and Researcher `TASK_STORE` (2026-07-18)
+- [x] Update README.md and CLAUDE.md to match the real workflow (2026-07-18)
+- [x] Delete dead code: `src/graph_cyclic.py` (2026-07-18)
+- [x] Remove unused deps from `requirements.txt` (2026-07-18)
+- [x] Rewrite stale `pyproject.toml` (2026-07-18)
 - [x] Remove repo noise from Researcher-Agent: `reports/` and `.obsidian/` untracked + gitignored (pushed 2026-07-18)
-- [ ] Delete the local 265MB `awsDeployment/build/` directory
+- [x] Delete the local 265MB `awsDeployment/build/` directory (2026-07-18)
 - [ ] Switch to structured JSON outputs (`response_format: json_object`) for critic/analyzer calls on Groq/OpenRouter
-- [ ] Replace deprecated `@app.on_event("startup")` with a lifespan handler in `src/api/app.py`
-- [ ] Fix local dev environment: `pip install -r requirements.txt` (pytest currently fails on missing `vaderSentiment`) and get the test suite green
+- [x] Replace deprecated `@app.on_event` with a lifespan handler (2026-07-18)
+- [x] Test suite green: live-integration test replaced with 7 unit tests for the loop conditions; pytest now gates CI (2026-07-18)
 - [ ] Keep MCP server sessions persistent in Researcher-Agent instead of spawning 6 subprocesses per request
 - [x] Add scheduled live canary: weekly (Mon 06:17 UTC) E2E analysis asserting provider, SWOT sections, and data sources (2026-07-18)
 - [x] Weekly keep-warm ping: covered by the canary's health checks against both Spaces (2026-07-18)
 - [ ] Upgrade Vite 5 → 7 (EOL) and React 18 → 19 when next touching the frontend
-- [ ] Add cache headers to FastAPI `StaticFiles` serving of the frontend bundle
+- [x] Add cache headers: immutable for hashed /assets, no-cache for the app shell (2026-07-18)
 - [ ] Consider SSE streaming of workflow status to replace 15s frontend polling

requirements.in

@@ -0,0 +1,30 @@
+# Core
+python-dotenv>=1.0.0
+pydantic>=2.0.0
+
+# LangChain/LangGraph
+langchain>=0.1.0,<1.0
+langgraph>=0.1.0,<1.0
+langchain-core>=0.1.0,<1.0
+langsmith>=0.1.0
+
+# LLM Providers (Groq is primary, others are fallback)
+requests>=2.31.0
+
+
+# HTTP Client
+httpx>=0.27.0
+
+# Yahoo Finance
+yfinance>=0.2.40
+
+# A2A Server (for Researcher A2A mode)
+fastapi>=0.115.0
+uvicorn>=0.32.0
+
+
+# Sentiment Analysis
+vaderSentiment>=3.3.2
+
+# Database
+psycopg2-binary>=2.9.0

requirements.txt

@@ -1,30 +1,196 @@
-# Core
-python-dotenv>=1.0.0
-pydantic>=2.0.0
-
-# LangChain/LangGraph
-langchain>=0.1.0,<1.0
-langgraph>=0.1.0,<1.0
-langchain-core>=0.1.0,<1.0
-langsmith>=0.1.0
-
-# LLM Providers (Groq is primary, others are fallback)
-requests>=2.31.0
-
-
-# HTTP Client
-httpx>=0.27.0
-
-# Yahoo Finance
-yfinance>=0.2.40
-
-# A2A Server (for Researcher A2A mode)
-fastapi>=0.115.0
-uvicorn>=0.32.0
-
-
-# Sentiment Analysis
-vaderSentiment>=3.3.2
-
-# Database
-psycopg2-binary>=2.9.0
+# This file was autogenerated by uv via the following command:
+#    uv pip compile requirements.in -o requirements.txt --python-version 3.11
+annotated-doc==0.0.4
+    # via fastapi
+annotated-types==0.7.0
+    # via pydantic
+anyio==4.14.2
+    # via
+    #   httpx
+    #   langsmith
+    #   starlette
+beautifulsoup4==4.15.0
+    # via yfinance
+certifi==2026.6.17
+    # via
+    #   curl-cffi
+    #   httpcore
+    #   httpx
+    #   requests
+cffi==2.1.0
+    # via curl-cffi
+charset-normalizer==3.4.9
+    # via requests
+click==8.4.2
+    # via uvicorn
+curl-cffi==0.15.0
+    # via yfinance
+distro==1.9.0
+    # via langsmith
+fastapi==0.139.2
+    # via -r requirements.in
+greenlet==3.5.3
+    # via sqlalchemy
+h11==0.16.0
+    # via
+    #   httpcore
+    #   uvicorn
+httpcore==1.0.9
+    # via httpx
+httpx==0.28.1
+    # via
+    #   -r requirements.in
+    #   langgraph-sdk
+    #   langsmith
+idna==3.18
+    # via
+    #   anyio
+    #   httpx
+    #   requests
+jsonpatch==1.33
+    # via langchain-core
+jsonpointer==3.1.1
+    # via jsonpatch
+langchain==0.3.30
+    # via -r requirements.in
+langchain-core==0.3.86
+    # via
+    #   -r requirements.in
+    #   langchain
+    #   langchain-text-splitters
+    #   langgraph
+    #   langgraph-checkpoint
+    #   langgraph-prebuilt
+langchain-text-splitters==0.3.11
+    # via langchain
+langgraph==0.6.11
+    # via -r requirements.in
+langgraph-checkpoint==3.0.1
+    # via
+    #   langgraph
+    #   langgraph-prebuilt
+langgraph-prebuilt==0.6.5
+    # via langgraph
+langgraph-sdk==0.2.15
+    # via langgraph
+langsmith==0.10.6
+    # via
+    #   -r requirements.in
+    #   langchain
+    #   langchain-core
+markdown-it-py==4.2.0
+    # via rich
+mdurl==0.1.2
+    # via markdown-it-py
+multitasking==0.0.13
+    # via yfinance
+numpy==2.4.6
+    # via
+    #   pandas
+    #   yfinance
+orjson==3.11.9
+    # via
+    #   langgraph-sdk
+    #   langsmith
+ormsgpack==1.12.2
+    # via langgraph-checkpoint
+packaging==25.0
+    # via
+    #   langchain-core
+    #   langsmith
+pandas==3.0.3
+    # via yfinance
+peewee==4.2.6
+    # via yfinance
+platformdirs==4.10.0
+    # via yfinance
+protobuf==7.35.1
+    # via yfinance
+psycopg2-binary==2.9.12
+    # via -r requirements.in
+pycparser==3.0
+    # via cffi
+pydantic==2.13.4
+    # via
+    #   -r requirements.in
+    #   fastapi
+    #   langchain
+    #   langchain-core
+    #   langgraph
+    #   langsmith
+pydantic-core==2.46.4
+    # via pydantic
+pygments==2.20.0
+    # via rich
+python-dateutil==2.9.0.post0
+    # via pandas
+python-dotenv==1.2.2
+    # via -r requirements.in
+pytz==2026.2
+    # via yfinance
+pyyaml==6.0.3
+    # via
+    #   langchain
+    #   langchain-core
+requests==2.34.2
+    # via
+    #   -r requirements.in
+    #   langchain
+    #   langsmith
+    #   requests-toolbelt
+    #   vadersentiment
+    #   yfinance
+requests-toolbelt==1.0.0
+    # via langsmith
+rich==15.0.0
+    # via curl-cffi
+six==1.17.0
+    # via python-dateutil
+sniffio==1.3.1
+    # via langsmith
+soupsieve==2.8.4
+    # via beautifulsoup4
+sqlalchemy==2.0.51
+    # via langchain
+starlette==1.3.1
+    # via fastapi
+tenacity==9.1.4
+    # via langchain-core
+typing-extensions==4.16.0
+    # via
+    #   anyio
+    #   beautifulsoup4
+    #   fastapi
+    #   langchain-core
+    #   langsmith
+    #   pydantic
+    #   pydantic-core
+    #   sqlalchemy
+    #   starlette
+    #   typing-inspection
+typing-inspection==0.4.2
+    # via
+    #   fastapi
+    #   pydantic
+urllib3==2.7.0
+    # via requests
+uuid-utils==0.17.0
+    # via
+    #   langchain-core
+    #   langsmith
+uvicorn==0.51.0
+    # via -r requirements.in
+vadersentiment==3.3.2
+    # via -r requirements.in
+websockets==16.1.1
+    # via
+    #   langsmith
+    #   yfinance
+xxhash==3.8.1
+    # via
+    #   langgraph
+    #   langsmith
+yfinance==1.5.1
+    # via -r requirements.in
+zstandard==0.25.0
+    # via langsmith

src/api/app.py

@@ -29,13 +29,26 @@ if os.getenv("OPENROUTER_API_KEY"):
     _llm_providers.append("OpenRouter")
 print(f"[Startup] LLM providers available: {_llm_providers or 'NONE - check HF Spaces secrets!'}")
 
+from contextlib import asynccontextmanager
+
+
+@asynccontextmanager
+async def lifespan(_app: FastAPI):
+    """Load stock listings on startup."""
+    await load_stock_listings()
+    yield
+
+
 app = FastAPI(
     title="Instant SWOT Agent API",
     description="Multi-agent SWOT analysis with self-correcting quality control",
-    version="2.0.0"
+    version="2.0.0",
+    lifespan=lifespan,
 )
 
-# CORS configuration for React frontend
+# CORS configuration for React frontend.
+# Note: literal wildcards like "https://*.hf.space" are NOT matched by
+# allow_origins; subdomain patterns require allow_origin_regex.
 app.add_middleware(
     CORSMiddleware,
     allow_origins=[
@@ -44,24 +57,28 @@ app.add_middleware(
         "http://localhost:8081",
         "http://localhost:3000",
         "https://huggingface.co",
-        "https://*.hf.space",
     ],
-    allow_credentials=True,
+    allow_origin_regex=r"https://.*\.hf\.space",
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
+
+@app.middleware("http")
+async def cache_headers(request, call_next):
+    """Immutable caching for hashed /assets bundles; no-cache for the shell."""
+    response = await call_next(request)
+    if request.url.path.startswith("/assets/"):
+        response.headers["Cache-Control"] = "public, max-age=31536000, immutable"
+    elif request.url.path == "/":
+        response.headers["Cache-Control"] = "no-cache"
+    return response
+
 # Include routers
 app.include_router(analysis_router)
 app.include_router(stocks_router)
 
 
-@app.on_event("startup")
-async def startup_event():
-    """Load stock listings on startup."""
-    await load_stock_listings()
-
-
 @app.get("/health")
 async def health_check():
     """Health check endpoint."""
@@ -78,6 +95,44 @@ async def health_check():
     }
 
 
+@app.get("/health/deep")
+def health_check_deep():
+    """
+    Deep health check: sends a 1-token prompt to every configured LLM provider.
+    Distinguishes 'key present' from 'model actually serves' — a plain key
+    check masked the June 2026 Gemini/OpenRouter model retirements.
+    Runs in the threadpool (sync def) since provider calls are blocking.
+    """
+    from src.llm_client import LLMClient
+
+    results = {}
+    try:
+        client = LLMClient()
+    except ValueError as e:
+        return {"status": "error", "detail": str(e), "providers": {}}
+
+    for provider in client.providers:
+        try:
+            content, error = client._call_provider(
+                provider=provider, prompt="Reply with: OK",
+                temperature=0, max_tokens=20
+            )
+            results[provider["name"]] = {
+                "model": provider["model"],
+                "ok": bool(content),
+                "error": error,
+            }
+        except Exception as e:
+            results[provider["name"]] = {
+                "model": provider["model"], "ok": False, "error": str(e)
+            }
+
+    return {
+        "status": "ok" if any(r["ok"] for r in results.values()) else "degraded",
+        "providers": results,
+    }
+
+
 @app.get("/api")
 async def api_info():
     """API info endpoint."""

src/api/routes/analysis.py

@@ -3,10 +3,12 @@ Analysis and workflow route handlers.
 Handles SWOT analysis workflow lifecycle.
 """
 
+import time
 import uuid
 import threading
+from collections import defaultdict, deque
 
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter, HTTPException, Request
 
 from src.api.schemas import AnalysisRequest, WorkflowStartResponse
 from src.services.workflow_store import (
@@ -18,14 +20,62 @@ from src.services.workflow_store import (
 
 router = APIRouter()
 
+# Abuse guards for the public endpoint (in-memory, per-process)
+WORKFLOW_TTL_SECONDS = 3600       # evict finished workflows after 1h
+MAX_ACTIVE_WORKFLOWS = 3          # concurrent analyses per instance
+RATE_LIMIT_WINDOW_SECONDS = 3600
+RATE_LIMIT_MAX_REQUESTS = 10      # analyses per IP per window
+_REQUESTS_BY_IP: dict = defaultdict(deque)
+
+
+def _evict_stale_workflows():
+    """Drop workflows past TTL so the in-memory store cannot grow unbounded."""
+    cutoff = time.time() - WORKFLOW_TTL_SECONDS
+    for wid in [
+        wid for wid, wf in WORKFLOWS.items()
+        if wf.get("created_at", 0) < cutoff
+        and wf.get("status") not in ("starting", "running")
+    ]:
+        WORKFLOWS.pop(wid, None)
+
+
+def _check_rate_limit(client_ip: str):
+    now = time.time()
+    window = _REQUESTS_BY_IP[client_ip]
+    while window and window[0] < now - RATE_LIMIT_WINDOW_SECONDS:
+        window.popleft()
+    if len(window) >= RATE_LIMIT_MAX_REQUESTS:
+        raise HTTPException(
+            status_code=429,
+            detail="Rate limit exceeded: max "
+                   f"{RATE_LIMIT_MAX_REQUESTS} analyses per hour per client."
+        )
+    window.append(now)
+
 
 @router.post("/analyze", response_model=WorkflowStartResponse)
-async def start_analysis(request: AnalysisRequest):
+async def start_analysis(request: AnalysisRequest, http_request: Request):
     """Start a new SWOT analysis workflow."""
+    _evict_stale_workflows()
+
+    client_ip = http_request.client.host if http_request.client else "unknown"
+    _check_rate_limit(client_ip)
+
+    active = sum(
+        1 for wf in WORKFLOWS.values()
+        if wf.get("status") in ("starting", "running")
+    )
+    if active >= MAX_ACTIVE_WORKFLOWS:
+        raise HTTPException(
+            status_code=429,
+            detail="Server busy: too many concurrent analyses. Retry shortly."
+        )
+
     workflow_id = str(uuid.uuid4())
 
     # Initialize workflow state
     WORKFLOWS[workflow_id] = {
+        "created_at": time.time(),
         "status": "starting",
         "current_step": "input",
         "revision_count": 0,

tests/test_conditions.py

@@ -0,0 +1,41 @@
+"""Unit tests for the self-correcting loop routing logic."""
+
+from src.utils.conditions import should_continue
+
+
+def test_exits_on_error():
+    assert should_continue({"error": "LLM providers failed", "score": 2}) == "exit"
+
+
+def test_exits_when_revision_skipped():
+    state = {"analyzer_revision_skipped": True, "score": 3, "revision_count": 0}
+    assert should_continue(state) == "exit"
+
+
+def test_exits_on_escalate():
+    state = {
+        "critique_details": {"status": "ESCALATE"},
+        "score": 3,
+        "revision_count": 1,
+    }
+    assert should_continue(state) == "exit"
+
+
+def test_exits_on_good_score():
+    assert should_continue({"score": 6, "revision_count": 0}) == "exit"
+    assert should_continue({"score": 9.5, "revision_count": 0}) == "exit"
+
+
+def test_exits_at_max_revisions():
+    assert should_continue({"score": 4, "revision_count": 3}) == "exit"
+    assert should_continue({"score": 4, "revision_count": 5}) == "exit"
+
+
+def test_retries_on_low_score_with_revisions_left():
+    assert should_continue({"score": 5.0, "revision_count": 0}) == "retry"
+    assert should_continue({"score": 5.9, "revision_count": 2}) == "retry"
+
+
+def test_retries_with_missing_defaults():
+    # No score/revision_count in state defaults to 0/0 -> retry
+    assert should_continue({}) == "retry"

tests/test_self_correcting_loop.py

@@ -1,79 +0,0 @@
-#!/usr/bin/env python3
-"""
-Comprehensive test for self-correction mechanisms in the SWOT Analysis Agent
-Tests multiple failure scenarios to verify the self-correcting loop functionality.
-"""
-
-import sys
-import os
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
-
-from src.graph_cyclic import run_self_correcting_workflow
-
-def test_analyzer_failure():
-    """Test self-correction when analyzer produces poor quality output"""
-    print("🧪 Testing Analyzer Failure Scenario...")
-
-    # Monkey patch the analyzer node to force poor quality
-    def force_poor_analyzer(state):
-        """Force a poor quality draft to trigger revision loop"""
-        state["draft_report"] = "Bad analysis. No details. Incomplete."
-        print("⚠️  FORCED POOR QUALITY: Overriding with very weak content")
-        return state
-
-    # Temporarily replace analyzer in the workflow
-    import src.nodes.analyzer
-    original_analyzer = src.nodes.analyzer.analyzer_node
-    src.nodes.analyzer.analyzer_node = force_poor_analyzer
-
-    try:
-        result = run_self_correcting_workflow("Test Company")
-        print(f"✅ Test completed with {result['revision_count']} revisions")
-        print(f"📊 Final score: {result['score']}/10")
-    finally:
-        # Restore original function
-        src.nodes.analyzer.analyzer_node = original_analyzer
-
-def test_critic_failure():
-    """Test self-correction when critic gives low scores"""
-    print("\n🧪 Testing Critic Failure Scenario...")
-    
-    # Monkey patch the critic to force a low score
-    def force_low_score_critic(state):
-        """Force a low score to trigger revision loop"""
-        state["score"] = 3  # Low score to force revision
-        state["critique"] = "Forced low score for testing self-correction loop"
-        print("⚠️  FORCED LOW SCORE: 3/10 to trigger revision loop")
-        return state
-
-    # Temporarily replace critic in the workflow
-    import src.nodes.critic
-    original_critic = src.nodes.critic.critic_node
-    src.nodes.critic.critic_node = force_low_score_critic
-    
-    try:
-        result = run_self_correcting_workflow("Test Company")
-        print(f"✅ Test completed with {result['revision_count']} revisions")
-        print(f"📊 Final score: {result['score']}/10")
-    finally:
-        # Restore original function
-        src.nodes.critic.critic_node = original_critic
-
-def test_workflow_failure():
-    """Test self-correction with custom workflow manipulation"""
-    print("\n🧪 Testing Workflow Failure Scenario...")
-    
-    # This test would implement the custom workflow approach from test_force_failure.py
-    # For brevity, we'll just indicate this as a placeholder
-    print("📝 Custom workflow failure test placeholder")
-    print("✅ Test framework ready for custom workflow testing")
-
-if __name__ == "__main__":
-    print("🚀 Running Self-Correction Test Suite")
-    print("=" * 50)
-    
-    test_analyzer_failure()
-    test_critic_failure()
-    test_workflow_failure()
-    
-    print("\n🎉 All self-correction tests completed!")