tensorgrid-ui 1.4.1 → 1.10.0

package/lib/index.js

@@ -220,10 +220,81 @@ export function apply(ctx) {
       })
     })
 
+    // Служба моделей нужна отдельным рядом: она отдаёт живой список
+    // подключённых моделей для выбора ревизора. Отдельным — потому что
+    // объединение с парой выше связало бы настройки обзора со стойкой
+    // входа: нет одной — пропала бы и другая, хотя они независимы.
+    const modelServices = { llm: null, generation: null }
+    web.inject(['llm'], (bound) => {
+      const generation = {}
+      modelServices.llm = bound.llm
+      modelServices.generation = generation
+      bound.effect(() => () => {
+        if (modelServices.generation !== generation) return
+        modelServices.llm = null
+        modelServices.generation = null
+      })
+    })
+
+    // ── ЗАСЛОН ДЛЯ НАШИХ МАРШРУТОВ ──────────────────────────────────────
+    //
+    // Берётся ШТАТНЫЙ, а не пишется свой. Это не перестраховка, а починка
+    // настоящей дыры, найденной обзором и подтверждённой на живом
+    // приложении:
+    //
+    //   /                      401   защищено
+    //   /api/любой-другой      401   защищено
+    //   /api/tensorgrid.auth   200   НАШ, без токена
+    //
+    // Приложение регистрирует на префикс `/api` обработчик с проверкой, а
+    // точное совпадение пути выигрывает у префикса. Наши точные маршруты не
+    // просто «не добавляли токен» — они ВЫРЕЗАЛИ из-под себя весь заслон.
+    //
+    // Штатная проверка делает три вещи, которых моя самодельная не делала:
+    // требует петлевой или явно доверенный Host (это и закрывает подмену
+    // имени), отклоняет запрос с `sec-fetch-site: cross-site` и лишь затем
+    // сверяет Origin. Плюс проверяет токен браузерной сессии.
+    const guard = { connection: null, generation: null }
+    web.inject(['connection'], (bound) => {
+      const generation = {}
+      guard.connection = bound.connection
+      guard.generation = generation
+      bound.effect(() => () => {
+        if (guard.generation !== generation) return
+        guard.connection = null
+        guard.generation = null
+      })
+    })
+
+    /**
+     * Отклонить запрос, если штатный заслон против.
+     *
+     * @returns true, если ответ уже отправлен и обработчику делать нечего.
+     */
+    function rejected(req, res) {
+      const connection = guard.connection
+      if (connection === null) {
+        // Заслона нет — значит браузерная часть не поднята. Открывать
+        // маршрут «пока суд да дело» нельзя: это ровно та дыра, что чиним.
+        res.writeHead(503, { 'content-type': 'application/json; charset=utf-8' })
+        res.end(JSON.stringify({ problem: 'проверка доступа недоступна' }))
+        return true
+      }
+      const rejection = connection.requestRejection(req)
+      if (rejection === undefined) return false
+      res.writeHead(rejection, { 'content-type': 'application/json; charset=utf-8' })
+      res.end(JSON.stringify({ problem: rejection === 401 ? 'требуется вход в приложение' : 'запрос отклонён' }))
+      return true
+    }
+
     // Манифест собирается в горячем модуле: он ЧИТАЕТ поставочный файл и
     // дополняет его нашими полями, а значит зависит от чужой формы, которая
     // может поменяться. Такую логику правильнее держать там, где её можно
     // поправить без перезапуска.
