@bongos/core 1.25.11 → 1.25.12

package/modules/front-door-guide/migrations/front_door_guide_001_conversations.sql

@@ -0,0 +1,48 @@
+-- front_door_guide_001_conversations.sql — the start-a-project guide's conversations
+-- and its spend ledger (task 1005272).
+--
+--   front_door_guide_conversations  one signed-out visitor's chat: the transcript, how
+--                                   many messages they sent, what it cost, and whether
+--                                   it has ended. The visitor proves it is theirs with a
+--                                   random token; only its SHA-256 is stored.
+--   front_door_guide_calls          one row per Claude call, with the API's own usage
+--                                   numbers and the price in micro-dollars. The daily,
+--                                   monthly and per-visitor caps are sums over it.
+--
+-- No raw IP address is stored: `visitor_hash` is a salted hash of it.
+
+CREATE TABLE IF NOT EXISTS front_door_guide_conversations (
+  id                BIGSERIAL   PRIMARY KEY,
+  token_hash        TEXT        NOT NULL UNIQUE,
+  visitor_hash      TEXT        NOT NULL,
+  messages          JSONB       NOT NULL DEFAULT '[]'::jsonb,
+  visitor_messages  INTEGER     NOT NULL DEFAULT 0,
+  spend_micro       BIGINT      NOT NULL DEFAULT 0,
+  status            TEXT        NOT NULL DEFAULT 'open',
+  end_reason        TEXT,
+  created_at        TIMESTAMPTZ NOT NULL DEFAULT now(),
+  updated_at        TIMESTAMPTZ NOT NULL DEFAULT now(),
+  CONSTRAINT front_door_guide_conversations_status_chk CHECK (status IN ('open', 'ended')),
+  CONSTRAINT front_door_guide_conversations_money_chk CHECK (spend_micro >= 0 AND visitor_messages >= 0)
+);
+
+CREATE INDEX IF NOT EXISTS front_door_guide_conversations_visitor_idx
+  ON front_door_guide_conversations (visitor_hash, created_at DESC);
+
+CREATE TABLE IF NOT EXISTS front_door_guide_calls (
+  id                  BIGSERIAL   PRIMARY KEY,
+  conversation_id     BIGINT      NOT NULL REFERENCES front_door_guide_conversations(id) ON DELETE CASCADE,
+  visitor_hash        TEXT        NOT NULL,
+  model               TEXT        NOT NULL,
+  input_tokens        INTEGER     NOT NULL DEFAULT 0,
+  output_tokens       INTEGER     NOT NULL DEFAULT 0,
+  cache_read_tokens   INTEGER     NOT NULL DEFAULT 0,
+  cache_write_tokens  INTEGER     NOT NULL DEFAULT 0,
+  cost_micro          BIGINT      NOT NULL,
+  stop_reason         TEXT,
+  created_at          TIMESTAMPTZ NOT NULL DEFAULT now(),
+  CONSTRAINT front_door_guide_calls_cost_chk CHECK (cost_micro >= 0)
+);
+
+CREATE INDEX IF NOT EXISTS front_door_guide_calls_created_idx ON front_door_guide_calls (created_at);
+CREATE INDEX IF NOT EXISTS front_door_guide_calls_visitor_idx ON front_door_guide_calls (visitor_hash, created_at);

package/modules/front-door-guide/module.json

@@ -0,0 +1,27 @@
+{
+  "key": "front-door-guide",
+  "title": "Start-a-project guide",
+  "description": "A signed-out visitor who presses start a project talks with an AI guide about what they want to build, for a few capped messages, before signing up (task 1005272, goal 1000106). Runs on the platform's own Anthropic key read from the environment; every cap is enforced on the server (messages and spend per visitor, a daily and a monthly site budget, message length, rate limits, a bot check), and a spent budget or a missing key answers with the plain form instead of an error. default:false: the hub turns it on.",
+  "version": "1.0.0",
+  "coreVersion": "^1.19.0",
+  "category": {
+    "parent": "pages"
+  },
+  "author": "Cloud Bongos LLC",
+  "origin": "Cloud Bongos (cloudbongos.com)",
+  "license": "AGPL-3.0",
+  "maintainer": "Cloud Bongos maintainers",
+  "default": false,
+  "maintenance": {
+    "status": "maintained"
+  },
+  "migrations": true,
+  "contributes": {
+    "routes": [
+      "front-door-guide"
+    ]
+  },
+  "provides": [],
+  "consumes": [],
+  "dependencies": { "@anthropic-ai/sdk": "^0.131.0" }
+}

