@bongos/core 1.17.0

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

@@ -0,0 +1,213 @@
+#!/usr/bin/env bash
+# GDS batch-claim smoke test. Renamed from PMS in V3.R01.
+#
+# Exercises POST /api/gds/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').
+#   Case C: 1 ready + 1 already-claimed → 409, ALREADY_CLAIMED enumerated,
+#           no partial commit (the still-ready one is NOT consumed).
+#
+# 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/gds/smoke-batch-claim.sh
+# Env:     GDS_API_BASE / PMS_API_BASE  override host (default https://amazonprimea.com)
+
+set -euo pipefail
+
+# shellcheck source=scripts/gds/lib.sh
+source "$(dirname "$0")/lib.sh"
+
+API="$(gds_api_base)"
+TOKEN="$(gds_resolve_token)" || exit $?
+
+ts=$(date +%Y%m%d-%H%M%S)
+
+# Wrapper: METHOD PATH [BODY] → echoes "HTTP_CODE\nPAYLOAD". 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}"
+}
+
+# split into code + payload
+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': 'BONGOS-V1',
+  'title': '__smoke__ batch-claim ${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/gds/tasks "${body}")"
+  python3 -c "import json,sys; print(json.loads('''${PAYLOAD}''')['task']['id'])"
+}
+
+# Track created tasks + claims for cleanup.
+CREATED_TASKS=()
+CREATED_CLAIMS=()
+cleanup() {
+  echo
+  echo "--- cleanup ---"
+  for cid in "${CREATED_CLAIMS[@]:-}"; do
+    [[ -z "${cid}" ]] && continue
+    call POST "/api/gds/claims/${cid}/resolve" \
+      '{"outcome":"abandoned","notes_md":"smoke cleanup"}' >/dev/null || true
+  done
+  for tid in "${CREATED_TASKS[@]:-}"; do
+    [[ -z "${tid}" ]] && continue
+    # Mark task abandoned via PATCH /api/gds/tasks/:id if available, else leave.
+    # The smoke filter on version_progress already keeps these out of dashboards.
+    call POST "/api/gds/tasks/${tid}/promote" '{"status":"abandoned"}' >/dev/null 2>&1 || true
+  done
+  echo "cleanup done"
+}
+trap cleanup EXIT
+
+fail=0
+ok()   { echo "PASS $*"; }
+bad()  { echo "FAIL $*"; fail=1; }
+
+echo "=== GDS batch-claim smoke ==="
+echo "API: ${API}"
+echo
+
+# ---- Case A: disjoint touches → 201 with 2 claim rows ------------------
+echo "--- A: disjoint-touches batch (expect 201) ---"
+TA1=$(mk_task A1 "__smoke__/batch/${ts}/a1")
+TA2=$(mk_task A2 "__smoke__/batch/${ts}/a2")
+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}")"
+if [[ "${CODE}" == "201" ]]; then
+  N=$(python3 -c "import json,sys; print(len(json.loads('''${PAYLOAD}''')['claims']))")
+  if [[ "${N}" == "2" ]]; then
+    ok "A: 201 with 2 claim rows"
+    # capture both claim ids for cleanup
+    while read -r cid; do CREATED_CLAIMS+=("${cid}"); done < <(python3 -c "
+import json,sys
+d = json.loads('''${PAYLOAD}''')
+for c in d['claims']: print(c['id'])
+")
+  else
+    bad "A: expected 2 claims, got ${N}"
+  fi
+else
+  bad "A: expected 201, got ${CODE} → ${PAYLOAD}"
+fi
+
+# ---- Case B: overlapping touches → 409 BATCH_TOUCHES_CONFLICT ----------
+echo
+echo "--- B: overlapping-touches batch (expect 409, no claims) ---"
+TB1=$(mk_task B1 "__smoke__/batch/${ts}/shared")
+TB2=$(mk_task B2 "__smoke__/batch/${ts}/shared")
+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}")"
+if [[ "${CODE}" == "409" ]]; then
+  REASON=$(python3 -c "
+import json,sys
+d = json.loads('''${PAYLOAD}''')
+fs = d.get('failures', [])
+reasons = sorted({f.get('reason','') for f in fs})
+print(','.join(reasons))
+")
+  if [[ "${REASON}" == *"BATCH_TOUCHES_CONFLICT"* ]]; then
+    ok "B: 409 with BATCH_TOUCHES_CONFLICT (reasons: ${REASON})"
+  else
+    bad "B: 409 but missing BATCH_TOUCHES_CONFLICT (reasons: ${REASON})"
+  fi
+  # Confirm neither task got claimed (status still 'ready').
+  for tid in "${TB1}" "${TB2}"; do
+    parse_call "$(call GET "/api/gds/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)"
+    else
+      bad "B: task #${tid} status = ${S} (rollback failed)"
+    fi
+  done
+else
+  bad "B: expected 409, got ${CODE} → ${PAYLOAD}"
+fi
+
+# ---- Case C: one ready + one already-claimed → 409, no partial commit --
+echo
+echo "--- C: one ready + one already-claimed (expect 409, ready task NOT consumed) ---"
+TC1=$(mk_task C1 "__smoke__/batch/${ts}/c1")
+TC2=$(mk_task C2 "__smoke__/batch/${ts}/c2")
+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}}")"
+if [[ "${CODE}" == "201" ]]; then
+  PRE_CLAIM_ID=$(python3 -c "import json,sys; print(json.loads('''${PAYLOAD}''')['claim']['id'])")
+  CREATED_CLAIMS+=("${PRE_CLAIM_ID}")
+  ok "C: pre-claim of #${TC1} = claim #${PRE_CLAIM_ID}"
+else
+  bad "C: pre-claim failed (${CODE}); skipping rest of case"
+fi
+
+BODY_C=$(python3 -c "import json; print(json.dumps({'task_ids':[${TC1},${TC2}]}))")
+parse_call "$(call POST /api/gds/claims/batch "${BODY_C}")"
+if [[ "${CODE}" == "409" ]]; then
+  ENUM=$(python3 -c "
+import json,sys
+d = json.loads('''${PAYLOAD}''')
+fs = d.get('failures', [])
+ids = sorted({int(f['task_id']) for f in fs if 'task_id' in f})
+print(','.join(str(i) for i in ids))
+")
+  # Must enumerate the failure for #TC1 (TASK_NOT_READY since it's now 'active').
+  if [[ "${ENUM}" == *"${TC1}"* ]]; then
+    ok "C: 409 enumerates failing task (#${TC1}) in failures[]"
+  else
+    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}")"
+  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)"
+  else
+    bad "C: task #${TC2} status = ${S} (partial commit leaked)"
+  fi
+else
+  bad "C: expected 409, got ${CODE} → ${PAYLOAD}"
+fi
+
+echo
+echo "--- summary ---"
+if [[ "${fail}" -eq 0 ]]; then
+  echo "OK: batch-claim smoke passed"
+else
+  echo "FAIL: one or more checks failed"
+fi
+exit "${fail}"

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

