mcp-agentic-pipelines 1.0.1

package/vendors/clinical-intake/questions/en.txt

@@ -0,0 +1,9 @@
+Hello, I'm the clinical intake assistant with Health Canada. I'm going to ask you a few questions to prepare for your consultation. What brings you in to see the doctor today?
+When did your symptoms begin? Did they start suddenly or gradually?
+On a scale of 0 to 10, where 0 is no pain and 10 is the worst pain you can imagine, how would you rate your current discomfort?
+Have you experienced this health issue before? If so, what diagnosis or treatment did you receive at that time?
+Are you currently taking any medications, whether prescribed or over-the-counter? Do you have any drug allergies or other allergies we should know about?
+Do you have any significant medical history such as diabetes, high blood pressure, heart conditions, or respiratory issues?
+Have you recently experienced any of the following: chest pain or pressure, unusual shortness of breath, severe dizziness, or a fever above 38.5°C (101.3°F)?
+Is there anything else you would like the doctor to know before your appointment? Thank you — the doctor will review all of this information.
+

package/vendors/clinical-intake/questions/fr.txt

@@ -0,0 +1,9 @@
+Bonjour, je suis l'assistant d'accueil clinique du RAMQ. Je vais vous poser quelques questions pour préparer votre consultation. Quel est le motif de votre visite aujourd'hui?
+Depuis quand avez-vous ces symptômes? Sont-ils apparus soudainement ou progressivement?
+Sur une échelle de 0 à 10, où 0 signifie aucune douleur et 10 la pire douleur imaginable, comment évaluez-vous votre inconfort actuel?
+Avez-vous déjà eu ce problème de santé auparavant? Si oui, quel diagnostic ou traitement aviez-vous reçu?
+Prenez-vous actuellement des médicaments, qu'ils soient prescrits ou en vente libre? Avez-vous des allergies médicamenteuses ou autres?
+Avez-vous des antécédents médicaux importants comme le diabète, l'hypertension, des problèmes cardiaques ou respiratoires?
+Avez-vous ressenti l'un des symptômes suivants récemment: douleur ou pression thoracique, essoufflement inhabituel, étourdissements sévères, ou fièvre supérieure à 38,5°C?
+Y a-t-il autre chose que vous aimeriez que le médecin sache avant votre rendez-vous? Merci de votre collaboration, le médecin examinera toutes ces informations.
+

package/vendors/piste/.env.example

@@ -0,0 +1,73 @@
+# ============================================================
+# Piste — Environment Variables
+# Copy to .env and fill in your API keys
+# ============================================================
+
+# --- App ---
+APP_NAME=Piste
+APP_VERSION=0.1.0
+DEBUG=true
+
+# --- Server ---
+HOST=0.0.0.0
+PORT=8000
+
+# --- CORS ---
+CORS_ORIGINS=["http://localhost:3000"]
+
+# --- Database (PostgreSQL 16) ---
+DATABASE_URL=postgresql+asyncpg://piste:piste@localhost:5432/piste
+DATABASE_URL_SYNC=postgresql+psycopg2://piste:piste@localhost:5432/piste
+
+# --- Redis 7.2 ---
+REDIS_URL=redis://localhost:6379/0
+
+# --- FAISS ---
+FAISS_INDEX_PATH=./data/faiss_evidence.index
+FAISS_DIMENSION=1536
+
+# --- LiteLLM / Model ---
+LITELLM_MODEL=deepseek/deepseek-chat
+LITELLM_FALLBACK_MODELS=["deepseek/deepseek-chat","claude-3-haiku-20240307"]
+
+# --- API Keys (REQUIRED — get your own at the URLs below) ---
+# DeepSeek: https://platform.deepseek.com/api_keys
+DEEPSEEK_API_KEY=sk-your-deepseek-key-here
+
+# OpenAI (optional fallback): https://platform.openai.com/api-keys
+OPENAI_API_KEY=sk-your-openai-key-here
+
+# Anthropic (optional fallback): https://console.anthropic.com/
+ANTHROPIC_API_KEY=sk-ant-your-key-here
+
+# --- Search Providers (at least one REQUIRED) ---
+# Tavily: https://app.tavily.com/home
+TAVILY_API_KEY=tvly-your-tavily-key-here
+
+# Serper: https://serper.dev/
+SERPER_API_KEY=your-serper-key-here
+
+# Google CSE (optional): https://console.cloud.google.com/apis/library/customsearch.googleapis.com
+GOOGLE_CSE_API_KEY=your-google-cse-key-here
+GOOGLE_CSE_ID=your-search-engine-id-here
+
+# --- DSPy ---
+DSPY_OPTIMIZER=BootstrapFewShot
+DSPY_MAX_LABELED_EXAMPLES=100
+
+# --- Pipeline ---
+VOTING_COMPLETIONS=3
+VOTING_THRESHOLD=0.67
+MAX_RETRY_LOOPS=3
+FAISS_CACHE_THRESHOLD=0.92
+
+# --- Idempotency ---
+VERDICT_CACHE_TTL_SECONDS=86400
+IDEMPOTENCY_LOCK_TTL_SECONDS=3600
+
+# --- Rate Limiting ---
+RATE_LIMIT_PER_USER=10
+RATE_LIMIT_GLOBAL=100
+
+# --- Auth ---
+JWT_SECRET_KEY=change-me-in-production-use-a-real-secret

