@bongos/core 1.17.0 → 1.17.1

package/scripts/gds/package-core.js

@@ -38,7 +38,7 @@
 //      carries a live credential verbatim, PRODUCE NOTHING — dist/ is never touched. The
 //      in-memory pass makes the abort atomic (same discipline as the mirror export).
 //   5. Only when the whole set is clean: write the tree to
-//      dist/cloudbongos-core-<version>/, the .tgz, and the pin MANIFEST.
+//      dist/bongos-core-<version>/, the .tgz, and the pin MANIFEST.
 //
 // THE VERSION STAMP is the platform version — src/module-api.js CORE_VERSION,
 // read via the SAME fail-soft accessor scripts/gds/module.js + bongos upgrade use
@@ -55,9 +55,9 @@
 //        [--version <v>] [--droplet-ip <ip>] [--publish [--live]]
 //   Defaults: --ref HEAD, --out-dir dist, --version = platform CORE_VERSION.
 //   Outputs (nothing is committed — dist/ is gitignored):
-//     dist/cloudbongos-core-<version>/           the redacted core tree (inspectable)
-//     dist/cloudbongos-core-<version>.tgz        the installable unit
-//     dist/cloudbongos-core-<version>.manifest.json   the PIN (tree hash + per-file hashes)
+//     dist/bongos-core-<version>/           the redacted core tree (inspectable)
+//     dist/bongos-core-<version>.tgz        the installable unit
+//     dist/bongos-core-<version>.manifest.json   the PIN (tree hash + per-file hashes)
 //   --publish        after building, `npm publish` the .tgz as a PRIVATE scoped
 //                    package (--access restricted). DRY-RUN unless --live is added
 //                    (task 2089 / ADR 0134). Private publish needs the cloudbongos
