@rackbops/plugin-tracker 0.7.0 → 0.9.0

package/dist/plugin.js

@@ -3,10 +3,59 @@
 import { mkdirSync } from "fs";
 import { join } from "path";
 
+// node_modules/@rackbops/docket-core/dist/record.js
+function isObj(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+var optional = (o, k, check) => o[k] === undefined || check(o[k]);
+var isString = (v) => typeof v === "string";
+var isNumber = (v) => typeof v === "number" && Number.isFinite(v);
+var isStringArray = (v) => Array.isArray(v) && v.every(isString);
+var REPLY_KINDS = new Set([
+  "accept",
+  "decline",
+  "opt_out",
+  "done",
+  "snooze",
+  "decision",
+  "text"
+]);
+function isMessage(v) {
+  if (!isObj(v) || !isString(v.text))
+    return false;
+  const actions = v.actions;
+  if (actions !== undefined && !(Array.isArray(actions) && actions.every((a) => REPLY_KINDS.has(a)))) {
+    return false;
+  }
+  return optional(v, "decisions", isStringArray) && v.ref === undefined;
+}
+function isSeries(v) {
+  return Array.isArray(v) && v.every((p) => isObj(p) && isNumber(p.value) && optional(p, "unit", isString) && optional(p, "note", isString) && optional(p, "at", isString));
+}
+function isFindings(v) {
+  return Array.isArray(v) && v.every((f) => isObj(f) && isString(f.text) && optional(f, "tags", isStringArray) && optional(f, "source", isString));
+}
+function isOutcome(v) {
+  return isObj(v) && v.snoozeUntil === undefined && optional(v, "notify", isMessage) && optional(v, "summary", isString) && optional(v, "series", isSeries) && optional(v, "complete", (c) => typeof c === "boolean") && optional(v, "findings", isFindings);
+}
+function parseRunRecord(value) {
+  if (!isObj(value))
+    return null;
+  const ok = isOutcome(value.outcome) && (value.costUsd === null || isNumber(value.costUsd)) && isString(value.firedAt) && (value.appliedAt === null || isString(value.appliedAt)) && Number.isInteger(value.resumes);
+  return ok ? value : null;
+}
+function hasFired(occurrence) {
+  return occurrence.record !== null && occurrence.record !== undefined;
+}
+function isFinishing(occurrence) {
+  return hasFired(occurrence) && occurrence.finishedAt === null;
+}
+
 // 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.";
+var STILL_FINISHING = "That run is still finishing; try again in a minute.";
 
 class ReplyRefusedError extends Error {
   name = "ReplyRefusedError";
@@ -21,8 +70,11 @@ async function runRefusal(store, task, occurrenceId, userId) {
     return "That run no longer exists.";
   if (task.status !== "active")
     return `That task is ${task.status}.`;
-  if (occurrence.status === "queued")
+  if ((occurrence.status === "queued" || occurrence.status === "running") && !hasFired(occurrence)) {
     return "That run has not fired yet.";
+  }
+  if (isFinishing(occurrence))
+    return STILL_FINISHING;
   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));
@@ -52,20 +104,40 @@ async function visibleTasks(store, actor, filter = {}) {
   }
   return out;
 }
