mission-control-v2/deploy/karten-gutachter.sh

#!/usr/bin/env bash
# Karten-Gutachter (naechtlich 04:00 — "Lucy kennt sich", 12.07.2026): stempelt jede neue
# Auftragsbuch-Karte mit einer Empfehlung (ANNEHMEN/ABLEHNEN/UNKLAR + EIN ehrlicher Satz),
# damit der Commander nie blind klickt. Ein-Schuss-Richter gegen llama-swap (:8080,
# fremdblick-Architektur, Muster chef-gutachter-feed.sh) — bekommt Karte (Commit-Text,
# Dateien, Diff) UND den Selbst-Steckbrief (was schon existiert), prueft also genau die
# Falle vom 12.07. (redundanter Gateway-Restart-Vorschlag). Der Stempel ist eine MEINUNG,
# kein Gate: die Karte bleibt klickbar, die Entscheidung bleibt beim Commander.
# Laeuft als Cron mit --no-agent: stdout leer = still; gestempelte Karten = kurze Zeilen.
# Ablage: /srv/models/mc2-karten-gutachten.json (Backend mischt es in die Karten-API).
set -uo pipefail

API="${MC_API:-http://127.0.0.1:9001}"
OUT="${MC2_KARTEN_GUTACHTEN:-/srv/models/mc2-karten-gutachten.json}"
ENDPOINT="${GUTACHTER_ENDPOINT:-http://127.0.0.1:8080/v1/chat/completions}"
CHEF="${GUTACHTER_MODEL:-gpt-oss-120b}"
VERTRETUNG="${GUTACHTER_FALLBACK:-GLM-4.7-Flash}"
STECK="$HOME/.hermes/state/selbst-steckbrief.md"
MAX_JE_LAUF=3   # Nacht-GPU-Budget: Rest kommt morgen dran

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": "karten-gutachter", "priority": "silent"}))
PY
)" >/dev/null 2>&1 || true
}

TMPD="$(mktemp -d /tmp/karten-gutachter.XXXXXX)"
trap 'rm -rf "$TMPD"' EXIT

if ! curl -sf -m 20 "$API/api/auftragsbuch" -o "$TMPD/items.json" 2>/dev/null; then
  echo "Karten-Gutachter: Auftragsbuch nicht erreichbar — kein Lauf."
  exit 0
fi

# Offene, noch ungestempelte Karten ermitteln + verwaiste Stempel aufraeumen (Karte weg
# oder neuer Stand = Stempel weg). Schluessel: "<repo>:<branch>@<ts>" haengt am Commit-
# Zeitstempel — ein nachgeschobener Commit macht den alten Stempel automatisch ungueltig.
python3 - "$TMPD/items.json" "$OUT" > "$TMPD/plan.txt" <<'PY'
import json, sys, os

items = (json.load(open(sys.argv[1], encoding="utf-8")) or {}).get("items") or []
out_path = sys.argv[2]
try:
    alt = json.load(open(out_path, encoding="utf-8"))
    if not isinstance(alt, dict):
        alt = {}
except Exception:
    alt = {}

offen = {}
for it in items:
    state = (it.get("status") or {}).get("state")
    if state in ("eingespielt", "laeuft", "rollback"):
        continue  # entschieden oder gerade in Arbeit — kein Stempel noetig
    key = "{}:{}".format(it.get("repo", "mc2"), it.get("branch", "?"))
    offen[key] = it

# Verwaiste/veraltete Stempel raus (atomar zurueckschreiben).
neu = {}
for key, g in alt.items():
    it = offen.get(key)
    if it and g.get("commit_ts") == it.get("ts"):
        neu[key] = g
tmp = out_path + ".tmp"
with open(tmp, "w", encoding="utf-8") as f:
    json.dump(neu, f, ensure_ascii=False)
os.replace(tmp, out_path)

for key, it in offen.items():
    if key in neu:
        continue
    repo, branch = key.split(":", 1)
    print("\x1f".join([repo, branch, str(it.get("ts") or 0),
                       (it.get("subject") or "")[:200],
                       (it.get("shortstat") or "")[:200]]))
PY

RASTER='Du bist der KARTEN-GUTACHTER einer lokalen KI-Box. Du bekommst EINE Vorschlags-Karte aus dem Auftragsbuch (Commit-Text, Datei-Liste, Diff) und den SELBST-STECKBRIEF der Box (was schon existiert und laeuft). Der Commander ist kein Entwickler — dein Urteil ist seine einzige fachliche Zweitmeinung vor dem Klick. Pruefe NUR anhand des Materials, erfinde nichts: (1) REDUNDANZ — existiert das laut Steckbrief oder Diff schon? Ein Vorschlag, der Bestehendes nur nachbaut oder verschlechtert (z. B. funktionierende Einstellungen ersetzt), ist abzulehnen. (2) RISIKO — beruehrt der Diff Security (Tokens/approvals/ufw/sudoers), loescht er Daten oder aendert er Verhalten, das der Commander nicht bestellt hat? (3) NUTZEN — loest er ein echtes, benanntes Problem? Antworte auf DEUTSCH in exakt zwei Zeilen: "URTEIL: ANNEHMEN" oder "URTEIL: ABLEHNEN" oder "URTEIL: UNKLAR", danach "SATZ: <ein ehrlicher Satz Begruendung in Alltagssprache>". Kein weiterer Text.'