+    //
+    // Заслон сюда НЕ ставится намеренно: манифест и иконку браузер просит до
+    // всякого входа, и в поставке они тоже отдаются открыто. Секретов в них
+    // нет — только имя и цвета.
     web.effect(() =>
       web.webServer.register({
         kind: 'exact',
@@ -246,8 +317,9 @@ export function apply(ctx) {
         path: '/api/tensorgrid.review',
         async handler(req, res) {
           try {
+            if (rejected(req, res)) return
             const runtime = await loadModule('./http-runtime.js')
-            await runtime.handleReview(req, res, loadModule)
+            await runtime.handleReview(req, res, loadModule, modelServices)
           } catch (error) {
             fail(res, error)
           }
@@ -261,6 +333,7 @@ export function apply(ctx) {
         path: '/api/tensorgrid.auth',
         async handler(req, res) {
           try {
+            if (rejected(req, res)) return
             const runtime = await loadModule('./http-runtime.js')
             await runtime.handleAuth(req, res, authServices, loadModule)
           } catch (error) {
@@ -276,6 +349,7 @@ export function apply(ctx) {
         path: '/api/tensorgrid.update',
         async handler(req, res) {
           try {
+            if (rejected(req, res)) return
             const runtime = await loadModule('./http-runtime.js')
             await runtime.handleUpdate(req, res, updateState, loadModule)
           } catch (error) {

package/lib/review-log.js

@@ -0,0 +1,538 @@
+/**
+ * Журнал обзоров: что нашли ревизоры и что из этого подтвердилось.
+ *
+ * ЗАЧЕМ ЭТО НУЖНО
+ *
+ * Ревизор ошибается примерно в трети случаев. Сегодня это проверено трижды:
+ * из четырёх выборочно проверенных находок одна оказалась ложной, причём
+ * обоснованной — ревизор запустил проверку, получил верный результат и
+ * сделал из него неверный вывод, честно пометив, чего не смог проверить.
+ *
+ * Пока приговор выносится в переписке и там же теряется, происходят две
+ * плохие вещи. Пользователь видит только пересказ агента, то есть его
+ * фильтрацию вместе с его ошибками. И никто не знает, какой ревизор на какой
+ * модели чаще прав — а это единственная величина, по которой можно судить,
+ * стоит ли он своих денег.
+ *
+ * КТО СУДИТ
+ *
+ * Не тот, кто смотрит, а тот, кто делал работу. Просить человека, не
+ * разбирающегося в коде, решить «настоящая это ошибка или нет» — значит
+ * просить невозможного и получить в ответ случайные нажатия, которые ещё и
+ * будут выглядеть как данные.
+ *
+ * Поэтому приговор выносит агент и обязан приложить ДОКАЗАТЕЛЬСТВО: что
+ * именно он запустил или прочитал. Человек может возразить, но не обязан
+ * ничего решать.
+ *
+ * Импортируются только встроенные модули Node.
+ */
+import { readFile, rename, rm, writeFile } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { createHash, randomBytes } from 'node:crypto'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const FILE_NAME = 'tensorgrid-review-log.json'
+
+/**
+ * Сколько обзоров храним.
+ *
+ * Журнал нужен для статистики, а не для архива. Двести обзоров — это месяцы
+ * работы, и по ним уже видно, какой ревизор чаще прав. Расти бесконечно
+ * файлу нельзя: его читают при каждом открытии настроек.
+ */
+const MAX_RUNS = 200
+
+/**
+ * Пределы на объём.
+ *
+ * Ограничения числа обзоров недостаточно: в каждой находке до пяти полей, в
+ * обзоре до шестидесяти находок на ревизора, ревизоров трое. Без предела на
+ * ДЛИНУ полей двести обзоров дают сотни мегабайт, а файл читается целиком
+ * при каждом открытии настроек и при каждом нажатии в панели.
+ */
+const FIELD_CHARS = 1200
+const REQUEST_CHARS = 400
+const EVIDENCE_CHARS = 800
+
+/**
+ * Сколько знаков доказательства считается доказательством.
+ *
+ * Порог намеренно низкий: это заслон от ПУСТОГО поля, а не попытка судить
+ * о качестве проверки. Судить о качестве может только человек, читающий
+ * улику, — для того она и показывается в панели рядом с находкой.
+ */
+const MIN_EVIDENCE_CHARS = 12
+
+/** Допустимые приговоры. Четвёртого состояния нет: неразобранное — «ждёт». */
+export const VERDICTS = ['pending', 'confirmed', 'false', 'deferred']
+
+/** Каталог профиля: поднимаемся, пока не найдём отметку об установке. */
+function findProfileRoot(startDir) {
+  let dir = startDir
+  for (let depth = 0; depth < 10; depth += 1) {
+    if (existsSync(join(dir, 'tensorgrid-installed.json'))) return dir
+    const parent = dirname(dir)
+    if (parent === dir) break
+    dir = parent
+  }
+  return null
+}
+
+/**
+ * Где лежит журнал. Рядом с настройками обзора.
+ *
+ * Каталог ищется ОТ СОБСТВЕННОГО расположения модуля, а не от рабочей
+ * папки. Это важно: рабочую папку задаёт чат, и подложенная в неё отметка
+ * об установке увела бы журнал в чужое дерево. Читают и пишут журнал
+ * разные стороны — агент и браузер, — и указывать они обязаны на один файл.
+ *
+ * @param root - явный каталог; только для проверок, где установленного
+ *   профиля нет вовсе.
+ */
+export function logPath(root = null) {
+  const found = root ?? findProfileRoot(dirname(fileURLToPath(import.meta.url)))
+  return found === null ? null : join(found, FILE_NAME)
+}
+
+/**
+ * Устойчивый признак находки.
+ *
+ * Считается по содержанию, а не по порядковому номеру: тот же дефект,
+ * найденный повторно в следующем обзоре, получит тот же признак, и прежний
+ * приговор к нему подойдёт. Нумерация этого не дала бы — она сдвигается от
+ * любой новой находки выше по списку.
+ */
+export function findingId(finding) {
+  const parts = [finding.reviewer, finding.title, finding.where ?? '']
+  return createHash('sha1').update(parts.join('\u0000')).digest('hex').slice(0, 12)
+}
+
+/** Пустой журнал. Отсутствие файла — не ошибка, а «обзоров ещё не было». */
+export function empty() {
+  return { runs: [], verdicts: {} }
+}
+
+/** Отрезать текст, не притворяясь, что ничего не отрезали. */
+function clip(value, limit) {
+  if (typeof value !== 'string') return null
+  return value.length <= limit ? value : `${value.slice(0, limit)}… (обрезано)`
+}
+
+/**
+ * Привести прочитанное к ожидаемой форме.
+ *
+ * Внутрь обзора смотрим ТАК ЖЕ придирчиво, как наружу. Раньше проверялось
+ * только наличие `id`, а `findings` и `reviewers` принимались любого типа —
+ * и один криво отредактированный обзор ронял `latest()` на `.map`, то есть
+ * весь раздел настроек целиком: состав, режимы, выбор моделей, запись
+ * приговоров. Починить из интерфейса было нельзя.
+ */
+export function normalise(raw) {
+  if (raw === null || typeof raw !== 'object') return empty()
+
+  const text = (value, limit) => (typeof value === 'string' ? clip(value, limit) : null)
+
+  const runs = Array.isArray(raw.runs)
+    ? raw.runs
+        .filter((run) => run !== null && typeof run === 'object' && typeof run.id === 'string')
+        .map((run) => ({
+          id: run.id,
+          at: text(run.at, 40) ?? null,
+          request: text(run.request, REQUEST_CHARS) ?? '',
+          reviewers: Array.isArray(run.reviewers)
+            ? run.reviewers
+                .filter((r) => r !== null && typeof r === 'object')
+                .map((r) => ({
+                  provider: text(r.provider, 64),
+                  model: text(r.model, 96),
+                  effort: text(r.effort, 32),
+                  failed: text(r.failed, 200),
+                  found: Number.isFinite(r.found) ? r.found : 0,
+                }))
+            : [],
+          findings: Array.isArray(run.findings)
+            ? run.findings
+                .filter((f) => f !== null && typeof f === 'object' && typeof f.id === 'string')
+                .map((f) => ({
+                  id: f.id,
+                  reviewer: text(f.reviewer, 64) ?? '?',
+                  severity: text(f.severity, 32) ?? 'не указана',
+                  title: text(f.title, FIELD_CHARS) ?? '',
+                  where: text(f.where, FIELD_CHARS),
+                  what: text(f.what, FIELD_CHARS),
+                  why: text(f.why, FIELD_CHARS),
+                  howToCheck: text(f.howToCheck, FIELD_CHARS),
+                }))
+            : [],
+        }))
+        .slice(-MAX_RUNS)
+    : []
+
+  // Признаки находок, которые ещё существуют. По ним отсеиваются
+  // приговоры-сироты: обзор выпал за предел, а приговор по нему остался бы
+  // в файле навсегда и продолжал бы влиять на статистику.
+  const alive = new Set()
+  for (const run of runs) for (const finding of run.findings) alive.add(finding.id)
+
+  // Объект БЕЗ прототипа: иначе ключ `__proto__` из правленого файла не
+  // записывается вовсе, а `recordVerdict` при этом отвечает «применено» —
+  // приговор человека исчезал при успешном ответе.
+  const verdicts = Object.create(null)
+  if (raw.verdicts !== null && typeof raw.verdicts === 'object') {
+    for (const [id, entry] of Object.entries(raw.verdicts)) {
+      if (entry === null || typeof entry !== 'object') continue
+      if (!VERDICTS.includes(entry.verdict)) continue
+      if (!alive.has(id)) continue
+      verdicts[id] = {
+        verdict: entry.verdict,
+        evidence: text(entry.evidence, EVIDENCE_CHARS) ?? '',
+        by: entry.by === 'human' ? 'human' : 'agent',
+        at: text(entry.at, 40),
+      }
+    }
+  }
+
+  return { runs, verdicts }
+}
+
+/**
+ * Прочитать журнал.
+ *
+ * Возвращает ещё и признак `intact`: удалось ли разобрать файл. Без него
+ * повреждённый журнал выглядел как пустой, а следующая запись накрывала им
+ * настоящие данные — двести обзоров и все приговоры, включая возражения
+ * человека, исчезали от одной лишней запятой, молча и безвозвратно.
+ */
+export async function read(root = null) {
+  const path = logPath(root)
+  if (path === null) return { ...empty(), intact: true, missing: true }
+  let text
+  try {
+    text = await readFile(path, 'utf8')
+  } catch (error) {
+    // Файла нет — это не повреждение, а «обзоров ещё не было».
+    if (error?.code === 'ENOENT') return { ...empty(), intact: true, missing: true }
+    return { ...empty(), intact: false, problem: String(error?.message ?? error) }
+  }
+  try {
+    return { ...normalise(JSON.parse(text.replace(/^\uFEFF/, ''))), intact: true, missing: false }
+  } catch (error) {
+    return { ...empty(), intact: false, problem: `журнал не разобран: ${String(error?.message ?? error)}` }
+  }
+}
+
+/**
+ * Очередь записи на каждый файл.
+ *
+ * Запись идёт по схеме «прочитать целиком → изменить → записать целиком»,
+ * и без очереди одновременные вызовы читают ОДНО состояние, а пишут каждый
+ * своё: побеждает последний, остальные исчезают бесследно. Проверено —
+ * двенадцать одновременных записей давали одну.
+ *
+ * Случай не выдуманный: журнал пишут две стороны — Host в конце обзора и
+ * браузер по нажатию в панели. Человек подтверждает находку ровно в тот
+ * момент, когда завершается второй обзор.
+ *
+ * Очередь внутрипроцессная, и этого достаточно: оба пути проходят через
+ * один Host. От двух ОДНОВРЕМЕННО ЗАПУЩЕННЫХ приложений она не спасает —
+ * такой случай потребовал бы файловой блокировки, а он у нас невозможен:
+ * второй экземпляр не поднимется на занятом порту.
+ */
+const queues = new Map()
+
+function serialise(path, work) {
+  const previous = queues.get(path) ?? Promise.resolve()
+  const next = previous.then(work, work)
+  // В очереди держим ТОЛЬКО факт завершения, без результата и без отказа:
+  // иначе одна неудачная запись уронила бы все следующие.
+  queues.set(path, next.then(() => undefined, () => undefined))
+  return next
+}
+/**
+ * Переименовать с повтором.
+ *
+ * На Windows одновременное переименование двух временных файлов в одну цель
+ * изредка отказывает с EPERM или EBUSY: файл в этот момент держит чужая
+ * операция. Это не ошибка вызывающего и не повод терять запись — достаточно
+ * повторить через несколько миллисекунд.
+ *
+ * Повторяются только эти два кода. Всё прочее — настоящая ошибка (нет прав
+ * на каталог, кончилось место), и глотать её нельзя.
+ */
+async function renameWithRetry(from, to, attempts = 5) {
+  for (let attempt = 1; ; attempt += 1) {
+    try {
+      await rename(from, to)
+      return
+    } catch (error) {
+      const retriable = error?.code === 'EPERM' || error?.code === 'EBUSY' || error?.code === 'EACCES'
+      if (!retriable || attempt >= attempts) throw error
+      await new Promise((resolve) => setTimeout(resolve, attempt * 15))
+    }
+  }
+}
+/**
+ * Записать журнал.
+ *
+ * Запись идёт через временный файл с УНИКАЛЬНЫМ именем и переименованием.
+ * Прежнее имя складывалось из номера процесса и времени в миллисекундах —
+ * у двух одновременных записей оно совпадало, и вторая получала отказ на
+ * переименовании, потому что первая уже унесла общий временный файл.
+ */
+async function write(value, root = null) {
+  const path = logPath(root)
+  if (path === null) throw new Error('не найден каталог профиля — некуда писать журнал обзоров')
+  const temporary = `${path}.${process.pid}.${randomBytes(6).toString('hex')}.tmp`
+  try {
+    await writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, 'utf8')
+    await renameWithRetry(temporary, path)
+  } catch (error) {
+    // Неудавшаяся запись не должна оставлять мусор рядом с настройками.
+    await rm(temporary, { force: true }).catch(() => {})
+    throw error
+  }
+}
+
+/**
+ * Записать состоявшийся обзор.
+ *
+ * @param run - что спрашивали, кого звали и что нашли.
+ * @returns признак записи и признаки находок — по ним потом выносится приговор.
+ */
+export async function recordRun(run, root = null) {
+  return serialise(logPath(root) ?? 'нет-пути', () => recordRunNow(run, root))
+}
+
+async function recordRunNow(run, root) {
+  const log = await read(root)
+
+  // Повреждённый журнал НЕ затирается.
+  //
+  // Раньше любая ошибка чтения давала пустой журнал, и следующая же запись
+  // накрывала им настоящие данные: двести обзоров и все приговоры, включая
+  // возражения человека, исчезали от одной лишней запятой — молча, с
+  // обычным ответом об успехе. Файл правит и человек руками, это заявлено
+  // как штатное, так что случай не выдуманный.
+  if (log.intact === false) {
+    throw new Error(`журнал обзоров повреждён, запись отменена, чтобы не потерять прежние: ${log.problem ?? ''}`.trim())
+  }
+
+  const findings = []
+  const seen = new Set()
+  for (const finding of run.findings ?? []) {
+    let id = findingId(finding)
+    // Признак считается по содержанию, и две находки с одинаковыми
+    // ревизором, названием и местом получали ОДИН признак: приговор по
+    // первой молча становился приговором по второй, а вторая исчезала из
+    // разбора. Различаем порядковым номером в пределах обзора.
+    if (seen.has(id)) {
+      let suffix = 2
+      while (seen.has(`${id}-${suffix}`)) suffix += 1
+      id = `${id}-${suffix}`
+    }
+    seen.add(id)
+    findings.push({
+      id,
+      reviewer: finding.reviewer,
+      severity: finding.severity,
+      title: clip(finding.title, FIELD_CHARS) ?? '',
+      where: clip(finding.where, FIELD_CHARS),
+      what: clip(finding.what, FIELD_CHARS),
+      why: clip(finding.why, FIELD_CHARS),
+      howToCheck: clip(finding.howToCheck, FIELD_CHARS),
+    })
+  }
+
+  const entry = {
+    id: `run-${Date.now().toString(36)}-${randomBytes(3).toString('hex')}`,
+    at: new Date().toISOString(),
+    request: clip(run.request, REQUEST_CHARS) ?? '',
+    // Модель и усилие сохраняются вместе с находками: без них статистика
+    // точности бессмысленна — «codex ошибается» ничего не значит, если
+    // неизвестно, на какой модели и с каким усилием.
+    reviewers: (run.reviewers ?? []).map((r) => ({
+      provider: r.provider,
+      model: r.model ?? null,
+      effort: r.effort ?? null,
+      failed: r.failed ?? null,
+      found: r.found ?? 0,
+    })),
+    findings,
+  }
+
+  log.runs.push(entry)
+  if (log.runs.length > MAX_RUNS) log.runs = log.runs.slice(-MAX_RUNS)
+
+  await write({ runs: log.runs, verdicts: log.verdicts }, root)
+  return { runId: entry.id, findingIds: findings.map((f) => f.id) }
+}
+
+/**
+ * Вынести приговор по находке.
+ *
+ * `evidence` не формальность: приговор без доказательства — это мнение, а
+ * инструмент затевался как раз против мнений, выдаваемых за факты.
+ *
+ * @param id - признак находки.
+ * @param verdict - подтверждено, ложная или отложено.
+ * @param evidence - что именно проверено: команда, файл, наблюдение.
+ * @param by - агент или человек; человек перекрывает агента.
+ */
+export async function recordVerdict(id, verdict, evidence, by = 'agent', root = null) {
+  if (!VERDICTS.includes(verdict)) throw new Error(`неизвестный приговор: ${String(verdict)}`)
+  return serialise(logPath(root) ?? 'нет-пути', () => recordVerdictNow(id, verdict, evidence, by, root))
+}
+
+async function recordVerdictNow(id, verdict, evidence, by, root) {
+
+  // ДОКАЗАТЕЛЬСТВО ТРЕБУЕТСЯ, а не просто объявлено обязательным.
+  //
+  // Весь замысел держится на фразе «приговор без доказательства — это
+  // мнение», и я написал её в комментарии, не применив в коде: пустая
+  // улика превращалась в пустую строку, приговор записывался и входил в
+  // статистику наравне с проверенным. То есть единственной защитой была
+  // просьба к тому, кого этот механизм и должен проверять.
+  //
+  // Отложенное — исключение: «настоящая, но чиним не сейчас» доказывать
+  // нечем, это решение о приоритете, а не о факте.
+  const proof = typeof evidence === 'string' ? evidence.trim() : ''
+  if (verdict !== 'deferred' && proof.length < MIN_EVIDENCE_CHARS) {
+    throw new Error(
+      `приговор «${verdict}» требует доказательства: что именно проверено — ` +
+      `запущенная команда и её результат, прочитанные файл и строка, наблюдённое поведение`,
+    )
+  }
+
+  const log = await read(root)
+  if (log.intact === false) {
+    throw new Error(`журнал обзоров повреждён, приговор не записан: ${log.problem ?? ''}`.trim())
+  }
+
+  // Приговор по НЕСУЩЕСТВУЮЩЕЙ находке отклоняется.
+  //
+  // Раньше он принимался, объявлялся применённым и терялся: агент мог дать
+  // признак из прошлого обзора или просто ошибиться, получить «Записано» —
+  // а в панели находка так и оставалась ждущей.
+  const known = new Set()
+  for (const run of log.runs) for (const finding of run.findings) known.add(finding.id)
+  if (!known.has(id)) {
+    return { id, applied: false, problem: 'находки с таким признаком нет ни в одном сохранённом обзоре' }
+  }
+
+  const existing = log.verdicts[id]
+
+  // Человек перекрывает агента, агент человека — нет. Иначе следующий обзор
+  // молча отменил бы возражение, ради которого всё и затевалось.
+  if (existing !== undefined && existing.by === 'human' && by === 'agent') {
+    return { id, kept: existing, applied: false }
+  }
+
+  const entry = {
+    verdict,
+    evidence: clip(proof, EVIDENCE_CHARS) ?? '',
+    by: by === 'human' ? 'human' : 'agent',
+    at: new Date().toISOString(),
+  }
+  log.verdicts[id] = entry
+  await write({ runs: log.runs, verdicts: log.verdicts }, root)
+  return { id, kept: entry, applied: true }
+}
+
+/**
+ * Точность ревизоров по накопленному журналу.
+ *
+ * Считаются ТОЛЬКО находки с вынесенным приговором: непроверенные не значат
+ * ни «правда», ни «ложь», и включать их значило бы врать в обе стороны.
+ * Поэтому рядом с долей всегда стоит, на скольких находках она посчитана —
+ * доля по трём находкам не значит ничего.
+ */
+export function accuracy(log) {
+  const byReviewer = new Map()
+
+  const key = (finding, run) => {
+    const used = (run.reviewers ?? []).find((r) => r.provider === finding.reviewer)
+    const model = used?.model ?? null
+    const effort = used?.effort ?? null
+    // Усилие входит в разрез наравне с моделью: быстрый прогон и глубокий
+    // — разные условия, и складывать их в одну долю значит мерить среднюю
+    // температуру. Без модели остаётся голое имя ревизора — так и пишем,
+    // честнее, чем выдумывать.
+    if (model === null && effort === null) return finding.reviewer
+    return `${finding.reviewer} · ${model ?? 'по умолчанию'}${effort === null ? '' : ` · ${effort}`}`
+  }
+
+  // КАЖДАЯ находка считается ОДИН раз, сколько бы обзоров её ни повторили.
+  //
+  // Признак считается по содержанию, поэтому та же находка в следующем
+  // обзоре получает тот же признак и ссылается на тот же единственный
+  // приговор. Перебор по всем обзорам засчитывал каждое вхождение отдельно:
+  // пять повторов одной находки и один разбор давали ревизору пять ошибок.
+  // Особенно едко с «ответом не по формату» — у него постоянное название,
+  // и пять сорванных запусков превращались в пять ошибок ревизора.
+  const counted = new Set()
+
+  // Идём с конца: разрез берётся по САМОМУ СВЕЖЕМУ обзору, где находка
+  // встретилась, — там модель и усилие ближе всего к тому, что оценивают.
+  for (let index = log.runs.length - 1; index >= 0; index -= 1) {
+    const run = log.runs[index]
+    for (const finding of run.findings ?? []) {
+      if (counted.has(finding.id)) continue
+      const verdict = log.verdicts[finding.id]
+      if (verdict === undefined || verdict.verdict === 'pending' || verdict.verdict === 'deferred') continue
+      counted.add(finding.id)
+      const name = key(finding, run)
+      const stat = byReviewer.get(name) ?? { reviewer: name, confirmed: 0, wrong: 0 }
+      if (verdict.verdict === 'confirmed') stat.confirmed += 1
+      else stat.wrong += 1
+      byReviewer.set(name, stat)
+    }
+  }
+
+  // Сколько находок ревизор ВООБЩЕ выдал — вторая половина честной картины.
+  //
+  // Без неё ревизор, чьи находки никто не разбирал, выглядит наравне с тем,
+  // у кого разобрано всё, а агент, склонный подтверждать своё и откладывать
+  // чужое, сам себе рисует оценку. Пара «рассужено из выданных» этот перекос
+  // и показывает.
+  const produced = new Map()
+  const seenFindings = new Set()
+  for (const run of log.runs) {
+    for (const finding of run.findings ?? []) {
+      if (seenFindings.has(finding.id)) continue
+      seenFindings.add(finding.id)
+      const name = key(finding, run)
+      produced.set(name, (produced.get(name) ?? 0) + 1)
+    }
+  }
+
+  return [...byReviewer.values()]
+    .map((stat) => ({
+      ...stat,
+      judged: stat.confirmed + stat.wrong,
+      produced: produced.get(stat.reviewer) ?? stat.confirmed + stat.wrong,
+      // Доля не округляется до целых процентов в источнике: пусть показ
+      // решает сам, а данные остаются точными.
+      rate: stat.confirmed + stat.wrong === 0 ? null : stat.confirmed / (stat.confirmed + stat.wrong),
+    }))
+    .sort((a, b) => b.judged - a.judged)
+}
+
+/** Находки последнего обзора вместе с приговорами — то, что показывает панель. */
+export function latest(log) {
+  const run = log.runs[log.runs.length - 1]
+  if (run === undefined) return null
+  return {
+    id: run.id,
+    at: run.at,
+    request: run.request,
+    reviewers: run.reviewers,
+    findings: (run.findings ?? []).map((finding) => ({
+      ...finding,
+      verdict: log.verdicts[finding.id]?.verdict ?? 'pending',
+      evidence: log.verdicts[finding.id]?.evidence ?? '',
+      by: log.verdicts[finding.id]?.by ?? null,
+    })),
+  }
+}