Files
Neutron/docs/evidence/checkpoint-session.md

170 lines
13 KiB
Markdown
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# 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](windows-session.md) and
[Linux capture instructions](linux-session.md) 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.
1. Recheck immutable materials immediately before local transfer:
`python3 tools/recon/fidelity_acceptance.py ready --checkpoint dist/fidelity/phase01`.
Require `materials_ready: true`, separately `acceptance: human_needed`. A changed
package/resource requires a fresh identified checkpoint. Preserve the old bundle.
2. 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.
3. 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.
4. 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.
5. Complete Linux real-display, physical-input and actual audible-device checks.
The saved `linux-01-06-matrix-preflight-linux` failure explains the current TTY/
auto_null limitation; it proves no captured gameplay. Retain failed/aborted/
skipped results and use fresh launch IDs for retries.
6. 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.
7. Record the following named human findings with reviewer and concrete notes:
`A1` original moving imagery/intelligible audio/DxWnd limits; `A2` actual browser
decode/seek/exclusive audio; `EVID-02-unclassified` original capture boundaries;
`EVID-04-unclassified` native route/input/audio/identity; `P1` preservation;
`P2` honest unretimed/unmixed/non-synthetic comparison; `P3` history/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.
8. 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 in `identity.copy_pre`, `identity.copy_post`, `identity.retained_copy`. For both lifetimes bind `copy_pre_sha256` to the named pre record; retained runs also bind `retained_copy_sha256` to the named retained snapshot. Native reviewed runs use the same explicit state-record contract |
| 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):
```json
{
"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):
```sh
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.