12 KiB
Phase 01 combined acceptance session
Materials preparation is separate from acceptance. The final local checkpoint is
dist/fidelity/phase01; all 120 obligations remain OPEN until actual captures and
human review. This document prepares the single combined session; it does not
report that any physical, audible, Windows or original fact has been observed.
Read Windows/DxWnd instructions and
Linux capture instructions together. They contain the exact
collector commands, settings, annotation fields and complete procedures. The
sealed packages retain source 446930d2a30d6d616c60ac5e59e4169a840bea09, dirty true,
diff 90cef95669caece53fe2d2c4736cf2ac05ed27f5d25ca03ab572589686bcb73d.
The later tools/checklist revision never replaces that runtime provenance.
- Recheck immutable materials immediately before local transfer:
python3 tools/recon/fidelity_acceptance.py ready --checkpoint dist/fidelity/phase01. Requirematerials_ready: true, separatelyacceptance: human_needed. A changed package/resource requires a fresh identified checkpoint. Preserve the old bundle. - On the actual Windows PC select already installed DxWnd, its original exported profile, recorder, browser and media tools. Record versions, executable hashes, Windows/GPU/driver identities and actual settings. Run the bundled PowerShell preflight and selftests; save their complete positive counts and failures.
- Use only generated original copies. Retain pristine/pre/retained/post inventories, original and relocated DxWnd profiles, wrapper limitations and the actual child launch method. Observe moving game imagery, intelligible game audio, crop and aspect before recording scenarios. Black/silent captures remain failed evidence.
- Follow
protocol/agenda.json: eight fresh/retained × natural/skipped × ordinary/ held-input cells, each with continuous, dialogue-return, bank-left, bank-right, landing-idle obligations on original-DxWnd and native Windows (80). Follow the same 40 obligations on native Linux. Retained departure/return must remain in one process/clock. Continuous is lab → VR04 → lab → outside. No fixture, warp, Wine, cross-publish, injected input or second fresh launch fills these slots. - Complete Linux real-display, physical-input and actual audible-device checks.
The saved
linux-01-06-matrix-preflight-linuxfailure explains the current TTY/ auto_null limitation; it proves no captured gameplay. Retain failed/aborted/ skipped results and use fresh launch IDs for retries. - Review actual paired recordings in the identified local browser, including decode/playback, seeking, complete tails, exclusive audio, corresponding events, raw elapsed/event drift, actual speed and optional overlays. Keep source MKV, derivation tool/hash/argv/time mapping and visible review gain. Do not invent timing/pixel/angle/audio thresholds or hide drift through retiming.
- Record the following named human findings with reviewer and concrete notes:
A1original moving imagery/intelligible audio/DxWnd limits;A2actual browser decode/seek/exclusive audio;EVID-02-unclassifiedoriginal capture boundaries;EVID-04-unclassifiednative route/input/audio/identity;P1preservation;P2honest unretimed/unmixed/non-synthetic comparison;P3history/full-scope/ native transparency;browser;paired_review;physical_input. A1/A2 are separate from the two flagged assumptions. Insufficient observation remains human_needed; descriptor-less P1/P2/P3 cannot be automatically dismissed. - Return the complete tree once by local filesystem/USB/existing local share. Compare mutable result/original-run inventories with the source transfer inventory, recheck READY/manifest and every linked hash before atomic import. Keep packages, original copies and media local and ignored.
Result reconciliation contract — integration agent only
The human tester collects, observes and returns the tree. The integration agent performs the following local reconciliation after return; the tester is never asked to engineer JSON or run the Python tooling. No normalized gameplay receipt exists yet. Do not run reconciliation on failed/skipped/aborted/incomplete runs as if they were successful; import those unchanged as diagnostic history.
Keep raw collector receipts immutable. Use the existing receipt importer on a
fresh local result destination; it validates hashes/containment and rejects
conflicting duplicates. Reviewed acceptance receipts are separately authored
records retaining the raw collector identity, actual media/events and limitations;
they must satisfy the shared receipt schema, source/package/resource binding and
full scenario continuity. Raw collection success never becomes review success.
Windows source/package/resources initially identify the exact fidelity-build.json
seal. Original reviewed receipts additionally identify the unchanged original
inventory and actual generated-copy pre/post inventories; missing raw collector
fields require evidence-backed normalization, never invented values.
Work on a fresh sibling derived directory for each captured raw receipt. Copy
every raw referenced file byte-identically into that directory, copy the raw
receipt.json as raw-receipt.json, and preserve raw-receipt.sha256. Make the
reviewed receipt a new ID ending -reviewed; retain the original launch/session
and clock IDs. Add the hashed raw receipt to artifacts with role diagnostic.
The integration agent uses this exact mapping; every new path is inside that fresh
derived directory and every identity uses identify_file(actual_path) including
SHA-256, size and header. No path or command from returned metadata is executed.
| Reviewed field | Actual source and required validation |
|---|---|
| Native executable | Raw identity copy; match manifest package executable SHA-256 |
| Native package | Exact selected RID's copied fidelity-build.json; match sealed package SHA-256 |
| Windows native source/resources | Same actual fidelity-build.json file; retain its source commit/dirty/diff fields. Resources are proven by exact full seal equality |
| Linux native source | Raw identity/BUILD-INFO.txt, with commit/dirty/diff taken from the matching exact package seal |
| Linux native resources | Raw identity/resources.json, exactly equal to manifest package resources |
| Original executable | Actual selected executable from the generated run (Neutron.exe or the recorded selected variant); retain its exact pristine relative path in identity.executable.original_member and compare size/header/hash to that member, retaining any mismatch as open |
| Original package/resources | Both identify hashed identify_tree(original-pristine) inventories whose complete file records and recomputed digest equal the checkpoint baseline. Generated-copy pre/post inventories remain separate; preserve all raw original content identities |
| Original pre/post | Save complete actual identify_tree(original-pristine) before/after return validation; require files and tree digest equal to the baseline and manifest original_pre. These describe authoritative/pristine preservation, separately from writable copy changes |
| Original copy pre/post/retained | Raw copy-pre.json, copy-post.json, retained-copy.json; preserve exact actual bytes/hashes and bind continuity to those hashes |
| Original source/launcher | Save manifest tool_source as collector-source.json and identify the actual bundled Windows collector; source commit/dirty/diff describes collector tooling, never recovered original source code |
| Original DxWnd/profile | Retain hashed actual dxwnd-tool.json, source profile and relocated export; explicit wrapper settings/limits are required |
| Platform/version/GPU/driver/Vulkan/SDL | Actual raw queries and human device/version records; absent observations remain missing, never guessed |
| Events/continuity/derivatives | Preserve actual raw values and hashed media; supplement only from observed annotations with methods/uncertainty; never generate invented markers |
| Review | Set visible/audible/ordinary_input/human_reviewed true only from the named, receipt-bound actual reviewer findings |
For example a Windows native raw receipt port-fresh-natural-ordinary-continuous-01
already identifies identity/build.json as source/package/resources. Its reviewed
identity retains that same file/hash, keeps source commit/dirty/diff from its
contents, and binds executable to manifest packages.win-x64.executable. It does
not substitute BUILD-INFO for that raw source or regenerate a package seal.
The reviewed record's minimal projection looks like this (metavariables below
are populated from the actual retained records by the integration agent):
{
"receipt_id": "port-fresh-natural-ordinary-continuous-01-reviewed",
"session_id": "port-fresh-natural-ordinary-continuous-01",
"status": "reviewed",
"identity": {
"source": {"path":"identity/build.json", "sha256":"ACTUAL_SEAL_HASH", "size":0,
"header":"ACTUAL_HEADER", "commit":"ACTUAL_BUILD_COMMIT", "dirty":true,
"diff_sha256":"ACTUAL_BUILD_DIFF"}
},
"review": {"visible":true,"audible":true,"ordinary_input":true,"human_reviewed":true},
"acceptance": {"state":"accepted","remaining":[]}
}
This projection is not a usable receipt or positive finding: retain all other
required raw fields, replace every metavariable/size with identified actual values,
keep limitations/discrepancies, and include missing identity mappings above.
Clear missing_evidence and acceptance remaining only when each corresponding
fact has actually been supplied and reviewed. Otherwise preserve the gap and
state: open. The shared validator and strict audit reject incomplete reviewed
records. Do not overwrite raw receipts or label normalized copies as raw captures.
After writing the complete derived receipt, the agent validates/imports with the existing API (run from repository root; substitute the actual derived directory):
PYTHONPATH=tools/recon python3 -c 'from pathlib import Path; from fidelity_receipts import read_receipt,validate_receipt,import_receipt; p=Path("LOCAL_DERIVED/receipt.json"); print(validate_receipt(read_receipt(p),p.parent)); print(import_receipt(p,p.parent,Path("dist/fidelity/phase01/results/imported")))'
An absent mapping or unobserved human fact is an OPEN result. Never manufacture source, original, device, media or review identities to make this command pass.
In results/current.json, list the explicit current receipt paths as
{"receipts":["imported/receipt-id/receipt.json"]}. Preserve historical/superseded
records outside that selection. Conflicting duplicate slots cannot be selected.
In results/human-review.json, use schema_version: 1, exact selected
receipt_ids, a receipt_sha256 object mapping each ID to its actual receipt hash,
and checks mapping every name above to { "observed": true, "reviewer": "actual reviewer", "notes": "specific observation and limitations" }. Empty or
false findings remain pending. These fields describe witnessed facts; tools never
generate positive human findings.
Run strict audit on the complete local result tree:
python3 tools/recon/fidelity_acceptance.py audit --checkpoint dist/fidelity/phase01 --results dist/fidelity/phase01/results --require-complete.
Nonzero means acceptance remains open. --allow-open may return zero for structural
inspection while explicitly reporting human_needed and every missing obligation;
it never satisfies EVID-02/EVID-04. Export actual paired selected receipts with the
existing fidelity_review.py export command; the prepared viewer starts empty.
Pending acceptance checklist
- Original-DxWnd 40 obligations, actual imagery/audio/input and wrapper review.
- Native Windows 40 obligations, physical input/audio and exact runtime identity.
- Native Linux 40 obligations, real display/audio and physical input.
- Actual paired browser playback, seeking, exclusive audio and exposed drift.
- Both unclassified assumptions, A1/A2 backstops and P1/P2/P3 dispositions.
- Returned identities and strict audit passed; current/history discrepancies reconciled.
Phase 1 and all EVID requirements remain pending. The roadmap permits independent source-backed recovery while these access dependencies remain open; it does not waive them or authorize broader gameplay admission.