@bongos/core 1.25.17 → 1.25.19

package/modules/onboarding/genesis-work.js

@@ -41,7 +41,8 @@
 //
 // WHICH STAGES. A stage adopts the pattern by declaring its questions in QUESTIONS.
 // Strategize does (task 1005116); scope's guided door is its project interview (task 1005114);
-// charter, legalize and legislation adopt it when they are next touched. A stage with
+// charter asks how decisions should go and the founder's principles (task 1005119);
+// legalize and legislation adopt it when they are next touched. A stage with
 // no questions still takes a free page and a link.
 //
 // THE BOUNDARY. Pure apart from the store. The store is injected (tests) or the
@@ -57,6 +58,9 @@ const STATES = Object.freeze(['answered', 'not_sure', 'skipped']);
 const ORIGINS = Object.freeze(['founder', 'assisted', 'carried_over']);
 const LIMITS = Object.freeze({ answer: 4000, page: 20000, link: 500 });
 
+// A closed question's options: [key, label] pairs, frozen.
+const choices = (pairs) => Object.freeze(pairs.map(([key, label]) => Object.freeze({ key, label })));
+
 // Each adopted stage's questions, in the order the guided door asks them. `id` is
 // stable: a stored answer names it, so never rename or reuse one. `hint` is the shape
 // of a good answer, shown under the question in every door. `group` (optional) is a
@@ -83,6 +87,47 @@ const QUESTIONS = Object.freeze({
     Object.freeze({ id: 'others_wrong', group: 'The bet', ask: 'What is everyone else in this area getting wrong?',
       hint: 'The thing you believe that others in this space do not. This is the bet the project makes.' }),
   ]),
