feat: Add CogDx reasoning verification connector

Adds optional cognitive diagnostics integration for trade verification:

- CogDxClient for reasoning analysis before trade execution
- Detects logical fallacies, calibration issues, cognitive biases
- Pre-trade verification gate with configurable thresholds
- Free pilot coupon: MERCURY-PILOT-2026

This helps prediction market agents catch reasoning flaws before
they become losses. External verification from computational
cognitive science methodology.

See docs/cogdx_integration.md for usage examples.

Author: drkavner

agents/connectors/cogdx.py

@@ -0,0 +1,214 @@
+"""
+Cerebratech CogDx Connector
+Cognitive Diagnostics for Prediction Market Agents
+
+Provides reasoning verification before trade execution.
+Free pilot: Use coupon code MERCURY-PILOT-2026 for $5 credit.
+
+Docs: https://api.cerebratech.ai
+"""
+
+import os
+import requests
+from typing import Dict, Any, Optional, List
+
+class CogDxClient:
+    """
+    Client for Cerebratech's Cognitive Diagnostics API.
+    
+    Verifies agent reasoning quality before high-stakes decisions.
+    Detects logical fallacies, calibration issues, and cognitive biases.
+    """
+    
+    BASE_URL = "https://api.cerebratech.ai"
+    
+    def __init__(self, coupon: Optional[str] = None, wallet: Optional[str] = None):
+        """
+        Initialize CogDx client.
+        
+        Args:
+            coupon: Pilot coupon code (e.g., 'MERCURY-PILOT-2026' for $5 credit)
+            wallet: Ethereum wallet address for credit-based payments
+        """
+        self.coupon = coupon or os.getenv("COGDX_COUPON")
+        self.wallet = wallet or os.getenv("COGDX_WALLET")
+    
+    def _headers(self) -> Dict[str, str]:
+        headers = {"Content-Type": "application/json"}
+        if self.coupon:
+            headers["X-COUPON"] = self.coupon
+        if self.wallet:
+            headers["X-WALLET"] = self.wallet
+        return headers
+    
+    def analyze_reasoning(self, reasoning_trace: str) -> Dict[str, Any]:
+        """
+        Analyze a reasoning trace for logical fallacies and validity issues.
+        
+        Args:
+            reasoning_trace: The agent's reasoning text to analyze
+            
+        Returns:
+            dict with:
+                - logical_validity: float 0-1
+                - status: 'valid' | 'flawed'
+                - flaws_detected: list of detected fallacies
+                - recommendations: suggested improvements
+        """
+        try:
+            response = requests.post(
+                f"{self.BASE_URL}/reasoning_trace_analysis",
+                headers=self._headers(),
+                json={"trace": reasoning_trace},
+                timeout=30
+            )
+            
+            if response.status_code == 402:
+                return {
+                    "error": "payment_required",
+                    "message": "Add COGDX_COUPON or COGDX_WALLET to env",
+                    "logical_validity": None
+                }
+            
+            return response.json()
+            
+        except Exception as e:
+            return {"error": str(e), "logical_validity": None}
+    
+    def calibration_audit(
+        self,
+        agent_id: str,
+        predictions: List[Dict[str, Any]]
+    ) -> Dict[str, Any]:
+        """
+        Audit prediction calibration - do confidence levels match accuracy?
+        
+        Args:
+            agent_id: Identifier for the agent
+            predictions: List of {prompt, response, confidence} dicts
+            
+        Returns:
+            dict with:
+                - calibration_score: float 0-1 (1 = perfectly calibrated)
+                - overconfidence_rate: float
+                - underconfidence_rate: float
+                - recommendations: list of strings
+        """
+        try:
+            response = requests.post(
+                f"{self.BASE_URL}/calibration_audit",
+                headers=self._headers(),
+                json={
+                    "agent_id": agent_id,
+                    "sample_outputs": predictions
+                },
+                timeout=30
+            )
+            return response.json()
+        except Exception as e:
+            return {"error": str(e)}
+    
+    def bias_scan(
+        self,
+        agent_id: str,
+        outputs: List[Dict[str, Any]]
+    ) -> Dict[str, Any]:
+        """
+        Scan for cognitive biases in agent outputs.
+        
+        Detects: anchoring, confirmation bias, availability heuristic,
+        representativeness, sunk cost, and more.
+        
+        Args:
+            agent_id: Identifier for the agent
+            outputs: List of {prompt, response, confidence} dicts
+            
+        Returns:
+            dict with:
+                - biases_detected: list of bias findings
+                - severity: 'low' | 'medium' | 'high'
+                - recommendations: list of strings
+        """
+        try:
+            response = requests.post(
+                f"{self.BASE_URL}/bias_scan",
+                headers=self._headers(),
+                json={
+                    "agent_id": agent_id,
+                    "sample_outputs": outputs
+                },
+                timeout=30
+            )
+            return response.json()
+        except Exception as e:
+            return {"error": str(e)}
+    
+    def verify_before_trade(
+        self,
+        reasoning: str,
+        min_validity: float = 0.7
+    ) -> Dict[str, Any]:
+        """
+        Pre-trade verification gate.
+        
+        Use this before executing trades to catch reasoning flaws.
+        
+        Args:
+            reasoning: The reasoning trace that led to the trade decision
+            min_validity: Minimum logical validity score to pass (default 0.7)
+            
+        Returns:
+            dict with:
+                - approved: bool
+                - validity_score: float
+                - issues: list of detected problems
+                - recommendation: 'proceed' | 'review' | 'reject'
+        """
+        result = self.analyze_reasoning(reasoning)
+        
+        if result.get("error"):
+            # On error, default to proceed but flag for review
+            return {
+                "approved": True,
+                "validity_score": None,
+                "issues": [f"CogDx unavailable: {result.get('error')}"],
+                "recommendation": "proceed_with_caution"
+            }
+        
+        validity = result.get("logical_validity", 0)
+        flaws = result.get("flaws_detected", [])
+        
+        approved = validity >= min_validity and len(flaws) == 0
+        
+        if validity >= min_validity and len(flaws) == 0:
+            recommendation = "proceed"
+        elif validity >= 0.5:
+            recommendation = "review"
+        else:
+            recommendation = "reject"
+        
+        return {
+            "approved": approved,
+            "validity_score": validity,
+            "issues": [f.get("name", str(f)) for f in flaws],
+            "recommendation": recommendation
+        }
+
+
+def verify_trade_reasoning(reasoning: str, coupon: str = None) -> bool:
+    """
+    Convenience function for quick trade verification.
+    
+    Usage:
+        from agents.connectors.cogdx import verify_trade_reasoning
+        
+        if verify_trade_reasoning(my_reasoning, coupon="MERCURY-PILOT-2026"):
+            execute_trade()
+        else:
+            print("Reasoning flagged for review")
+    
+    Returns True if reasoning passes verification, False otherwise.
+    """
+    client = CogDxClient(coupon=coupon)
+    result = client.verify_before_trade(reasoning)
+    return result.get("approved", False)