@@ -0,0 +1,296 @@
+#!/usr/bin/env bash
+# GDS batch-release + dry-run-validate smoke test (task 1758).
+#
+# Exercises POST /api/gds/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:
+#   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/gds/smoke-batch-release.sh
+# Env:     GDS_API_BASE / PMS_API_BASE  override host (default https://amazonprimea.com)
+
+set -euo pipefail
+
+# shellcheck source=scripts/gds/lib.sh
+source "$(dirname "$0")/lib.sh"
+
+API="$(gds_api_base)"
+TOKEN="$(gds_resolve_token)" || exit $?
+
+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': 'BONGOS-V1',
+  '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/gds/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/gds/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() {
+  echo
+  echo "--- cleanup ---"
+  for cid in "${CREATED_CLAIMS[@]:-}"; do
+    [[ -z "${cid}" ]] && continue
+    call POST "/api/gds/claims/${cid}/resolve" \
+      '{"outcome":"abandoned","notes_md":"smoke cleanup"}' >/dev/null || true
+  done
+  for tid in "${CREATED_TASKS[@]:-}"; do
+    [[ -z "${tid}" ]] && continue
+    call POST "/api/gds/tasks/${tid}/promote" '{"status":"abandoned"}' >/dev/null 2>&1 || true
+  done
+  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/gds/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/gds/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/gds/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/gds/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/gds/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/gds/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/gds/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/gds/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/gds/smoke-box.sh

