local-triage 0.0.0-stage → 0.10.0-dev.32

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (223) hide show
  1. package/LICENSE +21 -0
  2. package/README.md +90 -2
  3. package/THIRD-PARTY-NOTICES.md +48 -0
  4. package/app/__init__.py +3 -0
  5. package/app/affiliation.py +137 -0
  6. package/app/ask.py +300 -0
  7. package/app/build_info.py +98 -0
  8. package/app/capec.py +168 -0
  9. package/app/capec_view.py +27 -0
  10. package/app/codecmp.py +59 -0
  11. package/app/config.py +411 -0
  12. package/app/context.py +1451 -0
  13. package/app/cvss.py +357 -0
  14. package/app/db.py +6234 -0
  15. package/app/defect.py +670 -0
  16. package/app/defect_check.py +323 -0
  17. package/app/defect_drafts.py +612 -0
  18. package/app/defect_dto.py +149 -0
  19. package/app/defect_fields.py +248 -0
  20. package/app/defect_form.py +124 -0
  21. package/app/defect_links.py +107 -0
  22. package/app/defect_local_text.py +103 -0
  23. package/app/defect_references.py +164 -0
  24. package/app/defect_where.py +147 -0
  25. package/app/ecosystem.py +51 -0
  26. package/app/executors.py +660 -0
  27. package/app/feeds.py +1231 -0
  28. package/app/guard.py +164 -0
  29. package/app/hub_block_builder.py +200 -0
  30. package/app/hub_block_version.py +220 -0
  31. package/app/hub_defects.py +4469 -0
  32. package/app/hub_effects.py +421 -0
  33. package/app/hub_entity_versions.py +108 -0
  34. package/app/hub_import.py +2054 -0
  35. package/app/hub_onboarding.py +114 -0
  36. package/app/hub_ops.py +330 -0
  37. package/app/hub_pull.py +1195 -0
  38. package/app/hub_state.py +255 -0
  39. package/app/hub_status.py +237 -0
  40. package/app/hub_sync.py +619 -0
  41. package/app/hub_sync_api.py +241 -0
  42. package/app/hub_sync_compare.py +1054 -0
  43. package/app/hub_sync_contract.py +75 -0
  44. package/app/hub_template_model.py +74 -0
  45. package/app/hub_text_scale.py +159 -0
  46. package/app/journal.py +250 -0
  47. package/app/llm.py +850 -0
  48. package/app/llm_chat.py +596 -0
  49. package/app/llm_http.py +319 -0
  50. package/app/llm_messages.py +401 -0
  51. package/app/llm_net.py +764 -0
  52. package/app/llm_ollama.py +571 -0
  53. package/app/lockfile.py +505 -0
  54. package/app/logsafe.py +54 -0
  55. package/app/main.py +367 -0
  56. package/app/mask_display.py +132 -0
  57. package/app/masking.py +814 -0
  58. package/app/metrics.py +194 -0
  59. package/app/model_traffic.py +519 -0
  60. package/app/models.py +483 -0
  61. package/app/navigation.py +121 -0
  62. package/app/osv.py +279 -0
  63. package/app/package_identity.py +189 -0
  64. package/app/package_transition.py +824 -0
  65. package/app/profile_gate.py +71 -0
  66. package/app/prompts.py +1108 -0
  67. package/app/provider_keys.py +189 -0
  68. package/app/providers.py +511 -0
  69. package/app/routes/__init__.py +10 -0
  70. package/app/routes/api.py +153 -0
  71. package/app/routes/capec.py +186 -0
  72. package/app/routes/common.py +407 -0
  73. package/app/routes/components.py +1499 -0
  74. package/app/routes/cwe.py +168 -0
  75. package/app/routes/decision_selected.py +153 -0
  76. package/app/routes/defect_add.py +223 -0
  77. package/app/routes/defect_card_routes.py +363 -0
  78. package/app/routes/defect_selected.py +342 -0
  79. package/app/routes/feeds.py +155 -0
  80. package/app/routes/findings.py +2736 -0
  81. package/app/routes/hub.py +402 -0
  82. package/app/routes/hub_bulk.py +288 -0
  83. package/app/routes/hub_defect_routes.py +1945 -0
  84. package/app/routes/hub_status_routes.py +1132 -0
  85. package/app/routes/hub_sync_routes.py +463 -0
  86. package/app/routes/journal.py +132 -0
  87. package/app/routes/projects.py +1601 -0
  88. package/app/routes/providers.py +336 -0
  89. package/app/routes/references.py +26 -0
  90. package/app/routes/runs.py +219 -0
  91. package/app/routes/sca.py +2722 -0
  92. package/app/routes/settings.py +163 -0
  93. package/app/run_errors.py +151 -0
  94. package/app/sca.py +1662 -0
  95. package/app/sca_contract.py +1289 -0
  96. package/app/sca_research.py +1089 -0
  97. package/app/sca_research_net.py +1007 -0
  98. package/app/sca_text.py +965 -0
  99. package/app/serve.py +70 -0
  100. package/app/settings_store.py +262 -0
  101. package/app/static/app.css +2802 -0
  102. package/app/static/app.js +3772 -0
  103. package/app/static/capec-license.txt +9 -0
  104. package/app/static/favicon.svg +1 -0
  105. package/app/static/fonts/Golos-Text_DemiBold.woff2 +0 -0
  106. package/app/static/fonts/Golos-Text_Regular.woff2 +0 -0
  107. package/app/static/fonts/OFL.txt +90 -0
  108. package/app/static/navigation.js +234 -0
  109. package/app/static/observability.js +121 -0
  110. package/app/static/theme.js +49 -0
  111. package/app/storage/__init__.py +16 -0
  112. package/app/storage/local_state.py +246 -0
  113. package/app/storage/migrate.py +110 -0
  114. package/app/storage/migrations/postgresql/0001_baseline.sql +896 -0
  115. package/app/storage/migrations/postgresql/0002_feeds_and_secrets.sql +55 -0
  116. package/app/storage/migrations/postgresql/0003_project_mask_display.sql +5 -0
  117. package/app/storage/migrations/postgresql/0004_package_identity.sql +36 -0
  118. package/app/storage/postgresql.py +573 -0
  119. package/app/storage/schema.py +619 -0
  120. package/app/storage/sql.py +57 -0
  121. package/app/storage/tools.py +254 -0
  122. package/app/telemetry.py +307 -0
  123. package/app/templates/base.html +91 -0
  124. package/app/templates/capec/context.html +3 -0
  125. package/app/templates/capec/detail.html +27 -0
  126. package/app/templates/capec/index.html +128 -0
  127. package/app/templates/components/_archive.html +11 -0
  128. package/app/templates/components/archived.html +19 -0
  129. package/app/templates/components/batch.html +35 -0
  130. package/app/templates/components/detail.html +332 -0
  131. package/app/templates/components/index.html +338 -0
  132. package/app/templates/components/research_preview.html +80 -0
  133. package/app/templates/components/research_run.html +54 -0
  134. package/app/templates/cwe/bdu.html +56 -0
  135. package/app/templates/cwe/detail.html +233 -0
  136. package/app/templates/cwe/index.html +97 -0
  137. package/app/templates/error.html +8 -0
  138. package/app/templates/feeds/index.html +65 -0
  139. package/app/templates/findings/card.html +639 -0
  140. package/app/templates/findings/decision_selected.html +41 -0
  141. package/app/templates/findings/defect_add.html +46 -0
  142. package/app/templates/findings/defect_selected.html +47 -0
  143. package/app/templates/findings/list.html +153 -0
  144. package/app/templates/findings/send_selected.html +53 -0
  145. package/app/templates/findings/trace.html +72 -0
  146. package/app/templates/journal/detail.html +19 -0
  147. package/app/templates/journal/index.html +19 -0
  148. package/app/templates/macros.html +440 -0
  149. package/app/templates/navigation-fields.html +1 -0
  150. package/app/templates/navigation.html +11 -0
  151. package/app/templates/projects/_identity_summary.html +42 -0
  152. package/app/templates/projects/defect_card.html +153 -0
  153. package/app/templates/projects/defect_create_preview.html +17 -0
  154. package/app/templates/projects/defect_fields_diff.html +6 -0
  155. package/app/templates/projects/defect_fields_form.html +40 -0
  156. package/app/templates/projects/defect_references.html +17 -0
  157. package/app/templates/projects/defect_sync_preview.html +28 -0
  158. package/app/templates/projects/defect_update_actions.html +6 -0
  159. package/app/templates/projects/defect_update_preview.html +24 -0
  160. package/app/templates/projects/defects.html +126 -0
  161. package/app/templates/projects/delete.html +31 -0
  162. package/app/templates/projects/external.html +61 -0
  163. package/app/templates/projects/folders.html +64 -0
  164. package/app/templates/projects/hub_accepted.html +10 -0
  165. package/app/templates/projects/hub_assignment.html +50 -0
  166. package/app/templates/projects/hub_pending.html +20 -0
  167. package/app/templates/projects/hub_pending_list.html +17 -0
  168. package/app/templates/projects/hub_state_note.html +23 -0
  169. package/app/templates/projects/hub_step_note.html +5 -0
  170. package/app/templates/projects/hub_sync.html +105 -0
  171. package/app/templates/projects/hub_sync_confirm.html +32 -0
  172. package/app/templates/projects/hub_sync_worker.html +5 -0
  173. package/app/templates/projects/hub_text_rules.html +64 -0
  174. package/app/templates/projects/identity_report.html +74 -0
  175. package/app/templates/projects/list.html +90 -0
  176. package/app/templates/projects/project.html +433 -0
  177. package/app/templates/reference-missing.html +14 -0
  178. package/app/templates/runs/run.html +166 -0
  179. package/app/templates/sca/card.html +476 -0
  180. package/app/templates/sca/index.html +321 -0
  181. package/app/templates/settings/hub_url.html +31 -0
  182. package/app/templates/settings/index.html +216 -0
  183. package/app/templates/settings/provider.html +229 -0
  184. package/app/templates/settings/providers.html +37 -0
  185. package/app/templates/worklists.html +52 -0
  186. package/app/textsafe.py +117 -0
  187. package/app/timing.py +245 -0
  188. package/app/triage.py +1743 -0
  189. package/app/view.py +430 -0
  190. package/app/worklists.py +204 -0
  191. package/examples/demo/demo-hub-report-v2.xlsx +0 -0
  192. package/examples/demo/demo-hub-report.xlsx +0 -0
  193. package/examples/demo/repos/billing-core/pom.xml +30 -0
  194. package/examples/demo/repos/billing-core/src/main/java/org/example/billing/Invoice.java +9 -0
  195. package/examples/demo/repos/billing-core/src/main/java/org/example/billing/InvoiceRepository.java +51 -0
  196. package/examples/demo/repos/billing-core/src/main/java/org/example/billing/InvoiceStatus.java +11 -0
  197. package/examples/demo/repos/billing-core/src/main/java/org/example/billing/config/DatabaseSettings.java +18 -0
  198. package/examples/demo/repos/billing-core/src/main/java/org/example/billing/payment/PaymentTokenService.java +35 -0
  199. package/examples/demo/repos/billing-core/src/main/java/org/example/billing/web/InvoiceExportController.java +57 -0
  200. package/examples/demo/repos/catalog-api/catalog_api/__init__.py +1 -0
  201. package/examples/demo/repos/catalog-api/catalog_api/products.py +24 -0
  202. package/examples/demo/repos/catalog-api/catalog_api/tasks.py +24 -0
  203. package/examples/demo/repos/catalog-api/catalog_api/views.py +17 -0
  204. package/examples/demo/repos/catalog-api/requirements.txt +3 -0
  205. package/npm/build.json +5 -0
  206. package/npm/cli.js +346 -0
  207. package/npm/files.manifest +224 -0
  208. package/npm/lib/binding.js +64 -0
  209. package/npm/lib/cluster.js +330 -0
  210. package/npm/lib/env.js +88 -0
  211. package/npm/lib/fsx.js +125 -0
  212. package/npm/lib/http.js +53 -0
  213. package/npm/lib/metrics.js +73 -0
  214. package/npm/lib/paths.js +150 -0
  215. package/npm/lib/pg.js +351 -0
  216. package/npm/lib/proc.js +101 -0
  217. package/npm/lib/python.js +133 -0
  218. package/npm/lib/stand.js +46 -0
  219. package/npm/lib/supervisor.js +1141 -0
  220. package/npm/lib/version.js +21 -0
  221. package/npm/requirements.txt +476 -0
  222. package/npm-shrinkwrap.json +111 -0
  223. package/package.json +37 -4
