Auftragsbuch ausgebaut: Karten-Annahme, Bagatell-Annahme, Lucy-Annahme raus — Gate ist Ampel + User-Merge

Die Vorschlags-Inbox (routers/services auftragsbuch, AuftragsbuchView, /auftraege, Cockpit-
Kachel + Handlungsbedarf-Eintrag, deploy/auftrag-annehmen.sh, lucy-annahme.sh, bagatell-
annahme.sh, docs/AUFTRAGSBUCH.md) war seit 02.08.2026 ungenutzt: Kanban-Tools seit 21.08. aus,
v3-Umbau lief ueber Branch -> Ampel -> Merge -> deploy.sh, PC-Executor-IP in Box und Config
veraltet. Doku behauptete den Karten-Weg trotzdem als Standard.

Jetzt:
- Cockpit: Kachel "Ideen" (offen/haengend) statt "Auftragsbuch"; Handlungsbedarf zeigt haengende
  Ideen und springt in die Ideen-Ansicht.
- Guide/Schaubild: Kreislauf Idee -> Ideen-Queue -> IDE am PC -> Ampel -> DEIN Merge -> Live.
- events.py: kein Auftragsbuch-Fingerprint mehr; config.py: PC_EXECUTOR_URL-Default auf .22.
- Skills/Skripte: selbst-inventur ohne Karten-Abschnitt, morning-report nennt offene Branches,
  konzept-fliessband verweist auf die Ideen-Ansicht.
- Doku: STACK "Deploy & Pipeline" = Branch -> Ampel -> User-Merge -> deploy.sh (einziger Weg),
  GRENZEN/ARBEITSWEISE/FALLEN/README/BEDIENUNG/RUNBOOK/GEMINI_BRIEFING/gitea-workflow angepasst,
  ZIELBILD Punkt 9, OFFENE-FAEDEN + RAPHAEL.md: erledigt.
- Bewusst geblieben: werkstatt-SOUL/projektstart-SOUL (Werkstatt-Persona, eigener Faden),
  Chronik-Kategorie "auftragsbuch" fuer historische Eintraege.
Auf der Box bereits erledigt (Hand): mc2-bagatell.timer deaktiviert + Units archiviert,
PC-Executor-URL in ~/.hermes/config.yaml auf .22.