@@ -0,0 +1,150 @@
+#!/usr/bin/env bash
+# Smoke test for the per-builder dev box lifecycle (ADR 0031 §2/§5, #598).
+#
+# Unlike the other GDS smokes, this one is HERMETIC — no live server, no DB, no
+# DigitalOcean account, no network. It verifies the decision core + the dry-run
+# contract that make the lifecycle safe to ship before a single live box exists:
+#
+#   1. tests/boxes.mjs — pure logic (rank gate, cost, idle/dormant selection,
+#      transition legality) + the DO client's dry-run/live contract.
+#   2. route-rank invariant — the three /box* routes classify to their TRUE gate
+#      (archon roster, any-builder own-read + heartbeat), no 'unknown' findings.
+#   3. modules load — boxes.js, do-api.js, routes/box.js, and routes.js (mount).
+#   4. box.js --help + a dry-run plan run without a DB (control-plane safety:
+#      `--apply` is required to touch anything; dry-run is inert).
+#
+# Run:  bash scripts/gds/smoke-box.sh
+set -euo pipefail
+
+cd "$(dirname "$0")/../.."
+
+step() { printf '\n\033[1;36m==> %s\033[0m\n' "$*"; }
+fail() { printf '\033[0;31m✖ %s\033[0m\n' "$*" >&2; exit 1; }
+
+step "1. pure-logic + DO-client unit test (tests/boxes.mjs)"
+node tests/boxes.mjs || fail "boxes.mjs unit test failed"
+
+step "1b. box-access decision core (#600 rank-gated source access)"
+# tests/box_access.mjs (23 assertions) — re-added under #674 (written+passing in
+# #600 but deferred by parallel-claim conflicts on tests/). Covers the PURE
+# source-access decisions (decideSourceAccess / reconcileSourceAccess /
+# cloneSpecForScope / boxCanHoldSource / STARTER_SPARSE_PATHS) the
+# GET /box/source-access route and `box.js reconcile` both consume.
+node tests/box_access.mjs || fail "box_access.mjs unit test failed"
+
+step "1b2. box-credential provider (#600 scoped credential issuance)"
+# Kept inline: box-credential.js has no dedicated unit file yet. These pin the
+# env-provider's configured/unconfigured, scope→token/repo, and separate-starter-
+# repo hard-boundary behaviour so credential issuance never ships unverified.
+node -e "
+const c = require('./modules/dev-box/box-credential.js');
+const assert = require('node:assert').strict;
+let n = 0; const ok = (name, fn) => { fn(); n++; };
+ok('unconfigured→configured:false', () => assert.equal(c.makeEnvCredentialProvider({}).issue('full',{nowMs:0}).configured,false));
+ok('configured full→token+url', () => { const r=c.makeEnvCredentialProvider({BOX_SOURCE_REPO_URL:'u',BOX_SOURCE_FULL_TOKEN:'t'}).issue('full',{nowMs:0}); assert.equal(r.configured,true); assert.equal(r.token,'t'); });
+ok('starter falls back to full token', () => assert.equal(c.makeEnvCredentialProvider({BOX_SOURCE_REPO_URL:'u',BOX_SOURCE_FULL_TOKEN:'t'}).issue('starter',{nowMs:0}).token,'t'));
+ok('separate starter repo→hard-boundary flag', () => { const r=c.makeEnvCredentialProvider({BOX_SOURCE_REPO_URL:'u',BOX_SOURCE_FULL_TOKEN:'t',BOX_SOURCE_STARTER_REPO_URL:'s',BOX_SOURCE_STARTER_TOKEN:'st'}).issue('starter',{nowMs:0}); assert.equal(r.repoUrl,'s'); assert.equal(r.separateStarterRepo,true); });
+console.log('  ' + n + ' box-credential provider assertions passed');
+" || fail "box-credential provider failed"
+
+step "1c. onboarding module — SSH-key validation + renderers (#685, tests/box_onboard.mjs)"
+node tests/box_onboard.mjs || fail "box_onboard.mjs unit test failed"
+
+step "1c2. named-tunnel CF client — dry-run/live contract + ensure/teardown (#771, tests/cf_tunnel.mjs)"
+node tests/cf_tunnel.mjs || fail "cf_tunnel.mjs unit test failed"
+
+step "1d. end-to-end — real box-connect.sh + box-authorized-keys-fetch.sh vs a stub server (#685)"
+# Runs the GENUINE shell scripts against the real route handlers (stubbed DB):
+# key-gen -> register -> install settings, and the box-side authkeys sync + the
+# 403 clawback. Needs bash + curl + ssh-keygen (present on macOS + CI ubuntu).
+if command -v ssh-keygen >/dev/null 2>&1; then
+  node tests/box_connect_e2e.mjs || fail "box_connect_e2e.mjs end-to-end failed"
+else
+  echo "  (skipped — ssh-keygen not available)"
+fi
+
+step "1e. PowerShell bootstrap parses (#685) — best-effort, skipped where pwsh is absent"
+# box-connect.ps1 has no behavioral e2e (the harness is bash-only; the empty-
+# passphrase + BOM-less-write fixes rest on review). This at least catches gross
+# syntax errors on a pwsh-equipped machine (CI / a Windows runner); it no-ops on
+# a stock macOS/Linux dev box without PowerShell.
+if command -v pwsh >/dev/null 2>&1; then
+  pwsh -NoProfile -Command '$ErrorActionPreference="Stop"; $null=[System.Management.Automation.Language.Parser]::ParseFile((Resolve-Path infra/box-connect.ps1), [ref]$null, [ref]$null); Write-Output "  box-connect.ps1 parses"' \
+    || fail "box-connect.ps1 failed to parse under pwsh"
+else
+  echo "  (skipped — pwsh not installed; box-connect.ps1 behavior rests on review)"
+fi
+
+step "2. route-rank invariant — /box* routes classify to their true gate"
+node -e "
+const rc = require('./src/bongos/route-rank-check.js');
+const res = rc.checkRouteRanks();
+if (res.hardFail) { console.error('route-rank HARD FAIL'); process.exit(1); }
+const mine = res.routes.filter(r => r.file.endsWith('routes/box.js'));
+const want = {
+  'GET /boxes':'archon', 'GET /box/me':'any-builder', 'GET /box/source-access':'any-builder',
+  'POST /box/heartbeat':'any-builder',
+  // #685 onboarding surface
+  'POST /box/ssh-key':'any-builder', 'GET /box/ssh-key':'any-builder', 'DELETE /box/ssh-key/:id':'any-builder',
+  'GET /box/authorized-keys':'any-builder', 'GET /box/managed-settings':'any-builder',
+  // #701 onboarding middleware (auto-provision + wake-on-connect) + #760 terminal (ADR 0038)
+  'POST /box/ensure':'any-builder', 'GET /box/terminal':'any-builder', 'POST /box/terminal':'any-builder',
+  'GET /box/connect':'public', 'GET /box/connect.sh':'public', 'GET /box/connect.ps1':'public',
+};
+let bad = 0;
+for (const [key, rank] of Object.entries(want)) {
+  const got = (mine.find(r => r.key === key) || {}).rank;
+  if (got !== rank) { console.error('  MISMATCH ' + key + ': want ' + rank + ' got ' + got); bad++; }
+  else console.log('  ok ' + key + ' -> ' + rank);
+}
+process.exit(bad === 0 ? 0 : 1);
+" || fail "route-rank classification wrong"
+
+step "3. modules load cleanly (incl. the routes.js mount edit)"
+node -e "
+require('./modules/dev-box/boxes.js');
+require('./modules/dev-box/box-access.js');
+require('./modules/dev-box/box-credential.js');
+require('./modules/dev-box/box-onboard.js');
+require('./scripts/gds/do-api.js');
+require('./scripts/gds/cf-tunnel.js');
+require('./modules/dev-box/routes/box.js');
+require('./src/bongos/db.js');
+require('./src/bongos/routes.js');
+console.log('  all modules loaded');
+" || fail "module load failed"
+
+step "4. CLI is DB-free for --help (control-plane safety); reconcile + onboard registered"
+node scripts/gds/box.js --help | grep -q 'reconcile' || fail "box.js reconcile subcommand missing from help"
+node scripts/gds/box.js --help | grep -q 'onboard'   || fail "box.js onboard subcommand missing from help (#685)"
+node scripts/gds/box.js --help | grep -q 'run-intents' || fail "box.js run-intents subcommand missing from help (#701)"
+echo "  box.js --help ok (reconcile + onboard + run-intents present)"
+
+step "5. cloud-init carries the box scripts as valid base64 (#600 source + #685 authkeys)"
+node -e "
+const fs = require('fs');
+const o = require('./modules/dev-box/box-onboard.js');
+const raw = fs.readFileSync('infra/builder-box-cloud-init.yaml','utf8');
+const inject = (name) => {
+  const script = fs.readFileSync('infra/' + name,'utf8');
+  const b64 = Buffer.from(script,'utf8').toString('base64');
+  if (Buffer.from(b64,'base64').toString('utf8') !== script) { console.error('  ' + name + ' b64 does not round-trip'); process.exit(1); }
+  return b64;
+};
+const block = o.wrapManagedBlock([{ public_key: 'ssh-ed25519 AAAA', label: 'laptop' }]);
+const rendered = raw
+  .replace(/__REPO_URL__/g,'')
+  .replace(/__BOX_SOURCE_FETCH_B64__/g, inject('box-source-fetch.sh'))
+  .replace(/__BOX_AUTHKEYS_FETCH_B64__/g, inject('box-authorized-keys-fetch.sh'))
+  .replace(/__BUILDER_AUTHORIZED_KEYS_B64__/g, Buffer.from(block,'utf8').toString('base64'))
+  .replace(/__BOX_ENV_B64__/g, Buffer.from('','utf8').toString('base64'));
+const leftover = rendered.match(/__[A-Z_]+__/g);
+if (leftover) { console.error('  placeholders not substituted: ' + leftover.join(', ')); process.exit(1); }
+if (!raw.includes('encoding: b64')) { console.error('  write_files missing encoding: b64'); process.exit(1); }
+if (!raw.includes('/root/.ssh/otb-authorized-keys.block')) { console.error('  baked authorized_keys block not wired'); process.exit(1); }
+if (!raw.includes('box-authorized-keys-fetch.sh')) { console.error('  authkeys-fetch cron not wired'); process.exit(1); }
+if (!raw.includes('/etc/otb/box.env')) { console.error('  named-tunnel box.env not wired (#771)'); process.exit(1); }
+console.log('  source-fetch + authkeys-fetch scripts inject + round-trip; baked-keys block + box.env + crons wired');
+" || fail "cloud-init injection broken"
+
+printf '\n\033[1;32m✓ box-lifecycle smoke passed\033[0m\n'