yieldix 16.0.0__py3-none-any.whl

yieldix/__init__.py

@@ -0,0 +1,30 @@
+"""
+Yieldix: Autonomous B2B Revenue Engine & Speed-to-Lead Orchestrator.
+Version: 16.0.0
+"""
+
+__version__ = "16.0.0"
+__author__ = "Yieldix Contributors"
+
+from yieldix.core.circuit_breaker import CircuitBreaker
+from yieldix.core.engine import YieldixEngine
+from yieldix.core.types import (
+    BANTScore,
+    InboundLeadPayload,
+    LeadSource,
+    MonthlyReportPayload,
+    PipelineConfig,
+    TaskStatus,
+)
+
+__all__ = [
+    "BANTScore",
+    "CircuitBreaker",
+    "InboundLeadPayload",
+    "LeadSource",
+    "MonthlyReportPayload",
+    "PipelineConfig",
+    "TaskStatus",
+    "YieldixEngine",
+    "__version__",
+]

yieldix/cli/main.py

@@ -0,0 +1,449 @@
+"""
+Yieldix Command Line Interface (CLI).
+Enterprise execution, lead testing, L2 human review, and Monte Carlo simulation.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import random
+from decimal import Decimal
+
+import click
+
+from yieldix.core.engine import YieldixEngine
+from yieldix.core.types import InboundLeadPayload, LeadSource, PipelineConfig
+from yieldix.telemetry.reporter import MonthlyReportGenerator
+
+
+# DALGA-C-2 (YIELDIX-CLI-3): click 8.5'te Decimal-parametre yoktur;.geçersiz
+# sayısal girdi ham decimal.InvalidOperation yerine click rc=2 olmalı.
+class _DecimalParam(click.ParamType):
+    """Geçerli bir Decimal'e çevirir; çevrilemezse UsageError (rc=2)."""
+
+    name = "decimal"
+
+    def convert(self, value, param, ctx):
+        if isinstance(value, Decimal):
+            return value
+        try:
+            return Decimal(str(value))
+        except Exception:
+            self.fail(f"{value!r} geçerli bir Decimal sayı değil", param, ctx)
+
+
+_DECIMAL_PARAM = _DecimalParam()
+
+
+@click.group()
+@click.version_option("16.0.0", prog_name="yieldix")
+def main():
+    """🦄 Yieldix: Autonomous B2B Revenue Engine CLI."""
+
+
+@main.command(name="status")
+@click.option("--tenant", default="cust_enterprise_01", help="Tenant ID")
+def status(tenant: str):
+    """Displays engine and circuit breaker status."""
+    engine = YieldixEngine(PipelineConfig(tenant_id=tenant))
+    cycle = asyncio.run(engine.run_daily_cycle())
+    click.echo(f"=== YIELDIX ENGINE STATUS: {tenant} ===")
+    click.echo(f"Active Components: {', '.join(cycle['active_components'])}")
+    click.echo(f"Shed Components: {', '.join(cycle['shed_components']) if cycle['shed_components'] else 'None'}")
+    click.echo(f"Circuit Breaker Tripped: {cycle['circuit_breaker_tripped']}")
+
+
+@main.command(name="ingest")
+@click.option("--tenant", default="cust_enterprise_01", help="Tenant ID")
+@click.option("--name", required=True, help="Contact name")
+@click.option("--phone", required=True, help="Contact phone")
+@click.option("--intent", default="Kurumsal B2B teklif talebi", help="Lead intent")
+def ingest(tenant: str, name: str, phone: str, intent: str):
+    """Ingests a lead and triggers the sub-60s speed-to-lead flow."""
+    engine = YieldixEngine(PipelineConfig(tenant_id=tenant))
+    lead = InboundLeadPayload(
+        tenant_id=tenant,
+        lead_id=f"lead_{int(random.random()*10000)}",
+        contact_name=name,
+        contact_phone=phone,
+        source=LeadSource.WEB_FORM,
+        intent_summary=intent,
+    )
+    result = asyncio.run(engine.ingest_inbound_lead(lead))
+    click.echo(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+@main.command(name="simulate")
+@click.option("--runs", default=10000, type=click.IntRange(min=1),
+              help="Number of Monte Carlo simulation runs (>=1)")
+@click.option("--retainer", default="2500.00", type=_DECIMAL_PARAM,
+              help="Monthly retainer in USD")
+def simulate(runs: int, retainer: str | float):
+    """Executes N=10,000 Monte Carlo financial stress simulation."""
+    retainer_dec = retainer if isinstance(retainer, Decimal) else Decimal(str(retainer))
+    click.echo(f"Running Monte Carlo simulation ({runs} runs, Retainer=${retainer_dec:.2f})...")
+    profits = []
+    base_cogs = Decimal("90.00")
+    for _ in range(runs):
+        leads = max(100.0, random.gauss(450.0, 90.0))
+        api_multiplier = Decimal(str(round(random.uniform(0.85, 1.40), 4)))
+        escalation_pct = max(1.0, min(30.0, random.gauss(8.5, 3.2)))
+        lead_ratio = Decimal(str(round(leads / 450.0, 4)))
+        variable_cogs = base_cogs * lead_ratio * api_multiplier
+        penalty = Decimal("0.00")
+        if escalation_pct > 20.0:
+            esc_excess = Decimal(str(round((escalation_pct - 20.0) / 10.0, 4)))
+            penalty = Decimal("150.00") * esc_excess
+        net_profit = retainer_dec - (variable_cogs + penalty)
+        profits.append(net_profit)
+
+    profits.sort()
+    p5 = profits[int(runs * 0.05)]
+    p50 = profits[int(runs * 0.50)]
+    p95 = profits[int(runs * 0.95)]
+    loss_count = sum(1 for p in profits if p <= Decimal("0.00"))
+
+    click.echo("=== SIMULATION RESULTS ===")
+    click.echo(f"P5 (Worst Case): ${p5:.2f}")
+    click.echo(f"P50 (Median):     ${p50:.2f} (Margin: %{(p50/retainer_dec)*100:.2f})")
+    click.echo(f"P95 (Best Case):  ${p95:.2f}")
+    click.echo(f"Loss Probability: %{(loss_count/runs)*100:.2f}")
+
+
+@main.command(name="report")
+@click.option("--tenant", default="cust_enterprise_01", help="Tenant ID")
+@click.option("--start", default="2026-10-01", help="Period start date")
+@click.option("--end", default="2026-10-31", help="Period end date")
+def report(tenant: str, start: str, end: str):
+    """Generates an Ed25519 signed monthly audit report card."""
+    engine = YieldixEngine(PipelineConfig(tenant_id=tenant))
+    # Ingest baseline transaction event
+    engine.kpi_collector.record_lead_processed("lead_demo", 32.5, is_sql=True, cost_try=Decimal("15.00"))
+    rep_gen = MonthlyReportGenerator()
+    rep = rep_gen.generate_signed_report(
+        tenant_id=tenant,
+        period_start=start,
+        period_end=end,
+        kpi_collector=engine.kpi_collector,
+        active_components=engine.config.enabled_components,
+    )
+    card = rep_gen.export_markdown_card(rep)
+    click.echo(card)
+
+
+@main.command(name="serve")
+@click.option("--host", default="127.0.0.1", help="Host interface to bind")
+@click.option("--port", default=8088, type=int, help="Port to listen on")
+@click.option("--no-block", is_flag=True, default=False, help="Launch non-blocking smoke run")
+def serve(host: str, port: int, no_block: bool = False):
+    """Launches the sovereign Yieldix web telemetry and cockpit server."""
+    from yieldix.server.app import create_server
+    click.echo(f"Starting Yieldix Cockpit on http://{host}:{port}")
+    server = create_server(host=host, port=port)
+    server.start(blocking=not no_block)
+    if no_block:
+        server.stop()
+
+
+@main.command(name="pilot")
+@click.option("--tenant", default="pilot-demo-tenant", help="Tenant ID for the pilot run")
+@click.option("--leads-per-company", default=25, help="Synthetic leads per pilot company")
+@click.option("--seed", default=1337, help="Deterministic seed for replayability")
+@click.option("--out", default=None, help="Write the synthetic dataset JSON to this path")
+def pilot(tenant: str, leads_per_company: int, seed: int, out):
+    """
+    Generates a synthetic-but-realistic B2B pilot dataset and proves the full
+    lead → KPI → signed-report chain with quantified CPL/SQL values.
+
+    Dürüst-not: bu veri SENTETİKTİR (gerçek müşteri verisi gizlilik nedeniyle
+    kullanılamaz). Amacı CPL/SQL hesaplamasının kanıtlanabilir olduğunu
+    imzalı-raporla göstermektir.
+    """
+    from yieldix.telemetry.pilot_dataset import (
+        SyntheticPilotDataset, PILOT_COMPANIES,
+    )
+    ds = SyntheticPilotDataset(leads_per_company=leads_per_company, seed=seed)
+    records = ds.generate()
+
+    report, fingerprint, pubkey = ds.build_signed_report(records, tenant_id=tenant)
+
+    # Bağımsız-imza-doğrulaması: imzayı üreten-anahtarla değil, açık-anahtarla
+    # yeniden-teyit et ( tahrif-direnci kanıtı).
+    from yieldix.crypto.signer import Ed25519ReportSigner
+    payload = MonthlyReportGenerator.to_signable_dict(report)
+    sig_ok = Ed25519ReportSigner.verify_signature(
+        payload, report.ed25519_signature, pubkey)
+    tampered = dict(payload)
+    tampered["qualified_sql"] = (tampered["qualified_sql"] or 0) + 999
+    tamper_rejected = not Ed25519ReportSigner.verify_signature(
+        tampered, report.ed25519_signature, pubkey)
+
+    click.echo("=" * 70)
+    click.echo("  YIELDIX SENTETİK-PILOT-VERİ SETİ ( dürüst-sınır kapatması)")
+    click.echo("=" * 70)
+    click.echo(f"  Şirket sayısı:        {len(PILOT_COMPANIES)} kurgusal B2B şirket")
+    click.echo(f"  Lead sayısı:          {len(records)} ( deterministik-seed={seed})")
+    click.echo(f"  Şirket başına lead:   {leads_per_company}")
+    click.echo("-" * 70)
+    click.echo("  Quantified pilot KPI'lar ( imzalı-rapor kaynağı):")
+    click.echo(f"    Toplam lead:        {report.total_leads}")
+    click.echo(f"    SQL (nitelikli):    {report.qualified_sql} "
+               f"( %{(report.qualified_sql / max(1, report.total_leads)) * 100:.1f} dönüşüm)")
+    click.echo(f"    CPL (lead başı):    ₺{report.cost_per_lead_try}")
+    click.echo(f"    P95 hız-yanıt:      {report.p95_speed_to_lead_seconds:.1f} sn")
+    click.echo(f"    Hata oranı:         %{report.error_rate_pct:.2f}")
+    click.echo(f"    Eskalasyon oranı:   %{report.escalation_rate_pct:.2f}")
+    click.echo("-" * 70)
+    click.echo(f"  Veri-seti parmakizi:  {fingerprint[:24]}…")
+    click.echo(f"  SHA-256 özet:         {(report.sha256_digest or 'YOK')[:24]}…")
+    click.echo(f"  Ed25519 imza:         {'var' if report.ed25519_signature else 'YOK'}")
+    click.echo(f"  İmza-bağımsız-doğrula:{'✓ geçti' if sig_ok else '✗ BAŞARISIZ'}")
+    click.echo(f"  Tahrif-reddi:         {'✓ reddetti' if tamper_rejected else '✗ BAŞARISIZ'}")
+
+    if out:
+        p = SyntheticPilotDataset.write_json(records, out)
+        click.echo(f"  Veri seti yazıldı:    {p}")
+    click.echo("=" * 70)
+
+
+@main.command(name="verify")
+@click.option("--tenant", default="verify-tenant", help="Tenant ID for the verification run")
+@click.option("--json", "as_json", is_flag=True, default=False, help="Machine-readable JSON output")
+def verify(tenant: str, as_json: bool):
+    """
+    Bağımsız-doğrulama CLI'si ( kanıt-entegrasyonu).
+
+    lead → silindirler → KPI → imzalı-rapor zincirini sıfırdan-oynar ve
+    Ed25519-imzasını bağımsız olarak yeniden-doğrular. Demo-komutlarının
+    paylaştığı-durumu kullanmaz; her-geçidi ayrı-ölçer.
+
+    Exit-code: 0 = hepsi-geçti, 1 = en-az-bir-bozuk.
+    """
+    checks: list[dict] = []
+
+    def record(name, ok, detail):
+        checks.append({"check": name, "result": "PASS" if ok else "FAIL", "detail": detail})
+
+    # 1) Pipeline-koşusu: lead-ingest → döngü → KPI-toplandı
+    try:
+        engine = YieldixEngine(PipelineConfig(tenant_id=tenant))
+        lead = InboundLeadPayload(
+            tenant_id=tenant,
+            lead_id="lead_verify_001",
+            contact_name="Verification Contact",
+            contact_phone="+15550001111",
+            source=LeadSource.WEB_FORM,
+            intent_summary="Verification intent — enterprise B2B quote",
+        )
+        ingest_res = asyncio.run(engine.ingest_inbound_lead(lead))
+        cycle = asyncio.run(engine.run_daily_cycle())
+        ok = bool(ingest_res) and len(cycle.get("active_components", [])) > 0
+        record("pipeline_runs_lead_to_cycle", ok,
+               f"ingested={bool(ingest_res)} active={len(cycle.get('active_components', []))} "
+               f"shed={len(cycle.get('shed_components', []))}")
+    except Exception as e:  # pragma: no cover - diagnostic
+        record("pipeline_runs_lead_to_cycle", False, f"exception: {type(e).__name__}: {e}")
+
+    # 2) Kanıt-üretimi: imzalı-rapor-üretiliyor + SHA-256-özeti-var
+    try:
+        engine = YieldixEngine(PipelineConfig(tenant_id=tenant))
+        engine.kpi_collector.record_lead_processed(
+            "lead_verify_001", 32.5, is_sql=True, cost_try=Decimal("15.00"))
+        gen = MonthlyReportGenerator()
+        rep = gen.generate_signed_report(
+            tenant_id=tenant, period_start="2026-10-01", period_end="2026-10-31",
+            kpi_collector=engine.kpi_collector,
+            active_components=engine.config.enabled_components,
+        )
+        digest = getattr(rep, "sha256_digest", None)
+        sig = getattr(rep, "ed25519_signature", None)
+        pubkey = gen.signer.public_key_hex if gen.signer else None
+        ok = bool(digest) and bool(sig) and bool(pubkey)
+        record("signed_report_produced", ok,
+               f"digest={(digest or 'YOK')[:24]}… sig={'var' if sig else 'YOK'} key={'var' if pubkey else 'YOK'}")
+    except Exception as e:  # pragma: no cover - diagnostic
+        record("signed_report_produced", False, f"exception: {type(e).__name__}: {e}")
+
+    # 3) Bağımsız-imza-doğrulaması: imza, payload-üzerinden yeniden-teyit
+    try:
+        engine = YieldixEngine(PipelineConfig(tenant_id=tenant))
+        engine.kpi_collector.record_lead_processed(
+            "lead_verify_001", 32.5, is_sql=True, cost_try=Decimal("15.00"))
+        gen = MonthlyReportGenerator()
+        rep = gen.generate_signed_report(
+            tenant_id=tenant, period_start="2026-10-01", period_end="2026-10-31",
+            kpi_collector=engine.kpi_collector,
+            active_components=engine.config.enabled_components,
+        )
+        from yieldix.crypto.signer import Ed25519ReportSigner
+        payload = MonthlyReportGenerator.to_signable_dict(rep)
+        sig = getattr(rep, "ed25519_signature", None)
+        pubkey = gen.signer.public_key_hex if gen.signer else None
+        verified = Ed25519ReportSigner.verify_signature(payload, sig, pubkey)
+        # Tahrif-direnci: imzalı-payload-değiştirilince imza artık-onaylanmamalı
+        tampered = dict(payload)
+        if "total_leads" in tampered:
+            tampered["total_leads"] = (tampered["total_leads"] or 0) + 999
+        tampered_ok = not Ed25519ReportSigner.verify_signature(tampered, sig, pubkey)
+        ok = bool(verified) and tampered_ok
+        record("signature_verifies_and_tamper_resistant", ok,
+               f"verify={bool(verified)} tamper-rejected={tampered_ok}")
+    except Exception as e:  # pragma: no cover - diagnostic
+        record("signature_verifies_and_tamper_resistant", False,
+               f"exception: {type(e).__name__}: {e}")
+
+    # 4) Tenant-izolasyonu: AT-179 — configsiz-motor-default-tenant-reddeder
+    try:
+        import os
+        old = os.environ.pop("YIELDIX_TENANT_ID", None)
+        # YIELDIX-1 (DUZELTILDI): 'YIELDIX_ALLOW_DEFAULT_TENANT'-de-pop'lanip-
+        # GERI-KONMUYORDU ( env-mutasyonu-yan-etkisi — kontrol-kendi-env'ini-
+        # kalici-olarik-kirletiyordu). Artik-her-iki-deger-de-geri-yuklenir.
+        old_allow = os.environ.pop("YIELDIX_ALLOW_DEFAULT_TENANT", None)
+        try:
+            YieldixEngine()
+            ok = False
+            detail = "configsiz-engine-KABUL-EDİLDİ ( cross-tenant-açık!)"
+        except ValueError:
+            ok = True
+            detail = "configsiz-engine-reddedildi ( tenant-zorunlu-sağlam)"
+        finally:
+            if old is not None:
+                os.environ["YIELDIX_TENANT_ID"] = old
+            if old_allow is not None:
+                os.environ["YIELDIX_ALLOW_DEFAULT_TENANT"] = old_allow
+        record("tenant_isolation_enforced", ok, detail)
+    except Exception as e:  # pragma: no cover - diagnostic
+        record("tenant_isolation_enforced", False, f"exception: {type(e).__name__}: {e}")
+
+    # 5) Circuit-breaker: aşırı-ihlal → component-shed-edilir
+    try:
+        from yieldix.core.circuit_breaker import CircuitBreaker
+        cb = CircuitBreaker(max_escalation_pct=10.0, max_consecutive_breaches=3)
+        for _ in range(4):
+            cb.record_interaction("c_verify", has_error=False, was_escalated=True)
+            cb.evaluate_cycle("c_verify")
+        shed = cb.get_shed_components()
+        ok = "c_verify" in shed
+        record("circuit_breaker_sheds_on_breach", ok,
+               f"shed={shed}")
+    except Exception as e:  # pragma: no cover - diagnostic
+        record("circuit_breaker_sheds_on_breach", False,
+               f"exception: {type(e).__name__}: {e}")
+
+    # 6) Pilot-veri-seti: CPL/SQL quantified + imzalı-raporla-doğrulanıyor
+    #    ( "lead-qualification-akademik-boş" dürüst-eleştirisine yanıt)
+    try:
+        from yieldix.telemetry.pilot_dataset import (
+            SyntheticPilotDataset, PILOT_COMPANIES)
+        ds = SyntheticPilotDataset(leads_per_company=8, seed=1337)
+        records = ds.generate()
+        rep, fingerprint, pubkey = ds.build_signed_report(
+            records, tenant_id=tenant)
+        rate = sum(r.is_sql for r in records) / max(1, len(records))
+        ok = (
+            len(PILOT_COMPANIES) >= 10
+            and rep.total_leads == len(records)
+            and rep.qualified_sql == sum(r.is_sql for r in records)
+            and 0.02 <= rate <= 0.40
+            and rep.cost_per_lead_try > 0
+            and len(fingerprint) == 64
+        )
+        record("pilot_dataset_cpl_sql_quantified", ok,
+               f"companies={len(PILOT_COMPANIES)} leads={rep.total_leads} "
+               f"sql={rep.qualified_sql}(%{rate * 100:.1f}) cpl={rep.cost_per_lead_try}")
+    except Exception as e:  # pragma: no cover - diagnostic
+        record("pilot_dataset_cpl_sql_quantified", False,
+               f"exception: {type(e).__name__}: {e}")
+
+    # 7) Özet-tutarlılığı: rapordaki SHA-256 özeti payload'dan yeniden-hesaplanınca
+    #    aynı-değeri-vermeli ( digest-payload-ayrılması yok)
+    try:
+        from yieldix.crypto.hasher import sha256_digest_hex
+        engine = YieldixEngine(PipelineConfig(tenant_id=tenant))
+        engine.kpi_collector.record_lead_processed(
+            "lead_verify_001", 32.5, is_sql=True, cost_try=Decimal("15.00"))
+        gen = MonthlyReportGenerator()
+        rep = gen.generate_signed_report(
+            tenant_id=tenant, period_start="2026-10-01", period_end="2026-10-31",
+            kpi_collector=engine.kpi_collector,
+            active_components=engine.config.enabled_components,
+        )
+        payload = MonthlyReportGenerator.to_signable_dict(rep)
+        recomputed = sha256_digest_hex(payload)
+        ok = recomputed == rep.sha256_digest
+        record("report_digest_matches_payload", ok,
+               f"digest-match={ok}")
+    except Exception as e:  # pragma: no cover - diagnostic
+        record("report_digest_matches_payload", False,
+               f"exception: {type(e).__name__}: {e}")
+
+    # 8) BANT-nitelendirme-yapısaldır: keyword-tarama-DEĞİL, yapısal-puanlama
+    #    ( düşük-intent-lead yüksek-puan-almamalı)
+    try:
+        from yieldix.cylinders.web_qualifier import WebQualifier
+        q = WebQualifier(tenant_id=tenant)
+        thin = InboundLeadPayload(
+            tenant_id=tenant, lead_id="lead_thin", contact_name="X",
+            contact_phone="+15550000001", source=LeadSource.WEB_FORM,
+            intent_summary="merhaba")  # kısa-intent → düşük need-skoru
+        full = InboundLeadPayload(
+            tenant_id=tenant, lead_id="lead_full", contact_name="Y",
+            contact_phone="+15550000002", source=LeadSource.WEB_FORM,
+            intent_summary="Kurumsal B2B yazılım teklifi: 200 kullanicili plan, bu ay almak istiyoruz")
+        thin_bant = q.evaluate_initial_bant(thin)
+        full_bant = q.evaluate_initial_bant(full)
+        ok = full_bant.need >= thin_bant.need and full_bant.total_score >= 0.0
+        record("bant_scoring_is_structural", ok,
+               f"need-thin={thin_bant.need} need-full={full_bant.need} "
+               f"total-full={full_bant.total_score}")
+    except Exception as e:  # pragma: no cover - diagnostic
+        record("bant_scoring_is_structural", False,
+               f"exception: {type(e).__name__}: {e}")
+
+    # 9) Cross-tenant rapor-izolasyonu: bir tenant'ın raporu diğerine karışmıyor
+    #    ( imzalı-rapor tenant-bound olmalı)
+    try:
+        eng_a = YieldixEngine(PipelineConfig(tenant_id=f"{tenant}_A"))
+        eng_b = YieldixEngine(PipelineConfig(tenant_id=f"{tenant}_B"))
+        eng_a.kpi_collector.record_lead_processed("la", 10.0, is_sql=True, cost_try=Decimal("15"))
+        gen = MonthlyReportGenerator()
+        rep_a = gen.generate_signed_report(
+            tenant_id=f"{tenant}_A", period_start="2026-10-01", period_end="2026-10-31",
+            kpi_collector=eng_a.kpi_collector,
+            active_components=eng_a.config.enabled_components)
+        ok = rep_a.tenant_id == f"{tenant}_A" and eng_b.config.tenant_id == f"{tenant}_B"
+        # B toplayıcısı boş olmalı ( A'nın lead'leri sızmamış)
+        ok = ok and eng_b.kpi_collector.compute_summary_metrics()["total_leads"] == 0.0
+        record("cross_tenant_report_isolation", ok,
+               f"repA={rep_a.tenant_id} repB-untouched={ok}")
+    except Exception as e:  # pragma: no cover - diagnostic
+        record("cross_tenant_report_isolation", False,
+               f"exception: {type(e).__name__}: {e}")
+
+    n_pass = sum(1 for c in checks if c["result"] == "PASS")
+    n_all = len(checks)
+    verdict = "PASS" if n_pass == n_all else "FAIL"
+
+    if as_json:
+        click.echo(json.dumps({"verdict": verdict, "passed": n_pass, "total": n_all,
+                               "checks": checks}, ensure_ascii=False, indent=2))
+    else:
+        click.echo("=" * 70)
+        click.echo("  YIELDIX BAĞIMSIZ-DOĞRULAMA ( independent-verify)")
+        click.echo("=" * 70)
+        for c in checks:
+            mark = "✓" if c["result"] == "PASS" else "✗"
+            click.echo(f"  [{mark}] {c['result']:<4} {c['check']}")
+            click.echo(f"         {c['detail']}")
+        click.echo("-" * 70)
+        click.echo(f"  SONUÇ: {verdict} — {n_pass}/{n_all} kontrol-geçti")
+        click.echo("=" * 70)
+    ctx = click.get_current_context()
+    ctx.exit(0 if verdict == "PASS" else 1)
+
+
+if __name__ == "__main__":
+    main()
+

yieldix/core/circuit_breaker.py

@@ -0,0 +1,108 @@
+"""
+Yieldix Circuit Breaker & Component Shedding Engine.
+Implements Theorem 3: Bounded Error Propagation and Dynamic Component Isolation.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+logger = logging.getLogger("Yieldix.CircuitBreaker")
+
+
+@dataclass
+class ComponentMetrics:
+    total_calls: int = 0
+    error_count: int = 0
+    escalation_count: int = 0
+    consecutive_breaches: int = 0
+
+    @property
+    def error_rate_pct(self) -> float:
+        if self.total_calls == 0:
+            return 0.0
+        return (self.error_count / self.total_calls) * 100.0
+
+    @property
+    def escalation_rate_pct(self) -> float:
+        if self.total_calls == 0:
+            return 0.0
+        return (self.escalation_count / self.total_calls) * 100.0
+
+
+class CircuitBreaker:
+    """
+    Evaluates streaming or interval-based component telemetry.
+    If a component exceeds max_escalation_pct (default 20%) for max_consecutive_breaches (default 7 cycles),
+    it trips and dynamically sheds the faulty component from active execution.
+    """
+
+    def __init__(
+        self,
+        max_escalation_pct: float = 20.0,
+        max_consecutive_breaches: int = 7,
+    ):
+        self.max_escalation_pct = max_escalation_pct
+        self.max_consecutive_breaches = max_consecutive_breaches
+        self._metrics: dict[str, ComponentMetrics] = {}
+        self._shed_components: set[str] = set()
+
+    def record_interaction(
+        self, component_name: str, has_error: bool = False, was_escalated: bool = False
+    ) -> None:
+        if component_name not in self._metrics:
+            self._metrics[component_name] = ComponentMetrics()
+
+        m = self._metrics[component_name]
+        m.total_calls += 1
+        if has_error:
+            m.error_count += 1
+        if was_escalated:
+            m.escalation_count += 1
+
+    def evaluate_cycle(self, component_name: str) -> bool:
+        """
+        Evaluates current metrics for a component.
+        Returns True if the component is shed in this cycle, False otherwise.
+        """
+        if component_name in self._shed_components:
+            return False
+
+        metrics = self._metrics.get(component_name)
+        if not metrics or metrics.total_calls == 0:
+            return False
+
+        if metrics.escalation_rate_pct > self.max_escalation_pct:
+            metrics.consecutive_breaches += 1
+            logger.warning(
+                "Circuit Breaker Warning: Component '%s' escalation rate at %.2f%% (Breach %d/%d)",
+                component_name,
+                metrics.escalation_rate_pct,
+                metrics.consecutive_breaches,
+                self.max_consecutive_breaches,
+            )
+            if metrics.consecutive_breaches >= self.max_consecutive_breaches:
+                self._shed_components.add(component_name)
+                logger.error(
+                    "CIRCUIT BREAKER TRIPPED: Component '%s' has been shed from active pipeline! "
+                    "Teorem 3 Koruması: Ana motor güvenliği sağlandı.",
+                    component_name,
+                )
+                return True
+        else:
+            metrics.consecutive_breaches = 0
+
+        return False
+
+    def is_component_active(self, component_name: str) -> bool:
+        return component_name not in self._shed_components
+
+    def get_shed_components(self) -> list[str]:
+        return sorted(self._shed_components)
+
+    def reset_component(self, component_name: str) -> None:
+        self._shed_components.discard(component_name)
+        if component_name in self._metrics:
+            self._metrics[component_name] = ComponentMetrics()
+        logger.info("Circuit Breaker: Component '%s' has been manually reinstated.", component_name)