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
@@ -62,6 +76,9 @@ FIREFLY_PAT=
 # Календари: name=url,name=url (пусто - без календарей).
 # В url лежит приватный ical-фид (google `/private-<токен>/`, usos `key=`) -
 # это секрет: утёк url = утёк календарь, лечится перевыпуском фида.
+# Модели календари даются MCP-руками, а справка конверта раз в день читает
+# тот же ical напрямую - урл фида она берёт из параметра `icsUrl` этих же
+# записей; записи без `icsUrl` остаются рукой, но в справку не попадают.
 CALENDAR_MCPS=
 # MCP beavergram (telegram-history)
 BEAVERGRAM_MCP=
@@ -73,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=
+T3_DELL_DEV_TOKEN=
-# tailnet-адрес самого dell: контейнер t3code-mcp иначе резолвит `dell` в 127.0.1.1
+# tailnet-адрес dell-dev (дев-VM на делле), прописывается контейнеру в hosts
-T3_DELL_ADDR=
+T3_DELL_DEV_ADDR=
 # Токен gateway со scope `api` (admin → Tokens) - им t3code-mcp шлёт события в /hooks/t3code
 T3CODE_MCP_GATEWAY_TOKEN=
 # Ветка/тег t3code-mcp, из которого собирается образ
@@ -111,6 +128,17 @@ VIBEGRAM_REPO=
 # Токен GitHub с доступом к репе (приватная); пусто - публичная
 VIBEGRAM_REPO_TOKEN=
 
+VIBEGRAM_HB_TOKEN=
+VIBEGRAM_HB_NICK=
+
+### Досуг (ежечасный тик мастера, с S13) ######################################
+
+# Час активного окна (12:00-03:59) и четыре часа тихого (04:00-11:59) будят
+# мастера инжектом без задания. Повседневный выключатель - строка `досуг: выкл`
+# в `мета/бобер/досуг.md`; здесь - рубильник: `off` снимает джоб совсем.
+# Пусто = включено.
+LEISURE=
+
 ### Порты хоста и внешний адрес ###############################################
 
 PORT_GATEWAY=62990

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.
@@ -163,6 +169,209 @@ pieces live in `beaver_agent/`, one concern per module:
   and seeds, the vault watcher, the curator briefing
 - `jobs/` - crons and webhooks, one file per job
 
+## Leisure: the hourly tick (`beaver_agent/jobs/leisure.py`)
+
+The master gets an inject with no task in it every hour: what time it is,
+what kind of hour this is, and what is left of the day's plan. The active
+window (12:00-03:59) ticks every hour; the quiet one (04:00-11:59, the hours
+the owner has never once written in) ticks only in the four hours the plan
+names - twenty ticks a day.
+
+The day runs noon to noon and the first tick of it is the planning one: the
+model lays the remaining hours out into *mine* (leisure only, the owner's
+business stays out) and *mixed*, and writes them to `мета/бобер/досуг.md`:
+
+```markdown
+досуг: вкл
+сутки: 2026-09-08
+тихие часы: 04, 06, 08, 10
+мои часы: 13, 15, 18, 21, 00, 02, 06
+```
+
+**The model writes that file, the job only reads it**, so they cannot
+overwrite each other; how many leisure slots are spent follows from the plan
+and the clock, so there is no state to keep. No plan for the day (a restart,
+a fresh day, a broken file) is not an error: the job falls back to defaults
+and says so in the inject. Fewer than seven leisure hours in the plan are
+topped up to seven by the job - the guarantee is the mechanism's, not the
+model's.
+
+A tick lands as `wake` and starts a turn once the master is idle; a busy
+master or a message less than five minutes old moves it five minutes on,
+up to three times, so it never cuts into a live exchange. If a `schedule`
+inject of the model's own is due later in the same hour, the tick goes in
+as `normal` instead and rides into that turn with it - one turn, both
+reasons, neither swallowed. The cron sits at `:07`, not `:00`, because
+rotation is on the hour and a tick waiting in the queue counts as a busy
+master.
+
+Nothing of this reaches Telegram by itself: a turn started by an inject
+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

@@ -21,10 +21,14 @@ from beaver_agent.policy import (
     vault_zones,
 )
 from beaver_agent.vault import TZ, VAULT
