@bongos/core 1.20.34 → 1.20.36

package/modules/hall-ui/public/project-settings.css

@@ -186,3 +186,31 @@
   padding: 0.35rem 0;
   min-height: 24px;
 }
+
+/* Why a move stopped, by kind (task 1004450). WAITING is the accent, like a move in
+   flight — something is still being done, on its own clock. A DECISION is the warn mark:
+   nothing is broken, and the next step is the owner's. */
+.dp-settled--waiting {
+  border-left: 3px solid var(--accent);
+  padding-left: 0.7rem;
+}
+.dp-settled--decision {
+  border-left: 3px solid var(--warn);
+  padding-left: 0.7rem;
+}
+.dp-settled .ps-controls { margin: 0.4rem 0 0.2rem; }
+
+/* The project's update rule (task 1004445) — a quiet setting under the move, set apart by
+   a hairline so it does not read as part of whichever state sits above it. */
+.dp-rule {
+  margin: 0.9rem 0 0;
+  padding-top: 0.7rem;
+  border-top: 1px solid var(--rule-soft);
+}
+.dp-rule .ps-controls { align-items: center; gap: 0.5rem; }
+.dp-rule__label { font-size: 0.86rem; color: var(--ink-soft); }
+.dp-rule__select { min-height: 32px; }
+/* A link inside a stopped move's sentence ("the owner's blockers") is a control and owes
+   the 24px floor: the prose-link recipe buys the height with padding and hands it back
+   with an equal negative margin, so the line does not re-space. */
+.dp-settled .ov-row__sub a { display: inline-block; min-height: 24px; padding: 3px 0; margin: -3px 0; }

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

@@ -386,7 +386,7 @@
     const said = words();
     const who = (viewer && (viewer.display_name || viewer.github_login)) || 'an artist';
     const reason = `Reviewed in the studio by ${who} — the copy and visuals are good as shipped.${said ? ` ${said}` : ''}`;
-    const res = await api.request('POST', WRITE_ROUTES.abandon(p.taskId), { reason });
+    const res = await api.request('POST', WRITE_ROUTES.abandon(p.taskId), { body: { reason } });
     if (!res.ok) return verdictError(errMessage(res.data) || 'That could not be recorded. Nothing changed.');
     toast('Dismissed — the copy and visuals are good as shipped.');
     retire(p);
@@ -417,7 +417,7 @@
     const who = (viewer && (viewer.display_name || viewer.github_login)) || 'an artist';
     const stamp = new Date().toISOString().slice(0, 10);
     const block = `\n\n---\n\nARTIST NOTE (${stamp}, ${who}, from the studio):\n\n${said}`;
-    const res = await api.request('PATCH', WRITE_ROUTES.patch(p.taskId), { description: `${base}${block}` });
+    const res = await api.request('PATCH', WRITE_ROUTES.patch(p.taskId), { body: { description: `${base}${block}` } });
     if (!res.ok) return verdictError(errMessage(res.data) || 'That could not be recorded. Nothing changed.');
     p.description = `${base}${block}`;
     toast('Noted on the review — it stays open.');
@@ -447,7 +447,7 @@
     if (!said) return verdictError('Write what needs work first — a follow-up with no brief cannot be claimed.');
     const who = (viewer && (viewer.display_name || viewer.github_login)) || 'an artist';
     const about = p.shippedId ? `task ${p.shippedId}` : `review ${p.taskId}`;
-    const created = await api.request('POST', WRITE_ROUTES.create(), {
+    const created = await api.request('POST', WRITE_ROUTES.create(), { body: {
       version_id: p.versionId,
       goal_id: p.goalId ? Number(p.goalId) : undefined,
       title: `Artist verdict: the copy or visuals shipped in ${about} need work`,
@@ -463,17 +463,17 @@
       discipline: 'artist',
       source: 'studio-verdict',
       source_ref: `studio-needs-work-on-review-${p.taskId}`,
-    });
+    } });
     if (!created.ok) return verdictError(errMessage(created.data) || 'The follow-up could not be filed. Nothing changed.');
     const newId = created.data && created.data.task && created.data.task.id;
     if (!newId) return verdictError('The follow-up came back without an id, so the review was left open.');
     // Close the review against the follow-up. If this half fails the follow-up
     // still exists and is reported as such — a stranded-but-visible task beats
     // a silent success, and re-running the same verdict is safe.
-    const closed = await api.request('POST', WRITE_ROUTES.merge(p.taskId), {
+    const closed = await api.request('POST', WRITE_ROUTES.merge(p.taskId), { body: {
       into_task_id: Number(newId),
       reason: `Artist verdict from the studio: the review's answer is task ${newId}, which carries the work.`,
-    });
+    } });
     if (!closed.ok) {
       return verdictError(`Task ${newId} was filed, but this review could not be closed against it — close it from the review itself.`);
     }
