From 395ecaff0318f45bb0225f2f063ede0def1962c1 Mon Sep 17 00:00:00 2001
From: jherforth <herforth.jason@gmail.com>
Date: Sat, 31 Oct 2026 10:37:27 -0400
Subject: [PATCH] feat(chores): a schedule wizard, and "any day" beyond a week

The board's Add dialog keeps its picker of chips and gains a wizard beside
it (Picker | Wizard; each display remembers which it last used). The
wizard steps through it: how often (certain days, once in a while any day,
every few days, a date each month, again a while after it's done, just
once), the details, and for timings on days whether a chore not done that
day goes at day's end or stays until done; then the chores, and a
one-line summary before Add. Back keeps the answers.

"Once a week, any day" (#362) becomes once in a period, any day: duration
`any-day` with its period in `interval`: a week, two weeks, a month,
three or six months (calendar quarters and halves), or a year. Each
period's card is due on its last day, counts toward the daily bonus only
then, and an undone period is one miss; the next period starts fresh.
`weekly` is still accepted as any-day every week, and migration 38 turns
existing weekly rows into any-day 1w. The schedule dialog offers the
periods too.

The board's week calendar draws an any-day chore by its period, and uses
which schedules have a card up so a monthly chore done earlier in the
month isn't shown as waiting.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 client/src/components/ChoreScheduleBoard.jsx  | 140 ++++++++--
 client/src/components/ChoreSchedulesTab.jsx   |  65 +++--
 client/src/components/ScheduleWizard.jsx      | 253 ++++++++++++++++++
 client/src/i18n/locales/en/chores.json        |  83 +++++-
 client/src/i18n/locales/es/chores.json        |  83 +++++-
 client/src/utils/choreDays.js                 |  10 +-
 client/src/utils/choreDays.test.js            |  12 +-
 client/src/utils/choreHelpers.js              |   6 +-
 client/src/utils/choreHelpers.test.js         |   4 +-
 client/src/utils/choreScheduleGroups.js       | 106 +++++---
 client/src/utils/choreScheduleGroups.test.js  |  72 +++--
 docs/reference/backend-api.md                 |   2 +-
 docs/reference/features.md                    |  57 +++-
 server/index.js                               | 113 +++++---
 server/migrations/registry.js                 |   1 +
 server/migrations/schema38-anyDayChores.js    |  35 +++
 server/services/anyDayChores.js               |  94 +++++++
 server/services/weeklyChores.js               |  43 ---
 ...klyChores.test.js => anyDayChores.test.js} | 135 ++++++----
 server/tests/anyDayChoresRules.test.js        |  48 ++++
 server/tests/weeklyChoresRules.test.js        |  29 --
 21 files changed, 1091 insertions(+), 300 deletions(-)
 create mode 100644 client/src/components/ScheduleWizard.jsx
 create mode 100644 server/migrations/schema38-anyDayChores.js
 create mode 100644 server/services/anyDayChores.js
 delete mode 100644 server/services/weeklyChores.js
 rename server/tests/{weeklyChores.test.js => anyDayChores.test.js} (56%)
 create mode 100644 server/tests/anyDayChoresRules.test.js
 delete mode 100644 server/tests/weeklyChoresRules.test.js

diff --git a/client/src/components/ChoreScheduleBoard.jsx b/client/src/components/ChoreScheduleBoard.jsx
index ddf02356..5f551ffb 100644
--- a/client/src/components/ChoreScheduleBoard.jsx
+++ b/client/src/components/ChoreScheduleBoard.jsx
@@ -62,6 +62,14 @@ import {
   weekTiming,
 } from '../utils/choreScheduleGroups.js';
 import { calendarRoutinesFor } from '../utils/routineSchedules.js';
+import ScheduleWizard, { WIZARD_START } from './ScheduleWizard.jsx';
+
+// How the Add dialog picks a timing: the picker of chips, or the wizard.
+// Remembered per display; storage may be unavailable.
+const ADD_MODE_KEY = 'homeglow_choreAddMode';
+const readAddMode = () => {
+  try { return localStorage.getItem(ADD_MODE_KEY) === 'wizard' ? 'wizard' : 'picker'; } catch { return 'picker'; }
+};
 
 // "By person" view of Admin → Chores → Schedules: one tab per person (and
 // one for the unassigned bonus chores), a week calendar of what they have on
