feat: p2 batch 28-31 reminders lists comments bang stats

Calendar events support multiple reminder offsets with presets and per-user defaults. Lists index adds inline task entry and list property editing. Generic entity comments on list detail. New bangs.stats dashboard widget. Closes Gitea #28, #29, #30, #31. Migrations 0022 and 0023.
2026-07-04 22:17:35 -05:00
parent 7714b1187c
commit e1c2a090fb
31 changed files with 1287 additions and 92 deletions
@@ -0,0 +1,107 @@
+"use server";
+
+import { and, asc, eq } from "drizzle-orm";
+import { revalidatePath } from "next/cache";
+import { z } from "zod";
+import { db } from "@/lib/db";
+import { getCurrentSession } from "@/lib/session";
+import { comments, users } from "./schema";
+
+export type CommentDto = {
+  id: string;
+  entityType: string;
+  entityId: string;
+  body: string;
+  authorId: string;
+  authorName: string | null;
+  createdAt: string;
+};
+
+const commentInput = z.object({
+  entityType: z.string().trim().min(1).max(80),
+  entityId: z.string().uuid(),
+  body: z.string().trim().min(1).max(2000),
+});
+
+export async function listComments(entityType: string, entityId: string): Promise<CommentDto[]> {
+  const { household } = await getCurrentSession();
+  const parsedEntityId = z.string().uuid().parse(entityId);
+
+  const rows = await db
+    .select({
+      id: comments.id,
+      entityType: comments.entityType,
+      entityId: comments.entityId,
+      body: comments.body,
+      authorId: comments.authorId,
+      authorName: users.name,
+      createdAt: comments.createdAt,
+    })
+    .from(comments)
+    .innerJoin(users, eq(comments.authorId, users.id))
+    .where(
+      and(
+        eq(comments.householdId, household.id),
+        eq(comments.entityType, entityType),
+        eq(comments.entityId, parsedEntityId),
+      ),
+    )
+    .orderBy(asc(comments.createdAt));
+
+  return rows.map((row) => ({
+    id: row.id,
+    entityType: row.entityType,
+    entityId: row.entityId,
+    body: row.body,
+    authorId: row.authorId,
+    authorName: row.authorName,
+    createdAt: row.createdAt.toISOString(),
+  }));
+}
+
+export async function addComment(input: z.input<typeof commentInput>): Promise<CommentDto> {
+  const parsed = commentInput.parse(input);
+  const { user, household } = await getCurrentSession();
+
+  const [row] = await db
+    .insert(comments)
+    .values({
+      householdId: household.id,
+      entityType: parsed.entityType,
+      entityId: parsed.entityId,
+      authorId: user.id,
+      body: parsed.body,
+    })
+    .returning();
+
+  if (!row) throw new Error("Comment was not created");
+
+  revalidatePath("/lists");
+
+  return {
+    id: row.id,
+    entityType: row.entityType,
+    entityId: row.entityId,
+    body: row.body,
+    authorId: row.authorId,
+    authorName: user.name,
+    createdAt: row.createdAt.toISOString(),
+  };
+}
+
+export async function deleteComment(input: { id: string }) {
+  const parsed = z.object({ id: z.string().uuid() }).parse(input);
+  const { user, household } = await getCurrentSession();
+
+  const [existing] = await db
+    .select({ id: comments.id, authorId: comments.authorId })
+    .from(comments)
+    .where(and(eq(comments.id, parsed.id), eq(comments.householdId, household.id)))
+    .limit(1);
+
+  if (!existing) throw new Error("Comment not found");
+  if (existing.authorId !== user.id) throw new Error("Forbidden");
+
+  await db.delete(comments).where(eq(comments.id, parsed.id));
+  revalidatePath("/lists");
+}
@@ -24,4 +24,13 @@ export { createShareLink, resolveShareToken, revokeShareLink } from "./share";
 export type { ShareLinkCapabilities, CreateShareLinkResult } from "./share";
 export { sendPush, sendPushToEndpoint } from "./push";
 export { notify } from "./notify";
-export { scheduleReminder, cancelReminder, listReminders, startReminderWorker } from "./reminders";
+export {
+  scheduleReminder,
+  cancelReminder,
+  listReminders,
+  listReminderOffsets,
+  syncRemindersForEntity,
+  syncCalendarEventReminders,
+  startReminderWorker,
+} from "./reminders";
+export { listComments, addComment, deleteComment, type CommentDto } from "./comments";
@@ -1,11 +1,19 @@
 import { and, eq, inArray, isNull, lte, sql } from "drizzle-orm";
 import { db } from "@/lib/db";
 import logger from "@/lib/logger";
+import { fireAtForEventStart } from "@/lib/reminder-offsets";
 import { reminders } from "./schema";
 import { notify } from "./notify";

 const REMINDER_LOCK_KEY = 7_777_777;

