@robbeverhelst/do 1.160.0 → 1.162.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 })
@@ -3572,6 +3574,7 @@ var agents = pgTable("agents", {
   tenantId: text("tenant_id").notNull().references(() => tenants.id),
   name: text("name").notNull(),
   revokedAt: timestamp("revoked_at", { withTimezone: true }),
+  trustedDesks: text("trusted_desks").array().notNull().default([]),
   createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
   updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
 }, (t) => [
@@ -3597,8 +3600,13 @@ var areas = pgTable("areas", {
   color: areaColor("color").notNull().default("teal"),
   icon: text("icon"),
   reviewCadence: reviewCadence("review_cadence"),
-  archivedAt: timestamp("archived_at", { withTimezone: true })
-}, (t) => [index("areas_tenant_idx").on(t.tenantId)]);
+  archivedAt: timestamp("archived_at", { withTimezone: true }),
+  purpose: text("purpose"),
+  standards: jsonb("standards").$type().notNull().default(sql`'[]'::jsonb`)
+}, (t) => [
+  index("areas_tenant_idx").on(t.tenantId),
+  check("areas_standards_chk", sql`jsonb_typeof(${t.standards}) = 'array' AND jsonb_array_length(${t.standards}) <= 5`)
+]);
 
 // ../../packages/schema/src/db/core.ts
 var routineKind = pgEnum("routine_kind", ["sequence", "time_blocked", "checklist"]);
