feat: T4b/T4c wave 9 - phenology reports, autopilot A4-A10, honey ledger, Telegram delivery

- Phenology reports API with corrections and revokes; recompute per
  apiary via PhenologyRecomputeRequested, allowBackward for corrections;
  season changes are announced in the morning digest (changes since the
  previous digest, each once)
- Season autopilot A4-A10 with per-apiary sync (Apiary before Colony
  locks) and WinterCheckRecorded
- Honey batch ledger at runtime: initial amount, BOTTLING bookings,
  manual movements, one gram rounding, untracked bottlings never book
- Telegram delivery: planning, Berlin delivery times incl. DST, quiet
  hours, permission re-check and stale skip at send time, rate limits,
  cleanup of old deliveries
- ARCHITECTURE.md: assumptions 47-50 and updated sections 11.x

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>

ApiCore-Backend/src/notifications/notifications.service.spec.ts

@@ -3,6 +3,7 @@ import { NotificationsService } from './notifications.service';
 import { assertAppLink } from './notification-link';
 import { PrismaService } from '../prisma/prisma.service';
 import { PermissionResolverService } from '../auth/permissions/permission-resolver.service';
+import { NotificationDeliveryPlanner } from './delivery-planner';
 
 type CreateManyArg = {
   data: {
@@ -19,6 +20,7 @@ type CreateManyArg = {
 describe('NotificationsService', () => {
   let service: NotificationsService;
   let held: Set<string>;
+  let planner: { planIn: jest.Mock };
   let prisma: {
     notification: {
       createManyAndReturn: jest.Mock;
@@ -28,9 +30,12 @@ describe('NotificationsService', () => {
       updateMany: jest.Mock;
     };
     user: { findMany: jest.Mock };
+    $connect: jest.Mock;
+    $transaction: jest.Mock;
   };
 
   beforeEach(() => {
+    planner = { planIn: jest.fn().mockResolvedValue(0) };
     prisma = {
       notification: {
         createManyAndReturn: jest
@@ -44,7 +49,13 @@ describe('NotificationsService', () => {
         updateMany: jest.fn(),
       },
       user: { findMany: jest.fn().mockResolvedValue([]) },
+      // A transaction client lacks $connect; the root client has it.
+      $connect: jest.fn(),
+      $transaction: jest.fn(),
     };
+    prisma.$transaction.mockImplementation((work: (tx: unknown) => unknown) =>
+      Promise.resolve(work(prisma)),
+    );
     held = new Set();
     service = new NotificationsService(
       prisma as unknown as PrismaService,
@@ -53,6 +64,7 @@ describe('NotificationsService', () => {
           .fn()
           .mockImplementation(() => Promise.resolve(held)),
       } as unknown as PermissionResolverService,
+      planner as unknown as NotificationDeliveryPlanner,
     );
   });
 
@@ -155,6 +167,64 @@ describe('NotificationsService', () => {
     });
   });
 
+  describe('Telegram delivery planning', () => {
+    const base = {
+      priority: 'INFO' as const,
+      category: 'SYSTEM' as const,
+      message: 'm',
+    };
+
+    it('plans the deliveries of the inserted rows right after the insert', async () => {
+      prisma.user.findMany.mockResolvedValue([{ id: 'u1' }, { id: 'u2' }]);
+
+      const rows = await service.recordForUsers(['u1', 'u2'], base);
+
+      expect(planner.planIn).toHaveBeenCalledTimes(1);
+      expect(planner.planIn).toHaveBeenCalledWith(prisma, rows);
+      expect(
+        prisma.notification.createManyAndReturn.mock.invocationCallOrder[0],
+      ).toBeLessThan(planner.planIn.mock.invocationCallOrder[0]);
+    });
+
+    it('plans with the caller transaction and opens none of its own', async () => {
+      const tx = {
+        user: { findMany: jest.fn().mockResolvedValue([{ id: 'u1' }]) },
+        notification: {
+          createManyAndReturn: jest.fn().mockResolvedValue([{ id: 'n' }]),
+        },
+      };
+
+      await service.record({ userId: 'u1', ...base }, tx as never);
+
+      expect(planner.planIn).toHaveBeenCalledWith(tx, [{ id: 'n' }]);
+      expect(prisma.$transaction).not.toHaveBeenCalled();
+    });
+
+    it('without a caller transaction, rows and deliveries share one of their own', async () => {
+      prisma.user.findMany.mockResolvedValue([{ id: 'u1' }]);
+
+      await service.record({ userId: 'u1', ...base });
+
+      expect(prisma.$transaction).toHaveBeenCalledTimes(1);
+      expect(planner.planIn).toHaveBeenCalledTimes(1);
+    });
+
+    it('plans only what was inserted: a repeated dedupe key plans nothing new', async () => {
+      prisma.user.findMany.mockResolvedValue([{ id: 'u1' }]);
+      prisma.notification.createManyAndReturn.mockResolvedValue([]);
+
+      await service.record({ userId: 'u1', ...base, dedupeKey: 'k:u1' });
+
+      expect(planner.planIn).toHaveBeenCalledWith(expect.anything(), []);
+    });
+
+    it('plans nothing when no recipient is eligible', async () => {
+      await service.recordForUsers(['u1'], base);
+
+      expect(planner.planIn).not.toHaveBeenCalled();
+    });
+  });
+
   describe('recordForPermission', () => {
     const input = {
       priority: 'WARNUNG' as const,