@bongos/core 1.23.22 → 1.24.2

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

@@ -1,316 +0,0 @@
-#!/usr/bin/env bash
-# GDS batch-release + dry-run-validate smoke test (task 1758).
-#
-# 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/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
-#           dry run, neither task actually gets claimed (still 'ready' after).
-#   Case E: 1 ready + 1 already-active task → the active one is marked
-#           invalid (TASK_NOT_READY), the ready one stays valid.
-#
-# Creates synthetic '__smoke__' tasks that are filtered from the public surfaces.
-# Cleans up by releasing/abandoning every claim it creates and marking tasks
-# 'abandoned' so they don't linger.
-#
-# Usage:   bash scripts/bongos/smoke-batch-release.sh
-# Env:     GDS_API_BASE / PMS_API_BASE  override host (default: this instance's own,
-#          resolved from the session + branding pack — see lib.sh)
-
-set -euo pipefail
-
-# shellcheck source=scripts/bongos/lib.sh
-source "$(dirname "$0")/lib.sh"
-
-API="$(gds_api_base)"
-TOKEN="$(gds_resolve_token)" || exit $?
-
-# task 1003166 (G02): resolve the version at RUNTIME rather than naming one. A
-# literal works until that version ships, then `version_closed` refuses every
-# create and the smoke fails as if the code broke (idea 1000823).
-VERSION_ID=$(node "$(dirname "$0")/version-select.js") || {
-  echo "FAIL: could not resolve a building version — see version-select.js" >&2
-  exit 1
-}
-
-ts=$(date +%Y%m%d-%H%M%S)
-
-# Wrapper: METHOD PATH [BODY] → echoes "PAYLOAD\nHTTP_CODE". Never exits.
-call() {
-  local method="$1" path="$2" body="${3:-}"
-  local args=(-sS -X "${method}" -H "Authorization: Bearer ${TOKEN}" -H "Content-Type: application/json" -w "\n%{http_code}")
-  if [[ -n "${body}" ]]; then args+=(-d "${body}"); fi
-  curl "${args[@]}" "${API}${path}"
-}
-
-parse_call() {
-  local out="$1"
-  CODE="${out##*$'\n'}"
-  PAYLOAD="${out%$'\n'*}"
-}
-
-mk_task() {
-  # mk_task <suffix> <touches-csv>  → echoes new task id
-  local suffix="$1" touches_csv="$2"
-  local body
-  body=$(python3 -c "
-import json,sys
-t = '${touches_csv}'.split(',')
-print(json.dumps({
-  'version_id': '${VERSION_ID}',
-  'title': '__smoke__ batch-release ${ts}-${suffix}',
-  'description': 'smoke',
-  'status': 'ready',
-  'touches': t,
-  'est_minutes': 1,
-  'manual_degree': 1,
-  'priority': 5,
-  'automation_tag': 'overnight-safe',
-  'credits_reward': 0,
-  'source': 'smoke',
-  'source_ref': '${ts}-${suffix}'
-}))")
-  parse_call "$(call POST /api/bongos/tasks "${body}")"
-  python3 -c "import json,sys; print(json.loads('''${PAYLOAD}''')['task']['id'])"
-}
-
-claim_task() {
-  # claim_task <task_id>  → echoes new claim id.
-  # Uses /claims/batch with bind_session:false (task 1795) rather than the
-  # plain single-claim path — this CLI token IS a real bound session, and the
-  # plain single-claim path caps a session to ONE active claim at a time
-  # (gateOneActiveClaimPerSession, task 1642). bind_session:false stores
-  # creator_session_id NULL instead of the caller's session, so this session
-  # 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/bongos/claims/batch "{\"task_ids\":[${tid}],\"bind_session\":false}")"
-  python3 -c "import json,sys; print(json.loads('''${PAYLOAD}''')['claims'][0]['id'])"
-}
-
-# Track created tasks + claims for cleanup. Claims released in Case A/B are
-# dropped from CREATED_CLAIMS as they resolve so cleanup doesn't double-resolve.
-CREATED_TASKS=()
-CREATED_CLAIMS=()
-cleanup() {
-  local leaked=()
-  echo
-  echo "--- cleanup ---"
-  for cid in "${CREATED_CLAIMS[@]:-}"; do
-    [[ -z "${cid}" ]] && continue
-    call POST "/api/bongos/claims/${cid}/resolve" \
-      '{"outcome":"abandoned","notes_md":"smoke cleanup"}' >/dev/null || true
-  done
-  for tid in "${CREATED_TASKS[@]:-}"; do
-    [[ -z "${tid}" ]] && continue
-    # 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/bongos/tasks/${tid}/abandon" \
-         '{"reason":"smoke cleanup (scripts/bongos/smoke-batch-release.sh)"}' >/dev/null 2>&1; then
-      leaked+=("${tid}")
-    fi
-  done
-  if [[ ${#leaked[@]} -gt 0 ]]; then
-    echo "WARN: could not abandon ${#leaked[@]} smoke task(s): ${leaked[*]}"
-    echo "WARN: clear them with: node scripts/bongos/api.js POST /tasks/<id>/abandon --body '{\"reason\":\"smoke residue\"}'"
-  fi
-  echo "cleanup done"
-}
-trap cleanup EXIT
-
-fail=0
-ok()   { echo "PASS $*"; }
-bad()  { echo "FAIL $*"; fail=1; }
-
-echo "=== GDS batch-release + validate smoke ==="
-echo "API: ${API}"
-echo
-
-# ---- Case A: 2 own active claims → 200, both released ------------------
-# Each id is registered for cleanup IMMEDIATELY after it's created/claimed
-# (not batched after both calls) — so if the second call in a pair fails,
-# the first one's already-registered and still gets cleaned up on exit.
-echo "--- A: release 2 own claims (expect 200, both released) ---"
-TA1=$(mk_task A1 "__smoke__/batch-release/${ts}/a1"); CREATED_TASKS+=("${TA1}")
-TA2=$(mk_task A2 "__smoke__/batch-release/${ts}/a2"); CREATED_TASKS+=("${TA2}")
-CA1=$(claim_task "${TA1}"); CREATED_CLAIMS+=("${CA1}")
-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/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']))")
-  if [[ "${N}" == "2" && "${NF}" == "0" ]]; then
-    ok "A: 200 with 2 released, 0 failures"
-    CREATED_CLAIMS=("${CREATED_CLAIMS[@]/${CA1}/}" ); CREATED_CLAIMS=("${CREATED_CLAIMS[@]/${CA2}/}")
-  else
-    bad "A: expected 2 released/0 failures, got ${N}/${NF} → ${PAYLOAD}"
-  fi
-else
-  bad "A: expected 200, got ${CODE} → ${PAYLOAD}"
-fi
-for tid in "${TA1}" "${TA2}"; do
-  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'"
-  else
-    bad "A: task #${tid} status = ${S} (expected ready)"
-  fi
-done
-
-# ---- Case B: 1 own claim + 1 bogus id → 200, partial success -----------
-echo
-echo "--- B: 1 own claim + 1 bogus claim id (expect 200, partial) ---"
-TB1=$(mk_task B1 "__smoke__/batch-release/${ts}/b1")
-CREATED_TASKS+=("${TB1}")
-CB1=$(claim_task "${TB1}")
-CREATED_CLAIMS+=("${CB1}")
-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/bongos/claims/batch/release "${BODY_B}")"
-if [[ "${CODE}" == "200" ]]; then
-  RELEASED_IDS=$(python3 -c "
-import json,sys
-d = json.loads('''${PAYLOAD}''')
-print(','.join(str(r['claim_id']) for r in d['released']))
-")
-  FAIL_REASONS=$(python3 -c "
-import json,sys
-d = json.loads('''${PAYLOAD}''')
-fs = d['failures']
-print(','.join(f\"{f['claim_id']}:{f['reason']}\" for f in fs))
-")
-  if [[ "${RELEASED_IDS}" == *"${CB1}"* ]]; then
-    ok "B: good claim #${CB1} released (released: ${RELEASED_IDS})"
-    CREATED_CLAIMS=("${CREATED_CLAIMS[@]/${CB1}/}")
-  else
-    bad "B: good claim #${CB1} NOT released (released: ${RELEASED_IDS})"
-  fi
-  if [[ "${FAIL_REASONS}" == *"${BOGUS_CLAIM_ID}:CLAIM_NOT_FOUND"* ]]; then
-    ok "B: bogus id enumerated as CLAIM_NOT_FOUND (failures: ${FAIL_REASONS})"
-  else
-    bad "B: bogus id not enumerated as CLAIM_NOT_FOUND (failures: ${FAIL_REASONS})"
-  fi
-else
-  bad "B: expected 200, got ${CODE} → ${PAYLOAD}"
-fi
-
-# ---- Case C: validate, disjoint touches → parallel_safe:true -----------
-echo
-echo "--- C: validate 2 ready disjoint-touches tasks (expect parallel_safe:true) ---"
-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/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
-    ok "C: parallel_safe:true for disjoint touches"
-  else
-    bad "C: expected parallel_safe:true, got ${PS} → ${PAYLOAD}"
-  fi
-else
-  bad "C: expected 200, got ${CODE} → ${PAYLOAD}"
-fi
-# Dry run — confirm NOTHING got claimed.
-for tid in "${TC1}" "${TC2}"; do
-  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)"
-  else
-    bad "C: task #${tid} status = ${S} (validate must never claim)"
-  fi
-done
-
-# ---- Case D: validate, overlapping touches → parallel_safe:false -------
-echo
-echo "--- D: validate 2 ready overlapping-touches tasks (expect parallel_safe:false) ---"
-TD1=$(mk_task D1 "__smoke__/batch-release/${ts}/shared"); CREATED_TASKS+=("${TD1}")
-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/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 "
-import json,sys
-d = json.loads('''${PAYLOAD}''')
-rs = set()
-for r in d['results']:
-  for reason in r['reasons']:
-    rs.add(reason['reason'])
-print(','.join(sorted(rs)))
-")
-  if [[ "${PS}" == "False" && "${REASONS}" == *"BATCH_TOUCHES_CONFLICT"* ]]; then
-    ok "D: parallel_safe:false with BATCH_TOUCHES_CONFLICT (reasons: ${REASONS})"
-  else
-    bad "D: expected parallel_safe:false + BATCH_TOUCHES_CONFLICT, got ${PS}/${REASONS} → ${PAYLOAD}"
-  fi
-else
-  bad "D: expected 200, got ${CODE} → ${PAYLOAD}"
-fi
-for tid in "${TD1}" "${TD2}"; do
-  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)"
-  else
-    bad "D: task #${tid} status = ${S} (validate must never claim)"
-  fi
-done
-
-# ---- Case E: validate, 1 ready + 1 already-active → the active one invalid
-echo
-echo "--- E: validate 1 ready + 1 already-active (expect the active one invalid) ---"
-TE1=$(mk_task E1 "__smoke__/batch-release/${ts}/e1"); CREATED_TASKS+=("${TE1}")
-TE2=$(mk_task E2 "__smoke__/batch-release/${ts}/e2"); CREATED_TASKS+=("${TE2}")
-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/bongos/claims/batch/validate "${BODY_E}")"
-if [[ "${CODE}" == "200" ]]; then
-  VALID_E1=$(python3 -c "
-import json,sys
-d = json.loads('''${PAYLOAD}''')
-for r in d['results']:
-  if r['task_id'] == ${TE1}: print(r['valid'])
-")
-  VALID_E2=$(python3 -c "
-import json,sys
-d = json.loads('''${PAYLOAD}''')
-for r in d['results']:
-  if r['task_id'] == ${TE2}: print(r['valid'])
-")
-  if [[ "${VALID_E1}" == "False" && "${VALID_E2}" == "True" ]]; then
-    ok "E: active task #${TE1} invalid, ready task #${TE2} valid"
-  else
-    bad "E: expected #${TE1}=invalid/#${TE2}=valid, got ${VALID_E1}/${VALID_E2} → ${PAYLOAD}"
-  fi
-else
-  bad "E: expected 200, got ${CODE} → ${PAYLOAD}"
-fi
-
-echo
-echo "--- summary ---"
-if [[ "${fail}" -eq 0 ]]; then
-  echo "OK: batch-release + validate smoke passed"
-else
-  echo "FAIL: one or more checks failed"
-fi
-exit "${fail}"

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

@@ -1,222 +0,0 @@
-#!/usr/bin/env bash
-# GDS claim-consistency smoke test (production). Renamed from PMS in V3.R01.
-#
-# Enforces criterion 7 of pms-v2.md: every surface that lists "your active
-# claims" must read from the canonical helper (src/bongos/active-claims.js)
-# and therefore return identical claim sets in identical order.
-#
-# Strategy:
-#   1. Create 2 disjoint __smoke__ tasks
-#   2. Claim both as the same builder
-#   3. Hit every consumer surface that currently exists:
-#        - 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/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
-#   6. Release both claims, surfaces are cleaned up by the task lifecycle
-#
-# Surfaces that 404 are AUTO-SKIPPED so the smoke test passes against
-# current production even before PMS-V2 P6 lands. A summary line records
-# which surfaces were checked vs skipped.
-#
-# TODO: once PMS-V2 P6 (#48 — /builders web profile) ships, the
-# /api/bongos/builders/me surface will start returning 200 and this smoke
-# will automatically include it. No edits needed here.
-#
-# Usage:
-#   bash scripts/bongos/smoke-claim-consistency.sh
-# Optional env:
-#   GDS_API_BASE / PMS_API_BASE  override the API host (default: this instance's own,
-#                                resolved from the session + branding pack — see lib.sh)
-
-set -euo pipefail
-
-# shellcheck source=scripts/bongos/lib.sh
-source "$(dirname "$0")/lib.sh"
-
-API="$(gds_api_base)"
-TOKEN="$(gds_resolve_token)" || exit $?
-
-ts=$(date +%Y%m%d-%H%M%S)
-SMOKE_TITLE_A="__smoke__ claim-consistency-A ${ts}"
-SMOKE_TITLE_B="__smoke__ claim-consistency-B ${ts}"
-
-call() {
-  local method="$1" path="$2" body="${3:-}"
-  local args=(-sS -X "${method}" -H "Authorization: Bearer ${TOKEN}" -H "Content-Type: application/json" -w "\n%{http_code}")
-  if [[ -n "${body}" ]]; then args+=(-d "${body}"); fi
-  local out
-  out=$(curl "${args[@]}" "${API}${path}")
-  local code="${out##*$'\n'}"
-  local payload="${out%$'\n'*}"
-  echo "${payload}"
-  if [[ "${code}" -ge 300 ]]; then
-    echo "FAIL: ${method} ${path} -> HTTP ${code}" >&2
-    return 1
-  fi
-}
-
-# Returns the HTTP status code for a GET to PATH. Used for capability gating.
-probe_status() {
-  local path="$1"
-  curl -sS -o /dev/null -w "%{http_code}" \
-    -H "Authorization: Bearer ${TOKEN}" \
-    "${API}${path}"
-}
-
-# Extract sorted task_id list from a JSON payload at a given JSON path.
-# Args: <payload> <python-extract-expr-returning-list-of-ints>
-extract_ids() {
-  local payload="$1" expr="$2"
-  echo "${payload}" | python3 -c "
-import json, sys
-data = json.load(sys.stdin)
-ids = ${expr}
-print(','.join(str(x) for x in ids))
-"
-}
-
-create_task() {
-  local title="$1" suffix="$2"
-  local body
-  body=$(python3 -c "
-import json
-print(json.dumps({
-  'version_id': '${VERSION_ID}',
-  'title': '${title}',
-  'description': 'Synthetic smoke task. Auto-cleaned by smoke-claim-consistency.sh.',
-  'status': 'ready',
-  'touches': ['__smoke__/claim-consistency/${ts}/${suffix}'],
-  'est_minutes': 1,
-  'manual_degree': 1,
-  'priority': 5,
-  'automation_tag': 'overnight-safe',
-  'credits_reward': 0,
-  'source': 'smoke',
-  'source_ref': 'consistency-${ts}-${suffix}'
-}))
-")
-  local out
-  out=$(call POST /api/bongos/tasks "${body}")
-  echo "${out}" | python3 -c "import json,sys; print(json.load(sys.stdin)['task']['id'])"
-}
-
-claim_task() {
-  local task_id="$1"
-  local body
-  body=$(python3 -c "import json; print(json.dumps({'task_id': ${task_id}, 'worktree_name': '__smoke__'}))")
-  local out
-  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/bongos/claims/${claim_id}/resolve" '{"outcome":"abandoned","notes_md":"smoke cleanup"}' >/dev/null || true
-}
-
-echo "=== GDS claim-consistency smoke test ==="
-echo "API: ${API}"
-echo "Titles: ${SMOKE_TITLE_A} | ${SMOKE_TITLE_B}"
-echo
-
-# task 1003166 (G02): resolve the version at RUNTIME. This file used to hardcode
-# one; that version shipped, `version_closed` refused every create, and the smoke
-# could not pass while /merge-mode still advertised it green (idea 1000823).
-VERSION_ID=$(node "$(dirname "$0")/version-select.js") || {
-  echo "FAIL: could not resolve a building version — see version-select.js" >&2
-  exit 1
-}
-echo "Version: ${VERSION_ID}"
-
-echo "--- 1. create 2 smoke tasks ---"
-TASK_A=$(create_task "${SMOKE_TITLE_A}" "A")
-TASK_B=$(create_task "${SMOKE_TITLE_B}" "B")
-echo "task A=#${TASK_A}  task B=#${TASK_B}"
-
-# Always clean up on exit, even if assertions fail.
-CLAIM_A=""
-CLAIM_B=""
-cleanup() {
-  local rc=$?
-  echo
-  echo "--- cleanup ---"
-  [[ -n "${CLAIM_A}" ]] && release_claim "${CLAIM_A}" && echo "released claim ${CLAIM_A}"
-  [[ -n "${CLAIM_B}" ]] && release_claim "${CLAIM_B}" && echo "released claim ${CLAIM_B}"
-  exit "${rc}"
-}
-trap cleanup EXIT
-
-echo
-echo "--- 2. claim both as same builder (A first, then B) ---"
-CLAIM_A=$(claim_task "${TASK_A}")
-# Tiny pause so claimed_at differs and ordering is unambiguous.
-sleep 1
-CLAIM_B=$(claim_task "${TASK_B}")
-echo "claim A=#${CLAIM_A}  claim B=#${CLAIM_B}"
-
-EXPECTED="${TASK_A},${TASK_B}"
-echo "expected ordered task_ids: ${EXPECTED}"
-
-echo
-echo "--- 3. probe each surface, extract ordered task_id sequence ---"
-checked=0
-skipped=0
-fail=0
-
-# 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 "
-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/bongos/me                 -> ${ME_FILTERED}"
-if [[ "${ME_FILTERED}" == "${EXPECTED}" ]]; then
-  echo "  PASS /api/bongos/me ordering matches"
-  checked=$((checked+1))
-else
-  echo "  FAIL /api/bongos/me ordering mismatch (expected ${EXPECTED}, got ${ME_FILTERED})"
-  fail=1
-fi
-
-# 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/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 "
-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/bongos/builders/me        -> ${BME_FILTERED}"
-  if [[ "${BME_FILTERED}" == "${EXPECTED}" ]]; then
-    echo "  PASS /api/bongos/builders/me ordering matches /api/bongos/me"
-    checked=$((checked+1))
-  else
-    echo "  FAIL /api/bongos/builders/me ordering mismatch (expected ${EXPECTED}, got ${BME_FILTERED})"
-    fail=1
-  fi
-else
-  echo "/api/bongos/builders/me        -> HTTP ${BUILDERS_ME_CODE} (SKIP — PMS-V2 P6 not live yet)"
-  skipped=$((skipped+1))
-fi
-
-echo
-echo "--- summary ---"
-echo "surfaces checked: ${checked}"
-echo "surfaces skipped: ${skipped}"
-if [[ "${fail}" -eq 0 ]]; then
-  echo "OK: claim-consistency smoke passed (task A=#${TASK_A}, task B=#${TASK_B})"
-else
-  echo "FAIL: one or more surfaces disagreed on active-claims ordering"
-fi
-exit "${fail}"