package/modules/front-door-guide/routes/front-door-guide.js

@@ -0,0 +1,206 @@
+// modules/front-door-guide/routes/front-door-guide.js — the start-a-project guide's HTTP
+// surface (task 1005272). A signed-out visitor talks with an AI guide about what they
+// want to build before signing up.
+//
+//   GET  /front-door-guide/status                     can the guide talk right now
+//   POST /front-door-guide/conversations              start a chat       { website? }
+//   POST /front-door-guide/conversations/:id/messages send one message   { token, text, website? }
+//   GET  /front-door-guide/conversations/:id          read it back       header x-guide-token
+//
+// rank: public — every route. The visitor has no account yet; that is the point. What
+// stands in for one: per-visitor rate limits, a bot check, a token per conversation, and
+// every money cap enforced here before a call is made (the per-visitor message count and
+// spend, the site's daily and monthly budget). A spent budget or a missing key answers
+// `mode: 'form'`, never an error, so the front end always has somewhere to send the
+// visitor. The response shape is documented in ../CLAUDE.md.
+//
+// The visitor's words are never logged.
+
+'use strict';
+
+const express = require('express');
+const api = require('../../../src/module-api');
+const G = require('../guide');
+const db = require('../db');
+const claude = require('../claude');
+const { readSettings } = require('../settings');
+const L = require('../limits');
+
+const log = api.logger('front-door-guide');
+const ID_RE = /^\d{1,18}$/;
+const TOKEN_RE = /^[A-Za-z0-9_-]{16,64}$/;
+
+function salt() {
+  let s;
+  try { s = api.resolveEnv('FRONT_DOOR_GUIDE_SALT'); } catch (_) { s = null; }
+  if (s) return s;
+  let name = 'bongos';
+  try { name = api.instanceDbName() || name; } catch (_) { /* the default salt still separates visitors */ }
+  return `front-door-guide:${name}`;
+}
+
+function productName() {
+  try { return api.branding().identity.productName || 'Cloud Bongos'; } catch (_) { return 'Cloud Bongos'; }
+}
+
+// Can the site afford a call of `extraMicro` right now? → null, or the form reason.
+async function siteBudgetReason(settings, extraMicro, reservations) {
+  const pending = reservations.siteMicro();
+  // Spent is spent (>=), and a call must also fit in what is left (>).
+  const over = (spent, cap) => spent + pending >= cap || spent + pending + extraMicro > cap;
+  if (over(await db.siteSpendMicro('day'), settings.dailyBudgetMicro)) return 'daily_budget';
+  if (over(await db.siteSpendMicro('month'), settings.monthlyBudgetMicro)) return 'monthly_budget';
+  return null;
+}
+
+module.exports = function buildFrontDoorGuideRouter() {
+  const router = express.Router();
+  const reservations = L.makeReservations();
+  let current = readSettings();
+  const knobs = () => current;
+
+  const statusLimit = L.makeLimiter({ windowMs: 60_000, max: () => 60, scope: 'front-door-guide-read' });
+  const startLimit = L.makeLimiter({ windowMs: 3_600_000, max: () => knobs().startsPerHour, scope: 'front-door-guide-start' });
+  const messageLimit = L.makeLimiter({ windowMs: 60_000, max: () => knobs().messagesPerMinute, scope: 'front-door-guide-message' });
+  // Settings are re-read on every request, so an owner's change applies without a restart.
+  const fresh = (req, res, next) => { current = readSettings(); next(); };
+
+  // rank: public — the landing asks before it offers the chat.
+  router.get('/front-door-guide/status', fresh, statusLimit, api.asyncHandler('GET /front-door-guide/status', async (req, res) => {
+    const s = knobs();
+    const reason = !s.apiKey ? 'no_key' : await siteBudgetReason(s, 0, reservations);
+    res.json({
+      ok: true,
+      mode: reason ? 'form' : 'chat',
+      ...(reason ? { reason, message: G.FORM_REASONS[reason] } : {}),
+      limits: { max_messages: s.maxMessages, max_message_chars: s.maxMessageChars },
+    });
+  }));
+
+  // rank: public — start a chat. Answers the greeting and the conversation's token.
+  router.post('/front-door-guide/conversations', fresh, startLimit, api.asyncHandler('POST /front-door-guide/conversations', async (req, res) => {
+    if (api.validateOrRespond(req, res, { website: { type: 'string', maxLength: 500 } })) return;
+    const s = knobs();
+    const body = req.body || {};
+    if (G.botCheck({ body, userAgent: req.get('user-agent'), now: Date.now(), minFirstMessageMs: s.minFirstMessageMs })) {
+      return res.json(G.formAnswer('check_failed'));
+    }
+    if (!s.apiKey) return res.json(G.formAnswer('no_key'));
+    const budget = await siteBudgetReason(s, 0, reservations);
+    if (budget) return res.json(G.formAnswer(budget));
+    const visitor = L.visitorHash(L.clientIp(req), salt());
+    const used = await db.visitorUsage(visitor);
+    if (used.messages >= s.maxMessages || used.spendMicro >= s.visitorCapMicro) return res.json(G.formAnswer('visitor_limit'));
+    const token = L.newToken();
+    const conv = await db.createConversation(L.tokenHash(token), visitor);
+    res.status(201).json({
+      ok: true, mode: 'chat',
+      conversation: { ...G.conversationView(conv, s), token },
+      greeting: G.GREETING,
+    });
+  }));
+
+  // rank: public — one visitor message, one guide reply.
+  router.post('/front-door-guide/conversations/:id/messages', fresh, messageLimit, api.asyncHandler('POST /front-door-guide/conversations/:id/messages', async (req, res) => {
+    // The schema's ceiling on `text` is loose on purpose: the owner's own length limit is
+    // checked below, so a visitor hears `too_long` with the number, not a generic refusal.
+    if (api.validateOrRespond(req, res, {
+      token: { required: true, type: 'string', maxLength: 64 },
+      text: { required: true, type: 'string', maxLength: 100_000 },
+      website: { type: 'string', maxLength: 500 },
+    })) return;
+    const s = knobs();
+    const body = req.body || {};
+    if (!ID_RE.test(String(req.params.id)) || typeof body.token !== 'string' || !TOKEN_RE.test(body.token)) {
+      return res.status(400).json({ ok: false, error: 'bad_request' });
+    }
+    if (typeof body.text !== 'string' || !body.text.trim()) return res.status(400).json({ ok: false, error: 'empty' });
+    const text = body.text.trim();
+    if (text.length > s.maxMessageChars) {
+      return res.status(400).json({ ok: false, error: 'too_long', max_message_chars: s.maxMessageChars });
+    }
+    const conv = await db.getConversation(req.params.id, L.tokenHash(body.token));
+    if (!conv) return res.status(404).json({ ok: false, error: 'not_found' });
+    const view = () => G.conversationView(conv, s);
+    const ended = (reason) => ({ ok: true, mode: 'ended', reason, message: G.END_REASONS[reason] || G.END_REASONS.message_cap, conversation: view() });
+    if (conv.status === 'ended') return res.json(ended(conv.end_reason));
+
+    const bot = G.botCheck({
+      body, userAgent: req.get('user-agent'), now: Date.now(), minFirstMessageMs: s.minFirstMessageMs,
+      startedAt: new Date(conv.created_at).getTime(), firstMessage: Number(conv.visitor_messages) === 0,
+    });
+    if (bot) return res.json(G.formAnswer('check_failed'));
+    if (!s.apiKey) return res.json(G.formAnswer('no_key'));
+
+    // The visitor's caps count every chat they started today, not just this one.
+    const visitor = conv.visitor_hash;
+    if (reservations.busy(visitor)) return res.status(429).json({ ok: false, error: 'busy', retry_after_seconds: 2 });
+    const used = await db.visitorUsage(visitor);
+    if (used.messages >= s.maxMessages || Number(conv.visitor_messages) >= s.maxMessages) {
+      await db.endConversation(conv.id, 'message_cap');
+      return res.json(ended('message_cap'));
+    }
+
+    const system = G.systemPrompt(productName());
+    const messages = [...(conv.messages || []), { role: 'user', content: text }];
+    const estimate = G.estimateMicro({ model: s.model, system, messages, maxReplyTokens: s.maxReplyTokens });
+    if (used.spendMicro + estimate > s.visitorCapMicro) {
+      await db.endConversation(conv.id, 'visitor_budget');
+      return res.json(ended('visitor_budget'));
+    }
+    const budget = await siteBudgetReason(s, estimate, reservations);
+    if (budget) return res.json(G.formAnswer(budget));
+
+    const release = reservations.take(visitor, estimate);
+    if (!release) return res.status(429).json({ ok: false, error: 'busy', retry_after_seconds: 2 });
+    let result;
+    try {
+      result = await claude.askGuide({ client: claude.createClient(s.apiKey), settings: s, system, messages });
+    } finally {
+      release();
+    }
+    if (!result.ok) {
+      log.warn({ conversation_id: String(conv.id), error: result.error }, 'front-door-guide: call failed');
+      return res.json(G.formAnswer('unavailable'));
+    }
+
+    const cost = G.costMicro(result.model, result.usage);
+    const refused = result.stopReason === 'refusal';
+    const reply = refused ? G.REFUSAL_REPLY : (G.replyText(result.content) || G.EMPTY_REPLY);
+    // A declined message is not sent again on the next turn, or it would be declined again.
+    const kept = refused ? [...(conv.messages || []), { role: 'user', content: '(The visitor\'s message was declined.)' }] : messages;
+    const nextMessages = [...kept, { role: 'assistant', content: reply }];
+    let endReason = null;
+    if (Number(conv.visitor_messages) + 1 >= s.maxMessages || used.messages + 1 >= s.maxMessages) endReason = 'message_cap';
+    else if (used.spendMicro + cost >= s.visitorCapMicro) endReason = 'visitor_budget';
+    const u = result.usage || {};
+    const saved = await db.recordTurn(conv.id, { messages: nextMessages, status: endReason ? 'ended' : 'open', endReason }, {
+      visitorHash: visitor, model: result.model, costMicro: cost, stopReason: result.stopReason || null,
+      inputTokens: Number(u.input_tokens) || 0, outputTokens: Number(u.output_tokens) || 0,
+      cacheReadTokens: Number(u.cache_read_input_tokens) || 0, cacheWriteTokens: Number(u.cache_creation_input_tokens) || 0,
+    });
+    res.json({
+      ok: true,
+      mode: endReason ? 'ended' : 'chat',
+      ...(endReason ? { reason: endReason, message: G.END_REASONS[endReason] } : {}),
+      ...(refused ? { declined: true } : {}),
+      reply: { text: reply },
+      conversation: G.conversationView(saved || { ...conv, visitor_messages: Number(conv.visitor_messages) + 1 }, s),
+    });
+  }));
+
+  // rank: public — the transcript, for the plan and the sign-up hand-off.
+  router.get('/front-door-guide/conversations/:id', fresh, statusLimit, api.asyncHandler('GET /front-door-guide/conversations/:id', async (req, res) => {
+    const token = String(req.get('x-guide-token') || '');
+    if (!ID_RE.test(String(req.params.id)) || !TOKEN_RE.test(token)) return res.status(400).json({ ok: false, error: 'bad_request' });
+    const conv = await db.getConversation(req.params.id, L.tokenHash(token));
+    if (!conv) return res.status(404).json({ ok: false, error: 'not_found' });
+    res.json({
+      ok: true,
+      conversation: { ...G.conversationView(conv, knobs()), status: conv.status, end_reason: conv.end_reason || null },
+      transcript: G.transcriptView(conv.messages),
+    });
+  }));
+
+  return router;
+};

