Dated source reference. Current release status: handoff state. Full original relative paths are in the developer archive.

External game flow completion — accepted development50

Current extension: Match controls51 completes the three planned additions: game-clock rotation intent with native entry observations, original native timeout calls and connected-input/team assignment.510 Windows API tests/84 schemas and focused live52w/52za/52x pass; multi-controller physical input remains unverified because no gamepads are available. This closes the planned match-control implementation, with that hardware verification outstanding. Presentation, broad modding/rule semantics and public packaging remain separate. The earlier evidence/version paragraphs below remain their recorded checkpoints; consult the new ledger for current implementation and exact limits.

October18,2026 UTC. Current private API0.2.0.dev50/HTTPv1/snapshotABI25 is accepted through the public SDK and isolated Windows game. Runtime source51u/187 inputs, production DLL4f897924002508d689ebb18915f7d2eb0cd49517ad086aba1fb8703eca216f47; final documentation source51za retains all179 non-Markdown inputs, including63 native inputs, unchanged. Prior coaching49 evidence remains preserved. Public preview2/API36, editor dev7 and stable35 are separate.

Work in this scope:

• Native substitution request/cancel with explicit player ownership, fresh preimages and observed completion separate from queue acceptance.
• Optional per-opponent defensive configuration supplied by an app before the native match is revealed.
• Public-SDK result persistence/acknowledgment and owned finished-session closure, including clear cancellation/recovery outcomes.
• One focused end-to-end acceptance through the public API, then exact save/process/task preservation and current documentation.

Keep third-party architecture, original corpus/stable35/95 saves/98 isolated baseline/public ZIPs/hosting protected. Builds, tests and game execution stay on Dell; no shared desktop input while MVP is active. Historical cache links remain immutable. No new public package, GUI, presentation/artwork task or rare-rule certification is required. Native pending queues do not establish legal live/dead-ball state. Queue helpers6C0EF0/6C0F40 and user-request flag6C0FA0 have static evidence; original eligibility and pending queue instructions are now covered; native entry/result acceptance is recorded below. Research is in analysis/external-flow51.

Accepted evidence

Philadelphia wins5–4 naturally after two60-second college halves. At a native foul/free-throw stoppage with45.8941seconds left in half1, Michael Carter-Williams replaces Spencer Hawes and John Henson replaces Luke Ridnour: native positions, incoming on-court and outgoing off-court flags all agree. Later natural play retains the substituted positions. This is observed entry through original native handling, not a general legal live/dead-ball declaration or an exact-minute schedule.

The final reconciled23-player result is committed to the app inbox before ACK. Independent dynasty/scoreboard consumers receive identical content; repeated ACK/local restart-compatible storage remain idempotent. finish_owned closes only the matching run/match after result delivery; the broker remains independently available until its owner closes it. The bounded research watcher then closes that broker. Both51k/51w close and restore all98 baseline files. Final preservation records21,305,008,128bytes free. Failed51k remains a failed substitution run even though its independent result path passed.

No GUI, public release, presentation/artwork task or additional rare-rule certification was added. Exact rotation schedules, direct timeout calls, physical-device/multiple-human certification, native extra-field presentation, legal ball state/universal event meanings, arbitrary rule callbacks and safe asset hot-swap remain separate. Builds/API/native tests and games ran on Dell; Mac work stayed editing/storage/SSH, with no shared desktop input or MVP modification.

Client integration

The new contract is private API0.2.0.dev50/HTTPv1 and snapshotABI25 (68,680 bytes). EventABI4, collegeprofile4 and courtdefinition3 stay unchanged. Public preview2 still contains36/ABI14; the source APIs below require deliberately staging the current adapter and broker together.

launch_configuration.settings.defense in a version1 match request accepts defending home/away banks. Each opponent key belongs to the opposite team and an instantiated slot0–11; values use the same six fields/catalog as live defense.set. For example:

{"defense":{"home":{"away:0":{"on_ball_pressure":3,"hedge":2,"preferred_defender":"home:4"}},"away":{"home:0":{"preferred_defender":null}}}}

null selects automatic preferred defender; explicit defenders must be on the court at startup. These are stored defensive settings, not proof of physical guarding. All requested native setters and the complete batch read back before the loading cover reveals the match. Missing/invalid native state or failed readback keeps the cover in place with an explicit startup failure. The batch limit is426:282 prior values plus up to144 defensive values. Actual instantiated rosters can expose fewer than12 opponents.

For substitutions, read snapshot.substitutions and /v1/settings capability/catalog first. Acquire the normal control lease and use simulation.pause, allowing at least750ms of frozen simulation before a queue edit. Commands require paused, unfinished phase10 outside replay, matching run/period/revision and the observed pending preimage. Both teams are supported. Choose a current positions[].player_key as outgoing and a distinct own-team eligible_bench_player_keys entry as incoming. Do not infer legal live/dead ball from availability or presentation.

s = client.request('/v1/snapshot')
body = dict(type='substitution.queue', command_id=unique_id,
            client_id=app_id, lease_token=lease['lease_token'],
            run_id=s['run_id'], expected_period=s['raw_period'],
            expected_revision=s['substitutions']['revision'], side='home',
            outgoing_player_key='home:0', incoming_player_key='home:5',
            expected_pending_player_key=None)
receipt = client.request('/v1/commands', body)
request = client.request('/v1/substitutions/requests/' + unique_id)

Use unique durable command IDs; after a lost response inspect/retry the same ID rather than creating another request. An applied receipt has completed:false: the original native pending queue changed. Resume the owned pause to let the game process the request at its native opportunity. substitution.cancel uses the same guards and outgoing key, omits incoming_player_key, and supplies the current expected_pending_player_key. It cancels pending configuration, not an already completed entry.

