aura_engine.py

# aura_engine.py
# 20260904_1847
import os
import sys

# == AUTO-BOOTSTRAP ============================================================================
# --- PREREQUISITE 1: VIRTUAL ENVIRONMENT CHECK & AUTO-BOOTSTRAP ---
# Ensures the engine actually runs inside its .venv to avoid dependency issues.
# import scripts.py.bootstrap_venv
# from scripts.py.bootstrap_venv import bootstrap_hello
# bootstrap_hello() # its a dummy hello to prevent removed by linter
# === AUTO-BOOTSTRAP ===========================================================================
from scripts.py.bootstrap_venv import bootstrap_hello

bootstrap_hello()
# === AUTO-BOOTSTRAP ===========================================================================

#from config.settings import LANGUAGETOOL_CHECK_URL
# Python path to ensure reliable imports on all platforms
# This solves potential issues when running from a batch script on Windows
# os.environ["AURA_SELF_TEST_RUNNING"] = "0"
import atexit
import importlib
import logging
import platform
import re
import shutil
import signal
import subprocess
import threading
import time
from datetime import datetime, timedelta
from pathlib import Path

import objgraph
import psutil
import requests

from scripts.py.func import global_state
from scripts.py.func.config.dynamic_settings import settings
from scripts.py.set_secrets_to_DEFAULT_CONTENT import demo_secrets

SECRETS_PATH = Path(".secrets")
demo_secrets()

# PREREQUISITE: Write project root early to prevent import crashes in submodules when the project was moved to other folder

from scripts.py.func.create_required_folders import setup_project_structure
from scripts.py.func.get_project_root import get_aura_project_root

SCRIPT_DIR = Path(__file__).resolve().parent
SL5NET_AURA_PROJECT_ROOT = get_aura_project_root()
setup_project_structure(SL5NET_AURA_PROJECT_ROOT)

TMP_DIR = Path("C:/tmp") if platform.system() == "Windows" else Path("/tmp")
PROJECT_ROOT_FILE = TMP_DIR / "sl5_aura" / "sl5net_aura_project_root"
PROJECT_ROOT_FILE.write_text(str(SL5NET_AURA_PROJECT_ROOT), encoding="utf-8")
os.environ["SL5NET_AURA_PROJECT_ROOT"] = str(SL5NET_AURA_PROJECT_ROOT)

# Clean up search history file on startup for privacy (relevant in windows OS systems)
history_file = TMP_DIR / "sl5_aura" / "search_rules_history.txt"
if history_file.exists():
    try:
        history_file.unlink()
    except Exception as e:
        print(f"Ok. NP. {e}")


if settings.LOG_delete_on_startup:

    log_dir = Path("log")   # folder named "log"
    if not log_dir.is_dir():
        raise SystemExit(f"{log_dir} does not exist or is not a directory")

    setup_log_dir = (log_dir / "setup").resolve()
    for p in log_dir.rglob("*.log"):  # rglob is recursive
        if setup_log_dir in p.resolve().parents:
            continue
        try:
            p.unlink()
        except Exception as e:
            print(f"Failed to remove {p}: {e}")


from scripts.py.func.checks.check_path_length import run_path_check
from scripts.py.func.checks.check_settings_usage import check_settings_usage
from scripts.py.func.checks.espeak_check import espeak_check

espeak_check(settings)

from scripts.py.func.checks.check_settings_syntax import verify_plugin_notation

from scripts.py.func.check_for_updates import check_for_updates


if settings.TRINO_ENABLED:
    from scripts.py.func.db.init_trino_db import init_all as init_trino
    def async_trino_init():
        try:
            init_trino()
        except Exception as e:
            print(f"[AURA ENGINE] WARNING: Failed to initialize Trino database: {e}")
            print("[AURA ENGINE] Database features may be unavailable.")

    trino_thread = threading.Thread(target=async_trino_init, daemon=True)
    trino_thread.start()
    print("[AURA ENGINE] Trino database initialization started asynchronously in the background…")

verify_plugin_notation(settings.PLUGINS_ENABLED)

if getattr(settings, 'KILL_COMPETING_LT_AND_ELOQUENT_ON_START', False):
    os.system("pkill -f 'eloquent'")
    os.system("pkill -f '/app/LanguageTool/languagetool-server.jar'")

if settings.ENABLE_AUTO_LANGUAGE_DETECTION:
    # Check if the package is installed without actually importing it
    if importlib.util.find_spec("fasttext") is None:
        logging.warning("FastText is not installed but is enabled in config.")
        logging.info("At    ting to install 'fasttext-wheel' automatically…")
        try:
            subprocess.check_call([sys.executable, "-m", "pip", "install", "fasttext-wheel"])
            logging.info("INFO: FastText installed successfully. Please restart the service to activate it.")
            sys.exit(0)
        except subprocess.CalledProcessError:
            logging.error("Failed to install FastText. Please install it manually: pip install fasttext-wheel")
            sys.exit(1)
    else:
        logging.info("FastText for auto language detection is available.")



from scripts.py.func.main import main

#from scripts.py.func.notify import notify
#from scripts.py.func.cleanup import cleanup
#from scripts.py.func.start_languagetool_server import start_languagetool_server
#from scripts.py.func.stop_languagetool_server import stop_languagetool_server
#from scripts.py.func.check_memory_critical import check_memory_critical
# We need vosk here for the model loading
# import vosk





# --- Constants and Paths ---




# SL5NET_AURA_PROJECT_ROOT = Path(__file__).resolve().parent



_log_dir = SL5NET_AURA_PROJECT_ROOT / "log"



if not _log_dir.exists():
    shutil.copy(
        PROJECT_ROOT_FILE / 'config' / 'filters' / '.backlock' / 'first_run' / 'settings_local_log_filter.py',
        PROJECT_ROOT_FILE / 'config' / 'filters' / 'settings_local_log_filter.py'
    )






LOG_FILE = SL5NET_AURA_PROJECT_ROOT / "log" / "aura_engine.log"  # NICHT mit Path("log/…") überschreiben! könnte zu leidem äergerlichen unmerkbaren fehlern führen.


AURA_SELF_TEST_RUNNING =TMP_DIR / "sl5_aura" / "aura_self_test_running.flag"






# ==============================================================================
# --- PRE-RUN SETUP VALIDATION ---

# aura_engine.py:123
if str(SL5NET_AURA_PROJECT_ROOT) not in sys.path:
    sys.path.insert(0, str(SL5NET_AURA_PROJECT_ROOT))

    project_root = SL5NET_AURA_PROJECT_ROOT
    sys.path.append(str(project_root))





