feat(bot): add ad hoc reminder notifications

packages/adapters-db/src/ad-hoc-notification-repository.ts

@@ -0,0 +1,276 @@
+import { and, asc, eq, lte } from 'drizzle-orm'
+
+import { createDbClient, schema } from '@household/db'
+import { instantFromDatabaseValue, instantToDate, nowInstant } from '@household/domain'
+import type {
+  AdHocNotificationRecord,
+  AdHocNotificationRepository,
+  ClaimAdHocNotificationDeliveryResult
+} from '@household/ports'
+
+const DELIVERY_CLAIM_SOURCE = 'ad-hoc-notification'
+
+function parseMemberIds(raw: unknown): readonly string[] {
+  if (!Array.isArray(raw)) {
+    return []
+  }
+
+  return raw.filter((entry): entry is string => typeof entry === 'string' && entry.length > 0)
+}
+
+function mapNotification(row: {
+  id: string
+  householdId: string
+  creatorMemberId: string
+  assigneeMemberId: string | null
+  originalRequestText: string
+  notificationText: string
+  timezone: string
+  scheduledFor: Date | string
+  timePrecision: string
+  deliveryMode: string
+  dmRecipientMemberIds: unknown
+  friendlyTagAssignee: number
+  status: string
+  sourceTelegramChatId: string | null
+  sourceTelegramThreadId: string | null
+  sentAt: Date | string | null
+  cancelledAt: Date | string | null
+  cancelledByMemberId: string | null
+  createdAt: Date | string
+  updatedAt: Date | string
+}): AdHocNotificationRecord {
+  return {
+    id: row.id,
+    householdId: row.householdId,
+    creatorMemberId: row.creatorMemberId,
+    assigneeMemberId: row.assigneeMemberId,
+    originalRequestText: row.originalRequestText,
+    notificationText: row.notificationText,
+    timezone: row.timezone,
+    scheduledFor: instantFromDatabaseValue(row.scheduledFor)!,
+    timePrecision: row.timePrecision as AdHocNotificationRecord['timePrecision'],
+    deliveryMode: row.deliveryMode as AdHocNotificationRecord['deliveryMode'],
+    dmRecipientMemberIds: parseMemberIds(row.dmRecipientMemberIds),
+    friendlyTagAssignee: row.friendlyTagAssignee === 1,
+    status: row.status as AdHocNotificationRecord['status'],
+    sourceTelegramChatId: row.sourceTelegramChatId,
+    sourceTelegramThreadId: row.sourceTelegramThreadId,
+    sentAt: instantFromDatabaseValue(row.sentAt),
+    cancelledAt: instantFromDatabaseValue(row.cancelledAt),
+    cancelledByMemberId: row.cancelledByMemberId,
+    createdAt: instantFromDatabaseValue(row.createdAt)!,
+    updatedAt: instantFromDatabaseValue(row.updatedAt)!
+  }
+}
+
+function notificationSelect() {
+  return {
+    id: schema.adHocNotifications.id,
+    householdId: schema.adHocNotifications.householdId,
+    creatorMemberId: schema.adHocNotifications.creatorMemberId,
+    assigneeMemberId: schema.adHocNotifications.assigneeMemberId,
+    originalRequestText: schema.adHocNotifications.originalRequestText,
+    notificationText: schema.adHocNotifications.notificationText,
+    timezone: schema.adHocNotifications.timezone,
+    scheduledFor: schema.adHocNotifications.scheduledFor,
+    timePrecision: schema.adHocNotifications.timePrecision,
+    deliveryMode: schema.adHocNotifications.deliveryMode,
+    dmRecipientMemberIds: schema.adHocNotifications.dmRecipientMemberIds,
+    friendlyTagAssignee: schema.adHocNotifications.friendlyTagAssignee,
+    status: schema.adHocNotifications.status,
+    sourceTelegramChatId: schema.adHocNotifications.sourceTelegramChatId,
+    sourceTelegramThreadId: schema.adHocNotifications.sourceTelegramThreadId,
+    sentAt: schema.adHocNotifications.sentAt,
+    cancelledAt: schema.adHocNotifications.cancelledAt,
+    cancelledByMemberId: schema.adHocNotifications.cancelledByMemberId,
+    createdAt: schema.adHocNotifications.createdAt,
+    updatedAt: schema.adHocNotifications.updatedAt
+  }
+}
+
+export function createDbAdHocNotificationRepository(databaseUrl: string): {
+  repository: AdHocNotificationRepository
+  close: () => Promise<void>
+} {
+  const { db, queryClient } = createDbClient(databaseUrl, {
+    max: 3,
+    prepare: false
+  })
+
+  const repository: AdHocNotificationRepository = {
+    async createNotification(input) {
+      const timestamp = instantToDate(nowInstant())
+      const rows = await db
+        .insert(schema.adHocNotifications)
+        .values({
+          householdId: input.householdId,
+          creatorMemberId: input.creatorMemberId,
+          assigneeMemberId: input.assigneeMemberId ?? null,
+          originalRequestText: input.originalRequestText,
+          notificationText: input.notificationText,
+          timezone: input.timezone,
+          scheduledFor: instantToDate(input.scheduledFor),
+          timePrecision: input.timePrecision,
+          deliveryMode: input.deliveryMode,
+          dmRecipientMemberIds: input.dmRecipientMemberIds ?? [],
+          friendlyTagAssignee: input.friendlyTagAssignee ? 1 : 0,
+          status: 'scheduled',
+          sourceTelegramChatId: input.sourceTelegramChatId ?? null,
+          sourceTelegramThreadId: input.sourceTelegramThreadId ?? null,
+          updatedAt: timestamp
+        })
+        .returning(notificationSelect())
+
+      const row = rows[0]
+      if (!row) {
+        throw new Error('Notification insert did not return a row')
+      }
+
+      return mapNotification(row)
+    },
+
+    async getNotificationById(notificationId) {
+      const rows = await db
+        .select(notificationSelect())
+        .from(schema.adHocNotifications)
+        .where(eq(schema.adHocNotifications.id, notificationId))
+        .limit(1)
+
+      return rows[0] ? mapNotification(rows[0]) : null
+    },
+
+    async listUpcomingNotificationsForHousehold(householdId, asOf) {
+      const rows = await db
+        .select(notificationSelect())
+        .from(schema.adHocNotifications)
+        .where(
+          and(
+            eq(schema.adHocNotifications.householdId, householdId),
+            eq(schema.adHocNotifications.status, 'scheduled'),
+            lte(schema.adHocNotifications.createdAt, instantToDate(asOf))
+          )
+        )
+        .orderBy(
+          asc(schema.adHocNotifications.scheduledFor),
+          asc(schema.adHocNotifications.createdAt)
+        )
+
+      return rows
+        .map(mapNotification)
+        .filter((record) => record.scheduledFor.epochMilliseconds >= asOf.epochMilliseconds)
+    },
+
+    async cancelNotification(input) {
+      const rows = await db
+        .update(schema.adHocNotifications)
+        .set({
+          status: 'cancelled',
+          cancelledAt: instantToDate(input.cancelledAt),
+          cancelledByMemberId: input.cancelledByMemberId,
+          updatedAt: instantToDate(nowInstant())
+        })
+        .where(
+          and(
+            eq(schema.adHocNotifications.id, input.notificationId),
+            eq(schema.adHocNotifications.status, 'scheduled')
+          )
+        )
+        .returning(notificationSelect())
+
+      return rows[0] ? mapNotification(rows[0]) : null
+    },
+
+    async listDueNotifications(asOf) {
+      const rows = await db
+        .select(notificationSelect())
+        .from(schema.adHocNotifications)
+        .where(
+          and(
+            eq(schema.adHocNotifications.status, 'scheduled'),
+            lte(schema.adHocNotifications.scheduledFor, instantToDate(asOf))
+          )
+        )
+        .orderBy(
+          asc(schema.adHocNotifications.scheduledFor),
+          asc(schema.adHocNotifications.createdAt)
+        )
+
+      return rows.map(mapNotification)
+    },
+
+    async markNotificationSent(notificationId, sentAt) {
+      const rows = await db
+        .update(schema.adHocNotifications)
+        .set({
+          status: 'sent',
+          sentAt: instantToDate(sentAt),
+          updatedAt: instantToDate(nowInstant())
+        })
+        .where(
+          and(
+            eq(schema.adHocNotifications.id, notificationId),
+            eq(schema.adHocNotifications.status, 'scheduled')
+          )
+        )
+        .returning(notificationSelect())
+
+      return rows[0] ? mapNotification(rows[0]) : null
+    },
+
+    async claimNotificationDelivery(notificationId) {
+      const notification = await repository.getNotificationById(notificationId)
+      if (!notification) {
+        return {
+          notificationId,
+          claimed: false
+        } satisfies ClaimAdHocNotificationDeliveryResult
+      }
+
+      const rows = await db
+        .insert(schema.processedBotMessages)
+        .values({
+          householdId: notification.householdId,
+          source: DELIVERY_CLAIM_SOURCE,
+          sourceMessageKey: notificationId
+        })
+        .onConflictDoNothing({
+          target: [
+            schema.processedBotMessages.householdId,
+            schema.processedBotMessages.source,
+            schema.processedBotMessages.sourceMessageKey
+          ]
+        })
+        .returning({ id: schema.processedBotMessages.id })
+
+      return {
+        notificationId,
+        claimed: rows.length > 0
+      }
+    },
+
+    async releaseNotificationDelivery(notificationId) {
+      const notification = await repository.getNotificationById(notificationId)
+      if (!notification) {
+        return
+      }
+
+      await db
+        .delete(schema.processedBotMessages)
+        .where(
+          and(
+            eq(schema.processedBotMessages.householdId, notification.householdId),
+            eq(schema.processedBotMessages.source, DELIVERY_CLAIM_SOURCE),
+            eq(schema.processedBotMessages.sourceMessageKey, notificationId)
+          )
+        )
+    }
+  }
+
+  return {
+    repository,
+    close: async () => {
+      await queryClient.end({ timeout: 5 })
+    }
+  }
+}

