Stop Letting Antigravity Agents Self-Report 'Done' — Completion Contracts and External Verification

# scripts/done_check.py
import subprocess, sys, yaml
from pathlib import Path
 
EXIT_OK, EXIT_CHECK, EXIT_INTENT, EXIT_BUDGET = 0, 2, 3, 4
 
def sh(cmd: str) -> int:
    print(f"::group::{cmd}")
    rc = subprocess.run(cmd, shell=True).returncode
    print("::endgroup::")
    return rc
 
def changed_files() -> list[str]:
    out = subprocess.check_output(
        "git diff --name-only origin/main...HEAD", shell=True, text=True)
    return [l for l in out.splitlines() if l.strip()]
 
def main(contract_path: str) -> int:
    c = yaml.safe_load(Path(contract_path).read_text())
    task_dir = Path(contract_path).parent
 
    # check budget first; scope drift is a strong intent-drift signal
    files = changed_files()
    budget = c.get("budget", {})
    if (m := budget.get("max_files_changed")) and len(files) > m:
        print(f"BUDGET: {len(files)} files > {m}")
        return EXIT_BUDGET
    for forbidden in budget.get("forbid_paths", []):
        if any(f.startswith(forbidden) for f in files):
            print(f"BUDGET: touched forbidden path {forbidden}")
            return EXIT_BUDGET
 
    # formal & functional; bail on first failure (do not reach intent)
    for layer in ("formal", "functional"):
        for cmd in c.get(layer, []):
            if sh(cmd) != 0:
                print(f"{layer.upper()} FAILED: {cmd}")
                return EXIT_CHECK
 
    # intent: sieve the answers for existence AND concreteness
    intent = c.get("intent", {})
    answers = task_dir / "intent.md"
    if intent.get("questions"):
        if not answers.exists():
            print("INTENT: intent.md missing")
            return EXIT_INTENT
        text = answers.read_text()
        for q in intent["questions"]:
            qid = q["id"]
            block = extract_answer(text, qid)
            if not block or len(block.strip()) < 40 or block.strip() == "Confirmed":
                print(f"INTENT: answer too thin: {qid}")
                return EXIT_INTENT
            if qid in ("side_effects", "error_paths"):
                if not any(tok in block for tok in (".ts", ".py", "test", "spec")):
                    print(f"INTENT: no concrete reference: {qid}")
                    return EXIT_INTENT
 
    print("DONE: all layers passed")
    return EXIT_OK
 
def extract_answer(md: str, qid: str) -> str:
    # grab the block directly under "## <qid>"
    buf, capture = [], False
    for ln in md.splitlines():
        if ln.startswith("## "):
            capture = qid in ln
            continue
        if capture:
            buf.append(ln)
    return "\n".join(buf)
 
if __name__ == "__main__":
    sys.exit(main(sys.argv[1]))

# scripts/unattended_gate.py (final gate for unattended runs, excerpt)
import subprocess, sys, json
from pathlib import Path
 
STATE = Path(".agent/attempts.json")
 
def load_state():
    return json.loads(STATE.read_text()) if STATE.exists() else {}
 
def main(task_id: str, contract: str) -> int:
    st = load_state()
    rc = subprocess.run(["python", "scripts/done_check.py", contract]).returncode
    if rc == 0:
        # diff audit: catch huge deletions beyond the forbid_paths list
        numstat = subprocess.check_output(
            "git diff --numstat origin/main...HEAD", shell=True, text=True)
        big_del = [l for l in numstat.splitlines()
                   if l and l.split('\t')[1].isdigit() and int(l.split('\t')[1]) > 400]
        if big_del:
            print("AUDIT: deletion over 400 lines, quarantining")
            return 5
        st[task_id] = 0
        STATE.write_text(json.dumps(st)); return 0
 
    st[task_id] = st.get(task_id, 0) + 1
    STATE.write_text(json.dumps(st))
    if rc == 4 or st[task_id] >= 3:       # budget violation or repeated failure
        print(f"QUARANTINE: rc={rc} attempts={st[task_id]}")
        return 9                          # no auto-merge; hand to a human
    print(f"RETRY: rc={rc} attempts={st[task_id]}")
    return rc
 
if __name__ == "__main__":
    sys.exit(main(sys.argv[1], sys.argv[2]))