@@ -217,8 +225,8 @@ export default function ChoreScheduleBoard({
         return timing.dueDate ? t('chores:board.timing.oneTimeOn', { date: dateLabel(timing.dueDate) }) : t('chores:board.timing.oneTime');
       case 'after':
         return t('chores:board.timing.againAfter', { interval: intervalText(timing.interval) });
-      case 'weekly':
-        return t('chores:board.timing.weeklyAnyDay');
+      case 'anyDay':
+        return t(`chores:board.timing.anyDay.${timing.period}`);
       default:
         return t('chores:board.timing.custom', { expr: timing.rest });
     }
@@ -248,9 +256,15 @@ export default function ChoreScheduleBoard({
       .catch(() => { if (current) setHistory([]); });
     return () => { current = false; };
   }, [userId, dayKeys, today, schedules]);
+  // The sticky schedules with a card up now: an any-day chore without one
+  // was done earlier in its period (calendarWeek).
+  const openCards = useMemo(
+    () => new Set(schedules.filter((s) => s.parent_schedule_id && !s.crontab && s.visible).map((s) => s.parent_schedule_id)),
+    [schedules],
+  );
   const week = useMemo(
-    () => calendarWeek({ groups, dates: dayKeys, today, rows: history, vacation }),
-    [groups, dayKeys, today, history, vacation],
+    () => calendarWeek({ groups, dates: dayKeys, today, rows: history, vacation, openCards }),
+    [groups, dayKeys, today, history, vacation, openCards],
   );
 
   // ── Moving one chore (drag, or Move to…) ──────────────────────────
@@ -313,7 +327,8 @@ export default function ChoreScheduleBoard({
   });
 
   // ── Add chores ────────────────────────────────────────────────────
-  const [addDialog, setAddDialog] = useState(null); // { step, timing, picked:Set, days:[], date }
+  // step: 'timing' → 'chores' (→ 'review' from the wizard).
+  const [addDialog, setAddDialog] = useState(null); // { step, timing, picked:Set, days:[], date, wizard, keep, fromWizard }
   const openAdd = (timing = null) => setAddDialog({
     step: timing ? 'chores' : 'timing',
     timing,
@@ -324,7 +339,17 @@ export default function ChoreScheduleBoard({
     panel: null, // 'monthly' | 'custom' while one of those is open
     dom: '1',
     custom: { every: 3, from: 'dates', start: todayKeyString() },
+    wizard: WIZARD_START,
+    // From the wizard: true "stays until done", false "goes at day's end",
+    // null not asked (the chores keep their own setting).
+    keep: null,
+    fromWizard: false,
   });
+  const [addMode, setAddModeState] = useState(readAddMode);
+  const setAddMode = (mode) => {
+    setAddModeState(mode);
+    try { localStorage.setItem(ADD_MODE_KEY, mode); } catch { /* per-display convenience only */ }
+  };
   // A chore made with "New chore" while the dialog is open comes back ticked.
   const knownChoreIds = useRef(new Set(chores.map((c) => c.id)));
   useEffect(() => {
@@ -350,9 +375,13 @@ export default function ChoreScheduleBoard({
   const pickedNew = addDialog ? [...addDialog.picked].filter((id) => !mineByChore.has(id)) : [];
   const pickedMoves = addDialog ? [...addDialog.picked].filter((id) => mineByChore.has(id)) : [];
 
+  // The wizard's answer to "if it isn't done that day", for both the chores
+  // added and the ones moved; the picker doesn't ask.
+  const keepFields = (keep) => (keep === null || keep === undefined ? {} : { duration: keep ? 'until-completed' : 'day-of' });
   const saveAdd = () => {
     const timing = addTiming;
-    const fields = scheduleFieldsForTiming(timing);
+    const extra = keepFields(addDialog.keep);
+    const fields = { ...scheduleFieldsForTiming(timing), ...extra };
     const moves = pickedMoves.map((id) => mineByChore.get(id)[0].s);
     const created = pickedNew.length;
     setAddDialog(null);
@@ -361,7 +390,7 @@ export default function ChoreScheduleBoard({
         await axios.post(`${API_BASE_URL}/api/chore-schedules`, { chore_id: choreId, user_id: userId, visible: 1, ...fields });
       }
       for (const s of moves) {
-        await axios.patch(`${API_BASE_URL}/api/chore-schedules/${s.id}`, scheduleFieldsForTiming(timing, s));
+        await axios.patch(`${API_BASE_URL}/api/chore-schedules/${s.id}`, { ...scheduleFieldsForTiming(timing, s), ...extra });
       }
     }, moves.length && !created
       ? t('chores:board.movedCount', { count: moves.length, timing: timingLabel(timing) })
@@ -753,10 +782,16 @@ export default function ChoreScheduleBoard({
     // Every common schedule is offered, even ones the person already has:
     // picking one of those adds to it.
     const others = COMMON_TIMINGS;
-    const pick = (timing) => setAddDialog((d) => ({ ...d, step: 'chores', timing, date: timing.kind === 'once' ? (timing.dueDate || '') : '' }));
+    const pick = (timing) => setAddDialog((d) => ({ ...d, step: 'chores', timing, date: timing.kind === 'once' ? (timing.dueDate || '') : '', keep: null, fromWizard: false }));
+    const wizardMode = addMode === 'wizard';
+    // The person's own schedules are a shortcut: in the wizard, on its first step only.
+    const showGroups = groups.length > 0 && (!wizardMode || addDialog.wizard.step === 'how');
+    const finishWizard = (timing, keep) => setAddDialog((d) => ({
+      ...d, step: 'chores', timing, keep, fromWizard: true, date: timing.kind === 'once' ? (timing.dueDate || '') : '',
+    }));
     return (
       <Box sx={{ display: 'flex', flexDirection: 'column', gap: 2 }}>
-        {groups.length > 0 && (
+        {showGroups && (
           <Box>
             <Typography variant="overline" color="text.secondary">{t('chores:board.theirTimings', { name: personName })}</Typography>
             <Box sx={{ display: 'flex', flexDirection: 'column', gap: 1 }}>
@@ -778,6 +813,28 @@ export default function ChoreScheduleBoard({
             </Box>
           </Box>
         )}
+        <Box sx={{ display: 'flex', justifyContent: 'flex-end' }}>
+          <ToggleButtonGroup
+            size="small"
+            exclusive
+            value={addMode}
+            onChange={(_, mode) => mode && setAddMode(mode)}
+            aria-label={t('chores:wizard.modeLabel')}
+          >
+            <ToggleButton value="picker" sx={{ textTransform: 'none', px: 2 }}>{t('chores:wizard.picker')}</ToggleButton>
+            <ToggleButton value="wizard" sx={{ textTransform: 'none', px: 2 }}>{t('chores:wizard.wizard')}</ToggleButton>
+          </ToggleButtonGroup>
+        </Box>
+        {wizardMode ? (
+          <ScheduleWizard
+            value={addDialog.wizard}
+            onChange={(wizard) => setAddDialog((d) => ({ ...d, wizard }))}
+            onDone={finishWizard}
+            timingLabel={timingLabel}
+            shortDays={shortDays}
+          />
+        ) : (
+        <>
         <Box>
           <Box sx={{ display: 'flex', flexWrap: 'wrap', gap: 1 }}>
             {others.map((tm) => (
@@ -813,9 +870,36 @@ export default function ChoreScheduleBoard({
             </Button>
           </Box>
         </Box>
+        </>
+        )}
+      </Box>
+    );
+  };
+
+  // The wizard's last step: what will be added, in a sentence, before Add.
+  const renderAddReview = () => {
+    const picked = choresByTitle.filter((c) => addDialog.picked.has(c.id));
+    const names = picked.map((c) => `${c.icon ? `${c.icon} ` : ''}${c.title}`);
+    return (
+      <Box sx={{ display: 'flex', flexDirection: 'column', gap: 1.5 }}>
+        <Typography variant="caption" color="text.secondary">{t('chores:wizard.stepOf', { step: wizardStepCount(), count: wizardStepCount() })}</Typography>
+        <Paper variant="outlined" sx={{ p: 2, bgcolor: 'rgba(var(--accent-rgb), 0.06)', borderColor: 'var(--accent)' }}>
+          <Typography sx={{ fontWeight: 600 }}>
+            {t('chores:wizard.reviewSentence', { name: personName, chores: names.join(', '), timing: timingLabel(addTiming) })}
+          </Typography>
+          {addDialog.keep === true && <Typography variant="body2" color="text.secondary" sx={{ mt: 0.5 }}>{t('chores:wizard.reviewKeep')}</Typography>}
+          {addDialog.keep === false && <Typography variant="body2" color="text.secondary" sx={{ mt: 0.5 }}>{t('chores:wizard.reviewDrop')}</Typography>}
+          {addTiming?.kind === 'anyDay' && <Typography variant="body2" color="text.secondary" sx={{ mt: 0.5 }}>{t('chores:wizard.anyDayNote')}</Typography>}
+        </Paper>
+        {pickedMoves.length > 0 && (
+          <Alert severity="info">{t('chores:wizard.reviewMoves', { count: pickedMoves.length })}</Alert>
+        )}
       </Box>
     );
   };
+  // How many steps the wizard has for the answers given: how, details,
+  // (if missed), chores, review.
+  const wizardStepCount = () => (['days', 'everyN', 'monthly'].includes(addDialog?.wizard?.how) ? 5 : 4);
 
   // Every day / Weekdays / Weekends buttons that fill the day toggles.
   const quickDays = (onPick) => (
@@ -918,8 +1002,13 @@ export default function ChoreScheduleBoard({
     });
     return (
       <Box sx={{ display: 'flex', flexDirection: 'column', gap: 1.5 }}>
-        {addDialog.timing.kind === 'weekly' && <Alert severity="info">{t('chores:board.weeklyHelp')}</Alert>}
-        {addDialog.timing.kind === 'once' && (
+        {addDialog.fromWizard && (
+          <Typography variant="caption" color="text.secondary">
+            {t('chores:wizard.stepOf', { step: wizardStepCount() - 1, count: wizardStepCount() })} · {t('chores:wizard.choresTitle')}
+          </Typography>
+        )}
+        {addDialog.timing.kind === 'anyDay' && !addDialog.fromWizard && <Alert severity="info">{t('chores:wizard.anyDayNote')}</Alert>}
+        {addDialog.timing.kind === 'once' && !addDialog.fromWizard && (
           <TextField
             size="small"
             type="date"
@@ -1095,7 +1184,7 @@ export default function ChoreScheduleBoard({
       <Menu open={!!groupMenu} anchorEl={groupMenu?.anchor} onClose={() => setGroupMenu(null)}>
         {/* A group of routines only has nothing these can change; a
             once-a-week group has no days to change. */}
-        <MenuItem onClick={() => { const g = groupMenu.group; setGroupMenu(null); openEditDays(g); }} disabled={['custom', 'weekly'].includes(groupMenu?.group.timing.kind) || menuEmpty}>
+        <MenuItem onClick={() => { const g = groupMenu.group; setGroupMenu(null); openEditDays(g); }} disabled={['custom', 'anyDay'].includes(groupMenu?.group.timing.kind) || menuEmpty}>
           <EditCalendar fontSize="small" sx={{ mr: 1.5 }} />{t('chores:board.changeDays')}
         </MenuItem>
         <MenuItem onClick={() => { const g = groupMenu.group; setGroupMenu(null); setCopyDialog({ group: g, targets: [] }); }} disabled={menuEmpty}>
@@ -1110,21 +1199,36 @@ export default function ChoreScheduleBoard({
       {/* Add chores */}
       <Dialog open={!!addDialog} onClose={() => setAddDialog(null)} maxWidth="sm" fullWidth fullScreen={isMobile}>
         <DialogTitle>
-          {addDialog?.step === 'chores'
-            ? t('chores:board.addToTitle', { timing: timingLabel(addTiming), name: personName })
-            : t('chores:board.addTitle', { name: personName })}
+          {addDialog?.step === 'review'
+            ? t('chores:wizard.reviewTitle')
+            : addDialog?.step === 'chores'
+              ? t('chores:board.addToTitle', { timing: timingLabel(addTiming), name: personName })
+              : t('chores:board.addTitle', { name: personName })}
         </DialogTitle>
         <DialogContent dividers>
-          {addDialog && (addDialog.step === 'timing' ? renderAddTimingStep() : renderAddChoresStep())}
+          {addDialog && (addDialog.step === 'timing'
+            ? renderAddTimingStep()
+            : addDialog.step === 'review' ? renderAddReview() : renderAddChoresStep())}
         </DialogContent>
         <DialogActions>
           {addDialog?.step === 'chores' && (
-            <Button onClick={() => setAddDialog((d) => ({ ...d, step: 'timing', picked: new Set() }))} sx={{ mr: 'auto' }}>
+            // Back to the wizard keeps its answers; to the picker, starts over.
+            <Button onClick={() => setAddDialog((d) => ({ ...d, step: 'timing', picked: d.fromWizard ? d.picked : new Set() }))} sx={{ mr: 'auto' }}>
+              {t('chores:board.back')}
+            </Button>
+          )}
+          {addDialog?.step === 'review' && (
+            <Button onClick={() => setAddDialog((d) => ({ ...d, step: 'chores' }))} sx={{ mr: 'auto' }}>
               {t('chores:board.back')}
             </Button>
           )}
           <Button onClick={() => setAddDialog(null)}>{t('common:actions.cancel')}</Button>
-          {addDialog?.step === 'chores' && (
+          {addDialog?.step === 'chores' && addDialog.fromWizard && (
+            <Button variant="contained" onClick={() => setAddDialog((d) => ({ ...d, step: 'review' }))} disabled={!addDialog.picked.size}>
+              {t('chores:board.next')}
+            </Button>
+          )}
+          {(addDialog?.step === 'review' || (addDialog?.step === 'chores' && !addDialog.fromWizard)) && (
             <Button variant="contained" onClick={saveAdd} disabled={!addDialog.picked.size}>
               {pickedMoves.length
                 ? t('chores:board.addAndMove', { added: pickedNew.length, moved: pickedMoves.length })
diff --git a/client/src/components/ChoreSchedulesTab.jsx b/client/src/components/ChoreSchedulesTab.jsx
index eae80111..331b6a68 100644
--- a/client/src/components/ChoreSchedulesTab.jsx
+++ b/client/src/components/ChoreSchedulesTab.jsx
@@ -61,7 +61,7 @@ import RoutineStepsGroup from './RoutineStepsGroup.jsx';
 import RoutineEditorDialog from './RoutineEditorDialog.jsx';
 import useRoutines from '../hooks/useRoutines.js';
 import { schedulesWithRoutines } from '../utils/routineSchedules.js';
-import { WEEKLY_CRONTAB } from '../utils/choreScheduleGroups.js';
+import { ANY_DAY_CRONTAB, ANY_DAY_PERIODS } from '../utils/choreScheduleGroups.js';
 
 // Which way the schedules section opens: by person (grouped by timing) or the
 // full list. Remembered per display; storage may be unavailable.
@@ -230,6 +230,8 @@ const defaultScheduleForm = {
   duration: 'day-of',
   sleepCount: '',
   sleepUnit: 'd',
+  // An any-day chore's period (its interval).
+  anyDayPeriod: '1w',
   visible: true,
   due_date: '',
   due_days: '',
@@ -368,8 +370,8 @@ export default function ChoreSchedulesTab({ setSaveMessage }) {
 
   const computeCrontab = (f) => {
     if (f.isOneTime) return '';
-    // Once a week, any day: the crontab only marks the week start.
-    if (f.duration === 'weekly') return WEEKLY_CRONTAB;
+    // Once in a period, any day: its days mean nothing.
+    if (f.duration === 'any-day') return ANY_DAY_CRONTAB;
     if (f.scheduleMode === 'preset') return f.selectedPreset;
     if (f.scheduleMode === 'days') return f.selectedDays.length > 0 ? daysToCrontab(f.selectedDays) : '';
     return f.customCrontab;
@@ -463,6 +465,7 @@ export default function ChoreSchedulesTab({ setSaveMessage }) {
       duration: schedule.duration || 'day-of',
       sleepCount: schedule.interval ? (schedule.interval.match(/^(\d+)/)?.[1] || '') : '',
       sleepUnit: schedule.interval ? (schedule.interval.match(/[dwmy]$/i)?.[0].toLowerCase() || 'd') : 'd',
+      anyDayPeriod: schedule.duration === 'any-day' && ANY_DAY_PERIODS.includes(schedule.interval) ? schedule.interval : '1w',
       visible: !!schedule.visible,
       due_date: schedule.due_date || '',
       due_days: !isOneTime ? getDueDaysOffset(schedule.created_at, schedule.due_date) : '',
@@ -493,18 +496,20 @@ export default function ChoreSchedulesTab({ setSaveMessage }) {
 
     setSavingSchedule(true);
     try {
-      const normalizedInterval = !scheduleForm.isOneTime && scheduleForm.duration === 'once-completed'
-        ? `${scheduleForm.sleepCount}${scheduleForm.sleepUnit}`
-        : null;
+      const normalizedInterval = scheduleForm.isOneTime
+        ? null
+        : scheduleForm.duration === 'once-completed'
+          ? `${scheduleForm.sleepCount}${scheduleForm.sleepUnit}`
+          : scheduleForm.duration === 'any-day' ? scheduleForm.anyDayPeriod : null;
 
-      // A weekly chore's card is due by its Saturday; the server sets that.
+      // An any-day chore's card is due by its period's last day; the server sets that.
       const normalizedDueDate = scheduleForm.isOneTime
         ? (scheduleForm.due_date || null)
-        : (scheduleForm.due_days === '' || scheduleForm.duration === 'weekly'
+        : (scheduleForm.due_days === '' || scheduleForm.duration === 'any-day'
           ? null
           : buildDueDateFromOffset(editingSchedule?.created_at || new Date(), scheduleForm.due_days));
 
-      if (!scheduleForm.isOneTime && scheduleForm.duration !== 'weekly' && scheduleForm.due_days !== '' && !normalizedDueDate) {
+      if (!scheduleForm.isOneTime && scheduleForm.duration !== 'any-day' && scheduleForm.due_days !== '' && !normalizedDueDate) {
         showMessage('error', 'Days until due must be a non-negative whole number.');
         return;
       }
@@ -1062,8 +1067,8 @@ export default function ChoreSchedulesTab({ setSaveMessage }) {
                   {s.followup_of && <Box component="span" sx={{ display: 'block' }}>{t('chores:widget.followupOf', { title: s.followup_of })}</Box>}
                   {s.description && <Box component="span" sx={{ display: 'block' }}>{s.description}</Box>}
                   <Box component="span" sx={{ display: 'block' }}>
-                    {s.duration === 'weekly'
-                      ? t('chores:schedules.weeklyNext')
+                    {s.duration === 'any-day'
+                      ? t('chores:schedules.anyDayNext')
                       : `${t('chores:schedules.nextOccurrence')}: ${getNextOccurrence(s.crontab)}`}
                   </Box>
                 </>
@@ -1076,8 +1081,8 @@ export default function ChoreSchedulesTab({ setSaveMessage }) {
                     variant={s.user_id ? 'filled' : 'outlined'}
                     color={s.user_id ? 'primary' : 'default'}
                   />
-                  {s.crontab && s.duration === 'weekly' ? (
-                    <Chip label={t('chores:schedules.weeklyChip')} size="small" color="secondary" variant="outlined" />
+                  {s.crontab && s.duration === 'any-day' ? (
+                    <Chip label={t(`chores:board.timing.anyDay.${s.interval || '1w'}`)} size="small" color="secondary" variant="outlined" />
                   ) : s.crontab && s.duration === 'until-completed' ? (
                     <Chip label={t('chores:schedules.untilCompleted')} size="small" color="warning" />
                   ) : s.crontab && s.duration === 'once-completed' ? (
@@ -1495,8 +1500,8 @@ export default function ChoreSchedulesTab({ setSaveMessage }) {
 
             {!scheduleForm.isOneTime && (
               <>
-                {/* A weekly chore has no days to pick: any day of the week counts. */}
-                {scheduleForm.duration !== 'weekly' && (
+                {/* An any-day chore has no days to pick: any day of its period counts. */}
+                {scheduleForm.duration !== 'any-day' && (
                   <RadioGroup
                     row
                     value={scheduleForm.scheduleMode}
@@ -1519,17 +1524,31 @@ export default function ChoreSchedulesTab({ setSaveMessage }) {
                     <MenuItem value="day-of">{t('chores:schedules.dayOf')}</MenuItem>
                     <MenuItem value="until-completed">{t('chores:schedules.untilCompleted')}</MenuItem>
                     <MenuItem value="once-completed">{t('chores:schedules.onceCompleted')}</MenuItem>
-                    <MenuItem value="weekly">{t('chores:schedules.weekly')}</MenuItem>
+                    <MenuItem value="any-day">{t('chores:schedules.anyDay')}</MenuItem>
                   </Select>
                   <Typography variant="caption" color="text.secondary" sx={{ mt: 0.5, ml: 1.5 }}>
                     {t({
                       'until-completed': 'chores:schedules.durationHelp.untilCompleted',
                       'once-completed': 'chores:schedules.durationHelp.onceCompleted',
-                      weekly: 'chores:schedules.durationHelp.weekly',
+                      'any-day': 'chores:schedules.durationHelp.anyDay',
                     }[scheduleForm.duration] || 'chores:schedules.durationHelp.dayOf')}
                   </Typography>
                 </FormControl>
 
+                {scheduleForm.duration === 'any-day' && (
+                  <FormControl fullWidth size="small">
+                    <InputLabel id="schedule-any-day-period-label">{t('chores:wizard.periodLabel')}</InputLabel>
+                    <Select
+                      labelId="schedule-any-day-period-label"
+                      value={scheduleForm.anyDayPeriod}
+                      label={t('chores:wizard.periodLabel')}
+                      onChange={(e) => updateScheduleForm({ anyDayPeriod: e.target.value })}
+                    >
+                      {ANY_DAY_PERIODS.map((p) => <MenuItem key={p} value={p}>{t(`chores:board.timing.anyDay.${p}`)}</MenuItem>)}
+                    </Select>
+                  </FormControl>
+                )}
+
                 {scheduleForm.duration === 'once-completed' && (
                   <Grid container spacing={2}>
                     <Grid size={6}>
@@ -1566,7 +1585,7 @@ export default function ChoreSchedulesTab({ setSaveMessage }) {
                   </Grid>
                 )}
 
-                {scheduleForm.duration !== 'weekly' && scheduleForm.scheduleMode === 'preset' && (
+                {scheduleForm.duration !== 'any-day' && scheduleForm.scheduleMode === 'preset' && (
                   <FormControl fullWidth size="small">
                     <InputLabel id="schedule-schedule-preset-label">{t('chores:schedules.schedulePreset')}</InputLabel>
                     <Select
@@ -1589,7 +1608,7 @@ export default function ChoreSchedulesTab({ setSaveMessage }) {
                   </FormControl>
                 )}
 
-                {scheduleForm.duration !== 'weekly' && scheduleForm.scheduleMode === 'days' && (
+                {scheduleForm.duration !== 'any-day' && scheduleForm.scheduleMode === 'days' && (
                   <Box>
                     <Typography variant="body2" color="text.secondary" sx={{ mb: 1 }}>
                       {t('chores:schedules.selectDays')}
@@ -1625,7 +1644,7 @@ export default function ChoreSchedulesTab({ setSaveMessage }) {
                   </Box>
                 )}
 
-                {scheduleForm.duration !== 'weekly' && scheduleForm.scheduleMode === 'custom' && (
+                {scheduleForm.duration !== 'any-day' && scheduleForm.scheduleMode === 'custom' && (
                   <TextField
                     fullWidth
                     size="small"
@@ -1641,9 +1660,9 @@ export default function ChoreSchedulesTab({ setSaveMessage }) {
               </>
             )}
 
-            {!scheduleForm.isOneTime && scheduleForm.duration === 'weekly' ? (
+            {!scheduleForm.isOneTime && scheduleForm.duration === 'any-day' ? (
               <Alert severity="info" icon={<Schedule />} sx={{ py: 0.5 }}>
-                <Typography variant="body2">{t('chores:board.weeklyHelp')}</Typography>
+                <Typography variant="body2">{t('chores:wizard.anyDayNote')}</Typography>
               </Alert>
             ) : !crontabError && (
               <Alert severity={scheduleForm.isOneTime ? 'warning' : 'info'} icon={<Schedule />} sx={{ py: 0.5 }}>
@@ -1686,7 +1705,7 @@ export default function ChoreSchedulesTab({ setSaveMessage }) {
                   }
                 }}
               />
-            ) : scheduleForm.duration === 'weekly' ? null : (
+            ) : scheduleForm.duration === 'any-day' ? null : (
               <TextField
                 label={t('chores:schedules.daysUntilDue')}
                 type="number"
diff --git a/client/src/components/ScheduleWizard.jsx b/client/src/components/ScheduleWizard.jsx
new file mode 100644
index 00000000..35a7adc2
--- /dev/null
+++ b/client/src/components/ScheduleWizard.jsx
@@ -0,0 +1,253 @@
+import React from 'react';
+import {
+  Alert,
+  Box,
+  Button,
+  MenuItem,
+  Paper,
+  TextField,
+  ToggleButton,
+  ToggleButtonGroup,
+  Typography,
+} from '@mui/material';
+import { ArrowBack, ArrowForward } from '@mui/icons-material';
+import { useTranslation } from 'react-i18next';
+import {
+  ANY_DAY_PERIODS,
+  afterTiming,
+  anyDayTiming,
+  everyNTiming,
+  monthlyTiming,
+  onceTiming,
+  weekTiming,
+} from '../utils/choreScheduleGroups.js';
+
+// The Add dialog's wizard (Family → Chores, By person): how often, then its
+// details, then, for timings that fall on days, what happens if it isn't done
+// that day. It ends with onDone(timing, keep), where keep is true for "stays
+// until it's done", false for "goes at the end of the day", and null where
+// the question doesn't apply. The dialog then asks for the chores and shows a
+// summary before adding. The state lives with the dialog (`value`), so Back
+// from the chores returns to the step it left.
+
+export const WIZARD_START = {
+  step: 'how', how: null, days: [], n: 2, period: '1w', dom: [1], count: 2, unit: 'w', date: '', keep: false,
+};
+
+const HOWS = ['days', 'anyDay', 'everyN', 'monthly', 'after', 'once'];
+// Timings that fall on days, so "what if it isn't done that day" applies.
+const ON_DAYS = ['days', 'everyN', 'monthly'];
+const DAY_ORDER = [0, 1, 2, 3, 4, 5, 6];
+const QUICK_DAYS = [
+  { key: 'everyDay', days: [0, 1, 2, 3, 4, 5, 6] },
+  { key: 'weekdays', days: [1, 2, 3, 4, 5] },
+  { key: 'weekends', days: [0, 6] },
+];
+
+// The timing the answers so far make, or null while incomplete.
+export function wizardTiming(w) {
+  switch (w.how) {
+    case 'days': return w.days.length ? weekTiming(w.days) : null;
+    case 'everyN': return Number(w.n) >= 2 && Number(w.n) <= 60 ? everyNTiming(Number(w.n)) : null;
+    case 'anyDay': return anyDayTiming(w.period);
+    case 'monthly': return w.dom.length ? monthlyTiming([...w.dom].sort((a, b) => a - b).join(',')) : null;
+    case 'after': return Number(w.count) >= 1 && Number(w.count) <= 99 ? afterTiming(`${Number(w.count)}${w.unit}`) : null;
+    case 'once': return onceTiming(w.date || null);
+    default: return null;
+  }
+}
+
+export default function ScheduleWizard({ value: w, onChange, onDone, timingLabel, shortDays }) {
+  const { t } = useTranslation(['chores', 'common']);
+  const set = (patch) => onChange({ ...w, ...patch });
+  const timing = wizardTiming(w);
+  const asksMissed = ON_DAYS.includes(w.how);
+
+  const option = (key, selected, onClick, title, hint) => (
+    <Paper
+      key={key}
+      variant="outlined"
+      component="button"
+      type="button"
+      onClick={onClick}
+      aria-pressed={selected}
+      sx={{
+        textAlign: 'left',
+        p: 1.5,
+        cursor: 'pointer',
+        width: '100%',
+        font: 'inherit',
+        color: 'text.primary',
+        bgcolor: selected ? 'rgba(var(--accent-rgb), 0.10)' : 'background.paper',
+        borderColor: selected ? 'var(--accent)' : 'divider',
+        borderWidth: selected ? 2 : 1,
+        '&:hover': { bgcolor: selected ? 'rgba(var(--accent-rgb), 0.14)' : 'action.hover' },
+      }}
+    >
+      <Typography sx={{ fontWeight: 700 }}>{title}</Typography>
+      {hint && <Typography variant="body2" color="text.secondary">{hint}</Typography>}
+    </Paper>
+  );
+
+  const heading = (text) => (
+    <Typography variant="subtitle1" component="h3" sx={{ fontWeight: 700 }}>{text}</Typography>
+  );
+
+  // Step dots: where in the wizard this is, out of the steps this choice has.
+  const steps = ['how', 'details', ...(asksMissed || !w.how ? ['missed'] : [])];
+  const progress = (
+    <Typography variant="caption" color="text.secondary" aria-live="polite">
+      {t('chores:wizard.stepOf', { step: steps.indexOf(w.step) + 1, count: steps.length + 2 })}
+    </Typography>
+  );
+
+  const nav = (onBack, onNext, nextDisabled = false, nextLabel = t('chores:board.next')) => (
+    <Box sx={{ display: 'flex', gap: 1, alignItems: 'center', pt: 1 }}>
+      {onBack && <Button startIcon={<ArrowBack />} onClick={onBack}>{t('chores:board.back')}</Button>}
+      <Box sx={{ flex: 1 }} />
+      <Button variant="contained" endIcon={<ArrowForward />} onClick={onNext} disabled={nextDisabled}>{nextLabel}</Button>
+    </Box>
+  );
+
+  if (w.step === 'how') {
+    return (
+      <Box sx={{ display: 'flex', flexDirection: 'column', gap: 1.25 }}>
+        {progress}
+        {heading(t('chores:wizard.howTitle'))}
+        {HOWS.map((how) => option(
+          how,
+          w.how === how,
+          () => set({ how, step: 'details' }),
+          t(`chores:wizard.how.${how}.title`),
+          t(`chores:wizard.how.${how}.hint`),
+        ))}
+      </Box>
+    );
+  }
+
+  if (w.step === 'details') {
+    const next = () => (asksMissed ? set({ step: 'missed' }) : onDone(timing, null));
+    return (
+      <Box sx={{ display: 'flex', flexDirection: 'column', gap: 1.5 }}>
+        {progress}
+        {heading(t(`chores:wizard.details.${w.how}`))}
+
+        {w.how === 'days' && (
+          <>
+            <Box sx={{ display: 'flex', gap: 1, flexWrap: 'wrap' }}>
+              {QUICK_DAYS.map(({ key, days }) => (
+                <Button key={key} size="small" variant="outlined" onClick={() => set({ days })} sx={{ textTransform: 'none' }}>
+                  {t(`chores:board.timing.${key}`)}
+                </Button>
+              ))}
+            </Box>
+            <ToggleButtonGroup
+              value={w.days}
+              onChange={(_, days) => set({ days })}
+              aria-label={t('chores:board.pickDays')}
+              sx={{ flexWrap: 'wrap' }}
+            >
+              {DAY_ORDER.map((d) => <ToggleButton key={d} value={d} sx={{ minWidth: 48 }}>{shortDays[d]}</ToggleButton>)}
+            </ToggleButtonGroup>
+          </>
+        )}
+
+        {w.how === 'everyN' && (
+          <TextField
+            type="number"
+            size="small"
+            label={t('chores:wizard.everyNLabel')}
+            value={w.n}
+            onChange={(e) => set({ n: e.target.value })}
+            slotProps={{ htmlInput: { min: 2, max: 60 } }}
+            sx={{ maxWidth: 180 }}
+          />
+        )}
+
+        {w.how === 'anyDay' && (
+          <>
+            <Box sx={{ display: 'grid', gridTemplateColumns: { xs: '1fr 1fr', sm: '1fr 1fr 1fr' }, gap: 1 }}>
+              {ANY_DAY_PERIODS.map((period) => option(period, w.period === period, () => set({ period }), t(`chores:wizard.period.${period}`)))}
+            </Box>
+            <Alert severity="info">{t('chores:wizard.anyDayNote')}</Alert>
+          </>
+        )}
+
+        {w.how === 'monthly' && (
+          <>
+            <Box role="group" aria-label={t('chores:wizard.details.monthly')} sx={{ display: 'grid', gridTemplateColumns: 'repeat(7, minmax(0, 1fr))', gap: 0.5, maxWidth: 360 }}>
+              {Array.from({ length: 31 }, (_, i) => i + 1).map((day) => {
+                const on = w.dom.includes(day);
+                return (
+                  <ToggleButton
+                    key={day}
+                    value={day}
+                    selected={on}
+                    size="small"
+                    onChange={() => set({ dom: on ? w.dom.filter((d) => d !== day) : [...w.dom, day] })}
+                    sx={{ px: 0, minWidth: 0 }}
+                  >
+                    {day}
+                  </ToggleButton>
+                );
+              })}
+            </Box>
+            {w.dom.some((d) => d > 28) && (
+              <Typography variant="body2" color="text.secondary">{t('chores:board.shortMonths', { day: Math.max(...w.dom) })}</Typography>
+            )}
+          </>
+        )}
+
+        {w.how === 'after' && (
+          <Box sx={{ display: 'flex', gap: 1, flexWrap: 'wrap' }}>
+            <TextField
+              type="number"
+              size="small"
+              label={t('chores:wizard.afterCount')}
+              value={w.count}
+              onChange={(e) => set({ count: e.target.value })}
+              slotProps={{ htmlInput: { min: 1, max: 99 } }}
+              sx={{ width: 120 }}
+            />
+            <TextField select size="small" label={t('chores:schedules.sleepUnit')} value={w.unit} onChange={(e) => set({ unit: e.target.value })} sx={{ minWidth: 140 }}>
+              <MenuItem value="d">{t('chores:schedules.unitDays')}</MenuItem>
+              <MenuItem value="w">{t('chores:schedules.unitWeeks')}</MenuItem>
+              <MenuItem value="m">{t('chores:schedules.unitMonths')}</MenuItem>
+              <MenuItem value="y">{t('chores:schedules.unitYears')}</MenuItem>
+            </TextField>
+          </Box>
+        )}
+
+        {w.how === 'once' && (
+          <TextField
+            size="small"
+            type="date"
+            label={t('chores:schedules.dueDateOptional')}
+            value={w.date}
+            onChange={(e) => set({ date: e.target.value })}
+            slotProps={{ inputLabel: { shrink: true } }}
+            sx={{ maxWidth: 220 }}
+          />
+        )}
+
+        {timing && (
+          <Typography variant="body2" color="text.secondary">
+            {t('chores:wizard.soFar')} <strong>{timingLabel(timing)}</strong>
+          </Typography>
+        )}
+        {nav(() => set({ step: 'how' }), next, !timing)}
+      </Box>
+    );
+  }
+
+  // 'missed'
+  return (
+    <Box sx={{ display: 'flex', flexDirection: 'column', gap: 1.25 }}>
+      {progress}
+      {heading(t('chores:wizard.missedTitle'))}
+      {option('drop', !w.keep, () => set({ keep: false }), t('chores:wizard.missedDrop'), t('chores:wizard.missedDropHint'))}
+      {option('keep', w.keep, () => set({ keep: true }), t('chores:wizard.missedKeep'), t('chores:wizard.missedKeepHint'))}
+      {nav(() => set({ step: 'details' }), () => onDone(timing, w.keep), !timing)}
+    </Box>
+  );
+}
diff --git a/client/src/i18n/locales/en/chores.json b/client/src/i18n/locales/en/chores.json
index abd05057..765ab292 100644
--- a/client/src/i18n/locales/en/chores.json
+++ b/client/src/i18n/locales/en/chores.json
@@ -208,14 +208,13 @@
     "untilCompleted": "Until Completed",
     "onceCompleted": "Once Completed",
     "dayOf": "Day Of",
-    "weekly": "Once a week (any day)",
-    "weeklyChip": "Once a week",
-    "weeklyNext": "Any day this week; a new one each Sunday",
+    "anyDay": "Once in a while (any day)",
+    "anyDayNext": "Any day in its period; a fresh one each new period",
     "durationHelp": {
       "dayOf": "This chore will only appear on the day it is scheduled",
       "untilCompleted": "This chore will appear daily until completed",
       "onceCompleted": "This chore appears after a delay each time it is completed",
-      "weekly": "Done once, on any day from Sunday to Saturday. It only counts toward the daily bonus on Saturday."
+      "anyDay": "Done once, on any day of the period you pick. It only counts toward the daily bonus on the period's last day."
     },
     "visible": "Visible",
     "duplicate": "Duplicate",
@@ -527,7 +526,6 @@
     "daysOfMonthHelp": "One or more, like 1 or 1, 15",
     "againAfterCount": "Again after",
     "customEdit": "These chores use a custom schedule. Change each one with its settings button.",
-    "weeklyHelp": "Shows all week, and done once on any day counts. A fresh one comes each Sunday. It counts toward the daily bonus only on Saturday, and a week not done is one miss.",
     "changesCount_one": "This changes {{count}} chore for {{name}}.",
     "changesCount_other": "This changes {{count}} chores for {{name}}.",
     "daysChanged_one": "{{count}} chore now on {{timing}}.",
@@ -594,11 +592,84 @@
       "oneTime": "One-time",
       "oneTimeOn": "One-time · {{date}}",
       "againAfter": "Again {{interval}} after done",
-      "weeklyAnyDay": "Once a week, any day",
+      "anyDay": {
+        "1w": "Once a week, any day",
+        "2w": "Once every 2 weeks, any day",
+        "1m": "Once a month, any day",
+        "3m": "Once every 3 months, any day",
+        "6m": "Once every 6 months, any day",
+        "1y": "Once a year, any day"
+      },
       "custom": "Custom ({{expr}})",
       "yearly": "Every year · {{date}}",
       "everyNMonths_one": "Every month · {{dates}}",
       "everyNMonths_other": "Every {{count}} months · {{dates}}"
     }
+  },
+  "wizard": {
+    "modeLabel": "How to pick a schedule",
+    "picker": "Picker",
+    "wizard": "Wizard",
+    "stepOf": "Step {{step}} of {{count}}",
+    "howTitle": "How often should it happen?",
+    "how": {
+      "days": {
+        "title": "On certain days of the week",
+        "hint": "Every day, weekdays, or the days you pick"
+      },
+      "anyDay": {
+        "title": "Once in a while, any day",
+        "hint": "Once a week, a month, a year… any day in it counts"
+      },
+      "everyN": {
+        "title": "Every few days",
+        "hint": "Every 2 days, every 3 days…"
+      },
+      "monthly": {
+        "title": "On a date each month",
+        "hint": "The 1st, or the 1st and the 15th"
+      },
+      "after": {
+        "title": "Again a while after it’s done",
+        "hint": "Comes back 2 weeks after the last time, say"
+      },
+      "once": {
+        "title": "Just once",
+        "hint": "On a date, or whenever"
+      }
+    },
+    "details": {
+      "days": "Which days?",
+      "anyDay": "Once in how long?",
+      "everyN": "Every how many days?",
+      "monthly": "Which dates?",
+      "after": "How long after it’s done?",
+      "once": "When? (optional)"
+    },
+    "period": {
+      "1w": "A week",
+      "2w": "Two weeks",
+      "1m": "A month",
+      "3m": "Three months",
+      "6m": "Six months",
+      "1y": "A year"
+    },
+    "periodLabel": "How often",
+    "anyDayNote": "Doing it once, on any day in the period, counts. A fresh one comes when the next period starts. It counts toward the daily bonus only on the period’s last day, and a period not done is one miss. Weeks run Sunday to Saturday; months, quarters and years follow the calendar.",
+    "everyNLabel": "Days",
+    "afterCount": "How many",
+    "soFar": "So far:",
+    "missedTitle": "If it isn’t done that day…",
+    "missedDrop": "It goes away at the end of the day",
+    "missedDropHint": "The next one comes on its next day; a missed day is logged.",
+    "missedKeep": "It stays until it’s done",
+    "missedKeepHint": "It carries over to the next day until it’s checked off.",
+    "choresTitle": "Pick the chores",
+    "reviewTitle": "Check and add",
+    "reviewSentence": "{{name}}: {{chores}}. {{timing}}.",
+    "reviewKeep": "Each one stays until it’s done.",
+    "reviewDrop": "Each one goes away at the end of its day.",
+    "reviewMoves_one": "{{count}} of these already has a schedule for this person: it moves here.",
+    "reviewMoves_other": "{{count}} of these already have a schedule for this person: they move here."
   }
 }
diff --git a/client/src/i18n/locales/es/chores.json b/client/src/i18n/locales/es/chores.json
index 73eece40..f9e19016 100644
--- a/client/src/i18n/locales/es/chores.json
+++ b/client/src/i18n/locales/es/chores.json
@@ -208,14 +208,13 @@
     "untilCompleted": "Hasta completarla",
     "onceCompleted": "Una vez completada",
     "dayOf": "El mismo día",
-    "weekly": "Una vez a la semana (cualquier día)",
-    "weeklyChip": "Una vez a la semana",
-    "weeklyNext": "Cualquier día de esta semana; una nueva cada domingo",
+    "anyDay": "De vez en cuando (cualquier día)",
+    "anyDayNext": "Cualquier día de su periodo; una nueva en cada periodo",
     "durationHelp": {
       "dayOf": "Esta tarea solo aparece el día programado",
       "untilCompleted": "Esta tarea aparece cada día hasta completarla",
       "onceCompleted": "Esta tarea vuelve a aparecer un tiempo después de cada vez que se completa",
-      "weekly": "Se hace una vez, cualquier día de domingo a sábado. Solo cuenta para el bono diario el sábado."
+      "anyDay": "Se hace una vez, cualquier día del periodo que elijas. Solo cuenta para el bono diario el último día del periodo."
     },
     "visible": "Visible",
     "duplicate": "Duplicar",
@@ -527,7 +526,6 @@
     "daysOfMonthHelp": "Uno o más, como 1 o 1, 15",
     "againAfterCount": "De nuevo tras",
     "customEdit": "Estas tareas usan un horario personalizado. Cambia cada una con su botón de ajustes.",
-    "weeklyHelp": "Se ve toda la semana, y basta con hacerla una vez, cualquier día. Cada domingo llega una nueva. Solo cuenta para el bono diario el sábado, y una semana sin hacer cuenta como una falta.",
     "changesCount_one": "Esto cambia {{count}} tarea de {{name}}.",
     "changesCount_other": "Esto cambia {{count}} tareas de {{name}}.",
     "daysChanged_one": "{{count}} tarea ahora en {{timing}}.",
@@ -594,11 +592,84 @@
       "oneTime": "Una vez",
       "oneTimeOn": "Una vez · {{date}}",
       "againAfter": "De nuevo {{interval}} después de hacerla",
-      "weeklyAnyDay": "Una vez a la semana, cualquier día",
+      "anyDay": {
+        "1w": "Una vez a la semana, cualquier día",
+        "2w": "Una vez cada 2 semanas, cualquier día",
+        "1m": "Una vez al mes, cualquier día",
+        "3m": "Una vez cada 3 meses, cualquier día",
+        "6m": "Una vez cada 6 meses, cualquier día",
+        "1y": "Una vez al año, cualquier día"
+      },
       "custom": "Personalizado ({{expr}})",
       "yearly": "Cada año · {{date}}",
       "everyNMonths_one": "Cada mes · {{dates}}",
       "everyNMonths_other": "Cada {{count}} meses · {{dates}}"
     }
+  },
+  "wizard": {
+    "modeLabel": "Cómo elegir un horario",
+    "picker": "Selector",
+    "wizard": "Asistente",
+    "stepOf": "Paso {{step}} de {{count}}",
+    "howTitle": "¿Con qué frecuencia?",
+    "how": {
+      "days": {
+        "title": "Ciertos días de la semana",
+        "hint": "Cada día, entre semana o los días que elijas"
+      },
+      "anyDay": {
+        "title": "De vez en cuando, cualquier día",
+        "hint": "Una vez a la semana, al mes, al año… cualquier día cuenta"
+      },
+      "everyN": {
+        "title": "Cada pocos días",
+        "hint": "Cada 2 días, cada 3 días…"
+      },
+      "monthly": {
+        "title": "Una fecha cada mes",
+        "hint": "El día 1, o el 1 y el 15"
+      },
+      "after": {
+        "title": "De nuevo un tiempo después de hacerla",
+        "hint": "Vuelve, por ejemplo, 2 semanas después de la última vez"
+      },
+      "once": {
+        "title": "Solo una vez",
+        "hint": "En una fecha, o cuando sea"
+      }
+    },
+    "details": {
+      "days": "¿Qué días?",
+      "anyDay": "¿Una vez cada cuánto?",
+      "everyN": "¿Cada cuántos días?",
+      "monthly": "¿Qué fechas?",
+      "after": "¿Cuánto tiempo después de hacerla?",
+      "once": "¿Cuándo? (opcional)"
+    },
+    "period": {
+      "1w": "Una semana",
+      "2w": "Dos semanas",
+      "1m": "Un mes",
+      "3m": "Tres meses",
+      "6m": "Seis meses",
+      "1y": "Un año"
+    },
+    "periodLabel": "Frecuencia",
+    "anyDayNote": "Basta con hacerla una vez, cualquier día del periodo. Cuando empieza el siguiente periodo llega una nueva. Solo cuenta para el bono diario el último día del periodo, y un periodo sin hacer cuenta como una falta. Las semanas van de domingo a sábado; los meses, trimestres y años siguen el calendario.",
+    "everyNLabel": "Días",
+    "afterCount": "Cuántos",
+    "soFar": "Por ahora:",
+    "missedTitle": "Si no se hace ese día…",
+    "missedDrop": "Desaparece al terminar el día",
+    "missedDropHint": "La siguiente llega su próximo día; el día sin hacer queda registrado.",
+    "missedKeep": "Se queda hasta hacerla",
+    "missedKeepHint": "Pasa al día siguiente hasta que se marque como hecha.",
+    "choresTitle": "Elige las tareas",
+    "reviewTitle": "Revisa y añade",
+    "reviewSentence": "{{name}}: {{chores}}. {{timing}}.",
+    "reviewKeep": "Cada una se queda hasta hacerla.",
+    "reviewDrop": "Cada una desaparece al terminar su día.",
+    "reviewMoves_one": "{{count}} de estas ya tiene un horario para esta persona: se mueve aquí.",
+    "reviewMoves_other": "{{count}} de estas ya tienen un horario para esta persona: se mueven aquí."
   }
 }
diff --git a/client/src/utils/choreDays.js b/client/src/utils/choreDays.js
index 46853fbb..d277e7fa 100644
--- a/client/src/utils/choreDays.js
+++ b/client/src/utils/choreDays.js
@@ -51,11 +51,11 @@ export function cronFiresOn(crontab, dateStr) {
   return domMatch || dowMatch;
 }
 
-const STICKY_DURATIONS = ['until-completed', 'once-completed', 'weekly'];
+const STICKY_DURATIONS = ['until-completed', 'once-completed', 'any-day'];
 
 /**
  * Whether the midnight job logs misses for this schedule: an assigned,
- * zero-clam chore that isn't a sticky (until/once-completed, weekly) one.
+ * zero-clam chore that isn't a sticky (until/once-completed, any-day) one.
  * Mirrors the server's getTodaysRegularChoresForUser.
  */
 export function missesTracked(schedule) {
@@ -66,12 +66,12 @@ export function missesTracked(schedule) {
 
 /**
  * Whether the schedule was due on `dateStr`, or null when that can't be told
- * from the schedule (sticky chores carry over between days). A once-a-week
- * chore's card is due on its last day only (server/services/weeklyChores.js).
+ * from the schedule (sticky chores carry over between days). An any-day
+ * chore's card is due on its last day only (server/services/anyDayChores.js).
  */
 export function dueOn(schedule, dateStr) {
   if (schedule.crontab && STICKY_DURATIONS.includes(schedule.duration)) return null;
-  if (schedule.parent_duration === 'weekly' && schedule.due_date) return dateStr === schedule.due_date;
+  if (schedule.parent_duration === 'any-day' && schedule.due_date) return dateStr === schedule.due_date;
   if (!schedule.crontab) return true;
   return cronFiresOn(schedule.crontab, dateStr);
 }
diff --git a/client/src/utils/choreDays.test.js b/client/src/utils/choreDays.test.js
index 9fed5490..7b85deea 100644
--- a/client/src/utils/choreDays.test.js
+++ b/client/src/utils/choreDays.test.js
@@ -39,21 +39,21 @@ describe('missesTracked', () => {
     expect(missesTracked({ ...base, clam_value: 2 })).toBe(false);
     expect(missesTracked({ ...base, user_id: 0 })).toBe(false);
     expect(missesTracked({ ...base, crontab: MWF, duration: 'until-completed' })).toBe(false);
-    expect(missesTracked({ ...base, crontab: '0 0 * * 0', duration: 'weekly' })).toBe(false);
+    expect(missesTracked({ ...base, crontab: '0 0 * * 0', duration: 'any-day', interval: '1w' })).toBe(false);
   });
 });
 
 describe('dueOn', () => {
-  it("is a once-a-week chore's Saturday only, for its card", () => {
-    const card = { ...base, parent_schedule_id: 9, parent_duration: 'weekly', due_date: '2026-10-24' };
+  it("is an any-day chore's last day only, for its card", () => {
+    const card = { ...base, parent_schedule_id: 9, parent_duration: 'any-day', due_date: '2026-10-24' };
     expect(dueOn(card, '2026-10-20')).toBe(false);
     expect(dueOn(card, '2026-10-24')).toBe(true);
     // Its schedule carries over, like the other sticky ones.
-    expect(dueOn({ ...base, crontab: '0 0 * * 0', duration: 'weekly' }, '2026-10-25')).toBeNull();
+    expect(dueOn({ ...base, crontab: '0 0 * * 0', duration: 'any-day', interval: '1w' }, '2026-10-25')).toBeNull();
   });
 
-  it("marks a weekly card's days before Saturday as off, not missed", () => {
-    const card = { ...base, parent_schedule_id: 9, parent_duration: 'weekly', due_date: '2026-10-24', created_at: '2026-10-18 08:00:00' };
+  it("marks an any-day card's days before its last day as off, not missed", () => {
+    const card = { ...base, parent_schedule_id: 9, parent_duration: 'any-day', due_date: '2026-10-24', created_at: '2026-10-18 08:00:00' };
     const days = choreDays({ rows: [], schedule: card, userId: 2, today: TODAY });
     expect(days.filter((d) => d.date < TODAY).every((d) => d.state === 'off')).toBe(true);
   });
diff --git a/client/src/utils/choreHelpers.js b/client/src/utils/choreHelpers.js
index c727756d..2ebd98f7 100644
--- a/client/src/utils/choreHelpers.js
+++ b/client/src/utils/choreHelpers.js
@@ -37,13 +37,13 @@ export function shouldShowChoreToday(schedule, today = getTodayDateString()) {
 /**
  * Whether a chore counts toward the daily bonus today: a regular (zero-clam)
  * chore, unless it is a follow-up handed out today. A follow-up can arrive at
- * 9 pm, so it counts from the next day (issue #241). A once-a-week chore
- * counts on its week's last day only (its card's due date). Mirrors the
+ * 9 pm, so it counts from the next day (issue #241). An any-day chore
+ * counts on its period's last day only (its card's due date). Mirrors the
  * server's getTodaysRegularChoresForUser, so the widget and the bonus agree.
  */
 export function countsTowardDailyBonus(schedule, today = getTodayDateString()) {
   if ((schedule.clam_value || 0) !== 0) return false;
-  if (schedule.parent_duration === 'weekly' && schedule.due_date && schedule.due_date !== today) return false;
+  if (schedule.parent_duration === 'any-day' && schedule.due_date && schedule.due_date !== today) return false;
   return !(schedule.triggered_on && schedule.triggered_on === today);
 }
 
diff --git a/client/src/utils/choreHelpers.test.js b/client/src/utils/choreHelpers.test.js
index a4e868cd..1ddf1326 100644
--- a/client/src/utils/choreHelpers.test.js
+++ b/client/src/utils/choreHelpers.test.js
@@ -26,8 +26,8 @@ describe('countsTowardDailyBonus', () => {
         expect(countsTowardDailyBonus({ clam_value: 3, triggered_on: '2026-10-07' }, today)).toBe(false);
     });
 
-    it('counts a once-a-week chore on its Saturday only', () => {
-        const card = { clam_value: 0, parent_duration: 'weekly', due_date: '2026-10-10' };
+    it('counts an any-day chore on its last day only', () => {
+        const card = { clam_value: 0, parent_duration: 'any-day', due_date: '2026-10-10' };
         expect(countsTowardDailyBonus(card, today)).toBe(false);
         expect(countsTowardDailyBonus(card, '2026-10-10')).toBe(true);
         // Another sticky chore's card with a due date still counts every day.
diff --git a/client/src/utils/choreScheduleGroups.js b/client/src/utils/choreScheduleGroups.js
index 643896fe..b9e7d29f 100644
--- a/client/src/utils/choreScheduleGroups.js
+++ b/client/src/utils/choreScheduleGroups.js
@@ -73,7 +73,7 @@ function cronFields(crontab) {
 // daily copy (parent_schedule_id): the schedule it came from stands for it.
 export function timingOfSchedule(schedule) {
   if (!schedule || schedule.parent_schedule_id) return null;
-  if (schedule.duration === 'weekly') return weeklyTiming();
+  if (schedule.duration === 'any-day') return anyDayTiming(schedule.interval || '1w');
   if (schedule.duration === 'once-completed' && schedule.crontab) {
     const interval = schedule.interval || '';
     return { kind: 'after', key: `after:${interval}`, interval };
@@ -154,10 +154,39 @@ export const monthlyTiming = (dom) => {
 };
 export const onceTiming = (dueDate = null) => ({ kind: 'once', key: `once:${dueDate || ''}`, dueDate: dueDate || null });
 export const afterTiming = (interval) => ({ kind: 'after', key: `after:${interval}`, interval });
-// Once a week, any day (server/services/weeklyChores.js). The server keeps
-// its crontab at the week start; the days mean nothing.
-export const weeklyTiming = () => ({ kind: 'weekly', key: 'weekly' });
-export const WEEKLY_CRONTAB = '0 0 * * 0';
+// Once in a period, any day of it (server/services/anyDayChores.js). The
+// period is the schedule's interval; its crontab means nothing.
+export const ANY_DAY_PERIODS = ['1w', '2w', '1m', '3m', '6m', '1y'];
+export const anyDayTiming = (period = '1w') => ({ kind: 'anyDay', key: `anyDay:${period}`, period });
+export const ANY_DAY_CRONTAB = '0 0 * * *';
+
+/**
+ * The period a date ('YYYY-MM-DD') falls in, as { start, end }, the same as
+ * the server's periodOf: weeks run Sunday to Saturday (two weeks from the
+ * week `anchor`, the schedule's creation, is in), months and longer follow
+ * the calendar (quarters, halves, years).
+ */
+export function anyDayPeriodOf(dateKey, period = '1w', anchor = null) {
+  const m = String(ANY_DAY_PERIODS.includes(period) ? period : '1w').match(/^(\d+)([wmy])$/);
+  const count = Number(m[1]);
+  const weekStart = (key) => addDays(key, -new Date(`${key}T12:00:00Z`).getUTCDay());
+  if (m[2] === 'w') {
+    const start = weekStart(dateKey);
+    if (count === 1) return { start, end: addDays(start, 6) };
+    const from = weekStart(String(anchor || dateKey).slice(0, 10));
+    const weeks = Math.round((Date.parse(`${start}T12:00:00Z`) - Date.parse(`${from}T12:00:00Z`)) / (7 * 86400000));
+    const blockStart = addDays(from, Math.floor(weeks / count) * count * 7);
+    return { start: blockStart, end: addDays(blockStart, count * 7 - 1) };
+  }
+  const months = m[2] === 'y' ? count * 12 : count;
+  const [y, mo] = dateKey.split('-').map(Number);
+  const first = Math.floor((y * 12 + mo - 1) / months) * months;
+  const iso = (d) => d.toISOString().slice(0, 10);
+  return {
+    start: iso(new Date(Date.UTC(Math.floor(first / 12), first % 12, 1))),
+    end: iso(new Date(Date.UTC(Math.floor((first + months) / 12), (first + months) % 12, 0))),
+  };
+}
 
 // The day fields a timing writes into a crontab.
 function dayFieldsOf(timing) {
@@ -185,11 +214,11 @@ export function scheduleFieldsForTiming(timing, schedule = null) {
   const time = old ? `${old.minute} ${old.hour}` : '0 0';
   // A schedule leaving "again after done" or "once a week" goes back to
   // showing on its day.
-  const wasAfter = schedule?.duration === 'once-completed' || schedule?.duration === 'weekly';
+  const wasAfter = schedule?.duration === 'once-completed' || schedule?.duration === 'any-day';
   const keepDuration = schedule && !wasAfter ? (schedule.duration || 'day-of') : 'day-of';
   switch (timing.kind) {
-    case 'weekly':
-      return { crontab: WEEKLY_CRONTAB, duration: 'weekly', interval: null };
+    case 'anyDay':
+      return { crontab: ANY_DAY_CRONTAB, duration: 'any-day', interval: timing.period };
     case 'once':
       return { crontab: null, duration: 'day-of', interval: null, due_date: timing.dueDate || null };
     case 'after':
@@ -208,9 +237,10 @@ export function scheduleFieldsForTiming(timing, schedule = null) {
 }
 
 // Group order: every day first, then the other weekly groups (most days
-// first, then by first day), then once a week (any day), every-n-days,
-// monthly, again-after-done, custom, and one-time last (by date).
-const KIND_ORDER = { week: 0, weekly: 1, everyN: 2, monthly: 3, months: 4, after: 5, custom: 6, once: 7 };
+// first, then by first day), then once in a period (any day, shortest
+// first), every-n-days, monthly, again-after-done, custom, and one-time last
+// (by date).
+const KIND_ORDER = { week: 0, anyDay: 1, everyN: 2, monthly: 3, months: 4, after: 5, custom: 6, once: 7 };
 export function compareTimings(a, b) {
   if (KIND_ORDER[a.kind] !== KIND_ORDER[b.kind]) return KIND_ORDER[a.kind] - KIND_ORDER[b.kind];
   if (a.kind === 'week') {
@@ -224,6 +254,7 @@ export function compareTimings(a, b) {
     return 0;
   }
   if (a.kind === 'everyN') return a.n - b.n;
+  if (a.kind === 'anyDay') return ANY_DAY_PERIODS.indexOf(a.period) - ANY_DAY_PERIODS.indexOf(b.period);
   if (a.kind === 'months') return (a.every || 99) - (b.every || 99) || a.key.localeCompare(b.key);
   if (a.kind === 'once') return String(a.dueDate || '9999').localeCompare(String(b.dueDate || '9999'));
   return a.key.localeCompare(b.key);
@@ -256,7 +287,7 @@ export const COMMON_TIMINGS = [
   weekTiming([0, 6]),
   weekTiming([1, 3, 5]),
   weekTiming([2, 4]),
-  weeklyTiming(),
+  anyDayTiming('1w'),
   everyNTiming(2),
   onceTiming(null),
 ];
@@ -275,7 +306,7 @@ export function timingFallsOn(timing, date, { schedule = null, tz } = {}) {
       return timing.dueDate === key;
     }
     case 'after':
-    case 'weekly':
+    case 'anyDay':
       return null;
     default: {
       const expr = schedule?.crontab || `0 0 ${dayFieldsOf(timing)}`;
@@ -322,27 +353,39 @@ const inVacation = (vacation, key) => !!vacation && vacation.enabled === true
 
 const STICKY = new Set(['until-completed', 'once-completed']);
 
-// A once-a-week chore on the week shown (`days`, Sunday to Saturday): on the
-// day it was done; or, not done, on Saturday, its due day (missed if a miss
-// was logged, not done if that day is past, planned if it's ahead); and on
-// today, waiting, while this week is still open.
-function weeklyOnCalendar(s, days, { done, missed, today }) {
-  const saturday = days[days.length - 1];
+// An any-day chore on the week shown (`days`, Sunday to Saturday):
+//   on the day it was done;
+//   on today, waiting (or due today, on its period's last day), while it
+//     still has an open card (`openCards`: the schedules that do; unknown
+//     means it's assumed open);
+//   on its period's last day if that's in this week: missed if a miss was
+//     logged, not done if past (only when the whole period is this week, as
+//     an earlier week may have had it done), planned if ahead.
+function anyDayOnCalendar(s, period, days, { done, missed, today, openCards }) {
   const doneDay = days.find((d) => done.has(`${s.chore_id}|${d.date}`));
   if (doneDay) {
     doneDay.items.push({ schedule: s, state: 'done', late: false });
     return;
   }
   const since = s.created_at ? String(s.created_at).slice(0, 10) : null;
-  if (since && saturday.date < since) return;
-  if (missed.has(`${s.chore_id}|${saturday.date}`)) {
-    saturday.items.push({ schedule: s, state: 'missed', late: false });
-  } else if (saturday.date < today) {
-    if (!saturday.vacation) saturday.items.push({ schedule: s, state: 'notDone', late: false });
+  const periodEnd = days.find((d) => anyDayPeriodOf(d.date, period, s.created_at).end === d.date);
+  if (periodEnd && (!since || periodEnd.date >= since) && missed.has(`${s.chore_id}|${periodEnd.date}`)) {
+    periodEnd.items.push({ schedule: s, state: 'missed', late: false });
+    return;
+  }
+  const todayBox = days.find((d) => d.date === today);
+  if (todayBox) {
+    if (s.visible && (!openCards || openCards.has(s.id))) {
+      todayBox.items.push({ schedule: s, state: todayBox === periodEnd ? 'today' : 'waiting', late: false });
+    }
+    return;
+  }
+  if (!periodEnd || (since && periodEnd.date < since)) return;
+  if (periodEnd.date < today) {
+    const wholeWeek = anyDayPeriodOf(periodEnd.date, period, s.created_at).start >= days[0].date;
+    if (wholeWeek && !periodEnd.vacation) periodEnd.items.push({ schedule: s, state: 'notDone', late: false });
   } else if (s.visible) {
-    const todayBox = days.find((d) => d.date === today);
-    if (todayBox) todayBox.items.push({ schedule: s, state: todayBox === saturday ? 'today' : 'waiting', late: false });
-    else saturday.items.push({ schedule: s, state: 'planned', late: false });
+    periodEnd.items.push({ schedule: s, state: 'planned', late: false });
   }
 }
 
@@ -358,9 +401,10 @@ function weeklyOnCalendar(s, days, { done, missed, today }) {
  *   planned  a future day
  * Vacation days are flagged; hidden chores only appear where they were done.
  * `noDay` lists chores that can't be placed (one-time with no date, or an
- * again-after-done one with no next date).
+ * again-after-done one with no next date). `openCards` is the ids of the
+ * sticky schedules with a card on the wall now (see anyDayOnCalendar).
  */
-export function calendarWeek({ groups, dates, today, rows = [], vacation = null }) {
+export function calendarWeek({ groups, dates, today, rows = [], vacation = null, openCards = null }) {
   const done = new Map(); // `${chore_id}|${date}` → true
   const missed = new Set();
   for (const r of rows) {
@@ -373,8 +417,8 @@ export function calendarWeek({ groups, dates, today, rows = [], vacation = null
   const noDay = [];
   for (const g of groups) {
     for (const s of g.schedules) {
-      if (g.timing.kind === 'weekly') {
-        weeklyOnCalendar(s, days, { done, missed, today });
+      if (g.timing.kind === 'anyDay') {
+        anyDayOnCalendar(s, g.timing.period, days, { done, missed, today, openCards });
         continue;
       }
       let dueKeys = [];
diff --git a/client/src/utils/choreScheduleGroups.test.js b/client/src/utils/choreScheduleGroups.test.js
index c25447f6..bd917c6f 100644
--- a/client/src/utils/choreScheduleGroups.test.js
+++ b/client/src/utils/choreScheduleGroups.test.js
@@ -16,6 +16,8 @@ import {
   monthsFromStart,
   nextFireOn,
   calendarWeek,
+  anyDayTiming,
+  anyDayPeriodOf,
 } from './choreScheduleGroups.js';
 
 describe('parseDaysOfWeek', () => {
@@ -250,52 +252,74 @@ describe('calendarWeek', () => {
     expect(state(week, '2026-10-26', 6).state).toBe('planned');
   });
 
-  describe('a once-a-week chore', () => {
-    const weekly = (extra = {}) => S(9, 9, '0 0 * * 0', { duration: 'weekly', ...extra });
+  describe('an any-day chore', () => {
+    const anyDay = (extra = {}) => S(9, 9, '0 0 * * *', { duration: 'any-day', interval: '1w', ...extra });
     const onDays = (week) => week.days.filter((d) => d.items.some((i) => i.schedule.chore_id === 9)).map((d) => [d.date, state(week, d.date, 9).state]);
+    const run = (schedule, opts = {}) => onDays(calendarWeek({ groups: [group([schedule])], dates, today, ...opts }));
 
     it('sits on the day it was done, once', () => {
-      const week = calendarWeek({ groups: [group([weekly()])], dates, today, rows: [{ chore_id: 9, date: '2026-10-26', kind: 'completion' }] });
+      const week = calendarWeek({ groups: [group([anyDay()])], dates, today, rows: [{ chore_id: 9, date: '2026-10-26', kind: 'completion' }] });
       expect(onDays(week)).toEqual([['2026-10-26', 'done']]);
       expect(state(week, '2026-10-26', 9).late).toBe(false);
     });
 
-    it('waits on today while the week is open, and is due on Saturday', () => {
-      expect(onDays(calendarWeek({ groups: [group([weekly()])], dates, today }))).toEqual([['2026-10-28', 'waiting']]);
-      expect(onDays(calendarWeek({ groups: [group([weekly()])], dates, today: '2026-10-31' }))).toEqual([['2026-10-31', 'today']]);
+    it('waits on today while its card is open, and is due on the last day', () => {
+      expect(run(anyDay())).toEqual([['2026-10-28', 'waiting']]);
+      expect(run(anyDay(), { today: '2026-10-31' })).toEqual([['2026-10-31', 'today']]);
+      // A month's last day isn't this week: still waiting today.
+      expect(run(anyDay({ interval: '1m' }), { today: '2026-10-29' })).toEqual([['2026-10-29', 'waiting']]);
+      expect(run(anyDay({ interval: '1m' }), { today: '2026-10-31' })).toEqual([['2026-10-31', 'today']]);
     });
 
-    it('shows a past week as missed, or not done, on its Saturday', () => {
+    it('done earlier in its period (no open card), it shows nothing this week', () => {
+      expect(run(anyDay({ interval: '1m' }), { openCards: new Set() })).toEqual([]);
+      expect(run(anyDay({ interval: '1m' }), { openCards: new Set([9]) })).toEqual([['2026-10-28', 'waiting']]);
+    });
+
+    it('a past period: missed or not done on its last day, not done only if all of it was this week', () => {
       const later = '2026-11-02';
-      expect(onDays(calendarWeek({ groups: [group([weekly()])], dates, today: later, rows: [{ chore_id: 9, date: '2026-10-31', kind: 'missed' }] })))
-        .toEqual([['2026-10-31', 'missed']]);
-      expect(onDays(calendarWeek({ groups: [group([weekly()])], dates, today: later }))).toEqual([['2026-10-31', 'notDone']]);
+      expect(run(anyDay(), { today: later, rows: [{ chore_id: 9, date: '2026-10-31', kind: 'missed' }] })).toEqual([['2026-10-31', 'missed']]);
+      expect(run(anyDay(), { today: later })).toEqual([['2026-10-31', 'notDone']]);
+      expect(run(anyDay({ interval: '1m' }), { today: later })).toEqual([], 'it may have been done earlier in October');
+      expect(run(anyDay({ interval: '1m' }), { today: later, rows: [{ chore_id: 9, date: '2026-10-31', kind: 'missed' }] })).toEqual([['2026-10-31', 'missed']]);
     });
 
-    it('a week ahead is planned for its Saturday; nothing before it existed', () => {
-      expect(onDays(calendarWeek({ groups: [group([weekly()])], dates, today: '2026-10-20' }))).toEqual([['2026-10-31', 'planned']]);
-      expect(onDays(calendarWeek({ groups: [group([weekly({ created_at: '2026-11-03 10:00:00' })])], dates, today: '2026-11-04' }))).toEqual([]);
+    it('a period ending ahead is planned for its last day; nothing before it existed', () => {
+      expect(run(anyDay(), { today: '2026-10-20' })).toEqual([['2026-10-31', 'planned']]);
+      expect(run(anyDay({ interval: '1m' }), { today: '2026-10-20' })).toEqual([['2026-10-31', 'planned']]);
+      expect(run(anyDay({ interval: '3m' }), { today: '2026-10-20' })).toEqual([]);
+      expect(run(anyDay({ created_at: '2026-11-03 10:00:00' }), { today: '2026-11-04' })).toEqual([]);
     });
   });
 });
 
-describe('once a week, any day', () => {
-  it('is its own timing, offered with the common ones, after the week days', () => {
-    const schedule = { id: 1, crontab: '0 0 * * 0', duration: 'weekly' };
-    expect(timingOfSchedule(schedule)).toEqual({ kind: 'weekly', key: 'weekly' });
-    expect(COMMON_TIMINGS.some((tm) => tm.kind === 'weekly')).toBe(true);
+describe('once in a period, any day', () => {
+  it('is its own timing per period, the week one offered with the common ones', () => {
+    expect(timingOfSchedule({ id: 1, crontab: '0 0 * * *', duration: 'any-day', interval: '3m' })).toEqual({ kind: 'anyDay', key: 'anyDay:3m', period: '3m' });
+    expect(timingOfSchedule({ id: 1, crontab: '0 0 * * *', duration: 'any-day' })).toEqual(anyDayTiming('1w'));
+    expect(COMMON_TIMINGS.some((tm) => tm.key === 'anyDay:1w')).toBe(true);
     const groups = groupSchedulesForUser([
-      { id: 1, user_id: 1, title: 'Practice', crontab: '0 0 * * 0', duration: 'weekly' },
+      { id: 1, user_id: 1, title: 'Filter', crontab: '0 0 * * *', duration: 'any-day', interval: '3m' },
       { id: 2, user_id: 1, title: 'Dishes', crontab: '0 0 * * *', duration: 'day-of' },
       { id: 3, user_id: 1, title: 'Plants', crontab: '0 0 */2 * *', duration: 'day-of' },
+      { id: 4, user_id: 1, title: 'Practice', crontab: '0 0 * * *', duration: 'any-day', interval: '1w' },
     ], 1);
-    expect(groups.map((g) => g.timing.kind)).toEqual(['week', 'weekly', 'everyN']);
+    expect(groups.map((g) => g.timing.key)).toEqual(['week:0,1,2,3,4,5,6', 'anyDay:1w', 'anyDay:3m', 'every:2']);
   });
 
-  it('writes the week start, and moving off it goes back to its day', () => {
-    expect(scheduleFieldsForTiming({ kind: 'weekly', key: 'weekly' })).toEqual({ crontab: '0 0 * * 0', duration: 'weekly', interval: null });
-    const moved = scheduleFieldsForTiming(weekTiming([1, 3]), { crontab: '0 0 * * 0', duration: 'weekly' });
+  it('writes its period, and moving off it goes back to a day', () => {
+    expect(scheduleFieldsForTiming(anyDayTiming('1m'))).toEqual({ crontab: '0 0 * * *', duration: 'any-day', interval: '1m' });
+    const moved = scheduleFieldsForTiming(weekTiming([1, 3]), { crontab: '0 0 * * *', duration: 'any-day', interval: '1w' });
     expect(moved).toEqual({ crontab: '0 0 * * 1,3', duration: 'day-of', interval: null });
-    expect(timingFallsOn({ kind: 'weekly', key: 'weekly' }, new Date(2026, 9, 25))).toBeNull();
+    expect(timingFallsOn(anyDayTiming('1w'), new Date(2026, 9, 25))).toBeNull();
+  });
+
+  it('knows its periods as the server does', () => {
+    expect(anyDayPeriodOf('2026-11-04', '1w')).toEqual({ start: '2026-11-01', end: '2026-11-07' });
+    expect(anyDayPeriodOf('2026-11-15', '2w', '2026-11-04 09:00:00')).toEqual({ start: '2026-11-15', end: '2026-11-28' });
+    expect(anyDayPeriodOf('2028-02-10', '1m')).toEqual({ start: '2028-02-01', end: '2028-02-29' });
+    expect(anyDayPeriodOf('2026-11-30', '3m')).toEqual({ start: '2026-10-01', end: '2026-12-31' });
+    expect(anyDayPeriodOf('2026-07-15', '6m')).toEqual({ start: '2026-07-01', end: '2026-12-31' });
+    expect(anyDayPeriodOf('2026-10-31', '1y')).toEqual({ start: '2026-01-01', end: '2026-12-31' });
   });
 });
diff --git a/docs/reference/backend-api.md b/docs/reference/backend-api.md
index f7559017..050f9980 100644
--- a/docs/reference/backend-api.md
+++ b/docs/reference/backend-api.md
@@ -208,7 +208,7 @@ Every recipient (a device's browser push, an ntfy topic, a Home Assistant phone)
 | GET/POST | `/api/chores` | List / create chore definitions. Each listed chore carries `followups: [{ id, followup_chore_id, title }]`. |
 | PATCH/DELETE | `/api/chores/:id` | Update / delete a chore. Deleting removes its follow-up rules and any rule that names it. |
 | GET/PUT | `/api/chores/:id/followups` | A chore's follow-ups (issue #241). PUT replaces them with `{ followups: [{ followup_chore_id, user_ids, delay_minutes }] }`: at most 3, not the chore itself, no loops, at least one person, delay 0–10080 minutes. |
-| GET/POST | `/api/chore-schedules` | List (filter by `user_id`, `visible`, `usage`, `chore_id`) / create. `duration` is `day-of` (default), `until-completed`, `once-completed` (with `interval`) or `weekly` (once a week, any day: its crontab is set to `0 0 * * 0` whatever is sent). Each row carries `parent_duration`, the duration of the schedule a sticky chore's card came from (a `weekly` card is due on its `due_date`, the week's Saturday). Accepts `due_time` (`HH:MM`), `sound`, `sound_enabled`, `reminder_interval_minutes` for due-time sounds, and `due_date` (`YYYY-MM-DD`) for calendar deadlines. `expire_minutes` (one of 0, 15, 30, 60, 120, 180, 240, 360, 480, 720, or null) makes it expire that long after its due time; it needs a `due_time` (400 otherwise), and clearing the due time clears it. PATCH `user_id` reassigns a chore and re-checks the daily bonus for both owners. Taking a chore off someone's day (deleting its schedule or chore, hiding it, moving it to other days, snoozing it, giving the chore clams, or deleting a routine) re-checks their bonus too, and pays it if the rest of the day is done; it never takes a bonus back (issue #298). |
+| GET/POST | `/api/chore-schedules` | List (filter by `user_id`, `visible`, `usage`, `chore_id`) / create. `duration` is `day-of` (default), `until-completed`, `once-completed` (with an `interval` such as `3d`) or `any-day` (once in a period, any day: `interval` is its period, one of `1w`, `2w`, `1m`, `3m`, `6m`, `1y`, default `1w`; its crontab is set to `0 0 * * *` whatever is sent). `weekly` is accepted as `any-day` every `1w`. Each row carries `parent_duration`, the duration of the schedule a sticky chore's card came from (an `any-day` card is due on its `due_date`, its period's last day). Accepts `due_time` (`HH:MM`), `sound`, `sound_enabled`, `reminder_interval_minutes` for due-time sounds, and `due_date` (`YYYY-MM-DD`) for calendar deadlines. `expire_minutes` (one of 0, 15, 30, 60, 120, 180, 240, 360, 480, 720, or null) makes it expire that long after its due time; it needs a `due_time` (400 otherwise), and clearing the due time clears it. PATCH `user_id` reassigns a chore and re-checks the daily bonus for both owners. Taking a chore off someone's day (deleting its schedule or chore, hiding it, moving it to other days, snoozing it, giving the chore clams, or deleting a routine) re-checks their bonus too, and pays it if the rest of the day is done; it never takes a bonus back (issue #298). |
 | GET/PATCH/DELETE | `/api/chore-schedules/:id` | Single schedule CRUD. |
 | POST | `/api/chore-schedules/bulk` | Bulk create schedules. |
 | GET/POST | `/api/chore-history` | Query / add history entries. |
diff --git a/docs/reference/features.md b/docs/reference/features.md
index ce324589..6d406528 100644
--- a/docs/reference/features.md
+++ b/docs/reference/features.md
@@ -57,14 +57,26 @@ The chore system uses a **three-table model** (see [Database](../architecture/da
   - `day-of` — shows only on the scheduled day.
   - `until-completed` — a "sticky" chore that stays until done.
   - `once-completed` — sticky, and recurs again after an `interval` (e.g. `3m`).
-  - `weekly` — **once a week, any day** (practise an instrument). It shows all
-    week, Sunday to Saturday, and done once on any day counts. Its card is due
-    by the week's Saturday: until then it doesn't hold back the daily bonus, and
-    no miss is logged. On Saturday it counts toward the bonus if it's still open,
-    and an undone week is logged as **one** miss. Each Sunday a fresh card
-    replaces last week's, done or not. Its crontab is kept at `0 0 * * 0`, which
-    only marks the week start. Set it from the board's Add (*Once a week, any
-    day*) or the schedule dialog's Duration. Code: `server/services/weeklyChores.js`.
+  - `any-day` — **once in a period, any day of it** (practise an instrument
+    once a week; change the furnace filter once every 3 months). The period is
+    the schedule's `interval`:
+    - `1w`: Sunday to Saturday.
+    - `2w`: counted from the week the schedule was made.
+    - `1m`: a calendar month.
+    - `3m`, `6m`: quarters and halves of the year.
+    - `1y`: a calendar year.
+
+    Its card shows from the start of the period, and doing it once, any day,
+    counts. The card is due on the period's last day. Until then it doesn't hold
+    back the daily bonus and no miss is logged. On that last day it counts
+    toward the bonus if it's still open, and an undone period is logged as
+    **one** miss. When the next period starts, a fresh card replaces the old
+    one, done or not. Its crontab means nothing (kept at `0 0 * * *`). Set it
+    from the board's Add (the wizard's *Once in a while, any day*, or the
+    picker's *Once a week, any day*) or the schedule dialog's Duration.
+    `weekly`, its name for a day (#362), still works and means every `1w`;
+    migration `schema38-anyDayChores` converted those rows. Code:
+    `server/services/anyDayChores.js`.
 - **Sticky chores** are materialized nightly: the background job creates one-time
   child schedules (`parent_schedule_id`) when a recurring sticky schedule fires.
   When a card is cleared, its history moves to the schedule it came from, so the
@@ -135,16 +147,33 @@ tab, and unassigned bonus chores have one of their own. A tab shows:
   there, marked late), ✗ missed or not done, ⏳ a stays-until-done chore still
   waiting (also shown on today, "from Mon", until it's done); vacation days are striped and marked 🏖️, and days before a schedule
   existed show nothing. An "again after done" chore sits on its next date (the
-  server rewrites its crontab to that date when it's done). A once-a-week chore
-  sits on the day it was done. If it isn't done, it's on today (⏳) while the
-  week is open, and on Saturday otherwise (✗ for a past week, planned for a
-  week ahead). Arrows step to other
+  server rewrites its crontab to that date when it's done). An any-day chore
+  sits on the day it was done. If it isn't done, it's on today (⏳) while its
+  card is up, and on its period's last day if that falls in the week shown: ✗
+  for a logged miss (or, for a week, not done), planned for one ahead. A
+  longer period done in an earlier week shows nothing. Arrows step to other
   weeks. Chores with no fixed day (one-time with no date) are listed under it.
 - **The person's chores grouped by schedule**: "Every day", "Weekdays",
   "Mon · Wed · Fri", "Every other day", "Monthly · day 1",
   "Every 3 months · Jan 15, Apr 15, Jul 15, Oct 15", "Every year · Mar 20",
-  "One-time · Nov 3", "Again 3 days after done". **Add** offers the person's
-  schedules first, then the common ones, **Monthly** (pick the
+  "One-time · Nov 3", "Again 3 days after done", "Once a month, any day".
+  **Add** has two ways in, a **Picker** and a **Wizard**, and each display
+  remembers which it last used (the picker at first).
+  - **The wizard** steps through it:
+    1. How often: certain days of the week, once in a while any day, every
+       few days, a date each month, again a while after it's done, or just
+       once.
+    2. The details for that choice: the days, the period (a week, two weeks,
+       a month, three or six months, a year), the number of days, the dates
+       of the month, how long after, or the date.
+    3. For timings that fall on days only, if it isn't done that day: it goes
+       away at the end of the day, or it stays until it's done.
+    4. The chores.
+    5. A one-line summary, then Add.
+
+    Back keeps the answers given. `components/ScheduleWizard.jsx`.
+  - **The picker** offers the person's schedules first, then the common ones,
+    **Monthly** (pick the
   day of the month), **Custom** (every 1, 3, 6 or 9 months or a year, on set
   dates from a start date or counted from when it's done; 9 months only counts
   from when it's done), or any set of days; then a tick list of
diff --git a/server/index.js b/server/index.js
index fb6ac662..130a5015 100644
--- a/server/index.js
+++ b/server/index.js
@@ -95,7 +95,7 @@ const axios = require('axios');
 const ICAL = require('ical.js');
 const { CronExpressionParser } = require('cron-parser');
 const { cronFiresOnDate } = require('./utils/cronDay');
-const weeklyChores = require('./services/weeklyChores');
+const anyDayChores = require('./services/anyDayChores');
 const choreExpiry = require('./utils/choreExpiry');
 const cron = require('node-cron');
 // For widget upload and registry
@@ -261,8 +261,8 @@ const SYSTEM_SCHEMA_ID_KEY = 'SYSTEM_SCHEMA_ID';
 
 const schemaMigrations = require('./migrations/registry');
 
-// 'weekly': once a week, any day (services/weeklyChores.js).
-const ALLOWED_SCHEDULE_DURATIONS = new Set(['day-of', 'until-completed', 'once-completed', 'weekly']);
+// 'any-day': once in a period, any day of it (services/anyDayChores.js).
+const ALLOWED_SCHEDULE_DURATIONS = new Set(['day-of', 'until-completed', 'once-completed', 'any-day']);
 const SCHEDULE_INTERVAL_REGEX = /^([1-9]\d*)([dwmy])$/;
 
 // Fisher-Yates in-place shuffle. Mutates and returns the array.
@@ -2312,15 +2312,16 @@ async function applySchemaMigrations(currentSchemaId) {
   }
 }
 
-// Sticky schedules (until-completed, once-completed, weekly) are never shown
+// Sticky schedules (until-completed, once-completed, any-day) are never shown
 // on the dashboard themselves: on a day one fires it gets a visible one-time
 // child, and that is what appears and is completed. This creates today's
 // child for each sticky parent that fires on `today` and has no open child
 // yet, and returns the children it created.
 //
-// A weekly parent "fires" on any day of a week that isn't done yet, so one
-// set up mid-week shows at once, and one done on Wednesday doesn't come back
-// until Sunday. Its child is due by the week's Saturday.
+// An any-day parent "fires" on any day of a period that isn't done yet, so
+// one set up mid-week shows at once, and a weekly one done on Wednesday
+// doesn't come back until Sunday. Its child is due by the period's last day
+// (services/anyDayChores.js).
 //
 // The nightly job runs it for every schedule. Creating or editing a schedule
 // runs it for that one (`scheduleIds`), so a chore set up during the day
@@ -2337,7 +2338,7 @@ function spawnStickyChildren(today, scheduleIds = null) {
            cs.expire_minutes
     FROM chore_schedules cs
     WHERE cs.crontab IS NOT NULL
-      AND cs.duration IN ('until-completed', 'once-completed', 'weekly')
+      AND cs.duration IN ('until-completed', 'once-completed', 'any-day')
       AND cs.visible = 1
       ${onlyThese}
       AND NOT EXISTS (
@@ -2358,9 +2359,9 @@ function spawnStickyChildren(today, scheduleIds = null) {
       )
   `).all(...(Array.isArray(scheduleIds) ? scheduleIds : []));
 
-  // Done this week: a completion by this weekly parent's chore, for its
-  // person. Pruned cards' rows are moved to the parent (pruneDoneChildren).
-  const doneThisWeek = db.prepare(`
+  // Done this period: a completion on this any-day parent or one of its
+  // cards. A cleared card's rows are moved to the parent (nightly cleanup).
+  const doneThisPeriod = db.prepare(`
     SELECT 1 FROM chore_history ch
     JOIN chore_schedules s ON s.id = ch.chore_schedule_id
     WHERE (s.id = ? OR s.parent_schedule_id = ?)
@@ -2371,11 +2372,13 @@ function spawnStickyChildren(today, scheduleIds = null) {
 
   const created = [];
   for (const schedule of stickyParentSchedules) {
-    const weekly = schedule.duration === 'weekly';
+    const period = schedule.duration === anyDayChores.ANY_DAY
+      ? anyDayChores.periodOf(today, schedule.interval, schedule.created_at)
+      : null;
     let firesToday;
     try {
-      firesToday = weekly
-        ? !doneThisWeek.get(schedule.id, schedule.id, weeklyChores.weekStartOf(today), today)
+      firesToday = period
+        ? !doneThisPeriod.get(schedule.id, schedule.id, period.start, today)
         : cronFiresOnDate(schedule.crontab, today);
     } catch (parseError) {
       console.warn(`Skipping sticky schedule ${schedule.id} due to invalid crontab: ${schedule.crontab}`);
@@ -2384,8 +2387,8 @@ function spawnStickyChildren(today, scheduleIds = null) {
     if (!firesToday) continue;
 
     const dueDateOffset = calculateDateOffsetDays(schedule.created_at, schedule.due_date);
-    const childDueDate = weekly
-      ? weeklyChores.weekEndOf(today)
+    const childDueDate = period
+      ? period.end
       : dueDateOffset === null
         ? (schedule.due_date || null)
         : addDaysToDateOnly(today, dueDateOffset);
@@ -2465,9 +2468,9 @@ async function dailyBackgroundProcessing() {
     // kind = 'completion' is load-bearing (issue #72): a 'missed' row must not
     // make an UNcompleted one-time chore look completed and get it pruned.
     //
-    // A weekly chore's card goes once its week is over, done or not: the
-    // next week starts fresh, and an undone week was logged as one miss on
-    // its Saturday, above (services/weeklyChores.js).
+    // An any-day chore's card goes once its period is over, done or not: the
+    // next period starts fresh, and an undone one was logged as one miss on
+    // its last day, above (services/anyDayChores.js).
     const schedulesToPrune = db.prepare(`
       SELECT cs.id, cs.chore_id, cs.user_id, cs.parent_schedule_id, c.title
       FROM chore_schedules cs
@@ -2481,7 +2484,7 @@ async function dailyBackgroundProcessing() {
             WHERE ch.chore_schedule_id = cs.id
               AND ch.kind = 'completion'
           )
-          OR (ps.duration = 'weekly' AND cs.due_date IS NOT NULL AND cs.due_date < ?)
+          OR (ps.duration = 'any-day' AND cs.due_date IS NOT NULL AND cs.due_date < ?)
         )
     `).all(today);
     console.log(`Found ${schedulesToPrune.length} completed one-time chores to prune`);
@@ -3170,7 +3173,8 @@ fastify.get('/api/chore-schedules', async (request, reply) => {
     // "after Run the dishwasher" caption in the widget (issue #241).
     // routine_id: a schedule of a routine's chore (see /api/routines/today).
     // parent_duration: a sticky chore's card says what its schedule is, so
-    // the widget can tell a weekly chore's card (due its Saturday) apart.
+    // the widget can tell an any-day chore's card (due its period's last
+    // day) apart.
     let query = 'SELECT cs.*, c.title, c.description, c.clam_value, c.icon, tc.title AS followup_of, rt.id AS routine_id, ' +
       'ps.duration AS parent_duration ' +
       'FROM chore_schedules cs JOIN chores c ON cs.chore_id = c.id ' +
@@ -3192,7 +3196,7 @@ fastify.get('/api/chore-schedules', async (request, reply) => {
       conditions.push('cs.visible = ?');
       params.push(1);
       conditions.push('(cs.duration IS NULL OR cs.duration NOT IN (?, ?, ?))');
-      params.push(...weeklyChores.STICKY_DURATIONS);
+      params.push(...anyDayChores.STICKY_DURATIONS);
     }
     if (chore_id !== undefined) {
       conditions.push('cs.chore_id = ?');
@@ -3256,9 +3260,11 @@ function resolveScheduleUsers(body) {
 }
 
 fastify.post('/api/chore-schedules', async (request, reply) => {
-  const { chore_id, duration, visible, interval, parent_schedule_id, due_time, sound, sound_enabled, reminder_interval_minutes, due_date, transferable, can_snooze, snoozed_until } = request.body;
-  // A weekly chore's crontab only marks the week start (services/weeklyChores.js).
-  const crontab = duration === 'weekly' ? weeklyChores.WEEKLY_CRONTAB : request.body.crontab;
+  const { chore_id, visible, parent_schedule_id, due_time, sound, sound_enabled, reminder_interval_minutes, due_date, transferable, can_snooze, snoozed_until } = request.body;
+  // 'weekly', and an any-day chore with no period, are any-day every week;
+  // an any-day chore's days mean nothing (services/anyDayChores.js).
+  const { duration, interval } = anyDayChores.normalizeAnyDay(request.body.duration, request.body.interval);
+  const crontab = duration === anyDayChores.ANY_DAY ? anyDayChores.ANY_DAY_CRONTAB : request.body.crontab;
   try {
     if (!chore_id) {
       return reply.status(400).send({ error: 'chore_id is required' });
@@ -3288,8 +3294,12 @@ fastify.post('/api/chore-schedules', async (request, reply) => {
       if (!isValidScheduleInterval(normalizedInterval)) {
         return reply.status(400).send({ error: 'once-completed schedules require a valid interval like 30d, 3w, 2m, or 1y' });
       }
+    } else if (normalizedDuration === anyDayChores.ANY_DAY) {
+      if (!anyDayChores.isPeriod(normalizedInterval)) {
+        return reply.status(400).send({ error: `any-day schedules need a period: ${anyDayChores.PERIODS.join(', ')}` });
+      }
     } else if (normalizedInterval !== null) {
-      return reply.status(400).send({ error: 'interval is only allowed for once-completed schedules' });
+      return reply.status(400).send({ error: 'interval is only allowed for once-completed and any-day schedules' });
     }
 
     if (crontab) {
@@ -3327,7 +3337,7 @@ fastify.post('/api/chore-schedules', async (request, reply) => {
       crontab || null,
       normalizedDuration,
       visible !== undefined ? visible : 1,
-      normalizedDuration === 'once-completed' ? normalizedInterval : null,
+      ['once-completed', anyDayChores.ANY_DAY].includes(normalizedDuration) ? normalizedInterval : null,
       normalizedParentScheduleId,
       dueTimeResult.value,
       sound || null,
@@ -3390,8 +3400,13 @@ fastify.patch('/api/chore-schedules/:id', async (request, reply) => {
   const scheduleChore = db.prepare('SELECT chore_id FROM chore_schedules WHERE id = ?').get(id);
   const owner = scheduleChore && routineOwning(scheduleChore.chore_id);
   if (owner && ROUTINE_SCHEDULE_FIELDS.some((field) => request.body?.[field] !== undefined)) return refuseRoutineEdit(reply, owner);
-  const { chore_id, user_id, duration, visible, interval, parent_schedule_id, due_time, sound, sound_enabled, reminder_interval_minutes, due_date, transferable, can_snooze, snoozed_until, revoke_daily_bonus, transfer_bonus_clams, expire_minutes } = request.body;
-  let { crontab } = request.body;
+  const { chore_id, user_id, visible, parent_schedule_id, due_time, sound, sound_enabled, reminder_interval_minutes, due_date, transferable, can_snooze, snoozed_until, revoke_daily_bonus, transfer_bonus_clams, expire_minutes } = request.body;
+  let { crontab, duration, interval } = request.body;
+  // 'weekly' is an any-day chore every week (services/anyDayChores.js).
+  if (duration === 'weekly') {
+    duration = anyDayChores.ANY_DAY;
+    if (interval === undefined) interval = anyDayChores.DEFAULT_PERIOD;
+  }
   try {
     const dueTimeResult = normalizeDueTime(due_time);
     if (due_time !== undefined && !dueTimeResult.valid) {
@@ -3425,7 +3440,7 @@ fastify.patch('/api/chore-schedules/:id', async (request, reply) => {
       }
     }
 
-    const existingSchedule = db.prepare('SELECT id, user_id, crontab, duration, interval, snoozed_until, due_time, expire_minutes FROM chore_schedules WHERE id = ?').get(id);
+    const existingSchedule = db.prepare('SELECT id, user_id, crontab, duration, interval, snoozed_until, due_time, expire_minutes, created_at FROM chore_schedules WHERE id = ?').get(id);
     if (!existingSchedule) {
       return reply.status(404).send({ error: 'Schedule not found' });
     }
@@ -3446,8 +3461,14 @@ fastify.patch('/api/chore-schedules/:id', async (request, reply) => {
       return reply.status(400).send({ error: `Invalid duration. Expected one of: ${Array.from(ALLOWED_SCHEDULE_DURATIONS).join(', ')}` });
     }
 
-    // A weekly chore's crontab only marks the week start (services/weeklyChores.js).
-    if (nextDuration === 'weekly') crontab = weeklyChores.WEEKLY_CRONTAB;
+    // An any-day chore's days mean nothing; made one without a period (or
+    // from "again after done", whose interval may not be one), it's weekly.
+    if (nextDuration === anyDayChores.ANY_DAY) {
+      crontab = anyDayChores.ANY_DAY_CRONTAB;
+      if (interval === undefined && !anyDayChores.isPeriod(normalizeScheduleInterval(existingSchedule.interval))) {
+        interval = anyDayChores.DEFAULT_PERIOD;
+      }
+    }
     const nextCrontab = crontab !== undefined ? (crontab || null) : existingSchedule.crontab;
     const nextInterval = normalizeScheduleInterval(interval !== undefined ? interval : existingSchedule.interval);
     if (nextDuration === 'once-completed') {
@@ -3457,8 +3478,12 @@ fastify.patch('/api/chore-schedules/:id', async (request, reply) => {
       if (!isValidScheduleInterval(nextInterval)) {
         return reply.status(400).send({ error: 'once-completed schedules require a valid interval like 30d, 3w, 2m, or 1y' });
       }
+    } else if (nextDuration === anyDayChores.ANY_DAY) {
+      if (!anyDayChores.isPeriod(nextInterval)) {
+        return reply.status(400).send({ error: `any-day schedules need a period: ${anyDayChores.PERIODS.join(', ')}` });
+      }
     } else if (interval !== undefined && nextInterval !== null) {
-      return reply.status(400).send({ error: 'interval is only allowed for once-completed schedules' });
+      return reply.status(400).send({ error: 'interval is only allowed for once-completed and any-day schedules' });
     }
 
     const updates = [];
@@ -3470,7 +3495,7 @@ fastify.patch('/api/chore-schedules/:id', async (request, reply) => {
     if (duration !== undefined) { updates.push('duration = ?'); params.push(nextDuration); }
     if (interval !== undefined || duration !== undefined) {
       updates.push('interval = ?');
-      params.push(nextDuration === 'once-completed' ? nextInterval : null);
+      params.push(['once-completed', anyDayChores.ANY_DAY].includes(nextDuration) ? nextInterval : null);
     }
     if (parent_schedule_id !== undefined) {
       if (parent_schedule_id === null || parent_schedule_id === '') {
@@ -3552,19 +3577,23 @@ fastify.patch('/api/chore-schedules/:id', async (request, reply) => {
       awardDailyBonusesAfterRemoval([assigneeId]);
     }
 
-    // Made weekly: a card it already has open is this week's, due Saturday.
-    if (duration !== undefined && nextDuration === 'weekly' && existingSchedule.duration !== 'weekly') {
+    // Made any-day, or given another period: a card it already has open is
+    // this period's, due on its last day.
+    const periodChanged = nextDuration === anyDayChores.ANY_DAY
+      && (existingSchedule.duration !== anyDayChores.ANY_DAY || nextInterval !== normalizeScheduleInterval(existingSchedule.interval));
+    if ((duration !== undefined || interval !== undefined) && periodChanged) {
+      const { end } = anyDayChores.periodOf(getTodayLocalDateString(), nextInterval, existingSchedule.created_at);
       db.prepare(`
         UPDATE chore_schedules SET due_date = ?
         WHERE parent_schedule_id = ? AND crontab IS NULL
           AND NOT EXISTS (SELECT 1 FROM chore_history h WHERE h.chore_schedule_id = chore_schedules.id AND h.kind = 'completion')
-      `).run(weeklyChores.weekEndOf(getTodayLocalDateString()), id);
+      `).run(end, id);
     }
 
     // Made sticky, given a new timing, or shown again: if it now fires
     // today, today's chore appears at once (issue #256). An open child
     // already there is left as it is.
-    if (crontab !== undefined || duration !== undefined || visible !== undefined) {
+    if (crontab !== undefined || duration !== undefined || interval !== undefined || visible !== undefined) {
       spawnStickyChildren(getTodayLocalDateString(), [Number(id)]);
     }
 
@@ -3782,7 +3811,7 @@ function getTodaysRegularChoresForUser(userId, dateStr, referenceNow = new Date(
       AND cs.visible = 1
       AND NOT (
         cs.crontab IS NOT NULL
-        AND cs.duration IN ('until-completed', 'once-completed', 'weekly')
+        AND cs.duration IN ('until-completed', 'once-completed', 'any-day')
       )
   `).all(dateStr, userId);
 
@@ -3803,9 +3832,9 @@ function getTodaysRegularChoresForUser(userId, dateStr, referenceNow = new Date(
       continue;
     }
 
-    // A weekly chore's card is due on the week's last day only: until then it
-    // holds back no bonus and logs no miss (services/weeklyChores.js).
-    if (schedule.parent_duration === 'weekly' && !weeklyChores.weeklyChildDueOn(schedule, dateStr)) {
+    // An any-day chore's card is due on its period's last day only: until
+    // then it holds back no bonus and logs no miss (services/anyDayChores.js).
+    if (schedule.parent_duration === anyDayChores.ANY_DAY && !anyDayChores.anyDayChildDueOn(schedule, dateStr)) {
       continue;
     }
 
diff --git a/server/migrations/registry.js b/server/migrations/registry.js
index bff58521..23196c16 100644
--- a/server/migrations/registry.js
+++ b/server/migrations/registry.js
@@ -38,4 +38,5 @@ module.exports = [
   { schemaId: 35, migrationPath: './migrations/schema35-proxyWhitelistSeed', },
   { schemaId: 36, migrationPath: './migrations/schema36-prizeDescription', },
   { schemaId: 37, migrationPath: './migrations/schema37-photoDetails', },
+  { schemaId: 38, migrationPath: './migrations/schema38-anyDayChores', },
 ];
diff --git a/server/migrations/schema38-anyDayChores.js b/server/migrations/schema38-anyDayChores.js
new file mode 100644
index 00000000..f2093021
--- /dev/null
+++ b/server/migrations/schema38-anyDayChores.js
@@ -0,0 +1,35 @@
+const context = globalThis.__HOMEGLOW_SCHEMA_MIGRATION_CONTEXT;
+
+if (!context || !context.db) {
+    throw new Error('Schema migration context is missing for migration');
+}
+
+const { db, schemaIdKey, targetSchemaId } = context;
+
+try {
+    console.log(`=== Starting any-day chores schema migration to version ${targetSchemaId} ===`);
+
+    db.exec('BEGIN');
+    try {
+        // "Once a week, any day" (duration 'weekly', #362) becomes one of the
+        // any-day chores, whose period is the schedule's interval
+        // (services/anyDayChores.js): 'weekly' is 'any-day' every '1w'. Its
+        // cards keep their dates. Replaying this changes nothing.
+        db.prepare("UPDATE chore_schedules SET duration = 'any-day', interval = '1w' WHERE duration = 'weekly'").run();
+
+        db.prepare('INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)').run(
+            schemaIdKey,
+            String(targetSchemaId)
+        );
+
+        db.exec('COMMIT');
+        console.log(`=== Any-day chores schema migration completed (version ${targetSchemaId}) ===`);
+    } catch (migrationError) {
+        db.exec('ROLLBACK');
+        throw migrationError;
+    }
+} catch (error) {
+    console.error('=== Any-day chores schema migration failed ===');
+    console.error('Error:', error);
+    throw error;
+}
diff --git a/server/services/anyDayChores.js b/server/services/anyDayChores.js
new file mode 100644
index 00000000..0b17aad7
--- /dev/null
+++ b/server/services/anyDayChores.js
@@ -0,0 +1,94 @@
+// "Any day" chores (schedule duration 'any-day'): done once, on any day of a
+// period, and fresh each period. Practise an instrument once a week; change
+// the furnace filter once every 3 months. The period is the schedule's
+// `interval`, one of PERIODS:
+//   1w      Sunday to Saturday, as the admin board's calendar
+//   2w      two weeks, counted from the week the schedule was made
+//   1m      a calendar month
+//   3m, 6m  calendar quarters (Jan-Mar, ...) and halves (Jan-Jun, Jul-Dec)
+//   1y      a calendar year
+//
+// Like the other sticky schedules, the parent never shows itself: its visible
+// one-time child is what appears and is completed. The child's due_date is
+// the period's last day, and that is the only day it counts as due: it holds
+// back the daily bonus on that day alone, and an undone period is logged as
+// one miss, that day. When the next period starts, the old card goes and a
+// fresh one comes, whether or not it was done.
+
+const ANY_DAY = 'any-day';
+const PERIODS = ['1w', '2w', '1m', '3m', '6m', '1y'];
+const DEFAULT_PERIOD = '1w';
+// The days mean nothing for an any-day chore; the server keeps this.
+const ANY_DAY_CRONTAB = '0 0 * * *';
+
+const STICKY_DURATIONS = ['until-completed', 'once-completed', ANY_DAY];
+
+const parseDay = (dateStr) => {
+  const [y, m, d] = String(dateStr).slice(0, 10).split('-').map(Number);
+  return new Date(Date.UTC(y, m - 1, d));
+};
+const formatDay = (date) => date.toISOString().slice(0, 10);
+const addDays = (dateStr, days) => {
+  const date = parseDay(dateStr);
+  date.setUTCDate(date.getUTCDate() + days);
+  return formatDay(date);
+};
+
+// The Sunday and the Saturday of the week `dateStr` ('YYYY-MM-DD') is in.
+const weekStartOf = (dateStr) => addDays(dateStr, -parseDay(dateStr).getUTCDay());
+const weekEndOf = (dateStr) => addDays(weekStartOf(dateStr), 6);
+
+const isPeriod = (interval) => PERIODS.includes(interval);
+
+/**
+ * The period `dateStr` falls in, as { start, end } ('YYYY-MM-DD', inclusive).
+ * `anchor` is the day the schedule was made; only 2-week periods use it, so
+ * they run from that week.
+ */
+function periodOf(dateStr, interval = DEFAULT_PERIOD, anchor = null) {
+  const match = String(isPeriod(interval) ? interval : DEFAULT_PERIOD).match(/^(\d+)([wmy])$/);
+  const count = Number(match[1]);
+  const unit = match[2];
+  if (unit === 'w') {
+    const start = weekStartOf(dateStr);
+    if (count === 1) return { start, end: addDays(start, 6) };
+    const from = weekStartOf(anchor || dateStr);
+    const weeks = Math.floor((parseDay(start) - parseDay(from)) / (7 * 86400000));
+    const blockStart = addDays(from, (Math.floor(weeks / count) * count) * 7);
+    return { start: blockStart, end: addDays(blockStart, count * 7 - 1) };
+  }
+  const months = unit === 'y' ? count * 12 : count;
+  const date = parseDay(dateStr);
+  const index = date.getUTCFullYear() * 12 + date.getUTCMonth();
+  const first = Math.floor(index / months) * months;
+  const start = new Date(Date.UTC(Math.floor(first / 12), first % 12, 1));
+  const end = new Date(Date.UTC(Math.floor((first + months) / 12), (first + months) % 12, 0));
+  return { start: formatDay(start), end: formatDay(end) };
+}
+
+// Whether an any-day chore's card counts as due on `dateStr`: on its last
+// day only. A card without a date counts every day, as any one-time chore.
+const anyDayChildDueOn = (child, dateStr) => !child.due_date || child.due_date === dateStr;
+
+// What a request's duration and interval mean: 'weekly' (the name this had
+// for a day) is an any-day chore once a week; an any-day chore without a
+// period is weekly. Other durations pass through.
+function normalizeAnyDay(duration, interval) {
+  if (duration === 'weekly') return { duration: ANY_DAY, interval: DEFAULT_PERIOD };
+  if (duration === ANY_DAY) return { duration, interval: interval || DEFAULT_PERIOD };
+  return { duration, interval };
+}
+
+module.exports = {
+  ANY_DAY,
+  PERIODS,
+  DEFAULT_PERIOD,
+  ANY_DAY_CRONTAB,
+  STICKY_DURATIONS,
+  weekStartOf,
+  weekEndOf,
+  isPeriod,
+  periodOf,
+  anyDayChildDueOn,
+  normalizeAnyDay,
+};
diff --git a/server/services/weeklyChores.js b/server/services/weeklyChores.js
deleted file mode 100644
index 461f6094..00000000
--- a/server/services/weeklyChores.js
+++ /dev/null
@@ -1,43 +0,0 @@
-// "Once a week, any day" chores (schedule duration 'weekly'): practise an
-// instrument once a week, whichever day suits. The week runs Sunday to
-// Saturday, as the admin board's calendar does.
-//
-// Like the other sticky schedules, the parent never shows itself: its visible
-// one-time child is what appears and is completed. The child's due_date is
-// the week's Saturday, and that is the only day it counts as due: it holds
-// back the daily bonus on Saturday alone, and an undone week is logged as one
-// miss, that Saturday. The next Sunday the old card goes and a fresh one
-// comes, whether or not it was done.
-
-// Only marks the week start; the days mean nothing for a weekly chore.
-const WEEKLY_CRONTAB = '0 0 * * 0';
-
-const STICKY_DURATIONS = ['until-completed', 'once-completed', 'weekly'];
-
-const parseDay = (dateStr) => {
-  const [y, m, d] = String(dateStr).split('-').map(Number);
-  return new Date(Date.UTC(y, m - 1, d));
-};
-const formatDay = (date) => date.toISOString().slice(0, 10);
-const addDays = (dateStr, days) => {
-  const date = parseDay(dateStr);
-  date.setUTCDate(date.getUTCDate() + days);
-  return formatDay(date);
-};
-
-// The Sunday and the Saturday of the week `dateStr` ('YYYY-MM-DD') is in.
-const weekStartOf = (dateStr) => addDays(dateStr, -parseDay(dateStr).getUTCDay());
-const weekEndOf = (dateStr) => addDays(weekStartOf(dateStr), 6);
-
-// Whether a weekly chore's card counts as due on `dateStr`: on its last day
-// only. A card without a date (made before this rule) counts every day, as
-// any one-time chore does.
-const weeklyChildDueOn = (child, dateStr) => !child.due_date || child.due_date === dateStr;
-
-module.exports = {
-  WEEKLY_CRONTAB,
-  STICKY_DURATIONS,
-  weekStartOf,
-  weekEndOf,
-  weeklyChildDueOn,
-};
diff --git a/server/tests/weeklyChores.test.js b/server/tests/anyDayChores.test.js
similarity index 56%
rename from server/tests/weeklyChores.test.js
rename to server/tests/anyDayChores.test.js
index 8f10a25e..db2fc58c 100644
--- a/server/tests/weeklyChores.test.js
+++ b/server/tests/anyDayChores.test.js
@@ -1,6 +1,6 @@
-// "Once a week, any day" chores, end to end: a real HomeGlow server on a
-// throwaway database. The server runs in UTC on today's date, so a past week
-// is made by moving a card's due date back, as the nightly job would find it.
+// "Any day" chores, end to end: a real HomeGlow server on a throwaway
+// database. The server runs in UTC on today's date, so a past period is made
+// by moving a card's due date back, as the nightly job would find it.
 const test = require('node:test');
 const assert = require('node:assert/strict');
 const { spawn } = require('node:child_process');
@@ -8,11 +8,11 @@ const fs = require('node:fs');
 const path = require('node:path');
 const Database = require('better-sqlite3');
 const { freePort } = require('./freePort');
-const { weekEndOf } = require('../services/weeklyChores');
+const { periodOf } = require('../services/anyDayChores');
 
 const serverDir = path.resolve(__dirname, '..');
 const tmpDir = path.resolve(__dirname, '.tmp');
-const testDbPath = path.join(tmpDir, `weekly-${process.pid}-${Date.now()}.db`);
+const testDbPath = path.join(tmpDir, `any-day-${process.pid}-${Date.now()}.db`);
 const keepTestArtifacts = process.env.HOMEGLOW_TEST_KEEP_ARTIFACTS === '1';
 let baseUrl;
 let serverProcess;
@@ -34,10 +34,9 @@ const patch = (p, body) => api(p, { method: 'PATCH', body: JSON.stringify(body)
 const shift = (days) => new Date(Date.now() + days * 86400000).toISOString().slice(0, 10);
 const today = shift(0);
 const yesterday = shift(-1);
-const saturday = weekEndOf(today);
+const saturday = periodOf(today, '1w').end;
 
-test.before(async () => {
-  fs.mkdirSync(tmpDir, { recursive: true });
+async function startServer() {
   const port = await freePort();
   baseUrl = `http://127.0.0.1:${port}`;
   serverProcess = spawn(process.execPath, ['index.js'], {
@@ -57,15 +56,21 @@ test.before(async () => {
     await delay(250);
   }
   throw new Error('server did not start');
+}
+const stopServer = () => new Promise((resolve) => {
+  if (!serverProcess || serverProcess.exitCode !== null) return resolve();
+  serverProcess.once('close', resolve);
+  serverProcess.kill();
+  setTimeout(resolve, 5000);
+});
+
+test.before(async () => {
+  fs.mkdirSync(tmpDir, { recursive: true });
+  await startServer();
 });
 
 test.after(async () => {
-  await new Promise((resolve) => {
-    if (!serverProcess || serverProcess.exitCode !== null) return resolve();
-    serverProcess.once('close', resolve);
-    serverProcess.kill();
-    setTimeout(resolve, 5000);
-  });
+  await stopServer();
   if (process.exitCode && serverLogs) console.error(serverLogs.slice(-4000));
   if (!keepTestArtifacts) {
     for (const suffix of ['', '-wal', '-shm']) fs.rmSync(`${testDbPath}${suffix}`, { force: true });
@@ -80,13 +85,12 @@ async function person() {
 async function chore(title) {
   return (await post('/api/chores', { title, clam_value: 0 })).body.id;
 }
-async function weekly(userId, title = 'Practice piano') {
+async function anyDay(userId, interval = '1w', title = 'Practice piano') {
   const choreId = await chore(title);
-  const res = await post('/api/chore-schedules', { chore_id: choreId, user_id: userId, crontab: '0 0 * * 3', duration: 'weekly' });
+  const res = await post('/api/chore-schedules', { chore_id: choreId, user_id: userId, crontab: '0 0 * * 3', duration: 'any-day', interval });
   assert.equal(res.status, 200, JSON.stringify(res.body));
   return { choreId, parentId: res.body.id };
 }
-// The person's weekly card: the visible child of the parent.
 async function cardsOf(parentId) {
   return (await api('/api/chore-schedules')).body.filter((s) => s.parent_schedule_id === parentId);
 }
@@ -97,85 +101,122 @@ const withDb = (work) => {
   try { return work(db); } finally { db.close(); }
 };
 
-test('made weekly, it shows at once, due by this week\'s Saturday', async () => {
+test("once a week: it shows at once, due by this week's Saturday", async () => {
   const kid = await person();
-  const { parentId } = await weekly(kid);
+  const { parentId } = await anyDay(kid);
   const parent = (await api(`/api/chore-schedules/${parentId}`)).body;
-  assert.equal(parent.crontab, '0 0 * * 0', 'the days mean nothing: it only marks the week start');
-  assert.equal(parent.interval, null);
+  assert.equal(parent.duration, 'any-day');
+  assert.equal(parent.interval, '1w');
+  assert.equal(parent.crontab, '0 0 * * *', 'its days mean nothing');
 
   const cards = await cardsOf(parentId);
   assert.equal(cards.length, 1);
   assert.equal(cards[0].due_date, saturday);
-  assert.equal(cards[0].crontab, null);
-  assert.equal(cards[0].parent_duration, 'weekly');
-  // The dashboard's list leaves the parent out, as with the other sticky ones.
+  assert.equal(cards[0].parent_duration, 'any-day');
   const chart = (await api(`/api/chore-schedules?usage=chart&user_id=${kid}`)).body;
-  assert.deepEqual(chart.map((s) => s.id), [cards[0].id]);
+  assert.deepEqual(chart.map((s) => s.id), [cards[0].id], 'the dashboard list leaves the parent out');
+});
+
+test('longer periods are due on their last day: a month, a quarter, a year', async () => {
+  const kid = await person();
+  for (const interval of ['1m', '3m', '6m', '1y']) {
+    const { parentId } = await anyDay(kid, interval, `Every ${interval}`);
+    const [card] = await cardsOf(parentId);
+    assert.equal(card.due_date, periodOf(today, interval).end, interval);
+  }
+  const twoWeeks = await anyDay(kid, '2w', 'Fortnightly');
+  assert.equal((await cardsOf(twoWeeks.parentId))[0].due_date, periodOf(today, '2w', today).end);
+});
+
+test('"weekly" still works, and a period must be one of the list', async () => {
+  const kid = await person();
+  const choreId = await chore('Old weekly');
+  const res = await post('/api/chore-schedules', { chore_id: choreId, user_id: kid, duration: 'weekly' });
+  assert.equal(res.status, 200, JSON.stringify(res.body));
+  const parent = (await api(`/api/chore-schedules/${res.body.id}`)).body;
+  assert.equal(parent.duration, 'any-day');
+  assert.equal(parent.interval, '1w');
+  assert.equal((await post('/api/chore-schedules', { chore_id: choreId, user_id: kid, duration: 'any-day', interval: '5d' })).status, 400);
+  assert.equal((await patch(`/api/chore-schedules/${res.body.id}`, { interval: '3d' })).status, 400);
 });
 
-test('it holds back the daily bonus on its Saturday only', async () => {
+test('it holds back the daily bonus on its last day only', async () => {
   const kid = await person();
-  await weekly(kid);
+  await anyDay(kid);
   const dishesId = await chore('Dishes');
   const dishes = (await post('/api/chore-schedules', { chore_id: dishesId, user_id: kid, crontab: '0 0 * * *', duration: 'day-of' })).body.id;
   const done = await post('/api/chores/complete', { chore_schedule_id: dishes, user_id: kid, date: today });
   assert.equal(done.status, 200, JSON.stringify(done.body));
   const bonus = (await historyOf(kid)).some((r) => r.kind === 'daily_bonus' && r.date === today);
-  assert.equal(bonus, today !== saturday, today === saturday ? 'Saturday: the open weekly chore is needed' : 'before Saturday it is not');
+  assert.equal(bonus, today !== saturday, today === saturday ? 'its last day: the open chore is needed' : 'before its last day it is not');
 });
 
-test('done, it stays away until Sunday, and its history stays with the chore', async () => {
+test('done, it stays away until the next period, and its history stays with the chore', async () => {
   const kid = await person();
-  const { choreId, parentId } = await weekly(kid);
+  const { choreId, parentId } = await anyDay(kid, '1m');
   const [card] = await cardsOf(parentId);
   assert.equal((await post('/api/chores/complete', { chore_schedule_id: card.id, user_id: kid, date: today })).status, 200);
 
   await nightly();
   assert.equal((await api(`/api/chore-schedules/${card.id}`)).status, 404, 'the done card is cleared');
-  assert.deepEqual(await cardsOf(parentId), [], 'no new card while this week is done');
+  assert.deepEqual(await cardsOf(parentId), [], 'no new card while this month is done');
   const completion = (await historyOf(kid)).find((r) => r.kind === 'completion' && r.date === today);
   assert.equal(completion.chore_schedule_id, parentId, 'moved to the schedule it came from');
   assert.equal(completion.chore_id, choreId, 'so it still names its chore');
 });
 
-test('an undone week is one miss, then a fresh card', async () => {
+test('an undone period is one miss, then a fresh card', async () => {
   const kid = await person();
-  const { parentId } = await weekly(kid);
+  const { parentId } = await anyDay(kid);
   const [card] = await cardsOf(parentId);
 
-  // Before its Saturday it logs no miss.
   await nightly();
-  assert.equal((await historyOf(kid)).filter((r) => r.kind === 'missed').length, 0);
+  assert.equal((await historyOf(kid)).filter((r) => r.kind === 'missed').length, 0, 'no miss before its last day');
   assert.equal((await cardsOf(parentId)).length, 1, 'still the one card');
 
-  // Last week's card, as the job finds it on Sunday.
+  // Last period's card, as the job finds it the morning after.
   withDb((db) => db.prepare('UPDATE chore_schedules SET due_date = ? WHERE id = ?').run(yesterday, card.id));
   await nightly();
   const misses = (await historyOf(kid)).filter((r) => r.kind === 'missed');
-  assert.equal(misses.length, 1, 'one miss for the week');
+  assert.equal(misses.length, 1, 'one miss for the period');
   assert.equal(misses[0].date, yesterday);
-  assert.equal((await api(`/api/chore-schedules/${card.id}`)).status, 404, 'last week\'s card is gone');
+  assert.equal((await api(`/api/chore-schedules/${card.id}`)).status, 404, "last period's card is gone");
   const fresh = await cardsOf(parentId);
-  assert.equal(fresh.length, 1, 'a fresh card for this week');
+  assert.equal(fresh.length, 1, 'a fresh card for this period');
   assert.equal(fresh[0].due_date, saturday);
 
   await nightly();
   assert.equal((await historyOf(kid)).filter((r) => r.kind === 'missed').length, 1, 'no second miss');
 });
 
-test('a "stays until done" chore made weekly gives its open card this week\'s Saturday', async () => {
+test('made any-day, or given another period, its open card takes the new last day', async () => {
   const kid = await person();
   const choreId = await chore('Tidy desk');
   const parentId = (await post('/api/chore-schedules', { chore_id: choreId, user_id: kid, crontab: '0 0 * * *', duration: 'until-completed' })).body.id;
   const [open] = await cardsOf(parentId);
   assert.equal(open.due_date, null);
 
-  const res = await patch(`/api/chore-schedules/${parentId}`, { duration: 'weekly' });
-  assert.equal(res.status, 200, JSON.stringify(res.body));
-  const after = await cardsOf(parentId);
-  assert.equal(after.length, 1, 'the same card, not a second one');
-  assert.equal(after[0].id, open.id);
-  assert.equal(after[0].due_date, saturday);
-  assert.equal((await api(`/api/chore-schedules/${parentId}`)).body.crontab, '0 0 * * 0');
+  assert.equal((await patch(`/api/chore-schedules/${parentId}`, { duration: 'any-day' })).status, 200);
+  let after = await cardsOf(parentId);
+  assert.deepEqual(after.map((c) => [c.id, c.due_date]), [[open.id, saturday]], 'the same card, now due Saturday');
+  assert.equal((await api(`/api/chore-schedules/${parentId}`)).body.interval, '1w');
+
+  assert.equal((await patch(`/api/chore-schedules/${parentId}`, { interval: '1m' })).status, 200);
+  after = await cardsOf(parentId);
+  assert.deepEqual(after.map((c) => [c.id, c.due_date]), [[open.id, periodOf(today, '1m').end]]);
+});
+
+test('migration 38 turns "weekly" schedules into any-day ones', async () => {
+  const kid = await person();
+  const choreId = await chore('Planted weekly');
+  await stopServer();
+  const id = withDb((db) => {
+    db.prepare("UPDATE settings SET value = '37' WHERE key = 'SYSTEM_SCHEMA_ID'").run();
+    return db.prepare("INSERT INTO chore_schedules (chore_id, user_id, crontab, duration, visible) VALUES (?, ?, '0 0 * * 0', 'weekly', 1)").run(choreId, kid).lastInsertRowid;
+  });
+  await startServer();
+  const row = (await api(`/api/chore-schedules/${id}`)).body;
+  assert.equal(row.duration, 'any-day');
+  assert.equal(row.interval, '1w');
+  assert.equal(withDb((db) => db.prepare("SELECT value FROM settings WHERE key = 'SYSTEM_SCHEMA_ID'").get().value), '38');
 });
diff --git a/server/tests/anyDayChoresRules.test.js b/server/tests/anyDayChoresRules.test.js
new file mode 100644
index 00000000..41fc2f98
--- /dev/null
+++ b/server/tests/anyDayChoresRules.test.js
@@ -0,0 +1,48 @@
+// The period rules for "any day" chores (services/anyDayChores.js).
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { weekStartOf, weekEndOf, periodOf, anyDayChildDueOn, normalizeAnyDay, STICKY_DURATIONS } = require('../services/anyDayChores');
+
+test('a week runs Sunday to Saturday, from any day in it', () => {
+  // 2026-11-01 is a Sunday.
+  for (const day of ['2026-11-01', '2026-11-04', '2026-11-07']) {
+    assert.equal(weekStartOf(day), '2026-11-01', day);
+    assert.equal(weekEndOf(day), '2026-11-07', day);
+    assert.deepEqual(periodOf(day, '1w'), { start: '2026-11-01', end: '2026-11-07' });
+  }
+  assert.equal(weekEndOf('2026-12-30'), '2027-01-02');
+  assert.equal(weekStartOf('2027-01-01'), '2026-12-27');
+});
+
+test('two weeks run from the week the schedule was made', () => {
+  const anchor = '2026-11-04'; // its week starts Sunday 2026-11-01
+  assert.deepEqual(periodOf('2026-11-01', '2w', anchor), { start: '2026-11-01', end: '2026-11-14' });
+  assert.deepEqual(periodOf('2026-11-14', '2w', anchor), { start: '2026-11-01', end: '2026-11-14' });
+  assert.deepEqual(periodOf('2026-11-15', '2w', anchor), { start: '2026-11-15', end: '2026-11-28' });
+  assert.deepEqual(periodOf('2026-12-30', '2w', anchor), { start: '2026-12-27', end: '2027-01-09' });
+});
+
+test('months, quarters, halves and years follow the calendar', () => {
+  assert.deepEqual(periodOf('2026-02-10', '1m'), { start: '2026-02-01', end: '2026-02-28' });
+  assert.deepEqual(periodOf('2028-02-10', '1m'), { start: '2028-02-01', end: '2028-02-29' });
+  assert.deepEqual(periodOf('2026-11-30', '3m'), { start: '2026-10-01', end: '2026-12-31' });
+  assert.deepEqual(periodOf('2026-01-01', '3m'), { start: '2026-01-01', end: '2026-03-31' });
+  assert.deepEqual(periodOf('2026-07-15', '6m'), { start: '2026-07-01', end: '2026-12-31' });
+  assert.deepEqual(periodOf('2026-06-30', '6m'), { start: '2026-01-01', end: '2026-06-30' });
+  assert.deepEqual(periodOf('2026-10-31', '1y'), { start: '2026-01-01', end: '2026-12-31' });
+});
+
+test("an any-day chore's card is due on its last day only", () => {
+  const card = { due_date: '2026-11-07' };
+  assert.equal(anyDayChildDueOn(card, '2026-11-02'), false);
+  assert.equal(anyDayChildDueOn(card, '2026-11-07'), true);
+  assert.equal(anyDayChildDueOn({ due_date: null }, '2026-11-02'), true);
+});
+
+test('"weekly" is an any-day chore once a week; any-day defaults to a week', () => {
+  assert.deepEqual(normalizeAnyDay('weekly', null), { duration: 'any-day', interval: '1w' });
+  assert.deepEqual(normalizeAnyDay('any-day', null), { duration: 'any-day', interval: '1w' });
+  assert.deepEqual(normalizeAnyDay('any-day', '3m'), { duration: 'any-day', interval: '3m' });
+  assert.deepEqual(normalizeAnyDay('once-completed', '2w'), { duration: 'once-completed', interval: '2w' });
+  assert.deepEqual(STICKY_DURATIONS, ['until-completed', 'once-completed', 'any-day']);
+});
diff --git a/server/tests/weeklyChoresRules.test.js b/server/tests/weeklyChoresRules.test.js
deleted file mode 100644
index e157341f..00000000
--- a/server/tests/weeklyChoresRules.test.js
+++ /dev/null
@@ -1,29 +0,0 @@
-// The week rules for "once a week, any day" chores (services/weeklyChores.js).
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const { weekStartOf, weekEndOf, weeklyChildDueOn, STICKY_DURATIONS } = require('../services/weeklyChores');
-
-test('a week runs Sunday to Saturday, from any day in it', () => {
-  // 2026-11-01 is a Sunday.
-  for (const day of ['2026-11-01', '2026-11-04', '2026-11-07']) {
-    assert.equal(weekStartOf(day), '2026-11-01', day);
-    assert.equal(weekEndOf(day), '2026-11-07', day);
-  }
-  assert.equal(weekStartOf('2026-11-08'), '2026-11-08');
-  // Across a month and a year.
-  assert.equal(weekEndOf('2026-12-30'), '2027-01-02');
-  assert.equal(weekStartOf('2027-01-01'), '2026-12-27');
-});
-
-test("a weekly chore's card is due on its last day only", () => {
-  const card = { due_date: '2026-11-07' };
-  assert.equal(weeklyChildDueOn(card, '2026-11-02'), false);
-  assert.equal(weeklyChildDueOn(card, '2026-11-06'), false);
-  assert.equal(weeklyChildDueOn(card, '2026-11-07'), true);
-  // Without a date, it counts as any one-time chore does.
-  assert.equal(weeklyChildDueOn({ due_date: null }, '2026-11-02'), true);
-});
-
-test('weekly is one of the sticky durations', () => {
-  assert.deepEqual(STICKY_DURATIONS, ['until-completed', 'once-completed', 'weekly']);
-});