@bongos/core 1.20.34 → 1.20.35

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/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.35",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.20.34",
+      "version": "1.20.35",
       "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.35",
   "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,18 @@
       "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"
+    }
   ]
 }

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.35'; // 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/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];

package/tests/hall_client_request_shape.mjs

@@ -0,0 +1,103 @@
+// tests/hall_client_request_shape.mjs — every write a hall page sends through the
+// generated client's escape hatch carries its payload UNDER `body` (task 1004458).
+//
+// `api.request(method, path, opts)` reads `opts.body` as the JSON payload and
+// nothing else. Handing it the payload itself fails two quiet ways, and both
+// shipped: `{ decision }` (the mingle buttons) and `{ reason }` / `{ version_id,
+// … }` (the studio's verdicts) have no `body` key, so the request goes out EMPTY;
+// and `{ body: text }` (the Collab reply) sends a bare JSON string, which the
+// server's strict parser refuses as `bad_json`. Neither is visible until someone
+// presses the button on the live site.
+//
+// So this RUNS the real client against a recording fetch to pin what `body`
+// means, then scans every hall-side call for an options object whose keys are
+// not options.
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const OPTION_KEYS = new Set(['body', 'query', 'headers', 'hasBody', 'cache']);
+
+function client() {
+  const sent = [];
+  const win = {};
+  const src = fs.readFileSync(path.join(ROOT, 'clients', 'bongos-client', 'bongos-client.global.js'), 'utf8');
+  new Function('window', 'globalThis', 'self', src)(win, win, win);
+  const fetch = async (url, init) => { sent.push({ url, init }); return { ok: true, status: 200, text: async () => '{}' }; };
+  return { sent, api: win.BongosClient.createClient({ fetch, throwOnError: false }) };
+}
+
+test('the escape hatch sends opts.body as the payload, and nothing else', async () => {
+  const { sent, api } = client();
+  await api.request('POST', '/x', { body: { body: 'hello' } });
+  assert.equal(sent[0].init.body, '{"body":"hello"}', 'a nested object arrives as an object');
+  await api.request('POST', '/x', { decision: 'accepted' });
+  assert.equal(sent[1].init.body, undefined, 'a payload passed as options is DROPPED — this is the trap');
+});
+
+// Every `api.request('POST'|'PATCH'|'PUT'|'DELETE', …)` in a hall-side file.
+function hallFiles() {
+  const out = [];
+  for (const mod of fs.readdirSync(path.join(ROOT, 'modules'))) {
+    const dir = path.join(ROOT, 'modules', mod, 'public');
+    if (!fs.existsSync(dir)) continue;
+    for (const f of fs.readdirSync(dir)) if (f.endsWith('.js')) out.push(path.join(dir, f));
+  }
+  return out;
+}
+
+// The top-level arguments of the call starting at `open` (the index of its "(").
+function argsAt(src, open) {
+  const args = [];
+  let depth = 0; let cur = ''; let quote = null;
+  for (let i = open + 1; i < src.length; i++) {
+    const c = src[i];
+    if (quote) { cur += c; if (c === '\\') { cur += src[++i]; } else if (c === quote) quote = null; continue; }
+    if (c === '"' || c === "'" || c === '`') { quote = c; cur += c; continue; }
+    if ('({['.includes(c)) depth++;
+    if (')}]'.includes(c)) { if (depth === 0) { args.push(cur.trim()); return args; } depth--; }
+    if (c === ',' && depth === 0) { args.push(cur.trim()); cur = ''; continue; }
+    cur += c;
+  }
+  return args;
+}
+
+// The keys of an object literal's top level: `{ a, b: 1, ...c }` → ['a', 'b', '...'].
+function topKeys(obj) {
+  const inner = obj.trim().replace(/^\{/, '').replace(/\}$/, '');
+  return argsAt(`(${inner})`, 0).filter(Boolean).map((part) => {
+    if (part.startsWith('...')) return '...';
+    const m = /^([A-Za-z_$][\w$]*)\s*(?::|$)/.exec(part);
+    return m ? m[1] : part;
+  });
+}
+
+test('no hall page hands the client a payload where it expects options', () => {
+  const bad = [];
+  let seen = 0;
+  for (const file of hallFiles()) {
+    const src = fs.readFileSync(file, 'utf8');
+    const re = /\bapi\.request\(\s*'(POST|PATCH|PUT|DELETE)'/g;
+    let m;
+    while ((m = re.exec(src))) {
+      seen++;
+      const args = argsAt(src, src.indexOf('(', m.index));
+      const where = `${path.relative(ROOT, file)}:${src.slice(0, m.index).split('\n').length}`;
+      const opts = args[2];
+      if (!opts) continue;
+      if (!opts.startsWith('{')) { bad.push(`${where} passes \`${opts}\` — wrap it as { body: … }`); continue; }
+      const unknown = topKeys(opts).filter((k) => !OPTION_KEYS.has(k));
+      if (unknown.length) bad.push(`${where} passes ${unknown.join(', ')} as options — they are dropped; nest them under body`);
+    }
+  }
+  assert.ok(seen > 10, `the scan found the calls it is guarding (${seen})`);
+  assert.deepEqual(bad, [], bad.join('\n'));
+});
+
+test('the Collab reply nests its `body` field inside the payload', () => {
+  const js = fs.readFileSync(path.join(ROOT, 'modules', 'hall-ui', 'public', 'collab.js'), 'utf8');
+  assert.match(js, /\/replies`, \{ body: \{ body: v\.body \} \}\)/, 'a bare string is refused by the server as bad_json');
+});

package/tests/hall_studio_home.mjs

@@ -130,7 +130,13 @@ function bootStudio({ answers = {}, signedIn = true } = {}) {
     execCommand() {},
   };
   const client = {
-    request: async (method, url, body) => {
+    // The real client takes an OPTIONS object and sends `opts.body` as the JSON
+    // payload (task 1004458 moved every hall write onto that shape). Record the
+    // payload, not the options, so assertions read what the server would receive.
+    request: async (method, url, opts) => {
+      // Strictly `opts.body`, like the real client: a bare payload passed as the
+      // third argument arrives as undefined, which is the dropped-payload bug 1004458 fixed.
+      const body = opts ? opts.body : undefined;
       requests.push({ method, url, body });
       const key = `${method} ${url.replace(/^\/api\/bongos/, '')}`;
       if (key === 'GET /me') return signedIn ? ok({ builder: { id: ME, display_name: 'Artist A', rank: 'metic' } }) : { ok: false, status: 401, data: {} };

package/tests/hall_studio_world.mjs

@@ -239,7 +239,11 @@ async function bootStudio({ reviews = [], shipped = {}, rank = 'metic', flags =
     return els.get(id);
   };
   const calls = [];
-  const request = async (method, url, body) => {
+  // 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 studio
+  // made — so every verdict here was green while each one sent nothing (task 1004458).
+  const request = async (method, url, opts) => {
+    const body = opts && opts.body;
     calls.push({ method, url, body });
     if (method !== 'GET') {
       const custom = onWrite && onWrite({ method, url, body });

package/tests/help_requests.mjs

@@ -276,8 +276,10 @@ test('the settle refusal no longer lets you enumerate ids', () => {
   const from = routes.indexOf("'PATCH /help-requests/:id'");
   const patch = routes.slice(from, routes.indexOf('help_request_update_failed', from));
   assert.ok(!/getHelpRequest/.test(patch), 'no existence lookup in the refusal path');
+  // One refusal per WRITE: the settle's, and since task 1004458 the reopen's.
+  // Each covers absent / not yours / wrong state in one sentence.
   const reasons = patch.match(/reason: '[^']+'/g) || [];
-  assert.equal(reasons.length, 1, `exactly one refusal reason, got ${reasons}`);
+  assert.equal(reasons.length, 2, `exactly one refusal reason per write, got ${reasons}`);
 });
 
 test('both reads are capped', () => {
@@ -504,3 +506,54 @@ test('a reply to an ask that never existed is a named 404, not an FK 500', () =>
   const line = routes.slice(routes.lastIndexOf('router.post', idx), idx);
   assert.match(line, /api\.requireBuilder/, 'signed in, like every other route here');
 });
+
+// ---- reopen (task 1004458) ------------------------------------------------
+// RUN against a recording pool, like the settle tests above: the rule is the
+// WHERE, and a source grep would agree with a WHERE that had lost a clause.
+async function reopenSql(args) {
+  const calls = [];
+  const pool = { query: async (sql, params) => { calls.push({ sql, params }); return { rows: [{ id: 1 }] }; } };
+  const row = await help.reopenHelpRequest(args, { pool });
+  return { ...calls[0], row };
+}
+
+test('only the ASKER reopens, and only a settled ask', async () => {
+  const c = await reopenSql({ id: 5, builderId: 7 });
+  const where = c.sql.slice(c.sql.indexOf('WHERE'), c.sql.indexOf('RETURNING'));
+  assert.match(where, /requested_by = \$2/, 'the asker, bound, in the WHERE');
+  assert.ok(!/needs_builder_id|needs_craft/.test(where), 'the addressee has no branch here');
+  assert.ok(!/\bOR\b/.test(where), `a pure conjunction, so no clause can be bypassed: ${where}`);
+  assert.match(where, /status <> 'open'/, 'an open ask is not reopened again');
+  assert.deepEqual(c.params, [5, 7]);
+});
+
+test('reopening clears who settled it and marks it reopened', async () => {
+  const c = await reopenSql({ id: 5, builderId: 7 });
+  assert.match(c.sql, /status = 'open'/);
+  assert.match(c.sql, /settled_by = NULL/, 'it no longer reads as closed by someone');
+  assert.match(c.sql, /settled_reason = NULL/, 'nor as closed by the ledger');
+  assert.match(c.sql, /reopened_at = now\(\)/, 'the fact the ledger settle reads to leave it alone');
+});
+
+test('a REOPENED ask is never closed again by its task having shipped', async () => {
+  const calls = [];
+  const pool = { query: async (sql) => { calls.push(sql); return { rows: [] }; } };
+  await help.settleFromLedger({ pool });
+  assert.match(calls[0], /h\.reopened_at IS NULL/, 'the asker said the shipped task did not answer it');
+});
+
+test('PATCH routes status open to the asker-only reopen, never to the settle', () => {
+  const routes = read('modules', 'lifecycle', 'routes', 'help-requests.js');
+  const idx = routes.indexOf("'PATCH /help-requests/:id'");
+  const body = routes.slice(idx, routes.indexOf('errorCode', idx));
+  assert.match(body, /enum: \['answered', 'withdrawn', 'open'\]/);
+  assert.match(body, /req\.body\.status === 'open'[\s\S]*?reopenHelpRequest\(\{ id, builderId: req\.builder\.id \}\)/,
+    'the reopen takes the caller from the session, and no crafts at all');
+  assert.ok(body.indexOf('reopenHelpRequest') < body.indexOf('setHelpRequestStatus'), 'and returns before the settle runs');
+});
+
+test('the reopen migration adds the column and alters no core table', () => {
+  const sql = read('modules', 'lifecycle', 'migrations', 'lifecycle_016_help_request_reopen.sql');
+  assert.match(sql, /ALTER TABLE lifecycle_help_requests\s+ADD COLUMN IF NOT EXISTS reopened_at timestamptz/);
+  assert.ok(!/ALTER TABLE (?!lifecycle_)/.test(sql));
+});

package/tests/projects_hub_app_step.mjs

@@ -283,6 +283,48 @@ test('Next needs a complete answer: a mode, then a start command for a native ru
   assert.equal(w.validateRender(), true, 'docker needs no commands');
 });
 
+// task 1004457 — found live: the ask stayed on screen after the command was typed.
+test('typing a start command clears the "how your app starts" ask at once', async () => {
+  const w = load({ answers: ANSWERS, draft: { appPlatform: 'render' } });
+  w.typeKey(KEY);
+  await w.check();
+  await w.pickWorkspace(0);
+  w.pickService({ value: 'new' });
+  assert.equal(w.validateRender(), false);
+  assert.match(w.$('h-render').className, /err/);
+  w.$('f-renderStart').value = '   ';
+  w.$('renderNew').fire('input', { target: w.$('f-renderStart') });
+  assert.match(w.$('h-render').textContent, /how your app starts/, 'blank is still no answer');
+  w.$('f-renderStart').value = 'npm start';
+  w.$('renderNew').fire('input', { target: w.$('f-renderStart') });
+  assert.doesNotMatch(w.$('h-render').className, /err/);
+  assert.doesNotMatch(w.$('h-render').textContent, /how your app starts/);
+});
+
+test('the empty command boxes read as examples, not as filled-in values', () => {
+  assert.match(HUB, /id="f-renderBuild"[^>]*placeholder="for example: npm ci"/);
+  assert.match(HUB, /id="f-renderStart"[^>]*placeholder="for example: npm start"/);
+});
+
+// task 1004457 — owner call 2026-09-30: offer Render's Free web plan, never preselected.
+test('Free is on the plan list with its catch spelled out, and Starter stays the default', async () => {
+  const w = load({ answers: ANSWERS, draft: { appPlatform: 'render' } });
+  w.typeKey(KEY);
+  await w.check();
+  await w.pickWorkspace(0);
+  w.pickService({ value: 'new' });
+  const opts = w.$('f-renderPlan').children;
+  assert.deepEqual(opts.map((o) => o.value), ['free', 'starter', 'standard', 'pro']);
+  assert.match(opts[0].textContent, /^Free — \$0, but it sleeps when idle/);
+  assert.equal(opts.find((o) => o.selected).value, 'starter', 'Free is never the preselected plan');
+  w.state.renderPlan = 'free'; w.state.renderStart = 'npm start';
+  assert.equal(w.renderRequestBody().web_plan, 'free');
+  const dbOpts = w.$('f-renderDbPlan').children.map((o) => o.value);
+  assert.equal(dbOpts.includes('free'), false, 'the database stays paid-only');
+  const r = load({ draft: { appPlatform: 'render', renderOwnerName: 'Mine', renderMode: 'greenfield', renderRuntime: 'node', renderPlan: 'free' } });
+  assert.equal(r.appRow(), 'Render, workspace Mine — a new app (Node.js, Free, $0, but it sleeps when idle and takes about a minute to wake up), no database. Render bills you directly.');
+});
+
 test('what Create sends: greenfield carries the build and the plans, a link only the service', async () => {
   const w = load({ answers: ANSWERS, draft: { appPlatform: 'render' } });
   w.typeKey(KEY);

package/tests/provisioning_render_route.mjs

@@ -116,6 +116,13 @@ await ta('a missing project is 404', async () => {
   assert.equal((await post(PATH, GREEN)).status, 404);
 });
 
+await ta('Render\'s Free web plan is accepted and recorded (task 1004457)', async () => {
+  reset();
+  const r = await post(PATH, { ...GREEN, web_plan: 'free' });
+  assert.equal(r.status, 200, r.raw);
+  assert.equal(enqueueCalls[0].appHost.webPlan, 'free');
+});
+
 console.log('\nthe shape is checked first:');
 for (const [name, body, re] of [
   ['a key that is not a Render key', { ...GREEN, key: 'ghp_notrender' }, /Render API key/],