Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,33 +1,10 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""streamlit_app.py
-
-Скоринг публикаций по направлениям исследований DIR01..DIR14.
-Offline-first: приложение работает ТОЛЬКО по готовым JSONL candidates и НЕ делает
-никаких сетевых enrichment (OpenAlex API и т.п.).
-
-Хранилища на HuggingFace Hub (repo_type="dataset"):
-- PUBLICATIONS_REPO: содержит dir_registry.json и candidates JSONL
-- REVIEWS_REPO: журнал оценок (JSONL batches)
-
-Переменные окружения (Space Settings → Variables/Secrets):
-- PUBLICATIONS_REPO, REVIEWS_REPO (обязательно)
-- HF_TOKEN (нужен для записи; для чтения приватных репо)
-- BATCH_SIZE (по умолчанию 1)
-- PAGE_WINDOW_SIZE (по умолчанию 50)
-- PUB_DIR_REGISTRY_PATH (по умолчанию dir_registry.json)
-- PUB_CANDIDATES_PREFIX (по умолчанию candidates)
-- REVIEWS_LOG_PREFIX (по умолчанию reviews_log)
-- PUB_CANDIDATES_PATTERNS (опционально)
-
-"""
-
 import os
 import json
 import uuid
 import gzip
 import tempfile
 import datetime as dt
+import math
 from typing import List, Dict, Any, Optional, Tuple, Set
 
 import pandas as pd
@@ -35,42 +12,78 @@ import streamlit as st
 from huggingface_hub import hf_hub_download, HfApi
 
 # =========================
-# ENV CONFIG
+# ENV CONFIG (HF Space Variables / Secrets)
 # =========================
 PUBLICATIONS_REPO = os.environ.get("PUBLICATIONS_REPO", "").strip()
 REVIEWS_REPO = os.environ.get("REVIEWS_REPO", "").strip()
 HF_TOKEN = os.environ.get("HF_TOKEN") or os.environ.get("HF_API_TOKEN")
+ALLOW_CREATE_REVIEWS_REPO = (os.environ.get("ALLOW_CREATE_REVIEWS_REPO", "0").strip().lower() in ("1","true","yes","y","on"))
+REVIEWS_PRIVATE = (os.environ.get("REVIEWS_PRIVATE", "1").strip().lower() in ("1","true","yes","y","on"))
 
-ALLOW_CREATE_REVIEWS_REPO = (os.environ.get("ALLOW_CREATE_REVIEWS_REPO", "0").strip().lower() in ("1", "true", "yes", "y", "on"))
-REVIEWS_PRIVATE = (os.environ.get("REVIEWS_PRIVATE", "1").strip().lower() in ("1", "true", "yes", "y", "on"))
-
+# Надёжность по умолчанию: сразу пишем каждый review
 BATCH_SIZE = int(os.environ.get("BATCH_SIZE", "1"))
-PAGE_WINDOW_SIZE = int(os.environ.get("PAGE_WINDOW_SIZE", "50"))
 
-PUB_DIR_REGISTRY_PATH = os.environ.get("PUB_DIR_REGISTRY_PATH", "dir_registry.json").strip()
-PUB_CANDIDATES_PREFIX = os.environ.get("PUB_CANDIDATES_PREFIX", "candidates").strip()
-REVIEWS_LOG_PREFIX = os.environ.get("REVIEWS_LOG_PREFIX", "reviews_log").strip()
+PUB_DIR_REGISTRY_PATH = os.environ.get("PUB_DIR_REGISTRY_PATH", "dir_registry.json")
+PUB_CANDIDATES_PREFIX = os.environ.get("PUB_CANDIDATES_PREFIX", "candidates")
+REVIEWS_LOG_PREFIX = os.environ.get("REVIEWS_LOG_PREFIX", "reviews_log")
 
-# Паттерны поиска candidates файлов (разные схемы именования)
+# Паттерны поиска candidates файлов (поддержка разных схем данных)
+# Можно переопределить в Space Variables:
+#   PUB_CANDIDATES_PATTERNS="{prefix}/{dir_id}_top500.jsonl|{prefix}/{dir_id}.jsonl|manual_candidates/{dir_id}.jsonl|manual_candidates/{dir_id}_top500.jsonl"
 PUB_CANDIDATES_PATTERNS = os.environ.get(
     "PUB_CANDIDATES_PATTERNS",
-    "{prefix}/{dir_id}_top500.jsonl|{prefix}/{dir_id}_top500.jsonl.gz|{prefix}/{dir_id}.jsonl|{prefix}/{dir_id}.jsonl.gz|manual_candidates/{dir_id}.jsonl|manual_candidates/{dir_id}.jsonl.gz",
+    "{prefix}/{dir_id}_top500.jsonl|{prefix}/{dir_id}_top500.jsonl.gz|{prefix}/{dir_id}.jsonl|{prefix}/{dir_id}.jsonl.gz|manual_candidates/{dir_id}.jsonl|manual_candidates/{dir_id}.jsonl.gz"
 ).strip()
 
+
 api = HfApi(token=HF_TOKEN)
 
-st.set_page_config(page_title="Скоринг публикаций", layout="wide")
+st.set_page_config(page_title="ISS-GR Screening", layout="wide")
+
 
 # =========================
 # Helpers
 # =========================
 
+def check_dataset_repo(repo_id: str, token: Optional[str]) -> Tuple[bool, str]:
+    """
+    Проверяет существование датасет-репозитория (repo_type="dataset").
+    Возвращает (ok, message). Если ok=False, message содержит причину.
+    """
+    try:
+        api_local = HfApi(token=token) if token else HfApi()
+        _ = api_local.repo_info(repo_id=repo_id, repo_type="dataset")
+        return True, "OK"
+    except Exception as e:
+        msg = str(e)
+        # huggingface_hub кидает 404/Repository Not Found
+        return False, msg
+
+def maybe_create_reviews_repo(repo_id: str) -> Tuple[bool, str]:
+    """
+    Пытается создать reviews dataset repo, если включён ALLOW_CREATE_REVIEWS_REPO.
+    Возвращает (ok, message).
+    """
+    if not ALLOW_CREATE_REVIEWS_REPO:
+        return False, "ALLOW_CREATE_REVIEWS_REPO=0"
+    if not HF_TOKEN:
+        return False, "HF_TOKEN отсутствует (нужен для создания репозитория)"
+    try:
+        api.create_repo(
+            repo_id=repo_id,
+            repo_type="dataset",
+            private=bool(REVIEWS_PRIVATE),
+            exist_ok=True,
+        )
+        return True, "created_or_exists"
+    except Exception as e:
+        return False, str(e)
+
 def require_env(name: str, value: str) -> None:
     if not value:
         st.error(f"Не задано **{name}**. Укажи в Space Settings → Variables.")
         st.stop()
 
-
 def safe_int(x) -> Optional[int]:
     try:
         if x is None or pd.isna(x):
@@ -79,7 +92,6 @@ def safe_int(x) -> Optional[int]:
     except Exception:
         return None
 
-
 def safe_float(x) -> Optional[float]:
     try:
         if x is None or pd.isna(x):
@@ -88,20 +100,20 @@ def safe_float(x) -> Optional[float]:
     except Exception:
         return None
 
-
 def doi_url(doi: Optional[str]) -> Optional[str]:
     if not doi:
         return None
     doi = str(doi).strip()
-    if not doi:
-        return None
     if doi.startswith("http://") or doi.startswith("https://"):
         return doi
     return f"https://doi.org/{doi}"
 
-
 def normalize_dir_id(dir_id: str, pad2: bool) -> str:
-    """DIR1..DIR14 / DIR01..DIR14"""
+    """
+    Поддержка форматов DIR1..DIR14 и DIR01..DIR14.
+    pad2=True  -> DIR01
+    pad2=False -> DIR1
+    """
     if not isinstance(dir_id, str):
         return str(dir_id)
     s = dir_id.strip().upper()
@@ -111,35 +123,34 @@ def normalize_dir_id(dir_id: str, pad2: bool) -> str:
     try:
         n = int(tail)
     except Exception:
+        # DIRXX (не число) — как есть
         return dir_id.strip()
     return f"DIR{n:02d}" if pad2 else f"DIR{n}"
 
-
 def dir_variants(dir_id: str) -> List[str]:
+    """
+    Список вариантов идентификатора DIR, чтобы подхватить разные имена файлов/папок.
+    """
     if not isinstance(dir_id, str):
         return [str(dir_id)]
     a = dir_id.strip()
     b = normalize_dir_id(a, pad2=True)
     c = normalize_dir_id(a, pad2=False)
-    out: List[str] = []
+    out = []
     for x in [a, b, c]:
         if x and x not in out:
             out.append(x)
     return out
 
-
-def dir_tag(dir_id: str) -> str:
-    """DIR-01"""
-    d2 = normalize_dir_id(dir_id, pad2=True)  # DIR01
-    if d2.upper().startswith("DIR") and len(d2) >= 5:
-        return f"DIR-{d2[3:]}"
-    return d2
-
+def dir_no(dir_id: str) -> str:
+    if isinstance(dir_id, str) and dir_id.upper().startswith("DIR"):
+        return dir_id[3:]
+    return str(dir_id)
 
 def join_terms(term_list: Any) -> str:
     if not term_list:
         return "—"
-    out: List[str] = []
+    out = []
     for x in term_list:
         if isinstance(x, dict):
             t = x.get("t")
@@ -149,72 +160,74 @@ def join_terms(term_list: Any) -> str:
             out.append(str(x))
     return "; ".join(out) if out else "—"
 
-
 def topics_line(topics: Any) -> str:
     if not topics:
         return "—"
-    out: List[str] = []
-    if isinstance(topics, list):
-        for t in topics[:3]:
-            if isinstance(t, dict):
-                tid = t.get("topic_id") or t.get("id")
-                name = t.get("topic_name") or t.get("display_name")
-                if tid and name:
-                    out.append(f"{tid} — {name}")
-                elif name:
-                    out.append(str(name))
-                elif tid:
-                    out.append(str(tid))
-            else:
-                out.append(str(t))
+    out = []
+    for t in (topics[:3] if isinstance(topics, list) else []):
+        if isinstance(t, dict):
+            tid = t.get("topic_id") or t.get("id")
+            name = t.get("topic_name") or t.get("display_name")
+            if tid and name:
+                out.append(f"{tid} — {name}")
+            elif name:
+                out.append(str(name))
+            elif tid:
+                out.append(str(tid))
+        else:
+            out.append(str(t))
     return "; ".join(out) if out else "—"
 
+def get_reviewer() -> str:
+    default = os.environ.get("REVIEWER", "")
+    v = st.sidebar.text_input("Рецензент (имя/ник)", value=default).strip()
+    return v or "anonymous"
 
 def decode_abstract(abstract_inverted_index: Optional[dict]) -> str:
     if not abstract_inverted_index or not isinstance(abstract_inverted_index, dict):
         return ""
-    pos_to_word: Dict[int, str] = {}
+    pos_to_word = {}
     for w, positions in abstract_inverted_index.items():
         if not isinstance(positions, list):
             continue
         for p in positions:
-            try:
-                pos_to_word[int(p)] = str(w)
-            except Exception:
-                continue
+            pos_to_word[p] = w
     return " ".join(pos_to_word[p] for p in sorted(pos_to_word.keys())) if pos_to_word else ""
 
-
 def get_authors_and_abstract(row: Dict[str, Any]) -> Tuple[str, str]:
-    """Offline-only: показываем только то, что есть в candidates JSONL."""
-    authors = row.get("authors") or row.get("author_names") or row.get("authors_str")
+    """
+    Offline-first: берём авторов/аннотацию ТОЛЬКО из candidates JSONL.
+    Никаких обращений к OpenAlex API.
+    """
+    # authors
+    authors = row.get('authors') or row.get('author_names') or row.get('authors_str')
     if not authors:
-        auths = row.get("authorships")
+        # Иногда candidates могут содержать OpenAlex-подобный authroships, но уже на входе (без сети)
+        auths = row.get('authorships')
         if isinstance(auths, list):
-            names: List[str] = []
+            names = []
             for a in auths:
                 if not isinstance(a, dict):
                     continue
-                an = ((a.get("author") or {}).get("display_name") or "").strip()
+                an = ((a.get('author') or {}).get('display_name') or '').strip()
                 if an:
                     names.append(an)
             if names:
-                authors = ", ".join(names[:12]) + (", и др." if len(names) > 12 else "")
-
+                authors = ', '.join(names[:12]) + (', и др.' if len(names) > 12 else '')
     if isinstance(authors, list):
-        authors = ", ".join([str(a) for a in authors if a])
-    authors_str = authors.strip() if isinstance(authors, str) and authors.strip() else ""
+        authors = ', '.join([str(a) for a in authors if a])
+    authors_str = authors.strip() if isinstance(authors, str) and authors.strip() else ''
 
-    abstract = row.get("abstract") or row.get("abstract_text")
-    if not abstract and isinstance(row.get("abstract_inverted_index"), dict):
-        abstract = decode_abstract(row.get("abstract_inverted_index"))
-    abstract_str = abstract.strip() if isinstance(abstract, str) and abstract.strip() else ""
-
-    return authors_str or "—", abstract_str or "—"
+    # abstract
+    abstract = row.get('abstract') or row.get('abstract_text')
+    if not abstract and isinstance(row.get('abstract_inverted_index'), dict):
+        abstract = decode_abstract(row.get('abstract_inverted_index'))
+    abstract_str = abstract.strip() if isinstance(abstract, str) and abstract.strip() else ''
 
+    return authors_str or '—', abstract_str or '—'
 
 def open_jsonl_any(path: str) -> List[Dict[str, Any]]:
-    rows: List[Dict[str, Any]] = []
+    rows = []
     if path.endswith(".gz"):
         with gzip.open(path, "rt", encoding="utf-8") as f:
             for line in f:
@@ -229,32 +242,37 @@ def open_jsonl_any(path: str) -> List[Dict[str, Any]]:
                     rows.append(json.loads(line))
     return rows
 
-
 def normalize_candidate_row(obj: Dict[str, Any], selected_dir: str) -> Dict[str, Any]:
-    """Нормализация схем candidates (под разные генераторы)."""
+    """
+    Приводит разные схемы данных к единому набору полей, используемых UI.
+    Поддерживаем:
+    - старый формат candidates: work_id/year/cited_by/dir_score/match_score
+    - новый формат паспорта: source_id/openalex_work_id/publication_year/cited_by_count/dir_native_components/quality_weight
+    """
     out = dict(obj)
 
-    # IDs
+    # --- IDs ---
     source_id = out.get("source_id") or out.get("Source ID")
     if isinstance(source_id, str) and source_id.strip():
         out["source_id"] = source_id.strip()
 
     work_id = out.get("work_id")
     if not isinstance(work_id, str) or not work_id.strip():
+        # паспорта
         wid = out.get("openalex_work_id") or out.get("OpenAlex work ID") or out.get("dup_work_id")
         if isinstance(wid, str) and wid.strip():
             work_id = wid.strip()
-    out["work_id"] = work_id if isinstance(work_id, str) and work_id.strip() else None
+    out["work_id"] = work_id if isinstance(work_id, str) else None
 
-    # title
+    # --- Title ---
     title = out.get("title") or out.get("display_name") or out.get("Title")
     out["title"] = str(title).strip() if title else "—"
 
-    # doi
+    # --- DOI ---
     doi = out.get("doi") or out.get("DOI")
     out["doi"] = str(doi).strip() if doi else None
 
-    # abstract (offline)
+    # --- Abstract (offline) ---
     if out.get("abstract") is None:
         ab = out.get("abstract_text")
         if isinstance(ab, str) and ab.strip():
@@ -262,7 +280,8 @@ def normalize_candidate_row(obj: Dict[str, Any], selected_dir: str) -> Dict[str,
         elif isinstance(out.get("abstract_inverted_index"), dict):
             out["abstract"] = decode_abstract(out.get("abstract_inverted_index")) or None
 
-    # year / cited
+
+    # --- Year / cited_by ---
     year = out.get("year")
     if year is None:
         year = out.get("publication_year") or out.get("Publication year")
@@ -273,21 +292,27 @@ def normalize_candidate_row(obj: Dict[str, Any], selected_dir: str) -> Dict[str,
         cited_by = out.get("cited_by_count") or out.get("Cited by count")
     out["cited_by"] = safe_int(cited_by)
 
-    # scores
+    # --- Scores ---
+    # dir_score: приоритет
+    # 1) явное поле dir_score (старый candidates)
     ds = out.get("dir_score")
+    # 2) паспорта: dir_native_components.score (если selected_dir совпадает с родным)
     if ds is None:
         comp = out.get("dir_native_components") or {}
         if isinstance(comp, dict) and comp.get("score") is not None:
             ds = comp.get("score")
+    # 3) паспорта: dir_scores[selected_dir]
     if ds is None:
         dsd = out.get("dir_scores") or {}
         if isinstance(dsd, dict):
+            # пробуем разные варианты dir_id
             for dv in dir_variants(selected_dir):
                 if dv in dsd:
                     ds = dsd.get(dv)
                     break
     out["dir_score"] = safe_float(ds)
 
+    # match_score: старое поле; если его нет — используем delta или quality_weight*100 для “второй метрики”
     ms = out.get("match_score")
     if ms is None:
         comp = out.get("dir_native_components") or {}
@@ -300,64 +325,50 @@ def normalize_candidate_row(obj: Dict[str, Any], selected_dir: str) -> Dict[str,
                 ms = None
     out["match_score"] = safe_float(ms)
 
-    out["quality_weight"] = safe_float(out.get("quality_weight"))
-    out["dir_native_components"] = out.get("dir_native_components") if isinstance(out.get("dir_native_components"), dict) else {}
+    # quality_weight / components
+    qw = out.get("quality_weight")
+    out["quality_weight"] = safe_float(qw)
+    comp = out.get("dir_native_components")
+    out["dir_native_components"] = comp if isinstance(comp, dict) else {}
 
-    # links
+    # links: pdf/primary location
     out["pdf_url"] = out.get("pdf_url") or out.get("PDF URL")
     out["primary_location_url"] = out.get("primary_location_url") or out.get("Primary location URL")
 
     return out
 
-
-def row_keys_all(r: Dict[str, Any]) -> Set[str]:
-    keys: Set[str] = set()
-    sid = r.get("source_id")
+def review_key(row: Dict[str, Any]) -> str:
+    """
+    Ключ "уже оценено":
+    - если есть source_id — используем его (если вы теперь опираетесь на source_id)
+    - иначе work_id
+    """
+    sid = row.get("source_id")
     if isinstance(sid, str) and sid.strip():
-        keys.add(f"SRC::{sid.strip()}")
-    wid = r.get("work_id")
+        return f"SRC::{sid.strip()}"
+    wid = row.get("work_id")
     if isinstance(wid, str) and wid.strip():
-        keys.add(f"W::{wid.strip()}")
-    return keys
-
-
-def check_dataset_repo(repo_id: str, token: Optional[str]) -> Tuple[bool, str]:
-    try:
-        api_local = HfApi(token=token) if token else HfApi()
-        _ = api_local.repo_info(repo_id=repo_id, repo_type="dataset")
-        return True, "OK"
-    except Exception as e:
-        return False, str(e)
-
-
-def maybe_create_reviews_repo(repo_id: str) -> Tuple[bool, str]:
-    if not ALLOW_CREATE_REVIEWS_REPO:
-        return False, "ALLOW_CREATE_REVIEWS_REPO=0"
-    if not HF_TOKEN:
-        return False, "HF_TOKEN отсутствует (нужен для создания репозитория)"
-    try:
-        api.create_repo(repo_id=repo_id, repo_type="dataset", private=bool(REVIEWS_PRIVATE), exist_ok=True)
-        return True, "created_or_exists"
-    except Exception as e:
-        return False, str(e)
+        return f"W::{wid.strip()}"
+    return ""
 
 
 # =========================
-# Hub reads
+# Publications (read)
 # =========================
-
 @st.cache_data(show_spinner=False)
 def load_dir_registry(repo_id: str, filename: str) -> List[Dict[str, Any]]:
     path = hf_hub_download(repo_id=repo_id, filename=filename, repo_type="dataset", token=HF_TOKEN)
     with open(path, "r", encoding="utf-8") as f:
         return json.load(f)
 
-
 @st.cache_data(show_spinner=False)
 def load_candidates(repo_id: str, dir_id: str, prefix: str) -> pd.DataFrame:
+    """
+    Поддержка нескольких паттернов и вариантов DIR id (DIR1 vs DIR01).
+    """
     patterns = [p.strip() for p in PUB_CANDIDATES_PATTERNS.split("|") if p.strip()]
-    tried: List[str] = []
-    rows: Optional[List[Dict[str, Any]]] = None
+    tried = []
+    rows = None
 
     for dv in dir_variants(dir_id):
         for pat in patterns:
@@ -366,7 +377,11 @@ def load_candidates(repo_id: str, dir_id: str, prefix: str) -> pd.DataFrame:
             try:
                 path = hf_hub_download(repo_id=repo_id, filename=fname, repo_type="dataset", token=HF_TOKEN)
                 rows = open_jsonl_any(path)
-                break
+                if rows:
+                    break
+                # если файл пустой — тоже считаем найденным
+                if rows == []:
+                    break
             except Exception:
                 continue
         if rows is not None:
@@ -375,9 +390,11 @@ def load_candidates(repo_id: str, dir_id: str, prefix: str) -> pd.DataFrame:
     if rows is None:
         raise FileNotFoundError("Не найден candidates файл. Пробовали:\n" + "\n".join(tried[:30]) + ("\n..." if len(tried) > 30 else ""))
 
+    # normalize schema
     normed = [normalize_candidate_row(r, dir_id) for r in rows if isinstance(r, dict)]
     df = pd.DataFrame(normed)
 
+    # numeric columns
     for col in ["dir_score", "match_score", "cited_by", "year", "quality_weight"]:
         if col in df.columns:
             df[col] = pd.to_numeric(df[col], errors="coerce")
@@ -386,14 +403,14 @@ def load_candidates(repo_id: str, dir_id: str, prefix: str) -> pd.DataFrame:
 
 
 # =========================
-# Hub reviews index (read)
+# Reviews (read on-demand)
 # =========================
-
 @st.cache_data(show_spinner=False)
 def list_review_files(repo_id: str, dir_id: str, prefix: str) -> List[str]:
     files = api.list_repo_files(repo_id=repo_id, repo_type="dataset")
+    # в reviews repo папка может быть DIR1 или DIR01 — подхватываем оба
     needles = [f"/{dv}/" for dv in dir_variants(dir_id)]
-    out: List[str] = []
+    out = []
     for p in files:
         if not (p.startswith(prefix + "/") and p.endswith(".jsonl")):
             continue
@@ -401,25 +418,19 @@ def list_review_files(repo_id: str, dir_id: str, prefix: str) -> List[str]:
             out.append(p)
     return out
 
-
 @st.cache_data(show_spinner=False)
-def load_reviews_index(repo_id: str, dir_id: str, prefix: str) -> Tuple[Set[str], Dict[str, Dict[str, Any]], Dict[str, Dict[str, Any]]]:
-    """Возвращает:
-    - множество ключей (SRC:: / W::) уже оценённых публикаций
-    - словарь последних review по source_id
-    - словарь последних review по work_id
-
-    Важно: это НЕ enrichment; это чтение ваших собственных сохранённых оценок.
+def load_reviewed_keys(repo_id: str, dir_id: str, prefix: str) -> Set[str]:
+    """
+    Поддержка миграции:
+    - старые review содержали только work_id -> помечаем как W::<id>
+    - новые могут содержать source_id -> помечаем как SRC::<id>
     """
     try:
         files = list_review_files(repo_id, dir_id, prefix)
     except Exception:
