orzarua 0.5.0 → 0.6.0

package/dist/orzarua.mjs

@@ -7973,8 +7973,8 @@ function cleanRegex(source) {
   const end = source.endsWith("$") ? source.length - 1 : source.length;
   return source.slice(start, end);
 }
-function floatSafeRemainder(val, step) {
-  const ratio = val / step;
+function floatSafeRemainder(val, step2) {
+  const ratio = val / step2;
   const roundedRatio = Math.round(ratio);
   const tolerance = 4 * Number.EPSILON * Math.max(Math.abs(ratio), 1);
   if (Math.abs(ratio - roundedRatio) < tolerance)
@@ -27933,6 +27933,17 @@ var hebrewDateSchema = external_exports.strictObject({
   month: external_exports.number().int().describe("Nisan 1 ... Tishrei 7 ... Adar (Adar I in a leap year) 12, Adar II 13."),
   day: external_exports.number().int().describe("The day of the month, 1 to 30.")
 });
+var HEBREW_RANGES = { year: [3761, 6e3], month: [1, 13], day: [1, 30] };
+var HEBREW_DATE = {
+  type: "object",
+  properties: Object.fromEntries(Object.entries(HEBREW_RANGES).map(([at, [minimum, maximum]]) => [at, { type: "integer", minimum, maximum }])),
+  required: Object.keys(HEBREW_RANGES)
+};
+function hebrewDateShape(v) {
+  if (!isObject2(v)) return null;
+  const { year, month, day: day2 } = v;
+  return isWhole(year, ...HEBREW_RANGES.year) && isWhole(month, ...HEBREW_RANGES.month) && isWhole(day2, ...HEBREW_RANGES.day) ? { year, month, day: day2 } : null;
+}
 var occasionDateShape = {
   civil: civilDate("The civil date as entered"),
   afterSunset: external_exports.boolean().describe("Whether it was after sunset, which moves the Hebrew date to the next day."),
@@ -27986,6 +27997,7 @@ var datesViewSchema = external_exports.strictObject({
 }).readonly();
 var resolveResultSchema = external_exports.strictObject({
   hebrew: hebrewDateSchema.describe("The Hebrew date, after sunset applied."),
+  civil: civilDate("The civil date: the one sent, or for a Hebrew date sent, the civil day whose daytime is that Hebrew day"),
   hebrewWords: external_exports.string().describe('The Hebrew date in words ("14 Adar II 5787").'),
   affects: dateAffectsSchema.describe("Which choices apply to the date."),
   next: occasionOccurrenceSchema.nullable().describe("Its next anniversary on or after today, by the choices sent and the congregation's defaults; null when none falls in the next 390 days.")
@@ -28103,14 +28115,34 @@ function datesBodyUntil(today, office) {
     )
   });
 }
+var RESOLVE_HEBREW = { rule: "hebrewDate", required: false, schema: HEBREW_DATE };
+var HEBREW_SHAPE_WORDS = "date.hebrew must be { year, month, day }: whole numbers, the year 3761 to 6000, the month 1 to 13 (as the siddur numbers them), the day 1 to 30";
+var HEBREW_OR_CIVIL_WORDS = "date.hebrew takes the place of date.civil and date.afterSunset: send one or the other";
 function resolveBodyUntil(today) {
   return external_exports.object({
-    civil: reading({ rule: "civilDate", required: true, schema: PARTS.civil, params: CIVIL_RANGE }, (raw, refuse) => part.civil("date", raw, today, refuse)).describe(`The civil date, YYYY-MM-DD, from ${EARLIEST_OCCASION_DATE} to today in the congregation's time zone; required.`),
-    afterSunset: reading({ rule: "boolean", required: true, schema: PARTS.afterSunset }, (raw, refuse) => part.afterSunset("date", raw, refuse)).describe("Whether it was after sunset (the Hebrew date is then the next day's); required."),
+    // Left out is read here as left out, and refused below unless a Hebrew date takes its place, in the same words and the same order.
+    civil: reading({ rule: "civilDate", required: false, schema: PARTS.civil, params: CIVIL_RANGE }, (raw, refuse) => raw === void 0 ? void 0 : part.civil("date", raw, today, refuse)).describe(`The civil date, YYYY-MM-DD, from ${EARLIEST_OCCASION_DATE} to today in the congregation's time zone; required unless hebrew is sent.`),
+    afterSunset: reading({ rule: "boolean", required: false, schema: PARTS.afterSunset }, (raw, refuse) => raw === void 0 ? void 0 : part.afterSunset("date", raw, refuse)).describe("Whether it was after sunset (the Hebrew date is then the next day's); required unless hebrew is sent."),
     calendar: reading({ rule: "oneOf", required: true, schema: PARTS.calendar }, (raw, refuse) => part.calendar("date", raw, refuse)).describe("civil or hebrew: which calendar its anniversary is kept by; required."),
     adarObservance: reading({ rule: "oneOf", required: false, schema: PARTS.adarObservance }, (raw, refuse) => part.adarObservance("date", raw, refuse)).describe("adar-i or adar-ii, for a date in Adar of a common year; null or left out for any other (a choice it does not allow is refused)."),
-    shortMonthChoice: reading({ rule: "oneOf", required: false, schema: PARTS.shortMonthChoice }, (raw, refuse) => part.shortMonthChoice("date", raw, refuse)).describe(`${OCCASION_SHORT_MONTHS.join(", ")}, for the 30th of Cheshvan or Kislev; null or left out for any other.`)
-  });
+    shortMonthChoice: reading({ rule: "oneOf", required: false, schema: PARTS.shortMonthChoice }, (raw, refuse) => part.shortMonthChoice("date", raw, refuse)).describe(`${OCCASION_SHORT_MONTHS.join(", ")}, for the 30th of Cheshvan or Kislev; null or left out for any other.`),
+    hebrew: reading(RESOLVE_HEBREW, (raw, refuse) => {
+      if (raw === void 0) return void 0;
+      const hebrew = hebrewDateShape(raw);
+      if (hebrew === null) refuse(HEBREW_SHAPE_WORDS);
+      return hebrew;
+    }).describe(
+      "A Hebrew date { year, month, day } (months as the siddur numbers them: Nisan 1 ... Tishrei 7 ... Adar, or Adar I in a leap year, 12, Adar II 13), in place of civil and afterSunset: a day the calendar has, no later than the Hebrew day that begins this evening. The answer gives its civil day too."
+    )
+  }).superRefine((body, ctx) => {
+    const at = (path) => (message) => ctx.addIssue({ code: "custom", path: [path], message });
+    if (body.hebrew === void 0) {
+      if (body.civil === void 0) part.civil("date", void 0, today, at("civil"));
+      if (body.afterSunset === void 0) part.afterSunset("date", void 0, at("afterSunset"));
+    } else if (body.civil !== void 0 || body.afterSunset !== void 0) {
+      at("hebrew")(HEBREW_OR_CIVIL_WORDS);
+    }
+  }, { when: (payload) => isObject2(payload.value) });
 }
 var officeDatesBody = datesBodyUntil(null, true);
 var memberDatesBody = datesBodyUntil(null, false);
