@bongos/core 1.20.80 → 1.20.82

package/modules/hall-ui/public/settings-autobongos.js

@@ -0,0 +1,156 @@
+// modules/hall-ui/public/settings-autobongos.js — the "Your Autobongos runner"
+// panel on /builders/settings (task 1004501).
+//
+// WHY THE PANEL EXISTS. The fence used to be one switch and one goal list for
+// every runner on the instance. Owner ruling, 2026-10-01: each builder says which
+// work THEIR runner takes, and a builder who has said nothing gets no autonomous
+// work. This is where they say it.
+//
+// WHAT IT READS. GET /autonomy/fence answers with the caller's EFFECTIVE fence: the
+// project allowlist narrowed to their picks, plus `scope` (what they picked, whether
+// they may run a runner, whether the owner paused them) and `project` (the
+// unnarrowed allowlist they choose from). One read, so the panel cannot disagree
+// with what the builder's runner is told. The server decides every one of those
+// facts; this page only draws them.
+//
+// WHAT IT WRITES. PUT /autonomy/me/goals with the whole list, on Save. The route
+// refuses a goal that is not allowlisted (409), and it is behind `autonomy.run`, so
+// a builder who may not run a runner is told so here instead of shown a form that
+// would fail.
+//
+// Its own file on the settings-interaction.js precedent: settings.js sits against
+// the 1500-line ratchet, and this panel shares nothing with the rest of the page.
+
+(() => {
+  'use strict';
+
+  const API = '/api/bongos';
+  const { escapeHtml, $ } = window.OTB;
+  const { emptyStateHtml } = window.OTBKit;
+  const toast = (msg) => window.OTB.toast(msg);
+  const api = window.BongosClient.createClient({ baseUrl: '', credentials: 'same-origin', throwOnError: false });
+
+  const toAuth = () => window.location.assign(`${API}/auth/web/start`);
+
+  // The lines above the form: each one says why the runner might be idle, in the
+  // order the server checks them, so the first line a builder reads is the reason.
+  function noticesHtml(fence) {
+    const project = fence.project || {};
+    const scope = fence.scope || {};
+    const out = [];
+    if (project.enabled !== true) {
+      out.push(`The project's runner switch is off right now${project.paused_reason ? `: ${escapeHtml(project.paused_reason)}` : ''}. Your choices are kept and apply when it is back on.`);
+    }
+    if (scope.owner_paused) {
+      out.push(`The owner paused your runner${scope.owner_paused_reason ? `: ${escapeHtml(scope.owner_paused_reason)}` : ''}. Only the owner can resume it.`);
+    }
+    return out.map((t) => `<p class="prow__hint">${t}</p>`).join('');
+  }
+
+  // Goal names, by id. The fence carries only ids and the owner's note, so the
+  // names come from GET /goals — the list the Goals page draws for this same
+  // builder, so it names only goals they can already see. Best-effort: a failed
+  // read leaves the map empty and a row falls back to its number.
+  let goalNames = new Map();
+  async function loadGoalNames() {
+    try {
+      const res = await api.request('GET', `${API}/goals`);
+      if (res.ok && res.data && Array.isArray(res.data.goals)) {
+        goalNames = new Map(res.data.goals.map((g) => [Number(g.id), g.title]));
+      }
+    } catch (_) { /* names are a nicety; the picker works without them */ }
+  }
+  const goalLabel = (id) => goalNames.get(Number(id)) || `Goal ${id}`;
+
+  function render(fence) {
+    const body = $('#autobongos-body');
+    if (!body) return;
+    const scope = fence.scope || {};
+    if (scope.may_run !== true) {
+      body.innerHTML = emptyStateHtml('Your rank cannot run an Autobongos runner on this project. Ask the owner if you need one.');
+      return;
+    }
+    const goals = (fence.project && Array.isArray(fence.project.goals)) ? fence.project.goals : [];
+    if (!goals.length) {
+      body.innerHTML = noticesHtml(fence) + emptyStateHtml('The project has not allowed any goals for runners yet, so there is nothing to choose from.');
+      return;
+    }
+    const picked = new Set((scope.goals || []).map(Number));
+    body.innerHTML = `${noticesHtml(fence)}
+      <form id="autobongos-form">
+        <div class="prows">
+          ${goals.map((g) => {
+            const id = `autobongos-goal-${escapeHtml(String(g.goal_id))}`;
+            return `<label class="prow prow--pick" for="${id}">
+              <input type="checkbox" id="${id}" name="autobongos-goal" value="${escapeHtml(String(g.goal_id))}"${picked.has(Number(g.goal_id)) ? ' checked' : ''}>
+              <span class="prow__main">
+                <span class="prow__label">${escapeHtml(goalLabel(g.goal_id))}</span>
+                <span class="prow__desc">${escapeHtml([goalNames.has(Number(g.goal_id)) ? `goal ${g.goal_id}` : '', g.note || ''].filter(Boolean).join(' · '))}</span>
+              </span>
+            </label>`;
+          }).join('')}
+        </div>
+        <div class="settings-card">
+          <button type="submit" class="settings-btn" id="autobongos-save">Save</button>
+          <span class="settings-card__hint">${picked.size ? `Your runner works ${picked.size} goal${picked.size === 1 ? '' : 's'}.` : 'Your runner takes no work until you choose at least one goal.'}</span>
+        </div>
+      </form>`;
+    $('#autobongos-form').addEventListener('submit', (e) => {
+      e.preventDefault();
+      const ids = [...e.target.querySelectorAll('input[name="autobongos-goal"]:checked')].map((i) => Number(i.value));
+      save(ids);
+    });
+  }
+
+  async function load() {
+    const res = await api.request('GET', `${API}/autonomy/fence`);
+    if (res.status === 401) { toAuth(); return null; }
+    if (!res.ok) throw new Error(`fence GET → ${res.status}`);
+    return res.data;
+  }
+
+  async function save(goalIds) {
+    const status = $('#autobongos-status');
+    const btn = $('#autobongos-save');
+    if (status) status.textContent = 'Saving…';
+    if (btn) btn.disabled = true;
+    try {
+      const res = await api.request('PUT', `${API}/autonomy/me/goals`, { body: { goal_ids: goalIds } });
+      if (res.status === 401) { toAuth(); return; }
+      if (!res.ok) {
+        const env = res.data && res.data.error;
+        throw new Error((env && env.message) || `could not save (${res.status})`);
+      }
+      const msg = goalIds.length ? `Saved — your runner works ${goalIds.length} goal${goalIds.length === 1 ? '' : 's'}.` : 'Saved — your runner takes no work.';
+      if (status) status.textContent = msg;
+      toast(msg);
+      const fence = await load();
+      if (fence) render(fence);
+    } catch (err) {
+      console.error('[settings] save autobongos goals failed', err);
+      if (status) status.textContent = `Could not save: ${err.message}`;
+      toast('Could not save your runner’s goals. Try again.');
+      if (btn) btn.disabled = false;
+    }
+  }
+
+  async function setup() {
+    const section = $('#autobongos-scroll');
+    if (!section) return;
+    try {
+      const [fence] = await Promise.all([load(), loadGoalNames()]);
+      if (!fence) return;
+      render(fence);
+      section.hidden = false;
+    } catch (err) {
+      // Its own try/catch, like every other panel: a failing read shows this
+      // panel's own error rather than taking the settings page down with it.
+      console.error('[settings] failed to load autobongos scope', err);
+      section.hidden = false;
+      $('#autobongos-body').innerHTML =
+        '<p class="voices-empty">Your runner settings could not be loaded. Reload the page to try again.</p>';
+    }
+  }
+
+  setup();
+})();