+function seesAll(actor, task) {
+  return actor.admin || task.ownerId === actor.userId;
+}
 async function visibleOccurrences(store, actor, taskId) {
-  if (!await visibleTask(store, actor, taskId))
+  const task = await visibleTask(store, actor, taskId);
+  if (!task)
     return null;
-  return store.listOccurrences({ taskId });
+  const runs = await store.listOccurrences({ taskId });
+  return seesAll(actor, task) ? runs : runs.map((o) => ({ ...o, record: null }));
 }
 async function visibleReplies(store, actor, taskId) {
-  if (!await visibleTask(store, actor, taskId))
+  const task = await visibleTask(store, actor, taskId);
+  if (!task)
     return null;
-  return store.listReplies(taskId);
-}
+  const replies = await store.listReplies(taskId);
+  return seesAll(actor, task) ? replies : replies.filter((r) => r.userId === actor.userId);
+}
+var ABOUT_A_RECIPIENT = new Set([
+  "recipient_invited",
+  "recipient_accepted",
+  "recipient_declined",
+  "recipient_opted_out",
+  "recipient_removed",
+  "blocked",
+  "block_lifted"
+]);
 async function visibleHistory(store, actor, taskId) {
-  if (!await visibleTask(store, actor, taskId))
+  const task = await visibleTask(store, actor, taskId);
+  if (!task)
     return null;
-  return store.listTaskEvents(taskId);
+  const events = await store.listTaskEvents(taskId);
+  if (seesAll(actor, task))
+    return events;
+  return events.filter((e) => !ABOUT_A_RECIPIENT.has(e.kind) || e.detail.split(" ")[0] === actor.userId);
 }
 async function visibleSeries(store, actor, taskId, filter) {
   if (!await visibleTask(store, actor, taskId))
@@ -73,6 +145,191 @@ async function visibleSeries(store, actor, taskId, filter) {
   return store.listSeries(taskId, filter);
 }
 
+// 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/budget.js
+var BUDGET_ZONE = "America/New_York";
+var DEFAULT_BUDGET = {
+  person: { usd: 2, calls: 20 },
+  global: { usd: 10, calls: 100 }
+};
+function pad(n) {
+  return String(n).padStart(2, "0");
+}
+function budgetDay(now) {
+  const w = wallClock(now, BUDGET_ZONE);
+  const next = new Date(Date.UTC(w.year, w.month - 1, w.day + 1));
+  const start = zonedInstant(w.year, w.month, w.day, 0, 0, BUDGET_ZONE);
+  const end = zonedInstant(next.getUTCFullYear(), next.getUTCMonth() + 1, next.getUTCDate(), 0, 0, BUDGET_ZONE);
+  return {
+    day: `${w.year}-${pad(w.month)}-${pad(w.day)}`,
+    start: start.toISOString(),
+    end: end.toISOString()
+  };
+}
+function spent(rows) {
+  return rows.reduce((s, r) => ({ usd: s.usd + r.costUsd, calls: s.calls + r.calls }), {
+    usd: 0,
+    calls: 0
+  });
+}
+function reached(used, limits) {
+  if (limits.calls !== null && used.calls >= limits.calls)
+    return "calls";
+  if (limits.usd !== null && used.usd >= limits.usd)
+    return "usd";
+  return null;
+}
+async function budgetHold(store, policy, owner, now) {
+  const day = budgetDay(now);
+  const window = { since: day.start, before: day.end };
+  const all = await store.listUsage(window);
+  const everyone = spent(all);
+  const globalLimit = reached(everyone, policy.global);
+  if (globalLimit) {
+    return hold("global", globalLimit, everyone, policy.global, day);
+  }
+  const limits = await policy.personFor?.(owner) ?? policy.person;
+  const mine = spent(all.filter((u) => u.userId === owner.id));
+  const personLimit = reached(mine, limits);
+  return personLimit ? hold("person", personLimit, mine, limits, day) : null;
+}
+function hold(scope, limit, used, limits, day) {
+  return { scope, limit, used, limits, until: day.end, day: day.day };
+}
+async function charge(store, c) {
+  return store.addUsage({
+    userId: c.userId,
+    taskId: c.taskId,
+    occurrenceId: c.occurrenceId ?? null,
+    source: c.source,
+    calls: c.calls,
+    costUsd: c.costUsd ?? 0,
+    at: c.at.toISOString()
+  });
+}
+function describeLimit(h) {
+  return h.limit === "calls" ? `${h.limits.calls} model calls` : `${h.limits.usd} USD of model use (an estimate)`;
+}
+function budgetPersonMessage(h) {
+  return {
+    text: [
+      `You have reached today's limit of ${describeLimit(h)} for tasks that use the model.`,
+      "They will run again after midnight Eastern time. Reminders are not affected."
+    ].join(`
+`)
+  };
+}
+function budgetAdminMessage(h, who) {
+  const used = `(${h.used.calls} calls, about ${h.used.usd.toFixed(2)} USD)`;
+  if (h.scope === "global") {
+    return {
+      text: [
+        `Everyone together has reached today's limit of ${describeLimit(h)} ${used}.`,
+        "Every task that uses the model waits until midnight Eastern time."
+      ].join(`
+`)
+    };
+  }
+  const name = who?.displayName ?? who?.id ?? "Someone";
+  return {
+    text: [
+      `${name} has reached today's limit of ${describeLimit(h)} ${used}.`,
+      `${name}'s tasks that use the model wait until midnight Eastern time; an admin can raise ${name}'s limit.`
+    ].join(`
+`)
+  };
+}
+function usageLimitAdminMessage(until, parsed, retryAt) {
+  const retry = retryAt && retryAt < until ? `, trying again at ${retryAt.toISOString()} in case it was misread` : "";
+  const when = parsed ? `until ${until.toISOString()}${retry}` : "for an hour, then try again (no usable reset time came with it)";
+  return {
+    text: [
+      "The Claude subscription's usage limit was reached.",
+      `Tasks that use the model wait ${when}; nobody's budget is charged for it.`
+    ].join(`
+`)
+  };
+}
+async function noticeOnce(store, notifier, key, now, admins, person) {
+  if (!await store.claimNotice(key, now.toISOString()))
+    return false;
+  const sends = [];
+  for (const admin of await store.listUsers({ admin: true })) {
+    if (admin.id !== person?.user.id)
+      sends.push([admin.id, admins]);
+  }
+  if (person)
+    sends.push([person.user.id, person.message]);
+  for (const [userId, message] of sends) {
+    try {
+      await notifier.sendDm(userId, message);
+    } catch {}
+  }
+  return true;
+}
+
 // node_modules/@rackbops/docket-core/dist/capabilities.js
 var CAPABILITIES = ["notify", "graph:write", "discord:post", "github:issue"];
 var CAPABILITY_TIER = {
@@ -206,69 +463,6 @@ 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) {
@@ -548,11 +742,30 @@ function snoozeKey(occurrenceId) {
 }
 var SNOOZE_PREFIX = "snooze:";
 
+// node_modules/@rackbops/docket-core/dist/ports.js
+class DeliveryFailedError extends Error {
+  unreachable;
+  name = "DeliveryFailedError";
+  constructor(message, unreachable = false) {
+    super(message);
+    this.unreachable = unreachable;
+  }
+}
+
+class ExecutorUnavailableError extends Error {
+  name = "ExecutorUnavailableError";
+}
+
 // 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] ?? ""));
+var DEFAULT_DELIVERY_POLICY = {
+  attempts: 3,
+  deferrals: 8,
+  backoffMs: 60000,
+  maxBackoffMs: 3600000
+};
+var STALE_CLAIM_MS = 10 * 60000;
+function backoff(policy, n) {
+  return Math.min(policy.backoffMs * 2 ** Math.max(0, n - 1), policy.maxBackoffMs);
 }
 function messageFor(message, occurrence, target, ownerId) {
   const ref = { taskId: occurrence.taskId, occurrenceId: occurrence.id };
@@ -564,30 +777,129 @@ function messageFor(message, occurrence, target, ownerId) {
   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);
+function reason(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function emptyReport() {
+  return { sent: [], retrying: [], failed: [], unconfirmed: [], untried: [] };
+}
+async function deliver(store, notifier, occurrence, ownerId, targets, message, options) {
+  const policy = options.policy ?? DEFAULT_DELIVERY_POLICY;
+  const now = () => options.now();
+  const report = emptyReport();
+  const owed = await store.listDeliveries({
+    occurrenceId: occurrence.id,
+    dueBefore: now().toISOString()
+  });
+  for (const row of owed) {
+    if (options.signal?.aborted) {
+      report.untried.push(row.userId);
       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);
+    const target = targets.get(row.userId);
+    if (!target) {
+      await finalFail(store, row, "no longer a recipient", now());
+      report.failed.push(row.userId);
+      continue;
+    }
+    const claim = await store.claimDelivery(occurrence.id, row.userId, now().toISOString());
+    if (!claim) {
+      report.untried.push(row.userId);
+      continue;
+    }
+    await sendOne(store, notifier, occurrence, claim, target, ownerId, message, policy, now, report);
   }
   return report;
 }
+async function sendOne(store, notifier, occurrence, claim, target, ownerId, message, policy, now, report) {
+  const settle = (s) => store.settleDelivery(occurrence.id, claim.userId, s);
+  const counts = { attempts: claim.attempts, deferrals: claim.deferrals };
+  let messageId;
+  try {
+    ({ messageId } = await notifier.sendDm(target.id, messageFor(message, occurrence, target, ownerId)));
+  } catch (err) {
+    const error = reason(err);
+    const at = now();
+    if (err instanceof ExecutorUnavailableError) {
+      const deferrals = claim.deferrals + 1;
+      const last = deferrals >= policy.deferrals;
+      await settle({
+        status: last ? "failed" : "deferred",
+        error,
+        ...counts,
+        deferrals,
+        retryAt: last ? null : new Date(at.getTime() + backoff(policy, deferrals)).toISOString(),
+        at: at.toISOString()
+      });
+      (last ? report.failed : report.retrying).push(claim.userId);
+    } else if (err instanceof DeliveryFailedError) {
+      const attempts = claim.attempts + 1;
+      const last = err.unreachable || attempts >= policy.attempts;
+      await settle({
+        status: "failed",
+        error,
+        ...counts,
+        attempts,
+        retryAt: last ? null : new Date(at.getTime() + backoff(policy, attempts)).toISOString(),
+        at: at.toISOString()
+      });
+      (last ? report.failed : report.retrying).push(claim.userId);
+    } else {
+      await settle({ status: "unconfirmed", error, ...counts, retryAt: null, at: at.toISOString() });
+      report.unconfirmed.push(claim.userId);
+    }
+    return;
+  }
+  await settle({ status: "sent", messageId, ...counts, retryAt: null, at: now().toISOString() });
+  report.sent.push(claim.userId);
+}
+async function finalFail(store, row, error, at) {
+  await store.settleDelivery(row.occurrenceId, row.userId, {
+    status: "failed",
+    error,
+    attempts: row.attempts,
+    deferrals: row.deferrals,
+    retryAt: null,
+    at: at.toISOString()
+  });
+}
+async function dropOwed(store, rows, error, at) {
+  for (const row of rows)
+    await finalFail(store, row, error, at);
+}
+async function settleStaleClaims(store, now, all = false) {
+  const cutoff = new Date(now.getTime() - STALE_CLAIM_MS).toISOString();
+  let settled = 0;
+  for (const row of await store.listDeliveries({ status: "claimed" })) {
+    if (!all && (row.claimedAt ?? "") > cutoff)
+      continue;
+    await store.settleDelivery(row.occurrenceId, row.userId, {
+      status: "unconfirmed",
+      error: "claimed, never settled",
+      attempts: row.attempts,
+      deferrals: row.deferrals,
+      retryAt: null,
+      at: now.toISOString()
+    });
+    settled += 1;
+  }
+  return settled;
+}
+async function freshRoundForPause(store, rows) {
+  for (const row of rows) {
+    if (row.attempts === 0 && row.deferrals === 0)
+      continue;
+    await store.settleDelivery(row.occurrenceId, row.userId, {
+      status: row.status === "claimed" ? "pending" : row.status,
+      messageId: row.messageId,
+      error: row.error,
+      attempts: 0,
+      deferrals: 0,
+      retryAt: row.retryAt,
+      at: row.settledAt ?? row.createdAt
+    });
+  }
+}
 
 // node_modules/@rackbops/docket-core/dist/describe.js
 var WD = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
@@ -648,11 +960,6 @@ function describeSchedule(schedule, owner, viewerZone = owner.timeZone, now) {
   }
 }
 
-// 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;
 
@@ -666,7 +973,7 @@ 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));
+  const scheduled = pending.filter((o) => !o.dedupeKey.startsWith(SNOOZE_PREFIX) && !hasFired(o));
   if (scheduled.some((o) => o.status === "queued" || o.status === "running"))
     return null;
   const after = firstDueAfter(task.schedule, pending.length === 0, now);
@@ -691,6 +998,16 @@ function firstDueAfter(schedule, fresh, now) {
     return new Date(Date.parse(schedule.start) - 1);
   return now;
 }
+async function cancelScheduledRuns(store, taskId) {
+  let removed = 0;
+  for (const o of await store.listOccurrences({ taskId, status: "queued" })) {
+    if (o.dedupeKey.startsWith(SNOOZE_PREFIX) || hasFired(o))
+      continue;
+    if (await store.deleteOccurrence(o.id))
+      removed += 1;
+  }
+  return removed;
+}
 async function reschedule(store, task, owner, schedule, actorId, now) {
   if (schedule) {
     const problems = scheduleProblems(schedule);
@@ -698,7 +1015,7 @@ async function reschedule(store, task, owner, schedule, actorId, now) {
       throw new ScheduleError(problems.join("; "));
   }
   const at = now.toISOString();
-  const removed = await store.deleteQueuedOccurrences(task.id);
+  const removed = await cancelScheduledRuns(store, task.id);
   const updated = await store.updateTask(task.id, { schedule, at });
   await store.addTaskEvent({
     taskId: task.id,
@@ -713,34 +1030,95 @@ async function reschedule(store, task, owner, schedule, actorId, now) {
 // node_modules/@rackbops/docket-core/dist/dispatch.js
 var ME = "docket";
 var SERIES_IN_CONTEXT = 100;
+var USAGE_LIMIT_BACKOFF_MS = 3600000;
+var MAX_USAGE_LIMIT_WAIT_MS = 86400000;
+var USAGE_WINDOW_MS = 5 * 3600000;
+var MAX_RESUMES = 3;
+var STALE_RUN_MS = 10 * 60000;
+
+class UsageLimitReached extends Error {
+  until;
+  parsed;
+  window;
+  constructor(until, parsed, window) {
+    super(`usage limit until ${until.toISOString()}`);
+    this.until = until;
+    this.parsed = parsed;
+    this.window = window;
+  }
+}
 
 class Lanes {
   d;
+  executeAfter = null;
   constructor(d) {
     this.d = d;
   }
   async recover() {
-    return this.d.store.requeueRunning();
+    const ids = await this.d.store.requeueRunning();
+    await settleStaleClaims(this.d.store, this.d.clock.now(), true);
+    return ids;
   }
-  async tickNotify() {
+  async tickNotify(signal) {
     const result = { ran: 0, failed: 0, skipped: 0 };
-    for (const occurrence of await this.due("notify")) {
-      await this.runOne(occurrence) ? result.ran++ : result.failed++;
+    const count = (verdict) => {
+      if (verdict === "stop" || verdict === "held")
+        result.skipped++;
+      else
+        verdict === "ran" ? result.ran++ : result.failed++;
+    };
+    await this.guarded(() => this.sweepStaleRuns());
+    for (const occurrence of await this.unfinished()) {
+      if (signal?.aborted)
+        return result;
+      count(await this.guarded(() => this.resume(occurrence, signal)));
+    }
+    const due = await this.due("notify");
+    for (const [i, occurrence] of due.entries()) {
+      if (signal?.aborted) {
+        result.skipped += due.length - i;
+        return result;
+      }
+      count(await this.guarded(() => this.runOne(occurrence, signal)));
     }
+    if (!signal?.aborted)
+      await this.guarded(() => this.deliverOwed(signal));
     return result;
   }
+  async guarded(step) {
+    try {
+      return await step();
+    } catch {
+      return "failed";
+    }
+  }
+  async sweepStaleRuns() {
+    const { store, clock } = this.d;
+    const cutoff = new Date(clock.now().getTime() - STALE_RUN_MS).toISOString();
+    for (const o of await store.listOccurrences({ status: "running" })) {
+      if (!hasFired(o) || (o.startedAt ?? "") > cutoff)
+        continue;
+      await store.updateOccurrenceIf(o.id, "running", { status: "queued", startedAt: null });
+    }
+  }
   async tickExecute() {
     const due = await this.due("execute");
     if (!this.d.executor)
       return { ran: 0, failed: 0, skipped: due.length };
+    if (this.executeAfter && this.d.clock.now() < this.executeAfter) {
+      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;
+    for (const [i, occurrence] of due.entries()) {
+      const verdict = await this.guarded(() => this.runOne(occurrence));
+      if (verdict === "stop") {
+        result.skipped += due.length - i;
         break;
       }
-      outcome ? result.ran++ : result.failed++;
+      if (verdict === "held")
+        result.skipped++;
+      else
+        verdict === "ran" ? result.ran++ : result.failed++;
     }
     return result;
   }
@@ -774,7 +1152,7 @@ class Lanes {
       return null;
     const ctx = await this.context(loaded, occurrence, now);
     const outcome = await loaded.type.onReply({ ...ctx, reply });
-    await this.apply(task, outcome, now);
+    await this.apply(task, outcome, now, null);
     if (outcome.complete)
       await this.complete(task, input.userId, now);
     else if (outcome.snoozeUntil) {
@@ -783,19 +1161,36 @@ class Lanes {
     return outcome;
   }
   async due(lane) {
-    return this.d.store.listOccurrences({
+    const queued = await this.d.store.listOccurrences({
       lane,
       status: "queued",
       dueBefore: this.d.clock.now().toISOString()
     });
+    const status = new Map;
+    const kept = [];
+    for (const o of queued) {
+      if (hasFired(o))
+        continue;
+      if (!status.has(o.taskId)) {
+        status.set(o.taskId, (await this.d.store.getTask(o.taskId))?.status ?? null);
+      }
+      const s = status.get(o.taskId);
+      if (s === null || s === "active")
+        kept.push(o);
+    }
+    return kept;
   }
-  async load(task) {
-    const type = this.d.types[task.type];
-    if (!type)
-      return { error: `no task type ${task.type}` };
+  async unfinished() {
+    const queued = await this.d.store.listOccurrences({
+      status: "queued",
+      dueBefore: this.d.clock.now().toISOString()
+    });
+    return queued.filter(isFinishing);
+  }
+  async audience(task) {
     const owner = await this.d.store.getUser(task.ownerId);
     if (!owner)
-      return { error: `no owner ${task.ownerId}` };
+      return null;
     const recipients = [];
     for (const r of await this.d.store.listRecipients(task.id)) {
       if (r.state !== "accepted")
@@ -804,7 +1199,16 @@ class Lanes {
       if (user)
         recipients.push(user);
     }
-    return { task, type, owner, recipients };
+    return { owner, recipients };
+  }
+  async load(task) {
+    const type = this.d.types[task.type];
+    if (!type)
+      return { error: `no task type ${task.type}` };
+    const people = await this.audience(task);
+    if (!people)
+      return { error: `no owner ${task.ownerId}` };
+    return { task, type, ...people };
   }
   async context(loaded, occurrence, now) {
     const originalDueAt = await this.originalDueAt(occurrence);
@@ -837,75 +1241,275 @@ class Lanes {
     }
     return found;
   }
-  async apply(task, outcome, now) {
+  async apply(task, outcome, now, occurrenceId) {
     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 ?? []) {
+    for (const [i, point] of (outcome.series ?? []).entries()) {
       await store.addSeriesPoint({
         taskId: task.id,
         at: point.at ?? now.toISOString(),
         value: point.value,
         unit: point.unit ?? null,
-        note: point.note ?? null
+        note: point.note ?? null,
+        key: occurrenceId === null ? null : `${occurrenceId}:${i}`
       });
     }
   }
   async complete(task, actorId, now) {
     const { store } = this.d;
     const at = now.toISOString();
-    await store.deleteQueuedOccurrences(task.id);
+    for (const o of await store.listOccurrences({ taskId: task.id, status: "queued" })) {
+      if (!hasFired(o))
+        await store.deleteOccurrence(o.id);
+    }
     await store.updateTask(task.id, { status: "done", at });
     await store.addTaskEvent({ taskId: task.id, actorId, kind: "completed", detail: "", at });
   }
-  async runOne(occurrence) {
+  async runOne(occurrence, signal) {
     const { store, clock } = this.d;
     const task = await store.getTask(occurrence.taskId);
     if (!task)
       return this.fail(occurrence, `no task ${occurrence.taskId}`);
+    if (task.status !== "active")
+      return "held";
+    if (await this.finishing(task.id, occurrence.id))
+      return "held";
     const loaded = await this.load(task);
     if ("error" in loaded)
       return this.fail(occurrence, loaded.error);
+    if (loaded.type.lane === "execute") {
+      const held = await this.budgetCheck(loaded.owner);
+      if (held)
+        return held;
+    }
     const now = clock.now();
     const late = isLate(occurrence, now);
-    await store.updateOccurrence(occurrence.id, {
+    const started = await store.updateOccurrenceIf(occurrence.id, "queued", {
       status: "running",
       startedAt: now.toISOString(),
       late,
       error: null
     });
-    await this.event(occurrence, "status", late ? "started late" : "started");
+    if (!started || hasFired(started))
+      return "held";
+    let record;
+    try {
+      await this.event(occurrence, "status", late ? "started late" : "started");
+      const ctx = await this.context(loaded, started, now);
+      const { outcome, costUsd } = await this.execute(loaded.type, ctx, started);
+      if (signal?.aborted) {
+        await this.requeue(started, "the tick was aborted before the outcome was stored");
+        return "stop";
+      }
+      const { snoozeUntil: _replyOnly, ...kept } = outcome;
+      record = {
+        outcome: kept,
+        costUsd,
+        firedAt: clock.now().toISOString(),
+        appliedAt: null,
+        resumes: 0
+      };
+      await store.updateOccurrence(started.id, { record });
+    } catch (err) {
+      if (err instanceof ExecutorUnavailableError || err instanceof UsageLimitReached) {
+        await this.requeue(started, err.message);
+        if (err instanceof UsageLimitReached)
+          await this.usageLimit(err);
+        return "stop";
+      }
+      await this.fail(started, err instanceof Error ? err.message : String(err));
+      await this.next(task, loaded.owner);
+      return "failed";
+    }
+    return this.finishFired({ ...started, record }, task, record, signal);
+  }
+  async requeue(occurrence, why) {
+    await this.event(occurrence, "status", `waiting: ${why}`);
+    await this.d.store.updateOccurrence(occurrence.id, { status: "queued", startedAt: null });
+  }
+  async resume(occurrence, signal) {
+    const { store, clock } = this.d;
+    const started = await store.updateOccurrenceIf(occurrence.id, "queued", {
+      status: "running",
+      startedAt: clock.now().toISOString()
+    });
+    if (!started)
+      return "held";
+    const record = parseRunRecord(started.record);
+    const task = await store.getTask(started.taskId);
+    if (!record || !task) {
+      const error = record ? `no task ${started.taskId}` : "the run's record could not be read";
+      await this.event(started, "error", error);
+      await store.updateOccurrence(started.id, {
+        status: "done",
+        finishedAt: clock.now().toISOString(),
+        error
+      });
+      await dropOwed(store, await store.listDeliveries({ occurrenceId: started.id }), error, clock.now());
+      return "failed";
+    }
+    await this.event(started, "status", "resumed");
+    return this.finishFired(started, task, record, signal);
+  }
+  async finishFired(occurrence, task, record, signal) {
+    const { store, clock } = this.d;
+    const { outcome } = record;
+    let people = null;
+    let current = null;
     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());
+      people = await this.audience(task);
+      if (people && !outcome.complete)
+        await this.next(task, people.owner);
+      if (record.appliedAt === null) {
+        await this.apply(task, outcome, new Date(record.firedAt), occurrence.id);
+        const applied = { ...record, appliedAt: clock.now().toISOString() };
+        await store.updateOccurrence(occurrence.id, { record: applied });
+        record = applied;
+      }
+      if (outcome.notify && people) {
+        const at = clock.now().toISOString();
+        const snoozeRun = occurrence.dedupeKey.startsWith(SNOOZE_PREFIX);
+        const to = snoozeRun ? [people.owner] : [people.owner, ...people.recipients];
+        for (const u of to)
+          await store.planDelivery(occurrence.id, u.id, at);
       }
-      const snoozed = (await store.getOccurrence(occurrence.id))?.status === "snoozed";
-      await store.updateOccurrence(occurrence.id, {
-        status: snoozed ? "snoozed" : "done",
+      const done = await store.updateOccurrenceIf(occurrence.id, "running", {
+        status: "done",
         finishedAt: clock.now().toISOString(),
         summary: outcome.summary ?? null,
-        costUsd
+        costUsd: record.costUsd,
+        error: people ? null : `no owner ${task.ownerId}`
       });
-      if (outcome.complete)
-        await this.complete(task, null, clock.now());
-      else
-        await this.next(task, loaded.owner);
-      return true;
+      if (!done)
+        return "held";
+      current = await store.getTask(task.id);
+      if (outcome.complete && current && current.status !== "done") {
+        await this.complete(current, null, clock.now());
+        current = await store.getTask(task.id);
+      }
     } catch (err) {
-      if (err instanceof ExecutorUnavailableError) {
-        await this.event(occurrence, "status", `waiting: ${err.message}`);
-        await store.updateOccurrence(occurrence.id, { status: "queued" });
-        return null;
+      return this.putBack(occurrence, record, err);
+    }
+    const sending = current?.status === "active" || current?.status === "done";
+    if (outcome.notify && people && sending) {
+      try {
+        await this.deliverRun(occurrence, task, people, outcome.notify, signal);
+      } catch {}
+    }
+    return "ran";
+  }
+  async putBack(occurrence, record, err) {
+    const { store, clock } = this.d;
+    const message = err instanceof Error ? err.message : String(err);
+    const resumes = record.resumes + 1;
+    try {
+      await this.event(occurrence, "error", message);
+      if (resumes > MAX_RESUMES) {
+        await store.updateOccurrenceIf(occurrence.id, "running", {
+          status: "done",
+          finishedAt: clock.now().toISOString(),
+          error: `could not finish after ${MAX_RESUMES} tries: ${message}`
+        });
+        return "failed";
       }
-      await this.fail(occurrence, err instanceof Error ? err.message : String(err));
-      await this.next(task, loaded.owner);
-      return false;
+      await store.updateOccurrenceIf(occurrence.id, "running", {
+        status: "queued",
+        startedAt: null,
+        record: { ...record, resumes }
+      });
+    } catch {}
+    return "held";
+  }
+  async finishing(taskId, except) {
+    for (const status of ["queued", "running"]) {
+      const runs = await this.d.store.listOccurrences({ taskId, status });
+      if (runs.some((o) => o.id !== except && isFinishing(o)))
+        return true;
+    }
+    return false;
+  }
+  async deliverRun(occurrence, task, people, message, signal) {
+    const targets = new Map;
+    for (const u of [people.owner, ...people.recipients])
+      targets.set(u.id, u);
+    await deliver(this.d.store, this.d.notifier, occurrence, task.ownerId, targets, message, {
+      now: () => this.d.clock.now(),
+      policy: this.d.delivery ?? DEFAULT_DELIVERY_POLICY,
+      ...signal ? { signal } : {}
+    });
+  }
+  async deliverOwed(signal) {
+    const { store, clock } = this.d;
+    await settleStaleClaims(store, clock.now());
+    const byRun = new Map;
+    for (const row of await store.listDeliveries({ dueBefore: clock.now().toISOString() })) {
+      byRun.set(row.occurrenceId, [...byRun.get(row.occurrenceId) ?? [], row]);
+    }
+    for (const [occurrenceId, rows] of byRun) {
+      if (signal?.aborted)
+        return;
+      try {
+        const occurrence = await store.getOccurrence(occurrenceId);
+        const record = occurrence ? parseRunRecord(occurrence.record) : null;
+        const task = occurrence ? await store.getTask(occurrence.taskId) : null;
+        const message = record?.outcome.notify;
+        const people = task ? await this.audience(task) : null;
+        if (!occurrence || !message || !task || !people || task.status === "archived") {
+          await dropOwed(store, rows, "the run or its task is gone", clock.now());
+          continue;
+        }
+        if (task.status === "paused") {
+          await freshRoundForPause(store, rows);
+          continue;
+        }
+        await this.deliverRun(occurrence, task, people, message, signal);
+      } catch {}
     }
   }
+  async budgetCheck(owner) {
+    const { store, notifier, clock } = this.d;
+    const now = clock.now();
+    const hold = await budgetHold(store, this.d.budget ?? DEFAULT_BUDGET, owner, now);
+    if (!hold)
+      return null;
+    if (hold.scope === "global") {
+      await noticeOnce(store, notifier, `budget:global:${hold.day}`, now, budgetAdminMessage(hold, null));
+      return "stop";
+    }
+    await noticeOnce(store, notifier, `budget:person:${owner.id}:${hold.day}`, now, budgetAdminMessage(hold, owner), { user: owner, message: budgetPersonMessage(hold) });
+    return "held";
+  }
+  async usageLimit(err) {
+    const { store, notifier, clock } = this.d;
+    this.executeAfter = err.until;
+    const key = `usage-limit:${err.window}`;
+    await noticeOnce(store, notifier, key, clock.now(), usageLimitAdminMessage(err.parsed ? new Date(err.window) : err.until, err.parsed, err.until));
+  }
+  async chargeRun(occurrence, task, result) {
+    if (result.kind === "usage_limit") {
+      const now = this.d.clock.now();
+      const reset = result.resetsAt ? new Date(result.resetsAt) : null;
+      if (reset && !Number.isNaN(reset.getTime()) && reset > now) {
+        const until = new Date(Math.min(reset.getTime(), now.getTime() + MAX_USAGE_LIMIT_WAIT_MS));
+        throw new UsageLimitReached(until, true, reset.toISOString());
+      }
+      const window = Math.floor(now.getTime() / USAGE_WINDOW_MS);
+      throw new UsageLimitReached(new Date(now.getTime() + USAGE_LIMIT_BACKOFF_MS), false, `unknown:${window}`);
+    }
+    if (result.kind === "auth_failed")
+      return;
+    await charge(this.d.store, {
+      userId: task.ownerId,
+      taskId: task.id,
+      occurrenceId: occurrence.id,
+      source: "run",
+      calls: 1,
+      costUsd: result.totalCostUsd ?? null,
+      at: this.d.clock.now()
+    });
+  }
   async next(task, owner) {
     const current = await this.d.store.getTask(task.id);
     if (current)
@@ -923,12 +1527,17 @@ class Lanes {
       throw new ExecutorUnavailableError("no executor configured");
     const spec = await type.prepare(ctx);
     const result = await this.d.executor.run(spec, occurrence.id);
+    await this.chargeRun(occurrence, ctx.task, result);
     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" });
+    const current = await store.getOccurrence(occurrence.id);
+    if (!current || current.status !== "done" && current.status !== "failed")
+      return;
+    if (!await store.updateOccurrenceIf(current.id, current.status, { status: "snoozed" }))
+      return;
     await this.event(occurrence, "status", `snoozed until ${until.toISOString()} by ${reply.userId}`);
     await store.createOccurrence({
       taskId: task.id,
@@ -940,13 +1549,12 @@ class Lanes {
   }
   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",
+      status: "failed",
       finishedAt: this.d.clock.now().toISOString(),
       error: message
     });
-    return false;
+    return "failed";
   }
   async event(occurrence, type, text) {
     await this.d.store.addEvent({
@@ -961,6 +1569,16 @@ class Lanes {
 
 // 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 registrationText(user, options) {
+  const hour = String(user.preferredHour).padStart(2, "0");
+  return [
+    options.first ? "You are registered." : "Your settings are updated.",
+    `Reminders reach you by DM. One without a time of day arrives at ${hour}:00, ${user.timeZone} time.`,
+    `Your tasks are private to you and anyone you choose to share them with. ${ADMIN_DISCLOSURE}`,
+    ...options.notes ?? []
+  ].join(`
+`);
+}
 function name(user) {
   return user.displayName ?? "Someone";
 }
@@ -982,7 +1600,7 @@ 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 queued = (await store.listOccurrences({ taskId: task.id, status: "queued" })).filter((o) => !hasFired(o));
     const from = task.ownerId === actor.userId ? null : await store.getUser(task.ownerId);
     entries.push({ task, next: queued[0] ?? null, from });
   }
@@ -1841,13 +2459,18 @@ function decideAccess(input) {
     return NOT_REGISTERED;
   return null;
 }
-function parseGuildId(raw) {
+function parseGuildIds(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;
+  const ids = [];
+  for (const entry of raw.split(",")) {
+    const id = entry.trim();
+    if (!/^[0-9]{17,20}$/.test(id))
+      throw new Error(`TRACKER_GUILD_ID: "${id}" is not a Discord server id`);
+    if (!ids.includes(id))
+      ids.push(id);
+  }
+  return ids;
 }
 
 // plugins/tracker/src/admissions.ts
@@ -1874,53 +2497,6 @@ class Admissions {
   }
 }
 
-// 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)`;
@@ -2372,13 +2948,22 @@ 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)
+async function lookupMembership(interaction, guildIds, discordId, log) {
+  if (guildIds === null)
     return "not-checked";
-  if (interaction.guildId === guildId && interaction.user.id === discordId)
+  if (interaction.guildId !== null && guildIds.includes(interaction.guildId) && interaction.user.id === discordId)
     return "member";
+  const lookups = guildIds.map((guildId) => memberOf(interaction.client, guildId, discordId, log));
+  const firstYes = new Promise((resolve) => {
+    for (const l of lookups)
+      l.then((a) => a === "member" && resolve("member"));
+  });
+  const all = Promise.all(lookups).then((answers) => answers.includes("unknown") ? "unknown" : answers.includes("member") ? "member" : "not-member");
+  return Promise.race([firstYes, all]);
+}
+async function memberOf(client, guildId, discordId, log) {
   try {
-    const guild = await interaction.client.guilds.fetch(guildId);
+    const guild = await client.guilds.fetch(guildId);
     await guild.members.fetch({ user: discordId, force: true });
     return "member";
   } catch (err) {
@@ -2504,7 +3089,7 @@ function retimed(s, day, owner) {
   return null;
 }
 async function heldRuns(store, task) {
-  return (await store.listOccurrences({ taskId: task.id, status: "queued" })).filter((o) => !o.dedupeKey.startsWith(SNOOZE_PREFIX));
+  return (await store.listOccurrences({ taskId: task.id, status: "queued" })).filter((o) => !o.dedupeKey.startsWith(SNOOZE_PREFIX) && !hasFired(o));
 }
 async function restoreHeldRun(store, task, held, before, after, now) {
   const s = task.schedule;
@@ -2549,13 +3134,10 @@ async function allowPerson(d, admin, target) {
   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(`
-`);
+  return registrationText(user, {
+    first,
+    notes: [`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.`]
+  });
 }
 async function registerPerson(d, user, input) {
   let updated;
@@ -2615,21 +3197,21 @@ async function rescheduleOwned(d, owner, zoneChanged, before) {
       continue;
     if (!zoneChanged && s.hour !== undefined)
       continue;
-    const held = task.status === "paused" ? await heldRuns(d.store, task) : [];
-    const updated = await rescheduleKeepingSnoozes(d, task, owner, s, owner.id);
-    if (held.length > 0)
-      await restoreHeldRun(d.store, updated, held, before, owner, d.clock.now());
+    await d.locks.run(task.id, async () => {
+      const current = await d.store.getTask(task.id);
+      if (!current || current.status !== "active" && current.status !== "paused")
+        return;
+      const held = current.status === "paused" ? await heldRuns(d.store, current) : [];
+      const updated = await rescheduleKeepingSnoozes(d, current, owner, s, owner.id);
+      if (held.length > 0)
+        await restoreHeldRun(d.store, updated, held, before, owner, d.clock.now());
+    });
     moved++;
   }
   return moved;
 }
 async function rescheduleKeepingSnoozes(d, task, owner, schedule, actorId) {
-  const snoozes = (await d.store.listOccurrences({ taskId: task.id, status: "queued" })).filter((o) => o.dedupeKey.startsWith(SNOOZE_PREFIX));
-  const now = d.clock.now();
-  const { task: updated } = await reschedule(d.store, task, owner, schedule, actorId, 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() });
-  }
+  const { task: updated } = await reschedule(d.store, task, owner, schedule, actorId, d.clock.now());
   return updated;
 }
 async function liveTaskCap(d, owner) {
@@ -2673,14 +3255,24 @@ 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;
 }
+function answerable(o) {
+  if (o.status === "done" || o.status === "failed")
+    return true;
+  return (o.status === "running" || o.status === "queued") && hasFired(o);
+}
+async function latestRun(d, taskId) {
+  return (await d.store.listOccurrences({ taskId })).filter(answerable).at(-1) ?? null;
+}
 async function answerLatest(d, user, input) {
   if (input.until !== undefined && input.until.trim().length > MAX_WHEN)
     return `\`until\` is longer than ${MAX_WHEN} characters.`;
   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);
+  return d.locks.run(task.id, () => answerLatestLocked(d, user, task, input));
+}
+async function answerLatestLocked(d, user, task, input) {
+  const latest = await latestRun(d, task.id);
   if (!latest)
     return "That task has not reminded you yet, so there is nothing to answer.";
   let payload = null;
@@ -2716,7 +3308,13 @@ function editable(task) {
   return task.status === "active" || task.status === "paused";
 }
 var FINISHED = "That task has finished, so it cannot be changed. Set a new one instead.";
-async function pauseTask(d, user, taskId) {
+function locked(d, taskId, act) {
+  return d.locks.run(taskId.trim(), act);
+}
+function pauseTask(d, user, taskId) {
+  return locked(d, taskId, () => pauseLocked(d, user, taskId));
+}
+async function pauseLocked(d, user, taskId) {
   const task = await ownLiveTask(d, user, taskId);
   if (!task)
     return { ok: false, error: NO_SUCH_TASK };
@@ -2727,7 +3325,10 @@ async function pauseTask(d, user, taskId) {
   await d.store.addTaskEvent({ taskId: task.id, actorId: user.id, kind: "paused", detail: "paused by the owner", at });
   return { ok: true, text: `Paused \`${task.id}\`: nothing is sent until you resume it.` };
 }
-async function resumeTask(d, user, taskId) {
+function resumeTask(d, user, taskId) {
+  return locked(d, taskId, () => resumeLocked(d, user, taskId));
+}
+async function resumeLocked(d, user, taskId) {
   const task = await ownLiveTask(d, user, taskId);
   if (!task)
     return { ok: false, error: NO_SUCH_TASK };
@@ -2753,12 +3354,18 @@ async function resumeTask(d, user, taskId) {
   const without = names.length > 0 ? `, without ${names.join(", ")}` : "";
   return { ok: true, text: `Resumed \`${task.id}\`${without}.` };
 }
-async function deleteTask(d, user, taskId) {
+function deleteTask(d, user, taskId) {
+  return locked(d, taskId, () => deleteLocked(d, user, taskId));
+}
+async function deleteLocked(d, user, taskId) {
   const task = await ownLiveTask(d, user, taskId);
   if (!task)
     return { ok: false, error: NO_SUCH_TASK };
   const at = d.clock.now().toISOString();
-  await d.store.deleteQueuedOccurrences(task.id);
+  for (const o of await d.store.listOccurrences({ taskId: task.id, status: "queued" })) {
+    if (!hasFired(o))
+      await d.store.deleteOccurrence(o.id);
+  }
   await d.store.updateTask(task.id, { status: "archived", at });
   await d.store.addTaskEvent({ taskId: task.id, actorId: user.id, kind: "archived", detail: "deleted by the owner", at });
   return { ok: true, text: `Deleted \`${task.id}\` ${task.title}.` };
@@ -2893,30 +3500,31 @@ function hostButtons(message) {
 // 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)
+var UNKNOWN_USER2 = 10013;
+function isUnknownUser(err) {
+  if (typeof err === "object" && err !== null && err.code === UNKNOWN_USER2)
     return true;
+  return (err instanceof Error ? err.message : String(err)) === "Unknown User";
+}
+function isHostRefusal(err) {
   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");
+  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.startsWith("content is longer than") || isButtonRefusal(err);
 }
-
-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;
-  }
+function deliveryError(err) {
+  const reason = err instanceof Error ? err.message : String(err);
+  if (reason === HOST_CANNOT_MESSAGE || isUnknownUser(err))
+    return new DeliveryFailedError(reason, true);
+  if (isHostRefusal(err))
+    return new DeliveryFailedError(reason);
+  return err;
 }
-
-class UndeliverableError extends Error {
-  name = "UndeliverableError";
+function isUnreachable(err) {
+  return err instanceof DeliveryFailedError && err.unreachable;
 }
 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) {
@@ -2940,39 +3548,18 @@ function createDmNotifier(d) {
     async sendDm(userId, message) {
       const user = await d.store.getUser(userId);
       if (!user)
-        throw new UndeliverableError(`no user ${userId}`);
+        throw new DeliveryFailedError(`no user ${userId}`, true);
       const discordId = user.discordId;
       if (!discordId || !HOST_SNOWFLAKE.test(discordId))
-        throw new UndeliverableError(`user ${userId} has no valid Discord id`);
+        throw new DeliveryFailedError(`user ${userId} has no valid Discord id`, true);
       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 };
-        }
-      }
+        throw new DeliveryFailedError("the message has no text");
       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 };
-        }
-      }
+      const buttons = hostButtons(message);
+      let delivery;
       try {
-        const buttons = hostButtons(message);
-        let delivery;
         try {
           delivery = await d.dm(discordId, buttons.length > 0 ? { ...hostMessage, buttons } : hostMessage);
         } catch (err) {
@@ -2981,39 +3568,28 @@ function createDmNotifier(d) {
           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 mapped = deliveryError(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);
+        if (reason === HOST_CANNOT_MESSAGE || isUnknownUser(err)) {
+          try {
+            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`);
+          } catch (countErr) {
+            d.log.error(`could not count a failed DM to ${userId}`, countErr);
+          }
+        } else if (!(mapped instanceof DeliveryFailedError)) {
+          const what = message.ref?.occurrenceId ? `delivery of ${message.ref.occurrenceId}` : "a DM";
+          d.log.warn(`${what} to ${userId} is unconfirmed (${reason}); it will not be resent`);
         }
-        throw err;
+        throw mapped;
       }
+      d.health?.recordSuccess(userId);
+      return { messageId: delivery.messageId };
     }
   };
 }
-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.";
@@ -3059,8 +3635,9 @@ async function finishShare(d, p, err) {
     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.`;
+  if (isUnreachable(err)) {
+    const why = err instanceof Error && err.message === HOST_CANNOT_MESSAGE ? "their DMs are closed, or they blocked the bot" : "I can't reach them on Discord";
+    return `I could not DM <@${p.targetDiscordId}> (${why}), 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.";
@@ -3070,7 +3647,19 @@ var CONSENT_TEXT = {
   decline: "Declined. You will not get this task's results.",
   opt_out: "You will not get this task's messages any more."
 };
+async function taskOfRef(d, ref) {
+  const decoded = decodeReplyRef(ref);
+  if (!decoded)
+    return null;
+  if (decoded.scope === "t")
+    return decoded.id;
+  return (await d.store.getOccurrence(decoded.id))?.taskId ?? null;
+}
 async function press(d, user, ref) {
+  const taskId = await taskOfRef(d, ref);
+  return taskId === null ? pressLocked(d, user, ref) : d.locks.run(taskId, () => pressLocked(d, user, ref));
+}
+async function pressLocked(d, user, ref) {
   const verdict = await replyForRef(d.store, ref, user.id);
   if (!verdict.ok)
     return { ok: false, error: verdict.error };
@@ -3101,6 +3690,11 @@ async function replyRefusal(d, user, occurrenceId) {
   return mine?.state === "accepted" ? null : "That is not yours to reply to.";
 }
 async function submitReply(d, user, occurrenceId, text) {
+  const taskId = (await d.store.getOccurrence(occurrenceId))?.taskId;
+  const act = () => submitReplyLocked(d, user, occurrenceId, text);
+  return taskId === undefined ? act() : d.locks.run(taskId, act);
+}
+async function submitReplyLocked(d, user, occurrenceId, text) {
   const refusal = await replyRefusal(d, user, occurrenceId);
   if (refusal)
     return refusal;
@@ -3598,18 +4192,22 @@ async function decideRenewal(d, user, input) {
     return `\`/task decide\` answers a renewal; \`${task.id}\` is a ${task.type}.`;
   if (input.amount !== undefined && (!Number.isFinite(input.amount) || input.amount < 0))
     return "The amount has to be zero or more.";
-  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 renewal has no ask waiting for an answer yet.";
   const payload = input.amount === undefined ? input.choice : { choice: input.choice, amount: input.amount };
-  try {
-    await replyLanes(d).reply({ taskId: task.id, occurrenceId: latest.id, userId: user.id, kind: "decision", payload });
-  } catch (err) {
-    if (err instanceof ReplyRefusedError)
-      return err.message;
-    throw err;
-  }
+  const refused = await d.locks.run(task.id, async () => {
+    const latest = await latestRun(d, task.id);
+    if (!latest)
+      return "That renewal has no ask waiting for an answer yet.";
+    try {
+      await replyLanes(d).reply({ taskId: task.id, occurrenceId: latest.id, userId: user.id, kind: "decision", payload });
+      return null;
+    } catch (err) {
+      if (err instanceof ReplyRefusedError)
+        return err.message;
+      throw err;
+    }
+  });
+  if (refused !== null)
+    return refused;
   if (input.choice === "cancel")
     return `Cancelled: \`${task.id}\` ${task.title} will not ask again.`;
   const currency = task.config.currency ?? "";
@@ -3687,7 +4285,7 @@ function createSurface(w) {
   const ctx = {
     deps: w.deps,
     queue: w.queue ?? serial(),
-    membershipOf: (interaction, discordId) => w.membership ? w.membership(interaction, discordId) : lookupMembership(interaction, w.guildId, discordId, w.log),
+    membershipOf: (interaction, discordId) => w.membership ? w.membership(interaction, discordId) : lookupMembership(interaction, w.guildIds, discordId, w.log),
     log: w.log
   };
   const membershipOf = (interaction, discordId) => ctx.membershipOf(interaction, discordId);
@@ -3879,6 +4477,29 @@ function healthResponse(health) {
   });
 }
 
+// plugins/tracker/src/locks.ts
+class TaskLocks {
+  tails = new Map;
+  async run(taskId, fn) {
+    const before = this.tails.get(taskId) ?? Promise.resolve();
+    let release = () => {};
+    const mine = new Promise((resolve) => release = resolve);
+    const tail = before.then(() => mine);
+    this.tails.set(taskId, tail);
+    try {
+      await before;
+      return await fn();
+    } finally {
+      release();
+      if (this.tails.get(taskId) === tail)
+        this.tails.delete(taskId);
+    }
+  }
+  held(taskId) {
+    return this.tails.has(taskId);
+  }
+}
+
 // plugins/tracker/src/notify-lane.ts
 var FETCH_TYPES = new Set(["price"]);
 function takesType(kind, type) {
@@ -3901,17 +4522,41 @@ function untilAborted(type, signal) {
     }
   };
 }
-function laneStore(store, keep = () => true) {
+async function tasksWithWork(store, now, keep) {
+  const at = now.toISOString();
+  const ids = [];
+  const add = (id) => void (ids.includes(id) || ids.push(id));
+  for (const o of await store.listOccurrences({ status: "queued", dueBefore: at }))
+    add(o.taskId);
+  for (const o of await store.listOccurrences({ status: "running" }))
+    add(o.taskId);
+  const rows = [...await store.listDeliveries({ dueBefore: at }), ...await store.listDeliveries({ status: "claimed" })];
+  for (const row of rows) {
+    const o = await store.getOccurrence(row.occurrenceId);
+    if (o)
+      add(o.taskId);
+  }
+  const kept = [];
+  for (const id of ids) {
+    if (keep(await store.getTask(id)))
+      kept.push(id);
+  }
+  return kept;
+}
+function taskStore(store, taskId) {
   const view = Object.create(store);
-  view.listOccurrences = async (filter = {}) => {
-    const found = await store.listOccurrences(filter);
-    if (filter.status !== "queued" || filter.dueBefore === undefined)
-      return found;
+  view.listOccurrences = (filter = {}) => store.listOccurrences(filter.taskId === undefined ? { ...filter, taskId } : filter);
+  view.listDeliveries = async (filter = {}) => {
+    const rows = await store.listDeliveries(filter);
+    if (filter.occurrenceId !== undefined)
+      return rows;
+    const ours = new Map;
     const kept = [];
-    for (const o of found) {
-      const task = await store.getTask(o.taskId);
-      if (task?.status === "active" && keep(task))
-        kept.push(o);
+    for (const row of rows) {
+      if (!ours.has(row.occurrenceId))
+        ours.set(row.occurrenceId, (await store.getOccurrence(row.occurrenceId))?.taskId === taskId);
+      if (ours.get(row.occurrenceId))
+        kept.push(row);
     }
     return kept;
   };
@@ -3923,22 +4568,31 @@ async function runNotifyTick(d, signal) {
   if (signal?.aborted)
     return { kind: "aborted" };
   const kind = d.kind ?? "notify";
-  const store = laneStore(d.store, (task) => takesType(kind, task.type));
-  const notifier = createDmNotifier({
-    store,
-    claims: d.claims,
-    dm: d.dm,
-    clock: d.clock,
-    log: d.log,
-    ...signal ? { signal } : {},
-    ...d.health ? { health: d.health } : {}
-  });
+  const notifier = createDmNotifier({ store: d.store, dm: d.dm, clock: d.clock, log: d.log, ...d.health ? { health: d.health } : {} });
   let types = d.types;
   if (kind === "poll" && signal) {
     types = Object.fromEntries(Object.entries(d.types).map(([id, t]) => [id, FETCH_TYPES.has(id) ? untilAborted(t, signal) : t]));
   }
-  const lanes = new Lanes({ store, clock: d.clock, types, notifier, ...kind === "poll" && d.fetch ? { fetch: d.fetch } : {} });
-  const result = await lanes.tickNotify();
+  const locks = d.locks;
+  const result = { ran: 0, failed: 0, skipped: 0 };
+  for (const taskId of await tasksWithWork(d.store, d.clock.now(), (task) => task ? takesType(kind, task.type) : kind === "notify")) {
+    if (signal?.aborted)
+      break;
+    const pass = async () => {
+      const lanes = new Lanes({
+        store: taskStore(d.store, taskId),
+        clock: d.clock,
+        types,
+        notifier,
+        ...kind === "poll" && d.fetch ? { fetch: d.fetch } : {}
+      });
+      const r = await lanes.tickNotify(signal);
+      result.ran += r.ran;
+      result.failed += r.failed;
+      result.skipped += r.skipped;
+    };
+    await (locks ? locks.run(taskId, pass) : pass());
+  }
   return signal?.aborted ? { kind: "aborted" } : { kind: "ran", result };
 }
 
@@ -4128,6 +4782,68 @@ var MIGRATIONS = [
     member_checked_at TEXT
   );
   CREATE INDEX api_tokens_user ON api_tokens (user_id);
+  `,
+  `
+  ALTER TABLE occurrences ADD COLUMN record TEXT;
+
+  ALTER TABLE series ADD COLUMN key TEXT;
+  CREATE UNIQUE INDEX series_key ON series (key) WHERE key IS NOT NULL;
+
+  CREATE TABLE deliveries (
+    seq INTEGER PRIMARY KEY AUTOINCREMENT,
+    occurrence_id TEXT NOT NULL,
+    user_id TEXT NOT NULL,
+    status TEXT NOT NULL,
+    message_id TEXT,
+    error TEXT,
+    attempts INTEGER NOT NULL,
+    deferrals INTEGER NOT NULL,
+    retry_at TEXT,
+    created_at TEXT NOT NULL,
+    claimed_at TEXT,
+    settled_at TEXT,
+    UNIQUE (occurrence_id, user_id)
+  );
+  CREATE INDEX deliveries_user ON deliveries (user_id);
+  CREATE INDEX deliveries_owed ON deliveries (retry_at) WHERE retry_at IS NOT NULL;
+  CREATE INDEX deliveries_status ON deliveries (status);
+  INSERT INTO deliveries (occurrence_id, user_id, status, message_id, error, attempts, deferrals, retry_at, created_at, claimed_at, settled_at)
+    SELECT occurrence_id, user_id,
+      CASE
+        WHEN status IN ('sent', 'failed') THEN status
+        WHEN status = 'unconfirmed' AND reported_at IS NOT NULL THEN 'unconfirmed'
+        ELSE 'claimed'
+      END,
+      message_id, error,
+      CASE WHEN status = 'failed' THEN 1 ELSE 0 END,
+      0, NULL, claimed_at, claimed_at,
+      CASE
+        WHEN status IN ('sent', 'failed') OR (status = 'unconfirmed' AND reported_at IS NOT NULL)
+          THEN COALESCE(settled_at, claimed_at)
+        ELSE NULL
+      END
+    FROM delivery_claims ORDER BY claimed_at, occurrence_id, user_id;
+  DROP TABLE delivery_claims;
+
+  CREATE TABLE usage (
+    seq INTEGER PRIMARY KEY AUTOINCREMENT,
+    user_id TEXT NOT NULL,
+    task_id TEXT,
+    occurrence_id TEXT,
+    source TEXT NOT NULL,
+    calls INTEGER NOT NULL,
+    cost_usd REAL NOT NULL,
+    at TEXT NOT NULL
+  );
+  CREATE INDEX usage_user ON usage (user_id, at);
+
+  CREATE TABLE notices (
+    key TEXT PRIMARY KEY,
+    at TEXT NOT NULL
+  );
+
+  DROP INDEX users_usr_subject;
+  ALTER TABLE users DROP COLUMN usr_subject;
   `
 ];
 var BUSY_TIMEOUT_MS = 5000;
@@ -4153,212 +4869,33 @@ function openDatabase(path) {
     db.exec("PRAGMA secure_delete = ON");
     migrate(db);
     return db;
-  } catch (err) {
-    db.close();
-    throw err;
-  }
-}
-var META_TABLE = "tracker_meta";
-var VACUUMED = "vacuumed_for_secure_delete";
-function vacuumOnce(db, path) {
-  if (path === ":memory:")
-    return { ran: false };
-  try {
-    db.exec(`CREATE TABLE IF NOT EXISTS ${META_TABLE} (key TEXT PRIMARY KEY, value TEXT NOT NULL)`);
-    if (db.query(`SELECT 1 FROM ${META_TABLE} WHERE key = ?`).get(VACUUMED) !== null)
-      return { ran: false };
-    db.exec("PRAGMA busy_timeout = 0");
-    try {
-      db.exec("VACUUM");
-      const r = db.query("PRAGMA wal_checkpoint(TRUNCATE)").get();
-      if (r && Number(r.busy) !== 0)
-        throw new Error("the write-ahead log is busy");
-    } finally {
-      db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`);
-    }
-    db.query(`INSERT INTO ${META_TABLE} (key, value) VALUES (?, ?)`).run(VACUUMED, new Date().toISOString());
-    return { ran: true };
-  } catch (err) {
-    return { ran: false, error: err instanceof Error ? err.message : String(err) };
-  }
-}
-
-// plugins/tracker/src/roster.ts
-var FORGOTTEN = "forgotten";
-function historyNames(kind, detail, id) {
-  switch (kind) {
-    case "recipient_invited":
-    case "recipient_accepted":
-    case "recipient_declined":
-    case "recipient_opted_out":
-      return detail === id;
-    case "blocked":
-      return detail === `${id} 24h` || detail === `${id} permanent`;
-    case "recipient_removed":
-      return detail.startsWith(`${id}: `);
-    case "paused":
-      return detail.startsWith(`delivery to {${id}} paused:`);
-    default:
-      return false;
-  }
-}
-function eventNames(type, text, id) {
-  return type === "delivered" && text.startsWith(`${id} `);
-}
-function errorForms(id) {
-  return new RegExp(`(recipient |user |delivery to )${id}(?![0-9A-Za-z_])`, "g");
-}
-function errorNames(text, id) {
-  return text !== null && errorForms(id).test(text);
-}
-function redactError(text, id) {
-  return text.replace(errorForms(id), `$1(${FORGOTTEN})`);
-}
-
-class Roster {
-  db;
-  constructor(db) {
-    this.db = db;
-  }
-  people() {
-    const rows = this.db.query(`SELECT u.seq, u.discord_id, u.display_name, u.time_zone, u.preferred_hour, u.admin, u.created_at,
-                a.admitted_by, a.registered_at, h.paused_at, h.failures
-         FROM users u
-         LEFT JOIN admissions a ON a.user_id = 'u' || u.seq
-         LEFT JOIN delivery_health h ON h.user_id = 'u' || u.seq
-         ORDER BY u.seq`).all();
-    const owned = this.db.query("SELECT owner_id, status, COUNT(*) AS n FROM tasks GROUP BY owner_id, status").all();
-    const receiving = this.db.query(`SELECT r.user_id, COUNT(*) AS n FROM task_recipients r JOIN tasks t ON r.task_id = 't' || t.seq
-         WHERE r.state = 'accepted' AND t.status IN ('active', 'paused') GROUP BY r.user_id`).all();
-    return rows.map((r) => {
-      const id = `u${Number(r.seq)}`;
-      const counts = { active: 0, paused: 0, done: 0, archived: 0 };
-      for (const o of owned)
-        if (o.owner_id === id && o.status in counts)
-          counts[o.status] = Number(o.n);
-      const str = (v) => v === null || v === undefined ? null : String(v);
-      return {
-        id,
-        discordId: str(r.discord_id),
-        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),
-        admittedBy: str(r.admitted_by),
-        registeredAt: str(r.registered_at),
-        deliveryPausedAt: str(r.paused_at),
-        failures: Number(r.failures ?? 0),
-        owned: counts,
-        receiving: Number(receiving.find((x) => x.user_id === id)?.n ?? 0)
-      };
-    });
-  }
-  checkpoint() {
-    this.db.exec("PRAGMA busy_timeout = 0");
-    try {
-      const r = this.db.query("PRAGMA wal_checkpoint(TRUNCATE)").get();
-      return !r || Number(r.busy) === 0;
-    } finally {
-      this.db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`);
-    }
-  }
-  othersNamed(taskId, userId, name) {
-    const ids = new Set;
-    for (const r of this.db.query("SELECT user_id FROM task_recipients WHERE task_id = ?").all(taskId))
-      ids.add(r.user_id);
-    for (const r of this.db.query("SELECT detail FROM task_events WHERE task_id = ? AND kind LIKE 'recipient_%'").all(taskId)) {
-      const id = /^(u[1-9][0-9]*)(:|$)/.exec(r.detail)?.[1];
-      if (id)
-        ids.add(id);
-    }
-    ids.delete(userId);
-    const named = this.db.query("SELECT 1 FROM users WHERE seq = ? AND display_name = ?");
-    return [...ids].some((id) => named.get(Number(id.slice(1)), name) !== null);
-  }
-  admins() {
-    return this.db.query("SELECT COUNT(*) AS n FROM users WHERE admin = 1").get().n;
-  }
-  activeBlocks(now) {
-    const rows = this.db.query(`SELECT seq, owner_id, recipient_id, expires_at, created_at FROM invite_blocks
-         WHERE lifted_at IS NULL AND (expires_at IS NULL OR expires_at > ?) ORDER BY seq DESC`).all(now.toISOString());
-    return rows.map((r) => ({
-      id: `b${Number(r.seq)}`,
-      ownerId: String(r.owner_id),
-      recipientId: String(r.recipient_id),
-      expiresAt: r.expires_at === null ? null : String(r.expires_at),
-      createdAt: String(r.created_at)
-    }));
-  }
-  erase(userId) {
-    const seq = /^u([1-9][0-9]*)$/.exec(userId)?.[1];
-    if (seq === undefined)
-      throw new Error(`no user ${userId}`);
-    return this.db.transaction(() => {
-      const person = this.db.query("SELECT display_name FROM users WHERE seq = ?").get(Number(seq));
-      if (!person)
-        throw new Error(`no user ${userId}`);
-      const rows = {};
-      const del = (table, where, ...params) => {
-        rows[table] = (rows[table] ?? 0) + this.db.query(`DELETE FROM ${table} WHERE ${where}`).run(...params).changes;
-      };
-      const THEIR_TASKS = "SELECT 't' || seq FROM tasks WHERE owner_id = ?";
-      const THEIR_RUNS = `SELECT 'o' || seq FROM occurrences WHERE task_id IN (${THEIR_TASKS})`;
-      const pausedFor = this.db.query(`SELECT task_id FROM delivery_pauses WHERE user_id = ? AND task_id NOT IN (${THEIR_TASKS})`).all(userId, userId).map((r) => r.task_id);
-      const taskIds = (sql) => this.db.query(sql).all(userId).map((r) => r.t);
-      const recipientOf = new Set([
-        ...pausedFor,
-        ...taskIds("SELECT task_id AS t FROM task_recipients WHERE user_id = ?"),
-        ...this.db.query("SELECT task_id AS t, kind, detail FROM task_events WHERE instr(detail, ?) > 0").all(userId).filter((r) => historyNames(r.kind, r.detail, userId)).map((r) => r.t)
-      ]);
-      del("events", `occurrence_id IN (${THEIR_RUNS})`, userId);
-      del("delivery_claims", `occurrence_id IN (${THEIR_RUNS}) OR user_id = ?`, userId, userId);
-      del("replies", `task_id IN (${THEIR_TASKS}) OR user_id = ?`, userId, userId);
-      del("task_events", `task_id IN (${THEIR_TASKS}) OR actor_id = ?`, userId, userId);
-      del("series", `task_id IN (${THEIR_TASKS})`, userId);
-      del("task_recipients", `task_id IN (${THEIR_TASKS}) OR user_id = ?`, userId, userId);
-      del("delivery_pauses", `task_id IN (${THEIR_TASKS}) OR user_id = ?`, userId, userId);
-      del("occurrences", `task_id IN (${THEIR_TASKS})`, userId);
-      del("tasks", "owner_id = ?", userId);
-      const containing = (table, columns, column) => this.db.query(`SELECT seq, ${columns} FROM ${table} WHERE instr(${column}, ?) > 0`).all(userId);
-      for (const r of containing("task_events", "kind, detail", "detail")) {
-        if (historyNames(String(r.kind), String(r.detail), userId))
-          del("task_events", "seq = ?", Number(r.seq));
-      }
-      for (const r of containing("events", "type, text", "text")) {
-        if (eventNames(String(r.type), String(r.text), userId))
-          del("events", "seq = ?", Number(r.seq));
-        else if (errorNames(String(r.text), userId))
-          this.db.query("UPDATE events SET text = ? WHERE seq = ?").run(redactError(String(r.text), userId), r.seq);
-      }
-      for (const r of containing("occurrences", "error", "error")) {
-        if (errorNames(String(r.error), userId))
-          this.db.query("UPDATE occurrences SET error = ? WHERE seq = ?").run(redactError(String(r.error), userId), r.seq);
-      }
-      if (person.display_name !== null) {
-        const legacy = `delivery to ${person.display_name} paused:`;
-        const rowsNaming = this.db.query("SELECT seq, task_id, detail FROM task_events WHERE kind = 'paused' AND actor_id IS NULL").all();
-        for (const r of rowsNaming) {
-          if (!recipientOf.has(r.task_id) || !r.detail.startsWith(legacy))
-            continue;
-          if (this.othersNamed(r.task_id, userId, person.display_name))
-            continue;
-          del("task_events", "seq = ?", r.seq);
-        }
-      }
-      del("invite_blocks", "owner_id = ? OR recipient_id = ?", userId, userId);
-      this.db.query("UPDATE invite_blocks SET lifted_by = ? WHERE lifted_by = ?").run(FORGOTTEN, userId);
-      del("admissions", "user_id = ?", userId);
-      this.db.query("UPDATE admissions SET admitted_by = ? WHERE admitted_by = ?").run(FORGOTTEN, userId);
-      del("delivery_health", "user_id = ?", userId);
-      del("web_sessions", "user_id = ?", userId);
-      del("web_login_tokens", "user_id = ?", userId);
-      del("api_tokens", "user_id = ?", userId);
-      del("users", "seq = ?", Number(seq));
-      const held = this.db.query("SELECT 1 FROM delivery_pauses WHERE task_id = ? LIMIT 1");
-      const freed = [...new Set(pausedFor)].filter((t) => held.get(t) === null);
-      return { rows, freed };
-    })();
+  } catch (err) {
+    db.close();
+    throw err;
+  }
+}
+var META_TABLE = "tracker_meta";
+var VACUUMED = "vacuumed_for_secure_delete";
+function vacuumOnce(db, path) {
+  if (path === ":memory:")
+    return { ran: false };
+  try {
+    db.exec(`CREATE TABLE IF NOT EXISTS ${META_TABLE} (key TEXT PRIMARY KEY, value TEXT NOT NULL)`);
+    if (db.query(`SELECT 1 FROM ${META_TABLE} WHERE key = ?`).get(VACUUMED) !== null)
+      return { ran: false };
+    db.exec("PRAGMA busy_timeout = 0");
+    try {
+      db.exec("VACUUM");
+      const r = db.query("PRAGMA wal_checkpoint(TRUNCATE)").get();
+      if (r && Number(r.busy) !== 0)
+        throw new Error("the write-ahead log is busy");
+    } finally {
+      db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`);
+    }
+    db.query(`INSERT INTO ${META_TABLE} (key, value) VALUES (?, ?)`).run(VACUUMED, new Date().toISOString());
+    return { ran: true };
+  } catch (err) {
+    return { ran: false, error: err instanceof Error ? err.message : String(err) };
   }
 }
 
@@ -4387,7 +4924,6 @@ 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),
@@ -4440,6 +4976,7 @@ function toOccurrence(r) {
     summary: str(r.summary),
     costUsd: r.cost_usd === null || r.cost_usd === undefined ? null : Number(r.cost_usd),
     error: str(r.error),
+    record: r.record === null || r.record === undefined ? null : parse(r.record),
     createdAt: String(r.created_at)
   };
 }
@@ -4475,7 +5012,37 @@ function toReply(r) {
   };
 }
 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) };
+  return { id: idOf("s", r.seq), taskId: String(r.task_id), key: str(r.key), at: String(r.at), value: Number(r.value), unit: str(r.unit), note: str(r.note) };
+}
+function toUsage(r) {
+  return {
+    id: idOf("c", r.seq),
+    userId: String(r.user_id),
+    taskId: str(r.task_id),
+    occurrenceId: str(r.occurrence_id),
+    source: String(r.source),
+    calls: Number(r.calls),
+    costUsd: Number(r.cost_usd),
+    at: String(r.at)
+  };
+}
+function toDelivery(r) {
+  return {
+    occurrenceId: String(r.occurrence_id),
+    userId: String(r.user_id),
+    status: String(r.status),
+    messageId: str(r.message_id),
+    error: str(r.error),
+    attempts: Number(r.attempts),
+    deferrals: Number(r.deferrals),
+    retryAt: str(r.retry_at),
+    createdAt: String(r.created_at),
+    claimedAt: str(r.claimed_at),
+    settledAt: str(r.settled_at)
+  };
+}
+function deleteDeliveriesOf(db, userId) {
+  return db.query("DELETE FROM deliveries WHERE user_id = ?").run(userId).changes;
 }
 
 class SqliteStore {
@@ -4510,13 +5077,9 @@ class SqliteStore {
     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);
+    const { lastInsertRowid } = this.run(`INSERT INTO users (discord_id, display_name, time_zone, preferred_hour, admin, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`, u.discordId ?? 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) {
@@ -4524,16 +5087,19 @@ class SqliteStore {
     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));
+    this.run(`UPDATE users SET discord_id = ?, display_name = ?, time_zone = ?, preferred_hour = ?, admin = ?
+       WHERE seq = ?`, next.discordId, next.displayName, next.timeZone, next.preferredHour, next.admin ? 1 : 0, seqOf("u", id));
     return toUser(this.mustGet("users", "u", id, "user"));
   }
+  async listUsers(filter = {}) {
+    const rows = filter.admin === undefined ? this.all("SELECT * FROM users ORDER BY seq") : this.all("SELECT * FROM users WHERE admin = ? ORDER BY seq", filter.admin ? 1 : 0);
+    return rows.map(toUser);
+  }
   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);
@@ -4625,28 +5191,56 @@ class SqliteStore {
     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));
+    this.mustGet("occurrences", "o", id, "occurrence");
+    this.patchOccurrence(id, patch, null);
     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 updateOccurrenceIf(id, expected, patch) {
+    if (!this.patchOccurrence(id, patch, expected))
+      return null;
+    return toOccurrence(this.mustGet("occurrences", "o", id, "occurrence"));
+  }
+  patchOccurrence(id, patch, expected) {
+    const seq = seqOf("o", id);
+    if (seq === null)
+      return false;
+    const sets = [];
+    const params = [];
+    const set = (column, value) => (sets.push(`${column} = ?`), params.push(value));
+    if (patch.status !== undefined)
+      set("status", patch.status);
+    if (patch.startedAt !== undefined)
+      set("started_at", patch.startedAt);
+    if (patch.finishedAt !== undefined)
+      set("finished_at", patch.finishedAt);
+    if (patch.late !== undefined)
+      set("late", patch.late ? 1 : 0);
+    if (patch.summary !== undefined)
+      set("summary", patch.summary);
+    if (patch.costUsd !== undefined)
+      set("cost_usd", patch.costUsd);
+    if (patch.error !== undefined)
+      set("error", patch.error);
+    if (patch.record !== undefined)
+      set("record", patch.record === null ? null : json(patch.record));
+    if (sets.length === 0)
+      sets.push("seq = seq");
+    params.push(seq);
+    const guard = expected === null ? "" : " AND status = ?";
+    if (expected !== null)
+      params.push(expected);
+    return this.run(`UPDATE occurrences SET ${sets.join(", ")} WHERE seq = ?${guard}`, ...params).changes > 0;
+  }
+  async deleteOccurrence(id) {
+    const seq = seqOf("o", id);
+    if (seq === null)
+      return false;
+    return this.run("DELETE FROM occurrences WHERE seq = ? AND status = 'queued'", seq).changes > 0;
   }
   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);
+      this.run("UPDATE occurrences SET status = 'queued', started_at = NULL WHERE seq = ? AND status = 'running'", r.seq);
     return rows.map((r) => idOf("o", r.seq));
   }
   async addEvent(e) {
@@ -4672,7 +5266,14 @@ class SqliteStore {
     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);
+    const key = p.key ?? null;
+    const { changes, lastInsertRowid } = this.run("INSERT INTO series (task_id, key, at, value, unit, note) VALUES (?, ?, ?, ?, ?, ?) ON CONFLICT (key) WHERE key IS NOT NULL DO NOTHING", p.taskId, key, p.at, p.value, p.unit ?? null, p.note ?? null);
+    if (changes === 0) {
+      const known = this.one("SELECT * FROM series WHERE key = ?", key);
+      if (!known)
+        throw new Error(`series point ${key} was neither added nor found`);
+      return toPoint(known);
+    }
     return toPoint(this.mustGet("series", "s", idOf("s", lastInsertRowid), "series point"));
   }
   async listSeries(taskId, filter = {}) {
@@ -4680,6 +5281,246 @@ class SqliteStore {
     const kept = filter.limit === undefined ? points : points.slice(-filter.limit);
     return kept.map(toPoint);
   }
+  async addUsage(u) {
+    const { lastInsertRowid } = this.run("INSERT INTO usage (user_id, task_id, occurrence_id, source, calls, cost_usd, at) VALUES (?, ?, ?, ?, ?, ?, ?)", u.userId, u.taskId, u.occurrenceId, u.source, u.calls, u.costUsd, u.at);
+    return toUsage(this.mustGet("usage", "c", idOf("c", lastInsertRowid), "usage"));
+  }
+  async listUsage(filter = {}) {
+    const where = [];
+    const params = [];
+    if (filter.userId !== undefined)
+      where.push("user_id = ?"), params.push(filter.userId);
+    if (filter.since !== undefined)
+      where.push("at >= ?"), params.push(filter.since);
+    if (filter.before !== undefined)
+      where.push("at < ?"), params.push(filter.before);
+    const clause = where.length > 0 ? `WHERE ${where.join(" AND ")}` : "";
+    return this.all(`SELECT * FROM usage ${clause} ORDER BY at, seq`, ...params).map(toUsage);
+  }
+  async claimNotice(key, at) {
+    return this.run("INSERT INTO notices (key, at) VALUES (?, ?) ON CONFLICT (key) DO NOTHING", key, at).changes === 1;
+  }
+  delivery(occurrenceId, userId) {
+    const r = this.one("SELECT * FROM deliveries WHERE occurrence_id = ? AND user_id = ?", occurrenceId, userId);
+    return r ? toDelivery(r) : null;
+  }
+  async planDelivery(occurrenceId, userId, at) {
+    const { changes } = this.run(`INSERT INTO deliveries (occurrence_id, user_id, status, attempts, deferrals, retry_at, created_at)
+       VALUES (?, ?, 'pending', 0, 0, ?, ?)
+       ON CONFLICT (occurrence_id, user_id) DO NOTHING`, occurrenceId, userId, at, at);
+    return changes === 1 ? this.delivery(occurrenceId, userId) : null;
+  }
+  async claimDelivery(occurrenceId, userId, at) {
+    const { changes } = this.run(`UPDATE deliveries SET status = 'claimed', claimed_at = ?, retry_at = NULL
+       WHERE occurrence_id = ? AND user_id = ? AND retry_at IS NOT NULL`, at, occurrenceId, userId);
+    return changes === 1 ? this.delivery(occurrenceId, userId) : null;
+  }
+  async settleDelivery(occurrenceId, userId, settle) {
+    const { changes } = this.run(`UPDATE deliveries SET status = ?, message_id = ?, error = ?, attempts = ?, deferrals = ?, retry_at = ?, settled_at = ?
+       WHERE occurrence_id = ? AND user_id = ?`, settle.status, settle.messageId ?? null, settle.error ?? null, settle.attempts, settle.deferrals, settle.retryAt, settle.at, occurrenceId, userId);
+    if (changes === 0)
+      throw new Error(`no delivery ${occurrenceId}:${userId}`);
+    return this.delivery(occurrenceId, userId);
+  }
+  async listDeliveries(filter = {}) {
+    const where = [];
+    const params = [];
+    if (filter.occurrenceId !== undefined)
+      where.push("occurrence_id = ?"), params.push(filter.occurrenceId);
+    if (filter.userId !== undefined)
+      where.push("user_id = ?"), params.push(filter.userId);
+    if (filter.status !== undefined)
+      where.push("status = ?"), params.push(filter.status);
+    if (filter.dueBefore !== undefined)
+      where.push("retry_at IS NOT NULL AND retry_at <= ?"), params.push(filter.dueBefore);
+    const clause = where.length > 0 ? `WHERE ${where.join(" AND ")}` : "";
+    return this.all(`SELECT * FROM deliveries ${clause} ORDER BY created_at, seq`, ...params).map(toDelivery);
+  }
+  async deleteDeliveries(userId) {
+    return deleteDeliveriesOf(this.db, userId);
+  }
+}
+
+// plugins/tracker/src/roster.ts
+var FORGOTTEN = "forgotten";
+function historyNames(kind, detail, id) {
+  switch (kind) {
+    case "recipient_invited":
+    case "recipient_accepted":
+    case "recipient_declined":
+    case "recipient_opted_out":
+      return detail === id;
+    case "blocked":
+      return detail === `${id} 24h` || detail === `${id} permanent`;
+    case "recipient_removed":
+      return detail.startsWith(`${id}: `);
+    case "paused":
+      return detail.startsWith(`delivery to {${id}} paused:`);
+    default:
+      return false;
+  }
+}
+function eventNames(type, text, id) {
+  return type === "delivered" && text.startsWith(`${id} `);
+}
+function errorForms(id) {
+  return new RegExp(`(recipient |user |delivery to )${id}(?![0-9A-Za-z_])`, "g");
+}
+function errorNames(text, id) {
+  return text !== null && errorForms(id).test(text);
+}
+function redactError(text, id) {
+  return text.replace(errorForms(id), `$1(${FORGOTTEN})`);
+}
+
+class Roster {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  people() {
+    const rows = this.db.query(`SELECT u.seq, u.discord_id, u.display_name, u.time_zone, u.preferred_hour, u.admin, u.created_at,
+                a.admitted_by, a.registered_at, h.paused_at, h.failures
+         FROM users u
+         LEFT JOIN admissions a ON a.user_id = 'u' || u.seq
+         LEFT JOIN delivery_health h ON h.user_id = 'u' || u.seq
+         ORDER BY u.seq`).all();
+    const owned = this.db.query("SELECT owner_id, status, COUNT(*) AS n FROM tasks GROUP BY owner_id, status").all();
+    const receiving = this.db.query(`SELECT r.user_id, COUNT(*) AS n FROM task_recipients r JOIN tasks t ON r.task_id = 't' || t.seq
+         WHERE r.state = 'accepted' AND t.status IN ('active', 'paused') GROUP BY r.user_id`).all();
+    return rows.map((r) => {
+      const id = `u${Number(r.seq)}`;
+      const counts = { active: 0, paused: 0, done: 0, archived: 0 };
+      for (const o of owned)
+        if (o.owner_id === id && o.status in counts)
+          counts[o.status] = Number(o.n);
+      const str = (v) => v === null || v === undefined ? null : String(v);
+      return {
+        id,
+        discordId: str(r.discord_id),
+        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),
+        admittedBy: str(r.admitted_by),
+        registeredAt: str(r.registered_at),
+        deliveryPausedAt: str(r.paused_at),
+        failures: Number(r.failures ?? 0),
+        owned: counts,
+        receiving: Number(receiving.find((x) => x.user_id === id)?.n ?? 0)
+      };
+    });
+  }
+  checkpoint() {
+    this.db.exec("PRAGMA busy_timeout = 0");
+    try {
+      const r = this.db.query("PRAGMA wal_checkpoint(TRUNCATE)").get();
+      return !r || Number(r.busy) === 0;
+    } finally {
+      this.db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`);
+    }
+  }
+  othersNamed(taskId, userId, name) {
+    const ids = new Set;
+    for (const r of this.db.query("SELECT user_id FROM task_recipients WHERE task_id = ?").all(taskId))
+      ids.add(r.user_id);
+    for (const r of this.db.query("SELECT detail FROM task_events WHERE task_id = ? AND kind LIKE 'recipient_%'").all(taskId)) {
+      const id = /^(u[1-9][0-9]*)(:|$)/.exec(r.detail)?.[1];
+      if (id)
+        ids.add(id);
+    }
+    ids.delete(userId);
+    const named = this.db.query("SELECT 1 FROM users WHERE seq = ? AND display_name = ?");
+    return [...ids].some((id) => named.get(Number(id.slice(1)), name) !== null);
+  }
+  admins() {
+    return this.db.query("SELECT COUNT(*) AS n FROM users WHERE admin = 1").get().n;
+  }
+  activeBlocks(now) {
+    const rows = this.db.query(`SELECT seq, owner_id, recipient_id, expires_at, created_at FROM invite_blocks
+         WHERE lifted_at IS NULL AND (expires_at IS NULL OR expires_at > ?) ORDER BY seq DESC`).all(now.toISOString());
+    return rows.map((r) => ({
+      id: `b${Number(r.seq)}`,
+      ownerId: String(r.owner_id),
+      recipientId: String(r.recipient_id),
+      expiresAt: r.expires_at === null ? null : String(r.expires_at),
+      createdAt: String(r.created_at)
+    }));
+  }
+  erase(userId) {
+    const seq = /^u([1-9][0-9]*)$/.exec(userId)?.[1];
+    if (seq === undefined)
+      throw new Error(`no user ${userId}`);
+    return this.db.transaction(() => {
+      const person = this.db.query("SELECT display_name FROM users WHERE seq = ?").get(Number(seq));
+      if (!person)
+        throw new Error(`no user ${userId}`);
+      const rows = {};
+      const del = (table, where, ...params) => {
+        rows[table] = (rows[table] ?? 0) + this.db.query(`DELETE FROM ${table} WHERE ${where}`).run(...params).changes;
+      };
+      const THEIR_TASKS = "SELECT 't' || seq FROM tasks WHERE owner_id = ?";
+      const THEIR_RUNS = `SELECT 'o' || seq FROM occurrences WHERE task_id IN (${THEIR_TASKS})`;
+      const pausedFor = this.db.query(`SELECT task_id FROM delivery_pauses WHERE user_id = ? AND task_id NOT IN (${THEIR_TASKS})`).all(userId, userId).map((r) => r.task_id);
+      const taskIds = (sql) => this.db.query(sql).all(userId).map((r) => r.t);
+      const recipientOf = new Set([
+        ...pausedFor,
+        ...taskIds("SELECT task_id AS t FROM task_recipients WHERE user_id = ?"),
+        ...this.db.query("SELECT task_id AS t, kind, detail FROM task_events WHERE instr(detail, ?) > 0").all(userId).filter((r) => historyNames(r.kind, r.detail, userId)).map((r) => r.t)
+      ]);
+      del("events", `occurrence_id IN (${THEIR_RUNS})`, userId);
+      del("deliveries", `occurrence_id IN (${THEIR_RUNS})`, userId);
+      rows.deliveries = (rows.deliveries ?? 0) + deleteDeliveriesOf(this.db, userId);
+      del("usage", `task_id IN (${THEIR_TASKS}) OR user_id = ?`, userId, userId);
+      del("replies", `task_id IN (${THEIR_TASKS}) OR user_id = ?`, userId, userId);
+      del("task_events", `task_id IN (${THEIR_TASKS}) OR actor_id = ?`, userId, userId);
+      del("series", `task_id IN (${THEIR_TASKS})`, userId);
+      del("task_recipients", `task_id IN (${THEIR_TASKS}) OR user_id = ?`, userId, userId);
+      del("delivery_pauses", `task_id IN (${THEIR_TASKS}) OR user_id = ?`, userId, userId);
+      del("occurrences", `task_id IN (${THEIR_TASKS})`, userId);
+      del("tasks", "owner_id = ?", userId);
+      const containing = (table, columns, column) => this.db.query(`SELECT seq, ${columns} FROM ${table} WHERE instr(${column}, ?) > 0`).all(userId);
+      for (const r of containing("task_events", "kind, detail", "detail")) {
+        if (historyNames(String(r.kind), String(r.detail), userId))
+          del("task_events", "seq = ?", Number(r.seq));
+      }
+      for (const r of containing("events", "type, text", "text")) {
+        if (eventNames(String(r.type), String(r.text), userId))
+          del("events", "seq = ?", Number(r.seq));
+        else if (errorNames(String(r.text), userId))
+          this.db.query("UPDATE events SET text = ? WHERE seq = ?").run(redactError(String(r.text), userId), r.seq);
+      }
+      for (const r of containing("occurrences", "error", "error")) {
+        if (errorNames(String(r.error), userId))
+          this.db.query("UPDATE occurrences SET error = ? WHERE seq = ?").run(redactError(String(r.error), userId), r.seq);
+      }
+      if (person.display_name !== null) {
+        const legacy = `delivery to ${person.display_name} paused:`;
+        const rowsNaming = this.db.query("SELECT seq, task_id, detail FROM task_events WHERE kind = 'paused' AND actor_id IS NULL").all();
+        for (const r of rowsNaming) {
+          if (!recipientOf.has(r.task_id) || !r.detail.startsWith(legacy))
+            continue;
+          if (this.othersNamed(r.task_id, userId, person.display_name))
+            continue;
+          del("task_events", "seq = ?", r.seq);
+        }
+      }
+      del("invite_blocks", "owner_id = ? OR recipient_id = ?", userId, userId);
+      this.db.query("UPDATE invite_blocks SET lifted_by = ? WHERE lifted_by = ?").run(FORGOTTEN, userId);
+      del("admissions", "user_id = ?", userId);
+      this.db.query("UPDATE admissions SET admitted_by = ? WHERE admitted_by = ?").run(FORGOTTEN, userId);
+      del("delivery_health", "user_id = ?", userId);
+      del("web_sessions", "user_id = ?", userId);
+      del("web_login_tokens", "user_id = ?", userId);
+      del("api_tokens", "user_id = ?", userId);
+      del("notices", "key LIKE 'budget:person:' || ? || ':%'", userId);
+      del("users", "seq = ?", Number(seq));
+      const held = this.db.query("SELECT 1 FROM delivery_pauses WHERE task_id = ? LIMIT 1");
+      const freed = [...new Set(pausedFor)].filter((t) => held.get(t) === null);
+      return { rows, freed };
+    })();
+  }
 }
 
 // plugins/tracker/src/admin.ts
@@ -6831,7 +7672,7 @@ async function applyEdit(d, task, user, patch) {
 }
 async function nextRun(d, task) {
   const queued = await d.store.listOccurrences({ taskId: task.id, status: "queued" });
-  return queued[0] ?? null;
+  return queued.find((o) => !hasFired(o)) ?? null;
 }
 function savedText(task, user, next, now, what) {
   const cadence = task.schedule ? describeSchedule(task.schedule, user, user.timeZone, now) : "no schedule";
@@ -6839,7 +7680,10 @@ function savedText(task, user, next, now, what) {
   return clip(`Saved \`${task.id}\` ${what}: ${cadence}. Next: ${when}.`);
 }
 var blank = (v) => v === undefined || v.trim() === "";
-async function editReminder(d, user, taskId, input) {
+function editReminder(d, user, taskId, input) {
+  return d.locks.run(taskId.trim(), () => editReminderLocked(d, user, taskId, input));
+}
+async function editReminderLocked(d, user, taskId, input) {
   const task = await owned(d, user, taskId, "reminder");
   if (typeof task === "string")
     return { ok: false, error: task };
@@ -6883,10 +7727,13 @@ async function askedAbout(d, task, owner, date) {
   const old = task.schedule;
   if (old?.kind !== "period")
     return false;
-  const fired = (await d.store.listOccurrences({ taskId: task.id })).filter((o) => o.status !== "queued" && !o.dedupeKey.startsWith(SNOOZE_PREFIX));
+  const fired = (await d.store.listOccurrences({ taskId: task.id })).filter((o) => (o.status !== "queued" || hasFired(o)) && !o.dedupeKey.startsWith(SNOOZE_PREFIX));
   return fired.some((o) => periodDate(old, new Date(o.dueAt), owner.timeZone) === date);
 }
-async function editRenewal(d, user, taskId, input) {
+function editRenewal(d, user, taskId, input) {
+  return d.locks.run(taskId.trim(), () => editRenewalLocked(d, user, taskId, input));
+}
+async function editRenewalLocked(d, user, taskId, input) {
   const task = await owned(d, user, taskId, "renewal");
   if (typeof task === "string")
     return { ok: false, error: task };
@@ -6935,7 +7782,10 @@ async function editRenewal(d, user, taskId, input) {
   const cadence = describeSchedule(schedule, user, user.timeZone, now);
   return { ok: true, task: updated, text: clip(`Saved \`${updated.id}\` (renewal): ${cadence}. Next ask: ${ask}.`) };
 }
-async function editPrice(d, user, taskId, input) {
+function editPrice(d, user, taskId, input) {
+  return d.locks.run(taskId.trim(), () => editPriceLocked(d, user, taskId, input));
+}
+async function editPriceLocked(d, user, taskId, input) {
   const task = await owned(d, user, taskId, "price");
   if (typeof task === "string")
     return { ok: false, error: task };
@@ -7248,7 +8098,7 @@ async function nextAt(d, task) {
   if (task.status !== "active")
     return null;
   const queued = await d.store.listOccurrences({ taskId: task.id, status: "queued" });
-  return queued[0]?.dueAt ?? null;
+  return queued.find((o) => !hasFired(o))?.dueAt ?? null;
 }
 async function taskJson(d, user, task) {
   const type = EDITOR_TYPES.includes(task.type) ? task.type : null;
@@ -7778,7 +8628,7 @@ function createWebHandler(w) {
     return lookupWithin(() => shared, MEMBER_CHECK_TIMEOUT_MS);
   }
   async function recheck(d, user, checkedAt) {
-    if (w.guildId === null)
+    if (w.guildIds === null)
       return "ok";
     const now = d.clock.now().getTime();
     const age = checkedAt ? now - Date.parse(checkedAt) : Number.POSITIVE_INFINITY;
@@ -7818,7 +8668,7 @@ function createWebHandler(w) {
     return { kind: "signed-out", note: RECHECK_FAILED };
   }
   async function memberOf(discordId) {
-    if (w.guildId === null)
+    if (w.guildIds === null)
       return "not-checked";
     return await lookupWithin(() => w.membership(discordId), MEMBER_CHECK_TIMEOUT_MS) ?? "unknown";
   }
@@ -8019,12 +8869,12 @@ var TRACKER_TYPES = Object.freeze({
 });
 var NO_DM = {
   async sendDm() {
-    throw new Error("this bot has no host.dm (rackbops-discord-bot#736)");
+    throw new DeliveryFailedError("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 guildIds = parseGuildIds(host.env.TRACKER_GUILD_ID);
   const webOrigin = parseWebUrl(host.env.TRACKER_WEB_URL);
   const clock = options.clock ?? { now: () => new Date };
   const types = options.types ?? TRACKER_TYPES;
@@ -8032,26 +8882,26 @@ function createPlugin(host, options = {}) {
   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 queue = serial();
+  const locks = new TaskLocks;
   const surface = createSurface({
     deps: () => deps,
-    guildId,
+    guildIds,
     log: host.log,
     queue,
-    web: webOrigin ? { origin: webOrigin, name: host.name, gated: guildId !== null } : null,
+    web: webOrigin ? { origin: webOrigin, name: host.name, gated: guildIds !== null } : null,
     ...options.membership ? { membership: options.membership } : {}
   });
   async function tick(kind, signal) {
-    if (!store || !claims)
+    if (!store)
       return;
     const outcome = await runNotifyTick({
       store,
-      claims,
+      locks,
       clock,
       types,
       dm,
@@ -8105,14 +8955,14 @@ function createPlugin(host, options = {}) {
   const clientMembership = async (discordId) => {
     if (!discordClient)
       return null;
-    return lookupMembership({ guildId: null, user: { id: discordId }, client: discordClient }, guildId, discordId, host.log);
+    return lookupMembership({ guildId: null, user: { id: discordId }, client: discordClient }, guildIds, discordId, host.log);
   };
   const web = createWebHandler({
     name: host.name,
     origin: webOrigin,
     deps: () => deps,
     queue,
-    guildId,
+    guildIds,
     membership: options.webMembership ?? clientMembership
   });
   const interactions = surface.interactions;
@@ -8137,7 +8987,6 @@ function createPlugin(host, options = {}) {
       }
       const opened = openDatabase(path);
       const openedStore = new SqliteStore(opened);
-      const openedClaims = new ClaimStore(opened);
       try {
         const vacuum = vacuumOnce(opened, path);
         if ("error" in vacuum)
@@ -8151,18 +9000,20 @@ function createPlugin(host, options = {}) {
         }
         if (granted.length > 0)
           host.log.info(`made ${granted.length} admin(s) from TRACKER_ADMIN_DISCORD_IDS`);
-        const requeued = await openedStore.requeueRunning();
+        const open = await openedStore.listDeliveries({ status: "claimed" });
+        const requeued = await new Lanes({ store: openedStore, clock, types, notifier: NO_DM }).recover();
         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());
+        for (const c of open) {
+          const why = c.error ? ` (${c.error})` : "";
+          host.log.warn(`delivery of ${c.occurrenceId} to ${c.userId} claimed ${c.claimedAt ?? "?"} is unconfirmed${why}; it will not be resent`);
+        }
       } catch (err) {
         opened.close();
         throw err;
       }
       db = opened;
       store = openedStore;
-      claims = openedClaims;
       delivery = new DeliveryHealth(opened, openedStore, {
         log: host.log,
         ...dm ? {
@@ -8181,7 +9032,8 @@ function createPlugin(host, options = {}) {
         fetch: pageFetch(),
         dm,
         log: host.log,
-        notifier: dm ? createDmNotifier({ store: openedStore, claims: openedClaims, dm, clock, log: host.log, health: delivery }) : NO_DM,
+        notifier: dm ? createDmNotifier({ store: openedStore, dm, clock, log: host.log, health: delivery }) : NO_DM,
+        locks,
         logins: new LoginLinks(opened),
         sessions: new Sessions(opened),
         apiTokens: new ApiTokens(opened),
@@ -8190,7 +9042,7 @@ function createPlugin(host, options = {}) {
         lanes,
         webEditor: webOrigin !== null
       };
-      if (guildId === null)
+      if (guildIds === 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();
@@ -8200,7 +9052,6 @@ function createPlugin(host, options = {}) {
       deps = null;
       delivery = null;
       store = null;
-      claims = null;
       const closing = db;
       db = null;
       closing?.close();