package/vendors/piste/app/core/__init__.py

@@ -0,0 +1,4 @@
+# Copyright (c) 2026 Jinan Kordab
+# SPDX-License-Identifier: MIT
+
+# Core package — config, security, dependencies

package/vendors/piste/app/core/config.py

@@ -0,0 +1,83 @@
+# Copyright (c) 2026 Jinan Kordab
+# SPDX-License-Identifier: MIT
+
+"""
+Piste — Centralized Settings
+================================
+All configuration via environment variables + .env file.
+Uses pydantic-settings for validation.
+"""
+
+from pydantic_settings import BaseSettings
+from typing import List
+
+
+class Settings(BaseSettings):
+    model_config = {"env_file": ".env", "env_file_encoding": "utf-8", "extra": "ignore"}
+
+    # --- App ---
+    APP_NAME: str = "Piste"
+    APP_VERSION: str = "0.1.0"
+    DEBUG: bool = False
+
+    # --- Server ---
+    HOST: str = "0.0.0.0"
+    PORT: int = 8000
+
+    # --- CORS ---
+    CORS_ORIGINS: List[str] = ["http://localhost:3000"]
+
+    # --- Database (PostgreSQL 16) ---
+    DATABASE_URL: str = "postgresql+asyncpg://piste:piste@localhost:5432/piste"
+    DATABASE_URL_SYNC: str = "postgresql+psycopg2://piste:piste@localhost:5432/piste"
+
+    # --- Redis 7.2 ---
+    REDIS_URL: str = "redis://localhost:6379/0"
+
+    # --- FAISS ---
+    FAISS_INDEX_PATH: str = "./data/faiss_evidence.index"
+    FAISS_DIMENSION: int = 1536  # OpenAI embedding dimension
+
+    # --- LiteLLM ---
+    LITELLM_MODEL: str = "deepseek/deepseek-chat"
+    LITELLM_FALLBACK_MODELS: List[str] = ["deepseek/deepseek-chat", "claude-3-haiku-20240307"]
+    LITELLM_REQUEST_TIMEOUT: int = 600
+    OPENAI_API_KEY: str = ""
+    ANTHROPIC_API_KEY: str = ""
+    DEEPSEEK_API_KEY: str = ""
+
+    # --- DSPy ---
+    DSPY_OPTIMIZER: str = "BootstrapFewShot"  # or "MIPROv2"
+    DSPY_MAX_LABELED_EXAMPLES: int = 100
+
+    # --- Pipeline ---
+    VOTING_COMPLETIONS: int = 3
+    VOTING_THRESHOLD: float = 0.67  # 2/3 majority
+    MAX_RETRY_LOOPS: int = 3        # Loop 1 max retries
+    FAISS_CACHE_THRESHOLD: float = 0.92  # Cosine similarity for cache hit
+
+    # --- Idempotency ---
+    VERDICT_CACHE_TTL_SECONDS: int = 86400  # 24 hours
+    IDEMPOTENCY_LOCK_TTL_SECONDS: int = 3600  # 1 hour
+
+    # --- Rate Limiting ---
+    RATE_LIMIT_PER_USER: int = 10    # claims per minute
+    RATE_LIMIT_GLOBAL: int = 100     # claims per minute
+
+    # --- Auth ---
+    JWT_SECRET_KEY: str = "change-me-in-production"
+    JWT_ALGORITHM: str = "HS256"
+
+    # --- Observability ---
+    LANGSMITH_API_KEY: str = ""
+    LANGSMITH_PROJECT: str = "piste"
+    PROMETHEUS_PORT: int = 9090
+
+    # --- Search Providers ---
+    TAVILY_API_KEY: str = ""
+    SERPER_API_KEY: str = ""
+    GOOGLE_CSE_API_KEY: str = ""
+    GOOGLE_CSE_ID: str = ""
+
+
+settings = Settings()

