#!/usr/bin/env python3
import sys
sys.path.insert(0, '/home/openclaw/.openclaw/workspace/bin')
sys.path.insert(0, '/home/openclaw/.openclaw/workspace/lib')
try:
    from buenzli_wrapper import buenzli_response
    USE_BUENZLI = True
except:
    USE_BUENZLI = False
    def buenzli_response(t): return t

try:
    from structured_router import classify_intent
    USE_STRUCTURED_ROUTER = True
except:
    USE_STRUCTURED_ROUTER = False
    def classify_intent(m): return None

    USE_BUENZLI = False
    def buenzli_response(t): return t

try:
    from intent_families import classify_intent_family, collect_intent_families
    USE_INTENT_FAMILIES = True
except Exception:
    USE_INTENT_FAMILIES = False
    def classify_intent_family(_message, service_hints=None): return {'family': ''}

try:
    from playbook_store import format_playbook_context
    USE_PLAYBOOKS = True
except Exception:
    USE_PLAYBOOKS = False
    def format_playbook_context(_message, analysis=None, limit=None): return ''

try:
    from plan_first import build_plan, render_plan_context
    USE_PLAN_FIRST = True
except Exception:
    USE_PLAN_FIRST = False
    def build_plan(_message, _analysis, memory_ctx='', retrieval_ctx='', playbook_ctx=''): return None
    def render_plan_context(_plan): return ''


try:
    from intent_composition import compose_family_plan
    USE_INTENT_COMPOSITION = True
except Exception:
    USE_INTENT_COMPOSITION = False
    def compose_family_plan(_message, _analysis, family_candidates=None): return {'composed': False}


try:
    from composition_policy import choose_plan
    USE_COMPOSITION_POLICY = True
except Exception:
    USE_COMPOSITION_POLICY = False
    def choose_plan(base_tools, proposed_tools, family_candidates=None):
        return {'selected_tools': list(proposed_tools), 'policy': 'fallback_no_policy'}

try:
    from result_state import persist_result_state as _persist_result_state
except Exception:
    def _persist_result_state(
        message,
        analysis,
        final_text,
        evidence_items,
        *,
        should_skip_heavy_persistence,
        update_topic_state,
        compact_episode_text,
        remember_episode,
        record_incident_if_useful,
    ):
        if should_skip_heavy_persistence(message, analysis, evidence_items):
            return
        update_topic_state(message, analysis, final_text)
        remember_episode(compact_episode_text(message, analysis, final_text, evidence_items))
        record_incident_if_useful(message, analysis, final_text, evidence_items)

try:
    from final_answer_policy import should_skip_verify as _should_skip_verify
except Exception:
    def _should_skip_verify(analysis, evidence_items, tool_kinds):
        single_final = (
            len(evidence_items) == 1
            and tool_kinds.get(str(evidence_items[0].get('tool') or '')) == 'final'
            and bool(evidence_items[0].get('grounded'))
        )
        if single_final:
            return (
                analysis.get('role') in {'ops', 'research'}
                or analysis.get('task_type') in {'status', 'summarize', 'memory'}
                or str(evidence_items[0].get('tool') or '') in {'memory_profile', 'light_status', 'url_research', 'public_services_health', 'emby_user_provision', 'web_root_cause'}
            )
        last_ev = evidence_items[-1] if evidence_items else {}
        last_tool = str(last_ev.get('tool') or '')
        prep_tools_ok = {'final', 'memory', 'evidence'}
        composed_final = (
            len(evidence_items) >= 2
            and bool(analysis.get('force_sequential'))
            and bool(analysis.get('composition_reason'))
            and tool_kinds.get(last_tool) == 'final'
            and bool(last_ev.get('grounded'))
            and all(bool(item.get('grounded')) for item in evidence_items[:-1])
            and all(tool_kinds.get(str(item.get('tool') or '')) in prep_tools_ok for item in evidence_items[:-1])
        )
        return composed_final and last_tool in {'personal_assist', 'user_service_access_diagnose', 'web_root_cause', 'url_research', 'general_answer', 'light_status'}

try:
    from sequential_runner import run_sequential_tools as _run_sequential_tools
except Exception:
    def _run_sequential_tools(
        message,
        tools,
        analysis,
        *,
        is_complex_task,
        run_tool,
        evidence_object,
        trace_stage,
        sequential_tool_budget,
        summarize_sequential_context,
    ):
        collected = []
        seq_ctx = ''
        is_seq = bool(analysis.get('force_sequential')) or is_complex_task(message, analysis)
        failed_ev = None
        for name in tools:
            msg = f"{message}\n\nBisherige Analyseergebnisse:\n{seq_ctx}" if is_seq and seq_ctx else message
            prev_budget = os.environ.get('BIBABOT_TOOL_TIMEOUT')
            budget = sequential_tool_budget(name, is_seq)
            try:
                if budget:
                    os.environ['BIBABOT_TOOL_TIMEOUT'] = str(budget)
                rc, out, err = run_tool(name, msg)
            finally:
                if prev_budget is None:
                    os.environ.pop('BIBABOT_TOOL_TIMEOUT', None)
                else:
                    os.environ['BIBABOT_TOOL_TIMEOUT'] = prev_budget
            ev = evidence_object(name, rc, out, err)
            collected.append(ev)
            if out and is_seq:
                seq_ctx = summarize_sequential_context(collected)
            if rc == 124:
                trace_stage('sequential_timeout', name, f'budget={budget}')
                failed_ev = ev
                break
            if rc != 0:
                trace_stage('sequential_tool_error', name, (err or '')[:200])
                failed_ev = ev
                break
        trace_stage('multi_tool_collected', f'seq={is_seq}', str([(item.get("tool"), len(item.get("output", ""))) for item in collected]))
        return {'collected': collected, 'failed_ev': failed_ev, 'is_sequential': is_seq}

try:
    from composition_selector import apply_composition_selection as _apply_composition_selection
except Exception:
    def _apply_composition_selection(analysis, composition, family_candidates, *, choose_plan, use_policy=True):
        if not composition or not composition.get('composed'):
            return analysis, None, None
        before_comp = dict(analysis)
        if use_policy:
            policy = choose_plan(
                before_comp.get('tools') or [],
                composition.get('tools') or [],
                family_candidates,
                composition_reason=composition.get('reason', ''),
            ) or {}
        else:
            policy = {'selected_tools': list(composition.get('tools') or []), 'policy': 'no_policy'}
        updated = dict(analysis)
        updated.update(
            role=composition.get('role', analysis.get('role')),
            task_type=composition.get('task_type', analysis.get('task_type')),
            tools=policy.get('selected_tools') or composition.get('tools') or analysis.get('tools'),
            needs_setup_context=bool(composition.get('needs_setup_context', analysis.get('needs_setup_context'))),
            needs_memory=bool(composition.get('needs_memory', analysis.get('needs_memory'))),
            force_sequential=bool(composition.get('force_sequential')),
            composition_reason=composition.get('reason', ''),
            composition_policy=policy.get('policy', ''),
        )
        return updated, before_comp, {**composition, 'policy': policy.get('policy', '')}

try:
    from intent_normalizer import normalize_intent_family as _normalize_intent_family
except Exception:
    def _normalize_intent_family(message, analysis, family_info=None, *, classify_intent_family, service_hints):
        tools = list(analysis.get('tools') or [])
        primary = tools[0] if tools else ''
        family = (family_info or classify_intent_family(message, service_hints)).get('family', '')
        if family == 'url_research':
            analysis.update(role='research', task_type='summarize', tools=['url_research'], needs_setup_context=False, needs_web_research=False, confidence=max(float(analysis.get('confidence', 0.0)), 0.96))
            return analysis
        if family == 'web_diagnose':
            analysis.update(role='ops', task_type='diagnose', tools=['web_root_cause'], needs_setup_context=True, needs_web_research=False, confidence=max(float(analysis.get('confidence', 0.0)), 0.95))
            return analysis
        if family in {'memory_store', 'memory_lookup'}:
            analysis.update(role='personal', task_type='memory', tools=['memory_profile'], needs_memory=True, needs_web_research=False, confidence=max(float(analysis.get('confidence', 0.0)), 0.93))
            return analysis
        if family == 'live_status':
            analysis.update(role='ops', task_type='status', tools=['light_status'], needs_setup_context=True, needs_web_research=False, confidence=max(float(analysis.get('confidence', 0.0)), 0.95))
            return analysis
        if family == 'emby_provision':
            analysis.update(role='ops', task_type='howto', tools=['emby_user_provision'], needs_setup_context=True, needs_web_research=False, confidence=max(float(analysis.get('confidence', 0.0)), 0.95))
            return analysis
        if family == 'user_access':
            analysis.update(role='ops', task_type='diagnose', tools=['user_service_access_diagnose'], needs_setup_context=True, needs_web_research=False, confidence=max(float(analysis.get('confidence', 0.0)), 0.94))
            return analysis
        if family == 'stable_knowledge' and primary in {'web_research', 'url_research'}:
            analysis.update(role='general', task_type='explain', tools=['general_answer'], needs_web_research=False, confidence=max(float(analysis.get('confidence', 0.0)), 0.9))
            return analysis
        if family == 'personal_help' and primary not in {'personal_assist', 'expert_write'}:
            analysis.update(role='personal', task_type='assist', tools=['personal_assist'], needs_memory=bool((family_info or {}).get('needs_memory')), needs_web_research=False, confidence=max(float(analysis.get('confidence', 0.0)), 0.9))
            return analysis
        if family == 'personal_help' and primary == 'personal_assist' and not (family_info or {}).get('needs_memory'):
            analysis['needs_memory'] = False
        return analysis

try:
    from meta_controller import shadow_decision as _shadow_decision, log_shadow_decision as _log_shadow_decision
    USE_META_CONTROLLER = True
except Exception:
    USE_META_CONTROLLER = False
    def _shadow_decision(message, analysis, family_candidates, tool_registry):
        return {}
    def _log_shadow_decision(log_path, decision_row):
        return None

try:
    from outcome_logging import (
        log_intent_family_shadow as _log_intent_family_shadow,
        log_intent_composition as _log_intent_composition,
        record_task_outcome as _record_task_outcome,
    )
except Exception:
    def _log_intent_family_shadow(message, family_info, before_tools, after_tools, *, log_path, collect_intent_families, service_hints):
        family = str((family_info or {}).get('family') or '')
        if not family:
            return
        try:
            log_path.parent.mkdir(parents=True, exist_ok=True)
            try:
                candidates = [item.get('family') for item in collect_intent_families(message, service_hints) if item.get('family')]
            except Exception:
                candidates = [family]
            row = {
                'ts': datetime.now(timezone.utc).isoformat(),
                'message': message,
                'family': family,
                'family_candidates': candidates,
                'before_tool': before_tools[0] if before_tools else '',
                'after_tool': after_tools[0] if after_tools else '',
                'overridden': (before_tools[:1] != after_tools[:1]),
            }
            with log_path.open('a', encoding='utf-8') as f:
                f.write(json.dumps(row, ensure_ascii=False) + '\n')
        except Exception:
            pass
    def _log_intent_composition(message, family_candidates, analysis_before, analysis_after, composition, *, log_path):
        if not composition or not composition.get('composed'):
            return
        try:
            log_path.parent.mkdir(parents=True, exist_ok=True)
            row = {
                'ts': datetime.now(timezone.utc).isoformat(),
                'message': message,
                'family_candidates': [item.get('family') for item in family_candidates if item.get('family')],
                'before_tools': list(analysis_before.get('tools') or []),
                'after_tools': list(analysis_after.get('tools') or []),
                'reason': composition.get('reason', ''),
                'policy': composition.get('policy', analysis_after.get('composition_policy', '')),
                'force_sequential': bool(analysis_after.get('force_sequential')),
            }
            with log_path.open('a', encoding='utf-8') as f:
                f.write(json.dumps(row, ensure_ascii=False) + '\n')
        except Exception:
            pass
    def _record_task_outcome(message, analysis, final_text, evidence_items, *, status='success', error_text='', log_path, classify_intent_family, collect_intent_families, service_hints, refresh_composition_policy_async):
        try:
            log_path.parent.mkdir(parents=True, exist_ok=True)
            grounded_items = [item for item in evidence_items if item.get('grounded')]
            try:
                candidates = [item.get('family') for item in collect_intent_families(message, service_hints) if item.get('family')]
            except Exception:
                candidates = []
            row = {
                'ts': datetime.now(timezone.utc).isoformat(),
                'status': status,
                'message': message,
                'role': analysis.get('role'),
                'task_type': analysis.get('task_type'),
                'planned_tools': list(analysis.get('tools') or []),
                'used_tools': [item.get('tool') for item in evidence_items],
                'family': (classify_intent_family(message, service_hints) or {}).get('family', ''),
                'family_candidates': candidates,
                'grounded_count': len(grounded_items),
                'evidence_count': len(evidence_items),
                'answer_len': len((final_text or '').strip()),
                'needs_memory': bool(analysis.get('needs_memory')),
                'needs_setup_context': bool(analysis.get('needs_setup_context')),
                'error_text': (error_text or '')[:300],
                'composition_reason': str(analysis.get('composition_reason') or ''),
                'composition_policy': str(analysis.get('composition_policy') or ''),
            }
            with log_path.open('a', encoding='utf-8') as f:
                f.write(json.dumps(row, ensure_ascii=False) + '\n')
            if row.get('composition_reason') or row.get('composition_policy'):
                refresh_composition_policy_async()
        except Exception:
            pass

try:
    from response_policy import (
        postprocess_final_answer as _policy_postprocess_final_answer,
        should_skip_heavy_persistence,
        can_fast_exit_single_tool,
        should_skip_quality_feedback,
        build_lightweight_composed_answer,
        sequential_tool_budget,
        summarize_sequential_context,
    )
except Exception:
    def _policy_postprocess_final_answer(_message, _analysis, final_text):
        return (final_text or '').strip()
    def should_skip_heavy_persistence(_message, _analysis, _evidence_items):
        return False
    def can_fast_exit_single_tool(_analysis, _evidence_items, memory_ctx='', retrieval_ctx=''):
        return False
    def should_skip_quality_feedback(_analysis, _evidence_items):
        return False
    def build_lightweight_composed_answer(_message, _analysis, _evidence_items):
        return ''
    def sequential_tool_budget(_name, is_sequential, default=12):
        return default if is_sequential else 0
    def summarize_sequential_context(_evidence_items, max_chars=900):
        return ''


import argparse
import json
import os
import re
import subprocess
import sys
import tempfile
from datetime import datetime, timezone
from pathlib import Path

ROOT = Path('/home/openclaw/.openclaw/workspace')
LLM_MAC = ROOT / 'bin' / 'llm-mac'
LLM_LOCAL = ROOT / 'bin' / 'llm-answer-local'
AGENT_MEMORY = Path(os.environ.get('BIBABOT_AGENT_MEMORY_BIN', str(ROOT / 'bin' / 'agent-memory')))
CONTEXT_PACK = ROOT / 'bin' / 'context-pack'
LOG_PATH = ROOT / 'logs' / 'orchestrator-events.jsonl'
INTENT_FAMILY_LOG = ROOT / 'logs' / 'intent-family-shadow.jsonl'
TASK_OUTCOME_LOG = ROOT / 'logs' / 'task-outcomes.jsonl'
INTENT_COMPOSITION_LOG = ROOT / 'logs' / 'intent-composition.jsonl'
META_CONTROLLER_LOG = ROOT / 'logs' / 'meta-controller-shadow.jsonl'
COMPOSITION_POLICY_REFRESH = ROOT / 'bin' / 'composition-policy-refresh'
TOPIC_STATE = ROOT / 'memory' / 'topic-state.json'
TOPIC_HISTORY = ROOT / 'memory' / 'topic-history.jsonl'
PROFILE_STORE = ROOT / 'memory' / 'profile.jsonl'


def trace_stage(*parts):
    if os.environ.get('BIBABOT_TRACE', '0') != '1':
        return
    try:
        print('[trace]', *parts, file=sys.stderr, flush=True)
    except Exception:
        pass

TOOLS = {
    'memory_profile': {'description': 'Persoenliches Gedaechtnis lesen oder speichern. Nutze das fuer Fragen ueber Vorlieben, Stil, Identitaet oder wenn der Nutzer explizit etwas merken will.', 'kind': 'final'},
    'briefing': {'description': 'Liefert ein aktuelles Lagebild zu Haus, Homelab, Erinnerungen und Agent-Gesundheit.', 'kind': 'final'},
    'setup_lookup': {'description': 'Liest das echte Homelab-Inventar: welche Dienste es gibt, wo sie laufen, wie man an Logs kommt und welche Hosts relevant sind.', 'kind': 'evidence'},
    'public_services_health': {'description': 'Prueft oeffentliche Services, Hosts und aktuelle Warnings/Fehler.', 'kind': 'final'},
    'log_hotspots': {'description': 'Analysiert die haeufigsten Fehler in immich/nextcloud/traefik Logs.', 'kind': 'final'},
    'host_slow_diagnose': {'description': 'Diagnose fuer langsame Hosts oder Services anhand CPU, RAM, Disk, Netzwerk und Logs.', 'kind': 'final'},
    'kasm_diagnose': {'description': 'Diagnose fuer Kasm-Zugriff, Kasm-Deployment und Erreichbarkeit.', 'kind': 'final'},
    'user_service_access_diagnose': {'description': 'Diagnostiziert warum eine bestimmte Person oder ein Benutzer nicht auf einen bestimmten Dienst zugreifen kann. Erst Dienstgesundheit, dann Auth-/Rechtepfad pruefen.', 'kind': 'final'},
    'web_root_cause': {'description': 'Diagnose warum eine gehostete Website nicht erreichbar ist.', 'kind': 'final'},
    'sonos_library_diagnose': {'description': 'Diagnose fuer Sonos lokale Musikbibliothek auf Unraid/NAS/SMB. Erst Sonos-Mechanismus verstehen, dann Share/Pfad/Zugriff auf Unraid pruefen.', 'kind': 'final'},
    'emby_user_provision': {'description': 'Erklaert und verifiziert, wie Emby-Benutzer in deinem Setup angelegt werden sollen, insbesondere ueber LDAP/Authentik statt lokale Emby-User.', 'kind': 'final'},
    'light_status': {'description': 'Zeigt welche Lichter aktuell eingeschaltet sind.', 'kind': 'final'},
    'light_usage': {'description': 'Analysiert Lichtnutzung und Automatisierungspotenzial.', 'kind': 'final'},
    'light_control': {'description': 'Schaltet Lichter ein oder aus. Das ist eine echte Aktion mit Seiteneffekt.', 'kind': 'action'},
    'web_research': {'description': 'Recherchiert im Web mit Quellen. Nutze das fuer Fakten, unbekannte Begriffe, Named Entities oder aktuelle Informationen.', 'kind': 'final'},
    'url_research': {'description': 'Analysiert eine konkrete URL oder Webseite.', 'kind': 'final'},
    'compare_selfhosted': {'description': 'Vergleicht Self-Hosted-Loesungen mit Blick auf die bestehende Infrastruktur.', 'kind': 'final'},
    'security_plan': {'description': 'Erstellt einen priorisierten Sicherheitsplan fuer Homelab/Reverse Proxy/SSH/Secrets/Backups.', 'kind': 'final'},
    'media_advice': {'description': 'Hilft bei Medien-Workflows wie Lidarr, Emby, Audiobooks, Audiobookshelf.', 'kind': 'final'},
    'personal_assist': {'description': 'Persoenliche Hilfe wie Mails, Nachrichten, Erinnerungen, Einkaufslisten, To-dos.', 'kind': 'final'},
    'dev_build': {'description': 'Programmier- und Build-Aufgaben: Tools, Skripte, Apps, Implementierung.', 'kind': 'final'},
    'general_answer': {'description': 'Allgemeine hilfreiche Antwort fuer Erklaerungen, How-tos, Rezepte, Listen und alltaegliche Fragen.', 'kind': 'final'},
    'agent_introspect': {'description': 'Selbstbeobachtung: Pruefe eigene Konfidenz und markiere Unsicherheiten vor der Ausgabe', 'kind': 'evidence'},
    'agent_self_correct': {'description': 'Lerne aus Fehlern und vermeide bekannte Fehlermuster', 'kind': 'evidence'},
    'agent_reason': {'description': 'Komplexes Multi-Step Reasoning mit Checkpoints und Backtracking', 'kind': 'evidence'},
    'agent_anticipate': {'description': 'Vorhersage von User-Intentions fuer proaktive Unterstuetzung', 'kind': 'evidence'},
    'agent_emotion': {'description': 'Emotionale Intelligenz fuer adaptive Kommunikation', 'kind': 'evidence'},
    'agent_simulate': {'description': 'Mentale Simulation fuer Konsequenzen-Abschaetzung vor Aktionen', 'kind': 'evidence'},
    'agent_synthesize': {'description': 'Cross-Domain Synthese fuer kreative Problemloesung', 'kind': 'evidence'},
    'ops_exec':         {'description': 'Fuehrt Befehle auf Homelab-Hosts aus und analysiert Ausgabe', 'kind': 'action',  'script': 'ops-exec-action'},
    'ops_install':      {'description': 'Installiert und konfiguriert Software, testet und verifiziert', 'kind': 'action',  'script': 'ops-install-action'},
    'ops_api':          {'description': 'Fragt Homelab REST-APIs ab: HA, Docker, Emby, Nextcloud, Authentik', 'kind': 'final',   'script': 'ops-api-query'},
    'ops_deep_analyze': {'description': 'Tiefe Analyse: Logs + Befehle + Web-Recherche + Synthese', 'kind': 'final',   'script': 'ops-deep-analyze'},
    'qdrant_search':   {'description': 'Semantische Suche in der lokalen Wissensdatenbank (KB-Dateien, Homelab-Doku, Setup-Infos).', 'kind': 'evidence'},
    'expert_write':    {'description': 'Experte fuer kreatives Schreiben, Journalismus, Artikel, Emails, Storytelling, technische Doku.', 'kind': 'final'},
    'expert_code':     {'description': 'Senior Software Architect: Code-Architektur, Review, Debugging, Performance, Security.', 'kind': 'final'},
    'expert_research': {'description': 'Tiefer Research-Analyst: Multi-Quellen-Synthese, Fact-Checking, investigative Analyse.', 'kind': 'final'},
    'expert_edit':     {'description': 'Professionelles Lektorat: Grammatik, Stil, Struktur, Klarheit — Text sofort verwendbar.', 'kind': 'final'},
    'expert_strategy': {'description': 'Strategy Consultant: Business-Planung, OKRs, Roadmaps, Priorisierung, Management-Frameworks.', 'kind': 'final'},
    'goals_manage':    {'description': 'Verwaltet Ziele, Projekte und Wochen-Prioritaeten. Hinzufuegen, anzeigen, aktualisieren.', 'kind': 'final'},
    'contacts_manage': {'description': 'Verwaltet Kontakte, Follow-ups und Geburtstage. Hinzufuegen, anzeigen, suchen.', 'kind': 'final'},
}

def env_models(name: str, default: list[str]) -> list[str]:
    raw = os.environ.get(name, '').strip()
    if not raw:
        return list(default)
    return [item.strip() for item in raw.split(',') if item.strip()] or list(default)


ANALYSIS_MODELS = env_models('BIBABOT_ANALYSIS_MODELS', ['qwen2.5:3b', 'qwen2.5:1.5b', 'llama3.1:8b'])
VERIFY_MODELS = env_models('BIBABOT_VERIFY_MODELS', ['qwen2.5:3b', 'gemma3:27b-it-qat', 'gemma3:12b'])
FOLLOWUP_MODELS = env_models('BIBABOT_FOLLOWUP_MODELS', ['gemma3:12b', 'qwen2.5:3b', 'llama3.1:8b'])
GENERAL_CHAIN_DEFAULT = 'qwen2.5:3b,qwen2.5:1.5b,llama3.1:8b,mistral-small3.1:latest'
FINAL_ROLE_MAP = {'ops': 'ops', 'research': 'research', 'personal': 'personal', 'dev': 'dev', 'general': 'general'}
ROLE_HINTS = {'ops', 'research', 'personal', 'dev', 'general'}
SERVICE_HINTS = {'kasm', 'emby', 'sonos', 'unraid', 'traefik', 'nextcloud', 'immich', 'lidarr', 'radarr', 'sonarr', 'authentik', 'ldap', 'home assistant', 'homeassistant', 'tailscale', 'emby', 'wiki', 'share', 'smb'}
SERVICE_HINTS_PATTERN = re.compile(r'\b(' + '|'.join(re.escape(h) for h in SERVICE_HINTS if ' ' not in h) + r')\b')
FOLLOWUP_STOP = {'welche', 'welcher', 'welches', 'wie', 'was', 'warum', 'wieso', 'und', 'dafuer', 'dafür', 'dazu', 'damit', 'relevant', 'genau', 'nochmal', 'bitte'}
GROUNDED_FASTPATH_TOOLS = {'briefing', 'setup_lookup', 'public_services_health', 'log_hotspots', 'host_slow_diagnose', 'kasm_diagnose', 'user_service_access_diagnose', 'web_root_cause', 'sonos_library_diagnose', 'emby_user_provision', 'light_status', 'light_usage', 'compare_selfhosted', 'security_plan', 'url_research', 'personal_assist', 'goals_manage', 'contacts_manage'}
INCIDENT_MEMORY_TOOLS = {'public_services_health', 'log_hotspots', 'host_slow_diagnose', 'kasm_diagnose', 'user_service_access_diagnose', 'web_root_cause', 'sonos_library_diagnose', 'emby_user_provision'}
EVIDENCE_KIND_BY_TOOL = {
    'memory_profile': 'memory',
    'briefing': 'status',
    'setup_lookup': 'setup',
    'public_services_health': 'diagnostic',
    'log_hotspots': 'diagnostic',
    'host_slow_diagnose': 'diagnostic',
    'kasm_diagnose': 'diagnostic',
    'user_service_access_diagnose': 'diagnostic',
    'web_root_cause': 'diagnostic',
    'sonos_library_diagnose': 'diagnostic',
    'emby_user_provision': 'diagnostic',
    'light_status': 'status',
    'light_usage': 'diagnostic',
    'light_control': 'action',
    'web_research': 'web',
    'url_research': 'web',
    'compare_selfhosted': 'web',
    'security_plan': 'web',
    'media_advice': 'diagnostic',
    'personal_assist': 'general',
    'dev_build': 'general',
    'general_answer': 'general',
    'agent_introspect': 'introspection',
    'agent_self_correct': 'learning',
    'agent_reason': 'reasoning',
    'agent_anticipate': 'prediction',
    'agent_emotion': 'emotion',
    'agent_simulate': 'simulation',
    'agent_synthesize': 'synthesis',
    'expert_write': 'general',
    'expert_code': 'general',
    'expert_research': 'web',
    'expert_edit': 'general',
    'expert_strategy': 'general',
}


def norm(text: str) -> str:
    text = (text or '').lower()
    text = text.replace('ä', 'ae').replace('ö', 'oe').replace('ü', 'ue').replace('ß', 'ss')
    return re.sub(r'\s+', ' ', text).strip()


def normalize_inbound_message(text: str) -> str:
    clean = (text or '').replace('\r', '').strip()
    clean = re.sub(r'^\[[^\]\n]{8,80}\]\s*', '', clean)
    clean = re.sub(r'^\s*Current time:\s.*$', '', clean, flags=re.I | re.M)
    return clean.strip()


def is_complex_task(message: str, analysis: dict) -> bool:
    """True when a task needs sequential steps where each step uses the previous result."""
    low = norm(message)
    if analysis.get('role') not in {'ops', 'dev'}:
        return False
    if analysis.get('task_type') not in {'action', 'diagnose', 'build'}:
        return False
    # Explicit multi-step language: diagnose → then fix
    if re.search(r'(analysier|prüf|check|diagnose).{1,40}(und|dann|anschliessend).{1,40}(fix|reparier|beheb|restart|install|konfigur|deploy)', low):
        return True
    # Fix → then verify
    if re.search(r'(fix|install|deploy|reparier).{1,40}(und|dann).{1,40}(test|verif|prüf|zeig|sicher)', low):
        return True
    # Explicit deep/thorough analysis
    if re.search(r'(schritt.fuer.schritt|vollstaendig.*analysier|tiefgreifend|root.cause|ursache.*finden|warum.*kaputt|warum.*fehler|alles.*beheben|komplett.*analysier)', low):
        return True
    # Multiple action verbs = implied multi-step
    verbs = sum(1 for v in ['analysier', 'diagnose', 'fixe', 'reparier', 'installier', 'restart', 'konfigur', 'deploy', 'verif', 'beheb'] if v in low)
    return verbs >= 2


def run(cmd, timeout=120, env=None):
    try:
        if isinstance(cmd, (list, tuple)):
            cmd = [c.replace('\x00', '') if isinstance(c, str) else c for c in cmd]
        budget = (os.environ.get('BIBABOT_TOOL_TIMEOUT') or '').strip()
        if budget:
            try:
                timeout = min(int(timeout), max(1, int(budget)))
            except Exception:
                pass
        run_env = None
        if env is not None:
            run_env = os.environ.copy()
            run_env.update(env)
        proc = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout, env=run_env)
        return proc.returncode, (proc.stdout or '').strip(), (proc.stderr or '').strip()
    except subprocess.TimeoutExpired:
        return 124, '', 'timeout'


def call_llm(model: str, system: str, user: str, timeout: int = 180):
    return run([str(LLM_MAC), 'chat', model, system, user], timeout=timeout)


def call_llm_schema(model: str, schema: dict, system: str, user: str, timeout: int = 180):
    with tempfile.NamedTemporaryFile('w', suffix='.schema.json', delete=False, encoding='utf-8') as tmp:
        json.dump(schema, tmp, ensure_ascii=False)
        schema_path = tmp.name
    try:
        return run([str(LLM_MAC), 'chat-schema', model, schema_path, system, user], timeout=timeout)
    finally:
        try:
            os.unlink(schema_path)
        except OSError:
            pass


def model_exists(model: str) -> bool:
    rc, _out, _err = run([str(LLM_MAC), 'has', model], timeout=20)
    return rc == 0


ANALYSIS_SCHEMA = {
    "type": "object",
    "properties": {
        "role": {"type": "string", "enum": ["ops", "research", "personal", "dev", "general"]},
        "task_type": {"type": "string", "enum": ["diagnose", "explain", "compare", "howto", "write", "action", "status", "build", "memory"]},
        "needs_setup_context": {"type": "boolean"},
        "needs_web_research": {"type": "boolean"},
        "needs_memory": {"type": "boolean"},
        "dangerous_action": {"type": "boolean"},
        "tools": {"type": "array", "items": {"type": "string"}},
        "reasoning_focus": {"type": "array", "items": {"type": "string"}},
        "confidence": {"type": "number"}
    },
    "required": ["role", "task_type", "needs_setup_context", "needs_web_research", "needs_memory", "dangerous_action", "tools", "reasoning_focus", "confidence"],
    "additionalProperties": False
}

FOLLOWUP_SCHEMA = {
    "type": "object",
    "properties": {
        "is_followup": {"type": "boolean"},
        "root_message": {"type": "string"},
        "reply_mode": {"type": "string", "enum": ["direct", "compare", "steps", "single_choice", "diagnose"]},
        "focus": {"type": "string"}
    },
    "required": ["is_followup", "root_message", "reply_mode", "focus"],
    "additionalProperties": False
}

VERIFY_SCHEMA = {
    "type": "object",
    "properties": {
        "verdict": {"type": "string", "enum": ["keep", "revise", "retry"]},
        "grounded": {"type": "boolean"},
        "addresses_request": {"type": "boolean"},
        "wrong_entity_jump": {"type": "boolean"},
        "retry_tool": {"type": "string"},
        "missing_points": {"type": "array", "items": {"type": "string"}},
        "rationale": {"type": "string"},
        "revised_answer": {"type": "string"},
    },
    "required": ["verdict", "grounded", "addresses_request", "wrong_entity_jump", "retry_tool", "missing_points", "rationale", "revised_answer"],
    "additionalProperties": False
}