package/app/triage.py ADDED
@@ -0,0 +1,1743 @@
1
+ """Очередь триажа SAST: фоновый поток разбирает находки по одной.
2
+
3
+ Для каждой находки: кодовая база → папка с клоном, срез кода (build_context, секреты и ПДн маскируются),
4
+ отпечаток случая (case_hash), готовый вердикт из кэша или вызов модели, сохранение. Между находками поток
5
+ выполняет принятые команды «пауза» и «стоп». Прогоны выполняются по одному: видеокарта одна.
6
+
7
+ Порядок разбора задаётся при загрузке выгрузки (order_findings): срочные, затем по критичности, дубли (один ключ
8
+ группы) рядом – дубль с тем же отпечатком берёт уже готовый вердикт.
9
+
10
+ Команды и переходы состояний идущего прогона выполняются под общей блокировкой, поэтому принятая команда
11
+ не теряется: стоп важнее паузы, а после стопа прогон не уходит на паузу даже при сбое Ollama. Принятая команда
12
+ хранится и в базе (runs.control): «Стоп», принятый перед перезапуском приложения, при запуске останавливает прогон.
13
+
14
+ Настройки работы (адрес Ollama) берутся из базы поверх переменных окружения в начале каждого прогона
15
+ (current_settings): их меняют на странице «Настройки».
16
+ """
17
+
18
+ from __future__ import annotations
19
+
20
+ import hashlib
21
+ import json
22
+ import logging
23
+ import os
24
+ import statistics
25
+ import threading
26
+ import time
27
+ from collections.abc import Callable, Iterable, Mapping
28
+ import dataclasses
29
+ from dataclasses import dataclass, field
30
+ from pathlib import Path
31
+ from typing import Any
32
+
33
+ from app import model_traffic
34
+ from app.config import Settings
35
+ from app.context import build_context, clone_revision, export_fragment_view, file_presence, norm_path, resolve_repo
36
+ from app.db import (ACTIVE_RUN_STATES, FINAL_RUN_STATES, UNKNOWN_RESULT_NOTE, Database, DatabaseBusy,
37
+ EmptyQueue, ProfileChanged)
38
+ from app.hub_import import group_key, group_key2, is_urgent, near_columns2
39
+ from app.executors import (DROP_PAUSE_NOTE, DROP_SHARE_PAUSE, DROP_STREAK_PAUSE, REMOTE_KINDS, ProfileError,
40
+ SendNotAllowed, applied_think, choose_profile, client_for, drop_retry_allowed,
41
+ execution_values, fit_options, fit_thinking, host_metrics_of, json_overhead, planned_think,
42
+ prompt_size, provider_key, same_model, send_guard, snapshot_mismatch, snapshot_options, thinking_limit,
43
+ unload_allowed_of)
44
+ from app.llm import (DEFAULT_OPTIONS, LlmError, PromptOverflowError, estimate_tokens, gate_for,
45
+ model_answered, norm_model_name, outcome_unknown, prompt_budget, prompt_fits, prompt_tokens)
46
+ from app.llm_ollama import OllamaClient
47
+ from app.lockfile import LockUnsure
48
+ from app.storage import CommitUnknown
49
+ from app.logsafe import failure_text, log_failure
50
+ from app.masking import mask_text
51
+ from app.models import CodeContext, Finding, LlmStats
52
+ from app.prompts import (PROMPT_VERSION, VERDICT_ENUMS, VERDICT_FIELDS, VERDICT_REQUIRED, VERDICT_TYPES,
53
+ build_sast_messages, check_verdict_answer, parse_verdict, request_key, steering_fields,
54
+ steering_lines)
55
+
56
+ log = logging.getLogger("local_triage.triage")
57
+
58
+ SCOPES = ("live", "all", "urgent", "selected") # live – по умолчанию (бэклог 104)
59
+ SEVERITY_RANK = {"critical": 0, "high": 1, "medium": 2, "low": 3, "info": 4}
60
+ KIND_RANK = {"SAST": 0, "SCA": 1, "SCA-license": 2, "DAST": 3}
61
+ FEED_SIZE = 12 # сколько последних находок показывать в ленте прогона
62
+ WORKER_POLL_S = 1.0 # как часто поток проверяет очередь, если его не разбудили
63
+ CONTEXT_CHARS = 14000 # срез кода для модели, знаков; не помещается в окно контекста – сокращается
64
+ MIN_CONTEXT_CHARS = 1000 # …но не меньше: дальше промпт отклоняется с понятной ошибкой
65
+ CLONE_GONE_NOTE = ("Код находки в клоне сейчас не прочитать: файл пропал во время разбора или не найден однозначно. "
66
+ "Сохранённый срез не изменён. Проверьте клон или удалите его – тогда модель получит срез из базы.")
67
+ FIT_ATTEMPTS = 3 # сколько раз сокращать срез
68
+ CHANGED_NOTE = ("Находка или папка с клоном изменились, пока шёл разбор (новая выгрузка или другое соответствие "
69
+ "папок): результат не привязан, запустите прогон для неё заново.")
70
+ CODE_CHANGED_NOTE = ("Код в клоне изменился, пока отвечала модель: ответ относится к прежнему коду и к находке "
71
+ "не привязан. Запустите разбор этой находки заново.")
72
+ PARTIAL_NOTE = " Замеры скорости по этой находке неполные: ответа модели целиком нет."
73
+ # Занятая база или нечитаемый замок папки данных при записи результата находки (Э2): это не ошибка находки –
74
+ # запись повторяется, затем прогон встаёт на паузу, а находка остаётся в очереди
75
+ # Неизвестный исход COMMIT в прогоне – как занятая база: повтор и пауза, находка не считается ошибкой. Все записи под retry_busy
76
+ # безопасно повторить: вердикт с заранее полученным номером, срез, завершение находки только из pending, состояние прогона
77
+ # (ADR-0128, п. 6.4). Прямые записи без повтора при таком исходе дают паузу; «Продолжить» берёт следующую незавершённую находку.
78
+ BUSY_ERRORS = (DatabaseBusy, LockUnsure, CommitUnknown)
79
+ DB_UNKNOWN_PAUSE = ("Связь с базой оборвалась во время подтверждения записи, записалась ли она, неизвестно. Прогон на паузе. "
80
+ "Нажмите «Продолжить», когда база снова доступна: завершённые находки повторно не разбираются, а незавершённая "
81
+ "может быть разобрана заново.")
82
+ DB_RUN_PAUSE = ("База данных занята или недоступна либо не читается файл замка папки данных, и состояние прогона записать не "
83
+ "удалось. Прогон на паузе, разобранные находки сохранены. Нажмите «Продолжить», когда это пройдёт.")
84
+ DB_WRITE_RETRIES = 3
85
+ DB_RETRY_WAIT_S = 2.0
86
+ DB_BUSY_PAUSE = ("База данных занята (её держит другой запрос) или файл замка папки данных не прочитался: результат "
87
+ "находки не записан. Прогон на паузе, находка осталась в очереди. Нажмите «Продолжить», когда база "
88
+ "освободится: модель может разобрать эту находку заново.")
89
+ # Прогон без снимка исполнителя (начат до 0.9.12) и прогон с выключенным профилем (ADR-0102): исполнителя не
90
+ # подменяем – «Продолжить» создаёт новый прогон на действующем профиле проекта (TriageRunner.continue_as_new)
91
+ LEGACY_RUN_NOTE = ("Прогон начат до 0.9.12: сервер модели, на котором он шёл, не записан. Нажмите «Продолжить» – "
92
+ "неразобранные находки пойдут новым прогоном на профиле модели проекта.")
93
+ DISABLED_PROFILE_NOTE = ("Прогон на паузе. Включите профиль на странице «Настройки» или нажмите «Продолжить» – "
94
+ "неразобранные находки пойдут новым прогоном на действующем профиле проекта.")
95
+ PAUSE_OLLAMA_NOTE = "Прогон на паузе: проверьте Ollama и нажмите «Продолжить»."
96
+ PAUSE_PROVIDER_NOTE = "Прогон на паузе: устраните причину у провайдера и нажмите «Продолжить»."
97
+ PAYMENT_NOTE = "Провайдер ответил 402: нужна оплата (пополните баланс в личном кабинете провайдера)."
98
+
99
+
100
+ def pause_note(execution: Mapping[str, Any] | None) -> str:
101
+ """Подсказка паузы по классу исполнителя: Ollama своего контура или внешний провайдер."""
102
+ return PAUSE_PROVIDER_NOTE if str((execution or {}).get("trust") or "") == "external" else PAUSE_OLLAMA_NOTE
103
+
104
+
105
+ def pause_text(error: Exception) -> str:
106
+ """Текст паузы прогона при отказе перед отправкой: причина и что делать (SendNotAllowed.note; по умолчанию – о
107
+ выключенном профиле)."""
108
+ return f"{error} {getattr(error, 'note', '') or DISABLED_PROFILE_NOTE}"
109
+
110
+
111
+ def retry_busy(write: Callable[[], Any]) -> Any:
112
+ """Запись при занятой базе: несколько попыток с паузой; не вышло – исключение BUSY_ERRORS дальше."""
113
+ unknown = None
114
+ for attempt in range(DB_WRITE_RETRIES):
115
+ try:
116
+ return write()
117
+ except BUSY_ERRORS as e:
118
+ if isinstance(e, CommitUnknown):
119
+ unknown = e # следующая ошибка не снимает неопределённость: запись могла подтвердиться
120
+ if attempt + 1 == DB_WRITE_RETRIES:
121
+ if unknown is not None and unknown is not e:
122
+ raise unknown from e
123
+ raise
124
+ time.sleep(DB_RETRY_WAIT_S)
125
+ except Exception as e: # другая ошибка повтора тоже не значит, что прежняя запись не подтвердилась
126
+ if unknown is not None:
127
+ log_failure(log, "повтор записи после неизвестного исхода COMMIT не прошёл", e) # журнал покажет место этой ошибки
128
+ raise unknown from e
129
+ raise
130
+ return None
131
+ PROMPT_DOUBT_NOTE = ("Промпт, по счёту модели, не поместился в окно контекста вместе с ответом: начало могло быть "
132
+ "обрезано, ответ не принят. Увеличьте окно контекста (MODEL_NUM_CTX) и разберите находку ещё раз.")
133
+ # удалённый API: запрос не поместился в окно профиля даже с наименьшим срезом – совет про профиль, не про Ollama
134
+ REMOTE_WINDOW_NOTE = ("Увеличьте «Окно контекста модели» или уменьшите «Предел ответа» в профиле провайдера и "
135
+ "разберите находку ещё раз.")
136
+
137
+ # Медленный режим модели. Причина такого режима не доказана: у процесса модели часть памяти может оказаться
138
+ # в общей памяти Windows, и генерация идёт в несколько раз медленнее. Приложение только замечает замедление
139
+ # и перезагружает модель между находками; причину в интерфейсе не утверждает.
140
+ SLOW_TPS_SHARE = 0.35 # медленно – ниже этой доли обычной скорости (медианы последних ответов)
141
+ SLOW_TPS_ABSOLUTE = 30.0 # без ориентира: абсолютный порог ток/с для первых двух ответов подряд
142
+ SLOW_TPS_KNOWN_FAST = 80.0 # быстрая модель: раньше давала больше этого, иначе абсолютный порог не применяется
143
+ SLOW_STREAK = 2 # сколько медленных ответов подряд нужно, чтобы считать режим медленным
144
+ SLOW_MAX_RELOADS = 2 # не больше двух попыток перезагрузки за прогон, включая неудачные
145
+ SLOW_BASELINE_MIN = 3 # ориентир – медиана, для неё нужно не меньше трёх успешных ответов
146
+ SLOW_BASELINE_WINDOW = 20 # сколько последних ответов прогона берётся для ориентира
147
+ SLOW_HISTORY_WINDOW = 200 # сколько ответов прошлых прогонов той же модели смотреть
148
+ SLOW_RELOAD_WAIT_S = 15.0 # сколько ждать, пока /api/ps покажет модель выгруженной
149
+ SLOW_RELOAD_POLL_S = 0.2 # как часто спрашивать /api/ps во время ожидания
150
+
151
+
152
+ def slow_model_status_text(tps: float, baseline: float, reloaded: bool) -> str:
153
+ """Строка оператору о медленном режиме. Причина не называется: она не доказана."""
154
+ measured = f"{_tps_number(tps)} ток/с при обычных {_tps_number(baseline)}"
155
+ if reloaded:
156
+ return f"Модель работала медленно ({measured}) – перезагружена"
157
+ return (f"Модель работала медленно ({measured}) – перезагрузка не помогла: закройте программы, "
158
+ "использующие видеокарту, и нажмите «Пауза» → «Продолжить»")
159
+
160
+
161
+ def _tps_number(value: float) -> str:
162
+ """Ток/с в строке оператору: целое, если оно не меньше 10, иначе один знак после запятой."""
163
+ return f"{value:.0f}" if abs(value) >= 10 else f"{value:.1f}"
164
+
165
+
166
+ def _median(values: Iterable[float]) -> float | None:
167
+ items = list(values)
168
+ return float(statistics.median(items)) if items else None
169
+
170
+
171
+ @dataclass
172
+ class _SlowState:
173
+ """Замедление одного прогона: последние скорости, серия медленных ответов, перезагрузки и строка оператору."""
174
+
175
+ samples: list[float] = field(default_factory=list)
176
+ history_median: float | None = None # ориентир: медиана прошлых прогонов, только если замеров хватает
177
+ history_typical: float | None = None # та же медиана для строки оператору, даже по одному-двум замерам
178
+ history_fast: bool = False
179
+ streak: int = 0
180
+ reloads: int = 0
181
+ reload_pending: bool = False
182
+ unload_allowed: bool = True # снимок исполнителя разрешает выгрузку модели (профиль lan – только по разрешению)
183
+ after_reload: bool = False
184
+ pending_tps: float = 0.0
185
+ pending_baseline: float = 0.0
186
+ text: str = ""
187
+ warning: bool = False
188
+
189
+
190
+ class TriageError(Exception):
191
+ """Прогон не запустить или не изменить. Текст – по-русски, для показа в интерфейсе."""
192
+
193
+
194
+ # ============================================================================ порядок разбора
195
+
196
+ def severity_rank(f: Finding) -> int:
197
+ """Ранг критичности: 0 – критическая. У SCA отчёта Hub критичности нет – ранг по полосам CVSS v3."""
198
+ if f.severity in SEVERITY_RANK:
199
+ return SEVERITY_RANK[f.severity]
200
+ if f.cvss is not None:
201
+ if f.cvss >= 9.0:
202
+ return 0
203
+ if f.cvss >= 7.0:
204
+ return 1
205
+ if f.cvss >= 4.0:
206
+ return 2
207
+ return 3 if f.cvss > 0 else 4
208
+ return 5
209
+
210
+
211
+ def order_findings(findings: Iterable[Finding], sca_cvss: float = 9.0) -> list[dict]:
212
+ """Находки → строки для Database.save_import (и reorder_findings) в порядке разбора.
213
+
214
+ SAST впереди остальных видов; внутри вида – срочные, затем по критичности, затем по порядку выгрузки.
215
+ Находки с одним ключом группы (дубли) идут подряд, на месте самой срочной из них.
216
+ """
217
+ items = []
218
+ for index, f in enumerate(findings):
219
+ urgent = bool(is_urgent(f, sca_cvss=sca_cvss))
220
+ gk = group_key2(f) # дубли идут подряд по ключу второй редакции (ADR-0095)
221
+ key = (KIND_RANK.get(f.kind, 9), 0 if urgent else 1, severity_rank(f), index)
222
+ items.append((f, urgent, gk, key, (f.kind, gk or f"id:{f.hub_id}")))
223
+ best: dict[tuple[str, str], tuple] = {}
224
+ for _, _, _, key, group in items:
225
+ if group not in best or key < best[group]:
226
+ best[group] = key
227
+ items.sort(key=lambda item: (best[item[4]], item[3]))
228
+ rows = []
229
+ for pos, (f, urgent, gk, _, _) in enumerate(items):
230
+ cat, file2, line = near_columns2(f)
231
+ rows.append({"hub_id": f.hub_id, "pos": pos, "kind": f.kind, "severity": f.severity, "cvss": f.cvss,
232
+ "urgent": urgent, "codebase": f.codebase, "group_key": group_key(f), "group_key2": gk,
233
+ "g2_cat": cat, "g2_file": file2, "g2_line": line, "data": f.to_dict()})
234
+ return rows
235
+
236
+
237
+ def reorder_project(db: Database, project_id: int, sca_cvss: float) -> int:
238
+ """Заново упорядочить находки проекта и пересчитать срочность (например, после смены порога срочности SCA
239
+ на странице «Настройки»). Порядок выгрузки восстанавливается по листу и строке. Возвращает, у скольких находок
240
+ изменились порядок или срочность."""
241
+ findings = [Finding.from_dict(row["data"]) for row in db.findings_data(project_id)]
242
+ findings.sort(key=lambda f: (KIND_RANK.get(f.kind, 9), f.sheet, f.row))
243
+ return db.reorder_findings(project_id, order_findings(findings, sca_cvss))
244
+
245
+
246
+ # ============================================================================ случай для модели
247
+
248
+ def repo_dir_for(settings: Settings, project: dict, codebase_map: dict[str, dict],
249
+ f: Finding) -> tuple[Path | None, str]:
250
+ """Папка клона кодовой базы находки: (путь, "") или (None, причина). Отвязанный клон (detached, ADR-0072) не
251
+ читается, даже если папка на месте: код кодовой базы – срезы в базе."""
252
+ entry = codebase_map.get(f.codebase) or {}
253
+ folder = str(entry.get("folder") or "").strip()
254
+ if not folder:
255
+ return None, "кодовая база не сопоставлена с папкой"
256
+ if entry.get("detached"):
257
+ return None, "клон отвязан: код берётся из срезов в базе"
258
+ rel = "/".join(part for part in (str(project.get("repos_dir") or "").strip("/"), folder) if part)
259
+ try:
260
+ path = resolve_repo(settings.repos_root, rel)
261
+ except ValueError as e:
262
+ return None, str(e)
263
+ if not path.is_dir():
264
+ return None, "папка с клоном не найдена"
265
+ if empty_dir(path):
266
+ # Пустая папка на месте удалённого клона – тоже клона нет: иначе сверка ревизий сочла бы её другим
267
+ # кодом и сбросила сохранённые срезы (ADR-0072)
268
+ return None, "папка с клоном пуста"
269
+ return path, ""
270
+
271
+
272
+ def empty_dir(path: Path) -> bool:
273
+ """В папке нет ни одной записи. Не удалось прочитать – не пустая: решает обычная проверка файла."""
274
+ try:
275
+ with os.scandir(path) as entries:
276
+ return next(entries, None) is None
277
+ except OSError:
278
+ return False
279
+
280
+
281
+ def stored_code(case: dict | None) -> CodeContext | None:
282
+ """Сохранённый в базе срез находки (cases.context_json) или None, если среза нет. Срез с кодом из файла клона –
283
+ статус «ok»; срез из одной строки выгрузки (файла в клоне не было) и срез без строк тоже возвращаются: без
284
+ клона каждый остаётся тем, что видела модель, и отпечаток решения по нему не меняется."""
285
+ context = (case or {}).get("context") or {}
286
+ if not context.get("status"):
287
+ return None
288
+ try:
289
+ return CodeContext.from_dict(context)
290
+ except (TypeError, ValueError, KeyError):
291
+ return None
292
+
293
+
294
+ def snapshot_code(settings: Settings, source: dict, case: dict | None) -> tuple[CodeContext, str] | None:
295
+ """Код находки из базы вместо клона (ADR-0072): папки клона её кодовой базы нет (удалена, пуста, другой корень
296
+ папок с клонами) или в клоне нет файла находки, а срез сохранён при разборе или кнопкой «Сохранить срезы кода» –
297
+ (срез, отпечаток). Файл в клоне на месте или среза нет – None: код читается из клона, как раньше. Код проекта
298
+ после выгрузки не меняется, поэтому сохранённый срез без клона считается текущим кодом: он не перезаписывается
299
+ и не сверяется."""
300
+ ctx = stored_code(case)
301
+ if ctx is None:
302
+ return None
303
+ f = Finding.from_dict(source["data"])
304
+ repo_dir, _ = repo_dir_for(settings, {"repos_dir": source["repos_dir"]}, source_codebases(source, f), f)
305
+ if repo_dir is not None and _code_file_present(repo_dir, f, ctx.file):
306
+ return None
307
+ return ctx, case_hash(f, ctx)
308
+
309
+
310
+ def degrades(case: dict | None, ctx: CodeContext) -> bool:
311
+ """Новый срез хуже сохранённого: в базе код из файла (статус «ok»), а сейчас – только строка выгрузки или ничего.
312
+ Такой срез автоматически не записывается (ADR-0072): файл пропал во время разбора или не найден однозначно,
313
+ а полноценный срез в базе – единственная копия кода, если клон потом удалят."""
314
+ return ((case or {}).get("context") or {}).get("status") == "ok" and ctx.status != "ok"
315
+
316
+
317
+ def source_codebases(source: dict, f: Finding) -> dict[str, dict]:
318
+ """Сопоставление кодовой базы находки по снимку Database.case_input() – для repo_dir_for."""
319
+ return {f.codebase: {"folder": source["folder"], "detached": bool(source.get("detached"))}}
320
+
321
+
322
+ def _code_file_present(repo_dir: Path, f: Finding, stored_file: str = "") -> bool:
323
+ """Файл находки есть в клоне или это не определить (файл не читается). Нет только тогда, когда это доказано:
324
+ клон удалён не целиком – осталась .git или часть папок – и файла нет ни по пути сохранённого среза, ни по пути
325
+ из выгрузки. Несколько подходящих файлов или неполный обход клона – файл считается на месте: код читается из
326
+ клона, и его изменения видны, как раньше."""
327
+ try:
328
+ for rel in dict.fromkeys(r for r in (norm_path(stored_file), norm_path(f.file)) if r):
329
+ if file_presence(repo_dir, rel) != "missing":
330
+ return True
331
+ except (OSError, ValueError):
332
+ return True
333
+ return False
334
+
335
+
336
+ def observed_revisions(settings: Settings, project: dict, codebase_map: dict[str, dict]) -> dict[str, str]:
337
+ """Ревизии клонов кодовых баз проекта, папка которых сейчас на месте: {кодовая база: ревизия}; "" – папка
338
+ не клон git. Кодовые базы без папки или с пропавшей папкой не входят: о них ничего не известно."""
339
+ result = {}
340
+ for codebase, entry in codebase_map.items():
341
+ if not str((entry or {}).get("folder") or "").strip():
342
+ continue
343
+ repo_dir, _ = repo_dir_for(settings, project, codebase_map, Finding(hub_id="", kind="SAST", codebase=codebase))
344
+ if repo_dir is not None:
345
+ result[codebase] = clone_revision(repo_dir)
346
+ return result
347
+
348
+
349
+ def sync_revisions(db: Database, settings: Settings, project: dict) -> dict:
350
+ """Сверка ревизий клонов проекта с запомненными (Database.sync_revisions): при смене ревизии срезы находок
351
+ этой кодовой базы сбрасываются, а отметки «проверено» снимаются. Перед сверкой удалённые клоны с полными срезами
352
+ отвязываются (detach_removed_clones): клон другой выгрузки, положенный потом на то же место, срезы не сбросит."""
353
+ detach_removed_clones(db, settings, project)
354
+ return db.sync_revisions(project["id"], observed_revisions(settings, project,
355
+ db.get_codebase_map(project["id"], with_detached=True)))
356
+
357
+
358
+ def detach_removed_clones(db: Database, settings: Settings, project: dict) -> list[str]:
359
+ """Отвязать клоны, которые удалили после разбора (ADR-0072): у кодовой базы выбрана папка, клона нет (папка
360
+ удалена, пуста или вне корня), срез полон у каждой её находки SAST и хотя бы в одном срезе код из файла
361
+ (клон был: кодовую базу, которую разбирали без клона, не отвязываем). Отвязанный клон больше не читается,
362
+ пока человек не подключит клоны снова (Database.clear_detached) или не выберет другую папку. Возвращает
363
+ отвязанные сейчас кодовые базы."""
364
+ pid = int(project["id"])
365
+ if not settings.repos_root.is_dir():
366
+ return [] # корень папок с клонами не подключён: это не удаление клонов, отвязывать нельзя
367
+ counts = db.snapshot_counts(pid)
368
+ cmap = db.get_codebase_map(pid, with_detached=True)
369
+ removed = []
370
+ for codebase, entry in cmap.items():
371
+ n = counts.get(codebase) or {}
372
+ if (not str(entry.get("folder") or "").strip() or entry.get("detached") or not n.get("sast")
373
+ or n.get("none") or n.get("incomplete") or not n.get("code")):
374
+ continue
375
+ repo_dir, _ = repo_dir_for(settings, project, cmap, Finding(hub_id="", kind="SAST", codebase=codebase))
376
+ if repo_dir is None:
377
+ removed.append(codebase)
378
+ if removed:
379
+ db.set_detached(pid, removed)
380
+ return removed
381
+
382
+
383
+ def save_snapshots(db: Database, settings: Settings, project: dict, mask_key: bytes) -> dict:
384
+ """«Сохранить срезы кода» (ADR-0072): находкам SAST текущей выгрузки без сохранённого среза, у которых клон на
385
+ месте, строится и записывается срез – так же, как его строит прогон (маскирование, CONTEXT_CHARS), но без
386
+ модели. Удалять клоны можно после проверки полноты срезов. Срез без вердикта с причиной missing, unreadable
387
+ или неизвестной причиной, а также no_repo сопоставленного неотвязанного клона заменяется, только если файл
388
+ теперь доступен и прочитан; прежний вердикт по no_repo к новому коду не привязывается.
389
+ Возвращает {"saved": сколько записано, "skipped": {причина: сколько}}."""
390
+ pid = int(project["id"])
391
+ saved, skipped = 0, {}
392
+ for hub_id, upgrade in db.snapshot_candidates(pid):
393
+ source = db.case_input(pid, hub_id)
394
+ if source is None or source.get("missing"):
395
+ continue
396
+ f = Finding.from_dict(source["data"])
397
+ repo_dir, why = repo_dir_for(settings, {"repos_dir": source["repos_dir"]}, source_codebases(source, f), f)
398
+ if repo_dir is None:
399
+ skipped[why] = skipped.get(why, 0) + 1
400
+ continue
401
+ if upgrade and file_presence(repo_dir, f.file) != "found":
402
+ continue
403
+ # срез без строк тоже сохраняется – как в прогоне («Нет кода для разбора»): без клона он останется тем же
404
+ ctx = build_context(repo_dir, f, max_chars=CONTEXT_CHARS, mask_key=mask_key, no_repo_note=why)
405
+ if upgrade and ctx.status != "ok":
406
+ continue # полноценный срез не получен: прежний срез остаётся
407
+ if db.save_case(pid, hub_id, case_hash(f, ctx), {**case_context(f, ctx), "max_chars": CONTEXT_CHARS},
408
+ None, source, only_new=not upgrade, replace_line_only=upgrade):
409
+ saved += 1
410
+ return {"saved": saved, "skipped": skipped}
411
+
412
+
413
+ def case_hash(f: Finding, ctx: CodeContext) -> str:
414
+ """Отпечаток случая – всё, что модель видит в сведениях о находке и в коде: правило, место, маскированный срез
415
+ кода и сведения о нём. ID находки, имя кодовой базы, анализатор и критичность в промпт не входят (prompts.py),
416
+ поэтому нет их и здесь: дубль от другого анализатора или с другой критичностью получает тот же вердикт.
417
+ Шаблон промпта учитывает PROMPT_VERSION в ключе кэша, параметры генерации – константы (окно контекста на вход
418
+ не влияет: промпт, который в него не помещается, не отправляется)."""
419
+ payload = {
420
+ "kind": f.kind, "rule": f.rule, "cwe": list(f.cwe), "file": f.file, "line": f.line,
421
+ "language": f.language, "snippet": " ".join(str(f.snippet or "").split()),
422
+ "ctx": {"status": ctx.status, "file": ctx.file, "language": ctx.language, "start": ctx.start_line,
423
+ "target": ctx.target_line, "lines": list(ctx.lines), "enclosing": ctx.enclosing,
424
+ "export_line_check": ctx.export_line_check, "note": ctx.note},
425
+ }
426
+ if ctx.export_line_check_version >= 2:
427
+ # ADR-0082: в отпечатке – сверка версии 1 по тому же коду, чтобы уточнённая сверка не меняла отпечаток
428
+ # неизменного кода (иначе карточка сочла бы код изменившимся и решение потеряло бы «Проверено»)
429
+ payload["ctx"]["export_line_check"] = ctx.hash_check
430
+ payload["ctx"]["export_line_at"] = ctx.hash_check_at
431
+ elif ctx.export_line_check_version >= 1:
432
+ payload["ctx"]["export_line_at"] = ctx.export_line_at # новые срезы; старые отпечатки остаются прежними
433
+ text = json.dumps(payload, ensure_ascii=False, sort_keys=True)
434
+ return hashlib.sha256(text.encode("utf-8")).hexdigest()
435
+
436
+
437
+ def think_for(model: str) -> str | None:
438
+ """Режим рассуждений передаётся только моделям gpt-oss."""
439
+ return "low" if "gpt-oss" in model.casefold() else None
440
+
441
+
442
+ def model_options(num_ctx: int) -> dict[str, int]:
443
+ """Параметры генерации прогона: окно контекста из настроек; предел длины ответа – не больше четверти окна,
444
+ чтобы в маленьком окне оставалось место под промпт."""
445
+ return {"num_ctx": int(num_ctx), "num_predict": min(int(DEFAULT_OPTIONS["num_predict"]), int(num_ctx) // 4)}
446
+
447
+
448
+ def case_context(f: Finding, ctx: CodeContext) -> dict[str, Any]:
449
+ """Срез для хранения (cases.context_json): CodeContext и признаки попытки повлиять на разбор – номера строк
450
+ кода и названия полей находки с текстом, похожим на указания для модели. Карточка и список показывают их
451
+ человеку: вердикт, полученный под влиянием таких указаний, не должен выглядеть как обычный."""
452
+ return {**ctx.to_dict(), "steering_lines": steering_lines(ctx), "steering_fields": steering_fields(f, ctx)}
453
+
454
+
455
+ def current_code(settings: Settings, source: dict, mask_key: bytes, max_chars: int = CONTEXT_CHARS,
456
+ case: dict | None = None) -> tuple[Finding, CodeContext, str]:
457
+ """Срез текущего кода находки по снимку Database.case_input() – так же, как его строит прогон: (находка,
458
+ срез, отпечаток case_hash). Отпечаток сравнивается с тем, что видела модель (cases.case_hash) или человек
459
+ (reviews.code_hash): изменился – код в клоне другой. max_chars – размер среза, с которым считался отпечаток,
460
+ с которым идёт сравнение. case – сохранённый срез находки: если клона нет, текущий код – он (snapshot_code).
461
+ Без клона срез другого размера не построить: возвращается отпечаток сохранённого среза, и решение, принятое при
462
+ другом размере, не совпадёт – его актуальность не доказана (code_changed), решение сохраняют заново."""
463
+ f, ctx, chash, _ = current_code_origin(settings, source, mask_key, max_chars, case)
464
+ return f, ctx, chash
465
+
466
+
467
+ def current_code_origin(settings: Settings, source: dict, mask_key: bytes, max_chars: int = CONTEXT_CHARS,
468
+ case: dict | None = None) -> tuple[Finding, CodeContext, str, bool]:
469
+ """То же, что current_code, и признак: срез подставлен из базы (клона или файла находки нет, snapshot_code).
470
+ Признак – у того же чтения: повторная проверка клона позже может увидеть уже вернувшийся файл, код которого
471
+ никто не читал (ревью Codex ветки долга, круг 5)."""
472
+ f = Finding.from_dict(source["data"])
473
+ snapshot = snapshot_code(settings, source, case)
474
+ if snapshot is not None:
475
+ return f, snapshot[0], snapshot[1], True
476
+ repo_dir, why = repo_dir_for(settings, {"repos_dir": source["repos_dir"]}, source_codebases(source, f), f)
477
+ ctx = build_context(repo_dir, f, max_chars=max_chars, mask_key=mask_key, no_repo_note=why)
478
+ return f, ctx, case_hash(f, ctx), False
479
+
480
+
481
+ def _merged_stats(first: LlmStats | None, second: LlmStats | None) -> LlmStats | None:
482
+ """Замеры двух обращений одной находки (оборванное и автоматический повтор, ADR-0107): токены, попытки и время
483
+ складываются, скорость – последнего ответа."""
484
+ if first is None or second is None:
485
+ return second if second is not None else first
486
+ return dataclasses.replace(
487
+ second, prompt_tokens=first.prompt_tokens + second.prompt_tokens,
488
+ output_tokens=first.output_tokens + second.output_tokens, attempts=first.attempts + second.attempts,
489
+ total_s=round(first.total_s + second.total_s, 3), load_s=first.load_s + second.load_s,
490
+ reasoning_tokens=first.reasoning_tokens + second.reasoning_tokens,
491
+ cache_hit_tokens=first.cache_hit_tokens + second.cache_hit_tokens,
492
+ think=",".join(p for p in (first.think, second.think) if p))
493
+
494
+
495
+ def _after_drop(drop_error: LlmError, retry_error: Exception) -> LlmError:
496
+ """Обрыв без ответа, после которого повтор не получил ответа модели (не ушёл, 402, ошибка сервера): находка –
497
+ «результат неизвестен» первого запроса, причина повтора – в тексте (ревью Codex, круг 18)."""
498
+ drop_error.drop_retries = 1 # type: ignore[attr-defined]
499
+ drop_error.retry_error = str(retry_error) # type: ignore[attr-defined]
500
+ # 402 повтора – провайдер просит оплату: прогон встаёт на паузу по оплате (ревью Codex, круг 19)
501
+ drop_error.retry_status = getattr(retry_error, "status", None) # type: ignore[attr-defined]
502
+ drop_error.stats = _merged_stats(drop_error.stats, getattr(retry_error, "stats", None))
503
+ return drop_error
504
+
505
+
506
+ def _stats_partial(error: LlmError) -> bool:
507
+ """Замеры неудачного ответа неполные: попытку прервал сбой связи или сервера, и что модель успела
508
+ сгенерировать в ней, неизвестно (ответ не по формату, оборванный по длине ответ – замерены полностью).
509
+ Признак – ответа модели в ошибке нет (raw пуст), хотя попытка была; если клиент сам сообщает признак
510
+ (stats_partial), берётся он."""
511
+ explicit = getattr(error, "stats_partial", None)
512
+ if explicit is not None:
513
+ return bool(explicit)
514
+ if getattr(error, "drop_retries", 0):
515
+ # одна из попыток оборвалась без ответа: её расход неизвестен, как бы ни закончился повтор (ревью Codex, круг 19)
516
+ return True
517
+ if getattr(error, "reason", None):
518
+ # известный исход (LlmError.reason, ADR-0106 п. 8): ответ получен целиком, его расход в stats – замеры полные,
519
+ # даже если текста ответа нет (отказ модели, неизвестная причина остановки, ответ не по протоколу; KIMI-05)
520
+ return False
521
+ return error.stats is not None and error.stats.attempts > 0 and not error.raw
522
+
523
+
524
+ # ============================================================================ очередь
525
+
526
+ class TriageRunner:
527
+ """Фоновый поток триажа. Состояние прогонов – в базе; принятые команды паузы и стопа – в памяти процесса
528
+ и в базе (runs.control), чтобы принятый «Стоп» пережил перезапуск."""
529
+
530
+ def __init__(self, db: Database, settings: Settings,
531
+ client_factory: Callable[[str], OllamaClient] | None = None,
532
+ mask_key: bytes | None = None) -> None:
533
+ self.db = db
534
+ self.settings = settings
535
+ self._client_factory = client_factory or OllamaClient
536
+ self._mask_key = mask_key if mask_key is not None else db.mask_key()
537
+ self._lock = threading.Lock() # команды, переходы состояний идущего прогона, текущая находка
538
+ self._life = threading.Lock() # запуск и остановка потока
539
+ self._controls: dict[int, str] = {} # run_id -> 'pause' | 'stop'
540
+ self._live: dict[int, dict[str, Any]] = {} # run_id -> текущая находка и этап
541
+ self._slow: dict[int, _SlowState] = {} # run_id -> замедление и перезагрузки модели
542
+ self._unsaved_errors: dict[int, str] = {} # прогоны, чьё состояние «ошибка» не удалось записать
543
+ # прогоны, чью паузу из-за занятой базы не удалось записать (Э2): причина – запишется позже
544
+ self._unsaved_pauses: dict[int, str] = {}
545
+ # обрывы без ответа у внешнего провайдера по прогону: {run_id: {"drops", "streak", "done"}}; каскад – пауза
546
+ # прогона после находки (DROP_STREAK_PAUSE, DROP_SHARE_PAUSE); счёт заново после «Продолжить»
547
+ self._drops: dict[int, dict[str, int]] = {}
548
+ self._drop_pause: dict[int, str] = {}
549
+ self._wake = threading.Event()
550
+ self._halt = threading.Event()
551
+ self._thread: threading.Thread | None = None
552
+
553
+ def current_settings(self) -> Settings:
554
+ """Действующие настройки: сохранённые в интерфейсе (таблица settings) поверх переменных окружения."""
555
+ return self.settings.with_stored(self.db.get_settings())
556
+
557
+ # ---------------------------------------------------------------- жизненный цикл
558
+
559
+ def start(self) -> None:
560
+ """Запускает поток. Прогоны, прерванные перезапуском, ставятся на паузу. Повторный вызов при живом
561
+ потоке ничего не делает; после shutdown() ждёт, пока прежний поток доработает находку."""
562
+ with self._life:
563
+ if self._thread is not None and self._thread.is_alive():
564
+ if not self._halt.is_set():
565
+ return
566
+ self._thread.join()
567
+ self.db.recover_interrupted()
568
+ self._halt = threading.Event()
569
+ thread = threading.Thread(target=self._loop, args=(self._halt,), name="triage-worker", daemon=True)
570
+ thread.start() # не запустился – прежнее состояние, shutdown() не ждёт незапущенный поток
571
+ self._thread = thread
572
+
573
+ def shutdown(self, timeout: float = 5.0) -> bool:
574
+ """Останавливает поток после текущей находки. True – поток завершился за timeout секунд
575
+ (только тогда базу можно закрывать)."""
576
+ with self._life:
577
+ self._halt.set()
578
+ self._wake.set()
579
+ thread = self._thread
580
+ if thread is None or thread.ident is None:
581
+ return True
582
+ thread.join(timeout)
583
+ return not thread.is_alive()
584
+
585
+ # ---------------------------------------------------------------- команды
586
+
587
+ def enqueue(self, project_id: int, model: str, scope: str, hub_ids: Iterable[str] = (),
588
+ fresh: bool = False, origin: str = "", provider_id: int | None = None) -> int:
589
+ """Ставит прогон в очередь; возвращает его номер. fresh – не брать готовые вердикты из кэша. Профиль –
590
+ provider_id или профиль проекта, или профиль приложения (ADR-0102); снимок исполнителя пишется вместе с
591
+ прогоном: окно, предел ответа, срок и режим схемы замораживаются при постановке."""
592
+ model = str(model or "").strip()
593
+ if scope not in SCOPES:
594
+ raise TriageError("Неизвестный охват прогона.")
595
+ if not model:
596
+ raise TriageError("Не выбрана модель.")
597
+ settings = self.current_settings()
598
+ try:
599
+ profile = choose_profile(self.db, settings, self.db.get_project(project_id), provider_id)
600
+ except ProfileError as e:
601
+ raise TriageError(str(e)) from None
602
+ execution = execution_values(profile, model, "triage", settings.num_ctx, settings.model_json_schema)
603
+ with self._lock:
604
+ active = self.db.active_runs(project_id)
605
+ if active:
606
+ if origin == "card" and active[0].get("state") != "paused": # разборы идут по одному, очереди нет – сказать, что делать
607
+ raise TriageError(f"Сейчас идёт другой разбор (прогон №{active[0]['id']}). Разборы проекта идут по одному: "
608
+ "дождитесь его конца и нажмите «Разобрать» снова. Ход прогона – на странице проекта.")
609
+ raise TriageError(f"У проекта есть незавершённый прогон №{active[0]['id']}: продолжите или "
610
+ "остановите его.")
611
+ try: # состав очереди и паспорт – одним чтением в транзакции создания прогона (бэклог 104)
612
+ run_id = self.db.create_run(project_id, model, scope, PROMPT_VERSION, list(hub_ids), fresh=fresh,
613
+ origin=origin, execution=execution, queue_scope=scope)
614
+ except EmptyQueue:
615
+ raise TriageError("Нет находок SAST для выбранного охвата.") from None
616
+ except ProfileChanged as e:
617
+ raise TriageError(f"{e} Выберите для проекта действующий профиль.") from None
618
+ self._wake.set()
619
+ return run_id
620
+
621
+ def continuation_reason(self, run: dict) -> str:
622
+ """Почему прогон нельзя продолжить им самим ("" – можно): у него нет снимка исполнителя (начат до 0.9.12) или
623
+ профиль снимка выключен. Тогда «Продолжить» – новый прогон на действующем профиле проекта (П22)."""
624
+ execution = self.db.get_execution(run.get("execution_id"))
625
+ if execution is None:
626
+ return "Прогон начат до 0.9.12: адрес исполнителя у него не записан."
627
+ profile = self.db.get_provider(execution["provider_id"]) if execution.get("provider_id") else None
628
+ return snapshot_mismatch(profile, execution)
629
+
630
+ def continue_as_new(self, run_id: int, hub_ids: Iterable[str] | None = None, origin: str | None = None,
631
+ fresh: bool | None = None, execution_id: int | None = None) -> int:
632
+ """Новый прогон вместо прежнего (ADR-0102 п. 4–5, П22): «Продолжить» у прогона без снимка или с выключенным
633
+ профилем, «Повторить ошибочные». Новый прогон – с parent_run_id и собственным снимком на действующем профиле
634
+ проекта (или с перенесённым снимком execution_id); прежний, если он в очереди или на паузе, останавливается в
635
+ той же транзакции с отметкой, каким прогоном продолжен. Все проверки – до записи: отказ прежний прогон не
636
+ трогает. hub_ids – находки (по умолчанию – неразобранные)."""
637
+ with self._lock:
638
+ run = self.db.get_run(run_id)
639
+ if run is None:
640
+ raise TriageError("Прогон не найден.")
641
+ if run["state"] == "running":
642
+ raise TriageError("Прогон ещё идёт: сначала поставьте его на паузу.")
643
+ self.db.settle_sending_items(run_id) # К11: находки с меткой без результата новым прогоном не берутся
644
+ ids = list(hub_ids) if hub_ids is not None else self.db.pending_hub_ids(run_id)
645
+ if not ids:
646
+ raise TriageError("Продолжать нечего: все находки прогона уже разобраны.")
647
+ execution = None
648
+ if execution_id is None:
649
+ settings = self.current_settings()
650
+ try:
651
+ profile = choose_profile(self.db, settings, self.db.get_project(run["project_id"]))
652
+ except ProfileError as e:
653
+ raise TriageError(str(e)) from None
654
+ execution = execution_values(profile, run["model"], "triage", settings.num_ctx,
655
+ settings.model_json_schema)
656
+ others = [r for r in self.db.active_runs(run["project_id"]) if r["id"] != run_id]
657
+ if others:
658
+ raise TriageError(f"У проекта есть незавершённый прогон №{others[0]['id']}: продолжите или "
659
+ "остановите его.")
660
+ try:
661
+ new_id = self.db.create_run(run["project_id"], run["model"], "selected", PROMPT_VERSION, ids,
662
+ fresh=bool(run["fresh"]) if fresh is None else fresh,
663
+ origin=run.get("origin") or "" if origin is None else origin,
664
+ execution=execution, execution_id=execution_id, parent_run_id=run_id)
665
+ except ProfileChanged as e: # профиль выключили или сменили адрес только что: прежний прогон не тронут
666
+ raise TriageError(f"{e} Запустите новый прогон на действующем профиле проекта.") from None
667
+ except RuntimeError:
668
+ raise TriageError("Прогон успел измениться: обновите страницу.") from None
669
+ self._wake.set()
670
+ return new_id
671
+
672
+ def retry_errors(self, run_id: int, hub_ids: Iterable[str]) -> int:
673
+ """«Повторить ошибочные» (ADR-0102 п. 5): снимок прежнего прогона переносится, если его профиль включён и адрес
674
+ профиля не менялся; профиль выключен или адрес изменился – отказ с причиной (прежний прогон не трогается);
675
+ прогон без снимка (до 0.9.12) – новый прогон на действующем профиле проекта с собственным снимком."""
676
+ run = self.db.get_run(run_id)
677
+ if run is None:
678
+ raise TriageError("Прогон не найден.")
679
+ execution = self.db.get_execution(run.get("execution_id"))
680
+ if execution is None:
681
+ return self.continue_as_new(run_id, hub_ids, origin="retry", fresh=True)
682
+ profile = self.db.get_provider(execution["provider_id"]) if execution.get("provider_id") else None
683
+ reason = snapshot_mismatch(profile, execution)
684
+ if reason:
685
+ raise TriageError(f"{reason} Запустите новый прогон ошибочных находок на действующем профиле проекта.")
686
+ return self.continue_as_new(run_id, hub_ids, origin="retry", fresh=True, execution_id=int(execution["id"]))
687
+
688
+ def pause(self, run_id: int) -> bool:
689
+ """Пауза: прогон в очереди – сразу, идущий – после текущей находки. Принятый стоп важнее."""
690
+ with self._lock:
691
+ run = self.db.get_run(run_id)
692
+ if run is None:
693
+ return False
694
+ if run["state"] == "queued" and self.db.set_run_state(run_id, "paused", last_error="",
695
+ only_from=("queued",)):
696
+ return True
697
+ run = self.db.get_run(run_id) # поток мог успеть взять прогон в работу
698
+ if (run is not None and run["state"] == "running" and self._controls.get(run_id) != "stop"
699
+ and run.get("control") != "stop"):
700
+ try:
701
+ accepted = self.db.set_run_control(run_id, "pause")
702
+ except CommitUnknown:
703
+ self._controls[run_id] = "pause" # запись могла подтвердиться, а команду оператор дал
704
+ raise
705
+ if not accepted:
706
+ return False
707
+ self._controls[run_id] = "pause"
708
+ return True
709
+ return False
710
+
711
+ def resume(self, run_id: int) -> bool:
712
+ """Продолжить: прогон на паузе возвращается в очередь; у идущего снимается принятая пауза."""
713
+ with self._lock:
714
+ run = self.db.get_run(run_id)
715
+ if run is None:
716
+ return False
717
+ # пауза, у которой не записался итог: обработчик уже вышел, а в базе прогон ещё идёт – он тоже возвращается в очередь
718
+ stopping = self._controls.get(run_id) == "stop" or run.get("control") == "stop" # принятый «Стоп» важнее
719
+ if run["state"] == "paused" or (run["state"] == "running" and run_id in self._unsaved_pauses and not stopping):
720
+ # К11: находки с меткой отправки без результата – «результат неизвестен», снова не отправляются
721
+ self.db.settle_sending_items(run_id)
722
+ if run["state"] == "paused": # пауза уже в базе; записать её заново после этого «Продолжить» нельзя и при обрыве
723
+ self._unsaved_pauses.pop(run_id, None)
724
+ ok = self.db.set_run_state(run_id, "queued", last_error="", only_from=(run["state"],))
725
+ if ok:
726
+ # отложенная пауза не должна отменить это «Продолжить»
727
+ self._unsaved_pauses.pop(run_id, None)
728
+ self._controls.pop(run_id, None)
729
+ self._wake.set()
730
+ return ok
731
+ if run["state"] == "running" and self._controls.get(run_id) == "pause":
732
+ self.db.set_run_control(run_id, "")
733
+ del self._controls[run_id]
734
+ return True
735
+ return False
736
+
737
+ def stop(self, run_id: int) -> bool:
738
+ """Стоп: прогон в очереди или на паузе – сразу, идущий – после текущей находки. Принятая команда идущего
739
+ прогона сначала записывается в базу: если приложение перезапустится раньше, чем закончится текущая
740
+ находка, прогон при запуске будет остановлен, а не поставлен на паузу."""
741
+ with self._lock:
742
+ run = self.db.get_run(run_id)
743
+ if run is None:
744
+ return False
745
+ if run["state"] in ("queued", "paused") and self.db.set_run_state(
746
+ run_id, "stopped", only_from=("queued", "paused")):
747
+ return True
748
+ run = self.db.get_run(run_id)
749
+ if run is not None and run["state"] == "running":
750
+ try:
751
+ accepted = self.db.set_run_control(run_id, "stop")
752
+ except CommitUnknown:
753
+ self._controls[run_id] = "stop" # запись могла подтвердиться, а команду оператор дал: прогон остановится
754
+ raise
755
+ if accepted:
756
+ self._controls[run_id] = "stop"
757
+ return True
758
+ return False
759
+
760
+ def _apply_control(self, run_id: int) -> bool:
761
+ """Между находками: выполнить принятую команду. True – прогон остановлен или поставлен на паузу."""
762
+ with self._lock:
763
+ control = self._controls.get(run_id)
764
+ if control is None:
765
+ return False
766
+ self.db.set_run_state(run_id, "stopped" if control == "stop" else "paused", only_from=("running",))
767
+ self._controls.pop(run_id, None) # после записи: занятая база при повторе не потеряет команду
768
+ if control == "stop":
769
+ self._slow.pop(run_id, None)
770
+ return True
771
+
772
+ def _finish(self, run_id: int, state: str, last_error: str | None = None) -> None:
773
+ """Перевести идущий прогон в state. Если принят стоп, вместо паузы прогон останавливается."""
774
+ with self._lock:
775
+ control = self._controls.get(run_id)
776
+ if control == "stop" and state == "paused":
777
+ state = "stopped"
778
+ self.db.set_run_state(run_id, state, last_error=last_error, only_from=("running",))
779
+ self._controls.pop(run_id, None) # после записи: занятая база при повторе не потеряет принятый стоп
780
+ if state in FINAL_RUN_STATES:
781
+ self._slow.pop(run_id, None)
782
+
783
+ def _set_live(self, run_id: int, **values: Any) -> None:
784
+ with self._lock:
785
+ if 'since' in values:
786
+ values['since_monotonic'] = time.monotonic() if values['since'] is not None else None
787
+ if values.get('phase') and values.get('phase') != self._live.get(run_id,{}).get('phase'):
788
+ values['phase_since'] = time.time()
789
+ self._live.setdefault(run_id, {}).update(values)
790
+
791
+ # ---------------------------------------------------------------- состояние для страницы прогона
792
+
793
+ def run_status(self, run_id: int) -> dict | None:
794
+ """Состояние прогона: счётчики, скорость, оценка оставшегося времени, текущая находка, лента."""
795
+ run = self.db.get_run(run_id)
796
+ if run is None:
797
+ return None
798
+ with self._lock:
799
+ live = dict(self._live.get(run_id) or {})
800
+ control = self._controls.get(run_id)
801
+ active = run["state"] in ACTIVE_RUN_STATES
802
+ pending, calls = self.db.pending_model_groups(run_id) if active else (0, 0)
803
+ # среднее время ответа модели – без загрузки модели в память (её время – только у первой находки)
804
+ avg_call = run["model_seconds"] / run["model_calls"] if run["model_calls"] else None
805
+ from app.journal import eta_average
806
+ estimate = eta_average(self.db, run_id)
807
+ eta = round(calls * estimate) if run['state'] == 'running' and estimate is not None else None
808
+ tps_avg = run["output_tokens"] / run["eval_seconds"] if run["eval_seconds"] > 0 else None
809
+ # удалённый API: видеокарта и память этого компьютера к прогону не относятся, скорость генерации сервер не
810
+ # сообщает – скорость ответа считается по времени модели (с ожиданием сервера)
811
+ execution = self.db.get_execution(run.get("execution_id")) if run.get("execution_id") else None
812
+ remote = str((execution or {}).get("kind") or "ollama") in REMOTE_KINDS
813
+ if remote and tps_avg is None and run["model_seconds"] > 0 and run["output_tokens"]:
814
+ tps_avg = run["output_tokens"] / run["model_seconds"]
815
+ # длительность – время работы над находками: паузы и простой после перезапуска не входят
816
+ elapsed = None
817
+ if run["started_at"]:
818
+ working = self.db.run_work_seconds(run_id)
819
+ if run["state"] == "running" and live.get("since"):
820
+ working += max(0.0, time.monotonic() - live.get('since_monotonic', time.monotonic()))
821
+ elapsed = round(working)
822
+ current = None
823
+ if run["state"] == "running" and live.get("hub_id") and live.get("since"):
824
+ current = {"hub_id": live.get("hub_id"), "finding_id": live.get("finding_id"),
825
+ "phase": live.get("phase", ""), "seconds": round(max(0, time.monotonic() - live.get('since_monotonic', time.monotonic()))),
826
+ **{k:live.get(k) for k in ('phase_since','request_started_at','last_model_event_at','attempt')}}
827
+ total = int(run["total"] or 0)
828
+ new_verdicts = run["done"] - run["cached"] - run["skipped"] - run["failed"]
829
+ feed = self.db.recent_items(run_id, FEED_SIZE)
830
+ from app import journal
831
+ slow = journal.slow_model_state(self.db, run_id)
832
+ return {
833
+ "run": {key: run[key] for key in ("id", "project_id", "state", "scope", "model", "prompt_version",
834
+ "fresh", "total", "done", "failed", "cached", "skipped",
835
+ "model_calls", "last_error", "created_at", "started_at",
836
+ "finished_at", "partial_stats")},
837
+ "new_verdicts": max(0, new_verdicts),
838
+ "progress": round(100.0 * run["done"] / total, 1) if total else 100.0,
839
+ "pending": pending,
840
+ "eta_s": eta,
841
+ "avg_call_s": round(avg_call, 1) if avg_call is not None else None,
842
+ "elapsed_s": elapsed,
843
+ # у удалённого API последней скорости генерации нет – на её месте средняя скорость ответа
844
+ "tps_last": (round(tps_avg, 1) if remote and tps_avg else
845
+ round(run["last_tps"], 1) if run["last_tps"] else None),
846
+ "tps_avg": round(tps_avg, 1) if tps_avg else None,
847
+ "remote_executor": remote,
848
+ "remote_where": {"external": "у внешнего провайдера (интернет)", "lan": "на сервере в сети организации"}.get(
849
+ str((execution or {}).get("trust") or ""), "на сервере провайдера") if remote else "",
850
+ "control": control,
851
+ "current": current,
852
+ "feed": feed,
853
+ "last_result_at": feed[0]['finished_at'] if feed else None,
854
+ "slow_model": ({key: slow.get(key) for key in ("tps", "baseline", "reloads", "text", "warning")}
855
+ if slow.get("text") else None),
856
+ "journal_warning": model_traffic.failure_text(run_id),
857
+ }
858
+
859
+ # ---------------------------------------------------------------- поток
860
+
861
+ def _loop(self, halt: threading.Event) -> None:
862
+ """Диспетчер очереди. Не завершается от ошибок: сбой базы – подождать и попробовать снова."""
863
+ while not halt.is_set():
864
+ try:
865
+ self._save_pending_errors()
866
+ run = self.db.next_queued_run()
867
+ except Exception as e:
868
+ log_failure(log, "очередь прогонов недоступна", e)
869
+ halt.wait(WORKER_POLL_S)
870
+ continue
871
+ if run is None:
872
+ self._wake.wait(WORKER_POLL_S)
873
+ self._wake.clear()
874
+ continue
875
+ run_id = int(run["id"])
876
+ try:
877
+ with model_traffic.context(run_id=run_id): # сбой журнала при любом обращении прогона – в его учёт
878
+ self._process_run(run_id, halt)
879
+ except BUSY_ERRORS as e: # база занята, недоступна или исход записи неизвестен: данные целы, это не ошибка прогона
880
+ log_failure(log, "прогон %s на паузе: база занята или исход записи неизвестен", e, run_id)
881
+ self._pause_after_db_failure(run_id, DB_UNKNOWN_PAUSE if isinstance(e, CommitUnknown) else DB_RUN_PAUSE)
882
+ except Exception as e: # прогон не должен оставаться «идёт» после сбоя
883
+ eid = log_failure(log, "прогон %s прерван внутренней ошибкой", e, run_id)
884
+ self._mark_error(run_id, f"Внутренняя ошибка {type(e).__name__} (ошибка {eid}). Подробности – "
885
+ "в журнале контейнера.")
886
+ finally:
887
+ with self._lock:
888
+ # отложенной паузе нужен принятый «Стоп»: он мог остаться только в памяти
889
+ if run_id not in self._unsaved_pauses or self._controls.get(run_id) != "stop":
890
+ self._controls.pop(run_id, None)
891
+ self._live.pop(run_id, None)
892
+
893
+ def _pause_after_db_failure(self, run_id: int, note: str) -> None:
894
+ """Пауза прогона после сбоя записи вне обработки находки. Оставшийся в очереди тоже: иначе поток брал бы его снова и снова,
895
+ а следующие прогоны ждали бы. Завершённый не меняется; принятый «Стоп» (в памяти или в базе) важнее паузы. Сбой этой записи
896
+ не останавливает поток очереди: она повторится, когда база освободится (_save_pending_errors)."""
897
+ failure = None
898
+ with self._lock: # и запись, и её откладывание под одним замком: «Продолжить» не вклинится между ними
899
+ try:
900
+ run = self.db.get_run(run_id) or {}
901
+ stop = self._controls.get(run_id) == "stop" or run.get("control") == "stop"
902
+ self.db.set_run_state(run_id, "stopped" if stop else "paused", last_error=note, only_from=("running", "queued"))
903
+ self._controls.pop(run_id, None)
904
+ if (self.db.get_run(run_id) or {}).get("state") in FINAL_RUN_STATES:
905
+ self._slow.pop(run_id, None)
906
+ except Exception as e:
907
+ failure = e
908
+ self._unsaved_pauses[run_id] = note
909
+ if failure is not None:
910
+ log_failure(log, "пауза прогона %s не записана, повторю позже", failure, run_id)
911
+
912
+ def _mark_error(self, run_id: int, text: str) -> None:
913
+ try:
914
+ self.db.set_run_state(run_id, "error", last_error=text, only_from=("running", "queued"))
915
+ with self._lock:
916
+ self._slow.pop(run_id, None)
917
+ except Exception as e:
918
+ log_failure(log, "состояние прогона %s не записано, повторю позже", e, run_id)
919
+ with self._lock:
920
+ self._unsaved_errors[run_id] = text
921
+
922
+ def _save_pending_errors(self) -> None:
923
+ with self._lock:
924
+ pauses = dict(self._unsaved_pauses)
925
+ for run_id, text in pauses.items():
926
+ with self._lock: # как _finish: принятый «Стоп» (в памяти или в базе) важнее паузы, снимается после записи
927
+ if run_id not in self._unsaved_pauses: # пока шёл обход, оператор нажал «Продолжить»
928
+ continue
929
+ run = self.db.get_run(run_id) or {}
930
+ stop = self._controls.get(run_id) == "stop" or run.get("control") == "stop"
931
+ self.db.set_run_state(run_id, "stopped" if stop else "paused", last_error=text, only_from=("running", "queued"))
932
+ self._unsaved_pauses.pop(run_id, None)
933
+ self._controls.pop(run_id, None)
934
+ if (self.db.get_run(run_id) or {}).get("state") in FINAL_RUN_STATES:
935
+ self._slow.pop(run_id, None)
936
+ with self._lock:
937
+ pending = dict(self._unsaved_errors)
938
+ for run_id, text in pending.items():
939
+ self.db.set_run_state(run_id, "error", last_error=text, only_from=("running", "queued"))
940
+ with self._lock:
941
+ self._unsaved_errors.pop(run_id, None)
942
+ self._slow.pop(run_id, None)
943
+
944
+ def _process_run(self, run_id: int, halt: threading.Event) -> None:
945
+ if not self.db.set_run_state(run_id, "running", last_error="", only_from=("queued",)):
946
+ return # прогон успели поставить на паузу или остановить
947
+ run = self.db.get_run(run_id)
948
+ project = self.db.get_project(run["project_id"]) if run is not None else None
949
+ if run is None or project is None:
950
+ self._finish(run_id, "error", "Проект прогона не найден.")
951
+ return
952
+ if run["prompt_version"] != PROMPT_VERSION:
953
+ self._finish(run_id, "error", f"Прогон начат с промптом {run['prompt_version']}, а приложение уже "
954
+ f"работает с {PROMPT_VERSION}: запустите новый прогон.")
955
+ return
956
+ settings = self.current_settings() # папки клонов; адрес, модель и параметры – из снимка исполнителя
957
+ execution = self.db.get_execution(run.get("execution_id"))
958
+ if execution is None: # прогон до 0.9.12 (остался в очереди после обновления): исполнителя не подменяем
959
+ self._finish(run_id, "paused", LEGACY_RUN_NOTE)
960
+ return
961
+ guard = send_guard(self.db, execution, project_id=run["project_id"])
962
+ try:
963
+ guard()
964
+ except SendNotAllowed as e:
965
+ self._finish(run_id, "paused", pause_text(e))
966
+ return
967
+ try: # клон могли обновить (git pull) после прошлой сверки: срезы по прежнему коду не берутся
968
+ changed = sync_revisions(self.db, settings, project)["changed"]
969
+ if changed: # имена кодовых баз в журнал не пишутся: журнал пересылают при сбоях
970
+ log.info("прогон %s: сменилась ревизия клонов у %d кодовых баз", run_id, len(changed))
971
+ except Exception as e:
972
+ log_failure(log, "ревизии клонов не сверены (прогон %s)", e, run_id)
973
+ client = client_for(self._client_factory, execution, guard, db=self.db,
974
+ project_id=run["project_id"])
975
+ options, _, think_rule = snapshot_options(execution)
976
+ gate = gate_for(execution) # группа права на генерацию – из снимка прогона (ADR-0104 п. 6), не пересчитывается
977
+ try:
978
+ client.check_url()
979
+ except LlmError as e: # адрес не из разрешённых: продолжать бессмысленно, пока адрес не исправлен
980
+ self._refresh_contexts(run, halt)
981
+ refused = self._refused(guard) # профиль выключили – пауза, а не ошибка адреса
982
+ self._finish(run_id, "paused" if refused else "error", refused or str(e))
983
+ return
984
+ # счёт обрывов без ответа – заново на каждый запуск и после «Продолжить» (каскад – пауза, _count_drop)
985
+ self._drops.pop(run_id, None)
986
+ self._drop_pause.pop(run_id, None)
987
+ # удалённые API – точное имя модели, Ollama – без регистра и «:latest» (ADR-0106 п. 7)
988
+ name_of = same_model(str(execution.get("kind") or "ollama"))
989
+ remote = str(execution.get("kind") or "ollama") in REMOTE_KINDS
990
+ try:
991
+ model_list = client.list_models()
992
+ names = {name_of(m.get("name", "")) for m in model_list}
993
+ except LlmError as e:
994
+ self._refresh_contexts(run, halt)
995
+ # отказ допуска (адрес не подтверждён, ключ задан для другого адреса) – со своей причиной и подсказкой
996
+ self._finish(run_id, "paused", self._refused(guard) or (
997
+ pause_text(e) if isinstance(e, SendNotAllowed) else f"{e} {pause_note(execution)}"))
998
+ return
999
+ if name_of(run["model"]) not in names:
1000
+ self._refresh_contexts(run, halt)
1001
+ refused = self._refused(guard) # модель пропала, а профиль за это время выключили: причина – профиль
1002
+ if refused:
1003
+ self._finish(run_id, "paused", refused)
1004
+ return
1005
+ self._finish(run_id, "error", (
1006
+ f"Модели «{run['model']}» нет в списке моделей сервера профиля: проверьте имя модели (оно "
1007
+ "сравнивается точно, с учётом регистра) в профиле или в параметрах проекта." if remote else
1008
+ f"Модели «{run['model']}» нет в Ollama. Загрузите её командой: ollama pull {run['model']}"))
1009
+ return
1010
+ # Паспорт окружения сохраняется при каждом продолжении, без зависимости от браузера.
1011
+ from app import __version__
1012
+ from app.journal import environment
1013
+ from app.metrics import gpu_stats
1014
+ from app.telemetry import host_snapshot
1015
+ selected_model = next((m for m in model_list if name_of(m.get('name', '')) == name_of(run['model'])), {})
1016
+ # видеокарта, память и процессор этого компьютера – только когда модель на нём (профиль local, ADR-0102 п. 9)
1017
+ local_host = host_metrics_of(execution)
1018
+ host = host_snapshot(settings.data_dir / 'telemetry' / 'host.json') if local_host else {'status': 'remote'}
1019
+ try:
1020
+ gpu = gpu_stats() if local_host else None
1021
+ except Exception:
1022
+ gpu = None # Необязательная метрика не останавливает разбор находок.
1023
+ hardware = ({'name': gpu.get('name'), 'memory_total_mb': gpu.get('memory_total_mb'),
1024
+ 'gpus': [{'name': g.get('name'), 'memory_total_mb': g.get('memory_total_mb')} for g in gpu.get('gpus', [])]} if gpu else None)
1025
+ environment(self.db, run_id, {
1026
+ 'app_version': __version__, 'prompt_version': run['prompt_version'],
1027
+ 'model': {key: selected_model.get(key) for key in ('name', 'digest', 'size', 'params', 'quant', 'family', 'context_length')},
1028
+ # параметры и уровень рассуждения – из снимка исполнителя (ADR-0102), а не из текущих настроек
1029
+ 'execution_id': execution['id'], 'provider_id': execution.get('provider_id'),
1030
+ 'options': {**DEFAULT_OPTIONS, **options},
1031
+ # по сведениям сервера (семейство и возможности модели); у рассуждающей – предел по остатку окна
1032
+ 'think': applied_think(think_rule, run['model'], {'details': {'family': selected_model.get('family') or ''},
1033
+ 'capabilities': selected_model.get('capabilities')}),
1034
+ 'think_limit': thinking_limit(execution, applied_think(
1035
+ think_rule, run['model'], {'details': {'family': selected_model.get('family') or ''},
1036
+ 'capabilities': selected_model.get('capabilities')}))[0],
1037
+ 'gpu': hardware, 'host_memory_total': (host.get('memory') or {}).get('total_bytes') if host.get('status') == 'fresh' else None,
1038
+ 'host_status': host.get('status'),
1039
+ 'code_revisions': self.db.revisions(project['id']),
1040
+ })
1041
+ slow_state = self._slow_state(run, execution) # ориентир: ответы прогона и прошлых прогонов того же исполнителя
1042
+
1043
+ def waiting_cancelled() -> bool: # ожидание права на генерацию прерывают остановка, «Пауза» и «Стоп»
1044
+ with self._lock:
1045
+ return halt.is_set() or run_id in self._controls
1046
+
1047
+ while True:
1048
+ if self._apply_control(run_id):
1049
+ return
1050
+ if halt.is_set():
1051
+ self._finish(run_id, "paused", "Приложение остановлено, прогон на паузе.")
1052
+ return
1053
+ item = self.db.next_pending_item(run_id)
1054
+ if item is None:
1055
+ self._finish(run_id, "done")
1056
+ return
1057
+ # право на генерацию – на всю находку (ADR-0099): вопрос к модели в это время получает отказ, а начатый
1058
+ # вопрос находка дожидается
1059
+ if not gate.acquire("triage", waiting_cancelled):
1060
+ if self._apply_control(run_id):
1061
+ return
1062
+ if halt.is_set():
1063
+ self._finish(run_id, "paused", "Приложение остановлено, прогон на паузе.")
1064
+ return
1065
+ continue # команду успели отменить («Продолжить» после «Пауза») – ждать права снова
1066
+ refused, busy_note = "", DB_BUSY_PAUSE
1067
+ try:
1068
+ problem = self._process_item(run, client, item, settings, execution)
1069
+ except BUSY_ERRORS as e:
1070
+ if isinstance(e, CommitUnknown):
1071
+ busy_note = DB_UNKNOWN_PAUSE
1072
+ log_failure(log, "результат находки неизвестен: связь с базой оборвалась (прогон %s)", e, run_id)
1073
+ else:
1074
+ log_failure(log, "результат находки не записан: база занята (прогон %s)", e, run_id)
1075
+ busy = True
1076
+ except SendNotAllowed as e: # профиль выключили во время прогона: запрос не ушёл, находка в очереди
1077
+ busy, problem, refused = False, "", pause_text(e)
1078
+ else:
1079
+ busy = False
1080
+ finally:
1081
+ gate.release()
1082
+ if refused:
1083
+ self._set_live(run_id, since=None)
1084
+ self._finish(run_id, "paused", refused)
1085
+ return
1086
+ if busy: # незавершённую находку «Продолжить» возьмёт снова, завершённую при потерянном ответе – нет
1087
+ self._set_live(run_id, since=None)
1088
+ self._pause_after_db_failure(run_id, busy_note)
1089
+ return
1090
+ self._set_live(run_id, since=None) # время находки уже учтено в длительности прогона
1091
+ if problem: # сервер не отвечает (или 402 у провайдера): находка остаётся в очереди, стоп важнее паузы
1092
+ self._finish(run_id, "paused", f"{problem} {pause_note(execution)}")
1093
+ return
1094
+ drop_note = self._drop_pause.pop(run_id, "")
1095
+ if drop_note: # каскад обрывов у провайдера: находка записана, дальше – пауза, а не новые запросы
1096
+ self._drops.pop(run_id, None)
1097
+ self._finish(run_id, "paused", drop_note)
1098
+ return
1099
+ if self._apply_control(run_id):
1100
+ return
1101
+ if slow_state.reload_pending and not halt.is_set():
1102
+ # Выгрузка – между находками: запрос к модели уже закончен, следующий загрузит её заново; выгрузка –
1103
+ # тоже обращение к модели и не должна прийтись на ответ на вопрос
1104
+ if gate.acquire("triage", waiting_cancelled):
1105
+ try:
1106
+ self._reload_slow_model(run, client, slow_state, halt)
1107
+ finally:
1108
+ gate.release()
1109
+ if self._apply_control(run_id):
1110
+ return
1111
+
1112
+ def _count_drop(self, run: Mapping[str, Any], dropped: bool) -> None:
1113
+ """Учёт обрывов без ответа у внешнего провайдера: находка с обрывом (даже если повтор ответил) продолжает
1114
+ серию, находка с ответом её прерывает. Серия DROP_STREAK_PAUSE подряд или больше DROP_SHARE_PAUSE прогона
1115
+ (но не меньше DROP_STREAK_PAUSE обрывов) – прогон встанет на паузу после этой находки (повтор не должен
1116
+ становиться бесконечным)."""
1117
+ run_id = int(run["id"])
1118
+ counts = self._drops.setdefault(run_id, {"drops": 0, "streak": 0, "done": 0})
1119
+ counts["done"] += 1
1120
+ if not dropped:
1121
+ counts["streak"] = 0
1122
+ return
1123
+ counts["drops"] += 1
1124
+ counts["streak"] += 1
1125
+ share = counts["drops"] > DROP_SHARE_PAUSE * max(1, int(run.get("total") or 0))
1126
+ if counts["streak"] >= DROP_STREAK_PAUSE or (counts["drops"] >= DROP_STREAK_PAUSE and share):
1127
+ self._drop_pause[run_id] = DROP_PAUSE_NOTE.format(drops=counts["drops"], done=counts["done"],
1128
+ streak=counts["streak"])
1129
+
1130
+ @staticmethod
1131
+ def _model_entry(client: OllamaClient, model: str) -> dict[str, Any]:
1132
+ """Запись /api/tags о модели, которая сейчас лежит на сервере под этим именем: digest весов (ADR-0084) и
1133
+ семейство (уровень рассуждения, ADR-0102); сведения недоступны – {}."""
1134
+ try:
1135
+ return dict(client.model_info(model))
1136
+ except LlmError:
1137
+ return {}
1138
+
1139
+ @staticmethod
1140
+ def _model_digest(client: OllamaClient, model: str, run: dict) -> str:
1141
+ """Digest весов модели, которые сейчас лежат в Ollama под этим именем (ADR-0084); сведения недоступны –
1142
+ пусто: ключ кэша тогда без digest, отправка всё равно проверит модель перед запросом."""
1143
+ try:
1144
+ return str(client.model_info(model).get("digest") or "")
1145
+ except LlmError:
1146
+ return ""
1147
+
1148
+ def _process_item(self, run: dict, client: OllamaClient, item: dict, settings: Settings | None = None,
1149
+ execution: Mapping[str, Any] | None = None) -> str:
1150
+ """Одна находка прогона. Возвращает текст ошибки, если Ollama перестала отвечать, иначе "".
1151
+ settings – действующие настройки прогона (папки клонов); execution – снимок исполнителя (ADR-0102): параметры
1152
+ генерации, правило уровня рассуждения и режим схемы ответа. SendNotAllowed (профиль выключен перед
1153
+ отправкой) поднимается выше: прогон встаёт на паузу."""
1154
+ settings = settings or self.settings
1155
+ if execution is None:
1156
+ execution = self.db.get_execution(run.get("execution_id"))
1157
+ if execution is None:
1158
+ raise SendNotAllowed("У прогона нет снимка исполнителя: запрос к модели не отправлен.")
1159
+ run_id, item_id, hub_id = int(run["id"]), int(item["id"]), str(item["hub_id"])
1160
+ project_id = int(run["project_id"])
1161
+ started = time.monotonic()
1162
+ # Находка, папка проекта и папка клона – одним снимком на каждую находку: их могли поменять во время
1163
+ # прогона. Результат привязывается, только если снимок к моменту сохранения не устарел (save_case).
1164
+ source = self.db.case_input(project_id, hub_id)
1165
+ if source is None or source.get("missing"):
1166
+ self.db.finish_item(run_id, item_id, "skipped", error="Находки нет в текущей выгрузке.")
1167
+ return ""
1168
+ f = Finding.from_dict(source["data"])
1169
+ self._set_live(run_id, hub_id=hub_id, finding_id=source["finding_id"], phase="context", since=time.time(),
1170
+ request_started_at=None,last_model_event_at=None,attempt=None)
1171
+ model = str(run["model"])
1172
+ options, _, think_rule = snapshot_options(execution)
1173
+ schema_mode = str(execution.get("schema_mode") or settings.model_json_schema)
1174
+ try:
1175
+ repo_dir, why = repo_dir_for(settings, {"repos_dir": source["repos_dir"]}, source_codebases(source, f), f)
1176
+ max_chars = CONTEXT_CHARS
1177
+ # Клона нет (или в нём нет файла находки), а срез с кодом сохранён – модель разбирает его (ADR-0072):
1178
+ # срез из одной строки выгрузки не должен затереть код, который уже в базе
1179
+ stored = self.db.get_case(project_id, hub_id)
1180
+ snapshot = snapshot_code(settings, source, stored)
1181
+ if snapshot is not None:
1182
+ ctx = snapshot[0]
1183
+ max_chars = int((stored or {}).get("context", {}).get("max_chars") or CONTEXT_CHARS)
1184
+ else:
1185
+ ctx = build_context(repo_dir, f, max_chars=max_chars, mask_key=self._mask_key, no_repo_note=why)
1186
+ except BUSY_ERRORS:
1187
+ raise
1188
+ except Exception as e:
1189
+ eid = log_failure(log, "контекст находки не собран (прогон %s)", e, run_id)
1190
+ self.db.finish_item(run_id, item_id, "error", error=failure_text("Не удалось собрать контекст", e, eid))
1191
+ return ""
1192
+ if snapshot is None and degrades(stored, ctx):
1193
+ # Полноценный срез в базе не заменяется строкой выгрузки (ADR-0072): ни срезом, ни кэшем, ни ответом
1194
+ self._keep_slice(settings, source, stored, project_id, hub_id)
1195
+ self.db.finish_item(run_id, item_id, "skipped", error=CLONE_GONE_NOTE)
1196
+ return ""
1197
+
1198
+ def store(chash: str, verdict_id: int | None, from_saved: bool = False, **measures: Any) -> bool | None:
1199
+ """Срез и привязка к вердикту; сбой записи – ошибка этой находки, а не прогона (None). max_chars –
1200
+ размер среза: карточка соберёт текущий код так же и сравнит с тем, что видела модель."""
1201
+ try:
1202
+ return retry_busy(lambda: self.db.save_case(project_id, hub_id, chash,
1203
+ {**case_context(f, ctx), "max_chars": max_chars},
1204
+ verdict_id, source, no_downgrade=True,
1205
+ from_snapshot=snapshot is not None or from_saved))
1206
+ except BUSY_ERRORS:
1207
+ raise
1208
+ except Exception as e:
1209
+ eid = log_failure(log, "срез находки не сохранён (прогон %s)", e, run_id)
1210
+ self.db.finish_item(run_id, item_id, "error", case_hash=chash,
1211
+ error=failure_text("Не удалось сохранить срез", e, eid), **measures)
1212
+ return None
1213
+
1214
+ for attempt in range(FIT_ATTEMPTS + 1):
1215
+ chash = case_hash(f, ctx)
1216
+ if not ctx.lines:
1217
+ linked = store(chash, None)
1218
+ if linked is not None:
1219
+ self.db.finish_item(run_id, item_id, "skipped", case_hash=chash,
1220
+ error=f"Нет кода для разбора: {ctx.note or ctx.status}." if linked
1221
+ else CHANGED_NOTE)
1222
+ return ""
1223
+ current = (stored or {}).get("verdict") or {}
1224
+ if (not run["fresh"] and stored and stored.get("verdict_id") and stored.get("case_hash") == chash
1225
+ and current.get("prompt_version") == PROMPT_VERSION):
1226
+ # У находки уже есть вердикт по этому же коду (в том числе «второе мнение» другой модели): обычный
1227
+ # прогон его не заменяет ответом из кэша – иначе решение по нему потеряло бы «Проверено». Решение
1228
+ # принято по другому коду (код вернулся к срезу модели, бэклог 114) – отметка снимается; только когда
1229
+ # срез построен по клону: подставленный сохранённый срез (клона нет) не доказывает смену кода (ADR-0072)
1230
+ if snapshot is None:
1231
+ retry_busy(lambda h=chash, n=max_chars: self.db.reopen_for_decision_code(project_id, hub_id, h, n,
1232
+ source))
1233
+ self.db.finish_item(run_id, item_id, "cached", case_hash=chash, verdict_id=stored["verdict_id"],
1234
+ seconds=time.monotonic() - started)
1235
+ return ""
1236
+ try:
1237
+ # mask_key: строка срабатывания из выгрузки попадает в промпт только маскированной
1238
+ messages = self._masked(build_sast_messages(f, ctx, mask_key=self._mask_key))
1239
+ except Exception as e:
1240
+ eid = log_failure(log, "промпт не собран (прогон %s)", e, run_id)
1241
+ # срез всё равно сохраняется: если код изменился, прежний вердикт к нему уже не относится
1242
+ if store(chash, None) is not None:
1243
+ self.db.finish_item(run_id, item_id, "error", case_hash=chash,
1244
+ error=failure_text("Не удалось собрать промпт", e, eid))
1245
+ return ""
1246
+ # Кэш по запросу целиком (ADR-0027, ADR-0084): сообщения, параметры генерации, режим схемы и digest
1247
+ # весов модели, который сейчас лежит в Ollama под этим именем. Ответ на другой запрос или от других
1248
+ # весов не подставляется; в прогоне «заново» – только ответ на этот же запрос, полученный в нём же.
1249
+ # удалённый API отпечатка весов и сведений о рассуждении не отдаёт: запись модели не запрашивается – иначе
1250
+ # перед каждой находкой уходил лишний GET /models провайдеру; кэш по запросу у
1251
+ # внешнего провайдера и так не читается (нет digest), рассуждение gpt-oss определяется по имени
1252
+ remote = str((execution or {}).get("kind") or "ollama") in REMOTE_KINDS
1253
+ entry = {} if remote else self._model_entry(client, model)
1254
+ digest = str(entry.get("digest") or "")
1255
+ # уровень рассуждения – по модели, которая сейчас лежит на сервере под этим именем (ADR-0102): одно и то же
1256
+ # значение уходит в ключ кэша и в тело запроса
1257
+ think = applied_think(think_rule, model, entry or None)
1258
+ # на каждую отправку – то же значение (по нему предел, срок и ключ); изменилось – отказ без запроса
1259
+ think_per_send = planned_think(think_rule, model, think)
1260
+ # рассуждающий запрос (think true) – свой срок и предел ответа: остаток окна после промпта, не больше
1261
+ # предела рассуждения (срез подбирается под обычный предел – код у модели рассуждение не отнимает)
1262
+ think_limit, call_timeout = thinking_limit(execution, think)
1263
+ sent_options = fit_thinking(options, think_limit, messages) if think_limit else options
1264
+ rkey = request_key(model, messages, sent_options, think, PROMPT_VERSION, model_digest=digest,
1265
+ json_schema=schema_mode, provider=provider_key(execution))
1266
+ # веса не удалось определить – кэш по запросу не читается и не пополняется: неизвестные веса не
1267
+ # считаются совпавшими; у внешнего провайдера отпечатка весов нет никогда – кэша по ключу нет (П4),
1268
+ # каждый разбор – новый запрос
1269
+ external = str(execution.get("trust") or "") == "external"
1270
+ if not digest or external:
1271
+ cached = None
1272
+ elif run["fresh"]:
1273
+ cached = self.db.verdict_by_request_in_run(run_id, rkey)
1274
+ else:
1275
+ cached = self.db.find_verdict_by_request(rkey)
1276
+ if cached is not None:
1277
+ seconds = time.monotonic() - started
1278
+ linked = store(chash, cached["id"], seconds=seconds)
1279
+ if linked is not None:
1280
+ self.db.finish_item(run_id, item_id, "cached" if linked else "skipped", case_hash=chash,
1281
+ verdict_id=cached["id"] if linked else None,
1282
+ error="" if linked else CHANGED_NOTE, seconds=seconds)
1283
+ return ""
1284
+ # окно и предел ответа – того сервера, куда уйдёт запрос (у удалённого API – из профиля за вычетом схемы
1285
+ # ответа, которую клиент добавит к сообщениям; KIMI-01)
1286
+ fit = fit_options(execution, options, json_overhead(client, VERDICT_FIELDS, VERDICT_REQUIRED,
1287
+ VERDICT_ENUMS, VERDICT_TYPES))
1288
+ size = prompt_size(execution) # оценка длины – та же, что у клиента перед отправкой
1289
+ if attempt == FIT_ATTEMPTS or prompt_fits(messages, fit, size):
1290
+ break
1291
+ # Плотный код (знаки вне ASCII и кириллицы) не помещается в окно контекста: срез сокращается на нужную
1292
+ # долю с запасом, иначе Ollama обрезала бы начало промпта вместе с системным сообщением. Совсем
1293
+ # маленький срез не нужен: такой промпт chat_json отклонит с понятной ошибкой.
1294
+ excess = (size or prompt_tokens)(messages) - (prompt_budget(fit) or 0)
1295
+ code = "\n".join(ctx.lines)
1296
+ keep = max(0.0, 1.0 - excess / max(1, estimate_tokens(code))) * 0.9
1297
+ smaller = int((len(code) + 10 * len(ctx.lines)) * keep)
1298
+ if snapshot is not None:
1299
+ break # срез из базы без клона не пересобрать: если не помещается, ответит проверка длины промпта
1300
+ if smaller < MIN_CONTEXT_CHARS:
1301
+ if max_chars <= MIN_CONTEXT_CHARS:
1302
+ break # max_chars остаётся размером того среза, который уйдёт модели
1303
+ smaller = MIN_CONTEXT_CHARS # меньше не сокращаем, но и наименьший срез пробуем
1304
+ max_chars = smaller
1305
+ try:
1306
+ ctx = build_context(repo_dir, f, max_chars=max_chars, mask_key=self._mask_key, no_repo_note=why)
1307
+ except Exception as e:
1308
+ eid = log_failure(log, "контекст находки не собран (прогон %s)", e, run_id)
1309
+ self.db.finish_item(run_id, item_id, "error",
1310
+ error=failure_text("Не удалось собрать контекст", e, eid))
1311
+ return ""
1312
+ if degrades(stored, ctx): # файл пропал, пока срез сокращался
1313
+ self._keep_slice(settings, source, stored, project_id, hub_id)
1314
+ self.db.finish_item(run_id, item_id, "skipped", error=CLONE_GONE_NOTE)
1315
+ return ""
1316
+ # Новый срез – до обращения к модели: если код изменился, прежний вердикт к нему уже не относится
1317
+ # (save_case отвязывает его и снимает отметку «проверено»), даже если модель ответит ошибкой.
1318
+ linked = store(chash, None)
1319
+ if linked is None:
1320
+ return ""
1321
+ if not linked:
1322
+ self.db.finish_item(run_id, item_id, "skipped", case_hash=chash, error=CHANGED_NOTE)
1323
+ return ""
1324
+ self._set_live(run_id, phase="model")
1325
+ last_progress = [0.0]
1326
+ def progress(event):
1327
+ now=time.monotonic()
1328
+ if event['event']=='fragment':
1329
+ if now-last_progress[0]>=1:
1330
+ self._set_live(run_id,phase='generating',last_model_event_at=time.time())
1331
+ last_progress[0]=now
1332
+ elif event['event']=='request_started':
1333
+ last_progress[0]=0
1334
+ self._set_live(run_id,phase='waiting',request_started_at=time.time(),last_model_event_at=None,attempt=event['attempt'])
1335
+ elif event['event']=='response_done':self._set_live(run_id,phase='validating',last_model_event_at=time.time())
1336
+ if external:
1337
+ # К11: метка отправки – до сетевого вызова; перезапуск с меткой – «результат неизвестен», повтора нет
1338
+ self.db.mark_item_sending(run_id, item_id)
1339
+ try:
1340
+ # validate – проверка ответа по существу (пустой fix у истинной, комментарий для Hub без текста):
1341
+ # замечания ведут к повтору, как ответ не по формату. Контекст журнала обмена с моделью: обращения
1342
+ # внутри вызова (в том числе /api/tags перед отправкой кода) помечаются прогоном и находкой.
1343
+ with model_traffic.context(purpose="triage", run_id=run_id, hub_id=hub_id, project_id=project_id):
1344
+ client.timeout = call_timeout # срок одного обращения: у рассуждающего запроса – свой
1345
+ drop_error: LlmError | None = None
1346
+ while True:
1347
+ try:
1348
+ obj, stats = client.chat_json(model, messages, VERDICT_FIELDS, VERDICT_REQUIRED, VERDICT_ENUMS,
1349
+ options=sent_options, think=think_per_send, types=VERDICT_TYPES,
1350
+ validate=check_verdict_answer, progress=progress,
1351
+ json_schema=schema_mode)
1352
+ break
1353
+ except (SendNotAllowed, PromptOverflowError) as e:
1354
+ if drop_error is not None:
1355
+ # первый запрос оборвался (исход неизвестен), а повтор не ушёл: профиль выключен, отметка
1356
+ # снята, окно – находка остаётся «результат неизвестен», а не возвращается в очередь,
1357
+ # иначе «Продолжить» отправил бы её снова (ревью Codex, круг 18, блокирующее)
1358
+ raise _after_drop(drop_error, e) from e
1359
+ raise
1360
+ except LlmError as e:
1361
+ # обрыв без ответа у внешнего провайдера с отметкой профиля «Повторять после обрыва» – один
1362
+ # повтор на находку (ADR-0107); второй обрыв – «результат
1363
+ # неизвестен»; метка отправки стоит до конца: перезапуск между попытками – тоже «неизвестен»
1364
+ if (drop_error is None and external and outcome_unknown(e) and not getattr(e, "reason", None)
1365
+ and drop_retry_allowed(execution)):
1366
+ drop_error = e
1367
+ log.info("обрыв без ответа – автоматический повтор (прогон %s, находка %s)", run_id, hub_id)
1368
+ continue
1369
+ if drop_error is not None:
1370
+ if not model_answered(e) and not outcome_unknown(e):
1371
+ # повтор без ответа модели (402, ошибка сервера, сбой до отправки, кончились срок или
1372
+ # предел отправок – запрос не ушёл) – исход первого запроса по-прежнему неизвестен
1373
+ raise _after_drop(drop_error, e) from e
1374
+ e.drop_retries = 1 # type: ignore[attr-defined]
1375
+ e.stats = _merged_stats(drop_error.stats, e.stats)
1376
+ raise
1377
+ if drop_error is not None:
1378
+ # расход оборванной попытки – вместе с ответом повтора (ревью Codex, круг 18)
1379
+ stats = _merged_stats(drop_error.stats, stats)
1380
+ stats.drop_retries = 1
1381
+ if external:
1382
+ self._count_drop(run, drop_error is not None)
1383
+ except SendNotAllowed:
1384
+ # профиль выключен или отметка проекта снята перед отправкой (в том числе перед повтором – исход прежней
1385
+ # попытки известен): запрос не ушёл – метка снимается, находка остаётся в очереди, прогон – на паузу
1386
+ if external:
1387
+ self.db.mark_item_sending(run_id, item_id, sending=False)
1388
+ raise
1389
+ except PromptOverflowError as e:
1390
+ # Оценка длины промпта – эвристика с запасом (llm.estimate_tokens, llm.PROMPT_SAFETY_SHARE). Если сама
1391
+ # Ollama насчитала в промпте любой из попыток больше, чем помещается в окно вместе с ответом, начало
1392
+ # промпта могло быть обрезано вместе с системным сообщением: такому ответу не доверяем (chat_json).
1393
+ measures = self._measures(e.stats, time.monotonic() - started)
1394
+ # у удалённого API это отказ его клиента до отправки по окну профиля (запрос не ушёл, не оплачен): совет
1395
+ # про MODEL_NUM_CTX Ollama здесь ложный – текст клиента и совет про профиль
1396
+ remote_kind = str((execution or {}).get("kind") or "ollama") in REMOTE_KINDS
1397
+ text = f"{e} {REMOTE_WINDOW_NOTE}" if remote_kind and not getattr(e, "sent", False) else PROMPT_DOUBT_NOTE
1398
+ self.db.finish_item(run_id, item_id, "error", case_hash=chash, error=text, **measures)
1399
+ return ""
1400
+ except LlmError as e:
1401
+ partial = _stats_partial(e)
1402
+ if external and outcome_unknown(e):
1403
+ # К11: байты ушли, ответа нет (или он от посредника) – «результат неизвестен»: ошибка этой находки,
1404
+ # больше не отправляется (автоповтор после обрыва, если включён в профиле, уже был); метка снимается
1405
+ # вместе с записью результата
1406
+ measures = self._measures(e.stats, time.monotonic() - started)
1407
+ retry_error = str(getattr(e, "retry_error", "") or "")
1408
+ again = (f" Автоматический повтор после обрыва не получил ответа модели: {retry_error}" if retry_error
1409
+ else " Автоматический повтор после обрыва тоже остался без ответа."
1410
+ if getattr(e, "drop_retries", 0) else "")
1411
+ self.db.finish_item(run_id, item_id, "error", case_hash=chash,
1412
+ error=f"{UNKNOWN_RESULT_NOTE} {e}{again}", stats_partial=partial, **measures)
1413
+ self._count_drop(run, True)
1414
+ # повтор после обрыва получил 402: следующие находки тоже не примут – пауза по оплате, как без обрыва
1415
+ return PAYMENT_NOTE if getattr(e, "retry_status", None) == 402 else ""
1416
+ if external and getattr(e, "reason", None):
1417
+ # ответ получен: серия обрывов прервана, если обрыва не было; обрыв, после которого повтор получил
1418
+ # известный отказ, – тоже обрыв (ревью Codex, круг 18)
1419
+ self._count_drop(run, bool(getattr(e, "drop_retries", 0)))
1420
+ if getattr(e, "reason", None):
1421
+ # известный окончательный исход (ответ получен и разобран, ADR-0106): находка – ошибка сразу, с
1422
+ # расходом ответа; служебный опрос сервера не нужен – его сбой не оставит находку в очереди и не
1423
+ # отправит её заново после «Продолжить» (ревью круг 15, находка 1); метка отправки снимается записью
1424
+ measures = self._measures(e.stats, time.monotonic() - started)
1425
+ self.db.finish_item(run_id, item_id, "error", case_hash=chash,
1426
+ error=str(e) + (PARTIAL_NOTE if partial else ""), stats_partial=partial, **measures)
1427
+ return ""
1428
+ if external and getattr(e, "status", None) == 402:
1429
+ # нужна оплата: запрос провайдер не принял – метка снимается, находка остаётся в очереди, прогон –
1430
+ # на паузу с причиной
1431
+ self.db.mark_item_sending(run_id, item_id, sending=False)
1432
+ return PAYMENT_NOTE
1433
+ if not self._server_alive(client):
1434
+ if external: # ответ сервера был (или запрос не ушёл) – исход известен, метка снимается
1435
+ self.db.mark_item_sending(run_id, item_id, sending=False)
1436
+ return str(e)
1437
+ # Модель могла сгенерировать ответ не по формату: её токены и время входят в среднюю скорость
1438
+ # прогона; после сбоя связи замеры прерванной попытки неизвестны – находка помечается
1439
+ measures = self._measures(e.stats, time.monotonic() - started)
1440
+ self.db.finish_item(run_id, item_id, "error", case_hash=chash,
1441
+ error=str(e) + (PARTIAL_NOTE if partial else ""), stats_partial=partial, **measures)
1442
+ return ""
1443
+ eta_sample = self._observe_speed(run, stats)
1444
+ self._set_live(run_id, phase='saving')
1445
+ seconds = time.monotonic() - started
1446
+ measures = self._measures(stats, seconds)
1447
+ try:
1448
+ # срез, который видела модель (в том же представлении, что в промпте): номера строк-доказательств вне
1449
+ # него отбрасываются, при сверке differs уверенность ограничена (ADR-0080)
1450
+ verdict = parse_verdict(obj, export_fragment_view(f, ctx))
1451
+ except Exception as e: # неожиданный сбой разбора ответа – ошибка этой находки, прогон идёт дальше
1452
+ eid = log_failure(log, "ответ модели не разобран (прогон %s)", e, run_id)
1453
+ self.db.finish_item(run_id, item_id, "error", case_hash=chash,
1454
+ error=failure_text("Ответ модели не разобран", e, eid), **measures)
1455
+ return ""
1456
+ # последняя проверка перед сохранением – после всей нормализации вердикта (сервер с ключом мог вернуть его)
1457
+ if model_traffic.shows_secret([verdict.to_dict(), stats.to_dict()], getattr(client, "secrets", ())):
1458
+ self.db.finish_item(run_id, item_id, "error", case_hash=chash, error=model_traffic.KEY_IN_ANSWER,
1459
+ **measures)
1460
+ return ""
1461
+ try:
1462
+ # веса под этим именем сменились, пока модель отвечала, – ответ не кладётся под ключ прежних весов;
1463
+ # ответ на повтор (замечание о формате, другой seed) – ответ на другой запрос, под ключ первого не кладётся;
1464
+ # сервер отверг схему ответа – запрос ушёл без неё, под ключ со схемой тоже не кладётся
1465
+ dropped = getattr(client, "schema_dropped", None)
1466
+ saved_key = rkey if (digest and stats.attempts == 1 and not (callable(dropped) and dropped())
1467
+ and self._model_digest(client, model, run) == digest) else ""
1468
+ reserved = retry_busy(self.db.reserve_verdict_id)
1469
+ verdict_id = retry_busy(lambda: self.db.save_verdict(chash, model, PROMPT_VERSION, verdict.to_dict(),
1470
+ stats.to_dict(), request_key=saved_key,
1471
+ execution_id=int(execution["id"]),
1472
+ verdict_id=reserved))
1473
+ except BUSY_ERRORS:
1474
+ raise # занятая база – пауза прогона, находка остаётся в очереди (Э2)
1475
+ except Exception as e: # сбой записи – ошибка этой находки, а не всего прогона
1476
+ eid = log_failure(log, "вердикт не сохранён (прогон %s)", e, run_id)
1477
+ self.db.finish_item(run_id, item_id, "error", case_hash=chash,
1478
+ error=failure_text("Не удалось сохранить вердикт", e, eid), **measures)
1479
+ return ""
1480
+ # Пока модель отвечала, код в клоне могли поменять (правки в рабочей копии, git pull): ответ сохранён в кэше
1481
+ # для того кода, который она видела, но к находке не привязывается – иначе он выглядел бы действующим.
1482
+ # клон удалили, пока модель отвечала: поздняя сверка берёт сохранённый срез – и сохранение знает об этом,
1483
+ # подставленный срез сменой кода не считается (ADR-0072, ревью Codex ветки долга, круг 4)
1484
+ late_saved = {"used": False}
1485
+
1486
+ def late_snapshot():
1487
+ got = snapshot_code(settings, source, self.db.get_case(project_id, hub_id))
1488
+ late_saved["used"] = got is not None
1489
+ return got
1490
+
1491
+ if snapshot is None and self._code_changed(f, repo_dir, max_chars, chash, late_snapshot):
1492
+ self.db.finish_item(run_id, item_id, "skipped", case_hash=chash, error=CODE_CHANGED_NOTE, **measures)
1493
+ return ""
1494
+ linked = store(chash, verdict_id, from_saved=late_saved["used"], **measures)
1495
+ if linked is None:
1496
+ return ""
1497
+ if linked:
1498
+ # после обрыва замеры неполные: что модель успела сгенерировать в оборванной попытке, неизвестно; время
1499
+ # находки с повтором – не образец для оценки оставшегося
1500
+ retry_busy(lambda: self.db.finish_item(run_id, item_id, "done", case_hash=chash, verdict_id=verdict_id,
1501
+ eta_sample=eta_sample and not stats.drop_retries,
1502
+ stats_partial=bool(stats.drop_retries), **measures))
1503
+ else:
1504
+ retry_busy(lambda: self.db.finish_item(run_id, item_id, "skipped", case_hash=chash, error=CHANGED_NOTE,
1505
+ **measures))
1506
+ return ""
1507
+
1508
+ # ---------------------------------------------------------------- медленный режим модели
1509
+
1510
+ @staticmethod
1511
+ def _refused(guard: Callable[[], None]) -> str:
1512
+ """Текст паузы, если допуск профиля снимка уже не действует ("" – действует): сбой перед первой отправкой
1513
+ сначала сверяется с допуском (ADR-0102), чтобы выключенный профиль давал паузу, а не ошибку."""
1514
+ try:
1515
+ guard()
1516
+ except SendNotAllowed as e:
1517
+ return pause_text(e)
1518
+ return ""
1519
+
1520
+ def _slow_state(self, run: dict, execution: Mapping[str, Any] | None = None) -> _SlowState:
1521
+ """Состояние замедления прогона: ответы текущего прогона из базы, медиана прошлых прогонов той же конфигурации
1522
+ исполнителя (протокол, адрес, модель – ADR-0102, П24) и записанные в журнал перезагрузки. Читается один раз
1523
+ за прогон; продолжение после паузы берёт готовое. Выгружать модель можно, только если снимок это разрешает."""
1524
+ run_id = int(run["id"])
1525
+ state = self._slow.get(run_id)
1526
+ if state is not None:
1527
+ return state
1528
+ state = _SlowState()
1529
+ if execution is None:
1530
+ execution = self.db.get_execution(run.get("execution_id"))
1531
+ state.unload_allowed = unload_allowed_of(execution)
1532
+ executor = (str(execution["kind"]), str(execution["base_url"])) if execution else None
1533
+ try:
1534
+ state.samples = self.db.run_tps_samples(run_id, SLOW_BASELINE_WINDOW)
1535
+ history = self.db.model_tps_samples(str(run["model"]), exclude_run_id=run_id, limit=SLOW_HISTORY_WINDOW,
1536
+ executor=executor)
1537
+ state.history_median = _median(history) if len(history) >= SLOW_BASELINE_MIN else None
1538
+ state.history_typical = _median(history)
1539
+ state.history_fast = any(value > SLOW_TPS_KNOWN_FAST for value in history)
1540
+ from app import journal
1541
+ saved = journal.slow_model_state(self.db, run_id)
1542
+ state.reloads = int(saved.get("reloads") or 0)
1543
+ state.text = str(saved.get("text") or "")
1544
+ state.warning = bool(saved.get("warning"))
1545
+ except Exception as e:
1546
+ log_failure(log, "состояние медленного режима не прочитано (прогон %s)", e, run_id)
1547
+ self._slow[run_id] = state
1548
+ return state
1549
+
1550
+ def _observe_speed(self, run: dict, stats: Any) -> bool:
1551
+ """Учесть скорость законченного ответа. True – ответ годится для оценки оставшегося времени, False –
1552
+ медленный ответ (до перезагрузки) или первый ответ после загрузки модели. При медленном режиме
1553
+ помечает перезагрузку (её выполнит _reload_slow_model между находками) или записывает предупреждение.
1554
+ """
1555
+ tps = float(getattr(stats, "eval_tps", 0) or 0)
1556
+ if tps <= 0:
1557
+ return True
1558
+ state = self._slow_state(run)
1559
+ previous = state.samples[-SLOW_BASELINE_WINDOW:]
1560
+ reference = _median(previous) if len(previous) >= SLOW_BASELINE_MIN else state.history_median
1561
+ baseline = reference if reference is not None else (state.history_typical or tps)
1562
+ first_after_reload = state.after_reload
1563
+ state.after_reload = False
1564
+ if first_after_reload: # загрузка модели после перезагрузки: ответ не показатель режима
1565
+ state.streak = 0
1566
+ return False
1567
+ if reference is not None and reference > 0:
1568
+ slow = tps < reference * SLOW_TPS_SHARE
1569
+ elif state.history_fast:
1570
+ # Ориентира ещё нет: у моделей, которые раньше давали больше SLOW_TPS_KNOWN_FAST, два ответа
1571
+ # подряд ниже абсолютного порога уже говорят о медленном режиме.
1572
+ slow = tps < SLOW_TPS_ABSOLUTE
1573
+ else:
1574
+ slow = False
1575
+ if not slow:
1576
+ # Ориентир – медиана успешных ответов обычной скорости: медленные ответы её не сдвигают вниз,
1577
+ # иначе после первой же перезагрузки стало бы «нормально» медленно.
1578
+ state.samples.append(tps)
1579
+ state.samples = state.samples[-SLOW_BASELINE_WINDOW:]
1580
+ state.streak = 0
1581
+ return True
1582
+ state.streak += 1
1583
+ if state.streak < SLOW_STREAK:
1584
+ return False # медленный, но серия ещё не набрана: в оценку времени всё равно не берём
1585
+ state.streak = 0
1586
+ if state.reloads < SLOW_MAX_RELOADS and state.unload_allowed:
1587
+ state.reload_pending = True
1588
+ state.pending_tps = tps
1589
+ state.pending_baseline = baseline
1590
+ elif not state.warning:
1591
+ state.warning = True
1592
+ state.text = slow_model_status_text(tps, baseline, reloaded=False)
1593
+ if not state.unload_allowed: # общий сервер: выгружать модель профиль не разрешает (ADR-0102 п. 9)
1594
+ state.text += " Выгрузка модели на этом сервере не разрешена профилем."
1595
+ self._record_slow_event(run, "warning", tps, baseline, state)
1596
+ log.info("прогон %s: медленный режим модели не исправлен двумя перезагрузками (%s ток/с при обычных %s)",
1597
+ int(run["id"]), _tps_number(tps), _tps_number(baseline))
1598
+ return False
1599
+
1600
+ def _reload_slow_model(self, run: dict, client: OllamaClient, state: _SlowState,
1601
+ halt: threading.Event) -> None:
1602
+ """Выгрузить модель (keep_alive 0) и дождаться, что /api/ps её больше не показывает. Следующий запрос
1603
+ загрузит модель заново. Сбой выгрузки не останавливает прогон: предупреждение остаётся оператору."""
1604
+ run_id, project_id, model = int(run["id"]), int(run["project_id"]), str(run["model"])
1605
+
1606
+ def interrupted() -> bool:
1607
+ with self._lock:
1608
+ return halt.is_set() or run_id in self._controls
1609
+
1610
+ if not state.reload_pending or state.reloads >= SLOW_MAX_RELOADS or interrupted():
1611
+ return
1612
+ state.reload_pending = False
1613
+ tps, baseline = state.pending_tps, state.pending_baseline
1614
+ state.reloads += 1 # ошибка и прерванное ожидание тоже расходуют попытку
1615
+ try:
1616
+ with model_traffic.context(purpose="reload", run_id=run_id, project_id=project_id):
1617
+ client.unload_model(model)
1618
+ self._wait_unloaded(client, model, interrupted)
1619
+ except LlmError as e:
1620
+ state.warning = True
1621
+ state.text = f"Модель работала медленно – перезагрузить модель не удалось: {e}"
1622
+ self._record_slow_event(run, "warning", tps, baseline, state)
1623
+ log_failure(log, "модель не выгружена для перезагрузки (прогон %s)", e, run_id)
1624
+ return
1625
+ state.after_reload = True
1626
+ state.streak = 0
1627
+ state.warning = False
1628
+ state.text = slow_model_status_text(tps, baseline, reloaded=True)
1629
+ self._record_slow_event(run, "reload", tps, baseline, state)
1630
+ log.info("прогон %s: медленный режим модели (%s ток/с при обычных %s), модель выгружена",
1631
+ run_id, _tps_number(tps), _tps_number(baseline))
1632
+
1633
+ def _record_slow_event(self, run: dict, action: str, tps: float, baseline: float, state: _SlowState) -> None:
1634
+ """Событие медленного режима – в журнал прогона (страница «Журнал»). Сбой записи не мешает разбору."""
1635
+ try:
1636
+ from app import journal
1637
+ journal.slow_model_event(self.db, int(run["id"]), action=action, tps=tps, baseline=baseline,
1638
+ text=state.text, reloads=state.reloads)
1639
+ except Exception as e:
1640
+ log_failure(log, "событие медленного режима не записано (прогон %s)", e, int(run["id"]))
1641
+
1642
+ @staticmethod
1643
+ def _wait_unloaded(client: OllamaClient, model: str, interrupted: Callable[[], bool]) -> None:
1644
+ """Подтвердить выгрузку через /api/ps. Ошибка, истёкший срок и команда управления – не успех.
1645
+ Команды проверяются между опросами и сразу после ответа сервера."""
1646
+ wanted = norm_model_name(model)
1647
+ deadline = time.monotonic() + SLOW_RELOAD_WAIT_S
1648
+ while True:
1649
+ if interrupted():
1650
+ raise LlmError("ожидание выгрузки прервано командой управления.")
1651
+ if time.monotonic() >= deadline:
1652
+ raise LlmError(f"Ollama не подтвердила выгрузку за {SLOW_RELOAD_WAIT_S:g} с.")
1653
+ loaded = {norm_model_name(str(entry.get("name") or "")) for entry in client.ps()}
1654
+ if interrupted():
1655
+ raise LlmError("ожидание выгрузки прервано командой управления.")
1656
+ if time.monotonic() >= deadline:
1657
+ raise LlmError(f"Ollama не подтвердила выгрузку за {SLOW_RELOAD_WAIT_S:g} с.")
1658
+ if wanted not in loaded:
1659
+ return
1660
+ time.sleep(min(SLOW_RELOAD_POLL_S, max(0.0, deadline - time.monotonic())))
1661
+
1662
+ @staticmethod
1663
+ def _measures(stats: Any, seconds: float) -> dict[str, Any]:
1664
+ """Замеры ответа модели для finish_item; stats – LlmStats или None (сбой до первого ответа)."""
1665
+ measures: dict[str, Any] = {"seconds": seconds, "model_call": True}
1666
+ if stats is None:
1667
+ return measures
1668
+ measures.update(eval_tps=stats.eval_tps or None, output_tokens=stats.output_tokens,
1669
+ model_seconds=max(0.0, seconds - stats.load_s),
1670
+ eval_seconds=stats.output_tokens / stats.eval_tps if stats.eval_tps > 0 else 0.0)
1671
+ return measures
1672
+
1673
+ def _code_changed(self, f: Finding, repo_dir: Path | None, max_chars: int, chash: str,
1674
+ snapshot: Any = None) -> bool:
1675
+ """Код находки сейчас другой, чем в срезе с отпечатком chash. Не удалось прочитать – считается изменившимся:
1676
+ ответ про код, которого не видно, привязывать нельзя. snapshot() – срез из базы, если клон удалили, пока
1677
+ модель отвечала (snapshot_code): тогда сравнивается он, а не строка выгрузки (ADR-0072)."""
1678
+ try:
1679
+ late = snapshot() if snapshot is not None else None
1680
+ if late is not None:
1681
+ return late[1] != chash
1682
+ return case_hash(f, build_context(repo_dir, f, max_chars=max_chars, mask_key=self._mask_key)) != chash
1683
+ except BUSY_ERRORS:
1684
+ raise # занятая база – пауза прогона, а не «код изменился» (Э2)
1685
+ except Exception as e:
1686
+ log_failure(log, "срез находки не перечитан после ответа модели", e)
1687
+ return True
1688
+
1689
+ def _refresh_contexts(self, run: dict, halt: threading.Event) -> None:
1690
+ """Модель недоступна (Ollama не отвечает, модели нет, адрес не из разрешённых), а срезы находок прогона
1691
+ всё равно сверяются с текущим кодом: если код изменился (правки без смены ревизии, папка без .git),
1692
+ прежний вердикт отвязывается и отметка «проверено» снимается (save_case) – решение по прежнему коду
1693
+ не остаётся «проверенным» из-за того, что модель не ответила. Очередь прогона не меняется."""
1694
+ run_id, project_id = int(run["id"]), int(run["project_id"])
1695
+ for hub_id in self.db.pending_hub_ids(run_id):
1696
+ if halt.is_set():
1697
+ return
1698
+ try:
1699
+ stored = self.db.get_case(project_id, hub_id)
1700
+ source = self.db.case_input(project_id, hub_id)
1701
+ if stored is None or source is None:
1702
+ continue # среза нет – отвязывать нечего
1703
+ max_chars = int(stored["context"].get("max_chars") or CONTEXT_CHARS)
1704
+ f, ctx, chash, saved = current_code_origin(self.settings, source, self._mask_key, max_chars,
1705
+ case=stored)
1706
+ if chash == stored["case_hash"]:
1707
+ # срез тот же, а решение принято по другому коду (бэклог 114) – отметка снимается; если клона нет
1708
+ # и текущий код – сам сохранённый срез, сверять нечего (ADR-0072). Признак – у того же чтения:
1709
+ # файл мог вернуться в клон после него (ревью Codex ветки долга, круг 5)
1710
+ if not saved:
1711
+ self.db.reopen_for_decision_code(project_id, hub_id, chash, max_chars, source)
1712
+ continue
1713
+ if degrades(stored, ctx): # полноценный срез не ухудшается
1714
+ self._keep_slice(self.settings, source, stored, project_id, hub_id)
1715
+ continue
1716
+ self.db.save_case(project_id, hub_id, chash, {**case_context(f, ctx), "max_chars": max_chars},
1717
+ None, source, no_downgrade=True)
1718
+ except Exception as e:
1719
+ log_failure(log, "срез находки не сверен (прогон %s)", e, run_id)
1720
+
1721
+ def _keep_slice(self, settings: Settings, source: dict, stored: dict | None, project_id: int, hub_id: str) -> None:
1722
+ """Новый срез хуже сохранённого и не записывается (degrades). Если файл находки по-прежнему в клоне (его
1723
+ укоротили, путь стал неоднозначным), код под решением уже другой: отметка «проверено» снимается, срез
1724
+ остаётся. Если файл пропал (клон удаляют), код тот же – отметка остаётся."""
1725
+ if snapshot_code(settings, source, stored) is None:
1726
+ self.db.reopen_for_code_change(project_id, hub_id, source)
1727
+
1728
+ def _masked(self, messages: list[dict]) -> list[dict]:
1729
+ """Последняя сетка перед отправкой: маскирование всего текста сообщений с данными находки (путь файла,
1730
+ правило, заметки). Повторное маскирование уже замаскированного текста его не меняет.
1731
+
1732
+ env_style=False – как у среза кода в build_context: строка кода «КЛЮЧ=значение» не скрывается целиком,
1733
+ и модель видит тот же код, что человек в карточке. Поля находки prompts.py уже маскирует как текст."""
1734
+ return [{**m, "content": mask_text(str(m.get("content") or ""), self._mask_key, env_style=False)[0]}
1735
+ if m.get("role") == "user" else m for m in messages]
1736
+
1737
+ @staticmethod
1738
+ def _server_alive(client: OllamaClient) -> bool:
1739
+ try:
1740
+ client.version()
1741
+ except LlmError:
1742
+ return False
1743
+ return True