@atproto/ozone 0.1.172 → 0.1.174

package/src/db/migrations/20260219T164523000Z-create-report-table.ts

@@ -0,0 +1,155 @@
+import { Kysely, sql } from 'kysely'
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  // Report table - bridges report events to action events
+  await db.schema
+    .createTable('report')
+    .addColumn('id', 'serial', (col) => col.primaryKey())
+
+    // Core link to report event (display data still comes from moderation_event via JOIN)
+    .addColumn('eventId', 'integer', (col) => col.notNull().unique())
+
+    // Queue assignment (computed by background job in future iteration)
+    .addColumn('queueId', 'integer') // NULL = not yet assigned, -1 = no matching queue
+    .addColumn('queuedAt', 'varchar')
+
+    // Action linkage (sorted DESC, most recent first)
+    .addColumn('actionEventIds', 'jsonb') // Array of event IDs: [newest_id, ..., oldest_id]
+
+    // Reporter communication
+    .addColumn('actionNote', 'text')
+
+    // Whether the report is muted (reporter was muted or subject was muted at creation time)
+    .addColumn('isMuted', 'boolean', (col) => col.notNull().defaultTo(false))
+
+    // Status of the ticket/report
+    .addColumn('status', 'varchar', (col) => col.notNull().defaultTo('open')) // "open", "closed", "escalated"
+
+    // Denormalized from moderation_event for filtering without JOIN
+    .addColumn('reportType', 'varchar', (col) => col.notNull())
+    .addColumn('did', 'varchar', (col) => col.notNull())
+    .addColumn('recordPath', 'varchar', (col) => col.notNull().defaultTo('')) // '' = account/message, 'collection/rkey' = record
+    .addColumn('subjectMessageId', 'varchar') // NULL for non-message subjects
+
+    // Timestamps
+    .addColumn('createdAt', 'varchar', (col) => col.notNull())
+    .addColumn('updatedAt', 'varchar', (col) => col.notNull())
+    .addColumn('assignedTo', 'varchar') // DID of permanently assigned moderator
+    .addColumn('assignedAt', 'varchar') // When the permanent assignment was created
+    .addColumn('closedAt', 'varchar')
+    .execute()
+
+  // ─── Indexes ───
+  // Primary JOIN index - critical for every query that fetches display data from moderation_event
+  await db.schema
+    .createIndex('idx_report_event')
+    .on('report')
+    .column('eventId')
+    .execute()
+
+  // ─── Hot path: active reports (status != 'closed') ───
+  // Partial filter keeps these tight even as closed reports accumulate (~90% of table long-term).
+  // No isMuted in key (low cardinality, rarely filtered) and no INCLUDE columns
+  // (display data comes from moderation_event JOIN anyway).
+
+  // queryReports: queueId + status, paginated by createdAt
+  await sql`CREATE INDEX idx_report_active_queue_created ON report
+    ("queueId", status, "createdAt" DESC, id DESC)
+    WHERE status != 'closed'`.execute(db)
+
+  // queryReports: queueId + status, paginated by updatedAt
+  await sql`CREATE INDEX idx_report_active_queue_updated ON report
+    ("queueId", status, "updatedAt" DESC, id DESC)
+    WHERE status != 'closed'`.execute(db)
+
+  // queryReports: status only, paginated by createdAt
+  await sql`CREATE INDEX idx_report_active_status_created ON report
+    (status, "createdAt" DESC, id DESC)
+    WHERE status != 'closed'`.execute(db)
+
+  // queryReports: status only, paginated by updatedAt
+  await sql`CREATE INDEX idx_report_active_status_updated ON report
+    (status, "updatedAt" DESC, id DESC)
+    WHERE status != 'closed'`.execute(db)
+
+  // Active reports for a specific account (with optional queueId post-filter)
+  await sql`CREATE INDEX idx_report_active_did_created ON report
+    (did, status, "createdAt" DESC, id DESC)
+    WHERE status != 'closed'`.execute(db)
+
+  // A moderator's active workload (with optional queueId post-filter)
+  await sql`CREATE INDEX idx_report_active_assigned_created ON report
+    ("assignedTo", status, "createdAt" DESC, id DESC)
+    WHERE status != 'closed'`.execute(db)
+
+  // findReportsForSubject hot path — always filters NOT IN ('closed').
+  // did + recordPath identify the subject (account or specific record).
+  await sql`CREATE INDEX idx_report_subject_active ON report
+    (did, "recordPath", "createdAt" DESC, id DESC)
+    WHERE status != 'closed'`.execute(db)
+
+  // ─── Closed history (status = 'closed') ───
+  // Closed reports are terminal; only sort by createdAt.
+
+  // Closed pagination per queue
+  await sql`CREATE INDEX idx_report_closed_queue_created ON report
+    ("queueId", "createdAt" DESC, id DESC)
+    WHERE status = 'closed'`.execute(db)
+
+  // Closed history for an account
+  await sql`CREATE INDEX idx_report_closed_did_created ON report
+    (did, "createdAt" DESC, id DESC)
+    WHERE status = 'closed'`.execute(db)
+
+  // Moderator's closed-report history
+  await sql`CREATE INDEX idx_report_closed_assigned_created ON report
+    ("assignedTo", "createdAt" DESC, id DESC)
+    WHERE status = 'closed'`.execute(db)
+
+  // ─── Other access patterns ───
+
+  // Collection prefix queries: left-anchored LIKE 'app.bsky.feed.post/%' or 'app.bsky.%'
+  // text_pattern_ops enables btree-scannable prefix matching (supported since Postgres 8.x)
+  await sql`CREATE INDEX idx_report_record_path_pattern ON report
+    ("recordPath" text_pattern_ops)`.execute(db)
+
+  // Queue-router covering partial: index-only scan over unrouted, non-closed rows.
+  // Selects exactly the columns the router reads, eliminating heap fetches per batch.
+  await sql`CREATE INDEX idx_report_unassigned_id ON report (id)
+    INCLUDE (status, "reportType", "recordPath", "subjectMessageId")
+    WHERE "queueId" IS NULL AND status != 'closed'`.execute(db)
+
+  // Index for report statistics
+  await db.schema
+    .createIndex('idx_report_queue_created_id')
+    .on('report')
+    .columns(['queueId', 'createdAt', 'id'])
+    .execute()
+
+  // aggregate pending count query
+  await sql`CREATE INDEX idx_report_pending ON report (id) WHERE status != 'closed'`.execute(
+    db,
+  )
+  // per-queue pending count query
+  await sql`CREATE INDEX idx_report_queue_pending ON report ("queueId") WHERE status != 'closed'`.execute(
+    db,
+  )
+
+  // Queue-router event-source partial: scans new modEventReport rows by id
+  // for the daemon that inserts report rows from moderation_event.
+  await sql`CREATE INDEX moderation_event_report_id_idx
+    ON moderation_event (id)
+    WHERE action = 'tools.ozone.moderation.defs#modEventReport'`.execute(db)
+
+  // Stats windowed queries: aggregate/typeWindow filter by createdAt range and
+  // include both open and closed reports, so they cannot use the partial indexes
+  // above. (createdAt, reportType) ordering serves the date-range scan and
+  // satisfies GROUP BY reportType from the index without a heap fetch.
+  await sql`CREATE INDEX idx_report_created_type
+    ON report ("createdAt", "reportType")`.execute(db)
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await db.schema.dropIndex('moderation_event_report_id_idx').execute()
+  await db.schema.dropTable('report').execute()
+}