# We add the 'scripts' directory to the path to import our custom validator.

# sys.path.append(os.path.join(SCRIPT_DIR, 'scripts'))


from scripts.py.func.checks.check_installer_sizes import check_installer_sizes
from scripts.py.func.checks.validate_punctuation_map_keys import (
    validate_punctuation_map_keys,
)

# File: STT/aura_engine.py
# …
# --- Wrapper Script Check ---

    #sys.exit(1)

# ==============================================================================
# ==============================================================================
# ==============================================================================





TRIGGER_FILE = TMP_DIR /  "sl5_record.trigger"
HEARTBEAT_FILE = TMP_DIR / "sl5_aura" / "aura_engine.heartbeat"
PIDFILE = TMP_DIR / "sl5_aura" / "aura_engine.pid"
LOCK_DIR = TMP_DIR / "sl5_aura" / "aura_lock"


# backup settings.x11_input_method_OVERRIDE so linux/mac shell script can read this easier
settings_py_PATH = SL5NET_AURA_PROJECT_ROOT / 'config' / 'settings.py'
settings_py_backup_DIR = TMP_DIR / "sl5_aura" / "settings_py_backup"

settings_py_backup_PATH = TMP_DIR / "sl5_aura" / "settings_py_backup"
backup_settings_x11_input_method_OVERRIDE_PATH = settings_py_backup_PATH / 'x11_input_method_OVERRIDE.txt'


import os

path = backup_settings_x11_input_method_OVERRIDE_PATH
content = settings.x11_input_method_OVERRIDE
# os.makedirs(os.path.dirname(path), exist_ok=True)
with open(path, "w", encoding="utf-8") as f:
    f.write(content)
#
#
# with open(backup_settings_x11_input_method_OVERRIDE_PATH, 'w') as f:
#     f.write(settings.x11_input_method_OVERRIDE)





LANGUAGETOOL_JAR_PATH = SL5NET_AURA_PROJECT_ROOT / settings.LANGUAGETOOL_RELATIVE_PATH






suspicious_events = []
if platform.system() == "Windows":
    NOTIFY_SEND_PATH = None
OUTPUT_FILE = TMP_DIR / "sl5_aura" / "tts_output" / "tts_output.txt"
# logging.info(f"Auto-Zip: ✅ flag set - self-tests running")

HEARTBEAT_FILE = TMP_DIR / "sl5_aura" / "aura_engine.heartbeat"
PIDFILE = TMP_DIR / "sl5_aura" / "aura_engine.pid"
# LOG_FILE = Path("log/aura_engine.log")

# aura_engine.py:253
core_logic_self_test_is_running_FILE = TMP_DIR / "sl5_aura" / "core_logic_self_test_FILE_is_running"


# aura_engine.py:208
SCRIPT_DIR = Path(__file__).resolve().parent
LANGUAGETOOL_JAR_PATH = f"{SCRIPT_DIR}/LanguageTool-6.6/languagetool-server.jar"


if not run_path_check(SL5NET_AURA_PROJECT_ROOT, LOCK_DIR):
    print("\nFATAL: Path too long. See logs above.", file=sys.stderr)
    sys.exit(1)



languagetool_process = None


logging.raiseExceptions = True

class WindowsEmojiFilter1(logging.Filter):
    """
    A logging filter that replaces emojis with text placeholders on Windows.
    This prevents UnicodeEncodeError on older console environments.
    """
    def __init__(self):
        # Emojy resources: .venv/lib/python3.13/site-packages/rich/_emoji_codes.py
        super().__init__()
        self.replacements = {
            '⚠️': '[WARN]',
            '✅': '[OK]',
            '👍': '[OK]',
            '👎': '[NO]',
            '🎊': 'CONFETTI',
            '❌': '[FAIL]',
            '🎬': '[START]',
            '⏹️': '[STOP]',
            '🎤': '[MIC]',
            '🎙️': '[MIC]',
            '📢️': '[MIC]',
            '💾': '[SAVE]',
            '📋': '[EMPTY]',
            '🔳': '[NOTHING]',
            "👀": '[EYES]',
            '🚀': '[ROCKET]',
            '🔁':'REPLACE',
            '📚':'BOOK',
            '⌚': '[(-)]',  # clock
            '🗺️':'MAP',
            '🍒':'cherries'
        }

        # Fancy text symbols˗ˏˋ꒰ 🍒 ꒱ˏˋ°•*⁀ ༊*·˚⋆·˚ ༘ *・ ・ೃ⁀ ⇢ ˗ˏˋ*ೃ༄︶︶༉‧₊˚.♡ ༉‧₊˚ੈ ‧₊˚☄. *. ⋆: ̗̀ …


    def filter(self, record):
        # Only perform replacement if running on Windows
        #if os.name == 'nt':
        if platform.system() == "Windows":
            for emoji, text in self.replacements.items():
                record.msg = record.msg.replace(emoji, text)
        return True

class WindowsEmojiFilter(logging.Filter):
    """
    A logging filter that replaces emojis with text placeholders on Windows.
    This prevents UnicodeEncodeError on older console environments.
    """

    def __init__(self):
        super().__init__()
        self.replacements = {
            '🚀': '[▲]',
            '🔁': '[⟳]',
            '📚': '[▉]',
            '❌': '[■]',
            '⚠️': '[!]',
            '✅': '[✓]',
            '👍': '[OK]',
            '👎': '[NO]',
            '🎊': '[*]',
            '❌': '[x]',  # noqa: F601
            '🎬': '[>]',  # Start, Play
            '⏹️': '[■]',
            '🚫️': '[■]',
            '🏁': '[>]',  # Start
            '🔵': '●',
            '🎤': '[◉]',
            '🎙️': '[▣]',
            '📢️': '[≡]',
            '💾': '[¥]',
            '📋': '[‗]',
            '🔳': '[□]',
            "👀": '[o_o]',
            '🚀': '[▲]',
            '🔁': '[⟳]',
            '📚': '[▉]',
            '⌚': '[(-)]',
            '🗺️':'▀▄▀'
        }
        # ▣▣■
        # '🚀': '[>>>]',


    def filter(self, record):
        # Only perform replacement if running on Windows
        #if os.name == 'nt':
        if platform.system() == "Windows":
            for emoji, text in self.replacements.items():
                record.msg = record.msg.replace(emoji, text)
        return True



# aura_engine.py:268

logger = logging.getLogger()