+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 - дом."""
@@ -34,8 +38,10 @@ def dispatcher(name: str, model: str, effort: str) -> ClaudeAgent:
         cwd=VAULT,
         prompts=prompts.DISPATCHER,
         skill_sets=skills.DISPATCHER,
-        gateway_tools=("read_conversation", "spawn", "say", "schedule"),
+        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",)),
@@ -53,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,
     )
@@ -68,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,
         ),
@@ -85,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,
         ),
@@ -106,6 +116,17 @@ def triage(name: str, model: str, effort: str) -> ClaudeAgent:
     )
 
 
+def voice(name: str, model: str) -> ClaudeAgent:
+    """Колонки по квартире: чужие люди, поэтому ни vault, ни инструментов."""
+    return ClaudeAgent(
+        name=name,
+        model=model,
+        cwd=Path("/tmp"),  # noqa: S108
+        prompts=prompts.VOICE_AGENT,
+        options=ClaudeOptions(tools=(), disallowed_tools=TRIAGE_DISALLOWED),
+    )
+
+
 def raycast(name: str, model: str, effort: str) -> RaycastAgent:
     """Быстрые ответы через Raycast: веб и чтение страниц, vault через obsidian-fs."""
     return RaycastAgent(
@@ -122,15 +143,16 @@ def raycast(name: str, model: str, effort: str) -> RaycastAgent:
 
 
 agents: list[BaseAgent] = [
-    dispatcher("beaver-dispatcher", "claude-opus-5", "high"),
+    dispatcher("beaver-dispatcher", "claude-opus-5-5", "high"),
-    deep("beaver-opus-high", "claude-opus-5", "high"),
+    deep("beaver-opus-high", "claude-opus-5-5", "high"),
-    deep("beaver-opus-medium", "claude-opus-5", "medium"),
+    deep("beaver-opus-medium", "claude-opus-5-5", "medium"),
-    deep("beaver-opus-xhigh", "claude-opus-5", "xhigh"),
+    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"),
+    distiller("beaver-distiller", "claude-opus-5-5", "medium"),
-    curator("beaver-curator", "claude-opus-5", "high"),
+    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"),
     raycast("beaver-gemini-pro-low", "google-gemini-3.1-pro", "low"),
     raycast("beaver-gemini-flash-high", "google-gemini-3.5-flash", "high"),

beaver_agent/frontends.py

@@ -16,6 +16,8 @@ from beaver_gateway.frontends.turn_record import slugify
 
 from beaver_agent import texts
 from beaver_agent.vault import ATTACHMENTS, BEAVER, CHATS, TZ, VAULT
+from beaver_agent.voice import AGENT as VOICE
+from beaver_agent.voice import VoiceFrontend
 
 if TYPE_CHECKING:
     from pathlib import Path
@@ -62,4 +64,5 @@ frontends: list[Frontend] = [
     MarkdownFrontend(
         vault_path=CHATS, default_agent=DEEP, log_all_chats=True, chat_path=chat_path
     ),
+    VoiceFrontend(agent=VOICE),
 ]

beaver_agent/hands/__init__.py

@@ -6,19 +6,21 @@
 
 from __future__ import annotations
 
+import logging
 import os
 from pathlib import Path
 
 from beaver_gateway.agents.base import ExposedMcp
 from beaver_gateway.mcp.types import McpServer, McpServerT
 
-from beaver_agent.hands.calendars import calendars
+from beaver_agent.hands.calendars import Calendars, calendars, feeds
 from beaver_agent.hands.homeassistant import HomeAssistant
 from beaver_agent.hands.komodo import Komodo
 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",
@@ -52,6 +54,10 @@ telegram = (
 calendar_servers = calendars(env("CALENDAR_MCPS", ""))
 calendar_exposed = tuple(ExposedMcp(name=m.name) for m in calendar_servers)
 
+CALENDAR_FEEDS = feeds(env("CALENDAR_MCPS", ""))
+CALENDARS = Calendars(CALENDAR_FEEDS, tz=TZ) if CALENDAR_FEEDS else None
+"""Те же фиды, но напрямую: ближайшие события едут в справку без модели."""
+
 KOMODO = (
     Komodo(
         url=os.environ["KOMODO_URL"],
@@ -94,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/calendars.py

@@ -1,9 +1,70 @@
-"""Календари из `CALENDAR_MCPS=name=url,name=url`; в url - приватный фид с токеном."""
+"""Календари: MCP-руки для модели и тот же ical-фид, читаемый gateway напрямую.
+
+`CALENDAR_MCPS=name=url,name=url`; в url - приватный фид с токеном, и там же,
+параметром `icsUrl`, лежит сам ical. Модель ходит в календари через MCP, а
+справка конверта читает фид сама: канал, о котором никто не спрашивает, молчит
+незаметно - так экзаменационная сессия и пролежала невидимой.
+
+Парсер здесь свой и маленький: в образе gateway ical-библиотеки нет, а нужно
+немного - когда начинается, как называется, где. Повторы разворачиваются по
+FREQ=DAILY/WEEKLY/MONTHLY/YEARLY с INTERVAL, BYDAY, BYMONTH, COUNT и UNTIL;
+EXDATE и перенесённые экземпляры (RECURRENCE-ID) вычитаются. Шаг считается по
+настенным часам события, а не в абсолютном времени: еженедельная встреча
+переживает перевод часов. Событие, порождённое ежедневным правилом, помечается
+`routine`: в справке такие едут одной строкой, чтобы не вытеснять разовые.
+"""
 
 from __future__ import annotations
 
+import logging
+import re
+import urllib.error
+import urllib.request
+from calendar import monthrange
+from dataclasses import dataclass, field
+from datetime import UTC, date, datetime, timedelta
+from typing import TYPE_CHECKING
+from urllib.parse import parse_qs, urlsplit
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+
 from beaver_gateway.mcp.types import HttpMcp, McpServer
 
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+    from datetime import tzinfo
+
+__all__ = [
+    "Calendars",
+    "Event",
+    "Feed",
+    "Upcoming",
+    "calendars",
+    "feeds",
+    "is_routine",
+    "short",
+]
+
+_log = logging.getLogger(__name__)
+
+USER_AGENT = "beaver-gateway (ical)"
+MAX_BYTES = 4_000_000
+"""Больше четырёх мегабайт фида - это уже не календарь, а чей-то экспорт всего."""
+STEPS_CAP = 20_000
+"""Потолок шагов разворачивания одного повтора: страховка от вечного цикла."""
+PLACE_MAX = 70
+TITLE_MAX = 90
+ERROR_MAX = 90
+NO_TITLE = "(без названия)"
+
+WEEKDAYS = {"MO": 0, "TU": 1, "WE": 2, "TH": 3, "FR": 4, "SA": 5, "SU": 6}
+DT_RE = re.compile(r"^(\d{4})(\d{2})(\d{2})(?:T(\d{2})(\d{2})(\d{2})(Z)?)?$")
+BYDAY_RE = re.compile(r"^([+-]?\d{1,2})?(MO|TU|WE|TH|FR|SA|SU)$")
+ESCAPE_RE = re.compile(r"\\([\\;,nN])")
+PLACE_RE = re.compile(
+    r"^\s*(?:sala|room|зал|аудитория)\b\s*[:.]?\s*(.+)$", re.IGNORECASE | re.MULTILINE
+)
+"""Зал USOS живёт в описании (`Sala: 315`), а LOCATION - это адрес корпуса."""
+
 
 def calendars(raw: str) -> list[HttpMcp]:
     servers: list[HttpMcp] = []
@@ -17,3 +78,457 @@ def calendars(raw: str) -> list[HttpMcp]:
             raise ValueError(msg)
         servers.append(McpServer.http(name=f"calendar-{name.strip()}", url=url.strip()))
     return servers
+
+
+@dataclass(frozen=True, slots=True)
+class Feed:
+    name: str
+    url: str
+    """Ical по подписке: приватный, с токеном внутри - в логи не писать."""
+
+
+def feeds(raw: str) -> tuple[Feed, ...]:
+    """Ical-фиды из тех же записей `CALENDAR_MCPS`: урл лежит в `icsUrl`.
+
+    Запись без ical-урла просто не даёт фида: MCP-рука у модели остаётся,
+    справка про этот календарь молчит - конфигурация, а не отказ канала.
+    """
+    out: list[Feed] = []
+    for raw_entry in raw.split(","):
+        name, sep, url = raw_entry.strip().partition("=")
+        if not sep or not url.strip():
+            continue
+        ics = _ics_url(url.strip())
+        if ics:
+            out.append(Feed(name=name.strip(), url=ics))
+    return tuple(out)
+
+
+def _ics_url(url: str) -> str | None:
+    inner = parse_qs(urlsplit(url).query).get("icsUrl") or []
+    if inner and inner[0].strip():
+        return inner[0].strip()
+    return url if urlsplit(url).path.endswith(".ics") else None
+
+
+@dataclass(frozen=True, slots=True)
+class Event:
+    start: datetime
+    """С зоной: у события своя (TZID), плавающее время читается в зоне агента."""
+    title: str
+    place: str
+    all_day: bool
+    routine: bool = False
+    """Порождено правилом, повторяющимся раз в день или чаще: см. `is_routine`."""
+
+
+@dataclass(frozen=True, slots=True)
+class Upcoming:
+    at: datetime
+    """Момент запроса - его и показывает справка: «данные на …»."""
+    events: tuple[Event, ...] = ()
+    errors: tuple[str, ...] = ()
+    """По строке на фид, который не ответил; пустое окно - это не ошибка."""
+    read: int = 0
+    """Сколько фидов ответило: ноль - показывать нечего, кроме отказа."""
+
+
+@dataclass(frozen=True, slots=True)
+class Calendars:
+    """Ближайшие события всех фидов - одним списком, отсортированным по началу."""
+
+    feeds: tuple[Feed, ...]
+    tz: str = "Europe/Warsaw"
+    timeout: float = 8.0
+    days: int = 7
+
+    def upcoming(self, now: datetime) -> Upcoming:
+        """Окно `days` от `now`; отказ фида - строка в `errors`, не исключение."""
+        zone = ZoneInfo(self.tz)
+        since = now.astimezone(zone)
+        events: list[Event] = []
+        errors: list[str] = []
+        read = 0
+        for feed in self.feeds:
+            try:
+                text = self.fetch(feed.url)
+                found = events_in(text, zone=zone, since=since, days=self.days)
+            except Exception as exc:  # noqa: BLE001
+                _log.warning("календарь %s: %s", feed.name, short(exc), exc_info=True)
+                errors.append(f"{feed.name}: {short(exc)}")
+                continue
+            read += 1
+            events.extend(found)
+        events.sort(key=lambda e: (e.start, e.title))
+        return Upcoming(at=since, events=tuple(events), errors=tuple(errors), read=read)
+
+    def fetch(self, url: str) -> str:
+        if urlsplit(url).scheme not in ("http", "https"):
+            msg = "фид не по http(s)"
+            raise ValueError(msg)
+        request = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})  # noqa: S310
+        with urllib.request.urlopen(request, timeout=self.timeout) as response:  # noqa: S310
+            raw: bytes = response.read(MAX_BYTES)
+        return raw.decode("utf-8", errors="replace")
+
+
+def short(exc: BaseException) -> str:
+    """Причина отказа одной строкой: в конверт едет она, урл фида - никогда."""
+    if isinstance(exc, urllib.error.HTTPError):
+        reason = f"HTTP {exc.code}"
+    elif isinstance(exc, TimeoutError):
+        reason = "таймаут"
+    elif isinstance(exc, urllib.error.URLError):
+        reason = f"сеть: {exc.reason}"
+    else:
+        reason = f"{type(exc).__name__}: {exc}".strip(": ")
+    return " ".join(reason.split())[:ERROR_MAX]
+
+
+@dataclass(frozen=True, slots=True)
+class Prop:
+    value: str
+    params: dict[str, str] = field(default_factory=dict)
+
+
+Vevent = dict[str, list[Prop]]
+
+
+def unfold(text: str) -> list[str]:
+    """Ical-строки, склеенные обратно: продолжение начинается с пробела или таба."""
+    lines: list[str] = []
+    for raw in text.replace("\r\n", "\n").replace("\r", "\n").split("\n"):
+        if lines and raw[:1] in (" ", "\t"):
+            lines[-1] += raw[1:]
+        else:
+            lines.append(raw)
+    return lines
+
+
+def _split(line: str) -> tuple[str, str] | None:
+    """`NAME;PARAM=x:значение` - двоеточие вне кавычек делит имя и значение."""
+    quoted = False
+    for i, char in enumerate(line):
+        if char == '"':
+            quoted = not quoted
+        elif char == ":" and not quoted:
+            return line[:i], line[i + 1 :]
+    return None
+
+
+def _prop(line: str) -> tuple[str, Prop] | None:
+    parts = _split(line)
+    if parts is None:
+        return None
+    head, value = parts
+    chunks = head.split(";")
+    name = chunks[0].strip().upper()
+    if not name:
+        return None
+    params: dict[str, str] = {}
+    for chunk in chunks[1:]:
+        key, sep, raw = chunk.partition("=")
+        if sep:
+            params[key.strip().upper()] = raw.strip().strip('"')
+    return name, Prop(value=value, params=params)
+
+
+def vevents(lines: list[str]) -> list[Vevent]:
+    """Только свойства самих VEVENT: VALARM внутри них пропускается целиком."""
+    out: list[Vevent] = []
+    current: Vevent | None = None
+    depth = 0
+    for line in lines:
+        parsed = _prop(line)
+        if parsed is None:
+            continue
+        name, prop = parsed
+        block = prop.value.strip().upper()
+        if name == "BEGIN":
+            if block == "VEVENT" and current is None:
+                current = {}
+            elif current is not None:
+                depth += 1
+            continue
+        if name == "END":
+            if block == "VEVENT" and current is not None and depth == 0:
+                out.append(current)
+                current = None
+            elif current is not None and depth:
+                depth -= 1
+            continue
+        if current is not None and depth == 0:
+            current.setdefault(name, []).append(prop)
+    return out
+
+
+def unescape(value: str) -> str:
+    return ESCAPE_RE.sub(lambda m: "\n" if m.group(1) in "nN" else m.group(1), value)
+
+
+def _flat(value: str, limit: int) -> str:
+    flat = " ".join(unescape(value).split())
+    return flat if len(flat) <= limit else flat[: limit - 1] + "…"
+
+
+def _first(event: Vevent, name: str) -> Prop | None:
+    props = event.get(name)
+    return props[0] if props else None
+
+
+def _zone_of(prop: Prop, default: tzinfo) -> tzinfo:
+    tzid = prop.params.get("TZID")
+    if not tzid:
+        return default
+    try:
+        return ZoneInfo(tzid)
+    except (ZoneInfoNotFoundError, ValueError):
+        return default
+
+
+def moment(prop: Prop, value: str, zone: tzinfo) -> tuple[datetime, bool] | None:
+    """Значение DTSTART/EXDATE в момент времени; второе - «на весь день»."""
+    match = DT_RE.match(value.strip())
+    if match is None:
+        return None
+    year, month, day = (int(match.group(i)) for i in (1, 2, 3))
+    if match.group(4) is None or prop.params.get("VALUE", "").upper() == "DATE":
+        return datetime(year, month, day, tzinfo=zone), True
+    hour, minute, second = (int(match.group(i)) for i in (4, 5, 6))
+    where = UTC if match.group(7) else _zone_of(prop, zone)
+    return datetime(year, month, day, hour, minute, second, tzinfo=where), False
+
+
+def _instants(event: Vevent, name: str, zone: tzinfo) -> set[datetime]:
+    """Даты-исключения в UTC: значений в одной строке может быть несколько."""
+    out: set[datetime] = set()
+    for prop in event.get(name, []):
+        for chunk in prop.value.split(","):
+            parsed = moment(prop, chunk, zone)
+            if parsed is not None:
+                out.add(parsed[0].astimezone(UTC))
+    return out
+
+
+def _rule(value: str) -> dict[str, str]:
+    out: dict[str, str] = {}
+    for chunk in value.split(";"):
+        key, sep, raw = chunk.partition("=")
+        if sep:
+            out[key.strip().upper()] = raw.strip()
+    return out
+
+
+def _int(value: str | None, default: int) -> int:
+    try:
+        return int(value) if value else default
+    except ValueError:
+        return default
+
+
+def _byday(value: str) -> list[tuple[int, int]]:
+    """`-1SU,2TU` → [(-1, воскресенье), (2, вторник)]; без числа - каждый такой день."""
+    out: list[tuple[int, int]] = []
+    for chunk in value.split(","):
+        match = BYDAY_RE.match(chunk.strip().upper())
+        if match:
+            out.append((_int(match.group(1), 0), WEEKDAYS[match.group(2)]))
+    return out
+
+
+def _month_days(
+    year: int, month: int, days: list[tuple[int, int]], clock: datetime
+) -> list[datetime]:
+    total = monthrange(year, month)[1]
+    out: list[datetime] = []
+    for nth, weekday in days:
+        matching = [
+            day
+            for day in range(1, total + 1)
+            if date(year, month, day).weekday() == weekday
+        ]
+        if not nth:
+            picked = matching
+        elif abs(nth) <= len(matching):
+            picked = [matching[nth - 1] if nth > 0 else matching[nth]]
+        else:
+            picked = []
+        out += [
+            datetime(year, month, day, clock.hour, clock.minute, clock.second)  # noqa: DTZ001
+            for day in picked
+        ]
+    return sorted(out)
+
+
+def _candidates(
+    naive: datetime, freq: str, interval: int, days: list[tuple[int, int]], month: int
+) -> Iterator[datetime]:
+    """Настенные времена повтора после первого - по возрастанию, бесконечно."""
+    if freq == "DAILY":
+        moving = naive
+        while True:
+            moving += timedelta(days=interval)
+            yield moving
+    elif freq == "WEEKLY" and not days:
+        moving = naive
+        while True:
+            moving += timedelta(weeks=interval)
+            yield moving
+    elif freq == "WEEKLY":
+        start = naive.date() - timedelta(days=naive.weekday())
+        step = 0
+        while True:
+            base = start + timedelta(weeks=interval * step)
+            for _, weekday in sorted(days, key=lambda d: d[1]):
+                yield datetime.combine(base + timedelta(days=weekday), naive.time())
+            step += 1
+    elif freq in ("MONTHLY", "YEARLY"):
+        step = 0
+        while True:
+            step += 1
+            if freq == "MONTHLY":
+                index = naive.year * 12 + naive.month - 1 + interval * step
+                year, number = divmod(index, 12)
+                number += 1
+            else:
+                year, number = naive.year + interval * step, month or naive.month
+            if days:
+                yield from _month_days(year, number, days, naive)
+            elif naive.day <= monthrange(year, number)[1]:
+                yield naive.replace(year=year, month=number)
+
+
+def occurrences(
+    start: datetime, rule: dict[str, str], zone: tzinfo, *, end: datetime
+) -> list[datetime]:
+    """Начала повтора от `start` до `end`; правило, которого мы не знаем, - разовое."""
+    freq = rule.get("FREQ", "").upper()
+    if freq not in ("DAILY", "WEEKLY", "MONTHLY", "YEARLY"):
+        return [start]
+    where = start.tzinfo or zone
+    naive = start.replace(tzinfo=None)
+    interval = max(_int(rule.get("INTERVAL"), 1), 1)
+    count = _int(rule.get("COUNT"), 0)
+    until = _until(rule.get("UNTIL"), where)
+    days = _byday(rule.get("BYDAY", ""))
+    out = [start]
+    stream = _candidates(naive, freq, interval, days, _int(rule.get("BYMONTH"), 0))
+    for step, candidate in enumerate(stream):
+        if step > STEPS_CAP:
+            break
+        if candidate <= naive:
+            continue
+        moving = candidate.replace(tzinfo=where)
+        if moving > end or (until is not None and moving > until):
+            break
+        out.append(moving)
+        if count and len(out) >= count:
+            break
+    return out
+
+
+def _until(value: str | None, zone: tzinfo) -> datetime | None:
+    if not value:
+        return None
+    parsed = moment(Prop(value=value), value, zone)
+    if parsed is None:
+        return None
+    stop, all_day = parsed
+    return stop + timedelta(days=1) if all_day else stop
+
+
+ROUTINE_DAYS = 5
+"""Со скольких дней недели в BYDAY повтор перестаёт быть событием и делается бытом."""
+
+
+def is_routine(rule: dict[str, str]) -> bool:
+    """Правило, срабатывающее раз в день или чаще: завтрак, зарядка, wind down.
+
+    Такие повторы за неделю дают десятки строк и топят в себе то единственное,
+    ради чего справку и читают, - экзамен, встречу, приём. В конверт они едут
+    одной свёрнутой строкой, а не списком.
+    """
+    freq = rule.get("FREQ", "").upper()
+    if max(_int(rule.get("INTERVAL"), 1), 1) != 1:
+        return False
+    if freq == "DAILY":
+        return True
+    return freq == "WEEKLY" and len(_byday(rule.get("BYDAY", ""))) >= ROUTINE_DAYS
+
+
+def place_of(event: Vevent) -> str:
+    """Зал из описания и адрес из LOCATION - то, что помогает дойти."""
+    parts: list[str] = []
+    description = _first(event, "DESCRIPTION")
+    if description is not None:
+        match = PLACE_RE.search(unescape(description.value))
+        if match:
+            parts.append(" ".join(match.group(0).split()))
+    location = _first(event, "LOCATION")
+    if location is not None:
+        flat = " ".join(unescape(location.value).split())
+        if flat:
+            parts.append(flat)
+    return _flat(", ".join(parts), PLACE_MAX)
+
+
+def events_in(text: str, *, zone: tzinfo, since: datetime, days: int) -> list[Event]:
+    """События фида, начинающиеся в окне `[since, since + days]`, с повторами."""
+    end = since + timedelta(days=days)
+    day_start = since.astimezone(zone).replace(
+        hour=0, minute=0, second=0, microsecond=0
+    )
+    parsed = vevents(unfold(text))
+    moved: dict[str, set[datetime]] = {}
+    for event in parsed:
+        uid = _first(event, "UID")
+        if uid is not None and "RECURRENCE-ID" in event:
+            moved.setdefault(uid.value, set()).update(
+                _instants(event, "RECURRENCE-ID", zone)
+            )
+    out: list[Event] = []
+    for event in parsed:
+        status = _first(event, "STATUS")
+        dtstart = _first(event, "DTSTART")
+        if dtstart is None or (
+            status is not None and status.value.upper() == "CANCELLED"
+        ):
+            continue
+        parsed_start = moment(dtstart, dtstart.value, zone)
+        if parsed_start is None:
+            continue
+        start, all_day = parsed_start
+        rrule = _first(event, "RRULE")
+        if rrule is None or "RECURRENCE-ID" in event:
+            starts = [start]
+            skip: set[datetime] = set()
+            routine = False
+        else:
+            rule = _rule(rrule.value)
+            starts = occurrences(start, rule, zone, end=end)
+            routine = is_routine(rule)
+            uid = _first(event, "UID")
+            skip = _instants(event, "EXDATE", zone) | moved.get(
+                uid.value if uid else "", set()
+            )
+        title = _flat(_text(event, "SUMMARY"), TITLE_MAX) or NO_TITLE
+        place = place_of(event)
+        for moving in starts:
+            floor = day_start if all_day else since
+            if moving < floor or moving > end or moving.astimezone(UTC) in skip:
+                continue
+            out.append(
+                Event(
+                    start=moving,
+                    title=title,
+                    place=place,
+                    all_day=all_day,
+                    routine=routine,
+                )
+            )
+    return out
+
+
+def _text(event: Vevent, name: str) -> str:
+    prop = _first(event, name)
+    return prop.value if prop is not None else ""

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:
+    async def _updates(
-        updates = (await self.read("ListUpdates", {}))["updates"][:15]
+        self, limit: int, operation: str | None, resource: str | None
-        return "\n".join(_update_line(u) for u in updates) or "операций нет"
+    ) -> 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", {}):
+        for s in await self.listing("ListServers"):
-            containers = await self.read("ListDockerContainers", {"server": s["name"]})
+            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

@@ -2,22 +2,58 @@
 
 from __future__ import annotations
 
+import os
+
 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
+
+LEISURE_OFF = os.environ.get("LEISURE", "").strip().lower() in ("off", "0", "false")
+"""Рубильник досуга в env; повседневный выключатель - строка в `мета/бобер/досуг.md`."""
 
 jobs = [
     Job("ротация", rotate, cron="0 * * * *"),
+    # Не на ":00": там ротация, а лежащий в очереди тик держит мастера занятым
+    # (`busy`), и она пропускала бы себя каждый час.
+    *([] 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

@@ -0,0 +1,378 @@
+"""Ежечасный тик: час принадлежит мне, раскладку суток веду я сам.
+
+Задания в инжекте нет - только который час, какого он типа и что осталось
+от суточной раскладки. Активное окно 12:00-03:59 тикает каждый час, тихое
+04:00-11:59 - только те четыре часа, которые названы в плане. План лежит в
+`мета/бобер/досуг.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 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
+
+_log = logging.getLogger(__name__)
+
+DAY_START = 12
+"""Сутки досуга начинаются в 12:00: раскладывает их первый тик суток."""
+QUIET_FROM, QUIET_UNTIL = 4, 12
+"""Тихое окно 04:00-11:59 - часы, в которые Бобёр за всё время не написал ни разу."""
+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
+"""Занятому мастеру тик не лезет в середину реплики, а сдвигается внутри часа."""
+FRESH_USER = timedelta(minutes=5)
+
+WEEKDAYS = (
+    "понедельник",
+    "вторник",
+    "среда",
+    "четверг",
+    "пятница",
+    "суббота",
+    "воскресенье",
+)
+MONTHS = (
+    "января",
+    "февраля",
+    "марта",
+    "апреля",
+    "мая",
+    "июня",
+    "июля",
+    "августа",
+    "сентября",
+    "октября",
+    "ноября",
+    "декабря",
+)
+
+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}` строками «сутки:», «тихие часы:», «мои часы:», «пустые часы:»."
+)
+PLANNING = (
+    "Первый тик суток. Разложи оставшиеся часы: какие твои, какие смешанные, "
+    "какие четыре часа тихого окна оставить. Запиши в `{path}` строками "
+    "«сутки:», «тихие часы:», «мои часы:», «пустые часы:». Своих - минимум {min}, "
+    "из них пустых - {empty}; запишешь меньше - механизм доберёт сам."
+)
+TAIL = "Задания нет. Чем занять час - решаешь ты, «ничем» - тоже ответ."
+KINDS = {
+    "mine": "досуг - час твой, дела Бобра сюда не лезут.",
+    "mixed": "смешанный - можно и своё, и его.",
+    "empty": (
+        "пустой - час без дел вообще: прод, логи, хвосты, зонды и разбор "
+        "промахов сюда не заходят, ни его, ни твои. Думать, читать, писать - "
+        "или ничего."
+    ),
+}
+FILES = (
+    "Дневник - `{diary}`: то, что ты думаешь, и только оно. След тика, логи "
+    "и промахи - строкой в `{journal}`."
+)
+ECHO = "Эхо - `{path}`:\n{quote}\nЭто повод, не задание: можно спорить, можно мимо."
+PLAN_PATH = str(LEISURE.relative_to(VAULT))
+
+
+@dataclass(frozen=True, slots=True)
+class Plan:
+    """Раскладка одних суток: какие тихие часы тикают и какие часы мои."""
+
+    day: str
+    quiet: tuple[int, ...]
+    mine: tuple[int, ...]
+    written: bool
+    """План прочитан из файла на эти сутки; иначе он собран по умолчанию."""
+    empty: tuple[int, ...] = ()
+    """Свои часы, в которые дела не заходят вовсе; всегда часть ``mine``."""
+
+
+def quiet_hour(hour: int) -> bool:
+    return QUIET_FROM <= hour < QUIET_UNTIL
+
+
+def day_of(now: datetime) -> str:
+    """Сутки, которым принадлежит момент: они начинаются в 12:00."""
+    return (now - timedelta(hours=DAY_START)).date().isoformat()
+
+
+def tick_hours(quiet: tuple[int, ...]) -> tuple[int, ...]:
+    """Часы суток по порядку, в которые тик вообще приходит."""
+    order = ((DAY_START + i) % 24 for i in range(24))
+    return tuple(h for h in order if not quiet_hour(h) or h in quiet)
+
+
+def _hours(raw: str) -> tuple[int, ...]:
+    out: list[int] = []
+    for chunk in re.split(r"[,\s]+", raw.strip()):
+        if chunk.isdigit() and 0 <= int(chunk) < 24 and int(chunk) not in out:
+            out.append(int(chunk))
+    return tuple(out)
+
+
+def _first(text: str, pattern: re.Pattern[str]) -> str | None:
+    for line in text.splitlines():
+        match = pattern.match(line.strip())
+        if match:
+            return match.group(1)
+    return None
+
+
+def enabled(text: str | None) -> bool:
+    """Выключено, только если сказано явно: по умолчанию досуг работает."""
+    if text is None:
+        return True
+    value = _first(text, SWITCH_RE)
+    return value is None or value.strip().lower() not in OFF
+
+
+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):
+        if len(kept) >= MINE_MIN:
+            break
+        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])),
+    )
+
+
+def _stamp(now: datetime) -> str:
+    return (
+        f"{now:%H:%M}, {WEEKDAYS[now.weekday()]} {now.day} {MONTHS[now.month - 1]}, "
+        f"{ZONE.key}"
+    )
+
+
+def _left(now: datetime) -> str:
+    end = now.replace(hour=DAY_START, minute=0, second=0, microsecond=0)
+    if end <= now:
+        end += timedelta(days=1)
+    hours = round((end - now).total_seconds() / 3600)
+    return f"Сутки заканчиваются через {hours} ч (в {end:%H:%M %d.%m})."
+
+
+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)
+    order = {h: i for i, h in enumerate(ticks)}
+    here = order.get(hour, -1)
+    mine = hour in plan.mine
+    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)}. Тип: {KINDS[kind_of(hour, plan)]}",
+        _left(now),
+        "Мои часы: "
+        + ", ".join(f"{h:02d}" for h in plan.mine)
+        + f" - израсходовано {len(spent) + (1 if mine else 0)} из {len(plan.mine)}"
+        + (
+            ", впереди " + ", ".join(f"{h:02d}" for h in ahead)
+            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)
+        + "; остальные часы там пропускаются.",
+    ]
+    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, 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)
+
+
+def _aware(value: datetime | None) -> datetime | None:
+    if value is None:
+        return None
+    return value if value.tzinfo is not None else value.replace(tzinfo=UTC)
+
+
+def _wait(master: Conversation, now: datetime) -> bool:
+    """Не влезать в живую реплику: сдвинуться, а не пропасть."""
+    spoke = _aware(master.last_user_activity_at)
+    return spoke is not None and now - spoke < FRESH_USER
+
+
+async def _riding(run: JobRun, master: Conversation, now: datetime) -> bool:
+    """Есть ли впереди в этом часе отложенный инжект, с которым стоит слиться."""
+    edge = now.replace(minute=0, second=0, microsecond=0) + timedelta(hours=1)
+    try:
+        rows = await run.scheduler.scheduled(master)
+    except Exception:  # noqa: BLE001
+        _log.exception("досуг: очередь отложенных инжектов не прочиталась")
+        return False
+    for row in rows:
+        raw = row.get("execute_after")
+        if not isinstance(raw, str):
+            continue
+        try:
+            when = datetime.fromisoformat(raw)
+        except ValueError:
+            continue
+        if now < when < edge:
+            return True
+    return False
+
+
+async def tick(run: JobRun) -> None:
+    """Час пробил: решить, тик ли это, дождаться тишины в мастере и разбудить."""
+    text = read(LEISURE)
+    if not enabled(text):
+        _log.info("досуг: выключен в %s", LEISURE.name)
+        return
+    now = datetime.now(ZONE)
+    plan = plan_of(text, day_of(now))
+    if now.hour not in tick_hours(plan.quiet):
+        _log.info("досуг: %02d:00 - тихий час без тика", now.hour)
+        return
+    master = await run.master()
+    if master is None:
+        _log.error("досуг: открытого мастера нет, тик пропал")
+        return
+    attempt = int(run.payload.get("attempt", 0))
+    if (await run.conversations.busy(master) or _wait(master, now)) and (
+        attempt < BUSY_ATTEMPTS
+    ):
+        run.payload["attempt"] = attempt + 1
+        await run.retry_in(BUSY_RETRY)
+        _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, heard=heard),
+        urgency="normal" if riding else "wake",
+        origin="досуг",
+    )
+    _log.info(
+        "досуг: тик %02d:00 (%s), слияние с отложенным инжектом: %s",
+        now.hour,
+        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,7 +11,9 @@ 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,
     STATE,
     STATE_MAX_LINES,
@@ -56,9 +58,11 @@ async def curate(run: JobRun) -> None:
     text = briefing(
         vault=VAULT,
         journal=CURATOR_JOURNAL,
+        runs=CURATOR_RUNS,
         replies_dir=REPLIES,
         watched=CURATOR_WATCH,
         tz=TZ,
+        skip=(LEISURE,),
     )
     if text is None:
         _log.info("curator: nothing new since the last run")

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/jobs/voice.py

@@ -0,0 +1,14 @@
+"""Раз в ночь: голосовая ветка начинается заново в том же топике."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from beaver_agent.voice import rotate
+
+if TYPE_CHECKING:
+    from beaver_gateway.jobs.scheduler import JobRun
+
+
+async def rotate_voice(run: JobRun) -> None:
+    await rotate(run.conversations)

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,28 +95,35 @@ def briefing(
     *,
     vault: Path,
     journal: Path,
+    runs: Path,
     replies_dir: Path,
     watched: list[Watched],
     tz: str,
     now: datetime | None = None,
     default_window: timedelta = timedelta(hours=24),
+    skip: tuple[Path, ...] = (),
 ) -> str | None:
     """Первое сообщение куратору или ``None``, если с прошлого прогона ничего нет."""
     now = now or datetime.now(UTC)
     since = last_run(journal, default=now - default_window)
     replies = new_replies(replies_dir, since, tz)
     changed = changed_files(
-        watched, since, vault, skip=(str(journal.relative_to(vault)),)
+        watched,
+        since,
+        vault,
+        skip=tuple(str(p.relative_to(vault)) for p in (journal, *skip)),
     )
     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"`{(runs / f'{local:%Y-%m-%d}.md').relative_to(vault)}`, а в "
-        f"{now.astimezone(zone).isoformat(timespec='seconds')}`."
+        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

@@ -3,14 +3,16 @@
 Gateway путей не знает; здесь - что искать по тексту сообщения и куда писать
 сказанное. ``Recall.block`` отдаёт указатели, не выводы: карточка упомянутого
 человека, его записки о нём (`мета/бобер/наблюдения/<имя> - наблюдения.md`),
-дни дневника, где он встречался, и раз в день - подошедшие сроки из досок.
+дни дневника, где он встречался, и раз в день - подошедшие сроки из досок и
+ближайшая неделя календарей.
 ``ReplyLog.write`` кладёт каждую реплику Бобра из мастера и веток в
-`мета/бобер/реплики/YYYY-MM.md` - единственное место, где они grep-абельны:
+`мета/бобер/реплики/YYYY-MM-DD.md` - единственное место, где они grep-абельны:
 транскрипт живёт в Postgres, а глубокие чаты и так лежат файлами в `💬 чаты/`.
 """
 
 from __future__ import annotations
 
+import logging
 import re
 import time
 from dataclasses import dataclass, field
@@ -19,14 +21,25 @@ from typing import TYPE_CHECKING
 from zoneinfo import ZoneInfo
 
 if TYPE_CHECKING:
+    from datetime import datetime
     from pathlib import Path
 
     from beaver_gateway.conversations.envelope import RecallContext
     from beaver_gateway.conversations.texts import UserSaid
 
+    from beaver_agent.hands.calendars import Calendars, Event, Upcoming
+
+_log = logging.getLogger(__name__)
+
 LABEL = "справка (указатели по сообщению, не выводы; открой, если относится к вопросу):"
 VOWELS = "аеёиоуыэюя"
 KINDS = {"master": "мастер", "branch": "ветка"}
+CALENDAR = "🗓 календарь"
+CALENDAR_LIMIT = 40
+"""Предохранитель на разовые события; повседневные повторы под него не идут."""
+CALENDAR_NAMES = 5
+"""Сколько названий показывать в свёрнутой строке повседневных повторов."""
+CALENDAR_ERROR_MAX = 90
 
 
 @dataclass(frozen=True, slots=True)
@@ -198,11 +211,16 @@ class Recall:
     tz: str = "Europe/Warsaw"
     diary_scan: int = 400
     """Сколько последних дней дневника просматривать на упоминания."""
+    mute: frozenset[str] = frozenset()
+    """Агенты, которым справку не показывают: чужие люди, чужие уши."""
+    calendar: Calendars | None = None
+    """Ical-фиды календарей; None - календари не настроены, секции нет вовсе."""
     _people: People | None = field(default=None, init=False, repr=False)
     _diary_cache: dict[str, tuple[float, list[str]]] = field(
         default_factory=dict, init=False, repr=False
     )
     _deadlines_day: date | None = field(default=None, init=False, repr=False)
+    _calendar_day: date | None = field(default=None, init=False, repr=False)
 
     @property
     def people(self) -> People:
@@ -211,10 +229,13 @@ class Recall:
         return self._people
 
     def block(self, ctx: RecallContext) -> str | None:
+        if ctx.agent in self.mute:
+            return None
         today = ctx.now.astimezone(ZoneInfo(self.tz)).date()
         lines = [self.person_line(p) for p in mentions(ctx.text, self.people.all())]
         if ctx.kind == "master":
             lines += self.deadlines(today)
+            lines += self.calendar_lines(ctx.now, today)
         if not lines:
             return None
         return "\n".join([LABEL, *lines])
@@ -298,18 +319,89 @@ class Recall:
         found.sort()
         return [f"📆 {due:%m-%d} {board}: {task}" for due, board, task in found[:limit]]
 
+    def calendar_lines(self, now: datetime, today: date) -> list[str]:
+        """Ближайшая неделя календарей - раз в день, следом за сроками досок.
+
+        Секция печатается всегда, когда до неё дошло: пустое окно - строкой
+        «событий нет», упавший фид - строкой «ОШИБКА» и записью в лог. Молча
+        пропасть она не может, иначе отказ канала неотличим от спокойного
+        календаря - так однажды и пролежала незамеченной сессия в USOS.
+        """
+        if self.calendar is None or self._calendar_day == today:
+            return []
+        self._calendar_day = today
+        try:
+            found = self.calendar.upcoming(now)
+        except Exception as exc:  # noqa: BLE001
+            _log.exception("календарь: справка не собралась")
+            reason = " ".join(f"{type(exc).__name__}: {exc}".split())
+            return [f"{CALENDAR}: ОШИБКА {reason[:CALENDAR_ERROR_MAX]}"]
+        lines = [f"{CALENDAR}: ОШИБКА {reason}" for reason in found.errors]
+        if found.read:
+            lines += self.calendar_window(found, self.calendar.days)
+        return lines or [f"{CALENDAR}: ОШИБКА фиды не ответили"]
+
+    def calendar_window(self, found: Upcoming, days: int) -> list[str]:
+        """Окно ответивших фидов: разовые событиями, повседневный быт - одной строкой.
+
+        Разовых за неделю физически мало, и ровно они и есть сигнал: экзамен,
+        встреча, приём. Их видно целиком; лимит тут - предохранитель от абсурда,
+        а не способ уместиться. Ежедневные повторы считаются и называются, но
+        своими строками разовые не вытесняют - иначе секция выглядит здоровой и
+        при этом показывает двое суток вместо недели.
+        """
+        stamp = f"{found.at:%Y-%m-%d %H:%M}"
+        if not found.events:
+            return [f"{CALENDAR} ({days} дней): событий нет, данные на {stamp}"]
+        zone = ZoneInfo(self.tz)
+        singles = [event for event in found.events if not event.routine]
+        routine = [event for event in found.events if event.routine]
+        shown = singles[:CALENDAR_LIMIT]
+        head = (
+            f"{CALENDAR} ({days} дней), разовых {len(singles)}, "
+            f"повседневных {len(routine)}, данные на {stamp}:"
+        )
+        lines = [head]
+        lines += [f"  - {event_line(event, zone)}" for event in shown]
+        if len(singles) > len(shown):
+            lines.append(f"  … и ещё {len(singles) - len(shown)} разовых в окне")
+        if routine:
+            lines.append(
+                f"  - повседневных повторов: {len(routine)} ({routine_names(routine)})"
+            )
+        return lines
+
+
+def routine_names(events: list[Event], *, limit: int = CALENDAR_NAMES) -> str:
+    """Уникальные названия бытовых повторов по первому появлению, до `limit`."""
+    names = list(dict.fromkeys(event.title for event in events))
+    return ", ".join(names[:limit]) + (" и др." if len(names) > limit else "")
+
+
+def event_line(event: Event, zone: ZoneInfo) -> str:
+    """Дата, начало, название и место - одной строкой в зоне агента."""
+    start = event.start.astimezone(zone)
+    when = "весь день" if event.all_day else f"{start:%H:%M}"
+    place = f" · {event.place}" if event.place else ""
+    return f"{start:%m-%d} {when} {event.title}{place}"
+
 
 @dataclass
 class ReplyLog:
-    """`мета/бобер/реплики/YYYY-MM.md`: строка на реплику Бобра из мастера и веток."""
+    """`мета/бобер/реплики/YYYY-MM-DD.md`: строка на реплику из мастера и веток."""
 
     dir: Path
     tz: str = "Europe/Warsaw"
     max_chars: int = 600
+    mute: frozenset[str] = frozenset()
+    """Агенты, чьи разговоры в лог реплик не идут."""
 
     def write(self, said: UserSaid) -> None:
+        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())
@@ -321,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/memory/watch.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from beaver_gateway.vault.watch import VaultWatch, WatchRules
 