judge() { # $1=Modell  $2=Timeout  $3=max_tokens  (liest $EVID)
  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'
}

N=0
while IFS=$'\x1f' read -r repo branch cts subject stat; do
  [ -n "${repo:-}" ] || continue
  [ "$N" -ge "$MAX_JE_LAUF" ] && { echo "Karten-Gutachter: Tages-Deckel ($MAX_JE_LAUF) erreicht — Rest morgen."; break; }
  DIFF="$(curl -sfG -m 30 "$API/api/auftragsbuch/diff" \
      --data-urlencode "branch=$branch" --data-urlencode "repo=$repo" 2>/dev/null \
    | python3 -c '
import json, sys
try:
    print((json.load(sys.stdin).get("diff") or "")[:20000])
except Exception:
    pass' || true)"
  # Leerer Diff = deterministisch UNKLAR, OHNE Richter (Erstlauf 12.07.: eine Karte mit
  # 0 Dateien bekam trotzdem ANNEHMEN — ein LLM kann einen leeren Vorschlag nicht pruefen).
  if [ -z "${DIFF//[[:space:]]/}" ]; then
    python3 - "$OUT" "$repo" "$branch" "$cts" <<'PY'
import json, os, sys, time
out_path = sys.argv[1]
try:
    data = json.load(open(out_path, encoding="utf-8"))
    if not isinstance(data, dict):
        data = {}
except Exception:
    data = {}
data["{}:{}".format(sys.argv[2], sys.argv[3])] = {
    "empfehlung": "UNKLAR",
    "satz": "Der Vorschlag hat einen LEEREN Diff (0 geaenderte Dateien gegen main) — da gibt es nichts zu pruefen; technisch verdaechtig, im Zweifel ablehnen.",
    "richter": "mechanische Regel (leerer Diff)",
    "commit_ts": int(sys.argv[4]) if sys.argv[4].isdigit() else None,
    "ts": int(time.time())}
tmp = out_path + ".tmp"
with open(tmp, "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False)
os.replace(tmp, out_path)
PY
    N=$((N + 1))
    echo "Karte ${branch}: Empfehlung UNKLAR — leerer Diff (mechanische Regel, kein Richter noetig)."
    briefkasten "Karten-Gutachter" "Karte '${branch}' (${repo}): Empfehlung UNKLAR — der Diff ist leer (0 Dateien), technisch verdaechtig."
    continue
  fi
  EVID="KARTE ${repo}:${branch}
COMMIT: ${subject}
UMFANG: ${stat}

DIFF (ggf. gekuerzt):
${DIFF:-(Diff nicht lesbar)}

SELBST-STECKBRIEF DER BOX (was schon existiert):
$(head -90 "$STECK" 2>/dev/null || echo '(noch keine Selbst-Inventur gelaufen)')"

  RICHTER="$CHEF"
  URTEIL_RAW="$(judge "$CHEF" 420 1600)"
  if [ -z "${URTEIL_RAW// /}" ]; then
    RICHTER="$VERTRETUNG (Vertretung)"
    URTEIL_RAW="$(judge "$VERTRETUNG" 240 1200)"
  fi
  [ -z "${URTEIL_RAW// /}" ] && { echo "Karte ${branch}: Gutachter ausgefallen (kein Richter erreichbar)."; continue; }

  printf '%s' "$URTEIL_RAW" > "$TMPD/urteil.txt"
  STAMP="$(python3 - "$TMPD/urteil.txt" "$OUT" "$repo" "$branch" "$cts" "$RICHTER" <<'PY'
import json, os, re, sys, time

raw = open(sys.argv[1], encoding="utf-8", errors="replace").read()
m_u = re.search(r"URTEIL:\s*(ANNEHMEN|ABLEHNEN|UNKLAR)", raw, re.I)
m_s = re.search(r"SATZ:\s*(.+)", raw)
urteil = (m_u.group(1).upper() if m_u else "UNKLAR")
satz = (m_s.group(1).strip() if m_s else "Analyse unklar — Urteil nicht lesbar.")[:300]
out_path = sys.argv[2]
try:
    data = json.load(open(out_path, encoding="utf-8"))
    if not isinstance(data, dict):
        data = {}
except Exception:
    data = {}
key = "{}:{}".format(sys.argv[3], sys.argv[4])
data[key] = {"empfehlung": urteil, "satz": satz, "richter": sys.argv[6],
             "commit_ts": int(sys.argv[5]) if sys.argv[5].isdigit() else None,
             "ts": int(time.time())}
tmp = out_path + ".tmp"
with open(tmp, "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False)
os.replace(tmp, out_path)
print(urteil + "\x1f" + satz)
PY
)"
  URTEIL="${STAMP%%$'\x1f'*}"; SATZ="${STAMP#*$'\x1f'}"
  N=$((N + 1))
  echo "Karte ${branch}: Empfehlung ${URTEIL} — ${SATZ}"
  briefkasten "Karten-Gutachter" "Karte '${branch}' (${repo}): Empfehlung ${URTEIL} — ${SATZ} (Richter: ${RICHTER})"
done < "$TMPD/plan.txt"

# stdout bleibt LEER, wenn nichts zu stempeln war (--no-agent => stille Nacht).