"""Angriffsfaelle fuer die Abendkontrolle (abendkontrolle_wsl.py in WSL, abendkontrolle.py unter Windows). Koordinator-Werkzeug, nicht fuers Repo. Jeder Fall laeuft einzeln auf einer Wegwerfkopie, zuerst die Grundlinie; ohne Netz (--ohne-broker/--ohne-kerzen, Kalender und Journal aus Dateien, eine Ersatz- Auswertung fuer die Brokerzeile) und ohne Meldung (--ohne-meldung). Faelle an zwei Listenpositionen, wo die Reihenfolge zaehlen kann (AI/Regelwerk/pruefwerkzeuge.md, Abschnitt 3). Aufruf in WSL (Venv) und unter Windows: python abendkontrolle_angriffe.py Exit 0, wenn jeder Fall so ausgeht wie erwartet; sonst 1 mit der Liste der Abweichungen. """ import atexit import json import os import shutil import sqlite3 import subprocess import sys import tempfile from pathlib import Path HIER = Path(__file__).resolve().parent TAG = "2026-09-23" ECHTES_PROJEKT = Path("/mnt/d/Claude/Code Projekte/active - Trading Plattform") ECHTES_PROTOKOLL = ECHTES_PROJEKT / "artifacts" / "paper" / "2026-09-23T131023-paper.jsonl" KALENDER_TAG = [{"date": TAG, "open": "09:30", "close": "16:00"}] JOURNAL_GUT = ( "Ende: boersenschluss, Position 0, Orders 2, Killswitch aktiv, Exit 0\n" "trading-paper.service: Deactivated successfully.\n" ) DIENSTE_GUT = { "trading-dashboard.service": "active", "trading-paper.timer": "active", "trading-auswertung.timer": "active", } abweichungen: list[str] = [] # --- WSL-Teil ---------------------------------------------------------------------------------- def baue_projekt(wurzel: Path, killswitch: str | None = "aktiv") -> Path: projekt = wurzel / "projekt" (projekt / "artifacts" / "paper").mkdir(parents=True) (projekt / "data" / "paper" / "auswertungen").mkdir(parents=True) (projekt / "config").mkdir() # Die Auswertung importiert trading.geheimnisse aus dem Arbeitsverzeichnis. (projekt / "trading").symlink_to(ECHTES_PROJEKT / "trading") shutil.copyfile(ECHTES_PROTOKOLL, projekt / "artifacts" / "paper" / f"{TAG}T131023-paper.jsonl") (projekt / "data" / "paper" / "auswertungen" / f"{TAG}.md").write_text("# Bericht\n", encoding="utf-8") with sqlite3.connect(projekt / "data" / "registry.db") as db: db.execute("CREATE TABLE killswitch_zustand (id INTEGER PRIMARY KEY, zustand TEXT, seit TEXT, ausloeser TEXT)") if killswitch is not None: db.execute("INSERT INTO killswitch_zustand VALUES (1, ?, '2026-09-23T13:31:00+00:00', 'pascal')", (killswitch,)) (wurzel / "kalender.json").write_text(json.dumps(KALENDER_TAG), encoding="utf-8") (wurzel / "journal.txt").write_text(JOURNAL_GUT, encoding="utf-8") (wurzel / "dienste.json").write_text(json.dumps(DIENSTE_GUT), encoding="utf-8") return projekt def fahre(wurzel: Path, projekt: Path, extra_env: dict | None = None, tag: str = TAG, meldung: bool = False) -> dict: befehl = [ sys.executable, str(HIER / "abendkontrolle_wsl.py"), "--tag", tag, "--projekt", str(projekt), "--kalender", str(wurzel / "kalender.json"), "--journal", str(wurzel / "journal.txt"), "--dienste", str(wurzel / "dienste.json"), "--ohne-kerzen", ] if not meldung: befehl.append("--ohne-meldung") # Mit der Ersatz-Auswertung darf die Brokerzeile geprueft werden: Der Ersatz geht nicht ans Netz. if not (extra_env and "ABENDKONTROLLE_AUSWERTUNG" in extra_env): befehl.append("--ohne-broker") env = {k: v for k, v in os.environ.items() if k != "ABENDKONTROLLE_AUSWERTUNG"} env.update(extra_env or {}) lauf = subprocess.run(befehl, capture_output=True, text=True, env=env, timeout=300) try: ergebnis = json.loads(lauf.stdout.strip().splitlines()[-1]) except (IndexError, json.JSONDecodeError): return {"befunde": [f"KEINE JSON-AUSGABE exit {lauf.returncode}: {lauf.stderr[-300:]}"], "exit": lauf.returncode} ergebnis["_exit"] = lauf.returncode return ergebnis def erwarte(name: str, ergebnis: dict, *, befund: str | None, anzahl: int | None = None, exit_code: int = 0, auch: tuple = (), nicht: tuple = (), fakt=None) -> None: befunde = ergebnis.get("befunde", []) alles = " | ".join(befunde) ok = True if befund is None and befunde: ok = False if befund is not None and not any(befund in b for b in befunde): ok = False if any(teil not in alles for teil in auch) or any(teil in alles for teil in nicht): ok = False if anzahl is not None and len(befunde) != anzahl: ok = False if ergebnis.get("_exit", ergebnis.get("exit")) != exit_code: ok = False if fakt is not None: try: ok = ok and bool(fakt(ergebnis.get("fakten") or {}, ergebnis)) except Exception: ok = False zeile = f"{'OK ' if ok else 'FEHL'} {name}: {len(befunde)} Befund(e) {befunde[:3]} meldung={(ergebnis.get('fakten') or {}).get('meldung')}" print(zeile) if not ok: abweichungen.append(zeile) def wsl_faelle() -> None: def fall(name, vorbereiten, *, befund, anzahl=None, exit_code=0, env=None, tag=TAG, meldung=False, auch=(), nicht=(), fakt=None): with tempfile.TemporaryDirectory() as tmp: wurzel = Path(tmp) projekt = baue_projekt(wurzel) extra = vorbereiten(wurzel, projekt) umgebung = {**(env or {}), **(extra if isinstance(extra, dict) else {})} erwarte(name, fahre(wurzel, projekt, umgebung, tag, meldung), befund=befund, anzahl=anzahl, exit_code=exit_code, auch=auch, nicht=nicht, fakt=fakt) nichts = lambda w, p: None # noqa: E731 prot = lambda p: p / "artifacts" / "paper" / f"{TAG}T131023-paper.jsonl" # noqa: E731 def schreibe(pfad: Path, text: str) -> None: pfad.write_text(text, encoding="utf-8") def zeilen_aendern(p: Path, aendern) -> None: zeilen = prot(p).read_text(encoding="utf-8").splitlines() schreibe(prot(p), "\n".join(aendern(zeilen)) + "\n") fall("Grundlinie", nichts, befund=None, anzahl=0) # 1 Kalender # Ein Feiertag ohne Protokoll: kein Befund. Haelt die Kontrolle ihn faelschlich fuer einen Handelstag, # fehlt das Protokoll und es gibt einen -- so trennt der Fall "kein Handelstag" von "immer Handelstag". def feiertag(inhalt): def vorbereiten(w, p): schreibe(w / "kalender.json", inhalt) prot(p).unlink() return vorbereiten fall("Kalender leer (Feiertag, Wochenende)", feiertag("[]"), befund=None, anzahl=0) fall("Kalender nennt nur einen anderen Tag", feiertag(json.dumps([{"date": "2026-09-22"}])), befund=None, anzahl=0) fall("Kalender als Objekt", lambda w, p: schreibe(w / "kalender.json", "{}"), befund="Kalender in unerwarteter Form") fall("Kalender Eintrag ohne date, erste Position", lambda w, p: schreibe(w / "kalender.json", json.dumps([{"open": "09:30"}] + KALENDER_TAG)), befund="Kalender in unerwarteter Form") fall("Kalender Eintrag ohne date, letzte Position", lambda w, p: schreibe(w / "kalender.json", json.dumps(KALENDER_TAG + [{"date": 5}])), befund="Kalender in unerwarteter Form") fall("Kalender-Datei fehlt", lambda w, p: (w / "kalender.json").unlink(), befund="Kalender, und damit") fall("Kalender kein JSON", lambda w, p: schreibe(w / "kalender.json", ""), befund="Kalender, und damit") # 2 Protokoll fall("kein Protokoll", lambda w, p: prot(p).unlink(), befund="der Runner lief nicht") fall("nur Probeprotokoll", lambda w, p: prot(p).rename(prot(p).with_name(f"{TAG}T131023-probe.jsonl")), befund="der Runner lief nicht") # 6 Handel fall("nie aktiv", lambda w, p: zeilen_aendern(p, lambda z: [s.replace('"killswitch": "aktiv"', '"killswitch": "angehalten"') for s in z]), befund="Tag ohne Handel") fall("kaputte Zeile vorne", lambda w, p: zeilen_aendern(p, lambda z: [z[0], "{kaputt", *z[1:]]), befund="nicht lesbar") fall("kaputte Zeile hinten", lambda w, p: zeilen_aendern(p, lambda z: [*z, "[1, 2]"]), befund="nicht lesbar") # 3 Journal fall("Journal ohne Ende", lambda w, p: schreibe(w / "journal.txt", "gestartet\n"), befund="keine Zeile 'Ende") fall("Journal leer", lambda w, p: schreibe(w / "journal.txt", ""), befund="keine Zeile 'Ende") fall("Journal fehlt", lambda w, p: (w / "journal.txt").unlink(), befund="Journal nicht geprueft") fall("Exit 4", lambda w, p: schreibe(w / "journal.txt", JOURNAL_GUT.replace("Exit 0", "Exit 4")), befund="Exit 4") fall("Exit 4 im ersten von zwei Laeufen", lambda w, p: schreibe(w / "journal.txt", JOURNAL_GUT.replace("Exit 0", "Exit 4") + JOURNAL_GUT), befund="Lauf 1 von 2") fall("Exit 4 im letzten von zwei Laeufen", lambda w, p: schreibe(w / "journal.txt", JOURNAL_GUT + JOURNAL_GUT.replace("Exit 0", "Exit 4")), befund="Lauf 2 von 2") fall("Grund stoerung", lambda w, p: schreibe(w / "journal.txt", JOURNAL_GUT.replace("Ende: boersenschluss", "Ende: stoerung")), befund="nicht mit boersenschluss") fall("Position 10", lambda w, p: schreibe(w / "journal.txt", JOURNAL_GUT.replace("Position 0", "Position 10")), befund="Position 10") fall("Failed with result", lambda w, p: schreibe(w / "journal.txt", JOURNAL_GUT + "trading-paper.service: Failed with result 'exit-code'.\n"), befund="Failed with result") # 4 Auswertung fall("Orderzeile nicht gefuellt", lambda w, p: zeilen_aendern(p, lambda z: [s.replace('"status": "filled"', '"status": "canceled"', 1) if '"art": "order"' in s else s for s in z]), befund="nicht gefuellt") fall("Schlussposition 10 im Protokoll", lambda w, p: zeilen_aendern(p, lambda z: [s.replace('"position": 0', '"position": 10') if '"art": "ende"' in s else s for s in z]), befund="Schlussposition ungleich null") # 5 Broker (Ersatz-Auswertung, kein Netz) ersatz = HIER / "abendkontrolle_ersatz_auswertung.py" fall("Broker 2 offen", nichts, befund="2 offene Position", env={"ABENDKONTROLLE_AUSWERTUNG": str(ersatz), "ERSATZ_AUSGABE": "offene positionen beim broker jetzt: 2"}, ) fall("Broker 0 offen", nichts, befund=None, anzahl=0, env={"ABENDKONTROLLE_AUSWERTUNG": str(ersatz), "ERSATZ_AUSGABE": "offene positionen beim broker jetzt: 0"}) fall("Auswertung Exit 3", nichts, befund="Exit 3", env={"ABENDKONTROLLE_AUSWERTUNG": str(ersatz), "ERSATZ_AUSGABE": "VORAUSSETZUNG FEHLT: x", "ERSATZ_EXIT": "3"}) fall("Auswertung Kontowert in BEFUND wird maskiert", nichts, befund="kontowert [x]", env={"ABENDKONTROLLE_AUSWERTUNG": str(ersatz), "ERSATZ_AUSGABE": "BEFUND: kontowert 12345.67 zu tief"}) # 7 Bericht fall("Bericht fehlt", lambda w, p: (p / "data" / "paper" / "auswertungen" / f"{TAG}.md").unlink(), befund="Tagesbericht") # 8 Dienste fall("Dashboard inaktiv (erste Position)", lambda w, p: schreibe(w / "dienste.json", json.dumps({**DIENSTE_GUT, "trading-dashboard.service": "failed"})), befund="trading-dashboard.service ist nicht aktiv") fall("Auswertungs-Zeitgeber fehlt (letzte Position)", lambda w, p: schreibe(w / "dienste.json", json.dumps({k: v for k, v in DIENSTE_GUT.items() if "auswertung" not in k})), befund="trading-auswertung.timer ist nicht aktiv") fall("Dienste als Liste", lambda w, p: schreibe(w / "dienste.json", "[]"), befund="Dienste: Zustand nicht lesbar") # 9 Killswitch def killswitch(zustand): def vorbereiten(w, p): with sqlite3.connect(p / "data" / "registry.db") as db: if zustand is None: db.execute("DELETE FROM killswitch_zustand") else: db.execute("UPDATE killswitch_zustand SET zustand = ?", (zustand,)) return vorbereiten fall("Killswitch gesperrt", killswitch("gesperrt"), befund="gesperrt") fall("Killswitch ohne Zeile", killswitch(None), befund="kein Killswitch-Zustand") fall("Register fehlt", lambda w, p: (p / "data" / "registry.db").unlink(), befund="registry.db fehlt") # 3 Ende je Lauf: mittags abgebrochen, der zweite Lauf bleibt angehalten (Befund des Pruefers W2) def mittags_abgebrochen(w, p): zeilen = prot(p).read_text(encoding="utf-8").splitlines() takte = [z for z in zeilen if '"art": "takt"' in z] ende = json.loads(next(z for z in zeilen if '"art": "ende"' in z)) lauf1 = [zeilen[0], *takte[:30], json.dumps({**ende, "grund": "abbruch"})] lauf2 = [zeilen[0], *[z.replace('"killswitch": "aktiv"', '"killswitch": "angehalten"') for z in takte[30:]], json.dumps(ende)] schreibe(prot(p), "\n".join(lauf1) + "\n") schreibe(p / "artifacts" / "paper" / f"{TAG}T160000-paper.jsonl", "\n".join(lauf2) + "\n") schreibe(w / "journal.txt", JOURNAL_GUT.replace("Ende: boersenschluss", "Ende: abbruch") + JOURNAL_GUT) fall("mittags abgebrochen, danach angehalten", mittags_abgebrochen, befund="Lauf endete mit abbruch", auch=("Lauf 1 von 2) endete nicht mit boersenschluss",)) # Lauf nach Boersenschluss (WSL-Neustart abends): kein Befund (Befund des Pruefers W3) def nach_schluss(w, p): kopf = prot(p).read_text(encoding="utf-8").splitlines()[0] ende = {"art": "ende", "zeit": f"{TAG}T21:06:40+00:00", "grund": "wartezeit", "fehler": None, "position": 0, "orders": 0, "killswitch": "angehalten", "schritte": 0} schreibe(p / "artifacts" / "paper" / f"{TAG}T210500-paper.jsonl", kopf + "\n" + json.dumps(ende) + "\n") schreibe(w / "journal.txt", JOURNAL_GUT + "Ende: wartezeit, Position 0, Orders 0, Killswitch angehalten, Exit 3\n") fall("Lauf nach Boersenschluss (wartezeit, Exit 3)", nach_schluss, befund=None, anzahl=0) fall("nur ein Lauf mit wartezeit an einem Handelstag", lambda w, p: ( nach_schluss(w, p), prot(p).unlink(), schreibe(w / "journal.txt", "Ende: wartezeit, Position 0, Orders 0, Killswitch angehalten, Exit 3\n")), befund="keine Zeile 'Ende", auch=("kein Lauf des scharfen Runners in der Handelszeit",)) # 9 Killswitch: unbekannter Zustand, und eine Frage, die scheitert, haelt die anderen nicht auf fall("Killswitch unbekannter Zustand", killswitch("kaputt"), befund="unbekanntem Zustand") def register_ohne_tabelle(w, p): (p / "data" / "registry.db").unlink() sqlite3.connect(p / "data" / "registry.db").close() (p / "data" / "paper" / "auswertungen" / f"{TAG}.md").unlink() fall("Register ohne Tabelle, Bericht fehlt", register_ohne_tabelle, befund="Killswitch nicht geprueft", auch=("Tagesbericht",)) # Maske auch ohne Geldwort (Befund des Pruefers W4) fall("Maske ohne Geldwort", nichts, befund="Wert", env={"ABENDKONTROLLE_AUSWERTUNG": str(ersatz), "ERSATZ_AUSGABE": "BEFUND: Wert 100123.45 und 172.3456 und -4.56 USD\noffene positionen beim broker jetzt: 0"}, nicht=("100123", "172.3456", "4.56")) # Meldeweg (Befund des Pruefers B1): ein Fehlschlag darf nicht als "gesendet" stehen def mit_melder(port): def vorbereiten(w, p): text = (ECHTES_PROJEKT / "config" / "paper.toml").read_text(encoding="utf-8") anker = 'ntfy_url = "https://ntfy.sh"' if text.count(anker) != 1: raise RuntimeError("Anker ntfy_url fehlt in config/paper.toml") schreibe(p / "config" / "paper.toml", text.replace(anker, f'ntfy_url = "http://127.0.0.1:{port}"\nklartext_lokal = true')) schreibe(w / "secrets.toml", '[ntfy]\naktiv = true\nthema = "abendkontrolle-angriff"\n') (p / "data" / "paper" / "auswertungen" / f"{TAG}.md").unlink() # ein Befund, damit gemeldet wird return {"TRADING_GEHEIMNISSE": str(w / "secrets.toml")} return vorbereiten fall("Meldung scheitert (niemand hoert)", mit_melder(9), befund="Tagesbericht", meldung=True, fakt=lambda f, e: str(f.get("meldung", "")).startswith("nicht gesendet")) with tempfile.TemporaryDirectory() as tmp: mitschrift = Path(tmp) / "mitschrift.jsonl" port = 18765 server = subprocess.Popen([sys.executable, str(HIER / "ntfy_probe_server.py"), str(port), str(mitschrift)], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) try: import socket import time for _ in range(50): try: socket.create_connection(("127.0.0.1", port), timeout=0.2).close() break except OSError: time.sleep(0.1) fall("Meldung kommt an", mit_melder(port), befund="Tagesbericht", meldung=True, fakt=lambda f, e: f.get("meldung") == "gesendet" and "Abendkontrolle" in mitschrift.read_text(encoding="utf-8")) finally: server.terminate() server.wait(timeout=10) # Bedienfehler fall("Tag falsch", nichts, befund="abgebrochen", exit_code=2, tag="2026-13-40") # --- Windows-Teil -------------------------------------------------------------------------------- def abdichten(ak) -> list: """Sperrt die echten Wege von abendkontrolle.py fuer die Windows-Faelle (Plankritik DH, 2026-09-26). Die Faelle laufen mit --ohne-wsl; bricht ein Mutant diesen Schalter, liefe sonst der echte WSL-Teil gegen den echten Projektordner, und seit Paket DH ssh zum Docker-Host. wsl.exe und ssh.exe zeigen ins Leere, fahre_wsl und fahre_dockerhost schreiben jeden Aufruf mit und lehnen ab; jeder Aufruf ist eine Abweichung. """ gerufen = [] abdichten.erwartet = False def verboten(name): def weg(*argumente, **benannte): gerufen.append(name) zeile = f"FEHL echter Weg {name} gerufen: {argumente}" abweichungen.append(zeile) if not abdichten.erwartet: print(zeile) raise RuntimeError(f"echter Weg {name} in den Angriffsfaellen") weg.sperre = True return weg leer = Path(tempfile.mkdtemp(prefix="abendkontrolle-angriffe-kein-weg-")) atexit.register(shutil.rmtree, leer, True) # der leere Ordner bleibt nicht im Temp liegen ak.WSL = str(leer / "wsl.exe") ak.SSH = str(leer / "ssh.exe") ak.WSL_SKRIPT = "/nicht-vorhanden/abendkontrolle_wsl.py" ak.fahre_wsl = verboten("fahre_wsl") ak.fahre_dockerhost = verboten("fahre_dockerhost") return gerufen def windows_faelle() -> None: sys.path.insert(0, str(HIER)) import abendkontrolle as ak from datetime import datetime gerufen = abdichten(ak) # Die Abdichtung greift: Ohne --ohne-wsl nimmt main den WSL-Weg, und der muss als Abweichung # ankommen, nicht als Lauf. Die erwartete Abweichung wird danach wieder entfernt. vorher = len(abweichungen) abdichten.erwartet = True with tempfile.TemporaryDirectory() as tmp: (Path(tmp) / "Inbox").mkdir() ak.main(["--vault", tmp, "--tag", TAG, "--teil", "alpaca", "--jetzt", "2026-09-23T22:45:00"]) abdichten.erwartet = False # Beleg fuer die uebrigen Zeilen von abdichten: beide Programme und das Skript ins Leere, # fahre_dockerhost gesperrt. gesperrt = (not Path(ak.WSL).exists() and not Path(ak.SSH).exists() and ak.WSL_SKRIPT.startswith("/nicht-vorhanden/") and getattr(ak.fahre_dockerhost, "sperre", False)) ok = gesperrt and gerufen == ["fahre_wsl"] and len(abweichungen) == vorher + 1 del abweichungen[vorher:] del gerufen[:] zeile = f"{'OK ' if ok else 'FEHL'} W Abdichtung: der echte WSL-Weg kommt als Abweichung an" print(zeile) if not ok: abweichungen.append(zeile) gut = {"tag": TAG, "befunde": [], "hinweise": ["auto_fortsetzen: fortgesetzt"], "exit": 0, "fakten": {"handelstag": True, "ende": {"grund": "boersenschluss", "exit": "0", "orders": "79", "position": "0"}, "laeufe": [{"takte_aktiv": 375}], "broker_offen": 0, "bericht": True, "killswitch": {"zustand": "aktiv", "ausloeser": "automatik"}}} def lauf(name, notiz_vorher, ergebnis, *, jetzt="2026-09-23T22:45:00", pruefe): with tempfile.TemporaryDirectory() as tmp: vault = Path(tmp) (vault / "Inbox").mkdir() notiz = vault / "Inbox" / f"{TAG}.md" if notiz_vorher is not None: notiz.write_bytes(notiz_vorher if isinstance(notiz_vorher, bytes) else notiz_vorher.encode("utf-8")) eingabe = vault / "ergebnis.json" eingabe.write_text(ergebnis if isinstance(ergebnis, str) else json.dumps(ergebnis), encoding="utf-8") code = ak.main(["--vault", str(vault), "--tag", TAG, "--ohne-wsl", str(eingabe), "--jetzt", jetzt]) text = notiz.read_bytes().decode("utf-8", errors="replace") if notiz.exists() else "" marke = (vault / ak.ABLAGE_TEIL / f"{TAG}.json").exists() try: ok, grund = pruefe(code, text, marke) except Exception as ausnahme: # der Treiber selbst bricht nicht ab ok, grund = False, f"Pruefung warf {ausnahme!r}; Notiz {text[-120:]!r}" zeile = f"{'OK ' if ok else 'FEHL'} W {name}: {grund}" print(zeile) if not ok: abweichungen.append(zeile) kopf = "---\ntype: daily\n---\n\n# 2026-09-23\n\n" lauf("neue Notiz, ohne Befund", None, gut, pruefe=lambda c, t, m: ( c == 0 and m and "## Agentenprotokoll" in t and "ohne Befund" in t and "type: daily" in t, f"code {c} marke {m}")) lauf("Abschnitt vor einer weiteren Ueberschrift", kopf + "## Agentenprotokoll\n\n- alt\n\n## Danach\n\ntext\n", gut, pruefe=lambda c, t, m: (t.index("ohne Befund") < t.index("## Danach") and "- alt\n- 22:45" in t and "\n\n## Danach" in t and "\n\n\n" not in t, repr(t[-80:]))) lauf("Abschnitt am Ende", kopf + "## Agentenprotokoll\n\n- alt\n", gut, pruefe=lambda c, t, m: (t.endswith(".\n - Hinweis: auto_fortsetzen: fortgesetzt\n") and "- alt\n- 22:45" in t, repr(t[-60:]))) lauf("ohne Abschnitt", kopf + "## Anderes\n\nx\n", gut, pruefe=lambda c, t, m: (t.count("## Agentenprotokoll") == 1 and t.index("## Anderes") < t.index("## Agentenprotokoll"), repr(t[-60:]))) lauf("Abschnitt direkt vor naechster Ueberschrift", kopf + "## Agentenprotokoll\n## Danach\n", gut, pruefe=lambda c, t, m: ("## Agentenprotokoll\n\n- 22:45" in t and "\n\n## Danach" in t, repr(t))) lauf("CRLF-Notiz", (kopf + "## Agentenprotokoll\n\n- alt\n").replace("\n", "\r\n"), gut, pruefe=lambda c, t, m: ("\n" not in t.replace("\r\n", ""), "gemischte Zeilenenden" if "\n" in t.replace("\r\n", "") else "ok")) mit_befund = {**gut, "befunde": ["Runner endete mit Exit 4", "Beim Broker stehen 2 offene Position(en)"]} lauf("mit Befund", None, mit_befund, pruefe=lambda c, t, m: ( "**2 Befund(e)** #needs-review" in t and " - Runner endete mit Exit 4" in t and m, repr(t[-160:]))) lauf("Ergebnis ohne befunde", None, {"tag": TAG}, pruefe=lambda c, t, m: ( c == 1 and not m and "**gescheitert**" in t and "#needs-review" in t, f"code {c} marke {m}")) lauf("Ergebnis kein JSON", None, "nicht json", pruefe=lambda c, t, m: (c == 1 and not m and "**gescheitert**" in t, f"code {c}")) lauf("kein Handelstag", None, {"tag": TAG, "befunde": [], "hinweise": [], "fakten": {"handelstag": False}}, pruefe=lambda c, t, m: ("kein Handelstag" in t and m, repr(t[-60:]))) # Befunde des Pruefers: Ueberschrift mit Zusatz, Notiz ohne UTF-8, Abbruch mit JSON, Nachbardatei lauf("Ueberschrift mit Zusatz", kopf + "## Agentenprotokoll — Sitzung 9\n\n- alt\n\n## Offene Punkte\n\n- x\n", gut, pruefe=lambda c, t, m: (t.count("## Agentenprotokoll") == 1 and t.index("ohne Befund") < t.index("## Offene Punkte"), repr(t[-120:]))) kaputt = "---\ntype: daily\n---\n\n# Tag äöü\n".encode("cp1252") lauf("Notiz kein UTF-8", kaputt, mit_befund, pruefe=lambda c, t, m: (m and c == 1, f"code {c} marke {m}")) lauf("Abbruch mit JSON (exit 2) wird wiederholt", None, {"tag": TAG, "befunde": ["Abendkontrolle abgebrochen: X"], "hinweise": [], "fakten": {}, "exit": 2}, pruefe=lambda c, t, m: (not m and "**1 Befund(e)**" in t and c == 1, f"code {c} marke {m}")) with tempfile.TemporaryDirectory() as tmp: vault = Path(tmp) (vault / "Inbox").mkdir() eingabe = vault / "e.json" eingabe.write_text(json.dumps(gut), encoding="utf-8") ak.main(["--vault", str(vault), "--tag", TAG, "--ohne-wsl", str(eingabe), "--jetzt", "2026-09-23T22:45:00"]) rest = [p.name for p in (vault / "Inbox").iterdir() if not p.name.endswith(".md")] ok = not rest print(f"{'OK ' if ok else 'FEHL'} W keine Nachbardatei uebrig: {rest}") if not ok: abweichungen.append("Nachbardatei uebrig") # faellige_tage from datetime import date with tempfile.TemporaryDirectory() as tmp: ablage = Path(tmp) def tage(jetzt): return ak.faellige_tage(datetime.fromisoformat(jetzt), ablage) faelle = [ ("Do vor 22:30: heute nicht", "2026-09-24T21:00", ["2026-09-24"], False), ("Do nach 22:30: heute", "2026-09-24T22:45", ["2026-09-24"], True), ("Mo frueh: Fr nachholen, Wochenende nicht", "2026-09-28T08:00", ["2026-09-25"], True), ("Mo frueh: nichts vor ERSTER_TAG", "2026-09-28T08:00", ["2026-09-23"], False), ] for name, jetzt, erwartet, drin in faelle: ergebnis = tage(jetzt) ok = all((tag in ergebnis) == drin for tag in erwartet) and not any( date.fromisoformat(t).weekday() >= 5 for t in ergebnis) zeile = f"{'OK ' if ok else 'FEHL'} T {name}: {ergebnis}" print(zeile) if not ok: abweichungen.append(zeile) (ablage / "2026-09-25.json").write_text("{}", encoding="utf-8") ergebnis = tage("2026-09-28T08:00") ok = "2026-09-25" not in ergebnis print(f"{'OK ' if ok else 'FEHL'} T Ergebnisdatei da: nicht erneut: {ergebnis}") if not ok: abweichungen.append("Ergebnisdatei ignoriert") ergebnis = tage("2026-10-12T08:00") ok = min(ergebnis) >= "2026-10-05" print(f"{'OK ' if ok else 'FEHL'} T hoechstens sieben Tage zurueck: {ergebnis}") if not ok: abweichungen.append("Nachholfenster") # --- IBKR-Instanz (Paket IB2), WSL-Teil ------------------------------------------------------------ IBKR_JOURNAL_GUT = ( "Ende: boersenschluss, Position 0, Orders 2, Killswitch aktiv, Exit 0\n" "trading-paper-ibkr.service: Deactivated successfully.\n" ) # Erfundene Ausgabe von scripts/ibkr_pruefen.py lesen: ohne Kontonummer, ohne Betrag. IBKR_KONTO_GUT = ( "verbunden: Gateway 127.0.0.1:4004, Client-ID 12, Handelsmodus paper, Konto DU... (9 Zeichen), " "vom Gateway bestaetigt\n" "Konto: Kontowert, Bargeld und Kaufkraft gelesen (Betraege werden nicht ausgegeben)\n" "Waehrung des Kontowerts: EUR\n" "Positionen: 0\n" "Offene Orders: 0\n" "ERGEBNIS: gelesen\n" ) # Eine erfundene Kontonummer in der Form der Paper-Konten, nur fuer die Maske. KONTO_ERFUNDEN = "DU0000000" KONTO_ERFUNDEN_LANG = "DUQ000000" # 22:45 Berlin ist 16:45 New York (nach Boersenschluss), 16:00 Berlin ist 10:00 New York. NACH_SCHLUSS = f"{TAG}T22:45:00+02:00" IM_HANDEL = f"{TAG}T16:00:00+02:00" def baue_ibkr(wurzel: Path) -> Path: ordner = wurzel / "betrieb" (ordner / "artifacts" / "paper").mkdir(parents=True) (ordner / "data" / "paper").mkdir(parents=True) (ordner / "data" / "paper" / "broker.txt").write_text("ibkr\n", encoding="utf-8") shutil.copyfile(ECHTES_PROTOKOLL, ordner / "artifacts" / "paper" / f"{TAG}T131023-paper.jsonl") with sqlite3.connect(ordner / "data" / "registry.db") as db: db.execute("CREATE TABLE killswitch_zustand (id INTEGER PRIMARY KEY, zustand TEXT, seit TEXT, ausloeser TEXT)") db.execute("CREATE TABLE killswitch_ereignisse (id INTEGER PRIMARY KEY AUTOINCREMENT, zeit TEXT, stufe TEXT, " "ausloeser TEXT, grund TEXT, ergebnis TEXT, erfolgreich INTEGER)") db.execute("INSERT INTO killswitch_zustand VALUES (1, 'aktiv', '2026-09-23T13:31:00+00:00', 'automatik')") db.execute("INSERT INTO killswitch_ereignisse (zeit, stufe, ausloeser, grund, ergebnis, erfolgreich) " "VALUES ('2026-09-23T13:31:00+00:00', 'fortsetzen', 'automatik', 'Tagesstart', '{}', 1)") (wurzel / "kalender.json").write_text(json.dumps(KALENDER_TAG), encoding="utf-8") (wurzel / "journal.txt").write_text(IBKR_JOURNAL_GUT, encoding="utf-8") (wurzel / "dienste.json").write_text(json.dumps({"trading-paper-ibkr.timer": "active"}), encoding="utf-8") (wurzel / "konto.json").write_text(json.dumps({"exit": 0, "text": IBKR_KONTO_GUT}), encoding="utf-8") return ordner def fahre_ibkr(wurzel: Path, ordner: Path, jetzt: str = NACH_SCHLUSS, tag: str = TAG, *, projekt: Path | None = None, meldung: bool = False, env: dict | None = None) -> dict: befehl = [ sys.executable, str(HIER / "abendkontrolle_wsl.py"), "--teil", "ibkr", "--tag", tag, "--ibkr-ordner", str(ordner), "--projekt", str(wurzel if projekt is None else projekt), "--kalender", str(wurzel / "kalender.json"), "--journal", str(wurzel / "journal.txt"), "--dienste", str(wurzel / "dienste.json"), "--ibkr-konto", str(wurzel / "konto.json"), "--jetzt", jetzt, ] if not meldung: befehl.append("--ohne-meldung") umgebung = {k: v for k, v in os.environ.items() if k != "ABENDKONTROLLE_AUSWERTUNG"} umgebung.update(env or {}) lauf = subprocess.run(befehl, capture_output=True, text=True, env=umgebung, timeout=300) try: ergebnis = json.loads(lauf.stdout.strip().splitlines()[-1]) except (IndexError, json.JSONDecodeError): return {"befunde": [f"KEINE JSON-AUSGABE exit {lauf.returncode}: {lauf.stderr[-300:]}"], "exit": lauf.returncode} ergebnis["_exit"] = lauf.returncode return ergebnis def ibkr_wsl_faelle() -> None: def fall(name, vorbereiten, *, befund, anzahl=None, exit_code=0, jetzt=NACH_SCHLUSS, tag=TAG, auch=(), nicht=(), fakt=None): with tempfile.TemporaryDirectory() as tmp: wurzel = Path(tmp) ordner = baue_ibkr(wurzel) vorbereiten(wurzel, ordner) erwarte("IBKR " + name, fahre_ibkr(wurzel, ordner, jetzt, tag), befund=befund, anzahl=anzahl, exit_code=exit_code, auch=auch, nicht=nicht, fakt=fakt) nichts = lambda w, o: None # noqa: E731 prot = lambda o: o / "artifacts" / "paper" / f"{TAG}T131023-paper.jsonl" # noqa: E731 def schreibe(pfad: Path, text: str) -> None: pfad.write_text(text, encoding="utf-8") def konto(text: str, code: int = 0): return lambda w, o: schreibe(w / "konto.json", json.dumps({"exit": code, "text": text})) def register(*befehle: str): def vorbereiten(w, o): with sqlite3.connect(o / "data" / "registry.db") as db: for befehl in befehle: db.execute(befehl) return vorbereiten def zeilen_aendern(o: Path, aendern) -> None: zeilen = prot(o).read_text(encoding="utf-8").splitlines() schreibe(prot(o), "\n".join(aendern(zeilen)) + "\n") fall("Grundlinie", nichts, befund=None, anzahl=0, fakt=lambda f, e: f.get("konto") == {"positionen": 0, "orders": 0, "exit": 0} and e.get("teil") == "ibkr") # I2 No-Go-Tag: Zeitgeber aus und kein Protokoll ist leise; Zeitgeber an und kein Protokoll ist ein Befund. def zeitgeber_aus(w, o): prot(o).unlink() schreibe(w / "dienste.json", json.dumps({"trading-paper-ibkr.timer": "inactive"})) fall("Zeitgeber aus, kein Protokoll", zeitgeber_aus, befund=None, anzahl=0, fakt=lambda f, e: f.get("nicht_gestartet") is True and any("IBKR-Instanz heute nicht gestartet" in h for h in e.get("hinweise", []))) fall("Zeitgeber an, kein Protokoll", lambda w, o: prot(o).unlink(), befund="die Instanz lief nicht") fall("Zeitgeber aus, aber von Hand gelaufen", lambda w, o: schreibe(w / "dienste.json", json.dumps({"trading-paper-ibkr.timer": "inactive"})), befund=None, anzahl=0, fakt=lambda f, e: len(f.get("laeufe") or []) == 1 and not f.get("nicht_gestartet")) fall("Kalender leer", lambda w, o: (schreibe(w / "kalender.json", "[]"), prot(o).unlink()), befund=None, anzahl=0) # I3 Instanzmarke fall("Marke fehlt", lambda w, o: (o / "data" / "paper" / "broker.txt").unlink(), befund="Instanzmarke") fall("Marke alpaca", lambda w, o: schreibe(o / "data" / "paper" / "broker.txt", "alpaca\n"), befund="nicht der Betriebsordner der IBKR-Instanz") # I4 Register fall("gesperrt nach Red Button", register("UPDATE killswitch_zustand SET zustand = 'gesperrt', ausloeser = 'pascal'", "INSERT INTO killswitch_ereignisse (zeit, stufe, ausloeser, grund, ergebnis, erfolgreich) " "VALUES ('2026-09-23T15:00:00+00:00', 'glattstellen', 'pascal', 'Probe', '{}', 1)"), befund="IBKR-Killswitch steht auf gesperrt", auch=("letztes Ereignis glattstellen von pascal",)) fall("gesperrt ohne Ereignis", register("UPDATE killswitch_zustand SET zustand = 'gesperrt'", "DELETE FROM killswitch_ereignisse"), befund="IBKR-Killswitch steht auf gesperrt", auch=("ohne Ereignis im Register",)) fall("Killswitch unbekannter Zustand", register("UPDATE killswitch_zustand SET zustand = 'kaputt'"), befund="IBKR-Killswitch in unbekanntem Zustand") fall("Register fehlt", lambda w, o: (o / "data" / "registry.db").unlink(), befund="IBKR-Register data/registry.db fehlt") fall("Register ohne Ereignistabelle", register("DROP TABLE killswitch_ereignisse"), befund="IBKR-Killswitch nicht geprueft") # I5 Ende je Lauf, Handel, Schlussposition fall("Lauf endete mit abbruch", lambda w, o: zeilen_aendern(o, lambda z: [s.replace('"grund": "boersenschluss"', '"grund": "abbruch"') if '"art": "ende"' in s else s for s in z]), befund="Lauf endete mit abbruch") fall("nie aktiv", lambda w, o: zeilen_aendern(o, lambda z: [s.replace('"killswitch": "aktiv"', '"killswitch": "angehalten"') for s in z]), befund="Tag ohne Handel") # Das Journal meldet Position 0, das Protokoll eine Restposition: Die Schlussposition kommt aus dem # Protokoll, unabhaengig vom Journal (Anforderung Nr. 5, "Position 0"). fall("Restposition im Protokoll bei sauberem Journal", lambda w, o: zeilen_aendern(o, lambda z: [s.replace('"position": 0', '"position": 10') if '"art": "ende"' in s else s for s in z]), befund="endete laut Protokoll mit Position 10", anzahl=1) # Ein Lauf ohne Zeile ende: pruefe_laeufe ueberspringt ihn, im Teil ibkr meldet ihn # pruefe_schlusspositionen (Nachkritik IB2). fall("Lauf ohne Zeile ende", lambda w, o: zeilen_aendern(o, lambda z: [s for s in z if '"art": "ende"' not in s]), befund="Lauf ohne Zeile ende im Protokoll") # I6 Journal fall("Journal Exit 4", lambda w, o: schreibe(w / "journal.txt", IBKR_JOURNAL_GUT.replace("Exit 0", "Exit 4")), befund="Exit 4") fall("Journal ohne Ende", lambda w, o: schreibe(w / "journal.txt", "gestartet\n"), befund="von trading-paper-ibkr.service an diesem Tag") fall("Journal Failed with result", lambda w, o: schreibe(w / "journal.txt", IBKR_JOURNAL_GUT + "trading-paper-ibkr.service: Failed with result 'exit-code'.\n"), befund="Journal: trading-paper-ibkr.service endete mit 'Failed with result'") fall("Journal Traceback", lambda w, o: schreibe(w / "journal.txt", IBKR_JOURNAL_GUT + "Traceback (most recent call last):\n File x\nValueError: y\n"), befund="zeigt 'Traceback") fall("Journal Marke passt nicht zur Konfiguration", lambda w, o: schreibe(w / "journal.txt", IBKR_JOURNAL_GUT + "Dieser Ordner ist die IBKR-Instanz, die Konfiguration " "waehlt aber [broker] wahl = 'alpaca'. Nichts wird gebaut, das Alpaca-Konto bleibt unberuehrt.\n"), befund="zeigt 'Nichts wird gebaut'") # I7 Konto am Gateway fall("Konto 2 Positionen", konto(IBKR_KONTO_GUT.replace("Positionen: 0\n", "Positionen: 2\n AAPL.XNAS 10\n KO.XNYS 10\n")), befund="Beim IBKR-Gateway stehen 2 Position(en)", nicht=("AAPL.XNAS 10", "KO.XNYS 10")) fall("Konto 1 offene Order", konto(IBKR_KONTO_GUT.replace("Offene Orders: 0", "Offene Orders: 1")), befund="Beim IBKR-Gateway stehen 1 offene Order(s)") fall("Konto ohne Zeilen", konto("verbunden: Gateway 127.0.0.1:4004\nERGEBNIS: gelesen\n"), befund="Konto am Gateway nicht gelesen") fall("Konto Voraussetzung fehlt", konto("Voraussetzung fehlt: config/paper-ibkr.toml fehlt\n", 4), befund="endete mit Exit 4", auch=("Voraussetzung fehlt",)) fall("Konto BEFUND mit Kontonummer wird maskiert", konto(IBKR_KONTO_GUT + f"BEFUND: Gateway meldet das Konto {KONTO_ERFUNDEN} als gesperrt\n", 1), befund="[konto]", nicht=(KONTO_ERFUNDEN,)) # Die echte Form hat drei Buchstaben vorn und sechs Ziffern (Pruefung IB2); erfunden, wie oben. fall("Konto BEFUND mit Kontonummer in der echten Form wird maskiert", konto(IBKR_KONTO_GUT + f"BEFUND: Gateway meldet das Konto {KONTO_ERFUNDEN_LANG} als gesperrt\n", 1), befund="[konto]", nicht=(KONTO_ERFUNDEN_LANG,)) fall("im Handelsfenster wird das Konto nicht gelesen", konto("kaputt", 9), befund=None, anzahl=0, jetzt=IM_HANDEL, fakt=lambda f, e: "konto" not in f and any("nicht gelesen" in h for h in e.get("hinweise", []))) # Bedienung fall("Betriebsordner fehlt", lambda w, o: shutil.rmtree(o), befund="Betriebsordner der IBKR-Instanz fehlt", anzahl=1) fall("Tag falsch", nichts, befund="abgebrochen", exit_code=2, tag="2026-13-40") # Meldeweg des Teils ibkr ohne --ohne-meldung, gegen den lokalen Probeserver: Titel beginnt mit # "IBKR Abendkontrolle", Prioritaet hoch (Anforderung Nr. 5). Eine Zeile kennung in der kopierten # config/paper.toml faellt heraus, sonst stuende sie vor dem Titel. with tempfile.TemporaryDirectory() as tmp_server: mitschrift = Path(tmp_server) / "mitschrift.jsonl" port = 18766 server = subprocess.Popen([sys.executable, str(HIER / "ntfy_probe_server.py"), str(port), str(mitschrift)], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) try: import socket import time for _ in range(50): try: socket.create_connection(("127.0.0.1", port), timeout=0.2).close() break except OSError: time.sleep(0.1) with tempfile.TemporaryDirectory() as tmp: wurzel = Path(tmp) projekt = baue_projekt(wurzel) ordner = baue_ibkr(wurzel) (ordner / "data" / "paper" / "broker.txt").unlink() # ein Befund, damit gemeldet wird text = (ECHTES_PROJEKT / "config" / "paper.toml").read_text(encoding="utf-8") anker = 'ntfy_url = "https://ntfy.sh"' if text.count(anker) != 1: raise RuntimeError("Anker ntfy_url fehlt in config/paper.toml") text = text.replace(anker, f'ntfy_url = "http://127.0.0.1:{port}"\nklartext_lokal = true') text = "\n".join(z for z in text.split("\n") if not z.strip().startswith("kennung")) schreibe(projekt / "config" / "paper.toml", text) schreibe(wurzel / "secrets.toml", '[ntfy]\naktiv = true\nthema = "abendkontrolle-angriff"\n') ergebnis = fahre_ibkr(wurzel, ordner, projekt=projekt, meldung=True, env={"TRADING_GEHEIMNISSE": str(wurzel / "secrets.toml")}) zeilen = ([json.loads(z) for z in mitschrift.read_text(encoding="utf-8").split("\n") if z.strip()] if mitschrift.exists() else []) titel = [str(z.get("title") or "") for z in zeilen] stufen = [z.get("priority") for z in zeilen] gesendet = (ergebnis.get("fakten") or {}).get("meldung") ok = (gesendet == "gesendet" and len(zeilen) == 1 and titel[0].startswith("IBKR Abendkontrolle") and stufen == ["high"]) zeile = (f"{'OK ' if ok else 'FEHL'} IBKR Meldung mit Titel IBKR und Prioritaet hoch: " f"titel={titel} prioritaet={stufen} meldung={gesendet}") print(zeile) if not ok: abweichungen.append(zeile) finally: server.terminate() server.wait(timeout=10) # --- IBKR-Instanz (Paket IB2), Windows-Teil ---------------------------------------------------------- def ibkr_windows_faelle() -> None: sys.path.insert(0, str(HIER)) import abendkontrolle as ak from datetime import datetime abdichten(ak) gut = {"tag": TAG, "teil": "ibkr", "befunde": [], "hinweise": [], "exit": 0, "fakten": {"handelstag": True, "ende": {"grund": "boersenschluss", "exit": "0", "orders": "40", "position": "0"}, "laeufe": [{"takte_aktiv": 375}], "konto": {"positionen": 0, "orders": 0, "exit": 0}, "killswitch": {"zustand": "aktiv", "ausloeser": "automatik"}}} alpaca = {"tag": TAG, "befunde": [], "hinweise": [], "exit": 0, "fakten": {"handelstag": True, "ende": {"grund": "boersenschluss", "exit": "0", "orders": "79", "position": "0"}, "laeufe": [{"takte_aktiv": 375}], "broker_offen": 0, "bericht": True, "killswitch": {"zustand": "aktiv", "ausloeser": "automatik"}}} def pruefe_fall(name, ok, grund): zeile = f"{'OK ' if ok else 'FEHL'} W IBKR {name}: {grund}" print(zeile) if not ok: abweichungen.append(zeile) def lauf(name, ergebnis, *, teil="ibkr", pruefe): with tempfile.TemporaryDirectory() as tmp: vault = Path(tmp) (vault / "Inbox").mkdir() eingabe = vault / "ergebnis.json" eingabe.write_text(ergebnis if isinstance(ergebnis, str) else json.dumps(ergebnis), encoding="utf-8") argumente = ["--vault", str(vault), "--tag", TAG, "--ohne-wsl", str(eingabe), "--jetzt", "2026-09-23T22:45:00"] if teil is not None: argumente += ["--teil", teil] code = ak.main(argumente) notiz = vault / "Inbox" / f"{TAG}.md" text = notiz.read_text(encoding="utf-8") if notiz.exists() else "" eigene = (vault / ak.ABLAGE_TEIL / f"{TAG}-ibkr.json").exists() fremde = (vault / ak.ABLAGE_TEIL / f"{TAG}.json").exists() try: ok, grund = pruefe(code, text, eigene, fremde) except Exception as ausnahme: # der Treiber selbst bricht nicht ab ok, grund = False, f"Pruefung warf {ausnahme!r}" pruefe_fall(name, ok, grund) lauf("ohne Befund: eigene Zeile, eigene Datei", gut, pruefe=lambda c, t, e, f: ( c == 0 and e and not f and "— Abendkontrolle IBKR (automatisch): ohne Befund" in t and "Konto beim Gateway: 0 Position(en), 0 offene Order(s)" in t and "Abendkontrolle Trading Plattform" not in t, f"code {c} eigene {e} fremde {f} {t[-160:]!r}")) lauf("mit Befund", {**gut, "befunde": ["Beim IBKR-Gateway stehen 2 Position(en)"]}, pruefe=lambda c, t, e, f: ( "Abendkontrolle IBKR (automatisch): **1 Befund(e)** #needs-review" in t and " - Beim IBKR-Gateway stehen 2 Position(en)" in t and e, repr(t[-200:]))) lauf("nicht gestartet ist leise", {"tag": TAG, "teil": "ibkr", "befunde": [], "exit": 0, "hinweise": ["IBKR-Instanz heute nicht gestartet (trading-paper-ibkr.timer: inactive)"], "fakten": {"handelstag": True, "nicht_gestartet": True, "zeitgeber": "inactive"}}, pruefe=lambda c, t, e, f: ("Abendkontrolle IBKR (automatisch): IBKR-Instanz heute nicht gestartet (Zeitgeber aus)." in t and "#needs-review" not in t and e and c == 0, repr(t[-160:]))) lauf("kein Handelstag", {"tag": TAG, "teil": "ibkr", "befunde": [], "hinweise": [], "exit": 0, "fakten": {"handelstag": False}}, pruefe=lambda c, t, e, f: ("Abendkontrolle IBKR (automatisch): kein Handelstag" in t and e, repr(t[-120:]))) lauf("Abbruch wird wiederholt", {"tag": TAG, "teil": "ibkr", "befunde": ["Abendkontrolle abgebrochen: X"], "hinweise": [], "fakten": {}, "exit": 2}, pruefe=lambda c, t, e, f: (c == 1 and not e and "**1 Befund(e)**" in t, f"code {c} eigene {e}")) lauf("gescheitert", "nicht json", pruefe=lambda c, t, e, f: ( c == 1 and not e and "Abendkontrolle IBKR (automatisch): **gescheitert**" in t, f"code {c} {t[-120:]!r}")) # Ein Ergebnis des falschen Teils (etwa von einem WSL-Teil ohne IB2) landet nicht in der Datei der Instanz. lauf("Ergebnis eines anderen Teils", {**gut, "teil": "alpaca"}, pruefe=lambda c, t, e, f: ( c == 1 and not e and not f and "Abendkontrolle IBKR (automatisch): **gescheitert**" in t, f"code {c} eigene {e} fremde {f}")) lauf("ohne --teil mit --ohne-wsl nur Alpaca", alpaca, teil=None, pruefe=lambda c, t, e, f: ( f and not e and "Abendkontrolle IBKR" not in t and "Abendkontrolle Trading Plattform" in t, f"eigene {e} fremde {f}")) # Beide Teile in derselben Notiz, Alpaca zuerst, je mit eigener Ergebnisdatei. with tempfile.TemporaryDirectory() as tmp: vault = Path(tmp) (vault / "Inbox").mkdir() (vault / "a.json").write_text(json.dumps(alpaca), encoding="utf-8") (vault / "i.json").write_text(json.dumps(gut), encoding="utf-8") gemeinsam = ["--vault", str(vault), "--tag", TAG, "--jetzt", "2026-09-23T22:45:00"] ak.main(gemeinsam + ["--teil", "alpaca", "--ohne-wsl", str(vault / "a.json")]) ak.main(gemeinsam + ["--teil", "ibkr", "--ohne-wsl", str(vault / "i.json")]) text = (vault / "Inbox" / f"{TAG}.md").read_text(encoding="utf-8") stelle_a = text.find("Abendkontrolle Trading Plattform") stelle_i = text.find("Abendkontrolle IBKR") ok = (0 <= stelle_a < stelle_i and text.count("## Agentenprotokoll") == 1 and (vault / ak.ABLAGE_TEIL / f"{TAG}.json").exists() and (vault / ak.ABLAGE_TEIL / f"{TAG}-ibkr.json").exists()) pruefe_fall("beide Teile in einer Notiz", ok, f"alpaca {stelle_a} ibkr {stelle_i}") # Relativ zu IBKR_ERSTER_TAG: Den Wert setzt der Koordinator vor Welle 1 (Planuebersicht IB2). erster = ak.IBKR_ERSTER_TAG.isoformat() pruefe_fall("IBKR_ERSTER_TAG ist ein Werktag nicht vor ERSTER_TAG", ak.IBKR_ERSTER_TAG.weekday() < 5 and ak.IBKR_ERSTER_TAG >= ak.ERSTER_TAG, erster) # Ohne --tag: am ersten Tag vor 22:30 ist fuer den Teil ibkr nichts faellig, auch kein Tag davor. with tempfile.TemporaryDirectory() as tmp: vault = Path(tmp) (vault / "Inbox").mkdir() (vault / "i.json").write_text(json.dumps(gut), encoding="utf-8") ak.main(["--vault", str(vault), "--teil", "ibkr", "--ohne-wsl", str(vault / "i.json"), "--jetzt", f"{erster}T08:00:00"]) dateien = sorted(p.name for p in (vault / ak.ABLAGE_TEIL).glob("*-ibkr.json")) pruefe_fall("ohne --tag nichts vor IBKR_ERSTER_TAG", dateien == [], str(dateien)) # faellige Tage je Teil, direkt with tempfile.TemporaryDirectory() as tmp: ablage = Path(tmp) def ibkr_tage(jetzt): return ak.faellige_tage(datetime.fromisoformat(jetzt), ablage, erster_tag=ak.IBKR_ERSTER_TAG, endung=ak.IBKR_ENDUNG) ergebnis = ibkr_tage(f"{erster}T08:00") pruefe_fall("faellig: nichts vor IBKR_ERSTER_TAG", ergebnis == [], str(ergebnis)) ergebnis = ibkr_tage(f"{erster}T22:45") pruefe_fall("faellig: der erste Tag nach 22:30", erster in ergebnis, str(ergebnis)) (ablage / "2026-09-29-ibkr.json").write_text("{}", encoding="utf-8") ibkr = ibkr_tage("2026-09-30T08:00") alpaca_tage = ak.faellige_tage(datetime.fromisoformat("2026-09-30T08:00"), ablage) pruefe_fall("faellig: eigene Ergebnisdatei je Teil", "2026-09-29" not in ibkr and "2026-09-29" in alpaca_tage, f"ibkr {ibkr} alpaca {alpaca_tage}") if __name__ == "__main__": if sys.platform == "win32": windows_faelle() ibkr_windows_faelle() else: wsl_faelle() ibkr_wsl_faelle() print(f"ERGEBNIS: {len(abweichungen)} Abweichung(en)") sys.exit(1 if abweichungen else 0)