package/modules/front-door-guide/settings.js

@@ -0,0 +1,68 @@
+// modules/front-door-guide/settings.js — the owner's knobs for the start-a-project
+// guide (task 1005272): which model answers, how many messages and how much money one
+// visitor may use, the site's daily and monthly budget, and the per-message length.
+//
+// Every knob is configuration, read from the environment under the instance's prefix
+// (BONGOS_FRONT_DOOR_GUIDE_<NAME>, via the doorway's resolveEnv), and DEFAULTS below is
+// the one place the starting values are written. A value that is missing, blank or not
+// a usable number falls back to its default, so a typo never opens a cap wider.
+//
+// Money is integer micro-dollars (1 dollar = 1,000,000), the ai-studio convention, so
+// no budget comparison ever rounds a float. The env takes cents, which owners read.
+
+'use strict';
+
+// The starting values: the owner's settings for testing (2026-11-13).
+const DEFAULTS = Object.freeze({
+  MODEL: 'claude-opus-5-5',
+  EFFORT: 'low',                 // a short planning chat, not hard reasoning
+  MAX_MESSAGES: 8,               // visitor messages per visitor per day
+  VISITOR_CAP_CENTS: 50,         // what one visitor may spend per day
+  DAILY_BUDGET_CENTS: 200,       // the whole site, per UTC day
+  MONTHLY_BUDGET_CENTS: 2500,    // the whole site, per UTC calendar month
+  MAX_MESSAGE_CHARS: 1000,       // one visitor message
+  MAX_REPLY_TOKENS: 1500,        // one guide reply, thinking included
+  STARTS_PER_HOUR: 5,            // new conversations per visitor per hour
+  MESSAGES_PER_MINUTE: 6,        // messages per visitor per minute
+  MIN_FIRST_MESSAGE_MS: 1500,    // a person takes longer than this to type a first line
+});
+
+const EFFORTS = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
+const MODEL_RE = /^claude-[a-z0-9.-]{1,60}$/;
+
+function defaultResolve(suffix) {
+  return require('../../src/module-api').resolveEnv(suffix);
+}
+
+// A positive whole number from the env, or the default.
+function intKnob(read, name) {
+  const raw = read(`FRONT_DOOR_GUIDE_${name}`);
+  const n = Number(raw);
+  return raw !== undefined && raw !== '' && Number.isInteger(n) && n > 0 ? n : DEFAULTS[name];
+}
+
+// readSettings({ resolve }) → the resolved knobs, money in micro-dollars, plus the key.
+// The key is read here and only handed to the client builder; nothing returns it to a
+// browser. `resolve` is injectable so a test needs no environment.
+function readSettings({ resolve = defaultResolve } = {}) {
+  const read = (s) => { try { return resolve(s); } catch (_) { return undefined; } };
+  const model = String(read('FRONT_DOOR_GUIDE_MODEL') || '').trim();
+  const effort = String(read('FRONT_DOOR_GUIDE_EFFORT') || '').trim();
+  const key = String(read('FRONT_DOOR_GUIDE_ANTHROPIC_API_KEY') || '').trim();
+  return {
+    model: MODEL_RE.test(model) ? model : DEFAULTS.MODEL,
+    effort: EFFORTS.has(effort) ? effort : DEFAULTS.EFFORT,
+    apiKey: key || null,
+    maxMessages: intKnob(read, 'MAX_MESSAGES'),
+    visitorCapMicro: intKnob(read, 'VISITOR_CAP_CENTS') * 10_000,
+    dailyBudgetMicro: intKnob(read, 'DAILY_BUDGET_CENTS') * 10_000,
+    monthlyBudgetMicro: intKnob(read, 'MONTHLY_BUDGET_CENTS') * 10_000,
+    maxMessageChars: intKnob(read, 'MAX_MESSAGE_CHARS'),
+    maxReplyTokens: intKnob(read, 'MAX_REPLY_TOKENS'),
+    startsPerHour: intKnob(read, 'STARTS_PER_HOUR'),
+    messagesPerMinute: intKnob(read, 'MESSAGES_PER_MINUTE'),
+    minFirstMessageMs: intKnob(read, 'MIN_FIRST_MESSAGE_MS'),
+  };
+}
+
+module.exports = { readSettings, DEFAULTS };