Baut auf wartung/lucy-stimme-proxy-raphael auf (Proxy /api/lucy/stimme/*).
Gates: eslint 0 Fehler, vitest 59/59, tsc + vite build gruen, frontend/dist committet,
py_compile gruen.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

deploy/auftrag-annehmen.sh

@@ -1,162 +0,0 @@
-#!/usr/bin/env bash
-# Auftragsbuch: einen Vorschlags-Branch ANNEHMEN — der letzte Meter des propose-only-Kreislaufs.
-# Werkstatt/Orchestrator liefern Branches (wartung/*, orchestrator/*), der Commander klickt in
-# der Zentrale „Annehmen" → dieses Skript macht die bisherige Git-Handarbeit: Merge im
-# isolierten Worktree (Lehre: NIE im Live-Checkout arbeiten) → Push nach main → Deploy →
-# Health-Check → bei Rot automatischer Revert + Redeploy + Alarm.
-#
-# WICHTIG: läuft als EIGENE systemd-Unit (systemd-run, startet routers/auftragsbuch.py),
-# NICHT als Kind des Backends — deploy.sh startet mission-control-2 neu und würde sonst
-# den eigenen Eltern-Prozess mitten im Lauf töten. Außerdem wird es vom Backend als
-# /tmp-KOPIE gestartet (deploy.sh macht git reset --hard → die Datei unter den Füßen
-# eines laufenden bash zu tauschen korrumpiert das Skript, bekannte Falle).
-#
-# Nutzung: auftrag-annehmen.sh <branch>     (z. B. wartung/saubere-zusammenfassung)
-set -uo pipefail
-
-BRANCH="${1:?Nutzung: auftrag-annehmen.sh <branch>}"
-SRC="${MC2_SRC:-$HOME/mission-control-v2}"
-STATUS="${MC2_AUFTRAG_STATUS:-/srv/models/mc2-auftragsbuch.json}"
-API="${MC_API:-http://127.0.0.1:9001}"
-SLUG="$(echo "$BRANCH" | tr '/' '-')"
-WT="/tmp/annahme-$SLUG"
-LOG="/tmp/annahme-$SLUG.log"
-
-notify(){ bash "$SRC/deploy/notify.sh" -s "[Auftragsbuch]" "$1" || true; }
-
-# Status-Fortschritt für die UI (atomar via tmp+replace; die API liest die Datei nur).
-status(){  # $1=state  $2=detail
-  python3 - "$STATUS" "$BRANCH" "$1" "$2" <<'PY'
-import json, os, sys, time
-p, branch, state, detail = sys.argv[1:5]
-try:
-    d = json.load(open(p, encoding="utf-8"))
-except Exception:
-    d = {}
-d.setdefault("branches", {})[branch] = {"state": state, "detail": detail, "ts": time.time()}
-tmp = p + ".tmp"
-json.dump(d, open(tmp, "w", encoding="utf-8"), ensure_ascii=False)
-os.replace(tmp, p)
-PY
-}
-
-cleanup_wt(){ git -C "$SRC" worktree remove --force "$WT" 2>/dev/null || true; }
-
-fail(){
-  status "fehlgeschlagen" "$1"
-  notify "Vorschlag '$BRANCH' konnte NICHT eingespielt werden: $1 — nichts wurde verändert, der Branch bleibt liegen."
-  cleanup_wt
-  exit 1
-}
-
-status "laeuft" "Merge wird vorbereitet"
-cd "$SRC" || fail "Live-Checkout $SRC fehlt"
-git fetch -q origin || fail "git fetch (Gitea) fehlgeschlagen"
-git rev-parse --verify -q "refs/remotes/origin/$BRANCH" >/dev/null \
-  || fail "Branch origin/$BRANCH existiert nicht (schon gemergt/gelöscht?)"
-
-PRE="$(git rev-parse origin/main)"
-
-# Kaputt aufgesetzte Branches (Worker machte git init/Shallow statt zu klonen) haben KEINEN
-# gemeinsamen Vorfahren — git verweigert den Merge immer. Ehrlich sagen statt „Konflikt".
-git merge-base origin/main "origin/$BRANCH" >/dev/null 2>&1 \
-  || fail "Branch hat keinen gemeinsamen Ursprung mit main (kaputt aufgesetzt, z. B. git init statt Klonen) — bitte ablehnen (mit Grund) und die Idee neu in die Queue geben"
-
-# Isolierter Worktree — der Live-Checkout bleibt bis zum Deploy unberührt.
-cleanup_wt
-git worktree add --detach "$WT" origin/main >/dev/null 2>&1 || fail "Worktree konnte nicht angelegt werden"
-MERGE_MSG="Auftragsbuch: '$BRANCH' angenommen (Ein-Klick-Gate)"
-if ! git -C "$WT" -c user.name="Auftragsbuch" -c user.email="auftragsbuch@box.local" \
-     merge --no-ff "origin/$BRANCH" -m "$MERGE_MSG" >>"$LOG" 2>&1; then
-  git -C "$WT" merge --abort 2>/dev/null || true
-  # Selbstheilung: veralteten Branch mechanisch auf main rebasen (zweiter Worktree am
-  # Branch-Kopf). Klappt das sauber, wird der rebasede Stand gemergt — kein PC nötig.
-  status "laeuft" "Merge-Konflikt — Auto-Rebase wird versucht"
-  WT2="/tmp/annahme-rebase-$SLUG"
-  git worktree remove --force "$WT2" 2>/dev/null || true
-  REBASED=""
-  if git worktree add --detach "$WT2" "origin/$BRANCH" >/dev/null 2>&1 \
-     && git -C "$WT2" -c user.name="Auftragsbuch" -c user.email="auftragsbuch@box.local" \
-          rebase origin/main >>"$LOG" 2>&1; then
-    REBASED="$(git -C "$WT2" rev-parse HEAD)"
-  else
-    git -C "$WT2" rebase --abort 2>/dev/null || true
-  fi
-  git worktree remove --force "$WT2" 2>/dev/null || true
-  [ -n "$REBASED" ] || fail "Merge-Konflikt mit main, Auto-Rebase scheiterte ebenfalls — echter Inhaltskonflikt; am einfachsten ablehnen und die Idee neu in die Queue geben (frischer Branch von aktuellem main)"
-  git -C "$WT" -c user.name="Auftragsbuch" -c user.email="auftragsbuch@box.local" \
-      merge --no-ff "$REBASED" -m "$MERGE_MSG — auto-rebased (Branch war veraltet)" >>"$LOG" 2>&1 \
-    || { git -C "$WT" merge --abort 2>/dev/null || true; fail "Merge nach Auto-Rebase fehlgeschlagen (unerwartet) — Log: $LOG"; }
-fi
-
-# py_compile-Gate über die durch den Merge geänderten Python-Dateien (AGENTS.md-Regel).
-PYS="$(git -C "$WT" diff --name-only "$PRE"..HEAD -- '*.py' 2>/dev/null | tr '\n' ' ')"
-if [ -n "${PYS// /}" ]; then
-  PYBIN="$SRC/backend/.venv/bin/python"; [ -x "$PYBIN" ] || PYBIN="python3"
-  # shellcheck disable=SC2086
-  ( cd "$WT" && "$PYBIN" -m py_compile $PYS ) >>"$LOG" 2>&1 || fail "py_compile-Gate rot — der Patch enthält kaputtes Python"
-fi
-
-status "laeuft" "Push nach main läuft"
-PUSHED=0
-for _ in 1 2 3; do
-  git -C "$WT" push origin HEAD:main >>"$LOG" 2>&1 && { PUSHED=1; break; }
-  sleep 5
-done
-[ "$PUSHED" = 1 ] || fail "Push nach main fehlgeschlagen (Gitea nicht erreichbar / Token?)"
-cleanup_wt
-
-status "laeuft" "Deploy läuft — die Zentrale startet gleich kurz neu"
-notify "Vorschlag '$BRANCH' angenommen: Merge auf main ist durch, Deploy läuft. Die Zentrale ist gleich kurz weg."
-
-# deploy.sh als Kopie ausführen (Selbst-Reset-Falle: es resettet das Repo, in dem es liegt).
-cp "$SRC/deploy/deploy.sh" "/tmp/annahme-deploy-$SLUG.sh"
-DEPLOY_OK=1
-bash "/tmp/annahme-deploy-$SLUG.sh" >>"$LOG" 2>&1 || DEPLOY_OK=0
-
-# Health-Check mit Geduld (Dienst-Neustart + Warmup brauchen einen Moment).
-HEALTH=0
-if [ "$DEPLOY_OK" = 1 ]; then
-  for _ in $(seq 1 18); do
-    curl -sf -m 5 "$API/api/health" >/dev/null 2>&1 && { HEALTH=1; break; }
-    sleep 5
-  done
-fi
-
-if [ "$HEALTH" = 1 ]; then
-  # Gemergt + live + grün → der Remote-Branch hat seinen Zweck erfüllt.
-  git -C "$SRC" push origin --delete "$BRANCH" >>"$LOG" 2>&1 || true
-  git -C "$SRC" fetch -q --prune origin 2>/dev/null || true
-  status "eingespielt" "Deploy grün, Health-Check bestanden"
-  notify "Vorschlag '$BRANCH' ist LIVE — Deploy grün, Health-Check bestanden. ✅"
-  exit 0
-fi
-
-# ── Rollback: Merge revertieren, main zurückschieben, neu deployen, Alarm ──
-status "rollback" "Health rot — automatischer Revert läuft"
-git fetch -q origin || true
-cleanup_wt
-if git worktree add --detach "$WT" origin/main >/dev/null 2>&1 \
-   && git -C "$WT" -c user.name="Auftragsbuch" -c user.email="auftragsbuch@box.local" \
-        revert -m 1 --no-edit HEAD >>"$LOG" 2>&1 \
-   && git -C "$WT" push origin HEAD:main >>"$LOG" 2>&1; then
-  cleanup_wt
-  cp "$SRC/deploy/deploy.sh" "/tmp/annahme-rollback-$SLUG.sh"
-  bash "/tmp/annahme-rollback-$SLUG.sh" >>"$LOG" 2>&1 || true
-  R=0
-  for _ in $(seq 1 12); do
-    curl -sf -m 5 "$API/api/health" >/dev/null 2>&1 && { R=1; break; }
-    sleep 5
-  done
-  if [ "$R" = 1 ]; then
-    status "zurueckgerollt" "Health blieb rot — Merge automatisch revertiert, Box läuft wieder"
-    notify "Vorschlag '$BRANCH' hat den Health-Check GERISSEN. Automatisch zurückgerollt — die Box läuft wieder auf dem alten Stand. Der Branch bleibt zur Analyse liegen. Log: $LOG"
-    exit 1
-  fi
-fi
-cleanup_wt
-status "kritisch" "Rollback fehlgeschlagen — Box braucht Hilfe"
-curl -sf -m 5 -X POST "$API/api/alarm" -H 'Content-Type: application/json' \
-  --data "{\"subject\":\"[Auftragsbuch]\",\"text\":\"KRITISCH: Annehmen von $BRANCH UND Rollback fehlgeschlagen — Zentrale prüfen. Log: $LOG\"}" >/dev/null 2>&1 \
-  || notify "KRITISCH: Annehmen von '$BRANCH' UND Rollback fehlgeschlagen — bitte Box prüfen (restore.sh liegt bereit). Log: $LOG"
-exit 2

deploy/bagatell-annahme.sh

@@ -1,72 +0,0 @@
-#!/usr/bin/env bash
-# Bagatell-Annahme — „Harmloses darf selbst" (User-Entscheid 10.07.2026, konservativ geschnitten):
-# Vorschlags-Branches, die AUSSCHLIESSLICH Markdown-Dateien anlegen oder ändern (Doku/Wiki —
-# keine einzige Code-Zeile, keine Löschungen, keine Umbenennungen, keine Skripte), spielt die
-# Box nachts OHNE Klick ein. Der Weg ist derselbe wie beim Klick im Auftragsbuch:
-# auftrag-annehmen.sh (Merge im Worktree → py_compile-Gate → Push main → Deploy → Health →
-# Auto-Revert). Fangnetz drumherum: Nacht-Sicherung 03:30 (Zeitmaschine) liegt davor, die
-# Morgenlage 04:30 berichtet danach, jede Annahme steht in Chronik + Telegram.
-# JEDE Code-Zeile bleibt Klick-pflichtig — dieses Skript weitet die Klasse NIE selbst aus.
-#
-# Läuft als mc2-bagatell.timer (04:10) über eine /tmp-Kopie (Selbst-Reset-Falle: die Annahme
-# deployt und resettet damit das Repo, in dem dieses Skript liegt).
-set -uo pipefail
-
-SRC="${MC2_SRC:-$HOME/mission-control-v2}"
-STATUS="${MC2_AUFTRAG_STATUS:-/srv/models/mc2-auftragsbuch.json}"
-MAX_PRO_NACHT=2   # jede Annahme startet die Zentrale kurz neu — Nachtruhe wahren
-
-cd "$SRC" || exit 0
-git fetch -q --prune origin 2>/dev/null || exit 0
-
-angenommen=0
-for REF in $(git for-each-ref --format='%(refname:short)' refs/remotes/origin); do
-  [ "$angenommen" -ge "$MAX_PRO_NACHT" ] && break
-  BRANCH="${REF#origin/}"
-  case "$BRANCH" in wartung/*|orchestrator/*|doku/*|feature/*) ;; *) continue ;; esac
-
-  AHEAD="$(git rev-list --count "origin/main..$REF" 2>/dev/null || echo 0)"
-  [ "${AHEAD:-0}" -gt 0 ] || continue
-
-  # Nur unberührte Vorschläge: trägt der Branch schon irgendeinen Annahme-Status
-  # (läuft/fehlgeschlagen/zurückgerollt/…), entscheidet der Commander — nicht wir.
-  STATE="$(python3 - "$STATUS" "$BRANCH" <<'PY'
-import json, sys
-try:
-    print((json.load(open(sys.argv[1], encoding="utf-8")).get("branches", {}).get(sys.argv[2]) or {}).get("state", ""))
-except Exception:
-    print("")
-PY
-)"
-  [ -z "$STATE" ] || continue
-
-  # Bagatell-Klasse: JEDE geänderte Datei endet auf .md UND ist nur angelegt (A) oder
-  # geändert (M). Alles andere (Löschung, Rename R…, Copy C…, Nicht-Markdown) → Klick-Pflicht.
-  DIFF="$(git diff --name-status "origin/main...$REF" 2>/dev/null)"
-  [ -n "$DIFF" ] || continue
-  OK=1
-  while IFS=$'\t' read -r st path _rest; do
-    [ -n "$st" ] || continue
-    case "$st" in A|M) ;; *) OK=0; break ;; esac
-    case "$path" in *.md) ;; *) OK=0; break ;; esac
-  done <<< "$DIFF"
-  [ "$OK" = 1 ] || continue
-
-  N="$(printf '%s\n' "$DIFF" | wc -l | tr -d ' ')"
-  echo "Bagatelle erkannt: $BRANCH ($N Markdown-Datei(en))"
-  curl -sf -m 5 -X POST "${MC_ANNOUNCE_URL:-http://127.0.0.1:9001/api/voice/announce}" \
-    -H 'Content-Type: application/json' \
-    --data "$(jq -n --arg t "Bagatelle (nur Doku, $N Datei(en)): '$BRANCH' wird ohne Klick eingespielt — Fangnetz aktiv, Details in der Morgenlage." \
-      '{text:$t, subject:"[Bagatell-Annahme]", source:"bagatell", priority:"silent"}')" >/dev/null 2>&1 || true
-
-  RUNNER="/tmp/mc2-bagatell-annehmen-$$.sh"
-  cp "$SRC/deploy/auftrag-annehmen.sh" "$RUNNER" || continue
-  if bash "$RUNNER" "$BRANCH"; then
-    angenommen=$((angenommen+1))
-  else
-    # auftrag-annehmen.sh hat selbst gemeldet (fehlgeschlagen/zurückgerollt) und aufgeräumt;
-    # der Branch trägt jetzt einen Status → nächste Nacht fasst ihn niemand mehr automatisch an.
-    echo "Bagatell-Annahme von $BRANCH nicht grün — Meldung kam vom Annahme-Runner."
-  fi
-done
-echo "Bagatell-Lauf fertig: $angenommen eingespielt."

deploy/lucy-annahme.sh

@@ -1,228 +0,0 @@
-#!/usr/bin/env bash
-# Auftragsbuch: einen LUCY-Vorschlags-Branch ANNEHMEN — das PC-Gegenstück zu auftrag-annehmen.sh.
-# Lucy (Electron) lebt auf dem Windows-PC (F:\Coding Stuff\lucy); dist liegt NICHT im Repo.
-# Annehmen heißt darum: Merge auf main (hier, Box) → der PC zieht main, baut dist neu und
-# startet Lucy neu, WENN sie lief (User-Entscheid: Lucy startet nur, wenn der Commander sie will).
-# Schlägt am PC irgendetwas fehl, wird der Merge auf main automatisch revertiert — die laufende
-# Lucy bleibt die alte (der PC-Runner stellt dist aus seinem Backup wieder her).
-#
-# Der PC wird über den PC-Executor (client/hermes-pc/executor.py, :7777, Bearer-Token aus
-# ~/.hermes/config.yaml) gesteuert. /shell hat 60 s Timeout → der Build läuft DETACHED
-# (deploy/lucy-annahme.ps1 im Lucy-Repo schreibt eine Status-Datei, wir pollen sie).
-#
-# Läuft wie der MC2-Runner als EIGENE systemd-Unit und als /tmp-Kopie (Selbst-Reset-Falle).
-# Status-Schlüssel in der Auftragsbuch-JSON: "lucy:<branch>".
-#
-# Nutzung: lucy-annahme.sh <branch>     (z. B. wartung/turncheck-default-aus)
-set -uo pipefail
-
-BRANCH="${1:?Nutzung: lucy-annahme.sh <branch>}"
-SRC="${MC2_SRC:-$HOME/mission-control-v2}"
-LUCY="${MC2_LUCY_DIR:-$HOME/lucy}"
-STATUS="${MC2_AUFTRAG_STATUS:-/srv/models/mc2-auftragsbuch.json}"
-HERMES_CONF="${HERMES_CONF:-$HOME/.hermes/config.yaml}"
-SLUG="lucy-$(echo "$BRANCH" | tr '/' '-')"
-WT="/tmp/annahme-$SLUG"
-LOG="/tmp/annahme-$SLUG.log"
-
-# Windows-Seite (Pfade im PC-Dateisystem; einfach gehalten — EIN PC, EIN Checkout).
-PC_REPO='F:\Coding Stuff\lucy'
-PC_STATUSFILE='F:\Coding Stuff\lucy\.lucy-annahme.json'
-PC_RUNNER='F:\Coding Stuff\lucy\deploy\lucy-annahme.ps1'
-BUILD_TIMEOUT_S=1500   # 25 min Deckel für npm ci + tsc + electron-builder + Stimm-Warmup
-
-notify(){ bash "$SRC/deploy/notify.sh" -s "[Auftragsbuch]" "$1" || true; }
-
-# Status-Fortschritt für die UI (atomar via tmp+replace; die API liest die Datei nur).
-status(){  # $1=state  $2=detail
-  python3 - "$STATUS" "lucy:$BRANCH" "$1" "$2" <<'PY'
-import json, os, sys, time
-p, key, state, detail = sys.argv[1:5]
-try:
-    d = json.load(open(p, encoding="utf-8"))
-except Exception:
-    d = {}
-d.setdefault("branches", {})[key] = {"state": state, "detail": detail, "ts": time.time()}
-tmp = p + ".tmp"
-json.dump(d, open(tmp, "w", encoding="utf-8"), ensure_ascii=False)
-os.replace(tmp, p)
-PY
-}
-
-# PC-Executor: PowerShell-Kommando ausführen. stdout des PCs → stdout; rc 0 nur wenn
-# Transport UND Kommando grün. Token/URL kommen aus der Hermes-Config (kein zweiter Ablageort).
-PC_URL="$(sed -n 's/^[[:space:]]*PC_EXECUTOR_URL:[[:space:]]*//p' "$HERMES_CONF" | head -1 | tr -d "\"'" | tr -d '[:space:]')"
-PC_TOKEN="$(sed -n 's/^[[:space:]]*PC_EXECUTOR_TOKEN:[[:space:]]*//p' "$HERMES_CONF" | head -1 | tr -d "\"'" | tr -d '[:space:]')"
-pc_shell(){  # $1 = PowerShell-Kommando
-  python3 - "$PC_URL" "$PC_TOKEN" "$1" <<'PY'
-import json, sys, urllib.request
-url, token, cmd = sys.argv[1:4]
-req = urllib.request.Request(url + "/shell", data=json.dumps({"command": cmd}).encode(),
-                             headers={"Authorization": "Bearer " + token,
-                                      "Content-Type": "application/json"})
-try:
-    r = json.load(urllib.request.urlopen(req, timeout=58))
-except Exception as e:
-    print(f"(PC-Executor nicht erreichbar: {e})")
-    sys.exit(2)
-out = (r.get("stdout") or "").strip()
-if out:
-    print(out)
-err = (r.get("stderr") or "").strip()
-if err:
-    print(err, file=sys.stderr)
-sys.exit(0 if r.get("returncode") == 0 else 1)
-PY
-}
-
-cleanup_wt(){ git -C "$LUCY" worktree remove --force "$WT" 2>/dev/null || true; }
-
-fail(){
-  status "fehlgeschlagen" "$1"
-  notify "Lucy-Vorschlag '$BRANCH' konnte NICHT eingespielt werden: $1 — nichts wurde verändert, der Branch bleibt liegen."
-  cleanup_wt
-  exit 1
-}
-
-# Revert nach schon gepushtem Merge (PC-Phase rot): main zurückdrehen, PC-Checkout nachziehen.
-revert_main(){  # $1 = Grund für die Meldung
-  status "rollback" "PC-Phase rot — Merge wird automatisch zurückgedreht"
-  git -C "$LUCY" fetch -q origin || true
-  cleanup_wt
-  if git -C "$LUCY" worktree add --detach "$WT" origin/main >/dev/null 2>&1 \
-     && git -C "$WT" -c user.name="Auftragsbuch" -c user.email="auftragsbuch@box.local" \
-          revert -m 1 --no-edit HEAD >>"$LOG" 2>&1 \
-     && git -C "$WT" push origin HEAD:main >>"$LOG" 2>&1; then
-    cleanup_wt
-    # PC-Checkout best-effort auf den revertierten Stand nachziehen (Quelle = laufende Lucy).
-    pc_shell "git -C '$PC_REPO' fetch origin main 2>&1; git -C '$PC_REPO' merge --ff-only FETCH_HEAD 2>&1" >>"$LOG" 2>&1 || true
-    status "zurueckgerollt" "$1 — Merge automatisch revertiert, Lucy läuft in der alten Version weiter"
-    notify "Lucy-Vorschlag '$BRANCH' hat den PC-Build/Neustart GERISSEN: $1. Merge automatisch zurückgedreht — Lucy läuft in der alten Version weiter. Der Branch bleibt zur Analyse liegen. Log: $LOG"
-    exit 1
-  fi
-  cleanup_wt
-  status "kritisch" "Revert fehlgeschlagen — Lucy-Repo und PC von Hand prüfen"
-  notify "KRITISCH: Lucy-Annahme '$BRANCH' scheiterte UND der automatische Revert schlug fehl — bitte Lucy-Repo (Gitea main) und PC prüfen. Log: $LOG"
-  exit 2
-}
-
-[ -n "$PC_URL" ] && [ -n "$PC_TOKEN" ] || fail "PC-Executor-Zugang fehlt in $HERMES_CONF (PC_EXECUTOR_URL/TOKEN)"
-
-# ── Vorprüfungen am PC (VOR dem Merge — solange ist nichts kaputtzumachen) ──
-status "laeuft" "Vorprüfung: ist der PC bereit?"
-curl -sf -m 8 "$PC_URL/health" >/dev/null 2>&1 \
-  || fail "PC-Executor nicht erreichbar — Lucy-Annahme braucht den eingeschalteten PC (Executor-Task läuft bei Anmeldung)"
-
-PC_BRANCH="$(pc_shell "git -C '$PC_REPO' rev-parse --abbrev-ref HEAD" 2>>"$LOG")" \
-  || fail "PC-Arbeitskopie nicht lesbar (git am PC): $PC_BRANCH"
-[ "$PC_BRANCH" = "main" ] || fail "PC-Arbeitskopie steht auf '$PC_BRANCH' statt main — bitte am PC aufräumen"
-
-PC_DIRTY="$(pc_shell "git -C '$PC_REPO' status --porcelain -uno" 2>>"$LOG")" \
-  || fail "PC-Arbeitskopie nicht prüfbar"
-[ -z "$PC_DIRTY" ] || fail "PC-Arbeitskopie hat ungespeicherte Änderungen — bitte erst am PC committen/aufräumen: $(echo "$PC_DIRTY" | head -3 | tr '\n' ' ')"
-
-WAS_RUNNING="$(pc_shell "if (Get-Process Lucy -ErrorAction SilentlyContinue) { '1' } else { '0' }" 2>>"$LOG")" || WAS_RUNNING="0"
-case "$WAS_RUNNING" in 1|0) ;; *) WAS_RUNNING="0" ;; esac
-
-# ── Merge auf main (Box, isolierter Worktree — wie beim MC2-Runner) ─────────
-status "laeuft" "Merge wird vorbereitet"
-git -C "$LUCY" fetch -q origin || fail "git fetch (Gitea) fehlgeschlagen"
-git -C "$LUCY" rev-parse --verify -q "refs/remotes/origin/$BRANCH" >/dev/null \
-  || fail "Branch origin/$BRANCH existiert nicht (schon gemergt/gelöscht?)"
-
-# Kaputt aufgesetzte Branches (kein gemeinsamer Vorfahre) → Merge kann NIE gelingen.
-git -C "$LUCY" merge-base origin/main "origin/$BRANCH" >/dev/null 2>&1 \
-  || fail "Branch hat keinen gemeinsamen Ursprung mit main (kaputt aufgesetzt, z. B. git init statt Klonen) — bitte ablehnen (mit Grund) und die Idee neu in die Queue geben"
-
-cleanup_wt
-git -C "$LUCY" worktree add --detach "$WT" origin/main >/dev/null 2>&1 || fail "Worktree konnte nicht angelegt werden"
-MERGE_MSG="Auftragsbuch: Lucy-Vorschlag '$BRANCH' angenommen (Ein-Klick-Gate)"
-if ! git -C "$WT" -c user.name="Auftragsbuch" -c user.email="auftragsbuch@box.local" \
-     merge --no-ff "origin/$BRANCH" -m "$MERGE_MSG" >>"$LOG" 2>&1; then
-  git -C "$WT" merge --abort 2>/dev/null || true
-  # Selbstheilung: veralteten Branch mechanisch auf main rebasen (wie im MC2-Runner).
-  status "laeuft" "Merge-Konflikt — Auto-Rebase wird versucht"
-  WT2="/tmp/annahme-rebase-$SLUG"
-  git -C "$LUCY" worktree remove --force "$WT2" 2>/dev/null || true
-  REBASED=""
-  if git -C "$LUCY" worktree add --detach "$WT2" "origin/$BRANCH" >/dev/null 2>&1 \
-     && git -C "$WT2" -c user.name="Auftragsbuch" -c user.email="auftragsbuch@box.local" \
-          rebase origin/main >>"$LOG" 2>&1; then
-    REBASED="$(git -C "$WT2" rev-parse HEAD)"
-  else
-    git -C "$WT2" rebase --abort 2>/dev/null || true
-  fi
-  git -C "$LUCY" worktree remove --force "$WT2" 2>/dev/null || true
-  [ -n "$REBASED" ] || fail "Merge-Konflikt mit main, Auto-Rebase scheiterte ebenfalls — echter Inhaltskonflikt; am einfachsten ablehnen und die Idee neu in die Queue geben (frischer Branch von aktuellem main)"
-  git -C "$WT" -c user.name="Auftragsbuch" -c user.email="auftragsbuch@box.local" \
-      merge --no-ff "$REBASED" -m "$MERGE_MSG — auto-rebased (Branch war veraltet)" >>"$LOG" 2>&1 \
-    || { git -C "$WT" merge --abort 2>/dev/null || true; fail "Merge nach Auto-Rebase fehlgeschlagen (unerwartet) — Log: $LOG"; }
-fi
-
-status "laeuft" "Push nach main läuft"
-PUSHED=0
-for _ in 1 2 3; do
-  git -C "$WT" push origin HEAD:main >>"$LOG" 2>&1 && { PUSHED=1; break; }
-  sleep 5
-done
-[ "$PUSHED" = 1 ] || fail "Push nach main fehlgeschlagen (Gitea nicht erreichbar / Token?)"
-cleanup_wt
-
-# ── PC: main ziehen, Build detached starten ─────────────────────────────────
-status "laeuft" "PC zieht den neuen Stand"
-pc_shell "git -C '$PC_REPO' fetch origin main 2>&1; if (\$LASTEXITCODE -ne 0) { exit 1 }; git -C '$PC_REPO' merge --ff-only FETCH_HEAD 2>&1" >>"$LOG" 2>&1 \
-  || revert_main "PC konnte main nicht ziehen (git fetch/merge am PC rot)"
-
-pc_shell "if (Test-Path '$PC_RUNNER') { exit 0 } else { exit 1 }" >>"$LOG" 2>&1 \
-  || revert_main "PC-Runner-Skript fehlt im Lucy-Repo (deploy/lucy-annahme.ps1)"
-
-# WICHTIG: -File-Pfad MUSS eingebettete Anführungszeichen tragen — Start-Process fügt
-# die ArgumentList-Elemente OHNE Quoting zusammen; 'F:\Coding Stuff\…' zerbricht sonst am
-# Leerzeichen und die gespawnte powershell stirbt still (erster Live-Lauf, 12.07.).
-pc_shell "Remove-Item -Force '$PC_STATUSFILE' -ErrorAction SilentlyContinue; Start-Process powershell -WindowStyle Hidden -ArgumentList '-NoProfile','-ExecutionPolicy','Bypass','-File','\"$PC_RUNNER\"','-WasRunning','$WAS_RUNNING'" >>"$LOG" 2>&1 \
-  || revert_main "PC-Build ließ sich nicht starten"
-
-# ── Status-Datei pollen, Fortschritt in die UI spiegeln ─────────────────────
-status "laeuft" "PC baut Lucy (dist) — das dauert ein paar Minuten"
-DEADLINE=$(( $(date +%s) + BUILD_TIMEOUT_S ))
-LAST_DETAIL=""
-FINAL=""
-while [ "$(date +%s)" -lt "$DEADLINE" ]; do
-  sleep 10
-  RAW="$(pc_shell "if (Test-Path '$PC_STATUSFILE') { Get-Content -Raw '$PC_STATUSFILE' }" 2>>"$LOG")" || continue
-  [ -n "$RAW" ] || continue
-  # Parse OHNE f-String-Escapes: \" in f-String-Ausdruecken ist seit Python 3.12/3.14
-  # ein SyntaxError (alter Pre-3.12-Stil) — genau das legte den ersten Live-Lauf lahm.
-  PARSED="$(printf '%s' "$RAW" | python3 -c '
-import json, sys
-try:
-    d = json.loads(sys.stdin.read())
-except Exception:
-    sys.exit(0)
-detail = str(d.get("detail", "")).replace("|", "/").replace("\n", " ")
-done = "1" if d.get("done") else "0"
-ok = "1" if d.get("ok") else "0"
-print(done + "|" + ok + "|" + detail)
-')"
-  [ -n "$PARSED" ] || continue
-  DONE="${PARSED%%|*}"; REST="${PARSED#*|}"; OK="${REST%%|*}"; DETAIL="${REST#*|}"
-  if [ "$DETAIL" != "$LAST_DETAIL" ] && [ -n "$DETAIL" ]; then
-    LAST_DETAIL="$DETAIL"
-    status "laeuft" "PC: $DETAIL"
-  fi
-  if [ "$DONE" = "1" ]; then FINAL="$OK"; break; fi
-done
-
-[ -n "$FINAL" ] || revert_main "PC-Build-Timeout nach $((BUILD_TIMEOUT_S/60)) Minuten (Status-Datei blieb offen)"
-[ "$FINAL" = "1" ] || revert_main "${LAST_DETAIL:-PC meldet Fehler ohne Detail}"
-
-# ── Grün: Branch aufräumen, ehrlich melden ──────────────────────────────────
-git -C "$LUCY" push origin --delete "$BRANCH" >>"$LOG" 2>&1 || true
-git -C "$LUCY" fetch -q --prune origin 2>/dev/null || true
-status "eingespielt" "${LAST_DETAIL:-Build grün}"
-if [ "$WAS_RUNNING" = "1" ]; then
-  notify "Lucy-Vorschlag '$BRANCH' ist LIVE — dist am PC neu gebaut, Lucy neu gestartet, Stimme meldet sich. ✅"
-else
-  notify "Lucy-Vorschlag '$BRANCH' ist eingespielt — dist am PC neu gebaut. Lucy war aus und bleibt aus; die neue Version startet beim nächsten Öffnen. ✅"
-fi
-exit 0