package/src/db/migrations/20260219T165302248Z-moderator-assignment.ts

@@ -0,0 +1,42 @@
+import { Kysely, sql } from 'kysely'
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await db.schema
+    .createTable('moderator_assignment')
+    .addColumn('id', 'serial', (col) => col.primaryKey())
+    // assignee
+    .addColumn('did', 'text', (col) => col.notNull())
+    // assigned over
+    .addColumn('reportId', 'integer')
+    .addColumn('queueId', 'integer')
+    // validity
+    .addColumn('startAt', 'varchar', (col) => col.notNull())
+    .addColumn('endAt', 'varchar')
+    .execute()
+
+  // Partial index for getting active queue assignments
+  await sql`CREATE INDEX idx_assignment_queue_active ON moderator_assignment ("endAt") WHERE "reportId" IS NULL`.execute(
+    db,
+  )
+
+  // Partial index for getting active report assignments for queue
+  await sql`CREATE INDEX idx_assignment_report_by_queue ON moderator_assignment ("queueId", "endAt") WHERE "reportId" IS NOT NULL`.execute(
+    db,
+  )
+
+  // Index for checking active report assignment
+  await db.schema
+    .createIndex('idx_assignment_report_active')
+    .on('moderator_assignment')
+    .columns(['reportId', 'endAt'])
+    .execute()
+
+  // Partial index for permanent report assignments by moderator
+  await sql`CREATE INDEX idx_assignment_permanent_did ON moderator_assignment (did, "reportId") WHERE "endAt" IS NULL`.execute(
+    db,
+  )
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await db.schema.dropTable('moderator_assignment').ifExists().execute()
+}