+  // CHARTER (task 1005119): how decisions should go, then the founder's principles.
+  // A question with `choices` is a CLOSED one: an answer is one of its keys, because
+  // the government module's recommender reads it (recommendations.js CHARTER_ANSWERS
+  // and presets.js PRINCIPLE_ANSWERS hold the same keys, by test; a module may not
+  // import a sibling, ADR 0083). The prose ones shape the drafted bylaws and code of
+  // conduct in the founder's own words. Every one is skippable and "not sure yet".
+  charter: Object.freeze([
+    Object.freeze({ id: 'final_say', group: 'How decisions go', ask: 'When people disagree, who should have the final say?',
+      hint: 'Who settles it in the end. This is who gets a vote.',
+      choices: choices([['founder', 'Me, the founder'], ['trusted', 'The people who have earned trust by shipping'],
+        ['everyone', 'Everyone on the project'], ['council', 'A small group I appoint']]) }),
+    Object.freeze({ id: 'agreement', group: 'How decisions go', ask: 'How much agreement should a decision need?',
+      hint: 'Fewer means faster; more means everyone is bought in.',
+      choices: choices([['first_ratifier', 'One yes is enough'], ['consent', 'It passes unless someone objects'],
+        ['majority', 'More than half must say yes'], ['unanimous', 'Everyone who votes must agree']]) }),
+    Object.freeze({ id: 'strangers', group: 'How decisions go', ask: 'Do you expect people you have not met to show up and contribute?',
+      hint: 'Whether newcomers should get a say straight away or earn it first.',
+      choices: choices([['yes', 'Yes'], ['no', 'No, it is people I know']]) }),
+    Object.freeze({ id: 'answers_to', group: 'How decisions go', ask: 'Is there anyone outside the project it answers to: funders, a mission, a legal entity?',
+      hint: 'Something the project must stay true to, whoever is building it.',
+      choices: choices([['yes', 'Yes'], ['no', 'No']]) }),
+    Object.freeze({ id: 'step_back', group: 'How decisions go', ask: 'Do you want to be able to step back later and hand this over?',
+      hint: 'Whether the project should keep deciding well without you.',
+      choices: choices([['yes', 'Yes'], ['no', 'No, I plan to stay at the helm']]) }),
+    Object.freeze({ id: 'speed', group: 'How decisions go', ask: 'Would you rather decide fast, or have everyone bought in?',
+      hint: 'When the two pull apart, which wins.',
+      choices: choices([['fast', 'Decide fast'], ['bought_in', 'Everyone bought in']]) }),
+    Object.freeze({ id: 'trust_level', group: 'Principles', ask: 'How much should people be trusted to work without checking in first?',
+      hint: 'This shapes how strict the rules for the project\'s AI agents are.',
+      choices: choices([['a_lot', 'A lot: let them get on with it'], ['some', 'Some: a few rules everyone follows'],
+        ['little', 'Little: tight rules, checked often']]) }),
+    Object.freeze({ id: 'catch_or_fix', group: 'Principles', ask: 'When something goes wrong, would you rather have caught it early, or move fast and fix it?',
+      hint: 'Neither is wrong. It sets how much is checked before work goes ahead.',
+      choices: choices([['catch_early', 'Catch it early'], ['move_fast', 'Move fast and fix it']]) }),
+    Object.freeze({ id: 'leave_behaviour', group: 'Principles', ask: 'What behaviour would make you ask someone to leave?',
+      hint: 'The line nobody crosses. It becomes the heart of the code of conduct.' }),
+    Object.freeze({ id: 'feel', group: 'Principles', ask: 'What do you want this project to feel like to work on?',
+      hint: 'A few words: calm, fast, careful, playful, serious.' }),
+    Object.freeze({ id: 'write_down', group: 'Principles', ask: 'Is there anything you want written down now, so it is not argued about later?',
+      hint: 'A rule, a promise or a boundary. It goes into the bylaws as you wrote it.' }),
+  ]),
   strategize: Object.freeze([
     Object.freeze({ id: 'big_pieces', ask: 'What are the big pieces, and in what order do they get built?',
       hint: 'Three to six pieces is plenty. Say why that order: what has to exist before what.' }),
@@ -116,6 +161,14 @@ function checkAnswer(stage, questionId, body = {}) {
   const words = text(b.text);
   if (words.length > LIMITS.answer) return { ok: false, reason: 'answer_too_long' };
   if (state === 'answered' && !words) return { ok: false, reason: 'empty_answer' };
+  // A closed question's answer is one of its keys (or its label, read back as the key),
+  // so the recommender reading it never has to guess at prose.
+  const q = questionFor(stage, questionId);
+  if (state === 'answered' && q.choices) {
+    const hit = q.choices.find((c) => c.key === words || c.label.toLowerCase() === words.toLowerCase());
+    if (!hit) return { ok: false, reason: 'not_a_choice', expected: q.choices.map((c) => c.key) };
+    return { ok: true, value: { state, answer_md: hit.key, origin } };
+  }
   return { ok: true, value: { state, answer_md: words || null, origin } };
 }
 
@@ -130,6 +183,7 @@ function checkLink(url) {
 
 // ── pure: the view ────────────────────────────────────────────────────────────
 
+const labelOf = (q, key) => { const c = (q.choices || []).find((x) => x.key === key); return c ? c.label : null; };
 const iso = (v) => (v ? new Date(v).toISOString() : null);
 
 // shapeStage(stage, work, answers) → one stage's record as every door sees it.
@@ -141,8 +195,11 @@ function shapeStage(stage, work, answers = []) {
     const a = byId.get(q.id);
     return {
       id: q.id, ask: q.ask, hint: q.hint, group: q.group || null,
+      choices: q.choices || null,
       answer: a ? {
         state: a.state, text: a.answer_md || null, origin: a.origin,
+        // a closed answer's words, for a reader who should not see the key
+        choice_label: q.choices && a.state === 'answered' ? labelOf(q, a.answer_md) : null,
         // A carried-over answer is shown as such until the founder makes it theirs.
         carried_over: a.origin === 'carried_over',
         updated_at: iso(a.updated_at),
@@ -190,7 +247,7 @@ function contextMarkdown(stages) {
     out.push(`## ${s.stage[0].toUpperCase()}${s.stage.slice(1)}`);
     for (const q of said) {
       const a = q.answer;
-      const body = a.state === 'answered' ? a.text : `${STATE_WORDS[a.state]}${a.text ? ` — ${a.text}` : ''}`;
+      const body = a.state === 'answered' ? (a.choice_label || a.text) : `${STATE_WORDS[a.state]}${a.text ? ` — ${a.text}` : ''}`;
       out.push(`- **${q.ask}**${ORIGIN_WORDS[a.origin] || ''}\n  ${String(body).replace(/\n/g, '\n  ')}`);
     }
     if (s.page) out.push('', '**In the founder\'s own words:**', '', s.page);
@@ -203,6 +260,73 @@ function contextMarkdown(stages) {
     ...out].join('\n').trimEnd() + '\n';
 }
 
+// ── each stage's DOCUMENT (task 1005115) ──────────────────────────────────────
+// A finished stage leaves something behind the founder can come back to: the scope, the
+// strategy, the charter … It is NOT a second store. The document IS the stage's record
+// above (its answers, its free page, its link) read as one named page, so editing it is
+// editing those, through the same writes, by the same person. It stays editable after
+// the stage moves on, and editing it never reopens the stage or undoes anything: the
+// stage's progress is founding-mode's, and nothing here reads or writes it.
+const DOCUMENT_TITLES = Object.freeze({
+  scope: 'The scope', strategize: 'The strategy', charter: 'The charter',
+  legalize: 'The rewards', legislation: 'The voting rules',
+});
+
+// documentOf(shape) → the stage's document: its title, whether anything is in it yet,
+// and the founder's words as markdown. Each part names the write that edits it, so a
+// presentation (the game's district, the hall) never has to know the store.
+// The markdown is the founder's raw words, unescaped: a reader shows it as text or through
+// an escaping markdown renderer, never as HTML.
+function documentOf(s) {
+  const said = s.questions.filter((q) => q.answer);
+  const lines = [`# ${DOCUMENT_TITLES[s.stage]}`, ''];
+  let group = null;
+  for (const q of said) {
+    if (q.group && q.group !== group) { group = q.group; lines.push(`## ${group}`, ''); }
+    const a = q.answer;
+    const body = a.state === 'answered' ? (a.choice_label || a.text) : `${STATE_WORDS[a.state]}${a.text ? ` — ${a.text}` : ''}`;
+    lines.push(`**${q.ask}**${ORIGIN_WORDS[a.origin] || ''}`, '', String(body), '');
+  }
+  if (s.page) lines.push(said.length ? "## In the founder's own words" : '', '', s.page, '');
+  if (s.link) lines.push(`The founder's existing document: ${s.link}`, '');
+  const filled = said.length > 0 || !!s.page || !!s.link;
+  return {
+    stage: s.stage,
+    title: DOCUMENT_TITLES[s.stage],
+    filled,
+    markdown: filled ? lines.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd() + '\n' : '',
+    counts: s.counts,
+    updated_at: latest([s.updated_at, ...said.map((q) => q.answer.updated_at)]),
+    // Editing never reopens the stage. Task 1005107 narrows this for a stage the Board
+    // Room passed; until then every document is open to its author.
+    editable: true,
+    edit: {
+      answer: `PUT /api/bongos/founding/work/${s.stage}/answers/:question`,
+      page: `PUT /api/bongos/founding/work/${s.stage}/page`,
+      link: `PUT /api/bongos/founding/work/${s.stage}/link`,
+    },
+  };
+}
+
+const latest = (isos) => isos.filter(Boolean).sort().at(-1) || null;
+
+async function readDocument(stage, deps = {}) {
+  const r = await readStage(stage, deps);
+  if (!r.ok) return r;
+  return { ok: true, document: documentOf(r.work) };
+}
+
+// readDocuments(deps) → { stage: { title, filled, updated_at } } — the light summary the
+// genesis home carries per stage, so the page shows each stage's document in place.
+async function readDocuments(deps = {}) {
+  const out = {};
+  for (const s of await readAll(deps)) {
+    const d = documentOf(s);
+    out[s.stage] = { title: d.title, filled: d.filled, updated_at: d.updated_at, editable: d.editable };
+  }
+  return out;
+}
+
 // assistPrompt(stage) → the brief the founder hands their own AI session for the
 // assisted door. It works the stage's own questions (never a shape of its own),
 // argues rather than authors, and records only what the founder decides.
@@ -223,7 +347,11 @@ function assistPrompt(stage) {
   ];
   if (qs.length) {
     lines.push('The questions (the id in brackets is what you record the answer under):');
-    qs.forEach((q, i) => lines.push(`${i + 1}. [${q.id}] ${q.ask} (${q.hint})`));
+    qs.forEach((q, i) => {
+      lines.push(`${i + 1}. [${q.id}] ${q.ask} (${q.hint})`);
+      // A closed question records one of its keys, never prose.
+      if (q.choices) lines.push(`   Record one of: ${q.choices.map((c) => `${c.key} (${c.label})`).join(' · ')}`);
+    });
     lines.push('');
   }
   lines.push('To see what I have already said:  npx bongos genesis show ' + stage);
@@ -316,7 +444,43 @@ async function readAll(deps = {}) {
 async function readStage(stage, deps = {}) {
   if (!isStage(stage)) return { ok: false, reason: 'unknown_stage' };
   const all = await readAll(deps);
-  return { ok: true, work: all.find((s) => s.stage === stage) };
+  const work = all.find((s) => s.stage === stage);
+  if (stage === 'charter') work.advice = await charterAdvice(work, deps);
+  return { ok: true, work };
+}
+
+// charterAdvice(work, deps) — THE CHARTER STAGE'S RECOMMENDATION (task 1005119): the
+// founder's answers, handed to the government module's one recommender through its
+// port. Closed answers go as their keys, prose ones as the founder's words; "not sure
+// yet" and skipped are not sent, so the recommender falls back to what it does
+// without them. The head count is the founder's own expected number from the plan
+// when they gave one. Null with no government module, and null (never a failed read)
+// if the advice cannot be built: the questions still work without it.
+async function charterAdvice(work, deps = {}) {
+  try {
+    const api = deps.api || require('../../src/module-api');
+    const gov = deps.government !== undefined ? deps.government : api.resolveOptional('government');
+    if (!gov || typeof gov.charterAdvice !== 'function') return null;
+    const answers = {};
+    const prose = {};
+    for (const q of work.questions) {
+      if (!q.answer || q.answer.state !== 'answered') continue;
+      (q.choices ? answers : prose)[q.id] = q.answer.text;
+    }
+    let headcount = null;
+    const get = deps.getSetting || (api.projectSettings && api.projectSettings.get);
+    if (get) {
+      const row = await get('founding.plan');
+      try {
+        const v = row && row.value;
+        const plan = typeof v === 'string' ? JSON.parse(v) : v;
+        headcount = (plan && plan.expected_builders) || null;
+      } catch (_) { headcount = null; }
+    }
+    return await gov.charterAdvice({ answers, prose, headcount });
+  } catch (_) {
+    return null;
+  }
 }
 
 async function setDoor(stage, door, by, deps = {}) {
@@ -383,5 +547,6 @@ async function readContext(deps = {}) {
 // and are exercised through the operations (tests/genesis_work.mjs).
 module.exports = {
   STAGES, LIMITS, QUESTIONS, assistPrompt,
+  readDocument, readDocuments,
   pgStore, readAll, readStage, setDoor, setPage, setLink, setAnswer, clearAnswer, answerHistory, readContext,
 };

package/modules/onboarding/routes/genesis-work.js

@@ -15,7 +15,7 @@ const work = require('../genesis-work');
 
 const REFUSALS = {
   unknown_stage: 404, unknown_question: 404, bad_door: 400, bad_state: 400, bad_origin: 400,
-  empty_answer: 400, answer_too_long: 400, page_too_long: 400, link_too_long: 400, bad_link: 400,
+  empty_answer: 400, not_a_choice: 400, answer_too_long: 400, page_too_long: 400, link_too_long: 400, bad_link: 400,
 };
 
 // `deps` is for tests only (an in-memory store); production passes none.
@@ -25,7 +25,7 @@ module.exports = function mountGenesisWorkRoutes(router, deps = {}) {
     try {
       const r = await fn(req);
       if (r && r.ok === false) {
-        return res.status(REFUSALS[r.reason] || 409).json({ error: { code: r.reason, message: r.reason } });
+        return res.status(REFUSALS[r.reason] || 409).json({ error: { code: r.reason, message: r.reason, ...(r.expected ? { expected: r.expected } : {}) } });
       }
       res.set('Cache-Control', 'no-store');
       res.json(r);
@@ -41,6 +41,9 @@ module.exports = function mountGenesisWorkRoutes(router, deps = {}) {
   router.get('/founding/work', api.requireBuilder, handle(async () => ({ stages: await work.readAll(deps) })));
   router.get('/founding/context', api.requireBuilder, handle(() => work.readContext(deps)));
   router.get('/founding/work/:stage', api.requireBuilder, handle((req) => work.readStage(stage(req), deps)));
+  // The stage's document (task 1005115): its record read as one named page, editable
+  // through the writes below at any time, without reopening the stage.
+  router.get('/founding/work/:stage/document', api.requireBuilder, handle((req) => work.readDocument(stage(req), deps)));
   router.get('/founding/work/:stage/assist', api.requireBuilder, handle(async (req) => {
     const prompt = work.assistPrompt(stage(req));
     return prompt ? { prompt } : { ok: false, reason: 'unknown_stage' };

package/modules/platform-identity/module.json

@@ -12,7 +12,7 @@
   "maintainer": "Cloud Bongos maintainers",
   "maintenance": { "status": "core-maintained" },
   "contributes": {
-    "routes": ["sso", "sso-invites", "projects", "my-projects", "scouting", "profile", "public-profile", "connections", "community-search", "community-leaderboard", "guilds", "guilds-public"],
+    "routes": ["sso", "sso-invites", "sso-app-status", "projects", "my-projects", "scouting", "profile", "public-profile", "connections", "community-search", "community-leaderboard", "guilds", "guilds-public"],
     "migrations": true,
     "pollers": ["code-sweep", "visibility-pull", "guild-totals"]
   },

package/modules/platform-identity/routes/sso-app-status.js

@@ -0,0 +1,65 @@
+// modules/platform-identity/routes/sso-app-status.js — a hosted project asks the hub where
+// its own APP runs (task 1004571). Server-to-server, authenticated by client_id +
+// client_secret like the membership check-in and the invite notices; the asker is core's
+// readAppStatusFromHub (src/bongos/auth-admission.js), and its hall shows the answer in the
+// options menu.
+//
+//   POST /sso/app-status  { client_id, client_secret } → { ok, known, app, sandbox }
+//
+// A PROJECT READS ITS OWN ROW, NEVER ANOTHER'S. The project is the authenticated client
+// itself, named by both halves of the ADR 0246 projection (client_id = slug at the client's
+// registered origin) — nothing in the body can name a different one. The row and its
+// app-status reading belong to the provisioning module, so this asks through the
+// `provisioning.projectAppStatus` port; a hub without provisioning answers `known: false`.
+//
+// WHAT IT CARRIES is app-status.js's shape as is: the project is already trusted with its
+// own setup (it is the project's own hall asking). Its hall decides, per viewer, what an
+// owner sees beyond the state. Nothing here calls Render.
+//
+// WIRE SKEW (ADR 0352): a NEW route, so an older hub answers 404 and the hall says it could
+// not ask. The body is validated strictly, so a field added later must ride a header, or ship
+// on the hub and be released before any instance sends it.
+'use strict';
+
+const express = require('express');
+const api = require('../../../src/module-api');
+const pi = require('../platform-identity');
+
+const log = api.logger('platform-identity');
+const { pool, validateOrRespond } = api;
+
+/** The host a client's registered origin names, lowercased; null for no usable origin. */
+function originHost(origin) {
+  try { return new URL(String(origin || '')).host.toLowerCase() || null; } catch { return null; }
+}
+
+module.exports = function ssoAppStatusRoutes({ resolvePort = (name) => api.resolveOptional(name), db = pool } = {}) {
+  const router = express.Router();
+
+  // rank: public — authenticated by client_id + client_secret, not a builder rank.
+  router.post('/sso/app-status', async (req, res) => {
+    if (validateOrRespond(req, res, {
+      client_id: { required: true, type: 'string', maxLength: 200 },
+      client_secret: { required: true, type: 'string', maxLength: 512 },
+    }, { strict: true })) return undefined;
+    const { client_id, client_secret } = req.body;
+    try {
+      const client = await pi.getClient(client_id, { pool: db });
+      if (!client || client.status !== 'active' || !pi.clientSecretValid(client, client_secret)) {
+        return res.fail('invalid_client', 401);
+      }
+      const read = resolvePort('provisioning.projectAppStatus');
+      const host = originHost(client.origin);
+      const found = typeof read === 'function' && host ? await read({ slug: client.client_id, host }) : null;
+      if (!found) return res.json({ ok: true, known: false, app: null, sandbox: null });
+      return res.json({ ok: true, known: true, app: found.app || null, sandbox: found.sandbox || null });
+    } catch (err) {
+      log.error('[platform-identity] /sso/app-status', err && err.message);
+      return res.fail('app_status_failed', { status: 500, message: 'internal error' });
+    }
+  });
+
+  return router;
+};
+
+module.exports.originHost = originHost;

package/modules/provisioning/module.json

@@ -40,6 +40,7 @@
     "provisioning.projectOwnedBy",
     "provisioning.projectPublishIdentity",
     "provisioning.selfUpdateChannel",
+    "provisioning.projectAppStatus",
     "provisioning.moduleCatalog"
   ],
   "consumes": []

package/modules/provisioning/seams.js

@@ -7,6 +7,8 @@ const api = require('../../src/module-api');
 const { pool } = api;
 const provisioning = require('./provisioning');
 const { selfUpdateChannel } = require('./core-upgrade');
+const { appStatus } = require('./app-status');
+const { sandboxStatus } = require('./render-sandbox');
 const { ALWAYS_ON_CORE, optionalModules } = require('./starter-bundles');
 
 // The `provisioning.projectPublishIdentity` port (task 1003578, ADR 0247 D4): the name and
@@ -29,6 +31,32 @@ async function projectPublishIdentity(db, { slug, host } = {}) {
   return rows[0] ? { name: rows[0].slug, description: rows[0].description } : null;
 }
 
+// The `provisioning.projectAppStatus` port (task 1004571): where a hosted project's APP runs,
+// for that project's own hall. The hall asks the hub over the client-authenticated SSO route
+// (platform-identity routes/sso-app-status.js), which names the project by BOTH halves of the
+// ADR 0246 projection, as projectPublishIdentity does. The answer is app-status.js's own
+// shape — never a second one — read from the row alone (nothing here calls Render), with the
+// same "a lent key not yet spent means wait" reading the owner's route makes.
+// The sandbox beside a Render app (ADR 0406, task 1005289) rides along in render-sandbox.js's
+// own shape, the one the owner's route returns; null when the app is not on Render.
+// null = no such project on this plane; { app: null } = a project whose app has no platform.
+async function projectAppStatus(db, { slug, host } = {}) {
+  if (typeof slug !== 'string' || !slug || typeof host !== 'string' || !host) return null;
+  const { rows } = await db.query(
+    `SELECT i.app_host, i.status,
+            EXISTS (SELECT 1 FROM provisioning_intents p
+                     WHERE p.instance_id = i.id AND p.state IN ('pending', 'running')
+                       AND p.borrowed_key_enc IS NOT NULL) AS waiting
+       FROM provisioning_instances i
+      WHERE i.slug = $1 AND lower(i.domain) = $2
+      LIMIT 1`,
+    [slug, host.toLowerCase()],
+  );
+  if (!rows[0]) return null;
+  const app = appStatus(rows[0].app_host, { keyWaiting: rows[0].waiting === true });
+  return { app, sandbox: app && app.platform === 'render' ? sandboxStatus(rows[0]) : null };
+}
+
 // Idempotent — the loader calls the routes factory once at boot, but tests may
 // instantiate the router repeatedly; gating on hasProvider keeps each port
 // single-registered.
@@ -45,6 +73,8 @@ async function projectPublishIdentity(db, { slug, host } = {}) {
 //     question names both halves of the ADR 0246 projection.
 //   • PROVIDES port `provisioning.projectPublishIdentity` ({ slug, host }) → { name,
 //     description } | null — see projectPublishIdentity above.
+//   • PROVIDES port `provisioning.projectAppStatus` ({ slug, host }) → { app, sandbox } | null — see
+//     projectAppStatus above.
 //   • PROVIDES port `provisioning.moduleCatalog` () → { core: [key], optional: [{ key,
 //     label, summary }] } — the modules a NEW project gets and may opt into, with the
 //     owner-facing words the creation picker shows (task 1005273). The start-a-project
@@ -57,10 +87,11 @@ function registerProvisioningSeams() {
   api.registerProvider('provisioning.projectOwnedBy', (target) => provisioning.projectOwnedBy(pool, target));
   api.registerProvider('provisioning.projectPublishIdentity', (target) => projectPublishIdentity(pool, target));
   api.registerProvider('provisioning.selfUpdateChannel', () => selfUpdateChannel(pool));
+  api.registerProvider('provisioning.projectAppStatus', (target) => projectAppStatus(pool, target));
   api.registerProvider('provisioning.moduleCatalog', () => ({
     core: [...ALWAYS_ON_CORE],
     optional: optionalModules().map(({ key, label, summary }) => ({ key, label, summary })),
   }));
 }
 
-module.exports = { registerProvisioningSeams, projectPublishIdentity };
+module.exports = { registerProvisioningSeams, projectPublishIdentity, projectAppStatus };

package/modules/provisioning/starter-bundles.js

@@ -45,6 +45,7 @@
 // layers on, not part of any bundle, and they are listed here so a creation form
 // can show an owner what they already have without a second round trip.
 const ALWAYS_ON_CORE = Object.freeze([
+  'app-host',
   'autonomy',
   'builder-settings',
   'copy-desk',