@bongos/core 1.21.113 → 1.21.115

package/modules/hall-ui/public/gov-living.js

@@ -0,0 +1,1002 @@
+// modules/hall-ui/public/gov-living.js — THE LIVING CITY's model: the government
+// that steers a project's AI, as data (task 1004685, the living-city prototype).
+//
+// WHAT THIS IS. city-draw.js draws the city from the docket and the goals; this
+// file is the layer under the prototype's next drawings, which make the city
+// "live and breathe". It reads every real governor feed (the harness snapshots
+// them in scripts/hall-preview/fixtures) and returns one model the visual phases
+// draw from. ALL OF IT IS REAL (task 1004717): the prototype overlay that once
+// stood in for Leads, laws, pots, presets, build-outs and the human rewrite of
+// each ask is deleted, so a real project's city is complete on its own reads. A
+// concept no table holds (a Lead's deputies, a committee's members) is not drawn,
+// and a matter with no stored ask keeps its own words.
+//
+//   livingModel({ docket, constitution, goals, rollups, blockers, fence, claims,
+//                 tasks, moving, sessions, learnings, cost, roster, me, laws, leads, presets,
+//                 treasury, counts, now })
+//     → { viewer, owner, strictness, buildings[9], districts[], city, myAgents, _sources }
+//
+//   countsOf(model, session) → { on_you, on_others, open, agents_at_work, moving }
+//     over the server's own counts (GET /government/counts, task 1004716) when read
+//     the ONE definition of every number the city, the street, the deck and the
+//     shell's Governing tally print (gov-feeds.js hands it to each of them);
+//     tests/hall_gov_counts.mjs renders each surface and holds them equal.
+//
+// Every input takes the route's own body or the array inside it, and every one
+// may be missing: a missing feed leaves its part of the model empty, never
+// invented. `now` is ms since the epoch, passed in (ages, today's spend).
+//
+// WHERE EACH FIELD COMES FROM. Each object carries `_sources`, mapping a field
+// (or a dotted sub-field, `counts.building`) to:
+//   'real'     copied from a live read (an unread feed leaves it empty, never invented);
+//   'derived'  computed here from live reads only, by a rule written in this file;
+//   'mixed'    holds objects that carry their own `_sources` (read those).
+// There is no other label. tests/hall_gov_living.mjs walks the whole model to
+// hold it to that, and proves an `overlay` passed in changes nothing.
+//
+// ACTIVITY (0..1). An agent at work is an ACTIVE CLAIM (GET /tasks/claimable
+// active_claims). A claim belongs to the building its work answers to:
+//   1. its task's goal (GET /tasks?status=active gives task → goal), through
+//      goalBuilding(): the maintenance goal → Release; "Working area N" → the
+//      AREA_BUILDING table; an Autobongos goal → Automation; else the goal's
+//      category (CATEGORY_BUILDING);
+//   2. failing that, the modules its claim touches (MODULE_BUILDING), by majority;
+//   3. failing both, it is traffic with no building (`city.traffic.unplaced`).
+// A building's activity is claims there / ACTIVITY_FULL (3 agents is a busy
+// building), capped at 1. A district's is the larger of its claims and its
+// rollup's `active` count over ACTIVITY_FULL, and at least RECENT_FLOOR when its
+// rollup moved within the last day. `lit` is how lit the windows are: a base glow,
+// plus activity, plus a lamp when something there needs a person.
+//
+// THE ASK FORMAT. askFormat(card) is the enforced shape of a question to a human
+// (one question of at most 12 words, 2-3 tap options each with a one-line result,
+// a recommendation and why, who it waits on, what happens if nobody answers);
+// slopScore(text) measures the run-on text it replaces. A card that fails the
+// format is REFUSED: the model keeps it, marks `format.ok: false`, and sets
+// `shown: null` so a board shows the refusal, never the slop.
+// THE SERVER HOLDS THE SAME RULES (task 1004703): modules/government/asks.js
+// checkAsk refuses a slop ask before it is stored, and a matter that carries a
+// stored ask hands it here as `ask`; that card is real (`ask_real`). A matter
+// with no stored ask has no card: it shows in its own words (`shown: null`).
+// tests/government_asks.mjs holds both copies to one verdict.
+//
+// THE TREASURY (task 1004712): GET /government/treasury says which goals have a
+// pot (a budget the Treasury's holder gave it), what each spent this month
+// (cost_log through the goal's tasks), what the reserve lent it, the reserve, and
+// the spend cap (off by default: no limit). A dry pot's borrow is a real docket
+// matter (treasury_spending:<id>) whose stored ask waits on the Treasury.
+//
+// THE LEADS (task 1004709): GET /government/leads says who leads each building
+// (appointed by a passed People matter) and who holds the owner seat an unseated
+// building falls to; every building's Lead, holder and charter come from it.
+// The same read carries `build_rights` (task 1004710): what each building's
+// holder may build out without a vote, decided on the server from the form of
+// government; this file holds no rule of its own.
+// A LEAD'S BUILD-OUTS (task 1004711): the same read carries each building's
+// `structure` — committee rooms, floors, annexes and districts on the record
+// (going up for a day, then built) and those waiting on a vote. A building's
+// construction is drawn from it (a live site at its real progress, a ghost whose
+// tally is its sitting's on the docket) and its committee rooms are its real ones.
+// WHO AN ASK WAITS ON IS REAL (task 1004705, the direction desk): the server
+// routes every docket matter to a seat (modules/government/routing.js — its
+// stored ask's seat, else its building's Lead or its board; an unseated building
+// falls to the owner) and the docket carries the answer as `route` with
+// `routed: true`. Then `needs_you` is the route's `yours`, `waits_on` is the
+// route's seat, and an ask nobody can answer (past its deadline, or on an empty
+// seat) is settled with its `nobody` line: it does what its "if nobody answers"
+// says and is on nobody's "to do". A docket that is not routed falls back to
+// the seat the real Leads resolve, else the docket's own per-viewer word.
+//
+// PURE. No DOM, no fetch, no clock (the test reads this file to hold it to that).
+
+(function (root) {
+  'use strict';
+
+  const R = 'real';
+  const D = 'derived';
+  // a field holding objects that carry their own _sources (read those instead)
+  const M = 'mixed';
+
+  // ---------- the nine buildings (the docket's vocabulary order) ----------
+  const BUILDING_KEYS = Object.freeze(['charter', 'rules', 'disputes', 'people', 'planning', 'automation', 'review', 'release', 'treasury']);
+  const BUILDING_NAMES = Object.freeze({
+    charter: 'Charter', rules: 'Rules', disputes: 'Disputes', people: 'People', planning: 'Planning',
+    automation: 'Automation', review: 'Review', release: 'Release', treasury: 'Treasury',
+  });
+
+  // ---------- where work answers to (the activity mapping) ----------
+  // A working area (goals.working_area, or "Working area N" in its title) → the
+  // building whose Lead it reports to.
+  const AREA_BUILDING = Object.freeze({
+    1: 'people', // project creation: founders and newcomers arrive
+    2: 'people', // accounts, management & community
+    3: 'planning', // human project management
+    4: 'release', // core distribution
+    5: 'release', // module distribution
+    6: 'review', // the role experiences, checked by people
+    7: 'charter', // government itself
+    8: 'treasury', // platform credit economy
+    9: 'planning', // analytics: the flow and promises readings
+    10: 'disputes', // security reports
+    11: 'rules',
+    12: 'treasury', // cost optimisation
+  });
+  const CATEGORY_BUILDING = Object.freeze({
+    government: 'charter', economics: 'treasury', security: 'disputes', modules: 'release',
+    'builders-hall': 'planning', 'user-experience': 'review',
+  });
+  const MODULE_BUILDING = Object.freeze({
+    government: 'charter', ideas: 'planning', lifecycle: 'planning', grading: 'review', 'copy-desk': 'review',
+    'ui-design': 'review', 'hall-ui': 'review', 'npm-release': 'release', provisioning: 'release',
+    economy: 'treasury', autonomy: 'automation', 'platform-identity': 'people', onboarding: 'people',
+    'builder-settings': 'people', security: 'disputes',
+  });
+  const ACTIVITY_FULL = 3;
+  const RECENT_FLOOR = 0.2;
+  const DAY_MS = 24 * 3600 * 1000;
+  const URGENT_MS = DAY_MS;
+
+  // ---------- small helpers ----------
+  const arr = (v, key) => (Array.isArray(v) ? v : v && Array.isArray(v[key]) ? v[key] : []);
+  const obj = (v) => (v && typeof v === 'object' && !Array.isArray(v) ? v : null);
+  const str = (v) => (v == null ? '' : String(v));
+  const clamp01 = (n) => Math.max(0, Math.min(1, Number(n) || 0));
+  const round2 = (n) => Math.round((Number(n) || 0) * 100) / 100;
+  const round3 = (n) => Math.round((Number(n) || 0) * 1000) / 1000;
+  const time = (iso) => { const t = iso ? Date.parse(iso) : NaN; return isFinite(t) ? t : null; };
+
+  // ---------- the ask format ----------
+  const ASK_RULES = Object.freeze({ question_words: 12, options_min: 2, options_max: 3, label_words: 4, line_words: 14, why_words: 20 });
+  const MARKUP = /\*\*|`|^#|\[[^\]]*\]\(|https?:\/\/|<\/?[a-z]/im;
+
+  function words(text) { return str(text).trim().split(/\s+/).filter(Boolean); }
+  // Sentences end at . ! ? followed by a space and a capital (or a digit, a quote,
+  // a bracket), or by the end; a version (1.20.82) or a decimal does not end one.
+  function sentences(text) {
+    const t = str(text).replace(/\s+/g, ' ').trim();
+    const out = [];
+    let start = 0;
+    for (let i = 0; i < t.length; i++) {
+      const ch = t[i];
+      if (ch !== '.' && ch !== '!' && ch !== '?') continue;
+      const next = t[i + 1];
+      if (next !== undefined && next !== ' ') continue;
+      const after = t[i + 2];
+      if (next === ' ' && after !== undefined && !/[A-Z0-9"'(*[]/.test(after)) continue;
+      out.push(t.slice(start, i + 1).trim());
+      start = i + 2;
+    }
+    if (start < t.length) out.push(t.slice(start).trim());
+    return out.filter((s) => /[A-Za-z0-9]/.test(s));
+  }
+
+  // askFormat(card) → { ok, errors: [{ field, rule, message }], question_words }
+  function askFormat(card) {
+    const errors = [];
+    const err = (field, rule, message) => errors.push({ field, rule, message });
+    const c = obj(card);
+    if (!c) {
+      err('card', 'missing', 'No human card: the ask is still in its raw form.');
+      return { ok: false, errors, question_words: 0 };
+    }
+    const q = str(c.question).trim();
+    const qWords = words(q).length;
+    if (!q) err('question', 'missing', 'Ask one question.');
+    else {
+      if (qWords > ASK_RULES.question_words) err('question', 'too_long', `The question is ${qWords} words; ${ASK_RULES.question_words} at most.`);
+      if (!/\?$/.test(q)) err('question', 'not_a_question', 'End the question with a question mark.');
+      if (sentences(q).length > 1 || /\n/.test(q)) err('question', 'more_than_one', 'Ask exactly one question.');
+      if (MARKUP.test(q)) err('question', 'markup', 'No markup or links in the question.');
+    }
+    const opts = Array.isArray(c.options) ? c.options : [];
+    if (opts.length < ASK_RULES.options_min || opts.length > ASK_RULES.options_max) {
+      err('options', 'count', `Offer ${ASK_RULES.options_min} or ${ASK_RULES.options_max} tap answers, not ${opts.length}.`);
+    }
+    const keys = new Set();
+    opts.forEach((o, i) => {
+      const f = `options[${i}]`;
+      if (!obj(o)) { err(f, 'missing', 'An answer needs a key, a label and a result.'); return; }
+      const k = str(o.key).trim();
+      if (!k) err(f, 'no_key', 'An answer needs a key.');
+      else if (keys.has(k)) err(f, 'duplicate', `Two answers share the key "${k}".`);
+      keys.add(k);
+      const lw = words(o.label).length;
+      if (!lw) err(f, 'no_label', 'An answer needs a label to tap.');
+      else if (lw > ASK_RULES.label_words) err(f, 'label_too_long', `"${str(o.label)}" is ${lw} words; a tap label is ${ASK_RULES.label_words} at most.`);
+      lineRule(f + '.result', o.result, 'Say in one line what this answer does.');
+    });
+    const rec = obj(c.recommend);
+    if (!rec) err('recommend', 'missing', 'Recommend an answer and say why.');
+    else {
+      if (!keys.has(str(rec.key))) err('recommend', 'unknown_key', 'Recommend one of the answers offered.');
+      const ww = words(rec.why).length;
+      if (!ww) err('recommend', 'no_why', 'Say why in one line.');
+      else if (ww > ASK_RULES.why_words || /\n/.test(str(rec.why))) err('recommend', 'why_too_long', `The why is ${ww} words; ${ASK_RULES.why_words} at most, one line.`);
+    }
+    if (!str(c.waits_on).trim()) err('waits_on', 'missing', 'Say who this waits on.');
+    lineRule('if_nobody_answers', c.if_nobody_answers, 'Say what happens if nobody answers.');
+    return { ok: errors.length === 0, errors, question_words: qWords };
+
+    function lineRule(field, text, missingMessage) {
+      const t = str(text).trim();
+      const n = words(t).length;
+      if (!n) err(field, 'missing', missingMessage);
+      else if (/\n/.test(t) || n > ASK_RULES.line_words) err(field, 'not_one_line', `${n} words; one line of ${ASK_RULES.line_words} at most.`);
+      else if (MARKUP.test(t)) err(field, 'markup', 'No markup or links.');
+    }
+  }
+
+  // slopScore(text) → how far a text is from something a person can answer at a
+  // glance. `slop` is true past any one threshold; `score` (0..1) ranks them.
+  const SLOP = Object.freeze({ words: 30, sentences: 2, longest: 20 });
+  function slopScore(text) {
+    const t = str(text);
+    const w = words(t).length;
+    const ss = sentences(t);
+    const longest = ss.reduce((m, s) => Math.max(m, words(s).length), 0);
+    const lines = t.trim() ? t.trim().split(/\n+/).length : 0;
+    const markup = (t.match(/\*\*|`+|^#+\s|\[[^\]]*\]\([^)]*\)|https?:\/\/\S+|^\s*[-*]\s/gm) || []).length;
+    const why = [];
+    if (w > SLOP.words) why.push(`${w} words`);
+    if (ss.length > SLOP.sentences) why.push(`${ss.length} sentences`);
+    if (longest > SLOP.longest) why.push(`a ${longest}-word sentence`);
+    if (markup) why.push(`${markup} bits of markup`);
+    const score = round3(Math.max(Math.min(1, w / 120), Math.min(1, Math.max(0, ss.length - 1) / 6), Math.min(1, longest / 50), Math.min(1, markup / 6)));
+    return { words: w, sentences: ss.length, longest_sentence: longest, lines, markup, score, slop: why.length > 0, why };
+  }
+
+  // ---------- people ----------
+  function peopleIndex(roster, docket) {
+    const byId = {};
+    arr(roster, 'builders').forEach((b) => {
+      if (b && b.id != null) byId[String(b.id)] = { id: String(b.id), login: str(b.github_login), name: str(b.display_name || b.github_login) };
+    });
+    arr(docket && docket.buildings).forEach((b) => arr(b && b.holders).forEach((h) => {
+      if (h && h.id != null && !byId[String(h.id)]) byId[String(h.id)] = { id: String(h.id), login: str(h.login), name: str(h.name || h.login) };
+    }));
+    return (id) => (id == null ? null : byId[String(id)] || { id: String(id), login: '', name: '' });
+  }
+
+  // ---------- where work answers to ----------
+  function goalBuilding(goal) {
+    const g = obj(goal);
+    if (!g) return null;
+    if (g.is_maintenance) return 'release';
+    const area = Number(g.working_area) || Number((/working area\s+(\d+)/i.exec(str(g.title)) || [])[1]) || null;
+    if (area && AREA_BUILDING[area]) return AREA_BUILDING[area];
+    if (/autobongos|unattended/i.test(str(g.title))) return 'automation';
+    const slug = g.category && g.category.slug;
+    return (slug && CATEGORY_BUILDING[slug]) || null;
+  }
+  function touchesBuilding(touches) {
+    const tally = {};
+    arr(touches).forEach((t) => {
+      const m = /^modules\/([^/]+)\//.exec(str(t));
+      const b = m && MODULE_BUILDING[m[1]];
+      if (b) tally[b] = (tally[b] || 0) + 1;
+    });
+    const best = Object.keys(tally).sort((a, b) => tally[b] - tally[a] || BUILDING_KEYS.indexOf(a) - BUILDING_KEYS.indexOf(b))[0];
+    return best || null;
+  }
+
+  // ---------- seats ----------
+  // A seat names who an ask waits on: 'owner', 'lead:<building>' (an unseated
+  // building falls to the owner), 'committee:<building>.<key>', 'board:<building>'.
+  function seatResolver(ctx) {
+    return function resolve(seat, building) {
+      const s = str(seat) || (building ? 'lead:' + building : 'owner');
+      let m;
+      // the owner seat's members: every one GET /government/leads names (none unread)
+      const ownerIds = ctx.ownerIds || [];
+      if (s === 'owner') return { seat: s, label: 'the owner', person: ctx.owner, members: ownerIds };
+      if ((m = /^lead:(\w+)$/.exec(s))) {
+        const lead = ctx.leads[m[1]];
+        if (lead && lead.person) return { seat: s, label: `the ${BUILDING_NAMES[m[1]] || m[1]} Lead`, person: lead.person, members: [lead.person.id] };
+        return { seat: s, label: 'the owner', person: ctx.owner, members: ownerIds, fell_to_owner: true };
+      }
+      if ((m = /^committee:(\w+)\.(\w+)$/.exec(s))) {
+        const lead = ctx.leads[m[1]];
+        const com = lead && lead.committees.find((c) => c.key === m[2]);
+        if (com) return { seat: s, label: `${com.name} (${BUILDING_NAMES[m[1]] || m[1]})`, person: lead.person, members: com.members.map((p) => p.id) };
+        return resolve('lead:' + m[1], m[1]);
+      }
+      if ((m = /^board:(\w+)$/.exec(s))) {
+        const holders = ctx.holders[m[1]] || [];
+        return { seat: s, label: 'the board', person: null, members: holders.map((p) => p.id) };
+      }
+      return { seat: s, label: s, person: null, members: [] };
+    };
+  }
+
+  // Who answers for a building, as GET /government/leads says: its Lead's seat, or
+  // the owner's when it is unseated (task 1004709). { seat, ids, fell_to_owner }
+  function answersOf(read, key) {
+    const b = arr(read.buildings).find((x) => x && x.building === key);
+    const a = b && obj(b.answers);
+    return a ? { seat: str(a.seat), ids: arr(a.builder_ids).map(str), fell_to_owner: !!a.fell_to_owner } : null;
+  }
+
+  // What a building's holder may build out without a vote (task 1004710). The
+  // SERVER decides it (modules/government/build-rights.js: the form of government
+  // and the building's own decision rule, never a Lead's charter) and GET
+  // /government/leads carries it per building; this only reads the answer, one
+  // capsule at a time. { form, form_name, holder, capsules: { key: { without_vote, why, by } } } or null.
+  const CAPSULE_KEYS = Object.freeze(['committee', 'floor', 'annex', 'district']);
+  function rightsShape(r) {
+    if (!obj(r) || !obj(r.capsules)) return null;
+    const capsules = {};
+    CAPSULE_KEYS.forEach((k) => {
+      const c = obj(r.capsules[k]) ? r.capsules[k] : null;
+      capsules[k] = { without_vote: !!(c && c.without_vote === true), why: str(c && c.why), ground: str(c && c.ground) };
+    });
+    return { form: str(r.form), form_name: str(r.form_name), holder: str(r.holder), capsules };
+  }
+  function rightsOf(read, key) {
+    const b = arr(read.buildings).find((x) => x && x.building === key);
+    return b ? rightsShape(b.build_rights) : null;
+  }
+
+  // ---------- one ask card ----------
+  const STATE_ORDER = Object.freeze({ needs: 1, moving: 2, settled: 3 });
+  function makeAsk(base, human, ctx, sources) {
+    const opened = time(base.opened_at);
+    const deadline = time(base.deadline);
+    const format = askFormat(human);
+    // the server's route (task 1004705), when the docket was routed
+    const served = ctx.routed ? obj(base.route) : null;
+    const route = served
+      ? { seat: str(served.seat), label: str(served.label), person: null, fell_to_owner: !!served.fell_to_owner, members: [] }
+      : ctx.resolveSeat(human && human.waits_on, base.building);
+    const nobody = served && obj(served.nobody) ? { why: str(served.nobody.why), outcome: served.nobody.outcome == null ? null : str(served.nobody.outcome) } : null;
+    // an ask nobody answers has done what its "if nobody answers" line says
+    const state = nobody ? 'settled' : STATE_ORDER[base.state] ? base.state : 'needs';
+    // Routed: the route's word. A matter the routed docket does not carry is
+    // nobody's here. Not routed: whether the viewer holds the seat the real Leads
+    // resolve (GET /government/leads read), else the docket's own per-viewer 'needs'.
+    const needsYou = state === 'needs' && !!ctx.viewerId && (served ? !!served.yours && ctx.routedFor === ctx.viewerId
+      : ctx.routed ? false
+        : (route.members.indexOf(ctx.viewerId) >= 0 || (!ctx.seated && !!base.from_docket)));
+    const rawText = str(base.raw_title) + (base.raw_detail ? '\n\n' + str(base.raw_detail) : '');
+    return {
+      id: str(base.id),
+      source: str(base.source),
+      building: base.building,
+      state,
+      urgent: state === 'needs' && deadline != null && ctx.now != null && deadline - ctx.now <= URGENT_MS,
+      opened_at: base.opened_at || null,
+      deadline: base.deadline || null,
+      age_days: opened != null && ctx.now != null ? Math.max(0, Math.floor((ctx.now - opened) / DAY_MS)) : null,
+      rule: base.rule || null,
+      ref: base.ref || null,
+      href: base.href || null,
+      acts: base.acts || [],
+      tally: base.tally || null,
+      raw: { title: str(base.raw_title), detail: str(base.raw_detail), slop: slopScore(rawText) },
+      human: human || null,
+      format,
+      shown: format.ok ? human : null,
+      waits_on: { seat: route.seat, label: route.label, person: route.person || null, fell_to_owner: !!route.fell_to_owner, real: !!served },
+      needs_you: needsYou,
+      nobody,
+      // the card's words are the agent's own stored ask (task 1004703)
+      ask_real: !!base.ask_real,
+      _sources: served ? Object.assign({}, sources, { state: D, waits_on: R, needs_you: D, nobody: R }) : Object.assign({}, sources, { nobody: D }),
+    };
+  }
+
+  // Needs-you first (needs that wait on the viewer's seat), then the rest that
+  // need a person, then moving, then settled; inside a tier the oldest first (an
+  // ask with no date after the dated ones), then by id.
+  function askTier(a) { return a.needs_you ? 0 : STATE_ORDER[a.state]; }
+  function compareAsks(a, b) {
+    const t = askTier(a) - askTier(b);
+    if (t) return t;
+    const ta = time(a.opened_at);
+    const tb = time(b.opened_at);
+    if (ta != null && tb != null && ta !== tb) return ta - tb;
+    if ((ta == null) !== (tb == null)) return ta == null ? 1 : -1;
+    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+  }
+
+  // ---------- the counts every surface prints (one source) ----------
+  // The city's plaque, door and line, the street's header and readings, the
+  // decision deck and the shell's Governing tally all print these numbers, so
+  // each is defined once, here, with one plain label:
+  //   on_you          asks that need a person and wait on one of the viewer's seats
+  //   on_others       asks that need a person and wait on someone else's seat
+  //   open            on_you + on_others: what the deck holds
+  //   agents_at_work  active claims, one sky pod each ("5 agents working": a tile is
+  //                   one number and two words, the owner's line rule)
+  //   moving          tasks being built or waiting to land (GET /moving: active +
+  //                   confirmed, owner 2026-10-08); never below agents_at_work,
+  //                   since every active claim holds an active task
+  // `session` { answered: ids answered or passed on in this page view, extra: asks
+  // a building added this visit } is the page's own state, applied the same way
+  // wherever the numbers are printed. A figure that could not be read is null,
+  // never 0: zero says nothing waits on you.
+  // THE LABELS. The main count is "to do" (the owner's word, 2026-10-09; task
+  // 1004701): after a number "24 to do", and a heading that names the count (the
+  // street's header, the tally) is countLabel(): "to do 24". A desk's own floor
+  // line keeps "needs you": that is one matter, not the count.
+  const COUNT_WORDS = Object.freeze({
+    on_you: Object.freeze(['to do', 'to do']),
+    on_others: Object.freeze(['waits on others', 'wait on others']),
+    open: Object.freeze(['to decide', 'to decide']),
+    agents_at_work: Object.freeze(['agent working', 'agents working']),
+    moving: Object.freeze(['moving', 'moving']),
+  });
+  const COUNT_LABELS = Object.freeze({ on_you: 'to do', on_others: 'on others', open: 'to decide', agents_at_work: 'agents working', moving: 'moving' });
+  function countWords(key, n) { const w = COUNT_WORDS[key]; return w ? w[n === 1 ? 0 : 1] : ''; }
+  function countLabel(key) { return COUNT_LABELS[key] || ''; }
+  function isOnYou(a) { return !!a && a.state === 'needs' && !!a.needs_you; }
+  function isOnOthers(a) { return !!a && a.state === 'needs' && !a.needs_you; }
+  // THE SERVER'S COUNTS (task 1004716): GET /government/counts answers all five
+  // numbers in one read, over the docket's own routes (modules/government/
+  // counts.js), and names the matters on you and on others. Read, they ARE the
+  // real part of every count: this page takes away what it answered this visit
+  // and adds only what no server read holds yet (an ask a building added this
+  // visit). Not read, the counts are made here from the docket and the feeds, as
+  // before; tests/government_counts.mjs holds the two equal.
+  function servedCounts(c) {
+    if (!obj(c) || !Array.isArray(c.yours) || !Array.isArray(c.others)) return null;
+    const n = (v) => (typeof v === 'number' && isFinite(v) && v >= 0 ? v : null);
+    return { yours: c.yours.map(str), others: c.others.map(str), agents_at_work: n(c.agents_at_work), moving: n(c.moving) };
+  }
+  function countsOf(model, session) {
+    const city = model && obj(model.city) ? model.city : null;
+    const s = obj(session) || {};
+    const gone = {};
+    arr(s.answered).forEach((id) => { gone[str(id)] = true; });
+    const seen = {};
+    const extra = {};
+    arr(s.extra).forEach((a) => { if (a && a.id != null) extra[str(a.id)] = true; });
+    const asks = (city ? arr(city.asks) : []).concat(arr(s.extra)).filter((a) => {
+      if (!a || a.id == null || seen[a.id] || gone[str(a.id)]) return false;
+      seen[a.id] = true;
+      return true;
+    });
+    const served = city && obj(city.served) ? city.served : null;
+    const t = city && obj(city.traffic) ? city.traffic : null;
+    if (served) {
+      const held = {};
+      served.yours.concat(served.others).forEach((id) => { held[id] = true; });
+      const own = asks.filter((a) => !held[str(a.id)] && extra[str(a.id)]);
+      const onYou = served.yours.filter((id) => !gone[id]).length + own.filter(isOnYou).length;
+      const onOthers = served.others.filter((id) => !gone[id]).length + own.filter(isOnOthers).length;
+      const src = R;
+      return {
+        on_you: onYou,
+        on_others: onOthers,
+        open: onYou + onOthers,
+        agents_at_work: served.agents_at_work != null ? served.agents_at_work : t && t.read ? Number(t.agents) || 0 : null,
+        moving: served.moving != null ? served.moving : t && t.moving != null ? Number(t.moving) : null,
+        _sources: { on_you: src, on_others: src, open: src, agents_at_work: R, moving: R },
+      };
+    }
+    // the asks stand on the docket: without it there is nothing honest to count
+    const read = !!city && !!city.docket_read;
+    const onYou = read ? asks.filter(isOnYou).length : null;
+    const onOthers = read ? asks.filter(isOnOthers).length : null;
+    return {
+      on_you: onYou,
+      on_others: onOthers,
+      open: read ? onYou + onOthers : null,
+      agents_at_work: t && t.read ? Number(t.agents) || 0 : null,
+      moving: t && t.moving != null ? Number(t.moving) : null,
+      _sources: { on_you: D, on_others: D, open: D, agents_at_work: D, moving: R },
+    };
+  }
+
+  // ---------- my agents ----------
+  function agentSettings(me) {
+    const m = obj(me) || {};
+    const out = [];
+    const inter = obj(m.interaction);
+    if (inter) {
+      arr(inter.fields).forEach((f) => {
+        const eff = obj(inter.effective) || {};
+        out.push({
+          key: str(f.field), label: str(f.label), group: 'How it talks to you', source: 'me/interaction',
+          options: arr(f.values).map((v) => v.value), default: f.default_value,
+          value: eff[f.field] !== undefined ? eff[f.field] : f.default_value, real: true,
+        });
+      });
+    }
+    const wand = obj(m.wandering);
+    if (wand) {
+      out.push({
+        key: 'wandering', label: 'How far agents wander', group: 'How your agents work', source: 'me/wandering',
+        options: arr(wand.levels).filter((l) => l.allowed !== false).map((l) => l.key), default: wand.default_key,
+        value: wand.effective_key || wand.default_key, real: true,
+      });
+    }
+    const alloc = obj(m.model_allocation);
+    if (alloc) {
+      arr(alloc.slots).forEach((s) => {
+        const eff = obj(alloc.effective) || {};
+        out.push({
+          key: 'model.' + str(s.slot), label: str(s.label), group: 'Which models run', source: 'me/model-allocation',
+          options: arr(alloc.allowed_tiers).slice(), default: s.code_default,
+          value: eff[s.slot] !== undefined ? eff[s.slot] : s.code_default, real: true,
+        });
+      });
+    }
+    // THE LOCKS (task 1004707): GET /me's `laws.locks` — what each law in force
+    // did to THIS viewer's settings, enforced by the server. The slice's effective
+    // value already obeys it; `from` is the viewer's own. A lock the server could
+    // not enforce (a setting no table holds yet) locks nothing here: the row would
+    // claim an enforcement that is not happening.
+    const realLockFor = {};
+    arr(obj(m.laws) && m.laws.locks).forEach((l) => { if (l && l.enforced && l.setting && !realLockFor[l.setting]) realLockFor[l.setting] = l; });
+    return out.map((s) => {
+      const real = realLockFor[s.key] || null;
+      // A CAP (task 1004714): a law that only caps a setting ({ setting, max })
+      // leaves every value up to the cap the viewer's to pick. The server names
+      // them (`allowed`, law-locks.js); the row offers those and is not locked. A
+      // cap that leaves one value or fewer is a lock in all but name.
+      const capAllowed = real && real.max !== undefined && Array.isArray(real.allowed)
+        ? s.options.filter((v) => real.allowed.some((a) => String(a) === String(v))) : null;
+      if (capAllowed && capAllowed.length > 1) {
+        return {
+          key: s.key, label: s.label, group: s.group, options: capAllowed, default: s.default,
+          value: real.from != null ? real.from : s.value, effective: s.value, locked: false, lockedBy: null, advisedBy: null,
+          cappedBy: { law_id: 'law:' + str(real.law_id), no: Number(real.law_no) || null, text: str(real.law_text), max: real.max, real: true },
+          _sources: { key: R, label: R, options: R, default: R, value: R, effective: R, locked: R, lockedBy: R, advisedBy: D, cappedBy: R },
+        };
+      }
+      if (real) {
+        return {
+          key: s.key, label: s.label, group: s.group, options: s.options, default: s.default,
+          value: real.from != null ? real.from : s.value, effective: s.value, locked: true,
+          lockedBy: { law_id: 'law:' + str(real.law_id), no: Number(real.law_no) || null, text: str(real.law_text), real: true }, advisedBy: null,
+          _sources: { key: R, label: R, options: R, default: R, value: R, effective: R, locked: R, lockedBy: R, advisedBy: D },
+        };
+      }
+      // no law in force touches it: the viewer's own, free to change
+      return {
+        key: s.key, label: s.label, group: s.group, options: s.options, default: s.default,
+        value: s.value, effective: s.value, locked: false, lockedBy: null, advisedBy: null,
+        _sources: { key: R, label: R, options: R, default: R, value: R, effective: R, locked: D, lockedBy: D, advisedBy: D },
+      };
+    });
+  }
+
+  // ---------- the whole model ----------
+  function livingModel(input) {
+    const o = obj(input) || {};
+    const now = Number(o.now) > 0 ? Number(o.now) : null;
+    const docket = obj(o.docket) && Array.isArray(o.docket.matters) ? o.docket : null;
+    const goalsAll = arr(o.goals, 'goals');
+    const rollups = {};
+    arr(o.rollups, 'rollups').forEach((r) => { if (r && r.goal_id != null) rollups[String(r.goal_id)] = r; });
+    const claims = arr(o.claims, 'active_claims');
+    // whether the claims feed was read at all: no read is "unknown", never "no agent"
+    const claimsRead = Array.isArray(o.claims) || !!(obj(o.claims) && Array.isArray(o.claims.active_claims));
+    const tasks = arr(o.tasks, 'tasks');
+    const person = peopleIndex(o.roster, docket);
+    const me = obj(o.me) ? (obj(o.me.builder) ? o.me : { builder: o.me }) : null;
+
+    // the viewer
+    const vb = me && me.builder;
+    const viewerId = vb && vb.id != null ? String(vb.id) : null;
+
+    // real holders per building (who may decide there today)
+    const holders = {};
+    const dBuilding = {};
+    arr(docket && docket.buildings).forEach((b) => {
+      if (!b || !b.key) return;
+      dBuilding[b.key] = b;
+      holders[b.key] = arr(b.holders).map((h) => person(h.id));
+    });
+
+    // THE LEADS (task 1004709): GET /government/leads — who leads each building and
+    // who holds the owner seat. Unread, no building names a Lead and no owner.
+    const leadsRead = obj(o.leads) && Array.isArray(o.leads.buildings) ? o.leads : null;
+    const who = (p) => ({ id: str(p.id), login: str(p.login), name: str(p.name || p.login) });
+    const ownerRow = leadsRead && obj(leadsRead.owner) ? arr(leadsRead.owner.builders)[0] : null;
+    const owner = obj(ownerRow) && ownerRow.id != null ? who(ownerRow) : null;
+    const leads = {};
+    if (leadsRead) {
+      leadsRead.buildings.forEach((b) => {
+        const l = b && obj(b.lead);
+        if (!l || BUILDING_KEYS.indexOf(b.building) < 0 || !obj(l.builder) || l.builder.id == null) return;
+        leads[b.building] = { person: who(l.builder), since: l.since || null, charter: { scope: str(l.charter) }, committees: [], real: true };
+      });
+    }
+    // THE STRUCTURE (task 1004711): the same read carries what each building has
+    // grown under its holder (`structure`: build-outs standing, built or going up,
+    // and the ones waiting on a vote). A building's committee rooms are its real
+    // ones (no table seats members in them yet) and its build-outs are drawn from it.
+    const structRead = {};
+    if (leadsRead) {
+      leadsRead.buildings.forEach((b) => {
+        if (!b || BUILDING_KEYS.indexOf(b.building) < 0 || !obj(b.structure)) return;
+        structRead[b.building] = { standing: arr(b.structure.standing).filter(obj), proposed: arr(b.structure.proposed).filter(obj) };
+      });
+    }
+    const realRooms = (key) => structRead[key].standing.filter((x) => x.capsule === 'committee')
+      .map((x) => ({ key: 'b' + str(x.id), name: str(x.name), line: str(x.line), members: [], real: true, state: x.state === 'built' ? 'built' : 'building' }));
+    const realBuilt = (key) => structRead[key].standing.filter((x) => x.capsule !== 'committee' && x.state === 'built')
+      .map((x) => ({ id: 'buildout:' + str(x.id), capsule: str(x.capsule), name: str(x.name), line: str(x.line) }));
+    Object.keys(leads).forEach((k) => { if (structRead[k]) leads[k] = Object.assign({}, leads[k], { committees: realRooms(k) }); });
+    // THE PRESETS (task 1004715): GET /government/presets. The project's strictness
+    // is the preset its laws in force amount to (null: none), and each preset
+    // carries the locks a switch to it would leave in force. Unread: unknown (null).
+    const presetsRead = obj(o.presets) && Array.isArray(o.presets.presets) ? o.presets : null;
+    const realPresets = presetsRead ? presetsRead.presets.filter((p) => obj(p) && p.key).map((p) => ({
+      key: str(p.key), name: str(p.name), line: str(p.line), locks: arr(p.locks).filter((l) => obj(l) && l.setting).map((l) => Object.assign({}, l)),
+    })) : null;
+    const realCurrent = realPresets ? realPresets.find((p) => p.key === presetsRead.current) || null : null;
+    const ownerIds = leadsRead && obj(leadsRead.owner) ? arr(leadsRead.owner.builders).filter((p) => obj(p) && p.id != null).map((p) => str(p.id)) : null;
+    const resolveSeat = seatResolver({ owner, ownerIds, leads, holders });
+    // routed: the server routed every docket matter (task 1004705)
+    // (a docket is read per viewer: its `yours` is only ever its own viewer's)
+    const routed = !!(docket && docket.routed === true);
+    const routedFor = routed && obj(docket.viewer) && docket.viewer.id != null ? String(docket.viewer.id) : null;
+    const ctx = { now, viewerId, resolveSeat, routed, routedFor, seated: !!leadsRead };
+
+    // ---- asks: every docket matter, and every open blocker it does not already carry ----
+    const humanOf = (a) => (a ? {
+      question: a.question, options: a.options, recommend: a.recommend, waits_on: a.waits_on,
+      if_nobody_answers: a.if_nobody_answers, routing_note: a.routing_note || null,
+    } : null);
+    // THE STORED ASK (task 1004703): a matter whose agent wrote its card in the ask
+    // shape carries it as `ask` (GET /government/docket, GET /blockers), checked by
+    // the server's own rules (modules/government/asks.js). Its words are real; a
+    // matter without one has no card (`human: null`) and shows in its own words.
+    // Who its seat names is the server's route when the docket is routed (makeAsk
+    // relabels waits_on and needs_you), else the seat the real Leads resolve.
+    const ASK_SOURCES = { id: R, source: R, building: R, state: R, urgent: D, opened_at: R, deadline: R, age_days: D, rule: R, ref: R, href: R, acts: R, tally: R, raw: R, human: R, format: D, shown: D, waits_on: D, needs_you: D, ask_real: D };
+    const storedOf = (a) => (obj(a) && str(a.question) ? a : null);
+    const asks = [];
+    const seen = {};
+    arr(docket && docket.matters).forEach((m) => {
+      if (!m || m.id == null || seen[m.id]) return;
+      seen[m.id] = true;
+      const building = BUILDING_KEYS.indexOf(m.building) >= 0 ? m.building : 'planning';
+      const stored = storedOf(m.ask);
+      asks.push(makeAsk({
+        id: m.id, source: m.source, building, state: m.state, opened_at: m.opened_at, deadline: m.deadline,
+        rule: m.rule, ref: m.ref, href: m.href, acts: m.acts, tally: m.tally, raw_title: m.title, raw_detail: m.detail, from_docket: true, ask_real: !!stored, route: m.route,
+      }, humanOf(stored), ctx, ASK_SOURCES));
+    });
+    arr(o.blockers, 'blockers').forEach((b) => {
+      if (!b || b.id == null) return;
+      const id = 'blockers:' + b.id;
+      if (seen[id] || (b.status && b.status !== 'open')) return;
+      seen[id] = true;
+      const stored = storedOf(b.ask);
+      asks.push(makeAsk({
+        id, source: 'blockers', building: 'planning', state: 'needs', opened_at: b.created_at, deadline: null,
+        rule: 'decide', ref: { type: 'blocker', id: String(b.id) }, href: '/blockers#blocker-' + b.id, acts: [], raw_title: b.title, raw_detail: b.body_md, ask_real: !!stored,
+      }, humanOf(stored), ctx, ASK_SOURCES));
+    });
+    asks.sort(compareAsks);
+
+    // ---- traffic: where the agents are ----
+    const goalById = {};
+    goalsAll.forEach((g) => { if (g && g.id != null) goalById[String(g.id)] = g; });
+    const taskById = {};
+    tasks.forEach((t) => { if (t && t.id != null) taskById[String(t.id)] = t; });
+    const placed = claims.map((c) => {
+      const t = taskById[String(c.task_id)];
+      const goalId = t && t.goal_id != null ? String(t.goal_id) : null;
+      const building = (goalId && goalBuilding(goalById[goalId])) || touchesBuilding(c.touches) || null;
+      return { claim_id: str(c.claim_id), task_id: str(c.task_id), goal_id: goalId, building, builder: person(c.builder_id), since: c.claimed_at || null };
+    });
+    const claimsAt = {};
+    const claimsInGoal = {};
+    placed.forEach((p) => {
+      if (p.building) claimsAt[p.building] = (claimsAt[p.building] || 0) + 1;
+      if (p.goal_id) claimsInGoal[p.goal_id] = (claimsInGoal[p.goal_id] || 0) + 1;
+    });
+
+    // ---- construction ----
+    const construction = {};
+    BUILDING_KEYS.forEach((k) => { construction[k] = []; });
+    // A LEAD'S BUILD-OUTS (task 1004711), from GET /government/leads `structure`:
+    // one going up is a live site (scaffold, crane) at its real progress — a day
+    // from when it started; one waiting on a vote is a ghost whose tally is its
+    // sitting's on the docket (`ask_id` is that docket id). First in the list, so
+    // the drawing shows the build-out ahead of any other open sitting there.
+    const buildoutVotes = {};
+    BUILDING_KEYS.forEach((k) => {
+      const s = structRead[k];
+      if (!s) return;
+      s.standing.filter((x) => x.state === 'building').forEach((x) => {
+        const allowed = obj(x.allowed) ? x.allowed : {};
+        construction[k].push({
+          kind: 'buildout', capsule: str(x.capsule), id: 'buildout:' + str(x.id), label: str(x.name), line: str(x.line),
+          authorised: true, authorised_by: allowed.path === 'vote' ? 'a passed vote' : str(allowed.why) || null, needs: null,
+          progress: clamp01(x.progress), sitting_id: allowed.item_id != null ? String(allowed.item_id) : null,
+          illustrative: false, driven_by_task: null, task_status: null, ask_id: null,
+          _sources: { kind: D, capsule: R, id: R, label: R, line: R, authorised: D, authorised_by: R, needs: D, progress: R, sitting_id: R, illustrative: D, driven_by_task: D, task_status: D, ask_id: D },
+        });
+      });
+      s.proposed.forEach((x) => {
+        const id = str(x.docket_id);
+        buildoutVotes[id] = true;
+        construction[k].push({
+          kind: 'scaffold', capsule: str(x.capsule), id, label: str(x.name), line: str(x.line),
+          authorised: false, authorised_by: null, needs: 'a vote',
+          progress: null, sitting_id: x.item_id != null ? String(x.item_id) : null,
+          illustrative: false, driven_by_task: null, task_status: null, ask_id: id,
+          _sources: { kind: D, capsule: R, id: R, label: R, line: R, authorised: D, authorised_by: D, needs: D, progress: D, sitting_id: R, illustrative: D, driven_by_task: D, task_status: D, ask_id: R },
+        });
+      });
+    });
+    arr(docket && docket.matters).forEach((m) => {
+      // a sitting still open is a proposal drawn into the city: a real scaffold
+      // (a build-out's own sitting is drawn above, as its ghost)
+      if (!m || m.source !== 'board' || m.state === 'settled' || BUILDING_KEYS.indexOf(m.building) < 0 || buildoutVotes[str(m.id)]) return;
+      construction[m.building].push({
+        kind: 'scaffold', id: str(m.id), label: str(m.short || m.title), line: str(m.title), authorised: false,
+        progress: null, sitting_id: m.ref && m.ref.id != null ? String(m.ref.id) : null, illustrative: false, task_status: null,
+        _sources: { kind: D, id: R, label: R, line: R, authorised: D, progress: D, sitting_id: R, illustrative: D, task_status: D },
+      });
+    });
+    BUILDING_KEYS.forEach((k) => {
+      const d = dBuilding[k];
+      if (d && d.decision && d.decision.sitting) {
+        construction[k].push({
+          kind: 'scaffold', id: 'decision:' + k, label: 'A new way to decide', line: str(d.decision.rule_words), authorised: false,
+          progress: null, sitting_id: d.decision.set_by_item_id != null ? String(d.decision.set_by_item_id) : null, illustrative: false, task_status: null,
+          _sources: { kind: D, id: D, label: D, line: R, authorised: D, progress: D, sitting_id: R, illustrative: D, task_status: D },
+        });
+      }
+    });
+
+    // ---- the nine buildings ----
+    const vocab = {};
+    arr(docket && docket.vocabulary && docket.vocabulary.buildings).forEach((v) => { if (v && v.key) vocab[v.key] = v; });
+    const readings = arr(docket && docket.readings);
+    const floors = arr(docket && docket.floors);
+    const buildings = BUILDING_KEYS.map((key) => {
+      const d = dBuilding[key] || {};
+      const v = vocab[key] || {};
+      const lead = leads[key] || null;
+      const here = asks.filter((a) => a.building === key);
+      const needs = here.filter((a) => a.state === 'needs').length;
+      const movingAsks = here.filter((a) => a.state === 'moving').length;
+      const agents = claimsAt[key] || 0;
+      const activity = round3(clamp01(agents / ACTIVITY_FULL));
+      const lit = round3(clamp01(0.15 + 0.55 * activity + (needs > 0 ? 0.3 : 0)));
+      const seats = holders[key] ? holders[key].map((p) => ({ id: p.id, login: p.login, name: p.name, role: 'holder' })) : [];
+      if (lead && lead.person) seats.unshift({ id: lead.person.id, login: lead.person.login, name: lead.person.name, role: 'lead' });
+      const decision = d.decision ? {
+        rule: d.decision.rule || null, rule_words: d.decision.rule_words || null, who: d.decision.who || null,
+        decided_by: d.decision.decided_by || null, sitting: !!d.decision.sitting,
+      } : null;
+      return {
+        key,
+        name: str(d.name || v.name || BUILDING_NAMES[key]),
+        group: str(d.group || v.group),
+        lead: lead && lead.person ? Object.assign({ since: lead.since }, lead.person) : null,
+        held_by: lead && lead.person ? 'lead' : 'owner',
+        holder: lead && lead.person ? lead.person : owner,
+        seats,
+        charter: lead ? lead.charter : null,
+        // its committee rooms and the build-outs that stand built (GET
+        // /government/leads `structure`, task 1004711; empty unread)
+        structure: {
+          committees: structRead[key] ? realRooms(key) : [],
+          built: structRead[key] ? realBuilt(key) : [],
+        },
+        decision,
+        // who answers for it, as GET /government/leads says (null without that read)
+        answers: leadsRead ? answersOf(leadsRead, key) : null,
+        // what its holder may build out without a vote: the server's answer (null unread)
+        build_rights: leadsRead ? rightsOf(leadsRead, key) : null,
+        asks: here,
+        counts: { needs, moving: agents + movingAsks, building: construction[key].length, asks: here.length },
+        activity,
+        agents,
+        construction: construction[key],
+        lit,
+        readings: readings.filter((r) => r && r.building === key),
+        floors: floors.filter((f) => f && f.building === key).length,
+        _sources: {
+          key: D, name: R, group: R, decision: R, asks: M,
+          // the Lead, its holder and charter: GET /government/leads (task 1004709)
+          lead: R, held_by: D, holder: R, charter: R, seats: D, structure: R, answers: R, build_rights: R,
+          'counts.needs': D, 'counts.moving': D, 'counts.building': D, 'counts.asks': D, activity: D, agents: D, construction: M, lit: D, readings: R, floors: D,
+        },
+      };
+    });
+
+    // ---- districts: one per open goal, in the order the goals come ----
+    // the treasury (task 1004712); unread, no district shows a pot
+    const treasuryRead = obj(o.treasury) && Array.isArray(o.treasury.pots) ? o.treasury : null;
+    const pots = {};
+    if (treasuryRead) treasuryRead.pots.forEach((p) => { if (p && p.goal_id != null) pots[String(p.goal_id)] = p; });
+    // a pot's borrow is the docket matter its server filed, when the docket carries it
+    const borrowOf = (p) => {
+      const b = obj(p.borrow);
+      return b && b.state === 'open' && b.matter_id && seen[b.matter_id] ? str(b.matter_id) : null;
+    };
+    const districts = goalsAll.filter((g) => g && g.status === 'open' && g.id != null).map((g) => {
+      const id = String(g.id);
+      const r = rollups[id] || {};
+      const inGoal = claimsInGoal[id] || 0;
+      const last = time(r.last_activity_at);
+      const recent = now != null && last != null && now - last <= DAY_MS;
+      let activity = clamp01(Math.max(inGoal, Number(r.active) || 0) / ACTIVITY_FULL);
+      if (recent) activity = Math.max(activity, RECENT_FLOOR);
+      const p = pots[id];
+      const pot = !p ? null : {
+        budget_usd: round2(p.budget_usd), spent_usd: round2(p.spent_usd), lent_usd: round2(p.lent_usd), left_usd: round2(p.left_usd),
+        dry: !!p.dry, share: p.share != null ? Number(p.share) : null, borrow_ask_id: borrowOf(p), note: null, real: true,
+      };
+      return {
+        goal_id: id,
+        title: str(g.title),
+        version_id: g.version_id || null,
+        working_area: g.working_area != null ? Number(g.working_area) : null,
+        building: goalBuilding(g),
+        counts: {
+          shipped: Number(r.done) || 0, active: Number(r.active) || 0, ready: Number(r.ready) || 0,
+          blocked: Number(r.blocked) || 0, backlog: Number(r.backlog) || 0, total: Number(r.total) || 0,
+        },
+        last_activity_at: r.last_activity_at || null,
+        agents: inGoal,
+        activity: round3(activity),
+        pot,
+        _sources: { goal_id: R, title: R, version_id: R, working_area: R, building: D, counts: R, last_activity_at: R, agents: D, activity: D, pot: R },
+      };
+    });
+
+    // ---- the city as a whole ----
+    const cost = obj(o.cost) || {};
+    const dayKey = now != null ? new Date(now).toISOString().slice(0, 10) : null;
+    const monthKey = dayKey ? dayKey.slice(0, 7) : null;
+    const daily = arr(cost.daily);
+    const byMonth = arr(cost.by_month);
+    const today = dayKey ? daily.find((x) => str(x.day).slice(0, 10) === dayKey) : null;
+    const month = monthKey ? byMonth.find((x) => x.month === monthKey) : null;
+    const monthIdx = month ? byMonth.indexOf(month) : -1;
+    const money = readings.find((r) => r && r.key === 'money');
+    const mv = obj(o.moving);
+    const sessionsList = arr(o.sessions, 'sessions');
+    const recentSessions = now != null ? sessionsList.filter((s) => { const t = time(s.uploaded_at); return t != null && now - t <= DAY_MS; }) : [];
+    const learningsList = arr(o.learnings, 'learnings');
+    const rulesReading = readings.find((r) => r && r.key === 'rules');
+    // THE LAW BOOK (task 1004706): GET /government/laws — every law in force,
+    // passed by a sitting of the government in force; a repealed law is not in the
+    // book. Its locks are enforced by the server (task 1004707): My agents reads
+    // what each lock did to the viewer off GET /me's `laws.locks`, never from this book.
+    const laws = arr(o.laws, 'laws').filter((l) => l && l.id != null && l.in_force !== false).map((l) => {
+      const pb = obj(l.passed_by) || {};
+      return {
+        id: 'law:' + str(l.id), text: str(l.text),
+        passed_by: pb.government ? { id: null, login: '', name: str(pb.government) } : null,
+        passed_at: l.passed_at || null, origin: 'vote', effect_on_ai: str(l.effect_on_ai), locks: arr(l.locks).slice(),
+        enforced_by: null, real: true,
+        _sources: { id: R, text: R, passed_by: R, passed_at: R, origin: D, effect_on_ai: R, locks: R, enforced_by: D, real: D },
+      };
+    });
+    if (rulesReading && rulesReading.status === 'live') {
+      // the one standing rule the project really runs (the docket's rules-at-work reading)
+      // its name is the reading's own words ("the landing rule settled 24 filings…")
+      const named = /^the ([a-z][a-z -]*? rule)\b/i.exec(str(rulesReading.line));
+      laws.unshift({
+        id: 'rules:' + str(rulesReading.key), text: named ? 'The ' + named[1] : str(rulesReading.figure), passed_by: null, passed_at: null, origin: 'docket',
+        effect_on_ai: str(rulesReading.line), locks: [], enforced_by: null, real: true,
+        _sources: { id: D, text: D, passed_by: D, passed_at: D, origin: D, effect_on_ai: R, locks: D, enforced_by: D, real: D },
+      });
+    }
+    const counts = { total: asks.length, needs_you: 0, needs: 0, moving: 0, settled: 0, refused: 0, by_seat: {} };
+    asks.forEach((a) => {
+      if (a.needs_you) counts.needs_you += 1;
+      counts[a.state] += 1;
+      if (!a.format.ok) counts.refused += 1;
+      counts.by_seat[a.waits_on.seat] = (counts.by_seat[a.waits_on.seat] || 0) + 1;
+    });
+    const city = {
+      line: docket && docket.line ? str(docket.line) : 'the docket could not be read just now',
+      matters: docket && docket.counts ? Object.assign({}, docket.counts) : null,
+      docket_read: !!docket,
+      // every docket matter was routed to a real seat on the server (task 1004705)
+      routed,
+      // the server's counts, when GET /government/counts was read (task 1004716)
+      served: servedCounts(o.counts),
+      laws,
+      asks,
+      ask_counts: counts,
+      traffic: {
+        agents: placed.length,
+        read: claimsRead,
+        moving: mv && mv.moving != null ? Number(mv.moving) : null,
+        by_building: claimsAt,
+        unplaced: placed.filter((p) => !p.building).length,
+        claims: placed,
+      },
+      spend: {
+        today_usd: today ? round2(today.amount_usd) : (dayKey && daily.length ? 0 : null),
+        month_usd: month ? round2(month.total_usd) : (monthKey && byMonth.length ? 0 : null),
+        last_month_usd: monthIdx > 0 ? round2(byMonth[monthIdx - 1].total_usd) : null,
+        total_usd: cost.total_usd != null ? round2(cost.total_usd) : null,
+        unattended: money && obj(money.value) ? { left_usd: money.value.left_usd, spent_usd: money.value.spent_usd, ceiling_usd: money.value.ceiling_usd, line: str(money.line) } : null,
+        reserve_usd: treasuryRead && obj(treasuryRead.reserve) && treasuryRead.reserve.usd != null ? round2(treasuryRead.reserve.usd) : null,
+        reserve_line: treasuryRead && obj(treasuryRead.reserve) ? str(treasuryRead.reserve.line) : null,
+        pots_basis: treasuryRead ? str(treasuryRead.basis) : null,
+        // no default spend limit (the owner's ruling): the treasury's cap setting, off
+        // unless the project set one; unknown without the read
+        limit: treasuryRead && obj(treasuryRead.cap) ? (treasuryRead.cap.on ? round2(treasuryRead.cap.usd) : 'none') : null,
+        cap: treasuryRead && obj(treasuryRead.cap) ? { on: !!treasuryRead.cap.on, usd: treasuryRead.cap.usd != null ? round2(treasuryRead.cap.usd) : null, line: str(treasuryRead.cap.line) } : null,
+        // who answers for the Treasury today, and whether it is the viewer
+        treasury_yours: treasuryRead && obj(treasuryRead.answers) ? !!treasuryRead.answers.yours : null,
+      },
+      sessions: { last_day: recentSessions.length, builders_last_day: Object.keys(recentSessions.reduce((m, s) => { m[str(s.builder_id)] = 1; return m; }, {})).length, total: (obj(o.sessions) && o.sessions.total != null) ? Number(o.sessions.total) : sessionsList.length },
+      learnings: { count: learningsList.length, latest_at: learningsList.reduce((m, l) => (str(l.created_at) > m ? str(l.created_at) : m), '') || null },
+      fence: obj(o.fence) ? { enabled: !!o.fence.enabled, paused_reason: o.fence.paused_reason || null, updated_at: o.fence.updated_at || null } : null,
+      _sources: {
+        line: R, matters: R, docket_read: D, routed: D, served: R, laws: M, asks: M, ask_counts: D,
+        'traffic.agents': D, 'traffic.read': D, 'traffic.moving': R, 'traffic.by_building': D, 'traffic.unplaced': D, 'traffic.claims': D, counts: M,
+        'spend.today_usd': R, 'spend.month_usd': R, 'spend.last_month_usd': R, 'spend.total_usd': R, 'spend.unattended': R,
+        'spend.reserve_usd': R, 'spend.reserve_line': R, 'spend.pots_basis': R, 'spend.limit': R, 'spend.cap': R, 'spend.treasury_yours': R,
+        sessions: D, learnings: D, fence: R,
+      },
+    };
+    // the numbers every surface prints, as nobody has answered anything yet
+    city.counts = countsOf({ city });
+
+    // ---- the viewer and my agents ----
+    const holds = BUILDING_KEYS.filter((k) => viewerId && (holders[k] || []).some((p) => p.id === viewerId));
+    const seats = [];
+    holds.forEach((k) => seats.push({ building: k, role: 'holder' }));
+    Object.keys(leads).forEach((k) => {
+      const l = leads[k];
+      if (l.person && l.person.id === viewerId) seats.push({ building: k, role: 'lead' });
+    });
+    if (ownerIds && viewerId && ownerIds.indexOf(viewerId) >= 0) seats.push({ building: null, role: 'owner' });
+    // task 1004713: GET /me's `positions` block is the server's answer to "which seats
+    // do you hold" (modules/government/positions.js). When /me carries it, the seats,
+    // the seat flag and the governance tab are that block's; without it, the seats
+    // the docket's holders and GET /government/leads give above.
+    const sent = me && obj(me.positions) && Array.isArray(me.positions.held) ? me.positions : null;
+    const realSeats = sent ? arr(sent.held).filter((p) => p && p.kind).map((p) => ({ building: p.building || null, role: str(p.kind), title: str(p.title) })) : null;
+    const seatsNow = realSeats || seats;
+    const seatSrc = realSeats ? R : D;
+    const viewer = vb ? {
+      id: viewerId, login: str(vb.github_login), name: str(vb.display_name || vb.github_login), rank: vb.rank || null,
+      holds, seats: seatsNow, has_seat: seatsNow.length > 0,
+      tabs: seatsNow.length > 0 ? ['city', 'agents', 'governance'] : ['city', 'agents'],
+      _sources: { id: R, login: R, name: R, rank: R, holds: D, seats: seatSrc, has_seat: seatSrc, tabs: seatSrc },
+    } : null;
+    const settings = agentSettings(me);
+    const myAgents = {
+      strictness: realCurrent ? realCurrent.key : null,
+      settings,
+      locked: settings.filter((s) => s.locked).length,
+      _sources: { strictness: R, settings: M, locked: D },
+    };
+
+    return {
+      generated_at: now != null ? new Date(now).toISOString() : null,
+      viewer,
+      owner,
+      // the preset the laws in force amount to (GET /government/presets); null unread
+      strictness: realPresets
+        ? { key: realCurrent ? realCurrent.key : null, name: realCurrent ? realCurrent.name : 'No preset yet', line: realCurrent ? realCurrent.line : 'Laws are passed one at a time.', presets: realPresets, real: true }
+        : null,
+      buildings,
+      districts,
+      city,
+      myAgents,
+      // who leads each building is a real read (GET /government/leads, task 1004709)
+      seats_real: !!leadsRead,
+      // what needs whom is routed on the server (task 1004705)
+      routed,
+      _sources: { generated_at: D, viewer: M, owner: R, strictness: R, buildings: M, districts: M, city: M, myAgents: M, seats_real: D, routed: D },
+    };
+  }
+
+  const api = {
+    livingModel, askFormat, slopScore, goalBuilding, touchesBuilding, compareAsks,
+    countsOf, countWords, countLabel, isOnYou, isOnOthers, COUNT_WORDS, COUNT_LABELS,
+    BUILDING_KEYS, BUILDING_NAMES, AREA_BUILDING, CATEGORY_BUILDING, MODULE_BUILDING, ASK_RULES, SLOP,
+    ACTIVITY_FULL, RECENT_FLOOR, SOURCES: Object.freeze({ REAL: R, DERIVED: D, MIXED: M }),
+  };
+  root.GovLiving = api;
+  if (typeof module !== 'undefined' && module.exports) module.exports = api;
+}(typeof window !== 'undefined' ? window : globalThis));