@bongos/core 1.21.113 → 1.21.115

package/package.json

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

@@ -9536,5 +9536,133 @@
       "id": "1004679",
       "text": "When a project turns automatic pickup on, the background runner now picks up the oldest page an artist submitted and applies it, before its other work, then leaves it waiting for the artist. It stops at the monthly limit, leav"
     }
+  ],
+  "1.21.114": [
+    {
+      "id": "1004722",
+      "text": "New core releases can be cut again. Since the living-city prototype merged, every merge to main failed its release check, so no new core version went out and cloudbongos.com stayed on an old build. The cause was one security t"
+    },
+    {
+      "id": "1004728",
+      "text": "Shipping work from a project that keeps its Bongos core in a downloaded package no longer gets stuck at the final merge step."
+    },
+    {
+      "id": "1004702",
+      "text": "Decisions now open as light glass panels right where they belong, built to the mocks you approved. The deck no longer hides the street: each question sits beside the building that asks, with a thin line to its pin, the rest of"
+    },
+    {
+      "id": "1002846",
+      "text": "The ship-news channel is back on: it now gets one plain headline for each new feature or bug fix, while the builders' ship-feed keeps logging every ship."
+    },
+    {
+      "id": "1004260",
+      "text": "When you make your account private or hide your numbers, your account page now tells you that your guilds still count your numbers in their rounded totals, and links to each guild's page where you can switch that off."
+    },
+    {
+      "id": "1004673",
+      "text": "When a project's owner reviews people asking to join, a confirmed applicant's platform name now shows even if the platform is down, and the Discord approval prompt is re-posted with the real applicant's words when they take ov"
+    },
+    {
+      "id": "1003649",
+      "text": "The landing's dark mode now loads its chrome artwork about 200 KB lighter (447 KB down to 247 KB on first paint) with no visible change, so the page appears faster on slow connections."
+    },
+    {
+      "id": "1003639",
+      "text": "The onboarding diagrams now match the builders' hall in dark mode instead of sitting there as a bright white box, and they still look the same in light mode."
+    },
+    {
+      "id": "1002536",
+      "text": "Builders get a new #ai-news Discord channel for AI-tooling news from a short, curated list of feeds, at no running cost to us. An Archon switches it on by following the new setup guide."
+    },
+    {
+      "id": "1003645",
+      "text": "A check in the project page's test kit now really proves that \"Let the platform choose again\" resets a project's planet, instead of passing either way."
+    },
+    {
+      "id": "1004279",
+      "text": "On a project's hall, your profile's Connections tab now shows only the people you're connected with who also build on that project. Your requests and everyone else are one click away on your Connections page on the hub."
+    },
+    {
+      "id": "1004278",
+      "text": "You can now manage your connections on cloudbongos.com: a new Connections page (in your profile menu) shows who wants to connect, the builders you know across every project, and builders you may know, and lets you ask anyone b"
+    },
+    {
+      "id": "1004590",
+      "text": "The Projects menu now says \"Your projects: the ones you own\". The projects you help build moved to your Account page, so the old \"own or build on\" was only half true."
+    },
+    {
+      "id": "1004720",
+      "text": "The guide to your project's government now tells the whole story in plain words. It opens with the idea behind it: government is how a project steers its AI. A one-minute overview names the five parts: laws (the standing order"
+    },
+    {
+      "id": "1004719",
+      "text": "The government walk now proves the new government end to end: 169 checks, all passing, up from 123. It goes through the real routes for laws (passed by a vote, handed to every AI session, a locked setting refused and read back"
+    },
+    {
+      "id": "1004718",
+      "text": "The street and the city got their polish pass. On a wide screen the street now sits right on its six readings with no empty black sky above the skyline. Inside a building, the floor you pick is drawn in ink, not salmon, so sal"
+    },
+    {
+      "id": "1004717",
+      "text": "The city and the street now run on your project's real government only. The sample data the prototype leaned on is deleted: no invented Leads, laws, pots, building work or reworded questions, and no \"prototype\" tags or keys an"
+    },
+    {
+      "id": "1004716",
+      "text": "The government numbers now come from one place on the server. \"To do\", \"wait on others\", \"to decide\", \"agents working\" and \"moving\" are counted once by a new server read, and the city, the street header, the decision deck and"
+    },
+    {
+      "id": "1004715",
+      "text": "Strictness presets are real. A project can now pick how strict its AI agents run: Open workshop (one law: land only, going live waits for a person), Guild (the standard set: also \"stuck? note it and move on\" and agents stay on"
+    },
+    {
+      "id": "1004714",
+      "text": "When an AI agent needs a person to decide something, it now has to ask like a person: one short question, two or three answers to tap, its pick and why, who it waits on, and what happens if nobody answers. The server refuses a"
+    },
+    {
+      "id": "1004712",
+      "text": "The treasury is real. Whoever runs the Treasury (its Lead, or you while it has none) can give a goal a monthly pot. Each pot fills from the project's real AI spend on that goal's work this month. The reserve is last month's sp"
+    },
+    {
+      "id": "1004711",
+      "text": "Whoever holds a building (its Lead, or the owner when it has none) can now really grow it: a committee room, a new floor, an annex, or a district. If the form of government allows it, it goes up at once and the city shows scaf"
+    },
+    {
+      "id": "1004713",
+      "text": "Governing is now a seat you hold, not a craft you pick. The server works out which government seats each builder holds: the owner seat, a building Lead, a seat on a building's own sitting, or a board seat. It sends that list w"
+    },
+    {
+      "id": "1004705",
+      "text": "Every question an agent puts to a person now waits on a real seat. The server decides who each open matter is for: the building's Lead if it has one, the owner when it has none, the voters for a board vote, or whoever the agen"
+    },
+    {
+      "id": "1004710",
+      "text": "Whether a building can be built out without a vote now comes from your form of government, not from anything a Lead's charter says. Under a Monarchy whoever holds a building builds a room, floor or annex at once; under a Timoc"
+    },
+    {
+      "id": "1004709",
+      "text": "Each of the nine buildings in your project's city can now have a real Lead: one person in charge, with a one-line charter saying what they answer for. A Lead is appointed, replaced or removed only by a vote (a People matter)."
+    },
+    {
+      "id": "1004704",
+      "text": "AI agents now have to ask you things the way a person would. When an agent files something that is stuck on you, it must send a short card: one question of twelve words or fewer, two or three answers to tap, the answer it reco"
+    },
+    {
+      "id": "1004707",
+      "text": "Every AI session on your project now reads the project's laws first, before anyone's own settings. The server writes the words, so nobody's local files can change or drop them, and passing or repealing a law changes what the n"
+    },
+    {
+      "id": "1004706",
+      "text": "Your project can now have laws: short one-line rules every AI agent follows, like \"Ask like a human\". A law can also lock a personal setting it overrides. Laws change only the way the constitution does: someone proposes one (o"
+    },
+    {
+      "id": "1004701",
+      "text": "The living city is now the hall's base: the city, the street with depth, the decision deck, the government inside each building, and My agents. On a real project it shows only what the real data supports: no invented Leads, la"
+    }
+  ],
+  "1.21.115": [
+    {
+      "id": "1004671",
+      "text": "When you start a new project, \"Where are you?\" now starts on United States and is a search box instead of a long dropdown. Type a few letters and the list narrows to matching countries; capitals and accents don't matter, so \"c"
+    }
   ]
 }

