Files

119 lines
6.3 KiB
Markdown

# Owned playtest call context
> Technical evidence extract for the VCC Plus white paper. Only reviewed contracts, mechanisms, methods, results and limitations are retained. Original validation dates and configuration limits remain historical; this export is not a new test run.
## Access and timing
The tool requires toolset 10 or newer and explicit boolean `playtest` and
`playtestCallContext` fields in the private grant. BASIC, assembly, legacy grants
and ordinary shared runs do not gain access. Native export records the current
consent; editing client-side grant fields cannot enlarge the app's permission.
The consent explains the bounded stack inspection.
First pause at a verified stop in an owned disposable guest, then obtain its
immutable snapshot:
```json
{"name":"get_debug_snapshot","arguments":{"run_id":"<owned run>"}}
```
Use the returned IDs without adding an address, length or expression:
```json
{"name":"get_call_context","arguments":{"run_id":"<owned run>","snapshot_id":"<snapshot>"}}
```
The app checks the connection, project, revision, artifact and owned worker.
It captures the worker without advancing it and requires the same boot, field
clock, frame, cycles, generation, processor/mode/MD, registers, mapping,
program revision, complete memory and availability mask. A step, resume, restart,
new snapshot, disk exchange, rebuild, source change or revocation invalidates old context.
Request-budget bookkeeping is not guest state and does not invalidate a read.
Repeated reads of an unchanged snapshot return the same context.
## Bounded raw view
`status: "available"` supplies `stack_window` with exactly 64 bytes starting at
actual register **S**. It includes byte values, big-endian `words_be` with offsets
and addresses, and the physical RAM spans backing the logical window. Every
byte must be available RAM. ROM, unavailable pages, protected high memory,
wrapping ranges and unverified program locations fail closed.
`interpretation: "uninterpreted"` is deliberate: words can be saved registers,
locals, padding or arguments. Do not call an arbitrary stack word a return
address or a C value. The caller cannot choose another address, increase the
window, dereference a pointer, evaluate a guest expression or modify state.
This tool does not add stack ranges to `read_debug_memory`, whose existing
advertised ranges remain unchanged.
## Evidence-gated interpretations
`caller` and `arguments` have their own availability status, independent of the
raw view. A verified source location alone does not prove a call frame.
Caller interpretation requires compiler function metadata and verified normal
CMOC preserved-U prologue/epilogue bytes. At exact entry it uses the two bytes at
S; in a mapped body it uses U+2 only when the complete saved-frame/return slot is
inside the same 64-byte window. The return value must match one unique verified
direct call instruction targeting this callee, in approved caller source and
verified live code. There is no scan for plausible return addresses, speculative
unwinding, indirect-call guess or interrupt/tail-call assumption.
Integer argument values require compiler-provided positive frame offsets and
full-function scope, that normal ABI proof and a verified direct caller. Only
nonoverlapping, named integer locations wholly inside the same window are
interpreted. Unsupported types, pointers/aggregates, unknown or optimized frames,
missing metadata, ambiguous callers and locations outside the window stay
unavailable. No pointed-to storage is read.
`recorded_parameter_count` counts eligible compiler location records;
`all_recorded_parameters_available` states whether all those records were
interpreted. It does not prove that metadata contains the function's complete
prototype or all runtime arguments. Each interpreted item carries its location,
byte count and evidence label.
For an optimized/source-only entry, the raw view can still help an assistant
compare the stop with the project's own assembly emitted through its approved
Make diagnostic and `get_build_log`. Such analysis must distinguish observations
from inferred ABI meaning; the app does not manufacture typed arguments.
## Qualification
Focused authored helper tests cover safe bounds, RAM/bank identity, proven entry
and body cases, unsupported frames, ambiguous calls, stale metadata and types.
The public-helper harness checks fresh/legacy/forged grant discovery and dispatch,
strict two-ID arguments and unavailable results. Real worker and authenticated
host-boundary checks are recorded below. Private ROMs/toolchain and temporary
results remain outside Git; missing inputs are explicit skips.
### Executed checks — November 12, 2026
- Ten authored helper tests passed on arm64 and x86_64: bounds, unavailable RAM,
bank/source identity, entry and body interpretation, signed integer widths,
unsupported frames/types, ambiguous callers, stale metadata and overlaps.
- Five debugger inspection tests passed on both architectures, including the
semantic fingerprint regression and existing BASIC, assembly and C inspection.
- The real authenticated native C-grant test passed on both architectures. A
compiled seven-argument fixture exercised build, owned startup, snapshot and
context requests over the actual local transport. Wrong run/snapshot IDs,
extra address arguments, stepping/rebuild staleness, revocation and unapproved
or forged client grants were rejected. A non-owned run ID was rejected; this
test did not launch a separate ordinary shared run.
- A real 512 KB worker fixture passed on MC6809, HD6309 emulation mode and HD6309
native mode on both host architectures. Ordinary guest instructions created
the call/arguments. Repeated inspection preserved the complete captured guest
state; inspected and uninspected twins subsequently produced identical,
nonconstant guest PCM. Return, restart and retained-disk bytes also matched.
No host memory/register injection was used to create the call or its values.
- The public helper's complete protocol harness passed with both arm64 and
x86_64 helpers, including 23 fresh/legacy/malformed/forged grant variants,
strict two-ID schema validation and unavailable-result forwarding.
The x86_64 test bundle and worker were verified as thin Intel binaries and ran
through Rosetta on Apple Silicon. This is not physical Intel or macOS 14
qualification.