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 <noreply@anthropic.com>

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"

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: <max 90 Zeichen, Imperativ, deutsch>" / "KEY: <kurzer-kebab-slug>" / "BELEG: <woertliches Zitat aus dem Material, EINE Zeile>" / "WARUM: <ein Satz>". 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

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.

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 "<Projekt> — Etappe <n>: <was>" --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

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 "<Projekt> — Etappe <n>: <was>" --triage`). NIE auf
+unangenommene Branches aufbauen — erst wenn die Vor-Etappe in main ist, kommt die nächste.
 
 ## Leitplanken (nicht verhandelbar)
 

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
+     „<Projekt> — Etappe <n>: <was>"; 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 <n-1>")` — 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.