packages/adapters-db/src/index.ts

@@ -1,3 +1,4 @@
+export { createDbAdHocNotificationRepository } from './ad-hoc-notification-repository'
 export { createDbAnonymousFeedbackRepository } from './anonymous-feedback-repository'
 export { createDbFinanceRepository } from './finance-repository'
 export { createDbHouseholdConfigurationRepository } from './household-config-repository'

packages/adapters-db/src/telegram-pending-action-repository.ts

@@ -9,6 +9,10 @@ import type {
 } from '@household/ports'
 
 function parsePendingActionType(raw: string): TelegramPendingActionType {
+  if (raw === 'ad_hoc_notification') {
+    return raw
+  }
+
   if (raw === 'anonymous_feedback') {
     return raw
   }

packages/application/src/ad-hoc-notification-service.test.ts

@@ -0,0 +1,268 @@
+import { describe, expect, test } from 'bun:test'
+
+import { Temporal } from '@household/domain'
+import type {
+  AdHocNotificationRecord,
+  AdHocNotificationRepository,
+  CancelAdHocNotificationInput,
+  ClaimAdHocNotificationDeliveryResult,
+  CreateAdHocNotificationInput,
+  HouseholdConfigurationRepository,
+  HouseholdMemberRecord
+} from '@household/ports'
+
+import { createAdHocNotificationService } from './ad-hoc-notification-service'
+
+class NotificationRepositoryStub implements AdHocNotificationRepository {
+  notifications = new Map<string, AdHocNotificationRecord>()
+  nextId = 1
+
+  async createNotification(input: CreateAdHocNotificationInput): Promise<AdHocNotificationRecord> {
+    const id = `notif-${this.nextId++}`
+    const record: AdHocNotificationRecord = {
+      id,
+      householdId: input.householdId,
+      creatorMemberId: input.creatorMemberId,
+      assigneeMemberId: input.assigneeMemberId ?? null,
+      originalRequestText: input.originalRequestText,
+      notificationText: input.notificationText,
+      timezone: input.timezone,
+      scheduledFor: input.scheduledFor,
+      timePrecision: input.timePrecision,
+      deliveryMode: input.deliveryMode,
+      dmRecipientMemberIds: input.dmRecipientMemberIds ?? [],
+      friendlyTagAssignee: input.friendlyTagAssignee,
+      status: 'scheduled',
+      sourceTelegramChatId: input.sourceTelegramChatId ?? null,
+      sourceTelegramThreadId: input.sourceTelegramThreadId ?? null,
+      sentAt: null,
+      cancelledAt: null,
+      cancelledByMemberId: null,
+      createdAt: Temporal.Instant.from('2026-03-23T09:00:00Z'),
+      updatedAt: Temporal.Instant.from('2026-03-23T09:00:00Z')
+    }
+    this.notifications.set(id, record)
+    return record
+  }
+
+  async getNotificationById(notificationId: string): Promise<AdHocNotificationRecord | null> {
+    return this.notifications.get(notificationId) ?? null
+  }
+
+  async listUpcomingNotificationsForHousehold(
+    householdId: string,
+    asOf: Temporal.Instant
+  ): Promise<readonly AdHocNotificationRecord[]> {
+    return [...this.notifications.values()].filter(
+      (notification) =>
+        notification.householdId === householdId &&
+        notification.status === 'scheduled' &&
+        notification.scheduledFor.epochMilliseconds > asOf.epochMilliseconds
+    )
+  }
+
+  async cancelNotification(
+    input: CancelAdHocNotificationInput
+  ): Promise<AdHocNotificationRecord | null> {
+    const record = this.notifications.get(input.notificationId)
+    if (!record || record.status !== 'scheduled') {
+      return null
+    }
+
+    const next = {
+      ...record,
+      status: 'cancelled' as const,
+      cancelledAt: input.cancelledAt,
+      cancelledByMemberId: input.cancelledByMemberId
+    }
+    this.notifications.set(input.notificationId, next)
+    return next
+  }
+
+  async listDueNotifications(asOf: Temporal.Instant): Promise<readonly AdHocNotificationRecord[]> {
+    return [...this.notifications.values()].filter(
+      (notification) =>
+        notification.status === 'scheduled' &&
+        notification.scheduledFor.epochMilliseconds <= asOf.epochMilliseconds
+    )
+  }
+
+  async markNotificationSent(
+    notificationId: string,
+    sentAt: Temporal.Instant
+  ): Promise<AdHocNotificationRecord | null> {
+    const record = this.notifications.get(notificationId)
+    if (!record || record.status !== 'scheduled') {
+      return null
+    }
+
+    const next = {
+      ...record,
+      status: 'sent' as const,
+      sentAt
+    }
+    this.notifications.set(notificationId, next)
+    return next
+  }
+
+  async claimNotificationDelivery(
+    notificationId: string
+  ): Promise<ClaimAdHocNotificationDeliveryResult> {
+    return {
+      notificationId,
+      claimed: true
+    }
+  }
+
+  async releaseNotificationDelivery(): Promise<void> {}
+}
+
+function member(
+  input: Partial<HouseholdMemberRecord> & Pick<HouseholdMemberRecord, 'id'>
+): HouseholdMemberRecord {
+  return {
+    id: input.id,
+    householdId: input.householdId ?? 'household-1',
+    telegramUserId: input.telegramUserId ?? `${input.id}-tg`,
+    displayName: input.displayName ?? input.id,
+    status: input.status ?? 'active',
+    preferredLocale: input.preferredLocale ?? 'ru',
+    householdDefaultLocale: input.householdDefaultLocale ?? 'ru',
+    rentShareWeight: input.rentShareWeight ?? 1,
+    isAdmin: input.isAdmin ?? false
+  }
+}
+
+function createHouseholdRepository(
+  members: readonly HouseholdMemberRecord[]
+): Pick<HouseholdConfigurationRepository, 'getHouseholdMember' | 'listHouseholdMembers'> {
+  return {
+    async getHouseholdMember(householdId, telegramUserId) {
+      return (
+        members.find(
+          (member) => member.householdId === householdId && member.telegramUserId === telegramUserId
+        ) ?? null
+      )
+    },
+    async listHouseholdMembers(householdId) {
+      return members.filter((member) => member.householdId === householdId)
+    }
+  }
+}
+
+describe('createAdHocNotificationService', () => {
+  test('defaults date-only reminder to scheduled notification with topic delivery', async () => {
+    const repository = new NotificationRepositoryStub()
+    const members = [member({ id: 'creator' }), member({ id: 'assignee', displayName: 'Georgiy' })]
+    const service = createAdHocNotificationService({
+      repository,
+      householdConfigurationRepository: createHouseholdRepository(members)
+    })
+
+    const result = await service.scheduleNotification({
+      householdId: 'household-1',
+      creatorMemberId: 'creator',
+      assigneeMemberId: 'assignee',
+      originalRequestText: 'Напомни Георгию завтра',
+      notificationText: 'пошпынять Георгия о том, позвонил ли он',
+      timezone: 'Asia/Tbilisi',
+      scheduledFor: Temporal.Instant.from('2026-03-24T08:00:00Z'),
+      timePrecision: 'date_only_defaulted',
+      deliveryMode: 'topic'
+    })
+
+    expect(result.status).toBe('scheduled')
+    if (result.status === 'scheduled') {
+      expect(result.notification.deliveryMode).toBe('topic')
+      expect(result.notification.assigneeMemberId).toBe('assignee')
+    }
+  })
+
+  test('expands dm_all to all active members', async () => {
+    const repository = new NotificationRepositoryStub()
+    const members = [
+      member({ id: 'creator' }),
+      member({ id: 'alice' }),
+      member({ id: 'bob', status: 'away' }),
+      member({ id: 'carol' })
+    ]
+    const service = createAdHocNotificationService({
+      repository,
+      householdConfigurationRepository: createHouseholdRepository(members)
+    })
+
+    const result = await service.scheduleNotification({
+      householdId: 'household-1',
+      creatorMemberId: 'creator',
+      originalRequestText: 'remind everyone tomorrow',
+      notificationText: 'pay rent',
+      timezone: 'Asia/Tbilisi',
+      scheduledFor: Temporal.Instant.from('2026-03-24T08:00:00Z'),
+      timePrecision: 'date_only_defaulted',
+      deliveryMode: 'dm_all'
+    })
+
+    expect(result.status).toBe('scheduled')
+    if (result.status === 'scheduled') {
+      expect(result.notification.dmRecipientMemberIds).toEqual(['creator', 'alice', 'carol'])
+    }
+  })
+
+  test('rejects friendly mode without assignee', async () => {
+    const repository = new NotificationRepositoryStub()
+    const service = createAdHocNotificationService({
+      repository,
+      householdConfigurationRepository: createHouseholdRepository([member({ id: 'creator' })])
+    })
+
+    const result = await service.scheduleNotification({
+      householdId: 'household-1',
+      creatorMemberId: 'creator',
+      originalRequestText: 'remind tomorrow',
+      notificationText: 'check rent',
+      timezone: 'Asia/Tbilisi',
+      scheduledFor: Temporal.Instant.from('2026-03-24T08:00:00Z'),
+      timePrecision: 'date_only_defaulted',
+      deliveryMode: 'topic',
+      friendlyTagAssignee: true
+    })
+
+    expect(result).toEqual({
+      status: 'invalid',
+      reason: 'friendly_assignee_missing'
+    })
+  })
+
+  test('allows admin to cancel someone else notification', async () => {
+    const repository = new NotificationRepositoryStub()
+    const creator = member({ id: 'creator', telegramUserId: 'creator-tg' })
+    const admin = member({ id: 'admin', telegramUserId: 'admin-tg', isAdmin: true })
+    const service = createAdHocNotificationService({
+      repository,
+      householdConfigurationRepository: createHouseholdRepository([creator, admin])
+    })
+
+    const created = await repository.createNotification({
+      householdId: 'household-1',
+      creatorMemberId: 'creator',
+      originalRequestText: 'remind tomorrow',
+      notificationText: 'call landlord',
+      timezone: 'Asia/Tbilisi',
+      scheduledFor: Temporal.Instant.from('2026-03-24T08:00:00Z'),
+      timePrecision: 'date_only_defaulted',
+      deliveryMode: 'topic',
+      friendlyTagAssignee: false
+    })
+
+    const result = await service.cancelNotification({
+      notificationId: created.id,
+      viewerMemberId: 'admin',
+      asOf: Temporal.Instant.from('2026-03-23T09:00:00Z')
+    })
+
+    expect(result.status).toBe('cancelled')
+    if (result.status === 'cancelled') {
+      expect(result.notification.cancelledByMemberId).toBe('admin')
+    }
+  })
+})

packages/application/src/ad-hoc-notification-service.ts

@@ -0,0 +1,377 @@
+import { nowInstant, type Instant } from '@household/domain'
+import type {
+  AdHocNotificationDeliveryMode,
+  AdHocNotificationRecord,
+  AdHocNotificationRepository,
+  AdHocNotificationTimePrecision,
+  HouseholdConfigurationRepository,
+  HouseholdMemberRecord
+} from '@household/ports'
+
+interface NotificationActor {
+  memberId: string
+  householdId: string
+  isAdmin: boolean
+}
+
+export interface AdHocNotificationMemberSummary {
+  memberId: string
+  telegramUserId: string
+  displayName: string
+}
+
+export interface AdHocNotificationSummary {
+  id: string
+  notificationText: string
+  scheduledFor: Instant
+  deliveryMode: AdHocNotificationDeliveryMode
+  friendlyTagAssignee: boolean
+  creatorDisplayName: string
+  assigneeDisplayName: string | null
+  canCancel: boolean
+}
+
+export interface DeliverableAdHocNotification {
+  notification: AdHocNotificationRecord
+  creator: AdHocNotificationMemberSummary
+  assignee: AdHocNotificationMemberSummary | null
+  dmRecipients: readonly AdHocNotificationMemberSummary[]
+}
+
+export type ScheduleAdHocNotificationResult =
+  | {
+      status: 'scheduled'
+      notification: AdHocNotificationRecord
+    }
+  | {
+      status: 'invalid'
+      reason:
+        | 'creator_not_found'
+        | 'assignee_not_found'
+        | 'dm_recipients_missing'
+        | 'delivery_mode_invalid'
+        | 'friendly_assignee_missing'
+        | 'scheduled_for_past'
+    }
+
+export type CancelAdHocNotificationResult =
+  | {
+      status: 'cancelled'
+      notification: AdHocNotificationRecord
+    }
+  | {
+      status: 'not_found' | 'forbidden' | 'already_handled' | 'past_due'
+    }
+
+export interface AdHocNotificationService {
+  scheduleNotification(input: {
+    householdId: string
+    creatorMemberId: string
+    originalRequestText: string
+    notificationText: string
+    timezone: string
+    scheduledFor: Instant
+    timePrecision: AdHocNotificationTimePrecision
+    deliveryMode: AdHocNotificationDeliveryMode
+    assigneeMemberId?: string | null
+    dmRecipientMemberIds?: readonly string[]
+    friendlyTagAssignee?: boolean
+    sourceTelegramChatId?: string | null
+    sourceTelegramThreadId?: string | null
+  }): Promise<ScheduleAdHocNotificationResult>
+  listUpcomingNotifications(input: {
+    householdId: string
+    viewerMemberId: string
+    asOf?: Instant
+  }): Promise<readonly AdHocNotificationSummary[]>
+  cancelNotification(input: {
+    notificationId: string
+    viewerMemberId: string
+    asOf?: Instant
+  }): Promise<CancelAdHocNotificationResult>
+  listDueNotifications(asOf?: Instant): Promise<readonly DeliverableAdHocNotification[]>
+  claimDueNotification(notificationId: string): Promise<boolean>
+  releaseDueNotification(notificationId: string): Promise<void>
+  markNotificationSent(
+    notificationId: string,
+    sentAt?: Instant
+  ): Promise<AdHocNotificationRecord | null>
+}
+
+function summarizeMember(member: HouseholdMemberRecord): AdHocNotificationMemberSummary {
+  return {
+    memberId: member.id,
+    telegramUserId: member.telegramUserId,
+    displayName: member.displayName
+  }
+}
+
+function isActiveMember(member: HouseholdMemberRecord): boolean {
+  return member.status === 'active'
+}
+
+async function listMemberMap(
+  repository: Pick<HouseholdConfigurationRepository, 'listHouseholdMembers'>,
+  householdId: string
+): Promise<Map<string, HouseholdMemberRecord>> {
+  const members = await repository.listHouseholdMembers(householdId)
+  return new Map(members.map((member) => [member.id, member]))
+}
+
+function canCancelNotification(
+  notification: AdHocNotificationRecord,
+  actor: NotificationActor
+): boolean {
+  return actor.isAdmin || notification.creatorMemberId === actor.memberId
+}
+
+export function createAdHocNotificationService(input: {
+  repository: AdHocNotificationRepository
+  householdConfigurationRepository: Pick<
+    HouseholdConfigurationRepository,
+    'getHouseholdMember' | 'listHouseholdMembers'
+  >
+}): AdHocNotificationService {
+  async function resolveActor(
+    householdId: string,
+    memberId: string
+  ): Promise<NotificationActor | null> {
+    const members = await input.householdConfigurationRepository.listHouseholdMembers(householdId)
+    const member = members.find((entry) => entry.id === memberId)
+    if (!member) {
+      return null
+    }
+
+    return {
+      memberId: member.id,
+      householdId: member.householdId,
+      isAdmin: member.isAdmin
+    }
+  }
+
+  return {
+    async scheduleNotification(notificationInput) {
+      const memberMap = await listMemberMap(
+        input.householdConfigurationRepository,
+        notificationInput.householdId
+      )
+      const creator = memberMap.get(notificationInput.creatorMemberId)
+      if (!creator) {
+        return {
+          status: 'invalid',
+          reason: 'creator_not_found'
+        }
+      }
+
+      const assignee = notificationInput.assigneeMemberId
+        ? memberMap.get(notificationInput.assigneeMemberId)
+        : null
+      if (notificationInput.assigneeMemberId && !assignee) {
+        return {
+          status: 'invalid',
+          reason: 'assignee_not_found'
+        }
+      }
+
+      const effectiveNow = nowInstant()
+      if (notificationInput.scheduledFor.epochMilliseconds <= effectiveNow.epochMilliseconds) {
+        return {
+          status: 'invalid',
+          reason: 'scheduled_for_past'
+        }
+      }
+
+      const friendlyTagAssignee = notificationInput.friendlyTagAssignee === true
+      if (friendlyTagAssignee && !assignee) {
+        return {
+          status: 'invalid',
+          reason: 'friendly_assignee_missing'
+        }
+      }
+
+      let dmRecipientMemberIds: readonly string[] = []
+      switch (notificationInput.deliveryMode) {
+        case 'topic':
+          dmRecipientMemberIds = []
+          break
+        case 'dm_all':
+          dmRecipientMemberIds = [...memberMap.values()]
+            .filter(isActiveMember)
+            .map((member) => member.id)
+          break
+        case 'dm_selected': {
+          const selected = (notificationInput.dmRecipientMemberIds ?? [])
+            .map((memberId) => memberMap.get(memberId))
+            .filter((member): member is HouseholdMemberRecord => Boolean(member))
+            .filter(isActiveMember)
+
+          if (selected.length === 0) {
+            return {
+              status: 'invalid',
+              reason: 'dm_recipients_missing'
+            }
+          }
+
+          dmRecipientMemberIds = selected.map((member) => member.id)
+          break
+        }
+        default:
+          return {
+            status: 'invalid',
+            reason: 'delivery_mode_invalid'
+          }
+      }
+
+      const notification = await input.repository.createNotification({
+        householdId: notificationInput.householdId,
+        creatorMemberId: notificationInput.creatorMemberId,
+        assigneeMemberId: assignee?.id ?? null,
+        originalRequestText: notificationInput.originalRequestText.trim(),
+        notificationText: notificationInput.notificationText.trim(),
+        timezone: notificationInput.timezone,
+        scheduledFor: notificationInput.scheduledFor,
+        timePrecision: notificationInput.timePrecision,
+        deliveryMode: notificationInput.deliveryMode,
+        dmRecipientMemberIds,
+        friendlyTagAssignee,
+        sourceTelegramChatId: notificationInput.sourceTelegramChatId ?? null,
+        sourceTelegramThreadId: notificationInput.sourceTelegramThreadId ?? null
+      })
+
+      return {
+        status: 'scheduled',
+        notification
+      }
+    },
+
+    async listUpcomingNotifications({ householdId, viewerMemberId, asOf = nowInstant() }) {
+      const actor = await resolveActor(householdId, viewerMemberId)
+      if (!actor) {
+        return []
+      }
+
+      const memberMap = await listMemberMap(input.householdConfigurationRepository, householdId)
+      const notifications = await input.repository.listUpcomingNotificationsForHousehold(
+        householdId,
+        asOf
+      )
+
+      return notifications
+        .filter((notification) => actor.isAdmin || notification.creatorMemberId === actor.memberId)
+        .map((notification) => ({
+          id: notification.id,
+          notificationText: notification.notificationText,
+          scheduledFor: notification.scheduledFor,
+          deliveryMode: notification.deliveryMode,
+          friendlyTagAssignee: notification.friendlyTagAssignee,
+          creatorDisplayName:
+            memberMap.get(notification.creatorMemberId)?.displayName ??
+            notification.creatorMemberId,
+          assigneeDisplayName: notification.assigneeMemberId
+            ? (memberMap.get(notification.assigneeMemberId)?.displayName ??
+              notification.assigneeMemberId)
+            : null,
+          canCancel: canCancelNotification(notification, actor)
+        }))
+    },
+
+    async cancelNotification({ notificationId, viewerMemberId, asOf = nowInstant() }) {
+      const notification = await input.repository.getNotificationById(notificationId)
+      if (!notification) {
+        return {
+          status: 'not_found'
+        }
+      }
+
+      if (notification.status !== 'scheduled') {
+        return {
+          status: 'already_handled'
+        }
+      }
+
+      if (notification.scheduledFor.epochMilliseconds <= asOf.epochMilliseconds) {
+        return {
+          status: 'past_due'
+        }
+      }
+
+      const actor = await resolveActor(notification.householdId, viewerMemberId)
+      if (!actor || !canCancelNotification(notification, actor)) {
+        return {
+          status: 'forbidden'
+        }
+      }
+
+      const cancelled = await input.repository.cancelNotification({
+        notificationId,
+        cancelledByMemberId: actor.memberId,
+        cancelledAt: asOf
+      })
+
+      if (!cancelled) {
+        return {
+          status: 'already_handled'
+        }
+      }
+
+      return {
+        status: 'cancelled',
+        notification: cancelled
+      }
+    },
+
+    async listDueNotifications(asOf = nowInstant()) {
+      const due = await input.repository.listDueNotifications(asOf)
+      const groupedMembers = new Map<string, Map<string, HouseholdMemberRecord>>()
+
+      async function membersForHousehold(householdId: string) {
+        const existing = groupedMembers.get(householdId)
+        if (existing) {
+          return existing
+        }
+
+        const memberMap = await listMemberMap(input.householdConfigurationRepository, householdId)
+        groupedMembers.set(householdId, memberMap)
+        return memberMap
+      }
+
+      const results: DeliverableAdHocNotification[] = []
+      for (const notification of due) {
+        const memberMap = await membersForHousehold(notification.householdId)
+        const creator = memberMap.get(notification.creatorMemberId)
+        if (!creator) {
+          continue
+        }
+
+        const assignee = notification.assigneeMemberId
+          ? (memberMap.get(notification.assigneeMemberId) ?? null)
+          : null
+        const dmRecipients = notification.dmRecipientMemberIds
+          .map((memberId) => memberMap.get(memberId))
+          .filter((member): member is HouseholdMemberRecord => Boolean(member))
+
+        results.push({
+          notification,
+          creator: summarizeMember(creator),
+          assignee: assignee ? summarizeMember(assignee) : null,
+          dmRecipients: dmRecipients.map(summarizeMember)
+        })
+      }
+
+      return results
+    },
+
+    async claimDueNotification(notificationId) {
+      const result = await input.repository.claimNotificationDelivery(notificationId)
+      return result.claimed
+    },
+
+    releaseDueNotification(notificationId) {
+      return input.repository.releaseNotificationDelivery(notificationId)
+    },
+
+    markNotificationSent(notificationId, sentAt = nowInstant()) {
+      return input.repository.markNotificationSent(notificationId, sentAt)
+    }
+  }
+}

packages/application/src/index.ts

@@ -1,4 +1,13 @@
 export { calculateMonthlySettlement } from './settlement-engine'
+export {
+  createAdHocNotificationService,
+  type AdHocNotificationMemberSummary,
+  type AdHocNotificationService,
+  type AdHocNotificationSummary,
+  type CancelAdHocNotificationResult,
+  type DeliverableAdHocNotification,
+  type ScheduleAdHocNotificationResult
+} from './ad-hoc-notification-service'
 export {
   createAnonymousFeedbackService,
   type AnonymousFeedbackService,

packages/db/drizzle/0023_huge_vision.sql

@@ -0,0 +1,50 @@
+CREATE TABLE "ad_hoc_notifications" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"household_id" uuid NOT NULL,
+	"creator_member_id" uuid NOT NULL,
+	"assignee_member_id" uuid,
+	"original_request_text" text NOT NULL,
+	"notification_text" text NOT NULL,
+	"timezone" text NOT NULL,
+	"scheduled_for" timestamp with time zone NOT NULL,
+	"time_precision" text NOT NULL,
+	"delivery_mode" text NOT NULL,
+	"dm_recipient_member_ids" jsonb DEFAULT '[]'::jsonb NOT NULL,
+	"friendly_tag_assignee" integer DEFAULT 0 NOT NULL,
+	"status" text DEFAULT 'scheduled' NOT NULL,
+	"source_telegram_chat_id" text,
+	"source_telegram_thread_id" text,
+	"sent_at" timestamp with time zone,
+	"cancelled_at" timestamp with time zone,
+	"cancelled_by_member_id" uuid,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
+	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "payment_purchase_allocations" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"payment_record_id" uuid NOT NULL,
+	"purchase_id" uuid NOT NULL,
+	"member_id" uuid NOT NULL,
+	"amount_minor" bigint NOT NULL,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+ALTER TABLE "purchase_messages" ADD COLUMN "cycle_id" uuid;--> statement-breakpoint
+ALTER TABLE "purchase_messages" ADD COLUMN "payer_member_id" uuid;--> statement-breakpoint
+ALTER TABLE "ad_hoc_notifications" ADD CONSTRAINT "ad_hoc_notifications_household_id_households_id_fk" FOREIGN KEY ("household_id") REFERENCES "public"."households"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "ad_hoc_notifications" ADD CONSTRAINT "ad_hoc_notifications_creator_member_id_members_id_fk" FOREIGN KEY ("creator_member_id") REFERENCES "public"."members"("id") ON DELETE restrict ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "ad_hoc_notifications" ADD CONSTRAINT "ad_hoc_notifications_assignee_member_id_members_id_fk" FOREIGN KEY ("assignee_member_id") REFERENCES "public"."members"("id") ON DELETE set null ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "ad_hoc_notifications" ADD CONSTRAINT "ad_hoc_notifications_cancelled_by_member_id_members_id_fk" FOREIGN KEY ("cancelled_by_member_id") REFERENCES "public"."members"("id") ON DELETE set null ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "payment_purchase_allocations" ADD CONSTRAINT "payment_purchase_allocations_payment_record_id_payment_records_id_fk" FOREIGN KEY ("payment_record_id") REFERENCES "public"."payment_records"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "payment_purchase_allocations" ADD CONSTRAINT "payment_purchase_allocations_purchase_id_purchase_messages_id_fk" FOREIGN KEY ("purchase_id") REFERENCES "public"."purchase_messages"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "payment_purchase_allocations" ADD CONSTRAINT "payment_purchase_allocations_member_id_members_id_fk" FOREIGN KEY ("member_id") REFERENCES "public"."members"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "ad_hoc_notifications_due_idx" ON "ad_hoc_notifications" USING btree ("status","scheduled_for");--> statement-breakpoint
+CREATE INDEX "ad_hoc_notifications_household_status_idx" ON "ad_hoc_notifications" USING btree ("household_id","status","scheduled_for");--> statement-breakpoint
+CREATE INDEX "ad_hoc_notifications_creator_idx" ON "ad_hoc_notifications" USING btree ("creator_member_id");--> statement-breakpoint
+CREATE INDEX "ad_hoc_notifications_assignee_idx" ON "ad_hoc_notifications" USING btree ("assignee_member_id");--> statement-breakpoint
+CREATE INDEX "payment_purchase_allocations_payment_idx" ON "payment_purchase_allocations" USING btree ("payment_record_id");--> statement-breakpoint
+CREATE INDEX "payment_purchase_allocations_purchase_member_idx" ON "payment_purchase_allocations" USING btree ("purchase_id","member_id");--> statement-breakpoint
+ALTER TABLE "purchase_messages" ADD CONSTRAINT "purchase_messages_cycle_id_billing_cycles_id_fk" FOREIGN KEY ("cycle_id") REFERENCES "public"."billing_cycles"("id") ON DELETE set null ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "purchase_messages" ADD CONSTRAINT "purchase_messages_payer_member_id_members_id_fk" FOREIGN KEY ("payer_member_id") REFERENCES "public"."members"("id") ON DELETE set null ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "purchase_messages_cycle_idx" ON "purchase_messages" USING btree ("cycle_id");

packages/db/drizzle/meta/_journal.json

@@ -162,6 +162,13 @@
       "when": 1774205000000,
       "tag": "0022_carry_purchase_history",
       "breakpoints": true
+    },
+    {
+      "idx": 23,
+      "version": "7",
+      "when": 1774294611532,
+      "tag": "0023_huge_vision",
+      "breakpoints": true
     }
   ]
 }

