A green build is not a correct deploy. Prove it live.

# Generate a unique id per build and write it where the live page will serve it.
# (Here: a meta tag in index.html and a plain /build-id.txt next to it.)
BUILD_ID="build-$(date +%s)-$(git rev-parse --short HEAD 2>/dev/null || echo nogit)"
echo "stamping $BUILD_ID"

# index.html gets a machine-readable marker the poller can grep for.
printf '<meta name="x-build-id" content="%s">\n' "$BUILD_ID" >> dist/index.html
printf '%s\n' "$BUILD_ID" > dist/build-id.txt

# ... then ship it (Vercel here; swap for your deploy target) ...
# vercel deploy --prod --yes
echo "$BUILD_ID"   # hand this exact value to the poller below

#!/usr/bin/env python3
"""Smoke the live deploy. Exits 0 only if the real flow produces the
real output. Generic: a page-string check and an MCP tools/list check."""
import sys, json, urllib.request

def fetch(url, data=None, headers=None):
    req = urllib.request.Request(
        url, data=data, headers=headers or {}, method="POST" if data else "GET")
    with urllib.request.urlopen(req, timeout=15) as r:
        return r.status, r.read().decode("utf-8", "replace")

def check_page(url, must_contain):
    status, body = fetch(url)
    ok = status == 200 and must_contain in body
    print(("PASS" if ok else "FAIL"), "page", url,
          "->", status, repr(must_contain), "present" if ok else "MISSING")
    return ok

def check_mcp_tools(mcp_url, expected):
    # One framed JSON-RPC call. tools/list must return every name we expect.
    payload = json.dumps({
        "jsonrpc": "2.0", "id": 1, "method": "tools/list"}).encode()
    status, body = fetch(mcp_url, data=payload,
                         headers={"Content-Type": "application/json"})
    try:
        names = {t["name"] for t in json.loads(body)["result"]["tools"]}
    except Exception:
        names = set()
    missing = set(expected) - names
    ok = status == 200 and not missing
    print(("PASS" if ok else "FAIL"), "mcp", mcp_url,
          "-> got", sorted(names), "missing", sorted(missing))
    return ok

if __name__ == "__main__":
    base = sys.argv[1] if len(sys.argv) > 1 else "https://your-app.vercel.app"
    results = [
        check_page(base, "ship + prove"),
        # check_mcp_tools(base + "/mcp", ["get_notes", "search_notes", "add_note"]),
    ]
    sys.exit(0 if all(results) else 1)   # non-zero -> the agent holds

#!/usr/bin/env python3
"""Idempotent consequential write over a tiny store + append-only ledger.
The store backs idem_claim/idem_record; the ledger gives a human-auditable
trail with a dedup window. Swap the dict for Redis/KV; the contract holds."""
import json, time, hashlib, os, threading

_LOCK = threading.Lock()
_STORE = {}                      # key -> claimed_at epoch  (swap for KV)
LEDGER = "sent_ledger.jsonl"     # append-only audit trail

def idem_key(recipient: str, action: str, day: str) -> str:
    raw = f"{action}|{recipient}|{day}".encode()
    return "idem:" + hashlib.sha256(raw).hexdigest()[:16]

def _within_window(key: str, window_s: int) -> bool:
    """True if this key was recorded in the ledger inside the window."""
    if not os.path.exists(LEDGER):
        return False
    cutoff = time.time() - window_s
    with open(LEDGER, encoding="utf-8") as f:
        for line in f:
            try:
                row = json.loads(line)
            except ValueError:
                continue
            if row.get("key") == key and row.get("ts", 0) >= cutoff:
                return True
    return False

def idem_claim(key: str, window_s: int) -> bool:
    """Reserve the key. Returns False if already claimed/recorded in-window."""
    with _LOCK:
        if key in _STORE or _within_window(key, window_s):
            return False
        _STORE[key] = time.time()
        return True

def idem_record(key: str, meta: dict) -> None:
    """Commit to the append-only ledger after the side effect succeeds."""
    with _LOCK, open(LEDGER, "a", encoding="utf-8") as f:
        f.write(json.dumps({"key": key, "ts": time.time(), **meta}) + "\n")

def send_invite(email: str, day: str, window_s: int = 30 * 86400) -> str:
    key = idem_key(email, "invite", day)
    if not idem_claim(key, window_s):
        return f"already done, skipping ({key})"
    # --- real side effect goes here (SMTP, API call, booking) ---
    # send_email(email, ...)   # only runs once per key per window
    idem_record(key, {"email": email, "action": "invite", "day": day})
    return f"sent invite to {email} ({key})"

if __name__ == "__main__":
    day = time.strftime("%Y-%m-%d")
    print("run 1:", send_invite("sponsor@example.com", day))
    print("run 2:", send_invite("sponsor@example.com", day))  # retry -> no-op