13.08.2026 20:25 обновленная база данных

HOWTO/помощь со скриптами диагностики.md

@@ -0,0 +1,59 @@
+# 🛠 HOWTO: Помощь в технической диагностике системы (`scud_orion_ai_v2`)
+
+Данный документ содержит руководство по работе со служебными диагностическими утилитами проекта. Скрипты предназначены для быстрой оценки состояния базы данных SQLite, анализа файловой структуры и формирования контекстного снимка кодовой базы для ИИ.
+
+---
+
+## 📋 Содержимое папки `scripts/diagnostics/`
+
+Рекомендуется размещать диагностические скрипты в отдельной директории `scripts/diagnostics/`:
+
+1. **`inspect_db.py`** — Инспектор таблиц и записей базы данных SQLite.
+2. **`inspect_files.py`** — Сканер дискового пространства и структуры файлов.
+3. **`make_code_snapshot.py`** — Генератор единого текстового слепка кода для ИИ.
+
+---
+
+## 🚀 Назначение и запуск утилит
+
+### 1. Инспектор базы данных SQLite (`inspect_db.py`)
+
+* **Назначение:**
+  * Проверяет доступность базы данных (`data/scud_orion_ai.db`).
+  * Автоматически считывает список всех таблиц и их колонок.
+  * Подсчитывает количество записей в каждой таблице (`scud_logs`, `zup_staff`, `zup_absences` и др.).
+  * Выводит список всех активных правил из таблицы `ai_knowledge_base`.
+
+* **Команда для запуска:**
+  ```bash
+  python scripts/diagnostics/inspect_db.py
+2. Сканер файловой структуры (inspect_files.py)
+Назначение:
+
+Обходит структуру каталогов проекта.
+
+Показывает точный размер каждого файла в байтах и итоговый вес проекта в мегабайтах.
+
+Автоматически игнорирует служебные и временные папки (.git, __pycache__, venv, .venv).
+
+Команда для запуска:
+
+Bash
+python scripts/diagnostics/inspect_files.py
+3. Генератор контекстного снимка кода (make_code_snapshot.py)
+Назначение:
+
+Собирает весь исходный код Python (.py), настройки (.json), инструкции (.md) и скрипты (.sh) в единый файл project_code_snapshot.md.
+
+Исключает тяжелые архивы, логи и виртуальное окружение.
+
+Сформированный файл передается нейросети (LLM) для быстрого погружения в контекст проекта без потери архитектурных деталей.
+
+Команда для запуска:
+
+Bash
+python scripts/diagnostics/make_code_snapshot.py
+🎯 Чек-лист применения при сбоях
+Ошибка или несостыковка в отчетах: запустить inspect_db.py и проверить, заполнены ли таблицы scud_logs и zup_absences.
+
+Передача задачи или кода ИИ-ассистенту: запустить make_code_snapshot.py и прикрепить итоговый project_code_snapshot.md к запросу.

HOWTO/работа с кодом.md

@@ -0,0 +1,73 @@
+# 🛠 HOWTO: Правила внесения изменений и передачи кода в проекте
+
+## 📌 Зачем это нужно
+Проект `scud_orion_ai_v2` активно растет (17+ модулей, СУБД SQLite, ИИ-контур). Передача полных файлов кода при каждой мелкой правке сжигает окно контекста LLM, замедляет диалог и приводит к потере ранее внесенных архитектурных фич.
+
+---
+
+## 🎯 Правила для разработчика и ИИ
+
+### 1. Формат передачи изменений
+При запросах и ответах используются **точечные фрагменты кода** (Diff-стиль) с указанием привязок.
+
+Любой фрагмент должен содержать:
+1. **Точный путь к файлу** (`services/excel_exporter.py`).
+2. **Имя целевой функции/класса** (`generate_summary_excel`).
+3. **Зацепку (Context Anchor)** — уникальную соседнюю строку или блок `try/except`.
+
+---
+
+## 📐 Шаблоны фрагментов
+
+### Вариант А: Замена существующей логики
+
+> **Файл:** `services/excel_exporter.py`  
+> **Функция:** `generate_summary_excel()`  
+> **Место:** Строка ~150, блок фильтрации `no_pass_df`  
+>
+> ❌ **Удалить:**
+> ```python
+> no_pass_df = merged_df[merged_df.get('no_scud_pass', False) == True]
+> ```
+>
+> ✅ **Вставить:**
+> ```python
+> if 'no_scud_pass' in merged_df.columns:
+>     no_pass_df = merged_df[merged_df['no_scud_pass'] == True]
+> else:
+>     no_pass_df = pd.DataFrame()
+> ```
+
+---
+
+### Вариант Б: Вставка нового условия/блока
+
+> **Файл:** `main.py`  
+> **Функция:** `detect_all_anomalies()`  
+> **Место:** После цикла `for idx, row in merged_df.iterrows():`
+>
+> ➕ **Вставить код:**
+> ```python
+> # ИСКЛЮЧЕНИЯ без документов 1С НЕ пропускаются дальше к аномалиям СКУД
+> if is_exc and not has_1c_reason:
+>     continue
+> ```
+
+---
+
+### Вариант В: Git Unified Diff Format
+
+> **Файл:** `services/data_loader.py`
+> ```diff
+> @@ def process_scud_anomalies(df_scud, exceptions=None): @@
+> -  first_act = '—'
+> +  # Сохраняем вычисленную ранее активность из БД/файла
+> +  first_act = existing_fa if existing_fa not in ['—', '', 'None'] else '—'
+> ```
+
+---
+
+## 🚀 Чек-лист перед запуском
+1. Проверить синтаксис через `python -m py_compile <файл.py>`.
+2. Запустить скрипт с флагом отладки `python main.py -d`.
+3. Убедиться, что снапшот записан в SQLite (`python scripts/db_cli.py snapshots`).

ROADMAP.md

@@ -0,0 +1,28 @@
+# 🗺 Реестр задач проекта: SCUD Orion AI (v2)
+
+## 🟢 Выполненные задачи (Completed Tasks)
+* **[TASK-01]** `services/data_loader` — Исправление KeyError по ФИО в Excel экспорте 1С (переход на `.iloc`) *(03.08.2026)* — **ГОТОВО**
+* **[TASK-02]** `services/zup_extractor` — Перевод подключения 1С:ЗУП на продакшн MS SQL сервер `ACCOUNT-01` + гибридный фоллбэк *(04.08.2026)* — **ГОТОВО**
+* **[TASK-03]** `services/scud_export` — Инцидент Равина В.Э.: Фиксация 100% приоритета сырых логов `pLogData` СКУД над расчетом УРВ Ориона *(04.08.2026)* — **ГОТОВО**
+* **[TASK-04]** `core/database` — Реализация схемы SQLite WAL, сохранение снапшотов и маппинг колонок (`department`/`position`) *(05.08.2026)* — **ГОТОВО**
+* **[TASK-05]** `core/database` — Исправление бага дублирования номеров снапшотов (переход на вычисление `MAX()` по суффиксу) *(05.08.2026)* — **ГОТОВО**
+* **[TASK-06]** `scripts/fix_snapshots` — Создание и выполнение скрипта сквозной переиндексации снапшотов с префиксом `Y` *(05.08.2026)* — **ГОТОВО**
+* **[TASK-07]** `scripts/db_cli` — Реализация CLI-инспектора БД и выравнивание номеров срезов для идеальной верстки в терминале *(05.08.2026)* — **ГОТОВО**
+* **[TASK-08]** `main.py / logic` — Двойная проверка исключений по `department_scud` и 1С, удержание 100% приоритета кадровых документов *(05.08.2026)* — **ГОТОВО**
+* **[TASK-09]** `services/text_reporter` — Лаконичный вывод неразмеченных сотрудников с короткими аббревиатурами отделов СКУД (`РУК`, `ОИЗ`, `ПУ` и др.) *(05.08.2026)* — **ГОТОВО**
+
+---
+
+## 🟡 Ближайшие планы и бэклог (In Progress & Backlog v2.1)
+* **[TASK-10]** `services/scud_export` — **Внутридневной контроль:** Извлечение полных цепочек проходов `pLogData` (входы/выходы за смену) — **В ПЛАНАХ** [High]
+* **[TASK-11]** `services/data_loader` — **Внутридневной контроль:** Расчет количества и суммарной длительности отлучек/перекуров сверх обеда — **В ПЛАНАХ** [High]
+* **[TASK-12]** `services/text_reporter` — **Внутридневной контроль:** Вывод списка системных нарушителей внутреннего распорядка в Markdown-отчет — **В ПЛАНАХ** [Medium]
+* **[TASK-13]** `automation` — Автоматизация сбора срезов по расписанию (Cron / Systemd Timers на **12:00**, **17:00**, **19:00**) — **В ПЛАНАХ** [High]
+* **[TASK-14]** `services/notifications` — Интеграция Telegram-бота для алертов Администратору при массовых сбоях турникетов (>5%) — **В ПЛАНАХ** [Medium]
+
+---
+
+## 🔵 Дорожная карта Веб-релиза (Roadmap v3.0)
+* **[TASK-15]** `api / fastapi` — Создание REST API на FastAPI (`/api/v1/snapshots`, `/api/v1/scud/logs`, `/api/v1/anomalies`) — **В ПЛАНАХ** [High]
+* **[TASK-16]** `frontend / chat` — Веб-интерфейс с ИИ-чатом на базе Ollama (Qwen 2.5 14B) с поддержкой Function Calling к REST API — **В ПЛАНАХ** [High]
+* **[TASK-17]** `core/memory` — Создание модуля персистентной памяти проекта в SQLite и CLI-инструмента для фиксации архитектурных решений — **В ПЛАНАХ** [High]

compare_xlsx.py

@@ -0,0 +1,21 @@
+import openpyxl
+
+wb_good = openpyxl.load_workbook('output/5 августа 2026 отчет.xlsx') # или ваш путь к рабочему
+wb_bad = openpyxl.load_workbook('output/10 августа 2026 отчет.xlsx')
+
+ws_good = wb_good.active
+ws_bad = wb_bad.active
+
+print(f"Размер хорошего: {ws_good.max_row} строк, {ws_good.max_column} колонок")
+print(f"Размер с ошибкой: {ws_bad.max_row} строк, {ws_bad.max_column} колонок")
+
+# Сравним типы ячеек в колонках
+for r in range(4, min(ws_good.max_row, ws_bad.max_row) + 1):
+    for c in range(1, 11):
+        v_g = ws_good.cell(row=r, column=c).value
+        v_b = ws_bad.cell(row=r, column=c).value
+        t_g = type(v_g)
+        t_b = type(v_b)
+        if t_g != t_b:
+        
+            print(f"Строка {r}, колонка {c}: тип в хорошем {t_g}, в плохом {t_b}")

core/database.py

@@ -0,0 +1,480 @@
+import os
+import sqlite3
+import json
+import pandas as pd
+from datetime import datetime
+from config import DATA_DIR
+
+DB_PATH = os.path.join(DATA_DIR, "scud_orion_ai.db")
+
+
+def get_connection():
+    """Создает подключение к базе данных SQLite с оптимизированными настройками."""
+    conn = sqlite3.connect(DB_PATH)
+    conn.execute("PRAGMA foreign_keys = ON;")
+    conn.execute("PRAGMA journal_mode = WAL;")
+    return conn
+
+
+def init_db():
+    """Создает структуру таблиц и индексов в базе данных."""
+    with get_connection() as conn:
+        cursor = conn.cursor()
+
+        cursor.execute("""
+        CREATE TABLE IF NOT EXISTS scud_logs (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            log_date TEXT NOT NULL,
+            fio TEXT NOT NULL,
+            fio_clean TEXT NOT NULL,
+            department TEXT,
+            position TEXT,
+            time_in TEXT,
+            first_activity TEXT DEFAULT '—',
+            time_out TEXT,
+            time_in_building TEXT,
+            is_present INTEGER NOT NULL,
+            anomaly_flag TEXT DEFAULT 'NONE',
+            snapshot_time TEXT DEFAULT NULL,
+            snapshot_id TEXT DEFAULT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        );
+        """)
+
+        cursor.execute("PRAGMA table_info(scud_logs);")
+        cols = [col[1] for col in cursor.fetchall()]
+        if 'snapshot_id' not in cols:
+            cursor.execute("ALTER TABLE scud_logs ADD COLUMN snapshot_id TEXT DEFAULT NULL;")
+
+        cursor.execute("""
+        CREATE TABLE IF NOT EXISTS zup_staff (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            snapshot_date TEXT NOT NULL,
+            fio TEXT NOT NULL,
+            fio_clean TEXT NOT NULL,
+            department TEXT,
+            position TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        );
+        """)
+
+        cursor.execute("""
+        CREATE TABLE IF NOT EXISTS zup_absences (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            absence_date TEXT NOT NULL,
+            fio TEXT NOT NULL,
+            fio_clean TEXT NOT NULL,
+            absence_type TEXT NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        );
+        """)
+
+        cursor.execute("""
+        CREATE TABLE IF NOT EXISTS anomalies_history (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            anomaly_date TEXT NOT NULL,
+            fio TEXT NOT NULL,
+            anomaly_type TEXT NOT NULL,
+            details TEXT NOT NULL,
+            human_status TEXT DEFAULT 'Pending',
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        );
+        """)
+
+        cursor.execute("""
+        CREATE TABLE IF NOT EXISTS ai_knowledge_base (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            rule_text TEXT UNIQUE NOT NULL,
+            added_by TEXT DEFAULT 'Human',
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        );
+        """)
+
+        cursor.execute("CREATE INDEX IF NOT EXISTS idx_scud_date ON scud_logs(log_date);")
+        cursor.execute("CREATE INDEX IF NOT EXISTS idx_scud_fio ON scud_logs(fio_clean);")
+        cursor.execute("CREATE INDEX IF NOT EXISTS idx_scud_snapshot ON scud_logs(snapshot_time);")
+
+        conn.commit()
+
+    sync_knowledge_base_to_db()
+
+def has_scud_logs_for_date(date_str):
+    """Проверяет, есть ли в базе данные СКУД за указанную дату."""
+    with get_connection() as conn:
+        cursor = conn.cursor()
+        cursor.execute("SELECT 1 FROM scud_logs WHERE log_date = ? LIMIT 1", (date_str,))
+        return cursor.fetchone() is not None
+
+def has_yesterday_final_snapshot(date_str):
+    """Проверяет, зафиксирован ли уже ИТОГОВЫЙ вчерашний снапшот с индексом Y/22:00."""
+    with get_connection() as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            "SELECT 1 FROM scud_logs WHERE log_date = ? AND (snapshot_id LIKE 'Y%' OR snapshot_time LIKE '%22:00:00') LIMIT 1",
+            (date_str,)
+        )
+        return cursor.fetchone() is not None
+
+
+def get_or_create_snapshot_id(snapshot_time, date_str=None, is_yesterday=False):
+    """
+    Генерирует датированный составной ID снапшота (YYYYMMDD-NNN или YYYYMMDD-NNN).
+    Префикс 'Y' присваивается автоматически, если дата логов (date_str) предшествует дате снятия (snapshot_time).
+    """
+    try:
+        dt_snap = datetime.strptime(snapshot_time, "%Y-%m-%d %H:%M:%S").date()
+        date_prefix = dt_snap.strftime("%Y%m%d")
+    except (ValueError, TypeError):
+        dt_snap = datetime.now().date()
+        date_prefix = dt_snap.strftime("%Y%m%d")
+
+    # Автоматическая проверка: если дата логов раньше даты выгрузки — проставляем Y
+    if date_str:
+        try:
+            dt_log = datetime.strptime(date_str, "%d.%m.%Y").date()
+            if dt_log < dt_snap:
+                is_yesterday = True
+        except Exception:
+            pass
+
+    prefix = "Y" if is_yesterday else ""
+
+    with get_connection() as conn:
+        cursor = conn.cursor()
+
+        if date_str:
+            cursor.execute(
+                "SELECT snapshot_id FROM scud_logs WHERE log_date = ? AND snapshot_time = ? AND snapshot_id IS NOT NULL LIMIT 1",
+                (date_str, snapshot_time)
+            )
+        else:
+            cursor.execute(
+                "SELECT snapshot_id FROM scud_logs WHERE snapshot_time = ? AND snapshot_id IS NOT NULL LIMIT 1",
+                (snapshot_time,)
+            )
+
+        row = cursor.fetchone()
+        if row and row[0]:
+            return row[0]
+
+        cursor.execute("""
+            SELECT snapshot_id 
+            FROM scud_logs 
+            WHERE snapshot_id LIKE ? OR snapshot_id LIKE ?
+            ORDER BY snapshot_id DESC LIMIT 1
+        """, (f"{date_prefix}-%", f"Y{date_prefix}-%"))
+
+        last_row = cursor.fetchone()
+        next_seq = 1
+
+        if last_row and last_row[0]:
+            parts = last_row[0].replace("Y", "").split("-")
+            if len(parts) > 1 and parts[1].isdigit():
+                next_seq = int(parts[1]) + 1
+
+        return f"{prefix}{date_prefix}-{next_seq:03d}"
+
+
+def save_scud_to_db(df_scud, date_str, snapshot_time=None, is_yesterday=False):
+    """Сохраняет логи СКУД с автоматическим присвоением составного snapshot_id."""
+    if df_scud is None or df_scud.empty:
+        return
+
+    if not snapshot_time:
+        snapshot_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+    # Передаем date_str в генератор snapshot_id
+    snapshot_id = get_or_create_snapshot_id(snapshot_time, date_str=date_str, is_yesterday=is_yesterday)
+
+    data_to_insert = []
+    for _, r in df_scud.iterrows():
+        data_to_insert.append((
+            date_str,
+            r.get('Сотрудник', r.get('fio_raw', '')),
+            r.get('fio_clean', ''),
+            r.get('Подразделение', ''),
+            r.get('Должность', ''),
+            r.get('Начало_дня', 'Нет входа'),
+            r.get('Первая_активность', '—'),
+            r.get('Конец_дня', 'Нет выхода'),
+            r.get('Находился_в_здании', '00:00'),
+            1 if r.get('Пришел', False) else 0,
+            r.get('anomaly_flag', 'NONE'),
+            snapshot_time,
+            snapshot_id
+        ))
+
+    with get_connection() as conn:
+        cursor = conn.cursor()
+        cursor.execute("DELETE FROM scud_logs WHERE log_date = ? AND snapshot_time = ?", (date_str, snapshot_time))
+        cursor.executemany("""
+            INSERT INTO scud_logs (
+                log_date, fio, fio_clean, department, position, 
+                time_in, first_activity, time_out, time_in_building, 
+                is_present, anomaly_flag, snapshot_time, snapshot_id
+            )
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """, data_to_insert)
+        conn.commit()
+
+
+def get_latest_snapshot_time(date_str=None):
+    with get_connection() as conn:
+        cursor = conn.cursor()
+        if date_str:
+            cursor.execute("SELECT snapshot_time FROM scud_logs WHERE log_date = ? AND snapshot_time IS NOT NULL ORDER BY snapshot_time DESC LIMIT 1", (date_str,))
+        else:
+            cursor.execute("SELECT snapshot_time FROM scud_logs WHERE snapshot_time IS NOT NULL ORDER BY snapshot_time DESC LIMIT 1")
+        row = cursor.fetchone()
+        return row[0] if row else None
+
+
+def load_scud_from_db_by_snapshot(date_str, snapshot_param=None):
+    """
+    Загружает логи СКУД по ID снапшота.
+    Если snapshot_param не задан (или искался прошлый день), приоритетно выбирает 
+    финальный вечерний снапшот, начинающийся с буквы 'Y' (срез на 22:00) за дату date_str.
+    """
+    with get_connection() as conn:
+        df = pd.DataFrame()
+
+        # 1. Если передан конкретный ID снапшота (например, '20260810-001')
+        if snapshot_param:
+            df = pd.read_sql_query(
+                "SELECT * FROM scud_logs WHERE snapshot_id = ?", 
+                conn, params=(str(snapshot_param),)
+            )
+
+        # 2. Если по snapshot_param ничего не найдено ИЛИ snapshot_param=None (запрос за вчерашний день):
+        if df.empty and date_str:
+            cursor = conn.cursor()
+            
+            # ⭐️ ПРИОРИТЕТ 1: Ищем срез, начальный символ которого 'Y' (вечерний зафиксированный Y-снапшот)
+            cursor.execute(
+                "SELECT snapshot_id FROM scud_logs WHERE log_date = ? AND snapshot_id LIKE 'Y%' ORDER BY id DESC LIMIT 1", 
+                (date_str,)
+            )
+            row = cursor.fetchone()
+            
+            # ⭐️ ПРИОРИТЕТ 2: Если Y-снапшот не найден, берем самый свежий обычный
+            if not row:
+                cursor.execute(
+                    "SELECT snapshot_id FROM scud_logs WHERE log_date = ? ORDER BY id DESC LIMIT 1", 
+                    (date_str,)
+                )
+                row = cursor.fetchone()
+
+            if row and row[0]:
+                target_snap_id = row[0]
+                df = pd.read_sql_query(
+                    "SELECT * FROM scud_logs WHERE snapshot_id = ?", 
+                    conn, params=(target_snap_id,)
+                )
+
+        # Приводим названия колонок к стандарту
+        if not df.empty:
+            rename_map = {
+                'department': 'Подразделение',
+                'position': 'Должность',
+                'fio': 'Сотрудник',
+                'time_in': 'Начало_дня',
+                'first_activity': 'Первая_активность',
+                'time_out': 'Конец_дня',
+                'duration': 'Находился_в_здании',
+                'is_present': 'Пришел'
+            }
+            # Переименовываем имеющиеся колонки
+            df = df.rename(columns={k: v for k, v in rename_map.items() if k in df.columns})
+
+            # Заполняем недостающие колонки значениями по умолчанию, если их не было в БД
+            required_cols = ['Пришел', 'Начало_дня', 'Первая_активность', 'Конец_дня', 'Находился_в_здании', 'anomaly_flag']
+            for col in required_cols:
+                if col not in df.columns:
+                    if col == 'Пришел':
+                        df[col] = False
+                    else:
+                        df[col] = '—'
+
+            # Приводим тип флага Пришел к bool
+            if 'Пришел' in df.columns:
+                df['Пришел'] = df['Пришел'].astype(bool)
+
+        return df
+
+def get_available_snapshots(date_str=None):
+    """
+    Возвращает список снапшотов.
+    Сортировка по времени snapshot_time DESC.
+    """
+    with get_connection() as conn:
+        cursor = conn.cursor()
+        if date_str:
+            cursor.execute("""
+                SELECT 
+                    snapshot_id, 
+                    log_date, 
+                    snapshot_time, 
+                    COUNT(*) as cnt 
+                FROM scud_logs 
+                WHERE log_date = ? AND snapshot_time IS NOT NULL 
+                GROUP BY snapshot_id, log_date, snapshot_time 
+                ORDER BY snapshot_time DESC
+            """, (date_str,))
+        else:
+            cursor.execute("""
+                SELECT 
+                    snapshot_id, 
+                    log_date, 
+                    snapshot_time, 
+                    COUNT(*) as cnt 
+                FROM scud_logs 
+                WHERE snapshot_time IS NOT NULL 
+                GROUP BY snapshot_id, log_date, snapshot_time 
+                ORDER BY snapshot_time DESC
+            """)
+        return cursor.fetchall()
+
+
+def save_staff_to_db(df_staff, date_str):
+    if df_staff is None or df_staff.empty:
+        return
+    data_to_insert = [
+        (date_str, r.get('ФИО', ''), r.get('fio_clean', ''), r.get('Подразделение', ''), r.get('Должность', ''))
+        for _, r in df_staff.iterrows()
+    ]
+    with get_connection() as conn:
+        cursor = conn.cursor()
+        cursor.execute("DELETE FROM zup_staff WHERE snapshot_date = ?", (date_str,))
+        cursor.executemany("INSERT INTO zup_staff (snapshot_date, fio, fio_clean, department, position) VALUES (?, ?, ?, ?, ?)", data_to_insert)
+        conn.commit()
+
+
+def save_absences_to_db(df_absent, date_str):
+    if df_absent is None or df_absent.empty:
+        return
+    data_to_insert = [
+        (date_str, r.get('ФИО', r.get('fio_clean', '')), r.get('fio_clean', ''), r.get('Вид_отсутствия', ''))
+        for _, r in df_absent.iterrows()
+    ]
+    with get_connection() as conn:
+        cursor = conn.cursor()
+        cursor.execute("DELETE FROM zup_absences WHERE absence_date = ?", (date_str,))
+        cursor.executemany("INSERT INTO zup_absences (absence_date, fio, fio_clean, absence_type) VALUES (?, ?, ?, ?)", data_to_insert)
+        conn.commit()
+
+
+def save_anomalies_to_db(anomalies_list, date_str):
+    if not anomalies_list:
+        return
+    data_to_insert = [
+        (date_str, a.get('fio', ''), a.get('type', ''), a.get('details', ''))
+        for a in anomalies_list
+    ]
+    with get_connection() as conn:
+        cursor = conn.cursor()
+        cursor.execute("DELETE FROM anomalies_history WHERE anomaly_date = ?", (date_str,))
+        cursor.executemany("INSERT INTO anomalies_history (anomaly_date, fio, anomaly_type, details) VALUES (?, ?, ?, ?)", data_to_insert)
+        conn.commit()
+
+
+def get_all_rules_from_db():
+    with get_connection() as conn:
+        cursor = conn.cursor()
+        cursor.execute("SELECT rule_text FROM ai_knowledge_base")
+        return [r[0] for r in cursor.fetchall()]
+
+
+def add_rule_to_db(rule_text, added_by="Human"):
+    if not rule_text or not rule_text.strip():
+        return
+    with get_connection() as conn:
+        cursor = conn.cursor()
+        try:
+            cursor.execute("INSERT OR IGNORE INTO ai_knowledge_base (rule_text, added_by) VALUES (?, ?)", (rule_text.strip(), added_by))
+            conn.commit()
+        except Exception as e:
+            print(f"[⚠️] Ошибка записи правила в БД: {e}")
+
+
+def sync_knowledge_base_to_db():
+    pass
+
+def delete_snapshot_by_id(snapshot_id: str):
+    """Удаляет конкретный снапшот из таблицы scud_logs по его ID."""
+    with get_connection() as conn:
+        cursor = conn.cursor()
+        cursor.execute("DELETE FROM scud_logs WHERE snapshot_id = ?", (snapshot_id,))
+        deleted_count = cursor.rowcount
+        conn.commit()
+    print(f"[✓] Удален снапшот [{snapshot_id}]. Удалено строк: {deleted_count}")
+    return deleted_count
+
+def delete_snapshots_by_date(date_str: str):
+    """Удаляет все снапшоты за указанную дату (например, '04.08.2026')."""
+    with get_connection() as conn:
+        cursor = conn.cursor()
+        # Удаляем по log_date или по дате внутри snapshot_id
+        cursor.execute("DELETE FROM scud_logs WHERE log_date = ? OR snapshot_id LIKE ?", (date_str, f"%{date_str.replace('.', '')}%"))
+        deleted_count = cursor.rowcount
+        conn.commit()
+    print(f"[✓] Удалены все снапшоты за дату [{date_str}]. Удалено строк: {deleted_count}")
+    return deleted_count
+def init_department_synonyms_db():
+    """Создает таблицу синонимов отделов в БД SQLite."""
+    with get_connection() as conn:
+        cursor = conn.cursor()
+        cursor.execute("""
+        CREATE TABLE IF NOT EXISTS department_synonyms (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            short_name TEXT UNIQUE NOT NULL,
+            full_name TEXT NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        );
+        """)
+        # По умолчанию добавляем ОВК -> Отдел внутреннего контроля
+        cursor.execute("""
+            INSERT OR IGNORE INTO department_synonyms (short_name, full_name) 
+            VALUES ('овк', 'отдел внутреннего контроля')
+        """)
+        conn.commit()
+
+
+def get_department_synonyms_dict():
+    """Возвращает словарь всех изученных синонимов {short_name: full_name}."""
+    init_department_synonyms_db()
+    with get_connection() as conn:
+        cursor = conn.cursor()
+        cursor.execute("SELECT LOWER(short_name), LOWER(full_name) FROM department_synonyms")
+        return {row[0]: row[1] for row in cursor.fetchall()}
+
+
+def add_department_synonym_to_db(short_name, full_name):
+    """Сохраняет новую пару синонимов отдела в базу SQLite."""
+    init_department_synonyms_db()
+    with get_connection() as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            "INSERT OR REPLACE INTO department_synonyms (short_name, full_name) VALUES (?, ?)",
+            (short_name.strip().lower(), full_name.strip().lower())
+        )
+        conn.commit()
+    print(f"[✓] В базу SQLite добавлен новый синоним отдела: '{short_name}' ⟷ '{full_name}'")
+
+def load_staff_from_db(date_str):
+    """Загружает Штатное расписание 1С из базы SQLite за указанную дату."""
+    with get_connection() as conn:
+        df = pd.read_sql_query(
+            "SELECT fio as 'ФИО', fio_clean, department as 'Подразделение', position as 'Должность' FROM zup_staff WHERE snapshot_date = ?",
+            conn, params=(date_str,)
+        )
+        return df if not df.empty else None
+
+def load_absences_from_db(date_str):
+    """Загружает документальные отсутствия 1С из базы SQLite за указанную дату."""
+    with get_connection() as conn:
+        df = pd.read_sql_query(
+            "SELECT fio as 'ФИО', fio_clean, absence_type as 'Вид_отсутствия' FROM zup_absences WHERE absence_date = ?",
+            conn, params=(date_str,)
+        )
+        return df if not df.empty else None
+    

data/static_reason_workers.csv

@@ -9,4 +9,6 @@ fio,reason,note
 Пшеничный Виктор Петрович,Удаленная работа,Постоянная удаленка
 Незнанова Валерия Игоревна,Удаленная работа,Постоянная удаленка
 Ковалев Владимир Владимирович,Удаленная работа,Постоянная удаленка
-Кожокарь Татьяна Юрьевна,Удаленная работа,Постоянная удаленка
+Кожокарь Татьяна Юрьевна,Удаленная работа,Постоянная удаленка
+Субетто Юлия Викторовна,Удаленная работа,Постоянная удаленка
+Ароян Станислав Месропович,Удаленная работа,Временная удаленка

main.py

@@ -1,29 +1,107 @@
 import os
 import sys
+import json
 import argparse
 import pandas as pd
+from datetime import datetime, timedelta
 
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from config import DATE_TODAY, DATE_YESTERDAY, OUTPUT_DIR, DATA_DIR, normalize_fio
-from modules.scud_export import run_export
-from modules.share_copier import copy_1c_files_from_share
-from modules.data_validator import check_file_freshness
-from modules.data_loader import load_all_data
-from modules.excel_exporter import generate_summary_excel, generate_detailed_excel
-from modules.ai_verifier import ai_verify_scud_against_staff
-from modules.text_reporter import generate_markdown_report
-from modules.feedback_loop import review_ai_decisions
-from modules.knowledge_base import load_knowledge_base
-from modules.database import (
+from services.scud_export import run_export
+from services.share_copier import copy_1c_files_from_share
+from services.data_validator import check_file_freshness
+from services.data_loader import load_1c_data_smart, load_scud_data
+from services.excel_exporter import generate_summary_excel, generate_detailed_excel
+from services.ai_verifier import ai_verify_scud_against_staff, analyze_scud_mass_failure_ai
+from services.text_reporter import generate_markdown_report
+from services.feedback_loop import review_ai_decisions
+from services.knowledge_base import load_knowledge_base
+from core.database import (
     init_db, 
     save_scud_to_db, 
     save_staff_to_db,
     save_absences_to_db, 
-    save_anomalies_to_db
+    save_anomalies_to_db,
+    load_scud_from_db_by_snapshot,
+    load_staff_from_db,
+    load_absences_from_db,
+    get_latest_snapshot_time,
+    has_scud_logs_for_date
 )
 
 
+def load_exceptions_config():
+    """Загружает файл exceptions.json из корня проекта."""
+    root_dir = os.path.dirname(os.path.abspath(__file__))
+    json_path = os.path.join(root_dir, "exceptions.json")
+    if not os.path.exists(json_path):
+        return {}
+    try:
+        with open(json_path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except Exception as e:
+        print(f"[⚠️] Ошибка чтения exceptions.json: {e}")
+        return {}
+
+
+def apply_exceptions_from_json(df, exceptions_cfg):
+    """
+    Быстрая и эффективная разметка флага is_excluded=True на основе exceptions.json.
+    Выполняется мгновенно без цикличных HTTP-запросов к ИИ.
+    """
+    if df is None or df.empty or not exceptions_cfg:
+        if df is not None:
+            df['is_excluded'] = False
+        return df
+
+    deps = [d.strip().lower() for d in exceptions_cfg.get("departments", []) if d]
+    exact_pos = [p.strip().lower() for p in exceptions_cfg.get("positions", []) if p]
+    pos_kw = [k.strip().lower() for k in exceptions_cfg.get("position_keywords", []) if k]
+    exc_fios = [normalize_fio(f) for f in exceptions_cfg.get("fio", []) if f]
+
+    df['is_excluded'] = False
+
+    for idx, row in df.iterrows():
+        fio_clean = row.get('fio_clean', '')
+        dep_1c = str(row.get('Подразделение', '')).lower()
+        dep_scud = str(row.get('department_scud', row.get('department', ''))).lower()
+        pos = str(row.get('Должность', '')).lower()
+
+        is_fio_exc = fio_clean in exc_fios
+        is_pos_exc = (pos in exact_pos) or any(k in pos for k in pos_kw if k) if pos else False
+        
+        # Быстрая проверка отделов по подстрокам
+        is_dep_exc = False
+        if deps:
+            is_dep_exc = any(d in dep_1c or d in dep_scud for d in deps)
+
+        if is_fio_exc or is_dep_exc or is_pos_exc:
+            df.at[idx, 'is_excluded'] = True
+
+    return df
+
+
+def filter_report_dataframe(merged_df):
+    """
+    Исключает сотрудников из списка исключений и сотрудников без пропуска из детального отчета,
+    ЕСЛИ у них нет официального документа отсутствия из 1С:ЗУП.
+    """
+    if merged_df is None or merged_df.empty:
+        return merged_df
+
+    has_1c_reason = (
+        merged_df['Вид_отсутствия'].notna() & 
+        (merged_df['Вид_отсутствия'].astype(str).str.strip() != '') & 
+        (~merged_df['Вид_отсутствия'].astype(str).str.startswith('Исключение'))
+    )
+    is_not_excluded = merged_df.get('is_excluded', False) == False
+    is_not_no_pass = merged_df.get('no_scud_pass', False) == False
+
+    filtered_df = merged_df[(is_not_excluded & is_not_no_pass) | has_1c_reason].copy()
+    return filtered_df
+
+
 def load_static_reason_workers():
     """Загружает реестр удалёнщиков и статических причин из CSV."""
     static_path = os.path.join(DATA_DIR, "static_reason_workers.csv")
@@ -39,15 +117,9 @@ def load_static_reason_workers():
     return {}
 
 
-def detect_all_anomalies(merged_df, static_reasons_dict, kb_rules):
+def detect_all_anomalies(merged_df, static_reasons_dict, kb_rules, scud_fios_set=None):
     """
-    Автоматически находит ИСТИННЫЕ аномалии.
-    
-    ПРАВИЛА КОМПАНИИ:
-    1. Удалённые сотрудники имеют право беспрепятственно работать в офисе (НЕ аномалия).
-    2. Документы отсутствий из 1С имеют 100% приоритет над стат. реестром (НЕ аномалия).
-    3. АНОМАЛИЯ — Физический выход по СКУД при наличии в 1С ЛЮБЫХ причин отсутствия
-       (отпуск, больничный, уход за ребенком и т.д.), КРОМЕ командировок и служебных поездок.
+    Автоматически выявляет истинные аномалии СКУД ⟷ 1С.
     """
     anomalies = []
     kb_rules_text = " ".join(kb_rules).lower() if kb_rules else ""
@@ -58,8 +130,10 @@ def detect_all_anomalies(merged_df, static_reasons_dict, kb_rules):
         fio = row.get('Сотрудник', row.get('fio_clean', ''))
         fio_clean = row.get('fio_clean', '')
         is_present = row.get('Пришел', False)
+        is_exc = row.get('is_excluded', False)
         reason_1c = str(row.get('Вид_отсутствия', '')).strip()
-        has_1c_reason = pd.notna(row.get('Вид_отсутствия')) and reason_1c != ''
+        has_1c_reason = pd.notna(row.get('Вид_отсутствия')) and reason_1c != '' and not reason_1c.startswith('Исключение')
+        anom_flag = row.get('anomaly_flag', 'NONE')
 
         is_fio_whitelisted_in_kb = fio_clean.lower() in kb_rules_text
 
@@ -74,6 +148,25 @@ def detect_all_anomalies(merged_df, static_reasons_dict, kb_rules):
                     "details": f"Сотрудник пришел по СКУД, но в 1С оформлен документ: '{reason_1c}'"
                 })
 
+        if is_exc and not has_1c_reason:
+            continue
+
+        if anom_flag == 'ANOMALY_NO_IN_HAS_ACTIVITY':
+            first_act = row.get('Первая_активность', '—')
+            anomalies.append({
+                "type": "АНОМАЛИЯ СКУД: ПЕРЕМЕЩЕНИЕ БЕЗ ВХОДА",
+                "fio": fio,
+                "details": f"Отсутствует регистрация входа на КПП при зафиксированной первой активности в {first_act}"
+            })
+
+        if scud_fios_set is not None:
+            if fio_clean not in scud_fios_set and not has_1c_reason:
+                anomalies.append({
+                    "type": "АНОМАЛИЯ УЧЕТА: СОТРУДНИК ОТСУТСТВУЕТ В СКУД ОРИОН PRO",
+                    "fio": fio,
+                    "details": f"Сотрудник числится в Штатном расписании 1С ({row.get('Подразделение', '—')}), но полностью отсутствует в базе СКУД Орион Pro (профиль не создан или карта не выдана)"
+                })
+
     return anomalies
 
 
@@ -99,84 +192,135 @@ def aggregate_scud_by_employee(df, debug=False):
 
 
 def main():
-    parser = argparse.ArgumentParser(description="Система модульного контроллинга СКУД ⟷ 1С")
-    parser.add_argument('-d', '--debug', action='store_true', help="Запуск в режиме отладки")
-    parser.add_argument('--skip-export', action='store_true', help="Пропустить выгрузку СКУД из MS SQL")
-    parser.add_argument('--with-xlsx', action='store_true', help="Сохранять дублирующие сырые XLSX-файлы в папке data/")
-    args = parser.parse_args()
+    help_text = """
+Система автоматизированного контроллинга СКУД ⟷ 1С:ЗУП (scud_orion_ai_v2)
 
+ПРИМЕРЫ ЗАПУСКА:
+  python main.py                                      -- Обычный дневной запуск
+  python main.py --skip-export                         -- Расчет отчета по ПОСЛЕДНЕМУ имеющемуся снапшоту из SQLite
+  python main.py --snapshot 20260805-001              -- Расчет отчета строго по ID снапшота
+  python main.py -d                                   -- Запуск в режиме расширенной отладки (DEBUG)
+"""
+    parser = argparse.ArgumentParser(
+        description=help_text,
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    parser.add_argument('-d', '--debug', action='store_true', help="Запуск в режиме отладки с выводом подробных логов")
+    parser.add_argument('--skip-export', action='store_true', help="Пропустить выгрузку СКУД из MS SQL и построить отчет по последнему снапшоту")
+    parser.add_argument('--snapshot', type=str, default=None, help="Составной ID снапшота или время создания")
+
+    args = parser.parse_args()
     DEBUG = args.debug
 
     print("=" * 60)
     print(f"ЗАПУСК СИСТЕМЫ МОДУЛЬНОГО КОНТРОЛЛИНГА СКУД ⟷ 1С {'[DEBUG MODE]' if DEBUG else ''}")
     print("=" * 60)
 
-    # 0. Инициализация локальной базы данных SQLite и Базы Знаний
     init_db()
     kb_data = load_knowledge_base()
     kb_rules = kb_data.get("rules", [])
+    exceptions_cfg = load_exceptions_config()
 
-    # 0.1 Выгрузка из БД СКУД напрямую в SQLite и Excel (save_xlsx=True требуется для data_loader)
-    if not args.skip_export:
+    if args.snapshot:
+        snapshot_param = args.snapshot
+        print(f"[📸] РЕЖИМ СНАПШОТА: Расчет отчета строго по срезу '{snapshot_param}'")
+    elif args.skip_export:
+        snapshot_param = get_latest_snapshot_time()
+        print(f"[📸] РЕЖИМ --skip-export: Используем последний снапшот из SQLite ('{snapshot_param}')")
+    else:
+        snapshot_param = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f"[📸] СФОРМИРОВАН НОВЫЙ СНАПШОТ: '{snapshot_param}'")
+
+    if not args.skip_export and not args.snapshot:
         try:
             run_export(save_xlsx=True, debug=DEBUG)
         except Exception as e:
-            print(f"[⚠️] Ошибка автоэкспорта из БД: {e}. Используем имеющиеся записи в SQLite.")
+            print(f"[⚠️] Ошибка автоэкспорта из БД: {e}. Переходим к записям в SQLite.")
     else:
-        print("[0/5] Пропуск прямого экспорта из БД (--skip-export)...")
+        print("[0/5] Пропуск прямого экспорта из MS SQL (чтение из базы SQLite)...")
 
-    # 0.5 Копирование файлов 1С с сетевой шары /mnt/scud_share
-    copy_1c_files_from_share()
+    # ⚡️ ПРОВЕРКА ШАРЫ ТОЛЬКО ДЛЯ ОБЫЧНОГО ДНЕВНОГО ЗАПУСКА
+    if not args.snapshot and not args.skip_export:
+        copy_1c_files_from_share()
 
-    # 1. Валидация наличия файлов и данных
-    print("[1/5] Проверка актуальности и свежести входных данных...")
-    is_valid, warnings, errors, has_today_1c = check_file_freshness()
+        print("[1/5] Проверка актуальности и свежести входных данных...")
+        is_valid, warnings, errors, has_today_1c = check_file_freshness()
 
-    if warnings:
-        print("\n--- ⚠️ ПРЕДУПРЕЖДЕНИЯ ОБ АКТУАЛЬНОСТИ ---")
-        for w in warnings:
-            print(f"  • {w}")
-        print("-" * 45)
+        if warnings:
+            print("\n--- ⚠️ ПРЕДУПРЕЖДЕНИЯ ОБ АКТУАЛЬНОСТИ ---")
+            for w in warnings:
+                print(f"  • {w}")
+            print("-" * 45)
 
-    if not is_valid:
-        print("\n" + "!" * 60)
-        print("🛑 ОСТАНОВКА ВЫПОЛНЕНИЯ: Отсутствуют критически важные файлы за вчерашний день!")
-        for e in errors:
-            print(f"  {e}")
-        print("!" * 60)
-        sys.exit(1)
+        if not is_valid:
+            print("\n" + "!" * 60)
+            print("🛑 ОСТАНОВКА ВЫПОЛНЕНИЯ: Отсутствуют критически важные файлы за вчерашний день!")
+            for e in errors:
+                print(f"  {e}")
+            print("!" * 60)
+            sys.exit(1)
 
-    print("[✓] Проверка доступности данных успешно пройдена!\n")
+        print("[✓] Проверка доступности данных успешно пройдена!\n")
+    else:
+        print("[1/5] Пропуск проверки сетевой шары (все данные читаются из SQLite)...")
+        has_today_1c = True
 
-    # 2. Раздельная загрузка данных за Сегодня и за Вчера
     print("[2/5] Загрузка данных из СКУД, 1С:ЗУП, реестра причин и исключений...")
-    (
-        raw_scud_today_df,
-        raw_scud_yesterday_df,
-        df_staff_today,
-        df_absent_today,
-        df_staff_yesterday,
-        df_absent_yesterday
-    ) = load_all_data()
+    
+    # 🎯 ВЫЧИСЛЕНИЕ ДАТ СНАПШОТА И ДАТ НАКАНУНЕ
+    if args.snapshot or args.skip_export:
+        raw_scud_today_df = load_scud_from_db_by_snapshot(None, snapshot_param=snapshot_param)
+        
+        if not raw_scud_today_df.empty and 'log_date' in raw_scud_today_df.columns:
+            target_date_str = str(raw_scud_today_df['log_date'].iloc[0])
+        else:
+            target_date_str = DATE_TODAY
+
+        dt_target = datetime.strptime(target_date_str, "%d.%m.%Y")
+        if dt_target.weekday() == 0:  # Понедельник -> Пятница
+            dt_yesterday = dt_target - timedelta(days=3)
+        else:
+            dt_yesterday = dt_target - timedelta(days=1)
+        yesterday_date_str = dt_yesterday.strftime("%d.%m.%Y")
+
+        print(f"[📸] СНАПШОТ ОПРЕДЕЛЕН: Целевая дата = {target_date_str}, Накануне = {yesterday_date_str}")
+
+        raw_scud_yesterday_df = load_scud_from_db_by_snapshot(yesterday_date_str, snapshot_param=None)
+
+        # Гарантированная загрузка кадров 1С за обе даты (БД + локальный фолбэк)
+        df_staff_today, df_absent_today = load_1c_data_smart(target_date_str, use_db=True)
+        df_staff_yesterday, df_absent_yesterday = load_1c_data_smart(yesterday_date_str, use_db=True)
+    else:
+        target_date_str = DATE_TODAY
+        yesterday_date_str = DATE_YESTERDAY
+
+        raw_scud_today_df = load_scud_from_db_by_snapshot(target_date_str, snapshot_param=snapshot_param)
+        raw_scud_yesterday_df = load_scud_from_db_by_snapshot(yesterday_date_str, snapshot_param=None)
+
+        df_staff_today, df_absent_today = load_1c_data_smart(DATE_TODAY, use_db=False)
+        df_staff_yesterday, df_absent_yesterday = load_1c_data_smart(DATE_YESTERDAY, use_db=False)
 
-    # 💾 СОХРАНЕНИЕ КАДРОВЫХ СРЕЗОВ 1С В БАЗУ ДАННЫХ SQLite
     if df_staff_yesterday is not None:
-        save_staff_to_db(df_staff_yesterday, DATE_YESTERDAY)
+        save_staff_to_db(df_staff_yesterday, yesterday_date_str)
     if df_absent_yesterday is not None:
-        save_absences_to_db(df_absent_yesterday, DATE_YESTERDAY)
+        save_absences_to_db(df_absent_yesterday, yesterday_date_str)
 
     if df_staff_today is not None:
-        save_staff_to_db(df_staff_today, DATE_TODAY)
+        save_staff_to_db(df_staff_today, target_date_str)
     if df_absent_today is not None:
-        save_absences_to_db(df_absent_today, DATE_TODAY)
+        save_absences_to_db(df_absent_today, target_date_str)
 
     staff_fios_yesterday_clean = df_staff_yesterday['fio_clean'].dropna().tolist() if df_staff_yesterday is not None else []
     static_reasons_dict = load_static_reason_workers()
 
     # ============================================================
-    # 🎯 ЧАСТЬ 1: ДЕТАЛЬНЫЙ ОТЧЕТ ЗА ВЧЕРА (Строится Всегда)
+    # 🎯 ЧАСТЬ 1: ДЕТАЛЬНЫЙ ОТЧЕТ ЗА ВЧЕРА (ДЕНЬ НАКАНУНЕ)
     # ============================================================
-    print("\n[3/5] Обработка данных за ВЧЕРА...")
+    print(f"\n[3/5] Обработка и построение детального отчета за ВЧЕРА ({yesterday_date_str})...")
+    
+    if not raw_scud_yesterday_df.empty and 'Пришел' not in raw_scud_yesterday_df.columns:
+        raw_scud_yesterday_df['Пришел'] = raw_scud_yesterday_df['is_present'].astype(int) == 1 if 'is_present' in raw_scud_yesterday_df.columns else False
+
     scud_yesterday_unrecognized = raw_scud_yesterday_df[~raw_scud_yesterday_df['fio_clean'].isin(staff_fios_yesterday_clean)]['fio_clean'].tolist() if not raw_scud_yesterday_df.empty else []
     
     fio_mapping_scud_y = ai_verify_scud_against_staff(scud_yesterday_unrecognized, staff_fios_yesterday_clean)
@@ -196,9 +340,41 @@ def main():
 
     raw_scud_yesterday_df = aggregate_scud_by_employee(raw_scud_yesterday_df, debug=DEBUG)
 
-    merged_yesterday = raw_scud_yesterday_df[raw_scud_yesterday_df['fio_clean'].isin(staff_fios_yesterday_clean)].copy()
-    if df_absent_yesterday is not None:
-        merged_yesterday = merged_yesterday.merge(df_absent_yesterday, on='fio_clean', how='left')
+    # ⭐️ ФОРМИРУЕМ МЕРДЖ ИСКЛЮЧИТЕЛЬНО НА БАЗЕ ШТАТА ЗА ПРОШЛЫЙ ДЕНЬ
+    merged_yesterday = df_staff_yesterday.copy() if (df_staff_yesterday is not None and not df_staff_yesterday.empty) else (df_staff_today.copy() if df_staff_today is not None else pd.DataFrame())
+
+    if not merged_yesterday.empty:
+        if not raw_scud_yesterday_df.empty:
+            if 'Подразделение' in raw_scud_yesterday_df.columns:
+                raw_scud_yesterday_df['department_scud'] = raw_scud_yesterday_df['Подразделение']
+            elif 'department' in raw_scud_yesterday_df.columns:
+                raw_scud_yesterday_df['department_scud'] = raw_scud_yesterday_df['department']
+            else:
+                raw_scud_yesterday_df['department_scud'] = ''
+
+            merged_yesterday = merged_yesterday.merge(
+                raw_scud_yesterday_df[['fio_clean', 'Пришел', 'Начало_дня', 'Первая_активность', 'Конец_дня', 'Находился_в_здании', 'anomaly_flag', 'department_scud']], 
+                on='fio_clean', how='left'
+            )
+        
+        if 'Вид_отсутствия' in merged_yesterday.columns:
+            merged_yesterday = merged_yesterday.drop(columns=['Вид_отсутствия'])
+
+        # Присоединяем отсутствия СТРОГО за дату yesterday_date_str
+        if df_absent_yesterday is not None and not df_absent_yesterday.empty:
+            merged_yesterday = merged_yesterday.merge(
+                df_absent_yesterday[['fio_clean', 'Вид_отсутствия']], 
+                on='fio_clean', 
+                how='left'
+            )
+
+    if 'Пришел' not in merged_yesterday.columns:
+        merged_yesterday['Пришел'] = False
+    else:
+        merged_yesterday['Пришел'] = merged_yesterday['Пришел'].fillna(False)
+
+    if 'Сотрудник' not in merged_yesterday.columns:
+        merged_yesterday['Сотрудник'] = merged_yesterday.get('ФИО', merged_yesterday['fio_clean'])
 
     if static_reasons_dict:
         for fio_clean, reason_val in static_reasons_dict.items():
@@ -209,6 +385,7 @@ def main():
             )
             merged_yesterday.loc[mask_yesterday, 'Вид_отсутствия'] = reason_val
 
+    merged_yesterday = apply_exceptions_from_json(merged_yesterday, exceptions_cfg)
     mask_exc_yesterday = (
         (merged_yesterday['Пришел'] == False) & 
         (merged_yesterday['Вид_отсутствия'].isna() | (merged_yesterday['Вид_отсутствия'].astype(str).str.strip() == '')) & 
@@ -216,22 +393,38 @@ def main():
     )
     merged_yesterday.loc[mask_exc_yesterday, 'Вид_отсутствия'] = 'Исключение (ОВК/Подрядчики)'
 
-    generate_detailed_excel(merged_df=merged_yesterday, date_str=DATE_YESTERDAY)
+    scud_fios_yesterday_set = set(raw_scud_yesterday_df['fio_clean'].dropna().tolist()) if not raw_scud_yesterday_df.empty else set()
+    merged_yesterday['no_scud_pass'] = (
+        (~merged_yesterday['fio_clean'].isin(scud_fios_yesterday_set)) & 
+        (merged_yesterday['Вид_отсутствия'].isna() | (merged_yesterday['Вид_отсутствия'].astype(str).str.strip() == '')) & 
+        (merged_yesterday.get('is_excluded', False) == False)
+    )
 
-    # 💾 СОХРАНЕНИЕ ВЧЕРАШНИХ ДАННЫХ В SQLite:
-    save_scud_to_db(merged_yesterday, DATE_YESTERDAY)
+    anomalies_yesterday_list = detect_all_anomalies(merged_yesterday, static_reasons_dict, kb_rules, scud_fios_set=scud_fios_yesterday_set)
+    save_anomalies_to_db(anomalies_yesterday_list, yesterday_date_str)
+
+    filtered_yesterday = filter_report_dataframe(merged_yesterday)
+    generate_detailed_excel(merged_df=filtered_yesterday, date_str=yesterday_date_str)
+
+    yesterday_dt_obj = datetime.strptime(yesterday_date_str, "%d.%m.%Y")
+    yesterday_22_str = yesterday_dt_obj.strftime("%Y-%m-%d 22:00:00")
+    save_scud_to_db(merged_yesterday, yesterday_date_str, snapshot_time=yesterday_22_str, is_yesterday=True)
+    print(f"[✓] Детальный отчет за вчера сформирован и зафиксирован в SQLite за {yesterday_date_str}")
 
     # ============================================================
-    # 🎯 ЧАСТЬ 2: ЕЖЕДНЕВНАЯ СВОДКА ЗА СЕГОДНЯ
+    # 🎯 ЧАСТЬ 2: ЕЖЕДНЕВНАЯ СВОДКА (ЗА ЦЕЛЕВОЙ ДЕНЬ СНАПШОТА)
     # ============================================================
-    # 💾 СОХРАНЯЕМ СЕГОДНЯШНИЙ СКУД В SQLite (Даже если 1С еще не пришла):
-    save_scud_to_db(raw_scud_today_df, DATE_TODAY)
+    if not args.snapshot and not args.skip_export:
+        save_scud_to_db(raw_scud_today_df, target_date_str, snapshot_time=snapshot_param, is_yesterday=False)
 
     if has_today_1c and df_staff_today is not None and df_absent_today is not None:
-        print("\n[4/5] Обработка данных за СЕГОДНЯ...")
+        print(f"\n[4/5] Обработка и построение Ежедневной сводки за {target_date_str}...")
         staff_fios_today_clean = df_staff_today['fio_clean'].dropna().tolist()
 
-        scud_unrecognized = raw_scud_today_df[~raw_scud_today_df['fio_clean'].isin(staff_fios_today_clean)]['fio_clean'].tolist()
+        if not raw_scud_today_df.empty and 'Пришел' not in raw_scud_today_df.columns:
+            raw_scud_today_df['Пришел'] = raw_scud_today_df['is_present'].astype(int) == 1 if 'is_present' in raw_scud_today_df.columns else False
+
+        scud_unrecognized = raw_scud_today_df[~raw_scud_today_df['fio_clean'].isin(staff_fios_today_clean)]['fio_clean'].tolist() if not raw_scud_today_df.empty else []
         fio_mapping_scud = ai_verify_scud_against_staff(scud_unrecognized, staff_fios_today_clean)
         if fio_mapping_scud:
             raw_scud_today_df['fio_clean'] = raw_scud_today_df['fio_clean'].apply(
@@ -248,8 +441,30 @@ def main():
 
         raw_scud_today_df = aggregate_scud_by_employee(raw_scud_today_df, debug=DEBUG)
 
-        merged_today = raw_scud_today_df[raw_scud_today_df['fio_clean'].isin(staff_fios_today_clean)].copy()
-        merged_today = merged_today.merge(df_absent_today, on='fio_clean', how='left')
+        merged_today = df_staff_today.copy()
+        if not raw_scud_today_df.empty:
+            if 'Подразделение' in raw_scud_today_df.columns:
+                raw_scud_today_df['department_scud'] = raw_scud_today_df['Подразделение']
+            elif 'department' in raw_scud_today_df.columns:
+                raw_scud_today_df['department_scud'] = raw_scud_today_df['department']
+            else:
+                raw_scud_today_df['department_scud'] = ''
+
+            merged_today = merged_today.merge(
+                raw_scud_today_df[['fio_clean', 'Пришел', 'Начало_дня', 'Первая_активность', 'Конец_дня', 'Находился_в_здании', 'anomaly_flag', 'department_scud']], 
+                on='fio_clean', how='left'
+            )
+        
+        if df_absent_today is not None and not df_absent_today.empty:
+            merged_today = merged_today.merge(df_absent_today[['fio_clean', 'Вид_отсутствия']], on='fio_clean', how='left')
+
+        if 'Пришел' not in merged_today.columns:
+            merged_today['Пришел'] = False
+        else:
+            merged_today['Пришел'] = merged_today['Пришел'].fillna(False)
+
+        if 'Сотрудник' not in merged_today.columns:
+            merged_today['Сотрудник'] = merged_today.get('ФИО', merged_today['fio_clean'])
 
         if static_reasons_dict:
             for fio_clean, reason_val in static_reasons_dict.items():
@@ -260,6 +475,7 @@ def main():
                 )
                 merged_today.loc[mask_today, 'Вид_отсутствия'] = reason_val
 
+        merged_today = apply_exceptions_from_json(merged_today, exceptions_cfg)
         mask_exc_today = (
             (merged_today['Пришел'] == False) & 
             (merged_today['Вид_отсутствия'].isna() | (merged_today['Вид_отсутствия'].astype(str).str.strip() == '')) & 
@@ -267,30 +483,68 @@ def main():
         )
         merged_today.loc[mask_exc_today, 'Вид_отсутствия'] = 'Исключение (ОВК/Подрядчики)'
 
-        anomalies_list = detect_all_anomalies(merged_today, static_reasons_dict, kb_rules)
+        scud_fios_today_set = set(raw_scud_today_df['fio_clean'].dropna().tolist()) if not raw_scud_today_df.empty else set()
+        merged_today['no_scud_pass'] = (
+            (~merged_today['fio_clean'].isin(scud_fios_today_set)) & 
+            (merged_today['Вид_отсутствия'].isna() | (merged_today['Вид_отсутствия'].astype(str).str.strip() == '')) & 
+            (merged_today.get('is_excluded', False) == False)
+        )
 
-        # 💾 СОХРАНЕНИЕ СЕГОДНЯШНИХ АНОМАЛИЙ В БАЗУ ДАННЫХ SQLite
-        save_anomalies_to_db(anomalies_list, DATE_TODAY)
+        scud_fios_set = set(raw_scud_today_df['fio_clean'].dropna().tolist()) if not raw_scud_today_df.empty else set()
+        anomalies_list = detect_all_anomalies(merged_today, static_reasons_dict, kb_rules, scud_fios_set=scud_fios_set)
 
-        absent_explained = merged_today[(merged_today['Пришел'] == False) & (merged_today['Вид_отсутствия'].notna())]
-        absent_unexplained = merged_today[(merged_today['Пришел'] == False) & (merged_today['Вид_отсутствия'].isna())]
-        scud_present_but_absent_in_1c = merged_today[(merged_today['Пришел'] == True) & (merged_today['Вид_отсутствия'].notna())]
+        mass_failure_today = analyze_scud_mass_failure_ai(raw_scud_today_df)
+        if mass_failure_today and mass_failure_today.get("is_mass_failure"):
+            print("\n" + "!" * 60)
+            print(f"🚨 ВНИМАНИЕ! ИИ ОБНАРУЖИЛ ОПЕРАТИВНЫЙ СБОЙ ТУРНИКЕТОВ ВХОДА СЕГОДНЯ ({mass_failure_today['anomaly_percent']}% СМЕНЫ)")
+            print(mass_failure_today["alert_text"])
+            print("!" * 60 + "\n")
+
+        save_anomalies_to_db(anomalies_list, target_date_str)
+
+        is_no_pass_today = merged_today['no_scud_pass'] == True if 'no_scud_pass' in merged_today.columns else False
+        is_exc_today = merged_today.get('is_excluded', False) == True
+
+        absent_explained = merged_today[
+            (merged_today['Пришел'] == False) & 
+            (merged_today['Вид_отсутствия'].notna()) & 
+            (~merged_today['Вид_отсутствия'].astype(str).str.startswith('Исключение'))
+        ]
+
+        absent_unexplained = merged_today[
+            (merged_today['Пришел'] == False) & 
+            (merged_today['Вид_отсутствия'].isna() | (merged_today['Вид_отсутствия'].astype(str).str.strip() == '')) & 
+            (~is_no_pass_today) & 
+            (~is_exc_today)
+        ]
+
+        scud_present_but_absent_in_1c = merged_today[
+            (~is_exc_today) & 
+            (merged_today['Пришел'] == True) & 
+            (merged_today['Вид_отсутствия'].notna()) & 
+            (~merged_today['Вид_отсутствия'].astype(str).str.startswith('Исключение'))
+        ]
 
         print("[5/5] Запуск ИИ-аудитора и построение Ежедневной сводки...")
+        filtered_anomalies_list = [
+            a for a in anomalies_list 
+            if "ОТСУТСТВУЕТ В СКУД" not in a.get('type', '')
+        ]
+
         report_text = generate_markdown_report(
             merged_df=merged_today,
             absent_explained=absent_explained,
             absent_unexplained=absent_unexplained,
             scud_present_but_absent_in_1c=scud_present_but_absent_in_1c,
-            anomalies_list=anomalies_list,
+            anomalies_list=filtered_anomalies_list,
             raw_scud_df=raw_scud_today_df,
             raw_absent_df=df_absent_today,
-            date_str=DATE_TODAY
+            date_str=target_date_str
         )
 
-        generate_summary_excel(merged_df=merged_today, date_str=DATE_TODAY)
+        generate_summary_excel(merged_df=merged_today, date_str=target_date_str)
 
-        md_report_path = os.path.join(OUTPUT_DIR, f"Сводка_контроллинга_{DATE_TODAY}.md")
+        md_report_path = os.path.join(OUTPUT_DIR, f"Сводка_контроллинга_{target_date_str}.md")
         with open(md_report_path, "w", encoding="utf-8") as f:
             f.write(report_text)
         print(f"\n[✓] Текстовый отчет сохранен в: {md_report_path}")
@@ -311,8 +565,7 @@ def main():
         print("=" * 60)
         print(report_text)
     else:
-        print(f"\n[ℹ️] Формирование Ежедневной сводки за {DATE_TODAY} ПРОПУЩЕНО.")
-        print("     Ждём появления файлов 1С за текущую дату на сетевой шаре.")
+        print(f"\n[ℹ️] Формирование Ежедневной сводки за {target_date_str} ПРОПУЩЕНО.")
 
 
 if __name__ == "__main__":

modules/ai_verifier.py

@@ -1,104 +0,0 @@
-import json
-import re
-import requests
-from config import OLLAMA_URL, OLLAMA_MODEL
-from modules.database import get_all_rules_from_db
-
-
-def ask_ollama(prompt, system_prompt=None):
-    """
-    Универсальная функция отправки запросов к локальной модели Ollama (Qwen 2.5).
-    """
-    payload = {
-        "model": OLLAMA_MODEL,
-        "prompt": f"{system_prompt}\n\n{prompt}" if system_prompt else prompt,
-        "stream": False
-    }
-
-    try:
-        response = requests.post(OLLAMA_URL, json=payload, timeout=120)
-        if response.status_code == 200:
-            data = response.json()
-            if "response" in data:
-                return data["response"].strip()
-            elif "message" in data and "content" in data["message"]:
-                return data["message"]["content"].strip()
-            else:
-                return f"⚠️ Неизвестная структура ответа Ollama: {data}"
-        else:
-            return f"⚠️ Ошибка Ollama (Код {response.status_code}): {response.text}"
-    except requests.exceptions.ConnectionError:
-        return "⚠️ Не удалось подключиться к Ollama. Проверьте, запущен ли сервис (ollama run qwen2.5:14b)."
-    except Exception as e:
-        return f"⚠️ Ошибка при обращении к Ollama: {e}"
-
-
-def get_system_rules_context():
-    """
-    Загружает глобальные системные правила компании прямо из Базы Данных.
-    """
-    rules = get_all_rules_from_db()
-    if not rules:
-        return ""
-    rules_text = "\n".join([f"- {r}" for r in rules])
-    return f"\nОБЯЗАТЕЛЬНЫЕ ГЛОБАЛЬНЫЕ ПРАВИЛА И ПРИОРИТЕТЫ КОМПАНИИ:\n{rules_text}\n"
-
-
-def ai_verify_scud_against_staff(unrecognized_scud_fios, staff_fios):
-    """
-    ИИ-сверка опечаток и несовпадений ФИО между СКУД и 1С:ЗУП.
-    Записи из 1С считаются 100% эталоном.
-    """
-    if not unrecognized_scud_fios or not staff_fios:
-        return {}
-
-    rules_context = get_system_rules_context()
-
-    prompt = f"""
-Ты — кадровый аудитор безопасности СКУД.
-{rules_context}
-В СКУД записаны неопознанные ФИО: {json.dumps(unrecognized_scud_fios, ensure_ascii=False)}
-В официальном Штатном расписании 1С записаны ЭТАЛОНЫ: {json.dumps(staff_fios, ensure_ascii=False)}
-
-СТРОГИЕ ПРАВИЛА:
-1. Запись из Штат 1С — это 100% ПРАВИЛЬНЫЙ эталон.
-2. В СКУД допущена опечатка.
-3. Любое присутствие сотрудника по СКУД при наличии в 1С документа отсутствия (кроме командировок) является гарантированной аномалией.
-4. В поле "warning" опиши обнаруженную опечатку.
-5. Запрещено выдумывать опечатки!
-
-ОТВЕЧАЙ ТОЛЬКО ИСКЛЮЧИТЕЛЬНО В ФОРМАТЕ JSON!
-
-Формат ответа:
-{{
-  "verified_matches": [
-    {{
-      "scud_fio": "ФИО из СКУД",
-      "staff_fio": "эталон ФИО из Штат 1С",
-      "warning": "Описание опечатки в СКУД или 'Точное совпадение (без опечаток)'"
-    }}
-  ]
-}}
-"""
-    raw_response = ask_ollama(
-        prompt, 
-        system_prompt="Ты — JSON API. Выдавай ТОЛЬКО валидный JSON без markdown-разметки."
-    )
-    
-    mapping = {}
-    try:
-        match = re.search(r'\{.*\}', raw_response, re.DOTALL)
-        if match:
-            json_str = match.group(0)
-            json_str = re.sub(r'\}\s*[^}\]]*$', '}', json_str)
-            data = json.loads(json_str)
-            for item in data.get("verified_matches", []):
-                scud_f = item.get("scud_fio")
-                staff_f = item.get("staff_fio")
-                warn = item.get("warning", "Точное совпадение (без опечаток)")
-                if scud_f and staff_f:
-                    mapping[scud_f] = {"staff_fio": staff_f, "warning": warn}
-    except Exception as e:
-        print(f"[!] Ошибка разбора JSON от ИИ при сверке опечаток: {e}")
-    
-    return mapping

modules/data_loader.py

@@ -1,137 +0,0 @@
-import os
-import pandas as pd
-import warnings
-from config import (
-    normalize_fio, clean_scud_fio_light, load_exceptions, 
-    DATE_TODAY, DATE_YESTERDAY, find_dated_file, ZUP_1C_DIR, SCUD_DIR
-)
-# Импортируем прямую SQL-выгрузку отсутствий из 1С
-from modules.zup_extractor import fetch_zup_absences_from_sql
-
-warnings.filterwarnings('ignore', category=UserWarning, module='pandas')
-
-
-def is_excluded(fio, dept, pos, exceptions):
-    """Проверяет, входит ли сотрудник или должность в список исключений."""
-    fio_clean = normalize_fio(fio)
-    dept_str = str(dept).strip().upper() if pd.notna(dept) else ""
-    pos_str = str(pos).strip().lower() if pd.notna(pos) else ""
-
-    if fio_clean in exceptions["fio"] or dept_str in exceptions["departments"] or pos_str in exceptions["positions"]:
-        return True
-    if any(keyword in pos_str for keyword in exceptions["position_keywords"]):
-        return True
-    return False
-
-
-def load_staff_data(date_str):
-    """
-    Загружает файл Штатного расписания 1С за конкретную дату из папки 1c.
-    """
-    filepath = find_dated_file("Штат", date_str)
-    if not filepath:
-        fallback_path = os.path.join(ZUP_1C_DIR, "штат.xlsx")
-        if os.path.exists(fallback_path):
-            filepath = fallback_path
-        else:
-            return None
-
-    try:
-        df_raw = pd.read_excel(filepath, skiprows=8)
-        
-        # Индексы столбцов в файле 1С: 1 — ФИО, 5 — Подразделение, 12 — Должность
-        df_staff = df_raw.iloc[:, [1, 5, 12]].copy()
-        df_staff.columns = ['ФИО', 'Подразделение', 'Должность']
-        
-        df_staff = df_staff.dropna(subset=['ФИО']).reset_index(drop=True)
-        df_staff = df_staff[~df_staff['ФИО'].astype(str).str.contains('Всего|Организация|Сотрудник|ФИО', case=False, na=False)]
-        df_staff['fio_clean'] = df_staff['ФИО'].apply(normalize_fio)
-        return df_staff
-    except Exception as e:
-        print(f"[❌] Ошибка загрузки штата из {filepath}: {e}")
-        return None
-
-
-def load_absent_data(date_str):
-    """
-    Загружает документально подтвержденные отсутствия сотрудников
-    НАПРЯМУЮ из базы MS SQL 1С:ЗУП за указанную дату.
-    """
-    try:
-        df_absent = fetch_zup_absences_from_sql(date_str)
-        
-        if df_absent is not None and not df_absent.empty:
-            df_absent = df_absent.dropna(subset=['ФИО', 'Вид_отсутствия'])
-            df_absent = df_absent[~df_absent['ФИО'].astype(str).str.contains('АО "ЛЕНМОРНИИПРОЕКТ"|Сотрудник', case=False, na=False)]
-            df_absent['fio_clean'] = df_absent['ФИО'].apply(normalize_fio)
-            return df_absent[['fio_clean', 'Вид_отсутствия']].dropna(subset=['fio_clean'])
-        else:
-            return None
-    except Exception as e:
-        print(f"[⚠️] Ошибка SQL-выгрузки отсутствий за {date_str}: {e}")
-        return None
-
-
-def load_scud_data(target_date_type="today"):
-    """Загружает файл СКУД за 'today' или 'yesterday'."""
-    target_date = DATE_TODAY if target_date_type == "today" else DATE_YESTERDAY
-    scud_path = find_dated_file("Сотрудники", target_date, search_dirs=[SCUD_DIR])
-
-    if not scud_path:
-        scud_path = find_dated_file("Сотрудники", DATE_TODAY, search_dirs=[SCUD_DIR])
-        if not scud_path:
-            raise FileNotFoundError(f"Файл СКУД [{target_date_type}] за {target_date} не найден в {SCUD_DIR}!")
-
-    df_scud = pd.read_excel(scud_path)
-    exceptions = load_exceptions()
-
-    df_scud['fio_raw'] = df_scud['Сотрудник'].astype(str) if 'Сотрудник' in df_scud.columns else df_scud[df_scud.columns[0]].astype(str)
-    df_scud['fio_clean'] = df_scud['fio_raw'].apply(clean_scud_fio_light)
-
-    start_col = 'Начало_дня' if 'Начало_дня' in df_scud.columns else ('Начало дня' if 'Начало дня' in df_scud.columns else None)
-    status_col = 'Статус' if 'Статус' in df_scud.columns else None
-
-    def is_person_present(row):
-        val_status = str(row.get(status_col, '')).strip().lower() if status_col else ''
-        val_time = str(row.get(start_col, '')).strip() if start_col else ''
-        
-        if 'отсутствовал' in val_status or val_time in ['нет входа', 'none', 'nan', '', '00:00']:
-            return False
-        return True
-
-    df_scud['Пришел'] = df_scud.apply(is_person_present, axis=1)
-    
-    df_scud['is_excluded'] = df_scud.apply(
-        lambda r: is_excluded(r.get('Сотрудник', ''), r.get('Подразделение', ''), r.get('Должность', ''), exceptions),
-        axis=1
-    )
-    return df_scud
-
-
-def load_all_data():
-    """
-    Загружает слитные датасеты за Сегодня и за Вчера.
-    Если данных за Сегодня нет, возвращает для них None.
-    """
-    df_scud_today = load_scud_data(target_date_type="today")
-    try:
-        df_scud_yesterday = load_scud_data(target_date_type="yesterday")
-    except FileNotFoundError:
-        df_scud_yesterday = df_scud_today.copy()
-
-    # Загружаем 1С за Сегодня (может быть None)
-    df_staff_today = load_staff_data(DATE_TODAY)
-    df_absent_today = load_absent_data(DATE_TODAY)
-
-    # Загружаем 1С за Вчера (гарантированно есть)
-    df_staff_yesterday = load_staff_data(DATE_YESTERDAY)
-    df_absent_yesterday = load_absent_data(DATE_YESTERDAY)
-
-    return (
-        df_scud_today,
-        df_scud_yesterday,
-        df_staff_today,
-        df_absent_today,
-        df_staff_yesterday,
-        df_absent_yesterday
-    )

modules/database.py

@@ -1,271 +0,0 @@
-import os
-import sqlite3
-import json
-import pandas as pd
-from datetime import datetime
-from config import DATA_DIR
-
-DB_PATH = os.path.join(DATA_DIR, "scud_orion_ai.db")
-
-
-def get_connection():
-    """Создает подключение к базе данных SQLite с оптимизированными настройками."""
-    conn = sqlite3.connect(DB_PATH)
-    conn.execute("PRAGMA foreign_keys = ON;")
-    conn.execute("PRAGMA journal_mode = WAL;")  # Режим быстрого чтения/записи
-    return conn
-
-
-def init_db():
-    """Создает структуру таблиц и индексов в базе данных."""
-    with get_connection() as conn:
-        cursor = conn.cursor()
-
-        # 1. Таблица СКУД
-        cursor.execute("""
-        CREATE TABLE IF NOT EXISTS scud_logs (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            log_date TEXT NOT NULL,
-            fio TEXT NOT NULL,
-            fio_clean TEXT NOT NULL,
-            department TEXT,
-            position TEXT,
-            time_in TEXT,
-            time_out TEXT,
-            time_in_building TEXT,
-            is_present INTEGER NOT NULL,
-            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        );
-        """)
-
-        # 2. Таблица Штатного расписания 1С
-        cursor.execute("""
-        CREATE TABLE IF NOT EXISTS zup_staff (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            snapshot_date TEXT NOT NULL,
-            fio TEXT NOT NULL,
-            fio_clean TEXT NOT NULL,
-            department TEXT,
-            position TEXT,
-            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        );
-        """)
-
-        # 3. Таблица Отсутствий из 1С
-        cursor.execute("""
-        CREATE TABLE IF NOT EXISTS zup_absences (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            absence_date TEXT NOT NULL,
-            fio TEXT NOT NULL,
-            fio_clean TEXT NOT NULL,
-            absence_type TEXT NOT NULL,
-            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        );
-        """)
-
-        # 4. Реестр аномалий
-        cursor.execute("""
-        CREATE TABLE IF NOT EXISTS anomalies_history (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            anomaly_date TEXT NOT NULL,
-            fio TEXT NOT NULL,
-            anomaly_type TEXT NOT NULL,
-            details TEXT NOT NULL,
-            human_status TEXT DEFAULT 'Pending',
-            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        );
-        """)
-
-        # 5. База знаний ИИ
-        cursor.execute("""
-        CREATE TABLE IF NOT EXISTS ai_knowledge_base (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            rule_text TEXT UNIQUE NOT NULL,
-            added_by TEXT DEFAULT 'Human',
-            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        );
-        """)
-
-        # ⚡ ИНДЕКСЫ ДЛЯ УСКОРЕНИЯ ЗАПРОСОВ
-        cursor.execute("CREATE INDEX IF NOT EXISTS idx_scud_date ON scud_logs(log_date);")
-        cursor.execute("CREATE INDEX IF NOT EXISTS idx_scud_fio ON scud_logs(fio_clean);")
-        cursor.execute("CREATE INDEX IF NOT EXISTS idx_absences_date ON zup_absences(absence_date);")
-        cursor.execute("CREATE INDEX IF NOT EXISTS idx_staff_date ON zup_staff(snapshot_date);")
-        cursor.execute("CREATE INDEX IF NOT EXISTS idx_anomalies_date ON anomalies_history(anomaly_date);")
-
-        conn.commit()
-
-    # Автоматически загружаем базовые правила и системный промпт
-    sync_knowledge_base_to_db()
-
-
-def sync_knowledge_base_to_db():
-    """
-    Автоматически мигрирует правила из knowledge_base.json и системный промпт в таблицу ai_knowledge_base SQLite.
-    """
-    system_ai_prompt = (
-        "СИСТЕМНЫЙ ПРОМПТ ИИ (MATCHING & VERIFICATION):\n"
-        "Ты — экспертный ИИ-аудитор СКУД и кадрового учета 1С. Твоя задача — проводить интеллектуальный анализ аномалий "
-        "и сопоставление (Fuzzy Matching) нераспознанных ФИО из СКУД с эталонным Штатным расписанием 1С.\n\n"
-        "1. ЗАЩИТА ОТ ПОЛНЫХ ТЁЗОК (FULL NAME COLLISION):\n"
-        "   - Если в эталонном штате 1С присутствуют два или более сотрудников с ОДИНАКОВЫМИ ФИО (полные тёзки), "
-        "ты ОБЯЗАН учитывать контекст: Подразделение и Должность.\n"
-        "   - Ни в коем случае не объединяй записи разных людей! Если контекст не позволяет однозначно определить, кто именно из тёзок совершил проход, ПОМЕТЬ СЛУЧАЙ КАК НЕОДНОЗНАЧНЫЙ и НЕ делай автоматическую подмену.\n\n"
-        "2. ПРАВИЛА СОПОСТАВЛЕНИЯ (MATCHING RULES):\n"
-        "   - Допускаются исправления мелких опечаток, перестановки порядка (Имя Фамилия -> Фамилия Имя), замена букв Е/Ё, И/Й.\n"
-        "   - Учитывай сокращения инициалов (например, 'Иванов И.В.' -> 'Иванов Иван Васильевич').\n"
-        "   - Если уверенность в совпадении меньше 85% — НЕ сопоставляй, оставляй запись как нераспознанную.\n\n"
-        "3. ФОРМАТ ВЫХОДНЫХ ДАННЫХ:\n"
-        "   Верни строго JSON-объект без вводных слов и Markdown-разметки: {\"mappings\": [...], \"unmatched\": [...]}"
-    )
-
-    rules_to_insert = [
-        system_ai_prompt,
-        "ГЛОБАЛЬНОЕ ПРАВИЛО 1: Любое физическое присутствие сотрудника по СКУД при наличии в 1С документа отсутствия (отпуск, больничный, уход за ребенком и др.), КРОМЕ командировок и служебных поездок — ЯВЛЯЕТСЯ СТРОГОЙ ИСТИННОЙ АНОМАЛИЕЙ.",
-        "ГЛОБАЛЬНОЕ ПРАВИЛО 2: Документы отсутствий из 1С:ЗУП имеют 100% высший приоритет над статическим реестром удалёнщиков.",
-        "ГЛОБАЛЬНОЕ ПРАВИЛО 3: Удалённые сотрудники имеют право беспрепятственно работать в офисе по СКУД в любое время (это не является аномалией)."
-    ]
-
-    kb_path = os.path.join(os.path.dirname(DATA_DIR), "knowledge_base.json")
-    if os.path.exists(kb_path):
-        try:
-            with open(kb_path, "r", encoding="utf-8") as f:
-                kb_data = json.load(f)
-                file_rules = kb_data.get("rules", [])
-                for r in file_rules:
-                    if r not in rules_to_insert:
-                        rules_to_insert.append(r)
-        except Exception as e:
-            print(f"[⚠️] Ошибка чтения knowledge_base.json: {e}")
-
-    with get_connection() as conn:
-        cursor = conn.cursor()
-        for rule in rules_to_insert:
-            cursor.execute(
-                "INSERT OR IGNORE INTO ai_knowledge_base (rule_text, added_by) VALUES (?, ?)",
-                (rule.strip(), "System_AI")
-            )
-        conn.commit()
-
-
-def save_scud_to_db(df_scud, date_str):
-    """Оптимизированное сохранение логов СКУД за дату."""
-    if df_scud.empty:
-        return
-
-    data_to_insert = []
-    for _, r in df_scud.iterrows():
-        data_to_insert.append((
-            date_str,
-            r.get('Сотрудник', r.get('fio_raw', '')),
-            r.get('fio_clean', ''),
-            r.get('Подразделение', ''),
-            r.get('Должность', ''),
-            r.get('Начало_дня', 'Нет входа'),
-            r.get('Конец_дня', 'Нет выхода'),
-            r.get('Находился_в_здании', '00:00'),
-            1 if r.get('Пришел', False) else 0
-        ))
-
-    with get_connection() as conn:
-        cursor = conn.cursor()
-        cursor.execute("DELETE FROM scud_logs WHERE log_date = ?", (date_str,))
-        cursor.executemany("""
-            INSERT INTO scud_logs (log_date, fio, fio_clean, department, position, time_in, time_out, time_in_building, is_present)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-        """, data_to_insert)
-        conn.commit()
-
-
-def save_staff_to_db(df_staff, date_str):
-    """Сохраняет выгрузку Штатного расписания 1С в БД."""
-    if df_staff is None or df_staff.empty:
-        return
-
-    data_to_insert = []
-    for _, r in df_staff.iterrows():
-        data_to_insert.append((
-            date_str,
-            r.get('ФИО', ''),
-            r.get('fio_clean', ''),
-            r.get('Подразделение', ''),
-            r.get('Должность', '')
-        ))
-
-    with get_connection() as conn:
-        cursor = conn.cursor()
-        cursor.execute("DELETE FROM zup_staff WHERE snapshot_date = ?", (date_str,))
-        cursor.executemany("""
-            INSERT INTO zup_staff (snapshot_date, fio, fio_clean, department, position)
-            VALUES (?, ?, ?, ?, ?)
-        """, data_to_insert)
-        conn.commit()
-
-
-def save_absences_to_db(df_absent, date_str):
-    """Оптимизированное сохранение отсутствий из 1С в БД."""
-    if df_absent is None or df_absent.empty:
-        return
-
-    data_to_insert = []
-    for _, r in df_absent.iterrows():
-        data_to_insert.append((
-            date_str,
-            r.get('ФИО', r.get('fio_clean', '')),
-            r.get('fio_clean', ''),
-            r.get('Вид_отсутствия', '')
-        ))
-
-    with get_connection() as conn:
-        cursor = conn.cursor()
-        cursor.execute("DELETE FROM zup_absences WHERE absence_date = ?", (date_str,))
-        cursor.executemany("""
-            INSERT INTO zup_absences (absence_date, fio, fio_clean, absence_type)
-            VALUES (?, ?, ?, ?)
-        """, data_to_insert)
-        conn.commit()
-
-
-def save_anomalies_to_db(anomalies_list, date_str):
-    """Записывает обнаруженные аномалии за дату."""
-    if not anomalies_list:
-        return
-
-    data_to_insert = [
-        (date_str, a.get('fio', ''), a.get('type', ''), a.get('details', ''))
-        for a in anomalies_list
-    ]
-
-    with get_connection() as conn:
-        cursor = conn.cursor()
-        cursor.execute("DELETE FROM anomalies_history WHERE anomaly_date = ?", (date_str,))
-        cursor.executemany("""
-            INSERT INTO anomalies_history (anomaly_date, fio, anomaly_type, details)
-            VALUES (?, ?, ?, ?)
-        """, data_to_insert)
-        conn.commit()
-
-
-def get_all_rules_from_db():
-    """Возвращает список всех правил для ИИ из базы данных."""
-    with get_connection() as conn:
-        cursor = conn.cursor()
-        cursor.execute("SELECT rule_text FROM ai_knowledge_base")
-        rows = cursor.fetchall()
-        return [r[0] for r in rows]
-
-
-def add_rule_to_db(rule_text, added_by="Human"):
-    """Добавляет новое динамическое правило в базу данных."""
-    if not rule_text or not rule_text.strip():
-        return
-    with get_connection() as conn:
-        cursor = conn.cursor()
-        try:
-            cursor.execute(
-                "INSERT OR IGNORE INTO ai_knowledge_base (rule_text, added_by) VALUES (?, ?)",
-                (rule_text.strip(), added_by)
-            )
-            conn.commit()
-        except Exception as e:
-            print(f"[⚠️] Ошибка записи правила в БД: {e}")

modules/knowledge_base.py

@@ -1,20 +0,0 @@
-import json
-import os
-
-KB_FILE = os.path.join("data", "knowledge_base.json")
-
-def load_knowledge_base():
-    """Загружает накопленный опыт и правила компании"""
-    if not os.path.exists(KB_FILE):
-        return {"rules": [], "fio_corrections": {}}
-    with open(KB_FILE, "r", encoding="utf-8") as f:
-        return json.load(f)
-
-def add_rule_to_kb(new_rule):
-    """Добавляет новое правило, принятое человеком, в базу знаний"""
-    kb = load_knowledge_base()
-    if new_rule not in kb["rules"]:
-        kb["rules"].append(new_rule)
-        with open(KB_FILE, "w", encoding="utf-8") as f:
-            json.dump(kb, f, ensure_ascii=False, indent=2)
-        print(f"[✓] База знаний обновлена! Новое правило: {new_rule}")

project_snapshot_scud_orion_ai_v2.md

@@ -0,0 +1,252 @@
+О’кей хорошо! Ниже представлена полностью объединенная и систематизированная история развития проекта **`scud_orion_ai_v2`**. В нее вошел весь путь: от стартовых инцидентов с файлами 1С и отладкой MS SQL Ориона до текущей архитектуры со снапшотами, двойной фильтрацией исключений и SQLite-базой знаний.
+
+---
+
+# 🚀 ПОЛНАЯ ИСТОРИЯ РАЗВИТИЯ И СНАПШОТ ПРОЕКТА: SCUD ORION AI (v2)
+
+**Дата актуализации:** 05.08.2026  
+**Статус проекта:** Производственный релиз (*Production-Ready*) с поддержкой снапшотов, двойной фильтрацией исключений, лаконичным форматированием и синхронизацией SQLite.  
+**Общий объем кода:** ~2 620 строк Python (17 модулей + CLI-инструментарий)  
+
+---
+
+## 📌 1. НАЗНАЧЕНИЕ И АРХИТЕКТУРА СИСТЕМЫ
+
+Проект **`scud_orion_ai_v2`** — это система автоматизированного кадрового контроллинга и аудита трудовой дисциплины. Система сопоставляет логи физических проходов СКУД «Орион Pro» (MS SQL Server) с кадровыми данными и документами отсутствия из 1С:ЗУП 3.1 (MS SQL Server / Сетевая шара), а также выполняет квалификацию отклонений с помощью локальной LLM (Ollama / Qwen 2.5 14B).  
+
+### 💻 Ключевой стек технологий:
+* **Язык разработки:** Python 3.12 (в изолированном `venv`).
+* **СУБД СКУД (Источник):** MS SQL Server (`Orion-14.01.21-1` на хосте `172.16.31.221\SQL`).
+* **СУБД 1С (Источник):** MS SQL Server (`ACCOUNT-01`, БД `zup_db`).
+* **Фоллбэк/Обмен:** Сетевая Linux-шара (`/mnt/scud_share`).
+* **Локальная СУБД (Проект):** SQLite (`data/scud_orion_ai.db` с поддержкой WAL-режима и истории снапшотов).  
+* **AI Engine:** Ollama API (`http://192.168.11.3:11434/api/generate`, модель `qwen2.5:14b`).  
+* **CLI & Репорты:** `pandas`, `openpyxl`, `pyodbc`, `sqlite3`.
+
+---
+
+## 📜 2. ПОЛНАЯ ХРОНОЛОГИЯ ИНЦИДЕНТОВ И РЕШЕНИЙ
+
+### 🔹 Инцидент 1: Ошибка распарсивания Excel-файлов Штатного расписания 1С
+* **Симптом:** `KeyError: 'ФИО'` при запуске `main.py` на этапе загрузки штата из `/data/1c/Штат_DD_MM_YYYY.xlsx`.
+* **Причина:** Файлы экспорта 1С выгружаются со служебным заголовком. При `skiprows=7` датафрейм воспринимал строку с именами колонок как данные, присваивая столбцам имена `Unnamed: 0`, `Unnamed: 1`.
+* **Решение:** Перешли от обращения по текстовым именам колонок к позиционному связыванию через `.iloc[:, [1, 5, 12]]` (индексы: `1` — ФИО, `5` — Подразделение, `12` — Должность) со сдвигом `skiprows=8`.
+
+### 🔹 Инцидент 2: Падение сетевого подключения к MS SQL Server 1С (`Login timeout expired`)
+* **Симптом:** Соединение к MS SQL падало по таймауту (`HYT00`), приводя к отсутствию таблицы `zup_absences` в памяти и `KeyError: 'Вид_отсутствия'`.
+* **Причина:** В модуле `zup_extractor.py` находились дефолтные тестовые параметры подключения (`192.168.1.10`) вместо продакшн-конфигурации.
+* **Решение:**
+  * Перевели `zup_extractor.py` на прямой импорт параметров из `config.py` (сервер `ACCOUNT-01`).
+  * В `services/data_loader.py` реализован гибридный фоллбэк: при недоступности MS SQL 1С система автоматически считывает локальные файлы `Отсутствия_DD_MM_YYYY.xlsx` из папки `data/1c/` (копируемые с шары `/mnt/scud_share`).
+
+### 🔹 Инцидент 3: Аномалия УРВ «Орион Pro» (Случай сотрудника Равина В.Э.)
+* **Симптом:** В выгрузке `scud_export.py` сотрудник числился присутствовавшим (вход в 14:11:06), а в отчете УРВ «Орион Pro» стоял статус «Нет входа» / 0:00 отработанных часов.
+* **Расследование в SSMS:** Был установлен истинный системный ключ в базе Ориона: `pList.ID = 2107` (`pList.TabNumber = 13058`, а связка логов идет по `pLogData.HozOrgan = pList.ID`). Прямой запрос к сырым логам `pLogData` вернул события: `13:51:15` — Выход (Event 28/32), `14:11:06` — Вход (Event 28/32).
+* **Причина расхождения:** День сотрудника начался с фиксации Выхода в 13:51 (приход утром без прикладывания карты). Модуль УРВ «Ориона» не смог корректно сопоставить смену, начинающуюся с выхода, и обнулил табель.
+* **Вывод для системы:** Первичные физические логи `pLogData` (события 28/32) обладают 100% приоритетом над расчетным модулем УРВ Ориона.
+
+### 🔹 Инцидент 4: Ошибка нулевых показателей при `--skip-export`
+* **Причина:** В запросе к SQLite использовалось жесткое равенство по метке времени `snapshot_time`. Если секунды среза отличались, запрос возвращал 0 строк.
+* **Решение:** Введены составные ID снапшотов (`20260805-001`, `Y20260805-001`) и ступенчатый fallback-механизм в `core/database.py`: если точного времени нет, подтягивается самый свежий имеющийся срез за указанную дату.  
+
+### 🔹 Инцидент 5: Потеря названий отделов и должностей (`—`, `—`)
+* **Причина:** Колонки в базе SQLite назывались `department` и `position`, а отчет требовал `Подразделение` и `Должность`.
+* **Решение:** В `core/database.py` добавлен автоматический маппинг колонок при считывании из SQLite, а в `main.py` — подтягивание метаданных из 1С:Штат.
+
+### 🔹 Инцидент 6: Раздутый список «Неизвестных случаев» (21 чел $\rightarrow$ 11 чел)
+* **Причина:** В 1С отделы записаны полными именами (*«Отдел внутреннего контроля»*), а в `exceptions.json` — аббревиатурами (*«ОВК»*). Из-за этого контролеры ОВК, клининг и подрядчики не находились алгоритмом и попадали в неизвестные.
+* **Решение:** Реализована двойная проверка в `main.py`: при объединении данных сохраняется родная аббревиатура из MS SQL СКУД (`department_scud`). Функция `apply_exceptions_from_json` проводит поиск и по имени 1С, и по короткой аббревиатуре СКУД.
+
+---
+
+## 🛡️ 3. АРХИТЕКТУРА БЕЗОПАСНОСТИ И ПРИОРИТЕТОВ
+
+### 👥 Защита от «Полных Тёзок» (Full Name Collision)
+1. **Уровень 1 (БД & SQL):** Использование строго уникальных идентификаторов (`pList.ID` в СКУД, GUID/Табельный номер в 1С).
+2. **Уровень 2 (Составные ключи):** При мёрдже без прямых ID применяется контекстный ключ:
+   $$	ext{Composite Key} = 	ext{fio\_clean} + 	ext{"\_"} + 	ext{department} + 	ext{"\_"} + 	ext{position}$$
+3. **Уровень 3 (AI-Валидатор):** Системный промпт LLM запрещает объединять записи полных тёзок при разнице в отделе или должности.  
+
+### ⚙️ Иерархия приоритетов статуса сотрудника:
+
+<div style="text-align:center; margin:1em 0; font-size:1.05em;">
+
+<span class="math">Status = </span>
+<span class="math">
+ Пришел (по СКУД), если есть вход или активность<br/>
+ Документ 1С:ЗУП (Отпуск, Больничный...), высший приоритет над исключениями<br/>
+ Причина из static_reason_workers.csv, если указан удаленщик<br/>
+ Исключение (ОВК/Подрядчики), если подпадает под exceptions.json и в 1С ПУСТО<br/>
+ Неизвестно (Истинно неотмеченный), если офисный сотрудник без проходов и без 1С
+</span>
+
+</div>
+
+---
+
+## 📁 4. СТРУКТУРА КАТАЛОГОВ И ИСПРАВЛЕННЫХ МОДУЛЕЙ
+
+```text
+scud_orion_ai_v2/
+├── config.py                   # Глобальная конфигурация, пути, параметры SQL и LLM (Ollama)
+├── main.py                     # Главный оркестратор пайплайна (СКУД ⟷ 1С, ИИ-аудит, Excel/MD)
+├── exceptions.json             # Исключения (подрядчики, ОВК, клининг, списки ФИО)
+├── core/
+│   ├── __init__.py
+│   └── database.py             # Схема SQLite, таблицы scud_logs, zup_staff, ai_knowledge_base
+├── services/
+│   ├── __init__.py
+│   ├── scud_export.py          # Выгрузка СКУД из MS SQL Орион Pro + расчет первой активности
+│   ├── zup_extractor.py        # Выгрузка отсутствий из MS SQL 1С:ЗУП 3.1
+│   ├── share_copier.py         # Копирование XLSX файлов с шары /mnt/scud_share
+│   ├── data_loader.py          # Загрузка, очистка и маркировка аномалий СКУД/1С
+│   ├── data_validator.py       # Проверка свежести входных файлов
+│   ├── excel_exporter.py       # Формирование Excel-сводок и детальных отчетов (.xlsx)
+│   ├── ai_verifier.py          # Взаимодействие с Ollama (Qwen 2.5): сверка ФИО и сбои
+│   ├── text_reporter.py        # Генерация итогового Markdown-отчета (.md)
+│   ├── feedback_loop.py        # Контур обучения ИИ (Human-in-the-Loop)
+│   └── knowledge_base.py       # Загрузка и пополнение Базы Знаний ИИ через SQLite
+├── scripts/
+│   ├── __init__.py
+│   ├── migrate_db.py           # Мигратор схемы SQLite БД
+│   └── db_cli.py               # CLI утилита управления БД, снапшотами и экспорта в Excel
+├── data/                       # Локальная SQLite БД, выгрузки 1С, СКУД
+│   ├── scud_orion_ai.db
+│   └── static_reason_workers.csv
+└── output/                     # Готовые сводки и отчеты (.xlsx, .md)
+```
+
+---
+
+## 🛠 5. СПРАВОЧНИК КОМАНД И ЗАПУСКА
+
+### 1. Главный скрипт (`main.py`)
+
+```bash
+python main.py [ФЛАГИ]
+```
+
+| Команда / Флаг | Описание |
+| :--- | :--- |
+| `python main.py` | Обычный полный дневной запуск |
+| `python main.py --skip-export` | Расчет по последнему имеющемуся снапшоту из SQLite |
+| `python main.py --snapshot 20260805-001` | Расчет строго по ID конкретного снапшота |
+| `python main.py -d` | Режим расширенной отладки (DEBUG) |
+
+---
+
+### 2. CLI-утилита инспекции БД (`scripts/db_cli.py`)
+> Прототип Сервисного Слоя для будущего REST API.
+
+```bash
+python scripts/db_cli.py <КОМАНДА> [ПАРАМЕТР] [ФЛАГИ]
+```
+
+| Команда | Описание |
+| :--- | :--- |
+| `python scripts/db_cli.py scud` | Просмотр логов СКУД за сегодня |
+| `python scripts/db_cli.py scud --snapshot 20260805-001` | Просмотр логов конкретного снапшота |
+| `python scripts/db_cli.py scud --export-xlsx debug_today` | Экспорт среза СКУД в Excel |
+| `python scripts/db_cli.py snapshots` | Список всех снапшотов |
+| `python scripts/db_cli.py anomalies` | История найденных аномалий |
+| `python scripts/db_cli.py rules` | Правила Базы Знаний ИИ из SQLite |
+| `python scripts/db_cli.py dump [output.xlsx]` | Полный дамп всех таблиц БД в Excel |
+
+---
+
+📐 Сквозной цикл работы контроллинга SCUD Orion AI (v2)
+🔄 Схема движения данных
+
+               ┌────────────────────────────────────────┐
+               │    Входные CLI-параметры main.py       │
+               │ (--skip-export / --snapshot / --debug) │
+               └───────────────────┬────────────────────┘
+                                   │
+      ┌────────────────────────────┴───────────────────────────┐
+      ▼                                                        ▼
+┌───────────────────────────────┐            ┌───────────────────────────────────┐
+│  0. MS SQL Орион Pro (СКУД)   │            │  0.5 Сетевая шара /mnt/scud_share │
+│  scud_export.py (Первая акт.) │            │  share_copier.py (Штат и Отсут.)  │
+└──────────────┬────────────────┘            └─────────────────┬─────────────────┘
+               │                                               │
+               ▼                                               ▼
+┌───────────────────────────────┐            ┌───────────────────────────────────┐
+│  SQLite: scud_logs            │            │  data/1c/Штат & Отсутствия        │
+│  (Сохранение snapshot_id)     │            │  (Файлы Excel за сегодня/вчера)   │
+└──────────────┬────────────────┘            └─────────────────┬─────────────────┘
+               │                                               │
+               └───────────────────────┬───────────────────────┘
+                                       │
+                                       ▼
+                     ┌───────────────────────────────────┐
+                     │ 1. data_validator.py              │
+                     │ (Проверка свежести и остановок)   │
+                     └─────────────────┬─────────────────┘
+                                       │
+                                       ▼
+                     ┌───────────────────────────────────┐
+                     │ 2. data_loader.py                 │
+                     │ (Фоллбэки + Загрузка + Scud Dept) │
+                     └─────────────────┬─────────────────┘
+                                       │
+                                       ▼
+                     ┌───────────────────────────────────┐
+                     │ 3. ИИ-Арбитраж & SQLite KB        │
+                     │ (Qwen 2.5 + ai_knowledge_base)   │
+                     └─────────────────┬─────────────────┘
+                                       │
+                                       ▼
+                     ┌───────────────────────────────────┐
+                     │ 4. Иерархическое сведение         │
+                     │ (1С -> CSV -> exceptions.json)    │
+                     └─────────────────┬─────────────────┘
+                                       │
+                   ┌───────────────────┴───────────────────┐
+                   ▼                                       ▼
+      ┌──────────────────────────┐            ┌──────────────────────────┐
+      │     Данные за ВЧЕРА      │            │    Данные за СЕГОДНЯ     │
+      └────────────┬─────────────┘            └────────────┬─────────────┘
+                   │                                       │
+                   ▼                                       ▼
+      ┌──────────────────────────┐            ┌──────────────────────────┐
+      │ Detailed Excel (.xlsx)   │            │ Summary Excel (.xlsx)    │
+      │ Детальный разбор вчера   │            │ + Markdown сводка (.md)  │
+      └────────────┬─────────────┘            └────────────┬─────────────┘
+                   │                                       │
+                   └───────────────────┬───────────────────┘
+                                       │
+                                       ▼
+                     ┌───────────────────────────────────┐
+                     │ 5. feedback_loop.py               │
+                     │ ( Human-in-the-Loop обучение ИИ ) │
+                     └─────────────────┬─────────────────┘
+                                       │
+                                       ▼
+                     ┌───────────────────────────────────┐
+                     │ SQLite: scud_orion_ai.db          │
+                     │ (Фиксация логов, аномалий и KB)   │
+                     └───────────────────────────────────┘
+🛠 Подробное описание каждого этапа
+Этап	Модуль	Описание и выполняемые задачи
+0. СКУД Экспорт	services/scud_export.py	Запрос к MS SQL «Орион Pro», вычисление утреннего входа и первой активности (first_activity), запись в SQLite с присвоением snapshot_id.
+0.5. Копирование 1С	services/share_copier.py	Забор актуальных Excel-файлов Штатного расписания и Отсутствий из Linux-шары /mnt/scud_share.
+1. Валидация	services/data_validator.py	Проверка наличия кадровых данных за вчерашний день. При критическом отсутствии файлов блокирует расчет.
+2. Загрузка	services/data_loader.py	Загрузка датасетов, нормализация ФИО и проброс родных коротких аббревиатур отделов из СКУД (department_scud).
+3. ИИ-Аудит	services/ai_verifier.py	Запрос к локальной LLM Ollama (Qwen 2.5) с подгрузкой контекста правил из SQLite-таблицы ai_knowledge_base. Исправление опечаток ФИО и отслеживание сбоев турникетов (>5%).
+4. Сведение	main.py	Применение иерархии приоритетов: 1С:ЗУП → static_csv → exceptions.json (проверка по 1С и department_scud) → Неизвестные.
+5. Отчетность & Обучение	
+excel_exporter.py
+
+
+text_reporter.py
+
+
+feedback_loop.py
+
+Формирование Excel-файлов, сборка текста Markdown с аббревиатурами и запись вердиктов кадровика в SQLite.
+
+## 🔮 6. БУДУЩИЕ ТОЧКИ РОСТА (ДОРОЖНАЯ КАРТА ВЕБ-РЕЛИЗА)
+
+1. **REST API на FastAPI:** Перенос функций из `db_cli.py` в эндпоинты (`/api/v1/snapshots`, `/api/v1/scud/logs`, `/api/v1/anomalies`).
+2. **ИИ-Чат с поддержкой Function Calling:** Предоставление Ollama (Qwen 2.5) права прямого вызова эндпоинтов API из чата по запросу пользователя (*«Сформируй срез за 12:00 и экспортируй в Excel»*).
+3. **Telegram-уведомления:** Автоматическая отправка алертов администраторам при выявлении массовых сбоев турникетов (>5%).