package/vendors/piste/app/core/debuglog.py

@@ -0,0 +1,16 @@
+# Copyright (c) 2026 Jinan Kordab
+# SPDX-License-Identifier: MIT
+
+"""Debug logging for pipeline tracing."""
+import os
+from datetime import datetime
+
+DEBUG_LOG = "/tmp/piste_debug.log"
+
+def log(msg: str):
+    """Write timestamped debug message to log file."""
+    ts = datetime.utcnow().strftime("%H:%M:%S.%f")[:-3]
+    with open(DEBUG_LOG, "a") as f:
+        f.write(f"[{ts}] {msg}\n")
+    # Also print for docker logs
+    print(f"[DEBUG] {msg}", flush=True)

package/vendors/piste/app/core/middleware.py

@@ -0,0 +1,40 @@
+# Copyright (c) 2026 Jinan Kordab
+# SPDX-License-Identifier: MIT
+
+"""
+Rate Limiter Middleware
+========================
+Token-bucket rate limiting per user and global.
+Uses Redis for distributed rate limiting.
+
+Limits:
+  - 10 claims/minute per user
+  - 100 claims/minute global
+"""
+
+from fastapi import Request, HTTPException
+from starlette.middleware.base import BaseHTTPMiddleware
+from app.services.cache import redis_client
+from app.core.config import settings
+
+
+class RateLimitMiddleware(BaseHTTPMiddleware):
+    """Rate limiting middleware for API endpoints."""
+
+    async def dispatch(self, request: Request, call_next):
+        # Only rate-limit POST /api/v1/claims
+        if request.url.path == "/api/v1/claims" and request.method == "POST":
+            # Extract user identity (placeholder — use JWT in production)
+            user_id = request.headers.get("x-user-id", "anonymous")
+            client_ip = request.client.host if request.client else "unknown"
+            rate_key = f"rate:{user_id}:{client_ip}"
+
+            allowed = await redis_client.check_rate_limit(rate_key)
+            if not allowed:
+                raise HTTPException(
+                    status_code=429,
+                    detail="Rate limit exceeded. Please wait before submitting another claim.",
+                )
+
+        response = await call_next(request)
+        return response

package/vendors/piste/bridge_piste.py

