@robbeverhelst/do 1.343.0 → 1.344.0

package/dist/do.js

@@ -14420,7 +14420,7 @@ var configError = (message) => new CliError("config", message, EXIT.CONFIG);
 
 // src/meta.ts
 var CLI_NAME = "do";
-var VERSION = "1.343.0";
+var VERSION = "1.344.0";
 var API_PREFIX = "/api/v1";
 var DEFAULT_API_URL = "http://localhost:3001";
 
@@ -17984,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),
@@ -18025,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(),
@@ -18083,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",
@@ -18093,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",
@@ -18126,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"),
@@ -18133,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(),
@@ -18157,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),
@@ -18167,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(),
@@ -18222,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)]);
@@ -19000,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"]);
@@ -21357,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(),
@@ -21374,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", [
@@ -21412,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(),
@@ -21428,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,
@@ -21479,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({
@@ -21495,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([])
@@ -21522,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)
@@ -21552,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()
@@ -21896,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),
@@ -22068,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) {
@@ -22207,7 +22341,8 @@ var taskViewSchema = taskSchema.omit({
   blockedBy: array(taskBlockerSchema).default([]),
   blocks: number2().int().nonnegative().default(0),
   isBlocked: boolean2().default(false),
-  recurrence: taskRecurrenceSchema.nullable().default(null)
+  recurrence: taskRecurrenceSchema.nullable().default(null),
+  series: taskSeriesStripSchema.nullable().default(null)
 });
 var taskProjectIdSchema = ulidSchema.nullish();
 var taskAreaIdSchema = ulidSchema.nullish();
@@ -22243,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,
@@ -22297,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,
@@ -22426,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,
@@ -22434,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({
@@ -22495,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()
@@ -22525,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),
@@ -22615,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({
@@ -24009,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()
@@ -24229,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"),
@@ -24237,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)
@@ -24299,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(),
@@ -29876,6 +30060,27 @@ var habitOperations = defineOperations({
     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",
@@ -30052,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: {
@@ -31291,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(),
@@ -31300,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(),
@@ -31317,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({
@@ -33148,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)]);
@@ -33244,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) {
@@ -33263,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,
@@ -33284,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(),
@@ -33330,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}",
@@ -33892,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(),
@@ -33914,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),
@@ -33935,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({
@@ -33945,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
@@ -37554,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,
@@ -37563,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();
@@ -39039,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),
@@ -39049,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 });
@@ -39068,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,
@@ -39528,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({
@@ -39825,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(),
@@ -40805,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)) {
@@ -40825,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)) {
@@ -40838,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 } : {},
@@ -41532,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}
@@ -41574,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(`
 `);
 }
@@ -44978,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.",
@@ -45110,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");
@@ -45196,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) {
@@ -46580,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 = [
   {
@@ -46739,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"],
@@ -47185,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");
@@ -47227,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],
@@ -47246,7 +48016,8 @@ var commands20 = [
         measurementType: "binary",
         ...title ? { title } : {},
         ...readDataFlag(flags),
-        ...schedule ? { schedule } : {}
+        ...schedule ? { schedule } : {},
+        ...timingFromFlags(flags)
       });
       if (flagBool(flags, "dry-run")) {
         return {
@@ -47263,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],
@@ -47275,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 }));
@@ -47459,6 +48231,35 @@ var commands20 = [
     },
     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"],
@@ -47640,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
@@ -49755,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: {
@@ -49768,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"],
@@ -49788,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");
@@ -53781,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(`
 `);
@@ -53793,7 +54656,7 @@ 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) or any other text (a plain step with that title).";
+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)." },
@@ -53816,8 +54679,13 @@ function routineFields(flags) {
     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):(\S+)$/.exec(item.trim());
+  const link = /^(habit|task|routine):(\S+)$/.exec(item.trim());
   if (!link) {
     const text = (title ?? item).trim();
     if (!text)
@@ -53826,8 +54694,12 @@ async function stepFrom(client, item, title) {
   }
   const kind = link[1];
   const id = link[2];
-  const named = title ?? (await client.get(kind === "habit" ? pathOf(habitOperations.get, { id }) : pathOf(taskOperations.get, { id }))).title ?? kind;
-  return kind === "habit" ? { id: ulid3(), title: named, refKind: "habit", habitId: id } : { id: ulid3(), title: named, refKind: "task", taskId: id };
+  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 {
@@ -53836,6 +54708,8 @@ function stepInput(step, sortOrder) {
     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
@@ -53861,7 +54735,8 @@ function renderRoutine(data) {
   const r = data;
   const steps = (r.steps ?? []).map((s, i) => {
     const kind = s.refKind === "free" ? "" : ` [${s.refKind}]`;
-    return `    ${i + 1}. ${s.title}${kind}  ${s.id}`;
+    const optional = s.optional ? " (optional)" : "";
+    return `    ${i + 1}. ${s.title}${kind}${optional}  ${s.id}`;
   });
   return [
     `${r.title ?? "(routine)"}  ${r.id}`,
@@ -53875,6 +54750,30 @@ function putSteps(client, id, steps) {
   });
   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 }));
 }
@@ -53920,20 +54819,54 @@ var routineCommands = [
   {
     spec: {
       path: ["routines", "update"],
-      summary: "Change a routine: its title, kind, Area, notes, or --data.",
+      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." }, ...ROUTINE_FLAGS],
+      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)}. Only what you pass changes; its steps change with \`do routines steps\`.`
+      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) {
-        throw usageError("nothing to change \u2014 pass --title, --kind, --area, --notes or --data");
+      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 {
@@ -53988,31 +54921,52 @@ var routineCommands = [
   {
     spec: {
       path: ["routines", "steps", "add"],
-      summary: "Add a step to a routine, at the end or --at a position.",
+      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: true, description: "The step. See grammar." }
+        {
+          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: "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).`
+      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 item = args.slice(1).join(" ").trim();
+      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>` or a title");
+        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");
-      steps.splice(index, 0, await stepFrom(client, item, flagString(flags, "title")));
+      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 };
     }
   },
@@ -54122,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)),
@@ -55534,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));
@@ -55743,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);
@@ -55816,7 +56884,7 @@ function repeatFromFlags(flags) {
     out.anchor = "from_completion";
   return out;
 }
-var commands54 = [
+var commands55 = [
   {
     spec: {
       path: ["capture"],
@@ -55873,6 +56941,7 @@ 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 } : {},
@@ -56273,7 +57342,7 @@ var commands54 = [
 ];
 
 // src/commands/time-blocks.ts
-var commands55 = [
+var commands56 = [
   {
     spec: {
       path: ["time-blocks", "record"],
@@ -56454,7 +57523,7 @@ function renderLandedCounts(data, mode) {
   return out.join(`
 `);
 }
-var commands56 = [
+var commands57 = [
   {
     spec: {
       path: ["today"],
@@ -56826,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"],
@@ -56945,7 +58014,7 @@ var commands57 = [
 ];
 
 // src/commands/worktree-links.ts
-var commands58 = [
+var commands59 = [
   {
     spec: {
       path: ["worktree-links", "list"],
@@ -57109,7 +58178,8 @@ var FEATURE_COMMANDS = [
   ...commands55,
   ...commands56,
   ...commands57,
-  ...commands58
+  ...commands58,
+  ...commands59
 ];
 
 // src/registry.ts