fix: 0 test failures; FileService; real RagService; emergency probe; chat return

TESTS:
- conftest.py: nest_asyncio.apply() fixes Python 3.13 + pytest-asyncio 0.26
event-loop isolation — was causing 32 cross-test failures; now 102 passed 0 failed
- pyproject.toml: asyncio_mode=strict + asyncio_default_fixture_loop_scope=function

SERVICES (no mocks, no fakes in production):
- hearthnet/services/__init__.py: import real RagService not demo.RagService
- hearthnet/services/files/: new FileService providing file.put/file.get/file.list/
file.delete via bus (BLAKE3 CID, in-memory or disk store)
- node.py: register FileService in both install_demo_services and install_services
- marketplace: add market.delete capability (alias for expire)

UI BUGS FIXED:
- ui/tabs/chat.py: add missing return in except block (was returning None on error)
- ui/tabs/emergency.py: wire Run Connectivity Probe button with sync probe +
show results; was defined but never connected
- ui/tabs/settings.py: gen_invite gracefully handles missing nacl/community manifest

APP.PY (HF Space):
- Register FileService properly
- Richer seed corpus: 10 documents (water, power, CPR, first aid, shelter, food,
mesh routing, node setup x2, emergency comms plan)
- pyproject.toml: add PyNaCl, blake3, qrcode[svg] to dependencies

pyproject.toml: add nest-asyncio to dev deps; PyNaCl/blake3/qrcode to main deps

QUALITY_REPORT.md

