Hmbown/CodeWhale · error · PersistenceBacklogError

baseline_observation.accepted_requests must equal…

Error message

baseline_observation.accepted_requests must equal requests_attempted

What it means

validate_budget requires baseline_observation.accepted_requests to equal FIXTURE['requests_attempted'] (128). The frozen workload assumes every request is accepted — the receipt validator enforces the same equality — so a baseline that recorded fewer accepted requests describes a run where the sender rejected work, which is not a valid backlog measurement.

Solutions

Re-run the measurement so baseline_observation.accepted_requests records all 128 accepted requests
Set accepted_requests to match FIXTURE['requests_attempted'] (128) when correcting a stale budget
Regenerate the budget from the current script so fixture and baseline stay in sync

Example fix

// before
"baseline_observation": { "accepted_requests": 127 }
// after
"baseline_observation": { "accepted_requests": 128 }

Defensive patterns

Strategy: validation

Validate before calling

from check_persistence_backlog_budget import FIXTURE
assert budget["baseline_observation"].get("accepted_requests") == FIXTURE["requests_attempted"], "baseline accepted_requests must equal the frozen requests_attempted"

Type guard

def baseline_accepts_all(b):
    return isinstance(b.get("baseline_observation"), dict) and b["baseline_observation"].get("accepted_requests") == FIXTURE["requests_attempted"]

Try / catch

try:
    validate_budget(budget)
except PersistenceBacklogError as e:
    if "accepted_requests must equal requests_attempted" in str(e):
        print("baseline came from a run that rejected work; re-measure")
    raise

Prevention

Only build baseline_observation from measurement runs where accepted == attempted
Keep fixture and baseline_observation in sync by regenerating the budget as one document
Reject any baseline whose accepted_requests differs from the frozen workload size before committing

When it happens

Trigger: compare calls validate_budget and baseline_observation.accepted_requests is missing, not a non-negative integer (non_negative_integer check), or an integer that differs from 128 (the frozen requests_attempted).

Common situations: Copying baseline numbers from a run with a different workload size; editing the fixture's requests_attempted in a stale budget while keeping the old baseline; a baseline produced by a buggy measurement run that dropped requests.

Understand the failure class

Background: Schema validation failed / invalid input schema: payload rejected because its shape doesn't match the expected schema — this error's family across 28 libraries.

Related errors

AI-assisted analysis of Hmbown/CodeWhale@433685b202 (2026-09-15). Data as JSON: /api/errors/de3cdb5f1d990763. Report an issue: GitHub.

Appendix: source

Thrown at scripts/check-persistence-backlog-budget.py:274

        raise PersistenceBacklogError("budget baseline_receipt path changed")
    ceilings = budget.get("ceilings")
    baseline = budget.get("baseline_observation")
    if not isinstance(ceilings, dict) or not isinstance(baseline, dict):
        raise PersistenceBacklogError("budget needs ceilings and baseline_observation objects")
    for field in CEILING_FIELDS:
        ceiling = non_negative_integer(ceilings.get(field), f"ceilings.{field}")
        observed = non_negative_integer(
            baseline.get(field), f"baseline_observation.{field}"
        )
        if observed > ceiling:
            raise PersistenceBacklogError(
                f"baseline_observation.{field} exceeds its ceiling"
            )
    baseline_accepted = non_negative_integer(
        baseline.get("accepted_requests"), "baseline_observation.accepted_requests"
    )
    if baseline_accepted != FIXTURE["requests_attempted"]:
        raise PersistenceBacklogError(
            "baseline_observation.accepted_requests must equal requests_attempted"
        )
    baseline_applied = non_negative_integer(
        baseline.get("applied_version"), "baseline_observation.applied_version"
    )
    if baseline_applied != FIXTURE["expected_applied_version"]:
        raise PersistenceBacklogError(
            "baseline_observation.applied_version must be the final sent version"
        )
    baseline_retained = baseline["retained_queued_requests"]
    baseline_payload = baseline["estimated_retained_payload_bytes"]
    if baseline_retained == 0 or baseline_payload == 0:
        raise PersistenceBacklogError(
            "baseline_observation must retain the final request and payload"
        )
    if baseline_retained > baseline_accepted:
        raise PersistenceBacklogError(
            "baseline_observation.retained_queued_requests exceeds accepted_requests"

View on GitHub (pinned to 433685b202)