deploy/selbst-inventur.sh

@@ -97,21 +97,9 @@ for x in sorted(off, key=lambda x: x.get("title") or ""):
     print("- [{}] {}".format(x.get("status", "?"), (x.get("title") or "")[:100]))
 ' 2>/dev/null || echo "(Queue nicht lesbar)"
   echo
-  echo "## Offene Karten im Auftragsbuch"
-  curl -sf -m 10 "$API/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 sorted(items, key=lambda x: x.get("branch") or ""):
-    print("- {}:{}".format(it.get("repo", "mc2"), it.get("branch", "?")))
-' 2>/dev/null || echo "(Auftragsbuch nicht lesbar)"
   echo
   echo "## Feste Leitplanken (Kurzfassung — Details docs/wissen/)"
-  echo "- Jede Code-Zeile geht NUR ueber eine Auftragsbuch-Karte live (Klick des Commanders)."
+  echo "- Jede Code-Zeile geht NUR als Branch nach Gitea live: Ampel gruen, Merge durch den Commander, deploy.sh."
   echo "- TABU ohne explizites User-Ja: Security (approvals/Tokens/ufw/sudoers), ~/.hermes/config.yaml, systemd-Units, Hermes-Quellcode."
   echo "- Updates macht der Auto-Update-Timer mit Fangnetz — niemand sonst."
 } > "$STECK.tmp" 2>/dev/null