check_for_updates(logger)

# class PrintToConsoleAndFile(object):
#     def __init__(self, logger):
#         self.logger = logger
#         self.terminal = sys.__stdout__ # Das echte Terminal sichern
#
#     def write(self, buf):
# 1. Write to Console Immediately (Guaranteed!)
#         with self._lock:
#            self.terminal.write(buf)
#         self.terminal.flush()
#
#         # 2. Danach ins Logfile senden
#         if buf.strip():
#             try:
# Here we only use the logger for the file
# (If the ConsoleHandler is still active, it could happen twice,
# but better twice than not at all)
#                 self.logger.info(buf.rstrip())
#             except:
#                 pass
#
#     def flush(self):
#         self.terminal.flush()

# aura_engine.py:371
from config.filters.settings_local_log_filter import LOG_EXCLUDE, LOG_ONLY

LOG_FILTER_COMPILED_LOG_ONLY = [re.compile(p) for p in LOG_ONLY]
LOG_FILTER_COMPILED = [re.compile(p) for p in LOG_EXCLUDE]
LOG_FILTER_SETTINGS_PATH = os.path.join(os.path.dirname(__file__), "config", "filters", "settings_local_log_filter.py")
LOG_FILTER_CHECK_INTERVAL_MIN = 4
LOG_FILTER_CHECK_INTERVAL_MAX = 10
LOG_FILTER_CHECK_INTERVAL_STEP = 2
LOG_FILTER_current_interval = LOG_FILTER_CHECK_INTERVAL_MIN

LOG_FILTER_last_modified = os.path.getmtime(LOG_FILTER_SETTINGS_PATH)
LOG_FILTER_last_checked = time.monotonic()

def LOG_FILTER_refresh_if_needed():
    global LOG_FILTER_COMPILED, LOG_FILTER_COMPILED_LOG_ONLY
    global LOG_FILTER_last_modified, LOG_FILTER_last_checked
    global LOG_FILTER_current_interval

    now = time.monotonic()
    if now - LOG_FILTER_last_checked < LOG_FILTER_current_interval:
        return

    LOG_FILTER_last_checked = now

    current_mtime = os.path.getmtime(LOG_FILTER_SETTINGS_PATH)
    if current_mtime != LOG_FILTER_last_modified:
        from importlib import reload

        import config.filters.settings_local_log_filter as settings202603030531
        reload(settings202603030531)

        LOG_FILTER_COMPILED_LOG_ONLY = [re.compile(p) for p in settings202603030531.LOG_ONLY]
        LOG_FILTER_COMPILED = [re.compile(p) for p in settings202603030531.LOG_EXCLUDE]
        LOG_FILTER_last_modified = current_mtime

        # Änderung erkannt → reset für schnelle Folgeupdates
        LOG_FILTER_current_interval = LOG_FILTER_CHECK_INTERVAL_MIN
    else:
        # Keine Änderung → Intervall erhöhen bis Max
        LOG_FILTER_current_interval = min(
            LOG_FILTER_current_interval + LOG_FILTER_CHECK_INTERVAL_STEP,
            LOG_FILTER_CHECK_INTERVAL_MAX
        )

class SafeStreamToLogger:
    def __init__(self, logger, original_stream, file_handler):
        self.logger = logger
        self.terminal = original_stream
        self.file_handler_ref = file_handler               # <--- HIER speichern
        self.is_logging = False # <--- DER SCHUTZSCHALTER
        self._lock = threading.Lock()
        self.log_pattern = re.compile(r'^\d{2}:\d{2}:\d{2},\d{3}\s-\s[A-Z]+\s+-\s')

    def write(self, buf):

        # self.terminal.write(f"DEBUG_STDOUT 2026-0228-1533: {buf}")

        LOG_FILTER_refresh_if_needed()

        if LOG_FILTER_COMPILED_LOG_ONLY:
            if not any(p.search(buf) for p in LOG_FILTER_COMPILED_LOG_ONLY):
                return
            # 1. shorten letts like #### or somthing. not needed here anymore as aye-catcher.
            buf = re.sub(r"(.)\1{3,}", r"\1\1\1", buf)


        elif any(p.search(buf) for p in LOG_FILTER_COMPILED):
            return

        # global core_logic_self_test_is_running_FILE
        is_core_logic_self_test_is_running = core_logic_self_test_is_running_FILE.exists()
        # is_core_logic_self_test_is_running = False

        # 1. Always write to the console immediately (visible to you)


        if is_core_logic_self_test_is_running and ':st:' not in buf : # and buf[:3] == 'st:':
            return
            buf = f'ööööööööööööööööööööööööööööööööööööööö {buf} ääääääääääääääääääääääääääääääääääääääääääääää\n'
            buf = f'ööööööööööööööööööööööööööööööööööööööö {buf} ääääääääääääääääääääääääääääääääääääääääääääää\n'
            buf = f'ööööööööööööööööööööööööööööööööööööööö {buf} ääääääääääääääääääääääääääääääääääääääääääääää\n'
            buf = f'ööööööööööööööööööööööööööööööööööööööö {buf} ääääääääääääääääääääääääääääääääääääääääääääää\n'
            # return

        with self._lock:
            self.terminal.write(buf)
            # self.terminal.flush() <-- BESSER SO (Spart CPU/Zeit)

            # 2. If we are NOT logging, then send to the file
            # if not self.is_logging and buf.strip():
            if buf and not buf.isspace() and not self.is_logging:
                self.is_logging = True # Schalter an
                try:

                    # st:

                    # Check: Does the text already have a timestamp?
                    match = self.log_pattern.match(buf)

                    if match:
                        # JA: We're cutting out the timestamp at the front!
                        # match.end() ist die Stelle, wo der echte Text anfängt.
                        clean_msg = buf[match.end():].rstrip()
                    else:
                        # NO: We take the text as it is (e.g. from print)
                        clean_msg = buf.rstrip()



                    # Only write if there is still text left
                    if clean_msg:


                        record = logging.LogRecord(
                            name="PRINT", level=logging.INFO, pathname="print", lineno=0,
                            msg=clean_msg, args=(), exc_info=None
                        )
                        self.file_handler_ref.handle(record)

                except Exception as e202602281506:
                    print(f'lets ignore e202602281506: {e202602281506}')
                finally:
                    self.is_logging = False

    def flush(self):
        # self.terminal.flush() # entfernen spart viel Zeit. Erfüllt die Pflicht
        pass

# sys.stdout = SafeStreamToLogger(logger, sys.__stdout__)






