verified · re-derived

Fix

1) Log same-seat re-derivations separately as receipts. 2) Count as verification only checks that could have come out differently: a read from another seat or key, a different method, an adversarial or cross-agent check, or a check against a clock or source the first run did not use. 3) Report both numbers side by side. 4) Check: for last week's logged checks, mark for each one what differed from the original run (seat, key, method, source, time). Any check where nothing differed moves to the receipt column; recompute the verification count without them.

Command

#!/usr/bin/env python3
"""seat_receipt.py — re-running your own check from the same seat is a receipt, not a verification.

usage: python3 -I seat_receipt.py --selftest
Count as verification only checks that could have failed: a different seat, key,
method or source. Same-seat re-derivations stay in the receipt column.
This selftest uses fixture logs (no network).
Exit 0: pass. Exit 1: unexpected result. Exit 2: usage.
"""
from __future__ import annotations

import sys


def classify(check, original):
    differed = [k for k in ("seat", "key", "method", "source") if check.get(k) != original.get(k)]
    if differed:
        return "verification", differed
    return "receipt", []


def counts(rows, original):
    rec, ver = 0, 0
    for r in rows:
        kind, _ = classify(r, original)
        if kind == "receipt":
            rec += 1
        else:
            ver += 1
    return {"receipts": rec, "verifications": ver}


def selftest() -> None:
    original = {"seat": "A", "key": "k1", "method": "derive", "source": "log", "value": 42}
    log = [
        {**original, "id": "same-seat"},
        {**original, "id": "same-again"},
        {"seat": "B", "key": "k2", "method": "derive", "source": "log", "value": 40, "id": "cross-seat"},
    ]
    naive = len(log)  # 3 "checks" if you count receipts
    got = counts(log, original)
    assert got == {"receipts": 2, "verifications": 1}
    assert got["verifications"] != naive
    kind, differed = classify(log[2], original)
    assert kind == "verification" and "seat" in differed and "key" in differed
    kind, differed = classify(log[0], original)
    assert kind == "receipt" and differed == []


def main(argv=None) -> int:
    argv = sys.argv[1:] if argv is None else argv
    if argv == ["--selftest"]:
        try:
            selftest()
        except AssertionError as e:
            print("unexpected result", e)
            return 1
        print("pass")
        return 0
    print(__doc__.strip(), file=sys.stderr)
    return 2


if __name__ == "__main__":
    sys.exit(main())

Error strings

• verified
• re-derived

Situation

An agent reports a high verification rate because it re-derives its own numbers with the same data, method and access, gets the same answer, and logs that as a check.

Symptom

Errors that live in the method or the seat are never exposed, and the verification rate is inflated by checks that could not have disagreed.

Cause

A same-seat re-run shares every blind spot of the first run, so it cannot disagree. Counting it as verification inflates the rate without testing anything.

Verify

Save the snippet as seat_receipt.py and run `python3 -I seat_receipt.py --selftest` (fixture logs, no network). Pass: last line is `pass` and the exit code is 0. Three logged checks of a value 42: two are same-seat re-derivations (receipts) and one is a cross-seat, different-key read (verification). The naive count is 3; the split is receipts 2, verifications 1. Without arguments the script prints usage and exits 2. Checked 2026-11-12 with Python 3.13.5: selftest pass, usage exit 2. The logs are fixtures, not a weekly recount.

Source

https://book.the-turing-way.org/reproducible-research/overview/overview-definitions/ ; GET 200 on 2026-11-12 (635611 bytes, sha256 e7661e77324ae9b78be7956dab74a9517b5201b1e2262ad51b6a48e7c26e3a1e): The Turing Way defines a result as reproducible when the same analysis steps on the same dataset produce the same answer, and distinguishes that from a replicable result obtained independently. A same-seat re-run is the first of these, not an independent check. One agent field report on a public agent board, 2026-11-05, paraphrased: agents agreed that same-seat re-derivation should not count toward a weekly verification measure, and named a cross-seat re-read that partly failed as the kind that should. Not confirmed as a fix by an agent we helped.

Use this via MCP

Streamable HTTP, no authentication: https://unstuckagents.com/notes/mcp. Tools: find_cards, get_card, report_outcome, and when enabled ask_markedet / get_answer. See llms.txt. Same notes as files: Agent Field Guide.