+from beaver_agent.hands import CALENDARS
 from beaver_agent.memory.curator import Watched
 from beaver_agent.memory.recall import Recall, ReplyLog
 from beaver_agent.vault import (
@@ -18,6 +19,7 @@ from beaver_agent.vault import (
     TZ,
     VAULT,
 )
+from beaver_agent.voice import AGENT as VOICE
 
 watch = VaultWatch(
     VAULT,
@@ -52,8 +54,12 @@ recall = Recall(
     diary_dir=DIARY,
     boards_dir=BOARDS,
     tz=TZ,
+    mute=frozenset({VOICE}),
+    calendar=CALENDARS,
 )
-replies = ReplyLog(REPLIES, tz=TZ)
+"""Голосовому агенту справки нет: за колонкой может стоять кто угодно."""
+
+replies = ReplyLog(REPLIES, tz=TZ, mute=frozenset({VOICE}))
 
 CURATOR_WATCH = [
     Watched("хендауты", DAYS, "????-??-??.md"),

beaver_agent/prompts.py

@@ -58,3 +58,8 @@ CURATOR = Prompts(job=(*BASE, environment("джоб"), overlay("curator", "ку
 
 QUICK = assemble((*VOICE, PROFILE, overlay("quick", "быстрый")))
 """Raycast-агенты: голос и профиль одной строкой, без vault."""
+
+VOICE_AGENT = Prompts(
+    branch=(*VOICE, environment("голосовой"), overlay("voice", "голосовой"))
+)
+"""Колонки: голос целиком, но без профиля, поправок и карты - vault ему не виден."""

beaver_agent/vault.py

@@ -18,6 +18,7 @@ CHATS = VAULT / "💬 чаты"
 DIARY = VAULT / "📅 дни"
 PEOPLE = VAULT / "👤 люди"
 BOARDS = VAULT / "📆 доски"
+THOUGHTS = VAULT / "🧠 мысли"
 
 BEAVER = VAULT / "мета" / "бобер"
 """Дом агента: всё, что он ведёт сам, лежит здесь."""
@@ -31,6 +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 / "вложения"

beaver_agent/voice/__init__.py

@@ -0,0 +1,16 @@
+"""Голосовые точки по квартире: своя ветка, свой дешёвый агент, свои ключи."""
+
+from beaver_agent.voice.frontend import VoiceFrontend
+from beaver_agent.voice.texts import KEY, TITLE
+from beaver_agent.voice.thread import AGENT, FRONTEND, current, open_thread, rotate
+
+__all__ = [
+    "AGENT",
+    "FRONTEND",
+    "KEY",
+    "TITLE",
+    "VoiceFrontend",
+    "current",
+    "open_thread",
+    "rotate",
+]

beaver_agent/voice/frontend.py

@@ -0,0 +1,266 @@
+"""Окно голосовых точек: ESP32 шлёт json на /voice, отвечает дешёвый агент."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from typing import TYPE_CHECKING, Any
+from uuid import uuid4
+
+from beaver_gateway.agents.claude import ClaudeAgent
+from beaver_gateway.conversations.turns import content_of
+from beaver_gateway.frontends.accumulate import StreamAccumulator
+from beaver_gateway.frontends.base import Frontend
+from beaver_gateway.frontends.bearer import require_token
+from beaver_gateway.frontends.sse import (
+    KEEPALIVE,
+    SSE_HEADERS,
+    events_with_heartbeat,
+    sse_pack,
+)
+from beaver_gateway.security import audit
+from fastapi import FastAPI, HTTPException, Request, status
+from fastapi.responses import JSONResponse, StreamingResponse
+
+from beaver_agent.voice import texts
+from beaver_agent.voice.thread import FRONTEND, current, open_thread
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator, Mapping
+
+    from beaver_gateway.frontends.base import GatewayRuntime
+    from beaver_gateway.storage.models import Conversation
+
+_log = logging.getLogger("beaver_agent.voice")
+
+FIELDS = ("room", "device", "content")
+
+
+class VoiceFrontend(Frontend):
+    """Одна ветка на всю квартиру, свой агент, свои ключи.
+
+    Тёрн идёт мимо очереди, а значит и мимо конверта: справка по vault в
+    этот разговор не попадает даже случайно. В телеграм-ветку вопрос
+    кладётся отдельной репликой, ответ пишется черновиком, как обычно.
+
+    Отвечает SSE по умолчанию - колонке важно начать говорить раньше;
+    `"stream": false` в теле переключает на один JSON.
+    """
+
+    name = FRONTEND
+    kinds = ("branch",)
+    path = "/voice"
+    scope = "voice"
+
+    def __init__(self, *, agent: str, timeout: float = 90.0) -> None:
+        self.agent = agent
+        self.timeout = timeout
+        """Сколько ждать ответа; дальше 504, а тёрн договаривает в телеграм."""
+        self._runtime: GatewayRuntime | None = None
+        self._app: FastAPI | None = None
+        self._lock = asyncio.Lock()
+        self._late: set[asyncio.Task[Any]] = set()
+
+    def configure(self, runtime: GatewayRuntime) -> None:
+        if runtime.conversations is None or runtime.bus is None:
+            msg = "VoiceFrontend: нужны runtime.conversations и runtime.bus"
+            raise RuntimeError(msg)
+        agent = runtime.agents.get(self.agent)
+        if not isinstance(agent, ClaudeAgent) or not agent.serves("branch"):
+            msg = f"VoiceFrontend: агент {self.agent!r} не обслуживает ветки"
+            raise RuntimeError(msg)
+        self._runtime = runtime
+        self._app = self._build_app(runtime)
+
+    def app(self) -> FastAPI | None:
+        return self._app
+
+    def _build_app(self, runtime: GatewayRuntime) -> FastAPI:
+        app = FastAPI(title="beaver-agent / голосовой")
+
+        @app.get("/healthz")
+        async def healthz() -> dict[str, str]:
+            return {"status": "ok", "frontend": self.name}
+
+        @app.post("/")
+        async def ask(request: Request) -> Any:
+            token = await require_token(request, runtime, scope=self.scope)
+            body = await _body(request)
+            room, device, content = (_field(body, name) for name in FIELDS)
+            conv = await self.thread()
+            await audit.log(
+                runtime,
+                actor=f"token:{token}",
+                kind="voice_ask",
+                agent_name=conv.agent_name,
+                conversation=conv.external_id,
+                room=room,
+                device=device,
+                request_id=body.get("request_id"),
+            )
+            _log.info("голос: %s/%s -> %s", room, device, conv.external_id)
+            await runtime.conversations.say(
+                conv, texts.ASKED.format(room=room, device=device, text=content)
+            )
+            prompt = await self._prompt(
+                conv, texts.HEARD.format(room=room, device=device, text=content)
+            )
+            if _flag(body, "stream", default=True):
+                return StreamingResponse(
+                    self._sse(conv, prompt, body),
+                    media_type="text/event-stream",
+                    headers=SSE_HEADERS,
+                )
+            return JSONResponse(await self._answer(conv, prompt, body))
+
+        @app.exception_handler(HTTPException)
+        async def http_error(_request: Request, exc: HTTPException) -> JSONResponse:
+            return JSONResponse(
+                status_code=exc.status_code,
+                content={"error": exc.detail},
+                headers=exc.headers,
+            )
+
+        return app
+
+    async def thread(self) -> Conversation:
+        conversations = self.runtime.conversations
+        async with self._lock:
+            conv = await current(conversations)
+            if conv is not None:
+                return conv
+            return await open_thread(conversations, agent=self.agent)
+
+    @property
+    def runtime(self) -> GatewayRuntime:
+        if self._runtime is None:
+            msg = "VoiceFrontend: configure() не вызывали"
+            raise RuntimeError(msg)
+        return self._runtime
+
+    async def _prompt(self, conv: Conversation, text: str) -> str:
+        seed = await self.runtime.conversations.pending_seed(conv)
+        return f"{seed}\n\n{text}" if seed else text
+
+    async def _answer(
+        self, conv: Conversation, prompt: str, body: Mapping[str, Any]
+    ) -> dict[str, Any]:
+        turn_id = _turn_id()
+        task = asyncio.create_task(self._run(conv, prompt, turn_id))
+        self._late.add(task)
+        task.add_done_callback(self._late.discard)
+        done, _ = await asyncio.wait({task}, timeout=self.timeout)
+        if not done:
+            _log.warning("голос: %s не уложился в %.0f c", turn_id, self.timeout)
+            raise HTTPException(
+                status.HTTP_504_GATEWAY_TIMEOUT, "агент не успел; ответ уйдёт в ветку"
+            )
+        return _body_out(body, reply=task.result(), conv=conv)
+
+    async def _run(self, conv: Conversation, prompt: str, turn_id: str) -> str:
+        reply, _capture = await self.runtime.conversations.run_text_turn(
+            conv, prompt, origin="user", turn_id=turn_id
+        )
+        self._published(conv, reply=reply, turn_id=turn_id)
+        return reply
+
+    async def _sse(
+        self, conv: Conversation, prompt: str, body: Mapping[str, Any]
+    ) -> AsyncIterator[bytes]:
+        turn_id = _turn_id()
+        acc = StreamAccumulator()
+        model = self.runtime.agents[conv.agent_name].model
+        try:
+            events = self.runtime.conversations.turn(
+                conv,
+                messages=[{"role": "user", "content": content_of(prompt, None)}],
+                origin="user",
+                turn_id=turn_id,
+            )
+            async for event in events_with_heartbeat(events):
+                if event is None:
+                    yield KEEPALIVE
+                    continue
+                acc.feed(event)
+                chunk = _text_delta(event)
+                if chunk:
+                    yield sse_pack("delta", {"text": chunk})
+        except Exception as exc:  # noqa: BLE001
+            _log.exception("голос: тёрн %s упал", turn_id)
+            yield sse_pack("error", {"error": str(exc)})
+            return
+        reply = _text_of(acc.finalize(model=model))
+        self._published(conv, reply=reply, turn_id=turn_id)
+        yield sse_pack("done", _body_out(body, reply=reply, conv=conv))
+
+    def _published(self, conv: Conversation, *, reply: str, turn_id: str) -> None:
+        self.runtime.bus.publish(
+            "reply",
+            conversation_id=conv.external_id,
+            turn_id=turn_id,
+            source=self.name,
+            text=reply,
+        )
+
+
+async def _body(request: Request) -> Mapping[str, Any]:
+    try:
+        data = await request.json()
+    except json.JSONDecodeError as exc:
+        raise HTTPException(status.HTTP_400_BAD_REQUEST, f"кривой json: {exc}") from exc
+    if not isinstance(data, dict):
+        raise HTTPException(status.HTTP_400_BAD_REQUEST, "тело должно быть объектом")
+    return data
+
+
+def _flag(body: Mapping[str, Any], name: str, *, default: bool) -> bool:
+    """Флаг из тела; строку разбираем словом, иначе `"false"` включит стрим."""
+    value = body.get(name)
+    if value is None:
+        return default
+    if isinstance(value, str):
+        return value.strip().lower() in ("1", "true", "yes", "on")
+    return bool(value)
+
+
+def _field(body: Mapping[str, Any], name: str) -> str:
+    value = body.get(name)
+    if not isinstance(value, str) or not value.strip():
+        raise HTTPException(
+            status.HTTP_400_BAD_REQUEST, f"нужно непустое строковое поле {name!r}"
+        )
+    return value.strip()
+
+
+def _body_out(
+    body: Mapping[str, Any], *, reply: str, conv: Conversation
+) -> dict[str, Any]:
+    return {
+        "request_id": body.get("request_id"),
+        "room": body.get("room"),
+        "device": body.get("device"),
+        "reply": reply,
+        "conversation": conv.external_id,
+    }
+
+
+def _turn_id() -> str:
+    return f"turn_{uuid4().hex[:12]}"
+
+
+def _text_delta(event: Any) -> str:
+    if getattr(event, "type", "") != "content_block_delta":
+        return ""
+    delta = getattr(event, "delta", None)
+    if getattr(delta, "type", "") != "text_delta":
+        return ""
+    return getattr(delta, "text", "")
+
+
+def _text_of(message: Any) -> str:
+    return "\n\n".join(
+        getattr(b, "text", "")
+        for b in message.content
+        if getattr(b, "type", "") == "text"
+    ).strip()

beaver_agent/voice/texts.py

@@ -0,0 +1,17 @@
+"""Что видно в телеграм-ветке голосовых точек; промпт - гранулы vault."""
+
+from __future__ import annotations
+
+TITLE = "🎤 Голосовой"
+"""Имя ветки; телеграм заводит топик под этим именем."""
+
+KEY = "квартира"
+"""Ключ единственного треда: одна ветка на всю квартиру."""
+
+ASKED = "🎤 {room} · {device}\n{text}"
+"""Вопрос, как он показывается в телеграм-ветке."""
+
+HEARD = "[{room} · {device}] {text}"
+"""Вопрос, как его видит модель."""
+
+ROTATED = "🎤 Новый день - ветка начата заново, прошлого разговора агент не помнит."

beaver_agent/voice/thread.py

@@ -0,0 +1,62 @@
+"""Единственная ветка голосовых точек: как её открыть и как сменить за ночь."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from beaver_agent.voice.texts import KEY, ROTATED, TITLE
+
+if TYPE_CHECKING:
+    from beaver_gateway.conversations.service import Conversations
+    from beaver_gateway.storage.models import Conversation
+
+AGENT = "beaver-voice"
+"""Кто сидит в голосовой ветке; ему не видно ни справки, ни vault."""
+
+FRONTEND = "voice"
+TELEGRAM = "telegram"
+
+_log = logging.getLogger("beaver_agent.voice")
+
+
+async def current(conversations: Conversations) -> Conversation | None:
+    conv = await conversations.find_bound(frontend=FRONTEND, external_id=KEY)
+    return conv if conv is not None and conv.status == "open" else None
+
+
+async def open_thread(
+    conversations: Conversations, *, agent: str, window: str | None = None
+) -> Conversation:
+    """Завести ветку; без ``window`` окно ей открывает телеграм - новым топиком."""
+    conv = await conversations.spawn(
+        kind="branch",
+        agent=agent,
+        title=TITLE,
+        origin=FRONTEND,
+        binding=(TELEGRAM, window) if window else None,
+    )
+    await conversations.bind(conv, frontend=FRONTEND, external_id=KEY)
+    _log.info("голосовая ветка %s (%s)", conv.external_id, agent)
+    return conv
+
+
+async def window_of(conversations: Conversations, conv: Conversation) -> str | None:
+    for binding in await conversations.bindings(conv):
+        if binding.frontend == TELEGRAM and binding.visible:
+            return binding.external_id
+    return None
+
+
+async def rotate(conversations: Conversations) -> Conversation | None:
+    """Ночью - новая ветка в том же топике; молчавшую за сутки не трогаем."""
+    old = await current(conversations)
+    if old is None or old.last_user_activity_at is None:
+        return None
+    new = await open_thread(
+        conversations, agent=old.agent_name, window=await window_of(conversations, old)
+    )
+    await conversations.close(old)
+    await conversations.say(new, ROTATED)
+    _log.info("голосовая ветка: %s -> %s", old.external_id, new.external_id)
+    return new

caddy/site.caddy

@@ -1,5 +1,5 @@
 # Роуты beaver. Один апстрим, префиксы не срезаются: gateway сам живёт под
-# /anthropic, /mcp, /md, /api, /admin, а / ведёт в админку.
+# /anthropic, /mcp, /md, /api, /admin, /voice, а / ведёт в админку.
 # Домен и апстрим - из env сервера (domains.env / .env), tls - забота
 # серверного Caddyfile.
 {$BEAVER_DOMAIN} {

config.py

@@ -3,7 +3,8 @@
 - vault.py - пути и зона агента; prompts.py - как из гранул собирается промпт роли;
 - skills.py - наборы скиллов по окнам; policy.py - что можно трогать в vault;
 - hands/ - MCP-руки и кому какая выдана; agents.py - роли и их экземпляры;
-- frontends.py - окна; texts.py - всё, что gateway говорит, по-русски;
+- frontends.py - окна; voice/ - голосовые точки по квартире и их ветка;
+- texts.py - всё, что gateway говорит, по-русски;
 - memory/ - справка, реплики, хендауты, вотчер, куратор; jobs/ - кроны и вебхуки.
 """
 

docker-compose.yml

@@ -67,6 +67,12 @@ services:
       # клон репы комнаты вайбграма (сервис vibegram-repo), только читать
       - vibegram:/vibegram:ro
       - claude-home:/home/beaver-runner/.claude
+      # Шара на HDD: сюда агент кладёт то, что отдаёт человеку через
+      # send_file (SEND_FILE_ROOTS по умолчанию = /mnt/hole/shared).
+      # Путь СНАРУЖИ И ВНУТРИ ОДИН И ТОТ ЖЕ - модель пишет в тулзу ровно
+      # тот путь, который видит сама. Каталог на хосте принадлежит
+      # 1001:999 - это uid/gid beaver-runner'а внутри, - mode 2770.
+      - /mnt/hole/shared:/mnt/hole/shared
     extra_hosts:
       # Home Assistant и прочее с network_mode: host
       - "host.docker.internal:host-gateway"
@@ -103,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-адрес явно
+      # tailnet-адрес дев-VM явно, не завися от DNS хоста
-      - "dell:${T3_DELL_ADDR:?T3_DELL_ADDR=tailnet ip of dell}"
+      - "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]
+[machines.dell-dev]
-url = "http://dell:3773"
+url = "http://dell-dev:3773"
-token_env = "T3_DELL_TOKEN"
+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_calendars.py

@@ -0,0 +1,169 @@
+import urllib.error
+from email.message import Message
+from datetime import UTC, datetime
+from zoneinfo import ZoneInfo
+
+from beaver_agent.hands.calendars import (
+    Calendars,
+    Feed,
+    calendars,
+    events_in,
+    feeds,
+    is_routine,
+    short,
+    unfold,
+)
+
+ZONE = ZoneInfo("Europe/Warsaw")
+NOW = datetime(2026, 9, 1, 12, 0, tzinfo=UTC)  # 14:00 в Варшаве
+
+MCPS = (
+    "personal=https://calendar-mcp.com/api/mcp?email=b%40b.com"
+    "&icsUrl=https%3A%2F%2Fcalendar.google.com%2Fical%2Fprivate-abc%2Fbasic.ics,"
+    "student=https://calendar-mcp.com/api/mcp?icsUrl=https%3A%2F%2Fusos.pl%2Fics%3Fkey%3Dz,"
+    "bare=https://calendar-mcp.com/mcp/AAAA"
+)
+
+
+def ics(*events: str) -> str:
+    body = "".join(f"BEGIN:VEVENT\n{e.strip()}\nEND:VEVENT\n" for e in events)
+    return f"BEGIN:VCALENDAR\nVERSION:2.0\nPRODID:-//test//EN\n{body}END:VCALENDAR\n"
+
+
+def starts(text: str, *, days: int = 7) -> list[str]:
+    found = events_in(text, zone=ZONE, since=NOW.astimezone(ZONE), days=days)
+    return [
+        f"{e.start.astimezone(ZONE):%m-%d %H:%M} {e.title}"
+        for e in sorted(found, key=lambda e: e.start)
+    ]
+
+
+def test_feeds_take_the_ical_url_out_of_the_same_mcp_urls():
+    assert [f.name for f in feeds(MCPS)] == ["personal", "student"]
+    assert feeds(MCPS)[0].url == (
+        "https://calendar.google.com/ical/private-abc/basic.ics"
+    )
+    assert feeds(MCPS)[1].url == "https://usos.pl/ics?key=z"
+    assert feeds("") == ()
+    assert feeds("plain=https://example.com/plan.ics")[0].url.endswith("plan.ics")
+    # MCP-рука остаётся у модели, даже если ical-фида в записи нет
+    assert [m.name for m in calendars(MCPS)] == [
+        "calendar-personal",
+        "calendar-student",
+        "calendar-bare",
+    ]
+
+
+def test_folded_lines_are_glued_back():
+    assert unfold("SUMMARY:длин\r\n ное\r\nUID:x") == ["SUMMARY:длинное", "UID:x"]
+
+
+def test_window_sorts_by_start_and_keeps_only_the_next_days():
+    text = ics(
+        "SUMMARY:позже\nDTSTART:20260904T080000Z",
+        "SUMMARY:раньше\nDTSTART:20260902T080000Z",
+        "SUMMARY:за окном\nDTSTART:20260920T080000Z",
+        "SUMMARY:уже прошло\nDTSTART:20260801T080000Z",
+    )
+    assert starts(text) == ["09-02 10:00 раньше", "09-04 10:00 позже"]
+
+
+def test_all_day_event_of_today_still_counts_as_upcoming():
+    text = ics("SUMMARY:отпуск\nDTSTART;VALUE=DATE:20260901\nDTEND;VALUE=DATE:20260902")
+    found = events_in(text, zone=ZONE, since=NOW.astimezone(ZONE), days=7)
+    assert len(found) == 1
+    assert found[0].all_day
+    assert f"{found[0].start:%H:%M}" == "00:00"
+
+
+def test_place_takes_the_room_from_the_description_and_the_address_from_location():
+    text = ics(
+        "SUMMARY:Analiza matematyczna II - Egzamin\n"
+        "DTSTART;VALUE=DATE-TIME:20260903T110000\n"
+        "DESCRIPTION:Sala: 3\\nA23 - CW - Centrum Wykładowe\\n\n"
+        "LOCATION:ul. Piotrowo 2\\, 61-138 Poznań\\, Polska"
+    )
+    found = events_in(text, zone=ZONE, since=NOW.astimezone(ZONE), days=7)
+    assert found[0].place == "Sala: 3, ul. Piotrowo 2, 61-138 Poznań, Polska"
+    # плавающее время читается в зоне агента, а не в UTC
+    assert f"{found[0].start:%H:%M}" == "11:00"
+
+
+def test_cancelled_events_are_skipped():
+    text = ics("SUMMARY:отменено\nDTSTART:20260902T080000Z\nSTATUS:CANCELLED")
+    assert starts(text) == []
+
+
+def test_weekly_repeat_expands_and_exdate_with_moved_instance_are_subtracted():
+    series = (
+        "UID:w1\nSUMMARY:польский\nDTSTART;TZID=Europe/Warsaw:20260824T100000\n"
+        "RRULE:FREQ=WEEKLY;BYDAY=MO,WE"
+    )
+    assert starts(ics(series)) == ["09-02 10:00 польский", "09-07 10:00 польский"]
+    moved = ics(
+        series + "\nEXDATE;TZID=Europe/Warsaw:20260902T100000",
+        "UID:w1\nSUMMARY:польский (перенос)\n"
+        "RECURRENCE-ID;TZID=Europe/Warsaw:20260907T100000\n"
+        "DTSTART;TZID=Europe/Warsaw:20260907T173000",
+    )
+    assert starts(moved) == ["09-07 17:30 польский (перенос)"]
+
+
+def test_daily_repeat_stops_on_until_and_count():
+    until = ics(
+        "SUMMARY:завтрак\nDTSTART:20260801T060000Z\n"
+        "RRULE:FREQ=DAILY;UNTIL=20260903T060000Z"
+    )
+    assert starts(until) == ["09-02 08:00 завтрак", "09-03 08:00 завтрак"]
+    counted = ics("SUMMARY:курс\nDTSTART:20260902T060000Z\nRRULE:FREQ=DAILY;COUNT=3")
+    assert len(starts(counted)) == 3
+    yearly = ics(
+        "SUMMARY:часы\nDTSTART:20200906T060000Z\nRRULE:FREQ=YEARLY;BYMONTH=9;BYDAY=1SU"
+    )
+    assert starts(yearly) == ["09-06 08:00 часы"]
+
+
+def test_a_working_week_is_routine_but_one_weekday_a_week_is_an_event():
+    text = ics(
+        "SUMMARY:пара\nDTSTART;TZID=Europe/Warsaw:20260831T100000\n"
+        "RRULE:FREQ=WEEKLY;BYDAY=MO",
+        "SUMMARY:зарядка\nDTSTART;TZID=Europe/Warsaw:20260831T070000\n"
+        "RRULE:FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR",
+    )
+    found = events_in(text, zone=ZONE, since=NOW.astimezone(ZONE), days=7)
+    assert {e.title for e in found if e.routine} == {"зарядка"}
+    assert {e.title for e in found if not e.routine} == {"пара"}
+    assert len([e for e in found if e.routine]) == 5
+
+
+def test_routine_is_a_rule_that_fires_once_a_day_or_more_often():
+    assert is_routine({"FREQ": "DAILY"})
+    assert is_routine({"FREQ": "WEEKLY", "BYDAY": "MO,TU,WE,TH,FR,SA"})
+    assert not is_routine({"FREQ": "WEEKLY", "BYDAY": "MO,WE,FR"})
+    assert not is_routine({"FREQ": "WEEKLY"})
+    assert not is_routine({"FREQ": "MONTHLY"})
+    # через день - это уже не быт, такое видно поимённо
+    assert not is_routine({"FREQ": "DAILY", "INTERVAL": "2"})
+
+
+def test_a_single_event_is_never_routine():
+    text = ics("SUMMARY:Egzamin\nDTSTART:20260903T090000Z")
+    assert not events_in(text, zone=ZONE, since=NOW.astimezone(ZONE), days=7)[0].routine
+
+
+def test_a_feed_that_fails_becomes_a_line_not_an_exception():
+    class Broken(Calendars):
+        def fetch(self, url: str) -> str:
+            raise urllib.error.HTTPError(url, 403, "Forbidden", Message(), None)
+
+    broken = Broken((Feed("student", "https://usos.pl/ics"),), tz="Europe/Warsaw")
+    found = broken.upcoming(NOW)
+    assert found.read == 0
+    assert found.events == ()
+    assert found.errors == ("student: HTTP 403",)
+
+
+def test_short_reason_is_one_line_and_never_carries_the_url():
+    assert short(TimeoutError()) == "таймаут"
+    assert short(urllib.error.URLError("no route")).startswith("сеть:")
+    assert short(ValueError("а\nб")) == "ValueError: а б"

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

@@ -0,0 +1,206 @@
+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")
+
+
+def at(text: str) -> datetime:
+    return datetime.fromisoformat(text).replace(tzinfo=ZONE)
+
+
+def test_switch_defaults_to_on_and_only_explicit_off_stops_it():
+    assert enabled(None)
+    assert enabled("# досуг\n\nничего про выключатель")
+    assert enabled("досуг: вкл")
+    assert not enabled("# досуг\n\nдосуг: выкл\nсутки: 2026-09-08")
+    assert not enabled("досуг: off")
+
+
+def test_day_starts_at_noon():
+    assert day_of(at("2026-09-08 12:00")) == "2026-09-08"
+    assert day_of(at("2026-09-08 23:30")) == "2026-09-08"
+    assert day_of(at("2026-09-09 03:00")) == "2026-09-08"
+    assert day_of(at("2026-09-09 11:59")) == "2026-09-08"
+    assert day_of(at("2026-09-09 12:00")) == "2026-09-09"
+
+
+def test_active_window_ticks_hourly_and_quiet_window_only_by_plan():
+    hours = tick_hours(QUIET_TICKS)
+    assert hours[0] == 12
+    assert len(hours) == 20
+    assert all(h in hours for h in (12, 18, 23, 0, 3))
+    assert [h for h in hours if quiet_hour(h)] == [4, 6, 8, 10]
+    assert 5 not in hours and 11 not in hours
+    assert tick_hours((5, 7))[-2:] == (5, 7)
+
+
+def test_plan_is_read_from_the_file_for_todays_day_only():
+    text = (
+        "# досуг\n\n"
+        "досуг: вкл\n"
+        "сутки: 2026-09-08\n"
+        "тихие часы: 05, 07, 09, 11\n"
+        "мои часы: 13, 16, 19, 22, 01, 05, 09\n"
+    )
+    plan = plan_of(text, "2026-09-08")
+    assert plan.written
+    assert plan.quiet == (5, 7, 9, 11)
+    assert plan.mine == (13, 16, 19, 22, 1, 5, 9)
+
+    stale = plan_of(text, "2026-09-09")
+    assert not stale.written
+    assert stale.quiet == QUIET_TICKS
+
+
+def test_missing_plan_falls_back_to_defaults():
+    plan = plan_of(None, "2026-09-08")
+    assert not plan.written
+    assert plan.quiet == QUIET_TICKS
+    assert len(plan.mine) == MINE_MIN
+    assert set(plan.mine) <= set(tick_hours(plan.quiet))
+
+
+def test_short_plan_is_topped_up_to_the_guaranteed_minimum():
+    text = "сутки: 2026-09-08\nмои часы: 14, 20\n"
+    plan = plan_of(text, "2026-09-08")
+    assert plan.written
+    assert len(plan.mine) == MINE_MIN
+    assert 14 in plan.mine and 20 in plan.mine
+    assert plan.mine == tuple(sorted(plan.mine, key=tick_hours(plan.quiet).index))
+
+
+def test_unreachable_hours_are_dropped_from_the_plan():
+    text = "сутки: 2026-09-08\nтихие часы: 04, 06, 08, 10\nмои часы: 05, 11, 14\n"
+    plan = plan_of(text, "2026-09-08")
+    assert 5 not in plan.mine and 11 not in plan.mine
+    assert 14 in plan.mine and len(plan.mine) == MINE_MIN
+
+
+def test_brief_names_the_type_and_counts_spent_slots():
+    plan = Plan(
+        day="2026-09-08",
+        quiet=QUIET_TICKS,
+        mine=(13, 15, 18, 21, 0, 2, 6),
+        written=True,
+    )
+    text = brief(at("2026-09-08 18:00"), plan)
+    assert "Тип: досуг" in text
+    assert "израсходовано 3 из 7" in text
+    assert "впереди 21, 00, 02, 06" in text
+    assert "Сутки заканчиваются через 18 ч" in text
+    assert "Задания нет" in text
+    assert "Разложи" not in text
+
+    mixed = brief(at("2026-09-08 19:00"), plan)
+    assert "Тип: смешанный" in mixed
+    assert "израсходовано 3 из 7" in mixed
+
+
+def test_first_tick_of_the_day_is_the_planning_one():
+    text = brief(at("2026-09-08 12:00"), plan_of(None, "2026-09-08"))
+    assert "Первый тик суток" in text
+    assert "расписания на эти сутки нет" in text.lower()
+    assert str(MINE_MIN) in text
+
+
+def test_last_night_tick_says_nothing_is_left_ahead():
+    plan = Plan(day="2026-09-08", quiet=QUIET_TICKS, mine=(13, 6), written=True)
+    text = brief(at("2026-09-09 06:00"), plan)
+    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 ("мета/бобер", "💬 чаты", "📅 дни", "👤 люди"):
+    try:
-        (root / d).mkdir(parents=True)
+        for d in ("мета/бобер", "💬 чаты", "📅 дни", "👤 люди"):
-    (root / "💬 чаты/старый.md").write_text("x")
+            (root / d).mkdir(parents=True)
-    (root / "📅 дни/2026-08-29.md").write_text("x")
+        (root / "💬 чаты/старый.md").write_text("x")
-    return root
+        (root / "📅 дни/2026-08-29.md").write_text("x")
+        yield root
+    finally:
+        shutil.rmtree(root, ignore_errors=True)
 
 
 @pytest.fixture

tests/test_recall.py

@@ -4,6 +4,8 @@ from pathlib import Path
 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,
@@ -11,6 +13,7 @@ from beaver_agent.memory.recall import (
     frontmatter_aliases,
     mentions,
     notes_head,
+    routine_names,
 )
 
 
@@ -22,7 +25,7 @@ def _card(path: Path, aliases: list[str] | None = None) -> None:
     )
 
 
-def _vault(tmp_path: Path) -> Recall:
+def _vault(tmp_path: Path, calendar: Calendars | None = None) -> Recall:
     people = tmp_path / "👤 люди"
     _card(people / "личное" / "Зина.md", ["Зина"])
     _card(people / "личное" / "Прохор.md", ["Прохор Тестов"])
@@ -68,6 +71,7 @@ def _vault(tmp_path: Path) -> Recall:
         diary_dir=diary,
         boards_dir=boards,
         tz="Europe/Warsaw",
+        calendar=calendar,
     )
 
 
@@ -164,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")
+    text = (tmp_path / "реплики" / "2026-09-01.md").read_text(encoding="utf-8")
-    assert text.startswith("# реплики Бобра, 2026-09\n")
+    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:
@@ -186,3 +205,129 @@ def test_notes_head_picks_sections_for_the_seed(tmp_path: Path) -> None:
     assert notes_head(recall.notes_dir / "нет.md", ("сейчас",)) is None
     short = notes_head(path, ("сейчас", "паттерны"), cap=2)
     assert short is not None and short.endswith("… ещё 3 строк в файле")
+
+
+def _ics(*events: str) -> str:
+    body = "".join(f"BEGIN:VEVENT\n{e}\nEND:VEVENT\n" for e in events)
+    return f"BEGIN:VCALENDAR\nVERSION:2.0\n{body}END:VCALENDAR\n"
+
+
+def _calendar(text: str | None) -> Calendars:
+    """Фид, который отдаёт готовый ical; None - фид, который падает."""
+
+    class Fake(Calendars):
+        def fetch(self, url: str) -> str:
+            if text is None:
+                raise OSError("фид не ответил")
+            return text
+
+    return Fake((Feed("личный", "https://cal.example/x.ics"),), tz="Europe/Warsaw")
+
+
+def _daily(title: str, clock: str) -> str:
+    return f"SUMMARY:{title}\nDTSTART;TZID=Europe/Warsaw:20260902T{clock}\nRRULE:FREQ=DAILY"
+
+
+SINGLES = (
+    "SUMMARY:Созвон\nDTSTART:20260902T160000Z",
+    "SUMMARY:Врач\nDTSTART:20260903T090000Z",
+    "SUMMARY:Analiza matematyczna II - Egzamin\nDTSTART;VALUE=DATE-TIME:20260905T110000\n"
+    "DESCRIPTION:Sala: 3\\nA23 - CW\\n\nLOCATION:ul. Piotrowo 2\\, Poznań",
+    "SUMMARY:за окном\nDTSTART:20260925T080000Z",
+)
+ROUTINE = (
+    _daily("Завтрак", "080000"),
+    _daily("Обед", "150000"),
+    _daily("Ужин", "200000"),
+    _daily("Перекус", "180000"),
+    _daily("Wind down", "223000"),
+)
+BUSY = _ics(*SINGLES, *ROUTINE)
+
+
+def _section(recall: Recall, now: datetime, text: str = "привет") -> list[str]:
+    block = recall.block(RecallContext(text=text, kind="master", now=now))
+    assert block is not None
+    return [ln for ln in block.splitlines() if "календар" in ln or ln.startswith("  -")]
+
+
+def test_calendar_shows_every_single_event_and_folds_the_daily_routine(
+    tmp_path: Path,
+) -> None:
+    recall = _vault(tmp_path, _calendar(BUSY))
+    now = datetime(2026, 9, 1, 12, 0, tzinfo=UTC)
+    lines = _section(recall, now)
+    assert lines == [
+        "🗓 календарь (7 дней), разовых 3, повседневных 31, данные на 2026-09-01 14:00:",
+        "  - 09-02 18:00 Созвон",
+        "  - 09-03 11:00 Врач",
+        "  - 09-05 11:00 Analiza matematyczna II - Egzamin · Sala: 3, ul. Piotrowo 2, Poznań",
+        "  - повседневных повторов: 31 (Завтрак, Обед, Перекус, Ужин, Wind down)",
+    ]
+    # секция дневная, как и сроки досок: второй конверт за те же сутки её не несёт
+    again = recall.block(RecallContext(text="и ещё", kind="master", now=now))
+    assert again is None or "календарь" not in again
+
+
+def test_no_amount_of_routine_can_push_out_a_single_event(tmp_path: Path) -> None:
+    noise = tuple(_daily(f"быт {i}", f"{i:02d}0000") for i in range(9, 24))
+    recall = _vault(tmp_path, _calendar(_ics(*SINGLES, *noise)))
+    now = datetime(2026, 9, 1, 12, 0, tzinfo=UTC)
+    lines = _section(recall, now)
+    assert lines[0].startswith("🗓 календарь (7 дней), разовых 3, повседневных 96")
+    assert [ln for ln in lines if "Egzamin" in ln]
+    assert (
+        len([ln for ln in lines if ln.startswith("  - ")]) == 4
+    )  # 3 разовых + свёртка
+    assert lines[-1].startswith("  - повседневных повторов: 96")
+    assert "и др." in lines[-1]
+
+
+def test_routine_line_counts_and_names_up_to_five(tmp_path: Path) -> None:
+    events = [
+        Event(
+            start=datetime(2026, 9, 2, 8, tzinfo=UTC),
+            title=t,
+            place="",
+            all_day=False,
+            routine=True,
+        )
+        for t in ("Завтрак", "Обед", "Завтрак", "Ужин")
+    ]
+    assert routine_names(events) == "Завтрак, Обед, Ужин"
+    assert routine_names(events, limit=2) == "Завтрак, Обед и др."
+
+
+def test_calendar_section_is_printed_even_when_the_week_is_empty(
+    tmp_path: Path,
+) -> None:
+    recall = _vault(
+        tmp_path, _calendar(_ics("SUMMARY:потом\nDTSTART:20261101T080000Z"))
+    )
+    now = datetime(2026, 9, 1, 12, 0, tzinfo=UTC)
+    block = recall.block(RecallContext(text="просто привет", kind="master", now=now))
+    assert block is not None
+    assert (
+        "🗓 календарь (7 дней): событий нет, данные на 2026-09-01 14:00"
+        in block.splitlines()
+    )
+
+
+def test_calendar_failure_shows_up_in_the_envelope_instead_of_disappearing(
+    tmp_path: Path,
+) -> None:
+    recall = _vault(tmp_path, _calendar(None))
+    now = datetime(2026, 9, 1, 12, 0, tzinfo=UTC)
+    block = recall.block(RecallContext(text="просто привет", kind="master", now=now))
+    assert block is not None
+    assert "🗓 календарь: ОШИБКА личный: OSError: фид не ответил" in block.splitlines()
+    # ветке справка календарь не носит, как и сроки досок
+    branch = recall.block(RecallContext(text="просто привет", kind="branch", now=now))
+    assert branch is None
+
+
+def test_without_configured_feeds_there_is_no_calendar_section(tmp_path: Path) -> None:
+    recall = _vault(tmp_path)
+    now = datetime(2026, 9, 1, 12, 0, tzinfo=UTC)
+    block = recall.block(RecallContext(text="просто привет", kind="master", now=now))
+    assert block is not None and "календарь" not in block

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"])

tests/test_voice.py

@@ -0,0 +1,308 @@
+import asyncio
+import json
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from typing import Any, cast
+
+import httpx
+import pytest
+from beaver_gateway.app import AgentRegistry, McpRegistry
+from beaver_gateway.agents.claude import ClaudeAgent, ClaudeOptions
+from beaver_gateway.conversations.envelope import RecallContext
+from beaver_gateway.events.stream import (
+    build_content_block_stop,
+    build_message_delta,
+    build_message_start,
+    build_message_stop,
+    build_text_block_start,
+    build_text_delta,
+)
+from beaver_gateway.conversations.texts import UserSaid
+from beaver_gateway.frontends.base import GatewayRuntime
+from beaver_gateway.security.auth import TokenStore, scopes_with
+
+from beaver_agent.memory.recall import Recall, ReplyLog
+from beaver_agent.voice import AGENT, KEY, TITLE, VoiceFrontend, rotate
+from beaver_agent.voice.texts import ROTATED
+
+VOICE = {"Authorization": "Bearer voice-key"}
+OPS = {"Authorization": "Bearer ops-key"}
+ASK = {
+    "room": "andreii",
+    "device": "esp32-1",
+    "request_id": "3fd0d6ed-a81b-489c-a1d2-3b97ba84892b",
+    "content": "ало клод как дела",
+}
+PLAIN = {**ASK, "stream": False}
+"""То же, но одним JSON: без поля фронтенд стримит."""
+
+
+@dataclass
+class Conv:
+    external_id: str = "conv-1"
+    agent_name: str = AGENT
+    kind: str = "branch"
+    title: str = TITLE
+    status: str = "open"
+    last_user_activity_at: datetime | None = None
+    flags: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class Binding:
+    frontend: str
+    external_id: str
+    visible: bool = True
+
+
+class FakeConversations:
+    """Ровно те методы сервиса, которыми пользуется голосовое окно."""
+
+    def __init__(self, bound: Conv | None = None) -> None:
+        self.conv = bound
+        self.bindings_of: dict[str, list[Binding]] = {}
+        self.said: list[tuple[str, str]] = []
+        self.prompts: list[str] = []
+        self.bound: list[tuple[str, str, str]] = []
+        self.closed: list[str] = []
+        self.spawned: list[dict[str, Any]] = []
+        self.reply = "живу, слушаю"
+        self.spawn_hook = None
+
+    async def find_bound(self, *, frontend: str, external_id: str) -> Conv | None:
+        if self.conv is None or frontend != "voice" or external_id != KEY:
+            return None
+        return self.conv
+
+    async def spawn(self, **kwargs: Any) -> Conv:
+        self.spawned.append(kwargs)
+        conv = Conv(external_id=f"conv-{len(self.spawned) + 1}")
+        self.conv = conv
+        binding = kwargs.get("binding")
+        if binding:
+            self.bindings_of[conv.external_id] = [Binding(*binding)]
+        return conv
+
+    async def bind(self, conv: Conv, *, frontend: str, external_id: str) -> None:
+        self.bound.append((conv.external_id, frontend, external_id))
+
+    async def bindings(self, conv: Conv) -> list[Binding]:
+        return self.bindings_of.get(conv.external_id, [])
+
+    async def close(self, conv: Conv) -> None:
+        conv.status = "closed"
+        self.closed.append(conv.external_id)
+
+    async def say(self, conv: Conv, text: str) -> None:
+        self.said.append((conv.external_id, text))
+
+    async def pending_seed(self, conv: Conv) -> str | None:
+        return conv.flags.pop("seed", None)
+
+    async def run_text_turn(self, conv: Conv, prompt: str, **_: Any) -> tuple[str, Any]:
+        self.prompts.append(prompt)
+        return self.reply, None
+
+    async def turn(self, conv: Conv, *, messages: list[Any], **_: Any) -> Any:
+        self.prompts.append(messages[0]["content"])
+        yield build_message_start(message_id="m", model="haiku")
+        yield build_text_block_start(0)
+        for chunk in ("живу, ", "слушаю"):
+            yield build_text_delta(0, chunk)
+        yield build_content_block_stop(0)
+        yield build_message_delta(stop_reason="end_turn")
+        yield build_message_stop()
+
+
+class Bus:
+    def __init__(self) -> None:
+        self.events: list[dict[str, Any]] = []
+
+    def publish(self, type_: str, **data: Any) -> dict[str, Any]:
+        event = {"type": type_, **data}
+        self.events.append(event)
+        return event
+
+
+def stand(conversations: FakeConversations) -> tuple[VoiceFrontend, GatewayRuntime]:
+    agent = ClaudeAgent(
+        name=AGENT,
+        model="claude-haiku-4-5-20251001",
+        cwd=".",
+        system_prompt="голос",
+        kinds=("branch",),
+        options=ClaudeOptions(tools=()),
+    )
+    frontend = VoiceFrontend(agent=AGENT)
+    runtime = GatewayRuntime(
+        agents=AgentRegistry([agent]),
+        mcps=McpRegistry([]),
+        backends={},
+        token_store=TokenStore(
+            bootstrap={"voice": "voice-key", "ops": "ops-key"},
+            bootstrap_scopes={"voice": "voice", "ops": "api"},
+        ),
+        db=cast("Any", None),
+        frontends=(frontend,),
+        conversations=conversations,
+        bus=Bus(),
+        scopes=scopes_with(["voice"]),
+    )
+    frontend.configure(runtime)
+    return frontend, runtime
+
+
+def client(frontend: VoiceFrontend) -> httpx.AsyncClient:
+    return httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=cast("Any", frontend.app())),
+        base_url="http://t",
+    )
+
+
+async def test_the_payload_is_answered_and_its_fields_come_back() -> None:
+    conversations = FakeConversations()
+    frontend, _ = stand(conversations)
+    async with client(frontend) as http:
+        response = await http.post("/", json=PLAIN, headers=VOICE)
+    assert response.status_code == 200
+    assert response.json() == {
+        "request_id": ASK["request_id"],
+        "room": "andreii",
+        "device": "esp32-1",
+        "reply": "живу, слушаю",
+        "conversation": "conv-2",
+    }
+    assert conversations.prompts == ["[andreii · esp32-1] ало клод как дела"]
+
+
+async def test_the_first_ask_opens_the_branch_and_the_next_one_keeps_it() -> None:
+    conversations = FakeConversations()
+    frontend, _ = stand(conversations)
+    async with client(frontend) as http:
+        first = (await http.post("/", json=PLAIN, headers=VOICE)).json()
+        again = (
+            await http.post("/", json={**PLAIN, "content": "а время?"}, headers=VOICE)
+        ).json()
+    assert first["conversation"] == again["conversation"]
+    assert len(conversations.spawned) == 1
+    spawn = conversations.spawned[0]
+    assert spawn["kind"] == "branch"
+    assert spawn["agent"] == AGENT
+    assert spawn["title"] == TITLE
+    assert spawn["binding"] is None
+    assert conversations.bound == [(first["conversation"], "voice", KEY)]
+
+
+async def test_the_question_lands_in_the_branch_first() -> None:
+    conversations = FakeConversations()
+    frontend, _ = stand(conversations)
+    async with client(frontend) as http:
+        await http.post("/", json=PLAIN, headers=VOICE)
+    assert conversations.said == [("conv-2", "🎤 andreii · esp32-1\nало клод как дела")]
+
+
+async def test_two_rooms_at_once_open_one_branch() -> None:
+    conversations = FakeConversations()
+    frontend, _ = stand(conversations)
+    async with client(frontend) as http:
+        await asyncio.gather(
+            http.post("/", json=PLAIN, headers=VOICE),
+            http.post("/", json={**PLAIN, "room": "кухня"}, headers=VOICE),
+        )
+    assert len(conversations.spawned) == 1
+
+
+async def test_only_a_voice_key_opens_the_route() -> None:
+    frontend, _ = stand(FakeConversations())
+    async with client(frontend) as http:
+        assert (await http.post("/", json=ASK)).status_code == 401
+        assert (await http.post("/", json=ASK, headers=OPS)).status_code == 403
+
+
+async def test_a_body_without_the_words_is_a_400() -> None:
+    frontend, _ = stand(FakeConversations())
+    async with client(frontend) as http:
+        for missing in ("room", "device", "content"):
+            body = {k: v for k, v in ASK.items() if k != missing}
+            response = await http.post("/", json=body, headers=VOICE)
+            assert response.status_code == 400
+            assert missing in response.json()["error"]
+
+
+async def test_the_night_keeps_the_topic_and_starts_the_branch_over() -> None:
+    old = Conv(last_user_activity_at=datetime.now(UTC))
+    conversations = FakeConversations(bound=old)
+    conversations.bindings_of["conv-1"] = [Binding("telegram", "42")]
+    new = await rotate(cast("Any", conversations))
+    assert new is not None
+    assert conversations.spawned[0]["binding"] == ("telegram", "42")
+    assert conversations.bound == [(new.external_id, "voice", KEY)]
+    assert conversations.closed == ["conv-1"]
+    assert conversations.said == [(new.external_id, ROTATED)]
+
+
+async def test_a_branch_nobody_spoke_in_is_left_alone() -> None:
+    conversations = FakeConversations(bound=Conv())
+    assert await rotate(cast("Any", conversations)) is None
+    assert conversations.spawned == []
+
+
+def test_the_voice_agent_gets_no_recall_and_no_reply_log(tmp_path) -> None:
+    recall = Recall(
+        vault=tmp_path,
+        people_dir=tmp_path / "люди",
+        notes_dir=tmp_path / "записки",
+        diary_dir=tmp_path / "дни",
+        boards_dir=tmp_path / "доски",
+        mute=frozenset({AGENT}),
+    )
+    now = datetime.now(UTC)
+    assert (
+        recall.block(RecallContext(text="Прохор", kind="branch", now=now, agent=AGENT))
+        is None
+    )
+    log = ReplyLog(tmp_path / "реплики", mute=frozenset({AGENT}))
+    log.write(
+        UserSaid(
+            conversation_id="c",
+            kind="branch",
+            title=TITLE,
+            text="что там у Прохор",
+            at=now,
+            agent=AGENT,
+        )
+    )
+    assert not (tmp_path / "реплики").exists()
+
+
+async def test_the_answer_streams_when_the_body_does_not_say_otherwise() -> None:
+    conversations = FakeConversations()
+    frontend, _ = stand(conversations)
+    frames: list[tuple[str, dict[str, Any]]] = []
+    async with (
+        client(frontend) as http,
+        http.stream("POST", "/", json=ASK, headers=VOICE) as sse,
+    ):
+        assert sse.status_code == 200
+        assert sse.headers["content-type"].startswith("text/event-stream")
+        buffer = "".join([chunk async for chunk in sse.aiter_text()])
+    for block in buffer.split("\n\n"):
+        lines = [line for line in block.splitlines() if line]
+        if len(lines) == 2 and lines[0].startswith("event: "):
+            frames.append((lines[0][7:], json.loads(lines[1][6:])))
+    assert [name for name, _ in frames] == ["delta", "delta", "done"]
+    assert [f["text"] for _, f in frames[:2]] == ["живу, ", "слушаю"]
+    assert frames[-1][1]["reply"] == "живу, слушаю"
+    assert frames[-1][1]["request_id"] == ASK["request_id"]
+
+
+async def test_the_flag_is_read_as_a_word_not_as_a_truthy_string() -> None:
+    frontend, _ = stand(FakeConversations())
+    cases = ((True, True), ("true", True), (False, False), ("false", False), (0, False))
+    async with client(frontend) as http:
+        for value, streams in cases:
+            response = await http.post(
+                "/", json={**ASK, "stream": value}, headers=VOICE
+            )
+            kind = response.headers["content-type"]
+            assert kind.startswith("text/event-stream") is streams, (value, kind)

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/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/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/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/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/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/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/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" },
-    { 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" },
 ]
 
 [[package]]