halyn 2.2.3__tar.gz → 2.2.5__tar.gz

{halyn-2.2.3/src/halyn.egg-info → halyn-2.2.5}/PKG-INFO

@@ -1,9 +1,9 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: halyn
-Version: 2.2.3
+Version: 2.2.5
 Summary: Halyn — The governance layer for AI agents. Every action intercepted. Every decision auditable.
 Author-email: Elmadani SALKA <contact@halyn.dev>
-License-Expression: BUSL-1.1
+License: BUSL-1.1
 Project-URL: Homepage, https://halyn.dev
 Project-URL: Repository, https://github.com/halyndev/halyn
 Project-URL: Issues, https://github.com/halyndev/halyn/issues
@@ -29,7 +29,6 @@ Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-asyncio; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
-Dynamic: license-file
 
 <div align="center">
 
@@ -83,7 +82,7 @@ Every action produces a cryptographic proof stored locally. Not in the cloud. No
 **Option 1 — pip** (Python 3.10+):
 
 ```bash
-pip install halyn==2.1.3
+pip install halyn==2.2.4
 halyn serve
 ```
 
@@ -101,23 +100,33 @@ The curl script verifies your Python version and asks permission before doing an
 ## Quick Start
 
 ```python
-from halyn import ControlPlane
-
-# Start the governance layer
-gov = ControlPlane()
-gov.serve()  # dashboard at localhost:7420
-
-# Register an agent
-agent = gov.register_agent(
-    name="claude-cowork",
-    provider="anthropic",
-    autonomy_level=2,  # executor — reversible actions only
-)
-
-# Every agent action is intercepted and recorded
-result = agent.act("read_file", "/docs/contract.pdf")
-print(result.proof)    # sha256:a3f2e1...
-print(result.allowed)  # True
+from halyn.control_plane import ControlPlane
+from halyn.config import HalynConfig
+
+# Start the control plane (or run `halyn serve` from CLI)
+cp = ControlPlane(HalynConfig())
+
+# Every node action passes through the pipeline:
+# Consent → Shield → Execute → Audit
+import asyncio
+async def main():
+    await cp.start()
+    result = await cp.execute(
+        "myserver.observe",
+        {"channels": "cpu,ram"},
+        user_id="me",
+        intent_text="Check server load",
+    )
+    print(result.ok)     # True
+    print(result.data)   # {"cpu": 42.1, "ram": 67.3}
+
+    # Audit chain — cryptographic proof of every action
+    entries = cp.audit.query(limit=5)
+    valid, count, msg = cp.audit.verify_chain()
+    print(msg)           # "Chain valid (N entries)"
+    await cp.stop()
+
+asyncio.run(main())
 ```
 
 ---
@@ -228,7 +237,7 @@ Halyn intercepts any agentic system. The agent framework doesn't matter.
 | **AutoGen** | API calls intercepted automatically |
 | **CrewAI** | API calls intercepted automatically |
 | **Semantic Kernel** | API calls intercepted automatically |
-| **BeeQ** | Native AAP integration |
+| **Any AAP client** | Native AAP integration |
 | **Any MCP agent** | MCP server passthrough |
 | **Any A2A agent** | Network-level interception |
 | **Any OpenAI-compatible API** | Universal proxy compatibility |

{halyn-2.2.3 → halyn-2.2.5}/README.md

@@ -50,7 +50,7 @@ Every action produces a cryptographic proof stored locally. Not in the cloud. No
 **Option 1 — pip** (Python 3.10+):
 
 ```bash
-pip install halyn==2.1.3
+pip install halyn==2.2.4
 halyn serve
 ```
 