# Aktivieren
# sys.stdout = PrintToConsoleAndFile(logger)




# sys.stdout = StreamToLogger(logger, logging.INFO) # print -> Logger
# sys.stderr = StreamToLogger(logger, logging.ERROR) # Fehler -> Logger



# 304
logger.setLevel(logging.INFO)

# Clear any pre-existing handlers to prevent duplicates.
if len(logger.handlers) > 0:
    logger.handlers.clear()

# Create a shared formatter with the custom formatTime function.
def formatTime(record, datefmt=None):
    time_str = time.strftime("%H:%M:%S")
    milliseconds = int((record.created - int(record.created)) * 1000)
    ms_str = f",{milliseconds:03d}"
    return time_str + ms_str


# 1. We create a Filter class
class DittoFilter(logging.Filter):
    def __init__(self):
        super().__init__()
        self.last_msg = None

    def filter(self, record):
        # Den "echten" Inhalt der aktuellen Nachricht holen
        current_msg = record.getMessage()

        # compare with saved original message
        if current_msg == self.last_msg:
            # Es ist eine Wiederholung -> Text für die Ausgabe ändern
            record.msg = "〃"
            record.args = ()

            # IMPORTANT: We DO NOT update self.last_msg HERE.
            # We want the next line to still be with
            # dem Original (z.B. "Verbindung…") vergleicht und
            # not with the goosefoot ("〃").
        else:
            # Es ist eine neue Nachricht -> Speicher aktualisieren
            self.last_msg = current_msg

        return True


# Filter instanziieren
ditto_filter = DittoFilter()



# log_formatter = logging.Formatter('%(asctime)s - %(levelname)-8s - %(message)s')

log_formatter = logging.Formatter('%(asctime)s - %(threadName)s - %(levelname)s - %(message)s')

log_formatter.formatTime = formatTime

# Create, configure, and add the File Handler.


# aura_engine.py:594
class FlushingFileHandler(logging.FileHandler):
    def emit(self, record):
        try:
            super().emit(record)
            self.flush() # Zwingt den Inhalt sofort auf die Platte
        except Exception:
            self.handleError(record)






# file_handler = logging.FileHandler(f'{SCRIPT_DIR}/log/aura_engine.log', mode='a', encoding='utf-8')
# Use this new handler
file_handler = FlushingFileHandler(
    f'{SCRIPT_DIR}/log/aura_engine.log',
    mode='a',
    encoding='utf-8'
)


file_handler.setFormatter(log_formatter)

# logger.addFilter(ditto_filter)


sys.stdout = SafeStreamToLogger(logger, sys.__stdout__, file_handler)



# Create, configure, and add the Console Handler.
# console_handler = logging.StreamHandler(sys.stdout) # send it in the redirection
console_handler = logging.StreamHandler(sys.__stdout__)

console_handler.setFormatter(log_formatter)
#console_handler.addFilter(ditto_filter)




# aura_engine.py:636
# Add the WindowsEmojiFilter to the file_handler
if True:

    logger.addFilter(ditto_filter)
    logger.addHandler(file_handler)
    logger.addHandler(console_handler)

    # logger.addHandler(console_handler)
    # logger.addFilter(WindowsEmojiFilter())
    # logger.addFilter(ditto_filter)
else:
    logger.addHandler(file_handler)

    console_handler.addFilter(WindowsEmojiFilter())
    console_handler.addFilter(ditto_filter)
    file_handler.addFilter(WindowsEmojiFilter())
    file_handler.addFilter(ditto_filter)

# file_handler.addFilter(WindowsEmojiFilter())
# file_handler.addFilter(ditto_filter)


# if settings.DEV_MODE and settings.current_user == 'seeh':
    # for testing often a clean log helpss
    # aura_log = Path('log/aura_engine.log')
    # aura_log.unlink(missing_ok=True) ## seems problematic


DISABLE_ALL_TEST_QuickStopTestsForSomeReasons = False
# DISABLE_ALL_TEST_QuickStopTestsForSomeReasons = True

if settings.DEV_MODE and DISABLE_ALL_TEST_QuickStopTestsForSomeReasons :
    print(f'Hi DEV. BTW DISABLE_ALL_TEST_QuickStopTestsForSomeReasons is {DISABLE_ALL_TEST_QuickStopTestsForSomeReasons}')

global_state.LOGGING_ENABLED = settings.LOG_in_selftest

readme = """
vosk-model-small-de-0.15
17:36:26,230 - INFO     - >>> Core Logic Self-Test PASSED.
17:36:36,138 - INFO     - ==    ✅ MODEL READY: 'small'.
==> 10 Seconds Sekunden

vosk-model-de-0.21
    ✅ MODEL READY: 'de'.
13:27:52,772 - INFO     - >>> Core Logic Self-Test PASSED.
13:29:09,816 - INFO     - self_tester.py:216 ✅  89tested of 98 tests (lang=de-DE)
==> ~70 Seconds Sekunden


"""


if settings.SERVICE_START_OPTION > 1:
    # Option 1: Start the service only on autostart (start parameter) and if there is an internet

    def check_internet_connection(host='https://sl5.de'):
        if os.getenv('CI'):
            logger.info("CI environment detected. Skipping microphone-dependent recording.")
            return True  # Pretend internet is available for CI

        if host.startswith(('http://', 'https://')):
            host = host.split('//')[1]
        # Use 'ping -n 1' on Windows and 'ping -c 1' on other OS
        # The '-n 1' and '-c 1' options specify the number of echo requests to send
        param = '-n' if platform.system().lower() == 'windows' else '-c'
        try:
            # The subprocess.run function executes the ping command
            # It waits for the command to complete and returns a CompletedProcess object
            subprocess.run(
                ['ping', param, '1', host],
                check=True,  # This will raise a CalledProcessError if the command fails
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE
            )
            print(f"Internet connection is available. Successfully pinged {host}.")
            return True
        except subprocess.CalledProcessError:
            print(f"No internet connection. Failed to ping {host}.")
            return False
        except FileNotFoundError:
            print("The 'ping' command was not found. Please ensure it's in your system's PATH.")
            return False

    if not check_internet_connection():
        m = "Service will not start due to no internet connection."
        print(m)
        logging.info(m)

        if settings.SERVICE_START_OPTION == 11:
            m = "System will reboot in 8 seconds."
            print(m)
            logging.info(m)
            time.sleep(8)
            os.system('reboot')
            os.system('sudo systemctl restart systemd')
        else:
            sys.exit(1)