package/scripts/discord/README.md

@@ -45,8 +45,11 @@ node scripts/discord/post.js --channel ship_feed "shipped #607"        # -> #shi
 echo "hello team" | node scripts/discord/post.js
 ```
 
-`scripts/gds/ship.js` calls this automatically with the task `--summary` once a
-ship is live on the droplet. The call is best-effort: a Discord failure logs a
-warning and never blocks the deploy. The broadcast runs on the operator's
-machine during `/builder-ship`, so the secret only needs to exist locally — the
-droplet never needs the webhook URL.
+Ship announcements do **not** come through this CLI any more (task 1749): the
+server posts them once the deploy lands, from
+`modules/discord/ship-broadcast.js` — every ship to `#ship-feed`, and a plain
+headline to `#ship-news` only for a feature or a bug fix (task 1002846). This
+CLI carries the project's other news, which defaults to `#ship-news` (a builder
+graduating, a rank change, an outage heads-up); builder housekeeping passes
+`--channel ship_feed`. Every call is best-effort: a Discord failure logs a
+warning and never blocks anything.

package/scripts/discord/post.js

@@ -9,7 +9,18 @@
 //
 // Default channel: ship_news — the plain-language, business-facing feed that
 // replaced the Google Chat broadcast. Exits non-zero on failure so callers can
