@bongos/core 1.19.804 → 1.19.805

package/scripts/gds/session-digest.js

@@ -2,7 +2,7 @@
 // scripts/gds/session-digest.js — BFG 6D session capture on the SessionEnd seam
 // (ADR 0027; follow-up to #608/#617, idea #178).
 //
-// Uploads the FULL session digest to the BFG corpus (POST /api/gds/sessions)
+// Uploads the FULL session digest to the BFG corpus (POST /api/bongos/sessions)
 // when a Claude Code session ENDS. Wired as a SessionEnd hook in
 // .claude/settings.json (sibling to session-cost.js), which pipes
 // { session_id, transcript_path, cwd, reason } as JSON on stdin.

package/scripts/gds/session.js

@@ -11,8 +11,8 @@
 //   --all          show the long-tail (everything else that's claimable)
 //   --json         machine-readable output
 //
-// Calls POST /api/gds/session/optimize when available; falls back to
-// GET /api/gds/tasks/claimable + a deterministic local greedy when the
+// Calls POST /api/bongos/session/optimize when available; falls back to
+// GET /api/bongos/tasks/claimable + a deterministic local greedy when the
 // endpoint isn't deployed yet (P1 #44 ships it in parallel; P2 #45 the
 // batch-claim endpoint is also not in flight). The fallback uses the same
 // scoring rules so the recommendation set is stable either way.

package/scripts/gds/setup.js

