@robbeverhelst/do 1.304.0 → 1.306.0

package/dist/do.js

@@ -26108,10 +26108,16 @@ var moneyTransactionViewSchema = moneyTransactionSchema.omit({ dedupHash: true }
     nodeId: ulidSchema,
     kind: moneyLinkKindSchema,
     title: string2(),
-    type: string2()
+    type: string2(),
+    warrantyEnds: keyDateDaySchema.nullable().default(null)
   })).default([]),
   recurring: string2().nullable().default(null),
-  contact: object({ id: ulidSchema, name: string2(), payments: number2().int().nonnegative() }).nullable().default(null),
+  contact: object({
+    id: ulidSchema,
+    name: string2(),
+    kind: _enum2(["person", "organization"]).default("person"),
+    payments: number2().int().nonnegative()
+  }).nullable().default(null),
   split: object({
     parts: number2().int().positive(),
     even: boolean3(),
@@ -30246,6 +30252,382 @@ var googleHealthOperations = defineOperations({
   }
 });
 
+// ../../packages/schema/src/operations/guest-list-events.ts
+var crud2 = crudOperations({
+  segment: "guest-list-events",
+  tag: "Guests",
+  noun: "guest list event",
+  read: "contacts:read",
+  write: "contacts:write",
+  create: createGuestListEventInputSchema,
+  update: updateGuestListEventInputSchema,
+  listQuery: [{ name: "guestListId", description: "The guest list (required)." }],
+  listQuerySchema: guestListEventsQuerySchema
+});
+var guestListEventOperations = defineOperations({
+  ...crud2,
+  create: { ...crud2.create, webhook: "guest.event.created" },
+  update: { ...crud2.update, webhook: "guest.event.updated" },
+  remove: { ...crud2.remove, webhook: "guest.event.deleted" }
+});
+
+// ../../packages/schema/src/operations/guest-tables.ts
+var guestTableOperations = defineOperations({
+  ...crudOperations({
+    segment: "guest-tables",
+    tag: "Guests",
+    noun: "guest table",
+    read: "contacts:read",
+    write: "contacts:write",
+    create: createGuestTableInputSchema,
+    update: updateGuestTableInputSchema,
+    listQuery: [{ name: "guestListId", description: "The guest list (required)." }],
+    listQuerySchema: guestTablesQuerySchema
+  })
+});
+
+// ../../packages/schema/src/operations/guests.ts
+var guestOperations = defineOperations({
+  ...crudOperations({
+    segment: "guests",
+    tag: "Guests",
+    noun: "guest",
+    read: "contacts:read",
+    write: "contacts:write",
+    create: createGuestInputSchema,
+    update: updateGuestInputSchema,
+    listQuery: [
+      { name: "guestListId", description: "Only this guest list's guests." },
+      { name: "contactId", description: "Only this contact's guest rows." },
+      { name: "state", description: "`yes`, `no`, `maybe` or `waiting`: their overall answer." }
+    ],
+    listQuerySchema: guestsQuerySchema
+  }),
+  sent: {
+    method: "post",
+    path: "/guests/sent",
+    scopes: ["contacts:write"],
+    tag: "Guests",
+    summary: "Stamp save-the-dates or invitations as sent",
+    description: "Stamps `saveTheDateAt` (`what: save_the_date`) or `inviteSentAt` (`what: invite`) on every guest in `guestIds`, at `at` or now. Returns the guests; fires `guest.sent`.",
+    body: markGuestsSentInputSchema,
+    status: 200,
+    response: { description: "The stamped guests." },
+    errors: { 400: true, 404: true },
+    webhook: "guest.sent"
+  }
+});
+
+// ../../packages/schema/src/operations/habits.ts
+var habitListQuery = habitListQuerySchema.extend(paginationQuerySchema.shape);
+var habitOperations = defineOperations({
+  list: {
+    method: "get",
+    path: "/habits",
+    scopes: ["habits:read"],
+    tag: "Habits",
+    summary: "List habits",
+    description: "Every growing habit (with streaks) in the Space, oldest first. `retired=true` lists the Grown shelf instead: the retired habits, history kept.",
+    query: [
+      { name: "areaId", description: "Only rows in this Area (ULID)." },
+      {
+        name: "updatedSince",
+        description: "Only rows whose `updatedAt` is at or after this instant \u2014 an ISO 8601 datetime with offset, or a bare `YYYY-MM-DD` (UTC midnight).",
+        format: "date-time"
+      },
+      {
+        name: "retired",
+        description: "`true` lists the retired (Grown) habits instead of the growing ones.",
+        enum: ["true", "false"]
+      }
+    ],
+    querySchema: habitListQuery,
+    paginated: true,
+    status: 200,
+    response: { description: "The Space's habits." }
+  },
+  today: {
+    method: "get",
+    path: "/habits/today",
+    scopes: ["habits:read"],
+    tag: "Habits",
+    summary: "What's left today",
+    description: "\"What's left?\" (#866): the habits due on the key's member's day (their saved time zone), already filtered by schedule, grouped by part of day (morning, midday, evening, anytime). Each says its value today, `done`/`open`/`skipped` (never overdue: habits don't carry over), the week for an N-per-week habit, and its last check-in (`by` names the Agent). Also today's routines with how many steps are done. Quit habits are left out.",
+    status: 200,
+    response: { description: "Today's habits and routines." },
+    operationId: "habits_today"
+  },
+  getAway: {
+    method: "get",
+    path: "/habits/away",
+    scopes: ["habits:read"],
+    tag: "Habits",
+    summary: "Get away state",
+    description: "The Space's \"Away until \u2026\": `{ until }` while away (the day you're back, YYYY-MM-DD), else `{ until: null }`.",
+    status: 200,
+    response: { description: "The away state." }
+  },
+  setAway: {
+    method: "put",
+    path: "/habits/away",
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Set away",
+    description: '"Away till Monday": every habit rests until `until` (the day you\'re back, after today): off Now, no push, streaks and plants wait. `until: null` comes back now. Tasks and events carry on. Fires `habit.updated`.',
+    body: awayInputSchema,
+    status: 200,
+    response: { description: "The away state." },
+    errors: { 400: true },
+    webhook: "habit.updated"
+  },
+  get: {
+    method: "get",
+    path: "/habits/{id}",
+    scopes: ["habits:read"],
+    tag: "Habits",
+    summary: "Get a habit",
+    description: "One habit with its streak + heatmap.",
+    status: 200,
+    response: { description: "The habit." },
+    errors: { 404: true }
+  },
+  create: {
+    method: "post",
+    path: "/habits",
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Create a habit",
+    description: "Create a habit; fires `habit.created`.",
+    body: createHabitInputSchema,
+    status: 201,
+    response: { description: "The created habit." },
+    errors: { 400: true },
+    webhook: "habit.created"
+  },
+  update: {
+    method: "patch",
+    path: "/habits/{id}",
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Update a habit",
+    description: "Patch a habit; fires `habit.updated`.",
+    body: updateHabitInputSchema,
+    status: 200,
+    response: { description: "The updated habit." },
+    errors: {
+      400: true,
+      404: true
+    },
+    webhook: "habit.updated"
+  },
+  remove: {
+    method: "delete",
+    path: "/habits/{id}",
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Archive a habit",
+    description: "Soft-delete a habit; fires `habit.deleted`.",
+    status: 204,
+    response: { description: "Archived." },
+    errors: { 404: true },
+    webhook: "habit.deleted"
+  },
+  checkInByTitle: {
+    method: "post",
+    path: "/habits/check-in",
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Check in a habit by title",
+    description: 'Check in the habit whose `title` or one of whose aliases is this (case-insensitive) \u2014 "wake", "did my run", "meditated". `value` defaults to 1. `mode: "add"` (default) logs it on top of the day ("12 pages"); `mode: "set"` makes it the day\'s total ("read 40 total") by writing one entry with the difference, keeping earlier check-ins (amount habits only, else 400). `occurredAt` back-dates it: an instant, or a `YYYY-MM-DD` member\'s day (noon in their zone); `set` works on the member\'s day it lands in. Several matching habits are a 409 with `error.code: "ambiguous_habit"` and `error.details.candidates` (`id`, `title`, `aliases`) to ask which; none is a 404 naming close titles; a habit counted from an ingest (Google Fit, Strava, GitHub) is a 409 \u2014 it checks itself in. An Agent\'s key records an `agent` check-in naming the Agent. `note` puts a short note on the check-in ("drill done, felt heavy" \u2192 `note: "felt heavy"`); a `set` that changes nothing puts it on the day\'s latest check-in. The refreshed habit\'s `lastCheckIn.id` is the entry, for adding a note later. Returns the refreshed habit; fires `habit.updated`.',
+    body: habitCheckInByTitleInputSchema,
+    status: 201,
+    response: { description: "The refreshed habit." },
+    errors: {
+      400: true,
+      404: true,
+      409: "Several habits answer to the title (with the candidates), or it is counted from an ingest."
+    },
+    webhook: "habit.updated"
+  },
+  addAlias: {
+    method: "post",
+    path: "/habits/{id}/aliases",
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Add a habit alias",
+    description: 'Add another name a check-in by title matches ("wake" for "Wake up by 07:00"); one already there (ignoring case) is a no-op, at most 12. Returns the refreshed habit; fires `habit.updated`.',
+    body: habitAliasInputSchema,
+    status: 201,
+    response: { description: "The refreshed habit." },
+    errors: {
+      400: true,
+      404: true
+    },
+    webhook: "habit.updated"
+  },
+  removeAlias: {
+    method: "delete",
+    path: "/habits/{id}/aliases/{alias}",
+    pathParams: { alias: "The alias to drop (ignoring case)." },
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Remove a habit alias",
+    description: "Drop an alias; 404 when the habit doesn't have it. Returns the refreshed habit; fires `habit.updated`.",
+    status: 200,
+    response: { description: "The refreshed habit." },
+    errors: { 404: true },
+    webhook: "habit.updated"
+  },
+  listCheckIns: {
+    method: "get",
+    path: "/habits/{id}/check-ins",
+    scopes: ["habits:read"],
+    tag: "Habits",
+    summary: "List a habit's check-ins",
+    description: "A page of the habit's check-ins, newest first; pass the oldest one's `occurredAt` as `before` for the next page.",
+    query: [
+      { name: "before", description: "Only check-ins before this instant (ISO 8601)." },
+      { name: "limit", description: "Page size, 1\u2013200 (default 50).", type: "integer" }
+    ],
+    querySchema: habitEntriesQuerySchema,
+    status: 200,
+    response: { description: "The check-ins." },
+    errors: { 404: true }
+  },
+  checkIn: {
+    method: "post",
+    path: "/habits/{id}/check-ins",
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Check in",
+    description: "Record a check-in, with an optional short `note`; fires `habit.updated` with the refreshed streak. A habit counted from an ingest (`source` other than `manual`) answers 409.",
+    body: createHabitEntryInputSchema,
+    status: 201,
+    response: { description: "The refreshed habit." },
+    errors: {
+      400: true,
+      404: true
+    },
+    webhook: "habit.updated",
+    operationId: "check_in_habit"
+  },
+  skip: {
+    method: "post",
+    path: "/habits/{id}/skip",
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Skip a habit",
+    description: '"Skip gym today": a neutral rest day (a `skip` entry, value 0), never a miss. The streak treats the period as neutral and spends no grace. `date` (YYYY-MM-DD) defaults to today; an optional `note` says why ("Dentist"). Skipping a skipped day changes nothing but its note. Undo by deleting the skip entry like a check-in. Returns the refreshed habit; fires `habit.updated`.',
+    body: habitSkipInputSchema,
+    status: 201,
+    response: { description: "The refreshed habit." },
+    errors: {
+      400: true,
+      404: true
+    },
+    webhook: "habit.updated"
+  },
+  pause: {
+    method: "post",
+    path: "/habits/{id}/pause",
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Pause a habit",
+    description: '"Pause gym till the 26th": the habit rests until `until` (the day it\'s back, after today): off Now, no push, streak and plant wait. Pausing a paused habit moves its end. Returns the refreshed habit with `pause`; fires `habit.updated`.',
+    body: habitPauseInputSchema,
+    status: 201,
+    response: { description: "The refreshed habit." },
+    errors: {
+      400: true,
+      404: true
+    },
+    webhook: "habit.updated"
+  },
+  resume: {
+    method: "post",
+    path: "/habits/{id}/resume",
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Resume a habit",
+    description: "End a habit's pause: it's back today. The rest so far stays neutral. Returns the refreshed habit; fires `habit.updated`.",
+    status: 201,
+    response: { description: "The refreshed habit." },
+    errors: { 404: true },
+    webhook: "habit.updated"
+  },
+  retire: {
+    method: "post",
+    path: "/habits/{id}/retire",
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Retire a habit",
+    description: '"I\'m done with the cold showers habit": the habit moves to the Grown shelf with its plant in bloom and keeps its history. It leaves Now and Today, sends no push, takes no check-in by title and is never due; Progress keeps its past. Returns the refreshed habit with `retiredAt`; undo with `/unretire`. Fires `habit.updated`.',
+    status: 201,
+    response: { description: "The refreshed habit." },
+    errors: { 404: true },
+    webhook: "habit.updated"
+  },
+  unretire: {
+    method: "post",
+    path: "/habits/{id}/unretire",
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Bring a habit back",
+    description: "Bring a grown (retired) habit back: it's growing again from today, its history intact. Returns the refreshed habit; fires `habit.updated`.",
+    status: 201,
+    response: { description: "The refreshed habit." },
+    errors: { 404: true },
+    webhook: "habit.updated"
+  },
+  updateCheckIn: {
+    method: "patch",
+    path: "/habits/{id}/check-ins/{entryId}",
+    pathParams: { entryId: "The check-in entry's ULID." },
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Note a check-in",
+    description: "Edit a check-in afterwards: set, replace or clear (`null` or blank) its short `note` (at most 280 characters). The amount and time stay; undo a wrong check-in instead. Returns the check-in; fires `habit.updated`.",
+    body: updateHabitEntryInputSchema,
+    status: 200,
+    response: { description: "The check-in, with its note." },
+    errors: {
+      400: true,
+      404: true
+    },
+    webhook: "habit.updated",
+    operationId: "note_habit_check_in"
+  },
+  removeCheckIn: {
+    method: "delete",
+    path: "/habits/{id}/check-ins/{entryId}",
+    pathParams: { entryId: "The check-in entry's ULID." },
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Undo a check-in",
+    description: "Delete a check-in; fires `habit.updated`.",
+    status: 200,
+    response: { description: "The refreshed habit." },
+    errors: { 404: true },
+    webhook: "habit.updated",
+    operationId: "undo_habit_check_in"
+  }
+});
+
+// ../../packages/schema/src/operations/households.ts
+var householdOperations = defineOperations({
+  ...crudOperations({
+    segment: "households",
+    tag: "Guests",
+    noun: "household",
+    read: "contacts:read",
+    write: "contacts:write",
+    create: createHouseholdInputSchema,
+    update: updateHouseholdInputSchema,
+    listQuery: [{ name: "contactId", description: "Only the households this contact is in." }],
+    listQuerySchema: householdsQuerySchema
+  })
+});
+
 // ../../packages/schema/src/operations/inventory-items.ts
 var inventoryItemOperations = defineOperations({
   ...crudOperations({
@@ -30500,6 +30882,189 @@ var planOperations = defineOperations({
   undo: decision("/plans/{id}/undo", "undo", "Undo answered items: an accepted item's task is put back as it was before; a dismissed item simply waits again. Both read as proposed afterwards.")
 });
 
+// ../../packages/schema/src/operations/routines.ts
+var routineOperations = defineOperations({
+  getRun: {
+    method: "get",
+    path: "/routines/runs/{runId}",
+    pathParams: { runId: "The routine run's ULID." },
+    scopes: ["routines:read"],
+    tag: "Routines",
+    summary: "Get a run",
+    description: "One run with its per-step state.",
+    status: 200,
+    response: { description: "The run." },
+    errors: { 404: true }
+  },
+  updateRun: {
+    method: "patch",
+    path: "/routines/runs/{runId}",
+    pathParams: { runId: "The routine run's ULID." },
+    scopes: ["routines:write"],
+    tag: "Routines",
+    summary: "Update a run",
+    description: "Advance/finish a run; fires `routine.run.updated`.",
+    body: updateRoutineRunInputSchema,
+    status: 200,
+    response: { description: "The updated run." },
+    errors: { 400: true, 404: true },
+    webhook: "routine.run.updated"
+  },
+  updateRunStep: {
+    method: "patch",
+    path: "/routines/runs/{runId}/steps/{stepRunId}",
+    pathParams: { runId: "The routine run's ULID.", stepRunId: "The run step's ULID." },
+    scopes: ["routines:write"],
+    tag: "Routines",
+    summary: "Update a run step",
+    description: "Check off / edit one run step; fires `routine.run.updated`.",
+    body: updateRoutineRunStepInputSchema,
+    status: 200,
+    response: { description: "The updated run." },
+    errors: { 400: true, 404: true },
+    webhook: "routine.run.updated"
+  },
+  undoSteps: {
+    method: "post",
+    path: "/routines/runs/{runId}/undo",
+    pathParams: { runId: "The routine run's ULID." },
+    scopes: ["routines:write"],
+    tag: "Routines",
+    summary: "Undo All taken",
+    description: 'Take an "All taken" back in one call: each named step goes back to open and loses exactly the check-in it wrote; a finished run reopens. Steps no longer done are left alone. Fires `routine.run.updated`.',
+    body: routineRunUndoInputSchema,
+    status: 200,
+    response: { description: "The run." },
+    errors: { 400: true, 404: true },
+    webhook: "routine.run.updated",
+    operationId: "undo_routine_all_taken"
+  },
+  list: {
+    method: "get",
+    path: "/routines",
+    scopes: ["routines:read"],
+    tag: "Routines",
+    summary: "List routines",
+    description: "Every routine (with its steps) in the Space, newest first.",
+    querySchema: paginationQuerySchema,
+    paginated: true,
+    status: 200,
+    response: { description: "The Space's routines." }
+  },
+  get: {
+    method: "get",
+    path: "/routines/{id}",
+    scopes: ["routines:read"],
+    tag: "Routines",
+    summary: "Get a routine",
+    description: "One routine with its step templates.",
+    status: 200,
+    response: { description: "The routine." },
+    errors: { 404: true }
+  },
+  create: {
+    method: "post",
+    path: "/routines",
+    scopes: ["routines:write"],
+    tag: "Routines",
+    summary: "Create a routine",
+    description: "Create a routine (steps ride in the payload); fires `routine.created`.",
+    body: createRoutineInputSchema,
+    status: 201,
+    response: { description: "The created routine." },
+    errors: { 400: true },
+    webhook: "routine.created"
+  },
+  update: {
+    method: "patch",
+    path: "/routines/{id}",
+    scopes: ["routines:write"],
+    tag: "Routines",
+    summary: "Update a routine",
+    description: "Patch a routine; fires `routine.updated`.",
+    body: updateRoutineInputSchema,
+    status: 200,
+    response: { description: "The updated routine." },
+    errors: { 400: true, 404: true },
+    webhook: "routine.updated"
+  },
+  remove: {
+    method: "delete",
+    path: "/routines/{id}",
+    scopes: ["routines:write"],
+    tag: "Routines",
+    summary: "Delete a routine",
+    description: "Soft-delete a routine; fires `routine.deleted`.",
+    status: 204,
+    response: { description: "Deleted." },
+    errors: { 404: true },
+    webhook: "routine.deleted"
+  },
+  attachRecurrence: {
+    method: "put",
+    path: "/routines/{id}/recurrence",
+    scopes: ["routines:write"],
+    tag: "Routines",
+    summary: "Attach recurrence",
+    description: "Attach/replace the routine's recurrence rule; fires `routine.updated`.",
+    body: updateRecurrenceRuleInputSchema,
+    status: 200,
+    response: { description: "The routine." },
+    errors: { 400: true, 404: true },
+    webhook: "routine.updated"
+  },
+  detachRecurrence: {
+    method: "delete",
+    path: "/routines/{id}/recurrence",
+    scopes: ["routines:write"],
+    tag: "Routines",
+    summary: "Detach recurrence",
+    description: "Remove the routine's recurrence rule; returns the routine; fires `routine.updated`.",
+    status: 200,
+    response: { description: "The routine." },
+    errors: { 404: true },
+    webhook: "routine.updated"
+  },
+  markDone: {
+    method: "post",
+    path: "/routines/{id}/done",
+    scopes: ["routines:write"],
+    tag: "Routines",
+    summary: "Check in a whole routine (All taken)",
+    description: "\"Took my supplements\" (#873): one call checks in every open step of today's run (the key's member's day), starting today's run when there's none. Each habit step writes a check-in (`source: routine`); a habit already done today goes done without a second one; a step whose habit is skipped today is left alone. The run finishes once nothing is open. Returns the run and `taken`, the steps it resolved; hand their `stepRunId`s to `POST /api/v1/routines/runs/{runId}/undo` to take it all back. Calling it again changes nothing. Fires `routine.run.updated`.",
+    body: routineDoneInputSchema,
+    status: 200,
+    response: { description: "`{ run, taken }`." },
+    errors: { 400: true, 404: true },
+    webhook: "routine.run.updated",
+    operationId: "routine_all_taken"
+  },
+  startRun: {
+    method: "post",
+    path: "/routines/{id}/runs",
+    scopes: ["routines:write"],
+    tag: "Routines",
+    summary: "Start a run",
+    description: "Start a run of the routine; fires `routine.run.started`.",
+    body: startRoutineRunInputSchema,
+    status: 201,
+    response: { description: "The started run." },
+    errors: { 400: true, 404: true },
+    webhook: "routine.run.started"
+  },
+  listRuns: {
+    method: "get",
+    path: "/routines/{id}/runs",
+    scopes: ["routines:read"],
+    tag: "Routines",
+    summary: "List a routine's runs",
+    description: "The routine's runs, newest-first.",
+    status: 200,
+    response: { description: "The routine's runs." },
+    errors: { 404: true }
+  }
+});
+
 // ../../packages/schema/src/operations/rsvp-answers.ts
 var rsvpAnswerOperations = defineOperations({
   list: {
@@ -30556,9 +31121,115 @@ var rsvpQuestionOperations = defineOperations({
     description: "Adds the preset questions after the list's own (`diet`: per guest, shown to a guest who said yes to anything, with vegetarian \xB7 vegan \xB7 gluten-free \xB7 lactose-free \xB7 nut allergy \xB7 other, and a text line shown when other is picked; `message`: the household's, once). A preset the list already has stays as it is. Returns the list's questions; fires `rsvp.question.created`.",
     body: addRsvpPresetsInputSchema,
     status: 200,
-    response: { description: "The list's questions." },
-    errors: { 400: true, 404: true },
-    webhook: "rsvp.question.created"
+    response: { description: "The list's questions." },
+    errors: { 400: true, 404: true },
+    webhook: "rsvp.question.created"
+  }
+});
+
+// ../../packages/schema/src/operations/sensors.ts
+var sensorOperations = defineOperations({
+  status: {
+    method: "get",
+    path: "/sensors/home-assistant",
+    scopes: ["places:read"],
+    tag: "Sensors",
+    summary: "Get the Home Assistant link",
+    description: "Whether the Space has linked Home Assistant (in Settings in the app; the token is never returned), the `host` it was linked at, how many entities are mapped (`links`) and `lastReadingAt`, when the newest reading from it landed.",
+    status: 200,
+    response: { description: "The link's status." },
+    errors: { 403: true }
+  },
+  entities: {
+    method: "get",
+    path: "/sensors/home-assistant/entities",
+    scopes: ["places:read"],
+    tag: "Sensors",
+    summary: "List Home Assistant's entities",
+    description: "Every entity Home Assistant has, by `entityId`: its name, domain, state, unit, device class, `lastUpdated`, the reading it most likely gives on a Place and on an asset (`suggested`) and the sensor link it's mapped by, or null. 409 before Home Assistant is linked; 503 when it doesn't answer.",
+    status: 200,
+    response: { description: "The entities, by id." },
+    errors: { 403: true, 409: true, 503: "Home Assistant didn't answer, or refused the token." }
+  },
+  sync: {
+    method: "post",
+    path: "/sensors/home-assistant/sync",
+    scopes: ["places:write"],
+    tag: "Sensors",
+    summary: "Sync Home Assistant now",
+    description: "Read every mapped entity's state once and append it to the datapoints ledger: on a Place as `shed.temp`, `shed.humidity`, `shed.heater`, `shed.water_pct`, `shed.door`, `shed.feed_kg` or `shed.light` (what an animal's room card and the room alarm read), on an asset as `asset.state`, `asset.power` or `asset.energy`. A state already on the ledger, or one Home Assistant can't read, is skipped. The worker does the same every five minutes. Returns `{ syncedAt, entities, written, skipped, missing, error }` (`unauthorized`, `unavailable`, `bad_response`). 409 before Home Assistant is linked.",
+    status: 200,
+    response: { description: "What the sync did." },
+    errors: { 403: true, 409: true }
+  },
+  unifiStatus: {
+    method: "get",
+    path: "/sensors/unifi",
+    scopes: ["places:read"],
+    tag: "Sensors",
+    summary: "Whether UniFi is linked",
+    description: "Whether the Space has linked its UniFi controller (in the app's Settings \u2192 Home), the host and site it was linked at, how many devices are mapped to an asset, and when the newest presence reading landed. Never the API key: a key can't link or unlink UniFi.",
+    status: 200,
+    response: { description: "The status." },
+    errors: { 403: true }
+  },
+  unifiDevices: {
+    method: "get",
+    path: "/sensors/unifi/devices",
+    scopes: ["places:read", "collections:read"],
+    tag: "Sensors",
+    summary: "The devices UniFi sees",
+    description: "Every device the controller manages (gateway, switches, access points, cameras) and every client connected now: `mac`, `name`, `kind` (`device` | `client`), `model`, `online`, `firmware`, and the sensor `link` to the asset it's mapped to (behind the nodes wall). Network details. 409 before UniFi is linked; 503 when the controller can't be read.",
+    status: 200,
+    response: { description: "The devices." },
+    errors: { 403: true, 409: true }
+  },
+  syncUnifi: {
+    method: "post",
+    path: "/sensors/unifi/sync",
+    scopes: ["places:write"],
+    tag: "Sensors",
+    summary: "Sync UniFi now",
+    description: "Map every asset whose facet names a UniFi MAC (`external.unifiMac`), ask the controller once, and put each mapped device's presence on its asset as `asset.presence` (1 online, 0 offline, with its firmware): what the asset page's Live card reads. A reading lands when the presence or firmware changes, else hourly; a device the controller doesn't list reads offline and is named in `missing`. The worker does the same every five minutes. 409 before UniFi is linked.",
+    status: 200,
+    response: { description: "What the sync did." },
+    errors: { 403: true, 409: true }
+  },
+  links: {
+    method: "get",
+    path: "/sensors/links",
+    scopes: ["places:read"],
+    tag: "Sensors",
+    summary: "List the mapped entities",
+    description: "Every mapped entity, or only the ones on `nodeId`, with the name of what it lands on (`nodeTitle`). A mapping on an asset kept Not shared is its member's alone.",
+    query: [{ name: "nodeId", description: "Only the mappings on this Place or asset." }],
+    querySchema: sensorLinksQuerySchema,
+    status: 200,
+    response: { description: "The mappings, by entity id." },
+    errors: { 400: true }
+  },
+  createLink: {
+    method: "post",
+    path: "/sensors/links",
+    scopes: ["places:write"],
+    tag: "Sensors",
+    summary: "Map an entity",
+    description: "Map a Home Assistant entity (`externalId`) to a Place, an asset, or an animal (its room: the Place it's housed in) as a `reading`: a Place takes `temp`, `humidity`, `heater`, `water`, `door`, `feeder` or `light`; an asset `state`, `power` or `energy`. Mapping an entity that's already mapped moves it. 400 when the reading doesn't fit; 404 for no such node; 409 for an animal with no room.",
+    body: createSensorLinkInputSchema,
+    status: 201,
+    response: { description: "The mapping." },
+    errors: { 400: true, 404: true, 409: true }
+  },
+  removeLink: {
+    method: "delete",
+    path: "/sensors/links/{id}",
+    scopes: ["places:write"],
+    tag: "Sensors",
+    summary: "Unmap an entity",
+    description: "Remove one mapping; the readings it gave stay on the ledger.",
+    status: 204,
+    response: { description: "Removed." },
+    errors: { 404: true }
   }
 });
 
@@ -30683,6 +31354,195 @@ var tapTagOperations = defineOperations({
   }
 });
 
+// ../../packages/schema/src/operations/tasks.ts
+var taskListQuery = taskListQuerySchema.extend(paginationQuerySchema.shape).extend({ filter: taskListFilterSchema.optional().default("all") });
+var taskOperations = defineOperations({
+  list: {
+    method: "get",
+    path: "/tasks",
+    scopes: ["tasks:read"],
+    tag: "Tasks",
+    summary: "List tasks",
+    description: "Every task in the key's Space, newest first.",
+    query: [
+      {
+        name: "filter",
+        description: "`all` (default), `unsorted` (the Inbox's tasks to file: open, top-level, not proposed, with no planned day, Deadline, Area or Project) or `starred`.",
+        enum: ["all", "unsorted", "starred"]
+      },
+      {
+        name: "areaId",
+        description: "Only rows in this Area (ULID) \u2014 a project task by its project's Area (its effective Area)."
+      },
+      { name: "projectId", description: "Only tasks attached to this project (ULID)." },
+      {
+        name: "status",
+        description: "Only rows in any of these statuses (comma list or repeated key): `todo`, `in_progress`, `done`, `cancelled`."
+      },
+      {
+        name: "tag",
+        description: "Only tasks carrying every listed tag (comma list or repeated key; case-insensitive, a leading `#` is ignored)."
+      },
+      {
+        name: "updatedSince",
+        description: "Only rows whose `updatedAt` is at or after this instant \u2014 an ISO 8601 datetime with offset, or a bare `YYYY-MM-DD` (UTC midnight).",
+        format: "date-time"
+      },
+      {
+        name: "dueBefore",
+        description: "Only rows due strictly before this instant (undated rows are excluded) \u2014 an ISO 8601 datetime with offset, or a bare `YYYY-MM-DD` (UTC midnight).",
+        format: "date-time"
+      },
+      {
+        name: "owner",
+        description: "Only tasks with this Owner: `me`, `member:<id|email>`, `agent:<id|name>` (every desk) or `agent:<id|name>/<desk>`; `any` = owned, `none` = unowned. An unknown party is a 400."
+      },
+      {
+        name: "waitingOn",
+        description: "Only tasks waiting on this party: `me`, `member:<id|email>` or `agent:<id|name>`; `any` = waiting on someone, `none` = not waiting. An unknown party is a 400."
+      },
+      {
+        name: "completedSince",
+        description: "Only tasks finished at or after this instant (`completedAt`; open and cancelled tasks have none) \u2014 an ISO 8601 datetime with offset, or a bare `YYYY-MM-DD` (UTC midnight).",
+        format: "date-time"
+      },
+      {
+        name: "completedBefore",
+        description: "Only tasks finished strictly before this instant \u2014 an ISO 8601 datetime with offset, or a bare `YYYY-MM-DD` (UTC midnight).",
+        format: "date-time"
+      },
+      {
+        name: "proposed",
+        description: "`true` = only tasks Proposed by the agent (an Agent made them for a member, who hasn't accepted yet); `false` = only tasks on the plan. Absent = both.",
+        type: "boolean"
+      },
+      {
+        name: "ready",
+        description: "`true` = only open tasks whose Owner marked them Ready for you; `false` = the rest. Absent = both.",
+        type: "boolean"
+      },
+      {
+        name: "drifted",
+        description: "`true` = only open tasks whose planned day moved 3+ times (the weekly plan's Drifted card); `false` = the rest. Absent = both.",
+        type: "boolean"
+      }
+    ],
+    querySchema: taskListQuery,
+    paginated: true,
+    status: 200,
+    response: { description: "The Space's tasks.", list: true }
+  },
+  listSubtasks: {
+    method: "get",
+    path: "/tasks/{id}/subtasks",
+    scopes: ["tasks:read"],
+    tag: "Tasks",
+    summary: "List subtasks",
+    description: "The direct children of a task, ordered by `sortOrder` (ascending), then newest first.",
+    status: 200,
+    response: { description: "The ordered subtasks." },
+    errors: { 404: true }
+  },
+  get: {
+    method: "get",
+    path: "/tasks/{id}",
+    scopes: ["tasks:read"],
+    tag: "Tasks",
+    summary: "Get a task",
+    description: "Fetch one task by id.",
+    status: 200,
+    response: { description: "The task." },
+    errors: { 404: true }
+  },
+  create: {
+    method: "post",
+    path: "/tasks",
+    scopes: ["tasks:write"],
+    tag: "Tasks",
+    summary: "Create a task",
+    description: "Create a task; fires the `task.created` webhook.",
+    body: createTaskInputSchema,
+    status: 201,
+    response: { description: "The created task." },
+    errors: { 400: true, 409: true },
+    webhook: "task.created"
+  },
+  update: {
+    method: "patch",
+    path: "/tasks/{id}",
+    scopes: ["tasks:write"],
+    tag: "Tasks",
+    summary: "Update a task",
+    description: "Patch a task; fires the `task.updated` webhook.",
+    body: updateTaskInputSchema,
+    status: 200,
+    response: { description: "The updated task." },
+    errors: { 400: true, 404: true, 409: true },
+    webhook: "task.updated"
+  },
+  cancel: {
+    method: "post",
+    path: "/tasks/{id}/cancel",
+    scopes: ["tasks:write"],
+    tag: "Tasks",
+    summary: "Cancel a task",
+    description: 'Drop a task: its status becomes `cancelled` and any `completedAt` is cleared, so a drop never counts as Landed (#648). Fires `task.updated`. The same as a PATCH to `status: "cancelled"`.',
+    status: 200,
+    response: { description: "The cancelled task." },
+    errors: { 404: true },
+    webhook: "task.updated"
+  },
+  accept: {
+    method: "post",
+    path: "/tasks/{id}/accept",
+    scopes: ["tasks:write"],
+    tag: "Tasks",
+    summary: "Accept a proposal",
+    description: "Take a task Proposed by the agent onto the member's plan as it was suggested: its planned day, Deadline and Area stay; `proposedAt` clears (#889). A no-op success on a task that isn't a proposal. Fires `task.updated`. The same as a PATCH to `proposed: false`.",
+    status: 200,
+    response: { description: "The accepted task." },
+    errors: { 404: true },
+    webhook: "task.updated"
+  },
+  notNow: {
+    method: "post",
+    path: "/tasks/{id}/not-now",
+    scopes: ["tasks:write"],
+    tag: "Tasks",
+    summary: "Not now on a proposal",
+    description: "Keep a task Proposed by the agent, but out of the member's Inbox for a week (`notNowUntil`, #889). Let go is `cancel`. Fires `task.updated`.",
+    status: 200,
+    response: { description: "The proposal, back in a week." },
+    errors: { 404: true, 409: "The task isn't a proposal." },
+    webhook: "task.updated"
+  },
+  ready: {
+    method: "post",
+    path: "/tasks/{id}/ready",
+    scopes: ["tasks:write"],
+    tag: "Tasks",
+    summary: "Mark Ready for you",
+    description: "The task's Owner (the Space's agent, a Desk, a coding agent) finished something the member should look at: `readyAt` is set and the task reaches Now's Needs you with Review (#902). Looks good marks it done; Send back is a PATCH to `ready: false` (it reads Working on it again). The optional `note` is what's ready, in a line, with a link when there is one; absent keeps the note already there. Fires `task.updated`.",
+    body: markTaskReadyInputSchema,
+    status: 200,
+    response: { description: "The task, Ready for you." },
+    errors: { 404: true, 409: "The task is done or let go; only an open task can be ready." },
+    webhook: "task.updated"
+  },
+  remove: {
+    method: "delete",
+    path: "/tasks/{id}",
+    scopes: ["tasks:write"],
+    tag: "Tasks",
+    summary: "Delete a task",
+    description: "Delete a task; fires the `task.deleted` webhook.",
+    status: 204,
+    response: { description: "Deleted." },
+    errors: { 404: true },
+    webhook: "task.deleted"
+  }
+});
+
 // ../../packages/schema/src/operations/today.ts
 var todayOperations = defineOperations({
   fromEarlier: {
@@ -31032,7 +31892,7 @@ function parseCapture2(input, now) {
 
 // src/meta.ts
 var CLI_NAME = "do";
-var VERSION = "1.304.0";
+var VERSION = "1.306.0";
 var API_PREFIX = "/api/v1";
 var DEFAULT_API_URL = "http://localhost:3001";
 
@@ -31451,12 +32311,9 @@ function entityFromOperations(ops, spec) {
   };
 }
 var ENTITIES = [
-  {
+  entityFromOperations(taskOperations, {
     name: "tasks",
-    path: "/tasks",
-    readScopes: ["tasks:read"],
     returns: "Task",
-    canGet: true,
     listFlags: [
       {
         name: "filter",
@@ -31498,21 +32355,12 @@ var ENTITIES = [
         boolean: true
       }
     ],
-    write: {
-      scopes: ["tasks:write"],
-      createSchema: createTaskInputSchema,
-      createInput: "CreateTaskInput",
-      updateSchema: updateTaskInputSchema,
-      updateInput: "UpdateTaskInput",
-      canDelete: true
-    }
-  },
-  {
+    createInput: "CreateTaskInput",
+    updateInput: "UpdateTaskInput"
+  }),
+  entityFromOperations(habitOperations, {
     name: "habits",
-    path: "/habits",
-    readScopes: ["habits:read"],
     returns: "HabitSummary",
-    canGet: true,
     listFlags: [
       AREA_FLAG,
       UPDATED_SINCE_FLAG,
@@ -31521,15 +32369,9 @@ var ENTITIES = [
         description: "list the Grown shelf (retired habits) instead of the growing ones"
       }
     ],
-    write: {
-      scopes: ["habits:write"],
-      createSchema: createHabitInputSchema,
-      createInput: "CreateHabitInput",
-      updateSchema: updateHabitInputSchema,
-      updateInput: "UpdateHabitInput",
-      canDelete: true
-    }
-  },
+    createInput: "CreateHabitInput",
+    updateInput: "UpdateHabitInput"
+  }),
   {
     name: "projects",
     path: "/projects",
@@ -31594,22 +32436,13 @@ var ENTITIES = [
       canDelete: true
     }
   },
-  {
+  entityFromOperations(routineOperations, {
     name: "routines",
-    path: "/routines",
-    readScopes: ["routines:read"],
     returns: "RoutineView",
-    canGet: true,
     listFlags: [],
-    write: {
-      scopes: ["routines:write"],
-      createSchema: createRoutineInputSchema,
-      createInput: "CreateRoutineInput",
-      updateSchema: updateRoutineInputSchema,
-      updateInput: "UpdateRoutineInput",
-      canDelete: true
-    }
-  },
+    createInput: "CreateRoutineInput",
+    updateInput: "UpdateRoutineInput"
+  }),
   {
     name: "notes",
     path: "/notes",
@@ -31741,12 +32574,9 @@ var ENTITIES = [
       canDelete: true
     }
   },
-  {
+  entityFromOperations(householdOperations, {
     name: "households",
-    path: "/households",
-    readScopes: ["contacts:read"],
     returns: "HouseholdView",
-    canGet: true,
     listFlags: [
       {
         name: "contact",
@@ -31754,15 +32584,9 @@ var ENTITIES = [
         query: "contactId"
       }
     ],
-    write: {
-      scopes: ["contacts:write"],
-      createSchema: createHouseholdInputSchema,
-      createInput: "CreateHouseholdInput",
-      updateSchema: updateHouseholdInputSchema,
-      updateInput: "UpdateHouseholdInput",
-      canDelete: true
-    }
-  },
+    createInput: "CreateHouseholdInput",
+    updateInput: "UpdateHouseholdInput"
+  }),
   {
     name: "guest-lists",
     path: "/guest-lists",
@@ -31779,42 +32603,24 @@ var ENTITIES = [
       canDelete: true
     }
   },
-  {
+  entityFromOperations(guestListEventOperations, {
     name: "guest-list-events",
-    path: "/guest-list-events",
-    readScopes: ["contacts:read"],
     returns: "GuestListEvent",
-    canGet: true,
     listFlags: [
       { name: "list", description: "the guest list's id (required)", query: "guestListId" }
     ],
-    write: {
-      scopes: ["contacts:write"],
-      createSchema: createGuestListEventInputSchema,
-      createInput: "CreateGuestListEventInput",
-      updateSchema: updateGuestListEventInputSchema,
-      updateInput: "UpdateGuestListEventInput",
-      canDelete: true
-    }
-  },
-  {
+    createInput: "CreateGuestListEventInput",
+    updateInput: "UpdateGuestListEventInput"
+  }),
+  entityFromOperations(guestTableOperations, {
     name: "guest-tables",
-    path: "/guest-tables",
-    readScopes: ["contacts:read"],
     returns: "GuestTableView",
-    canGet: true,
     listFlags: [
       { name: "list", description: "the guest list's id (required)", query: "guestListId" }
     ],
-    write: {
-      scopes: ["contacts:write"],
-      createSchema: createGuestTableInputSchema,
-      createInput: "CreateGuestTableInput",
-      updateSchema: updateGuestTableInputSchema,
-      updateInput: "UpdateGuestTableInput",
-      canDelete: true
-    }
-  },
+    createInput: "CreateGuestTableInput",
+    updateInput: "UpdateGuestTableInput"
+  }),
   entityFromOperations(rsvpQuestionOperations, {
     name: "rsvp-questions",
     returns: "RsvpQuestion",
@@ -31824,26 +32630,17 @@ var ENTITIES = [
     createInput: "CreateRsvpQuestionInput",
     updateInput: "UpdateRsvpQuestionInput"
   }),
-  {
+  entityFromOperations(guestOperations, {
     name: "guests",
-    path: "/guests",
-    readScopes: ["contacts:read"],
     returns: "GuestView",
-    canGet: true,
     listFlags: [
       { name: "list", description: "only this guest list's guests", query: "guestListId" },
       { name: "contact", description: "only this contact's guest rows", query: "contactId" },
       { name: "state", description: "yes, no, maybe or waiting (overall)", query: "state" }
     ],
-    write: {
-      scopes: ["contacts:write"],
-      createSchema: createGuestInputSchema,
-      createInput: "CreateGuestInput",
-      updateSchema: updateGuestInputSchema,
-      updateInput: "UpdateGuestInput",
-      canDelete: true
-    }
-  },
+    createInput: "CreateGuestInput",
+    updateInput: "UpdateGuestInput"
+  }),
   {
     name: "key-dates",
     path: "/key-dates",
@@ -33299,27 +34096,27 @@ var COMMAND_SPECS = [
     summary: "Drop a task: status cancelled, never counted as Landed.",
     args: [{ name: "id", required: true, description: "Task ULID." }],
     flags: [],
-    scopes: ["tasks:write"],
+    scopes: [...taskOperations.cancel.scopes],
     returns: "Task",
-    notes: "POST /api/v1/tasks/{id}/cancel. Use this, not `task done`, for a dropped task."
+    notes: `${routeOf(taskOperations.cancel)}. Use this, not \`task done\`, for a dropped task.`
   },
   {
     path: ["tasks", "accept"],
     summary: "Accept a task Proposed by the agent: it joins the plan as suggested (day, Deadline, Area kept).",
     args: [{ name: "id", required: true, description: "Task ULID." }],
     flags: [],
-    scopes: ["tasks:write"],
+    scopes: [...taskOperations.accept.scopes],
     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`."
+    notes: `${routeOf(taskOperations.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 the agent: it leaves the Inbox for a week, still proposed.",
     args: [{ name: "id", required: true, description: "Task ULID." }],
     flags: [],
-    scopes: ["tasks:write"],
+    scopes: [...taskOperations.notNow.scopes],
     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`."
+    notes: `${routeOf(taskOperations.notNow)} (#889); 409 when the task isn't a proposal. Let go is \`do task cancel\`.`
   },
   {
     path: ["block-templates", "week"],
@@ -33613,16 +34410,16 @@ var COMMAND_SPECS = [
         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"],
+    scopes: [...taskOperations.ready.scopes],
     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`."
+    notes: `${routeOf(taskOperations.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).",
     args: [{ name: "id", required: true, description: "Task ULID." }],
     flags: [],
-    scopes: ["tasks:write"],
+    scopes: [...taskOperations.update.scopes],
     returns: "Task"
   },
   {
@@ -33642,7 +34439,7 @@ var COMMAND_SPECS = [
         description: "How long it takes, in minutes (sets durationMinutes)."
       }
     ],
-    scopes: ["tasks:write"],
+    scopes: [...taskOperations.update.scopes],
     returns: "Task"
   },
   {
@@ -33661,7 +34458,7 @@ var COMMAND_SPECS = [
         description: "How long it takes, in minutes (sets durationMinutes)."
       }
     ],
-    scopes: ["tasks:write"],
+    scopes: [...taskOperations.update.scopes],
     returns: "Task"
   },
   {
@@ -33682,7 +34479,7 @@ var COMMAND_SPECS = [
         description: 'A short note on the check-in ("felt heavy"), at most 280 characters.'
       }
     ],
-    scopes: ["habits:write"],
+    scopes: [...habitOperations.checkIn.scopes],
     returns: "HabitSummary"
   },
   {
@@ -33709,7 +34506,7 @@ var COMMAND_SPECS = [
         description: 'A short note on the check-in ("felt heavy"), at most 280 characters.'
       }
     ],
-    scopes: ["habits:write"],
+    scopes: [...habitOperations.checkInByTitle.scopes],
     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 ("<agent>, 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.`
   },
@@ -33721,7 +34518,7 @@ var COMMAND_SPECS = [
       { name: "alias", required: true, description: "The other name." }
     ],
     flags: [],
-    scopes: ["habits:write"],
+    scopes: [...habitOperations.addAlias.scopes],
     returns: "HabitSummary",
     notes: "POST /api/v1/habits/:id/aliases. One already there (ignoring case) is a no-op; at most 12."
   },
@@ -33733,7 +34530,7 @@ var COMMAND_SPECS = [
       { name: "alias", required: true, description: "The alias to drop (ignoring case)." }
     ],
     flags: [],
-    scopes: ["habits:write"],
+    scopes: [...habitOperations.removeAlias.scopes],
     returns: "HabitSummary",
     notes: "DELETE /api/v1/habits/:id/aliases/:alias. 404 when the habit doesn't have it."
   },
@@ -33742,9 +34539,9 @@ var COMMAND_SPECS = [
     summary: "What's left today: the habits due by part of day, and today's routines.",
     args: [],
     flags: [],
-    scopes: ["habits:read"],
+    scopes: [...habitOperations.today.scopes],
     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."
+    notes: `${routeOf(habitOperations.today)}. Your saved time zone's day; already filtered by schedule. Each habit says done/open/skipped (never overdue), its value today, the week for an N-per-week habit and its last check-in (\`by\` names the Agent). Quit habits are left out.`
   },
   {
     path: ["habit", "check-ins"],
@@ -33754,7 +34551,7 @@ var COMMAND_SPECS = [
       { name: "before", type: "string", description: "Only check-ins before this instant (ISO)." },
       { name: "limit", type: "string", description: "Page size 1\u2013200 (default 50)." }
     ],
-    scopes: ["habits:read"],
+    scopes: [...habitOperations.listCheckIns.scopes],
     returns: "HabitEntry"
   },
   {
@@ -33770,9 +34567,9 @@ var COMMAND_SPECS = [
       { 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"],
+    scopes: [...habitOperations.updateCheckIn.scopes],
     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."
+    notes: `${routeOf(habitOperations.updateCheckIn)}. Replaces the note; the amount and time stay (undo a wrong check-in instead). A skip's note is its why.`
   },
   {
     path: ["habit", "skip"],
@@ -33786,9 +34583,9 @@ var COMMAND_SPECS = [
         description: 'Why, if you like ("Dentist"); shows in the log.'
       }
     ],
-    scopes: ["habits:write"],
+    scopes: [...habitOperations.skip.scopes],
     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`)."
+    notes: `${routeOf(habitOperations.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"],
@@ -33801,9 +34598,9 @@ var COMMAND_SPECS = [
       }
     ],
     flags: [],
-    scopes: ["routines:write"],
+    scopes: [...routineOperations.markDone.scopes],
     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>`."
+    notes: `${routeOf(routineOperations.markDone)}. 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"],
@@ -33821,9 +34618,9 @@ var COMMAND_SPECS = [
       }
     ],
     flags: [],
-    scopes: ["routines:write"],
+    scopes: [...routineOperations.undoSteps.scopes],
     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."
+    notes: `${routeOf(routineOperations.undoSteps)}. Exactly the check-ins those steps wrote are removed; a finished run reopens. Steps no longer done are left alone.`
   },
   {
     path: ["habit", "pause"],
@@ -33836,9 +34633,9 @@ var COMMAND_SPECS = [
         description: "The day it's back (YYYY-MM-DD), after today. Required."
       }
     ],
-    scopes: ["habits:write"],
+    scopes: [...habitOperations.pause.scopes],
     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."
+    notes: `${routeOf(habitOperations.pause)}. Pausing a paused habit moves the day it's back. Paused days are neutral: the streak is frozen, never broken.`
   },
   {
     path: ["habit", "remind"],
@@ -33848,36 +34645,36 @@ var COMMAND_SPECS = [
       { name: "state", required: true, description: "`on` or `off`." }
     ],
     flags: [],
-    scopes: ["habits:write"],
+    scopes: [...habitOperations.update.scopes],
     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."
+    notes: `${routeOf(habitOperations.update)} {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"],
+    scopes: [...habitOperations.resume.scopes],
     returns: "HabitSummary",
-    notes: "POST /api/v1/habits/{id}/resume. The rest so far stays neutral."
+    notes: `${routeOf(habitOperations.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"],
+    scopes: [...habitOperations.retire.scopes],
     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>`."
+    notes: `${routeOf(habitOperations.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"],
+    scopes: [...habitOperations.unretire.scopes],
     returns: "HabitSummary",
-    notes: "POST /api/v1/habits/{id}/unretire. Its history is intact."
+    notes: `${routeOf(habitOperations.unretire)}. Its history is intact.`
   },
   {
     path: ["away"],
@@ -36561,63 +37358,63 @@ var COMMAND_SPECS = [
     summary: "Whether the Space has linked Home Assistant, how many entities are mapped, the newest reading.",
     args: [],
     flags: [],
-    scopes: ["places:read"],
+    scopes: [...sensorOperations.status.scopes],
     returns: "HomeAssistantStatus",
-    notes: "GET /api/v1/sensors/home-assistant. Home Assistant is linked in the app's Settings \u2192 Home; the token is never returned."
+    notes: `${routeOf(sensorOperations.status)}. Home Assistant is linked in the app's Settings \u2192 Home; the token is never returned.`
   },
   {
     path: ["sensors", "entities"],
     summary: "Every entity Home Assistant has, with its state, the reading it likely gives and what it's mapped to.",
     args: [],
     flags: [],
-    scopes: ["places:read"],
+    scopes: [...sensorOperations.entities.scopes],
     returns: "HomeAssistantEntity[]",
-    notes: "GET /api/v1/sensors/home-assistant/entities. 409 before Home Assistant is linked; 503 when it doesn't answer."
+    notes: `${routeOf(sensorOperations.entities)}. 409 before Home Assistant is linked; 503 when it doesn't answer.`
   },
   {
     path: ["sensors", "sync"],
     summary: "Read every mapped entity now and put its state on the ledger, as the five-minute sync does.",
     args: [],
     flags: [],
-    scopes: ["places:write"],
+    scopes: [...sensorOperations.sync.scopes],
     returns: "SensorSyncResult",
-    notes: "POST /api/v1/sensors/home-assistant/sync. A room's readings feed its card and the room alarm; an asset's show on its page. Returns entities, written, skipped, missing and the error (unauthorized, unavailable, bad_response). 409 before Home Assistant is linked."
+    notes: `${routeOf(sensorOperations.sync)}. A room's readings feed its card and the room alarm; an asset's show on its page. Returns entities, written, skipped, missing and the error (unauthorized, unavailable, bad_response). 409 before Home Assistant is linked.`
   },
   {
     path: ["sensors", "unifi"],
     summary: "Whether the Space has linked UniFi, how many devices are mapped, the newest reading.",
     args: [],
     flags: [],
-    scopes: ["places:read"],
+    scopes: [...sensorOperations.unifiStatus.scopes],
     returns: "UnifiStatus",
-    notes: "GET /api/v1/sensors/unifi. Linking UniFi (address + API key) is a member's, in Settings \u2192 Home; a key never sees the API key."
+    notes: `${routeOf(sensorOperations.unifiStatus)}. Linking UniFi (address + API key) is a member's, in Settings \u2192 Home; a key never sees the API key.`
   },
   {
     path: ["sensors", "unifi-devices"],
     summary: "Every device and connected client UniFi sees, with the asset each is mapped to.",
     args: [],
     flags: [],
-    scopes: ["places:read", "collections:read"],
+    scopes: [...sensorOperations.unifiDevices.scopes],
     returns: "UnifiDevice[]",
-    notes: "GET /api/v1/sensors/unifi/devices. Map one with `do sensors map <mac> <asset> --reading presence --provider unifi`, or give the asset `external.unifiMac` on its facet. 409 before UniFi is linked."
+    notes: `${routeOf(sensorOperations.unifiDevices)}. Map one with \`do sensors map <mac> <asset> --reading presence --provider unifi\`, or give the asset \`external.unifiMac\` on its facet. 409 before UniFi is linked.`
   },
   {
     path: ["sensors", "unifi-sync"],
     summary: "Put every mapped device's presence (online/offline, firmware) on its asset now.",
     args: [],
     flags: [],
-    scopes: ["places:write"],
+    scopes: [...sensorOperations.syncUnifi.scopes],
     returns: "SensorSyncResult",
-    notes: "POST /api/v1/sensors/unifi/sync. Assets whose facet names a UniFi MAC are mapped first; readings land as asset.presence on change, else hourly. The worker does the same every five minutes. 409 before UniFi is linked."
+    notes: `${routeOf(sensorOperations.syncUnifi)}. Assets whose facet names a UniFi MAC are mapped first; readings land as asset.presence on change, else hourly. The worker does the same every five minutes. 409 before UniFi is linked.`
   },
   {
     path: ["sensors", "links"],
     summary: "The mapped entities, or the ones on one Place or asset.",
     args: [],
     flags: [{ name: "node", type: "string", description: "Only the mappings on this node ULID." }],
-    scopes: ["places:read"],
+    scopes: [...sensorOperations.links.scopes],
     returns: "SensorLink[]",
-    notes: "GET /api/v1/sensors/links."
+    notes: `${routeOf(sensorOperations.links)}.`
   },
   {
     path: ["sensors", "map"],
@@ -36643,18 +37440,18 @@ var COMMAND_SPECS = [
       },
       { name: "label", type: "string", description: "A name for it (Home Assistant's own)." }
     ],
-    scopes: ["places:write"],
+    scopes: [...sensorOperations.createLink.scopes],
     returns: "SensorLink",
-    notes: "POST /api/v1/sensors/links. An animal maps to the Place it's housed in (409 when it has none). Mapping an entity again moves it."
+    notes: `${routeOf(sensorOperations.createLink)}. An animal maps to the Place it's housed in (409 when it has none). Mapping an entity again moves it.`
   },
   {
     path: ["sensors", "unmap"],
     summary: "Unmap an entity; the readings it gave stay.",
     args: [{ name: "link", required: true, description: "The sensor link ULID." }],
     flags: [],
-    scopes: ["places:write"],
+    scopes: [...sensorOperations.removeLink.scopes],
     returns: "None",
-    notes: "DELETE /api/v1/sensors/links/{id}."
+    notes: `${routeOf(sensorOperations.removeLink)}.`
   },
   {
     path: ["runs", "sessions", "list"],
@@ -36964,7 +37761,7 @@ var COMMAND_SPECS = [
         description: 'JSON MarkGuestsSentInput, e.g. {"guestIds":["01\u2026"],"what":"save_the_date"} (or "invite"; "at" defaults to now).'
       }
     ],
-    scopes: ["contacts:write"],
+    scopes: [...guestOperations.sent.scopes],
     returns: "GuestView"
   },
   {
@@ -40614,15 +41411,24 @@ var HANDLERS = {
   },
   "task cancel": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "task id");
-    return { data: await requireClient().post(`/tasks/${id}/cancel`, {}), render: renderTask };
+    return {
+      data: await requireClient().post(pathOf(taskOperations.cancel, { id }), {}),
+      render: renderTask
+    };
   },
   "tasks accept": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "task id");
-    return { data: await requireClient().post(`/tasks/${id}/accept`, {}), render: renderTask };
+    return {
+      data: await requireClient().post(pathOf(taskOperations.accept, { id }), {}),
+      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 };
+    return {
+      data: await requireClient().post(pathOf(taskOperations.notNow, { id }), {}),
+      render: renderTask
+    };
   },
   "block-templates week": async ({ flags, requireClient }) => {
     const start = flagString(flags, "start");
@@ -40792,12 +41598,18 @@ var HANDLERS = {
     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 };
+    return {
+      data: await requireClient().post(pathOf(taskOperations.ready, { id }), body),
+      render: renderTask
+    };
   },
   "task reopen": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "task id");
     const body = parseInput(updateTaskInputSchema, { status: "todo" });
-    return { data: await requireClient().patch(`/tasks/${id}`, body), render: renderTask };
+    return {
+      data: await requireClient().patch(pathOf(taskOperations.update, { id }), body),
+      render: renderTask
+    };
   },
   "task snooze": async ({ args, flags, io, requireClient }) => {
     const id = requireArg(args, 0, "task id");
@@ -40809,7 +41621,10 @@ var HANDLERS = {
       ...until ? { allDay: until.allDay } : {},
       ...duration ? { durationMinutes: duration } : {}
     });
-    return { data: await requireClient().patch(`/tasks/${id}`, body), render: renderTask };
+    return {
+      data: await requireClient().patch(pathOf(taskOperations.update, { id }), body),
+      render: renderTask
+    };
   },
   "task schedule": async ({ args, flags, requireClient }) => {
     const id = requireArg(args, 0, "task id");
@@ -40822,7 +41637,10 @@ var HANDLERS = {
       allDay: at.allDay,
       ...duration ? { durationMinutes: duration } : {}
     });
-    return { data: await requireClient().patch(`/tasks/${id}`, body), render: renderTask };
+    return {
+      data: await requireClient().patch(pathOf(taskOperations.update, { id }), body),
+      render: renderTask
+    };
   },
   "habit log": async ({ args, flags, requireClient }) => {
     const id = requireArg(args, 0, "habit id");
@@ -40839,7 +41657,7 @@ var HANDLERS = {
       ...note !== undefined ? { note } : {}
     });
     return {
-      data: await requireClient().post(`/habits/${id}/check-ins`, input),
+      data: await requireClient().post(pathOf(habitOperations.checkIn, { id }), input),
       render: renderHabit
     };
   },
@@ -40863,7 +41681,10 @@ var HANDLERS = {
       ...at ? { occurredAt: at } : {},
       ...note !== undefined ? { note } : {}
     });
-    return { data: await requireClient().post("/habits/check-in", input), render: renderHabit };
+    return {
+      data: await requireClient().post(pathOf(habitOperations.checkInByTitle), input),
+      render: renderHabit
+    };
   },
   "habit alias add": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "habit id");
@@ -40872,7 +41693,7 @@ var HANDLERS = {
       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),
+      data: await requireClient().post(pathOf(habitOperations.addAlias, { id }), input),
       render: renderHabit
     };
   },
@@ -40882,12 +41703,12 @@ var HANDLERS = {
     if (!alias)
       throw usageError("habit alias rm needs the alias to drop");
     return {
-      data: await requireClient().delete(`/habits/${id}/aliases/${encodeURIComponent(alias)}`),
+      data: await requireClient().delete(pathOf(habitOperations.removeAlias, { id, alias })),
       render: renderHabit
     };
   },
   "habits today": async ({ requireClient }) => ({
-    data: await requireClient().get("/habits/today"),
+    data: await requireClient().get(pathOf(habitOperations.today)),
     render: renderHabitsToday
   }),
   "habit check-ins": async ({ args, flags, requireClient }) => {
@@ -40897,7 +41718,7 @@ var HANDLERS = {
       limit: flagString(flags, "limit")
     };
     return {
-      data: await requireClient().get(`/habits/${id}/check-ins`, { query }),
+      data: await requireClient().get(pathOf(habitOperations.listCheckIns, { id }), { query }),
       render: renderList
     };
   },
@@ -40912,7 +41733,7 @@ var HANDLERS = {
       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),
+      data: await requireClient().patch(pathOf(habitOperations.updateCheckIn, { id, entryId }), input),
       render: renderHabitEntry
     };
   },
@@ -40924,7 +41745,10 @@ var HANDLERS = {
       ...date ? { date } : {},
       ...note !== undefined ? { note } : {}
     });
-    return { data: await requireClient().post(`/habits/${id}/skip`, input), render: renderHabit };
+    return {
+      data: await requireClient().post(pathOf(habitOperations.skip, { id }), input),
+      render: renderHabit
+    };
   },
   "habit pause": async ({ args, flags, requireClient }) => {
     const id = requireArg(args, 0, "habit id");
@@ -40932,7 +41756,10 @@ var HANDLERS = {
     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 };
+    return {
+      data: await requireClient().post(pathOf(habitOperations.pause, { id }), input),
+      render: renderHabit
+    };
   },
   "habit remind": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "habit id");