package/src/db/migrations/20260225T000000000Z-add-report-queue-table.ts

@@ -0,0 +1,41 @@
+import { Kysely, sql } from 'kysely'
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  // Report queue configuration table
+  await db.schema
+    .createTable('report_queue')
+    .addColumn('id', 'serial', (col) => col.primaryKey())
+    .addColumn('name', 'varchar', (col) => col.notNull()) // uniqueness enforced via partial index below
+    .addColumn('description', 'varchar') // Optional description of the queue
+
+    // Queue filters (determine assignment)
+    .addColumn('subjectTypes', 'jsonb', (col) => col.notNull()) // Array: ['account'] or ['record'] or both
+    .addColumn('collection', 'varchar') // Collection name (e.g., 'app.bsky.feed.post'), NULL for accounts
+    .addColumn('reportTypes', 'jsonb', (col) => col.notNull()) // Array: report reason types
+
+    // Metadata
+    .addColumn('createdBy', 'varchar', (col) => col.notNull()) // DID of mod who created queue
+    .addColumn('createdAt', 'varchar', (col) => col.notNull())
+    .addColumn('updatedAt', 'varchar', (col) => col.notNull())
+    .addColumn('enabled', 'boolean', (col) => col.notNull().defaultTo(true))
+    .addColumn('deletedAt', 'varchar') // NULL = active, timestamp = soft-deleted
+    .execute()
+
+  // Partial unique index on name — only enforces uniqueness for non-deleted queues,
+  // so a soft-deleted queue's name can be reused by a new queue.
+  await sql`CREATE UNIQUE INDEX idx_queue_name_unique ON report_queue (name) WHERE "deletedAt" IS NULL`.execute(
+    db,
+  )
+
+  // Partial composite index covers all list queries on active queues: filter by enabled,
+  // sort by createdAt/id. The WHERE clause keeps the index small (deleted rows excluded).
+  await sql`CREATE INDEX idx_queue_active ON report_queue (enabled, "createdAt", id) WHERE "deletedAt" IS NULL`.execute(
+    db,
+  )
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await db.schema.dropIndex('idx_queue_name_unique').execute()
+  await db.schema.dropIndex('idx_queue_active').execute()
+  await db.schema.dropTable('report_queue').execute()
+}

package/src/db/migrations/20260313T000000000Z-add-report-activity-table.ts

