From 961b003df4c9ec72487430476496553d221c3d0e Mon Sep 17 00:00:00 2001 From: Hitonabi Date: Sun, 12 Jul 2026 18:58:05 +0200 Subject: [PATCH] Zuendung (S4): Idle-Radar + Grossbau-Etappen-Regeln - deploy/idle-radar-feed.sh (Hermes-Cron 03:45): destilliert aus Journal- Fehlermustern (24h) + juengster Traum-Notiz max. 2 belegte Wartungs- Kandidaten und legt sie als rohe Ideen (triage) ins native Kanban. Ehrlichkeits-Gate: Beleg-Zitat wird MECHANISCH gegen das Material geprueft (reproduziert-oder-abgelehnt). Stau-Bremse (>=4 offene Queue- Aufgaben oder >=3 offene Karten -> nichts Neues), Dedup dreifach (State-Datei + Board-Abgleich inkl. archivierter + --idempotency-key), Security/Config/Updates tabu. Analyst gpt-oss-120b, Vertretung GLM. - deploy/idle-radar-prompt.md: versionierter Boten-Auftrag (Lucys Stimme, max 3 Saetze, nichts selbst umsetzen). - deploy.sh: kopiert idle-radar-feed.sh nach ~/.hermes/scripts/ (greift wegen Selbst-Reset-Falle erst ab dem 2. Deploy -> Vorinstallation einmalig von Hand; Cron-Registrierung einmalig: hermes cron create). - Grossbau-Etappen-Regeln (Zielbild-Entscheid 4, 10.07.): werkstatt-SOUL Regel 6 + wartung-/orchestrator-SKILL Scope-Check: Grosses nicht mehr ablehnen, sondern in Etappen bauen - jede Etappe eigener Branch, fuer sich lauffaehig + annehmbar, Folge-Etappen als neue Queue-Aufgaben, NIE auf unangenommene Branches aufbauen. - Doku: AUFTRAGSBUCH.md (Idle-Radar-Abschnitt), wissen/OFFENE-FAEDEN.md. Co-Authored-By: Claude Fable 5 --- deploy/deploy.sh | 5 +- deploy/idle-radar-feed.sh | 276 ++++++++++++++++++++++++++++ deploy/idle-radar-prompt.md | 26 +++ deploy/skills/orchestrator/SKILL.md | 10 +- deploy/skills/wartung/SKILL.md | 6 +- deploy/werkstatt-SOUL.md | 19 +- docs/AUFTRAGSBUCH.md | 12 ++ docs/wissen/OFFENE-FAEDEN.md | 13 +- 8 files changed, 358 insertions(+), 9 deletions(-) create mode 100644 deploy/idle-radar-feed.sh create mode 100644 deploy/idle-radar-prompt.md diff --git a/deploy/deploy.sh b/deploy/deploy.sh index 3e8b848..71281fe 100644 --- a/deploy/deploy.sh +++ b/deploy/deploy.sh @@ -92,10 +92,13 @@ cp "$SRC/deploy/chef-gutachter-feed.sh" "$HOME/.hermes/scripts/chef-gutachter-fe # Release-Radar-Cron (10.07.2026): hält neue hermes-agent-Releases wöchentlich gegen die # Eigenbau-Landkarte im Wissens-Vault ("mehr Hermes nativ, weniger Eigenkreationen"). cp "$SRC/deploy/hermes-release-radar-feed.sh" "$HOME/.hermes/scripts/hermes-release-radar-feed.sh" +# Idle-Radar (S4 "Zuendung", 12.07.2026): die Box gibt sich nachts selbst Arbeit — +# Journal-Fehlermuster + Traum-Funde -> belegte rohe Ideen (triage) im nativen Kanban. +cp "$SRC/deploy/idle-radar-feed.sh" "$HOME/.hermes/scripts/idle-radar-feed.sh" # Werkstatt-Kanban-Profil (Ideen-Queue, 10.07.2026): Leitplanken des Worker-Profils nachziehen # (Profil selbst wurde einmalig per `hermes profile create werkstatt --clone` angelegt). [ -d "$HOME/.hermes/profiles/werkstatt" ] && cp "$SRC/deploy/werkstatt-SOUL.md" "$HOME/.hermes/profiles/werkstatt/SOUL.md" -chmod +x "$HOME/.hermes/scripts/fremdblick.sh" "$HOME/.hermes/scripts/dreaming-feed.sh" "$HOME/.hermes/scripts/worker.sh" "$HOME/.hermes/scripts/chef-gutachter-feed.sh" "$HOME/.hermes/scripts/hermes-release-radar-feed.sh" "$HOME/.hermes/scripts/radar-selbstkritik-wrapper.sh" +chmod +x "$HOME/.hermes/scripts/fremdblick.sh" "$HOME/.hermes/scripts/dreaming-feed.sh" "$HOME/.hermes/scripts/worker.sh" "$HOME/.hermes/scripts/chef-gutachter-feed.sh" "$HOME/.hermes/scripts/hermes-release-radar-feed.sh" "$HOME/.hermes/scripts/radar-selbstkritik-wrapper.sh" "$HOME/.hermes/scripts/idle-radar-feed.sh" # Werkstatt-Skill (Autonomie E6): Selbstwartungs-Kreislauf für Hermes. mkdir -p "$HOME/.hermes/skills/wartung" cp "$SRC/deploy/skills/wartung/SKILL.md" "$HOME/.hermes/skills/wartung/SKILL.md" diff --git a/deploy/idle-radar-feed.sh b/deploy/idle-radar-feed.sh new file mode 100644 index 0000000..b82e34e --- /dev/null +++ b/deploy/idle-radar-feed.sh @@ -0,0 +1,276 @@ +#!/usr/bin/env bash +# Idle-Radar (naechtlich 03:45 — S4 "Zuendung", 12.07.2026): die Box gibt sich selbst Arbeit. +# Destilliert aus JOURNAL-Fehlermustern (24 h) und der juengsten TRAUM-Notiz 0-2 KLEINE, +# belegte Wartungs-Kandidaten und legt sie als ROHE IDEEN (triage) ins native Hermes-Kanban. +# Danach laeuft der bewiesene S2-Kreislauf von allein: Specifier arbeitet aus -> Werkstatt +# baut einen Vorschlags-Branch -> Karte im Auftragsbuch -> der KLICK des Commanders bleibt +# das einzige Gate. Muster wie hermes-release-radar-feed.sh: liegt in ~/.hermes/scripts/ +# (deploy.sh kopiert ihn), stdout wird dem Cron-Agenten als Prompt eingespeist; der +# eigentliche ABGLEICH laeuft als Ein-Schuss-Completion gegen llama-swap (:8080). +# Grundsaetze: +# - Kandidat NUR mit woertlichem Beleg-Zitat; das Skript prueft das Zitat MECHANISCH +# gegen das Material (reproduziert-oder-abgelehnt, Verdikt 04.07.) — haerter als +# ein zweites LLM-Urteil und gratis. +# - Max. 2 neue Ideen je Nacht + STAU-BREMSE: liegt schon genug Arbeit (volle Queue +# oder volles Auftragsbuch), legt der Radar NICHTS nach — die Box soll Arbeit +# abarbeiten, nicht anhaeufen. +# - Dedup dreifach: State-Datei (schon gemeldet) + Queue/Karten-Liste im Analysten- +# Kontext + --idempotency-key beim Anlegen. +# - Der Radar LEGT NUR IDEEN AN — er baut nichts, merged nichts, konfiguriert nichts. +# State: ~/.hermes/state/idle-radar-gemeldet.txt (ein KEY je bereits gemeldetem Kandidaten). +set -uo pipefail + +MC="$HOME/mission-control-v2" +VAULT="$HOME/wissens-vault" +STATE_DIR="$HOME/.hermes/state" +STATE="$STATE_DIR/idle-radar-gemeldet.txt" +ENDPOINT="${IDLE_ENDPOINT:-http://127.0.0.1:8080/v1/chat/completions}" +ANALYST="${IDLE_MODEL:-gpt-oss-120b}" +VERTRETUNG="${IDLE_FALLBACK:-GLM-4.7-Flash}" +HERMES="$HOME/.local/bin/hermes" +MAX_NEU=2 # harte Obergrenze neuer Ideen je Nacht (wie Bagatell-Pfad) +STAU_QUEUE=4 # ab so vielen offenen Queue-Aufgaben: Bremse +STAU_KARTEN=3 # ab so vielen offenen Auftragsbuch-Karten: Bremse + +mkdir -p "$STATE_DIR"; touch "$STATE" + +# Briefkasten-Spiegel (still, wie Morgenlage/Release-Radar): Chronik liest source=idle-radar. +briefkasten() { # $1=Betreff $2=Text + curl -sf -m 5 -X POST "${MC_ANNOUNCE_URL:-http://127.0.0.1:9001/api/voice/announce}" \ + -H 'Content-Type: application/json' \ + --data "$(python3 - "$1" "$2" <<'PY' +import json, sys +print(json.dumps({"text": sys.argv[2], "subject": sys.argv[1], + "source": "idle-radar", "priority": "silent"})) +PY +)" >/dev/null 2>&1 || true +} + +# ---------- Versionierter Auftrag fuer den Boten-Agenten ---------- +cat "$MC/deploy/idle-radar-prompt.md" 2>/dev/null || cat <<'EOF' +(Prompt-Datei fehlt noch — Kurzform:) Du bist der Bote des naechtlichen Idle-Radars. +Berichte den Befund unten in Lucys Stimme in hoechstens 3 Saetzen: wie viele neue +Queue-Ideen angelegt wurden (Titel nennen) oder warum keine. Nichts selbst umsetzen, +keine Kanban-Aktionen — das Skript hat alles Noetige bereits getan. +EOF +echo + +# ---------- Stau-Bremse (vor dem teuren Analysten) ---------- +OFFEN_QUEUE="$("$HERMES" kanban list --json 2>/dev/null | python3 -c ' +import json, sys +t = sys.stdin.read(); i = t.find("[") +try: + d = json.loads(t[i:]) if i >= 0 else [] +except Exception: + d = [] +print(sum(1 for x in d if isinstance(x, dict) and x.get("status") not in ("done", "archived"))) +' 2>/dev/null || echo 0)" +OFFEN_KARTEN="$(curl -sf -m 10 http://127.0.0.1:9001/api/auftragsbuch 2>/dev/null | python3 -c ' +import json, sys +try: + print(int(json.load(sys.stdin).get("open_count", 0))) +except Exception: + print(0) +' 2>/dev/null || echo 0)" + +if [ "${OFFEN_QUEUE:-0}" -ge "$STAU_QUEUE" ] || [ "${OFFEN_KARTEN:-0}" -ge "$STAU_KARTEN" ]; then + echo "## IDLE-RADAR-BEFUND: STAU-BREMSE (erhoben am $(date '+%d.%m.%Y %H:%M'))" + echo "Offene Queue-Aufgaben: ${OFFEN_QUEUE} (Bremse ab ${STAU_QUEUE}) · offene Karten: ${OFFEN_KARTEN} (Bremse ab ${STAU_KARTEN})." + echo "Es liegt genug Arbeit — heute Nacht keine neuen Ideen. Dem Commander EINEN kurzen Satz melden." + briefkasten "Idle-Radar" "Stau-Bremse: ${OFFEN_QUEUE} offene Queue-Aufgaben, ${OFFEN_KARTEN} offene Karten — keine neuen Ideen angelegt." + exit 0 +fi + +# ---------- Material sammeln (erst sammeln, dann kuerzen — SIGPIPE-Falle) ---------- +TRAUM_DATEI="$(ls -1t "$VAULT/traeume/"*.md 2>/dev/null | head -1 || true)" +EVID="$( + echo "### JOURNAL-FEHLERMUSTER (user-Dienste, letzte 24 h; Anzahl · Muster, lange Zahlen/IDs normalisiert):" + journalctl --user --since '24 hours ago' -p warning --no-pager 2>/dev/null \ + | sed -E 's/^[A-Z][a-z]{2} [0-9 ]{2} [0-9:]{8} [^ ]+ //; s/\[[0-9]+\]//; s/[0-9]{3,}/N/g; s/t_[0-9a-f]+/t_X/g' \ + | sort | uniq -c | sort -rn | head -18 + echo + echo "### JUENGSTE TRAUM-NOTIZ ($(basename "${TRAUM_DATEI:-keine}") — Funde des naechtlichen Lern-Crons):" + if [ -n "$TRAUM_DATEI" ]; then head -70 "$TRAUM_DATEI"; else echo "(keine Traum-Notiz gefunden)"; fi + echo + echo "### OFFENE SKILL-KANDIDATEN im Vault (nur Titelzeilen):" + ls -1 "$VAULT/skill-kandidaten/"*.md 2>/dev/null | head -8 | while read -r f; do + echo "- $(basename "$f"): $(head -1 "$f" 2>/dev/null)" + done + echo + echo "### SCHON IN DER IDEEN-QUEUE (inkl. archiviert = vom Commander verworfen; NICHT erneut vorschlagen):" + "$HERMES" kanban list --archived --json 2>/dev/null | python3 -c ' +import json, sys +t = sys.stdin.read(); i = t.find("[") +try: + d = json.loads(t[i:]) if i >= 0 else [] +except Exception: + d = [] +for x in d[:40]: + if isinstance(x, dict): + print("- [{}] {}".format(x.get("status", "?"), (x.get("title") or "")[:110])) +' 2>/dev/null || echo "(Queue nicht lesbar)" + echo + echo "### OFFENE KARTEN IM AUFTRAGSBUCH (warten auf Klick; NICHT erneut vorschlagen):" + curl -sf -m 10 http://127.0.0.1:9001/api/auftragsbuch 2>/dev/null | python3 -c ' +import json, sys +try: + items = json.load(sys.stdin).get("items") or [] +except Exception: + items = [] +if not items: + print("(keine)") +for it in items[:15]: + print("- {}:{}".format(it.get("repo", "mc2"), it.get("branch", "?"))) +' 2>/dev/null || echo "(Auftragsbuch nicht lesbar)" + echo + echo "### VOM IDLE-RADAR BEREITS GEMELDET (KEYs; NICHT erneut vorschlagen):" + tail -40 "$STATE" 2>/dev/null || true +)" + +RASTER='Du bist der IDLE-RADAR einer lokalen KI-Box (Hermes-Agent, MC2, Lucy). Du bekommst naechtliches Material: Journal-Fehlermuster, die juengste Traum-Notiz, offene Skill-Kandidaten sowie Listen dessen, was schon in Arbeit ist. Deine Aufgabe: destilliere daraus 0 bis 2 KLEINE, konkrete Wartungs-Kandidaten, die die Box-Werkstatt selbst umsetzen kann (Patch in 1-2 Dateien, Skript- oder Doku-Aenderung im MC2- oder Lucy-Repo). REGELN: Jeder Kandidat MUSS eine Zeile aus dem Material WOERTLICH zitieren (BELEG) — das Zitat wird mechanisch gegengeprueft, erfundene Zitate fliegen raus. Nichts vorschlagen, was sinngemaess schon in der IDEEN-QUEUE, den OFFENEN KARTEN oder der BEREITS-GEMELDET-Liste steht. TABU (niemals vorschlagen): Security (approvals/Tokens/ufw/sudoers/ssh), ~/.hermes/config.yaml, systemd-Units, Hermes-Quellcode, Updates/Upgrades, alles was den PC oder einen Menschen braucht. Ein wiederkehrendes Fehlermuster ist NUR dann ein Kandidat, wenn eine konkrete kleine Ursachen-Behebung erkennbar ist — "beobachten", "untersuchen" oder "Monitoring bauen" ist KEIN Auftrag. Qualitaet vor Quote: KANDIDATEN: 0 ist der Normalfall und voellig ok. Antworte auf DEUTSCH, exakt in dieser Struktur: erste Zeile "KANDIDATEN: <0|1|2>". Danach je Kandidat ein Block aus genau vier Zeilen: "TITEL: " / "KEY: " / "BELEG: " / "WARUM: ". Bei 0 stattdessen EIN Satz, warum nichts ansteht.' + +# Ein-Schuss-Analyst: $1=Modell $2=curl-Timeout $3=max_tokens (Muster chef-gutachter-feed.sh). +judge() { + local req + req="$(jq -n --arg m "$1" --arg sys "$RASTER" --arg usr "$EVID" --argjson mt "$3" \ + '{model:$m, messages:[{role:"system",content:$sys},{role:"user",content:$usr}], + max_tokens:$mt, temperature:0.2}')" + curl -s -m "$2" "$ENDPOINT" -H 'Content-Type: application/json' --data-binary "$req" \ + | python3 -c ' +import json, sys +try: + d = json.load(sys.stdin) + msg = d["choices"][0]["message"] + print((msg.get("content") or msg.get("reasoning_content") or "").strip()) +except Exception: + pass' +} + +RICHTER="$ANALYST" +ANALYSE="$(judge "$ANALYST" 420 2600)" +if [ -z "${ANALYSE// /}" ]; then + RICHTER="$VERTRETUNG (Vertretung — $ANALYST hat nicht geantwortet)" + ANALYSE="$(judge "$VERTRETUNG" 240 1800)" +fi + +echo "## IDLE-RADAR-BEFUND (erhoben am $(date '+%d.%m.%Y %H:%M'))" +echo "Offene Queue-Aufgaben vorher: ${OFFEN_QUEUE} · offene Karten: ${OFFEN_KARTEN} · Deckel: ${MAX_NEU}/Nacht" +echo + +if [ -z "${ANALYSE// /}" ]; then + echo "### ANALYSE AUSGEFALLEN" + echo "Beide Analysten ($ANALYST, $VERTRETUNG) haben nicht geantwortet — dem Commander EINEN ehrlichen Satz melden; morgen neuer Versuch." + briefkasten "Idle-Radar" "Analyse ausgefallen (kein Analyst erreichbar) — keine neuen Ideen." + exit 0 +fi + +echo "### ANALYSE (Analyst: $RICHTER)" +echo "$ANALYSE" +echo + +# ---------- Ehrlichkeits-Gate + Dedup + Anlegen (deterministisch im Skript) ---------- +# Temp-Dateien statt Pipes: Heredoc + Pipe gleichzeitig frisst stdin (Release-Radar-Lehre 10.07.). +TMPD="$(mktemp -d /tmp/idle-radar.XXXXXX)" +printf '%s' "$ANALYSE" > "$TMPD/analyse.txt" +printf '%s' "$EVID" > "$TMPD/material.txt" +PLAN="$(python3 - "$TMPD/analyse.txt" "$TMPD/material.txt" "$STATE" "$MAX_NEU" <<'PY' +import re, sys, unicodedata + +ana = open(sys.argv[1], encoding="utf-8", errors="replace").read() +evid = open(sys.argv[2], encoding="utf-8", errors="replace").read() +try: + state = {l.strip() for l in open(sys.argv[3], encoding="utf-8", errors="replace") if l.strip()} +except Exception: + state = set() +max_neu = int(sys.argv[4]) + +def norm(s): + s = unicodedata.normalize("NFKC", s) + s = "".join(ch for ch in s if ch.isalnum() or ch.isspace()) + return " ".join(s.lower().split()) + +nev = norm(evid) + +# Zeilenweise einsammeln (tolerant gegen Markdown-Deko und Leerzeilen zwischen Feldern). +cands, cur = [], {} +for line in ana.splitlines(): + line = line.strip().lstrip("*->#• ").strip() + m = re.match(r"(TITEL|KEY|BELEG|WARUM)\s*:\s*(.+)$", line) + if not m: + continue + k, v = m.group(1), m.group(2).strip() + if k == "TITEL" and cur: + cands.append(cur); cur = {} + cur[k] = v +if cur: + cands.append(cur) + +neu = 0 +SEP = "\x1f" +for c in cands: + titel = (c.get("TITEL") or "").strip()[:120] + warum = (c.get("WARUM") or "").strip()[:300] + beleg = (c.get("BELEG") or "").strip().strip('"„“»«>`').strip() + key = re.sub(r"[^a-z0-9-]+", "-", (c.get("KEY") or "").strip().lower())[:48].strip("-") + if not (titel and key and beleg): + continue + if key in state or ("idle-radar-" + key) in state: + print("SKIP" + SEP + key + SEP + "schon frueher gemeldet (State)") + continue + if not norm(beleg) or norm(beleg) not in nev: + print("SKIP" + SEP + key + SEP + "BELEG nicht woertlich im Material — verworfen (Ehrlichkeits-Gate)") + continue + if neu >= max_neu: + print("SKIP" + SEP + key + SEP + "Deckel erreicht") + continue + neu += 1 + print("NEU" + SEP + key + SEP + titel + SEP + beleg + SEP + warum) +PY +)" + +ANGELEGT=""; VERWORFEN="" +while IFS=$'\x1f' read -r art key titel beleg warum; do + [ -n "${art:-}" ] || continue + if [ "$art" = "SKIP" ]; then + VERWORFEN="${VERWORFEN}- ${key}: ${titel}"$'\n' # bei SKIP traegt das 3. Feld den Grund + continue + fi + [ "$art" = "NEU" ] || continue + BODY="Automatisch vom Idle-Radar erhoben am $(date '+%d.%m.%Y') (Quelle: Journal-Muster/Traum-Notiz der Nacht). + +BELEG (woertlich aus dem Material): ${beleg} + +WARUM: ${warum} + +Rohe Idee — bitte pruefen, klein schneiden und nur wenn tragfaehig promoten; sonst archivieren." + TASK_ID="$("$HERMES" kanban create "$titel" --body "$BODY" --triage \ + --created-by idle-radar --idempotency-key "idle-radar-${key}" --json 2>/dev/null \ + | python3 -c ' +import json, sys +t = sys.stdin.read(); i = t.find("{") +try: + print(json.loads(t[i:]).get("id", "") if i >= 0 else "") +except Exception: + print("") +' 2>/dev/null || true)" + if [ -n "${TASK_ID// /}" ]; then + echo "$key" >> "$STATE" + ANGELEGT="${ANGELEGT}- ${titel} (${TASK_ID}, Key ${key})"$'\n' + else + VERWORFEN="${VERWORFEN}- ${key}: kanban create fehlgeschlagen"$'\n' + fi +done <<< "$PLAN" +rm -rf "$TMPD" + +echo "### ANGELEGT (rohe Ideen, triage — der Specifier uebernimmt):" +echo "${ANGELEGT:-(keine)}" +echo "### NICHT ANGELEGT (Gate/Dedup/Deckel):" +echo "${VERWORFEN:-(keine)}" + +N_NEU="$(printf '%s' "$ANGELEGT" | grep -c '^-' || true)" +if [ "${N_NEU:-0}" -gt 0 ]; then + briefkasten "Idle-Radar" "Idle-Radar hat ${N_NEU} neue Idee(n) in die Queue gelegt: +${ANGELEGT}Der Specifier arbeitet sie aus; die Karten-Annahme bleibt beim Commander." +else + briefkasten "Idle-Radar" "Idle-Radar: keine neuen Ideen (Analyst: ${RICHTER})." +fi diff --git a/deploy/idle-radar-prompt.md b/deploy/idle-radar-prompt.md new file mode 100644 index 0000000..345ee99 --- /dev/null +++ b/deploy/idle-radar-prompt.md @@ -0,0 +1,26 @@ +# Idle-Radar — Auftrag für den Boten-Agenten + +Du bist der Bote des nächtlichen Idle-Radars. Unten steht ein automatisch erhobener +BEFUND: aus Journal-Fehlermustern und der jüngsten Traum-Notiz destilliert ein +Analysten-Modell kleine Wartungs-Kandidaten; das Skript hat die tragfähigen davon +BEREITS als rohe Ideen (triage) in die Ideen-Queue gelegt — den Rest erledigt der +bewiesene Kreislauf (Specifier → Werkstatt → Karte im Auftragsbuch → Klick des +Commanders). + +Deine Aufgabe — NUR berichten, in Lucys Stimme (Anrede „Commander", Alltagssprache, +Fazit zuerst), in höchstens 3 Sätzen: + +1. Bei „ANGELEGT: (keine)" oder „KANDIDATEN: 0": GENAU EIN kurzer Satz + (z. B. „Idle-Radar: nichts Belegbares heute Nacht — Queue bleibt wie sie ist."). +2. Bei neuen Ideen: nenne Anzahl und die Titel; sage dazu, dass die Box sie jetzt + selbst ausarbeitet und die Annahme wie immer per Karten-Klick beim Commander liegt. +3. Bei „STAU-BREMSE" oder „AUSGEFALLEN": ein ehrlicher Satz, warum der Radar heute + Nacht nichts angelegt hat. + +Harte Regeln: +- NICHTS selbst umsetzen: keine Kanban-Aktionen, nichts bauen, nichts konfigurieren — + das Anlegen hat das Skript schon deterministisch erledigt. +- Erfinde keine Kandidaten über den Befund hinaus; im Ehrlichkeits-Gate verworfene + Vorschläge (BELEG nicht im Material) nicht als Erfolg verkaufen. +- Die stille Briefkasten-Karte hat das Skript bereits geschrieben — du lieferst nur + die kurze Telegram-Meldung. diff --git a/deploy/skills/orchestrator/SKILL.md b/deploy/skills/orchestrator/SKILL.md index 4e8541b..a555550 100644 --- a/deploy/skills/orchestrator/SKILL.md +++ b/deploy/skills/orchestrator/SKILL.md @@ -29,8 +29,14 @@ Langsamer (Swap-Latenz + einer nach dem anderen: Minuten), aber bei Hintergrund- Passt: ein Auftrag, der in **2–4 abgegrenzte Teil-Tasks** zerfaellt, jeder ein 1–2-Datei-Bau-Schritt (neues kleines Modul + Test, kleine neue Funktion + Verdrahtung, zusammenhaengender Refactor in wenigen Dateien). Zu gross (viele Module, echte Architektur-Entscheidungen, breite API-Aenderung): -dann NUR einen **Plan** als Text im Telegram-Vorschlag liefern, KEINEN Code — der Commander schneidet -dann kleiner. +**Etappen-Weg statt Ablehnung** (Grossbau-Entscheid 10.07.2026) — zerlege das Projekt in Etappen, +von denen JEDE fuer sich lauffaehig, gate-gruen und einzeln annehmbar ist. Baue in DIESEM Lauf nur +Etappe 1 (als normalen Orchestrator-Durchlauf mit Workern + Zwei-Kritiker-Gate); den Etappen-Plan +in den Telegram-Vorschlag schreiben und die Folge-Etappen als neue Aufgaben in die Ideen-Queue +legen (`hermes kanban create " — Etappe : " --triage`, im Body: Plan + Branch der +Vor-Etappe). Eine Folge-Etappe wird erst gebaut, wenn der Branch der Vor-Etappe in main ist — +NIE auf unangenommene Branches aufbauen. Rauere Qualitaet ist bei Grossbau ok, aber ehrlich im +Vorschlag ausweisen, was fehlt oder wacklig ist. ## Leitplanken (nicht verhandelbar) - **Du delegierst, du baust NICHT selbst.** Jedes Bau-Artefakt MUSS aus einem `worker.sh`-Aufruf diff --git a/deploy/skills/wartung/SKILL.md b/deploy/skills/wartung/SKILL.md index 9cebc49..71f71ce 100644 --- a/deploy/skills/wartung/SKILL.md +++ b/deploy/skills/wartung/SKILL.md @@ -16,7 +16,11 @@ Nutze diesen Skill, wenn ein kleiner, klar umrissener Wartungsauftrag für das M **Scope-Check zuerst:** Klein = Config-Schlüssel-Migration, Dependency-Bump (Lockfile), Patch in 1–2 Dateien. Alles Größere (Architektur, mehrere Module, neue Features): -NUR einen Plan liefern (Text im Telegram-Vorschlag), KEINEN Code. +NICHT pauschal ablehnen, sondern den **Etappen-Weg** gehen (Großbau-Entscheid 10.07.2026): +einen Etappen-Plan in den Vorschlag schreiben (jede Etappe für sich lauffähig + annehmbar) +und NUR Etappe 1 als eigenen Vorschlags-Branch bauen; Folge-Etappen als neue Aufgaben in +die Ideen-Queue (`hermes kanban create " — Etappe : " --triage`). NIE auf +unangenommene Branches aufbauen — erst wenn die Vor-Etappe in main ist, kommt die nächste. ## Leitplanken (nicht verhandelbar) diff --git a/deploy/werkstatt-SOUL.md b/deploy/werkstatt-SOUL.md index 4129677..4c556f9 100644 --- a/deploy/werkstatt-SOUL.md +++ b/deploy/werkstatt-SOUL.md @@ -24,9 +24,22 @@ sauberes Handwerk. 5. TABU-Zonen: approvals/Tokens/ufw/Security-Configs, `~/.hermes/config.yaml`, systemd-Units, alles außerhalb deines Workspaces. Braucht der Auftrag so etwas → `kanban_block` mit Begründung, nicht selbst machen. -6. Zu groß oder unklar? Lieber `kanban_block` mit ehrlicher Diagnose (was fehlt, wie man - kleiner schneidet) als Murks. Für große Umbauten: nur einen PLAN als Kommentar - liefern, keinen Code. +6. Unklar? Lieber `kanban_block` mit ehrlicher Diagnose (was fehlt, wie man kleiner + schneidet) als Murks. GROSSE Aufträge sind erlaubt — aber NUR in Etappen + (Großbau-Entscheid 10.07.2026): + - Zuerst einen Etappen-Plan als Task-Kommentar: welche Etappen, was ist am Ende + JEDER Etappe fertig und für sich lauffähig. + - Dann NUR Etappe 1 bauen: eigener Vorschlags-Branch, Gates grün, für sich + annehmbar — eine halbe Baustelle kommt NIE auf eine Karte. + - Folge-Etappen als NEUE Kanban-Aufgaben anlegen (`kanban_create`, Titel + „ — Etappe : "; im Body: der Plan + Branch der Vor-Etappe). + - Bearbeitest du eine Etappen-Aufgabe ab Etappe 2: prüfe ZUERST, ob der Branch der + Vor-Etappe schon in main ist (`git log origin/main`). Wenn nein → + `kanban_block("wartet auf Annahme Etappe ")` — NIE auf unangenommene + Branches aufbauen. + - Rauere Qualität ist bei Großbau ok, aber ehrlich: was fehlt oder wacklig ist, + steht in der Summary. Scheitert eine Etappe: `kanban_block` + Diagnose als + Kommentar (was gelernt, wie kleiner schneiden) — Fehlversuche sind Lernmaterial. 7. Am Ende `kanban_complete` mit deutscher Summary: was gebaut, der BRANCH-NAME, wie geprüft. Der Branch-Name MUSS in der Summary stehen — daraus wird die Karte gefunden. diff --git a/docs/AUFTRAGSBUCH.md b/docs/AUFTRAGSBUCH.md index 267a951..92427c5 100644 --- a/docs/AUFTRAGSBUCH.md +++ b/docs/AUFTRAGSBUCH.md @@ -21,6 +21,18 @@ Vor dem Auftragsbuch liegt DIE eine Ideen-Queue: das native Hermes-Kanban Vorschlags-Branch auf Gitea — der hier als Karte erscheint. **Das Gate bleibt dein Klick.** +**Die Queue füttert sich auch selbst — Idle-Radar (S4 „Zündung", 12.07.2026):** ein +nächtlicher Hermes-Cron (03:45, `deploy/idle-radar-feed.sh`) destilliert aus den +Journal-Fehlermustern der letzten 24 h und der jüngsten Traum-Notiz bis zu **2 belegte** +Wartungs-Kandidaten und legt sie als rohe Ideen (`triage`, `created_by=idle-radar`) auf +dasselbe Board. Leitplanken: jedes Beleg-Zitat wird **mechanisch** gegen das Material +geprüft (erfundene Belege fliegen raus — reproduziert-oder-abgelehnt), **Stau-Bremse** +(ab 4 offenen Queue-Aufgaben oder 3 offenen Karten legt er nichts nach), dreifacher +Dedup (State-Datei `~/.hermes/state/idle-radar-gemeldet.txt`, Board-Abgleich inklusive +archivierter = verworfener Ideen, `--idempotency-key`), Security/Config/Updates tabu. +Der Radar legt nur Ideen an — gebaut wird über denselben Kreislauf, dein Klick bleibt +das Gate. + Die Queue-Sicht im Tab (Status, offene Ideen) kommt aus `hermes kanban list --json` (`backend/services/ideen.py`); die Morgenlage bekommt `kanban stats` als Beweismaterial. Entscheid nativ-vs-Eigenbau (Hermes-first): Probe 10.07.2026 — diff --git a/docs/wissen/OFFENE-FAEDEN.md b/docs/wissen/OFFENE-FAEDEN.md index 462a393..f261eba 100644 --- a/docs/wissen/OFFENE-FAEDEN.md +++ b/docs/wissen/OFFENE-FAEDEN.md @@ -6,6 +6,8 @@ keine zweite Liste anlegen. Verdikte werden NICHT als „offen" geführt → [VE ## Termine (auch als Box-Reminder hinterlegt) - **Mo 13.07., 05:15** — erster echter Release-Radar-Cron-Lauf → Morgenlage/Chronik prüfen. +- **täglich 03:45 (ab Registrierung)** — Idle-Radar legt max. 2 belegte Wartungs-Ideen in + die Queue; erste Läufe in der Morgenlage prüfen. - **20.–25.07. — ROCm-Recheck** (Anlass: Ryzen-AI-Halo-Launch 06.07., ROCm 7.13 Preview). Fragen: neue Halo-Community-Benches? llama.cpp-Issue #21284 (gfx1151-Prefill) gemerged? kyuz0-Grid aktualisiert (kyuz0.github.io/amd-strix-halo-toolboxes)? Falls ROCm dann @@ -29,8 +31,15 @@ keine zweite Liste anlegen. Verdikte werden NICHT als „offen" geführt → [VE f-String-`\"` auf Python 3.14 → Poll blind; Abschluss manuell nachgezogen, Build war grün) — Fixes + Executor-Fensterblitz-Fix in Karte `wartung/lucy-annahme-fixes`. Details FALLEN.md. **Der nächste Lucy-Auftrag ist der ehrliche Voll-Automatik-Test.** -- **S4 „leg los zuendung":** Idle-Radar / Fehler→Auftrag (Traum-Funde + Journal-Muster → - Queue-Kandidaten) · Großbau-Etappen-Regeln in Skills · Generalprobe ohne Claude. +- **S4 „leg los zuendung" ✅ gebaut (12.07.):** Idle-Radar (`deploy/idle-radar-feed.sh`, + Hermes-Cron nächtlich 03:45): Journal-Fehlermuster + Traum-Funde → max. 2 belegte rohe + Ideen/Nacht ins native Kanban (Ehrlichkeits-Gate prüft Beleg-Zitate mechanisch, + Stau-Bremse bei voller Queue/vollem Auftragsbuch, dreifacher Dedup inkl. archivierter + Ideen) · Großbau-Etappen-Regeln in werkstatt-SOUL + wartung-/orchestrator-Skill (jede + Etappe für sich lauffähig + annehmbar, NIE auf unangenommene Branches bauen, + Folge-Etappen als neue Queue-Aufgaben). **Offen: erste Scharf-Läufe in der Morgenlage + beobachten; der volle Kreislauf ohne Claude (Radar → Specifier → Werkstatt → Karte) + ist die eigentliche Generalprobe.** ## Lucy