packages/db/src/schema.ts

@@ -507,6 +507,52 @@ export const processedBotMessages = pgTable(
   })
 )
 
+export const adHocNotifications = pgTable(
+  'ad_hoc_notifications',
+  {
+    id: uuid('id').defaultRandom().primaryKey(),
+    householdId: uuid('household_id')
+      .notNull()
+      .references(() => households.id, { onDelete: 'cascade' }),
+    creatorMemberId: uuid('creator_member_id')
+      .notNull()
+      .references(() => members.id, { onDelete: 'restrict' }),
+    assigneeMemberId: uuid('assignee_member_id').references(() => members.id, {
+      onDelete: 'set null'
+    }),
+    originalRequestText: text('original_request_text').notNull(),
+    notificationText: text('notification_text').notNull(),
+    timezone: text('timezone').notNull(),
+    scheduledFor: timestamp('scheduled_for', { withTimezone: true }).notNull(),
+    timePrecision: text('time_precision').notNull(),
+    deliveryMode: text('delivery_mode').notNull(),
+    dmRecipientMemberIds: jsonb('dm_recipient_member_ids')
+      .default(sql`'[]'::jsonb`)
+      .notNull(),
+    friendlyTagAssignee: integer('friendly_tag_assignee').default(0).notNull(),
+    status: text('status').default('scheduled').notNull(),
+    sourceTelegramChatId: text('source_telegram_chat_id'),
+    sourceTelegramThreadId: text('source_telegram_thread_id'),
+    sentAt: timestamp('sent_at', { withTimezone: true }),
+    cancelledAt: timestamp('cancelled_at', { withTimezone: true }),
+    cancelledByMemberId: uuid('cancelled_by_member_id').references(() => members.id, {
+      onDelete: 'set null'
+    }),
+    createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull()
+  },
+  (table) => ({
+    dueIdx: index('ad_hoc_notifications_due_idx').on(table.status, table.scheduledFor),
+    householdStatusIdx: index('ad_hoc_notifications_household_status_idx').on(
+      table.householdId,
+      table.status,
+      table.scheduledFor
+    ),
+    creatorIdx: index('ad_hoc_notifications_creator_idx').on(table.creatorMemberId),
+    assigneeIdx: index('ad_hoc_notifications_assignee_idx').on(table.assigneeMemberId)
+  })
+)
+
 export const topicMessages = pgTable(
   'topic_messages',
   {

packages/ports/src/index.ts

@@ -6,6 +6,19 @@ export {
   type ReminderTarget,
   type ReminderType
 } from './reminders'
+export {
+  AD_HOC_NOTIFICATION_DELIVERY_MODES,
+  AD_HOC_NOTIFICATION_STATUSES,
+  AD_HOC_NOTIFICATION_TIME_PRECISIONS,
+  type AdHocNotificationDeliveryMode,
+  type AdHocNotificationRecord,
+  type AdHocNotificationRepository,
+  type AdHocNotificationStatus,
+  type AdHocNotificationTimePrecision,
+  type CancelAdHocNotificationInput,
+  type ClaimAdHocNotificationDeliveryResult,
+  type CreateAdHocNotificationInput
+} from './notifications'
 export type {
   ClaimProcessedBotMessageInput,
   ClaimProcessedBotMessageResult,

packages/ports/src/notifications.ts

@@ -0,0 +1,76 @@
+import type { Instant } from '@household/domain'
+
+export const AD_HOC_NOTIFICATION_TIME_PRECISIONS = ['exact', 'date_only_defaulted'] as const
+export const AD_HOC_NOTIFICATION_DELIVERY_MODES = ['topic', 'dm_all', 'dm_selected'] as const
+export const AD_HOC_NOTIFICATION_STATUSES = ['scheduled', 'sent', 'cancelled'] as const
+
+export type AdHocNotificationTimePrecision = (typeof AD_HOC_NOTIFICATION_TIME_PRECISIONS)[number]
+export type AdHocNotificationDeliveryMode = (typeof AD_HOC_NOTIFICATION_DELIVERY_MODES)[number]
+export type AdHocNotificationStatus = (typeof AD_HOC_NOTIFICATION_STATUSES)[number]
+
+export interface AdHocNotificationRecord {
+  id: string
+  householdId: string
+  creatorMemberId: string
+  assigneeMemberId: string | null
+  originalRequestText: string
+  notificationText: string
+  timezone: string
+  scheduledFor: Instant
+  timePrecision: AdHocNotificationTimePrecision
+  deliveryMode: AdHocNotificationDeliveryMode
+  dmRecipientMemberIds: readonly string[]
+  friendlyTagAssignee: boolean
+  status: AdHocNotificationStatus
+  sourceTelegramChatId: string | null
+  sourceTelegramThreadId: string | null
+  sentAt: Instant | null
+  cancelledAt: Instant | null
+  cancelledByMemberId: string | null
+  createdAt: Instant
+  updatedAt: Instant
+}
+
+export interface CreateAdHocNotificationInput {
+  householdId: string
+  creatorMemberId: string
+  assigneeMemberId?: string | null
+  originalRequestText: string
+  notificationText: string
+  timezone: string
+  scheduledFor: Instant
+  timePrecision: AdHocNotificationTimePrecision
+  deliveryMode: AdHocNotificationDeliveryMode
+  dmRecipientMemberIds?: readonly string[]
+  friendlyTagAssignee: boolean
+  sourceTelegramChatId?: string | null
+  sourceTelegramThreadId?: string | null
+}
+
+export interface CancelAdHocNotificationInput {
+  notificationId: string
+  cancelledByMemberId: string
+  cancelledAt: Instant
+}
+
+export interface ClaimAdHocNotificationDeliveryResult {
+  notificationId: string
+  claimed: boolean
+}
+
+export interface AdHocNotificationRepository {
+  createNotification(input: CreateAdHocNotificationInput): Promise<AdHocNotificationRecord>
+  getNotificationById(notificationId: string): Promise<AdHocNotificationRecord | null>
+  listUpcomingNotificationsForHousehold(
+    householdId: string,
+    asOf: Instant
+  ): Promise<readonly AdHocNotificationRecord[]>
+  cancelNotification(input: CancelAdHocNotificationInput): Promise<AdHocNotificationRecord | null>
+  listDueNotifications(asOf: Instant): Promise<readonly AdHocNotificationRecord[]>
+  markNotificationSent(
+    notificationId: string,
+    sentAt: Instant
+  ): Promise<AdHocNotificationRecord | null>
+  claimNotificationDelivery(notificationId: string): Promise<ClaimAdHocNotificationDeliveryResult>
+  releaseNotificationDelivery(notificationId: string): Promise<void>
+}

packages/ports/src/telegram-pending-actions.ts

@@ -1,6 +1,7 @@
 import type { Instant } from '@household/domain'
 
 export const TELEGRAM_PENDING_ACTION_TYPES = [
+  'ad_hoc_notification',
   'anonymous_feedback',
   'assistant_payment_confirmation',
   'household_group_invite',