scripts/add_rule_ai.py

@@ -0,0 +1,19 @@
+import sys
+import os
+
+# Добавляем корень проекта в путь поиска модулей Python
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from core.database import get_connection
+
+rule_text = (
+    "Сотрудники, присутствующие в 1С:ЗУП, но отсутствующие в СКУД Орион Pro, "
+    "являются аномалией синхронизации профилей. ИИ должен запрашивать у СБ статус выдачи пропуска."
+)
+
+with get_connection() as conn:
+    cursor = conn.cursor()
+    cursor.execute("INSERT OR IGNORE INTO ai_knowledge_base (rule_text) VALUES (?)", (rule_text,))
+    conn.commit()
+
+print("✓ Правило успешно внесено в SQLite БД!")

scripts/db_cli.py

@@ -1,128 +1,348 @@
-import sys
 import os
+import sys
+import argparse
 import sqlite3
 import pandas as pd
+from datetime import datetime
 
-# Добавляем корневую директорию проекта в sys.path
-SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
-PROJECT_ROOT = os.path.dirname(SCRIPT_DIR)
-sys.path.append(PROJECT_ROOT)
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
-from config import DATA_DIR
+from config import DATA_DIR, DATE_TODAY, OUTPUT_DIR
+from core.database import (
+    get_connection, 
+    get_available_snapshots, 
+    get_all_rules_from_db,
+    load_scud_from_db_by_snapshot,
+    get_latest_snapshot_time
+)
 
 DB_PATH = os.path.join(DATA_DIR, "scud_orion_ai.db")
 
 
