@cohortapp/agent-sdk 2.3.2 → 2.4.1

package/lib/mandate/derive.test.mjs

@@ -0,0 +1,224 @@
+/**
+ * lib/mandate/derive.test.mjs — the pillars model, derived at init from the
+ * charter and the role.
+ *
+ * This is the step that makes the inert PILLAR sections in an agent's
+ * `config/agent.json` load-bearing: charter clause → PILLAR → OBJECTIVE → GOAL,
+ * with a sensor bound to a capability the manifest says is actually REACHABLE.
+ *
+ * The negative cases matter more than the happy path here: an objective whose
+ * sensor cannot be reached must be proposed as a HUMAN measurement obligation
+ * with a recorded degradation, never bound to a capability that does not exist.
+ */
+
+"use strict";
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import { deriveMandate, toMandateBody, pickSensor, slug, firstClause } from "./derive.mjs";
+import { validateMandateBody, pillars, ancestry, provenanceOf } from "./model.mjs";
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+const CHARTER = [
+  { id: "cs_1", kind: "PILLAR", order: 1, title: "Revenue growth", body: "Own the revenue line end to end." },
+  { id: "cs_2", kind: "PILLAR", order: 2, title: "Customer retention", body: "Keep the customers we win." },
+  { id: "cs_9", kind: "PRINCIPLE", order: 9, title: "Be direct", body: "Say the hard thing early." },
+];
+
+/** A manifest where only the CRM read is actually reachable. */
+const ENTRIES = [
+  { id: "crm_list_deals", plane: "org", reachable: true },
+  { id: "crm_list_contacts", plane: "org", reachable: false },
+];
+/** The shape `lib/capability/inventory.buildInventory` actually returns. */
+const MANIFEST = { version: 1, entries: ENTRIES };
+
+// ---------------------------------------------------------------------------
+// Pure helpers
+// ---------------------------------------------------------------------------
+
+test("slug and firstClause are deterministic and bounded", () => {
+  assert.equal(slug("Revenue Growth!"), "revenue-growth");
+  assert.equal(slug("  Multiple   spaces  "), "multiple-spaces");
+  assert.equal(firstClause("Own the revenue line. And then some more."), "Own the revenue line.");
+  assert.ok(firstClause("x".repeat(500)).length <= 120);
+});
+
+test("pickSensor binds only to a REACHABLE capability", () => {
+  const reachable = new Set(["crm_list_deals"]);
+  const bound = pickSensor("pipeline coverage across open deals", reachable);
+  if (bound.capability) {
+    assert.equal(bound.source, "method");
+    assert.ok(reachable.has(bound.capability), "a bound sensor must name a reachable capability");
+  }
+
+  // Same text, nothing reachable: the family matched but no capability can be
+  // cited — that is a measurement DEBT, and it must be visible.
+  const unbound = pickSensor("pipeline coverage across open deals", new Set());
+  assert.equal(unbound.capability, null);
+  assert.equal(unbound.source, "human");
+});
+
+// ---------------------------------------------------------------------------
+// The derivation
+// ---------------------------------------------------------------------------
+
+test("charter PILLAR sections become PILLAR nodes carrying their charterSectionId", () => {
+  const r = deriveMandate({ charterSections: CHARTER, kpiCategories: [{ id: "pipeline", name: "Pipeline" }] });
+  const ps = pillars(r.objectives);
+  assert.equal(ps.length, 2, "only PILLAR/CAPABILITY sections become pillars — a PRINCIPLE is not an outcome");
+  assert.deepEqual(ps.map((p) => p.charterSectionId), ["cs_1", "cs_2"]);
+  assert.deepEqual(ps.map((p) => p.text), ["Revenue growth", "Customer retention"]);
+  for (const p of ps) {
+    assert.equal(p.parentKey, null);
+    assert.equal(p.state, "proposed", "nothing is adopted by derivation — a human adopts");
+    assert.equal(p.source.origin, "charter");
+  }
+});
+
+test("EVERYTHING derived is proposed — derivation can never adopt", () => {
+  const r = deriveMandate({
+    charterSections: CHARTER,
+    kpiCategories: [{ id: "pipeline", name: "Pipeline coverage", examples: ["pipeline_coverage_x"] }],
+    priorities: [{ id: "p1", title: "Land three lighthouse accounts" }],
+    manifest: MANIFEST,
+  });
+  assert.ok(r.objectives.length >= 4);
+  for (const o of r.objectives) {
+    assert.equal(o.state, "proposed", `"${o.key}" must be proposed, not ${o.state}`);
+    assert.ok(!o.adoptedById, "derivation must never stamp an adopter");
+  }
+  // And therefore nothing here can drive work: adoptedObjectives is empty.
+  const validation = validateMandateBody(r.objectives, { ownerMemberId: "mem_self" });
+  assert.equal(validation.errors.length, 0, `derived tree must be structurally valid: ${validation.errors.join("; ")}`);
+});
+
+test("the derived tree is structurally valid: every objective hangs off a pillar", () => {
+  const r = deriveMandate({
+    charterSections: CHARTER,
+    kpiCategories: [
+      { id: "pipeline", name: "Pipeline coverage", examples: ["pipeline_coverage_x"] },
+      { id: "churn", name: "Customer retention rate", examples: ["logo_retention_pct"] },
+    ],
+    manifest: MANIFEST,
+  });
+  const validation = validateMandateBody(r.objectives);
+  assert.equal(validation.ok, true, validation.errors.join("; "));
+
+  for (const o of r.objectives.filter((x) => x.kind !== "PILLAR")) {
+    assert.ok(o.parentKey, `"${o.key}" must have a parent`);
+    const chain = ancestry(r.objectives, o.key);
+    assert.ok(
+      chain.some((n) => n.kind === "PILLAR"),
+      `"${o.key}" must trace to a PILLAR — provenance is the whole point`
+    );
+  }
+});
+
+test("provenance walks objective → pillar → charter clause, offline", () => {
+  const r = deriveMandate({
+    charterSections: CHARTER,
+    kpiCategories: [{ id: "pipeline", name: "Pipeline coverage", examples: ["pipeline_coverage_x"] }],
+    manifest: MANIFEST,
+  });
+  const obj = r.objectives.find((o) => o.kind === "OBJECTIVE");
+  const prov = provenanceOf(r.objectives, obj.key);
+  assert.ok(prov.pillar, "an objective must resolve to a pillar");
+  assert.match(prov.clause, /^cs_/, "and the pillar must carry the charter clause id");
+  assert.ok(prov.chain.includes(obj.key));
+});
+
+test("an objective with no reachable sensor is a recorded DEGRADATION, not a silent human task", () => {
+  const r = deriveMandate({
+    charterSections: CHARTER,
+    // A KPI category nothing in the manifest can measure.
+    kpiCategories: [{ id: "brand-sentiment", name: "Brand sentiment", examples: ["nps_score"] }],
+    manifest: MANIFEST,
+  });
+  const obj = r.objectives.find((o) => o.key === "brand-sentiment");
+  assert.ok(obj);
+  assert.notEqual(obj.sensor && obj.sensor.source, "method");
+  assert.ok(
+    r.degradations.some((d) => d.kind === "no_reachable_sensor" && d.key === "brand-sentiment"),
+    `expected a no_reachable_sensor degradation; got ${JSON.stringify(r.degradations)}`
+  );
+});
+
+test("an empty charter is reported, not silently accepted", () => {
+  const r = deriveMandate({ charterSections: [], kpiCategories: [] });
+  assert.ok(r.degradations.some((d) => d.kind === "no_charter_pillars"));
+  assert.ok(r.degradations.some((d) => d.kind === "no_kpi_categories"));
+  assert.equal(r.objectives.length, 0);
+});
+
+test("derivation is deterministic — same inputs, byte-identical tree", () => {
+  const input = {
+    charterSections: CHARTER,
+    kpiCategories: [{ id: "pipeline", name: "Pipeline coverage", examples: ["pipeline_coverage_x"] }],
+    priorities: [{ id: "p1", title: "Land three lighthouse accounts" }],
+    manifest: MANIFEST,
+  };
+  assert.equal(JSON.stringify(deriveMandate(input)), JSON.stringify(deriveMandate(input)));
+});
+
+test("duplicate titles never collide into one key", () => {
+  const r = deriveMandate({
+    charterSections: [
+      { id: "cs_1", kind: "PILLAR", order: 1, title: "Growth", body: "Growth" },
+      { id: "cs_2", kind: "PILLAR", order: 2, title: "Growth", body: "Growth again" },
+    ],
+  });
+  const keys = r.objectives.map((o) => o.key);
+  assert.equal(new Set(keys).size, keys.length, `keys must be unique; got ${keys.join(",")}`);
+});
+
+test("overrides let a human set the real target without re-deriving", () => {
+  const r = deriveMandate({
+    charterSections: CHARTER,
+    kpiCategories: [{ id: "pipeline", name: "Pipeline coverage", examples: ["pipeline_coverage_x"] }],
+    manifest: MANIFEST,
+    overrides: { pipeline: { target: 3.5, tolerance: 0.2, cadence: "monthly", direction: "up" } },
+  });
+  const obj = r.objectives.find((o) => o.key === "pipeline");
+  assert.equal(obj.target, 3.5);
+  assert.equal(obj.tolerance, 0.2);
+  assert.equal(obj.cadence, "monthly");
+});
+
+test("toMandateBody produces the shape the cache and compiler consume", () => {
+  const r = deriveMandate({ charterSections: CHARTER, kpiCategories: [{ id: "pipeline", name: "Pipeline" }] });
+  const body = toMandateBody({ memberId: "mem_self", objectives: r.objectives });
+  assert.equal(body.memberId, "mem_self");
+  assert.ok(Array.isArray(body.objectives));
+  assert.equal(typeof body.budgetCentsPerPeriod, "number");
+  assert.ok(Array.isArray(body.reactsTo));
+  // And it must round-trip through the validator the loop uses.
+  assert.equal(validateMandateBody(body).ok, true);
+});
+
+test("a bare ENTRY ARRAY manifest is tolerated, not a crash", () => {
+  // `[].entries` is Array.prototype.entries — a function. Walking it naively
+  // threw "function is not iterable" and took the whole derivation with it.
+  const fromObject = deriveMandate({
+    charterSections: CHARTER,
+    kpiCategories: [{ id: "pipeline", name: "Pipeline coverage", examples: ["pipeline_coverage_x"] }],
+    manifest: MANIFEST,
+  });
+  const fromArray = deriveMandate({
+    charterSections: CHARTER,
+    kpiCategories: [{ id: "pipeline", name: "Pipeline coverage", examples: ["pipeline_coverage_x"] }],
+    manifest: ENTRIES,
+  });
+  assert.deepEqual(fromArray.objectives, fromObject.objectives);
+});
+
+test("toMandateBody tolerates junk without throwing", () => {
+  const body = toMandateBody({});
+  assert.equal(body.memberId, null);
+  assert.deepEqual(body.objectives, []);
+  assert.equal(validateMandateBody(body).ok, true);
+});

