@robbeverhelst/do 1.334.0 → 1.336.0

package/dist/do.js

@@ -14418,7 +14418,7 @@ var configError = (message) => new CliError("config", message, EXIT.CONFIG);
 
 // src/meta.ts
 var CLI_NAME = "do";
-var VERSION = "1.334.0";
+var VERSION = "1.336.0";
 var API_PREFIX = "/api/v1";
 var DEFAULT_API_URL = "http://localhost:3001";
 
@@ -22915,6 +22915,12 @@ var moneyAccountKind = pgEnum("money_account_kind", [
   "pension",
   "asset_manual"
 ]);
+var moneyPensionSubtype = pgEnum("money_pension_subtype", [
+  "group_insurance",
+  "pension_savings_fund",
+  "pension_savings_insurance",
+  "vapz"
+]);
 var moneyAccountHolder = pgEnum("money_account_holder", ["me", "joint", "other"]);
 var moneyAccountEntity = pgEnum("money_account_entity", ["personal", "business"]);
 var moneyImportSource = pgEnum("money_import_source", [
@@ -22966,6 +22972,8 @@ var moneyTaxTag = pgEnum("money_tax_tag", [
 var moneyAccounts = pgTable("money_accounts", {
   ...leafColumns(),
   kind: moneyAccountKind("kind").notNull().default("current"),
+  pensionSubtype: moneyPensionSubtype("pension_subtype"),
+  lockedUntil: date5("locked_until"),
   holder: moneyAccountHolder("holder").notNull().default("me"),
   entity: moneyAccountEntity("entity").notNull().default("personal"),
   institutionContactId: text("institution_contact_id").references(() => contacts.id, {
@@ -25202,6 +25210,7 @@ var fileViewLinkSchema = object({
 
 // ../../packages/schema/src/contracts/money.ts
 var moneyAccountKindSchema = _enum2(moneyAccountKind.enumValues);
+var moneyPensionSubtypeSchema = _enum2(moneyPensionSubtype.enumValues);
 var moneyAccountHolderSchema = _enum2(moneyAccountHolder.enumValues);
 var moneyAccountEntitySchema = _enum2(moneyAccountEntity.enumValues);
 var moneyImportSourceSchema = _enum2(moneyImportSource.enumValues);
@@ -25297,6 +25306,8 @@ var createMoneyAccountInputSchema = object({
   id: ulidSchema,
   title: string2().trim().min(1).max(120),
   kind: moneyAccountKindSchema.optional(),
+  pensionSubtype: moneyPensionSubtypeSchema.nullish(),
+  lockedUntil: keyDateDaySchema.nullish(),
   holder: moneyAccountHolderSchema.optional(),
   institutionContactId: ulidSchema.nullish(),
   iban: string2().trim().transform(compactIban).pipe(string2().regex(/^[A-Z]{2}\d{2}[A-Z0-9]{8,30}$/, "expected an IBAN")).nullish(),
@@ -25310,7 +25321,9 @@ var moneyBalanceAtSchema = union([keyDateDaySchema, exports_iso.datetime({ offse
 var updateMoneyAccountInputSchema = createMoneyAccountInputSchema.omit({ id: true, currency: true }).partial().extend({
   balance: moneyAmountSchema.optional(),
   balanceAt: moneyBalanceAtSchema.optional()
-}).strict().refine((u) => u.balance === undefined === (u.balanceAt === undefined), {
+}).strict().refine((u) => Object.values(u).some((v) => v !== undefined), {
+  message: "nothing to change: give a field to set (or a balance with its balanceAt)"
+}).refine((u) => u.balance === undefined === (u.balanceAt === undefined), {
   message: "a balance and the day it's from go together",
   path: ["balanceAt"]
 });
@@ -26558,6 +26571,16 @@ var familyTreeUnionSchema = object({
   partners: array(familyTreeRefSchema),
   children: array(familyTreeRefSchema)
 });
+var FAMILY_TREE_MAX_GENERATIONS = 50;
+var familyTreeAncestorSchema = object({
+  n: number2().int().min(1),
+  generation: number2().int().min(0),
+  ref: familyTreeRefSchema,
+  repeatOf: number2().int().nullable()
+});
+function ahnentafelGeneration(n) {
+  return Math.floor(Math.log2(n));
+}
 var familyTreePersonViewSchema = object({
   ref: familyTreeRefSchema,
   name: string2(),
@@ -26615,11 +26638,24 @@ var familyTreeViewSchema = object({
   birthdaysOffered: array(familyTreeRefSchema),
   branch: familyTreeBranchViewSchema.nullable(),
   matches: array(familyTreeMatchSchema),
+  edits: object({ count: number2().int(), skipped: number2().int() }),
   updatedAt: exports_coerce.date()
 });
 var familyTreeResponseSchema = object({ tree: familyTreeViewSchema.nullable() });
 var sourceNameSchema = string2().trim().min(1).max(80);
 var sourceEmailSchema = string2().trim().email().max(200);
+var familyTreeAncestorsQuerySchema = object({
+  ref: familyTreeRefSchema.optional(),
+  depth: exports_coerce.number().int().min(1).max(FAMILY_TREE_MAX_GENERATIONS).optional()
+});
+var familyTreeAncestorsSchema = object({
+  rootRef: familyTreeRefSchema,
+  depth: number2().int().nullable(),
+  generations: number2().int(),
+  deeper: boolean2(),
+  ancestors: array(familyTreeAncestorSchema),
+  people: array(familyTreePersonViewSchema)
+});
 var familyTreeQuerySchema = object({ side: familyTreeSideSchema.optional() });
 var familyTreeUploadFieldsSchema = object({
   sourceName: preprocess((v) => v === "" ? undefined : v, sourceNameSchema.optional()),
@@ -26656,7 +26692,118 @@ var familyTreeMatchDecisionResultSchema = object({
   matches: array(familyTreeMatchViewSchema)
 });
 
+// ../../packages/schema/src/contracts/family-tree-edits.ts
+var familyTreeDateSchema = string2().trim().regex(/^\d{4}(-\d{2}-\d{2})?$/, "expected YYYY or YYYY-MM-DD").refine((v) => {
+  if (v.length === 4)
+    return true;
+  const d = new Date(`${v}T00:00:00Z`);
+  return !Number.isNaN(d.getTime()) && d.toISOString().slice(0, 10) === v;
+}, "not a real day");
+var nameSchema = string2().trim().min(1).max(120);
+var partSchema = string2().trim().min(1).max(80).nullish();
+var placeSchema = string2().trim().min(1).max(200).nullish();
+var sexSchema = _enum2(["M", "F"]).nullish();
+var personFieldsShape = {
+  given: partSchema,
+  surname: partSchema,
+  sex: sexSchema,
+  birthDate: familyTreeDateSchema.nullish(),
+  birthPlace: placeSchema,
+  deathDate: familyTreeDateSchema.nullish(),
+  deathPlace: placeSchema
+};
+var addFamilyTreePersonInputSchema = object({ name: nameSchema, ...personFieldsShape }).strict();
+var editFamilyTreePersonInputSchema = object({ name: nameSchema.optional(), ...personFieldsShape }).strict().refine((v) => Object.values(v).some((x) => x !== undefined), "nothing to change");
+var factTypeSchema = string2().trim().min(1).max(40).transform((v) => v.toLowerCase());
+var factFieldsShape = {
+  date: string2().trim().min(1).max(60).nullish(),
+  place: placeSchema,
+  value: string2().trim().min(1).max(2000).nullish()
+};
+var addFamilyTreeFactInputSchema = object({ type: factTypeSchema, ...factFieldsShape }).strict();
+var editFamilyTreeFactInputSchema = object({ type: factTypeSchema.optional(), ...factFieldsShape }).strict().refine((v) => Object.values(v).some((x) => x !== undefined), "nothing to change");
+var familyTreeFactIdSchema = string2().regex(/^[A-Za-z0-9_-]{1,40}$/, "expected a fact id");
+var familyTreeLinkInputSchema = discriminatedUnion("kind", [
+  object({ kind: literal("parent"), parent: familyTreeRefSchema, child: familyTreeRefSchema }).strict(),
+  object({ kind: literal("partner"), a: familyTreeRefSchema, b: familyTreeRefSchema }).strict()
+]);
+var familyTreeFactSchema = object({
+  id: familyTreeFactIdSchema,
+  type: string2(),
+  date: string2().nullable(),
+  place: string2().nullable(),
+  value: string2().nullable()
+});
+var relativeSchema = object({ ref: familyTreeRefSchema, name: string2() });
+var familyTreePersonDetailSchema = object({
+  ref: familyTreeRefSchema,
+  name: string2(),
+  given: string2().nullable(),
+  surname: string2().nullable(),
+  sex: _enum2(["M", "F"]).nullable(),
+  birthDate: string2().nullable(),
+  birthYear: number2().int().nullable(),
+  birthPlace: string2().nullable(),
+  deathDate: string2().nullable(),
+  deathYear: number2().int().nullable(),
+  deathPlace: string2().nullable(),
+  living: boolean2(),
+  facts: array(familyTreeFactSchema),
+  parents: array(relativeSchema),
+  partners: array(relativeSchema),
+  children: array(relativeSchema),
+  added: boolean2(),
+  contact: object({ id: ulidSchema, title: string2() }).nullable()
+});
+var familyTreeEditKindSchema = _enum2([
+  "person_add",
+  "person_edit",
+  "person_remove",
+  "fact_add",
+  "fact_edit",
+  "fact_remove",
+  "link_parent",
+  "link_partner",
+  "unlink_parent",
+  "unlink_partner"
+]);
+var familyTreeEditViewSchema = object({
+  id: ulidSchema,
+  kind: familyTreeEditKindSchema,
+  line: string2(),
+  at: exports_coerce.date(),
+  applied: boolean2(),
+  reason: string2().nullable()
+});
+var familyTreeEditsSchema = object({ edits: array(familyTreeEditViewSchema) });
+var familyTreeChangeSchema = object({
+  ref: familyTreeRefSchema,
+  op: _enum2(["created", "updated", "deleted"]),
+  name: string2(),
+  fields: array(string2())
+});
+var familyTreeEditReceiptSchema = object({
+  edit: familyTreeEditViewSchema,
+  changes: array(familyTreeChangeSchema),
+  person: familyTreePersonDetailSchema.nullable()
+});
+var familyTreeUndoResultSchema = object({
+  undone: ulidSchema,
+  changes: array(familyTreeChangeSchema),
+  skipped: array(familyTreeEditViewSchema)
+});
+
 // ../../packages/schema/src/operations/family-tree.ts
+var REF = {
+  ref: { description: "The person's ref in the tree (`I12`, or `P\u2026` for one added in do)." }
+};
+var REF_SCHEMA = { ref: familyTreeRefSchema };
+var FACT = {
+  ...REF,
+  factId: { description: "The fact's id (`OCCU-1` from the GEDCOM, `f-\u2026` for one added in do)." }
+};
+var FACT_SCHEMA = { ref: familyTreeRefSchema, factId: familyTreeFactIdSchema };
+var RECEIPT = "Returns the receipt `{ edit, changes, person }`: `edit.id` is what `POST /family-tree/edits/{id}/undo` takes, `changes` lists each person the edit changed (created \xB7 updated \xB7 deleted, with the fields). The edit is kept as an overlay over the import, so a new GEDCOM keeps it.";
 var NOT_IN_STAR = "A sensitive scope (ADR 0028): never part of `*`, and only the tree of the member who minted the key.";
 var familyTreeOperations = defineOperations({
   import: {
@@ -26693,6 +26840,31 @@ var familyTreeOperations = defineOperations({
     response: { description: "`{ tree }`." },
     errors: { 400: true, 403: "The key doesn't hold `people:family-tree`, or is no member's." }
   },
+  ancestors: {
+    method: "get",
+    path: "/family-tree/ancestors",
+    scopes: ["people:family-tree"],
+    tag: "People",
+    summary: "The direct line back",
+    description: "A pedigree: every ancestor of `ref` (the member's own place in the tree when left out) as far as `depth` generations (1\u201350; all of them when left out). Each slot has its Ahnentafel number `n` (the person is 1, a father 2n, a mother 2n+1) and `generation`; someone who is an ancestor along two lines appears at each number, `repeatOf` naming the first. `people` holds each person once; `deeper` says the tree goes further back than `depth`. A 400 before the member said who they are and with no `ref`.",
+    query: [
+      {
+        name: "ref",
+        description: "Whose ancestors (default: the member's own place in the tree)."
+      },
+      {
+        name: "depth",
+        type: "integer",
+        minimum: 1,
+        maximum: 50,
+        description: "How many generations back (default: all)."
+      }
+    ],
+    querySchema: familyTreeAncestorsQuerySchema,
+    status: 200,
+    response: { description: "`{ rootRef, depth, generations, deeper, ancestors, people }`." },
+    errors: { 400: true, 404: true }
+  },
   people: {
     method: "get",
     path: "/family-tree/people",
@@ -26744,6 +26916,150 @@ var familyTreeOperations = defineOperations({
     status: 200,
     response: { description: "`{ id, did, matches }`." },
     errors: { 400: true, 404: true }
+  },
+  person: {
+    method: "get",
+    path: "/family-tree/people/{ref}",
+    scopes: ["people:family-tree"],
+    tag: "People",
+    summary: "One person in the tree",
+    description: "Their name, sex, birth and death (date and place), facts (each with the `id` an edit takes), parents, partners and children, whether the member added them, and the Contact they're linked to.",
+    pathParams: REF,
+    pathParamSchemas: REF_SCHEMA,
+    status: 200,
+    response: { description: "The person." },
+    errors: { 400: true, 404: true }
+  },
+  addPerson: {
+    method: "post",
+    path: "/family-tree/people",
+    scopes: ["people:family-tree"],
+    tag: "People",
+    summary: "Add a person to the tree",
+    description: `\`{ name, given?, surname?, sex? (M \xB7 F), birthDate?, birthPlace?, deathDate?, deathPlace? }\`; dates are \`YYYY\` or \`YYYY-MM-DD\`, and a death date or place means not living. They get a new ref (\`P\u2026\`); link them to parents or a partner next. ${RECEIPT}`,
+    body: addFamilyTreePersonInputSchema,
+    status: 201,
+    response: { description: "The receipt." },
+    errors: { 400: true, 404: true }
+  },
+  editPerson: {
+    method: "patch",
+    path: "/family-tree/people/{ref}",
+    scopes: ["people:family-tree"],
+    tag: "People",
+    summary: "Change a person in the tree",
+    description: `Any of the add's fields; \`null\` clears one. A change to the death decides again whether they're living. ${RECEIPT}`,
+    pathParams: REF,
+    pathParamSchemas: REF_SCHEMA,
+    body: editFamilyTreePersonInputSchema,
+    status: 200,
+    response: { description: "The receipt." },
+    errors: { 400: true, 404: true }
+  },
+  removePerson: {
+    method: "delete",
+    path: "/family-tree/people/{ref}",
+    scopes: ["people:family-tree"],
+    tag: "People",
+    summary: "Take a person out of the tree",
+    description: `Out of every family they're in; their link to a Contact comes back with an Undo. ${RECEIPT}`,
+    pathParams: REF,
+    pathParamSchemas: REF_SCHEMA,
+    status: 200,
+    response: { description: "The receipt (`person`: null)." },
+    errors: { 400: true, 404: true }
+  },
+  addFact: {
+    method: "post",
+    path: "/family-tree/people/{ref}/facts",
+    scopes: ["people:family-tree"],
+    tag: "People",
+    summary: "Add a fact to a person",
+    description: `\`{ type, date?, place?, value? }\`: an occupation, a residence, a baptism, a note (the type is a word of the member's own). The date is as written (\`ABT 1720\`). ${RECEIPT}`,
+    pathParams: REF,
+    pathParamSchemas: REF_SCHEMA,
+    body: addFamilyTreeFactInputSchema,
+    status: 201,
+    response: { description: "The receipt." },
+    errors: { 400: true, 404: true }
+  },
+  editFact: {
+    method: "patch",
+    path: "/family-tree/people/{ref}/facts/{factId}",
+    scopes: ["people:family-tree"],
+    tag: "People",
+    summary: "Change a fact",
+    description: `Any of \`type\`, \`date\`, \`place\`, \`value\`; \`null\` clears one. ${RECEIPT}`,
+    pathParams: FACT,
+    pathParamSchemas: FACT_SCHEMA,
+    body: editFamilyTreeFactInputSchema,
+    status: 200,
+    response: { description: "The receipt." },
+    errors: { 400: true, 404: true }
+  },
+  removeFact: {
+    method: "delete",
+    path: "/family-tree/people/{ref}/facts/{factId}",
+    scopes: ["people:family-tree"],
+    tag: "People",
+    summary: "Remove a fact",
+    description: RECEIPT,
+    pathParams: FACT,
+    pathParamSchemas: FACT_SCHEMA,
+    status: 200,
+    response: { description: "The receipt." },
+    errors: { 400: true, 404: true }
+  },
+  link: {
+    method: "post",
+    path: "/family-tree/links",
+    scopes: ["people:family-tree"],
+    tag: "People",
+    summary: "Link parent and child, or partners",
+    description: `\`{ kind: "parent", parent, child }\` (a child has at most two parents: a third is a 409) or \`{ kind: "partner", a, b }\`. ${RECEIPT}`,
+    body: familyTreeLinkInputSchema,
+    status: 200,
+    response: { description: "The receipt." },
+    errors: { 400: true, 404: true, 409: true },
+    operationId: "family_tree_link"
+  },
+  unlink: {
+    method: "post",
+    path: "/family-tree/unlink",
+    scopes: ["people:family-tree"],
+    tag: "People",
+    summary: "Unlink parent and child, or partners",
+    description: `The link's body. A child with siblings keeps them with the other parent; partners with children together are a 409 (unlink a parent first). ${RECEIPT}`,
+    body: familyTreeLinkInputSchema,
+    status: 200,
+    response: { description: "The receipt." },
+    errors: { 400: true, 404: true, 409: true },
+    operationId: "family_tree_unlink"
+  },
+  edits: {
+    method: "get",
+    path: "/family-tree/edits",
+    scopes: ["people:family-tree"],
+    tag: "People",
+    summary: "The member's edits to the tree",
+    description: "Oldest first, each `{ id, kind, line, at, applied, reason }`. The edits are an overlay replayed over every import: one the current file has no room for (its person or fact isn't in it, or it no longer fits) is `applied: false` with the `reason`, kept, and applies again when a later file brings its person back.",
+    status: 200,
+    response: { description: "`{ edits }`." },
+    errors: { 404: true }
+  },
+  undo: {
+    method: "post",
+    path: "/family-tree/edits/{id}/undo",
+    scopes: ["people:family-tree"],
+    tag: "People",
+    summary: "Undo an edit to the tree",
+    description: "The receipt's Undo: the edit leaves the overlay and the tree is replayed without it. Returns `{ undone, changes, skipped }`; `skipped` lists the edits that leaned on it (a fact on a person it added) and no longer apply. A POST, so it doesn't wait on a confirmation the way a delete does.",
+    pathParams: { id: "The edit's id (a receipt's `edit.id`)." },
+    pathParamSchemas: { id: ulidSchema },
+    status: 200,
+    response: { description: "`{ undone, changes, skipped }`." },
+    errors: { 400: true, 404: true },
+    operationId: "family_tree_undo"
   }
 });
 
@@ -27940,7 +28256,7 @@ var foodPatternsSchema = object({
 // ../../packages/schema/src/operations/food-log.ts
 var NO_MEMBER = "The key holds no health scope by name, or has no member behind it.";
 var HIDDEN2 = "No such meal, or it isn't the key's member's.";
-var RECEIPT = "The meal with its `receipt`: a headline with the kcal range, a confidence word (close \xB7 estimate \xB7 rough), a line per item with its source, and the Undo / Edit / Save as my meal calls.";
+var RECEIPT2 = "The meal with its `receipt`: a headline with the kcal range, a confidence word (close \xB7 estimate \xB7 rough), a line per item with its source, and the Undo / Edit / Save as my meal calls.";
 var ITEM = "Each item: `label` and one of `foodId` (from `GET /api/v1/foods/search`), `productId` or `recipeId`, with `grams`, `quantity` + `unit` (`2 boterham`, `1 el`) or `servings`; optional `gramsLow`/`gramsHigh` and `matchConfidence`. With no reference, an `estimate` `{kcal, proteinG, carbsG, fatG}` (a labelled guess). The numbers are computed: table \xD7 grams.";
 var meal = { id: "The meal's ULID." };
 var mealId = { id: ulidSchema };
@@ -27970,7 +28286,7 @@ var foodLogOperations = defineOperations({
     description: `Log what the member ate in one call: \`id\`, \`title\`, \`eatenAt\`, \`mealType\` (breakfast \xB7 lunch \xB7 dinner \xB7 snack \xB7 drink), optional \`portionNote\`, \`place\`, \`flags\`, \`capture\`, \`photoFileId\`, and \`items\`. ${ITEM} Always private to the member.`,
     body: createMealLogInputSchema,
     status: 201,
-    response: { description: RECEIPT },
+    response: { description: RECEIPT2 },
     errors: { 400: true, 403: NO_MEMBER },
     operationId: "food_log"
   },
@@ -27998,7 +28314,7 @@ var foodLogOperations = defineOperations({
     description: `Correct a meal: \`replace\` (\`[{itemId, item}]\`), \`remove\` (item ids) and \`add\` (items) add rows, never edit one; the meal's own fields update. ${ITEM}`,
     body: correctMealLogInputSchema,
     status: 200,
-    response: { description: RECEIPT },
+    response: { description: RECEIPT2 },
     errors: { 400: true, 404: HIDDEN2 },
     operationId: "food_correct"
   },
@@ -28025,7 +28341,7 @@ var foodLogOperations = defineOperations({
     summary: "Undo a meal's last correction",
     description: "Take back the latest correction: the items it replaced or removed are current again.",
     status: 200,
-    response: { description: RECEIPT },
+    response: { description: RECEIPT2 },
     errors: { 400: true, 404: HIDDEN2 }
   },
   saveMeal: {
@@ -33038,7 +33354,10 @@ var moneyNetWorthAccountSchema = object({
   currency: string2(),
   value: amount5,
   source: moneySnapshotSourceSchema,
-  month: moneyMonthSchema
+  month: moneyMonthSchema,
+  pensionSubtype: moneyPensionSubtypeSchema.nullable(),
+  lockedUntil: string2().nullable(),
+  locked: boolean2()
 });
 var moneyNetWorthUnknownSchema = moneyNetWorthAccountSchema.pick({
   accountId: true,
@@ -33053,6 +33372,8 @@ var moneyNetWorthSchema = object({
   total: amount5,
   have: amount5,
   owe: amount5,
+  liquid: amount5,
+  locked: amount5,
   points: array(moneyNetWorthPointSchema),
   accounts: array(moneyNetWorthAccountSchema),
   complete: boolean2(),
@@ -33263,7 +33584,7 @@ var moneyOperations = defineOperations({
     scopes: ["finance:write"],
     tag: "Money",
     summary: "Open a money account",
-    description: 'Open an account: `id`, `title`, optional `kind` (current \xB7 savings \xB7 credit_card \xB7 cash \xB7 voucher \xB7 loan \xB7 investment \xB7 pension \xB7 asset_manual), `holder`, `iban` (stored only masked and hashed), `currency`, `openingBalance` (a decimal string), `includeInBudget`, `includeInNetWorth` and `visibility`. An account is the household\'s (`visibility: space`) or "Only me" (`owner`, the default for a new one); another member never sees an Only me account or anything on it.',
+    description: 'Open an account: `id`, `title`, optional `kind` (current \xB7 savings \xB7 credit_card \xB7 cash \xB7 voucher \xB7 loan \xB7 investment \xB7 pension \xB7 asset_manual), the `pensionSubtype` of a pension (group_insurance \xB7 pension_savings_fund \xB7 pension_savings_insurance \xB7 vapz; on another kind a 400), `lockedUntil` (YYYY-MM-DD, any kind), `holder`, `iban` (stored only masked and hashed), `currency`, `openingBalance` (a decimal string), `includeInBudget` (always off for a pension, which never counts toward the budget), `includeInNetWorth` and `visibility`. An account is the household\'s (`visibility: space`) or "Only me" (`owner`, the default for a new one); another member never sees an Only me account or anything on it.',
     body: createMoneyAccountInputSchema,
     status: 201,
     response: { description: "The account." },
@@ -33338,7 +33659,7 @@ var moneyOperations = defineOperations({
     scopes: ["finance:write"],
     tag: "Money",
     summary: "Update a money account",
-    description: "Rename it, change its kind, IBAN, opening balance, what it counts towards, or who sees it. `balance` with `balanceAt` (a day, read as its end, or a moment) states what it held then: the anchor net worth counts from, back and forward through the ledger, for a bank whose export has no running balance. The two go together; a day ahead, or an account a bank link keeps, is a 400.",
+    description: "Rename it, change its kind (an investment account moved to `pension` keeps its balance and ledger; moved off `pension`, its `pensionSubtype` is cleared), its `pensionSubtype` or `lockedUntil` (null clears), IBAN, opening balance, what it counts towards, or who sees it. `balance` with `balanceAt` (a day, read as its end, or a moment) states what it held then: the anchor net worth counts from, back and forward through the ledger, for a bank whose export has no running balance. The two go together; a day ahead, or an account a bank link keeps, is a 400, and so is a body that sets nothing.",
     pathParams: { id: "The account's ULID." },
     pathParamSchemas: { id: ulidSchema },
     body: updateMoneyAccountInputSchema,
@@ -33858,7 +34179,7 @@ var moneyOperations = defineOperations({
     scopes: ["finance:read"],
     tag: "Money",
     summary: "Get net worth and its monthly line",
-    description: "Net worth for the accounts that count in it (`includeInNetWorth`): `total`, `have` and `owe` this month, `points` (one per month, oldest first, the current month last; `total` null before any account had a value) and `accounts` (biggest first, each with its `value`, `source` \u2014 balance, ledger or manual \u2014 and the `month` that value is from). A loan or a credit card always counts as owed. This month follows each account's balance, carried forward by what was booked after `balanceAt`; the months before an account was first read are worked back from its ledger; a value set by hand carries on until the next one. An account whose ledger came from a bank but has no balance yet (an export with no running balance) is never counted as 0: it is listed under `unknown` and left out of the total, and `complete` is false. `scope`: `all` (default), `space` or `owner`; `months` 2\u201360 (12 by default).",
+    description: "Net worth for the accounts that count in it (`includeInNetWorth`): `total`, `have` and `owe` this month, `liquid` and `locked` (they add up to `total`; locked is a pension, or an account whose `lockedUntil` day is ahead, never a debt), `points` (one per month, oldest first, the current month last; `total` null before any account had a value) and `accounts` (biggest first, each with its `value`, `source` \u2014 balance, ledger or manual \u2014 and the `month` that value is from). A loan or a credit card always counts as owed. This month follows each account's balance, carried forward by what was booked after `balanceAt`; the months before an account was first read are worked back from its ledger; a value set by hand carries on until the next one. An account whose ledger came from a bank but has no balance yet (an export with no running balance) is never counted as 0: it is listed under `unknown` and left out of the total, and `complete` is false. `scope`: `all` (default), `space` or `owner`; `months` 2\u201360 (12 by default).",
     query: [
       { name: "scope", description: "all, space or owner." },
       { name: "months", description: "How many months the line covers (2\u201360, default 12)." }
@@ -34566,12 +34887,12 @@ var periodOperations = defineOperations({
 var placePointSchema = tuple([number2().finite(), number2().finite()]);
 var placeOutlineSchema = array(placePointSchema).min(3).max(200);
 var placeKindSchema = _enum2(placeKindValues);
-var placeSchema = createSelectSchema(places, {
+var placeSchema2 = createSelectSchema(places, {
   outline: placeOutlineSchema.nullable(),
   kind: string2().default("room"),
   gardenFeatureId: string2().nullable().default(null)
 });
-var placeViewSchema = placeSchema.extend({
+var placeViewSchema = placeSchema2.extend({
   title: string2(),
   parentId: string2().nullable().default(null),
   createdAt: exports_coerce.date(),
@@ -36009,7 +36330,8 @@ var projectOperations = defineOperations({
 var occurrenceViewSchema = occurrenceSchema.extend({
   title: string2(),
   templateKind: _enum2(["task", "habit", "routine"]),
-  measurementType: habitMeasurementTypeSchema.nullable()
+  measurementType: habitMeasurementTypeSchema.nullable(),
+  allDay: boolean2().optional()
 });
 var todayResponseSchema = object({
   from: exports_coerce.date(),
@@ -48608,7 +48930,78 @@ function goalSavedSource(goal) {
   return "counted toward it";
 }
 
+// src/global-flags.ts
+var GLOBAL_FLAGS = [
+  { name: "json", type: "boolean", description: "Emit JSON (automatic when stdout is piped)." },
+  { name: "quiet", type: "boolean", description: "Suppress human output (errors still report)." },
+  { name: "verbose", type: "boolean", description: "Extra diagnostics on stderr." },
+  {
+    name: "api-key",
+    type: "string",
+    description: "API key; overrides DO_API_KEY and the config file."
+  },
+  {
+    name: "url",
+    type: "string",
+    description: "API origin; overrides DO_API_URL and the config file."
+  },
+  { name: "help", type: "boolean", description: "Show help for the command." },
+  { name: "version", type: "boolean", description: "Print the CLI version." },
+  {
+    name: "data",
+    type: "string",
+    description: `JSON object body for create/update (e.g. --data '{"title":"Buy milk"}').`
+  },
+  {
+    name: "allow-destructive",
+    type: "boolean",
+    description: "Permit a destructive verb (delete/revoke/remove-member). Off by default \u2014 a guardrail for autonomous agents."
+  },
+  {
+    name: "dry-run",
+    type: "boolean",
+    description: "Preview a create/update/delete/archive (prints before/after) without writing \u2014 for agent-driven cleanup."
+  }
+];
+
 // src/commands/money.ts
+function refuseUnknownFlags(flags, own) {
+  const known = new Set([...own, ...GLOBAL_FLAGS.map((f) => f.name)]);
+  const unknown = Object.keys(flags).filter((name) => !known.has(name));
+  if (unknown.length > 0) {
+    throw usageError(`unknown flag ${unknown.map((n) => `--${n}`).join(", ")} (takes ${own.map((n) => `--${n}`).join(", ")}; see \`do help\`)`);
+  }
+}
+var ACCOUNT_KIND_FLAGS = [
+  {
+    name: "kind",
+    type: "string",
+    description: "current \xB7 savings \xB7 credit_card \xB7 cash \xB7 voucher \xB7 loan \xB7 investment \xB7 pension \xB7 asset_manual."
+  },
+  {
+    name: "subtype",
+    type: "string",
+    description: "A pension's kind: group_insurance \xB7 pension_savings_fund \xB7 pension_savings_insurance \xB7 vapz (`none` clears it)."
+  },
+  {
+    name: "locked-until",
+    type: "string",
+    description: "YYYY-MM-DD until which it can't be taken out (`none` clears it)."
+  }
+];
+function accountKindFields(flags) {
+  const out = {};
+  const kind = flagString(flags, "kind");
+  const subtype = flagString(flags, "subtype");
+  const lockedUntil = flagString(flags, "locked-until");
+  if (kind !== undefined)
+    out.kind = kind;
+  if (subtype !== undefined)
+    out.pensionSubtype = subtype === "none" ? null : subtype;
+  if (lockedUntil !== undefined)
+    out.lockedUntil = lockedUntil === "none" ? null : lockedUntil;
+  return out;
+}
 function renderDedupe(data) {
   const r = data;
   const lines = r.pairs.map((p) => `${p.bookedOn}  ${p.amount.padStart(10)}  ${p.description ?? p.counterpartyName ?? ""}  keep ${p.keepId}  twin ${p.twinId} (${p.twinBookedOn})${p.ambiguous ? "  ambiguous: sort by hand" : ""}`);
@@ -48692,13 +49085,17 @@ var commands31 = [
     path: ["money", "account-add"],
     summary: "Open a money account (Only me unless --data says visibility: space).",
     args: [],
-    flags: [{ name: "data", type: "string", description: "CreateMoneyAccountInput JSON." }],
+    flags: [
+      { name: "data", type: "string", description: "CreateMoneyAccountInput JSON." },
+      ...ACCOUNT_KIND_FLAGS
+    ],
     returns: "MoneyAccountView",
-    notes: `. \`do money account-add --data '{"title":"Joint","kind":"current","holder":"joint","visibility":"space"}'\`. An IBAN is stored only masked and hashed.`,
+    notes: `. \`do money account-add --data '{"title":"Joint","kind":"current","holder":"joint","visibility":"space"}'\`. An IBAN is stored only masked and hashed. A pension: \`--kind pension --subtype group_insurance --locked-until 2055-01-01\` (a subtype on another kind is a 400).`,
     run: async ({ flags, requireClient }) => {
       const body = parseInput(createMoneyAccountInputSchema, {
         id: ulid3(),
-        ...readDataFlag(flags)
+        ...readDataFlag(flags),
+        ...accountKindFields(flags)
       });
       return {
         data: await requireClient().post(pathOf(moneyOperations.createAccount), body),
@@ -48713,6 +49110,7 @@ var commands31 = [
     args: [{ name: "id", required: true, description: "Account ULID." }],
     flags: [
       { name: "data", type: "string", description: "UpdateMoneyAccountInput JSON." },
+      ...ACCOUNT_KIND_FLAGS,
       {
         name: "balance",
         type: "string",
@@ -48725,8 +49123,14 @@ var commands31 = [
       }
     ],
     returns: "MoneyAccountView",
-    notes: ". `--balance 1234.56 --balance-at 2026-10-27` anchors an account whose bank export has no running balance (ING's): net worth counts from it, back and forward through the ledger. A negative one rides as `--balance=-20`. A day ahead is refused, and so is an account a bank link keeps. `--data` takes the rest (title, kind, iban, includeInNetWorth, \u2026).",
+    notes: ". `--balance 1234.56 --balance-at 2026-10-27` anchors an account whose bank export has no running balance (ING's): net worth counts from it, back and forward through the ledger. A negative one rides as `--balance=-20`. A day ahead is refused, and so is an account a bank link keeps. `--kind pension --subtype vapz --locked-until 2055-01-01` refiles it (an investment account moved to pension keeps its balance and ledger; moved off pension, the subtype is cleared). `--data` takes the rest (title, iban, includeInNetWorth, \u2026). A flag it doesn't take, or nothing to change, is refused before anything is sent.",
     run: async ({ args, flags, io, requireClient }) => {
+      refuseUnknownFlags(flags, [
+        "data",
+        ...ACCOUNT_KIND_FLAGS.map((f) => f.name),
+        "balance",
+        "balance-at"
+      ]);
       const id = requireArg(args, 0, "account id");
       const balance = flagString(flags, "balance");
       const balanceAt = flagString(flags, "balance-at");
@@ -48735,6 +49139,7 @@ var commands31 = [
       }
       const body = parseInput(updateMoneyAccountInputSchema, {
         ...readDataFlag(flags),
+        ...accountKindFields(flags),
         ...balance !== undefined ? { balance, balanceAt: balanceAt ?? isoDay(io.now()) } : {}
       });
       return {
@@ -49531,7 +49936,7 @@ var commands31 = [
       }
     ],
     returns: "MoneyNetWorth",
-    notes: ". 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. `complete: false` when an account counts but its balance isn't known (a bank export with no running balance): it's listed under `unknown`, left out of the total, never counted as 0; `do money account-update <id> --balance \u2026 --balance-at \u2026` states it.",
+    notes: ". total, have and owe this month, and liquid beside locked (a pension, or an account locked until a day ahead; each account says `locked`, `lockedUntil` and a pension's `pensionSubtype`); 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. `complete: false` when an account counts but its balance isn't known (a bank export with no running balance): it's listed under `unknown`, left out of the total, never counted as 0; `do money account-update <id> --balance \u2026 --balance-at \u2026` states it.",
     run: async ({ flags, requireClient }) => ({
       data: await requireClient().get(pathOf(moneyOperations.netWorthRead), {
         query: { scope: flagString(flags, "scope"), months: flagString(flags, "months") }
@@ -50116,6 +50521,139 @@ var commands33 = [
 // src/commands/people.ts
 import { readFileSync as readFileSync9 } from "fs";
 import { basename as basename6 } from "path";
+
+// ../../packages/domain/src/family-tree.ts
+function lifeYears(p) {
+  if (p.birthYear && p.deathYear)
+    return `${p.birthYear}\u2013${p.deathYear}`;
+  if (p.deathYear)
+    return `\u2013${p.deathYear}`;
+  return p.birthYear ? String(p.birthYear) : "";
+}
+function greats(generation) {
+  if (generation < 3)
+    return "";
+  const n = generation - 2;
+  return n === 1 ? "great-" : `${n}\xD7 great-`;
+}
+function generationLabel(generation) {
+  if (generation === 0)
+    return "You";
+  if (generation === 1)
+    return "Parents";
+  const word = `${greats(generation)}grandparents`;
+  return word.charAt(0).toUpperCase() + word.slice(1);
+}
+function ancestorTitle(n) {
+  const generation = ahnentafelGeneration(n);
+  if (generation === 0)
+    return "You";
+  const male = n % 2 === 0;
+  if (generation === 1)
+    return male ? "Father" : "Mother";
+  const word = `${greats(generation)}grand${male ? "father" : "mother"}`;
+  return word.charAt(0).toUpperCase() + word.slice(1);
+}
+function pedigreeOutline(view) {
+  const people = new Map(view.people.map((p) => [p.ref, p]));
+  const slots = new Map(view.ancestors.map((a) => [a.n, a]));
+  const rows = [];
+  const visit = (n) => {
+    const slot = slots.get(n);
+    const person = slot ? people.get(slot.ref) : undefined;
+    if (!slot || !person)
+      return;
+    const parents = [2 * n, 2 * n + 1].filter((m) => slots.has(m));
+    rows.push({
+      n,
+      generation: slot.generation,
+      title: ancestorTitle(n),
+      person,
+      repeatOf: slot.repeatOf,
+      parents
+    });
+    for (const m of parents)
+      visit(m);
+  };
+  visit(1);
+  return rows;
+}
+function pedigreeText(view) {
+  const lines = pedigreeOutline(view).map((r) => {
+    const years = lifeYears(r.person);
+    const name = years ? `${r.person.name} (${years})` : r.person.name;
+    const again = r.repeatOf ? ` \xB7 also #${r.repeatOf}, line shown there` : "";
+    return `${"  ".repeat(r.generation)}${r.title} \xB7 ${name} \xB7 ${r.person.ref}${again}`;
+  });
+  const deepest = generationLabel(view.generations).toLowerCase();
+  const more = view.deeper ? " The tree goes further back: ask for a bigger depth." : "";
+  return [...lines, "", `${view.generations} generations back (to the ${deepest}).${more}`].join(`
+`);
+}
+
+// src/commands/people.ts
+var EDIT_NOTE = "Answers with a receipt: edit.id (for `do people tree undo`), the changes person by person, and the person after. Edits are kept over a new import.";
+var PERSON_FLAGS = [
+  { name: "given", type: "string", description: "First name(s)." },
+  { name: "surname", type: "string", description: "Surname." },
+  { name: "sex", type: "string", description: "M or F." },
+  { name: "born", type: "string", description: "Birth date: YYYY or YYYY-MM-DD." },
+  { name: "born-place", type: "string", description: "Where they were born." },
+  { name: "died", type: "string", description: "Death date: YYYY or YYYY-MM-DD." },
+  { name: "died-place", type: "string", description: "Where they died." }
+];
+var PERSON_FLAG_FIELDS = {
+  given: "given",
+  surname: "surname",
+  sex: "sex",
+  born: "birthDate",
+  "born-place": "birthPlace",
+  died: "deathDate",
+  "died-place": "deathPlace"
+};
+var FACT_FLAGS = [
+  { name: "date", type: "string", description: "The date as written (ABT 1720, 1801-03-02)." },
+  { name: "place", type: "string", description: "Where." },
+  { name: "value", type: "string", description: "The value or note (farmer, a line of text)." }
+];
+var CLEAR_FLAG = {
+  name: "clear",
+  type: "string",
+  description: "Fields to clear, comma-separated."
+};
+var FACT_ARGS = [
+  { name: "ref", required: true, description: "Their ref in the tree." },
+  { name: "factId", required: true, description: "The fact's id (OCCU-1, f-\u2026)." }
+];
+var LINK_ARGS = [
+  { name: "kind", required: true, description: "parent, child or partner." },
+  { name: "ref", required: true, description: "The person's ref." },
+  { name: "other", required: true, description: "Their parent's, child's or partner's ref." }
+];
+var pick2 = (flags, fields) => Object.fromEntries(Object.entries(fields).flatMap(([flag, field]) => {
+  const v = flagString(flags, flag);
+  return v === undefined ? [] : [[field, v]];
+}));
+var personFields = (flags) => pick2(flags, { name: "name", ...PERSON_FLAG_FIELDS });
+var factFields = (flags) => pick2(flags, { date: "date", place: "place", value: "value" });
+var clears = (flags) => Object.fromEntries((flagString(flags, "clear") ?? "").split(",").map((f) => f.trim()).filter(Boolean).map((f) => [f, null]));
+var factParams = (args) => ({
+  ref: parseInput(familyTreeRefSchema, requireArg(args, 0, "ref")),
+  factId: parseInput(familyTreeFactIdSchema, requireArg(args, 1, "fact id"))
+});
+function linkBody(args) {
+  const kind = requireArg(args, 0, "kind");
+  const ref = requireArg(args, 1, "ref");
+  const other = requireArg(args, 2, "other");
+  if (kind === "parent")
+    return parseInput(familyTreeLinkInputSchema, { kind, parent: other, child: ref });
+  if (kind === "child") {
+    return parseInput(familyTreeLinkInputSchema, { kind: "parent", parent: ref, child: other });
+  }
+  if (kind === "partner")
+    return parseInput(familyTreeLinkInputSchema, { kind, a: ref, b: other });
+  throw usageError("the kind is parent, child or partner");
+}
 var commands34 = [
   {
     spec: {
@@ -50471,6 +51009,34 @@ var commands34 = [
       };
     }
   },
+  {
+    spec: {
+      path: ["people", "tree", "ancestors"],
+      summary: "Your direct line back, as a text pedigree: as far as --depth, or all of it.",
+      args: [],
+      flags: [
+        {
+          name: "depth",
+          type: "string",
+          description: "How many generations back (1\u201350; default all)."
+        },
+        { name: "ref", type: "string", description: "Whose ancestors (default: you in the tree)." }
+      ],
+      scopes: [...familyTreeOperations.ancestors.scopes],
+      returns: "FamilyTreeAncestors",
+      notes: "Each line is who they are to you, the name, the years and their ref, indented by generation; father's line before mother's. --json gives the slots by Ahnentafel number (you 1, a father 2n, a mother 2n+1)."
+    },
+    run: async ({ flags, requireClient }) => {
+      const depth = flagString(flags, "depth");
+      const ref = flagString(flags, "ref");
+      const query = { ...depth ? { depth } : {}, ...ref ? { ref } : {} };
+      parseInput(familyTreeAncestorsQuerySchema, query);
+      return {
+        data: await requireClient().get(pathOf(familyTreeOperations.ancestors), { query }),
+        render: (data) => pedigreeText(data)
+      };
+    }
+  },
   {
     spec: {
       path: ["people", "tree", "list"],
@@ -50555,6 +51121,223 @@ var commands34 = [
         render: renderRecord
       };
     }
+  },
+  {
+    spec: {
+      path: ["people", "tree", "person"],
+      summary: "One person in your tree: facts (with their ids), parents, partners, children.",
+      args: [{ name: "ref", required: true, description: "Their ref in the tree (I12)." }],
+      flags: [],
+      scopes: [...familyTreeOperations.person.scopes],
+      returns: "FamilyTreePersonDetail"
+    },
+    run: async ({ args, requireClient }) => {
+      const ref = parseInput(familyTreeRefSchema, requireArg(args, 0, "ref"));
+      return {
+        data: await requireClient().get(pathOf(familyTreeOperations.person, { ref })),
+        render: renderRecord
+      };
+    }
+  },
+  {
+    spec: {
+      path: ["people", "tree", "person", "add"],
+      summary: "Add someone your tree is missing.",
+      args: [{ name: "name", required: true, description: "Their full name." }],
+      flags: PERSON_FLAGS,
+      scopes: [...familyTreeOperations.addPerson.scopes],
+      returns: "FamilyTreeEditReceipt",
+      notes: `${EDIT_NOTE} They get a new ref (P\u2026): link them next (\`do people tree link parent <child> <parent>\`).`
+    },
+    run: async ({ args, flags, requireClient }) => {
+      const body = parseInput(addFamilyTreePersonInputSchema, {
+        ...personFields(flags),
+        name: args.join(" ").trim() || requireArg(args, 0, "name")
+      });
+      return {
+        data: await requireClient().post(pathOf(familyTreeOperations.addPerson), body),
+        render: renderRecord
+      };
+    }
+  },
+  {
+    spec: {
+      path: ["people", "tree", "person", "edit"],
+      summary: "Change a person in your tree: name, sex, birth, death.",
+      args: [{ name: "ref", required: true, description: "Their ref in the tree." }],
+      flags: [
+        { name: "name", type: "string", description: "Their full name." },
+        ...PERSON_FLAGS,
+        CLEAR_FLAG
+      ],
+      scopes: [...familyTreeOperations.editPerson.scopes],
+      returns: "FamilyTreeEditReceipt",
+      notes: `${EDIT_NOTE} --clear takes field names (birthPlace,deathDate,\u2026).`
+    },
+    run: async ({ args, flags, requireClient }) => {
+      const ref = parseInput(familyTreeRefSchema, requireArg(args, 0, "ref"));
+      const body = parseInput(editFamilyTreePersonInputSchema, {
+        ...personFields(flags),
+        ...clears(flags),
+        ...readDataFlag(flags)
+      });
+      return {
+        data: await requireClient().patch(pathOf(familyTreeOperations.editPerson, { ref }), body),
+        render: renderRecord
+      };
+    }
+  },
+  {
+    spec: {
+      path: ["people", "tree", "person", "remove"],
+      summary: "Take a person out of your tree (and out of their families).",
+      args: [{ name: "ref", required: true, description: "Their ref in the tree." }],
+      flags: [],
+      scopes: [...familyTreeOperations.removePerson.scopes],
+      returns: "FamilyTreeEditReceipt",
+      notes: `${EDIT_NOTE} An agent's key waits for the member's yes, as every delete does.`
+    },
+    run: async ({ args, requireClient }) => {
+      const ref = parseInput(familyTreeRefSchema, requireArg(args, 0, "ref"));
+      return {
+        data: await requireClient().delete(pathOf(familyTreeOperations.removePerson, { ref })),
+        render: renderRecord
+      };
+    }
+  },
+  {
+    spec: {
+      path: ["people", "tree", "fact", "add"],
+      summary: "Add a fact to a person: an occupation, a residence, a note.",
+      args: [
+        { name: "ref", required: true, description: "Their ref in the tree." },
+        {
+          name: "type",
+          required: true,
+          description: "What kind (occupation, residence, note, \u2026)."
+        }
+      ],
+      flags: FACT_FLAGS,
+      scopes: [...familyTreeOperations.addFact.scopes],
+      returns: "FamilyTreeEditReceipt",
+      notes: EDIT_NOTE
+    },
+    run: async ({ args, flags, requireClient }) => {
+      const ref = parseInput(familyTreeRefSchema, requireArg(args, 0, "ref"));
+      const body = parseInput(addFamilyTreeFactInputSchema, {
+        type: requireArg(args, 1, "type"),
+        ...factFields(flags)
+      });
+      return {
+        data: await requireClient().post(pathOf(familyTreeOperations.addFact, { ref }), body),
+        render: renderRecord
+      };
+    }
+  },
+  {
+    spec: {
+      path: ["people", "tree", "fact", "edit"],
+      summary: "Change one of a person's facts.",
+      args: FACT_ARGS,
+      flags: [
+        { name: "type", type: "string", description: "What kind of fact." },
+        ...FACT_FLAGS,
+        CLEAR_FLAG
+      ],
+      scopes: [...familyTreeOperations.editFact.scopes],
+      returns: "FamilyTreeEditReceipt",
+      notes: `${EDIT_NOTE} --clear takes field names (date,place,value).`
+    },
+    run: async ({ args, flags, requireClient }) => {
+      const params = factParams(args);
+      const type = flagString(flags, "type");
+      const body = parseInput(editFamilyTreeFactInputSchema, {
+        ...type ? { type } : {},
+        ...factFields(flags),
+        ...clears(flags)
+      });
+      return {
+        data: await requireClient().patch(pathOf(familyTreeOperations.editFact, params), body),
+        render: renderRecord
+      };
+    }
+  },
+  {
+    spec: {
+      path: ["people", "tree", "fact", "remove"],
+      summary: "Remove one of a person's facts.",
+      args: FACT_ARGS,
+      flags: [],
+      scopes: [...familyTreeOperations.removeFact.scopes],
+      returns: "FamilyTreeEditReceipt",
+      notes: `${EDIT_NOTE} An agent's key waits for the member's yes, as every delete does.`
+    },
+    run: async ({ args, requireClient }) => {
+      return {
+        data: await requireClient().delete(pathOf(familyTreeOperations.removeFact, factParams(args))),
+        render: renderRecord
+      };
+    }
+  },
+  {
+    spec: {
+      path: ["people", "tree", "link"],
+      summary: "Link two people: give someone a parent or a child, or a partner.",
+      args: LINK_ARGS,
+      flags: [],
+      scopes: [...familyTreeOperations.link.scopes],
+      returns: "FamilyTreeEditReceipt",
+      notes: `${EDIT_NOTE} A child has at most two parents.`
+    },
+    run: async ({ args, requireClient }) => ({
+      data: await requireClient().post(pathOf(familyTreeOperations.link), linkBody(args)),
+      render: renderRecord
+    })
+  },
+  {
+    spec: {
+      path: ["people", "tree", "unlink"],
+      summary: "Undo a parent, child or partner link.",
+      args: LINK_ARGS,
+      flags: [],
+      scopes: [...familyTreeOperations.unlink.scopes],
+      returns: "FamilyTreeEditReceipt",
+      notes: `${EDIT_NOTE} Partners with children together: unlink a parent first.`
+    },
+    run: async ({ args, requireClient }) => ({
+      data: await requireClient().post(pathOf(familyTreeOperations.unlink), linkBody(args)),
+      render: renderRecord
+    })
+  },
+  {
+    spec: {
+      path: ["people", "tree", "edits"],
+      summary: "Your edits to the tree, oldest first; the ones the current file has no room for are flagged.",
+      args: [],
+      flags: [],
+      scopes: [...familyTreeOperations.edits.scopes],
+      returns: "FamilyTreeEdits",
+      notes: "Edits are kept over every new import: one whose person isn't in the new file is applied: false with its reason, and applies again when a later file has them."
+    },
+    run: async ({ requireClient }) => ({
+      data: await requireClient().get(pathOf(familyTreeOperations.edits)),
+      render: renderRecord
+    })
+  },
+  {
+    spec: {
+      path: ["people", "tree", "undo"],
+      summary: "Undo one edit to the tree, by the id its receipt gave.",
+      args: [{ name: "editId", required: true, description: "The receipt's edit.id." }],
+      flags: [],
+      scopes: [...familyTreeOperations.undo.scopes],
+      returns: "FamilyTreeUndoResult",
+      notes: "skipped lists the edits that leaned on it (a fact on a person it added)."
+    },
+    run: async ({ args, requireClient }) => ({
+      data: await requireClient().post(pathOf(familyTreeOperations.undo, { id: requireArg(args, 0, "edit id") }), {}),
+      render: renderRecord
+    })
   }
 ];
 
@@ -53398,38 +54181,6 @@ var FEATURE_COMMANDS = [
 // src/registry.ts
 var COMMANDS = FEATURE_COMMANDS;
 var COMMAND_SPECS = COMMANDS.map((c) => c.spec);
-var GLOBAL_FLAGS = [
-  { name: "json", type: "boolean", description: "Emit JSON (automatic when stdout is piped)." },
-  { name: "quiet", type: "boolean", description: "Suppress human output (errors still report)." },
-  { name: "verbose", type: "boolean", description: "Extra diagnostics on stderr." },
-  {
-    name: "api-key",
-    type: "string",
-    description: "API key; overrides DO_API_KEY and the config file."
-  },
-  {
-    name: "url",
-    type: "string",
-    description: "API origin; overrides DO_API_URL and the config file."
-  },
-  { name: "help", type: "boolean", description: "Show help for the command." },
-  { name: "version", type: "boolean", description: "Print the CLI version." },
-  {
-    name: "data",
-    type: "string",
-    description: `JSON object body for create/update (e.g. --data '{"title":"Buy milk"}').`
-  },
-  {
-    name: "allow-destructive",
-    type: "boolean",
-    description: "Permit a destructive verb (delete/revoke/remove-member). Off by default \u2014 a guardrail for autonomous agents."
-  },
-  {
-    name: "dry-run",
-    type: "boolean",
-    description: "Preview a create/update/delete/archive (prints before/after) without writing \u2014 for agent-driven cleanup."
-  }
-];
 function matchCommand(positionals) {
   for (const len of [4, 3, 2, 1]) {
     const candidate = positionals.slice(0, len);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robbeverhelst/do",
-  "version": "1.334.0",
+  "version": "1.336.0",
   "private": false,
   "description": "do — the agent-drivable CLI over the public /api/v1 surface",
   "homepage": "https://github.com/robbeverhelst/do/tree/main/apps/cli",