GET /v1/substitutions/requests returns the latest100 observations; the individual-ID endpoint remains durable. The original command receipt never changes. substitution.request_changed events report pending, awaiting_entry, observed_in_lineup, cancelled, removed, superseded, ended_before_entry or context_changed. Only observed_in_lineup requires all three: the requested incoming player occupies the requested native position, is on court, and the outgoing player is off court. Removed/superseded queues remain under observation because a native transition can still follow. Context replacement and match end terminate unresolved tracking. This is bench-to-court request control, not an exact-minute rotation scheduler.

For completion, openhoops_api.game_flow.ResultInbox is a portable independent-client helper. It commits an immutable (consumer,match_id,revision) result to SQLite with full synchronization before sending ACK. A lost ACK response can recover from the committed copy; independent consumers keep separate receipts. Store the result into the app's own league transaction as appropriate rather than adding repeated totals.

from openhoops_api.game_flow import ResultInbox
with ResultInbox('my-app-results.sqlite3') as inbox:
    delivery = inbox.finish_owned(client, match_id, app_id, consumer_id)
    final_result = delivery['result']

receive only persists/acknowledges. finish_owned additionally requests finished-session closure after confirming the final result matches the broker-owned run and match. The stop helper checks those identities again; the server guards the command identities. An unrelated game is never selected for closure. Abandoned/review-required matches return explicit attention states without fabricated results. Timeouts send no ACK or stop. There is no requirement to use this helper or any first-party database/UI; all operations use documented public HTTP endpoints. finish_match.py exposes the same flow as a small terminal example.

Implementation and validation history — capture-time status

Production native51c compiles with MSVC19.51 /W4 /WX; DLL74421808675784d87d08ab9ab29d6d23cc3629a01f1ab2afc920cbbc0d8361a0. Source51j archive1f4df124cde50f1d572c42fca69b7d4031e8565ac3f8e9884f919e7e99aa6a87/187 inputs adds the portable inbox and schemas with every native input identical to51c.492 exact-source Windows API tests,76 schemas/48 positive-negative checks and unchanged historical result validation pass. Compiled instruction checks pass the prior1,104 cases plus93 new cases:70 queue/cancel pairs,22 refusals and a complete144-value startup-defense batch/readback. The exact DLL also passes27 prior pause/dispatch cases (51m). Synthetic instruction execution does not prove native stoppage processing, worker races or SEH failure handling.

Harness51e was stopped by exact executable/creation-time/command identity after an inefficient per-instruction symbol lookup consumed CPU.51f then exposed a missing simulation-active fixture flag;51g exhausted the conservative emulation instruction limit on the full144-entry batch.51h caches the symbol, supplies the correct native fixture state and permits the complete bounded batch. These are preserved harness failures, not accepted live gameplay evidence. Live51k remains pending.

Live51k startup verifies all156 requested values before reveal (18 coaching plus138 defensive fields across23 instantiated players), phase4 external IDs and natural college1-minute play with zero input/errors. Both teams' queue/cancel/readback and immutable duplicate receipts pass. The retained final queue on each side is cleared at halftime without an observed lineup entry. This is a failed substitution-completion acceptance; it is not promoted as working substitutions. The observer correctly reports removal instead of completed entry. Consumer/activation research51p–51r follows the original commit and pending-consumer paths. Final-result/inbox acceptance and closure are still pending.

Closed51k diagnostic51s inspects disposable SQLite copies and preserves all original DB/WAL/SHM hashes. It corrects the early halftime diagnosis: both retained requests disappear at source1366, immediately before the first foul transition10→18 at12.8759seconds in half1. Native9ABFB0's automatic lineup builder clears/replaces pending queues; the normal manual request flag does not prevent that calculation on this CPU fixture. Result handling independently passes: natural Milwaukee4–Philadelphia2, reconciled result committed before ACK, independent consumer/repeated ACK/immutable content, matching-owned finished stop and zero generated input/errors. Whole substitution acceptance remains failed. The run closes at11:08:00UTC and restores all98 baseline files;64 current files are archived independently from live saves. Stable/public assets remain protected.

Candidate51u archivea7cbf6e344690e55fa01de748d0e41ca2ba6f087c534b76842e37dfec9ab8680/187 inputs compiles non-probe DLL4f897924002508d689ebb18915f7d2eb0cd49517ad086aba1fb8703eca216f47. It skips that automatic builder only while an API-owned exact pending/outgoing node, native user-request flag, eligibility and original period still match. The original stoppage/entrance processor is unchanged; no physical lineup or legal ball-state flag is forced. Missing/changed/ineligible/cancelled context returns native passthrough. The thunk preserves flags/GPR/x87-control/SSE/stack and replays the complete original prologue. Availability2/PE substitution version2 reject the earlier queue-only prototype. The broker also waits for its first observed pending snapshot before interpreting absence as removal, avoiding a transient stale-publication false removal after the command receipt.

493 exact-source Windows API tests,76 schemas/48 fixtures,1,104 prior native cases,111 new substitution/ownership/startup cases and27 pause/dispatch cases pass.51v's first runner could not import sibling scripts because embedded Python excludes the script directory;51x supplies the explicit path without changing product code or expectations. Corrected live51w is in progress; successful native entry is not yet claimed.

Final51w supersedes the capture-time pending statements above. Closed/restored receipts and restoration preserve exact process identities and save hashes. Final documentation manifest distinguishes prose cleanup from the unchanged tested runtime.

Final documentation source51za SHA-256: 3300c47bfd4d022d0a4acc487eb050b89d5d2c620fb1d549a8a8f7cb065da78b. Final source/runtime acceptance verifies187 frozen inputs and all179 unchanged runtime inputs against51u, plus the exact production DLL and recorded passing live/test receipts.