@robbeverhelst/do 1.342.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.342.0";
+var VERSION = "1.343.0";
 var API_PREFIX = "/api/v1";
 var DEFAULT_API_URL = "http://localhost:3001";
 
@@ -21582,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 = {
@@ -22055,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,
@@ -22089,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();
@@ -22143,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();
@@ -22196,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"]);
 
@@ -29751,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"
@@ -30003,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"
@@ -37646,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." },
@@ -37659,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",
@@ -39498,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 }
@@ -39509,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." },
@@ -39522,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." },
@@ -47322,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)
   },
@@ -47388,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"],
@@ -53634,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"],
@@ -55274,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: {
@@ -55335,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 };
     }
   },
@@ -55633,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.342.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",