@robbeverhelst/do 1.341.0 → 1.343.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.341.0";
+var VERSION = "1.343.0";
 var API_PREFIX = "/api/v1";
 var DEFAULT_API_URL = "http://localhost:3001";
 
@@ -18020,7 +18022,10 @@ var habits = pgTable("habits", {
   pausedFrom: date5("paused_from", { mode: "string" }),
   pausedUntil: date5("paused_until", { mode: "string" }),
   remind: boolean4("remind").notNull().default(false),
-  retiredAt: timestamp("retired_at", { withTimezone: true })
+  retiredAt: timestamp("retired_at", { withTimezone: true }),
+  eventSourceId: text("event_source_id"),
+  eventMatch: text("event_match"),
+  eventOffset: text("event_offset")
 }, (t) => [
   index("habits_tenant_idx").on(t.tenantId),
   index("habits_tenant_area_idx").on(t.tenantId, t.areaId),
@@ -18050,6 +18055,8 @@ var recurrenceRules = pgTable("recurrence_rules", {
   interval: integer2("interval").notNull().default(1),
   freq: recurrenceFreq("freq"),
   byDay: text("by_day").array(),
+  byMonthDay: integer2("by_month_day"),
+  startsOn: date5("starts_on", { mode: "string" }),
   timeOfDay: text("time_of_day"),
   until: timestamp("until", { withTimezone: true }),
   count: integer2("count"),
@@ -21269,6 +21276,75 @@ var animalOperations = defineOperations({
 // ../../packages/schema/src/contracts/habit-sources.ts
 var habitSourceSchema = _enum2(["manual", "google_fit", "strava", "github"]);
 
+// ../../packages/schema/src/contracts/recurrence.ts
+var recurrenceRuleSchema = createSelectSchema(recurrenceRules, {
+  until: exports_coerce.date().nullable(),
+  byMonthDay: number2().int().nullable().default(null),
+  startsOn: exports_iso.date().nullable().default(null)
+});
+var occurrenceSchema = createSelectSchema(occurrences, {
+  occurrenceDate: exports_coerce.date(),
+  completedAt: exports_coerce.date().nullable()
+});
+var byDayCodeSchema = _enum2(["MO", "TU", "WE", "TH", "FR", "SA", "SU"]);
+var byDayOrdinalSchema = _enum2(["1", "2", "3", "4", "-1"]);
+var byDaySchema = union([
+  byDayCodeSchema,
+  templateLiteral([byDayOrdinalSchema, byDayCodeSchema])
+]);
+var BY_DAY_RE = /^(-1|[1-4])?(MO|TU|WE|TH|FR|SA|SU)$/;
+function parseByDay(code) {
+  const m = BY_DAY_RE.exec(code);
+  if (!m)
+    return null;
+  return { ordinal: m[1] ? Number(m[1]) : null, weekday: m[2] };
+}
+var recurrenceRuleParams = {
+  timezone: string2().min(1).default("UTC"),
+  interval: number2().int().positive().default(1),
+  mode: recurrenceModeSchema,
+  timeOfDay: string2().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "time-of-day must be HH:MM (24h)").nullish(),
+  freq: recurrenceFreqSchema.optional(),
+  byDay: array(byDaySchema).optional(),
+  until: exports_coerce.date().optional(),
+  count: number2().int().positive().optional(),
+  unit: recurrenceUnitSchema.optional(),
+  anchor: recurrenceAnchorSchema.optional()
+};
+function refineRecurrenceRule(v, ctx) {
+  if (v.mode === "rigid" && !v.freq) {
+    ctx.addIssue({ code: "custom", path: ["freq"], message: "rigid rules require a freq" });
+  }
+  const ordinal = v.byDay?.findIndex((code) => parseByDay(code)?.ordinal != null) ?? -1;
+  if (ordinal >= 0 && v.freq !== "monthly" && v.freq !== "yearly") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["byDay", ordinal],
+      message: "an ordinal weekday (1SU, -1FR) needs a monthly or yearly freq"
+    });
+  }
+  if (v.mode === "flexible") {
+    if (!v.unit) {
+      ctx.addIssue({ code: "custom", path: ["unit"], message: "flexible rules require a unit" });
+    }
+    if (!v.anchor) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["anchor"],
+        message: "flexible rules require an anchor"
+      });
+    }
+  }
+}
+var createRecurrenceRuleInputSchema = object({
+  templateId: ulidSchema,
+  ...recurrenceRuleParams
+}).superRefine(refineRecurrenceRule);
+var updateRecurrenceRuleInputSchema = object({ ...recurrenceRuleParams }).superRefine(refineRecurrenceRule);
+var updateOccurrenceInputSchema = createUpdateSchema(occurrences, {
+  occurrenceDate: exports_coerce.date().optional()
+}).pick({ occurrenceDate: true, status: true }).strict();
+
 // ../../packages/schema/src/contracts/habits.ts
 var habitSchema = createSelectSchema(habits, {
   source: habitSourceSchema.default("manual"),
@@ -21278,7 +21354,10 @@ var habitSchema = createSelectSchema(habits, {
   pausedFrom: exports_iso.date().nullable().default(null),
   pausedUntil: exports_iso.date().nullable().default(null),
   remind: boolean2().default(false),
-  retiredAt: exports_coerce.date().nullable().default(null)
+  retiredAt: exports_coerce.date().nullable().default(null),
+  eventSourceId: string2().nullable().default(null),
+  eventMatch: string2().nullable().default(null),
+  eventOffset: string2().nullable().default(null)
 });
 var habitEntrySchema = createSelectSchema(habitEntries, {
   occurredAt: exports_coerce.date(),
@@ -21297,6 +21376,30 @@ var habitTimeOfDaySchema = union([
 ]);
 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", [
+  object({ kind: literal("daily") }),
+  object({
+    kind: literal("weekdays"),
+    days: array(byDayCodeSchema).min(1).max(7).refine((days) => new Set(days).size === days.length, "each weekday once")
+  }),
+  object({
+    kind: literal("every"),
+    interval: number2().int().min(2),
+    unit: _enum2(["day", "week"]),
+    anchor: exports_iso.date()
+  }),
+  object({
+    kind: literal("monthly"),
+    dayOfMonth: union([number2().int().min(1).max(31), literal(-1)])
+  }),
+  object({
+    kind: literal("event"),
+    sourceId: ulidSchema,
+    match: string2().trim().min(1).max(120),
+    offset: _enum2(["day_before_evening", "same_day"])
+  })
+]);
+var eventColumns = { eventSourceId: true, eventMatch: true, eventOffset: true };
 var createHabitInputSchema = createInsertSchema(habits, {
   id: ulidSchema,
   source: habitSourceSchema.optional(),
@@ -21310,8 +21413,9 @@ var createHabitInputSchema = createInsertSchema(habits, {
   aliases: habitAliasesSchema.optional(),
   timeOfDay: habitTimeOfDaySchema.nullish(),
   remind: boolean2().optional()
-}).omit({ tenantId: true, recurrenceRuleId: true, retiredAt: true }).extend({
+}).omit({ tenantId: true, recurrenceRuleId: true, retiredAt: true, ...eventColumns }).extend({
   title: string2().min(1),
+  schedule: habitScheduleSchema.optional(),
   displayKind: string2().min(1).nullish()
 });
 var updateHabitInputSchema = createUpdateSchema(habits, {
@@ -21332,8 +21436,12 @@ var updateHabitInputSchema = createUpdateSchema(habits, {
   recurrenceRuleId: true,
   pausedFrom: true,
   pausedUntil: true,
-  retiredAt: true
-}).extend({ title: string2().min(1).optional() });
+  retiredAt: true,
+  ...eventColumns
+}).extend({
+  title: string2().min(1).optional(),
+  schedule: habitScheduleSchema.optional()
+});
 var HABIT_ENTRY_NOTE_MAX = 280;
 var habitEntryNoteSchema = string2().trim().max(HABIT_ENTRY_NOTE_MAX).transform((note) => note === "" ? null : note);
 var createHabitEntryInputSchema = createInsertSchema(habitEntries, {
@@ -21387,7 +21495,9 @@ var habitSummarySchema = habitSchema.extend({
   inRoutines: array(habitRoutineRefSchema).default([]),
   lastCheckIn: habitLastCheckInSchema.nullable().default(null),
   pause: habitPauseSchema.nullable().default(null),
-  today: habitTodaySchema.default({ due: true, done: false })
+  today: habitTodaySchema.default({ due: true, done: false }),
+  schedule: habitScheduleSchema.default({ kind: "daily" }),
+  nextDue: array(exports_iso.date()).default([])
 });
 var habitHeatmapCellSchema = object({
   date: string2(),
@@ -21474,12 +21584,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 = {
@@ -21947,6 +22123,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,
@@ -21981,7 +22206,8 @@ 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)
 });
 var taskProjectIdSchema = ulidSchema.nullish();
 var taskAreaIdSchema = ulidSchema.nullish();
@@ -22035,7 +22261,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();
@@ -22088,7 +22315,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"]);
 
@@ -22194,73 +22422,6 @@ var projectDetailSchema = projectViewSchema.extend({
 });
 var attachTaskInputSchema = object({ taskId: ulidSchema });
 
-// ../../packages/schema/src/contracts/recurrence.ts
-var recurrenceRuleSchema = createSelectSchema(recurrenceRules, {
-  until: exports_coerce.date().nullable()
-});
-var occurrenceSchema = createSelectSchema(occurrences, {
-  occurrenceDate: exports_coerce.date(),
-  completedAt: exports_coerce.date().nullable()
-});
-var byDayCodeSchema = _enum2(["MO", "TU", "WE", "TH", "FR", "SA", "SU"]);
-var byDayOrdinalSchema = _enum2(["1", "2", "3", "4", "-1"]);
-var byDaySchema = union([
-  byDayCodeSchema,
-  templateLiteral([byDayOrdinalSchema, byDayCodeSchema])
-]);
-var BY_DAY_RE = /^(-1|[1-4])?(MO|TU|WE|TH|FR|SA|SU)$/;
-function parseByDay(code) {
-  const m = BY_DAY_RE.exec(code);
-  if (!m)
-    return null;
-  return { ordinal: m[1] ? Number(m[1]) : null, weekday: m[2] };
-}
-var recurrenceRuleParams = {
-  timezone: string2().min(1).default("UTC"),
-  interval: number2().int().positive().default(1),
-  mode: recurrenceModeSchema,
-  timeOfDay: string2().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "time-of-day must be HH:MM (24h)").nullish(),
-  freq: recurrenceFreqSchema.optional(),
-  byDay: array(byDaySchema).optional(),
-  until: exports_coerce.date().optional(),
-  count: number2().int().positive().optional(),
-  unit: recurrenceUnitSchema.optional(),
-  anchor: recurrenceAnchorSchema.optional()
-};
-function refineRecurrenceRule(v, ctx) {
-  if (v.mode === "rigid" && !v.freq) {
-    ctx.addIssue({ code: "custom", path: ["freq"], message: "rigid rules require a freq" });
-  }
-  const ordinal = v.byDay?.findIndex((code) => parseByDay(code)?.ordinal != null) ?? -1;
-  if (ordinal >= 0 && v.freq !== "monthly" && v.freq !== "yearly") {
-    ctx.addIssue({
-      code: "custom",
-      path: ["byDay", ordinal],
-      message: "an ordinal weekday (1SU, -1FR) needs a monthly or yearly freq"
-    });
-  }
-  if (v.mode === "flexible") {
-    if (!v.unit) {
-      ctx.addIssue({ code: "custom", path: ["unit"], message: "flexible rules require a unit" });
-    }
-    if (!v.anchor) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["anchor"],
-        message: "flexible rules require an anchor"
-      });
-    }
-  }
-}
-var createRecurrenceRuleInputSchema = object({
-  templateId: ulidSchema,
-  ...recurrenceRuleParams
-}).superRefine(refineRecurrenceRule);
-var updateRecurrenceRuleInputSchema = object({ ...recurrenceRuleParams }).superRefine(refineRecurrenceRule);
-var updateOccurrenceInputSchema = createUpdateSchema(occurrences, {
-  occurrenceDate: exports_coerce.date().optional()
-}).pick({ occurrenceDate: true, status: true }).strict();
-
 // ../../packages/schema/src/contracts/routines.ts
 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);
@@ -29710,7 +29871,7 @@ 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"
@@ -29962,9 +30123,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"
@@ -37605,7 +37766,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." },
@@ -37618,12 +37779,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",
@@ -39457,7 +39631,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 }
@@ -39468,7 +39642,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." },
@@ -39481,7 +39655,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." },
@@ -46989,7 +47163,144 @@ var commands19 = [
 ];
 
 // src/commands/habits.ts