package/modules/provisioning/starter-bundles.js

@@ -82,7 +82,9 @@ const ALWAYS_ON_CORE = Object.freeze([
 // bills AI generation through Cloud Bongos's own payment processor account, so it stays on
 // the hub until a project can bring its own billing. `market-watch` sat here while it was
 // empty; task 1004938 shipped the owner's on/off switch and moved it to OPTIONAL_MODULES.
-const HUB_ONLY_MODULES = Object.freeze(['platform-identity', 'provisioning', 'npm-release', 'render-deploy', 'raise', 'ai-studio']);
+// `front-door-guide` (task 1005272) is the hub's start-a-project chat on Cloud Bongos's own
+// Anthropic key, so a new project gains nothing by switching it on.
+const HUB_ONLY_MODULES = Object.freeze(['platform-identity', 'provisioning', 'npm-release', 'render-deploy', 'raise', 'ai-studio', 'front-door-guide']);
 
 // The OPT-IN catalog as the creation picker renders it (BV1.R20, task 1002339):
 // every module an owner may actually choose, in the order the picker lists them,

package/package-lock.json

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

package/package.json

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

@@ -11772,5 +11772,15 @@
       "id": "1005268",
       "text": "An Archon can now switch the card requirement on or off for a builder straight from the People roster."
     }
+  ],
+  "1.25.12": [
+    {
+      "id": "1005272",
+      "text": "Visitors who press start a project can now talk with an AI guide about what they want to build, with strict limits on messages and spending, and a plain form whenever the guide is unavailable."
+    },
+    {
+      "id": "1005288",
+      "text": "Decided how every project gets a sandbox: a free copy of the app that always shows the newest finished work, while the real site only changes when a person presses promote. Fake data and test keys by default. Costs the owner n"
+    }
   ]
 }