docs/cogdx_integration.md

@@ -0,0 +1,115 @@
+# CogDx Integration: Reasoning Verification for Trading Agents
+
+## Overview
+
+This integration adds optional cognitive diagnostics to the Polymarket trading pipeline. Before executing trades, agents can verify their reasoning for logical fallacies and calibration issues.
+
+## Why This Matters
+
+Prediction market agents make high-stakes decisions based on probabilistic reasoning. Common failure modes include:
+
+- **Anchoring bias**: Over-weighting initial price as a signal
+- **Confirmation bias**: Seeking evidence that confirms existing position
+- **Overconfidence**: Stated certainty exceeding actual accuracy
+- **Logical fallacies**: Invalid reasoning chains leading to incorrect conclusions
+
+CogDx provides external verification to catch these issues before they become losses.
+
+## Quick Start
+
+```python
+from agents.connectors.cogdx import verify_trade_reasoning
+
+# In your trade pipeline
+reasoning = agent.source_best_trade(market)
+
+if verify_trade_reasoning(reasoning, coupon="MERCURY-PILOT-2026"):
+    polymarket.execute_market_order(market, amount)
+else:
+    print("Trade reasoning flagged - manual review recommended")
+```
+
+## Full Client Usage
+
+```python
+from agents.connectors.cogdx import CogDxClient
+
+client = CogDxClient(coupon="MERCURY-PILOT-2026")
+
+# Analyze reasoning for fallacies
+result = client.analyze_reasoning("""
+The market is trading at 0.65, but I believe the true probability is 0.80.
+My research shows strong evidence for YES outcome.
+Therefore I should buy YES at current price.
+""")
+
+print(result)
+# {
+#   "logical_validity": 0.85,
+#   "status": "valid",
+#   "flaws_detected": [],
+#   "recommendations": ["No obvious fallacies detected"]
+# }
+
+# Pre-trade verification gate
+gate = client.verify_before_trade(reasoning, min_validity=0.7)
+
+if gate["approved"]:
+    execute_trade()
+elif gate["recommendation"] == "review":
+    flag_for_human_review()
+else:
+    skip_trade()
+```
+
+## Calibration Audits
+
+Track prediction accuracy over time:
+
+```python
+predictions = [
+    {"prompt": "Will X happen?", "response": "Yes (75%)", "confidence": 0.75},
+    {"prompt": "Will Y happen?", "response": "No (60%)", "confidence": 0.60},
+    # ... more predictions with actual outcomes
+]
+
+audit = client.calibration_audit(
+    agent_id="my-polymarket-agent",
+    predictions=predictions
+)
+
+print(audit["calibration_score"])  # 0.0-1.0, higher = better calibrated
+```
+
+## Environment Variables
+
+```bash
+# Option 1: Pilot coupon (free trial)
+COGDX_COUPON=MERCURY-PILOT-2026
+
+# Option 2: Wallet-based credits
+COGDX_WALLET=0x...
+
+# Option 3: Pass directly to client
+client = CogDxClient(coupon="MERCURY-PILOT-2026")
+```
+
+## Pricing
+
+| Endpoint | Cost |
+|----------|------|
+| `/reasoning_trace_analysis` | $0.03 |
+| `/calibration_audit` | $0.06 |
+| `/bias_scan` | $0.10 |
+
+Free pilot: `MERCURY-PILOT-2026` provides $5 credit (~80 reasoning checks).
+
+## API Reference
+
+Full documentation: https://api.cerebratech.ai
+
+## About Cerebratech
+
+Cerebratech provides cognitive diagnostics for AI agents, built by computational cognitive scientists. Our tools help agents verify they're reasoning correctly before making consequential decisions.
+
+Contact: cerebratech.eth | https://cerebratech.ai