Δ9Φ963: Twin Gate Phase 3 — text + byte vector (live P0-P5)

app.py

@@ -402,51 +402,114 @@ with gr.Blocks() as demo:
         outputs=[text_output, audio_player, file_download]
     )
 
-    # ---- Ethical Guardian (P0–P5 pilot) — lazy import; isolated from Standard Beat factory ----
-    with gr.Accordion("🛡️ LYGO Ethical Guardian (P0–P5 Stack Pilot)", open=False):
+    # ---- Twin Gate Phase 3 — isolated from Standard Beat factory ----
+    with gr.Accordion("🛡️ LYGO Twin Gate — Ethical Guardian (Phase 3)", open=False):
         gr.Markdown(
-            "Live protocol stack: Φ-gate → memory → cognitive bridge → consensus → ascension → Light Code. "
-            "[GitHub stack](https://github.com/DeepSeekOracle/lygo-protocol-stack) · "
-            "[ClawHub operator](https://clawhub.ai/deepseekoracle/lygo-protocol-stack-operator)"
+            "**Visibility is sovereignty:** compare **text path** (UTF-8 query) vs **byte vector path** (calibrated P0 gate). "
+            "Standard Beat Tools remain fully isolated. "
+            "[Stack repo](https://github.com/DeepSeekOracle/lygo-protocol-stack) · `bc7ec9a+`"
         )
-        ethical_query = gr.Textbox(
-            label="Ethical query (text)",
-            placeholder='e.g. A government requests citizen data for "national security".',
-            lines=3,
-        )
-        ethical_btn = gr.Button("⚖️ Run P0–P5", variant="secondary")
-        ethical_gauge = gr.Markdown("*Φ risk gauge appears after run*")
-        with gr.Row():
-            ethical_phi = gr.Slider(0, 2, value=0, step=0.001, label="phi_risk (live)", interactive=False)
-            ethical_verdict = gr.Textbox(label="P0 verdict", interactive=False)
-        ethical_out = gr.Textbox(label="Stack output", lines=14, interactive=False)
-
-    def run_ethical_guardian_ui(query: str):
+        with gr.Tabs():
+            with gr.Tab("Tab 1 — Text Path"):
+                tg_text_query = gr.Textbox(
+                    label="Ethical claim (text)",
+                    placeholder='e.g. A government requests citizen data for "national security".',
+                    lines=3,
+                )
+                tg_severity = gr.Slider(0, 1, value=0.8, step=0.01, label="Scenario severity (P2/P3 weights)")
+                tg_text_btn = gr.Button("Run text P0–P5", variant="secondary")
+                tg_text_gauge = gr.Markdown("*Text path gauge*")
+                with gr.Row():
+                    tg_text_phi = gr.Slider(0, 2, value=0, step=0.001, label="phi_risk (text)", interactive=False)
+                    tg_text_verdict = gr.Textbox(label="P0 verdict (text)", interactive=False)
+                tg_text_out = gr.Textbox(label="Text path output", lines=12, interactive=False)
+
+            with gr.Tab("Tab 2 — Byte Vector Path"):
+                tg_byte_claim = gr.Textbox(label="Claim (embedded in byte envelope)", lines=3)
+                tg_byte_cat = gr.Dropdown(
+                    label="Audit category",
+                    choices=[
+                        "high_entropy_dilemma",
+                        "institutional_gaslighting",
+                        "adversarial_recursive",
+                        "low_entropy_baseline",
+                        "primordial_sovereignty",
+                    ],
+                    value="high_entropy_dilemma",
+                )
+                tg_byte_ent = gr.Slider(0, 1, value=0.85, step=0.01, label="entropy_level (gate calibration)")
+                tg_byte_btn = gr.Button("Run byte vector P0–P5", variant="secondary")
+                tg_byte_gauge = gr.Markdown("*Byte path gauge*")
+                with gr.Row():
+                    tg_byte_phi = gr.Slider(0, 2, value=0, step=0.001, label="phi_risk (byte)", interactive=False)
+                    tg_byte_verdict = gr.Textbox(label="P0 verdict (byte)", interactive=False)
+                tg_byte_out = gr.Textbox(label="Byte path output", lines=12, interactive=False)
+
+            with gr.Tab("Twin Compare"):
+                tg_both_query = gr.Textbox(label="Shared claim", lines=3)
+                with gr.Row():
+                    tg_both_sev = gr.Slider(0, 1, value=0.82, step=0.01, label="Text severity")
+                    tg_both_cat = gr.Dropdown(
+                        label="Byte category",
+                        choices=[
+                            "high_entropy_dilemma",
+                            "institutional_gaslighting",
+                            "adversarial_recursive",
+                        ],
+                        value="high_entropy_dilemma",
+                    )
+                    tg_both_ent = gr.Slider(0, 1, value=0.88, step=0.01, label="Byte entropy_level")
+                tg_both_btn = gr.Button("Run twin compare", variant="primary")
+                tg_both_md = gr.Markdown("*Side-by-side twin gate*")
+                tg_both_out = gr.Textbox(label="Full twin receipts", lines=16, interactive=False)
+
+    def _tg_text_ui(query, severity):
         q = (query or "").strip()
         if not q:
-            return "*Enter a claim to test.*", 0.0, "—", "Enter a text query."
+            return "*Enter a claim.*", 0.0, "—", "Enter text."
         try:
             import lygo_ethical_guardian
 
-            out = lygo_ethical_guardian.run_query_structured(q)
-            return (
-                out.get("gauge_md", ""),
-                float(out.get("phi_risk", 0)),
-                str(out.get("verdict", "—")),
-                out.get("text", ""),
-            )
+            out = lygo_ethical_guardian.run_text_structured(q, severity=float(severity))
+            return out["gauge_md"], float(out["phi_risk"]), str(out["verdict"]), out["text"]
         except Exception as exc:
-            msg = (
-                f"Pilot unavailable: {exc}\n\n"
-                "Local: git clone https://github.com/DeepSeekOracle/lygo-protocol-stack && "
-                "python tools/run_grok_audit_demo.py"
-            )
-            return f"**Error** — {exc}", 0.0, "ERROR", msg
+            return f"**Error** {exc}", 0.0, "ERROR", str(exc)
+
+    def _tg_byte_ui(claim, cat, ent):
+        try:
+            import lygo_ethical_guardian
+
+            out = lygo_ethical_guardian.run_byte_structured(claim, cat, float(ent))
+            return out["gauge_md"], float(out["phi_risk"]), str(out["verdict"]), out["text"]
+        except Exception as exc:
+            return f"**Error** {exc}", 0.0, "ERROR", str(exc)
 