# Execute the check. The script will exit here if the setup is incomplete.

if settings.DEV_MODE :





    validate_punctuation_map_keys(SCRIPT_DIR,logger)

    project_root = SCRIPT_DIR


if settings.DEV_MODE :

    check_settings_usage()

    try:
        # Create a copy of the current environment and set PYTHONPATH
        env = os.environ.copy()
        env['PYTHONPATH'] = '.'

        subprocess.run(
            [sys.executable, "scripts/py/func/checks/test_dictation_session_logic.py"],
            check=True,
            cwd=SCRIPT_DIR,
            env=env
        )
        logger.info(">>> Core Logic Self-Test PASSED.")
    except subprocess.CalledProcessError:
        logger.critical(">>> Core Logic Self-Test FAILED. Aborting service start.")
        sys.exit(1)



# ==============================================================================
# --- Wrapper Script Check ---
# if not DEV_MODE and os.environ.get("DICTATION_SERVICE_STARTED_CORRECTLY") != "true":
#     logger.fatal("FATAL: This script must be started using the 'activate-venv_and_run-server.sh' wrapper.")
#     sys.exit(1)
# ==============================================================================



from scripts.py.func.audio_manager import stop_audio_manager
from scripts.py.func.cleanup import cleanup
from scripts.py.func.guess_lt_language_from_model import guess_lt_language_from_model
from scripts.py.func.notify import notify
from scripts.py.func.start_languagetool_server import (
    LT_ALREADY_RUNNING_SENTINEL,
    start_languagetool_server,
)

# from scripts.py.func.stop_languagetool_server import stop_languagetool_server
# from scripts.py.func.transcribe_audio_with_feedback import transcribe_audio_with_feedback
# from scripts.py.func.check_memory_critical import check_memory_critical
from scripts.py.func.stop_languagetool_server import stop_languagetool_server

# aura_engine.py:809
files_to_clean = [HEARTBEAT_FILE, PIDFILE, TRIGGER_FILE]
atexit.register(lambda: cleanup(logger, files_to_clean))
atexit.register(lambda: stop_languagetool_server(logger, languagetool_process))
atexit.register(stop_audio_manager)

with open(PIDFILE, 'w') as f:
    f.write(str(os.getpid()))



# AURA_TMP = TMP_DIR / "sl5_aura"
# aura_project_root_path = Path( AURA_TMP / "aura_project_root.path")
# with open(aura_project_root_path, 'w') as f:
#     f.write(str(SL5NET_AURA_PROJECT_ROOT))




# --- Argument Parsing und Model-Setup ---
MODEL_NAME_DEFAULT = "vosk-model-de-0.21" # fallback

SCRIPT_DIR = Path(__file__).resolve().parent

""""
parser = argparse.ArgumentParser(description="A real-time dictation service using Vosk.")
parser.add_argument('--vosk_model', help=f"Name of the Vosk model folder. Defaults to '{MODEL_NAME_DEFAULT}'.")
parser.add_argument('--test-text', help="Bypass microphone and use this text for testing.")
args = parser.parse_args()
VOSK_MODEL_FILE = SCRIPT_DIR / "config/model_name.txt"
vosk_model_from_file = Path(VOSK_MODEL_FILE).read_text().strip() if Path(VOSK_MODEL_FILE).exists() else ""
MODEL_NAME = args.vosk_model or vosk_model_from_file or MODEL_NAME_DEFAULT

"""


"""
31.10.'25 22:09 Fri
22:07:36,080 - INFO     - Graceful shutdown initiated. Final timeout set to 2.0s.
22:07:36,484 - WARNING  - SYSTEM-MEMORY CRITICAL! Usage: 92.00440896261489%. Exceeds threshold. Terminating entire process group 82694.BTW: ramUsageIncreadFromBegining: 1.0818119049072266 times
"""


SYSTEM_RAM_THRESHOLD_PERCENT = 92.0
SYSTEM_SWAP_THRESHOLD_PERCENT = 85.0 # this is deprecated. idk. seems not working like expected. dont use it.

RAM_ESTIMATE_PER_MODEL_GB = 4.0 # plus some other needed space for the model
GB_TO_MB_CONVERSION_FACTOR = 1024

# aura_engine.py:404























# --- SETUP FOR DEDICATED MEMORY LOGGING ---
# Define the path for the memory log file
MEMORY_LOG_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'log/memory_leak_analysis.log')

# Initialize a dedicated logger for memory events
memory_logger = logging.getLogger('MemoryAnalyzer')



# Fügen Sie dies vor der Konfiguration des memory_logger hinzu:

# aura_engine.py:708
if os.path.exists(MEMORY_LOG_PATH):
    # Get last modification time
    mtime_ts = os.path.getmtime(MEMORY_LOG_PATH)
    log_date = datetime.fromtimestamp(mtime_ts).date()
    # If the log file is not from today, delete it
    if log_date < datetime.now().date():
        # os.remove(MEMORY_LOG_PATH)
        try:
            if os.path.exists(MEMORY_LOG_PATH):
                # Truncate the file instead of removing it to avoid WinError 32
                with open(MEMORY_LOG_PATH, 'w'):
                    pass
        except PermissionError:
            logger.warning(f"Could not clear {MEMORY_LOG_PATH} - file is locked. May Ctrl+Alt+Def and delete alle Python processes")
            logger.warning('Prüfe im Task-Manager, ob noch eine alte python.exe im Hintergrund läuft, die die Logdatei blockiert.')




        memory_logger.info("Old memory log file deleted.")







# Ensure the logger hasn't already been configured by accident (common in Python)
if not memory_logger.handlers:
    memory_logger.setLevel(logging.INFO)
    file_handler = logging.FileHandler(MEMORY_LOG_PATH, encoding="utf-8")
    file_handler.setFormatter(logging.Formatter('%(asctime)s - %(threadName)s - %(message)s'))

    memory_logger.addHandler(file_handler)
    # Prevent propagation to the root logger which might write to stdout/stderr
    memory_logger.propagate = False


