@robbeverhelst/do 1.314.1 → 1.316.0

package/dist/do.js

@@ -22627,6 +22627,31 @@ var houseUpkeepYearSchema = object({
 });
 var houseUpkeepYearQuerySchema = object({ year: exports_coerce.number().int().min(2000).max(2100).optional() }).strict();
 
+// ../../packages/schema/src/contracts/health-export.ts
+var HEALTH_EXPORT_RESOURCE_TYPES = [
+  "Patient",
+  "AllergyIntolerance",
+  "Condition",
+  "Observation",
+  "Encounter",
+  "MedicationStatement",
+  "MedicationAdministration",
+  "DiagnosticReport",
+  "DocumentReference"
+];
+var healthExportQuerySchema = object({
+  files: _enum2(["true", "false"]).default("true").transform((v) => v === "true")
+});
+var fhirResourceSchema = object({ resourceType: _enum2(HEALTH_EXPORT_RESOURCE_TYPES), id: string2().min(1) }).passthrough();
+var healthExportBundleSchema = object({
+  resourceType: literal("Bundle"),
+  id: string2().min(1),
+  type: literal("collection"),
+  timestamp: string2().datetime({ offset: true }),
+  meta: object({ tag: array(object({ system: string2(), code: string2() })) }),
+  entry: array(object({ fullUrl: string2().min(1), resource: fhirResourceSchema }))
+});
+
 // ../../packages/schema/src/receipt-kinds.ts
 var MONEY_RECEIPT_NODE_TYPE = "money_transaction";
 var RECEIPT_KINDS = {
@@ -26941,6 +26966,120 @@ var documentsQuerySchema = object({
   providerId: ulidSchema.optional()
 });
 
+// ../../packages/schema/src/contracts/document-ask.ts
+var documentPassageSourceSchema = _enum2(["field", "text"]);
+var documentPassageSchema = object({
+  documentId: ulidSchema,
+  documentTitle: string2(),
+  documentKind: documentKindSchema,
+  source: documentPassageSourceSchema,
+  fileId: ulidSchema.nullable(),
+  fileName: string2().nullable(),
+  page: number2().int().positive().nullable(),
+  text: string2(),
+  matched: array(string2())
+});
+var documentWithoutTextSchema = object({
+  documentId: ulidSchema,
+  documentTitle: string2()
+});
+var documentAskInputSchema = object({
+  question: string2().trim().min(2).max(500),
+  documentId: ulidSchema.optional(),
+  limit: exports_coerce.number().int().min(1).max(20).optional()
+}).strict();
+var documentAnswerSchema = object({
+  question: string2(),
+  found: boolean3(),
+  passages: array(documentPassageSchema),
+  pages: array(object({ documentId: ulidSchema, pages: array(number2().int()) })),
+  withoutText: array(documentWithoutTextSchema),
+  note: string2()
+});
+var documentSearchQuerySchema = object({
+  q: string2().trim().min(2).max(200),
+  documentId: ulidSchema.optional(),
+  limit: exports_coerce.number().int().min(1).max(50).optional()
+}).strict();
+var documentSearchResultSchema = object({
+  q: string2(),
+  hits: array(documentPassageSchema)
+});
+
+// ../../packages/schema/src/contracts/document-payments.ts
+var documentPaymentSchema = object({
+  transactionId: ulidSchema,
+  accountId: ulidSchema,
+  accountTitle: string2(),
+  bookedOn: string2(),
+  amount: string2(),
+  currency: string2(),
+  counterpartyName: string2().nullable()
+});
+var unmatchedPaperSchema = object({
+  id: ulidSchema,
+  title: string2(),
+  kind: documentKindSchema,
+  amountDue: number2(),
+  payBy: string2().nullable(),
+  providerTitle: string2().nullable(),
+  candidates: number2().int().nonnegative()
+});
+var paperMatchStatusSchema = _enum2([
+  "matched",
+  "already",
+  "ambiguous",
+  "none",
+  "not_payable"
+]);
+var paperMatchResultSchema = object({
+  documentId: ulidSchema,
+  status: paperMatchStatusSchema,
+  transactionId: ulidSchema.nullable(),
+  by: _enum2(["ref", "iban"]).nullable(),
+  candidates: array(ulidSchema)
+});
+var linkPaperPaymentInputSchema = object({ transactionId: ulidSchema }).strict();
+
+// ../../packages/schema/src/contracts/doccle.ts
+var DOCCLE_FAILURE_KINDS = ["credentials", "captcha", "changed", "unavailable"];
+var doccleFailureKindSchema = _enum2(DOCCLE_FAILURE_KINDS);
+var doccleFailureSchema = object({
+  kind: doccleFailureKindSchema,
+  title: string2(),
+  hint: string2(),
+  since: exports_coerce.date()
+});
+var doccleStatusSchema = object({
+  enabled: boolean3(),
+  connected: boolean3(),
+  archiveAfterImport: boolean3(),
+  lastRunAt: exports_coerce.date().nullable(),
+  lastOkAt: exports_coerce.date().nullable(),
+  failure: doccleFailureSchema.nullable(),
+  lastRun: object({
+    filed: number2().int().nonnegative(),
+    alreadyFiled: number2().int().nonnegative(),
+    secured: number2().int().nonnegative()
+  }),
+  imported: number2().int().nonnegative()
+});
+var doccleLoginInputSchema = object({
+  username: string2().trim().min(1).max(200),
+  password: string2().min(1).max(200)
+}).strict();
+var doccleSettingsInputSchema = object({ archiveAfterImport: boolean3() }).strict();
+var DOCCLE_RUN_OUTCOMES = ["ok", "failed", "not_connected", "off", "busy"];
+var doccleSyncResultSchema = object({
+  outcome: _enum2(DOCCLE_RUN_OUTCOMES),
+  filed: number2().int().nonnegative(),
+  alreadyFiled: number2().int().nonnegative(),
+  secured: number2().int().nonnegative(),
+  archived: number2().int().nonnegative(),
+  documentIds: array(string2()),
+  failure: doccleFailureSchema.nullable()
+});
+
 // ../../packages/schema/src/contracts/incidents.ts
 var incidentKindSchema = _enum2(incidentKind.enumValues);
 var incidentStatusSchema = _enum2(incidentStatus.enumValues);
@@ -31599,6 +31738,277 @@ var dayOperations = defineOperations({
   }
 });
 