@@ -3746,7 +3754,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"]);
@@ -3788,7 +3802,12 @@ var tasks = pgTable("tasks", {
   completedByUserId: text("completed_by_user_id"),
   completedByAgentId: text("completed_by_agent_id"),
   placeId: text("place_id").references(() => places.id, { onDelete: "set null" }),
-  filingSuggestion: jsonb("filing_suggestion").$type()
+  filingSuggestion: jsonb("filing_suggestion").$type(),
+  proposedAt: timestamp("proposed_at", { withTimezone: true }),
+  proposedDesk: text("proposed_desk"),
+  notNowUntil: timestamp("not_now_until", { withTimezone: true }),
+  readyAt: timestamp("ready_at", { withTimezone: true }),
+  readyNote: text("ready_note")
 }, (t) => [
   index("tasks_tenant_project_idx").on(t.tenantId, t.projectId),
   index("tasks_tenant_place_idx").on(t.tenantId, t.placeId),
@@ -3803,6 +3822,8 @@ var tasks = pgTable("tasks", {
   index("tasks_tenant_scheduled_idx").on(t.tenantId, t.scheduledAt),
   index("tasks_tenant_due_idx").on(t.tenantId, t.dueAt),
   index("tasks_tenant_completed_idx").on(t.tenantId, t.completedAt),
+  index("tasks_tenant_proposed_idx").on(t.tenantId, t.proposedAt).where(sql`${t.proposedAt} IS NOT NULL`),
+  index("tasks_tenant_ready_idx").on(t.tenantId, t.readyAt).where(sql`${t.readyAt} IS NOT NULL`),
   check("tasks_area_xor_project_chk", sql`${t.projectId} IS NULL OR ${t.areaId} IS NULL`)
 ]);
 var habits = pgTable("habits", {
@@ -3816,10 +3837,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 +3855,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 +3905,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 +18068,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 +18160,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);
@@ -18153,13 +18186,20 @@ var reflectionKindSchema = _enum2(reflectionKind.enumValues);
 
 // ../../packages/schema/src/contracts/agents.ts
 var agentSchema = createSelectSchema(agents, {
+  trustedDesks: array(string2()).default([]),
   revokedAt: exports_coerce.date().nullable(),
   createdAt: exports_coerce.date(),
   updatedAt: exports_coerce.date()
 });
 var agentNameSchema = string2().trim().min(1).max(60);
 var createAgentInputSchema = object({ name: agentNameSchema }).strict();
-var updateAgentInputSchema = object({ name: agentNameSchema }).strict();
+var deskSchema = string2().trim().toLowerCase().regex(/^[a-z0-9][a-z0-9_-]{0,39}$/, "a desk is a lower-case slug like `finance`");
+var updateAgentInputSchema = object({
+  name: agentNameSchema.optional(),
+  trustedDesks: array(deskSchema).max(40).transform((desks) => [...new Set(desks)]).optional()
+}).strict().refine((v) => v.name !== undefined || v.trustedDesks !== undefined, {
+  message: "send a name or trustedDesks"
+});
 var actorKindSchema = _enum2(["member", "agent"]);
 var actorRefSchema = object({
   kind: actorKindSchema,
@@ -18322,9 +18362,13 @@ var taskSchema = createSelectSchema(tasks, {
   startAt: exports_coerce.date().nullable(),
   dueAt: exports_coerce.date().nullable(),
   completedAt: exports_coerce.date().nullable().default(null),
-  placeId: string2().nullable().default(null)
+  placeId: string2().nullable().default(null),
+  proposedAt: exports_coerce.date().nullable().default(null),
+  proposedDesk: string2().nullable().default(null),
+  notNowUntil: exports_coerce.date().nullable().default(null),
+  readyAt: exports_coerce.date().nullable().default(null),
+  readyNote: string2().nullable().default(null)
 });
-var deskSchema = string2().trim().toLowerCase().regex(/^[a-z0-9][a-z0-9_-]{0,39}$/, "a desk is a lower-case slug like `finance`");
 var PARTY_RE = /^(?:(me)|(member|agent):([^/]+?))(?:\/(.+))?$/;
 function partySchema(allowDesk) {
   return string2().trim().min(1).max(200).transform((raw, ctx) => {
@@ -18419,7 +18463,12 @@ var createTaskInputSchema = createInsertSchema(tasks, {
   waitingSince: true,
   completedByUserId: true,
   completedByAgentId: true,
-  filingSuggestion: true
+  filingSuggestion: true,
+  proposedAt: true,
+  proposedDesk: true,
+  notNowUntil: true,
+  readyAt: true,
+  readyNote: true
 }).extend({
   title: string2().min(1),
   parentId: ulidSchema.nullish(),
@@ -18429,8 +18478,12 @@ var createTaskInputSchema = createInsertSchema(tasks, {
   owner: taskOwnerInputSchema.nullish(),
   waitingOn: taskWaitingOnInputSchema.nullish(),
   source: taskSourceSchema.nullish(),
-  nextStep: taskNextStepSchema.nullish()
+  nextStep: taskNextStepSchema.nullish(),
+  proposed: boolean3().optional(),
+  fromDesk: deskSchema.nullish()
 });
+var taskReadyNoteSchema = string2().trim().min(1).max(500);
+var markTaskReadyInputSchema = object({ note: taskReadyNoteSchema.nullish() }).strict();
 var updateTaskInputSchema = createUpdateSchema(tasks, {
   completedAt: completedAtInputSchema,
   scheduledAt: exports_coerce.date().nullish(),
@@ -18453,7 +18506,10 @@ var updateTaskInputSchema = createUpdateSchema(tasks, {
   waitingSince: true,
   completedByUserId: true,
   completedByAgentId: true,
-  filingSuggestion: true
+  filingSuggestion: true,
+  proposedAt: true,
+  proposedDesk: true,
+  readyAt: true
 }).extend({
   title: string2().min(1).optional(),
   parentId: ulidSchema.nullish(),
@@ -18462,7 +18518,11 @@ var updateTaskInputSchema = createUpdateSchema(tasks, {
   owner: taskOwnerInputSchema.nullish(),
   waitingOn: taskWaitingOnInputSchema.nullish(),
   source: taskSourceSchema.nullish(),
-  nextStep: taskNextStepSchema.nullish()
+  nextStep: taskNextStepSchema.nullish(),
+  proposed: boolean3().optional(),
+  notNowUntil: exports_coerce.date().nullish(),
+  ready: boolean3().optional(),
+  readyNote: taskReadyNoteSchema.nullish()
 }).strict();
 var taskListFilterSchema = _enum2(["all", "unsorted", "starred"]);
 
@@ -18606,13 +18666,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 +18700,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 +18715,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 +18748,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 +18758,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 +18778,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 +18799,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 +19051,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, {
@@ -18977,15 +19168,50 @@ var attachedNoteViewSchema = object({
 var setAttachedNoteInputSchema = object({ body: string2().max(ATTACHED_NOTE_BODY_MAX) }).strict();
 
 // ../../packages/schema/src/contracts/areas.ts
-var areaSchema = createSelectSchema(areas);
+var areaPurposeSchema = string2().trim().max(140).transform((v) => v.length === 0 ? null : v);
+var areaStandardTextSchema = string2().trim().min(1).max(120);
+var linkedNodeIdSchema = string2().trim().min(1).max(64);
+var areaStandardLinkSchema = discriminatedUnion("kind", [
+  object({ kind: literal("habit"), id: linkedNodeIdSchema }).strict(),
+  object({ kind: literal("task"), id: linkedNodeIdSchema }).strict(),
+  object({ kind: literal("metric"), key: metricKeySchema }).strict()
+]);
+var areaStandardSchema = object({
+  id: string2(),
+  text: string2(),
+  link: areaStandardLinkSchema.nullable().default(null)
+});
+var areaStandardInputSchema = object({
+  id: string2().min(1).max(64).optional(),
+  text: areaStandardTextSchema,
+  link: areaStandardLinkSchema.nullish()
+}).strict();
+var addAreaStandardInputSchema = object({ text: areaStandardTextSchema, link: areaStandardLinkSchema.nullish() }).strict();
+var updateAreaStandardInputSchema = object({
+  text: areaStandardTextSchema.optional(),
+  link: areaStandardLinkSchema.nullable().optional()
+}).strict();
+var areaStandardStateSchema = _enum2(["holding", "worth_a_look"]);
+var areaStandardViewSchema = areaStandardSchema.extend({
+  state: areaStandardStateSchema.nullable(),
+  why: string2().nullable(),
+  heldBy: string2().nullable()
+});
+var areaSchema = createSelectSchema(areas, {
+  purpose: string2().nullable().default(null),
+  standards: array(areaStandardSchema).default([])
+});
 var areaIconSchema = string2().trim().min(1).max(64);
 var createAreaInputSchema = createInsertSchema(areas, {
   id: ulidSchema,
-  icon: areaIconSchema.nullish()
-}).omit({ tenantId: true, archivedAt: true }).extend({ title: string2().min(1) });
+  icon: areaIconSchema.nullish(),
+  purpose: areaPurposeSchema.nullish()
+}).omit({ tenantId: true, archivedAt: true, standards: true }).extend({ title: string2().min(1) });
 var updateAreaInputSchema = createUpdateSchema(areas, {
   icon: areaIconSchema.nullish(),
-  archivedAt: exports_coerce.date().nullish()
+  archivedAt: exports_coerce.date().nullish(),
+  purpose: areaPurposeSchema.nullish(),
+  standards: array(areaStandardInputSchema).max(5).optional()
 }).omit({ id: true, tenantId: true }).extend({ title: string2().min(1).optional() }).strict();
 var areaViewSchema = areaSchema.extend({
   title: string2(),
@@ -18996,12 +19222,14 @@ var areaViewSchema = areaSchema.extend({
   projectCount: number2().int().min(0),
   taskCount: number2().int().min(0),
   habitCount: number2().int().min(0),
-  routineCount: number2().int().min(0)
+  routineCount: number2().int().min(0),
+  standardsWorthALook: number2().int().min(0).default(0)
 });
 var areaProjectSchema = projectViewSchema.extend({
   tasks: array(taskViewSchema)
 });
 var areaDetailSchema = areaViewSchema.extend({
+  standards: array(areaStandardViewSchema).default([]),
   projects: array(areaProjectSchema),
   habits: array(habitSummarySchema),
   routines: array(routineViewSchema),
@@ -19328,7 +19556,7 @@ function setModuleEnabled(enabled, key, on) {
 var userSettingsSchema = createSelectSchema(userSettings, {
   createdAt: exports_coerce.date(),
   updatedAt: exports_coerce.date()
-});
+}).omit({ autoRollOverdue: true });
 var updateUserSettingsInputSchema = createUpdateSchema(userSettings, {
   displayName: string2().trim().max(80).nullish(),
   avatarUrl: union([string2().url().max(2048), literal("")]).nullish(),
@@ -19339,9 +19567,15 @@ var updateUserSettingsInputSchema = createUpdateSchema(userSettings, {
   accent: settingsAccentSchema.optional(),
   sunCity: string2().trim().max(80).transform((city) => city === "" ? null : city).nullish(),
   backdrop: backdropIdSchema.nullish(),
-  enabledModules: array(string2().trim().min(1)).transform(normalizeEnabledModules).optional(),
-  autoRollOverdue: boolean3().optional()
-}).omit({ id: true, tenantId: true, userId: true, createdAt: true, updatedAt: true }).strict();
+  enabledModules: array(string2().trim().min(1)).transform(normalizeEnabledModules).optional()
+}).omit({
+  id: true,
+  tenantId: true,
+  userId: true,
+  createdAt: true,
+  updatedAt: true,
+  autoRollOverdue: true
+}).strict();
 
 // ../../packages/schema/src/contracts/shopping.ts
 var shoppingRecurrenceUnitSchema = _enum2(["day", "week", "month"]);
@@ -19607,7 +19841,8 @@ var timeBlockTaskSchema = object({
   id: ulidSchema,
   title: string2(),
   status: string2(),
-  areaId: string2().nullable()
+  areaId: string2().nullable(),
+  projectId: string2().nullable().optional()
 });
 var timeBlockViewSchema = timeBlockSchema.extend({
   title: string2(),
@@ -19687,7 +19922,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 +21083,7 @@ function parseCapture2(input, now) {
 
 // src/meta.ts
 var CLI_NAME = "do";
-var VERSION = "1.160.0";
+var VERSION = "1.162.0";
 var API_PREFIX = "/api/v1";
 var DEFAULT_API_URL = "http://localhost:3001";
 
@@ -21066,7 +21306,7 @@ var ENTITIES = [
     listFlags: [
       {
         name: "filter",
-        description: "all (default), unsorted (the GTD inbox) or starred",
+        description: "all (default), unsorted (the Inbox's tasks to file: no day, Deadline, Area or Project; never a proposal) or starred",
         query: "filter"
       },
       { ...AREA_FLAG, description: "only tasks in this area id (a project task by its project's)" },
@@ -21087,7 +21327,17 @@ var ENTITIES = [
         description: "waiting on: me, member:<id|email>, agent:<id|name>, any or none"
       },
       { name: "completedSince", description: "finished at or after this instant (ISO or date)" },
-      { name: "completedBefore", description: "finished before this instant (ISO or date)" }
+      { name: "completedBefore", description: "finished before this instant (ISO or date)" },
+      {
+        name: "proposed",
+        description: "only tasks Proposed by Echo (made by an Agent for a member, not accepted yet); --proposed=false for only the plan",
+        boolean: true
+      },
+      {
+        name: "ready",
+        description: "only open tasks their Owner marked Ready for you; --ready=false for the rest",
+        boolean: true
+      }
     ],
     write: {
       scope: "tasks:write",
@@ -21104,7 +21354,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,
@@ -21144,7 +21401,15 @@ var ENTITIES = [
     readScope: "areas:read",
     returns: "AreaView",
     canGet: true,
-    listFlags: [],
+    listFlags: [
+      {
+        name: "active",
+        description: "only live areas (not archived)",
+        query: "archived",
+        sends: "false"
+      },
+      { name: "archived", description: "only archived areas", query: "archived", sends: "true" }
+    ],
     write: {
       scope: "areas:write",
       createSchema: createAreaInputSchema,
@@ -21355,6 +21620,11 @@ var PAGINATION_FLAGS = [
     description: "Opaque keyset cursor from a previous page's nextCursor."
   }
 ];
+var STANDARD_LINK_FLAGS = [
+  { name: "habit", type: "string", description: "Held by this habit (its id)." },
+  { name: "task", type: "string", description: "Held by this recurring task (its id)." },
+  { name: "metric", type: "string", description: "Held by this Metric: weight, sleep or mood." }
+];
 var GLOBAL_FLAGS = [
   { name: "json", type: "boolean", description: "Emit JSON (automatic when stdout is piped)." },
   { name: "quiet", type: "boolean", description: "Suppress human output (errors still report)." },
@@ -21408,12 +21678,37 @@ 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: ["today", "earlier"],
+    summary: "From earlier: planned tasks of the last 14 days that weren't done, newest first, and the day Later this week lands on.",
+    args: [],
+    flags: [{ name: "area", type: "string", description: "Only tasks in this Area (id)." }],
+    scopes: ["tasks:read"],
+    returns: "FromEarlierResponse",
+    notes: "GET /api/v1/today/from-earlier, from your local day. Nothing here is late: timed tasks, time blocks and agents' work never roll, and a plan older than 14 days just waits where it was filed. Answer with `do today answer`."
+  },
+  {
+    path: ["today", "answer"],
+    summary: "Answer From earlier for one or more tasks: today, later (this week), someday or let-go.",
+    args: [
+      {
+        name: "answer",
+        required: true,
+        description: "today (plan it today) \xB7 later (the quiet day later this week) \xB7 someday (no date, kept in its Area or Project) \xB7 let-go (close it without doing it)."
+      },
+      { name: "ids", required: true, description: "One or more task ids." }
+    ],
+    flags: [],
+    scopes: ["tasks:write"],
+    returns: "RolloverResult",
+    notes: "POST /api/v1/today/rollover. `later` reads the day from `do today earlier` first. Let go is cancelled, never done, so it stays out of Landed; undo with `do task reopen`."
   },
   {
     path: ["now"],
@@ -21474,6 +21769,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.",
@@ -21531,6 +21835,39 @@ var COMMAND_SPECS = [
     returns: "Task",
     notes: "POST /api/v1/tasks/{id}/cancel. Use this, not `task done`, for a dropped task."
   },
+  {
+    path: ["tasks", "accept"],
+    summary: "Accept a task Proposed by Echo: it joins the plan as suggested (day, Deadline, Area kept).",
+    args: [{ name: "id", required: true, description: "Task ULID." }],
+    flags: [],
+    scopes: ["tasks:write"],
+    returns: "Task",
+    notes: "POST /api/v1/tasks/{id}/accept (#889). A no-op on a task that isn't a proposal. List proposals with `do tasks list --proposed`."
+  },
+  {
+    path: ["tasks", "dismiss"],
+    summary: "Not now on a task Proposed by Echo: it leaves the Inbox for a week, still proposed.",
+    args: [{ name: "id", required: true, description: "Task ULID." }],
+    flags: [],
+    scopes: ["tasks:write"],
+    returns: "Task",
+    notes: "POST /api/v1/tasks/{id}/not-now (#889); 409 when the task isn't a proposal. Let go is `do task cancel`."
+  },
+  {
+    path: ["tasks", "ready"],
+    summary: "Mark a task Ready for you: its Owner finished something the member should look at (a draft, a link, a worktree).",
+    args: [{ name: "id", required: true, description: "Task ULID." }],
+    flags: [
+      {
+        name: "note",
+        type: "string",
+        description: `What's ready, in a line, with a link when there is one ("Draft ready: 38 hours, 3,420 euro \u2014 https://\u2026"); at most 500 characters. Absent keeps the note already there.`
+      }
+    ],
+    scopes: ["tasks:write"],
+    returns: "Task",
+    notes: "POST /api/v1/tasks/{id}/ready (#902); 409 when the task is done or let go. It reaches Now's Needs you with Review (Looks good = done, Send back = `ready: false`). List them with `do tasks list --ready`."
+  },
   {
     path: ["task", "reopen"],
     summary: "Reopen a done or cancelled task (status todo; clears completedAt).",
@@ -21561,22 +21898,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. 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/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/: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 +21980,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).",
@@ -22079,6 +22613,66 @@ var COMMAND_SPECS = [
     returns: "CollectionCoverBackfillResult",
     notes: "Returns { checked, found }; run again while checked is 25 to work through more."
   },
+  {
+    path: ["areas", "purpose"],
+    summary: "Set an Area's purpose: one line of what it's for.",
+    args: [
+      { name: "id", required: true, description: "The Area's id." },
+      { name: "line", required: false, description: "The purpose, in one line (words join)." }
+    ],
+    flags: [{ name: "clear", type: "boolean", description: "Remove the purpose." }],
+    scopes: ["areas:write"],
+    returns: "AreaView",
+    notes: "PATCH /api/v1/areas/:id { purpose }. It shows under the Area's name on the hub."
+  },
+  {
+    path: ["areas", "standards", "list"],
+    summary: "List an Area's standards with how each is doing (holding / worth a look).",
+    args: [{ name: "id", required: true, description: "The Area's id." }],
+    flags: [],
+    scopes: ["areas:read"],
+    returns: "AreaStandardView",
+    notes: "Each linked standard says holding or worth a look with the reason in words; an unlinked one has no state (it's checked by hand in review)."
+  },
+  {
+    path: ["areas", "standards", "add"],
+    summary: "Add a standard (what fine looks like) to an Area; up to five.",
+    args: [
+      { name: "id", required: true, description: "The Area's id." },
+      { name: "text", required: true, description: "The standard, a plain sentence (words join)." }
+    ],
+    flags: STANDARD_LINK_FLAGS,
+    scopes: ["areas:write"],
+    returns: "AreaDetail",
+    notes: "POST /api/v1/areas/:id/standards. Echo adds standards only after the member said yes; the change list keeps Undo."
+  },
+  {
+    path: ["areas", "standards", "link"],
+    summary: "Change what holds a standard: a habit, a recurring task, a Metric, or none.",
+    args: [
+      { name: "id", required: true, description: "The Area's id." },
+      { name: "standard", required: true, description: "The standard's id." }
+    ],
+    flags: [
+      ...STANDARD_LINK_FLAGS,
+      { name: "none", type: "boolean", description: "Unlink it: checked by hand in review." }
+    ],
+    scopes: ["areas:write"],
+    returns: "AreaDetail",
+    notes: "PATCH /api/v1/areas/:id/standards/:standardId { link }."
+  },
+  {
+    path: ["areas", "standards", "rm"],
+    summary: "Remove a standard from an Area.",
+    args: [
+      { name: "id", required: true, description: "The Area's id." },
+      { name: "standard", required: true, description: "The standard's id." }
+    ],
+    flags: [],
+    scopes: ["areas:write"],
+    returns: "AreaDetail",
+    notes: "DELETE /api/v1/areas/:id/standards/:standardId."
+  },
   {
     path: ["places", "import"],
     summary: "Import the rooms of the house once from Gaard's house.json.",
@@ -22756,15 +23350,124 @@ 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 DAY_MS = 24 * 60 * 60 * 1000;
+function plannedDay(at, from) {
+  if (!at)
+    return "earlier";
+  const day = new Date(at);
+  const ago = from ? Math.round((Date.parse(from) - day.getTime()) / DAY_MS) : 7;
+  if (ago <= 1)
+    return "yesterday";
+  if (ago < 7)
+    return day.toLocaleDateString("en-GB", { weekday: "long" });
+  return day.toLocaleDateString("en-GB", { day: "numeric", month: "short" });
+}
+function renderFromEarlier(data, mode) {
+  const d = data;
+  const tasks = d.tasks ?? [];
+  if (tasks.length === 0)
+    return paint(mode, "dim", "Nothing from earlier.");
+  const later = d.laterThisWeek ? new Date(d.laterThisWeek).toLocaleDateString("en-GB", { weekday: "long" }) : null;
+  return [
+    paint(mode, "bold", "From earlier \xB7 planned, not done. Nothing is late."),
+    ...tasks.map((t) => `  \xB7 ${t.title ?? "(untitled)"} ${paint(mode, "dim", `\u2014 planned ${plannedDay(t.scheduledAt, d.from)}`)}  ${paint(mode, "dim", t.id)}`),
+    "",
+    paint(mode, "dim", `Answer with \`do today answer <today|later|someday|let-go> <id\u2026>\`${later ? `; later is ${later}` : ""}.`)
+  ].join(`
+`);
+}
+function renderFromEarlierAnswer(data, mode) {
+  const d = data;
+  const n = d.tasks ?? 0;
+  const tasks = `${n} task${n === 1 ? "" : "s"}`;
+  if (n === 0)
+    return paint(mode, "dim", "Nothing changed: those tasks are already done, let go or gone.");
+  switch (d.answer) {
+    case "today":
+      return `Planned for today: ${tasks}.`;
+    case "later":
+      return `Planned ${d.to ? new Date(d.to).toLocaleDateString("en-GB", { weekday: "long" }) : "later this week"}: ${tasks}.`;
+    case "someday":
+      return `Moved to Someday: ${tasks}, kept where they were filed.`;
+    default:
+      return `Let go: ${tasks}. ${paint(mode, "dim", "Changed your mind? `do task reopen <id>`.")}`;
+  }
+}
+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 +23482,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;
@@ -23011,10 +23746,15 @@ function renderNow(data, mode) {
   const waiting = now.waitingOnYou ?? [];
   const head = paint(mode, "bold", `Waiting on ${actorText(now.for)} \xB7 ${waiting.length}`);
   const lines = waiting.length ? waiting.map((t) => taskLine(t, mode)) : [paint(mode, "dim", "  nothing is waiting on you")];
+  const ready = now.readyForYou ?? [];
+  const readyLines = ready.length ? [
+    paint(mode, "bold", "Ready for you"),
+    ...ready.map((t) => taskLine(t, mode) + (t.readyNote ? paint(mode, "dim", ` \u2014 ${t.readyNote}`) : ""))
+  ] : [];
   const tl = now.timeline ?? {};
   const count = (xs) => xs?.length ?? 0;
   const timeline = paint(mode, "dim", `Today: ${count(tl.scheduledTasks)} scheduled \xB7 ${count(tl.dueOccurrences)} due \xB7 ${count(tl.overdueTasks) + count(tl.overdueOccurrences)} overdue`);
-  return [head, ...lines, timeline].join(`
+  return [head, ...lines, ...readyLines, timeline].join(`
 `);
 }
 function renderLanded(data, mode) {
@@ -23076,6 +23816,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 ?? [];
@@ -23113,6 +23891,18 @@ function renderMcpTools(data, mode) {
   return [paint(mode, "bold", `${tools.length} tools`), ...lines].join(`
 `);
 }
+function renderStandards(data, mode) {
+  const list = Array.isArray(data) ? data : [];
+  if (list.length === 0)
+    return paint(mode, "dim", "No standards yet.");
+  return list.map((s) => {
+    const state = s.state === "holding" ? `Holding${s.why ? `: ${s.why}` : ""}` : s.state === "worth_a_look" ? `Worth a look${s.why ? `: ${s.why}` : ""}` : "Checked by hand, in review";
+    const held = s.heldBy ? ` \xB7 ${s.heldBy}` : "";
+    return `  \xB7 ${s.text ?? "(untitled)"}
+    ${paint(mode, "dim", `${state}${held}  ${s.id ?? ""}`)}`;
+  }).join(`
+`);
+}
 
 // src/today.ts
 var OPEN_STATUSES = new Set(["todo", "in_progress"]);
@@ -23229,9 +24019,19 @@ 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 key = f.query ?? f.name;
+      if (f.sends !== undefined) {
+        if (flags[f.name] === undefined)
+          continue;
+        const other = entity.listFlags.find((o) => o !== f && o.sends !== undefined && (o.query ?? o.name) === key && (o.name in flags));
+        if (other)
+          throw usageError(`--${other.name} and --${f.name} can't be combined`);
+        query[key] = f.sends;
+        continue;
+      }
+      const value = flags[f.name] === true ? "true" : flagString(flags, f.name);
       if (value !== undefined)
-        query[f.query ?? f.name] = value;
+        query[key] = value;
       else if (f.required)
         throw usageError(`\`${entity.name} list\` requires --${f.name}`);
     }
@@ -23347,11 +24147,58 @@ 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
     };
   },
+  "today earlier": async ({ flags, io, requireClient }) => {
+    const area = flagString(flags, "area");
+    return {
+      data: await requireClient().get("/today/from-earlier", {
+        query: { from: localDayStart(io.now()).toISOString(), areaId: area }
+      }),
+      render: renderFromEarlier
+    };
+  },
+  "today answer": async ({ args, io, requireClient }) => {
+    const answer = requireArg(args, 0, "answer");
+    const taskIds = args.slice(1);
+    if (!FROM_EARLIER_ANSWERS.includes(answer)) {
+      throw usageError(`answer must be one of ${FROM_EARLIER_ANSWERS.join(", ")} (got \`${answer}\`)`);
+    }
+    if (taskIds.length === 0)
+      throw usageError("today answer needs at least one task id");
+    const client = requireClient();
+    const today = localDayStart(io.now());
+    let body;
+    let to;
+    if (answer === "today") {
+      to = today.toISOString();
+      body = { action: "reschedule", to, taskIds };
+    } else if (answer === "later") {
+      const earlier = await client.get("/today/from-earlier", {
+        query: { from: today.toISOString() }
+      });
+      to = earlier.laterThisWeek;
+      body = { action: "reschedule", to, taskIds };
+    } else {
+      body = { action: answer === "someday" ? "someday" : "drop", taskIds };
+    }
+    const result = await client.post("/today/rollover", body);
+    return {
+      data: { answer, ...to ? { to } : {}, ...result },
+      render: renderFromEarlierAnswer
+    };
+  },
   export: async ({ flags, requireClient }) => {
     const format = flagString(flags, "format") ?? "json";
     if (format !== "json" && format !== "ndjson") {
@@ -23403,6 +24250,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)) {
@@ -23574,6 +24425,20 @@ var HANDLERS = {
     const id = requireArg(args, 0, "task id");
     return { data: await requireClient().post(`/tasks/${id}/cancel`, {}), render: renderTask };
   },
+  "tasks accept": async ({ args, requireClient }) => {
+    const id = requireArg(args, 0, "task id");
+    return { data: await requireClient().post(`/tasks/${id}/accept`, {}), render: renderTask };
+  },
+  "tasks dismiss": async ({ args, requireClient }) => {
+    const id = requireArg(args, 0, "task id");
+    return { data: await requireClient().post(`/tasks/${id}/not-now`, {}), render: renderTask };
+  },
+  "tasks ready": async ({ args, flags, requireClient }) => {
+    const id = requireArg(args, 0, "task id");
+    const note = flagString(flags, "note");
+    const body = parseInput(markTaskReadyInputSchema, note !== undefined ? { note } : {});
+    return { data: await requireClient().post(`/tasks/${id}/ready`, body), render: renderTask };
+  },
   "task reopen": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "task id");
     const body = parseInput(updateTaskInputSchema, { status: "todo" });
@@ -23592,10 +24457,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 +24478,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 +24527,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 };
@@ -23827,6 +24811,51 @@ var HANDLERS = {
     const result = collectionCoverBackfillResultSchema.parse(await requireClient().post("/collection/covers", undefined));
     return { data: result, render: renderRecord };
   },
+  "areas purpose": async ({ args, flags, requireClient }) => {
+    const id = requireArg(args, 0, "area id");
+    const line = args.slice(1).join(" ").trim();
+    const clear = flagBool(flags, "clear");
+    if (clear && line)
+      throw usageError("pass a purpose or --clear, not both");
+    if (!clear && !line)
+      throw usageError('areas purpose needs a line, e.g. `do areas purpose <id> "Sleep well, move often"` (or --clear)');
+    const body = parseInput(updateAreaInputSchema, { purpose: clear ? null : line });
+    return { data: await requireClient().patch(`/areas/${id}`, body), render: renderRecord };
+  },
+  "areas standards list": async ({ args, requireClient }) => {
+    const id = requireArg(args, 0, "area id");
+    const area = await requireClient().get(`/areas/${id}`);
+    return { data: area.standards ?? [], render: renderStandards };
+  },
+  "areas standards add": async ({ args, flags, requireClient }) => {
+    const id = requireArg(args, 0, "area id");
+    const text = args.slice(1).join(" ").trim();
+    if (!text)
+      throw usageError('areas standards add needs the standard, e.g. `do areas standards add <id> "Move three times a week" --habit <habitId>`');
+    const link = standardLink(flags);
+    const body = parseInput(addAreaStandardInputSchema, { text, ...link ? { link } : {} });
+    const area = await requireClient().post(`/areas/${id}/standards`, body);
+    return { data: area.standards ?? [], render: renderStandards };
+  },
+  "areas standards link": async ({ args, flags, requireClient }) => {
+    const id = requireArg(args, 0, "area id");
+    const standard = requireArg(args, 1, "standard id");
+    const link = standardLink(flags);
+    const none = flagBool(flags, "none");
+    if (none && link)
+      throw usageError("pass one of --habit, --task, --metric or --none");
+    if (!none && !link)
+      throw usageError("say what holds it: --habit <id>, --task <id>, --metric <key>, or --none");
+    const body = parseInput(updateAreaStandardInputSchema, { link: none ? null : link });
+    const area = await requireClient().patch(`/areas/${id}/standards/${standard}`, body);
+    return { data: area.standards ?? [], render: renderStandards };
+  },
+  "areas standards rm": async ({ args, requireClient }) => {
+    const id = requireArg(args, 0, "area id");
+    const standard = requireArg(args, 1, "standard id");
+    const area = await requireClient().delete(`/areas/${id}/standards/${standard}`);
+    return { data: area.standards ?? [], render: renderStandards };
+  },
   "places import": async ({ args, flags, requireClient }) => {
     const path = requireArg(args, 0, "house.json path");
     let file;
@@ -24061,6 +25090,21 @@ function isoDay(date) {
   const day = String(date.getDate()).padStart(2, "0");
   return `${date.getFullYear()}-${month}-${day}`;
 }
+function standardLink(flags) {
+  const habit = flagString(flags, "habit");
+  const task = flagString(flags, "task");
+  const metric = flagString(flags, "metric");
+  const given = [habit, task, metric].filter((v) => v !== undefined);
+  if (given.length > 1)
+    throw usageError("pass one of --habit, --task or --metric");
+  if (habit !== undefined)
+    return { kind: "habit", id: habit };
+  if (task !== undefined)
+    return { kind: "task", id: task };
+  if (metric !== undefined)
+    return { kind: "metric", key: metric };
+  return null;
+}
 function requireArg(args, index, name) {
   const value = args[index];
   if (value === undefined || value.length === 0) {
@@ -24172,6 +25216,10 @@ function assertDestructiveAllowed(flags, action) {
     throw new CliError("destructive_blocked", `refusing to ${action} without --allow-destructive (a guardrail for autonomous agents)`, EXIT.USAGE);
   }
 }
+var FROM_EARLIER_ANSWERS = ["today", "later", "someday", "let-go"];
+function localDayStart(now) {
+  return new Date(now.getFullYear(), now.getMonth(), now.getDate());
+}
 
 // src/run.ts
 async function run(argv, io) {