-def query_db(sql, params=()):
-    """Выполняет SQL-запрос к локальной БД и возвращает результат в виде DataFrame."""
-    if not os.path.exists(DB_PATH):
-        print(f"❌ База данных не найдена: {DB_PATH}")
-        return None
-    try:
-        conn = sqlite3.connect(DB_PATH)
-        df = pd.read_sql_query(sql, conn, params=params)
-        conn.close()
-        return df
-    except Exception as e:
-        print(f"❌ Ошибка выполнения запроса: {e}")
-        return None
+def print_stats():
+    """Выводит общую статистику по записям в таблицах БД."""
+    print("\n" + "=" * 60)
+    print("📊 СТАТИСТИКА БАЗЫ ДАННЫХ SQLITE (scud_orion_ai.db):")
+    print("=" * 60)
+    with get_connection() as conn:
+        cursor = conn.cursor()
+        tables = ['scud_logs', 'zup_staff', 'zup_absences', 'anomalies_history', 'ai_knowledge_base']
+        for t in tables:
+            cursor.execute(f"SELECT COUNT(*) FROM {t}")
+            cnt = cursor.fetchone()[0]
+            print(f"  • Таблица [{t:<18}]: {cnt:>6} записей")
+    print("=" * 60 + "\n")
 
 
-def print_db_stats():
-    """Выводит статистику по количеству записей во всех таблицах базы данных."""
-    if not os.path.exists(DB_PATH):
-        print(f"❌ База данных не найдена: {DB_PATH}")
+def print_snapshots_list(date_str=None):
+    """Выводит реестр снапшотов с отображением даты и точного времени среза."""
+    rows = get_available_snapshots(date_str)
+    
+    print("\n" + "=" * 105)
+    print(f"📸 РЕЕСТР СОХРАНЕННЫХ СНАПШОТОВ (СВЕРХУ СВЕЖИЕ) {'ЗА ЛОГИ ' + date_str if date_str else ''}:")
+    print("=" * 105)
+    
+    header = f"{'ID снапшота':<16} | {'Дата снапшота (создания)':<24} | {'Дата и время среза':<20} | {'Записей':<8}"
+    print(header)
+    print("-" * 105)
+
+    if not rows:
+        print("Снапшотов пока нет.")
+        print("=" * 105 + "\n")
         return
 
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
-    tables = [t[0] for t in cursor.fetchall() if t[0] != 'sqlite_sequence']
+    def snapshot_sort_key(row):
+        snap_id = row[0] or ""
+        snap_time = row[2] or ""
+        
+        seq_num = 0
+        if "-" in snap_id:
+            parts = snap_id.replace("Y", "").split("-")
+            if len(parts) > 1 and parts[1].isdigit():
+                seq_num = int(parts[1])
+                
+        return (snap_time, seq_num)
 