+// ../../packages/schema/src/operations/documents.ts
+var DOCCLE_STATUS = "The import's status.";
+var PAPER_ID = { id: ulidSchema };
+var documentOperations = defineOperations({
+  ...crudOperations({
+    segment: "documents",
+    tag: "Documents",
+    noun: "document",
+    read: "documents:read",
+    write: "documents:write",
+    create: createDocumentInputSchema,
+    update: updateDocumentInputSchema,
+    listQuery: [
+      {
+        name: "kind",
+        description: "Only this kind (`insurance`, `contract`, `subscription`, `id_paper`, `house_cert`, `warranty`, \u2026)."
+      },
+      {
+        name: "status",
+        description: "Only this status (`active`, `ended`, `superseded`, `draft`)."
+      },
+      { name: "providerId", description: "Only the documents issued by this Contact." }
+    ],
+    listQuerySchema: documentsQuerySchema
+  }),
+  unmatched: {
+    method: "get",
+    path: "/documents/unmatched",
+    scopes: ["documents:read", "finance:read"],
+    tag: "Documents",
+    summary: "Papers waiting for their payment",
+    description: "The papers that ask for money (`fields.amountDue`, with an IBAN or a structured reference to match on) and have no payment linked, oldest due first: `{ id, title, kind, amountDue, payBy, providerTitle, candidates }`. `candidates` counts the payments that fit equally well. A payment on an account the key can't see doesn't count.",
+    status: 200,
+    response: { description: "The unmatched papers." }
+  },
+  matchAll: {
+    method: "post",
+    path: "/documents/match",
+    scopes: ["documents:read", "finance:write"],
+    tag: "Documents",
+    summary: "Match every paper to its payment",
+    description: "Match every paper still waiting for its payment. A payment is money out of exactly the amount due, booked between a week before the paper and 45 days after its due day, carrying its structured reference or (without one) going to its IBAN; it's linked only when exactly one fits, as the transaction's `evidence`. Returns one `{ documentId, status, transactionId, by, candidates }` per paper; `status` is `matched`, `already`, `ambiguous`, `none` or `not_payable`. Papers are also matched when filed or changed by a key with `finance:write`, and after a bank import.",
+    status: 200,
+    response: { description: "One result per paper." }
+  },
+  filed: {
+    method: "get",
+    path: "/documents/filed",
+    scopes: ["documents:read"],
+    tag: "Documents",
+    summary: "Check a filed source",
+    description: "Whether a mail (`gmail:<id>`) or an import was already filed: `{ filed, documentId }`. The Gmail watch and backfill dedupe with it. 403 until `DOCUMENTS_IMPORT_ENABLED=true`.",
+    query: [{ name: "source", description: "`gmail:<id>` or `doccle_zip`." }],
+    querySchema: object({ source: fileSourceSchema }),
+    status: 200,
+    response: { description: "`{ filed, documentId }`." },
+    errors: { 403: "Imports are off." },
+    operationId: "document_filed"
+  },
+  doccleStatus: {
+    method: "get",
+    path: "/documents/doccle",
+    scopes: ["documents:read"],
+    tag: "Documents",
+    summary: "Your Doccle import",
+    description: "The key's member's Doccle import (ADR 0033), which files their Doccle mailbox into Papers every night: `{ enabled, connected, archiveAfterImport, lastRunAt, lastOkAt, failure, lastRun: { filed, alreadyFiled, secured }, imported }`. `failure` (`{ kind, title, hint, since }`, kind `credentials` \xB7 `captcha` \xB7 `changed` \xB7 `unavailable`) says why it is stuck, while it is. The login itself is never returned.",
+    status: 200,
+    response: { description: DOCCLE_STATUS }
+  },
+  doccleSettings: {
+    method: "patch",
+    path: "/documents/doccle",
+    scopes: ["documents:write"],
+    tag: "Documents",
+    summary: "Change your Doccle import's setting",
+    description: "`{ archiveAfterImport }`: archive each document in Doccle once it is filed as a paper (off by default). Returns the status.",
+    body: doccleSettingsInputSchema,
+    status: 200,
+    response: { description: DOCCLE_STATUS },
+    errors: { 400: "Not a boolean." }
+  },
+  doccleConnect: {
+    method: "put",
+    path: "/documents/doccle/login",
+    scopes: ["connections:write"],
+    tag: "Documents",
+    summary: "Connect your Doccle login",
+    description: "`{ username, password }`: do checks the login with Doccle, then keeps it sealed in the connection-secret store (ADR 0032) for the nightly import. It is never returned or logged. Returns the status.",
+    afterScopes: "`*` and `private:*` never grant `connections:write`: a key holds it by name, and a guest's key never does.",
+    body: doccleLoginInputSchema,
+    status: 200,
+    response: { description: "The import's status, connected." },
+    errors: {
+      403: "The key doesn't hold `connections:write`, or is a guest's.",
+      422: "Doccle refused the login or asked for a captcha; nothing is kept.",
+      503: "Doccle couldn't be reached."
+    },
+    mcp: false
+  },
+  doccleDisconnect: {
+    method: "delete",
+    path: "/documents/doccle/login",
+    scopes: ["documents:write"],
+    tag: "Documents",
+    summary: "Forget your Doccle login",
+    description: "The nightly import stops; the papers it filed stay. Returns the status.",
+    status: 200,
+    response: { description: DOCCLE_STATUS }
+  },
+  doccleSync: {
+    method: "post",
+    path: "/documents/doccle/sync",
+    scopes: ["documents:write"],
+    tag: "Documents",
+    summary: "Run your Doccle import now",
+    description: "Each Doccle document not seen before becomes a paper: its sender as the provider (an organisation Contact), its date, its PDF (`source: doccle`), an invoice's amount, IBAN and payment reference, then matched to its payment. Nothing is filed twice: a document is skipped on Doccle's id, and a PDF already in Papers (a Doccle ZIP export, or by hand) on its SHA-256. `{ outcome, filed, alreadyFiled, secured, archived, documentIds, failure }`; `outcome` is `ok`, `failed` (the member is told once), `not_connected`, `off` (`DOCUMENTS_IMPORT_ENABLED` isn't on) or `busy`.",
+    status: 200,
+    response: { description: "What the run did." }
+  },
+  ask: {
+    method: "post",
+    path: "/documents/ask",
+    scopes: ["documents:read"],
+    tag: "Documents",
+    summary: "Ask the papers (doc_ask)",
+    description: "`doc_ask`: `{ question, documentId?, limit? }` asks one paper, or every paper the key can read, and returns the passages that answer, best first, each with its paper, file and page: `{ question, found, passages: [{ documentId, documentTitle, documentKind, source, fileId, fileName, page, text, matched }], pages: [{ documentId, pages }], withoutText, note }`. The words come from the papers' key fields (`source: field`, the page an extraction read it on) and their files' `textExtract` (`source: text`, a page per form feed). do writes no prose: word the answer from the passages, quote the pages, and say it is not legal advice (`note`). `withoutText` names the papers asked (or, asking them all, those the question names) that hold no file text, so you can offer to fetch the conditions. An Only me paper answers only its owner's key with `documents:private`.",
+    body: documentAskInputSchema,
+    status: 200,
+    response: { description: "The passages that answer." },
+    errors: { 404: "No such paper." },
+    reads: true
+  },
+  search: {
+    method: "get",
+    path: "/documents/search",
+    scopes: ["documents:read"],
+    tag: "Documents",
+    summary: "Search the papers' words",
+    description: "Search the papers' key fields and file text: `{ q, hits }`, a passage per page or field that holds the words, best first, shaped as `doc_ask`'s passages.",
+    query: [
+      { name: "q", description: "The words to find (two letters or more)." },
+      { name: "documentId", description: "Only this paper." },
+      { name: "limit", description: "How many hits at most (default 20, up to 50)." }
+    ],
+    querySchema: documentSearchQuerySchema,
+    status: 200,
+    response: { description: "The hits." }
+  },
+  matchOne: {
+    method: "post",
+    path: "/documents/{id}/match",
+    scopes: ["documents:read", "finance:write"],
+    tag: "Documents",
+    summary: "Match a paper to its payment",
+    description: "Match this paper to its payment, if exactly one fits: `{ documentId, status, transactionId, by, candidates }`.",
+    pathParamSchemas: PAPER_ID,
+    status: 200,
+    response: { description: "What matching did." },
+    errors: { 404: "No such paper." }
+  },
+  payments: {
+    method: "get",
+    path: "/documents/{id}/payments",
+    scopes: ["documents:read", "finance:read"],
+    tag: "Documents",
+    summary: "A paper's payments",
+    description: "The payments linked to this paper that the key may see: `{ transactionId, accountId, accountTitle, bookedOn, amount, currency, counterpartyName }`.",
+    pathParamSchemas: PAPER_ID,
+    status: 200,
+    response: { description: "The payments." }
+  },
+  linkPayment: {
+    method: "put",
+    path: "/documents/{id}/payments",
+    scopes: ["documents:read", "finance:write"],
+    tag: "Documents",
+    summary: "Link a payment to a paper",
+    description: "Link a payment to this paper by hand (`{ transactionId }`), e.g. one of the fits when matching was ambiguous. Returns the paper's payments.",
+    pathParamSchemas: PAPER_ID,
+    body: linkPaperPaymentInputSchema,
+    status: 200,
+    response: { description: "The paper's payments." },
+    errors: { 404: "No such paper or transaction." }
+  },
+  unlinkPayment: {
+    method: "delete",
+    path: "/documents/{id}/payments/{transactionId}",
+    scopes: ["documents:read", "finance:write"],
+    tag: "Documents",
+    summary: "Take a payment off a paper",
+    description: "Unlink this payment from the paper.",
+    pathParams: { transactionId: "The Money transaction's ULID." },
+    pathParamSchemas: { id: ulidSchema, transactionId: ulidSchema },
+    status: 204,
+    response: { description: "Unlinked." },
+    errors: { 404: "That payment isn't linked to this paper." }
+  }
+});
+
+// ../../packages/schema/src/operations/family-tree.ts
+var familyTreeOperations = defineOperations({
+  get: {
+    method: "get",
+    path: "/family-tree",
+    scopes: ["people:family-tree"],
+    tag: "People",
+    summary: "The family tree",
+    description: "The member's tree: the import facts, the branch two generations up from them once they've said who they are (`side` = `father` or `mother`), and what it noticed. `{ tree: null }` before an import.",
+    afterScopes: "A sensitive scope (ADR 0028): never part of `*`, and only the tree of the member who minted the key.",
+    query: [
+      { name: "side", description: "Which grandparents the branch climbs to: father or mother." }
+    ],
+    querySchema: familyTreeQuerySchema,
+    status: 200,
+    response: { description: "`{ tree }`." },
+    errors: { 400: true, 403: "The key doesn't hold `people:family-tree`, or is no member's." }
+  },
+  people: {
+    method: "get",
+    path: "/family-tree/people",
+    scopes: ["people:family-tree"],
+    tag: "People",
+    summary: "Everyone in the tree",
+    description: "By name, with `q` (a part of the name), `filter` (all \xB7 living \xB7 linked) and `limit` (1\u2013500, default 100): how to find a person's `ref`.",
+    query: [
+      { name: "q", description: "A part of the name." },
+      { name: "filter", description: "all, living or linked." },
+      { name: "limit", description: "At most this many (1\u2013500, default 100)." }
+    ],
+    querySchema: familyTreePeopleQuerySchema,
+    status: 200,
+    response: { description: "`{ people, total }`." },
+    errors: { 404: true }
+  },
+  me: {
+    method: "put",
+    path: "/family-tree/me",
+    scopes: ["people:family-tree"],
+    tag: "People",
+    summary: "This is me",
+    description: "`ref`: the member in the tree. It becomes the root of the branch, and a living person is linked to the member's own Contact (the one that is them).",
+    body: familyTreeMeInputSchema,
+    status: 200,
+    response: { description: "The tree." },
+    errors: { 400: true, 404: true }
+  },
+  matches: {
+    method: "get",
+    path: "/family-tree/matches",
+    scopes: ["people:family-tree"],
+    tag: "People",
+    summary: "What the tree noticed",
+    description: "Each with the `id` a decision takes: `suggest` (a living relative who looks like an unlinked Contact), `birthday_differs` (a linked relative's birthday falls on another day than their Contact's), `not_in_tree` (a linked relative's partner or kid who isn't in the tree). What was said no to isn't listed.",
+    status: 200,
+    response: { description: "`{ matches }`." },
+    errors: { 404: true }
+  },
+  decide: {
+    method: "post",
+    path: "/family-tree/matches",
+    scopes: ["people:family-tree"],
+    tag: "People",
+    summary: "Yes or no to a match",
+    description: "`{ id, decision: accept | reject }`. Yes links a suggested relative to the Contact, or takes the tree's birthday onto it; someone not in the tree has nothing to take, so only no (a 400). No hides the match for good. Returns `{ id, did, matches }` (`did`: linked \xB7 birthday_taken \xB7 dismissed).",
+    body: familyTreeMatchDecisionInputSchema,
+    status: 200,
+    response: { description: "`{ id, did, matches }`." },
+    errors: { 400: true, 404: true }
+  }
+});
+
 // ../../packages/schema/src/operations/files.ts
 var fileOperations = defineOperations({
   list: {
@@ -32362,122 +32772,796 @@ var habitOperations = defineOperations({
     response: { description: "The check-ins." },
     errors: { 404: true }
   },
-  checkIn: {
+  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/health.ts
+var healthOperations = defineOperations({
+  export: {
+    method: "get",
+    path: "/health/export",
+    scopes: ["health:export"],
+    tag: "Health",
+    summary: "Export every health record as FHIR",
+    description: "Every health record the member holds, as one FHIR R4 `collection` Bundle: the member (Patient), allergies, Conditions and Episodes (Condition), symptom entries and lab values (Observation; a correction is `corrected`, what it replaced `entered-in-error`), visits (Encounter), medicines and doses (MedicationStatement, MedicationAdministration), lab draws (DiagnosticReport) and the original documents (DocumentReference, bytes inline as base64 unless `files=false`). Works with Health turned off. Logged in the member's Who looked.",
+    query: [
+      { name: "files", description: "`false` leaves the documents' bytes out; default `true`." }
+    ],
+    querySchema: healthExportQuerySchema,
+    status: 200,
+    response: { description: "The FHIR Bundle." },
+    errors: { 400: true, 403: "Health is off for the member, or the key acts for no member." }
+  },
+  getConsent: {
+    method: "get",
+    path: "/health/consent",
+    scopes: ["health:read"],
+    tag: "Health",
+    summary: "Get the health consent",
+    description: "Whether the member has turned Health on: `{ granted, version, grantedAt, currentVersion, renewalNeeded, aiProvider }`. `granted` means on at today's consent text (`currentVersion`); `renewalNeeded` means the member agreed to an older text and is asked to agree again, so writes wait until they do. `aiProvider` is the AI provider this deployment names for what the agent reads (null when none). Only the member turns it on or off, in do; a key never can.",
+    status: 200,
+    response: { description: "The consent state." },
+    errors: { 403: "Health is off for the member, or the key acts for no member." }
+  },
+  getProfile: {
+    method: "get",
+    path: "/health/profile",
+    scopes: ["health:read"],
+    tag: "Health",
+    summary: "Get the health profile",
+    description: "The member's blood group, allergies, height, emergency contact and GP (Contacts); empty until set.",
+    status: 200,
+    response: { description: "The profile." },
+    errors: { 403: "Health is off for the member, or the key acts for no member." }
+  },
+  updateProfile: {
+    method: "patch",
+    path: "/health/profile",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Update the health profile",
+    description: "Set profile fields; an absent key keeps a field, `null` clears it.",
+    body: updateHealthProfileInputSchema,
+    status: 200,
+    response: { description: "The profile." },
+    errors: { 400: true, 403: "Health is off for the member, or the key acts for no member." }
+  },
+  log: {
+    method: "post",
+    path: "/health/log",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Log a health message",
+    description: "One chat turn about health in one call: name the Episode (`episodeId`) or describe it (`episode`: the member's open Episode in the same region or with the same title, active in the last 14 days, else a new one), then a `symptom`, a `dose` (a Medication by `medicationId`, or by name in `medication`, added as needed if new), or both. Returns a receipt: `{ episode, items[{ kind, id, line, guessed, undo }], entry, dose }`; each item's `undo` goes to `POST /api/v1/health/undo`. With `thread` (the member's home thread by slug, the Space's agent key with `agents:converse`), the receipt card is posted there too (\"Added to **Sprained ankle** (day 5).\" with what was logged, Undo and Edit) and `postId` names it.",
+    body: logHealthInputSchema,
+    status: 201,
+    response: { description: "The receipt." },
+    errors: {
+      400: true,
+      403: "Health is off for the member, or the key acts for no member.",
+      404: true
+    }
+  },
+  correct: {
+    method: "post",
+    path: "/health/correct",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Correct a health message",
+    description: "Correct a symptom entry by its id (`{ entryId, change }`): a new entry supersedes it, the history stays. Returns a receipt. 409 when the entry was corrected already.",
+    body: correctHealthInputSchema,
+    status: 201,
+    response: { description: "The receipt." },
+    errors: { 400: true, 404: true, 409: true }
+  },
+  undo: {
+    method: "post",
+    path: "/health/undo",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Undo a health receipt",
+    description: "Take back what a receipt wrote: `{ kind: entry | dose | episode, id }`. A POST, so it doesn't wait on a confirmation the way a delete does.",
+    body: healthUndoInputSchema,
+    status: 200,
+    response: { description: "`{ undone }`." },
+    errors: { 404: true, 409: true }
+  },
+  checkIn: {
+    method: "post",
+    path: "/health/episodes/{id}/check-in",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Check in on an Episode",
+    description: "Better / Same / Worse (`{ trend }`): today's trend against yesterday, as an entry in the member's words. One a day in the member's zone; a second one the same day corrects the first. Returns a receipt whose `undo` goes to `POST /api/v1/health/undo`.",
+    body: healthCheckInInputSchema,
+    status: 201,
+    response: { description: "The receipt." },
+    errors: {
+      400: true,
+      403: "Health is off for the member, or the key acts for no member.",
+      404: true
+    }
+  },
+  redFlags: {
+    method: "post",
+    path: "/health/episodes/{id}/red-flags",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Record the red flags asked in chat",
+    description: 'The red-flag screen answered in chat (`{ answers: { fever: false, vomiting: false }, thread? }`): the answers merge into the ones asked before and the Episode is marked checked today, so For the doctor shows it. With `thread` (the Space\'s agent key with `agents:converse`), a card confirms it there ("Noted as **checked: no red flags** (17 Oct).") with ways on to the summary and the Episode. Returns `{ episodeId, redFlags, checkedAt, postId }`.',
+    body: healthRedFlagsInputSchema,
+    status: 200,
+    response: { description: "The answers, when, and the card's post." },
+    errors: {
+      400: true,
+      403: "Health is off for the member, or the key acts for no member.",
+      404: true
+    }
+  },
+  upsertEpisode: {
+    method: "post",
+    path: "/health/episodes/upsert",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Find or start a health episode",
+    description: "The member's open Episode this belongs to (same subject, same region or title, active in the last 14 days), or a new one. Returns `{ episode, created }`.",
+    body: upsertHealthEpisodeInputSchema,
+    status: 200,
+    response: { description: "`{ episode, created }`." },
+    errors: { 400: true, 403: "Health is off for the member, or the key acts for no member." }
+  },
+  summary: {
+    method: "get",
+    path: "/health/summary",
+    scopes: ["health:read"],
+    tag: "Health",
+    summary: "Get the doctor summary",
+    description: "Everything the one-page doctor summary reads, for one Episode (`episodeId`, default the latest open one): the Episode and its course day by day, its entries, what was tried with what each did, the open Conditions, current Medications, the profile, the GP, the next visit with its questions, `labs` (the last 3 confirmed lab draws, each with its results, the lab's range and flag), and `trends` (sleep and weight from Metrics over the last 28 days, one point a day). The member's words, never a diagnosis.",
+    query: [{ name: "episodeId", description: "The Episode; default the latest open one." }],
+    querySchema: healthSummaryQuerySchema,
+    status: 200,
+    response: { description: "The summary." },
+    errors: { 403: "Health is off for the member, or the key acts for no member.", 404: true }
+  },
+  medicalId: {
+    method: "get",
+    path: "/health/medical-id",
+    scopes: ["health:read"],
+    tag: "Health",
+    summary: "Get the Medical ID",
+    description: "The few facts someone helping in an emergency needs, like a phone's medical ID: the member's `name` (their display name), `bloodGroup`, `allergies`, `heightCm`, the `medications` they take now (not stopped, scheduled ones first) and the `emergencyContact` from the profile with their name and phone. A field not set is `null` (or empty). Each read by a key is appended to the member's access log.",
+    status: 200,
+    response: { description: "The Medical ID." },
+    errors: { 403: "Health is off for the member, or the key acts for no member." }
+  },
+  listConditions: {
+    method: "get",
+    path: "/health/conditions",
+    scopes: ["health:read"],
+    tag: "Health",
+    summary: "List health conditions",
+    description: "The member's conditions. Something lasting (hay fever, runner's knee); `onset` is a fuzzy date. Reads and writes as the member who minted the key; another member's records read as missing.",
+    status: 200,
+    response: { description: "The member's conditions.", list: true },
+    errors: { 403: "Health is off for the member, or the key acts for no member." }
+  },
+  getCondition: {
+    method: "get",
+    path: "/health/conditions/{id}",
+    scopes: ["health:read"],
+    tag: "Health",
+    summary: "Get a health condition",
+    description: "One condition.",
+    status: 200,
+    response: { description: "The condition." },
+    errors: { 404: true }
+  },
+  createCondition: {
+    method: "post",
+    path: "/health/conditions",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Create a health condition",
+    description: "Add a condition, always private to the member (`subjectNodeId` names who it is about; absent = the member).",
+    body: createHealthConditionInputSchema,
+    status: 201,
+    response: { description: "The condition." },
+    errors: { 400: true, 403: "Health is off for the member, or the key acts for no member." }
+  },
+  updateCondition: {
+    method: "patch",
+    path: "/health/conditions/{id}",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Update a health condition",
+    description: "Patch a condition; `null` clears a field.",
+    body: updateHealthConditionInputSchema,
+    status: 200,
+    response: { description: "The condition." },
+    errors: {
+      400: true,
+      403: "Health is off for the member, or the key acts for no member.",
+      404: true
+    }
+  },
+  deleteCondition: {
+    method: "delete",
+    path: "/health/conditions/{id}",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Delete a health condition",
+    description: "Delete a condition. An Agent's delete waits on the member's confirmation (428).",
+    status: 204,
+    response: { description: "Deleted." },
+    errors: { 403: "Health is off for the member, or the key acts for no member.", 404: true }
+  },
+  addCareTeam: {
+    method: "post",
+    path: "/health/conditions/{id}/care-team",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Add to a health condition's care team",
+    description: "Link a Contact to the Condition (`cared_by`, condition \u2192 contact) with their role on it in `label` (\"dermatologist\"). Adding one already on it sets the role. The Condition's `careTeam` lists them by name with their phone; the Health home's Care team card and For the doctor read them.",
+    body: addHealthCareTeamInputSchema,
+    status: 201,
+    response: { description: "The Condition, with its care team." },
+    errors: {
+      400: true,
+      403: "Health is off for the member, or the key acts for no member.",
+      404: true
+    }
+  },
+  removeCareTeam: {
+    method: "delete",
+    path: "/health/conditions/{id}/care-team/{contactId}",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Remove from a health condition's care team",
+    description: "Take the Contact off the Condition's care team (the Contact stays). 404 when they weren't on it.",
+    pathParams: { contactId: "The Contact on the care team." },
+    status: 200,
+    response: { description: "The Condition, with its care team." },
+    errors: { 403: "Health is off for the member, or the key acts for no member.", 404: true }
+  },
+  listEpisodes: {
+    method: "get",
+    path: "/health/episodes",
+    scopes: ["health:read"],
+    tag: "Health",
+    summary: "List health episodes",
+    description: "The member's episodes. One stretch of a complaint, open ones first, with the latest live severity. `GET \u2026/{id}` returns its entries (superseded ones too), doses, visits and Condition. Create one already over with `status: \"resolved\"` and `endedAt` (not before `startedAt`, not in the future; `endedAt` alone implies resolved). Resolving one stamps `endedAt`; `redFlags` answers merge. Reads and writes as the member who minted the key; another member's records read as missing.",
+    query: [{ name: "status", description: "`open`, `watching` or `resolved`." }],
+    querySchema: healthEpisodeListQuerySchema,
+    status: 200,
+    response: { description: "The member's episodes.", list: true },
+    errors: { 403: "Health is off for the member, or the key acts for no member." }
+  },
+  getEpisode: {
+    method: "get",
+    path: "/health/episodes/{id}",
+    scopes: ["health:read"],
+    tag: "Health",
+    summary: "Get a health episode",
+    description: "One episode.",
+    status: 200,
+    response: { description: "The episode." },
+    errors: { 404: true }
+  },
+  createEpisode: {
+    method: "post",
+    path: "/health/episodes",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Create a health episode",
+    description: "Add a episode, always private to the member (`subjectNodeId` names who it is about; absent = the member).",
+    body: createHealthEpisodeInputSchema,
+    status: 201,
+    response: { description: "The episode." },
+    errors: { 400: true, 403: "Health is off for the member, or the key acts for no member." }
+  },
+  updateEpisode: {
+    method: "patch",
+    path: "/health/episodes/{id}",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Update a health episode",
+    description: "Patch a episode; `null` clears a field.",
+    body: updateHealthEpisodeInputSchema,
+    status: 200,
+    response: { description: "The episode." },
+    errors: {
+      400: true,
+      403: "Health is off for the member, or the key acts for no member.",
+      404: true
+    }
+  },
+  deleteEpisode: {
+    method: "delete",
+    path: "/health/episodes/{id}",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Delete a health episode",
+    description: "Delete a episode. An Agent's delete waits on the member's confirmation (428).",
+    status: 204,
+    response: { description: "Deleted." },
+    errors: { 403: "Health is off for the member, or the key acts for no member.", 404: true }
+  },
+  logSymptom: {
+    method: "post",
+    path: "/health/episodes/{id}/entries",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Log a health symptom",
+    description: "Add one thing said about an Episode (`symptom`, `bodyRegion`, `severity` 0\u201310, `severityGuessed` when it is a guess from the wording, `qualifiers`). An Agent's entry is `source: chat`.",
+    body: logHealthSymptomInputSchema,
+    status: 201,
+    response: { description: "The entry." },
+    errors: {
+      400: true,
+      403: "Health is off for the member, or the key acts for no member.",
+      404: true
+    }
+  },
+  correctSymptom: {
+    method: "post",
+    path: "/health/episodes/{id}/entries/{entryId}/correct",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Correct a health symptom",
+    description: 'Correct the live version of an entry ("not the foot, the ankle"): a new entry that supersedes it and copies every field not named, so the history stays. 409 when the entry was corrected already.',
+    pathParams: { entryId: "The symptom entry's id." },
+    body: correctHealthSymptomInputSchema,
+    status: 201,
+    response: { description: "The new entry." },
+    errors: { 400: true, 404: true, 409: true }
+  },
+  deleteSymptom: {
+    method: "delete",
+    path: "/health/episodes/{id}/entries/{entryId}",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Take back a health symptom",
+    description: "Take back the live version of an entry; what it corrected is live again. 409 when it was corrected since.",
+    pathParams: { entryId: "The symptom entry's id." },
+    status: 204,
+    response: { description: "Taken back." },
+    errors: { 404: true, 409: true }
+  },
+  listEncounters: {
+    method: "get",
+    path: "/health/encounters",
+    scopes: ["health:read"],
+    tag: "Health",
+    summary: "List health encounters",
+    description: "The member's encounters. Visits, latest first, each with its doctor's name (a Contact), questions to ask and outcome. Reads and writes as the member who minted the key; another member's records read as missing.",
+    status: 200,
+    response: { description: "The member's encounters.", list: true },
+    errors: { 403: "Health is off for the member, or the key acts for no member." }
+  },
+  getEncounter: {
+    method: "get",
+    path: "/health/encounters/{id}",
+    scopes: ["health:read"],
+    tag: "Health",
+    summary: "Get a health encounter",
+    description: "One encounter.",
+    status: 200,
+    response: { description: "The encounter." },
+    errors: { 404: true }
+  },
+  createEncounter: {
     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,
+    path: "/health/encounters",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Create a health encounter",
+    description: "Add a encounter, always private to the member (`subjectNodeId` names who it is about; absent = the member).",
+    body: createHealthEncounterInputSchema,
     status: 201,
-    response: { description: "The refreshed habit." },
+    response: { description: "The encounter." },
+    errors: { 400: true, 403: "Health is off for the member, or the key acts for no member." }
+  },
+  updateEncounter: {
+    method: "patch",
+    path: "/health/encounters/{id}",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Update a health encounter",
+    description: "Patch a encounter; `null` clears a field.",
+    body: updateHealthEncounterInputSchema,
+    status: 200,
+    response: { description: "The encounter." },
     errors: {
       400: true,
+      403: "Health is off for the member, or the key acts for no member.",
       404: true
-    },
-    webhook: "habit.updated",
-    operationId: "check_in_habit"
+    }
   },
-  skip: {
+  deleteEncounter: {
+    method: "delete",
+    path: "/health/encounters/{id}",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Delete a health encounter",
+    description: "Delete a encounter. An Agent's delete waits on the member's confirmation (428).",
+    status: 204,
+    response: { description: "Deleted." },
+    errors: { 403: "Health is off for the member, or the key acts for no member.", 404: true }
+  },
+  listMedications: {
+    method: "get",
+    path: "/health/medications",
+    scopes: ["health:read"],
+    tag: "Health",
+    summary: "List health medications",
+    description: "The member's medications. Drugs and supplements, stopped ones last, with when one was last taken. Reads and writes as the member who minted the key; another member's records read as missing.",
+    status: 200,
+    response: { description: "The member's medications.", list: true },
+    errors: { 403: "Health is off for the member, or the key acts for no member." }
+  },
+  getMedication: {
+    method: "get",
+    path: "/health/medications/{id}",
+    scopes: ["health:read"],
+    tag: "Health",
+    summary: "Get a health medication",
+    description: "One medication.",
+    status: 200,
+    response: { description: "The medication." },
+    errors: { 404: true }
+  },
+  createMedication: {
     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,
+    path: "/health/medications",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Create a health medication",
+    description: "Add a medication, always private to the member (`subjectNodeId` names who it is about; absent = the member).",
+    body: createHealthMedicationInputSchema,
     status: 201,
-    response: { description: "The refreshed habit." },
+    response: { description: "The medication." },
+    errors: { 400: true, 403: "Health is off for the member, or the key acts for no member." }
+  },
+  updateMedication: {
+    method: "patch",
+    path: "/health/medications/{id}",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Update a health medication",
+    description: "Patch a medication; `null` clears a field.",
+    body: updateHealthMedicationInputSchema,
+    status: 200,
+    response: { description: "The medication." },
     errors: {
       400: true,
+      403: "Health is off for the member, or the key acts for no member.",
       404: true
-    },
-    webhook: "habit.updated"
+    }
   },
-  pause: {
+  deleteMedication: {
+    method: "delete",
+    path: "/health/medications/{id}",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Delete a health medication",
+    description: "Delete a medication. An Agent's delete waits on the member's confirmation (428).",
+    status: 204,
+    response: { description: "Deleted." },
+    errors: { 403: "Health is off for the member, or the key acts for no member.", 404: true }
+  },
+  listDoses: {
+    method: "get",
+    path: "/health/medications/{id}/doses",
+    scopes: ["health:read"],
+    tag: "Health",
+    summary: "List health doses",
+    description: "The doses of one Medication, latest first.",
+    status: 200,
+    response: { description: "The doses.", list: true },
+    errors: { 404: true }
+  },
+  logDose: {
     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,
+    path: "/health/medications/{id}/doses",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Log a health dose",
+    description: "Log a dose taken, optionally for an Episode, with what it did (`effect`: none, a_little, helped, worse).",
+    body: logHealthDoseInputSchema,
     status: 201,
-    response: { description: "The refreshed habit." },
+    response: { description: "The dose." },
     errors: {
       400: true,
+      403: "Health is off for the member, or the key acts for no member.",
       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"
+  updateDose: {
+    method: "patch",
+    path: "/health/medications/{id}/doses/{doseId}",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Update a health dose",
+    description: "Say later what a dose did, or fix it.",
+    pathParams: { doseId: "The dose's id." },
+    body: updateHealthDoseInputSchema,
+    status: 200,
+    response: { description: "The dose." },
+    errors: { 400: true, 404: true }
   },
-  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"
+  deleteDose: {
+    method: "delete",
+    path: "/health/medications/{id}/doses/{doseId}",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Take back a health dose",
+    description: "Take a dose back.",
+    pathParams: { doseId: "The dose's id." },
+    status: 204,
+    response: { description: "Taken back." },
+    errors: { 404: true }
   },
-  unretire: {
+  listShares: {
+    method: "get",
+    path: "/health/shares",
+    scopes: ["health:read"],
+    tag: "Health",
+    summary: "List doctor summary shares",
+    description: "The member's \"For the doctor\" links, newest first: the sections each froze, when it expires or was taken back, how often it was opened, and `live`. Never the link's secret or the snapshot. Only the member makes one, in do.",
+    status: 200,
+    response: { description: "The shares." },
+    errors: { 403: "Health is off for the member, or the key acts for no member." }
+  },
+  revokeShare: {
+    method: "delete",
+    path: "/health/shares/{id}",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Take a doctor summary share back",
+    description: "The link stops opening (410). Idempotent.",
+    pathParams: { id: "The share's id." },
+    status: 200,
+    response: { description: "The share." },
+    errors: { 403: "Health is off for the member, or the key acts for no member.", 404: true }
+  },
+  listLabPanels: {
+    method: "get",
+    path: "/health/labs",
+    scopes: ["health:read"],
+    tag: "Health",
+    summary: "List health lab draws",
+    description: "The member's lab draws. Lab draws, latest first, each with its sheet of results (FHIR Observation-shaped: an `analyte` key, `loinc`, a UCUM `unit`, the lab's `refLow`/`refHigh`; `flag` is worked out from the range when absent). A draw read out of a document stays `status: draft` until the member checks it. On update, `results` replaces the whole sheet. Reads and writes as the member who minted the key; another member's records read as missing.",
+    status: 200,
+    response: { description: "The member's lab draws.", list: true },
+    errors: { 403: "Health is off for the member, or the key acts for no member." }
+  },
+  listLabAnalytes: {
+    method: "get",
+    path: "/health/labs/analytes",
+    scopes: ["health:read"],
+    tag: "Health",
+    summary: "List the canonical lab analytes",
+    description: 'The fixed analyte vocabulary: `key`, the printed `name`, `group`, the usual `unit`, `loinc` where plain, and `aliases` (English and Dutch; matched regardless of case, spaces, punctuation and accents). A lab result is written under the canonical key its `analyte` or `name` stands for ("ALAT" \u2192 `alt`, "25-OH vitamin D" \u2192 `vitamin_d`); a name that matches none keeps its own slug and comes back in the draw\'s `unmatched`. Trends read old keys as their canonical one.',
+    status: 200,
+    response: { description: "The analytes." },
+    errors: { 403: "Health is off for the member, or the key acts for no member." }
+  },
+  labNormalizeReport: {
+    method: "get",
+    path: "/health/labs/normalize",
+    scopes: ["health:read"],
+    tag: "Health",
+    summary: "Report how lab keys would normalize",
+    description: "A dry run: each stored result whose key isn't its canonical one (`changes`: `resultId`, `from`, `to`), and the keys matching no canonical analyte (`unmatched`, with how many results). Nothing is rewritten.",
+    status: 200,
+    response: { description: "The report." },
+    errors: { 403: "Health is off for the member, or the key acts for no member." }
+  },
+  getLabPanel: {
+    method: "get",
+    path: "/health/labs/{id}",
+    scopes: ["health:read"],
+    tag: "Health",
+    summary: "Get a health lab draw",
+    description: "One lab draw.",
+    status: 200,
+    response: { description: "The lab draw." },
+    errors: { 404: true }
+  },
+  createLabPanel: {
     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`.",
+    path: "/health/labs",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Create a health lab draw",
+    description: "Add a lab draw, always private to the member (`subjectNodeId` names who it is about; absent = the member).",
+    body: createHealthLabPanelInputSchema,
     status: 201,
-    response: { description: "The refreshed habit." },
-    errors: { 404: true },
-    webhook: "habit.updated"
+    response: { description: "The lab draw." },
+    errors: { 400: true, 403: "Health is off for the member, or the key acts for no member." }
   },
-  updateCheckIn: {
+  updateLabPanel: {
     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,
+    path: "/health/labs/{id}",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Update a health lab draw",
+    description: "Patch a lab draw; `null` clears a field.",
+    body: updateHealthLabPanelInputSchema,
     status: 200,
-    response: { description: "The check-in, with its note." },
+    response: { description: "The lab draw." },
     errors: {
       400: true,
+      403: "Health is off for the member, or the key acts for no member.",
       404: true
-    },
-    webhook: "habit.updated",
-    operationId: "note_habit_check_in"
+    }
   },
-  removeCheckIn: {
+  deleteLabPanel: {
     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`.",
+    path: "/health/labs/{id}",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Delete a health lab draw",
+    description: "Delete a lab draw. An Agent's delete waits on the member's confirmation (428).",
+    status: 204,
+    response: { description: "Deleted." },
+    errors: { 403: "Health is off for the member, or the key acts for no member.", 404: true }
+  },
+  labOverview: {
+    method: "get",
+    path: "/health/analytes",
+    scopes: ["health:read"],
+    tag: "Health",
+    summary: "List lab analytes",
+    description: "Every analyte the member's draws measured, each with its trend (oldest point first), the personal target band and the supplement taken for it; plus `draws`, `firstAt`, `lastAt`, `lastLab`.",
     status: 200,
-    response: { description: "The refreshed habit." },
-    errors: { 404: true },
-    webhook: "habit.updated",
-    operationId: "undo_habit_check_in"
+    response: { description: "The lab overview." },
+    errors: { 403: "Health is off for the member, or the key acts for no member." }
+  },
+  getLabAnalyte: {
+    method: "get",
+    path: "/health/analytes/{analyte}",
+    scopes: ["health:read"],
+    tag: "Health",
+    summary: "Get a lab analyte",
+    description: "One analyte's trend across draws. 404 when no draw measured it.",
+    pathParams: { analyte: "The analyte key (`vitamin_d`)." },
+    status: 200,
+    response: { description: "The analyte." },
+    errors: { 404: true }
+  },
+  setLabAnalyte: {
+    method: "put",
+    path: "/health/analytes/{analyte}",
+    scopes: ["health:write"],
+    tag: "Health",
+    summary: "Set a lab analyte",
+    description: "Keep a personal target band (`targetLow`/`targetHigh`, who set it in `targetByContactId`) or the Medication taken for it. An absent key keeps a field; `null` clears it.",
+    pathParams: { analyte: "The analyte key (`vitamin_d`)." },
+    body: setHealthLabAnalyteInputSchema,
+    status: 200,
+    response: { description: "The analyte." },
+    errors: {
+      400: true,
+      403: "Health is off for the member, or the key acts for no member.",
+      404: true
+    }
   }
 });
 
@@ -36671,7 +37755,7 @@ function parseCapture2(input, now) {
 
 // src/meta.ts
 var CLI_NAME = "do";
-var VERSION = "1.314.1";
+var VERSION = "1.316.0";
 var API_PREFIX = "/api/v1";
 var DEFAULT_API_URL = "http://localhost:3001";
 
@@ -38150,7 +39234,7 @@ var CONNECTION_COMMAND_SPECS = [
     ],
     scopes: ["connections:write"],
     returns: "DoccleStatus",
-    notes: "PUT /api/v1/documents/doccle/login, as `do documents doccle connect`. The password is read from the file's first line, never a flag. 422 when Doccle refuses the login or asks for a captcha (nothing is kept)."
+    notes: `${routeOf(documentOperations.doccleConnect)}, as \`do documents doccle connect\`. The password is read from the file's first line, never a flag. 422 when Doccle refuses the login or asks for a captcha (nothing is kept).`
   },
   {
     path: ["steam", "link"],
@@ -38300,7 +39384,7 @@ async function connectDoccle({
   }
   const secret = password;
   return {
-    data: await guarded([secret], () => requireClient().put("/documents/doccle/login", { username, password: secret })),
+    data: await guarded([secret], () => requireClient().put(pathOf(documentOperations.doccleConnect), { username, password: secret })),
     render: renderRecord
   };
 }
@@ -38898,12 +39982,9 @@ var ENTITIES = [
     createInput: "CreateKeyDateInput",
     updateInput: "UpdateKeyDateInput"
   }),
-  {
+  entityFromOperations(documentOperations, {
     name: "documents",
-    path: "/documents",
-    readScopes: ["documents:read"],
     returns: "DocumentView",
-    canGet: true,
     listFlags: [
       {
         name: "kind",
@@ -38921,15 +40002,9 @@ var ENTITIES = [
         query: "providerId"
       }
     ],
-    write: {
-      scopes: ["documents:write"],
-      createSchema: createDocumentInputSchema,
-      createInput: "CreateDocumentInput",
-      updateSchema: updateDocumentInputSchema,
-      updateInput: "UpdateDocumentInput",
-      canDelete: true
-    }
-  },
+    createInput: "CreateDocumentInput",
+    updateInput: "UpdateDocumentInput"
+  }),
   entityFromOperations(incidentOperations, {
     name: "incidents",
     returns: "IncidentView",
@@ -39546,12 +40621,42 @@ var HEALTH_COMMAND_SPECS = [
     notes: "Body: SetHealthLabAnalyteInput. An absent key keeps a field; null clears it."
   }
 ];
-var HEALTH_RECORD_PATHS = {
-  condition: "/health/conditions",
-  episode: "/health/episodes",
-  visit: "/health/encounters",
-  med: "/health/medications",
-  lab: "/health/labs"
+var HEALTH_RECORD_OPERATIONS = {
+  condition: {
+    list: healthOperations.listConditions,
+    get: healthOperations.getCondition,
+    create: healthOperations.createCondition,
+    update: healthOperations.updateCondition,
+    remove: healthOperations.deleteCondition
+  },
+  episode: {
+    list: healthOperations.listEpisodes,
+    get: healthOperations.getEpisode,
+    create: healthOperations.createEpisode,
+    update: healthOperations.updateEpisode,
+    remove: healthOperations.deleteEpisode
+  },
+  visit: {
+    list: healthOperations.listEncounters,
+    get: healthOperations.getEncounter,
+    create: healthOperations.createEncounter,
+    update: healthOperations.updateEncounter,
+    remove: healthOperations.deleteEncounter
+  },
+  med: {
+    list: healthOperations.listMedications,
+    get: healthOperations.getMedication,
+    create: healthOperations.createMedication,
+    update: healthOperations.updateMedication,
+    remove: healthOperations.deleteMedication
+  },
+  lab: {
+    list: healthOperations.listLabPanels,
+    get: healthOperations.getLabPanel,
+    create: healthOperations.createLabPanel,
+    update: healthOperations.updateLabPanel,
+    remove: healthOperations.deleteLabPanel
+  }
 };
 
 // src/journal-import.ts
@@ -40975,27 +42080,27 @@ var COMMAND_SPECS = [
     flags: [
       { name: "source", type: "string", description: "gmail:<id> or doccle_zip (required)." }
     ],
-    scopes: ["documents:read"],
+    scopes: [...documentOperations.filed.scopes],
     returns: "DocumentFiled",
-    notes: "GET /api/v1/documents/filed?source=. Off (403) until DOCUMENTS_IMPORT_ENABLED=true."
+    notes: `${routeOf(documentOperations.filed)}?source=. Off (403) until DOCUMENTS_IMPORT_ENABLED=true.`
   },
   {
     path: ["documents", "doccle", "status"],
     summary: "Your Doccle import: whether it's connected, archive after import, how the last run went and why it's stuck, if it is.",
     args: [],
     flags: [],
-    scopes: ["documents:read"],
+    scopes: [...documentOperations.doccleStatus.scopes],
     returns: "DoccleStatus",
-    notes: "GET /api/v1/documents/doccle. The import files your Doccle mailbox into Papers every night (03:30 Brussels). `failure` says why it stopped (credentials, captcha, changed, unavailable) and what to do. Never shows the login."
+    notes: `${routeOf(documentOperations.doccleStatus)}. The import files your Doccle mailbox into Papers every night (03:30 Brussels). \`failure\` says why it stopped (credentials, captcha, changed, unavailable) and what to do. Never shows the login.`
   },
   {
     path: ["documents", "doccle", "sync"],
     summary: "Run your Doccle import now: each new Doccle document becomes a paper (sender, date, PDF), nothing twice.",
     args: [],
     flags: [],
-    scopes: ["documents:write"],
+    scopes: [...documentOperations.doccleSync.scopes],
     returns: "DoccleSyncResult",
-    notes: "POST /api/v1/documents/doccle/sync. Deduped on Doccle's id and on the PDF's hash (so papers from a Doccle ZIP export aren't filed again). outcome: ok, failed (see failure), not_connected, off (DOCUMENTS_IMPORT_ENABLED isn't on), busy (a run is going)."
+    notes: `${routeOf(documentOperations.doccleSync)}. Deduped on Doccle's id and on the PDF's hash (so papers from a Doccle ZIP export aren't filed again). outcome: ok, failed (see failure), not_connected, off (DOCUMENTS_IMPORT_ENABLED isn't on), busy (a run is going).`
   },
   {
     path: ["documents", "doccle", "connect"],
@@ -41014,9 +42119,9 @@ var COMMAND_SPECS = [
         description: "Read the password from the first line of stdin (else DO_DOCCLE_PASSWORD)."
       }
     ],
-    scopes: ["connections:write"],
+    scopes: [...documentOperations.doccleConnect.scopes],
     returns: "DoccleStatus",
-    notes: "PUT /api/v1/documents/doccle/login. Needs a key with the opt-in connections:write (held by name: Full access never grants it, and a guest's key never holds it). The password is never a flag (shell history): pass --password-file <path>, pipe it in with --password-stdin, or set DO_DOCCLE_PASSWORD. 422 when Doccle refuses the login or asks for a captcha (nothing is kept), 503 when Doccle is down. The login is never returned."
+    notes: `${routeOf(documentOperations.doccleConnect)}. Needs a key with the opt-in connections:write (held by name: Full access never grants it, and a guest's key never holds it). The password is never a flag (shell history): pass --password-file <path>, pipe it in with --password-stdin, or set DO_DOCCLE_PASSWORD. 422 when Doccle refuses the login or asks for a captcha (nothing is kept), 503 when Doccle is down. The login is never returned.`
   },
   {
     path: ["documents", "doccle", "disconnect"],
@@ -41025,9 +42130,9 @@ var COMMAND_SPECS = [
     flags: [
       { name: "allow-destructive", type: "boolean", description: "Required to forget the login." }
     ],
-    scopes: ["documents:write"],
+    scopes: [...documentOperations.doccleDisconnect.scopes],
     returns: "DoccleStatus",
-    notes: "DELETE /api/v1/documents/doccle/login. Gated behind --allow-destructive."
+    notes: `${routeOf(documentOperations.doccleDisconnect)}. Gated behind --allow-destructive.`
   },
   {
     path: ["documents", "doccle", "set"],
@@ -41040,9 +42145,9 @@ var COMMAND_SPECS = [
         description: "on or off (off by default): archive in Doccle after import."
       }
     ],
-    scopes: ["documents:write"],
+    scopes: [...documentOperations.doccleSettings.scopes],
     returns: "DoccleStatus",
-    notes: "PATCH /api/v1/documents/doccle with { archiveAfterImport }."
+    notes: `${routeOf(documentOperations.doccleSettings)} with { archiveAfterImport }.`
   },
   {
     path: ["documents", "ask"],
@@ -41062,9 +42167,9 @@ var COMMAND_SPECS = [
         description: "How many passages at most (default 5, up to 20)."
       }
     ],
-    scopes: ["documents:read"],
+    scopes: [...documentOperations.ask.scopes],
     returns: "DocumentAnswer",
-    notes: "POST /api/v1/documents/ask with { question, documentId?, limit? }. Reads the papers' key fields and their files' text (a page per form feed). do writes no prose: word the answer from the passages, quote the pages, and say it is not legal advice. `withoutText` names the papers with no file text to read. An Only me paper answers only its owner's key with documents:private."
+    notes: `${routeOf(documentOperations.ask)} with { question, documentId?, limit? }. Reads the papers' key fields and their files' text (a page per form feed). do writes no prose: word the answer from the passages, quote the pages, and say it is not legal advice. \`withoutText\` names the papers with no file text to read. An Only me paper answers only its owner's key with documents:private.`
   },
   {
     path: ["documents", "search"],
@@ -41078,36 +42183,36 @@ var COMMAND_SPECS = [
         description: "How many hits at most (default 20, up to 50)."
       }
     ],
-    scopes: ["documents:read"],
+    scopes: [...documentOperations.search.scopes],
     returns: "{ q, hits: DocumentPassage[] }",
-    notes: "GET /api/v1/documents/search?q=&documentId=&limit=."
+    notes: `${routeOf(documentOperations.search)}?q=&documentId=&limit=.`
   },
   {
     path: ["documents", "unmatched"],
     summary: "List the papers that ask for money (an amount due) and have no payment linked yet, oldest due first.",
     args: [],
     flags: [],
-    scopes: ["documents:read", "finance:read"],
+    scopes: [...documentOperations.unmatched.scopes],
     returns: "UnmatchedPaper",
-    notes: "GET /api/v1/documents/unmatched. `candidates` counts the payments that fit equally well (pick one with `do documents link-payment`). A payment on an account you can't see doesn't count."
+    notes: `${routeOf(documentOperations.unmatched)}. \`candidates\` counts the payments that fit equally well (pick one with \`do documents link-payment\`). A payment on an account you can't see doesn't count.`
   },
   {
     path: ["documents", "match"],
     summary: "Match a paper (or, without an id, every paper still waiting) to the payment that paid it.",
     args: [{ name: "id", required: false, description: "The paper; left out, all of them." }],
     flags: [],
-    scopes: ["documents:read", "finance:write"],
+    scopes: [...documentOperations.matchOne.scopes],
     returns: "PaperMatchResult",
-    notes: "POST /api/v1/documents/:id/match or /api/v1/documents/match. A payment is money out of exactly the amount due, within the paper's window, with its structured reference or to its IBAN. Status: matched, already, ambiguous, none or not_payable."
+    notes: `${routeOf(documentOperations.matchOne)} or ${PUBLIC_API_PREFIX}${documentOperations.matchAll.path}. A payment is money out of exactly the amount due, within the paper's window, with its structured reference or to its IBAN. Status: matched, already, ambiguous, none or not_payable.`
   },
   {
     path: ["documents", "payments"],
     summary: "Show the payments linked to a paper.",
     args: [{ name: "id", required: true, description: "The paper (document id)." }],
     flags: [],
-    scopes: ["documents:read", "finance:read"],
+    scopes: [...documentOperations.payments.scopes],
     returns: "DocumentPayment",
-    notes: "GET /api/v1/documents/:id/payments."
+    notes: `${routeOf(documentOperations.payments)}.`
   },
   {
     path: ["documents", "link-payment"],
@@ -41117,9 +42222,9 @@ var COMMAND_SPECS = [
       { name: "transactionId", required: true, description: "The Money transaction." }
     ],
     flags: [],
-    scopes: ["documents:read", "finance:write"],
+    scopes: [...documentOperations.linkPayment.scopes],
     returns: "DocumentPayment",
-    notes: "PUT /api/v1/documents/:id/payments with { transactionId }."
+    notes: `${routeOf(documentOperations.linkPayment)} with { transactionId }.`
   },
   {
     path: ["documents", "unlink-payment"],
@@ -41129,9 +42234,9 @@ var COMMAND_SPECS = [
       { name: "transactionId", required: true, description: "The Money transaction." }
     ],
     flags: [],
-    scopes: ["documents:read", "finance:write"],
+    scopes: [...documentOperations.unlinkPayment.scopes],
     returns: "{ ok, unlinked }",
-    notes: "DELETE /api/v1/documents/:id/payments/:transactionId."
+    notes: `${routeOf(documentOperations.unlinkPayment)}.`
   },
   {
     path: ["incidents", "open"],
@@ -43874,7 +44979,7 @@ var COMMAND_SPECS = [
         description: "Which grandparents to climb to: father or mother."
       }
     ],
-    scopes: ["people:family-tree"],
+    scopes: [...familyTreeOperations.get.scopes],
     returns: "FamilyTreeResponse",
     notes: "people:family-tree is sensitive: never part of a full-access key, opened in Settings for one key, and only your own tree. { tree: null } before an import."
   },
@@ -43898,7 +45003,7 @@ var COMMAND_SPECS = [
       { name: "filter", type: "string", description: "all (default), living or linked." },
       { name: "limit", type: "string", description: "At most this many (1\u2013500, default 100)." }
     ],
-    scopes: ["people:family-tree"],
+    scopes: [...familyTreeOperations.people.scopes],
     returns: "FamilyTreePeople"
   },
   {
@@ -43906,7 +45011,7 @@ var COMMAND_SPECS = [
     summary: "Say which person in the tree is you.",
     args: [{ name: "personId", required: true, description: "Your ref in the tree (I12)." }],
     flags: [],
-    scopes: ["people:family-tree"],
+    scopes: [...familyTreeOperations.me.scopes],
     returns: "FamilyTreeView",
     notes: "The person becomes the root of the branch, and a living one is linked to your own Contact (the one that is you)."
   },
@@ -43922,7 +45027,7 @@ var COMMAND_SPECS = [
         description: "Say no to this match id (never offered again)."
       }
     ],
-    scopes: ["people:family-tree"],
+    scopes: [...familyTreeOperations.matches.scopes],
     returns: "FamilyTreeMatches",
     notes: "Without a flag it lists the matches: suggest (a relative who looks like a Contact), birthday_differs, not_in_tree. Yes to a suggest links them; yes to birthday_differs takes the tree's day; not_in_tree only takes no (the fix goes to who sent the tree). Ask the member before either."
   },
@@ -46252,24 +47357,24 @@ var HANDLERS = {
     return { data: await requireClient().upload("/documents/file", form), render: renderRecord };
   },
   "documents filed": async ({ flags, requireClient }) => ({
-    data: await requireClient().get("/documents/filed", {
+    data: await requireClient().get(pathOf(documentOperations.filed), {
       query: { source: requireFlag(flags, "source", "documents filed needs --source gmail:<id>") }
     }),
     render: renderRecord
   }),
   "documents doccle status": async ({ requireClient }) => ({
-    data: await requireClient().get("/documents/doccle"),
+    data: await requireClient().get(pathOf(documentOperations.doccleStatus)),
     render: renderRecord
   }),
   "documents doccle sync": async ({ requireClient }) => ({
-    data: await requireClient().post("/documents/doccle/sync", {}),
+    data: await requireClient().post(pathOf(documentOperations.doccleSync), {}),
     render: renderRecord
   }),
   "documents doccle connect": (ctx) => connectDoccle(ctx),
   "documents doccle disconnect": async ({ flags, requireClient }) => {
     assertDestructiveAllowed(flags, "forget the Doccle login");
     return {
-      data: await requireClient().delete("/documents/doccle/login"),
+      data: await requireClient().delete(pathOf(documentOperations.doccleDisconnect)),
       render: renderRecord
     };
   },
@@ -46278,7 +47383,7 @@ var HANDLERS = {
     if (archive !== "on" && archive !== "off")
       throw usageError("--archive takes on or off");
     return {
-      data: await requireClient().patch("/documents/doccle", {
+      data: await requireClient().patch(pathOf(documentOperations.doccleSettings), {
         archiveAfterImport: archive === "on"
       }),
       render: renderRecord
@@ -46294,7 +47399,10 @@ var HANDLERS = {
       documentId: flagString(flags, "document"),
       limit: limit === undefined ? undefined : Number(limit)
     }).filter(([, value]) => value !== undefined));
-    return { data: await requireClient().post("/documents/ask", body), render: renderRecord };
+    return {
+      data: await requireClient().post(pathOf(documentOperations.ask), body),
+      render: renderRecord
+    };
   },
   "documents search": async ({ args, flags, requireClient }) => {
     const q = args.join(" ").trim();
@@ -46306,28 +47414,30 @@ var HANDLERS = {
       limit: flagString(flags, "limit")
     }).filter(([, value]) => value !== undefined));
     return {
-      data: await requireClient().get("/documents/search", { query }),
+      data: await requireClient().get(pathOf(documentOperations.search), { query }),
       render: renderRecord
     };
   },
   "documents unmatched": async ({ requireClient }) => ({
-    data: await requireClient().get("/documents/unmatched"),
+    data: await requireClient().get(pathOf(documentOperations.unmatched)),
     render: renderList
   }),
   "documents match": async ({ args, requireClient }) => {
     const id = args[0];
-    const path = id ? `/documents/${id}/match` : "/documents/match";
+    const path = id ? pathOf(documentOperations.matchOne, { id }) : pathOf(documentOperations.matchAll);
     return { data: await requireClient().post(path, {}), render: id ? renderRecord : renderList };
   },
   "documents payments": async ({ args, requireClient }) => ({
-    data: await requireClient().get(`/documents/${requireArg(args, 0, "document id")}/payments`),
+    data: await requireClient().get(pathOf(documentOperations.payments, { id: requireArg(args, 0, "document id") })),
     render: renderList
   }),
   "documents link-payment": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "document id");
     const transactionId = requireArg(args, 1, "transaction id");
     return {
-      data: await requireClient().put(`/documents/${id}/payments`, { transactionId }),
+      data: await requireClient().put(pathOf(documentOperations.linkPayment, { id }), {
+        transactionId
+      }),
       render: renderList
     };
   },
@@ -46335,7 +47445,7 @@ var HANDLERS = {
     const id = requireArg(args, 0, "document id");
     const transactionId = requireArg(args, 1, "transaction id");
     assertDestructiveAllowed(flags, `unlink payment ${transactionId} from ${id}`);
-    await requireClient().delete(`/documents/${id}/payments/${transactionId}`);
+    await requireClient().delete(pathOf(documentOperations.unlinkPayment, { id, transactionId }));
     return { data: { ok: true, unlinked: transactionId }, render: renderRecord };
   },
   "incidents open": async ({ args, flags, requireClient }) => {
@@ -48338,18 +49448,24 @@ var HANDLERS = {
   ...healthRecordHandlers(),
   "health record": async ({ flags, requireClient }) => {
     const body = parseInput(logHealthInputSchema, readDataFlag(flags));
-    return { data: await requireClient().post("/health/log", body), render: renderRecord };
+    return {
+      data: await requireClient().post(pathOf(healthOperations.log), body),
+      render: renderRecord
+    };
   },
   "health fix": async ({ args, flags, requireClient }) => {
     const entryId = requireArg(args, 0, "entry");
     const body = parseInput(correctHealthInputSchema, { entryId, change: readDataFlag(flags) });
-    return { data: await requireClient().post("/health/correct", body), render: renderRecord };
+    return {
+      data: await requireClient().post(pathOf(healthOperations.correct), body),
+      render: renderRecord
+    };
   },
   "health check-in": async ({ args, requireClient }) => {
     const episodeId = requireArg(args, 0, "episode");
     const body = parseInput(healthCheckInInputSchema, { trend: requireArg(args, 1, "trend") });
     return {
-      data: await requireClient().post(`/health/episodes/${episodeId}/check-in`, body),
+      data: await requireClient().post(pathOf(healthOperations.checkIn, { id: episodeId }), body),
       render: renderRecord
     };
   },
@@ -48366,7 +49482,7 @@ var HANDLERS = {
       ...thread ? { thread: { slug: thread } } : {}
     });
     return {
-      data: await requireClient().post(`/health/episodes/${episodeId}/red-flags`, body),
+      data: await requireClient().post(pathOf(healthOperations.redFlags, { id: episodeId }), body),
       render: renderRecord
     };
   },
@@ -48375,37 +49491,40 @@ var HANDLERS = {
       kind: requireArg(args, 0, "kind"),
       id: requireArg(args, 1, "id")
     });
-    return { data: await requireClient().post("/health/undo", body), render: renderRecord };
+    return {
+      data: await requireClient().post(pathOf(healthOperations.undo), body),
+      render: renderRecord
+    };
   },
   "health find": async ({ flags, requireClient }) => {
     const body = parseInput(upsertHealthEpisodeInputSchema, readDataFlag(flags));
     return {
-      data: await requireClient().post("/health/episodes/upsert", body),
+      data: await requireClient().post(pathOf(healthOperations.upsertEpisode), body),
       render: renderRecord
     };
   },
   "health medical-id": async ({ requireClient }) => ({
-    data: await requireClient().get("/health/medical-id"),
+    data: await requireClient().get(pathOf(healthOperations.medicalId)),
     render: renderRecord
   }),
   "health summary": async ({ flags, requireClient }) => ({
-    data: await requireClient().get("/health/summary", {
+    data: await requireClient().get(pathOf(healthOperations.summary), {
       query: { episodeId: flagString(flags, "episode") }
     }),
     render: renderRecord
   }),
   "health export": async ({ flags, requireClient }) => {
-    const raw = await requireClient().getText("/health/export", {
+    const raw = await requireClient().getText(pathOf(healthOperations.export), {
       query: { files: flagBool(flags, "no-files") ? "false" : undefined }
     });
     return { raw, data: undefined, render: () => raw };
   },
   "health shares": async ({ requireClient }) => ({
-    data: await requireClient().getPage("/health/shares"),
+    data: await requireClient().getPage(pathOf(healthOperations.listShares)),
     render: renderList
   }),
   "health share revoke": async ({ args, requireClient }) => ({
-    data: await requireClient().delete(`/health/shares/${requireArg(args, 0, "id")}`),
+    data: await requireClient().delete(pathOf(healthOperations.revokeShare, { id: requireArg(args, 0, "id") })),
     render: renderRecord
   }),
   "health withings status": async ({ requireClient }) => ({
@@ -48425,11 +49544,11 @@ var HANDLERS = {
     render: renderRecord
   }),
   "health consent": async ({ requireClient }) => ({
-    data: await requireClient().get("/health/consent"),
+    data: await requireClient().get(pathOf(healthOperations.getConsent)),
     render: renderRecord
   }),
   "health profile": async ({ requireClient }) => ({
-    data: await requireClient().get("/health/profile"),
+    data: await requireClient().get(pathOf(healthOperations.getProfile)),
     render: renderRecord
   }),
   "health profile set": async ({ flags, requireClient }) => {
@@ -48441,7 +49560,10 @@ var HANDLERS = {
     if (sex !== undefined)
       fields.sex = sex.trim() ? sex.trim() : null;
     const body = parseInput(updateHealthProfileInputSchema, fields);
-    return { data: await requireClient().patch("/health/profile", body), render: renderRecord };
+    return {
+      data: await requireClient().patch(pathOf(healthOperations.updateProfile), body),
+      render: renderRecord
+    };
   },
   "health log": async ({ args, flags, requireClient }) => {
     const episode = requireArg(args, 0, "episode");
@@ -48460,7 +49582,7 @@ var HANDLERS = {
     };
     const body = parseInput(logHealthSymptomInputSchema, { id: ulid3(), ...raw });
     return {
-      data: await requireClient().post(`/health/episodes/${episode}/entries`, body),
+      data: await requireClient().post(pathOf(healthOperations.logSymptom, { id: episode }), body),
       render: renderRecord
     };
   },
@@ -48472,14 +49594,14 @@ var HANDLERS = {
       ...readDataFlag(flags)
     });
     return {
-      data: await requireClient().post(`/health/episodes/${episode}/entries/${entry}/correct`, body),
+      data: await requireClient().post(pathOf(healthOperations.correctSymptom, { id: episode, entryId: entry }), body),
       render: renderRecord
     };
   },
   "health unlog": async ({ args, requireClient }) => {
     const episode = requireArg(args, 0, "episode");
     const entry = requireArg(args, 1, "entry");
-    await requireClient().delete(`/health/episodes/${episode}/entries/${entry}`);
+    await requireClient().delete(pathOf(healthOperations.deleteSymptom, { id: episode, entryId: entry }));
     return { data: { ok: true, deleted: entry }, render: renderRecord };
   },
   "health lab import": async ({ args, flags, requireClient }) => {
@@ -48506,14 +49628,17 @@ var HANDLERS = {
     };
   },
   "health labs analytes": async ({ requireClient }) => ({
-    data: await requireClient().get("/health/labs/analytes"),
+    data: await requireClient().get(pathOf(healthOperations.listLabAnalytes)),
     render: renderList
   }),
   "health labs normalize": async ({ flags, requireClient }) => {
     if (!flagBool(flags, "dry-run")) {
       throw usageError("health labs normalize only reports for now: pass --dry-run (stored keys aren't rewritten)");
     }
-    return { data: await requireClient().get("/health/labs/normalize"), render: renderRecord };
+    return {
+      data: await requireClient().get(pathOf(healthOperations.labNormalizeReport)),
+      render: renderRecord
+    };
   },
   "health conditions care-team add": async ({ args, flags, requireClient }) => {
     const condition = requireArg(args, 0, "condition");
@@ -48523,7 +49648,7 @@ var HANDLERS = {
       ...label !== undefined ? { label } : {}
     });
     return {
-      data: await requireClient().post(`/health/conditions/${condition}/care-team`, body),
+      data: await requireClient().post(pathOf(healthOperations.addCareTeam, { id: condition }), body),
       render: renderRecord
     };
   },
@@ -48531,28 +49656,28 @@ var HANDLERS = {
     const condition = requireArg(args, 0, "condition");
     const contact = requireArg(args, 1, "contact");
     return {
-      data: await requireClient().delete(`/health/conditions/${condition}/care-team/${contact}`),
+      data: await requireClient().delete(pathOf(healthOperations.removeCareTeam, { id: condition, contactId: contact })),
       render: renderRecord
     };
   },
   "health analytes": async ({ requireClient }) => ({
-    data: await requireClient().get("/health/analytes"),
+    data: await requireClient().get(pathOf(healthOperations.labOverview)),
     render: renderRecord
   }),
   "health analyte": async ({ args, requireClient }) => ({
-    data: await requireClient().get(`/health/analytes/${requireArg(args, 0, "analyte")}`),
+    data: await requireClient().get(pathOf(healthOperations.getLabAnalyte, { analyte: requireArg(args, 0, "analyte") })),
     render: renderRecord
   }),
   "health analyte set": async ({ args, flags, requireClient }) => {
     const analyte = requireArg(args, 0, "analyte");
     const body = parseInput(setHealthLabAnalyteInputSchema, readDataFlag(flags));
     return {
-      data: await requireClient().put(`/health/analytes/${analyte}`, body),
+      data: await requireClient().put(pathOf(healthOperations.setLabAnalyte, { analyte }), body),
       render: renderRecord
     };
   },
   "health doses": async ({ args, requireClient }) => ({
-    data: await requireClient().getPage(`/health/medications/${requireArg(args, 0, "med")}/doses`),
+    data: await requireClient().getPage(pathOf(healthOperations.listDoses, { id: requireArg(args, 0, "med") })),
     render: renderList
   }),
   "health dose": async ({ args, flags, requireClient }) => {
@@ -48567,7 +49692,7 @@ var HANDLERS = {
     };
     const body = parseInput(logHealthDoseInputSchema, { id: ulid3(), ...raw });
     return {
-      data: await requireClient().post(`/health/medications/${med}/doses`, body),
+      data: await requireClient().post(pathOf(healthOperations.logDose, { id: med }), body),
       render: renderRecord
     };
   },
@@ -48576,14 +49701,14 @@ var HANDLERS = {
     const dose = requireArg(args, 1, "dose");
     const body = parseInput(updateHealthDoseInputSchema, readDataFlag(flags));
     return {
-      data: await requireClient().patch(`/health/medications/${med}/doses/${dose}`, body),
+      data: await requireClient().patch(pathOf(healthOperations.updateDose, { id: med, doseId: dose }), body),
       render: renderRecord
     };
   },
   "health undose": async ({ args, requireClient }) => {
     const med = requireArg(args, 0, "med");
     const dose = requireArg(args, 1, "dose");
-    await requireClient().delete(`/health/medications/${med}/doses/${dose}`);
+    await requireClient().delete(pathOf(healthOperations.deleteDose, { id: med, doseId: dose }));
     return { data: { ok: true, deleted: dose }, render: renderRecord };
   },
   "places import": async ({ args, flags, requireClient }) => {
@@ -48762,7 +49887,9 @@ var HANDLERS = {
     const side = flagString(flags, "side");
     parseInput(familyTreeQuerySchema, side ? { side } : {});
     return {
-      data: await requireClient().get("/family-tree", { query: side ? { side } : {} }),
+      data: await requireClient().get(pathOf(familyTreeOperations.get), {
+        query: side ? { side } : {}
+      }),
       render: renderRecord
     };
   },
@@ -48798,13 +49925,16 @@ var HANDLERS = {
     };
     parseInput(familyTreePeopleQuerySchema, query);
     return {
-      data: await requireClient().get("/family-tree/people", { query }),
+      data: await requireClient().get(pathOf(familyTreeOperations.people), { query }),
       render: renderRecord
     };
   },
   "people tree me": async ({ args, requireClient }) => {
     const body = parseInput(familyTreeMeInputSchema, { ref: requireArg(args, 0, "person id") });
-    return { data: await requireClient().put("/family-tree/me", body), render: renderRecord };
+    return {
+      data: await requireClient().put(pathOf(familyTreeOperations.me), body),
+      render: renderRecord
+    };
   },
   "people tree matches": async ({ flags, requireClient }) => {
     const accept = flagString(flags, "accept");
@@ -48813,13 +49943,16 @@ var HANDLERS = {
       throw usageError("--accept and --reject can't be combined");
     const client = requireClient();
     if (!accept && !reject) {
-      return { data: await client.get("/family-tree/matches"), render: renderRecord };
+      return { data: await client.get(pathOf(familyTreeOperations.matches)), render: renderRecord };
     }
     const body = parseInput(familyTreeMatchDecisionInputSchema, {
       id: accept ?? reject,
       decision: accept ? "accept" : "reject"
     });
-    return { data: await client.post("/family-tree/matches", body), render: renderRecord };
+    return {
+      data: await client.post(pathOf(familyTreeOperations.decide), body),
+      render: renderRecord
+    };
   },
   "guest-lists overview": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "guest list id");
@@ -49377,17 +50510,20 @@ function healthRecordHandlers() {
     lab: "labs"
   };
   const out = {};
-  for (const kind of Object.keys(HEALTH_RECORD_PATHS)) {
-    const path = HEALTH_RECORD_PATHS[kind];
+  for (const kind of Object.keys(HEALTH_RECORD_OPERATIONS)) {
+    const ops = HEALTH_RECORD_OPERATIONS[kind];
     const schemas = schemasOf[kind];
     out[`health ${plurals[kind]}`] = async ({ flags, requireClient }) => {
       const query = {};
       for (const name of schemas.list ?? [])
         query[name] = flagString(flags, name);
-      return { data: await requireClient().getPage(path, { query }), render: renderList };
+      return {
+        data: await requireClient().getPage(pathOf(ops.list), { query }),
+        render: renderList
+      };
     };
     out[`health ${kind}`] = async ({ args, requireClient }) => ({
-      data: await requireClient().get(`${path}/${requireArg(args, 0, "id")}`),
+      data: await requireClient().get(pathOf(ops.get, { id: requireArg(args, 0, "id") })),
       render: renderRecord
     });
     out[`health ${kind} add`] = async ({ flags, requireClient }) => {
@@ -49396,17 +50532,20 @@ function healthRecordHandlers() {
         ...readDataFlag(flags),
         ...schemas.addFlags?.(flags)
       });
-      return { data: await requireClient().post(path, body), render: renderRecord };
+      return { data: await requireClient().post(pathOf(ops.create), body), render: renderRecord };
     };
     out[`health ${kind} update`] = async ({ args, flags, requireClient }) => {
       const id = requireArg(args, 0, "id");
       const body = parseInput(schemas.update, readDataFlag(flags));
-      return { data: await requireClient().patch(`${path}/${id}`, body), render: renderRecord };
+      return {
+        data: await requireClient().patch(pathOf(ops.update, { id }), body),
+        render: renderRecord
+      };
     };
     out[`health ${kind} delete`] = async ({ args, flags, requireClient }) => {
       const id = requireArg(args, 0, "id");
       assertDestructiveAllowed(flags, `delete health ${kind} ${id}`);
-      await requireClient().delete(`${path}/${id}`);
+      await requireClient().delete(pathOf(ops.remove, { id }));
       return { data: { ok: true, deleted: id, softDelete: true }, render: renderRecord };
     };
   }