@rackbops/plugin-tracker 0.0.0 → 0.2.0

package/dist/plugin.js

@@ -0,0 +1,3631 @@
+// @bun
+// plugins/tracker/src/index.ts
+import { mkdirSync } from "fs";
+import { join } from "path";
+
+// node_modules/@rackbops/docket-core/dist/answer.js
+var RUN_KINDS = new Set(["done", "snooze", "decision"]);
+var NOT_YOURS = "That is not yours to answer.";
+var OVER = "That run is over; answer the latest message instead.";
+
+class ReplyRefusedError extends Error {
+  name = "ReplyRefusedError";
+}
+async function runRefusal(store, task, occurrenceId, userId) {
+  if (task.ownerId !== userId)
+    return NOT_YOURS;
+  if (occurrenceId === null)
+    return "Answer the message for the run you mean.";
+  const occurrence = await store.getOccurrence(occurrenceId);
+  if (!occurrence || occurrence.taskId !== task.id)
+    return "That run no longer exists.";
+  if (task.status !== "active")
+    return `That task is ${task.status}.`;
+  if (occurrence.status === "queued")
+    return "That run has not fired yet.";
+  if (occurrence.status === "snoozed" || occurrence.status === "skipped")
+    return OVER;
+  const answered = (await store.listReplies(task.id)).some((r) => r.occurrenceId === occurrence.id && RUN_KINDS.has(r.kind));
+  return answered ? "That run has already been answered." : null;
+}
+
+// node_modules/@rackbops/docket-core/dist/authz.js
+function canSee(actor, task, recipients) {
+  if (actor.admin || task.ownerId === actor.userId)
+    return true;
+  return recipients.some((r) => r.userId === actor.userId && r.state === "accepted");
+}
+async function visibleTask(store, actor, taskId) {
+  const task = await store.getTask(taskId);
+  if (!task)
+    return null;
+  return canSee(actor, task, await store.listRecipients(taskId)) ? task : null;
+}
+async function visibleTasks(store, actor, filter = {}) {
+  const tasks = await store.listTasks(filter);
+  if (actor.admin)
+    return tasks;
+  const out = [];
+  for (const task of tasks) {
+    if (canSee(actor, task, await store.listRecipients(task.id)))
+      out.push(task);
+  }
+  return out;
+}
+async function visibleOccurrences(store, actor, taskId) {
+  if (!await visibleTask(store, actor, taskId))
+    return null;
+  return store.listOccurrences({ taskId });
+}
+async function visibleReplies(store, actor, taskId) {
+  if (!await visibleTask(store, actor, taskId))
+    return null;
+  return store.listReplies(taskId);
+}
+async function visibleHistory(store, actor, taskId) {
+  if (!await visibleTask(store, actor, taskId))
+    return null;
+  return store.listTaskEvents(taskId);
+}
+
+// node_modules/@rackbops/docket-core/dist/capabilities.js
+var CAPABILITIES = ["notify", "graph:write", "discord:post", "github:issue"];
+var CAPABILITY_TIER = {
+  notify: 0,
+  "graph:write": 1,
+  "discord:post": 1,
+  "github:issue": 1
+};
+function isCapability(value) {
+  return CAPABILITIES.includes(value);
+}
+function unknownCapabilities(declared) {
+  return declared.filter((c) => !isCapability(c));
+}
+
+// node_modules/@rackbops/docket-core/dist/consent.js
+var DECLINE_BLOCK_MS = 24 * 60 * 60 * 1000;
+
+class ConsentError extends Error {
+  name = "ConsentError";
+}
+async function activeBlock(store, ownerId, recipientId, now) {
+  const blocks = await store.listBlocks(ownerId, recipientId);
+  return blocks.find((b) => b.liftedAt === null && (b.expiresAt === null || Date.parse(b.expiresAt) > now.getTime())) ?? null;
+}
+async function invite(store, actor, task, recipientId, now) {
+  if (!actor.admin && actor.userId !== task.ownerId)
+    return { ok: false, reason: "not_owner" };
+  if (recipientId === task.ownerId)
+    return { ok: false, reason: "self" };
+  const existing = (await store.listRecipients(task.id)).find((r) => r.userId === recipientId);
+  if (existing && (existing.state === "invited" || existing.state === "accepted")) {
+    return { ok: false, reason: "already_invited" };
+  }
+  const block = await activeBlock(store, task.ownerId, recipientId, now);
+  if (block)
+    return { ok: false, reason: "blocked", block };
+  const at = now.toISOString();
+  const recipient = await store.setRecipient(task.id, recipientId, "invited", at);
+  await store.addTaskEvent({
+    taskId: task.id,
+    actorId: actor.userId,
+    kind: "recipient_invited",
+    detail: recipientId,
+    at
+  });
+  return { ok: true, recipient };
+}
+async function respondToInvite(store, task, recipientId, answer, now, occurrenceId = null) {
+  const existing = (await store.listRecipients(task.id)).find((r) => r.userId === recipientId);
+  if (existing?.state !== "invited") {
+    throw new ConsentError(`${recipientId} has no open invitation to task ${task.id}`);
+  }
+  const at = now.toISOString();
+  const reply = await store.addReply({
+    occurrenceId,
+    taskId: task.id,
+    userId: recipientId,
+    kind: answer,
+    payload: null,
+    at
+  });
+  if (answer === "accept") {
+    const recipient = await store.setRecipient(task.id, recipientId, "accepted", at);
+    await store.addTaskEvent({
+      taskId: task.id,
+      actorId: recipientId,
+      kind: "recipient_accepted",
+      detail: recipientId,
+      at
+    });
+    return { recipient, reply, block: null };
+  }
+  const recipient = await store.setRecipient(task.id, recipientId, "declined", at);
+  await store.addTaskEvent({
+    taskId: task.id,
+    actorId: recipientId,
+    kind: "recipient_declined",
+    detail: recipientId,
+    at
+  });
+  const earlierDeclines = (await store.listBlocks(task.ownerId, recipientId)).filter((b) => b.declineReplyId !== null);
+  const permanent = earlierDeclines.length > 0;
+  const block = await store.createBlock({
+    ownerId: task.ownerId,
+    recipientId,
+    expiresAt: permanent ? null : new Date(now.getTime() + DECLINE_BLOCK_MS).toISOString(),
+    declineReplyId: reply.id,
+    at
+  });
+  await store.addTaskEvent({
+    taskId: task.id,
+    actorId: recipientId,
+    kind: "blocked",
+    detail: permanent ? `${recipientId} permanent` : `${recipientId} 24h`,
+    at
+  });
+  return { recipient, reply, block };
+}
+async function optOut(store, task, recipientId, now, occurrenceId = null) {
+  const at = now.toISOString();
+  await store.setRecipient(task.id, recipientId, "opted_out", at);
+  await store.addTaskEvent({
+    taskId: task.id,
+    actorId: recipientId,
+    kind: "recipient_opted_out",
+    detail: recipientId,
+    at
+  });
+  return store.addReply({
+    occurrenceId,
+    taskId: task.id,
+    userId: recipientId,
+    kind: "opt_out",
+    payload: null,
+    at
+  });
+}
+
+// node_modules/@rackbops/docket-core/dist/lanes.js
+var LANES = ["notify", "execute"];
+function isLane(value) {
+  return LANES.includes(value);
+}
+
+// node_modules/@rackbops/docket-core/dist/zoned.js
+var WEEKDAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+var formatters = new Map;
+function formatter(zone) {
+  let f = formatters.get(zone);
+  if (!f) {
+    f = new Intl.DateTimeFormat("en-US", {
+      timeZone: zone,
+      hourCycle: "h23",
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      weekday: "short"
+    });
+    formatters.set(zone, f);
+  }
+  return f;
+}
+function isTimeZone(zone) {
+  try {
+    formatter(zone);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function wallClock(instant, zone) {
+  const parts = formatter(zone).formatToParts(instant);
+  const get = (type) => parts.find((p) => p.type === type)?.value ?? "";
+  return {
+    year: Number(get("year")),
+    month: Number(get("month")),
+    day: Number(get("day")),
+    hour: Number(get("hour")),
+    minute: Number(get("minute")),
+    weekday: WEEKDAYS.indexOf(get("weekday"))
+  };
+}
+function zoneOffsetMinutes(instant, zone) {
+  const w = wallClock(instant, zone);
+  const asUtc = Date.UTC(w.year, w.month - 1, w.day, w.hour, w.minute);
+  const truncated = Math.floor(instant.getTime() / 60000) * 60000;
+  return Math.round((asUtc - truncated) / 60000);
+}
+function reads(instant, zone, d, h, min) {
+  const w = wallClock(new Date(instant), zone);
+  return w.day === d && w.hour === h && w.minute === min;
+}
+function zonedInstant(year, month, day, hour, minute, zone) {
+  const wanted = Date.UTC(year, month - 1, day, hour, minute);
+  const offset1 = zoneOffsetMinutes(new Date(wanted), zone);
+  const candidate1 = wanted - offset1 * 60000;
+  if (reads(candidate1, zone, day, hour, minute))
+    return new Date(candidate1);
+  const offset2 = zoneOffsetMinutes(new Date(candidate1), zone);
+  const candidate2 = wanted - offset2 * 60000;
+  if (reads(candidate2, zone, day, hour, minute))
+    return new Date(candidate2);
+  return new Date(Math.max(candidate1, candidate2));
+}
+
+// node_modules/@rackbops/docket-core/dist/schedule.js
+var SCHEDULE_KINDS = ["once", "calendar", "poll", "period"];
+function isScheduleKind(value) {
+  return SCHEDULE_KINDS.includes(value);
+}
+var MIN_POLL_MINUTES = 5;
+var MINUTE_MS = 60000;
+var DAY_MS = 86400000;
+var HORIZON_DAYS = 366 * 3;
+var HORIZON_PERIODS = 1e5;
+function parseLocalDate(value) {
+  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+  if (!m)
+    return null;
+  const year = Number(m[1]);
+  const month = Number(m[2]);
+  const day = Number(m[3]);
+  if (month < 1 || month > 12 || day < 1 || day > daysInMonth(year, month))
+    return null;
+  return { year, month, day };
+}
+function formatLocalDate(d) {
+  const mm = String(d.month).padStart(2, "0");
+  const dd = String(d.day).padStart(2, "0");
+  return `${d.year}-${mm}-${dd}`;
+}
+function daysInMonth(year, month) {
+  return new Date(Date.UTC(year, month, 0)).getUTCDate();
+}
+function dayNumber(d) {
+  return Math.floor(Date.UTC(d.year, d.month - 1, d.day) / DAY_MS);
+}
+function fromDayNumber(n) {
+  const dt = new Date(n * DAY_MS);
+  return { year: dt.getUTCFullYear(), month: dt.getUTCMonth() + 1, day: dt.getUTCDate() };
+}
+function weekdayOf(d) {
+  return new Date(Date.UTC(d.year, d.month - 1, d.day)).getUTCDay();
+}
+function addMonths(anchor, months) {
+  const index = anchor.year * 12 + (anchor.month - 1) + months;
+  const year = Math.floor(index / 12);
+  const month = index % 12 + 1;
+  return { year, month, day: Math.min(anchor.day, daysInMonth(year, month)) };
+}
+function periodDateAt(schedule, n) {
+  const anchor = parseLocalDate(schedule.anchor);
+  if (!anchor)
+    return null;
+  const steps = n * schedule.every;
+  switch (schedule.unit) {
+    case "day":
+      return fromDayNumber(dayNumber(anchor) + steps);
+    case "week":
+      return fromDayNumber(dayNumber(anchor) + steps * 7);
+    case "month":
+      return addMonths(anchor, steps);
+    case "year":
+      return addMonths(anchor, steps * 12);
+  }
+}
+function isInstant(value) {
+  return !Number.isNaN(Date.parse(value));
+}
+function checkLocalTime(prefix, schedule, problems) {
+  if (schedule.hour !== undefined && (!Number.isInteger(schedule.hour) || schedule.hour < 0 || schedule.hour > 23)) {
+    problems.push(`${prefix}.hour must be 0 to 23`);
+  }
+  if (schedule.minute !== undefined && (!Number.isInteger(schedule.minute) || schedule.minute < 0 || schedule.minute > 59)) {
+    problems.push(`${prefix}.minute must be 0 to 59`);
+  }
+}
+function calendarProblems(schedule) {
+  const problems = [];
+  if (!Number.isInteger(schedule.every) || schedule.every < 1) {
+    problems.push("calendar.every must be a whole number >= 1");
+  }
+  if (!["day", "week", "month"].includes(schedule.unit))
+    problems.push("calendar.unit is unknown");
+  if (!parseLocalDate(schedule.start))
+    problems.push("calendar.start must be a YYYY-MM-DD date");
+  if (schedule.weekdays !== undefined) {
+    if (schedule.weekdays.length === 0)
+      problems.push("calendar.weekdays must not be empty");
+    if (schedule.weekdays.some((w) => !Number.isInteger(w) || w < 0 || w > 6)) {
+      problems.push("calendar.weekdays must be 0 (Sunday) to 6 (Saturday)");
+    }
+  }
+  if (schedule.dayOfMonth !== undefined) {
+    if (!Number.isInteger(schedule.dayOfMonth) || schedule.dayOfMonth < 1 || schedule.dayOfMonth > 31) {
+      problems.push("calendar.dayOfMonth must be 1 to 31");
+    }
+  }
+  checkLocalTime("calendar", schedule, problems);
+  return problems;
+}
+function pollIntervalMs(schedule) {
+  return schedule.every * (schedule.unit === "hour" ? 60 : 1) * MINUTE_MS;
+}
+function pollProblems(schedule) {
+  const problems = [];
+  if (!Number.isInteger(schedule.every) || schedule.every < 1) {
+    problems.push("poll.every must be a whole number >= 1");
+  }
+  if (!["minute", "hour"].includes(schedule.unit)) {
+    problems.push("poll.unit must be minute or hour");
+  } else if (problems.length === 0 && pollIntervalMs(schedule) < MIN_POLL_MINUTES * MINUTE_MS) {
+    problems.push(`poll interval must be at least ${MIN_POLL_MINUTES} minutes`);
+  }
+  if (!isInstant(schedule.start))
+    problems.push("poll.start is not an ISO-8601 instant");
+  if (schedule.until !== undefined) {
+    if (!isInstant(schedule.until))
+      problems.push("poll.until is not an ISO-8601 instant");
+    else if (isInstant(schedule.start) && Date.parse(schedule.until) <= Date.parse(schedule.start)) {
+      problems.push("poll.until must be after poll.start");
+    }
+  }
+  return problems;
+}
+function periodProblems(schedule) {
+  const problems = [];
+  if (!Number.isInteger(schedule.every) || schedule.every < 1) {
+    problems.push("period.every must be a whole number >= 1");
+  }
+  if (!["day", "week", "month", "year"].includes(schedule.unit)) {
+    problems.push("period.unit must be day, week, month or year");
+  }
+  if (!parseLocalDate(schedule.anchor))
+    problems.push("period.anchor must be a YYYY-MM-DD date");
+  if (schedule.leadDays !== undefined && (!Number.isInteger(schedule.leadDays) || schedule.leadDays < 0)) {
+    problems.push("period.leadDays must be a whole number >= 0");
+  }
+  checkLocalTime("period", schedule, problems);
+  return problems;
+}
+function scheduleProblems(schedule) {
+  switch (schedule.kind) {
+    case "once":
+      return isInstant(schedule.at) ? [] : ["once.at is not an ISO-8601 instant"];
+    case "calendar":
+      return calendarProblems(schedule);
+    case "poll":
+      return pollProblems(schedule);
+    case "period":
+      return periodProblems(schedule);
+  }
+}
+function matchesDay(schedule, start, day) {
+  const gap = dayNumber(day) - dayNumber(start);
+  if (gap < 0)
+    return false;
+  switch (schedule.unit) {
+    case "day":
+      return gap % schedule.every === 0;
+    case "week": {
+      const weekdays = schedule.weekdays ?? [weekdayOf(start)];
+      const startOfWeek = dayNumber(start) - weekdayOf(start);
+      const weeks = Math.floor((dayNumber(day) - startOfWeek) / 7);
+      return weeks % schedule.every === 0 && weekdays.includes(weekdayOf(day));
+    }
+    case "month": {
+      const months = (day.year - start.year) * 12 + (day.month - start.month);
+      if (months < 0 || months % schedule.every !== 0)
+        return false;
+      const wanted = Math.min(schedule.dayOfMonth ?? start.day, daysInMonth(day.year, day.month));
+      return day.day === wanted;
+    }
+  }
+}
+function nextCalendarDue(schedule, after, ctx) {
+  const start = parseLocalDate(schedule.start);
+  if (!start)
+    return null;
+  const hour = schedule.hour ?? ctx.preferredHour;
+  const minute = schedule.minute ?? 0;
+  const local = wallClock(after, ctx.zone);
+  const firstDay = Math.max(dayNumber({ year: local.year, month: local.month, day: local.day }), dayNumber(start));
+  for (let n = firstDay;n < firstDay + HORIZON_DAYS; n++) {
+    const day = fromDayNumber(n);
+    if (!matchesDay(schedule, start, day))
+      continue;
+    const instant = zonedInstant(day.year, day.month, day.day, hour, minute, ctx.zone);
+    if (instant.getTime() > after.getTime())
+      return instant;
+  }
+  return null;
+}
+function nextPollDue(schedule, after) {
+  const start = Date.parse(schedule.start);
+  if (Number.isNaN(start))
+    return null;
+  const interval = pollIntervalMs(schedule);
+  const elapsed = after.getTime() - start;
+  const steps = elapsed < 0 ? 0 : Math.floor(elapsed / interval) + 1;
+  const due = start + steps * interval;
+  if (schedule.until !== undefined && due > Date.parse(schedule.until))
+    return null;
+  return new Date(due);
+}
+function nextPeriodDue(schedule, after, ctx) {
+  const hour = schedule.hour ?? ctx.preferredHour;
+  const minute = schedule.minute ?? 0;
+  const lead = schedule.leadDays ?? 0;
+  for (let n = 0;n < HORIZON_PERIODS; n++) {
+    const date = periodDateAt(schedule, n);
+    if (!date)
+      return null;
+    const fire = fromDayNumber(dayNumber(date) - lead);
+    const instant = zonedInstant(fire.year, fire.month, fire.day, hour, minute, ctx.zone);
+    if (instant.getTime() > after.getTime())
+      return instant;
+  }
+  return null;
+}
+function nextDue(schedule, after, ctx) {
+  switch (schedule.kind) {
+    case "once": {
+      const at = new Date(schedule.at);
+      return at.getTime() > after.getTime() ? at : null;
+    }
+    case "calendar":
+      return nextCalendarDue(schedule, after, ctx);
+    case "poll":
+      return nextPollDue(schedule, after);
+    case "period":
+      return nextPeriodDue(schedule, after, ctx);
+  }
+}
+function periodDate(schedule, due, zone) {
+  const local = wallClock(due, zone);
+  const fire = { year: local.year, month: local.month, day: local.day };
+  return formatLocalDate(fromDayNumber(dayNumber(fire) + (schedule.leadDays ?? 0)));
+}
+function daysUntil(date, now, zone) {
+  const target = parseLocalDate(date);
+  if (!target)
+    return null;
+  const local = wallClock(now, zone);
+  return dayNumber(target) - dayNumber({ year: local.year, month: local.month, day: local.day });
+}
+
+// node_modules/@rackbops/docket-core/dist/contract.js
+class TaskTypeError extends Error {
+  name = "TaskTypeError";
+}
+function defineTaskType(def) {
+  if (!def.id)
+    throw new TaskTypeError("a task type needs an id");
+  if (!isLane(def.lane))
+    throw new TaskTypeError(`${def.id}: unknown lane ${String(def.lane)}`);
+  const unknown = unknownCapabilities(def.capabilities);
+  if (unknown.length > 0) {
+    throw new TaskTypeError(`${def.id}: declares ungrantable capabilities: ${unknown.join(", ")}`);
+  }
+  if (def.schedule.length === 0)
+    throw new TaskTypeError(`${def.id}: accepts no schedule kind`);
+  const badKinds = def.schedule.filter((k) => !isScheduleKind(k));
+  if (badKinds.length > 0) {
+    throw new TaskTypeError(`${def.id}: unknown schedule kinds: ${badKinds.join(", ")}`);
+  }
+  if (def.lane === "notify" && !def.run)
+    throw new TaskTypeError(`${def.id}: a notify type needs run`);
+  if (def.lane === "execute" && (!def.prepare || !def.finish)) {
+    throw new TaskTypeError(`${def.id}: an execute type needs prepare and finish`);
+  }
+  return Object.freeze({ ...def });
+}
+
+// node_modules/@rackbops/docket-core/dist/dedupe.js
+function scheduledKey(taskId, dueAt) {
+  const iso = typeof dueAt === "string" ? new Date(dueAt).toISOString() : dueAt.toISOString();
+  return `sched:${taskId}:${iso}`;
+}
+function snoozeKey(occurrenceId) {
+  return `${SNOOZE_PREFIX}${occurrenceId}`;
+}
+var SNOOZE_PREFIX = "snooze:";
+
+// node_modules/@rackbops/docket-core/dist/delivery.js
+var NOTIFIER = "notifier";
+async function deliveredTo(store, occurrenceId) {
+  const events = await store.listEvents(occurrenceId);
+  return new Set(events.filter((e) => e.type === "delivered").map((e) => e.text.split(" ")[0] ?? ""));
+}
+function messageFor(message, occurrence, target, ownerId) {
+  const ref = { taskId: occurrence.taskId, occurrenceId: occurrence.id };
+  const actions = message.actions ?? [];
+  if (target.id === ownerId) {
+    return { ...message, actions: actions.filter((a) => a !== "opt_out"), ref };
+  }
+  const { decisions: _owners, ...rest } = message;
+  const kept = actions.filter((a) => !RUN_KINDS.has(a) && a !== "opt_out");
+  return { ...rest, actions: [...kept, "opt_out"], ref };
+}
+async function deliver(store, notifier, occurrence, targets, message, now) {
+  const task = await store.getTask(occurrence.taskId);
+  if (!task)
+    throw new Error(`no task ${occurrence.taskId}`);
+  const done = await deliveredTo(store, occurrence.id);
+  const report = { sent: [], skipped: [] };
+  for (const target of targets) {
+    if (done.has(target.id)) {
+      report.skipped.push(target.id);
+      continue;
+    }
+    const { messageId } = await notifier.sendDm(target.id, messageFor(message, occurrence, target, task.ownerId));
+    await store.addEvent({
+      occurrenceId: occurrence.id,
+      agent: NOTIFIER,
+      type: "delivered",
+      text: `${target.id} ${messageId}`,
+      at: now().toISOString()
+    });
+    done.add(target.id);
+    report.sent.push(target.id);
+  }
+  return report;
+}
+
+// node_modules/@rackbops/docket-core/dist/describe.js
+var WD = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+var MON = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+function clockTime(hour, minute) {
+  return `${hour}:${String(minute).padStart(2, "0")}`;
+}
+function formatInstant(instant, zone, now) {
+  const w = wallClock(new Date(instant), zone);
+  const year = now && wallClock(now, zone).year !== w.year ? ` ${w.year}` : "";
+  return `${WD[w.weekday]} ${MON[w.month - 1]} ${w.day}${year}, ${clockTime(w.hour, w.minute)}`;
+}
+function ordinal(n) {
+  const tens = n % 100;
+  if (tens >= 11 && tens <= 13)
+    return `${n}th`;
+  return `${n}${["th", "st", "nd", "rd"][n % 10] ?? "th"}`;
+}
+function every(n, unit, single) {
+  return n === 1 ? single : `every ${n} ${unit}s`;
+}
+function list(items) {
+  if (items.length <= 1)
+    return items.join("");
+  return `${items.slice(0, -1).join(", ")} and ${items[items.length - 1]}`;
+}
+function dateParts(date) {
+  const d = new Date(`${date}T00:00:00Z`);
+  return { weekday: d.getUTCDay(), day: d.getUTCDate() };
+}
+function describeSchedule(schedule, owner, viewerZone = owner.timeZone, now) {
+  const zoneNote = viewerZone === owner.timeZone ? "" : ` (${owner.timeZone} time)`;
+  switch (schedule.kind) {
+    case "once":
+      return `once, ${formatInstant(schedule.at, viewerZone, now)}`;
+    case "calendar": {
+      const at = `at ${clockTime(schedule.hour ?? owner.preferredHour, schedule.minute ?? 0)}`;
+      const start = dateParts(schedule.start);
+      if (schedule.unit === "day") {
+        return `${every(schedule.every, "day", "daily")} ${at}${zoneNote}`;
+      }
+      if (schedule.unit === "week") {
+        const days = [...schedule.weekdays ?? [start.weekday]].sort((a, b) => a - b);
+        const on = list(days.map((d) => WD[d] ?? "?"));
+        return `${every(schedule.every, "week", "weekly")} on ${on} ${at}${zoneNote}`;
+      }
+      const day = ordinal(schedule.dayOfMonth ?? start.day);
+      return `${every(schedule.every, "month", "monthly")} on the ${day} ${at}${zoneNote}`;
+    }
+    case "poll":
+      return schedule.every === 1 ? `every ${schedule.unit}` : `every ${schedule.every} ${schedule.unit}s`;
+    case "period": {
+      const cadence = schedule.every === 1 ? `every ${schedule.unit}` : `every ${schedule.every} ${schedule.unit}s`;
+      const days = schedule.leadDays === 1 ? "day" : "days";
+      const lead = schedule.leadDays ? `, ${schedule.leadDays} ${days} ahead` : "";
+      return `${cadence} from ${schedule.anchor}${lead}`;
+    }
+  }
+}
+
+// node_modules/@rackbops/docket-core/dist/ports.js
+class ExecutorUnavailableError extends Error {
+  name = "ExecutorUnavailableError";
+}
+
+// node_modules/@rackbops/docket-core/dist/scheduler.js
+var LATE_AFTER_MS = 5 * 60000;
+
+class ScheduleError extends Error {
+  name = "ScheduleError";
+}
+function isLate(occurrence, now) {
+  return now.getTime() - Date.parse(occurrence.dueAt) > LATE_AFTER_MS;
+}
+async function materialize(store, task, owner, now) {
+  if (task.status !== "active" || !task.schedule)
+    return null;
+  const pending = await store.listOccurrences({ taskId: task.id });
+  const scheduled = pending.filter((o) => !o.dedupeKey.startsWith(SNOOZE_PREFIX));
+  if (scheduled.some((o) => o.status === "queued" || o.status === "running"))
+    return null;
+  const after = firstDueAfter(task.schedule, pending.length === 0, now);
+  const due = nextDue(task.schedule, after, {
+    zone: owner.timeZone,
+    preferredHour: owner.preferredHour
+  });
+  if (!due)
+    return null;
+  return store.createOccurrence({
+    taskId: task.id,
+    lane: task.lane,
+    dueAt: due.toISOString(),
+    dedupeKey: scheduledKey(task.id, due),
+    at: now.toISOString()
+  });
+}
+function firstDueAfter(schedule, fresh, now) {
+  if (schedule.kind === "once")
+    return new Date(0);
+  if (schedule.kind === "poll" && fresh)
+    return new Date(Date.parse(schedule.start) - 1);
+  return now;
+}
+async function reschedule(store, task, owner, schedule, actorId, now) {
+  if (schedule) {
+    const problems = scheduleProblems(schedule);
+    if (problems.length > 0)
+      throw new ScheduleError(problems.join("; "));
+  }
+  const at = now.toISOString();
+  const removed = await store.deleteQueuedOccurrences(task.id);
+  const updated = await store.updateTask(task.id, { schedule, at });
+  await store.addTaskEvent({
+    taskId: task.id,
+    actorId,
+    kind: "schedule_changed",
+    detail: JSON.stringify(schedule),
+    at
+  });
+  return { task: updated, removed, next: await materialize(store, updated, owner, now) };
+}
+
+// node_modules/@rackbops/docket-core/dist/dispatch.js
+var ME = "docket";
+var SERIES_IN_CONTEXT = 100;
+
+class Lanes {
+  d;
+  constructor(d) {
+    this.d = d;
+  }
+  async recover() {
+    return this.d.store.requeueRunning();
+  }
+  async tickNotify() {
+    const result = { ran: 0, failed: 0, skipped: 0 };
+    for (const occurrence of await this.due("notify")) {
+      await this.runOne(occurrence) ? result.ran++ : result.failed++;
+    }
+    return result;
+  }
+  async tickExecute() {
+    const due = await this.due("execute");
+    if (!this.d.executor)
+      return { ran: 0, failed: 0, skipped: due.length };
+    const result = { ran: 0, failed: 0, skipped: 0 };
+    for (const occurrence of due) {
+      const outcome = await this.runOne(occurrence);
+      if (outcome === null) {
+        result.skipped += due.length - result.ran - result.failed;
+        break;
+      }
+      outcome ? result.ran++ : result.failed++;
+    }
+    return result;
+  }
+  async reply(input) {
+    const { store } = this.d;
+    const now = this.d.clock.now();
+    const task = await store.getTask(input.taskId);
+    if (!task)
+      throw new Error(`no task ${input.taskId}`);
+    if (input.kind === "accept" || input.kind === "decline") {
+      await respondToInvite(store, task, input.userId, input.kind, now, input.occurrenceId);
+      return null;
+    }
+    if (input.kind === "opt_out") {
+      await optOut(store, task, input.userId, now, input.occurrenceId);
+      return null;
+    }
+    if (RUN_KINDS.has(input.kind)) {
+      const refusal = await runRefusal(store, task, input.occurrenceId, input.userId);
+      if (refusal)
+        throw new ReplyRefusedError(refusal);
+    }
+    const reply = await store.addReply({ ...input, at: now.toISOString() });
+    if (task.status !== "active")
+      return null;
+    const loaded = await this.load(task);
+    if ("error" in loaded || !loaded.type.onReply)
+      return null;
+    const occurrence = input.occurrenceId ? await store.getOccurrence(input.occurrenceId) : null;
+    if (!occurrence)
+      return null;
+    const ctx = await this.context(loaded, occurrence, now);
+    const outcome = await loaded.type.onReply({ ...ctx, reply });
+    await this.apply(task, outcome, now);
+    if (outcome.complete)
+      await this.complete(task, input.userId, now);
+    else if (outcome.snoozeUntil) {
+      await this.snooze(task, occurrence, outcome.snoozeUntil, reply, now);
+    }
+    return outcome;
+  }
+  async due(lane) {
+    return this.d.store.listOccurrences({
+      lane,
+      status: "queued",
+      dueBefore: this.d.clock.now().toISOString()
+    });
+  }
+  async load(task) {
+    const type = this.d.types[task.type];
+    if (!type)
+      return { error: `no task type ${task.type}` };
+    const owner = await this.d.store.getUser(task.ownerId);
+    if (!owner)
+      return { error: `no owner ${task.ownerId}` };
+    const recipients = [];
+    for (const r of await this.d.store.listRecipients(task.id)) {
+      if (r.state !== "accepted")
+        continue;
+      const user = await this.d.store.getUser(r.userId);
+      if (user)
+        recipients.push(user);
+    }
+    return { task, type, owner, recipients };
+  }
+  async context(loaded, occurrence, now) {
+    const originalDueAt = await this.originalDueAt(occurrence);
+    return {
+      task: loaded.task,
+      occurrence,
+      ...originalDueAt ? { originalDueAt } : {},
+      owner: loaded.owner,
+      recipients: loaded.recipients,
+      config: loaded.task.config,
+      state: loaded.task.state,
+      now,
+      ports: this.d.fetch ? { fetch: this.d.fetch } : {},
+      history: {
+        events: await this.d.store.listEvents(occurrence.id),
+        replies: await this.d.store.listReplies(loaded.task.id),
+        series: await this.d.store.listSeries(loaded.task.id, { limit: SERIES_IN_CONTEXT })
+      }
+    };
+  }
+  async originalDueAt(occurrence) {
+    let current = occurrence;
+    let found = null;
+    for (let hops = 0;hops < 100 && current.dedupeKey.startsWith(SNOOZE_PREFIX); hops++) {
+      const from = await this.d.store.getOccurrence(current.dedupeKey.slice(SNOOZE_PREFIX.length));
+      if (!from)
+        break;
+      found = from.dueAt;
+      current = from;
+    }
+    return found;
+  }
+  async apply(task, outcome, now) {
+    const { store } = this.d;
+    if (outcome.state !== undefined) {
+      await store.updateTask(task.id, { state: outcome.state, at: now.toISOString() });
+    }
+    for (const point of outcome.series ?? []) {
+      await store.addSeriesPoint({
+        taskId: task.id,
+        at: point.at ?? now.toISOString(),
+        value: point.value,
+        unit: point.unit ?? null,
+        note: point.note ?? null
+      });
+    }
+  }
+  async complete(task, actorId, now) {
+    const { store } = this.d;
+    const at = now.toISOString();
+    await store.deleteQueuedOccurrences(task.id);
+    await store.updateTask(task.id, { status: "done", at });
+    await store.addTaskEvent({ taskId: task.id, actorId, kind: "completed", detail: "", at });
+  }
+  async runOne(occurrence) {
+    const { store, clock } = this.d;
+    const task = await store.getTask(occurrence.taskId);
+    if (!task)
+      return this.fail(occurrence, `no task ${occurrence.taskId}`);
+    const loaded = await this.load(task);
+    if ("error" in loaded)
+      return this.fail(occurrence, loaded.error);
+    const now = clock.now();
+    const late = isLate(occurrence, now);
+    await store.updateOccurrence(occurrence.id, {
+      status: "running",
+      startedAt: now.toISOString(),
+      late,
+      error: null
+    });
+    await this.event(occurrence, "status", late ? "started late" : "started");
+    try {
+      const ctx = await this.context(loaded, occurrence, now);
+      const { outcome, costUsd } = await this.execute(loaded.type, ctx, occurrence);
+      await this.apply(task, outcome, clock.now());
+      if (outcome.notify) {
+        await deliver(store, this.d.notifier, occurrence, [loaded.owner, ...loaded.recipients], outcome.notify, () => clock.now());
+      }
+      const snoozed = (await store.getOccurrence(occurrence.id))?.status === "snoozed";
+      await store.updateOccurrence(occurrence.id, {
+        status: snoozed ? "snoozed" : "done",
+        finishedAt: clock.now().toISOString(),
+        summary: outcome.summary ?? null,
+        costUsd
+      });
+      if (outcome.complete)
+        await this.complete(task, null, clock.now());
+      else
+        await this.next(task, loaded.owner);
+      return true;
+    } catch (err) {
+      if (err instanceof ExecutorUnavailableError) {
+        await this.event(occurrence, "status", `waiting: ${err.message}`);
+        await store.updateOccurrence(occurrence.id, { status: "queued" });
+        return null;
+      }
+      await this.fail(occurrence, err instanceof Error ? err.message : String(err));
+      await this.next(task, loaded.owner);
+      return false;
+    }
+  }
+  async next(task, owner) {
+    const current = await this.d.store.getTask(task.id);
+    if (current)
+      await materialize(this.d.store, current, owner, this.d.clock.now());
+  }
+  async execute(type, ctx, occurrence) {
+    if (type.lane === "notify") {
+      if (!type.run)
+        throw new Error(`${type.id} has no run`);
+      return { outcome: await type.run(ctx), costUsd: null };
+    }
+    if (!type.prepare || !type.finish)
+      throw new Error(`${type.id} has no prepare/finish`);
+    if (!this.d.executor)
+      throw new ExecutorUnavailableError("no executor configured");
+    const spec = await type.prepare(ctx);
+    const result = await this.d.executor.run(spec, occurrence.id);
+    const outcome = await type.finish(ctx, result);
+    return { outcome, costUsd: result.totalCostUsd ?? null };
+  }
+  async snooze(task, occurrence, until, reply, now) {
+    const { store } = this.d;
+    await store.updateOccurrence(occurrence.id, { status: "snoozed" });
+    await this.event(occurrence, "status", `snoozed until ${until.toISOString()} by ${reply.userId}`);
+    await store.createOccurrence({
+      taskId: task.id,
+      lane: task.lane,
+      dueAt: until.toISOString(),
+      dedupeKey: snoozeKey(occurrence.id),
+      at: now.toISOString()
+    });
+  }
+  async fail(occurrence, message) {
+    await this.event(occurrence, "error", message);
+    const snoozed = (await this.d.store.getOccurrence(occurrence.id))?.status === "snoozed";
+    await this.d.store.updateOccurrence(occurrence.id, {
+      status: snoozed ? "snoozed" : "failed",
+      finishedAt: this.d.clock.now().toISOString(),
+      error: message
+    });
+    return false;
+  }
+  async event(occurrence, type, text) {
+    await this.d.store.addEvent({
+      occurrenceId: occurrence.id,
+      agent: ME,
+      type,
+      text,
+      at: this.d.clock.now().toISOString()
+    });
+  }
+}
+
+// node_modules/@rackbops/docket-core/dist/messages.js
+var ADMIN_DISCLOSURE = "An admin of this tracker can see every task and its history, including yours.";
+function name(user) {
+  return user.displayName ?? "Someone";
+}
+function inviteMessage(task, owner, recipient, now) {
+  const cadence = task.schedule ? `, which runs ${describeSchedule(task.schedule, owner, recipient.timeZone, now)}` : "";
+  return {
+    text: [
+      `${name(owner)} wants you to be notified about "${task.title}"${cadence}.`,
+      "You would only receive its results; you can stop them from any message.",
+      ADMIN_DISCLOSURE,
+      "Do you accept these notifications?"
+    ].join(`
+`),
+    actions: ["accept", "decline"],
+    ref: { taskId: task.id, occurrenceId: null }
+  };
+}
+async function taskList(store, actor) {
+  const tasks = await visibleTasks(store, { ...actor, admin: false }, { status: "active" });
+  const entries = [];
+  for (const task of tasks) {
+    const queued = await store.listOccurrences({ taskId: task.id, status: "queued" });
+    const from = task.ownerId === actor.userId ? null : await store.getUser(task.ownerId);
+    entries.push({ task, next: queued[0] ?? null, from });
+  }
+  return entries.sort((a, b) => (a.next?.dueAt ?? "\uFFFF").localeCompare(b.next?.dueAt ?? "\uFFFF") || a.task.title.localeCompare(b.task.title));
+}
+function formatTaskList(entries, viewer, now) {
+  if (entries.length === 0)
+    return "You have no active tasks.";
+  return entries.map(({ task, next, from }) => {
+    const when = next ? `next ${formatInstant(next.dueAt, viewer.timeZone, now)}` : "nothing due";
+    const schedule = task.schedule?.kind === "once" ? null : task.schedule;
+    const cadence = schedule ? `, ${describeSchedule(schedule, from ?? viewer, viewer.timeZone, now)}` : "";
+    const owner = from ? ` (from ${name(from)})` : "";
+    return `\`${task.id}\` ${task.title}${owner} -- ${when}${cadence}`;
+  }).join(`
+`);
+}
+
+// node_modules/@rackbops/docket-core/dist/refs.js
+var MAX_REF_LENGTH = 80;
+var CODE = {
+  accept: "a",
+  decline: "x",
+  opt_out: "q",
+  done: "d",
+  snooze: "s",
+  decision: "c"
+};
+var KIND = Object.fromEntries(Object.entries(CODE).map(([k, c]) => [c, k]));
+
+class ReplyRefError extends Error {
+  name = "ReplyRefError";
+}
+function encodeReplyRef(ref) {
+  const [scope, id] = ref.occurrenceId === null ? ["t", ref.taskId] : ["o", ref.occurrenceId];
+  if (id.includes("."))
+    throw new ReplyRefError(`a Store id with a dot cannot be encoded: ${id}`);
+  const base = `${CODE[ref.kind]}.${scope}.${id}`;
+  if (ref.kind === "decision" && !ref.choice) {
+    throw new ReplyRefError("a decision needs its choice");
+  }
+  const encoded = ref.kind === "decision" ? `${base}.${ref.choice}` : base;
+  if (encoded.length > MAX_REF_LENGTH) {
+    throw new ReplyRefError(`a reference over ${MAX_REF_LENGTH} characters: ${encoded}`);
+  }
+  return encoded;
+}
+function decodeReplyRef(encoded) {
+  const m = /^([a-z])\.([ot])\.([^.]+)(?:\.(.+))?$/.exec(encoded);
+  const kind = m ? KIND[m[1] ?? ""] : undefined;
+  if (!m || !kind || m[3] === undefined)
+    return null;
+  const scope = m[2] === "o" ? "o" : "t";
+  if (kind === "decision") {
+    return m[4] === undefined ? null : { kind, scope, id: m[3], choice: m[4] };
+  }
+  return m[4] === undefined ? { kind, scope, id: m[3] } : null;
+}
+async function replyForRef(store, encoded, userId) {
+  const ref = decodeReplyRef(encoded);
+  if (!ref)
+    return { ok: false, error: "That button is not one of mine." };
+  const run = RUN_KINDS.has(ref.kind);
+  if (run && ref.scope !== "o")
+    return { ok: false, error: "That button is not one of mine." };
+  let taskId = ref.id;
+  let occurrenceId = null;
+  if (ref.scope === "o") {
+    const occurrence = await store.getOccurrence(ref.id);
+    if (!occurrence)
+      return { ok: false, error: "That run no longer exists." };
+    taskId = occurrence.taskId;
+    occurrenceId = occurrence.id;
+  }
+  const task = await store.getTask(taskId);
+  if (!task)
+    return { ok: false, error: "That task no longer exists." };
+  if (run) {
+    const refusal = await runRefusal(store, task, occurrenceId, userId);
+    if (refusal)
+      return { ok: false, error: refusal };
+  } else {
+    const mine = (await store.listRecipients(task.id)).find((r) => r.userId === userId);
+    const state = ref.kind === "opt_out" ? "accepted" : "invited";
+    if (mine?.state !== state)
+      return { ok: false, error: NOT_YOURS };
+  }
+  return {
+    ok: true,
+    input: {
+      taskId: task.id,
+      occurrenceId,
+      userId,
+      kind: ref.kind,
+      payload: ref.kind === "decision" ? { choice: ref.choice } : null
+    }
+  };
+}
+var LABELS = {
+  accept: "Accept",
+  decline: "Decline",
+  opt_out: "Stop sending me this",
+  done: "Done",
+  snooze: "Snooze 1h"
+};
+function replyButtons(message) {
+  const ref = message.ref;
+  if (!ref)
+    return [];
+  const buttons = [];
+  const add = (button) => {
+    if (!buttons.some((b) => b.ref === button.ref))
+      buttons.push(button);
+  };
+  for (const kind of message.actions ?? []) {
+    if (kind === "text")
+      continue;
+    if (kind === "decision") {
+      for (const choice of message.decisions ?? []) {
+        add({ kind, label: choice, ref: encodeReplyRef({ ...ref, kind, choice }) });
+      }
+      continue;
+    }
+    add({ kind, label: LABELS[kind], ref: encodeReplyRef({ ...ref, kind }) });
+  }
+  return buttons;
+}
+
+// node_modules/@rackbops/docket-core/dist/tasks.js
+class TaskError extends Error {
+  name = "TaskError";
+}
+function defaultCapabilities(type) {
+  return type.capabilities.filter((c) => CAPABILITY_TIER[c] === 0);
+}
+async function createTask(store, actor, owner, input, now) {
+  if (!actor.admin && actor.userId !== owner.id) {
+    throw new TaskError("only the owner or an admin creates a task for a person");
+  }
+  if (input.schedule) {
+    if (!input.type.schedule.includes(input.schedule.kind)) {
+      throw new ScheduleError(`${input.type.id} does not accept a ${input.schedule.kind} schedule`);
+    }
+    const problems = scheduleProblems(input.schedule);
+    if (problems.length > 0)
+      throw new ScheduleError(problems.join("; "));
+  }
+  const at = now.toISOString();
+  const task = await store.createTask({
+    ownerId: owner.id,
+    type: input.type.id,
+    title: input.title,
+    config: input.config,
+    schedule: input.schedule,
+    lane: input.type.lane,
+    capabilities: defaultCapabilities(input.type),
+    at
+  });
+  await store.addTaskEvent({
+    taskId: task.id,
+    actorId: actor.userId,
+    kind: "created",
+    detail: input.type.id,
+    at
+  });
+  return { task, next: await materialize(store, task, owner, now) };
+}
+
+// node_modules/@rackbops/docket-core/dist/when.js
+var UNITS = {
+  m: 60000,
+  min: 60000,
+  mins: 60000,
+  minute: 60000,
+  minutes: 60000,
+  h: 3600000,
+  hr: 3600000,
+  hrs: 3600000,
+  hour: 3600000,
+  hours: 3600000,
+  d: 86400000,
+  day: 86400000,
+  days: 86400000,
+  w: 604800000,
+  week: 604800000,
+  weeks: 604800000
+};
+var WEEKDAYS2 = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
+var ISO_RE = /^\d{4}-\d{2}-\d{2}t\d{2}:\d{2}(:\d{2}(\.\d+)?)?(z|[+-]\d{2}:?\d{2})$/;
+var RELATIVE_RE = /^in (\d+|an?) ?([a-z]+)$/;
+var DAY = String.raw`today|tomorrow|tmrw|[a-z]{3,9}|\d{4}-\d{2}-\d{2}|\d{1,2}/\d{1,2}`;
+var TIME = String.raw`noon|midnight|\d{1,2}(?::\d{2})? ?(?:am|pm)?`;
+var DAY_TIME_RE = new RegExp(`^(?:on )?(${DAY})(?: (?:at )?(${TIME}))?$`);
+var TIME_DAY_RE = new RegExp(`^(?:at )?(${TIME})(?: (?:on )?(${DAY}))?$`);
+var MAX_AHEAD_YEARS = 5;
+var MAX_AHEAD_MS = MAX_AHEAD_YEARS * 365.25 * 86400000;
+function knownZone(zone) {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: zone });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var HINT = `Try "in 2 hours", "9am", "tomorrow 9am", "friday 17:30" or "2026-10-01 9:00".`;
+function fail(text, why) {
+  return { ok: false, error: `${why ?? `I couldn't read "${text}" as a time.`} ${HINT}` };
+}
+function daysIn(year, month) {
+  return new Date(Date.UTC(year, month, 0)).getUTCDate();
+}
+function addDays(date, days) {
+  const d = new Date(Date.UTC(date.year, date.month - 1, date.day + days));
+  return { year: d.getUTCFullYear(), month: d.getUTCMonth() + 1, day: d.getUTCDate() };
+}
+function validDate(date) {
+  return date.month >= 1 && date.month <= 12 && date.day >= 1 && date.day <= daysIn(date.year, date.month);
+}
+function parseTime(word) {
+  if (word === "noon")
+    return { hour: 12, minute: 0 };
+  if (word === "midnight")
+    return { hour: 0, minute: 0 };
+  const m = /^(\d{1,2})(?::(\d{2}))? ?(am|pm)?$/.exec(word);
+  if (!m)
+    return null;
+  let hour = Number(m[1]);
+  const minute = m[2] === undefined ? 0 : Number(m[2]);
+  const meridiem = m[3];
+  if (minute > 59)
+    return null;
+  if (meridiem) {
+    if (hour < 1 || hour > 12)
+      return null;
+    hour = hour % 12 + (meridiem === "pm" ? 12 : 0);
+  } else if (hour > 23) {
+    return null;
+  }
+  return { hour, minute };
+}
+function weekday(word) {
+  if (word.length < 3)
+    return -1;
+  return WEEKDAYS2.findIndex((d) => d.startsWith(word));
+}
+function parseWhen(text, now, options) {
+  const result = resolve(text, now, options);
+  if (result.ok && result.at.getTime() - now.getTime() > MAX_AHEAD_MS) {
+    return fail(text, `${text} is more than ${MAX_AHEAD_YEARS} years away.`);
+  }
+  return result;
+}
+function resolve(text, now, options) {
+  const words = text.trim().toLowerCase().replace(/\s+/g, " ").replace(/,/g, "");
+  if (words === "")
+    return fail(text, "Say when.");
+  if (ISO_RE.test(words)) {
+    const [year, month, day] = words.slice(0, 10).split("-").map(Number);
+    if (!validDate({ year: year ?? 0, month: month ?? 0, day: day ?? 0 }))
+      return fail(text, `${words.slice(0, 10)} is not a date.`);
+    const at = new Date(Date.parse(words.toUpperCase()));
+    if (Number.isNaN(at.getTime()))
+      return fail(text);
+    return at > now ? { ok: true, at } : fail(text, `${text} has already passed.`);
+  }
+  const rel = RELATIVE_RE.exec(words);
+  if (rel) {
+    const n = rel[1] === "a" || rel[1] === "an" ? 1 : Number(rel[1]);
+    const unit = UNITS[rel[2] ?? ""];
+    if (unit === undefined || n < 1)
+      return fail(text);
+    if (n * unit > MAX_AHEAD_MS)
+      return fail(text, `${text} is more than ${MAX_AHEAD_YEARS} years away.`);
+    return { ok: true, at: new Date(now.getTime() + n * unit) };
+  }
+  if (!knownZone(options.zone))
+    return fail(text, `I don't know the time zone ${options.zone}.`);
+  let dayWord;
+  let timeWord;
+  const timeFirst = TIME_DAY_RE.exec(words);
+  const dayFirst = DAY_TIME_RE.exec(words);
+  if (timeFirst && parseTime(timeFirst[1] ?? "")) {
+    timeWord = timeFirst[1];
+    dayWord = timeFirst[2];
+  } else if (dayFirst) {
+    dayWord = dayFirst[1];
+    timeWord = dayFirst[2];
+  } else {
+    return fail(text);
+  }
+  const time = timeWord === undefined ? { hour: options.defaultHour, minute: 0 } : parseTime(timeWord);
+  if (!time)
+    return fail(text);
+  const clock = wallClock(now, options.zone);
+  const today = { year: clock.year, month: clock.month, day: clock.day };
+  const at = (date) => zonedInstant(date.year, date.month, date.day, time.hour, time.minute, options.zone);
+  if (dayWord === undefined) {
+    const first = at(today);
+    return { ok: true, at: first > now ? first : at(addDays(today, 1)) };
+  }
+  if (dayWord === "today") {
+    const when = at(today);
+    return when > now ? { ok: true, at: when } : fail(text, `${text} has already passed.`);
+  }
+  if (dayWord === "tomorrow" || dayWord === "tmrw")
+    return { ok: true, at: at(addDays(today, 1)) };
+  const iso = /^(\d{4})-(\d{2})-(\d{2})$/.exec(dayWord);
+  if (iso) {
+    const date = { year: Number(iso[1]), month: Number(iso[2]), day: Number(iso[3]) };
+    if (!validDate(date))
+      return fail(text, `${dayWord} is not a date.`);
+    const when = at(date);
+    return when > now ? { ok: true, at: when } : fail(text, `${text} has already passed.`);
+  }
+  const md = /^(\d{1,2})\/(\d{1,2})$/.exec(dayWord);
+  if (md) {
+    const month = Number(md[1]);
+    const day = Number(md[2]);
+    if (month === today.month && day === today.day) {
+      const when = at(today);
+      return when > now ? { ok: true, at: when } : fail(text, `${text} has already passed.`);
+    }
+    for (let year = today.year;year <= today.year + 4; year++) {
+      const date = { year, month, day };
+      if (validDate(date) && at(date) > now)
+        return { ok: true, at: at(date) };
+    }
+    return fail(text, `${dayWord} is not a date.`);
+  }
+  const wd = weekday(dayWord);
+  if (wd === -1)
+    return fail(text);
+  const ahead = (wd - clock.weekday + 7) % 7;
+  const sameDay = at(addDays(today, ahead));
+  return { ok: true, at: sameDay > now ? sameDay : at(addDays(today, ahead + 7)) };
+}
+
+// node_modules/@rackbops/docket-types/dist/extract.js
+function parsePrice(text) {
+  const m = /-?\d[\d.,\s]*/.exec(text.replace(/\u00A0/g, " "));
+  if (!m)
+    return null;
+  let digits = m[0].replace(/\s+/g, "");
+  const negative = digits.startsWith("-");
+  if (negative)
+    digits = digits.slice(1);
+  const decimal = /[.,](\d{1,2})$/.exec(digits);
+  let whole = digits;
+  let fraction = "";
+  if (decimal) {
+    whole = digits.slice(0, decimal.index);
+    fraction = decimal[1] ?? "";
+  }
+  whole = whole.replace(/[.,]/g, "");
+  if (whole === "" && fraction === "")
+    return null;
+  const value = Number(`${whole || "0"}.${fraction || "0"}`);
+  if (!Number.isFinite(value))
+    return null;
+  return negative ? -value : value;
+}
+var CURRENCY = /^[A-Z]{3}$/;
+function asCurrency(value) {
+  return typeof value === "string" && CURRENCY.test(value.trim().toUpperCase()) ? value.trim().toUpperCase() : undefined;
+}
+function asPrice(value) {
+  if (typeof value === "number")
+    return Number.isFinite(value) ? value : null;
+  if (typeof value === "string")
+    return parsePrice(value);
+  return null;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function priceFromJson(value, depth = 0) {
+  if (depth > 12)
+    return null;
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const found = priceFromJson(item, depth + 1);
+      if (found)
+        return found;
+    }
+    return null;
+  }
+  if (!isRecord(value))
+    return null;
+  for (const key of ["price", "lowPrice"]) {
+    const price = asPrice(value[key]);
+    if (price !== null) {
+      const currency = asCurrency(value.priceCurrency ?? value.currency);
+      return currency ? { value: price, currency } : { value: price };
+    }
+  }
+  const spec = value.priceSpecification;
+  if (spec) {
+    const found = priceFromJson(spec, depth + 1);
+    if (found)
+      return found;
+  }
+  if (value.offers) {
+    const found = priceFromJson(value.offers, depth + 1);
+    if (found)
+      return found;
+  }
+  for (const [key, child] of Object.entries(value)) {
+    if (key === "offers" || key === "priceSpecification")
+      continue;
+    const found = priceFromJson(child, depth + 1);
+    if (found)
+      return found;
+  }
+  return null;
+}
+var JSON_LD = /<script[^>]*type\s*=\s*["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+function jsonLdBlocks(html) {
+  const blocks = [];
+  for (const m of html.matchAll(JSON_LD)) {
+    try {
+      blocks.push(JSON.parse(m[1] ?? ""));
+    } catch {}
+  }
+  return blocks;
+}
+var META_KEYS = ["product:price:amount", "og:price:amount", "price"];
+var META_CURRENCY_KEYS = ["product:price:currency", "og:price:currency", "priceCurrency"];
+function metaContent(html, key) {
+  const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const tag = new RegExp(`<meta[^>]*(?:property|name|itemprop)\\s*=\\s*["']${escaped}["'][^>]*>`, "i").exec(html);
+  if (!tag)
+    return null;
+  const content = /content\s*=\s*["']([^"']*)["']/i.exec(tag[0]);
+  return content?.[1] ?? null;
+}
+function priceFromMeta(html) {
+  for (const key of META_KEYS) {
+    const raw = metaContent(html, key);
+    const value = raw === null ? null : parsePrice(raw);
+    if (value === null)
+      continue;
+    for (const ck of META_CURRENCY_KEYS) {
+      const currency = asCurrency(metaContent(html, ck));
+      if (currency)
+        return { value, currency };
+    }
+    return { value };
+  }
+  return null;
+}
+function priceFromPattern(body, pattern) {
+  let re;
+  try {
+    re = new RegExp(pattern, "i");
+  } catch {
+    return null;
+  }
+  const m = re.exec(body);
+  const captured = m?.[1] ?? m?.[0];
+  if (captured === undefined)
+    return null;
+  const value = parsePrice(captured);
+  return value === null ? null : { value };
+}
+function extractPrice(body, pattern) {
+  if (pattern)
+    return priceFromPattern(body, pattern);
+  for (const block of jsonLdBlocks(body)) {
+    const found = priceFromJson(block);
+    if (found)
+      return found;
+  }
+  const meta = priceFromMeta(body);
+  if (meta)
+    return meta;
+  const trimmed = body.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      return priceFromJson(JSON.parse(trimmed));
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+// node_modules/@rackbops/docket-types/dist/money.js
+function money(amount, currency) {
+  return `${amount.toFixed(2)} ${currency}`.trim();
+}
+
+// node_modules/@rackbops/docket-types/dist/price.js
+var BASELINE_RULES = ["first", "last", "peak"];
+var DEFAULT_DROP_PERCENT = 10;
+var DEFAULT_BASELINE = "last";
+var MISSES_BEFORE_TELLING = 3;
+var FRESH = {
+  first: null,
+  last: null,
+  peak: null,
+  below: false,
+  misses: 0,
+  alerts: 0
+};
+function stateOf(value) {
+  const s = value;
+  if (!s || typeof s !== "object" || typeof s.misses !== "number")
+    return { ...FRESH };
+  return {
+    first: s.first ?? null,
+    last: s.last ?? null,
+    peak: s.peak ?? null,
+    below: s.below ?? false,
+    misses: s.misses,
+    alerts: s.alerts ?? 0
+  };
+}
+function dropPercent(config) {
+  const d = config.dropPercent;
+  return typeof d === "number" && Number.isFinite(d) && d > 0 && d < 100 ? d : DEFAULT_DROP_PERCENT;
+}
+function baselineRule(config) {
+  return config.baseline && BASELINE_RULES.includes(config.baseline) ? config.baseline : DEFAULT_BASELINE;
+}
+function reference(state, rule) {
+  switch (rule) {
+    case "first":
+      return state.first;
+    case "last":
+      return state.last;
+    case "peak":
+      return state.peak;
+  }
+}
+function miss(ctx, state, reason) {
+  const misses = state.misses + 1;
+  const outcome = { state: { ...state, misses }, summary: `no price: ${reason}` };
+  if (misses === MISSES_BEFORE_TELLING) {
+    outcome.notify = {
+      text: `${ctx.task.title}: no price read from ${ctx.config.url} ${misses} polls in a row ` + `(${reason}). Check the page or the pattern; reply done to stop tracking.`,
+      actions: ["done"]
+    };
+  }
+  return outcome;
+}
+var price = defineTaskType({
+  id: "price",
+  lane: "notify",
+  capabilities: ["notify"],
+  schedule: ["poll"],
+  intake: {
+    options: [
+      { name: "url", description: "The product page", required: true, kind: "string" },
+      { name: "every", description: "Hours between checks", required: true, kind: "integer" },
+      {
+        name: "drop",
+        description: "Alert on a drop of at least this percent; default 10",
+        required: false,
+        kind: "number"
+      },
+      {
+        name: "baseline",
+        description: "Measure the drop from the first, last or peak price seen; default last",
+        required: false,
+        kind: "string"
+      },
+      {
+        name: "pattern",
+        description: "A regular expression whose first group is the price, if the page needs one",
+        required: false,
+        kind: "string"
+      }
+    ]
+  },
+  async run(ctx) {
+    const { fetch } = ctx.ports;
+    if (!fetch)
+      throw new Error("the price type needs the Fetch port; the host configured none");
+    const state = stateOf(ctx.state);
+    let body;
+    try {
+      const response = await fetch.get(ctx.config.url);
+      if (response.status !== 200)
+        return miss(ctx, state, `HTTP ${response.status}`);
+      body = response.body;
+    } catch (err) {
+      return miss(ctx, state, `fetch failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const found = extractPrice(body, ctx.config.pattern);
+    if (!found)
+      return miss(ctx, state, "no price in the page");
+    const seen = found.value;
+    const currency = found.currency ?? ctx.config.currency ?? "";
+    const point = currency ? { value: seen, unit: currency, note: "observed" } : { value: seen, note: "observed" };
+    const rule = baselineRule(ctx.config);
+    const drop = dropPercent(ctx.config);
+    const ref = reference(state, rule);
+    if (ref === null) {
+      return {
+        state: { first: seen, last: seen, peak: seen, below: false, misses: 0, alerts: 0 },
+        series: [point],
+        notify: {
+          text: `Now tracking ${ctx.task.title} at ${money(seen, currency)}. I will say when it ` + `drops ${drop}% or more from the ${rule} price seen. ${ctx.config.url}`,
+          actions: ["done"]
+        },
+        summary: `baseline ${money(seen, currency)}`
+      };
+    }
+    const line = ref * (1 - drop / 100);
+    const below = seen <= line + 0.000000001;
+    const crossing = below && !state.below;
+    const next = {
+      first: state.first ?? seen,
+      last: seen,
+      peak: Math.max(state.peak ?? seen, seen),
+      below,
+      misses: 0,
+      alerts: state.alerts + (crossing ? 1 : 0)
+    };
+    if (!crossing) {
+      return {
+        state: next,
+        series: [point],
+        summary: `${money(seen, currency)} (${rule} ${money(ref, currency)})`
+      };
+    }
+    const pct = Math.round((ref - seen) / ref * 100);
+    return {
+      state: next,
+      series: [point],
+      notify: {
+        text: `${ctx.task.title}: ${money(seen, currency)}, down ${pct}% from ` + `${money(ref, currency)} (${rule} seen). ${ctx.config.url}`,
+        actions: ["done"]
+      },
+      summary: `alert: ${money(seen, currency)}, down ${pct}% from ${money(ref, currency)}`
+    };
+  },
+  async onReply(ctx) {
+    if (ctx.reply.kind === "done")
+      return { complete: true, summary: "stopped tracking" };
+    return {};
+  }
+});
+
+// node_modules/@rackbops/docket-types/dist/reminder.js
+var DEFAULT_SNOOZE_MS = 60 * 60000;
+function snoozeUntil(payload, now) {
+  if (typeof payload === "object" && payload !== null) {
+    const p = payload;
+    if (typeof p.until === "string" && !Number.isNaN(Date.parse(p.until)))
+      return new Date(p.until);
+    if (typeof p.minutes === "number" && Number.isFinite(p.minutes) && p.minutes > 0) {
+      return new Date(now.getTime() + p.minutes * 60000);
+    }
+  }
+  return new Date(now.getTime() + DEFAULT_SNOOZE_MS);
+}
+var reminder = defineTaskType({
+  id: "reminder",
+  lane: "notify",
+  capabilities: ["notify"],
+  schedule: ["once", "calendar"],
+  intake: {
+    options: [
+      { name: "text", description: "What to be reminded of", required: true, kind: "string" },
+      {
+        name: "at",
+        description: "When, for a one-off reminder (an instant; the bot parses the person's words)",
+        required: false,
+        kind: "datetime"
+      }
+    ]
+  },
+  async run(ctx) {
+    return {
+      notify: { text: ctx.config.text, actions: ["done", "snooze"] },
+      summary: ctx.config.text
+    };
+  },
+  async onReply(ctx) {
+    if (ctx.reply.kind === "snooze") {
+      const until = snoozeUntil(ctx.reply.payload, ctx.now);
+      return { snoozeUntil: until, summary: `snoozed until ${until.toISOString()}` };
+    }
+    if (ctx.reply.kind === "done")
+      return { summary: "done" };
+    return {};
+  }
+});
+
+// node_modules/@rackbops/docket-types/dist/renewal.js
+var RENEWAL_DECISIONS = ["keep", "cancel", "renewed"];
+function isRenewalDecision(value) {
+  return RENEWAL_DECISIONS.includes(value);
+}
+function stateOf2(ctx) {
+  const s = ctx.state;
+  if (s && typeof s.amount === "number" && Number.isFinite(s.amount)) {
+    return {
+      amount: s.amount,
+      decision: s.decision ?? null,
+      decidedAt: s.decidedAt ?? null,
+      periodDate: s.periodDate ?? null
+    };
+  }
+  return { amount: ctx.config.amount, decision: null, decidedAt: null, periodDate: null };
+}
+function decisionOf(payload) {
+  if (typeof payload === "string") {
+    return { choice: isRenewalDecision(payload) ? payload : null, amount: null };
+  }
+  if (typeof payload === "object" && payload !== null) {
+    const p = payload;
+    const choice = typeof p.choice === "string" && isRenewalDecision(p.choice) ? p.choice : null;
+    const amount = typeof p.amount === "number" && Number.isFinite(p.amount) && p.amount >= 0 ? p.amount : null;
+    return { choice, amount };
+  }
+  return { choice: null, amount: null };
+}
+function periodDateOf(ctx) {
+  const due = new Date(ctx.originalDueAt ?? ctx.occurrence.dueAt);
+  const zone = ctx.owner.timeZone;
+  if (ctx.task.schedule?.kind === "period")
+    return periodDate(ctx.task.schedule, due, zone);
+  const w = wallClock(due, zone);
+  return `${w.year}-${String(w.month).padStart(2, "0")}-${String(w.day).padStart(2, "0")}`;
+}
+function plural(n, word) {
+  return `${n} ${word}${n === 1 ? "" : "s"}`;
+}
+function when(date, ctx) {
+  const days = daysUntil(date, ctx.now, ctx.owner.timeZone);
+  if (days === null || days > 0) {
+    return days === null ? `on ${date}` : `on ${date}, in ${plural(days, "day")}`;
+  }
+  return days === 0 ? `today, ${date}` : `on ${date}, ${plural(-days, "day")} ago`;
+}
+var renewal = defineTaskType({
+  id: "renewal",
+  lane: "notify",
+  capabilities: ["notify"],
+  schedule: ["period", "once"],
+  intake: {
+    options: [
+      { name: "amount", description: "What one period costs", required: true, kind: "number" },
+      { name: "currency", description: "Currency code, e.g. USD", required: true, kind: "string" },
+      {
+        name: "renews",
+        description: "The next renewal or expiry date, YYYY-MM-DD",
+        required: true,
+        kind: "string"
+      },
+      {
+        name: "every",
+        description: "Periods between renewals (with unit); default 1",
+        required: false,
+        kind: "integer"
+      },
+      {
+        name: "unit",
+        description: "day, week, month or year; default year",
+        required: false,
+        kind: "string"
+      },
+      {
+        name: "lead",
+        description: "Days before the date to ask; default 7",
+        required: false,
+        kind: "integer"
+      },
+      { name: "note", description: "Carried on every reminder", required: false, kind: "string" }
+    ]
+  },
+  async run(ctx) {
+    const state = stateOf2(ctx);
+    const date = periodDateOf(ctx);
+    const cost = money(state.amount, ctx.config.currency);
+    const lines = [
+      `${ctx.task.title} renews ${when(date, ctx)}: ${cost}. Keep it, cancel it, or mark it renewed.`
+    ];
+    if (ctx.config.note)
+      lines.push(ctx.config.note);
+    const paid = ctx.history.series.filter((p) => p.note === "keep" || p.note === "renewed");
+    if (paid.length > 0) {
+      const total = paid.reduce((sum, p) => sum + p.value, 0);
+      lines.push(`So far: ${plural(paid.length, "period")}, ${money(total, ctx.config.currency)}.`);
+    }
+    if (state.decision && state.periodDate) {
+      lines.push(`Last time (${state.periodDate}): ${state.decision}.`);
+    }
+    return {
+      notify: {
+        text: lines.join(`
+`),
+        actions: ["decision", "snooze"],
+        decisions: [...RENEWAL_DECISIONS]
+      },
+      summary: `asked: renews ${date} for ${cost}`
+    };
+  },
+  async onReply(ctx) {
+    if (ctx.reply.kind === "snooze") {
+      const until = snoozeUntil(ctx.reply.payload, ctx.now);
+      return { snoozeUntil: until, summary: `snoozed until ${until.toISOString()}` };
+    }
+    if (ctx.reply.kind !== "decision")
+      return {};
+    const { choice, amount } = decisionOf(ctx.reply.payload);
+    if (!choice)
+      return { summary: `decision not understood; say ${RENEWAL_DECISIONS.join(", ")}` };
+    const previous = stateOf2(ctx);
+    const date = periodDateOf(ctx);
+    const state = {
+      amount: amount ?? previous.amount,
+      decision: choice,
+      decidedAt: ctx.now.toISOString(),
+      periodDate: date
+    };
+    if (choice === "cancel")
+      return { state, complete: true, summary: `cancelled before ${date}` };
+    const point = {
+      value: state.amount,
+      unit: ctx.config.currency,
+      note: choice
+    };
+    return {
+      state,
+      series: [point],
+      summary: `${choice} for ${date} at ${money(state.amount, ctx.config.currency)}`
+    };
+  }
+});
+// node_modules/@rackbops/docket-types/dist/index.js
+var TASK_TYPES = Object.freeze({
+  reminder,
+  renewal,
+  price
+});
+
+// plugins/tracker/src/access.ts
+var NOT_MEMBER = "This tracker is only for members of its server.";
+var MEMBERSHIP_UNKNOWN = "I could not check that you are a member of this tracker's server. Try again in a minute.";
+var NOT_ADMITTED = "You are not on this tracker's list yet: ask an admin to `/allow` you.";
+var NOT_REGISTERED = "Run `/register` first: it sets when your reminders reach you.";
+var NOT_ADMIN = "Only a tracker admin can do that.";
+function decideAccess(input) {
+  if (input.membership === "not-member")
+    return NOT_MEMBER;
+  if (input.membership === "unknown")
+    return MEMBERSHIP_UNKNOWN;
+  if (!input.person)
+    return NOT_ADMITTED;
+  if (input.need === "admin")
+    return input.person.admin ? null : NOT_ADMIN;
+  if (input.need === "registered" && !input.registered)
+    return NOT_REGISTERED;
+  return null;
+}
+function parseGuildId(raw) {
+  if (raw === undefined || raw.trim() === "")
+    return null;
+  const id = raw.trim();
+  if (!/^[0-9]{17,20}$/.test(id))
+    throw new Error(`TRACKER_GUILD_ID: "${id}" is not a Discord server id`);
+  return id;
+}
+
+// plugins/tracker/src/admissions.ts
+class Admissions {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  get(userId) {
+    const r = this.db.query("SELECT * FROM admissions WHERE user_id = ?").get(userId);
+    if (!r)
+      return { userId, admittedBy: null, admittedAt: null, registeredAt: null };
+    return { userId, admittedBy: r.admitted_by, admittedAt: r.admitted_at, registeredAt: r.registered_at };
+  }
+  record(userId, admittedBy, at) {
+    this.db.query("INSERT INTO admissions (user_id, admitted_by, admitted_at) VALUES (?, ?, ?) ON CONFLICT (user_id) DO NOTHING").run(userId, admittedBy, at);
+  }
+  markRegistered(userId, at) {
+    this.db.query(`INSERT INTO admissions (user_id, admitted_by, admitted_at, registered_at) VALUES (?, NULL, ?, ?)
+         ON CONFLICT (user_id) DO UPDATE SET registered_at = COALESCE(admissions.registered_at, excluded.registered_at)`).run(userId, at, at);
+  }
+  isRegistered(userId) {
+    return this.get(userId).registeredAt !== null;
+  }
+}
+
+// plugins/tracker/src/claims.ts
+function toClaim(r) {
+  const s = (v) => v === null || v === undefined ? null : String(v);
+  return {
+    occurrenceId: String(r.occurrence_id),
+    userId: String(r.user_id),
+    discordId: String(r.discord_id),
+    status: String(r.status),
+    messageId: s(r.message_id),
+    channelId: s(r.channel_id),
+    error: s(r.error),
+    claimedAt: String(r.claimed_at),
+    settledAt: s(r.settled_at),
+    reportedAt: s(r.reported_at)
+  };
+}
+
+class ClaimStore {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  get(occurrenceId, userId) {
+    const r = this.db.query("SELECT * FROM delivery_claims WHERE occurrence_id = ? AND user_id = ?").get(occurrenceId, userId);
+    return r ? toClaim(r) : null;
+  }
+  claim(occurrenceId, userId, discordId, at) {
+    const { changes } = this.db.query(`INSERT INTO delivery_claims (occurrence_id, user_id, discord_id, status, claimed_at)
+         VALUES (?, ?, ?, 'claimed', ?)
+         ON CONFLICT (occurrence_id, user_id) DO UPDATE SET
+           discord_id = excluded.discord_id, status = 'claimed', claimed_at = excluded.claimed_at,
+           message_id = NULL, channel_id = NULL, error = NULL, settled_at = NULL, reported_at = NULL
+         WHERE delivery_claims.status = 'failed'`).run(occurrenceId, userId, discordId, at);
+    return changes === 1;
+  }
+  settle(occurrenceId, userId, status, at, detail = {}) {
+    this.db.query(`UPDATE delivery_claims SET status = ?, message_id = ?, channel_id = ?, error = ?, settled_at = ?
+         WHERE occurrence_id = ? AND user_id = ?`).run(status, detail.messageId ?? null, detail.channelId ?? null, detail.error ?? null, at, occurrenceId, userId);
+  }
+  markReported(occurrenceId, userId, at) {
+    this.db.query("UPDATE delivery_claims SET reported_at = ? WHERE occurrence_id = ? AND user_id = ?").run(at, occurrenceId, userId);
+  }
+  listUnsettled() {
+    return this.db.query("SELECT * FROM delivery_claims WHERE status IN ('claimed', 'unconfirmed') ORDER BY claimed_at").all().map(toClaim);
+  }
+}
+
+// plugins/tracker/src/delivery-health.ts
+var PAUSE_AFTER = 3;
+var PAUSE_DETAIL = `delivery paused: ${PAUSE_AFTER} DMs in a row could not be delivered (DMs closed, or the bot is blocked)`;
+function decidePause(failures, alreadyPaused) {
+  return !alreadyPaused && failures >= PAUSE_AFTER;
+}
+function name2(u, fallback) {
+  return u?.displayName ?? fallback;
+}
+function recipientPausedText(task, recipient, recipientId) {
+  return `Your task \`${task.id}\` (${task.title}) is paused: I could not DM ${name2(recipient, recipientId)} ${PAUSE_AFTER} times in a row. ` + `It resumes when they next use the tracker, or run \`/task resume ${task.id}\` to go on without them.`;
+}
+
+class DeliveryHealth {
+  db;
+  store;
+  options;
+  chain = Promise.resolve();
+  constructor(db, store, options = {}) {
+    this.db = db;
+    this.store = store;
+    this.options = options;
+  }
+  locked(fn) {
+    const next = this.chain.then(fn, fn);
+    this.chain = next.catch(() => {});
+    return next;
+  }
+  get(userId) {
+    const r = this.db.query("SELECT * FROM delivery_health WHERE user_id = ?").get(userId);
+    if (!r)
+      return null;
+    return { userId: r.user_id, failures: Number(r.failures), lastError: r.last_error, lastFailedAt: r.last_failed_at, pausedAt: r.paused_at };
+  }
+  isPaused(userId) {
+    return this.get(userId)?.pausedAt != null;
+  }
+  pausesFor(taskId) {
+    return this.db.query("SELECT user_id FROM delivery_pauses WHERE task_id = ? ORDER BY at, user_id").all(taskId).map((r) => r.user_id);
+  }
+  recordSuccess(userId) {
+    this.db.query("UPDATE delivery_health SET failures = 0 WHERE user_id = ? AND paused_at IS NULL").run(userId);
+  }
+  async recordFailure(userId, error, at) {
+    const notices = [];
+    const result = await this.locked(async () => {
+      this.db.query(`INSERT INTO delivery_health (user_id, failures, last_error, last_failed_at) VALUES (?, 1, ?, ?)
+           ON CONFLICT (user_id) DO UPDATE SET failures = delivery_health.failures + 1,
+             last_error = excluded.last_error, last_failed_at = excluded.last_failed_at`).run(userId, error, at);
+      const row = this.get(userId);
+      const pauses = decidePause(row.failures, row.pausedAt !== null);
+      if (!pauses && row.pausedAt === null)
+        return { failures: row.failures, paused: false };
+      if (pauses)
+        this.db.query("UPDATE delivery_health SET paused_at = ? WHERE user_id = ?").run(at, userId);
+      await this.pauseAffected(userId, at, notices);
+      return { failures: row.failures, paused: pauses };
+    });
+    for (const n of notices)
+      await this.tellOwner(n);
+    return result;
+  }
+  async affected(userId) {
+    const found = [];
+    for (const task of await this.store.listTasks()) {
+      if (task.ownerId === userId)
+        found.push({ task, asRecipient: false });
+      else if ((await this.store.listRecipients(task.id)).some((r) => r.userId === userId && r.state === "accepted")) {
+        found.push({ task, asRecipient: true });
+      }
+    }
+    return found;
+  }
+  async pauseAffected(userId, at, notices) {
+    const recipient = await this.store.getUser(userId);
+    for (const { task, asRecipient } of await this.affected(userId)) {
+      if (task.status !== "active" && this.pausesFor(task.id).length === 0)
+        continue;
+      const { changes } = this.db.query("INSERT INTO delivery_pauses (task_id, user_id, at) VALUES (?, ?, ?) ON CONFLICT DO NOTHING").run(task.id, userId, at);
+      if (changes === 0 || task.status !== "active")
+        continue;
+      await this.store.updateTask(task.id, { status: "paused", at });
+      const detail = asRecipient ? `delivery to ${name2(recipient, userId)} paused: ${PAUSE_AFTER} DMs in a row could not be delivered` : PAUSE_DETAIL;
+      await this.store.addTaskEvent({ taskId: task.id, actorId: null, kind: "paused", detail, at });
+      if (asRecipient) {
+        const owner = await this.store.getUser(task.ownerId);
+        if (owner)
+          notices.push({ owner, task, text: recipientPausedText(task, recipient, userId) });
+      }
+    }
+  }
+  async tellOwner({ owner, task, text }) {
+    if (!this.options.tellOwner)
+      return;
+    try {
+      await this.options.tellOwner(owner, text);
+    } catch (err) {
+      this.options.log?.warn(`could not tell ${owner.id} that ${task.id} paused: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  async release(taskId, actorId, detail, now) {
+    if (this.pausesFor(taskId).length > 0)
+      return false;
+    const task = await this.store.getTask(taskId);
+    if (!task || task.status !== "paused")
+      return false;
+    const at = now.toISOString();
+    const active = await this.store.updateTask(taskId, { status: "active", at });
+    await this.store.addTaskEvent({ taskId, actorId, kind: "resumed", detail, at });
+    const owner = await this.store.getUser(task.ownerId);
+    if (owner)
+      await materialize(this.store, active, owner, now);
+    return true;
+  }
+  resume(userId, now) {
+    return this.locked(async () => {
+      const row = this.get(userId);
+      if (!row?.pausedAt)
+        return null;
+      const tasks = this.pausedTasksOf(userId);
+      this.db.transaction(() => {
+        this.db.query("UPDATE delivery_health SET failures = 0, paused_at = NULL WHERE user_id = ?").run(userId);
+        this.db.query("DELETE FROM delivery_pauses WHERE user_id = ?").run(userId);
+      })();
+      const resumed = [];
+      for (const id of tasks)
+        if (await this.release(id, userId, "delivery resumed", now))
+          resumed.push(id);
+      return { pausedAt: row.pausedAt, tasks: resumed };
+    });
+  }
+  pausedTasksOf(userId) {
+    return this.db.query("SELECT task_id FROM delivery_pauses WHERE user_id = ? ORDER BY at, task_id").all(userId).map((r) => r.task_id);
+  }
+  resumeTask(task, ownerId, now) {
+    return this.locked(async () => {
+      const held = this.pausesFor(task.id).filter((u) => u !== ownerId);
+      if (held.length === 0 && this.pausesFor(task.id).length === 0)
+        return null;
+      const at = now.toISOString();
+      for (const userId of held) {
+        this.db.query("DELETE FROM delivery_pauses WHERE task_id = ? AND user_id = ?").run(task.id, userId);
+        await this.store.removeRecipient(task.id, userId);
+        await this.store.addTaskEvent({ taskId: task.id, actorId: ownerId, kind: "recipient_removed", detail: `${userId}: DMs could not be delivered`, at });
+      }
+      await this.release(task.id, ownerId, "resumed by the owner", now);
+      return held;
+    });
+  }
+}
+function resumedNotice(r) {
+  const what = r.tasks.length === 0 ? "Nothing else was waiting on you." : `${r.tasks.length} task(s) are back on.`;
+  return `I could not DM you ${PAUSE_AFTER} times in a row, so your reminders were paused. ${what} ` + "Check that you accept DMs from members of a server we share, or they will pause again.";
+}
+
+// plugins/tracker/src/people.ts
+var DEFAULT_TIME_ZONE = "America/New_York";
+var DEFAULT_PREFERRED_HOUR = 9;
+var SNOWFLAKE = /^[0-9]{17,20}$/;
+
+class PeopleError extends Error {
+  name = "PeopleError";
+}
+function parseAdminIds(raw) {
+  if (raw === undefined || raw.trim() === "")
+    return [];
+  const ids = raw.split(",").map((s) => s.trim());
+  for (const id of ids) {
+    if (!SNOWFLAKE.test(id))
+      throw new PeopleError(`TRACKER_ADMIN_DISCORD_IDS: "${id}" is not a Discord user id`);
+  }
+  return [...new Set(ids)];
+}
+async function admit(store, discordId, now, options = {}) {
+  if (!SNOWFLAKE.test(discordId))
+    throw new PeopleError(`"${discordId}" is not a Discord user id`);
+  const existing = await store.findUserByDiscordId(discordId);
+  if (existing)
+    return existing;
+  try {
+    return await store.createUser({
+      discordId,
+      timeZone: DEFAULT_TIME_ZONE,
+      preferredHour: DEFAULT_PREFERRED_HOUR,
+      admin: options.admin ?? false,
+      at: now.toISOString()
+    });
+  } catch (err) {
+    const winner = await store.findUserByDiscordId(discordId);
+    if (winner)
+      return winner;
+    throw err;
+  }
+}
+async function seedAdmins(store, discordIds, now) {
+  const granted = [];
+  for (const discordId of discordIds) {
+    const existing = await store.findUserByDiscordId(discordId);
+    if (existing?.admin)
+      continue;
+    if (existing)
+      await store.updateUser(existing.id, { admin: true });
+    else
+      await admit(store, discordId, now, { admin: true });
+    granted.push(discordId);
+  }
+  return granted;
+}
+async function setPreferences(store, userId, prefs) {
+  if (prefs.timeZone !== undefined && !isTimeZone(prefs.timeZone)) {
+    throw new PeopleError(`"${prefs.timeZone}" is not a time zone (use an IANA name such as America/New_York)`);
+  }
+  if (prefs.preferredHour !== undefined && !(Number.isInteger(prefs.preferredHour) && prefs.preferredHour >= 0 && prefs.preferredHour <= 23)) {
+    throw new PeopleError(`preferred hour must be a whole hour from 0 to 23, not ${prefs.preferredHour}`);
+  }
+  return store.updateUser(userId, {
+    ...prefs.timeZone !== undefined ? { timeZone: prefs.timeZone } : {},
+    ...prefs.preferredHour !== undefined ? { preferredHour: prefs.preferredHour } : {}
+  });
+}
+
+// plugins/tracker/src/actions.ts
+var MAX_ANSWER = 2000;
+var MAX_REMINDER_TEXT = 1500;
+var MAX_TITLE = 100;
+var NO_SUCH_TASK = "You have no task with that id. `/tasks` lists yours.";
+function clip(text, max = MAX_ANSWER) {
+  return text.length <= max ? text : `${text.slice(0, max - 3)}...`;
+}
+async function enter(d, discordId, membership, need) {
+  const person = await d.store.findUserByDiscordId(discordId);
+  const registered = person ? d.admissions.isRegistered(person.id) : false;
+  const refusal = decideAccess({ membership, person, registered, need });
+  if (refusal !== null || !person)
+    return { ok: false, content: refusal ?? "" };
+  const resumed = await d.health.resume(person.id, d.clock.now());
+  return { ok: true, user: person, notice: resumed ? resumedNotice(resumed) : null };
+}
+async function allowPerson(d, admin, target) {
+  if (target.bot)
+    return "A bot cannot use the tracker.";
+  if (target.membership === "not-member")
+    return `<@${target.discordId}> is not a member of this tracker's server.`;
+  if (target.membership === "unknown")
+    return "I could not check that they are a member of this tracker's server. Try again in a minute.";
+  const before = await d.store.findUserByDiscordId(target.discordId);
+  const now = d.clock.now();
+  const user = await admit(d.store, target.discordId, now);
+  d.admissions.record(user.id, admin.id, now.toISOString());
+  if (before)
+    return `<@${target.discordId}> is already on the list.`;
+  return `Allowed <@${target.discordId}>: they can now use \`/register\`.`;
+}
+function registeredText(user, first) {
+  return [
+    first ? "You are registered." : "Your settings are updated.",
+    `Reminders reach you by DM. One without a time of day arrives at ${String(user.preferredHour).padStart(2, "0")}:00, ${user.timeZone} time.`,
+    `Your tasks are private to you and anyone you choose to share them with. ${ADMIN_DISCLOSURE}`,
+    `Keep DMs from this server open: after ${PAUSE_AFTER} DMs in a row that cannot be delivered, your reminders pause until you next use a command.`
+  ].join(`
+`);
+}
+async function registerPerson(d, user, input) {
+  let updated;
+  try {
+    updated = await setPreferences(d.store, user.id, {
+      ...input.hour !== undefined ? { preferredHour: input.hour } : {},
+      ...input.zone !== undefined ? { timeZone: input.zone } : {}
+    });
+  } catch (err) {
+    if (err instanceof PeopleError)
+      return err.message;
+    throw err;
+  }
+  updated = await d.store.updateUser(user.id, { displayName: clip(input.displayName, 100) });
+  const first = !d.admissions.isRegistered(user.id);
+  d.admissions.markRegistered(user.id, d.clock.now().toISOString());
+  const zoneChanged = updated.timeZone !== user.timeZone;
+  if (zoneChanged || updated.preferredHour !== user.preferredHour)
+    await rescheduleOwned(d, updated, zoneChanged);
+  return registeredText(updated, first);
+}
+async function setHour(d, user, hour) {
+  if (hour === user.preferredHour)
+    return `Your preferred hour is already ${String(hour).padStart(2, "0")}:00, ${user.timeZone} time.`;
+  let updated;
+  try {
+    updated = await setPreferences(d.store, user.id, { preferredHour: hour });
+  } catch (err) {
+    if (err instanceof PeopleError)
+      return err.message;
+    throw err;
+  }
+  const moved = await rescheduleOwned(d, updated, false);
+  const note = moved > 0 ? ` ${moved} recurring reminder(s) moved to it.` : "";
+  return `Your preferred hour is now ${String(hour).padStart(2, "0")}:00, ${updated.timeZone} time.${note}`;
+}
+async function rescheduleOwned(d, owner, zoneChanged) {
+  let moved = 0;
+  for (const task of await d.store.listTasks({ ownerId: owner.id, status: "active" })) {
+    const s = task.schedule;
+    if (!s || s.kind !== "calendar" && s.kind !== "period")
+      continue;
+    if (!zoneChanged && s.hour !== undefined)
+      continue;
+    const snoozes = (await d.store.listOccurrences({ taskId: task.id, status: "queued" })).filter((o) => o.dedupeKey.startsWith(SNOOZE_PREFIX));
+    const now = d.clock.now();
+    await reschedule(d.store, task, owner, s, owner.id, now);
+    for (const o of snoozes) {
+      await d.store.createOccurrence({ taskId: o.taskId, lane: o.lane, dueAt: o.dueAt, dedupeKey: o.dedupeKey, at: now.toISOString() });
+    }
+    moved++;
+  }
+  return moved;
+}
+function reminderSchedule(when, repeat, zone, now) {
+  if (repeat === "none") {
+    if (!when)
+      return 'Say when: for example "in 20 minutes", "tomorrow 9am" or "friday at 17:30".';
+    return { kind: "once", at: when.toISOString() };
+  }
+  const w = wallClock(when ?? now, zone);
+  const start = `${w.year}-${String(w.month).padStart(2, "0")}-${String(w.day).padStart(2, "0")}`;
+  const base = { kind: "calendar", every: 1, unit: repeat, start };
+  if (!when)
+    return base;
+  return {
+    ...base,
+    hour: w.hour,
+    minute: w.minute,
+    ...repeat === "week" ? { weekdays: [w.weekday] } : {},
+    ...repeat === "month" ? { dayOfMonth: w.day } : {}
+  };
+}
+async function remind(d, user, input) {
+  const type = d.types.reminder;
+  if (!type)
+    return "Reminders are not available on this bot.";
+  const text = input.text.trim();
+  if (text.length === 0)
+    return "Say what to remind you of.";
+  if (text.length > MAX_REMINDER_TEXT)
+    return `That reminder is longer than ${MAX_REMINDER_TEXT} characters.`;
+  const now = d.clock.now();
+  let when = null;
+  if (input.when !== undefined && input.when.trim() !== "") {
+    const parsed = parseWhen(input.when, now, { zone: user.timeZone, defaultHour: user.preferredHour });
+    if (!parsed.ok)
+      return parsed.error;
+    when = parsed.at;
+  }
+  const schedule = reminderSchedule(when, input.repeat, user.timeZone, now);
+  if (typeof schedule === "string")
+    return schedule;
+  const actor = { userId: user.id, admin: user.admin };
+  const { task, next } = await createTask(d.store, actor, user, { type, title: clip(text, MAX_TITLE), config: { text }, schedule }, now);
+  const at = next ? formatInstant(next.dueAt, user.timeZone, now) : "never (that time has no next run)";
+  const cadence = schedule.kind === "once" ? "" : `, ${describeSchedule(schedule, user, user.timeZone, now)}`;
+  return clip(`Reminder \`${task.id}\` set: ${text}
+Next: ${at}${cadence}.`);
+}
+async function listTasks(d, user) {
+  const now = d.clock.now();
+  const lines = [formatTaskList(await taskList(d.store, { userId: user.id, admin: user.admin }), user, now)];
+  for (const task of await d.store.listTasks({ ownerId: user.id, status: "paused" })) {
+    const held = d.health.pausesFor(task.id).filter((u) => u !== user.id);
+    if (held.length === 0) {
+      lines.push(`Paused: \`${task.id}\` ${task.title}`);
+      continue;
+    }
+    const who = [];
+    for (const id of held)
+      who.push((await d.store.getUser(id))?.displayName ?? id);
+    lines.push(`Paused: \`${task.id}\` ${task.title} -- I could not DM ${who.join(", ")}; \`/task resume ${task.id}\` goes on without them.`);
+  }
+  return clip(lines.join(`
+`));
+}
+function replyLanes(d) {
+  return new Lanes({ store: d.store, clock: d.clock, types: d.types, notifier: d.notifier });
+}
+async function ownTask(d, user, taskId) {
+  const task = await visibleTask(d.store, { userId: user.id, admin: false }, taskId.trim());
+  return task && task.ownerId === user.id ? task : null;
+}
+async function answerLatest(d, user, input) {
+  const task = await ownTask(d, user, input.taskId);
+  if (!task)
+    return NO_SUCH_TASK;
+  const fired = (await d.store.listOccurrences({ taskId: task.id })).filter((o) => o.status === "running" || o.status === "done" || o.status === "failed");
+  const latest = fired.at(-1);
+  if (!latest)
+    return "That task has not reminded you yet, so there is nothing to answer.";
+  let payload = null;
+  if (input.kind === "snooze" && input.until !== undefined && input.until.trim() !== "") {
+    const parsed = parseWhen(input.until, d.clock.now(), { zone: user.timeZone, defaultHour: user.preferredHour });
+    if (!parsed.ok)
+      return parsed.error;
+    payload = { until: parsed.at.toISOString() };
+  }
+  try {
+    const outcome = await replyLanes(d).reply({ taskId: task.id, occurrenceId: latest.id, userId: user.id, kind: input.kind, payload });
+    return answeredText(input.kind, outcome?.snoozeUntil ?? null, user, d.clock.now());
+  } catch (err) {
+    if (err instanceof ReplyRefusedError)
+      return err.message;
+    throw err;
+  }
+}
+function answeredText(kind, snoozeUntil, user, now) {
+  if (kind === "snooze" && snoozeUntil)
+    return `Snoozed until ${formatInstant(snoozeUntil, user.timeZone, now)}.`;
+  if (kind === "done")
+    return "Marked done.";
+  return "Recorded.";
+}
+async function resumeTask(d, user, taskId) {
+  const task = await ownTask(d, user, taskId);
+  if (!task)
+    return NO_SUCH_TASK;
+  const removed = await d.health.resumeTask(task, user.id, d.clock.now());
+  if (removed === null)
+    return task.status === "paused" ? "That task was not paused by failed DMs." : `That task is ${task.status}, not paused.`;
+  const names = [];
+  for (const id of removed)
+    names.push((await d.store.getUser(id))?.displayName ?? id);
+  const without = names.length > 0 ? `, without ${names.join(", ")}` : "";
+  return `Resumed \`${task.id}\`${without}.`;
+}
+
+// plugins/tracker/src/discord-common.ts
+import { MessageFlags } from "discord.js";
+var STARTING = "The tracker is starting up; try again in a minute.";
+var FAILED = "Something went wrong on my side; try again in a minute.";
+var EPHEMERAL = { flags: MessageFlags.Ephemeral };
+var NO_MENTIONS = { allowedMentions: { parse: [] } };
+var UNKNOWN_MEMBER = 10007;
+var UNKNOWN_USER = 10013;
+async function lookupMembership(interaction, guildId, discordId, log) {
+  if (guildId === null)
+    return "not-checked";
+  if (interaction.guildId === guildId && interaction.user.id === discordId)
+    return "member";
+  try {
+    const guild = await interaction.client.guilds.fetch(guildId);
+    await guild.members.fetch({ user: discordId });
+    return "member";
+  } catch (err) {
+    const code = err.code;
+    if (code === UNKNOWN_MEMBER || code === UNKNOWN_USER)
+      return "not-member";
+    log.warn(`could not check membership of ${guildId}: ${err instanceof Error ? err.message : String(err)}`);
+    return "unknown";
+  }
+}
+function serial() {
+  let chain = Promise.resolve();
+  return (fn) => {
+    const next = chain.then(fn, fn);
+    chain = next.catch(() => {});
+    return next;
+  };
+}
+
+// plugins/tracker/src/history.ts
+var HISTORY_RUNS = 10;
+var HISTORY_CHANGES = 5;
+function replyText(r) {
+  if (r.kind === "text") {
+    const text = typeof r.payload === "object" && r.payload !== null ? String(r.payload.text ?? "") : "";
+    return `replied "${clip(text, 80)}"`;
+  }
+  if (r.kind === "decision")
+    return `chose ${String(r.payload?.choice ?? "?")}`;
+  return r.kind === "opt_out" ? "opted out" : r.kind;
+}
+function formatRun(o, replies, people, viewer, now) {
+  const late = o.late ? " (late)" : "";
+  const error = o.status === "failed" && o.error ? `: ${clip(o.error, 120)}` : "";
+  const answers = replies.filter((r) => r.occurrenceId === o.id).map((r) => `${people.get(r.userId)?.displayName ?? r.userId} ${replyText(r)}`);
+  const answered = answers.length > 0 ? `; ${answers.join(", ")}` : "";
+  return `- ${formatInstant(o.dueAt, viewer.timeZone, now)} -- ${o.status}${late}${error}${answered}`;
+}
+function formatChange(e, viewer, now) {
+  const detail = e.kind === "paused" || e.kind === "resumed" ? `: ${e.detail}` : "";
+  return `- ${formatInstant(e.at, viewer.timeZone, now)} ${e.kind.replaceAll("_", " ")}${detail}`;
+}
+async function taskHistory(d, user, taskId) {
+  const actor = { userId: user.id, admin: user.admin };
+  const id = taskId.trim();
+  const task = await visibleTask(d.store, actor, id);
+  if (!task)
+    return NO_SUCH_TASK;
+  const now = d.clock.now();
+  const all = await visibleOccurrences(d.store, actor, task.id) ?? [];
+  const upcoming = (o) => o.status === "queued" && Date.parse(o.dueAt) > now.getTime();
+  const runs = all.filter((o) => !upcoming(o));
+  const next = all.find(upcoming);
+  const replies = await visibleReplies(d.store, actor, task.id) ?? [];
+  const changes = await visibleHistory(d.store, actor, task.id) ?? [];
+  const people = new Map;
+  for (const r of replies) {
+    if (!people.has(r.userId)) {
+      const u = await d.store.getUser(r.userId);
+      if (u)
+        people.set(u.id, u);
+    }
+  }
+  const owner = task.ownerId === user.id ? user : await d.store.getUser(task.ownerId);
+  const cadence = task.schedule && owner ? describeSchedule(task.schedule, owner, user.timeZone, now) : "no schedule";
+  const lines = [`\`${task.id}\` ${task.title} -- ${task.type}, ${task.status}, ${cadence}`];
+  lines.push(next ? `Next: ${formatInstant(next.dueAt, user.timeZone, now)}` : "Next: nothing scheduled");
+  lines.push(runs.length === 0 ? "Runs: none yet" : "Runs:");
+  if (runs.length > HISTORY_RUNS)
+    lines.push(`- (${runs.length - HISTORY_RUNS} earlier)`);
+  for (const o of runs.slice(-HISTORY_RUNS))
+    lines.push(formatRun(o, replies, people, user, now));
+  lines.push("Changes:");
+  if (changes.length > HISTORY_CHANGES)
+    lines.push(`- (${changes.length - HISTORY_CHANGES} earlier)`);
+  for (const e of changes.slice(-HISTORY_CHANGES))
+    lines.push(formatChange(e, user, now));
+  return clip(lines.join(`
+`));
+}
+
+// plugins/tracker/src/interactions.ts
+import {
+  ActionRowBuilder,
+  ButtonBuilder,
+  ButtonStyle,
+  ModalBuilder,
+  TextInputBuilder,
+  TextInputStyle
+} from "discord.js";
+
+// plugins/tracker/src/buttons.ts
+var PREFIX = "tracker:";
+var REPLY_CODE = "r";
+var MODAL_CODE = "m";
+var REPLY_FIELD = "text";
+var MAX_REPLY_TEXT = 1000;
+var MAX_BUTTONS = 25;
+var STYLE = {
+  done: "success",
+  snooze: "secondary",
+  accept: "success",
+  decline: "danger",
+  opt_out: "secondary",
+  decision: "primary"
+};
+function replyButtonId(occurrenceId) {
+  return `${PREFIX}${REPLY_CODE}.o.${occurrenceId}`;
+}
+function modalId(occurrenceId) {
+  return `${PREFIX}${MODAL_CODE}.o.${occurrenceId}`;
+}
+function parseCustomId(customId) {
+  if (!customId.startsWith(PREFIX))
+    return null;
+  const rest = customId.slice(PREFIX.length);
+  const own = /^([rm])\.o\.([^.]+)$/.exec(rest);
+  if (own)
+    return own[1] === REPLY_CODE ? { kind: "reply-button", occurrenceId: own[2] } : { kind: "reply-modal", occurrenceId: own[2] };
+  return rest.length > 0 ? { kind: "ref", ref: rest } : null;
+}
+function hostButtons(message) {
+  const buttons = replyButtons(message).map((b) => ({
+    customId: `${PREFIX}${b.ref}`,
+    label: b.label.slice(0, 80),
+    style: STYLE[b.kind]
+  }));
+  const occurrenceId = message.ref?.occurrenceId ?? null;
+  if (occurrenceId === null)
+    return buttons.slice(0, MAX_BUTTONS);
+  return [...buttons.slice(0, MAX_BUTTONS - 1), { customId: replyButtonId(occurrenceId), label: "Reply", style: "secondary" }];
+}
+
+// plugins/tracker/src/notifier.ts
+var HOST_CANNOT_MESSAGE = "recipient cannot be messaged";
+var MAX_CONTENT = 2000;
+var UNCONFIRMED_MESSAGE_ID = "unconfirmed";
+var HOST_SNOWFLAKE = /^[0-9]{5,25}$/;
+var URL_OR_WRAPPED = /<(https?:\/\/[^\s<>]+)>|(https?:\/\/[^\s<>]+)/g;
+function wrapBareUrls(content) {
+  return content.replace(URL_OR_WRAPPED, (whole, wrapped, bare) => wrapped !== undefined ? whole : `<${bare}>`);
+}
+function isPreSendError(err) {
+  if (typeof err === "object" && err !== null && err.code === 10013)
+    return true;
+  const message = err instanceof Error ? err.message : String(err);
+  return message === "userId is not a valid id" || message === "message must be an object" || message === "content must be a string" || message === "content is empty" || message === "interactive buttons are not supported yet" || message === "Unknown User" || message.startsWith("content is longer than");
+}
+
+class RecipientUnreachableError extends Error {
+  userId;
+  name = "RecipientUnreachableError";
+  constructor(userId) {
+    super(`recipient ${userId} cannot be messaged (DMs closed, or the bot is blocked)`);
+    this.userId = userId;
+  }
+}
+
+class UndeliverableError extends Error {
+  name = "UndeliverableError";
+}
+var HOST_BUTTON_REFUSAL = /^(interactive buttons are not supported|buttons? (label|customId|customIds|style|must|is not valid|and links need|need this plugin))/;
+function isButtonRefusal(err) {
+  if (!(err instanceof Error) || err.code !== undefined)
+    return false;
+  return HOST_BUTTON_REFUSAL.test(err.message);
+}
+function toHostMessage(message) {
+  if (message.text.trim().length === 0)
+    return null;
+  let text = message.text;
+  let keep = text.length;
+  while (wrapBareUrls(text).length > MAX_CONTENT) {
+    keep -= Math.max(1, wrapBareUrls(text).length - MAX_CONTENT);
+    text = `${message.text.slice(0, Math.max(0, keep - 3))}...`;
+  }
+  return { content: text };
+}
+function createDmNotifier(d) {
+  return {
+    async sendDm(userId, message) {
+      const user = await d.store.getUser(userId);
+      if (!user)
+        throw new UndeliverableError(`no user ${userId}`);
+      const discordId = user.discordId;
+      if (!discordId || !HOST_SNOWFLAKE.test(discordId))
+        throw new UndeliverableError(`user ${userId} has no valid Discord id`);
+      const hostMessage = toHostMessage(message);
+      if (!hostMessage)
+        throw new UndeliverableError("the message has no text");
+      const occurrenceId = message.ref?.occurrenceId ?? null;
+      if (occurrenceId !== null) {
+        const existing = d.claims.get(occurrenceId, userId);
+        if (existing?.status === "sent")
+          return { messageId: existing.messageId || UNCONFIRMED_MESSAGE_ID };
+        if (existing && existing.status !== "failed") {
+          if (existing.status === "claimed") {
+            d.claims.settle(occurrenceId, userId, "unconfirmed", d.clock.now().toISOString(), { error: "claimed, never settled" });
+          }
+          reportUnconfirmed(d.claims, d.log, existing, d.clock.now().toISOString());
+          return { messageId: UNCONFIRMED_MESSAGE_ID };
+        }
+      }
+      if (d.health?.isPaused(userId))
+        throw new ExecutorUnavailableError(`delivery to ${userId} is paused`);
+      if (d.signal?.aborted)
+        throw new ExecutorUnavailableError("the tick was aborted before this send");
+      if (occurrenceId !== null) {
+        const at = d.clock.now().toISOString();
+        if (!d.claims.claim(occurrenceId, userId, discordId, at)) {
+          return { messageId: UNCONFIRMED_MESSAGE_ID };
+        }
+      }
+      try {
+        const buttons = hostButtons(message);
+        let delivery;
+        try {
+          delivery = await d.dm(discordId, buttons.length > 0 ? { ...hostMessage, buttons } : hostMessage);
+        } catch (err) {
+          if (buttons.length === 0 || !isButtonRefusal(err))
+            throw err;
+          d.log.warn(`DM sent without buttons: the host refused them (${err instanceof Error ? err.message : String(err)})`);
+          delivery = await d.dm(discordId, hostMessage);
+        }
+        d.health?.recordSuccess(userId);
+        if (occurrenceId !== null) {
+          d.claims.settle(occurrenceId, userId, "sent", d.clock.now().toISOString(), {
+            messageId: delivery.messageId,
+            channelId: delivery.channelId
+          });
+        }
+        return { messageId: delivery.messageId };
+      } catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        const unreachable = reason === HOST_CANNOT_MESSAGE;
+        const nothingSent = unreachable || isPreSendError(err);
+        if (occurrenceId !== null) {
+          d.claims.settle(occurrenceId, userId, nothingSent ? "failed" : "unconfirmed", d.clock.now().toISOString(), { error: reason });
+        }
+        if (unreachable) {
+          const counted = await d.health?.recordFailure(userId, reason, d.clock.now().toISOString());
+          if (counted?.paused)
+            d.log.warn(`paused delivery to ${userId}: ${counted.failures} DMs in a row could not be delivered`);
+          throw new RecipientUnreachableError(userId);
+        }
+        throw err;
+      }
+    }
+  };
+}
+function reportUnconfirmed(claims, log, claim, at) {
+  if (claim.reportedAt !== null)
+    return;
+  const what = claim.status === "claimed" ? `claimed ${claim.claimedAt}, never settled` : `unconfirmed since ${claim.claimedAt} (${claim.error ?? "no detail"})`;
+  log.warn(`delivery of ${claim.occurrenceId} to ${claim.userId} was ${what}; it will not be resent`);
+  claims.markReported(claim.occurrenceId, claim.userId, at);
+}
+
+// plugins/tracker/src/press.ts
+var CANNOT_SHARE = "can't be shared with: they have to be on this tracker's list, registered, a member of its server, and reachable by DM.";
+async function prepareShare(d, owner, taskId, target) {
+  const task = await visibleTask(d.store, { userId: owner.id, admin: false }, taskId.trim());
+  if (!task || task.ownerId !== owner.id)
+    return NO_SUCH_TASK;
+  if (task.status !== "active")
+    return `That task is ${task.status}.`;
+  const person = await d.store.findUserByDiscordId(target.discordId);
+  const refused = !person || !d.admissions.isRegistered(person.id) || target.membership === "not-member" || target.membership === "unknown" || d.health.isPaused(person.id);
+  if (refused)
+    return `<@${target.discordId}> ${CANNOT_SHARE}`;
+  const now = d.clock.now();
+  const result = await invite(d.store, { userId: owner.id, admin: false }, task, person.id, now);
+  if (!result.ok) {
+    if (result.reason === "blocked") {
+      const until = result.block?.expiresAt;
+      return until ? `<@${target.discordId}> declined an earlier invitation from you; you can invite them again after ${new Date(until).toISOString().slice(0, 16).replace("T", " ")} UTC.` : `<@${target.discordId}> declined your invitations twice; only an admin can lift that.`;
+    }
+    return `<@${target.discordId}> ${CANNOT_SHARE}`;
+  }
+  return { taskId: task.id, targetId: person.id, targetDiscordId: target.discordId, message: inviteMessage(task, owner, person, now) };
+}
+async function sendShare(d, p) {
+  try {
+    await d.notifier.sendDm(p.targetId, p.message);
+    return null;
+  } catch (err) {
+    return err ?? new Error("failed");
+  }
+}
+async function finishShare(d, p, err) {
+  if (err === null)
+    return `Invited <@${p.targetDiscordId}> to \`${p.taskId}\`. They get a DM to accept or decline.`;
+  await d.store.removeRecipient(p.taskId, p.targetId);
+  await d.store.addTaskEvent({
+    taskId: p.taskId,
+    actorId: null,
+    kind: "recipient_removed",
+    detail: `${p.targetId}: the invitation could not be delivered`,
+    at: d.clock.now().toISOString()
+  });
+  if (err instanceof RecipientUnreachableError) {
+    return `I could not DM <@${p.targetDiscordId}> (their DMs are closed, or they blocked the bot), so the invitation is withdrawn.`;
+  }
+  d.log.error(`invitation DM for ${p.taskId} to ${p.targetId} failed`, err);
+  return "The invitation could not be sent; try again in a minute.";
+}
+var CONSENT_TEXT = {
+  accept: "Accepted: you will get this task's results, and each one has a button to stop them.",
+  decline: "Declined. You will not get this task's results.",
+  opt_out: "You will not get this task's messages any more."
+};
+async function press(d, user, ref) {
+  const verdict = await replyForRef(d.store, ref, user.id);
+  if (!verdict.ok)
+    return { ok: false, error: verdict.error };
+  const { input } = verdict;
+  try {
+    const outcome = await replyLanes(d).reply(input);
+    const consent = CONSENT_TEXT[input.kind];
+    if (consent)
+      return { ok: true, status: consent, keepReplyFor: null };
+    const status = input.kind === "decision" ? `Recorded: ${String(input.payload?.choice ?? "")}.` : answeredText(input.kind, outcome?.snoozeUntil ?? null, user, d.clock.now());
+    return { ok: true, status, keepReplyFor: input.occurrenceId };
+  } catch (err) {
+    if (err instanceof ReplyRefusedError)
+      return { ok: false, error: err.message };
+    throw err;
+  }
+}
+async function replyRefusal(d, user, occurrenceId) {
+  const occurrence = await d.store.getOccurrence(occurrenceId);
+  if (!occurrence)
+    return "That run no longer exists.";
+  const task = await d.store.getTask(occurrence.taskId);
+  if (!task)
+    return "That task no longer exists.";
+  if (task.ownerId === user.id)
+    return null;
+  const mine = (await d.store.listRecipients(task.id)).find((r) => r.userId === user.id);
+  return mine?.state === "accepted" ? null : "That is not yours to reply to.";
+}
+async function submitReply(d, user, occurrenceId, text) {
+  const refusal = await replyRefusal(d, user, occurrenceId);
+  if (refusal)
+    return refusal;
+  const trimmed = text.trim();
+  if (trimmed.length === 0)
+    return "That reply was empty.";
+  const occurrence = await d.store.getOccurrence(occurrenceId);
+  if (!occurrence)
+    return "That run no longer exists.";
+  await replyLanes(d).reply({
+    taskId: occurrence.taskId,
+    occurrenceId,
+    userId: user.id,
+    kind: "text",
+    payload: { text: clip(trimmed, MAX_REPLY_TEXT) }
+  });
+  return "Reply kept with the task's history.";
+}
+function reducesContact(ref) {
+  const kind = decodeReplyRef(ref)?.kind;
+  return kind === "decline" || kind === "opt_out";
+}
+
+// plugins/tracker/src/interactions.ts
+function replyRow(occurrenceId) {
+  return new ActionRowBuilder().addComponents(new ButtonBuilder().setCustomId(replyButtonId(occurrenceId)).setLabel("Reply").setStyle(ButtonStyle.Secondary));
+}
+function replyModal(occurrenceId) {
+  return new ModalBuilder().setCustomId(modalId(occurrenceId)).setTitle("Reply").addComponents(new ActionRowBuilder().addComponents(new TextInputBuilder().setCustomId(REPLY_FIELD).setLabel("Your reply").setStyle(TextInputStyle.Paragraph).setRequired(true).setMaxLength(MAX_REPLY_TEXT)));
+}
+function createInteractionHandler(c) {
+  const membershipOf = (i) => c.membershipOf(i, i.user.id);
+  async function onButton(interaction, d, ref) {
+    await interaction.deferUpdate();
+    const gated = !reducesContact(ref);
+    const membership = gated ? await membershipOf(interaction) : "not-checked";
+    const result = await c.queue(async () => {
+      if (!gated) {
+        const person = await d.store.findUserByDiscordId(interaction.user.id);
+        if (!person)
+          return { notice: null, pressed: { ok: false, error: "That is not yours to answer." } };
+        return { notice: null, pressed: await press(d, person, ref) };
+      }
+      const entry = await enter(d, interaction.user.id, membership, "registered");
+      if (!entry.ok)
+        return { notice: null, pressed: { ok: false, error: entry.content } };
+      return { notice: entry.notice, pressed: await press(d, entry.user, ref) };
+    });
+    if (result.pressed.ok) {
+      const { status, keepReplyFor } = result.pressed;
+      await interaction.editReply({
+        content: clip(`${interaction.message.content}
+
+-- ${status}`),
+        components: keepReplyFor ? [replyRow(keepReplyFor)] : [],
+        ...NO_MENTIONS
+      });
+    } else {
+      await interaction.followUp({ content: result.pressed.error, ...EPHEMERAL });
+    }
+    if (result.notice)
+      await interaction.followUp({ content: result.notice, ...EPHEMERAL });
+  }
+  async function onReplyButton(interaction, d, occurrenceId) {
+    const person = await d.store.findUserByDiscordId(interaction.user.id);
+    const registered = person ? d.admissions.isRegistered(person.id) : false;
+    const refusal = decideAccess({ membership: "not-checked", person, registered, need: "registered" }) ?? (person ? await replyRefusal(d, person, occurrenceId) : NOT_ADMITTED);
+    if (refusal) {
+      await interaction.reply({ content: refusal, ...EPHEMERAL });
+      return;
+    }
+    await interaction.showModal(replyModal(occurrenceId));
+  }
+  async function onReplyModal(interaction, d, occurrenceId) {
+    await interaction.deferReply(EPHEMERAL);
+    const membership = await membershipOf(interaction);
+    const text = interaction.fields.getTextInputValue(REPLY_FIELD);
+    const content = await c.queue(async () => {
+      const entry = await enter(d, interaction.user.id, membership, "registered");
+      if (!entry.ok)
+        return entry.content;
+      const body = await submitReply(d, entry.user, occurrenceId, text);
+      return entry.notice ? `${entry.notice}
+
+${body}` : body;
+    });
+    await interaction.editReply({ content: clip(content), ...NO_MENTIONS });
+  }
+  async function failed(interaction) {
+    try {
+      if (interaction.deferred || interaction.replied)
+        await interaction.followUp({ content: FAILED, ...EPHEMERAL });
+      else
+        await interaction.reply({ content: FAILED, ...EPHEMERAL });
+    } catch (err) {
+      c.log.warn(`could not tell the presser of ${interaction.customId} that it failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return async (interaction) => {
+    const parsed = parseCustomId(interaction.customId);
+    const d = c.deps();
+    if (!parsed || !d) {
+      await interaction.reply({ content: d ? "That button is not one of mine." : STARTING, ...EPHEMERAL });
+      return;
+    }
+    try {
+      if (parsed.kind === "reply-modal" && interaction.isModalSubmit())
+        return await onReplyModal(interaction, d, parsed.occurrenceId);
+      if (interaction.isMessageComponent() && parsed.kind === "reply-button")
+        return await onReplyButton(interaction, d, parsed.occurrenceId);
+      if (interaction.isMessageComponent() && parsed.kind === "ref")
+        return await onButton(interaction, d, parsed.ref);
+      await interaction.reply({ content: "That is not one of mine.", ...EPHEMERAL });
+    } catch (err) {
+      c.log.error(`interaction ${interaction.customId} failed`, err);
+      await failed(interaction);
+    }
+  };
+}
+
+// plugins/tracker/src/discord.ts
+function displayName(user) {
+  return user.globalName ?? user.username;
+}
+function createSurface(w) {
+  const ctx = {
+    deps: w.deps,
+    queue: serial(),
+    membershipOf: (interaction, discordId) => w.membership ? w.membership(interaction, discordId) : lookupMembership(interaction, w.guildId, discordId, w.log),
+    log: w.log
+  };
+  const membershipOf = (interaction, discordId) => ctx.membershipOf(interaction, discordId);
+  async function run(interaction, need, act, pre = async () => {
+    return;
+  }) {
+    await interaction.deferReply(EPHEMERAL);
+    let content;
+    try {
+      const d = w.deps();
+      if (!d)
+        content = STARTING;
+      else {
+        const membership = await membershipOf(interaction, interaction.user.id);
+        const before = await pre();
+        const first = await ctx.queue(async () => {
+          const entry = await enter(d, interaction.user.id, membership, need);
+          if (!entry.ok)
+            return { notice: null, step: entry.content };
+          return { notice: entry.notice, step: await act(d, entry.user, before) };
+        });
+        let body;
+        if (typeof first.step === "string")
+          body = first.step;
+        else {
+          const { outside, finish } = first.step;
+          const result = await outside();
+          body = await ctx.queue(() => finish(result));
+        }
+        content = clip(first.notice ? `${first.notice}
+
+${body}` : body);
+      }
+    } catch (err) {
+      w.log.error(`/${interaction.commandName} failed`, err);
+      content = FAILED;
+    }
+    await interaction.editReply({ content, ...NO_MENTIONS });
+  }
+  const commands = [
+    {
+      name: "allow",
+      build: (b) => b.setDescription("Admin: let a person use the tracker").addUserOption((o) => o.setName("user").setDescription("Who to let in").setRequired(true)),
+      handle: (interaction) => {
+        const target = interaction.options.getUser("user", true);
+        return run(interaction, "admin", (d, admin, membership) => allowPerson(d, admin, { discordId: target.id, bot: target.bot, membership }), () => membershipOf(interaction, target.id));
+      }
+    },
+    {
+      name: "register",
+      build: (b) => b.setDescription("Sign up for reminders, or change your hour and time zone").addIntegerOption((o) => o.setName("hour").setDescription("Hour (0-23) a reminder without a time arrives; default 9").setMinValue(0).setMaxValue(23)).addStringOption((o) => o.setName("zone").setDescription("Your time zone, e.g. America/New_York (the default)").setMaxLength(64)),
+      handle: (interaction) => run(interaction, "admitted", (d, user) => {
+        const hour = interaction.options.getInteger("hour");
+        const zone = interaction.options.getString("zone");
+        return registerPerson(d, user, {
+          displayName: displayName(interaction.user),
+          ...hour !== null ? { hour } : {},
+          ...zone !== null ? { zone: zone.trim() } : {}
+        });
+      })
+    },
+    {
+      name: "remind",
+      build: (b) => b.setDescription("Set a reminder, sent to you by DM").addStringOption((o) => o.setName("text").setDescription("What to remind you of").setRequired(true).setMaxLength(MAX_REMINDER_TEXT)).addStringOption((o) => o.setName("when").setDescription('When: "in 20 minutes", "tomorrow 9am", "fri at 17:30"').setMaxLength(100)).addStringOption((o) => o.setName("repeat").setDescription("Repeat it (default: once)").addChoices({ name: "once", value: "none" }, { name: "daily", value: "day" }, { name: "weekly", value: "week" }, { name: "monthly", value: "month" })),
+      handle: (interaction) => run(interaction, "registered", (d, user) => {
+        const when = interaction.options.getString("when");
+        return remind(d, user, {
+          text: interaction.options.getString("text", true),
+          ...when !== null ? { when } : {},
+          repeat: interaction.options.getString("repeat") ?? "none"
+        });
+      })
+    },
+    {
+      name: "tasks",
+      build: (b) => b.setDescription("List your tasks and when each is next due"),
+      handle: (interaction) => run(interaction, "registered", (d, user) => listTasks(d, user))
+    },
+    {
+      name: "task",
+      build: (b) => b.setDescription("Answer, look back at, or share one of your tasks").addSubcommand((s) => s.setName("done").setDescription("Mark the task's latest reminder done").addStringOption((o) => o.setName("task").setDescription("The task id from /tasks, e.g. t3").setRequired(true).setMaxLength(24))).addSubcommand((s) => s.setName("snooze").setDescription("Snooze the task's latest reminder (default: an hour)").addStringOption((o) => o.setName("task").setDescription("The task id from /tasks, e.g. t3").setRequired(true).setMaxLength(24)).addStringOption((o) => o.setName("until").setDescription('Until when: "in 2h", "tomorrow 9am"').setMaxLength(100))).addSubcommand((s) => s.setName("history").setDescription("Every run of the task, how it was answered, and its changes").addStringOption((o) => o.setName("task").setDescription("The task id from /tasks, e.g. t3").setRequired(true).setMaxLength(24))).addSubcommand((s) => s.setName("resume").setDescription("Resume a task paused because someone could not be DMed, without them").addStringOption((o) => o.setName("task").setDescription("The task id from /tasks, e.g. t3").setRequired(true).setMaxLength(24))).addSubcommand((s) => s.setName("share").setDescription("Ask someone to receive this task's messages too").addStringOption((o) => o.setName("task").setDescription("The task id from /tasks, e.g. t3").setRequired(true).setMaxLength(24)).addUserOption((o) => o.setName("user").setDescription("Who to invite").setRequired(true))),
+      handle: (interaction) => {
+        const sub = interaction.options.getSubcommand();
+        const taskId = interaction.options.getString("task", true);
+        const shareWith = sub === "share" ? interaction.options.getUser("user", true) : null;
+        return run(interaction, "registered", async (d, user, membership) => {
+          switch (sub) {
+            case "done":
+              return answerLatest(d, user, { taskId, kind: "done" });
+            case "snooze": {
+              const until = interaction.options.getString("until");
+              return answerLatest(d, user, { taskId, kind: "snooze", ...until !== null ? { until } : {} });
+            }
+            case "history":
+              return taskHistory(d, user, taskId);
+            case "resume":
+              return resumeTask(d, user, taskId);
+            case "share": {
+              const pending = await prepareShare(d, user, taskId, { discordId: shareWith?.id ?? "", membership: membership ?? "unknown" });
+              if (typeof pending === "string")
+                return pending;
+              return { outside: () => sendShare(d, pending), finish: (err) => finishShare(d, pending, err) };
+            }
+            default:
+              return "Unknown subcommand.";
+          }
+        }, async () => shareWith ? membershipOf(interaction, shareWith.id) : null);
+      }
+    },
+    {
+      name: "settings",
+      build: (b) => b.setDescription("Your tracker settings").addSubcommand((s) => s.setName("hour").setDescription("The hour (0-23) a reminder without a time reaches you").addIntegerOption((o) => o.setName("hour").setDescription("0-23, in your time zone").setRequired(true).setMinValue(0).setMaxValue(23))),
+      handle: (interaction) => run(interaction, "registered", (d, user) => setHour(d, user, interaction.options.getInteger("hour", true)))
+    }
+  ];
+  return { commands, interactions: createInteractionHandler(ctx) };
+}
+
+// plugins/tracker/src/health.ts
+var STALE_AFTER_MS = 3 * 60000;
+function decideHealth(state, now) {
+  const lastTickAt = state.lastTickAt?.toISOString() ?? null;
+  if (state.activatedAt === null)
+    return { status: 503, body: { status: "inactive", lastTickAt } };
+  if (state.blocked !== null)
+    return { status: 503, body: { status: "blocked", lastTickAt, detail: state.blocked } };
+  const since = state.lastTickAt ?? state.activatedAt;
+  const fresh = now.getTime() - since.getTime() <= STALE_AFTER_MS;
+  if (state.lastTickAt === null)
+    return fresh ? { status: 200, body: { status: "starting", lastTickAt } } : { status: 503, body: { status: "stale", lastTickAt } };
+  return fresh ? { status: 200, body: { status: "ok", lastTickAt } } : { status: 503, body: { status: "stale", lastTickAt } };
+}
+function healthResponse(health) {
+  return new Response(JSON.stringify(health.body), {
+    status: health.status,
+    headers: { "content-type": "application/json", "cache-control": "no-store" }
+  });
+}
+
+// plugins/tracker/src/notify-lane.ts
+function laneStore(store) {
+  const view = Object.create(store);
+  view.listOccurrences = async (filter = {}) => {
+    const found = await store.listOccurrences(filter);
+    if (filter.status !== "queued" || filter.dueBefore === undefined)
+      return found;
+    const kept = [];
+    for (const o of found) {
+      if ((await store.getTask(o.taskId))?.status === "active")
+        kept.push(o);
+    }
+    return kept;
+  };
+  return view;
+}
+async function runNotifyTick(d, signal) {
+  if (typeof d.dm !== "function")
+    return { kind: "no-dm" };
+  if (signal?.aborted)
+    return { kind: "aborted" };
+  const store = laneStore(d.store);
+  const notifier = createDmNotifier({
+    store,
+    claims: d.claims,
+    dm: d.dm,
+    clock: d.clock,
+    log: d.log,
+    ...signal ? { signal } : {},
+    ...d.health ? { health: d.health } : {}
+  });
+  const lanes = new Lanes({ store, clock: d.clock, types: d.types, notifier });
+  const result = await lanes.tickNotify();
+  return signal?.aborted ? { kind: "aborted" } : { kind: "ran", result };
+}
+
+// plugins/tracker/src/schema.ts
+import { Database } from "bun:sqlite";
+var MIGRATIONS = [
+  `
+  CREATE TABLE users (
+    seq INTEGER PRIMARY KEY AUTOINCREMENT,
+    discord_id TEXT,
+    usr_subject TEXT,
+    display_name TEXT,
+    time_zone TEXT NOT NULL,
+    preferred_hour INTEGER NOT NULL,
+    admin INTEGER NOT NULL,
+    created_at TEXT NOT NULL
+  );
+  CREATE UNIQUE INDEX users_discord_id ON users (discord_id) WHERE discord_id IS NOT NULL;
+  CREATE INDEX users_usr_subject ON users (usr_subject);
+
+  CREATE TABLE tasks (
+    seq INTEGER PRIMARY KEY AUTOINCREMENT,
+    owner_id TEXT NOT NULL,
+    type TEXT NOT NULL,
+    title TEXT NOT NULL,
+    config TEXT NOT NULL,
+    state TEXT NOT NULL,
+    schedule TEXT NOT NULL,
+    lane TEXT NOT NULL,
+    capabilities TEXT NOT NULL,
+    status TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+  CREATE INDEX tasks_owner ON tasks (owner_id);
+
+  CREATE TABLE task_recipients (
+    seq INTEGER PRIMARY KEY AUTOINCREMENT,
+    task_id TEXT NOT NULL,
+    user_id TEXT NOT NULL,
+    state TEXT NOT NULL,
+    at TEXT NOT NULL,
+    UNIQUE (task_id, user_id)
+  );
+
+  CREATE TABLE invite_blocks (
+    seq INTEGER PRIMARY KEY AUTOINCREMENT,
+    owner_id TEXT NOT NULL,
+    recipient_id TEXT NOT NULL,
+    expires_at TEXT,
+    decline_reply_id TEXT,
+    lifted_by TEXT,
+    lifted_at TEXT,
+    created_at TEXT NOT NULL
+  );
+  CREATE INDEX invite_blocks_pair ON invite_blocks (owner_id, recipient_id);
+
+  CREATE TABLE occurrences (
+    seq INTEGER PRIMARY KEY AUTOINCREMENT,
+    task_id TEXT NOT NULL,
+    lane TEXT NOT NULL,
+    due_at TEXT NOT NULL,
+    started_at TEXT,
+    finished_at TEXT,
+    status TEXT NOT NULL,
+    late INTEGER NOT NULL,
+    dedupe_key TEXT NOT NULL UNIQUE,
+    summary TEXT,
+    cost_usd REAL,
+    error TEXT,
+    created_at TEXT NOT NULL
+  );
+  CREATE INDEX occurrences_due ON occurrences (status, lane, due_at);
+  CREATE INDEX occurrences_task ON occurrences (task_id);
+
+  CREATE TABLE events (
+    seq INTEGER PRIMARY KEY AUTOINCREMENT,
+    occurrence_id TEXT NOT NULL,
+    agent TEXT NOT NULL,
+    type TEXT NOT NULL,
+    text TEXT NOT NULL,
+    at TEXT NOT NULL
+  );
+  CREATE INDEX events_occurrence ON events (occurrence_id, seq);
+
+  CREATE TABLE task_events (
+    seq INTEGER PRIMARY KEY AUTOINCREMENT,
+    task_id TEXT NOT NULL,
+    actor_id TEXT,
+    kind TEXT NOT NULL,
+    detail TEXT NOT NULL,
+    at TEXT NOT NULL
+  );
+  CREATE INDEX task_events_task ON task_events (task_id, seq);
+
+  CREATE TABLE replies (
+    seq INTEGER PRIMARY KEY AUTOINCREMENT,
+    occurrence_id TEXT,
+    task_id TEXT NOT NULL,
+    user_id TEXT NOT NULL,
+    kind TEXT NOT NULL,
+    payload TEXT NOT NULL,
+    at TEXT NOT NULL
+  );
+  CREATE INDEX replies_task ON replies (task_id, seq);
+
+  CREATE TABLE series (
+    seq INTEGER PRIMARY KEY AUTOINCREMENT,
+    task_id TEXT NOT NULL,
+    at TEXT NOT NULL,
+    value REAL NOT NULL,
+    unit TEXT,
+    note TEXT
+  );
+  CREATE INDEX series_task ON series (task_id, at);
+
+  CREATE TABLE delivery_claims (
+    occurrence_id TEXT NOT NULL,
+    user_id TEXT NOT NULL,
+    discord_id TEXT NOT NULL,
+    status TEXT NOT NULL,
+    message_id TEXT,
+    channel_id TEXT,
+    error TEXT,
+    claimed_at TEXT NOT NULL,
+    settled_at TEXT,
+    reported_at TEXT,
+    PRIMARY KEY (occurrence_id, user_id)
+  );
+  `,
+  `
+  CREATE TABLE admissions (
+    user_id TEXT PRIMARY KEY,
+    admitted_by TEXT,
+    admitted_at TEXT NOT NULL,
+    registered_at TEXT
+  );
+  INSERT INTO admissions (user_id, admitted_by, admitted_at, registered_at)
+    SELECT 'u' || seq, NULL, created_at, NULL FROM users;
+
+  CREATE TABLE delivery_health (
+    user_id TEXT PRIMARY KEY,
+    failures INTEGER NOT NULL,
+    last_error TEXT,
+    last_failed_at TEXT,
+    paused_at TEXT
+  );
+
+  CREATE TABLE delivery_pauses (
+    task_id TEXT NOT NULL,
+    user_id TEXT NOT NULL,
+    at TEXT NOT NULL,
+    PRIMARY KEY (task_id, user_id)
+  );
+  `
+];
+function migrate(db) {
+  const current = db.query("PRAGMA user_version").get().user_version;
+  if (current > MIGRATIONS.length) {
+    throw new Error(`tracker database is at schema ${current}, newer than this plugin knows (${MIGRATIONS.length})`);
+  }
+  for (let version = current;version < MIGRATIONS.length; version++) {
+    db.transaction(() => {
+      db.exec(MIGRATIONS[version]);
+      db.exec(`PRAGMA user_version = ${version + 1}`);
+    })();
+  }
+}
+function openDatabase(path) {
+  const db = new Database(path, { create: true });
+  if (path !== ":memory:")
+    db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA busy_timeout = 5000");
+  migrate(db);
+  return db;
+}
+
+// plugins/tracker/src/store.ts
+var DEFAULT_TIME_ZONE2 = "UTC";
+var DEFAULT_PREFERRED_HOUR2 = 9;
+function idOf(prefix, seq) {
+  return `${prefix}${Number(seq)}`;
+}
+function seqOf(prefix, id) {
+  if (!id.startsWith(prefix))
+    return null;
+  const rest = id.slice(prefix.length);
+  return /^[1-9][0-9]*$/.test(rest) ? Number(rest) : null;
+}
+function json(value) {
+  return JSON.stringify(value ?? null);
+}
+function parse(text) {
+  return JSON.parse(String(text));
+}
+function str(value) {
+  return value === null || value === undefined ? null : String(value);
+}
+function toUser(r) {
+  return {
+    id: idOf("u", r.seq),
+    discordId: str(r.discord_id),
+    usrSubject: str(r.usr_subject),
+    displayName: str(r.display_name),
+    timeZone: String(r.time_zone),
+    preferredHour: Number(r.preferred_hour),
+    admin: Number(r.admin) === 1,
+    createdAt: String(r.created_at)
+  };
+}
+function toTask(r) {
+  return {
+    id: idOf("t", r.seq),
+    ownerId: String(r.owner_id),
+    type: String(r.type),
+    title: String(r.title),
+    config: parse(r.config),
+    state: parse(r.state),
+    schedule: parse(r.schedule),
+    lane: String(r.lane),
+    capabilities: parse(r.capabilities),
+    status: String(r.status),
+    createdAt: String(r.created_at),
+    updatedAt: String(r.updated_at)
+  };
+}
+function toRecipient(r) {
+  return { taskId: String(r.task_id), userId: String(r.user_id), state: String(r.state), at: String(r.at) };
+}
+function toBlock(r) {
+  return {
+    id: idOf("b", r.seq),
+    ownerId: String(r.owner_id),
+    recipientId: String(r.recipient_id),
+    expiresAt: str(r.expires_at),
+    declineReplyId: str(r.decline_reply_id),
+    liftedBy: str(r.lifted_by),
+    liftedAt: str(r.lifted_at),
+    createdAt: String(r.created_at)
+  };
+}
+function toOccurrence(r) {
+  return {
+    id: idOf("o", r.seq),
+    taskId: String(r.task_id),
+    lane: String(r.lane),
+    dueAt: String(r.due_at),
+    startedAt: str(r.started_at),
+    finishedAt: str(r.finished_at),
+    status: String(r.status),
+    late: Number(r.late) === 1,
+    dedupeKey: String(r.dedupe_key),
+    summary: str(r.summary),
+    costUsd: r.cost_usd === null || r.cost_usd === undefined ? null : Number(r.cost_usd),
+    error: str(r.error),
+    createdAt: String(r.created_at)
+  };
+}
+function toEvent(r) {
+  return {
+    id: idOf("e", r.seq),
+    occurrenceId: String(r.occurrence_id),
+    agent: String(r.agent),
+    type: String(r.type),
+    text: String(r.text),
+    at: String(r.at)
+  };
+}
+function toTaskEvent(r) {
+  return {
+    id: idOf("h", r.seq),
+    taskId: String(r.task_id),
+    actorId: str(r.actor_id),
+    kind: String(r.kind),
+    detail: String(r.detail),
+    at: String(r.at)
+  };
+}
+function toReply(r) {
+  return {
+    id: idOf("r", r.seq),
+    occurrenceId: str(r.occurrence_id),
+    taskId: String(r.task_id),
+    userId: String(r.user_id),
+    kind: String(r.kind),
+    payload: parse(r.payload),
+    at: String(r.at)
+  };
+}
+function toPoint(r) {
+  return { id: idOf("s", r.seq), taskId: String(r.task_id), at: String(r.at), value: Number(r.value), unit: str(r.unit), note: str(r.note) };
+}
+
+class SqliteStore {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  one(sql, ...params) {
+    return this.db.query(sql).get(...params) ?? null;
+  }
+  all(sql, ...params) {
+    return this.db.query(sql).all(...params);
+  }
+  run(sql, ...params) {
+    return this.db.query(sql).run(...params);
+  }
+  byId(table, prefix, id) {
+    const seq = seqOf(prefix, id);
+    return seq === null ? null : this.one(`SELECT * FROM ${table} WHERE seq = ?`, seq);
+  }
+  mustGet(table, prefix, id, what) {
+    const row = this.byId(table, prefix, id);
+    if (!row)
+      throw new Error(`no ${what} ${id}`);
+    return row;
+  }
+  async getUser(id) {
+    const r = this.byId("users", "u", id);
+    return r ? toUser(r) : null;
+  }
+  async findUserByDiscordId(discordId) {
+    const r = this.one("SELECT * FROM users WHERE discord_id = ? ORDER BY seq LIMIT 1", discordId);
+    return r ? toUser(r) : null;
+  }
+  async findUserBySubject(usrSubject) {
+    const r = this.one("SELECT * FROM users WHERE usr_subject = ? ORDER BY seq LIMIT 1", usrSubject);
+    return r ? toUser(r) : null;
+  }
+  async createUser(u) {
+    const { lastInsertRowid } = this.run(`INSERT INTO users (discord_id, usr_subject, display_name, time_zone, preferred_hour, admin, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`, u.discordId ?? null, u.usrSubject ?? null, u.displayName ?? null, u.timeZone ?? DEFAULT_TIME_ZONE2, u.preferredHour ?? DEFAULT_PREFERRED_HOUR2, u.admin ? 1 : 0, u.at);
+    return toUser(this.mustGet("users", "u", idOf("u", lastInsertRowid), "user"));
+  }
+  async updateUser(id, patch) {
+    const cur = toUser(this.mustGet("users", "u", id, "user"));
+    const next = {
+      ...cur,
+      ...patch.discordId !== undefined ? { discordId: patch.discordId } : {},
+      ...patch.usrSubject !== undefined ? { usrSubject: patch.usrSubject } : {},
+      ...patch.displayName !== undefined ? { displayName: patch.displayName } : {},
+      ...patch.timeZone !== undefined ? { timeZone: patch.timeZone } : {},
+      ...patch.preferredHour !== undefined ? { preferredHour: patch.preferredHour } : {},
+      ...patch.admin !== undefined ? { admin: patch.admin } : {}
+    };
+    this.run(`UPDATE users SET discord_id = ?, usr_subject = ?, display_name = ?, time_zone = ?, preferred_hour = ?, admin = ?
+       WHERE seq = ?`, next.discordId, next.usrSubject, next.displayName, next.timeZone, next.preferredHour, next.admin ? 1 : 0, seqOf("u", id));
+    return toUser(this.mustGet("users", "u", id, "user"));
+  }
+  async createTask(t) {
+    const { lastInsertRowid } = this.run(`INSERT INTO tasks (owner_id, type, title, config, state, schedule, lane, capabilities, status, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'active', ?, ?)`, t.ownerId, t.type, t.title, json(t.config), json(t.state), json(t.schedule), t.lane, json(t.capabilities), t.at, t.at);
+    return toTask(this.mustGet("tasks", "t", idOf("t", lastInsertRowid), "task"));
+  }
+  async getTask(id) {
+    const r = this.byId("tasks", "t", id);
+    return r ? toTask(r) : null;
+  }
+  async listTasks(filter = {}) {
+    const where = [];
+    const params = [];
+    if (filter.ownerId !== undefined)
+      where.push("owner_id = ?"), params.push(filter.ownerId);
+    if (filter.status !== undefined)
+      where.push("status = ?"), params.push(filter.status);
+    if (filter.type !== undefined)
+      where.push("type = ?"), params.push(filter.type);
+    const clause = where.length > 0 ? `WHERE ${where.join(" AND ")}` : "";
+    return this.all(`SELECT * FROM tasks ${clause} ORDER BY seq`, ...params).map(toTask);
+  }
+  async updateTask(id, patch) {
+    const cur = toTask(this.mustGet("tasks", "t", id, "task"));
+    const next = {
+      ...cur,
+      updatedAt: patch.at,
+      ...patch.title !== undefined ? { title: patch.title } : {},
+      ...patch.config !== undefined ? { config: patch.config } : {},
+      ...patch.state !== undefined ? { state: patch.state } : {},
+      ...patch.schedule !== undefined ? { schedule: patch.schedule } : {},
+      ...patch.capabilities !== undefined ? { capabilities: patch.capabilities } : {},
+      ...patch.status !== undefined ? { status: patch.status } : {}
+    };
+    this.run(`UPDATE tasks SET title = ?, config = ?, state = ?, schedule = ?, capabilities = ?, status = ?, updated_at = ?
+       WHERE seq = ?`, next.title, json(next.config), json(next.state), json(next.schedule), json(next.capabilities), next.status, next.updatedAt, seqOf("t", id));
+    return toTask(this.mustGet("tasks", "t", id, "task"));
+  }
+  async listRecipients(taskId) {
+    return this.all("SELECT * FROM task_recipients WHERE task_id = ? ORDER BY seq", taskId).map(toRecipient);
+  }
+  async setRecipient(taskId, userId, state, at) {
+    this.run(`INSERT INTO task_recipients (task_id, user_id, state, at) VALUES (?, ?, ?, ?)
+       ON CONFLICT (task_id, user_id) DO UPDATE SET state = excluded.state, at = excluded.at`, taskId, userId, state, at);
+    return { taskId, userId, state, at };
+  }
+  async removeRecipient(taskId, userId) {
+    this.run("DELETE FROM task_recipients WHERE task_id = ? AND user_id = ?", taskId, userId);
+  }
+  async listBlocks(ownerId, recipientId) {
+    return this.all("SELECT * FROM invite_blocks WHERE owner_id = ? AND recipient_id = ? ORDER BY seq", ownerId, recipientId).map(toBlock);
+  }
+  async getBlock(id) {
+    const r = this.byId("invite_blocks", "b", id);
+    return r ? toBlock(r) : null;
+  }
+  async createBlock(b) {
+    const { lastInsertRowid } = this.run("INSERT INTO invite_blocks (owner_id, recipient_id, expires_at, decline_reply_id, created_at) VALUES (?, ?, ?, ?, ?)", b.ownerId, b.recipientId, b.expiresAt, b.declineReplyId, b.at);
+    return toBlock(this.mustGet("invite_blocks", "b", idOf("b", lastInsertRowid), "block"));
+  }
+  async liftBlock(id, adminId, at) {
+    this.mustGet("invite_blocks", "b", id, "block");
+    this.run("UPDATE invite_blocks SET lifted_by = ?, lifted_at = ? WHERE seq = ?", adminId, at, seqOf("b", id));
+    return toBlock(this.mustGet("invite_blocks", "b", id, "block"));
+  }
+  async createOccurrence(o) {
+    const { changes, lastInsertRowid } = this.run(`INSERT INTO occurrences (task_id, lane, due_at, status, late, dedupe_key, created_at)
+       VALUES (?, ?, ?, 'queued', 0, ?, ?)
+       ON CONFLICT (dedupe_key) DO NOTHING`, o.taskId, o.lane, o.dueAt, o.dedupeKey, o.at);
+    if (changes === 0)
+      return null;
+    return toOccurrence(this.mustGet("occurrences", "o", idOf("o", lastInsertRowid), "occurrence"));
+  }
+  async getOccurrence(id) {
+    const r = this.byId("occurrences", "o", id);
+    return r ? toOccurrence(r) : null;
+  }
+  async listOccurrences(filter = {}) {
+    const where = [];
+    const params = [];
+    if (filter.taskId !== undefined)
+      where.push("task_id = ?"), params.push(filter.taskId);
+    if (filter.lane !== undefined)
+      where.push("lane = ?"), params.push(filter.lane);
+    if (filter.status !== undefined)
+      where.push("status = ?"), params.push(filter.status);
+    if (filter.dueBefore !== undefined)
+      where.push("due_at <= ?"), params.push(filter.dueBefore);
+    const clause = where.length > 0 ? `WHERE ${where.join(" AND ")}` : "";
+    return this.all(`SELECT * FROM occurrences ${clause} ORDER BY due_at, created_at, seq`, ...params).map(toOccurrence);
+  }
+  async updateOccurrence(id, patch) {
+    const cur = toOccurrence(this.mustGet("occurrences", "o", id, "occurrence"));
+    const next = {
+      ...cur,
+      ...patch.status !== undefined ? { status: patch.status } : {},
+      ...patch.startedAt !== undefined ? { startedAt: patch.startedAt } : {},
+      ...patch.finishedAt !== undefined ? { finishedAt: patch.finishedAt } : {},
+      ...patch.late !== undefined ? { late: patch.late } : {},
+      ...patch.summary !== undefined ? { summary: patch.summary } : {},
+      ...patch.costUsd !== undefined ? { costUsd: patch.costUsd } : {},
+      ...patch.error !== undefined ? { error: patch.error } : {}
+    };
+    this.run(`UPDATE occurrences SET status = ?, started_at = ?, finished_at = ?, late = ?, summary = ?, cost_usd = ?, error = ?
+       WHERE seq = ?`, next.status, next.startedAt, next.finishedAt, next.late ? 1 : 0, next.summary, next.costUsd, next.error, seqOf("o", id));
+    return toOccurrence(this.mustGet("occurrences", "o", id, "occurrence"));
+  }
+  async deleteQueuedOccurrences(taskId) {
+    return this.run("DELETE FROM occurrences WHERE task_id = ? AND status = 'queued'", taskId).changes;
+  }
+  async requeueRunning(lane) {
+    const rows = lane === undefined ? this.all("SELECT seq FROM occurrences WHERE status = 'running' ORDER BY seq") : this.all("SELECT seq FROM occurrences WHERE status = 'running' AND lane = ? ORDER BY seq", lane);
+    for (const r of rows)
+      this.run("UPDATE occurrences SET status = 'queued' WHERE seq = ?", r.seq);
+    return rows.map((r) => idOf("o", r.seq));
+  }
+  async addEvent(e) {
+    const { lastInsertRowid } = this.run("INSERT INTO events (occurrence_id, agent, type, text, at) VALUES (?, ?, ?, ?, ?)", e.occurrenceId, e.agent, e.type, e.text, e.at);
+    return toEvent(this.mustGet("events", "e", idOf("e", lastInsertRowid), "event"));
+  }
+  async listEvents(occurrenceId, after) {
+    const cursor = after === undefined ? null : this.byId("events", "e", after);
+    return this.all("SELECT * FROM events WHERE occurrence_id = ? AND seq > ? ORDER BY seq", occurrenceId, cursor ? Number(cursor.seq) : 0).map(toEvent);
+  }
+  async addTaskEvent(e) {
+    const { lastInsertRowid } = this.run("INSERT INTO task_events (task_id, actor_id, kind, detail, at) VALUES (?, ?, ?, ?, ?)", e.taskId, e.actorId, e.kind, e.detail, e.at);
+    return toTaskEvent(this.mustGet("task_events", "h", idOf("h", lastInsertRowid), "task event"));
+  }
+  async listTaskEvents(taskId) {
+    return this.all("SELECT * FROM task_events WHERE task_id = ? ORDER BY seq", taskId).map(toTaskEvent);
+  }
+  async addReply(r) {
+    const { lastInsertRowid } = this.run("INSERT INTO replies (occurrence_id, task_id, user_id, kind, payload, at) VALUES (?, ?, ?, ?, ?, ?)", r.occurrenceId, r.taskId, r.userId, r.kind, json(r.payload), r.at);
+    return toReply(this.mustGet("replies", "r", idOf("r", lastInsertRowid), "reply"));
+  }
+  async listReplies(taskId) {
+    return this.all("SELECT * FROM replies WHERE task_id = ? ORDER BY seq", taskId).map(toReply);
+  }
+  async addSeriesPoint(p) {
+    const { lastInsertRowid } = this.run("INSERT INTO series (task_id, at, value, unit, note) VALUES (?, ?, ?, ?, ?)", p.taskId, p.at, p.value, p.unit ?? null, p.note ?? null);
+    return toPoint(this.mustGet("series", "s", idOf("s", lastInsertRowid), "series point"));
+  }
+  async listSeries(taskId, filter = {}) {
+    const points = filter.since === undefined ? this.all("SELECT * FROM series WHERE task_id = ? ORDER BY at, seq", taskId) : this.all("SELECT * FROM series WHERE task_id = ? AND at >= ? ORDER BY at, seq", taskId, filter.since);
+    const kept = filter.limit === undefined ? points : points.slice(-filter.limit);
+    return kept.map(toPoint);
+  }
+}
+
+// plugins/tracker/src/index.ts
+var DB_DIR = "tracker";
+var DB_FILE = "tracker.sqlite";
+var TRACKER_TYPES = Object.freeze({
+  reminder,
+  renewal
+});
+var NO_DM = {
+  async sendDm() {
+    throw new Error("this bot has no host.dm (rackbops-discord-bot#736)");
+  }
+};
+function createPlugin(host, options = {}) {
+  const adminIds = parseAdminIds(host.env.TRACKER_ADMIN_DISCORD_IDS);
+  const guildId = parseGuildId(host.env.TRACKER_GUILD_ID);
+  const clock = options.clock ?? { now: () => new Date };
+  const types = options.types ?? TRACKER_TYPES;
+  const health = { activatedAt: null, lastTickAt: null, blocked: null };
+  let db = null;
+  let store = null;
+  let claims = null;
+  let delivery = null;
+  let deps = null;
+  let warnedNoDm = false;
+  const dm = host.dm?.bind(host);
+  const surface = createSurface({
+    deps: () => deps,
+    guildId,
+    log: host.log,
+    ...options.membership ? { membership: options.membership } : {}
+  });
+  return {
+    commands: surface.commands,
+    interactions: surface.interactions,
+    async activate() {
+      let path = options.dbPath;
+      if (path === undefined) {
+        const dir = join(host.dataDir, DB_DIR);
+        mkdirSync(dir, { recursive: true });
+        path = join(dir, DB_FILE);
+      }
+      const opened = openDatabase(path);
+      const openedStore = new SqliteStore(opened);
+      const openedClaims = new ClaimStore(opened);
+      try {
+        const granted = await seedAdmins(openedStore, adminIds, clock.now());
+        const admissions = new Admissions(opened);
+        for (const id of adminIds) {
+          const admin = await openedStore.findUserByDiscordId(id);
+          if (admin)
+            admissions.record(admin.id, null, clock.now().toISOString());
+        }
+        if (granted.length > 0)
+          host.log.info(`made ${granted.length} admin(s) from TRACKER_ADMIN_DISCORD_IDS`);
+        const requeued = await openedStore.requeueRunning();
+        if (requeued.length > 0)
+          host.log.warn(`requeued ${requeued.length} occurrence(s) left running: ${requeued.join(", ")}`);
+        for (const c of openedClaims.listUnsettled())
+          reportUnconfirmed(openedClaims, host.log, c, clock.now().toISOString());
+      } catch (err) {
+        opened.close();
+        throw err;
+      }
+      db = opened;
+      store = openedStore;
+      claims = openedClaims;
+      delivery = new DeliveryHealth(opened, openedStore, {
+        log: host.log,
+        ...dm ? {
+          tellOwner: async (owner, text) => {
+            if (owner.discordId)
+              await dm(owner.discordId, { content: text });
+          }
+        } : {}
+      });
+      deps = {
+        store: openedStore,
+        admissions: new Admissions(opened),
+        health: delivery,
+        clock,
+        types,
+        dm,
+        log: host.log,
+        notifier: dm ? createDmNotifier({ store: openedStore, claims: openedClaims, dm, clock, log: host.log, health: delivery }) : NO_DM
+      };
+      if (guildId === null)
+        host.log.warn("TRACKER_GUILD_ID is unset: no membership gate, only the admission list");
+      health.blocked = typeof host.dm === "function" ? null : "this bot has no host.dm (it predates rackbops-discord-bot#736)";
+      health.activatedAt = clock.now();
+    },
+    async dispose() {
+      health.activatedAt = null;
+      deps = null;
+      delivery = null;
+      store = null;
+      claims = null;
+      const closing = db;
+      db = null;
+      closing?.close();
+    },
+    ticks: [
+      {
+        name: "notify",
+        async run(signal) {
+          if (!store || !claims)
+            return;
+          const outcome = await runNotifyTick({ store, claims, clock, types, dm, log: host.log, ...delivery ? { health: delivery } : {} }, signal);
+          if (outcome.kind === "no-dm") {
+            if (!warnedNoDm)
+              host.log.warn("notify lane is off: this bot has no host.dm (rackbops-discord-bot#736)");
+            warnedNoDm = true;
+            return;
+          }
+          if (outcome.kind === "aborted")
+            return;
+          health.lastTickAt = clock.now();
+          const { ran, failed } = outcome.result;
+          if (failed > 0)
+            host.log.warn(`notify lane: ${ran} ran, ${failed} failed`);
+        }
+      }
+    ],
+    async http(request, info) {
+      if (info.path === "/healthz" && (request.method === "GET" || request.method === "HEAD")) {
+        return healthResponse(decideHealth(health, clock.now()));
+      }
+      return new Response("Not found", { status: 404 });
+    }
+  };
+}
+export {
+  DB_DIR,
+  DB_FILE,
+  TRACKER_TYPES,
+  createPlugin
+};