@@ -40940,19 +41767,31 @@ var HANDLERS = {
     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 };
+    return {
+      data: await requireClient().patch(pathOf(habitOperations.update, { 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 };
+    return {
+      data: await requireClient().post(pathOf(habitOperations.resume, { id }), {}),
+      render: renderHabit
+    };
   },
   "habit retire": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "habit id");
-    return { data: await requireClient().post(`/habits/${id}/retire`, {}), render: renderHabit };
+    return {
+      data: await requireClient().post(pathOf(habitOperations.retire, { id }), {}),
+      render: renderHabit
+    };
   },
   "habit unretire": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "habit id");
-    return { data: await requireClient().post(`/habits/${id}/unretire`, {}), render: renderHabit };
+    return {
+      data: await requireClient().post(pathOf(habitOperations.unretire, { id }), {}),
+      render: renderHabit
+    };
   },
   away: async ({ args, flags, requireClient }) => {
     const until = flagString(flags, "until");
@@ -40971,7 +41810,7 @@ var HANDLERS = {
     const id = requireArg(args, 0, "routine id");
     const input = parseInput(routineDoneInputSchema, {});
     return {
-      data: await requireClient().post(`/routines/${id}/done`, input),
+      data: await requireClient().post(pathOf(routineOperations.markDone, { id }), input),
       render: renderRoutineDone
     };
   },
@@ -40983,7 +41822,7 @@ var HANDLERS = {
     }
     const input = parseInput(routineRunUndoInputSchema, { stepRunIds });
     return {
-      data: await requireClient().post(`/routines/runs/${runId}/undo`, input),
+      data: await requireClient().post(pathOf(routineOperations.undoSteps, { runId }), input),
       render: renderRoutineUndo
     };
   },
