An unfinished job. A different context.

The receipt that
counted twice.

One real defect reproduction. One frozen midpoint. One separate AI continuation that had to finish the job from files—not this conversation.

Public projection, not the private execution archive. Historical records below are explicitly redacted derivatives. Machine paths, private identifiers, and coordination records are withheld. No new AI continuation was run for publication. The original handoff, contract, fixtures, provenance, and utility remain intact; the public integrity manifest binds this edition's current bytes.

Midpoint / failing4 events counted

Four records, but only three unique IDs.

Continuation / repaired3 unique events

The identical replay adds no work.

Useful output1 open maintenance item

A local queue the Pocket Arcade can consume.

Evidence you can follow

Replay the preserved case

The seed explicitly names ll-duplicate: repeated identical event IDs count twice. These new fictional Arcade receipts reproduce that behavior in original code. The replay below plays back recorded Python execution frames preserved in redacted historical records; it does not run Python in your browser. The included original source snapshots independently reproduce those numerical frames.

Acceptance case

JavaScript loads only local recorded data. The final observed result is 4 → 3 events.

Original SYNTHETIC input records, in arrival order
#	Event ID	Item / action	Minute	Record kind

Frozen midpointPre-fix capture

4 events counted

FAIL · expected 3 unique events

Separate continuationObserved repair

3 unique events

PASS · unchanged acceptance target

Inspect this recorded frame and its input hash

See evidence/before.json and evidence/after.json for the complete execution records.

The clean and ordering cases already passed at the midpoint. Only the specified duplicate-counting defect was unfinished. Historical failing acceptance output · Historical coordinator recheck · New public-projection checks

Actual execution chain

What crossed the boundary?

A / FIRST CONTEXT

Freeze, don't finish

A bounded utility, three fixtures, strict acceptance, 16 tests, input hashes, exact failing output, decisions, and the next action were committed while the duplicate case still failed.

Open the sealed midpoint handoff

B / SEPARATE CONTEXT

Recover and repair

One authorized separate Astra continuation recovered the work from project artifacts. It reproduced the failure, made the actual fix, added three regressions, and committed its result. Its private invocation metadata is withheld.

Read the derived recovery summary

C / COORDINATOR

Integrate and verify

The real child commit was fast-forwarded intact. The coordinator reran acceptance and all 19 tests, verified the sealed files, and built this evidence playback without modifying the repair.

Inspect the packaged result

Recovered from the artifacts

The exact fixture, acceptance target, and next command.
Which behavior already passed and had to remain intact.
The difference between raw records and unique work.
Conflict rejection, bounds, no-mutation rules, and scope.
Who owned the next step—not invented release authority.

Missing at the original handoff

The earlier conversation and undocumented reasoning.
A real-world dataset or human review.
The original downloaded archive in the second context.
At that time: browser validation, upstream acceptance, and publication permission.
Any guarantee that a different handoff would also succeed.

What can be reverified publicly? The original midpoint source, one-line fix, unchanged targets, numerical replay, and maintenance output can be checked from this snapshot. The historical executor identity and invocation cannot be independently reverified here because private records are withheld. The original executor's no-earlier-chat account remains a historical self-report; provider isolation was not audited. This is not a new continuation or an independent human review.

Something useful survives

The Pocket Arcade maintenance kit

Give the original Python CLI an explicitly selected synthetic JSONL file. It produces a stable per-item maintenance summary: raw input count, replay count, last event minute, open queue, and input SHA-256.

python3 -B projects/09-handoff/cli.py \
  projects/09-handoff/fixtures/duplicate.jsonl

The sample retains arcade-input as open, closes arcade-cache, and reports exactly one replay. The JSON is ready for an offline consumer; no other workstream was modified or integration fabricated.

History versus current bytes

Inspect the preserved repair

Historical private midpoint hash: 97dac1b6bdcfcfbae5ebdb43bbfdc0854335030e
Historical private fix hash: 849660c39cd53277f37ba3dddf8f7ccd553cf910
Original continuation: One separate Astra context; private identity withheld
Repeated-receipt input SHA-256: ca1f5c0591cfe5dc4c7b2d713f4efe4e58a6cf58270683d84f2bd4248048b040

Derived continuation history Redacted historical failing baseline Redacted historical passing capture Redacted historical coordinator recheck Historical input hashes Current public-byte manifest Original midpoint source snapshot Actual one-line repair diff Unchanged contract Inert seed provenance

Historical commit hashes are informational: their Git objects are not included in the fresh public repository. Checks use the included source snapshots, not hidden history. Public redacted records have new hashes and are not byte-identical private transcripts. Hashes bind bytes, not signatures or executor identities.