@@ -0,0 +1,301 @@
+"""
+Piste Bridge — stdin/stdout JSON worker for MCP server.
+
+Usage: python bridge_piste.py
+
+Reads JSON requests from stdin, processes them using the real Piste DSPy pipeline,
+writes JSON responses to stdout.
+
+IMPORTANT: This bridge uses the REAL pipeline modules (pipeline/stage1-4) directly.
+It does NOT require PostgreSQL, Redis, or Docker. The pipeline stages use DSPy + LiteLLM
+for LLM calls and Tavily/Serper for web search. Results are returned as JSON.
+
+Protocol:
+  Input:  {"id": 1, "action": "fact_check", "params": {"claim_text": "...", "locale": "en"}}
+  Output: {"id": 1, "result": {...}} or {"id": 1, "error": "message"}
+
+Actions:
+  - fact_check:  Run the full 4-stage fact-checking pipeline
+  - health:      Returns {"status": "ok"}
+"""
+
+import sys, importlib, json, asyncio, os
+
+# ── Verify dependencies (installed by MCP server on startup) ─────
+REQUIRED = {'dspy': 'dspy-ai', 'litellm': 'litellm', 'dotenv': 'python-dotenv'}
+_missing = [mod for mod in REQUIRED if not importlib.util.find_spec(mod)]
+if _missing:
+    sys.stderr.write(f'[piste] FATAL: missing packages: {", ".join(_missing)}. '
+                     f'The MCP server should have installed them.\n')
+    sys.stderr.flush()
+    sys.exit(1)
+
+# Ensure piste directory is on sys.path
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+# Load environment from .env if present
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    pass
+
+os.environ.setdefault('PISTE_LOG_LEVEL', 'WARNING')
+
+# ── Pipeline imports (lazy) ────────────────────────────────────────────
+
+_initialized = False
+_loop = None
+
+def get_loop():
+    global _loop
+    if _loop is None or _loop.is_closed():
+        _loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(_loop)
+    return _loop
+
+
+def init_pipeline():
+    """Configure DSPy with the API key from environment."""
+    global _initialized
+    if _initialized:
+        return
+
+    from pipeline.compiler import configure_dspy
+    configure_dspy()
+    _initialized = True
+
+
+async def run_fact_check(claim_text: str, locale: str = "en", context: str = None) -> dict:
+    """
+    Run the full 4-stage Piste fact-checking pipeline.
+    Uses REAL DSPy modules from the cloned piste repo.
+    """
+    import dspy
+    import uuid
+
+    run_id = str(uuid.uuid4())[:12]
+
+    # ── Stage 1: Check-Worthiness + Atomic Decomposition ──────────
+    from pipeline.stage1.check_worthiness import CheckWorthinessDetector
+    from pipeline.stage1.atomic_decomposer import AtomicClaimDecomposer
+
+    cw_detector = CheckWorthinessDetector()
+    decomposer = AtomicClaimDecomposer()
+
+    # Check if the claim is worth fact-checking
+    cw_result = cw_detector(claim_text)
+    cw_label = getattr(cw_result, 'label', 'CFC') if hasattr(cw_result, 'label') else str(cw_result)
+    cw_score = getattr(cw_result, 'score', 1.0) if hasattr(cw_result, 'score') else 1.0
+
+    # Decompose into atomic claims
+    atomic_claims = []
+    try:
+        decomp_result = decomposer(claim_text)
+        if hasattr(decomp_result, 'claims'):
+            atomic_claims = decomp_result.claims
+        elif isinstance(decomp_result, list):
+            atomic_claims = decomp_result
+    except Exception:
+        atomic_claims = [claim_text]
+
+    # ── Stage 2: Blind Web Retrieval ──────────────────────────────
+    from pipeline.stage2.search_decision import SearchDecisionGenerator
+    from pipeline.stage2.blind_retriever import BlindRetriever
+
+    sd_generator = SearchDecisionGenerator()
+    retriever = BlindRetriever()
+
+    all_sources = []
+    search_needed = True
+
+    try:
+        sd_result = sd_generator(claim_text)
+        search_needed = getattr(sd_result, 'search_needed', True) if hasattr(sd_result, 'search_needed') else True
+
+        if search_needed:
+            # Generate neutral search queries (blind — never sees the claim)
+            queries = []
+            if hasattr(sd_result, 'queries'):
+                queries = sd_result.queries
+            elif hasattr(sd_result, 'search_queries'):
+                queries = sd_result.search_queries
+
+            if not queries:
+                # Fallback: generate a simple neutral query
+                queries = [f"fact check {locale} political claim"]
+
+            for query in queries[:5]:  # Max 5 queries
+                try:
+                    results = retriever(query, locale=locale)
+                    if hasattr(results, 'sources'):
+                        all_sources.extend(results.sources)
+                    elif isinstance(results, list):
+                        all_sources.extend(results)
+                except Exception:
+                    pass
+    except Exception:
+        pass
+
+    # ── Stage 3: Per-Source Classification ────────────────────────
+    from pipeline.stage3.classifier import SourceClassifier
+
+    classifier = SourceClassifier()
+    classifications = []
+
+    for source in all_sources[:20]:  # Max 20 sources
+        try:
+            # Extract source text
+            if isinstance(source, dict):
+                source_text = source.get('text', '') or source.get('content', '') or source.get('title', '')
+                source_url = source.get('url', '') or source.get('link', '')
+                source_title = source.get('title', '') or source_url
+            elif isinstance(source, str):
+                source_text = source
+                source_url = ''
+                source_title = source[:100]
+            else:
+                source_text = str(source)
+                source_url = ''
+                source_title = str(source)[:100]
+
+            if not source_text.strip():
+                continue
+
+            classification = classifier(claim_text, source_text)
+            label = getattr(classification, 'label', 'UNRELATED') if hasattr(classification, 'label') else 'UNRELATED'
+            confidence = getattr(classification, 'confidence', 0.5) if hasattr(classification, 'confidence') else 0.5
+            rationale = getattr(classification, 'rationale', '') if hasattr(classification, 'rationale') else ''
+
+            classifications.append({
+                "url": source_url,
+                "title": source_title[:200],
+                "classification": str(label).upper(),
+                "confidence": float(confidence),
+                "rationale": str(rationale)[:500],
+            })
+        except Exception:
+            classifications.append({
+                "url": source.get('url', '') if isinstance(source, dict) else '',
+                "title": source.get('title', '')[:200] if isinstance(source, dict) else '',
+                "classification": "UNRELATED",
+                "confidence": 0.0,
+                "rationale": "Classification failed",
+            })
+
+    # ── Stage 4: Verdict Aggregation ──────────────────────────────
+    from pipeline.stage4.verdict_aggregator import VerdictAggregator
+
+    aggregator = VerdictAggregator()
+
+    try:
+        verdict = aggregator(classifications, claim_text)
+        verdict_label = getattr(verdict, 'label', 'UNVERIFIABLE') if hasattr(verdict, 'label') else 'UNVERIFIABLE'
+        verdict_explanation = getattr(verdict, 'explanation', '') if hasattr(verdict, 'explanation') else ''
+        verdict_distribution = getattr(verdict, 'distribution', {}) if hasattr(verdict, 'distribution') else {}
+    except Exception:
+        # Fallback verdict
+        supports = sum(1 for c in classifications if c['classification'] == 'SUPPORTS')
+        refutes = sum(1 for c in classifications if c['classification'] == 'REFUTES')
+        total = len(classifications) or 1
+
+        if supports > refutes and supports > total * 0.5:
+            verdict_label = 'TRUE' if supports > total * 0.8 else 'MOSTLY_TRUE'
+        elif refutes > supports and refutes > total * 0.5:
+            verdict_label = 'FALSE' if refutes > total * 0.8 else 'MOSTLY_FALSE'
+        elif supports == refutes and total > 0:
+            verdict_label = 'HALF_TRUE'
+        else:
+            verdict_label = 'UNVERIFIABLE'
+
+        verdict_explanation = f"Based on {supports} supporting and {refutes} refuting sources out of {total} total."
+        verdict_distribution = {"TRUE": 0, "MOSTLY_TRUE": 0, "HALF_TRUE": 0, "MOSTLY_FALSE": 0, "FALSE": 0, "PANTS_ON_FIRE": 0, "UNVERIFIABLE": 0}
+
+    return {
+        "run_id": run_id,
+        "claim_id": run_id,
+        "verdict": {
+            "label": str(verdict_label).upper(),
+            "distribution": verdict_distribution if isinstance(verdict_distribution, dict) else {},
+            "explanation": str(verdict_explanation)[:2000],
+            "sources": classifications[:15],
+        },
+        "stage1": {
+            "check_worthy": str(cw_label),
+            "score": float(cw_score),
+            "atomic_claims": [str(c) for c in atomic_claims[:5]],
+        },
+        "stage2": {
+            "search_needed": bool(search_needed),
+            "sources_found": len(all_sources),
+        },
+        "audit_url": f"piste://claims/{run_id}",
+        "elapsed_ms": 0,
+    }
+
+
+# ── Action Handlers ───────────────────────────────────────────────────
+
+def handle_fact_check(params):
+    """Run the full fact-checking pipeline."""
+    claim_text = params.get("claim_text", "")
+    locale = params.get("locale", "en")
+    context = params.get("context", None)
+
+    if not claim_text or len(claim_text) < 10:
+        return {"error": "Claim text must be at least 10 characters"}
+
+    loop = get_loop()
+    init_pipeline()
+
+    result = loop.run_until_complete(run_fact_check(claim_text, locale, context))
+    return result
+
+
+# ── Dispatcher ────────────────────────────────────────────────────────
+
+ACTIONS = {
+    "fact_check": handle_fact_check,
+    "health": lambda p: {"status": "ok", "backend": "piste"},
+}
+
+
+def main():
+    # Send ready signal
+    sys.stdout.write("__READY__\n")
+    sys.stdout.flush()
+
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+
+        try:
+            request = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+
+        req_id = request.get("id")
+        action = request.get("action", "")
+        params = request.get("params", {})
+
+        handler = ACTIONS.get(action)
+        if not handler:
+            result = {"id": req_id, "error": f"Unknown action: {action}"}
+            sys.stdout.write(json.dumps(result) + "\n")
+            sys.stdout.flush()
+            continue
+
+        try:
+            result_data = handler(params)
+            response = {"id": req_id, "result": result_data}
+        except Exception as e:
+            import traceback
+            response = {"id": req_id, "error": f"{type(e).__name__}: {str(e)}"}
+
+        sys.stdout.write(json.dumps(response, default=str) + "\n")
+        sys.stdout.flush()
+
+
+if __name__ == "__main__":
+    main()

