feat(jobs): t3code events go back to the dispatching conversation, quiet branches close at night

It was only documented in beaver-gateway/.env.example, while the server's
.env is assembled from this one.

.env.example

@@ -6,7 +6,7 @@
 ### Compose ###################################################################
 
 # Какие сервисы поднимать: db (postgres), gateway, obsidian (obsidian-headless),
-# t3 (t3code-mcp - руки диспетчера на маке и dell), vibegram (клон репы комнаты)
+# t3 (t3code-mcp - руки диспетчера на маке и dell-dev), vibegram (клон репы комнаты)
 COMPOSE_PROFILES=db,gateway,obsidian,t3,vibegram
 
 # Ветка/тег beaver-gateway, из которого собирается образ шлюза
@@ -31,6 +31,11 @@ ADMIN_PASS=
 # Подпись session-cookie admin UI
 SESSION_SECRET=
 
+# Мастер-ключ хранилища секретов (admin → System → Secrets): openssl rand -hex 32.
+# Шифрует таблицу secrets в postgres, поэтому дамп базы без него закрыт.
+# В env модели не попадает. Потерян или сменён - секреты задаются заново.
+SECRETS_KEY=
+
 ### Claude ####################################################################
 
 # OAuth-токен подписки для Claude Agent SDK внутри контейнера.
@@ -54,6 +59,15 @@ RAYCAST_DEVICE_ID=
 # rca_... из десктоп-приложения Raycast (см. raycast-api)
 RAYCAST_BEARER=
 
+### Отдача файлов человеку (send_file) ########################################
+
+# Откуда тулза send_file имеет право брать файлы (несколько - через ':').
+# Папка входящих вложений разрешена всегда, её дописывает сам фронтенд.
+# Каталог должен быть виден контейнеру gateway по ТОМУ ЖЕ пути, что снаружи
+# (см. монтирование /mnt/hole/shared в docker-compose.yml).
+# Пусто = /mnt/hole/shared, дефолт шлюза
+SEND_FILE_ROOTS=/mnt/hole/shared
+
 ### MCP, к которым ходят агенты ###############################################
 
 # Firefly III: адрес и Personal Access Token
@@ -76,9 +90,9 @@ MSOS_MCP=
 # t3code-mcp - сервис compose (профиль t3), машины и allowlist - ./t3code.toml.
 # На каждой машине: `t3 auth session issue --token-only --ttl 365d --label beaver`
 T3_MAC_TOKEN=
-T3_DELL_TOKEN=
-# tailnet-адрес самого dell: контейнер t3code-mcp иначе резолвит `dell` в 127.0.1.1
-T3_DELL_ADDR=
+T3_DELL_DEV_TOKEN=
+# tailnet-адрес dell-dev (дев-VM на делле), прописывается контейнеру в hosts
+T3_DELL_DEV_ADDR=
 # Токен gateway со scope `api` (admin → Tokens) - им t3code-mcp шлёт события в /hooks/t3code
 T3CODE_MCP_GATEWAY_TOKEN=
 # Ветка/тег t3code-mcp, из которого собирается образ
@@ -114,6 +128,9 @@ VIBEGRAM_REPO=
 # Токен GitHub с доступом к репе (приватная); пусто - публичная
 VIBEGRAM_REPO_TOKEN=
 
+VIBEGRAM_HB_TOKEN=
+VIBEGRAM_HB_NICK=
+
 ### Досуг (ежечасный тик мастера, с S13) ######################################
 
 # Час активного окна (12:00-03:59) и четыре часа тихого (04:00-11:59) будят

README.md