-    print("\n" + "=" * 55)
-    print(f"📊 СТАТИСТИКА ЛОКАЛЬНОЙ БАЗЫ ДАННЫХ: {DB_PATH}")
-    print("=" * 55)
+    sorted_rows = sorted(rows, key=snapshot_sort_key, reverse=True)
 
-    for t in tables:
-        cursor.execute(f"SELECT COUNT(*) FROM {t}")
-        count = cursor.fetchone()[0]
-        print(f"  • {t:<22} : {count} строк")
+    for r in sorted_rows:
+        snap_id = r[0] if r[0] else '----------'
+        log_date = r[1] if r[1] else '—'
+        snap_time = r[2] if r[2] else '—'
+        count = r[3]
 
-    conn.close()
-    print("=" * 55 + "\n")
+        time_part = "—"
+        if snap_time and " " in snap_time:
+            time_part = snap_time.split(" ")[1]
+
+        slice_datetime_str = f"{log_date} {time_part}" if time_part != "—" else log_date
+
+        if not snap_id.startswith("Y"):
+            formatted_snap_id = f" {snap_id}"
+        else:
+            formatted_snap_id = snap_id
+        
+        print(f"{formatted_snap_id:<16} | {snap_time:<24} | {slice_datetime_str:<20} | {count:<8}")
+
+    print("=" * 105 + "\n")
 
 
-if __name__ == "__main__":
-    if len(sys.argv) < 2:
-        print("\nИспользование CLI-модуля базы данных:")
-        print("  python scripts/db_cli.py stats                    -- Посмотреть статистику таблиц БД")
-        print("  python scripts/db_cli.py anomalies                -- Просмотреть все обнаруженные аномалии")
-        print("  python scripts/db_cli.py rules                    -- Просмотреть все правила Базы Знаний ИИ")
-        print("  python scripts/db_cli.py scud 03.08.2026           -- Посмотреть логи СКУД за конкретную дату")
-        print("  python scripts/db_cli.py staff 03.08.2026          -- Посмотреть Штатное расписание за дату")
-        print("  python scripts/db_cli.py absences 03.08.2026       -- Посмотреть отсутствия из 1С за дату")
-        print("  python scripts/db_cli.py dump [filename.xlsx]      -- Дамп всей базы SQLite в Excel-файл")
+def delete_snapshot_by_id(snapshot_id: str):
+    """Удаляет конкретный снапшот из таблицы scud_logs по его ID."""
+    with get_connection() as conn:
+        cursor = conn.cursor()
+        cursor.execute("DELETE FROM scud_logs WHERE snapshot_id = ?", (snapshot_id,))
+        deleted_count = cursor.rowcount
+        conn.commit()
+    print(f"\n[✓] Успешно удален снапшот [{snapshot_id}]. Удалено строк: {deleted_count}\n")
+    return deleted_count
+
+
+def delete_snapshots_by_date(date_str: str):
+    """Удаляет все снапшоты за указанную дату (например, '04.08.2026')."""
+    with get_connection() as conn:
+        cursor = conn.cursor()
+        cursor.execute("DELETE FROM scud_logs WHERE log_date = ? OR snapshot_id LIKE ?", (date_str, f"%{date_str.replace('.', '')}%"))
+        deleted_count = cursor.rowcount
+        conn.commit()
+    print(f"\n[✓] Успешно удалены все снапшоты за дату [{date_str}]. Удалено строк: {deleted_count}\n")
+    return deleted_count
+
+
+def inspect_scud(snapshot_id=None, date_str=None, export_xlsx=None):
+    """Инспектирует логи СКУД за выбранный снапшот или дату и опционально сохраняет XLSX."""
+    target_date = date_str if date_str else DATE_TODAY
+    
+    print("\n" + "=" * 90)
+    if snapshot_id:
+        print(f"🔍 ИНСПЕКЦИЯ СКУД ПО СНАПШОТУ [{snapshot_id}] (Дата: {target_date}):")
+    else:
+        print(f"🔍 ИНСПЕКЦИЯ СКУД ЗА ТЕКУЩУЮ ДАТУ [{target_date}] (ПОСЛЕДНИЙ СРЕЗ):")
+    print("=" * 90)
+
+    df = load_scud_from_db_by_snapshot(target_date, snapshot_param=snapshot_id)
+
+    if df.empty:
+        print(f"Записи СКУД не найдены.")
+        print("=" * 90 + "\n")
+        return
+
+    total = len(df)
+    present_cnt = len(df[df['Пришел'] == True]) if 'Пришел' in df.columns else 0
+    absent_cnt = total - present_cnt
+
+    print(f"Всего записей: {total} | Пришли: {present_cnt} | Не пришли: {absent_cnt}")
+    print("-" * 90)
+
+    cols_to_show = ['fio', 'department', 'position', 'time_in', 'first_activity', 'time_out', 'is_present', 'anomaly_flag', 'snapshot_id']
+    existing_cols = [c for c in cols_to_show if c in df.columns]
+    
+    print(df[existing_cols].head(30).to_string(index=False))
+    if len(df) > 30:
+        print(f"\n... и ещё {len(df) - 30} строк.")
+
+    if export_xlsx:
+        out_path = export_xlsx if export_xlsx.endswith('.xlsx') else f"{export_xlsx}.xlsx"
+        if not os.path.isabs(out_path):
+            out_path = os.path.join(OUTPUT_DIR, out_path)
+        
+        df.to_excel(out_path, index=False)
+        print("\n" + "*" * 90)
+        print(f"[✓] УСПЕШНЫЙ ЭКСПОРТ ДЕБАГ-ФАЙЛА В EXCEL: {out_path}")
+        print("*" * 90)
+
+    print("=" * 90 + "\n")
+
+
+def print_absences(date_str=None):
+    """Выводит список официально отсутствующих сотрудников из 1С:ЗУП за выбранный день."""
+    target_date = date_str if date_str else DATE_TODAY
+    print("\n" + "=" * 90)
+    print(f"📋 ОФИЦИАЛЬНЫЕ ОТСУТСТВИЯ ИЗ 1С:ЗУП ЗА ДАТУ [{target_date}]:")
+    print("=" * 90)
+    
+    with get_connection() as conn:
+        df = pd.read_sql_query(
+            "SELECT fio as 'ФИО', absence_type as 'Причина отсутствия 1С' FROM zup_absences WHERE absence_date = ? ORDER BY absence_type, fio", 
+            conn, 
+            params=(target_date,)
+        )
+        
+        if df.empty:
+            print(f"Записи об отсутствиях 1С за {target_date} в базе не найдены.")
+        else:
+            print(f"Всего зафиксировано документов 1С: {len(df)}")
+            print("-" * 90)
+            print(df.to_string(index=False))
+            
+    print("=" * 90 + "\n")
+
+
+def print_anomalies():
+    """Выводит список аномалий СКУД из БД."""
+    print("\n" + "=" * 80)
+    print("🚨 ИСТОРИЯ НАЙДЕННЫХ АНОМАЛИЙ СКУД ⟷ 1С:")
+    print("=" * 80)
+    with get_connection() as conn:
+        df = pd.read_sql_query("SELECT anomaly_date, fio, anomaly_type, details FROM anomalies_history ORDER BY id DESC LIMIT 50", conn)
+        if df.empty:
+            print("Аномалии не найдены.")
+        else:
+            print(df.to_string(index=False))
+    print("=" * 80 + "\n")
+
+
+def print_rules():
+    """Выводит правила базы знаний ИИ."""
+    rules = get_all_rules_from_db()
+    print("\n" + "=" * 80)
+    print("🧠 ПРАВИЛА БАЗЫ ЗНАНИЙ ИИ:")
+    print("=" * 80)
+    if not rules:
+        print("База знаний пуста.")
+    else:
+        for idx, r in enumerate(rules, 1):
+            print(f"  {idx}. {r}")
+    print("=" * 80 + "\n")
+
+
+def dump_all_to_excel(out_filename="db_dump_full.xlsx"):
+    """Дампит всю базу SQLite во многостраничный Excel."""
+    out_path = os.path.join(OUTPUT_DIR, out_filename)
+    print(f"\n[🔄] Создание полного дампа БД в файл: {out_path} ...")
+    with get_connection() as conn, pd.ExcelWriter(out_path, engine='openpyxl') as writer:
+        for table in ['scud_logs', 'zup_staff', 'zup_absences', 'anomalies_history', 'ai_knowledge_base']:
+            df = pd.read_sql_query(f"SELECT * FROM {table}", conn)
+            df.to_excel(writer, sheet_name=table[:31], index=False)
+    print(f"[✓] Дамп успешно сохранен: {out_path}\n")
+
+
+def print_system_prompts():
+    """Выводит все системные промпты из базы данных."""
+    print("\n" + "=" * 80)
+    print("📝 СИСТЕМНЫЕ ПРОМПТЫ (system_prompts):")
+    print("=" * 80)
+    with get_connection() as conn:
+        cursor = conn.cursor()
+        cursor.execute("SELECT id, name, is_active, updated_at, prompt_text FROM system_prompts ORDER BY id DESC")
+        rows = cursor.fetchall()
+        if not rows:
+            print("Таблица system_prompts пуста.")
+        else:
+            for r in rows:
+                print(f"ID: {r[0]} | Name: {r[1]} | Active: {r[2]} | Updated: {r[3]}")
+                print("-" * 80)
+                print(f"{r[4]}\n")
+    print("=" * 80 + "\n")
+
+
+def print_session_states():
+    """Выводит текущие активные сессии и превью (session_states)."""
+    print("\n" + "=" * 80)
+    print("🔄 АКТИВНЫЕ СЕССИИ И ПРЕВЬЮ (session_states):")
+    print("=" * 80)
+    with get_connection() as conn:
+        cursor = conn.cursor()
+        cursor.execute("SELECT session_id, state_type, updated_at, pending_data FROM session_states")
+        rows = cursor.fetchall()
+        if not rows:
+            print("Таблица session_states пуста (нет активных превью).")
+        else:
+            for r in rows:
+                print(f"Session: {r[0]} | Type: {r[1]} | Updated: {r[2]}")
+                print("-" * 80)
+                print(f"Pending Data:\n{r[3]}\n")
+    print("=" * 80 + "\n")    
+
+
+HELP_TEXT = """
+CLI-утилита инспекции и управления SQLite базой данных СКУД (scud_orion_ai.db)
+
+ДОСТУПНЫЕ КОМАНДЫ:
+  stats                                                      -- Общая статистика строк по всем таблицам БД
+  snapshots [ДД.ММ.ГГГГ]                                     -- Посмотреть реестр снапшотов (опционально за конкретную дату)
+  scud [ДД.ММ.ГГГГ] [--snapshot ID] [--export-xlsx NAME]     -- Инспекция логов СКУД по дате/снапшоту и экспорт в Excel
+  absences [ДД.ММ.ГГГГ]                                      -- Посмотреть список официально отсутствующих из 1С:ЗУП
+  anomalies                                                  -- Посмотреть историю найденных аномалий СКУД ⟷ 1С
+  rules                                                      -- Посмотреть правила Базы Знаний ИИ из SQLite
+  prompts                                                    -- Посмотреть системные промпты (system_prompts)
+  sessions                                                   -- Посмотреть активные сессии и превью (session_states)
+  dump [output.xlsx]                                         -- Полный дамп всех таблиц БД в многостраничный Excel
+  snapshot del [ID] или [--day ДД.ММ.ГГГГ]                   -- Удаление снапшота по ID или всех за выбранный день
+
+ПРИМЕРЫ ЗАПУСКА:
+  python scripts/db_cli.py stats
+  python scripts/db_cli.py snapshots 06.08.2026
+  python scripts/db_cli.py scud 06.08.2026 --export-xlsx срез_четверг
+  python scripts/db_cli.py scud --snapshot Y20260805-007
+  python scripts/db_cli.py absences 07.08.2026
+  python scripts/db_cli.py prompts
+  python scripts/db_cli.py sessions
+  python scripts/db_cli.py snapshot del Y20260805-007
+  python scripts/db_cli.py snapshot del --day 04.08.2026
+  python scripts/db_cli.py dump my_dump.xlsx
+"""
+
+
+def main():
+    if any(arg in sys.argv for arg in ['-h', '--help']):
+        print(HELP_TEXT)
         sys.exit(0)
 