@@ -68,23 +68,33 @@ The curl script verifies your Python version and asks permission before doing an
 ## Quick Start
 
 ```python
-from halyn import ControlPlane
-
-# Start the governance layer
-gov = ControlPlane()
-gov.serve()  # dashboard at localhost:7420
-
-# Register an agent
-agent = gov.register_agent(
-    name="claude-cowork",
-    provider="anthropic",
-    autonomy_level=2,  # executor — reversible actions only
-)
-
-# Every agent action is intercepted and recorded
-result = agent.act("read_file", "/docs/contract.pdf")
-print(result.proof)    # sha256:a3f2e1...
-print(result.allowed)  # True
+from halyn.control_plane import ControlPlane
+from halyn.config import HalynConfig
+
+# Start the control plane (or run `halyn serve` from CLI)
+cp = ControlPlane(HalynConfig())
+
+# Every node action passes through the pipeline:
+# Consent → Shield → Execute → Audit
+import asyncio
+async def main():
+    await cp.start()
+    result = await cp.execute(
+        "myserver.observe",
+        {"channels": "cpu,ram"},
+        user_id="me",
+        intent_text="Check server load",
+    )
+    print(result.ok)     # True
+    print(result.data)   # {"cpu": 42.1, "ram": 67.3}
+
+    # Audit chain — cryptographic proof of every action
+    entries = cp.audit.query(limit=5)
+    valid, count, msg = cp.audit.verify_chain()
+    print(msg)           # "Chain valid (N entries)"
+    await cp.stop()
+
+asyncio.run(main())
 ```
 
 ---
@@ -195,7 +205,7 @@ Halyn intercepts any agentic system. The agent framework doesn't matter.
 | **AutoGen** | API calls intercepted automatically |
 | **CrewAI** | API calls intercepted automatically |
 | **Semantic Kernel** | API calls intercepted automatically |
-| **BeeQ** | Native AAP integration |
+| **Any AAP client** | Native AAP integration |
 | **Any MCP agent** | MCP server passthrough |
 | **Any A2A agent** | Network-level interception |
 | **Any OpenAI-compatible API** | Universal proxy compatibility |

{halyn-2.2.3 → halyn-2.2.5}/pyproject.toml

@@ -1,10 +1,9 @@
 [project]
 name = "halyn"
-version = "2.2.3"
+version = "2.2.5"
 description = "Halyn — The governance layer for AI agents. Every action intercepted. Every decision auditable."
 requires-python = ">=3.10"