-        return set(), {}, {}
-
-    keys: Set[str] = set()
-    by_src: Dict[str, Dict[str, Any]] = {}
-    by_w: Dict[str, Dict[str, Any]] = {}
+        return set()
 
+    reviewed: Set[str] = set()
     for relpath in files:
         try:
             path = hf_hub_download(repo_id=repo_id, filename=relpath, repo_type="dataset", token=HF_TOKEN)
@@ -431,34 +442,29 @@ def load_reviews_index(repo_id: str, dir_id: str, prefix: str) -> Tuple[Set[str]
                     obj = json.loads(line)
 
                     sid = obj.get("source_id")
-                    wid = obj.get("work_id")
-
                     if isinstance(sid, str) and sid.strip():
-                        sid = sid.strip()
-                        keys.add(f"SRC::{sid}")
-                        by_src[sid] = obj
+                        reviewed.add(f"SRC::{sid.strip()}")
+
+                    wid = obj.get("work_id")
                     if isinstance(wid, str) and wid.strip():
-                        wid = wid.strip()
-                        keys.add(f"W::{wid}")
-                        by_w[wid] = obj
+                        reviewed.add(f"W::{wid.strip()}")
         except Exception:
             continue
-
-    return keys, by_src, by_w
+    return reviewed
 
 
 # =========================
-# Hub write
+# Reviews (write)
 # =========================
-
 def push_batch_to_reviews_repo(repo_id: str, dir_id: str, prefix: str, batch: List[Dict[str, Any]]) -> None:
     if not batch:
         return
     if not HF_TOKEN:
         raise RuntimeError("Нет HF_TOKEN (Secret) — нельзя записывать в reviews dataset.")
-
     today = dt.date.today().isoformat()
     batch_id = str(uuid.uuid4())
+
+    # Пишем в dir_id как есть (но если dir_id может быть DIR01, а у вас в БД DIR1 — нормализуйте в UI выбором)
     canonical_dir = normalize_dir_id(dir_id, pad2=False)
     path_in_repo = f"{prefix}/{today}/{canonical_dir}/{batch_id}.jsonl"
 
@@ -477,64 +483,20 @@ def push_batch_to_reviews_repo(repo_id: str, dir_id: str, prefix: str, batch: Li
 
 
 # =========================
-# Session state
+# Sidebar
 # =========================
 
-def ensure_state() -> None:
-    if "batch" not in st.session_state:
-        st.session_state["batch"] = []
-
-    if "reviewed_local_committed" not in st.session_state:
-        st.session_state["reviewed_local_committed"] = set()
-    if "reviewed_local_pending" not in st.session_state:
-        st.session_state["reviewed_local_pending"] = set()
-
-    # локальные значения (чтобы предзаполнять при навигации)
-    if "local_by_src" not in st.session_state:
-        st.session_state["local_by_src"] = {}
-    if "local_by_w" not in st.session_state:
-        st.session_state["local_by_w"] = {}
-
-    # remote кэш (НЕ показываем в UI)
-    if "remote_dir" not in st.session_state:
-        st.session_state["remote_dir"] = None
-    if "remote_keys" not in st.session_state:
-        st.session_state["remote_keys"] = set()
-    if "remote_by_src" not in st.session_state:
-        st.session_state["remote_by_src"] = {}
-    if "remote_by_w" not in st.session_state:
-        st.session_state["remote_by_w"] = {}
-
-
-def get_saved_review_for_row(row: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-    sid = row.get("source_id") if isinstance(row.get("source_id"), str) else None
-    wid = row.get("work_id") if isinstance(row.get("work_id"), str) else None
-
-    # local first (pending/committed current session)
-    if sid and sid in st.session_state.get("local_by_src", {}):
-        return st.session_state["local_by_src"].get(sid)
-    if wid and wid in st.session_state.get("local_by_w", {}):
-        return st.session_state["local_by_w"].get(wid)
-
-    # remote next
-    if sid and sid in st.session_state.get("remote_by_src", {}):
-        return st.session_state["remote_by_src"].get(sid)
-    if wid and wid in st.session_state.get("remote_by_w", {}):
-        return st.session_state["remote_by_w"].get(wid)
-
-    return None
-
-
 # =========================
-# Sidebar: диагностика + управление
+# MAIN APP (offline-first)
 # =========================
 
 with st.sidebar:
-    st.title("Скоринг публикаций")
+    st.title("ISS-GR Скрининг (offline-first)")
 
     require_env("PUBLICATIONS_REPO", PUBLICATIONS_REPO)
     require_env("REVIEWS_REPO", REVIEWS_REPO)
 
+    # Проверяем наличие репозиториев (чтобы не ловить 404 при сохранении)
     pub_ok, pub_msg = check_dataset_repo(PUBLICATIONS_REPO, HF_TOKEN)
     if not pub_ok:
         st.error("PUBLICATIONS_REPO недоступен как dataset repo. Проверь repo_id и доступ.\n\n" + pub_msg)
@@ -542,145 +504,122 @@ with st.sidebar:
 
     rev_ok, rev_msg = check_dataset_repo(REVIEWS_REPO, HF_TOKEN)
     if not rev_ok:
-        created, _ = maybe_create_reviews_repo(REVIEWS_REPO)
+        created, cmsg = maybe_create_reviews_repo(REVIEWS_REPO)
         if created:
             rev_ok2, rev_msg2 = check_dataset_repo(REVIEWS_REPO, HF_TOKEN)
             if not rev_ok2:
                 st.error("REVIEWS_REPO недоступен после create_repo.\n\n" + rev_msg2)
                 st.stop()
+            else:
+                st.success("REVIEWS_REPO создан/доступен.")
         else:
             st.error(
                 "REVIEWS_REPO недоступен (404/нет доступа).\n\n"
-                "Проверь:\n"
-                "1) REVIEWS_REPO = <owner>/<dataset_name> (именно dataset).\n"
-                "2) Репозиторий существует на Hub.\n"
-                "3) Для приватного repo нужен HF_TOKEN с доступом.\n\n"
+                "Что проверить:\n"
+                "1) В Space Variables: REVIEWS_REPO = <owner>/<dataset_name> (именно dataset).\n"
+                "2) Репозиторий реально существует на Hub.\n"
+                "3) Если repo приватный — в Secrets должен быть HF_TOKEN с правами write на этот dataset.\n"
+                "4) Если repo ещё не создан — включи ALLOW_CREATE_REVIEWS_REPO=1 (опционально) или создай вручную.\n\n"
                 + rev_msg
             )
             st.stop()
 
-    reviewer_default = os.environ.get("REVIEWER", "")
-    reviewer = st.text_input("Рецензент (имя/ник)", value=reviewer_default).strip() or "anonymous"
+# =========================
 
-    sort_mode = st.selectbox(
-        "Сортировка",
-        ["dir_score ↓", "delta ↓", "quality ↓", "год ↓", "cited_by ↓"],
-        index=0,
-    )
+# =========================
+# Load DIR registry + UI (offline-first)
+# =========================
+dirs = load_dir_registry(PUBLICATIONS_REPO, PUB_DIR_REGISTRY_PATH)
+dir_ids = [d.get("dir_id") for d in dirs if d.get("dir_id")]
+if not dir_ids:
+    st.error("В dir_registry.json не найдено ни одного dir_id.")
+    st.stop()
 
-    skip_reviewed = st.checkbox("Пропускать уже оценённые", value=True)
+dir_map = {d.get("dir_id"): d for d in dirs if d.get("dir_id")}
 
-    st.divider()
-    # сервисные кнопки
-    with st.expander("Сервис", expanded=False):
-        flush_now = st.button("⬆️ Синхронизировать pending сейчас", use_container_width=True)
-        clear_cache = st.button("🧹 Сбросить кэш (публикации/оценки)", use_container_width=True)
-        st.caption(f"BATCH_SIZE={BATCH_SIZE}")
+def _fmt_dir(did: str) -> str:
+    meta = dir_map.get(did) or {}
+    name = meta.get("dir_name") or "—"
+    return f"DIR-{str(dir_no(did)).zfill(2)} — {name}"
 
+st.title("Скоринг публикаций")
+
+# Выбор DIR — в основном интерфейсе (не в сайдбаре)
+selected_dir = st.selectbox("DIR", dir_ids, index=0, format_func=_fmt_dir)
+dir_meta = dir_map.get(selected_dir) or {}
 
 # =========================
-# Cache reset
+# Sidebar (минимум)
 # =========================
+with st.sidebar:
+    reviewer = get_reviewer()
+    st.caption(f"BATCH_SIZE={BATCH_SIZE} (настройка через переменную окружения)")
+    st.divider()
+    flush_now = st.button("⬆️ Синхронизировать pending сейчас", use_container_width=True)
+    clear_cache = st.button("🧹 Сбросить кэш", use_container_width=True)
 
-if "clear_cache" in locals() and clear_cache:
+if clear_cache:
     load_dir_registry.clear()
     load_candidates.clear()
-    list_review_files.clear()
-    load_reviews_index.clear()
-
+    if hasattr(list_review_files, "clear"):
+        list_review_files.clear()
+    if hasattr(load_reviewed_keys, "clear"):
+        load_reviewed_keys.clear()
+    if hasattr(load_review_index, "clear"):
+        load_review_index.clear()
     for k in [
-        "remote_dir",
-        "remote_keys",
-        "remote_by_src",
-        "remote_by_w",
+        "reviewed_remote",
+        "reviewed_remote_dir",
+        "review_index_remote",
+        "review_index_local",
         "reviewed_local_committed",
         "reviewed_local_pending",
-        "local_by_src",
-        "local_by_w",
         "batch",
     ]:
         if k in st.session_state:
             del st.session_state[k]
-
-    st.toast("Кэш очищен")
+    st.toast("Кэш очищен.")
     st.rerun()
 
-
 # =========================
-# Load DIR registry + main DIR select
+# DIR header
 # =========================
-
-dirs = load_dir_registry(PUBLICATIONS_REPO, PUB_DIR_REGISTRY_PATH)
-_dir_map = {d.get("dir_id"): d for d in dirs if d.get("dir_id")}
-_dir_ids = [d for d in _dir_map.keys()]
-if not _dir_ids:
-    st.error("В dir_registry.json не найдено ни одного dir_id")
-    st.stop()
-
-# top selector
-selected_dir = st.selectbox(
-    "DIR",
-    options=_dir_ids,
-    index=0,
-    format_func=lambda x: f"{dir_tag(x)} — {_dir_map.get(x, {}).get('dir_name', '—')}",
+defaults = (dir_meta.get("defaults") or {})
+year_from = defaults.get("year_from")
+year_to = defaults.get("year_to")
+
+terms = (dir_meta.get("terms") or {})
+anchor_str = join_terms(terms.get("anchor"))
+support_str = join_terms(terms.get("support"))
+noise_str = join_terms(terms.get("noise"))
+topics_str = topics_line(dir_meta.get("topics") or [])
+
+dir_desc = dir_meta.get("dir_description", "—")
+
+st.markdown(
+    f"""
+<div style="padding: 14px 16px; border: 1px solid rgba(49,51,63,0.2); border-radius: 12px; background: rgba(49,51,63,0.04);">
+  <div style="margin-top: 0px;">
+    <div style="font-size: 12px; font-weight: 700; text-transform: uppercase; opacity: 0.7;">Краткое описание</div>
+    <div style="margin-top: 4px; font-size: 14px; line-height: 1.35;">{dir_desc}</div>
+  </div>
+</div>
+""",
+    unsafe_allow_html=True,
 )
 
-dir_meta = _dir_map[selected_dir]
-canonical_dir = normalize_dir_id(selected_dir, pad2=False)
-
-
-# =========================
-# DIR header (card)
-# =========================
-
-def _get(d: Dict[str, Any], key: str, default: str = "—") -> str:
-    v = d.get(key)
-    return v if isinstance(v, str) and v.strip() else default
-
-st.markdown(f"### {dir_meta.get('dir_name', '—')}")
-
-# выделенный блок, чтобы отличался от основного интерфейса
-with st.container():
-    st.markdown(
-        """
-        <style>
-        .dir-card{border:1px solid rgba(255,255,255,.12); border-radius:14px; padding:14px 16px; background: rgba(255,255,255,.03);}
-        .dir-tag{font-size:12px; letter-spacing:.08em; opacity:.75; font-weight:700;}
-        .dir-desc-title{font-size:11px; letter-spacing:.08em; opacity:.75; font-weight:800; margin-top:10px;}
-        </style>
-        """,
-        unsafe_allow_html=True,
-    )
-    st.markdown(f"<div class='dir-card'><div class='dir-tag'>{dir_tag(selected_dir)}</div>", unsafe_allow_html=True)
-    st.markdown("<div class='dir-desc-title'>КРАТКОЕ ОПИСАНИЕ</div>", unsafe_allow_html=True)
-    st.write(_get(dir_meta, "dir_description"))
-
-    defaults = dir_meta.get("defaults") or {}
-    year_from = defaults.get("year_from")
-    year_to = defaults.get("year_to")
-
-    terms = dir_meta.get("terms") or {}
-    anchor_str = join_terms(terms.get("anchor"))
-    support_str = join_terms(terms.get("support"))
-    noise_str = join_terms(terms.get("noise"))
-    topics_str = topics_line(dir_meta.get("topics") or [])
-
-    with st.expander("Детали DIR", expanded=True):
-        st.markdown(f"**Временной интервал:** {year_from} – {year_to}")
-        st.markdown(f"**Якоря:** {anchor_str}")
-        st.markdown(f"**Поддержка:** {support_str}")
-        st.markdown(f"**Шум:** {noise_str}")
-        st.markdown(f"**Topics поиска:** {topics_str}")
-
-    st.markdown("</div>", unsafe_allow_html=True)
+with st.expander("Детали DIR", expanded=True):
+    st.markdown(f"**Временной интервал:** {year_from} – {year_to}")
+    st.markdown(f"**Якоря:** {anchor_str}")
+    st.markdown(f"**Поддержка:** {support_str}")
+    st.markdown(f"**Шум:** {noise_str}")
+    st.markdown(f"**Topics поиска:** {topics_str}")
 
 st.divider()
 
-
 # =========================
-# Load candidates
+# Load candidates + fixed sorting (A: dir_score ↓)
 # =========================
-
 try:
     df = load_candidates(PUBLICATIONS_REPO, selected_dir, PUB_CANDIDATES_PREFIX)
 except Exception as e:
@@ -688,53 +627,75 @@ except Exception as e:
     st.stop()
 
 if df.empty:
-    st.warning(f"Пустой список кандидатов для {selected_dir}")
+    st.warning(f"Пустой список кандидатов для {selected_dir}.")
     st.stop()
 
-# sort
-if sort_mode == "dir_score ↓" and "dir_score" in df.columns:
-    df = df.sort_values(["dir_score", "quality_weight", "match_score"], ascending=[False, False, False])
-elif sort_mode == "delta ↓" and "match_score" in df.columns:
-    df = df.sort_values(["match_score", "dir_score", "quality_weight"], ascending=[False, False, False])
-elif sort_mode == "quality ↓" and "quality_weight" in df.columns:
-    df = df.sort_values(["quality_weight", "dir_score"], ascending=[False, False])
-elif sort_mode == "год ↓" and "year" in df.columns:
-    df = df.sort_values(["year", "dir_score"], ascending=[False, False])
-elif sort_mode == "cited_by ↓" and "cited_by" in df.columns:
-    df = df.sort_values(["cited_by", "dir_score"], ascending=[False, False])
+# Fixed order: dir_score ↓ (stable ties)
+sort_cols: List[str] = []
+sort_asc: List[bool] = []
+if "dir_score" in df.columns:
+    sort_cols.append("dir_score"); sort_asc.append(False)
+if "quality_weight" in df.columns:
+    sort_cols.append("quality_weight"); sort_asc.append(False)
+if "match_score" in df.columns:
+    sort_cols.append("match_score"); sort_asc.append(False)
+if "year" in df.columns:
+    sort_cols.append("year"); sort_asc.append(False)
+if sort_cols:
+    df = df.sort_values(sort_cols, ascending=sort_asc)
 
 df = df.reset_index(drop=True)
-
-total = int(len(df))
-
+total = len(df)
+if total == 0:
+    st.warning("Пустой список кандидатов.")
+    st.stop()
 
 # =========================
-# State + remote reviews index (silent)
+# State: batch + local/remote indexes
 # =========================
+def ensure_state():
+    if "batch" not in st.session_state:
+        st.session_state["batch"] = []
+    if "reviewed_local_committed" not in st.session_state:
+        st.session_state["reviewed_local_committed"] = set()
+    if "reviewed_local_pending" not in st.session_state:
+        st.session_state["reviewed_local_pending"] = set()
+    if "reviewed_remote" not in st.session_state:
+        st.session_state["reviewed_remote"] = set()
+    if "reviewed_remote_dir" not in st.session_state:
+        st.session_state["reviewed_remote_dir"] = None
+    if "review_index_remote" not in st.session_state:
+        st.session_state["review_index_remote"] = {}
+    if "review_index_local" not in st.session_state:
+        st.session_state["review_index_local"] = {}
 
 ensure_state()
 
-if st.session_state.get("remote_dir") != canonical_dir:
-    # Тихо подгружаем индекс оценок, чтобы:
-    # - корректно пропускать уже оценённые
-    # - предзаполнять score/comment при навигации
-    r_keys, r_by_src, r_by_w = load_reviews_index(REVIEWS_REPO, selected_dir, REVIEWS_LOG_PREFIX)
-    st.session_state["remote_dir"] = canonical_dir
-    st.session_state["remote_keys"] = set(r_keys)
-    st.session_state["remote_by_src"] = dict(r_by_src)
-    st.session_state["remote_by_w"] = dict(r_by_w)
-
-reviewed_committed = set(st.session_state.get("remote_keys", set())) | set(st.session_state.get("reviewed_local_committed", set()))
-reviewed_pending = set(st.session_state.get("reviewed_local_pending", set()))
-reviewed_effective = reviewed_committed | reviewed_pending
+def row_keys_all(r: Dict[str, Any]) -> Set[str]:
+    keys = set()
+    sid = r.get("source_id")
+    if isinstance(sid, str) and sid.strip():
+        keys.add(f"SRC::{sid.strip()}")
+    wid = r.get("work_id")
+    if isinstance(wid, str) and wid.strip():
+        keys.add(f"W::{wid.strip()}")
+    return keys
 
+canonical_dir = normalize_dir_id(selected_dir, pad2=False)
 
-def is_reviewed_effective(r: Dict[str, Any]) -> bool:
-    keys = row_keys_all(r)
-    return bool(keys and any(k in reviewed_effective for k in keys))
+# Загрузка сохранённых оценок (тихо; remote-статусы не показываем)
+need_reload = (st.session_state["reviewed_remote_dir"] != canonical_dir)
+if need_reload:
+    # Без спиннера и без UI-вывода: просто подготавливаем пропуск/предзаполнение
+    st.session_state["reviewed_remote"] = load_reviewed_keys(REVIEWS_REPO, selected_dir, REVIEWS_LOG_PREFIX)
+    st.session_state["review_index_remote"] = load_review_index(REVIEWS_REPO, selected_dir, REVIEWS_LOG_PREFIX)
+    st.session_state["reviewed_remote_dir"] = canonical_dir
 
+reviewed_committed = set(st.session_state["reviewed_remote"]) | set(st.session_state["reviewed_local_committed"])
+reviewed_pending = set(st.session_state["reviewed_local_pending"])
+reviewed_effective = reviewed_committed | reviewed_pending
 
-def status_icon(r: Dict[str, Any]) -> str:
+def status_of_row(r: Dict[str, Any]) -> str:
     keys = row_keys_all(r)
     if keys and any(k in reviewed_committed for k in keys):
         return "✅"
@@ -742,18 +703,57 @@ def status_icon(r: Dict[str, Any]) -> str:
         return "🕓"
     return "🆕"
 
+def is_reviewed_effective(r: Dict[str, Any]) -> bool:
+    keys = row_keys_all(r)
+    return bool(keys and any(k in reviewed_effective for k in keys))
+
+def last_review_for_row(r: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """Берём последнюю известную оценку (pending/local -> remote)."""
+    keys = list(row_keys_all(r))
+    if not keys:
+        return None
+
+    best = None
+    best_ts = ""
+    # local index first
+    for k in keys:
+        obj = st.session_state["review_index_local"].get(k)
+        if isinstance(obj, dict):
+            t = str(obj.get("ts_utc") or obj.get("ts") or "")
+            if t > best_ts:
+                best_ts = t
+                best = obj
+    # remote index fallback
+    for k in keys:
+        obj = st.session_state["review_index_remote"].get(k)
+        if isinstance(obj, dict):
+            t = str(obj.get("ts_utc") or obj.get("ts") or "")
+            if t > best_ts:
+                best_ts = t
+                best = obj
+    return best
+
+# =========================
+# Sidebar: statuses (без remote)
+# =========================
+def split_key_set(keys: Set[str]) -> Tuple[Set[str], Set[str]]:
+    src_ids: Set[str] = set()
+    w_ids: Set[str] = set()
+    for k in keys:
+        if isinstance(k, str) and k.startswith("SRC::"):
+            src_ids.add(k[5:])
+        elif isinstance(k, str) and k.startswith("W::"):
+            w_ids.add(k[3:])
+    return src_ids, w_ids
+
+comm_src_ids, comm_w_ids = split_key_set(reviewed_committed)
+pend_src_ids, pend_w_ids = split_key_set(reviewed_pending)
 
-# counts for sidebar (без слова remote)
 src_series = df["source_id"].fillna("") if "source_id" in df.columns else pd.Series([""] * len(df))
 wid_series = df["work_id"].fillna("") if "work_id" in df.columns else pd.Series([""] * len(df))
 
-comm_src = {k[5:] for k in reviewed_committed if isinstance(k, str) and k.startswith("SRC::")}
-comm_w = {k[3:] for k in reviewed_committed if isinstance(k, str) and k.startswith("W::")}
-pend_src = {k[5:] for k in reviewed_pending if isinstance(k, str) and k.startswith("SRC::")}
-pend_w = {k[3:] for k in reviewed_pending if isinstance(k, str) and k.startswith("W::")}
-
-mask_committed = src_series.astype(str).isin(comm_src) | wid_series.astype(str).isin(comm_w)
-mask_pending = src_series.astype(str).isin(pend_src) | wid_series.astype(str).isin(pend_w)
+mask_committed = src_series.astype(str).isin(comm_src_ids) | wid_series.astype(str).isin(comm_w_ids)
+mask_pending = src_series.astype(str).isin(pend_src_ids) | wid_series.astype(str).isin(pend_w_ids)
 mask_reviewed = mask_committed | mask_pending
 
 committed_pub_count = int(mask_committed.sum())
@@ -761,9 +761,9 @@ pending_pub_count = int(mask_pending.sum())
 unreviewed_pub_count = int((~mask_reviewed).sum())
 
 with st.sidebar:
-    st.markdown("### Статусы")
-    st.write(f"✅ сохранено: {committed_pub_count}")
-    st.write(f"🕓 pending: {pending_pub_count}")
+    with st.expander("Статусы", expanded=False):
+        st.write(f"✅ сохранено: {committed_pub_count} публикаций")
+        st.write(f"🕓 pending: {pending_pub_count} публикаций")
 
     if st.session_state.get("batch"):
         pending_jsonl = "".join(json.dumps(x, ensure_ascii=False) + "\n" for x in st.session_state["batch"])
@@ -775,22 +775,19 @@ with st.sidebar:
             use_container_width=True,
         )
 
-
 # =========================
-# Commit helpers
+# Commit helper
 # =========================
-
 def commit_batch() -> Tuple[bool, str]:
     batch = st.session_state.get("batch") or []
     if not batch:
         return False, "batch_empty"
-
     try:
         push_batch_to_reviews_repo(REVIEWS_REPO, selected_dir, REVIEWS_LOG_PREFIX, batch)
     except Exception as e:
         return False, str(e)
 
-    # pending -> committed
+    # Update local sets: pending -> committed (keys)
     for obj in batch:
         sid = obj.get("source_id")
         wid = obj.get("work_id")
@@ -806,92 +803,67 @@ def commit_batch() -> Tuple[bool, str]:
     st.session_state["batch"] = []
     return True, "ok"
 
-
-if "flush_now" in locals() and flush_now and st.session_state.get("batch"):
+# manual flush
+if flush_now and st.session_state.get("batch"):
     with st.spinner("Синхронизирую pending батч…"):
         ok, msg = commit_batch()
     if ok:
-        st.success("Pending батч синхронизирован")
+        st.success("Pending батч синхронизирован.")
         st.rerun()
     else:
         st.error(f"Не удалось синхронизировать: {msg}")
 
+# recompute after possible commit
+reviewed_committed = set(st.session_state["reviewed_remote"]) | set(st.session_state["reviewed_local_committed"])
+reviewed_pending = set(st.session_state["reviewed_local_pending"])
+reviewed_effective = reviewed_committed | reviewed_pending
 
 # =========================
-# Navigation state
+# Navigation window + layout
 # =========================
-
 idx_key = f"idx_{canonical_dir}"
 if idx_key not in st.session_state:
     st.session_state[idx_key] = 0
 
+current_idx = int(st.session_state[idx_key])
+current_idx = max(0, min(total - 1, current_idx))
+st.session_state[idx_key] = current_idx
+
+window_size = int(PAGE_WINDOW_SIZE) if PAGE_WINDOW_SIZE else 50
+window_start = int(current_idx // window_size) * int(window_size)
+window_end = min(window_start + int(window_size), total)
+page_indices = list(range(window_start, window_end))
 
-def first_unreviewed_from(i0: int) -> int:
-    i = max(0, int(i0))
+def fmt_idx(i: int) -> str:
+    r = df.iloc[i].to_dict()
+    ico = status_of_row(r)
+    year_val = safe_int(r.get("year"))
+    year = str(year_val) if year_val is not None else "—"
+    title = (str(r.get("title")) if r.get("title") is not None else "—")
+    title_short = title if len(title) <= 80 else title[:77] + "…"
+    return f"{ico} {i+1:03d} | {year} | {title_short}"
+
+def next_unreviewed(from_idx: int) -> int:
+    i = max(0, from_idx)
     while i < total:
-        if not skip_reviewed:
-            return i
         r = df.iloc[i].to_dict()
         if is_reviewed_effective(r):
             i += 1
             continue
         return i
-    return max(0, total - 1)
-
-
-# при первом входе в DIR — позиционируемся на первом неоценённом
-if st.session_state[idx_key] == 0 and skip_reviewed:
-    st.session_state[idx_key] = first_unreviewed_from(0)
-
-current_idx = int(st.session_state[idx_key])
-current_idx = max(0, min(current_idx, total - 1))
-
-
-def next_idx(i: int) -> int:
-    j = min(total - 1, int(i) + 1)
-    return first_unreviewed_from(j) if skip_reviewed else j
-
+    return total - 1
 
-def prev_idx(i: int) -> int:
-    # назад НЕ пропускаем оценённые: эксперт часто хочет вернуться
-    return max(0, int(i) - 1)
-
-
-# =========================
-# Layout: list always visible + card
-# =========================
+# main 2-column layout: left=list+scoring, right=publication
+col_left, col_right = st.columns([1, 2], gap="large")
 
-col_list, col_card = st.columns([1.35, 2.65], gap="large")
-
-# current row
-row = df.iloc[current_idx].to_dict()
-
-# window indices around current
-half = max(1, PAGE_WINDOW_SIZE // 2)
-window_start = max(0, current_idx - half)
-window_end = min(total, window_start + PAGE_WINDOW_SIZE)
-window_start = max(0, window_end - PAGE_WINDOW_SIZE)
-window_indices = list(range(window_start, window_end))
-
-
-def fmt_idx(i: int) -> str:
-    r = df.iloc[i].to_dict()
-    ico = status_icon(r)
-    year = safe_int(r.get("year"))
-    year_s = str(year) if year is not None else "—"
-    title = str(r.get("title") or "—")
-    title_short = title if len(title) <= 70 else title[:67] + "…"
-    return f"{ico} {i+1:03d} | {year_s} | {title_short}"
-
-
-with col_list:
+with col_left:
     st.markdown("### Список публикаций")
-    st.caption("Публикации в текущем окне")
+    st.caption(f"Окно: {window_start+1}–{window_end} из {total} • Неоценено: {unreviewed_pub_count}")
 
     sel = st.selectbox(
-        "",
-        options=window_indices,
-        index=window_indices.index(current_idx) if current_idx in window_indices else 0,
+        "Публикации в текущем окне",
+        options=page_indices,
+        index=page_indices.index(current_idx) if current_idx in page_indices else 0,
         format_func=fmt_idx,
         label_visibility="collapsed",
     )
@@ -900,156 +872,70 @@ with col_list:
         st.session_state[idx_key] = int(sel)
         st.rerun()
 
-    nav1, nav2, nav3 = st.columns(3)
-    with nav1:
-        if st.button("⬅️ Назад", use_container_width=True):
-            st.session_state[idx_key] = prev_idx(current_idx)
-            st.rerun()
-    with nav2:
-        if st.button("➡️ Далее", use_container_width=True):
-            st.session_state[idx_key] = next_idx(current_idx)
-            st.rerun()
-    with nav3:
-        st.write(f"**Осталось:** {unreviewed_pub_count}")
-
-    st.caption(f"Всего: {total} · Показаны: {window_start+1}–{window_end}")
-
-
-# =========================
-# Publication card + scoring
-# =========================
-
-row = df.iloc[int(st.session_state[idx_key])].to_dict()
-
-saved = get_saved_review_for_row(row) or {}
-saved_score = safe_int(saved.get("score")) if isinstance(saved, dict) else None
-saved_comment = saved.get("comment") if isinstance(saved, dict) else None
-
-default_score = int(saved_score) if saved_score is not None else 0
-default_comment = str(saved_comment) if isinstance(saved_comment, str) else ""
-
-score_key = f"score_{canonical_dir}_{int(st.session_state[idx_key])}"
-comment_key = f"com_{canonical_dir}_{int(st.session_state[idx_key])}"
-
-# предзаполняем при первом появлении виджета
-if score_key not in st.session_state:
-    st.session_state[score_key] = default_score
-if comment_key not in st.session_state:
-    st.session_state[comment_key] = default_comment
-
-
-authors, abstract = get_authors_and_abstract(row)
-
-y = safe_int(row.get("year"))
-cites = safe_int(row.get("cited_by"))
-dir_score = safe_float(row.get("dir_score"))
-delta = safe_float(row.get("match_score"))
-qw = safe_float(row.get("quality_weight"))
-
-work_id = row.get("work_id") if isinstance(row.get("work_id"), str) else None
-source_id = row.get("source_id") if isinstance(row.get("source_id"), str) else None
-
-pdf_url = row.get("pdf_url")
-pl_url = row.get("primary_location_url")
-doi_link = doi_url(row.get("doi"))
-
-# open_access (если есть)
-oa = row.get("open_access") if isinstance(row.get("open_access"), dict) else {}
-oa_is = oa.get("is_oa") if isinstance(oa, dict) else None
-oa_status = oa.get("oa_status") if isinstance(oa, dict) else None
-oa_url = oa.get("oa_url") if isinstance(oa, dict) else None
-
-keys = row_keys_all(row)
-committed = bool(keys and any(k in reviewed_committed for k in keys))
-pending = bool(keys and any(k in reviewed_pending for k in keys))
-status_str = "✅ оценено" if committed else ("🕓 pending" if pending else "🆕 не оценено")
-
-has_abs = (isinstance(abstract, str) and abstract.strip() and abstract.strip() != "—")
-has_pdf = (isinstance(pdf_url, str) and pdf_url.strip())
-has_pl = (isinstance(pl_url, str) and pl_url.strip())
-has_doi = bool(doi_link)
-
-badges = [
-    f"Abstract {'✅' if has_abs else '❌'}",
-    f"PDF {'✅' if has_pdf else '❌'}",
-    f"URL {'✅' if has_pl else '❌'}",
-    f"DOI {'✅' if has_doi else '❌'}",
-]
-if oa_is is not None:
-    badges.append(f"OA {'✅' if oa_is else '❌'}{(' (' + str(oa_status) + ')') if oa_status else ''}")
+    # актуальная строка
+    current_idx = int(st.session_state[idx_key])
+    row = df.iloc[current_idx].to_dict()
+
+    # предзаполнение score/comment: если есть оценка -> она, иначе 0/пусто
+    existing = last_review_for_row(row) or {}
+    existing_score = safe_int(existing.get("score"))
+    if existing_score is None:
+        existing_score = 0
+    existing_comment = str(existing.get("comment") or "")
+
+    score_key = f"score_{canonical_dir}_{current_idx}"
+    comment_key = f"com_{canonical_dir}_{current_idx}"
+
+    if score_key not in st.session_state:
+        st.session_state[score_key] = int(existing_score)
+    # защита от старых/некорректных значений
+    if int(st.session_state[score_key]) not in (-2, -1, 0, 1, 2):
+        st.session_state[score_key] = 0
+
+    if comment_key not in st.session_state:
+        st.session_state[comment_key] = existing_comment
+
+    st.markdown("### Оценка")
+
+    label_map = {
+        -2: "точно нет",
+        -1: "скорее нет",
+        0: "не знаю",
+        1: "скорее да",
+        2: "точно да",
+    }
+
+    score = st.radio(
+        "Оценка",
+        options=[-2, -1, 0, 1, 2],
+        format_func=lambda v: f"{v:+d} — {label_map.get(v, '')}".replace("+0", "0"),
+        index=[-2, -1, 0, 1, 2].index(int(st.session_state[score_key])),
+        key=score_key,
+    )
 
+    comment = st.text_area("Комментарий", height=140, key=comment_key)
 
-with col_card:
-    info_col, score_col = st.columns([2.2, 1.1], gap="large")
+    b1, b2, b3 = st.columns([1, 2, 1])
 
-    with info_col:
-        st.markdown(f"### {row.get('title') or '—'}")
+    with b1:
+        if st.button("⬅️ Назад", use_container_width=True):
+            st.session_state[idx_key] = max(0, current_idx - 1)
+            st.rerun()
 
-        if source_id:
-            st.markdown(f"**Source ID:** `{source_id}`")
-        if work_id:
-            st.markdown(f"**Work ID:** `{work_id}`")
+    with b2:
+        if st.button("✅ Сохрани��ь и далее", use_container_width=True):
+            # собираем мета для review
+            authors, abstract = get_authors_and_abstract(row)
 
-        st.markdown("**Авторы:**")
-        st.write(authors)
+            y = safe_int(row.get("year"))
+            cites = safe_int(row.get("cited_by"))
+            dir_score = safe_float(row.get("dir_score"))
+            delta = safe_float(row.get("match_score"))
+            qw = safe_float(row.get("quality_weight"))
 
-        y_s = str(y) if y is not None else "—"
-        c_s = str(cites) if cites is not None else "—"
-        ds_s = f"{dir_score:.3f}" if dir_score is not None else "—"
-        dlt_s = f"{delta:.4f}" if delta is not None else "—"
-        qw_s = f"{qw:.3f}" if qw is not None else "—"
-        st.markdown(f"**Год:** {y_s} | **Цитаты:** {c_s} | **dir_score:** {ds_s} | **delta:** {dlt_s} | **quality:** {qw_s}")
-        st.caption(" | ".join(badges))
-
-        with st.expander("Детали авторанжирования (опционально)", expanded=False):
-            comp = row.get("dir_native_components") or {}
-            if isinstance(comp, dict) and comp:
-                tr = safe_float(comp.get("trace"))
-                tp = safe_float(comp.get("topic"))
-                tx = safe_float(comp.get("text"))
-                nz = safe_float(comp.get("noise"))
-                sc = safe_float(comp.get("score"))
-                dl = safe_float(comp.get("delta"))
-                st.markdown(
-                    f"**Компоненты (native DIR):** "
-                    f"trace={tr if tr is not None else '—'} | "
-                    f"topic={tp if tp is not None else '—'} | "
-                    f"text={tx if tx is not None else '—'} | "
-                    f"noise={nz if nz is not None else '—'} | "
-                    f"score={sc if sc is not None else '—'} | "
-                    f"delta={dl if dl is not None else '—'}"
-                )
-            expl = row.get("dir_score_explanation")
-            if expl:
-                st.markdown("**dir_score_explanation:**")
-                st.write(expl)
-
-        links = []
-        if work_id:
-            links.append(f"[OpenAlex]({work_id})")
-        if doi_link:
-            links.append(f"[DOI]({doi_link})")
-        if isinstance(pdf_url, str) and pdf_url.strip():
-            links.append(f"[PDF]({pdf_url.strip()})")
-        if isinstance(pl_url, str) and pl_url.strip():
-            links.append(f"[Primary URL]({pl_url.strip()})")
-        if isinstance(oa_url, str) and oa_url.strip():
-            links.append(f"[OA URL]({oa_url.strip()})")
-        st.markdown("**Ссылки:** " + (" | ".join(links) if links else "—"))
-
-        st.markdown("**Аннотация:**")
-        st.write(abstract)
-
-        st.markdown(f"**Статус:** {status_str}")
-        st.markdown(f"**Кандидат {int(st.session_state[idx_key])+1}/{total}**")
-
-    with score_col:
-        st.markdown("### Оценка")
-
-        score_val = st.slider("Баллы (-5..+5)", -5, 5, int(st.session_state[score_key]), key=score_key)
-        comment_val = st.text_area("Комментарий", height=160, key=comment_key)
+            work_id = row.get("work_id") if isinstance(row.get("work_id"), str) else None
+            source_id = row.get("source_id") if isinstance(row.get("source_id"), str) else None
 
-        if st.button("✅ Сохранить и далее", use_container_width=True):
             review = {
                 "ts_utc": dt.datetime.utcnow().isoformat(timespec="seconds") + "Z",
                 "dir_id": selected_dir,
@@ -1067,44 +953,149 @@ with col_card:
                     "delta": delta,
                     "quality_weight": qw,
                     "components": row.get("dir_native_components") or {},
-                    "rank": int(st.session_state[idx_key]),
+                    "rank": int(current_idx),
                 },
-                "score": int(score_val),
-                "comment": str(comment_val or ""),
+                "score": int(score),
+                "comment": comment,
                 "reviewer": reviewer,
             }
 
-            # add to batch
             st.session_state["batch"].append(review)
 
-            # update local maps (для предзаполнения)
-            if source_id:
-                st.session_state["local_by_src"][source_id] = review
-            if work_id:
-                st.session_state["local_by_w"][work_id] = review
-
-            # pending keys (оба)
-            if source_id:
-                st.session_state["reviewed_local_pending"].add(f"SRC::{source_id.strip()}")
-            if work_id:
-                st.session_state["reviewed_local_pending"].add(f"W::{work_id.strip()}")
+            # pending keys + local index for prefill
+            for k in row_keys_all(row):
+                st.session_state["reviewed_local_pending"].add(k)
+                st.session_state["review_index_local"][k] = review
 
+            # auto flush by BATCH_SIZE
             flushed = False
             if len(st.session_state["batch"]) >= BATCH_SIZE:
                 with st.spinner("Сохраняю в reviews repo…"):
                     ok, msg = commit_batch()
                 if ok:
                     flushed = True
-                    st.success("Сохранено")
+                    st.success("Сохранено.")
                 else:
                     st.error(f"Не удалось записать в reviews repo: {msg}")
-                    st.warning("Оценка сохранена локально как pending. Скачайте pending reviews или синхронизируйте позже.")
+                    st.warning("Оценка сохранена локально как pending. Скачайте pending reviews или повторите синхронизацию.")
 
-            if not flushed:
-                st.info(f"Добавлено в pending: {len(st.session_state['batch'])}/{BATCH_SIZE}")
+            # переход: следующая НЕоценённая (без тумблера)
+            nxt = next_unreviewed(current_idx + 1)
+            st.session_state[idx_key] = nxt
+            st.rerun()
 
-            # move next
-            st.session_state[idx_key] = next_idx(int(st.session_state[idx_key]))
+    with b3:
+        if st.button("➡️ Далее", use_container_width=True):
+            st.session_state[idx_key] = min(total - 1, current_idx + 1)
             st.rerun()
 
-        st.caption(f"Pending (несинхронизировано): {len(st.session_state.get('batch') or [])}")
+    st.caption(f"Pending: {len(st.session_state.get('batch') or [])}")
+
+with col_right:
+    # карточка публикации занимает максимум пространства справа
+    row = df.iloc[int(st.session_state[idx_key])].to_dict()
+
+    title = row.get("title") or "—"
+    authors, abstract = get_authors_and_abstract(row)
+
+    y = safe_int(row.get("year"))
+    cites = safe_int(row.get("cited_by"))
+    dir_score = safe_float(row.get("dir_score"))
+    delta = safe_float(row.get("match_score"))
+    qw = safe_float(row.get("quality_weight"))
+
+    work_id = row.get("work_id") if isinstance(row.get("work_id"), str) else None
+    source_id = row.get("source_id") if isinstance(row.get("source_id"), str) else None
+
+    doi_link = doi_url(row.get("doi"))
+    pdf_url = row.get("pdf_url")
+    pl_url = row.get("primary_location_url")
+
+    oa = row.get("open_access") if isinstance(row.get("open_access"), dict) else {}
+    oa_is = oa.get("is_oa") if isinstance(oa, dict) else None
+    oa_status = oa.get("oa_status") if isinstance(oa, dict) else None
+    oa_url = oa.get("oa_url") if isinstance(oa, dict) else None
+
+    keys = row_keys_all(row)
+    committed = bool(keys and any(k in reviewed_committed for k in keys))
+    pending = bool(keys and any(k in reviewed_pending for k in keys))
+    status_str = "✅ оценено" if committed else ("🕓 pending" if pending else "🆕 не оценено")
+
+    # badges
+    has_abs = (isinstance(abstract, str) and abstract.strip() and abstract.strip() != "—")
+    has_pdf = (isinstance(pdf_url, str) and isinstance(pdf_url, str) and pdf_url.strip())
+    has_pl = (isinstance(pl_url, str) and pl_url.strip())
+    has_doi = bool(doi_link)
+    badges = [
+        f"Abstract {'✅' if has_abs else '❌'}",
+        f"PDF {'✅' if has_pdf else '❌'}",
+        f"URL {'✅' if has_pl else '❌'}",
+        f"DOI {'✅' if has_doi else '❌'}",
+    ]
+    if oa_is is not None:
+        badges.append(f"OA {'✅' if oa_is else '❌'}{(' (' + str(oa_status) + ')') if oa_status else ''}")
+
+    st.markdown(f"## {title}")
+    st.caption(status_str + " • " + " | ".join(badges))
+
+    id_lines = []
+    if source_id:
+        id_lines.append(f"**Source ID:** `{source_id}`")
+    if work_id:
+        id_lines.append(f"**Work ID:** `{work_id}`")
+    if id_lines:
+        st.markdown(" • ".join(id_lines))
+
+    # Метрики
+    y_s = str(y) if y is not None else "—"
+    c_s = str(cites) if cites is not None else "—"
+    ds_s = f"{dir_score:.3f}" if dir_score is not None else "—"
+    dlt_s = f"{delta:.4f}" if delta is not None else "—"
+    qw_s = f"{qw:.3f}" if qw is not None else "—"
+    st.markdown(f"**Год:** {y_s}  |  **Цитаты:** {c_s}  |  **dir_score:** {ds_s}  |  **delta:** {dlt_s}  |  **quality:** {qw_s}")
+
+    # Авторы
+    if authors and authors != "—":
+        st.markdown("**Авторы:**")
+        st.write(authors)
+    else:
+        st.caption("Авторы: — (в исходных DIR*.jsonl авторы не предоставляются)")
+
+    # Ссылки
+    links = []
+    if work_id:
+        links.append(f"[OpenAlex]({work_id})")
+    if doi_link:
+        links.append(f"[DOI]({doi_link})")
+    if isinstance(pdf_url, str) and pdf_url.strip():
+        links.append(f"[PDF]({pdf_url.strip()})")
+    if isinstance(pl_url, str) and pl_url.strip():
+        links.append(f"[Primary URL]({pl_url.strip()})")
+    if isinstance(oa_url, str) and oa_url.strip():
+        links.append(f"[OA URL]({oa_url.strip()})")
+    st.markdown("**Ссылки:** " + (" | ".join(links) if links else "—"))
+
+    # Аннотация
+    st.markdown("### Аннотация")
+    st.write(abstract if abstract else "—")
+
+    # Доп. детали автооценки (по желанию)
+    with st.expander("Детали автооценки", expanded=True):
+        comp = row.get("dir_native_components") or {}
+        if isinstance(comp, dict) and comp:
+            tr = comp.get("trace"); tp = comp.get("topic"); tx = comp.get("text"); nz = comp.get("noise")
+            sc = comp.get("score"); dl = comp.get("delta")
+            st.markdown(
+                f"**Компоненты (native DIR):** "
+                f"trace={tr if tr is not None else '—'} | "
+                f"topic={tp if tp is not None else '—'} | "
+                f"text={tx if tx is not None else '—'} | "
+                f"noise={nz if nz is not None else '—'} | "
+                f"score={sc if sc is not None else '—'} | "
+                f"delta={dl if dl is not None else '—'}"
+            )
+        expl = row.get("dir_score_explanation")
+        if expl:
+            st.markdown("**dir_score_explanation:**")
+            st.write(expl)
+