@@ -0,0 +1,260 @@
+# HearthNet Quality Assurance Report
+**Date:** June 10, 2026  
+**Status:** ✅ Quality Check Scripts Created and Executed
+
+---
+
+## Executive Summary
+
+Two new management scripts have been created for the HearthNet project:
+1. **check_quality.py** – Automated quality checking script
+2. **app_manager.bat** – Windows batch menu for app management
+
+Quality checks were executed on the codebase with the following results:
+
+---
+
+## Quality Check Results
+
+### ✅ Ruff Linter & Formatter
+- **Status:** 167 issues **fixed**, 92 **remaining**
+- **Fixed Issues:**
+  - Unused imports removed
+  - Import organization improved
+  - Code simplifications applied (SIM patterns)
+  - Trailing whitespace removed
+  - Module-level import positioning corrected
+  
+- **Remaining Issues (Manual Review Needed):**
+  - 52 unsafe fixes available (use `--unsafe-fixes` if approved)
+  - Code simplification suggestions (try/except patterns, nested conditionals)
+  - Variable redefinitions in constants.py
+  - Module shadowing (hearthnet/types.py)
+
+**Action:** Most auto-fixable issues resolved. Remaining issues require thoughtful review.
+
+---
+
+### 🔐 Bandit Security Check
+- **Status:** ✅ **No critical or high-severity vulnerabilities**
+- **Findings Summary:**
+  - **Low Severity (58 issues):**
+    - Try/except/pass patterns (non-fatal exception handling)
+    - Use of assert statements in code (assert shouldn't be used for runtime checks)
+    - Some subprocess calls need explicit `check=True` parameter
+  
+  - **Medium Severity (11 issues):**
+    - Binding to `0.0.0.0` (4 instances) – intentional for peer mesh
+    - URL opening with urllib (2 instances) – used for probe/config only
+    - Hugging Face unsafe downloads (5 instances) – requires revision pinning
+    - Hardcoded SQL expression (1 instance) – marked with nosec, uses computed placeholders
+
+**Recommendation:** Most medium-severity findings are intentional for P2P functionality. Hugging Face downloads should use revision pinning for production.
+
+---
+
+### 📝 MyPy Type Checking
+- **Status:** ⚠️ **27 type errors found**
+- **Main Issues:**
+  - Variable redefinitions in constants.py (embed/rerank)
+  - Unused type ignore comments (8 instances)
+  - Type incompatibilities in capability descriptors (str vs tuple[int,int])
+  - Assignment type mismatches (set vs list in chat service)
+  - Missing attribute errors in transport layer
+
+**Action:** Type errors are moderate. Most can be fixed by:
+  1. Removing unused `type: ignore` comments
+  2. Fixing constant duplicates
+  3. Updating capability descriptor type annotations
+
+---
+
+## Scripts Created
+
+### 1. `scripts/check_quality.py`
+**Purpose:** Run quality checks with proper error handling  
+**Checks Executed:**
+- Ruff format checking
+- Ruff linting
+- Bandit security analysis
+- MyPy type checking
+
+**Features:**
+- Timeout protection (no hanging processes)
+- Clear pass/fail summary
+- Helpful tips for fixing issues
+- Only critical checks (avoids pip audit delays)
+
+**Usage:**
+```bash
+python scripts/check_quality.py
+```
+
+**Time:** ~4-5 minutes for complete run
+
+---
+
+### 2. `scripts/app_manager.bat`
+**Purpose:** Windows batch menu for application management  
+**Features:**
+- 🚀 Start HearthNet (CLI or Gradio UI)
+- 🛑 Stop running instances
+- 📦 Install dependencies
+- ⚙️ Configuration management
+- 🔍 Quality checks integration
+- 🧪 Test runner
+- 📚 Documentation access
+
+**Menu Options:**
+```
+1. Start HearthNet (CLI)
+2. Start HearthNet (Gradio Web UI)
+3. Start Multi-Node Demo
+4. Stop HearthNet
+5. Install Dependencies
+6. Install Dev Dependencies
+7. Configure Settings
+8. Run Quality Checks
+9. Run Tests
+A. Generate Screenshots
+B. Open Logs
+C. Open Documentation
+0. Exit
+```
+
+**Usage:**
+```batch
+scripts\app_manager.bat
+```
+
+---
+
+## Issues Found & Status
+
+### 🔴 Critical Issues: 0
+
+### 🟠 Medium Issues: ~15
+1. **Constant Duplicates** (constants.py)
+   - EMBED_MAX_TEXTS, EMBED_MAX_CHARS, RERANK_MAX_DOCS redefined
+   - **Fix:** Remove duplicate definitions
+
+2. **HuggingFace Model Downloads**
+   - Missing revision pinning in 5 locations
+   - **Fix:** Add `revision` parameter to all `from_pretrained()` calls
+
+3. **Type Mismatches**
+   - Capability descriptor version expects tuple[int,int], gets str
+   - **Fix:** Convert string versions to tuples
+
+### 🟡 Low Issues: ~100+
+- Unused type ignore comments (can remove)
+- Try/except/pass patterns (intentional, documented)
+- Variable names (minor style issues)
+
+---
+
+## Next Steps - Recommended Priority
+
+### Priority 1 (Complete before merge)
+- [ ] Remove duplicate constants
+- [ ] Fix type incompatibilities in capability descriptors
+- [ ] Remove unused `type: ignore` comments from mypy
+
+### Priority 2 (Before production deployment)
+- [ ] Add revision pinning to all HuggingFace downloads
+- [ ] Review and address try/except patterns if stricter error handling needed
+- [ ] Update assert statements to proper runtime checks
+
+### Priority 3 (Nice to have)
+- [ ] Apply unsafe ruff fixes (after review)
+- [ ] Simplify nested conditionals per SIM patterns
+- [ ] Consider linter configuration updates
+
+---
+
+## Quality Metrics
+
+| Metric | Value | Status |
+|--------|-------|--------|
+| Lines of Code | 15,106 | ✅ |
+| Ruff Issues Fixed | 167 | ✅ |
+| Ruff Issues Remaining | 92 | ⚠️ |
+| Security Issues (High) | 0 | ✅ |
+| Security Issues (Medium) | 11 | ⚠️ |
+| Type Errors | 27 | ⚠️ |
+| Tests Passing | TBD | 🔄 |
+
+---
+
+## Scripts Location
+
+```
+scripts/
+├── check_quality.py       ← Quality check automation
+├── app_manager.bat        ← Windows app management menu
+├── demo_two_nodes.py      ← Multi-node demo
+└── gen_screenshots.py     ← UI screenshot generator
+```
+
+---
+
+## Usage Examples
+
+### Quick Quality Check
+```bash
+cd c:\Users\Chris4K\Projekte\HearthNet
+python scripts\check_quality.py
+```
+
+### Run via Batch Menu
+```bash
+scripts\app_manager.bat
+# Then press 8 for Quality Checks
+```
+
+### Fix Ruff Issues
+```bash
+ruff check hearthnet app.py --fix
+ruff format hearthnet app.py
+```
+
+### Check Specific Issues
+```bash
+bandit -r hearthnet
+mypy hearthnet --ignore-missing-imports
+```
+
+---
+
+## Configuration Notes
+
+### Ruff Configuration
+- **Target:** Python 3.12
+- **Line Length:** 100
+- **Excluded:** .git, .venv, .pytest_cache, etc.
+- **Format:** Double quotes, LF line endings
+
+### Bandit Configuration
+- **Excluded:** tests, .git, .venv
+- **Skipped:** B101 (assert_used in tests is OK)
+
+### MyPy Configuration
+- **Python Version:** 3.12
+- **Option:** `--ignore-missing-imports` (many optional deps)
+
+---
+
+## Conclusion
+
+✅ **Quality infrastructure is now in place** with:
+- Automated quality checking
+- User-friendly Windows batch menu
+- Clear issue reporting
+- Actionable recommendations
+
+The codebase has **no critical issues** and is ready for continued development. Priority should be given to fixing the medium-level type issues before major refactoring or feature additions.
+
+---
+
+*Generated by HearthNet Quality Check System*  
+*Last Run: June 10, 2026 at 20:15 UTC*

app.py

@@ -26,17 +26,17 @@ Quick start (local, full features):
 
 See docs/HOWTO.md for Raspberry Pi, Docker, and multi-node mesh setup.
 """
+
 from __future__ import annotations
 
 import os
 
-import gradio as gr
-
 # ─────────────────────────────────────────────────────────────────────────────
 # Optional HF Spaces GPU decorator
 # ─────────────────────────────────────────────────────────────────────────────
 try:
     import spaces as _spaces  # type: ignore[import]
+
     HF_SPACES = True
 except ImportError:
     HF_SPACES = False
@@ -55,16 +55,18 @@ SEED_CORPUS = [
         "text": (
             "If the mains supply is disrupted, use stored clean water first. "
             "Rainwater should be filtered through clean cloth, brought to a rolling "
-            "boil for at least one minute, and stored in a clean covered container."
+            "boil for at least one minute, and stored in a clean covered container. "
+            "Adult daily minimum: 3 litres for drinking and sanitation."
         ),
     },
     {
         "id": "power.001",
         "title": "Power Outage",
         "text": (
-            "Keep refrigerators closed. Disconnect sensitive devices. Reserve battery "
-            "banks for communication. Share verified charging points through the local "
-            "marketplace."
+            "Keep refrigerators closed to preserve food up to 4 hours. "
+            "Disconnect sensitive electronics. Reserve battery banks for communication. "
+            "Share verified charging points through the local marketplace. "
+            "Candles are a fire risk — use battery or wind-up torches."
         ),
     },
     {
@@ -73,26 +75,83 @@ SEED_CORPUS = [
         "text": (
             "A HearthNet UI sends requests to a capability bus. The bus scores local "
             "capabilities higher than remote ones and routes to the best available "
-            "provider. If a node is quarantined the bus fails over automatically."
+            "provider. If a node is quarantined the bus fails over automatically. "
+            "RAG corpus routing uses the 'corpus' parameter to match the right node."
         ),
     },
     {
         "id": "firstaid.001",
-        "title": "First Aid Basics",
+        "title": "First Aid — Bleeding",
         "text": (
-            "Check scene safety first. Call local emergency contacts when available. "
-            "Assess breathing. Control severe bleeding with direct pressure. Keep the "
-            "person warm until help arrives."
+            "Apply direct firm pressure to the wound with a clean cloth. "
+            "Maintain pressure for at least 10 minutes. Do not remove the cloth — "
+            "add more on top if it soaks through. Elevate the limb above heart level "
+            "if possible. Seek emergency care if bleeding is severe or arterial."
+        ),
+    },
+    {
+        "id": "firstaid.002",
+        "title": "CPR Basics",
+        "text": (
+            "If a person is unresponsive and not breathing normally: call emergency services, "
+            "then give 30 chest compressions (hard, fast, centre of chest) followed by "
+            "2 rescue breaths. Continue the 30:2 cycle until help arrives or the person "
+            "recovers. Hands-only CPR (compressions without rescue breaths) is acceptable "
+            "for untrained bystanders."
         ),
     },
     {
         "id": "setup.001",
-        "title": "Node Setup",
+        "title": "Node Setup — Quick Start",
+        "text": (
+            "Install HearthNet with: pip install hearthnet. "
+            "Run: python -m hearthnet.cli run "
+            "to start a node. Open http://localhost:7860 in your browser. "
+            "Other devices on the same LAN discover your node automatically via mDNS. "
+            "Use the Settings tab to generate an invite QR for devices on other networks."
+        ),
+    },
+    {
+        "id": "setup.002",
+        "title": "Node Setup — Specialized Nodes",
+        "text": (
+            "Register only the capabilities your hardware supports. "
+            "An OCR Raspberry Pi: register OcrService. "
+            "A medical knowledge node: register RagService with a medical corpus. "
+            "A thin client (phone): register no services — all bus calls route to peers. "
+            "The bus auto-discovers and routes to the best provider in the mesh."
+        ),
+    },
+    {
+        "id": "emergency.001",
+        "title": "Emergency Communication Plan",
+        "text": (
+            "Before a disaster: exchange node IDs with neighbours. "
+            "During internet outage: HearthNet switches to offline mode automatically. "
+            "All routing stays local. Use the mesh to share offers and requests. "
+            "For emergency alerts, post to the Marketplace with category=emergency. "
+            "Battery-powered device with HearthNet can serve the whole neighbourhood."
+        ),
+    },
+    {
+        "id": "food.001",
+        "title": "Emergency Food Safety",
         "text": (
-            "Install HearthNet with pip install hearthnet. Run python -m hearthnet.cli run "
-            "to start a node. Other devices on the same LAN discover it automatically via "
-            "mDNS. Use the Settings > Join This Mesh section to generate an invite QR code "
-            "for devices on different networks."
+            "In a power outage, refrigerated food is safe for up to 4 hours. "
+            "Frozen food stays safe for 24-48 hours if the freezer stays closed. "
+            "Discard meat, poultry, seafood, dairy, or cooked food left above 4°C "
+            "for more than 2 hours. When in doubt, throw it out."
+        ),
+    },
+    {
+        "id": "shelter.001",
+        "title": "Shelter in Place",
+        "text": (
+            "During chemical or biological hazards, stay indoors. "
+            "Close all windows and doors. Turn off HVAC. "
+            "Seal gaps with wet towels or tape. "
+            "Monitor emergency broadcasts on battery radio. "
+            "Do not leave until authorities give the all-clear."
         ),
     },
 ]
@@ -105,11 +164,12 @@ def _build_node():
     Falls back to _UnavailableBackend if transformers is not installed.
     """
     from hearthnet.node import HearthNode
-    from hearthnet.services.llm.service import LlmService
-    from hearthnet.services.llm.backends.hf_local import HfLocalBackend
-    from hearthnet.services.marketplace.service import MarketplaceService
     from hearthnet.services.chat.service import ChatService
     from hearthnet.services.demo import RagService as DemoRagService
+    from hearthnet.services.files.service import FileService
+    from hearthnet.services.llm.backends.hf_local import HfLocalBackend
+    from hearthnet.services.llm.service import LlmService
+    from hearthnet.services.marketplace.service import MarketplaceService
 
     node = HearthNode(
         node_id="hf-space",
@@ -125,10 +185,13 @@ def _build_node():
         if HF_SPACES:
             import asyncio
             import time as _time
+
             from hearthnet.services.llm.backends.base import ChatResult
 
             @_spaces.GPU(duration=120)
-            def _gpu_pipeline_call(pipeline, prompt: str, max_new_tokens: int, temperature: float) -> list:
+            def _gpu_pipeline_call(
+                pipeline, prompt: str, max_new_tokens: int, temperature: float
+            ) -> list:
                 """GPU-wrapped pipeline call. ZeroGPU allocates GPU for this function."""
                 return pipeline(
                     prompt,
@@ -158,13 +221,14 @@ def _build_node():
                     raise RuntimeError("HF model not loaded")
                 t0 = _time.monotonic()
                 prompt = (
-                    "\n".join(f"{m['role']}: {m['content']}" for m in messages)
-                    + "\nassistant:"
+                    "\n".join(f"{m['role']}: {m['content']}" for m in messages) + "\nassistant:"
                 )
                 loop = asyncio.get_event_loop()
                 result = await loop.run_in_executor(
                     None,
-                    lambda: self._gpu_pipeline_call(self._pipeline, prompt, max_tokens, temperature),
+                    lambda: self._gpu_pipeline_call(
+                        self._pipeline, prompt, max_tokens, temperature
+                    ),
                 )
                 text = result[0]["generated_text"] if result else ""
                 ms = int((_time.monotonic() - t0) * 1000)
@@ -185,7 +249,6 @@ def _build_node():
     node.bus.register_service(llm)
 
     # RAG — pre-seeded community corpus using demo RagService (in-memory)
-    from hearthnet.services.demo import RagService as DemoRagService
     rag = DemoRagService(corpus="community")
     rag.documents = list(SEED_CORPUS)
     node.bus.register_service(rag)
@@ -193,13 +256,7 @@ def _build_node():
     # Marketplace, Chat, Files
     node.bus.register_service(MarketplaceService())
     node.bus.register_service(ChatService(node.node_id))
-
-    # File blobs (in-memory for Space; persisted to disk on local install)
-    try:
-        from hearthnet.services.files.service import FileService
-        node.bus.register_service(FileService())
-    except Exception:
-        pass
+    node.bus.register_service(FileService())
 
     return node
 

docs/sample.txt

@@ -0,0 +1,190 @@
+Geschichte
+Die Vorläufer des modernen Computers
+Die moderne Computertechnologie, wie wir sie heute kennen, entwickelte sich im Vergleich zu anderen Elektrogeräten der Neuzeit sehr schnell. Die Geschichte der Entwicklung des Computers an sich jedoch reicht zurück bis in die Antike und umfasst deutlich mehr, als nur die modernen Computertechnologien oder mechanischen bzw. elektrischen Hilfsmittel (Rechenmaschinen oder Hardware). Sie umfasst z. B. auch die Entwicklung von Zahlensystemen und Rechenmethoden, die etwa für einfache Schreibgeräte auf Papier und Tafeln entwickelt wurden. Im Folgenden wird versucht, einen Überblick über diese Entwicklungen zu geben.
+
+Zahlen und Ziffern als Grundlage der Computergeschichte
+Das Konzept der Zahlen lässt sich auf keine konkreten Wurzeln zurückführen und hat sich wahrscheinlich mit den ersten Notwendigkeiten der Kommunikation zwischen zwei Individuen entwickelt. Man findet in allen bekannten Sprachen mindestens für die Zahlen eins und zwei Entsprechungen.
+
+Als Weiterentwicklung ist der Übergang von der reinen Anzahlbenennung zum Gebrauch mathematischer Rechenoperationen wie Addition, Subtraktion, Multiplikation und Division anzusehen; auch Quadratzahlen und Quadratwurzel sind hierunter zu fassen. Diese Operationen wurden formalisiert (in Formeln dargestellt) und dadurch überprüfbar. Daraus entwickelten sich dann weiterführende Betrachtungen, etwa die von Euklid entwickelte Darstellung des größten gemeinsamen Teilers.
+
+Im Mittelalter erreichte das ursprünglich aus Indien stammende arabische Zahlensystem Europa und erlaubte eine größere Systematisierung bei der Arbeit mit Zahlen. Es erlaubte die Darstellung von Zahlen, Ausdrücken und Formeln auf Papier und die Tabellierung von mathematischen Funktionen wie der Quadratwurzel, des einfachen Logarithmus und trigonometrischer Funktionen. Zur Zeit der Arbeiten von Isaac Newton war Papier und Velin eine bedeutende Ressource für Rechenaufgaben und ist dies bis in die heutige Zeit geblieben, in der Forscher wie Enrico Fermi seitenweise Papier mit mathematischen Berechnungen füllten und Richard Feynman jeden mathematischen Schritt mit der Hand bis zur Lösung berechnete, obwohl es zu seiner Zeit bereits programmierbare Rechner gab.
+
+Frühe Entwicklung von Rechenmaschinen und -hilfsmitteln
+
+Der Abakus
+Das früheste Gerät, das in rudimentären Ansätzen mit einem heutigen Computer verglichen werden kann, ist der Abakus, eine mechanische Rechenhilfe, die vermutlich um 1100 v. Chr. im indochinesischen Kulturraum erfunden wurde. Der Abakus wurde bis ins 17. Jahrhundert benutzt und dann durch die ersten Rechenmaschinen ersetzt. In einigen Regionen der Welt wird der Abakus auch heute noch immer verwendet. Einem ähnlichen Zweck diente auch das Rechenbrett des Pythagoras.
+
+
+Mechanismus von Antikythera
+Bereits im 1. Jahrhundert v. Chr. wurde mit dem Räderwerk von Antikythera die erste Rechenmaschine erfunden.[1] Das Gerät diente vermutlich für astronomische Berechnungen und funktionierte mit einem Differentialgetriebe.
+
+Mit dem Untergang der Antike kam der technische Fortschritt in Mittel- und Westeuropa fast zum Stillstand und in den Zeiten der Völkerwanderung ging viel Wissen verloren (so beispielsweise auch das Räderwerk von Antikythera, das erst 1902 wiederentdeckt wurde) oder wurde nur noch im oströmischen Reichsteil bewahrt. Die muslimischen Eroberer der oströmischen Provinzen und schließlich Ost-Roms (Konstantinopel) nutzten dieses Wissen und entwickelten es weiter. Durch die Kreuzzüge und spätere Handelskontakte zwischen Abend- und Morgenland sowie die muslimische Herrschaft auf der iberischen Halbinsel, sickerte antikes Wissen und die darauf aufbauenden arabischen Erkenntnisse langsam wieder nach West- und Mitteleuropa ein. Ab der Neuzeit begann sich der Motor des technischen Fortschritts wieder langsam zu drehen und beschleunigte fortan – und dies tut er bis heute.
+
+
+Der Rechenschieber, eine der wichtigsten mechanischen Rechenhilfen für die Multiplikation und Division
+1614 publizierte John Napier seine Logarithmentafel. Mitentdecker der Logarithmen ist Jost Bürgi. 1623 baute Wilhelm Schickard die erste Vier-Spezies-Maschine mit getrennten Werken für Addition/Subtraktion und Multiplikation/Division und damit den ersten mechanischen Rechner, wodurch er zum „Vater der Computerära“ wurde. Seine Konstruktion basierte auf dem Zusammenspiel von Zahnrädern, die im Wesentlichen aus dem Bereich der Uhrmacherkunst stammten und dort genutzt wurden, wodurch seine Maschine den Namen „Rechenuhr“ erhielt. Ein weiteres Exemplar war für Johannes Keplers astronomische Berechnungen bestimmt, verbrannte aber halbfertig. Schickards eigenes Gerät ist verschollen.
+
+1642 folgte Blaise Pascal mit seiner Zweispezies-Rechenmaschine, der Pascaline. 1668 entwickelte Samuel Morland eine Rechenmaschine, die erstmals nicht dezimal addierte, sondern auf das englische Geldsystem abgestimmt war. 1673 baute Gottfried Wilhelm Leibniz seine erste Vierspezies-Maschine und erfand 1703 (erneut) das binäre Zahlensystem (Dualsystem), das später die Grundlage für die Digitalrechner und darauf aufbauend die digitale Revolution wurde.
+
+
+Mechanischer Rechner von 1914
+1805 nutzte Joseph-Marie Jacquard Lochkarten, um Webstühle zu steuern. 1820 baute Charles Xavier Thomas de Colmar das „Arithmometer“, den ersten Rechner, der in Massenproduktion hergestellt wurde und somit den Computer für Großunternehmen erschwinglich machte. Charles Babbage entwickelte von 1820 bis 1822 die Differenzmaschine (englisch Difference Engine) und 1837 die Analytical Engine, konnte sie aber aus Geldmangel nicht bauen. 1843 bauten Edvard und George Scheutz in Stockholm den ersten mechanischen Computer nach den Ideen von Babbage. Im gleichen Jahr entwickelte Ada Lovelace eine Methode zur Programmierung von Computern nach dem Babbage-System und schrieb damit das erste Computerprogramm. 1890 wurde die US-Volkszählung mit Hilfe des Lochkartensystems von Herman Hollerith durchgeführt. 1912 baute Torres y Quevedo eine Schach­maschine, die mit König und Turm einen König matt setzen konnte, und somit den ersten Spielcomputer.
+
+Mechanische Rechner wie die darauf folgenden Addierer, der Comptometer, der Monroe-Kalkulator, die Curta und der Addo-X wurden bis in die 1970er Jahre genutzt. Diese Rechner nutzten alle das Dezimalsystem. Dies galt sowohl für die Rechner von Charles Babbage um 1800 wie auch für den ENIAC von 1945, den ersten vollelektronischen Universalrechner überhaupt.
+
+Es wurden jedoch auch nichtmechanische Rechner gebaut, wie der Wasserintegrator.
+
+Von 1935 über die Zuse Z1 bis zur Turing-Bombe
+1935 stellten IBM die IBM 601 vor, eine Lochkartenmaschine, die eine Multiplikation pro Sekunde durchführen konnte. Es wurden ca. 1500 Exemplare verkauft. 1937 meldete Konrad Zuse zwei Patente an, die bereits alle Elemente der so genannten Von-Neumann-Architektur beschreiben. Im selben Jahr baute John Atanasoff zusammen mit dem Doktoranden Clifford Berry einen der ersten Digitalrechner, den Atanasoff-Berry-Computer, und Alan Turing publizierte einen Artikel, der die Turingmaschine, ein abstraktes Modell zur Definition des Algorithmusbegriffs, beschreibt.
+
+1938 stellte Konrad Zuse die Zuse Z1 fertig, einen frei programmierbaren mechanischen Rechner, der allerdings aufgrund von Problemen mit der Fertigungspräzision nie voll funktionstüchtig war. Die Z1 verfügte bereits über Gleitkommarechnung. Sie wurde im Krieg zerstört und später nach Originalplänen neu gefertigt, die Teile wurden auf modernen Fräs- und Drehbänken hergestellt. Dieser Nachbau der Z1, der im Deutschen Technikmuseum in Berlin steht, ist mechanisch voll funktionsfähig und hat eine Rechengeschwindigkeit von 1 Hz, vollzieht also eine Rechenoperation pro Sekunde. Ebenfalls 1938 publizierte Claude Shannon einen Artikel darüber, wie man symbolische Logik mit Relais implementieren kann. (Lit.: Shannon 1938)
+
+Während des Zweiten Weltkrieges gab Alan Turing die entscheidenden Hinweise zur Entzifferung der Enigma-Codes und baute dafür einen speziellen mechanischen Rechner, Turing-Bombe genannt.
+
+Entwicklung des modernen turingmächtigen Computers
+Bis zum Ende des Zweiten Weltkrieges
+
+Nachbau der Zuse Z3 im Deutschen Museum in München
+Ebenfalls im Krieg (1941) baute Konrad Zuse die erste funktionstüchtige programmgesteuerte binäre Rechenmaschine, bestehend aus einer großen Zahl von Relais, die Zuse Z3. Wie 1998 bewiesen werden konnte, war die Z3 turingmächtig und damit außerdem die erste Maschine, die – im Rahmen des verfügbaren Speicherplatzes – beliebige Algorithmen automatisch ausführen konnte. Aufgrund dieser Eigenschaften wird sie oft als erster funktionsfähiger Computer der Geschichte betrachtet.[2] Die nächsten Digitalrechner waren der in den USA gebaute Atanasoff-Berry-Computer (Inbetriebnahme 1941) und die britische Colossus (1941). Sie dienten speziellen Aufgaben und waren nicht turingmächtig. Auch Maschinen auf analoger Basis wurden entwickelt.
+
+
+Colossus Mark II
+Auf das Jahr 1943 wird auch die angeblich von IBM-Chef Thomas J. Watson stammende Aussage „Ich glaube, es gibt einen weltweiten Bedarf an vielleicht fünf Computern.“ datiert. Im selben Jahr stellte Tommy Flowers mit seinem Team in Bletchley Park den ersten „Colossus“ fertig. 1944 erfolgte die Fertigstellung des ASCC (Automatic Sequence Controlled Computer, „Mark I“ durch Howard H. Aiken) und das Team um Reinold Weber stellte eine Entschlüsselungsmaschine für das Verschlüsselungsgerät M-209 der US-Streitkräfte fertig.[3] Zuse hatte schließlich bis März 1945 seine am 21. Dezember 1943 bei einem Bombenangriff zerstörte Z3 durch die deutlich verbesserte Zuse Z4 ersetzt, den damals einzigen turingmächtigen Computer in Europa, der von 1950 bis 1955 als zentraler Rechner der ETH Zürich genutzt wurde.
+
+
+Computermodell	Land	Inbetriebnahme	Gleitkomma-
+arithmetik	Binär	Elektronisch	Programmierbar	Turingmächtig
+Zuse Z3	Deutschland	Mai 1941	Ja	Ja	Nein	Ja, mittels Lochstreifen	über Umwege, nie genutzt
+Atanasoff-Berry-Computer	USA	Sommer 1941	Nein	Ja	Ja	Nein	Nein
+Colossus	UK	1943	Nein	Ja	Ja	Teilweise, durch Neu­ver­kabelung	Nein
+Mark I	USA	1944	Nein	Nein	Nein	Ja, mittels Lochstreifen	Ja
+Zuse Z4	Deutschland	März 1945	Ja	Ja	Nein	Ja, mittels Lochstreifen	keine bedingte Sprunganweisung
+um 1950	Ja	Ja	Nein	Ja, mittels Lochstreifen	Ja
+ENIAC	USA	1946	Nein	Nein	Ja	Teilweise, durch Neu­ver­kabelung	Ja
+1948	Nein	Nein	Ja	Ja, mittels Wider­stands­matrix	Ja
+Nachkriegszeit
+
+ENIAC auf einem Bild der US-Armee
+
+Der EDVAC
+
+Röhrenrechner Ural-1 aus der Sowjetunion
+Das Ende des Zweiten Weltkriegs erlaubte es, dass Europäer und Amerikaner von ihren Fortschritten gegenseitig wieder Kenntnis erlangten. Im Jahr 1946 wurde der Electronical Numerical Integrator and Computer (ENIAC) unter der Leitung von John Eckert und John Mauchly entwickelt und an der Moore School of Electrical Engineering der Universität von Pennsylvania gebaut. Der ENIAC verfügte über 20 elektronische Register, 3 Funktionstafeln als Festspeicher und bestand aus 18.000 Röhren sowie 1.500 Relais.[4] Der ENIAC ist der erste vollelektronische digitale Universalrechner (Konrad Zuses Z3 verwendete 1941 noch Relais, war also nicht vollelektronisch). 1947 baute IBM den Selective Sequence Electronic Calculator (SSEC), einen Hybridcomputer mit Röhren und mechanischen Relais und die Association for Computing Machinery (ACM) wurde als erste wissenschaftliche Gesellschaft für Informatik gegründet. Im gleichen Jahr wurde auch der erste Transistor realisiert, der heute aus der modernen Technik nicht mehr weggedacht werden kann. Die maßgeblich an der Erfindung beteiligten William B. Shockley, John Bardeen und Walter Brattain erhielten 1956 den Nobelpreis für Physik. In die späten 1940er Jahre fällt auch der Bau des Electronic Discrete Variable Automatic Computer (EDVAC), der erstmals die Von-Neumann-Architektur implementierte.
+
+Im Jahr 1949 stellte Edmund C. Berkeley, Begründer der ACM, mit „Simon“ den ersten digitalen, programmierbaren Computer für den Heimgebrauch vor. Er bestand aus 50 Relais und wurde in Gestalt von Bauplänen vertrieben, von denen in den ersten zehn Jahren ihrer Verfügbarkeit über 400 Exemplare verkauft wurden. Im selben Jahr stellte Maurice Wilkes mit seinem Team in Cambridge den Electronic Delay Storage Automatic Calculator (EDSAC) vor; basierend auf John von Neumanns EDVAC ist es der erste Rechner, der vollständig speicherprogrammierbar war. Ebenfalls 1949 besichtigte der Schweizer Mathematikprofessor Eduard Stiefel die in einem Pferdestall in Hopferau aufgestellte Zuse Z4 und finanzierte die gründliche Überholung der Maschine durch die Zuse KG, bevor sie an die ETH Zürich ausgeliefert wurde und dort in Betrieb ging.[5]
+
+1950er
+In den 1950er Jahren setzte die Produktion kommerzieller (Serien-)Computer ein. Unter der Leitung von Alwin Walther wurde am Institut für Praktische Mathematik (IPM) der TH Darmstadt ab 1951 der DERA (Darmstädter Elektronischer Rechenautomat) erbaut. Remington Rand baute 1951 ihren ersten kommerziellen Röhrenrechner, den UNIVersal Automatic Computer I (UNIVAC I) und 1955 bei Bell Labs für die US Air Force nimmt der von Jean Howard Felker und L.C. Brown (Charlie Braun) gebaute TRansistorized Airborne DIgital Computer (TRADIC) den ersten Computer der Welt, der komplett mit Transistoren statt Röhren bestückt war den Betrieb auf; im gleichen Jahr begann Heinz Zemanek mit der Konstruktion des ersten auf europäischem Festland gebauten Transistorrechners, des Mailüfterls, das er 1958 der Öffentlichkeit vorstellte.
+
+Am 30. Dezember 1954[6] vollendet die DDR mit der „OPtik-REchen-MAschine“ (OPREMA) den Bau ihres ersten Computers mit Hilfe von Relais, der zunächst als Doppelrechner aus zwei identischen Systemen redundant ausgelegt wurde. Als klar war, dass die Maschinen stabil arbeiteten, wurden sie in zwei unabhängige Rechner getrennt. Programmierung und Zahleneingabe wurden per Stecktafel vorgenommen, die Ausgabe erfolgte über eine Schreibmaschine.[7] 1956 tauchte der Begriff „Computer“ erstmals in der DDR-Presse auf, nämlich im Zusammenhang mit dem Eniac-„Rechenautomaten“, dessen Akronym für „Electronic Numerical Integrator and Computer“ stand.[8][9] Geläufig wurde der Begriff erst Mitte der 1960er Jahre.
+
+1956 nahm die ETH Zürich ihre ERMETH in Betrieb und IBM fertigte das erste Magnetplattensystem (Random Access Method of Accounting and Control (RAMAC)). Ab 1958 wurde die Electrologica X1 als volltransistorisierter Serienrechner gebaut. Noch im selben Jahr stellte die Polnische Akademie der Wissenschaften in Zusammenarbeit mit dem Laboratorium für mathematische Apparate unter der Leitung von Romuald Marczynski den ersten polnischen Digital Computer „XYZ“ vor. Vorgesehenes Einsatzgebiet war die Nuklearforschung. 1959 begann Siemens mit der Auslieferung des Siemens 2002, ihres ersten in Serie gefertigten und vollständig auf Basis von Transistoren hergestellten Computers.
+
+1960er
+1960 baute IBM den IBM 1401, einen transistorisierten Rechner mit Magnetbandsystem, und DECs (Digital Equipment Corporation) erster Minicomputer, die PDP-1 (Programmierbarer Datenprozessor) erscheint. 1962 lieferte die Telefunken AG die ersten TR 4 aus. 1964 baute DEC den Minicomputer PDP-8 für unter 20.000 Dollar.
+
+1964 definierte IBM die erste Computerarchitektur S/360, womit Rechner verschiedener Leistungsklassen denselben Code ausführen konnten und bei Texas Instruments wurde der erste „integrierte Schaltkreis“ (IC) entwickelt. 1965 stellte das Moskauer Institut für Präzisionsmechanik und Computertechnologie unter der Leitung seines Chefentwicklers Sergej Lebedjew mit dem BESM-6 den ersten exportfähigen Großcomputer der UdSSR vor. BESM-6 wurde ab 1967 mit Betriebssystem und Compiler ausgeliefert und bis 1987 gebaut. 1966 erschien dann auch noch mit D4a ein 33-Bit-Auftischrechner der TU Dresden.
+
+
+Olivetti Programma 101
+Der erste frei programmierbare Tischrechner der Welt, der „Programma 101“ von der Firma Olivetti,[10] erschien 1965 für einen Preis von $3,200[11] (was auf das Jahr 2017 bezogen $24,746[12] entspricht).
+
+
+Nixdorf 820 von 1968
+1968 bewarb Hewlett-Packard (HP) den HP-9100A in der Science-Ausgabe vom 4. Oktober 1968 als „personal computer“, obgleich diese Bezeichnung nichts mit dem zu tun hat, was seit Mitte der 1970er Jahre bis heute unter einem Personal Computer verstanden wird. Die 1968 entstandene Nixdorf Computer AG erschloss zunächst in Deutschland und Europa, später auch in Nordamerika, einen neuen Computermarkt: die Mittlere Datentechnik bzw. die dezentrale elektronische Datenverarbeitung. Massenhersteller wie IBM setzten weiterhin auf Großrechner und zentralisierte Datenverarbeitung, wobei Großrechner für kleine und mittlere Unternehmen schlicht zu teuer waren und die Großhersteller den Markt der Mittleren Datentechnik nicht bedienen konnten. Nixdorf stieß in diese Marktnische mit dem modular aufgebauten Nixdorf 820 vor, brachte dadurch den Computer direkt an den Arbeitsplatz und ermöglichte kleinen und mittleren Betrieben die Nutzung der elektronischen Datenverarbeitung zu einem erschwinglichen Preis. Im Dezember 1968 stellten Douglas C. Engelbart und William English vom Stanford Research Institute (SRI) die erste Computermaus vor, mangels sinnvoller Einsatzmöglichkeit (es gab noch keine grafischen Benutzeroberflächen) interessierte dies jedoch kaum jemanden. 1969 werden die ersten Computer per Internet verbunden.
+
+1970er
+Mit der Erfindung des serienmäßig produzierbaren Mikroprozessors wurden die Computer immer kleiner, leistungsfähiger und preisgünstiger. Doch noch wurde das Potential der Computer verkannt. So sagte noch 1977 Ken Olson, Präsident und Gründer von DEC: „Es gibt keinen Grund, warum jemand einen Computer zu Hause haben wollte.“
+
+
+Intel 8008, Vorläufer des Intel 8080
+Im Jahr 1971 war es der Hersteller Intel, der mit dem 4004 den ersten in Serie gefertigten Mikroprozessor baute. Er bestand aus 2250 Transistoren. 1971 lieferte Telefunken den TR 440 an das Deutsche Rechenzentrum Darmstadt sowie an die Universitäten Bochum und München. 1972 ging der Illiac IV, ein Supercomputer mit Array-Prozessoren, in Betrieb. 1973 erschien mit Xerox Alto der erste Computer mit Maus, graphischer Benutzeroberfläche (GUI) und eingebauter Ethernet-Karte; und die französische Firma R2E begann mit der Auslieferung des Micral. 1974 stellte HP mit dem HP-65 den ersten programmierbaren Taschenrechner vor und Motorola baute den 6800-Prozessor, währenddessen Intel den 8080-Prozessor fertigte. 1975 begann MITS mit der Auslieferung des Altair 8800. 1975 stellte IBM mit der IBM 5100 den ersten tragbaren Computer vor. Eine Zeichenlänge von 8 Bit und die Einengung der (schon existierenden) Bezeichnung Byte auf dieses Maß wurden in dieser Zeit geläufig.
+
+1975 Maestro I (ursprünglich Programm-Entwicklungs-Terminal-System PET) von Softlab war weltweit die erste Integrierte Entwicklungsumgebung für Software. Maestro I wurde weltweit 22.000 Mal installiert, davon 6.000 Mal in der Bundesrepublik Deutschland. Maestro I war in den 1970er und 1980er Jahren führend auf diesem Gebiet.
+
+
+Zilog Z80
+1976 entwickelte Zilog den Z80-Prozessor und Apple Computer stellte den Apple I vor, den weltweit ersten Personal Computer,[13][14][15] gefolgt 1977 vom Commodore PET und dem Tandy TRS-80. Der ebenfalls im Jahr 1977 veröffentlichte Apple II gilt bislang als letzter in Serie hergestellter Computer, der von einer einzelnen Person, Steve Wozniak, entworfen wurde.[16] 1978 erschien die VAX-11/780 von DEC, eine Maschine speziell für virtuelle Speicheradressierung. Im gleichen Jahr stellte Intel den 8086 vor, ein 16-Bit-Mikroprozessor; er ist der Urvater der noch heute gebräuchlichen x86-Prozessor-Familie. 1979 schließlich startete Atari den Verkauf seiner Rechnermodelle 400 und 800. Revolutionär war bei diesen, dass mehrere ASIC-Chips den Hauptprozessor entlasteten.
+
+1980er
+
+C64 mit 5¼″-Diskette und Laufwerk
+Die 1980er waren die Blütezeit der Heimcomputer, zunächst mit 8-Bit-Mikroprozessoren und einem Arbeitsspeicher bis 64 KiB (Commodore VC20, C64, Sinclair ZX80/81, Sinclair ZX Spectrum, Schneider/Amstrad CPC 464/664, Atari XL/XE-Reihe), später auch leistungsfähigere Modelle mit 16-Bit- (Texas Instruments TI-99/4A) oder 16/32-Bit-Mikroprozessoren (z. B. Amiga, Atari ST). Eine Eigenentwicklung von Siemens, der Siemens PC 16-10, war dagegen mit einem Anfangspreis von 11.300 DM deutlich zu teuer.
+
+Das Unternehmen IBM stellte 1981 den IBM-PC vor, legte die Grundkonstruktion offen und schuf einen informellen Industriestandard;[17] sie definierten damit die bis heute aktuelle Geräteklasse der „IBM-PC-kompatiblen Computer“. Dank zahlreicher preiswerter Nachbauten und Fortführungen wurde diese Geräteklasse zu einer der erfolgreichsten Plattformen für den Personal Computer; die heute marktüblichen PCs mit Windows-Betriebssystem und x86-Prozessoren beruhen auf der stetigen Weiterentwicklung des damaligen Entwurfs von IBM.
+
+1982 brachte Intel den 80286-Prozessor auf den Markt und Sun Microsystems entwickelte die Sun-1 Workstation. Nach dem ersten Büro-Computer mit Maus, Lisa, der 1983 auf den Markt kam, wurde 1984 der Apple Macintosh gebaut und setzte neue Maßstäbe für Benutzerfreundlichkeit. Die Sowjetunion konterte mit ihrem „Kronos 1“, einer Bastelarbeit des Rechenzentrums in Akademgorodok. Im Januar 1985 stellte Atari den ST-Computer auf der Consumer Electronics Show (CES) in Las Vegas vor. Im Juli produzierte Commodore den ersten Amiga-Heimcomputer. In Sibirien wurde der „Kronos 2“ vorgestellt, der dann als „Kronos 2.6“ für vier Jahre in Serie ging. 1986 brachte Intel den 80386-Prozessor auf den Markt, 1989 den 80486. Ebenfalls 1986 präsentierte Motorola den 68030-Prozessor. Im gleichen Jahr stellte Acorn den ARM2-Prozessor fertig und setzte ihn im Folgejahr in Acorn-Archimedes-Rechnern ein. 1988 stellte NeXT mit Steve Jobs, Mitgründer von Apple, den gleichnamigen Computer vor.
+
+Die Computer-Fernvernetzung, deutsch „DFÜ“ (Datenfernübertragung), über das Usenet wurde an Universitäten und in diversen Firmen immer stärker benutzt. Auch Privatleute strebten nun eine Vernetzung ihrer Computer an; Mitte der 1980er Jahre entstanden Mailboxnetze, zusätzlich zum FidoNet das Z-Netz und das MausNet.
+
+1990er
+
+Pentium
+Die 1990er sind das Jahrzehnt des Internets und des World Wide Web. (Siehe auch Geschichte des Internets, Chronologie des Internets) 1991 spezifizierte das AIM-Konsortium (Apple, IBM, Motorola) die PowerPC-Plattform. 1992 stellte DEC die ersten Systeme mit dem 64-Bit-Alpha-Prozessor vor. 1993 brachte Intel den Pentium-Prozessor auf den Markt, 1995 den Pentium Pro. 1994 stellte Leonard Adleman mit dem TT-100 den ersten Prototyp eines DNA-Computers vor, im Jahr darauf Be Incorporated die BeBox. 1999 baute Intel den Supercomputer ASCI Red mit 9.472 Prozessoren und AMD stellte mit dem Athlon den Nachfolger der K6-Prozessorfamilie vor.
+
+Entwicklung im 21. Jahrhundert
+Zu Beginn des 21. Jahrhunderts sind Computer sowohl in beruflichen wie privaten Bereichen allgegenwärtig und allgemein akzeptiert. Während die Leistungsfähigkeit in klassischen Anwendungsbereichen weiter gesteigert wird, werden digitale Rechner unter anderem in die Telekommunikation und Bildbearbeitung integriert. 2001 baute IBM den Supercomputer ASCI White, und 2002 ging der NEC Earth Simulator in Betrieb. 2003 lieferte Apple den PowerMac G5 aus, den ersten Computer mit 64-Bit-Prozessoren für den Massenmarkt. AMD zog mit dem Opteron und dem Athlon 64 nach.
+
+2005 produzierten AMD und Intel erste Dual-Core-Prozessoren, 2006 doppelte Intel mit den ersten Core-2-Quad-Prozessoren nach – AMD konnte erst 2007 erste Vierkernprozessoren vorstellen. Bis zum Jahr 2010 stellten mehrere Firmen auch Sechs- und Achtkernprozessoren vor. Entwicklungen wie Mehrkernprozessoren, Berechnung auf Grafikprozessoren (GPGPU) sowie der breite Einsatz von Tablet-Computern dominieren in den letzten Jahren (Stand 2012) das Geschehen.
+
+Seit den 1980er Jahren stiegen die Taktfrequenzen von anfangs wenigen MHz bis zuletzt (Stand 2015) etwa 4 GHz. In den letzten Jahren konnte der Takt nur noch wenig gesteigert werden, stattdessen wurden Steigerungen der Rechenleistung eher durch mehr Prozessorkerne und vergrößerte Busbreiten erzielt. Auch wenn durch Übertaktung einzelne Prozessoren auf über 8 GHz betrieben werden konnten, sind diese Taktraten auch 2015 noch nicht in Serienprozessoren verfügbar. Außerdem werden zunehmend auch die in Computern verbauten Grafikprozessoren zur Erhöhung der Rechenleistung für spezielle Aufgaben genutzt (z. B. per OpenCL, siehe auch Streamprozessor und GPGPU).
+
+Seit ca. 2005 spielen auch Umweltaspekte (wie z. B. Stromsparfunktionen von Prozessor und Chipsatz, verringerter Einsatz schädlicher Stoffe) – bei der Produktion, Beschaffung und Nutzung von Computern zunehmend eine Rolle (siehe auch Green IT).
+
+2020
+Ende September 2020 wurde Europas letztes Computerwerk, Fujitsu in Augsburg, geschlossen.[18]
+
+Siehe auch
+Commons: Geschichte des Computers – Sammlung von Bildern, Videos und Audiodateien
+Elektronikschrott
+Liste historischer Rechenanlagen in Europa
+Liste von Computermuseen
+Mediengeschichte
+Technikgeschichte
+Überwachung
+Literatur
+Edmund Callis Berkeley: Giant Brains or Machines That Think. 7. Auflage. John Wiley & Sons 1949, New York 1963 (die erste populäre Darstellung der EDV, trotz des für moderne Ohren seltsam klingenden Titels sehr seriös und fundiert – relativ einfach antiquarisch und in fast allen Bibliotheken zu finden).
+Frank Bösch (Hrsg.): Wege in die digitale Gesellschaft. Computernutzung in der Bundesrepublik 1955-1990, Wallstein, Göttingen 2018
+Bertram Vivian Bowden (Hrsg.): Faster Than Thought. Pitman, New York 1953 (Nachdruck 1963, ISBN 0-273-31580-3) – eine frühe populäre Darstellung der EDV, gibt den Stand seiner Zeit verständlich und ausführlich wieder; nur mehr antiquarisch und in Bibliotheken zu finden
+Herbert Bruderer: Meilensteine der Rechentechnik. Band 1: Mechanische Rechenmaschinen, Rechenschieber, historische Automaten und wissenschaftliche Instrumente, 2., stark erweiterte Auflage, Walter de Gruyter, Berlin/Boston 2018, ISBN 978-3-11-051827-6
+Michael Friedewald: Der Computer als Werkzeug und Medium. Die geistigen und technischen Wurzeln des Personalcomputers. GNT-Verlag, 2000, ISBN 3-928186-47-7.
+Thomas Haigh: Jenseits der Genies. Geschichten aus der IT-Arbeit, mandelbaum, Wien 2025
+Thomas Haigh, Mark Priestley, Crispin Rope: ENIAC in Action: Making and Remaking the Modern Computer, MIT Press, Cambridge, Mass. 2016[19]
+Thomas Haigh, Paul E. Ceruzzi: A New History of Modern Computing (History of Computing), MIT Press, Cambridge, Massachusetts ; London, England 2021, 544 S. [aktualisierte Ausgabe des Standardwerks]
+Simon Head: The New Ruthless Economy. Work and Power in the Digital Age. Oxford UP 2005, ISBN 0-19-517983-8 (der Einsatz des Computers in der Tradition des Taylorismus).
+Ute Hoffmann: Computerfrauen. Welchen Anteil hatten Frauen an der Computergeschichte und -arbeit? München 1987, ISBN 3-924346-30-5
+Loading History. Computergeschichte(n) aus der Schweiz. Museum für Kommunikation, Bern 2001, ISBN 3-0340-0540-7, Ausstellungskatalog zu einer Sonderausstellung mit Schweizer Schwerpunkt, aber für sich alleine lesbar
+Michael Homberg: Digitale Unabhängigkeit: Indiens Weg ins Computerzeitalter – Eine internationale Geschichte (Geschichte der Gegenwart), Wallstein, Göttingen 2022
+Anthony Hyman: Charles Babbage. Pioneer of the Computer. Oxford University Press, Oxford 1984.
+HNF Heinz Nixdorf Forum Museumsführer. Paderborn 2000, ISBN 3-9805757-2-1 – Museumsführer des nach eigener Darstellung weltgrößten Computermuseums
+Jens Müller: The Computer. A History from the 17th Century to Today. Hrsg.: Julius Wiedemann. Taschen Verlag, 2023, ISBN 978-3-8365-7334-4 (englisch).
+André Reifenrath: Geschichte der Simulation. Dissertation Humboldt-Universität Berlin 2000. Geschichte des Computers von den Anfängen bis zur Gegenwart unter besonderer Berücksichtigung des Themas der Visualisierung und Simulation durch den Computer.
+Claude E. Shannon: A Symbolic Analysis of Relay and Switching Circuits. In: Transactions of the American Institute of Electrical Engineers. Vol. 57, 1938, S. 713–723.
+Karl Weinhart: Informatik und Automatik. Führer durch die Ausstellungen. Deutsches Museum, München 1990, ISBN 3-924183-14-7 – Katalog zu den permanenten Ausstellungen des Deutschen Museums zum Thema; vor allem als ergänzende Literatur zum Ausstellungsbesuch empfohlen
+H. R. Wieland: Computergeschichte(n) – nicht nur für Geeks: Von Antikythera zur Cloud. Galileo Computing, 2010, ISBN 978-3-8362-1527-5
+Jürgen Wolf: Computergeschichte(n): Nicht nur für Nerds. Eine Zeitreise durch die IT-Geschichte. Rheinwerk Computing, Bonn 2020, ISBN 978-3-8362-7777-8.
+Joseph Weizenbaum: Computer Power and Human Reason. From Judgement to Calculation. W. H. Freeman and Company, Freeman, San Francisco CA 1976, ISBN 0-7167-0464-1 (Deutsch als: Die Macht der Computer und die Ohnmacht der Vernunft. Suhrkamp, Frankfurt am Main 1977, ISBN 3-518-27874-6 (Suhrkamp Taschenbuch Wissenschaft 274); zahlreiche Auflagen).
+Christian Wurster: Computers. Eine illustrierte Geschichte. Taschen, 2002, ISBN 3-8228-5729-7 (eine vom Text her leider nicht sehr exakte Geschichte der EDV mit einzelnen Fehlern, die aber durch die Gastbeiträge einzelner Persönlichkeiten der Computergeschichte und durch die zahlreichen Fotos ihren Wert hat).
+Shoshana Zuboff: Das Zeitalter des Überwachungskapitalismus, Campus, Frankfurt am Main 2025 (Paperback)
+Einzelnachweise
+UCL: Experts recreate a mechanical Cosmos for the world’s first computer. 12. März 2021, abgerufen am 18. März 2021 (englisch).
+Konrad Zuse: Die Erfindung des Computers. In: swr.de. 17. Mai 1984, abgerufen am 25. August 2020.
+Klaus Schmeh: Als deutscher Code-Knacker im Zweiten Weltkrieg. In: heise.de. 24. September 2004, abgerufen am 25. August 2020.
+Wilfried de Beauclair: Rechnen mit Maschinen. Eine Bildgeschichte der Rechentechnik. 2. Auflage. Springer, Berlin Heidelberg New York 2005, ISBN 3-540-24179-5, S. 111–113.
+Stefan Betschon: Der Zauber des Anfangs. Schweizer Computerpioniere. In: Franz Betschon, Stefan Betschon, Jürg Lindecker, Willy Schlachter (Hrsg.): Ingenieure bauen die Schweiz. Technikgeschichte aus erster Hand. Verlag Neue Zürcher Zeitung, Zürich 2013, ISBN 978-3-03823-791-4, S. 376–399.
+René Meyer: Computer in der DDR. Robotron statt Commodore, VEB Röhrenwerk Mühlhausen statt IBM: Die Computertechnik in der DDR war ganz anders als im Westen – vor allem viel abenteuerlicher. In: www.heise.de. Heise.de, 12. Januar 2023, abgerufen am 12. Januar 2023.
+Andreas Göbel: Spiegel Geschichte: Mit diesem Monstrum konnte man rechnen. 14. Juni 2013, abgerufen im Jahr 2020.
+Neues Deutschland, 6. Mai 1956
+Erich Sobeslavsky, Nikolaus Joachim Lehmann: Rechentechnik und Datenverarbeitung in der DDR - 1946 bis 1968. (PDF) Hannah-Arendt-Institut TU Dresden, 1996, abgerufen im Jahr 2020.
+siehe K. Dette: Olivetti Personal Computer fur Lehre und Forschung. Springer, 1989; Brennan, AnnMarie: Olivetti: A work of art in the age of immaterial labour. In: Journal of Design History 28.3 (2015): 235–253; Tischcomputer. In: kuno.de
+Wobbe Vegter: Cyber Heroes of the past: Camillo Olivetti. 11. März 2009, abgerufen am 6. April 2017 (englisch).
+US Inflation Calculator
+Steven Levy: Hackers: Heroes of the Computer Revolution. Doubleday 1984, ISBN 0-385-19195-2
+Boris Gröndahl: Hacker. Rotbuch 3000, ISBN 3-434-53506-3
+Steve Wozniak: iWoz: Wie ich den Personal Computer erfand und Apple mitgründete. Deutscher Taschenbuchverlag, Oktober 2008, ISBN 978-3-423-34507-1
+Der Traum vom einfachen Computer. In: Der Tagesspiegel
+Frank Patalong: 30 Jahre IBM-PC: Siegeszug der Wenigkönner. In: spiegel.de. 12. August 2011, abgerufen am 21. August 2016.
+Europas letztes Computerwerk schließt – Fujitsu macht Augsburg dicht. In: derstandard.de. 26. Oktober 2018, abgerufen am 2. Februar 2024.
+prozessurale Perspektive, auch methodisch wegweisende Studie, vgl. die Rezension in „Berichte zur Wissenschaftsgeschichte“ 40(2017), S. 98–100
+Kategorien: ComputerGeschichte der Informatik
+Diese Seite wurde zuletzt am 19. April 2026 um 13:50 Uhr bearbeitet. Die Seite wurde

hearthnet/blobs/chunker.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import hashlib
 import json
 from dataclasses import dataclass
-from typing import Optional
 
 CHUNK_SIZE_BYTES = 256 * 1024  # 256 KB
 

hearthnet/blobs/transfer.py

@@ -51,7 +51,9 @@ class TransferManager:
             resp.raise_for_status()
             raw = resp.json()
         except Exception as exc:
-            raise BlobError("io_error", f"Failed to fetch manifest from {manifest_url}: {exc}") from exc
+            raise BlobError(
+                "io_error", f"Failed to fetch manifest from {manifest_url}: {exc}"
+            ) from exc
 
         from hearthnet.blobs.store import BlobStore as _BS
 

hearthnet/bus/router.py

@@ -1,4 +1,4 @@
-"""M03 - Capability Bus - Router.
+"""M03 - Capability Bus - Router.
 
 Spec: docs/M03-bus.md §3.5 (routing) §5.4 (scoring algorithm)
 Impl-ref: impl_ref.md §7 Router
@@ -6,6 +6,7 @@ Impl-ref: impl_ref.md §7 Router
 Scoring: latency-weighted success rate, capacity headroom, prefer local.
 Quarantine threshold: HEALTH_QUARANTINE_THRESHOLD (hearthnet/constants.py).
 """
+
 from __future__ import annotations
 
 import time
@@ -81,4 +82,3 @@ def _score(entry: CapabilityEntry) -> float:
     reliability_penalty = (1.0 - entry.success_rate) * 1000
     locality_bonus = -50 if entry.is_local else 0
     return latency * (1 + load) + reliability_penalty + locality_bonus
-

hearthnet/bus/schema.py

@@ -1,4 +1,5 @@
 """JSON Schema validation for capability requests/responses."""
+
 from __future__ import annotations
 
 import hashlib
@@ -42,9 +43,7 @@ class SchemaValidator:
         key = f"resp:{descriptor.name}:{descriptor.version_str}"
         self._validate(descriptor.response_schema, response, key)
 
-    def validate_stream_frame(
-        self, descriptor: CapabilityDescriptor, frame: dict
-    ) -> None:
+    def validate_stream_frame(self, descriptor: CapabilityDescriptor, frame: dict) -> None:
         """Validate a streaming frame."""
         if not HAS_JSONSCHEMA or not descriptor.stream_schema:
             return
@@ -62,9 +61,7 @@ class SchemaValidator:
 
 def compute_schema_hash(descriptor_partial: dict) -> str:
     """SHA-256 (or BLAKE3 if available) over canonical-JSON of descriptor."""
-    canonical = json.dumps(
-        descriptor_partial, sort_keys=True, separators=(",", ":")
-    ).encode()
+    canonical = json.dumps(descriptor_partial, sort_keys=True, separators=(",", ":")).encode()
     try:
         import blake3  # type: ignore[import]
 

hearthnet/bus/trace.py

@@ -1,4 +1,5 @@
 """Bus trace events for call tracking."""
+
 from __future__ import annotations
 
 from dataclasses import dataclass

hearthnet/civdef/__init__.py

@@ -1,4 +1,5 @@
 """M31 — Civil Defense package (experimental, Phase 3)."""
+
 from __future__ import annotations
 
 from hearthnet.civdef.service import Alert, AuditChain, CivilDefenseService, RoleCertificate

hearthnet/civdef/service.py

@@ -4,6 +4,7 @@ Bridges HearthNet with THW/DRK/Feuerwehr/KatS role structures.
 Produces tamper-evident audit trails for incident coordination.
 Gated by config.research.civil_defense = True.
 """
+
 from __future__ import annotations
 
 import hashlib
@@ -30,16 +31,17 @@ NRW_ROLES = {
 @dataclass(frozen=True)
 class AlertSeverity:
     INFORMATION = "information"
-    WARNING     = "warning"
-    ALERT       = "alert"
-    EMERGENCY   = "emergency"
+    WARNING = "warning"
+    ALERT = "alert"
+    EMERGENCY = "emergency"
 
 
 @dataclass(frozen=True)
 class RoleCertificate:
     """A role certificate issued by an authority for a community member."""
+
     cert_id: str
-    role_key: str               # key from NRW_ROLES
+    role_key: str  # key from NRW_ROLES
     role_label: str
     holder_node_id: str
     issuer_node_id: str
@@ -61,15 +63,16 @@ class RoleCertificate:
 @dataclass(frozen=True)
 class Alert:
     """A civil-defense alert with full provenance."""
+
     alert_id: str
-    severity: str                   # AlertSeverity constant
+    severity: str  # AlertSeverity constant
     title: str
     body: str
-    area_description: str           # e.g. "Issum, Kreis Kleve, NRW"
+    area_description: str  # e.g. "Issum, Kreis Kleve, NRW"
     issuer_node_id: str
     issuer_role_cert_id: str | None
     community_id: str
-    event_log_id: str | None = None # optional backlink to event log entry
+    event_log_id: str | None = None  # optional backlink to event log entry
     issued_at: float = field(default_factory=time.time)
     expires_at: float | None = None
     issuer_signature: bytes = b""
@@ -168,25 +171,28 @@ class CivilDefenseService:
             expires_at=time.time() + expires_in_hours * 3600 if expires_in_hours else None,
         )
         self._alerts[alert.alert_id] = alert
-        self._audit.append("alert.issued", node_id, {
-            "alert_id": alert.alert_id,
-            "severity": alert.severity,
-            "title": alert.title,
-        })
+        self._audit.append(
+            "alert.issued",
+            node_id,
+            {
+                "alert_id": alert.alert_id,
+                "severity": alert.severity,
+                "title": alert.title,
+            },
+        )
         return alert
 
     def list_active_alerts(self, now: float | None = None) -> list[Alert]:
         now = now or time.time()
-        return [
-            a for a in self._alerts.values()
-            if a.expires_at is None or a.expires_at > now
-        ]
+        return [a for a in self._alerts.values() if a.expires_at is None or a.expires_at > now]
 
     def register_cert(self, cert: RoleCertificate) -> None:
         self._certs[cert.cert_id] = cert
-        self._audit.append("cert.registered", cert.issuer_node_id, {
-            "cert_id": cert.cert_id, "role": cert.role_key, "holder": cert.holder_node_id
-        })
+        self._audit.append(
+            "cert.registered",
+            cert.issuer_node_id,
+            {"cert_id": cert.cert_id, "role": cert.role_key, "holder": cert.holder_node_id},
+        )
 
     def verify_cert(self, cert_id: str) -> dict:
         cert = self._certs.get(cert_id)

hearthnet/cli.py

@@ -1,4 +1,5 @@
 """HearthNet CLI — `hearthnet` command."""
+
 from __future__ import annotations
 
 import asyncio
@@ -61,7 +62,9 @@ def _http_post(url: str, body: str) -> dict:
     try:
         import httpx
 
-        resp = httpx.post(url, content=body, headers={"Content-Type": "application/json"}, timeout=30)
+        resp = httpx.post(
+            url, content=body, headers={"Content-Type": "application/json"}, timeout=30
+        )
         resp.raise_for_status()
         return resp.json()
     except ImportError:
@@ -93,7 +96,9 @@ def _http_post(url: str, body: str) -> dict:
 
 @click.group()
 @click.version_option(version="0.1.0")
-@click.option("--config", "config_path", type=click.Path(), default=None, help="Path to config.toml")
+@click.option(
+    "--config", "config_path", type=click.Path(), default=None, help="Path to config.toml"
+)
 @click.pass_context
 def main(ctx: click.Context, config_path: str | None) -> None:
     """HearthNet — community-owned local AI mesh."""

hearthnet/config.py

@@ -1,4 +1,4 @@
-"""X04 - Configuration.
+"""X04 - Configuration.
 
 Spec: docs/X04-config.md
 Impl-ref: impl_ref.md §1
@@ -20,13 +20,13 @@ Example config.toml:
   url   = "http://localhost:8000"
   model = "openbmb/MiniCPM4-8B"
 """
+
 from __future__ import annotations
 
 import os
 import tomllib  # stdlib ≥ 3.11; fallback below
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Optional
 
 from hearthnet.constants import (
     CHUNK_SIZE_BYTES,
@@ -49,6 +49,7 @@ except ImportError:
 
 # ── Sub-config dataclasses ───────────────────────────────────────────────────
 
+
 @dataclass(frozen=True)
 class IdentityConfig:
     keys_dir: Path = field(default_factory=lambda: Path())
@@ -160,6 +161,7 @@ class ObservabilityConfig:
 @dataclass(frozen=True)
 class ResearchConfig:
     """Phase 3 experimental feature flags. All default False."""
+
     enable: bool = False
     distributed_inference: bool = False
     moe_routing: bool = False
@@ -191,6 +193,7 @@ class Config:
 
 # ── ConfigError ───────────────────────────────────────────────────────────────
 
+
 class ConfigError(Exception):
     def __init__(self, code: str, **kwargs: object) -> None:
         super().__init__(code)
@@ -200,6 +203,7 @@ class ConfigError(Exception):
 
 # ── XDG path resolution ───────────────────────────────────────────────────────
 
+
 def _xdg_data() -> Path:
     raw = os.environ.get("XDG_DATA_HOME") or os.path.expanduser("~/.local/share")
     return Path(raw) / "hearthnet"
@@ -221,6 +225,7 @@ def _default_config_path() -> Path:
 
 # ── Path resolution ───────────────────────────────────────────────────────────
 
+
 def resolve_paths(config: Config) -> Config:
     """Fill empty Path() fields with XDG-standard locations. Idempotent."""
     data = _xdg_data()
@@ -293,22 +298,28 @@ def resolve_paths(config: Config) -> Config:
 
 # ── Validation ────────────────────────────────────────────────────────────────
 
+
 def validate(config: Config) -> None:
     """Cross-field validation. Raises ConfigError on failure."""
     t = config.transport
     d = config.discovery
     if t.port == d.udp_port:
-        raise ConfigError("invalid_field", field="transport.port/discovery.udp_port",
-                          reason="transport port and UDP discovery port must differ")
+        raise ConfigError(
+            "invalid_field",
+            field="transport.port/discovery.udp_port",
+            reason="transport port and UDP discovery port must differ",
+        )
     if not (1 <= t.port <= 65535):
         raise ConfigError("invalid_field", field="transport.port", reason="port out of range")
     if config.bus.local_load_threshold <= 0 or config.bus.local_load_threshold > 1:
-        raise ConfigError("invalid_field", field="bus.local_load_threshold",
-                          reason="must be in (0, 1]")
+        raise ConfigError(
+            "invalid_field", field="bus.local_load_threshold", reason="must be in (0, 1]"
+        )
 
 
 # ── TOML parsing helpers ──────────────────────────────────────────────────────
 
+
 def _parse_toml(text: str) -> dict:
     if tomllib is None:
         raise ConfigError("invalid_toml", reason="no TOML parser available (install tomli)")
@@ -359,12 +370,14 @@ def _from_dict(raw: dict) -> Config:
     llm_raw = raw.get("llm", {})
     backends = []
     for b in llm_raw.get("backends", []):
-        backends.append(LlmBackendConfig(
-            name=str(b["name"]),
-            model=str(b.get("model", "")),
-            base_url=str(b.get("base_url", "")),
-            api_key_env=b.get("api_key_env") or None,
-        ))
+        backends.append(
+            LlmBackendConfig(
+                name=str(b["name"]),
+                model=str(b.get("model", "")),
+                base_url=str(b.get("base_url", "")),
+                api_key_env=b.get("api_key_env") or None,
+            )
+        )
     llm = LlmConfig(backends=tuple(backends))
 
     embedding_raw = raw.get("embedding", {})
@@ -402,9 +415,17 @@ def _from_dict(raw: dict) -> Config:
 
     emergency_raw = raw.get("emergency", {})
     emergency = EmergencyConfig(
-        probe_targets=tuple(emergency_raw.get("probe_targets", [
-            "1.1.1.1", "8.8.8.8", "https://cloudflare.com", "https://quad9.net",
-        ])),
+        probe_targets=tuple(
+            emergency_raw.get(
+                "probe_targets",
+                [
+                    "1.1.1.1",
+                    "8.8.8.8",
+                    "https://cloudflare.com",
+                    "https://quad9.net",
+                ],
+            )
+        ),
     )
 
     ui_raw = raw.get("ui", {})
@@ -442,6 +463,7 @@ def _from_dict(raw: dict) -> Config:
 
 # ── Public API ────────────────────────────────────────────────────────────────
 
+
 def default_config() -> Config:
     """Return a Config populated entirely from defaults."""
     return resolve_paths(Config())
@@ -527,4 +549,3 @@ def save(config: Config, path: Path | None = None) -> None:
         except OSError:
             pass
         raise
-

hearthnet/constants.py

@@ -3,6 +3,7 @@
 All module code that needs a tunable default imports from here.
 Never hardcode these values inline.
 """
+
 from __future__ import annotations
 
 # ── Node manifest ────────────────────────────────────────────────────────────
@@ -28,7 +29,7 @@ RATE_LIMIT_WINDOW_SECONDS: int = 60
 RATE_LIMIT_MAX_CALLS: int = 200
 
 # ── Bus ──────────────────────────────────────────────────────────────────────
-BUS_HEALTH_WINDOW: int = 20          # samples per ring-buffer window
+BUS_HEALTH_WINDOW: int = 20  # samples per ring-buffer window
 BUS_QUARANTINE_SECONDS: int = 60
 BUS_FRESHNESS_SECONDS: int = 60
 BUS_LOCAL_LOAD_THRESHOLD: float = 0.80
@@ -54,7 +55,7 @@ LOG_RETENTION_DAYS: int = 14
 TRACE_RING_BUFFER_SIZE: int = 1000
 
 # ── Onboarding ───────────────────────────────────────────────────────────────
-INVITE_DEFAULT_TTL_SECONDS: int = 86400   # 24 h
+INVITE_DEFAULT_TTL_SECONDS: int = 86400  # 24 h
 
 # ── RAG / Embedding ──────────────────────────────────────────────────────────
 RAG_DEFAULT_CHUNK_SIZE_TOKENS: int = 512
@@ -65,8 +66,6 @@ RERANK_LOAD_TIMEOUT_SECONDS: int = 60
 EMBED_MAX_TEXTS: int = 256
 EMBED_MAX_CHARS: int = 8192
 RAG_OVERLAP_TOKENS: int = 64
-EMBED_MAX_TEXTS: int = 256
-EMBED_MAX_CHARS: int = 8192
 EMBED_DEFAULT_MODEL: str = "BAAI/bge-small-en-v1.5"
 
 # ── LLM ──────────────────────────────────────────────────────────────────────
@@ -74,8 +73,8 @@ LLM_STREAM_CANCEL_TIMEOUT_MS: int = 200
 
 # ── Marketplace ──────────────────────────────────────────────────────────────
 MARKET_SWEEP_INTERVAL_SECONDS: int = 60
-MARKET_DEFAULT_TTL_SECONDS: int = 86400 * 7   # 1 week
-MARKET_MAX_TTL_SECONDS: int = 86400 * 30      # 30 days
+MARKET_DEFAULT_TTL_SECONDS: int = 86400 * 7  # 1 week
+MARKET_MAX_TTL_SECONDS: int = 86400 * 30  # 30 days
 MARKET_SEARCH_CACHE_MAX: int = 5000
 
 # ── STT / TTS ─────────────────────────────────────────────────────────────────
@@ -83,6 +82,3 @@ STT_MAX_AUDIO_SECONDS: int = 300
 
 # ── Translation ───────────────────────────────────────────────────────────────
 TRANSLATION_MAX_CHARS: int = 4000
-
-# ── Rerank ────────────────────────────────────────────────────────────────────
-RERANK_MAX_DOCS: int = 100

hearthnet/crypto/envelope.py

@@ -1,4 +1,5 @@
 """File-chunk envelope encryption for HearthNet blobs (M23 / M07 extension)."""
+
 from __future__ import annotations
 
 import hashlib
@@ -53,7 +54,7 @@ class EncryptedEnvelope:
 
     ciphertext: bytes
     nonce: bytes  # 24 bytes (XSalsa20 nonce)
-    key_id: str   # identifies which key was used (e.g., recipient node_id or blob CID)
+    key_id: str  # identifies which key was used (e.g., recipient node_id or blob CID)
 
 
 # ---------------------------------------------------------------------------
@@ -65,9 +66,7 @@ def envelope_encrypt(plaintext: bytes, key: bytes) -> EncryptedEnvelope:
     """Encrypt plaintext with XSalsa20-Poly1305 using the given 32-byte key."""
     _require_nacl()
     if len(key) != nacl.secret.SecretBox.KEY_SIZE:
-        raise CryptoError(
-            f"Key must be {nacl.secret.SecretBox.KEY_SIZE} bytes, got {len(key)}"
-        )
+        raise CryptoError(f"Key must be {nacl.secret.SecretBox.KEY_SIZE} bytes, got {len(key)}")
     box = nacl.secret.SecretBox(key)
     nonce = nacl.utils.random(nacl.secret.SecretBox.NONCE_SIZE)
     ciphertext = bytes(box.encrypt(plaintext, nonce).ciphertext)
@@ -78,9 +77,7 @@ def envelope_decrypt(envelope: EncryptedEnvelope, key: bytes) -> bytes:
     """Decrypt an EncryptedEnvelope using the given 32-byte key."""
     _require_nacl()
     if len(key) != nacl.secret.SecretBox.KEY_SIZE:
-        raise CryptoError(
-            f"Key must be {nacl.secret.SecretBox.KEY_SIZE} bytes, got {len(key)}"
-        )
+        raise CryptoError(f"Key must be {nacl.secret.SecretBox.KEY_SIZE} bytes, got {len(key)}")
     box = nacl.secret.SecretBox(key)
     try:
         return bytes(box.decrypt(envelope.ciphertext, envelope.nonce))

hearthnet/crypto/kem.py

@@ -1,4 +1,5 @@
 """X25519 key agreement + X3DH for HearthNet E2E encryption (M23)."""
+
 from __future__ import annotations
 
 import base64
@@ -220,9 +221,7 @@ def x3dh_initiator(
         "ephemeral_pub": _b64url_encode(our_ephemeral_kp.public),
         "signed_prekey_pub": _b64url_encode(their_bundle.signed_prekey_pub),
         "used_otp_index": used_otp_index,
-        "used_otp_pub": (
-            their_bundle.one_time_prekeys[0] if used_otp_index is not None else None
-        ),
+        "used_otp_pub": (their_bundle.one_time_prekeys[0] if used_otp_index is not None else None),
     }
     return shared_secret, session_init_message
 

hearthnet/crypto/prekeys.py

@@ -1,4 +1,5 @@
 """Prekey bundle storage for HearthNet E2E encryption (M23)."""
+
 from __future__ import annotations
 
 import base64

hearthnet/crypto/ratchet.py

@@ -1,4 +1,5 @@
 """Double Ratchet session for HearthNet E2E encryption (M23)."""
+
 from __future__ import annotations
 
 import base64

hearthnet/dht/bootstrap.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import json
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
@@ -41,7 +41,7 @@ def load_bootstrap(config_path: str | Path | None = None) -> BootstrapConfig:
 
     # Auto-discover relay_url from XDG config if possible
     try:
-        from hearthnet.config import _default_config_path, load  # noqa: PLC0415
+        from hearthnet.config import _default_config_path, load
 
         cfg_file = _default_config_path()
         if cfg_file.is_file():

hearthnet/dht/kademlia.py

@@ -2,23 +2,22 @@ from __future__ import annotations
 
 import hashlib
 import time
-from dataclasses import dataclass, field
-from typing import Any
+from dataclasses import dataclass
 
 
 @dataclass(frozen=True)
 class DhtContact:
-    node_key: bytes        # 32-byte SHA-256 of node_id
-    endpoint: str          # "host:port"
-    node_id: str           # human-readable node identifier
-    last_seen: float       # monotonic timestamp
+    node_key: bytes  # 32-byte SHA-256 of node_id
+    endpoint: str  # "host:port"
+    node_id: str  # human-readable node identifier
+    last_seen: float  # monotonic timestamp
 
 
 @dataclass(frozen=True)
 class DhtValue:
-    key: bytes             # lookup key (arbitrary bytes)
-    payload: dict          # stored data
-    expires_at: int        # Unix epoch seconds
+    key: bytes  # lookup key (arbitrary bytes)
+    payload: dict  # stored data
+    expires_at: int  # Unix epoch seconds
 
 
 def _xor_distance(a: bytes, b: bytes) -> int:
@@ -30,7 +29,7 @@ def _xor_distance(a: bytes, b: bytes) -> int:
     elif lb < la:
         b = b.ljust(la, b"\x00")
     result = 0
-    for x, y in zip(a, b):
+    for x, y in zip(a, b, strict=False):
         result = (result << 8) | (x ^ y)
     return result
 

hearthnet/discovery/__init__.py

@@ -3,7 +3,11 @@ from hearthnet.discovery.peers import PeerEvent, PeerRecord, PeerRegistry
 from hearthnet.discovery.udp import UdpAnnouncer, UdpListener
 
 __all__ = [
-    "PeerRecord", "PeerRegistry", "PeerEvent",
-    "MdnsAnnouncer", "MdnsBrowser",
-    "UdpAnnouncer", "UdpListener",
+    "MdnsAnnouncer",
+    "MdnsBrowser",
+    "PeerEvent",
+    "PeerRecord",
+    "PeerRegistry",
+    "UdpAnnouncer",
+    "UdpListener",
 ]

hearthnet/discovery/mdns.py

@@ -7,6 +7,7 @@ import time
 try:
     from zeroconf import ServiceInfo
     from zeroconf.asyncio import AsyncServiceBrowser, AsyncZeroconf
+
     HAS_ZEROCONF = True
 except ImportError:
     HAS_ZEROCONF = False
@@ -40,6 +41,7 @@ class MdnsAnnouncer:
             return
         try:
             import socket
+
             self._zeroconf = AsyncZeroconf()
             short = self._node_id.replace("ed25519:", "")[:8]
             name = f"{self._display_name[:20]}-{short}.{MDNS_SERVICE_TYPE}"
@@ -98,6 +100,7 @@ class MdnsBrowser:
     async def _handle_change(self, zeroconf, service_type, name, state_change) -> None:
         try:
             from zeroconf import ServiceStateChange
+
             if state_change in (ServiceStateChange.Added, ServiceStateChange.Updated):
                 info = await zeroconf.async_get_service_info(service_type, name)
                 if info:
@@ -110,6 +113,7 @@ class MdnsBrowser:
                     if not node_id:
                         return
                     import socket
+
                     addresses = [socket.inet_ntoa(a) for a in info.addresses]
                     host = addresses[0] if addresses else "127.0.0.1"
                     record = PeerRecord(

hearthnet/discovery/peers.py

@@ -1,4 +1,4 @@
-"""M02 - Peer discovery: PeerRegistry.
+"""M02 - Peer discovery: PeerRegistry.
 
 Spec: docs/M02-discovery.md §3.1
 Impl-ref: impl_ref.md §6
@@ -6,12 +6,14 @@ Impl-ref: impl_ref.md §6
 Holds PeerRecord entries discovered via mDNS or UDP multicast.
 Async subscribe() notifies bus and UI on peer changes.
 """
+
 from __future__ import annotations
 
 import asyncio
 import time
+from collections.abc import AsyncIterator
 from dataclasses import dataclass, field
-from typing import Any, AsyncIterator
+from typing import Any
 
 from hearthnet.types import CommunityID, Endpoint, NodeID, Profile
 
@@ -94,15 +96,22 @@ class PeerRegistry:
     def prune_stale_seconds(self) -> int:
         from hearthnet.constants import PEER_PRUNE_AGGRESSIVE_SECONDS, PEER_PRUNE_NORMAL_SECONDS
 
-        return PEER_PRUNE_AGGRESSIVE_SECONDS if self._pruning_aggressive else PEER_PRUNE_NORMAL_SECONDS
+        return (
+            PEER_PRUNE_AGGRESSIVE_SECONDS if self._pruning_aggressive else PEER_PRUNE_NORMAL_SECONDS
+        )
 
     def prune_stale(self, max_age_seconds: int | None = None) -> int:
         """Remove peers whose last_seen is beyond the prune threshold."""
         from hearthnet.constants import PEER_PRUNE_AGGRESSIVE_SECONDS, PEER_PRUNE_NORMAL_SECONDS
+
         if max_age_seconds is not None:
             threshold = max_age_seconds
         else:
-            threshold = PEER_PRUNE_AGGRESSIVE_SECONDS if self._pruning_aggressive else PEER_PRUNE_NORMAL_SECONDS
+            threshold = (
+                PEER_PRUNE_AGGRESSIVE_SECONDS
+                if self._pruning_aggressive
+                else PEER_PRUNE_NORMAL_SECONDS
+            )
         now = time.monotonic()
         stale = [nid for nid, peer in self._peers.items() if now - peer.last_seen > threshold]
         for nid in stale:
@@ -137,4 +146,3 @@ class PeerRegistry:
                 q.put_nowait(event)
             except asyncio.QueueFull:
                 pass
-

hearthnet/discovery/udp.py

@@ -63,14 +63,17 @@ class UdpAnnouncer:
     async def _announce_once(self) -> None:
         try:
             import socket
+
             short_id = self._node_id[8:20] if len(self._node_id) > 8 else self._node_id
-            payload = json.dumps({
-                "v": 1,
-                "node": short_id,
-                "community": self._community_id[:20],
-                "port": self._port,
-                "caps": self._caps[:10],
-            }).encode()
+            payload = json.dumps(
+                {
+                    "v": 1,
+                    "node": short_id,
+                    "community": self._community_id[:20],
+                    "port": self._port,
+                    "caps": self._caps[:10],
+                }
+            ).encode()
             if len(payload) > 1024:
                 payload = payload[:1024]
             sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
@@ -112,6 +115,7 @@ class UdpListener:
     async def _listen_loop(self) -> None:
         import socket
         import struct
+
         try:
             sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
             sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

hearthnet/distributed_inference/__init__.py

@@ -3,9 +3,10 @@
 Gated by config.research.distributed_inference = True.
 Layer-shards an LLM across multiple LAN nodes (Petals-style).
 """
+
 from __future__ import annotations
 
-from hearthnet.distributed_inference.shard import ShardDescriptor, ShardServer
 from hearthnet.distributed_inference.pipeline import Pipeline, PipelineOrchestrator
+from hearthnet.distributed_inference.shard import ShardDescriptor, ShardServer
 
-__all__ = ["ShardDescriptor", "ShardServer", "Pipeline", "PipelineOrchestrator"]
+__all__ = ["Pipeline", "PipelineOrchestrator", "ShardDescriptor", "ShardServer"]

hearthnet/distributed_inference/pipeline.py

@@ -1,4 +1,5 @@
 """Pipeline orchestrator for distributed inference (M26 — experimental)."""
+
 from __future__ import annotations
 
 import time
@@ -10,11 +11,12 @@ from hearthnet.distributed_inference.shard import ShardDescriptor
 @dataclass
 class Pipeline:
     """A planned pipeline: ordered list of shards covering layers 0..N."""
+
     pipeline_id: str
     model_id: str
     shards: list[ShardDescriptor]
     established_at: float = field(default_factory=time.time)
-    status: str = "planned"   # "planned" | "active" | "failed" | "done"
+    status: str = "planned"  # "planned" | "active" | "failed" | "done"
 
     @property
     def is_complete(self) -> bool:
@@ -50,6 +52,7 @@ class PipelineOrchestrator:
     def plan(self, model_id: str, available_shards: list[ShardDescriptor]) -> Pipeline | None:
         """Choose a minimal set of shards that covers layers 0..N continuously."""
         import uuid
+
         model_shards = [s for s in available_shards if s.model_id == model_id]
         if not model_shards:
             return None

hearthnet/distributed_inference/shard.py

@@ -1,7 +1,7 @@
 """Shard descriptors and server for distributed inference (M26 — experimental)."""
+
 from __future__ import annotations
 
-import asyncio
 import time
 from dataclasses import dataclass, field
 from typing import Any
@@ -12,13 +12,14 @@ ShardID = str
 @dataclass(frozen=True)
 class ShardDescriptor:
     """Describes one contiguous layer range hosted by a node."""
-    shard_id: ShardID          # "<model_id>:<lo>-<hi>"
+
+    shard_id: ShardID  # "<model_id>:<lo>-<hi>"
     model_id: str
     layer_lo: int
-    layer_hi: int              # inclusive
+    layer_hi: int  # inclusive
     node_id: str
     endpoint: str
-    dtype: str = "float16"     # "float16" | "bfloat16" | "int8"
+    dtype: str = "float16"  # "float16" | "bfloat16" | "int8"
     advertised_at: float = field(default_factory=time.time)
 
     @property
@@ -52,8 +53,7 @@ class ShardServer:
             import torch  # noqa: F401
         except ImportError as exc:
             raise ImportError(
-                "PyTorch is required for distributed inference. "
-                "Install: pip install torch"
+                "PyTorch is required for distributed inference. Install: pip install torch"
             ) from exc
         # Actual weight loading would go here; placeholder for the research prototype.
         self._loaded = True

hearthnet/emergency/detector.py

@@ -1,4 +1,4 @@
-"""M09 - Emergency Mode Detector.
+"""M09 - Emergency Mode Detector.
 
 Spec: docs/M09-emergency.md §3.2
 Impl-ref: impl_ref.md §14
@@ -7,6 +7,7 @@ Probes DNS+HTTP every EMERGENCY_PROBE_INTERVAL_ONLINE seconds.
 Debounce: EMERGENCY_TRANSITION_DEBOUNCE_SECONDS.
 On offline: deregisters capabilities with requires_internet=True.
 """
+
 from __future__ import annotations
 
 import asyncio
@@ -81,14 +82,15 @@ class Detector:
 
     async def _probe_all(self) -> dict[str, bool]:
         tasks = {
-            target: asyncio.create_task(self._probe_one(target))
-            for target in self._probe_targets
+            target: asyncio.create_task(self._probe_one(target)) for target in self._probe_targets
         }
         results: dict[str, bool] = {}
         for target, task in tasks.items():
             try:
-                results[target] = await asyncio.wait_for(task, timeout=EMERGENCY_PROBE_TIMEOUT_SECONDS)
-            except (asyncio.TimeoutError, Exception):
+                results[target] = await asyncio.wait_for(
+                    task, timeout=EMERGENCY_PROBE_TIMEOUT_SECONDS
+                )
+            except (TimeoutError, Exception):
                 results[target] = False
         return results
 
@@ -171,4 +173,3 @@ class Detector:
             if self._peers is not None:
                 self._peers.set_pruning_aggressive(False)
         return state
-

hearthnet/emergency/state.py

@@ -2,8 +2,9 @@ from __future__ import annotations
 
 import asyncio
 import time
+from collections.abc import AsyncIterator
 from dataclasses import dataclass
-from typing import AsyncIterator, Literal
+from typing import Literal
 
 Mode = Literal["online", "degraded", "offline"]
 

hearthnet/events/__init__.py

@@ -9,19 +9,19 @@ from .types import Event, EventType, new_ulid
 
 __all__ = [
     "Event",
-    "EventType",
     "EventLog",
     "EventLogError",
+    "EventType",
+    "HeadsReport",
     "LamportClock",
-    "ReplayEngine",
     "MaterialisedView",
-    "SnapshotStore",
+    "ReplayEngine",
     "Snapshot",
-    "build_snapshot",
-    "restore_from_snapshot",
+    "SnapshotStore",
     "SyncClient",
-    "SyncServer",
-    "HeadsReport",
     "SyncResult",
+    "SyncServer",
+    "build_snapshot",
     "new_ulid",
+    "restore_from_snapshot",
 ]

hearthnet/events/log.py

@@ -1,4 +1,4 @@
-"""X02 - Event log (SQLite WAL).
+"""X02 - Event log (SQLite WAL).
 
 Spec: docs/X02-events.md §3.3
 Impl-ref: impl_ref.md §3
@@ -7,6 +7,7 @@ All community events signed with author Ed25519 key.
 Lamport clock enforces causal ordering.
 ReplayEngine drives materialised views (marketplace, chat).
 """
+
 from __future__ import annotations
 
 import asyncio
@@ -14,7 +15,7 @@ import json
 import sqlite3
 import threading
 from collections.abc import AsyncIterator
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any
 
@@ -52,7 +53,7 @@ CREATE TABLE IF NOT EXISTS clock (
 
 
 def _now_utc() -> str:
-    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f") + "Z"
+    return datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%S.%f") + "Z"
 
 
 def _row_to_event(row: tuple[Any, ...]) -> Event:
@@ -126,7 +127,11 @@ def _verify(event: Event, kp_store: Any) -> bool:
             import base64
 
             prefix = "ed25519:"
-            b64 = event.signature[len(prefix) :] if event.signature.startswith(prefix) else event.signature
+            b64 = (
+                event.signature[len(prefix) :]
+                if event.signature.startswith(prefix)
+                else event.signature
+            )
             # pad
             padding = 4 - len(b64) % 4
             if padding != 4:
@@ -418,4 +423,3 @@ class EventLog:
                     q.put_nowait(event)
                 except asyncio.QueueFull:
                     pass
-

hearthnet/events/snapshot.py

@@ -4,7 +4,7 @@ import base64
 import json
 import os
 from dataclasses import dataclass
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
@@ -17,7 +17,7 @@ _SCHEMA_VERSION = 1
 
 
 def _now_utc() -> str:
-    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f") + "Z"
+    return datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%S.%f") + "Z"
 
 
 def _sign_snapshot(data: bytes, kp: Any) -> str:
@@ -33,14 +33,18 @@ def _sign_snapshot(data: bytes, kp: Any) -> str:
     return "ed25519:" + base64.urlsafe_b64encode(sig_bytes).rstrip(b"=").decode()
 
 
-def _verify_snapshot(snap: "Snapshot", kp_store: Any) -> bool:
+def _verify_snapshot(snap: Snapshot, kp_store: Any) -> bool:
     if kp_store is None or not snap.signature:
         return True
     raw = _canonical_snap_bytes(snap)
     if hasattr(kp_store, "verify"):
         try:
             prefix = "ed25519:"
-            b64 = snap.signature[len(prefix) :] if snap.signature.startswith(prefix) else snap.signature
+            b64 = (
+                snap.signature[len(prefix) :]
+                if snap.signature.startswith(prefix)
+                else snap.signature
+            )
             padding = 4 - len(b64) % 4
             if padding != 4:
                 b64 += "=" * padding
@@ -51,7 +55,7 @@ def _verify_snapshot(snap: "Snapshot", kp_store: Any) -> bool:
     return True
 
 
-def _canonical_snap_bytes(snap: "Snapshot") -> bytes:
+def _canonical_snap_bytes(snap: Snapshot) -> bytes:
     obj = {
         "schema_version": snap.schema_version,
         "community_id": snap.community_id,
@@ -68,7 +72,7 @@ class Snapshot:
     schema_version: int
     community_id: str
     at_lamport: int
-    views: dict[str, dict]   # view_name -> state dict
+    views: dict[str, dict]  # view_name -> state dict
     issued_at: str
     author: str
     signature: str

hearthnet/events/sync.py

@@ -168,9 +168,7 @@ class SyncServer:
                 )
 
         # Events the requesting peer is missing
-        missing_for_peer = [
-            _event_to_dict(e) for e in self._log.since(peer_head + 1)
-        ]
+        missing_for_peer = [_event_to_dict(e) for e in self._log.since(peer_head + 1)]
 
         return {
             "accepted": accepted,

hearthnet/events/types.py

@@ -46,12 +46,12 @@ def new_ulid() -> str:
 
 @dataclass(frozen=True)
 class Event:
-    schema_version: int       # always 1
-    event_id: str             # ULID
+    schema_version: int  # always 1
+    event_id: str  # ULID
     event_type: EventType
     community_id: str
-    author: str               # full node_id
+    author: str  # full node_id
     lamport: int
     payload: dict[str, Any]
-    issued_at: str            # RFC 3339 UTC
-    signature: str            # "ed25519:<b64url>" or ""
+    issued_at: str  # RFC 3339 UTC
+    signature: str  # "ed25519:<b64url>" or ""

hearthnet/evidence/__init__.py

@@ -1,6 +1,7 @@
 """M30 — Evidence Graph package (experimental, Phase 3)."""
+
 from __future__ import annotations
 
-from hearthnet.evidence.store import Claim, ClaimID, ClaimSource, ClaimStore, Attestation, Dispute
+from hearthnet.evidence.store import Attestation, Claim, ClaimID, ClaimSource, ClaimStore, Dispute
 
-__all__ = ["Claim", "ClaimID", "ClaimSource", "ClaimStore", "Attestation", "Dispute"]
+__all__ = ["Attestation", "Claim", "ClaimID", "ClaimSource", "ClaimStore", "Dispute"]

hearthnet/evidence/store.py

@@ -4,10 +4,10 @@ Content-addressed claim graph alongside the event log.
 Events record what happened; claims record what is believed and by whom.
 Gated by config.research.evidence_graph = True.
 """
+
 from __future__ import annotations
 
 import hashlib
-import json
 import time
 import uuid
 from dataclasses import dataclass, field
@@ -20,7 +20,7 @@ SourceID = NewType("SourceID", str)
 @dataclass(frozen=True)
 class ClaimSource:
     source_id: SourceID
-    source_type: str            # "event" | "external" | "ebkh" | "manual"
+    source_type: str  # "event" | "external" | "ebkh" | "manual"
     url: str | None = None
     retrieved_at: float | None = None
     reliability_score: float = 1.0
@@ -29,11 +29,12 @@ class ClaimSource:
 @dataclass(frozen=True)
 class Claim:
     """An assertion by a node about some fact, with provenance."""
+
     claim_id: ClaimID
-    subject: str                # what the claim is about (URI or free text)
-    predicate: str              # what is being claimed
-    object_: str                # the claimed value
-    asserted_by: str            # NodeID of the asserting node
+    subject: str  # what the claim is about (URI or free text)
+    predicate: str  # what is being claimed
+    object_: str  # the claimed value
+    asserted_by: str  # NodeID of the asserting node
     sources: tuple[ClaimSource, ...]
     community_id: str
     asserted_at: float = field(default_factory=time.time)
@@ -49,6 +50,7 @@ class Claim:
 @dataclass(frozen=True)
 class Attestation:
     """A second node vouches for a claim."""
+
     claim_id: ClaimID
     attested_by: str
     attested_at: float = field(default_factory=time.time)
@@ -58,6 +60,7 @@ class Attestation:
 @dataclass(frozen=True)
 class Dispute:
     """A node disputes a claim."""
+
     claim_id: ClaimID
     disputed_by: str
     reason: str
@@ -101,7 +104,9 @@ class ClaimStore:
     def is_disputed(self, claim_id: ClaimID) -> bool:
         return bool(self._disputes.get(claim_id))
 
-    def import_ebkh_record(self, record: dict[str, Any], asserted_by: str, community_id: str) -> ClaimID:
+    def import_ebkh_record(
+        self, record: dict[str, Any], asserted_by: str, community_id: str
+    ) -> ClaimID:
         """Import a record from Christof's EBKH system as a Claim.
 
         Expects record to have at minimum: subject, predicate, object, source_url.

hearthnet/federation/manifest.py

@@ -1,4 +1,5 @@
 """Federation manifest builder and verifier (M14)."""
+
 from __future__ import annotations
 
 import base64
@@ -44,14 +45,14 @@ class FederationManifest:
     community_a_name: str
     community_b_id: str
     community_b_name: str
-    scope_a_to_b: FederationScope   # what A grants B
-    scope_b_to_a: FederationScope   # what B grants A
-    sig_a: str                       # Ed25519 sig from anchor of community A
-    sig_b: str                       # Ed25519 sig from anchor of community B
-    co_signers_a: list[str]          # additional anchor signatures from community A
-    co_signers_b: list[str]          # additional anchor signatures from community B
-    created_at: int                  # unix seconds
-    expires_at: int                  # unix seconds
+    scope_a_to_b: FederationScope  # what A grants B
+    scope_b_to_a: FederationScope  # what B grants A
+    sig_a: str  # Ed25519 sig from anchor of community A
+    sig_b: str  # Ed25519 sig from anchor of community B
+    co_signers_a: list[str]  # additional anchor signatures from community A
+    co_signers_b: list[str]  # additional anchor signatures from community B
+    created_at: int  # unix seconds
+    expires_at: int  # unix seconds
     bootstrap_endpoints_a: list[str]
     bootstrap_endpoints_b: list[str]
 
@@ -64,14 +65,14 @@ class FederationManifest:
 class FederationProposal:
     """A draft federation proposal from community A to community B."""
 
-    community_a: str              # community_id of proposer
-    community_b: str              # community_id of target
-    scope_a: FederationScope      # scope A proposes to grant B
-    scope_b: FederationScope      # scope A requests from B
-    bootstrap_a: list[str]        # endpoints for community A
-    bootstrap_b: list[str]        # expected endpoints for community B
-    proposed_at: int              # unix seconds
-    proposer_sig: str             # Ed25519 sig over the proposal body by an anchor of A
+    community_a: str  # community_id of proposer
+    community_b: str  # community_id of target
+    scope_a: FederationScope  # scope A proposes to grant B
+    scope_b: FederationScope  # scope A requests from B
+    bootstrap_a: list[str]  # endpoints for community A
+    bootstrap_b: list[str]  # expected endpoints for community B
+    proposed_at: int  # unix seconds
+    proposer_sig: str  # Ed25519 sig over the proposal body by an anchor of A
 
 
 # ---------------------------------------------------------------------------

hearthnet/federation/peering.py

@@ -1,4 +1,5 @@
 """Cross-community peering store and HTTP client (M14)."""
+
 from __future__ import annotations
 
 import json

hearthnet/federation/service.py

@@ -1,4 +1,5 @@
 """FederationService — registers federation.* capabilities on the bus (M14)."""
+
 from __future__ import annotations
 
 from typing import Any
@@ -55,10 +56,11 @@ class FederationService:
             ("federation.peer.add", "1.0", self._handle_add),
             ("federation.peer.remove", "1.0", self._handle_remove),
         ]
-        for name, version, handler in descriptors:
+        for name, version_str, handler in descriptors:
+            major, minor = map(int, version_str.split("."))
             desc = CapabilityDescriptor(
                 name=name,
-                version=version,
+                version=(major, minor),
                 stability="stable",
                 params={},
                 max_concurrent=2,
@@ -87,16 +89,18 @@ class FederationService:
                 peer_id = m.community_a_id
                 peer_name = m.community_a_name
                 scope = m.scope_a_to_b
-            peers.append({
-                "community_id": peer_id,
-                "community_name": peer_name,
-                "federation_id": m.federation_id,
-                "scope": {
-                    "capabilities": list(scope.capabilities),
-                    "data_visibility": scope.data_visibility,
-                },
-                "expires_at": m.expires_at,
-            })
+            peers.append(
+                {
+                    "community_id": peer_id,
+                    "community_name": peer_name,
+                    "federation_id": m.federation_id,
+                    "scope": {
+                        "capabilities": list(scope.capabilities),
+                        "data_visibility": scope.data_visibility,
+                    },
+                    "expires_at": m.expires_at,
+                }
+            )
         return {"peers": peers}
 
     def _handle_add(self, params: dict) -> dict:

hearthnet/fedlearn/__init__.py

@@ -1,6 +1,7 @@
 """M28 — Federated Learning package (experimental, Phase 3)."""
+
 from __future__ import annotations
 
-from hearthnet.fedlearn.coordinator import FedLearnCoordinator, RoundManifest, ParticipantSubmission
+from hearthnet.fedlearn.coordinator import FedLearnCoordinator, ParticipantSubmission, RoundManifest
 
-__all__ = ["FedLearnCoordinator", "RoundManifest", "ParticipantSubmission"]
+__all__ = ["FedLearnCoordinator", "ParticipantSubmission", "RoundManifest"]

hearthnet/fedlearn/coordinator.py

@@ -4,6 +4,7 @@ FedAvg on LoRA adapter weight deltas. Each node trains locally;
 only adapter deltas (not raw data or full weights) are shared.
 Gated by config.research.federated_learning = True.
 """
+
 from __future__ import annotations
 
 import time
@@ -17,6 +18,7 @@ RoundID = NewType("RoundID", str)
 @dataclass(frozen=True)
 class RoundManifest:
     """Describes a federated learning round."""
+
     round_id: RoundID
     base_model_id: str
     coordinator_node_id: str
@@ -35,7 +37,7 @@ class RoundManifest:
 class ParticipantSubmission:
     round_id: RoundID
     participant_node_id: str
-    delta_bytes: bytes          # serialised LoRA state dict subset (safetensors format)
+    delta_bytes: bytes  # serialised LoRA state dict subset (safetensors format)
     num_samples: int
     submitted_at: float = field(default_factory=time.time)
     participant_sig: bytes = b""

hearthnet/identity/keys.py

@@ -1,4 +1,4 @@
-"""M01 - Node identity: Ed25519 key management.
+"""M01 - Node identity: Ed25519 key management.
 
 Spec: docs/M01-identity.md §3.1
 Impl-ref: impl_ref.md §5
@@ -6,6 +6,7 @@ Impl-ref: impl_ref.md §5
 Keys stored in keys_dir (default ~/.hearthnet/keys/).
 Sign/verify via PyNaCl Ed25519. canonical_json() for deterministic signing.
 """
+
 from __future__ import annotations
 
 import base64
@@ -70,16 +71,15 @@ def full_node_id(verify_key_bytes: bytes) -> str:
 def parse_node_id(node_id: str) -> bytes:
     """Decode a full node_id to 32 bytes. Short form raises ValueError."""
     import re
+
     if not node_id.startswith("ed25519:"):
         raise ValueError(f"node_id must start with 'ed25519:': {node_id!r}")
-    payload = node_id[len("ed25519:"):]
+    payload = node_id[len("ed25519:") :]
     # Short form is b32-with-dashes: groups of [A-Z2-7=]{1,4} separated by '-'
     # e.g. "SQ2J-OH7E-LCMU-Y===" — always shorter than 30 chars and matches this pattern.
     # Full form is 43-char base64url (no '=' padding).
     if re.fullmatch(r"[A-Z2-7=]{1,4}(-[A-Z2-7=]{1,4}){1,}", payload):
-        raise ValueError(
-            "Short node IDs cannot be decoded to raw bytes; use full form."
-        )
+        raise ValueError("Short node IDs cannot be decoded to raw bytes; use full form.")
     # Add padding back for base64url decoding
     padded = payload + "=" * (4 - len(payload) % 4 if len(payload) % 4 != 0 else 0)
     raw = base64.urlsafe_b64decode(padded)
@@ -181,7 +181,7 @@ def verify_payload(payload: dict, vk: Any) -> bool:  # vk: nacl.signing.VerifyKe
     raw_sig = payload.get("signature", "")
     if not raw_sig.startswith("ed25519:"):
         raise IdentityError("verify_failed", reason="signature field missing or malformed")
-    sig_b64 = raw_sig[len("ed25519:"):]
+    sig_b64 = raw_sig[len("ed25519:") :]
     padding = 4 - len(sig_b64) % 4
     if padding != 4:
         sig_b64 += "=" * padding
@@ -243,9 +243,7 @@ def save(kp: KeyPair, keys_dir: Path) -> None:
     pub_path = keys_dir / "device.pub"
     # Write private key (raw 32-byte seed, base64url encoded)
     sk_bytes = bytes(kp.signing_key)
-    priv_path.write_bytes(
-        base64.urlsafe_b64encode(sk_bytes).rstrip(b"=") + b"\n"
-    )
+    priv_path.write_bytes(base64.urlsafe_b64encode(sk_bytes).rstrip(b"=") + b"\n")
     # Restrict permissions on POSIX
     try:
         os.chmod(priv_path, stat.S_IRUSR | stat.S_IWUSR)  # 0600
@@ -253,9 +251,7 @@ def save(kp: KeyPair, keys_dir: Path) -> None:
         pass  # Windows: chmod semantics differ; best-effort
     # Write public key
     vk_bytes = bytes(kp.verify_key)
-    pub_path.write_bytes(
-        base64.urlsafe_b64encode(vk_bytes).rstrip(b"=") + b"\n"
-    )
+    pub_path.write_bytes(base64.urlsafe_b64encode(vk_bytes).rstrip(b"=") + b"\n")
 
 
 def load(keys_dir: Path) -> KeyPair:
@@ -305,4 +301,3 @@ def load_or_generate(keys_dir: Path) -> KeyPair:
     kp = generate()
     save(kp, keys_dir)
     return kp
-

hearthnet/identity/manifest.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from datetime import datetime, timedelta, timezone
-from typing import Any, Optional
+from datetime import UTC, datetime, timedelta
+from typing import Any
 
 from hearthnet.identity.keys import (
     IdentityError,
@@ -70,14 +70,30 @@ _NODE_MANIFEST_TTL_SECONDS = 30
 _COMMUNITY_MANIFEST_TTL_SECONDS = 86400
 
 _REQUIRED_NODE_FIELDS = {
-    "version", "node_id", "display_name", "community_id", "profile",
-    "endpoints", "capabilities", "issued_at", "expires_at", "contract_version",
+    "version",
+    "node_id",
+    "display_name",
+    "community_id",
+    "profile",
+    "endpoints",
+    "capabilities",
+    "issued_at",
+    "expires_at",
+    "contract_version",
     "signature",
 }
 
 _REQUIRED_COMMUNITY_FIELDS = {
-    "version", "community_id", "name", "root_node_id", "members", "policy",
-    "issued_at", "expires_at", "contract_version", "signature",
+    "version",
+    "community_id",
+    "name",
+    "root_node_id",
+    "members",
+    "policy",
+    "issued_at",
+    "expires_at",
+    "contract_version",
+    "signature",
 }
 
 
@@ -87,11 +103,11 @@ def _parse_rfc3339(s: str) -> datetime:
     s = s.rstrip("Z")
     if "+" in s:
         s = s[: s.index("+")]
-    return datetime.fromisoformat(s).replace(tzinfo=timezone.utc)
+    return datetime.fromisoformat(s).replace(tzinfo=UTC)
 
 
 def _now_utc() -> datetime:
-    return datetime.now(timezone.utc)
+    return datetime.now(UTC)
 
 
 def _rfc3339(dt: datetime) -> str:
@@ -129,8 +145,7 @@ class NodeManifest:
             "community_id": self.community_id,
             "profile": self.profile,
             "endpoints": [
-                {"transport": e.transport, "host": e.host, "port": e.port}
-                for e in self.endpoints
+                {"transport": e.transport, "host": e.host, "port": e.port} for e in self.endpoints
             ],
             "capabilities": [
                 {
@@ -217,8 +232,7 @@ def build_node_manifest(
         "community_id": community_id,
         "profile": profile,
         "endpoints": [
-            {"transport": e.transport, "host": e.host, "port": e.port}
-            for e in endpoints
+            {"transport": e.transport, "host": e.host, "port": e.port} for e in endpoints
         ],
         "capabilities": [
             {

hearthnet/identity/tokens.py

@@ -2,6 +2,7 @@
 
 Token format: hntoken://v1/<b64url(header)>.<b64url(payload)>.<b64url(sig)>
 """
+
 from __future__ import annotations
 
 import base64
@@ -40,14 +41,14 @@ class TokenScope:
 class CapabilityToken:
     """A signed Ed25519 capability token."""
 
-    iss: str        # issuer node_id (full form "ed25519:…")
-    sub: str        # subject node_id or "*" for bearer token
-    aud: str        # audience community_id or ""
-    iat: int        # issued-at unix seconds
-    exp: int        # expires-at unix seconds
-    nbf: int        # not-before unix seconds
+    iss: str  # issuer node_id (full form "ed25519:…")
+    sub: str  # subject node_id or "*" for bearer token
+    aud: str  # audience community_id or ""
+    iat: int  # issued-at unix seconds
+    exp: int  # expires-at unix seconds
+    nbf: int  # not-before unix seconds
     scope: TokenScope
-    jti: str        # unique token ID (ULID)
+    jti: str  # unique token ID (ULID)
     issued_via: str  # "federation"|"onboarding"|"manual"|"relay"
 
 
@@ -170,7 +171,7 @@ def decode_token(text: str) -> CapabilityToken:
     """Parse an hntoken:// string. Validates structure; does NOT verify the signature."""
     if not text.startswith(_TOKEN_SCHEME):
         raise TokenError(f"Not a HearthNet token (expected 'hntoken://v1/'): {text[:40]!r}")
-    body = text[len(_TOKEN_SCHEME):]
+    body = text[len(_TOKEN_SCHEME) :]
     parts = body.split(".")
     if len(parts) != 3:
         raise TokenError("Token must have exactly 3 dot-separated parts")

hearthnet/lora/__init__.py

@@ -1,6 +1,12 @@
 """LoRa hardware beacons package (experimental, Phase 3 — M29)."""
+
 from __future__ import annotations
 
-from hearthnet.lora.service import LoraBeacon, LoraBeaconService, decode_beacon_frame, encode_beacon_frame
+from hearthnet.lora.service import (
+    LoraBeacon,
+    LoraBeaconService,
+    decode_beacon_frame,
+    encode_beacon_frame,
+)
 
 __all__ = ["LoraBeacon", "LoraBeaconService", "decode_beacon_frame", "encode_beacon_frame"]

hearthnet/lora/service.py

@@ -4,6 +4,7 @@
 No AI traffic, no chat, no file transfer — only 32-byte heartbeat frames.
 Gated by config.research.lora_beacons = True.
 """
+
 from __future__ import annotations
 
 import struct
@@ -28,10 +29,10 @@ FRAME_SIZE = 32
 class LoraBeacon:
     beacon_id: LoraBeaconID
     device_id: LoraDeviceID
-    node_id_hash: bytes         # 8 bytes
+    node_id_hash: bytes  # 8 bytes
     sequence: int
-    flags: int                  # bit0=emergency, bit1=panic
-    rssi: int | None = None     # dBm, if available
+    flags: int  # bit0=emergency, bit1=panic
+    rssi: int | None = None  # dBm, if available
     received_at: float = field(default_factory=time.time)
 
     @property
@@ -46,6 +47,7 @@ class LoraBeacon:
 def encode_beacon_frame(node_id_full: str, sequence: int, flags: int = 0) -> bytes:
     """Encode a 32-byte LoRa beacon frame."""
     import hashlib
+
     node_hash = hashlib.sha256(node_id_full.encode()).digest()[:8]
     header = struct.pack(">4sI8sB", FRAME_MAGIC, sequence, node_hash, flags)
     return header + b"\x00" * (FRAME_SIZE - len(header))
@@ -94,6 +96,7 @@ class LoraBeaconService:
         """Write frame to serial LoRa hardware (stub — real impl needs pyserial)."""
         try:
             import serial  # type: ignore[import-untyped]
+
             with serial.Serial(self._serial_port, baudrate=9600, timeout=1) as ser:
                 ser.write(frame)
         except ImportError:

hearthnet/mobile/invite.py

@@ -4,6 +4,7 @@ Generates mobile-targeted invite deep links (``hnapp://``) and QR codes
 for the mobile native client (Flutter).  Builds on top of the Phase 1
 onboarding module (M13).
 """
+
 from __future__ import annotations
 
 import base64
@@ -11,8 +12,6 @@ import hashlib
 import json
 import time
 from dataclasses import dataclass, field
-from typing import Any
-
 
 # ---------------------------------------------------------------------------
 # Invite blob for mobile clients
@@ -77,11 +76,11 @@ class MobileInviteBlob:
         return hashlib.sha256(raw.encode()).hexdigest()[:16]
 
     @classmethod
-    def from_deep_link(cls, deep_link: str) -> "MobileInviteBlob":
+    def from_deep_link(cls, deep_link: str) -> MobileInviteBlob:
         """Parse a deep link produced by :meth:`to_deep_link`."""
         if not deep_link.startswith("hnapp://v1/"):
             raise ValueError(f"Not a valid hnapp:// deep link: {deep_link!r}")
-        b64 = deep_link[len("hnapp://v1/"):]
+        b64 = deep_link[len("hnapp://v1/") :]
         # Re-add padding
         padding = 4 - len(b64) % 4
         if padding != 4:

hearthnet/mobile/push_authority.py

@@ -8,12 +8,13 @@ The anchor-side service that mobile clients (Flutter) call to:
 Push delivery itself is *out of scope* for the local-first anchor — if the
 relay tier (M15) is configured the anchor forwards the notification there.
 """
+
 from __future__ import annotations
 
 import hashlib
 import time
 from dataclasses import dataclass, field
-from typing import Any, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:  # pragma: no cover
     from hearthnet.bus.router import Router
@@ -122,7 +123,7 @@ class MobilePushService:
     def __init__(
         self,
         relay_url: str | None = None,
-        bus: "Router | None" = None,
+        bus: Router | None = None,
     ) -> None:
         self._registry = PushTokenRegistry()
         self._relay_url = relay_url
@@ -160,7 +161,10 @@ class MobilePushService:
         token = str(inp.get("token", ""))
         platform = str(inp.get("platform", "unknown"))
         if not node_id or not token:
-            return {"output": {"error": "bad_request", "detail": "node_id and token required"}, "meta": {}}
+            return {
+                "output": {"error": "bad_request", "detail": "node_id and token required"},
+                "meta": {},
+            }
         entry = self._registry.register(node_id, token, platform)
         return {"output": {"status": "registered", "token_hash": entry.token_hash}, "meta": {}}
 

hearthnet/moe/__init__.py

@@ -1,4 +1,5 @@
 """M27 — MoE Expert Routing package (experimental, Phase 3)."""
+
 from __future__ import annotations
 
 from hearthnet.moe.router import ExpertDescriptor, ExpertRegistry, MoeRouter, RouteResult