-    cmd = sys.argv[1].lower()
+    parser = argparse.ArgumentParser(
+        description=HELP_TEXT,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        add_help=False
+    )
+    parser.add_argument('command', nargs='?', default=None, choices=['stats', 'snapshots', 'scud', 'absences', 'anomalies', 'rules', 'prompts', 'sessions', 'dump', 'snapshot'], help="Основная команда")
+    parser.add_argument('action', nargs='?', default=None, help="Дополнительное действие (например, 'del')")
+    parser.add_argument('param', nargs='?', default=None, help="Параметр (дата, ID снапшота или имя файла)")
+    parser.add_argument('--snapshot', type=str, default=None, help="ID конкретного снапшота для инспекции")
+    parser.add_argument('--export-xlsx', type=str, default=None, help="Экспорт среза СКУД в Excel-файл")
+    parser.add_argument('--day', type=str, default=None, help="Удалить снапшоты за конкретный день (ДД.ММ.ГГГГ)")
 
-    if cmd == "stats":
-        print_db_stats()
+    if len(sys.argv) == 1:
+        print_stats()
+        return
 
-    elif cmd == "anomalies":
-        df = query_db("SELECT * FROM anomalies_history ORDER BY id DESC")
-        if df is not None:
-            print("\n🚨 РЕЕСТР НАЙДЕННЫХ АНОМАЛИЙ СКУД ⟷ 1С:")
-            print(df.to_string(index=False) if not df.empty else "Аномалий в базе пока нет.")
+    args = parser.parse_args()
 