package/modules/hall-ui/public/settings.html

@@ -163,6 +163,23 @@
               <p class="section-note">Ending a session takes effect immediately; the token stops working on its very next request.</p>
             </section>
 
+            <!-- YOUR AUTOBONGOS RUNNER — which goals your own unattended runner
+                 works (task 1004501). Rendered by settings-autobongos.js against
+                 GET /autonomy/fence (your effective fence) and PUT
+                 /autonomy/me/goals. Picking nothing means your runner takes no
+                 work. The project allowlist and the master switch stay the
+                 owner's, on the Gate page. -->
+            <section class="scroll" id="autobongos-scroll" aria-labelledby="autobongos-h" data-group="access" hidden>
+              <h2 id="autobongos-h" class="scroll__h">Your Autobongos runner</h2>
+              <p class="scroll__lede">
+                Choose which goals your own runner works while you are away. You can
+                only choose from the goals the project allows. If you choose none, your
+                runner takes no work.
+              </p>
+              <div id="autobongos-body" aria-live="polite"></div>
+              <p class="settings-status" id="autobongos-status" role="status" aria-live="polite"></p>
+            </section>
+
             <!-- IMAGE KEY — per-builder Gemini key (task 1013 / ADR 0073).
                  GET/PUT/DELETE /api/bongos/me/art-key/own. Write-only (set/replace/
                  remove); the full key is never shown again after save (masked,
@@ -425,5 +442,7 @@
 <script src="/builders/settings-render.js?v=2026-09-16-render-levels"></script>
 <!-- task 1004296: Settings → Software update. Own file on the same precedent. -->
 <script src="/builders/settings-software-update.js?v=2026-09-26-update"></script>
+<!-- task 1004501: Settings → Your Autobongos runner. Own file on the same precedent. -->
+<script src="/builders/settings-autobongos.js?v=2026-10-01-autobongos"></script>
 </body>
 </html>

package/modules/hall-ui/public/settings.js

@@ -1066,6 +1066,7 @@
     'privacy': 'account-hub-scroll',
     'disciplines': 'craft-scroll',
     'cli': 'cli-scroll',
+    'autobongos': 'autobongos-scroll',
     'art-key': 'art-key',
     'interaction': 'interaction-scroll',
     'wandering': 'wandering-scroll',

package/modules/hall-ui/records/profile-roles.md

@@ -48,3 +48,24 @@ Signed out, the section is one sign-in line (owner decision (a)).
 - **The whole after line is highlighted**, where the mock highlights only the changed words: the batch stores whole lines, not the changed span.
 - **The artist tab's lede does not say what each page paid**: the pay per page is not in the read.
 - **The trail's window** is the span of the person's own thoughts (at least a month), with a line at each month, rather than the mock's fixed three months.
+
+## Earnings for everyone, labelled by kind of credit (task 1004436, WA6.RP06)
+
+The Overview's charts used to stop at "No works shipped yet" before they read a credit, so an artist or an ideator with a full credit history got no chart at all. Now the **earnings figure** leads the "Over time" grid for anyone who has earned, shipped task or not: the mock's "Earnings over time", a sentence about the person, the kit's cumulative step line, and beside it "where it came from", one bar per kind of credit in the mock's words, largest first.
+
+- **The read is `GET /builders/:builderId/earnings`** (economy, `modules/economy/earnings.js` + `routes/earnings.js`): the ledger summed per UTC day and per kind, for any signed-in viewer and any builder, own profile included. It carries sums only, so the itemised ledger (`/builders/:builderId/credits`) stays behind `builder.roster.read`; the chart no longer reads it, and the estimate a refused viewer used to get (summed from shipped tasks, which is nothing for these two crafts) is gone.
+- **The kinds are economy's** (`KINDS`), the words the page's (`KIND_WORDS` in `profile-charts.js`). A descent payment shares stream 1's reason key, so it is told apart by the descent writer's own description ("N hops below idea #"); `tests/profile_earnings.mjs` holds that phrase against the writer.
+- **The kinds follow the lookback window**, as every other figure does; the line still enters the window at its running total and ends at the balance.
+- **The works charts still need a shipped task**, and without one they are a single line under the figure ("No works shipped yet ..."), not two empty cards. Someone with neither credits nor works gets one line for the whole section.
+- **On a phone** the figure stacks: the line, then "where it came from". The plot's viewBox is half again a card's on a wide screen so its type matches the cards', and the kit's own on a phone (read at draw time, at the same 720px the grid stacks).
+
+Harness: `builders__earnings.json` serves any id; the artist (2001) and the ideator (2002) carry their own earnings beside an empty `builders__<id>__activity.json`, and the `artist`/`ideator` states expect `#chart-drachmae` and `.pearn__kinds`.
+
+### Deliberate differences from the mock (RP06)
+
+- **No "Spark splits" row.** A spark author's 30% share is counted under the stream that paid it (shipped work, a Full Idea pass, the board), and the task's own list of kinds does not name it; a separate row would count the same credits under two words.
+- **No "historical estimate" foot.** The figure is only what the ledger paid. An idea's historical estimate is part of its SIZE (By the numbers says so with its ~ mark), never money booked, so the earnings line has none to include.
+- **Two kinds the mock does not draw:** "Simplification bonuses" (the net-negative ship bonus, which the task names) and "Other credits" (achievements, a hand grant), so the bars always add up to the balance.
+- **The live chart chrome stays:** the crosshair readout line above the plot, the "as a table" twin and the kit's end ticks (the first day and "today", no "0" label), rather than the mock's "8 weeks ago / this week". No number is reachable only through the picture.
+- **It sits in "Over time" under the lookback control**, so the kinds follow the window rather than the mock's fixed eight weeks.
+- **The sentence uses the person's full display name**, not a first name the hall does not have, and for someone who never shipped a task it names where their credits came from ("approved pages and ideas"), where the mock's artist sample had the general sentence.

package/modules/lifecycle/db-goals.js

@@ -18,6 +18,8 @@ const { nonTerminalSql, isTerminalStatus } = require('./task-status');
 const { maintenanceGoalTitle } = require('./goal-advisory.js');
 const { SMOKE_NOT_LIKE } = require('./db-shared.js');
 const { executorFor, inTransaction } = require('./db-executor.js');
+// Task 1003660 — closing a goal cancels its pending invites + join requests.
+const { cancelPendingMembershipRequests } = require('./goal-close-sweep.js');
 // BV1.R16 (task 1003603) — auto-close, shared with the done-when cascade so the
 // two achievement writers cannot drift apart (ADR 0263 §4).
 const { autoCloseVersionsForGoals } = require('./version-autoclose.js');
@@ -282,6 +284,7 @@ async function carryBugsForward({ fromVersionId, toVersionId }, deps = {}) {
   // never "done", it stopped being the live queue. Leaving it open on a shipped
   // version is the mirror of the defect this whole goal exists to remove.
   await exec.query(`UPDATE goals SET status = 'archived', updated_at = now() WHERE id = $1`, [from[0].id]);
+  await cancelPendingMembershipRequests(exec, from[0].id);
   return { fromGoalId: String(from[0].id), toGoalId: String(to.id), moved: moved.length, reason: null };
 }
 
@@ -493,6 +496,8 @@ async function setGoalStatus({ goalId, status }, deps = {}) {
       RETURNING ${GOAL_COLS}`,
     [goalId, status]
   );
+  // A goal leaving `open` takes no new members, so its pending asks are dead.
+  if (rows[0] && status !== 'open') await cancelPendingMembershipRequests(activePool, goalId);
   return rows[0] ?? null;
 }
 
@@ -797,6 +802,7 @@ async function archiveGoalWithDispositions({ goalId, plan = [], reason }, deps =
       `UPDATE goals SET status = 'archived', updated_at = now() WHERE id = $1 RETURNING ${GOAL_COLS}`,
       [goalId]
     );
+    await cancelPendingMembershipRequests(client, goalId);
     await client.query('COMMIT');
     return { goal: archived[0], applied, alreadyArchived: false };
   } catch (err) {

package/modules/lifecycle/db-versions.js

@@ -20,6 +20,7 @@ const { executorFor, inTransaction } = require('./db-executor.js');
 // (fitness pins the count). createVersion needs it to seed a version's FIRST goal
 // in the same transaction — task 1003701.
 const { createGoal } = require('./db-goals.js');
+const { cancelPendingMembershipRequests } = require('./goal-close-sweep.js');
 
 async function listVersions() {
   const { rows } = await pool.query(
@@ -405,6 +406,7 @@ async function closeVersion({ versionId, plan = [], reason, planningVersionId =
           [step.goalId, `Abandoned: ${reason}`]
         );
         await client.query(`UPDATE goals SET status = 'archived', updated_at = now() WHERE id = $1`, [step.goalId]);
+        await cancelPendingMembershipRequests(client, step.goalId);
         applied.push({ goal_id: String(step.goalId), verb: 'abandon', result: 'archived', tasks_abandoned: killed.length });
       } else {
         // roll_forward (BV1.R17, task 1003604, ADR 0263 §6): the goal survives the
@@ -496,6 +498,7 @@ async function closeVersion({ versionId, plan = [], reason, planningVersionId =
         // on the way out rather than being special-cased around it (the brief's
         // explicit ask).
         await client.query(`UPDATE goals SET status = 'archived', updated_at = now() WHERE id = $1`, [step.goalId]);
+        await cancelPendingMembershipRequests(client, step.goalId);
 
         applied.push({
           goal_id: String(step.goalId), verb: 'roll_forward', result: 'succeeded',

package/modules/lifecycle/done-when.js

@@ -27,6 +27,7 @@ const { pool } = require('../../src/module-api');
 const { nonTerminalSql } = require('./task-status');
 const { SMOKE_NOT_LIKE } = require('./db-shared.js');
 const { executorFor } = require('./db-executor.js');
+const { cancelPendingMembershipRequests } = require('./goal-close-sweep.js');
 // BV1.R16 (task 1003603) — auto-close. Dependency-free module, so requiring it
 // here creates no cycle (db-versions.js requires THIS file, which is why the
 // rule could not live beside closeVersion).
@@ -565,6 +566,9 @@ async function autoSatisfyShippedCriteria(exec, { taskId = null, criterionId = n
      RETURNING g.id, g.title, g.version_id, g.status`,
     [goalIds]
   );
+  // Task 1003660: an achieved goal takes no new members — close its pending asks
+  // on the same executor, so the cancel rides the ship transaction.
+  await cancelPendingMembershipRequests(exec, goals.map((g) => g.id));
   // BV1.R16 (task 1003603, ADR 0263 §§3–4): a version closes ITSELF once its last
   // non-maintenance goal achieves. On the caller's `exec`, so it sees the flips
   // above that have not committed yet — a check on the pool would never close the

package/modules/lifecycle/goal-close-sweep.js

@@ -0,0 +1,34 @@
+'use strict';
+// goal-close-sweep.js — closing a goal cancels its outstanding invites + join
+// requests (task 1003660, from idea 1000787).
+//
+// Task 1002887 added the accept-time `goal_not_open` re-check, which refuses a
+// stale invite when someone tries to accept it — but until then the row kept
+// listing in the invitee's inbox as something they could act on. A goal that has
+// left `open` (achieved or archived) can take no new members, so its pending rows
+// are dead; this closes them at the moment the goal closes instead.
+//
+// BOTH kinds ('invite' and 'request') are cancelled, with the same 'cancelled'
+// terminal state addGoalMember uses (core_188: "withdrawn/rescinded"). 'rejected'
+// would stamp a decision on someone nobody made one about, and 'accepted' stays
+// reserved for a flow that actually ran. resolved_by is left NULL: no person
+// resolved it, the goal closing did.
+//
+// Takes the CALLER'S executor, never the module pool, and requires nothing — so
+// the ship-time cascade in done-when.js (which cannot require db-goals.js without
+// a cycle) and every archive path share one statement, and the cancel commits or
+// rolls back with the status flip it belongs to.
+
+async function cancelPendingMembershipRequests(exec, goalIds) {
+  const ids = (Array.isArray(goalIds) ? goalIds : [goalIds]).filter((g) => g != null).map(Number);
+  if (ids.length === 0) return 0;
+  const { rowCount } = await exec.query(
+    `UPDATE goal_membership_requests
+        SET status = 'cancelled', resolved_at = now(), updated_at = now()
+      WHERE goal_id = ANY($1::bigint[]) AND status = 'pending'`,
+    [ids]
+  );
+  return rowCount ?? 0;
+}
+
+module.exports = { cancelPendingMembershipRequests };

package/modules/provisioning/app-status.js

@@ -23,27 +23,40 @@ const RENDER_URL_RE = /^https:\/\/[a-z0-9-]{1,63}\.onrender\.com\/?$/;
 
 // The stages the owner sees, in order. `failed` is not a stage: it is the setup stopping.
 const STAGES = ['creating', 'building', 'live'];
+
+// How long a build may go unanswered before the owner stops being told it is building
+// (task 1004502). Render can give up on a deploy — project 43's timed out in 15 minutes —
+// and with the key gone (ADR 0327) the platform cannot read that verdict. So past this the
+// stage is `quiet`: not a failure (we cannot see one), but no longer a promise, with the
+// way to Render's own deploy history. The poller keeps knocking, so a late answer still
+// turns it `live`. Measured from the runner's last write (`updatedAt`, provision-render.js),
+// which is when `deploying` or `linked` began — the poller's `live` write never touches it.
+const QUIET_AFTER_MS = 20 * 60_000;
 const STAGE_OF = { requested: 'creating', creating: 'creating', deploying: 'building', linked: 'building', live: 'live' };
 
 function serviceLinks(serviceId) {
   if (!SERVICE_ID_RE.test(String(serviceId || ''))) return null;
   const base = `${DASHBOARD}/web/${serviceId}`;
-  return { service: base, env: `${base}/env` };
+  return { service: base, env: `${base}/env`, deploys: `${base}/events` };
 }
 
 function appUrl(url) { return RENDER_URL_RE.test(String(url || '')) ? String(url).replace(/\/+$/, '') : null; }
 
 // The owner's view of app_host: the stage, the address, the links, the failure sentence,
 // and the answers a retry re-sends (never the key — there is none to send).
-function appStatus(appHost, { keyWaiting = false } = {}) {
+function appStatus(appHost, { keyWaiting = false, now = Date.now() } = {}) {
   const h = appHost || null;
   if (!h || h.platform !== 'render') return null;
   if (h.state === 'disconnected') return { platform: 'render', state: 'disconnected', stage: null };
   const failed = h.state === 'failed';
+  const stage = failed ? null : (STAGE_OF[h.state] || 'creating');
+  const since = Date.parse(h.updatedAt || '');
+  const quiet = stage === 'building' && Number.isFinite(since) && now - since > QUIET_AFTER_MS;
   return {
     platform: 'render',
     state: h.state || 'requested',
-    stage: failed ? null : (STAGE_OF[h.state] || 'creating'),
+    stage: quiet ? 'quiet' : stage,
+    quiet,
     // an intent that still holds the lent key has not run yet, so the owner waits rather
     // than retries
     waiting: !!keyWaiting,
@@ -80,4 +93,4 @@ function retryAnswers(h) {
   return r;
 }
 
-module.exports = { appStatus, appUrl, serviceLinks, oneSentence, retryAnswers, STAGES, RENDER_URL_RE, SERVICE_ID_RE };
+module.exports = { appStatus, appUrl, serviceLinks, oneSentence, retryAnswers, STAGES, QUIET_AFTER_MS, RENDER_URL_RE, SERVICE_ID_RE };

package/modules/public-landing/public/projects.html

@@ -2333,6 +2333,13 @@ summary{min-height:24px;padding:3px 0;}
       v.hint.setAttribute('role', 'status');
       v.retryForm.appendChild(v.hint);
       v.root.appendChild(v.retryForm);
+    } else if (app.stage === 'quiet') {
+      /* Past the time box (task 1004502): Render may have given up, and with the key gone we
+         cannot see its verdict — so no stage is claimed, the owner is sent to Render's own
+         deploy history, and the watch keeps asking in case the app still comes up. */
+      v.root.appendChild(appPara(['Your app hasn’t answered for over 20 minutes. Render may have stopped the deploy — its deploy history says why.']));
+      if (app.links && app.links.deploys) v.root.appendChild(appPara([appLink(app.links.deploys, 'See its deploys on Render')]));
+      v.root.appendChild(appPara(['If it starts answering, this changes to Live by itself.']));
     } else {
       var at = APP_STAGES.map(function (s) { return s[0]; }).indexOf(app.stage);
       var ol = appEl('ol', 'appStages');

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.20.80",
+  "version": "1.20.82",
   "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

@@ -8625,5 +8625,33 @@
       "id": "1003907",
       "text": "Autobongos has now been proven against the live project: it shipped work by itself with nobody watching, refused every kind of work it is not allowed to touch, and recovered from restarts and network failures on its own. The o"
     }
+  ],
+  "1.20.81": [
+    {
+      "id": "1004501",
+      "text": "Each builder now chooses which goals their own Autobongos runner works, in Settings, from the goals the project allows. A builder who chooses nothing gets no unattended work. Who may run a runner at all is now a project permis"
+    }
+  ],
+  "1.20.82": [
+    {
+      "id": "1004502",
+      "text": "When an app on Render never comes up, its project card no longer says 'building' forever: after 20 minutes it says the app hasn't answered and links straight to the app's deploy history on Render."
+    },
+    {
+      "id": "1004452",
+      "text": "We tested the deploy self-repair on a real throwaway project on the server. When a project has leftover unsaved changes, the platform now fixes them itself and the update goes through. When it hits something it cannot fix, it"
+    },
+    {
+      "id": "1004436",
+      "text": "Every profile now shows an earnings chart for anyone who has earned credits, even artists and ideators who have never shipped a task (before, they got no chart at all). Beside the line, a \"where it came from\" list shows each k"
+    },
+    {
+      "id": "1003660",
+      "text": "Closing a goal now clears its pending invites and join requests, so a stale invite disappears from the invitee's inbox instead of sitting there until someone tries to accept it."
+    },
+    {
+      "id": "1004509",
+      "text": "The Autobongos runner panel on the Gate page is now much lighter to read. While anything is missing it shows a short checklist saying what to do next; once everything is ready it shrinks to one status line with an on/off switc"
+    }
   ]
 }

package/scripts/hall-preview/server.js

@@ -118,6 +118,10 @@ const FIXTURE_FALLBACKS = [
   // the profile's drachmae chart reads the credits ledger (task 1003491): one
   // ledger fixture serves your own (/me/credits, exact match) and any other id.
   [/^builders\/\d+\/credits$/, 'me__credits'],
+  // the profile's earnings figure reads earnings by day and kind (task 1004436):
+  // one engineer's fixture serves any id; the artist and the ideator who never
+  // shipped a task (2001, 2002) carry their own, beside an empty activity record.
+  [/^builders\/\d+\/earnings$/, 'builders__earnings'],
   // the profile's per-craft activity log (task 1003281). One fixture per SECTION
   // rather than per id, because the section is what changes the row shape; the
   // craft and the page window are query string, which fixture matching ignores.

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.20.80'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.20.82'; // 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');

package/tests/auto_satisfy_criteria.mjs

@@ -107,12 +107,14 @@ await test('ASYMMETRY (rollup): the /status rollup is untouched by this task', (
 await test('EXEC: every write goes through the caller-supplied exec (so a ship txn is atomic)', async () => {
   const exec = fakeExec({ rows: [CRIT] }, { rows: [{ id: 77, title: 'g', version_id: 'BONGOS-V1', status: 'achieved' }] });
   const out = await autoSatisfyShippedCriteria(exec, { taskId: 5 });
-  // Three since BV1.R16 (task 1003603): the criterion update, the goal cascade,
-  // and the version auto-close — which is the point, because the third must ride
-  // the SAME exec as the first two or a version would never close on the ship
-  // that finished it.
-  assert.equal(exec.calls.length, 3, 'criterion update + goal cascade + version auto-close');
-  assert.match(exec.calls[2].sql, /UPDATE versions v/, 'and the third is the auto-close, on exec');
+  // Four: the criterion update, the goal cascade, the pending-request sweep for the
+  // goals it just achieved (task 1003660), and the version auto-close (BV1.R16,
+  // task 1003603) — every one must ride the SAME exec or a rolled-back ship could
+  // leave a half-applied close (or a version that never closes on the ship that
+  // finished it).
+  assert.equal(exec.calls.length, 4, 'criterion update + goal cascade + request sweep + version auto-close');
+  assert.match(exec.calls[2].sql, /UPDATE goal_membership_requests/, 'the sweep rides exec');
+  assert.match(exec.calls[3].sql, /UPDATE versions v/, 'and the last is the auto-close, on exec');
   assert.deepEqual(out.criteria, [CRIT]);
   assert.deepEqual(out.goals.map((g) => g.id), [77]);
   const src = readFileSync(new URL('../modules/lifecycle/done-when.js', import.meta.url), 'utf8');