def memory_leak_analyzer(interval_seconds=600, significant_growth_threshold=100):
    """
    Periodically logs the growth of the largest Python objects to a dedicated file
    to diagnose memory leaks. Runs indefinitely as a daemon thread.
    """
    memory_logger.info("logger.info('Memory Leak Analyzer started. Initializing object counts.')")

    process = psutil.Process(os.getpid())
    current_memory_mb = process.memory_info().rss / (1024 * 1024)

    memory_logger.info(f"System Process Memory (RSS): {current_memory_mb:.2f} MB")

    # Store initial counts of all objects to track growth accurately
    try:
        initial_counts = objgraph.most_common_types(limit=None, shortnames=False)
        initial_dict = {item[0]: item[1] for item in initial_counts}
    except Exception as e1:
        memory_logger.error(f"logger.info('Failed to get initial object counts: {e1}')")
        return  # Stop if initial check fails

    memory_logger.info(
        f"logger.info('Analysis interval set to {interval_seconds} seconds. Growth threshold: {significant_growth_threshold} objects.')")

    while True:
        try:
            time.sleep(interval_seconds)

            # 1. Get current process memory usage (as reported by OS)
            process = psutil.Process(os.getpid())
            current_memory_mb = process.memory_info().rss / (1024 * 1024)

            # 2. Get current Python object counts (top 30 to catch most issues)
            current_counts = objgraph.most_common_types(limit=30, shortnames=False)

            memory_logger.info("--- MEMORY SNAPSHOT ---")
            memory_logger.info(f"System Process Memory (RSS): {current_memory_mb:.2f} MB")

            # 3. Compare current counts to initial and log significant growth
            growth_found = False
            for type_name, count in current_counts:
                initial_count = initial_dict.get(type_name, 0)
                count_increase = count - initial_count

                # Only log objects that have grown significantly
                if count_increase > significant_growth_threshold:
                    memory_logger.info(
                        f"GROWTH DETECTED: {type_name}: Current={count} | Growth={count_increase}")
                    growth_found = True

            if not growth_found:
                memory_logger.info("logger.info('No significant object growth detected in top 30 types.')")
            memory_logger.info("---------------------")

        except Exception as e2:
            memory_logger.error(f"Analyzer loop encountered an error: {e2}")
            time.sleep(60)  # Short pause before continuing the loop


# --- INTEGRATION STEP ---
# This line must be added to your main application startup sequence (e.g., main.py or similar):

# To run it in parallel (similar to your existing watchdog):
if settings.DEV_MODE:
    threading.Thread(target=memory_leak_analyzer, daemon=True).start()


























parsed_trees = None
def system_memory_watchdog(logging):

    logging.info(f"System Memory 👀 Watchdog started. Threshold: {SYSTEM_RAM_THRESHOLD_PERCENT}%")

    process = psutil.Process(os.getpid())

    num_preloaded_models = len(settings.PRELOAD_MODELS)

    #estimated_total_size_mb = file_size_bytes / (1024 * 1024)
    estimated_ram_for_models_mb = num_preloaded_models * RAM_ESTIMATE_PER_MODEL_GB * GB_TO_MB_CONVERSION_FACTOR

    # Cross-platform call - use getpgrp only on non-Windows systems
    import sys
    my_pgid = None
    if not sys.platform.startswith('win'):
        try:
            my_pgid = os.getpgrp()
            logging.info(f"System Memory 👀 Watchdog is running on Unix-like system with pgid: {my_pgid}")
        except AttributeError:
            # Fallback in case os.getpgrp is still missing for some reason
            pass




    if True:
        # 2. Get Swap Memory just for information
        swap_info = psutil.swap_memory()
        current_swap_percent = swap_info.percent

        ram_info = psutil.virtual_memory()
        current_ram_percent = ((ram_info.total - ram_info.available) / ram_info.total) * 100

        log_msg = (
            f"SYSTEM-MEMORY Usage: {current_ram_percent:.1f}% (>{SYSTEM_RAM_THRESHOLD_PERCENT}%) "
            f"current_swap_percent: {current_swap_percent:.1f}% (>{SYSTEM_SWAP_THRESHOLD_PERCENT}%). "
        )


    while True:
        # get the real RAM-usages
        # current_memory_percent = psutil.virtual_memory().percent

        # 1. Get Physical RAM
        ram_info = psutil.virtual_memory()
        current_ram_percent = ((ram_info.total - ram_info.available) / ram_info.total) * 100

        # 2. Get Swap Memory
        # swap_info = psutil.swap_memory()
        # current_swap_percent = swap_info.percent

        # current_swap_percent seems not working in my tests sadly

        # and current_swap_percent > SYSTEM_SWAP_THRESHOLD_PERCENT
        if current_ram_percent > SYSTEM_RAM_THRESHOLD_PERCENT:

            # Create a detailed log message that shows WHY the shutdown is happening
            log_msg = (
                f"SYSTEM-MEMORY CRITICAL! RAM Usage: {current_ram_percent:.1f}% (>{SYSTEM_RAM_THRESHOLD_PERCENT}%) "
                # f"AND Swap Usage: {current_swap_percent:.1f}% (>{SYSTEM_SWAP_THRESHOLD_PERCENT}%). "
            )
            logging.warning(log_msg)

            ram_occupied_by_this_specific_process_mb =  process.memory_info().rss / (1024 * 1024)
            ramUsageIncreadFromBegining = ram_occupied_by_this_specific_process_mb / estimated_ram_for_models_mb
            if ram_occupied_by_this_specific_process_mb >= 1.3 * estimated_ram_for_models_mb: # 1.2 or higher is maybe a good value
                logging.error(
                    f"memoryLECK! "
                    f"Process-RAM {estimated_ram_for_models_mb:.2f} MB now {ram_occupied_by_this_specific_process_mb:.2f} MB")

                script_name = None
                if sys.platform.startswith('win'):
                    script_name = 'restart_venv_and_run-server.ahk'
                elif sys.platform in ["linux", "darwin"]:
                    script_name = 'restart_venv_and_run-server.sh'
                else:
                    logging.warning(f"restart for '{sys.platform}' not suported.")

                if script_name:
                    restart_script_path=''
                    try:
                        restart_script_path = os.path.join(SL5NET_AURA_PROJECT_ROOT, 'scripts', script_name)
                        logging.info(f"restart in '{sys.platform}' using  {restart_script_path}")
                        subprocess.Popen([restart_script_path], shell=True) # shell=True ist für Windows sicherer
                        logging.info("Prozess will end, hope it helps restarting.")
                        sys.exit(0)

                    except FileNotFoundError:
                        logging.error(f"restart-Skript not found: {restart_script_path}")
                    except Exception as e:
                        logging.error(f"error when try restart: {e}")





            logging.warning(
                f"SYSTEM-MEMORY CRITICAL! Usage: {current_ram_percent}%. "
                f"ram_occupied_by_this_specific_process_mb: {ram_occupied_by_this_specific_process_mb}%. "
                f"Exceeds threshold. Terminating entire process group {my_pgid}."
                f"BTW: ramUsageIncreadFromBegining: {ramUsageIncreadFromBegining} times"


            )
            try:
                # os.killpg(my_pgid, signal.SIGKILL)

                # logger.info("🚨 MEMORY CRITICAL! Initiating emergency shutdown.")

                # aura_engine.py
                if sys.platform == "win32":
                    # WINDOWS: Use taskkill to kill the process tree (/T) forcefully (/F)
                    # This simulates killpg behavior on Windows.
                    subprocess.run(["taskkill", "/F", "/T", "/PID", str(os.getpid())],
                                   stdout=subprocess.DEVNULL,
                                   stderr=subprocess.DEVNULL)
                else:
                    # LINUX / MACOS: Use standard killpg
                    os.killpg(my_pgid, signal.SIGKILL)



            except ProcessLookupError:
                pass

        time.sleep(2)


