@bongos/core 1.21.18 → 1.21.20

package/modules/ideas/governor-docket.js

@@ -57,6 +57,37 @@ function rulesReading(settledThisMonth) {
   };
 }
 
+// Rules · Rules in force (task 1004527): each standing rule and how many
+// matters it settled this month. The project records one standing rule today,
+// the landing rule; a rule put to the council has nowhere to live yet (the
+// docket's standing_rules source says coming). Pure.
+const LANDING_RULE = 'Every filing lands in its goal without a vote.';
+function rulesFloor(settledThisMonth) {
+  const n = Number(settledThisMonth) || 0;
+  return {
+    count: '1',
+    line: `1 rule · settled ${n} this month`,
+    lines: [[LANDING_RULE, `settled ${n}`], ['A new rule put to the council is coming.', 'coming']],
+    hot: false,
+  };
+}
+// The Rules record: what the landing rule settled, month by month. Pure.
+function rulesHistory(months) {
+  return (months || []).filter((m) => Number(m.n) > 0).map((m) => ({
+    id: `landing:${m.month}`, title: `The landing rule settled ${m.n} ${Number(m.n) === 1 ? 'filing' : 'filings'}`,
+    at: `${m.month}-01T00:00:00.000Z`, outcome: 'without a vote',
+  }));
+}
+async function routedByMonth(months = 6) {
+  const { rows } = await api.pool.query(
+    `SELECT to_char(created_at, 'YYYY-MM') AS month, count(*)::int AS n FROM ideas_task_lineage
+      WHERE origin = 'route' AND created_at >= date_trunc('month', now()) - (($1::int - 1) * interval '1 month')
+      GROUP BY month ORDER BY month DESC`,
+    [months],
+  );
+  return rows;
+}
+
 // Filings the routing rule landed this month (origin 'route').
 async function countRoutedThisMonth() {
   const { rows } = await api.pool.query(
@@ -66,6 +97,12 @@ async function countRoutedThisMonth() {
   return rows[0] ? rows[0].n : 0;
 }
 
+// One read per docket request: the collector hands every read a per-request
+// `once(key, fn)` (docket.js buildDocket), so two floors that need the same rows
+// share one query. Without it (a direct call) the read simply runs.
+const shared = (once, key, fn) => (typeof once === 'function' ? once(key, fn) : fn());
+const routedFor = (once) => shared(once, 'ideas.routedThisMonth', () => countRoutedThisMonth());
+
 function contributeIdeasToDocket() {
   api.contribute(POINT, {
     source: 'blockers',
@@ -81,13 +118,17 @@ function contributeIdeasToDocket() {
   api.contribute(POINT, {
     reading: 'rules',
     gate: { anyBuilder: true },
-    read: async () => rulesReading(await countRoutedThisMonth()),
+    read: async (_ctx, { once } = {}) => rulesReading(await routedFor(once)),
   });
+  api.contribute(POINT, { floor: 'rules.in_force', gate: { anyBuilder: true }, read: async (_ctx, { once } = {}) => rulesFloor(await routedFor(once)) });
+  api.contribute(POINT, { history: 'rules', building: 'rules', gate: { anyBuilder: true }, read: async () => rulesHistory(await routedByMonth()) });
 }
 
 module.exports = {
   contributeIdeasToDocket,
   blockerDocketMatter,
   rulesReading,
+  rulesFloor,
+  rulesHistory,
   countRoutedThisMonth,
 };

package/modules/lifecycle/governor-docket.js

@@ -123,7 +123,192 @@ function promisesReading(criteria) {
   return { value: { kept, total }, figure: `${kept} of ${total} kept`, line: 'what the goals say they deliver', hot: false };
 }
 
+// ── floors and the record (task 1004527) ─────────────────────────────────────
+// Each is pure over rows the existing reads already return; the registration
+// below gives each the atom of the route that serves those rows (GET /goals,
+// GET /versions, GET /tasks and GET /public/recent-shipped are any builder's).
+
+const MAX_LINES = 4;
+const SHIPPED_LIMIT = 200;
+const MONTHS = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec'];
+function monthStart(now) { const d = new Date(now); return Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), 1); }
+function dayWord(at) { const d = new Date(at); return Number.isNaN(d.getTime()) ? '' : `${MONTHS[d.getUTCMonth()]} ${d.getUTCDate()}`; }
+function plural(n, one, many) { return `${n} ${n === 1 ? one : many}`; }
+function more(lines, total) { if (total > lines.length) lines.push([`and ${total - lines.length} more`, '']); return lines; }
+
+// Planning · Goals: each open goal with its promises kept of total.
+function goalsFloor(goals, criteria) {
+  const open = (goals || []).filter((g) => g.status === 'open');
+  const by = new Map();
+  for (const c of criteria || []) {
+    if (c.goal_id == null) continue;
+    const k = String(c.goal_id);
+    if (!by.has(k)) by.set(k, { kept: 0, total: 0 });
+    const e = by.get(k); e.total += 1; if (c.satisfied === true) e.kept += 1;
+  }
+  const lines = open.slice(0, MAX_LINES).map((g) => {
+    const e = by.get(String(g.id));
+    return [String(g.title), e ? `${e.kept} of ${e.total} kept` : 'no promises yet'];
+  });
+  return { count: String(open.length), line: open.length ? plural(open.length, 'goal open', 'goals open') : 'no goal open', lines: more(lines, open.length), hot: false };
+}
+
+// Planning · Priorities: the building version's open goals in their worked order.
+function prioritiesFloor(goals, versionId) {
+  const mine = (goals || []).filter((g) => g.status === 'open' && (!versionId || g.version_id === versionId));
+  if (!mine.length) return { count: '', line: 'no goal in the order yet', lines: [['No open goal is ordered in the version building now.', '']], hot: false };
+  const top = mine.slice(0, 3).map((g, i) => `${i + 1} ${g.title}`).join(' · ');
+  return { count: '', line: 'the order goals are worked in', lines: [[top, versionId ? `version ${versionId}` : ''], [`${plural(mine.length, 'goal is', 'goals are')} in the order.`, '']], hot: false };
+}
+
+// Planning · Versions: what is building, and the last that shipped.
+function versionsFloor(versions, goals) {
+  const all = versions || [];
+  const building = all.filter((v) => v.status === 'building');
+  const shipped = all.filter((v) => v.status === 'shipped' && v.shipped_at).sort((a, b) => Date.parse(b.shipped_at) - Date.parse(a.shipped_at));
+  const goalsIn = (id) => (goals || []).filter((g) => g.version_id === id && g.status !== 'archived').length;
+  const lines = building.slice(0, MAX_LINES).map((v) => [`${v.name || v.id} is building.`, plural(goalsIn(v.id), 'goal', 'goals')]);
+  if (shipped[0]) lines.push([`${shipped[0].name || shipped[0].id} shipped.`, dayWord(shipped[0].shipped_at)]);
+  const head = building[0];
+  return {
+    count: '',
+    line: head ? `${head.name || head.id} building · ${plural(goalsIn(head.id), 'goal', 'goals')} in it` : 'no version building',
+    lines: lines.length ? lines : [['No version is recorded yet.', '']],
+    hot: false,
+  };
+}
+
+// Review · Signed off: promises a tester has marked kept, newest first.
+function signedOffFloor(criteria, now) {
+  const done = (criteria || []).filter((c) => c.satisfied === true && c.checked_at).sort((a, b) => Date.parse(b.checked_at) - Date.parse(a.checked_at));
+  const month = done.filter((c) => Date.parse(c.checked_at) >= monthStart(now)).length;
+  return {
+    count: String(month),
+    line: done.length ? `${month} signed off this month` : 'nothing signed off yet',
+    lines: done.slice(0, MAX_LINES).map((c) => [String(c.criterion_md), dayWord(c.checked_at)]),
+    hot: false,
+  };
+}
+
+// Release · Live this month: shipped work, newest first.
+function liveMonthFloor(shipped, now) {
+  const month = (shipped || []).filter((t) => t.shipped_at && Date.parse(t.shipped_at) >= monthStart(now));
+  return {
+    count: String(month.length),
+    line: month.length ? `${plural(month.length, 'piece', 'pieces')} of work went live` : 'nothing went live yet this month',
+    lines: more(month.slice(0, MAX_LINES).map((t) => [String(t.title), dayWord(t.shipped_at)]), month.length),
+    hot: false,
+  };
+}
+
+// Release · Held back: approved work that cannot go live until it catches up.
+function heldBackFloor(confirmed) {
+  const held = (confirmed || []).filter((t) => t.needs_rebase === true);
+  return {
+    count: String(held.length),
+    line: held.length ? `${plural(held.length, 'piece', 'pieces')} held` : 'nothing held',
+    lines: more(held.slice(0, MAX_LINES).map((t) => [String(t.title), 'must catch up first']), held.length),
+    hot: false,
+  };
+}
+
+// People · Newcomers: newcomer tasks being built, and the ones waiting.
+function newcomersFloor(active, ready) {
+  const building = (active || []).filter((t) => t.newcomer_friendly === true);
+  const waiting = (ready || []).filter((t) => t.newcomer_friendly === true);
+  return {
+    count: String(building.length),
+    line: `${plural(building.length, 'newcomer task', 'newcomer tasks')} being built`,
+    lines: [...building.slice(0, MAX_LINES - 1).map((t) => [String(t.title), 'being built']), [`${plural(waiting.length, 'newcomer task is', 'newcomer tasks are')} ready to claim.`, '']],
+    hot: false,
+  };
+}
+
+// The record: sign-offs, releases, goals achieved. Pure.
+function signoffHistory(criteria) {
+  return (criteria || []).filter((c) => c.satisfied === true && c.checked_at)
+    .map((c) => ({ id: c.id, title: String(c.criterion_md), at: c.checked_at, outcome: 'signed off' }));
+}
+function releaseHistory(shipped) {
+  return (shipped || []).filter((t) => t.shipped_at).map((t) => ({ id: t.id, title: String(t.title), at: t.shipped_at, outcome: 'live' }));
+}
+function goalHistory(goals) {
+  return (goals || []).filter((g) => g.status === 'achieved' && g.updated_at)
+    .map((g) => ({ id: g.id, title: `${g.title} achieved`, at: g.updated_at, outcome: 'all promises kept' }));
+}
+
+// The criteria of the versions the open goals live in — one read per version,
+// bounded, through the same listCriteria the version page serves.
+async function criteriaFor(versionIds) {
+  const ids = [...new Set(versionIds.filter(Boolean))].slice(0, 6);
+  return (await Promise.all(ids.map((v) => doneWhen.listCriteria(v)))).flat();
+}
+
+// One read per docket request: the collector hands every read a per-request
+// `once(key, fn)` (docket.js buildDocket), so two floors that need the same rows
+// share one query. Without it (a direct call) the read simply runs.
+const shared = (once, key, fn) => (typeof once === 'function' ? once(key, fn) : fn());
+const openGoals = (once) => shared(once, 'lifecycle.openGoals', () => db.listGoals({ status: 'open' }));
+const confirmedTasks = (once) => shared(once, 'lifecycle.confirmedTasks', () => db.listTasks({ status: 'confirmed', limit: STUCK_LIMIT }));
+
+function contributeLifecycleFloors() {
+  const any = { anyBuilder: true };
+  api.contribute(POINT, {
+    floor: 'planning.goals', gate: any,
+    read: async (_ctx, { once } = {}) => {
+      const goals = await openGoals(once);
+      return goalsFloor(goals, await criteriaFor(goals.map((g) => g.version_id)));
+    },
+  });
+  api.contribute(POINT, {
+    floor: 'planning.priorities', gate: any,
+    read: async (_ctx, { once } = {}) => prioritiesFloor(await openGoals(once), await db.currentBuildingVersionId()),
+  });
+  api.contribute(POINT, {
+    floor: 'planning.versions', gate: any,
+    read: async () => versionsFloor(await db.listVersions(), await db.listGoals({})),
+  });
+  api.contribute(POINT, {
+    floor: 'review.signed_off', gate: any,
+    read: async (_ctx, { now } = {}) => {
+      const v = await db.currentBuildingVersionId();
+      return signedOffFloor(v ? await doneWhen.listCriteria(v) : [], now);
+    },
+  });
+  api.contribute(POINT, {
+    floor: 'release.live_month', gate: any,
+    read: async (_ctx, { now } = {}) => liveMonthFloor(await db.recentShippedTasks(SHIPPED_LIMIT, { days: 31 }), now),
+  });
+  api.contribute(POINT, {
+    floor: 'release.held_back', gate: any,
+    read: async (_ctx, { once } = {}) => heldBackFloor(await confirmedTasks(once)),
+  });
+  api.contribute(POINT, {
+    floor: 'people.newcomers', gate: any,
+    read: async () => {
+      const [active, ready] = await Promise.all([db.listTasks({ status: 'active', limit: STUCK_LIMIT }), db.listTasks({ status: 'ready', limit: 200 })]);
+      return newcomersFloor(active, ready);
+    },
+  });
+  api.contribute(POINT, {
+    history: 'signoffs', building: 'review', gate: any,
+    read: async () => {
+      const v = await db.currentBuildingVersionId();
+      return signoffHistory(v ? await doneWhen.listCriteria(v) : []);
+    },
+  });
+  api.contribute(POINT, {
+    history: 'releases', building: 'release', gate: any,
+    read: async () => releaseHistory(await db.recentShippedTasks(60, { days: 120 })),
+  });
+  api.contribute(POINT, {
+    history: 'goals', building: 'planning', gate: any,
+    read: async () => goalHistory(await db.listGoals({ status: 'achieved' })),
+  });
+}
+
 function contributeLifecycleToDocket() {
+  contributeLifecycleFloors();
   api.contribute(POINT, {
     source: 'override_requests',
     building: 'release',
@@ -162,10 +347,10 @@ function contributeLifecycleToDocket() {
   api.contribute(POINT, {
     reading: 'flow',
     gate: { anyBuilder: true },
-    read: async (_ctx, { now } = {}) => {
+    read: async (_ctx, { now, once } = {}) => {
       const [completed, confirmed] = await Promise.all([
         db.listTasks({ status: 'completed', limit: STUCK_LIMIT }),
-        db.listTasks({ status: 'confirmed', limit: STUCK_LIMIT }),
+        confirmedTasks(once),
       ]);
       return flowReading({ completed, confirmed }, now);
     },
@@ -189,4 +374,14 @@ module.exports = {
   joinRequestMatter,
   flowReading,
   promisesReading,
+  goalsFloor,
+  prioritiesFloor,
+  versionsFloor,
+  signedOffFloor,
+  liveMonthFloor,
+  heldBackFloor,
+  newcomersFloor,
+  signoffHistory,
+  releaseHistory,
+  goalHistory,
 };

package/modules/security/routes/reports.js

@@ -69,6 +69,21 @@ function contributeReportsToDocket() {
       return lists.flat().map(redteamDocketMatter);
     },
   });
+  // The Disputes record (task 1004527): every report that was ruled on, dated by
+  // its ruling (confirmed or fixed). Same atom as the list route it reads.
+  api.contribute('governor.docket', {
+    history: 'rulings',
+    building: 'disputes',
+    gate: { permission: 'security.report.adjudicate' },
+    read: async () => rulingHistory((await Promise.all(['confirmed', 'fixed'].map((status) => security.listVulnerabilityReports({ scope: 'all', status, limit: 60 })))).flat()),
+  });
+}
+
+const RULING_WORDS = Object.freeze({ confirmed: 'confirmed', fixed: 'fixed', disputed: 'disputed', wontfix: 'will not fix' });
+function rulingHistory(reports) {
+  return (reports || [])
+    .filter((r) => RULING_WORDS[r.status] && (r.fixed_at || r.confirmed_at))
+    .map((r) => ({ id: r.id, title: `Security report: ${r.title}`, at: r.fixed_at || r.confirmed_at, outcome: RULING_WORDS[r.status] }));
 }
 
 module.exports = function buildSecurityReportsRouter() {
@@ -302,3 +317,4 @@ module.exports = function buildSecurityReportsRouter() {
 };
 
 module.exports.redteamDocketMatter = redteamDocketMatter;
+module.exports.rulingHistory = rulingHistory;

package/modules/security/security.js

@@ -155,7 +155,7 @@ async function createVulnerabilityReport({
 //
 // `scope: 'own'` REQUIRES builderId; omitting it throws rather than silently
 // leaking every report. Optional `status` narrows either scope.
-async function listVulnerabilityReports({ scope = 'own', builderId = null, status = null } = {}) {
+async function listVulnerabilityReports({ scope = 'own', builderId = null, status = null, limit = null } = {}) {
   if (scope !== 'own' && scope !== 'all') {
     throw { code: 'INVALID_SCOPE', scope, allowed: ['own', 'all'] };
   }
@@ -176,7 +176,10 @@ async function listVulnerabilityReports({ scope = 'own', builderId = null, statu
     `SELECT ${VULN_COLUMNS} FROM vulnerability_reports` +
     (where.length ? ` WHERE ${where.join(' AND ')}` : '') +
     ` ORDER BY reported_at DESC, id DESC`;
-  const { rows } = await pool.query(sql, params);
+  // Bounded when the caller asks (the governor docket's record, task 1004527).
+  let tail = '';
+  if (Number.isInteger(limit) && limit > 0) { params.push(limit); tail = ` LIMIT $${params.length}`; }
+  const { rows } = await pool.query(sql + tail, params);
   return rows;
 }
 

package/modules/ui-design/kit/fixtures/government-constitution-rules.json

@@ -0,0 +1,184 @@
+{
+  "_": "GET /government/constitution as the street reads it for a drafted amendment (task 1004530): the board block and the who-decides-what table, resolved by modules/government/decision-rules.js resolveAll (Release already amended to a sitting; every other building as today). Regenerate from the resolver, never by hand.",
+  "board": {
+    "membership": "rank:metic+",
+    "pass_rule": "majority",
+    "window_minutes": 4320,
+    "close_early_on_full_turnout": true
+  },
+  "history": [],
+  "headcount": 6,
+  "decision_rules": {
+    "areas": [
+      {
+        "area": "charter",
+        "name": "Charter",
+        "decided_by": "board",
+        "rule": "majority",
+        "rule_words": "majority vote",
+        "who": "the board (metic and above (metic, archon))",
+        "as_today": true,
+        "sitting": false,
+        "gate": null,
+        "today": "the board, under the constitution in force",
+        "acts": [],
+        "set_by_item_id": null,
+        "updated_at": null
+      },
+      {
+        "area": "rules",
+        "name": "Rules",
+        "decided_by": "gate",
+        "rule": "decide",
+        "rule_words": "decides alone",
+        "who": "whoever may change the project settings",
+        "as_today": true,
+        "sitting": false,
+        "gate": "project.settings.manage",
+        "today": "whoever may change the project settings",
+        "acts": [],
+        "set_by_item_id": null,
+        "updated_at": null
+      },
+      {
+        "area": "disputes",
+        "name": "Disputes",
+        "decided_by": "gate",
+        "rule": "decide",
+        "rule_words": "decides alone",
+        "who": "whoever may judge reports",
+        "as_today": true,
+        "sitting": false,
+        "gate": "security.report.adjudicate",
+        "today": "whoever may judge reports",
+        "acts": [],
+        "set_by_item_id": null,
+        "updated_at": null
+      },
+      {
+        "area": "people",
+        "name": "People",
+        "decided_by": "gate",
+        "rule": "decide",
+        "rule_words": "decides alone",
+        "who": "whoever may manage ranks",
+        "as_today": true,
+        "sitting": false,
+        "gate": "government.manage",
+        "today": "whoever may manage ranks",
+        "acts": [
+          "POST /government/assignments",
+          "DELETE /government/assignments/:builderId/:rankKey"
+        ],
+        "set_by_item_id": null,
+        "updated_at": null
+      },
+      {
+        "area": "planning",
+        "name": "Planning",
+        "decided_by": "gate",
+        "rule": "decide",
+        "rule_words": "decides alone",
+        "who": "whoever may create goals",
+        "as_today": true,
+        "sitting": false,
+        "gate": "goal.create",
+        "today": "whoever may create goals",
+        "acts": [],
+        "set_by_item_id": null,
+        "updated_at": null
+      },
+      {
+        "area": "automation",
+        "name": "Automation",
+        "decided_by": "gate",
+        "rule": "decide",
+        "rule_words": "decides alone",
+        "who": "whoever may switch unattended building on and off",
+        "as_today": true,
+        "sitting": false,
+        "gate": "autonomy.fence.manage",
+        "today": "whoever may switch unattended building on and off",
+        "acts": [],
+        "set_by_item_id": null,
+        "updated_at": null
+      },
+      {
+        "area": "review",
+        "name": "Review",
+        "decided_by": "gate",
+        "rule": "decide",
+        "rule_words": "decides alone",
+        "who": "whoever may mark work as meeting its checks",
+        "as_today": true,
+        "sitting": false,
+        "gate": "criterion.satisfy",
+        "today": "whoever may mark work as meeting its checks",
+        "acts": [],
+        "set_by_item_id": null,
+        "updated_at": null
+      },
+      {
+        "area": "release",
+        "name": "Release",
+        "decided_by": "rank:archon",
+        "rule": "unanimous",
+        "rule_words": "everyone agrees",
+        "who": "exactly archon",
+        "as_today": false,
+        "sitting": true,
+        "gate": "core.pin.move",
+        "today": "whoever may put a release live",
+        "acts": [],
+        "set_by_item_id": "3",
+        "updated_at": null
+      },
+      {
+        "area": "treasury",
+        "name": "Treasury",
+        "decided_by": "gate",
+        "rule": "decide",
+        "rule_words": "decides alone",
+        "who": "whoever may set spending limits",
+        "as_today": true,
+        "sitting": false,
+        "gate": "builder.budget.set",
+        "today": "whoever may set spending limits",
+        "acts": [],
+        "set_by_item_id": null,
+        "updated_at": null
+      }
+    ],
+    "rules": [
+      {
+        "key": "decide",
+        "words": "decides alone"
+      },
+      {
+        "key": "first",
+        "words": "first yes wins"
+      },
+      {
+        "key": "consent",
+        "words": "passes unless someone objects"
+      },
+      {
+        "key": "majority",
+        "words": "majority vote"
+      },
+      {
+        "key": "unanimous",
+        "words": "everyone agrees"
+      },
+      {
+        "key": "signoff",
+        "words": "signed off by someone who did not build it"
+      },
+      {
+        "key": "vacant",
+        "words": "no one holds this yet"
+      }
+    ],
+    "changed_by": "a passed amendment only — POST /government/board/decision-rules files one"
+  }
+}

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.18",
+  "version": "1.21.20",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.21.18",
+      "version": "1.21.20",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.18",
+  "version": "1.21.20",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/release-notes.json

@@ -8864,5 +8864,17 @@
       "id": "1004555",
       "text": "Project setup no longer shows an \"Allow repo access\" button — if the site needs GitHub access it fetches it in a quick reload and brings you straight back to where you were."
     }
+  ],
+  "1.21.19": [
+    {
+      "id": "1004530",
+      "text": "Inside any building on the street, \"change how this works\" now drafts a real amendment. It shows how the building decides today crossed out, and the proposed change written in. You pick who decides and how from the project's o"
+    }
+  ],
+  "1.21.20": [
+    {
+      "id": "1004527",
+      "text": "Inside every Governor City building, the floors now show real numbers instead of \"not recorded yet\". The Charter reads each section from the rules in force. People shows who sits on the council, the testers, the ranks and newc"
+    }
   ]
 }

package/src/module-api.js

@@ -75,7 +75,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.21.18'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.21.20'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('discord'); log.info('mounted');