@mikitasazan/notify 1.15.2 → 1.16.0

package/README.md

@@ -1,7 +1,7 @@
 # @mikitasazan/notify
 
 Единая типизированная отправка Telegram-уведомлений: **форум на проект**,
-внутри вкладки «⚙️ Ops» (роботы) и «💬 Dev» (люди), один бот, восемь типов
+внутри вкладки «⚙️ Ops» (роботы) и «💬 Dev» (люди), один бот, семь типов
 событий. Заменяет 18 разных имён переменных и 4+ независимых реализации
 `jq | curl`, что были в playhub, arvent, game-publisher до 26.07.2026.
 
@@ -84,10 +84,22 @@ notify report --project playhub --json < payload.json   # весь объект
 | `ci` | итог CI на master | `project`, `status` |
 | `pr` | событие пул-реквеста | `project`, `action`, `number`, `title` |
 | `issue` | событие задачи | `project`, `action`, `number`, `title` |
-| `incident` | приложение сломалось прямо сейчас | `project`, `title` |
-| `session` | рабочая сессия на маке в беде | `project`, `action` |
+| `incident` | что-то встало и ждёт тебя прямо сейчас: приложение, сейф, рабочая сессия на маке | `project`, `title` |
+| `session` | УСТАРЕЛ, это `incident`: карточка выходит с тегом `#incident`, имя собирается из `action` — `Claude session is burning the limit` | `project`, `action` |
 | `heartbeat_miss` | УСТАРЕЛ, молчание — это `job --status silent` | `project`, `job` |
 
+Скобка у слова типа говорит одним словом, чем кончилось: `Deploy (OK)`,
+`CI (Fail)`, `Job (Off)`, `Job (Silent)`, `Issue (Assigned)`, `PR (Merged)`.
+Она стоит там, где у типа исходов больше одного. У `incident` состояние одно,
+поэтому его скобка называет МЕСТО, где горит: `Incident (Vault)`,
+`Incident (Session)` — слово из `--scope`, без него имя проекта. У `report`
+исхода нет вовсе, и скобку занимает день: `Report (2026-08-23 / 2026-08-22)`.
+
+У `job` есть ещё два необязательных флага: `--via` — где задача крутилась
+(`mac`, `vps`, `actions`), это идёт строкой `Via: Mac` первой под второй
+строкой; и `--took` — сколько прогон занял, твоими же словами (`4m 12s`),
+строкой `Took:` под причиной. Не передал — строки нет.
+
 Отдельного вида «файл» нет: `--path` применим к ЛЮБОМУ событию, и тогда
 карточка едет подписью к вложению (подпись у Telegram ограничена 1024 знаками,
 а не 4000). Слово `file` осталось псевдонимом и собирает `report` с вложением —

package/dist/cli-flags.js

@@ -10,13 +10,13 @@
  */
 export const KNOWN_FLAGS = new Set([
     'action', 'actor', 'assignee', 'author', 'body', 'branch', 'commit',
-    'id', 'opened', 'reason', 'workdir',
+    'id', 'opened', 'reason', 'scope', 'workdir',
     'check', 'command', 'command-note', 'commit-author', 'commit-body', 'commit-title', 'commit-url',
     'detail', 'detail-label',
     'expected', 'filename', 'item',
     'item-group', 'job', 'key', 'last-seen', 'line', 'logs', 'note',
     'aside', 'number', 'path', 'period', 'project', 'reviewer', 'stat', 'status',
-    'target', 'title', 'url', 'via', 'workflow-name', 'workflow-url',
+    'target', 'title', 'took', 'url', 'via', 'workflow-name', 'workflow-url',
     // Flags with no value. They live here too, so parsing and the list do not drift apart.
     'json', 'recovered', 'dry-run'
 ]);

package/dist/cli.js

@@ -11,11 +11,12 @@
  * is no scenario where a deploy should fail because a message did not send.
  *
  *   notify deploy   --project playhub --status ok --commit "msg" [--commit-url "..."] --url "..."
- *   notify job      --project playhub --job "Game import" --status ok --stat "added=5"
+ *   notify job      --project playhub --job "Game import" --status ok --stat "added=5" [--via vps] [--took "4m 12s"]
  *   notify report   --project playhub --title "Daily summary" --line "Games=1284"
- *   notify ci       --project arvent  --status fail --branch master --actor saz_sam
+ *   notify ci       --project arvent  --status fail --branch master
  *   notify pr       --project arvent  --action opened --number 142 --title "..."
  *   notify incident --project arvent  --title "Redis is unreachable" --detail "$ERR"