deploy/skills/konzept-fliessband/SKILL.md

@@ -83,8 +83,8 @@ heavy-Rollen einer Runde am Stueck (heavy bleibt warm), DANN der Skeptiker (ein
   dieses Projekt nicht (noetige Komponente gibt es nur als Image o. ae.), sag das im Konzept
   AUSDRUECKLICH mit Begruendung — still ignorieren gilt nicht.
 - **★ Explizite Commander-Wahl UEBERSTIMMT deine Einschaetzung.** Steht im Auftrag eine Zeile
-  „AUFWAND (vom Commander gewaehlt): SIMPEL …" bzw. „… GRUENDLICH …" (der Commander hat im
-  Auftragsbuch „IDE: simpel" oder „IDE: gruendlich" geklickt), dann HALTE DICH DARAN — SIMPEL =
+  „AUFWAND (vom Commander gewaehlt): SIMPEL …" bzw. „… GRUENDLICH …" (der Commander hat in der
+  Ideen-Ansicht „IDE: simpel" oder „IDE: gruendlich" gewaehlt), dann HALTE DICH DARAN — SIMPEL =
   2 Rollen/1 Runde, GRUENDLICH = volle 3-5 Rollen/bis 3 Runden — auch wenn deine eigene
   Schaetzung anders ausfaellt. Nur wenn KEINE solche Zeile da ist, entscheidest du selbst.
 - **Max 3 Denk-Runden — keine Endlosschleife.** Nach der letzten Runde (je nach Groesse 1-3) kommt

deploy/skills/morning-report/SKILL.md

@@ -17,5 +17,5 @@ Dieser Skill fungiert als dein persönlicher, KI-gesteuerter Sysadmin, der dir j
 1. **System-Metriken abrufen**: Ruft den Health-Status und Load der Box ab.
 2. **Logs durchkämmen**: Sucht nach Auffälligkeiten, Fehlern oder Crashes in der Nacht.
 3. **News Fetching**: Liest die Top-Posts von Hacker News (oder anderen Tech-Feeds), filtert sie nach AI-Relevanz und fasst die 3 wichtigsten Entwicklungen zusammen.
-4. **Auftragsbuch Check**: Prüft, ob neue unentschiedene Vorschläge im Auftragsbuch liegen.
+4. **Offene Branches**: Nennt ungemergte Vorschlags-Branches auf Gitea (wartung/*, feature/*, doku/*), falls welche warten.
 5. **Report Generierung**: Bündelt all diese Informationen in eine kompakte, handyfreundliche (sehr kurze) Nachricht und schickt sie via Telegram an den Commander.