-// treat the post as best-effort (ship.js does).
+// treat the post as best-effort.
+//
+// The default stays ship_news on purpose (task 1002846). SHIP announcements
+// never pass through here: the server posts them from
+// modules/discord/ship-broadcast.js, whose kind filter decides which ships are
+// news. What does pass through here is the project's own news in plain words,
+// which is what #ship-news promises: a builder graduating
+// (modules/onboarding/onboarding-state.js), a rank change
+// (src/bongos/routes/builders.js), an outage heads-up
+// (modules/provisioning/pollers/liveness-notify.js) and the style-guide audit
+// (scripts/cron/style_guide_audit.sh). Builder housekeeping names its channel:
+// scripts/gds/pulse.js's reclaim nudge passes --channel ship_feed.
 
 const fs = require('node:fs');
 const { postWebhook } = require('./lib');

package/scripts/gds/artifact-audit.js

@@ -55,6 +55,7 @@
 const { execFileSync } = require('node:child_process');
 const { apiCall, arg, hasFlag } = require('./cli-lib');
 const { TASK_LIST_MAX_LIMIT, buildTaskPageQuery } = require('../../modules/lifecycle/task-list-limits.js');
+const { postWithAsk } = require('./ask.js');
 
 // The statuses where a claimed artifact is supposed to already exist. `shipped` is the one the
 // reconciler never revisits, and the reason this file exists.
@@ -172,7 +173,7 @@ module.exports = {
   auditArtifacts, declaresArtifact, taskIdsIn,
   AUDITED_STATUSES, ASSURANCE_GATE_DATE, TASK_REF,
   messageEvidence, contentEvidence, fetchAuditedTasks,
-  blockerSourceRef, blockerBody, fileBlocker,
+  blockerSourceRef, blockerBody, blockerAsk, fileBlocker,
 };
 
 // ---- the human surface ------------------------------------------------------------------
@@ -206,14 +207,30 @@ function blockerBody(stranded) {
   return lines.join('\n');
 }
 
