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

13 KiB
Raw Blame History

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.

  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):

{
  "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.