@@ -0,0 +1,48 @@
+import { Kysely, sql } from 'kysely'
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await db.schema
+    .createTable('report_activity')
+    .addColumn('id', 'serial', (col) => col.primaryKey())
+    .addColumn('reportId', 'integer', (col) => col.notNull())
+
+    // Discriminator: one of queueActivity | assignmentActivity | escalationActivity
+    //                        | closeActivity | internalNoteActivity | publicNoteActivity
+    .addColumn('activityType', 'varchar', (col) => col.notNull())
+
+    // The report's status at the moment this activity was recorded.
+    // Populated for state-change activity types; null for note-only activities.
+    .addColumn('previousStatus', 'varchar')
+
+    // Note fields — separated by audience
+    .addColumn('internalNote', 'text') // moderator-only
+    .addColumn('publicNote', 'text') // potentially reporter-visible
+
+    // Free-form JSON for loose activity-specific metadata (e.g. { assignmentId: 42 })
+    .addColumn('meta', 'jsonb')
+
+    // True when created by an automated process (e.g. queue router)
+    .addColumn('isAutomated', 'boolean', (col) =>
+      col.notNull().defaultTo(false),
+    )
+
+    .addColumn('createdBy', 'text', (col) => col.notNull())
+    .addColumn('createdAt', 'varchar', (col) => col.notNull())
+    .execute()
+
+  // Primary filter: all activities for a given report, sorted most-recent-first
+  await db.schema
+    .createIndex('idx_report_activity_report_created')
+    .on('report_activity')
+    .columns(['reportId', 'createdAt', 'id'])
+    .execute()
+
+  // Partial index to efficiently find automated activities per report
+  await sql`CREATE INDEX idx_report_activity_automated ON report_activity ("reportId", "createdAt", id) WHERE "isAutomated" = true`.execute(
+    db,
+  )
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await db.schema.dropTable('report_activity').execute()
+}

package/src/db/migrations/20260318T152058935Z-add-report-stat.ts

@@ -0,0 +1,35 @@
+import { Kysely, sql } from 'kysely'
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await db.schema
+    .createTable('report_stat')
+
+    // metadata
+    .addColumn('id', 'serial', (col) => col.primaryKey())
+    .addColumn('computedAt', 'varchar', (col) => col.notNull())
+
+    // group
+    .addColumn('date', 'varchar', (col) => col.notNull()) // ISO date e.g. '2026-04-15'
+    .addColumn('queueId', 'integer') // NULL = aggregate across all queues
+    .addColumn('reportTypes', 'jsonb') // NULL = aggregate across all report types
+    .addColumn('moderatorDid', 'varchar') // NULL = aggregate across all moderators
+
+    // stats
+    .addColumn('inboundCount', 'integer')
+    .addColumn('pendingCount', 'integer')
+    .addColumn('actionedCount', 'integer')
+    .addColumn('escalatedCount', 'integer')
+    .addColumn('actionRate', 'integer')
+    .addColumn('avgHandlingTimeSec', 'integer')
+    .execute()
+
+  // Lookup by date + group dimensions (covers getLiveStats and getHistoricalStats queries)
+  await sql`CREATE INDEX idx_report_stat_lookup ON report_stat (
+    date, "queueId", "moderatorDid", "reportTypes", "computedAt"
+  )`.execute(db)
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await db.schema.dropIndex('idx_report_stat_lookup').ifExists().execute()
+  await db.schema.dropTable('report_stat').ifExists().execute()
+}

package/src/db/migrations/20260428T000000000Z-add-expiring-tag-table.ts

@@ -0,0 +1,32 @@
+import { Kysely } from 'kysely'
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await db.schema
+    .createTable('expiring_tag')
+    .addColumn('id', 'serial', (col) => col.primaryKey())
+    .addColumn('eventId', 'integer', (col) => col.notNull())
+    .addColumn('did', 'varchar', (col) => col.notNull())
+    .addColumn('recordPath', 'varchar', (col) => col.notNull())
+    .addColumn('tag', 'varchar', (col) => col.notNull())
+    .addColumn('expiresAt', 'varchar', (col) => col.notNull())
+    .addColumn('createdBy', 'varchar', (col) => col.notNull())
+    .execute()
+
+  // Daemon polls for expired tags
+  await db.schema
+    .createIndex('idx_expiring_tag_expires_at')
+    .on('expiring_tag')
+    .column('expiresAt')
+    .execute()
+
+  // Cleanup queries when tags are manually removed
+  await db.schema
+    .createIndex('idx_expiring_tag_did_record_path')
+    .on('expiring_tag')
+    .columns(['did', 'recordPath'])
+    .execute()
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await db.schema.dropTable('expiring_tag').execute()
+}