@@ -81,7 +81,7 @@ const { collectEnvSecrets } = require(path.join(REPO_ROOT, 'modules/security/sec
 const { redactBlob, parseLsTree } = require(path.join(REPO_ROOT, 'scripts/public-mirror-export.js'));
 
 const MANIFEST_SCHEMA = 1;
-const ARTIFACT_NAME = 'cloudbongos-core';
+const ARTIFACT_NAME = 'bongos-core';
 // The tar internal root MUST be `package/` — that is the one hardcoded npm
 // convention for an installable tarball (`npm install ./x.tgz` / `npm pack`
 // output both use it; npm does not read the directory name to find package.json,
@@ -92,7 +92,7 @@ const TAR_ROOT = 'package/';
 // The self-describing manifest carried INSIDE the artifact (minus tarball.* — a
 // file cannot contain its own hash). The authoritative PIN is the side-car next
 // to the .tgz, which adds tarball.{sha256,bytes}.
-const INNER_MANIFEST = `${TAR_ROOT}.cloudbongos-core.json`;
+const INNER_MANIFEST = `${TAR_ROOT}.bongos-core.json`;
 
 // ---------------------------------------------------------------------------
 // The platform version — read CORE_VERSION via the doorway, lazily + fail-soft,
@@ -136,6 +136,38 @@ function sha256hex(buf) {
 const DOC_RE = /\.(md|markdown)$/i;
 function isDocPath(p) { return DOC_RE.test(String(p || '')); }
 
+// ---------------------------------------------------------------------------
+// Agent-doc STUB (task 2121; surfaced by the 2026-07-08 demo task-creation audit).
+// Claude Code AUTO-LOADS the nearest file named CLAUDE.md (or AGENTS.md) into the
+// live session whenever an agent opens a sibling file. In a CONSUMER instance the
+// core installs at node_modules/@bongos/core/, so the core repo's OWN CLAUDE.md tree
+// (root + scripts/gds + src/bongos + every module) would silently inject the
+// platform's project memory — wrong project title, hundreds of lines, dangling links
+// — into the instance's context the moment an agent reads any core file.
+//   The PUBLIC MIRROR deliberately publishes CLAUDE.md as the portable methodology
+// (ADR 0065 §4), so this cannot live in the shared publish-manifest — it is a
+// package-core-only transform. We keep the files PRESENT (nothing that probes for
+// them by path breaks) but replace their body with a tiny, brand-free stub, turning
+// the auto-load into a harmless "this doesn't govern you" redirect.
+const AGENT_DOC_RE = /(^|\/)(CLAUDE|AGENTS)\.md$/i;
+function isAgentDoc(p) { return AGENT_DOC_RE.test(String(p || '')); }
+const CORE_AGENT_DOC_STUB = `# @bongos/core — installed platform dependency (not your project's CLAUDE.md)
+
+This file is a placeholder shipped inside the **@bongos/core** package. The core's own
+internal agent notes are intentionally omitted from the published artifact so they cannot
+load into your instance's context.
+
+**It does not govern this repository.** Your own root \`CLAUDE.md\`, your \`.claude/\`
+directory, and the live Bongos database are the source of truth for how work happens here
+and who may do what.
+
+You are seeing this only because an agent opened a file under \`node_modules/@bongos/core/\`.
+Nothing in here needs to be read to use the platform — run \`bongos help\` for commands.
+
+_To work ON the platform core itself, use the standalone @bongos/core source repository,
+not this vendored copy._
+`;
+
 // Fail-loud gate for a FUNCTIONAL file: only an exact live-credential value (an env-secret
 // VALUE present verbatim, >= 8 chars) is a real leak. The sample is withheld (it's a secret).
 function functionalSecretLeaks(view, envSecrets) {
@@ -154,6 +186,12 @@ function functionalSecretLeaks(view, envSecrets) {
 //     `advisories` = brand-identity substrings + public IPs that ship as-is (non-fatal, for
 //     human awareness) — REUSES findLeaks so the detector is defined once.
 function processCoreFile({ pathRel, raw, rules, sensitiveLiterals, envSecrets }) {
+  // An auto-loaded agent doc (CLAUDE.md/AGENTS.md) → ship a brand-free stub, never the
+  // core's own project memory (task 2121). The stub is brand-free by construction, so it
+  // needs no redaction and can never leak — it short-circuits ahead of the doc path.
+  if (isAgentDoc(pathRel)) {
+    return { buf: Buffer.from(CORE_AGENT_DOC_STUB, 'utf8'), leaks: [], advisories: [], kind: 'stub' };
+  }
   if (isDocPath(pathRel)) {
     const r = redactBlob({ buf: raw, rules, sensitiveLiterals, envSecrets });
     const leaks = r.leaks.map((l) => ({ label: `doc:${l.label}`, sample: l.sample }));
@@ -174,7 +212,7 @@ function processCoreFile({ pathRel, raw, rules, sensitiveLiterals, envSecrets })
 //
 // The source repo's package.json/package-lock.json (isPublishable() includes
 // both) are GAME-heavy — colyseus/phaser/sharp/discord.js plus the repo's own
-// name/version — and are not what a downstream `npm install @cloudbongos/core`
+// name/version — and are not what a downstream `npm install @bongos/core`
 // should see. These two files are SYNTHESIZED here (never copied verbatim from
 // git) and staged in their place. Everything else still ships through the
 // normal isPublishable()/processCoreFile path.
@@ -195,7 +233,7 @@ function buildPackageJson({ version, sourceDeps, sourceOverrides }) {
     dependencies[name] = range;
   }
   const pkg = {
-    name: '@cloudbongos/core',
+    name: '@bongos/core',
     version,
     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',
@@ -215,7 +253,7 @@ function buildPackageJson({ version, sourceDeps, sourceOverrides }) {
     // default. `access:"restricted"` makes a scoped package private on publish, so a
     // paid npm org can ship it where only members can install — no accidental public
     // leak if someone forgets the CLI flag. Going public at launch is one step:
-    // `npm access public @cloudbongos/core` (or flip this to "public"). The name must
+    // `npm access public @bongos/core` (or flip this to "public"). The name must
     // stay SCOPED to be private at all — unscoped npm names are always public.
     publishConfig: { access: 'restricted' },
     dependencies,
@@ -481,7 +519,7 @@ function publishTarball({ tgzPath, live }) {
   if (!live) {
     console.error('  Dry-run: nothing is uploaded. To publish for real: re-run with --publish --live.');
     console.error('  That is PERMANENT and requires `npm login` + the cloudbongos npm org on a paid plan');
-    console.error('  (private scoped publish needs one). Going public later: `npm access public @cloudbongos/core`.');
+    console.error('  (private scoped publish needs one). Going public later: `npm access public @bongos/core`.');
   }
   const r = spawnSync(NPM_BIN, args, { cwd: REPO_ROOT, stdio: ['inherit', process.stderr, 'inherit'] });
   if (r.error || r.status !== 0) {
@@ -489,7 +527,7 @@ function publishTarball({ tgzPath, live }) {
     if (live) console.error('  Common causes: not logged in (`npm login`), the org isn’t on a paid plan (private scoped publish requires one), or 2FA.');
     process.exit(r.status || 1);
   }
-  console.error(`[package-core] npm publish ${live ? 'succeeded — @cloudbongos/core is live (private).' : 'dry-run OK — the tarball is publishable.'}`);
+  console.error(`[package-core] npm publish ${live ? 'succeeded — @bongos/core is live (private).' : 'dry-run OK — the tarball is publishable.'}`);
 }
 
 function main() {
@@ -520,7 +558,7 @@ function main() {
 
   // 2b. Synthesize the core's own package.json + pruned package-lock.json from the
   //     SOURCE files at this ref (never the live working tree, so --ref stays
-  //     reproducible) — express+pg only, name @cloudbongos/core, version = the
+  //     reproducible) — express+pg only, name @bongos/core, version = the
   //     platform version being packaged.
   const pkgJsonBlob = entries.find((e) => e.path === 'package.json');
   const pkgLockBlob = entries.find((e) => e.path === 'package-lock.json');
@@ -557,6 +595,7 @@ function main() {
   const advisories = []; // { path, label, sample } — non-fatal (brand/IP that ships verbatim)
   let docCount = 0;
   let funcCount = 0;
+  let stubCount = 0; // agent docs (CLAUDE.md/AGENTS.md) replaced with the brand-free stub (task 2121)
   for (const e of publishable) {
     let raw;
     try { raw = gitBuf(['cat-file', 'blob', e.sha]); }
@@ -565,7 +604,7 @@ function main() {
       processCoreFile({ pathRel: e.path, raw, rules, sensitiveLiterals, envSecrets });
     for (const l of fileLeaks) leaks.push({ path: e.path, label: l.label, sample: l.sample });
     for (const a of fileAdvisories) advisories.push({ path: e.path, label: a.label, sample: a.sample });
-    if (kind === 'doc') docCount++; else funcCount++;
+    if (kind === 'doc') docCount++; else if (kind === 'stub') stubCount++; else funcCount++;
     filesMeta.push({ path: e.path, mode: e.mode, sha256: sha256hex(buf) });
     staged.push({ name: TAR_ROOT + e.path, mode: parseInt(normalizeMode(e.mode), 8), buf });
   }
@@ -593,7 +632,7 @@ function main() {
     console.error('     for a live-credential leak, remove the secret at SOURCE (it should never be committed). Then re-run. dist/ was NOT touched.');
     process.exit(1);
   }
-  console.error(`[package-core] no-leak gate PASSED — ${staged.length} files clean (${docCount} docs redacted, ${funcCount} functional verbatim).`);
+  console.error(`[package-core] no-leak gate PASSED — ${staged.length} files clean (${docCount} docs redacted, ${stubCount} agent-docs stubbed, ${funcCount} functional verbatim).`);
 
   // Advisory: brand-identity + public-IP literals that ship VERBATIM inside functional
   // files. Not a leak (these are public, not secrets; a downstream rebrands via config) —
@@ -614,6 +653,7 @@ function main() {
     redaction: {
       model: 'docs-redacted+functional-verbatim', // task 1824
       docs_redacted: docCount,
+      agent_docs_stubbed: stubCount, // CLAUDE.md/AGENTS.md → brand-free stub (task 2121)
       functional_verbatim: funcCount,
       rules: rules.length,
       gate_literals: sensitiveLiterals.length,
@@ -675,6 +715,8 @@ module.exports = {
   octal, tarChecksum, ustarHeader, splitUstarName, buildTar,
   // task 1824 — the consumer-core file-classification layer (pure; unit-tested)
   isDocPath, functionalSecretLeaks, processCoreFile,
+  // task 2121 — agent-doc (CLAUDE.md/AGENTS.md) stub so a consumer's node_modules can't auto-load core memory
+  isAgentDoc, CORE_AGENT_DOC_STUB,
   // task 1882 (ADR 0108 §2) — the real installable npm package
   CORE_DEP_NAMES, buildPackageJson, resolveLockDep, lockfileClosure, prunePackageLock,
   // task 2089 (ADR 0134) — private-by-default npm publish

package/scripts/gds/provision.js

@@ -56,6 +56,12 @@ const REPO_ROOT = path.resolve(__dirname, '..', '..');
 // plain require (its require.main guard means importing it runs no CLI).
 const oauthSecret = require('./oauth-secret');
 
+// The registry-install gates + env-fed .npmrc (ADR 0134, task 2090). Lets the
+// standalone scaffold OPT IN to pulling the PRIVATE @bongos/core from the npm
+// registry (PROVISION_CORE_FROM_REGISTRY=1) instead of vendoring a tarball, with a
+// fail-soft fallback to the vendored path when no NPM_TOKEN is present.
+const { registryCoreRequested, hasNpmToken } = require('./npmrc');
+
 // The HTTP User-Agent the manifest conversion stamps its GitHub call with (GitHub
 // requires a UA). Overridable so a fork can identify itself; not secret.
 const MANIFEST_UA = process.env.PROVISION_GITHUB_UA || 'cloudbongos-provisioner';
@@ -118,7 +124,7 @@ const CONFIG = {
   // since the control plane and the run box are then the same machine.
   controlPlaneIp: process.env.PROVISION_CONTROL_PLANE_IP || null,
   // Parent dir for a STANDALONE instance's OWN repo checkout (hosting_shape='standalone',
-  // ADR 0108): each lives at <standaloneBase>/<slug> with @cloudbongos/core installed as
+  // ADR 0108): each lives at <standaloneBase>/<slug> with @bongos/core installed as
   // an npm dep. Distinct from co-tenant (which shares THIS control-plane checkout).
   standaloneBase: process.env.PROVISION_STANDALONE_BASE || '/srv/cloudbongos',
   // ── Privilege escalation (task 2066, ADR 0128) ───────────────────────────
@@ -207,13 +213,45 @@ function migrateCmd(inst, { privileged = false } = {}) {
     : `PGDATABASE=${dbName(inst)} MEDUSA_GDS_ONLY=1 ./scripts/migrate.sh`;
 }
 
+// Seed the instance's FIRST version so it can take tasks from minute one (task 2119,
+// goal 35). A freshly-migrated instance DB comes up with an EMPTY versions table —
+// migrate runs instance-seeds-off (ADR 0105) and `bongos init` ran --no-seed — yet
+// every task requires a version (tasks.version_id NOT NULL) and POST /versions is
+// Archon-only (no Archon exists until first sign-in). Without a seed here, a brand-new
+// project has NOWHERE to file a task. This runs on the box's DB path (no rank gate),
+// ONLY IF the versions table is empty: idempotent, safe to re-run, and it never
+// disturbs a project that already has versions. Mirrors seedViaApi's shape — V1
+// (status 'building') + one done-when criterion so /status has a finish line from day
+// one. `track` is set EXPLICITLY: versions.track is NOT NULL with no default (mig 112
+// dropped the CHECK), and 'product' matches the canonical V1 seed in 003_pms.sql.
+//
+// The id/name/done_when come from instanceInitSpec so the starter version has ONE
+// source of truth (the same spec the greenfield `bongos init` seed uses). SQL string
+// literals are DOLLAR-QUOTED ($v$…$v$) so the whole -c argument is single-quoted —
+// the one form that is safe UNCHANGED across all three executors: inline (/bin/sh),
+// over SSH (bash -s), AND embedded in a dedicated droplet's cloud-init (bash -lc "…"),
+// with no nested-quote or $-expansion hazard.
+function seedFirstVersionCmd(inst, { privileged = false } = {}) {
+  const v = instanceInitSpec(inst).version;
+  const q = (s) => `$v$${s}$v$`;                 // dollar-quoted literal (no value contains a single quote or $)
+  const sql =
+    `INSERT INTO versions (id, name, track, status, done_when) ` +
+    `SELECT ${q(v.id)}, ${q(v.name)}, $v$product$v$, $v$building$v$, ${q(v.done_when)} ` +
+    `WHERE NOT EXISTS (SELECT 1 FROM versions); ` +
+    `INSERT INTO done_when_criteria (version_id, criterion_id, criterion_md, sort_order) ` +
+    `SELECT ${q(v.id)}, $v$first-goal$v$, ${q(v.done_when)}, 10 ` +
+    `WHERE EXISTS (SELECT 1 FROM versions WHERE id = ${q(v.id)}) ` +
+    `AND NOT EXISTS (SELECT 1 FROM done_when_criteria WHERE version_id = ${q(v.id)} AND criterion_id = $v$first-goal$v$);`;
+  return asPostgres(`psql -v ON_ERROR_STOP=1 -d ${dbName(inst)} -c '${sql}'`, privileged);
+}
+
 // ── STANDALONE shape (hosting_shape='standalone', ADR 0108, task 1978) ────────
 // A standalone instance runs from its OWN repo checkout (host content: config/,
-// migrations/instance/, the core PIN in package.json) with @cloudbongos/core installed
+// migrations/instance/, the core PIN in package.json) with @bongos/core installed
 // as an npm DEPENDENCY — NOT the shared control-plane checkout the co-tenant shape uses.
 // It is the ADR 0108 DESTINATION model; these generators make provision.js drive the
 // scripts/deploy/deploy-instance.sh runbook API-driven instead of by hand.
-const CORE_PKG_DIR = 'node_modules/@cloudbongos/core';
+const CORE_PKG_DIR = 'node_modules/@bongos/core';
 function standaloneRoot(inst, { base = CONFIG.standaloneBase } = {}) { return path.posix.join(base, inst.slug); }
 // Sync the instance's own repo (host content + the core pin). Mirrors deploy-instance.sh
 // step 1 — assumes the repo is already cloned at standaloneRoot (initial clone is a
@@ -281,7 +319,7 @@ function instanceInitSpec(inst, { ownerLogin } = {}) {
 const INSTANCE_GITIGNORE = ['node_modules/', 'dist/', '.env', '.env.local', '*.log', ''].join('\n');
 
 // Clone the (empty) target_ref → standaloneRoot → materialize config/ + .claude/ + a
-// file:-pinned @cloudbongos/core + lockfile (via `bongos init --vendor-core`, task 2053)
+// file:-pinned @bongos/core + lockfile (via `bongos init --vendor-core`, task 2053)
 // → commit + push. Idempotent (skips once the repo carries a package.json) and dry-run
 // safe (every mutation goes through the injected exec/writeFile). ADR 0108 / 0125.
 async function scaffoldStandaloneRepo(inst, deps) {
@@ -327,23 +365,44 @@ async function scaffoldStandaloneRepo(inst, deps) {
   }
   exec(`git -C ${root} checkout -B main`);
 
-  // 2. build the installable core tarball from THIS control-plane checkout (the core source).
-  exec(`node scripts/gds/package-core.js`);                       // cwd = REPO_ROOT → dist/cloudbongos-core-<v>.tgz
-  const tgz = path.join(REPO_ROOT, 'dist', `cloudbongos-core-${coreV}.tgz`);
+  // Core-install path (ADR 0134, task 2090). DEFAULT = vendor a tarball built from THIS
+  // control-plane checkout (offline, proven — task 2053). OPT-IN = pull the PRIVATE
+  // @bongos/core from the npm registry (PROVISION_CORE_FROM_REGISTRY=1). The registry
+  // path needs NPM_TOKEN at `npm ci` time; if the flag is set but no token is present we
+  // FAIL SOFT to the vendored path so a tokenless standup still works (never a broken
+  // instance). The env is injectable for tests; the runner falls back to process.env.
+  const env = deps.env || process.env;
+  const wantRegistry = registryCoreRequested(env);
+  const useRegistry = wantRegistry && hasNpmToken(env);
+  if (wantRegistry && !useRegistry) {
+    log('  [scaffold] PROVISION_CORE_FROM_REGISTRY set but no NPM_TOKEN in env — falling back to the vendored-tarball core (ADR 0134 fail-soft).');
+  }
 
-  // 3. materialize config/ + .claude/ + a file:-pinned package.json + lockfile via `bongos init`
-  //    (--vendor-core, task 2053). --no-seed: the instance's own DB is seeded by migrate, not here.
+  // materialize config/ + .claude/ + a pinned package.json + lockfile via `bongos init`.
+  // --no-seed: the instance's own DB is seeded by migrate, not here. Two mutually
+  // exclusive core-resolution shapes:
+  //   registry (--registry-core): caret pin + env-fed .npmrc; `npm ci` pulls from the
+  //     registry. init generates the lockfile (NPM_TOKEN is present — we gated on it).
+  //   vendored (--vendor-core, default): a tarball built from this checkout, file:-pinned.
   const spec = instanceInitSpec(inst, { ownerLogin });
   const specPath = path.join(os.tmpdir(), `bongos-init-${inst.slug}.json`);
   writeFile(specPath, JSON.stringify(spec, null, 2));
-  exec(`node scripts/gds/init.js --from ${specPath} --dir ${root} --no-seed --force --vendor-core ${tgz}`);
+  if (useRegistry) {
+    log(`  [scaffold] core install: registry — PRIVATE @bongos/core@${coreV} via env-fed NPM_TOKEN (ADR 0134)`);
+    exec(`node scripts/gds/init.js --from ${specPath} --dir ${root} --no-seed --force --registry-core`);
+  } else {
+    log(`  [scaffold] core install: vendored tarball (offline default)`);
+    exec(`node scripts/gds/package-core.js`);                      // cwd = REPO_ROOT → dist/bongos-core-<v>.tgz
+    const tgz = path.join(REPO_ROOT, 'dist', `bongos-core-${coreV}.tgz`);
+    exec(`node scripts/gds/init.js --from ${specPath} --dir ${root} --no-seed --force --vendor-core ${tgz}`);
+  }
 
   // 4. commit + push the scaffold to the instance's own main (keep node_modules out).
   writeFile(path.join(root, '.gitignore'), INSTANCE_GITIGNORE);
   exec(`git -C ${root} config user.name "Cloud Bongos"`);
   exec(`git -C ${root} config user.email "bot@cloudbongos.com"`);
   exec(`git -C ${root} add -A`);
-  exec(`git -C ${root} commit -m "chore: scaffold ${inst.slug} on a pinned @cloudbongos/core ${coreV} (provision.js, ADR 0108)"`, { allowFail: true });
+  exec(`git -C ${root} commit -m "chore: scaffold ${inst.slug} on a pinned @bongos/core ${coreV} (provision.js, ADR 0108)"`, { allowFail: true });
   exec(`git -C ${root} push -u origin main`);
   log(`  [scaffold] pushed initial scaffold to ${repo.owner}/${repo.name}@main`);
   return { ok: true, scaffolded: true };
@@ -446,11 +505,25 @@ ${prefix}_OAUTH_ORIGIN=${origin}
 # GitHub App Manifest flow (ADR 0133) — the owner clicked one link; no secret was pasted.`
     : `# Provisioned by scripts/gds/provision.js (ADR 0111). Fill the OAuth app creds via the
 # one-click GitHub App Manifest flow (ADR 0133), or manually (oauth-secret.js place):`;
+  // The founding owner (firstAdmin): the GitHub login src/bongos/auth.js seats as the
+  // instance's first Archon on first sign-in (maybeSeatFirstAdmin checks
+  // <prefix>_FIRST_ADMIN before branding.firstAdmin). WITHOUT it a provisioned instance
+  // has NO owner — first sign-in is refused / lands rankless and the owner can never
+  // claim their own instance (goal 35 / criterion 165 regression, caught live 2026-07-07:
+  // demo had every origin override but no FIRST_ADMIN, so lars589 could not be seated).
+  // Derived from the instance repo owner (target_ref = "<owner>/<repo>"), the SAME source
+  // instanceInitSpec uses for the scaffold's branding.firstAdmin — so this env override and
+  // the scaffolded config/branding.json agree. (Org-owned repo: the org login is not a
+  // sign-in identity, so it is left unset; the owner sets <prefix>_FIRST_ADMIN by hand.)
+  const ownerRepo = parseTargetRef(inst.target_ref);
+  const firstAdminLine = ownerRepo && ownerRepo.owner
+    ? `${prefix}_FIRST_ADMIN=${ownerRepo.owner}\n`
+    : '';
   return `# /etc/${inst.slug}/web.env — per-instance secrets (chmod 600, OUTSIDE the repo).
 ${credComment}
 ${prefix}_GITHUB_CLIENT_ID=${clientId || ''}
 ${prefix}_GITHUB_CLIENT_SECRET=${clientSecret || ''}
-GDS_BRANDING_FILE=${PROVISIONED_BRANDING_FILE}
+${firstAdminLine}GDS_BRANDING_FILE=${PROVISIONED_BRANDING_FILE}
 ${originLines}PORT=${inst.port}
 PGDATABASE=${dbName(inst)}
 `;
@@ -808,7 +881,7 @@ async function provisionInstance(inst, deps) {
     // Co-tenant OR standalone: a process bound to an allocated port on the box it runs
     // on. Co-tenant shares that box's checkout ($0, cloudbongos.com model — under
     // remote-exec, the co-hosting box); standalone (ADR 0108) runs from its OWN repo
-    // dir with a pinned @cloudbongos/core (synced in step 2) on the CONTROL PLANE.
+    // dir with a pinned @bongos/core (synced in step 2) on the CONTROL PLANE.
     // Allocate against the ports of whichever box it runs on (boxExec: remote for a
     // co-tenant, local for a standalone — task 2074), then run the rest there.
     if (!inst.port) {
@@ -838,11 +911,16 @@ async function provisionInstance(inst, deps) {
   // ── step 2: code sync (standalone) + database ─────────────────────────────
   if (local && standalone) {
     // Standalone (ADR 0108 / deploy-instance.sh steps 1-2): sync the instance's own
-    // repo + install the pinned @cloudbongos/core, so the migrate + service below run
+    // repo + install the pinned @bongos/core, so the migrate + service below run
     // from the INSTANCE root, not this control-plane checkout. cwd = standaloneRoot.
     // boxExec = the control plane (where scaffoldStandaloneRepo just created the dir).
+    // REGISTRY CORE (ADR 0134): when the scaffold pinned the registry core, the committed
+    // .npmrc reads `_authToken=${NPM_TOKEN}` — so `npm ci` resolves the PRIVATE package
+    // only if NPM_TOKEN is in this runner's env (makeExec inherits process.env). The
+    // scaffold already gated on the token, so it is present; the VENDORED default needs
+    // no token (the tarball is committed). A tokenless registry `npm ci` 404s cleanly.
     const root = standaloneRoot(inst);
-    log('  [code] standalone — pull instance repo + npm ci (pinned @cloudbongos/core)');
+    log('  [code] standalone — pull instance repo + npm ci (pinned @bongos/core)');
     boxExec(standalonePullCmd(), { cwd: root });
     boxExec(standaloneInstallCmd(), { cwd: root });
   }
@@ -851,7 +929,13 @@ async function provisionInstance(inst, deps) {
     boxExec(dbCreateCmd(inst, { privileged }), { allowFail: true });   // "already exists" is fine
     if (standalone) boxExec(standaloneMigrateCmd(inst, { privileged }), { cwd: standaloneRoot(inst) });  // instance-root migrate
     else boxExec(migrateCmd(inst, { privileged }));
-  } else { log('    (runs via cloud-init on the droplet)'); }
+    // Seed the first version so the instance can take tasks from minute one (task 2119,
+    // goal 35). Only fires if the versions table is empty — idempotent, never disturbs an
+    // existing project. NOT allowFail: a re-run is a clean 0-row no-op, so a real failure
+    // here should surface. Dedicated bakes the same step into cloud-init (dedicatedUserData).
+    log('  [seed] first version (only if versions is empty)');
+    boxExec(seedFirstVersionCmd(inst, { privileged }));
+  } else { log('    (db create + migrate + first-version seed run via cloud-init on the droplet)'); }
 
   // ── step 3: config + per-instance secrets ─────────────────────────────────
   log('  [config] per-instance web.env');
@@ -929,6 +1013,7 @@ function dedicatedUserData(inst) {
 runcmd:
   - [ bash, -lc, "${dbCreateCmd(i)} || true" ]
   - [ bash, -lc, "cd ${REPO_ROOT} && ${migrateCmd(i)}" ]
+  - [ bash, -lc, "${seedFirstVersionCmd(i)}" ]
   - [ bash, -lc, "systemctl daemon-reload && systemctl enable --now ${i.slug}" ]
 `;
 }
@@ -1310,7 +1395,7 @@ if (require.main === module) main();
 module.exports = {
   CONFIG, MAX_INTENT_ATTEMPTS,
   // pure step generators (tested directly)
-  dbName, dbCreateCmd, migrateCmd, serviceUnit, serviceUnitPath, webEnvBody, webEnvPath,
+  dbName, dbCreateCmd, migrateCmd, seedFirstVersionCmd, serviceUnit, serviceUnitPath, webEnvBody, webEnvPath,
   standaloneRoot, standalonePullCmd, standaloneInstallCmd, standaloneMigrateCmd,
   // standalone scaffold (ADR 0108 / 0125, task 2055)
   parseTargetRef, instanceRepoRemote, instanceInitSpec, scaffoldStandaloneRepo, coreVersionSafe,

package/scripts/gds/seed-adopt-tasks.js

@@ -19,7 +19,7 @@ const RUNBOOK_TASK = 1981; // goal-35 canonical runbook; A05 depends on it (exte
 const TASKS = [
   { ref: 'A01', kind: 'feature', priority: 4, est: 180, crit: [CRIT], deps: [], extDeps: [],
     title: 'bongos init --adopt: mode skeleton + additive config layering (no clobber)',
-    description: 'Add an `--adopt` mode to `scripts/gds/init.js` (ADR 0121 §Decision 1-2). Instead of the greenfield "stand up a NEW instance" path (which refuses where config/branding.json exists and whose --force OVERWRITES), --adopt LAYERS onto the existing tree: add the pinned @cloudbongos/core dependency + the lean config/ overrides + .claude/ ADDITIVELY. For any pre-existing file (package.json, an existing .claude/, a CI workflow) it MERGES or LEAVES-AND-REPORTS — it never overwrites, and it must NOT reuse the --force code path. Writes only the lean branding.json overrides (rest resolves from *.neutral.json). Serves criterion adopt-existing-repo. deps: none (the ADR-0108 configurable-root substrate is shipped).' },
+    description: 'Add an `--adopt` mode to `scripts/gds/init.js` (ADR 0121 §Decision 1-2). Instead of the greenfield "stand up a NEW instance" path (which refuses where config/branding.json exists and whose --force OVERWRITES), --adopt LAYERS onto the existing tree: add the pinned @bongos/core dependency + the lean config/ overrides + .claude/ ADDITIVELY. For any pre-existing file (package.json, an existing .claude/, a CI workflow) it MERGES or LEAVES-AND-REPORTS — it never overwrites, and it must NOT reuse the --force code path. Writes only the lean branding.json overrides (rest resolves from *.neutral.json). Serves criterion adopt-existing-repo. deps: none (the ADR-0108 configurable-root substrate is shipped).' },
   { ref: 'A02', kind: 'feature', priority: 4, est: 150, crit: [CRIT], deps: [], extDeps: [],
     title: 'bongos init --adopt: detect the existing stack + layout',
     description: 'Before writing anything, --adopt inspects the existing tree — language/runtime, package manager, test + CI setup, directory layout — so the enabled modules, the generated repo-map, and the core<->host fitness boundary (ADR 0062 §1) fit what is already there instead of assuming the reference layout (ADR 0121 §Decision 4). Output: a detected-stack summary consumed by A03 (real-state capture) and A04 (pre-flight). Serves criterion adopt-existing-repo. deps: none.' },

package/scripts/gds/status.js

@@ -19,7 +19,7 @@
 //
 // Exit codes: 0 ok · 1 network/api error · 2 bad invocation · 3 not found.
 
-const { API_BASE, cliClient } = require('./cli-lib');
+const { API_BASE, cliClient, assertInstanceMatch } = require('./cli-lib');
 
 // The active internal version; override with GDS_STATUS_DEFAULT_VERSION (or pass
 // --version). Bumped GDS-V4 → BONGOS-V1 (task 1709, ADR 0103): GDS-V4 was
@@ -319,6 +319,11 @@ async function main() {
     console.log('Usage: node scripts/gds/status.js [--version ID] [Cn] [--json]');
     process.exit(0);
   }
+  // Fail closed if this repo's configured instance != the signed-in session's (task
+  // 2124 / demo-audit C2): fetchProgress uses a raw fetch(API_BASE/…) that bypasses the
+  // apiCall/cliClient guard, so without this `bongos status` would silently print another
+  // instance's progress. Skip only in --hook mode (the automated card path stays fail-open).
+  if (!opts.hook) await assertInstanceMatch();
   const data = await fetchProgress(opts.version);
 
   // Resolve the requested criterion (if any) once — every output mode needs it.

package/scripts/gds/task.js

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+// scripts/gds/task.js — `bongos task` : create + show a Bongos task from the terminal.
+//
+// task 2123 (demo-audit fix C1). The bongos CLI had start/claim/ship/status/… but no
+// way to CREATE a task — so seeding the first task (a new owner's opening move) meant
+// hand-driving POST /api/bongos/tasks through `bongos exec scripts/gds/api.js`. This is
+// the first-class front door.
+//
+// Usage:
+//   bongos task new --title "…" --description "…" [--kind feature] [--discipline engineer]
+//                   [--priority 3] [--version <id>] [--goal <id>] [--criteria C1,C2]
+//                   [--touches a/,b/] [--est-minutes N] [--credits N] [--ready] [--json]
+//   bongos task show <id> [--json]
+//
+// Task CREATION is Archon-gated SERVER-SIDE (creating work shapes scope, ADR 0016). This
+// CLI adds no authority — a lower rank gets a clear 403 message pointing at idea capture.
+
+const { cliClient, requireSession, arg, hasFlag } = require('./cli-lib');
+
+// Valid enums (mirrors the server's task-classifier vocab; a friendly client-side check
+// so an obvious typo fails before the round-trip — the server stays authoritative).
+const VALID_KINDS = ['feature', 'bug', 'infra', 'refactor', 'spike', 'learning-capture', 'cleanup', 'decision', 'blocker-resolution', 'verify'];
+const VALID_DISCIPLINES = ['engineer', 'artist', 'ideator', 'ui'];
+
+function csv(v) {
+  return String(v || '').split(',').map((s) => s.trim()).filter(Boolean);
+}
+
+// PURE argv → { body, criteria, errors } — exported for the unit test (no network).
+// `args` is the argv slice AFTER the `new` subcommand.
+function buildTaskBody(args) {
+  const errors = [];
+  const title = arg('--title', args);
+  const description = arg('--description', args);
+  if (!title) errors.push('--title is required');
+  if (!description) errors.push('--description is required');
+
+  const kind = arg('--kind', args) || 'feature';
+  if (!VALID_KINDS.includes(kind)) errors.push(`--kind must be one of: ${VALID_KINDS.join(', ')}`);
+  const discipline = arg('--discipline', args) || 'engineer';
+  if (!VALID_DISCIPLINES.includes(discipline)) errors.push(`--discipline must be one of: ${VALID_DISCIPLINES.join(', ')}`);
+
+  const num = (flag) => { const v = arg(flag, args); return v == null ? undefined : Number(v); };
+  const priority = num('--priority');
+  if (priority !== undefined && (!Number.isInteger(priority) || priority < 1 || priority > 5)) {
+    errors.push('--priority must be an integer 1–5');
+  }
+  const goalRaw = arg('--goal', args);
+  const goalId = goalRaw == null ? undefined : Number(goalRaw);
+  if (goalRaw != null && (!Number.isInteger(goalId) || goalId <= 0)) errors.push('--goal must be a positive integer task-goal id');
+
+  const body = {
+    title,
+    description,
+    kind,
+    discipline,
+    status: hasFlag('--ready', args) ? 'ready' : 'backlog',
+    source: 'bongos-task-cli',
+  };
+  const version = arg('--version', args);
+  if (version) body.version_id = version;
+  if (goalId !== undefined) body.goal_id = goalId;
+  if (priority !== undefined) body.priority = priority;
+  const est = num('--est-minutes'); if (est !== undefined) body.est_minutes = est;
+  const md = num('--manual-degree'); if (md !== undefined) body.manual_degree = md;
+  const credits = num('--credits'); if (credits !== undefined) body.credits_reward = credits;
+  const touches = csv(arg('--touches', args)); if (touches.length) body.touches = touches;
+  const criteria = csv(arg('--criteria', args));
+  if (criteria.length) body.criterion_ids = criteria;
+
+  return { body, criteria, errors };
+}
+
+function usage() {
+  console.error('usage:');
+  console.error('  bongos task new --title "…" --description "…" [--kind feature] [--discipline engineer]');
+  console.error('                  [--priority 3] [--version <id>] [--goal <id>] [--criteria C1,C2]');
+  console.error('                  [--touches a/,b/] [--est-minutes N] [--credits N] [--ready] [--json]');
+  console.error('  bongos task show <id> [--json]');
+  console.error(`\n  kinds: ${VALID_KINDS.join(' | ')}`);
+  console.error(`  disciplines: ${VALID_DISCIPLINES.join(' | ')}`);
+}
+
+function hallLink(base, id) {
+  try { return `${new URL(base).origin}/builders#/task/${id}`; } catch { return `task #${id}`; }
+}
+
+// The version_id a task defaults to when --version is omitted: the most-recent
+// BUILDING version (the capture.js precedent, so idea-capture and task-create agree).
+// Returns null when none is building — the caller then requires an explicit --version.
+async function resolveDefaultVersion(api) {
+  const r = await api.versions.getVersions();
+  if (!r.ok) return null;
+  const building = (r.data?.versions ?? []).filter((v) => v.status === 'building');
+  if (building.length === 0) return null;
+  building.sort((a, b) => {
+    const ta = a.started_at ? new Date(a.started_at).getTime() : 0;
+    const tb = b.started_at ? new Date(b.started_at).getTime() : 0;
+    return tb - ta;
+  });
+  return building[0].id;
+}
+
+async function cmdNew(args) {
+  const { body, errors } = buildTaskBody(args);
+  if (errors.length) { console.error('task new: ' + errors.join('; ') + '\n'); usage(); process.exit(2); }
+  const api = await cliClient();
+  // version_id is required by the API; default to the active (building) version so a
+  // new owner never has to know the id, but keep --version as the explicit override.
+  if (!body.version_id) {
+    body.version_id = await resolveDefaultVersion(api);
+    if (!body.version_id) {
+      console.error('task new: could not resolve an active version — pass --version <id> (see `bongos status`).');
+      process.exit(2);
+    }
+  }
+  const r = await api.tasks.postTasks({ body });
+  if (r.status === 403) {
+    console.error('Creating a task is Archon-gated (creating work shapes scope). Your rank is lower, so the server declined.');
+    console.error('To propose it instead, capture an idea for triage:');
+    console.error('  bongos exec scripts/gds/capture.js "<your idea>"');
+    process.exit(1);
+  }
+  if (r.status !== 201 || !r.data?.task) {
+    console.error(`task new failed (${r.status}):`, r.data);
+    process.exit(1);
+  }
+  const task = r.data.task;
+  if (hasFlag('--json', args)) { console.log(JSON.stringify(task, null, 2)); return; }
+  const { API_BASE } = require('./cli-lib');
+  console.log(`✓ Created task #${task.id} [${task.status}] — ${task.title}`);
+  console.log(`  kind=${task.kind} · discipline=${task.discipline}${task.priority ? ` · P${task.priority}` : ''}${task.goal_id ? ` · goal ${task.goal_id}` : ''}`);
+  console.log(`  ${hallLink(API_BASE, task.id)}`);
+  if (task.status !== 'ready') console.log(`  (status '${task.status}' — pass --ready to make it claimable now, deps permitting)`);
+  console.log(`  next: bongos claim ${task.id}`);
+}
+
+async function cmdShow(args) {
+  const id = Number(args[0]);
+  if (!Number.isInteger(id) || id <= 0) { console.error('usage: bongos task show <id>'); process.exit(2); }
+  const api = await cliClient();
+  const r = await api.tasks.getTasksId({ id });
+  if (r.status === 404) { console.error(`task #${id} not found.`); process.exit(1); }
+  if (r.status !== 200 || !r.data?.task) { console.error(`task show failed (${r.status}):`, r.data); process.exit(1); }
+  const task = r.data.task;
+  if (hasFlag('--json', args)) { console.log(JSON.stringify(task, null, 2)); return; }
+  console.log(`#${task.id} [${task.status}] — ${task.title}`);
+  console.log(`kind=${task.kind} · discipline=${task.discipline}${task.priority ? ` · P${task.priority}` : ''}${task.goal_id ? ` · goal ${task.goal_id}` : ''}${task.version_id ? ` · ${task.version_id}` : ''}`);
+  if (task.description) console.log(`\n${task.description}`);
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const sub = args[0];
+  if (!sub || sub === 'help' || sub === '--help' || sub === '-h') { usage(); process.exit(sub ? 0 : 2); }
+  await requireSession();
+  if (sub === 'new') return cmdNew(args.slice(1));
+  if (sub === 'show') return cmdShow(args.slice(1));
+  console.error(`task: unknown subcommand "${sub}"\n`); usage(); process.exit(2);
+}
+
+if (require.main === module) {
+  main().catch((err) => { console.error('fatal:', err); process.exit(1); });
+}
+
+module.exports = { buildTaskBody, VALID_KINDS, VALID_DISCIPLINES, csv, hallLink };