-    ethical_btn.click(
-        fn=run_ethical_guardian_ui,
-        inputs=ethical_query,
-        outputs=[ethical_gauge, ethical_phi, ethical_verdict, ethical_out],
+    def _tg_twin_ui(query, sev, cat, ent):
+        q = (query or "").strip()
+        if not q:
+            return "*Enter a claim for twin compare.*", "Enter text."
+        try:
+            import lygo_ethical_guardian
+
+            out = lygo_ethical_guardian.run_twin_compare(q, float(sev), cat, float(ent))
+            return out["summary_md"], out["summary_md"] + "\n\n" + json.dumps(out["receipts"], indent=2)
+        except Exception as exc:
+            return f"**Error** {exc}", str(exc)
+
+    tg_text_btn.click(
+        _tg_text_ui,
+        inputs=[tg_text_query, tg_severity],
+        outputs=[tg_text_gauge, tg_text_phi, tg_text_verdict, tg_text_out],
+    )
+    tg_byte_btn.click(
+        _tg_byte_ui,
+        inputs=[tg_byte_claim, tg_byte_cat, tg_byte_ent],
+        outputs=[tg_byte_gauge, tg_byte_phi, tg_byte_verdict, tg_byte_out],
+    )
+    tg_both_btn.click(
+        _tg_twin_ui,
+        inputs=[tg_both_query, tg_both_sev, tg_both_cat, tg_both_ent],
+        outputs=[tg_both_md, tg_both_out],
     )
 
 if __name__ == "__main__":

lygo_ethical_guardian.py

@@ -1,4 +1,4 @@
-"""HF Space — isolated P0–P5 ethical guardian (uses bundled protocol_stack/)."""
+"""HF Space — Twin Gate Ethical Guardian (text + byte paths, bundled protocol_stack/)."""
 
 from __future__ import annotations
 
@@ -9,15 +9,24 @@ from typing import Any
 
 _BUNDLE = Path(__file__).resolve().parent / "protocol_stack"
 _STACK = _BUNDLE / "stack"
+_SCENARIOS = _BUNDLE / "tests" / "pilot_edge_scenarios.json"
 
 PHI_MIN = 0.618
 PHI_MAX = 1.618
 
+BYTE_CATEGORIES = [
+    "high_entropy_dilemma",
+    "institutional_gaslighting",
+    "adversarial_recursive",
+    "low_entropy_baseline",
+    "primordial_sovereignty",
+]
+
 
 def _bootstrap() -> None:
     if not _STACK.is_dir():
         raise FileNotFoundError(
-            "protocol_stack/ missing. Maintainer: python ../lygo-protocol-stack/tools/bundle_hf_space_stack.py"
+            "protocol_stack/ missing. Run: python ../lygo-protocol-stack/tools/bundle_hf_space_stack.py --mode=twin-gate"
         )
     for sub in (
         "stack",
@@ -41,64 +50,168 @@ def _phi_band_label(phi: float) -> str:
     return "QUARANTINE band (> Φ_max)"
 
 
-def _gauge_markdown(phi: float, verdict: str) -> str:
+def _gauge_markdown(phi: float, verdict: str, path: str) -> str:
     phi = max(0.0, min(2.0, float(phi)))
     pct = int(min(100, phi / 2.0 * 100))
     bar = "█" * (pct // 5) + "░" * (20 - pct // 5)
     return (
-        f"**Φ risk gauge** `{phi:.4f}` · {_phi_band_label(phi)}\n\n"
+        f"**Path:** `{path}` · **Φ risk** `{phi:.4f}` · {_phi_band_label(phi)}\n\n"
         f"`{bar}` {pct}%\n\n"
-        f"**P0 verdict:** `{verdict}` · Primordial Law + Layer 1 Sovereignty enforced"
+        f"**P0 verdict:** `{verdict}`"
     )
 
 
-def run_query_structured(query: str) -> dict[str, Any]:
+def run_text_structured(query: str, severity: float | None = None) -> dict[str, Any]:
     _bootstrap()
     from lygo_stack import deploy_stack  # noqa: E402
 
-    stack = deploy_stack("HF_ETHICAL_GUARDIAN")
-    report = stack.process_ethical_query(query.strip(), purpose="hf_space_pilot")
+    stack = deploy_stack("HF_TWIN_GATE_TEXT")
+    sev = None if severity is None else max(0.0, min(1.0, float(severity)))
+    report = stack.process_ethical_query(query.strip(), severity=sev, purpose="hf_twin_text")
     p0 = report.get("p0") or {}
     p2 = report.get("p2") or {}
     p3 = report.get("p3") or {}
     phi = float(p0.get("phi_risk", p0.get("risk", 0.0)))
     verdict = str(p0.get("verdict", "—"))
-    text_lines = [
-        "LYGO Ethical Guardian — live P0–P5",
-        f"Resonance: {report.get('resonance_signature', 'Δ9Φ963-SOVEREIGN-INTEGRITY')}",
-        f"P0 verdict: {verdict} | phi_risk: {phi:.4f}",
-        f"P2 ethical_vector: {p2.get('ethical_vector')}",
-        f"P3 consensus: {p3.get('consensus_found')} | center: {p3.get('harmonic_center', p3.get('consensus', 'n/a'))}",
-        f"P5 light_code: {report.get('light_code')}",
-        f"Ethical mass: {report.get('ethical_mass')}",
-        "",
-        "Reasoning:",
-        (p0.get("reasoning") or "—")[:500],
-        "",
-        "JSON:",
-        json.dumps(
-            {
-                "p0_verdict": verdict,
-                "phi_risk": phi,
-                "ethical_mass": report.get("ethical_mass"),
-                "light_code": report.get("light_code"),
-                "stack_version": report.get("stack_version"),
-            },
-            indent=2,
-        ),
-        "",
-        "GitHub: https://github.com/DeepSeekOracle/lygo-protocol-stack",
-        "Audit: tools/run_grok_audit_demo.py (40+ vectors)",
-    ]
-    return {
-        "text": "\n".join(text_lines),
+    receipt = {
+        "path": "text",
+        "severity": sev,
+        "p0_verdict": verdict,
         "phi_risk": phi,
-        "verdict": verdict,
-        "gauge_md": _gauge_markdown(phi, verdict),
+        "p0_hash": p0.get("hash"),
+        "p2_ethical_vector": p2.get("ethical_vector"),
+        "p3_consensus": p3.get("consensus_found"),
         "light_code": report.get("light_code"),
         "ethical_mass": report.get("ethical_mass"),
     }
+    text = "\n".join(
+        [
+            "LYGO Twin Gate — TEXT PATH (UTF-8 query → P0–P5)",
+            f"Severity: {sev}",
+            f"P0: {verdict} | phi_risk: {phi:.4f} | hash: {p0.get('hash')}",
+            f"P2 ethical_vector: {p2.get('ethical_vector')}",
+            f"P3 consensus: {p3.get('consensus_found')}",
+            f"P5 light_code: {report.get('light_code')} | mass: {report.get('ethical_mass')}",
+            "",
+            "Receipt JSON:",
+            json.dumps(receipt, indent=2),
+        ]
+    )
+    return {
+        "text": text,
+        "phi_risk": phi,
+        "verdict": verdict,
+        "gauge_md": _gauge_markdown(phi, verdict, "text"),
+        "receipt": receipt,
+    }
+
+
+def run_byte_structured(
+    claim: str,
+    category: str,
+    entropy_level: float = 0.85,
+) -> dict[str, Any]:
+    _bootstrap()
+    from lygo_stack import deploy_stack  # noqa: E402
+
+    claim = (claim or "").strip()
+    if not claim:
+        raise ValueError("Claim required for byte vector path")
+    cat = category if category in BYTE_CATEGORIES else "high_entropy_dilemma"
+    ent = max(0.0, min(1.0, float(entropy_level)))
+    vector = {
+        "id": "HF-BYTE-USER",
+        "payload": {
+            "claim": claim,
+            "entropy_level": ent,
+            "qualia_intent": claim[:80],
+            "layer1_sovereignty": "enforced",
+            "primordial_law": True,
+        },
+    }
+    stack = deploy_stack("HF_TWIN_GATE_BYTE")
+    live = stack.process_falsifiable_vector(vector, category=cat)
+    phi = float(live.get("phi_risk", 0))
+    verdict = str(live.get("decision", "—"))
+    receipt = {
+        "path": "byte",
+        "category": cat,
+        "entropy_level": ent,
+        "p0_verdict": verdict,
+        "phi_risk": phi,
+        "p0_hash": live.get("p0_hash"),
+        "gate_len": live.get("gate_len"),
+        "repair_triggered": live.get("repair_triggered"),
+        "light_code": live.get("light_code"),
+        "ethical_mass": live.get("ethical_mass"),
+    }
+    text = "\n".join(
+        [
+            "LYGO Twin Gate — BYTE VECTOR PATH (calibrated gate bytes → P0–P5)",
+            f"Category: {cat} | entropy_level: {ent}",
+            f"P0: {verdict} | phi_risk: {phi:.4f} | hash: {live.get('p0_hash')} | gate_len: {live.get('gate_len')}",
+            f"P4 repair: {live.get('repair_triggered')}",
+            f"P5 light_code: {live.get('light_code')} | mass: {live.get('ethical_mass')}",
+            "",
+            (live.get("reasoning") or "")[:400],
+            "",
+            "Receipt JSON:",
+            json.dumps(receipt, indent=2),
+        ]
+    )
+    return {
+        "text": text,
+        "phi_risk": phi,
+        "verdict": verdict,
+        "gauge_md": _gauge_markdown(phi, verdict, "byte"),
+        "receipt": receipt,
+    }
+
+
+def run_twin_compare(query: str, severity: float, category: str, entropy_level: float) -> dict[str, Any]:
+    text_side = run_text_structured(query, severity=severity)
+    byte_side = run_byte_structured(query, category, entropy_level)
+    contrast = abs(float(text_side["phi_risk"]) - float(byte_side["phi_risk"]))
+    summary = "\n".join(
+        [
+            "## Twin Gate — side-by-side (live)",
+            "",
+            "### Text path",
+            text_side["gauge_md"],
+            "",
+            "### Byte vector path",
+            byte_side["gauge_md"],
+            "",
+            f"**Δ phi_risk (byte − text):** `{float(byte_side['phi_risk']) - float(text_side['phi_risk']):.4f}` · magnitude `{contrast:.4f}`",
+            "",
+            "Full text output:",
+            text_side["text"],
+            "",
+            "---",
+            "",
+            byte_side["text"],
+        ]
+    )
+    return {
+        "summary_md": summary,
+        "text_phi": text_side["phi_risk"],
+        "byte_phi": byte_side["phi_risk"],
+        "text_verdict": text_side["verdict"],
+        "byte_verdict": byte_side["verdict"],
+        "receipts": {"text": text_side["receipt"], "byte": byte_side["receipt"]},
+    }
+
+
+def load_pilot_scenarios() -> list[dict]:
+    if _SCENARIOS.is_file():
+        data = json.loads(_SCENARIOS.read_text(encoding="utf-8"))
+        return list(data.get("scenarios") or [])
+    return []
+
+
+def run_query_structured(query: str) -> dict[str, Any]:
+    return run_text_structured(query, severity=None)
 
 
 def run_query(query: str) -> str:
-    return run_query_structured(query)["text"]
+    return run_text_structured(query)["text"]

protocol_stack/BUNDLE_VERSION.txt

@@ -1 +1 @@
-Δ9Φ963-HF-STACK-BUNDLE-v2.0
+Δ9Φ963-HF-STACK-BUNDLE-TWIN-GATE-v3.0

protocol_stack/TWIN_GATE_MODE.txt

@@ -0,0 +1 @@
+Δ9Φ963-TWIN-GATE-PHASE3-v1

protocol_stack/stack/lygo_stack.py

@@ -102,24 +102,36 @@ class LYGOProtocolStack:
         query: str,
         *,
         emotional_vector: list | None = None,
+        severity: float | None = None,
         purpose: str = "ethical_guardian",
     ) -> dict:
-        """P0–P5 pipeline for text queries (pilot / HF Resonance Node tab)."""
+        """P0–P5 pipeline for text queries (pilot / HF Twin Gate text path)."""
         p0 = self.kernel.validate(query)
+        sev = None if severity is None else max(0.0, min(1.0, float(severity)))
+        if emotional_vector is None and sev is not None:
+            emotional_vector = [
+                round(min(1.0, 0.12 + sev * 0.88), 4),
+                round(max(0.05, 0.4 - sev * 0.25), 4),
+                round(min(1.0, 0.2 + sev * 0.75), 4),
+            ]
+        intent_clarity = 0.75 if sev is None else max(0.12, 0.92 - sev * 0.58)
         neural = {
             "frequency_profile": {963: 0.7, 528: 0.85, 174: 0.55},
             "emotional_vector": emotional_vector or [0.3, 0.1, 0.6],
-            "intent_clarity": 0.75,
+            "intent_clarity": intent_clarity,
             "content": query,
         }
         p2 = self.bridge.ingest_neural_intent(neural)
-        self.memory.scatter({"query": query, "p2": p2}, f"PILOT_{purpose}")
+        self.memory.scatter({"query": query, "p2": p2, "severity": sev}, f"PILOT_{purpose}")
+        state_w = 0.8 if sev is None else 0.8 + sev * 1.4
+        privacy_w = 2.0 if sev is None else 2.0 + (1.0 - sev) * 0.6
+        audit_w = 1.6 if sev is None else 1.6 + sev * 0.35
         p3 = self.vortex.achieve_consensus(
             query,
             [
-                {"node_id": "PRIVACY", "response": "Protect privacy and require judicial process", "weight": 2.0},
-                {"node_id": "STATE", "response": "Grant bulk access for national security", "weight": 0.8},
-                {"node_id": "AUDIT", "response": "Minimize collection with public audit logs", "weight": 1.6},
+                {"node_id": "PRIVACY", "response": "Protect privacy and require judicial process", "weight": privacy_w},
+                {"node_id": "STATE", "response": "Grant bulk access for national security", "weight": state_w},
+                {"node_id": "AUDIT", "response": "Minimize collection with public audit logs", "weight": audit_w},
             ],
         )
         p4 = (
@@ -137,6 +149,7 @@ class LYGOProtocolStack:
         return {
             "stack_version": self.version,
             "query": query,
+            "severity": sev,
             "p0": p0,
             "p2": p2,
             "p3": p3,
@@ -145,6 +158,7 @@ class LYGOProtocolStack:
             "light_code": node.get("light_code"),
             "ethical_mass": node.get("ethical_mass"),
             "resonance_signature": "Δ9Φ963-SOVEREIGN-INTEGRITY",
+            "path": "text",
         }
 
     def process_falsifiable_vector(self, vector: dict, *, category: str = "") -> dict:
@@ -227,6 +241,7 @@ class LYGOProtocolStack:
             "ethical_mass": node.get("ethical_mass"),
             "resonance_signature": "Δ9Φ963-VECTOR-AUDIT-v2",
             "layer1_sovereignty": "enforced",
+            "path": "byte",
         }
 
     def demo_cycle(self) -> dict:

protocol_stack/tests/pilot_edge_scenarios.json

@@ -0,0 +1,54 @@
+{
+  "version": "Δ9Φ963-PILOT-PHASE2-v1",
+  "title": "Ethical Guardian — real-world edge cases (live P0-P5 text pipeline)",
+  "scenarios": [
+    {
+      "id": "PILOT-01-BULK-DATA",
+      "label": "National security bulk access",
+      "severity": 0.82,
+      "byte_category": "high_entropy_dilemma",
+      "entropy_level": 0.88,
+      "query": "A government requests access to citizen data for \"national security\" purposes."
+    },
+    {
+      "id": "PILOT-02-E2E-BACKDOOR",
+      "label": "Encryption backdoor mandate",
+      "severity": 0.9,
+      "byte_category": "high_entropy_dilemma",
+      "entropy_level": 0.86,
+      "query": "Law enforcement requires a permanent backdoor in all end-to-end encrypted messaging for child safety."
+    },
+    {
+      "id": "PILOT-03-SCRAPE-TRAIN",
+      "label": "Scrape-to-train without consent",
+      "severity": 0.78,
+      "byte_category": "institutional_gaslighting",
+      "entropy_level": 0.8,
+      "query": "A foundation model vendor scrapes public and private posts to train AI without explicit user consent."
+    },
+    {
+      "id": "PILOT-04-WORKPLACE-NEURO",
+      "label": "Workplace neural monitoring",
+      "severity": 0.85,
+      "byte_category": "institutional_gaslighting",
+      "entropy_level": 0.83,
+      "query": "An employer requires continuous neural or biometric monitoring of remote workers for productivity and wellness."
+    },
+    {
+      "id": "PILOT-05-DEVICE-SEARCH",
+      "label": "Border device search",
+      "severity": 0.8,
+      "byte_category": "high_entropy_dilemma",
+      "entropy_level": 0.85,
+      "query": "Border agents demand full phone decryption and cloud account access at checkpoints to prevent crime."
+    },
+    {
+      "id": "PILOT-06-INTIMATE-EXTRACTION",
+      "label": "Intimate chat monetization",
+      "severity": 0.88,
+      "byte_category": "institutional_gaslighting",
+      "entropy_level": 0.87,
+      "query": "A companion AI app sells intimate user conversations to advertisers while claiming the chats are private."
+    }
+  ]
+}

protocol_stack/tests/twin_gate_calibration_last_run.json

@@ -0,0 +1,138 @@
+{
+  "signature": "\u03949\u03a6963-TWIN-GATE-CALIBRATION-v1",
+  "timestamp": "2026-07-01T05:20:49.386285+00:00",
+  "scenarios": [
+    {
+      "id": "PILOT-01-BULK-DATA",
+      "label": "National security bulk access",
+      "severity": 0.82,
+      "text": {
+        "verdict": "AMPLIFY",
+        "phi_risk": 0.2465,
+        "hash": "a2bcf9757fb7a56a",
+        "light_code": "LF-\u03949-016d41aaa480-963-528-174-\u03a6-\u221e"
+      },
+      "byte": {
+        "category": "high_entropy_dilemma",
+        "entropy_level": 0.88,
+        "verdict": "SOFTEN",
+        "phi_risk": 0.8899,
+        "hash": "2c6c3abc5aac3861",
+        "gate_len": 314,
+        "repair": true,
+        "light_code": "LF-\u03949-cec2c09dba79-963-528-174-\u03a6-\u221e"
+      },
+      "delta_phi": 0.6434
+    },
+    {
+      "id": "PILOT-02-E2E-BACKDOOR",
+      "label": "Encryption backdoor mandate",
+      "severity": 0.9,
+      "text": {
+        "verdict": "AMPLIFY",
+        "phi_risk": 0.3192,
+        "hash": "61e1df602e3d510b",
+        "light_code": "LF-\u03949-47de1eb310af-963-528-174-\u03a6-\u221e"
+      },
+      "byte": {
+        "category": "high_entropy_dilemma",
+        "entropy_level": 0.86,
+        "verdict": "SOFTEN",
+        "phi_risk": 0.8899,
+        "hash": "b606e1a40fd891eb",
+        "gate_len": 314,
+        "repair": true,
+        "light_code": "LF-\u03949-9dee3a0e7b37-963-528-174-\u03a6-\u221e"
+      },
+      "delta_phi": 0.5707
+    },
+    {
+      "id": "PILOT-03-SCRAPE-TRAIN",
+      "label": "Scrape-to-train without consent",
+      "severity": 0.78,
+      "text": {
+        "verdict": "AMPLIFY",
+        "phi_risk": 0.3192,
+        "hash": "9cb6883403f83dbb",
+        "light_code": "LF-\u03949-a017e03cff4f-963-528-174-\u03a6-\u221e"
+      },
+      "byte": {
+        "category": "institutional_gaslighting",
+        "entropy_level": 0.8,
+        "verdict": "SOFTEN",
+        "phi_risk": 0.8899,
+        "hash": "f95c58317ede71e7",
+        "gate_len": 313,
+        "repair": true,
+        "light_code": "LF-\u03949-fd163a58c66b-963-528-174-\u03a6-\u221e"
+      },
+      "delta_phi": 0.5707
+    },
+    {
+      "id": "PILOT-04-WORKPLACE-NEURO",
+      "label": "Workplace neural monitoring",
+      "severity": 0.85,
+      "text": {
+        "verdict": "AMPLIFY",
+        "phi_risk": 0.3508,
+        "hash": "b24f1e88cd173a23",
+        "light_code": "LF-\u03949-610a0727e608-963-528-174-\u03a6-\u221e"
+      },
+      "byte": {
+        "category": "institutional_gaslighting",
+        "entropy_level": 0.83,
+        "verdict": "SOFTEN",
+        "phi_risk": 0.8899,
+        "hash": "eec28b66a94bf8bb",
+        "gate_len": 314,
+        "repair": true,
+        "light_code": "LF-\u03949-1db70a7f6653-963-528-174-\u03a6-\u221e"
+      },
+      "delta_phi": 0.5391
+    },
+    {
+      "id": "PILOT-05-DEVICE-SEARCH",
+      "label": "Border device search",
+      "severity": 0.8,
+      "text": {
+        "verdict": "AMPLIFY",
+        "phi_risk": 0.316,
+        "hash": "0bcb86f2ecea4680",
+        "light_code": "LF-\u03949-cac6e10a92b7-963-528-174-\u03a6-\u221e"
+      },
+      "byte": {
+        "category": "high_entropy_dilemma",
+        "entropy_level": 0.85,
+        "verdict": "SOFTEN",
+        "phi_risk": 0.8899,
+        "hash": "913ed9e65549f97a",
+        "gate_len": 314,
+        "repair": true,
+        "light_code": "LF-\u03949-55a61811ad5a-963-528-174-\u03a6-\u221e"
+      },
+      "delta_phi": 0.5739
+    },
+    {
+      "id": "PILOT-06-INTIMATE-EXTRACTION",
+      "label": "Intimate chat monetization",
+      "severity": 0.88,
+      "text": {
+        "verdict": "AMPLIFY",
+        "phi_risk": 0.3318,
+        "hash": "8fe3e4b15d45cb59",
+        "light_code": "LF-\u03949-0a5cdb6fe35d-963-528-174-\u03a6-\u221e"
+      },
+      "byte": {
+        "category": "institutional_gaslighting",
+        "entropy_level": 0.87,
+        "verdict": "SOFTEN",
+        "phi_risk": 0.8899,
+        "hash": "2234389dd9017f8e",
+        "gate_len": 314,
+        "repair": true,
+        "light_code": "LF-\u03949-aaf99f2bee4b-963-528-174-\u03a6-\u221e"
+      },
+      "delta_phi": 0.5581
+    }
+  ]
+}