watchdog_thread = threading.Thread(target=system_memory_watchdog, args=(logger,), daemon=True)
watchdog_thread.start()









TRIGGER_FILE.unlink(missing_ok=True)

suspend_flag = (Path("C:/tmp") if platform.system() == "Windows" else Path(
    "/tmp")) / "sl5_aura" / "aura_vosk_suspended.flag"

suspend_flag.unlink(missing_ok=True)


# MODEL_PATH = SCRIPT_DIR / "models" / MODEL_NAME

# import scripts.py.func.guess_lt_language_from_model

# LT_LANGUAGE = guess_lt_language_from_model(MODEL_NAME)




active_lt_url = None

if settings.USE_EXTERNAL_LANGUAGETOOL:
    logger.warning(f"USING EXTERNAL LT SERVER: {settings.EXTERNAL_LANGUAGETOOL_URL}. AT YOUR OWN RISK.")
    active_lt_url = settings.EXTERNAL_LANGUAGETOOL_URL
    # PING-TEST:
    try:
        requests.get(f"{active_lt_url}/v2/languages", timeout=3)
        logger.info("External LanguageTool server is responsive.")
    except requests.exceptions.RequestException:
        logger.fatal("External LanguageTool server did not respond. Is it running?")
        sys.exit(1)
else:
    SL5NET_AURA_PROJECT_ROOT = Path(__file__).resolve().parent
    jar_path_absolute = SL5NET_AURA_PROJECT_ROOT / settings.LANGUAGETOOL_RELATIVE_PATH
    internal_lt_url = f"http://localhost:{settings.LANGUAGETOOL_PORT}"

    logger.info(f"start_languagetool_server(logger, …{str(jar_path_absolute)[-30:]}, {internal_lt_url})")

    # aura_engine.py:1176
    languagetool_process = start_languagetool_server(logger, jar_path_absolute, internal_lt_url, for_self_test=False)

    # NEU/CHANGE: Register atexit ONLY if a real process was started
    if languagetool_process and languagetool_process is not LT_ALREADY_RUNNING_SENTINEL:
        atexit.register(lambda: stop_languagetool_server(logger, languagetool_process))

    # if not languagetool_process: sys.exit(1)
    # atexit.register(lambda: stop_languagetool_server(logger, languagetool_process))

    # aura_engine.py:760
    # active_lt_url = f"http://localhost:{settings.LANGUAGETOOL_PORT}/v2/check"
    active_lt_url = f"{settings.LANGUAGETOOL_CHECK_URL}"

if not languagetool_process:
    logger.error("=" * 80)
    logger.error("🚨 CRITICAL STARTUP WARNING: LanguageTool Server failed to start or connect.")
    logger.error("To resolve this issue on Windows:")
    logger.error("  1. Ensure Java (java.exe) is installed and available in your system PATH.")
    logger.error(f"  2. Ensure port {settings.LANGUAGETOOL_PORT} is not blocked or in use by another application.")
    logger.error("=" * 80)
    notify("Aura Startup Warning", "LanguageTool Server failed to start.", "warning")

    # Safe acoustic warning
    try:
        from scripts.py.func.audio_manager import speak_inclusive_fallback

        speak_inclusive_fallback("wait for Language Tool", "en-US")
    except Exception as tts_err:
        logger.warning(f"Could not speak LanguageTool warning: {tts_err}")

    # Bypassed exit to allow graceful startup without LanguageTool
    # sys.exit(1)

# print(f'settings.DEV_MODE={settings.DEV_MODE}')
# sys.exit(1)


VOSK_MODEL_FILE = SCRIPT_DIR / "config/model_name.txt"
vosk_model_from_file = Path(VOSK_MODEL_FILE).read_text().strip() if Path(VOSK_MODEL_FILE).exists() else ""
lang_code = guess_lt_language_from_model(logger, vosk_model_from_file)

logger.info(f"lang_code: {lang_code}")

if os.getenv('CI'):
    logger.info("CI environment detected. Skipping Welcome Wizard 🧙")
elif settings.SHOW_SEARCH_ON_STARTUP:
    logger.info("aura_engine.py:1183 show Welcome Wizard 🧙 ")
    if settings.DEV_MODE:
        logger.info(f"DISPLAY={os.getenv('DISPLAY')} | XAUTH={os.getenv('XAUTHORITY')} | DBUS={os.getenv('DBUS_SESSION_BUS_ADDRESS')} ")

    try:
        from scripts.py.welcome_wizard.main import run_wizard
        run_wizard(lang_code)
    except Exception as e:
        logger.warning(f"1: Aura Welcome Wizard 🧙 err: {e}")
        logger.info(f"2: Aura Welcome Wizard 🧙 err: {e}")

if getattr(settings, "copy_zip_files_when_source_newer", False):
    from tools.copy_zip_files_when_source_newer import copy_zip_files_when_source_newer
    copy_zip_files_when_source_newer()