+type ReminderInput = {
+  fireAt: Date;
+  offsetMinutes?: number | null;
+  title?: string;
+  body?: string;
+};
+
 export async function scheduleReminder(input: {
  householdId: string;
  entityType: string;
@@ -15,30 +23,92 @@ export async function scheduleReminder(input: {
  channel?: string;
  title?: string;
  body?: string;
+  offsetMinutes?: number | null;
 }) {
  await db
-    .insert(reminders)
-    .values({
+    .delete(reminders)
+    .where(
+      and(
+        eq(reminders.entityType, input.entityType),
+        eq(reminders.entityId, input.entityId),
+        isNull(reminders.firedAt),
+      ),
+    );
+
+  await db.insert(reminders).values({
+    householdId: input.householdId,
+    entityType: input.entityType,
+    entityId: input.entityId,
+    fireAt: input.fireAt,
+    offsetMinutes: input.offsetMinutes ?? null,
+    channel: input.channel ?? "auto",
+    title: input.title ?? null,
+    body: input.body ?? null,
+    createdBy: input.createdBy,
+    firedAt: null,
+  });
+}
+
+export async function syncRemindersForEntity(input: {
+  householdId: string;
+  entityType: string;
+  entityId: string;
+  createdBy: string;
+  channel?: string;
+  reminders: ReminderInput[];
+}) {
+  await db
+    .delete(reminders)
+    .where(
+      and(
+        eq(reminders.entityType, input.entityType),
+        eq(reminders.entityId, input.entityId),
+        isNull(reminders.firedAt),
+      ),
+    );
+
+  const now = new Date();
+  const rows = input.reminders.filter((r) => r.fireAt > now);
+  if (rows.length === 0) return;
+
+  await db.insert(reminders).values(
+    rows.map((row) => ({
      householdId: input.householdId,
      entityType: input.entityType,
      entityId: input.entityId,
-      fireAt: input.fireAt,
+      fireAt: row.fireAt,
+      offsetMinutes: row.offsetMinutes ?? null,
      channel: input.channel ?? "auto",
-      title: input.title ?? null,
-      body: input.body ?? null,
+      title: row.title ?? null,
+      body: row.body ?? null,
      createdBy: input.createdBy,
      firedAt: null,
-    })
-    .onConflictDoUpdate({
-      target: [reminders.entityType, reminders.entityId],
-      set: {
-        fireAt: input.fireAt,
-        title: input.title ?? null,
-        body: input.body ?? null,
-        firedAt: null,
-        createdBy: input.createdBy,
-      },
-    });
+    })),
+  );
+}
+
+export async function syncCalendarEventReminders(input: {
+  householdId: string;
+  eventId: string;
+  eventTitle: string;
+  startAt: Date;
+  createdBy: string;
+  offsetMinutes: number[];
+}) {
+  const remindersToSchedule = input.offsetMinutes.map((offset) => ({
+    fireAt: fireAtForEventStart(input.startAt, offset),
+    offsetMinutes: offset,
+    title: input.eventTitle,
+    body: formatReminderOffsetBody(offset, input.eventTitle),
+  }));
+
+  await syncRemindersForEntity({
+    householdId: input.householdId,
+    entityType: "calendar.event",
+    entityId: input.eventId,
+    createdBy: input.createdBy,
+    reminders: remindersToSchedule,
+  });
 }

 export async function cancelReminder(entityType: string, entityId: string) {
@@ -54,6 +124,29 @@ export async function listReminders(entityType: string, entityId: string) {
    .where(and(eq(reminders.entityType, entityType), eq(reminders.entityId, entityId)));
 }

+export async function listReminderOffsets(entityType: string, entityId: string): Promise<number[]> {
+  const rows = await listReminders(entityType, entityId);
+  return rows
+    .filter((row) => row.offsetMinutes != null && row.firedAt == null)
+    .map((row) => row.offsetMinutes!)
+    .toSorted((a, b) => b - a);
+}
+
+function formatReminderOffsetBody(offsetMinutes: number, title: string): string {
+  if (offsetMinutes === 0) return `${title} is starting now`;
+  if (offsetMinutes % 1440 === 0) {
+    const days = offsetMinutes / 1440;
+    return days === 1 ? `${title} starts in 1 day` : `${title} starts in ${days} days`;
+  }
+  if (offsetMinutes % 60 === 0) {
+    const hours = offsetMinutes / 60;
+    return hours === 1 ? `${title} starts in 1 hour` : `${title} starts in ${hours} hours`;
+  }
+  return offsetMinutes === 1
+    ? `${title} starts in 1 minute`
+    : `${title} starts in ${offsetMinutes} minutes`;
+}
+
 async function tickReminders() {
  let dueReminders: (typeof reminders.$inferSelect)[] = [];

@@ -94,7 +187,12 @@ async function tickReminders() {
        await notify(reminder.createdBy, {
          title: reminder.title ?? "Reminder",
          body: reminder.body ?? "You have a reminder",
-          url: reminder.entityType === "notes.note" ? `/notes/${reminder.entityId}` : "/",
+          url:
+            reminder.entityType === "notes.note"
+              ? `/notes/${reminder.entityId}`
+              : reminder.entityType === "calendar.event"
+                ? "/calendar"
+                : "/",
          channels: ["push", "inapp"],
        });
      } catch (err) {
@@ -36,6 +36,10 @@ export const users = pgTable("users", {
  notifInApp: boolean("notif_inapp").notNull().default(true),
  notifNtfy: boolean("notif_ntfy").notNull().default(false),
  assistantEnabled: boolean("assistant_enabled").notNull().default(false),
+  defaultEventReminderOffsets: jsonb("default_event_reminder_offsets")
+    .notNull()
+    .$type<number[]>()
+    .default([30]),
  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
 });

@@ -170,12 +174,13 @@ export const reminders = pgTable(
    channel: text("channel").notNull().default("auto"),
    title: text("title"),
    body: text("body"),
+    offsetMinutes: integer("offset_minutes"),
    firedAt: timestamp("fired_at", { withTimezone: true }),
    createdBy: uuid("created_by").references(() => users.id, { onDelete: "set null" }),
    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
  },
  (t) => [
-    uniqueIndex("reminders_entity_unique").on(t.entityType, t.entityId),
+    index("reminders_entity_idx").on(t.entityType, t.entityId),
    index("reminders_household_fire_at_idx").on(t.householdId, t.fireAt),
  ],
 );
@@ -212,6 +217,25 @@ export const notifications = pgTable(
  (t) => [index("notifications_user_read_idx").on(t.userId, t.readAt)],
 );

+export const comments = pgTable(
+  "comments",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    householdId: uuid("household_id")
+      .notNull()
+      .references(() => households.id, { onDelete: "cascade" }),
+    entityType: text("entity_type").notNull(),
+    entityId: uuid("entity_id").notNull(),
+    authorId: uuid("author_id")
+      .notNull()
+      .references(() => users.id, { onDelete: "cascade" }),
+    body: text("body").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (t) => [index("comments_entity_idx").on(t.entityType, t.entityId, t.createdAt)],
+);
+
 export const householdApiTokens = pgTable(
  "household_api_tokens",
  {
@@ -0,0 +1,55 @@
+import type { BangAggregatesDto } from "../server/queries";
+
+type Props = {
+  aggregates: BangAggregatesDto;
+};
+
+export function BangStatsWidget({ aggregates }: Props) {
+  const recentMonths = aggregates.monthlyCounts.slice(-6);
+
+  return (
+    <div className="flex flex-col gap-4">
+      <div className="grid grid-cols-3 gap-3">
+        <StatBlock label="This month" value={String(aggregates.thisMonth)} />
+        <StatBlock label="This year" value={String(aggregates.thisYear)} />
+        <StatBlock
+          label="Avg gap"
+          value={aggregates.averageDaysBetween == null ? "—" : `${aggregates.averageDaysBetween}d`}
+        />
+      </div>
+
+      {recentMonths.length > 0 ? (
+        <div className="space-y-2">
+          <p className="text-xs font-medium text-[var(--ink-mute)]">Recent months</p>
+          <div className="space-y-1.5">
+            {recentMonths.map((row) => (
+              <div key={row.month} className="flex items-center justify-between text-sm">
+                <span>{formatMonth(row.month)}</span>
+                <span className="tabular-nums font-medium">{row.count}</span>
+              </div>
+            ))}
+          </div>
+        </div>
+      ) : (
+        <p className="text-sm text-[var(--ink-mute)]">No bangs recorded yet.</p>
+      )}
+    </div>
+  );
+}
+
+function StatBlock({ label, value }: { label: string; value: string }) {
+  return (
+    <div className="rounded-lg border border-[var(--hair)] px-3 py-2">
+      <div className="text-[11px] uppercase tracking-wide text-[var(--ink-mute)]">{label}</div>
+      <div className="text-2xl font-semibold tabular-nums">{value}</div>
+    </div>
+  );
+}
+
+function formatMonth(monthKey: string): string {
+  const [year, month] = monthKey.split("-").map(Number);
+  return new Date(year!, month! - 1, 1).toLocaleDateString(undefined, {
+    month: "short",
+    year: "numeric",
+  });
+}
@@ -1,18 +1,26 @@
 import { z } from "zod";
 import type { ModuleManifest, WidgetContext } from "../_core/module";
-import { getBangStats } from "./server/queries";
+import { getBangAggregates, getBangStats } from "./server/queries";
 import { BangWidget } from "./components/bang-widget";
+import { BangStatsWidget } from "./components/bang-stats-widget";

 const bangWidgetConfigSchema = z.object({
  maxRecentBangs: z.number().int().min(1).max(20).default(5),
 });

+const bangStatsConfigSchema = z.object({});
+
 async function BangWidgetServer({ config, ctx }: { config: unknown; ctx: WidgetContext }) {
  const parsed = bangWidgetConfigSchema.parse(config);
  const stats = await getBangStats(ctx.householdId, parsed.maxRecentBangs);
  return <BangWidget stats={stats} maxRecentBangs={parsed.maxRecentBangs} />;
 }

+async function BangStatsWidgetServer({ ctx }: { config: unknown; ctx: WidgetContext }) {
+  const aggregates = await getBangAggregates(ctx.householdId);
+  return <BangStatsWidget aggregates={aggregates} />;
+}
+
 const bangsManifest: ModuleManifest = {
  id: "bangs",
  name: "Bangs",
@@ -44,6 +52,18 @@ const bangsManifest: ModuleManifest = {
      defaultConfig: { maxRecentBangs: 5 },
      render: (props) => <BangWidgetServer {...props} />,
    },
+    {
+      id: "bangs.stats",
+      title: "Bang Stats",
+      description: "Monthly and yearly bang counts plus average days between bangs.",
+      category: "Fun",
+      defaultSize: { w: 3, h: 3 },
+      minSize: { w: 2, h: 2 },
+      defaultPriority: 55,
+      configSchema: bangStatsConfigSchema,
+      defaultConfig: {},
+      render: (props) => <BangStatsWidgetServer {...props} />,
+    },
  ],
  quickAdds: [
    {
@@ -1,4 +1,4 @@
-import { count, desc, eq } from "drizzle-orm";
+import { asc, count, desc, eq, sql } from "drizzle-orm";
 import { db } from "@/lib/db";
 import { users } from "@/modules/_core/schema";
 import { bangEvents } from "../schema";
@@ -14,6 +14,13 @@ export type RecentBangDto = {
  recordedByName: string | null;
 };

+export type BangAggregatesDto = {
+  thisMonth: number;
+  thisYear: number;
+  averageDaysBetween: number | null;
+  monthlyCounts: { month: string; count: number }[];
+};
+
 export async function getBangStatsForScope(
  householdId: string,
  limit: number,
@@ -48,3 +55,61 @@ export async function getBangStatsForScope(
 export async function getBangStats(householdId: string, limit: number): Promise<BangStatsDto> {
  return getBangStatsForScope(householdId, limit);
 }
+
+export async function getBangAggregates(householdId: string): Promise<BangAggregatesDto> {
+  const now = new Date();
+  const monthPrefix = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}`;
+  const yearPrefix = `${now.getFullYear()}-`;
+
+  const [thisMonthRow] = await db
+    .select({ count: sql<number>`count(*)::int` })
+    .from(bangEvents)
+    .where(
+      sql`${bangEvents.householdId} = ${householdId} and ${bangEvents.occurredOn} like ${`${monthPrefix}%`}`,
+    );
+
+  const [thisYearRow] = await db
+    .select({ count: sql<number>`count(*)::int` })
+    .from(bangEvents)
+    .where(
+      sql`${bangEvents.householdId} = ${householdId} and ${bangEvents.occurredOn} like ${`${yearPrefix}%`}`,
+    );
+
+  const monthlyRows = await db
+    .select({
+      month: sql<string>`substring(${bangEvents.occurredOn}, 1, 7)`,
+      count: sql<number>`count(*)::int`,
+    })
+    .from(bangEvents)
+    .where(eq(bangEvents.householdId, householdId))
+    .groupBy(sql`substring(${bangEvents.occurredOn}, 1, 7)`)
+    .orderBy(asc(sql`substring(${bangEvents.occurredOn}, 1, 7)`));
+
+  const dateRows = await db
+    .select({ occurredOn: bangEvents.occurredOn })
+    .from(bangEvents)
+    .where(eq(bangEvents.householdId, householdId))
+    .orderBy(asc(bangEvents.occurredOn));
+
+  let averageDaysBetween: number | null = null;
+  if (dateRows.length >= 2) {
+    const dates = dateRows.map((row) => parseBangDate(row.occurredOn).getTime());
+    let totalGapDays = 0;
+    for (let i = 1; i < dates.length; i++) {
+      totalGapDays += (dates[i]! - dates[i - 1]!) / (1000 * 60 * 60 * 24);
+    }
+    averageDaysBetween = Math.round((totalGapDays / (dates.length - 1)) * 10) / 10;
+  }
+
+  return {
+    thisMonth: thisMonthRow?.count ?? 0,
+    thisYear: thisYearRow?.count ?? 0,
+    averageDaysBetween,
+    monthlyCounts: monthlyRows.map((row) => ({ month: row.month, count: row.count })),
+  };
+}
+
+function parseBangDate(isoDate: string): Date {
+  const [year, month, day] = isoDate.split("-").map(Number);
+  return new Date(year!, month! - 1, day!);
+}
@@ -15,6 +15,7 @@ import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
 import { ShareButton } from "@/components/share-button";
+import { ReminderPicker } from "@/components/reminder-picker";
 import type { CalView } from "@/modules/_core/themes";
 import {
  Select,
@@ -25,6 +26,7 @@ import {
  SelectValue,
 } from "@/components/ui/select";
 import type { CalendarDto, CalendarEventDto } from "../server/queries";
+import { getEventReminderOffsets } from "../server/queries";
 import {
  createCalendar,
  createEvent,
@@ -57,7 +59,7 @@ type EventDraft = {
  allDay: boolean;
  location: string;
  notes: string;
-  remindMinutesBefore: number | null;
+  reminderOffsets: number[];
 };

 type MobileView = "day" | "week" | "agenda";
@@ -99,10 +101,12 @@ export function CalendarShell({
  calendars,
  events,
  defaultView = "month",
+  defaultReminderOffsets = [30],
 }: {
  calendars: CalendarDto[];
  events: CalendarEventDto[];
  defaultView?: CalView;
+  defaultReminderOffsets?: number[];
 }) {
  const [calendarRows, setCalendarRows] = useState(calendars);
  const [eventRows, setEventRows] = useState(events);
@@ -160,13 +164,14 @@ export function CalendarShell({
      allDay,
      location: "",
      notes: "",
-      remindMinutesBefore: 30,
+      reminderOffsets: [...defaultReminderOffsets],
    });
  }

  function openExistingEvent({ event }: EventClickArg) {
    const row = eventRows.find((item) => item.id === event.id);
    if (!row) return;
+    const eventId = row.id;
    setSelectedEvent({
      id: row.id,
      calendarId: row.calendarId,
@@ -176,7 +181,12 @@ export function CalendarShell({
      allDay: row.allDay,
      location: row.location ?? "",
      notes: row.notes ?? "",
-      remindMinutesBefore: null,
+      reminderOffsets: [],
+    });
+    void getEventReminderOffsets(eventId).then((offsets) => {
+      setSelectedEvent((current) =>
+        current?.id === eventId ? { ...current, reminderOffsets: offsets } : current,
+      );
    });
  }

@@ -199,7 +209,11 @@ export function CalendarShell({

    startTransition(async () => {
      if (eventId) {
-        await updateEvent({ id: eventId, ...payload });
+        await updateEvent({
+          id: eventId,
+          ...payload,
+          reminderOffsets: selectedEvent.reminderOffsets,
+        });
        setLastCalendarId(payload.calendarId);
        setEventRows((current) =>
          current.map((event) =>
@@ -220,7 +234,7 @@ export function CalendarShell({
      } else {
        const created = await createEvent({
          ...payload,
-          remindMinutesBefore: selectedEvent.remindMinutesBefore,
+          reminderOffsets: selectedEvent.reminderOffsets,
        });
        setLastCalendarId(payload.calendarId);
        setEventRows((current) => [...current, created]);
@@ -538,22 +552,11 @@ export function CalendarShell({
          placeholder="Add details…"
        />
      </div>
-      {!selectedEvent.id && (
-        <label className="flex items-center gap-2 text-sm">
-          <input
-            type="checkbox"
-            className="size-4 cursor-pointer"
-            checked={selectedEvent.remindMinutesBefore !== null}
-            onChange={(e) =>
-              setSelectedEvent({
-                ...selectedEvent,
-                remindMinutesBefore: e.target.checked ? 30 : null,
-              })
-            }
-          />
-          Remind me 30 min before
-        </label>
-      )}
+      <ReminderPicker
+        offsets={selectedEvent.reminderOffsets}
+        onChange={(reminderOffsets) => setSelectedEvent({ ...selectedEvent, reminderOffsets })}
+        disabled={isPending}
+      />
      <div className="flex items-center justify-between gap-2 pt-2">
        <div className="flex gap-2">
          {selectedEvent.id && (
@@ -7,7 +7,12 @@ import { db } from "@/lib/db";
 import { getCurrentSession } from "@/lib/session";
 import { logActivityForScope } from "@/modules/_core/activity";
 import { householdMembers } from "@/modules/_core/schema";
-import { scheduleReminder, cancelReminder } from "@/modules/_core/reminders";
+import {
+  cancelReminder,
+  syncCalendarEventReminders,
+  listReminderOffsets,
+} from "@/modules/_core/reminders";
+import { normalizeReminderOffsets } from "@/lib/reminder-offsets";
 import { calendarEvents, calendars } from "../schema";
 import { canSeeCalendarForScope, type ApiScope, type CalendarEventDto } from "./queries";
 import { calendarInput, calendarUpdateInput, eventInput, eventUpdateInput } from "./schemas";
@@ -193,17 +198,16 @@ export async function createEventForScope(

  if (!event) throw new Error("Event was not created");

-  if (parsed.remindMinutesBefore != null && scope.userId) {
-    const fireAt = new Date(parsed.startAt.getTime() - parsed.remindMinutesBefore * 60_000);
-    if (fireAt > new Date()) {
-      await scheduleReminder({
-        householdId: scope.householdId,
-        entityType: "calendar.event",
-        entityId: event.id,
-        fireAt,
-        createdBy: scope.userId,
-      });
-    }
+  const reminderOffsets = resolveReminderOffsets(parsed);
+  if (reminderOffsets.length > 0 && scope.userId) {
+    await syncCalendarEventReminders({
+      householdId: scope.householdId,
+      eventId: event.id,
+      eventTitle: event.title,
+      startAt: parsed.startAt,
+      createdBy: scope.userId,
+      offsetMinutes: reminderOffsets,
+    });
  }

  await logActivityForScope(scope, {
@@ -256,6 +260,43 @@ export async function updateEventForScope(
    })
    .where(eq(calendarEvents.id, parsed.id));

+  if (scope.userId) {
+    const [updated] = await db
+      .select({ title: calendarEvents.title, startAt: calendarEvents.startAt })
+      .from(calendarEvents)
+      .where(eq(calendarEvents.id, parsed.id))
+      .limit(1);
+
+    if (updated) {
+      const startAt = parsed.startAt ?? updated.startAt;
+      let offsets: number[];
+
+      if (parsed.reminderOffsets !== undefined || parsed.remindMinutesBefore !== undefined) {
+        offsets = resolveReminderOffsets(parsed);
+      } else if (parsed.startAt !== undefined) {
+        offsets = await listReminderOffsets("calendar.event", parsed.id);
+      } else {
+        offsets = [];
+      }
+
+      if (
+        offsets.length === 0 &&
+        (parsed.reminderOffsets !== undefined || parsed.remindMinutesBefore !== undefined)
+      ) {
+        await cancelReminder("calendar.event", parsed.id);
+      } else if (offsets.length > 0) {
+        await syncCalendarEventReminders({
+          householdId: scope.householdId,
+          eventId: parsed.id,
+          eventTitle: updated.title,
+          startAt,
+          createdBy: scope.userId,
+          offsetMinutes: offsets,
+        });
+      }
+    }
+  }
+
  await logActivityForScope(scope, {
    entityType: "calendar.event",
    entityId: parsed.id,
@@ -304,3 +345,16 @@ async function assertOwnsCalendar(userId: string, calendarId: string) {

  if (!calendar) throw new Error("Forbidden");
 }
+
+function resolveReminderOffsets(input: {
+  reminderOffsets?: number[];
+  remindMinutesBefore?: number | null;
+}): number[] {
+  if (input.reminderOffsets !== undefined) {
+    return normalizeReminderOffsets(input.reminderOffsets);
+  }
+  if (input.remindMinutesBefore != null) {
+    return normalizeReminderOffsets([input.remindMinutesBefore]);
+  }
+  return [];
+}
@@ -4,6 +4,8 @@ import { and, asc, eq, gte, inArray, lte, or, sql } from "drizzle-orm";
 import { z } from "zod";
 import { db } from "@/lib/db";
 import { getCurrentSession } from "@/lib/session";
+import { normalizeReminderOffsets } from "@/lib/reminder-offsets";
+import { listReminderOffsets } from "@/modules/_core/reminders";
 import { householdMembers } from "@/modules/_core/schema";
 import { calendarEvents, calendars } from "../schema";

@@ -258,6 +260,19 @@ export async function searchEvents(query: string, householdId: string) {
  }));
 }

+export async function getDefaultEventReminderOffsets(): Promise<number[]> {
+  const { user } = await getCurrentSession();
+  return normalizeReminderOffsets(user.defaultEventReminderOffsets ?? [30]);
+}
+
+export async function getEventReminderOffsets(eventId: string): Promise<number[]> {
+  const parsed = z.string().uuid().parse(eventId);
+  const { user, household } = await getCurrentSession();
+  const event = await getEventForScope({ householdId: household.id, userId: user.id }, parsed);
+  if (!event) throw new Error("Event not found");
+  return listReminderOffsets("calendar.event", parsed);
+}
+
 function toEventDto(row: {
  id: string;
  calendarId: string;
@@ -20,6 +20,8 @@ export const eventBaseInput = z.object({
  allDay: z.boolean().default(false),
  location: z.string().trim().max(300).nullable().optional(),
  notes: z.string().trim().max(3000).nullable().optional(),
+  reminderOffsets: z.array(z.number().int().min(0)).optional(),
+  /** @deprecated use reminderOffsets */
  remindMinutesBefore: z.number().int().min(0).nullable().optional(),
 });

@@ -4,6 +4,7 @@ import { useRouter } from "next/navigation";
 import { Archive, Plus, Trash2 } from "lucide-react";
 import { useEffect, useRef, useState, useTransition } from "react";
 import { DetailBackLink } from "@/components/detail-back-link";
+import { EntityComments } from "@/components/comments/entity-comments";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { ShareButton } from "@/components/share-button";
@@ -18,7 +19,13 @@ import {
  updateItem,
 } from "../server/actions";

-export function ListDetail({ initialList }: { initialList: ListDetailDto }) {
+export function ListDetail({
+  initialList,
+  currentUserId,
+}: {
+  initialList: ListDetailDto;
+  currentUserId: string;
+}) {
  const router = useRouter();
  const [list, setList] = useState(initialList);
  const [draft, setDraft] = useState("");
@@ -156,6 +163,7 @@ export function ListDetail({ initialList }: { initialList: ListDetailDto }) {
          <ListItemRow
            key={item.id}
            item={item}
+            currentUserId={currentUserId}
            onToggle={(done) => setItemDone(item, done)}
            onEdit={(text) => editItemText(item, text)}
            onCommit={() => commitItemText(item)}
@@ -170,6 +178,7 @@ export function ListDetail({ initialList }: { initialList: ListDetailDto }) {
              <ListItemRow
                key={item.id}
                item={item}
+                currentUserId={currentUserId}
                onToggle={(done) => setItemDone(item, done)}
                onEdit={(text) => editItemText(item, text)}
                onCommit={() => commitItemText(item)}
@@ -179,18 +188,22 @@ export function ListDetail({ initialList }: { initialList: ListDetailDto }) {
          </>
        )}
      </div>
+
+      <EntityComments entityType="lists.list" entityId={list.id} currentUserId={currentUserId} />
    </div>
  );
 }

 function ListItemRow({
  item,
+  currentUserId,
  onToggle,
  onEdit,
  onCommit,
  onRemove,
 }: {
  item: ListItemDto;
+  currentUserId: string;
  onToggle: (done: boolean) => void;
  onEdit: (text: string) => void;
  onCommit: () => void;
@@ -333,6 +346,14 @@ function ListItemRow({
          <Trash2 className="size-3.5" />
        </Button>
      </div>
+      <div className="px-[14px] pb-2">
+        <EntityComments
+          entityType="lists.item"
+          entityId={item.id}
+          currentUserId={currentUserId}
+          compact
+        />
+      </div>
    </div>
  );
 }
@@ -1,13 +1,13 @@
 "use client";

 import Link from "next/link";
-import { ChevronDown, ChevronRight, ExternalLink, Plus } from "lucide-react";
+import { ChevronDown, ChevronRight, ExternalLink, Pencil, Plus } from "lucide-react";
 import { useMemo, useState, useTransition } from "react";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
 import type { ListIndexItem, ListWithItemsDto } from "../server/queries";
-import { createList, toggleItem } from "../server/actions";
+import { addItem, createList, toggleItem, updateListProperties } from "../server/actions";

 export function ListsIndex({ lists }: { lists: ListWithItemsDto[] }) {
  const [listRows, setListRows] = useState(lists);
@@ -61,6 +61,44 @@ export function ListsIndex({ lists }: { lists: ListWithItemsDto[] }) {
    });
  }

+  function handleAddItem(listId: string, text: string) {
+    setListRows((current) =>
+      current.map((list) =>
+        list.id !== listId
+          ? list
+          : {
+              ...list,
+              openCount: list.openCount + 1,
+              items: [
+                ...list.items,
+                {
+                  id: `temp-${Date.now()}`,
+                  text,
+                  done: false,
+                  position: list.items.length,
+                },
+              ],
+            },
+      ),
+    );
+
+    startTransition(async () => {
+      await addItem({ listId, text });
+      const { listListsWithItems } = await import("../server/queries");
+      const refreshed = await listListsWithItems();
+      setListRows(refreshed);
+    });
+  }
+
+  function handleUpdateList(listId: string, patch: { name?: string; type?: string }) {
+    setListRows((current) =>
+      current.map((list) => (list.id === listId ? { ...list, ...patch } : list)),
+    );
+    startTransition(async () => {
+      await updateListProperties({ id: listId, ...patch });
+    });
+  }
+
  return (
    <div className="mx-auto grid w-full max-w-5xl gap-6">
      <div className="flex flex-col gap-2 sm:flex-row sm:items-end sm:justify-between">
@@ -101,7 +139,13 @@ export function ListsIndex({ lists }: { lists: ListWithItemsDto[] }) {
            <div className="eyebrow">{groupType}</div>
            <div className="grid gap-3 sm:grid-cols-2 lg:grid-cols-3">
              {groupLists.map((list) => (
-                <ListCard key={list.id} list={list} onToggle={handleToggle} />
+                <ListCard
+                  key={list.id}
+                  list={list}
+                  onToggle={handleToggle}
+                  onAddItem={handleAddItem}
+                  onUpdateList={handleUpdateList}
+                />
              ))}
            </div>
          </section>
@@ -114,11 +158,34 @@ export function ListsIndex({ lists }: { lists: ListWithItemsDto[] }) {
 function ListCard({
  list,
  onToggle,
+  onAddItem,
+  onUpdateList,
 }: {
  list: ListWithItemsDto;
  onToggle: (listId: string, item: ListIndexItem, done: boolean) => void;
+  onAddItem: (listId: string, text: string) => void;
+  onUpdateList: (listId: string, patch: { name?: string; type?: string }) => void;
 }) {
  const [expanded, setExpanded] = useState(true);
+  const [editing, setEditing] = useState(false);
+  const [draftName, setDraftName] = useState(list.name);
+  const [draftType, setDraftType] = useState(list.type);
+  const [itemDraft, setItemDraft] = useState("");
+
+  function saveListProperties() {
+    const name = draftName.trim();
+    const type = draftType.trim();
+    if (!name || !type) return;
+    onUpdateList(list.id, { name, type });
+    setEditing(false);
+  }
+
+  function submitItem() {
+    const text = itemDraft.trim();
+    if (!text) return;
+    onAddItem(list.id, text);
+    setItemDraft("");
+  }

  return (
    <div
@@ -135,22 +202,60 @@ function ListCard({
          >
            {expanded ? <ChevronDown className="size-4" /> : <ChevronRight className="size-4" />}
          </button>
-          <div className="min-w-0">
-            <h3 className="serif text-[15px] truncate text-[var(--ink)] m-0 font-medium">
-              {list.name}
-            </h3>
-            <div className="meta">
-              {list.openCount} open · {list.doneCount} done
-            </div>
+          <div className="min-w-0 flex-1">
+            {editing ? (
+              <div className="grid gap-2">
+                <Input value={draftName} onChange={(e) => setDraftName(e.target.value)} />
+                <Input value={draftType} onChange={(e) => setDraftType(e.target.value)} />
+                <div className="flex gap-2">
+                  <Button type="button" size="sm" onClick={saveListProperties}>
+                    Save
+                  </Button>
+                  <Button
+                    type="button"
+                    size="sm"
+                    variant="ghost"
+                    onClick={() => {
+                      setDraftName(list.name);
+                      setDraftType(list.type);
+                      setEditing(false);
+                    }}
+                  >
+                    Cancel
+                  </Button>
+                </div>
+              </div>
+            ) : (
+              <>
+                <h3 className="serif text-[15px] truncate text-[var(--ink)] m-0 font-medium">
+                  {list.name}
+                </h3>
+                <div className="meta">
+                  {list.type} · {list.openCount} open · {list.doneCount} done
+                </div>
+              </>
+            )}
          </div>
        </div>
-        <Link
-          href={`/lists/${list.id}`}
-          className="shrink-0 text-[var(--ink-mute)] hover:text-[var(--ink)] transition-colors"
-          aria-label={`Open ${list.name}`}
-        >
-          <ExternalLink className="size-4" />
-        </Link>
+        <div className="flex shrink-0 items-center gap-1">
+          {!editing && (
+            <button
+              type="button"
+              onClick={() => setEditing(true)}
+              className="text-[var(--ink-mute)] hover:text-[var(--ink)] transition-colors"
+              aria-label={`Edit ${list.name}`}
+            >
+              <Pencil className="size-4" />
+            </button>
+          )}
+          <Link
+            href={`/lists/${list.id}`}
+            className="text-[var(--ink-mute)] hover:text-[var(--ink)] transition-colors"
+            aria-label={`Open ${list.name}`}
+          >
+            <ExternalLink className="size-4" />
+          </Link>
+        </div>
      </div>

      {expanded && (
@@ -204,6 +309,23 @@ function ListCard({
              )}
            </div>
          )}
+
+          <div className="flex gap-2 px-[14px] py-3 border-t border-[var(--hair)]">
+            <Input
+              value={itemDraft}
+              onChange={(e) => setItemDraft(e.target.value)}
+              placeholder="Add a task…"
+              onKeyDown={(e) => {
+                if (e.key === "Enter") {
+                  e.preventDefault();
+                  submitItem();
+                }
+              }}
+            />
+            <Button type="button" size="sm" disabled={!itemDraft.trim()} onClick={submitItem}>
+              Add
+            </Button>
+          </div>
        </div>
      )}
    </div>
@@ -59,16 +59,20 @@ export async function updateListForScope(
    .update(lists)
    .set({
      name: parsed.name,
+      type: parsed.type,
      archived: parsed.archived,
    })
    .where(eq(lists.id, parsed.id));

-  if (parsed.name) {
+  if (parsed.name || parsed.type) {
    await logActivityForScope(toScope(scope), {
      entityType: "lists.list",
      entityId: parsed.id,
      action: "update",
-      payload: { name: parsed.name },
+      payload: {
+        ...(parsed.name ? { name: parsed.name } : {}),
+        ...(parsed.type ? { type: parsed.type } : {}),
+      },
    });
  }
  if (parsed.archived === true) {
@@ -93,6 +97,20 @@ export async function renameList(input: { id: string; name: string }) {
  revalidatePath(`/lists/${parsed.id}`);
 }

+export async function updateListProperties(input: { id: string; name?: string; type?: string }) {
+  const parsed = z
+    .object({
+      id: z.string().uuid(),
+      name: listInput.shape.name.optional(),
+      type: listInput.shape.type.optional(),
+    })
+    .parse(input);
+  const { household, user } = await getCurrentSession();
+  await updateListForScope({ householdId: household.id, userId: user.id, role: null }, parsed);
+  revalidatePath("/lists");
+  revalidatePath(`/lists/${parsed.id}`);
+}
+
 export async function archiveList(input: { id: string }) {
  const parsed = z.object({ id: z.string().uuid() }).parse(input);
  const { household, user } = await getCurrentSession();
@@ -7,6 +7,7 @@ export const listInput = z.object({

 export const listUpdateInput = z.object({
  name: listInput.shape.name.optional(),
+  type: listInput.shape.type.optional(),
  archived: z.boolean().optional(),
 });