package/src/db/migrations/index.ts

@@ -34,3 +34,9 @@ export * as _20250813T000000000Z from './20250813T000000000Z-mod-tool-batch-id-i
 export * as _20250923T000000000Z from './20250923T000000000Z-scheduled-actions'
 export * as _20251008T120000000Z from './20251008T120000000Z-add-strike-system'
 export * as _20260210T154806448Z from './20260210T154806448Z-mod-event-created-by-indexes'
+export * as _20260219T164523000Z from './20260219T164523000Z-create-report-table'
+export * as _20260219T165302248Z from './20260219T165302248Z-moderator-assignment'
+export * as _20260225T000000000Z from './20260225T000000000Z-add-report-queue-table'
+export * as _20260313T000000000Z from './20260313T000000000Z-add-report-activity-table'
+export * as _20260318T152058935Z from './20260318T152058935Z-add-report-stat'
+export * as _20260428T000000000Z from './20260428T000000000Z-add-expiring-tag-table'

package/src/db/pagination.ts

@@ -204,6 +204,91 @@ export class CreatedAtUriKeyset extends GenericKeyset<
   }
 }
 
+type EndAtIdKeysetParam = {
+  id: number
+  endAt: string | null
+}
+
+// Special value used here to represent a "permanent" endAt (i.e. a record that should be sorted as if it has an endAt infinitely far in the future).
+// Chosen to sort before all real timestamps in DESC order.
+const PERMANENT_ENDSAT = '9999-12-31T23:59:59.999Z'
+
+export class EndAtIdKeyset extends GenericKeyset<EndAtIdKeysetParam, Cursor> {
+  labelResult(result: EndAtIdKeysetParam): Cursor
+  labelResult(result: EndAtIdKeysetParam) {
+    return {
+      primary: result.endAt ?? PERMANENT_ENDSAT,
+      secondary: result.id.toString(),
+    }
+  }
+  labeledResultToCursor(labeled: Cursor) {
+    return {
+      primary: new Date(labeled.primary).getTime().toString(),
+      secondary: labeled.secondary,
+    }
+  }
+  cursorToLabeledResult(cursor: Cursor) {
+    const primaryDate = new Date(parseInt(cursor.primary, 10))
+    if (isNaN(primaryDate.getTime())) {
+      throw new InvalidRequestError('Malformed cursor')
+    }
+    return {
+      primary: primaryDate.toISOString(),
+      secondary: cursor.secondary,
+    }
+  }
+  // Override to substitute the PERMANENT_ENDSAT sentinel for NULL endAt rows
+  // so cursor pagination works across permanent (endAt IS NULL) assignments.
+  getSql(labeled?: Cursor, direction?: 'asc' | 'desc', tryIndex?: boolean) {
+    if (labeled === undefined) return
+    const primaryRef = sql`COALESCE(${this.primary}, ${PERMANENT_ENDSAT})`
+    if (tryIndex) {
+      if (direction === 'asc') {
+        return sql`((${primaryRef}, ${this.secondary}) > (${labeled.primary}, ${labeled.secondary}))`
+      } else {
+        return sql`((${primaryRef}, ${this.secondary}) < (${labeled.primary}, ${labeled.secondary}))`
+      }
+    } else {
+      if (direction === 'asc') {
+        return sql`((${primaryRef} > ${labeled.primary}) or (${primaryRef} = ${labeled.primary} and ${this.secondary} > ${labeled.secondary}))`
+      } else {
+        return sql`((${primaryRef} < ${labeled.primary}) or (${primaryRef} = ${labeled.primary} and ${this.secondary} < ${labeled.secondary}))`
+      }
+    }
+  }
+}
+
+type ComputedAtIdKeysetParam = {
+  id: number
+  computedAt: string | Date
+}
+
+export class ComputedAtIdKeyset extends GenericKeyset<
+  ComputedAtIdKeysetParam,
+  Cursor
+> {
+  labelResult(result: ComputedAtIdKeysetParam): Cursor
+  labelResult(result: ComputedAtIdKeysetParam) {
+    return { primary: result.computedAt, secondary: result.id.toString() }
+  }
+  labeledResultToCursor(labeled: Cursor) {
+    return {
+      primary: new Date(labeled.primary).getTime().toString(),
+      secondary: labeled.secondary,
+    }
+  }
+  cursorToLabeledResult(cursor: Cursor) {
+    const primaryDate = new Date(parseInt(cursor.primary, 10))
+    if (isNaN(primaryDate.getTime())) {
+      throw new InvalidRequestError('Malformed cursor')
+    }
+    return {
+      primary: primaryDate.toISOString(),
+      secondary: cursor.secondary,
+    }
+  }
+}
+
 export const paginate = <
   QB extends AnyQb,
   K extends GenericKeyset<unknown, any>,