if settings.DEV_MODE:
    from scripts.py.func.checks.check_all_maps_syntax import check_folder_syntax
    from scripts.py.func.log_memory_details import log4DEV, log_memory_details

    check_folder_syntax(SCRIPT_DIR / 'config' ) # should also work for useer without git … for normal users


    # from scripts.py.func.checks.live_reload_e2e_func_test import run_e2e_live_reload_func_test_v2
    # run_e2e_live_reload_func_test_v2(logger, active_lt_url)
    readme = """ 3.8.'26 15:58 Mon
    Disable flaky live-reload e2e test
    Comment out the hard import in aura_engine.py and rename the test file
    to prevent the module from being loaded. The test caused an infinite
    reload loop due to file-watcher race conditions.
    TODO: fix it and reenabel it
    """


    log4DEV('Script Start', logger)


    log_memory_details("Script Start", logger)



    from scripts.py.func.checks.check_example_file_is_synced import (
        check_example_file_is_synced,
    )

    # i call it two times because i removed the exit command when error today (2.10.'25 Thu). it's not critical but should not forget
    ##################### run_core_logic_self_test #############################
    #MODEL_NAME = MODEL_NAME_DEFAULT
    # aura_engine.py:1175
    from scripts.py.func.checks.self_tester import run_core_logic_self_test

    # from scripts.py.func.checks.auto_zip_startup_test import run_auto_zip_sanity_check,run_auto_zip_random_quick_check

    # run_auto_zip_random_quick_check(logger, force_full=False)


    if not DISABLE_ALL_TEST_QuickStopTestsForSomeReasons:

        # logger.info(f"{core_logic_self_test_is_running_FILE} created near aura_engine.py:1183 -> run_core_logic_self_test() starts now")
        # logger.info(f"Auto-Zip: {core_logic_self_test_is_running_FILE} created near aura_engine.py:1183 -> run_core_logic_self_test() starts now") # its often more relevant to this Auto-Zip
        # time.sleep(0.05)

        # aura_engine.py:1195
        self_test_start_time = time.time()
        log4DEV(f"Start run_core_logic_self_test( .. {lang_code}", logger)

        # aura_engine.py:1260
        run_core_logic_self_test(logger, TMP_DIR / "sl5_aura", active_lt_url,lang_code)
        # , LANGUAGETOOL_JAR_PATH,lt_process=active_lt_url)

        os.environ["AURA_SELF_TEST_RUNNING"] = "0"


        self_test_end_time = time.time()
        self_test_duration = self_test_end_time - self_test_start_time
        self_test_readable_duration = timedelta(seconds=self_test_duration)
        logger.info(f"⌚ self_test_readable_duration: {self_test_readable_duration}")

        logSnippet = """
        without checks and clean all cashes before. it seems service can start in about 23 Seconds with a good german Model (s,25.11.'25 00:04 Tue)
        23:59:57,438 - INFO     - DEV_MODE: Running punctuation map key validation…
        00:00:20,233 - INFO     - ==    ✅ MODEL READY: 'de'.

        without checks it seems service can start in about 27 Seconds with a good german Model (s,24.11.'25 15:16 Mon):
        15:12:19,851 - INFO     - DEV_MODE: Running punctuation map key validation…
        15:12:46,853 - INFO     - ==    ✅ MODEL READY: 'de'.

        """


        """
        # self_test_readable_duration
        59 of 82 tests ❌ FAILed.    seconds=5, microseconds=578883

        """

        check_installer_sizes()


        from scripts.py.func.checks.check_badges import check_badges


        check_badges(SCRIPT_DIR)


        from scripts.py.func.checks.setup_validator import (
            check_for_frequent_calls,
            check_for_unused_functions,
            parse_all_files,
            validate_setup,
        )

        validate_setup(SCRIPT_DIR, logger)


        SL5NET_AURA_PROJECT_ROOT = SCRIPT_DIR  # In this structure, SCRIPT_DIR is SL5NET_AURA_PROJECT_ROOT

        parsed_trees = parse_all_files(SL5NET_AURA_PROJECT_ROOT, logger)

    if not DISABLE_ALL_TEST_QuickStopTestsForSomeReasons:
        check_for_unused_functions(parsed_trees, SL5NET_AURA_PROJECT_ROOT, logger)
        check_for_frequent_calls(parsed_trees, logger, threshold=1)

        check_installer_sizes()


        check_example_file_is_synced(SCRIPT_DIR)

        from scripts.py.func.checks.integrity_checker import check_code_integrity
        from scripts.py.func.checks.validate_punctuation_map_keys import (
            validate_punctuation_map_keys,
        )

        check_code_integrity(SCRIPT_DIR, logger)

        check_installer_sizes()


        # i call it two times because i removed the exit command when error today (2.10.'25 Thu). it's not critical but should not forget
        check_example_file_is_synced(SCRIPT_DIR)



# --- main-logic is in Thread ---

# File: aura_engine.py
global AUTO_ENTER_AFTER_DICTATION_global

recording_time = 0
# from config import settings # Import the whole settings module
# aura_engine.py:1147
if __name__ == "__main__":
    # 1. Load all settings from the module into a dictionary
    config = {key: getattr(settings, key) for key in dir(settings) if key.isupper()}

    # 2. Add/overwrite dynamic, script-specific values
    config.update({
        "SCRIPT_DIR": SCRIPT_DIR,
        "TMP_DIR": TMP_DIR,
        "HEARTBEAT_FILE": HEARTBEAT_FILE,
        "PIDFILE": PIDFILE,
        "TRIGGER_FILE": TRIGGER_FILE,
        "SL5NET_AURA_PROJECT_ROOT": SL5NET_AURA_PROJECT_ROOT,
        "AUTO_ENTER_AFTER_DICTATION_REGEX_APPS": settings.AUTO_ENTER_AFTER_DICTATION_REGEX_APPS,
        "languagetool_process": active_lt_url
    })



    # --- Plugin State Communication ---
    # File: aura_engine.py Line 417
    # Create a flag file so client scripts know if a plugin is active.
    try:
        AUTO_ENTER_AFTER_DICTATION_global = settings.AUTO_ENTER_AFTER_DICTATION_REGEX_APPS
        auto_enter_flag_path = "/tmp/sl5_aura/sl5_auto_enter.flag"
        with open(auto_enter_flag_path, "w") as f:
            f.write(str(AUTO_ENTER_AFTER_DICTATION_global)) # Writes 1 or 0
        logger.info(f"Set auto-enter flag to: {AUTO_ENTER_AFTER_DICTATION_global}")
    except Exception as e:
        logger.error(f"Could not write auto-enter flag file: {e}")



    # Pass the complete, unified config to main()
    loaded_models = {}
    try:
        main(logger, loaded_models, config, suspicious_events, recording_time, active_lt_url)
        # Pass the complete, unified config to main()
    except BaseException as e:
        logger.info(f"🚨 CRITICAL BASE EXCEPTION: {type(e).__name__}: {e}", exc_info=True)
        logger.error(f"🚨 CRITICAL BASE EXCEPTION: {type(e).__name__}: {e}", exc_info=True)
        raise




logger.info("🏁 end of file aura_engine.py reached - logic fell through!")