@robbeverhelst/do 1.303.0 → 1.305.0

package/dist/do.js

@@ -4949,6 +4949,20 @@ var moneyRecurring = pgTable("money_recurring", {
   check("money_recurring_amount", sql`${t.expectedAmount} > 0`),
   check("money_recurring_business_share", sql`${t.businessShare} BETWEEN 0 AND 100`)
 ]);
+var moneySnapshotSource = pgEnum("money_snapshot_source", ["balance", "ledger", "manual"]);
+var moneySnapshots = pgTable("money_snapshots", {
+  id: text("id").primaryKey(),
+  tenantId: text("tenant_id").notNull().references(() => tenants.id),
+  accountId: text("account_id").notNull().references(() => moneyAccounts.id, { onDelete: "cascade" }),
+  month: char("month", { length: 7 }).notNull(),
+  value: numeric("value", { precision: 14, scale: 2 }).notNull(),
+  source: moneySnapshotSource("source").notNull().default("balance"),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (t) => [
+  unique("money_snapshots_account_month_key").on(t.tenantId, t.accountId, t.month),
+  check("money_snapshots_month", sql`${t.month} ~ '^[0-9]{4}-(0[1-9]|1[0-2])$'`)
+]);
 
 // ../../packages/schema/src/db/money-connections.ts
 var moneyConnectionStatus = pgEnum("money_connection_status", [
@@ -5632,6 +5646,18 @@ var foodWeekReads = pgTable("food_week_reads", {
   weekStart: text("week_start").notNull()
 }, (t) => [unique("food_week_reads_owner_week_uniq").on(t.tenantId, t.ownerUserId, t.weekStart)]);
 
+// ../../packages/schema/src/db/webhooks.ts
+var webhookSubscriptions = pgTable("webhook_subscriptions", {
+  id: text("id").primaryKey(),
+  tenantId: text("tenant_id").notNull().references(() => tenants.id),
+  url: text("url").notNull(),
+  events: text("events").array().notNull().default([]),
+  secret: text("secret").notNull(),
+  active: boolean("active").notNull().default(true),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (t) => [index("webhook_subscriptions_tenant_idx").on(t.tenantId)]);
+
 // ../../packages/schema/src/db/collaboration.ts
 var capability = pgEnum("collab_capability", ["view", "comment", "edit", "admin"]);
 var grantSubjectType = pgEnum("grant_subject_type", ["member", "role"]);
@@ -20509,6 +20535,21 @@ var collectionCoverBackfillResultSchema = object({
   found: number2().int().min(0),
   colored: number2().int().min(0).default(0)
 });
+function normalizeTag(raw) {
+  return raw.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function normalizeTags(raw) {
+  const seen = new Set;
+  const out = [];
+  for (const r of raw) {
+    const tag = normalizeTag(r);
+    if (!tag || seen.has(tag))
+      continue;
+    seen.add(tag);
+    out.push(tag);
+  }
+  return out;
+}
 var collectionSavedViewSchema = object({
   id: string2().min(1),
   name: string2().min(1),
@@ -20547,6 +20588,53 @@ var collectionLogResultSchema = object({
   item: collectionItemDetailSchema
 });
 
+// ../../packages/schema/src/contracts/list-filters.ts
+function csvList(item) {
+  return preprocess((raw) => (Array.isArray(raw) ? raw : [raw]).flatMap((v) => typeof v === "string" ? v.split(",") : [v]).map((v) => typeof v === "string" ? v.trim() : v).filter((v) => v !== ""), array(item).min(1));
+}
+var booleanQuerySchema = _enum2(["true", "false", "1", "0"]).transform((v) => v === "true" || v === "1");
+var instantQuerySchema = union([exports_iso.datetime({ offset: true }), exports_iso.date()]).transform((s) => new Date(s));
+var tagListSchema = csvList(string2().min(1)).transform((tags, ctx) => {
+  const normalized = normalizeTags(tags.map((t) => t.replace(/^#/, "")));
+  if (normalized.length === 0) {
+    ctx.addIssue({ code: "custom", message: "must name at least one tag" });
+    return NEVER;
+  }
+  return normalized;
+});
+function partyFilterSchema(party) {
+  return union([_enum2(["any", "none"]), party]);
+}
+var taskListQuerySchema = object({
+  areaId: ulidSchema.optional(),
+  projectId: ulidSchema.optional(),
+  status: csvList(taskStatusSchema).optional(),
+  tag: tagListSchema.optional(),
+  updatedSince: instantQuerySchema.optional(),
+  dueBefore: instantQuerySchema.optional(),
+  owner: partyFilterSchema(taskOwnerInputSchema).optional(),
+  waitingOn: partyFilterSchema(taskWaitingOnInputSchema).optional(),
+  completedSince: instantQuerySchema.optional(),
+  completedBefore: instantQuerySchema.optional(),
+  proposed: booleanQuerySchema.optional(),
+  ready: booleanQuerySchema.optional(),
+  drifted: booleanQuerySchema.optional()
+});
+var projectListQuerySchema = object({
+  areaId: ulidSchema.optional(),
+  status: csvList(projectStatusSchema).optional(),
+  updatedSince: instantQuerySchema.optional(),
+  dueBefore: instantQuerySchema.optional()
+});
+var habitListQuerySchema = object({
+  areaId: ulidSchema.optional(),
+  updatedSince: instantQuerySchema.optional(),
+  retired: _enum2(["true", "false"]).transform((v) => v === "true").optional()
+});
+var areaListQuerySchema = object({
+  archived: _enum2(["true", "false"]).transform((v) => v === "true").optional()
+});
+
 // ../../packages/schema/src/contracts/habit-sources.ts
 var habitSourceSchema = _enum2(["manual", "google_fit", "strava", "github"]);
 
@@ -24665,6 +24753,50 @@ var dayRecordUndoResultSchema = object({
 });
 var STATUS_QUARTER_MS = RECORD_ROUND_MINUTES * 60000;
 
+// ../../packages/schema/src/contracts/today.ts
+var occurrenceViewSchema = occurrenceSchema.extend({
+  title: string2(),
+  templateKind: _enum2(["task", "habit", "routine"]),
+  measurementType: habitMeasurementTypeSchema.nullable()
+});
+var todayResponseSchema = object({
+  from: exports_coerce.date(),
+  to: exports_coerce.date(),
+  scheduledTasks: array(taskViewSchema),
+  dueOccurrences: array(occurrenceViewSchema),
+  overdueTasks: array(taskViewSchema),
+  overdueOccurrences: array(occurrenceViewSchema)
+});
+var rolloverInputSchema = object({
+  taskIds: array(string2().min(1)).default([]),
+  occurrenceIds: array(string2().min(1)).default([]),
+  action: _enum2(["reschedule", "someday", "drop"]),
+  to: exports_coerce.date().optional()
+}).refine((v) => v.action !== "reschedule" || v.to !== undefined, {
+  message: "`to` is required when action is `reschedule`",
+  path: ["to"]
+});
+var rolloverResultSchema = object({
+  tasks: number2().int().nonnegative(),
+  occurrences: number2().int().nonnegative()
+});
+var fromEarlierQuerySchema = object({
+  from: instantQuerySchema.optional(),
+  areaId: ulidSchema.optional()
+});
+var fromEarlierResponseSchema = object({
+  from: exports_coerce.date(),
+  since: exports_coerce.date(),
+  laterThisWeek: exports_coerce.date(),
+  tasks: array(taskViewSchema)
+});
+var reviewDayStatSchema = object({
+  date: string2(),
+  completedTasks: number2().int().nonnegative(),
+  completedOccurrences: number2().int().nonnegative()
+});
+var reviewStatsSchema = array(reviewDayStatSchema);
+
 // ../../packages/schema/src/contracts/insights.ts
 var insightsActivityPointSchema = object({
   day: string2(),
@@ -25976,10 +26108,16 @@ var moneyTransactionViewSchema = moneyTransactionSchema.omit({ dedupHash: true }
     nodeId: ulidSchema,
     kind: moneyLinkKindSchema,
     title: string2(),
-    type: string2()
+    type: string2(),
+    warrantyEnds: keyDateDaySchema.nullable().default(null)
   })).default([]),
   recurring: string2().nullable().default(null),
-  contact: object({ id: ulidSchema, name: string2(), payments: number2().int().nonnegative() }).nullable().default(null),
+  contact: object({
+    id: ulidSchema,
+    name: string2(),
+    kind: _enum2(["person", "organization"]).default("person"),
+    payments: number2().int().nonnegative()
+  }).nullable().default(null),
   split: object({
     parts: number2().int().positive(),
     even: boolean3(),
@@ -27249,6 +27387,51 @@ var steamSyncResultSchema = object({
   games: array(steamGameSyncSchema)
 });
 
+// ../../packages/schema/src/contracts/money-net-worth.ts
+var amount5 = string2();
+var moneySnapshotSourceSchema = _enum2(moneySnapshotSource.enumValues);
+var moneyNetWorthQuerySchema = object({
+  scope: moneyBudgetScopeSchema.optional(),
+  months: exports_coerce.number().int().min(2).max(60).optional()
+});
+var moneyNetWorthPointSchema = object({
+  month: moneyMonthSchema,
+  total: amount5.nullable(),
+  have: amount5.nullable(),
+  owe: amount5.nullable()
+});
+var moneyNetWorthAccountSchema = object({
+  accountId: ulidSchema,
+  title: string2(),
+  kind: moneyAccountKindSchema,
+  visibility: _enum2(NODE_VISIBILITY_VALUES),
+  currency: string2(),
+  value: amount5,
+  source: moneySnapshotSourceSchema,
+  month: moneyMonthSchema
+});
+var moneyNetWorthSchema = object({
+  scope: moneyBudgetScopeSchema,
+  month: moneyMonthSchema,
+  total: amount5,
+  have: amount5,
+  owe: amount5,
+  points: array(moneyNetWorthPointSchema),
+  accounts: array(moneyNetWorthAccountSchema)
+});
+var setMoneyNetWorthValueInputSchema = object({
+  accountId: ulidSchema,
+  value: moneyAmountSchema,
+  month: moneyMonthSchema.optional()
+}).strict();
+var moneySnapshotSchema = object({
+  id: ulidSchema,
+  accountId: ulidSchema,
+  month: moneyMonthSchema,
+  value: amount5,
+  source: moneySnapshotSourceSchema
+});
+
 // ../../packages/schema/src/contracts/money-splits.ts
 var moneyPartySchema = union([
   object({ userId: ulidSchema }).strict(),
@@ -27990,7 +28173,8 @@ var GUEST_EXPORT_KINDS = [
   "floor-plan",
   "church",
   "answers",
-  "invitations"
+  "invitations",
+  "printer"
 ];
 var guestExportKindSchema = _enum2(GUEST_EXPORT_KINDS);
 var thankYouGiftSchema = object({
@@ -28576,6 +28760,209 @@ function scopeGranted(granted, required) {
   return granted.includes(FULL_ACCESS_SCOPE);
 }
 
+// ../../packages/schema/src/net/ssrf.ts
+var BLOCKED_HOST_SUFFIXES = [".internal", ".local", ".localhost"];
+var BLOCKED_HOSTNAMES = new Set(["localhost"]);
+function parseIpv4(host) {
+  const parts = host.split(".");
+  if (parts.length !== 4)
+    return null;
+  let value = 0;
+  for (const part of parts) {
+    if (!/^\d{1,3}$/.test(part))
+      return null;
+    const octet = Number(part);
+    if (octet > 255)
+      return null;
+    value = value * 256 + octet;
+  }
+  return value >>> 0;
+}
+function isBlockedIpv4(ip) {
+  const inRange = (base, bits) => {
+    const baseIp = parseIpv4(base);
+    if (baseIp === null)
+      return false;
+    const mask = bits === 0 ? 0 : 4294967295 << 32 - bits >>> 0;
+    return (ip & mask) === (baseIp & mask);
+  };
+  return inRange("0.0.0.0", 8) || inRange("10.0.0.0", 8) || inRange("100.64.0.0", 10) || inRange("127.0.0.0", 8) || inRange("169.254.0.0", 16) || inRange("172.16.0.0", 12) || inRange("192.0.0.0", 24) || inRange("192.0.2.0", 24) || inRange("192.168.0.0", 16) || inRange("198.18.0.0", 15) || inRange("224.0.0.0", 4) || inRange("240.0.0.0", 4);
+}
+function parseIpv6(host) {
+  let text = host;
+  const zone = text.indexOf("%");
+  if (zone !== -1)
+    text = text.slice(0, zone);
+  if (!text.includes(":"))
+    return null;
+  const lastColon = text.lastIndexOf(":");
+  const tail = text.slice(lastColon + 1);
+  if (tail.includes(".")) {
+    const v4 = parseIpv4(tail);
+    if (v4 === null)
+      return null;
+    const hex = `${(v4 >>> 16 & 65535).toString(16)}:${(v4 & 65535).toString(16)}`;
+    text = text.slice(0, lastColon + 1) + hex;
+  }
+  const halves = text.split("::");
+  if (halves.length > 2)
+    return null;
+  const toGroups = (segment) => {
+    if (segment === "")
+      return [];
+    const out = [];
+    for (const g of segment.split(":")) {
+      if (!/^[0-9a-fA-F]{1,4}$/.test(g))
+        return null;
+      out.push(Number.parseInt(g, 16));
+    }
+    return out;
+  };
+  const head = toGroups(halves[0] ?? "");
+  if (head === null)
+    return null;
+  let groups;
+  if (halves.length === 2) {
+    const back = toGroups(halves[1] ?? "");
+    if (back === null)
+      return null;
+    const fill = 8 - head.length - back.length;
+    if (fill < 0)
+      return null;
+    groups = [...head, ...Array(fill).fill(0), ...back];
+  } else {
+    groups = head;
+  }
+  return groups.length === 8 ? groups : null;
+}
+function isBlockedIpv6(groups) {
+  const isZero = groups.every((g) => g === 0);
+  if (isZero)
+    return true;
+  if (groups.slice(0, 7).every((g) => g === 0) && groups[7] === 1)
+    return true;
+  const isV4Mapped = groups.slice(0, 5).every((g) => g === 0) && groups[5] === 65535;
+  const isV4Compat = groups.slice(0, 6).every((g) => g === 0);
+  if (isV4Mapped || isV4Compat) {
+    const v4 = ((groups[6] ?? 0) << 16 | (groups[7] ?? 0)) >>> 0;
+    return isBlockedIpv4(v4);
+  }
+  const first = groups[0] ?? 0;
+  if ((first & 65024) === 64512)
+    return true;
+  if ((first & 65472) === 65152)
+    return true;
+  if ((first & 65280) === 65280)
+    return true;
+  return false;
+}
+function isBlockedIp(host) {
+  const bare = host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
+  const v4 = parseIpv4(bare);
+  if (v4 !== null)
+    return isBlockedIpv4(v4);
+  const v6 = parseIpv6(bare);
+  if (v6 !== null)
+    return isBlockedIpv6(v6);
+  return false;
+}
+
+class BlockedWebhookUrlError extends Error {
+  constructor(reason) {
+    super(`webhook url rejected: ${reason}`);
+    this.name = "BlockedWebhookUrlError";
+  }
+}
+function bareHost(hostname) {
+  return hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+}
+function isInternalHost(hostname) {
+  const host = hostname.toLowerCase();
+  if (BLOCKED_HOSTNAMES.has(host) || BLOCKED_HOST_SUFFIXES.some((s) => host.endsWith(s))) {
+    return true;
+  }
+  return isBlockedIp(host);
+}
+function assertSafeEgressUrl(rawUrl, policy) {
+  let url;
+  try {
+    url = new URL(rawUrl);
+  } catch {
+    throw policy.fail("not a valid URL");
+  }
+  if (!policy.protocols.includes(url.protocol)) {
+    const allowsHttp = policy.protocols.includes("http:");
+    throw policy.fail(`only ${allowsHttp ? "http(s)" : "https"} URLs are allowed`);
+  }
+  if (url.username || url.password) {
+    throw policy.fail("credentials in the URL are not allowed");
+  }
+  if (isInternalHost(url.hostname)) {
+    const kind = isBlockedIp(url.hostname) ? "a private or reserved address" : "internal";
+    throw policy.fail(`host '${url.hostname}' is ${kind}`);
+  }
+  return url;
+}
+function webhookUrlAllowlistFromEnv() {
+  const env = globalThis.process?.env;
+  const raw = env?.WEBHOOK_URL_ALLOWLIST;
+  if (!raw)
+    return [];
+  return raw.split(",").map((h) => h.trim().toLowerCase()).filter(Boolean);
+}
+function isAllowlistedHost(hostname, allowedHosts) {
+  const host = hostname.toLowerCase();
+  const bare = bareHost(host);
+  return allowedHosts.some((h) => h === host || h === bare);
+}
+function assertSafeWebhookUrl(rawUrl, opts = {}) {
+  let url;
+  try {
+    url = new URL(rawUrl);
+  } catch {
+    throw new BlockedWebhookUrlError("not a valid URL");
+  }
+  const allowedHosts = opts.allowedHosts ?? webhookUrlAllowlistFromEnv();
+  if (isAllowlistedHost(url.hostname, allowedHosts)) {
+    return url;
+  }
+  return assertSafeEgressUrl(rawUrl, {
+    protocols: ["https:"],
+    fail: (reason) => new BlockedWebhookUrlError(reason)
+  });
+}
+
+// ../../packages/schema/src/contracts/webhooks.ts
+var webhookUrlSchema = string2().superRefine((value, ctx) => {
+  try {
+    assertSafeWebhookUrl(value);
+  } catch (err) {
+    ctx.addIssue({
+      code: ZodIssueCode.custom,
+      message: err instanceof BlockedWebhookUrlError ? err.message : "invalid webhook url"
+    });
+  }
+});
+var webhookEventSchema = string2().min(1).max(120).regex(/^[a-z0-9]+(\.[a-z0-9]+)+$/, "must be a dotted event name like 'task.created'");
+var webhookSubscriptionSchema = createSelectSchema(webhookSubscriptions, {
+  events: array(webhookEventSchema),
+  createdAt: exports_coerce.date(),
+  updatedAt: exports_coerce.date()
+});
+var webhookSubscriptionPublicSchema = webhookSubscriptionSchema.omit({ secret: true });
+var createWebhookSubscriptionInputSchema = createInsertSchema(webhookSubscriptions, {
+  url: webhookUrlSchema,
+  events: array(webhookEventSchema).min(1),
+  secret: string2().min(16).max(200).optional()
+}).omit({ id: true, tenantId: true, active: true, createdAt: true, updatedAt: true }).strict();
+var createWebhookSubscriptionResultSchema = webhookSubscriptionPublicSchema.extend({
+  secret: string2()
+});
+var updateWebhookSubscriptionInputSchema = createUpdateSchema(webhookSubscriptions, {
+  url: webhookUrlSchema.optional(),
+  events: array(webhookEventSchema).min(1).optional()
+}).omit({ id: true, tenantId: true, secret: true, createdAt: true, updatedAt: true }).strict();
+
 // ../../packages/schema/src/contracts/roles.ts
 var permissionSetSchema = createSelectSchema(permissionSets, {
   createdAt: exports_coerce.date(),
@@ -29624,6 +30011,37 @@ function toCollectionTypeSummary(config) {
 }
 var COLLECTION_TYPE_SUMMARIES = COLLECTION_TYPE_LIST.map(toCollectionTypeSummary);
 
+// ../../packages/schema/src/operations/define.ts
+function defineOperations(table) {
+  return table;
+}
+var PUBLIC_API_PREFIX = "/api/v1";
+function pathOf(op, params = {}) {
+  return op.path.replace(/\{([A-Za-z0-9_]+)\}/g, (_, name) => {
+    const value = params[name];
+    if (value === undefined)
+      throw new Error(`pathOf: no value for {${name}} in ${op.path}`);
+    return encodeURIComponent(value);
+  });
+}
+function routeOf(op) {
+  return `${op.method.toUpperCase()} ${PUBLIC_API_PREFIX}${op.path}`;
+}
+
+// ../../packages/schema/src/operations/agents.ts
+var agentOperations = defineOperations({
+  list: {
+    method: "get",
+    path: "/agents",
+    scopes: ["agents:read"],
+    tag: "Agents",
+    summary: "List agents",
+    description: "The Space's live Agents (`id`, `name`), oldest first, to resolve an Agent by name.",
+    status: 200,
+    response: { description: "The Space's Agents.", list: true }
+  }
+});
+
 // ../../packages/schema/src/operations/crud.ts
 function crudOperations(r) {
   const base = `/${r.segment}`;
@@ -29695,22 +30113,520 @@ function crudOperations(r) {
   };
 }
 
-// ../../packages/schema/src/operations/define.ts
-function defineOperations(table) {
-  return table;
-}
-var PUBLIC_API_PREFIX = "/api/v1";
-function pathOf(op, params = {}) {
-  return op.path.replace(/\{([A-Za-z0-9_]+)\}/g, (_, name) => {
-    const value = params[name];
-    if (value === undefined)
-      throw new Error(`pathOf: no value for {${name}} in ${op.path}`);
-    return encodeURIComponent(value);
-  });
-}
-function routeOf(op) {
-  return `${op.method.toUpperCase()} ${PUBLIC_API_PREFIX}${op.path}`;
-}
+// ../../packages/schema/src/operations/block-templates.ts
+var crud = crudOperations({
+  segment: "block-templates",
+  tag: "Calendar",
+  noun: "block template",
+  read: "calendar:read",
+  write: "calendar:write",
+  create: createBlockTemplateInputSchema,
+  update: updateBlockTemplateInputSchema,
+  listQuery: []
+});
+var blockTemplateOperations = defineOperations({
+  ...crud,
+  create: { ...crud.create, webhook: undefined },
+  update: { ...crud.update, webhook: undefined },
+  remove: { ...crud.remove, webhook: undefined },
+  week: {
+    method: "get",
+    path: "/block-templates/week",
+    scopes: ["calendar:read"],
+    tag: "Calendar",
+    summary: "Lay out a week from the block templates",
+    description: "Every life block the key's member's templates lay out for the week starting `start` (a Monday), in time order, on their wall clock: `{ templateId, lifeKind, title, startAt, endAt, routineId }`. Writes nothing; this is what Sunday planning proposes.",
+    query: [{ name: "start", description: "The week's Monday (YYYY-MM-DD).", format: "date" }],
+    querySchema: blockTemplateWeekQuerySchema,
+    status: 200,
+    response: { description: "The week's blocks." },
+    errors: { 400: true }
+  },
+  defaults: {
+    method: "post",
+    path: "/block-templates/defaults",
+    scopes: ["calendar:write"],
+    tag: "Calendar",
+    summary: "Seed the default week",
+    description: "Give a member with no block templates the default week: sleep, the morning, reading, two work blocks, lunch and dinner with clean-up, a buffer, a free evening and a wind-down. A member who has templates keeps them; the call then returns them unchanged.",
+    status: 200,
+    response: { description: "The member's templates." }
+  }
+});
+
+// ../../packages/schema/src/operations/collection-upkeep.ts
+var collectionUpkeepOperations = defineOperations({
+  list: {
+    method: "get",
+    path: "/collection/{id}/upkeep",
+    scopes: ["collections:read"],
+    tag: "Collection",
+    summary: "List an asset's upkeep and repairs",
+    description: "The Tasks that look after this asset: `upkeep` (`maintains` \u2014 usually recurring, e.g. every 4 weeks from the last time) and `repairs` (one-off fix-it Tasks), open ones first. 404 unless the item is a live `asset`. Returns `{ itemId, upkeep, repairs }`.",
+    status: 200,
+    response: { description: "The asset's Tasks." },
+    errors: { 404: true }
+  },
+  link: {
+    method: "post",
+    path: "/collection/{id}/upkeep",
+    scopes: ["collections:write"],
+    tag: "Collection",
+    summary: "Tie a Task to an asset",
+    description: 'Tie a Task in the Space to this asset as its upkeep (`kind: "maintains"`, the default) or a repair (`"repairs"`). Make the Task (its recurrence, Place, Area) through the tasks API first. When a tied Task is finished \u2014 a one-off marked done, or one occurrence of a recurring one checked off \u2014 the asset gets a `service` / `repair` Entry with the Task on it, once per day, and upkeep moves its `lastServicedAt` forward. Returns the asset\'s Tasks.',
+    body: linkAssetTaskInputSchema,
+    status: 201,
+    response: { description: "The asset's Tasks." },
+    errors: { 400: true, 404: true }
+  },
+  unlink: {
+    method: "delete",
+    path: "/collection/{id}/upkeep/{taskId}",
+    pathParams: { taskId: "The Task's ULID." },
+    scopes: ["collections:write"],
+    tag: "Collection",
+    summary: "Untie a Task from an asset",
+    description: "Untie the Task from this asset; the Task itself stays. Returns the asset's Tasks.",
+    status: 200,
+    response: { description: "The asset's Tasks." },
+    errors: { 404: true }
+  }
+});
+
+// ../../packages/schema/src/operations/google-contacts.ts
+var googleContactsOperations = defineOperations({
+  list: {
+    method: "get",
+    path: "/people/google-contacts",
+    scopes: ["contacts:read"],
+    tag: "People",
+    summary: "Your Google Contacts, to pick from",
+    description: "The key's member's Google Contacts link (`status`: `available`, `mode`, `connected`, `account`) and the people in it matching `q` (a name or an email; everyone without), each with `resourceName`, `name`, `emails`, `phones`, `birthday` (`yearKnown: false` for a day and month only), the contact in do they'd merge into (`match`: by `email`, `phone` or a unique `name`; never a company) and what importing adds (`adds`). Not connected: no candidates. Connecting needs a browser (People \u2192 Import). A key with no member is a 403. Off until `GOOGLE_CONTACTS_API` is `fake` or `live`.",
+    query: [{ name: "q", description: "A name or email to narrow to." }],
+    querySchema: googleContactsQuerySchema,
+    status: 200,
+    response: { description: "The link and the candidates." },
+    errors: { 403: "Not a member's key." }
+  },
+  import: {
+    method: "post",
+    path: "/people/google-contacts/import",
+    scopes: ["contacts:write"],
+    tag: "People",
+    summary: "Import the people you picked from Google Contacts",
+    description: "Only the picked people (`resourceNames`, Google's `people/\u2026` ids, at most 200). Each merges into the contact it matches and fills in only a missing email, phone or birthday (a key date that becomes a Task), else becomes a new contact, so importing twice never duplicates anyone. Returns `{ created, merged (with what each got: added), missing }`. Not connected is a 409; off until `GOOGLE_CONTACTS_API` is set (403).",
+    body: importGoogleContactsInputSchema,
+    status: 200,
+    response: { description: "What the import did." },
+    errors: {
+      400: true,
+      403: "Off, or not a member's key.",
+      409: "Google Contacts isn't connected (or asks to sign in again)."
+    }
+  }
+});
+
+// ../../packages/schema/src/operations/google-health.ts
+var googleHealthOperations = defineOperations({
+  status: {
+    method: "get",
+    path: "/health/google-health",
+    scopes: ["health:read"],
+    tag: "Health",
+    summary: "Get the Google Health link",
+    description: "The key's member's Google Health link (connected in the app, Settings \u2192 Health): `available` and `mode` (off \xB7 fake \xB7 live, the server's switch), `connected`, the Google `account`, `lastSyncAt` and each resource's (sleep, resting_heart_rate, hrv, steps, workouts), and `failure` (`reauth` \xB7 `not_linked` \xB7 `unavailable` \xB7 `other`, with a title and a hint) when the sync stopped, and `nutrition` (writing the member's food back to Google Health, opt-in in the app: `enabled`, `granted` (the link has the write scope), `lastWrittenDay`, `failure`). Never another member's.",
+    status: 200,
+    response: { description: "The link's status." },
+    errors: { 403: true }
+  },
+  sync: {
+    method: "post",
+    path: "/health/google-health/sync",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Sync Google Health now",
+    description: "As the key's member, one sync of their Google Health, as the 07:30 morning sync does: last night's sleep (on the wake day, joining the Sleep and Bedtime Metrics), the day's resting heart rate and HRV, steps and workouts (joining the sessions) onto their own ledger, nothing twice. Returns written and skipped per resource and the status after it; a sync that stops answers 200 with `status.failure`. 409 before the member connected, 403 while the server has Google Health off.",
+    status: 200,
+    response: { description: "What came in, and the status after it." },
+    errors: { 403: true, 409: true }
+  }
+});
+
+// ../../packages/schema/src/operations/guest-list-events.ts
+var crud2 = crudOperations({
+  segment: "guest-list-events",
+  tag: "Guests",
+  noun: "guest list event",
+  read: "contacts:read",
+  write: "contacts:write",
+  create: createGuestListEventInputSchema,
+  update: updateGuestListEventInputSchema,
+  listQuery: [{ name: "guestListId", description: "The guest list (required)." }],
+  listQuerySchema: guestListEventsQuerySchema
+});
+var guestListEventOperations = defineOperations({
+  ...crud2,
+  create: { ...crud2.create, webhook: "guest.event.created" },
+  update: { ...crud2.update, webhook: "guest.event.updated" },
+  remove: { ...crud2.remove, webhook: "guest.event.deleted" }
+});
+
+// ../../packages/schema/src/operations/guest-tables.ts
+var guestTableOperations = defineOperations({
+  ...crudOperations({
+    segment: "guest-tables",
+    tag: "Guests",
+    noun: "guest table",
+    read: "contacts:read",
+    write: "contacts:write",
+    create: createGuestTableInputSchema,
+    update: updateGuestTableInputSchema,
+    listQuery: [{ name: "guestListId", description: "The guest list (required)." }],
+    listQuerySchema: guestTablesQuerySchema
+  })
+});
+
+// ../../packages/schema/src/operations/guests.ts
+var guestOperations = defineOperations({
+  ...crudOperations({
+    segment: "guests",
+    tag: "Guests",
+    noun: "guest",
+    read: "contacts:read",
+    write: "contacts:write",
+    create: createGuestInputSchema,
+    update: updateGuestInputSchema,
+    listQuery: [
+      { name: "guestListId", description: "Only this guest list's guests." },
+      { name: "contactId", description: "Only this contact's guest rows." },
+      { name: "state", description: "`yes`, `no`, `maybe` or `waiting`: their overall answer." }
+    ],
+    listQuerySchema: guestsQuerySchema
+  }),
+  sent: {
+    method: "post",
+    path: "/guests/sent",
+    scopes: ["contacts:write"],
+    tag: "Guests",
+    summary: "Stamp save-the-dates or invitations as sent",
+    description: "Stamps `saveTheDateAt` (`what: save_the_date`) or `inviteSentAt` (`what: invite`) on every guest in `guestIds`, at `at` or now. Returns the guests; fires `guest.sent`.",
+    body: markGuestsSentInputSchema,
+    status: 200,
+    response: { description: "The stamped guests." },
+    errors: { 400: true, 404: true },
+    webhook: "guest.sent"
+  }
+});
+
+// ../../packages/schema/src/operations/habits.ts
+var habitListQuery = habitListQuerySchema.extend(paginationQuerySchema.shape);
+var habitOperations = defineOperations({
+  list: {
+    method: "get",
+    path: "/habits",
+    scopes: ["habits:read"],
+    tag: "Habits",
+    summary: "List habits",
+    description: "Every growing habit (with streaks) in the Space, oldest first. `retired=true` lists the Grown shelf instead: the retired habits, history kept.",
+    query: [
+      { name: "areaId", description: "Only rows in this Area (ULID)." },
+      {
+        name: "updatedSince",
+        description: "Only rows whose `updatedAt` is at or after this instant \u2014 an ISO 8601 datetime with offset, or a bare `YYYY-MM-DD` (UTC midnight).",
+        format: "date-time"
+      },
+      {
+        name: "retired",
+        description: "`true` lists the retired (Grown) habits instead of the growing ones.",
+        enum: ["true", "false"]
+      }
+    ],
+    querySchema: habitListQuery,
+    paginated: true,
+    status: 200,
+    response: { description: "The Space's habits." }
+  },
+  today: {
+    method: "get",
+    path: "/habits/today",
+    scopes: ["habits:read"],
+    tag: "Habits",
+    summary: "What's left today",
+    description: "\"What's left?\" (#866): the habits due on the key's member's day (their saved time zone), already filtered by schedule, grouped by part of day (morning, midday, evening, anytime). Each says its value today, `done`/`open`/`skipped` (never overdue: habits don't carry over), the week for an N-per-week habit, and its last check-in (`by` names the Agent). Also today's routines with how many steps are done. Quit habits are left out.",
+    status: 200,
+    response: { description: "Today's habits and routines." },
+    operationId: "habits_today"
+  },
+  getAway: {
+    method: "get",
+    path: "/habits/away",
+    scopes: ["habits:read"],
+    tag: "Habits",
+    summary: "Get away state",
+    description: "The Space's \"Away until \u2026\": `{ until }` while away (the day you're back, YYYY-MM-DD), else `{ until: null }`.",
+    status: 200,
+    response: { description: "The away state." }
+  },
+  setAway: {
+    method: "put",
+    path: "/habits/away",
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Set away",
+    description: '"Away till Monday": every habit rests until `until` (the day you\'re back, after today): off Now, no push, streaks and plants wait. `until: null` comes back now. Tasks and events carry on. Fires `habit.updated`.',
+    body: awayInputSchema,
+    status: 200,
+    response: { description: "The away state." },
+    errors: { 400: true },
+    webhook: "habit.updated"
+  },
+  get: {
+    method: "get",
+    path: "/habits/{id}",
+    scopes: ["habits:read"],
+    tag: "Habits",
+    summary: "Get a habit",
+    description: "One habit with its streak + heatmap.",
+    status: 200,
+    response: { description: "The habit." },
+    errors: { 404: true }
+  },
+  create: {
+    method: "post",
+    path: "/habits",
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Create a habit",
+    description: "Create a habit; fires `habit.created`.",
+    body: createHabitInputSchema,
+    status: 201,
+    response: { description: "The created habit." },
+    errors: { 400: true },
+    webhook: "habit.created"
+  },
+  update: {
+    method: "patch",
+    path: "/habits/{id}",
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Update a habit",
+    description: "Patch a habit; fires `habit.updated`.",
+    body: updateHabitInputSchema,
+    status: 200,
+    response: { description: "The updated habit." },
+    errors: {
+      400: true,
+      404: true
+    },
+    webhook: "habit.updated"
+  },
+  remove: {
+    method: "delete",
+    path: "/habits/{id}",
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Archive a habit",
+    description: "Soft-delete a habit; fires `habit.deleted`.",
+    status: 204,
+    response: { description: "Archived." },
+    errors: { 404: true },
+    webhook: "habit.deleted"
+  },
+  checkInByTitle: {
+    method: "post",
+    path: "/habits/check-in",
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Check in a habit by title",
+    description: 'Check in the habit whose `title` or one of whose aliases is this (case-insensitive) \u2014 "wake", "did my run", "meditated". `value` defaults to 1. `mode: "add"` (default) logs it on top of the day ("12 pages"); `mode: "set"` makes it the day\'s total ("read 40 total") by writing one entry with the difference, keeping earlier check-ins (amount habits only, else 400). `occurredAt` back-dates it: an instant, or a `YYYY-MM-DD` member\'s day (noon in their zone); `set` works on the member\'s day it lands in. Several matching habits are a 409 with `error.code: "ambiguous_habit"` and `error.details.candidates` (`id`, `title`, `aliases`) to ask which; none is a 404 naming close titles; a habit counted from an ingest (Google Fit, Strava, GitHub) is a 409 \u2014 it checks itself in. An Agent\'s key records an `agent` check-in naming the Agent. `note` puts a short note on the check-in ("drill done, felt heavy" \u2192 `note: "felt heavy"`); a `set` that changes nothing puts it on the day\'s latest check-in. The refreshed habit\'s `lastCheckIn.id` is the entry, for adding a note later. Returns the refreshed habit; fires `habit.updated`.',
+    body: habitCheckInByTitleInputSchema,
+    status: 201,
+    response: { description: "The refreshed habit." },
+    errors: {
+      400: true,
+      404: true,
+      409: "Several habits answer to the title (with the candidates), or it is counted from an ingest."
+    },
+    webhook: "habit.updated"
+  },
+  addAlias: {
+    method: "post",
+    path: "/habits/{id}/aliases",
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Add a habit alias",
+    description: 'Add another name a check-in by title matches ("wake" for "Wake up by 07:00"); one already there (ignoring case) is a no-op, at most 12. Returns the refreshed habit; fires `habit.updated`.',
+    body: habitAliasInputSchema,
+    status: 201,
+    response: { description: "The refreshed habit." },
+    errors: {
+      400: true,
+      404: true
+    },
+    webhook: "habit.updated"
+  },
+  removeAlias: {
+    method: "delete",
+    path: "/habits/{id}/aliases/{alias}",
+    pathParams: { alias: "The alias to drop (ignoring case)." },
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Remove a habit alias",
+    description: "Drop an alias; 404 when the habit doesn't have it. Returns the refreshed habit; fires `habit.updated`.",
+    status: 200,
+    response: { description: "The refreshed habit." },
+    errors: { 404: true },
+    webhook: "habit.updated"
+  },
+  listCheckIns: {
+    method: "get",
+    path: "/habits/{id}/check-ins",
+    scopes: ["habits:read"],
+    tag: "Habits",
+    summary: "List a habit's check-ins",
+    description: "A page of the habit's check-ins, newest first; pass the oldest one's `occurredAt` as `before` for the next page.",
+    query: [
+      { name: "before", description: "Only check-ins before this instant (ISO 8601)." },
+      { name: "limit", description: "Page size, 1\u2013200 (default 50).", type: "integer" }
+    ],
+    querySchema: habitEntriesQuerySchema,
+    status: 200,
+    response: { description: "The check-ins." },
+    errors: { 404: true }
+  },
+  checkIn: {
+    method: "post",
+    path: "/habits/{id}/check-ins",
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Check in",
+    description: "Record a check-in, with an optional short `note`; fires `habit.updated` with the refreshed streak. A habit counted from an ingest (`source` other than `manual`) answers 409.",
+    body: createHabitEntryInputSchema,
+    status: 201,
+    response: { description: "The refreshed habit." },
+    errors: {
+      400: true,
+      404: true
+    },
+    webhook: "habit.updated",
+    operationId: "check_in_habit"
+  },
+  skip: {
+    method: "post",
+    path: "/habits/{id}/skip",
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Skip a habit",
+    description: '"Skip gym today": a neutral rest day (a `skip` entry, value 0), never a miss. The streak treats the period as neutral and spends no grace. `date` (YYYY-MM-DD) defaults to today; an optional `note` says why ("Dentist"). Skipping a skipped day changes nothing but its note. Undo by deleting the skip entry like a check-in. Returns the refreshed habit; fires `habit.updated`.',
+    body: habitSkipInputSchema,
+    status: 201,
+    response: { description: "The refreshed habit." },
+    errors: {
+      400: true,
+      404: true
+    },
+    webhook: "habit.updated"
+  },
+  pause: {
+    method: "post",
+    path: "/habits/{id}/pause",
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Pause a habit",
+    description: '"Pause gym till the 26th": the habit rests until `until` (the day it\'s back, after today): off Now, no push, streak and plant wait. Pausing a paused habit moves its end. Returns the refreshed habit with `pause`; fires `habit.updated`.',
+    body: habitPauseInputSchema,
+    status: 201,
+    response: { description: "The refreshed habit." },
+    errors: {
+      400: true,
+      404: true
+    },
+    webhook: "habit.updated"
+  },
+  resume: {
+    method: "post",
+    path: "/habits/{id}/resume",
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Resume a habit",
+    description: "End a habit's pause: it's back today. The rest so far stays neutral. Returns the refreshed habit; fires `habit.updated`.",
+    status: 201,
+    response: { description: "The refreshed habit." },
+    errors: { 404: true },
+    webhook: "habit.updated"
+  },
+  retire: {
+    method: "post",
+    path: "/habits/{id}/retire",
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Retire a habit",
+    description: '"I\'m done with the cold showers habit": the habit moves to the Grown shelf with its plant in bloom and keeps its history. It leaves Now and Today, sends no push, takes no check-in by title and is never due; Progress keeps its past. Returns the refreshed habit with `retiredAt`; undo with `/unretire`. Fires `habit.updated`.',
+    status: 201,
+    response: { description: "The refreshed habit." },
+    errors: { 404: true },
+    webhook: "habit.updated"
+  },
+  unretire: {
+    method: "post",
+    path: "/habits/{id}/unretire",
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Bring a habit back",
+    description: "Bring a grown (retired) habit back: it's growing again from today, its history intact. Returns the refreshed habit; fires `habit.updated`.",
+    status: 201,
+    response: { description: "The refreshed habit." },
+    errors: { 404: true },
+    webhook: "habit.updated"
+  },
+  updateCheckIn: {
+    method: "patch",
+    path: "/habits/{id}/check-ins/{entryId}",
+    pathParams: { entryId: "The check-in entry's ULID." },
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Note a check-in",
+    description: "Edit a check-in afterwards: set, replace or clear (`null` or blank) its short `note` (at most 280 characters). The amount and time stay; undo a wrong check-in instead. Returns the check-in; fires `habit.updated`.",
+    body: updateHabitEntryInputSchema,
+    status: 200,
+    response: { description: "The check-in, with its note." },
+    errors: {
+      400: true,
+      404: true
+    },
+    webhook: "habit.updated",
+    operationId: "note_habit_check_in"
+  },
+  removeCheckIn: {
+    method: "delete",
+    path: "/habits/{id}/check-ins/{entryId}",
+    pathParams: { entryId: "The check-in entry's ULID." },
+    scopes: ["habits:write"],
+    tag: "Habits",
+    summary: "Undo a check-in",
+    description: "Delete a check-in; fires `habit.updated`.",
+    status: 200,
+    response: { description: "The refreshed habit." },
+    errors: { 404: true },
+    webhook: "habit.updated",
+    operationId: "undo_habit_check_in"
+  }
+});
+
+// ../../packages/schema/src/operations/households.ts
+var householdOperations = defineOperations({
+  ...crudOperations({
+    segment: "households",
+    tag: "Guests",
+    noun: "household",
+    read: "contacts:read",
+    write: "contacts:write",
+    create: createHouseholdInputSchema,
+    update: updateHouseholdInputSchema,
+    listQuery: [{ name: "contactId", description: "Only the households this contact is in." }],
+    listQuerySchema: householdsQuerySchema
+  })
+});
 
 // ../../packages/schema/src/operations/inventory-items.ts
 var inventoryItemOperations = defineOperations({
@@ -29727,6 +30643,75 @@ var inventoryItemOperations = defineOperations({
   })
 });
 
+// ../../packages/schema/src/operations/mail-campaigns.ts
+var pathParams = { id: "The campaign's ULID." };
+var mailCampaignOperations = defineOperations({
+  list: {
+    method: "get",
+    path: "/mail-campaigns",
+    scopes: ["contacts:read"],
+    tag: "Guests",
+    summary: "List a guest list's mail campaigns",
+    description: "Its drafted and sent mails, newest first.",
+    query: [{ name: "guestListId", description: "The guest list (required)." }],
+    querySchema: mailCampaignsQuerySchema,
+    status: 200,
+    response: { description: "The campaigns." },
+    errors: { 400: true }
+  },
+  create: {
+    method: "post",
+    path: "/mail-campaigns",
+    scopes: ["contacts:write"],
+    tag: "Guests",
+    summary: "Draft a mail campaign",
+    description: "A draft for a guest list's households: its `kind` (`message`, `save_the_date` or `invitation`), the template's `data` (the copy per language, Dutch required) and an optional reply address. A key can draft, preview and edit, never test or send: only a member's own session sends.",
+    body: createMailCampaignInputSchema,
+    status: 201,
+    response: { description: "The draft." },
+    errors: { 400: true, 404: true }
+  },
+  get: {
+    method: "get",
+    path: "/mail-campaigns/{id}",
+    pathParams,
+    scopes: ["contacts:read"],
+    tag: "Guests",
+    summary: "Get a mail campaign",
+    description: "",
+    status: 200,
+    response: { description: "The campaign." },
+    errors: { 404: true }
+  },
+  update: {
+    method: "patch",
+    path: "/mail-campaigns/{id}",
+    pathParams,
+    scopes: ["contacts:write"],
+    tag: "Guests",
+    summary: "Edit a draft",
+    description: "Change its kind, data or reply address. Any edit makes the last test stale: a new test is needed before it can be sent.",
+    body: updateMailCampaignInputSchema,
+    status: 200,
+    response: { description: "The draft." },
+    errors: { 400: true, 404: true }
+  },
+  preview: {
+    method: "get",
+    path: "/mail-campaigns/{id}/preview",
+    pathParams,
+    scopes: ["contacts:read"],
+    tag: "Guests",
+    summary: "Preview a mail campaign",
+    description: "The mail as a household would get it in one language (`nl` by default, or `pt`): its subject and rendered body.",
+    query: [{ name: "language", description: "`nl` (default) or `pt`." }],
+    querySchema: mailPreviewQuerySchema,
+    status: 200,
+    response: { description: "The rendered mail." },
+    errors: { 400: true, 404: true }
+  }
+});
+
 // ../../packages/schema/src/operations/meal-plans.ts
 var mealPlanOperations = defineOperations({
   ...crudOperations({
@@ -29740,6 +30725,48 @@ var mealPlanOperations = defineOperations({
   })
 });
 
+// ../../packages/schema/src/operations/occurrences.ts
+var occurrenceOperations = defineOperations({
+  list: {
+    method: "get",
+    path: "/occurrences",
+    scopes: ["occurrences:read"],
+    tag: "Occurrences",
+    summary: "List a template's occurrences",
+    description: "Occurrences of one task/habit template, oldest-first.",
+    query: [{ name: "templateId", description: "The task/habit template's ULID.", required: true }],
+    querySchema: object({ templateId: ulidSchema }),
+    status: 200,
+    response: { description: "The template's occurrences." },
+    errors: { 400: true }
+  },
+  update: {
+    method: "patch",
+    path: "/occurrences/{id}",
+    scopes: ["occurrences:write"],
+    tag: "Occurrences",
+    summary: "Override an occurrence",
+    description: 'Reschedule/skip one occurrence ("edit this"); fires `occurrence.updated`.',
+    body: updateOccurrenceInputSchema,
+    status: 200,
+    response: { description: "The overridden occurrence." },
+    errors: { 400: true, 404: true },
+    webhook: "occurrence.updated"
+  },
+  complete: {
+    method: "post",
+    path: "/occurrences/{id}/complete",
+    scopes: ["occurrences:write"],
+    tag: "Occurrences",
+    summary: "Complete an occurrence",
+    description: "Mark an occurrence done; fires `occurrence.completed`.",
+    status: 201,
+    response: { description: "The completed occurrence." },
+    errors: { 404: true },
+    webhook: "occurrence.completed"
+  }
+});
+
 // ../../packages/schema/src/operations/periods.ts
 var periodOperations = defineOperations({
   ...crudOperations({
@@ -29765,6 +30792,474 @@ var periodOperations = defineOperations({
   })
 });
 
+// ../../packages/schema/src/operations/planning-rules.ts
+var planningRuleOperations = defineOperations({
+  ...crudOperations({
+    segment: "planning/rules",
+    tag: "Planning rules",
+    noun: "planning rule",
+    read: "planning:read",
+    write: "planning:write",
+    create: createPlanningRuleInputSchema,
+    update: updatePlanningRuleInputSchema,
+    listQuery: [
+      { name: "forUserId", description: "Only this member's rules." },
+      {
+        name: "kind",
+        description: "Only this kind (`fixed_time`, `keep_free`, `meaning`, `whose`, `limit`, `note`)."
+      }
+    ],
+    listQuerySchema: planningRulesQuerySchema
+  })
+});
+
+// ../../packages/schema/src/operations/plans.ts
+function decision(path, verb, what) {
+  return {
+    method: "post",
+    path,
+    scopes: ["tasks:write"],
+    tag: "Plans",
+    summary: `${verb[0]?.toUpperCase()}${verb.slice(1)} plan items`,
+    description: `${what} \`itemIds\` narrows it to those items; absent (or an empty body) answers every item it applies to. An unknown item id is a 404.`,
+    body: planDecisionInputSchema,
+    bodyOptional: true,
+    status: 200,
+    response: { description: "The plan, after.", view: "Plan" },
+    errors: { 400: true, 404: true }
+  };
+}
+var planOperations = defineOperations({
+  list: {
+    method: "get",
+    path: "/plans",
+    scopes: ["tasks:read"],
+    tag: "Plans",
+    summary: "List plans",
+    description: "The Space's plan proposals, newest first (the latest 20), each with its items and each item's task as it is now. `status`: `open` (an item waits for an answer), `settled` (none does) or `replaced` (a newer plan for the same week or day took its place).",
+    query: [
+      { name: "kind", description: "`week` or `day`." },
+      { name: "status", description: "`open`, `settled` or `replaced`." },
+      { name: "startsOn", description: "The week's Monday, or the day (`YYYY-MM-DD`)." },
+      { name: "forUserId", description: "Only this member's plans." }
+    ],
+    querySchema: planListQuerySchema.extend({ forUserId: string2().min(1).optional() }),
+    status: 200,
+    response: { description: "The plans.", list: true, view: "Plan" },
+    errors: { 400: true }
+  },
+  create: {
+    method: "post",
+    path: "/plans",
+    scopes: ["tasks:write"],
+    tag: "Plans",
+    summary: "Propose a plan",
+    description: "The agent proposes a week (`kind: week`, `startsOn` a Monday) or a day for a member (`forUserId`, default the member the key acts for). Each item is about one open task: `plan` it on a `day` (all-day, in the member's zone) or `at` a time (with `durationMinutes` when known), take it back to `someday`, or `let_go`. `reason` is the line shown with it. Nothing is written to a task until the member accepts; a newer plan for the same week or day replaces an open one. An Agent's own work joins only while it waits on the member. A block that is already there (a task, a life block or an event on that day with a similar title) is folded in, not added twice: a task is planned into the block's time, anything else is left out, and `merged` lists each with a hint; `onDuplicate: reject` refuses the plan with those hints instead.",
+    body: createPlanInputSchema,
+    status: 201,
+    response: {
+      description: "The plan, open, with the duplicates it folded in.",
+      view: "PlanCreateResult"
+    },
+    errors: { 400: true }
+  },
+  get: {
+    method: "get",
+    path: "/plans/{id}",
+    scopes: ["tasks:read"],
+    tag: "Plans",
+    summary: "Get a plan",
+    description: "One plan with its items.",
+    status: 200,
+    response: { description: "The plan.", view: "Plan" },
+    errors: { 404: true }
+  },
+  accept: {
+    ...decision("/plans/{id}/accept", "accept", "Accept proposed items: each task is written as the item says (a planned day or time, Someday, or cancelled for Let go; a task still Proposed by the agent joins the plan too), and the item keeps what it replaced for Undo. An item whose task has closed since is dismissed instead."),
+    errors: { 400: true, 404: true, 409: "A newer plan replaced this one." }
+  },
+  dismiss: decision("/plans/{id}/dismiss", "dismiss", "Leave proposed items out. Nothing is written to a task."),
+  undo: decision("/plans/{id}/undo", "undo", "Undo answered items: an accepted item's task is put back as it was before; a dismissed item simply waits again. Both read as proposed afterwards.")
+});
+
+// ../../packages/schema/src/operations/routines.ts
+var routineOperations = defineOperations({
+  getRun: {
+    method: "get",
+    path: "/routines/runs/{runId}",
+    pathParams: { runId: "The routine run's ULID." },
+    scopes: ["routines:read"],
+    tag: "Routines",
+    summary: "Get a run",
+    description: "One run with its per-step state.",
+    status: 200,
+    response: { description: "The run." },
+    errors: { 404: true }
+  },
+  updateRun: {
+    method: "patch",
+    path: "/routines/runs/{runId}",
+    pathParams: { runId: "The routine run's ULID." },
+    scopes: ["routines:write"],
+    tag: "Routines",
+    summary: "Update a run",
+    description: "Advance/finish a run; fires `routine.run.updated`.",
+    body: updateRoutineRunInputSchema,
+    status: 200,
+    response: { description: "The updated run." },
+    errors: { 400: true, 404: true },
+    webhook: "routine.run.updated"
+  },
+  updateRunStep: {
+    method: "patch",
+    path: "/routines/runs/{runId}/steps/{stepRunId}",
+    pathParams: { runId: "The routine run's ULID.", stepRunId: "The run step's ULID." },
+    scopes: ["routines:write"],
+    tag: "Routines",
+    summary: "Update a run step",
+    description: "Check off / edit one run step; fires `routine.run.updated`.",
+    body: updateRoutineRunStepInputSchema,
+    status: 200,
+    response: { description: "The updated run." },
+    errors: { 400: true, 404: true },
+    webhook: "routine.run.updated"
+  },
+  undoSteps: {
+    method: "post",
+    path: "/routines/runs/{runId}/undo",
+    pathParams: { runId: "The routine run's ULID." },
+    scopes: ["routines:write"],
+    tag: "Routines",
+    summary: "Undo All taken",
+    description: 'Take an "All taken" back in one call: each named step goes back to open and loses exactly the check-in it wrote; a finished run reopens. Steps no longer done are left alone. Fires `routine.run.updated`.',
+    body: routineRunUndoInputSchema,
+    status: 200,
+    response: { description: "The run." },
+    errors: { 400: true, 404: true },
+    webhook: "routine.run.updated",
+    operationId: "undo_routine_all_taken"
+  },
+  list: {
+    method: "get",
+    path: "/routines",
+    scopes: ["routines:read"],
+    tag: "Routines",
+    summary: "List routines",
+    description: "Every routine (with its steps) in the Space, newest first.",
+    querySchema: paginationQuerySchema,
+    paginated: true,
+    status: 200,
+    response: { description: "The Space's routines." }
+  },
+  get: {
+    method: "get",
+    path: "/routines/{id}",
+    scopes: ["routines:read"],
+    tag: "Routines",
+    summary: "Get a routine",
+    description: "One routine with its step templates.",
+    status: 200,
+    response: { description: "The routine." },
+    errors: { 404: true }
+  },
+  create: {
+    method: "post",
+    path: "/routines",
+    scopes: ["routines:write"],
+    tag: "Routines",
+    summary: "Create a routine",
+    description: "Create a routine (steps ride in the payload); fires `routine.created`.",
+    body: createRoutineInputSchema,
+    status: 201,
+    response: { description: "The created routine." },
+    errors: { 400: true },
+    webhook: "routine.created"
+  },
+  update: {
+    method: "patch",
+    path: "/routines/{id}",
+    scopes: ["routines:write"],
+    tag: "Routines",
+    summary: "Update a routine",
+    description: "Patch a routine; fires `routine.updated`.",
+    body: updateRoutineInputSchema,
+    status: 200,
+    response: { description: "The updated routine." },
+    errors: { 400: true, 404: true },
+    webhook: "routine.updated"
+  },
+  remove: {
+    method: "delete",
+    path: "/routines/{id}",
+    scopes: ["routines:write"],
+    tag: "Routines",
+    summary: "Delete a routine",
+    description: "Soft-delete a routine; fires `routine.deleted`.",
+    status: 204,
+    response: { description: "Deleted." },
+    errors: { 404: true },
+    webhook: "routine.deleted"
+  },
+  attachRecurrence: {
+    method: "put",
+    path: "/routines/{id}/recurrence",
+    scopes: ["routines:write"],
+    tag: "Routines",
+    summary: "Attach recurrence",
+    description: "Attach/replace the routine's recurrence rule; fires `routine.updated`.",
+    body: updateRecurrenceRuleInputSchema,
+    status: 200,
+    response: { description: "The routine." },
+    errors: { 400: true, 404: true },
+    webhook: "routine.updated"
+  },
+  detachRecurrence: {
+    method: "delete",
+    path: "/routines/{id}/recurrence",
+    scopes: ["routines:write"],
+    tag: "Routines",
+    summary: "Detach recurrence",
+    description: "Remove the routine's recurrence rule; returns the routine; fires `routine.updated`.",
+    status: 200,
+    response: { description: "The routine." },
+    errors: { 404: true },
+    webhook: "routine.updated"
+  },
+  markDone: {
+    method: "post",
+    path: "/routines/{id}/done",
+    scopes: ["routines:write"],
+    tag: "Routines",
+    summary: "Check in a whole routine (All taken)",
+    description: "\"Took my supplements\" (#873): one call checks in every open step of today's run (the key's member's day), starting today's run when there's none. Each habit step writes a check-in (`source: routine`); a habit already done today goes done without a second one; a step whose habit is skipped today is left alone. The run finishes once nothing is open. Returns the run and `taken`, the steps it resolved; hand their `stepRunId`s to `POST /api/v1/routines/runs/{runId}/undo` to take it all back. Calling it again changes nothing. Fires `routine.run.updated`.",
+    body: routineDoneInputSchema,
+    status: 200,
+    response: { description: "`{ run, taken }`." },
+    errors: { 400: true, 404: true },
+    webhook: "routine.run.updated",
+    operationId: "routine_all_taken"
+  },
+  startRun: {
+    method: "post",
+    path: "/routines/{id}/runs",
+    scopes: ["routines:write"],
+    tag: "Routines",
+    summary: "Start a run",
+    description: "Start a run of the routine; fires `routine.run.started`.",
+    body: startRoutineRunInputSchema,
+    status: 201,
+    response: { description: "The started run." },
+    errors: { 400: true, 404: true },
+    webhook: "routine.run.started"
+  },
+  listRuns: {
+    method: "get",
+    path: "/routines/{id}/runs",
+    scopes: ["routines:read"],
+    tag: "Routines",
+    summary: "List a routine's runs",
+    description: "The routine's runs, newest-first.",
+    status: 200,
+    response: { description: "The routine's runs." },
+    errors: { 404: true }
+  }
+});
+
+// ../../packages/schema/src/operations/rsvp-answers.ts
+var rsvpAnswerOperations = defineOperations({
+  list: {
+    method: "get",
+    path: "/rsvp-answers",
+    scopes: ["contacts:read"],
+    tag: "Guests",
+    summary: "List RSVP answers",
+    description: "A guest list's answers to its RSVP questions (`guestListId`, required), or one household's (`householdId`): `{ questionId, householdId, guestId, value }`, `guestId` null for the household's own.",
+    query: [
+      { name: "guestListId", description: "The guest list (required)." },
+      { name: "householdId", description: "Only this household's answers." }
+    ],
+    querySchema: rsvpAnswersQuerySchema,
+    status: 200,
+    response: { description: "The answers." },
+    errors: { 400: true, 404: true }
+  },
+  set: {
+    method: "put",
+    path: "/rsvp-answers",
+    scopes: ["contacts:write"],
+    tag: "Guests",
+    summary: "Set a household's RSVP answers",
+    description: "Lays `answers` over the household's stored ones (`value: null` clears one; answers left out stay) and returns what stands. An unknown question, a guest not in the household, a per-guest question without a guest, an event the guest isn't invited to, or a value that doesn't fit the kind is a 422; an answer whose question no longer shows (its `showIf`) is dropped. Fires `rsvp.answers.updated`.",
+    body: setRsvpAnswersInputSchema,
+    status: 200,
+    response: { description: "The household's answers after." },
+    errors: { 400: true, 404: true, 422: "An answer that can't be given (see the message)." },
+    webhook: "rsvp.answers.updated"
+  }
+});
+
+// ../../packages/schema/src/operations/rsvp-questions.ts
+var rsvpQuestionOperations = defineOperations({
+  ...crudOperations({
+    segment: "rsvp-questions",
+    tag: "Guests",
+    noun: "RSVP question",
+    eventBase: "rsvp.question",
+    read: "contacts:read",
+    write: "contacts:write",
+    create: createRsvpQuestionInputSchema,
+    update: updateRsvpQuestionInputSchema,
+    listQuery: [{ name: "guestListId", description: "The guest list (required)." }],
+    listQuerySchema: rsvpQuestionsQuerySchema
+  }),
+  presets: {
+    method: "post",
+    path: "/rsvp-questions/presets",
+    scopes: ["contacts:write"],
+    tag: "Guests",
+    summary: "Add the built-in RSVP questions",
+    description: "Adds the preset questions after the list's own (`diet`: per guest, shown to a guest who said yes to anything, with vegetarian \xB7 vegan \xB7 gluten-free \xB7 lactose-free \xB7 nut allergy \xB7 other, and a text line shown when other is picked; `message`: the household's, once). A preset the list already has stays as it is. Returns the list's questions; fires `rsvp.question.created`.",
+    body: addRsvpPresetsInputSchema,
+    status: 200,
+    response: { description: "The list's questions." },
+    errors: { 400: true, 404: true },
+    webhook: "rsvp.question.created"
+  }
+});
+
+// ../../packages/schema/src/operations/sensors.ts
+var sensorOperations = defineOperations({
+  status: {
+    method: "get",
+    path: "/sensors/home-assistant",
+    scopes: ["places:read"],
+    tag: "Sensors",
+    summary: "Get the Home Assistant link",
+    description: "Whether the Space has linked Home Assistant (in Settings in the app; the token is never returned), the `host` it was linked at, how many entities are mapped (`links`) and `lastReadingAt`, when the newest reading from it landed.",
+    status: 200,
+    response: { description: "The link's status." },
+    errors: { 403: true }
+  },
+  entities: {
+    method: "get",
+    path: "/sensors/home-assistant/entities",
+    scopes: ["places:read"],
+    tag: "Sensors",
+    summary: "List Home Assistant's entities",
+    description: "Every entity Home Assistant has, by `entityId`: its name, domain, state, unit, device class, `lastUpdated`, the reading it most likely gives on a Place and on an asset (`suggested`) and the sensor link it's mapped by, or null. 409 before Home Assistant is linked; 503 when it doesn't answer.",
+    status: 200,
+    response: { description: "The entities, by id." },
+    errors: { 403: true, 409: true, 503: "Home Assistant didn't answer, or refused the token." }
+  },
+  sync: {
+    method: "post",
+    path: "/sensors/home-assistant/sync",
+    scopes: ["places:write"],
+    tag: "Sensors",
+    summary: "Sync Home Assistant now",
+    description: "Read every mapped entity's state once and append it to the datapoints ledger: on a Place as `shed.temp`, `shed.humidity`, `shed.heater`, `shed.water_pct`, `shed.door`, `shed.feed_kg` or `shed.light` (what an animal's room card and the room alarm read), on an asset as `asset.state`, `asset.power` or `asset.energy`. A state already on the ledger, or one Home Assistant can't read, is skipped. The worker does the same every five minutes. Returns `{ syncedAt, entities, written, skipped, missing, error }` (`unauthorized`, `unavailable`, `bad_response`). 409 before Home Assistant is linked.",
+    status: 200,
+    response: { description: "What the sync did." },
+    errors: { 403: true, 409: true }
+  },
+  unifiStatus: {
+    method: "get",
+    path: "/sensors/unifi",
+    scopes: ["places:read"],
+    tag: "Sensors",
+    summary: "Whether UniFi is linked",
+    description: "Whether the Space has linked its UniFi controller (in the app's Settings \u2192 Home), the host and site it was linked at, how many devices are mapped to an asset, and when the newest presence reading landed. Never the API key: a key can't link or unlink UniFi.",
+    status: 200,
+    response: { description: "The status." },
+    errors: { 403: true }
+  },
+  unifiDevices: {
+    method: "get",
+    path: "/sensors/unifi/devices",
+    scopes: ["places:read", "collections:read"],
+    tag: "Sensors",
+    summary: "The devices UniFi sees",
+    description: "Every device the controller manages (gateway, switches, access points, cameras) and every client connected now: `mac`, `name`, `kind` (`device` | `client`), `model`, `online`, `firmware`, and the sensor `link` to the asset it's mapped to (behind the nodes wall). Network details. 409 before UniFi is linked; 503 when the controller can't be read.",
+    status: 200,
+    response: { description: "The devices." },
+    errors: { 403: true, 409: true }
+  },
+  syncUnifi: {
+    method: "post",
+    path: "/sensors/unifi/sync",
+    scopes: ["places:write"],
+    tag: "Sensors",
+    summary: "Sync UniFi now",
+    description: "Map every asset whose facet names a UniFi MAC (`external.unifiMac`), ask the controller once, and put each mapped device's presence on its asset as `asset.presence` (1 online, 0 offline, with its firmware): what the asset page's Live card reads. A reading lands when the presence or firmware changes, else hourly; a device the controller doesn't list reads offline and is named in `missing`. The worker does the same every five minutes. 409 before UniFi is linked.",
+    status: 200,
+    response: { description: "What the sync did." },
+    errors: { 403: true, 409: true }
+  },
+  links: {
+    method: "get",
+    path: "/sensors/links",
+    scopes: ["places:read"],
+    tag: "Sensors",
+    summary: "List the mapped entities",
+    description: "Every mapped entity, or only the ones on `nodeId`, with the name of what it lands on (`nodeTitle`). A mapping on an asset kept Not shared is its member's alone.",
+    query: [{ name: "nodeId", description: "Only the mappings on this Place or asset." }],
+    querySchema: sensorLinksQuerySchema,
+    status: 200,
+    response: { description: "The mappings, by entity id." },
+    errors: { 400: true }
+  },
+  createLink: {
+    method: "post",
+    path: "/sensors/links",
+    scopes: ["places:write"],
+    tag: "Sensors",
+    summary: "Map an entity",
+    description: "Map a Home Assistant entity (`externalId`) to a Place, an asset, or an animal (its room: the Place it's housed in) as a `reading`: a Place takes `temp`, `humidity`, `heater`, `water`, `door`, `feeder` or `light`; an asset `state`, `power` or `energy`. Mapping an entity that's already mapped moves it. 400 when the reading doesn't fit; 404 for no such node; 409 for an animal with no room.",
+    body: createSensorLinkInputSchema,
+    status: 201,
+    response: { description: "The mapping." },
+    errors: { 400: true, 404: true, 409: true }
+  },
+  removeLink: {
+    method: "delete",
+    path: "/sensors/links/{id}",
+    scopes: ["places:write"],
+    tag: "Sensors",
+    summary: "Unmap an entity",
+    description: "Remove one mapping; the readings it gave stay on the ledger.",
+    status: 204,
+    response: { description: "Removed." },
+    errors: { 404: true }
+  }
+});
+
+// ../../packages/schema/src/operations/settings.ts
+var settingsOperations = defineOperations({
+  get: {
+    method: "get",
+    path: "/settings",
+    scopes: ["settings:read"],
+    tag: "Settings",
+    summary: "Get settings",
+    description: "The caller's settings (lazily created). The key must carry a user identity.",
+    status: 200,
+    response: { description: "The caller's settings." }
+  },
+  update: {
+    method: "patch",
+    path: "/settings",
+    scopes: ["settings:write"],
+    tag: "Settings",
+    summary: "Update settings",
+    description: "Patch the caller's settings; fires `settings.updated`.",
+    body: updateUserSettingsInputSchema,
+    status: 200,
+    response: { description: "The updated settings." },
+    errors: { 400: true },
+    webhook: "settings.updated"
+  }
+});
+
 // ../../packages/schema/src/operations/shopping-lists.ts
 var shoppingListOperations = defineOperations({
   ...crudOperations({
@@ -29783,7 +31278,7 @@ var shoppingListOperations = defineOperations({
 // ../../packages/schema/src/operations/tap-tags.ts
 var READ = ["habits:read", "routines:read"];
 var WRITE = ["habits:write", "routines:write"];
-var pathParams = { id: "The tag's id: the ULID the sticker's link carries (`/t/{id}`)." };
+var pathParams2 = { id: "The tag's id: the ULID the sticker's link carries (`/t/{id}`)." };
 var tapTagOperations = defineOperations({
   list: {
     method: "get",
@@ -29811,7 +31306,7 @@ var tapTagOperations = defineOperations({
   get: {
     method: "get",
     path: "/tap-tags/{id}",
-    pathParams,
+    pathParams: pathParams2,
     scopes: READ,
     tag: "Habits",
     summary: "Get a tap tag",
@@ -29823,7 +31318,7 @@ var tapTagOperations = defineOperations({
   update: {
     method: "patch",
     path: "/tap-tags/{id}",
-    pathParams,
+    pathParams: pathParams2,
     scopes: WRITE,
     tag: "Habits",
     summary: "Rename or rebind a tap tag",
@@ -29836,7 +31331,7 @@ var tapTagOperations = defineOperations({
   remove: {
     method: "delete",
     path: "/tap-tags/{id}",
-    pathParams,
+    pathParams: pathParams2,
     scopes: WRITE,
     tag: "Habits",
     summary: "Delete a tap tag",
@@ -29848,7 +31343,7 @@ var tapTagOperations = defineOperations({
   tap: {
     method: "post",
     path: "/tap-tags/{id}/tap",
-    pathParams,
+    pathParams: pathParams2,
     scopes: WRITE,
     tag: "Habits",
     summary: "Tap a tap tag",
@@ -29859,6 +31354,292 @@ var tapTagOperations = defineOperations({
   }
 });
 
+// ../../packages/schema/src/operations/tasks.ts
+var taskListQuery = taskListQuerySchema.extend(paginationQuerySchema.shape).extend({ filter: taskListFilterSchema.optional().default("all") });
+var taskOperations = defineOperations({
+  list: {
+    method: "get",
+    path: "/tasks",
+    scopes: ["tasks:read"],
+    tag: "Tasks",
+    summary: "List tasks",
+    description: "Every task in the key's Space, newest first.",
+    query: [
+      {
+        name: "filter",
+        description: "`all` (default), `unsorted` (the Inbox's tasks to file: open, top-level, not proposed, with no planned day, Deadline, Area or Project) or `starred`.",
+        enum: ["all", "unsorted", "starred"]
+      },
+      {
+        name: "areaId",
+        description: "Only rows in this Area (ULID) \u2014 a project task by its project's Area (its effective Area)."
+      },
+      { name: "projectId", description: "Only tasks attached to this project (ULID)." },
+      {
+        name: "status",
+        description: "Only rows in any of these statuses (comma list or repeated key): `todo`, `in_progress`, `done`, `cancelled`."
+      },
+      {
+        name: "tag",
+        description: "Only tasks carrying every listed tag (comma list or repeated key; case-insensitive, a leading `#` is ignored)."
+      },
+      {
+        name: "updatedSince",
+        description: "Only rows whose `updatedAt` is at or after this instant \u2014 an ISO 8601 datetime with offset, or a bare `YYYY-MM-DD` (UTC midnight).",
+        format: "date-time"
+      },
+      {
+        name: "dueBefore",
+        description: "Only rows due strictly before this instant (undated rows are excluded) \u2014 an ISO 8601 datetime with offset, or a bare `YYYY-MM-DD` (UTC midnight).",
+        format: "date-time"
+      },
+      {
+        name: "owner",
+        description: "Only tasks with this Owner: `me`, `member:<id|email>`, `agent:<id|name>` (every desk) or `agent:<id|name>/<desk>`; `any` = owned, `none` = unowned. An unknown party is a 400."
+      },
+      {
+        name: "waitingOn",
+        description: "Only tasks waiting on this party: `me`, `member:<id|email>` or `agent:<id|name>`; `any` = waiting on someone, `none` = not waiting. An unknown party is a 400."
+      },
+      {
+        name: "completedSince",
+        description: "Only tasks finished at or after this instant (`completedAt`; open and cancelled tasks have none) \u2014 an ISO 8601 datetime with offset, or a bare `YYYY-MM-DD` (UTC midnight).",
+        format: "date-time"
+      },
+      {
+        name: "completedBefore",
+        description: "Only tasks finished strictly before this instant \u2014 an ISO 8601 datetime with offset, or a bare `YYYY-MM-DD` (UTC midnight).",
+        format: "date-time"
+      },
+      {
+        name: "proposed",
+        description: "`true` = only tasks Proposed by the agent (an Agent made them for a member, who hasn't accepted yet); `false` = only tasks on the plan. Absent = both.",
+        type: "boolean"
+      },
+      {
+        name: "ready",
+        description: "`true` = only open tasks whose Owner marked them Ready for you; `false` = the rest. Absent = both.",
+        type: "boolean"
+      },
+      {
+        name: "drifted",
+        description: "`true` = only open tasks whose planned day moved 3+ times (the weekly plan's Drifted card); `false` = the rest. Absent = both.",
+        type: "boolean"
+      }
+    ],
+    querySchema: taskListQuery,
+    paginated: true,
+    status: 200,
+    response: { description: "The Space's tasks.", list: true }
+  },
+  listSubtasks: {
+    method: "get",
+    path: "/tasks/{id}/subtasks",
+    scopes: ["tasks:read"],
+    tag: "Tasks",
+    summary: "List subtasks",
+    description: "The direct children of a task, ordered by `sortOrder` (ascending), then newest first.",
+    status: 200,
+    response: { description: "The ordered subtasks." },
+    errors: { 404: true }
+  },
+  get: {
+    method: "get",
+    path: "/tasks/{id}",
+    scopes: ["tasks:read"],
+    tag: "Tasks",
+    summary: "Get a task",
+    description: "Fetch one task by id.",
+    status: 200,
+    response: { description: "The task." },
+    errors: { 404: true }
+  },
+  create: {
+    method: "post",
+    path: "/tasks",
+    scopes: ["tasks:write"],
+    tag: "Tasks",
+    summary: "Create a task",
+    description: "Create a task; fires the `task.created` webhook.",
+    body: createTaskInputSchema,
+    status: 201,
+    response: { description: "The created task." },
+    errors: { 400: true, 409: true },
+    webhook: "task.created"
+  },
+  update: {
+    method: "patch",
+    path: "/tasks/{id}",
+    scopes: ["tasks:write"],
+    tag: "Tasks",
+    summary: "Update a task",
+    description: "Patch a task; fires the `task.updated` webhook.",
+    body: updateTaskInputSchema,
+    status: 200,
+    response: { description: "The updated task." },
+    errors: { 400: true, 404: true, 409: true },
+    webhook: "task.updated"
+  },
+  cancel: {
+    method: "post",
+    path: "/tasks/{id}/cancel",
+    scopes: ["tasks:write"],
+    tag: "Tasks",
+    summary: "Cancel a task",
+    description: 'Drop a task: its status becomes `cancelled` and any `completedAt` is cleared, so a drop never counts as Landed (#648). Fires `task.updated`. The same as a PATCH to `status: "cancelled"`.',
+    status: 200,
+    response: { description: "The cancelled task." },
+    errors: { 404: true },
+    webhook: "task.updated"
+  },
+  accept: {
+    method: "post",
+    path: "/tasks/{id}/accept",
+    scopes: ["tasks:write"],
+    tag: "Tasks",
+    summary: "Accept a proposal",
+    description: "Take a task Proposed by the agent onto the member's plan as it was suggested: its planned day, Deadline and Area stay; `proposedAt` clears (#889). A no-op success on a task that isn't a proposal. Fires `task.updated`. The same as a PATCH to `proposed: false`.",
+    status: 200,
+    response: { description: "The accepted task." },
+    errors: { 404: true },
+    webhook: "task.updated"
+  },
+  notNow: {
+    method: "post",
+    path: "/tasks/{id}/not-now",
+    scopes: ["tasks:write"],
+    tag: "Tasks",
+    summary: "Not now on a proposal",
+    description: "Keep a task Proposed by the agent, but out of the member's Inbox for a week (`notNowUntil`, #889). Let go is `cancel`. Fires `task.updated`.",
+    status: 200,
+    response: { description: "The proposal, back in a week." },
+    errors: { 404: true, 409: "The task isn't a proposal." },
+    webhook: "task.updated"
+  },
+  ready: {
+    method: "post",
+    path: "/tasks/{id}/ready",
+    scopes: ["tasks:write"],
+    tag: "Tasks",
+    summary: "Mark Ready for you",
+    description: "The task's Owner (the Space's agent, a Desk, a coding agent) finished something the member should look at: `readyAt` is set and the task reaches Now's Needs you with Review (#902). Looks good marks it done; Send back is a PATCH to `ready: false` (it reads Working on it again). The optional `note` is what's ready, in a line, with a link when there is one; absent keeps the note already there. Fires `task.updated`.",
+    body: markTaskReadyInputSchema,
+    status: 200,
+    response: { description: "The task, Ready for you." },
+    errors: { 404: true, 409: "The task is done or let go; only an open task can be ready." },
+    webhook: "task.updated"
+  },
+  remove: {
+    method: "delete",
+    path: "/tasks/{id}",
+    scopes: ["tasks:write"],
+    tag: "Tasks",
+    summary: "Delete a task",
+    description: "Delete a task; fires the `task.deleted` webhook.",
+    status: 204,
+    response: { description: "Deleted." },
+    errors: { 404: true },
+    webhook: "task.deleted"
+  }
+});
+
+// ../../packages/schema/src/operations/today.ts
+var todayOperations = defineOperations({
+  fromEarlier: {
+    method: "get",
+    path: "/today/from-earlier",
+    scopes: ["tasks:read"],
+    tag: "Reads",
+    summary: "From earlier",
+    description: 'The planned tasks that slipped (#888): open, non-recurring tasks whose all-day planned day falls in the 14 days before `from`, newest plan first. Timed tasks, tasks placed in a past time block and agent-owned work never roll; older plans simply leave the list (nothing is rewritten). A Space back from 21+ days away gets no pile. Also names `laterThisWeek`, the quietest later day this week (Monday-first; tomorrow on a Sunday) that "Later this week" lands on. Answer with `POST /api/v1/today/rollover`.',
+    query: [
+      {
+        name: "from",
+        description: "Your local day start, an ISO instant (or a bare date, read as UTC midnight). Defaults to the current UTC day."
+      },
+      { name: "areaId", description: "Only tasks in this Area (own or their Project's)." }
+    ],
+    querySchema: fromEarlierQuerySchema,
+    status: 200,
+    response: { description: "From earlier.", view: "FromEarlierResponse" },
+    errors: { 400: true }
+  },
+  rollover: {
+    method: "post",
+    path: "/today/rollover",
+    scopes: ["tasks:write"],
+    tag: "Tasks",
+    summary: "Answer From earlier",
+    description: 'Answer many tasks (and habit/routine occurrences) at once: `reschedule` to `to` (all-day; From earlier\'s Today and Later this week), `someday` (clear the planned day, keep the Area or Project; occurrences untouched), or `drop` ("Let go": tasks cancelled, occurrences skipped; a cancelled task never counts as Landed). Only open tasks and unresolved occurrences change; unknown ids are skipped. Returns how many of each moved. Occurrence ids need `habits:write` too.',
+    body: rolloverInputSchema,
+    status: 201,
+    response: { description: "How many tasks and occurrences changed." },
+    errors: { 400: true }
+  }
+});
+
+// ../../packages/schema/src/operations/webhooks.ts
+var webhookOperations = defineOperations({
+  list: {
+    method: "get",
+    path: "/webhooks",
+    scopes: ["webhooks:read"],
+    tag: "Webhooks",
+    summary: "List webhook subscriptions",
+    description: "The Space's outbound webhook endpoints (secrets omitted), newest first.",
+    querySchema: paginationQuerySchema,
+    paginated: true,
+    status: 200,
+    response: { description: "The subscriptions." }
+  },
+  create: {
+    method: "post",
+    path: "/webhooks",
+    scopes: ["webhooks:write"],
+    tag: "Webhooks",
+    summary: "Register a webhook subscription",
+    description: "Register an endpoint + events; returns the signing secret once.",
+    body: createWebhookSubscriptionInputSchema,
+    status: 201,
+    response: { description: "The created subscription (with its one-time secret)." },
+    errors: { 400: true }
+  },
+  get: {
+    method: "get",
+    path: "/webhooks/{id}",
+    scopes: ["webhooks:read"],
+    tag: "Webhooks",
+    summary: "Get a webhook subscription",
+    description: "One subscription (secret omitted).",
+    status: 200,
+    response: { description: "The subscription." },
+    errors: { 404: true }
+  },
+  update: {
+    method: "patch",
+    path: "/webhooks/{id}",
+    scopes: ["webhooks:write"],
+    tag: "Webhooks",
+    summary: "Update a webhook subscription",
+    description: "Patch url/events, or pause with `active: false`.",
+    body: updateWebhookSubscriptionInputSchema,
+    status: 200,
+    response: { description: "The updated subscription." },
+    errors: { 400: true, 404: true }
+  },
+  remove: {
+    method: "delete",
+    path: "/webhooks/{id}",
+    scopes: ["webhooks:write"],
+    tag: "Webhooks",
+    summary: "Delete a webhook subscription",
+    description: "Remove an endpoint.",
+    status: 204,
+    response: { description: "Deleted." },
+    errors: { 404: true }
+  }
+});
+
 // ../../node_modules/ulidx/dist/node/index.js
 import crypto from "crypto";
 
@@ -30111,7 +31892,7 @@ function parseCapture2(input, now) {
 
 // src/meta.ts
 var CLI_NAME = "do";
-var VERSION = "1.303.0";
+var VERSION = "1.305.0";
 var API_PREFIX = "/api/v1";
 var DEFAULT_API_URL = "http://localhost:3001";
 
@@ -30530,12 +32311,9 @@ function entityFromOperations(ops, spec) {
   };
 }
 var ENTITIES = [
-  {
+  entityFromOperations(taskOperations, {
     name: "tasks",
-    path: "/tasks",
-    readScopes: ["tasks:read"],
     returns: "Task",
-    canGet: true,
     listFlags: [
       {
         name: "filter",
@@ -30577,21 +32355,12 @@ var ENTITIES = [
         boolean: true
       }
     ],
-    write: {
-      scopes: ["tasks:write"],
-      createSchema: createTaskInputSchema,
-      createInput: "CreateTaskInput",
-      updateSchema: updateTaskInputSchema,
-      updateInput: "UpdateTaskInput",
-      canDelete: true
-    }
-  },
-  {
+    createInput: "CreateTaskInput",
+    updateInput: "UpdateTaskInput"
+  }),
+  entityFromOperations(habitOperations, {
     name: "habits",
-    path: "/habits",
-    readScopes: ["habits:read"],
     returns: "HabitSummary",
-    canGet: true,
     listFlags: [
       AREA_FLAG,
       UPDATED_SINCE_FLAG,
@@ -30600,15 +32369,9 @@ var ENTITIES = [
         description: "list the Grown shelf (retired habits) instead of the growing ones"
       }
     ],
-    write: {
-      scopes: ["habits:write"],
-      createSchema: createHabitInputSchema,
-      createInput: "CreateHabitInput",
-      updateSchema: updateHabitInputSchema,
-      updateInput: "UpdateHabitInput",
-      canDelete: true
-    }
-  },
+    createInput: "CreateHabitInput",
+    updateInput: "UpdateHabitInput"
+  }),
   {
     name: "projects",
     path: "/projects",
@@ -30673,22 +32436,13 @@ var ENTITIES = [
       canDelete: true
     }
   },
-  {
+  entityFromOperations(routineOperations, {
     name: "routines",
-    path: "/routines",
-    readScopes: ["routines:read"],
     returns: "RoutineView",
-    canGet: true,
     listFlags: [],
-    write: {
-      scopes: ["routines:write"],
-      createSchema: createRoutineInputSchema,
-      createInput: "CreateRoutineInput",
-      updateSchema: updateRoutineInputSchema,
-      updateInput: "UpdateRoutineInput",
-      canDelete: true
-    }
-  },
+    createInput: "CreateRoutineInput",
+    updateInput: "UpdateRoutineInput"
+  }),
   {
     name: "notes",
     path: "/notes",
@@ -30820,12 +32574,9 @@ var ENTITIES = [
       canDelete: true
     }
   },
-  {
+  entityFromOperations(householdOperations, {
     name: "households",
-    path: "/households",
-    readScopes: ["contacts:read"],
     returns: "HouseholdView",
-    canGet: true,
     listFlags: [
       {
         name: "contact",
@@ -30833,15 +32584,9 @@ var ENTITIES = [
         query: "contactId"
       }
     ],
-    write: {
-      scopes: ["contacts:write"],
-      createSchema: createHouseholdInputSchema,
-      createInput: "CreateHouseholdInput",
-      updateSchema: updateHouseholdInputSchema,
-      updateInput: "UpdateHouseholdInput",
-      canDelete: true
-    }
-  },
+    createInput: "CreateHouseholdInput",
+    updateInput: "UpdateHouseholdInput"
+  }),
   {
     name: "guest-lists",
     path: "/guest-lists",
@@ -30858,80 +32603,44 @@ var ENTITIES = [
       canDelete: true
     }
   },
-  {
+  entityFromOperations(guestListEventOperations, {
     name: "guest-list-events",
-    path: "/guest-list-events",
-    readScopes: ["contacts:read"],
     returns: "GuestListEvent",
-    canGet: true,
     listFlags: [
       { name: "list", description: "the guest list's id (required)", query: "guestListId" }
     ],
-    write: {
-      scopes: ["contacts:write"],
-      createSchema: createGuestListEventInputSchema,
-      createInput: "CreateGuestListEventInput",
-      updateSchema: updateGuestListEventInputSchema,
-      updateInput: "UpdateGuestListEventInput",
-      canDelete: true
-    }
-  },
-  {
+    createInput: "CreateGuestListEventInput",
+    updateInput: "UpdateGuestListEventInput"
+  }),
+  entityFromOperations(guestTableOperations, {
     name: "guest-tables",
-    path: "/guest-tables",
-    readScopes: ["contacts:read"],
     returns: "GuestTableView",
-    canGet: true,
     listFlags: [
       { name: "list", description: "the guest list's id (required)", query: "guestListId" }
     ],
-    write: {
-      scopes: ["contacts:write"],
-      createSchema: createGuestTableInputSchema,
-      createInput: "CreateGuestTableInput",
-      updateSchema: updateGuestTableInputSchema,
-      updateInput: "UpdateGuestTableInput",
-      canDelete: true
-    }
-  },
-  {
+    createInput: "CreateGuestTableInput",
+    updateInput: "UpdateGuestTableInput"
+  }),
+  entityFromOperations(rsvpQuestionOperations, {
     name: "rsvp-questions",
-    path: "/rsvp-questions",
-    readScopes: ["contacts:read"],
     returns: "RsvpQuestion",
-    canGet: true,
     listFlags: [
       { name: "list", description: "the guest list's id (required)", query: "guestListId" }
     ],
-    write: {
-      scopes: ["contacts:write"],
-      createSchema: createRsvpQuestionInputSchema,
-      createInput: "CreateRsvpQuestionInput",
-      updateSchema: updateRsvpQuestionInputSchema,
-      updateInput: "UpdateRsvpQuestionInput",
-      canDelete: true
-    }
-  },
-  {
+    createInput: "CreateRsvpQuestionInput",
+    updateInput: "UpdateRsvpQuestionInput"
+  }),
+  entityFromOperations(guestOperations, {
     name: "guests",
-    path: "/guests",
-    readScopes: ["contacts:read"],
     returns: "GuestView",
-    canGet: true,
     listFlags: [
       { name: "list", description: "only this guest list's guests", query: "guestListId" },
       { name: "contact", description: "only this contact's guest rows", query: "contactId" },
       { name: "state", description: "yes, no, maybe or waiting (overall)", query: "state" }
     ],
-    write: {
-      scopes: ["contacts:write"],
-      createSchema: createGuestInputSchema,
-      createInput: "CreateGuestInput",
-      updateSchema: updateGuestInputSchema,
-      updateInput: "UpdateGuestInput",
-      canDelete: true
-    }
-  },
+    createInput: "CreateGuestInput",
+    updateInput: "UpdateGuestInput"
+  }),
   {
     name: "key-dates",
     path: "/key-dates",
@@ -31137,12 +32846,9 @@ var ENTITIES = [
     createInput: "CreateMealPlanInput",
     updateInput: "UpdateMealPlanInput"
   }),
-  {
+  entityFromOperations({ list: occurrenceOperations.list }, {
     name: "occurrences",
-    path: "/occurrences",
-    readScopes: ["occurrences:read"],
     returns: "Occurrence",
-    canGet: false,
     listFlags: [
       {
         name: "template-id",
@@ -31151,7 +32857,7 @@ var ENTITIES = [
         query: "templateId"
       }
     ]
-  },
+  }),
   {
     name: "time-blocks",
     path: "/time-blocks",
@@ -31175,30 +32881,14 @@ var ENTITIES = [
       canDelete: true
     }
   },
-  {
+  entityFromOperations(blockTemplateOperations, {
     name: "block-templates",
-    path: "/block-templates",
-    readScopes: ["calendar:read"],
     returns: "BlockTemplateView",
-    canGet: true,
     listFlags: [],
-    write: {
-      scopes: ["calendar:write"],
-      createSchema: createBlockTemplateInputSchema,
-      createInput: "CreateBlockTemplateInput",
-      updateSchema: updateBlockTemplateInputSchema,
-      updateInput: "UpdateBlockTemplateInput",
-      canDelete: true
-    }
-  },
-  {
-    name: "webhooks",
-    path: "/webhooks",
-    readScopes: ["webhooks:read"],
-    returns: "WebhookSubscription",
-    canGet: true,
-    listFlags: []
-  }
+    createInput: "CreateBlockTemplateInput",
+    updateInput: "UpdateBlockTemplateInput"
+  }),
+  entityFromOperations({ list: webhookOperations.list, get: webhookOperations.get }, { name: "webhooks", returns: "WebhookSubscription", listFlags: [] })
 ];
 var entityByName = (name) => ENTITIES.find((e) => e.name === name);
 function entityOperations(e) {
@@ -31628,18 +33318,18 @@ var HEALTH_COMMAND_SPECS = [
     summary: "Whether your Google Health is connected, the last sync, and what stops it.",
     args: [],
     flags: [],
-    scopes: READ2,
+    scopes: [...googleHealthOperations.status.scopes],
     returns: "GoogleHealthStatus",
-    notes: "GET /api/v1/health/google-health. Connecting needs Google's consent in a browser: Settings \u2192 Health in do. `failure` (reauth, not_linked, unavailable, other) says what stops the sync, with a title and a hint. `nutrition` says whether your food is written back to Google Health (turned on in do; each settled day once, one entry per meal type) and the last day written."
+    notes: `${routeOf(googleHealthOperations.status)}. Connecting needs Google's consent in a browser: Settings \u2192 Health in do. \`failure\` (reauth, not_linked, unavailable, other) says what stops the sync, with a title and a hint. \`nutrition\` says whether your food is written back to Google Health (turned on in do; each settled day once, one entry per meal type) and the last day written.`
   },
   {
     path: ["health", "google", "sync"],
     summary: "Sync your Google Health now (sleep, resting heart rate, HRV, steps, workouts), as the morning sync does.",
     args: [],
     flags: [],
-    scopes: WRITE3,
+    scopes: [...googleHealthOperations.sync.scopes],
     returns: "GoogleHealthSyncResult",
-    notes: "POST /api/v1/health/google-health/sync. Written and skipped per resource, and the status after it; a sync that stops answers 200 with `status.failure`. 409 before Google Health is connected, 403 while the server has it switched off."
+    notes: `${routeOf(googleHealthOperations.sync)}. Written and skipped per resource, and the status after it; a sync that stops answers 200 with \`status.failure\`. 409 before Google Health is connected, 403 while the server has it switched off.`
   },
   {
     path: ["health", "withings", "status"],
@@ -31923,9 +33613,9 @@ var COMMAND_SPECS = [
     summary: "From earlier: planned tasks of the last 14 days that weren't done, newest first, and the day Later this week lands on.",
     args: [],
     flags: [{ name: "area", type: "string", description: "Only tasks in this Area (id)." }],
-    scopes: ["tasks:read"],
+    scopes: [...todayOperations.fromEarlier.scopes],
     returns: "FromEarlierResponse",
-    notes: "GET /api/v1/today/from-earlier, from your local day. Nothing here is late: timed tasks, time blocks and agents' work never roll, and a plan older than 14 days just waits where it was filed. Answer with `do today answer`."
+    notes: `${routeOf(todayOperations.fromEarlier)}, from your local day. Nothing here is late: timed tasks, time blocks and agents' work never roll, and a plan older than 14 days just waits where it was filed. Answer with \`do today answer\`.`
   },
   {
     path: ["today", "answer"],
@@ -32406,27 +34096,27 @@ var COMMAND_SPECS = [
     summary: "Drop a task: status cancelled, never counted as Landed.",
     args: [{ name: "id", required: true, description: "Task ULID." }],
     flags: [],
-    scopes: ["tasks:write"],
+    scopes: [...taskOperations.cancel.scopes],
     returns: "Task",
-    notes: "POST /api/v1/tasks/{id}/cancel. Use this, not `task done`, for a dropped task."
+    notes: `${routeOf(taskOperations.cancel)}. Use this, not \`task done\`, for a dropped task.`
   },
   {
     path: ["tasks", "accept"],
     summary: "Accept a task Proposed by the agent: it joins the plan as suggested (day, Deadline, Area kept).",
     args: [{ name: "id", required: true, description: "Task ULID." }],
     flags: [],
-    scopes: ["tasks:write"],
+    scopes: [...taskOperations.accept.scopes],
     returns: "Task",
-    notes: "POST /api/v1/tasks/{id}/accept (#889). A no-op on a task that isn't a proposal. List proposals with `do tasks list --proposed`."
+    notes: `${routeOf(taskOperations.accept)} (#889). A no-op on a task that isn't a proposal. List proposals with \`do tasks list --proposed\`.`
   },
   {
     path: ["tasks", "dismiss"],
     summary: "Not now on a task Proposed by the agent: it leaves the Inbox for a week, still proposed.",
     args: [{ name: "id", required: true, description: "Task ULID." }],
     flags: [],
-    scopes: ["tasks:write"],
+    scopes: [...taskOperations.notNow.scopes],
     returns: "Task",
-    notes: "POST /api/v1/tasks/{id}/not-now (#889); 409 when the task isn't a proposal. Let go is `do task cancel`."
+    notes: `${routeOf(taskOperations.notNow)} (#889); 409 when the task isn't a proposal. Let go is \`do task cancel\`.`
   },
   {
     path: ["block-templates", "week"],
@@ -32435,18 +34125,18 @@ var COMMAND_SPECS = [
     flags: [
       { name: "start", type: "string", description: "The week's Monday (YYYY-MM-DD). Required." }
     ],
-    scopes: ["calendar:read"],
+    scopes: [...blockTemplateOperations.week.scopes],
     returns: "BlockTemplateInstance[]",
-    notes: "GET /api/v1/block-templates/week?start= (plan vs record, phase 1)."
+    notes: `${routeOf(blockTemplateOperations.week)}?start= (plan vs record, phase 1).`
   },
   {
     path: ["block-templates", "defaults"],
     summary: "Give a member with no block templates the default week (sleep, morning, work, meals, a free evening). A no-op when they have templates.",
     args: [],
     flags: [],
-    scopes: ["calendar:write"],
+    scopes: [...blockTemplateOperations.defaults.scopes],
     returns: "BlockTemplateView[]",
-    notes: "POST /api/v1/block-templates/defaults (plan vs record, phase 1)."
+    notes: `${routeOf(blockTemplateOperations.defaults)} (plan vs record, phase 1).`
   },
   {
     path: ["time-blocks", "record"],
@@ -32584,18 +34274,18 @@ var COMMAND_SPECS = [
       },
       { name: "for", type: "string", description: "Only this member's plans (user id)." }
     ],
-    scopes: ["tasks:read"],
+    scopes: [...planOperations.list.scopes],
     returns: "Plan[]",
-    notes: "GET /api/v1/plans (#912): the latest 20."
+    notes: `${routeOf(planOperations.list)} (#912): the latest 20.`
   },
   {
     path: ["plans", "get"],
     summary: "One plan proposal with its items and each item's task as it is now.",
     args: [{ name: "id", required: true, description: "Plan id." }],
     flags: [],
-    scopes: ["tasks:read"],
+    scopes: [...planOperations.get.scopes],
     returns: "Plan",
-    notes: "GET /api/v1/plans/{id} (#912)."
+    notes: `${routeOf(planOperations.get)} (#912).`
   },
   {
     path: ["plans", "propose"],
@@ -32608,9 +34298,9 @@ var COMMAND_SPECS = [
         description: 'The CreatePlanInput as JSON: {"kind":"week","startsOn":"2026-10-19","note":"\u2026","items":[{"taskId":"\u2026","day":"2026-10-20","reason":"Deadline Friday"},{"taskId":"\u2026","at":"2026-10-21T09:00:00Z","durationMinutes":45},{"taskId":"\u2026","action":"someday"},{"taskId":"\u2026","action":"let_go"}],"blocks":[{"templateId":"\u2026","lifeKind":"meal","startAt":"2026-10-19T10:30:00Z","endAt":"2026-10-19T11:30:00Z"}]}. Blocks are life blocks (lay a week out with `do block-templates week`); a plan needs at least one item or block.'
       }
     ],
-    scopes: ["tasks:write"],
+    scopes: [...planOperations.create.scopes],
     returns: "Plan",
-    notes: "POST /api/v1/plans (#912). A week starts on a Monday; days are the member's, times are ISO instants inside the week. `forUserId` names the member (default: the member the key acts for). A newer plan for the same week or day replaces the open one."
+    notes: `${routeOf(planOperations.create)} (#912). A week starts on a Monday; days are the member's, times are ISO instants inside the week. \`forUserId\` names the member (default: the member the key acts for). A newer plan for the same week or day replaces the open one.`
   },
   {
     path: ["plans", "accept"],
@@ -32620,9 +34310,9 @@ var COMMAND_SPECS = [
       { name: "items", required: false, description: "Item ids (default: every proposed item)." }
     ],
     flags: [],
-    scopes: ["tasks:write"],
+    scopes: [...planOperations.accept.scopes],
     returns: "Plan",
-    notes: "POST /api/v1/plans/{id}/accept (#912). Undo with `do plans undo`."
+    notes: `${routeOf(planOperations.accept)} (#912). Undo with \`do plans undo\`.`
   },
   {
     path: ["plans", "dismiss"],
@@ -32632,9 +34322,9 @@ var COMMAND_SPECS = [
       { name: "items", required: false, description: "Item ids (default: every proposed item)." }
     ],
     flags: [],
-    scopes: ["tasks:write"],
+    scopes: [...planOperations.dismiss.scopes],
     returns: "Plan",
-    notes: "POST /api/v1/plans/{id}/dismiss (#912). Nothing is written to a task."
+    notes: `${routeOf(planOperations.dismiss)} (#912). Nothing is written to a task.`
   },
   {
     path: ["plans", "undo"],
@@ -32644,9 +34334,9 @@ var COMMAND_SPECS = [
       { name: "items", required: false, description: "Item ids (default: every answered item)." }
     ],
     flags: [],
-    scopes: ["tasks:write"],
+    scopes: [...planOperations.undo.scopes],
     returns: "Plan",
-    notes: "POST /api/v1/plans/{id}/undo (#912). The items read as proposed again."
+    notes: `${routeOf(planOperations.undo)} (#912). The items read as proposed again.`
   },
   {
     path: ["plan", "rules", "list"],
@@ -32660,9 +34350,9 @@ var COMMAND_SPECS = [
         description: "fixed_time, keep_free, meaning, whose, limit or note."
       }
     ],
-    scopes: ["planning:read"],
+    scopes: [...planningRuleOperations.list.scopes],
     returns: "PlanningRule[]",
-    notes: "GET /api/v1/planning/rules. Oldest first; `addedByAgent` marks the ones an agent added."
+    notes: `${routeOf(planningRuleOperations.list)}. Oldest first; \`addedByAgent\` marks the ones an agent added.`
   },
   {
     path: ["plan", "rules", "add"],
@@ -32680,9 +34370,9 @@ var COMMAND_SPECS = [
         description: "The member it is for (user id; default: the member the key acts for)."
       }
     ],
-    scopes: ["planning:write"],
+    scopes: [...planningRuleOperations.create.scopes],
     returns: "PlanningRule",
-    notes: "POST /api/v1/planning/rules. `forUserId` (--for) names the member; a rule without --rule is a note."
+    notes: `${routeOf(planningRuleOperations.create)}. \`forUserId\` (--for) names the member; a rule without --rule is a note.`
   },
   {
     path: ["plan", "rules", "update"],
@@ -32696,18 +34386,18 @@ var COMMAND_SPECS = [
         description: "The new structured part as JSON (see `plan rules add`), or `none` to make it a note."
       }
     ],
-    scopes: ["planning:write"],
+    scopes: [...planningRuleOperations.update.scopes],
     returns: "PlanningRule",
-    notes: "PATCH /api/v1/planning/rules/{id}."
+    notes: `${routeOf(planningRuleOperations.update)}.`
   },
   {
     path: ["plan", "rules", "remove"],
     summary: "Remove a planning rule (to the trash).",
     args: [{ name: "id", required: true, description: "Rule id." }],
     flags: [],
-    scopes: ["planning:write"],
+    scopes: [...planningRuleOperations.remove.scopes],
     returns: "void",
-    notes: "DELETE /api/v1/planning/rules/{id}. Destructive: needs --allow-destructive."
+    notes: `${routeOf(planningRuleOperations.remove)}. Destructive: needs --allow-destructive.`
   },
   {
     path: ["tasks", "ready"],
@@ -32720,16 +34410,16 @@ var COMMAND_SPECS = [
         description: `What's ready, in a line, with a link when there is one ("Draft ready: 38 hours, 3,420 euro \u2014 https://\u2026"); at most 500 characters. Absent keeps the note already there.`
       }
     ],
-    scopes: ["tasks:write"],
+    scopes: [...taskOperations.ready.scopes],
     returns: "Task",
-    notes: "POST /api/v1/tasks/{id}/ready (#902); 409 when the task is done or let go. It reaches Now's Needs you with Review (Looks good = done, Send back = `ready: false`). List them with `do tasks list --ready`."
+    notes: `${routeOf(taskOperations.ready)} (#902); 409 when the task is done or let go. It reaches Now's Needs you with Review (Looks good = done, Send back = \`ready: false\`). List them with \`do tasks list --ready\`.`
   },
   {
     path: ["task", "reopen"],
     summary: "Reopen a done or cancelled task (status todo; clears completedAt).",
     args: [{ name: "id", required: true, description: "Task ULID." }],
     flags: [],
-    scopes: ["tasks:write"],
+    scopes: [...taskOperations.update.scopes],
     returns: "Task"
   },
   {
@@ -32749,7 +34439,7 @@ var COMMAND_SPECS = [
         description: "How long it takes, in minutes (sets durationMinutes)."
       }
     ],
-    scopes: ["tasks:write"],
+    scopes: [...taskOperations.update.scopes],
     returns: "Task"
   },
   {
@@ -32768,7 +34458,7 @@ var COMMAND_SPECS = [
         description: "How long it takes, in minutes (sets durationMinutes)."
       }
     ],
-    scopes: ["tasks:write"],
+    scopes: [...taskOperations.update.scopes],
     returns: "Task"
   },
   {
@@ -32789,7 +34479,7 @@ var COMMAND_SPECS = [
         description: 'A short note on the check-in ("felt heavy"), at most 280 characters.'
       }
     ],
-    scopes: ["habits:write"],
+    scopes: [...habitOperations.checkIn.scopes],
     returns: "HabitSummary"
   },
   {
@@ -32816,7 +34506,7 @@ var COMMAND_SPECS = [
         description: 'A short note on the check-in ("felt heavy"), at most 280 characters.'
       }
     ],
-    scopes: ["habits:write"],
+    scopes: [...habitOperations.checkInByTitle.scopes],
     returns: "HabitSummary",
     notes: `POST /api/v1/habits/check-in. Title or alias, case-insensitive; several matches \u2192 409 with error.details.candidates (id, title, aliases), none \u2192 404 naming close titles; a habit counted from Google Fit, Strava or GitHub \u2192 409. --set writes the difference to the day's total as its own check-in. An Agent's key records the check-in as that Agent's ("<agent>, 07:12"). --note puts a short note on it ("drill done, felt heavy" \u2192 --note "felt heavy"); the reply's lastCheckIn.id is the check-in, for \`do habit note\` later.`
   },
@@ -32828,7 +34518,7 @@ var COMMAND_SPECS = [
       { name: "alias", required: true, description: "The other name." }
     ],
     flags: [],
-    scopes: ["habits:write"],
+    scopes: [...habitOperations.addAlias.scopes],
     returns: "HabitSummary",
     notes: "POST /api/v1/habits/:id/aliases. One already there (ignoring case) is a no-op; at most 12."
   },
@@ -32840,7 +34530,7 @@ var COMMAND_SPECS = [
       { name: "alias", required: true, description: "The alias to drop (ignoring case)." }
     ],
     flags: [],
-    scopes: ["habits:write"],
+    scopes: [...habitOperations.removeAlias.scopes],
     returns: "HabitSummary",
     notes: "DELETE /api/v1/habits/:id/aliases/:alias. 404 when the habit doesn't have it."
   },
@@ -32849,9 +34539,9 @@ var COMMAND_SPECS = [
     summary: "What's left today: the habits due by part of day, and today's routines.",
     args: [],
     flags: [],
-    scopes: ["habits:read"],
+    scopes: [...habitOperations.today.scopes],
     returns: "HabitsTodayResponse",
-    notes: "GET /api/v1/habits/today. Your saved time zone's day; already filtered by schedule. Each habit says done/open/skipped (never overdue), its value today, the week for an N-per-week habit and its last check-in (`by` names the Agent). Quit habits are left out."
+    notes: `${routeOf(habitOperations.today)}. Your saved time zone's day; already filtered by schedule. Each habit says done/open/skipped (never overdue), its value today, the week for an N-per-week habit and its last check-in (\`by\` names the Agent). Quit habits are left out.`
   },
   {
     path: ["habit", "check-ins"],
@@ -32861,7 +34551,7 @@ var COMMAND_SPECS = [
       { name: "before", type: "string", description: "Only check-ins before this instant (ISO)." },
       { name: "limit", type: "string", description: "Page size 1\u2013200 (default 50)." }
     ],
-    scopes: ["habits:read"],
+    scopes: [...habitOperations.listCheckIns.scopes],
     returns: "HabitEntry"
   },
   {
@@ -32877,9 +34567,9 @@ var COMMAND_SPECS = [
       { name: "note", required: false, description: "The note, at most 280 characters." }
     ],
     flags: [{ name: "clear", type: "boolean", description: "Drop the check-in's note." }],
-    scopes: ["habits:write"],
+    scopes: [...habitOperations.updateCheckIn.scopes],
     returns: "HabitEntry",
-    notes: "PATCH /api/v1/habits/{id}/check-ins/{entryId}. Replaces the note; the amount and time stay (undo a wrong check-in instead). A skip's note is its why."
+    notes: `${routeOf(habitOperations.updateCheckIn)}. Replaces the note; the amount and time stay (undo a wrong check-in instead). A skip's note is its why.`
   },
   {
     path: ["habit", "skip"],
@@ -32893,9 +34583,9 @@ var COMMAND_SPECS = [
         description: 'Why, if you like ("Dentist"); shows in the log.'
       }
     ],
-    scopes: ["habits:write"],
+    scopes: [...habitOperations.skip.scopes],
     returns: "HabitSummary",
-    notes: "POST /api/v1/habits/{id}/skip. The streak treats the period as neutral and spends no grace; the habit leaves Now for the day. Skipping a skipped day changes nothing. Undo: delete the skip entry (`do habit check-ins <id>` lists it with kind `skip`)."
+    notes: `${routeOf(habitOperations.skip)}. The streak treats the period as neutral and spends no grace; the habit leaves Now for the day. Skipping a skipped day changes nothing. Undo: delete the skip entry (\`do habit check-ins <id>\` lists it with kind \`skip\`).`
   },
   {
     path: ["routine", "done"],
@@ -32908,9 +34598,9 @@ var COMMAND_SPECS = [
       }
     ],
     flags: [],
-    scopes: ["routines:write"],
+    scopes: [...routineOperations.markDone.scopes],
     returns: "RoutineDoneResult",
-    notes: "POST /api/v1/routines/{id}/done. Today's run (your saved time zone's day), started if there's none. Each habit step checks in its habit; a habit already done today isn't counted twice; a step whose habit is skipped today is left alone. Calling it again changes nothing. Returns `run` and `taken` (the steps it resolved). Undo all of it with `do routine undo <run.id> <taken stepRunIds\u2026>`."
+    notes: `${routeOf(routineOperations.markDone)}. Today's run (your saved time zone's day), started if there's none. Each habit step checks in its habit; a habit already done today isn't counted twice; a step whose habit is skipped today is left alone. Calling it again changes nothing. Returns \`run\` and \`taken\` (the steps it resolved). Undo all of it with \`do routine undo <run.id> <taken stepRunIds\u2026>\`.`
   },
   {
     path: ["routine", "undo"],
@@ -32928,9 +34618,9 @@ var COMMAND_SPECS = [
       }
     ],
     flags: [],
-    scopes: ["routines:write"],
+    scopes: [...routineOperations.undoSteps.scopes],
     returns: "RoutineRunView",
-    notes: "POST /api/v1/routines/runs/{runId}/undo. Exactly the check-ins those steps wrote are removed; a finished run reopens. Steps no longer done are left alone."
+    notes: `${routeOf(routineOperations.undoSteps)}. Exactly the check-ins those steps wrote are removed; a finished run reopens. Steps no longer done are left alone.`
   },
   {
     path: ["habit", "pause"],
@@ -32943,9 +34633,9 @@ var COMMAND_SPECS = [
         description: "The day it's back (YYYY-MM-DD), after today. Required."
       }
     ],
-    scopes: ["habits:write"],
+    scopes: [...habitOperations.pause.scopes],
     returns: "HabitSummary",
-    notes: "POST /api/v1/habits/{id}/pause. Pausing a paused habit moves the day it's back. Paused days are neutral: the streak is frozen, never broken."
+    notes: `${routeOf(habitOperations.pause)}. Pausing a paused habit moves the day it's back. Paused days are neutral: the streak is frozen, never broken.`
   },
   {
     path: ["habit", "remind"],
@@ -32955,36 +34645,36 @@ var COMMAND_SPECS = [
       { name: "state", required: true, description: "`on` or `off`." }
     ],
     flags: [],
-    scopes: ["habits:write"],
+    scopes: [...habitOperations.update.scopes],
     returns: "HabitSummary",
-    notes: "PATCH /api/v1/habits/{id} {remind}. Off by default. On, the habit sends one Web Push a day at its time of day (a part of day: morning 08:00, midday 12:00, evening 18:00; none: 09:00), only in waking hours (07:00\u201322:00), with Done / +1 / Skip today buttons; not when it's done, skipped, paused or off today."
+    notes: `${routeOf(habitOperations.update)} {remind}. Off by default. On, the habit sends one Web Push a day at its time of day (a part of day: morning 08:00, midday 12:00, evening 18:00; none: 09:00), only in waking hours (07:00\u201322:00), with Done / +1 / Skip today buttons; not when it's done, skipped, paused or off today.`
   },
   {
     path: ["habit", "resume"],
     summary: "Resume a paused habit: it's back today.",
     args: [{ name: "id", required: true, description: "Habit ULID." }],
     flags: [],
-    scopes: ["habits:write"],
+    scopes: [...habitOperations.resume.scopes],
     returns: "HabitSummary",
-    notes: "POST /api/v1/habits/{id}/resume. The rest so far stays neutral."
+    notes: `${routeOf(habitOperations.resume)}. The rest so far stays neutral.`
   },
   {
     path: ["habit", "retire"],
     summary: `Retire a habit to the Grown shelf ("I'm done with the cold showers habit"): history kept.`,
     args: [{ name: "id", required: true, description: "Habit ULID." }],
     flags: [],
-    scopes: ["habits:write"],
+    scopes: [...habitOperations.retire.scopes],
     returns: "HabitSummary",
-    notes: "POST /api/v1/habits/{id}/retire. Not a delete: it keeps every check-in and its plant blooms on the Grown shelf. It leaves Now and Today, sends no push, takes no check-in by title and is never due; Progress keeps its past. `do habits list --retired` lists the shelf. Undo: `do habit unretire <id>`."
+    notes: `${routeOf(habitOperations.retire)}. Not a delete: it keeps every check-in and its plant blooms on the Grown shelf. It leaves Now and Today, sends no push, takes no check-in by title and is never due; Progress keeps its past. \`do habits list --retired\` lists the shelf. Undo: \`do habit unretire <id>\`.`
   },
   {
     path: ["habit", "unretire"],
     summary: "Bring a grown (retired) habit back: growing again from today.",
     args: [{ name: "id", required: true, description: "Habit ULID." }],
     flags: [],
-    scopes: ["habits:write"],
+    scopes: [...habitOperations.unretire.scopes],
     returns: "HabitSummary",
-    notes: "POST /api/v1/habits/{id}/unretire. Its history is intact."
+    notes: `${routeOf(habitOperations.unretire)}. Its history is intact.`
   },
   {
     path: ["away"],
@@ -33828,7 +35518,7 @@ var COMMAND_SPECS = [
     summary: "List the Space's Agents (id + name).",
     args: [],
     flags: [],
-    scopes: ["agents:read"],
+    scopes: [...agentOperations.list.scopes],
     returns: "AgentSummary",
     notes: "Creating an Agent and minting its keys stays a member's job in the app."
   },
@@ -34145,7 +35835,7 @@ var COMMAND_SPECS = [
     summary: "Show the caller's settings for the Space.",
     args: [],
     flags: [],
-    scopes: ["settings:read"],
+    scopes: [...settingsOperations.get.scopes],
     returns: "UserSettings",
     notes: "Needs a key minted while logged in (it carries the user identity)."
   },
@@ -34154,7 +35844,7 @@ var COMMAND_SPECS = [
     summary: "Patch the caller's settings.",
     args: [],
     flags: [{ name: "data", type: "string", description: "JSON of fields to change." }],
-    scopes: ["settings:write"],
+    scopes: [...settingsOperations.update.scopes],
     returns: "UserSettings"
   },
   {
@@ -34312,9 +36002,9 @@ var COMMAND_SPECS = [
     summary: "An asset's upkeep and repair Tasks, open ones first.",
     args: [{ name: "id", required: true, description: "Asset (Collection Item) ULID." }],
     flags: [],
-    scopes: ["collections:read"],
+    scopes: [...collectionUpkeepOperations.list.scopes],
     returns: "AssetUpkeep",
-    notes: "GET /api/v1/collection/{id}/upkeep (LifeOS House). Returns { itemId, upkeep, repairs }."
+    notes: `${routeOf(collectionUpkeepOperations.list)} (LifeOS House). Returns { itemId, upkeep, repairs }.`
   },
   {
     path: ["collection", "link-task"],
@@ -34324,9 +36014,9 @@ var COMMAND_SPECS = [
       { name: "taskId", required: true, description: "Task ULID." }
     ],
     flags: [{ name: "repair", type: "boolean", description: "A one-off repair, not upkeep." }],
-    scopes: ["collections:write"],
+    scopes: [...collectionUpkeepOperations.link.scopes],
     returns: "AssetUpkeep",
-    notes: "POST /api/v1/collection/{id}/upkeep. Make the Task (recurrence, Place, Area) first. Finishing it writes the asset's service / repair Entry by itself."
+    notes: `${routeOf(collectionUpkeepOperations.link)}. Make the Task (recurrence, Place, Area) first. Finishing it writes the asset's service / repair Entry by itself.`
   },
   {
     path: ["collection", "unlink-task"],
@@ -34336,7 +36026,7 @@ var COMMAND_SPECS = [
       { name: "taskId", required: true, description: "Task ULID." }
     ],
     flags: [],
-    scopes: ["collections:write"],
+    scopes: [...collectionUpkeepOperations.unlink.scopes],
     returns: "AssetUpkeep"
   },
   {
@@ -35183,6 +36873,35 @@ var COMMAND_SPECS = [
     returns: "MoneyYear",
     notes: "GET /api/v1/money/year. totals (income, spent, saved) and lastYear (the same months a year earlier, null with nothing booked then); months Jan\u2013Dec; spending and income by category, biggest first, each with lastYear; recurring streams with thisYear, lastYear and change (new \xB7 stopped \xB7 up \xB7 down \xB7 same); goals with what went toward them this year. A year under way counts to this month (through)."
   },
+  {
+    path: ["money", "net-worth"],
+    summary: "Net worth now and its month-end line (the accounts that count in it).",
+    args: [],
+    flags: [
+      { name: "scope", type: "string", description: "all (default) | space | owner." },
+      {
+        name: "months",
+        type: "string",
+        description: "How many months the line covers (2\u201360, default 12)."
+      }
+    ],
+    scopes: ["finance:read"],
+    returns: "MoneyNetWorth",
+    notes: "GET /api/v1/money/net-worth. total, have and owe this month; points per month (oldest first, total null before any value); accounts biggest first with value, source (balance \xB7 ledger \xB7 manual) and the month it's from. A loan or a card always counts as owed."
+  },
+  {
+    path: ["money", "net-worth-set"],
+    summary: "Set an account's value for a month by hand (a house, a car); again replaces it.",
+    args: [{ name: "accountId", required: true, description: "Account ULID." }],
+    flags: [
+      { name: "value", type: "string", description: "The value, e.g. 310000 or 1234.56." },
+      { name: "month", type: "string", description: "The month, YYYY-MM (default this month)." },
+      { name: "data", type: "string", description: "SetMoneyNetWorthValueInput JSON instead." }
+    ],
+    scopes: ["finance:write"],
+    returns: "MoneySnapshot",
+    notes: "PUT /api/v1/money/net-worth/values. A month ahead is refused. This month's value also becomes the account's balance unless a bank link keeps it. `do money net-worth-set <accountId> --value 310000`."
+  },
   {
     path: ["money", "goals"],
     summary: "List money goals: what's saved toward each, soonest first.",
@@ -35639,63 +37358,63 @@ var COMMAND_SPECS = [
     summary: "Whether the Space has linked Home Assistant, how many entities are mapped, the newest reading.",
     args: [],
     flags: [],
-    scopes: ["places:read"],
+    scopes: [...sensorOperations.status.scopes],
     returns: "HomeAssistantStatus",
-    notes: "GET /api/v1/sensors/home-assistant. Home Assistant is linked in the app's Settings \u2192 Home; the token is never returned."
+    notes: `${routeOf(sensorOperations.status)}. Home Assistant is linked in the app's Settings \u2192 Home; the token is never returned.`
   },
   {
     path: ["sensors", "entities"],
     summary: "Every entity Home Assistant has, with its state, the reading it likely gives and what it's mapped to.",
     args: [],
     flags: [],
-    scopes: ["places:read"],
+    scopes: [...sensorOperations.entities.scopes],
     returns: "HomeAssistantEntity[]",
-    notes: "GET /api/v1/sensors/home-assistant/entities. 409 before Home Assistant is linked; 503 when it doesn't answer."
+    notes: `${routeOf(sensorOperations.entities)}. 409 before Home Assistant is linked; 503 when it doesn't answer.`
   },
   {
     path: ["sensors", "sync"],
     summary: "Read every mapped entity now and put its state on the ledger, as the five-minute sync does.",
     args: [],
     flags: [],
-    scopes: ["places:write"],
+    scopes: [...sensorOperations.sync.scopes],
     returns: "SensorSyncResult",
-    notes: "POST /api/v1/sensors/home-assistant/sync. A room's readings feed its card and the room alarm; an asset's show on its page. Returns entities, written, skipped, missing and the error (unauthorized, unavailable, bad_response). 409 before Home Assistant is linked."
+    notes: `${routeOf(sensorOperations.sync)}. A room's readings feed its card and the room alarm; an asset's show on its page. Returns entities, written, skipped, missing and the error (unauthorized, unavailable, bad_response). 409 before Home Assistant is linked.`
   },
   {
     path: ["sensors", "unifi"],
     summary: "Whether the Space has linked UniFi, how many devices are mapped, the newest reading.",
     args: [],
     flags: [],
-    scopes: ["places:read"],
+    scopes: [...sensorOperations.unifiStatus.scopes],
     returns: "UnifiStatus",
-    notes: "GET /api/v1/sensors/unifi. Linking UniFi (address + API key) is a member's, in Settings \u2192 Home; a key never sees the API key."
+    notes: `${routeOf(sensorOperations.unifiStatus)}. Linking UniFi (address + API key) is a member's, in Settings \u2192 Home; a key never sees the API key.`
   },
   {
     path: ["sensors", "unifi-devices"],
     summary: "Every device and connected client UniFi sees, with the asset each is mapped to.",
     args: [],
     flags: [],
-    scopes: ["places:read", "collections:read"],
+    scopes: [...sensorOperations.unifiDevices.scopes],
     returns: "UnifiDevice[]",
-    notes: "GET /api/v1/sensors/unifi/devices. Map one with `do sensors map <mac> <asset> --reading presence --provider unifi`, or give the asset `external.unifiMac` on its facet. 409 before UniFi is linked."
+    notes: `${routeOf(sensorOperations.unifiDevices)}. Map one with \`do sensors map <mac> <asset> --reading presence --provider unifi\`, or give the asset \`external.unifiMac\` on its facet. 409 before UniFi is linked.`
   },
   {
     path: ["sensors", "unifi-sync"],
     summary: "Put every mapped device's presence (online/offline, firmware) on its asset now.",
     args: [],
     flags: [],
-    scopes: ["places:write"],
+    scopes: [...sensorOperations.syncUnifi.scopes],
     returns: "SensorSyncResult",
-    notes: "POST /api/v1/sensors/unifi/sync. Assets whose facet names a UniFi MAC are mapped first; readings land as asset.presence on change, else hourly. The worker does the same every five minutes. 409 before UniFi is linked."
+    notes: `${routeOf(sensorOperations.syncUnifi)}. Assets whose facet names a UniFi MAC are mapped first; readings land as asset.presence on change, else hourly. The worker does the same every five minutes. 409 before UniFi is linked.`
   },
   {
     path: ["sensors", "links"],
     summary: "The mapped entities, or the ones on one Place or asset.",
     args: [],
     flags: [{ name: "node", type: "string", description: "Only the mappings on this node ULID." }],
-    scopes: ["places:read"],
+    scopes: [...sensorOperations.links.scopes],
     returns: "SensorLink[]",
-    notes: "GET /api/v1/sensors/links."
+    notes: `${routeOf(sensorOperations.links)}.`
   },
   {
     path: ["sensors", "map"],
@@ -35721,18 +37440,18 @@ var COMMAND_SPECS = [
       },
       { name: "label", type: "string", description: "A name for it (Home Assistant's own)." }
     ],
-    scopes: ["places:write"],
+    scopes: [...sensorOperations.createLink.scopes],
     returns: "SensorLink",
-    notes: "POST /api/v1/sensors/links. An animal maps to the Place it's housed in (409 when it has none). Mapping an entity again moves it."
+    notes: `${routeOf(sensorOperations.createLink)}. An animal maps to the Place it's housed in (409 when it has none). Mapping an entity again moves it.`
   },
   {
     path: ["sensors", "unmap"],
     summary: "Unmap an entity; the readings it gave stay.",
     args: [{ name: "link", required: true, description: "The sensor link ULID." }],
     flags: [],
-    scopes: ["places:write"],
+    scopes: [...sensorOperations.removeLink.scopes],
     returns: "None",
-    notes: "DELETE /api/v1/sensors/links/{id}."
+    notes: `${routeOf(sensorOperations.removeLink)}.`
   },
   {
     path: ["runs", "sessions", "list"],
@@ -35932,7 +37651,7 @@ var COMMAND_SPECS = [
     summary: "Your Google Contacts, to pick from: who they'd merge into and what importing adds.",
     args: [],
     flags: [{ name: "q", type: "string", description: "A name or email to narrow to." }],
-    scopes: ["contacts:read"],
+    scopes: [...googleContactsOperations.list.scopes],
     returns: "GoogleContactsList",
     notes: "Connecting needs a browser (People \u2192 Import). Not connected: candidates is empty and status.connected false. A key with no member is forbidden."
   },
@@ -35947,7 +37666,7 @@ var COMMAND_SPECS = [
       }
     ],
     flags: [],
-    scopes: ["contacts:write"],
+    scopes: [...googleContactsOperations.import.scopes],
     returns: "GoogleContactsImportResult",
     notes: "Each merges into the contact it matches (email, then phone, then a unique name) and fills in only a missing email, phone or birthday; the rest become new contacts. Ids Google no longer has come back as missing. Not connected is a conflict."
   },
@@ -36042,7 +37761,7 @@ var COMMAND_SPECS = [
         description: 'JSON MarkGuestsSentInput, e.g. {"guestIds":["01\u2026"],"what":"save_the_date"} (or "invite"; "at" defaults to now).'
       }
     ],
-    scopes: ["contacts:write"],
+    scopes: [...guestOperations.sent.scopes],
     returns: "GuestView"
   },
   {
@@ -36056,7 +37775,7 @@ var COMMAND_SPECS = [
         description: 'JSON AddRsvpPresetsInput, e.g. {"guestListId":"01\u2026","presets":["diet","message"]}'
       }
     ],
-    scopes: ["contacts:write"],
+    scopes: [...rsvpQuestionOperations.presets.scopes],
     returns: "RsvpQuestion"
   },
   {
@@ -36067,7 +37786,7 @@ var COMMAND_SPECS = [
       { name: "list", type: "string", description: "The guest list's id (required)." },
       { name: "household", type: "string", description: "Only this household's answers." }
     ],
-    scopes: ["contacts:read"],
+    scopes: [...rsvpAnswerOperations.list.scopes],
     returns: "RsvpAnswer"
   },
   {
@@ -36081,7 +37800,7 @@ var COMMAND_SPECS = [
         description: 'JSON SetRsvpAnswersInput, e.g. {"guestListId":"01\u2026","householdId":"01\u2026","answers":[{"questionId":"01\u2026","value":true},{"questionId":"01\u2026","guestId":"01\u2026","value":["vegan"]}]}'
       }
     ],
-    scopes: ["contacts:write"],
+    scopes: [...rsvpAnswerOperations.set.scopes],
     returns: "RsvpAnswer"
   },
   {
@@ -36128,7 +37847,7 @@ var COMMAND_SPECS = [
     summary: "A guest list's mail campaigns (save-the-dates, invitations), newest first.",
     args: [],
     flags: [{ name: "list", type: "string", description: "The guest list's id (required)." }],
-    scopes: ["contacts:read"],
+    scopes: [...mailCampaignOperations.list.scopes],
     returns: "MailCampaignView",
     notes: "Each campaign carries the households it reaches (a draft: who it would go to) with their status, its mails by status, and readyToSend."
   },
@@ -36137,7 +37856,7 @@ var COMMAND_SPECS = [
     summary: "One mail campaign, with its households and how far it got.",
     args: [{ name: "id", required: true, description: "The campaign's id." }],
     flags: [],
-    scopes: ["contacts:read"],
+    scopes: [...mailCampaignOperations.get.scopes],
     returns: "MailCampaignView"
   },
   {
@@ -36151,7 +37870,7 @@ var COMMAND_SPECS = [
         description: 'JSON CreateMailCampaignInput, e.g. {"guestListId":"01\u2026","kind":"save_the_date","template":"message","data":{"nl":{"subject":"\u2026","heading":"\u2026","paragraphs":["\u2026"]},"pt":{\u2026},"footer":{"deleteBy":"2027-12-31"}},"replyTo":"hallo@example.com"}'
       }
     ],
-    scopes: ["contacts:write"],
+    scopes: [...mailCampaignOperations.create.scopes],
     returns: "MailCampaignView",
     notes: "Drafting only: a member previews it, sends a test to the Space's members and sends it from the Mail tab. An agent can never test or send."
   },
@@ -36166,7 +37885,7 @@ var COMMAND_SPECS = [
         description: 'JSON UpdateMailCampaignInput, e.g. {"data":{"nl":{\u2026}}}'
       }
     ],
-    scopes: ["contacts:write"],
+    scopes: [...mailCampaignOperations.update.scopes],
     returns: "MailCampaignView",
     notes: "Only a draft changes (409 otherwise); an edit makes the last test stale."
   },
@@ -36175,7 +37894,7 @@ var COMMAND_SPECS = [
     summary: "Draw a campaign's mail as its first household would get it.",
     args: [{ name: "id", required: true, description: "The campaign's id." }],
     flags: [{ name: "language", type: "string", description: "nl (default) or pt." }],
-    scopes: ["contacts:read"],
+    scopes: [...mailCampaignOperations.preview.scopes],
     returns: "MailPreview"
   },
   {
@@ -36195,7 +37914,7 @@ var COMMAND_SPECS = [
       {
         name: "kind",
         type: "string",
-        description: "caterer (meals and diets per table), venue (who sits where), church (who comes to the ceremony), answers (every RSVP answer, a row per guest), floor-plan (PDF) or invitations (PDF: a card per household with a live RSVP link, its QR and code)."
+        description: "caterer (meals and diets per table), venue (who sits where), church (who comes to the ceremony), answers (every RSVP answer, a row per guest), floor-plan (PDF), invitations (PDF: a card per household with a live RSVP link, its QR and code) or printer (CSV of those cards: household, address lines, country, language, code, URL)."
       },
       {
         name: "out",
@@ -38767,7 +40486,7 @@ var HANDLERS = {
   "today earlier": async ({ flags, io, requireClient }) => {
     const area = flagString(flags, "area");
     return {
-      data: await requireClient().get("/today/from-earlier", {
+      data: await requireClient().get(pathOf(todayOperations.fromEarlier), {
         query: { from: localDayStart(io.now()).toISOString(), areaId: area }
       }),
       render: renderFromEarlier
@@ -39692,27 +41411,36 @@ var HANDLERS = {
   },
   "task cancel": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "task id");
-    return { data: await requireClient().post(`/tasks/${id}/cancel`, {}), render: renderTask };
+    return {
+      data: await requireClient().post(pathOf(taskOperations.cancel, { id }), {}),
+      render: renderTask
+    };
   },
   "tasks accept": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "task id");
-    return { data: await requireClient().post(`/tasks/${id}/accept`, {}), render: renderTask };
+    return {
+      data: await requireClient().post(pathOf(taskOperations.accept, { id }), {}),
+      render: renderTask
+    };
   },
   "tasks dismiss": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "task id");
-    return { data: await requireClient().post(`/tasks/${id}/not-now`, {}), render: renderTask };
+    return {
+      data: await requireClient().post(pathOf(taskOperations.notNow, { id }), {}),
+      render: renderTask
+    };
   },
   "block-templates week": async ({ flags, requireClient }) => {
     const start = flagString(flags, "start");
     if (start === undefined)
       throw usageError("block-templates week needs --start");
     return {
-      data: await requireClient().get("/block-templates/week", { query: { start } }),
+      data: await requireClient().get(pathOf(blockTemplateOperations.week), { query: { start } }),
       render: renderRecord
     };
   },
   "block-templates defaults": async ({ requireClient }) => ({
-    data: await requireClient().post("/block-templates/defaults", {}),
+    data: await requireClient().post(pathOf(blockTemplateOperations.defaults), {}),
     render: renderRecord
   }),
   "time-blocks record": async ({ args, requireClient }) => {
@@ -39797,7 +41525,7 @@ var HANDLERS = {
     };
   },
   "plans list": async ({ flags, requireClient }) => {
-    const plans = await requireClient().get("/plans", {
+    const plans = await requireClient().get(pathOf(planOperations.list), {
       query: {
         kind: flagString(flags, "kind"),
         status: flagString(flags, "status"),
@@ -39809,19 +41537,25 @@ var HANDLERS = {
   },
   "plans get": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "plan id");
-    return { data: await requireClient().get(`/plans/${id}`), render: renderPlan };
+    return {
+      data: await requireClient().get(pathOf(planOperations.get, { id })),
+      render: renderPlan
+    };
   },
   "plans propose": async ({ flags, requireClient }) => {
     if (flagString(flags, "data") === undefined)
       throw usageError("plans propose needs --data");
     const body = parseInput(createPlanInputSchema, readDataFlag(flags));
-    return { data: await requireClient().post("/plans", body), render: renderPlan };
+    return {
+      data: await requireClient().post(pathOf(planOperations.create), body),
+      render: renderPlan
+    };
   },
   "plans accept": async (ctx) => planDecision(ctx, "accept"),
   "plans dismiss": async (ctx) => planDecision(ctx, "dismiss"),
   "plans undo": async (ctx) => planDecision(ctx, "undo"),
   "plan rules list": async ({ flags, requireClient }) => {
-    const rules = await requireClient().get("/planning/rules", {
+    const rules = await requireClient().get(pathOf(planningRuleOperations.list), {
       query: { forUserId: flagString(flags, "for"), kind: flagString(flags, "kind") }
     });
     return { data: rules, render: renderPlanningRules };
@@ -39838,7 +41572,7 @@ var HANDLERS = {
       ...flagString(flags, "for") ? { forUserId: flagString(flags, "for") } : {}
     });
     return {
-      data: await requireClient().post("/planning/rules", body),
+      data: await requireClient().post(pathOf(planningRuleOperations.create), body),
       render: renderPlanningRule
     };
   },
@@ -39850,26 +41584,32 @@ var HANDLERS = {
       ...rule !== undefined ? { rule } : {}
     });
     return {
-      data: await requireClient().patch(`/planning/rules/${id}`, body),
+      data: await requireClient().patch(pathOf(planningRuleOperations.update, { id }), body),
       render: renderPlanningRule
     };
   },
   "plan rules remove": async ({ args, flags, requireClient }) => {
     const id = requireArg(args, 0, "rule id");
     assertDestructiveAllowed(flags, "remove a planning rule");
-    await requireClient().delete(`/planning/rules/${id}`);
+    await requireClient().delete(pathOf(planningRuleOperations.remove, { id }));
     return { data: { id, removed: true }, render: () => `Removed rule ${id}.` };
   },
   "tasks ready": async ({ args, flags, requireClient }) => {
     const id = requireArg(args, 0, "task id");
     const note = flagString(flags, "note");
     const body = parseInput(markTaskReadyInputSchema, note !== undefined ? { note } : {});
-    return { data: await requireClient().post(`/tasks/${id}/ready`, body), render: renderTask };
+    return {
+      data: await requireClient().post(pathOf(taskOperations.ready, { id }), body),
+      render: renderTask
+    };
   },
   "task reopen": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "task id");
     const body = parseInput(updateTaskInputSchema, { status: "todo" });
-    return { data: await requireClient().patch(`/tasks/${id}`, body), render: renderTask };
+    return {
+      data: await requireClient().patch(pathOf(taskOperations.update, { id }), body),
+      render: renderTask
+    };
   },
   "task snooze": async ({ args, flags, io, requireClient }) => {
     const id = requireArg(args, 0, "task id");
@@ -39881,7 +41621,10 @@ var HANDLERS = {
       ...until ? { allDay: until.allDay } : {},
       ...duration ? { durationMinutes: duration } : {}
     });
-    return { data: await requireClient().patch(`/tasks/${id}`, body), render: renderTask };
+    return {
+      data: await requireClient().patch(pathOf(taskOperations.update, { id }), body),
+      render: renderTask
+    };
   },
   "task schedule": async ({ args, flags, requireClient }) => {
     const id = requireArg(args, 0, "task id");
@@ -39894,7 +41637,10 @@ var HANDLERS = {
       allDay: at.allDay,
       ...duration ? { durationMinutes: duration } : {}
     });
-    return { data: await requireClient().patch(`/tasks/${id}`, body), render: renderTask };
+    return {
+      data: await requireClient().patch(pathOf(taskOperations.update, { id }), body),
+      render: renderTask
+    };
   },
   "habit log": async ({ args, flags, requireClient }) => {
     const id = requireArg(args, 0, "habit id");
@@ -39911,7 +41657,7 @@ var HANDLERS = {
       ...note !== undefined ? { note } : {}
     });
     return {
-      data: await requireClient().post(`/habits/${id}/check-ins`, input),
+      data: await requireClient().post(pathOf(habitOperations.checkIn, { id }), input),
       render: renderHabit
     };
   },
@@ -39935,7 +41681,10 @@ var HANDLERS = {
       ...at ? { occurredAt: at } : {},
       ...note !== undefined ? { note } : {}
     });
-    return { data: await requireClient().post("/habits/check-in", input), render: renderHabit };
+    return {
+      data: await requireClient().post(pathOf(habitOperations.checkInByTitle), input),
+      render: renderHabit
+    };
   },
   "habit alias add": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "habit id");
@@ -39944,7 +41693,7 @@ var HANDLERS = {
       throw usageError("habit alias add needs an alias, e.g. `do habit alias add <id> wake`");
     const input = parseInput(habitAliasInputSchema, { alias });
     return {
-      data: await requireClient().post(`/habits/${id}/aliases`, input),
+      data: await requireClient().post(pathOf(habitOperations.addAlias, { id }), input),
       render: renderHabit
     };
   },
@@ -39954,12 +41703,12 @@ var HANDLERS = {
     if (!alias)
       throw usageError("habit alias rm needs the alias to drop");
     return {
-      data: await requireClient().delete(`/habits/${id}/aliases/${encodeURIComponent(alias)}`),
+      data: await requireClient().delete(pathOf(habitOperations.removeAlias, { id, alias })),
       render: renderHabit
     };
   },
   "habits today": async ({ requireClient }) => ({
-    data: await requireClient().get("/habits/today"),
+    data: await requireClient().get(pathOf(habitOperations.today)),
     render: renderHabitsToday
   }),
   "habit check-ins": async ({ args, flags, requireClient }) => {
@@ -39969,7 +41718,7 @@ var HANDLERS = {
       limit: flagString(flags, "limit")
     };
     return {
-      data: await requireClient().get(`/habits/${id}/check-ins`, { query }),
+      data: await requireClient().get(pathOf(habitOperations.listCheckIns, { id }), { query }),
       render: renderList
     };
   },
@@ -39984,7 +41733,7 @@ var HANDLERS = {
       throw usageError('habit note needs the note, e.g. `do habit note <id> <check-in id> "felt heavy"`');
     const input = parseInput(updateHabitEntryInputSchema, { note: clear ? null : text });
     return {
-      data: await requireClient().patch(`/habits/${id}/check-ins/${entryId}`, input),
+      data: await requireClient().patch(pathOf(habitOperations.updateCheckIn, { id, entryId }), input),
       render: renderHabitEntry
     };
   },
@@ -39996,7 +41745,10 @@ var HANDLERS = {
       ...date ? { date } : {},
       ...note !== undefined ? { note } : {}
     });
-    return { data: await requireClient().post(`/habits/${id}/skip`, input), render: renderHabit };
+    return {
+      data: await requireClient().post(pathOf(habitOperations.skip, { id }), input),
+      render: renderHabit
+    };
   },
   "habit pause": async ({ args, flags, requireClient }) => {
     const id = requireArg(args, 0, "habit id");
@@ -40004,7 +41756,10 @@ var HANDLERS = {
     if (!until)
       throw usageError("habit pause needs --until <YYYY-MM-DD>, the day it's back");
     const input = parseInput(habitPauseInputSchema, { until });
-    return { data: await requireClient().post(`/habits/${id}/pause`, input), render: renderHabit };
+    return {
+      data: await requireClient().post(pathOf(habitOperations.pause, { id }), input),
+      render: renderHabit
+    };
   },
   "habit remind": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "habit id");
@@ -40012,19 +41767,31 @@ var HANDLERS = {
     if (state !== "on" && state !== "off")
       throw usageError("habit remind takes `on` or `off`");
     const input = parseInput(updateHabitInputSchema, { remind: state === "on" });
-    return { data: await requireClient().patch(`/habits/${id}`, input), render: renderHabit };
+    return {
+      data: await requireClient().patch(pathOf(habitOperations.update, { id }), input),
+      render: renderHabit
+    };
   },
   "habit resume": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "habit id");
-    return { data: await requireClient().post(`/habits/${id}/resume`, {}), render: renderHabit };
+    return {
+      data: await requireClient().post(pathOf(habitOperations.resume, { id }), {}),
+      render: renderHabit
+    };
   },
   "habit retire": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "habit id");
-    return { data: await requireClient().post(`/habits/${id}/retire`, {}), render: renderHabit };
+    return {
+      data: await requireClient().post(pathOf(habitOperations.retire, { id }), {}),
+      render: renderHabit
+    };
   },
   "habit unretire": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "habit id");
-    return { data: await requireClient().post(`/habits/${id}/unretire`, {}), render: renderHabit };
+    return {
+      data: await requireClient().post(pathOf(habitOperations.unretire, { id }), {}),
+      render: renderHabit
+    };
   },
   away: async ({ args, flags, requireClient }) => {
     const until = flagString(flags, "until");
@@ -40043,7 +41810,7 @@ var HANDLERS = {
     const id = requireArg(args, 0, "routine id");
     const input = parseInput(routineDoneInputSchema, {});
     return {
-      data: await requireClient().post(`/routines/${id}/done`, input),
+      data: await requireClient().post(pathOf(routineOperations.markDone, { id }), input),
       render: renderRoutineDone
     };
   },
@@ -40055,7 +41822,7 @@ var HANDLERS = {
     }
     const input = parseInput(routineRunUndoInputSchema, { stepRunIds });
     return {
-      data: await requireClient().post(`/routines/runs/${runId}/undo`, input),
+      data: await requireClient().post(pathOf(routineOperations.undoSteps, { runId }), input),
       render: renderRoutineUndo
     };
   },
@@ -40099,7 +41866,7 @@ var HANDLERS = {
     };
   },
   "agents list": async ({ requireClient }) => ({
-    data: await requireClient().getPage("/agents"),
+    data: await requireClient().getPage(pathOf(agentOperations.list)),
     render: renderList
   }),
   "agent connection get": async ({ requireClient }) => ({
@@ -40215,12 +41982,15 @@ var HANDLERS = {
     };
   },
   "settings get": async ({ requireClient }) => ({
-    data: await requireClient().get("/settings"),
+    data: await requireClient().get(pathOf(settingsOperations.get)),
     render: renderRecord
   }),
   "settings update": async ({ flags, requireClient }) => {
     const body = parseInput(updateUserSettingsInputSchema, readDataFlag(flags));
-    return { data: await requireClient().patch("/settings", body), render: renderRecord };
+    return {
+      data: await requireClient().patch(pathOf(settingsOperations.update), body),
+      render: renderRecord
+    };
   },
   "modules list": async ({ requireClient }) => {
     const settings = await requireClient().get("/settings");
@@ -40314,7 +42084,10 @@ var HANDLERS = {
   },
   "collection upkeep": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "item id");
-    return { data: await requireClient().get(`/collection/${id}/upkeep`), render: renderRecord };
+    return {
+      data: await requireClient().get(pathOf(collectionUpkeepOperations.list, { id })),
+      render: renderRecord
+    };
   },
   "collection link-task": async ({ args, flags, requireClient }) => {
     const id = requireArg(args, 0, "item id");
@@ -40324,7 +42097,7 @@ var HANDLERS = {
       kind: flagBool(flags, "repair") ? "repairs" : "maintains"
     });
     return {
-      data: await requireClient().post(`/collection/${id}/upkeep`, body),
+      data: await requireClient().post(pathOf(collectionUpkeepOperations.link, { id }), body),
       render: renderRecord
     };
   },
@@ -40332,7 +42105,7 @@ var HANDLERS = {
     const id = requireArg(args, 0, "item id");
     const taskId = requireArg(args, 1, "task id");
     return {
-      data: await requireClient().delete(`/collection/${id}/upkeep/${taskId}`),
+      data: await requireClient().delete(pathOf(collectionUpkeepOperations.unlink, { id, taskId })),
       render: renderRecord
     };
   },
@@ -40897,6 +42670,23 @@ var HANDLERS = {
     });
     return { data: await requireClient().post("/money/budget/copy", body), render: renderRecord };
   },
+  "money net-worth": async ({ flags, requireClient }) => ({
+    data: await requireClient().get("/money/net-worth", {
+      query: { scope: flagString(flags, "scope"), months: flagString(flags, "months") }
+    }),
+    render: renderRecord
+  }),
+  "money net-worth-set": async ({ args, flags, requireClient }) => {
+    const body = flagString(flags, "data") !== undefined ? parseInput(setMoneyNetWorthValueInputSchema, readDataFlag(flags)) : parseInput(setMoneyNetWorthValueInputSchema, {
+      accountId: requireArg(args, 0, "account id"),
+      value: requireFlag(flags, "value", "money net-worth-set needs --value <amount>"),
+      month: flagString(flags, "month")
+    });
+    return {
+      data: await requireClient().put("/money/net-worth/values", body),
+      render: renderRecord
+    };
+  },
   "money goals": async ({ requireClient }) => ({
     data: await requireClient().get("/money/goals"),
     render: renderList
@@ -41206,31 +42996,31 @@ var HANDLERS = {
     return { data: await requireClient().post("/runs/steam/sync", body), render: renderRecord };
   },
   "sensors status": async ({ requireClient }) => ({
-    data: await requireClient().get("/sensors/home-assistant"),
+    data: await requireClient().get(pathOf(sensorOperations.status)),
     render: renderRecord
   }),
   "sensors entities": async ({ requireClient }) => ({
-    data: await requireClient().get("/sensors/home-assistant/entities"),
+    data: await requireClient().get(pathOf(sensorOperations.entities)),
     render: renderList
   }),
   "sensors sync": async ({ requireClient }) => ({
-    data: await requireClient().post("/sensors/home-assistant/sync", {}),
+    data: await requireClient().post(pathOf(sensorOperations.sync), {}),
     render: renderRecord
   }),
   "sensors unifi": async ({ requireClient }) => ({
-    data: await requireClient().get("/sensors/unifi"),
+    data: await requireClient().get(pathOf(sensorOperations.unifiStatus)),
     render: renderRecord
   }),
   "sensors unifi-devices": async ({ requireClient }) => ({
-    data: await requireClient().get("/sensors/unifi/devices"),
+    data: await requireClient().get(pathOf(sensorOperations.unifiDevices)),
     render: renderList
   }),
   "sensors unifi-sync": async ({ requireClient }) => ({
-    data: await requireClient().post("/sensors/unifi/sync", {}),
+    data: await requireClient().post(pathOf(sensorOperations.syncUnifi), {}),
     render: renderRecord
   }),
   "sensors links": async ({ flags, requireClient }) => ({
-    data: await requireClient().get("/sensors/links", {
+    data: await requireClient().get(pathOf(sensorOperations.links), {
       query: { nodeId: flagString(flags, "node") }
     }),
     render: renderList
@@ -41243,11 +43033,14 @@ var HANDLERS = {
       ...flagString(flags, "provider") ? { provider: flagString(flags, "provider") } : {},
       ...flagString(flags, "label") ? { label: flagString(flags, "label") } : {}
     });
-    return { data: await requireClient().post("/sensors/links", body), render: renderRecord };
+    return {
+      data: await requireClient().post(pathOf(sensorOperations.createLink), body),
+      render: renderRecord
+    };
   },
   "sensors unmap": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "sensor link id");
-    await requireClient().delete(`/sensors/links/${id}`);
+    await requireClient().delete(pathOf(sensorOperations.removeLink, { id }));
     return { data: { ok: true, unmapped: id }, render: renderRecord };
   },
   "runs sessions list": async ({ args, requireClient }) => {
@@ -41360,11 +43153,11 @@ var HANDLERS = {
     render: renderRecord
   }),
   "health google status": async ({ requireClient }) => ({
-    data: await requireClient().get("/health/google-health"),
+    data: await requireClient().get(pathOf(googleHealthOperations.status)),
     render: renderRecord
   }),
   "health google sync": async ({ requireClient }) => ({
-    data: await requireClient().post("/health/google-health/sync", {}),
+    data: await requireClient().post(pathOf(googleHealthOperations.sync), {}),
     render: renderRecord
   }),
   "health consent": async ({ requireClient }) => ({
@@ -41595,7 +43388,9 @@ var HANDLERS = {
   "people google": async ({ flags, requireClient }) => {
     const q = flagString(flags, "q");
     return {
-      data: await requireClient().get("/people/google-contacts", { query: q ? { q } : {} }),
+      data: await requireClient().get(pathOf(googleContactsOperations.list), {
+        query: q ? { q } : {}
+      }),
       render: renderRecord
     };
   },
@@ -41605,7 +43400,7 @@ var HANDLERS = {
     }
     const body = parseInput(importGoogleContactsInputSchema, { resourceNames: args });
     return {
-      data: await requireClient().post("/people/google-contacts/import", body),
+      data: await requireClient().post(pathOf(googleContactsOperations.import), body),
       render: renderRecord
     };
   },
@@ -41748,12 +43543,15 @@ var HANDLERS = {
   },
   "guests sent": async ({ flags, requireClient }) => {
     const body = parseInput(markGuestsSentInputSchema, readDataFlag(flags));
-    return { data: await requireClient().post("/guests/sent", body), render: renderRecord };
+    return {
+      data: await requireClient().post(pathOf(guestOperations.sent), body),
+      render: renderRecord
+    };
   },
   "rsvp-questions presets": async ({ flags, requireClient }) => {
     const body = parseInput(addRsvpPresetsInputSchema, readDataFlag(flags));
     return {
-      data: await requireClient().post("/rsvp-questions/presets", body),
+      data: await requireClient().post(pathOf(rsvpQuestionOperations.presets), body),
       render: renderRecord
     };
   },
@@ -41766,11 +43564,17 @@ var HANDLERS = {
       guestListId: list,
       ...household ? { householdId: household } : {}
     });
-    return { data: await requireClient().get("/rsvp-answers", { query }), render: renderRecord };
+    return {
+      data: await requireClient().get(pathOf(rsvpAnswerOperations.list), { query }),
+      render: renderRecord
+    };
   },
   "rsvp-answers set": async ({ flags, requireClient }) => {
     const body = parseInput(setRsvpAnswersInputSchema, readDataFlag(flags));
-    return { data: await requireClient().put("/rsvp-answers", body), render: renderRecord };
+    return {
+      data: await requireClient().put(pathOf(rsvpAnswerOperations.set), body),
+      render: renderRecord
+    };
   },
   "seating-proposals list": async ({ flags, requireClient }) => {
     const list = flagString(flags, "list");
@@ -41809,23 +43613,31 @@ var HANDLERS = {
       throw usageError("mail-campaigns list needs --list <guest list id>");
     parseInput(mailCampaignsQuerySchema, { guestListId: list });
     return {
-      data: await requireClient().get("/mail-campaigns", { query: { guestListId: list } }),
+      data: await requireClient().get(pathOf(mailCampaignOperations.list), {
+        query: { guestListId: list }
+      }),
       render: renderRecord
     };
   },
   "mail-campaigns get": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "campaign id");
-    return { data: await requireClient().get(`/mail-campaigns/${id}`), render: renderRecord };
+    return {
+      data: await requireClient().get(pathOf(mailCampaignOperations.get, { id })),
+      render: renderRecord
+    };
   },
   "mail-campaigns create": async ({ flags, requireClient }) => {
     const body = parseInput(createMailCampaignInputSchema, { id: ulid3(), ...readDataFlag(flags) });
-    return { data: await requireClient().post("/mail-campaigns", body), render: renderRecord };
+    return {
+      data: await requireClient().post(pathOf(mailCampaignOperations.create), body),
+      render: renderRecord
+    };
   },
   "mail-campaigns update": async ({ args, flags, requireClient }) => {
     const id = requireArg(args, 0, "campaign id");
     const body = parseInput(updateMailCampaignInputSchema, readDataFlag(flags));
     return {
-      data: await requireClient().patch(`/mail-campaigns/${id}`, body),
+      data: await requireClient().patch(pathOf(mailCampaignOperations.update, { id }), body),
       render: renderRecord
     };
   },
@@ -41835,7 +43647,7 @@ var HANDLERS = {
       language: flagString(flags, "language") ?? "nl"
     });
     return {
-      data: await requireClient().get(`/mail-campaigns/${id}/preview`, { query }),
+      data: await requireClient().get(pathOf(mailCampaignOperations.preview, { id }), { query }),
       render: renderRecord
     };
   },
@@ -42310,7 +44122,10 @@ async function planDecision({ args, requireClient }, verb) {
   const id = requireArg(args, 0, "plan id");
   const itemIds = args.slice(1);
   const body = parseInput(planDecisionInputSchema, itemIds.length > 0 ? { itemIds } : {});
-  return { data: await requireClient().post(`/plans/${id}/${verb}`, body), render: renderPlan };
+  return {
+    data: await requireClient().post(pathOf(planOperations[verb], { id }), body),
+    render: renderPlan
+  };
 }
 function parseInput(schema, value) {
   const result = schema.safeParse(value);