package/vendors/piste/pipeline/__init__.py

@@ -0,0 +1,4 @@
+# Copyright (c) 2026 Jinan Kordab
+# SPDX-License-Identifier: MIT
+
+# Pipeline package — DSPy 2.6 fact-checking modules

package/vendors/piste/pipeline/compiler.py

@@ -0,0 +1,68 @@
+# Copyright (c) 2026 Jinan Kordab
+# SPDX-License-Identifier: MIT
+
+"""
+DSPy Compiler Configuration
+============================
+Offline re-optimization of pipeline modules using human-labeled feedback (Loop 3).
+"""
+
+import dspy
+from app.core.config import settings
+from app.core.debuglog import log
+
+_dspy_configured = False
+
+
+def configure_dspy():
+    """Initialize DSPy with LiteLLM as the default language model."""
+    global _dspy_configured
+
+    model = settings.LITELLM_MODEL
+
+    # Route the correct API key based on model prefix
+    if "deepseek" in model.lower():
+        api_key = settings.DEEPSEEK_API_KEY
+    elif "claude" in model.lower() or "anthropic" in model.lower():
+        api_key = settings.ANTHROPIC_API_KEY
+    else:
+        api_key = settings.OPENAI_API_KEY
+
+    lm = dspy.LM(
+        model=model,
+        api_key=api_key,
+    )
+
+    if not _dspy_configured:
+        log(f"DSPY: first configure(), model={model}")
+        dspy.configure(lm=lm)
+        _dspy_configured = True
+    else:
+        log(f"DSPY: already configured, using dspy.context()")
+        dspy.context(lm=lm)
+
+    return lm
+
+
+def compile_module(module: dspy.Module, trainset: list[dspy.Example]) -> dspy.Module:
+    """Run DSPy compiler (BootstrapFewShot or MIPROv2) on a module.
+
+    Loop 3 [C4][J1]: User feedback → labeled examples → re-optimization.
+    """
+    optimizer_name = settings.DSPY_OPTIMIZER
+
+    if optimizer_name == "BootstrapFewShot":
+        optimizer = dspy.BootstrapFewShot(
+            metric=None,  # Use default metric or pass custom
+            max_labeled_demos=settings.DSPY_MAX_LABELED_EXAMPLES,
+        )
+    elif optimizer_name == "MIPROv2":
+        optimizer = dspy.MIPROv2(
+            metric=None,
+            num_threads=4,
+        )
+    else:
+        raise ValueError(f"Unknown DSPy optimizer: {optimizer_name}")
+
+    compiled = optimizer.compile(module, trainset=trainset)
+    return compiled

package/vendors/piste/pipeline/offline/__init__.py

@@ -0,0 +1,28 @@
+# Copyright (c) 2026 Jinan Kordab
+# SPDX-License-Identifier: MIT
+
+# Offline — VERIFAID Dataset Pipeline [J7]
+#   M1: Generate Claims (LLM, multilingual)   — pipeline/offline/verifaid_pipeline.py
+#   M2: Enrich + Label + FAISS Index          — pipeline/offline/verifaid_pipeline.py
+#   Scheduler + Loop 2 integration            — pipeline/offline/verifaid_pipeline.py
+
+from pipeline.offline.verifaid_pipeline import (
+    ClaimGenerator, claim_generator,
+    EvidenceEnricher, evidence_enricher,
+    OfflinePipelineScheduler, offline_scheduler,
+    ClaimGenerationSignature, EvidenceLabelingSignature,
+    TOPICS, LOCALES,
+)
+
+__all__ = [
+    "ClaimGenerator",
+    "claim_generator",
+    "EvidenceEnricher",
+    "evidence_enricher",
+    "OfflinePipelineScheduler",
+    "offline_scheduler",
+    "ClaimGenerationSignature",
+    "EvidenceLabelingSignature",
+    "TOPICS",
+    "LOCALES",
+]