package/lib/mandate/model.mjs

@@ -0,0 +1,352 @@
+/**
+ * lib/mandate/model.mjs — the operating-pillar spine, as data: validation,
+ * tree navigation, and the anti-Goodhart law.
+ *
+ * The spine is ONE self-referencing tree (the shape `lib/mandate/derive.mjs`
+ * emits and `lib/mandate/cache.mjs` persists as `body.objectives`):
+ *
+ *   PILLAR      a standing area of accountability — a charter clause / control
+ *               tower. Carries `charterSectionId`, so everything under it is
+ *               provenance-linked to the org's own words.
+ *     OBJECTIVE what we are moving inside that pillar this period.
+ *       GOAL    the measurable, dated commitment — the KPI itself.
+ *
+ * This module deliberately does NOT derive, fetch or cache anything (that is
+ * derive.mjs / cache.mjs). It answers the three questions the goal loop needs:
+ *
+ *   1. is this tree structurally sound?            `validateMandateBody`
+ *   2. which nodes may legally drive work?         `adoptedObjectives`
+ *   3. why is this node here, and who said so?     `ancestry` / `provenanceOf`
+ *
+ * **The anti-Goodhart law lives here.** An agent may PROPOSE an objective and
+ * may REPORT a sample, but a node whose `adoptedById` is its own owner is
+ * excluded from `adoptedObjectives` and reported as an error: a seat cannot
+ * define, measure and be graded on the same number. hq enforces the same rule
+ * server-side in `mandate.adopt`; this is the client-side mirror so an offline
+ * agent cannot quietly grade itself either.
+ *
+ * PURE: no fs, no network, no clock. ESM.
+ *
+ * @module lib/mandate/model
+ */
+
+"use strict";
+
+/** The three tiers of the spine, outermost first. */
+export const KINDS = Object.freeze(["PILLAR", "OBJECTIVE", "GOAL"]);
+
+/** Lifecycle. Only `active` may drive work; everything else is inert. */
+export const STATES = Object.freeze(["proposed", "active", "at_risk", "met", "missed", "retired"]);
+
+/** Which way "good" points for a metric. */
+export const DIRECTIONS = Object.freeze(["up", "down", "hold", "band"]);
+
+/** Collaborator roles. Each routes to an EXISTING org primitive (see goals/collaborate.mjs). */
+export const ROLES = Object.freeze(["DOER", "CONTRIBUTOR", "REVIEWER", "APPROVER", "INFORMED"]);
+
+/** Where a KPI number came from. `llm` is advisory and can never create work. */
+export const SENSOR_SOURCES = Object.freeze(["method", "human", "llm"]);
+
+/** Kinds that carry a number and can therefore be measured. */
+export const MEASURABLE_KINDS = Object.freeze(["OBJECTIVE", "GOAL"]);
+
+/** Which parents each kind may legally hang from (`null` = may be a root). */
+const LEGAL_PARENTS = Object.freeze({
+  PILLAR: [null],
+  OBJECTIVE: ["PILLAR", null],
+  GOAL: ["OBJECTIVE", "PILLAR"],
+});
+
+// ---------------------------------------------------------------------------
+// Accessors — tolerate every shape the mandate arrives in
+// ---------------------------------------------------------------------------
+
+/**
+ * Pull the objective list out of whatever the caller had to hand: a cache
+ * record (`{body:{objectives}}`), a bare body (`{objectives}`), or an array.
+ * Never throws; an unrecognised shape yields `[]`.
+ * @param {object|object[]} source
+ * @returns {object[]}
+ */
+export function objectivesOf(source) {
+  if (Array.isArray(source)) return source.filter(Boolean);
+  if (!source || typeof source !== "object") return [];
+  if (Array.isArray(source.objectives)) return source.objectives.filter(Boolean);
+  if (source.body && Array.isArray(source.body.objectives)) return source.body.objectives.filter(Boolean);
+  return [];
+}
+
+/** The seat the mandate belongs to, from a record or a body. */
+export function memberIdOf(source) {
+  if (!source || typeof source !== "object") return null;
+  return source.memberId || (source.body && source.body.memberId) || null;
+}
+
+/** Index objectives by key. @returns {Map<string,object>} */
+export function indexByKey(objectives) {
+  const m = new Map();
+  for (const o of objectivesOf(objectives)) if (o && o.key) m.set(o.key, o);
+  return m;
+}
+
+// ---------------------------------------------------------------------------
+// Validation — fail-closed, mirrors lib/archetype.validateProfile
+// ---------------------------------------------------------------------------
+
+/**
+ * Validate the mandate tree. Returns EVERY problem found and never throws: a
+ * partly-broken mandate must degrade to "the valid subset drives work", not to
+ * a crashed daemon. The loop refuses to admit work against any key in
+ * `badKeys`.
+ *
+ * @param {object|object[]} source  cache record, body, or objective array
+ * @param {object} [opts] @param {string} [opts.ownerMemberId] the seat itself
+ * @returns {{ok:boolean, errors:string[], warnings:string[], badKeys:string[]}}
+ */
+export function validateMandateBody(source, opts = {}) {
+  const list = objectivesOf(source);
+  const owner = opts.ownerMemberId || memberIdOf(source) || null;
+  const errors = [];
+  const warnings = [];
+  const badKeys = new Set();
+
+  const byKey = new Map();
+  for (const o of list) {
+    if (!o.key) {
+      errors.push("objective with no key");
+      continue;
+    }
+    if (byKey.has(o.key)) {
+      errors.push(`duplicate key "${o.key}"`);
+      badKeys.add(o.key);
+      continue;
+    }
+    byKey.set(o.key, o);
+  }
+
+  for (const o of list) {
+    if (!o.key) continue;
+    const at = `"${o.key}"`;
+    const kind = String(o.kind || "").toUpperCase();
+
+    if (!KINDS.includes(kind)) {
+      errors.push(`${at}: unknown kind "${o.kind}"`);
+      badKeys.add(o.key);
+    }
+    if (!STATES.includes(String(o.state))) {
+      errors.push(`${at}: unknown state "${o.state}"`);
+      badKeys.add(o.key);
+    }
+    if (o.direction != null && !DIRECTIONS.includes(String(o.direction))) {
+      errors.push(`${at}: unknown direction "${o.direction}"`);
+      badKeys.add(o.key);
+    }
+
+    // Parentage.
+    const legal = LEGAL_PARENTS[kind] || [];
+    if (o.parentKey) {
+      const parent = byKey.get(o.parentKey);
+      if (!parent) {
+        errors.push(`${at}: parent "${o.parentKey}" not found`);
+        badKeys.add(o.key);
+      } else if (!legal.includes(String(parent.kind || "").toUpperCase())) {
+        errors.push(`${at}: a ${kind} may not hang from a ${parent.kind}`);
+        badKeys.add(o.key);
+      }
+    } else if (!legal.includes(null)) {
+      errors.push(`${at}: a ${kind} requires a parent (${legal.filter(Boolean).join("|")})`);
+      badKeys.add(o.key);
+    }
+
+    // Measurability of an ACTIVE node.
+    if (MEASURABLE_KINDS.includes(kind) && o.state === "active") {
+      if (!o.metric) {
+        errors.push(`${at}: active ${kind} has no metric`);
+        badKeys.add(o.key);
+      }
+      // `Number(null)` is 0, so a null target would otherwise read as a legal
+      // target of zero — the exact class of silent coercion this codebase keeps
+      // getting bitten by. Require the value to be present AND finite.
+      if (o.target == null || o.target === "" || !Number.isFinite(Number(o.target))) {
+        errors.push(`${at}: active ${kind} has no numeric target`);
+        badKeys.add(o.key);
+      }
+      if (!o.cadence) warnings.push(`${at}: active ${kind} has no measure cadence — it will never come due`);
+      if (!o.sensor || !o.sensor.capability) {
+        warnings.push(`${at}: active ${kind} has no method sensor — measurement is a human obligation`);
+      } else if (!SENSOR_SOURCES.includes(String(o.sensor.source))) {
+        errors.push(`${at}: unknown sensor source "${o.sensor.source}"`);
+        badKeys.add(o.key);
+      }
+    }
+
+    // Adoption. THE anti-Goodhart law.
+    if (o.state === "active") {
+      if (o.adoptedById && owner && o.adoptedById === owner) {
+        errors.push(
+          `${at}: self-adopted — adoptedById equals the owning seat (${owner}). A seat cannot define, measure and be graded on the same number.`
+        );
+        badKeys.add(o.key);
+      } else if (!o.adoptedById) {
+        warnings.push(`${at}: active but the snapshot carries no adoptedById — adoption is unverifiable locally`);
+      }
+    }
+
+    for (const c of collaboratorsOf(o)) {
+      if (!ROLES.includes(c.role)) warnings.push(`${at}: unknown collaborator role "${c.role}"`);
+    }
+  }
+
+  // Cycles.
+  for (const o of list) {
+    if (!o.key) continue;
+    const walked = new Set();
+    let cur = o;
+    while (cur && cur.parentKey) {
+      if (walked.has(cur.key)) {
+        errors.push(`cycle in the objective tree at "${o.key}"`);
+        badKeys.add(o.key);
+        break;
+      }
+      walked.add(cur.key);
+      cur = byKey.get(cur.parentKey);
+    }
+  }
+
+  return { ok: errors.length === 0, errors, warnings, badKeys: [...badKeys] };
+}
+
+/** Normalise an objective's collaborators to `[{memberId, role}]`. Pure. */
+export function collaboratorsOf(objective) {
+  const raw = (objective && objective.collaborators) || [];
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const c of raw) {
+    if (!c) continue;
+    const memberId = typeof c === "string" ? c : c.memberId || c.member_id || c.id;
+    if (!memberId) continue;
+    const role = String((typeof c === "object" && (c.role || c.kind)) || "CONTRIBUTOR").toUpperCase();
+    out.push({ memberId: String(memberId), role });
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Tree navigation
+// ---------------------------------------------------------------------------
+
+/**
+ * Nest a flat list into roots → children. Orphans (an unresolvable `parentKey`)
+ * surface as roots so nothing is silently dropped.
+ * @param {object|object[]} source @returns {object[]}
+ */
+export function buildTree(source) {
+  const list = objectivesOf(source).map((o) => ({ ...o, children: [] }));
+  const byKey = new Map(list.map((o) => [o.key, o]));
+  const roots = [];
+  for (const o of list) {
+    const parent = o.parentKey ? byKey.get(o.parentKey) : null;
+    if (parent) parent.children.push(o);
+    else roots.push(o);
+  }
+  return roots;
+}
+
+/**
+ * The provenance chain for a key: `[node, parent, …, pillar]`. This is the
+ * offline "why did the agent do that?" walk — it needs no network.
+ * @param {object|object[]} source @param {string} key @returns {object[]}
+ */
+export function ancestry(source, key) {
+  const byKey = indexByKey(source);
+  const out = [];
+  const guard = new Set();
+  let cur = byKey.get(key);
+  while (cur && !guard.has(cur.key)) {
+    guard.add(cur.key);
+    out.push(cur);
+    cur = cur.parentKey ? byKey.get(cur.parentKey) : null;
+  }
+  return out;
+}
+
+/** The PILLAR a key ultimately hangs from, or null. */
+export function pillarFor(source, key) {
+  const chain = ancestry(source, key);
+  for (let i = chain.length - 1; i >= 0; i--) {
+    if (String(chain[i].kind).toUpperCase() === "PILLAR") return chain[i];
+  }
+  return null;
+}
+
+/**
+ * The provenance block stamped onto every machine-created task and audit line.
+ * @param {object|object[]} source @param {string} key
+ * @returns {{chain:string[], pillar:string|null, clause:string|null, adoptedBy:string|null, origin:string|null}}
+ */
+export function provenanceOf(source, key) {
+  const chain = ancestry(source, key);
+  const self = chain[0] || null;
+  const pillar = pillarFor(source, key);
+  return {
+    chain: chain.map((n) => n.key),
+    pillar: pillar ? pillar.key : null,
+    clause: (pillar && pillar.charterSectionId) || (self && self.charterSectionId) || null,
+    adoptedBy: (self && self.adoptedById) || null,
+    origin: (self && self.source && self.source.origin) || null,
+  };
+}
+
+/** All PILLAR nodes, in input order. */
+export function pillars(source) {
+  return objectivesOf(source).filter((o) => String(o.kind).toUpperCase() === "PILLAR");
+}
+
+/**
+ * The objectives that may legally drive work: measurable, `active`, structurally
+ * valid, and NOT self-adopted. Everything else — including every `proposed`
+ * node — compiles no obligations and admits no backlog.
+ *
+ * @param {object|object[]} source
+ * @param {object} [opts] @param {string} [opts.ownerMemberId] @param {string[]} [opts.badKeys]
+ * @returns {object[]}
+ */
+export function adoptedObjectives(source, opts = {}) {
+  const owner = opts.ownerMemberId || memberIdOf(source) || null;
+  const bad = new Set(opts.badKeys || []);
+  return objectivesOf(source).filter((o) => {
+    if (!o || bad.has(o.key)) return false;
+    if (!MEASURABLE_KINDS.includes(String(o.kind).toUpperCase())) return false;
+    if (o.state !== "active") return false;
+    if (isSelfAdopted(o, owner)) return false;
+    return true;
+  });
+}
+
+/** True when a node was adopted by its own owning seat (the Goodhart hole). */
+export function isSelfAdopted(objective, ownerMemberId) {
+  if (!objective || !objective.adoptedById) return false;
+  const owner = ownerMemberId || objective.ownerMemberId || objective.memberId || null;
+  return !!owner && objective.adoptedById === owner;
+}
+
+export default {
+  KINDS,
+  STATES,
+  DIRECTIONS,
+  ROLES,
+  SENSOR_SOURCES,
+  MEASURABLE_KINDS,
+  objectivesOf,
+  memberIdOf,
+  indexByKey,
+  validateMandateBody,
+  collaboratorsOf,
+  buildTree,
+  ancestry,
+  pillarFor,
+  provenanceOf,
+  pillars,
+  adoptedObjectives,
+  isSelfAdopted,
+};