def extract_json(text: str):
    if not text:
        return None
    start = text.find('{')
    while start != -1:
        depth = 0
        in_str = False
        esc = False
        for idx in range(start, len(text)):
            ch = text[idx]
            if in_str:
                if esc:
                    esc = False
                elif ch == '\\':
                    esc = True
                elif ch == '"':
                    in_str = False
                continue
            if ch == '"':
                in_str = True
            elif ch == '{':
                depth += 1
            elif ch == '}':
                depth -= 1
                if depth == 0:
                    snippet = text[start:idx + 1]
                    try:
                        return json.loads(snippet)
                    except Exception:
                        break
        start = text.find('{', start + 1)
    return None


def tool_catalog_text() -> str:
    return '\n'.join(f'- {name}: {meta["description"]}' for name, meta in TOOLS.items())


def topic_terms(text: str):
    terms = []
    for tok in re.findall(r'[a-z0-9._-]{3,}', norm(text)):
        if tok in FOLLOWUP_STOP:
            continue
        terms.append(tok)
    return list(dict.fromkeys(terms))[:12]


def load_topic_state():
    if not TOPIC_STATE.exists():
        return None
    try:
        data = json.loads(TOPIC_STATE.read_text(encoding='utf-8'))
    except Exception:
        return None
    return data if isinstance(data, dict) else None


def load_topic_history(limit: int = 12):
    if not TOPIC_HISTORY.exists():
        return []
    items = []
    try:
        lines = TOPIC_HISTORY.read_text(encoding='utf-8', errors='ignore').splitlines()
    except Exception:
        return []
    for line in lines[-limit:]:
        line = line.strip()
        if not line:
            continue
        try:
            data = json.loads(line)
        except Exception:
            continue
        if isinstance(data, dict):
            items.append(data)
    return items


def append_topic_history(payload: dict):
    try:
        TOPIC_HISTORY.parent.mkdir(parents=True, exist_ok=True)
        with TOPIC_HISTORY.open('a', encoding='utf-8') as f:
            f.write(json.dumps(payload, ensure_ascii=False) + '\n')
    except Exception:
        pass


def topic_state_match_score(message: str, state: dict | None):
    if not state:
        return 0.0
    score = 0.0
    qterms = topic_terms(message)
    combined = ' '.join([str(state.get('message') or ''), ' '.join(state.get('keywords') or []), str(state.get('summary') or '')])
    hay = norm(combined)
    for term in qterms:
        if term in hay:
            score += 2.0
    if is_followup_query(message):
        score += 1.4
    if state.get('analysis', {}).get('role') in {'ops', 'dev'} and any(s in hay for s in SERVICE_HINTS):
        score += 0.4
    return score


def recent_topic_event(message: str):
    candidates = []
    state = load_topic_state()
    if state:
        candidates.append(state)
    candidates.extend(load_topic_history())
    best = None
    best_score = 0.0
    seen = set()
    for item in reversed(candidates):
        key = (str(item.get('ts') or ''), str(item.get('message') or ''), str(item.get('summary') or ''))
        if key in seen:
            continue
        seen.add(key)
        score = topic_state_match_score(message, item)
        if score > best_score:
            best = item
            best_score = score
    if best_score >= 1.4:
        return best
    return None


def resolve_followup(message: str, state: dict | None):
    if not state or not is_followup_query(message):
        return None
    system = (
        'Du loest Anschlussfragen fuer J.A.R.V.I.S. auf. Nutze nur den gegebenen Themenkontext. ' 
        'Gib strikt JSON gemaess Schema aus.'
    )
    summary = str(state.get('summary') or '').strip()
    root = str(state.get('root_message') or state.get('message') or '').strip()
    user = (
        f'Aktuelles Thema:\n{root}\n\n'
        f'Bisheriger Kerninhalt:\n{summary}\n\n'
        f'Neue Nutzerfrage:\n{message}\n\n'
        'Bestimme, ob die neue Frage eine Anschlussfrage zum Thema ist, welches Ursprungsproblem gemeint ist und wie knapp geantwortet werden soll.'
    )
    for model in FOLLOWUP_MODELS:
        if not model_exists(model):
            continue
        rc, out, _err = call_llm_schema(model, FOLLOWUP_SCHEMA, system, user, timeout=45)
        if rc != 0 or not out:
            continue
        try:
            data = json.loads(out)
        except Exception:
            continue
        if isinstance(data, dict):
            return data
    return None


def update_topic_state(message: str, analysis: dict, final_text: str):
    if not isinstance(analysis, dict):
        return
    tools = [t for t in analysis.get('tools', []) if t in TOOLS and TOOLS[t]['kind'] != 'action']
    if not tools:
        return
    previous = load_topic_state() or {}
    summary_lines = []
    summary_cap = 4
    if analysis.get('role') == 'general' and analysis.get('task_type') in {'howto', 'compare', 'explain'}:
        summary_cap = 14
    elif analysis.get('task_type') in {'compare', 'build'}:
        summary_cap = 10
    for line in (final_text or '').splitlines():
        line = line.strip()
        if not line:
            continue
        summary_lines.append(line)
        if len(summary_lines) >= summary_cap:
            break
    root_message = message
    prev_match = topic_state_match_score(message, previous) if previous else 0.0
    if prev_match >= 1.4 and previous.get('root_message'):
        root_message = str(previous.get('root_message')).strip() or message
    payload = {
        'ts': datetime.now(timezone.utc).isoformat(),
        'root_message': root_message,
        'message': message,
        'keywords': topic_terms((root_message or message) + ' ' + message + ' ' + ' '.join(tools)),
        'summary': '\n'.join(summary_lines),
        'analysis': {
            'role': analysis.get('role'),
            'task_type': analysis.get('task_type'),
            'needs_setup_context': bool(analysis.get('needs_setup_context')),
            'needs_web_research': bool(analysis.get('needs_web_research')),
            'needs_memory': bool(analysis.get('needs_memory')),
            'tools': tools[:3],
        },
    }
    try:
        TOPIC_STATE.parent.mkdir(parents=True, exist_ok=True)
        TOPIC_STATE.write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')
        append_topic_history(payload)
    except Exception:
        pass


def current_topic_context(message: str):
    state = recent_topic_event(message)
    if not state:
        return ''
    tools = ', '.join(state.get('analysis', {}).get('tools', [])[:3])
    summary = str(state.get('summary') or '').strip()
    out = [f"Aktives Thema: {str(state.get('root_message') or state.get('message') or '').strip()} | tools={tools}"]
    if summary:
        out.append(summary)
    return '\n'.join(out)


def is_followup_query(message: str) -> bool:
    low = norm(message)
    if re.search(r'https?://', message):
        return False
    if any(h in low for h in SERVICE_HINTS):
        return False
    pronouns = ['dafuer', 'dafuer', 'dazu', 'damit', 'darauf', 'darin', 'darueber', 'davon']
    if any(p in low for p in pronouns):
        return True
    # 'diese/dieses/dieser' as standalone pronouns → followup, but NOT as articles before nouns/temporal words
    TEMPORAL_NOUNS = r'(monat|jahr|tag|abend|morgen|sommer|winter|herbst|fruehjahr|fruhling|woche|quartal|semester|moment|mal|abschnitt)'
    if re.search(r'\b(dies|dieses|diese[rn]?)\b', low) and not re.search(r'\bdiesen?\s+' + TEMPORAL_NOUNS, low) and not re.search(r'\bdieses\s+' + TEMPORAL_NOUNS, low) and not re.search(r'\bdieser?\s+' + TEMPORAL_NOUNS, low):
        return True
    if low.startswith('und '):
        return True
    if re.search(r'^welche[rns]? davon\b', low):
        return True
    return False


def recent_dialogue_event(message: str):
    if not LOG_PATH.exists():
        return None
    try:
        lines = LOG_PATH.read_text(encoding='utf-8', errors='ignore').splitlines()[-12:]
    except Exception:
        return None
    query_terms = topic_terms(message)
    ranked = []
    for idx, line in enumerate(reversed(lines), start=1):
        line = line.strip()
        if not line:
            continue
        try:
            data = json.loads(line)
        except Exception:
            continue
        if not isinstance(data, dict) or not data.get('analysis', {}).get('tools'):
            continue
        if norm(str(data.get('message') or '')) == norm(message):
            continue
        tools = [t for t in data.get('analysis', {}).get('tools', []) if t in TOOLS and TOOLS[t]['kind'] != 'action']
        if not tools:
            continue
        data['analysis']['tools'] = tools
        hay = norm(str(data.get('message') or '') + ' ' + ' '.join(TOOLS[t]['description'] for t in tools))
        score = 0.0
        for term in query_terms:
            if term in hay:
                score += 1.8
        score += max(0.0, 0.35 - idx * 0.03)
        ranked.append((score, data))
    if not ranked:
        return None
    ranked.sort(key=lambda x: x[0], reverse=True)
    if ranked[0][0] <= 0:
        return None
    return ranked[0][1]


def recent_dialogue_context():
    if not LOG_PATH.exists():
        return ''
    try:
        lines = LOG_PATH.read_text(encoding='utf-8', errors='ignore').splitlines()[-4:]
    except Exception:
        return ''
    parts = []
    for line in lines:
        try:
            data = json.loads(line)
        except Exception:
            continue
        msg = str(data.get('message') or '').strip()
        tools = ', '.join(data.get('analysis', {}).get('tools', [])[:3])
        if msg:
            parts.append(f'- Letzte Anfrage: {msg} | tools={tools}')
    return '\n'.join(parts[:3])


def analyze_with_llm(message: str, role_hint: str | None, memory_ctx: str = '', retrieval_ctx: str = ''):
    system = (
        'Du bist der Planungs-Kern von J.A.R.V.I.S. Verstehe zuerst den Mechanismus der Anfrage und waehle dann passende Tools. '
        'Verlasse dich nicht auf Keyword-Aehnlichkeit. Waehle nur Tools, die wirklich zum Problem passen. '
        'Beispiele: Sonos + Unraid Bibliothek -> sonos_library_diagnose. "Was ist Sitterdorf?" -> web_research. '
        'Bei mehrstufigen Aufgaben: waehle 2 Tools in der richtigen Reihenfolge (erst Info, dann Analyse/Aktion). '
        'Analyse+Fix: [ops_api, ops_deep_analyze]. Installation+Test: [ops_install, ops_exec]. '
        'Einfache Statusfragen brauchen nur 1 Tool. '
        'Gib nur JSON aus.'
    )
    hint_text = f'Bevorzugte Rolle: {role_hint}. Nutze sie als weichen Hinweis, aber nicht wenn sie fachlich offensichtlich falsch waere.\n' if role_hint else ''
    context_parts = []
    if memory_ctx:
        context_parts.append('Relevantes Nutzer-/Korrektur-Gedaechtnis:\n' + memory_ctx)
    if retrieval_ctx:
        context_parts.append('Relevantes lokales Setup-/Wissens-Retrieval:\n' + retrieval_ctx)
    topic_ctx = current_topic_context(message)
    if topic_ctx:
        context_parts.append('Aktiver Themenkontext:\n' + topic_ctx)
    context_block = ('\n\n'.join(context_parts) + '\n\n') if context_parts else ''
    user = (
        f'Anfrage:\n{message}\n\n'
        f'{hint_text}'
        f'{context_block}'
        'Verfuegbare Tools:\n'
        f'{tool_catalog_text()}\n\n'
        'JSON-Schema:\n'
        '{"role":"ops|research|personal|dev|general",'
        '"task_type":"diagnose|explain|compare|howto|write|action|status|build|memory",'
        '"needs_setup_context":true,'
        '"needs_web_research":false,'
        '"needs_memory":false,'
        '"dangerous_action":false,'
        '"tools":["tool_name"],'
        '"reasoning_focus":["kurzer Punkt"],'
        '"confidence":0.0}\n\n'
        'Regeln:\n'
        '- Waehle maximal 3 Tools.\n'
        '- Wenn die Anfrage zuerst Sachverstaendnis braucht, waehle das passende Sach-/Diagnosetool vor lokalen Checks.\n'
        '- Fuer alltaegliche Erklaerungen/Rezepte/How-tos ohne aktuelle Fakten reicht general_answer.\n'
        '- Fuer Named-Entity-, Orts- oder Faktenfragen mit Halluzinationsrisiko nimm web_research.\n'
        '- Fuer Vergleiche von lokal/self-hosted/selbst gehosteten Loesungen nimm compare_selfhosted.\n'
        '- Fuer Coding-/Build-Aufgaben nimm dev_build.\n'
        '- Fuer Mail/Nachricht/Reminder nimm personal_assist.\n'
        '- Fuer Fragen ueber Benutzerprofil/Vorlieben oder "merke dir" nimm memory_profile.\n'
        '- Fuer Lichter nur bei echter Anweisung light_control, sonst light_status oder light_usage.\n'
        '- Nimm setup_lookup nur wenn echtes Homelab-/Host-/Service-Wissen gebraucht wird.\n'
        '- Wenn Anfrage sowohl Diagnose als auch Fix will: [ops_api, ops_deep_analyze].\n'
        '- Wenn Anfrage Installation + Verifikation will: [ops_install, ops_exec].\n'
        '- Bei "was soll ich tun", "wie kann ich", "fix das" nach einer Fehlerdiagnose: ops_deep_analyze benutzen.\n'
    )
    for model in ANALYSIS_MODELS:
        if not model_exists(model):
            continue
        rc, out, _err = call_llm_schema(model, ANALYSIS_SCHEMA, system, user, timeout=90)
        if rc == 0 and out:
            try:
                parsed = json.loads(out)
            except Exception:
                parsed = extract_json(out)
            if isinstance(parsed, dict):
                return parsed
    return None


