@mikitasazan/notify 1.25.0 → 1.26.1

package/dist/render.js

@@ -21,14 +21,24 @@
  */
 import { DISPLAY, ICON, iconFor } from "./events.js";
 /**
- * A label gets a capital letter — but NOT a name that is deliberately
- * written lowercase: `iOS` was turning into `IOS`. The signal is a capital
- * second letter.
+ * A label gets a capital letter — but NOT a name. Two shapes of a name,
+ * both verbatim:
+ *
+ * 1. An inner-cap spelling a capital would flatten: `iOS` was turning into
+ *    `IOS`. The signal is a capital second letter.
+ * 2. `<name> #N` — a tracked thing named by number. In the tasks digest the
+ *    name is the repository's own (`zabukai-app #33`), and the one-name rule
+ *    keeps a repository's name symbol for symbol; this printed
+ *    «Zabukai-app #33» (owner, 12.09.2026). The ` #` is structural, not a
+ *    spelling guess — prose labels never carry one.
  */
 const cap = (s) => {
     if (s.length === 0 || /^[a-z][A-Z]/.test(s)) {
         return s;
     }
+    if (/ #[#\w]/.test(s)) {
+        return s;
+    }
     return s.charAt(0).toUpperCase() + s.slice(1);
 };
 /** Escapes EVERYTHING that comes from outside — only the template adds tags. */

package/dist/send.d.ts

@@ -5,6 +5,21 @@ export declare const dedupe: (e: NotifyEvent, now?: number) => {
     action: "send" | "suppress";
     stillRed?: number;
 };
+/**
+ * One slot per OFFENDER — project, type and the card's own instance key —
+ * not per type (15.09.2026). Keyed by type, the red about a broken weekly
+ * script went green the moment ANY other script of that type sent a clean
+ * card, the reactor deleted the red and closed its issue, and next week the
+ * same red counted as a first day again: an issue never filed. The slot is
+ * both the watchdog card's key and the entry in the red memory below.
+ */
+export declare const brokenSlot: (e: NotifyEvent) => string;
+/** Exported for tests: remember that this offender's red is in the feed. */
+export declare const rememberBroken: (slot: string, now?: number) => void;
+/** Exported for tests: true once — the slot was red and is forgotten now. */
+export declare const forgetBroken: (slot: string) => boolean;
+/** Exported for tests: the green that pairs with brokenCardEvent's red — same key, same project. */
+export declare const healedCardEvent: (e: NotifyEvent) => NotifyEvent;
 /** Exported for tests: the watchdog's own card must provably pass the lint. */
 export declare const brokenCardEvent: (e: NotifyEvent, faults: string[], offenderHtml: string) => NotifyEvent;
 export declare const notify: (e: NotifyEvent) => Promise<SendResult>;

package/dist/send.js

@@ -412,6 +412,62 @@ const journal = (line) => {
         // the journal is best-effort: a card must never be lost to bookkeeping
     }
 };
+/**
+ * One slot per OFFENDER — project, type and the card's own instance key —
+ * not per type (15.09.2026). Keyed by type, the red about a broken weekly
+ * script went green the moment ANY other script of that type sent a clean
+ * card, the reactor deleted the red and closed its issue, and next week the
+ * same red counted as a first day again: an issue never filed. The slot is
+ * both the watchdog card's key and the entry in the red memory below.
+ */
+export const brokenSlot = (e) => `notify-broken-${String(e.type)}-${String(e.project)}-${eventKey(e)}`;
+const brokenStatePath = () => join(dirname(statePath()), 'notify-broken.red.json');
+const readBroken = () => {
+    try {
+        const parsed = JSON.parse(readFileSync(brokenStatePath(), 'utf8'));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+};
+const writeBroken = (state) => {
+    try {
+        const file = brokenStatePath();
+        mkdirSync(dirname(file), { recursive: true });
+        const tmp = `${file}.tmp${process.pid}`;
+        writeFileSync(tmp, JSON.stringify(state, null, 1));
+        renameSync(tmp, file);
+    }
+    catch {
+        // memory is best-effort: a lost entry costs one green, never a card
+    }
+};
+/** Exported for tests: remember that this offender's red is in the feed. */
+export const rememberBroken = (slot, now = Date.now()) => {
+    const state = readBroken();
+    state[slot] = new Date(now).toISOString().slice(0, 10);
+    writeBroken(state);
+};
+/** Exported for tests: true once — the slot was red and is forgotten now. */
+export const forgetBroken = (slot) => {
+    const state = readBroken();
+    if (!Object.hasOwn(state, slot)) {
+        return false;
+    }
+    delete state[slot];
+    writeBroken(state);
+    return true;
+};
+/** Exported for tests: the green that pairs with brokenCardEvent's red — same key, same project. */
+export const healedCardEvent = (e) => ({
+    type: 'job',
+    project: 'mac-config',
+    job: 'notify: a card broke the standard',
+    status: 'ok',
+    note: `the ${String(e.type)} card for ${String(e.project)} passes the standard again`,
+    key: brokenSlot(e)
+});
 /** Exported for tests: the watchdog's own card must provably pass the lint. */
 export const brokenCardEvent = (e, faults, offenderHtml) => {
     const offender = offenderHtml
@@ -436,7 +492,7 @@ export const brokenCardEvent = (e, faults, offenderHtml) => {
         detail: offender || undefined,
         detailLabel: 'Offender',
         check: 'config jobs --log notify-broken',
-        key: `notify-broken-${String(e.type)}`
+        key: brokenSlot(e)
     };
 };
 const reportBrokenCard = async (e, faults, offenderHtml) => {
@@ -455,6 +511,19 @@ const reportBrokenCard = async (e, faults, offenderHtml) => {
         journal(`notify-watchdog: own card failed lint: ${ownFaults.join('; ')}`);
     }
     await deliver(targets(broken), html).catch(() => undefined);
+    rememberBroken(brokenSlot(e));
+};
+/**
+ * The green half of the watchdog: the offender's next clean card heals its
+ * own red, and only its own. Sent through `deliver` directly, not `notify`,
+ * so a green can never be swallowed by the 20h window a red just used.
+ */
+const reportHealedCard = async (e) => {
+    if (!forgetBroken(brokenSlot(e))) {
+        return;
+    }
+    const healed = healedCardEvent(e);
+    await deliver(targets(healed), render(healed)).catch(() => undefined);
 };
 export const notify = async (e) => {
     // Object.hasOwn, not `in`: `in` walks the prototype chain, and
@@ -486,5 +555,8 @@ export const notify = async (e) => {
     if (faults.length > 0) {
         await reportBrokenCard(e, faults, html);
     }
+    else {
+        await reportHealedCard(e);
+    }
     return result;
 };

package/package.json

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