package/scripts/bongos/publish-manifest.js

@@ -78,6 +78,7 @@ const PUBLISH_ALLOWLIST = [
   'modules/render-deploy/',  // the deploy page of a project whose app deploys through Render (task 1004270). default:false. MUST be here for the npm-release reason: modules/hall-ui/ ships as one subtree, so a released core without it carries deploy.js's loader for #rd-panel with no routes behind it.
   'modules/market-watch/',   // the weekly AI market watch (task 1004935, goal 1000137). default:false and empty for now, but MUST be here: shipped is not enabled, and a released core without it answers "unknown module" to an instance that turns it on; tests/market_watch_module.mjs (publishable) also reads its manifest.
   'modules/ai-studio/',      // AI generation for artists (task 1004916, ADR 0392): keys, prepaid balance, generate. default:false.
+  'modules/front-door-guide/', // the start-a-project guide (task 1005272): a capped AI chat for a signed-out visitor on the platform's key. default:false, hub first; shipped is not enabled.
   'modules/raise/',           // the /raise investor page (task 1004847, ADR 0384) — ships in core, enabled ONLY on the hub, like platform-identity. Owner decision 2026-10-25: the whole page, its copy and starting numbers included, lives in the repo so builders can contribute to it, accepting that it publishes with the core. Secrets never do: the investor password is RAISE_PASSWORD_HASH in the instance env. default:false.
   'modules/platform-identity/', // hub identity provider (ADR 0141) — ships in core, enabled ONLY on the hub (cloudbongos.com). MUST be here or the hub's enabledModules() throws "unknown module" and provision.js's federation load MODULE_NOT_FOUNDs (task 1002235, same rationale as provisioning above). default:false — shipped ≠ enabled; a vanilla/self-hosted instance never turns it on.
   // --- neutral (customer-0) config starters + their schemas (the filled-in *.json twins are denied) ---

package/src/bongos/module-scope-map.js

@@ -186,6 +186,11 @@ const MODULE_GLOBS = {
   'ai-studio': [
     'modules/ai-studio/',
   ],
+  // The start-a-project guide (task 1005272, goal 1000106): a capped AI chat for a
+  // signed-out visitor. Its test sits at the repo root, listed by exact path.
+  'front-door-guide': [
+    'modules/front-door-guide/', 'tests/front_door_guide.mjs',
+  ],
   // The /raise investor page (task 1004847, ADR 0384): hub-only.
   raise: [
     'modules/raise/',

package/src/module-api.js

@@ -81,7 +81,7 @@ const { sleep } = require('./sleep');
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.25.11'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.25.12'; // 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');