Terminplaner: Tagesjob-Meldung, Betriebe-Zaehlung und Bericht

meldeTagesjob meldet am Ende des Tagesjobs ueber den Melder aus A10a2 die Vorfaelle
tagesjob (Fehler oder Abbruch), deckel (Loeschdeckel an 3 Tagesjobs in Folge) und
betriebe (ab 20 aktiven Betrieben, D8) und merkt letzterTagesjob (nur Zaehlungen).
taeglicherJob liefert geloescht und aktiveBetriebe, tagesbericht haengt
"n aktive Betriebe" an.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

test/termineBetrieb.test.js

@@ -6,7 +6,8 @@ import { schemaKeys } from './support/schema.js'
 import { useTestEnv } from './support/testEnv.js'
 import { TERMINE_DATETIMES } from '../server/services/termine/schema.js'
 
-// Betriebspruefung des Terminplaners (Budget, Warteschlange, Anmeldepause) mit Abkuehlzeit fuer die Team-Mail (T20):
+// Betriebspruefung des Terminplaners (Budget, Warteschlange, Anmeldepause) und Tagesjob-Meldung (Fehler, Loeschdeckel, Zahl der
+// aktiven Betriebe) mit Abkuehlzeit fuer die Team-Mail (T20):
 // Nachbau von Appwrite mit Schema, Mails landen in der Senke (ueber einen Fake, der Sendeversuche zaehlt und gezielt
 // scheitert), alle Zeiten sind feste Parameter.
 const aw = await startAppwriteMock({
@@ -28,7 +29,7 @@ const { deleteDocument } = await import('../server/services/appwriteAdmin.js')
 const { setMailTransportForTests } = await import('../server/services/mailer.js')
 const { loadTemplate } = await import('../server/services/mailTemplates.js')
 const { einreihen, warteAufVersand, warteschlangeAlter, pausiertBis, resetOutboxForTests } = await import('../server/services/termine/outbox.js')
-const { pruefeBetrieb, meldeVorfall, resetBetriebForTests } = await import('../server/services/termine/betrieb.js')
+const { pruefeBetrieb, meldeVorfall, meldeTagesjob, letzterTagesjob, zaehleAktiveBetriebe, resetBetriebForTests } = await import('../server/services/termine/betrieb.js')
 const { minutenJob, resetJobsForTests } = await import('../server/services/termine/jobs.js')
 after(() => setMailTransportForTests(null))
 
@@ -498,3 +499,162 @@ test('minutenJob: eine unlesbare Warteschlange für die Betriebsprüfung ändert
   assert.equal(ergebnis.verfallen, 0)
   assert.equal(ergebnis.fehler, 1, 'nur der Schritt Warteschlange zählt; die Betriebsprüfung fügt keinen Fehler hinzu')
 })
+
+// ---------------------------------------------------------------- Tagesjob-Meldung (meldeTagesjob)
+
+const TAG = 24 * STUNDE
+const tag = (n) => plus(n * TAG)
+/** Ergebnis eines Tagesjobs, soweit meldeTagesjob es liest. */
+const tagesErgebnis = (over = {}) => ({ fehler: 0, gedeckelt: { loeschfristen: 0, abgeschaltet: 0, zellen: 0 }, geloescht: 0, aktiveBetriebe: 0, ...over })
+const AM_DECKEL = { loeschfristen: 1, abgeschaltet: 0, zellen: 0 }
+const textAllerMails = () => teamMails().map((mail) => `${mail.subject}\n${mail.text}`).join('\n')
+
+test('meldeTagesjob: Fehler im Tagesjob ⇒ Vorfall tagesjob mit Log und Team-Mail (nur Zahlen); ohne Fehler kein Vorfall', async () => {
+  assert.deepEqual(await meldeTagesjob(tagesErgebnis(), JETZT), [])
+  assert.equal(teamMails().length, 0)
+  assert.equal(betriebLog().length, 0)
+
+  assert.deepEqual(await meldeTagesjob(tagesErgebnis({ fehler: 2 }), plus(MIN)), ['tagesjob'])
+  assert.equal(teamMails().length, 1)
+  assert.equal(teamMails()[0].subject, '[Terminplaner] Tagesjob mit Fehlern')
+  assert.match(teamMails()[0].text, /2 Fehler/)
+  assert.equal(betriebLogMit(/Tagesjob.*2 Fehler/).length, 1)
+  assert.doesNotMatch(textAllerMails(), /@(?!webklar)|\b[bfcpr]_[a-z0-9]{4,}/i, 'weder Adresse noch Kennung in der Meldung')
+})
+
+test('meldeTagesjob: ein Abbruch des Tagesjobs ist ein Vorfall tagesjob, auch ohne gezählten Fehler im Ergebnis', async () => {
+  assert.deepEqual(await meldeTagesjob({ abbruch: true, fehler: 1 }, JETZT), ['tagesjob'])
+  assert.equal(teamMails().length, 1)
+  assert.match(teamMails()[0].text, /abgebrochen/)
+  assert.deepEqual(letzterTagesjob(), { at: JETZT.toISOString(), fehler: 1, gedeckelt: 0, geloescht: 0 })
+})
+
+test('meldeTagesjob: der Vorfall tagesjob folgt der Abkühlzeit (Log stündlich, Mail erst nach 6 Stunden, am nächsten Tag wieder)', async () => {
+  await meldeTagesjob(tagesErgebnis({ fehler: 1 }), JETZT)
+  await meldeTagesjob(tagesErgebnis({ fehler: 1 }), plus(30 * MIN))
+  assert.equal(teamMails().length, 1)
+  assert.equal(betriebLogMit(/Tagesjob/).length, 1)
+  await meldeTagesjob(tagesErgebnis({ fehler: 1 }), plus(2 * STUNDE))
+  assert.equal(teamMails().length, 1, 'innerhalb der 6 Stunden keine zweite Mail')
+  assert.equal(betriebLogMit(/Tagesjob/).length, 2, 'das Log nach einer Stunde wieder')
+  await meldeTagesjob(tagesErgebnis({ fehler: 1 }), tag(1))
+  assert.equal(teamMails().length, 2, 'der Tagesjob am nächsten Tag meldet wieder')
+})
+
+test('meldeTagesjob: Löschdeckel an 2 Tagesjobs in Folge ⇒ kein Vorfall, am 3. ⇒ deckel; die Folge hält an', async () => {
+  const gedeckelt = tagesErgebnis({ gedeckelt: AM_DECKEL })
+  assert.deepEqual(await meldeTagesjob(gedeckelt, tag(0)), [])
+  assert.deepEqual(await meldeTagesjob(gedeckelt, tag(1)), [])
+  assert.equal(teamMails().length, 0)
+  assert.deepEqual(await meldeTagesjob(gedeckelt, tag(2)), ['deckel'])
+  assert.equal(teamMails().length, 1)
+  assert.equal(teamMails()[0].subject, '[Terminplaner] Löschläufe am Deckel')
+  assert.match(teamMails()[0].text, /3 Tagesjobs in Folge/)
+  assert.equal(betriebLogMit(/Deckel/).length, 1)
+
+  assert.deepEqual(await meldeTagesjob(gedeckelt, tag(3)), ['deckel'], 'solange der Rückstand anhält, bleibt es ein Vorfall')
+  assert.equal(teamMails().length, 2, 'am nächsten Tag nach der Abkühlzeit wieder eine Mail')
+})
+
+test('meldeTagesjob: ein Tagesjob ohne Deckel unterbricht die Folge; jeder Bereich (Fristen, abgeschaltete Funktionen, Zellen) zählt', async () => {
+  const frei = tagesErgebnis()
+  const mitDeckel = (gedeckelt) => tagesErgebnis({ gedeckelt })
+  assert.deepEqual(await meldeTagesjob(mitDeckel({ loeschfristen: 1, abgeschaltet: 0, zellen: 0 }), tag(0)), [])
+  assert.deepEqual(await meldeTagesjob(mitDeckel({ loeschfristen: 0, abgeschaltet: 3, zellen: 0 }), tag(1)), [])
+  assert.deepEqual(await meldeTagesjob(frei, tag(2)), [])
+  assert.deepEqual(await meldeTagesjob(mitDeckel({ loeschfristen: 0, abgeschaltet: 0, zellen: 1 }), tag(3)), [])
+  assert.deepEqual(await meldeTagesjob(mitDeckel(AM_DECKEL), tag(4)), [])
+  assert.deepEqual(await meldeTagesjob(mitDeckel({ loeschfristen: 2, abgeschaltet: 1, zellen: 1 }), tag(5)), ['deckel'], 'drei Tage in Folge, jeder mit anderem Bereich')
+  assert.equal(teamMails().length, 1)
+})
+
+test('meldeTagesjob: ein abgebrochener Tagesjob verändert die Deckel-Folge nicht', async () => {
+  const gedeckelt = tagesErgebnis({ gedeckelt: AM_DECKEL })
+  await meldeTagesjob(gedeckelt, tag(0))
+  await meldeTagesjob(gedeckelt, tag(1))
+  await meldeTagesjob({ abbruch: true, fehler: 1 }, tag(2))
+  assert.deepEqual(await meldeTagesjob(gedeckelt, tag(3)), ['deckel'], 'Abbruch unterbricht die Folge nicht und zählt nicht mit')
+})
+
+test('meldeTagesjob: 19 aktive Betriebe ⇒ kein Vorfall, 20 ⇒ betriebe (D8) mit Hinweis auf den Umstieg ab 25; unbekannte Zahl (null) ⇒ nichts', async () => {
+  assert.deepEqual(await meldeTagesjob(tagesErgebnis({ aktiveBetriebe: 19 }), JETZT), [])
+  assert.deepEqual(await meldeTagesjob(tagesErgebnis({ aktiveBetriebe: null }), plus(MIN)), [])
+  assert.equal(teamMails().length, 0)
+  assert.deepEqual(await meldeTagesjob(tagesErgebnis({ aktiveBetriebe: 20 }), plus(2 * MIN)), ['betriebe'])
+  assert.equal(teamMails().length, 1)
+  assert.equal(teamMails()[0].subject, '[Terminplaner] Viele aktive Betriebe')
+  assert.match(teamMails()[0].text, /20 aktive Betriebe/)
+  assert.match(teamMails()[0].text, /25/)
+  assert.equal(betriebLogMit(/20 aktive Betriebe/).length, 1)
+
+  assert.deepEqual(await meldeTagesjob(tagesErgebnis({ aktiveBetriebe: 21 }), plus(3 * MIN)), ['betriebe'])
+  assert.equal(teamMails().length, 1, 'die Abkühlzeit gilt je Vorfall')
+})
+
+test('meldeTagesjob: mehrere Vorfälle zugleich ⇒ je eine Meldung mit eigener Überschrift', async () => {
+  const erg = tagesErgebnis({ fehler: 1, gedeckelt: AM_DECKEL, aktiveBetriebe: 22 })
+  assert.deepEqual(await meldeTagesjob(erg, tag(0)), ['tagesjob', 'betriebe'])
+  assert.deepEqual(await meldeTagesjob(erg, tag(1)), ['tagesjob', 'betriebe'])
+  assert.equal(teamMails().length, 4, 'je Tag eine Mail je Vorfall (Abkühlzeit 6 Stunden)')
+  assert.deepEqual(await meldeTagesjob(erg, tag(2)), ['tagesjob', 'deckel', 'betriebe'], 'am dritten Tag kommt deckel dazu')
+  assert.equal(teamMails().length, 7)
+  assert.deepEqual(
+    [...new Set(teamMails().map((mail) => mail.subject))].sort(),
+    ['[Terminplaner] Löschläufe am Deckel', '[Terminplaner] Tagesjob mit Fehlern', '[Terminplaner] Viele aktive Betriebe'],
+  )
+})
+
+test('letzterTagesjob: null bis zur ersten Meldung, danach nur Zählungen { at, fehler, gedeckelt, geloescht } als Zahlen (gedeckelt = Summe der Bereiche)', async () => {
+  assert.equal(letzterTagesjob(), null)
+  await meldeTagesjob(tagesErgebnis({ fehler: 3, gedeckelt: { loeschfristen: 2, abgeschaltet: 1, zellen: 1 }, geloescht: 17, aktiveBetriebe: 5 }), JETZT)
+  const letzter = letzterTagesjob()
+  assert.deepEqual(letzter, { at: JETZT.toISOString(), fehler: 3, gedeckelt: 4, geloescht: 17 })
+  for (const schluessel of ['fehler', 'gedeckelt', 'geloescht']) assert.equal(typeof letzter[schluessel], 'number', schluessel)
+  letzter.fehler = 99
+  assert.equal(letzterTagesjob().fehler, 3, 'der Aufrufer bekommt eine Kopie')
+
+  await meldeTagesjob(tagesErgebnis({ geloescht: 4 }), plus(TAG))
+  assert.deepEqual(letzterTagesjob(), { at: plus(TAG).toISOString(), fehler: 0, gedeckelt: 0, geloescht: 4 }, 'immer der letzte Lauf')
+  resetBetriebForTests()
+  assert.equal(letzterTagesjob(), null)
+})
+
+test('meldeTagesjob wirft nie: scheitert die Team-Mail, steht das im Log, der Lauf ist gemerkt und die Mail wird nicht neu versucht', async () => {
+  tr.wirf = (mail) => (ist20(mail) ? new Error('Verbindung abgelehnt') : null)
+  assert.deepEqual(await meldeTagesjob(tagesErgebnis({ fehler: 1 }), JETZT), ['tagesjob'])
+  assert.equal(tr.teamVersuche, 1)
+  assert.equal(teamMails().length, 0)
+  assert.equal(betriebLogMit(/Team-Mail.*nicht gesendet/).length, 1)
+  assert.equal(letzterTagesjob().fehler, 1)
+  await meldeTagesjob(tagesErgebnis({ fehler: 1 }), plus(MIN))
+  assert.equal(tr.teamVersuche, 1)
+
+  config.chatNotify.emails = []
+  assert.deepEqual(await meldeTagesjob(tagesErgebnis({ aktiveBetriebe: 30 }), plus(2 * MIN)), ['betriebe'], 'ohne Empfänger bleibt das Log')
+  assert.equal(betriebLogMit(/30 aktive Betriebe/).length, 1)
+})
+
+test('meldeTagesjob: unbrauchbare Ergebnisse ergeben keinen Wurf und keinen Vorfall; eine ungültige Uhrzeit ist ein TypeError', async () => {
+  for (const unbrauchbar of [undefined, null, {}, 'x', { fehler: 'viele', gedeckelt: 'ja', geloescht: -3, aktiveBetriebe: 'zwanzig' }, { fehler: -1, aktiveBetriebe: 2.5 }]) {
+    assert.deepEqual(await meldeTagesjob(unbrauchbar, JETZT), [], JSON.stringify(unbrauchbar))
+  }
+  assert.equal(teamMails().length, 0)
+  assert.deepEqual(letzterTagesjob(), { at: JETZT.toISOString(), fehler: 0, gedeckelt: 0, geloescht: 0 })
+  await assert.rejects(() => meldeTagesjob(tagesErgebnis(), 'jetzt'), TypeError)
+})
+
+test('zaehleAktiveBetriebe: zählt nur Termine-Dokumente im Zustand active (kein Entwurf, nicht abgeschaltet, keine andere Funktion); Appwrite 500 wirft', async () => {
+  const doc = (id, over) => aw.seed('portalFeatures', { $id: id, customerId: 'c_k', projectId: `p_${id}`, featureKey: 'termine', state: 'active', ...over })
+  assert.equal(await zaehleAktiveBetriebe(), 0)
+  doc('f_aktiv01')
+  doc('f_aktiv02')
+  doc('f_aus0001', { state: 'disabled' })
+  doc('f_bestellt', { state: 'ordered' })
+  doc('f_einbau01', { state: 'setup' })
+  doc('f_entwurf1', { state: 'off' })
+  doc('f_news0001', { featureKey: 'news' })
+  assert.equal(await zaehleAktiveBetriebe(), 2)
+
+  aw.failNext({ collection: 'portalFeatures', method: 'GET', status: 500, message: 'Nachbau kaputt' })
+  await assert.rejects(() => zaehleAktiveBetriebe(), (err) => err.status === 500)
+})

test/termineJobs.test.js

@@ -28,6 +28,7 @@ const { deleteDocument } = await import('../server/services/appwriteAdmin.js')
 const { setMailTransportForTests } = await import('../server/services/mailer.js')
 const { normalisiereEinstellung } = await import('../server/services/termine/einstellungen.js')
 const { resetOutboxForTests, warteAufVersand } = await import('../server/services/termine/outbox.js')
+const { letzterTagesjob, resetBetriebForTests } = await import('../server/services/termine/betrieb.js')
 const { neuesToken, verwaltungsToken, buchungsNummer } = await import('../server/services/termine/token.js')
 const { speichereEinstellung, resetKontextForTests } = await import('../server/services/termine/kontext.js')
 const { belegeZellen } = await import('../server/services/termine/zellen.js')
@@ -116,6 +117,7 @@ beforeEach(async () => {
   }
   resetKontextForTests()
   resetOutboxForTests()
+  resetBetriebForTests()
   resetJobsForTests()
   aw.resetListCalls()
   config.termine.mode = 'pilot'
@@ -1005,6 +1007,7 @@ test('taeglicherJob: gedeckelt zählt je Schritt und verfälscht den Löschzähl
   const erg = await taeglicherJob(JETZT)
   assert.deepEqual(erg.loeschfristen, { verfallen: 2, abgesagt: 2, abgelehnt: 1, erledigt: 0, nichterschienen: 0 }, 'nur Löschzähler')
   assert.deepEqual(erg.gedeckelt, { loeschfristen: 2, abgeschaltet: 0, zellen: 0 })
+  assert.equal(erg.geloescht, 5, 'geloescht = Summe aller Löschzähler, gedeckelt zählt nicht mit')
   assert.match(tagesbericht(erg), /^\[termine\] Tagesjob: 5 Buchungen gelöscht \(verfallen 2, abgesagt 2, abgelehnt 1, erledigt 0, nichterschienen 0, abgeschaltete Funktionen 0\)/)
 })
 
@@ -1301,7 +1304,7 @@ test('taeglicherJob: gedeckelt zählt je Schritt; der Tagesbericht nennt „Lös
   assert.deepEqual(erg.gedeckelt, { loeschfristen: 2, abgeschaltet: 0, zellen: 0 })
   let zeile = tagesbericht(erg)
   assert.match(zeile, /^\[termine\] Tagesjob: 4 Buchungen gelöscht \(/)
-  assert.match(zeile, /, 0 Mails nicht zugestellt, Löschläufe am Deckel: 2, Rest folgt an den nächsten Tagen, 0 Fehler$/)
+  assert.match(zeile, /, 0 Mails nicht zugestellt, Löschläufe am Deckel: 2, Rest folgt an den nächsten Tagen, 0 Fehler, 1 aktive Betriebe$/)
   assert.doesNotMatch(zeile, /\bb_|\bf_|@|Mustermann|Salon/)
 
   config.termine.loeschDeckel = DECKEL_VORHER
@@ -1309,7 +1312,7 @@ test('taeglicherJob: gedeckelt zählt je Schritt; der Tagesbericht nennt „Lös
   assert.deepEqual(erg.gedeckelt, { loeschfristen: 0, abgeschaltet: 0, zellen: 0 })
   zeile = tagesbericht(erg)
   assert.doesNotMatch(zeile, /Deckel/, 'ohne Deckel bleibt die Zeile unverändert')
-  assert.match(zeile, /, 0 Mails nicht zugestellt, 0 Fehler$/)
+  assert.match(zeile, /, 0 Mails nicht zugestellt, 0 Fehler, 1 aktive Betriebe$/)
 })
 
 test('tagesbericht: das Segment zählt die Schritte aller Bereiche und fehlt bei gedeckelt 0', () => {
@@ -1320,11 +1323,12 @@ test('tagesbericht: das Segment zählt die Schritte aller Bereiche und fehlt bei
     aufgeraeumt: 7,
     zellen: 8,
     fehler: 9,
+    aktiveBetriebe: 12,
   }
   const ohne = tagesbericht({ ...basis, gedeckelt: { loeschfristen: 0, abgeschaltet: 0, zellen: 0 } })
   assert.equal(
     ohne,
-    '[termine] Tagesjob: 21 Buchungen gelöscht (verfallen 1, abgesagt 2, abgelehnt 3, erledigt 4, nichterschienen 5, abgeschaltete Funktionen 6), 1 Funktionen bereinigt, 8 Zellen, 7 Outbox, 3 Mails nicht zugestellt, 9 Fehler',
+    '[termine] Tagesjob: 21 Buchungen gelöscht (verfallen 1, abgesagt 2, abgelehnt 3, erledigt 4, nichterschienen 5, abgeschaltete Funktionen 6), 1 Funktionen bereinigt, 8 Zellen, 7 Outbox, 3 Mails nicht zugestellt, 9 Fehler, 12 aktive Betriebe',
   )
   const mit = tagesbericht({ ...basis, gedeckelt: { loeschfristen: 2, abgeschaltet: 1, zellen: 1 } })
   assert.equal(mit, ohne.replace(', 9 Fehler', ', Löschläufe am Deckel: 4, Rest folgt an den nächsten Tagen, 9 Fehler'))
@@ -1644,6 +1648,8 @@ test('taeglicherJob: Löschfristen, Warteschlange, festgefahrene Mails, verwaist
   assert.equal('gedeckelt' in erg.loeschfristen, false, 'gedeckelt steht neben den Löschzählern, nicht darin')
   assert.deepEqual(erg.gedeckelt, { loeschfristen: 0, abgeschaltet: 0, zellen: 0 })
   assert.deepEqual(erg.abgeschaltet, { funktionen: 1, buchungen: 1 })
+  assert.equal(erg.geloescht, 3, 'verfallen 1 + erledigt 1 + abgeschaltete Funktion 1')
+  assert.equal(erg.aktiveBetriebe, 1, 'F1 ist aktiv, F2 abgeschaltet')
   assert.equal(erg.aufgeraeumt, 1)
   assert.ok(erg.zellen >= 1)
 
@@ -1662,7 +1668,7 @@ test('taeglicherJob: Löschfristen, Warteschlange, festgefahrene Mails, verwaist
   const zeile = tagesbericht(erg)
   assert.equal(
     zeile,
-    `[termine] Tagesjob: 3 Buchungen gelöscht (verfallen 1, abgesagt 0, abgelehnt 0, erledigt 1, nichterschienen 0, abgeschaltete Funktionen 1), 1 Funktionen bereinigt, ${erg.zellen} Zellen, 1 Outbox, 1 Mails nicht zugestellt, 0 Fehler`,
+    `[termine] Tagesjob: 3 Buchungen gelöscht (verfallen 1, abgesagt 0, abgelehnt 0, erledigt 1, nichterschienen 0, abgeschaltete Funktionen 1), 1 Funktionen bereinigt, ${erg.zellen} Zellen, 1 Outbox, 1 Mails nicht zugestellt, 0 Fehler, 1 aktive Betriebe`,
   )
   assert.doesNotMatch(zeile, /\bb_|\bf_|@|Mustermann|Salon/)
 })
@@ -1677,7 +1683,7 @@ test('taeglicherJob: abgeschaltete Funktion am Deckel ⇒ gedeckelt.abgeschaltet
   assert.equal(erg.fehler, 0)
   let zeile = tagesbericht(erg)
   assert.match(zeile, /^\[termine\] Tagesjob: 2 Buchungen gelöscht \(.*abgeschaltete Funktionen 2\), 1 Funktionen bereinigt, /)
-  assert.match(zeile, /, 0 Mails nicht zugestellt, Löschläufe am Deckel: 1, Rest folgt an den nächsten Tagen, 0 Fehler$/)
+  assert.match(zeile, /, 0 Mails nicht zugestellt, Löschläufe am Deckel: 1, Rest folgt an den nächsten Tagen, 0 Fehler, \d+ aktive Betriebe$/)
   assert.doesNotMatch(zeile, /\bb_|\bf_|@|Mustermann|Salon/)
 
   erg = await taeglicherJob(JETZT)
@@ -1718,7 +1724,7 @@ test('taeglicherJob: Zellen-Sweep am Deckel ⇒ gedeckelt.zellen zählt, zellen
   assert.doesNotMatch(warnLog().join('\n'), /\bb_|\bf_|\br_|\bc_/, 'die Warnung nennt keine Kennungen')
   const zeile = tagesbericht(erg)
   assert.match(zeile, /, 250 Zellen, /)
-  assert.match(zeile, /Löschläufe am Deckel: 1, Rest folgt an den nächsten Tagen, 0 Fehler$/)
+  assert.match(zeile, /Löschläufe am Deckel: 1, Rest folgt an den nächsten Tagen, 0 Fehler, 0 aktive Betriebe$/)
 
   erg = await taeglicherJob(JETZT)
   assert.equal(erg.zellen, 250)
@@ -1761,7 +1767,7 @@ test('taeglicherJob: ist die Liste der abgeschalteten Funktionen nicht lesbar, z
   assert.deepEqual(erg.gedeckelt, { loeschfristen: 0, abgeschaltet: 0, zellen: 0 })
   assert.equal(erg.fehler, 1)
   assert.equal(buchungen().length, 3)
-  assert.match(tagesbericht(erg), /, 0 Mails nicht zugestellt, 1 Fehler$/)
+  assert.match(tagesbericht(erg), /, 0 Mails nicht zugestellt, 1 Fehler, \d+ aktive Betriebe$/)
 })
 
 test('tagesbericht: keine Zeile, wenn der Job nicht gelaufen ist', () => {
@@ -1770,6 +1776,140 @@ test('tagesbericht: keine Zeile, wenn der Job nicht gelaufen ist', () => {
   assert.equal(tagesbericht(undefined), null)
 })
 
+test('tagesbericht: „n aktive Betriebe“ steht ganz am Ende, hinter den Fehlern; ohne Zahl (null oder fehlt) fehlt das Segment', () => {
+  const basis = {
+    festgefahren: 0,
+    loeschfristen: { verfallen: 0, abgesagt: 0, abgelehnt: 0, erledigt: 0, nichterschienen: 0 },
+    gedeckelt: { loeschfristen: 1, abgeschaltet: 0, zellen: 0 },
+    abgeschaltet: { funktionen: 0, buchungen: 0 },
+    aufgeraeumt: 0,
+    zellen: 0,
+    fehler: 2,
+  }
+  assert.match(tagesbericht({ ...basis, aktiveBetriebe: 0 }), /, Löschläufe am Deckel: 1, Rest folgt an den nächsten Tagen, 2 Fehler, 0 aktive Betriebe$/)
+  assert.match(tagesbericht({ ...basis, aktiveBetriebe: 31 }), /, 2 Fehler, 31 aktive Betriebe$/)
+  for (const unbekannt of [null, undefined, 'viele', -1]) {
+    assert.match(tagesbericht({ ...basis, aktiveBetriebe: unbekannt }), /, 2 Fehler$/, String(unbekannt))
+  }
+})
+
+test('taeglicherJob: aktiveBetriebe zählt nur aktive Termine-Dokumente (kein abgeschalteter Betrieb, keine andere Funktion); die Zeile nennt die Zahl ohne Kennungen', async () => {
+  await richteFunktionEin(F1)
+  await richteFunktionEin(F2)
+  await richteFunktionEin(F3, { state: 'disabled', disabledAt: iso(plus(JETZT, -2 * TAG)) }) // erst 2 Tage abgeschaltet: bleibt, zählt nicht
+  aw.seed('portalFeatures', feature('f_p_projekt04_termine', { featureKey: 'news' }))
+  aw.seed('portalFeatures', feature('f_p_projekt05_termine', { state: 'ordered' }))
+
+  const erg = await taeglicherJob(JETZT)
+  assert.equal(erg.aktiveBetriebe, 2)
+  assert.equal(erg.fehler, 0)
+  const zeile = tagesbericht(erg)
+  assert.match(zeile, /, 0 Fehler, 2 aktive Betriebe$/)
+  assert.doesNotMatch(zeile, /\bb_|\bf_|\bp_|\bc_|@|Mustermann|Salon/)
+})
+
+test('taeglicherJob: ist die Zahl der aktiven Betriebe nicht lesbar, ist aktiveBetriebe null, der Fehler gezählt, der Rest des Laufs fertig und die Zeile ohne Segment', async () => {
+  await legeLoeschFall('b_ver000', 'verfallen', 1)
+  aw.failNext({ collection: 'portalFeatures', method: 'GET', status: 500, message: 'Nachbau kaputt', after: 2 }) // 1. GET = Funktionen der Löschfristen, 2. = abgeschaltete, 3. = Zählung
+  const erg = await taeglicherJob(JETZT)
+  assert.equal(erg.aktiveBetriebe, null)
+  assert.equal(erg.fehler, 1)
+  assert.equal(erg.loeschfristen.verfallen, 1, 'die Löschung lief vorher')
+  assert.equal(erg.geloescht, 1)
+  assert.doesNotMatch(tagesbericht(erg), /aktive Betriebe/)
+  assert.ok(fehlerLog().some((zeile) => /Aktive Betriebe/.test(zeile) && /Nachbau kaputt/.test(zeile)), 'der Fehler steht im Log')
+})
+
+// ---------------------------------------------------------------- Tagesjob-Meldung ans Team (meldeTagesjob)
+
+const team20 = () => sink.sent.filter((mail) => /^\[Terminplaner\]/.test(mail.subject))
+
+test('taeglicherJob meldet am Ende: Fehler im Lauf ⇒ Team-Mail „Tagesjob mit Fehlern“, letzterTagesjob trägt nur Zählungen; ein sauberer Lauf meldet nichts', async () => {
+  assert.equal(letzterTagesjob(), null)
+  await legeLoeschFall('b_ver000', 'verfallen', 1)
+  aw.failNext({ collection: 'portalFeatures', method: 'GET', status: 500, message: 'Nachbau kaputt', after: 2 })
+  const erg = await taeglicherJob(JETZT)
+  assert.equal(erg.fehler, 1)
+  assert.equal(team20().length, 1)
+  assert.equal(team20()[0].subject, '[Terminplaner] Tagesjob mit Fehlern')
+  assert.match(team20()[0].text, /1 Fehler\b/)
+  assert.doesNotMatch(team20()[0].text, /Nachbau kaputt|\bb_|\bf_|@/, 'weder Fehlertext noch Kennungen noch Adressen in der Mail')
+  assert.deepEqual(letzterTagesjob(), { at: JETZT.toISOString(), fehler: 1, gedeckelt: 0, geloescht: 1 })
+
+  const spaeter = plus(JETZT, TAG)
+  const sauber = await taeglicherJob(spaeter)
+  assert.equal(sauber.fehler, 0)
+  assert.equal(team20().length, 1, 'ein sauberer Lauf schickt nichts')
+  assert.deepEqual(letzterTagesjob(), { at: spaeter.toISOString(), fehler: 0, gedeckelt: 0, geloescht: 0 })
+})
+
+test('taeglicherJob: Löschdeckel an 3 Tagesläufen in Folge ⇒ Team-Mail „Löschläufe am Deckel“; ein Lauf ohne Deckel beginnt die Folge neu', async () => {
+  config.termine.loeschDeckel = 2
+  for (let i = 0; i < 12; i += 1) await legeLoeschFall(`b_ver${nr(i)}`, 'verfallen', 1 + i)
+
+  assert.deepEqual((await taeglicherJob(plus(JETZT, 0 * TAG))).gedeckelt, { loeschfristen: 1, abgeschaltet: 0, zellen: 0 })
+  await taeglicherJob(plus(JETZT, 1 * TAG))
+  assert.equal(team20().length, 0, 'nach zwei Tagen noch nichts')
+  await taeglicherJob(plus(JETZT, 2 * TAG))
+  assert.equal(team20().length, 1)
+  assert.equal(team20()[0].subject, '[Terminplaner] Löschläufe am Deckel')
+  assert.match(team20()[0].text, /3 Tagesjobs in Folge/)
+  assert.equal(letzterTagesjob().gedeckelt, 1)
+
+  config.termine.loeschDeckel = DECKEL_VORHER
+  await taeglicherJob(plus(JETZT, 3 * TAG)) // räumt den Rest ohne Deckel
+  assert.equal(letzterTagesjob().gedeckelt, 0)
+  assert.equal(buchungen().length, 0)
+  config.termine.loeschDeckel = 2
+  for (let i = 0; i < 6; i += 1) await legeLoeschFall(`b_neu${nr(i)}`, 'verfallen', 1 + i)
+  await taeglicherJob(plus(JETZT, 4 * TAG))
+  await taeglicherJob(plus(JETZT, 5 * TAG))
+  assert.equal(team20().length, 1, 'zwei neue Deckeltage sind keine Folge von drei')
+})
+
+test('taeglicherJob: ab 20 aktiven Betrieben ⇒ Team-Mail „Viele aktive Betriebe“, bei 19 nicht', async () => {
+  for (let i = 1; i <= 19; i += 1) aw.seed('portalFeatures', feature(`f_p_betrieb${nr(i)}_termine`))
+  const erg19 = await taeglicherJob(JETZT)
+  assert.equal(erg19.aktiveBetriebe, 19)
+  assert.equal(team20().length, 0)
+
+  aw.seed('portalFeatures', feature('f_p_betrieb020_termine'))
+  const erg20 = await taeglicherJob(plus(JETZT, TAG))
+  assert.equal(erg20.aktiveBetriebe, 20)
+  assert.equal(team20().length, 1)
+  assert.equal(team20()[0].subject, '[Terminplaner] Viele aktive Betriebe')
+  assert.match(team20()[0].text, /20 aktive Betriebe/)
+  assert.match(tagesbericht(erg20), /, 0 Fehler, 20 aktive Betriebe$/)
+})
+
+test('taeglicherJob: bricht der Job unerwartet ab, erfährt das Team es (Vorfall tagesjob), der Fehler geht weiter an den Aufrufer und die Überlappungssperre ist frei', async () => {
+  Object.defineProperty(config.termine, 'loeschDeckel', {
+    configurable: true,
+    enumerable: true,
+    get() {
+      throw new Error('Unerwartet kaputt')
+    },
+  })
+  try {
+    await assert.rejects(() => taeglicherJob(JETZT), /Unerwartet kaputt/)
+  } finally {
+    Object.defineProperty(config.termine, 'loeschDeckel', { configurable: true, enumerable: true, writable: true, value: DECKEL_VORHER })
+  }
+  assert.equal(team20().length, 1)
+  assert.equal(team20()[0].subject, '[Terminplaner] Tagesjob mit Fehlern')
+  assert.match(team20()[0].text, /abgebrochen/)
+  assert.doesNotMatch(team20()[0].text, /Unerwartet kaputt/, 'der Fehlertext steht im Log des Aufrufers, nicht in der Mail')
+  assert.deepEqual(letzterTagesjob(), { at: JETZT.toISOString(), fehler: 1, gedeckelt: 0, geloescht: 0 })
+  assert.equal((await taeglicherJob(plus(JETZT, MIN))).uebersprungen, undefined, 'danach läuft der Job wieder')
+})
+
+test('taeglicherJob im Modus off und bei Überlappung: keine Tagesjob-Meldung, letzterTagesjob bleibt leer', async () => {
+  config.termine.mode = 'off'
+  assert.deepEqual(await taeglicherJob(JETZT), { aus: true })
+  assert.equal(letzterTagesjob(), null)
+  assert.equal(team20().length, 0)
+})
+
 test('taeglicherJob: festgefahrene Mail wird fehler und erst 48 Stunden später gelöscht (nicht im selben Lauf)', async () => {
   legeEintrag('o_alt', { createdAt: iso(plus(JETZT, -49 * STUNDE)), naechsterVersuch: iso(plus(JETZT, -48 * STUNDE)) })
   legeEintrag('o_neu', { createdAt: iso(plus(JETZT, -47 * STUNDE)), naechsterVersuch: iso(plus(JETZT, 10 * MIN)) })