-    elif cmd == "rules":
-        df = query_db("SELECT id, added_by, created_at, rule_text FROM ai_knowledge_base ORDER BY id ASC")
-        if df is not None and not df.empty:
-            print("\n🧠 ПРАВИЛА БАЗЫ ЗНАНИЙ ИИ (ОБУЧЕНИЕ):")
-            print("=" * 80)
-            for _, row in df.iterrows():
-                print(f"📌 [ID: {row['id']}] | Добавил: {row['added_by']} | Дата: {row['created_at']}")
-                print(f"{row['rule_text']}")
-                print("-" * 80)
+    if args.command == 'stats':
+        print_stats()
+    elif args.command == 'snapshots':
+        date_val = args.param or args.action
+        print_snapshots_list(date_str=date_val)
+    elif args.command == 'scud':
+        inspect_scud(snapshot_id=args.snapshot, date_str=args.param, export_xlsx=args.export_xlsx)
+    elif args.command == 'absences':
+        date_val = args.param or args.action
+        print_absences(date_str=date_val)
+    elif args.command == 'anomalies':
+        print_anomalies()
+    elif args.command == 'rules':
+        print_rules()
+    elif args.command == 'prompts':
+        print_system_prompts()
+    elif args.command == 'sessions':
+        print_session_states()
+    elif args.command == 'dump':
+        filename = args.param if args.param else "db_dump_full.xlsx"
+        dump_all_to_excel(filename)
+    elif args.command == 'snapshot':
+        if args.action == 'del':
+            if args.day:
+                delete_snapshots_by_date(args.day)
+            elif args.param:
+                delete_snapshot_by_id(args.param)
+            else:
+                print("\n[❌] Ошибка: Не указан ID снапшота или параметр --day для удаления.")
+                print("Пример: python scripts/db_cli.py snapshot del Y20260805-007\n")
         else:
-            print("\n🧠 База знаний пуста.")
-
-    elif cmd == "scud" and len(sys.argv) > 2:
-        date_str = sys.argv[2]
-        df = query_db("SELECT * FROM scud_logs WHERE log_date = ?", (date_str,))
-        if df is not None:
-            print(f"\n🚪 ЛОГИ СКУД ЗА {date_str} ({len(df)} записей):")
-            print(df.head(20).to_string(index=False))
-
-    elif cmd == "staff" and len(sys.argv) > 2:
-        date_str = sys.argv[2]
-        df = query_db("SELECT * FROM zup_staff WHERE snapshot_date = ?", (date_str,))
-        if df is not None:
-            print(f"\n📋 ШТАТНОЕ РАСПИСАНИЕ 1С ЗА {date_str} ({len(df)} сотрудников):")
-            print(df.head(20).to_string(index=False))
-
-    elif cmd == "absences" and len(sys.argv) > 2:
-        date_str = sys.argv[2]
-        df = query_db("SELECT * FROM zup_absences WHERE absence_date = ?", (date_str,))
-        if df is not None:
-            print(f"\n🏥 ДОКУМЕНТЫ ОТСУТСТВИЙ 1С ЗА {date_str} ({len(df)} записей):")
-            print(df.to_string(index=False) if not df.empty else f"Отсутствий за {date_str} не зарегистрировано.")
-
-    elif cmd == "dump":
-        out_path = sys.argv[2] if len(sys.argv) > 2 else "db_dump.xlsx"
-        if not os.path.exists(DB_PATH):
-            print(f"❌ Файл базы {DB_PATH} не найден.")
-            sys.exit(1)
-
-        conn = sqlite3.connect(DB_PATH)
-        tables = ["scud_logs", "zup_staff", "zup_absences", "anomalies_history", "ai_knowledge_base"]
-        
-        with pd.ExcelWriter(out_path, engine='openpyxl') as writer:
-            for table in tables:
-                df = pd.read_sql_query(f"SELECT * FROM {table}", conn)
-                df.to_excel(writer, sheet_name=table, index=False)
-        conn.close()
-        print(f"✅ Вся база данных успешно экспортирована в Excel-файл: {out_path}")
-
+            print(f"\n[❌] Ошибка: Неизвестное действие '{args.action}' для команды snapshot.")
+            print("Используйте: python scripts/db_cli.py snapshot del [ID или --day 'ДД.ММ.ГГГГ']\n")
     else:
-        print(f"❌ Неизвестная команда: {cmd}")
+        print(f"\n[❌] Ошибка: Неизвестная команда.")
+        print(HELP_TEXT)
+
+if __name__ == "__main__":
+    main()

scripts/diagnostics/inspect_db.py

@@ -0,0 +1,47 @@
+import os
+import sqlite3
+
+# Автопоиск файла базы данных в проекте
+db_path = 'data/scud_orion_ai.db' if os.path.exists('data/scud_orion_ai.db') else 'scud_orion_ai.db'
+
+print("=" * 80)
+print(f"🔍 ДИАГНОСТИКА СУБД SQLITE: {db_path}")
+print("=" * 80)
+
+if not os.path.exists(db_path):
+    print(f"❌ Файл базы данных {db_path} не найден!")
+    exit(1)
+
+conn = sqlite3.connect(db_path)
+cursor = conn.cursor()
+
+# 1. Список всех таблиц и колонок
+cursor.execute("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")
+tables = [t[0] for t in cursor.fetchall()]
+
+print("\n📋 СТРУКТУРА ТАБЛИЦ И КОЛИЧЕСТВО ЗАПИСЕЙ:")
+print("-" * 80)
+for t_name in tables:
+    cursor.execute(f"PRAGMA table_info({t_name})")
+    cols = [c[1] for c in cursor.fetchall()]
+    
+    cursor.execute(f"SELECT COUNT(*) FROM {t_name}")
+    count = cursor.fetchone()[0]
+    
+    print(f"• [{t_name:<20}] — {count:>6} строк | Колонки: {cols}")
+
+# 2. Просмотр правил Базы Знаний
+if 'ai_knowledge_base' in tables:
+    print("\n" + "=" * 80)
+    print("🧠 АКТУАЛЬНЫЕ ПРАВИЛА БАЗЫ ЗНАНИЙ (ai_knowledge_base):")
+    print("=" * 80)
+    cursor.execute("SELECT id, rule_text, added_by FROM ai_knowledge_base ORDER BY id ASC")
+    rules = cursor.fetchall()
+    if not rules:
+        print("Таблица ai_knowledge_base пуста.")
+    else:
+        for r_id, r_text, r_author in rules:
+            print(f" {r_id}. [{r_author}] {r_text}\n")
+
+conn.close()
+print("=" * 80)

scripts/diagnostics/inspect_files.py

@@ -0,0 +1,23 @@
+import os
+
+print("=" * 80)
+print("📂 ТЕКУЩЕЕ СОСТОЯНИЕ ФАЙЛОВ ПРОЕКТА (scud_orion_ai_v2)")
+print("=" * 80)
+
+total_files = 0
+total_size = 0
+
+for root, dirs, files in os.walk('.'):
+    # Исключаем служебные каталоги
+    dirs[:] = [d for d in dirs if d not in ['.git', '__pycache__', 'venv', '.venv', 'extracted_project']]
+    
+    for f in files:
+        p = os.path.join(root, f)
+        size = os.path.getsize(p)
+        total_files += 1
+        total_size += size
+        print(f"{p:<55} ({size:>10,} bytes)".replace(',', ' '))
+
+print("-" * 80)
+print(f"ИТОГО: файлов: {total_files} | Общий объем: {total_size / (1024 * 1024):.2f} MB")
+print("=" * 80)

scripts/diagnostics/make_code_snapshot.py

@@ -0,0 +1,31 @@
+import os
+
+OUTPUT_SNAPSHOT = "project_code_snapshot.md"
+
+# Расширения файлов для включения в снимок
+ALLOWED_EXTENSIONS = {'.py', '.json', '.md', '.sh', '.ini'}
+EXCLUDE_DIRS = {'.git', '__pycache__', 'venv', '.venv', 'output', 'logs', 'extracted_project'}
+EXCLUDE_FILES = {OUTPUT_SNAPSHOT, 'scud_orion_ai_v2.tar.gz', 'context_memory.db'}
+
+print(f"🔄 Сборка полного контекстного слепка проекта в {OUTPUT_SNAPSHOT}...")
+
+with open(OUTPUT_SNAPSHOT, 'w', encoding='utf-8') as out:
+    out.write("# 📦 ПОЛНЫЙ ИСХОДНЫЙ КОД И КОНФИГУРАЦИЯ ПРОЕКТА scud_orion_ai_v2\n\n")
+    
+    for root, dirs, files in os.walk('.'):
+        dirs[:] = [d for d in dirs if d not in EXCLUDE_DIRS]
+        
+        for file in sorted(files):
+            ext = os.path.splitext(file)[1].lower()
+            if ext in ALLOWED_EXTENSIONS and file not in EXCLUDE_FILES:
+                filepath = os.path.join(root, file)
+                out.write(f"## File: `{filepath}`\n")
+                out.write("```" + (ext.replace('.', '') if ext != '.md' else '') + "\n")
+                try:
+                    with open(filepath, 'r', encoding='utf-8', errors='replace') as f:
+                        out.write(f.read())
+                except Exception as e:
+                    out.write(f"// Ошибка чтения файла: {e}\n")
+                out.write("\n```\n\n")
+
+print(f"✓ Успешно создан слепок проекта: {OUTPUT_SNAPSHOT} ({os.path.getsize(OUTPUT_SNAPSHOT):,} bytes)")

scripts/fix_snapshots.py

@@ -0,0 +1,90 @@
+import sqlite3
+import os
+from datetime import datetime
+
+DB_PATH = 'data/scud_orion_ai.db'
+
+
+def parse_to_date(date_str):
+    """Надежное преобразование даты логов и времени снапшота в объект date."""
+    if not date_str:
+        return None
+    date_str = str(date_str).split(" ")[0].strip()
+    if "." in date_str:
+        try:
+            return datetime.strptime(date_str, "%d.%m.%Y").date()
+        except ValueError:
+            return None
+    elif "-" in date_str:
+        try:
+            return datetime.strptime(date_str, "%Y-%m-%d").date()
+        except ValueError:
+            return None
+    return None
+
+
+def fix_snapshots():
+    """
+    Переиндексирует снапшоты в таблице scud_logs.
+    Нумерация веников (001, 002, 003...) сквозная внутри каждого ДНЯ СОЗДАНИЯ.
+    Префикс Y выставляется только если дата логов < даты создания.
+    """
+    if not os.path.exists(DB_PATH):
+        print(f"База данных {DB_PATH} не найдена.")
+        return
+
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+
+    # Группируем по уникальным выгрузкам
+    cursor.execute("""
+        SELECT snapshot_time, log_date 
+        FROM scud_logs 
+        WHERE snapshot_time IS NOT NULL 
+        GROUP BY snapshot_time, log_date 
+        ORDER BY snapshot_time ASC, log_date ASC
+    """)
+    rows = cursor.fetchall()
+
+    if not rows:
+        print("Снапшоты не найдены.")
+        conn.close()
+        return
+
+    print("=== ИСПРАВЛЕНИЕ СКВОЗНОЙ НУМЕРАЦИИ ВНУТРИ ДНЯ СОЗДАНИЯ ===")
+
+    # Счетчик текущего порядкового номера strictly за ДЕНЬ СОЗДАНИЯ (YYYYMMDD)
+    seq_counters = {}
+
+    for snap_time_raw, log_date_raw in rows:
+        d_snap = parse_to_date(snap_time_raw)
+        d_log = parse_to_date(log_date_raw)
+
+        if not d_snap or not d_log:
+            continue
+
+        date_prefix = d_snap.strftime("%Y%m%d")
+
+        # Если дата логов строго раньше даты создания снапшота — ставим Y
+        is_yesterday = (d_log < d_snap)
+        prefix = "Y" if is_yesterday else ""
+
+        # Приращиваем сквозной счетчик за ЭТОТ ДЕНЬ СОЗДАНИЯ
+        seq_counters[date_prefix] = seq_counters.get(date_prefix, 0) + 1
+        seq_num = seq_counters[date_prefix]
+
+        new_id = f"{prefix}{date_prefix}-{seq_num:03d}"
+
+        cursor.execute(
+            "UPDATE scud_logs SET snapshot_id = ? WHERE snapshot_time = ? AND log_date = ?",
+            (new_id, snap_time_raw, log_date_raw)
+        )
+        print(f"  • Срез создания: {snap_time_raw} | Логи за: {log_date_raw} ===> Назначен ID: [{new_id}]")
+
+    conn.commit()
+    conn.close()
+    print("\n[✓] Переиндексация внутри дней создания успешно выполнена!")
+
+
+if __name__ == "__main__":
+    fix_snapshots()

services/ai_verifier.py

@@ -0,0 +1,246 @@
+import json
+import re
+import requests
+import pandas as pd
+from config import OLLAMA_URL, OLLAMA_MODEL
+from core.database import get_all_rules_from_db
+from core.database import get_department_synonyms_dict, add_department_synonym_to_db
+
+def resolve_department_exception_ai(dept_1c, dept_scud, exception_departments):
+    """
+    Универсальный сопоставитель отделов.
+    Проверяет 1С, СКУД, локальную базу синонимов SQLite и задействует ИИ для сложных случайных аббревиатур.
+    """
+    if not exception_departments:
+        return False
+
+    d_1c = str(dept_1c).strip().lower() if dept_1c else ""
+    d_scud = str(dept_scud).strip().lower() if dept_scud else ""
+    exc_list = [d.strip().lower() for d in exception_departments]
+
+    # 1. Прямая проверка: если точное имя или подстрока уже совпали в 1С или СКУД
+    for exc in exc_list:
+        if exc and (exc in d_1c or exc in d_scud or d_1c in exc or d_scud in exc):
+            return True
+
+    # 2. Проверка по сохраненной Базе Знаний синонимов из SQLite
+    synonyms = get_department_synonyms_dict()
+    for exc in exc_list:
+        # Если в БД зафиксировано: 'овк' -> 'отдел внутреннего контроля'
+        full_from_db = synonyms.get(exc, "")
+        if full_from_db and (full_from_db in d_1c or full_from_db in d_scud):
+            return True
+
+    # 3. Умный ИИ-арбитраж (если отдел спорный и еще не сохранен в БД)
+    if d_1c or d_scud:
+        dept_to_check = d_1c if d_1c else d_scud
+        prompt = f"""
+Ты — кадровый аналитик. 
+Проверь, является ли отдел сотрудника "{dept_to_check}" тем же самым подразделением, что и один из отделов-исключений: {exception_departments}?
+
+Примеры:
+- "Отдел внутреннего контроля" — это "ОВК" (Да)
+- "Отдел технического обеспечения" — это "ОТО" (Да)
+
+Ответь СТРОГО в формате JSON:
+{{
+  "is_match": true/false,
+  "matched_exception": "Название из списка исключений",
+  "explanation": "краткое объяснение"
+}}
+"""
+        try:
+            raw_res = ask_ollama(prompt, system_prompt="Отвечай только валидным JSON.")
+            match = re.search(r'\{.*\}', raw_res, re.DOTALL)
+            if match:
+                data = json.loads(match.group(0))
+                if data.get("is_match"):
+                    matched_exc = data.get("matched_exception", "").lower()
+                    # Запоминаем открытую ИИ связь в SQLite навсегда!
+                    add_department_synonym_to_db(matched_exc, dept_to_check)
+                    return True
+        except Exception as e:
+            print(f"[⚠️] Ошибка ИИ-арбитража отделов: {e}")
+
+    return False
+
+def ask_ollama(prompt, system_prompt=None):
+    """
+    Универсальная функция отправки запросов к локальной модели Ollama (Qwen 2.5).
+    """
+    payload = {
+        "model": OLLAMA_MODEL,
+        "prompt": f"{system_prompt}\n\n{prompt}" if system_prompt else prompt,
+        "stream": False
+    }
+
+    try:
+        response = requests.post(OLLAMA_URL, json=payload, timeout=120)
+        if response.status_code == 200:
+            data = response.json()
+            if "response" in data:
+                return data["response"].strip()
+            elif "message" in data and "content" in data["message"]:
+                return data["message"]["content"].strip()
+            else:
+                return f"⚠️ Неизвестная структура ответа Ollama: {data}"
+        else:
+            return f"⚠️ Ошибка Ollama (Код {response.status_code}): {response.text}"
+    except requests.exceptions.ConnectionError:
+        return "⚠️ Не удалось подключиться к Ollama. Проверьте, запущен ли сервис (ollama run qwen2.5:14b)."
+    except Exception as e:
+        return f"⚠️ Ошибка при обращении к Ollama: {e}"
+
+
+def get_system_rules_context():
+    """
+    Загружает динамические системные правила компании напрямую из Базы Данных SQLite.
+    """
+    rules = get_all_rules_from_db()
+    if not rules:
+        return ""
+    rules_text = "\n".join([f"- {r}" for r in rules])
+    return f"\nОБЯЗАТЕЛЬНЫЕ ГЛОБАЛЬНЫЕ ПРАВИЛА И ПРИОРИТЕТЫ КОМПАНИИ (ИЗ SQLITE БД):\n{rules_text}\n"
+
+
+def analyze_scud_mass_failure_ai(df_scud):
+    """
+    Оценивает процент аномалий 'ANOMALY_NO_IN_HAS_ACTIVITY' в выгрузке.
+    Если процент аномалий превышает 5% от смены или 10 человек, вызывает ИИ для генерации критического алерта.
+    """
+    if df_scud is None or df_scud.empty:
+        return None
+
+    total_records = len(df_scud)
+    anomaly_rows = df_scud[df_scud.get('anomaly_flag', 'NONE') == 'ANOMALY_NO_IN_HAS_ACTIVITY']
+    anomaly_count = len(anomaly_rows)
+
+    if total_records == 0:
+        return None
+
+    anomaly_percent = round((anomaly_count / total_records) * 100, 1)
+
+    if anomaly_percent > 5.0 or anomaly_count >= 10:
+        rules_context = get_system_rules_context()
+        prompt = f"""
+{rules_context}
+ВНИМАНИЕ! Проведён анализ смены СКУД:
+- Всего записей за смену: {total_records}
+- Выявлено сотрудников без утреннего входа, но с зафиксированной дневной активностью: {anomaly_count} ({anomaly_percent}% от смены)
+
+Сформируй понятное предупреждение для Администратора СКУД и Руководителя. 
+Объясни, что это критический массовый сбой турникетов/контроллеров входа на КПП, и порекомендуй действия.
+"""
+        alert_text = ask_ollama(prompt, system_prompt="Ты — ИИ-аналитик контроллинга СКУД. Отвечай кратко и строго по делу.")
+        return {
+            "is_mass_failure": True,
+            "anomaly_count": anomaly_count,
+            "anomaly_percent": anomaly_percent,
+            "alert_text": alert_text
+        }
+
+    return {
+        "is_mass_failure": False,
+        "anomaly_count": anomaly_count,
+        "anomaly_percent": anomaly_percent,
+        "alert_text": "Массовых сбоев оборудования не зафиксировано."
+    }
+
+
+def ai_verify_scud_against_staff(unrecognized_scud_fios, staff_fios):
+    if not unrecognized_scud_fios or not staff_fios:
+        return {}
+
+    # 🛡 Исключаем точные совпадения (чтобы ИИ не совершал ложных замен)
+    staff_fios_set = set(staff_fios)
+    real_unrecognized = [f for f in unrecognized_scud_fios if f not in staff_fios_set]
+
+    if not real_unrecognized:
+        return {}
+
+    rules_context = get_system_rules_context()
+
+    prompt = f"""
+Ты — кадровый аудитор безопасности СКУД.
+{rules_context}
+В СКУД записаны неопознанные ФИО: {json.dumps(unrecognized_scud_fios, ensure_ascii=False)}
+В официальном Штатном расписании 1С записаны ЭТАЛОНЫ: {json.dumps(staff_fios, ensure_ascii=False)}
+
+СТРОГИЕ ПРАВИЛА:
+1. Запись из Штат 1С — это 100% ПРАВИЛЬНЫЙ эталон.
+2. В СКУД допущена опечатка.
+3. Любое присутствие сотрудника по СКУД при наличии в 1С документа отсутствия (кроме командировок) является гарантированной аномалией.
+4. В поле "warning" опиши обнаруженную опечатку.
+5. Запрещено выдумывать опечатки и объединять разных людей/однофамильцев!
+
+ОТВЕЧАЙ ТОЛЬКО ИСКЛЮЧИТЕЛЬНО В ФОРМАТЕ JSON!
+
+Формат ответа:
+{{
+  "verified_matches": [
+    {{
+      "scud_fio": "ФИО из СКУД",
+      "staff_fio": "эталон ФИО из Штат 1С",
+      "warning": "Описание опечатки в СКУД или 'Точное совпадение (без опечаток)'"
+    }}
+  ]
+}}
+"""
+    raw_response = ask_ollama(
+        prompt, 
+        system_prompt="Ты — JSON API. Выдавай ТОЛЬКО валидный JSON без markdown-разметки."
+    )
+    
+    mapping = {}
+    try:
+        match = re.search(r'\{.*\}', raw_response, re.DOTALL)
+        if match:
+            json_str = match.group(0)
+            json_str = re.sub(r'\}\s*[^}\]]*$', '}', json_str)
+            data = json.loads(json_str)
+            for item in data.get("verified_matches", []):
+                scud_f = item.get("scud_fio")
+                staff_f = item.get("staff_fio")
+                warn = item.get("warning", "Точное совпадение (без опечаток)")
+                if scud_f and staff_f:
+                    mapping[scud_f] = {"staff_fio": staff_f, "warning": warn}
+    except Exception as e:
+        print(f"[!] Ошибка разбора JSON от ИИ при сверке опечаток: {e}")
+    
+    return mapping
+
+
+def ai_verify_department_exceptions(unexplained_df, exception_departments):
+    """
+    Локальный ИИ проверяет, не являются ли неотмеченные отделы синонимами отделов-исключений.
+    """
+    if unexplained_df.empty or not exception_departments:
+        return []
+
+    dept_list = unexplained_df['Подразделение'].dropna().unique().tolist()
+    rules_context = get_system_rules_context()
+
+    prompt = f"""
+{rules_context}
+Ты — кадровый аудитор.
+Список отделов-исключений компании: {json.dumps(exception_departments, ensure_ascii=False)}
+Список отделов сотрудников, попавших в неизвестные: {json.dumps(dept_list, ensure_ascii=False)}
+
+Определи, какие из отделов сотрудников являются ПОЛНЫМИ НАЗВАНИЯМИ или СИНУНИМАМИ отделов-исключений (например: 'Отдел внутреннего контроля' — это 'ОВК').
+
+Выдай ответ строго в формате JSON:
+{{
+  "matched_departments": ["Название отдела 1", "Название отдела 2"]
+}}
+"""
+    raw_response = ask_ollama(prompt, system_prompt="Выдавай только валидный JSON.")
+    
+    try:
+        match = re.search(r'\{.*\}', raw_response, re.DOTALL)
+        if match:
+            data = json.loads(match.group(0))
+            return data.get("matched_departments", [])
+    except Exception as e:
+        print(f"[⚠️] Ошибка ИИ-арбитража отделов: {e}")
+        
+    return []

