@robbeverhelst/do 1.306.0 → 1.306.1

package/dist/do.js

@@ -4026,7 +4026,7 @@ var notifications = pgTable("notifications", {
   id: text("id").primaryKey(),
   tenantId: text("tenant_id").notNull().references(() => tenants.id),
   userId: text("user_id").notNull().references(() => users.id),
-  type: notificationType("type").notNull(),
+  type: notificationType("type"),
   title: text("title").notNull(),
   body: text("body"),
   entityId: text("entity_id"),
@@ -24797,6 +24797,121 @@ var reviewDayStatSchema = object({
 });
 var reviewStatsSchema = array(reviewDayStatSchema);
 
+// ../../packages/schema/src/contracts/progress.ts
+var progressDateSchema = string2().regex(/^\d{4}-\d{2}-\d{2}$/, "expected YYYY-MM-DD");
+var progressRangeDays = [7, 30, 90];
+var progressQuerySchema = object({
+  days: exports_coerce.number().int().refine((n) => progressRangeDays.includes(n), {
+    message: "days must be 7, 30 or 90"
+  }).default(7)
+});
+var shareSchema = number2().min(0).max(1).nullable();
+var countSchema = number2().int().nonnegative();
+var progressRangeSchema = object({
+  from: progressDateSchema,
+  to: progressDateSchema,
+  days: union([literal(7), literal(30), literal(90)]),
+  timezone: string2().min(1)
+});
+var progressTodaySchema = object({
+  date: progressDateSchema,
+  tasksDone: countSchema,
+  tasksPlanned: countSchema,
+  habitsDone: countSchema,
+  habitsDue: countSchema,
+  blocksDone: countSchema,
+  blocksPlanned: countSchema,
+  completion: shareSchema
+});
+var progressDaySchema = object({
+  date: progressDateSchema,
+  tasksDoneMine: countSchema,
+  tasksDoneAgents: countSchema,
+  tasksSlipped: countSchema,
+  habitsDone: countSchema,
+  habitsDue: countSchema,
+  blocksDone: countSchema,
+  blocksPlanned: countSchema,
+  completion: shareSchema,
+  onTime: countSchema,
+  late: countSchema
+});
+var progressPeriodFigures = object({
+  from: progressDateSchema,
+  to: progressDateSchema,
+  tasksDone: countSchema,
+  habitsDone: countSchema,
+  completion: shareSchema
+});
+var progressPeriodSchema = progressPeriodFigures.extend({
+  previous: progressPeriodFigures
+});
+var progressTotalsSchema = object({
+  week: progressPeriodSchema,
+  month: progressPeriodSchema,
+  bestDay: object({ date: progressDateSchema, tasksDone: countSchema }).nullable(),
+  averagePerDay: object({
+    tasksDone: number2().nonnegative(),
+    habitsDone: number2().nonnegative()
+  }),
+  onTime: countSchema,
+  late: countSchema
+});
+var progressAreaSchema = object({
+  areaId: string2().nullable(),
+  name: string2(),
+  color: string2().nullable(),
+  tasksDone: countSchema,
+  tasksDoneMine: countSchema.default(0),
+  tasksDoneAgents: countSchema.default(0),
+  habitsDone: countSchema.default(0),
+  blocksDone: countSchema.default(0),
+  total: countSchema.default(0),
+  previousTotal: countSchema.default(0)
+});
+var progressHabitDayStateSchema = _enum2(["done", "missed", "open", "skipped", "not-due"]);
+var progressHabitSchema = object({
+  habitId: string2(),
+  name: string2(),
+  rate: shareSchema,
+  due: countSchema,
+  done: countSchema,
+  days: array(object({ date: progressDateSchema, state: progressHabitDayStateSchema }))
+});
+var progressResponseSchema = object({
+  range: progressRangeSchema,
+  today: progressTodaySchema,
+  days: array(progressDaySchema),
+  totals: progressTotalsSchema,
+  areas: array(progressAreaSchema),
+  areasHighlight: string2().nullable().default(null),
+  habits: array(progressHabitSchema)
+});
+var progressItemKindSchema = _enum2(["task", "habit", "block"]);
+var progressDoneItemSchema = object({
+  id: string2(),
+  title: string2(),
+  kind: progressItemKindSchema,
+  owner: _enum2(["me", "agent"]),
+  areaId: string2().nullable(),
+  completedAt: exports_coerce.date(),
+  late: boolean3()
+});
+var progressSlippedItemSchema = object({
+  id: string2(),
+  title: string2(),
+  kind: progressItemKindSchema,
+  dueAt: exports_coerce.date().nullable(),
+  scheduledAt: exports_coerce.date().nullable(),
+  areaId: string2().nullable()
+});
+var progressDayDetailSchema = object({
+  date: progressDateSchema,
+  timezone: string2().min(1),
+  done: array(progressDoneItemSchema),
+  slipped: array(progressSlippedItemSchema)
+});
+
 // ../../packages/schema/src/contracts/insights.ts
 var insightsActivityPointSchema = object({
   day: string2(),
@@ -25075,6 +25190,7 @@ var foodDaySchema = object({
   completeness: _enum2(FOOD_DAY_COMPLETENESS_VALUES)
 });
 var civilDate = string2().regex(/^\d{4}-\d{2}-\d{2}$/, "a date is YYYY-MM-DD");
+var foodDateSchema = civilDate;
 var mealLogListQuerySchema = object({ from: exports_coerce.date(), to: exports_coerce.date() }).refine((q) => q.from < q.to, { message: "from must be before to" }).refine((q) => q.to.getTime() - q.from.getTime() <= 92 * 24 * 60 * 60 * 1000, {
   message: "ask for at most 92 days"
 });
@@ -30113,6 +30229,410 @@ function crudOperations(r) {
   };
 }
 
+// ../../packages/schema/src/operations/animals.ts
+var READ = ["animals:read"];
+var WRITE = ["animals:write"];
+var visit = { visitId: "The vet visit's ULID." };
+var animalOperations = defineOperations({
+  ...crudOperations({
+    segment: "animals",
+    tag: "Animals",
+    noun: "animal",
+    read: "animals:read",
+    write: "animals:write",
+    create: createAnimalInputSchema,
+    update: updateAnimalInputSchema,
+    listQuery: [
+      {
+        name: "status",
+        description: "Only this status (`planned`, `active`, `quarantine`, `rehomed`, `lost`, `died`)."
+      },
+      { name: "form", description: "`individual` or `group`." },
+      { name: "groupId", description: "Only the members of this group." },
+      {
+        name: "includeEnded",
+        description: "`true`: include animals that left (rehomed, lost, died); left out by default."
+      }
+    ],
+    listQuerySchema: animalsQuerySchema
+  }),
+  overview: {
+    method: "get",
+    path: "/animals/overview",
+    scopes: READ,
+    tag: "Animals",
+    summary: "The Animals home",
+    description: "The animals still with the household, today's strip (eggs per flock against its heads with the last 7 days, the feed supplies with days left, the daily-care Habits and whether they're done today, in UTC days) `comingUp`, every animal's key dates from today on (each with `vet`, the vet its animal or flock is cared by, else null), and `periods`, the periods running on them.",
+    status: 200,
+    response: { description: "`{ animals, today, comingUp, periods }`." }
+  },
+  handover: {
+    method: "get",
+    path: "/animals/handover",
+    scopes: READ,
+    tag: "Animals",
+    summary: "The holiday handover",
+    description: "What a sitter needs for a trip: the `away` period given as `periodId` (404 when it isn't one), else the next `away` period still to come or running, else the Space's \"Away until \u2026\"; `trip` is null when nothing is planned. Each animal still here (planned ones and ones that left stay off) with `steps` and `aside` read from its attached note's list lines and other lines, its `speciesKey` and `speciesClass` (for its icon), and `asleep` when a hibernation runs into the trip; the trip carries the agent's `agentNote` (written on the `away` period's `rule.agentNote`); `contacts`, the linked vets then every Contact with the vet role (`kind: \"vet\"`), then each member's own Contact with a phone (`kind: \"member\"`); `trip.calendar` is null here (the calendar is the signed-in member's own); `sensors` when a room's sensors reported this week; the feed `supplies` with `lastsTrip`; the daily-care `habits` with `restsThroughTrip`. Never a chip or certificate number. Days are UTC.",
+    query: [
+      {
+        name: "periodId",
+        description: "An `away` period's ULID; the next trip when left out."
+      }
+    ],
+    querySchema: animalHandoverQuerySchema,
+    status: 200,
+    response: {
+      description: "`{ trip, areaId, animals, contacts, supplies, habits, generatedAt }`."
+    },
+    errors: { 404: "`periodId` isn't an `away` period in this Space." }
+  },
+  listSpecies: {
+    method: "get",
+    path: "/animals/species",
+    scopes: READ,
+    tag: "Animals",
+    summary: "List species profiles",
+    description: "The Space's species profiles; the built-in set (dog, cat, chicken, Hermann's tortoise, native finches with closed rings, \u2026) arrives on first use and can be edited.",
+    status: 200,
+    response: { description: "The species profiles." }
+  },
+  createSpecies: {
+    method: "post",
+    path: "/animals/species",
+    scopes: WRITE,
+    tag: "Animals",
+    summary: "Add a species profile",
+    description: "A species of the Space's own. `key` is a lowercase slug, unique per Space (409 when taken).",
+    body: createAnimalSpeciesInputSchema,
+    status: 201,
+    response: { description: "The species profile." },
+    errors: { 400: true }
+  },
+  updateSpecies: {
+    method: "patch",
+    path: "/animals/species/{speciesId}",
+    pathParams: { speciesId: "The species' ULID." },
+    scopes: WRITE,
+    tag: "Animals",
+    summary: "Edit a species profile",
+    description: "Edit the Space's copy of a species profile; the key stays.",
+    body: updateAnimalSpeciesInputSchema,
+    status: 200,
+    response: { description: "The species profile." },
+    errors: { 400: true }
+  },
+  vetVisit: {
+    method: "get",
+    path: "/animals/vet-visits/{visitId}",
+    pathParams: visit,
+    scopes: READ,
+    tag: "Animals",
+    summary: "A vet visit, as its receipt reads",
+    description: "The animal, when, the vet, the clinician, the vaccine with where it was read, the dewormer, the weight with its change since the weigh-in before, the key dates it set, the files it filed, the cost, and `undone`.",
+    status: 200,
+    response: { description: "The vet visit." },
+    errors: { 404: true }
+  },
+  patchVetVisit: {
+    method: "patch",
+    path: "/animals/vet-visits/{visitId}",
+    pathParams: visit,
+    scopes: WRITE,
+    tag: "Animals",
+    summary: "Put a vet visit's fields right",
+    description: "The receipt's Edit: `vetContactId`, `clinician`, `reason`, `vaccine`, `dewormer` or `cost` (null clears one). The ledger keeps every version; the newest wins. Fires `animal.visit.updated`.",
+    body: animalVetVisitPatchSchema,
+    status: 200,
+    response: { description: "The vet visit." },
+    errors: { 400: true, 404: true },
+    webhook: "animal.visit.updated"
+  },
+  undoVetVisit: {
+    method: "post",
+    path: "/animals/vet-visits/{visitId}/undo",
+    pathParams: visit,
+    scopes: WRITE,
+    tag: "Animals",
+    summary: "Take a vet visit back",
+    description: "The receipt's Undo: every write of that turn goes: the visit (its weight drops off the chart and the timeline), the key dates it set, and the files go back to the chat. Fires `animal.visit.undone`.",
+    status: 200,
+    response: { description: "The vet visit, `undone: true`." },
+    errors: { 404: true },
+    webhook: "animal.visit.undone"
+  },
+  timeline: {
+    method: "get",
+    path: "/animals/{id}/timeline",
+    scopes: READ,
+    tag: "Animals",
+    summary: "An animal's timeline",
+    description: "Newest first: weights (grams), lengths (mm), egg counts and notes logged on it (for a group, its members' too), periods starting and ending, and key dates that came round, over the last `days` (default 90).",
+    query: [{ name: "days", description: "How far back, in days (1\u20133650, default 90)." }],
+    querySchema: animalTimelineQuerySchema,
+    status: 200,
+    response: { description: "The timeline entries." },
+    errors: { 404: true }
+  },
+  lostCard: {
+    method: "get",
+    path: "/animals/{id}/lost-card",
+    scopes: READ,
+    tag: "Animals",
+    summary: "An animal's lost-pet card",
+    description: "`card` is null while it's off; else its `path` (`/lost/<token>`, the page its QR code opens, no account), what it shows (`photoFileId`, `phone`, `showChipped`, `note`) and `preview`, the finder's page. `photos` are the pictures on the animal it may show; `chipOnFile` whether it can say chipped.",
+    status: 200,
+    response: { description: "The card's state." },
+    errors: { 404: true }
+  },
+  setLostCard: {
+    method: "put",
+    path: "/animals/{id}/lost-card",
+    scopes: WRITE,
+    tag: "Animals",
+    summary: "Turn the lost-pet card on, or change what it shows",
+    description: "The name always shows; the rest only when given (`null` takes one off). An individual still with the household (a lost one included); the photo must be a picture on the animal; `showChipped` needs its chip on file and never shows the number. The link stays the same while the card is on.",
+    body: animalLostCardInputSchema,
+    status: 200,
+    response: { description: "The card's state." },
+    errors: { 400: true, 404: true }
+  },
+  removeLostCard: {
+    method: "delete",
+    path: "/animals/{id}/lost-card",
+    scopes: WRITE,
+    tag: "Animals",
+    summary: "Turn the lost-pet card off",
+    description: "Its link stops working (a printed QR too); turning it on again makes a new one.",
+    status: 204,
+    response: { description: "Off." },
+    errors: { 404: true }
+  },
+  acquisition: {
+    method: "get",
+    path: "/animals/{id}/acquisition",
+    scopes: READ,
+    tag: "Animals",
+    summary: "Bringing a planned animal home: its checklist",
+    description: 'The Task "Bring <name> home" (`taskId`, `pickUpOn`), its steps in order (`done`, and `quarantine` for the quarantine step), `blockers` to sort before the pick-up ("No EU CITES certificate with photo on file yet") and `arrived`. A 404 when none was made.',
+    status: 200,
+    response: { description: "The checklist." },
+    errors: { 404: true }
+  },
+  planAcquisition: {
+    method: "post",
+    path: "/animals/{id}/acquisition",
+    scopes: WRITE,
+    tag: "Animals",
+    summary: "Plan bringing a planned animal home",
+    description: 'Acquisitions are a checklist, not a form: makes the Task "Bring <name> home" in its Area (due `pickUpOn`), with a step per line of the checklist \u2014 the papers its kind needs (DogID, CatID, CITES A, closed ring), the vet check, its home, and the quarantine before it meets the others (`quarantine`, on by default for a reptile or a bird) \u2014 plus `extraSteps`. Only a `planned` animal (400 otherwise); one per animal (409).',
+    body: animalAcquisitionInputSchema,
+    status: 201,
+    response: { description: "The checklist." },
+    errors: { 400: true, 404: true, 409: "Already planned." }
+  },
+  arrived: {
+    method: "post",
+    path: "/animals/{id}/arrived",
+    scopes: WRITE,
+    tag: "Animals",
+    summary: "A planned animal is home",
+    description: "Sets `acquiredOn` (`on`, today by default) and its status: `quarantine` with a quarantine Period of `quarantineMonths` (3 when its checklist has the quarantine step), else `active`. The acquisition's Task is done; open steps stay open. Returns the animal's page.",
+    body: animalArrivedInputSchema,
+    status: 200,
+    response: { description: "The animal." },
+    errors: { 400: true, 404: true }
+  },
+  log: {
+    method: "post",
+    path: "/animals/{id}/log",
+    scopes: WRITE,
+    tag: "Animals",
+    summary: "Log eggs, a weight, a length or a note",
+    description: 'One fact as one call (`animal_log`): `{ kind: "weight", value, unit: "g"|"kg" }` (stored in grams), `{ kind: "length", value }` (mm), `{ kind: "eggs", count }` (the day\'s count on a bird or a flock; logging again that day replaces it) or `{ kind: "note", text }`; `occurredAt` back-dates it. Appended to the datapoints ledger. Returns the timeline entry; fires `animal.logged`.',
+    body: animalLogInputSchema,
+    status: 201,
+    response: { description: "The timeline entry." },
+    errors: { 400: true, 404: true },
+    webhook: "animal.logged"
+  },
+  logVetVisit: {
+    method: "post",
+    path: "/animals/{id}/vet-visits",
+    scopes: WRITE,
+    tag: "Animals",
+    summary: "Log a vet visit in one call",
+    description: 'A vet visit as one call (`animal_vet_visit`, mockup 03): the visit becomes a vet Encounter about the animal (the household\'s, `space`-visible), with `vetContactId`, `clinician`, `reason`, `vaccine` `{ name, source: "sticker"|"photo"|"said" }`, `dewormer` and `cost` `{ amount, currency }` on the ledger; `weight` `{ value, unit }` is logged on the animal; each of `nextDates` `[{ id, label, date }]` becomes a key date (so a Task); `files` `[{ id, name? }]` (uploaded from chat) are filed on the animal. `id` is the visit\'s, client-minted. Returns the visit, the receipt to post with `receipt: { nodeId: <animal id>, about: "vet_visit", parts: [<visit id>] }`; fires `animal.visit.logged`.',
+    body: animalVetVisitInputSchema,
+    status: 201,
+    response: { description: "The vet visit (the receipt)." },
+    errors: { 400: true, 404: true },
+    webhook: "animal.visit.logged"
+  }
+});
+
+// ../../packages/schema/src/operations/areas.ts
+var standard = { standardId: "The standard's id (from the Area's `standards`)." };
+var detail = "The Area detail; each standard carries `state` (`holding` / `worth_a_look`, null when unlinked), `why` in words and `heldBy`.";
+var areaOperations = defineOperations({
+  ...crudOperations({
+    segment: "areas",
+    tag: "Areas",
+    noun: "area",
+    read: "areas:read",
+    write: "areas:write",
+    create: createAreaInputSchema,
+    update: updateAreaInputSchema,
+    listQuery: [
+      {
+        name: "archived",
+        description: "`false`: only live Areas; `true`: only archived ones. Omit for both.",
+        enum: ["true", "false"]
+      }
+    ],
+    listQuerySchema: areaListQuerySchema
+  }),
+  overview: {
+    method: "get",
+    path: "/areas/overview",
+    scopes: ["areas:read"],
+    tag: "Areas",
+    summary: "How each Area is going",
+    description: 'The map of life (#901): every live, unarchived Area with its attention in words against its own usual (this fortnight vs its median fortnight over the 12 weeks before: `busier` "Busier than usual", `steady` "Steady", `quiet` "Quiet for three weeks", `resting` "Resting") and a short reason, its purpose line, at most two lines of what\'s moving, and `waiting`, what waits on the key\'s member (the only count). Activity is tasks landed, habit check-ins, notes and time blocks; under `owner=mine` (the default) agents\' work doesn\'t count. Resting Areas come last; set or clear resting with `PATCH /api/v1/areas/{id}` `{ restingUntil }`. Never a score.',
+    query: [
+      {
+        name: "owner",
+        description: "Whose work counts: `mine` (default), `agents` or `all`.",
+        enum: ["mine", "agents", "all"]
+      }
+    ],
+    querySchema: areaOverviewQuerySchema,
+    status: 200,
+    response: { description: "The overview.", view: "AreaOverview" },
+    errors: { 400: true },
+    operationId: "get_areas_overview"
+  },
+  sinceLastLook: {
+    method: "get",
+    path: "/areas/{id}/since-last-look",
+    scopes: ["areas:read"],
+    tag: "Areas",
+    summary: "What happened in an Area since the last look",
+    description: 'Areas 6: since the Area\'s last look (`lastReviewedAt`), or the last month without one, up to five tasks of the Area (its own and its Projects\') that `landed` (with `by` when an Agent did it) and that are `fresh`, and up to three that seem `stuck`, each with `why` in words ("Waiting on you since 3 October", "Deadline was 12 October", "Untouched since 1 September"). Named, never tallied.',
+    status: 200,
+    response: { description: "Since you last looked.", view: "AreaSinceLastLook" },
+    errors: { 404: true },
+    operationId: "get_area_since_last_look"
+  },
+  lookedAt: {
+    method: "post",
+    path: "/areas/{id}/looked-at",
+    scopes: ["areas:write"],
+    tag: "Areas",
+    summary: "Record a look at an Area",
+    description: 'Areas 6: "Looked at" sets the Area\'s `lastReviewedAt` to now, so its rhythm (`reviewCadence`: weekly, monthly, quarterly) starts again and it leaves Review until it comes round. Fires `area.updated`.',
+    status: 200,
+    response: { description: "The Area view." },
+    errors: { 404: true },
+    webhook: "area.updated",
+    operationId: "mark_area_looked_at"
+  },
+  rest: {
+    method: "post",
+    path: "/areas/{id}/rest",
+    scopes: ["areas:write"],
+    tag: "Areas",
+    summary: "Rest an Area until a day",
+    description: "Areas 8: rest the Area until `until` (the day it's back, after today). It keeps everything filed and folds to the foot of the map; Focus, Review and the agent's filing leave it alone; its recurring tasks pause (Today leaves out their occurrences dated while it rests). `habits: \"pause\"` pauses its habits until then too (default `keep`). Fires `area.updated`.",
+    body: restAreaInputSchema,
+    status: 200,
+    response: { description: "The Area view." },
+    errors: { 400: true, 404: true },
+    webhook: "area.updated",
+    operationId: "rest_area"
+  },
+  back: {
+    method: "post",
+    path: "/areas/{id}/back",
+    scopes: ["areas:write"],
+    tag: "Areas",
+    summary: "Bring a resting Area back",
+    description: "Areas 8: the Area is back today. The habits it paused come back too, and its recurring tasks' occurrences that went by while it rested are skipped, so nothing piles up. Fires `area.updated`.",
+    status: 200,
+    response: { description: "The Area view." },
+    errors: { 404: true },
+    webhook: "area.updated",
+    operationId: "bring_area_back"
+  },
+  toProject: {
+    method: "post",
+    path: "/areas/{id}/to-project",
+    scopes: ["areas:write", "projects:write"],
+    tag: "Areas",
+    summary: "Make an Area a Project",
+    description: "Areas 8: an Area that finishes (a wedding, a move) becomes a Project. The client mints `projectId`; the Project takes the Area's title (its purpose becomes the Project's note) and is filed under `intoAreaId` (or none). The Area's loose tasks become the Project's tasks; its own Projects, habits, routines, notes and Collection items move to `intoAreaId` beside it; the Area is archived, never deleted. Returns the receipt (`moved`) that `\u2026/to-project/undo` takes. An agent should only propose this; the member decides. Fires `area.updated`.",
+    body: areaToProjectInputSchema,
+    status: 200,
+    response: { description: "The receipt." },
+    errors: { 400: true, 404: true },
+    webhook: "area.updated",
+    operationId: "make_area_a_project"
+  },
+  undoToProject: {
+    method: "post",
+    path: "/areas/{id}/to-project/undo",
+    scopes: ["areas:write", "projects:write"],
+    tag: "Areas",
+    summary: "Undo making an Area a Project",
+    description: "Areas 8: hand back the receipt from `\u2026/to-project`; everything that moved comes back, the Area is active again and the Project made for it goes. Fires `area.updated`.",
+    body: undoAreaToProjectInputSchema,
+    status: 200,
+    response: { description: "The Area view." },
+    errors: { 400: true, 404: true },
+    webhook: "area.updated",
+    operationId: "undo_area_to_project"
+  },
+  addStandard: {
+    method: "post",
+    path: "/areas/{id}/standards",
+    scopes: ["areas:write"],
+    tag: "Areas",
+    summary: "Add an Area standard",
+    description: 'Add one standard (a plain sentence of what fine looks like) at the end; up to five per Area. `link` optionally ties it to what holds it: `{ kind: "habit", id }`, `{ kind: "task", id }` (a recurring task) or `{ kind: "metric", key }`. An Agent\'s add lands in the change list with Undo. Fires `area.updated`.',
+    body: addAreaStandardInputSchema,
+    status: 201,
+    response: { description: detail },
+    errors: { 400: true, 404: true },
+    webhook: "area.updated"
+  },
+  updateStandard: {
+    method: "patch",
+    path: "/areas/{id}/standards/{standardId}",
+    pathParams: standard,
+    scopes: ["areas:write"],
+    tag: "Areas",
+    summary: "Change an Area standard",
+    description: "Reword a standard or change what holds it (`link: null` unlinks it, so it's checked by hand in review). Fires `area.updated`.",
+    body: updateAreaStandardInputSchema,
+    status: 200,
+    response: { description: detail },
+    errors: { 400: true, 404: true },
+    webhook: "area.updated"
+  },
+  removeStandard: {
+    method: "delete",
+    path: "/areas/{id}/standards/{standardId}",
+    pathParams: standard,
+    scopes: ["areas:write"],
+    tag: "Areas",
+    summary: "Remove an Area standard",
+    description: "Remove one standard. Fires `area.updated`.",
+    status: 200,
+    response: { description: detail },
+    errors: { 404: true },
+    webhook: "area.updated"
+  }
+});
+
 // ../../packages/schema/src/operations/block-templates.ts
 var crud = crudOperations({
   segment: "block-templates",
@@ -30154,6 +30674,69 @@ var blockTemplateOperations = defineOperations({
   }
 });
 
+// ../../packages/schema/src/operations/calendar.ts
+var calendarOperations = defineOperations({
+  connections: {
+    method: "get",
+    path: "/calendar/connections",
+    scopes: ["calendar:read"],
+    tag: "Calendar",
+    summary: "List connections",
+    description: "The Space's integration connections (calendar + any other provider).",
+    status: 200,
+    response: { description: "The connections." }
+  },
+  connection: {
+    method: "get",
+    path: "/calendar/connections/{id}",
+    scopes: ["calendar:read"],
+    tag: "Calendar",
+    summary: "Get a connection",
+    description: "One integration connection by id.",
+    status: 200,
+    response: { description: "The connection." },
+    errors: { 404: true }
+  },
+  links: {
+    method: "get",
+    path: "/calendar/connections/{id}/links",
+    scopes: ["calendar:read"],
+    tag: "Calendar",
+    summary: "List event links",
+    description: "The local-node \u2194 remote-event links for a calendar connection.",
+    status: 200,
+    response: { description: "The event links." },
+    errors: { 404: true }
+  },
+  events: {
+    method: "get",
+    path: "/calendar/events",
+    scopes: ["calendar:read"],
+    tag: "Calendar",
+    summary: "List the member's events",
+    description: "The member's mirrored events overlapping `[from, to)` (ISO instants, both or neither; at most 62 days; neither = the next day), each with `busyForPlacement`, `optional` and `attending`. Needs a key that acts for a member.",
+    query: [
+      { name: "from", description: "Window start, an ISO instant." },
+      { name: "to", description: "Window end (exclusive), an ISO instant." }
+    ],
+    status: 200,
+    response: { description: "The events.", list: true, view: "Event" },
+    errors: { 400: true }
+  },
+  plan: {
+    method: "patch",
+    path: "/calendar/events/{id}/plan",
+    scopes: ["calendar:write"],
+    tag: "Calendar",
+    summary: "Mark an event optional, or answer one",
+    description: "Something the member may or may not do (watching a race) is `optional`: ask them first (a question with buttons), then record `attending` (`yes` \xB7 `no` \xB7 null = waiting). Until it's `yes` the event holds no time (`busyForPlacement` false) and nothing may be planned around it. do's own state; nothing goes to Google. `optional: false` clears the answer.",
+    body: eventPlanInputSchema,
+    status: 200,
+    response: { description: "The event, after.", view: "Event" },
+    errors: { 400: true, 404: true }
+  }
+});
+
 // ../../packages/schema/src/operations/collection-upkeep.ts
 var collectionUpkeepOperations = defineOperations({
   list: {
@@ -30193,6 +30776,386 @@ var collectionUpkeepOperations = defineOperations({
   }
 });
 
+// ../../packages/schema/src/operations/days.ts
+var pathParams = {
+  date: {
+    description: "The civil day, `YYYY-MM-DD`, in the member's zone.",
+    format: "date"
+  }
+};
+var pathParamSchemas = { date: dayDateSchema };
+var dayOperations = defineOperations({
+  record: {
+    method: "get",
+    path: "/days/{date}/record",
+    pathParams,
+    pathParamSchemas,
+    scopes: ["calendar:read"],
+    tag: "Calendar",
+    summary: "A day's record",
+    description: "The key's member's day as the evening check-in reads it: the life blocks starting that day, each with its plan, its record, `status` (`as_planned` \xB7 `moved` \xB7 `shortened` \xB7 `extended` \xB7 `skipped` \xB7 `replaced` \xB7 `unplanned`), `recordState` (`open` \xB7 `inferred` \xB7 `confirmed` \xB7 `closed`), a confidence word and its evidence; the queued `questions` (two at most), `filledIn` (blocks the agent wrote that the member hasn't confirmed), `gaps` (30+ min with no block), `closed` and `autoClosesAt` (48 h after the day ends).",
+    status: 200,
+    response: { description: "The day's record." },
+    errors: { 400: true }
+  },
+  write: {
+    method: "post",
+    path: "/days/{date}/record",
+    pathParams,
+    pathParamSchemas,
+    scopes: ["calendar:write"],
+    tag: "Calendar",
+    summary: "Write a day's record (day_record_write)",
+    description: "A set of changes to begun life blocks of that day, each with the facts behind it (`evidence`: `source` chat \xB7 edit_do \xB7 edit_google \xB7 google_health \xB7 wakehook \xB7 strava \xB7 habit \xB7 task \xB7 routine_run \xB7 do_activity \xB7 github \xB7 phone_location \xB7 plan_default, with `refKind`/`refId`). Retime a block (`blockId` + `startAt`/`endAt`), mark it `skipped` or `replacedBy` another, or mint a new one (`id` + `lifeKind` + times: an unplanned block, an `unknown` gap, a replacement). Times round to the quarter hour; status and confidence follow. An Agent's write leaves the record `inferred`; a member's confirms it. A closed day is a 409 for an Agent. Never waits for a confirmation. Returns the receipt: `receipt` (send it to `/undo`), one line in words per block, `googleUpdated` and the day.",
+    body: dayRecordWriteInputSchema,
+    status: 200,
+    response: { description: "The receipt." },
+    errors: { 400: true, 404: true, 409: true }
+  },
+  ask: {
+    method: "post",
+    path: "/days/{date}/record/ask",
+    pathParams,
+    pathParamSchemas,
+    scopes: ["calendar:write"],
+    tag: "Calendar",
+    summary: "Queue a check-in question (day_record_ask)",
+    description: "A fill-in question for the evening check-in about one block (`blockId`) or a gap (`id` + `startAt`/`endAt`, which becomes an `unknown` block). Two a day at most and never twice about one block (409). The member's own word in a later write answers it.",
+    body: dayRecordAskInputSchema,
+    status: 200,
+    response: { description: "The day's record." },
+    errors: { 400: true, 404: true, 409: true }
+  },
+  undo: {
+    method: "post",
+    path: "/days/{date}/record/undo",
+    pathParams,
+    pathParamSchemas,
+    scopes: ["calendar:write"],
+    tag: "Calendar",
+    summary: "Undo a record write",
+    description: "Takes a whole write back by its `receipt`: retimed blocks are put back, blocks it made are removed. The evidence stays as history.",
+    body: dayRecordUndoInputSchema,
+    status: 200,
+    response: { description: "`{ undone, day }`." },
+    errors: { 404: true }
+  },
+  close: {
+    method: "post",
+    path: "/days/{date}/close",
+    pathParams,
+    pathParamSchemas,
+    scopes: ["calendar:write"],
+    tag: "Calendar",
+    summary: "Close a day (day_close)",
+    description: "The member said the record is fine: every life block of the day is `closed` and pushed to Google at once. After this only the member changes it. A day nobody closes closes itself 48 h after it ends.",
+    status: 200,
+    response: { description: "The day's record." },
+    errors: { 400: true }
+  }
+});
+
+// ../../packages/schema/src/operations/food-log.ts
+var NO_MEMBER = "The key holds no health scope by name, or has no member behind it.";
+var HIDDEN = "No such meal, or it isn't the key's member's.";
+var RECEIPT = "The meal with its `receipt`: a headline with the kcal range, a confidence word (close \xB7 estimate \xB7 rough), a line per item with its source, and the Undo / Edit / Save as my meal calls.";
+var ITEM = "Each item: `label` and one of `foodId` (from `GET /api/v1/foods/search`), `productId` or `recipeId`, with `grams`, `quantity` + `unit` (`2 boterham`, `1 el`) or `servings`; optional `gramsLow`/`gramsHigh` and `matchConfidence`. With no reference, an `estimate` `{kcal, proteinG, carbsG, fatG}` (a labelled guess). The numbers are computed: table \xD7 grams.";
+var meal = { id: "The meal's ULID." };
+var mealId = { id: ulidSchema };
+var foodLogOperations = defineOperations({
+  list: {
+    method: "get",
+    path: "/food/logs",
+    scopes: ["health:read"],
+    tag: "Food",
+    summary: "List meals",
+    description: "The member's meals eaten in `[from, to)` (ISO instants, at most 92 days), oldest first.",
+    query: [
+      { name: "from", description: "Start (inclusive), an ISO instant.", required: true },
+      { name: "to", description: "End (exclusive), an ISO instant.", required: true }
+    ],
+    querySchema: mealLogListQuerySchema,
+    status: 200,
+    response: { description: "The meals." },
+    errors: { 400: true, 403: NO_MEMBER }
+  },
+  create: {
+    method: "post",
+    path: "/food/logs",
+    scopes: ["health:write"],
+    tag: "Food",
+    summary: "Log a meal",
+    description: `Log what the member ate in one call: \`id\`, \`title\`, \`eatenAt\`, \`mealType\` (breakfast \xB7 lunch \xB7 dinner \xB7 snack \xB7 drink), optional \`portionNote\`, \`place\`, \`flags\`, \`capture\`, \`photoFileId\`, and \`items\`. ${ITEM} Always private to the member.`,
+    body: createMealLogInputSchema,
+    status: 201,
+    response: { description: RECEIPT },
+    errors: { 400: true, 403: NO_MEMBER },
+    operationId: "food_log"
+  },
+  get: {
+    method: "get",
+    path: "/food/logs/{id}",
+    pathParams: meal,
+    pathParamSchemas: mealId,
+    scopes: ["health:read"],
+    tag: "Food",
+    summary: "Get a meal",
+    description: "One meal: its current items, the corrected ones, and the attribution its sources require.",
+    status: 200,
+    response: { description: "The meal." },
+    errors: { 404: HIDDEN }
+  },
+  correct: {
+    method: "patch",
+    path: "/food/logs/{id}",
+    pathParams: meal,
+    pathParamSchemas: mealId,
+    scopes: ["health:write"],
+    tag: "Food",
+    summary: "Correct a meal",
+    description: `Correct a meal: \`replace\` (\`[{itemId, item}]\`), \`remove\` (item ids) and \`add\` (items) add rows, never edit one; the meal's own fields update. ${ITEM}`,
+    body: correctMealLogInputSchema,
+    status: 200,
+    response: { description: RECEIPT },
+    errors: { 400: true, 404: HIDDEN },
+    operationId: "food_correct"
+  },
+  remove: {
+    method: "delete",
+    path: "/food/logs/{id}",
+    pathParams: meal,
+    pathParamSchemas: mealId,
+    scopes: ["health:write"],
+    tag: "Food",
+    summary: "Remove a meal",
+    description: "The receipt's Undo: the meal goes to Trash.",
+    status: 204,
+    response: { description: "Removed." },
+    errors: { 404: HIDDEN }
+  },
+  undoCorrection: {
+    method: "post",
+    path: "/food/logs/{id}/undo-correction",
+    pathParams: meal,
+    pathParamSchemas: mealId,
+    scopes: ["health:write"],
+    tag: "Food",
+    summary: "Undo a meal's last correction",
+    description: "Take back the latest correction: the items it replaced or removed are current again.",
+    status: 200,
+    response: { description: RECEIPT },
+    errors: { 400: true, 404: HIDDEN }
+  },
+  saveMeal: {
+    method: "post",
+    path: "/food/logs/{id}/save-meal",
+    pathParams: meal,
+    pathParamSchemas: mealId,
+    scopes: ["health:write"],
+    tag: "Food",
+    summary: "Save a meal as my meal",
+    description: "Keep the meal's current items as a saved meal (a private recipe of kind `saved_meal`, in grams), optionally under a new `title`. Log it again with `recipeId` + `servings: 1`. Returns `{ recipeId }`.",
+    body: saveMealInputSchema,
+    bodyOptional: true,
+    status: 201,
+    response: { description: "The saved meal's recipe id." },
+    errors: { 404: HIDDEN },
+    operationId: "food_save_meal"
+  },
+  context: {
+    method: "get",
+    path: "/food/logs/{id}/context",
+    pathParams: meal,
+    pathParamSchemas: mealId,
+    scopes: ["health:read"],
+    tag: "Food",
+    summary: "Show a meal in its day",
+    description: "The meal page's read: the weekmenu plan for the meal's day and slot (`planStatus` as_planned \xB7 swapped \xB7 unplanned), the nearby meal block, `minutesFromPlan`, `minutesBeforeBed`, and After \u2014 Health symptom entries, an Episode that began and doses in the 12 hours after, the night's sleep and the day rating \u2014 plus the Episode that began. Read-side; nothing in it says the meal caused what followed.",
+    status: 200,
+    response: { description: "The meal's context." },
+    errors: { 404: HIDDEN },
+    operationId: "food_context"
+  },
+  week: {
+    method: "get",
+    path: "/food/week",
+    scopes: ["health:read"],
+    tag: "Food",
+    summary: "Show a food week",
+    description: "The week (Monday to Sunday) around `start` (any day of it; this week by default): each day's total (null = nothing logged, not zero), its meals with the minute they were eaten and a `tired` or `symptom` mark when a Health symptom entry followed, the weekmenu's planned meals and kcal, the meal blocks' planned times and bedtime; `usualKcal` (the median complete day of the last 28, never a target), the `weight` Metric over 30 days with its 7-day trend, and the week in numbers. Read-side; nothing in it says a meal caused what followed.",
+    query: [{ name: "start", description: "", format: "date" }],
+    querySchema: foodWeekQuerySchema,
+    status: 200,
+    response: { description: "The food week." },
+    operationId: "food_week"
+  },
+  writeWeekRead: {
+    method: "put",
+    path: "/food/week/read",
+    scopes: ["health:write"],
+    tag: "Food",
+    summary: "Write the read of a food week",
+    description: "Write or replace the agent's read of the week holding `start` (any day of it): a few lines about the week (`body`, at most 2,000 characters), shown on the food week as the agent's read. It sits behind the private wall, the member's only. A week that hasn't started can't have one. Returns the week. Calm words, never a cause or a score.",
+    body: writeFoodWeekReadInputSchema,
+    status: 200,
+    response: { description: "The food week, with its read." },
+    errors: { 400: true, 403: NO_MEMBER },
+    operationId: "food_week_read"
+  },
+  removeWeekRead: {
+    method: "delete",
+    path: "/food/week/read",
+    scopes: ["health:write"],
+    tag: "Food",
+    summary: "Take back the read of a food week",
+    description: "Take back the read of the week holding `start`; nothing to take back is fine.",
+    query: [{ name: "start", description: "A day in the week, YYYY-MM-DD.", required: true }],
+    querySchema: foodWeekReadQuerySchema,
+    status: 204,
+    response: { description: "Taken back." },
+    errors: { 400: true, 403: NO_MEMBER },
+    operationId: "food_week_read_remove"
+  },
+  patterns: {
+    method: "get",
+    path: "/food/patterns",
+    scopes: ["health:read"],
+    tag: "Food",
+    summary: "Show food and how you feel",
+    description: 'A short, fixed list of questions over the 90 days up to this week\'s Monday (so the answers hold still all week): big lunches and a "tired" note within 4 h (weekdays), dinner within 3 h of bed and a symptom that night, very hot / fried / big meals and a symptom within 6 h, days you ate more and the day rating, and each week\'s average kcal against the weight trend. Each answer is `shown`, `no_difference` or `collecting` on the Insights rules (\u2265 21 paired days and \u2265 7 a side, an effect bar, a confidence word), with its sides as counts ("13 of 18 days") or means, the days still needed, and a footer that always gives the number of days. "Goes together", never a cause.',
+    status: 200,
+    response: { description: "The food questions' answers." },
+    operationId: "food_patterns"
+  },
+  proposeTrial: {
+    method: "post",
+    path: "/food/trials",
+    scopes: ["health:write"],
+    tag: "Food",
+    summary: "Propose a two-week food trial",
+    description: 'Propose one small change for the member to try for `days` (14 by default, 7\u201328) from `startsOn` (today or later): `title` is the change ("Split lunch"), `note` a few words on what you\'ll compare afterwards, `question` the food question it answers. It waits on Food and how you feel as "Try it for two weeks?" until the member starts it, says Not now (a week) or stops it; a newer proposal sets an older waiting one aside. Behind the private wall, the member\'s only. Still n-of-1 information, never a diagnosis.',
+    body: proposeFoodTrialInputSchema,
+    status: 201,
+    response: { description: "The trial, proposed." },
+    errors: { 400: true, 403: NO_MEMBER },
+    operationId: "food_trial"
+  },
+  stopTrial: {
+    method: "post",
+    path: "/food/trials/{id}/stop",
+    pathParams: { id: "The trial's ULID." },
+    pathParamSchemas: { id: ulidSchema },
+    scopes: ["health:write"],
+    tag: "Food",
+    summary: "Stop a food trial",
+    description: "Stop a trial, running or still proposed.",
+    status: 204,
+    response: { description: "Stopped." },
+    errors: { 404: "No such trial, or it isn't the key's member's." },
+    operationId: "food_trial_stop"
+  },
+  days: {
+    method: "get",
+    path: "/food/days",
+    scopes: ["health:read"],
+    tag: "Food",
+    summary: "List food days",
+    description: "The `food.kcal` series: per civil day in the member's timezone (a meal before 04:00 counts for the day before), kcal with a range, macros, meals and `complete`/`partial`. A day with nothing logged has no row: missing, not zero.",
+    query: [
+      { name: "from", description: "First day, YYYY-MM-DD.", required: true },
+      { name: "to", description: "Last day, YYYY-MM-DD.", required: true }
+    ],
+    querySchema: foodDaysQuerySchema,
+    status: 200,
+    response: { description: "The days." },
+    errors: { 400: true, 403: NO_MEMBER }
+  },
+  day: {
+    method: "get",
+    path: "/food/days/{date}",
+    pathParams: { date: "The day, YYYY-MM-DD." },
+    pathParamSchemas: { date: foodDateSchema },
+    scopes: ["health:read"],
+    tag: "Food",
+    summary: "Get a food day",
+    description: "One day: its meals, its total (null when nothing is logged) and the household's planned meals for it.",
+    status: 200,
+    response: { description: "The day." },
+    errors: { 400: true, 403: NO_MEMBER }
+  },
+  recall: {
+    method: "get",
+    path: "/food/recall",
+    scopes: ["health:read"],
+    tag: "Food",
+    summary: "Recall frequent meals",
+    description: `What the member eats often: their most-logged meals of the last 30 days (with the last one's id, to log it again) and their saved meals. Use it before asking what "the usual" is.`,
+    status: 200,
+    response: { description: "Frequent and saved meals." },
+    errors: { 403: NO_MEMBER },
+    operationId: "food_recall"
+  }
+});
+
+// ../../packages/schema/src/operations/foods.ts
+var foodOperations = defineOperations({
+  search: {
+    method: "get",
+    path: "/foods/search",
+    scopes: ["meals:read"],
+    tag: "Food",
+    summary: "Search foods",
+    description: "Search the nutrition reference by name: NEVO and USDA generic foods first, then branded products cached from Open Food Facts. Values are per 100 g, with each source's required attribution in `licence`. With `remote=true`, also asks Open Food Facts when there are fewer than `limit` local hits; never call it per keystroke. Returns `{ data, remote }`.",
+    query: [
+      {
+        name: "q",
+        description: "At least 2 characters of the food's name or brand.",
+        required: true
+      },
+      { name: "limit", description: "1\u201350, default 20.", type: "integer", minimum: 1, maximum: 50 },
+      {
+        name: "remote",
+        description: "`true` to also search Open Food Facts.",
+        enum: ["true", "false"]
+      }
+    ],
+    querySchema: foodSearchQuerySchema,
+    status: 200,
+    response: {
+      description: "What happened with Open Food Facts: `skipped` (not asked, or the cache answered), `used`, `rate_limited` (do's own guard refused to call; OFF allows 15 product reads and 10 searches a minute) or `unavailable`."
+    },
+    errors: { 400: true }
+  },
+  barcode: {
+    method: "get",
+    path: "/foods/barcode/{ean}",
+    pathParams: {
+      ean: { description: "The product's EAN/UPC barcode (8\u201314 digits).", pattern: "^\\d{8,14}$" }
+    },
+    pathParamSchemas: { ean: foodBarcodeSchema },
+    scopes: ["meals:read"],
+    tag: "Food",
+    summary: "Look up a food by barcode",
+    description: "A branded product by barcode, from the cache when it is under 30 days old, else from Open Food Facts (then cached). `{ found, barcode, food, remote }`; an unknown barcode is `found: false`, never an error.",
+    status: 200,
+    response: { description: "The product, or found: false." },
+    errors: { 400: true }
+  },
+  get: {
+    method: "get",
+    path: "/foods/{id}",
+    pathParams: { id: "The food's ULID." },
+    pathParamSchemas: { id: ulidSchema },
+    scopes: ["meals:read"],
+    tag: "Food",
+    summary: "Get a food",
+    description: "One food from the nutrition reference.",
+    status: 200,
+    response: { description: "The food." },
+    errors: { 404: true }
+  }
+});
+
 // ../../packages/schema/src/operations/google-contacts.ts
 var googleContactsOperations = defineOperations({
   list: {
@@ -30271,6 +31234,58 @@ var guestListEventOperations = defineOperations({
   remove: { ...crud2.remove, webhook: "guest.event.deleted" }
 });
 
+// ../../packages/schema/src/operations/guest-lists.ts
+var list = { id: "The guest list's ULID." };
+var guestListOperations = defineOperations({
+  ...crudOperations({
+    segment: "guest-lists",
+    tag: "Guests",
+    noun: "guest list",
+    read: "contacts:read",
+    write: "contacts:write",
+    create: createGuestListInputSchema,
+    update: updateGuestListInputSchema,
+    listQuery: [{ name: "projectId", description: "Only this project's guest list." }],
+    listQuerySchema: guestListsQuerySchema
+  }),
+  overview: {
+    method: "get",
+    path: "/guest-lists/{id}/overview",
+    pathParams: list,
+    scopes: ["contacts:read"],
+    tag: "Guests",
+    summary: "The guest list page",
+    description: "The guests grouped by household (a guest in none is a household of one), the head count overall and per part of the day with each part's cap (a plus-one is one more head, following the guest), the project's key dates (the deadlines), the witnesses and speeches by side, and how many households got their save-the-date and invitation.",
+    status: 200,
+    response: { description: "The overview." },
+    errors: { 404: true }
+  },
+  thankYou: {
+    method: "get",
+    path: "/guest-lists/{id}/thank-you",
+    pathParams: list,
+    scopes: ["contacts:read"],
+    tag: "Guests",
+    summary: "Thank-you cards",
+    description: "The gifts for the event: `gift_received` moments on guests' contacts whose `sourceNodeId` is the list's project (log one with `POST /contact-moments`). `toThank` (oldest first) and `thanked` (newest card first); mark a card sent with `PATCH /contact-moments/{id}` `{ thankedAt }`. The gifts stay on each person's timeline after the day.",
+    status: 200,
+    response: { description: "`{ toThank, thanked }`." },
+    errors: { 404: true }
+  },
+  export: {
+    method: "get",
+    path: "/guest-lists/{id}/exports/{kind}",
+    pathParams: { ...list, kind: { enum: GUEST_EXPORT_KINDS } },
+    scopes: ["contacts:read"],
+    tag: "Guests",
+    summary: "Export for the caterer, the venue, the room, the church, the answers or the printer",
+    description: "`caterer`: a CSV of meals per table (a plus-one is one more; the meal is the dinner, else the reception, else coming at all) with each diet as a count, never a name. `venue`: a CSV of the tables and who sits at each, one row per person. `floor-plan`: a one-page PDF of the tables with their people. `church`: a CSV of who comes to the ceremony, with their side and role. `answers`: a CSV of every RSVP answer, one row per guest (household, guest, RSVP) and a column per question in form order; a household's answer is on each of its guests' rows. `invitations`: the paper invitations' inserts, a PDF of one A6 card per household with a live whole-form RSVP link \u2014 its QR (error correction M, 45 mm) to the list's `siteUrl` + `/i/<token>` (do's own `/rsvp/<token>` without one), the link, its six-character short code, and the list's `sitePassword` only while it is set; mint the links first. `printer`: the same cards as a CSV for the printer or a mail merge \u2014 household, two address lines, country, language, code and URL (a household without an address keeps its row, blank). PDFs are drawn in an embedded Noto Sans, so names print in full Unicode. Served as an attachment.",
+    status: 200,
+    response: { description: "The file." },
+    errors: { 400: true, 404: true }
+  }
+});
+
 // ../../packages/schema/src/operations/guest-tables.ts
 var guestTableOperations = defineOperations({
   ...crudOperations({
@@ -30613,6 +31628,144 @@ var habitOperations = defineOperations({
   }
 });
 
+// ../../packages/schema/src/operations/house.ts
+var READ2 = ["collections:read"];
+var WRITE2 = ["collections:write"];
+var WRITE_WITH_TASKS = ["collections:write", "tasks:write"];
+var receipt = "Returns `{ item, receipt }`: the asset now, and a receipt naming everything made or changed (`itemId`, `created`, `before`, `taskIds`, `entryIds`, `files`). Post the receipt to `/api/v1/house/undo` to take it all back.";
+var houseOperations = defineOperations({
+  overview: {
+    method: "get",
+    path: "/house",
+    scopes: READ2,
+    tag: "House",
+    summary: "The House home",
+    description: "What's broken (assets in condition `broken` or with an open repair Task), upkeep coming up (open upkeep Tasks with the day each is next due, soonest first), the top-level Places with how many things live in each, and `thingCount` / `upkeepCount` / `toolCount` / `animalCount` (the animals living here, groups counted once).",
+    status: 200,
+    response: { description: "The House home." }
+  },
+  value: {
+    method: "get",
+    path: "/house/value",
+    scopes: READ2,
+    tag: "House",
+    summary: "The value inventory",
+    description: "What's in the house, for the contents insurance and a claim: every owned asset with its Place, `bought` (purchase, else install day), `paid`, `now` (+ `nowSource`), `proof` (`receipt_photo` \xB7 `receipt` \xB7 `photo` \xB7 `none`: a receipt/warranty Document that `covers` it or a non-image File on it; an image File on it or its cover), `excluded` (`insure: false`, say a borrowed thing: listed, not summed) and `visibility`. `totals` sums now and paid; `policy` is the active home insurance Document with an `insuredValue`, or null. Another member's Only me things never show.",
+    status: 200,
+    response: { description: "The value inventory." }
+  },
+  year: {
+    method: "get",
+    path: "/house/upkeep",
+    scopes: READ2,
+    tag: "House",
+    summary: "The upkeep year",
+    description: "Every upkeep routine (a Task tied to an asset as `maintains`) across one year: `routines[].months` holds twelve marks, January first \u2014 `done` (an occurrence done, or a `service` Entry for the Task), `late` (skipped or slipped past), `due` (this month, not done), `planned` (coming, projected from the rule past what's materialized) or null. `needs` lists the Supply parts that fit an asset with a routine in `needsMonth` (next month), with `low` at or below the restock level; `spent` sums this year's costs on asset Entries (repairs + faults, services).",
+    query: [
+      { name: "year", description: "The year (2000\u20132100); default this one.", type: "integer" }
+    ],
+    querySchema: houseUpkeepYearQuerySchema,
+    status: 200,
+    response: { description: "The upkeep year." },
+    errors: { 400: true }
+  },
+  asset: {
+    method: "get",
+    path: "/house/assets/{id}",
+    scopes: READ2,
+    tag: "House",
+    summary: "One asset's House page",
+    description: "The asset as a House page: `item` (the Item with its Entries), `trail` (the Places it sits in, outermost first), `parts` (the Supply items that fit it, kind `fits`), and `linked` (every other node tied to it either way \u2014 a Document that `covers` it, a Task, an Event \u2014 plus the Contacts on its Entries as `serviced_by`), `warrantyUntil` (the latest warranty end among the warranty papers and receipts that cover it, or null; upkeep and repair Tasks are read from `/api/v1/collection/{id}/upkeep`). Only me rows of other members never show.",
+    status: 200,
+    response: { description: "The asset page." },
+    errors: { 404: true }
+  },
+  linkPart: {
+    method: "post",
+    path: "/house/assets/{id}/parts",
+    scopes: WRITE2,
+    tag: "House",
+    summary: "Tie a part to an asset",
+    description: "Tie a Supply item to the asset as a part that fits it (a filter, a door rope, a spare battery). Idempotent. Returns the asset page.",
+    body: linkAssetPartInputSchema,
+    status: 200,
+    response: { description: "The asset page." },
+    errors: { 400: true, 404: true }
+  },
+  unlinkPart: {
+    method: "delete",
+    path: "/house/assets/{id}/parts/{inventoryItemId}",
+    pathParams: { inventoryItemId: "The Supply item's ULID." },
+    scopes: WRITE2,
+    tag: "House",
+    summary: "Untie a part from an asset",
+    description: "The Supply item stays; only the link goes. Returns the asset page.",
+    status: 200,
+    response: { description: "The asset page." },
+    errors: { 404: true }
+  },
+  lend: {
+    method: "post",
+    path: "/house/assets/{id}/lend",
+    scopes: WRITE2,
+    tag: "House",
+    summary: "Lend a thing, or note one borrowed (asset_lend)",
+    description: "Sets the Item's `loan` \u2014 `direction` `lent` (to someone) or `borrowed` (from them), `who`, an optional `contactId`, `since` (default today), `dueBack`, `note` \u2014 and logs a `lent` Entry. Works on any Collection Item. 409 while it's already out.",
+    body: lendAssetInputSchema,
+    status: 200,
+    response: { description: "The Item with its Entries." },
+    errors: { 400: true, 404: true, 409: "Already out; return it first." }
+  },
+  giveBack: {
+    method: "post",
+    path: "/house/assets/{id}/return",
+    scopes: WRITE2,
+    tag: "House",
+    summary: "It's back (asset_return)",
+    description: "Clears the Item's `loan` and logs a `returned` Entry (`on` default today, optional `note`). 409 when it isn't out.",
+    body: returnAssetInputSchema,
+    status: 200,
+    response: { description: "The Item with its Entries." },
+    errors: { 400: true, 404: true, 409: "It isn't out." }
+  },
+  fileAsset: {
+    method: "post",
+    path: "/house/assets",
+    scopes: WRITE_WITH_TASKS,
+    tag: "House",
+    summary: "File an asset (asset_file)",
+    description: `File a thing in the house from what an agent read off a type plate, a receipt or a sentence. Matches one already in the Space (the same \`facet.serial\`, else the same \`facet.model\` in the same Place; \`match: false\` skips it) and fills in what's new, else adds an \`asset\` (status \`have\`). \`fileIds\` (uploaded first via \`/api/v1/files\`) move onto the asset; \`upkeep\` sets one recurring routine; \`fault\` logs a \`fault\` Entry and puts a repair Task on the fix-it list. ${receipt}`,
+    body: fileAssetInputSchema,
+    status: 201,
+    response: { description: "`{ item, receipt }`." },
+    errors: { 400: true }
+  },
+  setUpkeep: {
+    method: "post",
+    path: "/house/assets/{id}/upkeep",
+    scopes: WRITE_WITH_TASKS,
+    tag: "House",
+    summary: "Set an asset's upkeep (asset_upkeep_set)",
+    description: `Add one upkeep routine to the asset: a Task in its Place that repeats \`every\` days, weeks or months after the last time it was done (flexible), or every N years on a fixed day (\`unit: "year"\`, from \`startOn\`), tied to the asset as \`maintains\`. ${receipt}`,
+    body: setAssetUpkeepInputSchema,
+    status: 201,
+    response: { description: "`{ item, receipt }`." },
+    errors: { 400: true, 404: true }
+  },
+  undo: {
+    method: "post",
+    path: "/house/undo",
+    scopes: WRITE_WITH_TASKS,
+    tag: "House",
+    summary: "Undo a House write",
+    description: "Take a House write back from its receipt: its Tasks go to Trash, its Entries are removed, moved Files go back where they were, and an added asset goes to Trash (a matched one gets its facet, Place and status back). Steps already undone are skipped. Returns `{ itemId, undone: true }`.",
+    body: undoHouseWriteInputSchema,
+    status: 200,
+    response: { description: "`{ itemId, undone }`." },
+    errors: { 400: true }
+  }
+});
+
 // ../../packages/schema/src/operations/households.ts
 var householdOperations = defineOperations({
   ...crudOperations({
@@ -30644,7 +31797,7 @@ var inventoryItemOperations = defineOperations({
 });
 
 // ../../packages/schema/src/operations/mail-campaigns.ts
-var pathParams = { id: "The campaign's ULID." };
+var pathParams2 = { id: "The campaign's ULID." };
 var mailCampaignOperations = defineOperations({
   list: {
     method: "get",
@@ -30674,7 +31827,7 @@ var mailCampaignOperations = defineOperations({
   get: {
     method: "get",
     path: "/mail-campaigns/{id}",
-    pathParams,
+    pathParams: pathParams2,
     scopes: ["contacts:read"],
     tag: "Guests",
     summary: "Get a mail campaign",
@@ -30686,7 +31839,7 @@ var mailCampaignOperations = defineOperations({
   update: {
     method: "patch",
     path: "/mail-campaigns/{id}",
-    pathParams,
+    pathParams: pathParams2,
     scopes: ["contacts:write"],
     tag: "Guests",
     summary: "Edit a draft",
@@ -30699,7 +31852,7 @@ var mailCampaignOperations = defineOperations({
   preview: {
     method: "get",
     path: "/mail-campaigns/{id}/preview",
-    pathParams,
+    pathParams: pathParams2,
     scopes: ["contacts:read"],
     tag: "Guests",
     summary: "Preview a mail campaign",
@@ -30725,6 +31878,72 @@ var mealPlanOperations = defineOperations({
   })
 });
 
+// ../../packages/schema/src/operations/metrics.ts
+var NO_MEMBER2 = "The key acts for no member.";
+var metricOperations = defineOperations({
+  list: {
+    method: "get",
+    path: "/metrics",
+    scopes: ["habits:read"],
+    tag: "Habits",
+    summary: "List metrics",
+    description: "Weight (kg), sleep (h), mood (1\u20135), the day rating, energy, bedtime, resting heart rate (bpm) and HRV (ms) as trend lines: one point per day in the member's timezone (that day's last value, hand-logged or from Google Fit or Google Health), oldest first, plus the latest. No target, no streak. The key must act for a member. Resting heart rate and HRV are health data: without `health:read` held by name their lines come back empty.",
+    query: [
+      { name: "days", description: "How far back, 1\u2013730 days (default 90).", type: "integer" }
+    ],
+    querySchema: metricsQuerySchema,
+    status: 200,
+    response: { description: "Every Metric with its points." },
+    errors: { 403: NO_MEMBER2 }
+  },
+  sessions: {
+    method: "get",
+    path: "/metrics/sessions",
+    scopes: ["habits:read"],
+    tag: "Habits",
+    summary: "List workout sessions",
+    description: "The member's workouts from their connections (Google Fit workouts, Strava activities), newest first: when, the sport in words, its name and minutes. Read only; they come in through sync.",
+    query: [
+      { name: "days", description: "How far back, 1\u2013365 days (default 14).", type: "integer" }
+    ],
+    querySchema: sessionsQuerySchema,
+    status: 200,
+    response: { description: "The sessions." },
+    errors: { 403: NO_MEMBER2 }
+  },
+  import: {
+    method: "post",
+    path: "/metrics/import",
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Import metrics from Health Connect",
+    description: "A batch the Android app read off the phone's Health Connect: `weight` (kg), `sleep` (h) and `bedtime` (minutes after 18:00), at most 500, each with its Health Connect `recordId`. Each lands once on the member's line with source `health_connect`; a record already imported, out of its Metric's range or in the future is skipped, not refused. Returns `{ imported, skipped }`.",
+    body: importMetricsInputSchema,
+    status: 201,
+    response: { description: "How many points landed and how many were skipped." },
+    errors: { 400: true, 403: NO_MEMBER2 }
+  },
+  log: {
+    method: "post",
+    path: "/metrics/{key}",
+    pathParams: {
+      key: {
+        description: "`weight` (kg), `sleep` (h), `mood` (1\u20135), `rating` (the day, 1\u201310), `energy` (1\u201310), `bedtime` (minutes after 18:00: 01:00 = 420), `resting_hr` (bpm) or `hrv` (ms). The last two are health data: logging one needs `health:write` too.",
+        enum: metricKeySchema.options
+      }
+    },
+    pathParamSchemas: { key: metricKeySchema },
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Log a metric",
+    description: 'Log one value ("weighed 72.4"; "slept 7.5 hours"; "mood 4"; "today was a 7" \u2192 `rating`; "bed 01:00" \u2192 `bedtime` 420); `occurredAt` back-dates it, `source` says `manual` (default) or `device`. A bedtime lands on the night\'s wake day. Logging again the same day replaces that day\'s point. 400 outside the Metric\'s range. Returns the Metric\'s refreshed line.',
+    body: logMetricInputSchema,
+    status: 201,
+    response: { description: "The Metric." },
+    errors: { 400: true, 403: NO_MEMBER2 }
+  }
+});
+
 // ../../packages/schema/src/operations/occurrences.ts
 var occurrenceOperations = defineOperations({
   list: {
@@ -30882,6 +32101,208 @@ 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/presets.ts
+var presetOperations = defineOperations({
+  list: {
+    method: "get",
+    path: "/presets",
+    scopes: ["presets:read"],
+    tag: "Presets",
+    summary: "List presets",
+    description: "The preset gallery catalog (metadata + recipe).",
+    status: 200,
+    response: { description: "The preset catalog." }
+  },
+  install: {
+    method: "post",
+    path: "/presets/{key}/install",
+    pathParams: { key: "The preset's catalog key." },
+    scopes: ["presets:install"],
+    tag: "Presets",
+    summary: "Install a preset",
+    description: "Install a preset's bundle into the key's Space; returns the created node ids.",
+    body: installPresetBodySchema,
+    bodyOptional: true,
+    status: 201,
+    response: { description: "The install result (created node ids)." },
+    errors: { 404: "Unknown preset key." }
+  }
+});
+
+// ../../packages/schema/src/operations/progress.ts
+var NO_MEMBER3 = "The key acts for no member.";
+var question = {
+  question: { description: "The question's key.", enum: insightsQuestionSchema.options }
+};
+var progressOperations = defineOperations({
+  get: {
+    method: "get",
+    path: "/progress",
+    scopes: ["tasks:read", "habits:read"],
+    tag: "Reads",
+    summary: "Progress",
+    description: `What got done day by day over the last 7, 30 or 90 days, in the key's member's saved timezone ("how was my week?"): today's done vs planned, per day tasks done (mine vs agents), habits done vs due, time blocks and day completion, the week and month against the period before, best day, average per day, on time vs late, tasks per Area and each habit's rate and days. Cancelled tasks never count; an empty day's completion is null.`,
+    query: [
+      {
+        name: "days",
+        description: "The range: `7` (default), `30` or `90` days ending today.",
+        type: "integer",
+        enum: [7, 30, 90]
+      }
+    ],
+    querySchema: progressQuerySchema,
+    status: 200,
+    response: { description: "The Progress read.", view: "ProgressResponse" },
+    errors: { 400: true },
+    operationId: "get_progress"
+  },
+  day: {
+    method: "get",
+    path: "/progress/days/{date}",
+    pathParams: { date: { description: "The day, `YYYY-MM-DD`.", format: "date" } },
+    pathParamSchemas: { date: progressDateSchema },
+    scopes: ["tasks:read", "habits:read"],
+    tag: "Reads",
+    summary: "Progress for a day",
+    description: "One day of Progress (the member's civil day): what was done \u2014 tasks, habits and time blocks, each with its owner (me or an agent) and whether it was late \u2014 and what slipped (planned that day, not finished by its end).",
+    status: 200,
+    response: { description: "The day's detail.", view: "ProgressDayDetail" },
+    errors: { 400: true },
+    operationId: "get_progress_day"
+  },
+  habits: {
+    method: "get",
+    path: "/progress/habits",
+    scopes: ["habits:read"],
+    tag: "Reads",
+    summary: "Habits on Progress",
+    description: "How the habits are going (#871), in the member's timezone: this week's grid (Monday first; each day done, skipped, empty or ahead, never missed) and the week so far, each habit's strength as a word (steady, building, settling-in) from a Loop-style smoothed score, the insights worker's patterns each with a confidence label, and when check-ins land by hour over the last 90 days.",
+    status: 200,
+    response: { description: "The habit insights.", view: "ProgressHabitsResponse" },
+    operationId: "get_progress_habits"
+  },
+  commits: {
+    method: "get",
+    path: "/progress/commits",
+    scopes: ["habits:read"],
+    tag: "Reads",
+    summary: "Your GitHub commits, yours and your agents'",
+    description: "The key's member's commits over the last `days` (7 by default, or 30), from their GitHub connection: `byYou` (the ones they made), `byAgents` (made on their account by an agent: a bot, an agent co-author, a \"Generated with\" footer) with `agents` by name, `unsorted` (synced before commits said who made them), and `perDay` in their zone. Only theirs count toward Insights' evening activity and a GitHub-sourced habit.",
+    query: [{ name: "days", description: "", type: "integer", enum: [7, 30] }],
+    querySchema: githubCommitsQuerySchema,
+    status: 200,
+    response: { description: "The split." },
+    errors: { 400: true, 403: NO_MEMBER3 }
+  },
+  questions: {
+    method: "get",
+    path: "/progress/questions",
+    scopes: ["habits:read"],
+    tag: "Reads",
+    summary: "Insights",
+    description: "Insights' answers to its fixed questions, for the key's member only: late nights vs the next day's rating, the morning routine vs the day, good runs, bedtime this week vs usual, what the best days have in common, reading this week vs usual. Each is `shown`, `no_difference` or `collecting` (with `neededDays`); recomputed weekly (Monday 04:00 in the member's zone). Quote `sentence` and `footer` verbatim; a pattern goes together, never a cause. Mention only a Medium or High one.",
+    status: 200,
+    response: { description: "This week's answers.", view: "InsightsAnswersResponse" },
+    errors: { 403: NO_MEMBER3 },
+    operationId: "get_insights"
+  },
+  dismiss: {
+    method: "post",
+    path: "/progress/questions/{question}/dismiss",
+    pathParams: question,
+    pathParamSchemas: { question: insightsQuestionSchema },
+    scopes: ["habits:write"],
+    tag: "Reads",
+    summary: "Set an insight aside",
+    description: 'Hide one answer as "not useful"; it stays hidden through the weekly recompute.',
+    status: 200,
+    response: { description: "The answers.", view: "InsightsAnswersResponse" },
+    errors: { 400: true },
+    operationId: "dismiss_insight"
+  },
+  restore: {
+    method: "post",
+    path: "/progress/questions/{question}/restore",
+    pathParams: question,
+    pathParamSchemas: { question: insightsQuestionSchema },
+    scopes: ["habits:write"],
+    tag: "Reads",
+    summary: "Bring an insight back",
+    description: "Show a set-aside answer again.",
+    status: 200,
+    response: { description: "The answers.", view: "InsightsAnswersResponse" },
+    errors: { 400: true },
+    operationId: "restore_insight"
+  },
+  activity: {
+    method: "post",
+    path: "/progress/activity",
+    scopes: ["habits:write"],
+    tag: "Reads",
+    summary: "Record member activity",
+    description: "The member was active somewhere do can't see \u2014 a message to the agent on another channel. The late-night question reads the last activity of each evening (00:00\u201304:00 counts for the evening before). `occurredAt` defaults to now; never in the future.",
+    body: memberActivityInputSchema,
+    status: 201,
+    response: { description: "Recorded." },
+    errors: { 400: true, 403: NO_MEMBER3 },
+    operationId: "record_member_activity"
+  }
+});
+
+// ../../packages/schema/src/operations/recipes.ts
+var recipe = { id: "The recipe's ULID." };
+var recipeOperations = defineOperations({
+  ...crudOperations({
+    segment: "recipes",
+    tag: "Meals",
+    noun: "recipe",
+    read: "meals:read",
+    write: "meals:write",
+    create: createRecipeInputSchema,
+    update: updateRecipeInputSchema,
+    paginated: true,
+    listQuerySchema: paginationQuerySchema
+  }),
+  usedIn: {
+    method: "get",
+    path: "/recipes/{id}/used-in",
+    pathParams: recipe,
+    scopes: ["meals:read"],
+    tag: "Meals",
+    summary: "Where a recipe was used",
+    description: "The meals the member ate it in (newest first, with what else was on the plate and how many servings) and the weekmenu days it's planned for from a week back on (soonest first), at most five of each. Meals are health data: a key without `health:read` gets the plans and no meals.",
+    status: 200,
+    response: { description: "The recipe's meals and plans." },
+    errors: { 404: true }
+  },
+  nutrition: {
+    method: "post",
+    path: "/recipes/{id}/nutrition",
+    pathParams: recipe,
+    scopes: ["meals:write"],
+    tag: "Meals",
+    summary: "Recompute a recipe's nutrition",
+    description: "Recompute the recipe's nutrition from its ingredients (each ingredient's product \u2192 its own values or its food's, \xD7 grams): per pot, per serving, the share of the mass matched (`coverage`) and the lines with no match or amount. Stored on the recipe; also done on every recipe write.",
+    status: 200,
+    response: { description: "The recipe's nutrition." },
+    errors: { 404: true }
+  },
+  match: {
+    method: "put",
+    path: "/recipes/{id}/ingredients/{ingredientId}/match",
+    pathParams: { ...recipe, ingredientId: "The ingredient's id." },
+    scopes: ["meals:write"],
+    tag: "Meals",
+    summary: "Confirm or swap an ingredient's match",
+    description: "Body `{ foodId }` (a food from `/api/v1/foods`): the ingredient's product becomes that reference food (a product is made for it when it has none) and the recipe's nutrition is worked out again. Returns the recipe.",
+    body: recipeIngredientMatchInputSchema,
+    status: 200,
+    response: { description: "The recipe." },
+    errors: { 404: true },
+    webhook: "recipe.updated"
+  }
+});
+
 // ../../packages/schema/src/operations/routines.ts
 var routineOperations = defineOperations({
   getRun: {
@@ -31098,6 +32519,79 @@ var rsvpAnswerOperations = defineOperations({
   }
 });
 
+// ../../packages/schema/src/operations/rsvp-links.ts
+var link = { id: "The link's ULID." };
+var rsvpLinkOperations = defineOperations({
+  list: {
+    method: "get",
+    path: "/rsvp-links",
+    scopes: ["contacts:read"],
+    tag: "Guests",
+    summary: "List a guest list's RSVP links",
+    description: "One per household, live or not, never with the token. `revealable` says a live link's token is kept, so it can be shown again.",
+    query: [{ name: "guestListId", description: "The guest list (required)." }],
+    querySchema: rsvpLinksQuerySchema,
+    status: 200,
+    response: { description: "The links." },
+    errors: { 400: true }
+  },
+  mint: {
+    method: "post",
+    path: "/rsvp-links",
+    scopes: ["contacts:write"],
+    tag: "Guests",
+    summary: "Mint RSVP links",
+    description: "One no-login link per household on the list: the named `householdIds`, or every household without a live link of the `mode`. `mode` is `full` (the whole form, the default) or `address` (the save-the-date's: the guests' names only, and it takes only the household's postal address and language). A guest in no household gets a household of one first; a household's older live link of that mode is revoked, the other mode's stays. The token (and the form's `path`, `/rsvp/<token>`) is in this response; it is looked up by its hash and kept sealed, so `GET /rsvp-links/{id}/token` shows the same link again. Webhooks never carry it. A link stops at `expiresAt`, by default the end of the RSVP deadline day (120 days without one; at most 400). The form behind it shows that household's guests (their names, parts, answers, diet, plus-one) and its postal address, nothing else. Fires `rsvp.link.created`.",
+    body: createRsvpLinksInputSchema,
+    status: 201,
+    response: { description: "The minted links, with their tokens." },
+    errors: { 400: true, 404: true },
+    webhook: "rsvp.link.created"
+  },
+  reveal: {
+    method: "get",
+    path: "/rsvp-links/{id}/token",
+    pathParams: link,
+    scopes: ["contacts:write"],
+    tag: "Guests",
+    summary: "Show an RSVP link again",
+    description: "The same token (and `path`) the live link was minted with, so the mail and the paper QR carry one link, and a whole-form link's `shortCode` (six characters, printed on the paper invitation and typed at the site's `/code`, which resolves it through `POST /public/rsvp/code`; an address link has none). A revoked or expired link is 410; one minted before tokens were kept is 409: replace it.",
+    status: 200,
+    response: { description: "The link, with its token." },
+    errors: {
+      404: true,
+      409: "Minted before tokens were kept; replace it.",
+      410: "Revoked or expired."
+    }
+  },
+  replace: {
+    method: "post",
+    path: "/rsvp-links/{id}/replace",
+    pathParams: link,
+    scopes: ["contacts:write"],
+    tag: "Guests",
+    summary: "Replace an RSVP link",
+    description: "A new token for the link's household, and the old link stops working (an old paper QR with it). The explicit way to re-mint. Fires `rsvp.link.created`.",
+    status: 200,
+    response: { description: "The new link, with its token." },
+    errors: { 404: true },
+    webhook: "rsvp.link.created"
+  },
+  revoke: {
+    method: "post",
+    path: "/rsvp-links/{id}/revoke",
+    pathParams: link,
+    scopes: ["contacts:write"],
+    tag: "Guests",
+    summary: "Revoke an RSVP link",
+    description: "The link stops working (the form says so). Idempotent. Fires `rsvp.link.revoked`.",
+    status: 200,
+    response: { description: "The link." },
+    errors: { 404: true },
+    webhook: "rsvp.link.revoked"
+  }
+});
+
 // ../../packages/schema/src/operations/rsvp-questions.ts
 var rsvpQuestionOperations = defineOperations({
   ...crudOperations({
@@ -31127,6 +32621,75 @@ var rsvpQuestionOperations = defineOperations({
   }
 });
 
+// ../../packages/schema/src/operations/seating-proposals.ts
+var proposal = { id: "The proposal's ULID." };
+var seatingProposalOperations = defineOperations({
+  list: {
+    method: "get",
+    path: "/seating-proposals",
+    scopes: ["contacts:read"],
+    tag: "Guests",
+    summary: "List seating proposals",
+    description: "A guest list's proposed plans, newest first: proposed, applied or dismissed.",
+    query: [{ name: "guestListId", description: "The guest list (required)." }],
+    querySchema: seatingProposalsQuerySchema,
+    status: 200,
+    response: { description: "The proposals." },
+    errors: { 400: true }
+  },
+  propose: {
+    method: "post",
+    path: "/seating-proposals",
+    scopes: ["contacts:write"],
+    tag: "Guests",
+    summary: "Propose a seating plan",
+    description: "Store a plan (the agent's first one: households together, circles near each other): tables with a name, seats and the guest ids at each. Every guest must be on the list and seated once; a table's heads (a plus-one counts) must fit its seats. Nothing moves until a member applies it. Through an API key it is `proposedBy: agent`. Fires `seating.proposal.created`.",
+    body: createSeatingProposalInputSchema,
+    status: 201,
+    response: { description: "The stored proposal." },
+    errors: { 400: true, 404: true },
+    webhook: "seating.proposal.created"
+  },
+  get: {
+    method: "get",
+    path: "/seating-proposals/{id}",
+    pathParams: proposal,
+    scopes: ["contacts:read"],
+    tag: "Guests",
+    summary: "Get a seating proposal",
+    description: "",
+    status: 200,
+    response: { description: "The proposal." },
+    errors: { 404: true }
+  },
+  apply: {
+    method: "post",
+    path: "/seating-proposals/{id}/apply",
+    pathParams: proposal,
+    scopes: ["contacts:write"],
+    tag: "Guests",
+    summary: "Apply a seating plan",
+    description: "The list's tables become the plan's (the old ones go) and each guest sits where it says; guests it doesn't name are unseated. Only a proposed plan applies (409 otherwise). Fires `seating.proposal.applied`.",
+    status: 200,
+    response: { description: "The applied proposal." },
+    errors: { 404: true, 409: "Already applied or dismissed." },
+    webhook: "seating.proposal.applied"
+  },
+  dismiss: {
+    method: "post",
+    path: "/seating-proposals/{id}/dismiss",
+    pathParams: proposal,
+    scopes: ["contacts:write"],
+    tag: "Guests",
+    summary: "Dismiss a seating plan",
+    description: "Set it aside without applying it. Fires `seating.proposal.dismissed`.",
+    status: 200,
+    response: { description: "The dismissed proposal." },
+    errors: { 404: true, 409: "Already applied or dismissed." },
+    webhook: "seating.proposal.dismissed"
+  }
+});
+
 // ../../packages/schema/src/operations/sensors.ts
 var sensorOperations = defineOperations({
   status: {
@@ -31276,14 +32839,14 @@ var shoppingListOperations = defineOperations({
 });
 
 // ../../packages/schema/src/operations/tap-tags.ts
-var READ = ["habits:read", "routines:read"];
-var WRITE = ["habits:write", "routines:write"];
-var pathParams2 = { id: "The tag's id: the ULID the sticker's link carries (`/t/{id}`)." };
+var READ3 = ["habits:read", "routines:read"];
+var WRITE3 = ["habits:write", "routines:write"];
+var pathParams3 = { id: "The tag's id: the ULID the sticker's link carries (`/t/{id}`)." };
 var tapTagOperations = defineOperations({
   list: {
     method: "get",
     path: "/tap-tags",
-    scopes: READ,
+    scopes: READ3,
     tag: "Habits",
     summary: "List tap tags",
     description: "The Space's NFC stickers: where each is (`label`), what a tap does (`habit`: check it in; `routine`: mark today's run done), its target's title and its link's `path`.",
@@ -31294,7 +32857,7 @@ var tapTagOperations = defineOperations({
   create: {
     method: "post",
     path: "/tap-tags",
-    scopes: WRITE,
+    scopes: WRITE3,
     tag: "Habits",
     summary: "Make a tap tag",
     description: "Bind a new sticker id (a client-minted ULID) to a live habit or routine of the Space, of the tag's kind. Write `https://<your do>/t/{id}` onto an NFC sticker.",
@@ -31306,8 +32869,8 @@ var tapTagOperations = defineOperations({
   get: {
     method: "get",
     path: "/tap-tags/{id}",
-    pathParams: pathParams2,
-    scopes: READ,
+    pathParams: pathParams3,
+    scopes: READ3,
     tag: "Habits",
     summary: "Get a tap tag",
     description: "One tag.",
@@ -31318,8 +32881,8 @@ var tapTagOperations = defineOperations({
   update: {
     method: "patch",
     path: "/tap-tags/{id}",
-    pathParams: pathParams2,
-    scopes: WRITE,
+    pathParams: pathParams3,
+    scopes: WRITE3,
     tag: "Habits",
     summary: "Rename or rebind a tap tag",
     description: "Change its `label`, or bind it to another habit or routine (`kind` and `targetId` together): the sticker stays as it is.",
@@ -31331,8 +32894,8 @@ var tapTagOperations = defineOperations({
   remove: {
     method: "delete",
     path: "/tap-tags/{id}",
-    pathParams: pathParams2,
-    scopes: WRITE,
+    pathParams: pathParams3,
+    scopes: WRITE3,
     tag: "Habits",
     summary: "Delete a tap tag",
     description: "The sticker's link stops doing anything.",
@@ -31343,8 +32906,8 @@ var tapTagOperations = defineOperations({
   tap: {
     method: "post",
     path: "/tap-tags/{id}/tap",
-    pathParams: pathParams2,
-    scopes: WRITE,
+    pathParams: pathParams3,
+    scopes: WRITE3,
     tag: "Habits",
     summary: "Tap a tap tag",
     description: "What the sticker does, as the key's member: check the habit in, or take today's run of the routine. Returns the receipt (`line`) and its `undo` (the check-in's `habitId` + `entryId`, or the run's `runId` + `stepRunIds` for `POST /routines/runs/{runId}/undo`). The same member's second tap within 30 s does nothing (`outcome: \"already\"`). The key must act for a member.",
@@ -31543,6 +33106,71 @@ var taskOperations = defineOperations({
   }
 });
 
+// ../../packages/schema/src/operations/time-blocks.ts
+var INSTANT = "an ISO 8601 datetime with offset, or a bare `YYYY-MM-DD` (UTC midnight)";
+var timeBlockOperations = defineOperations({
+  ...crudOperations({
+    segment: "time-blocks",
+    tag: "Calendar",
+    noun: "time block",
+    read: "calendar:read",
+    write: "calendar:write",
+    create: createTimeBlockInputSchema,
+    update: updateTimeBlockInputSchema,
+    listQuery: [
+      {
+        name: "from",
+        description: `Start of the window (inclusive) \u2014 ${INSTANT}. With \`to\`; both default to the next day.`,
+        format: "date-time"
+      },
+      {
+        name: "to",
+        description: `End of the window (exclusive, at most 62 days after \`from\`) \u2014 ${INSTANT}.`,
+        format: "date-time"
+      },
+      { name: "kind", description: "Only blocks of this kind: `task`, `focus` or `life`." }
+    ],
+    listQuerySchema: timeBlockRangeQuerySchema
+  }),
+  record: {
+    method: "get",
+    path: "/time-blocks/{id}/record",
+    scopes: ["calendar:read"],
+    tag: "Calendar",
+    summary: "A life block's record",
+    description: "One of the key's member's life blocks planned against what happened: the block (its frozen plan and its record), the nested Routine's steps as they went (`done` with a time, `skipped`, `open`), the evidence the record rests on (`check_in`, `you`, `agent`, or only the `plan`), a confidence word (`high` \xB7 `medium` \xB7 `low`, never a number), `confirmedAt` when the member said it looks right (an Agent's later change reopens it), `undo` (the cursor `POST /agent/undo` takes back the Agent's latest changes with) and `google` (the event's title on the \"do\" calendar). 400 for a task or focus block.",
+    status: 200,
+    response: { description: "The block's record." },
+    errors: { 400: true, 404: true }
+  },
+  confirm: {
+    method: "post",
+    path: "/time-blocks/{id}/confirm",
+    scopes: ["calendar:write"],
+    tag: "Calendar",
+    summary: "Say a life block's record looks right",
+    description: "Stamps the member's word on a begun life block's record and returns the record. 400 for a block still ahead or a work block.",
+    status: 200,
+    response: { description: "The block's record." },
+    errors: { 400: true, 404: true }
+  },
+  planVsRecord: {
+    method: "get",
+    path: "/time-blocks/plan-vs-record",
+    scopes: ["calendar:read"],
+    tag: "Calendar",
+    summary: "Plan vs what happened",
+    description: 'How the key\'s member\'s life blocks went against their plan over the last `days` (7, 30 or 90; default 30): `week`, last week (Monday to Sunday) as strips (each block\'s planned and recorded minutes into the day, and the day in words, "Held mostly", "Evening went elsewhere"); `hours`, where that week\'s time went per group of kinds, recorded against planned; `moves`, which blocks move over the range\'s weekdays and how, in words ("Lunch \xB7 60\u201375 min \xB7 Runs about twice the 30 planned \xB7 17 of 22"), counting a record once it\'s confirmed or 48 h old, each with `latestId` (its latest block); `evening`, the weekday evenings\' tasks (Tasks planned from 17:00) held, in words with the days work ran past 17:30, and a confidence word, or null; and `suggestion`, one template length to change ("plan it like it is", apply with `PATCH /api/v1/block-templates/{id}` `{ minutes }`) or null. Moving is information, not a miss: no score, no streak.',
+    query: [
+      { name: "days", description: "7, 30 (default) or 90.", type: "integer", enum: [7, 30, 90] }
+    ],
+    querySchema: planVsRecordQuerySchema,
+    status: 200,
+    response: { description: "Plan vs what happened." },
+    errors: { 400: true }
+  }
+});
+
 // ../../packages/schema/src/operations/today.ts
 var todayOperations = defineOperations({
   fromEarlier: {
@@ -31892,7 +33520,7 @@ function parseCapture2(input, now) {
 
 // src/meta.ts
 var CLI_NAME = "do";
-var VERSION = "1.306.0";
+var VERSION = "1.306.1";
 var API_PREFIX = "/api/v1";
 var DEFAULT_API_URL = "http://localhost:3001";
 
@@ -32121,7 +33749,7 @@ function resolveConfig(io, flags) {
 }
 
 // src/contacts-commands.ts
-var WRITE2 = ["contacts:write"];
+var WRITE4 = ["contacts:write"];
 var FIELD_FLAGS = [
   { name: "name", type: "string", description: "The display name (or pass it as the argument)." },
   { name: "kind", type: "string", description: "person (the default) or organization." },
@@ -32164,7 +33792,7 @@ var CONTACT_COMMAND_SPECS = [
     summary: "Add a contact: a person or an organisation, with their details.",
     args: [{ name: "name", required: false, description: "The display name." }],
     flags: FIELD_FLAGS,
-    scopes: WRITE2,
+    scopes: WRITE4,
     returns: "ContactView",
     notes: 'Flags build a CreateContactInput; --data adds any other field (a flag wins). The id is minted when omitted. e.g. `do contacts create "Sam Peters" --email sam@example.com --birthday 1990-04-12 --circles <id>`.'
   },
@@ -32173,14 +33801,14 @@ var CONTACT_COMMAND_SPECS = [
     summary: "Change a contact's details.",
     args: [{ name: "id", required: true, description: "The contact's id." }],
     flags: FIELD_FLAGS,
-    scopes: WRITE2,
+    scopes: WRITE4,
     returns: "ContactView",
     notes: "Only the flags you pass change. `none` clears a field (--email none, --birthday none). --birthday keeps the contact's other dates; --roles, --circles and --tags replace the list (a role it already has keeps its details)."
   }
 ];
 var MERGING_FLAGS = ["birthday", "no-year", "roles"];
 var NULLABLE = ["email", "phone", "company", "website", "notes"];
-function list(value) {
+function list2(value) {
   return value.split(",").map((v) => v.trim()).filter((v) => v.length > 0);
 }
 function isNone(value) {
@@ -32212,14 +33840,14 @@ function contactBodyFromFlags(flags, base, op, current) {
   }
   const tags = flagString(flags, "tags");
   if (tags !== undefined)
-    body.tags = isNone(tags) ? [] : list(tags);
+    body.tags = isNone(tags) ? [] : list2(tags);
   const circles = flagString(flags, "circles");
   if (circles !== undefined)
-    body.circleIds = isNone(circles) ? [] : list(circles);
+    body.circleIds = isNone(circles) ? [] : list2(circles);
   const roles = flagString(flags, "roles");
   if (roles !== undefined) {
     const kept = new Map((current?.roles ?? []).map((r) => [r.role, r]));
-    body.roles = (isNone(roles) ? [] : list(roles)).map((role) => {
+    body.roles = (isNone(roles) ? [] : list2(roles)).map((role) => {
       const had = kept.get(role);
       return had ? {
         id: had.id,
@@ -32396,12 +34024,9 @@ var ENTITIES = [
       canDelete: true
     }
   },
-  {
+  entityFromOperations(areaOperations, {
     name: "areas",
-    path: "/areas",
-    readScopes: ["areas:read"],
     returns: "AreaView",
-    canGet: true,
     listFlags: [
       {
         name: "active",
@@ -32411,15 +34036,9 @@ var ENTITIES = [
       },
       { name: "archived", description: "only archived areas", query: "archived", sends: "true" }
     ],
-    write: {
-      scopes: ["areas:write"],
-      createSchema: createAreaInputSchema,
-      createInput: "CreateAreaInput",
-      updateSchema: updateAreaInputSchema,
-      updateInput: "UpdateAreaInput",
-      canDelete: true
-    }
-  },
+    createInput: "CreateAreaInput",
+    updateInput: "UpdateAreaInput"
+  }),
   {
     name: "places",
     path: "/places",
@@ -32587,22 +34206,13 @@ var ENTITIES = [
     createInput: "CreateHouseholdInput",
     updateInput: "UpdateHouseholdInput"
   }),
-  {
+  entityFromOperations(guestListOperations, {
     name: "guest-lists",
-    path: "/guest-lists",
-    readScopes: ["contacts:read"],
     returns: "GuestListView",
-    canGet: true,
     listFlags: [{ name: "project", description: "only this project's list", query: "projectId" }],
-    write: {
-      scopes: ["contacts:write"],
-      createSchema: createGuestListInputSchema,
-      createInput: "CreateGuestListInput",
-      updateSchema: updateGuestListInputSchema,
-      updateInput: "UpdateGuestListInput",
-      canDelete: true
-    }
-  },
+    createInput: "CreateGuestListInput",
+    updateInput: "UpdateGuestListInput"
+  }),
   entityFromOperations(guestListEventOperations, {
     name: "guest-list-events",
     returns: "GuestListEvent",
@@ -32755,12 +34365,9 @@ var ENTITIES = [
     createInput: "CreateTapTagInput",
     updateInput: "UpdateTapTagInput"
   }),
-  {
+  entityFromOperations(animalOperations, {
     name: "animals",
-    path: "/animals",
-    readScopes: ["animals:read"],
     returns: "AnimalView",
-    canGet: true,
     listFlags: [
       {
         name: "status",
@@ -32776,15 +34383,9 @@ var ENTITIES = [
         boolean: true
       }
     ],
-    write: {
-      scopes: ["animals:write"],
-      createSchema: createAnimalInputSchema,
-      createInput: "CreateAnimalInput",
-      updateSchema: updateAnimalInputSchema,
-      updateInput: "UpdateAnimalInput",
-      canDelete: true
-    }
-  },
+    createInput: "CreateAnimalInput",
+    updateInput: "UpdateAnimalInput"
+  }),
   {
     name: "runs",
     path: "/runs",
@@ -32823,22 +34424,13 @@ var ENTITIES = [
     createInput: "CreateInventoryItemInput",
     updateInput: "UpdateInventoryItemInput"
   }),
-  {
+  entityFromOperations(recipeOperations, {
     name: "recipes",
-    path: "/recipes",
-    readScopes: ["meals:read"],
     returns: "Recipe",
-    canGet: true,
     listFlags: [],
-    write: {
-      scopes: ["meals:write"],
-      createSchema: createRecipeInputSchema,
-      createInput: "CreateRecipeInput",
-      updateSchema: updateRecipeInputSchema,
-      updateInput: "UpdateRecipeInput",
-      canDelete: true
-    }
-  },
+    createInput: "CreateRecipeInput",
+    updateInput: "UpdateRecipeInput"
+  }),
   entityFromOperations(mealPlanOperations, {
     name: "meal-plans",
     returns: "MealPlan",
@@ -32858,12 +34450,9 @@ var ENTITIES = [
       }
     ]
   }),
-  {
+  entityFromOperations(timeBlockOperations, {
     name: "time-blocks",
-    path: "/time-blocks",
-    readScopes: ["calendar:read"],
     returns: "TimeBlockView",
-    canGet: true,
     listFlags: [
       {
         name: "from",
@@ -32872,15 +34461,9 @@ var ENTITIES = [
       { name: "to", description: "window end, exclusive (at most 62 days after --from)" },
       { name: "kind", description: "only blocks of this kind: task, focus or life" }
     ],
-    write: {
-      scopes: ["calendar:write"],
-      createSchema: createTimeBlockInputSchema,
-      createInput: "CreateTimeBlockInput",
-      updateSchema: updateTimeBlockInputSchema,
-      updateInput: "UpdateTimeBlockInput",
-      canDelete: true
-    }
-  },
+    createInput: "CreateTimeBlockInput",
+    updateInput: "UpdateTimeBlockInput"
+  }),
   entityFromOperations(blockTemplateOperations, {
     name: "block-templates",
     returns: "BlockTemplateView",
@@ -32905,8 +34488,8 @@ function entityOperations(e) {
 }
 
 // src/health-commands.ts
-var READ2 = ["health:read"];
-var WRITE3 = ["health:write"];
+var READ4 = ["health:read"];
+var WRITE5 = ["health:write"];
 var DATA_FLAG = {
   name: "data",
   type: "string",
@@ -32920,7 +34503,7 @@ function recordSpecs(plural, singular, noun, returns, createInput, updateInput,
       summary: `List your health ${noun}s.`,
       args: [],
       flags: listFlags,
-      scopes: READ2,
+      scopes: READ4,
       returns
     },
     {
@@ -32928,7 +34511,7 @@ function recordSpecs(plural, singular, noun, returns, createInput, updateInput,
       summary: `Show one health ${noun}.`,
       args: [id],
       flags: [],
-      scopes: READ2,
+      scopes: READ4,
       returns
     },
     {
@@ -32936,7 +34519,7 @@ function recordSpecs(plural, singular, noun, returns, createInput, updateInput,
       summary: `Add a health ${noun} (--data '${createInput}').`,
       args: [],
       flags: [DATA_FLAG, ...addFlags],
-      scopes: WRITE3,
+      scopes: WRITE5,
       returns,
       notes: `Body: ${createInput}. Always private to you; subjectNodeId names who it is about (absent = you).`
     },
@@ -32945,7 +34528,7 @@ function recordSpecs(plural, singular, noun, returns, createInput, updateInput,
       summary: `Change a health ${noun} (--data '${updateInput}').`,
       args: [id],
       flags: [DATA_FLAG],
-      scopes: WRITE3,
+      scopes: WRITE5,
       returns,
       notes: `Body: ${updateInput}. null clears a field.`
     },
@@ -32954,7 +34537,7 @@ function recordSpecs(plural, singular, noun, returns, createInput, updateInput,
       summary: `Delete a health ${noun}.`,
       args: [id],
       flags: [],
-      scopes: WRITE3,
+      scopes: WRITE5,
       returns: "Deleted",
       notes: "Destructive: needs --allow-destructive. An Agent's delete waits on your confirmation."
     }
@@ -32966,7 +34549,7 @@ var HEALTH_COMMAND_SPECS = [
     summary: "Show whether Health is on (only you turn it on or off, in do).",
     args: [],
     flags: [],
-    scopes: READ2,
+    scopes: READ4,
     returns: "HealthConsentState",
     notes: "`granted` is on at today's consent text (`currentVersion`); `renewalNeeded` means you agreed to an older text, so writes wait until you agree again in do. `aiProvider` names who processes what the agent reads (null when this deployment names none)."
   },
@@ -32975,7 +34558,7 @@ var HEALTH_COMMAND_SPECS = [
     summary: "Show your health profile: blood group, allergies, lifestyle, notes, emergency contact, GP.",
     args: [],
     flags: [],
-    scopes: READ2,
+    scopes: READ4,
     returns: "HealthProfile"
   },
   {
@@ -32983,7 +34566,7 @@ var HEALTH_COMMAND_SPECS = [
     summary: "Show your Medical ID: name, blood group, allergies, current medications, height, emergency contact.",
     args: [],
     flags: [],
-    scopes: READ2,
+    scopes: READ4,
     returns: "HealthMedicalId",
     notes: "The few facts someone helping in an emergency needs. The emergency contact comes with their name and phone; a field not set is null. Each read by a key is logged for the member."
   },
@@ -33004,7 +34587,7 @@ var HEALTH_COMMAND_SPECS = [
         description: `Sex, in your words, for the doctor's page ("female"); "" clears it.`
       }
     ],
-    scopes: WRITE3,
+    scopes: WRITE5,
     returns: "HealthProfile",
     notes: "Body: UpdateHealthProfileInput. An absent key keeps a field; null clears it. Lifestyle is `alcohol`, `smoking`, `exercise`, and `notes` anything else: the member's own words. Notes go on For the doctor's background; `sex` on its patient line."
   },
@@ -33013,7 +34596,7 @@ var HEALTH_COMMAND_SPECS = [
     summary: "Log one health message: find or start the Episode, add a symptom and/or a dose.",
     args: [],
     flags: [DATA_FLAG],
-    scopes: WRITE3,
+    scopes: WRITE5,
     returns: "HealthReceipt",
     notes: 'Body: LogHealthInput, e.g. {"episode":{"title":"Sprained ankle","bodyRegion":"ankle_l"},"symptom":{"symptom":"worse on the stairs","severity":6,"severityGuessed":true},"dose":{"medication":"Ibuprofen"}}. The receipt lists each part with a line, what was guessed, and its undo. With "thread":{"slug":"<agent>"} (only an agent key that converses) the receipt card is posted there too, and postId names it.'
   },
@@ -33022,7 +34605,7 @@ var HEALTH_COMMAND_SPECS = [
     summary: `Correct a symptom entry and get a receipt (--data '{"bodyRegion":"ankle_l"}').`,
     args: [{ name: "entry", required: true, description: "The entry's id (its latest version)." }],
     flags: [DATA_FLAG],
-    scopes: WRITE3,
+    scopes: WRITE5,
     returns: "HealthReceipt"
   },
   {
@@ -33033,7 +34616,7 @@ var HEALTH_COMMAND_SPECS = [
       { name: "trend", required: true, description: "better|same|worse, against yesterday." }
     ],
     flags: [],
-    scopes: WRITE3,
+    scopes: WRITE5,
     returns: "HealthReceipt",
     notes: "One a day: a second check-in the same day corrects the first. The receipt carries its undo."
   },
@@ -33050,7 +34633,7 @@ var HEALTH_COMMAND_SPECS = [
         description: "Post the confirmation card in this thread (by slug); the agent's key only."
       }
     ],
-    scopes: WRITE3,
+    scopes: WRITE5,
     returns: "HealthRedFlagsResult",
     notes: "Flags: fever, vomiting, black_stools, blood, weight_loss, night_pain, chest_pain, short_of_breath. Answers merge into those asked before; the Episode is marked checked today, and For the doctor shows it."
   },
@@ -33062,7 +34645,7 @@ var HEALTH_COMMAND_SPECS = [
       { name: "id", required: true, description: "The id from the receipt's undo." }
     ],
     flags: [],
-    scopes: WRITE3,
+    scopes: WRITE5,
     returns: "HealthUndoResult",
     notes: "A POST, so an Agent's undo never waits on a confirmation."
   },
@@ -33071,7 +34654,7 @@ var HEALTH_COMMAND_SPECS = [
     summary: "Find the open Episode a complaint belongs to, or start one (--data UpsertHealthEpisodeInput).",
     args: [],
     flags: [DATA_FLAG],
-    scopes: WRITE3,
+    scopes: WRITE5,
     returns: "HealthEpisodeUpsert"
   },
   {
@@ -33081,7 +34664,7 @@ var HEALTH_COMMAND_SPECS = [
     flags: [
       { name: "episode", type: "string", description: "The Episode; default the latest open one." }
     ],
-    scopes: READ2,
+    scopes: READ4,
     returns: "HealthSummary"
   },
   {
@@ -33104,7 +34687,7 @@ var HEALTH_COMMAND_SPECS = [
     summary: "Your For-the-doctor links: sections, expiry, opens; never the secret.",
     args: [],
     flags: [],
-    scopes: READ2,
+    scopes: READ4,
     returns: "HealthShare[]",
     notes: "Only the member makes a share, in do; a key can list and take one back."
   },
@@ -33113,7 +34696,7 @@ var HEALTH_COMMAND_SPECS = [
     summary: "Take a For-the-doctor link back: it stops opening.",
     args: [{ name: "id", required: true, description: "The share's id." }],
     flags: [],
-    scopes: WRITE3,
+    scopes: WRITE5,
     returns: "HealthShare"
   },
   ...recordSpecs("conditions", "condition", "condition", "HealthConditionView", "CreateHealthConditionInput", "UpdateHealthConditionInput"),
@@ -33131,7 +34714,7 @@ var HEALTH_COMMAND_SPECS = [
         description: 'Their role on it, in your words ("dermatologist").'
       }
     ],
-    scopes: WRITE3,
+    scopes: WRITE5,
     returns: "HealthConditionView",
     notes: "A cared_by link (condition \u2192 contact). Adding one already on it sets the role. The condition's page, the Health home's Care team and For the doctor list them."
   },
@@ -33143,7 +34726,7 @@ var HEALTH_COMMAND_SPECS = [
       { name: "contact", required: true, description: "The Contact's id." }
     ],
     flags: [],
-    scopes: WRITE3,
+    scopes: WRITE5,
     returns: "HealthConditionView",
     notes: "An Agent's removal waits on your confirmation, like a delete."
   },
@@ -33180,7 +34763,7 @@ var HEALTH_COMMAND_SPECS = [
       { name: "at", type: "string", description: "When it happened (ISO); defaults to now." },
       { name: "note", type: "string", description: "A free-text note." }
     ],
-    scopes: WRITE3,
+    scopes: WRITE5,
     returns: "HealthSymptomEntry",
     notes: "An Agent's entry is source chat. For qualifiers, send --data with LogHealthSymptomInput."
   },
@@ -33196,7 +34779,7 @@ var HEALTH_COMMAND_SPECS = [
       }
     ],
     flags: [DATA_FLAG],
-    scopes: WRITE3,
+    scopes: WRITE5,
     returns: "HealthSymptomEntry",
     notes: "Body: CorrectHealthSymptomInput; fields not named are copied. The history stays."
   },
@@ -33208,7 +34791,7 @@ var HEALTH_COMMAND_SPECS = [
       { name: "entry", required: true, description: "The entry's id." }
     ],
     flags: [],
-    scopes: WRITE3,
+    scopes: WRITE5,
     returns: "Deleted"
   },
   ...recordSpecs("visits", "visit", "visit", "HealthEncounterView", "CreateHealthEncounterInput", "UpdateHealthEncounterInput"),
@@ -33218,7 +34801,7 @@ var HEALTH_COMMAND_SPECS = [
     summary: "List the doses of a Medication, latest first.",
     args: [{ name: "med", required: true, description: "The Medication's id." }],
     flags: [],
-    scopes: READ2,
+    scopes: READ4,
     returns: "HealthMedicationDose"
   },
   {
@@ -33232,7 +34815,7 @@ var HEALTH_COMMAND_SPECS = [
       { name: "at", type: "string", description: "When (ISO); defaults to now." },
       { name: "note", type: "string", description: "A free-text note." }
     ],
-    scopes: WRITE3,
+    scopes: WRITE5,
     returns: "HealthMedicationDose"
   },
   {
@@ -33243,7 +34826,7 @@ var HEALTH_COMMAND_SPECS = [
       { name: "dose", required: true, description: "The dose's id." }
     ],
     flags: [DATA_FLAG],
-    scopes: WRITE3,
+    scopes: WRITE5,
     returns: "HealthMedicationDose",
     notes: "Body: UpdateHealthDoseInput."
   },
@@ -33255,7 +34838,7 @@ var HEALTH_COMMAND_SPECS = [
       { name: "dose", required: true, description: "The dose's id." }
     ],
     flags: [],
-    scopes: WRITE3,
+    scopes: WRITE5,
     returns: "Deleted"
   },
   ...recordSpecs("labs", "lab", "lab draw", "HealthLabPanelView", "CreateHealthLabPanelInput", "UpdateHealthLabPanelInput"),
@@ -33277,7 +34860,7 @@ var HEALTH_COMMAND_SPECS = [
         description: "The file's media type, when its name doesn't say."
       }
     ],
-    scopes: WRITE3,
+    scopes: WRITE5,
     returns: "HealthLabImportResult",
     notes: "The draw stays a draft (status draft, source import) until the member checks it; the report is kept as its original. A report with no lab value in it is a 422."
   },
@@ -33286,7 +34869,7 @@ var HEALTH_COMMAND_SPECS = [
     summary: "The canonical analytes: key, printed name, group, unit, LOINC and aliases.",
     args: [],
     flags: [],
-    scopes: READ2,
+    scopes: READ4,
     returns: "LabAnalyteDef[]",
     notes: 'A result is written under the canonical key its analyte or name stands for ("ALAT" \u2192 alt, "25-OH vitamin D" \u2192 vitamin_d); a name that matches none keeps its slug and comes back in the draw\'s `unmatched`.'
   },
@@ -33301,7 +34884,7 @@ var HEALTH_COMMAND_SPECS = [
         description: "Required: only report, change nothing."
       }
     ],
-    scopes: READ2,
+    scopes: READ4,
     returns: "HealthLabNormalizeReport",
     notes: "Nothing is rewritten: trends already read old keys as their canonical one. Lists each result's from \u2192 to, and the keys that match no canonical analyte."
   },
@@ -33310,7 +34893,7 @@ var HEALTH_COMMAND_SPECS = [
     summary: "Every analyte your draws measured, each with its trend, grouped as a lab sheet.",
     args: [],
     flags: [],
-    scopes: READ2,
+    scopes: READ4,
     returns: "HealthLabOverview"
   },
   {
@@ -33336,7 +34919,7 @@ var HEALTH_COMMAND_SPECS = [
     summary: "Whether your Withings scale is connected, the last sync, and what stops it.",
     args: [],
     flags: [],
-    scopes: READ2,
+    scopes: READ4,
     returns: "WithingsStatus",
     notes: "GET /api/v1/health/withings. Connecting needs Withings' consent in a browser: Settings \u2192 Health in do. `failure` (reauth, unavailable, other) says what stops the sync, with a title and a hint."
   },
@@ -33345,7 +34928,7 @@ var HEALTH_COMMAND_SPECS = [
     summary: "Sync your Withings weigh-ins now, as the morning sync does.",
     args: [],
     flags: [],
-    scopes: WRITE3,
+    scopes: WRITE5,
     returns: "WithingsSyncResult",
     notes: "POST /api/v1/health/withings/sync. Written and skipped, and the status after it; a sync that stops answers 200 with `status.failure`. 409 before Withings is connected, 403 while the server has it switched off."
   },
@@ -33354,7 +34937,7 @@ var HEALTH_COMMAND_SPECS = [
     summary: "One analyte's trend across draws (do health analyte vitamin_d).",
     args: [{ name: "analyte", required: true, description: "The analyte key (vitamin_d)." }],
     flags: [],
-    scopes: READ2,
+    scopes: READ4,
     returns: "HealthLabAnalyteView"
   },
   {
@@ -33362,7 +34945,7 @@ var HEALTH_COMMAND_SPECS = [
     summary: `Keep a target band or the supplement for an analyte (--data '{"targetLow":40,"targetHigh":60}').`,
     args: [{ name: "analyte", required: true, description: "The analyte key (vitamin_d)." }],
     flags: [DATA_FLAG],
-    scopes: WRITE3,
+    scopes: WRITE5,
     returns: "HealthLabAnalyteView",
     notes: "Body: SetHealthLabAnalyteInput. An absent key keeps a field; null clears it."
   }
@@ -33680,16 +35263,16 @@ var COMMAND_SPECS = [
     flags: [
       { name: "days", type: "string", description: "The range: 7 (default), 30 or 90 days." }
     ],
-    scopes: ["tasks:read", "habits:read"],
+    scopes: [...progressOperations.get.scopes],
     returns: "ProgressResponse",
-    notes: "GET /api/v1/progress \u2014 days are your saved timezone's. Includes the week/month vs the period before, best day, Areas and each habit's rate."
+    notes: `${routeOf(progressOperations.get)} \u2014 days are your saved timezone's. Includes the week/month vs the period before, best day, Areas and each habit's rate.`
   },
   {
     path: ["progress", "day"],
     summary: "One day of Progress: what was done (and by whom) and what slipped.",
     args: [{ name: "date", required: true, description: "The day, YYYY-MM-DD." }],
     flags: [],
-    scopes: ["tasks:read", "habits:read"],
+    scopes: [...progressOperations.day.scopes],
     returns: "ProgressDayDetail"
   },
   {
@@ -33697,9 +35280,9 @@ var COMMAND_SPECS = [
     summary: "Habits this week: a done/skipped grid, each habit's strength word, patterns and when you check in.",
     args: [],
     flags: [],
-    scopes: ["habits:read"],
+    scopes: [...progressOperations.habits.scopes],
     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."
+    notes: `${routeOf(progressOperations.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: ["journal", "day"],
@@ -33996,18 +35579,18 @@ var COMMAND_SPECS = [
     summary: "Your GitHub commits: the ones you made, and your agents' on your account.",
     args: [],
     flags: [{ name: "days", type: "string", description: "7 (default) or 30." }],
-    scopes: ["habits:read"],
+    scopes: [...progressOperations.commits.scopes],
     returns: "GithubCommits",
-    notes: "GET /api/v1/progress/commits \u2014 your own only. `byYou`, `byAgents` with `agents` by name, `unsorted` (synced before the split) and `perDay`. Only your own commits count toward Insights and a GitHub-sourced habit."
+    notes: `${routeOf(progressOperations.commits)} \u2014 your own only. \`byYou\`, \`byAgents\` with \`agents\` by name, \`unsorted\` (synced before the split) and \`perDay\`. Only your own commits count toward Insights and a GitHub-sourced habit.`
   },
   {
     path: ["progress", "questions"],
     summary: "Insights' answers: late nights vs the next day, the morning routine, good runs, bedtime, best days, reading.",
     args: [],
     flags: [],
-    scopes: ["habits:read"],
+    scopes: [...progressOperations.questions.scopes],
     returns: "InsightsAnswersResponse",
-    notes: "GET /api/v1/progress/questions \u2014 this week's answers (recomputed Monday 04:00 in your zone), your own only. Each is shown, no_difference or collecting (with the days still needed); quote `sentence` and `footer` verbatim. Patterns go together; they never claim a cause."
+    notes: `${routeOf(progressOperations.questions)} \u2014 this week's answers (recomputed Monday 04:00 in your zone), your own only. Each is shown, no_difference or collecting (with the days still needed); quote \`sentence\` and \`footer\` verbatim. Patterns go together; they never claim a cause.`
   },
   {
     path: ["progress", "dismiss"],
@@ -34020,7 +35603,7 @@ var COMMAND_SPECS = [
       }
     ],
     flags: [],
-    scopes: ["habits:write"],
+    scopes: [...progressOperations.dismiss.scopes],
     returns: "InsightsAnswersResponse"
   },
   {
@@ -34028,7 +35611,7 @@ var COMMAND_SPECS = [
     summary: "Bring a set-aside Insights answer back.",
     args: [{ name: "question", required: true, description: "The question's key." }],
     flags: [],
-    scopes: ["habits:write"],
+    scopes: [...progressOperations.restore.scopes],
     returns: "InsightsAnswersResponse"
   },
   {
@@ -34039,9 +35622,9 @@ var COMMAND_SPECS = [
       { name: "at", type: "string", description: "When (ISO); defaults to now." },
       { name: "channel", type: "string", description: "Where, in a word (telegram)." }
     ],
-    scopes: ["habits:write"],
+    scopes: [...progressOperations.activity.scopes],
     returns: "MemberActivity",
-    notes: "POST /api/v1/progress/activity \u2014 the late-night question reads the member's last activity of each evening (00:00\u201304:00 counts for the evening before)."
+    notes: `${routeOf(progressOperations.activity)} \u2014 the late-night question reads the member's last activity of each evening (00:00\u201304:00 counts for the evening before).`
   },
   {
     path: ["search"],
@@ -34143,27 +35726,27 @@ var COMMAND_SPECS = [
     summary: "A life block planned against what happened: its plan and record, the nested routine's steps, what the record rests on and how sure it is (a word).",
     args: [{ name: "id", description: "The time block's id.", required: true }],
     flags: [],
-    scopes: ["calendar:read"],
+    scopes: [...timeBlockOperations.record.scopes],
     returns: "TimeBlockRecord",
-    notes: "GET /api/v1/time-blocks/{id}/record (plan vs record). Only a life block has a record."
+    notes: `${routeOf(timeBlockOperations.record)} (plan vs record). Only a life block has a record.`
   },
   {
     path: ["time-blocks", "confirm"],
     summary: "Say a begun life block's record looks right.",
     args: [{ name: "id", description: "The time block's id.", required: true }],
     flags: [],
-    scopes: ["calendar:write"],
+    scopes: [...timeBlockOperations.confirm.scopes],
     returns: "TimeBlockRecord",
-    notes: "POST /api/v1/time-blocks/{id}/confirm (plan vs record). An Agent's later change reopens it."
+    notes: `${routeOf(timeBlockOperations.confirm)} (plan vs record). An Agent's later change reopens it.`
   },
   {
     path: ["time-blocks", "plan-vs-record"],
     summary: "How the life blocks went against their plan: last week day by day, where the time went, which blocks move (in words), and one template change worth making.",
     args: [],
     flags: [{ name: "days", type: "string", description: "7, 30 (default) or 90." }],
-    scopes: ["calendar:read"],
+    scopes: [...timeBlockOperations.planVsRecord.scopes],
     returns: "PlanVsRecord",
-    notes: "GET /api/v1/time-blocks/plan-vs-record?days= (plan vs record). No score, no streak."
+    notes: `${routeOf(timeBlockOperations.planVsRecord)}?days= (plan vs record). No score, no streak.`
   },
   {
     path: ["days", "record"],
@@ -34172,9 +35755,9 @@ var COMMAND_SPECS = [
       { name: "date", required: true, description: "The day (YYYY-MM-DD), in the member's zone." }
     ],
     flags: [],
-    scopes: ["calendar:read"],
+    scopes: [...dayOperations.record.scopes],
     returns: "DayRecord",
-    notes: "GET /api/v1/days/{date}/record (plan vs record, phase 2). A day nobody closes closes itself 48 h after it ends."
+    notes: `${routeOf(dayOperations.record)} (plan vs record, phase 2). A day nobody closes closes itself 48 h after it ends.`
   },
   {
     path: ["days", "write"],
@@ -34187,9 +35770,9 @@ var COMMAND_SPECS = [
         description: 'The DayRecordWriteInput as JSON: {"changes":[{"blockId":"\u2026","endAt":"2026-10-19T11:45:00Z","evidence":[{"source":"habit","refKind":"habit_entry","refId":"\u2026","note":"Kitchen cleanup check-in"}]},{"id":"<new ULID>","lifeKind":"together","title":"TV together","startAt":"\u2026","endAt":"\u2026","evidence":[{"source":"chat","refKind":"agent_post","refId":"\u2026"}]},{"blockId":"\u2026","replacedBy":"<the new ULID>"},{"blockId":"\u2026","skipped":true}]}. Times round to the quarter hour. Required.'
       }
     ],
-    scopes: ["calendar:write"],
+    scopes: [...dayOperations.write.scopes],
     returns: "DayRecordReceipt",
-    notes: "POST /api/v1/days/{date}/record (plan vs record, phase 2). Never waits for a confirmation; 409 for an Agent on a closed day. Undo with `do days undo <date> <receipt>`."
+    notes: `${routeOf(dayOperations.write)} (plan vs record, phase 2). Never waits for a confirmation; 409 for an Agent on a closed day. Undo with \`do days undo <date> <receipt>\`.`
   },
   {
     path: ["days", "ask"],
@@ -34202,9 +35785,9 @@ var COMMAND_SPECS = [
         description: 'The DayRecordAskInput as JSON: {"blockId":"\u2026","question":"Did lunch run long?"} or, for a gap, {"id":"<new ULID>","startAt":"\u2026","endAt":"\u2026","question":"What filled 15:00\u201316:00?"}. Required.'
       }
     ],
-    scopes: ["calendar:write"],
+    scopes: [...dayOperations.ask.scopes],
     returns: "DayRecord",
-    notes: "POST /api/v1/days/{date}/record/ask (plan vs record, phase 2). 409 past two a day."
+    notes: `${routeOf(dayOperations.ask)} (plan vs record, phase 2). 409 past two a day.`
   },
   {
     path: ["days", "undo"],
@@ -34214,18 +35797,18 @@ var COMMAND_SPECS = [
       { name: "receipt", required: true, description: "The receipt a write returned." }
     ],
     flags: [],
-    scopes: ["calendar:write"],
+    scopes: [...dayOperations.undo.scopes],
     returns: "DayRecordUndoResult",
-    notes: "POST /api/v1/days/{date}/record/undo (plan vs record, phase 2)."
+    notes: `${routeOf(dayOperations.undo)} (plan vs record, phase 2).`
   },
   {
     path: ["days", "close"],
     summary: "Close a day (day_close): the member said the record is fine.",
     args: [{ name: "date", required: true, description: "The day (YYYY-MM-DD)." }],
     flags: [],
-    scopes: ["calendar:write"],
+    scopes: [...dayOperations.close.scopes],
     returns: "DayRecord",
-    notes: "POST /api/v1/days/{date}/close (plan vs record, phase 2). After this only the member changes the day."
+    notes: `${routeOf(dayOperations.close)} (plan vs record, phase 2). After this only the member changes the day.`
   },
   {
     path: ["calendar", "events"],
@@ -34235,9 +35818,9 @@ var COMMAND_SPECS = [
       { name: "from", type: "string", description: "Window start (ISO instant); with --to." },
       { name: "to", type: "string", description: "Window end (ISO instant), at most 62 days on." }
     ],
-    scopes: ["calendar:read"],
+    scopes: [...calendarOperations.events.scopes],
     returns: "Event[]",
-    notes: "GET /api/v1/calendar/events (week-plan feedback). Neither flag = the next day. Needs a key that acts for a member."
+    notes: `${routeOf(calendarOperations.events)} (week-plan feedback). Neither flag = the next day. Needs a key that acts for a member.`
   },
   {
     path: ["calendar", "plan"],
@@ -34256,9 +35839,9 @@ var COMMAND_SPECS = [
         description: "The member's answer: yes, no, or waiting (asks again)."
       }
     ],
-    scopes: ["calendar:write"],
+    scopes: [...calendarOperations.plan.scopes],
     returns: "Event",
-    notes: "PATCH /api/v1/calendar/events/{id}/plan. Until it's yes, an optional event holds no time; plan nothing around it."
+    notes: `${routeOf(calendarOperations.plan)}. Until it's yes, an optional event holds no time; plan nothing around it.`
   },
   {
     path: ["plans", "list"],
@@ -34711,7 +36294,7 @@ var COMMAND_SPECS = [
     summary: "Show weight, sleep, mood, the day rating, energy, bedtime, resting heart rate and HRV as daily trend lines (no target, no streak). Resting heart rate and HRV need health:read too.",
     args: [],
     flags: [{ name: "days", type: "string", description: "How far back, 1\u2013730 (default 90)." }],
-    scopes: ["habits:read"],
+    scopes: [...metricOperations.list.scopes],
     returns: "Metric"
   },
   {
@@ -34719,7 +36302,7 @@ var COMMAND_SPECS = [
     summary: "Show workout sessions your connections brought in (Google Fit, Google Health, Strava), newest first.",
     args: [],
     flags: [{ name: "days", type: "string", description: "How far back, 1\u2013365 (default 14)." }],
-    scopes: ["habits:read"],
+    scopes: [...metricOperations.sessions.scopes],
     returns: "Session"
   },
   {
@@ -34745,7 +36328,7 @@ var COMMAND_SPECS = [
         description: "manual (default), device \u2014 a wearable or wake hook reported it \u2014 or agent \u2014 the member told the agent (the default from an Agent's key)."
       }
     ],
-    scopes: ["habits:write"],
+    scopes: [...metricOperations.log.scopes],
     returns: "Metric",
     notes: "Logging again the same day replaces that day's point. A bedtime belongs to the night's wake day (logged at 23:30 or the next morning, it lands on the morning). The key must act for a member."
   },
@@ -34760,9 +36343,9 @@ var COMMAND_SPECS = [
         description: 'The batch as JSON: {"points":[{"key":"sleep","value":7.5,"occurredAt":"2026-10-20T07:00:00Z","recordId":"\u2026"}]} (source defaults to health_connect).'
       }
     ],
-    scopes: ["habits:write"],
+    scopes: [...metricOperations.import.scopes],
     returns: "ImportMetricsResult",
-    notes: "POST /api/v1/metrics/import. Each record lands once (its recordId); one already imported, out of range or in the future is skipped. At most 500 points."
+    notes: `${routeOf(metricOperations.import)}. Each record lands once (its recordId); one already imported, out of range or in the future is skipped. At most 500 points.`
   },
   {
     path: ["documents", "file"],
@@ -35254,25 +36837,25 @@ var COMMAND_SPECS = [
         description: "Also ask Open Food Facts when there are too few local hits."
       }
     ],
-    scopes: ["meals:read"],
+    scopes: [...foodOperations.search.scopes],
     returns: "FoodSearchResult",
-    notes: "GET /api/v1/foods/search. Values per 100 g; `licence` is the attribution to show. `remote` says whether OFF was used, skipped, rate_limited or unavailable."
+    notes: `${routeOf(foodOperations.search)}. Values per 100 g; \`licence\` is the attribution to show. \`remote\` says whether OFF was used, skipped, rate_limited or unavailable.`
   },
   {
     path: ["foods", "barcode"],
     summary: "Look up a branded product by barcode (cached Open Food Facts).",
     args: [{ name: "ean", required: true, description: "The EAN/UPC barcode, 8\u201314 digits." }],
     flags: [],
-    scopes: ["meals:read"],
+    scopes: [...foodOperations.barcode.scopes],
     returns: "FoodBarcodeResult",
-    notes: "GET /api/v1/foods/barcode/{ean}. An unknown barcode is found: false, not an error."
+    notes: `${routeOf(foodOperations.barcode)}. An unknown barcode is found: false, not an error.`
   },
   {
     path: ["foods", "get"],
     summary: "Show one food from the nutrition reference.",
     args: [{ name: "id", required: true, description: "Food ULID." }],
     flags: [],
-    scopes: ["meals:read"],
+    scopes: [...foodOperations.get.scopes],
     returns: "Food"
   },
   {
@@ -35286,9 +36869,9 @@ var COMMAND_SPECS = [
         description: 'The CreateMealLogInput as JSON (id optional): {"title":"Boterhammen met kaas","eatenAt":"2026-10-16T12:30:00+02:00","mealType":"lunch","items":[{"label":"boterham","foodId":"\u2026","quantity":2,"unit":"boterham"},{"label":"saus","grams":20,"estimate":{"kcal":90}}]}. Find foodIds with `do foods search`.'
       }
     ],
-    scopes: ["health:write"],
+    scopes: [...foodLogOperations.create.scopes],
     returns: "MealLogReceipt",
-    notes: "POST /api/v1/food/logs (the agent's food_log). Numbers are computed from the reference \xD7 grams; only an `estimate` brings its own. The receipt: headline with the kcal range, a confidence word, a line per item with its source, and the Undo / Edit / Save calls."
+    notes: `${routeOf(foodLogOperations.create)} (the agent's food_log). Numbers are computed from the reference \xD7 grams; only an \`estimate\` brings its own. The receipt: headline with the kcal range, a confidence word, a line per item with its source, and the Undo / Edit / Save calls.`
   },
   {
     path: ["food", "list"],
@@ -35302,16 +36885,16 @@ var COMMAND_SPECS = [
         description: "End (exclusive), an ISO instant; at most 92 days after --from."
       }
     ],
-    scopes: ["health:read"],
+    scopes: [...foodLogOperations.list.scopes],
     returns: "MealLogView",
-    notes: "GET /api/v1/food/logs."
+    notes: `${routeOf(foodLogOperations.list)}.`
   },
   {
     path: ["food", "get"],
     summary: "Show one meal: its items, the corrected ones and its sources' attribution.",
     args: [{ name: "id", required: true, description: "Meal ULID." }],
     flags: [],
-    scopes: ["health:read"],
+    scopes: [...foodLogOperations.get.scopes],
     returns: "MealLogView"
   },
   {
@@ -35319,9 +36902,9 @@ var COMMAND_SPECS = [
     summary: "Show a meal in its day: the weekmenu plan for its slot, the timing against the plan and bed, and what came after.",
     args: [{ name: "id", required: true, description: "Meal ULID." }],
     flags: [],
-    scopes: ["health:read"],
+    scopes: [...foodLogOperations.context.scopes],
     returns: "MealContext",
-    notes: "GET /api/v1/food/logs/{id}/context. Read-side: Health symptom entries and doses in the 12 h after, an Episode that began then, the night's sleep and the day rating. Nothing in it says the meal caused what followed."
+    notes: `${routeOf(foodLogOperations.context)}. Read-side: Health symptom entries and doses in the 12 h after, an Episode that began then, the night's sleep and the day rating. Nothing in it says the meal caused what followed.`
   },
   {
     path: ["food", "week"],
@@ -35334,36 +36917,36 @@ var COMMAND_SPECS = [
         description: "Any day of the week (YYYY-MM-DD); this week by default."
       }
     ],
-    scopes: ["health:read"],
+    scopes: [...foodLogOperations.week.scopes],
     returns: "FoodWeek",
-    notes: "GET /api/v1/food/week. Read-side: no target, ever; a missing day is missing, not zero. Nothing in it says a meal caused what followed."
+    notes: `${routeOf(foodLogOperations.week)}. Read-side: no target, ever; a missing day is missing, not zero. Nothing in it says a meal caused what followed.`
   },
   {
     path: ["food", "week-read"],
     summary: "Write or replace the read of a food week: a few calm lines about it, shown on the week as the agent's read.",
     args: [{ name: "start", required: true, description: "Any day of the week (YYYY-MM-DD)." }],
     flags: [{ name: "body", type: "string", description: "The read, at most 2,000 characters." }],
-    scopes: ["health:write"],
+    scopes: [...foodLogOperations.writeWeekRead.scopes],
     returns: "FoodWeek",
-    notes: "PUT /api/v1/food/week/read (food_week_read). Private to the member; a week that hasn't started can't have one. Say what went together, never a cause or a score."
+    notes: `${routeOf(foodLogOperations.writeWeekRead)} (food_week_read). Private to the member; a week that hasn't started can't have one. Say what went together, never a cause or a score.`
   },
   {
     path: ["food", "week-read-remove"],
     summary: "Take back the read of a food week.",
     args: [{ name: "start", required: true, description: "Any day of the week (YYYY-MM-DD)." }],
     flags: [],
-    scopes: ["health:write"],
+    scopes: [...foodLogOperations.removeWeekRead.scopes],
     returns: "None",
-    notes: "DELETE /api/v1/food/week/read?start= (food_week_read_remove). From an agent's key it waits on the member's confirmation, like every agent DELETE."
+    notes: `${routeOf(foodLogOperations.removeWeekRead)}?start= (food_week_read_remove). From an agent's key it waits on the member's confirmation, like every agent DELETE.`
   },
   {
     path: ["food", "patterns"],
     summary: "Show food and how you feel: the fixed food questions (big lunches and tiredness, late dinners, very hot or fried meals, intake and the day rating, the weekly average and weight).",
     args: [],
     flags: [],
-    scopes: ["health:read"],
+    scopes: [...foodLogOperations.patterns.scopes],
     returns: "FoodPatterns",
-    notes: "GET /api/v1/food/patterns. Over the 90 days up to this week's Monday, on the Insights rules: collecting until 21 paired days and 7 on each side; 'goes together', never a cause."
+    notes: `${routeOf(foodLogOperations.patterns)}. Over the 90 days up to this week's Monday, on the Insights rules: collecting until 21 paired days and 7 on each side; 'goes together', never a cause.`
   },
   {
     path: ["food", "trial"],
@@ -35389,18 +36972,18 @@ var COMMAND_SPECS = [
       },
       { name: "days", type: "string", description: "How many days it runs (7\u201328; default 14)." }
     ],
-    scopes: ["health:write"],
+    scopes: [...foodLogOperations.proposeTrial.scopes],
     returns: "FoodTrial",
-    notes: "POST /api/v1/food/trials (food_trial). Waits on Food and how you feel until the member starts it, says Not now (a week) or stops it; a newer proposal sets an older waiting one aside. Private to the member. n-of-1 information, never a diagnosis."
+    notes: `${routeOf(foodLogOperations.proposeTrial)} (food_trial). Waits on Food and how you feel until the member starts it, says Not now (a week) or stops it; a newer proposal sets an older waiting one aside. Private to the member. n-of-1 information, never a diagnosis.`
   },
   {
     path: ["food", "trial-stop"],
     summary: "Stop a food trial, running or still proposed.",
     args: [{ name: "id", required: true, description: "The trial's ULID." }],
     flags: [],
-    scopes: ["health:write"],
+    scopes: [...foodLogOperations.stopTrial.scopes],
     returns: "None",
-    notes: "POST /api/v1/food/trials/{id}/stop (food_trial_stop)."
+    notes: `${routeOf(foodLogOperations.stopTrial)} (food_trial_stop).`
   },
   {
     path: ["food", "correct"],
@@ -35413,16 +36996,16 @@ var COMMAND_SPECS = [
         description: 'The CorrectMealLogInput as JSON: {"replace":[{"itemId":"\u2026","item":{"label":"martino","foodId":"\u2026","grams":20}}],"remove":["\u2026"],"add":[\u2026],"flags":["spice:very_hot"]}.'
       }
     ],
-    scopes: ["health:write"],
+    scopes: [...foodLogOperations.correct.scopes],
     returns: "MealLogReceipt",
-    notes: "PATCH /api/v1/food/logs/{id} (the agent's food_correct)."
+    notes: `${routeOf(foodLogOperations.correct)} (the agent's food_correct).`
   },
   {
     path: ["food", "undo-correction"],
     summary: "Take back a meal's latest correction.",
     args: [{ name: "id", required: true, description: "Meal ULID." }],
     flags: [],
-    scopes: ["health:write"],
+    scopes: [...foodLogOperations.undoCorrection.scopes],
     returns: "MealLogReceipt"
   },
   {
@@ -35432,7 +37015,7 @@ var COMMAND_SPECS = [
     flags: [
       { name: "allow-destructive", type: "boolean", description: "Required to actually remove." }
     ],
-    scopes: ["health:write"],
+    scopes: [...foodLogOperations.remove.scopes],
     returns: "None",
     notes: "Gated behind --allow-destructive. The meal goes to Trash."
   },
@@ -35447,9 +37030,9 @@ var COMMAND_SPECS = [
         description: "The saved meal's name; defaults to the meal's."
       }
     ],
-    scopes: ["health:write"],
+    scopes: [...foodLogOperations.saveMeal.scopes],
     returns: "SaveMealResult",
-    notes: "POST /api/v1/food/logs/{id}/save-meal (the agent's food_save_meal). Log it again with recipeId + servings: 1."
+    notes: `${routeOf(foodLogOperations.saveMeal)} (the agent's food_save_meal). Log it again with recipeId + servings: 1.`
   },
   {
     path: ["food", "days"],
@@ -35459,7 +37042,7 @@ var COMMAND_SPECS = [
       { name: "from", type: "string", description: "First day, YYYY-MM-DD." },
       { name: "to", type: "string", description: "Last day, YYYY-MM-DD." }
     ],
-    scopes: ["health:read"],
+    scopes: [...foodLogOperations.days.scopes],
     returns: "FoodDay",
     notes: "A day with nothing logged has no row: missing, not zero."
   },
@@ -35470,7 +37053,7 @@ var COMMAND_SPECS = [
       { name: "date", required: true, description: "YYYY-MM-DD, the member's day (from 04:00)." }
     ],
     flags: [],
-    scopes: ["health:read"],
+    scopes: [...foodLogOperations.day.scopes],
     returns: "FoodDayView"
   },
   {
@@ -35478,27 +37061,27 @@ var COMMAND_SPECS = [
     summary: "What the member eats often: frequent meals of the last 30 days and saved meals.",
     args: [],
     flags: [],
-    scopes: ["health:read"],
+    scopes: [...foodLogOperations.recall.scopes],
     returns: "FoodRecall",
-    notes: `GET /api/v1/food/recall (the agent's food_recall). Use it to resolve "the usual".`
+    notes: `${routeOf(foodLogOperations.recall)} (the agent's food_recall). Use it to resolve "the usual".`
   },
   {
     path: ["recipes", "nutrition"],
     summary: "Recompute a recipe's nutrition from its ingredients.",
     args: [{ name: "id", required: true, description: "Recipe ULID." }],
     flags: [],
-    scopes: ["meals:write"],
+    scopes: [...recipeOperations.nutrition.scopes],
     returns: "RecipeNutrition",
-    notes: "POST /api/v1/recipes/{id}/nutrition. Per pot, per serving, coverage and the lines with no match."
+    notes: `${routeOf(recipeOperations.nutrition)}. Per pot, per serving, coverage and the lines with no match.`
   },
   {
     path: ["recipes", "used-in"],
     summary: "Where a recipe was used: the meals it was eaten in and the weekmenu days it's planned for.",
     args: [{ name: "id", required: true, description: "Recipe ULID." }],
     flags: [],
-    scopes: ["meals:read"],
+    scopes: [...recipeOperations.usedIn.scopes],
     returns: "RecipeUsedIn",
-    notes: "GET /api/v1/recipes/{id}/used-in. At most five of each; meals need health:read too (without it, plans only)."
+    notes: `${routeOf(recipeOperations.usedIn)}. At most five of each; meals need health:read too (without it, plans only).`
   },
   {
     path: ["recipes", "match"],
@@ -35509,9 +37092,9 @@ var COMMAND_SPECS = [
       { name: "food", required: true, description: "A food id from `do foods search`." }
     ],
     flags: [],
-    scopes: ["meals:write"],
+    scopes: [...recipeOperations.match.scopes],
     returns: "RecipeDetail",
-    notes: "PUT /api/v1/recipes/{id}/ingredients/{ingredientId}/match. The ingredient's product becomes that food and the nutrition is worked out again."
+    notes: `${routeOf(recipeOperations.match)}. The ingredient's product becomes that food and the nutrition is worked out again.`
   },
   {
     path: ["agents", "list"],
@@ -35885,7 +37468,7 @@ var COMMAND_SPECS = [
         description: "Filter to one gallery facet (habit|list|routine|area|project|recipe|contact|challenge|automation)."
       }
     ],
-    scopes: ["presets:read"],
+    scopes: [...presetOperations.list.scopes],
     returns: "Preset",
     notes: "The catalog is code-defined; --entity filters it client-side."
   },
@@ -35900,7 +37483,7 @@ var COMMAND_SPECS = [
         description: "The day the preset's key dates count from (YYYY-MM-DD), for a preset that names one (the Wedding: the wedding day)."
       }
     ],
-    scopes: ["presets:install"],
+    scopes: [...presetOperations.install.scopes],
     returns: "PresetInstallResult",
     notes: "Authors content as the caller, so it needs a key minted while logged in. A preset with a day (`anchor` in `presets list`) needs --on, else the API answers 422."
   },
@@ -36112,16 +37695,16 @@ var COMMAND_SPECS = [
       { name: "line", required: false, description: "The purpose, in one line (words join)." }
     ],
     flags: [{ name: "clear", type: "boolean", description: "Remove the purpose." }],
-    scopes: ["areas:write"],
+    scopes: [...areaOperations.update.scopes],
     returns: "AreaView",
-    notes: "PATCH /api/v1/areas/:id { purpose }. It shows under the Area's name on the hub."
+    notes: `${routeOf(areaOperations.update)} { 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"],
+    scopes: [...areaOperations.get.scopes],
     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)."
   },
@@ -36133,9 +37716,9 @@ var COMMAND_SPECS = [
       { name: "text", required: true, description: "The standard, a plain sentence (words join)." }
     ],
     flags: STANDARD_LINK_FLAGS,
-    scopes: ["areas:write"],
+    scopes: [...areaOperations.addStandard.scopes],
     returns: "AreaDetail",
-    notes: "POST /api/v1/areas/:id/standards. The agent adds standards only after the member said yes; the change list keeps Undo."
+    notes: `${routeOf(areaOperations.addStandard)}. The agent adds standards only after the member said yes; the change list keeps Undo.`
   },
   {
     path: ["areas", "standards", "link"],
@@ -36148,9 +37731,9 @@ var COMMAND_SPECS = [
       ...STANDARD_LINK_FLAGS,
       { name: "none", type: "boolean", description: "Unlink it: checked by hand in review." }
     ],
-    scopes: ["areas:write"],
+    scopes: [...areaOperations.updateStandard.scopes],
     returns: "AreaDetail",
-    notes: "PATCH /api/v1/areas/:id/standards/:standardId { link }."
+    notes: `${routeOf(areaOperations.updateStandard)} { link }.`
   },
   {
     path: ["areas", "standards", "rm"],
@@ -36160,9 +37743,9 @@ var COMMAND_SPECS = [
       { name: "standard", required: true, description: "The standard's id." }
     ],
     flags: [],
-    scopes: ["areas:write"],
+    scopes: [...areaOperations.removeStandard.scopes],
     returns: "AreaDetail",
-    notes: "DELETE /api/v1/areas/:id/standards/:standardId."
+    notes: `${routeOf(areaOperations.removeStandard)}.`
   },
   {
     path: ["areas", "overview"],
@@ -36175,9 +37758,9 @@ var COMMAND_SPECS = [
         description: "Whose work counts: mine (default; agents' work doesn't), agents or all."
       }
     ],
-    scopes: ["areas:read"],
+    scopes: [...areaOperations.overview.scopes],
     returns: "AreaOverview",
-    notes: 'GET /api/v1/areas/overview. Words, never a score: "Busier than usual", "Steady", "Quiet for three weeks", "Resting", each with a short reason. The only count is what waits on you. Resting Areas come last.'
+    notes: `${routeOf(areaOperations.overview)}. Words, never a score: "Busier than usual", "Steady", "Quiet for three weeks", "Resting", each with a short reason. The only count is what waits on you. Resting Areas come last.`
   },
   {
     path: ["areas", "rest"],
@@ -36195,36 +37778,36 @@ var COMMAND_SPECS = [
         description: "Pause the Area's habits until then too (they keep going otherwise)."
       }
     ],
-    scopes: ["areas:write"],
+    scopes: [...areaOperations.rest.scopes],
     returns: "AreaView",
-    notes: "POST /api/v1/areas/{id}/rest { until, habits } (Areas 8). Between active and archived: its attention reads Resting, Focus, Review and filing leave it alone, and its recurring tasks pause. Bring it back early with `do areas back`."
+    notes: `${routeOf(areaOperations.rest)} { until, habits } (Areas 8). Between active and archived: its attention reads Resting, Focus, Review and filing leave it alone, and its recurring tasks pause. Bring it back early with \`do areas back\`.`
   },
   {
     path: ["areas", "back"],
     summary: "Bring a resting Area back today.",
     args: [{ name: "id", required: true, description: "Area ULID." }],
     flags: [],
-    scopes: ["areas:write"],
+    scopes: [...areaOperations.back.scopes],
     returns: "AreaView",
-    notes: "POST /api/v1/areas/{id}/back (Areas 8). The habits it paused come back too, and the recurring tasks' occurrences that went by while it rested are skipped. Nothing was lost."
+    notes: `${routeOf(areaOperations.back)} (Areas 8). The habits it paused come back too, and the recurring tasks' occurrences that went by while it rested are skipped. Nothing was lost.`
   },
   {
     path: ["areas", "since"],
     summary: "What happened in an Area since you last looked: landed, new, and what seems stuck.",
     args: [{ name: "id", required: true, description: "Area ULID." }],
     flags: [],
-    scopes: ["areas:read"],
+    scopes: [...areaOperations.sinceLastLook.scopes],
     returns: "AreaSinceLastLook",
-    notes: 'GET /api/v1/areas/{id}/since-last-look (Areas 6). A few of each, named, never tallied; stuck ones say why in words ("Deadline was 12 October").'
+    notes: `${routeOf(areaOperations.sinceLastLook)} (Areas 6). A few of each, named, never tallied; stuck ones say why in words ("Deadline was 12 October").`
   },
   {
     path: ["areas", "looked-at"],
     summary: "Record a look at an Area: its review rhythm starts again from now.",
     args: [{ name: "id", required: true, description: "Area ULID." }],
     flags: [],
-    scopes: ["areas:write"],
+    scopes: [...areaOperations.lookedAt.scopes],
     returns: "AreaView",
-    notes: "POST /api/v1/areas/{id}/looked-at (Areas 6). The Area leaves Review until its rhythm (weekly, monthly, quarterly) comes round."
+    notes: `${routeOf(areaOperations.lookedAt)} (Areas 6). The Area leaves Review until its rhythm (weekly, monthly, quarterly) comes round.`
   },
   {
     path: ["areas", "focus"],
@@ -36264,9 +37847,9 @@ var COMMAND_SPECS = [
         description: "The Area to file the new Project under (none when left out)."
       }
     ],
-    scopes: ["areas:write", "projects:write"],
+    scopes: [...areaOperations.toProject.scopes],
     returns: "AreaToProjectResult",
-    notes: "POST /api/v1/areas/{id}/to-project (Areas 8). The Project takes the Area's title; its loose tasks go inside, its Projects, habits, routines and notes move beside it, and the Area is archived. An agent proposes this; only the member runs it."
+    notes: `${routeOf(areaOperations.toProject)} (Areas 8). The Project takes the Area's title; its loose tasks go inside, its Projects, habits, routines and notes move beside it, and the Area is archived. An agent proposes this; only the member runs it.`
   },
   {
     path: ["areas", "undo-make-project"],
@@ -36279,27 +37862,27 @@ var COMMAND_SPECS = [
         description: "The receipt as JSON: { projectId, moved } from `areas make-project`."
       }
     ],
-    scopes: ["areas:write", "projects:write"],
+    scopes: [...areaOperations.undoToProject.scopes],
     returns: "AreaView",
-    notes: "POST /api/v1/areas/{id}/to-project/undo (Areas 8). Everything comes back; the Project goes."
+    notes: `${routeOf(areaOperations.undoToProject)} (Areas 8). Everything comes back; the Project goes.`
   },
   {
     path: ["house"],
     summary: "The House home: what's broken, upkeep coming up, and the Places.",
     args: [],
     flags: [],
-    scopes: ["collections:read"],
+    scopes: [...houseOperations.overview.scopes],
     returns: "HouseOverview",
-    notes: "GET /api/v1/house."
+    notes: `${routeOf(houseOperations.overview)}.`
   },
   {
     path: ["house", "asset"],
     summary: "One asset's House page: its Place trail, the parts that fit it, what it's linked to.",
     args: [{ name: "id", required: true, description: "Asset ULID." }],
     flags: [],
-    scopes: ["collections:read"],
+    scopes: [...houseOperations.asset.scopes],
     returns: "HouseAsset",
-    notes: "GET /api/v1/house/assets/{id}. Upkeep and repairs: `do collection upkeep <id>`."
+    notes: `${routeOf(houseOperations.asset)}. Upkeep and repairs: \`do collection upkeep <id>\`.`
   },
   {
     path: ["house", "part"],
@@ -36309,9 +37892,9 @@ var COMMAND_SPECS = [
       { name: "supply", required: true, description: "Supply (inventory item) ULID." }
     ],
     flags: [],
-    scopes: ["collections:write"],
+    scopes: [...houseOperations.linkPart.scopes],
     returns: "HouseAsset",
-    notes: "POST /api/v1/house/assets/{id}/parts. Idempotent."
+    notes: `${routeOf(houseOperations.linkPart)}. Idempotent.`
   },
   {
     path: ["house", "unpart"],
@@ -36321,9 +37904,9 @@ var COMMAND_SPECS = [
       { name: "supply", required: true, description: "Supply (inventory item) ULID." }
     ],
     flags: [],
-    scopes: ["collections:write"],
+    scopes: [...houseOperations.unlinkPart.scopes],
     returns: "HouseAsset",
-    notes: "DELETE /api/v1/house/assets/{id}/parts/{inventoryItemId}."
+    notes: `${routeOf(houseOperations.unlinkPart)}.`
   },
   {
     path: ["house", "lend"],
@@ -36338,9 +37921,9 @@ var COMMAND_SPECS = [
       { name: "due", type: "string", description: "Due back, YYYY-MM-DD." },
       { name: "note", type: "string", description: "A note, e.g. return with a full tank." }
     ],
-    scopes: ["collections:write"],
+    scopes: [...houseOperations.lend.scopes],
     returns: "CollectionItemDetail",
-    notes: "POST /api/v1/house/assets/{id}/lend. Logs a lent Entry; 409 while it's already out."
+    notes: `${routeOf(houseOperations.lend)}. Logs a lent Entry; 409 while it's already out.`
   },
   {
     path: ["house", "return"],
@@ -36350,18 +37933,18 @@ var COMMAND_SPECS = [
       { name: "on", type: "string", description: "YYYY-MM-DD (default today)." },
       { name: "note", type: "string", description: "A note." }
     ],
-    scopes: ["collections:write"],
+    scopes: [...houseOperations.giveBack.scopes],
     returns: "CollectionItemDetail",
-    notes: "POST /api/v1/house/assets/{id}/return. 409 when it isn't out."
+    notes: `${routeOf(houseOperations.giveBack)}. 409 when it isn't out.`
   },
   {
     path: ["house", "value"],
     summary: "What's in the house: each thing's value and proof, the sums, the home policy.",
     args: [],
     flags: [],
-    scopes: ["collections:read"],
+    scopes: [...houseOperations.value.scopes],
     returns: "HouseValue",
-    notes: "GET /api/v1/house/value. Things marked insure: false are listed but left out of the sums."
+    notes: `${routeOf(houseOperations.value)}. Things marked insure: false are listed but left out of the sums.`
   },
   {
     path: ["house", "year"],
@@ -36370,9 +37953,9 @@ var COMMAND_SPECS = [
     flags: [
       { name: "year", type: "string", description: "The year, e.g. 2026 (default this one)." }
     ],
-    scopes: ["collections:read"],
+    scopes: [...houseOperations.year.scopes],
     returns: "HouseUpkeepYear",
-    notes: "GET /api/v1/house/upkeep. Each routine has twelve marks (done/due/planned/late/null), January first."
+    notes: `${routeOf(houseOperations.year)}. Each routine has twelve marks (done/due/planned/late/null), January first.`
   },
   {
     path: ["house", "file"],
@@ -36386,9 +37969,9 @@ var COMMAND_SPECS = [
         description: 'JSON FileAssetInput, e.g. {"facet":{"brand":"Acme","model":"D-100"},"fileIds":[\u2026],"upkeep":{"title":"Clean the filter","schedule":{"every":4,"unit":"week"}}}.'
       }
     ],
-    scopes: ["collections:write", "tasks:write"],
+    scopes: [...houseOperations.fileAsset.scopes],
     returns: "HouseWriteResult",
-    notes: "POST /api/v1/house/assets (asset_file). Returns { item, receipt }; `do house undo --data '<receipt>'` takes it back."
+    notes: `${routeOf(houseOperations.fileAsset)} (asset_file). Returns { item, receipt }; \`do house undo --data '<receipt>'\` takes it back.`
   },
   {
     path: ["house", "upkeep"],
@@ -36404,18 +37987,18 @@ var COMMAND_SPECS = [
       },
       { name: "start", type: "string", description: "First due day (YYYY-MM-DD)." }
     ],
-    scopes: ["collections:write", "tasks:write"],
+    scopes: [...houseOperations.setUpkeep.scopes],
     returns: "HouseWriteResult",
-    notes: "POST /api/v1/house/assets/{id}/upkeep (asset_upkeep_set)."
+    notes: `${routeOf(houseOperations.setUpkeep)} (asset_upkeep_set).`
   },
   {
     path: ["house", "undo"],
     summary: "Undo `house file` / `house upkeep` from its receipt.",
     args: [],
     flags: [{ name: "data", type: "string", description: "The receipt as JSON." }],
-    scopes: ["collections:write", "tasks:write"],
+    scopes: [...houseOperations.undo.scopes],
     returns: "{ itemId, undone }",
-    notes: "POST /api/v1/house/undo."
+    notes: `${routeOf(houseOperations.undo)}.`
   },
   {
     path: ["money", "accounts"],
@@ -37054,9 +38637,9 @@ var COMMAND_SPECS = [
     summary: "The Animals home: eggs today, feed days left, daily care, and what's coming up.",
     args: [],
     flags: [],
-    scopes: ["animals:read"],
+    scopes: [...animalOperations.overview.scopes],
     returns: "AnimalsOverview",
-    notes: "GET /api/v1/animals/overview. The animals still here, today's eggs per flock against its heads (last 7 days), the feed supplies with days left, the linked daily-care Habits, and every animal's key dates from today on."
+    notes: `${routeOf(animalOperations.overview)}. The animals still here, today's eggs per flock against its heads (last 7 days), the feed supplies with days left, the linked daily-care Habits, and every animal's key dates from today on.`
   },
   {
     path: ["animals", "handover"],
@@ -37069,45 +38652,45 @@ var COMMAND_SPECS = [
         description: "An `away` period's id; the next trip when left out."
       }
     ],
-    scopes: ["animals:read"],
+    scopes: [...animalOperations.handover.scopes],
     returns: "AnimalHandover",
-    notes: "GET /api/v1/animals/handover. The trip (an `away` period, else the Space's Away until \u2026), each animal still here with the steps from its attached note, the vets to call, whether the feed lasts, and whether the daily-care Habits rest. Never a chip or certificate number."
+    notes: `${routeOf(animalOperations.handover)}. The trip (an \`away\` period, else the Space's Away until \u2026), each animal still here with the steps from its attached note, the vets to call, whether the feed lasts, and whether the daily-care Habits rest. Never a chip or certificate number.`
   },
   {
     path: ["animals", "species"],
     summary: "List the species profiles (the built-in set arrives on first use).",
     args: [],
     flags: [],
-    scopes: ["animals:read"],
+    scopes: [...animalOperations.listSpecies.scopes],
     returns: "AnimalSpecies[]",
-    notes: "GET /api/v1/animals/species."
+    notes: `${routeOf(animalOperations.listSpecies)}.`
   },
   {
     path: ["animals", "species-add"],
     summary: "Add a species profile of your own.",
     args: [],
     flags: [{ name: "data", type: "string", description: "CreateAnimalSpeciesInput JSON." }],
-    scopes: ["animals:write"],
+    scopes: [...animalOperations.createSpecies.scopes],
     returns: "AnimalSpecies",
-    notes: "POST /api/v1/animals/species. `key` is a lowercase slug, unique per Space."
+    notes: `${routeOf(animalOperations.createSpecies)}. \`key\` is a lowercase slug, unique per Space.`
   },
   {
     path: ["animals", "species-update"],
     summary: "Edit a species profile.",
     args: [{ name: "id", required: true, description: "Species ULID." }],
     flags: [{ name: "data", type: "string", description: "UpdateAnimalSpeciesInput JSON." }],
-    scopes: ["animals:write"],
+    scopes: [...animalOperations.updateSpecies.scopes],
     returns: "AnimalSpecies",
-    notes: "PATCH /api/v1/animals/species/{id}."
+    notes: `${routeOf(animalOperations.updateSpecies)}.`
   },
   {
     path: ["animals", "timeline"],
     summary: "An animal's history, newest first (for a group, its members' too).",
     args: [{ name: "id", required: true, description: "Animal ULID." }],
     flags: [{ name: "days", type: "string", description: "How far back (default 90)." }],
-    scopes: ["animals:read"],
+    scopes: [...animalOperations.timeline.scopes],
     returns: "AnimalTimelineEntry[]",
-    notes: "GET /api/v1/animals/{id}/timeline. Weights (g), lengths (mm), egg counts and notes, periods starting and ending, and key dates that came round."
+    notes: `${routeOf(animalOperations.timeline)}. Weights (g), lengths (mm), egg counts and notes, periods starting and ending, and key dates that came round.`
   },
   {
     path: ["animals", "log"],
@@ -37125,9 +38708,9 @@ var COMMAND_SPECS = [
       { name: "unit", type: "string", description: "For a weight: g (default) or kg." },
       { name: "at", type: "string", description: "When (ISO 8601); default now." }
     ],
-    scopes: ["animals:write"],
+    scopes: [...animalOperations.log.scopes],
     returns: "AnimalTimelineEntry",
-    notes: 'POST /api/v1/animals/{id}/log (`animal_log`). `do animals log <hens> eggs 2`, `do animals log <dog> weight 37.8 --unit kg`, `do animals log <hen> note "eating again"`. Eggs are the day\'s count: logging again that day replaces it.'
+    notes: `${routeOf(animalOperations.log)} (\`animal_log\`). \`do animals log <hens> eggs 2\`, \`do animals log <dog> weight 37.8 --unit kg\`, \`do animals log <hen> note "eating again"\`. Eggs are the day's count: logging again that day replaces it.`
   },
   {
     path: ["animals", "vet-visit"],
@@ -37140,18 +38723,18 @@ var COMMAND_SPECS = [
         description: "JSON: { vetContactId?, clinician?, reason?, vaccine?: { name, source? }, dewormer?, weight?: { value, unit? }, nextDates?: [{ label, date }], files?: [{ id, name? }], cost?: { amount, currency? }, at? }. The visit's and each date's ids are minted."
       }
     ],
-    scopes: ["animals:write"],
+    scopes: [...animalOperations.logVetVisit.scopes],
     returns: "AnimalVetVisit",
-    notes: 'POST /api/v1/animals/{id}/vet-visits (`animal_vet_visit`, mockup 03). The visit is the receipt: post it with `receipt: { nodeId: <animal id>, about: "vet_visit", parts: [<visit id>] }`. `do animals vet-visit <dog> --data \'{"reason":"booster","vaccine":{"name":"DHPPi + L4","source":"sticker"},"weight":{"value":37.8}}\'`.'
+    notes: `${routeOf(animalOperations.logVetVisit)} (\`animal_vet_visit\`, mockup 03). The visit is the receipt: post it with \`receipt: { nodeId: <animal id>, about: "vet_visit", parts: [<visit id>] }\`. \`do animals vet-visit <dog> --data '{"reason":"booster","vaccine":{"name":"DHPPi + L4","source":"sticker"},"weight":{"value":37.8}}'\`.`
   },
   {
     path: ["animals", "vet-visit-get"],
     summary: "Read a vet visit as its receipt reads.",
     args: [{ name: "visitId", required: true, description: "Vet visit ULID." }],
     flags: [],
-    scopes: ["animals:read"],
+    scopes: [...animalOperations.vetVisit.scopes],
     returns: "AnimalVetVisit",
-    notes: "GET /api/v1/animals/vet-visits/{visitId}."
+    notes: `${routeOf(animalOperations.vetVisit)}.`
   },
   {
     path: ["animals", "vet-visit-edit"],
@@ -37164,27 +38747,27 @@ var COMMAND_SPECS = [
         description: "JSON: any of vetContactId, clinician, reason, vaccine, dewormer, cost (null clears one)."
       }
     ],
-    scopes: ["animals:write"],
+    scopes: [...animalOperations.patchVetVisit.scopes],
     returns: "AnimalVetVisit",
-    notes: "PATCH /api/v1/animals/vet-visits/{visitId}. The newest version wins."
+    notes: `${routeOf(animalOperations.patchVetVisit)}. The newest version wins.`
   },
   {
     path: ["animals", "vet-visit-undo"],
     summary: "Take a vet visit back (the receipt's Undo).",
     args: [{ name: "visitId", required: true, description: "Vet visit ULID." }],
     flags: [],
-    scopes: ["animals:write"],
+    scopes: [...animalOperations.undoVetVisit.scopes],
     returns: "AnimalVetVisit",
-    notes: "POST /api/v1/animals/vet-visits/{visitId}/undo. The visit, its weight, its key dates and the filed photos all go back."
+    notes: `${routeOf(animalOperations.undoVetVisit)}. The visit, its weight, its key dates and the filed photos all go back.`
   },
   {
     path: ["animals", "lost-card"],
     summary: "An animal's lost-pet card: on or off, its link, and what it could show.",
     args: [{ name: "id", required: true, description: "Animal ULID." }],
     flags: [],
-    scopes: ["animals:read"],
+    scopes: [...animalOperations.lostCard.scopes],
     returns: "AnimalLostCardState",
-    notes: "GET /api/v1/animals/{id}/lost-card. `card` is null while it's off; else its `path` (`/lost/<token>`, the page a QR code opens), what it shows and `preview` (the finder's page). `photos` are the pictures on the animal it may show; `chipOnFile` says whether it can say chipped."
+    notes: `${routeOf(animalOperations.lostCard)}. \`card\` is null while it's off; else its \`path\` (\`/lost/<token>\`, the page a QR code opens), what it shows and \`preview\` (the finder's page). \`photos\` are the pictures on the animal it may show; \`chipOnFile\` says whether it can say chipped.`
   },
   {
     path: ["animals", "lost-card-set"],
@@ -37197,27 +38780,27 @@ var COMMAND_SPECS = [
         description: 'JSON: `{ "phone": "+32 470 \u2026", "photoFileId": "\u2026", "showChipped": true, "note": "\u2026" }`; null takes a field off.'
       }
     ],
-    scopes: ["animals:write"],
+    scopes: [...animalOperations.setLostCard.scopes],
     returns: "AnimalLostCardState",
-    notes: "PUT /api/v1/animals/{id}/lost-card. An individual still with the household (a lost one included). The name always shows; the photo must be a picture on the animal; `showChipped` needs its chip on file and never shows the number. The link stays the same while the card is on."
+    notes: `${routeOf(animalOperations.setLostCard)}. An individual still with the household (a lost one included). The name always shows; the photo must be a picture on the animal; \`showChipped\` needs its chip on file and never shows the number. The link stays the same while the card is on.`
   },
   {
     path: ["animals", "lost-card-off"],
     summary: "Turn an animal's lost-pet card off (its link stops working).",
     args: [{ name: "id", required: true, description: "Animal ULID." }],
     flags: [],
-    scopes: ["animals:write"],
+    scopes: [...animalOperations.removeLostCard.scopes],
     returns: "void",
-    notes: "DELETE /api/v1/animals/{id}/lost-card. Destructive: a printed QR stops working, so it needs --allow-destructive. Turning it on again makes a new link."
+    notes: `${routeOf(animalOperations.removeLostCard)}. Destructive: a printed QR stops working, so it needs --allow-destructive. Turning it on again makes a new link.`
   },
   {
     path: ["animals", "acquisition"],
     summary: "Bringing a planned animal home: its checklist.",
     args: [{ name: "id", required: true, description: "Animal ULID." }],
     flags: [],
-    scopes: ["animals:read"],
+    scopes: [...animalOperations.acquisition.scopes],
     returns: "AnimalAcquisition",
-    notes: 'GET /api/v1/animals/{id}/acquisition. The Task "Bring <name> home", its steps in order, `blockers` to sort before the pick-up (papers its kind needs that aren\'t on file) and `arrived`; 404 when none was planned.'
+    notes: `${routeOf(animalOperations.acquisition)}. The Task "Bring <name> home", its steps in order, \`blockers\` to sort before the pick-up (papers its kind needs that aren't on file) and \`arrived\`; 404 when none was planned.`
   },
   {
     path: ["animals", "acquisition-plan"],
@@ -37235,9 +38818,9 @@ var COMMAND_SPECS = [
         description: 'JSON: `{ "quarantine": true, "extraSteps": ["Buy a UV lamp"] }`.'
       }
     ],
-    scopes: ["animals:write"],
+    scopes: [...animalOperations.planAcquisition.scopes],
     returns: "AnimalAcquisition",
-    notes: "POST /api/v1/animals/{id}/acquisition. The steps: the papers its kind needs (DogID, CatID, CITES A, closed ring), the vet check, its home, and the quarantine before it meets the others (on by default for a reptile or a bird). Only a planned animal; one per animal (409)."
+    notes: `${routeOf(animalOperations.planAcquisition)}. The steps: the papers its kind needs (DogID, CatID, CITES A, closed ring), the vet check, its home, and the quarantine before it meets the others (on by default for a reptile or a bird). Only a planned animal; one per animal (409).`
   },
   {
     path: ["animals", "arrived"],
@@ -37255,9 +38838,9 @@ var COMMAND_SPECS = [
         description: "How long it stays apart (0\u201312); 3 when its checklist has the quarantine step."
       }
     ],
-    scopes: ["animals:write"],
+    scopes: [...animalOperations.arrived.scopes],
     returns: "AnimalDetail",
-    notes: "POST /api/v1/animals/{id}/arrived. Sets acquiredOn and the status (`quarantine` with a Period, else `active`); open steps stay open."
+    notes: `${routeOf(animalOperations.arrived)}. Sets acquiredOn and the status (\`quarantine\` with a Period, else \`active\`); open steps stay open.`
   },
   {
     path: ["runs", "change"],
@@ -37746,7 +39329,7 @@ var COMMAND_SPECS = [
     summary: "The guest list page: households, head count per part, deadlines, roles.",
     args: [{ name: "id", required: true, description: "The guest list's id." }],
     flags: [],
-    scopes: ["contacts:read"],
+    scopes: [...guestListOperations.overview.scopes],
     returns: "GuestListOverview",
     notes: "A plus-one is one more head, following the guest's answer. keyDates are the project's (the RSVP deadline, save-the-dates, the civil notice window)."
   },
@@ -37808,7 +39391,7 @@ var COMMAND_SPECS = [
     summary: "A guest list's proposed seating plans, newest first.",
     args: [],
     flags: [{ name: "list", type: "string", description: "The guest list's id (required)." }],
-    scopes: ["contacts:read"],
+    scopes: [...seatingProposalOperations.list.scopes],
     returns: "SeatingProposal"
   },
   {
@@ -37822,7 +39405,7 @@ var COMMAND_SPECS = [
         description: 'JSON CreateSeatingProposalInput, e.g. {"guestListId":"01\u2026","tables":[{"name":"1","seats":8,"guestIds":["01\u2026"]}],"note":"Households together."}'
       }
     ],
-    scopes: ["contacts:write"],
+    scopes: [...seatingProposalOperations.propose.scopes],
     returns: "SeatingProposal",
     notes: "Keep households together and circles near each other. Each guest at one table; a table's heads (a plus-one counts) fit its seats. Read `do guest-lists overview` first for households and current tables."
   },
@@ -37831,7 +39414,7 @@ var COMMAND_SPECS = [
     summary: "Apply a proposed plan: the room's tables become its tables.",
     args: [{ name: "id", required: true, description: "The proposal's id." }],
     flags: [],
-    scopes: ["contacts:write"],
+    scopes: [...seatingProposalOperations.apply.scopes],
     returns: "SeatingProposal"
   },
   {
@@ -37839,7 +39422,7 @@ var COMMAND_SPECS = [
     summary: "Set a proposed plan aside.",
     args: [{ name: "id", required: true, description: "The proposal's id." }],
     flags: [],
-    scopes: ["contacts:write"],
+    scopes: [...seatingProposalOperations.dismiss.scopes],
     returns: "SeatingProposal"
   },
   {
@@ -37902,7 +39485,7 @@ var COMMAND_SPECS = [
     summary: "The gifts for the event: the cards still to send, then the ones sent.",
     args: [{ name: "id", required: true, description: "The guest list's id." }],
     flags: [],
-    scopes: ["contacts:read"],
+    scopes: [...guestListOperations.thankYou.scopes],
     returns: "ThankYouView",
     notes: 'Log a gift as a gift_received moment with sourceNodeId = the project: `do contact-moments create --data \'{"contactId":"<id>","kind":"gift_received","summary":"a moka pot","sourceNodeId":"<project>"}\'`. Mark the card sent: `do contact-moments update <id> --data \'{"thankedAt":"2027-07-10"}\'`.'
   },
@@ -37922,7 +39505,7 @@ var COMMAND_SPECS = [
         description: "Where to save a PDF (default: the name the API gives it)."
       }
     ],
-    scopes: ["contacts:read"],
+    scopes: [...guestListOperations.export.scopes],
     returns: "string",
     notes: "A CSV goes to stdout (`> tables.csv`); a PDF is saved: `do guest-lists export <id> --kind invitations --out invitations.pdf`. Mint the links first (`do rsvp-links create`); the QR opens the list's `siteUrl` + /i/<token>, and its `sitePassword` is printed only when set."
   },
@@ -37931,7 +39514,7 @@ var COMMAND_SPECS = [
     summary: "A guest list's RSVP links, one per household (never the tokens).",
     args: [],
     flags: [{ name: "list", type: "string", description: "The guest list's id (required)." }],
-    scopes: ["contacts:read"],
+    scopes: [...rsvpLinkOperations.list.scopes],
     returns: "RsvpLink"
   },
   {
@@ -37945,7 +39528,7 @@ var COMMAND_SPECS = [
         description: 'JSON CreateRsvpLinksInput, e.g. {"guestListId":"01\u2026"} (every household without a live link), "mode":"address" for the save-the-date (address only), or with "householdIds":["01\u2026"] (re-mints, revoking the old link; prefer `do rsvp-links replace`).'
       }
     ],
-    scopes: ["contacts:write"],
+    scopes: [...rsvpLinkOperations.mint.scopes],
     returns: "MintedRsvpLink",
     notes: "A guest in no household gets a household of one first. A link stops at the end of the RSVP deadline day (or after 120 days without one) unless expiresAt says otherwise. Send each household its own `path` on the web app."
   },
@@ -37954,7 +39537,7 @@ var COMMAND_SPECS = [
     summary: "Show a live RSVP link again: the same token it was minted with, and a whole-form link's short code.",
     args: [{ name: "id", required: true, description: "The link's id." }],
     flags: [],
-    scopes: ["contacts:write"],
+    scopes: [...rsvpLinkOperations.reveal.scopes],
     returns: "MintedRsvpLink",
     notes: "The mail and the paper QR carry this one link; `shortCode` (six characters) is printed on the paper invitation and typed at the site's /code. A revoked or expired link is gone; one minted before tokens were kept can't be shown: replace it."
   },
@@ -37963,7 +39546,7 @@ var COMMAND_SPECS = [
     summary: "Replace an RSVP link: a new token, and the old link (and its QR) stops working.",
     args: [{ name: "id", required: true, description: "The link's id." }],
     flags: [],
-    scopes: ["contacts:write"],
+    scopes: [...rsvpLinkOperations.replace.scopes],
     returns: "MintedRsvpLink"
   },
   {
@@ -37971,7 +39554,7 @@ var COMMAND_SPECS = [
     summary: "Stop one RSVP link working.",
     args: [{ name: "id", required: true, description: "The link's id." }],
     flags: [],
-    scopes: ["contacts:write"],
+    scopes: [...rsvpLinkOperations.revoke.scopes],
     returns: "RsvpLink"
   },
   {
@@ -40570,38 +42153,40 @@ var HANDLERS = {
     render: renderReview
   }),
   progress: async ({ flags, requireClient }) => ({
-    data: await requireClient().get("/progress", { query: { days: flagString(flags, "days") } }),
+    data: await requireClient().get(pathOf(progressOperations.get), {
+      query: { days: flagString(flags, "days") }
+    }),
     render: renderProgress
   }),
   "progress habits": async ({ requireClient }) => ({
-    data: await requireClient().get("/progress/habits"),
+    data: await requireClient().get(pathOf(progressOperations.habits)),
     render: renderProgressHabits
   }),
   "progress commits": async ({ flags, requireClient }) => {
     const days = flagString(flags, "days");
     const query = parseInput(githubCommitsQuerySchema, days ? { days } : {});
     return {
-      data: await requireClient().get("/progress/commits", {
+      data: await requireClient().get(pathOf(progressOperations.commits), {
         query: { days: String(query.days) }
       }),
       render: renderRecord
     };
   },
   "progress questions": async ({ requireClient }) => ({
-    data: await requireClient().get("/progress/questions"),
+    data: await requireClient().get(pathOf(progressOperations.questions)),
     render: renderInsightsAnswers
   }),
   "progress dismiss": async ({ args, requireClient }) => {
     const question = parseInput(insightsQuestionSchema, requireArg(args, 0, "question"));
     return {
-      data: await requireClient().post(`/progress/questions/${question}/dismiss`, {}),
+      data: await requireClient().post(pathOf(progressOperations.dismiss, { question }), {}),
       render: renderInsightsAnswers
     };
   },
   "progress restore": async ({ args, requireClient }) => {
     const question = parseInput(insightsQuestionSchema, requireArg(args, 0, "question"));
     return {
-      data: await requireClient().post(`/progress/questions/${question}/restore`, {}),
+      data: await requireClient().post(pathOf(progressOperations.restore, { question }), {}),
       render: renderInsightsAnswers
     };
   },
@@ -40612,7 +42197,10 @@ var HANDLERS = {
       ...at ? { occurredAt: at } : {},
       ...channel ? { channel } : {}
     });
-    return { data: await requireClient().post("/progress/activity", input), render: renderRecord };
+    return {
+      data: await requireClient().post(pathOf(progressOperations.activity), input),
+      render: renderRecord
+    };
   },
   "progress day": async ({ args, requireClient }) => {
     const date = requireArg(args, 0, "date");
@@ -40620,7 +42208,7 @@ var HANDLERS = {
       throw usageError("progress day needs a date as YYYY-MM-DD, e.g. `do progress day 2026-10-15`");
     }
     return {
-      data: await requireClient().get(`/progress/days/${date}`),
+      data: await requireClient().get(pathOf(progressOperations.day, { date })),
       render: renderProgressDay
     };
   },
@@ -41099,7 +42687,7 @@ var HANDLERS = {
     if (q.length < 2)
       throw usageError('foods search needs a name, e.g. `do foods search "gouda"`');
     return {
-      data: await requireClient().get("/foods/search", {
+      data: await requireClient().get(pathOf(foodOperations.search), {
         query: {
           q,
           limit: flagString(flags, "limit"),
@@ -41111,11 +42699,17 @@ var HANDLERS = {
   },
   "foods barcode": async ({ args, requireClient }) => {
     const ean = requireArg(args, 0, "barcode");
-    return { data: await requireClient().get(`/foods/barcode/${ean}`), render: renderRecord };
+    return {
+      data: await requireClient().get(pathOf(foodOperations.barcode, { ean })),
+      render: renderRecord
+    };
   },
   "foods get": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "food id");
-    return { data: await requireClient().get(`/foods/${id}`), render: renderRecord };
+    return {
+      data: await requireClient().get(pathOf(foodOperations.get, { id })),
+      render: renderRecord
+    };
   },
   "documents file": async ({ args, flags, requireClient }) => {
     if (flagString(flags, "data") === undefined)
@@ -41262,10 +42856,13 @@ var HANDLERS = {
     if (flagString(flags, "data") === undefined)
       throw usageError("food log needs --data");
     const body = parseInput(createMealLogInputSchema, { id: ulid3(), ...readDataFlag(flags) });
-    return { data: await requireClient().post("/food/logs", body), render: renderRecord };
+    return {
+      data: await requireClient().post(pathOf(foodLogOperations.create), body),
+      render: renderRecord
+    };
   },
   "food list": async ({ flags, requireClient }) => ({
-    data: await requireClient().get("/food/logs", {
+    data: await requireClient().get(pathOf(foodLogOperations.list), {
       query: {
         from: requireFlag(flags, "from", "food list needs --from <ISO instant>"),
         to: requireFlag(flags, "to", "food list needs --to <ISO instant>")
@@ -41275,19 +42872,25 @@ var HANDLERS = {
   }),
   "food get": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "meal id");
-    return { data: await requireClient().get(`/food/logs/${id}`), render: renderRecord };
+    return {
+      data: await requireClient().get(pathOf(foodLogOperations.get, { id })),
+      render: renderRecord
+    };
   },
   "food context": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "meal id");
     return {
-      data: await requireClient().get(`/food/logs/${id}/context`),
+      data: await requireClient().get(pathOf(foodLogOperations.context, { id })),
       render: renderRecord
     };
   },
   "food week": async ({ flags, requireClient }) => {
     const start = flagString(flags, "start");
     const query = start ? `?start=${encodeURIComponent(start)}` : "";
-    return { data: await requireClient().get(`/food/week${query}`), render: renderRecord };
+    return {
+      data: await requireClient().get(`${pathOf(foodLogOperations.week)}${query}`),
+      render: renderRecord
+    };
   },
   "food week-read": async ({ args, flags, requireClient }) => {
     const start = requireArg(args, 0, "a day of the week");
@@ -41295,15 +42898,18 @@ var HANDLERS = {
       start,
       body: flagString(flags, "body")
     });
-    return { data: await requireClient().put("/food/week/read", input), render: renderRecord };
+    return {
+      data: await requireClient().put(pathOf(foodLogOperations.writeWeekRead), input),
+      render: renderRecord
+    };
   },
   "food week-read-remove": async ({ args, requireClient }) => {
     const start = requireArg(args, 0, "a day of the week");
-    await requireClient().delete(`/food/week/read?start=${encodeURIComponent(start)}`);
+    await requireClient().delete(`${pathOf(foodLogOperations.removeWeekRead)}?start=${encodeURIComponent(start)}`);
     return { data: { ok: true, removed: start }, render: renderRecord };
   },
   "food patterns": async ({ requireClient }) => ({
-    data: await requireClient().get("/food/patterns"),
+    data: await requireClient().get(pathOf(foodLogOperations.patterns)),
     render: renderRecord
   }),
   "food trial": async ({ args, flags, requireClient }) => {
@@ -41315,11 +42921,14 @@ var HANDLERS = {
       startsOn: flagString(flags, "starts-on"),
       ...days === undefined ? {} : { days: Number(days) }
     });
-    return { data: await requireClient().post("/food/trials", input), render: renderRecord };
+    return {
+      data: await requireClient().post(pathOf(foodLogOperations.proposeTrial), input),
+      render: renderRecord
+    };
   },
   "food trial-stop": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "a trial id");
-    await requireClient().post(`/food/trials/${encodeURIComponent(id)}/stop`, {});
+    await requireClient().post(pathOf(foodLogOperations.stopTrial, { id }), {});
     return { data: { ok: true, stopped: id }, render: renderRecord };
   },
   "food correct": async ({ args, flags, requireClient }) => {
@@ -41327,31 +42936,34 @@ var HANDLERS = {
     if (flagString(flags, "data") === undefined)
       throw usageError("food correct needs --data");
     const body = parseInput(correctMealLogInputSchema, readDataFlag(flags));
-    return { data: await requireClient().patch(`/food/logs/${id}`, body), render: renderRecord };
+    return {
+      data: await requireClient().patch(pathOf(foodLogOperations.correct, { id }), body),
+      render: renderRecord
+    };
   },
   "food undo-correction": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "meal id");
     return {
-      data: await requireClient().post(`/food/logs/${id}/undo-correction`, {}),
+      data: await requireClient().post(pathOf(foodLogOperations.undoCorrection, { id }), {}),
       render: renderRecord
     };
   },
   "food remove": async ({ args, flags, requireClient }) => {
     const id = requireArg(args, 0, "meal id");
     assertDestructiveAllowed(flags, `remove meal ${id}`);
-    await requireClient().delete(`/food/logs/${id}`);
+    await requireClient().delete(pathOf(foodLogOperations.remove, { id }));
     return { data: { ok: true, removed: id }, render: renderRecord };
   },
   "food save-meal": async ({ args, flags, requireClient }) => {
     const id = requireArg(args, 0, "meal id");
     const title = flagString(flags, "title");
     return {
-      data: await requireClient().post(`/food/logs/${id}/save-meal`, title ? { title } : {}),
+      data: await requireClient().post(pathOf(foodLogOperations.saveMeal, { id }), title ? { title } : {}),
       render: renderRecord
     };
   },
   "food days": async ({ flags, requireClient }) => ({
-    data: await requireClient().get("/food/days", {
+    data: await requireClient().get(pathOf(foodLogOperations.days), {
       query: {
         from: requireFlag(flags, "from", "food days needs --from <YYYY-MM-DD>"),
         to: requireFlag(flags, "to", "food days needs --to <YYYY-MM-DD>")
@@ -41361,29 +42973,35 @@ var HANDLERS = {
   }),
   "food day": async ({ args, requireClient }) => {
     const date = requireArg(args, 0, "date (YYYY-MM-DD)");
-    return { data: await requireClient().get(`/food/days/${date}`), render: renderRecord };
+    return {
+      data: await requireClient().get(pathOf(foodLogOperations.day, { date })),
+      render: renderRecord
+    };
   },
   "food recall": async ({ requireClient }) => ({
-    data: await requireClient().get("/food/recall"),
+    data: await requireClient().get(pathOf(foodLogOperations.recall)),
     render: renderRecord
   }),
   "recipes nutrition": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "recipe id");
     return {
-      data: await requireClient().post(`/recipes/${id}/nutrition`, {}),
+      data: await requireClient().post(pathOf(recipeOperations.nutrition, { id }), {}),
       render: renderRecord
     };
   },
   "recipes used-in": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "recipe id");
-    return { data: await requireClient().get(`/recipes/${id}/used-in`), render: renderRecord };
+    return {
+      data: await requireClient().get(pathOf(recipeOperations.usedIn, { id })),
+      render: renderRecord
+    };
   },
   "recipes match": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "recipe id");
     const ingredient = requireArg(args, 1, "ingredient id");
     const foodId = requireArg(args, 2, "food id");
     return {
-      data: await requireClient().put(`/recipes/${id}/ingredients/${ingredient}/match`, {
+      data: await requireClient().put(pathOf(recipeOperations.match, { id, ingredientId: ingredient }), {
         foodId
       }),
       render: renderRecord
@@ -41445,19 +43063,22 @@ var HANDLERS = {
   }),
   "time-blocks record": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "time block id");
-    return { data: await requireClient().get(`/time-blocks/${id}/record`), render: renderRecord };
+    return {
+      data: await requireClient().get(pathOf(timeBlockOperations.record, { id })),
+      render: renderRecord
+    };
   },
   "time-blocks confirm": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "time block id");
     return {
-      data: await requireClient().post(`/time-blocks/${id}/confirm`, {}),
+      data: await requireClient().post(pathOf(timeBlockOperations.confirm, { id }), {}),
       render: renderRecord
     };
   },
   "time-blocks plan-vs-record": async ({ flags, requireClient }) => {
     const days = flagString(flags, "days");
     return {
-      data: await requireClient().get("/time-blocks/plan-vs-record", {
+      data: await requireClient().get(pathOf(timeBlockOperations.planVsRecord), {
         query: days === undefined ? {} : { days }
       }),
       render: renderRecord
@@ -41465,7 +43086,10 @@ var HANDLERS = {
   },
   "days record": async ({ args, requireClient }) => {
     const date = dayDateArg(args, "record");
-    return { data: await requireClient().get(`/days/${date}/record`), render: renderRecord };
+    return {
+      data: await requireClient().get(pathOf(dayOperations.record, { date })),
+      render: renderRecord
+    };
   },
   "days write": async ({ args, flags, requireClient }) => {
     const date = dayDateArg(args, "write");
@@ -41473,7 +43097,7 @@ var HANDLERS = {
       throw usageError("days write needs --data");
     const body = parseInput(dayRecordWriteInputSchema, readDataFlag(flags));
     return {
-      data: await requireClient().post(`/days/${date}/record`, body),
+      data: await requireClient().post(pathOf(dayOperations.write, { date }), body),
       render: renderRecord
     };
   },
@@ -41483,7 +43107,7 @@ var HANDLERS = {
       throw usageError("days ask needs --data");
     const body = parseInput(dayRecordAskInputSchema, readDataFlag(flags));
     return {
-      data: await requireClient().post(`/days/${date}/record/ask`, body),
+      data: await requireClient().post(pathOf(dayOperations.ask, { date }), body),
       render: renderRecord
     };
   },
@@ -41491,13 +43115,16 @@ var HANDLERS = {
     const date = dayDateArg(args, "undo");
     const body = parseInput(dayRecordUndoInputSchema, { receipt: requireArg(args, 1, "receipt") });
     return {
-      data: await requireClient().post(`/days/${date}/record/undo`, body),
+      data: await requireClient().post(pathOf(dayOperations.undo, { date }), body),
       render: renderRecord
     };
   },
   "days close": async ({ args, requireClient }) => {
     const date = dayDateArg(args, "close");
-    return { data: await requireClient().post(`/days/${date}/close`, {}), render: renderRecord };
+    return {
+      data: await requireClient().post(pathOf(dayOperations.close, { date }), {}),
+      render: renderRecord
+    };
   },
   "calendar events": async ({ flags, requireClient }) => {
     const from = flagString(flags, "from");
@@ -41505,7 +43132,9 @@ var HANDLERS = {
     if (from === undefined !== (to === undefined)) {
       throw usageError("calendar events takes --from and --to together");
     }
-    const events = await requireClient().get("/calendar/events", { query: { from, to } });
+    const events = await requireClient().get(pathOf(calendarOperations.events), {
+      query: { from, to }
+    });
     return { data: events, render: renderEvents };
   },
   "calendar plan": async ({ args, flags, requireClient }) => {
@@ -41520,7 +43149,7 @@ var HANDLERS = {
       ...attending !== undefined ? { attending: attending === "waiting" ? null : attending } : {}
     });
     return {
-      data: await requireClient().patch(`/calendar/events/${id}/plan`, body),
+      data: await requireClient().patch(pathOf(calendarOperations.plan, { id }), body),
       render: renderEvent
     };
   },
@@ -41828,11 +43457,17 @@ var HANDLERS = {
   },
   "metrics list": async ({ flags, requireClient }) => {
     const query = { days: flagString(flags, "days") };
-    return { data: await requireClient().get("/metrics", { query }), render: renderList };
+    return {
+      data: await requireClient().get(pathOf(metricOperations.list), { query }),
+      render: renderList
+    };
   },
   "metrics sessions": async ({ flags, requireClient }) => {
     const query = { days: flagString(flags, "days") };
-    return { data: await requireClient().get("/metrics/sessions", { query }), render: renderList };
+    return {
+      data: await requireClient().get(pathOf(metricOperations.sessions), { query }),
+      render: renderList
+    };
   },
   "metrics log": async ({ args, flags, requireClient }) => {
     const key = parseInput(metricKeySchema, requireArg(args, 0, "metric (weight|sleep|mood|rating|energy|bedtime)"));
@@ -41849,14 +43484,20 @@ var HANDLERS = {
       ...at ? { occurredAt: at } : {},
       ...source ? { source } : {}
     });
-    return { data: await requireClient().post(`/metrics/${key}`, input), render: renderRecord };
+    return {
+      data: await requireClient().post(pathOf(metricOperations.log, { key }), input),
+      render: renderRecord
+    };
   },
   "metrics import": async ({ flags, requireClient }) => {
     const input = parseInput(importMetricsInputSchema, {
       source: "health_connect",
       ...readDataFlag(flags)
     });
-    return { data: await requireClient().post("/metrics/import", input), render: renderRecord };
+    return {
+      data: await requireClient().post(pathOf(metricOperations.import), input),
+      render: renderRecord
+    };
   },
   "tap-tags tap": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "tag id");
@@ -42012,7 +43653,7 @@ var HANDLERS = {
     if (entity !== undefined && !presetEntitySchema.safeParse(entity).success) {
       throw usageError(`--entity must be one of: ${presetEntitySchema.options.join(", ")}`);
     }
-    const catalog = presetSchema.array().parse(await requireClient().get("/presets"));
+    const catalog = presetSchema.array().parse(await requireClient().get(pathOf(presetOperations.list)));
     const presets = entity ? catalog.filter((p) => p.entity === entity) : catalog;
     return { data: presets, render: renderPresetList };
   },
@@ -42020,7 +43661,7 @@ var HANDLERS = {
     const key = requireArg(args, 0, "preset key");
     const on = flagString(flags, "on");
     const body = on === undefined ? undefined : parseInput(installPresetInputSchema, { on });
-    const result = presetInstallResultSchema.parse(await requireClient().post(`/presets/${encodeURIComponent(key)}/install`, body));
+    const result = presetInstallResultSchema.parse(await requireClient().post(pathOf(presetOperations.install, { key }), body));
     return { data: result, render: renderPresetInstall };
   },
   "collection types": async ({ requireClient }) => {
@@ -42172,11 +43813,14 @@ var HANDLERS = {
     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 };
+    return {
+      data: await requireClient().patch(pathOf(areaOperations.update, { id }), body),
+      render: renderRecord
+    };
   },
   "areas standards list": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "area id");
-    const area = await requireClient().get(`/areas/${id}`);
+    const area = await requireClient().get(pathOf(areaOperations.get, { id }));
     return { data: area.standards ?? [], render: renderStandards };
   },
   "areas standards add": async ({ args, flags, requireClient }) => {
@@ -42186,7 +43830,7 @@ var HANDLERS = {
       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);
+    const area = await requireClient().post(pathOf(areaOperations.addStandard, { id }), body);
     return { data: area.standards ?? [], render: renderStandards };
   },
   "areas standards link": async ({ args, flags, requireClient }) => {
@@ -42199,20 +43843,20 @@ var HANDLERS = {
     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);
+    const area = await requireClient().patch(pathOf(areaOperations.updateStandard, { id, standardId: 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}`);
+    const area = await requireClient().delete(pathOf(areaOperations.removeStandard, { id, standardId: standard }));
     return { data: area.standards ?? [], render: renderStandards };
   },
   "areas overview": async ({ flags, requireClient }) => {
     const owner = flagString(flags, "owner");
     const query = parseInput(areaOverviewQuerySchema, owner ? { owner } : {});
     return {
-      data: await requireClient().get("/areas/overview", { query }),
+      data: await requireClient().get(pathOf(areaOperations.overview), { query }),
       render: renderAreaOverview
     };
   },
@@ -42225,26 +43869,29 @@ var HANDLERS = {
       until,
       habits: flagBool(flags, "pause-habits") ? "pause" : "keep"
     });
-    return { data: await requireClient().post(`/areas/${id}/rest`, input), render: renderRecord };
+    return {
+      data: await requireClient().post(pathOf(areaOperations.rest, { id }), input),
+      render: renderRecord
+    };
   },
   "areas back": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "area id");
     return {
-      data: await requireClient().post(`/areas/${id}/back`, undefined),
+      data: await requireClient().post(pathOf(areaOperations.back, { id }), undefined),
       render: renderRecord
     };
   },
   "areas since": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "area id");
     return {
-      data: await requireClient().get(`/areas/${id}/since-last-look`),
+      data: await requireClient().get(pathOf(areaOperations.sinceLastLook, { id })),
       render: renderSinceLastLook
     };
   },
   "areas looked-at": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "area id");
     return {
-      data: await requireClient().post(`/areas/${id}/looked-at`, undefined),
+      data: await requireClient().post(pathOf(areaOperations.lookedAt, { id }), undefined),
       render: renderRecord
     };
   },
@@ -42265,17 +43912,20 @@ var HANDLERS = {
       intoAreaId: flagString(flags, "into") ?? null
     });
     return {
-      data: await requireClient().post(`/areas/${id}/to-project`, input),
+      data: await requireClient().post(pathOf(areaOperations.toProject, { id }), input),
       render: renderRecord
     };
   },
   house: async ({ requireClient }) => ({
-    data: await requireClient().get("/house"),
+    data: await requireClient().get(pathOf(houseOperations.overview)),
     render: renderRecord
   }),
   "house asset": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "asset id");
-    return { data: await requireClient().get(`/house/assets/${id}`), render: renderRecord };
+    return {
+      data: await requireClient().get(pathOf(houseOperations.asset, { id })),
+      render: renderRecord
+    };
   },
   "house part": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "asset id");
@@ -42283,7 +43933,7 @@ var HANDLERS = {
       inventoryItemId: requireArg(args, 1, "supply id")
     });
     return {
-      data: await requireClient().post(`/house/assets/${id}/parts`, input),
+      data: await requireClient().post(pathOf(houseOperations.linkPart, { id }), input),
       render: renderRecord
     };
   },
@@ -42291,7 +43941,7 @@ var HANDLERS = {
     const id = requireArg(args, 0, "asset id");
     const supply = requireArg(args, 1, "supply id");
     return {
-      data: await requireClient().delete(`/house/assets/${id}/parts/${supply}`),
+      data: await requireClient().delete(pathOf(houseOperations.unlinkPart, { id, inventoryItemId: supply })),
       render: renderRecord
     };
   },
@@ -42303,7 +43953,10 @@ var HANDLERS = {
       ...title ? { title } : {},
       ...flagString(flags, "place") ? { placeId: flagString(flags, "place") } : {}
     });
-    return { data: await requireClient().post("/house/assets", input), render: renderRecord };
+    return {
+      data: await requireClient().post(pathOf(houseOperations.fileAsset), input),
+      render: renderRecord
+    };
   },
   "house upkeep": async ({ args, flags, requireClient }) => {
     const id = requireArg(args, 0, "asset id");
@@ -42320,7 +43973,7 @@ var HANDLERS = {
       }
     });
     return {
-      data: await requireClient().post(`/house/assets/${id}/upkeep`, input),
+      data: await requireClient().post(pathOf(houseOperations.setUpkeep, { id }), input),
       render: renderRecord
     };
   },
@@ -42335,7 +43988,7 @@ var HANDLERS = {
       ...flagString(flags, "note") ? { note: flagString(flags, "note") } : {}
     });
     return {
-      data: await requireClient().post(`/house/assets/${id}/lend`, input),
+      data: await requireClient().post(pathOf(houseOperations.lend, { id }), input),
       render: renderRecord
     };
   },
@@ -42346,12 +43999,12 @@ var HANDLERS = {
       ...flagString(flags, "note") ? { note: flagString(flags, "note") } : {}
     });
     return {
-      data: await requireClient().post(`/house/assets/${id}/return`, input),
+      data: await requireClient().post(pathOf(houseOperations.giveBack, { id }), input),
       render: renderRecord
     };
   },
   "house value": async ({ requireClient }) => ({
-    data: await requireClient().get("/house/value"),
+    data: await requireClient().get(pathOf(houseOperations.value)),
     render: renderRecord
   }),
   "house year": async ({ flags, requireClient }) => {
@@ -42360,13 +44013,16 @@ var HANDLERS = {
       throw usageError("--year must be a year, e.g. 2026");
     }
     return {
-      data: await requireClient().get(`/house/upkeep${year ? `?year=${year}` : ""}`),
+      data: await requireClient().get(`${pathOf(houseOperations.year)}${year ? `?year=${year}` : ""}`),
       render: renderRecord
     };
   },
   "house undo": async ({ flags, requireClient }) => {
     const input = parseInput(undoHouseWriteInputSchema, readDataFlag(flags));
-    return { data: await requireClient().post("/house/undo", input), render: renderRecord };
+    return {
+      data: await requireClient().post(pathOf(houseOperations.undo), input),
+      render: renderRecord
+    };
   },
   "areas undo-make-project": async ({ args, flags, requireClient }) => {
     const id = requireArg(args, 0, "area id");
@@ -42376,7 +44032,7 @@ var HANDLERS = {
       moved: receipt.moved
     });
     return {
-      data: await requireClient().post(`/areas/${id}/to-project/undo`, input),
+      data: await requireClient().post(pathOf(areaOperations.undoToProject, { id }), input),
       render: renderRecord
     };
   },
@@ -42780,29 +44436,32 @@ var HANDLERS = {
     return { data: { ok: true, removed: id }, render: renderRecord };
   },
   "animals overview": async ({ requireClient }) => ({
-    data: await requireClient().get("/animals/overview"),
+    data: await requireClient().get(pathOf(animalOperations.overview)),
     render: renderRecord
   }),
   "animals handover": async ({ flags, requireClient }) => {
     const periodId = flagString(flags, "period");
     return {
-      data: await requireClient().get("/animals/handover", periodId ? { query: { periodId } } : {}),
+      data: await requireClient().get(pathOf(animalOperations.handover), periodId ? { query: { periodId } } : {}),
       render: renderRecord
     };
   },
   "animals species": async ({ requireClient }) => ({
-    data: await requireClient().get("/animals/species"),
+    data: await requireClient().get(pathOf(animalOperations.listSpecies)),
     render: renderList
   }),
   "animals species-add": async ({ flags, requireClient }) => {
     const body = parseInput(createAnimalSpeciesInputSchema, { id: ulid3(), ...readDataFlag(flags) });
-    return { data: await requireClient().post("/animals/species", body), render: renderRecord };
+    return {
+      data: await requireClient().post(pathOf(animalOperations.createSpecies), body),
+      render: renderRecord
+    };
   },
   "animals species-update": async ({ args, flags, requireClient }) => {
     const id = requireArg(args, 0, "species id");
     const body = parseInput(updateAnimalSpeciesInputSchema, readDataFlag(flags));
     return {
-      data: await requireClient().patch(`/animals/species/${id}`, body),
+      data: await requireClient().patch(pathOf(animalOperations.updateSpecies, { speciesId: id }), body),
       render: renderRecord
     };
   },
@@ -42811,7 +44470,7 @@ var HANDLERS = {
     const days = flagString(flags, "days");
     const query = parseInput(animalTimelineQuerySchema, days ? { days } : {});
     return {
-      data: await requireClient().get(`/animals/${id}/timeline`, {
+      data: await requireClient().get(pathOf(animalOperations.timeline, { id }), {
         query: { days: String(query.days) }
       }),
       render: renderList
@@ -42830,7 +44489,10 @@ var HANDLERS = {
     if (kind !== "note" && Number.isNaN(n))
       throw usageError("the value must be a number");
     const body = parseInput(animalLogInputSchema, { ...fact, ...at ? { occurredAt: at } : {} });
-    return { data: await requireClient().post(`/animals/${id}/log`, body), render: renderRecord };
+    return {
+      data: await requireClient().post(pathOf(animalOperations.log, { id }), body),
+      render: renderRecord
+    };
   },
   "animals vet-visit": async ({ args, flags, requireClient }) => {
     const id = requireArg(args, 0, "animal id");
@@ -42841,46 +44503,46 @@ var HANDLERS = {
       nextDates: (raw.nextDates ?? []).map((d) => ({ id: ulid3(), ...d }))
     });
     return {
-      data: await requireClient().post(`/animals/${id}/vet-visits`, body),
+      data: await requireClient().post(pathOf(animalOperations.logVetVisit, { id }), body),
       render: renderRecord
     };
   },
   "animals vet-visit-get": async ({ args, requireClient }) => ({
-    data: await requireClient().get(`/animals/vet-visits/${requireArg(args, 0, "visit id")}`),
+    data: await requireClient().get(pathOf(animalOperations.vetVisit, { visitId: requireArg(args, 0, "visit id") })),
     render: renderRecord
   }),
   "animals vet-visit-edit": async ({ args, flags, requireClient }) => {
     const visitId = requireArg(args, 0, "visit id");
     const body = parseInput(animalVetVisitPatchSchema, readDataFlag(flags));
     return {
-      data: await requireClient().patch(`/animals/vet-visits/${visitId}`, body),
+      data: await requireClient().patch(pathOf(animalOperations.patchVetVisit, { visitId }), body),
       render: renderRecord
     };
   },
   "animals vet-visit-undo": async ({ args, requireClient }) => ({
-    data: await requireClient().post(`/animals/vet-visits/${requireArg(args, 0, "visit id")}/undo`, {}),
+    data: await requireClient().post(pathOf(animalOperations.undoVetVisit, { visitId: requireArg(args, 0, "visit id") }), {}),
     render: renderRecord
   }),
   "animals lost-card": async ({ args, requireClient }) => ({
-    data: await requireClient().get(`/animals/${requireArg(args, 0, "animal id")}/lost-card`),
+    data: await requireClient().get(pathOf(animalOperations.lostCard, { id: requireArg(args, 0, "animal id") })),
     render: renderRecord
   }),
   "animals lost-card-set": async ({ args, flags, requireClient }) => {
     const id = requireArg(args, 0, "animal id");
     const body = parseInput(animalLostCardInputSchema, readDataFlag(flags));
     return {
-      data: await requireClient().put(`/animals/${id}/lost-card`, body),
+      data: await requireClient().put(pathOf(animalOperations.setLostCard, { id }), body),
       render: renderRecord
     };
   },
   "animals lost-card-off": async ({ args, flags, requireClient }) => {
     const id = requireArg(args, 0, "animal id");
     assertDestructiveAllowed(flags, `turn off the lost-pet card of ${id} (its printed QR stops working)`);
-    await requireClient().delete(`/animals/${id}/lost-card`);
+    await requireClient().delete(pathOf(animalOperations.removeLostCard, { id }));
     return { data: { ok: true, animalId: id }, render: renderRecord };
   },
   "animals acquisition": async ({ args, requireClient }) => ({
-    data: await requireClient().get(`/animals/${requireArg(args, 0, "animal id")}/acquisition`),
+    data: await requireClient().get(pathOf(animalOperations.acquisition, { id: requireArg(args, 0, "animal id") })),
     render: renderRecord
   }),
   "animals acquisition-plan": async ({ args, flags, requireClient }) => {
@@ -42891,7 +44553,7 @@ var HANDLERS = {
       ...pickUp ? { pickUpOn: pickUp } : {}
     });
     return {
-      data: await requireClient().post(`/animals/${id}/acquisition`, body),
+      data: await requireClient().post(pathOf(animalOperations.planAcquisition, { id }), body),
       render: renderRecord
     };
   },
@@ -42904,7 +44566,7 @@ var HANDLERS = {
       ...months !== undefined ? { quarantineMonths: Number(months) } : {}
     });
     return {
-      data: await requireClient().post(`/animals/${id}/arrived`, body),
+      data: await requireClient().post(pathOf(animalOperations.arrived, { id }), body),
       render: renderRecord
     };
   },
@@ -43537,7 +45199,7 @@ var HANDLERS = {
   "guest-lists overview": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "guest list id");
     return {
-      data: await requireClient().get(`/guest-lists/${id}/overview`),
+      data: await requireClient().get(pathOf(guestListOperations.overview, { id })),
       render: renderRecord
     };
   },
@@ -43582,7 +45244,9 @@ var HANDLERS = {
       throw usageError("seating-proposals list needs --list <guest list id>");
     parseInput(seatingProposalsQuerySchema, { guestListId: list });
     return {
-      data: await requireClient().get("/seating-proposals", { query: { guestListId: list } }),
+      data: await requireClient().get(pathOf(seatingProposalOperations.list), {
+        query: { guestListId: list }
+      }),
       render: renderRecord
     };
   },
@@ -43591,19 +45255,22 @@ var HANDLERS = {
       id: ulid3(),
       ...readDataFlag(flags)
     });
-    return { data: await requireClient().post("/seating-proposals", body), render: renderRecord };
+    return {
+      data: await requireClient().post(pathOf(seatingProposalOperations.propose), body),
+      render: renderRecord
+    };
   },
   "seating-proposals apply": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "proposal id");
     return {
-      data: await requireClient().post(`/seating-proposals/${id}/apply`, {}),
+      data: await requireClient().post(pathOf(seatingProposalOperations.apply, { id }), {}),
       render: renderRecord
     };
   },
   "seating-proposals dismiss": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "proposal id");
     return {
-      data: await requireClient().post(`/seating-proposals/${id}/dismiss`, {}),
+      data: await requireClient().post(pathOf(seatingProposalOperations.dismiss, { id }), {}),
       render: renderRecord
     };
   },
@@ -43654,14 +45321,14 @@ var HANDLERS = {
   "guest-lists thank-you": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "guest list id");
     return {
-      data: await requireClient().get(`/guest-lists/${id}/thank-you`),
+      data: await requireClient().get(pathOf(guestListOperations.thankYou, { id })),
       render: renderRecord
     };
   },
   "guest-lists export": async ({ args, flags, requireClient }) => {
     const id = requireArg(args, 0, "guest list id");
     const kind = parseInput(guestExportKindSchema, flagString(flags, "kind") ?? "venue");
-    const path = `/guest-lists/${id}/exports/${kind}`;
+    const path = pathOf(guestListOperations.export, { id, kind });
     if (kind === "floor-plan" || kind === "invitations") {
       const file = await requireClient().getBytes(path);
       const out = flagString(flags, "out") ?? basename2(file.name ?? `${kind}.pdf`);
@@ -43680,29 +45347,37 @@ var HANDLERS = {
       throw usageError("rsvp-links list needs --list <guest list id>");
     parseInput(rsvpLinksQuerySchema, { guestListId: list });
     return {
-      data: await requireClient().get("/rsvp-links", { query: { guestListId: list } }),
+      data: await requireClient().get(pathOf(rsvpLinkOperations.list), {
+        query: { guestListId: list }
+      }),
       render: renderRecord
     };
   },
   "rsvp-links create": async ({ flags, requireClient }) => {
     const body = parseInput(createRsvpLinksInputSchema, readDataFlag(flags));
-    return { data: await requireClient().post("/rsvp-links", body), render: renderRecord };
+    return {
+      data: await requireClient().post(pathOf(rsvpLinkOperations.mint), body),
+      render: renderRecord
+    };
   },
   "rsvp-links token": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "rsvp link id");
-    return { data: await requireClient().get(`/rsvp-links/${id}/token`), render: renderRecord };
+    return {
+      data: await requireClient().get(pathOf(rsvpLinkOperations.reveal, { id })),
+      render: renderRecord
+    };
   },
   "rsvp-links replace": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "rsvp link id");
     return {
-      data: await requireClient().post(`/rsvp-links/${id}/replace`, {}),
+      data: await requireClient().post(pathOf(rsvpLinkOperations.replace, { id }), {}),
       render: renderRecord
     };
   },
   "rsvp-links revoke": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "rsvp link id");
     return {
-      data: await requireClient().post(`/rsvp-links/${id}/revoke`, {}),
+      data: await requireClient().post(pathOf(rsvpLinkOperations.revoke, { id }), {}),
       render: renderRecord
     };
   },