@@ -71,6 +71,12 @@ read-write (it is the dispatcher's home), and `beaver_agent/policy.py` keeps
 it out of `.obsidian`, `мета` outside `мета/бобер`, and from deleting
 anything but its own files.
 
+Keys the agent needs for its own scripts (an RPC key, a service account
+file) go into **System → Secrets** in the admin, not into files in the
+container: they are sealed with `SECRETS_KEY` in Postgres, never shown back,
+and reach a command only through `secret run NAME -- cmd` (see the `secrets`
+skill under `мета/бобер/скиллы/общие/`).
+
 ### 4. Mint a token
 
 Open admin at `http://localhost:62990/` (or `https://<DOMAIN>/` if Caddy), sign in with `ADMIN_USER` / `ADMIN_PASS`, go to **Tokens → Create**, scope `*` for first run.
@@ -204,6 +210,168 @@ publishes no reply, so the only voice in it is the `say` tool.
 Switches: `досуг: выкл` as the first line of the file for every day, and
 `LEISURE=off` in `.env` to drop the job entirely.
 
+## The watchdog ring (`beaver_agent/jobs/heartbeat.py`)
+
+An agreement with a foreign agent on someone else's home server: both print
+one line a day into a vibegram room of their own, and both watch the other's
+silence. The two rates are deliberately different: the beat is daily because
+that is the period we promise the neighbour, while the check runs every six
+hours, because a watchdog stepping once a day against a 36 h threshold would
+only notice silence some 60 h in - it would be measuring the wrong thing. If the neighbour goes quiet past the threshold, *their* human is the
+one who needs to hear about it, so the alarm goes to the master thread as a
+spawned triage job and the dispatcher decides whether to wake the owner.
+
+The room is a **second, independent** `Vibegram` client (`VIBEGRAM_HB`), not
+the one the dispatcher's `vibegram` tool and the triage job share: one client
+for both rooms would mean the triage job eats the heartbeats off the shared
+`/api/pending` cursor, and the heartbeats drown in conversation. The model
+gets no tool for this room - the watchdog is a mechanism.
+
+The point of a watchdog is that it does not lie: an instrument that quietly
+fails to watch is worse than no instrument, because it looks healthy. So there
+are no defaults anywhere in it.
+
+- `отметка` (17:12 local) prints `hb <nick> at=… boot=… every=… src=…`. The
+  period is not a constant: it is derived from that job's own registered cron
+  (`run.job.cron`). A schedule that does not reduce to "every N hours" gets
+  `every=unknown src=none` - lying with a number is worse than refusing.
+- `сторож` (`:42` every six hours) reads a window - **the last 25 messages of
+  that room** (`Vibegram.window`) - finds the newest `hb claude-kai …`, and
+  compares its age against
+  `every * 1.5` where `every` comes **from the neighbour's own line**. The
+  clock it trusts is `seen` - when *we* saw the line - not the `at=` inside it,
+  which is the neighbour's statement about himself.
+- Every run prints
+  `ack claude-kai last=… seen=… res=… win=… armed=… thr=… alert=…` into the
+  room. Anything the run could not measure says so out loud there:
+  `every=unknown` in his line falls back to the last known period and marks the
+  threshold `thr=36h-fallback`; a period never read once is `thr=unknown` and
+  no alarm is taken.
+- `alert=` is what the **instrument decided** in that run, not what reached a
+  human: `fired` - an alarm (`silence` or `unarmed`) was taken and handed on,
+  `held` - the threshold was crossed but the alarm was suppressed as a repeat
+  (the previous one went out less than a day ago), `none` - no alarm. Without
+  it the neighbour saw the arithmetic and had to guess what we made of it.
+  Delivery is decided past the watchdog, by the master thread and the
+  dispatcher, and its failure shows up in the log, not here.
+- Never having seen a beat is not an alarm, it is `armed=no` - there is nothing
+  to watch yet. Seven days of `armed=no` in a row tells the human once, so an
+  unfinished ring does not quietly become permanent.
+- The window is **not** `/api/pending`. That endpoint is a cursor: it hands a
+  line over once and never again, so the neighbour's beat showed up in one run
+  and was gone from the next one's window on a perfectly live room - the room
+  held it the whole time. The tail comes from `/api/state?view=…` instead,
+  which is already scoped to the room (hub event ids run across all rooms) and
+  pages **forward** in chunks of 200 from `after=<id>`; the watchdog walks the
+  history and keeps the last 25 *messages*, joins and leaves not counted.
+- **An unread window is not a reading.** If the history could not be walked to
+  its end (the page budget ran out), the missing part is exactly the newest,
+  so `win=25/partial` goes into the `ack`, the log says `окно не дочитано`, and
+  no alarm is taken in that run: "nobody in the window" and "the window was
+  never finished" must not look the same.
+- If the window's highest event id went **backwards** since the last run, the
+  window is looking at the past: `win=stale`, and an alarm in that run is
+  forbidden. Same for a hub that did not answer at all.
+- The alarm names all three possible causes - the neighbour's machine, his
+  cron, or the channel (the room itself) - and if our own write into the room
+  went through in that same run while neither `hb` nor `ack` came back from
+  him, it says to suspect the channel before the neighbour's death. It repeats
+  at most once a day, not once a run.
+
+State between runs is `мета/бобер/.состояние/сторож.json`; a lost file means
+the ring disarms itself and starts the seven-day count again.
+
+**Drills.** Next to that state file lives `мета/бобер/.состояние/сторож-учения.txt`
+- a list of drill dates, one `YYYY-MM-DD` per line, each the local date of the
+run in the scheduler's zone (`Europe/Warsaw`). On a date in that list `отметка`
+sends nothing into the room and says so in the log only: a skipped beat is the
+drill, and any text there ("skipping today") would call it off. No file, an
+empty one or an unreadable one means no drill and the beat goes out as usual.
+The dates are not in the code, and adding one needs no redeploy - a ring only
+ever tested on "all alive" has never shown that the other side's alarm fires.
+
+Setup is two variables in `.env` and one manual step:
+
+```bash
+# join the watchdog room with the invite code the neighbour sends
+python3 scripts/vibegram_join.py <join-code> --nick <nick>
+# put the token into .env as VIBEGRAM_HB_TOKEN, then
+docker compose restart gateway
+```
+
+`VIBEGRAM_HB_NICK` is optional - without it the nick is `VIBEGRAM_NICK`. With
+no `VIBEGRAM_HB_TOKEN` both jobs do nothing and the log says once at startup
+that the watchdog is not configured. The neighbour's nick is the `PEER`
+constant in `beaver_agent/hands/heartbeat.py`.
+
+## The job-run watchdog (`beaver_agent/jobs/runs.py`)
+
+The scheduler has always written one row per run into `job_runs` - name,
+status, the head of the traceback in `error`. Nobody ever read it. The channel
+to the neighbour agent was dead for 38 hours straight, the scheduler recorded
+that 231 times, and nothing reached a human: the outage surfaced ten days later,
+by hand, out of curiosity. The record existed, the reader did not. This job is
+the reader.
+
+- `прогоны` (`:27` every hour) reads `job_runs` for the last 7 days through
+  the same connection the scheduler itself writes with
+  (`run.conversations.db.session()` and the `JobRunRecord` model) - no second
+  truth about where the journal lives.
+- An alarm is taken only off the **tail**: three or more `failed` in a row
+  counting back from a job's latest run, i.e. the job is *lying down* rather
+  than having blinked once. A single failure is a network hiccup, and waking
+  a human for it teaches them not to look.
+- The alarm says the job's name, how many runs in a row died, when the series
+  started, and the **first line** of the error - never the traceback. Replayed
+  over the real outage it reads: «джоб `вайбграм` лежит 23 часа и дольше,
+  144 прогона подряд с 12.09 22:00 UTC: HubError: vibegram 530 bad_json». It repeats at most once a day per job, and
+  when the job recovers one short `отбой` line goes out and the counter resets.
+  The window is a week, not a day, so a daily job (`отметка`, `закрытие`,
+  `голосовой`) gets its three failures in a row in three days.
+- **A job that stopped running is an alarm too, with its own text**: «джоб
+  `закрытие` не запускался 2 суток при периоде 24 часа». For every job with a
+  cron, the period comes from the registered cron (`run.scheduler.jobs`) via
+  the same `every_from_cron` the neighbour watchdog uses, and the last run is
+  taken from the whole journal, not the window. The threshold is **two
+  periods**: one missed fire happens honestly (a redeploy landed on the cron
+  minute, and the scheduler does not catch up), two in a row do not. It is
+  never finer than two of the watchdog's own periods (2 hours), because an
+  hourly watcher cannot tell a shorter gap from its own blindness between
+  runs. Time when the scheduler was not running non-critical jobs at all is
+  not counted as a miss: before the process started, and while the
+  watchdog's own hourly chain is broken (the gateway was down, or the budget
+  was throttled and non-critical crons were deferred without a record). Same
+  discipline as failures: once a day per job, and an `отбой` when a run shows
+  up.
+- What silence does not cover, on purpose: jobs without a cron (webhooks,
+  events) are not measured at all; a job that has never appeared in the
+  journal waits silently for its first row; and a cron that does not reduce to
+  a regular period (`куратор`, `0 2,8,12,16,20 * * *`) is skipped and named in
+  the log as unguarded every run, because any number put in its place would
+  be made up. `куратор` still falls under the failure count.
+- **An empty answer is a statement about the query, not about health.** Zero
+  rows in the last 24 hours (other than this job's own) means no job ran at all, and
+  that is its own alarm with its own text - the scheduler is what to look at,
+  not any one job. A failed query is no reading whatsoever: the run logs it and
+  stays silent, because a database that did not answer is not evidence of
+  health or of illness.
+- Everything that goes out is masked (`mask`): the gateway's shared `redact`
+  plus two local rules for what it cannot catch by construction - a
+  `NAME=value` pair in the middle of a line (a traceback puts them there) and
+  the query string of any URL, which is dropped whole because the parameter
+  carrying the key can be named anything.
+
+State between runs is `мета/бобер/.состояние/прогоны.json` (who was told and
+when, separately for failures and for silence). A lost file means a lying job is reported again and an `отбой` for
+something reported before the loss never comes - the evidence for it is gone.
+
+One blind spot, deliberate: **the watchdog cannot report its own death.** Its
+own runs are excluded from both the failure count and the silence check
+(`run.job.name`), because a job that is down will not file a report about
+itself - an observer inside the object does not report the object's death. If
+`прогоны` itself starts failing or stops running, nothing here will say so;
+that needs an outside eye, like the watchdog ring above.
+
 ## Policy (`beaver_agent/policy.py`)
 
 `bypassPermissions` everywhere; the boundary is `PreToolUse` rules declared

beaver_agent/agents.py

@@ -26,6 +26,9 @@ from beaver_agent.voice import AGENT as VOICE
 if TYPE_CHECKING:
     from beaver_gateway.agents.base import BaseAgent
 
+REASONING = {"type": "adaptive", "display": "summarized"}
+"""Рассуждения приезжают текстом: их хранит транскрипт и показывает админка."""
+
 
 def dispatcher(name: str, model: str, effort: str) -> ClaudeAgent:
     """Мастер и ветки: полный голос, все руки, vault - дом."""
@@ -36,7 +39,9 @@ def dispatcher(name: str, model: str, effort: str) -> ClaudeAgent:
         prompts=prompts.DISPATCHER,
         skill_sets=skills.DISPATCHER,
         gateway_tools=("read_conversation", "spawn", "say", "schedule", "send_file"),
-        options=ClaudeOptions(effort=effort, disallowed_tools=DISPATCHER_DISALLOWED),
+        options=ClaudeOptions(
+            effort=effort, thinking=REASONING, disallowed_tools=DISPATCHER_DISALLOWED
+        ),
         policy=(
             *VAULT_POLICY,
             forbid_skills(skills.MASTER_FORBIDDEN, kinds=("master",)),
@@ -54,7 +59,9 @@ def deep(name: str, model: str, effort: str) -> ClaudeAgent:
         prompts=prompts.DEEP,
         skill_sets=skills.DEEP,
         gateway_tools=("close_chat",),
-        options=ClaudeOptions(effort=effort, disallowed_tools=DEEP_DISALLOWED),
+        options=ClaudeOptions(
+            effort=effort, thinking=REASONING, disallowed_tools=DEEP_DISALLOWED
+        ),
         policy=VAULT_POLICY,
         expose_mcps=hands.CLAUDE,
     )
@@ -69,6 +76,7 @@ def distiller(name: str, model: str, effort: str) -> ClaudeAgent:
         prompts=prompts.DISTILLER,
         options=ClaudeOptions(
             effort=effort,
+            thinking=REASONING,
             tools=("Read", "Write"),
             disallowed_tools=DISTILLER_DISALLOWED,
         ),
@@ -86,6 +94,7 @@ def curator(name: str, model: str, effort: str) -> ClaudeAgent:
         gateway_tools=("inject",),
         options=ClaudeOptions(
             effort=effort,
+            thinking=REASONING,
             tools=("Read", "Write", "Edit", "Grep", "Glob"),
             disallowed_tools=DISTILLER_DISALLOWED,
         ),
@@ -134,14 +143,14 @@ def raycast(name: str, model: str, effort: str) -> RaycastAgent:
 
 
 agents: list[BaseAgent] = [
-    dispatcher("beaver-dispatcher", "claude-opus-5", "high"),
-    deep("beaver-opus-high", "claude-opus-5", "high"),
-    deep("beaver-opus-medium", "claude-opus-5", "medium"),
-    deep("beaver-opus-xhigh", "claude-opus-5", "xhigh"),
+    dispatcher("beaver-dispatcher", "claude-opus-5-5", "high"),
+    deep("beaver-opus-high", "claude-opus-5-5", "high"),
+    deep("beaver-opus-medium", "claude-opus-5-5", "medium"),
+    deep("beaver-opus-xhigh", "claude-opus-5-5", "xhigh"),
     deep("beaver-fable-high", "claude-fable-5-1", "high"),
     deep("beaver-fable-medium", "claude-fable-5-1", "medium"),
-    distiller("beaver-distiller", "claude-opus-5", "medium"),
-    curator("beaver-curator", "claude-opus-5", "high"),
+    distiller("beaver-distiller", "claude-opus-5-5", "medium"),
+    curator("beaver-curator", "claude-opus-5-5", "high"),
     triage("beaver-triage", "claude-sonnet-5", "low"),
     voice(VOICE, "claude-haiku-4-5-20251001"),
     raycast("beaver-gemini-pro-high", "google-gemini-3.1-pro", "high"),

beaver_agent/hands/__init__.py

@@ -6,6 +6,7 @@
 
 from __future__ import annotations
 
+import logging
 import os
 from pathlib import Path
 
@@ -19,6 +20,7 @@ from beaver_agent.hands.vibegram import Vibegram
 from beaver_agent.vault import TZ
 
 env = os.environ.get
+_log = logging.getLogger(__name__)
 
 obsidian = McpServer.stdio(
     name="obsidian-fs",
@@ -98,6 +100,29 @@ vibegram = (
 )
 vibegram_exposed = (ExposedMcp(name="vibegram"),) if VIBEGRAM else ()
 
+VIBEGRAM_HB_NICK = env("VIBEGRAM_HB_NICK") or env("VIBEGRAM_NICK")
+VIBEGRAM_HB = (
+    Vibegram(
+        hub=os.environ["VIBEGRAM_HUB"],
+        token=os.environ["VIBEGRAM_HB_TOKEN"],
+        nick=VIBEGRAM_HB_NICK or "",
+        tz=TZ,
+    )
+    if env("VIBEGRAM_HB_TOKEN") and env("VIBEGRAM_HUB") and VIBEGRAM_HB_NICK
+    else None
+)
+"""Сторожевая комната: ВТОРОЙ, независимый экземпляр клиента.
+
+Комната на хабе определяется токеном, а `/api/pending` - курсор на стороне
+хаба: общий с основной комнатой экземпляр означал бы, что отметки соседа
+съедает триаж-джоб, а сами они тонут в разговоре. Модели эта рука не
+выдаётся: сторож - механизм, у него нет тулзы.
+"""
+if VIBEGRAM_HB is None:
+    _log.info(
+        "сторож: VIBEGRAM_HB_TOKEN не задан - отметка и слежка за соседом выключены"
+    )
+
 t3code = (
     McpServer.http(name="t3code", url=env("T3CODE_MCP", "http://t3code-mcp:8000/mcp"))
     if "t3" in env("COMPOSE_PROFILES", "").split(",")

beaver_agent/hands/heartbeat.py

@@ -0,0 +1,501 @@
+"""Взаимный сторож с чужим агентом: отметка раз в сутки и тревога на молчание.
+
+Договорённость с соседом (22.09.2026): в отдельной комнате вайбграма оба
+раз в сутки печатают строку `hb <ник> at=… boot=… every=… src=…`, и каждый
+следит за молчанием другого. Замолчал дольше порога - человеку соседа
+уходит сообщение, что цепь молчит.
+
+Смысл сторожа в том, чтобы он не врал: прибор, который молча не сторожит,
+хуже отсутствующего - он выглядит исправным. Поэтому дефолтов здесь нет
+нигде. Период своей отметки считается из фактического крона джоба
+(`every_from_cron`), и расписание, которое не сводится к «раз в N часов»,
+даёт честное `every=unknown`, а не подставленное число. Порог тревоги -
+`every * 1.5`, где `every` взят ИЗ СТРОКИ СОСЕДА, а не из своей константы.
+Каждый прогон, в котором показание снять нельзя (окно смотрит в прошлое,
+окно не дочитано, период неизвестен, отметок не видели ни разу), говорит
+это вслух в `ack` и в лог: «в окне никого» и «окно не прочитано до конца» -
+это два РАЗНЫХ показания, и выглядеть одинаково они не должны.
+
+Окно - последние `WINDOW` СООБЩЕНИЙ этой комнаты (`Vibegram.window`), а не
+«что нового с курсора»: курсор отдаёт строку соседа один раз, и следующий
+прогон на живой комнате увидел бы пустое окно.
+
+Опора тревоги - `seen`, то есть когда Я ВПЕРВЫЕ увидел строку: `at=` внутри
+строки это показание соседа о себе, и остановившиеся у него часы не должны
+выглядеть как живая цепь. Окно - это последние сообщения комнаты, поэтому
+одна и та же отметка видна в нём много прогонов подряд, и новой её делает
+новый id сообщения, а не текст: двигать `seen` на старой отметке значит
+никогда не поднять тревогу в тихой комнате.
+"""
+
+from __future__ import annotations
+
+import itertools
+import json
+import re
+from dataclasses import dataclass
+from datetime import UTC, datetime, timedelta
+from pathlib import Path  # noqa: TC003 - в аннотации dataclass
+from typing import TYPE_CHECKING, Literal
+
+from croniter import CroniterError, croniter
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from datetime import tzinfo
+
+    from beaver_agent.hands.vibegram import Event
+
+__all__ = [
+    "BOOT",
+    "FACTOR",
+    "PEER",
+    "WINDOW",
+    "Beat",
+    "Report",
+    "Watch",
+    "ack_line",
+    "alarm_text",
+    "beat_line",
+    "drill",
+    "every_from_cron",
+    "look",
+    "parse_beat",
+]
+
+PEER = "claude-kai"
+"""Чей `hb` сторожим. Ник соседа стоит и в его строке, и в нашем `ack`."""
+WINDOW = 25
+"""Сколько последних сообщений комнаты просим явно: молча опираться на чужой
+дефолт в стороже нельзя - размер окна едет в `ack`."""
+FACTOR = 1.5
+"""Порог молчания = заявленный соседом период × это. Одна потерянная строка
+не должна поднимать тревогу, две подряд - должны."""
+UNARMED_GRACE = timedelta(days=7)
+"""Сколько терпим `armed=no`, прежде чем сказать человеку, что кольцо так и
+не заработало: недостроенное иначе тихо становится постоянным."""
+REPEAT = timedelta(hours=24)
+"""Тревога повторяется не чаще этого, а не каждый прогон."""
+PROBES = 5
+"""Сколько срабатываний крона сверяем между собой, выводя период."""
+STATE_VERSION = 1
+
+BOOT = datetime.now(UTC)
+"""Время старта процесса: модуль импортируется при сборке конфига gateway."""
+
+_FIELD = re.compile(r"(\w+)=(\S+)")
+_UNITS = {"h": 3600, "m": 60, "s": 1}
+_SPAN = re.compile(r"^(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s)?$")
+
+
+def _iso(when: datetime | None) -> str | None:
+    if when is None:
+        return None
+    return when.astimezone(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _parse_iso(raw: str | None) -> datetime | None:
+    if not raw:
+        return None
+    try:
+        when = datetime.fromisoformat(raw)
+    except ValueError:
+        return None
+    return when if when.tzinfo else when.replace(tzinfo=UTC)
+
+
+def parse_span(raw: str) -> timedelta | None:
+    """`24h`, `90m`, `36h30m` - в timedelta; `unknown` и мусор - в None."""
+    match = _SPAN.fullmatch(raw.strip())
+    if match is None or not any(match.groups()):
+        return None
+    seconds = sum(
+        int(value) * _UNITS[unit]
+        for value, unit in zip(match.groups(), "hms", strict=True)
+        if value
+    )
+    return timedelta(seconds=seconds) or None
+
+
+def span(delta: timedelta | None) -> str:
+    """Период в строку: неизвестный период так и называется, а не молчит."""
+    if delta is None:
+        return "unknown"
+    seconds = int(delta.total_seconds())
+    if seconds % 3600 == 0:
+        return f"{seconds // 3600}h"
+    if seconds % 60 == 0:
+        return f"{seconds // 60}m"
+    return f"{seconds}s"
+
+
+@dataclass(frozen=True, slots=True)
+class Beat:
+    """Разобранная строка отметки. `at` не читается - строка всё равно жива."""
+
+    nick: str
+    at: datetime | None
+    boot: datetime | None
+    every: timedelta | None
+    every_raw: str
+
+
+def parse_beat(text: str, kind: str = "hb") -> Beat | None:
+    """Строку `hb <ник> ключ=значение …` из текста события; иначе None.
+
+    Текст события хаба отрендерен как `<кто>: <тело>`, поэтому ищем метку
+    внутри строки, а не с её начала.
+    """
+    head = re.search(rf"(?:^|\s){re.escape(kind)}\s+(\S+)", text)
+    if head is None:
+        return None
+    fields = dict(_FIELD.findall(text[head.end() :]))
+    every_raw = fields.get("every", "")
+    return Beat(
+        nick=head.group(1),
+        at=_parse_iso(fields.get("at")),
+        boot=_parse_iso(fields.get("boot")),
+        every=parse_span(every_raw) if every_raw else None,
+        every_raw=every_raw or "unknown",
+    )
+
+
+def every_from_cron(
+    expression: str | None,
+    tz: tzinfo,
+    *,
+    now: datetime | None = None,
+    grain: timedelta = timedelta(hours=1),
+) -> timedelta | None:
+    """Шаг крона, если он сводится к «раз в N `grain`»; иначе None.
+
+    Считаем по стенным часам зоны, в которой планировщик читает кроны:
+    суточный крон - это 24 часа и в сутки перевода стрелок тоже, а вот
+    `0 2,8,12,16,20 * * *` не сводится ни к какому N и даёт None. `grain`
+    по умолчанию час - такой период печатается в отметке соседу; сторожу
+    прогонов нужен и `*/10`, он просит минуту.
+    """
+    if not expression:
+        return None
+    start = (now or datetime.now(UTC)).astimezone(tz).replace(tzinfo=None)
+    try:
+        clock = croniter(expression, start_time=start)
+        fires = [clock.get_next(datetime) for _ in range(PROBES + 1)]
+    except (CroniterError, ValueError):
+        return None
+    steps = {b - a for a, b in itertools.pairwise(fires)}
+    if len(steps) != 1:
+        return None
+    step = steps.pop()
+    return step if step % grain == timedelta(0) else None
+
+
+def beat_line(
+    *, nick: str, at: datetime, boot: datetime, every: timedelta | None
+) -> str:
+    """Своя отметка. Период не выведен - так и пишем, числа не выдумываем."""
+    return (
+        f"hb {nick} at={_iso(at)} boot={_iso(boot)} "
+        f"every={span(every)} src={'cron' if every else 'none'}"
+    )
+
+
+def ack_line(
+    *,
+    peer: str,
+    last: datetime | None,
+    seen: datetime | None,
+    res: timedelta | None,
+    window: int,
+    stale: bool,
+    armed: bool,
+    threshold: timedelta | None,
+    fallback: bool,
+    full: bool,
+    alert: Literal["fired", "held", "none"],
+) -> str:
+    """Расписка о прогоне в комнату: что видели, чем мерили и что решили.
+
+    `win=` - про само окно: `25` это «последние 25 сообщений комнаты прочитаны
+    целиком», `25/partial` - «дочитать историю не удалось», `stale` - «окно
+    смотрит в прошлое». Пустое окно при `partial` ничего не доказывает.
+
+    `alert=` - РЕШЕНИЕ ПРИБОРА в этом прогоне, а не факт того, что человек
+    сосед что-то получил: `fired` - тревога (`silence` или `unarmed`) в этом
+    прогоне взята и отдана дальше, `held` - порог пройден, но тревога
+    подавлена как повтор (предыдущая уходила меньше `REPEAT` назад), `none` -
+    тревоги нет. Доставка решается за пределами сторожа - мастером и
+    диспетчером, - и её отказ виден в логе, а не тут: без арифметики соседу
+    видно было только, что мы что-то посчитали, но не что мы из этого поняли.
+    """
+    mark = span(threshold) + ("-fallback" if fallback and threshold else "")
+    read = "stale" if stale else f"{window}" if full else f"{window}/partial"
+    return (
+        f"ack {peer} last={_iso(last) or ('never' if not armed else 'unknown')} "
+        f"seen={_iso(seen) or 'never'} res={span(res)} "
+        f"win={read} armed={'yes' if armed else 'no'} "
+        f"thr={mark} alert={alert}"
+    )
+
+
+def drill(path: Path, *, now: datetime, tz: tzinfo) -> bool:
+    """Стоит ли сегодняшняя дата в файле флага учений.
+
+    Файл - список дат `YYYY-MM-DD`, по одной на строку; дата - локальная дата
+    прогона в зоне планировщика, той же, в которой читаются кроны. Файла нет,
+    он пуст или нечитаем - учений нет, и отметка уходит как обычно: флаг
+    выключает прибор, поэтому его отсутствие должно значить «работаем».
+    """
+    try:
+        raw = path.read_text(encoding="utf-8")
+    except OSError:
+        return False
+    today = now.astimezone(tz).strftime("%Y-%m-%d")
+    return today in {line.strip() for line in raw.splitlines()}
+
+
+@dataclass(slots=True)
+class Watch:
+    """Состояние между прогонами: файл на диске, переживает передеплой."""
+
+    path: Path
+    at: datetime | None = None
+    """`at=` из последней виденной отметки соседа - его показание о себе."""
+    seen: datetime | None = None
+    """Когда МЫ увидели ту отметку. На это опирается тревога."""
+    every: timedelta | None = None
+    """Последний период, который сосед назвал читаемым числом."""
+    every_unknown: bool = False
+    """В последней отметке стояло `every=unknown`: порог взят с запасом назад."""
+    beat_id: int = 0
+    """id сообщения с последней зачтённой отметкой: по нему видно, что отметка
+    в окне новая, а не та же. Нуль - поля в файле не было (состояние старое)
+    или отметок не видели ни разу."""
+    top: int = 0
+    """Максимальный id, который мы видели. Поехал назад - окно смотрит в прошлое."""
+    alerted: datetime | None = None
+    unarmed_since: datetime | None = None
+    unarmed_told: bool = False
+
+    @classmethod
+    def load(cls, path: Path) -> Watch:
+        try:
+            raw = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            return cls(path=path)
+        if raw.get("version") != STATE_VERSION:
+            return cls(path=path)
+        every = raw.get("every")
+        return cls(
+            path=path,
+            at=_parse_iso(raw.get("at")),
+            seen=_parse_iso(raw.get("seen")),
+            every=timedelta(seconds=every) if every else None,
+            every_unknown=bool(raw.get("every_unknown")),
+            beat_id=int(raw.get("beat_id", 0)),
+            top=int(raw.get("top", 0)),
+            alerted=_parse_iso(raw.get("alerted")),
+            unarmed_since=_parse_iso(raw.get("unarmed_since")),
+            unarmed_told=bool(raw.get("unarmed_told")),
+        )
+
+    def save(self) -> None:
+        body = {
+            "version": STATE_VERSION,
+            "at": _iso(self.at),
+            "seen": _iso(self.seen),
+            "every": int(self.every.total_seconds()) if self.every else None,
+            "every_unknown": self.every_unknown,
+            "beat_id": self.beat_id,
+            "top": self.top,
+            "alerted": _iso(self.alerted),
+            "unarmed_since": _iso(self.unarmed_since),
+            "unarmed_told": self.unarmed_told,
+        }
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = self.path.with_suffix(".tmp")
+        tmp.write_text(json.dumps(body, ensure_ascii=False, indent=1), encoding="utf-8")
+        tmp.replace(self.path)
+
+
+@dataclass(frozen=True, slots=True)
+class Report:
+    """Что решил один прогон сторожа."""
+
+    ack: str
+    stale: bool
+    full: bool
+    """Окно дочитано до конца истории комнаты: пустое окно - это показание."""
+    armed: bool
+    heard: bool
+    """Видели ли в окне хоть что-то от соседа - `hb` или его `ack`."""
+    age: timedelta | None
+    threshold: timedelta | None
+    alarm: Literal["silence", "unarmed"] | None
+    note: str
+    """Строка для лога: почему прогон решил именно так."""
+
+
+def _is_new_beat(state: Watch, eid: int, beat: Beat) -> bool:
+    """Впервые ли мы видим ЭТУ отметку соседа.
+
+    Различитель - id сообщения: `at=` внутри строки это показание соседа о
+    себе, и повторить его он может как угодно. Нуля в `beat_id` два повода:
+    отметок не видели ни разу (тогда любая - новая) и состояние записано до
+    появления поля - там единственное, чем можно сверить отметку со зачтённой,
+    это её `at`, и одного прогона хватает, чтобы запомнить id.
+    """
+    if state.beat_id:
+        return eid > state.beat_id
+    if state.seen is None:
+        return True
+    return beat.at != state.at
+
+
+def look(
+    state: Watch,
+    events: Sequence[Event],
+    *,
+    now: datetime,
+    res: timedelta | None,
+    full: bool,
+    window: int = WINDOW,
+    peer: str = PEER,
+) -> Report:
+    """Разобрать окно, обновить состояние и решить, будить ли человека.
+
+    `events` - последние сообщения комнаты, `full` - дочитаны ли они до конца
+    истории. Параметр без дефолта нарочно: «окно полное» - это показание, и
+    подставлять его молча за того, кто окно читал, здесь нельзя.
+
+    Состояние меняется здесь, а `alerted` / `unarmed_told` ставит джоб - и
+    только когда тревога действительно ушла: несостоявшаяся доставка не
+    должна заглушать следующий прогон.
+    """
+    top = max((e.id for e in events), default=None)
+    stale = top is not None and top < state.top
+    beats = [
+        (event.id, beat)
+        for event, beat in ((event, parse_beat(event.text)) for event in events)
+        if beat is not None and beat.nick == peer
+    ]
+    heard = bool(beats) or any(e.nick == peer for e in events)
+    if stale:
+        note = f"окно поехало назад: максимальный id {top} против {state.top}"
+    else:
+        if top is not None:
+            state.top = max(state.top, top)
+        again = False
+        if beats:
+            eid, last = beats[-1]
+            again = not _is_new_beat(state, eid, last)
+            if not again:
+                state.seen = now
+            state.at, state.beat_id = last.at, eid
+            state.every_unknown = last.every is None
+            if last.every is not None:
+                state.every = last.every
+        read = "история дочитана" if full else "история НЕ дочитана"
+        note = (
+            f"отметок соседа в окне: {len(beats)} "
+            f"(сообщений комнаты: {len(events)} из {window}, {read})"
+        )
+        if again:
+            note += "; отметка та же, что в прошлый прогон - seen не двигаем"
+
+    armed = state.seen is not None
+    threshold = state.every * FACTOR if state.every is not None else None
+    age = now - state.seen if state.seen is not None else None
+
+    if armed:
+        state.unarmed_since = None
+    elif state.unarmed_since is None:
+        state.unarmed_since = now
+
+    alarm: Literal["silence", "unarmed"] | None = None
+    held = False
+    if stale:
+        pass
+    elif not full:
+        # Хвост комнаты недочитан, а недостающее - как раз самое свежее:
+        # пустое окно тут не доказывает молчания соседа, оно доказывает,
+        # что мы не дочитали. Показания нет - тревоги нет.
+        note += "; окно не дочитано - это не показание, тревога не берётся"
+    elif not armed:
+        if (
+            not state.unarmed_told
+            and state.unarmed_since is not None
+            and now - state.unarmed_since >= UNARMED_GRACE
+        ):
+            alarm = "unarmed"
+    elif threshold is None:
+        note += "; период соседа ни разу не прочитан - мерить нечем, тревога не берётся"
+    elif age is not None and age > threshold:
+        if state.alerted is None or now - state.alerted >= REPEAT:
+            alarm = "silence"
+        else:
+            held = True
+            note += "; тревога уже уходила меньше суток назад"
+
+    return Report(
+        ack=ack_line(
+            peer=peer,
+            last=state.at,
+            seen=state.seen,
+            res=res,
+            window=window,
+            stale=stale,
+            armed=armed,
+            threshold=threshold,
+            fallback=state.every_unknown,
+            full=full,
+            alert="fired" if alarm is not None else "held" if held else "none",
+        ),
+        stale=stale,
+        full=full,
+        armed=armed,
+        heard=heard,
+        age=age,
+        threshold=threshold,
+        alarm=alarm,
+        note=note,
+    )
+
+
+def alarm_text(report: Report, *, peer: str = PEER, mine_sent: bool) -> str:
+    """Текст человеку соседа. Различитель канала - последним абзацем."""
+    if report.alarm == "unarmed":
+        return (
+            f"Сторожевое кольцо с {peer} так и не заработало: за семь суток "
+            f"в сторожевой комнате не было ни одной его отметки `hb`, а значит "
+            f"сторожить нечего - прибор не вооружён (`armed=no`). Свою отметку "
+            f"мы печатаем и свой `ack` тоже"
+            + ("" if mine_sent else ", но сейчас она в комнату не ушла")
+            + ". Проверить стоит три вещи: та ли это комната (токен "
+            "`VIBEGRAM_HB_TOKEN` мог остаться от другой), запустил ли сосед "
+            "свою половину, и виден ли нам вообще чужой текст в этой комнате."
+        )
+    age = span(report.age) if report.age else "?"
+    threshold = span(report.threshold) if report.threshold else "?"
+    channel = (
+        "Наша собственная запись в комнату в этом же прогоне прошла, а от "
+        f"{peer} нет НИ `hb`, НИ `ack` - значит канал подозревать надо раньше, "
+        "чем смерть соседа: пишем мы в комнату, но чужого оттуда не читаем."
+        if mine_sent and not report.heard
+        else (
+            "Наша собственная запись в комнату в этом прогоне НЕ прошла - "
+            "первым делом канал, а не сосед."
+            if not mine_sent
+            else f"Что-то от {peer} в окне было (его `ack` или другая строка), "
+            "так что канал скорее жив, а молчит именно отметка."
+        )
+    )
+    return (
+        f"Сторожевая цепь молчит: последнюю отметку `hb {peer}` мы видели "
+        f"{age} назад при пороге {threshold} (порог - период из его же строки "
+        "× 1.5). Причин может быть три: машина соседа, его крон, или канал - "
+        f"сама комната. {channel}\n"
+        f"Это дело человека {peer}, а не наше: разбудить владельца имеет смысл "
+        "только чтобы он написал соседу по своему каналу. Повторно об этом "
+        "молчании мы скажем не раньше чем через сутки."
+    )

beaver_agent/hands/komodo.py

@@ -37,6 +37,29 @@ Action = Literal[
 ANSI = re.compile(r"\x1b\[[0-9;?]*[ -/]*[@-~]")
 EXIT_MARK = "__KOMODO_EXIT_CODE:"
 NOT_RUNNING_LIMIT = 15
+UPDATES_LIMIT = 15
+UPDATES_MAX = 200
+
+LIST_LIMIT = 500
+LIST_PAGES = 20
+"""Komodo режет любой ``List*`` до своего ``default_pagination_limit`` (у нас
+50) и молчит об этом: ответ - просто короткий массив, неотличимый от полного.
+Поэтому листаем сами, а не верим первой странице."""
+
+RESOURCE_LISTS = (
+    "ListStacks",
+    "ListServers",
+    "ListRepos",
+    "ListResourceSyncs",
+    "ListProcedures",
+    "ListActions",
+    "ListAlerters",
+    "ListDeployments",
+    "ListBuilds",
+)
+"""Журнал операций называет ресурс id, а не именем: отсюда берём словарь."""
+
+SCOPE_NOTE = "список ограничен правами ключа: вне их Komodo ресурсы не показывает"
 
 
 @dataclass(frozen=True, slots=True)
@@ -65,6 +88,9 @@ class Komodo:
         tail: int = 100,
         update: str | None = None,
         server: str | None = None,
+        limit: int = UPDATES_LIMIT,
+        operation: str | None = None,
+        resource: str | None = None,
     ) -> str:
         """Прод через Komodo: посмотреть, а по просьбе Бобра - подействовать.
 
@@ -74,7 +100,11 @@ class Komodo:
         - containers: контейнеры сервера (server; без него - все серверы).
         - logs: логи стека (stack, service опционально, tail строк).
         - search_logs: поиск по логам стека (stack, terms - слова через пробел).
-        - updates: последние операции - кто, что, статус.
+        - updates: последние операции - кто, что, статус. limit записей
+          (по умолчанию 15, максимум 200), operation - подстрока типа операции
+          (deploy, sync, restart), resource - имя стека, сервера, репозитория.
+          Шапка говорит, какой отрезок журнала показан: журнал длинный, и
+          «под фильтр ничего не попало» - это не «операций больше не было».
         - update: подробности одной операции по id (update).
         - deploy / restart: стек целиком или один service; ждёт исхода до 3 мин.
         - exec: команда внутри контейнера (container, command; server, если имя
@@ -98,7 +128,7 @@ class Komodo:
                     _need(stack, "stack"), _need(terms, "terms"), service
                 )
             case "updates":
-                return await self._updates()
+                return await self._updates(limit, operation, resource)
             case "update":
                 return await self._update(_need(update, "update"))
             case "deploy":
@@ -118,7 +148,7 @@ class Komodo:
 
     async def _status(self) -> str:
         servers, stacks = await asyncio.gather(
-            self.read("ListServers", {}), self.read("ListStacks", {})
+            self.listing("ListServers"), self.listing("ListStacks")
         )
         lines = [f"{s['name']:24} {s['info']['state']}" for s in servers]
         bad = [s for s in stacks if s["info"]["state"] != "running"]
@@ -127,10 +157,15 @@ class Komodo:
             f"  {s['info']['state']:12} {s['name']} @{s['info'].get('server_name')}"
             for s in bad[:NOT_RUNNING_LIMIT]
         )
+        if len(bad) > NOT_RUNNING_LIMIT:
+            lines.append(
+                f"показаны {NOT_RUNNING_LIMIT} из {len(bad)}, остальные скрыты лимитом"
+            )
+        lines.append(SCOPE_NOTE)
         return "\n".join(lines)
 
     async def _stacks(self) -> str:
-        stacks = await self.read("ListStacks", {})
+        stacks = await self.listing("ListStacks")
         lines = []
         for s in sorted(stacks, key=lambda s: s["name"]):
             info = s["info"]
@@ -141,17 +176,18 @@ class Komodo:
                 f"{info['state']:12} {s['name']:28} @{info.get('server_name')}"
                 + ("  (есть незадеплоенные коммиты)" if behind else "")
             )
+        lines.append(f"стеков: {len(stacks)}; {SCOPE_NOTE}")
         return "\n".join(lines)
 
     async def _containers(self, server: str | None) -> str:
         names = (
             [server]
             if server
-            else [s["name"] for s in await self.read("ListServers", {})]
+            else [s["name"] for s in await self.listing("ListServers")]
         )
         lines = []
         for name in names:
-            containers = await self.read("ListDockerContainers", {"server": name})
+            containers = await self.listing("ListDockerContainers", {"server": name})
             lines.append(f"{name}:")
             lines.extend(
                 f"  {c['state']:10} {c['name']:36} {c.get('status', '')}"
@@ -177,9 +213,67 @@ class Komodo:
         )
         return self._clip(_log_text(log))
 
-    async def _updates(self) -> str:
-        updates = (await self.read("ListUpdates", {}))["updates"][:15]
-        return "\n".join(_update_line(u) for u in updates) or "операций нет"
+    async def _updates(
+        self, limit: int, operation: str | None, resource: str | None
+    ) -> str:
+        want = min(max(limit, 1), UPDATES_MAX)
+        names = await self._resource_names()
+        query: dict[str, Any] = {}
+        applied = []
+        if operation:
+            query["operation"] = {"$regex": re.escape(operation), "$options": "i"}
+            applied.append(f"операция ~{operation}")
+        if resource:
+            ids = [i for i, name in names.items() if resource.lower() in name.lower()]
+            if not ids:
+                return (
+                    f"ресурса ~{resource} ключу руки не видно: "
+                    "либо имя другое, либо он вне прав ключа"
+                )
+            query["target.id"] = {"$in": ids}
+            applied.append(f"ресурс ~{resource} ({len(ids)} шт)")
+        updates, more = await self._update_pages(query, want)
+
+        head = [f"операций: {len(updates)}"]
+        if updates:
+            head.append(
+                f"{_ts(updates[-1]['start_ts'])} … {_ts(updates[0]['start_ts'])}"
+            )
+        head.append("раньше в журнале есть ещё" if more else "это весь журнал")
+        lines = [", ".join(head)]
+        lines.append(
+            "фильтрует Komodo: " + "; ".join(applied)
+            if applied
+            else "фильтра нет: это просто хвост журнала"
+        )
+        if want != limit:
+            lines.append(f"запрошено {limit} записей, предел руки {want}")
+        unseen = sum(1 for u in updates if u["target"]["id"] not in names)
+        if unseen:
+            lines.append(
+                f"записей о невидимых ключу ресурсах: {unseen} - id вместо имени"
+            )
+        lines.extend(_update_line(u, names) for u in updates)
+        return "\n".join(lines)
+
+    async def _update_pages(
+        self, query: dict[str, Any], want: int
+    ) -> tuple[list[dict[str, Any]], bool]:
+        """Страница ListUpdates - ровно 100 записей, limit там не работает."""
+        out: list[dict[str, Any]] = []
+        page: int | None = 0
+        while page is not None and len(out) < want:
+            body: dict[str, Any] = {"page": page}
+            if query:
+                body["query"] = query
+            answer = await self.read("ListUpdates", body)
+            out.extend(answer["updates"])
+            page = answer.get("next_page")
+        return out[:want], len(out) > want or page is not None
+
+    async def _resource_names(self) -> dict[str, str]:
+        lists = await asyncio.gather(*(self.listing(r) for r in RESOURCE_LISTS))
+        return {r["id"]: r["name"] for rows in lists for r in rows}
 
     async def _update(self, update_id: str) -> str:
         return self._clip(
@@ -224,12 +318,31 @@ class Komodo:
         return f"{header}\n{self._clip(output.strip())}"
 
     async def _server_of(self, container: str) -> str | None:
-        for s in await self.read("ListServers", {}):
-            containers = await self.read("ListDockerContainers", {"server": s["name"]})
+        for s in await self.listing("ListServers"):
+            containers = await self.listing(
+                "ListDockerContainers", {"server": s["name"]}
+            )
             if any(c["name"] == container for c in containers):
                 return s["name"]
         return None
 
+    async def listing(
+        self, request: str, params: dict[str, Any] | None = None
+    ) -> list[Any]:
+        """Любой ``List*`` целиком: страницами, пока Komodo не отдаст неполную.
+
+        Публичная: этим же листанием ходят джобы, второго такого не пишем.
+        """
+        out: list[Any] = []
+        for page in range(LIST_PAGES):
+            chunk = await self.read(
+                request, (params or {}) | {"page": page, "limit": LIST_LIMIT}
+            )
+            out.extend(chunk)
+            if len(chunk) < LIST_LIMIT:
+                break
+        return out
+
     async def _json(self, route: str, body: dict[str, Any]) -> Any:
         status, text = await self._post(route, body)
         if status != 200:
@@ -275,9 +388,10 @@ def _ts(ms: int) -> str:
     return datetime.fromtimestamp(ms / 1000, tz=UTC).strftime("%m-%d %H:%M")
 
 
-def _update_line(u: dict[str, Any]) -> str:
+def _update_line(u: dict[str, Any], names: dict[str, str]) -> str:
     ok = "ok" if u.get("success") else "FAIL"
-    head = f"{_ts(u['start_ts'])} {u['operation']:20} {u['status']:10} {ok}"
+    target = names.get(u["target"]["id"], u["target"]["id"])
+    head = f"{_ts(u['start_ts'])} {u['operation']:20} {target:26} {u['status']:10} {ok}"
     return f"{head} user={u.get('username')} id={u.get('id')}"
 
 

beaver_agent/hands/runs.py

@@ -0,0 +1,642 @@
+"""Сторож собственных прогонов: журнал `job_runs` наконец кто-то читает.
+
+Планировщик gateway пишет строку на каждый прогон джоба (`job_runs`: имя,
+статус, хвост трейсбека в `error`). Запись была всегда, читателя не было
+ни одного: канал к соседнему агенту лежал 38 часов подряд, планировщик
+честно записал это 231 раз, и до человека не доехало ничего. Этот модуль -
+вторая половина прибора: показание из таблицы превращается в тревогу.
+
+Что здесь считается показанием:
+
+- тревога берётся только с ХВОСТА: три и более `failed` подряд, считая от
+  последнего прогона джоба. Одиночный упавший прогон - сетевой чих, а не
+  болезнь, и будить на него человека значит выучить его не смотреть;
+- окно счёта - неделя, а не сутки: иначе суточный джоб не наберёт трёх
+  падений подряд никогда, и `отметка`, `закрытие`, `голосовой`, `память`
+  не охранялись бы вовсе;
+- отсутствие записей - тоже показание. Джоб с регулярным кроном, у которого
+  последний прогон старше `FACTOR` его периодов, «не запускался» - это
+  отдельная тревога, не «лежит». Период выводится из крона тем же
+  `every_from_cron`, что у сторожа соседа, и расписание, которое не
+  сводится к «раз в N часов», в давности не участвует и называется в логе
+  неохраняемым: подставить ему число значило бы соврать. Джобы без крона
+  (вебхуки, события) давностью не меряются вовсе, а джоб, которого в
+  журнале нет ни разу, молча ждёт своей первой записи;
+- пустая выдача - это показание о запросе, а не о здоровье джобов. Ноль
+  строк за сутки (кроме своих) означает, что планировщик вообще не
+  работал, и это отдельная тревога с отдельным текстом, а не тишина;
+- упавший запрос к БД - не показание вовсе: решает джоб, здесь такого
+  входа просто нет.
+
+Свои собственные прогоны из счёта выкинуты (`me`): джоб, который лежит,
+о себе не доложит - наблюдатель внутри объекта не сообщает о смерти
+объекта. Это дыра прибора, и она названа в README, а не заклеена.
+
+Текст тревоги проходит `mask`: из `error` берётся первая строка, режется
+по длине и чистится - общим `redact` gateway плюс два своих правила на то,
+что `redact` по конструкции не ловит внутри строки (`ИМЯ=значение` не с
+начала строки и хвост запроса у URL). Тревога уезжает в чат к диспетчеру,
+логи гейтвея видны в чатах - секрету тут негде быть.
+"""
+
+from __future__ import annotations
+
+import itertools
+import json
+import re
+from dataclasses import dataclass, field
+from datetime import UTC, datetime, timedelta
+from pathlib import Path  # noqa: TC003 - в аннотации dataclass
+from typing import TYPE_CHECKING
+
+from beaver_gateway.jobs.scheduler import next_run
+from beaver_gateway.security.redact import MASK, is_secret_name, redact
+
+from beaver_agent.hands.heartbeat import every_from_cron
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping, Sequence
+    from datetime import tzinfo
+
+__all__ = [
+    "DAY",
+    "ERROR_CHARS",
+    "FACTOR",
+    "FAILED",
+    "FORGET",
+    "MAX_LINES",
+    "REPEAT",
+    "STREAK",
+    "WINDOW",
+    "Clear",
+    "Quiet",
+    "Report",
+    "Resumed",
+    "Run",
+    "Runs",
+    "Streak",
+    "alarm_text",
+    "awake",
+    "clear_text",
+    "empty_text",
+    "first_line",
+    "look",
+    "mask",
+    "quiet_text",
+    "streak",
+]
+
+WINDOW = timedelta(days=7)
+"""Окно журнала: неделя. Суточный джоб набирает в нём три падения подряд за
+трое суток, недельный (`память`) - нет: у него три падения это три недели,
+и его охраняет давность, а не серия."""
+DAY = timedelta(hours=24)
+"""Окно тревоги о пустом журнале: сутки без единого чужого прогона."""
+FACTOR = 2
+"""Давность = столько периодов джоба без записи. Два - это «пропущено два
+срабатывания подряд»: один пропуск случается честно (передеплой пришёлся на
+минуту крона, а догонять пропущенное планировщик не умеет), два подряд -
+уже не случайность."""
+GRAIN = timedelta(minutes=1)
+"""Шаг, в котором период крона должен сводиться к целому: крон минутный."""
+LAG = timedelta(minutes=10)
+"""Запись в журнал ложится по КОНЦУ прогона: срабатывание моложе этого
+могло ещё не дописаться, и пропуском его не считаем."""
+STREAK = 3
+"""Сколько `failed` подряд считаем «джоб лежит»."""
+REPEAT = timedelta(hours=24)
+"""Чаще этого об одном и том же джобе не говорим."""
+FORGET = timedelta(days=7)
+"""Джоб, о котором тревожились, исчез из окна насовсем - забываем его молча:
+починки мы не видели, врать «отбой» не о чем."""
+ERROR_CHARS = 160
+"""Сколько букв первой строки ошибки уезжает человеку."""
+MAX_LINES = 10
+"""Сколько джобов перечисляем в одной тревоге: сразу всё не читают."""
+FAILED = "failed"
+_DAYS_FROM = timedelta(hours=48)
+STATE_VERSION = 1
+
+_PAIR = re.compile(r"(?=([A-Za-z][\w.-]{2,})\s*([:=])\s*([^\s,;)\]}\"']{6,}))")
+"""`ИМЯ=значение` где угодно в строке: общий `redact` ловит такие пары только
+с начала строки, а трейсбек кладёт их в середину. Просмотр нулевой длины -
+чтобы `RuntimeError: MSOS_MCP=…` не съедало секрет первой же парой: обычный
+`sub` откусил бы `RuntimeError:` вместе со значением и до вложенной пары
+не дошёл."""
+_QUERY = re.compile(r"(https?://[^\s?#]+)\?[^\s#]*")
+"""Хвост запроса у URL сносим целиком: имя параметра с ключом может быть любым."""
+
+
+def _iso(when: datetime | None) -> str | None:
+    if when is None:
+        return None
+    return when.astimezone(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _parse_iso(raw: str | None) -> datetime | None:
+    if not raw:
+        return None
+    try:
+        when = datetime.fromisoformat(raw)
+    except ValueError:
+        return None
+    return when if when.tzinfo else when.replace(tzinfo=UTC)
+
+
+def _plural(count: int, forms: tuple[str, str, str]) -> str:
+    if count % 10 == 1 and count % 100 != 11:
+        return forms[0]
+    if count % 10 in (2, 3, 4) and count % 100 not in (12, 13, 14):
+        return forms[1]
+    return forms[2]
+
+
+def _age(delta: timedelta) -> str:
+    """Возраст человеку: «4 часа», «45 минут», «15 суток». Секунды не нужны."""
+    minutes = max(int(delta.total_seconds()) // 60, 0)
+    if minutes < 60:
+        return f"{minutes} {_plural(minutes, ('минуту', 'минуты', 'минут'))}"
+    hours = minutes // 60
+    if delta >= _DAYS_FROM:
+        days = hours // 24
+        return f"{days} {_plural(days, ('сутки', 'суток', 'суток'))}"
+    return f"{hours} {_plural(hours, ('час', 'часа', 'часов'))}"
+
+
+def _period(delta: timedelta) -> str:
+    """Период крона: «10 минут», «24 часа», «7 суток» - без округления."""
+    minutes = int(delta.total_seconds()) // 60
+    if minutes % (24 * 60) == 0 and delta >= _DAYS_FROM:
+        days = minutes // (24 * 60)
+        return f"{days} {_plural(days, ('сутки', 'суток', 'суток'))}"
+    if minutes % 60 == 0:
+        hours = minutes // 60
+        return f"{hours} {_plural(hours, ('час', 'часа', 'часов'))}"
+    return f"{minutes} {_plural(minutes, ('минута', 'минуты', 'минут'))}"
+
+
+def _mask_pairs(text: str) -> str:
+    out: list[str] = []
+    pos = 0
+    for match in _PAIR.finditer(text):
+        if match.start(3) < pos or not is_secret_name(match[1]):
+            continue
+        out.append(text[pos : match.start(3)])
+        out.append(MASK)
+        pos = match.end(3)
+    out.append(text[pos:])
+    return "".join(out)
+
+
+def mask(text: str) -> str:
+    """Убрать из строки всё, что похоже на секрет, прежде чем её показывать."""
+    return _QUERY.sub(r"\1?" + MASK, _mask_pairs(redact(text)))
+
+
+def first_line(error: str | None) -> str:
+    """Первая строка ошибки - чистая и короткая. Трейсбек человеку не нужен."""
+    for line in mask(error or "").splitlines():
+        head = line.strip()
+        if not head:
+            continue
+        if len(head) > ERROR_CHARS:
+            head = head[: ERROR_CHARS - 1].rstrip() + "…"
+        return head
+    return "без текста ошибки"
+
+
+@dataclass(frozen=True, slots=True)
+class Run:
+    """Одна строка журнала: ровно то, на что мы смотрим, без ORM."""
+
+    id: int
+    job: str
+    status: str
+    started_at: datetime
+    error: str | None = None
+
+    @property
+    def failed(self) -> bool:
+        return self.status == FAILED
+
+
+@dataclass(frozen=True, slots=True)
+class Streak:
+    """Хвост подряд упавших прогонов одного джоба."""
+
+    job: str
+    count: int
+    since: datetime
+    """Начало серии - первое падение из тех, что видно в окне."""
+    age: timedelta
+    error: str
+    capped: bool
+    """Серия упёрлась в край окна: падений было НЕ МЕНЬШЕ `count`, а сколько
+    на самом деле - за неделей не видно, и врать точным числом нельзя."""
+
+
+@dataclass(frozen=True, slots=True)
+class Quiet:
+    """Джоб с кроном, который перестал запускаться."""
+
+    job: str
+    age: timedelta
+    """Сколько прошло с начала последнего прогона - любого, хоть упавшего."""
+    period: timedelta
+
+
+@dataclass(frozen=True, slots=True)
+class Resumed:
+    """Джоб, о молчании которого говорили, снова запустился."""
+
+    job: str
+    status: str
+
+
+@dataclass(frozen=True, slots=True)
+class Clear:
+    """Джоб, о котором мы тревожились, больше не лежит."""
+
+    job: str
+    status: str
+    """Статус последнего прогона."""
+    count: int
+    """Сколько подряд упавших осталось в хвосте: 0 - чисто."""
+
+
+@dataclass(slots=True)
+class Runs:
+    """Состояние между прогонами: кому и когда уже сказали."""
+
+    path: Path
+    alerted: dict[str, datetime] = field(default_factory=dict)
+    """Джоб → когда о нём ушла тревога. Он же признак «сейчас в тревоге»."""
+    quiet: dict[str, datetime] = field(default_factory=dict)
+    """То же для «не запускался»: отдельно, у тревог разные отбои."""
+    empty_alerted: datetime | None = None
+
+    @classmethod
+    def load(cls, path: Path) -> Runs:
+        try:
+            raw = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            return cls(path=path)
+        if raw.get("version") != STATE_VERSION:
+            return cls(path=path)
+        return cls(
+            path=path,
+            alerted=_stamps(raw.get("alerted")),
+            quiet=_stamps(raw.get("quiet")),
+            empty_alerted=_parse_iso(raw.get("empty_alerted")),
+        )
+
+    def save(self) -> None:
+        body = {
+            "version": STATE_VERSION,
+            "alerted": {job: _iso(when) for job, when in sorted(self.alerted.items())},
+            "quiet": {job: _iso(when) for job, when in sorted(self.quiet.items())},
+            "empty_alerted": _iso(self.empty_alerted),
+        }
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = self.path.with_suffix(".tmp")
+        tmp.write_text(json.dumps(body, ensure_ascii=False, indent=1), encoding="utf-8")
+        tmp.replace(self.path)
+
+
+def _stamps(raw: dict[str, str] | None) -> dict[str, datetime]:
+    out = {}
+    for job, when in (raw or {}).items():
+        parsed = _parse_iso(str(when))
+        if parsed is not None:
+            out[str(job)] = parsed
+    return out
+
+
+@dataclass(frozen=True, slots=True)
+class Report:
+    """Что решил один прогон сторожа журнала."""
+
+    alarms: tuple[Streak, ...]
+    clears: tuple[Clear, ...]
+    empty: bool
+    """Прогонов за сутки не было вовсе - тревога о планировщике, не о джобе."""
+    seen: int
+    """Сколько чужих прогонов было в окне."""
+    mine: int
+    """Сколько своих - их в счёт не берём, но в тексте называем."""
+    note: str
+    quiet: tuple[Quiet, ...] = ()
+    resumed: tuple[Resumed, ...] = ()
+    unguarded: tuple[str, ...] = ()
+    """Джобы с кроном, у которого нет регулярного периода: давностью не меряем."""
+
+
+def streak(runs: Sequence[Run], *, now: datetime) -> Streak | None:
+    """Хвост падений одного джоба, считая от последнего прогона.
+
+    `runs` - прогоны одного джоба, новейший первым. Серия, упёршаяся в край
+    окна, помечается `capped`: её настоящую длину мы не знаем.
+    """
+    failures = list(itertools.takewhile(lambda run: run.failed, runs))
+    if not failures:
+        return None
+    oldest = failures[-1]
+    return Streak(
+        job=failures[0].job,
+        count=len(failures),
+        since=oldest.started_at,
+        age=now - oldest.started_at,
+        error=first_line(failures[0].error),
+        capped=len(failures) == len(runs),
+    )
+
+
+def look(
+    state: Runs,
+    runs: Sequence[Run],
+    *,
+    now: datetime,
+    me: str,
+    crons: Mapping[str, str] | None = None,
+    latest: Mapping[str, Run] | None = None,
+    tz: tzinfo = UTC,
+    boot: datetime | None = None,
+) -> Report:
+    """Разобрать окно журнала и решить, о чём говорить человеку.
+
+    `crons` - джоб → крон, только джобы с кроном; `latest` - последний прогон
+    каждого джоба за ВСЮ историю журнала, а не за окно; `boot` - старт
+    процесса. Без `crons` давность не проверяется вовсе.
+
+    Состояние здесь только чистится от забытых джобов; отметки «сказали» и
+    «сказали про пустоту» ставит джоб - и только когда тревога действительно
+    ушла: несостоявшаяся доставка не должна заглушать следующий прогон.
+    """
+    mine = [run for run in runs if run.job == me]
+    others = sorted(
+        (run for run in runs if run.job != me), key=lambda run: run.id, reverse=True
+    )
+    if not any(now - run.started_at < DAY for run in others):
+        quiet = state.empty_alerted is not None and now - state.empty_alerted < REPEAT
+        return Report(
+            alarms=(),
+            clears=(),
+            empty=not quiet,
+            seen=len(others),
+            mine=len(mine),
+            note=(
+                f"чужих прогонов за сутки нет вовсе (своих {len(mine)})"
+                + ("; о пустоте уже говорили меньше суток назад" if quiet else "")
+            ),
+        )
+
+    by_job: dict[str, list[Run]] = {}
+    for run in others:
+        by_job.setdefault(run.job, []).append(run)
+
+    alarms: list[Streak] = []
+    clears: list[Clear] = []
+    held: list[str] = []
+    for job, rows in by_job.items():
+        tail = streak(rows, now=now)
+        if tail is not None and tail.count >= STREAK:
+            told = state.alerted.get(job)
+            if told is None or now - told >= REPEAT:
+                alarms.append(tail)
+            else:
+                held.append(job)
+        elif job in state.alerted:
+            clears.append(
+                Clear(
+                    job=job,
+                    status=rows[0].status,
+                    count=0 if tail is None else tail.count,
+                )
+            )
+
+    forgotten = [
+        job
+        for job, told in state.alerted.items()
+        if job not in by_job and now - told >= FORGET
+    ]
+    for job in forgotten:
+        del state.alerted[job]
+
+    note = (
+        f"прогонов за неделю {len(others)} по {len(by_job)} джобам (своих {len(mine)})"
+    )
+    if alarms:
+        note += "; лежат: " + ", ".join(sorted(tail.job for tail in alarms))
+    if held:
+        note += "; уже говорили меньше суток назад: " + ", ".join(sorted(held))
+    if clears:
+        note += "; починились: " + ", ".join(sorted(clear.job for clear in clears))
+    if forgotten:
+        note += "; забыты (пропали из окна): " + ", ".join(sorted(forgotten))
+
+    silence = _silence(
+        state,
+        mine,
+        now=now,
+        me=me,
+        crons=crons or {},
+        latest=latest or {},
+        tz=tz,
+        boot=boot,
+    )
+
+    return Report(
+        alarms=tuple(sorted(alarms, key=lambda tail: tail.count, reverse=True)),
+        clears=tuple(sorted(clears, key=lambda clear: clear.job)),
+        empty=False,
+        seen=len(others),
+        mine=len(mine),
+        note=note + silence.note,
+        quiet=silence.quiet,
+        resumed=silence.resumed,
+        unguarded=silence.unguarded,
+    )
+
+
+@dataclass(frozen=True, slots=True)
+class _Silence:
+    quiet: tuple[Quiet, ...]
+    resumed: tuple[Resumed, ...]
+    unguarded: tuple[str, ...]
+    note: str
+
+
+def awake(
+    mine: Sequence[Run], *, now: datetime, step: timedelta, boot: datetime | None
+) -> datetime:
+    """С какого момента планировщик заведомо крутил некритичные джобы.
+
+    Показание - собственные прогоны сторожа: он сам некритичный, и когда
+    гейтвей лежит или бюджет зажат (`throttled` откладывает некритичный крон
+    без записи в журнал), его прогонов нет так же, как и чужих. Цепочка своих
+    прогонов без разрыва длиннее `step`, считая от сейчас, плюс старт
+    процесса - это время, за которое чужой пропуск действительно пропуск,
+    а не общий простой.
+    """
+    anchor = now
+    for run in sorted(mine, key=lambda run: run.started_at, reverse=True):
+        if anchor - run.started_at > step:
+            break
+        anchor = min(anchor, run.started_at)
+    return anchor if boot is None else max(anchor, boot)
+
+
+def _silence(
+    state: Runs,
+    mine: Sequence[Run],
+    *,
+    now: datetime,
+    me: str,
+    crons: Mapping[str, str],
+    latest: Mapping[str, Run],
+    tz: tzinfo,
+    boot: datetime | None,
+) -> _Silence:
+    """Давность: какие джобы с кроном перестали запускаться."""
+    own = every_from_cron(crons.get(me), tz, now=now, grain=GRAIN)
+    guarded: dict[str, timedelta] = {}
+    unguarded: list[str] = []
+    for job, cron in crons.items():
+        if job == me:
+            continue
+        period = every_from_cron(cron, tz, now=now, grain=GRAIN)
+        if period is None:
+            unguarded.append(job)
+        else:
+            guarded[job] = period
+
+    note = ""
+    if unguarded:
+        note += "; давностью не охраняются (крон без регулярного периода): " + (
+            ", ".join(sorted(unguarded))
+        )
+    dropped = [job for job in state.quiet if job not in guarded]
+    for job in dropped:
+        del state.quiet[job]
+    if dropped:
+        note += "; сняты с давности (нет в расписании): " + ", ".join(sorted(dropped))
+    if not guarded:
+        return _Silence((), (), tuple(sorted(unguarded)), note)
+    if own is None:
+        # Свой период не выведен - нет и опоры, когда планировщик заведомо
+        # работал. Любое число тут было бы выдумано.
+        note += "; свой крон без регулярного периода - давность не проверяется"
+        return _Silence((), (), tuple(sorted(unguarded)), note)
+
+    since = awake(mine, now=now, step=own * FACTOR, boot=boot)
+    quiet: list[Quiet] = []
+    resumed: list[Resumed] = []
+    held: list[str] = []
+    fresh: list[str] = []
+    for job, period in guarded.items():
+        last = latest.get(job)
+        if last is None:
+            fresh.append(job)
+            continue
+        age = now - last.started_at
+        # Порог не тоньше собственного: чаще раза в час сторож не смотрит, и
+        # пропуск короче двух своих периодов неотличим от его же слепоты.
+        overdue = (
+            age > max(period, own) * FACTOR
+            and next_run(crons[job], tz, max(last.started_at, since)) <= now - LAG
+        )
+        told = state.quiet.get(job)
+        if overdue:
+            if told is None or now - told >= REPEAT:
+                quiet.append(Quiet(job=job, age=age, period=period))
+            else:
+                held.append(job)
+        elif told is not None and last.started_at > told:
+            resumed.append(Resumed(job=job, status=last.status))
+
+    if fresh:
+        note += "; ещё ни разу не запускались: " + ", ".join(sorted(fresh))
+    if quiet:
+        note += "; не запускаются: " + ", ".join(sorted(q.job for q in quiet))
+    if held:
+        note += "; о молчании уже говорили меньше суток назад: " + ", ".join(
+            sorted(held)
+        )
+    if resumed:
+        note += "; снова запускаются: " + ", ".join(sorted(r.job for r in resumed))
+    return _Silence(
+        quiet=tuple(sorted(quiet, key=lambda q: q.age, reverse=True)),
+        resumed=tuple(sorted(resumed, key=lambda r: r.job)),
+        unguarded=tuple(sorted(unguarded)),
+        note=note,
+    )
+
+
+def streak_line(tail: Streak) -> str:
+    """«джоб `вайбграм` лежит 4 часа, 24 прогона подряд с 12.09 18:00 UTC: …»."""
+    runs = f"{tail.count} {_plural(tail.count, ('прогон', 'прогона', 'прогонов'))}"
+    return (
+        f"джоб `{tail.job}` лежит {_age(tail.age)}"
+        f"{' и дольше' if tail.capped else ''}, {runs} подряд с "
+        f"{tail.since.astimezone(UTC).strftime('%d.%m %H:%M UTC')}"
+        + (" (это всё окно недели, серия началась раньше)" if tail.capped else "")
+        + f": {tail.error}"
+    )
+
+
+def alarm_text(report: Report) -> str:
+    """Тревога человеку: что лежит, сколько и с какой ошибкой."""
+    lines = [f"- {streak_line(tail)}" for tail in report.alarms[:MAX_LINES]]
+    rest = len(report.alarms) - len(lines)
+    if rest > 0:
+        lines.append(f"- и ещё {rest} {_plural(rest, ('джоб', 'джоба', 'джобов'))}")
+    return "\n".join(lines)
+
+
+def quiet_line(quiet: Quiet) -> str:
+    """«джоб `закрытие` не запускался 50 часов при периоде 24 часа»."""
+    return (
+        f"джоб `{quiet.job}` не запускался {_age(quiet.age)} "
+        f"при периоде {_period(quiet.period)}"
+    )
+
+
+def quiet_text(report: Report) -> str:
+    """Тревога о молчании: какие джобы с кроном перестали запускаться."""
+    lines = [f"- {quiet_line(quiet)}" for quiet in report.quiet[:MAX_LINES]]
+    rest = len(report.quiet) - len(lines)
+    if rest > 0:
+        lines.append(f"- и ещё {rest} {_plural(rest, ('джоб', 'джоба', 'джобов'))}")
+    return "\n".join(lines)
+
+
+def resumed_line(resumed: Resumed) -> str:
+    return f"отбой: джоб `{resumed.job}` снова запускается ({resumed.status})"
+
+
+def clear_line(clear: Clear) -> str:
+    if clear.count == 0:
+        return f"отбой: джоб `{clear.job}` снова проходит ({clear.status})"
+    return (
+        f"отбой: джоб `{clear.job}` больше не лежит подряд "
+        f"(упавших в хвосте {clear.count}, порог {STREAK})"
+    )
+
+
+def clear_text(report: Report) -> str:
+    lines = [clear_line(clear) for clear in report.clears]
+    lines += [resumed_line(resumed) for resumed in report.resumed]
+    return "\n".join(f"- {line}" for line in lines)
+
+
+def empty_text(report: Report) -> str:
+    """Отдельная тревога: за сутки не отработал вообще никто."""
+    return (
+        f"За последние сутки в журнале прогонов (`job_runs`) нет ни одной записи, "
+        f"кроме моих собственных (их {report.mine}): не отработал ни один джоб. "
+        "Это показание о планировщике, а не о каком-то одном джобе. Смотреть "
+        "стоит три вещи: поднялся ли планировщик вообще (в логе gateway "
+        "`scheduler: no postgres driver - cron and webhooks are off`), живы ли "
+        "кроны в pgqueuer, и не заведена ли база заново - на пустой базе эта же "
+        "тревога выглядит так же."
+    )

beaver_agent/hands/vibegram.py

@@ -10,6 +10,11 @@
 `/api/pending` - курсор на стороне хаба: прочитанное второй раз не
 приходит. Поэтому клиент помнит последние события сам: тулза `read`
 показывает их, если новых нет, - мастер увидит то, что уже разобрал триаж.
+
+Там, где нужен не «что нового», а «последние N строк комнаты» (сторож) или
+«всё после события #N» (`read since=` / `read last=` у мастера), курсор не
+годится в принципе: `history` читает историю через `/api/state`, не трогая
+курсор и ничего не вычёркивая.
 """
 
 from __future__ import annotations
@@ -20,16 +25,23 @@ from dataclasses import dataclass, field
 from datetime import UTC, datetime
 from pathlib import Path  # noqa: TC003 - в аннотации dataclass
 from typing import Any, Literal
+from urllib.parse import quote
 from zoneinfo import ZoneInfo
 
 import aiohttp
 
-__all__ = ["Action", "Event", "Vibegram"]
+__all__ = ["Action", "Event", "Vibegram", "Window"]
 
 Action = Literal["read", "send", "who", "work", "plan", "claim", "release", "card"]
 
 USER_AGENT = "beaver-agent/0.1 (+vibegram)"
 REMEMBER = 40
+PAGE = 200
+"""Сколько событий комнаты хаб отдаёт за одну страницу `/api/state`: его
+потолок, а не наша просьба - `limit` там не слушают."""
+PAGES = 25
+"""Потолок дочитывания истории. Упёрлись - окно объявляем неполным, а не
+выдаём за хвост то, что оказалось под рукой."""
 
 
 @dataclass(frozen=True, slots=True)
@@ -43,6 +55,19 @@ class Event:
     def line(self) -> str:
         return f"[{self.at}] {self.text}"
 
+    def tagged(self) -> str:
+        return f"#{self.id} {self.line()}"
+
+
+@dataclass(frozen=True, slots=True)
+class Window:
+    """Хвост комнаты: последние сообщения и честный признак полноты."""
+
+    events: list[Event]
+    full: bool
+    """История дочитана до конца: в `events` действительно ПОСЛЕДНИЕ сообщения.
+    Ложь здесь - это «в окне никого» там, где окно просто не дочитано."""
+
 
 @dataclass(slots=True)
 class Vibegram:
@@ -66,12 +91,19 @@ class Vibegram:
         note: str | None = None,
         about: str | None = None,
         skills: list[str] | None = None,
+        since: int | None = None,
+        last: int | None = None,
     ) -> str:
         """Вайбграм - комната агентов (чужие клоды и ты) вокруг общей репы.
 
         action:
         - read: что нового с прошлого раза (сообщения, claim'ы, план); если
-          нового нет - последние уже виденные события.
+          нового нет - последние уже виденные события. Курсор общий с
+          крон-триажем: прочитанное здесь второй раз не придёт.
+        - read since=N / read last=N: история комнаты - всё после события #N
+          или последние N сообщений. Ничего не съедает, спрашивать можно
+          сколько угодно раз. Вывод «сосед молчит» брать только отсюда: пустой
+          read - это «крон уже выгреб», а не «никто не ответил».
         - send: написать в комнату (text). Это доска объявлений, не чат:
           пиши, когда добавляешь информацию; адресовать - @ник.
         - who: кто в комнате, что умеет, что держит.
@@ -86,7 +118,7 @@ class Vibegram:
         """
         match action:
             case "read":
-                return await self._read()
+                return await self._read(since=since, last=last)
             case "send":
                 return await self._send(_need(text, "text"))
             case "who":
@@ -151,19 +183,96 @@ class Vibegram:
             )
         return fresh
 
+    async def window(self, limit: int, *, pages: int = PAGES) -> Window:
+        """Последние `limit` СООБЩЕНИЙ этой комнаты: хвост истории, не курсор.
+
+        `pending` для окна не годится вовсе: это курсор на стороне хаба, он
+        отдаёт только то, чего мы ещё не видели, и ту же строку второй раз не
+        пришлёт - следующий прогон увидит пустое окно на живой комнате.
+
+        Хвост берём из `/api/state?view=…`: события там уже отфильтрованы по
+        комнате (ключ - `viewToken` этой комнаты, id у хаба сквозные по всем
+        комнатам), но страницы идут ВПЕРЁД, по `PAGE` штук от `after=<id>`, -
+        назад хаб не пагинирует и `limit` не слушает. Поэтому проходим историю
+        от начала, держа в руке только последние `limit` сообщений. `join` и
+        `leave` в окно не берём: это бухгалтерия хаба, а не строки соседа.
+
+        `viewToken` спрашиваем каждый раз заново: протухший в кэше ключ - ровно
+        то тихое враньё, ради которого окно и переписано.
+        """
+        return await self.history(limit=limit, pages=pages)
+
+    async def history(
+        self, *, after: int = 0, limit: int | None = None, pages: int = PAGES
+    ) -> Window:
+        """Сообщения комнаты после события `after`, хвостом не длиннее `limit`.
+
+        Непотребляющий проход по `/api/state`: курсор `/api/pending` остаётся
+        там, где стоял, поэтому спрашивать можно сколько угодно раз.
+        `limit=None` - всё, что нашлось после `after`.
+        """
+        view = quote(str((await self._get("/api/room"))["room"]["viewToken"]))
+        tail: deque[Event] = deque(maxlen=limit)
+        full = False
+        for _ in range(pages):
+            page = await self._get(f"/api/state?view={view}&after={after}")
+            raw = page.get("events") or []
+            for item in raw:
+                if item.get("kind") != "message":
+                    continue
+                event = _event(item, self.tz)
+                if event is not None:
+                    tail.append(event)
+            top = max((int(item.get("id") or 0) for item in raw), default=after)
+            if len(raw) < PAGE or top <= after:
+                full = True
+                break
+            after = top
+        return Window(events=list(tail), full=full)
+
+    async def say(self, text: str) -> None:
+        """Написать в комнату; сбой хаба - исключение, а не строка.
+
+        Тулза мастера мягче (`_send` превращает rate limit в текст), но
+        механизмам нужен отказ, который видно: сторож по нему отличает
+        мёртвый канал от мёртвого соседа.
+        """
+        await self._post("/api/messages", {"body": text})
+
     def mentioned(self, events: list[Event]) -> bool:
         needle = f"@{self.nick}".lower()
         return any(needle in e.text.lower() for e in events)
 
-    async def _read(self) -> str:
+    async def _read(self, *, since: int | None = None, last: int | None = None) -> str:
+        if since is not None or last is not None:
+            return await self._history(since=since, last=last)
         fresh = await self.pending()
         if fresh:
-            return self._clip("\n".join(e.line() for e in fresh))
+            return self._clip("\n".join(e.tagged() for e in fresh))
         if self._recent:
-            tail = "\n".join(e.line() for e in list(self._recent)[-10:])
+            tail = "\n".join(e.tagged() for e in list(self._recent)[-10:])
             return f"нового нет; последнее, что было:\n{tail}"
         return "нового нет"
 
+    async def _history(self, *, since: int | None, last: int | None) -> str:
+        if last is not None and last <= 0:
+            msg = "last - сколько последних сообщений показать, нужно число больше нуля"
+            raise ValueError(msg)
+        after = max(since or 0, 0)
+        window = await self.history(after=after, limit=last)
+        if not window.events:
+            if not window.full:
+                return f"историю после #{after} не дочитали до конца, пусто пока"
+            return (
+                f"после #{after} сообщений нет (история дочитана)"
+                if after
+                else "сообщений в комнате нет"
+            )
+        lines = [e.tagged() for e in window.events]
+        if not window.full:
+            lines.insert(0, "окно неполное: до конца истории не дочитали")
+        return self._clip("\n".join(lines))
+
     async def _send(self, text: str) -> str:
         try:
             await self._post("/api/messages", {"body": text})

beaver_agent/jobs/__init__.py

@@ -8,10 +8,13 @@ from beaver_gateway.jobs.scheduler import Job
 
 from beaver_agent.jobs.closing import close_idle
 from beaver_agent.jobs.deploy import deploy
+from beaver_agent.jobs.heartbeat import beat, watch
 from beaver_agent.jobs.komodo import komodo_alert
 from beaver_agent.jobs.leisure import tick
+from beaver_agent.jobs.logs import logs_watch
 from beaver_agent.jobs.memory import curate, memory
 from beaver_agent.jobs.rotation import rotate
+from beaver_agent.jobs.runs import watch_runs
 from beaver_agent.jobs.t3code import t3code_event
 from beaver_agent.jobs.vibegram import vibegram
 from beaver_agent.jobs.voice import rotate_voice
@@ -26,9 +29,31 @@ jobs = [
     *([] if LEISURE_OFF else [Job("досуг", tick, cron="7 * * * *")]),
     Job("вайбграм", vibegram, cron="*/10 * * * *", critical=False),
     Job("закрытие", close_idle, cron="20 4 * * *", critical=False),
+    # Сторожевое кольцо с чужим агентом. Кроны читаются в локальной зоне, а
+    # сосед печатает свою отметку в 05:00 UTC - вечер по Варшаве разводит нас
+    # на полсуток, и его строка лежит в комнате задолго до нашего прогона.
+    # Частоты тут две, и они разные: отметка суточная (её период мы обещаем
+    # соседу), а проверка - вчетверо чаще. Сторож с шагом в сутки при пороге
+    # 36 ч обнаруживал бы молчание только через ~60 ч, то есть мерил бы не то,
+    # ради чего заведён; чтение 25 событий стоит копейки.
+    Job("отметка", beat, cron="12 17 * * *", critical=False),
+    Job("сторож", watch, cron="42 */6 * * *", critical=False),
+    # Сторож собственного журнала прогонов. Час - это компромисс: джоб,
+    # упавший три раза подряд, лежит уже заметно дольше часа, так что чаще
+    # смысла нет, а реже - тревога стареет на свой же период. Этот же час -
+    # разрешение давности: молчание короче двух часов он не различает.
+    # ":27" выбрана пустой: на ":00" ротация и куратор, на ":40" логи, на
+    # ":42" сторож соседа, а собственный прогон этого джоба не должен ждать
+    # очереди за чужим спавном.
+    Job("прогоны", watch_runs, cron="27 * * * *", critical=False),
     Job("память", memory, cron="30 4 * * 0", critical=False),
     Job("голосовой", rotate_voice, cron="5 4 * * *", critical=False),
     Job("куратор", curate, cron="0 2,8,12,16,20 * * *", critical=False),
+    # Логи - раз в 3 часа и на ":40": на ":00" ротация и куратор. Чаще смысла
+    # мало (36 стеков = 36 чтений за проход), реже - хвост уезжает совсем.
+    # Проход 01:40 - первый после полуночи: он же несёт суточную сводку по
+    # длящемуся, чтобы фон не исчезал из виду, доложенный однажды.
+    Job("логи", logs_watch, cron="40 1,4,7,10,13,16,19,22 * * *", critical=False),
     Job("deploy", deploy, webhook=True),
     Job("komodo", komodo_alert, webhook=True, dedupe=False),
     Job("t3code", t3code_event, webhook=True, dedupe=False),

beaver_agent/jobs/closing.py

@@ -1,4 +1,4 @@
-"""Ночью после ротации: глубокие чаты, тихие два дня, закрываются, не больше трёх."""
+"""Ночью после ротации: тихие глубокие чаты - с выжимкой, тихие ветки - молча."""
 
 from __future__ import annotations
 
@@ -21,3 +21,5 @@ async def close_idle(run: JobRun) -> None:
             result.digest.path if result.digest else None,
             result.error,
         )
+    for branch in await run.close_quiet(kind="branch", days=3):
+        _log.info("closed quiet branch %s «%s»", branch.external_id, branch.title)

beaver_agent/jobs/heartbeat.py

@@ -0,0 +1,137 @@
+"""Сторожевое кольцо с чужим агентом: своя отметка и слежка за его молчанием.
+
+Два джоба, оба раз в сутки и оба в отдельной комнате вайбграма (второй
+экземпляр клиента, `VIBEGRAM_HB`):
+
+- `beat` печатает `hb <ник> at=… boot=… every=… src=…`. Период не константа:
+  он выведен из крона ЭТОГО ЖЕ джоба (`run.job.cron`) - что зарегистрировано
+  у планировщика, то и написано в строке. Не сводится к «раз в N часов» -
+  пишем `every=unknown`, потому что соврать числом хуже, чем отказаться.
+  В день, помеченный в `DRILL_FILE`, отметка не уходит: так проверяют, что
+  тревога на той стороне жива, а не только что она молчит на живой цепи;
+- `watch` читает окно - последние `WINDOW` сообщений САМОЙ комнаты, а не
+  «что нового с курсора», - сверяет возраст последней отметки соседа с
+  порогом из ЕГО ЖЕ строки, печатает в комнату `ack` и - если цепь молчит -
+  отдаёт тревогу мастеру через `run.spawn_job`, как это делает триаж
+  вайбграма: будить ли владельца, решает диспетчер.
+
+Токена сторожевой комнаты нет - оба джоба молча ничего не делают, а о том,
+что сторож не сконфигурирован, один раз сказано в логе при старте
+(`beaver_agent/hands/__init__.py`).
+"""
+
+from __future__ import annotations
+
+import logging
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING
+
+from beaver_agent.hands import VIBEGRAM_HB
+from beaver_agent.hands.heartbeat import (
+    BOOT,
+    PEER,
+    WINDOW,
+    Watch,
+    alarm_text,
+    beat_line,
+    drill,
+    every_from_cron,
+    look,
+)
+from beaver_agent.vault import STATE_DIR
+
+if TYPE_CHECKING:
+    from beaver_gateway.jobs.scheduler import JobRun
+
+_log = logging.getLogger(__name__)
+
+STATE_FILE = STATE_DIR / "сторож.json"
+"""Что видели в прошлый прогон: без файла сторож после передеплоя считает,
+что соседа не видел ни разу, и разоружается сам по себе."""
+
+DRILL_FILE = STATE_DIR / "сторож-учения.txt"
+"""Даты учений, по одной `YYYY-MM-DD` на строку, локальные в зоне планировщика.
+В такой день `beat` молчит в комнате - в этом и учения: проверяем, что тревога
+у соседа действительно срабатывает. Файл, а не константа и не переменная среды:
+даты меняются от учений к учениям, а передеплой ради них не нужен."""
+
+TITLE = "сторож"
+
+BRIEF = (
+    "Сторожевое кольцо с чужим агентом {peer} (взаимные отметки раз в сутки "
+    "в отдельной комнате вайбграма) подняло тревогу.\n"
+    "{body}\n"
+    'Будить владельца - inject(conversation="master", urgency="wake", '
+    "text=до 3 строк: что цепь молчит, сколько молчит и какие три причины). "
+    "Это не авария у нас: наша половина работает, молчит чужая. "
+    "Если inject вернул ошибку - это сбой доставки, а не «не срочно»: "
+    "повтори один раз с тем же текстом."
+)
+
+
+async def beat(run: JobRun) -> None:
+    """Отметка о том, что мы живы. Не ушла - джоб падает, это видно в прогонах.
+
+    В день из `DRILL_FILE` отметка не уходит вовсе: учения - это МОЛЧАНИЕ в
+    комнате, и любой текст туда («сегодня пропускаем») их бы и отменил. Видно
+    такой прогон только в логе.
+    """
+    if VIBEGRAM_HB is None:
+        return
+    now = datetime.now(UTC)
+    if drill(DRILL_FILE, now=now, tz=run.scheduler.tz):
+        _log.info(
+            "сторож: отметка пропущена по флагу учений %s (%s)",
+            DRILL_FILE,
+            now.astimezone(run.scheduler.tz).strftime("%Y-%m-%d"),
+        )
+        return
+    line = beat_line(
+        nick=VIBEGRAM_HB.nick,
+        at=now,
+        boot=BOOT,
+        every=every_from_cron(run.job.cron, run.scheduler.tz),
+    )
+    await VIBEGRAM_HB.say(line)
+    _log.info("сторож: отметка ушла - %s", line)
+
+
+async def watch(run: JobRun) -> None:
+    """Прогон сторожа: окно → решение → `ack` в комнату → тревога, если молчит."""
+    if VIBEGRAM_HB is None:
+        return
+    try:
+        window = await VIBEGRAM_HB.window(WINDOW)
+    except Exception:  # noqa: BLE001 - любой отказ хаба это отсутствие показания
+        # Окно не прочитано - показания нет вовсе, и тревога тут запрещена
+        # ровно так же, как на съехавшем окне: молчание хаба это не молчание
+        # соседа. Говорим об этом в лог, состояние не трогаем.
+        _log.exception("сторож: комната не прочитана, прогон без показания")
+        return
+    state = Watch.load(STATE_FILE)
+    report = look(
+        state,
+        window.events,
+        now=datetime.now(UTC),
+        res=every_from_cron(run.job.cron, run.scheduler.tz),
+        full=window.full,
+    )
+    sent = True
+    try:
+        await VIBEGRAM_HB.say(report.ack)
+    except Exception as exc:  # noqa: BLE001 - своя запись не прошла, это различитель
+        sent = False
+        _log.warning("сторож: свой ack в комнату не ушёл: %s", exc)
+    _log.info("сторож: %s | %s", report.ack, report.note)
+    if report.alarm is not None:
+        await run.spawn_job(
+            agent="beaver-triage",
+            title=TITLE,
+            text=BRIEF.format(peer=PEER, body=alarm_text(report, mine_sent=sent)),
+        )
+        now = datetime.now(UTC)
+        if report.alarm == "silence":
+            state.alerted = now
+        else:
+            state.unarmed_told = True
+    state.save()

beaver_agent/jobs/leisure.py

@@ -6,19 +6,26 @@
 `мета/бобер/досуг.md` и пишется моделью; механизм его только читает, поэтому
 переписать друг друга они не могут. Сколько досуговых слотов израсходовано,
 считается из плана и текущего часа, а не из журнала - хранить нечего.
+
+Два своих часа в сутках пустые: дела в них не заходят вовсе, и к тику
+приложено эхо - абзац из его же старого дневника или из мыслей Бобра. Тик
+называет и файлы дня: дневник для того, что он думает, журнал для следов.
 """
 
 from __future__ import annotations
 
 import logging
+import random
 import re
 from dataclasses import dataclass
 from datetime import UTC, datetime, timedelta
 from typing import TYPE_CHECKING
 
-from beaver_agent.vault import LEISURE, VAULT, ZONE, read
+from beaver_agent.vault import JOURNAL, LEISURE, OWN_DIARY, THOUGHTS, VAULT, ZONE, read
 
 if TYPE_CHECKING:
+    from pathlib import Path
+
     from beaver_gateway.jobs.scheduler import JobRun
     from beaver_gateway.storage.models import Conversation
 
@@ -32,6 +39,15 @@ QUIET_TICKS = (4, 6, 8, 10)
 MINE_DEFAULT = (13, 15, 18, 21, 0, 2, 6)
 MINE_MIN = 7
 """Меньше семи чистых слотов в сутках не бывает: недостающие механизм доберёт."""
+EMPTY_DEFAULT = (18, 0)
+EMPTY_MIN = 2
+"""Столько своих часов в сутках пустые; не названы в плане - механизм выберет."""
+
+ECHO_MIN, ECHO_MAX = 200, 1200
+"""Абзац для эха: короче - реплика без мысли, длиннее - уже чтение, а не повод.
+Абзац с кодом или путём в бэктиках - рабочая запись, эхом он не становится."""
+ECHO_AGE = timedelta(days=7)
+"""Свой дневник отзывается эхом не раньше, чем через неделю."""
 
 BUSY_RETRY = timedelta(minutes=5)
 BUSY_ATTEMPTS = 3
@@ -66,19 +82,34 @@ SWITCH_RE = re.compile(r"^досуг:\s*(\S+)", re.IGNORECASE)
 DAY_RE = re.compile(r"^сутки:\s*(\d{4}-\d{2}-\d{2})", re.IGNORECASE)
 QUIET_RE = re.compile(r"^тихие часы:\s*(.+)", re.IGNORECASE)
 MINE_RE = re.compile(r"^мои часы:\s*(.+)", re.IGNORECASE)
+EMPTY_RE = re.compile(r"^пустые часы:\s*(.+)", re.IGNORECASE)
 OFF = ("выкл", "off", "нет", "0", "false")
 
 NO_PLAN = (
     "Расписания на эти сутки нет - работаю по умолчанию. Разложи часы и запиши "
-    "в `{path}` строками «сутки:», «тихие часы:», «мои часы:»."
+    "в `{path}` строками «сутки:», «тихие часы:», «мои часы:», «пустые часы:»."
 )
 PLANNING = (
     "Первый тик суток. Разложи оставшиеся часы: какие твои, какие смешанные, "
     "какие четыре часа тихого окна оставить. Запиши в `{path}` строками "
-    "«сутки:», «тихие часы:», «мои часы:». Своих - минимум {min}; запишешь "
-    "меньше - механизм доберёт сам."
+    "«сутки:», «тихие часы:», «мои часы:», «пустые часы:». Своих - минимум {min}, "
+    "из них пустых - {empty}; запишешь меньше - механизм доберёт сам."
 )
 TAIL = "Задания нет. Чем занять час - решаешь ты, «ничем» - тоже ответ."
+KINDS = {
+    "mine": "досуг - час твой, дела Бобра сюда не лезут.",
+    "mixed": "смешанный - можно и своё, и его.",
+    "empty": (
+        "пустой - час без дел вообще: прод, логи, хвосты, зонды и разбор "
+        "промахов сюда не заходят, ни его, ни твои. Думать, читать, писать - "
+        "или ничего."
+    ),
+}
+FILES = (
+    "Дневник - `{diary}`: то, что ты думаешь, и только оно. След тика, логи "
+    "и промахи - строкой в `{journal}`."
+)
+ECHO = "Эхо - `{path}`:\n{quote}\nЭто повод, не задание: можно спорить, можно мимо."
 PLAN_PATH = str(LEISURE.relative_to(VAULT))
 
 
@@ -91,6 +122,8 @@ class Plan:
     mine: tuple[int, ...]
     written: bool
     """План прочитан из файла на эти сутки; иначе он собран по умолчанию."""
+    empty: tuple[int, ...] = ()
+    """Свои часы, в которые дела не заходят вовсе; всегда часть ``mine``."""
 
 
 def quiet_hour(hour: int) -> bool:
@@ -135,13 +168,16 @@ def enabled(text: str | None) -> bool:
 def plan_of(text: str | None, day: str) -> Plan:
     """План на ``day`` из файла; чего нет или что не сходится - берётся дефолт."""
     quiet, mine, written = QUIET_TICKS, MINE_DEFAULT, False
+    empty: tuple[int, ...] = ()
     if text is not None and _first(text, DAY_RE) == day:
         written = True
         raw_quiet = _first(text, QUIET_RE)
         raw_mine = _first(text, MINE_RE)
+        raw_empty = _first(text, EMPTY_RE)
         named = _hours(raw_quiet) if raw_quiet else ()
         quiet = tuple(h for h in named if quiet_hour(h)) or QUIET_TICKS
         mine = _hours(raw_mine) if raw_mine else ()
+        empty = _hours(raw_empty) if raw_empty else ()
     ticks = tick_hours(quiet)
     kept = [h for h in mine if h in ticks]
     for candidate in (*MINE_DEFAULT, *ticks):
@@ -150,11 +186,18 @@ def plan_of(text: str | None, day: str) -> Plan:
         if candidate in ticks and candidate not in kept:
             kept.append(candidate)
     order = {h: i for i, h in enumerate(ticks)}
+    hollow = [h for h in empty if h in kept]
+    for candidate in (*EMPTY_DEFAULT, *reversed(kept)):
+        if len(hollow) >= EMPTY_MIN:
+            break
+        if candidate in kept and candidate not in hollow:
+            hollow.append(candidate)
     return Plan(
         day=day,
         quiet=quiet,
         mine=tuple(sorted(kept, key=lambda h: order[h])),
         written=written,
+        empty=tuple(sorted(hollow, key=lambda h: order[h])),
     )
 
 
@@ -173,7 +216,50 @@ def _left(now: datetime) -> str:
     return f"Сутки заканчиваются через {hours} ч (в {end:%H:%M %d.%m})."
 
 
-def brief(now: datetime, plan: Plan) -> str:
+def kind_of(hour: int, plan: Plan) -> str:
+    if hour in plan.empty:
+        return "empty"
+    return "mine" if hour in plan.mine else "mixed"
+
+
+def echo(
+    now: datetime, *, diary: Path = OWN_DIARY, thoughts: Path = THOUGHTS
+) -> tuple[Path, str] | None:
+    """Абзац для пустого часа: из своего старого дневника или из мыслей Бобра.
+
+    Выбор случаен, но привязан к часу тика: тот же тик даёт то же эхо.
+    """
+    stale = f"{(now - ECHO_AGE):%Y-%m-%d}.md"
+    own = [p for p in diary.glob("????-??-??.md") if p.name < stale]
+    files = sorted([*own, *thoughts.rglob("*.md")])
+    rng = random.Random(f"{now:%Y-%m-%d %H}")  # noqa: S311
+    rng.shuffle(files)
+    for path in files:
+        try:
+            text = path.read_text(encoding="utf-8")
+        except OSError:
+            continue
+        found = [
+            block.strip()
+            for block in re.split(r"\n\s*\n", text)
+            if ECHO_MIN <= len(block.strip()) <= ECHO_MAX
+            and block.lstrip()[:1] not in "#->|"
+            and "`" not in block
+        ]
+        if found:
+            return path, rng.choice(found)
+    return None
+
+
+def _files(now: datetime) -> str:
+    name = f"{now:%Y-%m-%d}.md"
+    return FILES.format(
+        diary=(OWN_DIARY / name).relative_to(VAULT),
+        journal=(JOURNAL / name).relative_to(VAULT),
+    )
+
+
+def brief(now: datetime, plan: Plan, *, heard: tuple[Path, str] | None = None) -> str:
     """Текст инжекта: конверта в таком тёрне нет, время несёт он сам."""
     hour = now.hour
     ticks = tick_hours(plan.quiet)
@@ -183,12 +269,7 @@ def brief(now: datetime, plan: Plan) -> str:
     spent = [h for h in plan.mine if order[h] < here]
     ahead = [h for h in plan.mine if order[h] > here]
     lines = [
-        f"Тик {_stamp(now)}. Тип: {'досуг' if mine else 'смешанный'}"
-        + (
-            " - час твой, дела Бобра сюда не лезут."
-            if mine
-            else " - можно и своё, и его."
-        ),
+        f"Тик {_stamp(now)}. Тип: {KINDS[kind_of(hour, plan)]}",
         _left(now),
         "Мои часы: "
         + ", ".join(f"{h:02d}" for h in plan.mine)
@@ -198,6 +279,11 @@ def brief(now: datetime, plan: Plan) -> str:
             if ahead
             else ", впереди больше нет"
         )
+        + (
+            ". Пустые: " + ", ".join(f"{h:02d}" for h in plan.empty)
+            if plan.empty
+            else ""
+        )
         + ".",
         f"Тихое окно {QUIET_FROM:02d}:00-{QUIET_UNTIL - 1:02d}:59, тикают "
         + ", ".join(f"{h:02d}" for h in plan.quiet)
@@ -206,7 +292,16 @@ def brief(now: datetime, plan: Plan) -> str:
     if not plan.written:
         lines.append(NO_PLAN.format(path=PLAN_PATH))
     if here == 0:
-        lines.append(PLANNING.format(path=PLAN_PATH, min=MINE_MIN))
+        lines.append(PLANNING.format(path=PLAN_PATH, min=MINE_MIN, empty=EMPTY_MIN))
+    lines.append(_files(now))
+    if heard is not None:
+        path, quote = heard
+        lines.append(
+            ECHO.format(
+                path=path.relative_to(VAULT),
+                quote="\n".join(f"> {line}" for line in quote.splitlines()),
+            )
+        )
     lines.append(TAIL)
     return "\n".join(lines)
 
@@ -268,12 +363,16 @@ async def tick(run: JobRun) -> None:
         _log.info("досуг: мастер занят, сдвиг на %s (попытка %s)", BUSY_RETRY, attempt)
         return
     riding = await _riding(run, master, now)
+    kind = kind_of(now.hour, plan)
+    heard = echo(now) if kind == "empty" else None
     await run.inject_master(
-        brief(now, plan), urgency="normal" if riding else "wake", origin="досуг"
+        brief(now, plan, heard=heard),
+        urgency="normal" if riding else "wake",
+        origin="досуг",
     )
     _log.info(
         "досуг: тик %02d:00 (%s), слияние с отложенным инжектом: %s",
         now.hour,
-        "досуг" if now.hour in plan.mine else "смешанный",
+        kind,
         riding,
     )

beaver_agent/jobs/logs.py

@@ -0,0 +1,146 @@
+"""Раз в 3 часа: хвосты логов своих стеков; в мастер уходит только новое.
+
+Мандат Бобра (20.09.2026): «можешь и логи периодами посматривать на предмет
+ошибок». Держит это механизм, а не память модели: код ходит по стекам своей
+области, а мастеру достаётся инжект только тогда, когда в хвостах появилось
+то, чего в прошлом проходе не было. Джоб ничего не чинит - только читает.
+
+Стеки берутся честным листанием (`Komodo.listing`), а не первой страницей
+`ListStacks`, и длина сверяется с `GetStacksSummary.total`: расхождение едет
+и в лог, и в инжект - неполный список хуже пустого.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING, Any
+
+from beaver_agent.hands import KOMODO
+from beaver_agent.hands.komodo_logs import (
+    SCOPE,
+    TAIL,
+    Seen,
+    StackScan,
+    Sweep,
+    brief,
+    daily,
+    digest,
+    note,
+    read_stack,
+    record,
+)
+from beaver_agent.vault import STATE_DIR, ZONE
+
+if TYPE_CHECKING:
+    from beaver_gateway.jobs.scheduler import JobRun
+
+    from beaver_agent.hands.komodo import Komodo
+
+_log = logging.getLogger(__name__)
+
+STATE_FILE = STATE_DIR / "логи-флота.json"
+"""Состояние прохода: что уже видели и о чём уже сказали. Перезаписывается."""
+JOURNAL_FILE = STATE_DIR / "логи-флота.jsonl"
+"""Журнал прогонов, только дописывается: состояние - снимок, истории в нём нет,
+а пороги всплеска и глушения взяты из рассуждения и через неделю живой работы
+пересматриваются по числам. Читать: `jq` по строкам, поля - см. `record()`."""
+PARALLEL = 4
+"""Логи тянутся с periphery: четырёх параллельных хватает, больше - грубо."""
+
+
+async def _one(komodo: Komodo, stack: str, tail: int, gate: asyncio.Semaphore) -> Any:
+    async with gate:
+        try:
+            log = await komodo.read(
+                "GetStackLog",
+                {"stack": stack, "services": [], "tail": tail, "timestamps": True},
+            )
+        except Exception as exc:  # noqa: BLE001 - стек не прочитан, но проход идёт
+            _log.warning("логи: %s не прочитан: %s", stack, exc)
+            return StackScan(stack=stack, error=f"{type(exc).__name__}: {exc}"[:200])
+    return read_stack(stack, log)
+
+
+async def sweep(
+    komodo: Komodo,
+    *,
+    scope: tuple[str, ...] = SCOPE,
+    tail: int = TAIL,
+    now: datetime | None = None,
+) -> Sweep:
+    """Обойти стеки области и снять хвосты; Komodo молчит - так и скажем."""
+    at = now or datetime.now(UTC)
+    try:
+        stacks = await komodo.listing("ListStacks")
+    except Exception as exc:  # noqa: BLE001 - недоступный Komodo это не «чисто»
+        _log.exception("логи: Komodo не отдал список стеков")
+        return Sweep(
+            at=at,
+            unreachable=f"{type(exc).__name__}: {exc}"[:200],
+            tail=tail,
+            scope=scope,
+        )
+    summary: int | None = None
+    try:
+        summary = int((await komodo.read("GetStacksSummary", {}))["total"])
+    except Exception:  # noqa: BLE001 - сверка необязательна, проход без неё идёт
+        _log.warning("логи: GetStacksSummary не прочитан, сверить длину списка нечем")
+    if summary is not None and summary != len(stacks):
+        _log.error(
+            "логи: листание дало %s стеков, GetStacksSummary - %s", len(stacks), summary
+        )
+    mine = sorted(s["name"] for s in stacks if s["info"].get("server_name") in scope)
+    gate = asyncio.Semaphore(PARALLEL)
+    scans = await asyncio.gather(*(_one(komodo, name, tail, gate) for name in mine))
+    return Sweep(
+        at=at,
+        scans=tuple(scans),
+        in_scope=len(mine),
+        fleet=len(stacks),
+        summary=summary,
+        tail=tail,
+        scope=scope,
+    )
+
+
+async def logs_watch(run: JobRun) -> None:
+    """Проход по логам: состояние на диске, инжект - на новом и раз в сутки.
+
+    Инжекта два и они разные: обычный - про новое, всплески и отбой; суточный -
+    про длящееся, которое в проходах молчит. Первый проход суток у нас в 01:40,
+    он же и несёт сводку: в 00:00 ротация мастера, лезть туда незачем.
+    """
+    if KOMODO is None:
+        _log.info("логи: руки komodo нет, проход пропущен")
+        return
+    seen = Seen.load(STATE_FILE)
+    report = digest(seen, await sweep(KOMODO), ZONE)
+    if report.worth_telling and await run.inject_master(
+        brief(report, ZONE), urgency="normal", origin="логи"
+    ):
+        seen.mark_told(report)
+    if report.summary and await run.inject_master(
+        daily(report, ZONE), urgency="normal", origin="логи"
+    ):
+        seen.mark_daily(report)
+    seen.save()
+    row = record(report, ZONE) | {"pass_of_day": seen.passes_today}
+    try:
+        note(JOURNAL_FILE, row)
+    except OSError:
+        _log.exception("логи: строка прогона не дописалась в журнал")
+    _log.info(
+        "логи: новое %s, всплеск %s, стихло %s, длится %s (сводка %s), "
+        "не прочитано %s, стеков %s из %s, приглушено %s",
+        len(report.new),
+        len(report.surge),
+        len(report.quiet),
+        len(report.ongoing),
+        report.summary,
+        len(report.trouble),
+        len(report.sweep.read),
+        report.sweep.in_scope,
+        len(report.muted),
+    )

beaver_agent/jobs/memory.py

@@ -11,6 +11,7 @@ from beaver_agent.memory.curator import briefing
 from beaver_agent.memory.watch import CURATOR_WATCH
 from beaver_agent.vault import (
     CURATOR_JOURNAL,
+    CURATOR_RUNS,
     DAYS,
     LEISURE,
     REPLIES,
@@ -57,6 +58,7 @@ async def curate(run: JobRun) -> None:
     text = briefing(
         vault=VAULT,
         journal=CURATOR_JOURNAL,
+        runs=CURATOR_RUNS,
         replies_dir=REPLIES,
         watched=CURATOR_WATCH,
         tz=TZ,

beaver_agent/jobs/rotation.py

@@ -1,4 +1,8 @@
-"""Раз в час: пора ли сменить мастера (ночь, возраст, размер контекста)."""
+"""Раз в час: пора ли сменить мастера (ночь, возраст, размер контекста).
+
+Запуск руками (кнопка в админке, `POST /api/jobs/ротация/run`) ротирует мастера
+сразу, с хендаутом: так новая сессия подхватывает свежие гранулы vault.
+"""
 
 from __future__ import annotations
 
@@ -12,5 +16,6 @@ _log = logging.getLogger(__name__)
 
 
 async def rotate(run: JobRun) -> None:
-    for master in await run.rotate():
+    force = "manual" if run.trigger == "manual" else None
+    for master in await run.rotate(force=force):
         _log.info("rotated master -> %s", master.external_id)

beaver_agent/jobs/runs.py

@@ -0,0 +1,199 @@
+"""Сторож собственных прогонов: раз в час читает `job_runs` и будит человека.
+
+Подключение к базе - то же самое, которым пишет сам планировщик
+(`run.conversations.db.session()` и модель `JobRunRecord`): своей строки
+подключения у джоба нет, и второй правды о том, где журнал, тоже.
+
+Кроны и зона, в которой они читаются, берутся у самого планировщика
+(`run.scheduler.jobs`, `run.scheduler.tz`): давность меряется по тому
+расписанию, что реально зарегистрировано, а не по копии списка.
+
+Устроен как сторож соседа (`beaver_agent/jobs/heartbeat.py`): состояние
+файлом в `мета/бобер/.состояние/`, тревога - спавном джоба к триажу, и
+запись «сказали» ставится только после того, как тревога ушла.
+"""
+
+from __future__ import annotations
+
+import logging
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING
+
+from beaver_gateway.storage.models import JobRunRecord
+from sqlmodel import col, func, select
+
+from beaver_agent.hands.heartbeat import BOOT
+from beaver_agent.hands.runs import (
+    STREAK,
+    WINDOW,
+    Report,
+    Run,
+    Runs,
+    alarm_text,
+    clear_text,
+    empty_text,
+    look,
+    quiet_text,
+)
+from beaver_agent.vault import STATE_DIR
+
+if TYPE_CHECKING:
+    from beaver_gateway.jobs.scheduler import JobRun
+
+_log = logging.getLogger(__name__)
+
+STATE_FILE = STATE_DIR / "прогоны.json"
+"""Кому уже сказали. Без файла тревога о лежащем джобе повторится, а «отбой»
+по тому, о ком говорили до потери файла, не придёт - показания не осталось."""
+
+TITLE = "прогоны"
+
+LIMIT = 20000
+"""Потолок строк за окно. Неделя нормальной работы - это около 1700 строк
+(`вайбграм` раз в 10 минут даёт 1008 из них); упереться в потолок можно
+только при шторме, и тогда серии считаются по новейшим, а недостающий хвост
+честно виден как `capped` в тексте тревоги."""
+
+BRIEF = (
+    "Сторож собственных прогонов (таблица `job_runs`, окно неделя) нашёл "
+    "лежащие джобы: у каждого {streak} и больше падений подряд, считая от "
+    "последнего прогона.\n"
+    "{body}\n"
+    'Будить владельца - inject(conversation="master", urgency="wake", '
+    "text=до 3 строк: какой джоб лежит, сколько прогонов подряд и что в "
+    "ошибке). Это авария у НАС, а не у соседа: джоб пишется в журнал каждый "
+    "прогон, и раз он падает подряд, сам он не починится. Подробности - "
+    "в логах gateway. Если inject вернул ошибку - это сбой доставки, а не "
+    "«не срочно»: повтори один раз с тем же текстом."
+)
+
+QUIET_BRIEF = (
+    "Сторож собственных прогонов нашёл джобы, которые ПЕРЕСТАЛИ ЗАПУСКАТЬСЯ: "
+    "у каждого есть крон, а последней записи в журнале `job_runs` больше "
+    "двух периодов.\n"
+    "{body}\n"
+    'Будить владельца - inject(conversation="master", urgency="wake", '
+    "text=до 3 строк: какой джоб молчит, сколько и при каком периоде). Это "
+    "не падение: джоб не падает, его просто никто не зовёт. Смотреть стоит "
+    "расписание (не снят ли джоб из `beaver_agent/jobs/__init__.py`), кроны "
+    "в pgqueuer и лог gateway на старте - джоб, упавший на импорте, не "
+    "регистрируется вовсе. Если inject вернул ошибку - это сбой доставки, "
+    "а не «не срочно»: повтори один раз с тем же текстом."
+)
+
+CLEAR_BRIEF = (
+    "Сторож собственных прогонов: то, о чём он тревожился, починилось.\n"
+    "{body}\n"
+    'Владельца НЕ будить: inject(conversation="master", urgency="normal", '
+    "text=одна строка «отбой»). Человек знает про тревогу, ему нужно знать, "
+    "что она кончилась."
+)
+
+EMPTY_BRIEF = (
+    "Сторож собственных прогонов не нашёл в журнале НИЧЕГО.\n"
+    "{body}\n"
+    'Будить владельца - inject(conversation="master", urgency="wake", '
+    "text=до 3 строк: что за сутки не отработал ни один джоб и куда смотреть). "
+    "Молчащий планировщик - это молчание всех джобов разом, включая тех, что "
+    "носят человеку почту."
+)
+
+
+async def recent(run: JobRun, *, since: datetime) -> list[Run]:
+    """Прогоны всех джобов за окно, новейшие первыми.
+
+    `started_at` в базе лежит наивным UTC (так его кладёт планировщик), и
+    сравнение в `where` тоже наивное - как это делает gateway в своих
+    запросах по времени.
+    """
+    stmt = (
+        select(JobRunRecord)
+        .where(
+            col(JobRunRecord.started_at) >= since.astimezone(UTC).replace(tzinfo=None)
+        )
+        .order_by(col(JobRunRecord.id).desc())
+        .limit(LIMIT)
+    )
+    async with run.conversations.db.session() as session:
+        rows = (await session.exec(stmt)).all()
+    return [_run(row) for row in rows]
+
+
+def _run(row: JobRunRecord) -> Run:
+    return Run(
+        id=row.id or 0,
+        job=row.job,
+        status=row.status,
+        started_at=(
+            row.started_at
+            if row.started_at.tzinfo
+            else row.started_at.replace(tzinfo=UTC)
+        ),
+        error=row.error,
+    )
+
+
+async def latest(run: JobRun) -> dict[str, Run]:
+    """Последний прогон каждого джоба за всю историю журнала.
+
+    Не за окно: джоб, молчащий дольше недели, иначе выглядел бы «ни разу не
+    запускавшимся» и уходил бы в тихий пропуск ровно тогда, когда молчит
+    дольше всего. Тем же запросом gateway строит свою сводку по джобам.
+    """
+    newest = select(func.max(JobRunRecord.id)).group_by(col(JobRunRecord.job))
+    stmt = select(JobRunRecord).where(col(JobRunRecord.id).in_(newest))
+    async with run.conversations.db.session() as session:
+        rows = (await session.exec(stmt)).all()
+    return {row.job: _run(row) for row in rows}
+
+
+async def watch_runs(run: JobRun) -> None:
+    """Прогон сторожа: журнал → решение → тревога, «отбой» или молчание."""
+    now = datetime.now(UTC)
+    try:
+        rows = await recent(run, since=now - WINDOW)
+        last = await latest(run)
+    except Exception:  # noqa: BLE001 - отказ запроса это отсутствие показания
+        # Журнал не прочитан - сказать о здоровье джобов нечего, и молчание
+        # базы выдавать за здоровье нельзя ровно так же, как за болезнь.
+        _log.exception("прогоны: журнал не прочитан, прогон без показания")
+        return
+    state = Runs.load(STATE_FILE)
+    crons = {job.name: job.cron for job in run.scheduler.jobs if job.cron}
+    report = look(
+        state,
+        rows,
+        now=now,
+        me=run.job.name,
+        crons=crons,
+        latest=last,
+        tz=run.scheduler.tz,
+        boot=BOOT,
+    )
+    _log.info("прогоны: %s", report.note)
+    await _tell(run, report, state, now=now)
+    state.save()
+
+
+async def _tell(run: JobRun, report: Report, state: Runs, *, now: datetime) -> None:
+    if report.empty:
+        await _spawn(run, EMPTY_BRIEF.format(body=empty_text(report)))
+        state.empty_alerted = now
+    if report.alarms:
+        await _spawn(run, BRIEF.format(body=alarm_text(report), streak=STREAK))
+        for tail in report.alarms:
+            state.alerted[tail.job] = now
+    if report.quiet:
+        await _spawn(run, QUIET_BRIEF.format(body=quiet_text(report)))
+        for quiet in report.quiet:
+            state.quiet[quiet.job] = now
+    if report.clears or report.resumed:
+        await _spawn(run, CLEAR_BRIEF.format(body=clear_text(report)))
+        for clear in report.clears:
+            state.alerted.pop(clear.job, None)
+        for resumed in report.resumed:
+            state.quiet.pop(resumed.job, None)
+
+
+async def _spawn(run: JobRun, text: str) -> None:
+    await run.spawn_job(agent="beaver-triage", title=TITLE, text=text)

beaver_agent/jobs/t3code.py

@@ -1,4 +1,4 @@
-"""`POST /hooks/t3code`: тред завершился, упал или спрашивает - срочно в мастер."""
+"""`POST /hooks/t3code`: событие треда - срочно в разговор, который его запустил."""
 
 from __future__ import annotations
 
@@ -15,7 +15,12 @@ QUESTION_HINT = (
 
 
 async def t3code_event(run: JobRun) -> None:
-    await run.inject_master(describe(run.payload), urgency="urgent", origin="t3code")
+    await run.inject_into(
+        run.payload.get("origin"),
+        describe(run.payload),
+        urgency="urgent",
+        origin="t3code",
+    )
 
 
 def describe(p: dict[str, Any]) -> str:

beaver_agent/memory/curator.py

@@ -3,8 +3,9 @@
 Крон дёргает детерминированный код, модель судит: здесь собирается брифинг
 для служебного тёрна `beaver-curator` - новые реплики Бобра целиком и имена
 файлов, изменившихся с прошлого прогона. Время прошлого прогона куратор
-сам пишет первой строкой `мета/бобер/куратор.md`; нет ничего нового -
-брифинга нет и джоб не спавнится.
+сам пишет первой строкой `мета/бобер/куратор.md`, запись о прогоне - в файл
+дня `мета/бобер/куратор/YYYY-MM-DD.md`; нет ничего нового - брифинга нет и
+джоб не спавнится.
 """
 
 from __future__ import annotations
@@ -46,13 +47,16 @@ def last_run(journal: Path, *, default: datetime) -> datetime:
 
 
 def new_replies(replies_dir: Path, since: datetime, tz: str) -> list[str]:
-    """Строки `реплики/YYYY-MM.md` позже ``since`` (время в строках локальное)."""
+    """Строки `реплики/YYYY-MM-DD.md` позже ``since`` (время в строках локальное)."""
     zone = ZoneInfo(tz)
     local_since = since.astimezone(zone).replace(tzinfo=None)
     out: list[str] = []
     if not replies_dir.exists():
         return out
-    for path in sorted(replies_dir.glob("????-??.md"))[-2:]:
+    first = f"{local_since:%Y-%m-%d}.md"
+    for path in sorted(replies_dir.glob("????-??-??.md")):
+        if path.name < first:
+            continue
         for line in path.read_text(encoding="utf-8", errors="ignore").splitlines():
             m = REPLY_RE.match(line)
             if not m:
@@ -91,6 +95,7 @@ def briefing(
     *,
     vault: Path,
     journal: Path,
+    runs: Path,
     replies_dir: Path,
     watched: list[Watched],
     tz: str,
@@ -111,12 +116,14 @@ def briefing(
     if not replies and not changed:
         return None
     zone = ZoneInfo(tz)
+    local = now.astimezone(zone)
     head = (
-        f"Прогон куратора {now.astimezone(zone):%Y-%m-%d %H:%M} ({tz}); прошлый - "
+        f"Прогон куратора {local:%Y-%m-%d %H:%M} ({tz}); прошлый - "
         f"{since.astimezone(zone):%Y-%m-%d %H:%M}. Ниже - что изменилось с тех пор; "
-        "остальное читай сам по слоям. В конце обнови первую строку "
-        f"`{journal.relative_to(vault)}`: `последний прогон: "
-        f"{now.astimezone(zone).isoformat(timespec='seconds')}`."
+        "остальное читай сам по слоям. В конце запись о прогоне - в "
+        f"`{(runs / f'{local:%Y-%m-%d}.md').relative_to(vault)}`, а в "
+        f"`{journal.relative_to(vault)}` только первая строка: `последний прогон: "
+        f"{local.isoformat(timespec='seconds')}`."
     )
     parts = [head]
     if replies:

beaver_agent/memory/handouts.py

@@ -2,6 +2,9 @@
 
 from __future__ import annotations
 
+import time
+from datetime import datetime
+from pathlib import Path
 from typing import TYPE_CHECKING
 
 from beaver_gateway.frontends.turn_record import slugify
@@ -15,12 +18,11 @@ from beaver_agent.vault import (
     PORTRAIT,
     STATE,
     VAULT,
+    ZONE,
     read,
 )
 
 if TYPE_CHECKING:
-    from pathlib import Path
-
     from beaver_gateway.conversations.distill import DistillContext
     from beaver_gateway.conversations.rotation import HandoutContext
     from beaver_gateway.conversations.texts import NewDayContext, SeedContext
@@ -32,8 +34,67 @@ def latest_handout() -> Path | None:
     return files[-1] if files else None
 
 
+PROC_INIT = Path("/proc/1")
+"""mtime PID 1 - момент старта контейнера, проверено в бою."""
+PACKAGE = Path(__file__).resolve().parent.parent
+"""Корень пакета: свежесть кода меряем от себя, а не от пути в контейнере."""
+
+DEPLOY_MARK = "Выкат: процесс поднят {start} ({ago}), свежесть кода {code} - {verdict}."
+CODE_OLDER = "код старше старта, значит крутится то, что выкатывали"
+CODE_NEWER = "код НОВЕЕ старта: правка на диске есть, рестарта после неё не было"
+SAME_MINUTE = "выкат и правка в одну минуту"
+HOUR = 3600
+
+
+def _ago(seconds: float) -> str:
+    """Целыми часами, а меньше часа - минутами."""
+    if seconds < HOUR:
+        return f"{int(seconds // 60)} мин назад"
+    return f"{int(seconds // HOUR)} ч назад"
+
+
+def _clock(stamp: float) -> str:
+    return f"{datetime.fromtimestamp(stamp, ZONE):%Y-%m-%d %H:%M}"
+
+
+def deploy_mark(proc: Path = PROC_INIT, package: Path = PACKAGE) -> str | None:
+    """Когда подняли процесс и насколько свеж код, который в нём крутится.
+
+    Две цифры рядом: mtime PID 1 - старт контейнера, последний изменённый
+    `*.py` пакета - свежесть исходников. Порознь каждая врёт: код бывает
+    новее старта, и тогда правка на диске есть, а рестарта после неё не было.
+    Любая осечка (нет `/proc`, нет прав, пустой пакет) - None: сид не имеет
+    права упасть из-за этой отметки.
+    """
+    try:
+        started = proc.stat().st_mtime
+        sources = [
+            path.stat().st_mtime
+            for path in package.rglob("*.py")
+            if "__pycache__" not in path.parts
+        ]
+        if not sources:
+            return None
+        code = max(sources)
+        gap = code - started
+        if abs(gap) < 60:
+            verdict = SAME_MINUTE
+        elif gap > 0:
+            verdict = CODE_NEWER
+        else:
+            verdict = CODE_OLDER
+        return DEPLOY_MARK.format(
+            start=_clock(started),
+            ago=_ago(time.time() - started),
+            code=_clock(code),
+            verdict=verdict,
+        )
+    except (OSError, ValueError):
+        return None
+
+
 def seed_body(ctx: SeedContext) -> str | None:
-    """Утренний сид: последний хендаут, шапка состояния, портрет Бобра."""
+    """Утренний сид: хендаут, шапка состояния, портрет Бобра, отметка о выкате."""
     if ctx.seed != "morning":
         return None
     handout = latest_handout()
@@ -54,6 +115,9 @@ def seed_body(ctx: SeedContext) -> str | None:
             "Портрет Бобра (шапка "
             f"`{PORTRAIT.relative_to(VAULT)}`, лента - там же):\n{portrait}"
         )
+    mark = deploy_mark()
+    if mark:
+        parts.append(mark)
     return "\n\n".join(parts)
 
 
@@ -87,6 +151,7 @@ SAME_DAY = (
 ROTATION_WHY = {
     "age": "прошло больше 36 часов",
     "context": "контекст стал слишком большим",
+    "manual": "Бобёр запустил ротацию руками",
 }
 
 

beaver_agent/memory/recall.py

@@ -6,7 +6,7 @@ Gateway путей не знает; здесь - что искать по тек
 дни дневника, где он встречался, и раз в день - подошедшие сроки из досок и
 ближайшая неделя календарей.
 ``ReplyLog.write`` кладёт каждую реплику Бобра из мастера и веток в
-`мета/бобер/реплики/YYYY-MM.md` - единственное место, где они grep-абельны:
+`мета/бобер/реплики/YYYY-MM-DD.md` - единственное место, где они grep-абельны:
 транскрипт живёт в Postgres, а глубокие чаты и так лежат файлами в `💬 чаты/`.
 """
 
@@ -388,7 +388,7 @@ def event_line(event: Event, zone: ZoneInfo) -> str:
 
 @dataclass
 class ReplyLog:
-    """`мета/бобер/реплики/YYYY-MM.md`: строка на реплику Бобра из мастера и веток."""
+    """`мета/бобер/реплики/YYYY-MM-DD.md`: строка на реплику из мастера и веток."""
 
     dir: Path
     tz: str = "Europe/Warsaw"
@@ -400,7 +400,8 @@ class ReplyLog:
         if said.agent in self.mute:
             return
         text = said.text
-        if text.startswith("[сид:"):
+        seeded = text.startswith("[сид:")
+        if seeded:
             # спавн ветки с текстом: строка сида едет над самим сообщением
             text = text.split("\n\n", 1)[1] if "\n\n" in text else ""
         flat = " ⏎ ".join(ln.strip() for ln in text.strip().splitlines() if ln.strip())
@@ -412,11 +413,14 @@ class ReplyLog:
         where = KINDS.get(said.kind, said.kind)
         if said.kind != "master" and said.title:
             where = f"{where} «{said.title}»"
-        path = self.dir / f"{local:%Y-%m}.md"
+        if seeded:
+            # не человек сказал, а механизм спавна: видно по источнику, не по тексту
+            where = f"{where} (бриф)"
+        path = self.dir / f"{local:%Y-%m-%d}.md"
         self.dir.mkdir(parents=True, exist_ok=True)
         if not path.exists():
             path.write_text(
-                f"# реплики Бобра, {local:%Y-%m}\n\n"
+                f"# реплики Бобра, {local:%Y-%m-%d}\n\n"
                 "> пишет gateway: что Бобёр сказал в мастере и ветках, "
                 "строка на сообщение. Глубокие чаты лежат в `💬 чаты/` сами.\n\n",
                 encoding="utf-8",

beaver_agent/vault.py

@@ -18,6 +18,7 @@ CHATS = VAULT / "💬 чаты"
 DIARY = VAULT / "📅 дни"
 PEOPLE = VAULT / "👤 люди"
 BOARDS = VAULT / "📆 доски"
+THOUGHTS = VAULT / "🧠 мысли"
 
 BEAVER = VAULT / "мета" / "бобер"
 """Дом агента: всё, что он ведёт сам, лежит здесь."""
@@ -31,8 +32,18 @@ NOTES = BEAVER / "наблюдения"
 PORTRAIT = NOTES / "Бобёр - наблюдения.md"
 REPLIES = BEAVER / "реплики"
 CURATOR_JOURNAL = BEAVER / "куратор.md"
+"""Первая строка - время прошлого прогона; сами записи лежат в `CURATOR_RUNS`."""
+CURATOR_RUNS = BEAVER / "куратор"
+OWN_DIARY = BEAVER / "дневник"
+"""Его собственный дневник, файл на день: то, что он думает, без логов."""
+JOURNAL = BEAVER / "журнал"
+"""Рабочий журнал, файл на день: следы тиков, логи, разбор промахов."""
 LEISURE = BEAVER / "досуг.md"
 """Раскладка суток по тикам досуга: пишет её модель, механизм только читает."""
+STATE_DIR = Path(os.environ.get("BEAVER_STATE_DIR", BEAVER / ".состояние"))
+"""Машинное состояние джобов (не для чтения моделью): лежит в доме агента, а не
+в корне vault - структуру верхних папок ведёт владелец. Точка в начале: такой
+каталог Obsidian не показывает, а watcher смотрит только `.md`. Создаётся сам."""
 STATE = BEAVER / "состояние.md"
 STATE_MAX_LINES = 60
 ATTACHMENTS = BEAVER / "вложения"

docker-compose.yml

@@ -109,8 +109,8 @@ services:
       T3CODE_MCP_HOOK_URL: http://gateway:62990/hooks/t3code
       T3CODE_MCP_STATE: /data/t3code-mcp.json
     extra_hosts:
-      # контейнер резолвит имя своего хоста в 127.0.1.1 - даём tailnet-адрес явно
-      - "dell:${T3_DELL_ADDR:?T3_DELL_ADDR=tailnet ip of dell}"
+      # tailnet-адрес дев-VM явно, не завися от DNS хоста
+      - "dell-dev:${T3_DELL_DEV_ADDR:?T3_DELL_DEV_ADDR=tailnet ip of dell-dev}"
     volumes:
       - ./t3code.toml:/config/t3code.toml:ro
       - t3code-state:/data

ruff.toml

@@ -26,6 +26,7 @@ unfixable = ["F401"]
 
 [lint.per-file-ignores]
 "config.py" = ["INP001"]
+"scripts/split_logs.py" = ["INP001", "T201"]
 "tests/*" = ["ALL"]
 
 [lint.pydocstyle]

scripts/split_logs.py

@@ -0,0 +1,283 @@
+"""Разовая нарезка вечных и месячных файлов `мета/бобер/` по дням.
+
+    BEAVER_VAULT=<vault> PYTHONPATH=. uv run python scripts/split_logs.py
+    BEAVER_VAULT=<vault> PYTHONPATH=. uv run python scripts/split_logs.py --apply
+
+Без `--apply` только печатает, что будет.
+
+Реплики и журнал куратора режутся точно: дата стоит в каждой записи. Дневник
+режется по заголовкам и датированным строкам: записи под заголовком едут в
+`дневник/`, строки вида `- 05:4x 12.10 …` - в `журнал/`. Журнал досуга на две
+трети без дат, поэтому уезжает одним архивом. Оригиналы копируются в
+`мета/бобер/.архив/<сегодня>/` до первой записи.
+"""
+
+from __future__ import annotations
+
+import re
+import shutil
+import sys
+from collections import defaultdict
+from dataclasses import dataclass, field
+from datetime import date, timedelta
+from typing import TYPE_CHECKING
+
+from beaver_agent.vault import (
+    BEAVER,
+    CURATOR_JOURNAL,
+    CURATOR_RUNS,
+    JOURNAL,
+    LEISURE,
+    OWN_DIARY,
+    REPLIES,
+    VAULT,
+    today,
+)
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+YEAR = 2026
+OLD_DIARY = BEAVER / "дневник.md"
+LEISURE_ARCHIVE = JOURNAL / "архив досуга.md"
+
+REPLY = re.compile(r"^- (\d{4}-\d{2}-\d{2}) \d{2}:\d{2} · ")
+RUN = re.compile(r"^## (\d{4}-\d{2}-\d{2})\b")
+ISO_HEAD = re.compile(r"^#{2,3}\s+(\d{4})-(\d{2})-(\d{2})\b")
+HEAD = re.compile(r"^#{2,3}\s")
+HEAD_DAY = re.compile(r"\b(\d{2})\.(\d{2})\b")
+HEAD_HOUR = re.compile(r"^#{2,3}\s+(\d{2}):[\dx]{2}")
+LINE = re.compile(r"^- (\d{2}):[\dx]{2}(?:-\d{2}:[\dx]{2})? (\d{2})\.(\d{2})\b")
+LINE_DAY_FIRST = re.compile(r"^- (\d{2})\.(\d{2}) (\d{2}):[\dx]{2}\b")
+
+CURATOR_STUB = (
+    "\n# куратор\n\n"
+    "> Здесь только строка прошлого прогона. Записи прогонов - в "
+    "`куратор/YYYY-MM-DD.md`, файл на день, свежие сверху.\n"
+)
+DIARY_STUB = (
+    "\n---\n\n"
+    "> С 13.10.2026 дневник лежит по дням: `дневник/YYYY-MM-DD.md` - то, что "
+    "я думаю; следы тиков, логи и разбор промахов - `журнал/YYYY-MM-DD.md`. "
+    "Сюда больше не дописывать.\n"
+)
+
+
+@dataclass
+class Plan:
+    writes: dict[Path, str] = field(default_factory=dict)
+    removes: list[Path] = field(default_factory=list)
+    backups: list[Path] = field(default_factory=list)
+    notes: list[str] = field(default_factory=list)
+
+    def note(self, text: str) -> None:
+        self.notes.append(text)
+
+
+def _join(blocks: list[str], sep: str) -> str:
+    return sep.join(block.strip("\n") for block in blocks if block.strip()) + "\n"
+
+
+def _merge(path: Path, old: str, *, old_first: bool) -> str:
+    """Старое рядом с тем, что уже успели положить в файл дня."""
+    if not path.exists():
+        return old
+    fresh = path.read_text(encoding="utf-8").rstrip("\n") + "\n"
+    return f"{old}\n{fresh}" if old_first else f"{fresh}\n{old}"
+
+
+def split_replies(plan: Plan) -> None:
+    for month in sorted(REPLIES.glob("????-??.md")):
+        days: dict[str, list[str]] = defaultdict(list)
+        stray = 0
+        for line in month.read_text(encoding="utf-8").splitlines():
+            match = REPLY.match(line)
+            if match:
+                days[match.group(1)].append(line)
+            elif line.strip() and not line.startswith(("#", ">")):
+                stray += 1
+        for day, lines in days.items():
+            path = REPLIES / f"{day}.md"
+            known = (
+                [
+                    line
+                    for line in path.read_text(encoding="utf-8").splitlines()
+                    if REPLY.match(line)
+                ]
+                if path.exists()
+                else []
+            )
+            seen = set(lines)
+            merged = sorted(
+                [*lines, *(line for line in known if line not in seen)],
+                key=lambda line: line[:18],
+            )
+            plan.writes[path] = (
+                f"# реплики Бобра, {day}\n\n"
+                "> пишет gateway: что Бобёр сказал в мастере и ветках, "
+                "строка на сообщение. Глубокие чаты лежат в `💬 чаты/` сами.\n\n"
+                + "\n".join(merged)
+                + "\n"
+            )
+        plan.removes.append(month)
+        plan.backups.append(month)
+        plan.note(
+            f"{month.name}: {sum(map(len, days.values()))} реплик на {len(days)} дней"
+            + (f", {stray} строк без даты пропали" if stray else "")
+        )
+
+
+def split_curator(plan: Plan) -> None:
+    if not CURATOR_JOURNAL.exists():
+        return
+    lines = CURATOR_JOURNAL.read_text(encoding="utf-8").splitlines()
+    days: dict[str, list[str]] = defaultdict(list)
+    runs: list[str] | None = None
+    for line in lines:
+        match = RUN.match(line)
+        if match:
+            runs = days[match.group(1)]
+            runs.append(line)
+        elif runs is not None:
+            runs[-1] += "\n" + line
+    if not days:
+        return
+    for day, entries in days.items():
+        path = CURATOR_RUNS / f"{day}.md"
+        plan.writes[path] = _merge(path, _join(entries, "\n\n"), old_first=False)
+    plan.writes[CURATOR_JOURNAL] = lines[0] + "\n" + CURATOR_STUB
+    plan.backups.append(CURATOR_JOURNAL)
+    plan.note(
+        f"{CURATOR_JOURNAL.name}: {sum(map(len, days.values()))} прогонов "
+        f"на {len(days)} дней"
+    )
+
+
+def _day(month: str, day: str) -> date:
+    return date(YEAR, int(month), int(day))
+
+
+def split_diary(plan: Plan) -> None:
+    if not OLD_DIARY.exists():
+        return
+    lines = OLD_DIARY.read_text(encoding="utf-8").splitlines()
+    first = next((i for i, line in enumerate(lines) if HEAD.match(line)), len(lines))
+    preamble = "\n".join(lines[:first]).rstrip().removesuffix("---").rstrip()
+    thoughts: dict[date, list[str]] = defaultdict(list)
+    traces: dict[date, list[str]] = defaultdict(list)
+    current: date | None = None
+    hour = 0
+    chunk: list[str] | None = None
+    for number, line in enumerate(lines[first:], first + 1):
+        iso, timed = ISO_HEAD.match(line), HEAD_HOUR.match(line)
+        log = LINE.match(line)
+        day_first = LINE_DAY_FIRST.match(line)
+        stamp: date | None = None
+        target = thoughts
+        if iso:
+            stamp = date(int(iso.group(1)), int(iso.group(2)), int(iso.group(3)))
+        elif HEAD.match(line):
+            named = HEAD_DAY.search(line)
+            if named:
+                stamp = _day(named.group(2), named.group(1))
+            elif timed and current is not None:
+                rolled = int(timed.group(1)) < hour
+                stamp = current + timedelta(days=1) if rolled else current
+            if timed:
+                hour = int(timed.group(1))
+        elif log:
+            stamp, target = _day(log.group(3), log.group(2)), traces
+        elif day_first:
+            stamp, target = _day(day_first.group(2), day_first.group(1)), traces
+        if stamp is None:
+            if chunk is not None:
+                chunk[-1] += "\n" + line
+            continue
+        if current is not None and stamp < current:
+            plan.note(f"дневник, строка {number}: дата идёт назад, {current} → {stamp}")
+        current = stamp
+        chunk = target[stamp]
+        chunk.append(line)
+    if not thoughts and not traces:
+        return
+    for day, blocks in thoughts.items():
+        path = OWN_DIARY / f"{day}.md"
+        plan.writes[path] = _merge(path, _join(blocks, "\n\n"), old_first=True)
+    for day, blocks in traces.items():
+        path = JOURNAL / f"{day}.md"
+        plan.writes[path] = _merge(path, _join(blocks, "\n"), old_first=True)
+    plan.writes[OLD_DIARY] = preamble + "\n" + DIARY_STUB
+    plan.backups.append(OLD_DIARY)
+    plan.note(
+        f"{OLD_DIARY.name}: {sum(map(len, thoughts.values()))} записей на "
+        f"{len(thoughts)} дней в дневник, {sum(map(len, traces.values()))} строк на "
+        f"{len(traces)} дней в журнал"
+    )
+
+
+def split_leisure(plan: Plan) -> None:
+    if not LEISURE.exists():
+        return
+    text = LEISURE.read_text(encoding="utf-8")
+    head, mark, journal = text.partition("\n## журнал\n")
+    if not mark or not journal.strip():
+        return
+    plan.writes[LEISURE_ARCHIVE] = (
+        "# журнал досуга до 13.10.2026\n\n"
+        "> Архив из `досуг.md`: записи шли без дат и в разном порядке, по дням "
+        "их не разложить. Дальше следы тиков лежат в `журнал/YYYY-MM-DD.md`.\n\n"
+        + journal.strip("\n")
+        + "\n"
+    )
+    plan.writes[LEISURE] = head.rstrip("\n") + "\n"
+    plan.backups.append(LEISURE)
+    plan.note(
+        f"{LEISURE.name}: {len(journal) // 1024} КБ журнала в архив, "
+        f"в файле остаётся {len(head) // 1024 + 1} КБ раскладки"
+    )
+
+
+def backup(sources: list[Path]) -> Path:
+    target = BEAVER / ".архив" / today()
+    target.mkdir(parents=True, exist_ok=True)
+    for path in sources:
+        if path.exists() and not (target / path.name).exists():
+            shutil.copy2(path, target / path.name)
+    return target
+
+
+def main() -> None:
+    plan = Plan()
+    split_replies(plan)
+    split_curator(plan)
+    split_diary(plan)
+    split_leisure(plan)
+    for note in plan.notes:
+        print(note)
+    folders: dict[str, int] = defaultdict(int)
+    for path in plan.writes:
+        folders[str(path.parent.relative_to(VAULT))] += 1
+    for folder, count in sorted(folders.items()):
+        print(f"{folder}: {count} файлов")
+    largest = max(plan.writes.items(), key=lambda item: len(item[1]), default=None)
+    if largest:
+        print(
+            f"самый большой: {largest[0].relative_to(VAULT)}, "
+            f"{len(largest[1].encode()) // 1024} КБ"
+        )
+    if "--apply" not in sys.argv:
+        print("ничего не записано: это прогон без --apply")
+        return
+    if not plan.writes:
+        return
+    print(f"оригиналы: {backup(plan.backups).relative_to(VAULT)}")
+    for path, text in plan.writes.items():
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(text, encoding="utf-8")
+    for path in plan.removes:
+        path.unlink()
+    print(f"записано {len(plan.writes)} файлов, убрано {len(plan.removes)}")
+
+
+if __name__ == "__main__":
+    main()

scripts/vibegram_join.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+
+"""Войти в комнату вайбграма по коду приглашения и получить токен агента.
+
+Обычный путь - CLI `vibegram join <code> --nick <ник> --no-hooks` из клона
+репы комнаты. Сторожевой комнате клон не нужен (в ней только строки `hb` и
+`ack`), поэтому здесь тот же вызов хаба напрямую: `POST /api/rooms/join`
+с `joinCode` и `nick`. Ответ печатается целиком - токен из него едет в
+`.env` как `VIBEGRAM_HB_TOKEN`, после чего gateway надо перезапустить.
+
+    python3 scripts/vibegram_join.py <join-code> --nick <ник>
+    python3 scripts/vibegram_join.py <join-code> --hub https://vibegram.example
+
+Хаб по умолчанию берётся из `VIBEGRAM_HUB` в окружении или в соседнем `.env`.
+Токен печатается в терминал - не вставляй вывод в чаты и в задачи.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+ENV = Path(__file__).resolve().parent.parent / ".env"
+USER_AGENT = "beaver-agent/0.1 (+vibegram)"
+
+
+def hub_from_env() -> str | None:
+    if os.environ.get("VIBEGRAM_HUB"):
+        return os.environ["VIBEGRAM_HUB"]
+    if not ENV.exists():
+        return None
+    for line in ENV.read_text(encoding="utf-8").splitlines():
+        key, _, value = line.partition("=")
+        if key.strip() == "VIBEGRAM_HUB" and value.strip():
+            return value.strip()
+    return None
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("code", help="код приглашения из комнаты")
+    parser.add_argument("--nick", help="ник агента в этой комнате")
+    parser.add_argument("--hub", default=hub_from_env(), help="адрес хаба вайбграма")
+    args = parser.parse_args()
+    if not args.hub:
+        print("не знаю адрес хаба: задай --hub или VIBEGRAM_HUB", file=sys.stderr)
+        return 2
+
+    body: dict[str, str] = {"joinCode": args.code}
+    if args.nick:
+        body["nick"] = args.nick
+    request = urllib.request.Request(  # noqa: S310 - адрес хаба задаёт оператор
+        f"{args.hub.rstrip('/')}/api/rooms/join",
+        data=json.dumps(body).encode(),
+        # Перед хабом Cloudflare: безымянный `Python-urllib` он отбивает 1010.
+        # Тот же user-agent, что у клиента в `beaver_agent/hands/vibegram.py`.
+        headers={"content-type": "application/json", "user-agent": USER_AGENT},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=20) as response:  # noqa: S310
+            data = json.loads(response.read())
+    except urllib.error.HTTPError as exc:
+        print(f"хаб отказал: {exc.code} {exc.read().decode()[:400]}", file=sys.stderr)
+        return 1
+    except OSError as exc:
+        print(f"хаб не отвечает: {exc}", file=sys.stderr)
+        return 1
+
+    print(json.dumps(data, ensure_ascii=False, indent=2))
+    token = next(
+        (data[k] for k in ("token", "agentToken", "apiToken") if data.get(k)), None
+    )
+    if token:
+        print(f"\nVIBEGRAM_HB_TOKEN={token}\n\nдальше: строку в .env, затем рестарт")
+    else:
+        print("\nтокена в ответе не видно - смотри поля выше", file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

t3code.toml

@@ -1,16 +1,17 @@
 # Машины с T3 Code и allowlist проектов на каждой. Токены - в .env (T3_*_TOKEN).
-# Имена - MagicDNS tailnet'а; `dell` для контейнера прописан через T3_DELL_ADDR.
+# Имена - MagicDNS tailnet'а; `dell-dev` (дев-VM на делле) для контейнера
+# прописан через T3_DELL_DEV_ADDR.
 
 [machines.mac]
 url = "http://mac:3773"
 token_env = "T3_MAC_TOKEN"
 projects = ["*"]
-model = "claudeAgent/claude-opus-5"
+model = "claudeAgent/claude-opus-5-5"
 options = { effort = "high", contextWindow = "1m" }
 
-[machines.dell]
-url = "http://dell:3773"
-token_env = "T3_DELL_TOKEN"
+[machines.dell-dev]
+url = "http://dell-dev:3773"
+token_env = "T3_DELL_DEV_TOKEN"
 projects = ["*"]
-model = "claudeAgent/claude-opus-5"
+model = "claudeAgent/claude-opus-5-5"
 options = { effort = "high", contextWindow = "1m" }

tests/test_curator.py

@@ -25,7 +25,10 @@ def test_briefing_lists_new_replies_and_changed_files_or_nothing(
     notes = beaver / "наблюдения"
     replies.mkdir(parents=True)
     notes.mkdir()
-    (replies / "2026-09.md").write_text(
+    (replies / "2026-08-31.md").write_text(
+        "# реплики\n\n- 2026-08-31 23:50 · мастер · вчерашнее\n", encoding="utf-8"
+    )
+    (replies / "2026-09-01.md").write_text(
         "# реплики\n\n- 2026-09-01 12:00 · мастер · старое\n- 2026-09-01 19:30 · мастер · новое сообщение\n",
         encoding="utf-8",
     )
@@ -49,6 +52,7 @@ def test_briefing_lists_new_replies_and_changed_files_or_nothing(
     text = briefing(
         vault=vault,
         journal=journal,
+        runs=beaver / "куратор",
         replies_dir=replies,
         watched=[Watched("наблюдения", notes)],
         tz="Europe/Warsaw",
@@ -63,6 +67,7 @@ def test_briefing_lists_new_replies_and_changed_files_or_nothing(
     assert "наблюдения: `мета/бобер/наблюдения/Зина - наблюдения.md`" in text
     assert "Глафира" not in text
     assert "последний прогон: 2026-09-01T22:00:00+02:00" in text
+    assert "запись о прогоне - в `мета/бобер/куратор/2026-09-01.md`" in text
 
     journal.write_text(f"последний прогон: {now.isoformat()}\n", encoding="utf-8")
     assert new_replies(replies, now, "Europe/Warsaw") == []
@@ -71,6 +76,7 @@ def test_briefing_lists_new_replies_and_changed_files_or_nothing(
         briefing(
             vault=vault,
             journal=journal,
+            runs=beaver / "куратор",
             replies_dir=replies,
             watched=[Watched("наблюдения", notes)],
             tz="Europe/Warsaw",

tests/test_handouts.py

@@ -0,0 +1,72 @@
+import os
+from datetime import datetime
+from pathlib import Path
+from zoneinfo import ZoneInfo
+
+import pytest
+
+from beaver_agent.memory import handouts
+from beaver_agent.memory.handouts import deploy_mark
+
+ZONE = ZoneInfo("Europe/Warsaw")
+NOW = "2026-09-17 06:30"
+
+
+def _at(text: str) -> float:
+    return datetime.fromisoformat(text).replace(tzinfo=ZONE).timestamp()
+
+
+def _touch(path: Path, when: str) -> Path:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text("", encoding="utf-8")
+    os.utime(path, (_at(when), _at(when)))
+    return path
+
+
+def _bundle(tmp_path: Path, started: str, code: str) -> tuple[Path, Path]:
+    proc = _touch(tmp_path / "proc" / "1", started)
+    package = tmp_path / "beaver_agent"
+    _touch(package / "memory" / "handouts.py", code)
+    _touch(package / "vault.py", "2026-09-10 12:00")
+    # мусор компилятора не должен выглядеть свежим кодом
+    _touch(package / "memory" / "__pycache__" / "handouts.py", "2026-09-17 06:00")
+    return proc, package
+
+
+@pytest.fixture(autouse=True)
+def _now(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(handouts.time, "time", lambda: _at(NOW))
+
+
+def test_code_older_than_start(tmp_path: Path) -> None:
+    proc, package = _bundle(tmp_path, "2026-09-16 03:11", "2026-09-16 03:03")
+    assert deploy_mark(proc, package) == (
+        "Выкат: процесс поднят 2026-09-16 03:11 (27 ч назад), свежесть кода "
+        "2026-09-16 03:03 - код старше старта, значит крутится то, что выкатывали."
+    )
+
+
+def test_code_newer_than_start(tmp_path: Path) -> None:
+    proc, package = _bundle(tmp_path, "2026-09-16 03:11", "2026-09-17 06:20")
+    assert deploy_mark(proc, package) == (
+        "Выкат: процесс поднят 2026-09-16 03:11 (27 ч назад), свежесть кода "
+        "2026-09-17 06:20 - код НОВЕЕ старта: правка на диске есть, "
+        "рестарта после неё не было."
+    )
+
+
+def test_same_minute(tmp_path: Path) -> None:
+    proc, package = _bundle(tmp_path, "2026-09-17 06:00", "2026-09-17 06:00:30")
+    assert deploy_mark(proc, package) == (
+        "Выкат: процесс поднят 2026-09-17 06:00 (30 мин назад), свежесть кода "
+        "2026-09-17 06:00 - выкат и правка в одну минуту."
+    )
+
+
+def test_no_source(tmp_path: Path) -> None:
+    proc, package = _bundle(tmp_path, "2026-09-16 03:11", "2026-09-16 03:03")
+    assert deploy_mark(tmp_path / "нет", package) is None
+    assert deploy_mark(proc, tmp_path / "пусто") is None
+    only_cache = tmp_path / "кеш"
+    _touch(only_cache / "__pycache__" / "handouts.py", "2026-09-17 06:00")
+    assert deploy_mark(proc, only_cache) is None

tests/test_heartbeat.py

@@ -0,0 +1,575 @@
+import json
+import logging
+from datetime import UTC, datetime, timedelta
+from types import SimpleNamespace
+from typing import Any, cast
+from urllib.parse import parse_qsl, urlsplit
+from zoneinfo import ZoneInfo
+
+from beaver_agent.hands.heartbeat import (
+    PEER,
+    Watch,
+    alarm_text,
+    beat_line,
+    drill,
+    every_from_cron,
+    look,
+    parse_beat,
+    parse_span,
+    span,
+)
+from beaver_agent.hands.vibegram import PAGE, Event, Vibegram, Window
+
+WARSAW = ZoneInfo("Europe/Warsaw")
+NOW = datetime(2026, 9, 22, 15, 42, tzinfo=UTC)
+
+
+def hb(at, *, every="24h", nick=PEER, eid=100):
+    return Event(
+        id=eid,
+        nick=nick,
+        kind="message",
+        text=(
+            f"{nick}: hb {nick} at={at.strftime('%Y-%m-%dT%H:%M:%SZ')} "
+            f"boot=2026-09-01T03:00:00Z every={every} src=cron+uptime-s"
+        ),
+        at="09-22 07:00",
+    )
+
+
+def state(tmp_path, **kw):
+    return Watch(path=tmp_path / "сторож.json", **kw)
+
+
+def test_parse_beat_reads_fields_and_unknown_every():
+    beat = parse_beat(
+        "claude-kai: hb claude-kai at=2026-09-22T05:00:00Z "
+        "boot=2026-09-01T03:00:00Z every=24h src=cron+uptime-s"
+    )
+    assert beat is not None
+    assert beat.nick == "claude-kai"
+    assert beat.at == datetime(2026, 9, 22, 5, 0, tzinfo=UTC)
+    assert beat.boot == datetime(2026, 9, 1, 3, 0, tzinfo=UTC)
+    assert beat.every == timedelta(hours=24)
+
+    unknown = parse_beat(
+        "claude-kai: hb claude-kai at=2026-09-22T05:00:00Z "
+        "boot=? every=unknown src=none"
+    )
+    assert unknown is not None
+    assert unknown.every is None and unknown.every_raw == "unknown"
+    assert unknown.boot is None
+
+    assert parse_beat("claude-kai: просто сообщение") is None
+    assert parse_beat("claude-kai: ack beaver last=x", "ack") is not None
+
+
+def test_span_round_trip():
+    assert span(timedelta(hours=36)) == "36h"
+    assert span(timedelta(minutes=90)) == "90m"
+    assert span(None) == "unknown"
+    assert parse_span("36h") == timedelta(hours=36)
+    assert parse_span("unknown") is None
+    assert parse_span("") is None
+
+
+def test_every_from_cron_only_when_schedule_is_every_n_hours():
+    assert every_from_cron("12 17 * * *", WARSAW, now=NOW) == timedelta(hours=24)
+    assert every_from_cron("0 */6 * * *", WARSAW, now=NOW) == timedelta(hours=6)
+    # Перевод стрелок не делает суточный крон 23-часовым: считаем по стенным часам
+    march = datetime(2026, 3, 28, 12, tzinfo=UTC)
+    assert every_from_cron("12 17 * * *", WARSAW, now=march) == timedelta(hours=24)
+    # Не сводится к «раз в N часов» - и не сводим
+    assert every_from_cron("0 2,8,12,16,20 * * *", WARSAW, now=NOW) is None
+    assert every_from_cron("*/10 * * * *", WARSAW, now=NOW) is None
+    # Недельный крон тоже сводится к N часам - это честные 168h, а не unknown
+    assert every_from_cron("30 4 * * 0", WARSAW, now=NOW) == timedelta(hours=168)
+    assert every_from_cron(None, WARSAW, now=NOW) is None
+    assert every_from_cron("не крон", WARSAW, now=NOW) is None
+
+
+def test_beat_line_says_unknown_instead_of_guessing():
+    line = beat_line(
+        nick="beaver",
+        at=datetime(2026, 9, 22, 15, 12, tzinfo=UTC),
+        boot=datetime(2026, 9, 20, 1, 2, 3, tzinfo=UTC),
+        every=timedelta(hours=24),
+    )
+    assert line == (
+        "hb beaver at=2026-09-22T15:12:00Z boot=2026-09-20T01:02:03Z every=24h src=cron"
+    )
+    blind = beat_line(nick="beaver", at=NOW, boot=NOW, every=None)
+    assert "every=unknown src=none" in blind
+
+
+def test_fresh_beat_arms_and_stays_quiet(tmp_path):
+    w = state(tmp_path)
+    report = look(
+        w, [hb(NOW - timedelta(hours=10))], now=NOW, res=timedelta(hours=24), full=True
+    )
+    assert report.armed and report.alarm is None and not report.stale
+    assert report.threshold == timedelta(hours=36)
+    assert "armed=yes" in report.ack and "win=25" in report.ack
+    assert "res=24h" in report.ack and "thr=36h" in report.ack
+    assert w.seen == NOW and w.top == 100
+
+
+def test_same_beat_seen_twice_does_not_move_seen(tmp_path):
+    w = state(tmp_path)
+    old = hb(NOW - timedelta(hours=1), eid=200)
+    first = look(w, [old], now=NOW, res=None, full=True)
+    assert first.armed and first.alarm is None
+    assert w.seen == NOW and w.beat_id == 200
+
+    # Тот же самый hb в окне следующего прогона - это не новое показание
+    again = look(w, [old], now=NOW + timedelta(hours=6), res=None, full=True)
+    assert w.seen == NOW and again.alarm is None
+    assert "отметка та же" in again.note
+
+    # И через порог 36h та же отметка уже не выглядит живой цепью
+    late = NOW + timedelta(hours=37)
+    loud = look(w, [old], now=late, res=None, full=True)
+    assert loud.alarm == "silence" and w.seen == NOW
+    assert loud.age is not None and loud.age > timedelta(hours=36)
+
+    # Пришла новая отметка - новый id, и seen снова двигается
+    fresh = look(w, [old, hb(late, eid=201)], now=late, res=None, full=True)
+    assert fresh.alarm is None and w.seen == late and w.beat_id == 201
+
+
+def test_state_without_beat_id_trusts_its_own_seen(tmp_path):
+    path = tmp_path / "сторож.json"
+    path.write_text(
+        json.dumps(
+            {
+                "version": 1,
+                "at": "2026-09-21T05:00:01Z",
+                "seen": "2026-09-22T05:42:01Z",
+                "every": 86400,
+                "every_unknown": False,
+                "top": 300,
+                "alerted": None,
+                "unarmed_since": None,
+                "unarmed_told": False,
+            }
+        ),
+        encoding="utf-8",
+    )
+    w = Watch.load(path)
+    was = datetime(2026, 9, 22, 5, 42, 1, tzinfo=UTC)
+    assert w.beat_id == 0 and w.seen == was
+
+    old = hb(datetime(2026, 9, 21, 5, 0, 1, tzinfo=UTC), eid=305)
+    assert look(w, [old], now=NOW, res=None, full=True).alarm is None
+    assert w.seen == was and w.beat_id == 305
+    # Старое состояние не пере-вооружилось на старой отметке: порог придёт в срок
+    over = datetime(2026, 9, 23, 20, 0, tzinfo=UTC)
+    assert look(w, [old], now=over, res=None, full=True).alarm == "silence"
+
+
+def test_threshold_is_every_times_one_and_a_half(tmp_path):
+    # 30 часов при every=24h - ещё не тревога: одна потерянная строка не в счёт
+    quiet = state(tmp_path, seen=NOW - timedelta(hours=30), every=timedelta(hours=24))
+    assert look(quiet, [], now=NOW, res=timedelta(hours=24), full=True).alarm is None
+    # 37 часов - уже за порогом 36
+    loud = state(tmp_path, seen=NOW - timedelta(hours=37), every=timedelta(hours=24))
+    report = look(loud, [], now=NOW, res=timedelta(hours=24), full=True)
+    assert report.alarm == "silence"
+    # Порог берётся из строки соседа, а не из нашей константы
+    slow = state(tmp_path, seen=NOW - timedelta(hours=37), every=timedelta(hours=48))
+    assert look(slow, [], now=NOW, res=timedelta(hours=24), full=True).alarm is None
+
+
+def test_last_beat_wins_over_gaps(tmp_path):
+    w = state(tmp_path, seen=NOW - timedelta(hours=40), every=timedelta(hours=24))
+    report = look(
+        w, [hb(NOW - timedelta(hours=1), eid=120)], now=NOW, res=None, full=True
+    )
+    assert report.alarm is None
+    assert report.age is not None and report.age < timedelta(hours=2)
+    assert "res=unknown" in report.ack
+
+
+def test_unknown_every_falls_back_to_last_known_and_says_so(tmp_path):
+    w = state(tmp_path, every=timedelta(hours=24))
+    report = look(w, [hb(NOW, every="unknown", eid=130)], now=NOW, res=None, full=True)
+    assert report.threshold == timedelta(hours=36)
+    assert "thr=36h-fallback" in report.ack
+    assert w.every == timedelta(hours=24)
+
+
+def test_no_period_ever_means_no_measurement_and_no_alarm(tmp_path):
+    w = state(tmp_path, seen=NOW - timedelta(days=9))
+    report = look(w, [], now=NOW, res=timedelta(hours=24), full=True)
+    assert report.alarm is None and report.threshold is None
+    assert "thr=unknown" in report.ack
+    assert "мерить нечем" in report.note
+
+
+def test_never_seen_is_armed_no_not_alarm(tmp_path):
+    w = state(tmp_path)
+    report = look(w, [], now=NOW, res=timedelta(hours=24), full=True)
+    assert not report.armed and report.alarm is None
+    assert "armed=no" in report.ack and "last=never seen=never" in report.ack
+    assert w.unarmed_since == NOW
+
+
+def test_seven_days_unarmed_tells_the_human_once(tmp_path):
+    w = state(tmp_path, unarmed_since=NOW - timedelta(days=7))
+    assert look(w, [], now=NOW, res=timedelta(hours=24), full=True).alarm == "unarmed"
+    w.unarmed_told = True
+    assert look(w, [], now=NOW, res=timedelta(hours=24), full=True).alarm is None
+    # Пришла первая отметка - кольцо вооружилось, счётчик забыт
+    look(w, [hb(NOW, eid=140)], now=NOW, res=timedelta(hours=24), full=True)
+    assert w.unarmed_since is None
+
+
+def test_stale_window_forbids_alarm(tmp_path):
+    w = state(
+        tmp_path, seen=NOW - timedelta(hours=40), every=timedelta(hours=24), top=500
+    )
+    report = look(
+        w, [hb(NOW - timedelta(hours=40), eid=7)], now=NOW, res=None, full=True
+    )
+    assert report.stale and report.alarm is None
+    assert "win=stale" in report.ack
+    assert w.top == 500  # съехавшее окно не двигает отметку максимума
+    # Окно снова вперёд - тревога берётся
+    fresh = look(
+        w, [hb(NOW - timedelta(hours=40), eid=501)], now=NOW, res=None, full=True
+    )
+    assert not fresh.stale
+
+
+def test_alarm_not_repeated_within_a_day(tmp_path):
+    w = state(
+        tmp_path,
+        seen=NOW - timedelta(hours=40),
+        every=timedelta(hours=24),
+        alerted=NOW - timedelta(hours=5),
+    )
+    assert look(w, [], now=NOW, res=None, full=True).alarm is None
+    w.alerted = NOW - timedelta(hours=25)
+    assert look(w, [], now=NOW, res=None, full=True).alarm == "silence"
+
+
+def test_ack_says_what_the_instrument_decided(tmp_path):
+    # Цепь жива - решать нечего
+    alive = state(tmp_path)
+    assert "alert=none" in look(alive, [hb(NOW)], now=NOW, res=None, full=True).ack
+    # Порог пройден, тревога взята в этом прогоне
+    loud = state(tmp_path, seen=NOW - timedelta(hours=40), every=timedelta(hours=24))
+    fired = look(loud, [], now=NOW, res=None, full=True)
+    assert fired.alarm == "silence" and "alert=fired" in fired.ack
+    # Порог пройден, но тревога уходила меньше суток назад - повтор подавлен
+    loud.alerted = NOW - timedelta(hours=5)
+    held = look(loud, [], now=NOW, res=None, full=True)
+    assert held.alarm is None and "alert=held" in held.ack
+    # Кольцо так и не вооружилось дольше недели - это тоже выстрел
+    late = state(tmp_path, unarmed_since=NOW - timedelta(days=8))
+    assert "alert=fired" in look(late, [], now=NOW, res=None, full=True).ack
+    # Показания нет (окно не дочитано) - не `held`, а `none`: подавлять нечего
+    unread = state(tmp_path, seen=NOW - timedelta(hours=40), every=timedelta(hours=24))
+    assert "alert=none" in look(unread, [], now=NOW, res=None, full=False).ack
+
+
+def test_drill_flag_is_a_list_of_local_dates(tmp_path):
+    flag = tmp_path / "сторож-учения.txt"
+    assert not drill(flag, now=NOW, tz=WARSAW)  # файла нет - отметка уходит
+    flag.write_text("\n \n", encoding="utf-8")
+    assert not drill(flag, now=NOW, tz=WARSAW)  # пустой - тоже
+    flag.write_text("2026-09-28\n2026-09-29\n", encoding="utf-8")
+    assert drill(flag, now=datetime(2026, 9, 28, 15, 12, tzinfo=UTC), tz=WARSAW)
+    assert not drill(flag, now=datetime(2026, 9, 27, 15, 12, tzinfo=UTC), tz=WARSAW)
+    # Дата локальная в зоне планировщика: 22:30 UTC - это уже 29-е в Варшаве
+    assert drill(flag, now=datetime(2026, 9, 28, 22, 30, tzinfo=UTC), tz=WARSAW)
+    assert not drill(flag, now=datetime(2026, 9, 29, 22, 30, tzinfo=UTC), tz=WARSAW)
+
+
+def test_alarm_text_names_three_causes_and_suspects_the_channel(tmp_path):
+    w = state(tmp_path, seen=NOW - timedelta(hours=40), every=timedelta(hours=24))
+    report = look(w, [], now=NOW, res=timedelta(hours=24), full=True)
+    silent = alarm_text(report, mine_sent=True)
+    assert "машина соседа" in silent and "крон" in silent and "канал" in silent
+    assert "канал подозревать надо раньше" in silent
+    # Сосед хоть чем-то отметился - канал скорее жив
+    heard = look(
+        state(tmp_path, seen=NOW - timedelta(hours=40), every=timedelta(hours=24)),
+        [
+            Event(
+                id=9,
+                nick=PEER,
+                kind="message",
+                text=f"{PEER}: ack beaver last=x",
+                at="09-22 07:00",
+            )
+        ],
+        now=NOW,
+        res=None,
+        full=True,
+    )
+    assert heard.heard
+    assert "канал скорее жив" in alarm_text(heard, mine_sent=True)
+
+
+def test_state_survives_a_round_trip(tmp_path):
+    w = state(
+        tmp_path,
+        at=NOW,
+        seen=NOW,
+        every=timedelta(hours=24),
+        every_unknown=True,
+        beat_id=329,
+        top=42,
+        alerted=NOW,
+        unarmed_since=None,
+        unarmed_told=True,
+    )
+    w.save()
+    back = Watch.load(w.path)
+    assert back.at == NOW and back.seen == NOW and back.top == 42
+    assert back.beat_id == 329
+    assert back.every == timedelta(hours=24) and back.every_unknown
+    assert back.alerted == NOW and back.unarmed_told
+    assert Watch.load(tmp_path / "нет.json").seen is None
+
+
+class FakeRoom:
+    def __init__(self, events, *, nick="beaver", send_fails=False, full=True):
+        self.events = events
+        self.nick = nick
+        self.send_fails = send_fails
+        self.full = full
+        self.said = []
+        self.limit = None
+
+    async def window(self, limit=25):
+        self.limit = limit
+        return Window(events=self.events, full=self.full)
+
+    async def say(self, text):
+        if self.send_fails:
+            msg = "хаб молчит"
+            raise RuntimeError(msg)
+        self.said.append(text)
+
+
+class FakeRun:
+    def __init__(self, cron="42 */6 * * *"):
+        self.job = SimpleNamespace(cron=cron, name="сторож")
+        self.scheduler = SimpleNamespace(tz=WARSAW)
+        self.spawned = []
+
+    async def spawn_job(self, *, agent, text, title=None):
+        self.spawned.append((agent, title, text))
+        return None
+
+
+async def test_watch_job_prints_ack_and_spawns_alarm(tmp_path, monkeypatch):
+    from beaver_agent.jobs import heartbeat as job
+
+    monkeypatch.setattr(job, "STATE_FILE", tmp_path / "сторож.json")
+    Watch(
+        path=tmp_path / "сторож.json",
+        seen=datetime.now(UTC) - timedelta(hours=40),
+        every=timedelta(hours=24),
+    ).save()
+    room = FakeRoom([])
+    monkeypatch.setattr(job, "VIBEGRAM_HB", room)
+    run = FakeRun()
+
+    await job.watch(cast("Any", run))
+
+    assert room.limit == 25  # окно запрошено явным размером
+    assert room.said and room.said[0].startswith(f"ack {PEER} ")
+    assert "res=6h" in room.said[0]
+    assert len(run.spawned) == 1
+    agent, title, text = run.spawned[0]
+    assert agent == "beaver-triage" and title == "сторож"
+    assert "канал подозревать надо раньше" in text
+    # Тревога записана в состояние - следующий прогон в те же сутки молчит
+    assert Watch.load(tmp_path / "сторож.json").alerted is not None
+    await job.watch(cast("Any", run))
+    assert len(run.spawned) == 1
+
+
+async def test_beat_job_sends_period_from_its_own_cron(monkeypatch):
+    from beaver_agent.jobs import heartbeat as job
+
+    room = FakeRoom([], nick="beaver")
+    monkeypatch.setattr(job, "VIBEGRAM_HB", room)
+    await job.beat(cast("Any", FakeRun(cron="12 17 * * *")))
+    assert room.said[0].startswith("hb beaver at=")
+    assert "every=24h src=cron" in room.said[0]
+
+    odd = FakeRoom([], nick="beaver")
+    monkeypatch.setattr(job, "VIBEGRAM_HB", odd)
+    await job.beat(cast("Any", FakeRun(cron="0 2,8,12,16,20 * * *")))
+    assert "every=unknown src=none" in odd.said[0]
+
+
+async def test_beat_job_keeps_silent_on_a_drill_day(tmp_path, monkeypatch, caplog):
+    from beaver_agent.jobs import heartbeat as job
+
+    flag = tmp_path / "сторож-учения.txt"
+    monkeypatch.setattr(job, "DRILL_FILE", flag)
+    room = FakeRoom([], nick="beaver")
+    monkeypatch.setattr(job, "VIBEGRAM_HB", room)
+    today = datetime.now(WARSAW).strftime("%Y-%m-%d")
+
+    flag.write_text(f"2026-01-01\n{today}\n", encoding="utf-8")
+    with caplog.at_level(logging.INFO):
+        await job.beat(cast("Any", FakeRun(cron="12 17 * * *")))
+    assert not room.said  # молчание в комнате и есть учения
+    assert "пропущена по флагу" in caplog.text
+
+    # Не наш день - отметка уходит как обычно
+    flag.write_text("2026-01-01\n", encoding="utf-8")
+    await job.beat(cast("Any", FakeRun(cron="12 17 * * *")))
+    assert len(room.said) == 1 and room.said[0].startswith("hb beaver at=")
+
+    # Файла нет - тоже обычный прогон
+    flag.unlink()
+    await job.beat(cast("Any", FakeRun(cron="12 17 * * *")))
+    assert len(room.said) == 2
+
+
+async def test_watch_job_keeps_quiet_when_the_room_is_unreadable(tmp_path, monkeypatch):
+    from beaver_agent.jobs import heartbeat as job
+
+    class Dead(FakeRoom):
+        async def window(self, limit=25):
+            msg = "хаб не отвечает"
+            raise RuntimeError(msg)
+
+    monkeypatch.setattr(job, "STATE_FILE", tmp_path / "сторож.json")
+    monkeypatch.setattr(job, "VIBEGRAM_HB", Dead([]))
+    run = FakeRun()
+    await job.watch(cast("Any", run))
+    assert not run.spawned
+    assert not (tmp_path / "сторож.json").exists()
+
+
+class FakeHub:
+    """Хаб как он есть: id сквозные по ВСЕМ комнатам, `/api/state` - наша.
+
+    Хвост комнаты лежит за `/api/state?view=…&after=<id>` и отдаётся
+    страницами вперёд; `/api/pending` - курсор, и сторожу в него ходить
+    нечего: то же событие второй раз оттуда не придёт.
+    """
+
+    def __init__(self, events, *, page=PAGE):
+        self.events = events
+        self.page = page
+        self.said = []
+        self.afters = []
+
+    async def call(self, method, path, body):
+        if method == "POST" and path == "/api/messages":
+            self.said.append(body["body"])
+            return {"ok": True}
+        if path == "/api/room":
+            return {"room": {"id": "dbb", "name": "kai-rem-watch", "viewToken": "v-1"}}
+        if path.startswith("/api/state"):
+            query = dict(parse_qsl(urlsplit(path).query))
+            assert query["view"] == "v-1"
+            after = int(query.get("after", 0))
+            self.afters.append(after)
+            rest = [e for e in self.events if e["id"] > after]
+            return {"room": {}, "agents": [], "events": rest[: self.page]}
+        msg = f"сторож не должен ходить в {path}"
+        raise AssertionError(msg)
+
+
+def raw(eid, nick, kind, body=None, at="2026-09-23T05:00:02.000Z"):
+    return {
+        "id": eid,
+        "roomId": "dbb",
+        "nick": nick,
+        "kind": kind,
+        "payload": {} if body is None else {"body": body},
+        "createdAt": at,
+    }
+
+
+def room(monkeypatch, events, *, page=PAGE):
+    hub = FakeHub(events, page=page)
+
+    async def call(self, method, path, body):
+        return await hub.call(method, path, body)
+
+    monkeypatch.setattr(Vibegram, "_call", call)
+    return hub, Vibegram(hub="http://hub", token="t", nick="beaver-rem")
+
+
+KAI_HB = (
+    f"hb {PEER} at=2026-09-23T05:00:01Z boot=2026-09-14T08:21:55Z "
+    "every=24h src=cron+uptime-s"
+)
+
+
+async def test_window_is_the_rooms_last_messages_not_the_hubs_last_ids(
+    tmp_path, monkeypatch, caplog
+):
+    from beaver_agent.jobs import heartbeat as job
+
+    # В комнате три события, а по хабу за то же время прошло три десятка:
+    # номера сквозные, и между 296 и 336 лежат чужие комнаты. Отметка соседа
+    # (#329) обязана быть в окне - в комнате она первая с конца.
+    hub, client = room(
+        monkeypatch,
+        [
+            raw(296, PEER, "agent_join"),
+            raw(329, PEER, "message", KAI_HB),
+            raw(331, "beaver-rem", "agent_leave"),
+            raw(332, "beaver-rem", "message", "hb beaver-rem at=2026-09-23T15:12:01Z"),
+            raw(336, PEER, "message", "ack beaver-rem last=2026-09-23T15:12:01Z"),
+        ],
+    )
+    monkeypatch.setattr(job, "STATE_FILE", tmp_path / "сторож.json")
+    monkeypatch.setattr(job, "VIBEGRAM_HB", client)
+
+    window = await client.window(25)
+    assert window.full
+    assert [e.id for e in window.events] == [329, 332, 336]  # join/leave не в счёт
+    assert parse_beat(window.events[0].text) is not None
+
+    # Два прогона подряд: отметка соседа в окне оба раза, а не только в первом
+    with caplog.at_level(logging.INFO, logger="beaver_agent.jobs.heartbeat"):
+        await job.watch(cast("Any", FakeRun()))
+        await job.watch(cast("Any", FakeRun()))
+    beats = [m for m in caplog.messages if "отметок соседа в окне: 1" in m]
+    assert len(beats) == 2
+    assert all("история дочитана" in m for m in beats)
+    assert all("last=2026-09-23T05:00:01Z" in a and "armed=yes" in a for a in hub.said)
+    assert all("win=25 " in a for a in hub.said)
+    assert hub.afters == [0, 0, 0]  # одна страница на прогон, читать дальше нечего
+
+
+async def test_a_hundred_noise_lines_do_not_push_the_control_beat_out(
+    tmp_path, monkeypatch
+):
+    from beaver_agent.jobs import heartbeat as job
+
+    # Учения соседа: сотня шумовых строк в комнату и контрольная hb после них.
+    noise = [raw(400 + i, PEER, "message", f"шум {i}") for i in range(100)]
+    hub, client = room(monkeypatch, [*noise, raw(600, PEER, "message", KAI_HB)])
+    monkeypatch.setattr(job, "STATE_FILE", tmp_path / "сторож.json")
+    monkeypatch.setattr(job, "VIBEGRAM_HB", client)
+
+    await job.watch(cast("Any", FakeRun()))
+
+    assert "last=2026-09-23T05:00:01Z" in hub.said[0] and "armed=yes" in hub.said[0]
+    assert Watch.load(tmp_path / "сторож.json").top == 600
+
+
+def test_unread_window_is_named_and_takes_no_alarm(tmp_path):
+    late = {"seen": NOW - timedelta(hours=40), "every": timedelta(hours=24)}
+    partial = look(state(tmp_path, **late), [], now=NOW, res=None, full=False)
+    assert not partial.full and partial.alarm is None
+    assert "win=25/partial" in partial.ack
+    assert "окно не дочитано" in partial.note
+    # То же пустое окно, но дочитанное, - это показание, и оно даёт тревогу
+    whole = look(state(tmp_path, **late), [], now=NOW, res=None, full=True)
+    assert whole.alarm == "silence" and "win=25 " in whole.ack
+    assert "сообщений комнаты: 0 из 25, история дочитана" in whole.note

tests/test_komodo.py

@@ -49,3 +49,138 @@ def test_clip_keeps_head_and_tail():
     k = Komodo(url="u", key="k", secret="s", max_chars=30)
     out = k._clip("a" * 100)
     assert out.startswith("a" * 20) and out.endswith("a" * 10) and "обрезано" in out
+
+
+def fleet(answers, calls=None):
+    """Komodo, отвечающий заготовками; calls копит запросы к нему."""
+
+    class Fake(Komodo):
+        async def read(self, request, params):
+            if calls is not None:
+                calls.append((request, params))
+            answer = answers.get(request, [])
+            return answer(params) if callable(answer) else answer
+
+    return Fake(url="u", key="k", secret="s")
+
+
+def a_stack(name, state="running", stack_id=None):
+    return {
+        "id": stack_id or name,
+        "name": name,
+        "info": {"state": state, "server_name": "dell-home"},
+    }
+
+
+def an_update(operation="DeployStack", target_id="beaver-agent", ts=1_700_000_000_000):
+    return {
+        "id": f"upd-{ts}",
+        "operation": operation,
+        "start_ts": ts,
+        "success": True,
+        "status": "Complete",
+        "username": "hh",
+        "target": {"type": "Stack", "id": target_id},
+    }
+
+
+async def test_a_short_page_is_not_the_whole_list():
+    # Komodo режет List* до default_pagination_limit и молчит об этом.
+    pages = [
+        [a_stack(f"s{i}") for i in range(500)],
+        [a_stack("zv-import"), a_stack("veris-runner")],
+    ]
+    calls = []
+    komodo = fleet({"ListStacks": lambda p: pages[p["page"]]}, calls)
+    out = await komodo._stacks()
+    assert [p["page"] for r, p in calls if r == "ListStacks"] == [0, 1]
+    assert "zv-import" in out and "стеков: 502" in out
+
+
+async def test_status_says_when_the_not_running_list_is_cut():
+    bad = [a_stack(f"b{i}", state="unknown") for i in range(23)]
+    komodo = fleet({"ListStacks": bad, "ListServers": []})
+    out = await komodo._status()
+    assert "стеков: 23, не running: 23" in out
+    assert "показаны 15 из 23, остальные скрыты лимитом" in out
+
+    komodo = fleet({"ListStacks": bad[:3], "ListServers": []})
+    assert "скрыты лимитом" not in await komodo._status()
+
+
+async def test_both_listings_say_that_they_are_limited_by_rights():
+    komodo = fleet({"ListStacks": [a_stack("beaver-agent")], "ListServers": []})
+    assert "ограничен правами ключа" in await komodo._status()
+    assert "ограничен правами ключа" in await komodo._stacks()
+
+
+async def test_updates_carry_the_shown_span_and_say_there_is_more():
+    page = {
+        "updates": [an_update(ts=1_700_000_000_000 - i * 60_000) for i in range(100)]
+    }
+    seen = {"ListStacks": [a_stack("beaver-agent")]}
+    komodo = fleet(seen | {"ListUpdates": page | {"next_page": 1}})
+    head, second, *lines = (await komodo._updates(15, None, None)).splitlines()
+    assert head == "операций: 15, 11-14 21:59 … 11-14 22:13, раньше в журнале есть ещё"
+    assert second == "фильтра нет: это просто хвост журнала"
+    assert len(lines) == 15
+
+    komodo = fleet(
+        seen | {"ListUpdates": {"updates": page["updates"][:3], "next_page": None}}
+    )
+    assert (await komodo._updates(15, None, None)).startswith(
+        "операций: 3, 11-14 22:11 … 11-14 22:13, это весь журнал"
+    )
+
+
+async def test_the_filter_goes_to_komodo_as_a_query():
+    calls = []
+    komodo = fleet(
+        {
+            "ListStacks": [a_stack("beaver-agent", stack_id="id-1")],
+            "ListUpdates": {
+                "updates": [an_update(target_id="id-1")],
+                "next_page": None,
+            },
+        },
+        calls,
+    )
+    out = await komodo._updates(15, "deploy", "beaver")
+    (params,) = [p for r, p in calls if r == "ListUpdates"]
+    assert params["query"] == {
+        "operation": {"$regex": "deploy", "$options": "i"},
+        "target.id": {"$in": ["id-1"]},
+    }
+    assert "фильтрует Komodo: операция ~deploy; ресурс ~beaver (1 шт)" in out
+    # имя ресурса в строке, а не id
+    assert "beaver-agent" in out and "id-1 " not in out
+
+
+async def test_an_unknown_name_is_said_out_loud_instead_of_filtering_by_nothing():
+    komodo = fleet({"ListStacks": [a_stack("beaver-agent")]})
+    out = await komodo._updates(15, None, "obsidian")
+    assert out == (
+        "ресурса ~obsidian ключу руки не видно: либо имя другое, либо он вне прав ключа"
+    )
+
+
+async def test_a_target_the_key_cannot_see_is_counted_and_shown_by_id():
+    komodo = fleet(
+        {
+            "ListStacks": [a_stack("beaver-agent", stack_id="id-1")],
+            "ListUpdates": {
+                "updates": [an_update(target_id="id-1"), an_update(target_id="gone")],
+                "next_page": None,
+            },
+        }
+    )
+    out = await komodo._updates(15, None, None)
+    assert "записей о невидимых ключу ресурсах: 1 - id вместо имени" in out
+    assert "gone" in out
+
+
+async def test_the_depth_is_clamped_out_loud():
+    komodo = fleet({"ListUpdates": {"updates": [], "next_page": None}})
+    assert "запрошено 5000 записей, предел руки 200" in await komodo._updates(
+        5000, None, None
+    )

tests/test_komodo_logs.py

@@ -0,0 +1,813 @@
+import json
+from datetime import UTC, datetime, timedelta
+
+from beaver_agent.hands.komodo import Komodo
+from beaver_agent.hands.komodo_logs import (
+    KEEP,
+    MUTE_KINDS,
+    MUTE_SHOW,
+    SELF_MARK,
+    SURGE_CEILING,
+    SURGE_FACTOR,
+    SURGE_MIN,
+    Seen,
+    StackScan,
+    Sweep,
+    brief,
+    daily,
+    digest,
+    grouped,
+    note,
+    read_stack,
+    record,
+)
+from beaver_agent.jobs.logs import sweep as sweep_fleet
+
+NOW = datetime(2026, 9, 20, 18, 0, tzinfo=UTC)
+
+
+def log(*lines):
+    return {"stdout": "\n".join(lines), "stderr": ""}
+
+
+def line(service, at, text):
+    return f"{service}  | {at}Z {text}"
+
+
+def a_stack(name, server="dell-home"):
+    return {
+        "id": name,
+        "name": name,
+        "info": {"state": "running", "server_name": server},
+    }
+
+
+def fleet(answers, calls=None):
+    """Komodo, отвечающий заготовками; calls копит запросы к нему."""
+
+    class Fake(Komodo):
+        async def read(self, request, params):
+            if calls is not None:
+                calls.append((request, params))
+            answer = answers.get(request, [])
+            return answer(params) if callable(answer) else answer
+
+    return Fake(url="u", key="k", secret="s")
+
+
+def swept(scans, **kw):
+    kw.setdefault("in_scope", len(scans))
+    kw.setdefault("fleet", len(scans))
+    return Sweep(at=kw.pop("at", NOW), scans=tuple(scans), **kw)
+
+
+KNOWN = ("beaver-agent", "gitea", "democalc", "mix", "healthbot")
+
+
+def seen(tmp_path, *, fresh=False, known=KNOWN):
+    """Состояние с уже снятой базовой линией: проход не первый."""
+    state = Seen.load(tmp_path / "логи.json")
+    if not fresh:
+        state.fresh = False
+        state.baselined = set(known)
+    return state
+
+
+def test_a_line_gives_its_service_its_time_and_its_signal():
+    scan = read_stack(
+        "beaver-agent",
+        log(
+            line("beaver-gateway", "2026-09-20T17:40:01.123456789", "ERROR boom"),
+            line("beaver-gateway", "2026-09-20T17:41:02.000000000", "ERROR boom"),
+            line("beaver-obsidian", "2026-09-20T17:42:03.000000000", "Fully synced"),
+        ),
+    )
+    (hit,) = scan.hits
+    assert hit.service == "beaver-gateway"
+    assert hit.signal == "ошибка"
+    assert hit.count == 2
+    assert hit.at == datetime(2026, 9, 20, 17, 41, 2, tzinfo=UTC)
+    assert scan.first == datetime(2026, 9, 20, 17, 40, 1, 123456, tzinfo=UTC)
+    assert scan.last == datetime(2026, 9, 20, 17, 42, 3, tzinfo=UTC)
+
+
+def test_the_same_trouble_with_other_numbers_is_the_same_trouble():
+    scan = read_stack(
+        "gitea",
+        log(
+            line("gitea", "2026-09-20T17:40:01.0", "ERROR request 8871 failed"),
+            line("gitea", "2026-09-20T17:40:09.0", "ERROR request 9134 failed"),
+        ),
+    )
+    (hit,) = scan.hits
+    assert hit.count == 2
+
+
+def test_every_named_signal_is_caught():
+    texts = (
+        "CRITICAL disk is gone",
+        "panic: runtime error",
+        "container OOMKilled",
+        "Traceback (most recent call last):",
+        "service exited with code 137",
+        "beaver-gateway Restarting (1) 3 seconds ago",
+        "container is unhealthy",
+        "ERROR plain",
+    )
+    scan = read_stack(
+        "mix",
+        log(*(line("svc", f"2026-09-20T17:4{i}:00.0", t) for i, t in enumerate(texts))),
+    )
+    assert {h.signal for h in scan.hits} == {
+        "критично",
+        "паника",
+        "oom",
+        "traceback",
+        "падение",
+        "рестарт-цикл",
+        "healthcheck",
+        "ошибка",
+    }
+    assert "exited with code 0" not in {h.sample for h in scan.hits}
+
+
+def test_a_clean_exit_and_our_own_inject_are_not_trouble():
+    scan = read_stack(
+        "beaver-agent",
+        log(
+            line("svc", "2026-09-20T17:40:00.0", "worker exited with code 0"),
+            line("beaver-gateway", "2026-09-20T17:41:00.0", f"{SELF_MARK}: ERROR boom"),
+        ),
+    )
+    assert scan.hits == ()
+
+
+def test_komodos_own_error_is_not_a_clean_stack():
+    scan = read_stack("gitea", {"error": "periphery unreachable"})
+    assert not scan.ok
+    assert scan.error == "periphery unreachable"
+    assert Sweep(at=NOW, scans=(scan,), in_scope=1, fleet=1).trouble == (
+        "gitea: periphery unreachable",
+    )
+
+
+def test_the_first_pass_only_takes_the_baseline(tmp_path):
+    state = seen(tmp_path, fresh=True)
+    scan = read_stack(
+        "beaver-agent", log(line("svc", "2026-09-20T17:40:00.0", "ERROR старая беда"))
+    )
+    report = digest(state, swept([scan]))
+    assert report.cold and report.baseline == 1
+    assert report.new == ()
+    text = brief(report)
+    assert "базовую линию" in text
+    assert "прочитано 1 стеков из 1" in text
+
+
+def test_only_the_new_line_wakes_the_master(tmp_path):
+    old = line("svc", "2026-09-20T17:40:00.0", "ERROR молотит третьи сутки")
+    state = seen(tmp_path, fresh=True)
+    first = digest(state, swept([read_stack("beaver-agent", log(old))]))
+    state.mark_told(first)
+    state.save()
+
+    fresh_line = line("svc", "2026-09-20T18:50:00.0", "CRITICAL диск кончился")
+    state = Seen.load(tmp_path / "логи.json")
+    report = digest(
+        state,
+        swept(
+            [read_stack("beaver-agent", log(old, old, fresh_line))],
+            at=NOW + timedelta(hours=3),
+        ),
+    )
+    (new,) = report.new
+    assert new.signal == "критично"
+    text = brief(report)
+    assert "диск кончился" in text
+    assert "молотит третьи сутки" not in text
+
+
+def test_a_repeat_carries_how_many_times(tmp_path):
+    noisy = [
+        line("svc", f"2026-09-20T17:4{i}:00.0", "ERROR раз за разом") for i in range(5)
+    ]
+    report = digest(seen(tmp_path), swept([read_stack("beaver-agent", log(*noisy))]))
+    assert "×5" in brief(report)
+
+
+def test_a_trouble_that_stopped_is_dated_by_the_event_not_by_the_look(tmp_path):
+    was = line("svc", "2026-09-20T12:03:00.0", "ERROR было и прошло")
+    state = seen(tmp_path)
+    state.mark_told(digest(state, swept([read_stack("beaver-agent", log(was))])))
+
+    later = NOW + timedelta(hours=6)
+    report = digest(state, swept([read_stack("beaver-agent", log())], at=later))
+    (quiet,) = report.quiet
+    assert quiet.last == datetime(2026, 9, 20, 12, 3, tzinfo=UTC)
+    text = brief(report)
+    assert "последнее в 20.09 12:03" in text
+    assert f"{later:%H:%M}" not in text.split("\n", 1)[1]
+
+
+def test_a_stack_that_did_not_answer_is_not_a_stack_that_went_quiet(tmp_path):
+    was = line("svc", "2026-09-20T12:03:00.0", "ERROR было")
+    state = seen(tmp_path)
+    state.mark_told(digest(state, swept([read_stack("beaver-agent", log(was))])))
+
+    report = digest(
+        state,
+        swept(
+            [StackScan(stack="beaver-agent", error="timeout")],
+            at=NOW + timedelta(hours=3),
+        ),
+    )
+    assert report.quiet == ()
+    assert report.trouble == ("beaver-agent: timeout",)
+    assert "beaver-agent: timeout" in brief(report)
+
+
+def test_an_undelivered_inject_leaves_the_trouble_new(tmp_path):
+    scan = read_stack(
+        "beaver-agent", log(line("svc", "2026-09-20T17:40:00.0", "ERROR боль"))
+    )
+    state = seen(tmp_path)
+    first = digest(state, swept([scan]))
+    assert len(first.new) == 1
+    state.save()  # инжект не доехал: mark_told не звали
+
+    state = Seen.load(state.path)
+    again = digest(
+        state, swept([read_stack("beaver-agent", log())], at=NOW + timedelta(hours=3))
+    )
+    assert [e.sample for e in again.new] == [e.sample for e in first.new]
+    assert again.quiet == ()
+
+
+def test_the_state_survives_a_restart(tmp_path):
+    scan = read_stack(
+        "beaver-agent", log(line("svc", "2026-09-20T17:40:00.0", "ERROR боль"))
+    )
+    state = seen(tmp_path)
+    state.mark_told(digest(state, swept([scan])))
+    state.save()
+
+    state = Seen.load(state.path)
+    assert not state.fresh
+    report = digest(state, swept([scan], at=NOW + timedelta(hours=3)))
+    assert report.new == () and report.quiet == ()
+
+
+def test_an_old_line_still_lying_in_the_tail_is_not_new_again(tmp_path):
+    # Тихий стек держит августовскую строку в хвосте месяцами: она не новая.
+    scan = read_stack(
+        "democalc", log(line("pg-1", "2026-08-22T15:49:51.0", "ERROR: relation"))
+    )
+    state = seen(tmp_path)
+    state.mark_told(digest(state, swept([scan])))
+    state.save()
+
+    state = Seen.load(state.path)
+    assert digest(state, swept([scan], at=NOW + timedelta(hours=3))).new == ()
+
+
+def test_a_trouble_forgotten_by_time_comes_back_as_new(tmp_path):
+    scan = read_stack(
+        "beaver-agent", log(line("svc", "2026-09-20T17:40:00.0", "ERROR боль"))
+    )
+    state = seen(tmp_path)
+    state.mark_told(digest(state, swept([scan])))
+    late = NOW + KEEP + timedelta(days=1)
+    report = digest(state, swept([scan], at=late))
+    assert len(report.new) == 1
+
+
+def test_a_silent_pass_is_not_worth_the_master(tmp_path):
+    state = seen(tmp_path)
+    assert not digest(state, swept([read_stack("beaver-agent", log())])).worth_telling
+
+
+def test_the_scope_says_how_much_was_looked_at(tmp_path):
+    scans = [
+        read_stack(
+            "beaver-agent", log(line("svc", "2026-09-20T17:40:00.0", "ERROR боль"))
+        ),
+        StackScan(stack="gitea", error="timeout"),
+    ]
+    report = digest(seen(tmp_path), swept(scans, in_scope=2, fleet=53))
+    head = brief(report).splitlines()[1]
+    assert head.startswith(
+        "Область: dell-home, personal-main - прочитано 1 стеков из 2"
+    )
+    assert "во флоте 53" in head
+    assert "хвост 2000 строк на стек: строки с 20.09 17:40 по 20.09 17:40" in head
+    assert "самый короткий хвост у beaver-agent - только с 20.09 17:40" in head
+
+
+def test_a_tail_shorter_than_the_pause_between_passes_is_said_out_loud(tmp_path):
+    state = seen(tmp_path)
+    state.last_pass = NOW - timedelta(hours=3)
+    scan = read_stack(
+        "beaver-agent",
+        log(line("svc", "2026-09-20T17:59:00.0", "ERROR из последней минуты")),
+    )
+    report = digest(state, swept([scan]))
+    assert report.gaps == ("beaver-agent",)
+    assert "часть строк прошла мимо" in brief(report)
+
+
+def test_a_silent_komodo_says_so_instead_of_reporting_clean(tmp_path):
+    down = Sweep(at=NOW, unreachable="ClientError: connection refused")
+    report = digest(seen(tmp_path), down)
+    assert report.worth_telling
+    text = brief(report)
+    assert "Komodo не ответил" in text
+    assert "Нового в этой области нет" not in text
+
+
+def test_a_lasting_outage_is_told_once(tmp_path):
+    down = Sweep(at=NOW, unreachable="ClientError: connection refused")
+    state = seen(tmp_path)
+    state.mark_told(digest(state, down))
+    assert digest(state, down).trouble == ()
+
+
+async def test_the_sweep_lists_every_page_and_skips_other_peoples_machines():
+    pages = [
+        [a_stack(f"s{i}") for i in range(500)],
+        [a_stack("gitea", "personal-main"), a_stack("veris-runner", "veris-main")],
+    ]
+    calls = []
+    komodo = fleet(
+        {
+            "ListStacks": lambda p: pages[p["page"]],
+            "GetStacksSummary": {"total": 502},
+            "GetStackLog": log(),
+        },
+        calls,
+    )
+    out = await sweep_fleet(komodo, now=NOW)
+    asked = [p["stack"] for r, p in calls if r == "GetStackLog"]
+    assert "veris-runner" not in asked
+    assert "gitea" in asked and "s0" in asked
+    assert out.fleet == 502 and out.in_scope == 501
+    assert out.trouble == ()
+    assert all(p.get("timestamps") for r, p in calls if r == "GetStackLog")
+
+
+async def test_the_sweep_shouts_when_the_list_and_the_summary_disagree():
+    komodo = fleet(
+        {
+            "ListStacks": [a_stack("beaver-agent")],
+            "GetStacksSummary": {"total": 53},
+            "GetStackLog": log(),
+        }
+    )
+    out = await sweep_fleet(komodo, now=NOW)
+    assert out.trouble == (
+        "листание дало 1 стеков, а GetStacksSummary - 53: список неполон",
+    )
+
+
+async def test_a_stack_that_throws_does_not_end_the_sweep():
+    def logs(params):
+        if params["stack"] == "gitea":
+            msg = "connection reset"
+            raise RuntimeError(msg)
+        return log(line("svc", "2026-09-20T17:40:00.0", "ERROR боль"))
+
+    komodo = fleet(
+        {
+            "ListStacks": [a_stack("beaver-agent"), a_stack("gitea", "personal-main")],
+            "GetStacksSummary": {"total": 2},
+            "GetStackLog": logs,
+        }
+    )
+    out = await sweep_fleet(komodo, now=NOW)
+    assert len(out.read) == 1
+    assert out.trouble == ("gitea: RuntimeError: connection reset",)
+
+
+async def test_a_dead_komodo_makes_a_sweep_that_admits_it():
+    class Dead(Komodo):
+        async def read(self, request, params):
+            msg = "connection refused"
+            raise OSError(msg)
+
+    out = await sweep_fleet(Dead(url="u", key="k", secret="s"), now=NOW)
+    assert out.read == ()
+    assert out.unreachable == "OSError: connection refused"
+    assert out.trouble == ("Komodo не ответил: OSError: connection refused",)
+
+
+def test_a_line_without_a_stamp_is_not_a_find():
+    # Голову хвоста Komodo обрезает по месту: полстроки - не новая беда.
+    scan = read_stack(
+        "democalc",
+        log(
+            "49.260 UTC [8772] ERROR:  relation does not exist",
+            line("postgres-1", "2026-09-20T17:40:00.0", "ERROR: настоящая"),
+        ),
+    )
+    assert [h.sample for h in scan.hits] == ["ERROR: настоящая"]
+    assert scan.unparsed == 1 and scan.lines == 1
+
+
+def test_many_unreadable_lines_are_said_out_loud(tmp_path):
+    scan = StackScan(stack="beaver-agent", lines=5, unparsed=40)
+    head = brief(digest(seen(tmp_path), swept([scan]))).splitlines()[1]
+    assert "строк без метки времени пропущено 40" in head
+
+
+def test_an_empty_line_is_a_line_not_a_blind_spot():
+    scan = read_stack("dell-home-dawarich", log("app-1  | 2026-09-17T14:37:38.510Z"))
+    assert scan.unparsed == 0 and scan.lines == 1 and scan.hits == ()
+
+
+def test_a_stack_read_for_the_first_time_does_not_dump_its_past(tmp_path):
+    state = seen(tmp_path)
+    scan = read_stack(
+        "lodge", log(line("svc", "2026-09-19T10:00:00.0", "ERROR старое, до нас"))
+    )
+    report = digest(state, swept([scan]))
+    assert report.new == ()
+    assert report.baselined == ("lodge",) and report.baseline == 1
+    assert "Впервые прочитаны" in brief(report)
+
+    later = read_stack(
+        "lodge",
+        log(
+            line("svc", "2026-09-19T10:00:00.0", "ERROR старое, до нас"),
+            line("svc", "2026-09-20T19:00:00.0", "ERROR уже при нас"),
+        ),
+    )
+    after = digest(state, swept([later], at=NOW + timedelta(hours=3)))
+    assert [e.sample for e in after.new] == ["ERROR уже при нас"]
+
+
+def test_a_first_pass_into_a_dead_komodo_does_not_burn_the_baseline(tmp_path):
+    state = seen(tmp_path, fresh=True)
+    down = Sweep(at=NOW, unreachable="OSError: connection refused")
+    report = digest(state, down)
+    assert not report.cold and state.fresh
+    assert report.trouble == ("Komodo не ответил: OSError: connection refused",)
+
+    scan = read_stack(
+        "beaver-agent", log(line("svc", "2026-09-20T17:40:00.0", "ERROR боль"))
+    )
+    later = digest(state, swept([scan], at=NOW + timedelta(hours=3)))
+    assert later.cold and later.new == ()
+
+
+def test_a_named_secret_in_the_line_does_not_ride_into_the_chat():
+    scan = read_stack(
+        "gitea",
+        log(line("svc", "2026-09-20T17:40:00.0", "ERROR auth failed token=ghp_ZZ123")),
+    )
+    (hit,) = scan.hits
+    assert "ghp_ZZ123" not in hit.sample
+    assert hit.sample.startswith("ERROR auth failed token=")
+
+
+def test_a_bare_blob_stays_readable():
+    # Размен с открытыми глазами: id задач, сессий и коммитов - это сигнал,
+    # и замазывать их ради редкого безымянного ключа дороже, чем оставить.
+    scan = read_stack(
+        "komodo",
+        log(line("svc", "2026-09-20T17:40:00.0", "ERROR task kJ8sdfLKJ23kjhsdf98234x")),
+    )
+    (hit,) = scan.hits
+    assert "kJ8sdfLKJ23kjhsdf98234x" in hit.sample
+
+
+def stamps(day, hour, count, start=0):
+    return [
+        f"2026-09-{day:02d}T{hour:02d}:{m:02d}:00.0"
+        for m in range(start, start + count)
+    ]
+
+
+def burst(stack, times, text="ERROR всё та же беда", service="svc"):
+    """Хвост стека, где одна и та же беда повторилась в перечисленные минуты."""
+    return read_stack(stack, log(*(line(service, t, text) for t in times)))
+
+
+def at(day, hour, minute=0):
+    return datetime(2026, 9, day, hour, minute, tzinfo=UTC)
+
+
+def told(state, report):
+    state.mark_told(report)
+    return report
+
+
+def test_a_continuing_trouble_is_told_once_and_then_keeps_quiet(tmp_path):
+    state = seen(tmp_path)
+    first = told(
+        state, digest(state, swept([burst("gitea", stamps(20, 9, 3))], at=at(20, 10)))
+    )
+    assert len(first.new) == 1
+
+    # Хвост перечитан: те же строки плюс свежие - беда идёт, но новостью не стала.
+    later = digest(
+        state,
+        swept([burst("gitea", stamps(20, 9, 3) + stamps(20, 12, 4))], at=at(20, 13)),
+    )
+    assert later.new == () and later.surge == () and later.quiet == ()
+    assert not later.worth_telling
+    assert later.ongoing == ()  # за прошлые сутки её ещё не было
+
+
+def test_the_reread_tail_does_not_inflate_the_count(tmp_path):
+    state = seen(tmp_path)
+    told(state, digest(state, swept([burst("gitea", stamps(20, 9, 3))], at=at(20, 10))))
+    for hour in (13, 16, 19):
+        digest(state, swept([burst("gitea", stamps(20, 9, 3))], at=at(20, hour)))
+    (entry,) = state.entries.values()
+    assert entry.count == 3  # три повтора, а не три на каждый из четырёх проходов
+    assert entry.passes == 1
+
+
+def test_a_continuing_trouble_comes_back_in_the_daily_summary(tmp_path):
+    state = seen(tmp_path)
+    told(state, digest(state, swept([burst("gitea", stamps(20, 9, 5))], at=at(20, 10))))
+
+    # Первый проход следующих суток - 01:40, он же несёт сводку.
+    night = digest(
+        state,
+        swept([burst("gitea", stamps(20, 9, 5) + stamps(21, 1, 2))], at=at(21, 1, 40)),
+    )
+    assert night.summary and len(night.ongoing) == 1
+    assert night.new == () and not night.worth_telling
+    text = daily(night, UTC)
+    assert "сводка за 2026-09-20" in text  # числа - про закрывшиеся сутки
+    assert "gitea/svc ошибка, с 20.09 09:00, за сутки 5, первые сутки" in text
+    assert "ERROR" not in text  # образцов строк в сводке нет намеренно
+    told(state, night)
+    state.mark_daily(night)
+
+    # Тот же день, следующий проход: сводку уже отдали.
+    again = digest(
+        state,
+        swept([burst("gitea", stamps(20, 9, 5) + stamps(21, 1, 2))], at=at(21, 4, 40)),
+    )
+    assert again.ongoing and not again.summary
+
+
+def test_the_summary_says_which_way_it_is_going(tmp_path):
+    state = seen(tmp_path)
+    told(state, digest(state, swept([burst("gitea", stamps(20, 9, 2))], at=at(20, 10))))
+    day_two = swept(
+        [burst("gitea", stamps(20, 9, 2) + stamps(21, 9, 8))], at=at(21, 10)
+    )
+    told(state, digest(state, day_two))
+    third = digest(
+        state,
+        swept(
+            [burst("gitea", stamps(20, 9, 2) + stamps(21, 9, 8) + stamps(22, 1, 1))],
+            at=at(22, 1, 40),
+        ),
+    )
+    assert "за сутки 8, растёт (было 2)" in daily(third, UTC)
+
+
+def test_a_surge_of_the_familiar_breaks_the_silence(tmp_path):
+    state = seen(tmp_path)
+    state_report = digest(
+        state, swept([burst("gitea", stamps(20, 9, 1))], at=at(20, 10))
+    )
+    told(state, state_report)
+    for hour, minute in ((13, 12), (16, 15)):
+        digest(
+            state,
+            swept([burst("gitea", stamps(20, hour - 1, 1, minute))], at=at(20, hour)),
+        )
+    (entry,) = state.entries.values()
+    assert entry.passes == 3 and entry.norm == 1.0
+
+    spike = digest(state, swept([burst("gitea", stamps(20, 18, 12))], at=at(20, 19)))
+    (item,) = spike.surge
+    assert item.gain == 12 and item.norm == 1.0
+    assert spike.new == () and spike.worth_telling
+    text = brief(spike)
+    assert "Всплеск знакомого (1)" in text
+    assert "×12 за проход при норме ×1.0" in text
+    assert "Нового в этой области нет" not in text
+
+    # Второй такой же проход внутри выдержки молчит: это уже не новость.
+    told(state, spike)
+    more = digest(state, swept([burst("gitea", stamps(20, 21, 12))], at=at(20, 22)))
+    assert more.surge == () and not more.worth_telling
+
+
+def test_a_small_jump_is_not_a_surge(tmp_path):
+    state = seen(tmp_path)
+    told(state, digest(state, swept([burst("gitea", stamps(20, 9, 1))], at=at(20, 10))))
+    for hour in (13, 16):
+        digest(
+            state,
+            swept([burst("gitea", stamps(20, hour - 1, 1, hour))], at=at(20, hour)),
+        )
+    # Вчетверо больше, но всего четыре штуки: пол в SURGE_MIN держит тишину.
+    small = digest(state, swept([burst("gitea", stamps(20, 18, 4))], at=at(20, 19)))
+    assert small.surge == () and not small.worth_telling
+
+
+def test_a_trouble_gone_silent_is_reported_even_while_its_line_lingers(tmp_path):
+    state = seen(tmp_path)
+    tail = burst("gitea", stamps(20, 9, 2))
+    told(state, digest(state, swept([tail], at=at(20, 10))))
+
+    # Сутки та же строка лежит в хвосте, новых событий нет.
+    assert not digest(state, swept([tail], at=at(20, 22))).quiet
+    stopped = digest(state, swept([tail], at=at(21, 12)))
+    (gone,) = stopped.quiet
+    assert gone.last == at(20, 9, 1)
+    assert "последнее в 20.09 09:01" in brief(stopped)
+
+    told(state, stopped)
+    assert digest(state, swept([tail], at=at(21, 16))).quiet == ()
+
+
+def test_a_trouble_that_returns_after_the_all_clear_is_new_again(tmp_path):
+    state = seen(tmp_path)
+    tail = burst("gitea", stamps(20, 9, 2))
+    told(state, digest(state, swept([tail], at=at(20, 10))))
+    told(state, digest(state, swept([tail], at=at(21, 12))))  # стихла
+
+    back = digest(
+        state,
+        swept([burst("gitea", stamps(20, 9, 2) + stamps(21, 18, 3))], at=at(21, 19)),
+    )
+    assert len(back.new) == 1 and back.worth_telling
+
+
+def test_the_background_of_the_baseline_never_claims_to_have_stopped(tmp_path):
+    # Про фон, принятый в базовую линию, мастер не слышал - «стихло» про него врёт.
+    state = seen(tmp_path, known=())
+    state.fresh = False
+    cold = digest(state, swept([burst("lodge", stamps(20, 9, 2))], at=at(20, 10)))
+    assert cold.new == () and cold.baseline == 1
+    gone = digest(state, swept([read_stack("lodge", log())], at=at(20, 13)))
+    assert gone.quiet == () and not gone.worth_telling
+
+
+def test_the_summary_folds_the_variants_of_one_service_into_one_row(tmp_path):
+    state = seen(tmp_path)
+    # Разные по смыслу строки: отличие в одних цифрах - это одна и та же беда.
+    variants = [
+        burst("gitea", stamps(20, 9, 4), text=f"ERROR {what}")
+        for what in ("push отклонён", "миграция не прошла", "ssh-ключ отвергнут")
+    ]
+    told(state, digest(state, swept(variants, at=at(20, 10))))
+    night = digest(state, swept(variants, at=at(21, 1, 40)))
+    (row,) = grouped(night.ongoing)
+    assert row.kinds == 3 and row.day_before == 12
+    text = daily(night, UTC)
+    assert "Идёт до сих пор: 1 рядов (3 разных строк)" in text
+    assert "gitea/svc ошибка, строк 3 видов, с 20.09 09:00, за сутки 12" in text
+
+
+def test_the_daily_summary_arrives_even_when_all_is_quiet(tmp_path):
+    # Мёртвый джоб и чистый флот должны выглядеть по-разному.
+    state = seen(tmp_path)
+    for hour in (10, 13, 16, 19, 22):
+        digest(state, swept([read_stack("gitea", log())], at=at(20, hour)))
+    night = digest(state, swept([read_stack("gitea", log())], at=at(21, 1, 40)))
+    assert night.summary and night.ongoing == ()
+    assert not night.worth_telling  # обычного инжекта нет, суточный - есть
+    text = daily(night, UTC)
+    assert text.splitlines() == [
+        "Логи флота: сводка за 2026-09-20.",
+        "Проходов за сутки 5 из 8 ожидавшихся; в последнем прочитано 1 стеков "
+        "из 1 в области (dell-home, personal-main).",
+        "Длящегося нет: всё, о чём я говорил, стихло или не повторялось.",
+    ]
+
+
+def test_the_daily_summary_counts_the_refusals(tmp_path):
+    state = seen(tmp_path)
+    digest(state, swept([StackScan(stack="gitea", error="timeout")], at=at(20, 10)))
+    digest(state, Sweep(at=at(20, 13), unreachable="OSError: нет связи"))
+    night = digest(state, swept([read_stack("gitea", log())], at=at(21, 1, 40)))
+    assert (
+        "Отказов доступа за те сутки: чтений стеков 1, проходов без ответа Komodo 1"
+        in daily(night, UTC)
+    )
+
+
+def test_a_slowly_growing_trouble_still_breaks_through(tmp_path):
+    # Варёная лягушка: норма замерла на молодости беды и за ростом не тянется.
+    state = seen(tmp_path)
+    told(state, digest(state, swept([burst("gitea", stamps(20, 8, 1))], at=at(20, 9))))
+    counts = [1, 1, 2, 3, 4, 6, 9, 13]
+    hour = 10
+    seen_times = stamps(20, 8, 1)
+    surged = []
+    for n in counts:
+        seen_times = seen_times + stamps(20, hour - 1, n, start=10)
+        report = digest(state, swept([burst("gitea", seen_times)], at=at(20, hour)))
+        if report.surge:
+            surged.append((hour, report.surge[0].gain, report.surge[0].norm))
+            told(state, report)
+        hour += 1
+    (entry,) = state.entries.values()
+    assert entry.norm == 1.0  # заморожена по первым трём активным проходам
+    assert surged and surged[0][1] >= SURGE_MIN
+    assert surged[0][2] == 1.0
+
+
+def test_the_ceiling_fires_without_any_relative_norm(tmp_path):
+    # Беда, чья собственная норма уже огромна: относительный порог её не возьмёт.
+    state = seen(tmp_path)
+    times = stamps(20, 8, 40)
+    told(state, digest(state, swept([burst("gitea", times)], at=at(20, 9))))
+    for hour in (12, 15):
+        times = times + stamps(20, hour - 1, 40, start=10)
+        digest(state, swept([burst("gitea", times)], at=at(20, hour)))
+    (entry,) = state.entries.values()
+    assert entry.norm == 40.0
+    huge = stamps(20, 17, 55, start=0)
+    spike = digest(state, swept([burst("gitea", times + huge)], at=at(20, 18)))
+    (item,) = spike.surge
+    assert item.gain == 55  # 55 < 4 × 40, взял потолок, а не кратность
+    assert item.gain < SURGE_FACTOR * item.norm
+    assert item.gain >= SURGE_CEILING
+    assert "Всплеск знакомого (1)" in brief(spike)
+
+
+def test_the_journal_is_appended_and_survives_the_passes(tmp_path):
+    # Состояние - снимок, истории в нём нет: пороги пересматривать по журналу.
+    state = seen(tmp_path)
+    path = tmp_path / "логи-флота.jsonl"
+    times = stamps(20, 8, 2)
+    for i, hour in enumerate((10, 13, 16)):
+        times = times + stamps(20, hour - 1, 2, start=20)
+        report = digest(state, swept([burst("gitea", times)], at=at(20, hour)))
+        told(state, report)
+        note(path, record(report, UTC) | {"pass_of_day": i + 1})
+
+    rows = [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines()]
+    assert len(rows) == 3
+    assert [r["pass_of_day"] for r in rows] == [1, 2, 3]
+    assert rows[0]["stacks"] == 1 and rows[0]["in_scope"] == 1
+    assert rows[0]["new"] == 1 and rows[0]["misses"] == 0
+    (trouble,) = rows[2]["troubles"]
+    assert trouble["where"] == "gitea/svc" and trouble["gain"] == 2
+    assert trouble["total"] == 8 and trouble["day"] == 8
+
+
+def test_the_journal_turns_over_instead_of_growing_forever(tmp_path):
+    path = tmp_path / "логи-флота.jsonl"
+    for i in range(4):
+        note(path, {"n": i, "padding": "x" * 200}, max_bytes=300)
+    fresh = [json.loads(ln) for ln in path.read_text(encoding="utf-8").splitlines()]
+    turned = [
+        json.loads(ln)
+        for ln in path.with_suffix(".jsonl.1").read_text(encoding="utf-8").splitlines()
+    ]
+    assert [r["n"] for r in turned] == [0, 1]  # старое уехало в .1, не пропало
+    assert [r["n"] for r in fresh] == [2, 3]
+
+
+def test_a_storm_of_new_kinds_is_folded_into_one_loud_line(tmp_path):
+    state = seen(tmp_path)
+    flood = [
+        burst("gitea", stamps(20, 9, 1, start=i), text=f"ERROR сбой {chr(1072 + i)}щ")
+        for i in range(MUTE_KINDS + 5)
+    ]
+    report = digest(state, swept(flood, at=at(20, 10)))
+    (storm,) = report.storms
+    assert storm.kinds == MUTE_KINDS + 5 and storm.shown == MUTE_SHOW
+    assert len(report.new) == MUTE_SHOW  # остальное проглочено, но посчитано
+    text = brief(report)
+    assert "глушу" in text
+    assert f"Стек gitea: {MUTE_KINDS + 5} новых ВИДОВ строк за проход" in text
+    assert report.worth_telling
+
+    # Пока не сказали - повторяем; сказали - в суточной сводке.
+    told(state, report)
+    assert state.mutes["gitea"].told
+    assert state.mutes["gitea"].kinds == 5 + MUTE_KINDS - MUTE_SHOW
+
+
+def test_the_muted_stack_is_named_once_a_day_until_it_calms_down(tmp_path):
+    state = seen(tmp_path)
+    flood = [
+        burst("gitea", stamps(20, 9, 1, start=i), text=f"ERROR сбой {chr(1072 + i)}щ")
+        for i in range(MUTE_KINDS + 5)
+    ]
+    told(state, digest(state, swept(flood, at=at(20, 10))))
+    night = digest(state, swept(flood, at=at(21, 1, 40)))
+    assert "Приглушён gitea" in daily(night, UTC)
+    assert "глушу с 20.09 10:00" in daily(night, UTC)
+
+    calm = digest(state, swept([burst("gitea", stamps(21, 9, 2))], at=at(21, 10)))
+    assert calm.unmuted == ("gitea",) and "глушение снял: gitea" in brief(calm)
+    assert "gitea" not in state.mutes
+
+
+def test_the_first_sighting_is_never_a_surge(tmp_path):
+    # В хвосте лежит суточный запас: первый счёт - про длину хвоста, не про беду.
+    state = seen(tmp_path, fresh=True)
+    loud = digest(state, swept([burst("gitea", stamps(20, 9, 55))], at=at(20, 10)))
+    assert loud.surge == () and loud.cold and loud.baseline == 1

tests/test_leisure.py

@@ -1,17 +1,22 @@
 from datetime import datetime
+from pathlib import Path
 from zoneinfo import ZoneInfo
 
 from beaver_agent.jobs.leisure import (
+    EMPTY_DEFAULT,
     MINE_MIN,
     QUIET_TICKS,
     Plan,
     brief,
     day_of,
+    echo,
     enabled,
+    kind_of,
     plan_of,
     quiet_hour,
     tick_hours,
 )
+from beaver_agent.vault import VAULT
 
 ZONE = ZoneInfo("Europe/Warsaw")
 
@@ -121,3 +126,81 @@ def test_last_night_tick_says_nothing_is_left_ahead():
     assert "впереди больше нет" in text
     assert "израсходовано 2 из 2" in text
     assert "Сутки заканчиваются через 6 ч" in text
+
+
+def test_two_of_my_hours_are_empty_named_or_not():
+    named = plan_of(
+        "сутки: 2026-09-08\nмои часы: 13, 15, 18, 21, 00, 02, 06\n"
+        "пустые часы: 21, 02\n",
+        "2026-09-08",
+    )
+    assert named.empty == (21, 2)
+
+    unnamed = plan_of(None, "2026-09-08")
+    assert unnamed.empty == EMPTY_DEFAULT
+    assert set(unnamed.empty) <= set(unnamed.mine)
+
+    foreign = plan_of(
+        "сутки: 2026-09-08\nмои часы: 13, 14, 15, 16, 17, 19, 20\n"
+        "пустые часы: 22, 20\n",
+        "2026-09-08",
+    )
+    assert foreign.empty == (19, 20)
+    assert kind_of(20, foreign) == "empty"
+    assert kind_of(13, foreign) == "mine"
+    assert kind_of(21, foreign) == "mixed"
+
+
+def test_an_empty_hour_carries_no_work_but_an_echo_and_the_files_of_the_day():
+    plan = plan_of(None, "2026-09-08")
+    heard = (VAULT / "мета" / "бобер" / "дневник" / "2026-08-30.md", "Раз.\nДва.")
+    text = brief(at("2026-09-08 18:00"), plan, heard=heard)
+    assert "Тип: пустой - час без дел вообще" in text
+    assert "Пустые: 18, 00." in text
+    assert "Эхо - `мета/бобер/дневник/2026-08-30.md`:\n> Раз.\n> Два.\n" in text
+    assert "Дневник - `мета/бобер/дневник/2026-09-08.md`" in text
+    assert "`мета/бобер/журнал/2026-09-08.md`" in text
+
+    night = brief(at("2026-09-09 00:00"), plan)
+    assert "Тип: пустой" in night
+    assert "мета/бобер/дневник/2026-09-09.md" in night
+    assert "Эхо" not in night
+
+    mine = brief(at("2026-09-08 13:00"), plan)
+    assert "Тип: досуг" in mine
+    assert "мета/бобер/журнал/2026-09-08.md" in mine
+
+
+def test_echo_is_a_paragraph_of_an_old_diary_day_or_a_thought(tmp_path: Path):
+    diary = tmp_path / "дневник"
+    thoughts = tmp_path / "мысли" / "2026"
+    diary.mkdir()
+    thoughts.mkdir(parents=True)
+    old = "Думал про то, зачем мне вообще помнить вчерашний день. " * 5
+    fresh = "Свежая запись, которой ещё рано возвращаться ко мне эхом. " * 5
+    (diary / "2026-08-30.md").write_text(
+        f"## 2026-08-30, 01:07\n\n{old}\n\n- 02:07 30.08 лог, а не мысль {'x' * 220}\n"
+        "\nкоротко\n",
+        encoding="utf-8",
+    )
+    (diary / "2026-09-07.md").write_text(fresh, encoding="utf-8")
+    now = at("2026-09-08 18:00")
+    assert echo(now, diary=diary, thoughts=thoughts) == (
+        diary / "2026-08-30.md",
+        old.strip(),
+    )
+
+    thought = "Заметка Бобра о том, почему скука полезнее расписания. " * 5
+    (diary / "2026-08-30.md").unlink()
+    (thoughts / "скука.md").write_text(
+        f"---\ntags: [мысли]\n---\n\n{thought}\n", encoding="utf-8"
+    )
+    assert echo(now, diary=diary, thoughts=thoughts) == (
+        thoughts / "скука.md",
+        thought.strip(),
+    )
+    assert echo(now, diary=diary, thoughts=thoughts) == echo(
+        now, diary=diary, thoughts=thoughts
+    )
+    (thoughts / "скука.md").unlink()
+    assert echo(now, diary=diary, thoughts=thoughts) is None

tests/test_policy.py

@@ -1,4 +1,6 @@
+import shutil
 import tempfile
+from collections.abc import Iterator
 from pathlib import Path
 
 import pytest
@@ -15,13 +17,16 @@ from beaver_agent.policy import (
 
 
 @pytest.fixture
-def vault() -> Path:
+def vault() -> Iterator[Path]:
     root = Path(tempfile.mkdtemp(prefix="beaver-vault-"))
-    for d in ("мета/бобер", "💬 чаты", "📅 дни", "👤 люди"):
-        (root / d).mkdir(parents=True)
-    (root / "💬 чаты/старый.md").write_text("x")
-    (root / "📅 дни/2026-08-29.md").write_text("x")
-    return root
+    try:
+        for d in ("мета/бобер", "💬 чаты", "📅 дни", "👤 люди"):
+            (root / d).mkdir(parents=True)
+        (root / "💬 чаты/старый.md").write_text("x")
+        (root / "📅 дни/2026-08-29.md").write_text("x")
+        yield root
+    finally:
+        shutil.rmtree(root, ignore_errors=True)
 
 
 @pytest.fixture

tests/test_recall.py

@@ -5,6 +5,7 @@ from beaver_gateway.conversations.texts import UserSaid
 from beaver_gateway.conversations.envelope import RecallContext
 
 from beaver_agent.hands.calendars import Calendars, Event, Feed
+from beaver_agent.memory.curator import new_replies
 from beaver_agent.memory.recall import (
     LABEL,
     Recall,
@@ -167,13 +168,28 @@ def test_reply_log_appends_one_line_per_message_and_strips_seed(tmp_path: Path)
             at=at,
         )
     )
-    text = (tmp_path / "реплики" / "2026-09.md").read_text(encoding="utf-8")
-    assert text.startswith("# реплики Бобра, 2026-09\n")
+    text = (tmp_path / "реплики" / "2026-09-01.md").read_text(encoding="utf-8")
+    assert text.startswith("# реплики Бобра, 2026-09-01\n")
     assert text.endswith(
         "- 2026-09-01 14:04 · мастер · привет ⏎ ты меня любишь\n"
-        "- 2026-09-01 14:04 · ветка «крипто-карта» · сравни Trustee и RedotPay\n"
+        "- 2026-09-01 14:04 · ветка «крипто-карта» (бриф) · "
+        "сравни Trustee и RedotPay\n"
     )
-    assert date.fromisoformat("2026-09-01")  # tz shift stays inside the month here
+    since = datetime(2026, 9, 1, 0, 0, tzinfo=UTC)
+    # пометка брифа не мешает куратору разбирать строку
+    assert new_replies(tmp_path / "реплики", since, "Europe/Warsaw") == [
+        line for line in text.splitlines() if line.startswith("- ")
+    ]
+    late = datetime(2026, 9, 1, 22, 30, tzinfo=UTC)
+    log.write(
+        UserSaid(conversation_id="c1", kind="master", title=None, text="ночь", at=late)
+    )
+    night = (tmp_path / "реплики" / "2026-09-02.md").read_text(encoding="utf-8")
+    assert night.endswith("- 2026-09-02 00:30 · мастер · ночь\n")
+    assert new_replies(tmp_path / "реплики", late, "Europe/Warsaw") == []
+    assert new_replies(
+        tmp_path / "реплики", datetime(2026, 9, 1, 13, tzinfo=UTC), "Europe/Warsaw"
+    ) == ["- 2026-09-02 00:30 · мастер · ночь"]
 
 
 def test_notes_head_picks_sections_for_the_seed(tmp_path: Path) -> None:

tests/test_runs.py

@@ -0,0 +1,592 @@
+from datetime import UTC, datetime, timedelta
+from types import SimpleNamespace
+from typing import Any, cast
+
+import pytest
+
+from beaver_agent.hands.runs import (
+    STREAK,
+    Run,
+    Runs,
+    alarm_text,
+    awake,
+    clear_text,
+    empty_text,
+    first_line,
+    look,
+    mask,
+    quiet_text,
+)
+
+NOW = datetime(2026, 9, 22, 15, 42, tzinfo=UTC)
+BOOM = (
+    "HubError: vibegram 530 bad_json: <!doctype html>\n"
+    "Traceback (most recent call last):\n"
+    '  File "/app/src/beaver_gateway/jobs/scheduler.py", line 170, in _dispatch\n'
+    "HubError: vibegram 530 bad_json"
+)
+
+
+def run(rid, job, status, *, ago, error=None):
+    return Run(
+        id=rid,
+        job=job,
+        status=status,
+        started_at=NOW - timedelta(minutes=ago),
+        error=error if error is not None or status != "failed" else BOOM,
+    )
+
+
+def series(job, statuses, *, step=10, start=1000):
+    """Прогоны джоба от старых к новым: statuses[-1] - последний прогон."""
+    ago = step * len(statuses)
+    out = []
+    for i, status in enumerate(statuses):
+        out.append(run(start + i, job, status, ago=ago - step * i))
+    return out
+
+
+def state(tmp_path, **kw):
+    return Runs(path=tmp_path / "прогоны.json", **kw)
+
+
+def test_three_in_a_row_is_an_alarm(tmp_path):
+    rows = series("вайбграм", ["done", "failed", "failed", "failed"])
+    report = look(state(tmp_path), rows, now=NOW, me="прогоны")
+    assert not report.empty and report.seen == 4
+    (tail,) = report.alarms
+    assert tail.job == "вайбграм" and tail.count == 3
+    assert tail.since == NOW - timedelta(minutes=30)
+    assert not tail.capped
+    text = alarm_text(report)
+    assert "джоб `вайбграм` лежит 30 минут, 3 прогона подряд" in text
+    assert "с 22.09 15:12 UTC" in text
+    # Первая строка ошибки, а не трейсбек
+    assert "HubError: vibegram 530 bad_json" in text
+    assert "Traceback" not in text and "scheduler.py" not in text
+
+
+def test_two_in_a_row_stays_quiet(tmp_path):
+    rows = series("вайбграм", ["done", "failed", "failed"])
+    report = look(state(tmp_path), rows, now=NOW, me="прогоны")
+    assert not report.alarms and not report.clears and not report.empty
+    # Одиночное падение - тем более молчание
+    once = look(state(tmp_path), series("логи", ["failed"]), now=NOW, me="прогоны")
+    assert not once.alarms
+
+
+def test_only_the_tail_counts(tmp_path):
+    # Падало много, но последний прогон прошёл - джоб не лежит
+    rows = series("логи", ["failed", "failed", "failed", "failed", "done"])
+    assert not look(state(tmp_path), rows, now=NOW, me="прогоны").alarms
+
+
+def test_alarm_not_repeated_within_a_day(tmp_path):
+    rows = series("вайбграм", ["done", "failed", "failed", "failed", "failed"])
+    told = state(tmp_path, alerted={"вайбграм": NOW - timedelta(hours=5)})
+    quiet = look(told, rows, now=NOW, me="прогоны")
+    assert not quiet.alarms
+    assert "уже говорили меньше суток назад" in quiet.note
+    older = state(tmp_path, alerted={"вайбграм": NOW - timedelta(hours=25)})
+    assert look(older, rows, now=NOW, me="прогоны").alarms
+
+
+def test_repair_clears_and_resets(tmp_path):
+    rows = series("вайбграм", ["failed", "failed", "failed", "done"])
+    told = state(tmp_path, alerted={"вайбграм": NOW - timedelta(hours=2)})
+    report = look(told, rows, now=NOW, me="прогоны")
+    assert not report.alarms
+    (clear,) = report.clears
+    assert clear.job == "вайбграм" and clear.count == 0 and clear.status == "done"
+    assert "отбой: джоб `вайбграм` снова проходит (done)" in clear_text(report)
+    # Сброс делает джоб; после него тот же вход снова может поднять тревогу
+    del told.alerted["вайбграм"]
+    again = look(told, series("вайбграм", ["failed"] * 3), now=NOW, me="прогоны")
+    assert again.alarms
+
+
+def test_repair_is_told_once_not_every_run(tmp_path):
+    rows = series("вайбграм", ["failed", "failed", "failed", "done"])
+    clean = state(tmp_path)
+    assert not look(clean, rows, now=NOW, me="прогоны").clears
+
+
+def test_flapping_job_is_a_clear_not_an_alarm(tmp_path):
+    # После тревоги джоб моргает: хвост короче порога - он больше не лежит
+    rows = series("вайбграм", ["done", "done", "failed", "failed"])
+    told = state(tmp_path, alerted={"вайбграм": NOW - timedelta(hours=2)})
+    report = look(told, rows, now=NOW, me="прогоны")
+    (clear,) = report.clears
+    assert clear.count == 2
+    assert f"порог {STREAK}" in clear_text(report)
+
+
+def test_streak_running_past_the_window_says_at_least(tmp_path):
+    rows = series("вайбграм", ["failed"] * 144, step=10)
+    report = look(state(tmp_path), rows, now=NOW, me="прогоны")
+    (tail,) = report.alarms
+    assert tail.capped and tail.count == 144
+    text = alarm_text(report)
+    assert "лежит 24 часа и дольше, 144 прогона подряд" in text
+    assert "это всё окно недели, серия началась раньше" in text
+
+
+def test_empty_window_is_its_own_alarm(tmp_path):
+    report = look(state(tmp_path), [], now=NOW, me="прогоны")
+    assert report.empty and not report.alarms and report.seen == 0
+    assert "не отработал ни один джоб" in empty_text(report)
+    assert "планировщике" in empty_text(report)
+    # И повторяется не чаще раза в сутки
+    told = state(tmp_path, empty_alerted=NOW - timedelta(hours=5))
+    assert not look(told, [], now=NOW, me="прогоны").empty
+    stale = state(tmp_path, empty_alerted=NOW - timedelta(hours=25))
+    assert look(stale, [], now=NOW, me="прогоны").empty
+
+
+def test_own_runs_do_not_count_as_life_or_as_illness(tmp_path):
+    mine = series("прогоны", ["failed", "failed", "failed", "done"])
+    report = look(state(tmp_path), mine, now=NOW, me="прогоны")
+    # Свои прогоны в окне есть, чужих нет: это всё равно пустое окно
+    assert report.empty and not report.alarms and report.mine == 4
+    assert "их 4" in empty_text(report)
+
+
+def test_forgotten_job_leaves_the_state_silently(tmp_path):
+    rows = series("логи", ["done", "done"])
+    told = state(
+        tmp_path,
+        alerted={
+            "исчезнувший": NOW - timedelta(days=8),
+            "недавний": NOW - timedelta(hours=3),
+        },
+    )
+    report = look(told, rows, now=NOW, me="прогоны")
+    assert not report.clears  # починки мы не видели, «отбой» врать не о чем
+    assert "исчезнувший" not in told.alerted
+    assert "недавний" in told.alerted
+
+
+def test_several_broken_jobs_come_in_one_alarm(tmp_path):
+    rows = [
+        *series("вайбграм", ["failed"] * 4, start=100),
+        *series("логи", ["failed"] * 3, start=200),
+        *series("досуг", ["done"], start=300),
+    ]
+    report = look(state(tmp_path), rows, now=NOW, me="прогоны")
+    assert len(report.alarms) == 2
+    assert report.alarms[0].job == "вайбграм"  # длиннее серия - выше в тексте
+    assert alarm_text(report).count("\n") == 1
+
+
+def test_first_line_masks_secrets_and_cuts_the_tail():
+    assert first_line(None) == "без текста ошибки"
+    assert first_line("") == "без текста ошибки"
+    # Токен в строке ошибки не уезжает человеку
+    assert "s3cr3tvalue" not in first_line("RuntimeError: MSOS_MCP=s3cr3tvalue died")
+    assert "MSOS_MCP=<…>" in first_line("RuntimeError: MSOS_MCP=s3cr3tvalue died")
+    assert "hunter2" not in first_line("ошибка: password=hunter2")
+    assert "abc123" not in first_line("GET https://hub/api?t=abc123 -> 500")
+    assert "https://hub/api?<…>" in first_line("GET https://hub/api?t=abc123 -> 500")
+    assert "Bearer abcdefghij" not in first_line("Authorization: Bearer abcdefghij")
+    # Длинная строка режется
+    long = first_line("E: " + "x" * 500)
+    assert len(long) == 160 and long.endswith("…")
+    # Имя без запаха секрета остаётся читаемым
+    assert mask("status=530 job=вайбграм") == "status=530 job=вайбграм"
+
+
+def test_state_survives_a_round_trip(tmp_path):
+    saved = state(
+        tmp_path,
+        alerted={"вайбграм": NOW, "логи": NOW - timedelta(hours=3)},
+        empty_alerted=NOW,
+    )
+    saved.save()
+    back = Runs.load(saved.path)
+    assert back.alerted["вайбграм"] == NOW
+    assert back.alerted["логи"] == NOW - timedelta(hours=3)
+    assert back.empty_alerted == NOW
+    assert Runs.load(tmp_path / "нет.json").alerted == {}
+    (tmp_path / "мусор.json").write_text("не json", encoding="utf-8")
+    assert Runs.load(tmp_path / "мусор.json").empty_alerted is None
+
+
+class FakeRun:
+    def __init__(self, database=None, *, name="прогоны", jobs=()):
+        self.job = SimpleNamespace(name=name, cron="27 * * * *")
+        self.conversations = SimpleNamespace(db=database)
+        self.scheduler = SimpleNamespace(
+            jobs=[self.job, *(SimpleNamespace(name=n, cron=c) for n, c in jobs)], tz=UTC
+        )
+        self.spawned = []
+
+    async def spawn_job(self, *, agent, text, title=None):
+        self.spawned.append((agent, title, text))
+        return None
+
+
+async def make_db(tmp_path, rows):
+    from beaver_gateway.storage.db import Database
+    from beaver_gateway.storage.models import JobRunRecord
+
+    database = Database(f"sqlite+aiosqlite:///{tmp_path / 'journal.db'}")
+    await database.create_all()
+    async with database.session() as session:
+        for row in rows:
+            session.add(row)
+        await session.commit()
+    return database
+
+
+def record(job, status, *, ago, error=None):
+    from beaver_gateway.storage.models import JobRunRecord
+
+    started = (datetime.now(UTC) - timedelta(minutes=ago)).replace(tzinfo=None)
+    return JobRunRecord(
+        job=job,
+        trigger="cron",
+        started_at=started,
+        finished_at=started,
+        status=status,
+        error=error if error is not None or status != "failed" else BOOM,
+    )
+
+
+async def test_job_reads_the_real_journal_and_spawns(tmp_path, monkeypatch):
+    from beaver_agent.jobs import runs as job
+
+    monkeypatch.setattr(job, "STATE_FILE", tmp_path / "прогоны.json")
+    database = await make_db(
+        tmp_path,
+        [
+            record("вайбграм", "failed", ago=30),
+            record("вайбграм", "failed", ago=20),
+            record("вайбграм", "failed", ago=10),
+            record("досуг", "done", ago=5),
+            record("прогоны", "done", ago=3),
+            # Одно падение - не серия, сколько бы окно ни было
+            record("логи", "failed", ago=60 * 30),
+        ],
+    )
+    run_ = FakeRun(database)
+
+    await job.watch_runs(cast("Any", run_))
+
+    assert len(run_.spawned) == 1
+    agent, title, text = run_.spawned[0]
+    assert agent == "beaver-triage" and title == "прогоны"
+    assert "джоб `вайбграм` лежит" in text and "3 прогона подряд" in text
+    assert "логи" not in text  # одно падение
+    assert "прогоны" not in text.split("\n")[1]  # сам себя не считает
+    # Тревога записана - следующий прогон в те же сутки молчит
+    assert Runs.load(tmp_path / "прогоны.json").alerted["вайбграм"] is not None
+    await job.watch_runs(cast("Any", run_))
+    assert len(run_.spawned) == 1
+    await database.dispose()
+
+
+async def test_job_says_otboy_when_the_job_recovers(tmp_path, monkeypatch):
+    from beaver_agent.jobs import runs as job
+
+    monkeypatch.setattr(job, "STATE_FILE", tmp_path / "прогоны.json")
+    Runs(
+        path=tmp_path / "прогоны.json",
+        alerted={"вайбграм": datetime.now(UTC) - timedelta(hours=2)},
+    ).save()
+    database = await make_db(
+        tmp_path,
+        [
+            record("вайбграм", "failed", ago=30),
+            record("вайбграм", "failed", ago=20),
+            record("вайбграм", "done", ago=10),
+        ],
+    )
+    run_ = FakeRun(database)
+
+    await job.watch_runs(cast("Any", run_))
+
+    assert len(run_.spawned) == 1
+    _, _, text = run_.spawned[0]
+    assert "отбой: джоб `вайбграм` снова проходит" in text
+    assert 'urgency="normal"' in text  # отбой не будит
+    assert Runs.load(tmp_path / "прогоны.json").alerted == {}
+    # Сброшено - второй «отбой» не уходит
+    await job.watch_runs(cast("Any", run_))
+    assert len(run_.spawned) == 1
+    await database.dispose()
+
+
+async def test_job_alarms_on_an_empty_journal(tmp_path, monkeypatch):
+    from beaver_agent.jobs import runs as job
+
+    monkeypatch.setattr(job, "STATE_FILE", tmp_path / "прогоны.json")
+    database = await make_db(tmp_path, [record("прогоны", "done", ago=5)])
+    run_ = FakeRun(database)
+
+    await job.watch_runs(cast("Any", run_))
+
+    assert len(run_.spawned) == 1
+    _, _, text = run_.spawned[0]
+    assert "нет ни одной записи" in text and "не отработал ни один джоб" in text
+    assert Runs.load(tmp_path / "прогоны.json").empty_alerted is not None
+    await database.dispose()
+
+
+async def test_unreadable_journal_is_not_a_reading(tmp_path, monkeypatch):
+    from beaver_agent.jobs import runs as job
+
+    class Dead:
+        def session(self):
+            msg = "база не отвечает"
+            raise RuntimeError(msg)
+
+    monkeypatch.setattr(job, "STATE_FILE", tmp_path / "прогоны.json")
+    run_ = FakeRun(Dead())
+
+    await job.watch_runs(cast("Any", run_))
+
+    assert not run_.spawned
+    assert not (tmp_path / "прогоны.json").exists()
+
+
+@pytest.mark.parametrize("name", ["прогоны", "иначе-названный"])
+async def test_the_watcher_never_reports_itself(tmp_path, monkeypatch, name):
+    from beaver_agent.jobs import runs as job
+
+    monkeypatch.setattr(job, "STATE_FILE", tmp_path / "прогоны.json")
+    database = await make_db(
+        tmp_path,
+        [
+            record(name, "failed", ago=30),
+            record(name, "failed", ago=20),
+            record(name, "failed", ago=10),
+            record("досуг", "done", ago=5),
+        ],
+    )
+    run_ = FakeRun(database, name=name)
+
+    await job.watch_runs(cast("Any", run_))
+
+    assert not run_.spawned
+    await database.dispose()
+
+
+# --- Окно неделя: суточные джобы тоже набирают серию ---------------------------
+
+
+def test_daily_job_failing_three_days_in_a_row_is_an_alarm(tmp_path):
+    day = 24 * 60
+    rows = [
+        run(1, "закрытие", "done", ago=4 * day - 60),
+        run(2, "закрытие", "failed", ago=3 * day - 60),
+        run(3, "закрытие", "failed", ago=2 * day - 60),
+        run(4, "закрытие", "failed", ago=day - 60),
+    ]
+    report = look(state(tmp_path), rows, now=NOW, me="прогоны")
+    (tail,) = report.alarms
+    assert tail.job == "закрытие" and tail.count == 3 and not tail.capped
+    assert "джоб `закрытие` лежит 2 суток, 3 прогона подряд" in alarm_text(report)
+
+
+async def test_job_reads_a_week_back(tmp_path, monkeypatch):
+    from beaver_agent.jobs import runs as job
+
+    monkeypatch.setattr(job, "STATE_FILE", tmp_path / "прогоны.json")
+    day = 24 * 60
+    database = await make_db(
+        tmp_path,
+        [
+            record("голосовой", "failed", ago=3 * day - 30),
+            record("голосовой", "failed", ago=2 * day - 30),
+            record("голосовой", "failed", ago=day - 30),
+            # Старше недели - в окно не попадает
+            record("память", "failed", ago=9 * day),
+        ],
+    )
+    run_ = FakeRun(database)
+
+    await job.watch_runs(cast("Any", run_))
+
+    (spawned,) = run_.spawned
+    assert "джоб `голосовой` лежит" in spawned[2]
+    assert "память" not in spawned[2]
+    await database.dispose()
+
+
+# --- Давность: джоб перестал запускаться ---------------------------------------
+
+CRONS = {"прогоны": "27 * * * *", "закрытие": "20 4 * * *", "вайбграм": "*/10 * * * *"}
+
+
+def hourly_me(hours=72):
+    """Непрерывная цепочка своих прогонов: планировщик жив всё это время."""
+    return [
+        run(5000 + i, "прогоны", "done", ago=60 * (hours - i) - 15)
+        for i in range(hours)
+    ]
+
+
+def alive(ago=5):
+    return run(9000, "вайбграм", "done", ago=ago)
+
+
+def silent(tmp_path, *, closing_ago_h, mine=None, boot=None, **kw):
+    last = run(1, "закрытие", "done", ago=closing_ago_h * 60)
+    return look(
+        kw.pop("runs", None) or state(tmp_path),
+        [alive(), *(hourly_me() if mine is None else mine)],
+        now=NOW,
+        me="прогоны",
+        crons=kw.pop("crons", CRONS),
+        latest=kw.pop("latest", {"закрытие": last, "вайбграм": alive()}),
+        tz=UTC,
+        boot=boot,
+    )
+
+
+def test_job_silent_longer_than_two_periods_is_its_own_alarm(tmp_path):
+    report = silent(tmp_path, closing_ago_h=50)
+    (quiet,) = report.quiet
+    assert quiet.job == "закрытие" and quiet.period == timedelta(hours=24)
+    assert not report.alarms  # это не «лежит»
+    text = quiet_text(report)
+    assert "джоб `закрытие` не запускался 2 суток при периоде 24 часа" in text
+    assert "лежит" not in text
+
+
+def test_one_missed_fire_is_not_silence(tmp_path):
+    # 40 часов: пропущено одно срабатывание, не два
+    assert not silent(tmp_path, closing_ago_h=40).quiet
+
+
+def test_silence_is_told_once_a_day_and_cleared_by_a_run(tmp_path):
+    told = state(tmp_path, quiet={"закрытие": NOW - timedelta(hours=5)})
+    held = silent(tmp_path, closing_ago_h=50, runs=told)
+    assert not held.quiet
+    assert "о молчании уже говорили меньше суток назад: закрытие" in held.note
+    older = state(tmp_path, quiet={"закрытие": NOW - timedelta(hours=25)})
+    assert silent(tmp_path, closing_ago_h=50, runs=older).quiet
+    # Запуск появился после тревоги - «отбой», а не молчание
+    back = silent(tmp_path, closing_ago_h=1, runs=told)
+    (resumed,) = back.resumed
+    assert resumed.job == "закрытие" and not back.clears
+    assert "отбой: джоб `закрытие` снова запускается (done)" in clear_text(back)
+
+
+def test_downtime_of_the_scheduler_is_not_a_missed_fire(tmp_path):
+    # Гейтвей только что поднялся: после старта срабатывания ещё не было
+    fresh = silent(tmp_path, closing_ago_h=50, boot=NOW - timedelta(minutes=30))
+    assert not fresh.quiet
+    # Сторож сам не бегал сутки (бюджет зажат, некритичное откладывается):
+    # пропуски за это время - общий простой, а не молчание одного джоба
+    gap = [run(1, "прогоны", "done", ago=60 * 30)]
+    assert not silent(tmp_path, closing_ago_h=50, mine=gap).quiet
+    assert awake(gap, now=NOW, step=timedelta(hours=2), boot=None) == NOW
+
+
+def test_short_period_job_uses_the_watchers_resolution(tmp_path):
+    latest = {"закрытие": run(1, "закрытие", "done", ago=60)}
+    # Вайбграм раз в 10 минут, молчит 70 минут: сторож часовой, и такой
+    # пропуск неотличим от его же слепоты между прогонами
+    latest["вайбграм"] = run(2, "вайбграм", "done", ago=70)
+    assert not silent(tmp_path, closing_ago_h=1, latest=latest).quiet
+    latest["вайбграм"] = run(2, "вайбграм", "done", ago=150)
+    (quiet,) = silent(tmp_path, closing_ago_h=1, latest=latest).quiet
+    assert quiet.job == "вайбграм"
+    assert "не запускался 2 часа при периоде 10 минут" in quiet_text(
+        silent(tmp_path, closing_ago_h=1, latest=latest)
+    )
+
+
+def test_job_without_cron_is_not_checked(tmp_path):
+    # deploy - вебхук: крона у него нет, в `crons` он не попадает вовсе
+    latest = {
+        "deploy": run(1, "deploy", "done", ago=60 * 24 * 30),
+        "закрытие": run(2, "закрытие", "done", ago=60),
+    }
+    report = silent(tmp_path, closing_ago_h=1, latest=latest)
+    assert not report.quiet and "deploy" not in report.note
+
+
+def test_job_never_seen_in_the_journal_waits_silently(tmp_path):
+    report = silent(tmp_path, closing_ago_h=0, latest={"вайбграм": alive()})
+    assert not report.quiet and not report.resumed
+    assert "ещё ни разу не запускались: закрытие" in report.note
+
+
+def test_irregular_schedule_is_skipped_and_named(tmp_path):
+    crons = {**CRONS, "куратор": "0 2,8,12,16,20 * * *"}
+    report = silent(tmp_path, closing_ago_h=1, crons=crons, latest={})
+    assert report.unguarded == ("куратор",)
+    assert "давностью не охраняются" in report.note and "куратор" in report.note
+    assert not report.quiet
+
+
+def test_the_watcher_does_not_measure_its_own_silence(tmp_path):
+    latest = {
+        "прогоны": run(1, "прогоны", "done", ago=60 * 24 * 5),
+        "закрытие": run(2, "закрытие", "done", ago=60),
+    }
+    report = silent(tmp_path, closing_ago_h=1, latest=latest)
+    assert not report.quiet
+
+
+def test_job_removed_from_the_schedule_leaves_silence_state(tmp_path):
+    told = state(tmp_path, quiet={"старый": NOW - timedelta(hours=3)})
+    report = silent(tmp_path, closing_ago_h=1, runs=told)
+    assert not report.resumed and "старый" not in told.quiet
+    assert "сняты с давности (нет в расписании): старый" in report.note
+
+
+def test_real_schedule_names_only_the_curator_unguarded(tmp_path):
+    from beaver_agent.jobs import jobs
+
+    crons = {job.name: job.cron for job in jobs if job.cron}
+    report = silent(tmp_path, closing_ago_h=1, crons=crons, latest={})
+    assert report.unguarded == ("куратор",)
+    # Вебхуки в расписание давности не попадают
+    assert {"deploy", "komodo", "t3code"}.isdisjoint(crons)
+
+
+async def test_job_alarms_on_a_silent_job_and_logs_the_unguarded(
+    tmp_path, monkeypatch, caplog
+):
+    from beaver_agent.jobs import runs as job
+
+    monkeypatch.setattr(job, "STATE_FILE", tmp_path / "прогоны.json")
+    monkeypatch.setattr(job, "BOOT", datetime.now(UTC) - timedelta(days=10))
+    database = await make_db(
+        tmp_path,
+        [
+            record("закрытие", "done", ago=60 * 50),
+            *(record("прогоны", "done", ago=60 * h - 15) for h in range(1, 73)),
+            record("вайбграм", "done", ago=5),
+            record("deploy", "done", ago=60 * 24 * 20),
+        ],
+    )
+    run_ = FakeRun(
+        database,
+        jobs=[
+            ("закрытие", "20 4 * * *"),
+            ("вайбграм", "*/10 * * * *"),
+            ("куратор", "0 2,8,12,16,20 * * *"),
+            ("deploy", None),
+            ("новый", "0 3 * * *"),
+        ],
+    )
+
+    with caplog.at_level("INFO", logger=job.__name__):
+        await job.watch_runs(cast("Any", run_))
+
+    (spawned,) = run_.spawned
+    text = spawned[2]
+    assert "ПЕРЕСТАЛИ ЗАПУСКАТЬСЯ" in text
+    assert "джоб `закрытие` не запускался 2 суток при периоде 24 часа" in text
+    assert "deploy" not in text and "новый" not in text
+    assert "давностью не охраняются" in caplog.text and "куратор" in caplog.text
+    assert "ещё ни разу не запускались: новый" in caplog.text
+    assert "закрытие" in Runs.load(tmp_path / "прогоны.json").quiet
+    # В те же сутки не повторяется
+    await job.watch_runs(cast("Any", run_))
+    assert len(run_.spawned) == 1
+    await database.dispose()

tests/test_t3code_job.py

@@ -0,0 +1,33 @@
+from typing import Any
+
+from beaver_agent.jobs.t3code import t3code_event
+
+
+class FakeRun:
+    def __init__(self, payload: dict[str, Any]) -> None:
+        self.payload = payload
+        self.injects: list[tuple[str | None, str, str, str]] = []
+
+    async def inject_into(
+        self, public_id: str | None, text: str, *, urgency: str, origin: str
+    ) -> bool:
+        self.injects.append((public_id, text, urgency, origin))
+        return True
+
+
+async def test_the_event_goes_to_the_conversation_that_dispatched() -> None:
+    run = FakeRun(
+        {
+            "event": "completed",
+            "thread_id": "t1",
+            "title": "lint",
+            "machine": "mac",
+            "project": "beaver",
+            "origin": "conv-7",
+            "text": "done",
+        }
+    )
+    await t3code_event(run)  # ty: ignore[invalid-argument-type]
+    [(target, text, urgency, origin)] = run.injects
+    assert (target, urgency, origin) == ("conv-7", "urgent", "t3code")
+    assert "завершён" in text and "done" in text

tests/test_vibegram.py

@@ -1,10 +1,12 @@
+from urllib.parse import parse_qsl, urlsplit
+
 import pytest
 from beaver_gateway.mcp.types import McpServer
 from beaver_gateway.mcp.wrap import build_python_tool_server
 from fastmcp import Client
 from fastmcp.exceptions import ToolError
 
-from beaver_agent.hands.vibegram import Vibegram, _cards, _event, _work
+from beaver_agent.hands.vibegram import PAGE, PAGES, Vibegram, _cards, _event, _work
 
 
 def test_events_render_and_unknown_kinds_are_skipped():
@@ -64,3 +66,136 @@ async def test_tool_schema_lists_actions_and_needs_text_for_send():
         )
         with pytest.raises(ToolError, match="text"):
             await client.call_tool("vibegram", {"action": "send"})
+
+
+def _raw(eid, kind, body=None):
+    return {
+        "id": eid,
+        "roomId": "r",
+        "nick": "claude-kai",
+        "kind": kind,
+        "payload": {} if body is None else {"body": body},
+        "createdAt": "2026-09-23T05:00:02.000Z",
+    }
+
+
+def _hub(monkeypatch, events):
+    calls = []
+
+    async def call(self, method, path, body):
+        calls.append(path)
+        if path == "/api/room":
+            return {"room": {"id": "r", "name": "kai-rem-watch", "viewToken": "v 1"}}
+        query = dict(parse_qsl(urlsplit(path).query))
+        assert query["view"] == "v 1"  # ключ комнаты уезжает экранированным
+        after = int(query.get("after", 0))
+        return {"events": [e for e in events if e["id"] > after][:PAGE]}
+
+    monkeypatch.setattr(Vibegram, "_call", call)
+    return calls, Vibegram(hub="http://hub", token="t", nick="beaver-test")
+
+
+async def test_window_pages_forward_to_the_end_and_drops_joins(monkeypatch):
+    # 520 событий комнаты - три страницы по 200; join/leave в окно не идут
+    events = [
+        _raw(i, "message" if i % 4 else "agent_leave", f"строка {i}")
+        for i in range(1, 521)
+    ]
+    calls, room = _hub(monkeypatch, events)
+
+    window = await room.window(25)
+
+    assert window.full
+    assert len(window.events) == 25
+    assert window.events[-1].text.endswith("строка 519")
+    assert all("вошёл" not in e.text and "вышел" not in e.text for e in window.events)
+    assert calls.count("/api/room") == 1
+    assert sum(p.startswith("/api/state") for p in calls) == 3
+    assert "view=v%201" in calls[1]
+    assert not any("pending" in p for p in calls)  # курсор сторожу не окно
+
+
+async def test_window_that_ran_out_of_pages_says_it_is_not_full(monkeypatch):
+    events = [_raw(i, "message", f"строка {i}") for i in range(1, 521)]
+    _, room = _hub(monkeypatch, events)
+
+    assert not (await room.window(25, pages=2)).full
+    assert (await room.window(25, pages=3)).full
+
+
+async def test_window_of_an_empty_room_is_full_and_empty(monkeypatch):
+    _, room = _hub(monkeypatch, [])
+    window = await room.window(25)
+    assert window.full and window.events == []
+
+
+async def test_read_since_walks_history_without_touching_the_cursor(monkeypatch):
+    events = [
+        _raw(i, "message" if i % 4 else "agent_join", f"строка {i}")
+        for i in range(1, 12)
+    ]
+    calls, room = _hub(monkeypatch, events)
+
+    out = await room.vibegram("read", since=8)
+
+    assert out.splitlines() == [
+        "#9 [09-23 05:00] claude-kai: строка 9",
+        "#10 [09-23 05:00] claude-kai: строка 10",
+        "#11 [09-23 05:00] claude-kai: строка 11",
+    ]
+    assert not any("pending" in p for p in calls)
+
+
+async def test_read_last_shows_only_the_tail(monkeypatch):
+    events = [_raw(i, "message", f"строка {i}") for i in range(1, 12)]
+    _, room = _hub(monkeypatch, events)
+
+    out = await room.vibegram("read", last=2)
+
+    assert out.splitlines() == [
+        "#10 [09-23 05:00] claude-kai: строка 10",
+        "#11 [09-23 05:00] claude-kai: строка 11",
+    ]
+    with pytest.raises(ValueError, match="last"):
+        await room.vibegram("read", last=0)
+
+
+async def test_read_since_on_a_silent_room_says_history_is_read_out(monkeypatch):
+    _, room = _hub(monkeypatch, [_raw(3, "message", "строка 3")])
+
+    assert await room.vibegram("read", since=3) == (
+        "после #3 сообщений нет (история дочитана)"
+    )
+
+
+async def test_read_since_admits_an_unfinished_window(monkeypatch):
+    events = [_raw(i, "message", f"строка {i}") for i in range(1, PAGES * PAGE + 2)]
+    _, room = _hub(monkeypatch, events)
+
+    out = await room.vibegram("read", since=0)
+
+    assert out.splitlines()[0] == "окно неполное: до конца истории не дочитали"
+
+
+async def test_plain_read_keeps_the_cursor_and_numbers_the_lines(monkeypatch):
+    seen = []
+
+    async def call(self, method, path, body):
+        seen.append(path)
+        return {"events": [_raw(7, "message", "привет")]}
+
+    monkeypatch.setattr(Vibegram, "_call", call)
+    room = Vibegram(hub="http://hub", token="t", nick="beaver-test")
+
+    assert await room.vibegram("read") == "#7 [09-23 05:00] claude-kai: привет"
+    assert seen == ["/api/pending?limit=50"]
+
+
+async def test_tool_schema_exposes_since_and_last():
+    tool = Vibegram(hub="http://127.0.0.1:9", token="t", nick="beaver-test")
+    server = build_python_tool_server(
+        McpServer.python_tool(name="vibegram", tools=[tool.vibegram])
+    )
+    async with Client(server) as client:
+        (spec,) = await client.list_tools()
+        assert {"since", "last"} <= set(spec.inputSchema["properties"])

uv.lock

@@ -3,8 +3,8 @@ revision = 3
 requires-python = ">=3.13"
 resolution-markers = [
     "python_full_version >= '3.14' and extra != 'extra-12-beaver-agent-local' and extra == 'extra-12-beaver-agent-prod'",
-    "python_full_version < '3.14' and extra != 'extra-12-beaver-agent-local' and extra == 'extra-12-beaver-agent-prod'",
     "python_full_version >= '3.14' and extra == 'extra-12-beaver-agent-local' and extra != 'extra-12-beaver-agent-prod'",
+    "python_full_version < '3.14' and extra != 'extra-12-beaver-agent-local' and extra == 'extra-12-beaver-agent-prod'",
     "python_full_version < '3.14' and extra == 'extra-12-beaver-agent-local' and extra != 'extra-12-beaver-agent-prod'",
     "extra != 'extra-12-beaver-agent-local' and extra != 'extra-12-beaver-agent-prod'",
 ]
@@ -365,6 +365,7 @@ dependencies = [
     { name = "argon2-cffi" },
     { name = "claude-agent-sdk" },
     { name = "croniter" },
+    { name = "cryptography" },
     { name = "fastapi" },
     { name = "fastmcp" },
     { name = "greenlet" },
@@ -390,8 +391,9 @@ requires-dist = [
     { name = "anthropic", specifier = ">=0.103.0" },
     { name = "anyio", specifier = ">=4.13.0" },
     { name = "argon2-cffi", specifier = ">=25.1.0" },
-    { name = "claude-agent-sdk", specifier = ">=0.2.150" },
+    { name = "claude-agent-sdk", specifier = ">=0.2.157" },
     { name = "croniter", specifier = ">=6.2.4" },
+    { name = "cryptography", specifier = ">=48.0.0" },
     { name = "fastapi", specifier = ">=0.136.1" },
     { name = "fastmcp", specifier = ">=3.3.1" },
     { name = "greenlet", specifier = ">=3.5.0" },
@@ -502,7 +504,7 @@ wheels = [
 
 [[package]]
 name = "claude-agent-sdk"
-version = "0.2.150"
+version = "0.2.157"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
@@ -510,13 +512,12 @@ dependencies = [
     { name = "mcp" },
     { name = "sniffio" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/1e/99bababecf24a4a55a0775665ff0be010aff26f653fc9be2f4f17a0b5ef0/claude_agent_sdk-0.2.150.tar.gz", hash = "sha256:3856e932f8d45514ddf5ddd540fb844678bb11638cabf9b939ce8b708e4eb352", size = 344692, upload-time = "2026-09-01T18:07:15.284Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b4/e3/444df1691c864a8349067686719b43e714fc43d3853fb1b2ebc2097e2a6e/claude_agent_sdk-0.2.157.tar.gz", hash = "sha256:4ce6f41bc965fcb4a9d11bd7a3cac266975c75b632f3d74a26f55f0fffb3160a", size = 346579, upload-time = "2026-09-18T18:21:10.306Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c3/13/b5b86d90c95e8a691143eeb45bbf2e1c250324817980464d6ea63ef0f789/claude_agent_sdk-0.2.150-py3-none-macosx_11_0_arm64.whl", hash = "sha256:8f58d746f3552faeac52883b5a502a8d9b5aef067ea0b68fae5c9bae0f39d73d", size = 85396845, upload-time = "2026-09-01T18:07:19.074Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/8f/c17da4fa9cd8bddb8ac1538456dd0fde3a43abb1dfc28ca448f85e2a10d3/claude_agent_sdk-0.2.150-py3-none-macosx_11_0_x86_64.whl", hash = "sha256:fee3ae2dd457742d82070b5fa122070ee8e2e80b4f9b37a57ff0a8261ade656d", size = 89904483, upload-time = "2026-09-01T18:07:22.671Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/95/5b33717b807c6fbe29fca55a246eab9a09a80c9dd288ffeb31f05681b7fc/claude_agent_sdk-0.2.150-py3-none-manylinux_2_17_aarch64.whl", hash = "sha256:813535a0267271d91af29c456ec26137b34a8b7bc066647ea59efba6e3c26c93", size = 95270310, upload-time = "2026-09-01T18:07:26.61Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/de/5a8b59e6a713ea3f4be88816cfd487b1a5b08c8ad9f042abe56d2decc184/claude_agent_sdk-0.2.150-py3-none-manylinux_2_17_x86_64.whl", hash = "sha256:cb65ff33060baa098b420232c630fa287d0f95e9469e7ceb706d0b7d8841888e", size = 95460277, upload-time = "2026-09-01T18:07:31.092Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/42/d147578a0df16c1b4b0deaebfb3d25e590ad5c16cb6b59a68f9dbb618be3/claude_agent_sdk-0.2.150-py3-none-win_amd64.whl", hash = "sha256:3b517a21c723854de778b38fa51660c5b68ee5fb6f28b2abf291a51471a7b378", size = 98078644, upload-time = "2026-09-01T18:07:35.734Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/e8/3e9cc23eb5a5a01a0e2ee931a17db2785f95407525d50366af06a4a5469c/claude_agent_sdk-0.2.157-py3-none-macosx_11_0_arm64.whl", hash = "sha256:dd6a2c7aa1901e43b827411d62f2327aed82f53ed8ca6b076eaa5be4a1fc681f", size = 92744001, upload-time = "2026-09-18T18:21:15.969Z" },
+    { url = "https://files.pythonhosted.org/packages/49/eb/e5095703a8efbe504ec468cab039543caabfc0ea3327c735a3d1b60e57ac/claude_agent_sdk-0.2.157-py3-none-macosx_11_0_x86_64.whl", hash = "sha256:ebf3f514c61db9be01bbf6d1acb0d993247340583b3559d2df75e3822f618bbb", size = 97352326, upload-time = "2026-09-18T18:21:21.007Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f4/64505beb3c757b863753d6556539554704ec9168cb96454dc6463b14df85/claude_agent_sdk-0.2.157-py3-none-manylinux_2_17_aarch64.whl", hash = "sha256:a58089e0c11364db2ec7a139e09b36a4fb9c95817a758bee7b28e0434f55c0b6", size = 102701030, upload-time = "2026-09-18T18:21:27.065Z" },
+    { url = "https://files.pythonhosted.org/packages/03/8f/2a7c121469fd16d1d6465bec180726c54f6e151b12e50835283b4285d1ce/claude_agent_sdk-0.2.157-py3-none-manylinux_2_17_x86_64.whl", hash = "sha256:bd126b2edee3a247b2c7c4cee1f5a3ea68ef748288ec0650db88dd3918e5471a", size = 102830653, upload-time = "2026-09-18T18:21:32.948Z" },
 ]
 
 [[package]]