@@ -882,7 +882,7 @@
     wedit.save = 'saving';
     wedit.error = '';
     paintEditing();
-    wedit.inflight = api.request('PUT', WRITE_ROUTES.draft(STUDIO), body);
+    wedit.inflight = api.request('PUT', WRITE_ROUTES.draft(STUDIO), { body });
     const res = await wedit.inflight;
     wedit.inflight = null;
     if (res.ok) {

package/modules/lifecycle/help-requests.js

@@ -48,7 +48,7 @@ async function craftsForBuilder(builderId, deps = {}) {
   return [...new Set(list.map(craftForDiscipline).filter(Boolean))];
 }
 
-const COLS = 'id, requested_by, needs_craft, needs_builder_id, what_is_stuck, task_id, goal_id, status, created_at, updated_at, settled_by, settled_reason';
+const COLS = 'id, requested_by, needs_craft, needs_builder_id, what_is_stuck, task_id, goal_id, status, created_at, updated_at, settled_by, settled_reason, reopened_at';
 // The two list reads also NAME the people on a row — who is asking (the fact
 // the collab page owes a helper: "who to answer", task 1003471) and who a
 // by-name ask is addressed to — through two LEFT JOINs on builders. COLS stays
@@ -257,6 +257,11 @@ async function listOpenAll({ limit = MAX_ROWS } = {}, deps = {}) {
 // it, and inventing one — treating a reply as an answer, say — would close the
 // clarifying question that was asking for more detail. Those still need a person.
 //
+// NEVER a REOPENED row (task 1004458). An asker who reopens an ask is saying the
+// shipped task did NOT answer it; closing it again on the next page load because
+// that same task is still shipped would overrule them in under a second. Once
+// reopened, only a person closes it.
+//
 // IDEMPOTENT, and safe to run on every list read: the WHERE matches only rows
 // that are still open, so a second run within the same page load finds nothing.
 async function settleFromLedger(deps = {}) {
@@ -266,6 +271,7 @@ async function settleFromLedger(deps = {}) {
         SET status = 'answered', settled_reason = 'task_shipped', updated_at = now()
       WHERE h.status = 'open'
         AND h.task_id IS NOT NULL
+        AND h.reopened_at IS NULL
         AND EXISTS (SELECT 1 FROM tasks t WHERE t.id = h.task_id AND t.status = 'shipped')
      RETURNING h.id, h.task_id`
   );
@@ -359,6 +365,33 @@ async function setHelpRequestStatus({ id, builderId, status, crafts = [] }, deps
   return rows[0] || null;
 }
 
+// THE ASKER REOPENS (task 1004458, owner direction: "like a traditional ticket").
+// Closing moved to the addressee with ADR 0330, which means an ask can now be
+// closed by someone other than the person who needed the answer — so the person
+// who needed it gets the last word. Only they may reopen: an addressee who wants
+// more has a reply box, and a third party reopening someone else's question
+// would be putting it back in a queue its owner had left.
+//
+// Any settled status reopens — 'answered' by a person or by the ledger, and the
+// asker's own 'withdrawn'. The settle fields are cleared so the row reads as the
+// open ask it is again, and `reopened_at` is what keeps settleFromLedger from
+// closing it straight back.
+//
+// Returns null for absent, not yours, or still open — ONE answer for all three,
+// for the same enumeration reason setHelpRequestStatus gives.
+async function reopenHelpRequest({ id, builderId }, deps = {}) {
+  const activePool = deps.pool || pool;
+  const { rows } = await activePool.query(
+    `UPDATE lifecycle_help_requests
+        SET status = 'open', settled_by = NULL, settled_reason = NULL,
+            reopened_at = now(), updated_at = now()
+      WHERE id = $1 AND requested_by = $2 AND status <> 'open'
+     RETURNING ${COLS}`,
+    [id, builderId]
+  );
+  return rows[0] || null;
+}
+
 // ---- replies (task 1004216) -------------------------------------------------
 //
 // APPEND-ONLY, and the table's own trigger is the authority — there is deliberately
@@ -450,7 +483,7 @@ async function repliesForRequests(ids, deps = {}) {
 module.exports = {
   HELP_CRAFTS, helpCrafts, disciplineForCraft, craftForDiscipline, craftsForBuilder,
   validateHelpRequest, MAX_STUCK, MAX_ROWS, capRows,
-  builderExists, createHelpRequest, listOpenForBuilder, listMine, listOpenAll, getHelpRequest, setHelpRequestStatus,
+  builderExists, createHelpRequest, listOpenForBuilder, listMine, listOpenAll, getHelpRequest, setHelpRequestStatus, reopenHelpRequest,
   settleFromLedger, listArchivedForBuilder, listArchivedMine,
   countOpenForBuilder, craftMapSql,
   MAX_REPLY, MAX_THREAD_ON_LIST, validateReply, createReply, listReplies, repliesForRequests,

package/modules/lifecycle/migrations/lifecycle_016_help_request_reopen.sql

@@ -0,0 +1,23 @@
+-- lifecycle_016_help_request_reopen.sql — the asker can reopen a settled ask
+-- (task 1004458, owner direction 2026-09-30: "mark it as resolved and the
+-- requester should then be able to re-open like traditional ticket fashion").
+--
+-- WHY A COLUMN AND NOT JUST A STATUS FLIP. Reopening sets status back to 'open',
+-- which is all the page needs. But settleFromLedger (lifecycle_012) closes every
+-- open ask whose task has shipped, on every Collab read — so an ask the ledger
+-- closed, then reopened by its asker, would be closed again on the very next
+-- page load. `reopened_at` is the fact that settle reads to leave it alone: the
+-- asker has said the shipped task did not answer the question, and only a person
+-- closes it from then on.
+--
+-- MODULE-OWNED and `lifecycle_`-prefixed, so fitness check 11 permits it; no core
+-- table is altered (ADR 0083 §Decision #5).
+
+ALTER TABLE lifecycle_help_requests
+  ADD COLUMN IF NOT EXISTS reopened_at timestamptz;
+
+COMMENT ON COLUMN lifecycle_help_requests.reopened_at IS
+  'When the asker last reopened this ask after it was settled (task 1004458). Non-NULL keeps settleFromLedger from closing it again because its task shipped.';
+
+INSERT INTO schema_migrations (version) VALUES ('lifecycle_016_help_request_reopen')
+ON CONFLICT (version) DO NOTHING;

package/modules/lifecycle/routes/help-requests.js

@@ -200,6 +200,9 @@ module.exports = function buildHelpRequestsRouter() {
   // Nobody is assigned by being asked — closing an ask ends a question, it does
   // not accept work (ADR 0187 §3).
   //
+  // 'open' REOPENS a settled ask (task 1004458) — the asker's alone, ticket
+  // style: whoever closed it, the person who needed the answer has the last word.
+  //
   // rank: any-builder — who may settle is enforced in the UPDATE's WHERE, not by
   // rank. The caller's crafts come from THEIR OWN profile, never from the body,
   // for the same reason the addressed read refuses a ?craft= it was handed.
@@ -207,9 +210,20 @@ module.exports = function buildHelpRequestsRouter() {
     const id = parseId(req, res, { code: 'bad_help_request_id', positiveInt: true });
     if (id === null) return;
     if (validateOrRespond(req, res, {
-      status: { required: true, type: 'string', enum: ['answered', 'withdrawn'] },
+      status: { required: true, type: 'string', enum: ['answered', 'withdrawn', 'open'] },
     })) return;
 
+    if (req.body.status === 'open') {
+      const reopened = await help.reopenHelpRequest({ id, builderId: req.builder.id });
+      if (!reopened) {
+        // Same single refusal as below, for the same enumeration reason.
+        return res.fail('help_request_not_reopenable', 404, {
+          reason: 'no settled help request with that id that you asked',
+        });
+      }
+      return res.json({ ok: true, help_request: reopened });
+    }
+
     const crafts = await help.craftsForBuilder(req.builder.id);
     const row = await help.setHelpRequestStatus({
       id, builderId: req.builder.id, status: req.body.status, crafts,

package/modules/provisioning/core-upgrade.js

@@ -348,7 +348,10 @@ function previewFromSnapshot(inst, snap, openIntent, lastMove) {
     preflight_at: pf && recommended && pf.target === recommended ? (snap.preflight_at || null) : null,
     // not_before: a failed move waiting out its retry backoff (task 1004447) — the page can
     // say "trying again at …" instead of an unexplained "pending" for up to six hours.
-    open_intent: openIntent ? { action: openIntent.action, state: openIntent.state, target_version: openIntent.target_version || null, not_before: openIntent.not_before || null, last_error: openIntent.not_before && openIntent.last_error ? String(openIntent.last_error).slice(0, 600) : null } : null,
+    open_intent: openIntent ? { action: openIntent.action, state: openIntent.state, target_version: openIntent.target_version || null, not_before: openIntent.not_before || null, last_error: openIntent.not_before && openIntent.last_error ? String(openIntent.last_error).slice(0, 600) : null,
+      // WHY it is waiting (task 1004450): a transient retry and a known snag the runner just
+      // fixed wait the same way, and the page words them differently. Only on a waiting row.
+      failure: openIntent.not_before && openIntent.failure_class ? { class: openIntent.failure_class, reason: openIntent.failure_reason || null } : null } : null,
     // THE LAST MOVE, WHATEVER BECAME OF IT (task 1004145).
     //
     // `open_intent` is `state IN ('pending','running')` — by the index's own definition.

package/modules/provisioning/render-standup.js

@@ -21,7 +21,10 @@
 
 // The plan and region vocabulary — shared with the runner's payload builder, which
 // requires it from here, so the web tier and the runner can never disagree on a name.
-const WEB_PLANS = ['starter', 'standard', 'pro', 'pro_plus', 'pro_max', 'pro_ultra'];
+// `free` is a web plan only (task 1004457, owner call 2026-09-30): the app sleeps when
+// idle, which is the owner's trade to make. The database has no free plan here —
+// Render's free Postgres has no backups and expires.
+const WEB_PLANS = ['free', 'starter','standard', 'pro', 'pro_plus', 'pro_max', 'pro_ultra'];
 const DB_PLANS = ['basic_256mb', 'basic_1gb', 'basic_4gb', 'pro_4gb', 'pro_8gb'];
 const REGIONS = ['virginia', 'ohio', 'oregon', 'frankfurt', 'singapore'];
 const MODES = ['adopt', 'greenfield'];

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

@@ -1434,10 +1434,10 @@ summary{min-height:24px;padding:3px 0;}
                     </select>
                   </label>
                   <label class="wizField" id="renderBuildWrap"><span>Build command <small>— leave empty if there is none</small></span>
-                    <input type="text" id="f-renderBuild" autocomplete="off" spellcheck="false" maxlength="500" placeholder="npm ci">
+                    <input type="text" id="f-renderBuild" autocomplete="off" spellcheck="false" maxlength="500" placeholder="for example: npm ci">
                   </label>
                   <label class="wizField" id="renderStartWrap"><span>Start command</span>
-                    <input type="text" id="f-renderStart" autocomplete="off" spellcheck="false" maxlength="500" placeholder="npm start">
+                    <input type="text" id="f-renderStart" autocomplete="off" spellcheck="false" maxlength="500" placeholder="for example: npm start">
                   </label>
                   <label class="wizField"><span>Plan</span>
                     <select id="f-renderPlan"></select>
@@ -1800,14 +1800,18 @@ summary{min-height:24px;padding:3px 0;}
      a key reaches every workspace its user is in, so nothing is pre-picked (ADR 0327).
      Prices are Render's list prices per month: starter and basic_256mb were measured by the
      pilot (task 1004142); Render's own pricing page is the source of truth, and the review
-     says Render bills the owner. Lists are built node by node, never from an HTML string. */
-  var RENDER_WEB_PLANS = [['starter', 'Starter', 7], ['standard', 'Standard', 25], ['pro', 'Pro', 85]];
+     says Render bills the owner. Lists are built node by node, never from an HTML string.
+     Free (task 1004457) is listed first by price but never preselected: its app sleeps when
+     idle, and the list says so rather than letting $0 read as a plain bargain. */
+  var RENDER_WEB_PLANS = [['free', 'Free', 0], ['starter', 'Starter', 7], ['standard', 'Standard', 25], ['pro', 'Pro', 85]];
+  var RENDER_FREE_NOTE = '$0, but it sleeps when idle and takes about a minute to wake up';
+  function planPrice(p) { return p[2] ? 'about $' + p[2] + '/month' : RENDER_FREE_NOTE; }
   var RENDER_DB_PLANS = [['basic_256mb', 'Basic 256 MB', 6], ['basic_1gb', 'Basic 1 GB', 19], ['basic_4gb', 'Basic 4 GB', 75]];
   var RENDER_RUNTIMES = { node: 'Node.js', python: 'Python', ruby: 'Ruby', go: 'Go', rust: 'Rust', elixir: 'Elixir', docker: 'Docker' };
   var RENDER_KEY_RE = /^rnd_[A-Za-z0-9]{16,128}$/;
   function planLabel(list, v) {
     var p = list.filter(function (x) { return x[0] === v; })[0] || list[0];
-    return p[1] + ', about $' + p[2] + '/month';
+    return p[1] + ', ' + planPrice(p);
   }
   function runtimeLabel(v) { return RENDER_RUNTIMES[v] || RENDER_RUNTIMES.node; }
   function repoOf(url) { var m = String(url || '').replace(/\.git$/, '').match(/github\.com\/([^/]+\/[^/]+)$/i); return m ? m[1].toLowerCase() : ''; }
@@ -1832,7 +1836,7 @@ summary{min-height:24px;padding:3px 0;}
     function fillPlans(sel, list, v) {
       sel.textContent = '';
       list.forEach(function (p) {
-        var o = appEl('option', null, p[1] + ' — about $' + p[2] + '/month');
+        var o = appEl('option', null, p[1] + ' — ' + planPrice(p));
         o.value = p[0];
         if (p[0] === v) o.selected = true;
         sel.appendChild(o);
@@ -1972,7 +1976,12 @@ summary{min-height:24px;padding:3px 0;}
     });
     q('renderNew').addEventListener('input', function (ev) {
       if (ev.target.id === q('f-renderBuild').id) st.renderBuild = ev.target.value;
-      if (ev.target.id === q('f-renderStart').id) st.renderStart = ev.target.value;
+      if (ev.target.id === q('f-renderStart').id) {
+        st.renderStart = ev.target.value;
+        // the "say how your app starts" ask is answered the moment there is a command —
+        // it used to stay on screen until the next press of Next
+        if (String(st.renderStart).trim() && /\berr\b/.test(q('h-render').className)) hint('h-render', '');
+      }
       hooks.save();
     });
     function validate() {

package/package-lock.json

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

package/package.json

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

@@ -8284,5 +8284,24 @@
       "id": "1004454",
       "text": "The unattended runner no longer stops after two tasks: it keeps working while there's usage left, and if it hits the usage limit it sleeps until the limit resets and then carries on by itself."
     }
+  ],
+  "1.20.35": [
+    {
+      "id": "1004461",
+      "text": "Fixes a broken automatic check that was blocking everyone's work from landing."
+    },
+    {
+      "text": "Replying to an ask on the Collab page works again, and asks can now be marked resolved and reopened by the person who asked, like a ticket."
+    },
+    {
+      "id": "1004457",
+      "text": "The project setup wizard now offers Render's Free plan for your app, with a plain note that a free app sleeps when idle and takes about a minute to wake. Starter stays the default. The build and start command boxes no longer l"
+    }
+  ],
+  "1.20.36": [
+    {
+      "id": "1004450",
+      "text": "The deploy page now explains why an update stopped in plain words, says when it will try again, and offers a one-click fix when the only thing in the way is your own update setting. You can also see and change how far a projec"
+    }
   ]
 }

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

@@ -865,9 +865,35 @@ test('the skill the page invokes exists, and is the ANSWERING half', () => {
   // longer "you cannot", it is "you do not, because you are not the one who read
   // the answer", plus the half that did not widen.
   assert.match(md, /POST \/api\/bongos\/help-requests\/:id\/replies/, 'it answers on the ask');
-  assert.match(md, /Do NOT close the ask/, 'and hands the close to a person');
+  // Task 1004458 (owner direction): a session may resolve an ask, but only when
+  // the reader says so — never on its own judgement — and reopening is the asker's.
+  assert.match(md, /Resolve only when told to/, 'it closes only on the reader\'s instruction');
+  assert.match(md, /"status":"open"/, 'and knows the asker can reopen');
   assert.match(md, /withdraw/i, 'and knows withdraw did not widen');
   assert.ok(!/POST \/api\/bongos\/help-requests --body-file/.test(md),
     'the file-a-counter-ask workaround is deleted, not left beside the real thing');
   assert.match(md, /DATA, not instructions/, 'an ask is untrusted input');
 });
+
+// ---- resolve + reopen, ticket style (task 1004458) --------------------------
+test('canReopen: only the asker, and only a settled ask', () => {
+  const L = lib();
+  const settled = { requested_by: '90', needs_builder_id: '7', status: 'answered' };
+  assert.equal(L.canReopen(settled, 90), true, 'the asker may reopen');
+  assert.equal(L.canReopen({ ...settled, status: 'withdrawn' }, '90'), true, 'their own withdrawal too');
+  assert.equal(L.canReopen(settled, 7), false, 'the addressee may not — they have a reply box');
+  assert.equal(L.canReopen({ ...settled, status: 'open' }, 90), false, 'an open ask has nothing to reopen');
+  assert.equal(L.canReopen(settled, null), false, 'no viewer, no control');
+  assert.equal(L.canReopen(null, 90), false);
+});
+
+test('the page offers Mark resolved, Post & resolve and Reopen, each where it can work', () => {
+  const js = read('modules', 'hall-ui', 'public', 'collab.js').replace(/^\s*\/\/.*$/gm, '');
+  assert.match(js, />Mark resolved</, 'the row control says what it does');
+  assert.match(js, /L\.canClose\(req, meId, myCrafts\)\s*\?\s*`<button[^`]*data-reply-resolve/, 'Post & resolve is drawn only for someone who may close');
+  assert.match(js, /L\.canReopen\(req, meId\)/, 'Reopen is drawn only for the asker');
+  assert.match(js, /settle\(Number\(reopenBtn\.getAttribute\('data-id'\)\), 'open'\)/, 'and it sends status open');
+  // The close waits for the reply: a refused reply must not leave an ask closed.
+  const post = js.slice(js.indexOf('async function postReply'), js.indexOf('function toggleReply'));
+  assert.ok(post.indexOf('if (!r.ok)') < post.indexOf("status: 'answered'"), 'resolve runs only after the reply landed');
+});

package/tests/core_upgrade_door.mjs

@@ -431,7 +431,7 @@ await t('schema_pending passes through as a count, and UNKNOWN stays null rather
 await t('an open intent is surfaced with its target, so the page can say what is already running', () => {
   const p = CU.previewFromSnapshot(previewInst, { served_version: '1.19.758', available: [], recommended: null },
     { action: 'core-upgrade', state: 'running', target_version: '1.19.762' });
-  assert.deepEqual(p.open_intent, { action: 'core-upgrade', state: 'running', target_version: '1.19.762', not_before: null, last_error: null });
+  assert.deepEqual(p.open_intent, { action: 'core-upgrade', state: 'running', target_version: '1.19.762', not_before: null, last_error: null, failure: null });
 });
 
 console.log('\nthe deploy page is gated on the same atom as its routes:');
@@ -1007,5 +1007,12 @@ await t('the preview says when a waiting move will try again, and why it is wait
     'an ordinary pending intent shows no error');
 });
 
+await t('a waiting move says what KIND of failure it is waiting out; a plain pending one says none (task 1004450)', () => {
+  const p = CU.previewFromSnapshot(ACTIVE, null, waiting({ failure_class: 'known_wedge', failure_reason: 'dirty_tree' }), null);
+  assert.deepEqual(p.open_intent.failure, { class: 'known_wedge', reason: 'dirty_tree' });
+  assert.equal(CU.previewFromSnapshot(ACTIVE, null, waiting({ not_before: null, failure_class: 'transient' }), null).open_intent.failure, null);
+  assert.equal(CU.previewFromSnapshot(ACTIVE, null, waiting(), null).open_intent.failure, null, 'a row from before the columns');
+});
+
 console.log(`\ncore_upgrade_door: ${passed} passed, ${failed} failed`);
 if (failed) process.exit(1);

package/tests/deploy_page_projects.mjs

@@ -517,7 +517,7 @@ test('the runner’s shell output is folded behind a disclosure, never the headl
   }) });
   await b.settle();
   const html = b.panel();
-  assert.match(html, /<details class="dp-settled__detail"><summary>What the upgrade said<\/summary>/, 'folded');
+  assert.match(html, /<details class="dp-settled__detail"><summary>Technical detail — what the upgrade said<\/summary>/, 'folded');
   assert.match(html, /working tree not clean/, 'and the words are still all there');
   assert.ok(html.indexOf('did not land') < html.indexOf('<details'), 'the plain sentence comes first');
 });
@@ -645,3 +645,167 @@ test('the reconnect link returns to the page\u2019s full https address when ther
   await b.settle();
   assert.ok(b.panel().includes(`return=${encodeURIComponent(here)}`), b.panel());
 });
+
+// ── why a move stopped, by kind; the update rule; waiting is not moving (task 1004450) ──
+
+// A body built inside the vm is another realm's object; compare its data, not its prototype.
+const plain = (o) => JSON.parse(JSON.stringify(o));
+const soon = (mins) => new Date(Date.now() + mins * 60000).toISOString();
+const failedAs = (cls, reason, over = {}) => ({
+  target_version: '1.19.871', state: 'error', at: new Date().toISOString(), error: 'raw runner words', superseded: false,
+  failure: { class: cls, reason }, ...over,
+});
+const waitingIntent = (cls, reason, mins = 60) => ({
+  action: 'core-upgrade', state: 'pending', target_version: '1.19.871', not_before: soon(mins),
+  last_error: 'x', failure: cls ? { class: cls, reason } : null,
+});
+
+test('a move waiting out a temporary failure says WHEN it tries again, and offers to try now', async () => {
+  const b = boot({ controlPlane: preview('1', 'cloudbongos', { open_intent: waitingIntent('transient', 'not_published') }) });
+  await b.settle();
+  const html = b.panel();
+  assert.match(html, /dp-settled--waiting/);
+  assert.match(html, /Waiting to try core 1\.19\.871 again at .*in about 60 min/);
+  assert.match(html, /not published yet/, 'the reason, in plain words');
+  assert.match(html, /usually temporary/);
+  assert.doesNotMatch(html, /is pending for this box/, 'not the generic busy line');
+  b.els.get('dp-retry-1')._on.click();
+  await b.settle();
+  const post = b.posts.find((p) => /core-upgrade$/.test(p.path));
+  assert.deepEqual(post && plain(post.body), { to: '1.19.871' }, 'Try now asks for the SAME move');
+});
+
+test('a known snag the runner just fixed says what it did, and that it tries once more', async () => {
+  const b = boot({ controlPlane: preview('1', 'cloudbongos', { open_intent: waitingIntent('known_wedge', 'dirty_tree', 2) }) });
+  await b.settle();
+  const html = b.panel();
+  assert.match(html, /A known snag stopped the move/);
+  assert.match(html, /unsaved file changes/);
+  assert.match(html, /saved those changes on its own/);
+  assert.match(html, /tries the move once more/);
+});
+
+test('a pending move with a PAST not_before is still a move under way, not a wait', async () => {
+  const b = boot({ controlPlane: preview('1', 'cloudbongos', { open_intent: waitingIntent('transient', 'not_published', -5) }) });
+  await b.settle();
+  assert.doesNotMatch(b.panel(), /dp-settled--waiting/);
+  assert.match(b.panel(), /is pending for this box/);
+});
+
+test('a move that falls into a WAIT stops the poll at once, with no "still working" toast', async () => {
+  const b = boot({
+    scope: 'hoodify-finance', moveTries: 50,
+    instanceOver: (inst, n) => (n >= 2 ? { open_intent: waitingIntent('transient', 'registry_unreadable') } : {}),
+  });
+  await b.settle();
+  b.els.get('dp-preview-32')._on.click();
+  b.els.get('dp-confirm-32')._on.click();
+  for (let i = 0; i < 4; i++) await b.settle();
+  assert.match(b.panel(), /dp-settled--waiting/, 'the row shows the wait');
+  assert.doesNotMatch(b.panel(), /dp-moving/, 'and is no longer painted as moving');
+  assert.ok(!b.toasts.some((t) => /Still working/.test(t)), `no false "still working": ${b.toasts}`);
+  assert.ok(b.reads.get('32') < 10, `the poll stopped early (read ${b.reads.get('32')} times, bound 50)`);
+});
+
+test('a refusal by the update rule offers ONE click: allow new releases, then move', async () => {
+  const b = boot({ controlPlane: preview('1', 'cloudbongos', { update_channel: 'patch', last_move: failedAs('needs_decision', 'outside_channel', { target_version: '1.20.1' }) }) });
+  await b.settle();
+  const html = b.panel();
+  assert.match(html, /dp-settled--decision/);
+  assert.match(html, /Your call/);
+  assert.match(html, /outside this project’s update rule/);
+  assert.match(html, /Allow new releases and move to 1\.20\.1/);
+  b.els.get('dp-allow-1')._on.click();
+  await b.settle();
+  const paths = b.posts.map((p) => p.path);
+  const rule = paths.indexOf('/provisioning/instances/1/update-channel');
+  const mv = paths.indexOf('/provisioning/instances/1/core-upgrade');
+  assert.ok(rule >= 0 && mv > rule, `the rule changes FIRST, then the move is queued: ${paths}`);
+  assert.deepEqual(plain(b.posts[rule].body), { channel: 'minor' });
+  assert.deepEqual(plain(b.posts[mv].body), { to: '1.20.1' });
+});
+
+test('under the widest rule already, the refusal offers no allow button', async () => {
+  const b = boot({ controlPlane: preview('1', 'cloudbongos', { update_channel: 'minor', last_move: failedAs('needs_decision', 'outside_channel') }) });
+  await b.settle();
+  assert.doesNotMatch(b.panel(), /dp-allow-1/);
+});
+
+test('the other decisions say what the owner can do, with no button that cannot help', async () => {
+  const b = boot({ controlPlane: preview('1', 'cloudbongos', { last_move: failedAs('needs_decision', 'artist_gate') }) });
+  await b.settle();
+  assert.match(b.panel(), /Approve the artist review/);
+  assert.doesNotMatch(b.panel(), /dp-allow-1/);
+});
+
+test('a failure nothing automatic can fix points at the blocker filed for it', async () => {
+  const b = boot({ controlPlane: preview('1', 'cloudbongos', { last_move: failedAs('unknown', 'health') }) });
+  await b.settle();
+  const html = b.panel();
+  assert.match(html, /nothing automatic can fix it/);
+  assert.match(html, /did not answer after restarting/);
+  assert.match(html, /href="\/blockers"/);
+  assert.match(html, /<details class="dp-settled__detail">/, 'the runner’s words are still one click away');
+});
+
+test('a failed ROLLBACK says the project may be down', async () => {
+  const b = boot({ controlPlane: preview('1', 'cloudbongos', { last_move: failedAs('unknown', 'rollback_failed') }) });
+  await b.settle();
+  assert.match(b.panel(), /may be down/);
+  assert.match(b.panel(), /href="\/blockers"/);
+});
+
+test('a temporary failure that ran out of retries offers to try again — only for the move on offer', async () => {
+  const b = boot({ controlPlane: preview('1', 'cloudbongos', { last_move: failedAs('transient', 'npm_install') }) });
+  await b.settle();
+  assert.match(b.panel(), /kept stopping/);
+  assert.match(b.panel(), /dp-again-1/);
+  const other = boot({ controlPlane: preview('1', 'cloudbongos', { last_move: failedAs('transient', 'npm_install', { target_version: '1.19.850' }) }) });
+  await other.settle();
+  assert.doesNotMatch(other.panel(), /dp-again-1/, 'a try-again for a version no longer on offer would be a different move');
+});
+
+test('the update rule is shown in words and can be changed from the page', async () => {
+  const b = boot({ controlPlane: preview('1', 'cloudbongos', { update_channel: 'patch' }) });
+  await b.settle();
+  const html = b.panel();
+  assert.match(html, /Update rule: Fixes only/);
+  assert.match(html, /<option value="patch" selected>/);
+  b.els.set('dp-rule-sel-1', { value: 'minor' });
+  b.els.get('dp-rule-save-1')._on.click();
+  await b.settle();
+  const post = b.posts.find((p) => /update-channel$/.test(p.path));
+  assert.deepEqual(post && plain(post.body), { channel: 'minor' });
+  assert.ok(b.toasts.length, 'the server’s sentence is shown');
+});
+
+test('a preview with no rule reading shows no rule control, rather than a guessed one', async () => {
+  const b = boot();
+  await b.settle();
+  assert.doesNotMatch(b.panel(), /Update rule/);
+});
+
+test('every reason the runner can give has owner words on this page — none falls to the fallback', async () => {
+  // upgrade-outcome.js's REASON_CLASS is the vocabulary; a reason added there with no
+  // sentence here would reach the owner as "no words for this yet".
+  const { createRequire } = await import('node:module');
+  const req = createRequire(import.meta.url);
+  const vocab = Object.keys(req(path.join(ROOT, 'scripts/gds/upgrade-outcome.js')).REASON_CLASS || {});
+  assert.ok(vocab.length > 20, 'the vocabulary was read');
+  const block = SRC.slice(SRC.indexOf('const REASON_WORDS = {'), SRC.indexOf('const reasonWords'));
+  const missing = vocab.filter((k) => !new RegExp(`\\b${k}:`).test(block));
+  assert.deepEqual(missing, [], `reasons with no owner words: ${missing}`);
+});
+
+test('a module that is not ready says what the owner can do about it', async () => {
+  const b = boot({ controlPlane: preview('1', 'cloudbongos', { last_move: failedAs('needs_decision', 'module_incompatible') }) });
+  await b.settle();
+  assert.match(b.panel(), /Turn that module off/);
+});
+
+test('a known snag it could not fix names the next step, and does NOT point at a blocker that was never filed', async () => {
+  const b = boot({ controlPlane: preview('1', 'cloudbongos', { last_move: failedAs('known_wedge', 'disk_full') }) });
+  await b.settle();
+  assert.match(b.panel(), /whoever runs that machine clears the snag/);
+  assert.doesNotMatch(b.panel(), /href="\/blockers"/, 'move-escalation files no blocker for this class');
+});

package/tests/hall_approval_queue.mjs

@@ -92,7 +92,11 @@ function bootPanel({ answers = {}, writes = null, mode = 'light' } = {}) {
     get activeElement() { return boot.focused || null; },
   };
   const api = {
-    async request(method, u, reqBody) {
+    // The REAL client's shape: request(method, path, { body }). This fake once
+    // took the payload as the third argument, which is exactly the mistake the
+    // panel made — so the suite agreed with a write that sent nothing (task 1004458).
+    async request(method, u, opts) {
+      const reqBody = opts && opts.body;
       requests.push({ method, url: u, body: reqBody });
       const key = `${method} ${u}`;
       const hit = answers[key];