-license = "BUSL-1.1"
-license-files = ["LICENSE"]
+license = {text = "BUSL-1.1"}
 authors = [{name = "Elmadani SALKA", email = "contact@halyn.dev"}]
 readme = "README.md"
 keywords = [
@@ -46,7 +45,7 @@ where = ["src"]
 halyn = ["py.typed"]
 
 [build-system]
-requires = ["setuptools>=77", "wheel"]
+requires = ["setuptools>=61,<77", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [tool.ruff]

{halyn-2.2.3 → halyn-2.2.5}/src/halyn/__init__.py

@@ -9,7 +9,7 @@ Every action intercepted. Every decision auditable.
 The AI cannot bypass it.
 """
 
-__version__ = "2.2.3"
+__version__ = "2.2.4"
 __author__ = "Elmadani SALKA"
 __license__ = "BUSL-1.1"
 __email__ = "contact@halyn.dev"

{halyn-2.2.3 → halyn-2.2.5}/src/halyn/dashboard.py

@@ -181,6 +181,29 @@ body{background:var(--bg);color:var(--fg);font-family:var(--font);height:100vh;d
 ::-webkit-scrollbar{width:4px}
 ::-webkit-scrollbar-track{background:transparent}
 ::-webkit-scrollbar-thumb{background:var(--border);border-radius:2px}
+
+/* ── MOBILE ─────────────────────────────────────────── */
+@media(max-width:700px){
+  body{height:auto;overflow:auto}
+  .topbar{padding:.5rem .75rem}
+  .version{display:none}
+  #estop-btn{font-size:.65rem;padding:.2rem .5rem}
+  .statstrip{flex-wrap:wrap}
+  .stat{flex:1 1 33%;min-width:0;padding:.5rem .6rem;border-bottom:1px solid var(--border)}
+  .stat .v{font-size:1.1rem}
+  .stat .l{font-size:.6rem}
+  .main{grid-template-columns:1fr;overflow:visible}
+  .col{border-right:none;border-bottom:1px solid var(--border);overflow:visible}
+  .col:last-child{border-bottom:none}
+  .panel{overflow:visible}
+  .panel-body{overflow:visible;max-height:none}
+  .audit-row{grid-template-columns:50px 1fr 45px;font-size:.68rem}
+  .audit-row .hash{display:none}
+  .cmd-input-row{flex-direction:column;gap:.4rem}
+  .cmd-input{width:100%}
+  .cmd-send{width:100%;text-align:center}
+  .cmd-history{min-height:120px;max-height:200px;overflow-y:auto}
+}
 </style>
 </head>
 <body>

halyn-2.2.5/src/halyn/redteam.py

@@ -0,0 +1,186 @@
+# Copyright (c) 2026 Elmadani SALKA
+# Licensed under BUSL-1.1. See LICENSE file.
+
+from __future__ import annotations
+import asyncio, logging, signal, sys, time
+from dataclasses import dataclass, field
+from typing import Any
+
+log = logging.getLogger('halyn.redteam')
+
+PROBES = [
+    {'name': 'probe.noop',     'tool': 'halyn.probe.noop',
+     'args': {'echo': 'ping'},                              'expect': 'any',     'intent': 'redteam.noop'},
+    {'name': 'probe.delete',   'tool': 'halyn.probe.delete_all',
+     'args': {'target': '*'},                               'expect': 'blocked', 'intent': 'redteam.dangerous'},
+    {'name': 'probe.exfil',    'tool': 'halyn.probe.exfil',
+     'args': {'destination': 'http://evil.example.com'},    'expect': 'blocked', 'intent': 'redteam.exfil'},
+    {'name': 'probe.fs_write', 'tool': 'halyn.probe.write_file',
+     'args': {'path': '/etc/passwd', 'content': 'pwned'},  'expect': 'blocked', 'intent': 'redteam.fs'},
+]
+
+
+@dataclass
+class ProbeResult:
+    name: str; ok: bool; expected: bool; status: str; duration_ms: float; error: str = ''
+
+
+@dataclass
+class LoopStats:
+    cycles: int = 0; probes_sent: int = 0; probes_expected: int = 0
+    chain_checks: int = 0; chain_breaks: int = 0; alerts_sent: int = 0
+    started_at: float = field(default_factory=time.time)
+    def uptime_seconds(self): return time.time() - self.started_at
+
+
+async def _get(session, url):
+    import aiohttp
+    async with session.get(url, timeout=aiohttp.ClientTimeout(total=5)) as r:
+        return await r.json()
+
+
+async def _post(session, url, body):
+    import aiohttp
+    async with session.post(url, json=body, timeout=aiohttp.ClientTimeout(total=5)) as r:
+        return await r.json()
+
+
+async def run_probe(session, base_url, probe):
+    t0 = time.perf_counter()
+    try:
+        resp = await _post(session, base_url + '/execute', {
+            'tool': probe['tool'], 'args': probe['args'],
+            'user_id': 'halyn.redteam', 'intent': probe['intent'],
+        })
+        ms = (time.perf_counter() - t0) * 1000
+        result_ok = resp.get('ok', False)
+        status = resp.get('status', 'unknown')
+        expected = (not result_ok) if probe['expect'] == 'blocked' else True
+        return ProbeResult(probe['name'], True, expected, status, ms)
+    except asyncio.TimeoutError:
+        return ProbeResult(probe['name'], False, False, 'timeout',
+                           (time.perf_counter() - t0) * 1000, 'timeout')
+    except Exception as e:
+        return ProbeResult(probe['name'], False, False, 'error',
+                           (time.perf_counter() - t0) * 1000, str(e)[:200])
+
+
+async def check_chain(session, base_url):
+    try:
+        r = await _get(session, base_url + '/audit/verify')
+        return r.get('valid', False), r.get('entries_checked', 0), r.get('message', '')
+    except Exception as e:
+        return False, 0, 'unreachable: ' + str(e)
+
+
+async def send_alert(session, webhook, msg, stats):
+    log.critical('ALERT: %s', msg)
+    stats.alerts_sent += 1
+    if not webhook:
+        return
+    try:
+        import aiohttp
+        text = (':rotating_light: *Halyn Alert*\n' + msg +
+                '\nCycle ' + str(stats.cycles) +
+                ' | Uptime ' + str(int(stats.uptime_seconds())) + 's' +
+                ' | Chain breaks: ' + str(stats.chain_breaks))
+        payload = {'text': text}
+        async with session.post(webhook, json=payload,
+                                timeout=aiohttp.ClientTimeout(total=5)) as r:
+            log.info('alert.webhook status=%d', r.status)
+    except Exception as e:
+        log.error('alert.webhook failed: %s', e)
+
+
+async def redteam_loop(base_url, interval, webhook, verbose):
+    import aiohttp
+    stats = LoopStats()
+    prev_tip = None
+    print('')
+    print('  Halyn Red Team')
+    print('  Target:   ' + base_url)
+    print('  Interval: ' + str(interval) + 's | Probes: ' + str(len(PROBES))
+          + ' | Webhook: ' + ('yes' if webhook else 'no'))
+    print('  Ctrl+C to stop')
+    print('')
+    print('   CYC      TIME    PROBES   CHAIN                      MS')
+    print('  ' + '-' * 58)
+    async with aiohttp.ClientSession() as session:
+        while True:
+            t0 = time.time()
+            stats.cycles += 1
+            try:
+                h = await _get(session, base_url + '/health')
+            except Exception as e:
+                await send_alert(session, webhook, 'Halyn unreachable: ' + str(e), stats)
+                await asyncio.sleep(interval)
+                continue
+            if not h.get('running', False):
+                await send_alert(session, webhook, 'running=false', stats)
+            results = []
+            for probe in PROBES:
+                r = await run_probe(session, base_url, probe)
+                results.append(r)
+                stats.probes_sent += 1
+                if r.expected:
+                    stats.probes_expected += 1
+                else:
+                    await send_alert(session, webhook,
+                        'Probe ' + r.name + ' unexpected: status=' + r.status
+                        + ' expected=' + probe['expect'] + ' error=' + r.error,
+                        stats)
+                if verbose:
+                    log.info('  %s %s -> %s (%.0fms)',
+                             'OK' if r.expected else 'FAIL',
+                             r.name, r.status, r.duration_ms)
+            valid, count, msg = await check_chain(session, base_url)
+            stats.chain_checks += 1
+            if not valid:
+                stats.chain_breaks += 1
+                await send_alert(session, webhook,
+                    'CHAIN BROKEN cycle=' + str(stats.cycles)
+                    + ': ' + msg + ' entries=' + str(count),
+                    stats)
+            try:
+                ar = await _get(session, base_url + '/audit?limit=1')
+                tip = ar.get('chain_tip', '')
+                if prev_tip and tip == 'GENESIS' and stats.cycles > 1:
+                    await send_alert(session, webhook,
+                        'Chain tip reset to GENESIS at cycle ' + str(stats.cycles)
+                        + ' - log may have been wiped', stats)
+                prev_tip = tip
+            except Exception:
+                pass
+            n_ok = sum(1 for r in results if r.expected)
+            chain_str = ('OK (' + str(count) + ' entries)'
+                         if valid else 'BROKEN (' + str(count) + ' entries)')
+            ms = (time.time() - t0) * 1000
+            print('  ' + str(stats.cycles).rjust(4)
+                  + '  ' + time.strftime('%H:%M:%S')
+                  + '  ' + str(n_ok) + '/' + str(len(results)) + ' probes'
+                  + '  ' + chain_str.ljust(26)
+                  + '  ' + str(int(ms)).rjust(5) + 'ms')
+            await asyncio.sleep(max(0.0, interval - (time.time() - t0)))
+
+
+def run(url='http://localhost:7420', interval=30.0, webhook=None, verbose=False):
+    try:
+        import aiohttp  # noqa
+    except ImportError:
+        print('Error: aiohttp required -- pip install halyn')
+        sys.exit(1)
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s %(name)s %(levelname)s %(message)s',
+        datefmt='%H:%M:%S',
+    )
+    loop = asyncio.new_event_loop()
+    def _stop(sig, frame):
+        print('\n  Stopping...')
+        loop.stop()
+    signal.signal(signal.SIGINT, _stop)
+    signal.signal(signal.SIGTERM, _stop)
+    try:
+        loop.run_until_complete(redteam_loop(url, interval, webhook, verbose))
+    finally:
+        loop.close()

{halyn-2.2.3 → halyn-2.2.5}/src/halyn/security/proxy.py

@@ -140,8 +140,6 @@ class HalynProxy:
         """
         Apply shield rules. Returns (blocked, reason).
         
-        Note: PHY §2 (physical world irreversibility rule) belongs to BeeQ,
-        not Halyn. Halyn intercepts and audits. BeeQ decides based on PHY laws.
         Halyn shields are generic destructive pattern detection.
         """
         blocked_patterns = ["delete all", "rm -rf", "format disk", "drop database"]

{halyn-2.2.3 → halyn-2.2.5/src/halyn.egg-info}/PKG-INFO

@@ -1,9 +1,9 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: halyn
-Version: 2.2.3
+Version: 2.2.5
 Summary: Halyn — The governance layer for AI agents. Every action intercepted. Every decision auditable.
 Author-email: Elmadani SALKA <contact@halyn.dev>
-License-Expression: BUSL-1.1
+License: BUSL-1.1
 Project-URL: Homepage, https://halyn.dev
 Project-URL: Repository, https://github.com/halyndev/halyn
 Project-URL: Issues, https://github.com/halyndev/halyn/issues
@@ -29,7 +29,6 @@ Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-asyncio; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
-Dynamic: license-file
 
 <div align="center">
 
@@ -83,7 +82,7 @@ Every action produces a cryptographic proof stored locally. Not in the cloud. No
 **Option 1 — pip** (Python 3.10+):
 
 ```bash
-pip install halyn==2.1.3
+pip install halyn==2.2.4
 halyn serve
 ```
 
@@ -101,23 +100,33 @@ The curl script verifies your Python version and asks permission before doing an
 ## Quick Start
 
 ```python
-from halyn import ControlPlane
-
-# Start the governance layer
-gov = ControlPlane()
-gov.serve()  # dashboard at localhost:7420
-
-# Register an agent
-agent = gov.register_agent(
-    name="claude-cowork",
-    provider="anthropic",
-    autonomy_level=2,  # executor — reversible actions only
-)
-
-# Every agent action is intercepted and recorded
-result = agent.act("read_file", "/docs/contract.pdf")
-print(result.proof)    # sha256:a3f2e1...
-print(result.allowed)  # True
+from halyn.control_plane import ControlPlane
+from halyn.config import HalynConfig
+
+# Start the control plane (or run `halyn serve` from CLI)
+cp = ControlPlane(HalynConfig())
+
+# Every node action passes through the pipeline:
+# Consent → Shield → Execute → Audit
+import asyncio
+async def main():
+    await cp.start()
+    result = await cp.execute(
+        "myserver.observe",
+        {"channels": "cpu,ram"},
+        user_id="me",
+        intent_text="Check server load",
+    )
+    print(result.ok)     # True
+    print(result.data)   # {"cpu": 42.1, "ram": 67.3}
+
+    # Audit chain — cryptographic proof of every action
+    entries = cp.audit.query(limit=5)
+    valid, count, msg = cp.audit.verify_chain()
+    print(msg)           # "Chain valid (N entries)"
+    await cp.stop()
+
+asyncio.run(main())
 ```
 
 ---
@@ -228,7 +237,7 @@ Halyn intercepts any agentic system. The agent framework doesn't matter.
 | **AutoGen** | API calls intercepted automatically |
 | **CrewAI** | API calls intercepted automatically |
 | **Semantic Kernel** | API calls intercepted automatically |
-| **BeeQ** | Native AAP integration |
+| **Any AAP client** | Native AAP integration |
 | **Any MCP agent** | MCP server passthrough |
 | **Any A2A agent** | Network-level interception |
 | **Any OpenAI-compatible API** | Universal proxy compatibility |

halyn-2.2.3/src/halyn/redteam.py

@@ -1,153 +0,0 @@
-# Copyright (c) 2026 Elmadani SALKA
-# Licensed under BUSL-1.1. See LICENSE file.
-# Commercial use requires a license - contact@halyn.dev
-
-from __future__ import annotations
-import asyncio, logging, signal, sys, time
-from dataclasses import dataclass, field
-from typing import Any
-
-log = logging.getLogger("halyn.redteam")
-
-PROBES = [
-    {"name": "probe.noop",     "tool": "halyn.probe.noop",
-     "args": {"echo": "ping"},                             "expect": "any",     "intent": "redteam.noop"},
-    {"name": "probe.delete",   "tool": "halyn.probe.delete_all",
-     "args": {"target": "*"},                              "expect": "blocked", "intent": "redteam.dangerous"},
-    {"name": "probe.exfil",    "tool": "halyn.probe.exfil",
-     "args": {"destination": "http://evil.example.com"},   "expect": "blocked", "intent": "redteam.exfil"},
-    {"name": "probe.fs_write", "tool": "halyn.probe.write_file",
-     "args": {"path": "/etc/passwd", "content": "pwned"}, "expect": "blocked", "intent": "redteam.fs"},
-]
-
-@dataclass
-class ProbeResult:
-    name: str; ok: bool; expected: bool; status: str; duration_ms: float; error: str = ""
-
-@dataclass
-class LoopStats:
-    cycles: int = 0; probes_sent: int = 0; probes_expected: int = 0
-    chain_checks: int = 0; chain_breaks: int = 0; alerts_sent: int = 0
-    started_at: float = field(default_factory=time.time)
-    def uptime_seconds(self): return time.time() - self.started_at
-
-async def _get(session, url):
-    import aiohttp
-    async with session.get(url, timeout=aiohttp.ClientTimeout(total=5)) as r:
-        return await r.json()
-
-async def _post(session, url, body):
-    import aiohttp
-    async with session.post(url, json=body, timeout=aiohttp.ClientTimeout(total=5)) as r:
-        return await r.json()
-
-async def run_probe(session, base_url, probe):
-    t0 = time.perf_counter()
-    try:
-        resp = await _post(session, f"{base_url}/execute", {
-            "tool": probe["tool"], "args": probe["args"],
-            "user_id": "halyn.redteam", "intent": probe["intent"],
-        })
-        ms = (time.perf_counter() - t0) * 1000
-        result_ok = resp.get("ok", False)
-        status = resp.get("status", "unknown")
-        expected = (not result_ok) if probe["expect"] == "blocked" else True
-        return ProbeResult(probe["name"], True, expected, status, ms)
-    except asyncio.TimeoutError:
-        return ProbeResult(probe["name"], False, False, "timeout", (time.perf_counter()-t0)*1000, "timeout")
-    except Exception as e:
-        return ProbeResult(probe["name"], False, False, "error", (time.perf_counter()-t0)*1000, str(e)[:200])
-
-async def check_chain(session, base_url):
-    try:
-        r = await _get(session, f"{base_url}/audit/verify")
-        return r.get("valid", False), r.get("entries_checked", 0), r.get("message", "")
-    except Exception as e:
-        return False, 0, f"unreachable: {e}"
-
-async def send_alert(session, webhook, msg, stats):
-    log.critical("ALERT: %s", msg)
-    stats.alerts_sent += 1
-    if not webhook:
-        return
-    try:
-        import aiohttp
-        payload = {"text": f":rotating_light: *Halyn Alert*
-{msg}
-Cycle {stats.cycles} | Uptime {stats.uptime_seconds():.0f}s | Chain breaks: {stats.chain_breaks}"}
-        async with session.post(webhook, json=payload, timeout=aiohttp.ClientTimeout(total=5)) as r:
-            log.info("alert.webhook status=%d", r.status)
-    except Exception as e:
-        log.error("alert.webhook failed: %s", e)
-
-async def redteam_loop(base_url, interval, webhook, verbose):
-    import aiohttp
-    stats = LoopStats()
-    prev_tip = None
-    print(f"
-  Halyn Red Team")
-    print(f"  Target:   {base_url}")
-    print(f"  Interval: {interval}s | Probes: {len(PROBES)} | Webhook: {"yes" if webhook else "no"}")
-    print(f"  Ctrl+C to stop
-")
-    print(f"  CYC       TIME    PROBES   CHAIN                      MS")
-    print(f"  " + "-"*60)
-    async with aiohttp.ClientSession() as session:
-        while True:
-            t0 = time.time()
-            stats.cycles += 1
-            try:
-                h = await _get(session, f"{base_url}/health")
-            except Exception as e:
-                await send_alert(session, webhook, f"Halyn unreachable: {e}", stats)
-                await asyncio.sleep(interval)
-                continue
-            if not h.get("running", False):
-                await send_alert(session, webhook, "running=false", stats)
-            results = []
-            for probe in PROBES:
-                r = await run_probe(session, base_url, probe)
-                results.append(r)
-                stats.probes_sent += 1
-                if r.expected:
-                    stats.probes_expected += 1
-                else:
-                    await send_alert(session, webhook,
-                        f"Probe {r.name!r} unexpected: status={r.status} expected={probe["expect"]} error={r.error}", stats)
-                if verbose:
-                    log.info("  %s %s -> %s (%.0fms)", "OK" if r.expected else "FAIL", r.name, r.status, r.duration_ms)
-            valid, count, msg = await check_chain(session, base_url)
-            stats.chain_checks += 1
-            if not valid:
-                stats.chain_breaks += 1
-                await send_alert(session, webhook, f"CHAIN BROKEN cycle={stats.cycles}: {msg} entries={count}", stats)
-            try:
-                ar = await _get(session, f"{base_url}/audit?limit=1")
-                tip = ar.get("chain_tip", "")
-                if prev_tip and tip == "GENESIS" and stats.cycles > 1:
-                    await send_alert(session, webhook, f"Chain tip reset to GENESIS at cycle {stats.cycles} - log may have been wiped", stats)
-                prev_tip = tip
-            except Exception:
-                pass
-            n_ok = sum(1 for r in results if r.expected)
-            chain_str = f"OK ({count} entries)" if valid else f"BROKEN ({count} entries)"
-            ms = (time.time() - t0) * 1000
-            print(f"  {stats.cycles:>4}  {time.strftime("%H:%M:%S")}  {n_ok}/{len(results)} probes  {chain_str:<26}  {ms:>5.0f}ms")
-            await asyncio.sleep(max(0.0, interval - (time.time() - t0)))
-
-def run(url="http://localhost:7420", interval=30.0, webhook=None, verbose=False):
-    try:
-        import aiohttp
-    except ImportError:
-        print("Error: aiohttp required -- pip install halyn"); sys.exit(1)
-    logging.basicConfig(level=logging.INFO, format="%(asctime)s %(name)s %(levelname)s %(message)s", datefmt="%H:%M:%S")
-    loop = asyncio.new_event_loop()
-    def _stop(sig, frame):
-        print("
-  Stopping..."); loop.stop()
-    signal.signal(signal.SIGINT, _stop)
-    signal.signal(signal.SIGTERM, _stop)
-    try:
-        loop.run_until_complete(redteam_loop(url, interval, webhook, verbose))
-    finally:
-        loop.close()