Overwriting an earlier failure because something later worked destroys the explanation of what changed. It can also hide whether input was already delivered. In actual service experiments I retain the failed attempt and connect later reading, fixes and tests as different events.
The 2026-10-27 update adds the later source boundaries: same-runtime document reading versus post-restart restoration, and a new checkpoint that leaves the earlier failed attempt intact.
A client failure and a server effect can coexist
A historical ZIP attachment reached the actual site while client selection proof failed and left needs_review. Later reading confirmed the attachment without uploading it again. The failure records which proof the client could not obtain, even though an external effect existed.
Seeing the attachment later does not automatically make every earlier verification and final record successful. Connect the later observation and its time to the original attempt. Retaining the disagreement between delivery and recorded state helps the next operator avoid a simple restart. Preserving evidence against duplication matters more than cosmetically removing a red label.
Reading an existing draft differs from entering it again
A paragraph-detection error stopped multiline input before submission. The already-written test draft was compared exactly by reading, then sent once. Advancing verification did not require refilling it. Confusion between blank logical lines and CSS spacing remained a separate fix.
A later actual page-API multiline input and new-response check is recorded separately. It was not reassigned as a successful new run of the earlier plugin. Similar operation names do not make run identities and verification sequences interchangeable. Preserving the route identifies what still needs regression testing and what actually completed.
Link a fix to its cause and a follow-up test to changed code
After fixing file-selection proof, an independent HTTP receiver checked bytes and the new selection condition. The final build was not used for another actual ChatGPT ZIP upload. Final-code local evidence and earlier live-service effects remain side by side with their difference stated.
Gemini records separately connect menu-item recognition, shortened attachment cards, an editing-window misclassification and refusal classification to causes and tests. One local fix cannot clear every feature failure. A passing follow-up becomes useful when it explains which change altered which counterexample. A count alone loses the relationship to the original defect.
Do not launder cancelled waiting into a successful run
When generation took long, an executor wait was cancelled while site generation was neither stopped nor resent. Reading later found the result. A usable medium does not justify rewriting the cancelled observer run as succeeded: the generation and observer have different lifetimes.
The Gemini record explicitly retains failure and cancellation states. An ownership refusal is not bypassed; existing execution is settled before reading. That procedure reconciles an earlier effect rather than proving a new generation succeeded. Separate executor status from external-media existence so later operations can interpret both accurately.
Update 2026-10-27: does the read belong to the original document?
A later implementation review adds an important condition to this article. Matching address, title and body do not necessarily identify the document that received the original input. A remaining internal recovery function could accept a replaced document on that basis and mark the earlier failed step as verified. The later source and verification report record a focused correction to that behavior.
The changed source binds newly recorded failed input to the host module’s lifetime marker, profile, project, frame and document epoch. A legacy record without that binding, or a record from another module lifetime, is not upgraded through this read check. The supported boundary is narrower: compare known values within the same live document context.
That lifetime marker is neither a login credential nor a permanent logical document ID issued by the site. Opening an equal address after restarting the application does not prove automatic restoration of the earlier draft. The change also does not resolve every logical document replacement within a single-page application. Same-runtime reading and post-restart document recovery remain separate claims.
A new read record references the failure without changing it
The inspected source compares known title and target values through reads, requires a unique target, and accepts only checked and matches values that are exactly true. It rechecks context around asynchronous operations because the document can change while a read is pending. Unsettled native input blocks progress. A returned response alone is not the required evidence.
After a successful check, it creates a new read checkpoint in the current task and links the original task and step identifiers. It does not rewrite the old failed step as verified. Releasing the current guard and changing the historical attempt’s terminal state are different operations. Incomplete recovery work also remains excluded from automatic registration as a reusable successful procedure.
The example below does not persist that relationship in a database or authenticate a real page read. It receives declared before/after context and a declared proof, then creates a separate in-memory record. The old status and send count remain unchanged. Its flags explicitly decline to claim actual guard release, reading, transmission or durable storage.
Explore the implementation
Actual synthetic output; original status retained
{
"original": {
"attempt_id": "attempt-one",
"status": "needs_review",
"send_count": 1
},
"new_checkpoint": {
"id": "read-one",
"original_attempt_id": "attempt-one",
"kind": "read_only_evidence",
"status": "declared_match"
},
"reason": "declared_read_matches",
"performs_read_or_send": false,
"releases_runtime_guard": false,
"authenticates_context": false,
"persistent_receipt_written": false
}Distinguish reachable product paths from remaining internal code
The later report also separates the defect’s reachability. The current bootstrap removes the embedded model execution path, and the existing UI resume request is rejected in favor of checking the current result through external tools. A reproduction of the remaining internal recovery function is therefore not proof that the current public interface offers general automatic resumption.
The report separately records an owned test of the public text-read path after partial input. An external fixture completing the expected value before a successful read is not automatic repair of a real service draft. The internal two-process checks, the public read-path execution and preservation of existing drafts are distinct evidence scopes.
For this content update I read the selected source, test source and coordinator report. I did not rerun the product, independent review models or browser, and did not open account material, drafts or protected receipts. The report’s native check counts are not added to the synthetic example counts below. A narrower statement of current support refines the date and reachability of the earlier record.
Additional example: preserve the attempt while recording a declared read
I compared the existing failure-lab ZIP’s 4,684 bytes and SHA, extracted it and ran its 28 packaged tests. The separate read-record example passed 22 tests. They cover module lifetime, profile, project, frame and epoch mismatches; changes after reading; legacy records; ambiguous targets; and incomplete or truthy proof values. The existing lab’s failure receipt and send count remain unchanged.
The complete code below is a new independent synthetic example. Matching declared context returns a separate checkpoint referencing the original attempt. Missing or changed context creates no such evidence. It compares supplied identifiers and booleans rather than authenticating their origin. It does not replace a site’s stable document identity or the product’s security and recovery implementation.
Five execution records cover matching context, a legacy record, another runtime, a document change after reading and an unproven read. The excerpt below contains the actual synthetic matching-context output. The helper is an inline addition, not a new file inside the existing ZIP. The existing lab, original failure records and public article address are retained.
Explore the implementation
Complete synthetic implementation; no actual read or persistence
"""Synthetic declared-context ledger. No site read, authentication or guard release."""
from copy import deepcopy
import re
def read_checkpoint(original, stored, before, after, proof, read_id):
def token(value):
if type(value) is not str or not re.fullmatch(r'[a-z][a-z0-9_-]{0,39}', value):
raise ValueError('OPAQUE_ID')
def binding(value):
if type(value) is not dict or set(value) != {'runtime', 'profile', 'project', 'frame', 'epoch'}:
raise ValueError('EXACT_BINDING_FIELDS')
for key in ['runtime', 'profile', 'project', 'frame']:
token(value[key])
if type(value['epoch']) is not int or value['epoch'] < 0:
raise ValueError('DOCUMENT_EPOCH')
if type(original) is not dict or set(original) != {'attempt_id', 'status', 'send_count'}:
raise ValueError('EXACT_ORIGINAL_FIELDS')
token(original['attempt_id']); token(read_id)
if read_id == original['attempt_id']:
raise ValueError('READ_NEEDS_NEW_ID')
if original['status'] not in ('failed', 'needs_review', 'cancelled'):
raise ValueError('EXPECTED_UNSETTLED_ATTEMPT')
if type(original['send_count']) is not int or original['send_count'] not in (0, 1):
raise ValueError('BOUNDED_SEND_COUNT')
binding(before); binding(after)
if stored is not None:
binding(stored)
if type(proof) is not dict or set(proof) != {'checked', 'matches', 'target_count', 'native_settled'}:
raise ValueError('EXACT_PROOF_FIELDS')
if any(type(proof[k]) is not bool for k in ['checked', 'matches', 'native_settled']):
raise ValueError('BOOLEAN_PROOF')
if type(proof['target_count']) is not int or not 0 <= proof['target_count'] <= 64:
raise ValueError('TARGET_COUNT')
reason = ('legacy_binding_missing' if stored is None else
'before_binding_changed' if before != stored else
'after_binding_changed' if after != stored else
'native_input_unsettled' if not proof['native_settled'] else
'target_not_unique' if proof['target_count'] != 1 else
'read_not_proven' if not (proof['checked'] and proof['matches']) else
'declared_read_matches')
checkpoint = ({'id': read_id, 'original_attempt_id': original['attempt_id'],
'kind': 'read_only_evidence', 'status': 'declared_match'}
if reason == 'declared_read_matches' else None)
return deepcopy({'original': original, 'new_checkpoint': checkpoint, 'reason': reason,
'performs_read_or_send': False, 'releases_runtime_guard': False,
'authenticates_context': False, 'persistent_receipt_written': False})
Preserve the links rather than only the final conclusion
I connect initial failure, causal hypothesis, actual fix, independent test, later observation and remaining scope. The public account needs no original manuscript or identifying file. It can still explain which evidence changed a claim at which stage.
This article reviews that lineage without editing the original needs_review state or sending another generation request. The synthetic failure lab cannot modify operational records either. Retaining what failed and what was deliberately not repeated turns an improved result into reusable production knowledge. A final success sentence alone cannot preserve that material or guide the next operator through an uncertain delivery.