@robbeverhelst/do 1.160.0 → 1.161.0

package/dist/do.js

@@ -3514,6 +3514,8 @@ var tenants = pgTable("tenants", {
   name: text("name").notNull(),
   backdrop: text("backdrop"),
   gaardHouseUrl: text("gaard_house_url"),
+  awayFrom: date("away_from", { mode: "string" }),
+  awayUntil: date("away_until", { mode: "string" }),
   createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
   updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
   deletedAt: timestamp("deleted_at", { withTimezone: true })
@@ -3746,7 +3748,13 @@ var habitMeasurementType = pgEnum("habit_measurement_type", [
   "negative"
 ]);
 var habitPeriod = pgEnum("habit_period", ["day", "week", "month"]);
-var habitEntrySource = pgEnum("habit_entry_source", ["manual", "routine", "ingest"]);
+var habitEntrySource = pgEnum("habit_entry_source", [
+  "manual",
+  "routine",
+  "ingest",
+  "agent"
+]);
+var habitEntryKind = pgEnum("habit_entry_kind", ["check_in", "skip"]);
 var habitSource = pgEnum("habit_source", ["manual", "google_fit", "strava", "github"]);
 var recurrenceMode = pgEnum("recurrence_mode", ["rigid", "flexible"]);
 var recurrenceFreq = pgEnum("recurrence_freq", ["daily", "weekly", "monthly", "yearly"]);
@@ -3816,10 +3824,17 @@ var habits = pgTable("habits", {
   recurrenceRuleId: text("recurrence_rule_id").references(() => recurrenceRules.id),
   areaId: text("area_id").references(() => areas.id),
   source: habitSource("source").notNull().default("manual"),
-  sourceMetric: text("source_metric")
+  sourceMetric: text("source_metric"),
+  aliases: text("aliases").array().notNull().default(sql`'{}'::text[]`),
+  timeOfDay: text("time_of_day"),
+  pausedFrom: date("paused_from", { mode: "string" }),
+  pausedUntil: date("paused_until", { mode: "string" }),
+  remind: boolean("remind").notNull().default(false),
+  retiredAt: timestamp("retired_at", { withTimezone: true })
 }, (t) => [
   index("habits_tenant_idx").on(t.tenantId),
-  index("habits_tenant_area_idx").on(t.tenantId, t.areaId)
+  index("habits_tenant_area_idx").on(t.tenantId, t.areaId),
+  check("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]$'`)
 ]);
 var habitEntries = pgTable("habit_entries", {
   id: text("id").primaryKey(),
@@ -3827,9 +3842,12 @@ var habitEntries = pgTable("habit_entries", {
   habitId: text("habit_id").notNull().references(() => habits.id),
   value: doublePrecision("value").notNull().default(1),
   source: habitEntrySource("source").notNull().default("manual"),
+  kind: habitEntryKind("kind").notNull().default("check_in"),
   occurredAt: timestamp("occurred_at", { withTimezone: true }).notNull(),
   createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  externalId: text("external_id")
+  externalId: text("external_id"),
+  agentId: text("agent_id"),
+  note: text("note")
 }, (t) => [
   index("habit_entries_habit_occurred_idx").on(t.habitId, t.occurredAt),
   uniqueIndex("habit_entries_habit_external_uniq").on(t.habitId, t.externalId).where(sql`${t.externalId} IS NOT NULL`)
@@ -3874,7 +3892,8 @@ var notificationType = pgEnum("notification_type", [
   "automation",
   "streak_at_risk",
   "reflection_nudge",
-  "shutdown_nudge"
+  "shutdown_nudge",
+  "habit_reminder"
 ]);
 var notifications = pgTable("notifications", {
   id: text("id").primaryKey(),
@@ -18036,7 +18055,7 @@ var spaceSchema = createSelectSchema(tenants, {
   createdAt: exports_coerce.date(),
   updatedAt: exports_coerce.date(),
   deletedAt: exports_coerce.date().nullable()
-}).omit({ gaardHouseUrl: true });
+}).omit({ gaardHouseUrl: true, awayFrom: true, awayUntil: true });
 var backdropIdSchema = string2().trim().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "a backdrop id is lowercase words joined by dashes").max(40);
 var updateSpaceInputSchema = object({
   name: string2().trim().min(1).max(120).optional(),
@@ -18128,6 +18147,7 @@ var routineRunStepStatusSchema = _enum2(routineRunStepStatus.enumValues);
 var habitMeasurementTypeSchema = _enum2(habitMeasurementType.enumValues);
 var habitPeriodSchema = _enum2(habitPeriod.enumValues);
 var habitEntrySourceSchema = _enum2(habitEntrySource.enumValues);
+var habitEntryKindSchema = _enum2(habitEntryKind.enumValues);
 var recurrenceModeSchema = _enum2(recurrenceMode.enumValues);
 var recurrenceFreqSchema = _enum2(recurrenceFreq.enumValues);
 var recurrenceUnitSchema = _enum2(recurrenceUnit.enumValues);
@@ -18606,13 +18626,31 @@ var habitSourceSchema = _enum2(["manual", "google_fit", "strava", "github"]);
 // ../../packages/schema/src/contracts/habits.ts
 var habitSchema = createSelectSchema(habits, {
   source: habitSourceSchema.default("manual"),
-  sourceMetric: string2().nullable().default(null)
+  sourceMetric: string2().nullable().default(null),
+  aliases: array(string2()).default([]),
+  timeOfDay: string2().nullable().default(null),
+  pausedFrom: exports_iso.date().nullable().default(null),
+  pausedUntil: exports_iso.date().nullable().default(null),
+  remind: boolean3().default(false),
+  retiredAt: exports_coerce.date().nullable().default(null)
 });
 var habitEntrySchema = createSelectSchema(habitEntries, {
   occurredAt: exports_coerce.date(),
   createdAt: exports_coerce.date(),
-  externalId: string2().nullish()
+  externalId: string2().nullish(),
+  kind: habitEntryKindSchema.default("check_in"),
+  agentId: string2().nullish(),
+  note: string2().nullish()
+}).extend({
+  by: string2().nullish()
 });
+var HABIT_PARTS_OF_DAY = ["morning", "midday", "evening"];
+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 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 createHabitInputSchema = createInsertSchema(habits, {
   id: ulidSchema,
   source: habitSourceSchema.optional(),
@@ -18622,8 +18660,11 @@ var createHabitInputSchema = createInsertSchema(habits, {
   targetUnit: string2().min(1).nullish(),
   period: habitPeriodSchema.default("day"),
   frequencyCount: number2().int().positive().default(1),
-  areaId: ulidSchema.nullish()
-}).omit({ tenantId: true, recurrenceRuleId: true }).extend({
+  areaId: ulidSchema.nullish(),
+  aliases: habitAliasesSchema.optional(),
+  timeOfDay: habitTimeOfDaySchema.nullish(),
+  remind: boolean3().optional()
+}).omit({ tenantId: true, recurrenceRuleId: true, retiredAt: true }).extend({
   title: string2().min(1),
   displayKind: string2().min(1).nullish()
 });
@@ -18634,14 +18675,29 @@ var updateHabitInputSchema = createUpdateSchema(habits, {
   targetUnit: string2().min(1).nullish(),
   period: habitPeriodSchema.optional(),
   frequencyCount: number2().int().positive().optional(),
-  areaId: ulidSchema.nullish()
-}).omit({ id: true, tenantId: true, measurementType: true, recurrenceRuleId: true }).extend({ title: string2().min(1).optional() });
+  areaId: ulidSchema.nullish(),
+  aliases: habitAliasesSchema.optional(),
+  timeOfDay: habitTimeOfDaySchema.nullish(),
+  remind: boolean3().optional()
+}).omit({
+  id: true,
+  tenantId: true,
+  measurementType: true,
+  recurrenceRuleId: true,
+  pausedFrom: true,
+  pausedUntil: true,
+  retiredAt: true
+}).extend({ title: string2().min(1).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, {
   id: ulidSchema,
   value: number2().nonnegative().default(1),
   source: habitEntrySourceSchema.default("manual"),
-  occurredAt: exports_coerce.date().optional()
-}).omit({ tenantId: true, habitId: true, createdAt: true });
+  occurredAt: exports_coerce.date().optional(),
+  note: habitEntryNoteSchema.nullish()
+}).omit({ tenantId: true, habitId: true, createdAt: true, agentId: true, kind: true });
+var updateHabitEntryInputSchema = object({ note: habitEntryNoteSchema.nullable() }).strict();
 var habitStreakStateSchema = _enum2(["active", "recovering", "broken"]);
 var habitStreakSchema = object({
   current: number2().int().nonnegative(),
@@ -18652,7 +18708,8 @@ var habitStreakSchema = object({
   completionRate: number2().min(0).max(1),
   state: habitStreakStateSchema,
   graceBudget: number2().int().nonnegative(),
-  graceRemaining: number2().int().nonnegative()
+  graceRemaining: number2().int().nonnegative(),
+  skippedToday: boolean3().default(false)
 });
 var habitRoutineRefSchema = object({
   id: ulidSchema,
@@ -18661,7 +18718,19 @@ var habitRoutineRefSchema = object({
 var habitLastCheckInSchema = object({
   at: exports_coerce.date(),
   value: number2(),
-  source: habitEntrySourceSchema
+  source: habitEntrySourceSchema,
+  by: string2().nullish(),
+  id: string2().optional(),
+  note: string2().nullish()
+});
+var habitPauseSchema = object({
+  until: exports_iso.date(),
+  by: _enum2(["habit", "away"])
+});
+var habitTodaySchema = object({
+  due: boolean3(),
+  done: boolean3(),
+  week: object({ done: number2().int().nonnegative(), target: number2().int().positive() }).optional()
 });
 var habitSummarySchema = habitSchema.extend({
   title: string2(),
@@ -18669,12 +18738,16 @@ var habitSummarySchema = habitSchema.extend({
   displayKind: string2().default("default"),
   streak: habitStreakSchema,
   inRoutines: array(habitRoutineRefSchema).default([]),
-  lastCheckIn: habitLastCheckInSchema.nullable().default(null)
+  lastCheckIn: habitLastCheckInSchema.nullable().default(null),
+  pause: habitPauseSchema.nullable().default(null),
+  today: habitTodaySchema.default({ due: true, done: false })
 });
 var habitHeatmapCellSchema = object({
   date: string2(),
   value: number2(),
-  satisfied: boolean3()
+  satisfied: boolean3(),
+  rest: boolean3().default(false),
+  notes: array(string2()).optional()
 });
 var habitDetailSchema = habitSummarySchema.extend({
   heatmap: array(habitHeatmapCellSchema),
@@ -18686,11 +18759,69 @@ var habitEntriesQuerySchema = object({
   before: exports_coerce.date().optional(),
   limit: exports_coerce.number().int().min(1).max(200).default(50)
 });
+var civilDateSchema = string2().regex(/^\d{4}-\d{2}-\d{2}$/, "expected YYYY-MM-DD");
+var habitCheckInModeSchema = _enum2(["add", "set"]);
 var habitCheckInByTitleInputSchema = object({
   title: string2().trim().min(1).max(300),
   value: number2().nonnegative().optional(),
-  occurredAt: exports_coerce.date().optional()
+  mode: habitCheckInModeSchema.default("add"),
+  occurredAt: union([civilDateSchema, exports_coerce.date()]).optional(),
+  note: habitEntryNoteSchema.nullish()
+}).strict();
+var habitCandidateSchema = object({
+  id: ulidSchema,
+  title: string2(),
+  aliases: array(string2())
+});
+var habitCheckInAmbiguousSchema = object({
+  error: object({
+    code: literal("ambiguous_habit"),
+    message: string2(),
+    details: object({ candidates: array(habitCandidateSchema).min(2) })
+  })
+});
+var habitAliasInputSchema = object({ alias: habitAliasSchema }).strict();
+var habitSkipInputSchema = object({
+  date: exports_iso.date().optional(),
+  note: habitEntryNoteSchema.nullish()
 }).strict();
+var habitPauseInputSchema = object({ until: exports_iso.date() }).strict();
+var awayInputSchema = object({ until: exports_iso.date().nullable() }).strict();
+var awayStateSchema = object({
+  until: exports_iso.date().nullable()
+});
+var habitDayPartSchema = _enum2(["morning", "midday", "evening", "anytime"]);
+var habitTodayStateSchema = _enum2(["done", "open", "skipped"]);
+var habitTodayItemSchema = object({
+  habitId: ulidSchema,
+  title: string2(),
+  aliases: array(string2()).default([]),
+  measurementType: habitMeasurementTypeSchema,
+  unit: string2().nullable(),
+  target: number2().nullable(),
+  timeOfDay: string2().nullable().default(null),
+  value: number2(),
+  state: habitTodayStateSchema,
+  week: object({ done: number2().int().nonnegative(), target: number2().int().positive() }).optional(),
+  last: object({
+    source: habitEntrySourceSchema,
+    by: string2().optional(),
+    at: exports_coerce.date()
+  }).nullable().default(null)
+});
+var habitTodayRoutineSchema = object({
+  routineId: ulidSchema,
+  title: string2(),
+  timeOfDay: string2().nullable(),
+  stepsDone: number2().int().nonnegative(),
+  stepsTotal: number2().int().nonnegative()
+});
+var habitsTodayResponseSchema = 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)
+});
 
 // ../../packages/schema/src/contracts/metrics.ts
 var metricKeySchema = _enum2(["weight", "sleep", "mood"]);
@@ -18880,6 +19011,26 @@ var updateRoutineRunStepInputSchema = object({
 var updateRoutineRunInputSchema = object({
   status: routineRunStatusSchema.optional()
 }).strict();
+var routineRunsQuerySchema = object({
+  limit: exports_coerce.number().int().min(1).max(200).optional()
+});
+var routineDoneInputSchema = object({
+  id: ulidSchema.optional(),
+  occurrenceDate: exports_coerce.date().nullish()
+}).strict();
+var routineDoneStepSchema = object({
+  stepRunId: string2(),
+  title: string2(),
+  habitId: string2().nullable(),
+  habitEntryId: string2().nullable()
+});
+var routineDoneResultSchema = object({
+  run: routineRunViewSchema,
+  taken: array(routineDoneStepSchema)
+});
+var routineRunUndoInputSchema = object({
+  stepRunIds: array(string2().min(1)).min(1).max(100)
+}).strict();
 
 // ../../packages/schema/src/contracts/projects.ts
 var projectSchema = createSelectSchema(projects, {
@@ -19687,7 +19838,12 @@ var agentChangeSchema = object({
   changedAt: exports_coerce.date(),
   title: string2().nullable(),
   actor: actorRefSchema,
-  fields: array(agentChangeFieldSchema).optional()
+  fields: array(agentChangeFieldSchema).optional(),
+  checkIn: object({
+    value: number2(),
+    unit: string2().nullable(),
+    measurementType: habitMeasurementTypeSchema
+  }).optional()
 });
 var agentChangesPageSchema = object({
   data: array(agentChangeSchema),
@@ -20843,7 +20999,7 @@ function parseCapture2(input, now) {
 
 // src/meta.ts
 var CLI_NAME = "do";
-var VERSION = "1.160.0";
+var VERSION = "1.161.0";
 var API_PREFIX = "/api/v1";
 var DEFAULT_API_URL = "http://localhost:3001";
 
@@ -21104,7 +21260,14 @@ var ENTITIES = [
     readScope: "habits:read",
     returns: "HabitSummary",
     canGet: true,
-    listFlags: [AREA_FLAG, UPDATED_SINCE_FLAG],
+    listFlags: [
+      AREA_FLAG,
+      UPDATED_SINCE_FLAG,
+      {
+        name: "retired",
+        description: "list the Grown shelf (retired habits) instead of the growing ones"
+      }
+    ],
     write: {
       scope: "habits:write",
       createSchema: createHabitInputSchema,
@@ -21408,12 +21571,12 @@ var COMMAND_SPECS = [
   },
   {
     path: ["today"],
-    summary: "Show today's actionable tasks (scheduled, due, overdue, in-progress).",
+    summary: "Show today's actionable tasks (scheduled, due, overdue, in-progress), then the habits and routines due today.",
     args: [],
     flags: [],
     scopes: ["tasks:read"],
     returns: "TodaySummary",
-    notes: "Composed client-side from GET /api/v1/tasks; uses the local day from your clock."
+    notes: "Tasks are composed client-side from GET /api/v1/tasks (the local day from your clock); habits and routines come from GET /api/v1/habits/today (your saved time zone's day) under `habits`, left out when the key lacks habits:read."
   },
   {
     path: ["now"],
@@ -21474,6 +21637,15 @@ var COMMAND_SPECS = [
     scopes: ["tasks:read", "habits:read"],
     returns: "ProgressDayDetail"
   },
+  {
+    path: ["progress", "habits"],
+    summary: "Habits this week: a done/skipped grid, each habit's strength word, patterns and when you check in.",
+    args: [],
+    flags: [],
+    scopes: ["habits:read"],
+    returns: "ProgressHabitsResponse",
+    notes: "GET /api/v1/progress/habits \u2014 the week is your saved timezone's, Monday first. Strength is a word (steady, building, settling-in); patterns come from the insights worker with a confidence label."
+  },
   {
     path: ["search"],
     summary: "Search node titles and note bodies across the Space.",
@@ -21561,22 +21733,76 @@ var COMMAND_SPECS = [
         description: "Amount logged (binary habits use 1).",
         default: "1"
       },
-      { name: "at", type: "string", description: "When it occurred (ISO); defaults to now." }
+      { name: "at", type: "string", description: "When it occurred (ISO); defaults to now." },
+      {
+        name: "note",
+        type: "string",
+        description: 'A short note on the check-in ("felt heavy"), at most 280 characters.'
+      }
     ],
     scopes: ["habits:write"],
     returns: "HabitSummary"
   },
   {
     path: ["habit", "check-in"],
-    summary: 'Check a habit in by its title ("did my run").',
-    args: [{ name: "title", required: true, description: "The habit's exact title." }],
+    summary: 'Check a habit in by its title or an alias ("wake", "did my run").',
+    args: [
+      { name: "title", required: true, description: "The habit's title or one of its aliases." }
+    ],
     flags: [
       { name: "value", type: "string", description: "Amount logged; defaults to 1." },
-      { name: "at", type: "string", description: "When it occurred (ISO); defaults to now." }
+      {
+        name: "set",
+        type: "boolean",
+        description: "Make --value the day's total instead of adding it (amount habits)."
+      },
+      {
+        name: "at",
+        type: "string",
+        description: "When it occurred: an ISO instant, or a day (YYYY-MM-DD, your time zone); defaults to now."
+      },
+      {
+        name: "note",
+        type: "string",
+        description: 'A short note on the check-in ("felt heavy"), at most 280 characters.'
+      }
     ],
     scopes: ["habits:write"],
     returns: "HabitSummary",
-    notes: "POST /api/v1/habits/check-in. Exact title (case-insensitive); several matches \u2192 409, none \u2192 404 naming close titles; a habit counted from Google Fit, Strava or GitHub \u2192 409."
+    notes: `POST /api/v1/habits/check-in. Title or alias, case-insensitive; several matches \u2192 409 with error.details.candidates (id, title, aliases), none \u2192 404 naming close titles; a habit counted from Google Fit, Strava or GitHub \u2192 409. --set writes the difference to the day's total as its own check-in. An Agent's key records the check-in as that Agent's ("Echo, 07:12"). --note puts a short note on it ("drill done, felt heavy" \u2192 --note "felt heavy"); the reply's lastCheckIn.id is the check-in, for \`do habit note\` later.`
+  },
+  {
+    path: ["habit", "alias", "add"],
+    summary: 'Give a habit another name check-ins match ("wake" for "Wake up by 07:00").',
+    args: [
+      { name: "id", required: true, description: "Habit ULID." },
+      { name: "alias", required: true, description: "The other name." }
+    ],
+    flags: [],
+    scopes: ["habits:write"],
+    returns: "HabitSummary",
+    notes: "POST /api/v1/habits/:id/aliases. One already there (ignoring case) is a no-op; at most 12."
+  },
+  {
+    path: ["habit", "alias", "rm"],
+    summary: "Drop one of a habit's aliases.",
+    args: [
+      { name: "id", required: true, description: "Habit ULID." },
+      { name: "alias", required: true, description: "The alias to drop (ignoring case)." }
+    ],
+    flags: [],
+    scopes: ["habits:write"],
+    returns: "HabitSummary",
+    notes: "DELETE /api/v1/habits/:id/aliases/:alias. 404 when the habit doesn't have it."
+  },
+  {
+    path: ["habits", "today"],
+    summary: "What's left today: the habits due by part of day, and today's routines.",
+    args: [],
+    flags: [],
+    scopes: ["habits:read"],
+    returns: "HabitsTodayResponse",
+    notes: "GET /api/v1/habits/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."
   },
   {
     path: ["habit", "check-ins"],
@@ -21589,6 +21815,149 @@ var COMMAND_SPECS = [
     scopes: ["habits:read"],
     returns: "HabitEntry"
   },
+  {
+    path: ["habit", "note"],
+    summary: 'Put a note on a check-in afterwards ("felt heavy"), or clear it.',
+    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)."
+      },
+      { name: "note", required: false, description: "The note, at most 280 characters." }
+    ],
+    flags: [{ name: "clear", type: "boolean", description: "Drop the check-in's note." }],
+    scopes: ["habits:write"],
+    returns: "HabitEntry",
+    notes: "PATCH /api/v1/habits/{id}/check-ins/{entryId}. Replaces the note; the amount and time stay (undo a wrong check-in instead). A skip's note is its why."
+  },
+  {
+    path: ["habit", "skip"],
+    summary: 'Skip a day: a neutral rest day, never a miss ("skip gym today").',
+    args: [{ name: "id", required: true, description: "Habit ULID." }],
+    flags: [
+      { name: "date", type: "string", description: "The day (YYYY-MM-DD); defaults to today." },
+      {
+        name: "note",
+        type: "string",
+        description: 'Why, if you like ("Dentist"); shows in the log.'
+      }
+    ],
+    scopes: ["habits:write"],
+    returns: "HabitSummary",
+    notes: "POST /api/v1/habits/{id}/skip. The streak treats the period as neutral and spends no grace; the habit leaves Now for the day. Skipping a skipped day changes nothing. Undo: delete the skip entry (`do habit check-ins <id>` lists it with kind `skip`)."
+  },
+  {
+    path: ["routine", "done"],
+    summary: `All taken: check in every open step of today's routine in one go ("took my supplements").`,
+    args: [
+      {
+        name: "id",
+        required: true,
+        description: "Routine ULID (`do habits today` lists today's)."
+      }
+    ],
+    flags: [],
+    scopes: ["routines:write"],
+    returns: "RoutineDoneResult",
+    notes: "POST /api/v1/routines/{id}/done. Today's run (your saved time zone's day), started if there's none. Each habit step checks in its habit; a habit already done today isn't counted twice; a step whose habit is skipped today is left alone. Calling it again changes nothing. Returns `run` and `taken` (the steps it resolved). Undo all of it with `do routine undo <run.id> <taken stepRunIds\u2026>`."
+  },
+  {
+    path: ["routine", "undo"],
+    summary: "Take an All taken back in one go: its steps reopen and lose their check-ins.",
+    args: [
+      {
+        name: "runId",
+        required: true,
+        description: "The run's ULID (`run.id` from `do routine done`)."
+      },
+      {
+        name: "stepRunIds",
+        required: true,
+        description: "The `taken` step ids from `do routine done`, space- or comma-separated."
+      }
+    ],
+    flags: [],
+    scopes: ["routines:write"],
+    returns: "RoutineRunView",
+    notes: "POST /api/v1/routines/runs/{runId}/undo. Exactly the check-ins those steps wrote are removed; a finished run reopens. Steps no longer done are left alone."
+  },
+  {
+    path: ["habit", "pause"],
+    summary: "Pause a habit until the day it's back: 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."
+      }
+    ],
+    scopes: ["habits:write"],
+    returns: "HabitSummary",
+    notes: "POST /api/v1/habits/{id}/pause. Pausing a paused habit moves the day it's back. Paused days are neutral: the streak is frozen, never broken."
+  },
+  {
+    path: ["habit", "remind"],
+    summary: "Turn a habit's daily reminder on or off: one push at its time, never a follow-up.",
+    args: [
+      { name: "id", required: true, description: "Habit ULID." },
+      { name: "state", required: true, description: "`on` or `off`." }
+    ],
+    flags: [],
+    scopes: ["habits:write"],
+    returns: "HabitSummary",
+    notes: "PATCH /api/v1/habits/{id} {remind}. Off by default. On, the habit sends one Web Push a day at its time of day (a part of day: morning 08:00, midday 12:00, evening 18:00; none: 09:00), only in waking hours (07:00\u201322:00), with Done / +1 / Skip today buttons; not when it's done, skipped, paused or off today."
+  },
+  {
+    path: ["habit", "resume"],
+    summary: "Resume a paused habit: it's back today.",
+    args: [{ name: "id", required: true, description: "Habit ULID." }],
+    flags: [],
+    scopes: ["habits:write"],
+    returns: "HabitSummary",
+    notes: "POST /api/v1/habits/{id}/resume. The rest so far stays neutral."
+  },
+  {
+    path: ["habit", "retire"],
+    summary: `Retire a habit to the Grown shelf ("I'm done with the cold showers habit"): history kept.`,
+    args: [{ name: "id", required: true, description: "Habit ULID." }],
+    flags: [],
+    scopes: ["habits:write"],
+    returns: "HabitSummary",
+    notes: "POST /api/v1/habits/{id}/retire. Not a delete: it keeps every check-in and its plant blooms on the Grown shelf. It leaves Now and Today, sends no push, takes no check-in by title and is never due; Progress keeps its past. `do habits list --retired` lists the shelf. Undo: `do habit unretire <id>`."
+  },
+  {
+    path: ["habit", "unretire"],
+    summary: "Bring a grown (retired) habit back: growing again from today.",
+    args: [{ name: "id", required: true, description: "Habit ULID." }],
+    flags: [],
+    scopes: ["habits:write"],
+    returns: "HabitSummary",
+    notes: "POST /api/v1/habits/{id}/unretire. Its history is intact."
+  },
+  {
+    path: ["away"],
+    summary: 'Away until a day ("away till Monday"): every habit rests. `do away off` comes back.',
+    args: [
+      {
+        name: "off",
+        required: false,
+        description: "`off` comes back now; omit it (and --until) to show the away state."
+      }
+    ],
+    flags: [
+      {
+        name: "until",
+        type: "string",
+        description: "The day you're back (YYYY-MM-DD), after today."
+      }
+    ],
+    scopes: ["habits:read", "habits:write"],
+    returns: "AwayState",
+    notes: "GET/PUT /api/v1/habits/away. While away, habits leave Now, reminders stop and plants wait; tasks and events carry on. Reading needs habits:read, setting habits:write."
+  },
   {
     path: ["metrics", "list"],
     summary: "Show weight, sleep and mood as daily trend lines (no target, no streak).",
@@ -22756,15 +23125,81 @@ function renderTask(data, mode) {
 }
 function renderToday(data, mode) {
   const result = data;
-  if (result.count === 0) {
-    return paint(mode, "green", `Nothing scheduled for ${result.date}. Inbox zero. \u2713`);
-  }
-  const header = paint(mode, "bold", `Today \xB7 ${result.date} \xB7 ${result.count} item(s)`);
-  const lines = result.items.map((item) => {
-    const tag = paint(mode, bucketColor(item.bucket), `[${item.bucket}]`);
-    const star = item.starred ? paint(mode, "yellow", " \u2605") : "";
-    return `  ${tag} ${item.title}${star}  ${paint(mode, "dim", item.id)}`;
-  });
+  const tasks = result.count === 0 ? paint(mode, "green", `Nothing scheduled for ${result.date}. Inbox zero. \u2713`) : [
+    paint(mode, "bold", `Today \xB7 ${result.date} \xB7 ${result.count} item(s)`),
+    ...result.items.map((item) => {
+      const tag = paint(mode, bucketColor(item.bucket), `[${item.bucket}]`);
+      const star = item.starred ? paint(mode, "yellow", " \u2605") : "";
+      return `  ${tag} ${item.title}${star}  ${paint(mode, "dim", item.id)}`;
+    })
+  ].join(`
+`);
+  const habits = result.habits ? habitLines(result.habits, mode) : [];
+  return habits.length > 0 ? `${tasks}
+
+${habits.join(`
+`)}` : tasks;
+}
+var PART_LABEL = {
+  morning: "Morning",
+  midday: "Midday",
+  evening: "Evening",
+  anytime: "Any time today"
+};
+function clock(at, timezone) {
+  return new Intl.DateTimeFormat("en-GB", {
+    timeZone: timezone,
+    hour: "2-digit",
+    minute: "2-digit",
+    hourCycle: "h23"
+  }).format(new Date(at));
+}
+function civilDay(at, timezone) {
+  return new Intl.DateTimeFormat("en-CA", {
+    timeZone: timezone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).format(new Date(at));
+}
+function habitLines(day, mode) {
+  const lines = [];
+  for (const group of day.groups) {
+    lines.push(paint(mode, "bold", PART_LABEL[group.part]));
+    for (const h of group.habits) {
+      const mark = h.state === "done" ? paint(mode, "green", "\u2713") : h.state === "skipped" ? paint(mode, "dim", "\u2013") : "\u25CB";
+      const meta = [];
+      if (h.timeOfDay)
+        meta.push(h.timeOfDay);
+      if (h.target !== null && h.measurementType !== "binary") {
+        meta.push(`${h.value} of ${h.target}${h.unit ? ` ${h.unit}` : ""}`);
+      }
+      if (h.week)
+        meta.push(`${h.week.done} of ${h.week.target} this week`);
+      if (h.last?.by && civilDay(h.last.at, day.timezone) === day.date) {
+        meta.push(`${h.last.by}, ${clock(h.last.at, day.timezone)}`);
+      }
+      const tail = meta.length > 0 ? paint(mode, "dim", ` \xB7 ${meta.join(" \xB7 ")}`) : "";
+      lines.push(`  ${mark} ${h.title}${tail}  ${paint(mode, "dim", h.habitId)}`);
+    }
+  }
+  if (day.routines.length > 0) {
+    lines.push(paint(mode, "bold", "Routines"));
+    for (const r of day.routines) {
+      const when = r.timeOfDay ? ` ${r.timeOfDay}` : "";
+      const steps = paint(mode, "dim", ` \xB7 ${r.stepsDone} of ${r.stepsTotal} steps`);
+      lines.push(`  ${r.title}${when}${steps}  ${paint(mode, "dim", r.routineId)}`);
+    }
+  }
+  return lines;
+}
+function renderHabitsToday(data, mode) {
+  const day = data;
+  const lines = habitLines(day, mode);
+  const header = paint(mode, "bold", `Habits \xB7 ${day.date} (${day.timezone})`);
+  if (lines.length === 0)
+    return `${header}
+Nothing due today.`;
   return [header, ...lines].join(`
 `);
 }
@@ -22779,13 +23214,45 @@ function bucketColor(bucket) {
 }
 function renderHabit(data, mode) {
   const h = data;
+  if (h.retiredAt) {
+    return `${h.title ?? "(habit)"} \u2014 grown ${h.retiredAt.slice(0, 10)}, on the Grown shelf with its history
+  ${paint(mode, "dim", h.id)}`;
+  }
   const streak = h.streak;
   const flame = streak?.satisfiedToday ? paint(mode, "green", "\u2713 today") : "not yet today";
   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})` : "";
-  return `${h.title ?? "(habit)"} \u2014 ${flame}${pct}${counts}${recovering}
-  ${paint(mode, "dim", h.id)}`;
+  const rest = h.pause ? ` \xB7 ${h.pause.by === "away" ? "away" : "paused"}, back ${h.pause.until}` : 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}
+  ${paint(mode, "dim", h.id)}${last}`;
+}
+function renderHabitEntry(data, mode) {
+  const e = data;
+  const said = e.note ? `Noted: "${e.note}"` : "No note.";
+  return `${said}
+  ${paint(mode, "dim", e.id ?? "")}`;
+}
+function renderRoutineDone(data, mode) {
+  const d = data;
+  const title = d.run?.routineTitle ?? "(routine)";
+  const taken = d.taken ?? [];
+  if (taken.length === 0)
+    return `${title}: nothing left to check in today.`;
+  const names = taken.map((t) => t.title).join(", ");
+  const undo = `do routine undo ${d.run?.id ?? "<run>"} ${taken.map((t) => t.stepRunId).join(" ")}`;
+  return `${title}: checked in ${names}.
+  ${paint(mode, "dim", `undo: ${undo}`)}`;
+}
+function renderRoutineUndo(data) {
+  const run = data;
+  return `${run.routineTitle ?? "(routine)"}: undone. Those check-ins are gone.`;
+}
+function renderAway(data) {
+  const until = data.until;
+  return until ? `Away until ${until}. Habits are resting; tasks carry on.` : "Here. Habits are on.";
 }
 function renderWhoami(data, mode) {
   const w = data;
@@ -23076,6 +23543,44 @@ function renderProgress(data, mode) {
   return out.join(`
 `);
 }
+var CELL = {
+  done: "\u25A0",
+  skipped: "\u2013",
+  empty: "\xB7",
+  ahead: " "
+};
+var hh = (h) => `${String(h).padStart(2, "0")}:00`;
+var usually = (when) => when?.usual ? `usually ${hh(when.usual.from)}\u2013${hh(when.usual.to)}` : null;
+function renderProgressHabits(data, mode) {
+  const p = data;
+  const out = [
+    paint(mode, "bold", `Habits \xB7 week of ${p.week?.from ?? "?"} \u2192 ${p.week?.to ?? "?"} (${p.timezone ?? "?"})`)
+  ];
+  const habits = p.habits ?? [];
+  if (habits.length === 0)
+    out.push(paint(mode, "dim", "  (no habits yet)"));
+  const width = Math.max(0, ...habits.map((h) => h.name.length));
+  for (const h of habits) {
+    const cells = h.week.map((d) => CELL[d.state]).join(" ");
+    const count = h.weekOf === null ? `${h.weekDone} done` : `${h.weekDone} of ${h.weekOf}`;
+    const extra = [h.strengthWord.replace("-", " "), usually(h.when)].filter(Boolean).join(" \xB7 ");
+    out.push(`  ${h.name.padEnd(width)}  ${cells}  ${count} \xB7 ${extra}`);
+  }
+  const patterns = p.patterns ?? [];
+  out.push("", paint(mode, "bold", "Patterns"));
+  if (patterns.length === 0) {
+    out.push(paint(mode, "dim", "  (none yet: patterns need a few weeks of check-ins)"));
+  }
+  for (const x of patterns) {
+    out.push(`  ${x.title}`, `    ${x.body}`, `    ${paint(mode, "dim", x.confidenceLabel)}`);
+  }
+  const when = usually(p.when);
+  if (when && p.when) {
+    out.push("", `When  ${when} (${Math.round((p.when.usual?.share ?? 0) * 100)}% of ${p.when.checkins} check-ins)`);
+  }
+  return out.join(`
+`);
+}
 function renderProgressDay(data, mode) {
   const d = data;
   const done = d.done ?? [];
@@ -23229,7 +23734,7 @@ async function dispatchEntity(entity, rest, flags, requireClient) {
   if (op === "list") {
     const query = {};
     for (const f of entity.listFlags) {
-      const value = flagString(flags, f.name);
+      const value = flags[f.name] === true ? "true" : flagString(flags, f.name);
       if (value !== undefined)
         query[f.query ?? f.name] = value;
       else if (f.required)
@@ -23347,8 +23852,16 @@ var HANDLERS = {
       tasks.push(...page.data);
       cursor = page.nextCursor ?? undefined;
     } while (cursor);
+    const habits = await client.get("/habits/today").catch((error) => {
+      if (error instanceof CliError && (error.code === "auth" || error.exitCode === EXIT.NOT_FOUND))
+        return;
+      throw error;
+    });
     return {
-      data: selectToday(tasks, io.now()),
+      data: {
+        ...selectToday(tasks, io.now()),
+        ...Array.isArray(habits?.groups) ? { habits } : {}
+      },
       render: renderToday
     };
   },
@@ -23403,6 +23916,10 @@ var HANDLERS = {
     data: await requireClient().get("/progress", { query: { days: flagString(flags, "days") } }),
     render: renderProgress
   }),
+  "progress habits": async ({ requireClient }) => ({
+    data: await requireClient().get("/progress/habits"),
+    render: renderProgressHabits
+  }),
   "progress day": async ({ args, requireClient }) => {
     const date = requireArg(args, 0, "date");
     if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
@@ -23592,10 +24109,12 @@ var HANDLERS = {
     if (Number.isNaN(value))
       throw usageError("--value must be a number");
     const at = flagString(flags, "at");
+    const note = flagString(flags, "note");
     const input = parseInput(createHabitEntryInputSchema, {
       id: ulid3(),
       value,
-      ...at ? { occurredAt: at } : {}
+      ...at ? { occurredAt: at } : {},
+      ...note !== undefined ? { note } : {}
     });
     return {
       data: await requireClient().post(`/habits/${id}/check-ins`, input),
@@ -23611,13 +24130,44 @@ var HANDLERS = {
     if (value !== undefined && Number.isNaN(value))
       throw usageError("--value must be a number");
     const at = flagString(flags, "at");
+    const set = flags.set === true;
+    if (set && value === undefined)
+      throw usageError("--set needs --value, the day's new total");
+    const note = flagString(flags, "note");
     const input = parseInput(habitCheckInByTitleInputSchema, {
       title,
       ...value !== undefined ? { value } : {},
-      ...at ? { occurredAt: at } : {}
+      mode: set ? "set" : "add",
+      ...at ? { occurredAt: at } : {},
+      ...note !== undefined ? { note } : {}
     });
     return { data: await requireClient().post("/habits/check-in", input), render: renderHabit };
   },
+  "habit alias add": async ({ args, requireClient }) => {
+    const id = requireArg(args, 0, "habit id");
+    const alias = args.slice(1).join(" ").trim();
+    if (!alias)
+      throw usageError("habit alias add needs an alias, e.g. `do habit alias add <id> wake`");
+    const input = parseInput(habitAliasInputSchema, { alias });
+    return {
+      data: await requireClient().post(`/habits/${id}/aliases`, input),
+      render: renderHabit
+    };
+  },
+  "habit alias rm": async ({ args, requireClient }) => {
+    const id = requireArg(args, 0, "habit id");
+    const alias = args.slice(1).join(" ").trim();
+    if (!alias)
+      throw usageError("habit alias rm needs the alias to drop");
+    return {
+      data: await requireClient().delete(`/habits/${id}/aliases/${encodeURIComponent(alias)}`),
+      render: renderHabit
+    };
+  },
+  "habits today": async ({ requireClient }) => ({
+    data: await requireClient().get("/habits/today"),
+    render: renderHabitsToday
+  }),
   "habit check-ins": async ({ args, flags, requireClient }) => {
     const id = requireArg(args, 0, "habit id");
     const query = {
@@ -23629,6 +24179,92 @@ var HANDLERS = {
       render: renderList
     };
   },
+  "habit note": async ({ args, flags, requireClient }) => {
+    const id = requireArg(args, 0, "habit id");
+    const entryId = requireArg(args, 1, "check-in id");
+    const text = args.slice(2).join(" ").trim();
+    const clear = flags.clear === true;
+    if (clear && text)
+      throw usageError("habit note takes a note or --clear, not both");
+    if (!clear && !text)
+      throw usageError('habit note needs the note, e.g. `do habit note <id> <check-in id> "felt heavy"`');
+    const input = parseInput(updateHabitEntryInputSchema, { note: clear ? null : text });
+    return {
+      data: await requireClient().patch(`/habits/${id}/check-ins/${entryId}`, input),
+      render: renderHabitEntry
+    };
+  },
+  "habit skip": async ({ args, flags, requireClient }) => {
+    const id = requireArg(args, 0, "habit id");
+    const date = flagString(flags, "date");
+    const note = flagString(flags, "note");
+    const input = parseInput(habitSkipInputSchema, {
+      ...date ? { date } : {},
+      ...note !== undefined ? { note } : {}
+    });
+    return { data: await requireClient().post(`/habits/${id}/skip`, input), render: renderHabit };
+  },
+  "habit pause": 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 });
+    return { data: await requireClient().post(`/habits/${id}/pause`, input), render: renderHabit };
+  },
+  "habit remind": async ({ args, requireClient }) => {
+    const id = requireArg(args, 0, "habit id");
+    const state = requireArg(args, 1, "on|off");
+    if (state !== "on" && state !== "off")
+      throw usageError("habit remind takes `on` or `off`");
+    const input = parseInput(updateHabitInputSchema, { remind: state === "on" });
+    return { data: await requireClient().patch(`/habits/${id}`, input), render: renderHabit };
+  },
+  "habit resume": async ({ args, requireClient }) => {
+    const id = requireArg(args, 0, "habit id");
+    return { data: await requireClient().post(`/habits/${id}/resume`, {}), render: renderHabit };
+  },
+  "habit retire": async ({ args, requireClient }) => {
+    const id = requireArg(args, 0, "habit id");
+    return { data: await requireClient().post(`/habits/${id}/retire`, {}), render: renderHabit };
+  },
+  "habit unretire": async ({ args, requireClient }) => {
+    const id = requireArg(args, 0, "habit id");
+    return { data: await requireClient().post(`/habits/${id}/unretire`, {}), render: renderHabit };
+  },
+  away: async ({ args, flags, requireClient }) => {
+    const until = flagString(flags, "until");
+    const off = args[0] === "off";
+    if (args.length > 0 && !off)
+      throw usageError("`do away` takes `off`, or --until <YYYY-MM-DD>");
+    if (off && until)
+      throw usageError("`do away off` comes back now; it takes no --until");
+    if (!off && !until) {
+      return { data: await requireClient().get("/habits/away"), render: renderAway };
+    }
+    const input = parseInput(awayInputSchema, { until: off ? null : until });
+    return { data: await requireClient().put("/habits/away", input), render: renderAway };
+  },
+  "routine done": async ({ args, requireClient }) => {
+    const id = requireArg(args, 0, "routine id");
+    const input = parseInput(routineDoneInputSchema, {});
+    return {
+      data: await requireClient().post(`/routines/${id}/done`, input),
+      render: renderRoutineDone
+    };
+  },
+  "routine undo": async ({ args, requireClient }) => {
+    const runId = requireArg(args, 0, "run id");
+    const stepRunIds = args.slice(1).flatMap((a) => a.split(",")).map((a) => a.trim()).filter(Boolean);
+    if (stepRunIds.length === 0) {
+      throw usageError("routine undo needs the step ids `do routine done` printed, e.g. `do routine undo <run> <step> <step>`");
+    }
+    const input = parseInput(routineRunUndoInputSchema, { stepRunIds });
+    return {
+      data: await requireClient().post(`/routines/runs/${runId}/undo`, input),
+      render: renderRoutineUndo
+    };
+  },
   "metrics list": async ({ flags, requireClient }) => {
     const query = { days: flagString(flags, "days") };
     return { data: await requireClient().get("/metrics", { query }), render: renderList };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robbeverhelst/do",
-  "version": "1.160.0",
+  "version": "1.161.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",