@@ -28128,8 +28160,8 @@ var datesContracts = [
     path: "/congs/{congId}/dates/resolve",
     auth: "user",
     lock: "allowed-when-locked",
-    summary: "Show the Hebrew date a civil date resolves to, before saving it.",
-    description: "Takes one date as the dates body holds it and answers its Hebrew date (after sunset applied), in words, which Adar and short-month choices apply to it, and its next anniversary. It computes and saves nothing, so it is allowed while the congregation is locked. Use it before dates.updateForMember to see the Hebrew date and which choices to offer, and before adding a yahrzeit by a civil date of death (yahrzeits.createForMember, congregationYahrzeits.create) to see the Hebrew date it will be kept on. The office (member.record.edit) and any active or lapsed member, for their own dates, may call it.",
+    summary: "Show the Hebrew date a civil date resolves to (or the civil day of a Hebrew date), before saving it.",
+    description: "Takes one date as the dates body holds it and answers its Hebrew date (after sunset applied), in words, its civil date, which Adar and short-month choices apply to it, and its next anniversary. It may take a Hebrew date (hebrew) in place of the civil date and after-sunset: that date is checked as a yahrzeit's is (a day the calendar has, not in the future), and the answer gives its civil day. It computes and saves nothing, so it is allowed while the congregation is locked. Use it before dates.updateForMember to see the Hebrew date and which choices to offer, and before adding a yahrzeit (yahrzeits.createForMember, congregationYahrzeits.create) to see the Hebrew date it will be kept on, or whether a Hebrew date will be taken. The office (member.record.edit) and any active or lapsed member, for their own dates, may call it.",
     capability: "any-member",
     effect: "read",
     params: congParams,
@@ -28144,7 +28176,12 @@ var datesContracts = [
         hint: "Act as a current member, or someone whose role has member.record.edit."
       },
       NO_CONGREGATION,
-      DATE_REFUSED
+      DATE_REFUSED,
+      {
+        code: "invalid",
+        when: "A Hebrew date (date.hebrew) is not a day of the calendar (a 30th the month does not have that year, Adar II in a common year), is in the future, or is sent with a civil date or after-sunset.",
+        hint: "Send a Hebrew date the calendar has and that is past, or the civil date and after-sunset instead, never both."
+      }
     ]
   }),
   full({
@@ -30066,22 +30103,9 @@ var yahrzeitMonthSchema = external_exports.strictObject({
   count: external_exports.number().int().describe("How many names the month reads.")
 }).readonly();
 var intIn = (v, min, max2) => typeof v === "number" && Number.isInteger(v) && v >= min && v <= max2 ? v : null;
-var HEBREW_RANGES = { year: [3761, 6e3], month: [1, 13], day: [1, 30] };
-var HEBREW_DATE = {
-  type: "object",
-  properties: Object.fromEntries(Object.entries(HEBREW_RANGES).map(([part2, [minimum, maximum]]) => [part2, { type: "integer", minimum, maximum }])),
-  required: Object.keys(HEBREW_RANGES)
-};
 var EPOCH_MS = { type: "integer", minimum: 0, maximum: Number.MAX_SAFE_INTEGER };
 var YAHRZEIT_ID = { type: "string", pattern: SIDDUR_YAHRZEIT_ID.source };
 var collapse = (v) => v.trim().replace(/\s+/g, " ");
-function hebrewDateShape(v) {
-  if (!isObject2(v)) return null;
-  const year = intIn(v["year"], ...HEBREW_RANGES.year);
-  const month = intIn(v["month"], ...HEBREW_RANGES.month);
-  const day2 = intIn(v["day"], ...HEBREW_RANGES.day);
-  return year === null || month === null || day2 === null ? null : { year, month, day: day2 };
-}
 var nameField2 = reading({ rule: "name", required: true, schema: { type: "string", minLength: 1, maxLength: NAME_MAX } }, (raw, refuse) => {
   const name = typeof raw === "string" ? collapse(raw) : "";
   if (name.length >= 1 && name.length <= NAME_MAX) return name;
@@ -34898,7 +34922,7 @@ function stepOf(raw, at, mediaPrefix, reading2) {
     return null;
   }
   const before = errors.length;
-  const step = {
+  const step2 = {
     stepId: idOf(f, "stepId", `${at}.`, errors),
     kind: "message",
     enabled: booleanOf(f, "enabled", `${at}.`, errors),
@@ -34910,12 +34934,12 @@ function stepOf(raw, at, mediaPrefix, reading2) {
     push: pushOf(f["push"], `${at}.push`, errors),
     whatsapp: booleanOf(f, "whatsapp", `${at}.`, errors)
   };
-  const chosen2 = new Set(step.channels.map((c) => c.channel));
-  if (chosen2.has("whatsapp") !== step.whatsapp) errors.push(`${at}.whatsapp must be true when WhatsApp is one of the channels, and only then`);
-  if (chosen2.has("email") && step.email === null && errors.length === before) errors.push(`${at}.email: write the email, or take email off the channels`);
-  if (chosen2.has("sms") && step.sms === null && errors.length === before) errors.push(`${at}.sms: write the SMS, or take SMS off the channels`);
-  if (chosen2.has("push") && step.push === null && errors.length === before) errors.push(`${at}.push: write the push notification, or take push off the channels`);
-  return errors.length === before ? step : null;
+  const chosen2 = new Set(step2.channels.map((c) => c.channel));
+  if (chosen2.has("whatsapp") !== step2.whatsapp) errors.push(`${at}.whatsapp must be true when WhatsApp is one of the channels, and only then`);
+  if (chosen2.has("email") && step2.email === null && errors.length === before) errors.push(`${at}.email: write the email, or take email off the channels`);
+  if (chosen2.has("sms") && step2.sms === null && errors.length === before) errors.push(`${at}.sms: write the SMS, or take SMS off the channels`);
+  if (chosen2.has("push") && step2.push === null && errors.length === before) errors.push(`${at}.push: write the push notification, or take push off the channels`);
+  return errors.length === before ? step2 : null;
 }
 function stepsOf(raw, mediaPrefix, reading2) {
   const { errors } = reading2;
@@ -37189,9 +37213,9 @@ function readRounding(parent, refuse) {
     refuse("time.rounding must be an object");
     return null;
   }
-  const step = ROUNDING_STEPS.find((s) => s === fields["step"]);
-  if (step === void 0) refuse(`time.rounding.step must be one of ${ROUNDING_STEPS.join(", ")}`);
-  return { direction: readPart(ROUNDING_DIRECTION, fields, "direction", "time.rounding", refuse) ?? "nearest", step: step ?? 5 };
+  const step2 = ROUNDING_STEPS.find((s) => s === fields["step"]);
+  if (step2 === void 0) refuse(`time.rounding.step must be one of ${ROUNDING_STEPS.join(", ")}`);
+  return { direction: readPart(ROUNDING_DIRECTION, fields, "direction", "time.rounding", refuse) ?? "nearest", step: step2 ?? 5 };
 }
 var TIME_KIND = oneOf(["clock", "zman"], "clock");
 var CLOCK_MINUTES = integerField(0, MINUTES_IN_DAY - 1, true);
@@ -38123,6 +38147,11 @@ function commandByWords(area, action) {
 function commandById(id2) {
   return BY_ID2.get(id2) ?? null;
 }
+function needCommand(workflowId, id2) {
+  const cmd = commandById(id2);
+  if (cmd === null) throw new Error(`${workflowId} uses ${id2}, which this CLI has no command for.`);
+  return cmd;
+}
 function idParams(cmd) {
   return Object.keys(cmd.contract.params.shape).filter((key) => key !== "congId");
 }
@@ -38488,7 +38517,7 @@ var isStarted = (entry) => "kind" in entry && entry.kind === "started";
 var resultsOf = (backup) => backup.results.filter((entry) => !("kind" in entry));
 var unanswered = (backup) => {
   const answered = new Set(resultsOf(backup).map((entry) => entry.step));
-  return backup.results.filter(isStarted).map((entry) => entry.step).filter((step) => !answered.has(step));
+  return backup.results.filter(isStarted).map((entry) => entry.step).filter((step2) => !answered.has(step2));
 };
 var changedNothing = (entry) => !entry.ok && entry.error?.mayHaveLanded !== true && entry.error?.code !== "network";
 var restoredBy = (backup) => backup.results.find(isRestored);
@@ -38949,6 +38978,26 @@ var RESTORERS = {
   "tickets.saveTypes": ticketTypes
 };
 var RESTORER_BY_ID = new Map(Object.entries(RESTORERS).flatMap(([id2, restorer]) => restorer === void 0 ? [] : [[id2, restorer]]));
+var TAKE_BACK = {
+  "yahrzeits.createForMember": "yahrzeits.deleteForMember",
+  "congregationYahrzeits.create": "congregationYahrzeits.delete"
+};
+var TAKE_BACK_BY_ID = new Map(Object.entries(TAKE_BACK).flatMap(([id2, del]) => del === void 0 ? [] : [[id2, del]]));
+var takeBackFor = (cmd) => {
+  const del = TAKE_BACK_BY_ID.get(cmd.id);
+  return del === void 0 ? null : commandById(del);
+};
+function takeBack(del, created2, current, label) {
+  const left = (words) => ({ ok: true, steps: [], changes: [], kept: [], left: [words] });
+  if (current === null) return left(`${label} was already removed.`);
+  if (current["adoptedFromOffice"] === true) return left(`${label}: the member took it into their own list since, so it is theirs and is left as it is now.`);
+  if (!sameValue(keeperOf(current), keeperOf(created2))) return left(`${label} was moved to another keeper since it was added, so it is left as it is now.`);
+  if (current["version"] !== created2["version"]) return left(`${label} was changed since it was added, so it is left as it is now.`);
+  const memberId = keeperOf(current);
+  const input2 = { ...typeof memberId === "string" && "memberId" in del.input.shape ? { memberId } : {}, yahrzeitId: current["yahrzeitId"], version: current["version"] };
+  const record3 = recordLabel(del, input2);
+  return { ok: true, steps: [{ commandId: del.id, input: input2, record: record3 }], changes: deleteChanges(yahrzeitBody2(current), record3), kept: [] };
+}
 var RECORD_KEYS = {
   "series.listOverrides": "override",
   "calendarSettings.get": "settings",
@@ -39000,6 +39049,206 @@ var WHOLE_READS = new Map(Object.entries(BACKUP_READS).flatMap(([id2, options])
 var MAY_BE_ABSENT = /* @__PURE__ */ new Set(["series.saveOverride", "me.updateYahrzeit"]);
 var mayBeAbsent = (cmd) => MAY_BE_ABSENT.has(cmd.id);
 
+// ../backend/src/core/blocks.ts
+function plainRun(text2, bold = false) {
+  return { text: text2, bold, italic: false, href: null };
+}
+function paragraphBlock(text2) {
+  return { type: "paragraph", runs: [plainRun(text2)] };
+}
+
+// ../backend/src/core/automations/presets.ts
+var NINE_AM = 540;
+function step(title, subject, body, push) {
+  return {
+    kind: "message",
+    enabled: true,
+    to: { kind: "subject" },
+    channels: [{ channel: "push", mode: "everyone" }, { channel: "email", mode: "fallback" }],
+    title,
+    email: { subject, blocks: [paragraphBlock(body)] },
+    sms: null,
+    push,
+    whatsapp: false
+  };
+}
+var WARM_WISHES = "With warm wishes from everyone at {congregation}.";
+var AUTOMATION_PRESETS = [
+  {
+    presetId: "yahrzeit-reminder",
+    name: "Yahrzeit reminder",
+    sendAt: NINE_AM,
+    triggers: [{ kind: "occasion", occasion: "yahrzeit", leadDays: 3 }],
+    step: step(
+      "The yahrzeit of {deceased_name}",
+      "The yahrzeit of {deceased_name}",
+      "{first_name}, the yahrzeit of {deceased_name} begins {begins} ({hebrew_date}). We will say kaddish with you. {congregation}.",
+      { title: "The yahrzeit of {deceased_name}", body: "It begins {begins}." }
+    )
+  },
+  {
+    presetId: "birthday",
+    name: "Birthday greeting",
+    sendAt: NINE_AM,
+    triggers: [{ kind: "occasion", occasion: "birthday", leadDays: 0 }],
+    step: step(
+      "Mazal tov, {first_name}",
+      "Mazal tov on your birthday",
+      `Mazal tov on your birthday, {first_name}. ${WARM_WISHES}`,
+      { title: "Mazal tov, {first_name}", body: WARM_WISHES }
+    )
+  },
+  {
+    presetId: "wedding",
+    name: "Wedding anniversary",
+    sendAt: NINE_AM,
+    triggers: [{ kind: "occasion", occasion: "wedding", leadDays: 0 }],
+    step: step(
+      "Mazal tov, {first_name}",
+      "Mazal tov on your wedding anniversary",
+      `Mazal tov on your {years} wedding anniversary, {first_name}. ${WARM_WISHES}`,
+      { title: "Mazal tov, {first_name}", body: WARM_WISHES }
+    )
+  },
+  {
+    presetId: "b-mitzvah",
+    name: "B'mitzvah anniversary",
+    sendAt: NINE_AM,
+    triggers: [{ kind: "occasion", occasion: "b-mitzvah", leadDays: 0 }],
+    step: step(
+      "Mazal tov, {first_name}",
+      "Mazal tov on your b'mitzvah anniversary",
+      `Mazal tov on the {years} anniversary of your b'mitzvah, {first_name}. ${WARM_WISHES}`,
+      { title: "Mazal tov, {first_name}", body: WARM_WISHES }
+    )
+  },
+  {
+    presetId: "shabbat-list",
+    name: "Weekly Shabbat list",
+    sendAt: NINE_AM,
+    triggers: [{ kind: "weekly", weekday: 4 }],
+    step: {
+      kind: "shabbat-digest",
+      enabled: true,
+      to: { kind: "capability", capability: "shabbat-list.view" },
+      channels: [{ channel: "email", mode: "everyone" }, { channel: "push", mode: "everyone" }]
+    }
+  }
+];
+function presetWrite(preset) {
+  const weekly = preset.triggers.some((t) => t.kind === "weekly");
+  return {
+    name: preset.name,
+    triggers: preset.triggers,
+    sendAt: preset.sendAt,
+    restDays: "before",
+    shabbat: "following",
+    grouping: weekly ? "per-occurrence" : "per-shabbat",
+    steps: [preset.step]
+  };
+}
+
+// src/tool/workflows/automation-presets.ts
+var presetIds = () => AUTOMATION_PRESETS.map((p) => p.presetId);
+function presetNamed(workflowId, given) {
+  const ids = presetIds();
+  const found = AUTOMATION_PRESETS.find((p) => p.presetId === given);
+  if (found !== void 0) return { ok: true, data: found };
+  const word = typeof given === "string" ? given.toLowerCase() : "";
+  const near = word === "" ? null : ids.find((id2) => id2.startsWith(word) || word.startsWith(id2)) ?? suggest(word, ids);
+  return fail2(cliError("invalid-input", `There is no preset "${String(given)}".${near === null ? "" : ` Did you mean "${near}"?`}`, {
+    page: workflowId,
+    hint: `The presets are ${ids.join(", ")}. The list of presets (automations presets) says what each one does.`,
+    details: [{ path: ["from"], message: `one of ${ids.join(", ")}` }]
+  }));
+}
+var summaryOf = (preset) => ({
+  presetId: preset.presetId,
+  name: preset.name,
+  triggers: preset.triggers,
+  sendAt: preset.sendAt,
+  channels: preset.step.channels.map((c) => c.channel)
+});
+var WEEKDAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+function presetWords(preset) {
+  const when = preset.triggers.map((t) => {
+    if (t.kind === "weekly") return `every ${WEEKDAYS[t.weekday] ?? "week"}`;
+    return t.leadDays === 0 ? `on the day of a ${t.occasion}` : `${t.leadDays} day${t.leadDays === 1 ? "" : "s"} before a ${t.occasion}`;
+  }).join(", ");
+  const at = `${Math.floor(preset.sendAt / 60)}:${String(preset.sendAt % 60).padStart(2, "0")}`;
+  return `${when}, at ${at}, by ${preset.step.channels.map((c) => c.channel).join(" and ")}`;
+}
+var presetList = () => AUTOMATION_PRESETS.map((p) => `- \`${p.presetId}\`: ${p.name}, ${presetWords(p)}`).join("\n");
+var automationsPresets = {
+  id: "automations.presets",
+  words: ["automations", "presets"],
+  summary: "List the gallery's automation presets: what sets each off, when it goes and the channels it uses.",
+  description: "The starting points an automation is made from (automations create, from a preset): its id, name, triggers, send time (minutes after midnight) and channels. Nothing is saved or sent.",
+  effect: "read",
+  uses: [],
+  input: external_exports.strictObject({}),
+  run: () => Promise.resolve({ ok: true, data: AUTOMATION_PRESETS.map(summaryOf) })
+};
+var inputSchema = external_exports.strictObject({
+  presetId: external_exports.string().min(1).describe("The preset to start from (`automations presets` lists them)."),
+  overrides: external_exports.record(external_exports.string(), external_exports.unknown()).optional().describe("Fields of automations.create to change from the preset, by name (the line's own flags, set and body).")
+});
+function layOver(base, over) {
+  if (!isRecord(over)) return over;
+  if (Array.isArray(base)) {
+    const out2 = [...base];
+    for (const [key, value] of Object.entries(over)) {
+      const at = /^\d+$/.test(key) ? Number(key) : -1;
+      if (at < 0) return over;
+      out2[at] = layOver(base[at], value);
+    }
+    return out2;
+  }
+  if (!isRecord(base)) return over;
+  const out = { ...base };
+  for (const [key, value] of Object.entries(over)) out[key] = layOver(base[key], value);
+  return out;
+}
+function suggestedOf(data) {
+  const saved = asObject(asObject(asObject(data)["automation"])["automation"]);
+  const automationId = saved["automationId"];
+  const version3 = saved["version"];
+  const steps = Array.isArray(saved["steps"]) ? saved["steps"] : [];
+  const stepId = isRecord(steps[0]) ? steps[0]["stepId"] : void 0;
+  if (typeof automationId !== "string" || typeof version3 !== "number") return [];
+  return [
+    {
+      commandId: "automations.get",
+      input: { automationId },
+      why: "Read it back, then see a step as an email, push and in-app copy with automations preview, its fields as the body (--body): nothing is saved or sent."
+    },
+    ...typeof stepId === "string" ? [{ commandId: "automations.test", input: { automationId, stepId, channels: ["email"] }, why: "Send yourself the email, to see how it arrives." }] : [],
+    { commandId: "automations.enable", input: { automationId, version: version3, confirmCost: true }, why: "Turn it on: a plan that says who it will reach and what it costs." }
+  ];
+}
+var automationsCreateFromPreset = {
+  id: "automations.createFromPreset",
+  words: ["automations", "create"],
+  summary: "Make an automation from one of the gallery's presets, turned off.",
+  description: "Starts from a preset (`automations presets`) and saves it as a new automation, turned off, at version 1. Any other field of automations.create changes only what it names: a new name renames it and leaves the rest as the preset has it. Preview it, test it on yourself and turn it on (`automations enable`, a plan) as for any automation.",
+  effect: "write",
+  uses: ["automations.create"],
+  claims: "--from",
+  flagsFrom: "automations.create",
+  input: inputSchema,
+  async run(ctx, input2) {
+    const parsed = inputSchema.safeParse(input2);
+    if (!parsed.success) return fail2(cliError("invalid-input", "The input is not a preset's id and the fields to change.", { page: "automations.createFromPreset" }));
+    const preset = presetNamed("automations.createFromPreset", parsed.data.presetId);
+    if (!preset.ok) return preset;
+    const write = layOver({ ...presetWrite(preset.data), version: 0 }, parsed.data.overrides ?? {});
+    const made = await executeUnguarded(ctx, needCommand("automations.createFromPreset", "automations.create"), isRecord(write) ? write : {});
+    if (!made.ok) return made;
+    const suggested = suggestedOf(made.data);
+    return { ok: true, data: made.data, ...suggested.length === 0 ? {} : { suggested } };
+  }
+};
+
 // ../backend/src/core/geo/locales.ts
 var DEFAULT_LOCALE = "en-AU";
 var PLATFORM_LOCALE = DEFAULT_LOCALE;
@@ -39106,6 +39355,30 @@ function scanCsv(text2) {
   const isSepHint = (r) => /^sep=.?$/i.test(r.cells[0] ?? "") && r.cells.slice(1).every((c) => c === "");
   return { lines: records.filter((r) => !isSepHint(r)) };
 }
+var isBlankLine = (r) => r.cells.every((c) => cleanCell(c) === "");
+function headerAndData(lines2) {
+  const [header, ...data] = lines2.filter((r, i2, all) => !isBlankLine(r) || all.slice(0, i2).some((p) => !isBlankLine(p)));
+  return { header, data };
+}
+function columnsByMapping(headerCells2, mapping, aliases) {
+  const mapped = /* @__PURE__ */ new Map();
+  const skipped = [];
+  const unmapped = headerCells2.map((raw, index3) => {
+    const name = cleanCell(raw);
+    if (!Object.prototype.hasOwnProperty.call(mapping, name)) return raw;
+    const field = mapping[name] ?? null;
+    if (field === null || [...mapped.values()].includes(field)) skipped.push(name);
+    else mapped.set(index3, field);
+    return "";
+  });
+  const mappedFields = new Set(mapped.values());
+  const left = {};
+  for (const f of Object.keys(aliases)) if (!mappedFields.has(f)) left[f] = aliases[f];
+  const byAlias = mapColumns(unmapped, left);
+  return { columns: new Map([...byAlias.columns, ...mapped]), ignored: [...skipped, ...byAlias.ignored] };
+}
+var HEBREW_MARKS = /[֑-ׇ]/u;
+var WORD_SPLITTERS = /[-‐-―־׀׃׆]/u;
 
 // ../backend/src/core/member-import.ts
 var MAX_IMPORT_ROWS = 2e3;
@@ -39127,28 +39400,8 @@ var IMPORT_ALIASES = {
   countsForMinyan: ["counts for minyan", "counts_for_minyan"]
 };
 var fatal = (error62, ignoredColumns = []) => ({ rows: [], ignoredColumns, error: error62 });
-var isBlankLine = (r) => r.cells.every((c) => cleanCell(c) === "");
-function headerAndData(lines2) {
-  const [header, ...data] = lines2.filter((r, i2, all) => !isBlankLine(r) || all.slice(0, i2).some((p) => !isBlankLine(p)));
-  return { header, data };
-}
-var headerOf = (lines2) => headerAndData(lines2).header;
-function importColumns(headerCells, mapping = {}) {
-  const mapped = /* @__PURE__ */ new Map();
-  const skipped = [];
-  const unmapped = headerCells.map((raw, index3) => {
-    const name = cleanCell(raw);
-    if (!Object.prototype.hasOwnProperty.call(mapping, name)) return raw;
-    const field = mapping[name] ?? null;
-    if (field === null || [...mapped.values()].includes(field)) skipped.push(name);
-    else mapped.set(index3, field);
-    return "";
-  });
-  const mappedFields = new Set(mapped.values());
-  const aliases = {};
-  for (const f of IMPORT_FIELDS) if (!mappedFields.has(f)) aliases[f] = IMPORT_ALIASES[f];
-  const byAlias = mapColumns(unmapped, aliases);
-  return { columns: new Map([...byAlias.columns, ...mapped]), ignored: [...skipped, ...byAlias.ignored] };
+function importColumns(headerCells2, mapping = {}) {
+  return columnsByMapping(headerCells2, mapping, IMPORT_ALIASES);
 }
 var NEEDS_NAME_COLUMNS = "The first row needs a column headed with a first name and a last name (for example First name and Surname).";
 function rowsFromTable(lines2, mapping = {}) {
@@ -39195,18 +39448,6 @@ function duplicateNameRows(rows) {
   return duplicates;
 }
 
-// src/tool/column-letters.ts
-function columnLetters(index3) {
-  let n = index3 + 1;
-  let out = "";
-  while (n > 0) {
-    const rest = (n - 1) % 26;
-    out = String.fromCharCode(65 + rest) + out;
-    n = Math.floor((n - 1) / 26);
-  }
-  return out;
-}
-
 // node_modules/read-excel-file/modules/saxen/parser.js
 function _typeof(o) {
   "@babel/helpers - typeof";
@@ -43019,6 +43260,18 @@ function readXlsxFile(input2, options) {
   });
 }
 
+// src/tool/column-letters.ts
+function columnLetters(index3) {
+  let n = index3 + 1;
+  let out = "";
+  while (n > 0) {
+    const rest = (n - 1) % 26;
+    out = String.fromCharCode(65 + rest) + out;
+    n = Math.floor((n - 1) / 26);
+  }
+  return out;
+}
+
 // src/tool/sheet.ts
 var tableSchema = external_exports.strictObject({
   name: external_exports.string().describe("The file's name."),
@@ -43030,6 +43283,39 @@ var tableSchema = external_exports.strictObject({
     cells: external_exports.array(external_exports.string()).readonly().describe("Its cells as text.")
   }).readonly()).readonly().describe("The lines of the sheet, blank ones left out, each with its own number.")
 }).readonly();
+var headerCells = (table2) => headerAndData(table2.lines).header?.cells ?? [];
+function headerKeyed(table2, mapping) {
+  const headers = headerCells(table2).map(cleanCell).filter((name) => name !== "");
+  const keyed = {};
+  const unused = [];
+  for (const [key, field] of Object.entries(mapping)) {
+    const header = headers.includes(key) ? key : headers.find((name) => squash(name) === squash(key));
+    if (header === void 0) unused.push(key);
+    else keyed[header] = field;
+  }
+  return { mapping: keyed, unused };
+}
+function proposalOf(header, columns) {
+  const out = {};
+  header.forEach((raw, index3) => {
+    const name = cleanCell(raw);
+    if (name !== "") out[name] = columns.get(index3) ?? null;
+  });
+  return out;
+}
+function columnName(header, columns, field) {
+  const at = field === null || field === void 0 ? void 0 : [...columns].find(([, f]) => f === field)?.[0];
+  return at === void 0 ? void 0 : `${columnLetters(at)} (${cleanCell(header[at] ?? "")})`;
+}
+function unreadableSheet(table2, error62, words) {
+  const headers = Object.keys(words.propose(table2));
+  const names = words.columnsMissing(error62) ? ` The headers found: ${headers.length === 0 ? "none" : headers.join(", ")}.${words.after === void 0 ? "" : ` ${words.after}`}` : "";
+  return fail2(cliError("invalid-input", `${table2.name}: ${error62}${names}`, {
+    page: words.page,
+    hint: names === "" ? "Fix the file and plan again." : words.mapHint,
+    ...names === "" ? {} : { next: [{ commandId: words.page, input: { file: table2.path ?? table2.name, map: "map.json" }, why: "Writes the headers it found to map.json, to edit." }] }
+  }));
+}
 var KINDS = "Save it as .xlsx or .csv and try again";
 function textOf2(cell2) {
   if (typeof cell2 === "string") return cell2;
@@ -43079,48 +43365,28 @@ async function readTable(bytes, name, sheet) {
 // src/tool/workflows/members-import.ts
 var importMappingSchema = external_exports.record(external_exports.string(), external_exports.enum(IMPORT_FIELDS).nullable());
 var CREATE_ONLY_WORDS = "Only add people: a row whose email is on file is skipped, never updated.";
-var inputSchema = external_exports.strictObject({
+var inputSchema2 = external_exports.strictObject({
   table: tableSchema.describe("The sheet, read from the file (a front end does that: give it the file, not this)."),
   mapping: importMappingSchema.optional().describe("Which column is which field, by the header as written (null leaves a column out). It overrides the headers the reader knows."),
   createOnly: external_exports.boolean().optional().describe(CREATE_ONLY_WORDS)
 });
-function headerKeyed(table2, mapping) {
-  const headers = (headerOf(table2.lines)?.cells ?? []).map(cleanCell).filter((name) => name !== "");
-  const keyed = {};
-  const unused = [];
-  for (const [key, field] of Object.entries(mapping)) {
-    const header = headers.includes(key) ? key : headers.find((name) => squash(name) === squash(key));
-    if (header === void 0) unused.push(key);
-    else keyed[header] = field;
-  }
-  return { mapping: keyed, unused };
-}
-var need = (id2) => {
-  const cmd = commandById(id2);
-  if (cmd === null) throw new Error(`members.importSheet uses ${id2}, which this CLI has no command for.`);
-  return cmd;
-};
+var need = (id2) => needCommand("members.importSheet", id2);
 function columnsOf(table2, mapping) {
-  const header = headerOf(table2.lines)?.cells ?? [];
+  const header = headerCells(table2);
   return { header, ...importColumns(header, mapping) };
 }
 function mappingOf(table2, mapping = {}) {
   const { header, columns } = columnsOf(table2, mapping);
-  const out = {};
-  header.forEach((raw, index3) => {
-    const name = cleanCell(raw);
-    if (name !== "") out[name] = columns.get(index3) ?? null;
-  });
-  return out;
+  return proposalOf(header, columns);
 }
 function unreadable(table2, error62) {
-  const headers = Object.keys(mappingOf(table2));
-  const names = error62.startsWith(NEEDS_NAME_COLUMNS) ? ` The headers found: ${headers.length === 0 ? "none" : headers.join(", ")}. Name the first and last name columns in a map file.` : "";
-  return fail2(cliError("invalid-input", `${table2.name}: ${error62}${names}`, {
+  return unreadableSheet(table2, error62, {
     page: "members.importSheet",
-    hint: names === "" ? "Fix the file and plan again." : "A map file says which header is which field (firstName, lastName, email, phone and so on), and one that is not there yet is written with these headers to edit. Map the columns, then plan again.",
-    ...names === "" ? {} : { next: [{ commandId: "members.importSheet", input: { file: table2.path ?? table2.name, map: "map.json" }, why: "Writes the headers it found to map.json, to edit." }] }
-  }));
+    columnsMissing: (e) => e.startsWith(NEEDS_NAME_COLUMNS),
+    after: "Name the first and last name columns in a map file.",
+    propose: (t) => mappingOf(t),
+    mapHint: "A map file says which header is which field (firstName, lastName, email, phone and so on), and one that is not there yet is written with these headers to edit. Map the columns, then plan again."
+  });
 }
 function batches(items, size) {
   return Array.from({ length: Math.ceil(items.length / size) }, (_, i2) => items.slice(i2 * size, (i2 + 1) * size));
@@ -43134,19 +43400,16 @@ var membersImportSheet = {
   effect: "destructive",
   // members.getMinyanFlag keeps a flag an update sets; members.update and members.setMinyanFlag are how a restore puts them back.
   uses: ["members.import", "members.list", "households.list", MINYAN_READ, "members.update", "members.setMinyanFlag"],
-  input: inputSchema,
+  input: inputSchema2,
   claims: "positional",
   async plan(ctx, given) {
-    const { table: table2, mapping: asGiven = {}, createOnly = false } = inputSchema.parse(given);
+    const { table: table2, mapping: asGiven = {}, createOnly = false } = inputSchema2.parse(given);
     const { mapping, unused } = headerKeyed(table2, asGiven);
     const read2 = rowsFromTable(table2.lines, mapping);
     if (read2.error !== null) return unreadable(table2, read2.error);
     if (read2.rows.length === 0) return fail2(cliError("invalid-input", `${table2.name} has a header and no members under it.`, { page: "members.importSheet", hint: "Add the members under the header row and plan again." }));
     const { header, columns, ignored } = columnsOf(table2, mapping);
-    const columnOf = (field) => {
-      const at = field === null || field === void 0 ? void 0 : [...columns].find(([, f]) => f === field)?.[0];
-      return at === void 0 ? void 0 : `${columnLetters(at)} (${cleanCell(header[at] ?? "")})`;
-    };
+    const columnOf = (field) => columnName(header, columns, field);
     const emailRepeats = duplicateEmailRows(read2.rows);
     const nameRepeats = duplicateNameRows(read2.rows);
     const repeats = [];
@@ -43242,8 +43505,551 @@ var membersImportSheet = {
   }
 };
 
+// ../backend/src/contracts/hebrew-months.ts
+var NAMES = {
+  1: "Nisan",
+  2: "Iyyar",
+  3: "Sivan",
+  4: "Tamuz",
+  5: "Av",
+  6: "Elul",
+  7: "Tishrei",
+  8: "Cheshvan",
+  9: "Kislev",
+  10: "Tevet",
+  11: "Sh'vat",
+  13: "Adar II"
+};
+function isHebrewLeapYear(year) {
+  return (7 * year + 1) % 19 < 7;
+}
+function monthName(month, year) {
+  if (month === 12) return isHebrewLeapYear(year) ? "Adar I" : "Adar";
+  return NAMES[month] ?? "";
+}
+function hebrewDateWords(d) {
+  return `${String(d.day)} ${monthName(d.month, d.year)} ${String(d.year)}`;
+}
+var isPlainAdarDeath = (d) => d.month === 12 && !isHebrewLeapYear(d.year);
+var isShortMonthDeath = (d) => d.day === 30 && (d.month === 8 || d.month === 9);
+var YEARS = [3761, 6e3];
+var SPELLINGS = {
+  nisan: 1,
+  nissan: 1,
+  iyyar: 2,
+  iyar: 2,
+  sivan: 3,
+  tamuz: 4,
+  tammuz: 4,
+  av: 5,
+  ab: 5,
+  elul: 6,
+  tishrei: 7,
+  tishri: 7,
+  cheshvan: 8,
+  heshvan: 8,
+  marcheshvan: 8,
+  kislev: 9,
+  tevet: 10,
+  teves: 10,
+  shvat: 11,
+  shevat: 11,
+  adar: 12,
+  // Adar I and Adar II, by number and by their Hebrew names (Aleph and Bet, Rishon and Sheni).
+  adari: 12,
+  adar1: 12,
+  adaraleph: 12,
+  adaralef: 12,
+  adarrishon: 12,
+  adarii: 13,
+  adar2: 13,
+  adarbet: 13,
+  adarbeth: 13,
+  adarsheni: 13
+};
+var ADAR_I = /* @__PURE__ */ new Set(["adari", "adar1", "adaraleph", "adaralef", "adarrishon"]);
+var spelledOf = (name) => name.toLowerCase().replace(/[^a-z0-9]/g, "");
+var DATE_WORDS2 = /^(\d{1,2})\s+(.+?)\s+(\d{4})$/;
+function mostDays(month, year) {
+  if (month === 2 || month === 4 || month === 6 || month === 10 || month === 13) return 29;
+  return month === 12 && !isHebrewLeapYear(year) ? 29 : 30;
+}
+function parseHebrewDateWords(text2) {
+  const read2 = DATE_WORDS2.exec(text2.trim().replace(/\s+/g, " "));
+  if (read2 === null) return null;
+  const [, dayText = "", name = "", yearText = ""] = read2;
+  const day2 = Number(dayText);
+  const year = Number(yearText);
+  const spelled = spelledOf(name);
+  const month = Object.hasOwn(SPELLINGS, spelled) ? SPELLINGS[spelled] : void 0;
+  if (month === void 0 || year < YEARS[0] || year > YEARS[1]) return null;
+  if (!isHebrewLeapYear(year) && (month === 13 || ADAR_I.has(spelled))) return null;
+  if (day2 < 1 || day2 > mostDays(month, year)) return null;
+  return { year, month, day: day2 };
+}
+function namesPlainAdar(text2) {
+  const [, , name = ""] = DATE_WORDS2.exec(text2.trim().replace(/\s+/g, " ")) ?? [];
+  return spelledOf(name) === "adar";
+}
+
+// ../backend/src/core/yahrzeit-types.ts
+var MAX_YAHRZEITS_PER_MEMBER = 200;
+
+// src/tool/workflows/yahrzeit-sheet.ts
+var YAHRZEIT_COLUMNS = ["id", "keeper", "name", "hebrewName", "hebrewDate", "civilDate", "afterSunset", "adarObservance", "shortMonthChoice"];
+var NEXT_DATE_COLUMN = "nextDate";
+var YAHRZEIT_ALIASES = {
+  id: ["id", "yahrzeit id", "yahrzeitid"],
+  keeper: ["keeper", "kept by", "keeper email", "member", "member email", "email", "owner"],
+  name: ["name", "deceased", "deceased name", "name of deceased", "name of the deceased"],
+  hebrewName: ["hebrew name", "hebrew"],
+  hebrewDate: ["hebrew date", "hebrew date of death", "date of death hebrew"],
+  civilDate: ["civil date", "civil date of death", "date of death", "date", "gregorian date"],
+  afterSunset: ["after sunset", "after nightfall", "after dark"],
+  adarObservance: ["adar observance", "adar"],
+  shortMonthChoice: ["short month choice", "short month"]
+};
+var yahrzeitMappingSchema = external_exports.record(external_exports.string(), external_exports.enum(YAHRZEIT_COLUMNS).nullable());
+var CONGREGATION_KEEPER = "congregation";
+var MEMBER_KEEPER = "member:";
+function deceasedKey(name) {
+  const parted = name.replace(INVISIBLE, "").normalize("NFD").replace(new RegExp(WORD_SPLITTERS, "gu"), " ");
+  return nameKey(parted.replace(new RegExp(HEBREW_MARKS, "gu"), ""));
+}
+var NEEDS_KEEPER_AND_NAME = "The first row needs a column headed Keeper (a member's email, or congregation) and a column headed Name (the person who died).";
+var yahrzeitColumnsOf = (headerCells2, mapping = {}) => columnsByMapping(headerCells2, mapping, YAHRZEIT_ALIASES);
+function readYahrzeitSheet(lines2, mapping = {}) {
+  const { header, data } = headerAndData(lines2);
+  if (header === void 0) return { ok: false, error: "The file is empty." };
+  const { columns, ignored } = yahrzeitColumnsOf(header.cells, mapping);
+  const taken = new Set(columns.values());
+  if (!taken.has("keeper") || !taken.has("name")) return { ok: false, error: NEEDS_KEEPER_AND_NAME };
+  const rows = data.filter((line) => !isBlankLine(line)).map((line) => {
+    const cells = { id: "", keeper: "", name: "", hebrewName: "", hebrewDate: "", civilDate: "", afterSunset: "", adarObservance: "", shortMonthChoice: "" };
+    columns.forEach((column, index3) => {
+      cells[column] = cleanCell(line.cells[index3] ?? "");
+    });
+    return { row: line.line, cells };
+  });
+  return { ok: true, rows, header: header.cells, columns, ignored };
+}
+function readYesNo(cell2) {
+  const word = squash(cell2);
+  if (["yes", "y", "true", "1"].includes(word)) return true;
+  if (["no", "n", "false", "0"].includes(word)) return false;
+  return null;
+}
+function readAdar(cell2) {
+  const word = squash(cell2);
+  if (word === "adari" || word === "adar1") return "adar-i";
+  if (word === "adarii" || word === "adar2") return "adar-ii";
+  return ADAR_OBSERVANCES.find((choice) => squash(choice) === word) ?? null;
+}
+function readShortMonth(cell2) {
+  const word = squash(cell2);
+  if (["29", "29th", "samemonth29"].includes(word)) return "same-month-29";
+  if (["1", "1st", "nextmonth1", "1stofnextmonth"].includes(word)) return "next-month-1";
+  return null;
+}
+function exportRow(y, emailOf2) {
+  const keeper = y.keeper.kind === "congregation" ? CONGREGATION_KEEPER : emailOf2(y.keeper.memberId) ?? `${MEMBER_KEEPER}${y.keeper.memberId}`;
+  const cells = {
+    id: y.yahrzeitId,
+    keeper,
+    name: y.name,
+    hebrewName: y.hebrewName ?? "",
+    hebrewDate: hebrewDateWords(y.hebrewDate),
+    // Only the Hebrew date of death is kept: the civil date a person typed is not, so this column is left for a sheet to fill.
+    civilDate: "",
+    afterSunset: "",
+    adarObservance: y.adarObservance ?? "",
+    shortMonthChoice: y.shortMonthChoice ?? ""
+  };
+  return [...YAHRZEIT_COLUMNS.map((column) => cells[column]), y.nextDate];
+}
+var EXPORT_HEADERS = [...YAHRZEIT_COLUMNS, NEXT_DATE_COLUMN];
+function peopleOf(data) {
+  const list2 = Array.isArray(data) ? data.filter(isRecord) : [];
+  const emailOf2 = (m) => typeof m["email"] === "string" && m["email"] !== "" ? normaliseEmail(m["email"]) : null;
+  const held = /* @__PURE__ */ new Map();
+  for (const m of list2) {
+    const email4 = emailOf2(m);
+    if (email4 !== null) held.set(email4, (held.get(email4) ?? 0) + 1);
+  }
+  return list2.flatMap((m) => {
+    if (typeof m["memberId"] !== "string") return [];
+    const email4 = emailOf2(m);
+    return [{
+      memberId: m["memberId"],
+      email: email4,
+      onlyOne: email4 !== null && held.get(email4) === 1,
+      status: String(m["status"] ?? ""),
+      name: `${String(m["firstName"] ?? "")} ${String(m["lastName"] ?? "")}`.trim()
+    }];
+  });
+}
+async function readYahrzeitsAndMembers(ctx, workflowId) {
+  const all = needCommand(workflowId, "yahrzeits.all");
+  const listed = await executeUnguarded(ctx, all, {});
+  if (!listed.ok) return listed;
+  const parsed = yahrzeitAllSchema.safeParse(listed.data);
+  if (!parsed.success) return fail2(cliError("internal", "yahrzeits.all answered a list this CLI cannot read.", { contract: all.contract, hint: "Upgrade the CLI, and report it if it stays." }));
+  const members2 = await executeUnguarded(ctx, needCommand(workflowId, "members.list"), {});
+  if (!members2.ok) return members2;
+  return { ok: true, data: { yahrzeits: parsed.data, people: peopleOf(members2.data) } };
+}
+
+// src/tool/workflows/yahrzeits-bulk.ts
+var MAX_BULK_YAHRZEIT_ROWS = 1e3;
+var WORKFLOW_ID = "yahrzeits.bulk";
+var inputSchema3 = external_exports.strictObject({
+  table: tableSchema.describe("The sheet, read from the file (a front end does that: give it the file, not this)."),
+  mapping: yahrzeitMappingSchema.optional().describe("Which column is which, by the header as written (null leaves a column out). It overrides the headers the reader knows.")
+});
+var need2 = (id2) => needCommand(WORKFLOW_ID, id2);
+var CONGREGATION = { key: CONGREGATION_KEEPER, memberId: null, words: "the congregation" };
+var keeperOfView = (y) => y.keeper.kind === "member" ? { key: y.keeper.memberId, memberId: y.keeper.memberId, words: y.keeper.name } : CONGREGATION;
+function keeperOfCell(cell2, people2) {
+  if (cell2 === "") return { why: "The keeper is empty: write the member's email, or congregation." };
+  if (cell2.toLowerCase() === CONGREGATION_KEEPER) return { keeper: CONGREGATION };
+  const byId = cell2.toLowerCase().startsWith(MEMBER_KEEPER);
+  const matches = byId ? people2.filter((p) => p.memberId === cell2.slice(MEMBER_KEEPER.length)) : people2.filter((p) => p.email !== null && p.email === normaliseEmail(cell2));
+  const [only] = matches;
+  if (only === void 0) return { why: byId ? `No member has the id ${cell2.slice(MEMBER_KEEPER.length)}.` : `No member has the email ${cell2}: write a member's email, or congregation.` };
+  if (matches.length > 1) return { why: `The email ${cell2} matches ${String(matches.length)} records, so the keeper is not clear: write member:<id> for the one meant.` };
+  if (only.status === "pending") return { why: `${only.name} is a join request, not a member yet, so the office cannot keep a yahrzeit on their record.` };
+  return { keeper: { key: only.memberId, memberId: only.memberId, words: only.name } };
+}
+var sameDate = (a, b) => a.year === b.year && a.month === b.month && a.day === b.day;
+var heb = (d) => ({ year: d.year, month: d.month, day: d.day });
+function labelOf(row) {
+  return row.cells.name === "" ? `Row ${String(row.row)}` : row.cells.name;
+}
+var onlyHebrewName = (changes) => changes.length > 0 && changes.every((c) => c.field === "hebrewName");
+var CORRECTION_NOTE = "The member's app takes the correction, and they see the office corrected it.";
+var PORTAL_CORRECTION_NOTE = "The member sees the office corrected it.";
+var HEBREW_NAME_NOTE = "Only the Hebrew name changes: it is the office's own, so this is not a correction, and the member's app does not take it.";
+var LEAP_ADAR_NOTE = "Adar in a leap year is read as Adar I: write Adar II if that was meant.";
+var SUNSET_UNREAD = "after sunset goes with a civil date, so the afterSunset cell is not read here.";
+var ADDED_NOTE = "A yahrzeit the sheet added is removed by the restore, unless it was changed since. Each removal is backed up too, so the restore can itself be put back.";
+var ALL_PUT_BACK = "A restore puts every change back, through the same routes, with the version each record has then; a record changed since is left and named.";
+var yahrzeitsBulk = {
+  id: WORKFLOW_ID,
+  words: ["yahrzeits", "bulk"],
+  summary: "Add or change many yahrzeits from a spreadsheet: matched by id, or by keeper and name.",
+  description: "Reads yahrzeits from an Excel (.xlsx) or CSV file, as yahrzeits export writes them, and plans every row: added, changed (with each change), unchanged, ambiguous (more than one yahrzeit of that name for the keeper: add the id) or skipped with its reason and its column. A date is a Hebrew date in words, or a civil date with after-sunset; the plan shows both, and a Hebrew date the year does not have is skipped at once. Nothing is written until the plan is confirmed, and a restore puts the changes back and removes the yahrzeits it added.",
+  effect: "destructive",
+  // yahrzeits.all and members.list are read; dates.resolve shows each date's Hebrew and civil day. The writes are the per-yahrzeit routes; a restore
+  // sends the updates back through them, and removes what it added through the deletes (whose backup read is yahrzeits.listForMember or yahrzeits.all).
+  uses: [
+    "yahrzeits.all",
+    "members.list",
+    "dates.resolve",
+    "yahrzeits.createForMember",
+    "yahrzeits.updateForMember",
+    "congregationYahrzeits.create",
+    "congregationYahrzeits.update",
+    "yahrzeits.deleteForMember",
+    "congregationYahrzeits.delete",
+    "yahrzeits.listForMember"
+  ],
+  input: inputSchema3,
+  async plan(ctx, given) {
+    const { table: table2, mapping: asGiven = {} } = inputSchema3.parse(given);
+    const { mapping, unused } = headerKeyed(table2, asGiven);
+    const sheet = readYahrzeitSheet(table2.lines, mapping);
+    if (!sheet.ok) return unreadable2(table2, sheet.error);
+    if (sheet.rows.length === 0) return fail2(cliError("invalid-input", `${table2.name} has a header and no yahrzeits under it.`, { page: WORKFLOW_ID, hint: "Add the yahrzeits under the header row and plan again." }));
+    if (sheet.rows.length > MAX_BULK_YAHRZEIT_ROWS) {
+      return fail2(cliError("invalid-input", `${table2.name} has ${String(sheet.rows.length)} rows, and a sheet may hold at most ${String(MAX_BULK_YAHRZEIT_ROWS)}: each row is a call of its own.`, { page: WORKFLOW_ID, hint: `Split it into sheets of ${String(MAX_BULK_YAHRZEIT_ROWS)} rows or fewer.` }));
+    }
+    const columnOf = (field) => columnName(sheet.header, sheet.columns, field);
+    const read2 = await readYahrzeitsAndMembers(ctx, WORKFLOW_ID);
+    if (!read2.ok) return read2;
+    const { yahrzeits, people: people2 } = read2.data;
+    const byId = new Map(yahrzeits.map((y) => [y.yahrzeitId, y]));
+    const heldBy = /* @__PURE__ */ new Map();
+    for (const y of yahrzeits) heldBy.set(keeperOfView(y).key, (heldBy.get(keeperOfView(y).key) ?? 0) + 1);
+    const answers = /* @__PURE__ */ new Map();
+    const resolve = async (body) => {
+      const key = JSON.stringify(body);
+      const held = answers.get(key);
+      if (held !== void 0) return held;
+      const answered = await executeUnguarded(ctx, need2("dates.resolve"), { ...body, calendar: "hebrew" });
+      const one2 = answered.ok ? resolveResultSchema.safeParse(answered.data) : null;
+      const outcome = !answered.ok ? answered : one2?.success === true ? { ok: true, data: one2.data } : fail2(cliError("internal", "dates.resolve answered a date this CLI cannot read.", { contract: need2("dates.resolve").contract, hint: "Upgrade the CLI, and report it if it stays." }));
+      answers.set(key, outcome);
+      return outcome;
+    };
+    const resolvedOn = async (column, body, notes2, afterSunset) => {
+      const answered = await resolve(body);
+      if (!answered.ok) return answered.error.code === "invalid" ? { ok: true, data: { kind: "wrong", column, why: answered.error.message } } : answered;
+      const { hebrew, civil, affects } = answered.data;
+      return { ok: true, data: { kind: "date", date: { hebrew: heb(hebrew), civil, affects, ...afterSunset === void 0 ? {} : { afterSunset } }, notes: notes2 } };
+    };
+    const readDate = async (cells) => {
+      if (cells.hebrewDate !== "" && cells.civilDate !== "") {
+        return { ok: true, data: { kind: "wrong", column: "civilDate", why: "The row gives both hebrewDate and civilDate: keep one of them." } };
+      }
+      const sunsetUnread = cells.afterSunset === "" ? [] : [`${cells.hebrewDate === "" ? "With no date, " : "With a Hebrew date, "}${SUNSET_UNREAD}`];
+      if (cells.hebrewDate !== "") {
+        const hebrew = parseHebrewDateWords(cells.hebrewDate);
+        if (hebrew === null) {
+          return { ok: true, data: { kind: "wrong", column: "hebrewDate", why: `"${cells.hebrewDate}" is not a Hebrew date: write it as 15 Nisan 5780 (Adar I and Adar II only in a leap year).` } };
+        }
+        const leapAdar = hebrew.month === 12 && namesPlainAdar(cells.hebrewDate) && !isPlainAdarDeath(hebrew) ? [LEAP_ADAR_NOTE] : [];
+        return resolvedOn("hebrewDate", { hebrew }, [...leapAdar, ...sunsetUnread]);
+      }
+      if (cells.civilDate === "") return { ok: true, data: { kind: "none", notes: sunsetUnread } };
+      if (!/^\d{4}-\d{2}-\d{2}$/.test(cells.civilDate)) {
+        const why = parseHebrewDateWords(cells.civilDate) === null ? `"${cells.civilDate}" is not a date: write it as YYYY-MM-DD.` : `"${cells.civilDate}" is a Hebrew date: head the column Hebrew date, or map it to hebrewDate.`;
+        return { ok: true, data: { kind: "wrong", column: "civilDate", why } };
+      }
+      if (cells.afterSunset === "") return { ok: true, data: { kind: "wrong", column: "afterSunset", why: "afterSunset is empty: a civil date needs yes or no, whether the death was after sunset." } };
+      const afterSunset = readYesNo(cells.afterSunset);
+      if (afterSunset === null) return { ok: true, data: { kind: "wrong", column: "afterSunset", why: `"${cells.afterSunset}" is not yes or no: say whether the death was after sunset.` } };
+      return resolvedOn("civilDate", { civil: cells.civilDate, afterSunset }, [], afterSunset);
+    };
+    const steps = [];
+    const rows = [];
+    const changes = [];
+    const claimed = /* @__PURE__ */ new Map();
+    const added = /* @__PURE__ */ new Map();
+    let shares = 0;
+    for (const sheetRow of sheet.rows) {
+      const { row, cells } = sheetRow;
+      const label = labelOf(sheetRow);
+      const skip = (column, reason) => ({ row, label, action: "skip", reason, ...columnOf(column) === void 0 ? {} : { column: columnOf(column) } });
+      const done = (planned, step2, made2 = []) => {
+        rows.push(planned);
+        if (step2 !== void 0) steps.push(step2);
+        changes.push(...made2);
+      };
+      const who = keeperOfCell(cells.keeper, people2);
+      if ("why" in who) {
+        done(skip("keeper", who.why));
+        continue;
+      }
+      const { keeper } = who;
+      let target = null;
+      if (cells.id !== "") {
+        const found = byId.get(cells.id);
+        if (found === void 0) {
+          done(skip("id", `No yahrzeit has the id ${cells.id}: it may have been removed.`));
+          continue;
+        }
+        if (keeperOfView(found).key !== keeper.key) {
+          done(skip("keeper", `${found.name} is kept by ${keeperOfView(found).words}, not ${keeper.words}: move it first (yahrzeits move).`));
+          continue;
+        }
+        target = found;
+      } else {
+        if (cells.name === "") {
+          done(skip("name", "The name is empty: a row with no id needs the name of the person who died."));
+          continue;
+        }
+        const matches = yahrzeits.filter((y) => keeperOfView(y).key === keeper.key && deceasedKey(y.name) === deceasedKey(cells.name));
+        if (matches.length > 1) {
+          done({
+            row,
+            label,
+            action: "ambiguous",
+            reason: `${String(matches.length)} yahrzeits kept by ${keeper.words} are named like this (ids ${matches.map((y) => y.yahrzeitId).join(", ")}): add the id column (orzarua yahrzeits export writes it).`
+          });
+          continue;
+        }
+        target = matches[0] ?? null;
+      }
+      if (target !== null) {
+        const earlier = claimed.get(`old|${target.yahrzeitId}`);
+        if (earlier !== void 0) {
+          done({ row, label, action: "skip", reason: `Repeats row ${String(earlier)} (the same yahrzeit).` });
+          continue;
+        }
+        claimed.set(`old|${target.yahrzeitId}`, row);
+      }
+      const outcome = await readDate(cells);
+      if (!outcome.ok) return outcome;
+      if (outcome.data.kind === "wrong") {
+        done(skip(outcome.data.column, outcome.data.why));
+        continue;
+      }
+      const dateNotes = outcome.data.notes;
+      const adar = cells.adarObservance === "" ? null : readAdar(cells.adarObservance);
+      if (cells.adarObservance !== "" && adar === null) {
+        done(skip("adarObservance", `"${cells.adarObservance}" is not an Adar choice: write adar-i or adar-ii.`));
+        continue;
+      }
+      const short = cells.shortMonthChoice === "" ? null : readShortMonth(cells.shortMonthChoice);
+      if (cells.shortMonthChoice !== "" && short === null) {
+        done(skip("shortMonthChoice", `"${cells.shortMonthChoice}" is not a short-month choice: write same-month-29 or next-month-1.`));
+        continue;
+      }
+      const date5 = outcome.data.kind === "date" ? outcome.data.date : null;
+      const shown = (d) => ({ hebrew: hebrewDateWords(d.hebrew), civil: d.civil, ...d.afterSunset === void 0 ? {} : { afterSunset: d.afterSunset } });
+      const finalDate = date5?.hebrew ?? target?.hebrewDate ?? null;
+      if (finalDate === null) {
+        done(skip("hebrewDate", "A new yahrzeit needs its date of death: hebrewDate (such as 15 Nisan 5780), or civilDate with afterSunset."));
+        continue;
+      }
+      const affects = date5?.affects ?? { adar: isPlainAdarDeath(finalDate), shortMonth: isShortMonthDeath(finalDate) };
+      if (adar !== null && !affects.adar) {
+        done(skip("adarObservance", "An Adar choice applies only to a death in plain Adar of a common year."));
+        continue;
+      }
+      if (short !== null && !affects.shortMonth) {
+        done(skip("shortMonthChoice", "A short-month choice applies only to a death on the 30th of Cheshvan or Kislev."));
+        continue;
+      }
+      const adarNow = adar ?? (target !== null && affects.adar ? target.adarObservance : null);
+      const shortNow = short ?? (target !== null && affects.shortMonth ? target.shortMonthChoice : null);
+      const dateBody = { kind: "hebrew", hebrew: heb(finalDate) };
+      const reasonOf = (sentences) => sentences.length === 0 ? {} : { reason: sentences.join(" ") };
+      const shownDates = date5 === null ? {} : { dates: shown(date5) };
+      if (target === null) {
+        const name2 = `${keeper.key}|${deceasedKey(cells.name)}`;
+        const claim2 = `new|${name2}|${hebrewDateWords(finalDate)}`;
+        const earlier = claimed.get(claim2);
+        if (earlier !== void 0) {
+          done({ row, label, action: "skip", reason: `Repeats row ${String(earlier)} (the same name for the same keeper). Two people of one name are told apart by their dates of death.` });
+          continue;
+        }
+        if (keeper.memberId !== null && (heldBy.get(keeper.key) ?? 0) >= MAX_YAHRZEITS_PER_MEMBER) {
+          done(skip("keeper", `${keeper.words}'s record already holds ${String(MAX_YAHRZEITS_PER_MEMBER)} yahrzeits, the most it may.`));
+          continue;
+        }
+        claimed.set(claim2, row);
+        if (keeper.memberId !== null) heldBy.set(keeper.key, (heldBy.get(keeper.key) ?? 0) + 1);
+        const sameName = added.get(name2);
+        if (sameName === void 0) added.set(name2, row);
+        const asHebrewName = yahrzeits.filter((y) => keeperOfView(y).key === keeper.key && y.hebrewName !== null && deceasedKey(y.hebrewName) === deceasedKey(cells.name));
+        const input2 = {
+          ...keeper.memberId === null ? {} : { memberId: keeper.memberId },
+          name: cells.name,
+          ...cells.hebrewName === "" ? {} : { hebrewName: cells.hebrewName },
+          date: dateBody,
+          ...adarNow === null ? {} : { adarObservance: adarNow },
+          ...shortNow === null ? {} : { shortMonthChoice: shortNow }
+        };
+        const sentences = [
+          `A new yahrzeit kept by ${keeper.words}.`,
+          ...sameName === void 0 ? [] : [`Row ${String(sameName)} adds one of the same name with another date of death, so these are two people.`],
+          ...asHebrewName.map((y) => `Kept by the same keeper: ${y.yahrzeitId} has this as its Hebrew name. If it is the same person, add the id.`),
+          ...dateNotes
+        ];
+        done(
+          { row, label, action: "create", ...reasonOf(sentences), ...shownDates },
+          { commandId: keeper.memberId === null ? "congregationYahrzeits.create" : "yahrzeits.createForMember", input: input2, rows: [row], before: null }
+        );
+        continue;
+      }
+      const record3 = `yahrzeits/${target.yahrzeitId}`;
+      const renames = cells.id !== "" && cells.name !== "";
+      const name = renames ? cells.name : target.name;
+      const spelling = !renames && cells.name !== "" && cells.name !== target.name ? [`The sheet writes this name as ${cells.name}; the record's spelling ${target.name} is kept (matched ignoring case, spacing and nikkud): add the id to rename it.`] : [];
+      const hebrewName = cells.hebrewName === "" ? target.hebrewName : cells.hebrewName;
+      const made = [
+        ...name === target.name ? [] : [{ record: record3, field: "name", from: target.name, to: name }],
+        ...hebrewName === target.hebrewName ? [] : [{ record: record3, field: "hebrewName", from: target.hebrewName, to: hebrewName }],
+        ...sameDate(finalDate, target.hebrewDate) ? [] : [{ record: record3, field: "hebrewDate", from: hebrewDateWords(target.hebrewDate), to: hebrewDateWords(finalDate) }],
+        ...adarNow === target.adarObservance ? [] : [{ record: record3, field: "adarObservance", from: target.adarObservance, to: adarNow }],
+        ...shortNow === target.shortMonthChoice ? [] : [{ record: record3, field: "shortMonthChoice", from: target.shortMonthChoice, to: shortNow }]
+      ];
+      if (made.length === 0) {
+        done({ row, label, action: "unchanged", ...reasonOf([...spelling, ...dateNotes]), ...shownDates });
+        continue;
+      }
+      const correction = !target.correctionOnly ? [] : [onlyHebrewName(made) ? HEBREW_NAME_NOTE : target.siddurYahrzeitId === null ? PORTAL_CORRECTION_NOTE : CORRECTION_NOTE];
+      if (target.correctionOnly) shares += 1;
+      const { nextDate: _next, ...held } = target;
+      const cmd = need2(keeper.memberId === null ? "congregationYahrzeits.update" : "yahrzeits.updateForMember");
+      const readId = cmd.contract.backup === "none" ? "yahrzeits.all" : cmd.contract.backup.reads[0] ?? "yahrzeits.all";
+      done(
+        { row, label, action: "update", ...reasonOf([...correction, ...spelling, ...dateNotes]), ...shownDates, changes: made },
+        {
+          commandId: cmd.id,
+          rows: [row],
+          before: { [readId]: held },
+          input: {
+            ...keeper.memberId === null ? {} : { memberId: keeper.memberId },
+            yahrzeitId: target.yahrzeitId,
+            version: target.version,
+            name,
+            hebrewName,
+            adarObservance: adarNow,
+            shortMonthChoice: shortNow,
+            date: dateBody
+          }
+        },
+        made
+      );
+    }
+    const count = (action) => rows.filter((r) => r.action === action).length;
+    const ambiguous = count("ambiguous");
+    const backup = need2("yahrzeits.updateForMember").contract.backup;
+    const undo = shares > 0 && backup !== "none" && backup.note !== void 0 ? { restore: "partial", note: backup.note } : { restore: "full", note: ALL_PUT_BACK };
+    const notes = [
+      ...steps.length === 0 ? ["Nothing to do: every row is already as the sheet says, or is skipped."] : [],
+      ...ambiguous === 0 ? [] : [`${String(ambiguous)} ${ambiguous === 1 ? "row matches" : "rows match"} more than one yahrzeit and ${ambiguous === 1 ? "is" : "are"} left out: add the id column to say which one.`],
+      ...count("create") === 0 ? [] : [ADDED_NOTE],
+      ...unused.length === 0 ? [] : [`The column mapping names ${unused.map((key) => JSON.stringify(key)).join(", ")}, which no header of the sheet matches, so ${unused.length === 1 ? "it is" : "they are"} not used.`]
+    ];
+    return {
+      ok: true,
+      data: {
+        commandId: "yahrzeits.updateForMember",
+        steps,
+        rows,
+        changes,
+        notes,
+        undo,
+        extra: { mapping: proposalOf(sheet.header, sheet.columns), ignoredColumns: sheet.ignored }
+      }
+    };
+  }
+};
+function yahrzeitMappingOf(table2, mapping = {}) {
+  const header = headerCells(table2);
+  return proposalOf(header, yahrzeitColumnsOf(header, mapping).columns);
+}
+function unreadable2(table2, error62) {
+  return unreadableSheet(table2, error62, {
+    page: WORKFLOW_ID,
+    columnsMissing: (e) => e === NEEDS_KEEPER_AND_NAME,
+    propose: (t) => yahrzeitMappingOf(t),
+    mapHint: `A map file says which header is which column (${YAHRZEIT_COLUMNS.join(", ")}), and one that is not there yet is written with these headers to edit. Map the columns, then plan again.`
+  });
+}
+
+// ../backend/src/core/csv.ts
+function csvCell(value) {
+  const text2 = value ?? "";
+  const safe = /^[=+\-@\t\r]/.test(text2) ? `'${text2}` : text2;
+  return `"${safe.replace(/"/g, '""')}"`;
+}
+function csvDocument(headers, rows) {
+  return `\uFEFF${[headers, ...rows].map((row) => row.map(csvCell).join(",")).join("\r\n")}`;
+}
+
+// src/tool/workflows/yahrzeits-export.ts
+var yahrzeitsExport = {
+  id: "yahrzeits.export",
+  words: ["yahrzeits", "export"],
+  summary: "Export every yahrzeit as a spreadsheet (CSV): one row each, with its id, keeper and dates.",
+  description: "Writes every yahrzeit the congregation remembers, the office's and the members' shares, as CSV text: id, keeper (a member's email, or congregation), name, Hebrew name, Hebrew date, the choices, and the next anniversary. Edit it and give it back to yahrzeits bulk, which matches each row by its id.",
+  effect: "read",
+  uses: ["yahrzeits.all", "members.list"],
+  input: external_exports.strictObject({}),
+  async run(ctx) {
+    const read2 = await readYahrzeitsAndMembers(ctx, "yahrzeits.export");
+    if (!read2.ok) return read2;
+    const emails = new Map(read2.data.people.map((p) => [p.memberId, p.onlyOne ? p.email : null]));
+    return { ok: true, data: csvDocument(EXPORT_HEADERS, read2.data.yahrzeits.map((y) => exportRow(y, (id2) => emails.get(id2) ?? null))) };
+  }
+};
+
 // src/tool/workflows/index.ts
-var WORKFLOWS = [membersImportSheet];
+var WORKFLOWS = [membersImportSheet, yahrzeitsExport, yahrzeitsBulk, automationsPresets, automationsCreateFromPreset];
 
 // src/tool/workflows/workflow.ts
 var workflowById = (id2) => WORKFLOWS.find((wf) => wf.id === id2) ?? null;
@@ -43343,7 +44149,7 @@ function draftOf(automation) {
 var PROPOSED_REACH = "automations.comingUp (new words)";
 function channelsOfAutomation(automation) {
   const steps = Array.isArray(automation["steps"]) ? automation["steps"].filter(isRecord) : [];
-  return [...new Set(steps.flatMap((step) => Array.isArray(step["channels"]) ? step["channels"].filter(isRecord).map((c) => String(c["channel"])) : []))];
+  return [...new Set(steps.flatMap((step2) => Array.isArray(step2["channels"]) ? step2["channels"].filter(isRecord).map((c) => String(c["channel"])) : []))];
 }
 async function enableReach(ctx, cmd, draft) {
   if (draft === null) return { ok: true, data: null };
@@ -43802,8 +44608,8 @@ async function planWorkflow(ctx, wf, input2, options = {}) {
   const made = await finish(ctx, {
     commandId: draft.commandId,
     input: {},
-    steps: draft.steps.map(({ before: _before, ...step }) => step),
-    before: { steps: draft.steps.map((step) => step.before) },
+    steps: draft.steps.map(({ before: _before, ...step2 }) => step2),
+    before: { steps: draft.steps.map((step2) => step2.before) },
     changes: draft.changes,
     rows: draft.rows,
     ...draft.extra === void 0 ? {} : { extra: draft.extra },
@@ -43821,10 +44627,10 @@ async function backedUp(ctx, store, run2, steps, before) {
   const file2 = opened.data;
   const calls = [];
   let last2 = { ok: true, data: null };
-  for (const [index3, step] of steps.entries()) {
-    const cmd = commandById(step.commandId);
-    if (cmd === null) return { calls, result: fail2(unknownCall(step)) };
-    const input2 = index3 === 0 || !last2.ok ? step.input : withVersionFrom(cmd, step.input, last2.data);
+  for (const [index3, step2] of steps.entries()) {
+    const cmd = commandById(step2.commandId);
+    if (cmd === null) return { calls, result: fail2(unknownCall(step2)) };
+    const input2 = index3 === 0 || !last2.ok ? step2.input : withVersionFrom(cmd, step2.input, last2.data);
     const result = await executeUnguarded(ctx, cmd, input2);
     calls.push({ at: await recordResult(ctx, store, file2, result), ok: result.ok });
     if (!result.ok) {
@@ -43861,26 +44667,26 @@ async function openBackup(ctx, store, run2, before) {
     }));
   }
 }
-async function recordResult(ctx, store, file2, result, step) {
+async function recordResult(ctx, store, file2, result, step2) {
   const at = ctx.now().toISOString();
-  const which = step === void 0 ? {} : { step };
+  const which = step2 === void 0 ? {} : { step: step2 };
   try {
     await store.append(file2, result.ok ? { at, ok: true, data: result.data, ...which } : { at, ok: false, error: result.error, ...which });
   } catch {
   }
   return at;
 }
-async function recordStarted(ctx, store, file2, step) {
+async function recordStarted(ctx, store, file2, step2) {
   try {
-    await store.append(file2, { kind: "started", at: ctx.now().toISOString(), step });
+    await store.append(file2, { kind: "started", at: ctx.now().toISOString(), step: step2 });
   } catch {
   }
 }
-var unknownCall = (step) => cliError("internal", `The plan calls ${step.commandId}, which this CLI does not know.`, { hint: "Upgrade the CLI, or make a new plan." });
+var unknownCall = (step2) => cliError("internal", `The plan calls ${step2.commandId}, which this CLI does not know.`, { hint: "Upgrade the CLI, or make a new plan." });
 var rowWords = (rows) => `${rows.length === 1 ? "row" : "rows"} ${rows.join(", ")}`;
 async function independentSteps(ctx, store, stored, before) {
   const wf = stored.workflowId === void 0 ? null : workflowById(stored.workflowId);
-  const outside = wf === null ? void 0 : stored.steps.find((step) => !wf.uses.includes(step.commandId));
+  const outside = wf === null ? void 0 : stored.steps.find((step2) => !wf.uses.includes(step2.commandId));
   if (wf !== null && outside !== void 0) return { calls: [], result: fail2(outsideUses(wf.id, outside.commandId)) };
   const opened = await openBackup(ctx, store, {
     commandId: stored.commandId,
@@ -43891,12 +44697,12 @@ async function independentSteps(ctx, store, stored, before) {
   if (!opened.ok) return { calls: [], result: opened };
   const calls = [];
   const failed2 = [];
-  for (const [index3, step] of stored.steps.entries()) {
-    const cmd = commandById(step.commandId);
+  for (const [index3, step2] of stored.steps.entries()) {
+    const cmd = commandById(step2.commandId);
     if (cmd !== null) await recordStarted(ctx, store, opened.data, index3);
-    const result = cmd === null ? fail2(unknownCall(step)) : await executeUnguarded(ctx, cmd, step.input);
+    const result = cmd === null ? fail2(unknownCall(step2)) : await executeUnguarded(ctx, cmd, step2.input);
     calls.push({ at: await recordResult(ctx, store, opened.data, result, index3), ok: result.ok });
-    if (!result.ok) failed2.push({ rows: step.rows ?? [], error: result.error });
+    if (!result.ok) failed2.push({ rows: step2.rows ?? [], error: result.error });
   }
   const total = stored.steps.length;
   const answer2 = { steps: total, ok: total - failed2.length, failed: failed2, backup: opened.data };
@@ -44018,7 +44824,7 @@ function gatedPlan(made) {
 function plannedCommands(made) {
   const wf = made.restoreOf === void 0 && made.workflowId !== void 0 ? workflowById(made.workflowId) : null;
   if (wf !== null) return usedCommands(wf);
-  const ids = made.workflowId === void 0 ? [made.commandId] : [...new Set(made.steps.map((step) => step.commandId))];
+  const ids = made.workflowId === void 0 ? [made.commandId] : [...new Set(made.steps.map((step2) => step2.commandId))];
   return ids.flatMap((id2) => {
     const cmd = commandById(id2);
     return cmd === null ? [] : [cmd];
@@ -44071,7 +44877,7 @@ async function runWorkflow(ctx, wf, input2) {
   if (wf.run === void 0) return fail2(cliError("internal", `${wf.id} has nothing to run: it is a mistake in this CLI.`, { page: wf.id, hint: "Upgrade the CLI, and report it if it stays." }));
   return wf.run({ ...ctx, only: usesOnly(wf) }, asObject(input2));
 }
-function changedSince(cmd, restorer, original, written2, current, label) {
+function changedSince(cmd, restorer, original, written2, current, label, was) {
   if (written2 !== void 0) {
     const back = restorer({ before: written2, current, originalInput: original });
     if (!back.ok) return [back.message];
@@ -44080,6 +44886,8 @@ function changedSince(cmd, restorer, original, written2, current, label) {
   const record3 = namedIn(cmd, current, original);
   if (record3 === null) return [];
   const now = projectionFor(cmd)(record3);
+  const held = namedIn(cmd, was, original);
+  if (held !== null && fieldKeys(cmd).every((key) => !(key in now) || sameSent(projectionFor(cmd)(held)[key], now[key]))) return [];
   return fieldKeys(cmd).filter((key) => original[key] !== void 0 && key in now && !sameSent(original[key], now[key]));
 }
 async function restorePlan(ctx, backup, backupFile, save = true) {
@@ -44153,17 +44961,17 @@ async function restoreOne(here, cmd, restorer, was, original, written2, results,
   const spec = cmd.contract.backup;
   if (spec === "none" || spec.restore !== "recreate") {
     if (current === null && was !== null) return { kind: "gone" };
-    const since = current === null || judgesItself(cmd) ? [] : changedSince(cmd, restorer, original, written2, current, recordLabel(cmd, original));
+    const since = current === null || judgesItself(cmd) ? [] : changedSince(cmd, restorer, original, written2, current, recordLabel(cmd, original), was);
     if (since.length > 0) return { kind: "changed", fields: since };
   }
   const back = restorer({ before: was, current, originalInput: original, ...results === void 0 ? {} : { results }, ...more });
   if (!back.ok) return { kind: "refused", code: back.code, message: back.message };
   if (back.steps.length === 0) return { kind: "same" };
-  for (const step of back.steps) {
-    const stepCmd = commandById(step.commandId);
-    const refused3 = stepCmd === null ? cliError("internal", `This CLI has no command ${step.commandId}.`) : checkInput(stepCmd, step.input);
+  for (const step2 of back.steps) {
+    const stepCmd = commandById(step2.commandId);
+    const refused3 = stepCmd === null ? cliError("internal", `This CLI has no command ${step2.commandId}.`) : checkInput(stepCmd, step2.input);
     if (refused3 !== null) {
-      return { kind: "failed", result: fail2(cliError("internal", `The restore of ${recordLabel(cmd, original)} would send what ${step.commandId} refuses (${refused3.message}), so it was not planned.`, {
+      return { kind: "failed", result: fail2(cliError("internal", `The restore of ${recordLabel(cmd, original)} would send what ${step2.commandId} refuses (${refused3.message}), so it was not planned.`, {
         contract: cmd.contract,
         hint: "This is a mistake in the CLI: upgrade it, and report it if it stays."
       })) };
@@ -44239,24 +45047,55 @@ async function restoreWorkflowPlan(ctx, backup, backupFile, save = true) {
   const left = [];
   const partial2 = /* @__PURE__ */ new Set();
   let stays = 0;
-  for (const [index3, step] of (backup.steps ?? []).entries()) {
+  let removed = 0;
+  let yahrzeitsRead = null;
+  const yahrzeitsNow = async () => {
+    if (yahrzeitsRead === null) {
+      const all = commandById("yahrzeits.all");
+      const answered = all === null ? fail2(cliError("internal", "This CLI has no command yahrzeits.all.")) : await executeUnguarded(here, all, {});
+      yahrzeitsRead = answered.ok ? { ok: true, data: Array.isArray(answered.data) ? answered.data : [] } : answered;
+    }
+    return yahrzeitsRead;
+  };
+  for (const [index3, step2] of (backup.steps ?? []).entries()) {
     const ran = results.find((entry) => entry.step === index3);
     const uncertain = ran === void 0 ? sentOnly.has(index3) : !ran.ok && !changedNothing(ran);
     if (!uncertain && (ran === void 0 || !ran.ok)) continue;
-    const cmd = commandById(step.commandId);
-    if (cmd === null) return fail2(cliError("internal", `This backup calls ${step.commandId}, which this CLI does not know.`, { hint: "Upgrade the CLI." }));
+    const cmd = commandById(step2.commandId);
+    if (cmd === null) return fail2(cliError("internal", `This backup calls ${step2.commandId}, which this CLI does not know.`, { hint: "Upgrade the CLI." }));
     const restorer = restorerFor(cmd);
-    const label = `${recordLabel(cmd, step.input)}${step.rows === void 0 || step.rows.length === 0 ? "" : ` (${rowWords(step.rows)})`}`;
+    const label = `${recordLabel(cmd, step2.input)}${step2.rows === void 0 || step2.rows.length === 0 ? "" : ` (${rowWords(step2.rows)})`}`;
     if (uncertain) left.push(mayHaveChanged(label, index3, ran));
+    const del = takeBackFor(cmd);
+    if (del !== null && ran?.ok === true && isRecord(ran.data)) {
+      const now = await yahrzeitsNow();
+      if (!now.ok) return now;
+      const id2 = ran.data["yahrzeitId"];
+      const current = now.data.find((y) => isRecord(y) && y["yahrzeitId"] === id2) ?? null;
+      const back = takeBack(del, ran.data, current, label);
+      if (!back.ok) return fail2(cliError(back.code, back.message));
+      for (const call of back.steps) {
+        const refused3 = checkInput(del, call.input);
+        if (refused3 !== null) return fail2(cliError("internal", `The restore of ${label} would send what ${del.id} refuses (${refused3.message}), so it was not planned.`, { hint: "This is a mistake in the CLI: upgrade it, and report it if it stays." }));
+        const before = await readBefore(here, del, call.input);
+        if (!before.ok) return before;
+        steps.push({ commandId: call.commandId, input: call.input, ...step2.rows === void 0 ? {} : { rows: step2.rows } });
+        stepBefores.push(before.data);
+      }
+      if (back.steps.length > 0) removed += 1;
+      changes.push(...back.changes);
+      left.push(...back.left ?? []);
+      continue;
+    }
     if (restorer === null) {
-      if (uncertain) left.push(`${label}: what it may have made stays, as no route takes a new record back.`);
+      if (uncertain) left.push(takeBackFor(cmd) === null ? `${label}: what it may have made stays, as no route takes a new record back.` : `${label}: what it may have added stays, as this restore cannot tell what it made: check yahrzeits all.`);
       else stays += 1;
       continue;
     }
     const written2 = ran?.ok === true && (isRecord(ran.data) || Array.isArray(ran.data)) ? ran.data : void 0;
     const extra = await extraReads(here, cmd, befores[index3] ?? null);
     if (!extra.ok) return extra;
-    const one2 = await restoreOne(here, cmd, restorer, primaryOf(cmd, befores[index3] ?? null), step.input, written2, ran?.ok === true ? ran.data : void 0, {
+    const one2 = await restoreOne(here, cmd, restorer, primaryOf(cmd, befores[index3] ?? null), step2.input, written2, ran?.ok === true ? ran.data : void 0, {
       ...uncertain ? { uncertain: true } : {},
       ...extra.data === void 0 ? {} : { extra: extra.data }
     });
@@ -44270,7 +45109,7 @@ async function restoreWorkflowPlan(ctx, backup, backupFile, save = true) {
       if (callCmd === null) return fail2(cliError("internal", `This CLI has no command ${call.commandId}.`));
       const before = await readBefore(here, callCmd, call.input);
       if (!before.ok) return before;
-      steps.push({ commandId: call.commandId, input: call.input, ...step.rows === void 0 ? {} : { rows: step.rows } });
+      steps.push({ commandId: call.commandId, input: call.input, ...step2.rows === void 0 ? {} : { rows: step2.rows } });
       stepBefores.push(before.data);
     }
     changes.push(...one2.back.changes);
@@ -44287,7 +45126,10 @@ async function restoreWorkflowPlan(ctx, backup, backupFile, save = true) {
       hint: left.length > 0 ? "Look at the records as they are now, and change them by hand if that is still wanted." : "Nothing was changed."
     }));
   }
-  const notes = [...partial2, ...left, ...kept.length > 0 ? [`Left as they are now: ${kept.join(", ")} (${KEPT_WORDS}).`] : [], ...stayed];
+  const takenBack = removed === 0 ? [] : [
+    `${String(removed)} ${removed === 1 ? "record it created is" : "records it created are"} removed. Each removal is backed up, so this restore can itself be put back.`
+  ];
+  const notes = [...partial2, ...left, ...kept.length > 0 ? [`Left as they are now: ${kept.join(", ")} (${KEPT_WORDS}).`] : [], ...stayed, ...takenBack];
   const made = await finish(here, {
     commandId: first.commandId,
     input: {},
@@ -44302,6 +45144,19 @@ async function restoreWorkflowPlan(ctx, backup, backupFile, save = true) {
   return { ok: true, data: made };
 }
 
+// src/tool/next.ts
+var hinted = (next) => `\`${next.command}\`${next.input === void 0 ? "" : ` with ${JSON.stringify(next.input)}`}`;
+function withNext(result, write) {
+  if (!result.ok) {
+    const { error: error62 } = result;
+    if (error62.next === void 0 || error62.next.length === 0) return result;
+    return { ok: false, error: { ...error62, hint: `${error62.hint} Run: ${error62.next.map((s) => hinted(write(s))).join(", then ")}.` } };
+  }
+  if (result.suggested === void 0) return result;
+  const { suggested, ...rest } = result;
+  return { ...rest, next: [...result.next ?? [], ...suggested.map(write)] };
+}
+
 // examples/shared.ts
 var day = (ahead) => new Date(Date.now() + ahead * 864e5).toISOString().slice(0, 10);
 var withVersion = (fields, version3) => JSON.stringify(fields).replace(/\}$/, version3 === void 0 || version3 === null ? "}" : `,"version":${version3}}`);
@@ -45304,13 +46159,28 @@ var AUTOMATIONS_EXAMPLES = [
     expect: { exit: 2, json: { ok: false, "error.message": { $contains: "{deceased_name} needs a yahrzeit trigger" } } }
   },
   {
-    id: "automations-create",
-    command: "automations.create",
-    title: "Make the yahrzeit reminder (the gallery's preset): it is saved turned off, at version 1, and sends nothing; a version of 0 says it is new",
-    argv: ["automations", "create", "--body", "-"],
-    stdin: withVersion(YAHRZEIT(), "0"),
+    id: "automations-create-from-typo",
+    command: "automations.createFromPreset",
+    title: "A realistic mistake: a preset's name is misspelt, so nothing is made, exit 2, with the nearest id and the list of ids",
+    argv: ["automations", "create", "--from", "yahrzeit"],
+    as: "admin",
+    expect: { exit: 2, json: { ok: false, "error.code": "invalid-input", "error.message": { $contains: 'Did you mean "yahrzeit-reminder"?' }, "error.hint": { $contains: "yahrzeit-reminder, birthday, wedding, b-mitzvah, shabbat-list" } } }
+  },
+  {
+    id: "automations-presets",
+    command: "automations.presets",
+    title: "List the gallery's presets: each one's id, what sets it off, when it goes and its channels. Nothing is saved or sent",
+    argv: ["automations", "presets"],
+    as: "admin",
+    expect: { exit: 0, json: { ok: true, "data.[presetId=yahrzeit-reminder].sendAt": 540, "data.[presetId=yahrzeit-reminder].channels": ["push", "email"] } }
+  },
+  {
+    id: "automations-create-from",
+    command: "automations.createFromPreset",
+    title: "Make the yahrzeit reminder from the gallery's preset: it is saved turned off, at version 1, and sends nothing; the answer names what to run next",
+    argv: ["automations", "create", "--from", "yahrzeit-reminder"],
     as: "admin",
-    expect: { exit: 0, json: { ok: true, "data.automation.usable": true, "data.automation.automation.enabled": false, "data.automation.automation.version": 1 } },
+    expect: { exit: 0, json: { ok: true, "data.automation.usable": true, "data.automation.automation.name": "Yahrzeit reminder", "data.automation.automation.enabled": false, "data.automation.automation.version": 1 } },
     saves: { autoId: "data.automation.automation.automationId", autoVersion: "data.automation.automation.version", autoStepId: "data.automation.automation.steps.0.stepId" }
   },
   {
@@ -46749,6 +47619,22 @@ var DATES_EXAMPLES = [
     as: "admin",
     expect: { exit: 0, json: { ok: true, "data.hebrew.year": 5779, "data.hebrew.month": 1, "data.hebrew.day": 8 } }
   },
+  {
+    id: "dates-resolve-hebrew",
+    command: "dates.resolve",
+    title: "See the civil day of a Hebrew date, checked as a yahrzeit's is (8 Nisan 5779)",
+    argv: ["dates", "resolve", "--hebrew", '{"year":5779,"month":1,"day":8}', "--calendar", "hebrew"],
+    as: "admin",
+    expect: { exit: 0, json: { ok: true, "data.civil": "2019-04-13", "data.hebrewWords": "8 Nisan 5779" } }
+  },
+  {
+    id: "dates-resolve-hebrew-not-a-day",
+    command: "dates.resolve",
+    title: "A Hebrew date the year does not have is refused: Cheshvan 5784 has 29 days",
+    argv: ["dates", "resolve", "--hebrew", '{"year":5784,"month":8,"day":30}', "--calendar", "hebrew"],
+    as: "admin",
+    expect: { exit: 2, json: { ok: false, "error.message": { $contains: "date.hebrew is not a day of the Hebrew calendar" } } }
+  },
   {
     id: "dates-resolve-future",
     command: "dates.resolve",
@@ -48701,6 +49587,162 @@ var AVRAHAM2 = (day2, version3) => withVersion({ name: "Avraham Levi", hebrewNam
 var SARA = JSON.stringify({ name: "Sara Levi", date: { kind: "gregorian", gregorian: "2015-06-10", afterSunset: false } });
 var FUTURE2 = JSON.stringify({ name: "Avraham Levi", date: { kind: "gregorian", gregorian: "2999-01-01", afterSunset: false } });
 var MOVE = (from, version3) => `{"yahrzeitId":"{yahrzeitId}","fromMemberId":"${from}","toMemberId":null,"version":${version3}}`;
+var KEEPER2 = "dina.{scopeSlug}@example.test";
+var SEED = (name, month, day2) => JSON.stringify({ name, date: { kind: "hebrew", hebrew: { year: 5779, month, day: day2 } } });
+var BULK_SHEET = [
+  "Id,Keeper,Name,Hebrew date,Civil date,After sunset",
+  `{bulkFirstId},${KEEPER2},Sarah Cohen,9 Nisan 5779,,`,
+  `{bulkSecondId},${KEEPER2},Sarah Cohen,,2015-06-10,no`,
+  "{bulkCongId},congregation,Rabbi Moshe Stein,5 Sivan 5750,,",
+  `,${KEEPER2},Miriam Shapiro,12 Tishrei 5760,,`
+].join("\n");
+var BULK_EXAMPLES = [
+  {
+    id: "yahrzeits-bulk-keeper",
+    command: "members.create",
+    title: "Add the member whose yahrzeits a sheet will change: her email holds this run's own slug, so no other record can match it",
+    argv: ["members", "create", "--first-name", "Dina", "--last-name", "Mayer", "--email", KEEPER2],
+    as: "admin",
+    expect: { exit: 0, json: { ok: true, "data.firstName": "Dina" } },
+    saves: { bulkKeeperId: "data.memberId" }
+  },
+  {
+    id: "yahrzeits-bulk-seed-first",
+    command: "yahrzeits.createForMember",
+    title: "Add Sarah Cohen's yahrzeit to her record",
+    argv: ["yahrzeits", "create-for-member", "--member-id", "{bulkKeeperId}", "--body", "-"],
+    stdin: SEED("Sarah Cohen", 1, 8),
+    as: "admin",
+    expect: { exit: 0, json: { ok: true, "data.name": "Sarah Cohen" } },
+    saves: { bulkFirstId: "data.yahrzeitId" }
+  },
+  {
+    id: "yahrzeits-bulk-seed-second",
+    command: "yahrzeits.createForMember",
+    title: "Add a second yahrzeit with the same name on the same record: a different Sarah Cohen, died on another day",
+    argv: ["yahrzeits", "create-for-member", "--member-id", "{bulkKeeperId}", "--body", "-"],
+    stdin: SEED("Sarah Cohen", 2, 3),
+    as: "admin",
+    expect: { exit: 0, json: { ok: true, "data.name": "Sarah Cohen" } },
+    saves: { bulkSecondId: "data.yahrzeitId" }
+  },
+  {
+    id: "yahrzeits-bulk-seed-congregation",
+    command: "congregationYahrzeits.create",
+    title: "Add a yahrzeit the congregation keeps itself",
+    argv: ["congregation-yahrzeits", "create", "--body", "-"],
+    stdin: SEED("Rabbi Moshe Stein", 3, 3),
+    as: "admin",
+    expect: { exit: 0, json: { ok: true, "data.keeper.kind": "congregation" } },
+    saves: { bulkCongId: "data.yahrzeitId" }
+  },
+  {
+    id: "yahrzeits-export",
+    command: "yahrzeits.export",
+    title: "Export every yahrzeit as CSV: a header row, then one row each with its id, keeper and dates",
+    argv: ["yahrzeits", "export"],
+    as: "admin",
+    expect: { exit: 0, json: { ok: true, data: { $contains: '"id","keeper","name","hebrewName","hebrewDate"' } } }
+  },
+  {
+    id: "yahrzeits-bulk-unmapped",
+    command: "yahrzeits.bulk",
+    title: "A sheet whose keeper and name columns the reader does not know is refused, exit 2, naming the headers it found and how to map them",
+    argv: ["yahrzeits", "bulk", "unmapped.csv"],
+    files: { "unmapped.csv": ["Contact,Deceased person,Died", `${KEEPER2},Sarah Cohen,9 Nisan 5779`].join("\n") },
+    as: "admin",
+    expect: {
+      exit: 2,
+      json: { ok: false, "error.message": { $contains: "The headers found: Contact, Deceased person, Died" }, "error.hint": { $contains: "orzarua yahrzeits bulk unmapped.csv --map map.json" } }
+    }
+  },
+  {
+    id: "yahrzeits-bulk-ambiguous-plan",
+    command: "yahrzeits.bulk",
+    title: "A sheet that names Sarah Cohen without her id: two yahrzeits of that name for this keeper, so the row is ambiguous and left out, with the hint to add the id",
+    argv: ["yahrzeits", "bulk", "ambiguous.csv"],
+    files: { "ambiguous.csv": ["Keeper,Name,Hebrew date", `${KEEPER2},Sarah Cohen,9 Nisan 5779`].join("\n") },
+    as: "admin",
+    expect: { exit: 7, json: { "error.plan.rows.0.action": "ambiguous", "error.plan.rows.0.reason": { $contains: "add the id column" }, "error.plan.steps": [] } }
+  },
+  {
+    id: "yahrzeits-bulk-plan",
+    command: "yahrzeits.bulk",
+    title: "The same sheet with the ids filled in, a civil date and a congregation row: a plan that shows both dates of the civil row, and adds Miriam Shapiro",
+    argv: ["yahrzeits", "bulk", "yahrzeits.csv"],
+    files: { "yahrzeits.csv": BULK_SHEET },
+    as: "admin",
+    expect: {
+      exit: 7,
+      json: {
+        "error.plan.rows.0.action": "update",
+        "error.plan.rows.0.changes.0.to": "9 Nisan 5779",
+        "error.plan.rows.0.dates.civil": "2019-04-14",
+        "error.plan.rows.1.action": "update",
+        "error.plan.rows.1.dates.civil": "2015-06-10",
+        "error.plan.rows.1.dates.hebrew": "23 Sivan 5775",
+        "error.plan.rows.2.action": "update",
+        "error.plan.rows.3.action": "create"
+      }
+    }
+  },
+  {
+    id: "yahrzeits-bulk-confirm",
+    command: "yahrzeits.bulk",
+    title: "Confirm the plan: three yahrzeits are changed and one is added; the answer names the backup the run left",
+    argv: ["yahrzeits", "bulk", "--confirm", "{planId}"],
+    as: "admin",
+    expect: { exit: 0, json: { ok: true, "data.steps": 4, "data.ok": 4, "data.backup": { $present: true } } },
+    saves: { bulkBackup: "data.backup" }
+  },
+  {
+    id: "yahrzeits-bulk-all",
+    command: "yahrzeits.all",
+    title: "List every yahrzeit again: the changes are there",
+    argv: ["yahrzeits", "all"],
+    as: "admin",
+    expect: { exit: 0, json: { ok: true, "data.[yahrzeitId={bulkFirstId}].hebrewDate.day": 9, "data.[yahrzeitId={bulkSecondId}].hebrewDate.day": 23, "data.[yahrzeitId={bulkSecondId}].hebrewDate.year": 5775 } }
+  },
+  {
+    id: "yahrzeits-bulk-restore-plan",
+    command: "restore",
+    title: "Plan putting the sheet's changes back, from its own backup: the three changed yahrzeits go back, and the one it added (Miriam Shapiro) is removed",
+    argv: ["restore", "{bulkBackup}"],
+    as: "admin",
+    expect: {
+      exit: 7,
+      json: {
+        "error.plan.changes.0.field": "date.hebrew.day",
+        "error.plan.steps.3.commandId": "yahrzeits.deleteForMember",
+        "error.plan.notes": { $contains: "1 record it created is removed" }
+      }
+    }
+  },
+  {
+    id: "yahrzeits-bulk-restore-confirm",
+    command: "restore",
+    title: "Confirm the restore: three put back and one removed",
+    argv: ["restore", "--confirm", "{planId}"],
+    as: "admin",
+    expect: { exit: 0, json: { ok: true, "data.steps": 4, "data.ok": 4 } }
+  },
+  {
+    id: "yahrzeits-bulk-restored",
+    command: "yahrzeits.all",
+    title: "List them once more: the days are as they were",
+    argv: ["yahrzeits", "all"],
+    as: "admin",
+    expect: { exit: 0, json: { ok: true, "data.[yahrzeitId={bulkFirstId}].hebrewDate.day": 8, "data.[yahrzeitId={bulkSecondId}].hebrewDate.day": 3 } }
+  },
+  {
+    id: "yahrzeits-bulk-restored-removed",
+    command: "yahrzeits.listForMember",
+    title: "The keeper's own list: the yahrzeit the sheet added is gone",
+    argv: ["yahrzeits", "list-for-member", "--member-id", "{bulkKeeperId}"],
+    as: "admin",
+    expect: { exit: 0, json: { ok: true, "data.[name=Miriam Shapiro]": { $present: false }, "data.[name=Sarah Cohen].name": "Sarah Cohen" } }
+  }
+];
 var YAHRZEITS_EXAMPLES = [
   {
     id: "yahrzeits-member",
@@ -48849,7 +49891,8 @@ var YAHRZEITS_EXAMPLES = [
     argv: ["yahrzeits", "move", "--confirm", "{planId}"],
     as: "admin",
     expect: { exit: 0, json: { ok: true, "data.keeper.kind": "congregation" } }
-  }
+  },
+  ...BULK_EXAMPLES
 ];
 
 // examples/recipes.ts
@@ -48892,6 +49935,21 @@ var RECIPE_STEPS = {
     "congregation-yahrzeits-create",
     "yahrzeits-month"
   ],
+  "update-yahrzeits-from-a-spreadsheet": [
+    "yahrzeits-bulk-keeper",
+    "yahrzeits-bulk-seed-first",
+    "yahrzeits-bulk-seed-second",
+    "yahrzeits-bulk-seed-congregation",
+    "yahrzeits-export",
+    "yahrzeits-bulk-unmapped",
+    "yahrzeits-bulk-ambiguous-plan",
+    "yahrzeits-bulk-plan",
+    "yahrzeits-bulk-confirm",
+    "yahrzeits-bulk-all",
+    "yahrzeits-bulk-restore-plan",
+    "yahrzeits-bulk-restore-confirm",
+    "yahrzeits-bulk-restored"
+  ],
   "move-a-yahrzeit-to-the-congregation": [
     "yahrzeits-member",
     "yahrzeits-create-for-member",
@@ -49040,8 +50098,9 @@ var RECIPE_STEPS = {
     "automations-comms-settings-get",
     "automations-reply-to-plan",
     "automations-reply-to-confirm",
-    "automations-create-bad-placeholder",
-    "automations-create",
+    "automations-create-from-typo",
+    "automations-presets",
+    "automations-create-from",
     "automations-preview",
     "automations-test-plan",
     "automations-test-confirm",
@@ -49049,7 +50108,10 @@ var RECIPE_STEPS = {
     "automations-enable-no-cost-plan",
     "automations-enable-no-cost-confirm",
     "automations-enable-plan",
-    "automations-enable-confirm"
+    "automations-enable-confirm",
+    "automations-disable",
+    "automations-delete-plan",
+    "automations-delete-confirm"
   ],
   "email-on-a-date": [
     "automations-comms-settings-get",
@@ -49213,7 +50275,7 @@ var attendance_and_visitors_default = "# Attendance, the minyan and visitors\n\n
 var billing_and_credit_default = "# Billing, messaging credit and printed books\n\nWhat a congregation pays Or Zarua for: messaging credit (SMS and WhatsApp messages), the subscription that keeps it open after its trial, and printed books. Ticket money is different: it goes to the congregation's own Stripe account (`orzarua docs tickets`).\n\n```\norzarua credit get\norzarua billing get\norzarua books list-orders\n```\n\nEvery amount is in cents of Australian dollars: `amountMinor: 2000` is A$20.00. Only `payments.configure` or `org.configure` buys, subscribes or orders; staff who draft or send messages read the credit too.\n\n## Stripe's own pages: open them in a browser\n\nThe command line never takes a card, a bank account or an address. A purchase answers a page of Stripe's, which the command line only prints, after the answer:\n\n- **\"Open this link to pay: <url>\"**: Stripe's Checkout, for a pack of credit, the subscription or a book order. A person opens it in a browser and pays there. Nothing is charged until they do, and a page nobody pays closes by itself (about 30 minutes for the subscription, 24 hours otherwise).\n- **\"Open this link in a browser: <url>\"**: any other page, such as Stripe's billing portal (`billing portal`) or Settings, Payments.\n\nWith `--json`, and through the MCP server, the same sentences are in the answer's `links`. An agent gives the link to the person; it never fills in the page for them.\n\nA payment is recorded when Stripe confirms it, a few seconds after the page says paid. Read it again until it shows: `billing get-purchase` for a pack or the subscription, `books get-order` for books.\n\n## GST\n\nEvery platform price is GST-exclusive. For a congregation in Australia, 10% GST is added on top: A$20 of credit costs A$22, the subscription's invoices are tax invoices \"+ GST\", and each top-up has a tax invoice. For a congregation overseas the sale is a GST-free export: the card pays the price alone, and the invoice says so. `credit get` and `billing get` say which applies (`gst`: `taxable`, `export`, or `none` while the platform is not registered). A printed book's price already includes its GST.\n\n## Messaging credit\n\nSMS and WhatsApp messages are paid from the congregation's messaging credit; email and push cost nothing. `credit get` answers what is `available`, what is `held` for messages on their way, the price of each unit by destination country (ex GST), and the credit terms.\n\n**The terms first.** No credit can be bought until the congregation agrees to the credit terms of its country: credit is non-refundable, and credit left when a congregation leaves is forfeited. An admin agrees in their own name:\n\n```\norzarua credit agree --terms-id <terms.text.id>\n```\n\nThis records a legal agreement in the person's name, so it is always a plan, and the person must say yes after reading `terms.text`. An API token can never agree. If the terms changed since they were read, it is refused (`conflict`) and nothing is recorded.\n\n**A pack by card.** `credit buy-pack --amount-minor 2000` (or 5000, 10000) is a plan; its confirm answers the Checkout page and the `purchaseId`. The credit is added once the card is paid there. `orzarua docs top-up-messaging-credit` walks through it.\n\n**A bank transfer.** `credit get` answers `bankTransfer`, the account and the reference to use (the congregation's address); Or Zarua records the transfer, at least A$20. From outside Australia it is an international transfer.\n\n**The history.** `credit ledger` pages through every entry, newest first: a top-up adds credit; a send reserves credit, is charged what it used, and the rest is released; an adjustment is Or Zarua's correction. Pass the page's `next` as `--before` for the page after. `credit receipt --entry-id <id>` is a top-up's invoice. When the available credit falls below the low-balance threshold (comms settings), the admins are emailed once.\n\n## The subscription\n\nA congregation that signed itself up has a 14-day trial. After it, the subscription keeps the congregation open; without one it is locked (reads still work). `billing get` answers where it stands (`standing`: open, in its trial with the days left, or locked), the active records it counts by billing class (members, and everyone else), this month's estimate at today's counts with its GST, the monthly price tiers, and the subscription terms. A congregation in the pilot is exempt (`state: exempt`) and is not billed.\n\n```\norzarua billing subscribe --terms-id <terms.id>\n```\n\nThis is a plan: the person accepts the subscription terms of their country, read in `billing get`. That acceptance is recorded in the person's name, so they must say yes after reading the terms. An API token can never subscribe. Its confirm answers the Checkout page (card, or BECS direct debit in Australia). It is billed monthly, and Or Zarua gives at least 30 days' notice by email before a price change. It works while the congregation is locked: subscribing is what lifts the lock. One Checkout at a time; it is refused when the congregation is exempt or already subscribed.\n\n`billing portal` answers Stripe's billing portal for one visit: change the card, read the invoices, cancel, or mend a subscription that needs attention (a failed payment). It needs a Stripe customer first (a subscription or a card purchase).\n\n## Printed books\n\nThe printed siddurim and the Guide, ordered from Or Zarua at the catalogue's prices, with lower prices from 10 copies of an edition. Or Zarua places each paid order with the printer, usually within two business days, and posts it within Australia only, usually within two to three weeks.\n\n```\norzarua books quote --body order.json\norzarua books start-order --body order.json\n```\n\n`order.json` names editions and copies: `{ \"lines\": [{ \"id\": \"weekday-hardcover-en\", \"quantity\": 10 }] }`. The editions are `weekday-hardcover-en`, `shabbat-hardcover-en`, `hebrew-hardcover-en` and `guide-paperback-en`; only those on sale can be ordered. `books quote` prices it and changes nothing; prices, discounts and shipping are always the catalogue's. From 50 copies there is no price (`quote: true`): email Or Zarua for a quote, and `start-order` refuses it.\n\n`books start-order` is a plan whose preview is the quote. Its confirm answers the Checkout page, where the card and the Australian address are given, and the `orderId`. `books get-order` then follows it: `open` until paid, `paid`, `placed` with the printer (its reference), `shipped` (the tracking), or `refunded`. Until it is placed, the order can be cancelled for a full refund by emailing Or Zarua; after that it is printed to order, and a damaged or faulty copy is replaced or refunded.\n\n## What can't be undone\n\nBuying credit, subscribing and ordering books move money, so each is a plan with its notes and a confirm. None of them can be put back with `restore`: credit is non-refundable, a subscription is cancelled in the billing portal, and a book order is cancelled by email until it is placed.\n\n## Sources\n\nThe congregation platform design (Messaging credit; Congregation billing; Printed books), the prepaid messaging, platform purchases and book orders plans, the international design (GST and the terms by country), the self-serve sign-up design (the trial and the lock), and the CLI design (Stripe-hosted steps).\n";
 
 // docs/guides/automations.md
-var automations_default = '# Automations, the Shabbat list and the Hebrew-date defaults\n\nAn automation is a message that goes by itself on a member\'s date: a yahrzeit reminder three days before, a birthday greeting on the day, a wedding anniversary. A weekly automation sends the Shabbat list to the staff who read it. Members\' dates are in `orzarua docs dates` and `orzarua docs yahrzeits`.\n\n```\norzarua automations list\norzarua automations get --automation-id <automationId>\norzarua automations runs --automation-id <automationId>\norzarua automation-runs list\n```\n\n## Three things must be on before anything sends\n\n1. **The automation is on.** `automations create` saves it turned off.\n2. **The congregation\'s switch is on** (`orzarua automations update-settings --enabled --version <settingsVersion>`, a plan). While it is off nothing sends, whatever each automation says. Turning it on lets every automation that is on send from now: a date due before then is never sent, so nothing old goes out.\n3. **A channel can be used.** Email needs the office\'s reply-to address (`orzarua docs messages`).\n\nTurning an automation on (`automations enable`) and the switch both let people be told, so they are plans the user confirms. Neither sends at that moment: a daily sweep sends each message at its due time.\n\n## Writing an automation\n\nThe body says what fires it, when, and what it sends. A new automation has `"version": 0`; `get` gives the version a change sends back. Triggers and steps get their ids when they are saved, and keep them when the whole automation is sent back.\n\n```json\n{\n  "name": "Yahrzeit reminder",\n  "triggers": [{ "kind": "occasion", "occasion": "yahrzeit", "leadDays": 3 }],\n  "sendAt": 540, "restDays": "before", "shabbat": "following", "grouping": "per-shabbat",\n  "steps": [{\n    "kind": "message", "enabled": true, "to": { "kind": "subject" },\n    "channels": [{ "channel": "push", "mode": "everyone" }, { "channel": "email", "mode": "fallback" }],\n    "title": "The yahrzeit of {deceased_name}",\n    "email": { "subject": "The yahrzeit of {deceased_name}", "blocks": [{ "type": "paragraph", "runs": [{ "text": "{first_name}, the yahrzeit of {deceased_name} begins {begins}." }] }] },\n    "sms": null, "push": { "title": "The yahrzeit of {deceased_name}", "body": "It begins {begins}." }, "whatsapp": false\n  }],\n  "version": 0\n}\n```\n\n- **Triggers:** `occasion` (yahrzeit, birthday, wedding or b-mitzvah, `leadDays` 0 to 30 before it), each occasion once; or one `weekly` trigger (`weekday` 0 Sunday to 6 Saturday), which stands alone. At most 6 triggers and 10 steps; a congregation may have 20 automations.\n- **Time:** `sendAt` is minutes after midnight in the congregation\'s time zone, in steps of 15 (540 is 9:00). SMS, push and WhatsApp cannot be timed inside the overnight quiet hours (`orzarua comms get-settings`).\n- **Rest days:** a send that falls on Shabbat or Yom Tov goes the day before (`restDays: before`) or after it; there is no "send now anyway" for an automation. `shabbat` says which Shabbat an occurrence belongs to; `grouping` makes one message for each person and Shabbat (`per-shabbat`), naming every occasion, or one for each occurrence.\n- **Steps:** a message to the person the date is about, on the channels chosen (each `everyone`, or `fallback` for those no `everyone` channel reaches), with the text each chosen channel needs. An email takes no images and at most 5,000 characters. A weekly automation\'s step is the Shabbat list: `{ "kind": "shabbat-digest", "enabled": true, "to": { "kind": "capability", "capability": "shabbat-list.view" }, "channels": [{ "channel": "email", "mode": "everyone" }] }` (or `"to": { "kind": "roles", "roleIds": [...] }`, never the Member role), by email or push only. Weekly automations are fixed at `grouping: per-occurrence`, `shabbat: following`, `restDays: before`.\n- **Placeholders:** `{first_name}`, `{last_name}`, `{hebrew_name}`, `{congregation}`, `{contact}`, `{occasions}`, `{shabbat}`, `{occasion}`, `{date}`, `{hebrew_date}`, `{hebrew_date_he}`, `{years}`, and for one occasion only `{deceased_name}`, `{begins}` and `{reading_shabbat}` (yahrzeit) and `{partner_first_name}` (wedding). A placeholder the triggers do not have is refused when saving. A missing value reads as its fallback, never blank.\n\n## Checking before turning on\n\n- `orzarua automations preview --body preview.json`: one step as an email, push, SMS and in-app copy, filled with a member (`memberId`) or a sample, with any fallback named. The draft may be unsaved.\n- `orzarua automations coming-up --body draft.json`: who it would message in the next days (1 to 60), when each goes and whether a rest day moved it, the 30-day estimate and the credit available. This is the cost `--confirm-cost` confirms.\n- `orzarua automations test --automation-id <id> --step-id <id> --channels email`: a test to your own record, at once, at any hour. It reaches a person, so it is a plan; SMS and WhatsApp are charged from the credit.\n\n`automations enable` needs `--confirm-cost` and the version read; its plan says how many people it will message over the next 30 days, on which channels, and what that costs. `automations disable` runs at once and tells nobody.\n\n`automations update` of an automation that is **on** retargets a live sender, so its plan carries the same reach and cost as turning it on (people over the next 30 days, channels, cost, whether the credit covers it), and a confirm answers `plan-changed` if either moved. The server does not ask for the cost to be confirmed on an update, so read it in the plan. Of one that is off, the plan is the field changes alone.\n\n## Runs\n\nEach person and Shabbat is one run. `automations runs` and `automation-runs list` list them newest first (`--before` a run id, `--limit` up to 100); `automation-runs get` shows each delivery with the plain reason when it did not go (opted out, no mobile number, not enough credit).\n\n## The Hebrew-date defaults and the Shabbat list\'s week\n\n- `orzarua settings get-occasion-dates` and `update-occasion-dates --adar adar-i|adar-ii --short-month same-month-29|next-month-1|first-anniversary`: where a plain-Adar date falls in a leap year, and what a 30 Cheshvan or Kislev date does when that month has 29 days. They apply to every date that carries no choice of its own.\n- `orzarua settings get-shabbat-list` and `update-shabbat-list --week shabbat-to-friday|sunday-to-shabbat`: which week of yahrzeits the list holds, the congregation\'s custom.\n- `orzarua shabbat-list get --shabbat 2026-11-07`: the list for one Saturday (the coming one when left out): seven days, each with its Hebrew date, the names read, who remembers each, and the times.\n\nThe switch, the occasion defaults and the week share one settings version: read it again before each save.\n\n## Undo\n\n`automations update` and `delete`, and both settings, are backed up first: `orzarua restore` puts an automation back as it was (a deleted one is made again, turned off, under a new id), and the settings as they were. Turning on and the switch cannot be unsent: turn them off, and messages already sent stay sent.\n\n## When it goes wrong\n\n- **`invalid`: a placeholder "needs a yahrzeit trigger".** The trigger for that occasion is not in the automation.\n- **`invalid`: "write the email, or take email off the channels".** A chosen channel has no text.\n- **`invalid`: "Confirm what it will cost".** Enable without `--confirm-cost`.\n- **`invalid` about quiet hours.** Move `sendAt` out of the overnight window, or use email only.\n- **`conflict`.** Someone changed it: read it again and send the new version.\n- **`forbidden`: made by a newer release.** It can be turned off or deleted, not changed.\n\nSources: the congregation automations design (Triggers, Quiet windows, Steps, Placeholders, The Shabbat list digest step, The Shabbat list, Capabilities, Delivery records); the automations plans 1 and 2 (2026-10-21, 2026-10-22); the CLI design\'s section 8 (turning on is outward); and the code\'s own rules (core/automation-validation.ts, core/automations/automations.ts, core/shabbat-list/shabbat-list.ts).\n';
+var automations_default = '# Automations, the Shabbat list and the Hebrew-date defaults\n\nAn automation is a message that goes by itself on a member\'s date: a yahrzeit reminder three days before, a birthday greeting on the day, a wedding anniversary. A weekly automation sends the Shabbat list to the staff who read it. Members\' dates are in `orzarua docs dates` and `orzarua docs yahrzeits`.\n\n```\norzarua automations list\norzarua automations get --automation-id <automationId>\norzarua automations runs --automation-id <automationId>\norzarua automation-runs list\n```\n\n## Three things must be on before anything sends\n\n1. **The automation is on.** `automations create` saves it turned off.\n2. **The congregation\'s switch is on** (`orzarua automations update-settings --enabled --version <settingsVersion>`, a plan). While it is off nothing sends, whatever each automation says. Turning it on lets every automation that is on send from now: a date due before then is never sent, so nothing old goes out.\n3. **A channel can be used.** Email needs the office\'s reply-to address (`orzarua docs messages`).\n\nTurning an automation on (`automations enable`) and the switch both let people be told, so they are plans the user confirms. Neither sends at that moment: a daily sweep sends each message at its due time.\n\n## Starting from a preset\n\nThe gallery\'s presets are the quickest start: `orzarua automations presets` lists them, and `orzarua automations create --from <preset>` saves one as a new automation, turned off, at version 1. Any other flag of `automations create`, `--set` or `--body` changes only what it names, so the rest stays as the preset has it: `--set steps.0.title=Happy birthday` changes only the first step\'s title. A list given whole, in `--body` or as a flag (`--steps`, `--triggers`), replaces the preset\'s list.\n\n```\norzarua automations create --from yahrzeit-reminder\norzarua automations create --from yahrzeit-reminder --name "Yahrzeit reminder (office)"\n```\n\n{{automation-presets}}\n\nA misspelt name is refused with the nearest id and the list. The answer names what to run next (as lines on the command line, and as tool calls with their input over MCP): read it back (`automations get`, whose fields are the body `automations preview` shows a step from), test it on yourself, and turn it on (`automations enable`, a plan that says who it will reach and what it costs). Making one from a preset never turns it on.\n\n## Writing an automation\n\nThe body says what fires it, when, and what it sends. A new automation has `"version": 0`; `get` gives the version a change sends back. Triggers and steps get their ids when they are saved, and keep them when the whole automation is sent back.\n\n```json\n{\n  "name": "Yahrzeit reminder",\n  "triggers": [{ "kind": "occasion", "occasion": "yahrzeit", "leadDays": 3 }],\n  "sendAt": 540, "restDays": "before", "shabbat": "following", "grouping": "per-shabbat",\n  "steps": [{\n    "kind": "message", "enabled": true, "to": { "kind": "subject" },\n    "channels": [{ "channel": "push", "mode": "everyone" }, { "channel": "email", "mode": "fallback" }],\n    "title": "The yahrzeit of {deceased_name}",\n    "email": { "subject": "The yahrzeit of {deceased_name}", "blocks": [{ "type": "paragraph", "runs": [{ "text": "{first_name}, the yahrzeit of {deceased_name} begins {begins}." }] }] },\n    "sms": null, "push": { "title": "The yahrzeit of {deceased_name}", "body": "It begins {begins}." }, "whatsapp": false\n  }],\n  "version": 0\n}\n```\n\n- **Triggers:** `occasion` (yahrzeit, birthday, wedding or b-mitzvah, `leadDays` 0 to 30 before it), each occasion once; or one `weekly` trigger (`weekday` 0 Sunday to 6 Saturday), which stands alone. At most 6 triggers and 10 steps; a congregation may have 20 automations.\n- **Time:** `sendAt` is minutes after midnight in the congregation\'s time zone, in steps of 15 (540 is 9:00). SMS, push and WhatsApp cannot be timed inside the overnight quiet hours (`orzarua comms get-settings`).\n- **Rest days:** a send that falls on Shabbat or Yom Tov goes the day before (`restDays: before`) or after it; there is no "send now anyway" for an automation. `shabbat` says which Shabbat an occurrence belongs to; `grouping` makes one message for each person and Shabbat (`per-shabbat`), naming every occasion, or one for each occurrence.\n- **Steps:** a message to the person the date is about, on the channels chosen (each `everyone`, or `fallback` for those no `everyone` channel reaches), with the text each chosen channel needs. An email takes no images and at most 5,000 characters. A weekly automation\'s step is the Shabbat list: `{ "kind": "shabbat-digest", "enabled": true, "to": { "kind": "capability", "capability": "shabbat-list.view" }, "channels": [{ "channel": "email", "mode": "everyone" }] }` (or `"to": { "kind": "roles", "roleIds": [...] }`, never the Member role), by email or push only. Weekly automations are fixed at `grouping: per-occurrence`, `shabbat: following`, `restDays: before`.\n- **Placeholders:** `{first_name}`, `{last_name}`, `{hebrew_name}`, `{congregation}`, `{contact}`, `{occasions}`, `{shabbat}`, `{occasion}`, `{date}`, `{hebrew_date}`, `{hebrew_date_he}`, `{years}`, and for one occasion only `{deceased_name}`, `{begins}` and `{reading_shabbat}` (yahrzeit) and `{partner_first_name}` (wedding). A placeholder the triggers do not have is refused when saving. A missing value reads as its fallback, never blank.\n\n## Checking before turning on\n\n- `orzarua automations preview --body preview.json`: one step as an email, push, SMS and in-app copy, filled with a member (`memberId`) or a sample, with any fallback named. The draft may be unsaved.\n- `orzarua automations coming-up --body draft.json`: who it would message in the next days (1 to 60), when each goes and whether a rest day moved it, the 30-day estimate and the credit available. This is the cost `--confirm-cost` confirms.\n- `orzarua automations test --automation-id <id> --step-id <id> --channels email`: a test to your own record, at once, at any hour. It reaches a person, so it is a plan; SMS and WhatsApp are charged from the credit.\n\n`automations enable` needs `--confirm-cost` and the version read; its plan says how many people it will message over the next 30 days, on which channels, and what that costs. `automations disable` runs at once and tells nobody.\n\n`automations update` of an automation that is **on** retargets a live sender, so its plan carries the same reach and cost as turning it on (people over the next 30 days, channels, cost, whether the credit covers it), and a confirm answers `plan-changed` if either moved. The server does not ask for the cost to be confirmed on an update, so read it in the plan. Of one that is off, the plan is the field changes alone.\n\n## Runs\n\nEach person and Shabbat is one run. `automations runs` and `automation-runs list` list them newest first (`--before` a run id, `--limit` up to 100); `automation-runs get` shows each delivery with the plain reason when it did not go (opted out, no mobile number, not enough credit).\n\n## The Hebrew-date defaults and the Shabbat list\'s week\n\n- `orzarua settings get-occasion-dates` and `update-occasion-dates --adar adar-i|adar-ii --short-month same-month-29|next-month-1|first-anniversary`: where a plain-Adar date falls in a leap year, and what a 30 Cheshvan or Kislev date does when that month has 29 days. They apply to every date that carries no choice of its own.\n- `orzarua settings get-shabbat-list` and `update-shabbat-list --week shabbat-to-friday|sunday-to-shabbat`: which week of yahrzeits the list holds, the congregation\'s custom.\n- `orzarua shabbat-list get --shabbat 2026-11-07`: the list for one Saturday (the coming one when left out): seven days, each with its Hebrew date, the names read, who remembers each, and the times.\n\nThe switch, the occasion defaults and the week share one settings version: read it again before each save.\n\n## Undo\n\n`automations update` and `delete`, and both settings, are backed up first: `orzarua restore` puts an automation back as it was (a deleted one is made again, turned off, under a new id), and the settings as they were. Turning on and the switch cannot be unsent: turn them off, and messages already sent stay sent.\n\n## When it goes wrong\n\n- **`invalid`: a placeholder "needs a yahrzeit trigger".** The trigger for that occasion is not in the automation.\n- **`invalid`: "write the email, or take email off the channels".** A chosen channel has no text.\n- **`invalid`: "Confirm what it will cost".** Enable without `--confirm-cost`.\n- **`invalid` about quiet hours.** Move `sendAt` out of the overnight window, or use email only.\n- **`conflict`.** Someone changed it: read it again and send the new version.\n- **`forbidden`: made by a newer release.** It can be turned off or deleted, not changed.\n\nSources: the congregation automations design (Triggers, Quiet windows, Steps, Placeholders, The Shabbat list digest step, The Shabbat list, Capabilities, Delivery records); the automations plans 1 and 2 (2026-10-21, 2026-10-22); the CLI design\'s section 8 (turning on is outward); and the code\'s own rules (core/automation-validation.ts, core/automations/automations.ts, core/shabbat-list/shabbat-list.ts).\n';
 
 // docs/guides/backups.md
 var backups_default = "# Backups and restore\n\nBefore every confirmed change to existing data, the CLI saves the records as they stood. A plain write that overwrites something is backed up too.\n\n## What a backup holds\n\nOne file per change, in `~/.local/share/orzarua/backups/<congregation>/`, named by when it ran and the command. It holds:\n\n- the before-state, read with the command's own backup reads;\n- the command and its input;\n- who ran it, the environment, and the CLI's version;\n- the result of each record, appended as it goes.\n\nA run that stops halfway leaves a precise record of what changed and what didn't.\n\n```\norzarua backups\norzarua backups show <file>\norzarua backups prune --days 90\n```\n\n- `backups` lists them, newest first: the command, how many results, how many failed, and whether it was restored. `--cong <slug>` lists one congregation's.\n- `backups show` prints one: what ran, what the records held before, and what came of each.\n- `backups prune` removes those older than 90 days (or `--days`).\n\n## How far a change can be undone\n\nEach command says how far its effect can be undone, and its plan shows it before the user says yes, so nobody confirms in the belief that something is undoable when it isn't.\n\n| Restore | What it covers | How it is put back |\n|---|---|---|\n| `full` | Field edits | Through the normal update, with the record's current version |\n| `recreate` | Deletes | The record is created again under a new id. Links to the old id don't come back |\n| `partial` | Edits with side effects a later edit doesn't reverse | The fields go back; the side effects stay, as the plan names them |\n| `none` | Sends, refunds and payments; anything with no backup | Can't be undone |\n\nFor example, putting a member record's fields back restores the details, but an added opt-out can't be removed by staff, and a resigned member's shared yahrzeits stay deleted. `orzarua describe <command>` names each command's own.\n\n## Restoring\n\n```\norzarua restore <file>\norzarua restore --confirm <planId>\n```\n\n`restore` builds a plan that puts the records back, through the same plan and confirm as any change (`orzarua docs safety`):\n\n- A record someone else changed since the run is refused and named, never overwritten.\n- A record that already reads as the backup holds it is said to be so, and left alone.\n- A backup is put back only once: a restore marks it, and a second restore of it is refused.\n- The records are backed up again before the restore changes them.\n- A workflow's backup (a plan of many rows) is put back row by row: a record changed since is left as it is and named in the plan's notes, the others are still put back, and what the run created stays. A call of it that failed after it was sent (no answer, a timeout, a server error), or was sent and never answered, may have changed some of its records: each is judged by its version, and any the restore cannot settle is named. A call the server refused changed nothing. If some of the restore's own calls fail, its answer names them, to put back by hand.\n\nShow the user the restore plan in plain words, and confirm it only after their explicit yes.\n\n## The activity log\n\nThe server keeps its own activity log of who did what, for staff with permission to see the activity log. The CLI names itself on every request, and the server logs it. Changes made with an API token are marked \"via token\" and the token's name.\n";
@@ -49264,7 +50326,7 @@ var start_default = '# Start here: the orzarua command line\n\n`orzarua` runs th
 var tickets_default = '# Tickets, payments and the ledger\n\nA ticketed event sells tickets through the congregation\'s own Stripe account. The congregation is the seller: the money goes to its account, its name is on the buyer\'s statement, and its refunds and disputes are its own. Or Zarua takes its part of a booking fee the buyer pays on top of each paid ticket.\n\n```\norzarua payments get\norzarua tickets list-types --event-id <eventId>\norzarua tickets door --event-id <eventId>\n```\n\nEvery amount is in minor units (cents) of the congregation\'s own currency: `priceMinor: 4000` is A$40.00 in Australia and \xA340.00 in the United Kingdom.\n\n## Stripe\'s own pages: open them in a browser\n\nThe command line never takes a card or a bank account. Two steps happen on pages of Stripe\'s, which the command line only prints, after the answer: "Open this link in a browser: <url>" for the account\'s page, "Open this link to pay: <url>" for the buyer\'s (in `links` with `--json` and through the MCP server):\n\n- **The congregation\'s account.** `payments setup` makes it, and Stripe then needs the rest (who represents the congregation, its bank account) in its own forms. The answer\'s `settingsUrl` is Settings, Payments in the web admin, where those forms open: open it in a browser. `payments session` answers the same page. Once the forms are done, `payments refresh` reads the account again; `state` turns `ready` and tickets can be sold.\n- **The buyer\'s card.** `tickets checkout` holds the places and answers `payUrl`, the event\'s page, where Stripe\'s own form takes the card. Open it in a browser (or pay in the app). The order turns `paid` once Stripe confirms the payment; read it with `tickets get-order`.\n\nAn agent never fills in either page for a person.\n\n## Setting up payments\n\n```\norzarua payments setup --body setup.json\n```\n\n`setup.json` may name the congregation\'s business number, of a type its country takes (`idTypes` in `payments get`): `{ "businessId": { "type": "au_abn", "value": "51 824 753 556" } }` in Australia; `us_ein`, `gb_crn`, `ca_crarr` or `nz_bn` elsewhere. Leave it out and Stripe asks for it. A type of another country is refused (exit 2). Where tickets can\'t be sold (the congregation\'s country or currency), `payments get` says why in `unavailableWords`, and the set-up is refused in the same words; events without tickets, and RSVPs, still work there.\n\nOnly `payments.configure` or `org.configure` sets payments up: whoever fills in Stripe\'s forms first becomes the account\'s representative. Staff with `tickets.view` read where it stands.\n\n`payments setup-again` is only for an account Stripe closed or rejected: it lets go of the old account, so the next set-up makes a new one. It is a plan, and it is refused while the account is open or ticket sales are open on it.\n\n## Ticket types and prices\n\nAn event sells tickets when its `rsvp.mode` is `ticketed` (`orzarua docs events`). Its ticket types are saved as a whole list:\n\n```json\n{\n  "types": [\n    { "typeId": null, "name": "Adult", "priceMinor": 4000, "categoryPrices": [{ "categoryId": "member", "priceMinor": 2500 }], "limit": null },\n    { "typeId": null, "name": "Child", "priceMinor": 1500, "categoryPrices": [], "limit": 20 },\n    { "typeId": null, "name": "Volunteer", "priceMinor": 0, "categoryPrices": [], "limit": null }\n  ]\n}\n```\n\n```\norzarua tickets save-types --event-id <eventId> --body types.json\n```\n\n- **The whole list.** A type with `typeId: null` is added; a type sent with its `typeId` and the `version` read (`tickets list-types`) is changed; a type left out is deleted. A type with tickets sold can\'t be removed or limited below what is sold. It is a plan, and its backup can put the list back.\n- **Prices.** `priceMinor` is the public price; `0` is a ticket at no charge. `categoryPrices` gives a membership category\'s active members their own price (one each, from `categories list`). A buyer pays their price, decided when the places are held, and the order records why. A paid price with its booking fee must reach Stripe\'s smallest charge in the currency (50 cents in Australian dollars).\n- **Limits.** `limit` is the type\'s own places, 1 or more, or `null` for only the event\'s capacity. A limit of 0 is refused: to stop selling a type, leave it out (when none are sold), or close the event\'s sales.\n- **The booking fee** is added to each paid ticket, shown beside its price, so the congregation receives the price. A ticket at no charge carries none.\n\n## Buying, as a member\n\n```\norzarua tickets checkout --event-id <eventId> --body \'{"lines":[{"typeId":"<typeId>","quantity":2}]}\'\n```\n\nBuying costs money, so it is a plan the person confirms. Confirmed, it holds the places for 15 minutes and answers `payUrl`. Refused when a type is sold out or has fewer left than asked for (`full`, exit 6, with how many are left), when the order is larger than the event allows, or when sales have closed. Only active members buy here; anyone else buys on the event\'s public page. Tickets at no charge are booked at once, with no page to pay on.\n\n- `tickets get-order` reads your own order: pending, paid (with each ticket\'s code), expired, or refunded.\n- `tickets release` gives an unpaid hold back (a plan): nothing was charged.\n- `tickets cancel` cancels your own paid tickets while the event\'s refund policy allows (a plan): the tickets\' prices go back to the card, and the booking fee is kept.\n- `tickets set-reminder --reminder` asks for a reminder before the event.\n\n## At the door\n\n`tickets door` lists every paid ticket and walk-in by name, with each ticket\'s code and whether it is in. A refunded ticket is shown, never let in.\n\n- `tickets check-in --order-id <orderId> --index <n> --body \'{"checked":true,"version":<version>}\'` checks one ticket in at the version the list showed. A second door that checks the same ticket in from the same list is refused (`conflict`, exit 6): read the list again.\n- `tickets add-walk-in --body \'{"name":"Avi Cohen","typeId":"<typeId>","quantity":3}\'` adds people who paid at the door, already checked in. No card is charged. Past the event\'s capacity it is refused (`full`) with the count it would make; send it again with `"confirm": true` in the body (or `--past-capacity` on the line) once staff have said yes.\n\n## Refunds\n\n```\norzarua tickets refund --event-id <eventId> --order-id <orderId> --body \'{"scope":"tickets","perLine":[1],"version":<version>}\'\n```\n\nA refund moves money back to the buyer\'s card, from the congregation\'s Stripe account, so it is a plan, and it can\'t be undone. The plan says how much goes back.\n\n- `scope: "tickets"` refunds some tickets\' prices (`perLine`: how many of each line, from `tickets list-orders`); the booking fees are kept, and the places are freed.\n- `scope: "everything"` refunds what is left of the order, booking fees included; Or Zarua returns its part of the fee to the congregation.\n- **Never more than was paid.** A line can give back at most what is left of it (`refundedPerLine` says what already went): asking for more is refused (`conflict`), and the plan says so first.\n- Stripe keeps its card fee either way. When money goes back, the buyer is emailed what was refunded.\n- The order\'s `version` makes a refund happen once: a second confirm of the same version is refused, never refunded twice.\n- An order that took no money (tickets at no charge, a walk-in) is refunded by its tickets: only its places are freed.\n\nA paid ticket is refunded here, not through `events cancel-rsvp` (RSVPs without payment only). Cancelling the whole event refunds every paid order in full by itself (`events cancel`).\n\n## The money\n\n- `tickets sales` shows an event\'s tickets sold at each price, and the money from the ledger: ticket prices, booking fees, refunds, Or Zarua\'s part (with its GST in Australia), Stripe\'s known fees, and the net. It also says what cancelling the event now would refund.\n- `ledger statement --from <YYYY-MM-DD> --to <YYYY-MM-DD>` totals every movement of ticket money between two days (at most 400), in the congregation\'s time zone, by kind and by event. Each entry is written once, from Stripe\'s own events: a sale shows once it is paid, a refund once Stripe made it.\n\nSources: the congregation platform design 2026-10-13 (Tickets and payments: Stripe setup, onboarding, price, checkout, tickets and guests, refunds); the tickets plan 2026-10-17 (Connect onboarding, ticket types and the booking fee, checkout, refunds, the door list and the sales view); the international design 2026-10-23 and its tickets in local currency plan 2026-10-25 (each country\'s currency, business ids and where tickets can\'t be sold); the CLI design 2026-10-29 (Stripe-hosted steps are printed, never handled); and the code\'s own rules in `core/tickets/` (`ticket-types.ts`, `checkout.ts`, `orders.ts`, `door.ts`, `refunds.ts`, `ledger.ts`, `onboarding.ts`, `validation.ts`).\n';
 
 // docs/guides/yahrzeits.md
-var yahrzeits_default = "# Yahrzeits: kept by a member, or by the congregation\n\nA yahrzeit is the anniversary of a death, kept by its Hebrew date. The congregation reads the names on Shabbat, and its automations can remind the family.\n\n## Who keeps a yahrzeit\n\nEvery yahrzeit has a **keeper**:\n\n- **A member's record.** Either the member shared it from the Or Zarua app or their portal (`source: member`), or the office recorded it for them (`source: office`).\n- **The congregation itself**, for someone no member keeps: a founder, a past rabbi. It shows as \"Remembered by\" the congregation, has no member, and no limit on how many.\n\nA member's record holds up to 200 yahrzeits. A record that is a join request holds none.\n\n## Member-shared yahrzeits are the member's\n\nA yahrzeit the member shared belongs to them; the congregation's copy exists by their consent. The office may **correct** it, never remove or move it:\n\n- a correction also changes the member's own copy in their app, and the member sees that the office corrected it (changing only the Hebrew name is not a correction). A yahrzeit entered in the portal has no app copy, so only the congregation's copy changes;\n- the member's own later edit, made after the correction reached their app, wins;\n- stopping sharing deletes the congregation's copy, and leaving the congregation deletes every yahrzeit the member shared. Resigning does too.\n\n`yahrzeits all` marks these `correctionOnly`.\n\n## Hebrew and civil dates\n\nA yahrzeit is kept by its Hebrew date: `{ year, month, day }`, months as the siddur numbers them (Nisan 1 ... Tishrei 7 ... Adar, or Adar I in a leap year, 12, Adar II 13).\n\nYou may give the civil date of death instead, with whether it was **after sunset**. After sunset moves it to the next Hebrew day. The civil date is resolved to its Hebrew date once, at save, and only the Hebrew date is kept. To see the Hebrew date first:\n\n```\norzarua dates resolve --civil 2019-03-14 --after-sunset --calendar hebrew\n```\n\nA date in the future is refused, as is a day the Hebrew calendar does not have (Adar II in a common year, a 30th the month lacks that year). The question of sunset is only for entering a death date. A yahrzeit itself is kept from the evening before its civil date: the Shabbat list's `beginsEvening` is the civil day before `date`, and the platform counts that evening from nightfall.\n\n## Adar and short months\n\nTwo choices apply only to some dates, and are kept on each yahrzeit:\n\n- `adarObservance`: for a death in plain Adar (month 12 of a common year), which Adar a leap year keeps it in: `adar-i` or `adar-ii`. Left out: Adar I.\n- `shortMonthChoice`: for a death on 30 Cheshvan or 30 Kislev, where a year that month has 29 days keeps it: `same-month-29` or `next-month-1`. Left out: none chosen.\n\n`dates resolve` says which choices apply to a date.\n\n## Which Shabbat a name is read\n\nEach congregation has a week setting:\n\n- `shabbat-to-friday` (the default): a name is read on the Shabbat that begins its week;\n- `sunday-to-shabbat`: on the Shabbat that ends it. A yahrzeit that begins Friday evening or on Shabbat is read that Shabbat; one that begins Saturday night belongs to the next week.\n\n```\norzarua yahrzeits month --month 2026-11\norzarua yahrzeits all\n```\n\n- `yahrzeits month` lists every Shabbat of a month with the names read that week. A name read on the 1st of next month is in next month's list.\n- `yahrzeits all` lists every yahrzeit, soonest next anniversary first, with who keeps it, its id and its version.\n- Both leave out join requests' and resigned members' yahrzeits. A deceased member's stay.\n\n## Recording, correcting, moving\n\n| Task | Command | Effect |\n|---|---|---|\n| Add to a member's record | `orzarua yahrzeits create-for-member` | write |\n| Add for someone no member keeps | `orzarua congregation-yahrzeits create` | write |\n| Correct one on a member's record | `orzarua yahrzeits update-for-member` | destructive |\n| Correct one the congregation keeps | `orzarua congregation-yahrzeits update` | destructive |\n| Remove an office entry | `orzarua yahrzeits delete-for-member`, `orzarua congregation-yahrzeits delete` | destructive |\n| Move between the congregation and a member | `orzarua yahrzeits move` | destructive |\n\n- An edit replaces the name, Hebrew name, date and choices: send them all as read, with your changes, and the version read. A Hebrew name left out is cleared.\n- A move is one change under the same id: from the congregation's list to a member when a family turns up, or from a member's record to the congregation. It never goes between two members directly: move it to the congregation, then on.\n- A member's share can't be moved or removed.\n- Reading yahrzeits needs permission to see members' contact details or to edit member records; changing them needs permission to edit member records.\n\nCongregation-kept yahrzeits send no reminder to a member, because no member keeps them.\n\nRecipes: `orzarua how record a yahrzeit`, `orzarua how move a yahrzeit to the congregation`, `orzarua how correct a yahrzeit date`.\n";
+var yahrzeits_default = "# Yahrzeits: kept by a member, or by the congregation\n\nA yahrzeit is the anniversary of a death, kept by its Hebrew date. The congregation reads the names on Shabbat, and its automations can remind the family.\n\n## Who keeps a yahrzeit\n\nEvery yahrzeit has a **keeper**:\n\n- **A member's record.** Either the member shared it from the Or Zarua app or their portal (`source: member`), or the office recorded it for them (`source: office`).\n- **The congregation itself**, for someone no member keeps: a founder, a past rabbi. It shows as \"Remembered by\" the congregation, has no member, and no limit on how many.\n\nA member's record holds up to 200 yahrzeits. A record that is a join request holds none.\n\n## Member-shared yahrzeits are the member's\n\nA yahrzeit the member shared belongs to them; the congregation's copy exists by their consent. The office may **correct** it, never remove or move it:\n\n- a correction also changes the member's own copy in their app, and the member sees that the office corrected it (changing only the Hebrew name is not a correction). A yahrzeit entered in the portal has no app copy, so only the congregation's copy changes;\n- the member's own later edit, made after the correction reached their app, wins;\n- stopping sharing deletes the congregation's copy, and leaving the congregation deletes every yahrzeit the member shared. Resigning does too.\n\n`yahrzeits all` marks these `correctionOnly`.\n\n## Hebrew and civil dates\n\nA yahrzeit is kept by its Hebrew date: `{ year, month, day }`, months as the siddur numbers them (Nisan 1 ... Tishrei 7 ... Adar, or Adar I in a leap year, 12, Adar II 13).\n\nYou may give the civil date of death instead, with whether it was **after sunset**. After sunset moves it to the next Hebrew day. The civil date is resolved to its Hebrew date once, at save, and only the Hebrew date is kept. To see the Hebrew date first:\n\n```\norzarua dates resolve --civil 2019-03-14 --after-sunset --calendar hebrew\n```\n\nA date in the future is refused, as is a day the Hebrew calendar does not have (Adar II in a common year, a 30th the month lacks that year). To check a Hebrew date before saving it, and see its civil day, give it in place of the civil date: `orzarua dates resolve --hebrew '{\"year\":5779,\"month\":1,\"day\":8}' --calendar hebrew` answers `civil` (2019-04-13), and refuses a day the year does not have, or a date after tonight, as the save would. The question of sunset is only for entering a death date. A yahrzeit itself is kept from the evening before its civil date: the Shabbat list's `beginsEvening` is the civil day before `date`, and the platform counts that evening from nightfall.\n\n## Adar and short months\n\nTwo choices apply only to some dates, and are kept on each yahrzeit:\n\n- `adarObservance`: for a death in plain Adar (month 12 of a common year), which Adar a leap year keeps it in: `adar-i` or `adar-ii`. Left out: Adar I.\n- `shortMonthChoice`: for a death on 30 Cheshvan or 30 Kislev, where a year that month has 29 days keeps it: `same-month-29` or `next-month-1`. Left out: none chosen.\n\n`dates resolve` says which choices apply to a date.\n\n## Which Shabbat a name is read\n\nEach congregation has a week setting:\n\n- `shabbat-to-friday` (the default): a name is read on the Shabbat that begins its week;\n- `sunday-to-shabbat`: on the Shabbat that ends it. A yahrzeit that begins Friday evening or on Shabbat is read that Shabbat; one that begins Saturday night belongs to the next week.\n\n```\norzarua yahrzeits month --month 2026-11\norzarua yahrzeits all\n```\n\n- `yahrzeits month` lists every Shabbat of a month with the names read that week. A name read on the 1st of next month is in next month's list.\n- `yahrzeits all` lists every yahrzeit, soonest next anniversary first, with who keeps it, its id and its version.\n- Both leave out join requests' and resigned members' yahrzeits. A deceased member's stay.\n\n## Recording, correcting, moving\n\n| Task | Command | Effect |\n|---|---|---|\n| Add to a member's record | `orzarua yahrzeits create-for-member` | write |\n| Add for someone no member keeps | `orzarua congregation-yahrzeits create` | write |\n| Correct one on a member's record | `orzarua yahrzeits update-for-member` | destructive |\n| Correct one the congregation keeps | `orzarua congregation-yahrzeits update` | destructive |\n| Remove an office entry | `orzarua yahrzeits delete-for-member`, `orzarua congregation-yahrzeits delete` | destructive |\n| Move between the congregation and a member | `orzarua yahrzeits move` | destructive |\n\n- An edit replaces the name, Hebrew name, date and choices: send them all as read, with your changes, and the version read. A Hebrew name left out is cleared.\n- A move is one change under the same id: from the congregation's list to a member when a family turns up, or from a member's record to the congregation. It never goes between two members directly: move it to the congregation, then on.\n- A member's share can't be moved or removed.\n- Reading yahrzeits needs permission to see members' contact details or to edit member records; changing them needs permission to edit member records.\n\nCongregation-kept yahrzeits send no reminder to a member, because no member keeps them.\n\n## Many yahrzeits at once\n\n`orzarua yahrzeits export` writes every yahrzeit as CSV (a header row, then one row each), and `orzarua yahrzeits bulk <file>` reads an Excel (`.xlsx`) or CSV file back, plans every row and, once confirmed, adds and changes yahrzeits (`orzarua how update yahrzeits from a spreadsheet`). The first row names the columns. These headers are read (case, spaces and punctuation don't matter); any other column is left out, and the plan lists it (the export's `nextDate` is one: it moves every day, so it is never read):\n{{yahrzeit-columns}}\n\n- **The keeper** is a member's email, or `congregation`. A keeper with no email is written `member:<id>`, which is read too. An email no member has, or two records share, or a join request's, is skipped, naming the keeper column.\n- **How a row finds its yahrzeit.**\n  - A row with an `id` changes that yahrzeit. An unknown `id` is skipped. An `id` whose keeper is not the row's is skipped: move it first (`orzarua yahrzeits move`).\n  - A row with no `id` matches the keeper's yahrzeit of the same name, ignoring case, spacing, nikkud and joiners (a maqaf or a hyphen reads as a space). One match changes it, none adds a new one, and more than one is `ambiguous`: it is left out and never guessed, so add the `id` column (`orzarua yahrzeits export` writes it).\n  - A row matched by its name keeps the name as the record spells it: the name found the record, it is not an edit (on a member's share, a new spelling would be a correction their app takes). The plan notes a different spelling. Only a row with an `id` renames.\n  - Two new rows of one name for one keeper are one person when their dates agree (the second is a repeat), and two people when their dates differ. A new name that is the Hebrew name of another of the keeper's yahrzeits is still added, with a note naming that yahrzeit: add its `id` if it is the same person.\n- **Dates.** The Hebrew date is written in words, `15 Nisan 5780` (Sh'vat, Shevat and Shvat; Iyyar and Iyar; Tamuz and Tammuz; Cheshvan, Heshvan and Marcheshvan; Adar, Adar I and Adar II, Adar Aleph and Adar Bet, Adar Rishon and Adar Sheni are all read; Adar I and Adar II only in a leap year, where plain Adar is read as Adar I and the plan says so). The civil date is `YYYY-MM-DD` with `afterSunset` as `yes` or `no`, required with it; with a Hebrew date, `afterSunset` is not read, and the plan says so. Either date is resolved by `dates resolve` at plan time, so the plan shows both dates (a Hebrew date's civil day, and a civil date's Hebrew date), and what is saved is the Hebrew date the plan showed. A Hebrew date the year does not have (30 Cheshvan in a year Cheshvan has 29 days) or one after tonight is skipped at plan time, naming the `hebrewDate` column. Give one of the two on a row, never both.\n- **What changes and what stays.** Only a cell with text changes anything: an empty cell never clears a field, so a sheet cannot remove a Hebrew name. A row that says what the yahrzeit says is `unchanged`. An Adar or short-month choice is refused where the date takes none.\n- **A member's share** (`correctionOnly`) is updated as a correction: the member's app takes it, and they see the office corrected it (a share entered in the member's portal has no app copy: they see the office corrected it). A row that changes only the Hebrew name is not a correction, and the plan says so.\n- **Every row is its own call.** A sheet holds at most 1000 rows. A confirm makes one call per row that does something, under the version `yahrzeits all` read, so one that fails (a yahrzeit changed since) leaves the others standing, and a plan whose yahrzeits changed since answers `plan-changed` before anything is written.\n- **Backed up.** The run's backup holds each changed yahrzeit as it was, and `orzarua restore <backup>` puts them back. A yahrzeit the sheet added is removed by the restore, unless it was changed since (or the member took it into their own list, or it was moved): that one is left as it is and named. Each removal is backed up too, so the restore can itself be put back. A plan that touches a member's share says that putting it back is another correction.\n\nRecipes: `orzarua how record a yahrzeit`, `orzarua how move a yahrzeit to the congregation`, `orzarua how correct a yahrzeit date`, `orzarua how update yahrzeits from a spreadsheet`.\n";
 
 // docs/recipes/add-a-member.md
 var add_a_member_default = '# Add a member\n\nAdd one person\'s record, put them in a household, and invite them to the Or Zarua app.\n\n1. Check you may add records here (it needs permission to edit member records):\n\n   ```\n   orzarua can members.create\n   ```\n\n2. Make sure they are not on file already. Look for their name or email in the list:\n\n   ```\n   orzarua members list\n   ```\n\n3. Find their household, or make one. Note its `householdId`:\n\n   ```\n   orzarua households list\n   orzarua households create --name "Cohen family"\n   ```\n\n4. Add the record. Write the phone as people write it in the congregation\'s country, or with + and the country code:\n\n   ```\n   orzarua members create --first-name Ruth --last-name Cohen --email ruth@example.com --phone "+61 412 345 678" --household-id <householdId>\n   ```\n\n   It runs at once and answers the new record, with its `memberId` and version 1. It holds the Member role and the default category unless you name others.\n\n5. Invite them, so they can use the Or Zarua app. This sends an email, so it answers a plan first:\n\n   ```\n   orzarua members invite --member-id <memberId>\n   ```\n\n6. Show the user the plan in plain words and ask for an explicit yes. Then, in a separate step:\n\n   ```\n   orzarua members invite --confirm <planId>\n   ```\n\n## If it goes wrong\n\n- **`invalid-input` naming `phone`**: the number does not read as a phone in the congregation\'s country. Write it with + and the country code ("+44 7400 123456") and run step 4 again.\n- **`invalid` naming `householdId`**: the id names no household here. Take it from `orzarua households list`.\n- **`forbidden`**: you lack permission to edit member records, or the record has a role beyond Member and you lack permission to manage roles. `orzarua can members.create` says which, and which roles have it.\n';
@@ -49305,6 +50367,9 @@ var move_a_yahrzeit_to_the_congregation_default = '# Move a yahrzeit to the cong
 // docs/recipes/record-a-yahrzeit.md
 var record_a_yahrzeit_default = '# Record a yahrzeit\n\nAdd a yahrzeit a member asked the office to keep, or one the congregation keeps itself, for someone no member keeps: a founder, a past rabbi. Read `orzarua docs yahrzeits` for the rules.\n\n1. If you have the civil date of death, see the Hebrew date it resolves to. Say whether the death was after sunset: that moves it to the next Hebrew day.\n\n   ```\n   orzarua dates resolve --civil 2019-03-14 --after-sunset --calendar hebrew\n   ```\n\n   The answer also says whether an Adar or short-month choice applies to this date. If one does, ask the user which they want.\n\n2. Write the yahrzeit in `yahrzeit.json`: the deceased\'s name, the Hebrew name if known, and the date, either as the civil date with after sunset, or as a Hebrew date:\n\n   ```json\n   { "name": "Avraham Levi", "hebrewName": "Avraham ben Yitzchak", "date": { "kind": "gregorian", "gregorian": "2019-03-14", "afterSunset": true } }\n   ```\n\n   ```json\n   { "name": "Avraham Levi", "date": { "kind": "hebrew", "hebrew": { "year": 5779, "month": 1, "day": 8 } }, "adarObservance": null }\n   ```\n\n   Months are numbered as the siddur numbers them: Nisan 1 ... Tishrei 7 ... Adar, or Adar I in a leap year, 12, Adar II 13.\n\n3. **Kept by a member.** Find the member\'s record, then add it there:\n\n   ```\n   orzarua members list\n   orzarua yahrzeits create-for-member --member-id <memberId> --body yahrzeit.json\n   ```\n\n   It is the office\'s entry, not a share: the member sees it, and may take it into their own list in the app.\n\n4. **Kept by the congregation**, for someone no member keeps:\n\n   ```\n   orzarua congregation-yahrzeits create --body yahrzeit.json\n   ```\n\n   Either way it runs at once and answers the new yahrzeit at version 1, with its id.\n\n5. Check where it falls: the month list shows the Shabbat its name is read on.\n\n   ```\n   orzarua yahrzeits month --month 2026-11\n   ```\n\n## If it goes wrong\n\n- **`invalid`: the date is in the future, or not a day of the Hebrew calendar** (Adar II in a common year, a 30th the month lacks that year). Check the date with `orzarua dates resolve`, and send the Hebrew date it answers.\n- **`invalid`: the record already holds 200 yahrzeits.** Remove one the office keeps there (`orzarua yahrzeits delete-for-member`), or keep this one on the congregation\'s list.\n- **`invalid`: the record is a join request.** It holds no yahrzeits: approve the request first (`orzarua members approve`).\n';
 
+// docs/recipes/update-yahrzeits-from-a-spreadsheet.md
+var update_yahrzeits_from_a_spreadsheet_default = '# Update yahrzeits from a spreadsheet\n\nAdd or change many yahrzeits from an Excel (`.xlsx`) or CSV file: export what is there, edit the sheet, plan the whole file, show the user what will happen to every row, then confirm. Read `orzarua docs yahrzeits` for the columns, how rows are matched and what a member\'s share allows.\n\n1. Export every yahrzeit. The file is the sheet to edit: one row each, with its `id`, its keeper (a member\'s email, or `congregation`), the name, the Hebrew date and any Adar or short-month choice.\n\n   ```\n   orzarua yahrzeits export --out yahrzeits.csv\n   ```\n\n   Without `--out` the CSV text is the answer. Open it in Excel or Sheets, change what needs changing, and add the new people as new rows with no `id`.\n\n2. Plan the sheet. Nothing is written:\n\n   ```\n   orzarua yahrzeits bulk yahrzeits.csv\n   ```\n\n   The answer is a plan (exit 7): every row, numbered as the sheet numbers it, with what happens to it:\n\n   - **update**: the yahrzeit its `id` names, or the keeper\'s one of that name, with each change as `field: from \u2192 to`;\n   - **create**: a new yahrzeit, kept by the member or by the congregation;\n   - **unchanged**: it already reads as the sheet says;\n   - **ambiguous**: no `id`, and the keeper has more than one yahrzeit of that name. It is never guessed: the row is left out, with the ids it could be;\n   - **skip**: with its reason and its column, such as `column A (Keeper)`.\n\n   A row\'s dates are shown both ways: the Hebrew date that will be saved, and its civil day (or the civil date and after-sunset that were written).\n\n   A row with no `id` that found its yahrzeit by name keeps the name as the record spells it; the plan notes a different spelling. To rename, put the `id` in the row.\n\n3. **If a row is `ambiguous`** (two yahrzeits for one keeper have the same name, such as two Sarah Cohens), the plan says to add the `id` column: `orzarua yahrzeits export` writes it. Put the id of the one meant in that row and plan again.\n\n4. **Dates.** Write the Hebrew date in words (`15 Nisan 5780`, `3 Adar II 5784`) in `hebrewDate`, or the civil date as `YYYY-MM-DD` in `civilDate` with `afterSunset` as `yes` or `no`. Both are checked by `dates resolve` when the plan is made: a Hebrew date the year does not have (30 Cheshvan in a year Cheshvan has 29 days) or one after tonight is skipped there and then, naming the `hebrewDate` column, never at the confirm. A civil date with no `afterSunset` is skipped, naming that column. In a leap year plain `Adar` is read as Adar I, and the plan says so: write `Adar II` if that was meant. Give one of the two dates, never both.\n\n5. **A member\'s share.** A yahrzeit the member shared (`correctionOnly`) is theirs: the office may correct it. The plan notes that the member\'s app takes the correction and they see the office corrected it. A row that changes only the Hebrew name is not a correction, and the plan says so.\n\n6. Show the user the plan in plain words. Changing yahrzeits is destructive, so ask for an explicit yes. Then, in a separate step:\n\n   ```\n   orzarua yahrzeits bulk --confirm <planId>\n   ```\n\n   Each row that does something is a call of its own, so one that fails leaves the others standing. The answer says how many went and names the backup it left (`backup`).\n\n7. Check the result with `orzarua yahrzeits all`.\n\n## Put it back\n\nThe confirm\'s answer names the backup (`backup`; `orzarua backups` lists them too). To put the changed yahrzeits back as they were, and remove the ones the sheet added:\n\n```\norzarua restore <backup>\norzarua restore --confirm <planId>\n```\n\nA yahrzeit the sheet added is removed by the restore, unless it was changed since. A yahrzeit someone changed since the sheet (or one it added that the member took into their own list, or that was moved) is left as it is now, and the plan names it. Each removal is backed up too, so the restore can itself be put back. See `orzarua how undo a change`.\n\n## Over MCP\n\nAn agent plans the same file with `plan`, `command: "yahrzeits.bulk"` and `input: { "file": "<path>", "map": "<path>", "sheet": "<name or number>" }` (only `file` is needed), shows the user the plan, and runs it with `apply` after their yes. `run` with `command: "yahrzeits.export"` answers the CSV text.\n\n## If it goes wrong\n\n- **A row is skipped for its keeper**: the email matches no member (or matches two records, or a join request). Write the member\'s email as it is on their record, `member:<id>` for one record among several with one email, or `congregation`.\n- **An `id` is skipped as kept by someone else**: the row\'s keeper is not the yahrzeit\'s. Move it first (`orzarua yahrzeits move`), or correct the keeper cell.\n- **It refuses to read the sheet** (exit 2, "The first row needs a column headed Keeper ... and a column headed Name"): the headers are not ones the reader knows, and the answer lists the ones it found. Name the right columns in a map file: `--map map.json` (written with the columns found when it is not there yet; edit it and plan again). A header the reader does not use at all is listed in the plan as an ignored column.\n- **A sheet of more than 1000 rows** is refused: split it.\n- **`plan-changed`** on the confirm: a yahrzeit changed between the plan and the confirm. Nothing was done. Show the user the new plan in the answer, and confirm that one after their yes.\n';
+
 // docs/recipes/recover-from-a-conflict.md
 var recover_from_a_conflict_default = "# Recover from a conflict\n\nSomeone else changed a record while you were working on it. Records carry a `version`, and a change sent with an old one is refused rather than overwriting their work.\n\n1. Recognise it. The command exits 6 with one of:\n\n   - `conflict`: the change was sent with an old version, or another change ran at the same moment. Nothing was saved.\n   - `plan-changed`: the record changed between the plan and the confirm. Nothing was saved, and the answer holds a new plan.\n\n2. Read the record again, as it is now:\n\n   ```\n   orzarua members get --member-id <memberId>\n   ```\n\n   The hint in the error names the read to use for each command (for a yahrzeit, `orzarua yahrzeits all`; for a household, `orzarua households list`).\n\n3. Compare it with what you meant to change. Someone else's edit may already do it, or may change what the user wants. If in doubt, ask the user.\n\n4. Apply your change to what is there now, with the fresh version, and send it again. Never resend the old body unchanged: it would undo the other person's edit.\n\n   ```\n   orzarua members update --member-id <memberId> --body member.json\n   ```\n\n5. A change that needs a plan answers a new one. Show the user the new plan in plain words and ask for an explicit yes; the yes they gave the old plan does not carry over. Then, in a separate step:\n\n   ```\n   orzarua members update --confirm <planId>\n   ```\n\n   For `plan-changed`, the new plan is already in the answer: show it to the user, and confirm its id once they say yes.\n\n## If it goes wrong\n\n- **It conflicts again**: someone is editing the same record right now. Wait a moment, then start again from step 2.\n- **`conflict` from `orzarua members import`**: another import is running. Wait for it to finish (about a minute at most), then run the dry run again before committing.\n- **A network failure on the change**: it may have landed. Read the record first (step 2), and repeat the change only if it did not.\n";
 
@@ -49312,7 +50377,7 @@ var recover_from_a_conflict_default = "# Recover from a conflict\n\nSomeone else
 var refund_a_ticket_default = '# Refund a ticket\n\nGive money back to a buyer as the office: some tickets, or everything left of the order. Read `orzarua docs tickets` for the rules. A refund goes back to the buyer\'s card and can\'t be undone, so it is a plan the user confirms.\n\n1. Find the order, what it bought, what is already refunded, and its version.\n\n   ```\n   orzarua tickets list-orders --event-id <eventId>\n   ```\n\n   Each order lists its `lines`, `refundedPerLine` and `version`.\n\n2. Make the plan: how many tickets of each line, at the version read.\n\n   ```\n   orzarua tickets refund --event-id <eventId> --order-id <orderId> --body \'{"scope":"tickets","perLine":[1],"version":<version>}\'\n   ```\n\n   The plan says how much goes back to the buyer\'s card. `scope: "tickets"` gives back the tickets\' prices and keeps the booking fees; `{"scope":"everything","version":<version>}` gives back what is left of the order, booking fees included. Show the plan to the user in plain words and ask for an explicit yes.\n\n3. Once the user has said yes, confirm the plan\'s id.\n\n   ```\n   orzarua tickets refund --confirm <planId>\n   ```\n\n   The answer is the order with what is now refunded. The buyer is emailed, and the places can be taken again. The money shows in `orzarua ledger statement --from <day> --to <day>` once Stripe has made the refund.\n\nA buyer can cancel their own tickets while the event\'s refund policy allows (`tickets cancel`). To refund everyone, cancel the event (`orzarua docs events`).\n\n## If it goes wrong\n\n- **More tickets than are left on a line.** The plan already says it will be refused, and the confirm is (`conflict`, exit 6): nothing went back. A line gives back at most its quantity less `refundedPerLine`. Make a new plan with the right number.\n- **`conflict` because the order changed.** Someone checked a ticket in or refunded it since you read the version. Read the orders again and make a new plan; never resend the old one.\n- **`payments-unavailable`.** Stripe could not make the refund. Try again later: the same version makes the same refund, never a second one.\n- **"Nothing is left to refund".** Everything has been refunded already, or the order took no money (tickets at no charge): refund its tickets by count to release their places.\n';
 
 // docs/recipes/remind-families-of-a-yahrzeit.md
-var remind_families_of_a_yahrzeit_default = '# Remind families of a yahrzeit\n\nMessage each mourner three days before a yahrzeit, by themselves, from the gallery\'s yahrzeit reminder: write it, preview it, test it on yourself, check the cost, then turn it on. Read `orzarua docs automations` first: nothing sends until the automation and the congregation\'s switch are both on, and turning either on is a plan the user confirms.\n\n1. Make sure email can be sent (`orzarua comms get-settings`; set the reply-to address if it is missing, as in `orzarua docs send-an-announcement`).\n\n2. Write the reminder as `yahrzeit.json`: the yahrzeit trigger three days before, a send time of 9:00 (`540`), and one message step with the email and push text (the example in `orzarua docs automations`). Save it with a version of 0.\n\n   ```\n   orzarua automations create --body yahrzeit.json\n   ```\n\n   A placeholder the trigger does not have, such as `{deceased_name}` in a birthday automation, is refused with the step and the placeholder named; fix the text and save again. The automation is saved turned off. Note its `automationId`, its `version` and its step\'s `stepId`.\n\n3. Preview the step with a sample yahrzeit. Nothing is saved or sent.\n\n   ```\n   orzarua automations preview --body preview.json\n   ```\n\n   `preview.json` holds `{ "automation": <the draft>, "stepIndex": 0, "sample": "yahrzeit" }`.\n\n4. Send yourself the email, to see how it arrives. It reaches a person, so it answers a plan that names the file with the step as it renders: show it to the user and ask for an explicit yes, then confirm.\n\n   ```\n   orzarua automations test --automation-id <automationId> --step-id <stepId> --channels email\n   orzarua automations test --confirm <planId>\n   ```\n\n5. Check who it would message in the next 30 days and what that costs.\n\n   ```\n   orzarua automations coming-up --body draft.json\n   ```\n\n6. Turn it on, with the cost confirmed and the version read. The plan says how many people it will message, on which channels and what it costs; without `--confirm-cost` the confirm is refused, so make the plan again with it. Show the plan to the user and ask for an explicit yes.\n\n   ```\n   orzarua automations enable --automation-id <automationId> --version <version> --confirm-cost\n   orzarua automations enable --confirm <planId>\n   ```\n\n   It sends nothing at that moment: the daily sweep sends each reminder at its due time, and only while the congregation\'s switch is on (`orzarua automations update-settings --enabled --version <settingsVersion>`, another plan). A reminder due before it was turned on is never sent.\n\n7. Watch what it did: `orzarua automations runs --automation-id <automationId>`, and `orzarua automation-runs get --run-id <runId>` for each delivery and why any did not go.\n\n## If it goes wrong\n\n- **`invalid`: "{deceased_name} needs a yahrzeit trigger".** The text uses a placeholder the triggers do not have: fix it, or add the trigger.\n- **`invalid`: "Confirm what it will cost to turn this automation on."** The enable plan was made without `--confirm-cost`: check the cost with `coming-up`, and plan again with it.\n- **`conflict`.** The automation changed: read it again (`automations get`) and plan with its new version.\n- **A reminder did not go.** `automation-runs get` gives the reason for each delivery: opted out, no email address, not enough credit.\n';
+var remind_families_of_a_yahrzeit_default = '# Remind families of a yahrzeit\n\nMessage each mourner three days before a yahrzeit, by themselves, from the gallery\'s yahrzeit reminder: make it from the preset, preview it, test it on yourself, check the cost, then turn it on. Read `orzarua docs automations` first: nothing sends until the automation and the congregation\'s switch are both on, and turning either on is a plan the user confirms.\n\n1. Make sure email can be sent (`orzarua comms get-settings`; set the reply-to address if it is missing, as in `orzarua docs send-an-announcement`).\n\n2. Start from the gallery\'s yahrzeit reminder. `automations presets` lists the presets; `--from` makes one from the preset you name, and any other flag changes only what it names (`--name "Yahrzeit reminder (office)"`). The text and timing are the preset\'s: three days before a yahrzeit, at 9:00, push to everyone it reaches and email to the rest.\n\n   ```\n   orzarua automations presets\n   orzarua automations create --from yahrzeit-reminder\n   ```\n\n   A name that is not a preset is refused with the nearest one ("Did you mean yahrzeit-reminder?") and the list: fix it and run it again. The automation is saved turned off. Note its `automationId`, its `version` and its step\'s `stepId`. To write your own text instead, save a body with a version of 0 (`orzarua automations create --body yahrzeit.json`, the example in `orzarua docs automations`).\n\n3. Preview the step with a sample yahrzeit. Nothing is saved or sent.\n\n   ```\n   orzarua automations preview --body preview.json\n   ```\n\n   `preview.json` holds `{ "automation": <the draft: the saved automation\'s fields, from `orzarua automations get`>, "stepIndex": 0, "sample": "yahrzeit" }`.\n\n4. Send yourself the email, to see how it arrives. It reaches a person, so it answers a plan that names the file with the step as it renders: show it to the user and ask for an explicit yes, then confirm.\n\n   ```\n   orzarua automations test --automation-id <automationId> --step-id <stepId> --channels email\n   orzarua automations test --confirm <planId>\n   ```\n\n5. Check who it would message in the next 30 days and what that costs.\n\n   ```\n   orzarua automations coming-up --body draft.json\n   ```\n\n6. Turn it on, with the cost confirmed and the version read. The plan says how many people it will message, on which channels and what it costs; without `--confirm-cost` the confirm is refused, so make the plan again with it. Show the plan to the user and ask for an explicit yes.\n\n   ```\n   orzarua automations enable --automation-id <automationId> --version <version> --confirm-cost\n   orzarua automations enable --confirm <planId>\n   ```\n\n   It sends nothing at that moment: the daily sweep sends each reminder at its due time, and only while the congregation\'s switch is on (`orzarua automations update-settings --enabled --version <settingsVersion>`, another plan). A reminder due before it was turned on is never sent.\n\n7. Watch what it did: `orzarua automations runs --automation-id <automationId>`, and `orzarua automation-runs get --run-id <runId>` for each delivery and why any did not go.\n\n8. To stop it, turn it off (`orzarua automations disable --automation-id <automationId> --version <version>`, at once, and nobody is told), or delete it (`orzarua automations delete`, a plan: its runs stay in the log, and a backup can make it again).\n\n## If it goes wrong\n\n- **`invalid-input`: "There is no preset".** `--from` names a preset that is not in the gallery: use one of the ids `automations presets` lists.\n- **`invalid`: "{deceased_name} needs a yahrzeit trigger".** Only in an automation you wrote yourself: the text uses a placeholder the triggers do not have. Fix it, or add the trigger.\n- **`invalid`: "Confirm what it will cost to turn this automation on."** The enable plan was made without `--confirm-cost`: check the cost with `coming-up`, and plan again with it.\n- **`conflict`.** The automation changed: read it again (`automations get`) and plan with its new version.\n- **A reminder did not go.** `automation-runs get` gives the reason for each delivery: opted out, no email address, not enough credit.\n';
 
 // docs/recipes/schedule-a-message.md
 var schedule_a_message_default = "# Schedule a message\n\nSchedule a newsletter for a later time in the congregation's own clock, and unschedule it if plans change. Read `orzarua docs messages` for the quiet windows and the credit. A scheduled message goes without anyone pressing anything, so scheduling it is a plan the user confirms.\n\n1. Make sure email can be sent (`orzarua comms get-settings`; set the reply-to address if it is missing, as in `orzarua docs send-an-announcement`).\n\n2. Write the newsletter as a draft.\n\n   ```\n   orzarua messages create --body newsletter.json\n   ```\n\n3. Check when it would really go: a time inside Shabbat or Yom Tov moves to when the window ends, and the night holds SMS and push.\n\n   ```\n   orzarua messages timing --body timing.json\n   ```\n\n4. Make the schedule's plan, with the version you read and the time in the congregation's own clock (`YYYY-MM-DDTHH:mm`).\n\n   ```\n   orzarua messages schedule --message-id <messageId> --version <version> --at 2026-12-14T09:00\n   ```\n\n   The plan says who it reaches on each channel, what it costs (reserved now, held until it goes), where the rendered email is, and when it goes if a quiet window moves it. Show it to the user and ask for an explicit yes.\n\n5. Once the user has said yes, confirm the plan's id.\n\n   ```\n   orzarua messages schedule --confirm <planId>\n   ```\n\n   The answer is the message, scheduled, and when it goes. The audience is read when it goes.\n\n6. To stop it before its time, unschedule it (a plan, then its confirm): it is a draft again, and its credit is given back.\n\n   ```\n   orzarua messages unschedule --message-id <messageId> --version <version>\n   orzarua messages unschedule --confirm <planId>\n   ```\n\n## If it goes wrong\n\n- **`invalid`: \"Choose a time at least a minute from now.\"** The time has passed, or is under a minute away. The plan is made either way, since the time is checked when it is sent: make a new plan with a later time.\n- **`invalid`: \"Choose a time within a year.\"** Choose an earlier date.\n- **`insufficient-credit`.** The credit does not cover the paid channels: top up first, or choose email only.\n- **`conflict`.** The message changed since its version was read: read it again and plan with the new version.\n";
@@ -49387,6 +50452,7 @@ var RECIPES = {
   "import-a-spreadsheet": import_a_spreadsheet_default,
   "give-someone-a-role": give_someone_a_role_default,
   "record-a-yahrzeit": record_a_yahrzeit_default,
+  "update-yahrzeits-from-a-spreadsheet": update_yahrzeits_from_a_spreadsheet_default,
   "move-a-yahrzeit-to-the-congregation": move_a_yahrzeit_to_the_congregation_default,
   "correct-a-yahrzeit-date": correct_a_yahrzeit_date_default,
   "undo-a-change": undo_a_change_default,
@@ -49515,6 +50581,8 @@ var ALIASES = {
 var FILLS = {
   "capabilities": () => Object.entries(CAPABILITY_WORDS).map(([capability, words]) => `- \`${capability}\`: ${words}`).join("\n"),
   "import-columns": () => IMPORT_FIELDS.map((field) => `- \`${field}\`: ${IMPORT_ALIASES[field].map((alias) => `"${alias}"`).join(", ")}`).join("\n"),
+  "yahrzeit-columns": () => YAHRZEIT_COLUMNS.map((column) => `- \`${column}\`: ${YAHRZEIT_ALIASES[column].map((alias) => `"${alias}"`).join(", ")}`).join("\n"),
+  "automation-presets": presetList,
   "preset-roles": () => PRESET_ROLES.map((role) => `- **${role.name}** (\`${role.roleId}\`): ${role.capabilities.length === 0 ? "nothing beyond what any member may do" : role.capabilities.join(", ")}`).join("\n")
 };
 function filled(text2) {
@@ -52051,16 +53119,16 @@ function setPath(into, root, assignment) {
   const path = assignment.slice(0, at).split(".");
   const raw = assignment.slice(at + 1);
   let schema = root;
-  for (const step of path) schema = schema?.properties?.[step];
+  for (const step2 of path) schema = schema?.properties?.[step2];
   const types = typesOf(schema);
   const value = types.includes("array") && schema !== void 0 ? coerceList([raw], schema) : coerce(raw, schema);
   if (!value.ok) return problem("set", `--set ${path.join(".")} ${value.message}`);
   let target = into;
-  for (const step of path.slice(0, -1)) {
-    const next = target[step];
-    if (next !== void 0 && next !== null && !isRecord(next)) return problem("set", `--set ${path.join(".")}: "${step}" is already a value, not an object`);
+  for (const step2 of path.slice(0, -1)) {
+    const next = target[step2];
+    if (next !== void 0 && next !== null && !isRecord(next)) return problem("set", `--set ${path.join(".")}: "${step2}" is already a value, not an object`);
     const child = isRecord(next) ? { ...next } : {};
-    target[step] = child;
+    target[step2] = child;
     target = child;
   }
   target[path[path.length - 1] ?? ""] = value.value;
@@ -52512,8 +53580,10 @@ function commandLine(suggestion) {
   const file2 = wf !== null && typeof suggestion.input["file"] === "string" ? [quote(suggestion.input["file"])] : [];
   const flags = Object.entries(suggestion.input).flatMap(([key, value]) => {
     if (value === void 0 || value === null || wf !== null && key === "file" && file2.length > 0) return [];
-    const text2 = typeof value === "string" ? value : JSON.stringify(value);
-    return [`--${flagFor({ id: suggestion.commandId }, key)} ${quote(text2)}`];
+    const flag = flagFor({ id: suggestion.commandId }, key);
+    if (typeof value === "boolean") return [value ? `--${flag}` : `--no-${flag}`];
+    if (Array.isArray(value) && value.every((item) => typeof item === "string")) return value.map((item) => `--${flag} ${quote(item)}`);
+    return [`--${flag} ${quote(typeof value === "string" ? value : JSON.stringify(value))}`];
   });
   return ["orzarua", ...words, ...file2, ...flags].join(" ");
 }
@@ -52527,6 +53597,7 @@ function confirmCommand(made) {
   const base = made.restoreOf !== void 0 ? "orzarua restore" : `orzarua ${words}`;
   return `${base}${made.env === "prod" ? "" : ` --env ${made.env}`} --confirm ${made.planId}`;
 }
+var lineNext = (s) => ({ command: commandLine(s), why: s.why });
 function withLines(error62) {
   if (error62.plan !== void 0 && (error62.code === "confirm-required" || error62.code === "plan-changed")) {
     const which = error62.code === "plan-changed" ? "the new plan" : "the plan";
@@ -52538,13 +53609,11 @@ function withLines(error62) {
   if (error62.code === "confirm-required") {
     return { ...error62, hint: "Run the command without --confirm to make a plan, show it to the user, and confirm it with --confirm <planId> once they say yes." };
   }
-  if (error62.next !== void 0 && error62.next.length > 0) {
-    return { ...error62, hint: `${error62.hint} Run: ${error62.next.map((s) => `\`${commandLine(s)}\``).join(", then ")}.` };
-  }
-  return error62;
+  return null;
 }
 function forTheLine(result) {
-  return result.ok ? result : { ok: false, error: withLines(result.error) };
+  const own2 = result.ok ? null : withLines(result.error);
+  return own2 === null ? withNext(result, lineNext) : { ok: false, error: own2 };
 }
 
 // src/cli/commands/plans.ts
@@ -52942,26 +54011,25 @@ async function prepare(rt, globals, needs) {
 }
 
 // src/cli/workflow-files.ts
-var PAGE = "members.importSheet";
 var isMissing = (error62) => error62 instanceof Error && "code" in error62 && error62.code === "ENOENT";
 var baseName = (path) => path.split(/[\\/]/).pop() ?? path;
-function readMapping(path, text2) {
+function readMapping(spec, path, text2) {
   let parsed;
   try {
     parsed = JSON.parse(text2);
   } catch {
-    return fail2(cliError("invalid-input", `${path} is not JSON.`, { page: PAGE, hint: 'It maps each header to a field: {"Forename": "firstName", "Notes": null}.' }));
+    return fail2(cliError("invalid-input", `${path} is not JSON.`, { page: spec.page, hint: 'It maps each header to a field: {"Forename": "firstName", "Notes": null}.' }));
   }
-  if (!isRecord(parsed)) return fail2(cliError("invalid-input", `${path} must be a JSON object of headers and fields.`, { page: PAGE, hint: 'For example {"Forename": "firstName", "Notes": null}.' }));
-  const mapping = importMappingSchema.safeParse(parsed);
+  if (!isRecord(parsed)) return fail2(cliError("invalid-input", `${path} must be a JSON object of headers and fields.`, { page: spec.page, hint: 'For example {"Forename": "firstName", "Notes": null}.' }));
+  const mapping = spec.mapping.safeParse(parsed);
   if (mapping.success) return { ok: true, data: mapping.data };
-  const [header, value] = Object.entries(parsed).find(([key, field]) => !importMappingSchema.safeParse({ [key]: field }).success) ?? ["", null];
-  return fail2(cliError("invalid-input", `${path}: ${JSON.stringify(header)} is mapped to ${JSON.stringify(value)}, which is not a field the import reads.`, {
-    page: PAGE,
-    hint: `Use one of ${IMPORT_FIELDS.join(", ")}, or null to leave the column out.`
+  const [header, value] = Object.entries(parsed).find(([key, field]) => !spec.mapping.safeParse({ [key]: field }).success) ?? ["", null];
+  return fail2(cliError("invalid-input", `${path}: ${JSON.stringify(header)} is mapped to ${JSON.stringify(value)}, which is not a ${spec.noun}.`, {
+    page: spec.page,
+    hint: `Use one of ${spec.fields.join(", ")}, or null to leave the column out.`
   }));
 }
-var membersImportSheet2 = async (rt, given) => {
+async function loadSheet(rt, given, spec) {
   const file2 = String(given["file"]);
   const sheet = typeof given["sheet"] === "string" ? given["sheet"] : null;
   const map2 = typeof given["map"] === "string" ? given["map"] : null;
@@ -52969,43 +54037,79 @@ var membersImportSheet2 = async (rt, given) => {
   try {
     bytes = rt.readBytes(file2);
   } catch (error62) {
-    return fail2(cliError(isMissing(error62) ? "not-found" : "invalid-input", `Could not read ${file2}${isMissing(error62) ? ": there is no such file" : ""}.`, { page: PAGE, hint: "Give the path of an .xlsx or .csv file." }));
+    return fail2(cliError(isMissing(error62) ? "not-found" : "invalid-input", `Could not read ${file2}${isMissing(error62) ? ": there is no such file" : ""}.`, { page: spec.page, hint: "Give the path of an .xlsx or .csv file." }));
   }
   const name = baseName(file2);
   const table2 = await readTable(bytes, name, sheet);
-  if (!table2.ok) return fail2({ ...table2.error, docs: docsForPage(PAGE) });
+  if (!table2.ok) return fail2({ ...table2.error, docs: docsForPage(spec.page) });
   const read2 = name === file2 ? table2.data : { ...table2.data, path: file2 };
-  const input2 = { table: read2, ...given["createOnly"] === true ? { createOnly: true } : {} };
+  const input2 = { table: read2 };
   if (map2 === null) return { ok: true, data: input2 };
   if (!map2.toLowerCase().endsWith(".json")) {
-    return fail2(cliError("invalid-input", `The map file must be a .json file, not ${map2}.`, { page: PAGE, hint: "Name a .json file, such as map.json: one that is not there yet is written with the columns found, to edit." }));
+    return fail2(cliError("invalid-input", `The map file must be a .json file, not ${map2}.`, { page: spec.page, hint: "Name a .json file, such as map.json: one that is not there yet is written with the columns found, to edit." }));
   }
   let text2 = null;
   try {
     text2 = rt.readFile(map2);
   } catch (error62) {
-    if (!isMissing(error62)) return fail2(cliError("invalid-input", `Could not read the map file ${map2}.`, { page: PAGE }));
+    if (!isMissing(error62)) return fail2(cliError("invalid-input", `Could not read the map file ${map2}.`, { page: spec.page }));
   }
   if (text2 === null) {
     try {
-      rt.writeFile(map2, `${JSON.stringify(mappingOf(table2.data), null, 2)}
+      rt.writeFile(map2, `${JSON.stringify(spec.propose(table2.data), null, 2)}
 `);
     } catch {
-      return fail2(cliError("invalid-input", `Could not write the proposed column mapping to ${map2}.`, { page: PAGE, hint: "Check the folder is there and can be written to." }));
+      return fail2(cliError("invalid-input", `Could not write the proposed column mapping to ${map2}.`, { page: spec.page, hint: "Check the folder is there and can be written to." }));
     }
     return { ok: true, data: input2, warnings: [`Wrote the proposed column mapping to ${map2}: edit it and plan again`] };
   }
-  const mapping = readMapping(map2, text2);
+  const mapping = readMapping(spec, map2, text2);
   if (!mapping.ok) return mapping;
   return { ok: true, data: { ...input2, mapping: mapping.data } };
+}
+var MEMBERS = {
+  page: "members.importSheet",
+  noun: "field the import reads",
+  fields: IMPORT_FIELDS,
+  mapping: importMappingSchema,
+  propose: (table2) => mappingOf(table2)
+};
+var YAHRZEITS = {
+  page: "yahrzeits.bulk",
+  noun: "column the yahrzeit sheet reads",
+  fields: YAHRZEIT_COLUMNS,
+  mapping: yahrzeitMappingSchema,
+  propose: (table2) => yahrzeitMappingOf(table2)
+};
+var membersImportSheet2 = async (rt, given) => {
+  const loaded = await loadSheet(rt, given, MEMBERS);
+  return loaded.ok && given["createOnly"] === true ? { ...loaded, data: { ...loaded.data, createOnly: true } } : loaded;
+};
+var yahrzeitsBulk2 = (rt, given) => loadSheet(rt, given, YAHRZEITS);
+var automationsCreateFromPreset2 = (_rt, given) => {
+  const fields = isRecord(given["fields"]) ? given["fields"] : {};
+  return Promise.resolve({ ok: true, data: { presetId: given["from"], overrides: fields } });
+};
+var LOADERS = {
+  "members.importSheet": membersImportSheet2,
+  "yahrzeits.bulk": yahrzeitsBulk2,
+  "automations.createFromPreset": automationsCreateFromPreset2
 };
-var LOADERS = { "members.importSheet": membersImportSheet2 };
 var LOADER_INPUTS = {
   "members.importSheet": external_exports.strictObject({
     file: external_exports.string().min(1).describe("The member list: an .xlsx or .csv file."),
     sheet: external_exports.string().optional().describe("The sheet of a workbook, by name or by number (1 is the first). The first sheet when left out."),
     map: external_exports.string().optional().describe("A JSON file mapping each header to a field. If it is not there yet, it is written with the columns found, to edit."),
     createOnly: external_exports.boolean().optional().describe(CREATE_ONLY_WORDS)
+  }),
+  "yahrzeits.bulk": external_exports.strictObject({
+    file: external_exports.string().min(1).describe("The yahrzeit list: an .xlsx or .csv file, such as the one yahrzeits export writes."),
+    sheet: external_exports.string().optional().describe("The sheet of a workbook, by name or by number (1 is the first). The first sheet when left out."),
+    map: external_exports.string().optional().describe("A JSON file mapping each header to a column. If it is not there yet, it is written with the columns found, to edit.")
+  }),
+  "automations.createFromPreset": external_exports.strictObject({
+    from: external_exports.string().min(1).describe("The preset to start from: one of those `automations presets` lists."),
+    fields: external_exports.record(external_exports.string(), external_exports.unknown()).optional().describe("Fields of automations.create to change from the preset, by name. On the command line these are its flags, --set and --body.")
   })
 };
 var frontInputOf = (wf) => LOADER_INPUTS[wf.id] ?? wf.input;
@@ -53055,8 +54159,8 @@ function humanBackup(data) {
     if (!isRecord(entry)) return "  ?";
     if (entry["kind"] === "restored") return `  ${String(entry["at"])}  restored by plan ${String(entry["planId"])}`;
     if (entry["kind"] === "started") {
-      const step = Number(entry["step"]) + 1;
-      return `  ${String(entry["at"])}  step ${String(step)} sent${answered.has(entry["step"]) ? "" : "; its answer was not recorded, so it may have changed something"}`;
+      const step2 = Number(entry["step"]) + 1;
+      return `  ${String(entry["at"])}  step ${String(step2)} sent${answered.has(entry["step"]) ? "" : "; its answer was not recorded, so it may have changed something"}`;
     }
     return `  ${String(entry["at"])}  ${entry["ok"] === true ? "ok" : "failed"}`;
   };
@@ -53468,7 +54572,8 @@ async function runContract(rt, cmd, argv2, globals, finish2, refuse) {
   return finish2(withNote(cmd, explain401(result, s)), outputFor(cmd));
 }
 function workflowLine(wf) {
-  const input2 = frontInputOf(wf);
+  const front = frontInputOf(wf);
+  const input2 = wf.flagsFrom !== void 0 && "fields" in front.shape ? front.omit({ fields: true }) : front;
   return { id: wf.id, input: input2, body: "fields", positionals: "file" in input2.shape ? ["file"] : [] };
 }
 function workflowFlags(wf) {
@@ -55055,12 +56160,12 @@ ZodString2.create = (params) => {
     ...processCreateParams(params)
   });
 };
-function floatSafeRemainder2(val, step) {
+function floatSafeRemainder2(val, step2) {
   const valDecCount = (val.toString().split(".")[1] || "").length;
-  const stepDecCount = (step.toString().split(".")[1] || "").length;
+  const stepDecCount = (step2.toString().split(".")[1] || "").length;
   const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
   const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
-  const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
+  const stepInt = Number.parseInt(step2.toFixed(decCount).replace(".", ""));
   return valInt % stepInt / 10 ** decCount;
 }
 var ZodNumber2 = class _ZodNumber extends ZodType2 {
@@ -63155,12 +64260,12 @@ var McpServer = class {
     }
     return registeredPrompt;
   }
-  _createRegisteredTool(name, title, description, inputSchema2, outputSchema, annotations, execution, _meta, handler) {
+  _createRegisteredTool(name, title, description, inputSchema4, outputSchema, annotations, execution, _meta, handler) {
     validateAndWarnToolName(name);
     const registeredTool = {
       title,
       description,
-      inputSchema: getZodSchemaObject(inputSchema2),
+      inputSchema: getZodSchemaObject(inputSchema4),
       outputSchema: getZodSchemaObject(outputSchema),
       annotations,
       execution,
@@ -63211,7 +64316,7 @@ var McpServer = class {
       throw new Error(`Tool ${name} is already registered`);
     }
     let description;
-    let inputSchema2;
+    let inputSchema4;
     let outputSchema;
     let annotations;
     if (typeof rest[0] === "string") {
@@ -63220,7 +64325,7 @@ var McpServer = class {
     if (rest.length > 1) {
       const firstArg = rest[0];
       if (isZodRawShapeCompat(firstArg)) {
-        inputSchema2 = rest.shift();
+        inputSchema4 = rest.shift();
         if (rest.length > 1 && typeof rest[0] === "object" && rest[0] !== null && !isZodRawShapeCompat(rest[0])) {
           annotations = rest.shift();
         }
@@ -63232,7 +64337,7 @@ var McpServer = class {
       }
     }
     const callback = rest[0];
-    return this._createRegisteredTool(name, void 0, description, inputSchema2, outputSchema, annotations, { taskSupport: "forbidden" }, void 0, callback);
+    return this._createRegisteredTool(name, void 0, description, inputSchema4, outputSchema, annotations, { taskSupport: "forbidden" }, void 0, callback);
   }
   /**
    * Registers a tool with a config object and callback.
@@ -63241,8 +64346,8 @@ var McpServer = class {
     if (this._registeredTools[name]) {
       throw new Error(`Tool ${name} is already registered`);
     }
-    const { title, description, inputSchema: inputSchema2, outputSchema, annotations, _meta } = config2;
-    return this._createRegisteredTool(name, title, description, inputSchema2, outputSchema, annotations, { taskSupport: "forbidden" }, _meta, cb);
+    const { title, description, inputSchema: inputSchema4, outputSchema, annotations, _meta } = config2;
+    return this._createRegisteredTool(name, title, description, inputSchema4, outputSchema, annotations, { taskSupport: "forbidden" }, _meta, cb);
   }
   prompt(name, ...rest) {
     if (this._registeredPrompts[name]) {
@@ -63533,8 +64638,14 @@ function refuseTokenCreate(cmd) {
   return cmd.id === "tokens.create" ? cliError("forbidden", TOKEN_CREATE_REFUSAL, { contract: cmd.contract, hint: "Ask the user to run `orzarua tokens create` themselves, then give you the token." }) : null;
 }
 var read = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var toolNext = (s) => {
+  const cmd = commandById(s.commandId);
+  const wf = cmd === null ? workflowById(s.commandId) : null;
+  const risky = cmd !== null ? isRisky(cmd) : wf !== null && isRiskyWorkflow(wf);
+  return { command: `${risky ? "plan" : "run"} ${s.commandId}`, why: s.why, input: s.input };
+};
 function forTheTools(result) {
-  if (result.ok) return result;
+  if (result.ok) return withNext(result, toolNext);
   const { error: error62 } = result;
   if ((error62.code === "confirm-required" || error62.code === "plan-changed") && error62.plan !== void 0) {
     const which = error62.code === "plan-changed" ? "the new plan" : "the plan";
@@ -63542,7 +64653,7 @@ function forTheTools(result) {
   }
   if (error62.code === "confirm-required") return fail2({ ...error62, hint: PLAN_FIRST_HINT });
   if (error62.code === "no-congregation") return fail2({ ...error62, hint: "Call use_congregation with a slug (whoami lists the congregations you belong to)." });
-  return result;
+  return withNext(result, toolNext);
 }
 var previewUri = (planId) => `orzarua://plans/${planId}/preview.html`;
 function withoutHtml(plan2) {
@@ -63865,9 +64976,9 @@ var runtime = {
   stdout: process.stdout,
   stderr: process.stderr,
   stdinIsTTY: process.stdin.isTTY === true,
-  version: "0.5.0",
+  version: "0.6.0",
   now: () => /* @__PURE__ */ new Date(),
-  client: (baseUrl) => fetchClient(baseUrl, "0.5.0"),
+  client: (baseUrl) => fetchClient(baseUrl, "0.6.0"),
   prompt,
   readStdin: () => readFileSync3(0, "utf8"),
   readFile: (path) => readFileSync3(path, "utf8"),