@@ -286,7 +286,7 @@ const { isDeviceFlowDisabled, deviceFlowFallbackLines } = require('./device-flow
 async function redeemCliToken(token) {
   let res;
   try {
-    res = await fetch(`${API_BASE}/api/gds/me`, { headers: { Authorization: `Bearer ${token}` } });
+    res = await fetch(`${API_BASE}/api/bongos/me`, { headers: { Authorization: `Bearer ${token}` } });
   } catch (err) {
     console.error(`Could not reach ${API_BASE}: ${err.message}`);
     return { ok: false, status: 0 };
@@ -392,7 +392,7 @@ async function main() {
     console.log('');
     const preExisting = await loadSession();
     if (preExisting && preExisting.token && !forceFlag) {
-      dryRunStep(`Would verify existing session at ${SESSION_PATH} via GET /api/gds/me.`);
+      dryRunStep(`Would verify existing session at ${SESSION_PATH} via GET /api/bongos/me.`);
       dryRunStep('If the token is valid: on an interactive shell, would ASK whether to continue as that builder or set up as a different one ([1] continue / [2] sign in again, replacing the saved session). Non-interactive shells keep the existing session. (--force skips the question and re-auths directly.)');
       dryRunStep('If the token is rejected (401), would fall through to the Device Flow.');
     } else if (preExisting && forceFlag) {
@@ -400,17 +400,17 @@ async function main() {
     } else {
       dryRunStep(`No existing session at ${SESSION_PATH}; would proceed straight to Device Flow.`);
     }
-    dryRunStep('Would POST /api/gds/auth/device/start to get a user_code + verification_uri from GitHub.');
+    dryRunStep('Would POST /api/bongos/auth/device/start to get a user_code + verification_uri from GitHub.');
     dryRunStep('If GitHub refuses with device_flow_disabled (a one-click App whose checkbox is unticked, task 1003051): would print the web sign-in guidance (hall Settings → CLI Access) and prompt for a pasted CLI token instead of dead-ending.');
-    dryRunStep('Would print the verification_uri and user_code, then poll /api/gds/auth/device/poll every few seconds until the user approves or the code expires.');
+    dryRunStep('Would print the verification_uri and user_code, then poll /api/bongos/auth/device/poll every few seconds until the user approves or the code expires.');
     dryRunStep(`On approval, would write the bearer token + builder profile to ${SESSION_PATH} (chmod 600).`);
     if (SKIP_KEYS) {
       dryRunStep('Would skip the Gemini-key prompt (--skip-keys set).');
     } else {
       dryRunStep(`Would prompt for a per-builder GOOGLE_AI_STUDIO_KEY on TTY shells and store it as gemini_api_key in ${SESSION_PATH} (mode 600). Used by modules/art-pipeline/pipeline/gen_api.py for per-builder cost attribution.`);
     }
-    dryRunStep('Would read ~/.claude.json oauthAccount and, on a TTY, prompt to confirm the Anthropic email; on a match would POST /api/gds/me/anthropic-link and store anthropic_user_id in the session (kept as cosmetic attribution; the identity pin was removed — task 1039 / idea 258). On mismatch would REFUSE to link.');
-    dryRunStep('Would prompt for preferred disciplines (creative / engineering / both / skip) and PATCH /api/gds/me/disciplines on TTY shells.');
+    dryRunStep('Would read ~/.claude.json oauthAccount and, on a TTY, prompt to confirm the Anthropic email; on a match would POST /api/bongos/me/anthropic-link and store anthropic_user_id in the session (kept as cosmetic attribution; the identity pin was removed — task 1039 / idea 258). On mismatch would REFUSE to link.');
+    dryRunStep('Would prompt for preferred disciplines (creative / engineering / both / skip) and PATCH /api/bongos/me/disciplines on TTY shells.');
     dryRunStep(`Would prompt for onboarding-friction consent (Y/n) and record the decision to ${onboardingConfig.CONSENT_PATH} on TTY shells.`);
     dryRunStep('Would print "Authenticated as <github_login>" and exit 0.');
     process.exit(0);
@@ -503,7 +503,7 @@ async function main() {
   // GitHub device flow below (auth.idp unset) is untouched — the self-hosted default.
   let idpCfg = null;
   try {
-    const m = await fetch(`${API_BASE}/api/gds/instance`);
+    const m = await fetch(`${API_BASE}/api/bongos/instance`);
     const mj = m.ok ? await m.json() : null;
     idpCfg = (mj && mj.auth && mj.auth.idp) || null;
   } catch (_) { /* manifest unreachable → fall through to the direct flow */ }

package/scripts/gds/ship-flow.js

@@ -563,7 +563,7 @@ async function shipMain() {
         console.error('  grade fails, fix its findings and re-run (unlimited, no attempt cap):');
         console.error(`      node scripts/gds/ship.js ${taskId} --regrade`);
         console.error(`  If the grade genuinely cannot pass, ask a builder whose role holds`);
-        console.error(`  task.confirm.grade_bypass${floorNote} to POST /api/gds/tasks/${taskId}/confirm.`);
+        console.error(`  task.confirm.grade_bypass${floorNote} to POST /api/bongos/tasks/${taskId}/confirm.`);
         process.exit(1);
       }
       console.error(`manual-confirm failed: ${apiErrorLine(confirm.data, confirm.status)}`);
@@ -601,7 +601,7 @@ async function shipMain() {
       console.error('Task stays at completed. Manual options:');
       console.error(`  - Re-run /builder-ship ${taskId} to try grading again, or`);
       console.error(`  - node scripts/gds/ship.js ${taskId} --regrade after fixing findings, or`);
-      console.error(`  - POST /api/gds/tasks/${taskId}/confirm to manual-confirm (last resort —`);
+      console.error(`  - POST /api/bongos/tasks/${taskId}/confirm to manual-confirm (last resort —`);
       console.error('    permission-gated on task.confirm.grade_bypass).');
       process.exit(1);
     }
@@ -896,7 +896,7 @@ async function regradeMain() {
           console.error('');
           console.error(`✖ Confirming without a passing grade is permission-gated: task.confirm.grade_bypass${floor ? ` (floor: ${floor})` : ''}.`);
           console.error('  This is an authorization wall, not a verdict on your work.');
-          console.error(`  Ask a builder whose role holds it to POST /api/gds/tasks/${taskId}/confirm.`);
+          console.error(`  Ask a builder whose role holds it to POST /api/bongos/tasks/${taskId}/confirm.`);
           process.exit(1);
         }
         console.error(`manual-confirm failed: ${apiErrorLine(confirm.data, confirm.status)}`);

package/scripts/gds/ship-grade-steps.js

@@ -293,7 +293,7 @@ function formatGradeOutcome(g, taskId, cliFinding = null) {
     out.push('When the grader is reachable again, re-grade:');
     out.push(`  node scripts/gds/ship.js ${taskId} --regrade`);
     out.push('Or land it now via manual-confirm:');
-    out.push(`  curl -X POST -H "Authorization: Bearer <token>" ${resolveInstanceBase() || '<instance-origin>'}/api/gds/tasks/${taskId}/confirm`);
+    out.push(`  curl -X POST -H "Authorization: Bearer <token>" ${resolveInstanceBase() || '<instance-origin>'}/api/bongos/tasks/${taskId}/confirm`);
     return out.join('\n');
   }
 
@@ -350,7 +350,7 @@ function formatGradeOutcome(g, taskId, cliFinding = null) {
     out.push('When the grader is healthy again, re-grade:');
     out.push(`  node scripts/gds/ship.js ${taskId} --regrade`);
     out.push('Or land it now via manual-confirm:');
-    out.push(`  curl -X POST -H "Authorization: Bearer <token>" ${resolveInstanceBase() || '<instance-origin>'}/api/gds/tasks/${taskId}/confirm`);
+    out.push(`  curl -X POST -H "Authorization: Bearer <token>" ${resolveInstanceBase() || '<instance-origin>'}/api/bongos/tasks/${taskId}/confirm`);
     return out.join('\n');
   }
 
@@ -377,7 +377,7 @@ function formatGradeOutcome(g, taskId, cliFinding = null) {
     out.push('Grade failed — task stays at completed. Fix the issues above, commit, then re-grade:');
     out.push(`  node scripts/gds/ship.js ${taskId} --regrade`);
     out.push('Last resort (only if the grade was wrong):');
-    out.push(`  curl -X POST -H "Authorization: Bearer <token>" ${resolveInstanceBase() || '<instance-origin>'}/api/gds/tasks/${taskId}/confirm`);
+    out.push(`  curl -X POST -H "Authorization: Bearer <token>" ${resolveInstanceBase() || '<instance-origin>'}/api/bongos/tasks/${taskId}/confirm`);
   }
   return out.join('\n');
 }

package/scripts/gds/ship-memory-sync.js

@@ -17,7 +17,7 @@ const { REPO_ROOT } = require('./ship-state.js');
 // ---------- Memory sync-on-ship (Task #274 / V3.R55) ----------
 //
 // After a successful ship, push the builder's local Claude Code memory dir to
-// the server (POST /api/gds/memory/sync), so a builder's MEMORY.md +
+// the server (POST /api/bongos/memory/sync), so a builder's MEMORY.md +
 // feedback_*.md follow them across machines and survive a dead laptop. This is
 // the push half of ADR 0024's cloneable-memory chain; #275 wires the pull side.
 //

package/scripts/gds/ship-session-upload.js

@@ -18,7 +18,7 @@ const { REPO_ROOT } = require('./ship-state.js');
 // ---------- Session upload-on-ship (6D.1 / ADR 0027) ----------
 //
 // After a successful ship, upload a COMPACT, secret-scrubbed digest of this
-// Claude Code session (POST /api/gds/sessions), so the BFG (a local Claude Code
+// Claude Code session (POST /api/bongos/sessions), so the BFG (a local Claude Code
 // routine — 6D.3) can later search the corpus (6D.2) and deep-dive the wasteful
 // sessions. We never upload raw transcript CONTENT — only per-turn metadata
 // (role, tool name, error flag, token usage, length) + short scrubbed snippets
@@ -277,14 +277,14 @@ async function uploadSessionOnShip(taskId) {
       recordUploadSkip(taskId, {
         code: 'session_invalid',
         reason:
-          'POST /api/gds/sessions returned 401 — the GDS session token is missing or invalid, so the ' +
+          'POST /api/bongos/sessions returned 401 — the GDS session token is missing or invalid, so the ' +
           'digest was rejected. Re-auth with /builder-reauth. This ship will NOT appear in the BFG session corpus.',
       });
     } else {
       recordUploadSkip(taskId, {
         code: `http_${r.status}`,
         reason:
-          `POST /api/gds/sessions returned ${r.status}${r.data && r.data.error ? ` (${apiErrorLine(r.data)})` : ''} — ` +
+          `POST /api/bongos/sessions returned ${r.status}${r.data && r.data.error ? ` (${apiErrorLine(r.data)})` : ''} — ` +
           'the API rejected or could not store the digest. This ship will NOT appear in the BFG session corpus.',
       });
     }

package/scripts/gds/smoke-batch-claim.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 # GDS batch-claim smoke test. Renamed from PMS in V3.R01.
 #
-# Exercises POST /api/gds/claims/batch:
+# Exercises POST /api/bongos/claims/batch:
 #   Case A: 2 ready tasks, disjoint touches → 201, 2 claim rows.
 #   Case B: 2 ready tasks, OVERLAPPING touches → 409, BATCH_TOUCHES_CONFLICT,
 #           no claims persisted (both tasks stay 'ready').
@@ -70,7 +70,7 @@ print(json.dumps({
   'source': 'smoke',
   'source_ref': '${ts}-${suffix}'
 }))")
-  parse_call "$(call POST /api/gds/tasks "${body}")"
+  parse_call "$(call POST /api/bongos/tasks "${body}")"
   python3 -c "import json,sys; print(json.loads('''${PAYLOAD}''')['task']['id'])"
 }
 
@@ -83,7 +83,7 @@ cleanup() {
   echo "--- cleanup ---"
   for cid in "${CREATED_CLAIMS[@]:-}"; do
     [[ -z "${cid}" ]] && continue
-    call POST "/api/gds/claims/${cid}/resolve" \
+    call POST "/api/bongos/claims/${cid}/resolve" \
       '{"outcome":"abandoned","notes_md":"smoke cleanup"}' >/dev/null || true
   done
   for tid in "${CREATED_TASKS[@]:-}"; do
@@ -94,7 +94,7 @@ cleanup() {
     # failure. Every run since has leaked its fixtures as status='ready'
     # (the 2026-05-11 batch, then 1001920-1001925 from 2026-07-03). The real
     # endpoint is POST /tasks/:id/abandon {"reason": ...}.
-    if ! call POST "/api/gds/tasks/${tid}/abandon" \
+    if ! call POST "/api/bongos/tasks/${tid}/abandon" \
          '{"reason":"smoke cleanup (scripts/gds/smoke-batch-claim.sh)"}' >/dev/null 2>&1; then
       leaked+=("${tid}")
     fi
@@ -127,7 +127,7 @@ CREATED_TASKS+=("${TA1}" "${TA2}")
 echo "  created tasks ${TA1}, ${TA2}"
 
 BODY_A=$(python3 -c "import json; print(json.dumps({'task_ids':[${TA1},${TA2}],'worktree_name':'__smoke_batch__'}))")
-parse_call "$(call POST /api/gds/claims/batch "${BODY_A}")"
+parse_call "$(call POST /api/bongos/claims/batch "${BODY_A}")"
 if [[ "${CODE}" == "201" ]]; then
   N=$(python3 -c "import json,sys; print(len(json.loads('''${PAYLOAD}''')['claims']))")
   if [[ "${N}" == "2" ]]; then
@@ -154,7 +154,7 @@ CREATED_TASKS+=("${TB1}" "${TB2}")
 echo "  created tasks ${TB1}, ${TB2} (both touch __smoke__/batch/${ts}/shared)"
 
 BODY_B=$(python3 -c "import json; print(json.dumps({'task_ids':[${TB1},${TB2}]}))")
-parse_call "$(call POST /api/gds/claims/batch "${BODY_B}")"
+parse_call "$(call POST /api/bongos/claims/batch "${BODY_B}")"
 if [[ "${CODE}" == "409" ]]; then
   REASON=$(python3 -c "
 import json,sys
@@ -170,7 +170,7 @@ print(','.join(reasons))
   fi
   # Confirm neither task got claimed (status still 'ready').
   for tid in "${TB1}" "${TB2}"; do
-    parse_call "$(call GET "/api/gds/tasks/${tid}")"
+    parse_call "$(call GET "/api/bongos/tasks/${tid}")"
     S=$(python3 -c "import json,sys; print(json.loads('''${PAYLOAD}''')['task']['status'])")
     if [[ "${S}" == "ready" ]]; then
       ok "B: task #${tid} stayed 'ready' (rollback worked)"
@@ -191,7 +191,7 @@ CREATED_TASKS+=("${TC1}" "${TC2}")
 echo "  created tasks ${TC1} (will pre-claim), ${TC2} (still ready)"
 
 # Pre-claim TC1 via the single-claim path so it's already 'active'.
-parse_call "$(call POST /api/gds/claims "{\"task_id\":${TC1}}")"
+parse_call "$(call POST /api/bongos/claims "{\"task_id\":${TC1}}")"
 if [[ "${CODE}" == "201" ]]; then
   PRE_CLAIM_ID=$(python3 -c "import json,sys; print(json.loads('''${PAYLOAD}''')['claim']['id'])")
   CREATED_CLAIMS+=("${PRE_CLAIM_ID}")
@@ -201,7 +201,7 @@ else
 fi
 
 BODY_C=$(python3 -c "import json; print(json.dumps({'task_ids':[${TC1},${TC2}]}))")
-parse_call "$(call POST /api/gds/claims/batch "${BODY_C}")"
+parse_call "$(call POST /api/bongos/claims/batch "${BODY_C}")"
 if [[ "${CODE}" == "409" ]]; then
   ENUM=$(python3 -c "
 import json,sys
@@ -217,7 +217,7 @@ print(','.join(str(i) for i in ids))
     bad "C: 409 but failures[] missing #${TC1} (got: ${ENUM})"
   fi
   # Confirm TC2 stayed 'ready' (no partial commit).
-  parse_call "$(call GET "/api/gds/tasks/${TC2}")"
+  parse_call "$(call GET "/api/bongos/tasks/${TC2}")"
   S=$(python3 -c "import json,sys; print(json.loads('''${PAYLOAD}''')['task']['status'])")
   if [[ "${S}" == "ready" ]]; then
     ok "C: task #${TC2} stayed 'ready' (no partial commit)"

package/scripts/gds/smoke-batch-release.sh

@@ -1,13 +1,13 @@
 #!/usr/bin/env bash
 # GDS batch-release + dry-run-validate smoke test (task 1758).
 #
-# Exercises POST /api/gds/claims/batch/release:
+# Exercises POST /api/bongos/claims/batch/release:
 #   Case A: 2 own active claims → 200, both in released[], both tasks 'ready'.
 #   Case B: 1 own active claim + 1 bogus claim id → 200 (NOT all-or-nothing —
 #           the batch has no cross-claim invariant), the good one released,
 #           the bad one enumerated in failures[] with CLAIM_NOT_FOUND.
 #
-# Exercises POST /api/gds/claims/batch/validate:
+# Exercises POST /api/bongos/claims/batch/validate:
 #   Case C: 2 ready tasks, disjoint touches → parallel_safe:true, both valid.
 #   Case D: 2 ready tasks, OVERLAPPING touches → parallel_safe:false, both
 #           marked invalid (BATCH_TOUCHES_CONFLICT) — and, since this is a
@@ -76,7 +76,7 @@ print(json.dumps({
   'source': 'smoke',
   'source_ref': '${ts}-${suffix}'
 }))")
-  parse_call "$(call POST /api/gds/tasks "${body}")"
+  parse_call "$(call POST /api/bongos/tasks "${body}")"
   python3 -c "import json,sys; print(json.loads('''${PAYLOAD}''')['task']['id'])"
 }
 
@@ -90,7 +90,7 @@ claim_task() {
   # can hold as many of these as it needs for fixture setup (NULL sessions are
   # explicitly excluded from the uniq_active_claim_per_session index).
   local tid="$1"
-  parse_call "$(call POST /api/gds/claims/batch "{\"task_ids\":[${tid}],\"bind_session\":false}")"
+  parse_call "$(call POST /api/bongos/claims/batch "{\"task_ids\":[${tid}],\"bind_session\":false}")"
   python3 -c "import json,sys; print(json.loads('''${PAYLOAD}''')['claims'][0]['id'])"
 }
 
@@ -104,7 +104,7 @@ cleanup() {
   echo "--- cleanup ---"
   for cid in "${CREATED_CLAIMS[@]:-}"; do
     [[ -z "${cid}" ]] && continue
-    call POST "/api/gds/claims/${cid}/resolve" \
+    call POST "/api/bongos/claims/${cid}/resolve" \
       '{"outcome":"abandoned","notes_md":"smoke cleanup"}' >/dev/null || true
   done
   for tid in "${CREATED_TASKS[@]:-}"; do
@@ -112,7 +112,7 @@ cleanup() {
     # task 1002856: same bug as smoke-batch-claim.sh — /tasks/:id/promote is the
     # backlog->ready transition and ignores a status field, so this never
     # abandoned anything and the redirect swallowed the failure.
-    if ! call POST "/api/gds/tasks/${tid}/abandon" \
+    if ! call POST "/api/bongos/tasks/${tid}/abandon" \
          '{"reason":"smoke cleanup (scripts/gds/smoke-batch-release.sh)"}' >/dev/null 2>&1; then
       leaked+=("${tid}")
     fi
@@ -145,7 +145,7 @@ CA2=$(claim_task "${TA2}"); CREATED_CLAIMS+=("${CA2}")
 echo "  claimed #${TA1}→claim ${CA1}, #${TA2}→claim ${CA2}"
 
 BODY_A=$(python3 -c "import json; print(json.dumps({'claim_ids':[${CA1},${CA2}]}))")
-parse_call "$(call POST /api/gds/claims/batch/release "${BODY_A}")"
+parse_call "$(call POST /api/bongos/claims/batch/release "${BODY_A}")"
 if [[ "${CODE}" == "200" ]]; then
   N=$(python3 -c "import json,sys; print(len(json.loads('''${PAYLOAD}''')['released']))")
   NF=$(python3 -c "import json,sys; print(len(json.loads('''${PAYLOAD}''')['failures']))")
@@ -159,7 +159,7 @@ else
   bad "A: expected 200, got ${CODE} → ${PAYLOAD}"
 fi
 for tid in "${TA1}" "${TA2}"; do
-  parse_call "$(call GET "/api/gds/tasks/${tid}")"
+  parse_call "$(call GET "/api/bongos/tasks/${tid}")"
   S=$(python3 -c "import json,sys; print(json.loads('''${PAYLOAD}''')['task']['status'])")
   if [[ "${S}" == "ready" ]]; then
     ok "A: task #${tid} back to 'ready'"
@@ -179,7 +179,7 @@ BOGUS_CLAIM_ID=999999999
 echo "  claimed #${TB1}→claim ${CB1}; bogus id ${BOGUS_CLAIM_ID}"
 
 BODY_B=$(python3 -c "import json; print(json.dumps({'claim_ids':[${CB1},${BOGUS_CLAIM_ID}]}))")
-parse_call "$(call POST /api/gds/claims/batch/release "${BODY_B}")"
+parse_call "$(call POST /api/bongos/claims/batch/release "${BODY_B}")"
 if [[ "${CODE}" == "200" ]]; then
   RELEASED_IDS=$(python3 -c "
 import json,sys
@@ -214,7 +214,7 @@ TC1=$(mk_task C1 "__smoke__/batch-release/${ts}/c1"); CREATED_TASKS+=("${TC1}")
 TC2=$(mk_task C2 "__smoke__/batch-release/${ts}/c2"); CREATED_TASKS+=("${TC2}")
 
 BODY_C=$(python3 -c "import json; print(json.dumps({'task_ids':[${TC1},${TC2}]}))")
-parse_call "$(call POST /api/gds/claims/batch/validate "${BODY_C}")"
+parse_call "$(call POST /api/bongos/claims/batch/validate "${BODY_C}")"
 if [[ "${CODE}" == "200" ]]; then
   PS=$(python3 -c "import json,sys; print(json.loads('''${PAYLOAD}''')['parallel_safe'])")
   if [[ "${PS}" == "True" ]]; then
@@ -227,7 +227,7 @@ else
 fi
 # Dry run — confirm NOTHING got claimed.
 for tid in "${TC1}" "${TC2}"; do
-  parse_call "$(call GET "/api/gds/tasks/${tid}")"
+  parse_call "$(call GET "/api/bongos/tasks/${tid}")"
   S=$(python3 -c "import json,sys; print(json.loads('''${PAYLOAD}''')['task']['status'])")
   if [[ "${S}" == "ready" ]]; then
     ok "C: task #${tid} still 'ready' (validate did not claim)"
@@ -244,7 +244,7 @@ TD2=$(mk_task D2 "__smoke__/batch-release/${ts}/shared"); CREATED_TASKS+=("${TD2
 echo "  created tasks ${TD1}, ${TD2} (both touch __smoke__/batch-release/${ts}/shared)"
 
 BODY_D=$(python3 -c "import json; print(json.dumps({'task_ids':[${TD1},${TD2}]}))")
-parse_call "$(call POST /api/gds/claims/batch/validate "${BODY_D}")"
+parse_call "$(call POST /api/bongos/claims/batch/validate "${BODY_D}")"
 if [[ "${CODE}" == "200" ]]; then
   PS=$(python3 -c "import json,sys; print(json.loads('''${PAYLOAD}''')['parallel_safe'])")
   REASONS=$(python3 -c "
@@ -265,7 +265,7 @@ else
   bad "D: expected 200, got ${CODE} → ${PAYLOAD}"
 fi
 for tid in "${TD1}" "${TD2}"; do
-  parse_call "$(call GET "/api/gds/tasks/${tid}")"
+  parse_call "$(call GET "/api/bongos/tasks/${tid}")"
   S=$(python3 -c "import json,sys; print(json.loads('''${PAYLOAD}''')['task']['status'])")
   if [[ "${S}" == "ready" ]]; then
     ok "D: task #${tid} still 'ready' (validate did not claim)"
@@ -283,7 +283,7 @@ CE1=$(claim_task "${TE1}"); CREATED_CLAIMS+=("${CE1}")
 echo "  #${TE1} pre-claimed (claim ${CE1}, now 'active'); #${TE2} stays 'ready'"
 
 BODY_E=$(python3 -c "import json; print(json.dumps({'task_ids':[${TE1},${TE2}]}))")
-parse_call "$(call POST /api/gds/claims/batch/validate "${BODY_E}")"
+parse_call "$(call POST /api/bongos/claims/batch/validate "${BODY_E}")"
 if [[ "${CODE}" == "200" ]]; then
   VALID_E1=$(python3 -c "
 import json,sys

package/scripts/gds/smoke-claim-consistency.sh

@@ -9,11 +9,11 @@
 #   1. Create 2 disjoint __smoke__ tasks
 #   2. Claim both as the same builder
 #   3. Hit every consumer surface that currently exists:
-#        - GET /api/gds/me                              (always present)
-#        - GET /api/gds/builders/me   (PMS-V2 P6)       (capability-gated)
+#        - GET /api/bongos/me                              (always present)
+#        - GET /api/bongos/builders/me   (PMS-V2 P6)       (capability-gated)
 #      The /builder-start and /builder-session CLIs render server data;
 #      they do not constitute independent surfaces in the sense of
-#      criterion 7 (they consume /api/gds/* responses). We assert at the
+#      criterion 7 (they consume /api/bongos/* responses). We assert at the
 #      API boundary, which is where the bug class lives.
 #   4. Extract the ordered (task_id) sequence from each surface
 #   5. Assert all surfaces return identical sequences
@@ -24,7 +24,7 @@
 # which surfaces were checked vs skipped.
 #
 # TODO: once PMS-V2 P6 (#48 — /builders web profile) ships, the
-# /api/gds/builders/me surface will start returning 200 and this smoke
+# /api/bongos/builders/me surface will start returning 200 and this smoke
 # will automatically include it. No edits needed here.
 #
 # Usage:
@@ -101,7 +101,7 @@ print(json.dumps({
 }))
 ")
   local out
-  out=$(call POST /api/gds/tasks "${body}")
+  out=$(call POST /api/bongos/tasks "${body}")
   echo "${out}" | python3 -c "import json,sys; print(json.load(sys.stdin)['task']['id'])"
 }
 
@@ -110,13 +110,13 @@ claim_task() {
   local body
   body=$(python3 -c "import json; print(json.dumps({'task_id': ${task_id}, 'worktree_name': '__smoke__'}))")
   local out
-  out=$(call POST /api/gds/claims "${body}")
+  out=$(call POST /api/bongos/claims "${body}")
   echo "${out}" | python3 -c "import json,sys; print(json.load(sys.stdin)['claim']['id'])"
 }
 
 release_claim() {
   local claim_id="$1"
-  call POST "/api/gds/claims/${claim_id}/resolve" '{"outcome":"abandoned","notes_md":"smoke cleanup"}' >/dev/null || true
+  call POST "/api/bongos/claims/${claim_id}/resolve" '{"outcome":"abandoned","notes_md":"smoke cleanup"}' >/dev/null || true
 }
 
 echo "=== GDS claim-consistency smoke test ==="
@@ -168,8 +168,8 @@ checked=0
 skipped=0
 fail=0
 
-# Surface 1: /api/gds/me — always present.
-ME_PAYLOAD=$(call GET /api/gds/me)
+# Surface 1: /api/bongos/me — always present.
+ME_PAYLOAD=$(call GET /api/bongos/me)
 ME_IDS=$(extract_ids "${ME_PAYLOAD}" "[c['task_id'] for c in data.get('active_claims', [])]")
 # Filter to just our 2 smoke task_ids in case the builder has other live claims.
 ME_FILTERED=$(python3 -c "
@@ -177,19 +177,19 @@ ids = '${ME_IDS}'.split(',') if '${ME_IDS}' else []
 keep = [x for x in ids if x in ('${TASK_A}', '${TASK_B}')]
 print(','.join(keep))
 ")
-echo "/api/gds/me                 -> ${ME_FILTERED}"
+echo "/api/bongos/me                 -> ${ME_FILTERED}"
 if [[ "${ME_FILTERED}" == "${EXPECTED}" ]]; then
-  echo "  PASS /api/gds/me ordering matches"
+  echo "  PASS /api/bongos/me ordering matches"
   checked=$((checked+1))
 else
-  echo "  FAIL /api/gds/me ordering mismatch (expected ${EXPECTED}, got ${ME_FILTERED})"
+  echo "  FAIL /api/bongos/me ordering mismatch (expected ${EXPECTED}, got ${ME_FILTERED})"
   fail=1
 fi
 
-# Surface 2: /api/gds/builders/me — PMS-V2 P6, capability-gated.
-BUILDERS_ME_CODE=$(probe_status /api/gds/builders/me)
+# Surface 2: /api/bongos/builders/me — PMS-V2 P6, capability-gated.
+BUILDERS_ME_CODE=$(probe_status /api/bongos/builders/me)
 if [[ "${BUILDERS_ME_CODE}" == "200" ]]; then
-  BME_PAYLOAD=$(call GET /api/gds/builders/me)
+  BME_PAYLOAD=$(call GET /api/bongos/builders/me)
   # Try both common shapes: top-level active_claims, or nested under builder/profile.
   BME_IDS=$(extract_ids "${BME_PAYLOAD}" "[c['task_id'] for c in (data.get('active_claims') or data.get('builder', {}).get('active_claims') or data.get('profile', {}).get('active_claims') or [])]")
   BME_FILTERED=$(python3 -c "
@@ -197,16 +197,16 @@ ids = '${BME_IDS}'.split(',') if '${BME_IDS}' else []
 keep = [x for x in ids if x in ('${TASK_A}', '${TASK_B}')]
 print(','.join(keep))
 ")
-  echo "/api/gds/builders/me        -> ${BME_FILTERED}"
+  echo "/api/bongos/builders/me        -> ${BME_FILTERED}"
   if [[ "${BME_FILTERED}" == "${EXPECTED}" ]]; then
-    echo "  PASS /api/gds/builders/me ordering matches /api/gds/me"
+    echo "  PASS /api/bongos/builders/me ordering matches /api/bongos/me"
     checked=$((checked+1))
   else
-    echo "  FAIL /api/gds/builders/me ordering mismatch (expected ${EXPECTED}, got ${BME_FILTERED})"
+    echo "  FAIL /api/bongos/builders/me ordering mismatch (expected ${EXPECTED}, got ${BME_FILTERED})"
     fail=1
   fi
 else
-  echo "/api/gds/builders/me        -> HTTP ${BUILDERS_ME_CODE} (SKIP — PMS-V2 P6 not live yet)"
+  echo "/api/bongos/builders/me        -> HTTP ${BUILDERS_ME_CODE} (SKIP — PMS-V2 P6 not live yet)"
   skipped=$((skipped+1))
 fi
 

package/scripts/gds/smoke-dependencies.sh

@@ -31,29 +31,29 @@ BASE="${GDS_BASE:-$(gds_api_base)}"
 SUFFIX="$(date +%s)"
 
 echo "=== 1. Create task B (depends-on target, status=ready) ==="
-B=$(curl -sS -X POST "$BASE/api/gds/tasks" \
+B=$(curl -sS -X POST "$BASE/api/bongos/tasks" \
   -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
   --data "{\"version_id\":\"GDS-V3\",\"title\":\"__smoke__ dep-test B $SUFFIX\",\"description\":\"smoke\",\"status\":\"ready\",\"kind\":\"feature\",\"discipline\":\"engineering\",\"priority\":5,\"touches\":[\"smoke-dep-B-$SUFFIX/\"],\"source\":\"smoke\",\"source_ref\":\"smoke-dep-B-$SUFFIX\"}")
 B_ID=$(echo "$B" | python3 -c "import json,sys; print(json.load(sys.stdin)['task']['id'])")
 echo "  B id=$B_ID"
 
 echo "=== 2. Create task A (dependent, status=backlog) ==="
-A=$(curl -sS -X POST "$BASE/api/gds/tasks" \
+A=$(curl -sS -X POST "$BASE/api/bongos/tasks" \
   -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
   --data "{\"version_id\":\"GDS-V3\",\"title\":\"__smoke__ dep-test A $SUFFIX\",\"description\":\"smoke\",\"status\":\"backlog\",\"kind\":\"feature\",\"discipline\":\"engineering\",\"priority\":5,\"touches\":[\"smoke-dep-A-$SUFFIX/\"],\"source\":\"smoke\",\"source_ref\":\"smoke-dep-A-$SUFFIX\"}")
 A_ID=$(echo "$A" | python3 -c "import json,sys; print(json.load(sys.stdin)['task']['id'])")
 echo "  A id=$A_ID"
 
 echo "=== 3. Wire A → depends_on B ==="
-curl -sS -X POST "$BASE/api/gds/tasks/$A_ID/dependencies" \
+curl -sS -X POST "$BASE/api/bongos/tasks/$A_ID/dependencies" \
   -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
   --data "{\"depends_on_task_id\": $B_ID}" | python3 -m json.tool
 
 echo "=== 4. Manually promote A (testing claim-time gate, not auto-promote) ==="
-curl -sS -X POST "$BASE/api/gds/tasks/$A_ID/promote" -H "Authorization: Bearer $TOKEN" | python3 -m json.tool
+curl -sS -X POST "$BASE/api/bongos/tasks/$A_ID/promote" -H "Authorization: Bearer $TOKEN" | python3 -m json.tool
 
 echo "=== 5. Attempt claim A — MUST 409 DEPS_NOT_SHIPPED ==="
-CLAIM_RESP=$(curl -sS -X POST "$BASE/api/gds/claims" \
+CLAIM_RESP=$(curl -sS -X POST "$BASE/api/bongos/claims" \
   -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
   --data "{\"task_id\": $A_ID, \"worktree_name\": \"smoke-$SUFFIX\"}")
 echo "$CLAIM_RESP" | python3 -m json.tool
@@ -63,14 +63,14 @@ echo "=== 6. Claim + ship B (the dep) ==="
 node scripts/gds/claim.js "$B_ID" --worktree "smoke-$SUFFIX-B"
 # Move through completed → confirmed → shipped using direct API calls (skip the
 # scanner/grader by going straight at /resolve + /confirm + /ship)
-curl -sS -X POST "$BASE/api/gds/claims/by-task/$B_ID/resolve" \
+curl -sS -X POST "$BASE/api/bongos/claims/by-task/$B_ID/resolve" \
   -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
   --data '{"outcome":"completed","verification":{"passed":true,"smoke_ok":true}}' >/dev/null
-curl -sS -X POST "$BASE/api/gds/tasks/$B_ID/confirm" -H "Authorization: Bearer $TOKEN" >/dev/null
-curl -sS -X POST "$BASE/api/gds/tasks/$B_ID/ship"    -H "Authorization: Bearer $TOKEN" >/dev/null
+curl -sS -X POST "$BASE/api/bongos/tasks/$B_ID/confirm" -H "Authorization: Bearer $TOKEN" >/dev/null
+curl -sS -X POST "$BASE/api/bongos/tasks/$B_ID/ship"    -H "Authorization: Bearer $TOKEN" >/dev/null
 
 echo "=== 7. Verify A auto-promoted (status should still be 'ready' from manual step 4, or auto-flipped from backlog) ==="
-A_STATUS=$(curl -sS -H "Authorization: Bearer $TOKEN" "$BASE/api/gds/tasks/$A_ID" | python3 -c "import json,sys; print(json.load(sys.stdin)['task']['status'])")
+A_STATUS=$(curl -sS -H "Authorization: Bearer $TOKEN" "$BASE/api/bongos/tasks/$A_ID" | python3 -c "import json,sys; print(json.load(sys.stdin)['task']['status'])")
 echo "  A status: $A_STATUS"
 [ "$A_STATUS" = "ready" ] && echo "  PASS" || (echo "  FAIL: A not ready"; exit 1)
 

package/scripts/gds/smoke-write.sh

@@ -4,9 +4,9 @@
 # Exercises the full claim → ship round-trip against the live API:
 #   1. Read session token from ~/.config/otb/bongos-session.json (or the legacy
 #      gds-session.json / pms-session.json names, all still accepted on read)
-#   2. POST /api/gds/tasks → create a synthetic task titled '__smoke__ <ts>'
-#   3. POST /api/gds/claims → claim it
-#   4. POST /api/gds/claims/:id/resolve outcome=shipped
+#   2. POST /api/bongos/tasks → create a synthetic task titled '__smoke__ <ts>'
+#   3. POST /api/bongos/claims → claim it
+#   4. POST /api/bongos/claims/:id/resolve outcome=shipped
 #   5. Validate: tasks.status flipped to 'shipped'
 #                session_logs row exists for this claim
 #                public/recent-shipped does NOT contain the smoke title
@@ -53,7 +53,7 @@ call() {
 }
 
 snapshot_progress() {
-  curl -sS "${API}/api/gds/public/progress" \
+  curl -sS "${API}/api/bongos/public/progress" \
     | python3 -c "import json,sys; d=json.load(sys.stdin); print(','.join(f\"{r['version_id']}:{r['shipped_weight']}/{r['total_weight']}\" for r in d['progress']))"
 }
 
@@ -83,7 +83,7 @@ echo "Version: ${VERSION_ID}"
 # version-select.js, and node is the interpreter a Windows builder box actually
 # has — the python3 the rest of this file depends on is frequently absent there
 # (it is the Microsoft Store stub), so a python3 step cannot be verified locally.
-GOAL_ID=$(call GET "/api/gds/goals?version=${VERSION_ID}" | node -e '
+GOAL_ID=$(call GET "/api/bongos/goals?version=${VERSION_ID}" | node -e '
 let s = "";
 process.stdin.on("data", (d) => { s += d; });
 process.stdin.on("end", () => {
@@ -140,21 +140,21 @@ print(json.dumps({
   'source_ref': '${ts}'
 }))
 ")
-TASK_JSON=$(call POST /api/gds/tasks "${CREATE_BODY}")
+TASK_JSON=$(call POST /api/bongos/tasks "${CREATE_BODY}")
 TASK_ID=$(echo "${TASK_JSON}" | python3 -c "import json,sys; print(json.load(sys.stdin)['task']['id'])")
 echo "created task #${TASK_ID}"
 
 echo
 echo "--- 2. claim task ---"
 CLAIM_BODY=$(python3 -c "import json; print(json.dumps({'task_id': ${TASK_ID}, 'worktree_name': '__smoke__'}))")
-CLAIM_JSON=$(call POST /api/gds/claims "${CLAIM_BODY}")
+CLAIM_JSON=$(call POST /api/bongos/claims "${CLAIM_BODY}")
 CLAIM_ID=$(echo "${CLAIM_JSON}" | python3 -c "import json,sys; print(json.load(sys.stdin)['claim']['id'])")
 echo "claim #${CLAIM_ID}"
 
 echo
 echo "--- 3. resolve claim shipped (verification.passed=true → lands at completed; grade gates confirm) ---"
 RESOLVE_BODY='{"outcome":"shipped","notes_md":"smoke-test","value_summary":"smoke-test","verification":{"passed":true,"scanner_clean":true,"smoke_clean":true}}'
-RESOLVE_JSON=$(call POST "/api/gds/claims/${CLAIM_ID}/resolve" "${RESOLVE_BODY}")
+RESOLVE_JSON=$(call POST "/api/bongos/claims/${CLAIM_ID}/resolve" "${RESOLVE_BODY}")
 echo "${RESOLVE_JSON}"
 
 echo
@@ -162,7 +162,7 @@ echo "--- 4. validate ---"
 fail=0
 
 # 4a. recent-shipped does NOT contain the smoke title
-RECENT=$(curl -sS "${API}/api/gds/public/recent-shipped")
+RECENT=$(curl -sS "${API}/api/bongos/public/recent-shipped")
 if echo "${RECENT}" | python3 -c "
 import json, sys
 data = json.load(sys.stdin)
@@ -196,7 +196,7 @@ fi
 # (Pre-#209 this asserted 'confirmed', which has been failing on every run
 # since the grader gate landed — fixed in #468.) The task should never reach
 # 'shipped' (that needs a merge). credits_reward=0, so no credit_log row.
-TASK_AFTER=$(call GET "/api/gds/tasks/${TASK_ID}")
+TASK_AFTER=$(call GET "/api/bongos/tasks/${TASK_ID}")
 STATUS_AFTER=$(echo "${TASK_AFTER}" | python3 -c "import json,sys; print(json.load(sys.stdin)['task']['status'])")
 if [[ "${STATUS_AFTER}" == "completed" ]]; then
   echo "PASS task.status = completed (resolve landed it at completed; grade gates confirm — V3.R18 #209)"
@@ -249,7 +249,7 @@ cleanup_throwaway_task() {
   out=$(curl -sS -X POST \
     -H "Authorization: Bearer ${TOKEN}" -H "Content-Type: application/json" \
     -d "${reason}" -w "\n%{http_code}" \
-    "${API}/api/gds/tasks/${TASK_ID}/abandon") || true
+    "${API}/api/bongos/tasks/${TASK_ID}/abandon") || true
   code="${out##*$'\n'}"
   case "${code}" in
     2*)  echo "PASS cleaned up throwaway task #${TASK_ID} (abandoned)" ;;