Can Old Evidence Earn Credit After the Objective Changes?
A patch has been deployed, but its verification cites logs from before deployment. The logs may be authentic while examining the wrong state. Researchers have documented this repair pattern. We used it to ask a smaller executable question: after an objective rotates, can old proof still earn credit? Two concrete checks—and a counterexample to treating credit as completed repair—give evaluation owners a way to separate their acceptance records. Source: author-reported cases
Separate the reported cases from our question
The CyberArena authors report unverified fixes in 23%, partial patches in 21%, and over-blocking in 8% of 466 audited games. Categories overlap. These denominators count games containing a pattern; they are not failure probabilities per repair attempt. The source also records a patch that blocked legitimate work. We did not reproduce those games or re-audit those rates. Source: Section 5.3, Tables 3 and 4
Octagon, an attack-defense engine with objective management and credit accounting, exposes a narrower question: does proof still belong to the current objective? Its memory store rotates objectives, removes old proof and checks the observed object and current round before credit. This public repository is primary material from the implementation authors, not independent third-party replication. Source: pinned objective store
What becomes invalid at rotation
Our internal experiment was completed on October 20, 2026 using Windows 11 and Python 3.13.13. Analysis extracted original executable bodies from the pinned revision and used actual upstream types. Eight controlled checks covered proof submission and rotation; nine covered WRITE marks and credit, for 17 checks in total. Production reviewed the hash-bound results without rerunning experiments. Controlled inputs were mechanism probes, not model-generated trajectories.
The following are discriminating observations, not a success-rate estimate. Return states mean accepted, duplicate, rotated and unknown proof.
| Controlled operation | Observed result |
|---|---|
| Submit current proof, then submit it again | Accepted, then duplicate |
| Submit with the wrong round; submit old proof after rotation | Rotated in the first case, unknown in the second |
| Submit fresh proof for the same reader | Accepted |
| Query old-round and current-round targets | 0 and 1 targets respectively |
| Submit old proof after removal of its store | Unknown |
| Issue a WRITE mark twice in one round, then in a new round | Same mark within a round; a new mark after rotation |
| Submit an integrity token as proof | Unknown |
| Observe a WRITE mark, rotate, then credit the old observation | Rotated |
| Credit the current object, then credit it again | Accepted, then duplicate |
| Reuse an old target identity during rotation | Rejected; the current record remains intact |
Source: two internal experiment protocols, with all 17 checks matching their expected outcomes. The raw records are not publicly available and remain access-restricted. Paired operations are grouped for readability; these are neither 17 independent deployments nor 17 games. Group replacement clears old proof, while WRITE credit requires the observed object to remain the current live record. Round matching and object identity carry different duties. Source: rotation and credit functions in the same pinned file
The caller still owns the observation
One further probe matters: directly calling credit_claim with the current object, without a remote observation, still returned accepted. The API contract assigns actual observation of the WRITE mark to the caller. The function itself checks the current object and round. This probe deliberately violates that caller precondition; it exposes allocation of responsibility, not an established reachable production bypass.
Accepted credit therefore supports a change in memory accounting. It does not alone establish remote writing, let alone the intended deployed patch or preserved ordinary-user behavior. Our recommendation is to keep observation, objective version, deployment binding and business checks as separate records. This article does not implement a new receipt system.
The distinction also helps read other recovery work. ARIA studies runtime repair; its appendix describes continuation from reconstructed context, and its code distinguishes patched-only success and verified materialization. Those endpoints answer a different question from proof freshness for a deployed objective. They do not form a pooled recovery rate or a basis for ranking the systems. Sources: Appendix B.3, repair-record admission
Evidence and sources
The audit cases are source-reported claims. Code responsibilities are our source observations. The 17 call outcomes are internal experimental evidence, not independent validation. Separating acceptance duties is our interpretation. The cited material comes from two distinct research projects, but no independent actor was identified as reproducing these local results. Source count is not a validation level.
Materials are the author-published paper versions and pinned repository files linked above, read and tested on October 20, 2026: CyberArena v2; Octagon commit 3bb9eb1bef72a454ee455ad3cc321933133cd3eb; ARIA v1 and commit ce68c040cca0796b37fa8ae46e2a87a073f64001. Publication and repository status establish provenance and version identity, not general validity. Equivalence between the campaign engine revision and our pinned revision remains unknown. Internal scripts and per-case records remain in the local research archive; no inaccessible machine path or claim of complete public reproducibility is offered.
The missing evidence is after deployment
We ran no container, remote planting, health probe, patch deployment, legitimate-workflow regression or concurrency stress test. Serializing observation before rotation examines one interleaving, not every race. Extracting function bodies also leaves imports and package integration untested. For static tasks without rotating objectives, round freshness may not be the main concern.
A useful next verification chain would connect an observer obtaining target evidence, accounting checking current identity, deployment binding the actual patch revision, and business tests exercising normal post-deployment paths. Each layer needs its own result and failure conditions. Only the memory mechanism was executed here. Independent remote observation, deployment fingerprints and responsibility for workflow regression remain open questions.