#!/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