@bongos/core 1.17.0

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

@@ -0,0 +1,212 @@
+#!/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/gds/me                              (always present)
+#        - GET /api/gds/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
+#      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/gds/builders/me surface will start returning 200 and this smoke
+# will automatically include it. No edits needed here.
+#
+# Usage:
+#   bash scripts/gds/smoke-claim-consistency.sh
+# Optional env:
+#   GDS_API_BASE / PMS_API_BASE  override the API 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)
+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': 'PMS-V2',
+  '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/gds/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/gds/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
+}
+
+echo "=== GDS claim-consistency smoke test ==="
+echo "API: ${API}"
+echo "Titles: ${SMOKE_TITLE_A} | ${SMOKE_TITLE_B}"
+echo
+
+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/gds/me — always present.
+ME_PAYLOAD=$(call GET /api/gds/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/gds/me                 -> ${ME_FILTERED}"
+if [[ "${ME_FILTERED}" == "${EXPECTED}" ]]; then
+  echo "  PASS /api/gds/me ordering matches"
+  checked=$((checked+1))
+else
+  echo "  FAIL /api/gds/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)
+if [[ "${BUILDERS_ME_CODE}" == "200" ]]; then
+  BME_PAYLOAD=$(call GET /api/gds/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/gds/builders/me        -> ${BME_FILTERED}"
+  if [[ "${BME_FILTERED}" == "${EXPECTED}" ]]; then
+    echo "  PASS /api/gds/builders/me ordering matches /api/gds/me"
+    checked=$((checked+1))
+  else
+    echo "  FAIL /api/gds/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)"
+  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}"

package/scripts/gds/smoke-dependencies.sh

@@ -0,0 +1,84 @@
+#!/usr/bin/env bash
+# Smoke test for the dependency + auto-promotion system (ADR 0015 / migration 020).
+#
+# Round-trip:
+#   1. Create task A with status='backlog', kind='feature'
+#   2. Create task B with status='ready'
+#   3. Wire A.dependencies = [B]    (A's status stays backlog — auto-promotion only
+#                                    fires when B SHIPS, not when the edge is added)
+#   4. Try to claim A — must fail 409 DEPS_NOT_SHIPPED (manual promote test)
+#   5. Promote A manually (the route allows it; the gate is at claim time)
+#   6. Try to claim A — still 409 DEPS_NOT_SHIPPED
+#   7. Claim B, ship B (active → completed → confirmed → shipped)
+#   8. Verify A auto-promoted backlog→ready (or stays ready if step 5 ran)
+#   9. Claim A — succeeds
+#  10. Release A + clean up
+#
+# Run from any environment where ~/.config/otb/{gds,pms}-session.json is valid.
+# Requires curl + jq.
+set -euo pipefail
+
+TOKEN=$(python3 -c "
+import json, os, sys
+for p in ['/Users/'+os.environ['USER']+'/.config/otb/gds-session.json',
+          '/Users/'+os.environ['USER']+'/.config/otb/pms-session.json']:
+    if os.path.exists(p):
+        print(json.load(open(p))['token']); sys.exit(0)
+sys.exit(1)
+")
+
+BASE="${GDS_BASE:-https://amazonprimea.com}"
+SUFFIX="$(date +%s)"
+
+echo "=== 1. Create task B (depends-on target, status=ready) ==="
+B=$(curl -sS -X POST "$BASE/api/gds/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" \
+  -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" \
+  -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
+
+echo "=== 5. Attempt claim A — MUST 409 DEPS_NOT_SHIPPED ==="
+CLAIM_RESP=$(curl -sS -X POST "$BASE/api/gds/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
+echo "$CLAIM_RESP" | grep -q "DEPS_NOT_SHIPPED" && echo "  PASS: claim refused with DEPS_NOT_SHIPPED" || (echo "  FAIL: claim was not refused"; exit 1)
+
+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" \
+  -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
+
+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'])")
+echo "  A status: $A_STATUS"
+[ "$A_STATUS" = "ready" ] && echo "  PASS" || (echo "  FAIL: A not ready"; exit 1)
+
+echo "=== 8. Claim A — must succeed now ==="
+node scripts/gds/claim.js "$A_ID" --worktree "smoke-$SUFFIX-A"
+
+echo "=== 9. Cleanup (release A; mark both abandoned) ==="
+node scripts/gds/release.js "$A_ID" --reason "smoke cleanup" || true
+
+echo
+echo "ALL SMOKE STEPS PASSED."

package/scripts/gds/smoke-gds.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+// Cross-platform replacement for smoke-gds.sh — same checks, no bash required.
+// Works on Windows (Git Bash / PowerShell / cmd), macOS, and Linux.
+//
+// Usage:
+//   node scripts/gds/smoke-gds.js                        # against production
+//   GDS_API_BASE=http://localhost:3000 node scripts/gds/smoke-gds.js
+//
+// Exit 0 = all checks passed. Exit 1 = one or more failures.
+
+const https = require('https');
+const http = require('http');
+const net = require('net');
+const { URL } = require('url');
+
+const BASE = process.env.GDS_API_BASE || process.env.PMS_API_BASE || 'https://amazonprimea.com';
+
+// Laptop-ergonomics preflight (#958 / V4.R20). The smoke checks need a running
+// GDS server. When BASE points at a LOCAL listener that isn't up, every check
+// floods with ECONNREFUSED and fails the ship for a reason that is not a real
+// defect (sessions 328, 1113). We detect the missing LOCAL listener and skip with
+// an explicit notice. A REMOTE base (prod) that's unreachable still fails — that
+// is a genuine problem, not a laptop convenience.
+const LOCAL_HOSTS = new Set(['localhost', '127.0.0.1', '::1', '0.0.0.0']);
+function isLocalTarget(hostname) {
+  return LOCAL_HOSTS.has(String(hostname).toLowerCase());
+}
+
+// TCP connect probe: resolves true if something accepts a connection on host:port
+// within timeoutMs, false on refusal/timeout/error. Never throws.
+function probeListener(host, port, timeoutMs = 1500) {
+  return new Promise((resolve) => {
+    let done = false;
+    const sock = net.connect({ host, port });
+    const finish = (v) => { if (!done) { done = true; sock.destroy(); resolve(v); } };
+    sock.setTimeout(timeoutMs);
+    sock.once('connect', () => finish(true));
+    sock.once('error', () => finish(false));
+    sock.once('timeout', () => finish(false));
+  });
+}
+
+const CHECKS = [
+  // Public read-only surface
+  ['GET /api/gds/healthz',              `${BASE}/api/gds/healthz`,             200],
+  ['GET /api/gds/versions',             `${BASE}/api/gds/versions`,            200],
+  ['GET /api/gds/leaderboard',          `${BASE}/api/gds/leaderboard`,         200],
+  ['GET /api/gds/public/versions',      `${BASE}/api/gds/public/versions`,     200],
+  ['GET /api/gds/public/progress',      `${BASE}/api/gds/public/progress`,     200],
+  ['GET /api/gds/public/cost-summary',  `${BASE}/api/gds/public/cost-summary`, 200],
+  ['GET /api/gds/public/recent-shipped',`${BASE}/api/gds/public/recent-shipped`,200],
+  ['GET /api/gds/public/leaderboard',   `${BASE}/api/gds/public/leaderboard`,  200],
+  // Auth-gated: must return 401 when called without a token
+  ['GET /api/gds/me (unauth)',              `${BASE}/api/gds/me`,                   401],
+  ['GET /api/gds/tasks (unauth)',           `${BASE}/api/gds/tasks`,                401],
+  ['GET /api/gds/tasks/claimable (unauth)', `${BASE}/api/gds/tasks/claimable`,      401],
+  ['GET /api/gds/memory/files (unauth)',    `${BASE}/api/gds/memory/files`,         401],
+  ['GET /api/gds/memory/file (unauth)',     `${BASE}/api/gds/memory/file?path=MEMORY.md`, 401],
+  ['GET /api/gds/memory/builders/1/files (unauth)', `${BASE}/api/gds/memory/builders/1/files`, 401],
+  ['GET /api/gds/memory/builders/1/file (unauth)',  `${BASE}/api/gds/memory/builders/1/file?path=MEMORY.md`, 401],
+  // Search (#949): the recall endpoint is requireBuilder-gated — POST without a
+  // token must 401, never serve. (POST because the route is POST-only; a GET
+  // would 404, which wouldn't prove the auth gate.)
+  ['POST /api/gds/search (unauth)',     `${BASE}/api/gds/search`,              401, 'POST'],
+  // Legacy /api/pms/* removed in V3.R01-followup (#308)
+  ['GET /api/pms/healthz (removed)',    `${BASE}/api/pms/healthz`,             404],
+];
+
+function checkUrl(label, url, expectStatus, method = 'GET') {
+  return new Promise((resolve) => {
+    const parsed = new URL(url);
+    const lib = parsed.protocol === 'https:' ? https : http;
+    const opts = {
+      hostname: parsed.hostname,
+      port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
+      path: parsed.pathname + parsed.search,
+      method,
+      timeout: 10000,
+    };
+    const req = lib.request(opts, (res) => {
+      // drain the response body
+      res.resume();
+      res.on('end', () => {
+        const ok = res.statusCode === expectStatus;
+        console.log(`${ok ? 'PASS' : 'FAIL'}  ${label}  (${res.statusCode}${ok ? '' : ` expected=${expectStatus}`})`);
+        resolve(ok);
+      });
+    });
+    req.on('error', (err) => {
+      console.log(`FAIL  ${label}  (error: ${err.message})`);
+      resolve(false);
+    });
+    req.on('timeout', () => {
+      req.destroy();
+      console.log(`FAIL  ${label}  (timeout)`);
+      resolve(false);
+    });
+    req.end();
+  });
+}
+
+async function main() {
+  const parsed = new URL(BASE);
+  const host = parsed.hostname;
+  const port = Number(parsed.port) || (parsed.protocol === 'https:' ? 443 : 80);
+
+  if (isLocalTarget(host) && !(await probeListener(host, port))) {
+    console.log('=== GDS smoke SKIPPED ===');
+    console.log(`No server listening on ${host}:${port} (local target ${BASE}).`);
+    console.log('The smoke checks need a running GDS server — start one (npm start) or point');
+    console.log('GDS_API_BASE at a reachable host. Skipping: not a ship-blocking failure.');
+    process.exit(0);
+  }
+
+  console.log(`=== GDS smoke against ${BASE} ===`);
+  const results = await Promise.all(CHECKS.map(([label, url, status, method]) => checkUrl(label, url, status, method)));
+  const passed = results.filter(Boolean).length;
+  const failed = results.length - passed;
+  console.log(`=== ${passed} passed, ${failed} failed ===`);
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+if (require.main === module) main();
+
+module.exports = { isLocalTarget, probeListener };

package/scripts/gds/smoke-write.sh

@@ -0,0 +1,168 @@
+#!/usr/bin/env bash
+# GDS write-path smoke test (production). Renamed from PMS in V3.R01.
+#
+# Exercises the full claim → ship round-trip against the live API:
+#   1. Read session token from ~/.config/otb/gds-session.json (or legacy pms-session.json)
+#   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
+#   5. Validate: tasks.status flipped to 'shipped'
+#                session_logs row exists for this claim
+#                public/recent-shipped does NOT contain the smoke title
+#                public/progress weighting unchanged (smoke tasks filtered)
+#
+# The synthetic task has credits_reward=0 so no credit_log row is written
+# and the leaderboard is unaffected. The credit-award path is implicitly
+# validated by every real /builder-ship in production.
+#
+# Usage:
+#   bash scripts/gds/smoke-write.sh
+# Optional env:
+#   GDS_API_BASE / PMS_API_BASE  override the API 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)
+SMOKE_TITLE="__smoke__ write-path ${ts}"
+
+call() {
+  # call METHOD PATH [BODY] → echoes JSON, exits non-zero if HTTP non-2xx
+  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
+}
+
+snapshot_progress() {
+  curl -sS "${API}/api/gds/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']))"
+}
+
+echo "=== GDS write-path smoke test ==="
+echo "API: ${API}"
+echo "Title: ${SMOKE_TITLE}"
+echo
+
+echo "--- 0. snapshot progress before ---"
+PROGRESS_BEFORE=$(snapshot_progress)
+echo "${PROGRESS_BEFORE}"
+
+echo
+echo "--- 1. create task ---"
+CREATE_BODY=$(python3 -c "
+import json
+print(json.dumps({
+  'version_id': 'PMS-V1',
+  'title': '${SMOKE_TITLE}',
+  'description': 'Synthetic smoke task. Auto-shipped by smoke-write.sh.',
+  'status': 'ready',
+  'touches': ['__smoke__/${ts}'],
+  'est_minutes': 1,
+  'manual_degree': 1,
+  'priority': 5,
+  'automation_tag': 'overnight-safe',
+  'credits_reward': 0,
+  'source': 'smoke',
+  'source_ref': '${ts}'
+}))
+")
+TASK_JSON=$(call POST /api/gds/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_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}")
+echo "${RESOLVE_JSON}"
+
+echo
+echo "--- 4. validate ---"
+fail=0
+
+# 4a. recent-shipped does NOT contain the smoke title
+RECENT=$(curl -sS "${API}/api/gds/public/recent-shipped")
+if echo "${RECENT}" | python3 -c "
+import json, sys
+data = json.load(sys.stdin)
+titles = [t['title'] for t in data.get('tasks', [])]
+needle = '${SMOKE_TITLE}'
+sys.exit(0 if needle not in titles else 1)
+"; then
+  echo "PASS recent-shipped excludes smoke task"
+else
+  echo "FAIL recent-shipped LEAKED smoke task"
+  fail=1
+fi
+
+# 4b. progress unchanged (smoke filtered from version_progress view)
+PROGRESS_AFTER=$(snapshot_progress)
+if [[ "${PROGRESS_BEFORE}" == "${PROGRESS_AFTER}" ]]; then
+  echo "PASS progress unchanged (smoke filtered from version_progress)"
+else
+  echo "FAIL progress changed:"
+  echo "  before: ${PROGRESS_BEFORE}"
+  echo "  after:  ${PROGRESS_AFTER}"
+  fail=1
+fi
+
+# 4c. task.status lands at 'completed' after resolve.
+# Under the MAS grader-gated lifecycle (V3.R18 #209 / ADR 0024), resolveClaim
+# with verification.passed=true lands the task at 'completed' and STOPS — the
+# completed→confirmed transition is gated by the subagent quality grader
+# (POST /tasks/:id/grade), NOT by resolve. This smoke test exercises only the
+# resolve round-trip, so 'completed' is the correct terminal state here.
+# (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}")
+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)"
+else
+  echo "FAIL task.status = ${STATUS_AFTER} (expected completed)"
+  fail=1
+fi
+
+# 4d. session_logs row exists — checked via DB (need ssh)
+if command -v ssh >/dev/null && ssh -o BatchMode=yes -o ConnectTimeout=3 lars@104.236.254.243 true 2>/dev/null; then
+  SLOG_COUNT=$(ssh lars@104.236.254.243 "psql -d amazonprimea -tAc \"SELECT count(*) FROM session_logs WHERE claim_id = ${CLAIM_ID}\"")
+  if [[ "${SLOG_COUNT}" == "1" ]]; then
+    echo "PASS session_logs row exists (claim_id=${CLAIM_ID})"
+  else
+    echo "FAIL session_logs row missing (claim_id=${CLAIM_ID}, count=${SLOG_COUNT})"
+    fail=1
+  fi
+else
+  echo "SKIP session_logs DB check (no SSH access from this host)"
+fi
+
+echo
+echo "--- summary ---"
+if [[ "${fail}" -eq 0 ]]; then
+  echo "OK: write-path smoke passed (task #${TASK_ID}, claim #${CLAIM_ID})"
+else
+  echo "FAIL: one or more checks failed (task #${TASK_ID}, claim #${CLAIM_ID})"
+fi
+exit "${fail}"