@robbeverhelst/do 1.342.0 → 1.344.0

package/dist/do.js

@@ -971,7 +971,9 @@ var GLOBAL_BOOLEAN_FLAGS = [
   "allow-destructive",
   "dry-run",
   "draft",
-  "no-year"
+  "no-year",
+  "after-done",
+  "no-repeat"
 ];
 var SHORT_ALIASES = {
   h: "help",
@@ -14418,7 +14420,7 @@ var configError = (message) => new CliError("config", message, EXIT.CONFIG);
 
 // src/meta.ts
 var CLI_NAME = "do";
-var VERSION = "1.342.0";
+var VERSION = "1.344.0";
 var API_PREFIX = "/api/v1";
 var DEFAULT_API_URL = "http://localhost:3001";
 
@@ -17982,9 +17984,13 @@ var tasks = pgTable("tasks", {
   readyAt: timestamp("ready_at", { withTimezone: true }),
   readyNote: text("ready_note"),
   moveCount: integer2("move_count").notNull().default(0),
-  movedFrom: timestamp("moved_from", { withTimezone: true })
+  movedFrom: timestamp("moved_from", { withTimezone: true }),
+  seriesId: text("series_id"),
+  seriesLabel: text("series_label"),
+  seriesSlot: date5("series_slot", { mode: "string" })
 }, (t) => [
   index("tasks_tenant_project_idx").on(t.tenantId, t.projectId),
+  uniqueIndex("tasks_series_slot_uniq").on(t.seriesId, t.seriesSlot).where(sql`${t.seriesId} IS NOT NULL`),
   unique("tasks_tenant_number_uniq").on(t.tenantId, t.number),
   index("tasks_tenant_place_idx").on(t.tenantId, t.placeId),
   index("tasks_milestone_idx").on(t.milestoneId),
@@ -18023,11 +18029,13 @@ var habits = pgTable("habits", {
   retiredAt: timestamp("retired_at", { withTimezone: true }),
   eventSourceId: text("event_source_id"),
   eventMatch: text("event_match"),
-  eventOffset: text("event_offset")
+  eventOffset: text("event_offset"),
+  durationMinutes: integer2("duration_minutes")
 }, (t) => [
   index("habits_tenant_idx").on(t.tenantId),
   index("habits_tenant_area_idx").on(t.tenantId, t.areaId),
-  check2("habits_time_of_day_chk", sql`${t.timeOfDay} IS NULL OR ${t.timeOfDay} IN ('morning', 'midday', 'evening') OR ${t.timeOfDay} ~ '^([01][0-9]|2[0-3]):[0-5][0-9]$'`)
+  check2("habits_time_of_day_chk", sql`${t.timeOfDay} IS NULL OR ${t.timeOfDay} IN ('morning', 'midday', 'evening') OR ${t.timeOfDay} ~ '^([01][0-9]|2[0-3]):[0-5][0-9]$'`),
+  check2("habits_duration_minutes_chk", sql`${t.durationMinutes} IS NULL OR ${t.durationMinutes} BETWEEN 1 AND 600`)
 ]);
 var habitEntries = pgTable("habit_entries", {
   id: text("id").primaryKey(),
@@ -18081,7 +18089,7 @@ var occurrences = pgTable("occurrences", {
 
 // ../../packages/schema/src/db/core.ts
 var routineKind = pgEnum("routine_kind", ["sequence", "time_blocked", "checklist"]);
-var routineStepRef = pgEnum("routine_step_ref", ["free", "habit", "task"]);
+var routineStepRef = pgEnum("routine_step_ref", ["free", "habit", "task", "routine"]);
 var projectStatus = pgEnum("project_status", [
   "planning",
   "active",
@@ -18091,6 +18099,12 @@ var projectStatus = pgEnum("project_status", [
 ]);
 var settingsTheme = pgEnum("settings_theme", ["system", "light", "dark"]);
 var settingsDensity = pgEnum("settings_density", ["comfortable", "compact"]);
+var settingsGlass = pgEnum("settings_glass", ["liquid", "frosted", "solid"]);
+var settingsThemePack = pgEnum("settings_theme_pack", ["do", "skyrim", "pokemon"]);
+var settingsThemePackScope = pgEnum("settings_theme_pack_scope", [
+  "section",
+  "everywhere"
+]);
 var settingsAccent = pgEnum("settings_accent", ["teal", "purple", "amber", "rose"]);
 var routineRunStatus = pgEnum("routine_run_status", [
   "in_progress",
@@ -18124,6 +18138,8 @@ var routineSteps = pgTable("routine_steps", {
   refKind: routineStepRef("ref_kind").notNull().default("free"),
   habitId: text("habit_id").references(() => habits.id),
   taskId: text("task_id").references(() => tasks.id),
+  childRoutineId: text("child_routine_id").references(() => routines.id),
+  optional: boolean4("optional").notNull().default(false),
   sortOrder: integer2("sort_order").notNull().default(0),
   durationMinutes: integer2("duration_minutes"),
   notes: text("notes"),
@@ -18131,11 +18147,14 @@ var routineSteps = pgTable("routine_steps", {
 }, (t) => [
   index("routine_steps_routine_order_idx").on(t.routineId, t.sortOrder),
   index("routine_steps_habit_idx").on(t.habitId),
+  index("routine_steps_child_routine_idx").on(t.childRoutineId),
   check2("routine_steps_ref_kind_chk", sql`(
-        (${t.refKind} = 'free'  AND ${t.habitId} IS NULL AND ${t.taskId} IS NULL) OR
-        (${t.refKind} = 'habit' AND ${t.habitId} IS NOT NULL AND ${t.taskId} IS NULL) OR
-        (${t.refKind} = 'task'  AND ${t.taskId} IS NOT NULL AND ${t.habitId} IS NULL)
-      )`)
+        (${t.refKind} = 'free'    AND ${t.habitId} IS NULL AND ${t.taskId} IS NULL AND ${t.childRoutineId} IS NULL) OR
+        (${t.refKind} = 'habit'   AND ${t.habitId} IS NOT NULL AND ${t.taskId} IS NULL AND ${t.childRoutineId} IS NULL) OR
+        (${t.refKind} = 'task'    AND ${t.taskId} IS NOT NULL AND ${t.habitId} IS NULL AND ${t.childRoutineId} IS NULL) OR
+        (${t.refKind} = 'routine' AND ${t.childRoutineId} IS NOT NULL AND ${t.habitId} IS NULL AND ${t.taskId} IS NULL)
+      )`),
+  check2("routine_steps_not_self_chk", sql`${t.childRoutineId} IS NULL OR ${t.childRoutineId} <> ${t.routineId}`)
 ]);
 var routineRuns = pgTable("routine_runs", {
   id: text("id").primaryKey(),
@@ -18155,6 +18174,9 @@ var routineRunSteps = pgTable("routine_run_steps", {
   refKind: routineStepRef("ref_kind").notNull().default("free"),
   habitId: text("habit_id").references(() => habits.id),
   taskId: text("task_id").references(() => tasks.id),
+  childRoutineId: text("child_routine_id").references(() => routines.id),
+  groupStepId: text("group_step_id").references(() => routineRunSteps.id),
+  optional: boolean4("optional").notNull().default(false),
   reason: text("reason"),
   habitEntryId: text("habit_entry_id").references(() => habitEntries.id),
   sortOrder: integer2("sort_order").notNull().default(0),
@@ -18165,7 +18187,8 @@ var routineRunSteps = pgTable("routine_run_steps", {
   completedAt: timestamp("completed_at", { withTimezone: true })
 }, (t) => [
   index("routine_run_steps_run_order_idx").on(t.runId, t.sortOrder),
-  check2("routine_run_steps_ref_kind_chk", sql`(${t.refKind} <> 'habit' OR ${t.habitId} IS NOT NULL)`)
+  check2("routine_run_steps_ref_kind_chk", sql`(${t.refKind} <> 'habit' OR ${t.habitId} IS NOT NULL)`),
+  check2("routine_run_steps_routine_chk", sql`(${t.refKind} <> 'routine' OR ${t.childRoutineId} IS NOT NULL)`)
 ]);
 var projects = pgTable("projects", {
   ...leafColumns(),
@@ -18220,6 +18243,14 @@ var userSettings = pgTable("user_settings", {
   calendarZoom: integer2("calendar_zoom"),
   lifeBlockSharing: jsonb("life_block_sharing").$type(),
   recentSearches: jsonb("recent_searches").$type().notNull().default([]),
+  glass: settingsGlass("glass").notNull().default("liquid"),
+  followSky: boolean4("follow_sky").notNull().default(true),
+  nightUntilWake: boolean4("night_until_wake").notNull().default(false),
+  largerText: boolean4("larger_text").notNull().default(false),
+  reduceMotion: boolean4("reduce_motion").notNull().default(false),
+  showStreakNumbers: boolean4("show_streak_numbers").notNull().default(true),
+  themePack: settingsThemePack("theme_pack").notNull().default("do"),
+  themePackScope: settingsThemePackScope("theme_pack_scope").notNull().default("section"),
   createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
   updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
 }, (t) => [unique("user_settings_tenant_user_uniq").on(t.tenantId, t.userId)]);
@@ -18998,14 +19029,24 @@ var recipeIngredients = pgTable("recipe_ingredients", {
   index("recipe_ingredients_tenant_idx").on(t.tenantId),
   index("recipe_ingredients_product_idx").on(t.productId)
 ]);
+var MEAL_PLAN_STATES = ["planned", "cooked", "out", "unsure", "draft"];
 var mealPlans = pgTable("meal_plans", {
   ...leafColumns(),
   recipeId: text("recipe_id").references(() => recipes.id),
   plannedFor: timestamp("planned_for", { withTimezone: true }).notNull(),
   mealType: mealType("meal_type").notNull().default("dinner"),
   servings: integer2("servings"),
-  notes: text("notes")
-}, (t) => [index("meal_plans_tenant_planned_idx").on(t.tenantId, t.plannedFor)]);
+  notes: text("notes"),
+  state: text("state", { enum: MEAL_PLAN_STATES }).notNull().default("planned"),
+  cookUserId: text("cook_user_id").references(() => users.id, { onDelete: "set null" }),
+  company: text("company"),
+  leftoverPortions: integer2("leftover_portions"),
+  leftoverEatBy: date5("leftover_eat_by", { mode: "string" }),
+  leftoverFrozen: boolean4("leftover_frozen").notNull().default(false)
+}, (t) => [
+  index("meal_plans_tenant_planned_idx").on(t.tenantId, t.plannedFor),
+  check2("meal_plans_state_check", sql`${t.state} IN ('planned', 'cooked', 'out', 'unsure', 'draft')`)
+]);
 
 // ../../packages/schema/src/db/reflections.ts
 var reflectionKind = pgEnum("reflection_kind", ["daily", "weekly"]);
@@ -21355,7 +21396,8 @@ var habitSchema = createSelectSchema(habits, {
   retiredAt: exports_coerce.date().nullable().default(null),
   eventSourceId: string2().nullable().default(null),
   eventMatch: string2().nullable().default(null),
-  eventOffset: string2().nullable().default(null)
+  eventOffset: string2().nullable().default(null),
+  durationMinutes: number2().int().nullable().default(null)
 });
 var habitEntrySchema = createSelectSchema(habitEntries, {
   occurredAt: exports_coerce.date(),
@@ -21372,6 +21414,8 @@ var habitTimeOfDaySchema = union([
   _enum2(HABIT_PARTS_OF_DAY),
   string2().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "Use a 24-hour time, like 07:30")
 ]);
+var HABIT_DURATION_MAX_MINUTES = 600;
+var habitDurationMinutesSchema = number2().int().min(1).max(HABIT_DURATION_MAX_MINUTES);
 var habitAliasSchema = string2().trim().min(1).max(60);
 var habitAliasesSchema = array(habitAliasSchema).max(12).transform((aliases) => aliases.filter((a, i) => aliases.findIndex((b) => b.toLowerCase() === a.toLowerCase()) === i));
 var habitScheduleSchema = discriminatedUnion("kind", [
@@ -21410,7 +21454,8 @@ var createHabitInputSchema = createInsertSchema(habits, {
   areaId: ulidSchema.nullish(),
   aliases: habitAliasesSchema.optional(),
   timeOfDay: habitTimeOfDaySchema.nullish(),
-  remind: boolean2().optional()
+  remind: boolean2().optional(),
+  durationMinutes: habitDurationMinutesSchema.nullish()
 }).omit({ tenantId: true, recurrenceRuleId: true, retiredAt: true, ...eventColumns }).extend({
   title: string2().min(1),
   schedule: habitScheduleSchema.optional(),
@@ -21426,7 +21471,8 @@ var updateHabitInputSchema = createUpdateSchema(habits, {
   areaId: ulidSchema.nullish(),
   aliases: habitAliasesSchema.optional(),
   timeOfDay: habitTimeOfDaySchema.nullish(),
-  remind: boolean2().optional()
+  remind: boolean2().optional(),
+  durationMinutes: habitDurationMinutesSchema.nullish()
 }).omit({
   id: true,
   tenantId: true,
@@ -21477,7 +21523,7 @@ var habitLastCheckInSchema = object({
   note: string2().nullish()
 });
 var habitPauseSchema = object({
-  until: exports_iso.date(),
+  until: exports_iso.date().nullable(),
   by: _enum2(["habit", "away"])
 });
 var habitTodaySchema = object({
@@ -21493,6 +21539,7 @@ var habitSummarySchema = habitSchema.extend({
   inRoutines: array(habitRoutineRefSchema).default([]),
   lastCheckIn: habitLastCheckInSchema.nullable().default(null),
   pause: habitPauseSchema.nullable().default(null),
+  paused: boolean2().default(false),
   today: habitTodaySchema.default({ due: true, done: false }),
   schedule: habitScheduleSchema.default({ kind: "daily" }),
   nextDue: array(exports_iso.date()).default([])
@@ -21520,6 +21567,20 @@ var habitYearSchema = object({
     marks: array(habitDayMarkSchema)
   }))
 });
+var HABIT_DUE_MAX_DAYS = 62;
+var habitDueQuerySchema = object({ from: exports_iso.date(), to: exports_iso.date() }).strict().refine((q) => q.from <= q.to, { message: "`to` is before `from`", path: ["to"] }).refine((q) => (Date.parse(q.to) - Date.parse(q.from)) / 86400000 + 1 <= HABIT_DUE_MAX_DAYS, {
+  message: `at most ${HABIT_DUE_MAX_DAYS} days`,
+  path: ["to"]
+});
+var habitDueDateSchema = object({
+  habitId: ulidSchema,
+  title: string2(),
+  date: exports_iso.date(),
+  time: string2().regex(/^\d{2}:\d{2}$/).nullable(),
+  scheduleLabel: string2().min(1),
+  daily: boolean2(),
+  streakLabel: string2().min(1)
+});
 var habitEntriesQuerySchema = object({
   before: exports_coerce.date().optional(),
   limit: exports_coerce.number().int().min(1).max(200).default(50)
@@ -21550,7 +21611,7 @@ var habitSkipInputSchema = object({
   date: exports_iso.date().optional(),
   note: habitEntryNoteSchema.nullish()
 }).strict();
-var habitPauseInputSchema = object({ until: exports_iso.date() }).strict();
+var habitPauseInputSchema = object({ until: exports_iso.date().nullish() }).strict();
 var awayInputSchema = object({ until: exports_iso.date().nullable() }).strict();
 var awayStateSchema = object({
   until: exports_iso.date().nullable()
@@ -21582,12 +21643,78 @@ var habitTodayRoutineSchema = object({
   stepsDone: number2().int().nonnegative(),
   stepsTotal: number2().int().nonnegative()
 });
-var habitsTodayResponseSchema = object({
+var habitsTodayBaseSchema = object({
   date: string2().regex(/^\d{4}-\d{2}-\d{2}$/),
   timezone: string2().min(1),
   groups: array(object({ part: habitDayPartSchema, habits: array(habitTodayItemSchema) })),
   routines: array(habitTodayRoutineSchema)
 });
+var habitMomentSchema = _enum2(["morning", "day", "evening"]);
+var habitMomentStateSchema = _enum2(["done", "going", "tonight", "open"]);
+var habitRowKindSchema = _enum2(["tick", "amount", "timer", "days-without"]);
+var HABIT_STRIP_DAYS = 14;
+var habitStripDaySchema = _enum2([
+  "done",
+  "missed",
+  "not_due",
+  "today_open",
+  "today_done"
+]);
+var habitStreakUnitSchema = _enum2(["days", "in_a_row", "since"]);
+var habitSectionStreakSchema = object({
+  current: number2().int().nonnegative(),
+  best: number2().int().nonnegative(),
+  unit: habitStreakUnitSchema,
+  since: exports_iso.date().nullable().default(null)
+});
+var habitSectionRowSchema = object({
+  habitId: ulidSchema,
+  title: string2(),
+  kind: habitRowKindSchema,
+  schedule: habitScheduleSchema,
+  scheduleWords: string2(),
+  sourceWords: string2().nullable(),
+  done: boolean2(),
+  amount: object({ value: number2(), target: number2().nullable(), unit: string2().nullable() }).nullable(),
+  strip: array(habitStripDaySchema).length(HABIT_STRIP_DAYS),
+  streak: habitSectionStreakSchema,
+  routineStep: object({
+    routineId: ulidSchema,
+    title: string2(),
+    step: number2().int().positive(),
+    of: number2().int().positive()
+  }).nullable()
+});
+var habitSectionMomentSchema = object({
+  moment: habitMomentSchema,
+  label: string2(),
+  routines: array(object({ id: ulidSchema, title: string2(), time: string2().nullable() })),
+  state: habitMomentStateSchema,
+  going: number2().int().nonnegative().default(0),
+  rows: array(habitSectionRowSchema)
+});
+var habitNotDueSchema = object({
+  id: ulidSchema,
+  title: string2(),
+  nextDue: exports_iso.date().nullable()
+});
+var habitWeekDaySchema = object({
+  day: exports_iso.date(),
+  done: number2().int().nonnegative().nullable(),
+  due: number2().int().nonnegative()
+});
+var habitSectionTotalsSchema = object({
+  dueToday: number2().int().nonnegative(),
+  doneToday: number2().int().nonnegative(),
+  weekDone: number2().int().nonnegative(),
+  weekDue: number2().int().nonnegative()
+});
+var habitsTodayResponseSchema = habitsTodayBaseSchema.extend({
+  moments: array(habitSectionMomentSchema).default([]),
+  notDue: array(habitNotDueSchema).default([]),
+  week: array(habitWeekDaySchema).default([]),
+  totals: habitSectionTotalsSchema.default({ dueToday: 0, doneToday: 0, weekDone: 0, weekDue: 0 })
+});
 
 // ../../packages/schema/src/contracts/metrics.ts
 var METRICS = {
@@ -21828,6 +21955,78 @@ var taskBlockerSchema = object({
   dueAt: exports_coerce.date().nullable()
 });
 
+// ../../packages/schema/src/db/task-series.ts
+var taskSeries = pgTable("task_series", {
+  id: text("id").primaryKey(),
+  tenantId: text("tenant_id").notNull().references(() => tenants.id),
+  title: text("title").notNull(),
+  recurrenceRuleId: text("recurrence_rule_id").notNull().references(() => recurrenceRules.id),
+  startsOn: date5("starts_on", { mode: "string" }).notNull(),
+  occurrenceLabel: text("occurrence_label").notNull().default("date"),
+  leadDays: integer2("lead_days").notNull().default(14),
+  areaId: text("area_id").references(() => areas.id, { onDelete: "set null" }),
+  projectId: text("project_id").references(() => projects.id, { onDelete: "set null" }),
+  tags: text("tags").array().notNull().default([]),
+  priority: workPriority("priority").notNull().default("none"),
+  durationMinutes: integer2("duration_minutes"),
+  ownerUserId: text("owner_user_id").references(() => users.id, { onDelete: "set null" }),
+  ownerAgentId: text("owner_agent_id").references(() => agents.id, { onDelete: "set null" }),
+  subtaskTitles: text("subtask_titles").array().notNull().default([]),
+  active: boolean4("active").notNull().default(true),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (t) => [
+  index("task_series_tenant_idx").on(t.tenantId, t.active)
+]);
+
+// ../../packages/schema/src/contracts/task-series.ts
+var taskSeriesRuleSchema = object({
+  freq: _enum2(["weekly", "monthly", "yearly"]),
+  interval: number2().int().min(1).max(52).default(1)
+}).strict();
+var taskSeriesLabelSchema = _enum2(["quarter", "month", "date"]);
+var leadDaysSchema2 = number2().int().min(0).max(365);
+var taskSeriesRowSchema = createSelectSchema(taskSeries, {
+  occurrenceLabel: taskSeriesLabelSchema,
+  startsOn: exports_iso.date(),
+  createdAt: exports_coerce.date(),
+  updatedAt: exports_coerce.date()
+});
+var makeTaskSeriesInputSchema = object({
+  rule: taskSeriesRuleSchema,
+  occurrenceLabel: taskSeriesLabelSchema.default("date"),
+  leadDays: leadDaysSchema2.default(14)
+}).strict();
+var updateTaskSeriesInputSchema = object({
+  title: string2().trim().min(1).max(500).optional(),
+  rule: taskSeriesRuleSchema.optional(),
+  occurrenceLabel: taskSeriesLabelSchema.optional(),
+  leadDays: leadDaysSchema2.optional(),
+  active: boolean2().optional()
+}).strict();
+var taskSeriesItemSchema = object({
+  taskId: ulidSchema.nullable(),
+  label: string2(),
+  slot: exports_iso.date(),
+  status: taskStatusSchema.nullable(),
+  completedAt: exports_coerce.date().nullable()
+});
+var taskSeriesStripSchema = object({
+  id: ulidSchema,
+  title: string2(),
+  rhythm: string2(),
+  items: array(taskSeriesItemSchema),
+  nextMadeOn: exports_iso.date().nullable()
+});
+var taskSeriesViewSchema = taskSeriesStripSchema.extend({
+  rule: taskSeriesRuleSchema,
+  occurrenceLabel: taskSeriesLabelSchema,
+  leadDays: number2().int(),
+  startsOn: exports_iso.date(),
+  active: boolean2(),
+  made: number2().int().nonnegative()
+});
+
 // ../../packages/schema/src/contracts/task-source.ts
 var taskSourceSchema = object({
   kind: string2().trim().min(1).max(40),
@@ -22000,7 +22199,10 @@ var taskSchema = createSelectSchema(tasks, {
   movedFrom: exports_coerce.date().nullable().default(null),
   waitingFor: string2().nullable().default(null),
   nudgedAt: exports_coerce.date().nullable().default(null),
-  nudgeCount: number2().int().nonnegative().default(0)
+  nudgeCount: number2().int().nonnegative().default(0),
+  seriesId: string2().nullable().default(null),
+  seriesLabel: string2().nullable().default(null),
+  seriesSlot: exports_iso.date().nullable().default(null)
 });
 var PARTY_RE = /^(?:(me)|(member|agent|contact):([^/]+?))(?:\/(.+))?$/;
 function partySchema(allowDesk, allowContact = false) {
@@ -22055,6 +22257,55 @@ var taskFilingSuggestionSchema = object({
 var completedAtInputSchema = exports_coerce.date().refine((d) => d.getTime() <= Date.now() + 60000, "completedAt can't be in the future").nullish();
 var taskNextStepSchema = string2().trim().min(1).max(500);
 var taskDeliverableSchema = string2().trim().min(1).max(500);
+var taskRecurrenceAnchorSchema = _enum2(["fixed", "from_completion"]);
+function isTimeZone(zone) {
+  try {
+    new Intl.DateTimeFormat("en", { timeZone: zone });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var taskRecurrenceInputSchema = object({
+  freq: recurrenceFreqSchema,
+  interval: number2().int().positive().default(1),
+  byDay: array(byDaySchema).min(1).optional(),
+  byMonthDay: number2().int().min(-1).max(31).refine((d) => d !== 0, "byMonthDay is 1\u201331, or -1 for the last day").optional(),
+  anchor: taskRecurrenceAnchorSchema.default("fixed"),
+  timezone: string2().refine(isTimeZone, "an IANA time zone, e.g. Europe/Brussels").optional()
+}).strict().superRefine((v, ctx) => {
+  const issue = (path, message) => ctx.addIssue({ code: "custom", path, message });
+  if (v.anchor === "from_completion") {
+    if (v.freq === "yearly")
+      issue(["freq"], "a from_completion rule is daily, weekly or monthly");
+    if (v.byDay)
+      issue(["byDay"], "a from_completion rule takes no byDay");
+    if (v.byMonthDay !== undefined)
+      issue(["byMonthDay"], "a from_completion rule takes no byMonthDay");
+    return;
+  }
+  if (v.byDay && v.freq === "daily")
+    issue(["byDay"], "byDay needs a weekly or monthly freq");
+  const ordinal = v.byDay?.findIndex((code) => parseByDay(code)?.ordinal != null) ?? -1;
+  if (ordinal >= 0 && v.freq !== "monthly" && v.freq !== "yearly") {
+    issue(["byDay", ordinal], "an ordinal weekday (1SU, -1FR) needs a monthly or yearly freq");
+  }
+  if (v.byMonthDay !== undefined && v.freq !== "monthly") {
+    issue(["byMonthDay"], "byMonthDay needs a monthly freq");
+  }
+  if (v.byMonthDay !== undefined && v.byDay) {
+    issue(["byMonthDay"], "pass byDay or byMonthDay, not both");
+  }
+});
+var taskRecurrenceSchema = object({
+  ruleId: ulidSchema,
+  freq: recurrenceFreqSchema,
+  interval: number2().int().positive(),
+  byDay: array(string2()).nullable(),
+  byMonthDay: number2().int().nullable(),
+  anchor: taskRecurrenceAnchorSchema,
+  timezone: string2()
+});
 var taskViewSchema = taskSchema.omit({
   ownerUserId: true,
   ownerAgentId: true,
@@ -22089,7 +22340,9 @@ var taskViewSchema = taskSchema.omit({
   filingSuggestion: taskFilingSuggestionSchema.nullable().default(null),
   blockedBy: array(taskBlockerSchema).default([]),
   blocks: number2().int().nonnegative().default(0),
-  isBlocked: boolean2().default(false)
+  isBlocked: boolean2().default(false),
+  recurrence: taskRecurrenceSchema.nullable().default(null),
+  series: taskSeriesStripSchema.nullable().default(null)
 });
 var taskProjectIdSchema = ulidSchema.nullish();
 var taskAreaIdSchema = ulidSchema.nullish();
@@ -22125,6 +22378,9 @@ var createTaskInputSchema = createInsertSchema(tasks, {
   completedByUserId: true,
   completedByAgentId: true,
   filingSuggestion: true,
+  seriesId: true,
+  seriesLabel: true,
+  seriesSlot: true,
   proposedAt: true,
   proposedDesk: true,
   notNowUntil: true,
@@ -22143,7 +22399,8 @@ var createTaskInputSchema = createInsertSchema(tasks, {
   source: taskSourceSchema.nullish(),
   nextStep: taskNextStepSchema.nullish(),
   proposed: boolean2().optional(),
-  fromDesk: deskSchema.nullish()
+  fromDesk: deskSchema.nullish(),
+  recurrence: taskRecurrenceInputSchema.nullish()
 });
 var taskReadyNoteSchema = string2().trim().min(1).max(500);
 var markTaskReadyInputSchema = object({ note: taskReadyNoteSchema.nullish() }).strict();
@@ -22178,6 +22435,9 @@ var updateTaskInputSchema = createUpdateSchema(tasks, {
   completedByUserId: true,
   completedByAgentId: true,
   filingSuggestion: true,
+  seriesId: true,
+  seriesLabel: true,
+  seriesSlot: true,
   proposedAt: true,
   proposedDesk: true,
   readyAt: true,
@@ -22196,7 +22456,8 @@ var updateTaskInputSchema = createUpdateSchema(tasks, {
   proposed: boolean2().optional(),
   notNowUntil: exports_coerce.date().nullish(),
   ready: boolean2().optional(),
-  readyNote: taskReadyNoteSchema.nullish()
+  readyNote: taskReadyNoteSchema.nullish(),
+  recurrence: taskRecurrenceInputSchema.nullish()
 }).strict();
 var taskListFilterSchema = _enum2(["all", "unsorted", "starred"]);
 
@@ -22306,7 +22567,9 @@ var attachTaskInputSchema = object({ taskId: ulidSchema });
 var routineDayTimesSchema = partialRecord(_enum2(["MO", "TU", "WE", "TH", "FR", "SA", "SU"]), string2().regex(/^([01]\d|2[0-3]):[0-5]\d$/));
 var routineSchema = createSelectSchema(routines);
 var routineStepSchema = createSelectSchema(routineSteps, {
-  createdAt: exports_coerce.date()
+  createdAt: exports_coerce.date(),
+  childRoutineId: string2().nullish(),
+  optional: boolean2().optional()
 });
 var routineStepInputSchema = object({
   id: ulidSchema,
@@ -22314,12 +22577,36 @@ var routineStepInputSchema = object({
   refKind: routineStepRefSchema.default("free"),
   habitId: ulidSchema.nullish(),
   taskId: ulidSchema.nullish(),
+  childRoutineId: ulidSchema.nullish(),
   newHabit: createHabitInputSchema.optional(),
+  optional: boolean2().optional(),
   sortOrder: number2().int().min(0).optional(),
   durationMinutes: number2().int().positive().nullish(),
   notes: string2().nullish()
 }).superRefine((step, ctx) => {
-  if (step.refKind === "habit") {
+  if (step.refKind !== "routine" && step.childRoutineId) {
+    ctx.addIssue({
+      code: ZodIssueCode.custom,
+      message: "only a routine step sets childRoutineId",
+      path: ["childRoutineId"]
+    });
+  }
+  if (step.refKind === "routine") {
+    if (!step.childRoutineId) {
+      ctx.addIssue({
+        code: ZodIssueCode.custom,
+        message: "a routine step needs childRoutineId",
+        path: ["childRoutineId"]
+      });
+    }
+    if (step.habitId || step.taskId || step.newHabit) {
+      ctx.addIssue({
+        code: ZodIssueCode.custom,
+        message: "a routine step cannot set a habit/task link",
+        path: ["refKind"]
+      });
+    }
+  } else if (step.refKind === "habit") {
     const linkId = step.newHabit?.id ?? step.habitId;
     if (!linkId) {
       ctx.addIssue({
@@ -22375,6 +22662,16 @@ var createRoutineInputSchema = createInsertSchema(routines, {
   parentId: ulidSchema.nullish(),
   steps: array(routineStepInputSchema).optional(),
   dayTimes: routineDayTimesSchema.optional()
+}).superRefine((input, ctx) => {
+  for (const [i, step] of (input.steps ?? []).entries()) {
+    if (step.childRoutineId && step.childRoutineId === input.id) {
+      ctx.addIssue({
+        code: ZodIssueCode.custom,
+        message: "a routine cannot contain itself",
+        path: ["steps", i, "childRoutineId"]
+      });
+    }
+  }
 });
 var updateRoutineInputSchema = createUpdateSchema(routines, {
   areaId: ulidSchema.nullish()
@@ -22405,7 +22702,10 @@ var routineRunSchema = createSelectSchema(routineRuns, {
 var routineRunStepSchema = createSelectSchema(routineRunSteps, {
   completedAt: exports_coerce.date().nullable(),
   taskId: string2().nullable().default(null),
-  reason: string2().nullable().default(null)
+  reason: string2().nullable().default(null),
+  childRoutineId: string2().nullish(),
+  groupStepId: string2().nullish(),
+  optional: boolean2().optional()
 });
 var routineRunStepViewSchema = routineRunStepSchema.extend({
   habit: habitSummarySchema.nullable().default(null),
@@ -22495,14 +22795,16 @@ var addRoutineTaskStepInputSchema = object({
 var reorderRoutineStepsInputSchema = object({
   stepIds: array(ulidSchema).min(1).max(200).refine((ids) => new Set(ids).size === ids.length, "stepIds must not repeat")
 }).strict();
-var routineTodayStepKindSchema = _enum2(["step", "habit", "task"]);
+var routineTodayStepKindSchema = _enum2(["step", "habit", "task", "routine"]);
 var routineTodayStepSchema = object({
   n: number2().int().positive(),
   title: string2(),
   kind: routineTodayStepKindSchema,
   meta: string2().nullable(),
   minutes: number2().int().nullable(),
-  done: boolean2()
+  done: boolean2(),
+  depth: number2().int().nonnegative().default(0),
+  optional: boolean2().default(false)
 });
 var routineTodayStateSchema = _enum2(["done", "running", "upcoming", "resting"]);
 var routineTodaySchema = object({
@@ -23889,7 +24191,7 @@ var timeBlockViewSchema = timeBlockSchema.omit({
 var timeBlockStepSchema = object({
   id: string2(),
   title: string2(),
-  refKind: _enum2(["free", "habit", "task"]),
+  refKind: routineStepRefSchema,
   status: _enum2(["done", "skipped", "open"]),
   at: exports_coerce.date().nullable(),
   habitId: string2().nullable().optional()
@@ -24109,6 +24411,7 @@ var calendarEventLinks = pgTable("calendar_event_links", {
   connectionId: text("connection_id").notNull().references(() => connections.id, { onDelete: "cascade" }),
   nodeId: text("node_id").notNull().references(() => nodes.id, { onDelete: "cascade" }),
   purpose: calendarLinkPurpose("purpose").notNull().default("block"),
+  slot: text("slot").notNull().default(""),
   externalCalendarId: text("external_calendar_id").notNull(),
   externalEventId: text("external_event_id").notNull(),
   etag: text("etag"),
@@ -24117,7 +24420,7 @@ var calendarEventLinks = pgTable("calendar_event_links", {
   createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
   updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
 }, (t) => [
-  unique("calendar_event_links_connection_node_uniq").on(t.connectionId, t.nodeId, t.purpose),
+  unique("calendar_event_links_connection_node_uniq").on(t.connectionId, t.nodeId, t.purpose, t.slot),
   unique("calendar_event_links_connection_event_uniq").on(t.connectionId, t.externalEventId),
   index("calendar_event_links_tenant_connection_idx").on(t.tenantId, t.connectionId),
   index("calendar_event_links_node_idx").on(t.nodeId)
@@ -24179,7 +24482,8 @@ var calendarConnectionCalendars = pgTable("calendar_connection_calendars", {
 var calendarEventLinkSchema = createSelectSchema(calendarEventLinks, {
   createdAt: exports_coerce.date(),
   updatedAt: exports_coerce.date(),
-  lastSyncedAt: exports_coerce.date()
+  lastSyncedAt: exports_coerce.date(),
+  slot: string2().default("")
 });
 var calendarSyncResultSchema = object({
   connectionId: string2(),
@@ -29751,11 +30055,32 @@ var habitOperations = defineOperations({
     scopes: ["habits:read"],
     tag: "Habits",
     summary: "What's left today",
-    description: "\"What's left?\" (#866): the habits due on the key's member's day (their saved time zone), already filtered by schedule, grouped by part of day (morning, midday, evening, anytime). Each says its value today, `done`/`open`/`skipped` (never overdue: habits don't carry over), the week for an N-per-week habit, and its last check-in (`by` names the Agent). Also today's routines with how many steps are done. Quit habits are left out.",
+    description: "\"What's left?\" (#866): the habits due on the key's member's day (their saved time zone), already filtered by schedule, grouped by part of day (morning, midday, evening, anytime). Each says its value today, `done`/`open`/`skipped` (never overdue: habits don't carry over), the week for an N-per-week habit, and its last check-in (`by` names the Agent). Also today's routines with how many steps are done. Quit habits are left out of `groups`. The Habits section (V3-47) rides along: `moments` (morning, day, evening; habits inside their routine, each with its schedule in words, today's amount, a 14-day strip where a day it isn't due is `not_due`, never `missed`, and its streak in days, in a row or since), `notDue` (live, unpaused habits off today, by next due day), this Monday-to-Sunday `week` counting only due habits, and `totals`.",
     status: 200,
     response: { description: "Today's habits and routines." },
     operationId: "habits_today"
   },
+  due: {
+    method: "get",
+    path: "/habits/due",
+    scopes: ["habits:read"],
+    tag: "Habits",
+    summary: "Habit due dates in a range",
+    description: "Plan's Month and agendas (V3-22): every growing habit's due days from `from` through `to` (the key's member's civil days, both included, at most 62), by its schedule alone, the same rule the list and today read. A day it rests (paused, away) or before it began isn't one; quit and event-scheduled habits are left out. Each row is `{ habitId, title, date, time, scheduleLabel, daily, streakLabel }`: `time` its exact `HH:MM` or null, `daily` true for a habit due every day, `streakLabel` `N days` for a daily habit and `N in a row` otherwise. Sorted by date, then time.",
+    query: [
+      { name: "from", description: "The first day (YYYY-MM-DD).", format: "date", required: true },
+      {
+        name: "to",
+        description: "The last day (YYYY-MM-DD), at most 62 days on.",
+        format: "date",
+        required: true
+      }
+    ],
+    querySchema: habitDueQuerySchema,
+    status: 200,
+    response: { description: "The habits' due days." },
+    errors: { 400: true }
+  },
   getAway: {
     method: "get",
     path: "/habits/away",
@@ -29932,8 +30257,9 @@ var habitOperations = defineOperations({
     scopes: ["habits:write"],
     tag: "Habits",
     summary: "Pause a habit",
-    description: '"Pause gym till the 26th": the habit rests until `until` (the day it\'s back, after today): off Now, no push, streak and plant wait. Pausing a paused habit moves its end. Returns the refreshed habit with `pause`; fires `habit.updated`.',
+    description: '"Pause gym till the 26th": the habit rests until `until` (the day it\'s back, after today): off Now, no push, streak and plant wait. No body, or `until: null`, pauses open-ended: it rests until `/resume` (`paused` true, `pausedUntil` null). Pausing a paused habit moves its end. Returns the refreshed habit with `pause` and `paused`; fires `habit.updated`.',
     body: habitPauseInputSchema,
+    bodyOptional: true,
     status: 201,
     response: { description: "The refreshed habit." },
     errors: {
@@ -30003,9 +30329,9 @@ var habitOperations = defineOperations({
     scopes: ["habits:write"],
     tag: "Habits",
     summary: "Undo a check-in",
-    description: "Delete a check-in; fires `habit.updated`.",
+    description: "Delete a wrong or test check-in (or a skip): the streak, today state and heatmap recompute from what's left. The entry must be this habit's: another habit's, another Space's or one already gone is a 404. Find the id with `GET /habits/{id}/check-ins` or `lastCheckIn.id`. Returns the refreshed habit; fires `habit.updated`.",
     status: 200,
-    response: { description: "The refreshed habit." },
+    response: { description: "The refreshed habit, its streak recomputed." },
     errors: { 404: true },
     webhook: "habit.updated",
     operationId: "undo_habit_check_in"
@@ -31171,6 +31497,12 @@ var houseValueSchema = object({
   }).nullable()
 });
 var upkeepMonthMarkSchema = _enum2(["done", "due", "planned", "late"]).nullable();
+var upkeepRoutineKindSchema = _enum2(["habit", "series"]);
+var upkeepSeriesRunSchema = object({
+  year: number2().int(),
+  mark: _enum2(["done", "running", "late"]),
+  taskId: string2()
+});
 var houseUpkeepRoutineSchema = object({
   taskId: string2(),
   title: string2(),
@@ -31180,7 +31512,14 @@ var houseUpkeepRoutineSchema = object({
   months: array(upkeepMonthMarkSchema).length(12),
   bookedOn: day.nullable().default(null),
   itemState: string2().nullable().default(null),
-  certified: boolean2().default(false)
+  certified: boolean2().default(false),
+  kind: upkeepRoutineKindSchema.default("habit"),
+  placeTitle: string2().nullable().default(null),
+  cadenceWords: string2().default(""),
+  nextOn: day.nullable().default(null),
+  nextWords: string2().default(""),
+  late: boolean2().default(false),
+  seriesRuns: array(upkeepSeriesRunSchema).default([])
 });
 var houseUpkeepNeedSchema = object({
   id: string2(),
@@ -31197,6 +31536,12 @@ var houseUpkeepYearSchema = object({
   year: number2().int(),
   currentMonth: number2().int().min(1).max(12).nullable(),
   routines: array(houseUpkeepRoutineSchema),
+  counts: object({
+    all: number2().int().min(0),
+    habits: number2().int().min(0),
+    series: number2().int().min(0),
+    late: number2().int().min(0)
+  }).default({ all: 0, habits: 0, series: 0, late: 0 }),
   needsMonth: number2().int().min(1).max(12),
   needs: array(houseUpkeepNeedSchema),
   spent: object({
@@ -33028,6 +33373,7 @@ var apiKeys = pgTable("api_keys", {
   scopes: text("scopes").array().notNull().default([]),
   lastUsedAt: timestamp("last_used_at", { withTimezone: true }),
   revokedAt: timestamp("revoked_at", { withTimezone: true }),
+  expiresAt: timestamp("expires_at", { withTimezone: true }),
   createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
   updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
 }, (t) => [index("api_keys_tenant_idx").on(t.tenantId)]);
@@ -33124,6 +33470,22 @@ var API_KEY_SCOPE_VALUES = [
   "private:*",
   "*"
 ];
+var API_TOKEN_SECTION_VALUES = [
+  "today",
+  "plan",
+  "work",
+  "habits",
+  "journal",
+  "home",
+  "food",
+  "collection",
+  "money",
+  "health",
+  "people",
+  "animals",
+  "agents",
+  "settings"
+];
 var FULL_ACCESS_SCOPE = "*";
 var CONNECTIONS_WRITE_SCOPE = "connections:write";
 function scopeGranted(granted, required) {
@@ -33143,16 +33505,25 @@ var apiKeyScopesInputSchema = array(apiKeyScopeSchema).refine((scopes) => !scope
 });
 var apiKeySchema = createSelectSchema(apiKeys, {
   scopes: array(apiKeyScopeSchema),
+  expiresAt: exports_coerce.date().nullable().default(null),
   agentId: string2().nullable().default(null),
   lastUsedAt: exports_coerce.date().nullable(),
   revokedAt: exports_coerce.date().nullable(),
   createdAt: exports_coerce.date(),
   updatedAt: exports_coerce.date()
 });
-var apiKeyPublicSchema = apiKeySchema.omit({ keyHash: true });
+var apiKeySectionAccessSchema = object({
+  section: _enum2(API_TOKEN_SECTION_VALUES),
+  access: _enum2(["read", "write"])
+}).strict();
+var apiKeyPublicSchema = apiKeySchema.omit({ keyHash: true }).extend({
+  sections: array(apiKeySectionAccessSchema).default([]),
+  scopeLine: string2().default("")
+});
 var createApiKeyInputSchema = createInsertSchema(apiKeys, {
   name: string2().min(1).max(120),
   scopes: apiKeyScopesInputSchema.optional(),
+  expiresAt: exports_coerce.date().nullish(),
   agentId: ulidSchema.nullish()
 }).omit({
   id: true,
@@ -33164,7 +33535,27 @@ var createApiKeyInputSchema = createInsertSchema(apiKeys, {
   revokedAt: true,
   createdAt: true,
   updatedAt: true
-}).strict();
+}).extend({
+  sections: array(apiKeySectionAccessSchema).min(1).max(API_TOKEN_SECTION_VALUES.length).optional()
+}).strict().refine((v) => v.scopes === undefined || v.sections === undefined, {
+  message: "give scopes or sections, not both",
+  path: ["sections"]
+}).refine((v) => !v.expiresAt || v.expiresAt.getTime() > Date.now(), {
+  message: "an expiry must be in the future",
+  path: ["expiresAt"]
+});
+var createKeyFromKeyInputSchema = object({
+  name: string2().min(1).max(120),
+  scopes: apiKeyScopesInputSchema.optional(),
+  sections: array(apiKeySectionAccessSchema).min(1).max(API_TOKEN_SECTION_VALUES.length).optional(),
+  expiresAt: exports_coerce.date().nullish()
+}).strict().refine((v) => v.scopes === undefined || v.sections === undefined, {
+  message: "give scopes or sections, not both",
+  path: ["sections"]
+}).refine((v) => !v.expiresAt || v.expiresAt.getTime() > Date.now(), {
+  message: "an expiry must be in the future",
+  path: ["expiresAt"]
+});
 var createApiKeyResultSchema = apiKeyPublicSchema.extend({ key: string2() });
 var updateApiKeyInputSchema = object({
   name: string2().min(1).max(120).optional(),
@@ -33210,6 +33601,20 @@ var keyOperations = defineOperations({
     response: { description: "The keys." },
     errors: { 403: true }
   },
+  create: {
+    method: "post",
+    path: "/keys",
+    scopes: ["keys:write"],
+    tag: "Identity",
+    summary: "Mint an API key",
+    description: 'A key for the member behind this key, by `sections` (each `read` or `write`: Today/Inbox, Plan, Work, Habits, Journal, Home, Food, Collection, Money, Health, People, Animals, Agents, Settings; the server keeps the scopes they stand for) or by `scopes`, not both, with an optional `expiresAt` (null never expires; past it the key gets 401 "This token expired on <date>"). Never more than the calling key holds (403), never an Agent\'s key. The plaintext `key` is in the answer once; the key carries its `scopeLine` ("Work, Plan: read and write").',
+    body: createKeyFromKeyInputSchema,
+    status: 201,
+    response: { description: "The key, with its one-time secret." },
+    errors: { 400: true, 403: true },
+    throttle: "strict",
+    mcp: false
+  },
   update: {
     method: "patch",
     path: "/keys/{id}",
@@ -33772,19 +34177,37 @@ var mailCampaignOperations = defineOperations({
 });
 
 // ../../packages/schema/src/contracts/meal-plans.ts
+var mealPlanStateSchema = _enum2(MEAL_PLAN_STATES);
+var civilDate2 = string2().regex(/^\d{4}-\d{2}-\d{2}$/, "a date is YYYY-MM-DD");
+var weekMenuFields = {
+  state: mealPlanStateSchema.optional(),
+  cookUserId: ulidSchema.nullish(),
+  company: string2().max(120).nullish(),
+  leftoverPortions: number2().int().positive().nullish(),
+  leftoverEatBy: civilDate2.nullish(),
+  leftoverFrozen: boolean2().optional()
+};
 var mealPlanSchema = createSelectSchema(mealPlans, {
-  plannedFor: exports_coerce.date()
+  plannedFor: exports_coerce.date(),
+  state: mealPlanStateSchema.default("planned"),
+  cookUserId: string2().nullable().default(null),
+  company: string2().nullable().default(null),
+  leftoverPortions: number2().int().nullable().default(null),
+  leftoverEatBy: string2().nullable().default(null),
+  leftoverFrozen: boolean2().default(false)
 });
 var createMealPlanInputSchema = createInsertSchema(mealPlans, {
   id: ulidSchema,
   recipeId: ulidSchema.nullish(),
   plannedFor: exports_coerce.date(),
-  servings: number2().int().positive().nullish()
+  servings: number2().int().positive().nullish(),
+  ...weekMenuFields
 }).omit({ tenantId: true }).extend({ title: string2().min(1) });
 var updateMealPlanInputSchema = createUpdateSchema(mealPlans, {
   recipeId: ulidSchema.nullish(),
   plannedFor: exports_coerce.date().optional(),
-  servings: number2().int().positive().nullish()
+  servings: number2().int().positive().nullish(),
+  ...weekMenuFields
 }).omit({ id: true, tenantId: true }).extend({ title: string2().min(1).optional() }).strict();
 var mealPlanViewSchema = mealPlanSchema.extend({
   title: string2(),
@@ -33794,6 +34217,10 @@ var mealPlanViewSchema = mealPlanSchema.extend({
   deletedAt: exports_coerce.date().nullable(),
   recipeTitle: string2().nullable()
 });
+var mealPlanListQuerySchema = object({
+  recipeId: ulidSchema.optional(),
+  state: mealPlanStateSchema.optional()
+});
 var generateGroceryListInputSchema = object({
   id: ulidSchema,
   title: string2().min(1),
@@ -33815,6 +34242,59 @@ var mealPlanCookResultSchema = object({
   consumedCount: number2().int().min(0),
   ingredients: array(cookedIngredientSchema)
 });
+var cookMealPlanInputSchema = object({
+  leftoverPortions: number2().int().positive().nullish(),
+  leftoverEatBy: civilDate2.nullish()
+}).strict();
+var mealWeekQuerySchema = object({ start: civilDate2.optional() });
+var acceptMealDraftInputSchema = object({ start: civilDate2 }).strict();
+var mealWeekCookSchema = object({
+  userId: string2(),
+  name: string2(),
+  initial: string2()
+});
+var mealWeekSlotSchema = object({
+  id: ulidSchema,
+  title: string2(),
+  recipeId: ulidSchema.nullable(),
+  state: mealPlanStateSchema,
+  cook: mealWeekCookSchema.nullable(),
+  company: string2().nullable(),
+  notes: string2().nullable(),
+  time: string2().nullable()
+});
+var mealWeekDaySchema = object({
+  date: civilDate2,
+  isToday: boolean2(),
+  dinner: mealWeekSlotSchema.nullable(),
+  lunch: mealWeekSlotSchema.nullable()
+});
+var mealWeekLeftoverSchema = object({
+  mealPlanId: ulidSchema,
+  title: string2(),
+  portions: number2().int(),
+  cookedOn: civilDate2,
+  eatBy: civilDate2.nullable(),
+  frozen: boolean2()
+});
+var mealWeekDraftDaySchema = object({
+  date: civilDate2,
+  dinner: mealWeekSlotSchema.nullable(),
+  why: string2().nullable()
+});
+var mealWeekSchema = object({
+  week: number2().int().min(1).max(53),
+  start: civilDate2,
+  end: civilDate2,
+  days: array(mealWeekDaySchema).length(7),
+  summary: object({
+    planned: number2().int().min(0),
+    cooked: number2().int().min(0),
+    out: number2().int().min(0)
+  }),
+  leftovers: array(mealWeekLeftoverSchema),
+  draft: array(mealWeekDraftDaySchema).length(7)
+});
 
 // ../../packages/schema/src/operations/meal-plans.ts
 var mealPlanOperations = defineOperations({
@@ -33825,8 +34305,43 @@ var mealPlanOperations = defineOperations({
     read: "meals:read",
     write: "meals:write",
     create: createMealPlanInputSchema,
-    update: updateMealPlanInputSchema
-  })
+    update: updateMealPlanInputSchema,
+    listQuery: [
+      { name: "recipeId", description: "Only the plans of this recipe (its ULID)." },
+      {
+        name: "state",
+        description: "Only plans in this state (`planned`, `cooked`, `out`, `unsure`, `draft`); `cooked` with `recipeId` is who cooked a recipe when."
+      }
+    ],
+    listQuerySchema: mealPlanListQuerySchema
+  }),
+  week: {
+    method: "get",
+    path: "/meal-plans/week",
+    scopes: ["meals:read"],
+    tag: "Meals",
+    summary: "Show the week menu",
+    description: "The week (Monday to Sunday) from `start` (any day is moved to its Monday; this week by default): each day's dinner and lunch with its state (planned \xB7 cooked \xB7 out \xB7 unsure), who cooks and the company of a meal out; the dinner counts (planned, cooked, out); the leftovers still to eat; and next week's `draft` dinners, each with its one-line why (the draft plan's notes).",
+    query: [{ name: "start", description: "A day of the week, YYYY-MM-DD.", format: "date" }],
+    querySchema: mealWeekQuerySchema,
+    status: 200,
+    response: { description: "The week menu." },
+    errors: { 400: true },
+    operationId: "meal_week"
+  },
+  acceptDraft: {
+    method: "post",
+    path: "/meal-plans/week/accept-draft",
+    scopes: ["meals:write"],
+    tag: "Meals",
+    summary: "Accept a week's draft",
+    description: "Turn every `draft` meal plan in the week from `start` into a `planned` one and return that week's menu. Accepting a week with no drafts left changes nothing.",
+    body: acceptMealDraftInputSchema,
+    status: 200,
+    response: { description: "The week menu, its drafts planned." },
+    errors: { 400: true },
+    operationId: "meal_week_accept_draft"
+  }
 });
 
 // ../../packages/schema/src/operations/members.ts
@@ -37434,7 +37949,8 @@ var recipeLibrarySchema = object({
   recipes: array(object({
     id: ulidSchema,
     lastCookedAt: exports_coerce.date().nullable(),
-    ingredients: array(string2())
+    ingredients: array(string2()),
+    cookedCount: number2().int().min(0).optional()
   })),
   menu: array(object({
     planId: ulidSchema,
@@ -37443,7 +37959,9 @@ var recipeLibrarySchema = object({
     plannedFor: exports_coerce.date(),
     mealType: mealTypeSchema,
     cooked: boolean2(),
-    onList: array(string2())
+    onList: array(string2()),
+    state: mealPlanStateSchema.optional(),
+    cook: mealWeekCookSchema.nullable().optional()
   }))
 });
 var recipeIngredientMatchInputSchema = object({ foodId: string2().min(1) }).strict();
@@ -37646,7 +38164,7 @@ var routineOperations = defineOperations({
     scopes: ["routines:write"],
     tag: "Routines",
     summary: "Update a routine",
-    description: "Patch a routine; fires `routine.updated`.",
+    description: "Patch a routine; fires `routine.updated`. `steps`, when present, replaces the template in one call, in the order given: a step whose `id` is already the routine's is updated in place (its runs keep pointing at it), one left out is dropped (past runs keep their snapshot), a new `id` is added. `steps: []` empties the routine. The habits and tasks the steps link are never changed.",
     body: updateRoutineInputSchema,
     status: 200,
     response: { description: "The updated routine." },
@@ -37659,12 +38177,25 @@ var routineOperations = defineOperations({
     scopes: ["routines:write"],
     tag: "Routines",
     summary: "Delete a routine",
-    description: "Soft-delete a routine; fires `routine.deleted`.",
+    description: "Soft-delete a routine into Trash; its steps and runs stay for history, and the habits and tasks its steps link are untouched. Fires `routine.deleted`.",
     status: 204,
     response: { description: "Deleted." },
     errors: { 404: true },
     webhook: "routine.deleted"
   },
+  archive: {
+    method: "post",
+    path: "/routines/{id}/archive",
+    scopes: ["routines:write"],
+    tag: "Routines",
+    summary: "Archive a routine",
+    description: "Put the routine in Trash: the same soft delete as `DELETE /api/v1/routines/{id}`, restorable like any other node. Its steps and runs stay for history; the habits and tasks its steps link are untouched. Fires `routine.deleted`.",
+    status: 204,
+    response: { description: "Archived." },
+    errors: { 404: true },
+    webhook: "routine.deleted",
+    operationId: "archive_routine"
+  },
   attachRecurrence: {
     method: "put",
     path: "/routines/{id}/recurrence",
@@ -38906,6 +39437,9 @@ var PILL_PAGES_MAX = 4;
 var CALENDAR_ZOOM_MIN = 75;
 var CALENDAR_ZOOM_MAX = 300;
 var calendarZoomSchema = number2().int().min(CALENDAR_ZOOM_MIN).max(CALENDAR_ZOOM_MAX);
+var settingsGlassSchema = _enum2(settingsGlass.enumValues);
+var themePackSchema = _enum2(settingsThemePack.enumValues);
+var themePackScopeSchema = _enum2(settingsThemePackScope.enumValues);
 var userSettingsSchema = createSelectSchema(userSettings, {
   pinnedAreaIds: array(string2()).default([]),
   focusAreaId: string2().nullable().default(null),
@@ -38916,6 +39450,14 @@ var userSettingsSchema = createSelectSchema(userSettings, {
   pillPages: array(string2()).default([]).transform((ids) => ids.filter((id) => pillPageSchema.safeParse(id).success)),
   foodDiaryMode: boolean2().default(false),
   calendarZoom: number2().int().nullable().default(null),
+  glass: settingsGlassSchema.default("liquid"),
+  followSky: boolean2().default(true),
+  nightUntilWake: boolean2().default(false),
+  largerText: boolean2().default(false),
+  reduceMotion: boolean2().default(false),
+  showStreakNumbers: boolean2().default(true),
+  themePack: themePackSchema.default("do"),
+  themePackScope: themePackScopeSchema.default("section"),
   createdAt: exports_coerce.date(),
   updatedAt: exports_coerce.date()
 }).omit({ autoRollOverdue: true });
@@ -38935,7 +39477,15 @@ var updateUserSettingsInputSchema = createUpdateSchema(userSettings, {
   quietHours: quietHoursSchema.nullish(),
   lifeBlockSharing: lifeBlockSharingSchema.nullish(),
   calendarZoom: calendarZoomSchema.nullish(),
-  pillPages: array(pillPageSchema).transform((ids) => [...new Set(ids)]).pipe(array(pillPageSchema).max(PILL_PAGES_MAX)).optional()
+  pillPages: array(pillPageSchema).transform((ids) => [...new Set(ids)]).pipe(array(pillPageSchema).max(PILL_PAGES_MAX)).optional(),
+  glass: settingsGlassSchema.optional(),
+  followSky: boolean2().optional(),
+  nightUntilWake: boolean2().optional(),
+  largerText: boolean2().optional(),
+  reduceMotion: boolean2().optional(),
+  showStreakNumbers: boolean2().optional(),
+  themePack: themePackSchema.optional(),
+  themePackScope: themePackScopeSchema.optional()
 }).omit({
   id: true,
   tenantId: true,
@@ -39395,6 +39945,66 @@ var taskBlockOperations = defineOperations({
   }
 });
 
+// ../../packages/schema/src/operations/task-series.ts
+var taskSeriesOperations = defineOperations({
+  make: {
+    method: "post",
+    path: "/tasks/{id}/make-series",
+    scopes: ["tasks:write"],
+    tag: "Tasks",
+    summary: "Make a task the first of a series",
+    description: "The task (by id or ref, `DO-150`) becomes slot 0 of a new series on `rule` (every N weeks, months or years; a quarter is 3 months), its Deadline (else its planned day, else today) the first slot. Its Area, Project, labels, priority, estimate, Owner and sub-task titles are the template each next task copies; the next is made `leadDays` before its slot and named by `occurrenceLabel` (`quarter`, `month`, `date`). A task already in a series is a 409.",
+    body: makeTaskSeriesInputSchema,
+    status: 201,
+    response: { description: "The series, with its strip." },
+    errors: { 400: true, 404: true, 409: true }
+  },
+  list: {
+    method: "get",
+    path: "/task-series",
+    scopes: ["tasks:read"],
+    tag: "Tasks",
+    summary: "List task series",
+    description: "The Space's task series, stopped ones too: each with its rhythm in words, its settings, how many tasks it made and its strip (up to two past occurrences, the latest, and the next with the day it's made).",
+    status: 200,
+    response: { description: "The series." }
+  },
+  get: {
+    method: "get",
+    path: "/task-series/{id}",
+    scopes: ["tasks:read"],
+    tag: "Tasks",
+    summary: "Show a task series",
+    description: "One series with its settings and its strip.",
+    status: 200,
+    response: { description: "The series." },
+    errors: { 404: true }
+  },
+  update: {
+    method: "patch",
+    path: "/task-series/{id}",
+    scopes: ["tasks:write"],
+    tag: "Tasks",
+    summary: "Update a task series",
+    description: "Rename it, change its rhythm, naming or lead days, or stop (`active: false`) and resume it.",
+    body: updateTaskSeriesInputSchema,
+    status: 200,
+    response: { description: "The series." },
+    errors: { 400: true, 404: true }
+  },
+  stop: {
+    method: "delete",
+    path: "/task-series/{id}",
+    scopes: ["tasks:write"],
+    tag: "Tasks",
+    summary: "Stop a task series",
+    description: "No more tasks are made; every task it made stays.",
+    status: 204,
+    response: { description: "Stopped." },
+    errors: { 404: true }
+  }
+});
+
 // ../../packages/schema/src/operations/tasks.ts
 var taskListQuery = taskListQuerySchema.extend(paginationQuerySchema.shape).extend({ filter: taskListFilterSchema.optional().default("all") });
 var taskOperations = defineOperations({
@@ -39498,7 +40108,7 @@ var taskOperations = defineOperations({
     scopes: ["tasks:read"],
     tag: "Tasks",
     summary: "Get a task",
-    description: "Fetch one task by id (ULID) or by its ref (`DO-142`, case-insensitive).",
+    description: "Fetch one task by id (ULID) or by its ref (`DO-142`, case-insensitive). A repeating task carries its rule as `recurrence` (null for a one-off).",
     status: 200,
     response: { description: "The task." },
     errors: { 404: true }
@@ -39509,7 +40119,7 @@ var taskOperations = defineOperations({
     scopes: ["tasks:write"],
     tag: "Tasks",
     summary: "Create a task",
-    description: "Create a task; fires the `task.created` webhook.",
+    description: "Create a task; fires the `task.created` webhook. An optional `recurrence` makes it repeat: `freq` daily/weekly/monthly, `interval`, `byDay` / `byMonthDay` for a `fixed` (calendar) series, or `anchor: from_completion` (the next one is due `interval` after the last was done).",
     body: createTaskInputSchema,
     status: 201,
     response: { description: "The created task." },
@@ -39522,7 +40132,7 @@ var taskOperations = defineOperations({
     scopes: ["tasks:write"],
     tag: "Tasks",
     summary: "Update a task",
-    description: "Patch a task; fires the `task.updated` webhook.",
+    description: 'Patch a task; fires the `task.updated` webhook. `recurrence` sets or changes its repeat rule and `recurrence: null` ends the series (the done history stays). On a repeating task `status: "done"` finishes the open occurrence; the task stays open for the next one.',
     body: updateTaskInputSchema,
     status: 200,
     response: { description: "The updated task." },
@@ -39692,6 +40302,67 @@ var todayOperations = defineOperations({
   }
 });
 
+// ../../packages/schema/src/contracts/waste-calendar.ts
+var WASTE_KIND_VALUES = ["rest", "pmd", "paper", "garden", "glass", "other"];
+var wasteKindSchema = _enum2(WASTE_KIND_VALUES);
+var civilDate3 = exports_iso.date();
+var wasteCollectionSchema = object({
+  date: civilDate3,
+  kinds: array(wasteKindSchema).min(1),
+  movedBy: string2().min(1).optional()
+});
+var wasteCalendarConnectInputSchema = object({
+  feedUrl: url({ protocol: /^https?$/ }).max(2000)
+}).strict();
+var wasteCalendarNextQuerySchema = object({
+  limit: exports_coerce.number().int().min(1).max(12).default(4)
+});
+var wasteCalendarNextItemSchema = wasteCollectionSchema.extend({
+  kindsWords: string2().min(1),
+  binsOutAt: string2().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}$/)
+});
+var wasteCalendarNextSchema = object({
+  connected: boolean2(),
+  collections: array(wasteCalendarNextItemSchema),
+  lastSyncAt: exports_coerce.date().nullable(),
+  lastSyncLine: string2().nullable(),
+  lastError: string2().nullable()
+});
+
+// ../../packages/schema/src/operations/waste-calendar.ts
+var CONNECT3 = ["connections:write"];
+var AFTER3 = "`*` and `private:*` never grant `connections:write`: a key holds it by name, and a guest's key never does.";
+var wasteCalendarOperations = defineOperations({
+  connect: {
+    method: "post",
+    path: "/integrations/waste-calendar",
+    scopes: CONNECT3,
+    afterScopes: AFTER3,
+    tag: "Connections",
+    summary: "Connect the waste calendar",
+    description: "Keep the household's waste-collection iCal `feedUrl` (the municipality's or the waste app's), sealed, and read it now; it's read again every morning at 06:00. Connecting again replaces the URL. The URL is never returned. Answers what's next, as `next` does: a feed that can't be read still connects, with `lastError` saying why.",
+    body: wasteCalendarConnectInputSchema,
+    status: 200,
+    response: { description: "The next collections." },
+    errors: { 400: true, 403: true },
+    throttle: "strict",
+    mcp: false
+  },
+  next: {
+    method: "get",
+    path: "/integrations/waste-calendar/next",
+    scopes: ["settings:read"],
+    tag: "Connections",
+    summary: "The next waste collections",
+    description: 'The next `limit` (1\u201312, 4 by default) collection days from today in the connecting member\'s zone: each its `date`, `kinds` (`rest`, `pmd`, `paper`, `garden`, `glass`, `other`), `kindsWords` ("Rest and PMD", "Garden, moved by the holiday"), `movedBy` when the feed says why it moved, and `binsOutAt` (the evening before at 20:00, local). With `lastSyncAt`, `lastSyncLine` ("Today 06:00, every morning") and the last read\'s `lastError`; `connected: false` with none set up.',
+    query: [{ name: "limit", description: "How many collection days (1\u201312, default 4)." }],
+    querySchema: wasteCalendarNextQuerySchema,
+    status: 200,
+    response: { description: "The next collections." },
+    errors: { 403: true }
+  }
+});
+
 // ../../packages/schema/src/db/webhooks.ts
 var webhookSubscriptions = pgTable("webhook_subscriptions", {
   id: text("id").primaryKey(),
@@ -40672,6 +41343,14 @@ function addMonths(d, months) {
 var TAG_RE = /(?:^|\s)#([\p{L}\p{N}][\p{L}\p{N}_-]*)/gu;
 var STAR_RE = /(?:^|\s)!(star|flag|s|f)?(?=\s|$)/giu;
 var AREA_RE = /(?:^|\s)~([\p{L}\p{N}][\p{L}\p{N}_-]*)/gu;
+var PRIORITY_RE = /(?:^|\s)(?:p([123])|!(high|medium|low))(?=\s|$)/giu;
+var PRIORITY_OF_P = { "1": "high", "2": "medium", "3": "low" };
+function capturePriority(token) {
+  const m = /^(?:p([123])|!(high|medium|low))$/iu.exec(token.trim());
+  if (!m)
+    return null;
+  return m[1] ? PRIORITY_OF_P[m[1]] ?? null : m[2]?.toLowerCase();
+}
 function parseCapture(input, now) {
   const tags = [];
   for (const match of input.matchAll(TAG_RE)) {
@@ -40692,7 +41371,12 @@ function parseCapture(input, now) {
       break;
     }
   }
-  let stripped = blankMatches(input, [TAG_RE, STAR_RE, AREA_RE]);
+  let priority;
+  for (const match of input.matchAll(PRIORITY_RE)) {
+    priority = capturePriority(match[0]) ?? undefined;
+    break;
+  }
+  let stripped = blankMatches(input, [TAG_RE, STAR_RE, AREA_RE, PRIORITY_RE]);
   const when = now ? parseWhen(stripped, now) : undefined;
   if (when) {
     for (const span of [...when.spans].sort((a, b) => b.start - a.start)) {
@@ -40705,6 +41389,7 @@ function parseCapture(input, now) {
     tags,
     ...starred ? { starred } : {},
     ...area ? { area } : {},
+    ...priority ? { priority } : {},
     ...when?.scheduledAt ? { scheduledAt: when.scheduledAt, allDay: when.allDay } : {},
     ...when?.dueAt ? { dueAt: when.dueAt, ...when.scheduledAt ? {} : { allDay: when.dueAllDay } } : {},
     ...when?.durationMinutes ? { durationMinutes: when.durationMinutes } : {},
@@ -41399,7 +42084,7 @@ function renderHabit(data, mode) {
   const pct = typeof streak?.completionRate === "number" ? ` \xB7 ${Math.round(streak.completionRate * 100)}% lately` : "";
   const recovering = streak?.state === "recovering" ? paint(mode, "yellow", " \xB7 recovering") : "";
   const counts = streak ? ` \xB7 streak ${streak.current ?? 0} (best ${streak.longest ?? 0})` : "";
-  const rest = h.pause ? ` \xB7 ${h.pause.by === "away" ? "away" : "paused"}, back ${h.pause.until}` : streak?.skippedToday ? " \xB7 rest day" : "";
+  const rest = h.pause ? ` \xB7 ${h.pause.by === "away" ? "away" : "paused"}${h.pause.until ? `, back ${h.pause.until}` : " until resumed"}` : streak?.skippedToday ? " \xB7 rest day" : "";
   const last = h.lastCheckIn?.id ? `
   ${paint(mode, "dim", `last check-in ${h.lastCheckIn.id}`)}${h.lastCheckIn.note ? ` "${h.lastCheckIn.note}"` : ""}` : "";
   return `${h.title ?? "(habit)"} \u2014 ${flame}${pct}${counts}${recovering}${rest}
@@ -41441,10 +42126,11 @@ function renderKeys(data, mode) {
     return paint(mode, "dim", "(no keys)");
   return keys.map((key) => {
     const scopes = key.scopes ?? [];
-    const reach = sayFullAccess(scopes) ?? (scopes.join(", ") || "(no scopes)");
+    const reach = key.scopeLine || sayFullAccess(scopes) || scopes.join(", ") || "(no scopes)";
+    const expires = key.expiresAt ? paint(mode, "dim", ` \xB7 expires ${key.expiresAt.slice(0, 10)}`) : "";
     const changed = key.changes?.[0] ? paint(mode, "dim", ` \xB7 changed ${key.changes[0].at.slice(0, 10)}`) : "";
     return `${key.name}  ${paint(mode, "dim", key.id)}
-  ${reach}${changed}`;
+  ${reach}${expires}${changed}`;
   }).join(`
 `);
 }
@@ -44845,6 +45531,32 @@ var CONNECTION_COMMAND_SPECS = [
     returns: "MoneyKrakenLinkStatus",
     notes: `${routeOf(krakenLinkOperations.remove)}. Gated behind --allow-destructive.`
   },
+  {
+    path: ["connections", "waste", "next"],
+    summary: "The next waste collections: each day's kinds in words and when the bins go out (the evening before, at 20:00).",
+    args: [],
+    flags: [
+      { name: "limit", type: "string", description: "How many collection days (1\u201312, default 4)." }
+    ],
+    scopes: scopesOf(wasteCalendarOperations.next),
+    returns: "WasteCalendarNext",
+    notes: `${routeOf(wasteCalendarOperations.next)}. A pickup that moved says why ("Garden, moved by the holiday").`
+  },
+  {
+    path: ["connections", "waste", "connect"],
+    summary: "Connect the household's waste calendar: its iCal feed URL, read from a file, then read it.",
+    args: [],
+    flags: [
+      {
+        name: "feed-file",
+        type: "string",
+        description: "Path to a file holding the feed's URL (one line), or - to read it from stdin."
+      }
+    ],
+    scopes: scopesOf(wasteCalendarOperations.connect),
+    returns: "WasteCalendarNext",
+    notes: `${routeOf(wasteCalendarOperations.connect)}. The URL can carry a private token, so it's read from the file and sealed; it is never a flag, never printed and never read back. It's read again every morning at 06:00; connecting again replaces it.`
+  },
   {
     path: ["doccle", "connect"],
     summary: "Give do your Doccle login so the nightly import can run. do checks it with Doccle first and keeps it sealed.",
@@ -44977,6 +45689,24 @@ var CONNECTION_HANDLERS = {
     data: await guarded([], () => requireClient().get(pathOf(krakenLinkOperations.status))),
     render: renderKraken
   }),
+  "connections waste next": async ({ flags, requireClient }) => {
+    const limit = flagString(flags, "limit");
+    if (limit !== undefined && !/^\d+$/.test(limit))
+      throw usageError("--limit takes a number (1\u201312)");
+    const path = `${pathOf(wasteCalendarOperations.next)}${limit ? `?limit=${limit}` : ""}`;
+    return {
+      data: await guarded([], () => requireClient().get(path)),
+      render: renderWaste
+    };
+  },
+  "connections waste connect": async ({ io, flags, requireClient }) => {
+    refuseSecretFlags(flags, ["url", "feed", "feed-url"], "--feed-file <path>");
+    const feedUrl = (await readSecret(io, flags, "feed-file", "the feed's URL", "line")).trim();
+    return {
+      data: await guarded([feedUrl], () => requireClient().post(pathOf(wasteCalendarOperations.connect), { feedUrl })),
+      render: renderWaste
+    };
+  },
   "money kraken-link set": async ({ io, flags, requireClient }) => {
     refuseSecretFlags(flags, ["key", "api-key", "secret", "api-secret", "private-key"], "--key-file <path>");
     const text = await readSecret(io, flags, "key-file", "the Kraken key", "all");
@@ -45063,6 +45793,30 @@ function refuseSecretFlags(flags, names, instead) {
     }
   }
 }
+function renderWaste(data, mode) {
+  const next = data;
+  if (!next || !Array.isArray(next.collections))
+    return renderRecord(data, mode);
+  if (!next.connected)
+    return "No waste calendar connected. Run do connections waste connect.";
+  const day = (iso) => new Date(`${iso.slice(0, 10)}T12:00:00Z`).toLocaleDateString("en-GB", {
+    weekday: "short",
+    day: "numeric",
+    month: "short",
+    timeZone: "UTC"
+  });
+  const weekday = (iso) => new Date(`${iso.slice(0, 10)}T12:00:00Z`).toLocaleDateString("en-GB", {
+    weekday: "short",
+    timeZone: "UTC"
+  });
+  const lines = next.collections.map((c) => `${day(c.date)} \xB7 ${c.kindsWords} \xB7 bins out ${weekday(c.binsOutAt)} ${c.binsOutAt.slice(11)}`);
+  return [
+    ...lines.length > 0 ? lines : ["No collections coming up."],
+    ...next.lastSyncLine ? [`Read: ${next.lastSyncLine}`] : [],
+    ...next.lastError ? [`Last read failed: ${next.lastError}`] : []
+  ].join(`
+`);
+}
 async function readSecret(io, flags, flag, what, take) {
   const path = flagString(flags, flag);
   if (path === undefined || path.length === 0) {
@@ -46447,6 +47201,45 @@ var commands16 = [
   }
 ];
 
+// ../../packages/domain/src/date.ts
+var formatters = new Map;
+function dateTimeFormat(locale, options) {
+  const key = `${locale ?? ""}|${JSON.stringify(options)}`;
+  let formatter = formatters.get(key);
+  if (!formatter) {
+    formatter = new Intl.DateTimeFormat(locale, options);
+    formatters.set(key, formatter);
+  }
+  return formatter;
+}
+var STYLES = ["dateStyle", "timeStyle"];
+var DATE_FIELDS = ["weekday", "year", "month", "day", ...STYLES];
+var CLOCK_PARTS = new Set(["hour", "minute", "second", "fractionalSecond", "dayPeriod"]);
+function dayInZone(now, zone) {
+  return dateTimeFormat("en-CA", {
+    timeZone: zone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).format(now);
+}
+function dayOfUtc(t) {
+  const d = new Date(t);
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())}`;
+}
+function utcOfDay(day) {
+  const [y, m, d] = day.split("-").map(Number);
+  return Date.UTC(y, m - 1, d);
+}
+function shiftDay2(day, n) {
+  return dayOfUtc(utcOfDay(day) + n * 86400000);
+}
+function mondayOfDay(day) {
+  const weekday = (new Date(utcOfDay(day)).getUTCDay() + 6) % 7;
+  return shiftDay2(day, -weekday);
+}
+
 // src/commands/food.ts
 var commands17 = [
   {
@@ -46606,6 +47399,86 @@ var commands17 = [
       };
     }
   },
+  {
+    spec: {
+      path: ["food", "menu"],
+      summary: "Show the week menu: each day's dinner and lunch with who cooks and its state, the counts, the leftovers and next week's draft.",
+      args: [],
+      flags: [
+        {
+          name: "start",
+          type: "string",
+          description: "Any day of the week (YYYY-MM-DD); this week by default."
+        }
+      ],
+      scopes: [...mealPlanOperations.week.scopes],
+      returns: "MealWeek",
+      notes: `${routeOf(mealPlanOperations.week)}. A draft dinner's \`why\` is its plan's notes; write drafts with \`do meal-plans create\` and state "draft".`
+    },
+    run: async ({ flags, requireClient }) => {
+      const start = flagString(flags, "start");
+      return {
+        data: await requireClient().get(pathOf(mealPlanOperations.week), {
+          query: { start }
+        }),
+        render: renderRecord
+      };
+    }
+  },
+  {
+    spec: {
+      path: ["food", "plans"],
+      summary: "List meal plans, by recipe and state: --recipe <id> --state cooked is who cooked it when.",
+      args: [],
+      flags: [
+        { name: "recipe", type: "string", description: "Only this recipe's plans (its ULID)." },
+        {
+          name: "state",
+          type: "string",
+          description: "Only this state: planned, cooked, out, unsure or draft."
+        }
+      ],
+      scopes: [...mealPlanOperations.list.scopes],
+      returns: "MealPlan",
+      notes: `${routeOf(mealPlanOperations.list)}. \`cookUserId\` is who cooked it; \`notes\` is the plan's note.`
+    },
+    run: async ({ flags, requireClient }) => {
+      const query = parseInput(mealPlanListQuerySchema, {
+        recipeId: flagString(flags, "recipe"),
+        state: flagString(flags, "state")
+      });
+      return {
+        data: await requireClient().get(pathOf(mealPlanOperations.list), { query }),
+        render: renderRecord
+      };
+    }
+  },
+  {
+    spec: {
+      path: ["food", "draft", "accept"],
+      summary: "Accept a week's draft menu: its draft dinners become planned ones.",
+      args: [],
+      flags: [
+        {
+          name: "start",
+          type: "string",
+          description: "Any day of the week (YYYY-MM-DD); next week by default."
+        }
+      ],
+      scopes: [...mealPlanOperations.acceptDraft.scopes],
+      returns: "MealWeek",
+      notes: `${routeOf(mealPlanOperations.acceptDraft)}. Idempotent: a week with no drafts left is unchanged.`
+    },
+    run: async ({ flags, requireClient }) => {
+      const zone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+      const start = flagString(flags, "start") ?? shiftDay2(mondayOfDay(dayInZone(new Date, zone)), 7);
+      const body = parseInput(acceptMealDraftInputSchema, { start });
+      return {
+        data: await requireClient().post(pathOf(mealPlanOperations.acceptDraft), body),
+        render: renderRecord
+      };
+    }
+  },
   {
     spec: {
       path: ["food", "week-read"],
@@ -47052,9 +47925,19 @@ var SCHEDULE_FLAGS = [
     type: "string",
     description: "Due monthly on this day of the month: 1\u201331 (a 31 falls on a shorter month's last day), or last."
   },
+  {
+    name: "time",
+    type: "string",
+    description: "When in the day: a 24-hour time (16:30) or a part of day (morning, midday, evening); none clears it."
+  },
+  {
+    name: "for",
+    type: "string",
+    description: "How long it takes (15m, 1h, 1h30m; 1\u2013600 minutes); none clears it back to 15m."
+  },
   { name: "data", type: "string", description: "JSON for any other field of the contract." }
 ];
-var SCHEDULE_NOTES = "One of --every-day, --on mo,we,fr, --every 3d|2w [--from YYYY-MM-DD], --monthly 1|last sets its schedule; days it isn't due never break the streak. Without one, it keeps `period` + `frequencyCount` (3\xD7 a week). The reply's `nextDue` lists its next 4 due days.";
+var SCHEDULE_NOTES = "One of --every-day, --on mo,we,fr, --every 3d|2w [--from YYYY-MM-DD], --monthly 1|last sets its schedule; days it isn't due never break the streak. Without one, it keeps `period` + `frequencyCount` (3\xD7 a week). The reply's `nextDue` lists its next 4 due days. --time 16:30|morning|midday|evening and --for 20m put it on your do calendar at that time on each due day (a part of day at 08:00, 12:30 or 19:00; 15 minutes without --for).";
 function localToday() {
   const now = new Date;
   const pad = (n) => String(n).padStart(2, "0");
@@ -47094,11 +47977,31 @@ function scheduleFromFlags(flags, today = localToday()) {
   }
   return;
 }
+function minutesFromFlag(raw) {
+  const text = raw.trim().toLowerCase();
+  const m = /^(?:(\d+)\s*h)?\s*(?:(\d+)\s*m?)?$/.exec(text);
+  if (!text || !m || m[1] === undefined && m[2] === undefined)
+    throw usageError("--for takes a length like 15m, 1h or 1h30m");
+  return Number(m[1] ?? 0) * 60 + Number(m[2] ?? 0);
+}
+function timingFromFlags(flags) {
+  const time = flagString(flags, "time");
+  const length = flagString(flags, "for");
+  const out = {};
+  if (time !== undefined) {
+    const t = time.trim().toLowerCase();
+    out.timeOfDay = t === "none" ? null : /^\d:\d\d$/.test(t) ? `0${t}` : t;
+  }
+  if (length !== undefined) {
+    out.durationMinutes = length.trim().toLowerCase() === "none" ? null : minutesFromFlag(length);
+  }
+  return out;
+}
 var commands20 = [
   {
     spec: {
       path: ["habits", "create"],
-      summary: "Create a habit, with an optional schedule (every day, weekdays, every N, monthly).",
+      summary: "Create a habit, with an optional schedule (every day, weekdays, every N, monthly), time and length.",
       args: [{ name: "title", required: false, description: "The habit's title." }],
       flags: SCHEDULE_FLAGS,
       scopes: [...habitOperations.create.scopes],
@@ -47113,7 +48016,8 @@ var commands20 = [
         measurementType: "binary",
         ...title ? { title } : {},
         ...readDataFlag(flags),
-        ...schedule ? { schedule } : {}
+        ...schedule ? { schedule } : {},
+        ...timingFromFlags(flags)
       });
       if (flagBool(flags, "dry-run")) {
         return {
@@ -47130,7 +48034,7 @@ var commands20 = [
   {
     spec: {
       path: ["habits", "update"],
-      summary: "Change a habit: its schedule (--every-day, --on, --every, --monthly) or --data.",
+      summary: "Change a habit: its schedule (--every-day, --on, --every, --monthly), --time, --for or --data.",
       args: [{ name: "id", required: true, description: "Habit ULID." }],
       flags: SCHEDULE_FLAGS,
       scopes: [...habitOperations.update.scopes],
@@ -47142,10 +48046,11 @@ var commands20 = [
       const schedule = scheduleFromFlags(flags);
       const body = parseInput(updateHabitInputSchema, {
         ...readDataFlag(flags),
-        ...schedule ? { schedule } : {}
+        ...schedule ? { schedule } : {},
+        ...timingFromFlags(flags)
       });
       if (Object.keys(body).length === 0)
-        throw usageError("nothing to change \u2014 pass a schedule flag such as --on mo,we, or --data");
+        throw usageError("nothing to change \u2014 pass a schedule flag such as --on mo,we, --time, --for, or --data");
       const client = requireClient();
       if (flagBool(flags, "dry-run")) {
         const before = await client.get(pathOf(habitOperations.get, { id }));
@@ -47322,10 +48227,39 @@ var commands20 = [
       flags: [],
       scopes: [...habitOperations.today.scopes],
       returns: "HabitsTodayResponse",
-      notes: `${routeOf(habitOperations.today)}. Your saved time zone's day; already filtered by schedule. Each habit says done/open/skipped (never overdue), its value today, the week for an N-per-week habit and its last check-in (\`by\` names the Agent). Quit habits are left out.`
+      notes: `${routeOf(habitOperations.today)}. Your saved time zone's day; already filtered by schedule. Each habit says done/open/skipped (never overdue), its value today, the week for an N-per-week habit and its last check-in (\`by\` names the Agent). Quit habits are left out of \`groups\`. The Habits section rides along: \`moments\` (morning, day, evening; each habit inside its routine, with \`scheduleWords\`, today's \`amount\`, a 14-day \`strip\` oldest first where a day it isn't due is \`not_due\`, never \`missed\`, its \`streak\` in days, in a row or since, and its \`routineStep\`), \`notDue\` (every live, unpaused habit off today, by \`nextDue\`), this Monday-to-Sunday \`week\` (due habits only; a day after today has \`done: null\`) and \`totals\`.`
     },
     run: readOperation(habitOperations.today, renderHabitsToday)
   },
+  {
+    spec: {
+      path: ["habits", "due"],
+      summary: "Each habit's due days in a range, by its schedule (Plan's Month and agendas).",
+      args: [],
+      flags: [
+        { name: "from", type: "string", description: "The first day (YYYY-MM-DD). Required." },
+        {
+          name: "to",
+          type: "string",
+          description: "The last day (YYYY-MM-DD), at most 62 days on. Required."
+        }
+      ],
+      scopes: [...habitOperations.due.scopes],
+      returns: "HabitDueDate[]",
+      notes: `${routeOf(habitOperations.due)}?from=&to=. Your saved time zone's days, both ends included. One row per habit per due day: \`time\` (HH:MM or null), \`scheduleLabel\`, \`daily\` (due every day) and \`streakLabel\` (\`N days\` daily, \`N in a row\` otherwise). Paused days, quit and event-scheduled habits are left out.`
+    },
+    run: async ({ flags, requireClient }) => {
+      const from = flagString(flags, "from");
+      const to = flagString(flags, "to");
+      if (from === undefined || to === undefined) {
+        throw usageError("habits due needs --from and --to");
+      }
+      return {
+        data: await requireClient().get(pathOf(habitOperations.due), { query: { from, to } }),
+        render: renderList
+      };
+    }
+  },
   {
     spec: {
       path: ["habit", "check-ins"],
@@ -47388,6 +48322,32 @@ var commands20 = [
       };
     }
   },
+  {
+    spec: {
+      path: ["habit", "undo"],
+      summary: "Undo a wrong or test check-in (or a skip); the streak recomputes.",
+      args: [
+        { name: "id", required: true, description: "Habit ULID." },
+        {
+          name: "entry-id",
+          required: true,
+          description: "The check-in's ULID (`do habit check-ins <id>`, or lastCheckIn.id)."
+        }
+      ],
+      flags: [],
+      scopes: [...habitOperations.removeCheckIn.scopes],
+      returns: "HabitSummary",
+      notes: `${routeOf(habitOperations.removeCheckIn)}. The check-in must be this habit's: another habit's, or one already gone, is a 404. Prints the refreshed habit.`
+    },
+    run: async ({ args, requireClient }) => {
+      const id = requireArg(args, 0, "habit id");
+      const entryId = requireArg(args, 1, "check-in id");
+      return {
+        data: await requireClient().delete(pathOf(habitOperations.removeCheckIn, { id, entryId })),
+        render: renderHabit
+      };
+    }
+  },
   {
     spec: {
       path: ["habit", "skip"],
@@ -47481,25 +48441,23 @@ var commands20 = [
   {
     spec: {
       path: ["habit", "pause"],
-      summary: "Pause a habit until the day it's back: off Now, no push, the plant waits.",
+      summary: "Pause a habit until the day it's back, or until resumed: off Now, no push, the plant waits.",
       args: [{ name: "id", required: true, description: "Habit ULID." }],
       flags: [
         {
           name: "until",
           type: "string",
-          description: "The day it's back (YYYY-MM-DD), after today. Required."
+          description: "The day it's back (YYYY-MM-DD), after today. Leave it out to pause until `habit resume`."
         }
       ],
       scopes: [...habitOperations.pause.scopes],
       returns: "HabitSummary",
-      notes: `${routeOf(habitOperations.pause)}. Pausing a paused habit moves the day it's back. Paused days are neutral: the streak is frozen, never broken.`
+      notes: `${routeOf(habitOperations.pause)}. Without --until the pause is open-ended: it lasts until \`habit resume\`. Pausing a paused habit moves the day it's back. Paused days are neutral: the streak is frozen, never broken.`
     },
     run: async ({ args, flags, requireClient }) => {
       const id = requireArg(args, 0, "habit id");
       const until = flagString(flags, "until");
-      if (!until)
-        throw usageError("habit pause needs --until <YYYY-MM-DD>, the day it's back");
-      const input = parseInput(habitPauseInputSchema, { until });
+      const input = parseInput(habitPauseInputSchema, until ? { until } : {});
       return {
         data: await requireClient().post(pathOf(habitOperations.pause, { id }), input),
         render: renderHabit
@@ -49596,6 +50554,17 @@ var commands25 = [
 ];
 
 // src/commands/keys.ts
+function renderCreatedKey(data, mode) {
+  const key = data.data ?? data;
+  if (!key?.key)
+    return renderRecord(data, mode);
+  return [
+    `${key.name}: ${key.scopeLine || "(no scopes)"}`,
+    key.expiresAt ? `Expires ${key.expiresAt.slice(0, 10)}.` : "Never expires.",
+    `Key (shown once): ${key.key}`
+  ].join(`
+`);
+}
 var commands26 = [
   {
     spec: {
@@ -49609,6 +50578,57 @@ var commands26 = [
     },
     run: readOperation(keyOperations.list, renderKeys, {}, { paged: true })
   },
+  {
+    spec: {
+      path: ["keys", "create"],
+      summary: "Mint an API key by section, each read or write, with an optional expiry. Prints the key once.",
+      args: [],
+      flags: [
+        { name: "name", type: "string", description: "What the key is for (e.g. 'CI deploy')." },
+        {
+          name: "section",
+          type: "string",
+          description: "A section and its access, <section>:<read|write>, repeated: today, plan, work, habits, journal, home, food, collection, money, health, people, animals, agents, settings."
+        },
+        {
+          name: "expires",
+          type: "string",
+          description: "When it stops working, a date (YYYY-MM-DD). Left out: never."
+        }
+      ],
+      scopes: [...keyOperations.create.scopes],
+      returns: "ApiKeyCreated",
+      notes: "The key is for the member behind this key, never more than this key holds (exit 3), never an Agent's. The secret is printed once, then never again; past its expiry the key gets 401 'This token expired on <date>'."
+    },
+    run: async ({ flags, requireClient }) => {
+      const name = flagString(flags, "name");
+      if (!name)
+        throw usageError("keys create needs --name <name>");
+      const sections = flagStrings(flags, "section").map((raw) => {
+        const [section, access] = raw.split(":").map((part) => part.trim());
+        if (!section || access !== "read" && access !== "write") {
+          throw usageError(`--section takes <section>:<read|write>, not '${raw}'`);
+        }
+        return { section, access };
+      });
+      if (sections.length === 0) {
+        throw usageError("keys create needs at least one --section <section>:<read|write>");
+      }
+      const expires = flagString(flags, "expires");
+      if (expires !== undefined && !/^\d{4}-\d{2}-\d{2}$/.test(expires)) {
+        throw usageError("--expires takes a date, YYYY-MM-DD");
+      }
+      const body = {
+        name,
+        sections,
+        ...expires ? { expiresAt: `${expires}T00:00:00.000Z` } : {}
+      };
+      return {
+        data: await requireClient().post(pathOf(keyOperations.create), body),
+        render: renderCreatedKey
+      };
+    }
+  },
   {
     spec: {
       path: ["keys", "update"],
@@ -49629,7 +50649,7 @@ var commands26 = [
       ],
       scopes: [...keyOperations.update.scopes],
       returns: "ApiKey",
-      notes: "A key never grants more than it holds: it can't widen its own scopes or change a key that reaches further (exit 3). Every change is recorded on the key. Minting and revoking stay in the app."
+      notes: "A key never grants more than it holds: it can't widen its own scopes or change a key that reaches further (exit 3). Every change is recorded on the key. Revoking stays in the app."
     },
     run: async ({ args, flags, requireClient }) => {
       const id = requireArg(args, 0, "key id");
@@ -53622,7 +54642,9 @@ function renderRoutinesToday(data, mode) {
     const steps = r.steps.map((s) => {
       const meta = s.meta ? paint(mode, "dim", ` \xB7 ${s.meta}`) : "";
       const kind = s.kind === "step" ? "" : ` [${s.kind}]`;
-      return `    ${s.done ? "\u2713" : "\u25CB"} ${s.n}. ${s.title}${kind}${meta}`;
+      const optional = s.optional ? " (optional)" : "";
+      const indent = "  ".repeat(s.depth ?? 0);
+      return `    ${indent}${s.done ? "\u2713" : "\u25CB"} ${s.n}. ${s.title}${kind}${optional}${meta}`;
     });
     return [head, ...steps].join(`
 `);
@@ -53634,7 +54656,418 @@ function renderRoutineTaskAdded(data) {
   const last = run.steps?.at(-1)?.title ?? "the task";
   return `${run.routineTitle ?? "(routine)"}: ${last} is the last step of today's run.`;
 }
+var STEP_GRAMMAR = "A step is `habit:<habit id>` (a habit step, titled after the habit), `task:<task id>` (a Work task step, titled after the task), `routine:<routine id>` (a nested routine, titled after it: a run walks its steps in this place) or any other text (a plain step with that title).";
+var ROUTINE_FLAGS = [
+  { name: "kind", type: "string", description: "sequence, time_blocked or checklist." },
+  { name: "area", type: "string", description: "The Area's ULID (`none` unfiles it)." },
+  { name: "notes", type: "string", description: "The routine's notes." },
+  { name: "data", type: "string", description: "JSON (or @file) with the rest of the input." }
+];
+function routineFields(flags) {
+  const out = { ...readDataFlag(flags) };
+  const title = flagString(flags, "title");
+  const kind = flagString(flags, "kind");
+  const area = flagString(flags, "area");
+  const notes = flagString(flags, "notes");
+  if (title !== undefined)
+    out.title = title;
+  if (kind !== undefined)
+    out.kind = kind;
+  if (area !== undefined)
+    out.areaId = area === "none" ? null : area;
+  if (notes !== undefined)
+    out.notes = notes;
+  return out;
+}
+var LINK_PATH = {
+  habit: habitOperations.get,
+  task: taskOperations.get,
+  routine: routineOperations.get
+};
+async function stepFrom(client, item, title) {
+  const link = /^(habit|task|routine):(\S+)$/.exec(item.trim());
+  if (!link) {
+    const text = (title ?? item).trim();
+    if (!text)
+      throw usageError("a step needs a title");
+    return { id: ulid3(), title: text, refKind: "free" };
+  }
+  const kind = link[1];
+  const id = link[2];
+  const named = title ?? (await client.get(pathOf(LINK_PATH[kind], { id }))).title ?? kind;
+  if (kind === "habit")
+    return { id: ulid3(), title: named, refKind: "habit", habitId: id };
+  if (kind === "task")
+    return { id: ulid3(), title: named, refKind: "task", taskId: id };
+  return { id: ulid3(), title: named, refKind: "routine", childRoutineId: id };
+}
+function stepInput(step, sortOrder) {
+  return {
+    id: step.id,
+    title: step.title,
+    refKind: step.refKind,
+    habitId: step.refKind === "habit" ? step.habitId : null,
+    taskId: step.refKind === "task" ? step.taskId : null,
+    childRoutineId: step.refKind === "routine" ? step.childRoutineId : null,
+    optional: step.optional,
+    sortOrder,
+    durationMinutes: step.durationMinutes,
+    notes: step.notes
+  };
+}
+function stepIndex(steps, token) {
+  const byId = steps.findIndex((s) => s.id === token);
+  if (byId >= 0)
+    return byId;
+  const n = Number(token);
+  if (Number.isInteger(n) && n >= 1 && n <= steps.length)
+    return n - 1;
+  throw usageError(`no step ${token} in this routine \u2014 name its id or its number`);
+}
+function positionOf(raw, max, name) {
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 1 || n > max) {
+    throw usageError(`${name} must be a number from 1 to ${max}`);
+  }
+  return n - 1;
+}
+function renderRoutine(data) {
+  const r = data;
+  const steps = (r.steps ?? []).map((s, i) => {
+    const kind = s.refKind === "free" ? "" : ` [${s.refKind}]`;
+    const optional = s.optional ? " (optional)" : "";
+    return `    ${i + 1}. ${s.title}${kind}${optional}  ${s.id}`;
+  });
+  return [
+    `${r.title ?? "(routine)"}  ${r.id}`,
+    ...steps.length ? steps : ["    (no steps)"]
+  ].join(`
+`);
+}
+function putSteps(client, id, steps) {
+  const body = parseInput(updateRoutineInputSchema, {
+    steps: steps.map((s, i) => ({ ...s, sortOrder: i }))
+  });
+  return client.patch(pathOf(routineOperations.update, { id }), body);
+}
+function ruleAt(recurrence, at, timezone) {
+  if (!/^([01]\d|2[0-3]):[0-5]\d$/.test(at))
+    throw usageError("--at takes a 24-hour time: 07:30");
+  if (!recurrence)
+    return { mode: "rigid", freq: "daily", interval: 1, timezone, timeOfDay: at };
+  const keep = {
+    mode: recurrence.mode,
+    timezone: recurrence.timezone,
+    interval: recurrence.interval,
+    freq: recurrence.freq,
+    byDay: recurrence.byDay,
+    until: recurrence.until,
+    count: recurrence.count,
+    unit: recurrence.unit,
+    anchor: recurrence.anchor
+  };
+  return {
+    ...Object.fromEntries(Object.entries(keep).filter(([, v]) => v !== null && v !== undefined)),
+    timeOfDay: at
+  };
+}
+function localZone() {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+}
+function readRoutine(client, id) {
+  return client.get(pathOf(routineOperations.get, { id }));
+}
+var routineCommands = [
+  {
+    spec: {
+      path: ["routines", "create"],
+      summary: "Create a routine with its steps.",
+      args: [{ name: "title", required: false, description: "The routine's title." }],
+      flags: [
+        ...ROUTINE_FLAGS,
+        { name: "step", type: "string", description: "A step, in order; repeat it. See grammar." }
+      ],
+      scopes: [...routineOperations.create.scopes],
+      returns: "RoutineView",
+      grammar: { step: STEP_GRAMMAR },
+      notes: `${routeOf(routineOperations.create)}. The id is minted when omitted; --data carries the rest of a CreateRoutineInput. A linked step's title is read from its habit or task. e.g. \`do routines create "Wind down" --step "Lights low" --step habit:<id>\`.`
+    },
+    run: async ({ args, flags, requireClient }) => {
+      const title = args.join(" ").trim();
+      const client = requireClient();
+      const steps = [];
+      for (const item of flagStrings(flags, "step"))
+        steps.push(await stepFrom(client, item));
+      const body = parseInput(createRoutineInputSchema, {
+        id: ulid3(),
+        ...title ? { title } : {},
+        ...routineFields(flags),
+        ...steps.length ? { steps: steps.map((s, i) => ({ ...s, sortOrder: i })) } : {}
+      });
+      if (flagBool(flags, "dry-run")) {
+        return {
+          data: { dryRun: true, op: "create", entity: "routines", after: body },
+          render: renderRecord
+        };
+      }
+      return {
+        data: await client.post(pathOf(routineOperations.create), body),
+        render: renderRoutine
+      };
+    }
+  },
+  {
+    spec: {
+      path: ["routines", "update"],
+      summary: "Change a routine: its title, kind, Area, notes, start time (--at), or --data.",
+      args: [{ name: "id", required: true, description: "Routine ULID." }],
+      flags: [
+        { name: "title", type: "string", description: "A new title." },
+        {
+          name: "at",
+          type: "string",
+          description: "Its start time, 24-hour (07:30); one that doesn't repeat starts daily."
+        },
+        ...ROUTINE_FLAGS
+      ],
+      scopes: [...routineOperations.update.scopes],
+      returns: "RoutineView",
+      notes: `${routeOf(routineOperations.update)}; --at is ${routeOf(routineOperations.attachRecurrence)} with the routine's rule as it is and its time moved (a routine that doesn't repeat yet becomes daily at that time, in this machine's zone). Only what you pass changes; its steps change with \`do routines steps\`. A routine at a time lands on your do calendar, each child routine and own step as its own event.`
+    },
+    run: async ({ args, flags, requireClient }) => {
+      const id = requireArg(args, 0, "routine id");
+      const at = flagString(flags, "at");
+      const body = parseInput(updateRoutineInputSchema, routineFields(flags));
+      if (Object.keys(body).length === 0 && at === undefined) {
+        throw usageError("nothing to change \u2014 pass --title, --kind, --area, --notes, --at or --data");
+      }
+      const client = requireClient();
+      if (at !== undefined) {
+        const before = await readRoutine(client, id);
+        const rule = parseInput(updateRecurrenceRuleInputSchema, ruleAt(before.recurrence, at.trim(), localZone()));
+        if (flagBool(flags, "dry-run")) {
+          return {
+            data: {
+              dryRun: true,
+              op: "update",
+              entity: "routines",
+              id,
+              before,
+              recurrence: rule,
+              changes: body
+            },
+            render: renderRecord
+          };
+        }
+        const timed = await client.put(pathOf(routineOperations.attachRecurrence, { id }), rule);
+        if (Object.keys(body).length === 0)
+          return { data: timed, render: renderRoutine };
+        return {
+          data: await client.patch(pathOf(routineOperations.update, { id }), body),
+          render: renderRoutine
+        };
+      }
+      if (flagBool(flags, "dry-run")) {
+        const before = await readRoutine(client, id);
+        return {
+          data: {
+            dryRun: true,
+            op: "update",
+            entity: "routines",
+            id,
+            before,
+            after: mergePreview(before, body),
+            changes: body
+          },
+          render: renderRecord
+        };
+      }
+      return {
+        data: await client.patch(pathOf(routineOperations.update, { id }), body),
+        render: renderRoutine
+      };
+    }
+  },
+  {
+    spec: {
+      path: ["routines", "steps", "set"],
+      summary: "Replace a routine's steps with a new ordered list, or --clear them all.",
+      args: [
+        { name: "id", required: true, description: "Routine ULID." },
+        { name: "steps", required: false, description: "The steps, in order. See grammar." }
+      ],
+      flags: [{ name: "clear", type: "boolean", description: "Empty the routine (no steps)." }],
+      scopes: [...routineOperations.update.scopes],
+      returns: "RoutineView",
+      grammar: { step: STEP_GRAMMAR },
+      notes: `${routeOf(routineOperations.update)} with \`steps\`, in one call. The habits and tasks the old steps linked are untouched; past runs keep their snapshot.`
+    },
+    run: async ({ args, flags, requireClient }) => {
+      const id = requireArg(args, 0, "routine id");
+      const items = args.slice(1);
+      const clear = flagBool(flags, "clear");
+      if (items.length === 0 && !clear) {
+        throw usageError("routines steps set needs the steps in order, or --clear to empty it");
+      }
+      if (items.length > 0 && clear)
+        throw usageError("--clear takes no steps");
+      const client = requireClient();
+      const steps = [];
+      for (const item of items)
+        steps.push(await stepFrom(client, item));
+      return { data: await putSteps(client, id, steps), render: renderRoutine };
+    }
+  },
+  {
+    spec: {
+      path: ["routines", "steps", "add"],
+      summary: "Add a step to a routine (or a nested routine), at the end or --at a position.",
+      args: [
+        { name: "id", required: true, description: "Routine ULID." },
+        {
+          name: "step",
+          required: false,
+          description: "The step. See grammar. Leave it out with --routine."
+        }
+      ],
+      flags: [
+        { name: "at", type: "string", description: "Its position, 1-based (default: last)." },
+        { name: "title", type: "string", description: "Its title (instead of the linked name)." },
+        {
+          name: "routine",
+          type: "string",
+          description: "Nest this routine (its ULID) as the step; same as `routine:<id>`."
+        },
+        {
+          name: "optional",
+          type: "boolean",
+          description: "An optional step: it never keeps the routine from being done."
+        }
+      ],
+      scopes: [...routineOperations.get.scopes, ...routineOperations.update.scopes],
+      returns: "RoutineView",
+      grammar: { step: STEP_GRAMMAR },
+      notes: `${routeOf(routineOperations.get)}, then ${routeOf(routineOperations.update)} with every step (the others keep their ids). A nested routine (\`--routine <id>\`) walks its steps in this place when the routine runs, to any depth; one that would contain itself is a 400. e.g. \`do routines steps add <morning> --routine <teeth> --optional\`.`
+    },
+    run: async ({ args, flags, requireClient }) => {
+      const id = requireArg(args, 0, "routine id");
+      const child = flagString(flags, "routine");
+      const words = args.slice(1).join(" ").trim();
+      if (child && words)
+        throw usageError("--routine is the step; pass no other step with it");
+      const item = child ? `routine:${child}` : words;
+      if (!item)
+        throw usageError("routines steps add needs the step: `habit:<id>`, `task:<id>`, `routine:<id>` (or --routine <id>) or a title");
+      const client = requireClient();
+      const routine = await readRoutine(client, id);
+      const steps = routine.steps.map((s, i) => stepInput(s, i));
+      const at = flagString(flags, "at");
+      const index = at === undefined ? steps.length : positionOf(at, steps.length + 1, "--at");
+      const step = await stepFrom(client, item, flagString(flags, "title"));
+      if (flagBool(flags, "optional"))
+        step.optional = true;
+      steps.splice(index, 0, step);
+      return { data: await putSteps(client, id, steps), render: renderRoutine };
+    }
+  },
+  {
+    spec: {
+      path: ["routines", "steps", "rm"],
+      summary: "Remove a step from a routine.",
+      args: [
+        { name: "id", required: true, description: "Routine ULID." },
+        { name: "step", required: true, description: "The step's ULID or its number (1-based)." }
+      ],
+      flags: [],
+      scopes: [...routineOperations.get.scopes, ...routineOperations.update.scopes],
+      returns: "RoutineView",
+      notes: `${routeOf(routineOperations.get)}, then ${routeOf(routineOperations.update)} without it. A habit or task it linked is untouched; past runs keep it.`
+    },
+    run: async ({ args, requireClient }) => {
+      const id = requireArg(args, 0, "routine id");
+      const token = requireArg(args, 1, "step");
+      const client = requireClient();
+      const routine = await readRoutine(client, id);
+      const index = stepIndex(routine.steps, token);
+      const steps = routine.steps.filter((_, i) => i !== index).map((s, i) => stepInput(s, i));
+      return { data: await putSteps(client, id, steps), render: renderRoutine };
+    }
+  },
+  {
+    spec: {
+      path: ["routines", "steps", "move"],
+      summary: "Move a routine's step to a new position.",
+      args: [
+        { name: "id", required: true, description: "Routine ULID." },
+        { name: "step", required: true, description: "The step's ULID or its number (1-based)." },
+        { name: "position", required: true, description: "Where it goes, 1-based." }
+      ],
+      flags: [],
+      scopes: [...routineOperations.get.scopes, ...routineOperations.reorderSteps.scopes],
+      returns: "RoutineView",
+      notes: `${routeOf(routineOperations.get)}, then ${routeOf(routineOperations.reorderSteps)}. Runs already started keep their order.`
+    },
+    run: async ({ args, requireClient }) => {
+      const id = requireArg(args, 0, "routine id");
+      const token = requireArg(args, 1, "step");
+      const to = requireArg(args, 2, "position");
+      const client = requireClient();
+      const routine = await readRoutine(client, id);
+      const from = stepIndex(routine.steps, token);
+      const ids = routine.steps.map((s) => s.id);
+      const [moved] = ids.splice(from, 1);
+      ids.splice(positionOf(to, routine.steps.length, "position"), 0, moved);
+      const input = parseInput(reorderRoutineStepsInputSchema, { stepIds: ids });
+      return {
+        data: await client.patch(pathOf(routineOperations.reorderSteps, { id }), input),
+        render: renderRoutine
+      };
+    }
+  },
+  {
+    spec: {
+      path: ["routines", "archive"],
+      summary: "Archive a routine: into Trash, restorable.",
+      args: [{ name: "id", required: true, description: "Routine ULID." }],
+      flags: [],
+      scopes: [...routineOperations.archive.scopes],
+      returns: "{ ok, archived }",
+      notes: `${routeOf(routineOperations.archive)}. The habits and tasks its steps link are untouched.`
+    },
+    run: async ({ args, flags, requireClient }) => {
+      const id = requireArg(args, 0, "routine id");
+      const client = requireClient();
+      if (flagBool(flags, "dry-run")) {
+        const before = await readRoutine(client, id);
+        return {
+          data: { dryRun: true, op: "archive", entity: "routines", id, before, softDelete: true },
+          render: renderRecord
+        };
+      }
+      await client.post(pathOf(routineOperations.archive, { id }), {});
+      return { data: { ok: true, archived: id, softDelete: true }, render: renderRecord };
+    }
+  },
+  {
+    spec: {
+      path: ["routines", "rm"],
+      summary: "Delete a routine (into Trash); needs --allow-destructive.",
+      args: [{ name: "id", required: true, description: "Routine ULID." }],
+      flags: [],
+      scopes: [...routineOperations.remove.scopes],
+      returns: "{ ok, deleted }",
+      notes: `${routeOf(routineOperations.remove)}. The same soft delete as archive, behind the destructive guardrail.`
+    },
+    run: async ({ args, flags, requireClient }) => {
+      const id = requireArg(args, 0, "routine id");
+      assertDestructiveAllowed(flags, `delete routines ${id}`);
+      await requireClient().delete(pathOf(routineOperations.remove, { id }));
+      return { data: { ok: true, deleted: id, softDelete: true }, render: renderRecord };
+    }
+  }
+];
 var commands42 = [
+  ...routineCommands,
   {
     spec: {
       path: ["routines", "today"],
@@ -53643,7 +55076,7 @@ var commands42 = [
       flags: [],
       scopes: [...routineOperations.today.scopes],
       returns: "RoutinesTodayResult",
-      notes: `${routeOf(routineOperations.today)}. Today is your saved time zone's day. A routine is on it when its rule has it due, it has a slot today, or it ran today. Each step's \`kind\` is step, habit or task (a Work task); \`rhythm\` is its last 14 days, oldest first (all, some, none, off).`
+      notes: `${routeOf(routineOperations.today)}. Today is your saved time zone's day. A routine is on it when its rule has it due, it has a slot today, or it ran today. Each step's \`kind\` is step, habit, task (a Work task) or routine (a nested routine's heading, its steps one \`depth\` deeper; V3-121); \`rhythm\` is its last 14 days, oldest first (all, some, none, off).`
     },
     run: async ({ requireClient }) => ({
       data: await requireClient().get(pathOf(routineOperations.today)),
@@ -55055,7 +56488,8 @@ var commands50 = [
       args: [],
       flags: [{ name: "data", type: "string", description: "JSON of fields to change." }],
       scopes: [...settingsOperations.update.scopes],
-      returns: "UserSettings"
+      returns: "UserSettings",
+      notes: `Appearance keys: glass (liquid|frosted|solid), followSky, nightUntilWake, largerText, reduceMotion, showStreakNumbers, themePack (do|skyrim|pokemon), themePackScope (section|everywhere). E.g. --data '{"showStreakNumbers":false}'.`
     },
     run: async ({ flags, requireClient }) => {
       const body = parseInput(updateUserSettingsInputSchema, readDataFlag(flags));
@@ -55264,6 +56698,119 @@ var commands53 = [
   })
 ];
 
+// ../../packages/domain/src/task-series.ts
+function rhythmFromWord(word) {
+  const map = {
+    week: { freq: "weekly", interval: 1 },
+    weekly: { freq: "weekly", interval: 1 },
+    fortnight: { freq: "weekly", interval: 2 },
+    month: { freq: "monthly", interval: 1 },
+    monthly: { freq: "monthly", interval: 1 },
+    quarter: { freq: "monthly", interval: 3 },
+    quarterly: { freq: "monthly", interval: 3 },
+    "half-year": { freq: "monthly", interval: 6 },
+    year: { freq: "yearly", interval: 1 },
+    yearly: { freq: "yearly", interval: 1 }
+  };
+  return map[word.trim().toLowerCase()] ?? null;
+}
+
+// src/commands/task-series.ts
+function renderSeries(data, mode) {
+  const page = data;
+  const list = Array.isArray(page) ? page : ("data" in page) ? page.data : [page];
+  if (list.length === 0)
+    return paint(mode, "dim", "(no task series)");
+  return list.map((s) => {
+    const next = s.active ? s.nextMadeOn ? `next made ${s.nextMadeOn}` : "next made" : "stopped";
+    const items = s.items.map((i) => i.taskId ? `${i.label} (${i.status ?? "?"})` : `${i.label} (to come)`).join(", ");
+    return `  ${s.title}  ${paint(mode, "dim", s.rhythm)}  ${next}  ${paint(mode, "dim", s.id)}
+    ${items}`;
+  }).join(`
+`);
+}
+var commands54 = [
+  defineCommand({
+    operation: taskSeriesOperations.make,
+    path: ["tasks", "make-series"],
+    summary: "Make a task the first of a series: each next one is its own task.",
+    args: [{ name: "task", required: true, description: "The task's ref (DO-150) or id." }],
+    flags: [
+      {
+        name: "every",
+        type: "string",
+        description: "week, fortnight, month, quarter, half-year or year."
+      },
+      {
+        name: "label",
+        type: "string",
+        description: "How each is named: quarter (Q1\u2026), month (October) or date (Mon 26 Oct)."
+      },
+      {
+        name: "lead",
+        type: "string",
+        description: "Make each next task this many days before it's due (default 14)."
+      }
+    ],
+    returns: "TaskSeries",
+    run: async ({ args, flags, requireClient }) => {
+      const task = requireArg(args, 0, "task");
+      const every = flagString(flags, "every");
+      const rule = every ? rhythmFromWord(every) : null;
+      if (!rule) {
+        throw usageError("tasks make-series needs --every week|fortnight|month|quarter|half-year|year");
+      }
+      const label = flagString(flags, "label");
+      const lead = flagString(flags, "lead");
+      const body = parseInput(makeTaskSeriesInputSchema, {
+        rule,
+        ...label ? { occurrenceLabel: label.trim().toLowerCase() } : {},
+        ...lead !== undefined ? { leadDays: Number(lead) } : {}
+      });
+      return {
+        data: await requireClient().post(pathOf(taskSeriesOperations.make, { id: task }), body),
+        render: renderSeries
+      };
+    }
+  }),
+  defineCommand({
+    operation: taskSeriesOperations.list,
+    path: ["series", "list"],
+    summary: "List the task series, with their rhythm and what's next.",
+    returns: "TaskSeries[]",
+    run: async ({ requireClient }) => ({
+      data: await requireClient().get(pathOf(taskSeriesOperations.list)),
+      render: renderSeries
+    })
+  }),
+  defineCommand({
+    operation: taskSeriesOperations.get,
+    path: ["series", "show"],
+    summary: "Show a task series: its strip of tasks and the next to come.",
+    args: [{ name: "series", required: true, description: "The series' id." }],
+    returns: "TaskSeries",
+    run: async ({ args, requireClient }) => ({
+      data: await requireClient().get(pathOf(taskSeriesOperations.get, { id: requireArg(args, 0, "series") })),
+      render: renderSeries
+    })
+  }),
+  defineCommand({
+    operation: taskSeriesOperations.stop,
+    path: ["series", "stop"],
+    summary: "Stop a task series: no more tasks are made; the ones made stay.",
+    args: [{ name: "series", required: true, description: "The series' id." }],
+    returns: "{ ok, stopped }",
+    run: async ({ args, requireClient }) => {
+      const id = requireArg(args, 0, "series");
+      await requireClient().delete(pathOf(taskSeriesOperations.stop, { id }));
+      return {
+        data: { ok: true, stopped: id },
+        render: () => "Stopped the series. Its tasks stay."
+      };
+    }
+  })
+];
+
 // src/capture.ts
 function parseCapture2(input, now) {
   const parsed = parseCapture(input, now);
@@ -55274,7 +56821,70 @@ function parseCapture2(input, now) {
 }
 
 // src/commands/tasks.ts
-var commands54 = [
+var REPEAT_FLAGS = [
+  {
+    name: "repeat",
+    type: "string",
+    description: "Make it repeat: daily, weekly, monthly or yearly. On update it replaces the rule."
+  },
+  {
+    name: "every",
+    type: "string",
+    description: "With --repeat: every N days/weeks/months (default 1)."
+  },
+  {
+    name: "on",
+    type: "string",
+    description: "With --repeat weekly (or monthly): the weekdays, comma-separated: mo,th. Monthly also takes 1su (the 1st Sunday) or -1fr (the last Friday)."
+  },
+  {
+    name: "day",
+    type: "string",
+    description: "With --repeat monthly: the day of the month, 1\u201331 or last (a shorter month uses its last day)."
+  },
+  {
+    name: "after-done",
+    type: "boolean",
+    description: "With --repeat: the next one is due N after the last was done, not on the calendar (anchor from_completion)."
+  }
+];
+var REPEAT_DETAIL = ["every", "on", "day", "after-done"];
+function repeatFromFlags(flags) {
+  const repeat = flagString(flags, "repeat");
+  if (flagBool(flags, "no-repeat")) {
+    if (repeat !== undefined)
+      throw usageError("--repeat and --no-repeat can't be combined");
+    return null;
+  }
+  if (repeat === undefined) {
+    const stray = REPEAT_DETAIL.find((f) => flags[f] !== undefined);
+    if (stray)
+      throw usageError(`--${stray} goes with --repeat daily|weekly|monthly`);
+    return;
+  }
+  const out = { freq: repeat.trim().toLowerCase() };
+  const every = flagString(flags, "every");
+  if (every !== undefined) {
+    if (!/^\d+$/.test(every.trim()))
+      throw usageError("--every must be a whole number, e.g. --every 2");
+    out.interval = Number(every);
+  }
+  const on = flagString(flags, "on");
+  if (on !== undefined) {
+    out.byDay = on.split(",").map((d) => d.trim().toUpperCase()).filter((d) => d.length > 0);
+  }
+  const day = flagString(flags, "day");
+  if (day !== undefined) {
+    const d = day.trim().toLowerCase();
+    if (d !== "last" && !/^-?\d+$/.test(d))
+      throw usageError("--day must be 1\u201331 or last");
+    out.byMonthDay = d === "last" ? -1 : Number(d);
+  }
+  if (flagBool(flags, "after-done"))
+    out.anchor = "from_completion";
+  return out;
+}
+var commands55 = [
   {
     spec: {
       path: ["capture"],
@@ -55331,21 +56941,21 @@ var commands54 = [
         title: parsed.title,
         tags: parsed.tags,
         ...parsed.starred ? { starred: parsed.starred } : {},
+        ...parsed.priority ? { priority: parsed.priority } : {},
         ...parsed.area ? { areaName: parsed.area } : {},
         ...scheduledAt ? { scheduledAt } : {},
         ...dueAt ? { dueAt } : {},
         ...scheduledAt || dueAt ? { allDay } : {},
-        ...duration ? { durationMinutes: duration } : {}
+        ...duration ? { durationMinutes: duration } : {},
+        ...parsed.recurrence ? {
+          recurrence: {
+            freq: parsed.recurrence.freq,
+            interval: parsed.recurrence.interval,
+            ...parsed.recurrence.byDay ? { byDay: parsed.recurrence.byDay } : {}
+          }
+        } : {}
       });
-      const client = requireClient();
-      const task = await client.post(pathOf(taskOperations.create), input);
-      if (parsed.recurrence) {
-        const rule = parseInput(createRecurrenceRuleInputSchema, {
-          templateId: id,
-          ...parsed.recurrence
-        });
-        await client.post("/recurrence/rules", rule);
-      }
+      const task = await requireClient().post(pathOf(taskOperations.create), input);
       return { data: task, render: renderTask };
     }
   },
@@ -55633,11 +57243,106 @@ var commands54 = [
         render: renderTask
       };
     }
+  }),
+  defineCommand({
+    operation: taskOperations.create,
+    path: ["tasks", "create"],
+    summary: "Create a task; --repeat makes it repeat.",
+    returns: "Task",
+    args: [
+      {
+        name: "title",
+        required: false,
+        description: "The task's title (or pass it in --data)."
+      }
+    ],
+    flags: [
+      {
+        name: "data",
+        type: "string",
+        description: "JSON CreateTaskInput (or @file) for any other field."
+      },
+      ...REPEAT_FLAGS
+    ],
+    notes: ' \u2014 e.g. `do tasks create "Descale the kettle" --repeat monthly --after-done`, `do tasks create "Gym" --repeat weekly --on mo,th`, `do tasks create "Pay rent" --repeat monthly --day 1`. The id is minted when omitted.',
+    run: async ({ args, flags, requireClient }) => {
+      const title = args.join(" ").trim();
+      const recurrence = repeatFromFlags(flags);
+      if (recurrence === null)
+        throw usageError("--no-repeat is for `tasks update`");
+      const body = parseInput(createTaskInputSchema, {
+        id: ulid3(),
+        ...readDataFlag(flags),
+        ...title ? { title } : {},
+        ...recurrence ? { recurrence } : {}
+      });
+      if (flagBool(flags, "dry-run")) {
+        return {
+          data: { dryRun: true, op: "create", entity: "tasks", after: body },
+          render: renderRecord
+        };
+      }
+      return {
+        data: await requireClient().post(pathOf(taskOperations.create), body),
+        render: renderTask
+      };
+    }
+  }),
+  defineCommand({
+    operation: taskOperations.update,
+    path: ["tasks", "update"],
+    summary: "Change a task; --repeat sets its repeat rule, --no-repeat ends the series.",
+    returns: "Task",
+    args: [{ name: "id", required: true, description: "Task ULID or ref (DO-142)." }],
+    flags: [
+      {
+        name: "data",
+        type: "string",
+        description: "JSON UpdateTaskInput (or @file): the fields to change."
+      },
+      ...REPEAT_FLAGS,
+      {
+        name: "no-repeat",
+        type: "boolean",
+        description: "Stop the series: no more occurrences; the done history stays."
+      }
+    ],
+    notes: " \u2014 --repeat replaces the whole rule (pass every part you want kept). On a repeating task, `do task done` finishes the open occurrence and the task stays open for the next one.",
+    run: async ({ args, flags, requireClient }) => {
+      const id = requireArg(args, 0, "task id");
+      const recurrence = repeatFromFlags(flags);
+      const body = parseInput(updateTaskInputSchema, {
+        ...readDataFlag(flags),
+        ...recurrence !== undefined ? { recurrence } : {}
+      });
+      if (Object.keys(body).length === 0)
+        throw usageError("nothing to change \u2014 pass --repeat, --no-repeat or --data");
+      const client = requireClient();
+      if (flagBool(flags, "dry-run")) {
+        const before = await client.get(pathOf(taskOperations.get, { id }));
+        return {
+          data: {
+            dryRun: true,
+            op: "update",
+            entity: "tasks",
+            id,
+            before,
+            after: mergePreview(before, body),
+            changes: body
+          },
+          render: renderRecord
+        };
+      }
+      return {
+        data: await client.patch(pathOf(taskOperations.update, { id }), body),
+        render: renderTask
+      };
+    }
   })
 ];
 
 // src/commands/time-blocks.ts
-var commands55 = [
+var commands56 = [
   {
     spec: {
       path: ["time-blocks", "record"],
@@ -55818,7 +57523,7 @@ function renderLandedCounts(data, mode) {
   return out.join(`
 `);
 }
-var commands56 = [
+var commands57 = [
   {
     spec: {
       path: ["today"],
@@ -56190,7 +57895,7 @@ function renderViews(data, mode) {
 function renderView(data, mode) {
   return renderViews([data], mode);
 }
-var commands57 = [
+var commands58 = [
   defineCommand({
     operation: workViewOperations.list,
     path: ["views", "list"],
@@ -56309,7 +58014,7 @@ var commands57 = [
 ];
 
 // src/commands/worktree-links.ts
-var commands58 = [
+var commands59 = [
   {
     spec: {
       path: ["worktree-links", "list"],
@@ -56473,7 +58178,8 @@ var FEATURE_COMMANDS = [
   ...commands55,
   ...commands56,
   ...commands57,
-  ...commands58
+  ...commands58,
+  ...commands59
 ];
 
 // src/registry.ts