@@ -42157,31 +42996,31 @@ var HANDLERS = {
     return { data: await requireClient().post("/runs/steam/sync", body), render: renderRecord };
   },
   "sensors status": async ({ requireClient }) => ({
-    data: await requireClient().get("/sensors/home-assistant"),
+    data: await requireClient().get(pathOf(sensorOperations.status)),
     render: renderRecord
   }),
   "sensors entities": async ({ requireClient }) => ({
-    data: await requireClient().get("/sensors/home-assistant/entities"),
+    data: await requireClient().get(pathOf(sensorOperations.entities)),
     render: renderList
   }),
   "sensors sync": async ({ requireClient }) => ({
-    data: await requireClient().post("/sensors/home-assistant/sync", {}),
+    data: await requireClient().post(pathOf(sensorOperations.sync), {}),
     render: renderRecord
   }),
   "sensors unifi": async ({ requireClient }) => ({
-    data: await requireClient().get("/sensors/unifi"),
+    data: await requireClient().get(pathOf(sensorOperations.unifiStatus)),
     render: renderRecord
   }),
   "sensors unifi-devices": async ({ requireClient }) => ({
-    data: await requireClient().get("/sensors/unifi/devices"),
+    data: await requireClient().get(pathOf(sensorOperations.unifiDevices)),
     render: renderList
   }),
   "sensors unifi-sync": async ({ requireClient }) => ({
-    data: await requireClient().post("/sensors/unifi/sync", {}),
+    data: await requireClient().post(pathOf(sensorOperations.syncUnifi), {}),
     render: renderRecord
   }),
   "sensors links": async ({ flags, requireClient }) => ({
-    data: await requireClient().get("/sensors/links", {
+    data: await requireClient().get(pathOf(sensorOperations.links), {
       query: { nodeId: flagString(flags, "node") }
     }),
     render: renderList
@@ -42194,11 +43033,14 @@ var HANDLERS = {
       ...flagString(flags, "provider") ? { provider: flagString(flags, "provider") } : {},
       ...flagString(flags, "label") ? { label: flagString(flags, "label") } : {}
     });
-    return { data: await requireClient().post("/sensors/links", body), render: renderRecord };
+    return {
+      data: await requireClient().post(pathOf(sensorOperations.createLink), body),
+      render: renderRecord
+    };
   },
   "sensors unmap": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "sensor link id");
-    await requireClient().delete(`/sensors/links/${id}`);
+    await requireClient().delete(pathOf(sensorOperations.removeLink, { id }));
     return { data: { ok: true, unmapped: id }, render: renderRecord };
   },
   "runs sessions list": async ({ args, requireClient }) => {
@@ -42701,7 +43543,10 @@ var HANDLERS = {
   },
   "guests sent": async ({ flags, requireClient }) => {
     const body = parseInput(markGuestsSentInputSchema, readDataFlag(flags));
-    return { data: await requireClient().post("/guests/sent", body), render: renderRecord };
+    return {
+      data: await requireClient().post(pathOf(guestOperations.sent), body),
+      render: renderRecord
+    };
   },
   "rsvp-questions presets": async ({ flags, requireClient }) => {
     const body = parseInput(addRsvpPresetsInputSchema, readDataFlag(flags));