+// The card a person answers (task 1004704): the finding as an ask, short enough
+// to decide at a glance; the body above carries the list.
+function blockerAsk(stranded) {
+  const n = stranded.length;
+  return {
+    question: `Check by hand the ${n} shipped task${n === 1 ? '' : 's'} nothing on main names?`,
+    options: [
+      { key: 'check', label: 'Check each', result: 'Someone reads each by hand before anything is reopened.', act: 'go ahead' },
+      { key: 'accept', label: 'Accept them', result: 'They stay shipped and credited as they are.', act: 'not now' },
+    ],
+    recommend: { key: 'check', why: 'A credited task with no code may be paid work that does not exist.' },
+    waits_on: 'lead:review',
+    if_nobody_answers: 'They stay shipped and credited, unchecked.',
+  };
+}
+
 async function fileBlocker(stranded, { call = apiCall } = {}) {
   if (!stranded.length) return { filed: false, reason: 'nothing to report' };
-  const r = await call('POST', '/api/bongos/blockers', {
+  const r = await postWithAsk((body) => call('POST', '/api/bongos/blockers', body), {
     title: `${stranded.length} shipped task(s) claim an artifact nothing on main names`,
     body_md: blockerBody(stranded),
     source: 'artifact-audit',
     source_ref: blockerSourceRef(stranded),
-  });
+  }, blockerAsk(stranded));
   if (!r || !r.ok) return { filed: false, reason: `POST /blockers → ${r && r.status}` };
   if (r.data && r.data.skipped) return { filed: false, reason: 'already filed for this exact finding set' };
   return { filed: true, id: r.data && r.data.blocker && r.data.blocker.id };

package/scripts/gds/ask.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+'use strict';
+//
+// scripts/gds/ask.js — the rewrite helper an agent runs BEFORE it asks a person
+// anything (task 1004704, goal 1000111: "agents must ask like humans").
+//
+// WHY. The owner's ruling: an AI agent asks a person the way a person would —
+// short, decidable, no slop. The shape is the ask (modules/government/asks.js,
+// task 1004703): one question of at most twelve words, two or three tap answers
+// each with a one-line result, a pick and why, the seat it waits on, what
+// happens if nobody answers; the long text rides along as `detail`. The server
+// refuses anything else, and a blocker an AI session files by hand without one
+// is refused too (`ask_required`). This helper is the loop that turns prose into
+// a card: write the card, check it, read every fix the server names, rewrite,
+// check again — and only then file it, or print it.
+//
+//   node scripts/gds/ask.js template            a blank card to fill in
+//   node scripts/gds/ask.js check <file|->      the server's verdict; on a pass,
+//                                               the card as a person reads it
+//
+// `check` asks the server (POST /government/asks/check, the dry run: nothing is
+// stored). With no session, or a server that cannot answer, it checks with the
+// same rules locally and says so. The file holds the ask bare or as { ask }, so
+// the body you will POST to /blockers can be checked as it is.
+//
+// The printed card is also what an agent puts in CHAT for an ask that is not a
+// stored matter: the "please confirm" list at the end of a run, a review
+// request, a help request. Same shape everywhere a person reads it.
+//
+// For scripts that file templated blockers: `checkedAsk` and `postWithAsk`
+// below. A templated card is checked here before it is sent, and a filing whose
+// card is refused is re-sent without it — a script's blocker always files.
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const asks = require(path.join(__dirname, '..', '..', 'modules', 'government', 'asks.js'));
+
+const TEMPLATE = Object.freeze({
+  question: 'One question, twelve words at most?',
+  options: [
+    { key: 'yes', label: 'Do it', result: 'One line: what happens if they pick this.' },
+    { key: 'no', label: 'Leave it', result: 'One line: what happens if they pick this.' },
+  ],
+  recommend: { key: 'yes', why: 'One line: why you would pick it.' },
+  waits_on: 'owner',
+  if_nobody_answers: 'One line: what happens if nobody answers.',
+  detail: 'Optional. The long text rides along here; it is never the ask.',
+});
+
+// The ask in a body: bare, or as { ask } (the shape POST /blockers takes).
+function askOf(body) {
+  return body && typeof body === 'object' && !Array.isArray(body) && body.ask !== undefined ? body.ask : body;
+}
+
+// A templated card, checked with the server's own rules. → the stored form, or
+// null when it breaks a rule (the caller files without it rather than not at all).
+function checkedAsk(ask) {
+  const r = asks.checkAsk(ask);
+  return r.ok ? r.ask : null;
+}
+
+// File a blocker with its card. `post(body)` → { ok, status, data } (the shape
+// cli-lib's apiCall and the generated client both answer). A card that breaks a
+// rule is never sent; a server that refuses the card or cannot check it gets the
+// same blocker again without it, so the filing never depends on the card.
+const CARD_REFUSALS = new Set(['ask_refused', 'asks_unavailable', 'validation_failed']);
+async function postWithAsk(post, body, ask) {
+  const card = ask ? checkedAsk(ask) : null;
+  if (!card) return post(body);
+  const r = await post({ ...body, ask: card });
+  const code = r && r.data && r.data.error && r.data.error.code;
+  if (r && !r.ok && (r.status === 400 || r.status === 503) && CARD_REFUSALS.has(code)) return post(body);
+  return r;
+}
+
+// The verdict as plain lines. ok → the card; refused → the refusal and each fix.
+function verdictLines({ ok, ask, message, errors, where }) {
+  const out = [];
+  if (ok) {
+    out.push(`✓ This ask has the shape${where === 'local' ? ' (checked here; the server could not be asked)' : ''}. As a person reads it:`);
+    out.push('');
+    out.push(asks.cardText(ask));
+    return out;
+  }
+  out.push(`✗ ${message || asks.refusalLine(errors)}`);
+  if (where === 'local') out.push('  (checked here; the server could not be asked)');
+  const list = Array.isArray(errors) ? errors : [];
+  if (list.length) {
+    out.push('');
+    out.push('Fix each, then check again:');
+    for (const e of list) out.push(`  - ${e.field}: ${e.message}`);
+  }
+  return out;
+}
+
+function readJson(file) {
+  const raw = file === '-' ? fs.readFileSync(0, 'utf8') : fs.readFileSync(file, 'utf8');
+  return JSON.parse(raw.replace(/^/, ''));
+}
+
+// The server's verdict, or null when it could not give one (no session, offline,
+// no government module, not allowed) — the caller then checks locally.
+async function serverVerdict(ask, { client } = {}) {
+  let api = client;
+  try {
+    if (!api) {
+      const lib = require('./cli-lib');
+      if (!lib.readSessionToken()) return null;
+      api = await lib.cliClient({ allowUnauthenticated: true });
+    }
+    const r = await api.request('POST', '/government/asks/check', { body: { ask } });
+    if (r && r.ok && r.data && r.data.ok) return { ok: true, ask: r.data.ask, where: 'server' };
+    const err = r && r.data && r.data.error;
+    if (r && r.status === 400 && err && err.code === 'ask_refused') {
+      return { ok: false, message: err.message, errors: (err.details && err.details.errors) || [], where: 'server' };
+    }
+    return null;
+  } catch (_) {
+    return null;
+  }
+}
+
+async function check(file, deps = {}) {
+  let body;
+  try { body = readJson(file); } catch (e) {
+    return { code: 2, lines: [`ask: could not read the card as JSON (${e.message}). Start from: node scripts/gds/ask.js template`] };
+  }
+  const ask = askOf(body);
+  let v = deps.local ? null : await serverVerdict(ask, deps);
+  if (!v) {
+    const r = asks.checkAsk(ask);
+    v = { ok: r.ok, ask: r.ask, errors: r.errors, where: 'local' };
+  }
+  return { code: v.ok ? 0 : 1, lines: verdictLines(v) };
+}
+
+const USAGE = [
+  'usage:',
+  '  node scripts/gds/ask.js template          print a blank card to fill in',
+  '  node scripts/gds/ask.js check <file|->    check a card; on a pass, print it as a person reads it',
+  '      --local                               check with the rules here, without the server',
+].join('\n');
+
+async function main(argv = process.argv.slice(2)) {
+  const cmd = argv[0];
+  if (cmd === 'template') {
+    console.log(JSON.stringify(TEMPLATE, null, 2));
+    return 0;
+  }
+  if (cmd === 'check' && argv[1]) {
+    const r = await check(argv[1], { local: argv.includes('--local') });
+    console.log(r.lines.join('\n'));
+    return r.code;
+  }
+  console.error(USAGE);
+  return 2;
+}
+
+if (require.main === module) {
+  main().then((code) => { process.exitCode = code; }, (e) => { console.error(`ask: ${e && e.message}`); process.exitCode = 1; });
+}
+
+module.exports = { TEMPLATE, askOf, checkedAsk, postWithAsk, verdictLines, serverVerdict, check, main };

package/scripts/gds/autobongos-verify.js

@@ -39,6 +39,7 @@ const path = require('node:path');
 const { execFile } = require('node:child_process');
 
 const { classifyStrand, WATCHED } = require('./strand-watch.js');
+const { postWithAsk } = require('./ask.js');
 
 // failureReason — what a failed child process said, fit for one run-log field
 // (task 1004180).
@@ -264,6 +265,23 @@ function blockerFor(v, { taskId, taskTitle = null, worker = null } = {}) {
     body_md: lines.join('\n'),
     source: 'autobongos',
     source_ref: `task-${taskId}-${v.shape}`,
+    ask: blockerAsk(v, { taskId }),
+  };
+}
+
+// The card a person answers (task 1004704): the shape as one decidable question.
+// fileBlocker sends it beside the row and files without it if it is refused.
+function blockerAsk(v, { taskId }) {
+  const shape = String((v && v.shape) || 'unfinished').replace(/_/g, ' ');
+  return {
+    question: `Requeue task ${taskId}, which came back ${shape}?`,
+    options: [
+      { key: 'requeue', label: 'Requeue it', result: 'The blocker closes and a runner may pick it up again.', act: 'go ahead' },
+      { key: 'keep', label: 'Keep it out', result: 'It stays out of the pool until someone looks.', act: 'not now' },
+    ],
+    recommend: { key: 'keep', why: 'Read the run log first; a second run may fail the same way.' },
+    waits_on: 'lead:automation',
+    if_nobody_answers: 'The task stays out of the pool.',
   };
 }
 
@@ -351,7 +369,8 @@ async function fetchTask(api, taskId) {
 async function fileBlocker(api, row, { taskId, link }) {
   let created = null;
   try {
-    const r = await api.blockers.postBlockers({ body: row });
+    const { ask, ...body } = row;
+    const r = await postWithAsk((b) => api.blockers.postBlockers({ body: b }), body, ask);
     if (!r || !r.ok) return { filed: false, reason: `POST /blockers → ${r ? r.status : 'no response'}`, linked: false };
     if (r.data && r.data.skipped) return { filed: false, duplicate: true, reason: 'this task already carries a blocker of this shape', linked: false };
     created = r.data && r.data.blocker;
@@ -594,6 +613,6 @@ if (require.main === module) {
 }
 
 module.exports = {
-  classifyLedger, blockerFor, probeArtifact, fileBlocker, verifyShip, failureReason,
+  classifyLedger, blockerFor, blockerAsk, probeArtifact, fileBlocker, verifyShip, failureReason,
   LAND_GRACE_MS, namesTask, pendingLandIds, recheckLands,
 };