+ *   notify session  --project mac-config --action "burning the limit"   # DEPRECATED alias of incident
  *   notify file     --project arvent  --title "Full dialogues" --path ./out.txt [--filename name.txt]
  *   notify <type> [--key stable-key]   # the task's key on the card's last line
  *   notify <type> --json < payload.json   # the whole event object on stdin
@@ -23,7 +24,7 @@
  */
 import { readFileSync } from 'node:fs';
 import { KNOWN_FLAGS } from "./cli-flags.js";
-import { render } from "./render.js";
+import { render, sessionTitle } from "./render.js";
 import { lintCard } from "./lint.js";
 import { notify } from "./send.js";
 import { ROUTES } from "./routes.js";
@@ -272,6 +273,11 @@ else {
                 job: one('job') ?? '(no name)',
                 status: jobStatus(),
                 aside: one('aside'),
+                // Where it ran and how long it took: `--via mac`, `--took '4m 12s'`.
+                // `--took` fills `duration` — the flag is the sender's word for the
+                // question ("how long did it take?"), the field is the card's.
+                via: one('via'),
+                duration: one('took'),
                 expected: one('expected'),
                 lastSeen: one('last-seen'),
                 stats: pairs('stat'),
@@ -344,30 +350,30 @@ else {
                 url: one('url')
             };
             break;
+        // DEPRECATED since 1.16.0. `notify session` is an alias of `notify
+        // incident`: the two cards said one thing — something is stuck and waits
+        // for you — under two names and the same 🚨. The subcommand still works
+        // because the runaway guard on this Mac calls it, and it builds an
+        // incident whose title names the session: `Claude session is burning the
+        // limit`. `--status` is read no more; an incident has one state.
         case 'session':
-            event = {
-                type: 'session',
-                project: project(),
-                action: one('action') ?? 'in trouble',
-                id: one('id'),
-                workdir: one('workdir'),
-                reason: one('reason'),
-                opened: one('opened'),
-                command: one('command'),
-                commandNote: one('command-note'),
-                // Only two states here, so `disabled` must not leak in from jobStatus.
-                status: jobStatus() === 'ok' ? 'ok' : 'fail'
-            };
-            break;
         case 'incident':
             event = {
                 type: 'incident',
                 project: project(),
-                title: one('title') ?? '(no title)',
+                title: command === 'session'
+                    ? sessionTitle(one('action') ?? 'in trouble')
+                    : (one('title') ?? '(no title)'),
+                scope: command === 'session' ? 'Session' : one('scope'),
                 detail: one('detail'),
                 items: items(),
                 logs: one('logs'),
-                url: one('url')
+                url: one('url'),
+                workdir: one('workdir'),
+                reason: one('reason'),
+                opened: one('opened'),
+                command: one('command'),
+                commandNote: one('command-note')
             };
             break;
         case 'heartbeat_miss':

package/dist/events.d.ts

@@ -141,13 +141,32 @@ export type NotifyEvent = Keyed & (
      */
     status: 'ok' | 'fail' | 'disabled' | 'silent';
     /**
-     * The one qualifier the name needs to be readable on its own, printed in
-     * brackets right after it: `Yandex game import (reporting again)`. It is
-     * the same slot a report uses for the day it covers. Anything that is a
-     * FACT about the job goes in a row of its own; this is for the word that
-     * finishes the name.
+     * The one sentence that says why this card exists at all («reporting
+     * again»). It has no bracket of its own any more — the bracket on a job
+     * carries the outcome — and prints in the `Reason:` row, but only when
+     * the sender left `note` empty; a real reason is never duplicated.
+     * The field stays for the senders that still pass it.
      */
     aside?: string;
+    /**
+     * WHERE the job ran, one word from the sender: `mac` (launchd on this
+     * Mac), `vps` (a cron on the server), `actions` (GitHub Actions). Any
+     * other word is passed through and capitalised. It prints as a `Via:`
+     * row directly under the type line — it is a fact ABOUT the run, and
+     * the bracket on the type word belongs to the outcome. Until now the
+     * Mac's launchd, a
+     * VPS cron, GitHub Actions and the silence watchdog all arrived under
+     * one bare `#job` tag and only memory told them apart; deploy has said
+     * «via GitHub Actions» from the start, and job now does too
+     * (03.09.2026).
+     */
+    via?: string;
+    /**
+     * How long the run took, in the sender's own words: `4m 12s`, `38s`.
+     * Printed as a `Took:` row right under the reason. Absent — no row:
+     * a job that does not measure itself must not be made to say `0s`.
+     */
+    duration?: string;
     /** How often the task owes a check-in — for `silent` and for recovering from it. */
     expected?: string;
     /** When it was last seen. */
@@ -327,22 +346,50 @@ export type NotifyEvent = Keyed & (
     /** A local path to the logs (not a URL — renders monospaced, to copy, not to click). */
     logs?: string;
     url?: string;
+    /**
+     * The rest of this block arrived with the `session` type, which was
+     * folded into `incident` on 03.09.2026. Two types said one thing —
+     * something is stuck and waits for you — under the same 🚨, and the
+     * owner cut it to one. The fields are not session-only in meaning: a
+     * stuck deploy has a working directory too, and any alarm can carry a
+     * command that gets you out of it.
+     */
+    /**
+     * WHERE it burns, one word, printed in the bracket on the type word:
+     * `Incident (Vault):`, `Incident (Session):`. The owner (03.09.2026):
+     * the bracket should throw the place at the eye before anything is
+     * read. Not an outcome — an incident has one — so this is the one
+     * bracket that names a place. Absent → the project name, capitalised.
+     */
+    scope?: string;
+    /** Which working copy this is about, when several of them look alike. */
+    workdir?: string;
+    /** One line of measurement: what the guard saw. */
+    reason?: string;
+    /**
+     * A long quotation of someone's own writing — the line he opened a
+     * session with. Quoted, never a field: a field would clip it to one
+     * short line, which is exactly how the first version of that card lost
+     * it.
+     */
+    opened?: string;
+    /** A command for him to run, monospaced so Telegram makes it copyable. */
+    command?: string;
+    /** WHAT that command does — see the note on `job.commandNote`. */
+    commandNote?: string;
 }
 /**
- * A working session on this Mac is in trouble — not a job, not a workflow.
- * It went out as `job` at first and read wrong: `#job` promises something
- * scheduled that ran and failed, and the owner rightly asked what a burning
- * session was doing under that heading.
- *
- * What makes it its own type rather than an `incident`: a session has an
- * identity nothing else here has — an id, a working directory, and the line
- * he typed to start it, which is the ONLY thing that tells two of his open
- * sessions apart.
+ * DEPRECATED since 1.16.0: send an `incident`. The type is still ACCEPTED
+ * and renders as one — the runaway guard on this Mac
+ * (`context-runaway-notify.sh`) sends exactly this and must keep working —
+ * but `#session` is never printed again: the card comes out `#incident`.
+ * It was a separate type because a session has an id, a working directory
+ * and the line he typed to open it; `incident` carries all three now.
  */
  | {
     type: 'session';
     project: Project;
-    /** What happened, as the second line reads it: `Session: burning the limit`. */
+    /** What happened. Line 2 builds the incident's name out of it: `burning the limit` → `Claude session is burning the limit`. */
     action: string;
     /** The session's own id. Never printed as a field — he cannot type it or search it; it only reaches the card inside the `command`'s `rm`. */
     id?: string;
@@ -360,7 +407,11 @@ export type NotifyEvent = Keyed & (
     command?: string;
     /** WHAT that command does — see the note on `job.commandNote`. */
     commandNote?: string;
-    /** `fail` red, `ok` green — a session that recovered is not an alarm. */
+    /**
+     * Kept for old senders and no longer read: an incident is an alarm by
+     * definition, and no sender ever passed `ok` here — the runaway guard
+     * only ever sends the bad news.
+     */
     status?: 'fail' | 'ok';
 }
 /**

package/dist/events.js

@@ -73,8 +73,9 @@ export const iconFor = (e) => {
             // `undefined` at the head of line 2. Not knowing is itself a state the
             // package already has a word and a sound for.
             return JOB_ICON[e.status] ?? ICON.unknown;
+        // A session IS an incident since 03.09.2026 — same icon, same sound, same
+        // tag. It is listed separately only because the type name still exists.
         case 'session':
-            return e.status === 'ok' ? ICON.ok : ICON.alarm;
         case 'incident':
             return ICON.alarm;
         case 'heartbeat_miss':

package/dist/lint.js

@@ -36,8 +36,11 @@ const OUTCOMES = new Set(['ok', 'fail', 'off', 'unknown', 'info']);
  * Labels the template retired. Each one used to say what a neighbour said.
  * `Check` LEFT this list in v2.1: rule S brought it back as the standard
  * verification-command row. `Logs` stays retired — the new spelling is `Log`.
+ * `Via` left it on 03.09.2026: the bracket on the type word now says how the
+ * job ENDED, so where it ran has nowhere else to go and is a row again — and
+ * it never duplicated a neighbour, which is what this list is for.
  */
-const RETIRED = ['Title', 'Number', 'State', 'Via', 'Logs', 'Task', 'Id', 'Period'];
+const RETIRED = ['Title', 'Number', 'State', 'Logs', 'Task', 'Id', 'Period'];
 /**
  * Reads a finished card and returns what is wrong with it, in the owner's
  * terms. An empty array means the card obeys the standard.

package/dist/render.d.ts

@@ -59,6 +59,17 @@ export declare const clampMessage: (text: string, limit?: number, marker?: strin
  * the patterns contain no `<>&"`, so nothing the author typed can become a tag.
  */
 export declare const markdownToTelegram: (text: string) => string;
+/**
+ * A session has no name of its own, so the incident's title is built out of
+ * what happened to it: `burning the limit` → `Claude session is burning the
+ * limit`. That is the whole of what the separate `session` card ever said
+ * differently — every other row it had is an incident row now.
+ *
+ * The 36-character id is still not printed: he cannot type it, cannot search
+ * it and cannot act on it. It reaches the card only inside the `rm` command at
+ * the bottom, which is the one place it is of any use.
+ */
+export declare const sessionTitle: (action: string | undefined) => string;
 export declare const slug: (raw: string) => string;
 /**
  * The instance tag: exactly which concrete event this is (branch,

package/dist/render.js

@@ -127,6 +127,15 @@ const firstLine = (value) => {
     }
     return `${value.split('\n')[0]}…`;
 };
+/**
+ * The first value the sender actually filled in, trimmed; `undefined` when
+ * every one of them came in empty. Neither `??` nor `||` alone can do this:
+ * `??` keeps an empty string and so takes the fallback away, `||` still lets
+ * a whitespace-only one through to a visibly empty row or bracket. Both `''`
+ * and `'   '` reach us for real — from a `--json` payload and from a shell
+ * flag whose variable expanded to nothing.
+ */
+const filled = (...values) => values.map((v) => String(v ?? '').trim()).find((v) => v !== '');
 /**
  * A field: `<b>Label:</b> value` — a bold, capitalized label, a plain value.
  * `null` is dropped the same as `undefined`/`''` — the field's sources are
@@ -168,13 +177,14 @@ const fieldLink = (label, url, text) => {
 /** A monospace field — a path/command to copy, not a link. */
 const fieldCode = (label, value) => value ? `<b>${esc(cap(label))}:</b> <code>${esc(value)}</code>` : null;
 /**
- * The owner himself, under the two names the senders know him by. A people
- * row that names the reader is not news: on the 49 PR and issue cards of the
- * week of 25.08.2026 `Author:` was him on every one, and the single row that
- * ever said something was `Assignee: Ilja-Prihach`. So a person row is printed
- * only when the person is someone else (03.09.2026).
+ * People rows are printed ALWAYS, the owner included. They used to be
+ * suppressed when the login/handle was his own (`mikitasazan`/`chelsnebes`),
+ * on the theory that a row naming the reader is not news. In practice a card
+ * whose people rows vanish only for him reads as a card with a hole: he saw
+ * Issue #322 and PR #118 with no `Author:` at all and asked where the people
+ * had gone. Every card now carries the same set of rows, so an absent row
+ * means an empty field and nothing else (03.09.2026).
  */
-const OWNER = { github: 'mikitasazan', telegram: 'chelsnebes' };
 /**
  * A person field — Author, Assignee, Reviewer. Every one of them is a
  * GitHub login (`github-cards.py` reads it off `.user.login`/`.assignee.login`
@@ -192,31 +202,8 @@ const fieldPerson = (label, login) => {
         return null;
     }
     const oneLine = firstLine(login);
-    if (oneLine.toLowerCase() === OWNER.github) {
-        return null;
-    }
     return `<b>${esc(cap(label))}:</b> <a href="https://github.com/${esc(oneLine)}">${esc(oneLine)}</a>`;
 };
-/**
- * `Actor` on a CI card is a Telegram handle, not a GitHub login
- * (`nightly.yml`, step "Кто чинит" — "по «@chelsnebes» приходит уведомление
- * тому, кто чинит, по «mikitasazan» — нет"), so it links to Telegram, not
- * GitHub: `github.com/@chelsnebes` would open a page that does not exist.
- * Telegram DOES auto-link a bare `@handle` on its own, but the owner asked
- * for an explicit link like every other identifier on the card, not an
- * implicit one riding on a client behavior he cannot see from here.
- */
-const fieldTelegram = (label, handle) => {
-    if (!handle) {
-        return null;
-    }
-    const oneLine = firstLine(handle);
-    const bare = oneLine.replace(/^@/, '');
-    if (bare.toLowerCase() === OWNER.telegram) {
-        return null;
-    }
-    return `<b>${esc(cap(label))}:</b> <a href="https://t.me/${esc(bare)}">${esc(oneLine)}</a>`;
-};
 /**
  * A row that asks something FROM THE OWNER, rather than reports a fact. It
  * already stood last, set off by a blank line, and still read as an
@@ -685,11 +672,18 @@ const renderDeploy = (e) => {
         // The run URL rides on the name (03.09.2026): the thing you read is the
         // thing you tap. It spent three days in a `Source:` row at the bottom, and
         // the owner asked what that row was for when the name was right there.
-        typeLine(icon, 'Deploy', mechanism(e.workflowName, e.via), sourceUrl(e), e.status === 'fail' ? 'Fail' : 'OK'),
+        // The outcome word comes from the icon, not from a second reading of
+        // `status`: `fail ? 'Fail' : 'OK'` defaulted the opposite way from
+        // `iconFor` (`ok ? 🟢 : 🔴`), so any status outside {ok,fail} arrived as
+        // 🔴 `#fail` with the word `(OK)` beside it.
+        typeLine(icon, 'Deploy', mechanism(e.workflowName, e.via), sourceUrl(e), outcomeAside(e)),
         ...twoBlocks([field('Target', e.target), reason('Reason', e.note), field('Still red', e.stillRed ? `day ${e.stillRed}` : null)], [
+            // The body sits straight under the commit line, the people below it —
+            // the same shape as a PR or an issue. With `Author:` wedged between
+            // the two, the quote read as the author's words (03.09.2026).
             commitRow(e.commit, e.commitUrl, e.commitTitle),
-            fieldPerson('Author', e.commitAuthor),
-            bodyQuote(e.commitBody)
+            bodyQuote(e.commitBody),
+            fieldPerson('Author', e.commitAuthor)
         ])
     ]);
 };
@@ -697,6 +691,35 @@ const schedule = (expected, lastSeen, lastLabel) => {
     const rows = [field('Expected', expected), field(lastLabel, lastSeen)].filter((r) => r !== null);
     return rows.length > 0 ? ['', group('Schedule'), ...rows] : [];
 };
+/**
+ * `via` for display. The three words the senders actually use get an explicit
+ * spelling — `vps` upper-cased whole would read as a shout, `VPS` lower-cased
+ * as a typo — and anything else just gets its first letter raised, so a word
+ * nobody foresaw still prints as a word rather than being dropped.
+ */
+const VIA_NAMES = { mac: 'Mac', vps: 'VPS', actions: 'Actions' };
+const viaName = (via) => VIA_NAMES[via.trim().toLowerCase()] ?? via.trim().charAt(0).toUpperCase() + via.trim().slice(1);
+/**
+ * The bracket on the type word says HOW IT ENDED, in one word — the owner's
+ * decision of 03.09.2026: one slot, one meaning, on every type. It used to
+ * mean three different things at once — the outcome on deploy and CI, the day
+ * on a report, and (for one afternoon) the place of the run on a job — so the
+ * bracket could not be read without first knowing which card you were looking
+ * at. A job's outcome now reads the same way a deploy's does.
+ */
+const JOB_OUTCOME = {
+    ok: 'OK',
+    fail: 'Fail',
+    disabled: 'Off',
+    silent: 'Silent'
+};
+/**
+ * Where the job ran, as its own row directly under the type line. It spent one
+ * afternoon inside the bracket on the type word, which cost the bracket its
+ * single meaning; `Via:` is a fact ABOUT the run, and facts about the subject
+ * are what the rows under line 2 are for.
+ */
+const viaRow = (via) => via?.trim() ? field('Via', viaName(via)) : null;
 const renderJob = (e) => {
     const icon = iconFor(e);
     const hasItems = (e.items ?? []).length > 0;
@@ -715,8 +738,30 @@ const renderJob = (e) => {
         // The URL is on the name (03.09.2026). It went down to a `Source:` row in
         // v2.1 so the pointer could be SEEN — and came back, because the row's
         // only text was `workflow run`, the same two words on every card.
-        typeLine(icon, 'Job', e.job, sourceUrl(e), e.aside),
-        reason('Reason', e.note),
+        // `?? outcomeAside(e)` for the same reason `iconFor` defends itself: an
+        // untyped `--json` payload can carry a status outside the map or none at
+        // all, and `cap(undefined)` threw a TypeError instead of rendering a card.
+        // The word comes from the icon, so ❓ and `#unknown` say `(Unknown)`.
+        typeLine(icon, 'Job', e.job, sourceUrl(e), JOB_OUTCOME[e.status] ?? outcomeAside(e)),
+        // Where it ran comes first among the facts: it qualifies everything below
+        // it — the same reason, the same duration mean different things on the Mac
+        // and on the server.
+        viaRow(e.via),
+        // `aside` no longer has a bracket to ride in. It was always a sentence
+        // about WHY this card exists at all («reporting again»), which is what the
+        // Reason row says; it fills that row only when the sender left it empty,
+        // and is dropped rather than duplicating a real reason. The field stays in
+        // the event type — the senders that still pass it must not start failing.
+        // `filled`, not `??`: a sender that passes `note: ''` (an empty variable
+        // in a shell script) left the row empty, and `??` read that as a reason
+        // given — dropping the aside and the whole row with it.
+        reason('Reason', filled(e.note, e.aside)),
+        // How long the run took, in the sender's own words. It sits under the
+        // reason and above the timetable: the reason says what happened, this
+        // says what it cost, and only then comes when it is due again.
+        // Trimmed by `filled`: a whitespace-only `--took` printed a bare
+        // `Took:` with nothing after it.
+        field('Took', filled(e.duration)),
         field('Still red', e.stillRed ? `day ${e.stillRed}` : null),
         // The timetable is a different subject from this event: how often the task
         // owes a sign of life and when it last gave one. It stood in a bare run
@@ -775,19 +820,23 @@ const renderCi = (e) => {
     const icon = iconFor(e);
     return join([
         // The run URL is on the gate's name — `CI: <a>nightly</a>` — since 03.09.2026.
-        typeLine(icon, 'CI', mechanism(e.workflowName, undefined), sourceUrl(e), e.status === 'fail' ? 'Fail' : 'OK'),
-        // `Actor` used to be read as "who wrote the commit," and on most runs it
-        // is — `github.actor` for a push IS the person who pushed. It stops being
-        // that on a scheduled run: arvent's nightly rewrites it to whoever is on
-        // duty to fix a red run, which can be someone other than the commit's
-        // author. So Actor answers "who is responsible for this run," `Author`
-        // below the commit answers "who wrote this code" — two different people
-        // on a nightly card, the same person everywhere else.
+        // Same source as the icon — see the deploy card: the two readings of
+        // `status` defaulted opposite ways and the bracket could contradict both
+        // the icon and the tag.
+        typeLine(icon, 'CI', mechanism(e.workflowName, undefined), sourceUrl(e), outcomeAside(e)),
+        // No `Actor:` row (03.09.2026). It was redundant on every kind of run: on
+        // a push the actor IS the commit's author, printed a line above; on a
+        // scheduled run GitHub names the workflow's owner, the same person every
+        // night; only a hand-pressed button carries news, and the run link on
+        // line 2 shows that. `actor` stays in the event for old senders and is
+        // simply not printed.
         ...twoBlocks([reason('Reason', e.note), field('Still red', e.stillRed ? `day ${e.stillRed}` : null)], [
-            fieldTelegram('Actor', e.actor),
+            // Commit line, its body, then the people — same shape as deploy, PR
+            // and issue; a people row between a title and its quote makes the
+            // quote read as that person's words.
             commitRow(e.commit, e.commitUrl, e.commitTitle),
-            fieldPerson('Author', e.commitAuthor),
-            bodyQuote(e.commitBody)
+            bodyQuote(e.commitBody),
+            fieldPerson('Author', e.commitAuthor)
         ])
     ]);
 };
@@ -824,11 +873,34 @@ const renderCi = (e) => {
  * twenty lines under a title that could not be tapped. With no url the number
  * still prints, plain. With no title the line ends at the number.
  */
-const numberedLine = (icon, type, number, title, url) => {
+const numberedLine = (icon, type, number, title, url, outcome) => {
     const id = url ? `<a href="${esc(firstLine(url))}">#${number}</a>` : `#${number}`;
     const name = title?.trim() ? ` · ${esc(firstLine(title.trim()))}` : '';
-    return `${icon} <b>${esc(type)}</b> ${id}${name}`;
+    // The bracket goes on the TYPE WORD, before the number — the same slot it
+    // takes on `Deploy (OK):`, so one glance finds the outcome on any card.
+    const label = outcome ? `${type} (${outcome})` : type;
+    return `${icon} <b>${esc(label)}</b> ${id}${name}`;
 };
+/**
+ * How a pull request or an issue ended, in one word. An action nobody
+ * foresaw — a new GitHub verb, or a missing one in an untyped `--json`
+ * payload — takes the word the icon already implies, `Unknown`; it used to
+ * take the literal `Info`, which is not an outcome and contradicted both the
+ * ❓ on the same line and the `#unknown` tag above it.
+ */
+const PR_OUTCOME = {
+    opened: 'Opened',
+    approved: 'Approved',
+    changes_requested: 'Changes',
+    merged: 'Merged',
+    closed: 'Closed'
+};
+const ISSUE_OUTCOME = {
+    opened: 'Opened',
+    assigned: 'Assigned',
+    closed: 'Closed'
+};
+const outcomeWord = (table, e) => table[e.action] ?? outcomeAside(e);
 // The people come BEFORE the text, and the text comes only when it is the
 // news. An `assigned` card carries one new fact — who took it — and it used to
 // sit dead last, under the issue's entire description: the owner read a card
@@ -866,7 +938,7 @@ const prBody = (action, body) => {
 // old order, title then Author then Assignee then finally the body — "why
 // does the assignee cut apart what should be inseparable?"
 const renderPr = (e) => join([
-    numberedLine(iconFor(e), 'PR', e.number, e.title, e.url),
+    numberedLine(iconFor(e), 'PR', e.number, e.title, e.url, outcomeWord(PR_OUTCOME, e)),
     prBody(e.action, e.body),
     e.body ? '' : null,
     fieldPerson('Author', e.author),
@@ -881,7 +953,7 @@ const renderPr = (e) => join([
 // Whole on opened and assigned (the text is still the news, or the person who
 // took it needs the whole brief); the first section on closed — see prBody.
 const renderIssue = (e) => join([
-    numberedLine(iconFor(e), 'Issue', e.number, e.title, e.url),
+    numberedLine(iconFor(e), 'Issue', e.number, e.title, e.url, outcomeWord(ISSUE_OUTCOME, e)),
     markdownQuote(e.body, e.action !== 'closed'),
     e.body ? '' : null,
     fieldPerson('Author', e.author),
@@ -898,35 +970,55 @@ const renderIssue = (e) => join([
 const renderIncident = (e) => {
     const findings = bullets(e.items, false);
     return join([
-        typeLine(iconFor(e), 'Incident', e.title, e.url),
+        // The bracket on an incident names WHERE it burns, not how it ended —
+        // it has one ending. `Incident (Vault):`, `Incident (Session):`; with no
+        // word from the sender, the project name stands in.
+        // `filled`, not `??`: `scope: ''` and `scope: ' '` are a sender that
+        // named no place, and `??` let the first past the project fallback (no
+        // bracket at all) and the second into a visibly empty one.
+        typeLine(iconFor(e), 'Incident', e.title, e.url, filled(e.scope) ?? cap(e.project)),
         e.detail && e.detail !== e.title ? note(e.detail) : null,
+        // The rows below came from the `session` card when it was folded in
+        // (03.09.2026), in the order they had there: which copy, what the guard
+        // measured, then his own opening line as a quote, then the way out.
+        field('Project', e.workdir),
+        reason('Reason', e.reason),
         field('Still red', e.stillRed ? `day ${e.stillRed}` : null),
         findings.length > 0 ? '' : null,
-        ...findings
+        ...findings,
+        e.opened ? '' : null,
+        quoted('Opened with', e.opened),
+        e.command ? '' : null,
+        ...fieldRun(e.command, e.commandNote)
         // `Log:` moved to the pointer block `render` appends — see renderJob.
     ]);
 };
-// A session in trouble. Same law as every other card: identifier first, then
-// the facts as fields, then his own words as a quote — never as a field, which
-// keeps one line and clipped the name of the very session the card is about.
-//
-// A session has no name, so line 2 says what happened to it. The 36-character
-// id is not printed: he cannot type it, cannot search it and cannot act on it.
-// It is still in the card — inside the `rm` command at the bottom, which is the
-// one place it is of any use.
-const renderSession = (e) => join([
-    typeLine(iconFor(e), 'Session', e.action),
-    // No blank line under the type line: a blank means a new block, and here it
-    // opened a block that had no heading. Facts about the session touch the
-    // line that names it, the way they do on every job card.
-    field('Project', e.workdir),
-    reason('Reason', e.reason),
-    field('Still red', e.stillRed ? `day ${e.stillRed}` : null),
-    e.opened ? '' : null,
-    quoted('Opened with', e.opened),
-    e.command ? '' : null,
-    ...fieldRun(e.command, e.commandNote)
-]);
+/**
+ * A session has no name of its own, so the incident's title is built out of
+ * what happened to it: `burning the limit` → `Claude session is burning the
+ * limit`. That is the whole of what the separate `session` card ever said
+ * differently — every other row it had is an incident row now.
+ *
+ * The 36-character id is still not printed: he cannot type it, cannot search
+ * it and cannot act on it. It reaches the card only inside the `rm` command at
+ * the bottom, which is the one place it is of any use.
+ */
+export const sessionTitle = (action) => {
+    const what = action?.trim();
+    return what ? `Claude session is ${what}` : 'Claude session is in trouble';
+};
+/**
+ * The folded `session` type (03.09.2026): accepted, never rendered as itself.
+ * It is turned into the incident it always was and handed to the incident
+ * renderer, so there is ONE card shape and no second copy to keep in step.
+ */
+const asIncident = (e) => ({
+    ...e,
+    type: 'incident',
+    scope: 'Session',
+    title: sessionTitle(e.action)
+});
+const renderSession = (e) => renderIncident(asIncident(e));
 const renderHeartbeatMiss = (e) => {
     const icon = iconFor(e);
     return join([
@@ -935,10 +1027,10 @@ const renderHeartbeatMiss = (e) => {
         // repository builds this event any more — the silence watchdog sends an
         // ordinary job with `--status silent` — but a machine still running the old
         // copy of that watchdog can, and the card it gets must obey the template.
-        // No bracket saying `ok` or `miss`: the icon says it, the third tag says
-        // it, and `miss` is not one of the five words the outcome is allowed to
-        // be. The bracket is for what finishes the NAME, never for a verdict.
-        typeLine(icon, 'Heartbeat', e.job),
+        // The bracket takes an outcome word, the same as a job card does — and
+        // it takes one of the job's own words: `Silent`, never `miss`, which is
+        // not one of the words the outcome is allowed to be.
+        typeLine(icon, 'Heartbeat', e.job, undefined, e.recovered ? 'OK' : 'Silent'),
         field('Reason', e.note),
         ...schedule(e.expected, e.lastSeen, e.recovered ? 'Last run' : 'Last seen')
     ]);
@@ -978,7 +1070,8 @@ const TYPE_TAG = {
     pr: 'pr',
     issue: 'issue',
     incident: 'incident',
-    session: 'session',
+    // Folded into incident on 03.09.2026 — `#session` is never printed again.
+    session: 'incident',
     heartbeat_miss: 'heartbeat'
 };
 /**
@@ -1045,6 +1138,25 @@ export const OUTCOME_TAG = {
     [ICON.info]: 'info'
 };
 export const outcomeTag = (e) => OUTCOME_TAG[iconFor(e)];
+/**
+ * The bracket word for a status or an action no outcome table knows — a new
+ * GitHub verb, a `--json` payload with a typo or with no status at all. It is
+ * read off the SAME icon the card already shows, so line 2 can never
+ * contradict line 1 or the third tag: an unmapped value renders ❓ `#unknown`
+ * and now says `(Unknown)` too, where it used to say `(OK)` or `(Info)` — the
+ * exact opposite of the icon beside it.
+ *
+ * `info` gets no word: nothing was decided on that card, and there is no
+ * honest outcome to name. A missing bracket is a gap; a wrong one is a lie.
+ */
+const FALLBACK_OUTCOME = {
+    ok: 'OK',
+    fail: 'Fail',
+    off: 'Off',
+    unknown: 'Unknown',
+    info: undefined
+};
+const outcomeAside = (e) => FALLBACK_OUTCOME[outcomeTag(e)];
 const tagsLine = (e) => `#${TYPE_TAG[e.type]} #${esc(eventKey(e))} #${outcomeTag(e)}`;
 /**
  * Rule S (v2.1, amended 03.09.2026): the card says where to verify it. A

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikitasazan/notify",
-  "version": "1.15.2",
+  "version": "1.16.0",
   "description": "Единая типизированная отправка Telegram-уведомлений (форум-темы, маршрутизация, ретраи) для всех проектов",
   "type": "module",
   "license": "MIT",