services/data_loader.py

@@ -0,0 +1,243 @@
+import os
+import pandas as pd
+import warnings
+from config import (
+    normalize_fio, clean_scud_fio_light, load_exceptions, 
+    DATE_TODAY, DATE_YESTERDAY, find_dated_file, ZUP_1C_DIR, SCUD_DIR
+)
+# Импортируем прямую SQL-выгрузку отсутствий из 1С и функции работы с SQLite
+from services.zup_extractor import fetch_zup_absences_from_sql
+from core.database import (
+    load_scud_from_db_by_snapshot,
+    load_staff_from_db,
+    load_absences_from_db
+)
+
+warnings.filterwarnings('ignore', category=UserWarning, module='pandas')
+
+
+def is_excluded(fio, dept, pos, exceptions):
+    """Проверяет, входит ли сотрудник или должность в список исключений."""
+    fio_clean = normalize_fio(fio)
+    dept_str = str(dept).strip().upper() if pd.notna(dept) else ""
+    pos_str = str(pos).strip().lower() if pd.notna(pos) else ""
+
+    if fio_clean in exceptions["fio"] or dept_str in exceptions["departments"] or pos_str in exceptions["positions"]:
+        return True
+    if any(keyword in pos_str for keyword in exceptions["position_keywords"]):
+        return True
+    return False
+
+
+def load_staff_data(date_str):
+    """
+    Загружает файл Штатного расписания 1С за конкретную дату из папки 1c.
+    """
+    filepath = find_dated_file("Штат", date_str)
+    if not filepath:
+        fallback_path = os.path.join(ZUP_1C_DIR, "штат.xlsx")
+        if os.path.exists(fallback_path):
+            filepath = fallback_path
+        else:
+            return None
+
+    try:
+        df_raw = pd.read_excel(filepath, skiprows=8)
+        
+        # Индексы столбцов в файле 1С: 1 — ФИО, 5 — Подразделение, 12 — Должность
+        df_staff = df_raw.iloc[:, [1, 5, 12]].copy()
+        df_staff.columns = ['ФИО', 'Подразделение', 'Должность']
+        
+        df_staff = df_staff.dropna(subset=['ФИО']).reset_index(drop=True)
+        df_staff = df_staff[~df_staff['ФИО'].astype(str).str.contains('Всего|Организация|Сотрудник|ФИО', case=False, na=False)]
+        df_staff['fio_clean'] = df_staff['ФИО'].apply(normalize_fio)
+        return df_staff
+    except Exception as e:
+        print(f"[❌] Ошибка загрузки штата из {filepath}: {e}")
+        return None
+
+
+def load_absent_data(date_str):
+    """
+    Загружает документально подтвержденные отсутствия сотрудников
+    НАПРЯМУЮ из базы MS SQL 1С:ЗУП за указанную дату,
+    а также автоматически обогащает их удаленщиками из static_reason_workers.csv.
+    """
+    df_absent = None
+    try:
+        df_absent = fetch_zup_absences_from_sql(date_str)
+        
+        if df_absent is not None and not df_absent.empty:
+            df_absent = df_absent.dropna(subset=['ФИО', 'Вид_отсутствия'])
+            df_absent = df_absent[~df_absent['ФИО'].astype(str).str.contains('АО "ЛЕНМОРНИИПРОЕКТ"|Сотрудник', case=False, na=False)]
+            df_absent['fio_clean'] = df_absent['ФИО'].apply(normalize_fio)
+            df_absent = df_absent[['fio_clean', 'Вид_отсутствия']].dropna(subset=['fio_clean'])
+        else:
+            df_absent = pd.DataFrame(columns=['fio_clean', 'Вид_отсутствия'])
+    except Exception as e:
+        print(f"[⚠️] Ошибка SQL-выгрузки отсутствий за {date_str}: {e}")
+        df_absent = pd.DataFrame(columns=['fio_clean', 'Вид_отсутствия'])
+
+    # ⭐️ ОБОГАЩЕНИЕ УДАЛЕНЩИКАМИ ИЗ static_reason_workers.csv
+    try:
+        from config import DATA_DIR
+        static_path = os.path.join(DATA_DIR, "static_reason_workers.csv")
+        if os.path.exists(static_path):
+            df_static = pd.read_csv(static_path, encoding='utf-8')
+            if 'fio' in df_static.columns and 'reason' in df_static.columns:
+                df_static['fio_clean'] = df_static['fio'].apply(normalize_fio)
+                existing_fios = set(df_absent['fio_clean'].dropna().tolist()) if not df_absent.empty else set()
+                
+                new_rows = []
+                for _, s_row in df_static.iterrows():
+                    if s_row['fio_clean'] not in existing_fios:
+                        new_rows.append({
+                            'fio_clean': s_row['fio_clean'],
+                            'Вид_отсутствия': s_row['reason']
+                        })
+                if new_rows:
+                    df_absent = pd.concat([df_absent, pd.DataFrame(new_rows)], ignore_index=True)
+    except Exception as e:
+        print(f"[⚠️] Ошибка обогащения удаленщиками в load_absent_data: {e}")
+
+    return df_absent if not df_absent.empty else None
+
+
+def load_1c_data_smart(date_str, use_db=False):
+    """
+    Универсальный загрузчик данных 1С (Штат и Отсутствия).
+    Если use_db=True, приоритетно извлекает сохраненные данные из SQLite БД
+    за целевую дату указанного снапшота.
+    """
+    df_staff = None
+    df_absent = None
+
+    if use_db:
+        df_staff = load_staff_from_db(date_str)
+        df_absent = load_absences_from_db(date_str)
+
+    # Если в базе нет записей за эту дату или use_db=False — загружаем из файлов/SQL
+    if df_staff is None:
+        df_staff = load_staff_data(date_str)
+    if df_absent is None:
+        df_absent = load_absent_data(date_str)
+
+    return df_staff, df_absent
+
+
+def process_scud_anomalies(df_scud, exceptions=None):
+    """
+    Вычисляет 'Первую активность' и маркирует аномалии СКУД.
+    """
+    if exceptions is None:
+        exceptions = load_exceptions()
+
+    start_col = 'Начало_дня' if 'Начало_дня' in df_scud.columns else ('Начало дня' if 'Начало дня' in df_scud.columns else None)
+    end_col = 'Конец_дня' if 'Конец_дня' in df_scud.columns else ('Конец дня' if 'Конец дня' in df_scud.columns else None)
+    status_col = 'Статус' if 'Статус' in df_scud.columns else None
+
+    first_activities = []
+    anomaly_flags = []
+    is_present_flags = []
+
+    for _, row in df_scud.iterrows():
+        fio = str(row.get('Сотрудник', row.get('fio_raw', ''))).strip()
+        fio_clean = normalize_fio(fio)
+        dept = str(row.get('Подразделение', '')).strip()
+        pos = str(row.get('Должность', '')).strip()
+
+        val_start = str(row.get(start_col, '')).strip() if start_col else ''
+        val_end = str(row.get(end_col, '')).strip() if end_col else ''
+        val_status = str(row.get(status_col, '')).strip().lower() if status_col else ''
+
+        raw_first_event = row.get('raw_first_event', None)
+        if pd.isna(raw_first_event) or str(raw_first_event).strip() in ['', 'None', 'nan', '00:00:00']:
+            raw_first_event = None
+
+        has_no_in = (val_start in ['нет входа', 'none', 'nan', '', '00:00:00', '00:00'])
+        has_no_out = (val_end in ['нет выхода', 'none', 'nan', '', '00:00:00', '00:00'])
+
+        first_act = '—'
+        anom_flag = 'NONE'
+        is_present = not ('отсутствовал' in val_status or has_no_in)
+
+        if has_no_in:
+            if raw_first_event is not None or not has_no_out:
+                first_act = str(raw_first_event) if raw_first_event else val_end
+                anom_flag = 'ANOMALY_NO_IN_HAS_ACTIVITY'
+
+                if not is_excluded(fio, dept, pos, exceptions):
+                    is_present = False
+            else:
+                first_act = '—'
+                is_present = False
+
+        first_activities.append(first_act)
+        anomaly_flags.append(anom_flag)
+        is_present_flags.append(is_present)
+
+    df_scud['Первая_активность'] = first_activities
+    df_scud['anomaly_flag'] = anomaly_flags
+    df_scud['Пришел'] = is_present_flags
+
+    return df_scud
+
+
+def load_scud_data(target_date_type="today", snapshot_param=None):
+    """
+    Загружает логи СКУД за 'today' или 'yesterday' НАПРЯМУЮ из локальной базы SQLite.
+    """
+    target_date = DATE_TODAY if target_date_type == "today" else DATE_YESTERDAY
+    
+    df_scud = load_scud_from_db_by_snapshot(target_date, snapshot_param=snapshot_param)
+    
+    if df_scud is None or df_scud.empty:
+        df_scud = load_scud_from_db_by_snapshot(DATE_TODAY, snapshot_param=snapshot_param)
+        if df_scud is None or df_scud.empty:
+            print(f"[ℹ️] В базе SQLite / файлах отсутствует СКУД за {target_date}. Возвращаем пустой набор.")
+            return pd.DataFrame()
+
+    exceptions = load_exceptions()
+
+    if 'fio_clean' not in df_scud.columns:
+        fio_raw_col = 'fio' if 'fio' in df_scud.columns else ('Сотрудник' if 'Сотрудник' in df_scud.columns else df_scud.columns[0])
+        df_scud['fio_raw'] = df_scud[fio_raw_col].astype(str)
+        df_scud['fio_clean'] = df_scud['fio_raw'].apply(clean_scud_fio_light)
+
+    if 'Начало_дня' not in df_scud.columns and 'time_in' in df_scud.columns:
+        df_scud['Начало_дня'] = df_scud['time_in']
+    if 'Конец_дня' not in df_scud.columns and 'time_out' in df_scud.columns:
+        df_scud['Конец_дня'] = df_scud['time_out']
+    if 'Первая_активность' not in df_scud.columns and 'first_activity' in df_scud.columns:
+        df_scud['Первая_активность'] = df_scud['first_activity']
+    if 'Пришел' not in df_scud.columns and 'is_present' in df_scud.columns:
+        df_scud['Пришел'] = df_scud['is_present'].astype(bool)
+
+    df_scud['is_excluded'] = df_scud.apply(
+        lambda r: is_excluded(r.get('fio', r.get('Сотрудник', '')), r.get('department', r.get('Подразделение', '')), r.get('position', r.get('Должность', '')), exceptions),
+        axis=1
+    )
+    return df_scud
+
+
+def load_all_data():
+    """
+    Загружает слитные датасеты за Сегодня и за Вчера напрямую из базы SQLite и 1С.
+    """
+    df_scud_today = load_scud_data(target_date_type="today")
+    try:
+        df_scud_yesterday = load_scud_data(target_date_type="yesterday")
+    except FileNotFoundError:
+        df_scud_yesterday = df_scud_today.copy()
+
+    df_staff_today, df_absent_today = load_1c_data_smart(DATE_TODAY)
+    df_staff_yesterday, df_absent_yesterday = load_1c_data_smart(DATE_YESTERDAY)
+
+    return (
+        df_scud_today,
+        df_scud_yesterday,
+        df_staff_today,
+        df_absent_today,
+        df_staff_yesterday,
+        df_absent_yesterday
+    )

services/excel_exporter.py

@@ -16,6 +16,7 @@ MONTHS_RU = {
     9: "сентября", 10: "октября", 11: "ноября", 12: "декабря"
 }
 
+
 def format_date_ru(date_str):
     """Преобразует дату формата '27.07.2026' в '27 июля 2026'"""
     try:
@@ -24,6 +25,7 @@ def format_date_ru(date_str):
     except Exception:
         return date_str
 
+
 # Границы ячеек
 THIN_SIDE = Side(border_style="thin", color="D3D3D3")
 THIN_BORDER = Border(left=THIN_SIDE, right=THIN_SIDE, top=THIN_SIDE, bottom=THIN_SIDE)