package/src/db/schema/expiring_tag.ts

@@ -0,0 +1,17 @@
+import { Generated } from 'kysely'
+
+export const tableName = 'expiring_tag'
+
+export interface ExpiringTag {
+  id: Generated<number>
+  eventId: number
+  did: string
+  recordPath: string
+  tag: string
+  expiresAt: string
+  createdBy: string
+}
+
+export type PartialDB = {
+  [tableName]: ExpiringTag
+}

package/src/db/schema/index.ts

@@ -5,16 +5,22 @@ import * as accountRecordStatusStats from './account_record_status_stats'
 import * as accountStrike from './account_strike'
 import * as blobPushEvent from './blob_push_event'
 import * as communicationTemplate from './communication_template'
+import * as expiringTag from './expiring_tag'
 import * as firehoseCursor from './firehose_cursor'
 import * as jobCursor from './job_cursor'
 import * as label from './label'
 import * as member from './member'
 import * as modEvent from './moderation_event'
 import * as modSubjectStatus from './moderation_subject_status'
+import * as moderatorAssignment from './moderator_assignment'
 import * as set from './ozone_set'
 import * as recordEventsStats from './record_events_stats'
 import * as recordPushEvent from './record_push_event'
 import * as repoPushEvent from './repo_push_event'
+import * as report from './report'
+import * as reportActivity from './report_activity'
+import * as reportQueue from './report_queue'
+import * as reportStat from './report_stat'
 import * as safelink from './safelink'
 import * as scheduledAction from './scheduled-action'
 import * as setting from './setting'
@@ -23,6 +29,9 @@ import * as verification from './verification'
 
 export type DatabaseSchemaType = modEvent.PartialDB &
   modSubjectStatus.PartialDB &
+  report.PartialDB &
+  reportActivity.PartialDB &
+  reportQueue.PartialDB &
   label.PartialDB &
   signingKey.PartialDB &
   repoPushEvent.PartialDB &
@@ -41,7 +50,10 @@ export type DatabaseSchemaType = modEvent.PartialDB &
   firehoseCursor.PartialDB &
   jobCursor.PartialDB &
   safelink.PartialDB &
-  scheduledAction.PartialDB
+  scheduledAction.PartialDB &
+  moderatorAssignment.PartialDB &
+  reportStat.PartialDB &
+  expiringTag.PartialDB
 
 export type DatabaseSchema = Kysely<DatabaseSchemaType>
 

package/src/db/schema/moderator_assignment.ts

@@ -0,0 +1,16 @@
+import { Generated } from 'kysely'
+
+export const moderatorAssignmentTableName = 'moderator_assignment'
+
+export interface ModeratorAssignment {
+  id: Generated<number>
+  did: string
+  reportId: number | null
+  queueId: number | null
+  startAt: string
+  endAt: string | null
+}
+
+export type PartialDB = {
+  [moderatorAssignmentTableName]: ModeratorAssignment
+}

package/src/db/schema/report.ts