def heuristic_analysis(message: str, role_hint: str | None = None):
    low = norm(message)

    # === EXPERT-EDIT: Highest priority — lectorat/proofread patterns before anything else ===
    # These are unambiguous writing-help patterns that must not be caught by service/ops rules
    if re.search(r'(korrigier.{0,20}(text|folgenden|meinen|diesen|den)|'
                 r'lektorier|lektorat|proofreading|proofread|'
                 r'verbessere.{0,20}(text|meinen text|folgenden text|diesen text|schreibstil)|'
                 r'ueberarbeite.{0,20}(text|meinen|diesen|folgenden)|'
                 r'überarbeite.{0,20}(text|meinen|diesen|folgenden)|'
                 r'rechtschreibung.*pruefen|grammatik.*pruefen|pruef.*grammatik|pruef.*rechtschreibung|'
                 r'stilistisch.*verbessern|stilverbesserung|besser.*formulier|umformulier|'
                 r'klingt.*besser|klingt.*natuerlicher|klingt.*professioneller|'
                 r'feedback.*text|feedback.*meinem text|text.*feedback)', low) and not any(s in low for s in ('docker', 'code', 'skript')):
        analysis = {
            'role': 'general', 'task_type': 'write', 'needs_setup_context': False,
            'needs_web_research': False, 'needs_memory': False, 'dangerous_action': False,
            'tools': ['expert_edit'], 'reasoning_focus': [], 'confidence': 0.95,
        }
        return analysis

    # === FIX: CREATIVE-WRITE EARLY INTERCEPT (höchste Priorität) ===
    # Creative writing -> personal_assist (tweet, gedicht, witz, bio, instagram post, etc.)
    # MUSS VOR goals_manage und expert_write kommen!
    if re.search(r'(\btweet\b|erstelle.*tweet|tweet.*erstelle|schreib.*tweet|twitter.*post)', low):
        return {'role': 'personal', 'task_type': 'write', 'tools': ['personal_assist'], 'needs_memory': True, 'needs_setup_context': False, 'needs_web_research': False, 'dangerous_action': False, 'confidence': 0.94}
    if re.search(r'(\bgedicht\b|schreib.*gedicht|erstelle.*gedicht)', low):
        return {'role': 'personal', 'task_type': 'write', 'tools': ['personal_assist'], 'needs_memory': True, 'needs_setup_context': False, 'needs_web_research': False, 'dangerous_action': False, 'confidence': 0.94}
    if re.search(r'(\bwitz\b|schreib.*witz|erstelle.*witz|witz.*schreib)', low):
        return {'role': 'personal', 'task_type': 'write', 'tools': ['personal_assist'], 'needs_memory': True, 'needs_setup_context': False, 'needs_web_research': False, 'dangerous_action': False, 'confidence': 0.94}
    if re.search(r'(instagram.*post|facebook.*post|kurze.*bio|\bbio\b.*github)', low):
        return {'role': 'personal', 'task_type': 'write', 'tools': ['personal_assist'], 'needs_memory': True, 'needs_setup_context': False, 'needs_web_research': False, 'dangerous_action': False, 'confidence': 0.94}

    # GOALS-MANAGE: Ziel/Projekt-Verwaltung (explizite Verwaltungsbefehle — nicht Strategie-Anfragen)
    # FIX: Ausschluss von "tweet" und creative writing bereits oben abgehandelt
    if re.search(r'(fuege.*ziel|ziel.*hinzufuegen|neues ziel|setze.*ziel|wochen.*prio|prioritaet.*setze|constraint.*hinzufueg|ziel.*abgehakt|ziel.*erledigt|zeig.*ziele|was sind.*ziele|aktuelle.*ziele|zeig.*projekte)', low) or (re.search(r'(projekt.*erstell|neues.*projekt|projekt.*hinzufuegen)', low) and re.search(r'(jarvis|agent|merke|speicher|trag.*ein)', low)):
        return {'role': 'personal', 'task_type': 'memory', 'tools': ['goals_manage'], 'needs_memory': False, 'needs_setup_context': False, 'needs_web_research': False, 'dangerous_action': False, 'confidence': 0.93}

    # CONTACTS-MANAGE: Kontakt-Verwaltung
    if re.search(r'(neuer kontakt|kontakt.*hinzufuegen|merke.*kontakt|wer hat.*geburtstag|geburtstage.*naechste|follow.?up.*faellig|follow.?up.*hinzufueg|letzter kontakt.*mit|zeig.*kontakte|habe.*kontaktiert|schuldige.*follow|offene.*follow)', low):
        return {'role': 'personal', 'task_type': 'memory', 'tools': ['contacts_manage'], 'needs_memory': False, 'needs_setup_context': False, 'needs_web_research': False, 'dangerous_action': False, 'confidence': 0.93}

    # === FIX: Pre-Check Fast-Path für Rezepte (höchste Priorität) ===
    # Diese Patterns müssen VOR allen anderen Checks kommen, um ungrounded general_answer zu vermeiden
    # Fix RECIPE-ROUTING-FINAL: Vereinfachte, robuste Patterns ohne \b am Ende
    # ── PRO-WRITE EARLY INTERCEPT ─────────────────────────────────────────────
    # Professionelle Kommunikation -> expert_write (vor personal_assist)
    # FIX: "bewerbung" nur wenn formell/professionell (anschreiben, motivationsschreiben, etc.)
    # "schreibe mir eine bewerbung" -> personal_assist (persönliche Hilfe, nicht formelle Dokumentation)
    _pro_write_types = r'(anschreiben|motivationsschreiben|cover.?letter|kundigungsschreiben|kuendigungsschreiben|offizielle.*anfrage|formeller.*brief|formelle.*email|gehaltsverhandlung.*email|gehalts.*email|email.*(chef|vorgesetzt|manager|leitung|boss).*(gehal|bonus|kuendigung|versetz|urlaub)|email.*wegen.*(gehal|kuendigung|bonus|versetz)|kundigung.*verfass|kündigung.*verfass|offizielle.*stellungnahme|pressemitteilung|pitch.*deck|investor.*email|business.*proposal|vertrags.*entwurf|meeting.*protokoll|protokoll.*erstell)'
    _pro_trigger = r'(kannst du|hilf mir|erstell|formulier|schreib|verfass|mach mir|ich brauche|bitte.*erstell|entwirf)'
    if re.search(_pro_write_types, low) and re.search(_pro_trigger, low):
        return {'role': 'research', 'task_type': 'write', 'tools': ['expert_write'], 'needs_memory': False, 'needs_setup_context': False, 'needs_web_research': False, 'dangerous_action': False, 'confidence': 0.91}
    
    # FIX BEWERBUNG: "schreibe mir eine bewerbung" -> personal_assist (persönliche Hilfe)
    # "bewerbung als X" oder "anschreiben fuer X" -> expert_write (formell)
    if re.search(r'(schreib.*mir.*bewerbung|bewerbung.*schreib|hilf.*bewerbung|bewerbung.*hilf)', low) and not re.search(r'(anschreiben|motivationsschreiben|formell|professionell)', low):
        return {'role': 'personal', 'task_type': 'write', 'tools': ['personal_assist'], 'needs_memory': True, 'needs_setup_context': False, 'needs_web_research': False, 'dangerous_action': False, 'confidence': 0.92}

    # INTERNAL-TOOL-IDEAS: brainstorming for internal tools should stay general/dev, not recipe/personal
    if re.search(r'(nenne|gib|zeig).{0,20}(ideen|vorschlaege|vorschläge|optionen)', low) and re.search(r'(internes? tool|internes? werkzeug|zugriffspruefung|zugriffsprüfung|access tool)', low):
        return {'role': 'general', 'task_type': 'explain', 'tools': ['general_answer'], 'needs_memory': False, 'needs_setup_context': False, 'needs_web_research': False, 'dangerous_action': False, 'confidence': 0.94}

    # WICHTIG: Patterns enden mit \s oder .* damit sie auch mit Leerzeichen/Folgetext matchen
    RECIPE_FASTPATH = (
        # Basis: "Gib mir X Rezept/Ideen/Vorschlaege..."
        r'^(gib mir|gib|zeig mir|zeig|bringe mir|bringe|schick mir|schick)\s+(ein|eine|einen|\d+)\s+(rezept|ideen|vorschlaege|vorschläge)',
        r'^(gib mir|gib|zeig mir|zeig)\s+(rezept|ideen|vorschlaege|vorschläge)',
        # "Rezept fuer...", "Ideen fuer..."
        r'(rezept|rezepte|ideen|vorschlaege|vorschläge)\s+(fuer|für)',
        # "schnelles Abendessen", "was kochen"
        r'(schnelles|einfaches|gutes)\s+(abendessen|mittagessen|fruehstueck|frühstück|essen|gericht)',
        r'(abendessen|mittagessen|fruehstueck|frühstück)\s+(ideen|vorschlaege|vorschläge|rezepte)',
        r'(was|was soll ich)\s+(kochen|essen|zum essen|zum abendessen|zum mittagessen)',
        # Spezifische Gerichte
        r'(omelett|omelette|omeletten|pfannkuchen|spaghetti|pasta|risotto|curry|suppe|salat|bowl|wraps)',
    )
    if any(re.search(p, low) for p in RECIPE_FASTPATH) and not any(h in low for h in ('homelab', 'server', 'docker', 'container', 'menu', 'code', 'script', 'programm')):
        return {'role': 'personal', 'task_type': 'howto', 'tools': ['personal_assist'], 'needs_memory': True, 'needs_setup_context': False, 'needs_web_research': False, 'dangerous_action': False, 'confidence': 0.95}
    
    # Pattern-Definitionen am Anfang der Funktion (Fix: RECIPE_PATTERNS muss vor Verwendung definiert sein)
    RECIPE_PATTERNS = (
        r'(gib mir.*rezept|rezept fuer|rezept f.r|wie mache ich|wie bereite ich)',
        r'(ideen.*abendessen|schnelles abendessen|was koche ich|was esse ich|abendessen.*ideen|abendessen.*vorschlag)',
        r'(omelett|omelette|omeletten|pasta|spaghetti|pfannkuchen|wraps|shakshuka|risotto|curry|suppe|salat|bowl)',
        r'(zutaten|kochen|koch|backen|essen fuer|was koche|was esse|schnell.*essen|einfach.*kochen)',
        r'(hunger|hungrig|mahlzeit|gericht|gerichte|speise|speisen)',
        # Fix RECIPE-ROUTING-11: "Gib mir X fuer Y" - allgemeines Pattern für Rezept-Anfragen
        r'^(gib mir|gib)\s+\w+\s+(fuer|für)\s+\w+',
        # Fix RECIPE-ROUTING-12: "Gib mir X Ideen fuer Y" - erlaube beliebigen Text nach "fuer"
        r'^(gib mir|gib)\s+\d+\s+ideen\s+(fuer|für)\b',
    )
    # (WRITE-CREATIVE Patterns jetzt oben unter CREATIVE-WRITE EARLY INTERCEPT)
    SCIENCE_KB_PATTERNS = (
        r'(himmel.*blau|blauer himmel|warum.*himmel)',
        r'(sonne.*rot|sonne.*orange|sonnenuntergang.*rot|sonnenuntergang.*orange|untergehende sonne)',
        r'(mondfinsternis.*rot|roter mond|blutmond|mond.*rot)',
        r'(rayleigh.*streuung|lichtstreuung|streuung.*licht)',
        r'(mond.*grösser|mond.*größer|mondtäuschung|mondtaeuschung)',
    )
    GENERAL_KB_PATTERNS = (
        r'(was ist docker|was ist ein docker|was.*erklaer.*docker|docker vs.*vergleich|unterschied.*docker)',
        r'(was ist ein reverse proxy|was ist reverse proxy|reverse proxy.*was)',
        r'(was ist tailscale|tailscale.*was|vpn.*tailscale)',
        r'(unraid.*truenass|truenass.*unraid|unraid vs|truenass vs)',
        r'(unterschied.*wetter.*klima|wetter.*klima.*unterschied|was ist.*wetter|was ist.*klima)',
        r'(photosynthese|photo.*synthese|pflanzen.*licht|licht.*pflanzen)',
        r'(lichtjahr|licht jahr|was ist.*lichtjahr)',
        r'(fleisch.*auftauen|auftauen.*fleisch|fleisch.*tiefkühl|fleisch.*gefrier)',
        r'(waschmittel.*pulver|waschmittel.*flüssig|waschmittel.*pods|pulver.*flüssig)',
        r'(kühlschrank.*temperatur|kühlschrank.*grad|gefrierfach.*temperatur)',
        r'(schnittwunde.*erste hilfe|erste hilfe.*schnitt|schnitt.*wunde.*was tun)',
        r'(wasser.*pro tag|wieviel wasser|wie viel wasser.*trinken)',
        r'(schlaf.*dauer|schlaf.*stunden|wie lange.*schlafen|schlafdauer)',
        r'(3-säulen.*system|drei säulen|ahv.*pensionskasse|säule 3a|säule 3b)',
        r'(was ist ein etf|etf.*was|etf.*fonds|exchange traded)',
        r'(du.*sie.*deutsch|sie.*du.*deutsch|wann du.*wann sie)',
        # Neue Patterns für erweiterte KB_GENERAL (Fix K1-K12)
        r'(berechne.*prozent|trinkgeld|prozent.*berechnen|prozentrechnung)',
        r'(tage bis|wie viele tage|tage.*weihnachten|tage.*geburtstag)',
        r'(stunden.*jahr|zeitrechnung|minuten.*jahr|stunden pro)',
        r'(vitamin d|vitamin-d|mangel.*vitamin)',
        r'(kopfschmerzen|kopf.*tut weh|migräne|migrane|schmerzen.*kopf)',
        r'(gestresst|stress.*was tun|entspannung|entspannen)',
        r'(schweiz.*gegründet|bundesstaat.*schweiz|gründung.*schweiz|schweiz.*geschichte)',
        r'(http.*status|status code|503|502|404|500.*error|http.*fehler)',
        r'(passwort.*ändern|passwoerter.*aendern|warum.*passwort)',
        r'(python.*error|typeerror|python.*fehler|was bedeutet.*error)',
        r'(übersetze|uebersetze|auf englisch|auf italienisch|auf deutsch|wie sagt man)',
        r'(buch.*empfehl|buch.*schlafen|gutes buch|lesen.*schlafen)',
        # Neue Patterns für erweiterte KB_GENERAL (Fix K13-K24)
        r'(was ist.*ip.*adresse|ip.*adresse.*was|ip-adresse|meine ip)',
        r'(was ist.*dns|dns.*was|domain name system)',
        r'(was ist.*vpn|vpn.*was|virtual private)',
        r'(router.*switch|unterschied.*router|access point.*unterschied)',
        r'(makronaehrstoff|makro.*nährstoff|kohlenhydrate.*protein|protein.*fett)',
        r'(glykaemisch|glykämisch|gi.*wert|glykaemischer index)',
        r'(keto.*diaet|keto.*diät|ketose|ketogene)',
        r'(was ist.*inflation|inflation.*was|verbraucherpreisindex)',
        r'(zinseszins|zins.*zins|zinsrechnung)',
        r'(aktien.*etf|etf.*aktien|einzelaktie.*etf)',
        r'(waschmaschine.*funktioniert|wie funktioniert.*waschmaschine)',
        r'(kuehlschrank.*funktioniert|kühlschrank.*funktioniert|wie funktioniert.*kühlschrank)',
        r'(backpulver.*natron|natron.*hefe|backpulver.*hefe|unterschied.*backpulver)',
        r'(jahreszeiten.*warum|warum.*jahreszeiten|warum gibt es.*jahreszeiten)',
        r'(biologisch.*oekologisch|biologisch.*ökologisch|unterschied.*bio)',
        r'(was ist.*oekosystem|oekosystem.*was|was ist.*ökossystem|ökossystem.*was)',
        # Neue Patterns für erweiterte KB_GENERAL (Fix K25-K48) - Sport, Technik, Kochen, Psychologie
        r'\b(hiit|high intensity interval|interval training)\b',
        r'\bkrafttraining\b|\bkraft.*training\b|\bmuskeltraining\b',
        r'(ausdauer.*kraft|kraft.*ausdauer|unterschied.*ausdauer)',
        r'(oled.*led|led.*oled|qled.*oled|oled.*qled|unterschied.*fernseher)',
        r'(energie.*klasse|energieeffizienz|stromverbrauch.*gerät|was bedeuten.*klassen)',
        r'(usb.*a|usb.*c|lightning|unterschied.*usb|usb.*unterschied)',
        r'(sous.*vide|sousvide|unterschied.*sous|vakuum.*garen)',
        r'(salzen.*vor|salzen.*nach|fleisch.*salzen|wann.*salzen)',
        r'(maillard.*reaktion|maillard|braten.*kruste|röstaromen)',
        r'(sarkasmus.*ironie|ironie.*sarkasmus|unterschied.*sarkasmus)',
        r'(gaslighting|gas.*lighting|manipulation.*wahrnehmung)',
        r'(dunning.*kruger|dunningkruger|kompetenz.*überschätz|selbsteinschätzung)',
        r'(confirmation.*bias|bestätigungsfehler|bestaetigungsfehler|bias.*bestätigung)',
        r'(himmel.*blau.*warum|warum.*himmel.*blau|rayleigh)',
        r'(meteor.*meteorit|meteorit.*asteroid|unterschied.*meteor)',
        r'(eis.*schwimmt|schwimmt.*eis|eis.*wasser|warum.*eis)',
        r'(freizügigkeitskonto|freizuegigkeitskonto|säule.*2.*konto|pensionskasse.*konto)',
        r'(ahv.*lücke|ahv.*luecke|beitragslücke|beitragsluecke|rente.*lücke)',
        r'(schaltjahr|schalt.*jahr|warum.*schaltjahr|29.*februar)',
        r'(gmt.*utc|utc.*gmt|unterschied.*gmt|coordinated.*universal)',
        # Neue Patterns für erweiterte KB_GENERAL (Fix K49-K64) - Auto, Reisen, Büro
        r'(benzin.*diesel|diesel.*benzin|unterschied.*benzin|unterschied.*diesel|was ist.*diesel)',
        r'(ampel.*farbe|ampel.*bedeutung|rot.*gelb.*grün|ampel.*regel)',
        r'(rechts.*vor.*links|vorfahrt.*rechts|wer.*vorfahrt)',
        r'(tempolimit|geschwindigkeit.*auto|wie schnell.*fahren|autobahn.*tempo)',
        r'(handgepäck|aufgegabengepäck|flüssigkeiten.*flug|was.*handgepäck)',
        r'(jetlag|jet.*lag|zeitverschiebung|umstellung.*zeit)',
        r'(reisepass|personalausweis|unterschied.*pass|pass.*ausweis)',
        r'(visum|visa|einreise.*erlaubnis|touristenvisum|schengen.*visum)',
        r'(pomodoro.*technik|pomodoro|25.*minuten.*arbeit|produktiv.*technik)',
        r'(pdf.*word|word.*pdf|unterschied.*pdf|dokument.*pdf)',
        r'(cloud.*speicher|cloud.*storage|google.*drive|dropbox|icloud)(?!.*next)',
        r'(e.*mail.*etikette|email.*etikette|betreff.*mail|anrede.*mail)',
    )
    # Fix KB-SCIENCE-NEW: Neue Patterns für KB_GENERAL_SCIENCE (Physik, Chemie, Astronomie)
    SCIENCE_NEW_PATTERNS = (
        r'(newton.*gesetz|newtonsches.*gesetz|trägheit|actio.*reactio|f.*=.*m.*a)',
        r'(energie.*formen|kinetische.*energie|potentielle.*energie|thermische.*energie)',
        r'(lichtgeschwindigkeit|schallgeschwindigkeit|wie schnell.*licht|wie schnell.*schall)',
        r'(elektromagnetisch.*spektrum|radio.*welle|mikrowelle|infrarot|ultraviolett|röntgen|gamma)',
        r'(aggregatzustand|fest.*flüssig.*gas|plasma.*zustand|zustand.*materie)',
    )
    # Fix KB-HEALTH: Gesundheit & Wohlbefinden Patterns für KB_HEALTH_WELLNESS
    HEALTH_KB_PATTERNS = (
        r'(schlaf.*dauer|schlaf.*stunden|wie lange.*schlafen|optimale.*schlaf|schlafhygiene)',
        r'(power.*nap|powernap|nickerchen|mittagsschlaf|kurz.*schlaf)',
        r'(wasser.*trinken|wieviel.*wasser|wie viel.*wasser|wasser.*pro.*tag|hydratation)',
        r'(vitamin.*d|vitamin-d|magnesium|eisen.*mangel|mineralien|vitamine)',
        r'(herzfrequenz|puls.*zone|training.*zone|fitness.*zone|ausdauer.*zone)',
        r'(schritte.*tag|schritte.*pro|10\.000.*schritte|schrittzahl)',
        r'(cortisol|stress.*hormon|stress.*reduktion|entspannung.*technik)',
        r'(burnout|burn.*out|ueberlastung|überlastung|erschöpfung)',
        r'(ballaststoffe|zucker.*konsum|makronaehrstoffe|makro.*nährstoff)',
        r'(erste.*hilfe|schnittwunde|verbrennung|bewusstlos|bewusstlosigkeit)',
        r'(schlaf.*qualitaet|besser.*schlafen|einschlaf.*tip|durchschlaf)',
        r'(dehydration|dehydriert|durst|flüssigkeits.*mangel|wasser.*bedarf)',
        r'(ph.*wert|ph.*skala|sauer.*basisch|säure.*lauge|zitronensaft.*ph)',
        r'(periodensystem|chemisches.*element|wasserstoff|kohlenstoff|sauerstoff|eisen|gold)',
        r'(zelle.*biologie|zellmembran|zytoplasma|zellkern|mitochondrien|dna.*erklärung)',
        r'(photosynthese|pflanzen.*licht|co2.*wasser.*licht|chloroplasten)',
        r'(dns.*basen|adenin.*thymin|guanin.*cytosin|doppelhelix|genetik.*einfach)',
        r'(sonnensystem|planet.*reihenfolge|merkur.*venus.*erde|jupiter.*saturn|lichtjahr)',
        r'(erde.*durchmesser|mond.*entfernung|astronomische.*einheit|ae.*entfernung)',
    )
    # Fix KB-EVERYDAY: Neue Patterns für KB_EVERYDAY_KNOWLEDGE (Kochen, Haushalt, Gesundheit)
    EVERYDAY_KB_PATTERNS = (
        r'(garzeit|kochzeit|nudeln.*kochen|reis.*kochen|kartoffeln.*kochen|eier.*kochen)',
        r'(fleisch.*temperatur|kern.*temperatur|braten.*grad|steak.*medium)',
        r'(haltbarkeit|wie lange.*haltbar|kühlschrank.*tage|aufbewahren)',
        r'(flecken.*entfernen|rotwein.*fleck|kaffee.*fleck|fett.*entfernen|blut.*entfernen)',
        r'(putzen.*tip|reinigung.*tip|hausputz|sauber.*machen|mikrofaser)',
        r'(notruf|erste.*hilfe|bewusstlos|blutung|verbrennung|erste.*hilfe.*maßnahme)',
        r'(vitamin.*funktion|vitamin.*quelle|vitamin.*a|vitamin.*c|vitamin.*d|vitamin.*b)',
        r'(steuerklasse|steuerklasse.*i|steuerklasse.*iii|brutto.*netto|abkürzung.*kv)',
        r'(passwort.*sicher|sicheres.*passwort|2fa|zwei.*faktor|passwort.*manager)',
        r'(datei.*größe|kb.*mb.*gb|kilobyte|megabyte|gigabyte|terabyte)',
        r'(internet.*geschwindigkeit|dsl.*kabel|glasfaser|5g.*geschwindigkeit)',
        r'(müll.*trennung|gelber.*sack|biomüll|papier.*tonne|glas.*container)',
        r'(energie.*sparen|strom.*sparen|led.*lampe|kühlschrank.*sparen)',
    )
    # Fix KB-AUTO: Neue Patterns für KB_AUTOMOBILITY (Autos, Fahrzeuge, Mobilität)
    AUTO_KB_PATTERNS = (
        r'(benzin.*diesel|diesel.*benzin|unterschied.*benzin|unterschied.*diesel|was ist.*diesel|e10.*benzin|super.*e10)',
        r'(ölwechsel|öl.*wechsel|oelwechsel|oel.*wechsel|ölstand|oelstand|öl.*prüfen|oel.*pruefen)',
        r'(reifen.*druck|reifendruck|reifen.*wechsel|winterreifen|sommerreifen|reifen.*profil|profiltiefe)',
        r'(tanken|tankstelle|benzin.*preis|diesel.*preis|tank.*kosten|sprit.*kosten)',
        r'(elektroauto|e-auto|eauto|ladestation|schnellladen|reichweite|akku.*auto|batterie.*auto)',
        r'(führerschein|fuehrerschein|fahrerlaubnis|führerschein.*kategorie|fuehrerschein.*kategorie)',
        r'(tempolimit|geschwindigkeit.*auto|wie schnell.*fahren|autobahn.*tempo|tempo.*limit)',
        r'(auto.*kaufen|auto.*verkaufen|gebrauchtwagen|neuwagen|wertverlust|auto.*kosten)',
        r'(versicherung.*auto|auto.*versicherung|kasko|vollkasko|haftpflicht|kfz.*versicherung)',
        r'(promillegrenze|promille.*auto|alkohol.*fahren|trunkenheit|blutalkohol)',
        r'(wartung.*auto|auto.*wartung|inspektion.*auto|auto.*inspektion|service.*auto)',
        r'(ampel.*farbe|ampel.*bedeutung|rot.*gelb.*grün|ampel.*regel|vorfahrt.*regel)',
        r'(rechts.*vor.*links|vorfahrt.*rechts|wer.*vorfahrt|vorfahrtsregel)',
        r'(unfall.*auto|auto.*unfall|pannen|abschleppen|kfz.*schaden)',
        r'(mietwagen|car.*sharing|carsharing|mobility|auto.*mieten)',
        r'(motor.*funktioniert|wie.*funktioniert.*motor|ottomotor|dieselmotor|hybrid.*auto)',
        r'(antrieb.*auto|frontantrieb|heckantrieb|allrad|quattro|xDrive|4matic)',
        r'(verbrauch.*auto|auto.*verbrauch|liter.*100km|kraftstoff.*verbrauch)',
    )
    analysis = {
        'role': role_hint if role_hint in ROLE_HINTS else 'general',
        'task_type': 'explain',
        'needs_setup_context': False,
        'needs_web_research': False,
        'needs_memory': False,
        'dangerous_action': False,
        'tools': [],
        'reasoning_focus': ['Verstehe zuerst das eigentliche Objekt und den Mechanismus der Anfrage.'],
        'confidence': 0.35,
    }
    if re.search(r'https?://', message):
        analysis.update(role='research', task_type='explain', tools=['url_research'], needs_web_research=True, confidence=0.82)
        return analysis
    if is_followup_query(message):
        prev = recent_topic_event(message) or recent_dialogue_event(message)
        if prev:
            prev_analysis = prev.get('analysis', {})
            prev_tools = prev_analysis.get('tools', [])
            # Fix 9: don't inherit url_research for ops/setup queries
            OPS_SIGNALS = ('hoste ich', 'mein setup', 'meine infrastruktur', 'welche services', 'welche hosts', 'wo laeuft', 'oeffentlich', 'hosts laufen', 'laufen sie', 'gerade fehler')
            if prev_tools == ['url_research'] and any(s in low for s in OPS_SIGNALS):
                analysis.update(role='ops', task_type='status', tools=['setup_lookup'], needs_setup_context=True, confidence=0.87)
                return analysis
            resolved = resolve_followup(message, prev) if prev.get('summary') else None
            focus = str((resolved or {}).get('focus') or str(prev.get('message') or '')).strip()
            analysis.update(
                role=prev_analysis.get('role', role_hint if role_hint in ROLE_HINTS else 'general'),
                task_type=prev_analysis.get('task_type', 'explain'),
                tools=prev_tools[:3],
                needs_setup_context=bool(prev_analysis.get('needs_setup_context')),
                needs_web_research=bool(prev_analysis.get('needs_web_research')),
                needs_memory=bool(prev_analysis.get('needs_memory')),
                confidence=0.92 if resolved and resolved.get('is_followup') else 0.9,
                reasoning_focus=[f'Kurze Follow-up-Anfrage; nutze den zuletzt verifizierten Kontext: {focus}'],
            )
            return analysis
    if re.search(r'^(bitte\s+)?(merke dir|merk dir|denk daran|behalte im kopf)\b', low) or re.search(r'was weisst du (alles |so )?(ueber|über) mich', low) or re.search(r'was weisst du über mich', message.lower()) or re.search(r'(mein profil|mein gespeichertes profil|profil anzeigen|profil zeigen|gespeichertes profil)', low) or re.search(r'\b(was ist mir .* wichtig|wie sollst du (mir )?antworten|welche vorlieben|welchen stil|welche art hilfe wuensche ich mir|welche art hilfe wünsche ich mir|welche praeferenzen hast du von mir gespeichert|welche präferenzen hast du von mir gespeichert)\b', low) or (re.search(r'was weisst du', low) and re.search(r'vorlieben', low)) or (re.search(r'wie sollst du mir antworten', low) and re.search(r'kennst', low)):
        analysis.update(role='personal', task_type='memory', tools=['memory_profile'], needs_memory=True, confidence=0.92)
        return analysis
    if '?' not in message and re.search(r'\b(ich will|ich bevorzuge|mir ist wichtig|achte darauf|das ist falsch|es sollte|er sollte|wenn es um .* geht|ich .* wichtig finde)\b', low) and not re.search(r'\b(installieren|einrichten|deployen|konfigurieren|aufsetzen|einbinden|migrieren|upgraden)\b', low) and not re.search(r'(homelab|server|services).{0,50}(sicher|security|absichern|haerten)', low) and not re.search(r'(sicher genug|ausreichend sicher|homelab.*sicher|server.*sicher)', low) and not re.search(r'\b(wechseln|migrieren|umsteigen|umziehen|umstellen)\b', low) and not re.search(r'\bvon\b.{1,30}\b(auf|zu)\b.{1,30}\b(wechseln|migrieren|umsteigen|umziehen|umstellen)\b', low) and not re.search(r'(abnehmen|ernaehrungsplan|ernaehrung.*plan|trainingsplan|fitness.*plan|sport.*plan|diaet.*plan|kalorien.*plan|mahlzeiten.*plan|essensplan|gewicht.*verlieren|gewicht.*reduzier)', low):
        analysis.update(role='personal', task_type='memory', tools=['memory_profile'], needs_memory=True, confidence=0.94)
        return analysis
    # Fix MEMORY-ROUTING-1: Persönliche Präferenz-Fragen ("Welche Art X mag ich?", "Was bevorzuge ich?")
    # WICHTIG: Ausschluss für Gesundheitsbeschwerden ("ich habe kopfschmerzen") und Planung ("was habe ich geplant")
    if re.search(r'\b(welche|was)\b.*\b(ich|mein|meine|mir)\b', low) and re.search(r'\b(mag|bevorzuge|nehme|trinke|esse|kaufe|nutze|verwende|sammle|interessiere)\b', low) and not re.search(r'\b(habe|hatte|bekomme|fuehle|fühle|spüre|spuere)\b.*\b(kopfschmerzen|schmerzen|weh|krank|beschwerden|geplant|vor|termin|woche)\b', low) and not re.search(r'(homelab|server|docker|container|service|host|setup|install|konfig)', low):
        analysis.update(role='personal', task_type='memory', tools=['memory_profile'], needs_memory=True, confidence=0.93)
        return analysis
    if 'briefing' in low or 'lagebild' in low or 'was ist gerade wichtig' in low:
        analysis.update(role='ops', task_type='status', tools=['briefing'], needs_setup_context=True, confidence=0.92)
        return analysis
    if re.search(r'\b(dnssec|markdown|html|backup|snapshot|ram|ssd)\b', low) and not re.search(r'(aktuell|heute|neueste|latest)', low):
        if re.search(r'(was ist|erklaer|erkläre|in einfachen worten|in drei saetzen|in drei sätzen|unterschied|vergleiche? kurz)', low):
            analysis.update(role='general', task_type='explain', tools=['general_answer'], needs_memory=False, confidence=0.95)
            return analysis
    if re.search(r'\b(sonarr|radarr)\b', low) and re.search(r'(unterschied|vergleiche?|vergleich)', low):
        analysis.update(role='general', task_type='explain', tools=['general_answer'], needs_memory=False, confidence=0.95)
        return analysis
    # Fix PROMETHEUS-INSTALL: Service-Installation + Verifikation -> ops_install + ops_exec (Multi-step)
    # Fix INSTALL-VERIFY: "installieren und danach verifizieren" -> Multi-step Pattern
    if re.search(r'(prometheus|grafana|node.*exporter|cadvisor|loki|promtail|influxdb|telegraf|zabbix|nagios)', low) and re.search(r'(installieren|install|aufsetzen|deployen|einrichten)', low) and re.search(r'(verifizieren|verifizier|testen|prüfen|pruefen|checken|sicherstellen|danach|anschliessend|anschließend)', low):
        analysis.update(role='ops', task_type='build', tools=['ops_install', 'ops_exec'], needs_setup_context=True, dangerous_action=True, confidence=0.96)
        return analysis
    # Fix PROBLEM-FOLLOWUP: "Was war das Problem" nach Diagnose -> ops_deep_analyze
    if re.search(r'^(was war das problem|was war das|welches problem|welches war das problem|das problem)', low) and re.search(r'(gefunden|diagnose|analyse|vorher|eben|gerade|du|hast)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['ops_deep_analyze'], needs_setup_context=True, confidence=0.94)
        return analysis
    if any(hint in low for hint in SERVICE_HINTS if hint not in {"share", "smb"}) and "sonos" not in low and (re.search(r'\b(?:kann|can)\s+(?!mein\b|meine\b|my\b|der\b|die\b|das\b)[a-z0-9_.@-]{2,40}\s+nicht\b', low) or re.search(r'\b[a-z0-9_.@-]{2,40}\b.*(kann sich nicht|kommt nicht rein|hat keinen zugriff|hat kein zugriff|kann nicht zugreifen|kann sich nicht anmelden|sieht .* nicht|findet .* nicht|entdeckt .* nicht|hat keine berechtigung|permission|forbidden|denied)', low) or re.search(r'\bwarum\s+kann\s+[a-z0-9_.@-]{2,40}\s+sich\s+nicht\b', low) or re.search(r'\bwarum\s+kann\s+[a-z0-9_.@-]{2,40}\s+nicht\b', low)) and re.search(r'(zugreifen|zugriff|anmelden|login|einloggen|rein|access|sieht .* nicht|findet .* nicht|entdeckt .* nicht|berechtigung|permission|forbidden|denied|mfa|duo|2fa)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['user_service_access_diagnose'], needs_setup_context=True, confidence=0.95)
        return analysis
    if any(hint in low for hint in SERVICE_HINTS if hint not in {'share', 'smb'}) and re.search(r'(sieht .* nicht|findet .* nicht|entdeckt .* nicht|fehlt|fehlen|bibliothek|library|\bserie\b|\bstaffel\b|\bfolge\b|\bepisod|\bfilm\b|ordner|ressource)', low) and 'sonos' not in low and not re.search(r'\b(sonarr|radarr|lidarr)\b', low) and not re.search(r'\b(soll ich|oder|vs|versus|vergleich|einsetzen|nehmen|waehlen)\b', low):
        analysis.update(role='ops', task_type='diagnose', tools=['user_service_access_diagnose'], needs_setup_context=True, confidence=0.93)
        return analysis
    if 'sonos' in low and re.search(r'(bibliothek|library|musik|music|share|freigabe|smb|nas|unraid|zugreifen|zugriff|findet|erreicht|scan)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['sonos_library_diagnose'], needs_setup_context=True, confidence=0.97)
        return analysis

    # CAS-1: mass user failure after config change → diagnose (not provision)
    if re.search(r'(alle benutzer|alle user|niemand kann|keiner kann|kein benutzer|alle mitglieder).*(anmelden|einloggen|zugreifen|verbinden|nutzen)', low) or re.search(r'(anmelden|einloggen).*(alle|niemand|keiner|kein benutzer)', low) or re.search(r'(ldap|authentik|sso).*(aenderung|update|neuer|geaendert|provider|einstellung).*(anmelden|einloggen|zugriff|nutzen)', low) or re.search(r'(neuen? ldap|ldap.*provider|authentik.*ldap).*(benutzer|user|anmelden|einloggen)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['user_service_access_diagnose'],
                        needs_setup_context=True, confidence=0.92)
        return analysis

    if 'emby' in low and re.search(r'(einrichten|anlegen|neu(?:en|e|er)?.*benutzer|neuen.*account|ldap|authentik|wie bisherige|wie die bisherigen|wie die bestehenden|bestehenden benutzer|standard)', low):
        analysis.update(role='ops', task_type='howto', tools=['emby_user_provision'], needs_setup_context=True, confidence=0.96)
        return analysis
    # Fix EMBY-GENERAL: Emby + Problem/Integration/Streaming/Abbruch -> setup_lookup (not general_answer)
    # Ausschluss: Vergleiche (vs, oder, besser, empfehl) -> compare_selfhosted
    if 'emby' in low and re.search(r'(bricht|ab|problem|fehler|streaming|stream|integration|integriere|media player|player|transcoding|hw.*accel|hardware.*accel|absturz|crashed|hängt|haengt|nicht mehr|kein bild|kein ton)', low) and not re.search(r'(vs|versus|oder.*besser|besser.*oder|empfiehl|soll ich.*oder)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['setup_lookup'], needs_setup_context=True, confidence=0.95)
        return analysis
    if re.search(r'(schalte|mach|ausschalten|einschalten|deaktivier|aktivier|turn off|turn on|dimm|dimmen|heller|dunkler|helligkeit)', low) and re.search(r'(licht|lichter|lights|wohnzimmer|buero|badezimmer|kueche|esszimmer|bedroom|kitchen|living|manuel|katja|alle)', low) and not re.search(r'(welche|welches|status|gerade|aktuell|eingeschaltet|eingeschalten|an sind|an ist)', low):
        analysis.update(role='ops', task_type='action', tools=['light_control'], dangerous_action=True, confidence=0.97)
        return analysis
    if re.search(r'(welche lichter|welches licht|welche lampen|welche beleuchtung|welche lichtbereiche|lichtbereiche|gerade.*licht|aktuell.*licht|aktuelle.*beleuchtung|zimmerlampen|status.*licht|licht.*status|wie.*licht.*status|lights.*status|status.*lights)', low):
        analysis.update(role='ops', task_type='status', tools=['light_status'], needs_setup_context=True, confidence=0.98)
        return analysis
    if 'licht' in low and re.search(r'(daten|automatis|wann|wie lange)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['light_usage'], needs_setup_context=True, confidence=0.88)
        return analysis
    # Fix W1: Erweiterte Web-Diagnose Patterns für interne Seiten/Doku
    if (re.search(r'[a-z0-9.-]+\.[a-z]{2,}', low) and re.search(r'(nicht oeffnen|nicht öffnen|nicht laden|webseite|website|url|zugriff|erreichbar|ausfällt|ausfaellt)', low)) or (re.search(r'(subdomain|sub-domain|hostname|hostnamen|host|domain|wiki|wissensseite|wissens-url|doku-seite|dokuseite|dokumentationsseite|dokumentation|documentation|docs?|interne.*seite|intern.*seite|wissens.*seite)', low) and re.search(r'(nicht laden|nicht oeffnen|nicht öffnen|nicht aufzugehen|nicht auf|aufgehen|von aussen|von außen|von ausserhalb|ausserhalb|extern|erreichbar|oeffnen|ausfällt|ausfaellt|welche zwei infos|welche zwei angaben|brauchst du zuerst|was brauchst du zuerst|welche.*infos|welche.*angaben|brauchst du|was brauchst)', low)):
        analysis.update(role='ops', task_type='diagnose', tools=['web_root_cause'], needs_setup_context=True, confidence=0.92)
        return analysis
    # LOG-COMPLEX: "häufigsten fehler", "fehler-patterns", "wochenbericht"
    if re.search(r'(haeufigsten?\s*fehler|fehler.{0,20}haeufig|welche fehler|fehler.?patterns|fehler.?muster)', low) or        re.search(r'(fehler.{0,30}(letzten|24|stunden|tagen|woche|monat)|wochenbericht.*fehler|log.*auswertung|log.*analyse|logs.*auswerter)', low) or        re.search(r'(fehler.*tauchen.*logs|logs.*fehler|logs.*letzten|zeig.*fehler.*logs|fehler.*logs.*letzten)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['log_hotspots'],
                        needs_setup_context=True, confidence=0.90)
        return analysis

    # Fix PIHOLE-REPORT: PiHole DNS-Report/Statistik-Anfragen -> setup_lookup (not general_answer)
    # Fix PIHOLE-CASE: Case-insensitive matching für Pihole/PiHole/pihole
    # Fix PIHOLE-BOUNDARY: Match auch "Pihole-Report" (Bindestrich ist keine Wortgrenze)
    if re.search(r'\bpihole[-_]?|\bpi[-_]?hole|\bpi-hole\b', low) and re.search(r'(report|statistik|statistiken|anfragen|blockiert|geblockt|dns.*heute|heute.*dns|wie viele|anzahl)', low):
        analysis.update(role='ops', task_type='status', tools=['setup_lookup'], needs_setup_context=True, confidence=0.94)
        return analysis
    if re.search(r'\b(logs?)\b', low) and re.search(r'(immich|nextcloud|traefik)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['log_hotspots'], needs_setup_context=True, confidence=0.92)
        return analysis
    if re.search(r'(langsam|langsamer|performance|cpu|ram|disk|netzwerk)', low) and 'host' in low:
        analysis.update(role='ops', task_type='diagnose', tools=['host_slow_diagnose'], needs_setup_context=True, confidence=0.9)
        return analysis
    if 'kasm' in low and re.search(r'(warum|wieso|zugreifen|kann|problem|fehler)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['kasm_diagnose'], needs_setup_context=True, confidence=0.9)
        return analysis
    if re.search(r'(homelab|reverse proxy|reverse-proxy|ssh|secrets|backups?|sicherer|sicherheit|security)', low) and re.search(r'(massnahmenplan|massnahmenplan|\bplan\b|priorisiert|haerten|haerten|recherchiere)', low) and not re.search(r'(urlaub|reise|trip|ferien).{0,30}planen', low):
        analysis.update(role='research', task_type='howto', tools=['security_plan'], needs_setup_context=True, needs_web_research=True, confidence=0.95)
        return analysis
    if re.search(r'(hoerbuch|hörbuch|audiobook|audiobooks?)', low) and re.search(r'(server|system|tool|dienst|plattform|plattformen|option|optionen|vergleich|vergleiche|gegeneinander|abwaegen|abwägen|loesung|lösung|empfehl|waehlen|wählen|priorisieren|aufsetzen|homelab|setup|stack)', low):
        analysis.update(role='research', task_type='compare', tools=['compare_selfhosted'], needs_web_research=True, confidence=0.95)
        return analysis
    if any(t in low for t in ('pihole', 'adguard', 'vaultwarden', 'bitwarden', 'jellyfin', 'plex', 'navidrome', 'paperless', 'gitea', 'forgejo', 'uptime-kuma', 'portainer', 'heimdall', 'dashdot', 'overseerr', 'bazarr', 'prowlarr', 'readarr', 'kavita')) and re.search(r'(besser|oder|vs|vergleich|vergleiche|unterschied|welches|empfiehl|nehmen|waehlen|wählen|statt|anstatt)', low):
        analysis.update(role='research', task_type='compare', tools=['compare_selfhosted'], needs_web_research=True, confidence=0.87)
        return analysis
    # MIG-VS: "X vs Y" / "soll ich X oder Y" service comparison
    _cs = r'(nextcloud|seafile|jellyfin|emby|plex|vaultwarden|bitwarden|portainer|traefik|nginx|proxmox|unraid|truenas|synology|docker|podman|gitea|forgejo|immich|photoprism|audiobookshelf|navidrome|lidarr|sonarr|radarr)'
    if re.search(_cs + r'\s*(vs\.?|versus)\s*' + _cs, low) or re.search(r'(soll ich|lohnt sich|empfiehlst du).{0,60}' + _cs + r'.{0,40}(oder|vs|anstatt|statt)', low) or re.search(r'(soll ich|lohnt sich|empfiehlst du).{0,60}' + _cs + r'.{0,60}' + _cs, low) or re.search(r'(was ist besser|welches ist besser|was empfiehlst).{0,80}' + _cs, low) and not re.search(r'\bfuer homelab\b', low) or re.search(_cs + r'.{0,40}(oder|vs|versus).{0,40}' + _cs + r'.{0,50}(einsetzen|verwenden|nehmen|waehlen|nutzen)', low):
        analysis.update(role='ops', task_type='compare', tools=['compare_selfhosted'],
                        needs_setup_context=False, confidence=0.91)
        return analysis

    # MIG: migration / platform switch / "von X auf Y wechseln"
    _mig_svcs = r'(unraid|proxmox|docker|truenas|synology|qnap|ubuntu|debian|jellyfin|emby|nextcloud|vaultwarden|bitwarden|portainer|seafile|plex|gitea|forgejo)'
    if re.search(r'\bvon\b.{1,40}\b(auf|zu|nach)\b.{1,40}\b(wechseln|migrieren|umsteigen|umziehen|umstellen)\b', low) or re.search(r'\bvon\b\s+' + _mig_svcs + r'.{0,20}\b(auf|zu)\b', low) or re.search(_mig_svcs + r'.{1,30}\b(wechseln|migrieren|umsteigen|umziehen|umstellen)\b', low) or re.search(r'(was muss ich beachten.*(wechseln|migrieren|umsteigen)|was verliere ich dabei|was aendert sich beim wechsel)', low):
        analysis.update(role='ops', task_type='compare', tools=['compare_selfhosted'],
                        needs_setup_context=True, confidence=0.90)
        return analysis

    # EXPERT-RESEARCH early intercept: deep/comprehensive research queries → expert_research before compare_selfhosted
    if re.search(r'(recherchiere.{0,30}(tiefgr|tiefsinnig|vollst|komplett|umfassend|detailliert)|'
                 r'marktanalyse|wettbewerbsanalyse|kompetitor.*analyse|competitive.*analysis|'
                 r'investigier|investigative|vollstaendige.*analyse|comprehensive.*analysis|'
                 r'fact.?check|fakten.*pruefen|quellen.*pruefen|verifizier.*fakten|'
                 r'recherche.*bericht|research.*report|due.*diligence)', low):
        analysis.update(role='research', task_type='explain', tools=['expert_research'], needs_web_research=True, confidence=0.93)
        return analysis
    if re.search(r'(selbst zu hosten|selbst hosten|selber hosten|self-hosted|self hosted)', low):
        analysis.update(role='research', task_type='compare', tools=['compare_selfhosted'], needs_web_research=True, confidence=0.84)
        return analysis
    # Fix PROTO-SYNTH: Protokoll/Technologie-Erklaerung + was nutzt [Service] konkret
    # MUSS VOR allgemeinem 'vergleich' Pattern kommen!
    # Catches: "Unterschied OAuth2/OIDC/SAML + was nutzt Authentik?"
    if any(h in low for h in SERVICE_HINTS) and re.search(
        r'(oauth|oidc|saml|jwt|openid|ldap|'
        r'protokoll.*unterschied|unterschied.*protokoll|auth.*protokoll|'
        r'was ist.*unterschied|unterschied.*zwischen|erklaer.*protokoll|erklär.*protokoll|'
        r'was ist.*oauth|was ist.*oidc|was ist.*saml|was ist.*ldap)', low) and re.search(
        r'(nutzt|verwendet|benutzt|einsetzt|konkret|im einsatz|wie setzt.*ein|wie verwendet|was.*nutzt|was.*verwendet)', low):
        analysis.update(role='ops', task_type='explain', tools=['ops_deep_analyze'],
                        needs_setup_context=True, confidence=0.91)
        return analysis
    # Fix ARCH-REASONING: Architektur/Abhängigkeits/Kaskaden-Fragen -> ops_deep_analyze
    # Catches: 'was passiert wenn X ausfällt', 'wie hängen X und Y zusammen', 'Abhängigkeitskette'
    if any(h in low for h in SERVICE_HINTS) and re.search(
        r'(abhaengigkeits?kette|abhaengigkeiten|zusammenspiel|wie haengen|wie hängen|was passiert wenn|'
        r'wenn .{0,30} ausfaellt|wenn .{0,30} ausfällt|wenn .{0,30} down|cascad|kaskad|'
        r'zusammenhaeng|zusammenhäng|wie.*funktioniert.*zusammen|login.*flow|login-flow|auth.*flow|'
        r'welche.*abhaengig|welche.*abhängig|ich plane .{0,40} zu deployen)', low):
        analysis.update(role='ops', task_type='explain', tools=['ops_deep_analyze'],
                        needs_setup_context=True, confidence=0.93)
        return analysis
    if re.search(r'(recherchiere|vergleich|vergleiche)', low):
        wants_selfhosted = bool(re.search(r'(hosten|hosting|lokal|on-prem|onprem|selbst|self)', low))
        analysis.update(role='research', task_type='compare', tools=['compare_selfhosted'] if wants_selfhosted else ['web_research'], needs_web_research=True, confidence=0.82)
        return analysis
    if re.search(r'(welche services|welche dienste|welche apps|welche anwendungen|welche app|welche anwendung|was hoste ich|hoste ich aktuell|oeffentlich|öffentlich|extern erreichbar|oeffentlich erreichbar|öffentlich erreichbar|gesund|oeffentliche app|öffentliche app|oeffentliche anwendung|öffentliche anwendung)', low) and re.search(r'(fehler|warnings?|warnungen|probleme|kaputt|status|zustand|gesund|gestoert|gestört|stoerung|störung|instabil|instabilsten|unreachable|down)', low):
        analysis.update(role='ops', task_type='status', tools=['public_services_health'], needs_setup_context=True, confidence=0.95)
        return analysis
    if re.search(r'(hoste ich|mein setup|meine infrastruktur|wo laeuft|welche hosts|welche services|oeffentlich)', low):
        analysis.update(role='ops', task_type='status', tools=['setup_lookup'], needs_setup_context=True, confidence=0.86)
        return analysis
    # Fix K13: Homelab service + HTTP error code -> setup_lookup (before GENERAL_KB_PATTERNS)
    if any(s in low for s in ('traefik', 'nextcloud', 'immich', 'emby', 'authentik', 'nginx')) and re.search(r'(502|503|404|500|401|403|error|fehler|zurück|zurueck|gibt|return)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['setup_lookup'], needs_setup_context=True, confidence=0.94)
        return analysis
    # Fix STATUS-REPORT: "Statusbericht", "Bericht", "Übersicht" + Homelab/Setup -> setup_lookup
    if re.search(r'(statusbericht|status.*bericht|bericht|übersicht|uebersicht|zustand|gesamtzustand)', low) and re.search(r'(homelab|setup|infrastruktur|services|dienste|server|host|system)', low):
        analysis.update(role='ops', task_type='status', tools=['setup_lookup'], needs_setup_context=True, confidence=0.95)
        return analysis
    # Fix NC-OPT: "kannst du mir [SERVICE] optimieren" -> setup_lookup (not web_research)
    if re.search(r'(kannst du mir|kannst du|hilf mir|unterstütze mich|unterstuetze mich).{0,30}(optimieren|verbessern|tunen|konfigurieren|einrichten|aufräumen|aufrauemen)', low) and any(s in low for s in ('nextcloud', 'immich', 'traefik', 'authentik', 'emby', 'unraid', 'proxmox', 'docker', 'nginx', 'tailscale', 'home assistant', 'homeassistant', 'kasm', 'pihole', 'adguard', 'wireguard', 'sonarr', 'radarr', 'lidarr', 'audiobookshelf')):
        analysis.update(role='ops', task_type='setup', tools=['setup_lookup'], needs_setup_context=True, confidence=0.92)
        return analysis
    # Fix POWER-OUTAGE: Stromausfall + Homelab/Server -> setup_lookup (Diagnose nötig)
    if re.search(r'(stromausfall|strom.*aus|blackout|strom.*weg|strom.*unterbrechung|strom.*wieder|nach.*strom)', low) and re.search(r'(homelab|server|dienste|services|nicht mehr|komplett|funktioniert|erreichbar|neustart|restart)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['setup_lookup'], needs_setup_context=True, confidence=0.96)
        return analysis
    # Fix 13: Recipe/cooking questions covered by KB_RECIPES.md -> direct general_answer
    # Fix R1: Erweiterte Rezept-Patterns für bessere Abdeckung
    # Fix STAT4: past-tense food/activity queries → memory_profile (not recipe)
    if re.search(r'(was habe ich|was hatte ich|was.*ich.*(gemacht|getan|gelernt|gelesen|getrunken|gegessen|geschlafen|trainiert))', low) and re.search(r'(letzte woche|gestern|letzten|vorige woche|letztem monat|letztes jahr|heute morgen|heute frueh)', low):
        analysis.update(role='personal', task_type='memory', tools=['memory_profile'], needs_memory=True, confidence=0.89)
        return analysis
    RECIPE_PATTERNS_EXTENDED = RECIPE_PATTERNS + (
        r'(gib mir.*rezept|gib.*rezept|rezept.*bitte|rezept fuer|rezept f.r)',
        r'(omeletten|omelette|omelett|eier.*kochen|eier.*braten)',
        r'(schnell.*kochen|einfach.*kochen|was.*kochen|was.*essen)',
    )
    if any(re.search(p, low) for p in RECIPE_PATTERNS_EXTENDED) and not any(h in low for h in ('homelab', 'server', 'docker', 'container', 'menu', 'code', 'script', 'programm')) and not re.search(r'(normalerweise|gewoehnlich|meistens|morgens|abends|taeglich|stets)', low):
        analysis.update(role='personal', task_type='howto', tools=['personal_assist'], needs_memory=True, confidence=0.93)
        return analysis
    # Also catch broader food queries (Fix 7 restored)
    if re.search(r'(ideen|abendessen|mittagessen|fruehstueck|rezept|zutaten|kochen|backen|was essen|was koche|was esse|zum essen|schnelles essen)', low) and not any(h in low for h in ('homelab', 'server', 'docker', 'container', 'menu')) and not re.search(r'(normalerweise|gewoehnlich|meistens|oft|immer|morgens|abends|taeglich|stets|ueblicherweise|typisch)', low):
        analysis.update(role='personal', task_type='howto', tools=['personal_assist'], needs_memory=True, confidence=0.90)
        return analysis
    # Fix WEB-ENTITY: Definition/Entity questions that general-local-assist rejects -> web_research FIRST
    # These patterns must come BEFORE general_answer patterns to avoid ungrounded results
    # BUT: Skip if query matches KB patterns (KB_GENERAL or KB_SCIENCE) to avoid double-routing
    # Fix SETUP-PRE: Homelab/Setup-Queries müssen VOR WEB_ENTITY_PATTERN geprüft werden
    SETUP_PRE_PATTERN = r'(hoste ich|mein setup|meine infrastruktur|welche services|welche hosts|wo laeuft|welche hosts|welche services|oeffentlich|öffentlich|extern erreichbar|oeffentlich erreichbar|öffentlich erreichbar)'
    if re.search(SETUP_PRE_PATTERN, low) and re.search(r'(ich|mein|meine|mir)', low):
        analysis.update(role='ops', task_type='status', tools=['setup_lookup'], needs_setup_context=True, confidence=0.92)
        return analysis
    WEB_ENTITY_PATTERN = r'^(was ist|wer ist|wo ist|wo liegt|wo befindet sich|wie leben|wie lebt|wo leben|wo lebt|was essen|was frisst|wie gross ist|wie groß ist|wie alt wird|wie funktioniert)\b'
    if re.search(WEB_ENTITY_PATTERN, low):
        # Check if this is covered by KB patterns - if so, let KB patterns handle it
        kb_covered = False
        # Check against GENERAL_KB_PATTERNS (need to check before they're defined, so inline check)
        # Fix KB-COVERAGE: Erweiterte Liste deckt alle GENERAL_KB_PATTERNS ab
        kb_general_terms = ['docker', 'reverse proxy', 'tailscale', 'truenass', 'wetter', 'klima', 
                           'photosynthese', 'lichtjahr', 'fleisch.*auftauen', 'waschmittel',
                           'kühlschrank', 'schnittwunde', 'wasser.*trinken', 'schlaf.*dauer',
                           'säulen.*system', 'etf', 'du.*sie.*deutsch', 'prozent', 'trinkgeld',
                           'kaffee.*kochen', 'tee.*zubereiten', 'eier.*kochen', 'pasta.*kochen',
                           'bohnen.*einweichen', 'reis.*kochen', 'avocado.*reif', 'brot.*aufbewahren',
                           'zitronen.*haltbar', 'butter.*haltbar', 'öl.*haltbar', 'honig.*haltbar',
                           'käse.*haltbar', 'zwiebeln.*haltbar', 'knoblauch.*haltbar',
                           # Neue KB-General Begriffe (K1-K48)
                           'tage bis', 'stunden.*jahr', 'vitamin d', 'kopfschmerzen', 'gestresst',
                           'schweiz.*gegründet', 'http.*status', 'passwort.*ändern', 'python.*error',
                           'übersetze', 'buch.*empfehl', 'ip.*adresse', 'dns', 'vpn',
                           'router.*switch', 'makronaehrstoff', 'glykaemisch', 'keto',
                           'inflation', 'zinseszins', 'aktien.*etf', 'waschmaschine',
                           'kuehlschrank.*funktioniert', 'backpulver', 'jahreszeiten',
                           'biologisch.*oekologisch', 'oekosystem', 'hiit', 'krafttraining',
                           'ausdauer', 'oled', 'energie.*klasse', 'usb', 'sous.*vide',
                           'salzen', 'maillard', 'sarkasmus', 'gaslighting', 'dunning',
                           'confirmation.*bias', 'meteor', 'eis.*schwimmt', 'freizügigkeitskonto',
                           'ahv.*lücke', 'schaltjahr', 'gmt.*utc']
        for term in kb_general_terms:
            if re.search(term.replace('.*', '.*'), low):
                kb_covered = True
                break
        # Check against SCIENCE_KB_PATTERNS
        if not kb_covered:
            science_terms = ['rayleigh', 'lichtstreuung', 'himmel.*blau', 'mondfinsternis', 
                            'blutmond', 'mondtäuschung', 'mond.*grösser', 'mond.*größer']
            for term in science_terms:
                if re.search(term, low):
                    kb_covered = True
                    break
        if not kb_covered:
            # Tech architecture topics -> expert_code (not web_research)
            _tech_entity_topics = r'(microservice|event.driven|cqrs|saga.pattern|message.queue|rabbitmq|kafka|kubernetes|k8s|terraform|ansible|design.pattern|dependency.injection|solid.prinzip|clean.architektur|hexagonal|rest.*graphql|graphql.*rest|websocket|grpc|jwt.*flow|oauth.*flow|openid.*flow|ci.cd|gitflow|feature.flag|blue.green|canary.deploy|serverless|nosql.*sql|sharding|datenbank.*indexing|orm.*raw.*sql|async.*await|threading.*async|race.condition|deadlock|idempotent|eventual.consistency|cap.theorem|domain.driven|ddd|bounded.context)'
            if re.search(_tech_entity_topics, low):
                analysis.update(role='dev', task_type='explain', tools=['qdrant_search', 'expert_code'], confidence=0.89)
                return analysis
            analysis.update(role='research', task_type='explain', tools=['web_research'], needs_web_research=True, confidence=0.85)
            return analysis
    # Fix 10: Science questions covered by KB_SCIENCE_COMMON.md -> direct general_answer
    # Fix S1: Erweiterte Science-Patterns für Mondfinsternis, Sonnenfarbe
    SCIENCE_KB_PATTERNS_EXTENDED = SCIENCE_KB_PATTERNS + (
        r'(mondfinsternis.*rot|mondfinsternis.*kupfer|roter mond|kupferfarbener mond|mond.*rot|mond.*kupfer)',
        r'(sonne.*rot|sonne.*orange|sonnenuntergang.*rot|sonnenuntergang.*orange|untergehende sonne|sonne.*untergang.*farbe)',
        r'(mond.*grösser|mond.*größer|mondtäuschung|mondtaeuschung|mond.*groß|mond.*gross)',
        r'(himmel.*blau|blauer himmel|warum.*himmel|licht.*himmel)',
    )
    if any(re.search(p, low) for p in SCIENCE_KB_PATTERNS_EXTENDED):
        analysis.update(role='general', task_type='explain', tools=['general_answer'], needs_memory=False, confidence=0.95)
        return analysis
    # Fix KB-SCIENCE-NEW: Neue Science-Patterns für erweiterte KB_GENERAL_SCIENCE
    if any(re.search(p, low) for p in SCIENCE_NEW_PATTERNS):
        analysis.update(role='general', task_type='explain', tools=['general_answer'], needs_memory=False, confidence=0.95)
        return analysis
    # Fix 15: General knowledge questions covered by KB_GENERAL.md -> direct general_answer
    if any(re.search(p, low) for p in GENERAL_KB_PATTERNS):
        analysis.update(role='general', task_type='explain', tools=['general_answer'], needs_memory=False, confidence=0.95)
        return analysis
    # Fix KB-EVERYDAY: Alltagswissen-Fragen für KB_EVERYDAY_KNOWLEDGE
    if any(re.search(p, low) for p in EVERYDAY_KB_PATTERNS):
        analysis.update(role='general', task_type='explain', tools=['general_answer'], needs_memory=False, confidence=0.95)
        return analysis
    # Fix KB-HEALTH: Gesundheit & Wohlbefinden Fragen für KB_HEALTH_WELLNESS
    if any(re.search(p, low) for p in HEALTH_KB_PATTERNS):
        analysis.update(role='general', task_type='explain', tools=['general_answer'], needs_memory=False, confidence=0.95)
        return analysis
    # Fix KB-LANGUAGES: Sprach- & Übersetzungsfragen für KB_LANGUAGES
    LANGUAGE_KB_PATTERNS = (
        r'(übersetze|uebersetze|auf englisch|auf deutsch|auf italienisch|auf französisch|wie sagt man|wie heisst|wie heißt)',
        r'(du.*sie.*deutsch|sie.*du.*deutsch|wann du.*wann sie|anrede.*deutsch|höflich.*anreden)',
        r'(grammatik|zeitformen|konjugation|deklinieren|tenses|present|past|future|perfect)',
        r'(false friends|falsche freunde|übersetzungsfehler|übersetzung.*fehler|false.*friend)',
        r'(sprache.*lernen|lernen.*sprache|vokabeln|aussprache|sprachniveau|cefr|a1|b1|c1.*sprache)',
        r'(email.*etikette|email.*betreff|schlussformel|grussformel|anrede.*email)',
        r'(smalltalk|konversation|kommunikation.*tip|gespräch.*führen|small.*talk)',
        r'(ciao.*bedeutung|buongiorno|bonjour.*bedeutung|grüße.*italienisch|grüße.*französisch)',
    )
    if any(re.search(p, low) for p in LANGUAGE_KB_PATTERNS):
        analysis.update(role='general', task_type='explain', tools=['general_answer'], needs_memory=False, confidence=0.95)
        return analysis
    # Fix KB-FINANCE: Finanz- & Geldanlagefragen für KB_FINANCE
    FINANCE_KB_PATTERNS = (
        r'\b(etf|etfs|aktienfond|indexfond|msci world|msci|sp 500|dax|nasdaq)\b',
        r'(wie.*anlegen|geld.*anlegen|anlage.*tip|wohin.*geld|sparen.*tip|budget.*tip)',
        r'(tagesgeld|festgeld|sparbuch|zinsen|zinssatz|konto.*gebühr|bank.*gebühr)',
        r'(steuerklasse|abgeltungssteuer|freistellungsauftrag|steuer.*freibetrag|kapitalertrag)',
        r'(versicherung.*tip|haftpflicht|hausrat|berufsunfähigkeit|rechtschutz)',
        r'(notgroschen|notfall.*geld|3 monatsgehälter|6 monatsgehälter)',
        r'(bitcoin|ethereum|krypto|cryptowährung|wallet|blockchain|coin)',
        r'(depot.*eröffnen|broker.*vergleich|neo.*broker|trade republic|scalable)',
        r'(50/30/20|fünfzig dreißig zwanzig|budget.*regel|sparrate)',
    )
    if any(re.search(p, low) for p in FINANCE_KB_PATTERNS):
        analysis.update(role='general', task_type='explain', tools=['general_answer'], needs_memory=False, confidence=0.95)
        return analysis
    # Fix KB-LEGAL: Recht & Verbraucherfragen für KB_LEGAL_CONSUMER
    LEGAL_KB_PATTERNS = (
        r'(kündigungsfrist|kündigen|vertrag.*kündigen|kündigung)',
        r'(widerrufsrecht|rückgabe|umtausch|14 tage|14 tage.*recht)',
        r'(gewährleistung|garantie|reklamation|mängel|mangel)',
        r'(mietrecht|mieterhöhung|kaution|miete.*recht)',
        r'(arbeitsrecht|urlaub.*recht|kündigungsschutz|arbeitsvertrag)',
        r'(bußgeld|bussgeld|punkte.*führerschein|führerschein.*punkte|verkehrsrecht)',
        r'(dsgvo|datenschutz|auskunft.*daten|recht.*vergessen)',
        r'(erbrecht|testament|pflichtteil|erbe.*recht)',
        r'(verbraucherrecht|mängelrüge|schadensersatz|verbraucher)',
    )
    if any(re.search(p, low) for p in LEGAL_KB_PATTERNS):
        analysis.update(role='general', task_type='explain', tools=['general_answer'], needs_memory=False, confidence=0.95)
        return analysis
    # Fix KB-TRAVEL: Reise & Transport Fragen für KB_TRAVEL_TRANSPORT.md
    TRAVEL_KB_PATTERNS = (
        r'(bahn|zug|db|sparbpreis|bahncard|quer-durchs-land|deutschlandticket|verspätung|anschluss|zug.*verpasst)',
        r'(handgepäck|handgepaeck|flüssigkeit|fluessigkeit|packen|koffer|reiseapotheke|reise.*packen)',
        r'(flug|fluggastrecht|eu261|überbuchung|ueberbuchung|annullierung|flug.*annulliert|flug.*verspätet)',
        r'(mietwagen|auto.*mieten|vignette|umweltzone|crit.air|critair|grüne.*plakette|gruene.*plakette)',
        r'(flixbus|fernbus|bus.*fahren|bus.*reise)',
        r'(reise.*buchen|urlaub.*buchen|beste.*buchungszeit|wann.*buchen|früh.*buchen|frueh.*buchen)',
        r'(reisedokument|reisepass|personalausweis|visum|einreise|impfung|reise.*versicherung)',
    )
    if any(re.search(p, low) for p in TRAVEL_KB_PATTERNS):
        analysis.update(role='general', task_type='explain', tools=['general_answer'], needs_memory=False, confidence=0.95)
        return analysis
    # Fix KB-COOKING: Kochtechniken & Küchenwissen für KB_COOKING_TECHNIQUES
    COOKING_KB_PATTERNS = (
        r'(braten|schmoren|dünsten|duensten|blanchieren|sous.*vide|garen|garzeit|gar.*zeit)',
        r'(julienne|brunoise|würfeln|wuerfeln|schneiden|hacken|messer.*schärfen|messer.*schaerfen)',
        r'(mehlschwitze|roux|binden.*sauce|reduzieren.*sauce|montieren.*butter)',
        r'(kerntemperatur|kern.*temperatur|fleisch.*temperatur|braten.*grad|steak.*medium)',
        r'(marinieren|marinade|fleisch.*marinieren|fleisch.*würzen|fleisch.*wuerzen)',
        r'(hefeteig|rührteig|biskuitteig|mürbeteig|blätterteig|gären|gaeren|backen)',
        r'(mise en place|zubereiten|kochtechnik|küchenwissen|kuechenwissen)',
        r'(sauce.*machen|sosse.*machen|fond.*machen|braten.*anbraten)',
        r'(gemüse.*kochen|gemuese.*kochen|gemüse.*garen|gemuese.*garen|blanchieren)',
        r'(fleisch.*ruhen|fleisch.*ruhen.*lassen|braten.*ruhen)',
    )
    if any(re.search(p, low) for p in COOKING_KB_PATTERNS):
        analysis.update(role='general', task_type='explain', tools=['general_answer'], needs_memory=False, confidence=0.95)
        return analysis

    # Fix KB-PETS: Haustiere & Tierhaltung Fragen für KB_PETS_ANIMALS.md
    PETS_KB_PATTERNS = (
        r'\b(hund|hunde|welpe|welpen|rasse|hunderasse|hunderassen|hundeerziehung|hundetraining)\b',
        r'\b(katze|katzen|kitten|kastration|katzenklo|kratzbaum|freigänger|freigaenger)\b',
        r'\b(haustier|haustiere|tierhaltung|tierarzt|tiergesundheit|impfung.*tier|entwurmung)\b',
        r'(kaninchen|meerschweinchen|hamster|maus|maeuse|vogel|voegel|wellensittich|aquarium|fisch|fische)',
        r'(hundefutter|katzenfutter|tierfutter|barf|trockenfutter|nassfutter|futter)',
        r'(hund.*temperament|katze.*charakter|welpe.*erziehen|hund.*trainieren)',
        r'(giftig.*hund|giftig.*katze|schokolade.*hund|schokolade.*katze|lilien.*katze)',
        r'(zecken|zeckenschutz|floh|flöhe|flöhe|entwurmung|impfung.*hund|impfung.*katze)',
        r'(hund.*auslauf|katze.*auslauf|gassi|spazieren|hund.*bewegung)',
        r'(aquarium.*einrichten|aquarium.*wasserwerte|fische.*haltung|aquaristik)',
        r'(tierverhalten|hundesprache|katzensprache|hund.*kommunikation|katze.*kommunikation)',
        r'(hundesteuer|hundepflichtversicherung|tier.*versicherung|chip.*tier)',
    )
    if any(re.search(p, low) for p in PETS_KB_PATTERNS):
        analysis.update(role='general', task_type='explain', tools=['general_answer'], needs_memory=False, confidence=0.95)
        return analysis
    # Fix KB-AUTO: Auto & Mobilität Fragen für KB_AUTOMOBILITY.md
    if any(re.search(p, low) for p in AUTO_KB_PATTERNS):
        analysis.update(role='general', task_type='explain', tools=['general_answer'], needs_memory=False, confidence=0.95)
        return analysis
    # Fix KB-HOUSE-GARDEN: Haus & Garten Wissen für KB_HOUSE_GARDEN.md
    HOUSE_GARDEN_PATTERNS = (
        r'\b(monstera|sansevieria|ficus|calathea|zamioculcas|pflanze|pflanzen|zimmerpflanze|zimmerpflanzen)\b',
        r'\b(sukkulente|sukkulenten|kakteen|kaktus)\b',
        r'\b(giessen|giessen|giess|gieß|gieße|wasser.*pflanze|pflanze.*wasser)\b',
        r'\b(umtopfen|neuer.*topf|topf.*wechseln|pflanze.*umtopfen)\b',
        r'\b(garten|beet|rasen|mähen|maehen|rasen.*mähen|rasen.*maehen)\b',
        r'\b(tomaten|gemüse|gemuese|kräuter|kraeuter|hochbeet|aussaat|ernte)\b',
        r'\b(unkraut|schädling|schaedling|blattlaus|schnecke|mehltau|krankheit.*pflanze)\b',
        r'\b(kompost|kompostieren|komposthaufen|komposterde)\b',
        r'\b(gartengerät|gartengeraet|spaten|schere|schaufel|rechen|hacke)\b',
        r'\b(frühling|fruehling|sommer|herbst|winter|saison|jahreszeit.*garten)\b',
        r'\b(streichen|wand.*streichen|farbe.*wand|anstrich|renovieren)\b',
        r'\b(löcher.*wand|loch.*wand|wand.*loch|reparieren.*wand|dübel|duebel)\b',
        r'\b(wasserhahn|hahn.*tropft|tropfender.*hahn|armatur.*reparieren)\b',
        r'\b(drainage|topf.*drainage|pflanze.*drainage|wurzelfäule|wurzelfaeule)\b',
        r'\b(lichtbedarf|sonne.*pflanze|pflanze.*sonne|halbschatten|schattenpflanze)\b',
        r'\b(garzeit|kochzeit|nudeln.*kochen|reis.*kochen|kartoffeln.*kochen|eier.*kochen)\b',
        r'\b(fleisch.*temperatur|kern.*temperatur|braten.*grad|steak.*medium)\b',
        r'\b(haltbarkeit|wie lange.*haltbar|kühlschrank.*tage|aufbewahren)\b',
        r'\b(flecken.*entfernen|rotwein.*fleck|kaffee.*fleck|fett.*entfernen|blut.*entfernen)\b',
        r'\b(putzen.*tip|reinigung.*tip|hausputz|sauber.*machen|mikrofaser)\b',
    )
    if any(re.search(p, low) for p in HOUSE_GARDEN_PATTERNS) and not any(s in low for s in ('homelab', 'server', 'docker', 'container', 'service', 'host', 'setup', 'infrastruktur', 'nextcloud', 'traefik', 'proxmox', 'unraid')):
        analysis.update(role='general', task_type='explain', tools=['general_answer'], needs_memory=False, confidence=0.95)
        return analysis
    # Fix KB-SPORT-FITNESS: Sport, Fitness & Bewegung für KB_SPORT_FITNESS.md
    # WICHTIG: Patterns müssen spezifisch sein - keine Planungs- oder Homelab-Queries matchen
    SPORT_FITNESS_PATTERNS = (
        # Spezifische Sportarten/Disziplinen (nicht "sport" allein)
        r'\b(krafttraining|cardio|ausdauertraining)\b',
        r'\b(laufen\b|joggen\b|radfahren\b|schwimmen\b|marathon\b|triathlon\b|ironman\b)(?!\s*sollten|\s*soll|\s*werden|\s*können|\s*koennen)',
        r'\b(yoga\b|pilates\b|crossfit\b|calisthenics\b|bodybuilding\b|powerlifting\b)',
        r'\b(kampfsport\b|boxen\b|kickboxen\b|muay thai\b|bjj\b|judo\b|mma\b|wrestling\b)',
        r'\b(teamsport\b|fussball\b|basketball\b|volleyball\b|handball\b|eishockey\b)',
        # Spezifische Übungen/Equipment
        r'\b(kniebeuge\b|bankdrücken\b|kreuzheben\b|deadlift\b|squat\b|bench press\b)',
        r'\b(klimmzug\b|liegestütz\b|liegestuetz\b|pushup\b|pullup\b|muscle up\b|plank\b)',
        r'\b(hantel\b|hanteln\b|kettlebell\b|widerstandsband\b|resistance band\b)',
        r'\b(laufschuhe|sport.*schuhe|schuhe.*laufen)',
        # Trainingskonzepte (nicht "training" allein)
        r'\b(workout\b|trainingsplan\b|trainingsplanung\b|progressive überlastung)',
        r'\b(wiederholungen\b|sätze\b|satz\b|satz.*zahl|wiederholungszahl)',
        r'\b(herzfrequenz\b|puls\b|puls.*zone|zone 2|zone 3|hiit\b|liss\b)',
        r'\b(aufwaermen|aufwärmen|mobilität|dehnübung|dehnuebung)',
        # Ernährung spezifisch für Sport
        r'\b(protein.*muskel|muskel.*protein|kreatin\b|supplement\b)',
        r'\b(ernährung.*sport|sport.*ernährung|fitness.*ernährung)',
        # Verletzungen/Regeneration
        r'\b(verletzung.*sport|sport.*verletzung|muskelkater\b|regeneration\b)',
        r'\b(schlaf.*muskel|muskel.*schlaf|muskel.*wachstum)',
    )
    # Nur matchen wenn KEINE Planungs- oder Homelab-Keywords vorhanden
    if any(re.search(p, low) for p in SPORT_FITNESS_PATTERNS):
        if not any(s in low for s in ('homelab', 'server', 'docker', 'container', 'service', 'host', 'setup', 'infrastruktur', 'plane', 'planen', 'woche', 'monat', 'januar', 'februar', 'märz', 'april', 'mai', 'juni', 'juli', 'august', 'september', 'oktober', 'november', 'dezember')):
            analysis.update(role='general', task_type='explain', tools=['general_answer'], needs_memory=False, confidence=0.95)
            return analysis
    # Fix DNS-PROBLEM: DNS-Auflösungsprobleme im Homelab → setup_lookup (not general_answer)
    if re.search(r'(dns|dns.*aufloesung|dns.*auflösung|domain.*nicht|namensauflösung)', low) and re.search(r'(funktioniert.*nicht|problem|fehler|nicht.*erreichbar|timeout)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['setup_lookup'], needs_setup_context=True, confidence=0.94)
        return analysis
    # Fix KB-EVERYDAY-TECH: Alltägliche Technik & Gadgets für KB_EVERYDAY_TECH.md
    EVERYDAY_TECH_PATTERNS = (
        r'\b(iphone|android|smartphone|handys?|tablets?|ipad)\b',
        r'\b(speicher voll|akku|batterie|laden|ladekabel|face id|touch id|fingerabdruck)\b',
        r'\b(screenshot|bildschirmfoto|drucken|tastenkürzel|shortcut)\b',
        r'\b(passwort|passwort-manager|2fa|zwei-faktor|sicher)\b',
        r'\b(phishing|spam|betrug|virus|malware|schutz)\b',
        r'\b(wlan|wifi|internet|router|verbindung|netzwerk)\b',
        r'\b(bluetooth|kopfhörer|airpods|lautsprecher|boxen)\b',
        r'\b(streaming|netflix|spotify|qualität|daten|auflösung)\b',
        r'\b(drucker|scanner|drucken|tinte|laser)\b',
        r'\b(e-mail|email|anhang|mail|posteingang)\b',
        r'\b(whatsapp|signal|telegram|messenger|chat)\b',
        r'\b(update|software|app|programm|installieren|deinstallieren)\b',
        r'\b(cloud|icloud|google drive|dropbox|backup|speichern)\b',
        r'\b(usb|kabel|ladegerät|adapter|hdmi|displayport)\b',
        r'\b(airplay|chromecast|bildschirm.*spiegeln|screen mirroring)\b',
        r'\b(alexa|google assistant|siri|smart home|smarte steckdose)\b',
        r'\b(thermostat|heizung.*steuern|smart.*heizung)\b',
        r'\b(fotos?|bilder|videos?|galerie|kamera)\b',
        r'\b(datei.*größe|kb|mb|gb|kilobyte|megabyte|gigabyte)\b',
        r'\b(energie.*klasse|stromverbrauch|verbrauch.*gerät)\b',
        r'\b(oled|qled|led|fernseher|tv|bildschirm|monitor)\b',
        r'\b(pdf|word|dokument|datei.*konvertieren|konvertieren)\b',
        r'\b(pomodoro|produktiv|zeitmanagement|zeit.*managen)\b',
    )
    if any(re.search(p, low) for p in EVERYDAY_TECH_PATTERNS) and not any(s in low for s in ('homelab', 'server', 'docker', 'container', 'service', 'host', 'setup', 'infrastruktur', 'nextcloud', 'traefik', 'proxmox', 'unraid')) and not re.search(r'(skalier|von.*auf.*user|performance.*app|bottleneck|load.balanc)', low) and not re.search(r'(email.*(chef|vorgesetzt|manager|leitung|gehal|bonus)|wegen.*gehal)', low):
        analysis.update(role='general', task_type='explain', tools=['general_answer'], needs_memory=False, confidence=0.95)
        return analysis
    # Fix KB-EVERYDAY-PROBLEMS: Alltags-Probleme & Life Hacks für KB_EVERYDAY_PROBLEMS.md
    EVERYDAY_PROBLEMS_PATTERNS = (
        r'(smartphone.*lädt|handy.*lädt|lädt.*nicht|ladeproblem|ladekabel|akku.*problem)',
        r'(laptop.*heiss|laptop.*laut|laptop.*heiß|lüfter.*laut|cpu.*100)',
        r'(wlan.*langsam|internet.*langsam|wifi.*langsam|verbindung.*schlecht)',
        r'(bluetooth.*koppelt|koppelt.*nicht|bluetooth.*problem)',
        r'(fleck.*entfernen|flecken.*entfernen|kaffeefleck|rotweinfleck|fettfleck)',
        r'(abfluss.*verstopft|verstopft.*abfluss|rohr.*verstopft|abfluss.*reinigen)',
        r'(mikrowelle.*reinigen|mikrowelle.*sauber|mikrowelle.*putzen)',
        r'(kühlschrank.*stinkt|kühlschrank.*geruch|kühlschrank.*muffig)',
        r'(kleidung.*trocknen|schnell.*trocknen|nass.*trocknen)',
        r'(schuhe.*trocknen|schuhe.*nass|schuhe.*feucht)',
        r'(reißverschluss.*klemmt|reißverschluss.*hakt|zipper.*klemmt)',
        r'(messer.*schärfen|messer.*scharf|stumpf.*messer)',
        r'(wein.*öffnen|korkenzieher|flasche.*öffnen|weinflasche)',
        r'(eier.*schälen|eier.*pellen|schälen.*eier)',
        r'(knoblauch.*hände|knoblauchgeruch|geruch.*hände)',
        r'(avocado.*reif|avocado.*reifen|avocado.*schneller)',
        r'(einschlafen|nicht.*müde|schlafen.*nicht|schlaf.*problem)',
        r'(sonnenbrand|verbrannt|haut.*rot|sonne.*verbrannt)',
        r'(schnupfen|erkältet|erkältung|krank|husten|kopfschmerzen)',
        r'(stich|insekt|mückenstich|bienenstich|juckt|jucken)',
        r'(batterie.*tot|auto.*springt|starten.*nicht|starthilfe)',
        r'(koffer.*packen|packen.*koffer|effizient.*packen)',
        r'(jetlag|zeitverschiebung|müde.*reise|schlaf.*reise)',
        r'(papierstau|drucker.*stau|drucker.*problem)',
        r'(passwort.*vergessen|einloggen.*nicht|zugang.*vergessen)',
        r'(life.*hack|lifehack|trick|tipp|hilfe|funktioniert.*nicht|geht.*nicht|kaputt)',
    )
    if any(re.search(p, low) for p in EVERYDAY_PROBLEMS_PATTERNS) and not any(s in low for s in ('homelab', 'server', 'docker', 'container', 'service', 'host', 'setup', 'infrastruktur', 'nextcloud', 'traefik', 'proxmox', 'unraid')):
        analysis.update(role='general', task_type='explain', tools=['general_answer'], needs_memory=False, confidence=0.95)
        return analysis
    # Fix KB-HOWTO-EXPLAIN: Alltags-Erklärungen & How-Tos für KB_HOWTO_EXPLAIN.md
    HOWTO_EXPLAIN_PATTERNS = (
        r'(wie sage ich|wie lehne ich|wie gebe ich.*feedback|wie sage ich.*zu spät)',
        r'(wie lehne ich.*ab|höflich.*ablehnen|ablehnen.*einladung)',
        r'(konstruktives feedback|feedback.*geben|kritik.*äußern)',
        r'(wie putze ich|badezimmer.*putzen|putzen.*badezimmer)',
        r'(wie wasche ich.*bettwäsche|bettwäsche.*waschen)',
        r'(wie entferne ich.*kalk|kalk.*entfernen|kalk.*armatur)',
        r'(wie lagere ich.*gemüse|gemüse.*lagern|gemüse.*kühlschrank)',
        r'(wie erstelle ich.*passwort|sicheres passwort|passwort.*erstellen)',
        r'(wie sichere ich.*daten|daten.*sichern|backup.*regel)',
        r'(wie erkenne ich.*phishing|phishing.*erkennen|phishing.*mail)',
        r'(wie gehe ich.*schlafstörung|schlafstörung.*umgehen|schlafhygiene)',
        r'(wie trinke ich.*mehr wasser|mehr wasser.*trinken)',
        r'(wie mache ich.*pause|effektive pause|pomodoro)',
        r'(wie erstelle ich.*haushaltsplan|haushaltsplan.*erstellen|50/30/20)',
        r'(wie sortiere ich.*unterlagen|unterlagen.*sortieren|wes-system)',
        r'(schlafhygiene|einschlafen|schlaf.*tip|besser.*schlafen)',
        r'(trinken.*wasser|wasser.*trinken|mehr.*wasser)',
        r'(haushaltsplan|budget.*plan|finanz.*plan)',
        r'(unterlagen.*sortieren|dokumente.*sortieren|papier.*sortieren)',
    )
    if any(re.search(p, low) for p in HOWTO_EXPLAIN_PATTERNS) and not any(s in low for s in ('homelab', 'server', 'docker', 'container', 'service', 'host', 'setup', 'infrastruktur', 'nextcloud', 'traefik', 'proxmox', 'unraid')):
        analysis.update(role='general', task_type='explain', tools=['general_answer'], needs_memory=False, confidence=0.95)
        return analysis
    # Fix STAT: Personal tracking/stats queries → memory_profile
    # Fix STAT-BOOKS: "wie viele buecher habe ich..." Pattern
    if re.search(r'(wie viel.*(km|kilometer).*ich|\bkm\b.*gelaufen|laufstatistik|wie oft.*gelaufen|'
                 r'schlafzeiten|schlafdauer|wann.*geschlafen|letzte.*schlaf|wie lange.*geschlafen|'
                 r'trainingsstatistik|zeig.*meine.*statistik|meine.*trainings|wie oft.*trainiert|'
                 r'wie viele.*buecher.*(ich|habe|gelesen)|buecher.*(ich|habe).*(gelesen|dieses jahr|letztes jahr)|gelesen.*dieses jahr|'
                 r'meine.*lekture|wie viele.*(ich|habe).*(gelesen|geschrieben|gemacht|getan).*(jahr|monat))', low):
        analysis.update(role='personal', task_type='memory', tools=['memory_profile'], needs_memory=True, confidence=0.89)
        return analysis
    # Fix STAT-PASTTENSE: what did I do/eat last week → memory_profile (not recipe)
    if re.search(r'(was habe ich.*(letzte woche|gestern|letzten|vorige woche|letztem monat).*(gegessen|getrunken|gemacht|getan|gelernt)|'
                 r'was.*ich.*(letzten|letzte woche|gestern).*(gegessen|getrunken|gemacht|getan))', low):
        analysis.update(role='personal', task_type='memory', tools=['memory_profile'], needs_memory=True, confidence=0.89)
        return analysis
    # Fix 1: Personal preference questions -> memory_profile
    # Fix PREF-BOOKS: "was ist mein lieblingsbuch" Pattern
    if re.search(r'(was esse ich|was trinke ich|was hore ich|was lese ich|was schaue ich)', low) and re.search(r'(normalerweise|gewoehnlich|meistens|oft|immer|morgens|abends|taeglich|stets|ueblicherweise|typisch)', low):
        analysis.update(role='personal', task_type='memory', tools=['memory_profile'], needs_memory=True, confidence=0.91)
        return analysis
    if re.search(r'\b(welche art|welche|was fuer|was fur|wie viel|wieviel|welchen|am liebsten)\b', low) and re.search(r'\b(ich|mein|meine|mir)\b', low) and re.search(r'\b(mag|bevorzuge|trinke|esse|hore|hoere|lese|moechte|mochte|vorliebe|gewohnheit|kaffee|tee|musik|buch|buecher|filme|sport|essen|gericht|liebsten|lieber)\b', low):
        analysis.update(role='personal', task_type='memory', tools=['memory_profile'], needs_memory=True, confidence=0.9)
        return analysis
    # Fix 17: Personal location + known places → memory_profile
    if re.search(r"(sitterdorf|thurgau.*erlen|erlen.*thurgau)", low) and not re.search(r"(komme ich|fahrt|strecke|route|bahn|zug|bus|wie.*nach|von.*nach|entfernung|navigation)", low):
        analysis.update(role='personal', task_type='memory', tools=['memory_profile'], needs_memory=True, confidence=0.93)
        return analysis
    if re.search(r'(wo wohne ich|wo lebe ich|meine adresse|mein wohnort|wo wohn|wo leb)', low) and re.search(r'\b(ich|mir|mein|wir)\b', low):
        analysis.update(role='personal', task_type='memory', tools=['memory_profile'], needs_memory=True, confidence=0.92)
        return analysis
    # ── TECH-EXPLAIN INTERCEPT ────────────────────────────────────────────────
    # Tech-Themen bei erklaer/wie funktioniert -> expert_code (nicht general_answer)
    _tech_explain_topics = r'(microservice|event.driven|cqrs|saga.pattern|message.queue|rabbitmq|kafka|kubernetes|k8s|terraform|ansible|grafana|prometheus|design.pattern|dependency.injection|solid.prinzip|clean.architektur|hexagonal|rest.*graphql|graphql.*rest|websocket|grpc|jwt.*flow|oauth.*flow|openid.*flow|ci.cd.*pipeline|gitflow|feature.flag|a.b.testing|blue.green|canary.deploy|serverless|lambda.funktion|nosql.*sql|sharding|indexing.*datenbank|orm.*raw.*sql|async.*await|promise.*callback|threading.*async|race.condition|deadlock|idempotent|eventual.consistency|cap.theorem)'
    if re.search(r'^(erklaer|erklaere|wie funktioniert|wie funk|was ist der unterschied|unterschied zwischen|was sind die vor|vor.*und nachteil)', low) and re.search(_tech_explain_topics, low):
        analysis.update(role='dev', task_type='explain', tools=['qdrant_search', 'expert_code'], confidence=0.89)
        return analysis

    # SKALIER INTERCEPT: Skalierungs- und App-Design-Fragen -> expert_strategy+code
    if re.search(r'(wie skalier|wie.*von.*auf.*user|wie.*app.*skalier|horizontal.*skalier|vertical.*skalier|load.*balanc|wie.*performance.*verbessern.*app|wie.*app.*schneller|bottleneck.*app|database.*skalier)', low) and not any(s in low for s in ('homelab', 'nextcloud', 'emby', 'traefik')):
        analysis.update(role='dev', task_type='explain', tools=['expert_strategy'], confidence=0.88)
        return analysis

    if re.search(r'^(warum|weshalb|wieso|wie entsteht|wie funktioniert|erklaer|erklaere)\b', low) and not any(h in low for h in ('server', 'host', 'docker', 'kasm', 'ssl', 'cert', 'dns', 'traefik', 'nginx', 'container', 'homelab', 'setup', 'infrastruktur', 'authentik', 'tailscale', 'proxmox', 'unraid', 'linux', 'nextcloud', 'immich', 'emby', 'lidarr', 'radarr', 'sonarr', 'audiobookshelf')):
        analysis.update(role='general', task_type='explain', tools=['general_answer'], needs_memory=False, confidence=0.78)
        return analysis

    # Fix DOCKER-MAINT-2: docker maintenance/cleanup → setup_lookup (MUST come before JARVIS patterns)
    if re.search(r'(docker|container)', low) and re.search(r'(aufraeumen|aufraumen|prune|bereinigen|cleanup|clean.*up)', low):
        analysis.update(role='ops', task_type='setup', tools=['setup_lookup'], needs_setup_context=True, confidence=0.94)
        return analysis

    # CONV-EXEC: Container action commands (restart/stop/start) → ops_exec
    if re.search(r'(neu starten|neustart|restart|stoppen|starten|kill|beenden|stop|start).{0,30}(container|docker|service)', low) or re.search(r'(container|docker|service).{0,30}(neu starten|neustart|restart|stoppen|starten)', low):
        analysis.update(role='ops', task_type='action', tools=['ops_exec'], needs_setup_context=False, confidence=0.91)
        return analysis

    # Fix DOCKER-ROUTING-2: Docker/Container Inventar-Queries → setup_lookup (not ops_api)
    # "zeig mir alle docker container", "docker list", "welche container laufen"
    if re.search(r'(zeig mir|zeige mir|zeig|zeige|liste|list|alle|welche).{0,15}(docker|container)', low) and re.search(r'(docker|container|laufen|vorhanden|installiert|hoste)', low):
        analysis.update(role='ops', task_type='status', tools=['setup_lookup'], needs_setup_context=True, confidence=0.94)
        return analysis
    # Fix DOCKER-ROUTING-3: Docker compose/maintenance → setup_lookup
    if re.search(r'(docker|compose).{0,20}(update|upgrade|aktualisieren|durchfuehren|ausfuehren)', low):
        analysis.update(role='ops', task_type='setup', tools=['setup_lookup'], needs_setup_context=True, confidence=0.93)
        return analysis
    # Fix NC-ROUTING: "kannst du [SERVICE] prüfen" → setup_lookup (Inventar/Config, nicht Live-API)
    # WICHTIG: prufen (mit u) und pruefen (mit ue) beide abdecken
    if re.search(r'(kannst du|koenntest du).{0,30}(prufen|prüfen|pruefen|checken|testen|ueberpruefen|ueberprüfen|uberprufen|überprüfen)', low) and any(s in low for s in ('nextcloud', 'immich', 'traefik', 'authentik', 'emby', 'unraid', 'proxmox', 'docker', 'nginx', 'tailscale', 'home assistant', 'homeassistant', 'kasm', 'pihole', 'adguard', 'wireguard', 'sonarr', 'radarr', 'lidarr', 'audiobookshelf')):
        analysis.update(role='ops', task_type='setup', tools=['setup_lookup'], needs_setup_context=True, confidence=0.92)
        return analysis

    # CONV-OPS: Conversational queries with embedded ops commands → ops_api
    # "kannst du mal schauen ob container laufen" / "was läuft auf dem server"
    if re.search(r'(kannst du|koenntest du|magst du|bitte|koennte man|schau mal|prüf mal|pruef mal|check mal|zeig mir|zeige mir|schau ob|pruef ob|check ob)', low) and re.search(r'(container|docker|server|services?|homelab|nextcloud|sonarr|radarr|emby|vaultwarden|pihole|ollama|traefik)', low):
        analysis.update(role='ops', task_type='status', tools=['ops_api'], needs_setup_context=False, confidence=0.90)
        return analysis
    # CONV-RUNNING: "was läuft (gerade|auf)" → ops_api live status
    if re.search(r'(was laueft|was läuft|was laeuft|wer laueft|wer läuft).{0,30}(server|docker|container|homelab|gerade|tower|ubuntu)', low) or re.search(r'(server|homelab|docker).{0,20}(was laueft|was läuft|was laeuft|aktiv|online|running|up|stehen)', low):
        analysis.update(role='ops', task_type='status', tools=['ops_api'], needs_setup_context=False, confidence=0.90)
        return analysis
    # CONV-HOWIS: "wie geht es dem/der [service]" → ops_api live check
    if re.search(r'(wie geht es|wie steht es|wie ist es um).{0,20}(container|docker|nextcloud|sonarr|radarr|emby|vaultwarden|pihole|ollama|traefik|postgresql|service|server)', low):
        analysis.update(role='ops', task_type='status', tools=['ops_api'], needs_setup_context=False, confidence=0.89)
        return analysis

    # CONV-STATUS: "wie läuft/steht es mit" specific services → ops_api
    if re.search(r'(wie laueft|wie läuft|wie steht).{0,30}(nextcloud|sonarr|radarr|emby|vaultwarden|pihole|ollama|traefik|docker|container)', low):
        analysis.update(role='ops', task_type='status', tools=['ops_api'], needs_setup_context=False, confidence=0.89)
        return analysis

    # JARVIS: complex diagnose+fix tasks → ops_deep_analyze directly (it already does infra checks)
    if re.search(r'(unhealthy|kaputt|defekt|fehler|exited|problem).{0,50}(container|service|docker)', low) and \
       re.search(r'(wie|was|fix|reparier|beheb|loesung|was soll|wie kann|wie loes|was tun|schritte|vorgehen)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['ops_deep_analyze'], needs_setup_context=False, confidence=0.94)
        return analysis

    # JARVIS: explicit deep / root-cause analysis → ops_deep_analyze
    if re.search(r'(tiefe.*analyse|deep.*analyse|vollstaendig.*analysier|root.*cause|ursache.*finden|warum.*kaputt|warum.*fehler|detailliert.*analysier|grundursache)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['ops_deep_analyze'], needs_setup_context=False, confidence=0.93)
        return analysis

    # JARVIS: unhealthy container diagnose → ops_deep_analyze for full log analysis
    if re.search(r'(unhealthy|health.*container|container.*health|kaputt.*container|container.*kaputt|defekt.*container)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['ops_deep_analyze'], needs_setup_context=False, confidence=0.95)
        return analysis

    # JARVIS: docker RAM/memory/volume/disk analysis → ops_api
    if re.search(r'(container.*ram|container.*memory|container.*speicher|ram.*container|docker.*volume|docker.*disk|docker.*platz|volume.*groesse|volume.*size|docker.*speicher)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['ops_api'], needs_setup_context=False, confidence=0.93)
        return analysis

    # JARVIS: TLS/cert check → ops_api
    if re.search(r'(tls.*zertifikat|zertifikat.*ablauf|cert.*ablauf|traefik.*tls|traefik.*cert|letsencrypt.*ablauf|acme.*check|https.*cert)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['ops_api'], needs_setup_context=False, confidence=0.93)
        return analysis

    # JARVIS: security audit docker → ops_api
    if re.search(r'(security.*audit|docker.*sicherheit|docker.*audit|container.*sicherheit|privileged.*container|container.*root|sicherheitsaudit)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['ops_api'], needs_setup_context=False, confidence=0.94)
        return analysis

    # JARVIS: pihole / DNS stats → ops_api
    if re.search(r'(pihole|pi-hole|pi hole|dns.*blockiert|blockierte.*domains|dns.*report|dns.*statistik)', low):
        analysis.update(role='ops', task_type='status', tools=['ops_api'], needs_setup_context=False, confidence=0.95)
        return analysis

    # JARVIS: postgresql / database → ops_api
    if re.search(r'(postgresql|postgres.*datenbank|datenbank.*groesse|db.*groesse|postgresql.*check|postgres.*query|datenbank.*report)', low):
        analysis.update(role='ops', task_type='status', tools=['ops_api'], needs_setup_context=False, confidence=0.94)
        return analysis

    # JARVIS: full homelab status report → public_services_health
    if re.search(r'(vollstaendiger.*statusbericht|homelab.*statusbericht|statusbericht.*homelab|homelab.*report|vollstaendiger.*bericht|alle.*services.*status)', low):
        analysis.update(role='ops', task_type='status', tools=['public_services_health'], needs_setup_context=True, confidence=0.93)
        return analysis
    # Fix DOCKER-INVENTORY: docker/container INVENTORY queries → setup_lookup (not ops_api)
    # These are "what do I have" questions, not "what's the current live status"
    if re.search(r'(docker|container)', low) and re.search(r'(zeig mir alle|alle docker|wie viele|wie viel|count|anzahl|liste aller|list all)', low):
        analysis.update(role='ops', task_type='status', tools=['setup_lookup'], needs_setup_context=True, confidence=0.92)
        return analysis
    # Fix 18 (upgraded): docker/container queries with live data → ops_api
    if re.search(r'(docker|container|pod|stack|compose)', low) and re.search(r'(zeig|status|liste|list|alle|laufen|running|starten|stoppen|restart|logs|pruef|check|unhealthy|health|ram|memory|speicher|volume|disk|platz|security|sicherheit|audit|privileged|zertifikat|cert|tls)', low):
        analysis.update(role='ops', task_type='status', tools=['ops_api'], needs_setup_context=False, confidence=0.91)
        return analysis
    # Fix T1: IP-Adresse / Netzwerk-Info Abfragen → setup_lookup
    if re.search(r'(ip adresse|ip-adresse|tailscale ip|tailscale-ip|meine ip|welche ip|zeig.*ip|lautet.*ip|ip.*tailscale)', low):
        analysis.update(role='ops', task_type='status', tools=['setup_lookup'], needs_setup_context=True, confidence=0.87)
        return analysis
    # Fix OPS-PROC: server process/monitoring queries -> setup_lookup
    if re.search(r'(ubuntu|server|host|proxmox|unraid|docker)', low) and re.search(r'(prozesse|laufende services|ps aux|top.*cpu|systemctl list|running.*services|logs.*anzeigen|zeige.*logs|logs.*zeigen)', low):
        analysis.update(role='ops', task_type='status', tools=['setup_lookup'], needs_setup_context=True, confidence=0.86)
        return analysis
    # AMB-SERVER-SLOW: personal + server slow → ops signal dominates
    if re.search(r'(server|proxmox|homelab|vm|container|service).*(langsam|traege|haengt|keine reaktion|hohe last|ueberlastet|cpu last|ram last|speicher last)', low) or        re.search(r'(langsam|traege).*(server|proxmox|homelab|vm|container|service)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['setup_lookup'],
                        needs_setup_context=True, confidence=0.88)
        return analysis

    # Fix OPS-SETUP: homelab config/setup/install tasks → setup_lookup
    if any(s in low for s in ('proxmox', 'traefik', 'nextcloud', 'authentik', 'nginx', 'unraid', 'docker', 'ubuntu', 'tailscale', 'immich', 'homelab', 'sonarr', 'radarr', 'lidarr', 'audiobookshelf', 'emby', 'home assistant', 'homeassistant', 'kasm', 'wireguard', 'fail2ban', 'pihole', 'adguard')) and re.search(r'(einrichten|installieren|konfigurieren|aufsetzen|erstelle.*vm|neue.*vm|reverse proxy.*host|synchronisiere|deploye|setup|upgrade|migrieren|einbinden|integrieren|verbinden|kalibrieren|anpassen|profil.*erstellen|snapshot|auflisten|aufliste|sichern|restore|wiederherstellen|backup.*job|clonen|klonen)', low):
        analysis.update(role='ops', task_type='howto', tools=['setup_lookup'], needs_setup_context=True, confidence=0.87)
        return analysis
    # AMB-SECURITY-DOMINATES: homelab security signal dominates personal request
    if re.search(r'(homelab|server|services).*(sicher|security|absichern|geschuetzt|firewall|angriff)', low) or        re.search(r'(sicher genug|ausreichend sicher|gut geschuetzt|sicherheit.*homelab|homelab.*sicherheit)', low):
        analysis.update(role='ops', task_type='setup', tools=['setup_lookup'],
                        needs_setup_context=True, confidence=0.88)
        return analysis

        # SEC-INCIDENT: suspicious requests, brute force, intrusion detection
    if re.search(r'(komische|verdaechtige|seltsame|unbekannte|fremde).*(requests?|anfragen|ips?|zugriffe|verbindungen)', low) or        re.search(r'(chinesische|russische|unbekannte).*(ips?|adresse|anfragen)|ip.*(china|russland|unknown)', low) or        re.search(r'(\d+)\s*mal.*(erfolglos|fehlgeschlagen|versucht|failed).*(einlog|einzulog|anmeld|zugriff|login|loggen)', low) or        re.search(r'(brute.?force|einbruchsversuch|hack.{0,20}versuch|angriff|intruder|eindringling)', low) or        re.search(r'(moeglicher angriff|möglicher angriff|unter angriff|wird angegriffen|jemand.*(versucht|probiert).*(einlog|hack|zugriff))', low) or        re.search(r'(viele.*(401|403|4\d\d).*(unbekannt|fremd|verdaechtig)|log.*verdaechtig|logs.*(angriff|hack))', low):
        analysis.update(role='ops', task_type='diagnose', tools=['setup_lookup'],
                        needs_setup_context=True, confidence=0.91)
        return analysis

    # Fix SEC-HARDEN: security hardening queries → setup_lookup
    if re.search(r'(server|ssh|linux|ubuntu|proxmox|host|system|container|homelab).*(absichern|sichern|haerten|hartung|haertung|hardening|absicherung|security)', low) or re.search(r'(ssh|system|server|linux).*(hartung|haertung|haerten)\b', low) or re.search(r'\b(ssh|fail2ban|firewall|ufw|iptables).*(einrichten|konfigurieren?|absichern|aufsetzen)', low) or re.search(r'\b(konfiguriere?|einrichte?|richte.{0,10}ein).{0,20}\b(fail2ban|ufw|iptables|firewall|ssh)\b', low) or re.search(r'\b(fail2ban|ufw|iptables|firewall)\b.{0,80}\b(sperren|blockieren|bannen|gesperrt|so dass|damit)', low):
        analysis.update(role='ops', task_type='setup', tools=['setup_lookup'], needs_setup_context=True, confidence=0.87)
        return analysis
    # SET-INTEGRATION: "integriere X mit Y", n8n automation, webhooks
    if re.search(r'(integriere?|verbinde?|koppel?|synchro).{0,20}(home.?assistant|emby|nextcloud|sonarr|radarr|n8n|telegram|slack|webhook)', low) or        re.search(r'(home.?assistant|emby|nextcloud|n8n).{0,30}(integriere?|verbinde?|koppel?)', low) or        re.search(r'(n8n.{0,30}(webhook|trigger|workflow|automatisier|notification|benachrichtig))', low) or        re.search(r'(automation.{0,30}(homelab|services)|homelab.{0,30}automation)', low):
        analysis.update(role='ops', task_type='setup', tools=['setup_lookup'],
                        needs_setup_context=True, confidence=0.88)
        return analysis

    # Fix DOCK-MAINT: docker maintenance tasks → setup_lookup
    if re.search(r'\bdocker\b', low) and re.search(r'(volumes?.*aufraeumen|aufraeumen.*volumes?|prune|bereinigen|compose.*update|compose.*upgrade|alle.*container.*aktualisier|container.*log|logs.*container|images.*aufraeumen)', low):
        analysis.update(role='ops', task_type='setup', tools=['setup_lookup'], needs_setup_context=True, confidence=0.87)
        return analysis
    # CAS-STROMAUSFALL: nach stromausfall/neustart homelab nicht hochgekommen
    if re.search(r'(stromausfall|stromunterbrechung|nach dem neustart|nach neustart|nach.*(reboot|restart)).*(homelab|server|services|vms?|container)', low) or        re.search(r'(homelab|server|services).*(nicht.*(hochgekommen|gestartet|oben|erreichbar)|down|ausgefallen).*(stromausfall|neustart|reboot)', low) or        re.search(r'(stromausfall.*(homelab|server)|homelab.*(stromausfall|ausgefallen|nicht.*hoch))', low):
        analysis.update(role='ops', task_type='diagnose', tools=['setup_lookup'],
                        needs_setup_context=True, confidence=0.90)
        return analysis

    # Fix ERR: Raw error message input → setup_lookup
    if re.search(r'(econnrefused|connection refused|\[emerg\]|fatal.*failed|permission denied.*publickey|port.*allocated|address.*already.*in.*use|bind\(\).*failed|error response from daemon)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['setup_lookup'], needs_setup_context=True, confidence=0.87)
        return analysis
    # Fix OLLAMA: ollama/LLM server queries → setup_lookup
    if re.search(r'\bollama\b', low) or (re.search(r'\bllm\b|\bmodell\b', low) and re.search(r'(mac.?studio|mac.?mini|server|lauft|startet|laeuft|welches)', low)):
        analysis.update(role='ops', task_type='setup', tools=['setup_lookup'], needs_setup_context=True, confidence=0.87)
        return analysis
    # Fix OPS-CRASH: generic homelab/server crash → setup_lookup
    if re.search(r'(homelab|server|host|alle.*services|gesamte.*infrastruktur)', low) and re.search(r'(abgestuerzt|abgestuerzt|nicht mehr erreichbar|komplett down|alles down|crash|ausgefallen|ausgefallen)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['setup_lookup'], needs_setup_context=True, confidence=0.89)
        return analysis
    # Fix MED-1: sonarr/radarr/lidarr content/indexer issues → setup_lookup
    if re.search(r'\b(sonarr|radarr|lidarr|audiobookshelf)\b', low) and re.search(r'(findet|steckt|haengt|fehler|problem|indexer|episod|serie|film|qualitaet|profil|download|hinzufuegen|nicht|konfigur)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['setup_lookup'], needs_setup_context=True, confidence=0.87)
        return analysis
    # Fix 19: service status queries → setup_lookup
    if re.search(r'(status meiner|status der|meine.*status|services.*status|dienste.*status|welche.*laufen|alle.*services)', low) and not re.search(r'(licht|lampe|beleuchtung)', low):
        analysis.update(role='ops', task_type='status', tools=['setup_lookup'], needs_setup_context=True, confidence=0.87)
        return analysis
    # Fix NET: network diagnostic queries → setup_lookup
    if re.search(r'(\bport\b.*(nicht erreichbar|geschlossen|blockiert|offen|listen|filtered)|'
                 r'\bping\b.*(fehl|timeout|keine antwort|schlaegt|schlagt)|'
                 r'\btraceroute\b|\bdns\b.*(funktioniert nicht|aufloesung|resolution|fehl|problem)|'
                 r'\bnslookup\b|\bdig\b.*(domain|dns)|'
                 r'netzwerk.*problem|netzwerkfehler|verbindung.*timeout|connection.*timeout)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['setup_lookup'], needs_setup_context=True, confidence=0.87)
        return analysis
    # Fix SSL: SSL/TLS/certbot issues → setup_lookup
    if re.search(r'(ssl.*(zertifikat|cert|ablaufen|abgelaufen|fehler|ungueltig|invalid|handshake)|'
                 r'zertifikat.*(abgelaufen|ablaufen|ungueltig|fehler|erneuern)|'
                 r'\bcertbot\b|lets.?encrypt|letsencrypt|\bacme\b)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['setup_lookup'], needs_setup_context=True, confidence=0.87)
        return analysis
    # Fix 20: homelab service fault/check → setup_lookup
    if any(s in low for s in ('nextcloud', 'immich', 'traefik', 'authentik', 'emby', 'lidarr', 'radarr', 'sonarr', 'audiobookshelf', 'unraid', 'proxmox', 'docker', 'nginx', 'tailscale', 'home assistant', 'homeassistant', 'kasm', 'pihole', 'adguard', 'wireguard')) and re.search(r'(nicht|problem|fehler|kaputt|down|error|pruef|prufen|check|zeig|status|warum|erreichbar|langsam|performance|ram|cpu|speicher|bricht|abbricht|haengt|haengt sich|crash|absturz|abgestuerzt|friert ein|not working|broken|offline|stuck|failed|issue|sensor.*offline|offline.*sensor|schlaegt fehl|schlagt fehl|funktioniert nicht|sync.*fehl|fehl.*sync|ldap.*fehl|fehl.*ldap)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['setup_lookup'], needs_setup_context=True, confidence=0.88)
        return analysis
    # Fix HA: Home Assistant queries → setup_lookup (entitaten, dashboard, automatisierung)
    if re.search(r'\bhome.?assistant\b|homeassistant', low) and not re.search(r'(\blicht\b|\blampe\b|beleuchtung|schalte.*licht|licht.*ein|licht.*aus)', low):
        analysis.update(role='ops', task_type='setup', tools=['setup_lookup'], needs_setup_context=True, confidence=0.87)
        return analysis
    # PERS-PLAN: personal plans (nutrition, fitness, vacation) → personal_assist
    if re.search(r'(ernaehrungsplan|ernaehrung.*plan|diaet.*plan|kalorien.*plan|mahlzeiten.*plan|essensplan)', low) or        re.search(r'(fitness.*plan|trainingsplan|sport.*plan|lauf.*plan|workout.*plan)', low) or        re.search(r'(4.?wochen.*(ernaehrung|abnehmen|sport|training)|wochen.*plan.*(essen|ernaehrung|sport))', low) or        re.search(r'(ich will.{0,30}abnehmen|abnehm.*plan|gewicht.*verlieren|gewicht.*reduzier)', low):
        analysis.update(role='personal', task_type='assist', tools=['personal_assist'],
                        needs_memory=True, confidence=0.90)
        return analysis

    # PERS-WRITE: career writing (Bewerbung, Lebenslauf) → personal_assist
    if re.search(r'(bewerbung|lebenslauf|anschreiben|motivationsschreiben|cover.?letter|\bcv\b|resume)', low) or        re.search(r'(schreib|erstell).{0,30}(bewerbung|lebenslauf|anschreiben)', low):
        analysis.update(role='personal', task_type='assist', tools=['personal_assist'],
                        needs_memory=True, confidence=0.90)
        return analysis

    # PERS-TRAVEL: travel planning with specific destination → web_research
    if re.search(r'(reiseplan|reiseroute|reisefuehrer|reise.*planen).{0,60}(japan|usa|thailand|europa|italien|spanien|frankreich|portugal|griechenland|tuerkei|bali|dubai|kanada|australien|neuseeland|england|irland|norwegen|schweden|island)', low) or        re.search(r'(reise|urlaub|trip).{0,30}(2|3|4|5|6|7|8|9|10|14|21)\s*(wochen|tage|nächte|naechte).{0,60}(japan|usa|thailand|europa)', low) or        re.search(r'(hotels?.{0,30}sehenswuerdigkeiten|sehenswuerdigkeiten.{0,30}hotels?).{0,60}(japan|usa|thailand|europa|italien|spanien)', low):
        analysis.update(role='personal', task_type='research', tools=['web_research'],
                        needs_memory=False, confidence=0.90)
        return analysis

    if re.search(r'(schreibe|erstelle|baue|implementiere|programmiere|deploy)', low) and re.search(r'(tool|app|skript|script|api|programm|code|python|node|bash|kasm)', low):
        analysis.update(role='dev', task_type='build', tools=['dev_build'], confidence=0.92)
        return analysis
    # ARCH: homelab architecture planning, backup-konzept, monitoring-stack, HA
    # ARCH-STRATEGY: 'wie gehe ich vor + homelab projekt' -> expert_strategy
    if re.search(r'(wie gehe ich vor|was ist der beste ansatz|wie am besten vorgehen|wie.*projekt.*planen|wie.*planen.*projekt)', low) and re.search(r'(homelab.?projekt|neues.*projekt|projekt.*aufbauen|projekt.*strukturier|projekt.*priorisier)', low):
        analysis.update(role='research', task_type='strategy', tools=['expert_strategy'], confidence=0.89)
        return analysis
    if re.search(r'(backup.?(konzept|strategie|plan|lösung|loesung)|backup.*erstell|vollstaendiges backup|komplettes backup)', low) or        re.search(r'(monitoring.?stack|prometheus.*grafana|grafana.*prometheus|alertmanager|nagios.*homelab|zabbix.*homelab)', low) or        re.search(r'(hochverfuegbarkeit|high.?availab|cluster.*(proxmox|nextcloud|homelab)|proxmox.*cluster|failover.*homelab)', low) or        re.search(r'(zweiten?.*(proxmox|node|server).*hinzufueg|neuen?.*(proxmox|node).*hinzufueg|proxmox.*node.*migr)', low) or        re.search(r'(homelab.*(aufbauen|planen|konzept|architektur|design|struktur|sicherer|absichern)|wie.*(homelab|server).*(aufbauen|planen))', low) or        re.search(r'(backup.*konzept|sicherungskonzept|datensicherung.*konzept|disaster.*recovery)', low):
        analysis.update(role='ops', task_type='setup', tools=['setup_lookup'],
                        needs_setup_context=True, confidence=0.88)
        return analysis

    # Fix PLAN: day planning and calendar actions → personal_assist
    if re.search(r'(tagesplan|tages.*plan|plan.*fuer.*heute|was.*heute.*plane|mein.*tag.*organisier)', low):
        analysis.update(role='personal', task_type='howto', tools=['personal_assist'], needs_memory=True, confidence=0.88)
        return analysis
    if re.search(r'(fuge.*kalender|kalender.*eintrag|termin.*kalender|kalender.*termin|kalender.*hinzufuegen|trage.*ein|fuege.*termin)', low):
        analysis.update(role='personal', task_type='write', tools=['personal_assist'], needs_memory=True, confidence=0.88)
        return analysis
    if re.search(r'(woche|wochenplanung|ueberblick|überblick|dranbleib|struktur)', low) and re.search(r'(ich|meine|mein|plane|planen|organisier|verlier|ueberblick|überblick)', low):
        analysis.update(role='personal', task_type='howto', tools=['personal_assist'], needs_memory=True, confidence=0.93)
        return analysis
    # Fix PROD-1: Produktivität/Wochenplanung mit "wie organisiere ich" Pattern
    if re.search(r'(wie|was).{0,10}(organisier|plane).{0,20}(woche|wochen|meine woche|meinen tag)', low) and re.search(r'(pragmatisch|ueberblick|überblick|struktur|dranbleib|verlier|fokus|produktiv)', low):
        analysis.update(role='personal', task_type='howto', tools=['personal_assist'], needs_memory=True, confidence=0.94)
        return analysis
    if re.search(r'(mail|email|e-mail|\bnachricht\b|erinnere|einkauf|einkaufsliste|todo|to-do|packliste|verfasse|verfass|dankesbrief|entschuldig|geburtstagsbrief)', low):
        analysis.update(role='personal', task_type='write', tools=['personal_assist'], needs_memory=True, confidence=0.9)
        return analysis
    # PERSONAL-MESSAGE: short everyday drafts should not escalate to expert_write
    if re.search(r'(kurze[nr]?|kurzen|kurze|kleine[nr]?|kleine|knappe[nr]?|knappe|kurz)\s+(entwurf|absage|antwort|nachricht)', low) or \
       (re.search(r'(absage|terminverschieb|treffen absagen|termin absagen)', low) and re.search(r'(schreib|entwurf|kurz|kurzen|kurze)', low)):
        analysis.update(role='personal', task_type='write', tools=['personal_assist'], needs_memory=True, confidence=0.93)
        return analysis
    # TOOL-IDEAS: brainstorming for internal tools is not personal assistance
    if re.search(r'(idee[n]?|vorschlaege|vorschläge|optionen)', low) and re.search(r'(internes? tool|zugriffspruefung|zugriffsprüfung|internes? werkzeug)', low):
        analysis.update(role='general', task_type='explain', tools=['general_answer'], needs_memory=False, confidence=0.92)
        return analysis
    # Fix NAV2: Navigation / Reisefragen -> web_research
    if re.search(r'(wie komme ich.*nach|fahrt von.*nach|strecke von.*nach|route.*nach|zug.*nach|bus.*nach|wie lange.*nach|entfernung.*nach|anreise|abfahrt.*nach)', low):
        analysis.update(role='research', task_type='explain', tools=['web_research'], needs_web_research=True, confidence=0.87)
        return analysis
    # Fix N2: News/Nachrichten → web_research
    if re.search(r'(nachrichten|news|schlagzeilen|headline|meldungen)', low) and re.search(r'(aktuell|heute|neueste|latest|was sind die|letzte)', low):
        analysis.update(role='research', task_type='explain', tools=['web_research'], needs_web_research=True, confidence=0.86)
        return analysis
    # Fix SHOP: product/hardware recommendations → web_research
    if re.search(r'(empfiehl mir|empfehle mir|was ist (ein )?guter|welcher.*ist gut|welche.*ist gut|bestes.*fuer|beste.*fuer|gutes.*fuer|guten.*fuer)', low) and re.search(r'(monitor|festplatte|ssd|hdd|webcam|tastatur|maus|drucker|router|switch|kabel|nas|raspberry|grafikkarte|cpu|prozessor|ram|netzteil|gehaeuse|laptop|notebook|tablet|kopfhoerer|lautsprecher|kamera|mikrofon)', low):
        analysis.update(role='research', task_type='compare', tools=['web_research'], needs_web_research=True, confidence=0.84)
        return analysis
    # Fix W1: Wetter/Forecast → web_research (braucht aktuelle Daten)
    if re.search(r'(wetter|temperatur|regen|schnee|sonne|wind|forecast|niederschlag|grad.*celsius|celsius.*grad|wettervorhersage|wie wird.*morgen|wie ist.*wetter)', low):
        analysis.update(role='research', task_type='explain', tools=['web_research'], needs_web_research=True, confidence=0.88)
        return analysis
    # Fix POD: podcast/audiobook discovery → web_research
    if re.search(r'\bpodcast', low) or (re.search(r'\bhoerbuecher?\b|\baudiobooks?\b', low) and re.search(r'(finden|empfehle?|kostenlos|beste?|wo.*kann|listen|plattform)', low)):
        analysis.update(role='research', task_type='lookup', tools=['web_research'], confidence=0.87)
        return analysis
    if re.search(r'(aktuell|neueste|heute|latest)', low) and not re.search(r'(rezept|abendessen|mittagessen|fruehstueck|kochen|backen|essen|mahlzeit|gericht)', low) and not any(s in low for s in ('nextcloud', 'immich', 'traefik', 'authentik', 'emby', 'unraid', 'proxmox', 'docker', 'nginx', 'tailscale', 'server', 'ram', 'cpu', 'disk', 'speicher', 'container', 'homelab')) and not re.search(r'\b(schreibe?|verfasse?|erstelle?|formuliere?|entschuldig|dankesbrief|brief|nachricht schreiben)\b', low):
        analysis.update(role='research', task_type='explain', tools=['web_research', 'expert_write'], needs_web_research=True, confidence=0.75)
        return analysis

    # OPS-EXEC: execute commands on hosts
    if re.search(r'(fuehre?\s+aus|execute|lauf\s+aus|fuhre?\s+aus)', low) or \
       (re.search(r'(teste?\s+ob|teste?\s+den|pruefe?\s+ob|pruefe?\s+den|ueberpruefe?)', low) and any(s in low for s in SERVICE_HINTS)):
        analysis.update(role='ops', task_type='action', tools=['ops_exec'], needs_setup_context=True, confidence=0.87)
        return analysis

    # OPS-INSTALL: install/configure software
    if re.search(r'(installiere?|setup\s+\w|richte\s+ein|aufsetzen|deploye?)', low) and \
       not re.search(r'(wie\s+(installiere|richte|setze|deploye)|anleitung|erklaer)', low):
        analysis.update(role='ops', task_type='action', tools=['ops_install'], needs_setup_context=True, confidence=0.87)
        return analysis

    # OPS-API: query homelab APIs
    if re.search(r'(api\s+(abfrage|query|status)|zeig\s+mir\s+(alle\s+)?(container|entities|services|benutzer))', low) or \
       re.search(r'(docker\s+(ps|stats|images)|liste\s+(alle\s+)?(container|images|volumes))', low):
        analysis.update(role='ops', task_type='final', tools=['ops_api'], needs_setup_context=True, confidence=0.88)
        return analysis

    # CAUSAL: warum/wieso/zusammenhang/ursache/seit/nach dem → deep causal analysis
    if re.search(r'\b(warum|wieso|weshalb|reason|ursache|zusammenhang|root.?cause)\b', low) and \
       SERVICE_HINTS_PATTERN.search(low):
        analysis.update(role='ops', task_type='diagnose', tools=['ops_deep_analyze'],
                        needs_setup_context=True, confidence=0.90)
        return analysis

    if re.search(r'\b(seit|after|nach dem|nach dem update|nach dem neustart|nach dem stromausfall)\b', low) and \
       re.search(r'(nicht mehr|funktioniert nicht|geht nicht|down|offline|error|fehler|kaputt|problem)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['ops_deep_analyze'],
                        needs_setup_context=True, confidence=0.90)
        return analysis

    if re.search(r'(mehrere services|alle services|viele services|ploetzlich.*nicht|gleichzeitig.*nicht)', low):
        analysis.update(role='ops', task_type='diagnose', tools=['ops_deep_analyze'],
                        needs_setup_context=True, confidence=0.89)
        return analysis

    # OPS-DEEP: complex multi-service analysis
    if re.search(r'(komplette?\s+analyse|tiefe?\s+analyse|vollstaendige?\s+diagnose|ursachenanalyse)', low) or \
       (re.search(r'(analysiere?\s+(alle|komplett|alles)|wochenbericht|monatsbericht)', low) and any(s in low for s in SERVICE_HINTS)):
        analysis.update(role='ops', task_type='diagnose', tools=['ops_deep_analyze'], needs_setup_context=True, confidence=0.88)
        return analysis

    # Fix KB-ENTERTAINMENT: Entertainment, Gaming, Filme & Serien für KB_ENTERTAINMENT
    # Muss NACH personal/memory Patterns kommen, aber VOR dem Fallback
    ENTERTAINMENT_KB_PATTERNS = (
        r'\b(elden ring|witcher|fortnite|minecraft|zelda|mario|pokemon)\b',
        r'\b(playstation|xbox|switch|steam|epic games|gog|battle\.net)\b',
        r'\b(netflix|disney\+|hbo|prime video|apple tv|paramount|peacock)\b',
        r'\b(spotify|apple music|tidal|deezer|youtube music)\b',
        r'\b(twitch|youtube|streamer|lets play|walkthrough|gameplay)\b',
        r'\b(mmorpg|rpg|fps|moba|battle royale|open world|indie game)\b',
        r'\b(gpu|grafikkarte|rtx 40|rx 7\d{3}|gaming pc|144hz|240hz)\b',
        r'(was.*spielen|spiel.*empfehl|gutes.*spiel|bestes.*spiel|spiel.*tip)',
        r'(was.*schauen|film.*empfehl|serie.*empfehl|guter.*film|beste.*serie)',
        r'(was.*hören|musik.*empfehl|gute.*musik|playlist.*tip|song.*empfehl)',
        r'(binge.*watch|staffel.*empfehl|folge.*empfehl|streaming.*tip)',
    )
    if any(re.search(p, low) for p in ENTERTAINMENT_KB_PATTERNS):
        analysis.update(role='general', task_type='explain', tools=['general_answer'], needs_memory=False, confidence=0.95)
        return analysis
    # Fix KB-HISTORY: Geschichte & Kultur Fragen für KB_HISTORY_CULTURE
    # Muss NACH allen Setup/OPS Patterns kommen, aber VOR dem Fallback
    HISTORY_KB_PATTERNS = (
        r'^(wann war|wer war|was war|wie war|wann lebte|wer lebte|wann starb|wer starb)\b',
        r'^(in welchem jahr|in welchem jahrhundert|in welcher epoche)\b',
        r'^(erster weltkrieg|zweiter weltkrieg|kalter krieg|französische revolution|industrielle revolution)\b',
        r'^(altes ägypten|römisches reich|antikes griechenland|mittelalter|renaissance)\b',
        r'^(karl der große|napoleon|luther|hitler|caesar|augustus|cleopatra)\b',
        r'^(pyramiden|kolosseum|chinesische mauer|eiffelturm|taj mahal)\b',
        r'^(leonardo da vinci|michelangelo|mozart|beethoven|bach|picasso)\b',
        r'^(sokrates|platon|aristoteles|philosophie|demokratie)\b',
        r'^(religion|christentum|islam|judentum|buddhismus|hinduismus)\b',
        r'^(bibel|koran|tora|torah)\b',
        r'^(v\.chr\.|n\.chr\.|vor christus|nach christus)\b',
    )
    if any(re.search(p, low) for p in HISTORY_KB_PATTERNS):
        analysis.update(role='general', task_type='explain', tools=['general_answer'], needs_memory=False, confidence=0.95)
        return analysis

    # Fix KB-SMALLTALK: Smalltalk, Gesprächsthemen, Alltagsfragen für KB_SMALLTALK
    # Muss VOR dem Fallback kommen, damit Begrüßungen/Motivation nicht ungrounded landen
    SMALLTALK_KB_PATTERNS = (
        r'^(wie geht|wie gehts|wie geht es dir|was machst du|was gibt es neues|was gibts neues)\b',
        r'^(erzähl mir|erzähl was|erzähl einen witz|erzähl mir was|erzähl mir einen witz)\b',
        r'^(langweilig|mir ist langweilig|unterhaltung|gespräch|plaudern|quatschen)\b',
        r'^(guten morgen|guten abend|gute nacht|hallo|hi|hey)\b',
        r'^(danke|vielen dank|danke dir|danke schön|danke schoen)\b',
        r'^(motivation|inspiration|aufmunterung|ermutigung|gib mir kraft)\b',
        r'^(tipp|ratschlag|empfehlung|was würdest du tun|was wuerdest du tun)\b',
        r'^(meinung|was denkst du|wie siehst du das|was sagst du dazu)\b',
        r'^(entschuldigung|sorry|verzeihung|entschuldige)\b',
        r'^(bis später|bis bald|tschüss|tschuesss|ciao|auf wiedersehen)\b',
    )
    if any(re.search(p, low) for p in SMALLTALK_KB_PATTERNS):
        analysis.update(role='general', task_type='explain', tools=['general_answer'], needs_memory=False, confidence=0.95)
        return analysis

    # Fix KB-TECH-SUPPORT: Technik-Support & DIY Fragen für KB_TECH_SUPPORT.md
    # WICHTIG: Muss VOR dem Fallback kommen, damit Tech-Probleme nicht ungrounded landen
    TECH_SUPPORT_PATTERNS = (
        r'\b(smartphone|handy|iphone|android|tablet|ipad)\b.*\b(lädt nicht|lädt nicht|akku|bildschirm|display|kaputt|defekt|problem)\b',
        r'\b(laptop|computer|pc|windows|mac|macbook)\b.*\b(langsam|hängt|hängt|friert|bluescreen|neustart|startet nicht)\b',
        r'\b(wlan|wifi|internet|router)\b.*\b(funktioniert nicht|geht nicht|langsam|verbindung|problem)\b',
        r'\b(drucker|scanner)\b.*\b(funktioniert nicht|geht nicht|verbindet|problem|fehler)\b',
        r'\b(fernseher|tv|fernbedienung|streaming|netflix)\b.*\b(funktioniert nicht|geht nicht|bild|ton|problem)\b',
        r'\b(usb|hdmi|kabel|anschluss)\b.*\b(funktioniert nicht|geht nicht|erkannt|problem)\b',
        r'\b(virus|malware|phishing|sicherheit|passwort vergessen)\b',
        r'\b(app|programm|software)\b.*\b(stürzt|ab|hängt|startet nicht|fehler)\b',
        r'\b(datei|ordner)\b.*\b(löschen|löschen|nicht öffnen|nicht öffnen|zugriff)\b',
        r'\b(windows|update|aktualisieren)\b.*\b(hängt|hängt|fehler|problem)\b',
        r'\b(waschmaschine|staubsauger|kühlschrank)\b.*\b(funktioniert nicht|geht nicht|problem|fehler|laut)\b',
        r'\b(diy|reparieren|fixen|hilfe|support)\b.*\b(technik|gerät|problem)\b',
    )
    if any(re.search(p, low) for p in TECH_SUPPORT_PATTERNS) and not any(s in low for s in ('homelab', 'server', 'docker', 'container', 'service', 'host', 'setup', 'infrastruktur', 'nextcloud', 'traefik', 'proxmox', 'unraid')):
        analysis.update(role='general', task_type='explain', tools=['general_answer'], needs_memory=False, confidence=0.95)
        return analysis

    # ── IMPLICIT DOMAIN ROUTING (Thema, nicht Schluesselwort) ──────────────────
    # Kein "schreib einen Artikel" noetig — das Thema bestimmt den Skill.

    # IMPLICIT-CODE: Tech-Konzepte erklaeren / vergleichen / implementieren
    _tech_topics = (
        r'(microservice|kubernetes|k8s|docker.compose|terraform|ansible|'
        r'rest.api|graphql|grpc|websocket|message.queue|rabbitmq|kafka|'
        r'sql.*nosql|nosql.*sql|relational.*datenbank|datenbank.*design|'
        r'design.pattern|entwurfsmuster|solid.*prinzip|dependency.*injection|'
        r'event.driven|cqrs|saga.*pattern|clean.*architektur|hexagonal|'
        r'ci.*cd.*pipeline|devops.*praxis|git.*workflow|branching.*modell|'
        r'algorithmus|komplexitaet|big.o|sortier|graphen.*algorithmus|'
        r'machine.*learning.*impl|neural.*network.*bau|embedding.*erstell|'
        r'api.*rate.limit|auth.*token.*flow|oauth.*impl|jwt.*erstell)'
    )
    _explain_verbs = r'(erklaer|erklaere|was ist|wie funk|unterschied|vergleich|vor.*nach|wann.*nutzen|wann.*verwenden|wie.*besser|welches.*besser|empfehlung|wie.*impl|wie.*umsetz|zeig.*wie|beispiel.*fuer)'
    if re.search(_tech_topics, low) and re.search(_explain_verbs, low) and not any(s in low for s in SERVICE_HINTS):
        analysis.update(role='dev', task_type='explain', tools=['qdrant_search', 'expert_code'], confidence=0.87)
        return analysis

    # IMPLICIT-WRITE: Kommunikationsaufgaben ohne "schreib" Keyword
    _comm_types = r'(\bemail\b|\bbrief\b|anschreiben|bewerbung|motivationsschreiben|\bpitch\b|proposal|\bpraesentation\b|\bpresentation\b|executive.*summary|zusammenfassung.*fuer|bericht.*fuer|protokoll.*erstell|minutes.*of|meeting.*notes|stellungnahme|offizielle.*mitteilung|pressemitteilung|newsletter|\bslogan\b|produktbeschreibung|landing.*page.*text)'
    _comm_triggers = r'(kannst du|hilf mir|erstelle|formulier|schreib|verfass|mach mir|ich brauche|benotige|erstell mir|bitte.*erstell|wie.*formulier|wie.*sag ich|gib mir.*entwurf)'
    if re.search(_comm_types, low) and re.search(_comm_triggers, low) and not any(s in low for s in ('homelab', 'server', 'docker', 'code', 'skript')):
        analysis.update(role='research', task_type='write', tools=['expert_write'], confidence=0.89)
        return analysis

    # IMPLICIT-SYNTH: Komplexe Synthesis-Fragen → Web-Recherche + Expert-Schreiben
    _synth_patterns = r'(was.*beste.*2\d{3}|welche.*empfehlung.*2\d{3}|wie ist der stand|aktueller stand von|neueste.*entwicklung|wohin.*entwickelt sich|wie.*zukunft|state of the art|was denken experten|expertenmeinung zu|marktfuehrer|markt.*analyse|wettbewerbsvergleich|vor.*nachteile.*von.*und.*von)'
    if re.search(_synth_patterns, low) and not any(s in low for s in SERVICE_HINTS):
        analysis.update(role='research', task_type='explain', tools=['web_research', 'expert_write'], needs_web_research=True, confidence=0.86)
        return analysis

    # IMPLICIT-STRATEGY: Planungs- und Vorgehen-Fragen ohne explizites "OKR/SWOT"
    _plan_patterns = r'(wie.*aufbauen|wie gehe ich vor|schritt.*fuer.*schritt.*vorgehen|wie.*skalier|best.*approach.*fuer|bestes.*vorgehen|wie.*strukturier|wie.*priorisier|was.*zuerst|in welcher reihenfolge.*vorgehen|langfristig.*planen|strategie.*entwickeln|roadmap.*fuer|plan.*fuer.*naechsten|wie.*team.*aufstell|ressourcen.*einsetzen)'
    if re.search(_plan_patterns, low) and not any(s in low for s in ('kasm', 'emby', 'sonos', 'lidarr', 'radarr', 'sonarr', 'traefik', 'nextcloud', 'immich', 'authentik', 'ldap')) and not re.search(r'(diagnos|kaputt|fehler|defekt|nicht.*laueft|nicht.*laeuft|nicht.*erreichbar)', low):
        analysis.update(role='research', task_type='build', tools=['expert_strategy'], confidence=0.85)
        return analysis

    # IMPLICIT-EDIT: Text liegt vor und soll verbessert werden (ohne "lektoriere")
    # Erkennung: langer Text + Verbesserungswunsch
    _edit_triggers = r'(klingt.*gut|klingt das gut|ist das gut formuliert|passt das so|kannst du.*verbessern|kannst du.*anpassen|kannst du.*ueberarbeiten|bitte.*verbessern|bitte.*anpassen|mach.*besser|mach.*professioneller|mach.*klarer|zu lang|zu kurz|zu foermlich|zu informell|andere formulierung|anders formulieren)'
    if re.search(_edit_triggers, low) and len(low) > 20 and not any(s in low for s in ('homelab', 'server', 'docker', 'code', 'skript')):
        analysis.update(role='general', task_type='write', tools=['expert_edit'], confidence=0.87)
        return analysis

    # ── EXPERT DOMAINS ────────────────────────────────────────────────────────
    # EXPERT-WRITE: Artikel, Blog, Journalismus, kreatives Schreiben, Storytelling
    if re.search(r'(schreib.{0,20}(artikel|blog|essay|bericht|kolumne|reportage|feature|story|geschichte|novelle|kurzgeschichte|prolog|epilog|gedicht|rede|speech|pitch|biographie|profil|portrait|caption|post|thread)|'
                 r'verfasse.{0,20}(artikel|text|bericht|email|brief|nachricht|anschreiben|proposal|pitch|stellungnahme)|'
                 r'erstell.{0,20}(artikel|blog.*post|newsletter|pressemitteilung|content|copy|slogan|headline|landing.*page|produktbeschreibung)|'
                 r'schreib.{0,20}(mir|uns|einen|eine|guten|spannenden|interessanten|professionellen|kreativen|packenden|ueberzeugenden)|'
                 r'ich brauche.{0,30}(artikel|text|story|email|anschreiben|pressemitteilung|newsletter|pitch|proposal)|'
                 r'ghostwrite|narrativ|storytelling|lede|inverted pyramid|hook.*fuer.*text|teaser.*fuer)', low) and not any(s in low for s in ('homelab', 'docker', 'container', 'code', 'skript', 'script', 'programm', 'funktion', 'klasse')):
        analysis.update(role='research', task_type='write', tools=['expert_write'], confidence=0.92)
        return analysis

    # EXPERT-CODE: Code-Architektur, Code-Review, Senior-Dev-Aufgaben
    if re.search(r'(code.*review|review.*code|code.*analysier|analysier.*code|'
                 r'architektur.*entscheiden|technische.*schulden|tech.*debt|refactor|refaktorier|'
                 r'design.*pattern|entwurfsmuster|solid.*prinzip|clean.*code|clean.*architektur|'
                 r'performance.*optimier|bottleneck.*find|profil.*code|security.*audit.*code|'
                 r'algorithm.*optimier|komplexitaet.*reduzier|o.*notation|big.*o|'
                 r'api.*design|api.*architektur|microservice.*design|monolith.*split|'
                 r'test.*strategie|unit.*test.*schreib|integration.*test|tdd|bdd|'
                 r'was.*best.*practice|beste.*praxis.*code|code.*qualitaet|'
                 r'implementier.*fuer.*mich|schreib.*funktion|schreib.*klasse|schreib.*script|schreib.*skript|'
                 r'bau.*mir.*eine.*app|erstell.*mir.*ein.*programm|erstell.*mir.*eine.*api|'
                 r'wie.*implementier.*ich|wie.*programmier.*ich|wie.*baue.*ich|wie.*erstell.*ich.*code|'
                 r'debug.*diesen|fehler.*in.*meinem.*code|warum.*gibt.*mein.*code|was.*falsch.*code)', low):
        analysis.update(role='dev', task_type='build', tools=['expert_code'], confidence=0.91)
        return analysis

    # EXPERT-RESEARCH: Tiefe Recherche, Marktanalyse, investigativ
    if re.search(r'(recherchiere.{0,30}(tiefgr|tiefsinnig|vollst|komplett|umfassend|detailliert)|'
                 r'marktanalyse|wettbewerbsanalyse|kompetitor.*analyse|competitive.*analysis|'
                 r'investigier|investigative|vollstaendige.*analyse|comprehensive.*analysis|'
                 r'fact.?check|fakten.*pruefen|quellen.*pruefen|verifizier.*fakten|'
                 r'recherche.*bericht|research.*report|due.*diligence|'
                 r'was.*sagen.*experten|expertenmeinung|state.*of.*art|aktueller.*stand)', low):
        analysis.update(role='research', task_type='explain', tools=['expert_research'], needs_web_research=True, confidence=0.90)
        return analysis

    # EXPERT-EDIT: Lektorat, Korrekturlesen, Stilverbesserung
    if re.search(r'(korrigier.{0,20}(text|folgenden|meinen|diesen|den)|'
                 r'lektorier|lektüre|proofreading|proofread|'
                 r'verbessere.{0,20}(text|meinen text|folgenden text|diesen text|schreibstil)|'
                 r'ueberarbeite.{0,20}(text|meinen|diesen|folgenden)|'
                 r'überarbeite.{0,20}(text|meinen|diesen|folgenden)|'
                 r'rechtschreibung.*pruefen|grammatik.*pruefen|pruef.*grammatik|pruef.*rechtschreibung|'
                 r'stilistisch.*verbessern|stilverbesserung|besser.*formulier|umformulier|'
                 r'klingt.*besser|klingt.*natuerlicher|klingt.*professioneller|'
                 r'feedback.*text|feedback.*meinem text|text.*feedback)', low) and not any(s in low for s in ('docker', 'code', 'skript')):
        analysis.update(role='general', task_type='write', tools=['expert_edit'], confidence=0.92)
        return analysis

    # EXPERT-STRATEGY: Strategie, Business-Planung, Management
    if re.search(r'(businessplan|business.*plan|business.*strategie|go.*to.*market|gtm.*strategie|startup.*plan|gruendungsplan|'
                 r'okr.*(erstell|roadmap|ziel)|erstell.*okr|erstell.*roadmap|'
                 r'ziele.*definier|quartalsziele|jahresziele|'
                 r'roadmap.*(erstell|plan)|produkt.*roadmap|feature.*priorisier|'
                 r'swot.*analyse|swot.*erstell|staerken.*schwaechen|'
                 r'entscheidungs.*matrix|priorisierungs.*matrix|rice.*scoring|'
                 r'strategische.*planung|langfristige.*planung|wachstums.*strategie|'
                 r'project.*charter|projektcharter|projektplanung|meilenstein.*plan|'
                 r'ressourcen.*planung|kapazitaets.*planung|team.*aufbau|'
                 r'wie.*skalier|skalierungs.*strategie|pivot.*entscheid)', low) and not any(s in low for s in ('docker', 'container')):
        analysis.update(role='research', task_type='build', tools=['expert_strategy'], confidence=0.91)
        return analysis

    if role_hint == 'ops':
        analysis.update(role='ops', task_type='diagnose', tools=['setup_lookup'], needs_setup_context=True, confidence=0.66)
    elif role_hint == 'research':
        analysis.update(role='research', task_type='explain', tools=['web_research'], needs_web_research=True, confidence=0.66)
    elif role_hint == 'personal':
        analysis.update(role='personal', task_type='write', tools=['personal_assist'], needs_memory=True, confidence=0.66)
    elif role_hint == 'dev':
        analysis.update(role='dev', task_type='build', tools=['dev_build'], confidence=0.66)
    else:
        analysis.update(role='general', task_type='howto', tools=['general_answer'], needs_memory=False, confidence=0.6)
    return analysis


def normalize_analysis(data, message: str, role_hint: str | None):
    if not isinstance(data, dict):
        data = heuristic_analysis(message, role_hint)
    out = heuristic_analysis(message, role_hint)
    # Fix RECIPE-ROUTING-13: Wenn Heuristik hohe Confidence hat (Fast-Path), behalte ihre Tools
    # Heuristik-Fast-Paths (z.B. Rezepte) haben confidence >= 0.9, LLM hat confidence <= 0.8
    if out.get('confidence', 0) >= 0.9:
        # Heuristik-Fast-Path: behalte Tools, erlaube nur reasoning_focus vom LLM
        out.update({k: v for k, v in data.items() if k in {'reasoning_focus'}})
    else:
        out.update({k: v for k, v in data.items() if k in out or k in {'reasoning_focus', 'tools', 'confidence'}})
    role = str(out.get('role') or (role_hint or 'general')).lower()
    if role not in FINAL_ROLE_MAP:
        role = role_hint if role_hint in FINAL_ROLE_MAP else 'general'
    out['role'] = role
    tools = out.get('tools') or []
    clean_tools = []
    for t in tools:
        name = str(t).strip()
        if name in TOOLS and name not in clean_tools:
            clean_tools.append(name)
    out['tools'] = clean_tools[:3]
    out['needs_setup_context'] = bool(out.get('needs_setup_context'))
    out['needs_web_research'] = bool(out.get('needs_web_research'))
    out['needs_memory'] = bool(out.get('needs_memory'))
    out['dangerous_action'] = bool(out.get('dangerous_action'))
    out['force_sequential'] = bool(out.get('force_sequential'))
    if not out['tools']:
        out['tools'] = heuristic_analysis(message, role_hint)['tools']
    if out['needs_setup_context'] and 'setup_lookup' not in out['tools'] and out['role'] == 'ops' and not out['dangerous_action']:
        existing_kinds = {TOOLS[t]['kind'] for t in out['tools'] if t in TOOLS}
        if existing_kinds <= {'evidence'}:
            out['tools'] = (['setup_lookup'] + out['tools'])[:3]
    if out['needs_web_research'] and not any(t in out['tools'] for t in ['web_research', 'url_research', 'compare_selfhosted', 'security_plan']):
        out['tools'] = (['web_research'] + out['tools'])[:3]
    family_candidates = collect_intent_families(message, SERVICE_HINTS) if USE_INTENT_FAMILIES else []
    family_info = family_candidates[0] if family_candidates else classify_intent_family(message, SERVICE_HINTS)
    before_tools = list(out.get('tools') or [])
    out = apply_intent_normalizer(message, out, family_info=family_info)
    if family_candidates:
        out['family_candidates'] = [item.get('family') for item in family_candidates if item.get('family')]
    composition = compose_family_plan(message, out, family_candidates) if USE_INTENT_COMPOSITION else {'composed': False}
    out, before_comp, logged_composition = _apply_composition_selection(
        out,
        composition,
        family_candidates,
        choose_plan=choose_plan,
        use_policy=USE_COMPOSITION_POLICY,
    )
    if before_comp and logged_composition:
        log_intent_composition(message, family_candidates, before_comp, out, logged_composition)
    log_intent_family_shadow(message, family_info, before_tools, list(out.get('tools') or []))
    if USE_META_CONTROLLER:
        _log_shadow_decision(
            META_CONTROLLER_LOG,
            _shadow_decision(message, out, family_candidates, TOOLS),
        )
    return out


def apply_intent_normalizer(message: str, analysis: dict, family_info: dict | None = None):
    return _normalize_intent_family(
        message,
        analysis,
        family_info,
        classify_intent_family=classify_intent_family,
        service_hints=SERVICE_HINTS,
    )


def log_intent_family_shadow(message: str, family_info: dict, before_tools: list[str], after_tools: list[str]):
    _log_intent_family_shadow(
        message,
        family_info,
        before_tools,
        after_tools,
        log_path=INTENT_FAMILY_LOG,
        collect_intent_families=collect_intent_families,
        service_hints=SERVICE_HINTS,
    )


def log_intent_composition(message: str, family_candidates: list[dict], analysis_before: dict, analysis_after: dict, composition: dict):
    _log_intent_composition(
        message,
        family_candidates,
        analysis_before,
        analysis_after,
        composition,
        log_path=INTENT_COMPOSITION_LOG,
    )


def write_temp(prefix: str, text: str):
    tmp = tempfile.NamedTemporaryFile('w', suffix=f'.{prefix}.txt', delete=False, encoding='utf-8')
    tmp.write(text)
    tmp.flush()
    tmp.close()
    return tmp.name


def load_profile_entries_local():
    if not PROFILE_STORE.exists():
        return []
    items = []
    try:
        lines = PROFILE_STORE.read_text(encoding='utf-8', errors='ignore').splitlines()
    except Exception:
        return []
    for line in lines:
        line = line.strip()
        if not line:
            continue
        try:
            data = json.loads(line)
        except Exception:
            continue
        if isinstance(data, dict) and data.get('memory_type') == 'profile':
            items.append(data)
    return items


def profile_memory_context(query: str, limit: int = 4):
    entries = load_profile_entries_local()
    if not entries:
        return ''
    qnorm = norm(query)
    qterms = topic_terms(query)
    scored = []
    for entry in entries:
        text = str(entry.get('text') or '').strip()
        if not text:
            continue
        en = norm(text)
        score = float(entry.get('importance', 0.5))
        if qnorm and qnorm in en:
            score += 5.0
        for term in qterms:
            if term in en:
                score += 1.7
        cat = str(entry.get('category') or '')
        if cat == 'constraint':
            score += 0.7
        if cat == 'setup' and any(h in qnorm for h in SERVICE_HINTS):
            score += 1.2
        if cat == 'preference' and any(k in qnorm for k in ['antwort', 'stil', 'kurz', 'direkt', 'mag', 'bevorzug', 'gerne']):
            score += 1.0
        if score >= 1.45:
            scored.append((score, entry))
    if not scored:
        fallback = []
        for entry in reversed(entries):
            cat = str(entry.get('category') or '')
            if cat in {'constraint', 'preference'}:
                fallback.append(entry)
            if len(fallback) >= min(limit, 2):
                break
        if not fallback:
            return ''
        picked = list(reversed(fallback))
    else:
        picked = []
        seen = set()
        for _score, entry in sorted(scored, key=lambda x: (x[0], x[1].get('last_seen_at', x[1].get('created_at', ''))), reverse=True):
            key = (entry.get('category', 'fact'), norm(str(entry.get('text') or '')))
            if key in seen:
                continue
            seen.add(key)
            picked.append(entry)
            if len(picked) >= limit:
                break
    lines = ['Persoenlicher Kontext:']
    for entry in picked:
        lines.append(f"- [{entry.get('category', 'fact')}|profile] {str(entry.get('text') or '').strip()}")
    return '\n'.join(lines) if len(lines) > 1 else ''


def memory_context(message: str, analysis: dict | None = None):
    if not analysis or not AGENT_MEMORY.exists():
        return ''
    role = str(analysis.get('role') or '')
    task_type = str(analysis.get('task_type') or '')
    needs_memory = bool(analysis.get('needs_memory')) or task_type == 'memory'
    if not needs_memory:
        return ''
    if task_type == 'memory':
        rc, out, _err = run([str(AGENT_MEMORY), 'context', message], timeout=10)
        if rc != 0 or not out or '(kein persoenlicher Kontext gespeichert)' in out:
            return ''
        return out
    base = ''
    if role in {'personal', 'general', 'ops'}:
        base = profile_memory_context(message)
    # Append goals + contacts context for personal/research roles or planning task types
    if role in {'personal', 'research'} or task_type in {'strategy', 'write', 'assist', 'plan'}:
        extra_parts = []
        goals_bin = ROOT / 'bin' / 'goals-manage'
        contacts_bin = ROOT / 'bin' / 'contacts-manage'
        if goals_bin.exists():
            rc_g, out_g, _ = run([str(goals_bin), 'context'], timeout=10)
            if rc_g == 0 and out_g and '(Noch keine' not in out_g and '(Keine' not in out_g:
                extra_parts.append(out_g)
        if contacts_bin.exists():
            rc_c, out_c, _ = run([str(contacts_bin), 'show-due', 'days=3'], timeout=10)
            if rc_c == 0 and out_c and 'Keine Follow-ups' not in out_c:
                extra_parts.append('Follow-ups (3 Tage):\n' + out_c)
            rc_b, out_b, _ = run([str(contacts_bin), 'show-birthdays', 'days=7'], timeout=10)
            if rc_b == 0 and out_b and 'Keine Geburtstage' not in out_b:
                extra_parts.append('Geburtstage (7 Tage):\n' + out_b)
        if extra_parts:
            extras = '\n\n'.join(extra_parts)
            base = (base + '\n\n' + extras).strip() if base else extras
    return base


def remember_user_signal(message: str):
    if not AGENT_MEMORY.exists():
        return
    try:
        run([str(AGENT_MEMORY), 'ingest', message], timeout=8)
    except Exception:
        pass


def remember_episode(message: str):
    if not AGENT_MEMORY.exists():
        return
    try:
        run([str(AGENT_MEMORY), 'episode', message], timeout=8)
    except Exception:
        pass


def remember_incident(text: str):
    if not AGENT_MEMORY.exists():
        return
    try:
        run([str(AGENT_MEMORY), 'incident', text], timeout=10)
    except Exception:
        pass


def should_fetch_retrieval(message: str, analysis: dict | None = None, role_hint: str | None = None) -> bool:
    low = norm(message)
    if analysis:
        role = analysis.get('role')
        needs_setup = bool(analysis.get('needs_setup_context'))
        needs_web = bool(analysis.get('needs_web_research'))
        task_type = analysis.get('task_type')
        if role == 'research' and needs_web and not needs_setup:
            return False
        if role in {'general', 'personal'} and not needs_setup and not any(h in low for h in SERVICE_HINTS):
            return False
        if role == 'research' and task_type == 'compare' and not needs_setup and not any(h in low for h in SERVICE_HINTS):
            return False
    if role_hint in {'ops', 'dev'}:
        return True
    if analysis and (analysis.get('needs_setup_context') or analysis.get('role') in {'ops', 'dev'}):
        return True
    if any(h in low for h in SERVICE_HINTS):
        return True
    if re.search(r'\b(set?up|host|service|dienste|logs?|share|smb|bibliothek|container|agent|bibabot|gedaechtnis|memory|router|subagent)\b', low):
        return True
    return False


def retrieval_context(message: str, analysis: dict | None = None, role_hint: str | None = None):
    if not CONTEXT_PACK.exists() or not should_fetch_retrieval(message, analysis, role_hint):
        return ''
    queries = [message]
    if is_followup_query(message):
        topic = recent_topic_event(message) or load_topic_state()
        if topic:
            root = str(topic.get('root_message') or topic.get('message') or '').strip()
            if root and norm(root) != norm(message):
                queries.append(f'{root}\n{message}')
    if analysis:
        focus = ' '.join(str(x).strip() for x in analysis.get('reasoning_focus', [])[:2] if str(x).strip())
        if focus:
            queries.append(f'{message}\n{focus}')
    low = norm(message)
    hinted = [term for term in SERVICE_HINTS if term in low]
    if hinted:
        queries.append(' '.join(dict.fromkeys(hinted + [message])))

    lines = []
    seen = set()
    for query in queries[:3]:
        rc, out, _err = run([str(CONTEXT_PACK), query], timeout=35)
        if rc != 0 or not out:
            continue
        for line in out.splitlines():
            line = line.strip()
            if not line or line == 'Kontext-Snippets:' or line in seen:
                continue
            seen.add(line)
            lines.append(line)
            if len(lines) >= 8:
                return 'Kontext-Snippets:\n' + '\n'.join(lines)
    return 'Kontext-Snippets:\n' + '\n'.join(lines) if lines else ''


def append_context(base: str, extra: str) -> str:
    extra = (extra or '').strip()
    base = (base or '').strip()
    if not extra:
        return base
    if not base:
        return extra
    if extra in base:
        return base
    return base + '\n\n' + extra


def playbook_context(message: str, analysis: dict | None = None) -> str:
    if not USE_PLAYBOOKS:
        return ''
    try:
        return format_playbook_context(message, analysis=analysis)
    except Exception:
        return ''


def apply_plan_first(analysis: dict, plan: dict | None) -> dict:
    if not plan:
        return analysis
    out = dict(analysis or {})
    tool_override = [str(t).strip() for t in plan.get('tool_override') or [] if str(t).strip() in TOOLS]
    if tool_override:
        out['tools'] = tool_override[:3]
    focus = []
    for item in (out.get('reasoning_focus') or []) + (plan.get('reasoning_focus') or []):
        text = str(item).strip()
        if text and text not in focus:
            focus.append(text)
    if focus:
        out['reasoning_focus'] = focus[:6]
    gaps = set(plan.get('evidence_gaps') or [])
    if 'setup_or_inventory' in gaps:
        out['needs_setup_context'] = True
    if 'personal_memory' in gaps:
        out['needs_memory'] = True
    out['plan_first_mode'] = plan.get('mode', 'plan_first')
    return out


def response_contract(analysis: dict):
    task_type = analysis.get('task_type', 'explain')
    if task_type == 'diagnose':
        return 'Antwortvertrag: Erklaere kurz den relevanten Mechanismus, nenne die wahrscheinlichste Ursache, belege sie mit den vorhandenen Fakten und gib die naechsten sinnvollen Checks oder Fixes an.'
    if task_type == 'compare':
        return 'Antwortvertrag: Gib eine klare Empfehlung, vergleiche die besten Optionen mit konkreten Tradeoffs und begruende, warum die Empfehlung zur Situation passt.'
    if task_type == 'howto':
        return 'Antwortvertrag: Gib konkrete, brauchbare Schritte statt Meta-Erklaerungen. Nenne Voraussetzungen und typische Stolpersteine kurz.'
    if task_type == 'build':
        return 'Antwortvertrag: Zerlege das Vorhaben in sinnvolle Schritte, nenne den vorgesehenen Output und sage offen, was bereits verifiziert ist.'
    if task_type == 'status':
        return 'Antwortvertrag: Nenne zuerst den aktuellen Zustand und danach nur die Punkte, die wirklich Aufmerksamkeit brauchen.'
    if task_type == 'action':
        return 'Antwortvertrag: Sage klar, was getan wurde oder was blockiert war, und nenne den verifizierten Effekt.'
    if task_type == 'memory':
        return 'Antwortvertrag: Antworte persoenlich, konkret und nur mit wirklich gespeichertem Kontext.'
    return 'Antwortvertrag: Antworte direkt auf die eigentliche Frage, dann kurz die wichtigsten Begruendungen oder Beispiele.'


def postprocess_final_answer(message: str, analysis: dict, final_text: str) -> str:
    return _policy_postprocess_final_answer(message, analysis, final_text)


def compact_episode_text(message: str, analysis: dict, final_text: str, evidence_items: list[dict]) -> str:
    lines = []
    for line in (final_text or '').splitlines():
        line = line.strip()
        if not line or line.lower() in {'befund:', 'ursache:', 'wahrscheinlichste ursache:', 'naechste pruefungen/aktionen:', 'naechster schritt:', 'aktion:'}:
            continue
        lines.append(line)
        if len(lines) >= 3:
            break
    if not lines and evidence_items:
        lines = [item.get('summary', '') for item in evidence_items if item.get('summary')]
    snippet = ' | '.join(line for line in lines if line)[:700]
    return f'{message}\nAntwortkern: {snippet}' if snippet else message


def evidence_object(tool: str, rc: int, output: str, err: str = ''):
    # Fix GENERAL-GROUNDEDNESS-5: rc kann None sein, was alle Heuristiken deaktiviert
    # Normalisiere rc zu int (0 = success, 1 = failure)
    if rc is None:
        rc = 0 if (output or '').strip() else 1
    clean = (output or '').strip()
    # Fix EVIDENCE-STDERR-1: Wenn stdout leer ist, aber stderr substanzielle Antwort hat, nutze stderr
    # Problem: Tools wie research-web-answer geben bei Fehlern 'nicht_verifiziert' auf stderr aus
    # Lösung: Fallback auf stderr wenn stdout leer und stderr nicht nur Fehlermeldung ist
    if not clean and err and len(err.strip()) > 20 and 'nicht_verifiziert' not in err.lower():
        clean = err.strip()
    low = norm(clean)
    kind = EVIDENCE_KIND_BY_TOOL.get(tool, 'general')
    grounded = False
    if tool in GROUNDED_FASTPATH_TOOLS:
        grounded = bool(clean)
    elif kind == 'web':
        # Fix WEB-GROUNDEDNESS-7: Entschärfte Heuristik für web_research
        # Problem: Zu strenge Kombination von Bedingungen hat 32% (12/37) als ungrounded markiert
        # Lösung: Einfachere, robustere Prüfung - akzeptiere mehr Antworten als grounded
        
        # Basis: Kein Fehler und substanzieller Output
        # Fix WEB-GROUNDEDNESS-8: Erkenne nicht_verifiziert überall im String, nicht nur am Anfang
        has_valid_output = bool(clean) and rc == 0 and not clean.startswith('(fehler:') and 'nicht_verifiziert' not in clean.lower()
        
        # Explizite Marker (Kurzantwort/Quellen Format von research-web-answer)
        # Fix WEB-GROUNDEDNESS-8: Prüfe ob nach Marker auch tatsächlich Inhalt kommt
        has_quellen = 'Quellen:' in clean and len(clean.split('Quellen:')[-1].strip()) > 10
        # Kurzantwort muss gefolgt sein von substanziellem Inhalt (nicht nur Formatierung)
        if 'Kurzantwort:' in clean:
            after_marker = clean.split('Kurzantwort:')[-1].strip()
            # Entferne Markdown-Formatierung für die Prüfung
            after_clean = after_marker.replace('**', '').replace('*', '').replace('- ', '').strip()
            has_kurzantwort = len(after_clean) > 20 and '.' in after_clean
        else:
            has_kurzantwort = False
        has_explicit_markers = has_quellen or has_kurzantwort
        
        # Substanzieller Content (ENTSCHÄRFT: von 150 auf 100 Zeichen, von 2 auf 1 Sätze)
        has_substantial_content = (
            has_valid_output and len(clean) > 100 and clean.count('.') >= 1
        )
        
        # Web-typische Strukturmerkmale (erweitert)
        web_markers = ['http', 'www.', '.de', '.com', '.org', ' - ', '•', '→', '1.', '2.', '3.', '- ', '**', '*']
        has_web_structure = any(m in clean.lower() for m in web_markers)
        
        # Markdown-Struktur als Qualitätsindikator
        has_markdown_structure = has_valid_output and any(c in clean for c in ['**', '*', '- ', '1.', '2.', '###', '##'])
        
        # Mehrzeilige Antworten sind wahrscheinlich gut
        has_multiple_lines = has_valid_output and len(clean.splitlines()) >= 2
        
        # Kombinierte Entscheidung (ENTSCHÄRFT: OR statt AND-Kombinationen)
        grounded = (
            has_explicit_markers or 
            (has_substantial_content and (has_web_structure or has_markdown_structure)) or
            (has_valid_output and len(clean) > 200 and has_multiple_lines)
        )
    elif kind in {'memory', 'status', 'action'}:
        grounded = bool(clean)
    elif kind == 'general':
        # Fix PERSONAL-GROUNDEDNESS-1: Spezielle Heuristik für personal_assist
        # Problem: personal_assist Antworten (Rezepte, Wochenplanung, etc.) wurden als ungrounded markiert
        # Lösung: Eigene, weniger strenge Heuristik für personal_assist
        if tool == 'personal_assist':
            # personal_assist gibt strukturierte Antworten (Rezepte, Listen, How-tos)
            # Akzeptiere wenn: Output existiert, kein Fehler, und substanziell (>50 Zeichen)
            has_valid_output = bool(clean) and rc == 0 and not clean.startswith('(fehler:') and not clean.startswith('nicht_verifiziert')
            
            # Persönliche Assistenz-Marker (Rezepte, Listen, How-tos)
            # Fix PERS-GROUNDED-2: Erweiterte Marker für Abendessen-Ideen und Essens-Themen
            personal_markers = [
                'zutaten', 'zubereitung', 'zutatenliste',  # Rezepte
                'schritt', 'schritte', 'anleitung', 'vorgehen',  # How-tos
                'kurzbeschreibung', 'beschreibung',  # Allgemein
                'portione', 'portionen',  # Rezepte
                'tipps', 'hinweise', 'beispiel',  # Listen/Tipps
                '1.', '2.', '3.', '- ',  # Aufzählungen
                '**', '*',  # Markdown-Formatierung
                'hier sind', 'wichtige punkte', 'punkte',  # Einleitungen
                'optionen/hinweise', 'optionen', 'hinweise',  # Rezept-Ende
                'einfaches', 'grundrezept',  # Rezept-Einleitung
                'fuer', 'portionen',  # Rezept-Header
                'wochenplan', 'wochenplanung', 'pragmatisch',  # Wochenplanung
                'prioritaeten', 'prioritäten', 'kalenderblock',  # Planung
                'brain-dump', 'tagesabschluss', 'review',  # Produktivität
                # Fix PERS-GROUNDED-2: Neue Marker für Abendessen-Ideen
                'abendessen', 'abend-essen', 'ideen', 'schnell', 'einfach',  # Essens-Ideen
                'one-pan', 'one pan', 'pasta', 'bowl', 'wrap', 'sandwich',  # Gerichtstypen
                'protein', 'gemuese', 'gemüse', 'fleisch', 'fisch', 'tofu',  # Zutaten-Kategorien
                'gerichte', 'variationen', 'klassiker', 'optionen',  # Listen-Typen
                'meal-prep', 'meal prep', 'vorbereiten', 'vorkochen',  # Planung
                'min', 'minute', 'minuten', 'stunde', 'zeit',  # Zeitangaben
            ]
            has_personal_structure = has_valid_output and any(m in low for m in personal_markers)
            
            # Substantielle Antworten sind grounded (ENTSCHÄRFT für personal)
            is_substantial = (
                has_valid_output and 
                (len(clean) > 50 and clean.count('.') >= 1) or
                (len(clean) > 30 and has_personal_structure) or
                (len(clean.splitlines()) >= 2 and has_personal_structure)
            )
            
            # Mehrzeilige Antworten mit Struktur sind grounded
            has_multiple_lines = has_valid_output and len(clean.splitlines()) >= 2
            has_markdown = has_valid_output and any(c in clean for c in ['**', '*', '- ', '1.', '2.', '###', '##'])
            
            # Kombinierte Entscheidung für personal_assist
            grounded = (
                has_personal_structure or 
                is_substantial or 
                (has_multiple_lines and len(clean) > 40) or
                (has_markdown and len(clean) > 40)
            )
            # Fix PERS-GROUNDED-3: Entferne early return - Summary wird jetzt unten erstellt
            # Der Code fällt durch zu den gemeinsamen Summary/Return-Blöcken am Ende der Funktion
        
        # Fix GENERAL-GROUNDEDNESS-6: Entschärfte Heuristik für general_answer
        # Problem: Zu strenge Prüfung hat viele valide Antworten als ungrounded markiert
        # Lösung: Akzeptiere mehr Antworten als grounded, besonders wenn sie aus general-local-assist kommen
        
        # Basis: Output existiert und ist kein Fehler
        has_valid_output = bool(clean) and rc == 0 and not clean.startswith('(fehler:') and not clean.startswith('nicht_verifiziert')
        
        # Heuristik 1: Strukturierte Inhalte (Rezepte, How-tos, Erklärungen)
        # Fix GENERAL-GROUNDEDNESS-7: Erweiterte Marker für general-local-assist Output-Format
        structure_markers = [
            'zutaten', 'zubereitung', 'zutatenliste',  # Rezepte
            'schritt', 'schritte', 'anleitung', 'vorgehen',  # How-tos
            'kurzbeschreibung', 'beschreibung',  # Allgemein
            'portione', 'portionen',  # Rezepte
            'vorteile', 'nachteile', 'fazit',  # Vergleiche
            'erklärung', 'erklaerung', 'warum', 'wie',  # Erklärungen
            'tipps', 'hinweise', 'beispiel',  # Listen/Tipps
            '1.', '2.', '3.', '- ',  # Aufzählungen
            '**', '*',  # Markdown-Formatierung
            'hier sind', 'wichtige punkte', 'punkte',  # Einleitungen
            # Fix GENERAL-GROUNDEDNESS-7: Zusätzliche Marker für Rezept-Format
            'optionen/hinweise', 'optionen', 'hinweise',  # Rezept-Ende
            'einfaches', 'grundrezept',  # Rezept-Einleitung
            'fuer', 'portionen',  # Rezept-Header
        ]
        has_structure = has_valid_output and any(m in low for m in structure_markers)
        
        # Heuristik 2: Substantielle Antworten sind grounded (ENTSCHÄRFT)
        # Vorher: >100 Zeichen, 2+ Sätze
        # Jetzt: >80 Zeichen, 1+ Sätze (oder >50 Zeichen mit Struktur)
        # Fix GENERAL-GROUNDEDNESS-8: Mehrzeilige Antworten mit Struktur sind immer grounded
        is_substantial = (
            has_valid_output and 
            (len(clean) > 80 and clean.count('.') >= 1) or
            (len(clean) > 50 and any(m in low for m in structure_markers)) or
            # Fix: Mehrzeilige Antworten mit Aufzählungen sind grounded
            (len(clean.splitlines()) >= 3 and any(m in low for m in ['-', '1.', '2.', 'zutaten', 'zubereitung', 'kurzbeschreibung']))
        )
        
        # Heuristik 3: Definition/Erklärung-Form
        explanation_patterns = [
            r'^\w+\s+ist\s+ein',  # "Docker ist ein..."
            r'^\w+\s+ist\s+die',  # "Das ist die..."
            r'^\w+\s+sind\s+',    # "Y sind..."
            r'^ein\s+\w+\s+ist',  # "Ein Lichtjahr ist..."
            r'^der\s+\w+\s+ist',  # "Der Unterschied ist..."
            r'^die\s+\w+\s+ist',  # "Die Antwort ist..."
            r'^\w+\s+bedeutet',   # "X bedeutet..."
        ]
        has_explanation_form = has_valid_output and any(re.search(p, low) for p in explanation_patterns)
        
        # Heuristik 4: Vergleichs-Marker
        comparison_markers = [' vs ', ' versus ', 'unterschied', 'vergleich', ' vs. ', ' im vergleich zu ', ' gegenüber ']
        has_comparison = has_valid_output and any(m in low for m in comparison_markers)
        
        # Heuristik 5: Wissenschaft/Fakt-Marker
        fact_markers = [
            'lichtjahr', 'lichtjahre', 'photosynthese', 'dna', 'protein',
            'kalorie', 'kilokalorie', 'kcal', 'gramm', 'meter', 'sekunde',
            'prozent', '°c', 'grad', 'jahr', 'monat', 'tag', 'stunde',
            'wasser', 'sauerstoff', 'kohlenstoff', 'stickstoff',
            'erde', 'mond', 'sonne', 'planet', 'stern', 'galaxie',
            'atom', 'molekül', 'molekuel', 'zelle', 'organismus',
            'temperatur', 'druck', 'geschwindigkeit', 'masse', 'gewicht',
        ]
        has_fact_content = has_valid_output and any(m in low for m in fact_markers)
        
        # Heuristik 6: Allgemeine Erklärungs-Wörter
        explanation_words = ['weil', 'denn', 'daher', 'deshalb', 'folglich', 'somit', 'also']
        has_explanation_words = has_valid_output and any(m in low for m in explanation_words)
        
        # Heuristik 7: Qualitäts-Indikatoren (NEU)
        # Antworten mit mehreren Zeilen oder Markdown sind wahrscheinlich gut
        has_multiple_lines = has_valid_output and len(clean.splitlines()) >= 2
        has_markdown = has_valid_output and any(c in clean for c in ['**', '*', '- ', '1.', '2.', '###', '##'])
        
        # Kombinierte Entscheidung: grounded wenn mindestens eine Bedingung erfüllt (ENTSCHÄRFT)
        # Vorher: strengere Schwellen (60-80 Zeichen)
        # Jetzt: akzeptiere auch kurze aber strukturierte Antworten
        grounded = (
            has_structure or 
            is_substantial or 
            (has_explanation_form and len(clean) > 50) or 
            (has_comparison and len(clean) > 50) or 
            (has_fact_content and len(clean) > 50) or
            (has_explanation_words and len(clean) > 60) or
            (has_multiple_lines and len(clean) > 60) or
            (has_markdown and len(clean) > 60)
        )
    summary = ''
    for line in clean.splitlines():
        line = line.strip()
        if not line or line.lower() in {'befund:', 'ursache:', 'aktion:', 'kurzantwort:', 'quellen:'}:
            continue
        summary = line[:220]
        break
    if not summary:
        summary = clean.splitlines()[0][:220] if clean else f'(fehler: {(err or "").strip()})'
    return {
        'tool': tool,
        'rc': rc,
        'kind': kind,
        'grounded': grounded,
        'output': clean if clean else (err or '').strip(),
        'error': (err or '').strip(),
        'summary': summary,
        'confidence': 0.92 if grounded else 0.72 if clean else 0.15,
        'signals': [sig for sig in ['ldap', 'authentik', 'oidc', 'dns', 'smb', 'share', 'warning', 'error', 'quelle', 'quellen'] if sig in low],
    }


def render_evidence(evidence_items: list[dict], memory_ctx: str = '', retrieval_ctx: str = '') -> str:
    blocks = []
    if memory_ctx:
        blocks.append('Persoenlicher Kontext:\n' + memory_ctx)
    if retrieval_ctx:
        blocks.append(retrieval_ctx)
    if evidence_items:
        rendered = []
        for idx, item in enumerate(evidence_items, start=1):
            rendered.append(
                f"Evidence {idx}: tool={item.get('tool')} kind={item.get('kind')} grounded={item.get('grounded')} rc={item.get('rc')}\n"
                f"{item.get('output') or item.get('error') or '(leer)'}"
            )
        blocks.append('Evidence-Objekte:\n' + '\n\n'.join(rendered))
    return '\n\n'.join(blocks) if blocks else '(keine)'


def record_incident_if_useful(message: str, analysis: dict, final_text: str, evidence_items: list[dict]):
    if analysis.get('task_type') != 'diagnose':
        return
    grounded = [item for item in evidence_items if item.get('grounded') and item.get('tool') in INCIDENT_MEMORY_TOOLS]
    if not grounded:
        return
    subject = ''
    for token in [analysis.get('role', ''), *analysis.get('tools', [])]:
        token = str(token or '').strip()
        if token in {'ops', 'research', 'personal', 'dev', 'general'}:
            continue
        if token:
            subject = token
            break
    lead = ''
    for line in (final_text or '').splitlines():
        line = line.strip()
        if not line or line.lower() in {'befund:', 'ursache:', 'aktion:'}:
            continue
        lead = line[:260]
        break
    if not lead:
        lead = grounded[0].get('summary', '')[:260]
    text = f"{message}\nLoesungskern: {lead}"
    remember_incident(text)



def refresh_composition_policy_async():
    if not COMPOSITION_POLICY_REFRESH.exists():
        return
    try:
        subprocess.Popen(
            [str(COMPOSITION_POLICY_REFRESH)],
            stdout=subprocess.DEVNULL,
            stderr=subprocess.DEVNULL,
            start_new_session=True,
        )
    except Exception:
        pass

def record_task_outcome(message: str, analysis: dict, final_text: str, evidence_items: list[dict], status: str = 'success', error_text: str = ''):
    _record_task_outcome(
        message,
        analysis,
        final_text,
        evidence_items,
        status=status,
        error_text=error_text,
        log_path=TASK_OUTCOME_LOG,
        classify_intent_family=classify_intent_family,
        collect_intent_families=collect_intent_families,
        service_hints=SERVICE_HINTS,
        refresh_composition_policy_async=refresh_composition_policy_async,
    )


def persist_result_state(message: str, analysis: dict, final_text: str, evidence_items: list[dict]):
    _persist_result_state(
        message,
        analysis,
        final_text,
        evidence_items,
        should_skip_heavy_persistence=should_skip_heavy_persistence,
        update_topic_state=update_topic_state,
        compact_episode_text=compact_episode_text,
        remember_episode=remember_episode,
        record_incident_if_useful=record_incident_if_useful,
    )


def verify_answer(message: str, analysis: dict, draft: str, evidence_items: list[dict], memory_ctx: str = '', retrieval_ctx: str = ''):
    if not draft.strip():
        return None
    if analysis.get('task_type') in {'action', 'memory'}:
        return {'verdict': 'keep', 'grounded': True, 'addresses_request': True, 'wrong_entity_jump': False, 'retry_tool': '', 'missing_points': [], 'rationale': 'Direkter Spezialpfad.', 'revised_answer': ''}
    if len(evidence_items) == 1 and evidence_items[0].get('tool') in GROUNDED_FASTPATH_TOOLS and evidence_items[0].get('grounded'):
        return {'verdict': 'keep', 'grounded': True, 'addresses_request': True, 'wrong_entity_jump': False, 'retry_tool': '', 'missing_points': [], 'rationale': 'Direkter grounded Tool-Fastpath.', 'revised_answer': ''}
    if len(evidence_items) == 1 and evidence_items[0].get('tool') == 'web_research':
        raw = evidence_items[0].get('output', '')
        if raw.strip().startswith('Kurzantwort:') and 'Quellen:' in raw:
            return {'verdict': 'keep', 'grounded': True, 'addresses_request': True, 'wrong_entity_jump': False, 'retry_tool': '', 'missing_points': [], 'rationale': 'Direkter Research-Fastpath mit Quellen.', 'revised_answer': ''}
    if analysis.get('role') == 'general' and len(evidence_items) == 1 and evidence_items[0].get('tool') == 'general_answer' and not memory_ctx and not retrieval_ctx:
        return {'verdict': 'keep', 'grounded': True, 'addresses_request': True, 'wrong_entity_jump': False, 'retry_tool': '', 'missing_points': [], 'rationale': 'Direkter General-Fastpath ohne riskante Evidenzspruenge.', 'revised_answer': ''}
    # Fix PERS-GROUNDED-3: Fastpath für personal_assist (wie general_answer)
    # Problem: personal_assist läuft durch LLM-Verifier und wird manchmal falsch als ungrounded markiert
    # Lösung: Direkter Fastpath wenn personal_assist grounded ist und keine Memory/Retrieval-Kontext
    if analysis.get('role') == 'personal' and len(evidence_items) == 1 and evidence_items[0].get('tool') == 'personal_assist' and evidence_items[0].get('grounded') and not memory_ctx and not retrieval_ctx:
        return {'verdict': 'keep', 'grounded': True, 'addresses_request': True, 'wrong_entity_jump': False, 'retry_tool': '', 'missing_points': [], 'rationale': 'Direkter Personal-Fastpath ohne riskante Evidenzspruenge.', 'revised_answer': ''}
    system = (
        'Du bist das Qualitaetspruef-Modul von J.A.R.V.I.S. '
        'Pruefe eine Antwort nur gegen Nutzerfrage, Analyse und vorhandene Evidence-Objekte. '
        'Eine schlechte Antwort springt auf falsche Objekte oder Mechanismen, etwa Sonos -> Audiobookshelf. '
        'Wenn die Antwort mit der vorhandenen Evidenz reparierbar ist, gib verdict=revise und liefere revised_answer. '
        'Wenn das falsche Tool verwendet wurde und ein anderes vorhandenes Tool klar besser passt, gib verdict=retry und retry_tool. '
        'Erfinde keine neuen Fakten.'
    )
    user = (
        f'Nutzerfrage:\n{message}\n\n'
        f'Analyse:\n{json.dumps(analysis, ensure_ascii=False)}\n\n'
        f'Evidenz:\n{render_evidence(evidence_items, memory_ctx=memory_ctx, retrieval_ctx=retrieval_ctx)}\n\n'
        f'Antwortentwurf:\n{draft}\n\n'
        'Verfuegbare Tools fuer retry:\n'
        f'{tool_catalog_text()}\n\n'
        'Pruefe: trifft die Antwort das eigentliche Objekt der Anfrage, beantwortet sie die Teilfragen, bleibt sie bei belegten Aussagen, und fehlt etwas Wesentliches?'
    )
    for model in VERIFY_MODELS:
        if not model_exists(model):
            continue
        rc, out, _err = call_llm_schema(model, VERIFY_SCHEMA, system, user, timeout=60)
        if rc != 0 or not out:
            continue
        try:
            data = json.loads(out)
        except Exception:
            continue
        if not isinstance(data, dict):
            continue
        retry_tool = str(data.get('retry_tool') or '').strip()
        if retry_tool and retry_tool not in TOOLS:
            data['retry_tool'] = ''
        return data
    return None


def finalize_answer(message: str, analysis: dict, evidence_items: list[dict], draft: str, memory_ctx: str = '', retrieval_ctx: str = '', allow_retry: bool = True, allow_synthesize: bool = True):
    tool_kinds = {name: cfg.get('kind', '') for name, cfg in TOOLS.items()}
    _skip_verify = _should_skip_verify(analysis, evidence_items, tool_kinds)
    review = ({} if _skip_verify else verify_answer(message, analysis, draft, evidence_items, memory_ctx=memory_ctx, retrieval_ctx=retrieval_ctx)) or {}
    verdict = review.get('verdict', 'keep')
    revised = str(review.get('revised_answer') or '').strip()
    retry_tool = str(review.get('retry_tool') or '').strip()

    if verdict == 'retry' and allow_retry and retry_tool and retry_tool not in [item.get('tool') for item in evidence_items] and TOOLS.get(retry_tool, {}).get('kind') != 'action':
        rc, out, err = run_tool(retry_tool, message)
        if rc == 0 and out:
            merged = evidence_items + [evidence_object(retry_tool, rc, out, err)]
            new_draft = synthesize(message, analysis, merged, memory_ctx=memory_ctx, retrieval_ctx=retrieval_ctx)
            return finalize_answer(message, analysis, merged, new_draft, memory_ctx=memory_ctx, retrieval_ctx=retrieval_ctx, allow_retry=False, allow_synthesize=False)
        if err:
            evidence_items = evidence_items + [evidence_object(retry_tool, rc, out, err)]

    if verdict == 'revise' and revised:
        return revised, evidence_items

    if verdict == 'keep':
        return draft, evidence_items

    if allow_synthesize and evidence_items and draft == evidence_items[-1].get('output', ''):
        new_draft = synthesize(message, analysis, evidence_items, memory_ctx=memory_ctx, retrieval_ctx=retrieval_ctx)
        if new_draft and new_draft != draft:
            return finalize_answer(message, analysis, evidence_items, new_draft, memory_ctx=memory_ctx, retrieval_ctx=retrieval_ctx, allow_retry=False, allow_synthesize=False)

    return draft, evidence_items


def run_tool(name: str, message: str):
    trace_stage('run_tool', name)
    if name == 'memory_profile':
        low = norm(message)
        if re.search(r'^(bitte\s+)?(merke dir|merk dir|denk daran|behalte im kopf)\b', low):
            return run([str(AGENT_MEMORY), 'ingest', message], timeout=20)
        if '?' not in message and re.search(r'\b(ich will|ich bevorzuge|mir ist wichtig|achte darauf|das ist falsch|es sollte|er sollte|wenn es um .* geht|ich .* wichtig finde)\b', low):
            return run([str(AGENT_MEMORY), 'ingest', message], timeout=20)
        if 'was weisst du ueber mich' in low or 'was weisst du über mich' in message.lower() or 'mein profil' in low or 'gespeichertes profil' in low:
            return run([str(AGENT_MEMORY), 'summary'], timeout=20)
        return run([str(AGENT_MEMORY), 'answer', message], timeout=20)
    if name == 'briefing':
        return run([str(ROOT / 'bin' / 'agent-briefing')], timeout=70)
    if name == 'setup_lookup':
        return run([str(ROOT / 'bin' / 'ops-setup-qa'), message], timeout=70)
    if name == 'public_services_health':
        return run([str(ROOT / 'bin' / 'ops-public-services-health')], timeout=70)
    if name == 'log_hotspots':
        return run([str(ROOT / 'bin' / 'ops-log-hotspots'), message], timeout=90)
    if name == 'host_slow_diagnose':
        return run([str(ROOT / 'bin' / 'ops-host-slow-diagnose'), message], timeout=120)
    if name == 'kasm_diagnose':
        return run([str(ROOT / 'bin' / 'ops-kasm-diagnose'), message], timeout=120)
    if name == 'user_service_access_diagnose':
        return run([str(ROOT / 'bin' / 'ops-user-service-access-diagnose'), message], timeout=120)
    if name == 'web_root_cause':
        return run([str(ROOT / 'bin' / 'ops-web-root-cause'), message], timeout=120)
    if name == 'sonos_library_diagnose':
        return run([str(ROOT / 'bin' / 'ops-sonos-library-diagnose'), message], timeout=120)
    if name == 'emby_user_provision':
        return run([str(ROOT / 'bin' / 'ops-emby-user-provision-advice'), message], timeout=120)
    if name == 'light_status':
        return run([str(ROOT / 'bin' / 'ops-lights-on')], timeout=40)
    if name == 'light_usage':
        return run([str(ROOT / 'bin' / 'ops-light-usage-advice'), '168'], timeout=90)
    if name == 'light_control':
        return run([str(ROOT / 'bin' / 'home-lightctl'), message], timeout=40)
    if name == 'web_research':
        quick = ROOT / 'bin' / 'research-quick-answer'
        low = norm(message)
        if quick.exists() and re.search(r'^(was ist|wer ist|wo ist|wo liegt|wo befindet sich|warum|wieso|weshalb|wie leben|wie lebt|wo leben|wo lebt|was essen|was frisst|wie gross ist|wie groß ist|wie alt wird|wie funktioniert)\b', low):
            rc, out, err = run([str(quick), message], timeout=25)
            if rc == 0 and out.strip() and 'nicht_verifiziert' not in out.lower():
                return rc, out, err
        # Fix WEB-RESEARCH-FALLBACK: Wenn Web-Recherche fehlschlägt, versuche general-local-assist
        # Problem: 26% der web_research Aufrufe waren ungrounded wegen Netzwerkfehlern
        # Lösung: Fallback auf lokales Wissen statt nicht_verifiziert zurückgeben
        rc, out, err = run([str(ROOT / 'bin' / 'research-web-answer'), message], timeout=180)
        # Fix WEB-STDERR-1: Prüfe auch stderr wenn stdout leer ist
        # Problem: research-web-answer gibt 'nicht_verifiziert' auf stderr aus bei Fehlern
        combined_output = out.strip() if out.strip() else err.strip()
        if rc != 0 or not combined_output or 'nicht_verifiziert' in combined_output.lower():
            # Web-Recherche fehlgeschlagen - versuche general-local-assist als Fallback
            # Fix WEB-FALLBACK-1: Akzeptiere auch Exit Code 1 wenn substanzielle Antwort vorhanden
            # Problem: general-local-assist gibt oft rc=1 zurück auch bei brauchbarer Antwort
            env = os.environ.copy()
            env['BIBABOT_SELF_CRITIQUE'] = '0'
            env.setdefault('MAC_OLLAMA_MODEL_GENERAL', os.environ.get('BIBABOT_GENERAL_CHAIN', GENERAL_CHAIN_DEFAULT))
            env['MAC_OLLAMA_NUM_CTX_CHAT'] = env.get('MAC_OLLAMA_NUM_CTX_CHAT', '24576')
            rc2, out2, err2 = run([str(ROOT / 'bin' / 'general-local-assist'), message], timeout=70, env=env)
            # Akzeptiere Antwort wenn: Exit Code 0 ODER (Exit Code 1 UND substanzielle Antwort >100 Zeichen)
            has_substantial_output = out2.strip() and len(out2.strip()) > 100 and 'nicht_verifiziert' not in out2.lower()
            if (rc2 == 0 and out2.strip()) or (rc2 == 1 and has_substantial_output):
                # Markiere als Web-Antwort mit Hinweis auf Fallback
                return 0, f"{out2.strip()}\n\n(Hinweis: Web-Recherche nicht verfügbar, Antwort basiert auf lokalem Wissen)", ""
        return rc, out, err
    if name == 'url_research':
        return run([str(ROOT / 'bin' / 'research-url-answer'), message], timeout=180)
    if name == 'compare_selfhosted':
        return run([str(ROOT / 'bin' / 'research-compare-selfhosted'), message], timeout=150)
    if name == 'security_plan':
        return run([str(ROOT / 'bin' / 'research-security-plan')], timeout=150)
    if name == 'media_advice':
        low = norm(message)
        mode = 'audiobooks'
        if 'lidarr' in low:
            mode = 'lidarr'
        elif 'emby' in low:
            mode = 'emby'
        return run([str(ROOT / 'bin' / 'ops-media-advice'), mode], timeout=90)
    if name == 'personal_assist':
        return run([str(ROOT / 'bin' / 'personal-local-assist'), message], timeout=150)
    if name == 'dev_build':
        return run([str(ROOT / 'bin' / 'dev-local-assist'), message], timeout=240)
    if name == 'general_answer':
        env = os.environ.copy()
        env['BIBABOT_SELF_CRITIQUE'] = '0'
        env['MAC_OLLAMA_CALL_TIMEOUT_SEC'] = '75'
        env.setdefault('MAC_OLLAMA_MODEL_GENERAL', os.environ.get('BIBABOT_GENERAL_CHAIN', GENERAL_CHAIN_DEFAULT))
        env['MAC_OLLAMA_NUM_CTX_CHAT'] = env.get('MAC_OLLAMA_NUM_CTX_CHAT', '24576')
        return run([str(ROOT / 'bin' / 'general-local-assist'), message], timeout=100, env=env)
    if name == 'ops_exec':
        return run([str(ROOT / 'bin' / 'ops-exec-action'), message], timeout=120)
    if name == 'ops_install':
        return run([str(ROOT / 'bin' / 'ops-install-action'), message], timeout=180)
    if name == 'ops_api':
        return run([str(ROOT / 'bin' / 'ops-api-query'), message], timeout=100)
    if name == 'ops_deep_analyze':
        return run([str(ROOT / 'bin' / 'ops-deep-analyze'), message], timeout=130)
    if name == 'qdrant_search':
        return run([str(ROOT / 'bin' / 'qdrant-context-search'), message], timeout=40)
    if name == 'expert_write':
        return run([str(ROOT / 'bin' / 'expert-write-assist'), message], timeout=180)
    if name == 'expert_code':
        return run([str(ROOT / 'bin' / 'expert-code-assist'), message], timeout=180)
    if name == 'expert_research':
        return run([str(ROOT / 'bin' / 'expert-deep-research'), message], timeout=200)
    if name == 'expert_edit':
        return run([str(ROOT / 'bin' / 'expert-proofread'), message], timeout=180)
    if name == 'expert_strategy':
        return run([str(ROOT / 'bin' / 'expert-strategy-assist'), message], timeout=180)
    if name == 'goals_manage':
        return run([str(ROOT / 'bin' / 'goals-manage'), message], timeout=15)
    if name == 'contacts_manage':
        return run([str(ROOT / 'bin' / 'contacts-manage'), message], timeout=15)
    if name == 'agent_introspect':
        return run([str(ROOT / 'bin' / 'agent-introspect'), 'analyze'], timeout=30)
    if name == 'agent_self_correct':
        return run([str(ROOT / 'bin' / 'agent-self-correct'), 'check', message], timeout=30)
    if name == 'agent_reason':
        return run([str(ROOT / 'bin' / 'agent-reason'), 'start', message, '--max-depth', '10'], timeout=60)
    if name == 'agent_anticipate':
        return run([str(ROOT / 'bin' / 'agent-anticipate'), 'predict', message], timeout=30)
    if name == 'agent_emotion':
        return run([str(ROOT / 'bin' / 'agent-emotion'), 'analyze', message], timeout=30)
    if name == 'agent_simulate':
        return run([str(ROOT / 'bin' / 'agent-simulate'), 'action', message], timeout=45)
    if name == 'agent_synthesize':
        return run([str(ROOT / 'bin' / 'agent-synthesize'), 'solve', message, '--domains', 'computing,homelab'], timeout=60)
    # AUTO-LEARN TRIGGER    if name.startswith("expert_") or name.startswith("kb_"):        import subprocess as _sp        _sp.run([str(ROOT / "bin" / "agent-learn"), "queue", name, "--priority", "5"], capture_output=True)
    return 1, '', f'unknown_tool:{name}'


def synthesize(message: str, analysis: dict, evidence_items: list[dict], memory_ctx: str = '', retrieval_ctx: str = ''):
    role = FINAL_ROLE_MAP.get(analysis.get('role', 'general'), 'general')
    files = []
    analysis_text = ['Orchestrator-Analyse:', f"- role={analysis.get('role')}", f"- task_type={analysis.get('task_type')}", f"- tools={', '.join(analysis.get('tools', []))}"]
    for item in analysis.get('reasoning_focus', [])[:4]:
        analysis_text.append(f'- focus={item}')
    files.append(write_temp('analysis', '\n'.join(analysis_text)))
    mem = memory_ctx or memory_context(message)
    if mem:
        files.append(write_temp('memory', mem))
    if retrieval_ctx:
        files.append(write_temp('retrieval', retrieval_ctx))
    files.append(write_temp('contract', response_contract(analysis)))
    files.append(write_temp('evidence', render_evidence(evidence_items)))
    for idx, item in enumerate(evidence_items, start=1):
        files.append(write_temp(f'tool{idx}', f"Tool: {item.get('tool')}\nKind: {item.get('kind')}\nGrounded: {item.get('grounded')}\n\n{item.get('output') or item.get('error') or '(leer)'}"))
    cmd = [str(LLM_LOCAL), '--role', role]
    for path in files:
        cmd.extend(['--extra-context-file', path])
    cmd.append(message)
    _synth_env = os.environ.copy()
    _synth_env['BIBABOT_SELF_CRITIQUE'] = '0'
    _synth_env['MAC_OLLAMA_CALL_TIMEOUT_SEC'] = '60'
    # Use better synthesis models when expert tools are involved
    _expert_tools = {'expert_write', 'expert_code', 'expert_research', 'expert_edit', 'expert_strategy'}
    _has_expert = any(item.get('tool') in _expert_tools for item in evidence_items)
    if _has_expert:
        _synth_env['MAC_OLLAMA_MODEL_OPS'] = 'gemma3:27b-it-qat,qwen3:30b-a3b,mistral-small3.1:latest'
        _synth_env['MAC_OLLAMA_MODEL_GENERAL'] = 'gemma3:27b-it-qat,lfm2:24b,mistral-small3.1:latest'
    else:
        _synth_env['MAC_OLLAMA_MODEL_OPS'] = 'mistral-small3.1:latest,llama3.1:8b,qwen2.5:3b'
        _synth_env['MAC_OLLAMA_MODEL_GENERAL'] = 'mistral-small3.1:latest,llama3.1:8b,qwen2.5:3b'
    try:
        rc, out, err = run(cmd, timeout=90, env=_synth_env)
    finally:
        for path in files:
            try:
                os.unlink(path)
            except OSError:
                pass
    if rc == 0 and out:
        return out
    if evidence_items:
        return evidence_items[-1].get('output', '') or evidence_items[-1].get('error', '')
    return 'nicht_verifiziert: Kein belastbares Ergebnis erzeugt.'


# ─── Quality Feedback Loop ────────────────────────────────────────────────────

FEEDBACK_TOOLS = {'expert_write', 'expert_code', 'expert_research', 'expert_edit', 'expert_strategy'}

_FEEDBACK_ROLE_MAP = {
    'expert_write':    'write',
    'expert_code':     'code_expert',
    'expert_research': 'research_deep',
    'expert_edit':     'proofread',
    'expert_strategy': 'strategy',
}


def judge_output(message: str, output: str) -> tuple[int, str, str]:
    """Ruft llm-judge auf und gibt (score, critique, improve) zurueck."""
    judge_bin = ROOT / 'bin' / 'llm-judge'
    if not judge_bin.exists():
        return 3, '', ''
    try:
        import json as _json
        rc, out, err = run([str(judge_bin), message[:1500], output[:3500]], timeout=35)
        if rc == 0 and out:
            start = out.find('{')
            end   = out.rfind('}') + 1
            if start >= 0 and end > start:
                d = _json.loads(out[start:end])
                score = max(1, min(5, int(d.get('score', 3))))
                return score, str(d.get('critique', '')), str(d.get('improve', ''))
    except Exception:
        pass
    return 3, '', ''


def refine_output(message: str, role: str, original: str, critique: str, improve: str) -> str:
    """Verbessert die Antwort basierend auf der Qualitaetskritik."""
    orig_ctx = 'Deine erste Antwort (zu verbessern):\n' + original
    crit_ctx = (
        'Qualitaetskritik vom Pruefer:\n'
        'Note: unzureichend\n'
        'Kritik: ' + critique + '\n'
        'Verbesserungspunkte: ' + improve + '\n\n'
        'Erstelle jetzt eine vollstaendige, verbesserte Version deiner Antwort.'
    )
    orig_file     = write_temp('refine_orig',     orig_ctx)
    critique_file = write_temp('refine_critique', crit_ctx)
    try:
        cmd = [str(LLM_LOCAL), '--role', role,
               '--extra-context-file', orig_file,
               '--extra-context-file', critique_file,
               message]
        env = os.environ.copy()
        env['MAC_OLLAMA_MODEL_OPS']        = 'gemma3:27b-it-qat,qwen3:30b-a3b,mistral-small3.1:latest'
        env['MAC_OLLAMA_MODEL_GENERAL']    = 'gemma3:27b-it-qat,lfm2:24b,mistral-small3.1:latest'
        env['MAC_OLLAMA_CALL_TIMEOUT_SEC'] = '90'
        env['BIBABOT_SELF_CRITIQUE']       = '0'
        rc, out, err = run(cmd, timeout=120, env=env)
        if rc == 0 and out and len(out) > 80:
            return out
    except Exception:
        pass
    finally:
        for f in (orig_file, critique_file):
            try:
                os.unlink(f)
            except OSError:
                pass
    return original



def quality_feedback_loop(message: str, analysis: dict, final_text: str, evidence_items: list[dict]) -> str:
    """Bewertet die Ausgabe mit llm-judge; bei Score < 3 wird sie mit dem Originalmodell verfeinert.
    Greift nur fuer expert_* Tools ein, alles andere bleibt unveraendert."""
    used_tools = {item.get('tool') for item in evidence_items}
    if not used_tools & FEEDBACK_TOOLS:
        return final_text
    if not final_text or len(final_text) < 80:
        return final_text

    score, critique, improve = judge_output(message, final_text)
    trace_stage('quality_judge', f'score={score}', f'critique={critique[:60]}')

    if score >= 3:
        # Qualitaet ausreichend — keine Aenderung
        return final_text

    # Score 1 oder 2 → verfeinern
    tool = next((t for t in evidence_items if t.get('tool') in FEEDBACK_TOOLS), {}).get('tool', '')
    role = _FEEDBACK_ROLE_MAP.get(tool, 'general')
    trace_stage('quality_refine_start', f'tool={tool}', f'role={role}')
    refined = refine_output(message, role, final_text, critique, improve)
    trace_stage('quality_refine_done', f'len={len(refined)}')
    return refined


def log_event(message: str, analysis: dict, evidence_items: list[dict], role_hint: str | None):
    try:
        LOG_PATH.parent.mkdir(parents=True, exist_ok=True)
        entry = {
            'ts': datetime.now(timezone.utc).isoformat(),
            'message': message,
            'role_hint': role_hint,
            'analysis': analysis,
            'tools': [item.get('tool') for item in evidence_items],
            'evidence': [
                {
                    'tool': item.get('tool'),
                    'kind': item.get('kind'),
                    'grounded': item.get('grounded'),
                    'rc': item.get('rc'),
                    'summary': item.get('summary'),
                    'confidence': item.get('confidence'),
                }
                for item in evidence_items
            ],
        }
        with LOG_PATH.open('a', encoding='utf-8') as f:
            f.write(json.dumps(entry, ensure_ascii=False) + '\n')
    except Exception:
        pass


AUTO_KB_LEARN = ROOT / "bin" / "auto-kb-learn"


def auto_learn_async(message: str, answer: str):
    """Non-blocking background learning from research tasks."""
    if not AUTO_KB_LEARN.exists():
        return
    try:
        subprocess.Popen(
            [str(AUTO_KB_LEARN), message[:500], answer[:2000]],
            stdout=subprocess.DEVNULL,
            stderr=subprocess.DEVNULL,
            start_new_session=True,
        )
    except Exception:
        pass


def main():
    p = argparse.ArgumentParser()
    p.add_argument('--role-hint', choices=sorted(ROLE_HINTS), default=None)
    p.add_argument('message')
    args = p.parse_args()
    message = normalize_inbound_message(args.message)
    role_hint = args.role_hint

    trace_stage('start', message)
    remember_user_signal(message)
    trace_stage('after_remember_user_signal')
    seed = heuristic_analysis(message, role_hint)
    trace_stage('seed', json.dumps(seed, ensure_ascii=False))
    memory_ctx = memory_context(message, seed)
    trace_stage('memory_ctx', 'yes' if memory_ctx else 'no')
    retrieval_ctx = retrieval_context(message, seed, role_hint)
    trace_stage('retrieval_ctx', 'yes' if retrieval_ctx else 'no')
    playbook_ctx = playbook_context(message, seed)
    retrieval_ctx = append_context(retrieval_ctx, playbook_ctx)
    trace_stage('playbook_ctx', 'yes' if playbook_ctx else 'no')
    if seed.get('confidence', 0.0) >= 0.65 or seed.get('dangerous_action'):
        analysis = normalize_analysis(seed, message, role_hint)
    else:
        raw = analyze_with_llm(message, role_hint, memory_ctx=memory_ctx, retrieval_ctx=retrieval_ctx)
        analysis = normalize_analysis(raw or seed, message, role_hint)
        if not memory_ctx and analysis.get('needs_memory'):
            memory_ctx = memory_context(message, analysis) or memory_ctx
        retrieval_ctx = retrieval_context(message, analysis, role_hint) or retrieval_ctx
        playbook_ctx = playbook_ctx or playbook_context(message, analysis)
        retrieval_ctx = append_context(retrieval_ctx, playbook_ctx)

    plan = None
    if USE_PLAN_FIRST:
        try:
            plan = build_plan(message, analysis, memory_ctx=memory_ctx, retrieval_ctx=retrieval_ctx, playbook_ctx=playbook_ctx)
        except Exception:
            plan = None
    if plan:
        trace_stage('plan_first', json.dumps(plan, ensure_ascii=False))
        analysis = apply_plan_first(analysis, plan)
        if not memory_ctx and analysis.get('needs_memory'):
            memory_ctx = memory_context(message, analysis) or memory_ctx
        refreshed = retrieval_context(message, analysis, role_hint)
        retrieval_ctx = append_context(refreshed or retrieval_ctx, playbook_ctx)
        retrieval_ctx = append_context(retrieval_ctx, render_plan_context(plan))

    if os.environ.get('SUBAGENT_DEBUG', '0') == '1':
        print(json.dumps(analysis, ensure_ascii=False), file=sys.stderr)

    tools = analysis.get('tools', [])
    if not tools:
        tools = ['general_answer']
        analysis['tools'] = tools

    trace_stage('tools', ','.join(tools))
    if len(tools) == 1:
        rc, out, err = run_tool(tools[0], message)
        trace_stage('tool_result', tools[0], f'rc={rc}', f'out={len(out)}', f'err={len(err)}')
        evidence_items = [evidence_object(tools[0], rc, out, err)]

        # Auto-escalate: ops_api found critical issues + user wants solutions → add ops_deep_analyze
        _low = norm(message)
        if (tools[0] == 'ops_api' and rc == 0 and out and
                analysis.get('task_type') in {'diagnose', 'status'} and
                any(k in out.lower() for k in ['unhealthy', 'error', 'exited', 'failed']) and
                re.search(r'(fix|reparier|beheb|wie|was soll|was tun|wie kann|loesung|schritte|warum|analyse)', _low)):
            trace_stage('auto_escalate', 'ops_api→ops_deep_analyze')
            _deep_msg = f"{message}\n\nAPI Daten:\n{out[:800]}"
            _rc2, _out2, _err2 = run_tool('ops_deep_analyze', _deep_msg)
            if _rc2 == 0 and _out2:
                evidence_items = [evidence_object('ops_api', rc, out, err),
                                  evidence_object('ops_deep_analyze', _rc2, _out2, _err2)]
                draft = synthesize(message, analysis, evidence_items, memory_ctx=memory_ctx, retrieval_ctx=retrieval_ctx)
                final, used_outputs = finalize_answer(message, analysis, evidence_items, draft, memory_ctx=memory_ctx, retrieval_ctx=retrieval_ctx)
                final = postprocess_final_answer(message, analysis, final)
                if not should_skip_quality_feedback(analysis, used_outputs):
                    final = quality_feedback_loop(message, analysis, final, used_outputs)
                log_event(message, analysis, used_outputs, role_hint)
                persist_result_state(message, analysis, final, used_outputs)
                if USE_BUENZLI:
                    final = buenzli_response(final)
                record_task_outcome(message, analysis, final, used_outputs, status='success')
                print(final)
                return 0

        log_event(message, analysis, evidence_items, role_hint)
        if rc == 0 and out:
            if can_fast_exit_single_tool(analysis, evidence_items, memory_ctx=memory_ctx, retrieval_ctx=retrieval_ctx):
                final, used_outputs = out, evidence_items
            else:
                final, used_outputs = finalize_answer(message, analysis, evidence_items, out, memory_ctx=memory_ctx, retrieval_ctx=retrieval_ctx)
            log_event(message, analysis, used_outputs, role_hint)
            final = postprocess_final_answer(message, analysis, final)
            if not should_skip_quality_feedback(analysis, used_outputs):
                final = quality_feedback_loop(message, analysis, final, used_outputs)
            persist_result_state(message, analysis, final, used_outputs)
            # Auto-learn from research results
            if tools[0] in {"web_research", "url_research", "compare_selfhosted"} and final and len(final) > 50:
                auto_learn_async(message, final)
            if USE_BUENZLI:
                final = buenzli_response(final)
            record_task_outcome(message, analysis, final, used_outputs, status='success')
            print(final)
            return 0
        if out:
            record_task_outcome(message, analysis, out, evidence_items, status='tool_output_unverified')
            print(out)
            return 0
        fallback_tools = []
        if tools[0] == 'general_answer' and analysis.get('task_type') in {'explain', 'howto'} and '?' in message:
            fallback_tools = ['web_research']
        elif tools[0] == 'web_research':
            fallback_tools = ['general_answer']
        elif tools[0] == 'user_service_access_diagnose':
            fallback_tools = ['setup_lookup']
        for fb in fallback_tools:
            frc, fout, ferr = run_tool(fb, message)
            if frc == 0 and fout:
                merged = evidence_items + [evidence_object(fb, frc, fout, ferr)]
                trace_stage('fallback_tool_result', fb, f'rc={frc}', f'out={len(fout)}', f'err={len(ferr)}')
                final, used_outputs = finalize_answer(message, analysis, merged, fout, memory_ctx=memory_ctx, retrieval_ctx=retrieval_ctx)
                log_event(message, analysis, used_outputs, role_hint)
                final = postprocess_final_answer(message, analysis, final)
                if not should_skip_quality_feedback(analysis, used_outputs):
                    final = quality_feedback_loop(message, analysis, final, used_outputs)
                persist_result_state(message, analysis, final, used_outputs)
                if USE_BUENZLI:
                    final = buenzli_response(final)
                record_task_outcome(message, analysis, final, used_outputs, status='success')
                print(final)
                return 0
        if err:
            record_task_outcome(message, analysis, '', evidence_items, status='tool_failed', error_text=err)
            print(f'nicht_verifiziert: Tool {tools[0]} schlug fehl ({err}).')
            return 1
        record_task_outcome(message, analysis, '', evidence_items, status='no_result')
        print('nicht_verifiziert: Kein belastbares Ergebnis erzeugt.')
        return 1

    # Sequential execution: each tool gets accumulated context from previous steps
    _seq_result = _run_sequential_tools(
        message,
        tools,
        analysis,
        is_complex_task=is_complex_task,
        run_tool=run_tool,
        evidence_object=evidence_object,
        trace_stage=trace_stage,
        sequential_tool_budget=sequential_tool_budget,
        summarize_sequential_context=summarize_sequential_context,
    )
    collected = list(_seq_result.get('collected') or [])
    _failed_ev = _seq_result.get('failed_ev')
    _is_seq = bool(_seq_result.get('is_sequential'))
    if _failed_ev is not None:
        _tool = _failed_ev.get('tool', '')
        _err = _failed_ev.get('error', '') or ('timeout' if _failed_ev.get('rc') == 124 else 'tool_failed')
        record_task_outcome(message, analysis, '', collected, status='tool_failed', error_text=f'{_tool}:{_err}')
        print(f'nicht_verifiziert: Kompositionsschritt {_tool} schlug fehl ({_err}).')
        return 1
    # Skip expensive synthesize when final tool already produced a complete structured answer
    _last_ev = collected[-1] if collected else {}
    _last_out = _last_ev.get('output', '')
    _last_kind = TOOLS.get(_last_ev.get('tool', ''), {}).get('kind', '')
    _prep_direct = bool(analysis.get('composition_reason')) and _last_kind == 'final' and _last_out and all(bool(item.get('grounded')) for item in collected[:-1])
    _light_composed = build_lightweight_composed_answer(message, analysis, collected)
    if _light_composed:
        draft = _light_composed
        trace_stage('synthesize_skipped', 'lightweight_composed_answer')
    elif _is_seq and _last_kind == 'final' and _last_out and (len(_last_out) > 100 or _prep_direct):
        draft = _last_out
        trace_stage('synthesize_skipped', 'final_tool_output_used_directly' if len(_last_out) > 100 else 'composition_final_output_used_directly')
    else:
        draft = synthesize(message, analysis, collected, memory_ctx=memory_ctx, retrieval_ctx=retrieval_ctx)
    trace_stage('after_synthesize', f'draft={len(draft)}')
    final, used_outputs = finalize_answer(message, analysis, collected, draft, memory_ctx=memory_ctx, retrieval_ctx=retrieval_ctx)
    final = postprocess_final_answer(message, analysis, final)
    final = quality_feedback_loop(message, analysis, final, used_outputs)
    log_event(message, analysis, used_outputs, role_hint)
    persist_result_state(message, analysis, final, used_outputs)
    if USE_BUENZLI:
        final = buenzli_response(final)
    record_task_outcome(message, analysis, final, used_outputs, status='success')
    print(final)
    return 0


if __name__ == '__main__':
    raise SystemExit(main())