@@ -34,13 +36,15 @@ FILL_TOTAL_LIST = PatternFill(start_color="F2F2F2", end_color="F2F2F2", fill_typ
 FILL_UNEXPLAINED = PatternFill(start_color="FCE4D6", end_color="FCE4D6", fill_type="solid")
 FILL_PRESENT = PatternFill(start_color="E2EFDA", end_color="E2EFDA", fill_type="solid")
 FILL_ANOMALY = PatternFill(start_color="FCE4D6", end_color="FCE4D6", fill_type="solid")
+FILL_NO_PASS = PatternFill(start_color="E1F5FE", end_color="E1F5FE", fill_type="solid")  # Мягкий пастельно-голубой для "Нет пропуска"
 
 CATEGORY_PASTEL_COLORS = ["FFF2CC", "E1D5E7", "E1F5FE", "FFF0F5", "E8F8F5", "FCF3CF"]
 
 # Палитра для Детального отчета
 YELLOW_FILL = PatternFill(start_color="FFF2CC", end_color="FFF2CC", fill_type="solid")     # Обычные отсутствия
-LIGHT_RED_FILL = PatternFill(start_color="FCE4D6", end_color="FCE4D6", fill_type="solid")  # Неизвестные случаи
+LIGHT_RED_FILL = PatternFill(start_color="FCE4D6", end_color="FCE4D6", fill_type="solid")  # Потенциальные прогулы
 GREEN_FILL = PatternFill(start_color="E2EFDA", end_color="E2EFDA", fill_type="solid")     # Аномалии (пришел в отпуске)
+LIGHT_BLUE_FILL = PatternFill(start_color="E1F5FE", end_color="E1F5FE", fill_type="solid") # Бледно-голубой для "Нет пропуска"
 
 
 def calculate_deviation(time_in_building_str, reason="", norm_hours=8, lunch_minutes=30):
@@ -128,8 +132,17 @@ def generate_summary_excel(merged_df, date_str="27.07.2026", filename=None):
 
     current_row = 4
 
-    # 3. НЕИЗВЕСТНО (По умолчанию РАСКРЫТО, чистые ФИО без цифр)
-    unexplained = merged_df[(merged_df['Пришел'] == False) & (merged_df['Вид_отсутствия'].isna())]
+    # Подготовка флагов для точной фильтрации
+    is_no_pass = merged_df['no_scud_pass'] == True if 'no_scud_pass' in merged_df.columns else False
+    is_exc = merged_df.get('is_excluded', False) == True
+
+    # 3. НЕИЗВЕСТНО (Исключаем категорию "Нет пропуска" и "Исключения ОВК/Охрана")
+    unexplained = merged_df[
+        (merged_df['Пришел'] == False) & 
+        (merged_df['Вид_отсутствия'].isna() | (merged_df['Вид_отсутствия'].astype(str).str.strip() == '')) & 
+        (~is_no_pass) & 
+        (~is_exc)
+    ]
     ws.cell(row=current_row, column=1, value="неизвестно")
     ws.cell(row=current_row, column=2, value=len(unexplained))
     format_row_cells(ws, current_row, FILL_UNEXPLAINED, is_bold=True, bold_font=bold_font)
@@ -142,7 +155,23 @@ def generate_summary_excel(merged_df, date_str="27.07.2026", filename=None):
         ws.row_dimensions[current_row].hidden = False
         current_row += 1
 
-    # 4. КАТЕГОРИИ ОТСУТСТВИЙ (Свернуты hidden=True, ИСКЛЮЧЕНИЯ ИСКЛЮЧЕНЫ)
+    # 4. РАЗДЕЛ: НЕТ ПРОПУСКА (Строго один независимый блок)
+    no_pass_df = merged_df[is_no_pass] if 'no_scud_pass' in merged_df.columns else pd.DataFrame()
+
+    ws.cell(row=current_row, column=1, value="Нет пропуска")
+    ws.cell(row=current_row, column=2, value=len(no_pass_df))
+    format_row_cells(ws, current_row, FILL_NO_PASS, is_bold=True, bold_font=bold_font)
+    current_row += 1
+
+    if not no_pass_df.empty:
+        for fio in sorted(no_pass_df['Сотрудник'].dropna().unique()):
+            ws.cell(row=current_row, column=1, value=fio)
+            format_row_cells(ws, current_row, FILL_NO_PASS, is_bold=False)
+            ws.row_dimensions[current_row].outlineLevel = 1
+            ws.row_dimensions[current_row].hidden = False
+            current_row += 1
+
+    # 5. КАТЕГОРИИ ОТСУТСТВИЙ (Свернуты hidden=True)
     absent_only = merged_df[
         (merged_df['Пришел'] == False) & 
         (merged_df['Вид_отсутствия'].notna()) & 
@@ -166,7 +195,7 @@ def generate_summary_excel(merged_df, date_str="27.07.2026", filename=None):
             ws.row_dimensions[current_row].hidden = True
             current_row += 1
 
-    # 5. ИТОГО НА РАБОТЕ (Свернут hidden=True)
+    # 6. ИТОГО НА РАБОТЕ (Свернут hidden=True)
     is_working_mask = (merged_df['Пришел'] == True) | (
         merged_df['Вид_отсутствия'].astype(str).str.lower().str.contains('командировк|удален|дистанцион|разъездн', regex=True, na=False)
     )
@@ -185,10 +214,15 @@ def generate_summary_excel(merged_df, date_str="27.07.2026", filename=None):
             ws.row_dimensions[current_row].hidden = True
             current_row += 1
 
-    # 6. АНОМАЛИИ (Свернут hidden=True)
-    anomalies = merged_df[(merged_df['Пришел'] == True) & (merged_df['Вид_отсутствия'].notna())]
+    # 7. АНОМАЛИИ СКУД И 1С (ОВК и Подрядчики из исключений СУДА НЕ ПОПАДАЮТ)
+    anomalies = merged_df[
+        (~is_exc) & (
+            ((merged_df['Пришел'] == True) & (merged_df['Вид_отсутствия'].notna()) & (~merged_df['Вид_отсутствия'].astype(str).str.startswith('Исключение'))) |
+            (merged_df.get('anomaly_flag', 'NONE') == 'ANOMALY_NO_IN_HAS_ACTIVITY')
+        )
+    ]
     
-    ws.cell(row=current_row, column=1, value="Аномалии")
+    ws.cell(row=current_row, column=1, value="Аномалии СКУД и 1С")
     ws.cell(row=current_row, column=2, value=len(anomalies))
     format_row_cells(ws, current_row, FILL_ANOMALY, is_bold=True, bold_font=bold_font)
     current_row += 1
@@ -198,10 +232,16 @@ def generate_summary_excel(merged_df, date_str="27.07.2026", filename=None):
     if not anomalies.empty:
         for _, row in anomalies.iterrows():
             fio = row.get('Сотрудник', '')
-            reason = row.get('Вид_отсутствия', 'Неизвестная причина')
-            reason_text = f"В 1С: {reason}"
+            reason = row.get('Вид_отсутствия', '')
+            anom_flag = row.get('anomaly_flag', 'NONE')
+
+            if anom_flag == 'ANOMALY_NO_IN_HAS_ACTIVITY':
+                first_act = row.get('Первая_активность', '—')
+                reason_text = f"🚨 АНОМАЛИЯ СКУД: Нет входа (первая активность: {first_act})"
+            else:
+                reason_text = f"В 1С: {reason}"
             
-            cell_a = ws.cell(row=current_row, column=1, value=f"{fio} (На работе)")
+            cell_a = ws.cell(row=current_row, column=1, value=f"{fio}")
             cell_b = ws.cell(row=current_row, column=2, value=reason_text)
             
             cell_a.fill = FILL_ANOMALY
@@ -223,7 +263,7 @@ def generate_summary_excel(merged_df, date_str="27.07.2026", filename=None):
             current_row += 1
 
     ws.column_dimensions['A'].width = 45.0
-    ws.column_dimensions['B'].width = 32.0
+    ws.column_dimensions['B'].width = 38.0
 
     try:
         wb.save(output_path)
@@ -251,7 +291,7 @@ def generate_detailed_excel(merged_df, date_str="26.07.2026", filename=None):
     ws["D2"].font = Font(name="Arial", size=10, bold=True)
 
     headers = [
-        "№", "ФИО", "Подразделение", "время входа", "время выхода",
+        "№", "ФИО", "Подразделение", "время входа", "первая активность", "время выхода",
         "находился в здании", "причина отсутствия", "норма", "отклонение от нормы"
     ]
     ws.append([])
@@ -269,22 +309,27 @@ def generate_detailed_excel(merged_df, date_str="26.07.2026", filename=None):
     end_col = 'Конец дня' if 'Конец дня' in merged_df.columns else 'Конец_дня'
     hours_col = 'Часы' if 'Часы' in merged_df.columns else 'Находился_в_здании'
 
-    chars_per_line_g = 24
+    chars_per_line_h = 24
 
     for idx, row in merged_df.reset_index(drop=True).iterrows():
         is_present = row.get('Пришел', False)
         absence_reason = row.get('Вид_отсутствия', '')
         has_reason = pd.notna(absence_reason) and str(absence_reason).strip() != ''
+        anom_flag = row.get('anomaly_flag', 'NONE')
 
         in_building_str = str(row.get(hours_col, '00:00'))
-        
+        first_act_val = str(row.get('Первая_активность', '—')).strip()
+        has_first_act = first_act_val not in ['—', '', 'None', 'nan']
+
+        dept_scud_val = row.get('department_scud', row.get('department', row.get('Подразделение', '')))
         deviation_val = calculate_deviation(in_building_str, reason=absence_reason if has_reason else "", norm_hours=8, lunch_minutes=30)
 
         ws.append([
             idx + 1,
             row.get('Сотрудник', ''),
-            row.get('Подразделение', ''),
+            dept_scud_val,
             row.get(start_col, 'Нет входа'),
+            first_act_val,
             row.get(end_col, 'Нет выхода'),
             in_building_str,
             absence_reason if has_reason else '',
@@ -294,16 +339,20 @@ def generate_detailed_excel(merged_df, date_str="26.07.2026", filename=None):
         
         row_num = 5 + idx
         
+        # ЗАЛИВКА СТРОК:
         if is_present and has_reason:
             row_fill = GREEN_FILL
-        elif not is_present:
-            row_fill = YELLOW_FILL if has_reason else LIGHT_RED_FILL
+        elif not is_present and has_reason:
+            row_fill = YELLOW_FILL
+        elif not is_present and not has_reason and not has_first_act:
+            # Розово-красный подсвечивает исключительно неизвестные случаи (потенциальные прогулы)
+            row_fill = LIGHT_RED_FILL
         else:
             row_fill = None
 
-        val_g_str = str(absence_reason) if has_reason else ""
-        if len(val_g_str) > chars_per_line_g:
-            needed_lines = math.ceil(len(val_g_str) / chars_per_line_g)
+        val_h_str = str(absence_reason) if has_reason else ""
+        if len(val_h_str) > chars_per_line_h:
+            needed_lines = math.ceil(len(val_h_str) / chars_per_line_h)
             ws.row_dimensions[row_num].height = max(needed_lines * 18, 22)
         else:
             ws.row_dimensions[row_num].height = 20
@@ -314,25 +363,28 @@ def generate_detailed_excel(merged_df, date_str="26.07.2026", filename=None):
             if row_fill:
                 cell.fill = row_fill
             
-            if col_idx == 7:
+            if col_idx == 8:
                 cell.alignment = Alignment(horizontal="left", vertical="center", wrap_text=True)
-            elif col_idx in [1, 4, 5, 6, 8, 9]:
+            elif col_idx in [1, 4, 5, 6, 7, 9, 10]:
                 cell.alignment = Alignment(horizontal="center", vertical="center")
             else:
                 cell.alignment = Alignment(horizontal="left", vertical="center")
 
+    # Динамический компактный автоподгон ширины колонок
     for col in ws.columns:
         col_letter = get_column_letter(col[0].column)
-        if col_letter == 'G':
-            ws.column_dimensions['G'].width = 25.0
-        else:
-            max_len = 0
-            for cell in col:
-                if cell.value is not None:
-                    line_max = max(len(l) for l in str(cell.value).split("\n"))
-                    if line_max > max_len:
-                        max_len = line_max
-            ws.column_dimensions[col_letter].width = max(max_len + 4, 12)
+        max_len = 0
+        for cell in col:
+            if cell.value is not None:
+                cell_lines = str(cell.value).split("\n")
+                line_max = max(len(line) for line in cell_lines)
+                if line_max > max_len:
+                    max_len = line_max
+
+        optimal_width = max(max_len + 2, 8)
+        if optimal_width > 35:
+            optimal_width = 35
+        ws.column_dimensions[col_letter].width = optimal_width
 
     try:
         wb.save(output_path)

services/feedback_loop.py

@@ -1,12 +1,12 @@
 import os
 import json
-from modules.database import add_rule_to_db
+from core.database import add_rule_to_db
 
 try:
-    from modules.knowledge_base import save_rule
+    from services.knowledge_base import save_rule
 except ImportError:
     try:
-        from modules.knowledge_base import add_rule as save_rule
+        from services.knowledge_base import add_rule as save_rule
     except ImportError:
         save_rule = None
 
@@ -40,17 +40,14 @@ def review_ai_decisions(report_text, suspicious_cases):
         elif user_input_clean in ['н', 'нет', 'no', 'n', '-']:
             print("  [ℹ️] Решение отклонено оператором.")
         elif user_input:
-            # Если оператор ввел действительно новое текстовое правило
-            new_rule = f"Правило по {fio_target}: {user_input}"
-            
-            add_rule_to_db(new_rule, added_by="Human_Admin")
-            if save_rule:
-                try:
-                    save_rule(new_rule)
-                except Exception:
-                    pass
+            # Если оператор обучает систему синониму отделов
+            if "отдел" in user_input_clean or "овк" in user_input_clean:
+                from core.database import add_department_synonym_to_db
+                add_department_synonym_to_db(user_input.strip(), "отдел внутреннего контроля")
 
-            print(f"  [✓] Новое правило записано в Базу Знаний: {new_rule}")
+            new_rule = f"Правило: {user_input}"
+            add_rule_to_db(new_rule, added_by="Human_Admin")
+            print(f"  [✓] Новое правило записано в Базу Знаний SQLite: {new_rule}")
         else:
             print("  [ℹ️] Запись пропущена.")
 

services/knowledge_base.py

@@ -0,0 +1,23 @@
+import os
+from core.database import get_all_rules_from_db, add_rule_to_db
+
+
+def load_knowledge_base():
+    """
+    Загружает актуальные правила Базы Знаний компании напрямую из базы данных SQLite.
+    """
+    rules = get_all_rules_from_db()
+    return {
+        "rules": rules if rules else [],
+        "fio_corrections": {}
+    }
+
+
+def add_rule_to_kb(new_rule):
+    """
+    Добавляет новое принятое человеком правило в SQLite таблицу ai_knowledge_base.
+    """
+    if not new_rule or not new_rule.strip():
+        return
+    add_rule_to_db(new_rule.strip(), added_by="Human")
+    print(f"[✓] База знаний SQLite успешно обновлена! Новое правило: {new_rule.strip()}")

services/scud_export.py

@@ -1,7 +1,6 @@
 """
 Модуль автоматического экспорта данных СКУД (Orion) из MS SQL Server в SQLite и Excel.
-Исправлена логика определения направления проходов (Mode = 2 -> OUT).
-Адаптирован для Linux (Ubuntu 24.04).
+Добавлена фиксация Первой Активности (без учета направления) и среза по времени.
 """
 
 import argparse
@@ -16,7 +15,7 @@ import pyodbc
 from openpyxl.utils import get_column_letter
 
 from config import SCUD_DIR, clean_scud_fio_light, load_exceptions
-from modules.database import save_scud_to_db
+from core.database import save_scud_to_db, has_scud_logs_for_date, has_yesterday_final_snapshot
 
 warnings.filterwarnings("ignore", message="pandas only supports SQLAlchemy connectable")
 
@@ -82,11 +81,13 @@ WITH DailyLogs AS (
     WHERE log.TimeVal BETWEEN @StartDate AND @EndDate
       AND log.HozOrgan IS NOT NULL
       AND log.HozOrgan > 0
-      AND (log.Event IN (28, 29, 26, 27, 32, 33) OR log.Mode IN (1, 2))
+      AND log.Event IN (26, 27, 28, 29, 32, 33, 54, 55, 64, 65)
 ),
 Passages AS (
     SELECT
         EmployeeID,
+        MIN(TimeVal) AS FirstRawEvent,
+        MAX(TimeVal) AS LastRawEvent,
         MIN(CASE WHEN Direction = 'IN' THEN TimeVal END) AS FirstIn,
         MAX(CASE WHEN Direction = 'OUT' THEN TimeVal END) AS LastOut,
         MAX(CASE WHEN RowNumDesc = 1 THEN Direction END) AS LastEventType
@@ -107,26 +108,33 @@ SELECT
     ISNULL(CAST(p.TabNumber AS NVARCHAR(50)), N'—') AS [Таб_№],
     CONVERT(VARCHAR(10), @TargetDate, 104) AS [Дата],
     ISNULL(CAST(CONVERT(VARCHAR(8), pass.FirstIn, 108) AS NVARCHAR(20)), N'Нет входа') AS [Начало_дня],
+    CASE 
+        WHEN pass.FirstIn IS NULL AND pass.FirstRawEvent IS NOT NULL 
+            THEN CAST(CONVERT(VARCHAR(8), pass.FirstRawEvent, 108) AS NVARCHAR(20))
+        ELSE N'—'
+    END AS [Первая_активность],
     CASE
         WHEN @TargetDate = CAST(GETDATE() AS DATE) AND (pass.LastEventType = 'IN' OR pass.LastOut IS NULL OR pass.LastOut <= pass.FirstIn)
             THEN N'Нет выхода'
         WHEN pass.LastOut IS NOT NULL AND pass.LastOut > pass.FirstIn
             THEN CAST(CONVERT(VARCHAR(8), pass.LastOut, 108) AS NVARCHAR(20))
+        WHEN @TargetDate < CAST(GETDATE() AS DATE) AND pass.LastRawEvent IS NOT NULL AND pass.LastRawEvent > ISNULL(pass.FirstIn, pass.FirstRawEvent)
+            THEN CAST(CONVERT(VARCHAR(8), pass.LastRawEvent, 108) AS NVARCHAR(20))
         ELSE N'Нет выхода'
     END AS [Конец_дня],
     CASE
-        WHEN pass.EmployeeID IS NOT NULL AND pass.FirstIn IS NOT NULL THEN
+        WHEN pass.EmployeeID IS NOT NULL AND (pass.FirstIn IS NOT NULL OR pass.FirstRawEvent IS NOT NULL) THEN
             RIGHT('0' + CAST(DATEDIFF(MINUTE,
-                pass.FirstIn,
+                ISNULL(pass.FirstIn, pass.FirstRawEvent),
                 CASE 
                     WHEN @TargetDate = CAST(GETDATE() AS DATE) AND (pass.LastEventType = 'IN' OR pass.LastOut IS NULL OR pass.LastOut <= pass.FirstIn) THEN GETDATE()
-                    ELSE ISNULL(pass.LastOut, pass.FirstIn)
+                    ELSE ISNULL(pass.LastOut, pass.LastRawEvent)
                 END) / 60 AS VARCHAR), 2) + ':' +
             RIGHT('0' + CAST(DATEDIFF(MINUTE,
-                pass.FirstIn,
+                ISNULL(pass.FirstIn, pass.FirstRawEvent),
                 CASE 
                     WHEN @TargetDate = CAST(GETDATE() AS DATE) AND (pass.LastEventType = 'IN' OR pass.LastOut IS NULL OR pass.LastOut <= pass.FirstIn) THEN GETDATE()
-                    ELSE ISNULL(pass.LastOut, pass.FirstIn)
+                    ELSE ISNULL(pass.LastOut, pass.LastRawEvent)
                 END) % 60 AS VARCHAR), 2)
         ELSE N'00:00'
     END AS [Находился_в_здании],
@@ -204,7 +212,6 @@ def run_export(input_date: str | None = None, save_xlsx: bool = True, debug: boo
     os.makedirs(SCUD_DIR, exist_ok=True)
 
     targets = get_targets(input_date)
-
     conn_str = (
         f"DRIVER={{{ODBC_DRIVER}}};"
         f"SERVER={SERVER_NAME};"
@@ -220,9 +227,20 @@ def run_export(input_date: str | None = None, save_xlsx: bool = True, debug: boo
         processing_date = target["date"]
         processing_date_str = processing_date.strftime("%d.%m.%Y")
         period_label = target["name"]
+        is_yesterday = (period_label == "Вчера")
 
-        log(f"--- Обработка периода: {period_label} ({processing_date_str}) ---")
+        # ⚡️ ПРОВЕРКА НАЛИЧИЯ ВЧЕРАШНЕГО ДНЯ В SQLITE:
+        # Если это вчерашний день и его снапшот уже зафиксирован в SQLite — пропускаем тяжелый запрос к MS SQL
+        if is_yesterday and has_yesterday_final_snapshot(processing_date_str):
+            log(f"[ℹ️] Вчерашний день ({processing_date_str}) уже зафиксирован финишным снапшотом Y. Пропускаем запрос к MS SQL.")
+            continue
 
+        if is_yesterday:
+            snapshot_time = f"{processing_date.strftime('%Y-%m-%d')} 22:00:00"
+        else:
+            snapshot_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+        log(f"--- Обработка периода: {period_label} ({processing_date_str}) --- [Снапшот: {snapshot_time}]")
         sql_query = SQL_QUERY_TEMPLATE.format(target_date=processing_date.strftime("%Y-%m-%d"))
 
         connection = None
@@ -233,15 +251,17 @@ def run_export(input_date: str | None = None, save_xlsx: bool = True, debug: boo
             log(f"База вернула {len(df)} строк за {processing_date_str}")
 
             if len(df) > 0:
-                # 1. Готовим колонки для локальной БД
                 df['fio_clean'] = df['Сотрудник'].apply(clean_scud_fio_light)
-                df['Пришел'] = df['Статус'].str.contains('Присутствовал', case=False, na=False)
+                
+                df['anomaly_flag'] = 'NONE'
+                mask_anomaly = (df['Начало_дня'] == 'Нет входа') & (df['Первая_активность'] != '—')
+                df.loc[mask_anomaly, 'anomaly_flag'] = 'ANOMALY_NO_IN_HAS_ACTIVITY'
 
-                # 2. ПРЯМОЕ СОХРАНЕНИЕ В SQLite (scud_orion_ai.db)
-                save_scud_to_db(df, processing_date_str)
+                df['Пришел'] = df['Статус'].str.contains('Присутствовал', case=False, na=False) & (~mask_anomaly)
+
+                save_scud_to_db(df, processing_date_str, snapshot_time=snapshot_time, is_yesterday=is_yesterday)
                 log(f"[✓] Записи за {processing_date_str} успешно сохранены в SQLite!", "SUCCESS")
 
-                # 3. Сохранение в Excel (если включен флаг save_xlsx)
                 if save_xlsx:
                     file_name = f"Сотрудники_{processing_date_str}.xlsx"
                     file_path = os.path.join(SCUD_DIR, file_name)
@@ -270,10 +290,22 @@ def run_export(input_date: str | None = None, save_xlsx: bool = True, debug: boo
 
 
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description="Экспорт данных СКУД в SQLite и Excel")
-    parser.add_argument("--date", dest="input_date", default=None)
-    parser.add_argument("-d", "--debug", action="store_true")
-    parser.add_argument("--no-xlsx", dest="save_xlsx", action="store_false", default=True, help="Отключить сохранение в XLSX")
+    help_text = """
+Модуль прямого экспорта данных СКУД Орион Pro (MS SQL Server) в SQLite и Excel.
+
+ПРИМЕРЫ ЗАПУСКА:
+  python services/scud_export.py                      -- Автоматическая выгрузка за Сегодня и Вчера
+  python services/scud_export.py --date 05.08.2026   -- Точечная выгрузка СКУД за конкретную дату
+  python services/scud_export.py --no-xlsx           -- Сохранение логов СКУД ТОЛЬКО в SQLite без дублирования в XLSX
+  python services/scud_export.py -d                  -- Запуск в режиме отладки MS SQL запросов (DEBUG)
+"""
+    parser = argparse.ArgumentParser(
+        description=help_text,
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    parser.add_argument("--date", dest="input_date", default=None, help="Дата выгрузки в формате ДД.ММ.ГГГГ (по умолчанию выгружаются Вчера и Сегодня)")
+    parser.add_argument("-d", "--debug", action="store_true", help="Включить подробные логи отладки подключения и запросов к MS SQL")
+    parser.add_argument("--no-xlsx", dest="save_xlsx", action="store_false", default=True, help="Отключить генерирование промежуточных XLSX-файлов в папке data/scud/")
     args = parser.parse_args()
 
     run_export(args.input_date, save_xlsx=args.save_xlsx, debug=args.debug)

services/text_reporter.py

@@ -1,19 +1,18 @@
 import json
 import difflib
 import re
-from modules.ai_verifier import ask_ollama
-from modules.knowledge_base import load_knowledge_base
+from services.ai_verifier import ask_ollama
+from services.knowledge_base import load_knowledge_base
 
 
 def find_python_fuzzy_matches(unexplained_df, raw_absent_df):
     """
     Точный поиск совпадений ФИО силами Python (без галлюцинаций ИИ).
-    Сравнивает фамилию и полное имя с порогом сходства >= 0.80.
+    Сравнивает фамилию и полное имя с порогом сходства >= 0.75.
     """
     if unexplained_df.empty or raw_absent_df is None or raw_absent_df.empty:
         return []
 
-    # Собираем словарь чистых ФИО 1С -> сырые ФИО 1С
     absent_dict = {}
     for idx, r in raw_absent_df.iterrows():
         raw_fio = str(r.get('ФИО', ''))
@@ -37,7 +36,6 @@ def find_python_fuzzy_matches(unexplained_df, raw_absent_df):
                 continue
             abs_surname = abs_parts[0].lower()
 
-            # Строгая проверка совпадения фамилии
             if surname == abs_surname:
                 ratio = difflib.SequenceMatcher(None, fio.lower(), abs_clean.lower()).ratio()
                 if ratio >= 0.75:
@@ -51,23 +49,13 @@ def find_python_fuzzy_matches(unexplained_df, raw_absent_df):
     return matches
 
 
-def generate_markdown_report(merged_df, absent_explained, absent_unexplained, scud_present_but_absent_in_1c, anomalies_list=None, raw_scud_df=None, raw_staff_df=None, raw_absent_df=None, date_str="29.07.2026"):
+def generate_markdown_report(merged_df, absent_explained, absent_unexplained, scud_present_but_absent_in_1c, anomalies_list=None, raw_scud_df=None, raw_staff_df=None, raw_absent_df=None, date_str="05.08.2026"):
+    # 1. Загрузка Базы Знаний
     kb = load_knowledge_base()
     custom_rules = kb.get("rules", [])
     custom_rules_str = "\n".join([f"- {r}" for r in custom_rules]) if custom_rules else "Специфических правил компании пока нет."
 
-    # 1. Точный расчет неточных совпадений через Python (Исключает галлюцинации ИИ)
-    fio_mismatches_python = find_python_fuzzy_matches(absent_unexplained, raw_absent_df)
-
-    # 2. Список истинно неизвестных для ИИ
-    unexplained_list = []
-    if not absent_unexplained.empty:
-        for idx, r in absent_unexplained.iterrows():
-            fio = r.get('Сотрудник', r.get('fio_clean', ''))
-            dept = r.get('Подразделение', '—')
-            pos = r.get('Должность', '—')
-            unexplained_list.append(f"{fio} — {dept}, {pos}")
-
+    # 2. Предварительный расчет ключевых метрик (РЕШАЕТ NameError: total_staff)
     total_staff = len(merged_df)
     is_working_mask = (merged_df['Пришел'] == True) | (
         merged_df['Вид_отсутствия'].astype(str).str.lower().str.contains('командировк|удален|дистанцион|разъездн', regex=True, na=False)
@@ -77,6 +65,25 @@ def generate_markdown_report(merged_df, absent_explained, absent_unexplained, sc
     unexplained_cnt = len(absent_unexplained)
     anomalies_cnt = len(anomalies_list) if anomalies_list else 0
 
+    # 3. Точный расчет неточных совпадений через Python
+    fio_mismatches_python = find_python_fuzzy_matches(absent_unexplained, raw_absent_df)
+
+    # 4. Формирование списка неизвестных с приоритетом аббревиатуры СКУД
+    unexplained_list = []
+    if not absent_unexplained.empty:
+        for idx, r in absent_unexplained.iterrows():
+            fio = r.get('Сотрудник', r.get('fio_clean', ''))
+            
+            dept_scud = str(r.get('department_scud', '')).strip()
+            dept_1c = str(r.get('Подразделение', '')).strip()
+            dept = dept_scud if (dept_scud and dept_scud.lower() != 'nan' and dept_scud != '—') else dept_1c
+            if not dept:
+                dept = '—'
+
+            pos = r.get('Должность', '—')
+            unexplained_list.append(f"{fio} — {dept}, {pos}")
+
+    # 5. Сборка промпта для Ollama
     prompt = f"""
 Ты — старший аудитор кадровой безопасности и контроллинга СКУД. 
 Сформируй итоговую сводку кадрового контроля на {date_str}.
@@ -131,5 +138,5 @@ def generate_markdown_report(merged_df, absent_explained, absent_unexplained, sc
 (2-3 системные рекомендации без указания ФИО сотрудников)
 """
 
-    sys_prompt = "Ты — эксперт кадрового аудита. Будь точен, не придумывай непереданные данные."
+    sys_prompt = "Ты — русскоязычный кадровый аудитор. Пиши СТРОГО на русском языке по предоставленному Markdown-шаблону. Категорически запрещено выводить JSON или китайские символы."
     return ask_ollama(prompt, system_prompt=sys_prompt)

test.txt

@@ -0,0 +1 @@
+122222222222222222222222222222

Анализ_аномалии_СКУД_и_техзадание.md

@@ -0,0 +1,61 @@
+# ТЕХНИЧЕСКИЙ РАЗБОР АНОМАЛИИ СКУД И ТЗ НА ФИКС
+> **Проблема скрытого маскирования сбоев турникетов и правила их устранения в проекте `scud_orion_ai`**
+
+---
+
+### 📋 Метаданные инцидента
+
+| Параметр | Значение |
+| :--- | :--- |
+| **Дата инцидента:** | 04 августа 2026 г. |
+| **Затронуто сотрудников:** | ~119 человек (из 276) |
+| **Система:** | СКУД «Орион Pro» (MSSQL) + Python ETL + SQLite |
+| **Статус решения:** | Требуется фикс валидации данных (В процессе) |
+
+---
+
+## 1. Суть проблемы («Грабли»)
+
+При утреннем сбое турникетов или контроллеров СКУД (08:00–10:00) события первичного прохода в базу не попадают. В результате у сотрудников в итоговом отчете формируется значение `Начало_дня = «Нет входа»`. 
+
+Однако в течение дня сотрудники перемещаются внутри здания, выходят на обед или прикладывают карты к внутренним считывателям, генерируя сырые транзакции в MSSQL (таблица `pLogData`).
+
+> 🚨 **Главная баг-логика текущего алгоритма:**
+> Скрипт перебирает все события за день и, видя любую дневную/вечернюю активность, **автоматически присваивает сотруднику флаг `is_present = 1` (`Статус = «Присутствовал»`)**.
+> 
+> В итоге система «тихо сглаживает» аномалию: вместо того чтобы поднять тревогу о массовом сбое турникетов (70+ человек без утреннего входа), скрипт отправил 30+ человек в «Итого на работе», искусственно уменьшив список проблемных записей до 7 «неизвестных».
+
+---
+
+## 2. Разбор механики расхождения отчетов (17:00 vs Конец дня)
+
+Вопреки первоначальной гипотезе, вечерние выходы (17:42 и т.д.) у данных сотрудников не записывались в колонку `time_out` (там оставалось «Нет выхода»). Расхождение выгрузок было вызвано двумя факторами:
+
+1. **В 17:00** в базе SQL 1С еще отсутствовал полный пакет кадровых документов за день, либо запуск производился без сверки с реестром исключений.
+2. **При повторном прогоне** (вечером/ночью) скрипт подтянул полную базу 1С, а для оставшихся «безвходных» отработал скрытый флаг `is_present = 1`, маскируя технический сбой СКУД.
+
+---
+
+## 3. Техническое задание на исправление (Правила фикса)
+
+* **Строгая валидация флага присутствия (Data Sanitization):**
+  Если `time_in == 'Нет входа'` и сотрудник отсутствует в `static_reason_workers.csv` (статичные удалёнщики/внештатники), код **ЗАПРЕЩАЕТ** автоматически проставлять `is_present = 1`, даже если выгрузка/агрегатор передает статус «Присутствовал».
+
+* **Детектор аномалий и «Красный флаг» (Anomaly Detection):**
+  Если у человека `time_in == 'Нет входа'`, но при этом есть дневные проходы в `pLogData`, система помечает его статусом:
+  `🚨 АНОМАЛИЯ СКУД: Присутствие без утреннего входа (Зафиксирована активность в течение дня)`.
+
+* **Группировка массовых сбоев:**
+  Если процент людей с подобной аномалией превышает **5% от штата**, ИИ/модуль аналитики генерирует системный алерт: 
+  `«Внимание! Зафиксирован массовый сбой регистраторов входа СКУД»`.
+
+* **Параметризация MSSQL СКУД по времени (`@CutoffDateTime`):**
+  Добавить возможность делать срезы базы СКУД на конкретный час (например, 17:00), чтобы видеть честное состояние контроллеров и транзакций на выбранный момент времени:
+  ```sql
+  DECLARE @CutoffDateTime DATETIME = '2026-08-04 17:00:00';
+  SELECT * FROM pLogData WHERE TimeVal <= @CutoffDateTime;
+
+  Хранение истории выгрузок (snapshot_time):
+Запретить перезапись (REPLACE) локальной БД SQLite в рамках одного дня. Каждая выгрузка за день должна сохраняться с меткой времени snapshot_time, чтобы сохранять историю срезов (12:00, 17:00, 19:00).
+
+Документ зафиксирован в рамках проекта scud_orion_ai_v2.