@@ -0,0 +1,27 @@
+import { Generated } from 'kysely'
+
+export const reportTableName = 'report'
+
+export interface Report {
+  id: Generated<number>
+  eventId: number // References moderation_event.id
+  queueId: number | null // NULL = not yet assigned, -1 = no matching queue
+  queuedAt: string | null
+  actionEventIds: number[] | null // Array of event IDs, sorted DESC [newest, ..., oldest]
+  actionNote: string | null
+  isMuted: boolean
+  status: string // 'open', 'closed', 'escalated', 'queued', 'assigned'
+  reportType: string // Denormalized from moderation_event.meta.reportType
+  did: string // Denormalized from moderation_event.subjectDid
+  recordPath: string // '' = account/message, 'collection/rkey' = record
+  subjectMessageId: string | null // Denormalized from moderation_event.subjectMessageId
+  createdAt: string
+  updatedAt: string
+  assignedTo: string | null // DID of permanently assigned moderator, null if unassigned
+  assignedAt: string | null // When the permanent assignment was created
+  closedAt: string | null
+}
+
+export type PartialDB = {
+  [reportTableName]: Report
+}

package/src/db/schema/report_activity.ts

@@ -0,0 +1,22 @@
+import { Generated } from 'kysely'
+
+export const reportActivityTableName = 'report_activity'
+
+export interface ReportActivity {
+  id: Generated<number>
+  reportId: number
+  // One of: queueActivity | assignmentActivity | escalationActivity
+  //         | closeActivity | internalNoteActivity | publicNoteActivity
+  activityType: string
+  previousStatus: string | null // report status before this activity; null for note-only types
+  internalNote: string | null // moderator-only note
+  publicNote: string | null // potentially reporter-visible note
+  meta: unknown | null // loose activity-specific metadata (e.g. { assignmentId: 42 })
+  isAutomated: boolean
+  createdBy: string // DID of actor (or service DID for automated activities)
+  createdAt: string // ISO string
+}
+
+export type PartialDB = {
+  [reportActivityTableName]: ReportActivity
+}

package/src/db/schema/report_queue.ts

@@ -0,0 +1,21 @@
+import { Generated } from 'kysely'
+
+export const reportQueueTableName = 'report_queue'
+
+export interface ReportQueue {
+  id: Generated<number>
+  name: string
+  subjectTypes: string[] // ['account'] or ['record'] or ['account', 'record']
+  collection: string | null // Collection name (e.g., 'app.bsky.feed.post'), NULL for accounts
+  reportTypes: string[] // Array of report reason types (fully qualified NSIDs)
+  description: string | null // Optional description of the queue
+  createdBy: string // DID of moderator who created this queue
+  createdAt: string
+  updatedAt: string
+  enabled: boolean
+  deletedAt: string | null // NULL = active, timestamp = soft-deleted
+}
+
+export type PartialDB = {
+  [reportQueueTableName]: ReportQueue
+}

package/src/db/schema/report_stat.ts

@@ -0,0 +1,27 @@
+import { Generated } from 'kysely'
+
+export const reportStatTableName = 'report_stat'
+
+export interface ReportStat {
+  // metadata
+  id: Generated<number>
+  computedAt: string // When this snapshot was last computed
+
+  // group
+  date: string // ISO date e.g. '2026-04-15' — the calendar day this snapshot covers
+  queueId: number | null // NULL = aggregate across all queues
+  reportTypes: string[] | null // NULL = aggregate across all report types
+  moderatorDid: string | null // NULL = aggregate, non-null = per-moderator
+
+  // stats
+  inboundCount: number | null // Reports received during this calendar day
+  pendingCount: number | null // Reports with status != 'closed' at time of computation
+  actionedCount: number | null // Reports closed during this calendar day
+  escalatedCount: number | null // Reports escalated during this calendar day
+  actionRate: number | null // actionedCount / inboundCount * 100
+  avgHandlingTimeSec: number | null // Average time from creation/assignment to close, in seconds
+}
+
+export type PartialDB = {
+  [reportStatTableName]: ReportStat
+}