+var SCHEDULE_FLAGS = [
+  { name: "every-day", type: "boolean", description: "Due every day." },
+  {
+    name: "on",
+    type: "string",
+    description: "Due on these weekdays, comma-separated (mo,we,fr)."
+  },
+  {
+    name: "every",
+    type: "string",
+    description: "Due every N days or weeks (3d, 2w), counted in calendar days from --from, never from the last check-in."
+  },
+  {
+    name: "from",
+    type: "string",
+    description: "The day --every counts from, YYYY-MM-DD (default today)."
+  },
+  {
+    name: "monthly",
+    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: "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.";
+function localToday() {
+  const now = new Date;
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
+}
+function scheduleFromFlags(flags, today = localToday()) {
+  const on = flagString(flags, "on");
+  const every = flagString(flags, "every");
+  const monthly = flagString(flags, "monthly");
+  const given = [flagBool(flags, "every-day"), on, every, monthly].filter((v) => v !== undefined && v !== false);
+  if (given.length > 1)
+    throw usageError("pick one schedule: --every-day, --on, --every or --monthly");
+  if (flagString(flags, "from") !== undefined && every === undefined)
+    throw usageError("--from goes with --every");
+  if (flagBool(flags, "every-day"))
+    return { kind: "daily" };
+  if (on !== undefined) {
+    const days = on.split(",").map((d) => d.trim().toUpperCase()).filter((d) => d.length > 0);
+    return { kind: "weekdays", days };
+  }
+  if (every !== undefined) {
+    const m = /^(\d+)\s*([dw])$/i.exec(every.trim());
+    if (!m)
+      throw usageError("--every takes a number of days or weeks: 3d or 2w");
+    return {
+      kind: "every",
+      interval: Number(m[1]),
+      unit: m[2]?.toLowerCase() === "w" ? "week" : "day",
+      anchor: flagString(flags, "from") ?? today
+    };
+  }
+  if (monthly !== undefined) {
+    const day = monthly.trim().toLowerCase() === "last" ? -1 : Number(monthly);
+    if (!Number.isInteger(day))
+      throw usageError("--monthly takes a day of the month (1\u201331) or last");
+    return { kind: "monthly", dayOfMonth: day };
+  }
+  return;
+}
 var commands20 = [
+  {
+    spec: {
+      path: ["habits", "create"],
+      summary: "Create a habit, with an optional schedule (every day, weekdays, every N, monthly).",
+      args: [{ name: "title", required: false, description: "The habit's title." }],
+      flags: SCHEDULE_FLAGS,
+      scopes: [...habitOperations.create.scopes],
+      returns: "HabitSummary",
+      notes: `${routeOf(habitOperations.create)}. --data carries the rest of a CreateHabitInput; the id is minted and a yes/no measurement assumed when omitted. ${SCHEDULE_NOTES} e.g. \`do habits create "Water the plants" --every 3d\`.`
+    },
+    run: async ({ args, flags, requireClient }) => {
+      const title = args.join(" ").trim();
+      const schedule = scheduleFromFlags(flags);
+      const body = parseInput(createHabitInputSchema, {
+        id: ulid3(),
+        measurementType: "binary",
+        ...title ? { title } : {},
+        ...readDataFlag(flags),
+        ...schedule ? { schedule } : {}
+      });
+      if (flagBool(flags, "dry-run")) {
+        return {
+          data: { dryRun: true, op: "create", entity: "habits", after: body },
+          render: renderRecord
+        };
+      }
+      return {
+        data: await requireClient().post(pathOf(habitOperations.create), body),
+        render: renderRecord
+      };
+    }
+  },
+  {
+    spec: {
+      path: ["habits", "update"],
+      summary: "Change a habit: its schedule (--every-day, --on, --every, --monthly) or --data.",
+      args: [{ name: "id", required: true, description: "Habit ULID." }],
+      flags: SCHEDULE_FLAGS,
+      scopes: [...habitOperations.update.scopes],
+      returns: "HabitSummary",
+      notes: `${routeOf(habitOperations.update)}. Only what you pass changes. ${SCHEDULE_NOTES}`
+    },
+    run: async ({ args, flags, requireClient }) => {
+      const id = requireArg(args, 0, "habit id");
+      const schedule = scheduleFromFlags(flags);
+      const body = parseInput(updateHabitInputSchema, {
+        ...readDataFlag(flags),
+        ...schedule ? { schedule } : {}
+      });
+      if (Object.keys(body).length === 0)
+        throw usageError("nothing to change \u2014 pass a schedule flag such as --on mo,we, or --data");
+      const client = requireClient();
+      if (flagBool(flags, "dry-run")) {
+        const before = await client.get(pathOf(habitOperations.get, { id }));
+        return {
+          data: {
+            dryRun: true,
+            op: "update",
+            entity: "habits",
+            id,
+            before,
+            after: mergePreview(before, body),
+            changes: body
+          },
+          render: renderRecord
+        };
+      }
+      return {
+        data: await client.patch(pathOf(habitOperations.update, { id }), body),
+        render: renderRecord
+      };
+    }
+  },
   {
     spec: {
       path: ["habit", "log"],
@@ -47144,7 +47455,7 @@ 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)
   },
@@ -47210,6 +47521,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"],
@@ -53456,7 +53793,327 @@ 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 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;
+}
+async function stepFrom(client, item, title) {
+  const link = /^(habit|task):(\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(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 };
+}
+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,
+    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}]`;
+    return `    ${i + 1}. ${s.title}${kind}  ${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 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, or --data.",
+      args: [{ name: "id", required: true, description: "Routine ULID." }],
+      flags: [{ name: "title", type: "string", description: "A new title." }, ...ROUTINE_FLAGS],
+      scopes: [...routineOperations.update.scopes],
+      returns: "RoutineView",
+      notes: `${routeOf(routineOperations.update)}. Only what you pass changes; its steps change with \`do routines steps\`.`
+    },
+    run: async ({ args, flags, requireClient }) => {
+      const id = requireArg(args, 0, "routine id");
+      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");
+      }
+      const client = requireClient();
+      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, at the end or --at a position.",
+      args: [
+        { name: "id", required: true, description: "Routine ULID." },
+        { name: "step", required: true, description: "The step. See grammar." }
+      ],
+      flags: [
+        { name: "at", type: "string", description: "Its position, 1-based (default: last)." },
+        { name: "title", type: "string", description: "Its title (instead of the linked name)." }
+      ],
+      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).`
+    },
+    run: async ({ args, flags, requireClient }) => {
+      const id = requireArg(args, 0, "routine id");
+      const item = args.slice(1).join(" ").trim();
+      if (!item)
+        throw usageError("routines steps add needs the step: `habit:<id>`, `task:<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")));
+      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"],
@@ -55096,6 +55753,69 @@ function parseCapture2(input, now) {
 }
 
 // src/commands/tasks.ts
+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 commands54 = [
   {
     spec: {
@@ -55157,17 +55877,16 @@ var commands54 = [
         ...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 };
     }
   },
@@ -55455,6 +56174,101 @@ 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
+      };
+    }
   })
 ];
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robbeverhelst/do",
-  "version": "1.341.0",
+  "version": "1.343.0",
   "private": false,
   "description": "do — the agent-drivable CLI over the public /api/v1 surface",
   "homepage": "https://github.com/robbeverhelst/do/tree/main/apps/cli",